scsi_transport_iscsi.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * iSCSI transport class definitions
   4 *
   5 * Copyright (C) IBM Corporation, 2004
   6 * Copyright (C) Mike Christie, 2004 - 2005
   7 * Copyright (C) Dmitry Yusupov, 2004 - 2005
   8 * Copyright (C) Alex Aizman, 2004 - 2005
   9 */
  10#include <linux/module.h>
  11#include <linux/mutex.h>
  12#include <linux/slab.h>
  13#include <linux/bsg-lib.h>
  14#include <linux/idr.h>
  15#include <net/tcp.h>
  16#include <scsi/scsi.h>
  17#include <scsi/scsi_host.h>
  18#include <scsi/scsi_device.h>
  19#include <scsi/scsi_transport.h>
  20#include <scsi/scsi_transport_iscsi.h>
  21#include <scsi/iscsi_if.h>
  22#include <scsi/scsi_cmnd.h>
  23#include <scsi/scsi_bsg_iscsi.h>
  24
  25#define ISCSI_TRANSPORT_VERSION "2.0-870"
  26
  27#define ISCSI_SEND_MAX_ALLOWED  10
  28
  29#define CREATE_TRACE_POINTS
  30#include <trace/events/iscsi.h>
  31
  32/*
  33 * Export tracepoint symbols to be used by other modules.
  34 */
  35EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_conn);
  36EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_eh);
  37EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_session);
  38EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_tcp);
  39EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_sw_tcp);
  40
  41static int dbg_session;
  42module_param_named(debug_session, dbg_session, int,
  43		   S_IRUGO | S_IWUSR);
  44MODULE_PARM_DESC(debug_session,
  45		 "Turn on debugging for sessions in scsi_transport_iscsi "
  46		 "module. Set to 1 to turn on, and zero to turn off. Default "
  47		 "is off.");
  48
  49static int dbg_conn;
  50module_param_named(debug_conn, dbg_conn, int,
  51		   S_IRUGO | S_IWUSR);
  52MODULE_PARM_DESC(debug_conn,
  53		 "Turn on debugging for connections in scsi_transport_iscsi "
  54		 "module. Set to 1 to turn on, and zero to turn off. Default "
  55		 "is off.");
  56
  57#define ISCSI_DBG_TRANS_SESSION(_session, dbg_fmt, arg...)		\
  58	do {								\
  59		if (dbg_session)					\
  60			iscsi_cls_session_printk(KERN_INFO, _session,	\
  61						 "%s: " dbg_fmt,	\
  62						 __func__, ##arg);	\
  63		iscsi_dbg_trace(trace_iscsi_dbg_trans_session,		\
  64				&(_session)->dev,			\
  65				"%s " dbg_fmt, __func__, ##arg);	\
  66	} while (0);
  67
  68#define ISCSI_DBG_TRANS_CONN(_conn, dbg_fmt, arg...)			\
  69	do {								\
  70		if (dbg_conn)						\
  71			iscsi_cls_conn_printk(KERN_INFO, _conn,		\
  72					      "%s: " dbg_fmt,		\
  73					      __func__, ##arg);		\
  74		iscsi_dbg_trace(trace_iscsi_dbg_trans_conn,		\
  75				&(_conn)->dev,				\
  76				"%s " dbg_fmt, __func__, ##arg);	\
  77	} while (0);
  78
  79struct iscsi_internal {
  80	struct scsi_transport_template t;
  81	struct iscsi_transport *iscsi_transport;
  82	struct list_head list;
  83	struct device dev;
  84
  85	struct transport_container conn_cont;
  86	struct transport_container session_cont;
  87};
  88
  89static DEFINE_IDR(iscsi_ep_idr);
  90static DEFINE_MUTEX(iscsi_ep_idr_mutex);
  91
  92static atomic_t iscsi_session_nr; /* sysfs session id for next new session */
  93
  94static struct workqueue_struct *iscsi_conn_cleanup_workq;
  95
  96static DEFINE_IDA(iscsi_sess_ida);
  97/*
  98 * list of registered transports and lock that must
  99 * be held while accessing list. The iscsi_transport_lock must
 100 * be acquired after the rx_queue_mutex.
 101 */
 102static LIST_HEAD(iscsi_transports);
 103static DEFINE_SPINLOCK(iscsi_transport_lock);
 104
 105#define to_iscsi_internal(tmpl) \
 106	container_of(tmpl, struct iscsi_internal, t)
 107
 108#define dev_to_iscsi_internal(_dev) \
 109	container_of(_dev, struct iscsi_internal, dev)
 110
 111static void iscsi_transport_release(struct device *dev)
 112{
 113	struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
 114	kfree(priv);
 115}
 116
 117/*
 118 * iscsi_transport_class represents the iscsi_transports that are
 119 * registered.
 120 */
 121static struct class iscsi_transport_class = {
 122	.name = "iscsi_transport",
 123	.dev_release = iscsi_transport_release,
 124};
 125
 126static ssize_t
 127show_transport_handle(struct device *dev, struct device_attribute *attr,
 128		      char *buf)
 129{
 130	struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
 131
 132	if (!capable(CAP_SYS_ADMIN))
 133		return -EACCES;
 134	return sysfs_emit(buf, "%llu\n",
 135		  (unsigned long long)iscsi_handle(priv->iscsi_transport));
 136}
 137static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
 138
 139#define show_transport_attr(name, format)				\
 140static ssize_t								\
 141show_transport_##name(struct device *dev, 				\
 142		      struct device_attribute *attr,char *buf)		\
 143{									\
 144	struct iscsi_internal *priv = dev_to_iscsi_internal(dev);	\
 145	return sysfs_emit(buf, format"\n", priv->iscsi_transport->name);\
 146}									\
 147static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
 148
 149show_transport_attr(caps, "0x%x");
 150
 151static struct attribute *iscsi_transport_attrs[] = {
 152	&dev_attr_handle.attr,
 153	&dev_attr_caps.attr,
 154	NULL,
 155};
 156
 157static struct attribute_group iscsi_transport_group = {
 158	.attrs = iscsi_transport_attrs,
 159};
 160
 161/*
 162 * iSCSI endpoint attrs
 163 */
 164#define iscsi_dev_to_endpoint(_dev) \
 165	container_of(_dev, struct iscsi_endpoint, dev)
 166
 167#define ISCSI_ATTR(_prefix,_name,_mode,_show,_store)	\
 168struct device_attribute dev_attr_##_prefix##_##_name =	\
 169        __ATTR(_name,_mode,_show,_store)
 170
 171static void iscsi_endpoint_release(struct device *dev)
 172{
 173	struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
 174
 175	mutex_lock(&iscsi_ep_idr_mutex);
 176	idr_remove(&iscsi_ep_idr, ep->id);
 177	mutex_unlock(&iscsi_ep_idr_mutex);
 178
 179	kfree(ep);
 180}
 181
 182static struct class iscsi_endpoint_class = {
 183	.name = "iscsi_endpoint",
 184	.dev_release = iscsi_endpoint_release,
 185};
 186
 187static ssize_t
 188show_ep_handle(struct device *dev, struct device_attribute *attr, char *buf)
 189{
 190	struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
 191	return sysfs_emit(buf, "%d\n", ep->id);
 192}
 193static ISCSI_ATTR(ep, handle, S_IRUGO, show_ep_handle, NULL);
 194
 195static struct attribute *iscsi_endpoint_attrs[] = {
 196	&dev_attr_ep_handle.attr,
 197	NULL,
 198};
 199
 200static struct attribute_group iscsi_endpoint_group = {
 201	.attrs = iscsi_endpoint_attrs,
 202};
 203
 204struct iscsi_endpoint *
 205iscsi_create_endpoint(int dd_size)
 206{
 207	struct iscsi_endpoint *ep;
 208	int err, id;
 209
 210	ep = kzalloc(sizeof(*ep) + dd_size, GFP_KERNEL);
 211	if (!ep)
 212		return NULL;
 213
 214	mutex_lock(&iscsi_ep_idr_mutex);
 215
 216	/*
 217	 * First endpoint id should be 1 to comply with user space
 218	 * applications (iscsid).
 219	 */
 220	id = idr_alloc(&iscsi_ep_idr, ep, 1, -1, GFP_NOIO);
 221	if (id < 0) {
 222		mutex_unlock(&iscsi_ep_idr_mutex);
 223		printk(KERN_ERR "Could not allocate endpoint ID. Error %d.\n",
 224		       id);
 225		goto free_ep;
 226	}
 227	mutex_unlock(&iscsi_ep_idr_mutex);
 228
 229	ep->id = id;
 230	ep->dev.class = &iscsi_endpoint_class;
 231	dev_set_name(&ep->dev, "ep-%d", id);
 232	err = device_register(&ep->dev);
 233        if (err)
 234		goto put_dev;
 235
 236	err = sysfs_create_group(&ep->dev.kobj, &iscsi_endpoint_group);
 237	if (err)
 238		goto unregister_dev;
 239
 240	if (dd_size)
 241		ep->dd_data = &ep[1];
 242	return ep;
 243
 244unregister_dev:
 245	device_unregister(&ep->dev);
 246	return NULL;
 247
 248put_dev:
 249	mutex_lock(&iscsi_ep_idr_mutex);
 250	idr_remove(&iscsi_ep_idr, id);
 251	mutex_unlock(&iscsi_ep_idr_mutex);
 252	put_device(&ep->dev);
 253	return NULL;
 254free_ep:
 255	kfree(ep);
 256	return NULL;
 257}
 258EXPORT_SYMBOL_GPL(iscsi_create_endpoint);
 259
 260void iscsi_destroy_endpoint(struct iscsi_endpoint *ep)
 261{
 262	sysfs_remove_group(&ep->dev.kobj, &iscsi_endpoint_group);
 263	device_unregister(&ep->dev);
 264}
 265EXPORT_SYMBOL_GPL(iscsi_destroy_endpoint);
 266
 267void iscsi_put_endpoint(struct iscsi_endpoint *ep)
 268{
 269	put_device(&ep->dev);
 270}
 271EXPORT_SYMBOL_GPL(iscsi_put_endpoint);
 272
 273/**
 274 * iscsi_lookup_endpoint - get ep from handle
 275 * @handle: endpoint handle
 276 *
 277 * Caller must do a iscsi_put_endpoint.
 278 */
 279struct iscsi_endpoint *iscsi_lookup_endpoint(u64 handle)
 280{
 281	struct iscsi_endpoint *ep;
 282
 283	mutex_lock(&iscsi_ep_idr_mutex);
 284	ep = idr_find(&iscsi_ep_idr, handle);
 285	if (!ep)
 286		goto unlock;
 287
 288	get_device(&ep->dev);
 289unlock:
 290	mutex_unlock(&iscsi_ep_idr_mutex);
 291	return ep;
 292}
 293EXPORT_SYMBOL_GPL(iscsi_lookup_endpoint);
 294
 295/*
 296 * Interface to display network param to sysfs
 297 */
 298
 299static void iscsi_iface_release(struct device *dev)
 300{
 301	struct iscsi_iface *iface = iscsi_dev_to_iface(dev);
 302	struct device *parent = iface->dev.parent;
 303
 304	kfree(iface);
 305	put_device(parent);
 306}
 307
 308
 309static struct class iscsi_iface_class = {
 310	.name = "iscsi_iface",
 311	.dev_release = iscsi_iface_release,
 312};
 313
 314#define ISCSI_IFACE_ATTR(_prefix, _name, _mode, _show, _store)	\
 315struct device_attribute dev_attr_##_prefix##_##_name =		\
 316	__ATTR(_name, _mode, _show, _store)
 317
 318/* iface attrs show */
 319#define iscsi_iface_attr_show(type, name, param_type, param)		\
 320static ssize_t								\
 321show_##type##_##name(struct device *dev, struct device_attribute *attr,	\
 322		     char *buf)						\
 323{									\
 324	struct iscsi_iface *iface = iscsi_dev_to_iface(dev);		\
 325	struct iscsi_transport *t = iface->transport;			\
 326	return t->get_iface_param(iface, param_type, param, buf);	\
 327}									\
 328
 329#define iscsi_iface_net_attr(type, name, param)				\
 330	iscsi_iface_attr_show(type, name, ISCSI_NET_PARAM, param)	\
 331static ISCSI_IFACE_ATTR(type, name, S_IRUGO, show_##type##_##name, NULL);
 332
 333#define iscsi_iface_attr(type, name, param)				\
 334	iscsi_iface_attr_show(type, name, ISCSI_IFACE_PARAM, param)	\
 335static ISCSI_IFACE_ATTR(type, name, S_IRUGO, show_##type##_##name, NULL);
 336
 337/* generic read only ipv4 attribute */
 338iscsi_iface_net_attr(ipv4_iface, ipaddress, ISCSI_NET_PARAM_IPV4_ADDR);
 339iscsi_iface_net_attr(ipv4_iface, gateway, ISCSI_NET_PARAM_IPV4_GW);
 340iscsi_iface_net_attr(ipv4_iface, subnet, ISCSI_NET_PARAM_IPV4_SUBNET);
 341iscsi_iface_net_attr(ipv4_iface, bootproto, ISCSI_NET_PARAM_IPV4_BOOTPROTO);
 342iscsi_iface_net_attr(ipv4_iface, dhcp_dns_address_en,
 343		     ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN);
 344iscsi_iface_net_attr(ipv4_iface, dhcp_slp_da_info_en,
 345		     ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN);
 346iscsi_iface_net_attr(ipv4_iface, tos_en, ISCSI_NET_PARAM_IPV4_TOS_EN);
 347iscsi_iface_net_attr(ipv4_iface, tos, ISCSI_NET_PARAM_IPV4_TOS);
 348iscsi_iface_net_attr(ipv4_iface, grat_arp_en,
 349		     ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN);
 350iscsi_iface_net_attr(ipv4_iface, dhcp_alt_client_id_en,
 351		     ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN);
 352iscsi_iface_net_attr(ipv4_iface, dhcp_alt_client_id,
 353		     ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID);
 354iscsi_iface_net_attr(ipv4_iface, dhcp_req_vendor_id_en,
 355		     ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN);
 356iscsi_iface_net_attr(ipv4_iface, dhcp_use_vendor_id_en,
 357		     ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN);
 358iscsi_iface_net_attr(ipv4_iface, dhcp_vendor_id,
 359		     ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID);
 360iscsi_iface_net_attr(ipv4_iface, dhcp_learn_iqn_en,
 361		     ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN);
 362iscsi_iface_net_attr(ipv4_iface, fragment_disable,
 363		     ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE);
 364iscsi_iface_net_attr(ipv4_iface, incoming_forwarding_en,
 365		     ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN);
 366iscsi_iface_net_attr(ipv4_iface, ttl, ISCSI_NET_PARAM_IPV4_TTL);
 367
 368/* generic read only ipv6 attribute */
 369iscsi_iface_net_attr(ipv6_iface, ipaddress, ISCSI_NET_PARAM_IPV6_ADDR);
 370iscsi_iface_net_attr(ipv6_iface, link_local_addr,
 371		     ISCSI_NET_PARAM_IPV6_LINKLOCAL);
 372iscsi_iface_net_attr(ipv6_iface, router_addr, ISCSI_NET_PARAM_IPV6_ROUTER);
 373iscsi_iface_net_attr(ipv6_iface, ipaddr_autocfg,
 374		     ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG);
 375iscsi_iface_net_attr(ipv6_iface, link_local_autocfg,
 376		     ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG);
 377iscsi_iface_net_attr(ipv6_iface, link_local_state,
 378		     ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE);
 379iscsi_iface_net_attr(ipv6_iface, router_state,
 380		     ISCSI_NET_PARAM_IPV6_ROUTER_STATE);
 381iscsi_iface_net_attr(ipv6_iface, grat_neighbor_adv_en,
 382		     ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN);
 383iscsi_iface_net_attr(ipv6_iface, mld_en, ISCSI_NET_PARAM_IPV6_MLD_EN);
 384iscsi_iface_net_attr(ipv6_iface, flow_label, ISCSI_NET_PARAM_IPV6_FLOW_LABEL);
 385iscsi_iface_net_attr(ipv6_iface, traffic_class,
 386		     ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS);
 387iscsi_iface_net_attr(ipv6_iface, hop_limit, ISCSI_NET_PARAM_IPV6_HOP_LIMIT);
 388iscsi_iface_net_attr(ipv6_iface, nd_reachable_tmo,
 389		     ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO);
 390iscsi_iface_net_attr(ipv6_iface, nd_rexmit_time,
 391		     ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME);
 392iscsi_iface_net_attr(ipv6_iface, nd_stale_tmo,
 393		     ISCSI_NET_PARAM_IPV6_ND_STALE_TMO);
 394iscsi_iface_net_attr(ipv6_iface, dup_addr_detect_cnt,
 395		     ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT);
 396iscsi_iface_net_attr(ipv6_iface, router_adv_link_mtu,
 397		     ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU);
 398
 399/* common read only iface attribute */
 400iscsi_iface_net_attr(iface, enabled, ISCSI_NET_PARAM_IFACE_ENABLE);
 401iscsi_iface_net_attr(iface, vlan_id, ISCSI_NET_PARAM_VLAN_ID);
 402iscsi_iface_net_attr(iface, vlan_priority, ISCSI_NET_PARAM_VLAN_PRIORITY);
 403iscsi_iface_net_attr(iface, vlan_enabled, ISCSI_NET_PARAM_VLAN_ENABLED);
 404iscsi_iface_net_attr(iface, mtu, ISCSI_NET_PARAM_MTU);
 405iscsi_iface_net_attr(iface, port, ISCSI_NET_PARAM_PORT);
 406iscsi_iface_net_attr(iface, ipaddress_state, ISCSI_NET_PARAM_IPADDR_STATE);
 407iscsi_iface_net_attr(iface, delayed_ack_en, ISCSI_NET_PARAM_DELAYED_ACK_EN);
 408iscsi_iface_net_attr(iface, tcp_nagle_disable,
 409		     ISCSI_NET_PARAM_TCP_NAGLE_DISABLE);
 410iscsi_iface_net_attr(iface, tcp_wsf_disable, ISCSI_NET_PARAM_TCP_WSF_DISABLE);
 411iscsi_iface_net_attr(iface, tcp_wsf, ISCSI_NET_PARAM_TCP_WSF);
 412iscsi_iface_net_attr(iface, tcp_timer_scale, ISCSI_NET_PARAM_TCP_TIMER_SCALE);
 413iscsi_iface_net_attr(iface, tcp_timestamp_en, ISCSI_NET_PARAM_TCP_TIMESTAMP_EN);
 414iscsi_iface_net_attr(iface, cache_id, ISCSI_NET_PARAM_CACHE_ID);
 415iscsi_iface_net_attr(iface, redirect_en, ISCSI_NET_PARAM_REDIRECT_EN);
 416
 417/* common iscsi specific settings attributes */
 418iscsi_iface_attr(iface, def_taskmgmt_tmo, ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO);
 419iscsi_iface_attr(iface, header_digest, ISCSI_IFACE_PARAM_HDRDGST_EN);
 420iscsi_iface_attr(iface, data_digest, ISCSI_IFACE_PARAM_DATADGST_EN);
 421iscsi_iface_attr(iface, immediate_data, ISCSI_IFACE_PARAM_IMM_DATA_EN);
 422iscsi_iface_attr(iface, initial_r2t, ISCSI_IFACE_PARAM_INITIAL_R2T_EN);
 423iscsi_iface_attr(iface, data_seq_in_order,
 424		 ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN);
 425iscsi_iface_attr(iface, data_pdu_in_order, ISCSI_IFACE_PARAM_PDU_INORDER_EN);
 426iscsi_iface_attr(iface, erl, ISCSI_IFACE_PARAM_ERL);
 427iscsi_iface_attr(iface, max_recv_dlength, ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH);
 428iscsi_iface_attr(iface, first_burst_len, ISCSI_IFACE_PARAM_FIRST_BURST);
 429iscsi_iface_attr(iface, max_outstanding_r2t, ISCSI_IFACE_PARAM_MAX_R2T);
 430iscsi_iface_attr(iface, max_burst_len, ISCSI_IFACE_PARAM_MAX_BURST);
 431iscsi_iface_attr(iface, chap_auth, ISCSI_IFACE_PARAM_CHAP_AUTH_EN);
 432iscsi_iface_attr(iface, bidi_chap, ISCSI_IFACE_PARAM_BIDI_CHAP_EN);
 433iscsi_iface_attr(iface, discovery_auth_optional,
 434		 ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL);
 435iscsi_iface_attr(iface, discovery_logout,
 436		 ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN);
 437iscsi_iface_attr(iface, strict_login_comp_en,
 438		 ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN);
 439iscsi_iface_attr(iface, initiator_name, ISCSI_IFACE_PARAM_INITIATOR_NAME);
 440
 441static umode_t iscsi_iface_attr_is_visible(struct kobject *kobj,
 442					  struct attribute *attr, int i)
 443{
 444	struct device *dev = container_of(kobj, struct device, kobj);
 445	struct iscsi_iface *iface = iscsi_dev_to_iface(dev);
 446	struct iscsi_transport *t = iface->transport;
 447	int param = -1;
 448
 449	if (attr == &dev_attr_iface_def_taskmgmt_tmo.attr)
 450		param = ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO;
 451	else if (attr == &dev_attr_iface_header_digest.attr)
 452		param = ISCSI_IFACE_PARAM_HDRDGST_EN;
 453	else if (attr == &dev_attr_iface_data_digest.attr)
 454		param = ISCSI_IFACE_PARAM_DATADGST_EN;
 455	else if (attr == &dev_attr_iface_immediate_data.attr)
 456		param = ISCSI_IFACE_PARAM_IMM_DATA_EN;
 457	else if (attr == &dev_attr_iface_initial_r2t.attr)
 458		param = ISCSI_IFACE_PARAM_INITIAL_R2T_EN;
 459	else if (attr == &dev_attr_iface_data_seq_in_order.attr)
 460		param = ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN;
 461	else if (attr == &dev_attr_iface_data_pdu_in_order.attr)
 462		param = ISCSI_IFACE_PARAM_PDU_INORDER_EN;
 463	else if (attr == &dev_attr_iface_erl.attr)
 464		param = ISCSI_IFACE_PARAM_ERL;
 465	else if (attr == &dev_attr_iface_max_recv_dlength.attr)
 466		param = ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH;
 467	else if (attr == &dev_attr_iface_first_burst_len.attr)
 468		param = ISCSI_IFACE_PARAM_FIRST_BURST;
 469	else if (attr == &dev_attr_iface_max_outstanding_r2t.attr)
 470		param = ISCSI_IFACE_PARAM_MAX_R2T;
 471	else if (attr == &dev_attr_iface_max_burst_len.attr)
 472		param = ISCSI_IFACE_PARAM_MAX_BURST;
 473	else if (attr == &dev_attr_iface_chap_auth.attr)
 474		param = ISCSI_IFACE_PARAM_CHAP_AUTH_EN;
 475	else if (attr == &dev_attr_iface_bidi_chap.attr)
 476		param = ISCSI_IFACE_PARAM_BIDI_CHAP_EN;
 477	else if (attr == &dev_attr_iface_discovery_auth_optional.attr)
 478		param = ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL;
 479	else if (attr == &dev_attr_iface_discovery_logout.attr)
 480		param = ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN;
 481	else if (attr == &dev_attr_iface_strict_login_comp_en.attr)
 482		param = ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN;
 483	else if (attr == &dev_attr_iface_initiator_name.attr)
 484		param = ISCSI_IFACE_PARAM_INITIATOR_NAME;
 485
 486	if (param != -1)
 487		return t->attr_is_visible(ISCSI_IFACE_PARAM, param);
 488
 489	if (attr == &dev_attr_iface_enabled.attr)
 490		param = ISCSI_NET_PARAM_IFACE_ENABLE;
 491	else if (attr == &dev_attr_iface_vlan_id.attr)
 492		param = ISCSI_NET_PARAM_VLAN_ID;
 493	else if (attr == &dev_attr_iface_vlan_priority.attr)
 494		param = ISCSI_NET_PARAM_VLAN_PRIORITY;
 495	else if (attr == &dev_attr_iface_vlan_enabled.attr)
 496		param = ISCSI_NET_PARAM_VLAN_ENABLED;
 497	else if (attr == &dev_attr_iface_mtu.attr)
 498		param = ISCSI_NET_PARAM_MTU;
 499	else if (attr == &dev_attr_iface_port.attr)
 500		param = ISCSI_NET_PARAM_PORT;
 501	else if (attr == &dev_attr_iface_ipaddress_state.attr)
 502		param = ISCSI_NET_PARAM_IPADDR_STATE;
 503	else if (attr == &dev_attr_iface_delayed_ack_en.attr)
 504		param = ISCSI_NET_PARAM_DELAYED_ACK_EN;
 505	else if (attr == &dev_attr_iface_tcp_nagle_disable.attr)
 506		param = ISCSI_NET_PARAM_TCP_NAGLE_DISABLE;
 507	else if (attr == &dev_attr_iface_tcp_wsf_disable.attr)
 508		param = ISCSI_NET_PARAM_TCP_WSF_DISABLE;
 509	else if (attr == &dev_attr_iface_tcp_wsf.attr)
 510		param = ISCSI_NET_PARAM_TCP_WSF;
 511	else if (attr == &dev_attr_iface_tcp_timer_scale.attr)
 512		param = ISCSI_NET_PARAM_TCP_TIMER_SCALE;
 513	else if (attr == &dev_attr_iface_tcp_timestamp_en.attr)
 514		param = ISCSI_NET_PARAM_TCP_TIMESTAMP_EN;
 515	else if (attr == &dev_attr_iface_cache_id.attr)
 516		param = ISCSI_NET_PARAM_CACHE_ID;
 517	else if (attr == &dev_attr_iface_redirect_en.attr)
 518		param = ISCSI_NET_PARAM_REDIRECT_EN;
 519	else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
 520		if (attr == &dev_attr_ipv4_iface_ipaddress.attr)
 521			param = ISCSI_NET_PARAM_IPV4_ADDR;
 522		else if (attr == &dev_attr_ipv4_iface_gateway.attr)
 523			param = ISCSI_NET_PARAM_IPV4_GW;
 524		else if (attr == &dev_attr_ipv4_iface_subnet.attr)
 525			param = ISCSI_NET_PARAM_IPV4_SUBNET;
 526		else if (attr == &dev_attr_ipv4_iface_bootproto.attr)
 527			param = ISCSI_NET_PARAM_IPV4_BOOTPROTO;
 528		else if (attr ==
 529			 &dev_attr_ipv4_iface_dhcp_dns_address_en.attr)
 530			param = ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN;
 531		else if (attr ==
 532			 &dev_attr_ipv4_iface_dhcp_slp_da_info_en.attr)
 533			param = ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN;
 534		else if (attr == &dev_attr_ipv4_iface_tos_en.attr)
 535			param = ISCSI_NET_PARAM_IPV4_TOS_EN;
 536		else if (attr == &dev_attr_ipv4_iface_tos.attr)
 537			param = ISCSI_NET_PARAM_IPV4_TOS;
 538		else if (attr == &dev_attr_ipv4_iface_grat_arp_en.attr)
 539			param = ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN;
 540		else if (attr ==
 541			 &dev_attr_ipv4_iface_dhcp_alt_client_id_en.attr)
 542			param = ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN;
 543		else if (attr == &dev_attr_ipv4_iface_dhcp_alt_client_id.attr)
 544			param = ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID;
 545		else if (attr ==
 546			 &dev_attr_ipv4_iface_dhcp_req_vendor_id_en.attr)
 547			param = ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN;
 548		else if (attr ==
 549			 &dev_attr_ipv4_iface_dhcp_use_vendor_id_en.attr)
 550			param = ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN;
 551		else if (attr == &dev_attr_ipv4_iface_dhcp_vendor_id.attr)
 552			param = ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID;
 553		else if (attr ==
 554			 &dev_attr_ipv4_iface_dhcp_learn_iqn_en.attr)
 555			param = ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN;
 556		else if (attr ==
 557			 &dev_attr_ipv4_iface_fragment_disable.attr)
 558			param = ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE;
 559		else if (attr ==
 560			 &dev_attr_ipv4_iface_incoming_forwarding_en.attr)
 561			param = ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN;
 562		else if (attr == &dev_attr_ipv4_iface_ttl.attr)
 563			param = ISCSI_NET_PARAM_IPV4_TTL;
 564		else
 565			return 0;
 566	} else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6) {
 567		if (attr == &dev_attr_ipv6_iface_ipaddress.attr)
 568			param = ISCSI_NET_PARAM_IPV6_ADDR;
 569		else if (attr == &dev_attr_ipv6_iface_link_local_addr.attr)
 570			param = ISCSI_NET_PARAM_IPV6_LINKLOCAL;
 571		else if (attr == &dev_attr_ipv6_iface_router_addr.attr)
 572			param = ISCSI_NET_PARAM_IPV6_ROUTER;
 573		else if (attr == &dev_attr_ipv6_iface_ipaddr_autocfg.attr)
 574			param = ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG;
 575		else if (attr == &dev_attr_ipv6_iface_link_local_autocfg.attr)
 576			param = ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG;
 577		else if (attr == &dev_attr_ipv6_iface_link_local_state.attr)
 578			param = ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE;
 579		else if (attr == &dev_attr_ipv6_iface_router_state.attr)
 580			param = ISCSI_NET_PARAM_IPV6_ROUTER_STATE;
 581		else if (attr ==
 582			 &dev_attr_ipv6_iface_grat_neighbor_adv_en.attr)
 583			param = ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN;
 584		else if (attr == &dev_attr_ipv6_iface_mld_en.attr)
 585			param = ISCSI_NET_PARAM_IPV6_MLD_EN;
 586		else if (attr == &dev_attr_ipv6_iface_flow_label.attr)
 587			param = ISCSI_NET_PARAM_IPV6_FLOW_LABEL;
 588		else if (attr == &dev_attr_ipv6_iface_traffic_class.attr)
 589			param = ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS;
 590		else if (attr == &dev_attr_ipv6_iface_hop_limit.attr)
 591			param = ISCSI_NET_PARAM_IPV6_HOP_LIMIT;
 592		else if (attr == &dev_attr_ipv6_iface_nd_reachable_tmo.attr)
 593			param = ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO;
 594		else if (attr == &dev_attr_ipv6_iface_nd_rexmit_time.attr)
 595			param = ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME;
 596		else if (attr == &dev_attr_ipv6_iface_nd_stale_tmo.attr)
 597			param = ISCSI_NET_PARAM_IPV6_ND_STALE_TMO;
 598		else if (attr == &dev_attr_ipv6_iface_dup_addr_detect_cnt.attr)
 599			param = ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT;
 600		else if (attr == &dev_attr_ipv6_iface_router_adv_link_mtu.attr)
 601			param = ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU;
 602		else
 603			return 0;
 604	} else {
 605		WARN_ONCE(1, "Invalid iface attr");
 606		return 0;
 607	}
 608
 609	return t->attr_is_visible(ISCSI_NET_PARAM, param);
 610}
 611
 612static struct attribute *iscsi_iface_attrs[] = {
 613	&dev_attr_iface_enabled.attr,
 614	&dev_attr_iface_vlan_id.attr,
 615	&dev_attr_iface_vlan_priority.attr,
 616	&dev_attr_iface_vlan_enabled.attr,
 617	&dev_attr_ipv4_iface_ipaddress.attr,
 618	&dev_attr_ipv4_iface_gateway.attr,
 619	&dev_attr_ipv4_iface_subnet.attr,
 620	&dev_attr_ipv4_iface_bootproto.attr,
 621	&dev_attr_ipv6_iface_ipaddress.attr,
 622	&dev_attr_ipv6_iface_link_local_addr.attr,
 623	&dev_attr_ipv6_iface_router_addr.attr,
 624	&dev_attr_ipv6_iface_ipaddr_autocfg.attr,
 625	&dev_attr_ipv6_iface_link_local_autocfg.attr,
 626	&dev_attr_iface_mtu.attr,
 627	&dev_attr_iface_port.attr,
 628	&dev_attr_iface_ipaddress_state.attr,
 629	&dev_attr_iface_delayed_ack_en.attr,
 630	&dev_attr_iface_tcp_nagle_disable.attr,
 631	&dev_attr_iface_tcp_wsf_disable.attr,
 632	&dev_attr_iface_tcp_wsf.attr,
 633	&dev_attr_iface_tcp_timer_scale.attr,
 634	&dev_attr_iface_tcp_timestamp_en.attr,
 635	&dev_attr_iface_cache_id.attr,
 636	&dev_attr_iface_redirect_en.attr,
 637	&dev_attr_iface_def_taskmgmt_tmo.attr,
 638	&dev_attr_iface_header_digest.attr,
 639	&dev_attr_iface_data_digest.attr,
 640	&dev_attr_iface_immediate_data.attr,
 641	&dev_attr_iface_initial_r2t.attr,
 642	&dev_attr_iface_data_seq_in_order.attr,
 643	&dev_attr_iface_data_pdu_in_order.attr,
 644	&dev_attr_iface_erl.attr,
 645	&dev_attr_iface_max_recv_dlength.attr,
 646	&dev_attr_iface_first_burst_len.attr,
 647	&dev_attr_iface_max_outstanding_r2t.attr,
 648	&dev_attr_iface_max_burst_len.attr,
 649	&dev_attr_iface_chap_auth.attr,
 650	&dev_attr_iface_bidi_chap.attr,
 651	&dev_attr_iface_discovery_auth_optional.attr,
 652	&dev_attr_iface_discovery_logout.attr,
 653	&dev_attr_iface_strict_login_comp_en.attr,
 654	&dev_attr_iface_initiator_name.attr,
 655	&dev_attr_ipv4_iface_dhcp_dns_address_en.attr,
 656	&dev_attr_ipv4_iface_dhcp_slp_da_info_en.attr,
 657	&dev_attr_ipv4_iface_tos_en.attr,
 658	&dev_attr_ipv4_iface_tos.attr,
 659	&dev_attr_ipv4_iface_grat_arp_en.attr,
 660	&dev_attr_ipv4_iface_dhcp_alt_client_id_en.attr,
 661	&dev_attr_ipv4_iface_dhcp_alt_client_id.attr,
 662	&dev_attr_ipv4_iface_dhcp_req_vendor_id_en.attr,
 663	&dev_attr_ipv4_iface_dhcp_use_vendor_id_en.attr,
 664	&dev_attr_ipv4_iface_dhcp_vendor_id.attr,
 665	&dev_attr_ipv4_iface_dhcp_learn_iqn_en.attr,
 666	&dev_attr_ipv4_iface_fragment_disable.attr,
 667	&dev_attr_ipv4_iface_incoming_forwarding_en.attr,
 668	&dev_attr_ipv4_iface_ttl.attr,
 669	&dev_attr_ipv6_iface_link_local_state.attr,
 670	&dev_attr_ipv6_iface_router_state.attr,
 671	&dev_attr_ipv6_iface_grat_neighbor_adv_en.attr,
 672	&dev_attr_ipv6_iface_mld_en.attr,
 673	&dev_attr_ipv6_iface_flow_label.attr,
 674	&dev_attr_ipv6_iface_traffic_class.attr,
 675	&dev_attr_ipv6_iface_hop_limit.attr,
 676	&dev_attr_ipv6_iface_nd_reachable_tmo.attr,
 677	&dev_attr_ipv6_iface_nd_rexmit_time.attr,
 678	&dev_attr_ipv6_iface_nd_stale_tmo.attr,
 679	&dev_attr_ipv6_iface_dup_addr_detect_cnt.attr,
 680	&dev_attr_ipv6_iface_router_adv_link_mtu.attr,
 681	NULL,
 682};
 683
 684static struct attribute_group iscsi_iface_group = {
 685	.attrs = iscsi_iface_attrs,
 686	.is_visible = iscsi_iface_attr_is_visible,
 687};
 688
 689/* convert iscsi_ipaddress_state values to ascii string name */
 690static const struct {
 691	enum iscsi_ipaddress_state	value;
 692	char				*name;
 693} iscsi_ipaddress_state_names[] = {
 694	{ISCSI_IPDDRESS_STATE_UNCONFIGURED,	"Unconfigured" },
 695	{ISCSI_IPDDRESS_STATE_ACQUIRING,	"Acquiring" },
 696	{ISCSI_IPDDRESS_STATE_TENTATIVE,	"Tentative" },
 697	{ISCSI_IPDDRESS_STATE_VALID,		"Valid" },
 698	{ISCSI_IPDDRESS_STATE_DISABLING,	"Disabling" },
 699	{ISCSI_IPDDRESS_STATE_INVALID,		"Invalid" },
 700	{ISCSI_IPDDRESS_STATE_DEPRECATED,	"Deprecated" },
 701};
 702
 703char *iscsi_get_ipaddress_state_name(enum iscsi_ipaddress_state port_state)
 704{
 705	int i;
 706	char *state = NULL;
 707
 708	for (i = 0; i < ARRAY_SIZE(iscsi_ipaddress_state_names); i++) {
 709		if (iscsi_ipaddress_state_names[i].value == port_state) {
 710			state = iscsi_ipaddress_state_names[i].name;
 711			break;
 712		}
 713	}
 714	return state;
 715}
 716EXPORT_SYMBOL_GPL(iscsi_get_ipaddress_state_name);
 717
 718/* convert iscsi_router_state values to ascii string name */
 719static const struct {
 720	enum iscsi_router_state	value;
 721	char			*name;
 722} iscsi_router_state_names[] = {
 723	{ISCSI_ROUTER_STATE_UNKNOWN,		"Unknown" },
 724	{ISCSI_ROUTER_STATE_ADVERTISED,		"Advertised" },
 725	{ISCSI_ROUTER_STATE_MANUAL,		"Manual" },
 726	{ISCSI_ROUTER_STATE_STALE,		"Stale" },
 727};
 728
 729char *iscsi_get_router_state_name(enum iscsi_router_state router_state)
 730{
 731	int i;
 732	char *state = NULL;
 733
 734	for (i = 0; i < ARRAY_SIZE(iscsi_router_state_names); i++) {
 735		if (iscsi_router_state_names[i].value == router_state) {
 736			state = iscsi_router_state_names[i].name;
 737			break;
 738		}
 739	}
 740	return state;
 741}
 742EXPORT_SYMBOL_GPL(iscsi_get_router_state_name);
 743
 744struct iscsi_iface *
 745iscsi_create_iface(struct Scsi_Host *shost, struct iscsi_transport *transport,
 746		   uint32_t iface_type, uint32_t iface_num, int dd_size)
 747{
 748	struct iscsi_iface *iface;
 749	int err;
 750
 751	iface = kzalloc(sizeof(*iface) + dd_size, GFP_KERNEL);
 752	if (!iface)
 753		return NULL;
 754
 755	iface->transport = transport;
 756	iface->iface_type = iface_type;
 757	iface->iface_num = iface_num;
 758	iface->dev.release = iscsi_iface_release;
 759	iface->dev.class = &iscsi_iface_class;
 760	/* parent reference released in iscsi_iface_release */
 761	iface->dev.parent = get_device(&shost->shost_gendev);
 762	if (iface_type == ISCSI_IFACE_TYPE_IPV4)
 763		dev_set_name(&iface->dev, "ipv4-iface-%u-%u", shost->host_no,
 764			     iface_num);
 765	else
 766		dev_set_name(&iface->dev, "ipv6-iface-%u-%u", shost->host_no,
 767			     iface_num);
 768
 769	err = device_register(&iface->dev);
 770	if (err)
 771		goto put_dev;
 772
 773	err = sysfs_create_group(&iface->dev.kobj, &iscsi_iface_group);
 774	if (err)
 775		goto unreg_iface;
 776
 777	if (dd_size)
 778		iface->dd_data = &iface[1];
 779	return iface;
 780
 781unreg_iface:
 782	device_unregister(&iface->dev);
 783	return NULL;
 784
 785put_dev:
 786	put_device(&iface->dev);
 787	return NULL;
 788}
 789EXPORT_SYMBOL_GPL(iscsi_create_iface);
 790
 791void iscsi_destroy_iface(struct iscsi_iface *iface)
 792{
 793	sysfs_remove_group(&iface->dev.kobj, &iscsi_iface_group);
 794	device_unregister(&iface->dev);
 795}
 796EXPORT_SYMBOL_GPL(iscsi_destroy_iface);
 797
 798/*
 799 * Interface to display flash node params to sysfs
 800 */
 801
 802#define ISCSI_FLASHNODE_ATTR(_prefix, _name, _mode, _show, _store)	\
 803struct device_attribute dev_attr_##_prefix##_##_name =			\
 804	__ATTR(_name, _mode, _show, _store)
 805
 806/* flash node session attrs show */
 807#define iscsi_flashnode_sess_attr_show(type, name, param)		\
 808static ssize_t								\
 809show_##type##_##name(struct device *dev, struct device_attribute *attr,	\
 810		     char *buf)						\
 811{									\
 812	struct iscsi_bus_flash_session *fnode_sess =			\
 813					iscsi_dev_to_flash_session(dev);\
 814	struct iscsi_transport *t = fnode_sess->transport;		\
 815	return t->get_flashnode_param(fnode_sess, param, buf);		\
 816}									\
 817
 818
 819#define iscsi_flashnode_sess_attr(type, name, param)			\
 820	iscsi_flashnode_sess_attr_show(type, name, param)		\
 821static ISCSI_FLASHNODE_ATTR(type, name, S_IRUGO,			\
 822			    show_##type##_##name, NULL);
 823
 824/* Flash node session attributes */
 825
 826iscsi_flashnode_sess_attr(fnode, auto_snd_tgt_disable,
 827			  ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE);
 828iscsi_flashnode_sess_attr(fnode, discovery_session,
 829			  ISCSI_FLASHNODE_DISCOVERY_SESS);
 830iscsi_flashnode_sess_attr(fnode, portal_type, ISCSI_FLASHNODE_PORTAL_TYPE);
 831iscsi_flashnode_sess_attr(fnode, entry_enable, ISCSI_FLASHNODE_ENTRY_EN);
 832iscsi_flashnode_sess_attr(fnode, immediate_data, ISCSI_FLASHNODE_IMM_DATA_EN);
 833iscsi_flashnode_sess_attr(fnode, initial_r2t, ISCSI_FLASHNODE_INITIAL_R2T_EN);
 834iscsi_flashnode_sess_attr(fnode, data_seq_in_order,
 835			  ISCSI_FLASHNODE_DATASEQ_INORDER);
 836iscsi_flashnode_sess_attr(fnode, data_pdu_in_order,
 837			  ISCSI_FLASHNODE_PDU_INORDER);
 838iscsi_flashnode_sess_attr(fnode, chap_auth, ISCSI_FLASHNODE_CHAP_AUTH_EN);
 839iscsi_flashnode_sess_attr(fnode, discovery_logout,
 840			  ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN);
 841iscsi_flashnode_sess_attr(fnode, bidi_chap, ISCSI_FLASHNODE_BIDI_CHAP_EN);
 842iscsi_flashnode_sess_attr(fnode, discovery_auth_optional,
 843			  ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL);
 844iscsi_flashnode_sess_attr(fnode, erl, ISCSI_FLASHNODE_ERL);
 845iscsi_flashnode_sess_attr(fnode, first_burst_len, ISCSI_FLASHNODE_FIRST_BURST);
 846iscsi_flashnode_sess_attr(fnode, def_time2wait, ISCSI_FLASHNODE_DEF_TIME2WAIT);
 847iscsi_flashnode_sess_attr(fnode, def_time2retain,
 848			  ISCSI_FLASHNODE_DEF_TIME2RETAIN);
 849iscsi_flashnode_sess_attr(fnode, max_outstanding_r2t, ISCSI_FLASHNODE_MAX_R2T);
 850iscsi_flashnode_sess_attr(fnode, isid, ISCSI_FLASHNODE_ISID);
 851iscsi_flashnode_sess_attr(fnode, tsid, ISCSI_FLASHNODE_TSID);
 852iscsi_flashnode_sess_attr(fnode, max_burst_len, ISCSI_FLASHNODE_MAX_BURST);
 853iscsi_flashnode_sess_attr(fnode, def_taskmgmt_tmo,
 854			  ISCSI_FLASHNODE_DEF_TASKMGMT_TMO);
 855iscsi_flashnode_sess_attr(fnode, targetalias, ISCSI_FLASHNODE_ALIAS);
 856iscsi_flashnode_sess_attr(fnode, targetname, ISCSI_FLASHNODE_NAME);
 857iscsi_flashnode_sess_attr(fnode, tpgt, ISCSI_FLASHNODE_TPGT);
 858iscsi_flashnode_sess_attr(fnode, discovery_parent_idx,
 859			  ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX);
 860iscsi_flashnode_sess_attr(fnode, discovery_parent_type,
 861			  ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE);
 862iscsi_flashnode_sess_attr(fnode, chap_in_idx, ISCSI_FLASHNODE_CHAP_IN_IDX);
 863iscsi_flashnode_sess_attr(fnode, chap_out_idx, ISCSI_FLASHNODE_CHAP_OUT_IDX);
 864iscsi_flashnode_sess_attr(fnode, username, ISCSI_FLASHNODE_USERNAME);
 865iscsi_flashnode_sess_attr(fnode, username_in, ISCSI_FLASHNODE_USERNAME_IN);
 866iscsi_flashnode_sess_attr(fnode, password, ISCSI_FLASHNODE_PASSWORD);
 867iscsi_flashnode_sess_attr(fnode, password_in, ISCSI_FLASHNODE_PASSWORD_IN);
 868iscsi_flashnode_sess_attr(fnode, is_boot_target, ISCSI_FLASHNODE_IS_BOOT_TGT);
 869
 870static struct attribute *iscsi_flashnode_sess_attrs[] = {
 871	&dev_attr_fnode_auto_snd_tgt_disable.attr,
 872	&dev_attr_fnode_discovery_session.attr,
 873	&dev_attr_fnode_portal_type.attr,
 874	&dev_attr_fnode_entry_enable.attr,
 875	&dev_attr_fnode_immediate_data.attr,
 876	&dev_attr_fnode_initial_r2t.attr,
 877	&dev_attr_fnode_data_seq_in_order.attr,
 878	&dev_attr_fnode_data_pdu_in_order.attr,
 879	&dev_attr_fnode_chap_auth.attr,
 880	&dev_attr_fnode_discovery_logout.attr,
 881	&dev_attr_fnode_bidi_chap.attr,
 882	&dev_attr_fnode_discovery_auth_optional.attr,
 883	&dev_attr_fnode_erl.attr,
 884	&dev_attr_fnode_first_burst_len.attr,
 885	&dev_attr_fnode_def_time2wait.attr,
 886	&dev_attr_fnode_def_time2retain.attr,
 887	&dev_attr_fnode_max_outstanding_r2t.attr,
 888	&dev_attr_fnode_isid.attr,
 889	&dev_attr_fnode_tsid.attr,
 890	&dev_attr_fnode_max_burst_len.attr,
 891	&dev_attr_fnode_def_taskmgmt_tmo.attr,
 892	&dev_attr_fnode_targetalias.attr,
 893	&dev_attr_fnode_targetname.attr,
 894	&dev_attr_fnode_tpgt.attr,
 895	&dev_attr_fnode_discovery_parent_idx.attr,
 896	&dev_attr_fnode_discovery_parent_type.attr,
 897	&dev_attr_fnode_chap_in_idx.attr,
 898	&dev_attr_fnode_chap_out_idx.attr,
 899	&dev_attr_fnode_username.attr,
 900	&dev_attr_fnode_username_in.attr,
 901	&dev_attr_fnode_password.attr,
 902	&dev_attr_fnode_password_in.attr,
 903	&dev_attr_fnode_is_boot_target.attr,
 904	NULL,
 905};
 906
 907static umode_t iscsi_flashnode_sess_attr_is_visible(struct kobject *kobj,
 908						    struct attribute *attr,
 909						    int i)
 910{
 911	struct device *dev = container_of(kobj, struct device, kobj);
 912	struct iscsi_bus_flash_session *fnode_sess =
 913						iscsi_dev_to_flash_session(dev);
 914	struct iscsi_transport *t = fnode_sess->transport;
 915	int param;
 916
 917	if (attr == &dev_attr_fnode_auto_snd_tgt_disable.attr) {
 918		param = ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE;
 919	} else if (attr == &dev_attr_fnode_discovery_session.attr) {
 920		param = ISCSI_FLASHNODE_DISCOVERY_SESS;
 921	} else if (attr == &dev_attr_fnode_portal_type.attr) {
 922		param = ISCSI_FLASHNODE_PORTAL_TYPE;
 923	} else if (attr == &dev_attr_fnode_entry_enable.attr) {
 924		param = ISCSI_FLASHNODE_ENTRY_EN;
 925	} else if (attr == &dev_attr_fnode_immediate_data.attr) {
 926		param = ISCSI_FLASHNODE_IMM_DATA_EN;
 927	} else if (attr == &dev_attr_fnode_initial_r2t.attr) {
 928		param = ISCSI_FLASHNODE_INITIAL_R2T_EN;
 929	} else if (attr == &dev_attr_fnode_data_seq_in_order.attr) {
 930		param = ISCSI_FLASHNODE_DATASEQ_INORDER;
 931	} else if (attr == &dev_attr_fnode_data_pdu_in_order.attr) {
 932		param = ISCSI_FLASHNODE_PDU_INORDER;
 933	} else if (attr == &dev_attr_fnode_chap_auth.attr) {
 934		param = ISCSI_FLASHNODE_CHAP_AUTH_EN;
 935	} else if (attr == &dev_attr_fnode_discovery_logout.attr) {
 936		param = ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN;
 937	} else if (attr == &dev_attr_fnode_bidi_chap.attr) {
 938		param = ISCSI_FLASHNODE_BIDI_CHAP_EN;
 939	} else if (attr == &dev_attr_fnode_discovery_auth_optional.attr) {
 940		param = ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL;
 941	} else if (attr == &dev_attr_fnode_erl.attr) {
 942		param = ISCSI_FLASHNODE_ERL;
 943	} else if (attr == &dev_attr_fnode_first_burst_len.attr) {
 944		param = ISCSI_FLASHNODE_FIRST_BURST;
 945	} else if (attr == &dev_attr_fnode_def_time2wait.attr) {
 946		param = ISCSI_FLASHNODE_DEF_TIME2WAIT;
 947	} else if (attr == &dev_attr_fnode_def_time2retain.attr) {
 948		param = ISCSI_FLASHNODE_DEF_TIME2RETAIN;
 949	} else if (attr == &dev_attr_fnode_max_outstanding_r2t.attr) {
 950		param = ISCSI_FLASHNODE_MAX_R2T;
 951	} else if (attr == &dev_attr_fnode_isid.attr) {
 952		param = ISCSI_FLASHNODE_ISID;
 953	} else if (attr == &dev_attr_fnode_tsid.attr) {
 954		param = ISCSI_FLASHNODE_TSID;
 955	} else if (attr == &dev_attr_fnode_max_burst_len.attr) {
 956		param = ISCSI_FLASHNODE_MAX_BURST;
 957	} else if (attr == &dev_attr_fnode_def_taskmgmt_tmo.attr) {
 958		param = ISCSI_FLASHNODE_DEF_TASKMGMT_TMO;
 959	} else if (attr == &dev_attr_fnode_targetalias.attr) {
 960		param = ISCSI_FLASHNODE_ALIAS;
 961	} else if (attr == &dev_attr_fnode_targetname.attr) {
 962		param = ISCSI_FLASHNODE_NAME;
 963	} else if (attr == &dev_attr_fnode_tpgt.attr) {
 964		param = ISCSI_FLASHNODE_TPGT;
 965	} else if (attr == &dev_attr_fnode_discovery_parent_idx.attr) {
 966		param = ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX;
 967	} else if (attr == &dev_attr_fnode_discovery_parent_type.attr) {
 968		param = ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE;
 969	} else if (attr == &dev_attr_fnode_chap_in_idx.attr) {
 970		param = ISCSI_FLASHNODE_CHAP_IN_IDX;
 971	} else if (attr == &dev_attr_fnode_chap_out_idx.attr) {
 972		param = ISCSI_FLASHNODE_CHAP_OUT_IDX;
 973	} else if (attr == &dev_attr_fnode_username.attr) {
 974		param = ISCSI_FLASHNODE_USERNAME;
 975	} else if (attr == &dev_attr_fnode_username_in.attr) {
 976		param = ISCSI_FLASHNODE_USERNAME_IN;
 977	} else if (attr == &dev_attr_fnode_password.attr) {
 978		param = ISCSI_FLASHNODE_PASSWORD;
 979	} else if (attr == &dev_attr_fnode_password_in.attr) {
 980		param = ISCSI_FLASHNODE_PASSWORD_IN;
 981	} else if (attr == &dev_attr_fnode_is_boot_target.attr) {
 982		param = ISCSI_FLASHNODE_IS_BOOT_TGT;
 983	} else {
 984		WARN_ONCE(1, "Invalid flashnode session attr");
 985		return 0;
 986	}
 987
 988	return t->attr_is_visible(ISCSI_FLASHNODE_PARAM, param);
 989}
 990
 991static struct attribute_group iscsi_flashnode_sess_attr_group = {
 992	.attrs = iscsi_flashnode_sess_attrs,
 993	.is_visible = iscsi_flashnode_sess_attr_is_visible,
 994};
 995
 996static const struct attribute_group *iscsi_flashnode_sess_attr_groups[] = {
 997	&iscsi_flashnode_sess_attr_group,
 998	NULL,
 999};
1000
1001static void iscsi_flashnode_sess_release(struct device *dev)
1002{
1003	struct iscsi_bus_flash_session *fnode_sess =
1004						iscsi_dev_to_flash_session(dev);
1005
1006	kfree(fnode_sess->targetname);
1007	kfree(fnode_sess->targetalias);
1008	kfree(fnode_sess->portal_type);
1009	kfree(fnode_sess);
1010}
1011
1012static const struct device_type iscsi_flashnode_sess_dev_type = {
1013	.name = "iscsi_flashnode_sess_dev_type",
1014	.groups = iscsi_flashnode_sess_attr_groups,
1015	.release = iscsi_flashnode_sess_release,
1016};
1017
1018/* flash node connection attrs show */
1019#define iscsi_flashnode_conn_attr_show(type, name, param)		\
1020static ssize_t								\
1021show_##type##_##name(struct device *dev, struct device_attribute *attr,	\
1022		     char *buf)						\
1023{									\
1024	struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev);\
1025	struct iscsi_bus_flash_session *fnode_sess =			\
1026				iscsi_flash_conn_to_flash_session(fnode_conn);\
1027	struct iscsi_transport *t = fnode_conn->transport;		\
1028	return t->get_flashnode_param(fnode_sess, param, buf);		\
1029}									\
1030
1031
1032#define iscsi_flashnode_conn_attr(type, name, param)			\
1033	iscsi_flashnode_conn_attr_show(type, name, param)		\
1034static ISCSI_FLASHNODE_ATTR(type, name, S_IRUGO,			\
1035			    show_##type##_##name, NULL);
1036
1037/* Flash node connection attributes */
1038
1039iscsi_flashnode_conn_attr(fnode, is_fw_assigned_ipv6,
1040			  ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6);
1041iscsi_flashnode_conn_attr(fnode, header_digest, ISCSI_FLASHNODE_HDR_DGST_EN);
1042iscsi_flashnode_conn_attr(fnode, data_digest, ISCSI_FLASHNODE_DATA_DGST_EN);
1043iscsi_flashnode_conn_attr(fnode, snack_req, ISCSI_FLASHNODE_SNACK_REQ_EN);
1044iscsi_flashnode_conn_attr(fnode, tcp_timestamp_stat,
1045			  ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT);
1046iscsi_flashnode_conn_attr(fnode, tcp_nagle_disable,
1047			  ISCSI_FLASHNODE_TCP_NAGLE_DISABLE);
1048iscsi_flashnode_conn_attr(fnode, tcp_wsf_disable,
1049			  ISCSI_FLASHNODE_TCP_WSF_DISABLE);
1050iscsi_flashnode_conn_attr(fnode, tcp_timer_scale,
1051			  ISCSI_FLASHNODE_TCP_TIMER_SCALE);
1052iscsi_flashnode_conn_attr(fnode, tcp_timestamp_enable,
1053			  ISCSI_FLASHNODE_TCP_TIMESTAMP_EN);
1054iscsi_flashnode_conn_attr(fnode, fragment_disable,
1055			  ISCSI_FLASHNODE_IP_FRAG_DISABLE);
1056iscsi_flashnode_conn_attr(fnode, keepalive_tmo, ISCSI_FLASHNODE_KEEPALIVE_TMO);
1057iscsi_flashnode_conn_attr(fnode, port, ISCSI_FLASHNODE_PORT);
1058iscsi_flashnode_conn_attr(fnode, ipaddress, ISCSI_FLASHNODE_IPADDR);
1059iscsi_flashnode_conn_attr(fnode, max_recv_dlength,
1060			  ISCSI_FLASHNODE_MAX_RECV_DLENGTH);
1061iscsi_flashnode_conn_attr(fnode, max_xmit_dlength,
1062			  ISCSI_FLASHNODE_MAX_XMIT_DLENGTH);
1063iscsi_flashnode_conn_attr(fnode, local_port, ISCSI_FLASHNODE_LOCAL_PORT);
1064iscsi_flashnode_conn_attr(fnode, ipv4_tos, ISCSI_FLASHNODE_IPV4_TOS);
1065iscsi_flashnode_conn_attr(fnode, ipv6_traffic_class, ISCSI_FLASHNODE_IPV6_TC);
1066iscsi_flashnode_conn_attr(fnode, ipv6_flow_label,
1067			  ISCSI_FLASHNODE_IPV6_FLOW_LABEL);
1068iscsi_flashnode_conn_attr(fnode, redirect_ipaddr,
1069			  ISCSI_FLASHNODE_REDIRECT_IPADDR);
1070iscsi_flashnode_conn_attr(fnode, max_segment_size,
1071			  ISCSI_FLASHNODE_MAX_SEGMENT_SIZE);
1072iscsi_flashnode_conn_attr(fnode, link_local_ipv6,
1073			  ISCSI_FLASHNODE_LINK_LOCAL_IPV6);
1074iscsi_flashnode_conn_attr(fnode, tcp_xmit_wsf, ISCSI_FLASHNODE_TCP_XMIT_WSF);
1075iscsi_flashnode_conn_attr(fnode, tcp_recv_wsf, ISCSI_FLASHNODE_TCP_RECV_WSF);
1076iscsi_flashnode_conn_attr(fnode, statsn, ISCSI_FLASHNODE_STATSN);
1077iscsi_flashnode_conn_attr(fnode, exp_statsn, ISCSI_FLASHNODE_EXP_STATSN);
1078
1079static struct attribute *iscsi_flashnode_conn_attrs[] = {
1080	&dev_attr_fnode_is_fw_assigned_ipv6.attr,
1081	&dev_attr_fnode_header_digest.attr,
1082	&dev_attr_fnode_data_digest.attr,
1083	&dev_attr_fnode_snack_req.attr,
1084	&dev_attr_fnode_tcp_timestamp_stat.attr,
1085	&dev_attr_fnode_tcp_nagle_disable.attr,
1086	&dev_attr_fnode_tcp_wsf_disable.attr,
1087	&dev_attr_fnode_tcp_timer_scale.attr,
1088	&dev_attr_fnode_tcp_timestamp_enable.attr,
1089	&dev_attr_fnode_fragment_disable.attr,
1090	&dev_attr_fnode_max_recv_dlength.attr,
1091	&dev_attr_fnode_max_xmit_dlength.attr,
1092	&dev_attr_fnode_keepalive_tmo.attr,
1093	&dev_attr_fnode_port.attr,
1094	&dev_attr_fnode_ipaddress.attr,
1095	&dev_attr_fnode_redirect_ipaddr.attr,
1096	&dev_attr_fnode_max_segment_size.attr,
1097	&dev_attr_fnode_local_port.attr,
1098	&dev_attr_fnode_ipv4_tos.attr,
1099	&dev_attr_fnode_ipv6_traffic_class.attr,
1100	&dev_attr_fnode_ipv6_flow_label.attr,
1101	&dev_attr_fnode_link_local_ipv6.attr,
1102	&dev_attr_fnode_tcp_xmit_wsf.attr,
1103	&dev_attr_fnode_tcp_recv_wsf.attr,
1104	&dev_attr_fnode_statsn.attr,
1105	&dev_attr_fnode_exp_statsn.attr,
1106	NULL,
1107};
1108
1109static umode_t iscsi_flashnode_conn_attr_is_visible(struct kobject *kobj,
1110						    struct attribute *attr,
1111						    int i)
1112{
1113	struct device *dev = container_of(kobj, struct device, kobj);
1114	struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev);
1115	struct iscsi_transport *t = fnode_conn->transport;
1116	int param;
1117
1118	if (attr == &dev_attr_fnode_is_fw_assigned_ipv6.attr) {
1119		param = ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6;
1120	} else if (attr == &dev_attr_fnode_header_digest.attr) {
1121		param = ISCSI_FLASHNODE_HDR_DGST_EN;
1122	} else if (attr == &dev_attr_fnode_data_digest.attr) {
1123		param = ISCSI_FLASHNODE_DATA_DGST_EN;
1124	} else if (attr == &dev_attr_fnode_snack_req.attr) {
1125		param = ISCSI_FLASHNODE_SNACK_REQ_EN;
1126	} else if (attr == &dev_attr_fnode_tcp_timestamp_stat.attr) {
1127		param = ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT;
1128	} else if (attr == &dev_attr_fnode_tcp_nagle_disable.attr) {
1129		param = ISCSI_FLASHNODE_TCP_NAGLE_DISABLE;
1130	} else if (attr == &dev_attr_fnode_tcp_wsf_disable.attr) {
1131		param = ISCSI_FLASHNODE_TCP_WSF_DISABLE;
1132	} else if (attr == &dev_attr_fnode_tcp_timer_scale.attr) {
1133		param = ISCSI_FLASHNODE_TCP_TIMER_SCALE;
1134	} else if (attr == &dev_attr_fnode_tcp_timestamp_enable.attr) {
1135		param = ISCSI_FLASHNODE_TCP_TIMESTAMP_EN;
1136	} else if (attr == &dev_attr_fnode_fragment_disable.attr) {
1137		param = ISCSI_FLASHNODE_IP_FRAG_DISABLE;
1138	} else if (attr == &dev_attr_fnode_max_recv_dlength.attr) {
1139		param = ISCSI_FLASHNODE_MAX_RECV_DLENGTH;
1140	} else if (attr == &dev_attr_fnode_max_xmit_dlength.attr) {
1141		param = ISCSI_FLASHNODE_MAX_XMIT_DLENGTH;
1142	} else if (attr == &dev_attr_fnode_keepalive_tmo.attr) {
1143		param = ISCSI_FLASHNODE_KEEPALIVE_TMO;
1144	} else if (attr == &dev_attr_fnode_port.attr) {
1145		param = ISCSI_FLASHNODE_PORT;
1146	} else if (attr == &dev_attr_fnode_ipaddress.attr) {
1147		param = ISCSI_FLASHNODE_IPADDR;
1148	} else if (attr == &dev_attr_fnode_redirect_ipaddr.attr) {
1149		param = ISCSI_FLASHNODE_REDIRECT_IPADDR;
1150	} else if (attr == &dev_attr_fnode_max_segment_size.attr) {
1151		param = ISCSI_FLASHNODE_MAX_SEGMENT_SIZE;
1152	} else if (attr == &dev_attr_fnode_local_port.attr) {
1153		param = ISCSI_FLASHNODE_LOCAL_PORT;
1154	} else if (attr == &dev_attr_fnode_ipv4_tos.attr) {
1155		param = ISCSI_FLASHNODE_IPV4_TOS;
1156	} else if (attr == &dev_attr_fnode_ipv6_traffic_class.attr) {
1157		param = ISCSI_FLASHNODE_IPV6_TC;
1158	} else if (attr == &dev_attr_fnode_ipv6_flow_label.attr) {
1159		param = ISCSI_FLASHNODE_IPV6_FLOW_LABEL;
1160	} else if (attr == &dev_attr_fnode_link_local_ipv6.attr) {
1161		param = ISCSI_FLASHNODE_LINK_LOCAL_IPV6;
1162	} else if (attr == &dev_attr_fnode_tcp_xmit_wsf.attr) {
1163		param = ISCSI_FLASHNODE_TCP_XMIT_WSF;
1164	} else if (attr == &dev_attr_fnode_tcp_recv_wsf.attr) {
1165		param = ISCSI_FLASHNODE_TCP_RECV_WSF;
1166	} else if (attr == &dev_attr_fnode_statsn.attr) {
1167		param = ISCSI_FLASHNODE_STATSN;
1168	} else if (attr == &dev_attr_fnode_exp_statsn.attr) {
1169		param = ISCSI_FLASHNODE_EXP_STATSN;
1170	} else {
1171		WARN_ONCE(1, "Invalid flashnode connection attr");
1172		return 0;
1173	}
1174
1175	return t->attr_is_visible(ISCSI_FLASHNODE_PARAM, param);
1176}
1177
1178static struct attribute_group iscsi_flashnode_conn_attr_group = {
1179	.attrs = iscsi_flashnode_conn_attrs,
1180	.is_visible = iscsi_flashnode_conn_attr_is_visible,
1181};
1182
1183static const struct attribute_group *iscsi_flashnode_conn_attr_groups[] = {
1184	&iscsi_flashnode_conn_attr_group,
1185	NULL,
1186};
1187
1188static void iscsi_flashnode_conn_release(struct device *dev)
1189{
1190	struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev);
1191
1192	kfree(fnode_conn->ipaddress);
1193	kfree(fnode_conn->redirect_ipaddr);
1194	kfree(fnode_conn->link_local_ipv6_addr);
1195	kfree(fnode_conn);
1196}
1197
1198static const struct device_type iscsi_flashnode_conn_dev_type = {
1199	.name = "iscsi_flashnode_conn_dev_type",
1200	.groups = iscsi_flashnode_conn_attr_groups,
1201	.release = iscsi_flashnode_conn_release,
1202};
1203
1204static const struct bus_type iscsi_flashnode_bus;
1205
1206int iscsi_flashnode_bus_match(struct device *dev,
1207			      const struct device_driver *drv)
1208{
1209	if (dev->bus == &iscsi_flashnode_bus)
1210		return 1;
1211	return 0;
1212}
1213EXPORT_SYMBOL_GPL(iscsi_flashnode_bus_match);
1214
1215static const struct bus_type iscsi_flashnode_bus = {
1216	.name = "iscsi_flashnode",
1217	.match = &iscsi_flashnode_bus_match,
1218};
1219
1220/**
1221 * iscsi_create_flashnode_sess - Add flashnode session entry in sysfs
1222 * @shost: pointer to host data
1223 * @index: index of flashnode to add in sysfs
1224 * @transport: pointer to transport data
1225 * @dd_size: total size to allocate
1226 *
1227 * Adds a sysfs entry for the flashnode session attributes
1228 *
1229 * Returns:
1230 *  pointer to allocated flashnode sess on success
1231 *  %NULL on failure
1232 */
1233struct iscsi_bus_flash_session *
1234iscsi_create_flashnode_sess(struct Scsi_Host *shost, int index,
1235			    struct iscsi_transport *transport,
1236			    int dd_size)
1237{
1238	struct iscsi_bus_flash_session *fnode_sess;
1239	int err;
1240
1241	fnode_sess = kzalloc(sizeof(*fnode_sess) + dd_size, GFP_KERNEL);
1242	if (!fnode_sess)
1243		return NULL;
1244
1245	fnode_sess->transport = transport;
1246	fnode_sess->target_id = index;
1247	fnode_sess->dev.type = &iscsi_flashnode_sess_dev_type;
1248	fnode_sess->dev.bus = &iscsi_flashnode_bus;
1249	fnode_sess->dev.parent = &shost->shost_gendev;
1250	dev_set_name(&fnode_sess->dev, "flashnode_sess-%u:%u",
1251		     shost->host_no, index);
1252
1253	err = device_register(&fnode_sess->dev);
1254	if (err)
1255		goto put_dev;
1256
1257	if (dd_size)
1258		fnode_sess->dd_data = &fnode_sess[1];
1259
1260	return fnode_sess;
1261
1262put_dev:
1263	put_device(&fnode_sess->dev);
1264	return NULL;
1265}
1266EXPORT_SYMBOL_GPL(iscsi_create_flashnode_sess);
1267
1268/**
1269 * iscsi_create_flashnode_conn - Add flashnode conn entry in sysfs
1270 * @shost: pointer to host data
1271 * @fnode_sess: pointer to the parent flashnode session entry
1272 * @transport: pointer to transport data
1273 * @dd_size: total size to allocate
1274 *
1275 * Adds a sysfs entry for the flashnode connection attributes
1276 *
1277 * Returns:
1278 *  pointer to allocated flashnode conn on success
1279 *  %NULL on failure
1280 */
1281struct iscsi_bus_flash_conn *
1282iscsi_create_flashnode_conn(struct Scsi_Host *shost,
1283			    struct iscsi_bus_flash_session *fnode_sess,
1284			    struct iscsi_transport *transport,
1285			    int dd_size)
1286{
1287	struct iscsi_bus_flash_conn *fnode_conn;
1288	int err;
1289
1290	fnode_conn = kzalloc(sizeof(*fnode_conn) + dd_size, GFP_KERNEL);
1291	if (!fnode_conn)
1292		return NULL;
1293
1294	fnode_conn->transport = transport;
1295	fnode_conn->dev.type = &iscsi_flashnode_conn_dev_type;
1296	fnode_conn->dev.bus = &iscsi_flashnode_bus;
1297	fnode_conn->dev.parent = &fnode_sess->dev;
1298	dev_set_name(&fnode_conn->dev, "flashnode_conn-%u:%u:0",
1299		     shost->host_no, fnode_sess->target_id);
1300
1301	err = device_register(&fnode_conn->dev);
1302	if (err)
1303		goto put_dev;
1304
1305	if (dd_size)
1306		fnode_conn->dd_data = &fnode_conn[1];
1307
1308	return fnode_conn;
1309
1310put_dev:
1311	put_device(&fnode_conn->dev);
1312	return NULL;
1313}
1314EXPORT_SYMBOL_GPL(iscsi_create_flashnode_conn);
1315
1316/**
1317 * iscsi_is_flashnode_conn_dev - verify passed device is to be flashnode conn
1318 * @dev: device to verify
1319 * @data: pointer to data containing value to use for verification
1320 *
1321 * Verifies if the passed device is flashnode conn device
1322 *
1323 * Returns:
1324 *  1 on success
1325 *  0 on failure
1326 */
1327static int iscsi_is_flashnode_conn_dev(struct device *dev, const void *data)
1328{
1329	return dev->bus == &iscsi_flashnode_bus;
1330}
1331
1332static int iscsi_destroy_flashnode_conn(struct iscsi_bus_flash_conn *fnode_conn)
1333{
1334	device_unregister(&fnode_conn->dev);
1335	return 0;
1336}
1337
1338static int flashnode_match_index(struct device *dev, const void *data)
1339{
1340	struct iscsi_bus_flash_session *fnode_sess = NULL;
1341	int ret = 0;
1342
1343	if (!iscsi_flashnode_bus_match(dev, NULL))
1344		goto exit_match_index;
1345
1346	fnode_sess = iscsi_dev_to_flash_session(dev);
1347	ret = (fnode_sess->target_id == *((const int *)data)) ? 1 : 0;
1348
1349exit_match_index:
1350	return ret;
1351}
1352
1353/**
1354 * iscsi_get_flashnode_by_index -finds flashnode session entry by index
1355 * @shost: pointer to host data
1356 * @idx: index to match
1357 *
1358 * Finds the flashnode session object for the passed index
1359 *
1360 * Returns:
1361 *  pointer to found flashnode session object on success
1362 *  %NULL on failure
1363 */
1364static struct iscsi_bus_flash_session *
1365iscsi_get_flashnode_by_index(struct Scsi_Host *shost, uint32_t idx)
1366{
1367	struct iscsi_bus_flash_session *fnode_sess = NULL;
1368	struct device *dev;
1369
1370	dev = device_find_child(&shost->shost_gendev, &idx,
1371				flashnode_match_index);
1372	if (dev)
1373		fnode_sess = iscsi_dev_to_flash_session(dev);
1374
1375	return fnode_sess;
1376}
1377
1378/**
1379 * iscsi_find_flashnode_sess - finds flashnode session entry
1380 * @shost: pointer to host data
1381 * @data: pointer to data containing value to use for comparison
1382 * @fn: function pointer that does actual comparison
1383 *
1384 * Finds the flashnode session object comparing the data passed using logic
1385 * defined in passed function pointer
1386 *
1387 * Returns:
1388 *  pointer to found flashnode session device object on success
1389 *  %NULL on failure
1390 */
1391struct device *
1392iscsi_find_flashnode_sess(struct Scsi_Host *shost, const void *data,
1393			  device_match_t fn)
1394{
1395	return device_find_child(&shost->shost_gendev, data, fn);
1396}
1397EXPORT_SYMBOL_GPL(iscsi_find_flashnode_sess);
1398
1399/**
1400 * iscsi_find_flashnode_conn - finds flashnode connection entry
1401 * @fnode_sess: pointer to parent flashnode session entry
1402 *
1403 * Finds the flashnode connection object comparing the data passed using logic
1404 * defined in passed function pointer
1405 *
1406 * Returns:
1407 *  pointer to found flashnode connection device object on success
1408 *  %NULL on failure
1409 */
1410struct device *
1411iscsi_find_flashnode_conn(struct iscsi_bus_flash_session *fnode_sess)
1412{
1413	return device_find_child(&fnode_sess->dev, NULL,
1414				 iscsi_is_flashnode_conn_dev);
1415}
1416EXPORT_SYMBOL_GPL(iscsi_find_flashnode_conn);
1417
1418static int iscsi_iter_destroy_flashnode_conn_fn(struct device *dev, void *data)
1419{
1420	if (!iscsi_is_flashnode_conn_dev(dev, NULL))
1421		return 0;
1422
1423	return iscsi_destroy_flashnode_conn(iscsi_dev_to_flash_conn(dev));
1424}
1425
1426/**
1427 * iscsi_destroy_flashnode_sess - destroy flashnode session entry
1428 * @fnode_sess: pointer to flashnode session entry to be destroyed
1429 *
1430 * Deletes the flashnode session entry and all children flashnode connection
1431 * entries from sysfs
1432 */
1433void iscsi_destroy_flashnode_sess(struct iscsi_bus_flash_session *fnode_sess)
1434{
1435	int err;
1436
1437	err = device_for_each_child(&fnode_sess->dev, NULL,
1438				    iscsi_iter_destroy_flashnode_conn_fn);
1439	if (err)
1440		pr_err("Could not delete all connections for %s. Error %d.\n",
1441		       fnode_sess->dev.kobj.name, err);
1442
1443	device_unregister(&fnode_sess->dev);
1444}
1445EXPORT_SYMBOL_GPL(iscsi_destroy_flashnode_sess);
1446
1447static int iscsi_iter_destroy_flashnode_fn(struct device *dev, void *data)
1448{
1449	if (!iscsi_flashnode_bus_match(dev, NULL))
1450		return 0;
1451
1452	iscsi_destroy_flashnode_sess(iscsi_dev_to_flash_session(dev));
1453	return 0;
1454}
1455
1456/**
1457 * iscsi_destroy_all_flashnode - destroy all flashnode session entries
1458 * @shost: pointer to host data
1459 *
1460 * Destroys all the flashnode session entries and all corresponding children
1461 * flashnode connection entries from sysfs
1462 */
1463void iscsi_destroy_all_flashnode(struct Scsi_Host *shost)
1464{
1465	device_for_each_child(&shost->shost_gendev, NULL,
1466			      iscsi_iter_destroy_flashnode_fn);
1467}
1468EXPORT_SYMBOL_GPL(iscsi_destroy_all_flashnode);
1469
1470/*
1471 * BSG support
1472 */
1473/**
1474 * iscsi_bsg_host_dispatch - Dispatch command to LLD.
1475 * @job: bsg job to be processed
1476 */
1477static int iscsi_bsg_host_dispatch(struct bsg_job *job)
1478{
1479	struct Scsi_Host *shost = iscsi_job_to_shost(job);
1480	struct iscsi_bsg_request *req = job->request;
1481	struct iscsi_bsg_reply *reply = job->reply;
1482	struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
1483	int cmdlen = sizeof(uint32_t);	/* start with length of msgcode */
1484	int ret;
1485
1486	/* check if we have the msgcode value at least */
1487	if (job->request_len < sizeof(uint32_t)) {
1488		ret = -ENOMSG;
1489		goto fail_host_msg;
1490	}
1491
1492	/* Validate the host command */
1493	switch (req->msgcode) {
1494	case ISCSI_BSG_HST_VENDOR:
1495		cmdlen += sizeof(struct iscsi_bsg_host_vendor);
1496		if ((shost->hostt->vendor_id == 0L) ||
1497		    (req->rqst_data.h_vendor.vendor_id !=
1498			shost->hostt->vendor_id)) {
1499			ret = -ESRCH;
1500			goto fail_host_msg;
1501		}
1502		break;
1503	default:
1504		ret = -EBADR;
1505		goto fail_host_msg;
1506	}
1507
1508	/* check if we really have all the request data needed */
1509	if (job->request_len < cmdlen) {
1510		ret = -ENOMSG;
1511		goto fail_host_msg;
1512	}
1513
1514	ret = i->iscsi_transport->bsg_request(job);
1515	if (!ret)
1516		return 0;
1517
1518fail_host_msg:
1519	/* return the errno failure code as the only status */
1520	BUG_ON(job->reply_len < sizeof(uint32_t));
1521	reply->reply_payload_rcv_len = 0;
1522	reply->result = ret;
1523	job->reply_len = sizeof(uint32_t);
1524	bsg_job_done(job, ret, 0);
1525	return 0;
1526}
1527
1528/**
1529 * iscsi_bsg_host_add - Create and add the bsg hooks to receive requests
1530 * @shost: shost for iscsi_host
1531 * @ihost: iscsi_cls_host adding the structures to
1532 */
1533static int
1534iscsi_bsg_host_add(struct Scsi_Host *shost, struct iscsi_cls_host *ihost)
1535{
1536	struct device *dev = &shost->shost_gendev;
1537	struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
1538	struct queue_limits lim;
1539	struct request_queue *q;
1540	char bsg_name[20];
1541
1542	if (!i->iscsi_transport->bsg_request)
1543		return -ENOTSUPP;
1544
1545	snprintf(bsg_name, sizeof(bsg_name), "iscsi_host%d", shost->host_no);
1546	scsi_init_limits(shost, &lim);
1547	q = bsg_setup_queue(dev, bsg_name, &lim, iscsi_bsg_host_dispatch, NULL,
1548			0);
1549	if (IS_ERR(q)) {
1550		shost_printk(KERN_ERR, shost, "bsg interface failed to "
1551			     "initialize - no request queue\n");
1552		return PTR_ERR(q);
1553	}
1554
1555	ihost->bsg_q = q;
1556	return 0;
1557}
1558
1559static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
1560			    struct device *cdev)
1561{
1562	struct Scsi_Host *shost = dev_to_shost(dev);
1563	struct iscsi_cls_host *ihost = shost->shost_data;
1564
1565	memset(ihost, 0, sizeof(*ihost));
1566	mutex_init(&ihost->mutex);
1567
1568	iscsi_bsg_host_add(shost, ihost);
1569	/* ignore any bsg add error - we just can't do sgio */
1570
1571	return 0;
1572}
1573
1574static int iscsi_remove_host(struct transport_container *tc,
1575			     struct device *dev, struct device *cdev)
1576{
1577	struct Scsi_Host *shost = dev_to_shost(dev);
1578	struct iscsi_cls_host *ihost = shost->shost_data;
1579
1580	bsg_remove_queue(ihost->bsg_q);
1581	return 0;
1582}
1583
1584static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
1585			       "iscsi_host",
1586			       iscsi_setup_host,
1587			       iscsi_remove_host,
1588			       NULL);
1589
1590static DECLARE_TRANSPORT_CLASS(iscsi_session_class,
1591			       "iscsi_session",
1592			       NULL,
1593			       NULL,
1594			       NULL);
1595
1596static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
1597			       "iscsi_connection",
1598			       NULL,
1599			       NULL,
1600			       NULL);
1601
1602static struct sock *nls;
1603static DEFINE_MUTEX(rx_queue_mutex);
1604
1605static LIST_HEAD(sesslist);
1606static DEFINE_SPINLOCK(sesslock);
1607static LIST_HEAD(connlist);
1608static DEFINE_SPINLOCK(connlock);
1609
1610static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn *conn)
1611{
1612	struct iscsi_cls_session *sess = iscsi_dev_to_session(conn->dev.parent);
1613	return sess->sid;
1614}
1615
1616/*
1617 * Returns the matching session to a given sid
1618 */
1619static struct iscsi_cls_session *iscsi_session_lookup(uint32_t sid)
1620{
1621	unsigned long flags;
1622	struct iscsi_cls_session *sess;
1623
1624	spin_lock_irqsave(&sesslock, flags);
1625	list_for_each_entry(sess, &sesslist, sess_list) {
1626		if (sess->sid == sid) {
1627			spin_unlock_irqrestore(&sesslock, flags);
1628			return sess;
1629		}
1630	}
1631	spin_unlock_irqrestore(&sesslock, flags);
1632	return NULL;
1633}
1634
1635/*
1636 * Returns the matching connection to a given sid / cid tuple
1637 */
1638static struct iscsi_cls_conn *iscsi_conn_lookup(uint32_t sid, uint32_t cid)
1639{
1640	unsigned long flags;
1641	struct iscsi_cls_conn *conn;
1642
1643	spin_lock_irqsave(&connlock, flags);
1644	list_for_each_entry(conn, &connlist, conn_list) {
1645		if ((conn->cid == cid) && (iscsi_conn_get_sid(conn) == sid)) {
1646			spin_unlock_irqrestore(&connlock, flags);
1647			return conn;
1648		}
1649	}
1650	spin_unlock_irqrestore(&connlock, flags);
1651	return NULL;
1652}
1653
1654/*
1655 * The following functions can be used by LLDs that allocate
1656 * their own scsi_hosts or by software iscsi LLDs
1657 */
1658static struct {
1659	int value;
1660	char *name;
1661} iscsi_session_state_names[] = {
1662	{ ISCSI_SESSION_LOGGED_IN,	"LOGGED_IN" },
1663	{ ISCSI_SESSION_FAILED,		"FAILED" },
1664	{ ISCSI_SESSION_FREE,		"FREE" },
1665};
1666
1667static const char *iscsi_session_state_name(int state)
1668{
1669	int i;
1670	char *name = NULL;
1671
1672	for (i = 0; i < ARRAY_SIZE(iscsi_session_state_names); i++) {
1673		if (iscsi_session_state_names[i].value == state) {
1674			name = iscsi_session_state_names[i].name;
1675			break;
1676		}
1677	}
1678	return name;
1679}
1680
1681static char *iscsi_session_target_state_name[] = {
1682	[ISCSI_SESSION_TARGET_UNBOUND]   = "UNBOUND",
1683	[ISCSI_SESSION_TARGET_ALLOCATED] = "ALLOCATED",
1684	[ISCSI_SESSION_TARGET_SCANNED]   = "SCANNED",
1685	[ISCSI_SESSION_TARGET_UNBINDING] = "UNBINDING",
1686};
1687
1688int iscsi_session_chkready(struct iscsi_cls_session *session)
1689{
1690	int err;
1691
1692	switch (session->state) {
1693	case ISCSI_SESSION_LOGGED_IN:
1694		err = 0;
1695		break;
1696	case ISCSI_SESSION_FAILED:
1697		err = DID_IMM_RETRY << 16;
1698		break;
1699	case ISCSI_SESSION_FREE:
1700		err = DID_TRANSPORT_FAILFAST << 16;
1701		break;
1702	default:
1703		err = DID_NO_CONNECT << 16;
1704		break;
1705	}
1706	return err;
1707}
1708EXPORT_SYMBOL_GPL(iscsi_session_chkready);
1709
1710int iscsi_is_session_online(struct iscsi_cls_session *session)
1711{
1712	unsigned long flags;
1713	int ret = 0;
1714
1715	spin_lock_irqsave(&session->lock, flags);
1716	if (session->state == ISCSI_SESSION_LOGGED_IN)
1717		ret = 1;
1718	spin_unlock_irqrestore(&session->lock, flags);
1719	return ret;
1720}
1721EXPORT_SYMBOL_GPL(iscsi_is_session_online);
1722
1723static void iscsi_session_release(struct device *dev)
1724{
1725	struct iscsi_cls_session *session = iscsi_dev_to_session(dev);
1726	struct Scsi_Host *shost;
1727
1728	shost = iscsi_session_to_shost(session);
1729	scsi_host_put(shost);
1730	ISCSI_DBG_TRANS_SESSION(session, "Completing session release\n");
1731	kfree(session);
1732}
1733
1734int iscsi_is_session_dev(const struct device *dev)
1735{
1736	return dev->release == iscsi_session_release;
1737}
1738EXPORT_SYMBOL_GPL(iscsi_is_session_dev);
1739
1740static int iscsi_iter_session_fn(struct device *dev, void *data)
1741{
1742	void (* fn) (struct iscsi_cls_session *) = data;
1743
1744	if (!iscsi_is_session_dev(dev))
1745		return 0;
1746	fn(iscsi_dev_to_session(dev));
1747	return 0;
1748}
1749
1750void iscsi_host_for_each_session(struct Scsi_Host *shost,
1751				 void (*fn)(struct iscsi_cls_session *))
1752{
1753	device_for_each_child(&shost->shost_gendev, fn,
1754			      iscsi_iter_session_fn);
1755}
1756EXPORT_SYMBOL_GPL(iscsi_host_for_each_session);
1757
1758struct iscsi_scan_data {
1759	unsigned int channel;
1760	unsigned int id;
1761	u64 lun;
1762	enum scsi_scan_mode rescan;
1763};
1764
1765static int iscsi_user_scan_session(struct device *dev, void *data)
1766{
1767	struct iscsi_scan_data *scan_data = data;
1768	struct iscsi_cls_session *session;
1769	struct Scsi_Host *shost;
1770	struct iscsi_cls_host *ihost;
1771	unsigned long flags;
1772	unsigned int id;
1773
1774	if (!iscsi_is_session_dev(dev))
1775		return 0;
1776
1777	session = iscsi_dev_to_session(dev);
1778
1779	ISCSI_DBG_TRANS_SESSION(session, "Scanning session\n");
1780
1781	shost = iscsi_session_to_shost(session);
1782	ihost = shost->shost_data;
1783
1784	mutex_lock(&ihost->mutex);
1785	spin_lock_irqsave(&session->lock, flags);
1786	if (session->state != ISCSI_SESSION_LOGGED_IN) {
1787		spin_unlock_irqrestore(&session->lock, flags);
1788		goto user_scan_exit;
1789	}
1790	id = session->target_id;
1791	spin_unlock_irqrestore(&session->lock, flags);
1792
1793	if (id != ISCSI_MAX_TARGET) {
1794		if ((scan_data->channel == SCAN_WILD_CARD ||
1795		     scan_data->channel == 0) &&
1796		    (scan_data->id == SCAN_WILD_CARD ||
1797		     scan_data->id == id)) {
1798			scsi_scan_target(&session->dev, 0, id,
1799					 scan_data->lun, scan_data->rescan);
1800			spin_lock_irqsave(&session->lock, flags);
1801			session->target_state = ISCSI_SESSION_TARGET_SCANNED;
1802			spin_unlock_irqrestore(&session->lock, flags);
1803		}
1804	}
1805
1806user_scan_exit:
1807	mutex_unlock(&ihost->mutex);
1808	ISCSI_DBG_TRANS_SESSION(session, "Completed session scan\n");
1809	return 0;
1810}
1811
1812static int iscsi_user_scan(struct Scsi_Host *shost, uint channel,
1813			   uint id, u64 lun)
1814{
1815	struct iscsi_scan_data scan_data;
1816
1817	scan_data.channel = channel;
1818	scan_data.id = id;
1819	scan_data.lun = lun;
1820	scan_data.rescan = SCSI_SCAN_MANUAL;
1821
1822	return device_for_each_child(&shost->shost_gendev, &scan_data,
1823				     iscsi_user_scan_session);
1824}
1825
1826static void iscsi_scan_session(struct work_struct *work)
1827{
1828	struct iscsi_cls_session *session =
1829			container_of(work, struct iscsi_cls_session, scan_work);
1830	struct iscsi_scan_data scan_data;
1831
1832	scan_data.channel = 0;
1833	scan_data.id = SCAN_WILD_CARD;
1834	scan_data.lun = SCAN_WILD_CARD;
1835	scan_data.rescan = SCSI_SCAN_RESCAN;
1836
1837	iscsi_user_scan_session(&session->dev, &scan_data);
1838}
1839
1840/**
1841 * iscsi_block_scsi_eh - block scsi eh until session state has transistioned
1842 * @cmd: scsi cmd passed to scsi eh handler
1843 *
1844 * If the session is down this function will wait for the recovery
1845 * timer to fire or for the session to be logged back in. If the
1846 * recovery timer fires then FAST_IO_FAIL is returned. The caller
1847 * should pass this error value to the scsi eh.
1848 */
1849int iscsi_block_scsi_eh(struct scsi_cmnd *cmd)
1850{
1851	struct iscsi_cls_session *session =
1852			starget_to_session(scsi_target(cmd->device));
1853	unsigned long flags;
1854	int ret = 0;
1855
1856	spin_lock_irqsave(&session->lock, flags);
1857	while (session->state != ISCSI_SESSION_LOGGED_IN) {
1858		if (session->state == ISCSI_SESSION_FREE) {
1859			ret = FAST_IO_FAIL;
1860			break;
1861		}
1862		spin_unlock_irqrestore(&session->lock, flags);
1863		msleep(1000);
1864		spin_lock_irqsave(&session->lock, flags);
1865	}
1866	spin_unlock_irqrestore(&session->lock, flags);
1867	return ret;
1868}
1869EXPORT_SYMBOL_GPL(iscsi_block_scsi_eh);
1870
1871static void session_recovery_timedout(struct work_struct *work)
1872{
1873	struct iscsi_cls_session *session =
1874		container_of(work, struct iscsi_cls_session,
1875			     recovery_work.work);
1876	unsigned long flags;
1877
1878	iscsi_cls_session_printk(KERN_INFO, session,
1879				 "session recovery timed out after %d secs\n",
1880				 session->recovery_tmo);
1881
1882	spin_lock_irqsave(&session->lock, flags);
1883	switch (session->state) {
1884	case ISCSI_SESSION_FAILED:
1885		session->state = ISCSI_SESSION_FREE;
1886		break;
1887	case ISCSI_SESSION_LOGGED_IN:
1888	case ISCSI_SESSION_FREE:
1889		/* we raced with the unblock's flush */
1890		spin_unlock_irqrestore(&session->lock, flags);
1891		return;
1892	}
1893	spin_unlock_irqrestore(&session->lock, flags);
1894
1895	ISCSI_DBG_TRANS_SESSION(session, "Unblocking SCSI target\n");
1896	scsi_target_unblock(&session->dev, SDEV_TRANSPORT_OFFLINE);
1897	ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking SCSI target\n");
1898
1899	if (session->transport->session_recovery_timedout)
1900		session->transport->session_recovery_timedout(session);
1901}
1902
1903static void __iscsi_unblock_session(struct work_struct *work)
1904{
1905	struct iscsi_cls_session *session =
1906			container_of(work, struct iscsi_cls_session,
1907				     unblock_work);
1908	unsigned long flags;
1909
1910	ISCSI_DBG_TRANS_SESSION(session, "Unblocking session\n");
1911
1912	cancel_delayed_work_sync(&session->recovery_work);
1913	spin_lock_irqsave(&session->lock, flags);
1914	session->state = ISCSI_SESSION_LOGGED_IN;
1915	spin_unlock_irqrestore(&session->lock, flags);
1916	/* start IO */
1917	scsi_target_unblock(&session->dev, SDEV_RUNNING);
1918	ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking session\n");
1919}
1920
1921/**
1922 * iscsi_unblock_session - set a session as logged in and start IO.
1923 * @session: iscsi session
1924 *
1925 * Mark a session as ready to accept IO.
1926 */
1927void iscsi_unblock_session(struct iscsi_cls_session *session)
1928{
1929	if (!cancel_work_sync(&session->block_work))
1930		cancel_delayed_work_sync(&session->recovery_work);
1931
1932	queue_work(session->workq, &session->unblock_work);
1933	/*
1934	 * Blocking the session can be done from any context so we only
1935	 * queue the block work. Make sure the unblock work has completed
1936	 * because it flushes/cancels the other works and updates the state.
1937	 */
1938	flush_work(&session->unblock_work);
1939}
1940EXPORT_SYMBOL_GPL(iscsi_unblock_session);
1941
1942static void __iscsi_block_session(struct work_struct *work)
1943{
1944	struct iscsi_cls_session *session =
1945			container_of(work, struct iscsi_cls_session,
1946				     block_work);
1947	struct Scsi_Host *shost = iscsi_session_to_shost(session);
1948	unsigned long flags;
1949
1950	ISCSI_DBG_TRANS_SESSION(session, "Blocking session\n");
1951	spin_lock_irqsave(&session->lock, flags);
1952	session->state = ISCSI_SESSION_FAILED;
1953	spin_unlock_irqrestore(&session->lock, flags);
1954	scsi_block_targets(shost, &session->dev);
1955	ISCSI_DBG_TRANS_SESSION(session, "Completed SCSI target blocking\n");
1956	if (session->recovery_tmo >= 0)
1957		queue_delayed_work(session->workq,
1958				   &session->recovery_work,
1959				   session->recovery_tmo * HZ);
1960}
1961
1962void iscsi_block_session(struct iscsi_cls_session *session)
1963{
1964	queue_work(session->workq, &session->block_work);
1965}
1966EXPORT_SYMBOL_GPL(iscsi_block_session);
1967
1968static void __iscsi_unbind_session(struct work_struct *work)
1969{
1970	struct iscsi_cls_session *session =
1971			container_of(work, struct iscsi_cls_session,
1972				     unbind_work);
1973	struct Scsi_Host *shost = iscsi_session_to_shost(session);
1974	struct iscsi_cls_host *ihost = shost->shost_data;
1975	unsigned long flags;
1976	unsigned int target_id;
1977	bool remove_target = true;
1978
1979	ISCSI_DBG_TRANS_SESSION(session, "Unbinding session\n");
1980
1981	/* Prevent new scans and make sure scanning is not in progress */
1982	mutex_lock(&ihost->mutex);
1983	spin_lock_irqsave(&session->lock, flags);
1984	if (session->target_state == ISCSI_SESSION_TARGET_ALLOCATED) {
1985		remove_target = false;
1986	} else if (session->target_state != ISCSI_SESSION_TARGET_SCANNED) {
1987		spin_unlock_irqrestore(&session->lock, flags);
1988		mutex_unlock(&ihost->mutex);
1989		ISCSI_DBG_TRANS_SESSION(session,
1990			"Skipping target unbinding: Session is unbound/unbinding.\n");
1991		return;
1992	}
1993
1994	session->target_state = ISCSI_SESSION_TARGET_UNBINDING;
1995	target_id = session->target_id;
1996	session->target_id = ISCSI_MAX_TARGET;
1997	spin_unlock_irqrestore(&session->lock, flags);
1998	mutex_unlock(&ihost->mutex);
1999
2000	if (remove_target)
2001		scsi_remove_target(&session->dev);
2002
2003	if (session->ida_used)
2004		ida_free(&iscsi_sess_ida, target_id);
2005
2006	iscsi_session_event(session, ISCSI_KEVENT_UNBIND_SESSION);
2007	ISCSI_DBG_TRANS_SESSION(session, "Completed target removal\n");
2008
2009	spin_lock_irqsave(&session->lock, flags);
2010	session->target_state = ISCSI_SESSION_TARGET_UNBOUND;
2011	spin_unlock_irqrestore(&session->lock, flags);
2012}
2013
2014static void __iscsi_destroy_session(struct work_struct *work)
2015{
2016	struct iscsi_cls_session *session =
2017		container_of(work, struct iscsi_cls_session, destroy_work);
2018
2019	session->transport->destroy_session(session);
2020}
2021
2022struct iscsi_cls_session *
2023iscsi_alloc_session(struct Scsi_Host *shost, struct iscsi_transport *transport,
2024		    int dd_size)
2025{
2026	struct iscsi_cls_session *session;
2027
2028	session = kzalloc(sizeof(*session) + dd_size,
2029			  GFP_KERNEL);
2030	if (!session)
2031		return NULL;
2032
2033	session->transport = transport;
2034	session->creator = -1;
2035	session->recovery_tmo = 120;
2036	session->recovery_tmo_sysfs_override = false;
2037	session->state = ISCSI_SESSION_FREE;
2038	INIT_DELAYED_WORK(&session->recovery_work, session_recovery_timedout);
2039	INIT_LIST_HEAD(&session->sess_list);
2040	INIT_WORK(&session->unblock_work, __iscsi_unblock_session);
2041	INIT_WORK(&session->block_work, __iscsi_block_session);
2042	INIT_WORK(&session->unbind_work, __iscsi_unbind_session);
2043	INIT_WORK(&session->scan_work, iscsi_scan_session);
2044	INIT_WORK(&session->destroy_work, __iscsi_destroy_session);
2045	spin_lock_init(&session->lock);
2046
2047	/* this is released in the dev's release function */
2048	scsi_host_get(shost);
2049	session->dev.parent = &shost->shost_gendev;
2050	session->dev.release = iscsi_session_release;
2051	device_initialize(&session->dev);
2052	if (dd_size)
2053		session->dd_data = &session[1];
2054
2055	ISCSI_DBG_TRANS_SESSION(session, "Completed session allocation\n");
2056	return session;
2057}
2058EXPORT_SYMBOL_GPL(iscsi_alloc_session);
2059
2060int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id)
2061{
2062	struct Scsi_Host *shost = iscsi_session_to_shost(session);
2063	unsigned long flags;
2064	int id = 0;
2065	int err;
2066
2067	session->sid = atomic_add_return(1, &iscsi_session_nr);
2068
2069	session->workq = alloc_workqueue("iscsi_ctrl_%d:%d",
2070			WQ_SYSFS | WQ_MEM_RECLAIM | WQ_UNBOUND, 0,
2071			shost->host_no, session->sid);
2072	if (!session->workq)
2073		return -ENOMEM;
2074
2075	if (target_id == ISCSI_MAX_TARGET) {
2076		id = ida_alloc(&iscsi_sess_ida, GFP_KERNEL);
2077
2078		if (id < 0) {
2079			iscsi_cls_session_printk(KERN_ERR, session,
2080					"Failure in Target ID Allocation\n");
2081			err = id;
2082			goto destroy_wq;
2083		}
2084		session->target_id = (unsigned int)id;
2085		session->ida_used = true;
2086	} else
2087		session->target_id = target_id;
2088	spin_lock_irqsave(&session->lock, flags);
2089	session->target_state = ISCSI_SESSION_TARGET_ALLOCATED;
2090	spin_unlock_irqrestore(&session->lock, flags);
2091
2092	dev_set_name(&session->dev, "session%u", session->sid);
2093	err = device_add(&session->dev);
2094	if (err) {
2095		iscsi_cls_session_printk(KERN_ERR, session,
2096					 "could not register session's dev\n");
2097		goto release_ida;
2098	}
2099	err = transport_register_device(&session->dev);
2100	if (err) {
2101		iscsi_cls_session_printk(KERN_ERR, session,
2102					 "could not register transport's dev\n");
2103		goto release_dev;
2104	}
2105
2106	spin_lock_irqsave(&sesslock, flags);
2107	list_add(&session->sess_list, &sesslist);
2108	spin_unlock_irqrestore(&sesslock, flags);
2109
2110	iscsi_session_event(session, ISCSI_KEVENT_CREATE_SESSION);
2111	ISCSI_DBG_TRANS_SESSION(session, "Completed session adding\n");
2112	return 0;
2113
2114release_dev:
2115	device_del(&session->dev);
2116release_ida:
2117	if (session->ida_used)
2118		ida_free(&iscsi_sess_ida, session->target_id);
2119destroy_wq:
2120	destroy_workqueue(session->workq);
2121	return err;
2122}
2123EXPORT_SYMBOL_GPL(iscsi_add_session);
2124
2125static void iscsi_conn_release(struct device *dev)
2126{
2127	struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev);
2128	struct device *parent = conn->dev.parent;
2129
2130	ISCSI_DBG_TRANS_CONN(conn, "Releasing conn\n");
2131	kfree(conn);
2132	put_device(parent);
2133}
2134
2135static int iscsi_is_conn_dev(const struct device *dev)
2136{
2137	return dev->release == iscsi_conn_release;
2138}
2139
2140static int iscsi_iter_destroy_conn_fn(struct device *dev, void *data)
2141{
2142	if (!iscsi_is_conn_dev(dev))
2143		return 0;
2144
2145	iscsi_remove_conn(iscsi_dev_to_conn(dev));
2146	iscsi_put_conn(iscsi_dev_to_conn(dev));
2147
2148	return 0;
2149}
2150
2151void iscsi_remove_session(struct iscsi_cls_session *session)
2152{
2153	unsigned long flags;
2154	int err;
2155
2156	ISCSI_DBG_TRANS_SESSION(session, "Removing session\n");
2157
2158	spin_lock_irqsave(&sesslock, flags);
2159	if (!list_empty(&session->sess_list))
2160		list_del(&session->sess_list);
2161	spin_unlock_irqrestore(&sesslock, flags);
2162
2163	if (!cancel_work_sync(&session->block_work))
2164		cancel_delayed_work_sync(&session->recovery_work);
2165	cancel_work_sync(&session->unblock_work);
2166	/*
2167	 * If we are blocked let commands flow again. The lld or iscsi
2168	 * layer should set up the queuecommand to fail commands.
2169	 * We assume that LLD will not be calling block/unblock while
2170	 * removing the session.
2171	 */
2172	spin_lock_irqsave(&session->lock, flags);
2173	session->state = ISCSI_SESSION_FREE;
2174	spin_unlock_irqrestore(&session->lock, flags);
2175
2176	scsi_target_unblock(&session->dev, SDEV_TRANSPORT_OFFLINE);
2177	/*
2178	 * qla4xxx can perform it's own scans when it runs in kernel only
2179	 * mode. Make sure to flush those scans.
2180	 */
2181	flush_work(&session->scan_work);
2182	/* flush running unbind operations */
2183	flush_work(&session->unbind_work);
2184	__iscsi_unbind_session(&session->unbind_work);
2185
2186	/* hw iscsi may not have removed all connections from session */
2187	err = device_for_each_child(&session->dev, NULL,
2188				    iscsi_iter_destroy_conn_fn);
2189	if (err)
2190		iscsi_cls_session_printk(KERN_ERR, session,
2191					 "Could not delete all connections "
2192					 "for session. Error %d.\n", err);
2193
2194	transport_unregister_device(&session->dev);
2195
2196	destroy_workqueue(session->workq);
2197
2198	ISCSI_DBG_TRANS_SESSION(session, "Completing session removal\n");
2199	device_del(&session->dev);
2200}
2201EXPORT_SYMBOL_GPL(iscsi_remove_session);
2202
2203static void iscsi_stop_conn(struct iscsi_cls_conn *conn, int flag)
2204{
2205	ISCSI_DBG_TRANS_CONN(conn, "Stopping conn.\n");
2206
2207	switch (flag) {
2208	case STOP_CONN_RECOVER:
2209		WRITE_ONCE(conn->state, ISCSI_CONN_FAILED);
2210		break;
2211	case STOP_CONN_TERM:
2212		WRITE_ONCE(conn->state, ISCSI_CONN_DOWN);
2213		break;
2214	default:
2215		iscsi_cls_conn_printk(KERN_ERR, conn, "invalid stop flag %d\n",
2216				      flag);
2217		return;
2218	}
2219
2220	conn->transport->stop_conn(conn, flag);
2221	ISCSI_DBG_TRANS_CONN(conn, "Stopping conn done.\n");
2222}
2223
2224static void iscsi_ep_disconnect(struct iscsi_cls_conn *conn, bool is_active)
2225{
2226	struct iscsi_cls_session *session = iscsi_conn_to_session(conn);
2227	struct iscsi_endpoint *ep;
2228
2229	ISCSI_DBG_TRANS_CONN(conn, "disconnect ep.\n");
2230	WRITE_ONCE(conn->state, ISCSI_CONN_FAILED);
2231
2232	if (!conn->ep || !session->transport->ep_disconnect)
2233		return;
2234
2235	ep = conn->ep;
2236	conn->ep = NULL;
2237
2238	session->transport->unbind_conn(conn, is_active);
2239	session->transport->ep_disconnect(ep);
2240	ISCSI_DBG_TRANS_CONN(conn, "disconnect ep done.\n");
2241}
2242
2243static void iscsi_if_disconnect_bound_ep(struct iscsi_cls_conn *conn,
2244					 struct iscsi_endpoint *ep,
2245					 bool is_active)
2246{
2247	/* Check if this was a conn error and the kernel took ownership */
2248	spin_lock_irq(&conn->lock);
2249	if (!test_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags)) {
2250		spin_unlock_irq(&conn->lock);
2251		iscsi_ep_disconnect(conn, is_active);
2252	} else {
2253		spin_unlock_irq(&conn->lock);
2254		ISCSI_DBG_TRANS_CONN(conn, "flush kernel conn cleanup.\n");
2255		mutex_unlock(&conn->ep_mutex);
2256
2257		flush_work(&conn->cleanup_work);
2258		/*
2259		 * Userspace is now done with the EP so we can release the ref
2260		 * iscsi_cleanup_conn_work_fn took.
2261		 */
2262		iscsi_put_endpoint(ep);
2263		mutex_lock(&conn->ep_mutex);
2264	}
2265}
2266
2267static int iscsi_if_stop_conn(struct iscsi_cls_conn *conn, int flag)
2268{
2269	ISCSI_DBG_TRANS_CONN(conn, "iscsi if conn stop.\n");
2270	/*
2271	 * For offload, iscsid may not know about the ep like when iscsid is
2272	 * restarted or for kernel based session shutdown iscsid is not even
2273	 * up. For these cases, we do the disconnect now.
2274	 */
2275	mutex_lock(&conn->ep_mutex);
2276	if (conn->ep)
2277		iscsi_if_disconnect_bound_ep(conn, conn->ep, true);
2278	mutex_unlock(&conn->ep_mutex);
2279
2280	/*
2281	 * If this is a termination we have to call stop_conn with that flag
2282	 * so the correct states get set. If we haven't run the work yet try to
2283	 * avoid the extra run.
2284	 */
2285	if (flag == STOP_CONN_TERM) {
2286		cancel_work_sync(&conn->cleanup_work);
2287		iscsi_stop_conn(conn, flag);
2288	} else {
2289		/*
2290		 * Figure out if it was the kernel or userspace initiating this.
2291		 */
2292		spin_lock_irq(&conn->lock);
2293		if (!test_and_set_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags)) {
2294			spin_unlock_irq(&conn->lock);
2295			iscsi_stop_conn(conn, flag);
2296		} else {
2297			spin_unlock_irq(&conn->lock);
2298			ISCSI_DBG_TRANS_CONN(conn,
2299					     "flush kernel conn cleanup.\n");
2300			flush_work(&conn->cleanup_work);
2301		}
2302		/*
2303		 * Only clear for recovery to avoid extra cleanup runs during
2304		 * termination.
2305		 */
2306		spin_lock_irq(&conn->lock);
2307		clear_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags);
2308		spin_unlock_irq(&conn->lock);
2309	}
2310	ISCSI_DBG_TRANS_CONN(conn, "iscsi if conn stop done.\n");
2311	return 0;
2312}
2313
2314static void iscsi_cleanup_conn_work_fn(struct work_struct *work)
2315{
2316	struct iscsi_cls_conn *conn = container_of(work, struct iscsi_cls_conn,
2317						   cleanup_work);
2318	struct iscsi_cls_session *session = iscsi_conn_to_session(conn);
2319
2320	mutex_lock(&conn->ep_mutex);
2321	/*
2322	 * Get a ref to the ep, so we don't release its ID until after
2323	 * userspace is done referencing it in iscsi_if_disconnect_bound_ep.
2324	 */
2325	if (conn->ep)
2326		get_device(&conn->ep->dev);
2327	iscsi_ep_disconnect(conn, false);
2328
2329	if (system_state != SYSTEM_RUNNING) {
2330		/*
2331		 * If the user has set up for the session to never timeout
2332		 * then hang like they wanted. For all other cases fail right
2333		 * away since userspace is not going to relogin.
2334		 */
2335		if (session->recovery_tmo > 0)
2336			session->recovery_tmo = 0;
2337	}
2338
2339	iscsi_stop_conn(conn, STOP_CONN_RECOVER);
2340	mutex_unlock(&conn->ep_mutex);
2341	ISCSI_DBG_TRANS_CONN(conn, "cleanup done.\n");
2342}
2343
2344static int iscsi_iter_force_destroy_conn_fn(struct device *dev, void *data)
2345{
2346	struct iscsi_transport *transport;
2347	struct iscsi_cls_conn *conn;
2348
2349	if (!iscsi_is_conn_dev(dev))
2350		return 0;
2351
2352	conn = iscsi_dev_to_conn(dev);
2353	transport = conn->transport;
2354
2355	if (READ_ONCE(conn->state) != ISCSI_CONN_DOWN)
2356		iscsi_if_stop_conn(conn, STOP_CONN_TERM);
2357
2358	transport->destroy_conn(conn);
2359	return 0;
2360}
2361
2362/**
2363 * iscsi_force_destroy_session - destroy a session from the kernel
2364 * @session: session to destroy
2365 *
2366 * Force the destruction of a session from the kernel. This should only be
2367 * used when userspace is no longer running during system shutdown.
2368 */
2369void iscsi_force_destroy_session(struct iscsi_cls_session *session)
2370{
2371	struct iscsi_transport *transport = session->transport;
2372	unsigned long flags;
2373
2374	WARN_ON_ONCE(system_state == SYSTEM_RUNNING);
2375
2376	spin_lock_irqsave(&sesslock, flags);
2377	if (list_empty(&session->sess_list)) {
2378		spin_unlock_irqrestore(&sesslock, flags);
2379		/*
2380		 * Conn/ep is already freed. Session is being torn down via
2381		 * async path. For shutdown we don't care about it so return.
2382		 */
2383		return;
2384	}
2385	spin_unlock_irqrestore(&sesslock, flags);
2386
2387	device_for_each_child(&session->dev, NULL,
2388			      iscsi_iter_force_destroy_conn_fn);
2389	transport->destroy_session(session);
2390}
2391EXPORT_SYMBOL_GPL(iscsi_force_destroy_session);
2392
2393void iscsi_free_session(struct iscsi_cls_session *session)
2394{
2395	ISCSI_DBG_TRANS_SESSION(session, "Freeing session\n");
2396	iscsi_session_event(session, ISCSI_KEVENT_DESTROY_SESSION);
2397	put_device(&session->dev);
2398}
2399EXPORT_SYMBOL_GPL(iscsi_free_session);
2400
2401/**
2402 * iscsi_alloc_conn - alloc iscsi class connection
2403 * @session: iscsi cls session
2404 * @dd_size: private driver data size
2405 * @cid: connection id
2406 */
2407struct iscsi_cls_conn *
2408iscsi_alloc_conn(struct iscsi_cls_session *session, int dd_size, uint32_t cid)
2409{
2410	struct iscsi_transport *transport = session->transport;
2411	struct iscsi_cls_conn *conn;
2412
2413	conn = kzalloc(sizeof(*conn) + dd_size, GFP_KERNEL);
2414	if (!conn)
2415		return NULL;
2416	if (dd_size)
2417		conn->dd_data = &conn[1];
2418
2419	mutex_init(&conn->ep_mutex);
2420	spin_lock_init(&conn->lock);
2421	INIT_LIST_HEAD(&conn->conn_list);
2422	INIT_WORK(&conn->cleanup_work, iscsi_cleanup_conn_work_fn);
2423	conn->transport = transport;
2424	conn->cid = cid;
2425	WRITE_ONCE(conn->state, ISCSI_CONN_DOWN);
2426
2427	/* this is released in the dev's release function */
2428	if (!get_device(&session->dev))
2429		goto free_conn;
2430
2431	dev_set_name(&conn->dev, "connection%d:%u", session->sid, cid);
2432	device_initialize(&conn->dev);
2433	conn->dev.parent = &session->dev;
2434	conn->dev.release = iscsi_conn_release;
2435
2436	return conn;
2437
2438free_conn:
2439	kfree(conn);
2440	return NULL;
2441}
2442EXPORT_SYMBOL_GPL(iscsi_alloc_conn);
2443
2444/**
2445 * iscsi_add_conn - add iscsi class connection
2446 * @conn: iscsi cls connection
2447 *
2448 * This will expose iscsi_cls_conn to sysfs so make sure the related
2449 * resources for sysfs attributes are initialized before calling this.
2450 */
2451int iscsi_add_conn(struct iscsi_cls_conn *conn)
2452{
2453	int err;
2454	unsigned long flags;
2455	struct iscsi_cls_session *session = iscsi_dev_to_session(conn->dev.parent);
2456
2457	err = device_add(&conn->dev);
2458	if (err) {
2459		iscsi_cls_session_printk(KERN_ERR, session,
2460					 "could not register connection's dev\n");
2461		return err;
2462	}
2463	err = transport_register_device(&conn->dev);
2464	if (err) {
2465		iscsi_cls_session_printk(KERN_ERR, session,
2466					 "could not register transport's dev\n");
2467		device_del(&conn->dev);
2468		return err;
2469	}
2470
2471	spin_lock_irqsave(&connlock, flags);
2472	list_add(&conn->conn_list, &connlist);
2473	spin_unlock_irqrestore(&connlock, flags);
2474
2475	return 0;
2476}
2477EXPORT_SYMBOL_GPL(iscsi_add_conn);
2478
2479/**
2480 * iscsi_remove_conn - remove iscsi class connection from sysfs
2481 * @conn: iscsi cls connection
2482 *
2483 * Remove iscsi_cls_conn from sysfs, and wait for previous
2484 * read/write of iscsi_cls_conn's attributes in sysfs to finish.
2485 */
2486void iscsi_remove_conn(struct iscsi_cls_conn *conn)
2487{
2488	unsigned long flags;
2489
2490	spin_lock_irqsave(&connlock, flags);
2491	list_del(&conn->conn_list);
2492	spin_unlock_irqrestore(&connlock, flags);
2493
2494	transport_unregister_device(&conn->dev);
2495	device_del(&conn->dev);
2496}
2497EXPORT_SYMBOL_GPL(iscsi_remove_conn);
2498
2499void iscsi_put_conn(struct iscsi_cls_conn *conn)
2500{
2501	put_device(&conn->dev);
2502}
2503EXPORT_SYMBOL_GPL(iscsi_put_conn);
2504
2505void iscsi_get_conn(struct iscsi_cls_conn *conn)
2506{
2507	get_device(&conn->dev);
2508}
2509EXPORT_SYMBOL_GPL(iscsi_get_conn);
2510
2511/*
2512 * iscsi interface functions
2513 */
2514static struct iscsi_internal *
2515iscsi_if_transport_lookup(struct iscsi_transport *tt)
2516{
2517	struct iscsi_internal *priv;
2518	unsigned long flags;
2519
2520	spin_lock_irqsave(&iscsi_transport_lock, flags);
2521	list_for_each_entry(priv, &iscsi_transports, list) {
2522		if (tt == priv->iscsi_transport) {
2523			spin_unlock_irqrestore(&iscsi_transport_lock, flags);
2524			return priv;
2525		}
2526	}
2527	spin_unlock_irqrestore(&iscsi_transport_lock, flags);
2528	return NULL;
2529}
2530
2531static int
2532iscsi_multicast_skb(struct sk_buff *skb, uint32_t group, gfp_t gfp)
2533{
2534	return nlmsg_multicast(nls, skb, 0, group, gfp);
2535}
2536
2537static int
2538iscsi_unicast_skb(struct sk_buff *skb, u32 portid)
2539{
2540	return nlmsg_unicast(nls, skb, portid);
2541}
2542
2543int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
2544		   char *data, uint32_t data_size)
2545{
2546	struct nlmsghdr	*nlh;
2547	struct sk_buff *skb;
2548	struct iscsi_uevent *ev;
2549	char *pdu;
2550	struct iscsi_internal *priv;
2551	int len = nlmsg_total_size(sizeof(*ev) + sizeof(struct iscsi_hdr) +
2552				   data_size);
2553
2554	priv = iscsi_if_transport_lookup(conn->transport);
2555	if (!priv)
2556		return -EINVAL;
2557
2558	skb = alloc_skb(len, GFP_ATOMIC);
2559	if (!skb) {
2560		iscsi_conn_error_event(conn, ISCSI_ERR_CONN_FAILED);
2561		iscsi_cls_conn_printk(KERN_ERR, conn, "can not deliver "
2562				      "control PDU: OOM\n");
2563		return -ENOMEM;
2564	}
2565
2566	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2567	ev = nlmsg_data(nlh);
2568	memset(ev, 0, sizeof(*ev));
2569	ev->transport_handle = iscsi_handle(conn->transport);
2570	ev->type = ISCSI_KEVENT_RECV_PDU;
2571	ev->r.recv_req.cid = conn->cid;
2572	ev->r.recv_req.sid = iscsi_conn_get_sid(conn);
2573	pdu = (char*)ev + sizeof(*ev);
2574	memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
2575	memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
2576
2577	return iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
2578}
2579EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
2580
2581int iscsi_offload_mesg(struct Scsi_Host *shost,
2582		       struct iscsi_transport *transport, uint32_t type,
2583		       char *data, uint16_t data_size)
2584{
2585	struct nlmsghdr	*nlh;
2586	struct sk_buff *skb;
2587	struct iscsi_uevent *ev;
2588	int len = nlmsg_total_size(sizeof(*ev) + data_size);
2589
2590	skb = alloc_skb(len, GFP_ATOMIC);
2591	if (!skb) {
2592		printk(KERN_ERR "can not deliver iscsi offload message:OOM\n");
2593		return -ENOMEM;
2594	}
2595
2596	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2597	ev = nlmsg_data(nlh);
2598	memset(ev, 0, sizeof(*ev));
2599	ev->type = type;
2600	ev->transport_handle = iscsi_handle(transport);
2601	switch (type) {
2602	case ISCSI_KEVENT_PATH_REQ:
2603		ev->r.req_path.host_no = shost->host_no;
2604		break;
2605	case ISCSI_KEVENT_IF_DOWN:
2606		ev->r.notify_if_down.host_no = shost->host_no;
2607		break;
2608	}
2609
2610	memcpy((char *)ev + sizeof(*ev), data, data_size);
2611
2612	return iscsi_multicast_skb(skb, ISCSI_NL_GRP_UIP, GFP_ATOMIC);
2613}
2614EXPORT_SYMBOL_GPL(iscsi_offload_mesg);
2615
2616void iscsi_conn_error_event(struct iscsi_cls_conn *conn, enum iscsi_err error)
2617{
2618	struct nlmsghdr	*nlh;
2619	struct sk_buff	*skb;
2620	struct iscsi_uevent *ev;
2621	struct iscsi_internal *priv;
2622	int len = nlmsg_total_size(sizeof(*ev));
2623	unsigned long flags;
2624	int state;
2625
2626	spin_lock_irqsave(&conn->lock, flags);
2627	/*
2628	 * Userspace will only do a stop call if we are at least bound. And, we
2629	 * only need to do the in kernel cleanup if in the UP state so cmds can
2630	 * be released to upper layers. If in other states just wait for
2631	 * userspace to avoid races that can leave the cleanup_work queued.
2632	 */
2633	state = READ_ONCE(conn->state);
2634	switch (state) {
2635	case ISCSI_CONN_BOUND:
2636	case ISCSI_CONN_UP:
2637		if (!test_and_set_bit(ISCSI_CLS_CONN_BIT_CLEANUP,
2638				      &conn->flags)) {
2639			queue_work(iscsi_conn_cleanup_workq,
2640				   &conn->cleanup_work);
2641		}
2642		break;
2643	default:
2644		ISCSI_DBG_TRANS_CONN(conn, "Got conn error in state %d\n",
2645				     state);
2646		break;
2647	}
2648	spin_unlock_irqrestore(&conn->lock, flags);
2649
2650	priv = iscsi_if_transport_lookup(conn->transport);
2651	if (!priv)
2652		return;
2653
2654	skb = alloc_skb(len, GFP_ATOMIC);
2655	if (!skb) {
2656		iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored "
2657				      "conn error (%d)\n", error);
2658		return;
2659	}
2660
2661	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2662	ev = nlmsg_data(nlh);
2663	ev->transport_handle = iscsi_handle(conn->transport);
2664	ev->type = ISCSI_KEVENT_CONN_ERROR;
2665	ev->r.connerror.error = error;
2666	ev->r.connerror.cid = conn->cid;
2667	ev->r.connerror.sid = iscsi_conn_get_sid(conn);
2668
2669	iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
2670
2671	iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn error (%d)\n",
2672			      error);
2673}
2674EXPORT_SYMBOL_GPL(iscsi_conn_error_event);
2675
2676void iscsi_conn_login_event(struct iscsi_cls_conn *conn,
2677			    enum iscsi_conn_state state)
2678{
2679	struct nlmsghdr *nlh;
2680	struct sk_buff  *skb;
2681	struct iscsi_uevent *ev;
2682	struct iscsi_internal *priv;
2683	int len = nlmsg_total_size(sizeof(*ev));
2684
2685	priv = iscsi_if_transport_lookup(conn->transport);
2686	if (!priv)
2687		return;
2688
2689	skb = alloc_skb(len, GFP_ATOMIC);
2690	if (!skb) {
2691		iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored "
2692				      "conn login (%d)\n", state);
2693		return;
2694	}
2695
2696	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2697	ev = nlmsg_data(nlh);
2698	ev->transport_handle = iscsi_handle(conn->transport);
2699	ev->type = ISCSI_KEVENT_CONN_LOGIN_STATE;
2700	ev->r.conn_login.state = state;
2701	ev->r.conn_login.cid = conn->cid;
2702	ev->r.conn_login.sid = iscsi_conn_get_sid(conn);
2703	iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
2704
2705	iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn login (%d)\n",
2706			      state);
2707}
2708EXPORT_SYMBOL_GPL(iscsi_conn_login_event);
2709
2710void iscsi_post_host_event(uint32_t host_no, struct iscsi_transport *transport,
2711			   enum iscsi_host_event_code code, uint32_t data_size,
2712			   uint8_t *data)
2713{
2714	struct nlmsghdr *nlh;
2715	struct sk_buff *skb;
2716	struct iscsi_uevent *ev;
2717	int len = nlmsg_total_size(sizeof(*ev) + data_size);
2718
2719	skb = alloc_skb(len, GFP_NOIO);
2720	if (!skb) {
2721		printk(KERN_ERR "gracefully ignored host event (%d):%d OOM\n",
2722		       host_no, code);
2723		return;
2724	}
2725
2726	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2727	ev = nlmsg_data(nlh);
2728	ev->transport_handle = iscsi_handle(transport);
2729	ev->type = ISCSI_KEVENT_HOST_EVENT;
2730	ev->r.host_event.host_no = host_no;
2731	ev->r.host_event.code = code;
2732	ev->r.host_event.data_size = data_size;
2733
2734	if (data_size)
2735		memcpy((char *)ev + sizeof(*ev), data, data_size);
2736
2737	iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_NOIO);
2738}
2739EXPORT_SYMBOL_GPL(iscsi_post_host_event);
2740
2741void iscsi_ping_comp_event(uint32_t host_no, struct iscsi_transport *transport,
2742			   uint32_t status, uint32_t pid, uint32_t data_size,
2743			   uint8_t *data)
2744{
2745	struct nlmsghdr *nlh;
2746	struct sk_buff *skb;
2747	struct iscsi_uevent *ev;
2748	int len = nlmsg_total_size(sizeof(*ev) + data_size);
2749
2750	skb = alloc_skb(len, GFP_NOIO);
2751	if (!skb) {
2752		printk(KERN_ERR "gracefully ignored ping comp: OOM\n");
2753		return;
2754	}
2755
2756	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2757	ev = nlmsg_data(nlh);
2758	ev->transport_handle = iscsi_handle(transport);
2759	ev->type = ISCSI_KEVENT_PING_COMP;
2760	ev->r.ping_comp.host_no = host_no;
2761	ev->r.ping_comp.status = status;
2762	ev->r.ping_comp.pid = pid;
2763	ev->r.ping_comp.data_size = data_size;
2764	memcpy((char *)ev + sizeof(*ev), data, data_size);
2765
2766	iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_NOIO);
2767}
2768EXPORT_SYMBOL_GPL(iscsi_ping_comp_event);
2769
2770static int
2771iscsi_if_send_reply(u32 portid, int type, void *payload, int size)
2772{
2773	struct sk_buff	*skb;
2774	struct nlmsghdr	*nlh;
2775	int len = nlmsg_total_size(size);
2776
2777	skb = alloc_skb(len, GFP_ATOMIC);
2778	if (!skb) {
2779		printk(KERN_ERR "Could not allocate skb to send reply.\n");
2780		return -ENOMEM;
2781	}
2782
2783	nlh = __nlmsg_put(skb, 0, 0, type, (len - sizeof(*nlh)), 0);
2784	memcpy(nlmsg_data(nlh), payload, size);
2785	return iscsi_unicast_skb(skb, portid);
2786}
2787
2788static int
2789iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
2790{
2791	struct iscsi_uevent *ev = nlmsg_data(nlh);
2792	struct iscsi_stats *stats;
2793	struct sk_buff *skbstat;
2794	struct iscsi_cls_conn *conn;
2795	struct nlmsghdr	*nlhstat;
2796	struct iscsi_uevent *evstat;
2797	struct iscsi_internal *priv;
2798	int len = nlmsg_total_size(sizeof(*ev) +
2799				   sizeof(struct iscsi_stats) +
2800				   sizeof(struct iscsi_stats_custom) *
2801				   ISCSI_STATS_CUSTOM_MAX);
2802	int err = 0;
2803
2804	priv = iscsi_if_transport_lookup(transport);
2805	if (!priv)
2806		return -EINVAL;
2807
2808	conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid);
2809	if (!conn)
2810		return -EEXIST;
2811
2812	do {
2813		int actual_size;
2814
2815		skbstat = alloc_skb(len, GFP_ATOMIC);
2816		if (!skbstat) {
2817			iscsi_cls_conn_printk(KERN_ERR, conn, "can not "
2818					      "deliver stats: OOM\n");
2819			return -ENOMEM;
2820		}
2821
2822		nlhstat = __nlmsg_put(skbstat, 0, 0, 0,
2823				      (len - sizeof(*nlhstat)), 0);
2824		evstat = nlmsg_data(nlhstat);
2825		memset(evstat, 0, sizeof(*evstat));
2826		evstat->transport_handle = iscsi_handle(conn->transport);
2827		evstat->type = nlh->nlmsg_type;
2828		evstat->u.get_stats.cid =
2829			ev->u.get_stats.cid;
2830		evstat->u.get_stats.sid =
2831			ev->u.get_stats.sid;
2832		stats = (struct iscsi_stats *)
2833			((char*)evstat + sizeof(*evstat));
2834		memset(stats, 0, sizeof(*stats));
2835
2836		transport->get_stats(conn, stats);
2837		actual_size = nlmsg_total_size(sizeof(struct iscsi_uevent) +
2838					       sizeof(struct iscsi_stats) +
2839					       sizeof(struct iscsi_stats_custom) *
2840					       stats->custom_length);
2841		actual_size -= sizeof(*nlhstat);
2842		actual_size = nlmsg_msg_size(actual_size);
2843		skb_trim(skbstat, NLMSG_ALIGN(actual_size));
2844		nlhstat->nlmsg_len = actual_size;
2845
2846		err = iscsi_multicast_skb(skbstat, ISCSI_NL_GRP_ISCSID,
2847					  GFP_ATOMIC);
2848	} while (err < 0 && err != -ECONNREFUSED);
2849
2850	return err;
2851}
2852
2853/**
2854 * iscsi_session_event - send session destr. completion event
2855 * @session: iscsi class session
2856 * @event: type of event
2857 */
2858int iscsi_session_event(struct iscsi_cls_session *session,
2859			enum iscsi_uevent_e event)
2860{
2861	struct iscsi_internal *priv;
2862	struct Scsi_Host *shost;
2863	struct iscsi_uevent *ev;
2864	struct sk_buff  *skb;
2865	struct nlmsghdr *nlh;
2866	int rc, len = nlmsg_total_size(sizeof(*ev));
2867
2868	priv = iscsi_if_transport_lookup(session->transport);
2869	if (!priv)
2870		return -EINVAL;
2871	shost = iscsi_session_to_shost(session);
2872
2873	skb = alloc_skb(len, GFP_KERNEL);
2874	if (!skb) {
2875		iscsi_cls_session_printk(KERN_ERR, session,
2876					 "Cannot notify userspace of session "
2877					 "event %u\n", event);
2878		return -ENOMEM;
2879	}
2880
2881	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2882	ev = nlmsg_data(nlh);
2883	ev->transport_handle = iscsi_handle(session->transport);
2884
2885	ev->type = event;
2886	switch (event) {
2887	case ISCSI_KEVENT_DESTROY_SESSION:
2888		ev->r.d_session.host_no = shost->host_no;
2889		ev->r.d_session.sid = session->sid;
2890		break;
2891	case ISCSI_KEVENT_CREATE_SESSION:
2892		ev->r.c_session_ret.host_no = shost->host_no;
2893		ev->r.c_session_ret.sid = session->sid;
2894		break;
2895	case ISCSI_KEVENT_UNBIND_SESSION:
2896		ev->r.unbind_session.host_no = shost->host_no;
2897		ev->r.unbind_session.sid = session->sid;
2898		break;
2899	default:
2900		iscsi_cls_session_printk(KERN_ERR, session, "Invalid event "
2901					 "%u.\n", event);
2902		kfree_skb(skb);
2903		return -EINVAL;
2904	}
2905
2906	/*
2907	 * this will occur if the daemon is not up, so we just warn
2908	 * the user and when the daemon is restarted it will handle it
2909	 */
2910	rc = iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_KERNEL);
2911	if (rc == -ESRCH)
2912		iscsi_cls_session_printk(KERN_ERR, session,
2913					 "Cannot notify userspace of session "
2914					 "event %u. Check iscsi daemon\n",
2915					 event);
2916
2917	ISCSI_DBG_TRANS_SESSION(session, "Completed handling event %d rc %d\n",
2918				event, rc);
2919	return rc;
2920}
2921EXPORT_SYMBOL_GPL(iscsi_session_event);
2922
2923static int
2924iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_endpoint *ep,
2925			struct iscsi_uevent *ev, pid_t pid,
2926			uint32_t initial_cmdsn,	uint16_t cmds_max,
2927			uint16_t queue_depth)
2928{
2929	struct iscsi_transport *transport = priv->iscsi_transport;
2930	struct iscsi_cls_session *session;
2931	struct Scsi_Host *shost;
2932
2933	session = transport->create_session(ep, cmds_max, queue_depth,
2934					    initial_cmdsn);
2935	if (!session)
2936		return -ENOMEM;
2937
2938	session->creator = pid;
2939	shost = iscsi_session_to_shost(session);
2940	ev->r.c_session_ret.host_no = shost->host_no;
2941	ev->r.c_session_ret.sid = session->sid;
2942	ISCSI_DBG_TRANS_SESSION(session,
2943				"Completed creating transport session\n");
2944	return 0;
2945}
2946
2947static int
2948iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
2949{
2950	struct iscsi_cls_conn *conn;
2951	struct iscsi_cls_session *session;
2952
2953	session = iscsi_session_lookup(ev->u.c_conn.sid);
2954	if (!session) {
2955		printk(KERN_ERR "iscsi: invalid session %d.\n",
2956		       ev->u.c_conn.sid);
2957		return -EINVAL;
2958	}
2959
2960	conn = transport->create_conn(session, ev->u.c_conn.cid);
2961	if (!conn) {
2962		iscsi_cls_session_printk(KERN_ERR, session,
2963					 "couldn't create a new connection.");
2964		return -ENOMEM;
2965	}
2966
2967	ev->r.c_conn_ret.sid = session->sid;
2968	ev->r.c_conn_ret.cid = conn->cid;
2969
2970	ISCSI_DBG_TRANS_CONN(conn, "Completed creating transport conn\n");
2971	return 0;
2972}
2973
2974static int
2975iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
2976{
2977	struct iscsi_cls_conn *conn;
2978
2979	conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid);
2980	if (!conn)
2981		return -EINVAL;
2982
2983	ISCSI_DBG_TRANS_CONN(conn, "Flushing cleanup during destruction\n");
2984	flush_work(&conn->cleanup_work);
2985	ISCSI_DBG_TRANS_CONN(conn, "Destroying transport conn\n");
2986
2987	if (transport->destroy_conn)
2988		transport->destroy_conn(conn);
2989	return 0;
2990}
2991
2992static int
2993iscsi_if_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev, u32 rlen)
2994{
2995	char *data = (char*)ev + sizeof(*ev);
2996	struct iscsi_cls_conn *conn;
2997	struct iscsi_cls_session *session;
2998	int err = 0, value = 0, state;
2999
3000	if (ev->u.set_param.len > rlen ||
3001	    ev->u.set_param.len > PAGE_SIZE)
3002		return -EINVAL;
3003
3004	session = iscsi_session_lookup(ev->u.set_param.sid);
3005	conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid);
3006	if (!conn || !session)
3007		return -EINVAL;
3008
3009	/* data will be regarded as NULL-ended string, do length check */
3010	if (strlen(data) > ev->u.set_param.len)
3011		return -EINVAL;
3012
3013	switch (ev->u.set_param.param) {
3014	case ISCSI_PARAM_SESS_RECOVERY_TMO:
3015		sscanf(data, "%d", &value);
3016		if (!session->recovery_tmo_sysfs_override)
3017			session->recovery_tmo = value;
3018		break;
3019	default:
3020		state = READ_ONCE(conn->state);
3021		if (state == ISCSI_CONN_BOUND || state == ISCSI_CONN_UP) {
3022			err = transport->set_param(conn, ev->u.set_param.param,
3023					data, ev->u.set_param.len);
3024		} else {
3025			return -ENOTCONN;
3026		}
3027	}
3028
3029	return err;
3030}
3031
3032static int iscsi_if_ep_connect(struct iscsi_transport *transport,
3033			       struct iscsi_uevent *ev, int msg_type)
3034{
3035	struct iscsi_endpoint *ep;
3036	struct sockaddr *dst_addr;
3037	struct Scsi_Host *shost = NULL;
3038	int non_blocking, err = 0;
3039
3040	if (!transport->ep_connect)
3041		return -EINVAL;
3042
3043	if (msg_type == ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST) {
3044		shost = scsi_host_lookup(ev->u.ep_connect_through_host.host_no);
3045		if (!shost) {
3046			printk(KERN_ERR "ep connect failed. Could not find "
3047			       "host no %u\n",
3048			       ev->u.ep_connect_through_host.host_no);
3049			return -ENODEV;
3050		}
3051		non_blocking = ev->u.ep_connect_through_host.non_blocking;
3052	} else
3053		non_blocking = ev->u.ep_connect.non_blocking;
3054
3055	dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
3056	ep = transport->ep_connect(shost, dst_addr, non_blocking);
3057	if (IS_ERR(ep)) {
3058		err = PTR_ERR(ep);
3059		goto release_host;
3060	}
3061
3062	ev->r.ep_connect_ret.handle = ep->id;
3063release_host:
3064	if (shost)
3065		scsi_host_put(shost);
3066	return err;
3067}
3068
3069static int iscsi_if_ep_disconnect(struct iscsi_transport *transport,
3070				  u64 ep_handle)
3071{
3072	struct iscsi_cls_conn *conn;
3073	struct iscsi_endpoint *ep;
3074
3075	if (!transport->ep_disconnect)
3076		return -EINVAL;
3077
3078	ep = iscsi_lookup_endpoint(ep_handle);
3079	if (!ep)
3080		return -EINVAL;
3081
3082	conn = ep->conn;
3083	if (!conn) {
3084		/*
3085		 * conn was not even bound yet, so we can't get iscsi conn
3086		 * failures yet.
3087		 */
3088		transport->ep_disconnect(ep);
3089		goto put_ep;
3090	}
3091
3092	mutex_lock(&conn->ep_mutex);
3093	iscsi_if_disconnect_bound_ep(conn, ep, false);
3094	mutex_unlock(&conn->ep_mutex);
3095put_ep:
3096	iscsi_put_endpoint(ep);
3097	return 0;
3098}
3099
3100static int
3101iscsi_if_transport_ep(struct iscsi_transport *transport,
3102		      struct iscsi_uevent *ev, int msg_type, u32 rlen)
3103{
3104	struct iscsi_endpoint *ep;
3105	int rc = 0;
3106
3107	switch (msg_type) {
3108	case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST:
3109	case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
3110		if (rlen < sizeof(struct sockaddr))
3111			rc = -EINVAL;
3112		else
3113			rc = iscsi_if_ep_connect(transport, ev, msg_type);
3114		break;
3115	case ISCSI_UEVENT_TRANSPORT_EP_POLL:
3116		if (!transport->ep_poll)
3117			return -EINVAL;
3118
3119		ep = iscsi_lookup_endpoint(ev->u.ep_poll.ep_handle);
3120		if (!ep)
3121			return -EINVAL;
3122
3123		ev->r.retcode = transport->ep_poll(ep,
3124						   ev->u.ep_poll.timeout_ms);
3125		iscsi_put_endpoint(ep);
3126		break;
3127	case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
3128		rc = iscsi_if_ep_disconnect(transport,
3129					    ev->u.ep_disconnect.ep_handle);
3130		break;
3131	}
3132	return rc;
3133}
3134
3135static int
3136iscsi_tgt_dscvr(struct iscsi_transport *transport,
3137		struct iscsi_uevent *ev, u32 rlen)
3138{
3139	struct Scsi_Host *shost;
3140	struct sockaddr *dst_addr;
3141	int err;
3142
3143	if (rlen < sizeof(*dst_addr))
3144		return -EINVAL;
3145
3146	if (!transport->tgt_dscvr)
3147		return -EINVAL;
3148
3149	shost = scsi_host_lookup(ev->u.tgt_dscvr.host_no);
3150	if (!shost) {
3151		printk(KERN_ERR "target discovery could not find host no %u\n",
3152		       ev->u.tgt_dscvr.host_no);
3153		return -ENODEV;
3154	}
3155
3156
3157	dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
3158	err = transport->tgt_dscvr(shost, ev->u.tgt_dscvr.type,
3159				   ev->u.tgt_dscvr.enable, dst_addr);
3160	scsi_host_put(shost);
3161	return err;
3162}
3163
3164static int
3165iscsi_set_host_param(struct iscsi_transport *transport,
3166		     struct iscsi_uevent *ev, u32 rlen)
3167{
3168	char *data = (char*)ev + sizeof(*ev);
3169	struct Scsi_Host *shost;
3170	int err;
3171
3172	if (!transport->set_host_param)
3173		return -ENOSYS;
3174
3175	if (ev->u.set_host_param.len > rlen ||
3176	    ev->u.set_host_param.len > PAGE_SIZE)
3177		return -EINVAL;
3178
3179	shost = scsi_host_lookup(ev->u.set_host_param.host_no);
3180	if (!shost) {
3181		printk(KERN_ERR "set_host_param could not find host no %u\n",
3182		       ev->u.set_host_param.host_no);
3183		return -ENODEV;
3184	}
3185
3186	/* see similar check in iscsi_if_set_param() */
3187	if (strlen(data) > ev->u.set_host_param.len) {
3188		err = -EINVAL;
3189		goto out;
3190	}
3191
3192	err = transport->set_host_param(shost, ev->u.set_host_param.param,
3193					data, ev->u.set_host_param.len);
3194out:
3195	scsi_host_put(shost);
3196	return err;
3197}
3198
3199static int
3200iscsi_set_path(struct iscsi_transport *transport, struct iscsi_uevent *ev, u32 rlen)
3201{
3202	struct Scsi_Host *shost;
3203	struct iscsi_path *params;
3204	int err;
3205
3206	if (rlen < sizeof(*params))
3207		return -EINVAL;
3208
3209	if (!transport->set_path)
3210		return -ENOSYS;
3211
3212	shost = scsi_host_lookup(ev->u.set_path.host_no);
3213	if (!shost) {
3214		printk(KERN_ERR "set path could not find host no %u\n",
3215		       ev->u.set_path.host_no);
3216		return -ENODEV;
3217	}
3218
3219	params = (struct iscsi_path *)((char *)ev + sizeof(*ev));
3220	err = transport->set_path(shost, params);
3221
3222	scsi_host_put(shost);
3223	return err;
3224}
3225
3226static int iscsi_session_has_conns(int sid)
3227{
3228	struct iscsi_cls_conn *conn;
3229	unsigned long flags;
3230	int found = 0;
3231
3232	spin_lock_irqsave(&connlock, flags);
3233	list_for_each_entry(conn, &connlist, conn_list) {
3234		if (iscsi_conn_get_sid(conn) == sid) {
3235			found = 1;
3236			break;
3237		}
3238	}
3239	spin_unlock_irqrestore(&connlock, flags);
3240
3241	return found;
3242}
3243
3244static int
3245iscsi_set_iface_params(struct iscsi_transport *transport,
3246		       struct iscsi_uevent *ev, uint32_t len)
3247{
3248	char *data = (char *)ev + sizeof(*ev);
3249	struct Scsi_Host *shost;
3250	int err;
3251
3252	if (!transport->set_iface_param)
3253		return -ENOSYS;
3254
3255	shost = scsi_host_lookup(ev->u.set_iface_params.host_no);
3256	if (!shost) {
3257		printk(KERN_ERR "set_iface_params could not find host no %u\n",
3258		       ev->u.set_iface_params.host_no);
3259		return -ENODEV;
3260	}
3261
3262	err = transport->set_iface_param(shost, data, len);
3263	scsi_host_put(shost);
3264	return err;
3265}
3266
3267static int
3268iscsi_send_ping(struct iscsi_transport *transport, struct iscsi_uevent *ev, u32 rlen)
3269{
3270	struct Scsi_Host *shost;
3271	struct sockaddr *dst_addr;
3272	int err;
3273
3274	if (rlen < sizeof(*dst_addr))
3275		return -EINVAL;
3276
3277	if (!transport->send_ping)
3278		return -ENOSYS;
3279
3280	shost = scsi_host_lookup(ev->u.iscsi_ping.host_no);
3281	if (!shost) {
3282		printk(KERN_ERR "iscsi_ping could not find host no %u\n",
3283		       ev->u.iscsi_ping.host_no);
3284		return -ENODEV;
3285	}
3286
3287	dst_addr = (struct sockaddr *)((char *)ev + sizeof(*ev));
3288	err = transport->send_ping(shost, ev->u.iscsi_ping.iface_num,
3289				   ev->u.iscsi_ping.iface_type,
3290				   ev->u.iscsi_ping.payload_size,
3291				   ev->u.iscsi_ping.pid,
3292				   dst_addr);
3293	scsi_host_put(shost);
3294	return err;
3295}
3296
3297static int
3298iscsi_get_chap(struct iscsi_transport *transport, struct nlmsghdr *nlh)
3299{
3300	struct iscsi_uevent *ev = nlmsg_data(nlh);
3301	struct Scsi_Host *shost = NULL;
3302	struct iscsi_chap_rec *chap_rec;
3303	struct iscsi_internal *priv;
3304	struct sk_buff *skbchap;
3305	struct nlmsghdr *nlhchap;
3306	struct iscsi_uevent *evchap;
3307	uint32_t chap_buf_size;
3308	int len, err = 0;
3309	char *buf;
3310
3311	if (!transport->get_chap)
3312		return -EINVAL;
3313
3314	priv = iscsi_if_transport_lookup(transport);
3315	if (!priv)
3316		return -EINVAL;
3317
3318	chap_buf_size = (ev->u.get_chap.num_entries * sizeof(*chap_rec));
3319	len = nlmsg_total_size(sizeof(*ev) + chap_buf_size);
3320
3321	shost = scsi_host_lookup(ev->u.get_chap.host_no);
3322	if (!shost) {
3323		printk(KERN_ERR "%s: failed. Could not find host no %u\n",
3324		       __func__, ev->u.get_chap.host_no);
3325		return -ENODEV;
3326	}
3327
3328	do {
3329		int actual_size;
3330
3331		skbchap = alloc_skb(len, GFP_KERNEL);
3332		if (!skbchap) {
3333			printk(KERN_ERR "can not deliver chap: OOM\n");
3334			err = -ENOMEM;
3335			goto exit_get_chap;
3336		}
3337
3338		nlhchap = __nlmsg_put(skbchap, 0, 0, 0,
3339				      (len - sizeof(*nlhchap)), 0);
3340		evchap = nlmsg_data(nlhchap);
3341		memset(evchap, 0, sizeof(*evchap));
3342		evchap->transport_handle = iscsi_handle(transport);
3343		evchap->type = nlh->nlmsg_type;
3344		evchap->u.get_chap.host_no = ev->u.get_chap.host_no;
3345		evchap->u.get_chap.chap_tbl_idx = ev->u.get_chap.chap_tbl_idx;
3346		evchap->u.get_chap.num_entries = ev->u.get_chap.num_entries;
3347		buf = (char *)evchap + sizeof(*evchap);
3348		memset(buf, 0, chap_buf_size);
3349
3350		err = transport->get_chap(shost, ev->u.get_chap.chap_tbl_idx,
3351				    &evchap->u.get_chap.num_entries, buf);
3352
3353		actual_size = nlmsg_total_size(sizeof(*ev) + chap_buf_size);
3354		skb_trim(skbchap, NLMSG_ALIGN(actual_size));
3355		nlhchap->nlmsg_len = actual_size;
3356
3357		err = iscsi_multicast_skb(skbchap, ISCSI_NL_GRP_ISCSID,
3358					  GFP_KERNEL);
3359	} while (err < 0 && err != -ECONNREFUSED);
3360
3361exit_get_chap:
3362	scsi_host_put(shost);
3363	return err;
3364}
3365
3366static int iscsi_set_chap(struct iscsi_transport *transport,
3367			  struct iscsi_uevent *ev, uint32_t len)
3368{
3369	char *data = (char *)ev + sizeof(*ev);
3370	struct Scsi_Host *shost;
3371	int err = 0;
3372
3373	if (!transport->set_chap)
3374		return -ENOSYS;
3375
3376	shost = scsi_host_lookup(ev->u.set_path.host_no);
3377	if (!shost) {
3378		pr_err("%s could not find host no %u\n",
3379		       __func__, ev->u.set_path.host_no);
3380		return -ENODEV;
3381	}
3382
3383	err = transport->set_chap(shost, data, len);
3384	scsi_host_put(shost);
3385	return err;
3386}
3387
3388static int iscsi_delete_chap(struct iscsi_transport *transport,
3389			     struct iscsi_uevent *ev)
3390{
3391	struct Scsi_Host *shost;
3392	int err = 0;
3393
3394	if (!transport->delete_chap)
3395		return -ENOSYS;
3396
3397	shost = scsi_host_lookup(ev->u.delete_chap.host_no);
3398	if (!shost) {
3399		printk(KERN_ERR "%s could not find host no %u\n",
3400		       __func__, ev->u.delete_chap.host_no);
3401		return -ENODEV;
3402	}
3403
3404	err = transport->delete_chap(shost, ev->u.delete_chap.chap_tbl_idx);
3405	scsi_host_put(shost);
3406	return err;
3407}
3408
3409static const struct {
3410	enum iscsi_discovery_parent_type value;
3411	char				*name;
3412} iscsi_discovery_parent_names[] = {
3413	{ISCSI_DISC_PARENT_UNKNOWN,	"Unknown" },
3414	{ISCSI_DISC_PARENT_SENDTGT,	"Sendtarget" },
3415	{ISCSI_DISC_PARENT_ISNS,	"isns" },
3416};
3417
3418char *iscsi_get_discovery_parent_name(int parent_type)
3419{
3420	int i;
3421	char *state = "Unknown!";
3422
3423	for (i = 0; i < ARRAY_SIZE(iscsi_discovery_parent_names); i++) {
3424		if (iscsi_discovery_parent_names[i].value & parent_type) {
3425			state = iscsi_discovery_parent_names[i].name;
3426			break;
3427		}
3428	}
3429	return state;
3430}
3431EXPORT_SYMBOL_GPL(iscsi_get_discovery_parent_name);
3432
3433static int iscsi_set_flashnode_param(struct iscsi_transport *transport,
3434				     struct iscsi_uevent *ev, uint32_t len)
3435{
3436	char *data = (char *)ev + sizeof(*ev);
3437	struct Scsi_Host *shost;
3438	struct iscsi_bus_flash_session *fnode_sess;
3439	struct iscsi_bus_flash_conn *fnode_conn;
3440	struct device *dev;
3441	uint32_t idx;
3442	int err = 0;
3443
3444	if (!transport->set_flashnode_param) {
3445		err = -ENOSYS;
3446		goto exit_set_fnode;
3447	}
3448
3449	shost = scsi_host_lookup(ev->u.set_flashnode.host_no);
3450	if (!shost) {
3451		pr_err("%s could not find host no %u\n",
3452		       __func__, ev->u.set_flashnode.host_no);
3453		err = -ENODEV;
3454		goto exit_set_fnode;
3455	}
3456
3457	idx = ev->u.set_flashnode.flashnode_idx;
3458	fnode_sess = iscsi_get_flashnode_by_index(shost, idx);
3459	if (!fnode_sess) {
3460		pr_err("%s could not find flashnode %u for host no %u\n",
3461		       __func__, idx, ev->u.set_flashnode.host_no);
3462		err = -ENODEV;
3463		goto put_host;
3464	}
3465
3466	dev = iscsi_find_flashnode_conn(fnode_sess);
3467	if (!dev) {
3468		err = -ENODEV;
3469		goto put_sess;
3470	}
3471
3472	fnode_conn = iscsi_dev_to_flash_conn(dev);
3473	err = transport->set_flashnode_param(fnode_sess, fnode_conn, data, len);
3474	put_device(dev);
3475
3476put_sess:
3477	put_device(&fnode_sess->dev);
3478
3479put_host:
3480	scsi_host_put(shost);
3481
3482exit_set_fnode:
3483	return err;
3484}
3485
3486static int iscsi_new_flashnode(struct iscsi_transport *transport,
3487			       struct iscsi_uevent *ev, uint32_t len)
3488{
3489	char *data = (char *)ev + sizeof(*ev);
3490	struct Scsi_Host *shost;
3491	int index;
3492	int err = 0;
3493
3494	if (!transport->new_flashnode) {
3495		err = -ENOSYS;
3496		goto exit_new_fnode;
3497	}
3498
3499	shost = scsi_host_lookup(ev->u.new_flashnode.host_no);
3500	if (!shost) {
3501		pr_err("%s could not find host no %u\n",
3502		       __func__, ev->u.new_flashnode.host_no);
3503		err = -ENODEV;
3504		goto exit_new_fnode;
3505	}
3506
3507	index = transport->new_flashnode(shost, data, len);
3508
3509	if (index >= 0)
3510		ev->r.new_flashnode_ret.flashnode_idx = index;
3511	else
3512		err = -EIO;
3513
3514	scsi_host_put(shost);
3515
3516exit_new_fnode:
3517	return err;
3518}
3519
3520static int iscsi_del_flashnode(struct iscsi_transport *transport,
3521			       struct iscsi_uevent *ev)
3522{
3523	struct Scsi_Host *shost;
3524	struct iscsi_bus_flash_session *fnode_sess;
3525	uint32_t idx;
3526	int err = 0;
3527
3528	if (!transport->del_flashnode) {
3529		err = -ENOSYS;
3530		goto exit_del_fnode;
3531	}
3532
3533	shost = scsi_host_lookup(ev->u.del_flashnode.host_no);
3534	if (!shost) {
3535		pr_err("%s could not find host no %u\n",
3536		       __func__, ev->u.del_flashnode.host_no);
3537		err = -ENODEV;
3538		goto exit_del_fnode;
3539	}
3540
3541	idx = ev->u.del_flashnode.flashnode_idx;
3542	fnode_sess = iscsi_get_flashnode_by_index(shost, idx);
3543	if (!fnode_sess) {
3544		pr_err("%s could not find flashnode %u for host no %u\n",
3545		       __func__, idx, ev->u.del_flashnode.host_no);
3546		err = -ENODEV;
3547		goto put_host;
3548	}
3549
3550	err = transport->del_flashnode(fnode_sess);
3551	put_device(&fnode_sess->dev);
3552
3553put_host:
3554	scsi_host_put(shost);
3555
3556exit_del_fnode:
3557	return err;
3558}
3559
3560static int iscsi_login_flashnode(struct iscsi_transport *transport,
3561				 struct iscsi_uevent *ev)
3562{
3563	struct Scsi_Host *shost;
3564	struct iscsi_bus_flash_session *fnode_sess;
3565	struct iscsi_bus_flash_conn *fnode_conn;
3566	struct device *dev;
3567	uint32_t idx;
3568	int err = 0;
3569
3570	if (!transport->login_flashnode) {
3571		err = -ENOSYS;
3572		goto exit_login_fnode;
3573	}
3574
3575	shost = scsi_host_lookup(ev->u.login_flashnode.host_no);
3576	if (!shost) {
3577		pr_err("%s could not find host no %u\n",
3578		       __func__, ev->u.login_flashnode.host_no);
3579		err = -ENODEV;
3580		goto exit_login_fnode;
3581	}
3582
3583	idx = ev->u.login_flashnode.flashnode_idx;
3584	fnode_sess = iscsi_get_flashnode_by_index(shost, idx);
3585	if (!fnode_sess) {
3586		pr_err("%s could not find flashnode %u for host no %u\n",
3587		       __func__, idx, ev->u.login_flashnode.host_no);
3588		err = -ENODEV;
3589		goto put_host;
3590	}
3591
3592	dev = iscsi_find_flashnode_conn(fnode_sess);
3593	if (!dev) {
3594		err = -ENODEV;
3595		goto put_sess;
3596	}
3597
3598	fnode_conn = iscsi_dev_to_flash_conn(dev);
3599	err = transport->login_flashnode(fnode_sess, fnode_conn);
3600	put_device(dev);
3601
3602put_sess:
3603	put_device(&fnode_sess->dev);
3604
3605put_host:
3606	scsi_host_put(shost);
3607
3608exit_login_fnode:
3609	return err;
3610}
3611
3612static int iscsi_logout_flashnode(struct iscsi_transport *transport,
3613				  struct iscsi_uevent *ev)
3614{
3615	struct Scsi_Host *shost;
3616	struct iscsi_bus_flash_session *fnode_sess;
3617	struct iscsi_bus_flash_conn *fnode_conn;
3618	struct device *dev;
3619	uint32_t idx;
3620	int err = 0;
3621
3622	if (!transport->logout_flashnode) {
3623		err = -ENOSYS;
3624		goto exit_logout_fnode;
3625	}
3626
3627	shost = scsi_host_lookup(ev->u.logout_flashnode.host_no);
3628	if (!shost) {
3629		pr_err("%s could not find host no %u\n",
3630		       __func__, ev->u.logout_flashnode.host_no);
3631		err = -ENODEV;
3632		goto exit_logout_fnode;
3633	}
3634
3635	idx = ev->u.logout_flashnode.flashnode_idx;
3636	fnode_sess = iscsi_get_flashnode_by_index(shost, idx);
3637	if (!fnode_sess) {
3638		pr_err("%s could not find flashnode %u for host no %u\n",
3639		       __func__, idx, ev->u.logout_flashnode.host_no);
3640		err = -ENODEV;
3641		goto put_host;
3642	}
3643
3644	dev = iscsi_find_flashnode_conn(fnode_sess);
3645	if (!dev) {
3646		err = -ENODEV;
3647		goto put_sess;
3648	}
3649
3650	fnode_conn = iscsi_dev_to_flash_conn(dev);
3651
3652	err = transport->logout_flashnode(fnode_sess, fnode_conn);
3653	put_device(dev);
3654
3655put_sess:
3656	put_device(&fnode_sess->dev);
3657
3658put_host:
3659	scsi_host_put(shost);
3660
3661exit_logout_fnode:
3662	return err;
3663}
3664
3665static int iscsi_logout_flashnode_sid(struct iscsi_transport *transport,
3666				      struct iscsi_uevent *ev)
3667{
3668	struct Scsi_Host *shost;
3669	struct iscsi_cls_session *session;
3670	int err = 0;
3671
3672	if (!transport->logout_flashnode_sid) {
3673		err = -ENOSYS;
3674		goto exit_logout_sid;
3675	}
3676
3677	shost = scsi_host_lookup(ev->u.logout_flashnode_sid.host_no);
3678	if (!shost) {
3679		pr_err("%s could not find host no %u\n",
3680		       __func__, ev->u.logout_flashnode.host_no);
3681		err = -ENODEV;
3682		goto exit_logout_sid;
3683	}
3684
3685	session = iscsi_session_lookup(ev->u.logout_flashnode_sid.sid);
3686	if (!session) {
3687		pr_err("%s could not find session id %u\n",
3688		       __func__, ev->u.logout_flashnode_sid.sid);
3689		err = -EINVAL;
3690		goto put_host;
3691	}
3692
3693	err = transport->logout_flashnode_sid(session);
3694
3695put_host:
3696	scsi_host_put(shost);
3697
3698exit_logout_sid:
3699	return err;
3700}
3701
3702static int
3703iscsi_get_host_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
3704{
3705	struct iscsi_uevent *ev = nlmsg_data(nlh);
3706	struct Scsi_Host *shost = NULL;
3707	struct iscsi_internal *priv;
3708	struct sk_buff *skbhost_stats;
3709	struct nlmsghdr *nlhhost_stats;
3710	struct iscsi_uevent *evhost_stats;
3711	int host_stats_size = 0;
3712	int len, err = 0;
3713	char *buf;
3714
3715	if (!transport->get_host_stats)
3716		return -ENOSYS;
3717
3718	priv = iscsi_if_transport_lookup(transport);
3719	if (!priv)
3720		return -EINVAL;
3721
3722	host_stats_size = sizeof(struct iscsi_offload_host_stats);
3723	len = nlmsg_total_size(sizeof(*ev) + host_stats_size);
3724
3725	shost = scsi_host_lookup(ev->u.get_host_stats.host_no);
3726	if (!shost) {
3727		pr_err("%s: failed. Could not find host no %u\n",
3728		       __func__, ev->u.get_host_stats.host_no);
3729		return -ENODEV;
3730	}
3731
3732	do {
3733		int actual_size;
3734
3735		skbhost_stats = alloc_skb(len, GFP_KERNEL);
3736		if (!skbhost_stats) {
3737			pr_err("cannot deliver host stats: OOM\n");
3738			err = -ENOMEM;
3739			goto exit_host_stats;
3740		}
3741
3742		nlhhost_stats = __nlmsg_put(skbhost_stats, 0, 0, 0,
3743				      (len - sizeof(*nlhhost_stats)), 0);
3744		evhost_stats = nlmsg_data(nlhhost_stats);
3745		memset(evhost_stats, 0, sizeof(*evhost_stats));
3746		evhost_stats->transport_handle = iscsi_handle(transport);
3747		evhost_stats->type = nlh->nlmsg_type;
3748		evhost_stats->u.get_host_stats.host_no =
3749					ev->u.get_host_stats.host_no;
3750		buf = (char *)evhost_stats + sizeof(*evhost_stats);
3751		memset(buf, 0, host_stats_size);
3752
3753		err = transport->get_host_stats(shost, buf, host_stats_size);
3754		if (err) {
3755			kfree_skb(skbhost_stats);
3756			goto exit_host_stats;
3757		}
3758
3759		actual_size = nlmsg_total_size(sizeof(*ev) + host_stats_size);
3760		skb_trim(skbhost_stats, NLMSG_ALIGN(actual_size));
3761		nlhhost_stats->nlmsg_len = actual_size;
3762
3763		err = iscsi_multicast_skb(skbhost_stats, ISCSI_NL_GRP_ISCSID,
3764					  GFP_KERNEL);
3765	} while (err < 0 && err != -ECONNREFUSED);
3766
3767exit_host_stats:
3768	scsi_host_put(shost);
3769	return err;
3770}
3771
3772static int iscsi_if_transport_conn(struct iscsi_transport *transport,
3773				   struct nlmsghdr *nlh, u32 pdu_len)
3774{
3775	struct iscsi_uevent *ev = nlmsg_data(nlh);
3776	struct iscsi_cls_session *session;
3777	struct iscsi_cls_conn *conn = NULL;
3778	struct iscsi_endpoint *ep;
3779	int err = 0;
3780
3781	switch (nlh->nlmsg_type) {
3782	case ISCSI_UEVENT_CREATE_CONN:
3783		return iscsi_if_create_conn(transport, ev);
3784	case ISCSI_UEVENT_DESTROY_CONN:
3785		return iscsi_if_destroy_conn(transport, ev);
3786	case ISCSI_UEVENT_STOP_CONN:
3787		conn = iscsi_conn_lookup(ev->u.stop_conn.sid,
3788					 ev->u.stop_conn.cid);
3789		if (!conn)
3790			return -EINVAL;
3791
3792		return iscsi_if_stop_conn(conn, ev->u.stop_conn.flag);
3793	}
3794
3795	/*
3796	 * The following cmds need to be run under the ep_mutex so in kernel
3797	 * conn cleanup (ep_disconnect + unbind and conn) is not done while
3798	 * these are running. They also must not run if we have just run a conn
3799	 * cleanup because they would set the state in a way that might allow
3800	 * IO or send IO themselves.
3801	 */
3802	switch (nlh->nlmsg_type) {
3803	case ISCSI_UEVENT_START_CONN:
3804		conn = iscsi_conn_lookup(ev->u.start_conn.sid,
3805					 ev->u.start_conn.cid);
3806		break;
3807	case ISCSI_UEVENT_BIND_CONN:
3808		conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid);
3809		break;
3810	case ISCSI_UEVENT_SEND_PDU:
3811		conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid);
3812		break;
3813	}
3814
3815	if (!conn)
3816		return -EINVAL;
3817
3818	mutex_lock(&conn->ep_mutex);
3819	spin_lock_irq(&conn->lock);
3820	if (test_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags)) {
3821		spin_unlock_irq(&conn->lock);
3822		mutex_unlock(&conn->ep_mutex);
3823		ev->r.retcode = -ENOTCONN;
3824		return 0;
3825	}
3826	spin_unlock_irq(&conn->lock);
3827
3828	switch (nlh->nlmsg_type) {
3829	case ISCSI_UEVENT_BIND_CONN:
3830		session = iscsi_session_lookup(ev->u.b_conn.sid);
3831		if (!session) {
3832			err = -EINVAL;
3833			break;
3834		}
3835
3836		ev->r.retcode =	transport->bind_conn(session, conn,
3837						ev->u.b_conn.transport_eph,
3838						ev->u.b_conn.is_leading);
3839		if (!ev->r.retcode)
3840			WRITE_ONCE(conn->state, ISCSI_CONN_BOUND);
3841
3842		if (ev->r.retcode || !transport->ep_connect)
3843			break;
3844
3845		ep = iscsi_lookup_endpoint(ev->u.b_conn.transport_eph);
3846		if (ep) {
3847			ep->conn = conn;
3848			conn->ep = ep;
3849			iscsi_put_endpoint(ep);
3850		} else {
3851			err = -ENOTCONN;
3852			iscsi_cls_conn_printk(KERN_ERR, conn,
3853					      "Could not set ep conn binding\n");
3854		}
3855		break;
3856	case ISCSI_UEVENT_START_CONN:
3857		ev->r.retcode = transport->start_conn(conn);
3858		if (!ev->r.retcode)
3859			WRITE_ONCE(conn->state, ISCSI_CONN_UP);
3860
3861		break;
3862	case ISCSI_UEVENT_SEND_PDU:
3863		if ((ev->u.send_pdu.hdr_size > pdu_len) ||
3864		    (ev->u.send_pdu.data_size > (pdu_len - ev->u.send_pdu.hdr_size))) {
3865			err = -EINVAL;
3866			break;
3867		}
3868
3869		ev->r.retcode =	transport->send_pdu(conn,
3870				(struct iscsi_hdr *)((char *)ev + sizeof(*ev)),
3871				(char *)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,
3872				ev->u.send_pdu.data_size);
3873		break;
3874	default:
3875		err = -ENOSYS;
3876	}
3877
3878	mutex_unlock(&conn->ep_mutex);
3879	return err;
3880}
3881
3882static int
3883iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, uint32_t *group)
3884{
3885	int err = 0;
3886	u32 portid;
3887	struct iscsi_uevent *ev = nlmsg_data(nlh);
3888	struct iscsi_transport *transport = NULL;
3889	struct iscsi_internal *priv;
3890	struct iscsi_cls_session *session;
3891	struct iscsi_endpoint *ep = NULL;
3892	u32 rlen;
3893
3894	if (!netlink_capable(skb, CAP_SYS_ADMIN))
3895		return -EPERM;
3896
3897	if (nlh->nlmsg_type == ISCSI_UEVENT_PATH_UPDATE)
3898		*group = ISCSI_NL_GRP_UIP;
3899	else
3900		*group = ISCSI_NL_GRP_ISCSID;
3901
3902	priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle));
3903	if (!priv)
3904		return -EINVAL;
3905	transport = priv->iscsi_transport;
3906
3907	if (!try_module_get(transport->owner))
3908		return -EINVAL;
3909
3910	portid = NETLINK_CB(skb).portid;
3911
3912	/*
3913	 * Even though the remaining payload may not be regarded as nlattr,
3914	 * (like address or something else), calculate the remaining length
3915	 * here to ease following length checks.
3916	 */
3917	rlen = nlmsg_attrlen(nlh, sizeof(*ev));
3918
3919	switch (nlh->nlmsg_type) {
3920	case ISCSI_UEVENT_CREATE_SESSION:
3921		err = iscsi_if_create_session(priv, ep, ev,
3922					      portid,
3923					      ev->u.c_session.initial_cmdsn,
3924					      ev->u.c_session.cmds_max,
3925					      ev->u.c_session.queue_depth);
3926		break;
3927	case ISCSI_UEVENT_CREATE_BOUND_SESSION:
3928		ep = iscsi_lookup_endpoint(ev->u.c_bound_session.ep_handle);
3929		if (!ep) {
3930			err = -EINVAL;
3931			break;
3932		}
3933
3934		err = iscsi_if_create_session(priv, ep, ev,
3935					portid,
3936					ev->u.c_bound_session.initial_cmdsn,
3937					ev->u.c_bound_session.cmds_max,
3938					ev->u.c_bound_session.queue_depth);
3939		iscsi_put_endpoint(ep);
3940		break;
3941	case ISCSI_UEVENT_DESTROY_SESSION:
3942		session = iscsi_session_lookup(ev->u.d_session.sid);
3943		if (!session)
3944			err = -EINVAL;
3945		else if (iscsi_session_has_conns(ev->u.d_session.sid))
3946			err = -EBUSY;
3947		else
3948			transport->destroy_session(session);
3949		break;
3950	case ISCSI_UEVENT_DESTROY_SESSION_ASYNC:
3951		session = iscsi_session_lookup(ev->u.d_session.sid);
3952		if (!session)
3953			err = -EINVAL;
3954		else if (iscsi_session_has_conns(ev->u.d_session.sid))
3955			err = -EBUSY;
3956		else {
3957			unsigned long flags;
3958
3959			/* Prevent this session from being found again */
3960			spin_lock_irqsave(&sesslock, flags);
3961			list_del_init(&session->sess_list);
3962			spin_unlock_irqrestore(&sesslock, flags);
3963
3964			queue_work(system_dfl_wq, &session->destroy_work);
3965		}
3966		break;
3967	case ISCSI_UEVENT_UNBIND_SESSION:
3968		session = iscsi_session_lookup(ev->u.d_session.sid);
3969		if (session)
3970			queue_work(session->workq, &session->unbind_work);
3971		else
3972			err = -EINVAL;
3973		break;
3974	case ISCSI_UEVENT_SET_PARAM:
3975		err = iscsi_if_set_param(transport, ev, rlen);
3976		break;
3977	case ISCSI_UEVENT_CREATE_CONN:
3978	case ISCSI_UEVENT_DESTROY_CONN:
3979	case ISCSI_UEVENT_STOP_CONN:
3980	case ISCSI_UEVENT_START_CONN:
3981	case ISCSI_UEVENT_BIND_CONN:
3982	case ISCSI_UEVENT_SEND_PDU:
3983		err = iscsi_if_transport_conn(transport, nlh, rlen);
3984		break;
3985	case ISCSI_UEVENT_GET_STATS:
3986		err = iscsi_if_get_stats(transport, nlh);
3987		break;
3988	case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
3989	case ISCSI_UEVENT_TRANSPORT_EP_POLL:
3990	case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
3991	case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST:
3992		err = iscsi_if_transport_ep(transport, ev, nlh->nlmsg_type, rlen);
3993		break;
3994	case ISCSI_UEVENT_TGT_DSCVR:
3995		err = iscsi_tgt_dscvr(transport, ev, rlen);
3996		break;
3997	case ISCSI_UEVENT_SET_HOST_PARAM:
3998		err = iscsi_set_host_param(transport, ev, rlen);
3999		break;
4000	case ISCSI_UEVENT_PATH_UPDATE:
4001		err = iscsi_set_path(transport, ev, rlen);
4002		break;
4003	case ISCSI_UEVENT_SET_IFACE_PARAMS:
4004		err = iscsi_set_iface_params(transport, ev, rlen);
4005		break;
4006	case ISCSI_UEVENT_PING:
4007		err = iscsi_send_ping(transport, ev, rlen);
4008		break;
4009	case ISCSI_UEVENT_GET_CHAP:
4010		err = iscsi_get_chap(transport, nlh);
4011		break;
4012	case ISCSI_UEVENT_DELETE_CHAP:
4013		err = iscsi_delete_chap(transport, ev);
4014		break;
4015	case ISCSI_UEVENT_SET_FLASHNODE_PARAMS:
4016		err = iscsi_set_flashnode_param(transport, ev, rlen);
4017		break;
4018	case ISCSI_UEVENT_NEW_FLASHNODE:
4019		err = iscsi_new_flashnode(transport, ev, rlen);
4020		break;
4021	case ISCSI_UEVENT_DEL_FLASHNODE:
4022		err = iscsi_del_flashnode(transport, ev);
4023		break;
4024	case ISCSI_UEVENT_LOGIN_FLASHNODE:
4025		err = iscsi_login_flashnode(transport, ev);
4026		break;
4027	case ISCSI_UEVENT_LOGOUT_FLASHNODE:
4028		err = iscsi_logout_flashnode(transport, ev);
4029		break;
4030	case ISCSI_UEVENT_LOGOUT_FLASHNODE_SID:
4031		err = iscsi_logout_flashnode_sid(transport, ev);
4032		break;
4033	case ISCSI_UEVENT_SET_CHAP:
4034		err = iscsi_set_chap(transport, ev, rlen);
4035		break;
4036	case ISCSI_UEVENT_GET_HOST_STATS:
4037		err = iscsi_get_host_stats(transport, nlh);
4038		break;
4039	default:
4040		err = -ENOSYS;
4041		break;
4042	}
4043
4044	module_put(transport->owner);
4045	return err;
4046}
4047
4048/*
4049 * Get message from skb.  Each message is processed by iscsi_if_recv_msg.
4050 * Malformed skbs with wrong lengths or invalid creds are not processed.
4051 */
4052static void
4053iscsi_if_rx(struct sk_buff *skb)
4054{
4055	u32 portid = NETLINK_CB(skb).portid;
4056
4057	mutex_lock(&rx_queue_mutex);
4058	while (skb->len >= NLMSG_HDRLEN) {
4059		int err;
4060		uint32_t rlen;
4061		struct nlmsghdr	*nlh;
4062		struct iscsi_uevent *ev;
4063		uint32_t group;
4064		int retries = ISCSI_SEND_MAX_ALLOWED;
4065
4066		nlh = nlmsg_hdr(skb);
4067		if (nlh->nlmsg_len < sizeof(*nlh) + sizeof(*ev) ||
4068		    skb->len < nlh->nlmsg_len) {
4069			break;
4070		}
4071
4072		ev = nlmsg_data(nlh);
4073		rlen = NLMSG_ALIGN(nlh->nlmsg_len);
4074		if (rlen > skb->len)
4075			rlen = skb->len;
4076
4077		err = iscsi_if_recv_msg(skb, nlh, &group);
4078		if (err) {
4079			ev->type = ISCSI_KEVENT_IF_ERROR;
4080			ev->iferror = err;
4081		}
4082		do {
4083			/*
4084			 * special case for GET_STATS, GET_CHAP and GET_HOST_STATS:
4085			 * on success - sending reply and stats from
4086			 * inside of if_recv_msg(),
4087			 * on error - fall through.
4088			 */
4089			if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
4090				break;
4091			if (ev->type == ISCSI_UEVENT_GET_CHAP && !err)
4092				break;
4093			if (ev->type == ISCSI_UEVENT_GET_HOST_STATS && !err)
4094				break;
4095			err = iscsi_if_send_reply(portid, nlh->nlmsg_type,
4096						  ev, sizeof(*ev));
4097			if (err == -EAGAIN && --retries < 0) {
4098				printk(KERN_WARNING "Send reply failed, error %d\n", err);
4099				break;
4100			}
4101		} while (err < 0 && err != -ECONNREFUSED && err != -ESRCH);
4102		skb_pull(skb, rlen);
4103	}
4104	mutex_unlock(&rx_queue_mutex);
4105}
4106
4107#define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store)		\
4108struct device_attribute dev_attr_##_prefix##_##_name =	\
4109	__ATTR(_name,_mode,_show,_store)
4110
4111/*
4112 * iSCSI connection attrs
4113 */
4114#define iscsi_conn_attr_show(param)					\
4115static ssize_t								\
4116show_conn_param_##param(struct device *dev, 				\
4117			struct device_attribute *attr, char *buf)	\
4118{									\
4119	struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent);	\
4120	struct iscsi_transport *t = conn->transport;			\
4121	return t->get_conn_param(conn, param, buf);			\
4122}
4123
4124#define iscsi_conn_attr(field, param)					\
4125	iscsi_conn_attr_show(param)					\
4126static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param,	\
4127			NULL);
4128
4129iscsi_conn_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH);
4130iscsi_conn_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH);
4131iscsi_conn_attr(header_digest, ISCSI_PARAM_HDRDGST_EN);
4132iscsi_conn_attr(data_digest, ISCSI_PARAM_DATADGST_EN);
4133iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN);
4134iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN);
4135iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT);
4136iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN);
4137iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS);
4138iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);
4139iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);
4140iscsi_conn_attr(local_port, ISCSI_PARAM_LOCAL_PORT);
4141iscsi_conn_attr(statsn, ISCSI_PARAM_STATSN);
4142iscsi_conn_attr(keepalive_tmo, ISCSI_PARAM_KEEPALIVE_TMO);
4143iscsi_conn_attr(max_segment_size, ISCSI_PARAM_MAX_SEGMENT_SIZE);
4144iscsi_conn_attr(tcp_timestamp_stat, ISCSI_PARAM_TCP_TIMESTAMP_STAT);
4145iscsi_conn_attr(tcp_wsf_disable, ISCSI_PARAM_TCP_WSF_DISABLE);
4146iscsi_conn_attr(tcp_nagle_disable, ISCSI_PARAM_TCP_NAGLE_DISABLE);
4147iscsi_conn_attr(tcp_timer_scale, ISCSI_PARAM_TCP_TIMER_SCALE);
4148iscsi_conn_attr(tcp_timestamp_enable, ISCSI_PARAM_TCP_TIMESTAMP_EN);
4149iscsi_conn_attr(fragment_disable, ISCSI_PARAM_IP_FRAGMENT_DISABLE);
4150iscsi_conn_attr(ipv4_tos, ISCSI_PARAM_IPV4_TOS);
4151iscsi_conn_attr(ipv6_traffic_class, ISCSI_PARAM_IPV6_TC);
4152iscsi_conn_attr(ipv6_flow_label, ISCSI_PARAM_IPV6_FLOW_LABEL);
4153iscsi_conn_attr(is_fw_assigned_ipv6, ISCSI_PARAM_IS_FW_ASSIGNED_IPV6);
4154iscsi_conn_attr(tcp_xmit_wsf, ISCSI_PARAM_TCP_XMIT_WSF);
4155iscsi_conn_attr(tcp_recv_wsf, ISCSI_PARAM_TCP_RECV_WSF);
4156iscsi_conn_attr(local_ipaddr, ISCSI_PARAM_LOCAL_IPADDR);
4157
4158static const char *const connection_state_names[] = {
4159	[ISCSI_CONN_UP] = "up",
4160	[ISCSI_CONN_DOWN] = "down",
4161	[ISCSI_CONN_FAILED] = "failed",
4162	[ISCSI_CONN_BOUND] = "bound"
4163};
4164
4165static ssize_t show_conn_state(struct device *dev,
4166			       struct device_attribute *attr, char *buf)
4167{
4168	struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent);
4169	const char *state = "unknown";
4170	int conn_state = READ_ONCE(conn->state);
4171
4172	if (conn_state >= 0 &&
4173	    conn_state < ARRAY_SIZE(connection_state_names))
4174		state = connection_state_names[conn_state];
4175
4176	return sysfs_emit(buf, "%s\n", state);
4177}
4178static ISCSI_CLASS_ATTR(conn, state, S_IRUGO, show_conn_state,
4179			NULL);
4180
4181#define iscsi_conn_ep_attr_show(param)					\
4182static ssize_t show_conn_ep_param_##param(struct device *dev,		\
4183					  struct device_attribute *attr,\
4184					  char *buf)			\
4185{									\
4186	struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent);	\
4187	struct iscsi_transport *t = conn->transport;			\
4188	struct iscsi_endpoint *ep;					\
4189	ssize_t rc;							\
4190									\
4191	/*								\
4192	 * Need to make sure ep_disconnect does not free the LLD's	\
4193	 * interconnect resources while we are trying to read them.	\
4194	 */								\
4195	mutex_lock(&conn->ep_mutex);					\
4196	ep = conn->ep;							\
4197	if (!ep && t->ep_connect) {					\
4198		mutex_unlock(&conn->ep_mutex);				\
4199		return -ENOTCONN;					\
4200	}								\
4201									\
4202	if (ep)								\
4203		rc = t->get_ep_param(ep, param, buf);			\
4204	else								\
4205		rc = t->get_conn_param(conn, param, buf);		\
4206	mutex_unlock(&conn->ep_mutex);					\
4207	return rc;							\
4208}
4209
4210#define iscsi_conn_ep_attr(field, param)				\
4211	iscsi_conn_ep_attr_show(param)					\
4212static ISCSI_CLASS_ATTR(conn, field, S_IRUGO,				\
4213			show_conn_ep_param_##param, NULL);
4214
4215iscsi_conn_ep_attr(address, ISCSI_PARAM_CONN_ADDRESS);
4216iscsi_conn_ep_attr(port, ISCSI_PARAM_CONN_PORT);
4217
4218static struct attribute *iscsi_conn_attrs[] = {
4219	&dev_attr_conn_max_recv_dlength.attr,
4220	&dev_attr_conn_max_xmit_dlength.attr,
4221	&dev_attr_conn_header_digest.attr,
4222	&dev_attr_conn_data_digest.attr,
4223	&dev_attr_conn_ifmarker.attr,
4224	&dev_attr_conn_ofmarker.attr,
4225	&dev_attr_conn_address.attr,
4226	&dev_attr_conn_port.attr,
4227	&dev_attr_conn_exp_statsn.attr,
4228	&dev_attr_conn_persistent_address.attr,
4229	&dev_attr_conn_persistent_port.attr,
4230	&dev_attr_conn_ping_tmo.attr,
4231	&dev_attr_conn_recv_tmo.attr,
4232	&dev_attr_conn_local_port.attr,
4233	&dev_attr_conn_statsn.attr,
4234	&dev_attr_conn_keepalive_tmo.attr,
4235	&dev_attr_conn_max_segment_size.attr,
4236	&dev_attr_conn_tcp_timestamp_stat.attr,
4237	&dev_attr_conn_tcp_wsf_disable.attr,
4238	&dev_attr_conn_tcp_nagle_disable.attr,
4239	&dev_attr_conn_tcp_timer_scale.attr,
4240	&dev_attr_conn_tcp_timestamp_enable.attr,
4241	&dev_attr_conn_fragment_disable.attr,
4242	&dev_attr_conn_ipv4_tos.attr,
4243	&dev_attr_conn_ipv6_traffic_class.attr,
4244	&dev_attr_conn_ipv6_flow_label.attr,
4245	&dev_attr_conn_is_fw_assigned_ipv6.attr,
4246	&dev_attr_conn_tcp_xmit_wsf.attr,
4247	&dev_attr_conn_tcp_recv_wsf.attr,
4248	&dev_attr_conn_local_ipaddr.attr,
4249	&dev_attr_conn_state.attr,
4250	NULL,
4251};
4252
4253static umode_t iscsi_conn_attr_is_visible(struct kobject *kobj,
4254					 struct attribute *attr, int i)
4255{
4256	struct device *cdev = container_of(kobj, struct device, kobj);
4257	struct iscsi_cls_conn *conn = transport_class_to_conn(cdev);
4258	struct iscsi_transport *t = conn->transport;
4259	int param;
4260
4261	if (attr == &dev_attr_conn_max_recv_dlength.attr)
4262		param = ISCSI_PARAM_MAX_RECV_DLENGTH;
4263	else if (attr == &dev_attr_conn_max_xmit_dlength.attr)
4264		param = ISCSI_PARAM_MAX_XMIT_DLENGTH;
4265	else if (attr == &dev_attr_conn_header_digest.attr)
4266		param = ISCSI_PARAM_HDRDGST_EN;
4267	else if (attr == &dev_attr_conn_data_digest.attr)
4268		param = ISCSI_PARAM_DATADGST_EN;
4269	else if (attr == &dev_attr_conn_ifmarker.attr)
4270		param = ISCSI_PARAM_IFMARKER_EN;
4271	else if (attr == &dev_attr_conn_ofmarker.attr)
4272		param = ISCSI_PARAM_OFMARKER_EN;
4273	else if (attr == &dev_attr_conn_address.attr)
4274		param = ISCSI_PARAM_CONN_ADDRESS;
4275	else if (attr == &dev_attr_conn_port.attr)
4276		param = ISCSI_PARAM_CONN_PORT;
4277	else if (attr == &dev_attr_conn_exp_statsn.attr)
4278		param = ISCSI_PARAM_EXP_STATSN;
4279	else if (attr == &dev_attr_conn_persistent_address.attr)
4280		param = ISCSI_PARAM_PERSISTENT_ADDRESS;
4281	else if (attr == &dev_attr_conn_persistent_port.attr)
4282		param = ISCSI_PARAM_PERSISTENT_PORT;
4283	else if (attr == &dev_attr_conn_ping_tmo.attr)
4284		param = ISCSI_PARAM_PING_TMO;
4285	else if (attr == &dev_attr_conn_recv_tmo.attr)
4286		param = ISCSI_PARAM_RECV_TMO;
4287	else if (attr == &dev_attr_conn_local_port.attr)
4288		param = ISCSI_PARAM_LOCAL_PORT;
4289	else if (attr == &dev_attr_conn_statsn.attr)
4290		param = ISCSI_PARAM_STATSN;
4291	else if (attr == &dev_attr_conn_keepalive_tmo.attr)
4292		param = ISCSI_PARAM_KEEPALIVE_TMO;
4293	else if (attr == &dev_attr_conn_max_segment_size.attr)
4294		param = ISCSI_PARAM_MAX_SEGMENT_SIZE;
4295	else if (attr == &dev_attr_conn_tcp_timestamp_stat.attr)
4296		param = ISCSI_PARAM_TCP_TIMESTAMP_STAT;
4297	else if (attr == &dev_attr_conn_tcp_wsf_disable.attr)
4298		param = ISCSI_PARAM_TCP_WSF_DISABLE;
4299	else if (attr == &dev_attr_conn_tcp_nagle_disable.attr)
4300		param = ISCSI_PARAM_TCP_NAGLE_DISABLE;
4301	else if (attr == &dev_attr_conn_tcp_timer_scale.attr)
4302		param = ISCSI_PARAM_TCP_TIMER_SCALE;
4303	else if (attr == &dev_attr_conn_tcp_timestamp_enable.attr)
4304		param = ISCSI_PARAM_TCP_TIMESTAMP_EN;
4305	else if (attr == &dev_attr_conn_fragment_disable.attr)
4306		param = ISCSI_PARAM_IP_FRAGMENT_DISABLE;
4307	else if (attr == &dev_attr_conn_ipv4_tos.attr)
4308		param = ISCSI_PARAM_IPV4_TOS;
4309	else if (attr == &dev_attr_conn_ipv6_traffic_class.attr)
4310		param = ISCSI_PARAM_IPV6_TC;
4311	else if (attr == &dev_attr_conn_ipv6_flow_label.attr)
4312		param = ISCSI_PARAM_IPV6_FLOW_LABEL;
4313	else if (attr == &dev_attr_conn_is_fw_assigned_ipv6.attr)
4314		param = ISCSI_PARAM_IS_FW_ASSIGNED_IPV6;
4315	else if (attr == &dev_attr_conn_tcp_xmit_wsf.attr)
4316		param = ISCSI_PARAM_TCP_XMIT_WSF;
4317	else if (attr == &dev_attr_conn_tcp_recv_wsf.attr)
4318		param = ISCSI_PARAM_TCP_RECV_WSF;
4319	else if (attr == &dev_attr_conn_local_ipaddr.attr)
4320		param = ISCSI_PARAM_LOCAL_IPADDR;
4321	else if (attr == &dev_attr_conn_state.attr)
4322		return S_IRUGO;
4323	else {
4324		WARN_ONCE(1, "Invalid conn attr");
4325		return 0;
4326	}
4327
4328	return t->attr_is_visible(ISCSI_PARAM, param);
4329}
4330
4331static struct attribute_group iscsi_conn_group = {
4332	.attrs = iscsi_conn_attrs,
4333	.is_visible = iscsi_conn_attr_is_visible,
4334};
4335
4336/*
4337 * iSCSI session attrs
4338 */
4339#define iscsi_session_attr_show(param, perm)				\
4340static ssize_t								\
4341show_session_param_##param(struct device *dev,				\
4342			   struct device_attribute *attr, char *buf)	\
4343{									\
4344	struct iscsi_cls_session *session = 				\
4345		iscsi_dev_to_session(dev->parent);			\
4346	struct iscsi_transport *t = session->transport;			\
4347									\
4348	if (perm && !capable(CAP_SYS_ADMIN))				\
4349		return -EACCES;						\
4350	return t->get_session_param(session, param, buf);		\
4351}
4352
4353#define iscsi_session_attr(field, param, perm)				\
4354	iscsi_session_attr_show(param, perm)				\
4355static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
4356			NULL);
4357iscsi_session_attr(targetname, ISCSI_PARAM_TARGET_NAME, 0);
4358iscsi_session_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN, 0);
4359iscsi_session_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T, 0);
4360iscsi_session_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN, 0);
4361iscsi_session_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST, 0);
4362iscsi_session_attr(max_burst_len, ISCSI_PARAM_MAX_BURST, 0);
4363iscsi_session_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN, 0);
4364iscsi_session_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN, 0);
4365iscsi_session_attr(erl, ISCSI_PARAM_ERL, 0);
4366iscsi_session_attr(tpgt, ISCSI_PARAM_TPGT, 0);
4367iscsi_session_attr(username, ISCSI_PARAM_USERNAME, 1);
4368iscsi_session_attr(username_in, ISCSI_PARAM_USERNAME_IN, 1);
4369iscsi_session_attr(password, ISCSI_PARAM_PASSWORD, 1);
4370iscsi_session_attr(password_in, ISCSI_PARAM_PASSWORD_IN, 1);
4371iscsi_session_attr(chap_out_idx, ISCSI_PARAM_CHAP_OUT_IDX, 1);
4372iscsi_session_attr(chap_in_idx, ISCSI_PARAM_CHAP_IN_IDX, 1);
4373iscsi_session_attr(fast_abort, ISCSI_PARAM_FAST_ABORT, 0);
4374iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0);
4375iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0);
4376iscsi_session_attr(tgt_reset_tmo, ISCSI_PARAM_TGT_RESET_TMO, 0);
4377iscsi_session_attr(ifacename, ISCSI_PARAM_IFACE_NAME, 0);
4378iscsi_session_attr(initiatorname, ISCSI_PARAM_INITIATOR_NAME, 0);
4379iscsi_session_attr(targetalias, ISCSI_PARAM_TARGET_ALIAS, 0);
4380iscsi_session_attr(boot_root, ISCSI_PARAM_BOOT_ROOT, 0);
4381iscsi_session_attr(boot_nic, ISCSI_PARAM_BOOT_NIC, 0);
4382iscsi_session_attr(boot_target, ISCSI_PARAM_BOOT_TARGET, 0);
4383iscsi_session_attr(auto_snd_tgt_disable, ISCSI_PARAM_AUTO_SND_TGT_DISABLE, 0);
4384iscsi_session_attr(discovery_session, ISCSI_PARAM_DISCOVERY_SESS, 0);
4385iscsi_session_attr(portal_type, ISCSI_PARAM_PORTAL_TYPE, 0);
4386iscsi_session_attr(chap_auth, ISCSI_PARAM_CHAP_AUTH_EN, 0);
4387iscsi_session_attr(discovery_logout, ISCSI_PARAM_DISCOVERY_LOGOUT_EN, 0);
4388iscsi_session_attr(bidi_chap, ISCSI_PARAM_BIDI_CHAP_EN, 0);
4389iscsi_session_attr(discovery_auth_optional,
4390		   ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL, 0);
4391iscsi_session_attr(def_time2wait, ISCSI_PARAM_DEF_TIME2WAIT, 0);
4392iscsi_session_attr(def_time2retain, ISCSI_PARAM_DEF_TIME2RETAIN, 0);
4393iscsi_session_attr(isid, ISCSI_PARAM_ISID, 0);
4394iscsi_session_attr(tsid, ISCSI_PARAM_TSID, 0);
4395iscsi_session_attr(def_taskmgmt_tmo, ISCSI_PARAM_DEF_TASKMGMT_TMO, 0);
4396iscsi_session_attr(discovery_parent_idx, ISCSI_PARAM_DISCOVERY_PARENT_IDX, 0);
4397iscsi_session_attr(discovery_parent_type, ISCSI_PARAM_DISCOVERY_PARENT_TYPE, 0);
4398
4399static ssize_t
4400show_priv_session_target_state(struct device *dev, struct device_attribute *attr,
4401			char *buf)
4402{
4403	struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
4404
4405	return sysfs_emit(buf, "%s\n",
4406			iscsi_session_target_state_name[session->target_state]);
4407}
4408
4409static ISCSI_CLASS_ATTR(priv_sess, target_state, S_IRUGO,
4410			show_priv_session_target_state, NULL);
4411
4412static ssize_t
4413show_priv_session_state(struct device *dev, struct device_attribute *attr,
4414			char *buf)
4415{
4416	struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
4417	return sysfs_emit(buf, "%s\n", iscsi_session_state_name(session->state));
4418}
4419static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
4420			NULL);
4421static ssize_t
4422show_priv_session_creator(struct device *dev, struct device_attribute *attr,
4423			char *buf)
4424{
4425	struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
4426	return sysfs_emit(buf, "%d\n", session->creator);
4427}
4428static ISCSI_CLASS_ATTR(priv_sess, creator, S_IRUGO, show_priv_session_creator,
4429			NULL);
4430static ssize_t
4431show_priv_session_target_id(struct device *dev, struct device_attribute *attr,
4432			    char *buf)
4433{
4434	struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
4435	return sysfs_emit(buf, "%d\n", session->target_id);
4436}
4437static ISCSI_CLASS_ATTR(priv_sess, target_id, S_IRUGO,
4438			show_priv_session_target_id, NULL);
4439
4440#define iscsi_priv_session_attr_show(field, format)			\
4441static ssize_t								\
4442show_priv_session_##field(struct device *dev, 				\
4443			  struct device_attribute *attr, char *buf)	\
4444{									\
4445	struct iscsi_cls_session *session = 				\
4446			iscsi_dev_to_session(dev->parent);		\
4447	if (session->field == -1)					\
4448		return sysfs_emit(buf, "off\n");			\
4449	return sysfs_emit(buf, format"\n", session->field);		\
4450}
4451
4452#define iscsi_priv_session_attr_store(field)				\
4453static ssize_t								\
4454store_priv_session_##field(struct device *dev,				\
4455			   struct device_attribute *attr,		\
4456			   const char *buf, size_t count)		\
4457{									\
4458	int val;							\
4459	char *cp;							\
4460	struct iscsi_cls_session *session =				\
4461		iscsi_dev_to_session(dev->parent);			\
4462	if ((session->state == ISCSI_SESSION_FREE) ||			\
4463	    (session->state == ISCSI_SESSION_FAILED))			\
4464		return -EBUSY;						\
4465	if (strncmp(buf, "off", 3) == 0) {				\
4466		session->field = -1;					\
4467		session->field##_sysfs_override = true;			\
4468	} else {							\
4469		val = simple_strtoul(buf, &cp, 0);			\
4470		if (*cp != '\0' && *cp != '\n')				\
4471			return -EINVAL;					\
4472		session->field = val;					\
4473		session->field##_sysfs_override = true;			\
4474	}								\
4475	return count;							\
4476}
4477
4478#define iscsi_priv_session_rw_attr(field, format)			\
4479	iscsi_priv_session_attr_show(field, format)			\
4480	iscsi_priv_session_attr_store(field)				\
4481static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO | S_IWUSR,		\
4482			show_priv_session_##field,			\
4483			store_priv_session_##field)
4484
4485iscsi_priv_session_rw_attr(recovery_tmo, "%d");
4486
4487static struct attribute *iscsi_session_attrs[] = {
4488	&dev_attr_sess_initial_r2t.attr,
4489	&dev_attr_sess_max_outstanding_r2t.attr,
4490	&dev_attr_sess_immediate_data.attr,
4491	&dev_attr_sess_first_burst_len.attr,
4492	&dev_attr_sess_max_burst_len.attr,
4493	&dev_attr_sess_data_pdu_in_order.attr,
4494	&dev_attr_sess_data_seq_in_order.attr,
4495	&dev_attr_sess_erl.attr,
4496	&dev_attr_sess_targetname.attr,
4497	&dev_attr_sess_tpgt.attr,
4498	&dev_attr_sess_password.attr,
4499	&dev_attr_sess_password_in.attr,
4500	&dev_attr_sess_username.attr,
4501	&dev_attr_sess_username_in.attr,
4502	&dev_attr_sess_fast_abort.attr,
4503	&dev_attr_sess_abort_tmo.attr,
4504	&dev_attr_sess_lu_reset_tmo.attr,
4505	&dev_attr_sess_tgt_reset_tmo.attr,
4506	&dev_attr_sess_ifacename.attr,
4507	&dev_attr_sess_initiatorname.attr,
4508	&dev_attr_sess_targetalias.attr,
4509	&dev_attr_sess_boot_root.attr,
4510	&dev_attr_sess_boot_nic.attr,
4511	&dev_attr_sess_boot_target.attr,
4512	&dev_attr_priv_sess_recovery_tmo.attr,
4513	&dev_attr_priv_sess_state.attr,
4514	&dev_attr_priv_sess_target_state.attr,
4515	&dev_attr_priv_sess_creator.attr,
4516	&dev_attr_sess_chap_out_idx.attr,
4517	&dev_attr_sess_chap_in_idx.attr,
4518	&dev_attr_priv_sess_target_id.attr,
4519	&dev_attr_sess_auto_snd_tgt_disable.attr,
4520	&dev_attr_sess_discovery_session.attr,
4521	&dev_attr_sess_portal_type.attr,
4522	&dev_attr_sess_chap_auth.attr,
4523	&dev_attr_sess_discovery_logout.attr,
4524	&dev_attr_sess_bidi_chap.attr,
4525	&dev_attr_sess_discovery_auth_optional.attr,
4526	&dev_attr_sess_def_time2wait.attr,
4527	&dev_attr_sess_def_time2retain.attr,
4528	&dev_attr_sess_isid.attr,
4529	&dev_attr_sess_tsid.attr,
4530	&dev_attr_sess_def_taskmgmt_tmo.attr,
4531	&dev_attr_sess_discovery_parent_idx.attr,
4532	&dev_attr_sess_discovery_parent_type.attr,
4533	NULL,
4534};
4535
4536static umode_t iscsi_session_attr_is_visible(struct kobject *kobj,
4537					    struct attribute *attr, int i)
4538{
4539	struct device *cdev = container_of(kobj, struct device, kobj);
4540	struct iscsi_cls_session *session = transport_class_to_session(cdev);
4541	struct iscsi_transport *t = session->transport;
4542	int param;
4543
4544	if (attr == &dev_attr_sess_initial_r2t.attr)
4545		param = ISCSI_PARAM_INITIAL_R2T_EN;
4546	else if (attr == &dev_attr_sess_max_outstanding_r2t.attr)
4547		param = ISCSI_PARAM_MAX_R2T;
4548	else if (attr == &dev_attr_sess_immediate_data.attr)
4549		param = ISCSI_PARAM_IMM_DATA_EN;
4550	else if (attr == &dev_attr_sess_first_burst_len.attr)
4551		param = ISCSI_PARAM_FIRST_BURST;
4552	else if (attr == &dev_attr_sess_max_burst_len.attr)
4553		param = ISCSI_PARAM_MAX_BURST;
4554	else if (attr == &dev_attr_sess_data_pdu_in_order.attr)
4555		param = ISCSI_PARAM_PDU_INORDER_EN;
4556	else if (attr == &dev_attr_sess_data_seq_in_order.attr)
4557		param = ISCSI_PARAM_DATASEQ_INORDER_EN;
4558	else if (attr == &dev_attr_sess_erl.attr)
4559		param = ISCSI_PARAM_ERL;
4560	else if (attr == &dev_attr_sess_targetname.attr)
4561		param = ISCSI_PARAM_TARGET_NAME;
4562	else if (attr == &dev_attr_sess_tpgt.attr)
4563		param = ISCSI_PARAM_TPGT;
4564	else if (attr == &dev_attr_sess_chap_in_idx.attr)
4565		param = ISCSI_PARAM_CHAP_IN_IDX;
4566	else if (attr == &dev_attr_sess_chap_out_idx.attr)
4567		param = ISCSI_PARAM_CHAP_OUT_IDX;
4568	else if (attr == &dev_attr_sess_password.attr)
4569		param = ISCSI_PARAM_USERNAME;
4570	else if (attr == &dev_attr_sess_password_in.attr)
4571		param = ISCSI_PARAM_USERNAME_IN;
4572	else if (attr == &dev_attr_sess_username.attr)
4573		param = ISCSI_PARAM_PASSWORD;
4574	else if (attr == &dev_attr_sess_username_in.attr)
4575		param = ISCSI_PARAM_PASSWORD_IN;
4576	else if (attr == &dev_attr_sess_fast_abort.attr)
4577		param = ISCSI_PARAM_FAST_ABORT;
4578	else if (attr == &dev_attr_sess_abort_tmo.attr)
4579		param = ISCSI_PARAM_ABORT_TMO;
4580	else if (attr == &dev_attr_sess_lu_reset_tmo.attr)
4581		param = ISCSI_PARAM_LU_RESET_TMO;
4582	else if (attr == &dev_attr_sess_tgt_reset_tmo.attr)
4583		param = ISCSI_PARAM_TGT_RESET_TMO;
4584	else if (attr == &dev_attr_sess_ifacename.attr)
4585		param = ISCSI_PARAM_IFACE_NAME;
4586	else if (attr == &dev_attr_sess_initiatorname.attr)
4587		param = ISCSI_PARAM_INITIATOR_NAME;
4588	else if (attr == &dev_attr_sess_targetalias.attr)
4589		param = ISCSI_PARAM_TARGET_ALIAS;
4590	else if (attr == &dev_attr_sess_boot_root.attr)
4591		param = ISCSI_PARAM_BOOT_ROOT;
4592	else if (attr == &dev_attr_sess_boot_nic.attr)
4593		param = ISCSI_PARAM_BOOT_NIC;
4594	else if (attr == &dev_attr_sess_boot_target.attr)
4595		param = ISCSI_PARAM_BOOT_TARGET;
4596	else if (attr == &dev_attr_sess_auto_snd_tgt_disable.attr)
4597		param = ISCSI_PARAM_AUTO_SND_TGT_DISABLE;
4598	else if (attr == &dev_attr_sess_discovery_session.attr)
4599		param = ISCSI_PARAM_DISCOVERY_SESS;
4600	else if (attr == &dev_attr_sess_portal_type.attr)
4601		param = ISCSI_PARAM_PORTAL_TYPE;
4602	else if (attr == &dev_attr_sess_chap_auth.attr)
4603		param = ISCSI_PARAM_CHAP_AUTH_EN;
4604	else if (attr == &dev_attr_sess_discovery_logout.attr)
4605		param = ISCSI_PARAM_DISCOVERY_LOGOUT_EN;
4606	else if (attr == &dev_attr_sess_bidi_chap.attr)
4607		param = ISCSI_PARAM_BIDI_CHAP_EN;
4608	else if (attr == &dev_attr_sess_discovery_auth_optional.attr)
4609		param = ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL;
4610	else if (attr == &dev_attr_sess_def_time2wait.attr)
4611		param = ISCSI_PARAM_DEF_TIME2WAIT;
4612	else if (attr == &dev_attr_sess_def_time2retain.attr)
4613		param = ISCSI_PARAM_DEF_TIME2RETAIN;
4614	else if (attr == &dev_attr_sess_isid.attr)
4615		param = ISCSI_PARAM_ISID;
4616	else if (attr == &dev_attr_sess_tsid.attr)
4617		param = ISCSI_PARAM_TSID;
4618	else if (attr == &dev_attr_sess_def_taskmgmt_tmo.attr)
4619		param = ISCSI_PARAM_DEF_TASKMGMT_TMO;
4620	else if (attr == &dev_attr_sess_discovery_parent_idx.attr)
4621		param = ISCSI_PARAM_DISCOVERY_PARENT_IDX;
4622	else if (attr == &dev_attr_sess_discovery_parent_type.attr)
4623		param = ISCSI_PARAM_DISCOVERY_PARENT_TYPE;
4624	else if (attr == &dev_attr_priv_sess_recovery_tmo.attr)
4625		return S_IRUGO | S_IWUSR;
4626	else if (attr == &dev_attr_priv_sess_state.attr)
4627		return S_IRUGO;
4628	else if (attr == &dev_attr_priv_sess_target_state.attr)
4629		return S_IRUGO;
4630	else if (attr == &dev_attr_priv_sess_creator.attr)
4631		return S_IRUGO;
4632	else if (attr == &dev_attr_priv_sess_target_id.attr)
4633		return S_IRUGO;
4634	else {
4635		WARN_ONCE(1, "Invalid session attr");
4636		return 0;
4637	}
4638
4639	return t->attr_is_visible(ISCSI_PARAM, param);
4640}
4641
4642static struct attribute_group iscsi_session_group = {
4643	.attrs = iscsi_session_attrs,
4644	.is_visible = iscsi_session_attr_is_visible,
4645};
4646
4647/*
4648 * iSCSI host attrs
4649 */
4650#define iscsi_host_attr_show(param)					\
4651static ssize_t								\
4652show_host_param_##param(struct device *dev, 				\
4653			struct device_attribute *attr, char *buf)	\
4654{									\
4655	struct Scsi_Host *shost = transport_class_to_shost(dev);	\
4656	struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
4657	return priv->iscsi_transport->get_host_param(shost, param, buf); \
4658}
4659
4660#define iscsi_host_attr(field, param)					\
4661	iscsi_host_attr_show(param)					\
4662static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param,	\
4663			NULL);
4664
4665iscsi_host_attr(netdev, ISCSI_HOST_PARAM_NETDEV_NAME);
4666iscsi_host_attr(hwaddress, ISCSI_HOST_PARAM_HWADDRESS);
4667iscsi_host_attr(ipaddress, ISCSI_HOST_PARAM_IPADDRESS);
4668iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME);
4669iscsi_host_attr(port_state, ISCSI_HOST_PARAM_PORT_STATE);
4670iscsi_host_attr(port_speed, ISCSI_HOST_PARAM_PORT_SPEED);
4671
4672static struct attribute *iscsi_host_attrs[] = {
4673	&dev_attr_host_netdev.attr,
4674	&dev_attr_host_hwaddress.attr,
4675	&dev_attr_host_ipaddress.attr,
4676	&dev_attr_host_initiatorname.attr,
4677	&dev_attr_host_port_state.attr,
4678	&dev_attr_host_port_speed.attr,
4679	NULL,
4680};
4681
4682static umode_t iscsi_host_attr_is_visible(struct kobject *kobj,
4683					 struct attribute *attr, int i)
4684{
4685	struct device *cdev = container_of(kobj, struct device, kobj);
4686	struct Scsi_Host *shost = transport_class_to_shost(cdev);
4687	struct iscsi_internal *priv = to_iscsi_internal(shost->transportt);
4688	int param;
4689
4690	if (attr == &dev_attr_host_netdev.attr)
4691		param = ISCSI_HOST_PARAM_NETDEV_NAME;
4692	else if (attr == &dev_attr_host_hwaddress.attr)
4693		param = ISCSI_HOST_PARAM_HWADDRESS;
4694	else if (attr == &dev_attr_host_ipaddress.attr)
4695		param = ISCSI_HOST_PARAM_IPADDRESS;
4696	else if (attr == &dev_attr_host_initiatorname.attr)
4697		param = ISCSI_HOST_PARAM_INITIATOR_NAME;
4698	else if (attr == &dev_attr_host_port_state.attr)
4699		param = ISCSI_HOST_PARAM_PORT_STATE;
4700	else if (attr == &dev_attr_host_port_speed.attr)
4701		param = ISCSI_HOST_PARAM_PORT_SPEED;
4702	else {
4703		WARN_ONCE(1, "Invalid host attr");
4704		return 0;
4705	}
4706
4707	return priv->iscsi_transport->attr_is_visible(ISCSI_HOST_PARAM, param);
4708}
4709
4710static struct attribute_group iscsi_host_group = {
4711	.attrs = iscsi_host_attrs,
4712	.is_visible = iscsi_host_attr_is_visible,
4713};
4714
4715/* convert iscsi_port_speed values to ascii string name */
4716static const struct {
4717	enum iscsi_port_speed	value;
4718	char			*name;
4719} iscsi_port_speed_names[] = {
4720	{ISCSI_PORT_SPEED_UNKNOWN,	"Unknown" },
4721	{ISCSI_PORT_SPEED_10MBPS,	"10 Mbps" },
4722	{ISCSI_PORT_SPEED_100MBPS,	"100 Mbps" },
4723	{ISCSI_PORT_SPEED_1GBPS,	"1 Gbps" },
4724	{ISCSI_PORT_SPEED_10GBPS,	"10 Gbps" },
4725	{ISCSI_PORT_SPEED_25GBPS,       "25 Gbps" },
4726	{ISCSI_PORT_SPEED_40GBPS,       "40 Gbps" },
4727};
4728
4729char *iscsi_get_port_speed_name(struct Scsi_Host *shost)
4730{
4731	int i;
4732	char *speed = "Unknown!";
4733	struct iscsi_cls_host *ihost = shost->shost_data;
4734	uint32_t port_speed = ihost->port_speed;
4735
4736	for (i = 0; i < ARRAY_SIZE(iscsi_port_speed_names); i++) {
4737		if (iscsi_port_speed_names[i].value & port_speed) {
4738			speed = iscsi_port_speed_names[i].name;
4739			break;
4740		}
4741	}
4742	return speed;
4743}
4744EXPORT_SYMBOL_GPL(iscsi_get_port_speed_name);
4745
4746/* convert iscsi_port_state values to ascii string name */
4747static const struct {
4748	enum iscsi_port_state	value;
4749	char			*name;
4750} iscsi_port_state_names[] = {
4751	{ISCSI_PORT_STATE_DOWN,		"LINK DOWN" },
4752	{ISCSI_PORT_STATE_UP,		"LINK UP" },
4753};
4754
4755char *iscsi_get_port_state_name(struct Scsi_Host *shost)
4756{
4757	int i;
4758	char *state = "Unknown!";
4759	struct iscsi_cls_host *ihost = shost->shost_data;
4760	uint32_t port_state = ihost->port_state;
4761
4762	for (i = 0; i < ARRAY_SIZE(iscsi_port_state_names); i++) {
4763		if (iscsi_port_state_names[i].value & port_state) {
4764			state = iscsi_port_state_names[i].name;
4765			break;
4766		}
4767	}
4768	return state;
4769}
4770EXPORT_SYMBOL_GPL(iscsi_get_port_state_name);
4771
4772static int iscsi_session_match(struct attribute_container *cont,
4773			   struct device *dev)
4774{
4775	struct iscsi_cls_session *session;
4776	struct Scsi_Host *shost;
4777	struct iscsi_internal *priv;
4778
4779	if (!iscsi_is_session_dev(dev))
4780		return 0;
4781
4782	session = iscsi_dev_to_session(dev);
4783	shost = iscsi_session_to_shost(session);
4784	if (!shost->transportt)
4785		return 0;
4786
4787	priv = to_iscsi_internal(shost->transportt);
4788	if (priv->session_cont.ac.class != &iscsi_session_class.class)
4789		return 0;
4790
4791	return &priv->session_cont.ac == cont;
4792}
4793
4794static int iscsi_conn_match(struct attribute_container *cont,
4795			   struct device *dev)
4796{
4797	struct iscsi_cls_session *session;
4798	struct iscsi_cls_conn *conn;
4799	struct Scsi_Host *shost;
4800	struct iscsi_internal *priv;
4801
4802	if (!iscsi_is_conn_dev(dev))
4803		return 0;
4804
4805	conn = iscsi_dev_to_conn(dev);
4806	session = iscsi_dev_to_session(conn->dev.parent);
4807	shost = iscsi_session_to_shost(session);
4808
4809	if (!shost->transportt)
4810		return 0;
4811
4812	priv = to_iscsi_internal(shost->transportt);
4813	if (priv->conn_cont.ac.class != &iscsi_connection_class.class)
4814		return 0;
4815
4816	return &priv->conn_cont.ac == cont;
4817}
4818
4819static int iscsi_host_match(struct attribute_container *cont,
4820			    struct device *dev)
4821{
4822	struct Scsi_Host *shost;
4823	struct iscsi_internal *priv;
4824
4825	if (!scsi_is_host_device(dev))
4826		return 0;
4827
4828	shost = dev_to_shost(dev);
4829	if (!shost->transportt  ||
4830	    shost->transportt->host_attrs.ac.class != &iscsi_host_class.class)
4831		return 0;
4832
4833        priv = to_iscsi_internal(shost->transportt);
4834        return &priv->t.host_attrs.ac == cont;
4835}
4836
4837struct scsi_transport_template *
4838iscsi_register_transport(struct iscsi_transport *tt)
4839{
4840	struct iscsi_internal *priv;
4841	unsigned long flags;
4842	int err;
4843
4844	BUG_ON(!tt);
4845	WARN_ON(tt->ep_disconnect && !tt->unbind_conn);
4846
4847	priv = iscsi_if_transport_lookup(tt);
4848	if (priv)
4849		return NULL;
4850
4851	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
4852	if (!priv)
4853		return NULL;
4854	INIT_LIST_HEAD(&priv->list);
4855	priv->iscsi_transport = tt;
4856	priv->t.user_scan = iscsi_user_scan;
4857
4858	priv->dev.class = &iscsi_transport_class;
4859	dev_set_name(&priv->dev, "%s", tt->name);
4860	err = device_register(&priv->dev);
4861	if (err)
4862		goto put_dev;
4863
4864	err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group);
4865	if (err)
4866		goto unregister_dev;
4867
4868	/* host parameters */
4869	priv->t.host_attrs.ac.class = &iscsi_host_class.class;
4870	priv->t.host_attrs.ac.match = iscsi_host_match;
4871	priv->t.host_attrs.ac.grp = &iscsi_host_group;
4872	priv->t.host_size = sizeof(struct iscsi_cls_host);
4873	transport_container_register(&priv->t.host_attrs);
4874
4875	/* connection parameters */
4876	priv->conn_cont.ac.class = &iscsi_connection_class.class;
4877	priv->conn_cont.ac.match = iscsi_conn_match;
4878	priv->conn_cont.ac.grp = &iscsi_conn_group;
4879	transport_container_register(&priv->conn_cont);
4880
4881	/* session parameters */
4882	priv->session_cont.ac.class = &iscsi_session_class.class;
4883	priv->session_cont.ac.match = iscsi_session_match;
4884	priv->session_cont.ac.grp = &iscsi_session_group;
4885	transport_container_register(&priv->session_cont);
4886
4887	spin_lock_irqsave(&iscsi_transport_lock, flags);
4888	list_add(&priv->list, &iscsi_transports);
4889	spin_unlock_irqrestore(&iscsi_transport_lock, flags);
4890
4891	printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
4892	return &priv->t;
4893
4894unregister_dev:
4895	device_unregister(&priv->dev);
4896	return NULL;
4897put_dev:
4898	put_device(&priv->dev);
4899	return NULL;
4900}
4901EXPORT_SYMBOL_GPL(iscsi_register_transport);
4902
4903void iscsi_unregister_transport(struct iscsi_transport *tt)
4904{
4905	struct iscsi_internal *priv;
4906	unsigned long flags;
4907
4908	BUG_ON(!tt);
4909
4910	mutex_lock(&rx_queue_mutex);
4911
4912	priv = iscsi_if_transport_lookup(tt);
4913	BUG_ON (!priv);
4914
4915	spin_lock_irqsave(&iscsi_transport_lock, flags);
4916	list_del(&priv->list);
4917	spin_unlock_irqrestore(&iscsi_transport_lock, flags);
4918
4919	transport_container_unregister(&priv->conn_cont);
4920	transport_container_unregister(&priv->session_cont);
4921	transport_container_unregister(&priv->t.host_attrs);
4922
4923	sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group);
4924	device_unregister(&priv->dev);
4925	mutex_unlock(&rx_queue_mutex);
4926}
4927EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
4928
4929void iscsi_dbg_trace(void (*trace)(struct device *dev, struct va_format *),
4930		     struct device *dev, const char *fmt, ...)
4931{
4932	struct va_format vaf;
4933	va_list args;
4934
4935	va_start(args, fmt);
4936	vaf.fmt = fmt;
4937	vaf.va = &args;
4938	trace(dev, &vaf);
4939	va_end(args);
4940}
4941EXPORT_SYMBOL_GPL(iscsi_dbg_trace);
4942
4943static __init int iscsi_transport_init(void)
4944{
4945	int err;
4946	struct netlink_kernel_cfg cfg = {
4947		.groups	= 1,
4948		.input	= iscsi_if_rx,
4949	};
4950	printk(KERN_INFO "Loading iSCSI transport class v%s.\n",
4951		ISCSI_TRANSPORT_VERSION);
4952
4953	atomic_set(&iscsi_session_nr, 0);
4954
4955	err = class_register(&iscsi_transport_class);
4956	if (err)
4957		return err;
4958
4959	err = class_register(&iscsi_endpoint_class);
4960	if (err)
4961		goto unregister_transport_class;
4962
4963	err = class_register(&iscsi_iface_class);
4964	if (err)
4965		goto unregister_endpoint_class;
4966
4967	err = transport_class_register(&iscsi_host_class);
4968	if (err)
4969		goto unregister_iface_class;
4970
4971	err = transport_class_register(&iscsi_connection_class);
4972	if (err)
4973		goto unregister_host_class;
4974
4975	err = transport_class_register(&iscsi_session_class);
4976	if (err)
4977		goto unregister_conn_class;
4978
4979	err = bus_register(&iscsi_flashnode_bus);
4980	if (err)
4981		goto unregister_session_class;
4982
4983	nls = netlink_kernel_create(&init_net, NETLINK_ISCSI, &cfg);
4984	if (!nls) {
4985		err = -ENOBUFS;
4986		goto unregister_flashnode_bus;
4987	}
4988
4989	iscsi_conn_cleanup_workq = alloc_workqueue("%s",
4990			WQ_SYSFS | WQ_MEM_RECLAIM | WQ_UNBOUND, 0,
4991			"iscsi_conn_cleanup");
4992	if (!iscsi_conn_cleanup_workq) {
4993		err = -ENOMEM;
4994		goto release_nls;
4995	}
4996
4997	return 0;
4998
4999release_nls:
5000	netlink_kernel_release(nls);
5001unregister_flashnode_bus:
5002	bus_unregister(&iscsi_flashnode_bus);
5003unregister_session_class:
5004	transport_class_unregister(&iscsi_session_class);
5005unregister_conn_class:
5006	transport_class_unregister(&iscsi_connection_class);
5007unregister_host_class:
5008	transport_class_unregister(&iscsi_host_class);
5009unregister_iface_class:
5010	class_unregister(&iscsi_iface_class);
5011unregister_endpoint_class:
5012	class_unregister(&iscsi_endpoint_class);
5013unregister_transport_class:
5014	class_unregister(&iscsi_transport_class);
5015	return err;
5016}
5017
5018static void __exit iscsi_transport_exit(void)
5019{
5020	destroy_workqueue(iscsi_conn_cleanup_workq);
5021	netlink_kernel_release(nls);
5022	bus_unregister(&iscsi_flashnode_bus);
5023	transport_class_unregister(&iscsi_connection_class);
5024	transport_class_unregister(&iscsi_session_class);
5025	transport_class_unregister(&iscsi_host_class);
5026	class_unregister(&iscsi_endpoint_class);
5027	class_unregister(&iscsi_iface_class);
5028	class_unregister(&iscsi_transport_class);
5029}
5030
5031module_init(iscsi_transport_init);
5032module_exit(iscsi_transport_exit);
5033
5034MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
5035	      "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
5036	      "Alex Aizman <itn780@yahoo.com>");
5037MODULE_DESCRIPTION("iSCSI Transport Interface");
5038MODULE_LICENSE("GPL");
5039MODULE_VERSION(ISCSI_TRANSPORT_VERSION);
5040MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_ISCSI);