brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * iSCSI transport class definitions4 *5 * Copyright (C) IBM Corporation, 20046 * Copyright (C) Mike Christie, 2004 - 20057 * Copyright (C) Dmitry Yusupov, 2004 - 20058 * Copyright (C) Alex Aizman, 2004 - 20059 */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  1028 29#define CREATE_TRACE_POINTS30#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 must99 * be held while accessing list. The iscsi_transport_lock must100 * 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 are119 * registered.120 */121static struct class iscsi_transport_class = {122	.name = "iscsi_transport",123	.dev_release = iscsi_transport_release,124};125 126static ssize_t127show_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 attrs163 */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_t188show_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 space218	 * 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 handle275 * @handle: endpoint handle276 *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 sysfs297 */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		else565			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		else603			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	else766		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 sysfs800 */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 sysfs1222 * @shost: pointer to host data1223 * @index: index of flashnode to add in sysfs1224 * @transport: pointer to transport data1225 * @dd_size: total size to allocate1226 *1227 * Adds a sysfs entry for the flashnode session attributes1228 *1229 * Returns:1230 *  pointer to allocated flashnode sess on success1231 *  %NULL on failure1232 */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 sysfs1270 * @shost: pointer to host data1271 * @fnode_sess: pointer to the parent flashnode session entry1272 * @transport: pointer to transport data1273 * @dd_size: total size to allocate1274 *1275 * Adds a sysfs entry for the flashnode connection attributes1276 *1277 * Returns:1278 *  pointer to allocated flashnode conn on success1279 *  %NULL on failure1280 */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 conn1318 * @dev: device to verify1319 * @data: pointer to data containing value to use for verification1320 *1321 * Verifies if the passed device is flashnode conn device1322 *1323 * Returns:1324 *  1 on success1325 *  0 on failure1326 */1327static int iscsi_is_flashnode_conn_dev(struct device *dev, 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, 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 == *((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 index1355 * @shost: pointer to host data1356 * @idx: index to match1357 *1358 * Finds the flashnode session object for the passed index1359 *1360 * Returns:1361 *  pointer to found flashnode session object on success1362 *  %NULL on failure1363 */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 entry1380 * @shost: pointer to host data1381 * @data: pointer to data containing value to use for comparison1382 * @fn: function pointer that does actual comparison1383 *1384 * Finds the flashnode session object comparing the data passed using logic1385 * defined in passed function pointer1386 *1387 * Returns:1388 *  pointer to found flashnode session device object on success1389 *  %NULL on failure1390 */1391struct device *1392iscsi_find_flashnode_sess(struct Scsi_Host *shost, void *data,1393			  int (*fn)(struct device *dev, void *data))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 entry1401 * @fnode_sess: pointer to parent flashnode session entry1402 *1403 * Finds the flashnode connection object comparing the data passed using logic1404 * defined in passed function pointer1405 *1406 * Returns:1407 *  pointer to found flashnode connection device object on success1408 *  %NULL on failure1409 */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 entry1428 * @fnode_sess: pointer to flashnode session entry to be destroyed1429 *1430 * Deletes the flashnode session entry and all children flashnode connection1431 * entries from sysfs1432 */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 entries1458 * @shost: pointer to host data1459 *1460 * Destroys all the flashnode session entries and all corresponding children1461 * flashnode connection entries from sysfs1462 */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 support1472 */1473/**1474 * iscsi_bsg_host_dispatch - Dispatch command to LLD.1475 * @job: bsg job to be processed1476 */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 requests1530 * @shost: shost for iscsi_host1531 * @ihost: iscsi_cls_host adding the structures to1532 */1533static int1534iscsi_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 sid1618 */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 tuple1637 */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 allocate1656 * their own scsi_hosts or by software iscsi LLDs1657 */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 transistioned1842 * @cmd: scsi cmd passed to scsi eh handler1843 *1844 * If the session is down this function will wait for the recovery1845 * timer to fire or for the session to be logged back in. If the1846 * recovery timer fires then FAST_IO_FAIL is returned. The caller1847 * 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 session1924 *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 only1935	 * queue the block work. Make sure the unblock work has completed1936	 * 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	} else2087		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 2125/**2126 * iscsi_create_session - create iscsi class session2127 * @shost: scsi host2128 * @transport: iscsi transport2129 * @dd_size: private driver data size2130 * @target_id: which target2131 *2132 * This can be called from a LLD or iscsi_transport.2133 */2134struct iscsi_cls_session *2135iscsi_create_session(struct Scsi_Host *shost, struct iscsi_transport *transport,2136		     int dd_size, unsigned int target_id)2137{2138	struct iscsi_cls_session *session;2139 2140	session = iscsi_alloc_session(shost, transport, dd_size);2141	if (!session)2142		return NULL;2143 2144	if (iscsi_add_session(session, target_id)) {2145		iscsi_free_session(session);2146		return NULL;2147	}2148	return session;2149}2150EXPORT_SYMBOL_GPL(iscsi_create_session);2151 2152static void iscsi_conn_release(struct device *dev)2153{2154	struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev);2155	struct device *parent = conn->dev.parent;2156 2157	ISCSI_DBG_TRANS_CONN(conn, "Releasing conn\n");2158	kfree(conn);2159	put_device(parent);2160}2161 2162static int iscsi_is_conn_dev(const struct device *dev)2163{2164	return dev->release == iscsi_conn_release;2165}2166 2167static int iscsi_iter_destroy_conn_fn(struct device *dev, void *data)2168{2169	if (!iscsi_is_conn_dev(dev))2170		return 0;2171 2172	iscsi_remove_conn(iscsi_dev_to_conn(dev));2173	return 0;2174}2175 2176void iscsi_remove_session(struct iscsi_cls_session *session)2177{2178	unsigned long flags;2179	int err;2180 2181	ISCSI_DBG_TRANS_SESSION(session, "Removing session\n");2182 2183	spin_lock_irqsave(&sesslock, flags);2184	if (!list_empty(&session->sess_list))2185		list_del(&session->sess_list);2186	spin_unlock_irqrestore(&sesslock, flags);2187 2188	if (!cancel_work_sync(&session->block_work))2189		cancel_delayed_work_sync(&session->recovery_work);2190	cancel_work_sync(&session->unblock_work);2191	/*2192	 * If we are blocked let commands flow again. The lld or iscsi2193	 * layer should set up the queuecommand to fail commands.2194	 * We assume that LLD will not be calling block/unblock while2195	 * removing the session.2196	 */2197	spin_lock_irqsave(&session->lock, flags);2198	session->state = ISCSI_SESSION_FREE;2199	spin_unlock_irqrestore(&session->lock, flags);2200 2201	scsi_target_unblock(&session->dev, SDEV_TRANSPORT_OFFLINE);2202	/*2203	 * qla4xxx can perform it's own scans when it runs in kernel only2204	 * mode. Make sure to flush those scans.2205	 */2206	flush_work(&session->scan_work);2207	/* flush running unbind operations */2208	flush_work(&session->unbind_work);2209	__iscsi_unbind_session(&session->unbind_work);2210 2211	/* hw iscsi may not have removed all connections from session */2212	err = device_for_each_child(&session->dev, NULL,2213				    iscsi_iter_destroy_conn_fn);2214	if (err)2215		iscsi_cls_session_printk(KERN_ERR, session,2216					 "Could not delete all connections "2217					 "for session. Error %d.\n", err);2218 2219	transport_unregister_device(&session->dev);2220 2221	destroy_workqueue(session->workq);2222 2223	ISCSI_DBG_TRANS_SESSION(session, "Completing session removal\n");2224	device_del(&session->dev);2225}2226EXPORT_SYMBOL_GPL(iscsi_remove_session);2227 2228static void iscsi_stop_conn(struct iscsi_cls_conn *conn, int flag)2229{2230	ISCSI_DBG_TRANS_CONN(conn, "Stopping conn.\n");2231 2232	switch (flag) {2233	case STOP_CONN_RECOVER:2234		WRITE_ONCE(conn->state, ISCSI_CONN_FAILED);2235		break;2236	case STOP_CONN_TERM:2237		WRITE_ONCE(conn->state, ISCSI_CONN_DOWN);2238		break;2239	default:2240		iscsi_cls_conn_printk(KERN_ERR, conn, "invalid stop flag %d\n",2241				      flag);2242		return;2243	}2244 2245	conn->transport->stop_conn(conn, flag);2246	ISCSI_DBG_TRANS_CONN(conn, "Stopping conn done.\n");2247}2248 2249static void iscsi_ep_disconnect(struct iscsi_cls_conn *conn, bool is_active)2250{2251	struct iscsi_cls_session *session = iscsi_conn_to_session(conn);2252	struct iscsi_endpoint *ep;2253 2254	ISCSI_DBG_TRANS_CONN(conn, "disconnect ep.\n");2255	WRITE_ONCE(conn->state, ISCSI_CONN_FAILED);2256 2257	if (!conn->ep || !session->transport->ep_disconnect)2258		return;2259 2260	ep = conn->ep;2261	conn->ep = NULL;2262 2263	session->transport->unbind_conn(conn, is_active);2264	session->transport->ep_disconnect(ep);2265	ISCSI_DBG_TRANS_CONN(conn, "disconnect ep done.\n");2266}2267 2268static void iscsi_if_disconnect_bound_ep(struct iscsi_cls_conn *conn,2269					 struct iscsi_endpoint *ep,2270					 bool is_active)2271{2272	/* Check if this was a conn error and the kernel took ownership */2273	spin_lock_irq(&conn->lock);2274	if (!test_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags)) {2275		spin_unlock_irq(&conn->lock);2276		iscsi_ep_disconnect(conn, is_active);2277	} else {2278		spin_unlock_irq(&conn->lock);2279		ISCSI_DBG_TRANS_CONN(conn, "flush kernel conn cleanup.\n");2280		mutex_unlock(&conn->ep_mutex);2281 2282		flush_work(&conn->cleanup_work);2283		/*2284		 * Userspace is now done with the EP so we can release the ref2285		 * iscsi_cleanup_conn_work_fn took.2286		 */2287		iscsi_put_endpoint(ep);2288		mutex_lock(&conn->ep_mutex);2289	}2290}2291 2292static int iscsi_if_stop_conn(struct iscsi_cls_conn *conn, int flag)2293{2294	ISCSI_DBG_TRANS_CONN(conn, "iscsi if conn stop.\n");2295	/*2296	 * For offload, iscsid may not know about the ep like when iscsid is2297	 * restarted or for kernel based session shutdown iscsid is not even2298	 * up. For these cases, we do the disconnect now.2299	 */2300	mutex_lock(&conn->ep_mutex);2301	if (conn->ep)2302		iscsi_if_disconnect_bound_ep(conn, conn->ep, true);2303	mutex_unlock(&conn->ep_mutex);2304 2305	/*2306	 * If this is a termination we have to call stop_conn with that flag2307	 * so the correct states get set. If we haven't run the work yet try to2308	 * avoid the extra run.2309	 */2310	if (flag == STOP_CONN_TERM) {2311		cancel_work_sync(&conn->cleanup_work);2312		iscsi_stop_conn(conn, flag);2313	} else {2314		/*2315		 * Figure out if it was the kernel or userspace initiating this.2316		 */2317		spin_lock_irq(&conn->lock);2318		if (!test_and_set_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags)) {2319			spin_unlock_irq(&conn->lock);2320			iscsi_stop_conn(conn, flag);2321		} else {2322			spin_unlock_irq(&conn->lock);2323			ISCSI_DBG_TRANS_CONN(conn,2324					     "flush kernel conn cleanup.\n");2325			flush_work(&conn->cleanup_work);2326		}2327		/*2328		 * Only clear for recovery to avoid extra cleanup runs during2329		 * termination.2330		 */2331		spin_lock_irq(&conn->lock);2332		clear_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags);2333		spin_unlock_irq(&conn->lock);2334	}2335	ISCSI_DBG_TRANS_CONN(conn, "iscsi if conn stop done.\n");2336	return 0;2337}2338 2339static void iscsi_cleanup_conn_work_fn(struct work_struct *work)2340{2341	struct iscsi_cls_conn *conn = container_of(work, struct iscsi_cls_conn,2342						   cleanup_work);2343	struct iscsi_cls_session *session = iscsi_conn_to_session(conn);2344 2345	mutex_lock(&conn->ep_mutex);2346	/*2347	 * Get a ref to the ep, so we don't release its ID until after2348	 * userspace is done referencing it in iscsi_if_disconnect_bound_ep.2349	 */2350	if (conn->ep)2351		get_device(&conn->ep->dev);2352	iscsi_ep_disconnect(conn, false);2353 2354	if (system_state != SYSTEM_RUNNING) {2355		/*2356		 * If the user has set up for the session to never timeout2357		 * then hang like they wanted. For all other cases fail right2358		 * away since userspace is not going to relogin.2359		 */2360		if (session->recovery_tmo > 0)2361			session->recovery_tmo = 0;2362	}2363 2364	iscsi_stop_conn(conn, STOP_CONN_RECOVER);2365	mutex_unlock(&conn->ep_mutex);2366	ISCSI_DBG_TRANS_CONN(conn, "cleanup done.\n");2367}2368 2369static int iscsi_iter_force_destroy_conn_fn(struct device *dev, void *data)2370{2371	struct iscsi_transport *transport;2372	struct iscsi_cls_conn *conn;2373 2374	if (!iscsi_is_conn_dev(dev))2375		return 0;2376 2377	conn = iscsi_dev_to_conn(dev);2378	transport = conn->transport;2379 2380	if (READ_ONCE(conn->state) != ISCSI_CONN_DOWN)2381		iscsi_if_stop_conn(conn, STOP_CONN_TERM);2382 2383	transport->destroy_conn(conn);2384	return 0;2385}2386 2387/**2388 * iscsi_force_destroy_session - destroy a session from the kernel2389 * @session: session to destroy2390 *2391 * Force the destruction of a session from the kernel. This should only be2392 * used when userspace is no longer running during system shutdown.2393 */2394void iscsi_force_destroy_session(struct iscsi_cls_session *session)2395{2396	struct iscsi_transport *transport = session->transport;2397	unsigned long flags;2398 2399	WARN_ON_ONCE(system_state == SYSTEM_RUNNING);2400 2401	spin_lock_irqsave(&sesslock, flags);2402	if (list_empty(&session->sess_list)) {2403		spin_unlock_irqrestore(&sesslock, flags);2404		/*2405		 * Conn/ep is already freed. Session is being torn down via2406		 * async path. For shutdown we don't care about it so return.2407		 */2408		return;2409	}2410	spin_unlock_irqrestore(&sesslock, flags);2411 2412	device_for_each_child(&session->dev, NULL,2413			      iscsi_iter_force_destroy_conn_fn);2414	transport->destroy_session(session);2415}2416EXPORT_SYMBOL_GPL(iscsi_force_destroy_session);2417 2418void iscsi_free_session(struct iscsi_cls_session *session)2419{2420	ISCSI_DBG_TRANS_SESSION(session, "Freeing session\n");2421	iscsi_session_event(session, ISCSI_KEVENT_DESTROY_SESSION);2422	put_device(&session->dev);2423}2424EXPORT_SYMBOL_GPL(iscsi_free_session);2425 2426/**2427 * iscsi_alloc_conn - alloc iscsi class connection2428 * @session: iscsi cls session2429 * @dd_size: private driver data size2430 * @cid: connection id2431 */2432struct iscsi_cls_conn *2433iscsi_alloc_conn(struct iscsi_cls_session *session, int dd_size, uint32_t cid)2434{2435	struct iscsi_transport *transport = session->transport;2436	struct iscsi_cls_conn *conn;2437 2438	conn = kzalloc(sizeof(*conn) + dd_size, GFP_KERNEL);2439	if (!conn)2440		return NULL;2441	if (dd_size)2442		conn->dd_data = &conn[1];2443 2444	mutex_init(&conn->ep_mutex);2445	spin_lock_init(&conn->lock);2446	INIT_LIST_HEAD(&conn->conn_list);2447	INIT_WORK(&conn->cleanup_work, iscsi_cleanup_conn_work_fn);2448	conn->transport = transport;2449	conn->cid = cid;2450	WRITE_ONCE(conn->state, ISCSI_CONN_DOWN);2451 2452	/* this is released in the dev's release function */2453	if (!get_device(&session->dev))2454		goto free_conn;2455 2456	dev_set_name(&conn->dev, "connection%d:%u", session->sid, cid);2457	device_initialize(&conn->dev);2458	conn->dev.parent = &session->dev;2459	conn->dev.release = iscsi_conn_release;2460 2461	return conn;2462 2463free_conn:2464	kfree(conn);2465	return NULL;2466}2467EXPORT_SYMBOL_GPL(iscsi_alloc_conn);2468 2469/**2470 * iscsi_add_conn - add iscsi class connection2471 * @conn: iscsi cls connection2472 *2473 * This will expose iscsi_cls_conn to sysfs so make sure the related2474 * resources for sysfs attributes are initialized before calling this.2475 */2476int iscsi_add_conn(struct iscsi_cls_conn *conn)2477{2478	int err;2479	unsigned long flags;2480	struct iscsi_cls_session *session = iscsi_dev_to_session(conn->dev.parent);2481 2482	err = device_add(&conn->dev);2483	if (err) {2484		iscsi_cls_session_printk(KERN_ERR, session,2485					 "could not register connection's dev\n");2486		return err;2487	}2488	err = transport_register_device(&conn->dev);2489	if (err) {2490		iscsi_cls_session_printk(KERN_ERR, session,2491					 "could not register transport's dev\n");2492		device_del(&conn->dev);2493		return err;2494	}2495 2496	spin_lock_irqsave(&connlock, flags);2497	list_add(&conn->conn_list, &connlist);2498	spin_unlock_irqrestore(&connlock, flags);2499 2500	return 0;2501}2502EXPORT_SYMBOL_GPL(iscsi_add_conn);2503 2504/**2505 * iscsi_remove_conn - remove iscsi class connection from sysfs2506 * @conn: iscsi cls connection2507 *2508 * Remove iscsi_cls_conn from sysfs, and wait for previous2509 * read/write of iscsi_cls_conn's attributes in sysfs to finish.2510 */2511void iscsi_remove_conn(struct iscsi_cls_conn *conn)2512{2513	unsigned long flags;2514 2515	spin_lock_irqsave(&connlock, flags);2516	list_del(&conn->conn_list);2517	spin_unlock_irqrestore(&connlock, flags);2518 2519	transport_unregister_device(&conn->dev);2520	device_del(&conn->dev);2521}2522EXPORT_SYMBOL_GPL(iscsi_remove_conn);2523 2524void iscsi_put_conn(struct iscsi_cls_conn *conn)2525{2526	put_device(&conn->dev);2527}2528EXPORT_SYMBOL_GPL(iscsi_put_conn);2529 2530void iscsi_get_conn(struct iscsi_cls_conn *conn)2531{2532	get_device(&conn->dev);2533}2534EXPORT_SYMBOL_GPL(iscsi_get_conn);2535 2536/*2537 * iscsi interface functions2538 */2539static struct iscsi_internal *2540iscsi_if_transport_lookup(struct iscsi_transport *tt)2541{2542	struct iscsi_internal *priv;2543	unsigned long flags;2544 2545	spin_lock_irqsave(&iscsi_transport_lock, flags);2546	list_for_each_entry(priv, &iscsi_transports, list) {2547		if (tt == priv->iscsi_transport) {2548			spin_unlock_irqrestore(&iscsi_transport_lock, flags);2549			return priv;2550		}2551	}2552	spin_unlock_irqrestore(&iscsi_transport_lock, flags);2553	return NULL;2554}2555 2556static int2557iscsi_multicast_skb(struct sk_buff *skb, uint32_t group, gfp_t gfp)2558{2559	return nlmsg_multicast(nls, skb, 0, group, gfp);2560}2561 2562static int2563iscsi_unicast_skb(struct sk_buff *skb, u32 portid)2564{2565	return nlmsg_unicast(nls, skb, portid);2566}2567 2568int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,2569		   char *data, uint32_t data_size)2570{2571	struct nlmsghdr	*nlh;2572	struct sk_buff *skb;2573	struct iscsi_uevent *ev;2574	char *pdu;2575	struct iscsi_internal *priv;2576	int len = nlmsg_total_size(sizeof(*ev) + sizeof(struct iscsi_hdr) +2577				   data_size);2578 2579	priv = iscsi_if_transport_lookup(conn->transport);2580	if (!priv)2581		return -EINVAL;2582 2583	skb = alloc_skb(len, GFP_ATOMIC);2584	if (!skb) {2585		iscsi_conn_error_event(conn, ISCSI_ERR_CONN_FAILED);2586		iscsi_cls_conn_printk(KERN_ERR, conn, "can not deliver "2587				      "control PDU: OOM\n");2588		return -ENOMEM;2589	}2590 2591	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);2592	ev = nlmsg_data(nlh);2593	memset(ev, 0, sizeof(*ev));2594	ev->transport_handle = iscsi_handle(conn->transport);2595	ev->type = ISCSI_KEVENT_RECV_PDU;2596	ev->r.recv_req.cid = conn->cid;2597	ev->r.recv_req.sid = iscsi_conn_get_sid(conn);2598	pdu = (char*)ev + sizeof(*ev);2599	memcpy(pdu, hdr, sizeof(struct iscsi_hdr));2600	memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);2601 2602	return iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);2603}2604EXPORT_SYMBOL_GPL(iscsi_recv_pdu);2605 2606int iscsi_offload_mesg(struct Scsi_Host *shost,2607		       struct iscsi_transport *transport, uint32_t type,2608		       char *data, uint16_t data_size)2609{2610	struct nlmsghdr	*nlh;2611	struct sk_buff *skb;2612	struct iscsi_uevent *ev;2613	int len = nlmsg_total_size(sizeof(*ev) + data_size);2614 2615	skb = alloc_skb(len, GFP_ATOMIC);2616	if (!skb) {2617		printk(KERN_ERR "can not deliver iscsi offload message:OOM\n");2618		return -ENOMEM;2619	}2620 2621	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);2622	ev = nlmsg_data(nlh);2623	memset(ev, 0, sizeof(*ev));2624	ev->type = type;2625	ev->transport_handle = iscsi_handle(transport);2626	switch (type) {2627	case ISCSI_KEVENT_PATH_REQ:2628		ev->r.req_path.host_no = shost->host_no;2629		break;2630	case ISCSI_KEVENT_IF_DOWN:2631		ev->r.notify_if_down.host_no = shost->host_no;2632		break;2633	}2634 2635	memcpy((char *)ev + sizeof(*ev), data, data_size);2636 2637	return iscsi_multicast_skb(skb, ISCSI_NL_GRP_UIP, GFP_ATOMIC);2638}2639EXPORT_SYMBOL_GPL(iscsi_offload_mesg);2640 2641void iscsi_conn_error_event(struct iscsi_cls_conn *conn, enum iscsi_err error)2642{2643	struct nlmsghdr	*nlh;2644	struct sk_buff	*skb;2645	struct iscsi_uevent *ev;2646	struct iscsi_internal *priv;2647	int len = nlmsg_total_size(sizeof(*ev));2648	unsigned long flags;2649	int state;2650 2651	spin_lock_irqsave(&conn->lock, flags);2652	/*2653	 * Userspace will only do a stop call if we are at least bound. And, we2654	 * only need to do the in kernel cleanup if in the UP state so cmds can2655	 * be released to upper layers. If in other states just wait for2656	 * userspace to avoid races that can leave the cleanup_work queued.2657	 */2658	state = READ_ONCE(conn->state);2659	switch (state) {2660	case ISCSI_CONN_BOUND:2661	case ISCSI_CONN_UP:2662		if (!test_and_set_bit(ISCSI_CLS_CONN_BIT_CLEANUP,2663				      &conn->flags)) {2664			queue_work(iscsi_conn_cleanup_workq,2665				   &conn->cleanup_work);2666		}2667		break;2668	default:2669		ISCSI_DBG_TRANS_CONN(conn, "Got conn error in state %d\n",2670				     state);2671		break;2672	}2673	spin_unlock_irqrestore(&conn->lock, flags);2674 2675	priv = iscsi_if_transport_lookup(conn->transport);2676	if (!priv)2677		return;2678 2679	skb = alloc_skb(len, GFP_ATOMIC);2680	if (!skb) {2681		iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored "2682				      "conn error (%d)\n", error);2683		return;2684	}2685 2686	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);2687	ev = nlmsg_data(nlh);2688	ev->transport_handle = iscsi_handle(conn->transport);2689	ev->type = ISCSI_KEVENT_CONN_ERROR;2690	ev->r.connerror.error = error;2691	ev->r.connerror.cid = conn->cid;2692	ev->r.connerror.sid = iscsi_conn_get_sid(conn);2693 2694	iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);2695 2696	iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn error (%d)\n",2697			      error);2698}2699EXPORT_SYMBOL_GPL(iscsi_conn_error_event);2700 2701void iscsi_conn_login_event(struct iscsi_cls_conn *conn,2702			    enum iscsi_conn_state state)2703{2704	struct nlmsghdr *nlh;2705	struct sk_buff  *skb;2706	struct iscsi_uevent *ev;2707	struct iscsi_internal *priv;2708	int len = nlmsg_total_size(sizeof(*ev));2709 2710	priv = iscsi_if_transport_lookup(conn->transport);2711	if (!priv)2712		return;2713 2714	skb = alloc_skb(len, GFP_ATOMIC);2715	if (!skb) {2716		iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored "2717				      "conn login (%d)\n", state);2718		return;2719	}2720 2721	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);2722	ev = nlmsg_data(nlh);2723	ev->transport_handle = iscsi_handle(conn->transport);2724	ev->type = ISCSI_KEVENT_CONN_LOGIN_STATE;2725	ev->r.conn_login.state = state;2726	ev->r.conn_login.cid = conn->cid;2727	ev->r.conn_login.sid = iscsi_conn_get_sid(conn);2728	iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);2729 2730	iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn login (%d)\n",2731			      state);2732}2733EXPORT_SYMBOL_GPL(iscsi_conn_login_event);2734 2735void iscsi_post_host_event(uint32_t host_no, struct iscsi_transport *transport,2736			   enum iscsi_host_event_code code, uint32_t data_size,2737			   uint8_t *data)2738{2739	struct nlmsghdr *nlh;2740	struct sk_buff *skb;2741	struct iscsi_uevent *ev;2742	int len = nlmsg_total_size(sizeof(*ev) + data_size);2743 2744	skb = alloc_skb(len, GFP_NOIO);2745	if (!skb) {2746		printk(KERN_ERR "gracefully ignored host event (%d):%d OOM\n",2747		       host_no, code);2748		return;2749	}2750 2751	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);2752	ev = nlmsg_data(nlh);2753	ev->transport_handle = iscsi_handle(transport);2754	ev->type = ISCSI_KEVENT_HOST_EVENT;2755	ev->r.host_event.host_no = host_no;2756	ev->r.host_event.code = code;2757	ev->r.host_event.data_size = data_size;2758 2759	if (data_size)2760		memcpy((char *)ev + sizeof(*ev), data, data_size);2761 2762	iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_NOIO);2763}2764EXPORT_SYMBOL_GPL(iscsi_post_host_event);2765 2766void iscsi_ping_comp_event(uint32_t host_no, struct iscsi_transport *transport,2767			   uint32_t status, uint32_t pid, uint32_t data_size,2768			   uint8_t *data)2769{2770	struct nlmsghdr *nlh;2771	struct sk_buff *skb;2772	struct iscsi_uevent *ev;2773	int len = nlmsg_total_size(sizeof(*ev) + data_size);2774 2775	skb = alloc_skb(len, GFP_NOIO);2776	if (!skb) {2777		printk(KERN_ERR "gracefully ignored ping comp: OOM\n");2778		return;2779	}2780 2781	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);2782	ev = nlmsg_data(nlh);2783	ev->transport_handle = iscsi_handle(transport);2784	ev->type = ISCSI_KEVENT_PING_COMP;2785	ev->r.ping_comp.host_no = host_no;2786	ev->r.ping_comp.status = status;2787	ev->r.ping_comp.pid = pid;2788	ev->r.ping_comp.data_size = data_size;2789	memcpy((char *)ev + sizeof(*ev), data, data_size);2790 2791	iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_NOIO);2792}2793EXPORT_SYMBOL_GPL(iscsi_ping_comp_event);2794 2795static int2796iscsi_if_send_reply(u32 portid, int type, void *payload, int size)2797{2798	struct sk_buff	*skb;2799	struct nlmsghdr	*nlh;2800	int len = nlmsg_total_size(size);2801 2802	skb = alloc_skb(len, GFP_ATOMIC);2803	if (!skb) {2804		printk(KERN_ERR "Could not allocate skb to send reply.\n");2805		return -ENOMEM;2806	}2807 2808	nlh = __nlmsg_put(skb, 0, 0, type, (len - sizeof(*nlh)), 0);2809	memcpy(nlmsg_data(nlh), payload, size);2810	return iscsi_unicast_skb(skb, portid);2811}2812 2813static int2814iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)2815{2816	struct iscsi_uevent *ev = nlmsg_data(nlh);2817	struct iscsi_stats *stats;2818	struct sk_buff *skbstat;2819	struct iscsi_cls_conn *conn;2820	struct nlmsghdr	*nlhstat;2821	struct iscsi_uevent *evstat;2822	struct iscsi_internal *priv;2823	int len = nlmsg_total_size(sizeof(*ev) +2824				   sizeof(struct iscsi_stats) +2825				   sizeof(struct iscsi_stats_custom) *2826				   ISCSI_STATS_CUSTOM_MAX);2827	int err = 0;2828 2829	priv = iscsi_if_transport_lookup(transport);2830	if (!priv)2831		return -EINVAL;2832 2833	conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid);2834	if (!conn)2835		return -EEXIST;2836 2837	do {2838		int actual_size;2839 2840		skbstat = alloc_skb(len, GFP_ATOMIC);2841		if (!skbstat) {2842			iscsi_cls_conn_printk(KERN_ERR, conn, "can not "2843					      "deliver stats: OOM\n");2844			return -ENOMEM;2845		}2846 2847		nlhstat = __nlmsg_put(skbstat, 0, 0, 0,2848				      (len - sizeof(*nlhstat)), 0);2849		evstat = nlmsg_data(nlhstat);2850		memset(evstat, 0, sizeof(*evstat));2851		evstat->transport_handle = iscsi_handle(conn->transport);2852		evstat->type = nlh->nlmsg_type;2853		evstat->u.get_stats.cid =2854			ev->u.get_stats.cid;2855		evstat->u.get_stats.sid =2856			ev->u.get_stats.sid;2857		stats = (struct iscsi_stats *)2858			((char*)evstat + sizeof(*evstat));2859		memset(stats, 0, sizeof(*stats));2860 2861		transport->get_stats(conn, stats);2862		actual_size = nlmsg_total_size(sizeof(struct iscsi_uevent) +2863					       sizeof(struct iscsi_stats) +2864					       sizeof(struct iscsi_stats_custom) *2865					       stats->custom_length);2866		actual_size -= sizeof(*nlhstat);2867		actual_size = nlmsg_msg_size(actual_size);2868		skb_trim(skbstat, NLMSG_ALIGN(actual_size));2869		nlhstat->nlmsg_len = actual_size;2870 2871		err = iscsi_multicast_skb(skbstat, ISCSI_NL_GRP_ISCSID,2872					  GFP_ATOMIC);2873	} while (err < 0 && err != -ECONNREFUSED);2874 2875	return err;2876}2877 2878/**2879 * iscsi_session_event - send session destr. completion event2880 * @session: iscsi class session2881 * @event: type of event2882 */2883int iscsi_session_event(struct iscsi_cls_session *session,2884			enum iscsi_uevent_e event)2885{2886	struct iscsi_internal *priv;2887	struct Scsi_Host *shost;2888	struct iscsi_uevent *ev;2889	struct sk_buff  *skb;2890	struct nlmsghdr *nlh;2891	int rc, len = nlmsg_total_size(sizeof(*ev));2892 2893	priv = iscsi_if_transport_lookup(session->transport);2894	if (!priv)2895		return -EINVAL;2896	shost = iscsi_session_to_shost(session);2897 2898	skb = alloc_skb(len, GFP_KERNEL);2899	if (!skb) {2900		iscsi_cls_session_printk(KERN_ERR, session,2901					 "Cannot notify userspace of session "2902					 "event %u\n", event);2903		return -ENOMEM;2904	}2905 2906	nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);2907	ev = nlmsg_data(nlh);2908	ev->transport_handle = iscsi_handle(session->transport);2909 2910	ev->type = event;2911	switch (event) {2912	case ISCSI_KEVENT_DESTROY_SESSION:2913		ev->r.d_session.host_no = shost->host_no;2914		ev->r.d_session.sid = session->sid;2915		break;2916	case ISCSI_KEVENT_CREATE_SESSION:2917		ev->r.c_session_ret.host_no = shost->host_no;2918		ev->r.c_session_ret.sid = session->sid;2919		break;2920	case ISCSI_KEVENT_UNBIND_SESSION:2921		ev->r.unbind_session.host_no = shost->host_no;2922		ev->r.unbind_session.sid = session->sid;2923		break;2924	default:2925		iscsi_cls_session_printk(KERN_ERR, session, "Invalid event "2926					 "%u.\n", event);2927		kfree_skb(skb);2928		return -EINVAL;2929	}2930 2931	/*2932	 * this will occur if the daemon is not up, so we just warn2933	 * the user and when the daemon is restarted it will handle it2934	 */2935	rc = iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_KERNEL);2936	if (rc == -ESRCH)2937		iscsi_cls_session_printk(KERN_ERR, session,2938					 "Cannot notify userspace of session "2939					 "event %u. Check iscsi daemon\n",2940					 event);2941 2942	ISCSI_DBG_TRANS_SESSION(session, "Completed handling event %d rc %d\n",2943				event, rc);2944	return rc;2945}2946EXPORT_SYMBOL_GPL(iscsi_session_event);2947 2948static int2949iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_endpoint *ep,2950			struct iscsi_uevent *ev, pid_t pid,2951			uint32_t initial_cmdsn,	uint16_t cmds_max,2952			uint16_t queue_depth)2953{2954	struct iscsi_transport *transport = priv->iscsi_transport;2955	struct iscsi_cls_session *session;2956	struct Scsi_Host *shost;2957 2958	session = transport->create_session(ep, cmds_max, queue_depth,2959					    initial_cmdsn);2960	if (!session)2961		return -ENOMEM;2962 2963	session->creator = pid;2964	shost = iscsi_session_to_shost(session);2965	ev->r.c_session_ret.host_no = shost->host_no;2966	ev->r.c_session_ret.sid = session->sid;2967	ISCSI_DBG_TRANS_SESSION(session,2968				"Completed creating transport session\n");2969	return 0;2970}2971 2972static int2973iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)2974{2975	struct iscsi_cls_conn *conn;2976	struct iscsi_cls_session *session;2977 2978	session = iscsi_session_lookup(ev->u.c_conn.sid);2979	if (!session) {2980		printk(KERN_ERR "iscsi: invalid session %d.\n",2981		       ev->u.c_conn.sid);2982		return -EINVAL;2983	}2984 2985	conn = transport->create_conn(session, ev->u.c_conn.cid);2986	if (!conn) {2987		iscsi_cls_session_printk(KERN_ERR, session,2988					 "couldn't create a new connection.");2989		return -ENOMEM;2990	}2991 2992	ev->r.c_conn_ret.sid = session->sid;2993	ev->r.c_conn_ret.cid = conn->cid;2994 2995	ISCSI_DBG_TRANS_CONN(conn, "Completed creating transport conn\n");2996	return 0;2997}2998 2999static int3000iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)3001{3002	struct iscsi_cls_conn *conn;3003 3004	conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid);3005	if (!conn)3006		return -EINVAL;3007 3008	ISCSI_DBG_TRANS_CONN(conn, "Flushing cleanup during destruction\n");3009	flush_work(&conn->cleanup_work);3010	ISCSI_DBG_TRANS_CONN(conn, "Destroying transport conn\n");3011 3012	if (transport->destroy_conn)3013		transport->destroy_conn(conn);3014	return 0;3015}3016 3017static int3018iscsi_if_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev, u32 rlen)3019{3020	char *data = (char*)ev + sizeof(*ev);3021	struct iscsi_cls_conn *conn;3022	struct iscsi_cls_session *session;3023	int err = 0, value = 0, state;3024 3025	if (ev->u.set_param.len > rlen ||3026	    ev->u.set_param.len > PAGE_SIZE)3027		return -EINVAL;3028 3029	session = iscsi_session_lookup(ev->u.set_param.sid);3030	conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid);3031	if (!conn || !session)3032		return -EINVAL;3033 3034	/* data will be regarded as NULL-ended string, do length check */3035	if (strlen(data) > ev->u.set_param.len)3036		return -EINVAL;3037 3038	switch (ev->u.set_param.param) {3039	case ISCSI_PARAM_SESS_RECOVERY_TMO:3040		sscanf(data, "%d", &value);3041		if (!session->recovery_tmo_sysfs_override)3042			session->recovery_tmo = value;3043		break;3044	default:3045		state = READ_ONCE(conn->state);3046		if (state == ISCSI_CONN_BOUND || state == ISCSI_CONN_UP) {3047			err = transport->set_param(conn, ev->u.set_param.param,3048					data, ev->u.set_param.len);3049		} else {3050			return -ENOTCONN;3051		}3052	}3053 3054	return err;3055}3056 3057static int iscsi_if_ep_connect(struct iscsi_transport *transport,3058			       struct iscsi_uevent *ev, int msg_type)3059{3060	struct iscsi_endpoint *ep;3061	struct sockaddr *dst_addr;3062	struct Scsi_Host *shost = NULL;3063	int non_blocking, err = 0;3064 3065	if (!transport->ep_connect)3066		return -EINVAL;3067 3068	if (msg_type == ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST) {3069		shost = scsi_host_lookup(ev->u.ep_connect_through_host.host_no);3070		if (!shost) {3071			printk(KERN_ERR "ep connect failed. Could not find "3072			       "host no %u\n",3073			       ev->u.ep_connect_through_host.host_no);3074			return -ENODEV;3075		}3076		non_blocking = ev->u.ep_connect_through_host.non_blocking;3077	} else3078		non_blocking = ev->u.ep_connect.non_blocking;3079 3080	dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));3081	ep = transport->ep_connect(shost, dst_addr, non_blocking);3082	if (IS_ERR(ep)) {3083		err = PTR_ERR(ep);3084		goto release_host;3085	}3086 3087	ev->r.ep_connect_ret.handle = ep->id;3088release_host:3089	if (shost)3090		scsi_host_put(shost);3091	return err;3092}3093 3094static int iscsi_if_ep_disconnect(struct iscsi_transport *transport,3095				  u64 ep_handle)3096{3097	struct iscsi_cls_conn *conn;3098	struct iscsi_endpoint *ep;3099 3100	if (!transport->ep_disconnect)3101		return -EINVAL;3102 3103	ep = iscsi_lookup_endpoint(ep_handle);3104	if (!ep)3105		return -EINVAL;3106 3107	conn = ep->conn;3108	if (!conn) {3109		/*3110		 * conn was not even bound yet, so we can't get iscsi conn3111		 * failures yet.3112		 */3113		transport->ep_disconnect(ep);3114		goto put_ep;3115	}3116 3117	mutex_lock(&conn->ep_mutex);3118	iscsi_if_disconnect_bound_ep(conn, ep, false);3119	mutex_unlock(&conn->ep_mutex);3120put_ep:3121	iscsi_put_endpoint(ep);3122	return 0;3123}3124 3125static int3126iscsi_if_transport_ep(struct iscsi_transport *transport,3127		      struct iscsi_uevent *ev, int msg_type, u32 rlen)3128{3129	struct iscsi_endpoint *ep;3130	int rc = 0;3131 3132	switch (msg_type) {3133	case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST:3134	case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:3135		if (rlen < sizeof(struct sockaddr))3136			rc = -EINVAL;3137		else3138			rc = iscsi_if_ep_connect(transport, ev, msg_type);3139		break;3140	case ISCSI_UEVENT_TRANSPORT_EP_POLL:3141		if (!transport->ep_poll)3142			return -EINVAL;3143 3144		ep = iscsi_lookup_endpoint(ev->u.ep_poll.ep_handle);3145		if (!ep)3146			return -EINVAL;3147 3148		ev->r.retcode = transport->ep_poll(ep,3149						   ev->u.ep_poll.timeout_ms);3150		iscsi_put_endpoint(ep);3151		break;3152	case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:3153		rc = iscsi_if_ep_disconnect(transport,3154					    ev->u.ep_disconnect.ep_handle);3155		break;3156	}3157	return rc;3158}3159 3160static int3161iscsi_tgt_dscvr(struct iscsi_transport *transport,3162		struct iscsi_uevent *ev, u32 rlen)3163{3164	struct Scsi_Host *shost;3165	struct sockaddr *dst_addr;3166	int err;3167 3168	if (rlen < sizeof(*dst_addr))3169		return -EINVAL;3170 3171	if (!transport->tgt_dscvr)3172		return -EINVAL;3173 3174	shost = scsi_host_lookup(ev->u.tgt_dscvr.host_no);3175	if (!shost) {3176		printk(KERN_ERR "target discovery could not find host no %u\n",3177		       ev->u.tgt_dscvr.host_no);3178		return -ENODEV;3179	}3180 3181 3182	dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));3183	err = transport->tgt_dscvr(shost, ev->u.tgt_dscvr.type,3184				   ev->u.tgt_dscvr.enable, dst_addr);3185	scsi_host_put(shost);3186	return err;3187}3188 3189static int3190iscsi_set_host_param(struct iscsi_transport *transport,3191		     struct iscsi_uevent *ev, u32 rlen)3192{3193	char *data = (char*)ev + sizeof(*ev);3194	struct Scsi_Host *shost;3195	int err;3196 3197	if (!transport->set_host_param)3198		return -ENOSYS;3199 3200	if (ev->u.set_host_param.len > rlen ||3201	    ev->u.set_host_param.len > PAGE_SIZE)3202		return -EINVAL;3203 3204	shost = scsi_host_lookup(ev->u.set_host_param.host_no);3205	if (!shost) {3206		printk(KERN_ERR "set_host_param could not find host no %u\n",3207		       ev->u.set_host_param.host_no);3208		return -ENODEV;3209	}3210 3211	/* see similar check in iscsi_if_set_param() */3212	if (strlen(data) > ev->u.set_host_param.len)3213		return -EINVAL;3214 3215	err = transport->set_host_param(shost, ev->u.set_host_param.param,3216					data, ev->u.set_host_param.len);3217	scsi_host_put(shost);3218	return err;3219}3220 3221static int3222iscsi_set_path(struct iscsi_transport *transport, struct iscsi_uevent *ev, u32 rlen)3223{3224	struct Scsi_Host *shost;3225	struct iscsi_path *params;3226	int err;3227 3228	if (rlen < sizeof(*params))3229		return -EINVAL;3230 3231	if (!transport->set_path)3232		return -ENOSYS;3233 3234	shost = scsi_host_lookup(ev->u.set_path.host_no);3235	if (!shost) {3236		printk(KERN_ERR "set path could not find host no %u\n",3237		       ev->u.set_path.host_no);3238		return -ENODEV;3239	}3240 3241	params = (struct iscsi_path *)((char *)ev + sizeof(*ev));3242	err = transport->set_path(shost, params);3243 3244	scsi_host_put(shost);3245	return err;3246}3247 3248static int iscsi_session_has_conns(int sid)3249{3250	struct iscsi_cls_conn *conn;3251	unsigned long flags;3252	int found = 0;3253 3254	spin_lock_irqsave(&connlock, flags);3255	list_for_each_entry(conn, &connlist, conn_list) {3256		if (iscsi_conn_get_sid(conn) == sid) {3257			found = 1;3258			break;3259		}3260	}3261	spin_unlock_irqrestore(&connlock, flags);3262 3263	return found;3264}3265 3266static int3267iscsi_set_iface_params(struct iscsi_transport *transport,3268		       struct iscsi_uevent *ev, uint32_t len)3269{3270	char *data = (char *)ev + sizeof(*ev);3271	struct Scsi_Host *shost;3272	int err;3273 3274	if (!transport->set_iface_param)3275		return -ENOSYS;3276 3277	shost = scsi_host_lookup(ev->u.set_iface_params.host_no);3278	if (!shost) {3279		printk(KERN_ERR "set_iface_params could not find host no %u\n",3280		       ev->u.set_iface_params.host_no);3281		return -ENODEV;3282	}3283 3284	err = transport->set_iface_param(shost, data, len);3285	scsi_host_put(shost);3286	return err;3287}3288 3289static int3290iscsi_send_ping(struct iscsi_transport *transport, struct iscsi_uevent *ev, u32 rlen)3291{3292	struct Scsi_Host *shost;3293	struct sockaddr *dst_addr;3294	int err;3295 3296	if (rlen < sizeof(*dst_addr))3297		return -EINVAL;3298 3299	if (!transport->send_ping)3300		return -ENOSYS;3301 3302	shost = scsi_host_lookup(ev->u.iscsi_ping.host_no);3303	if (!shost) {3304		printk(KERN_ERR "iscsi_ping could not find host no %u\n",3305		       ev->u.iscsi_ping.host_no);3306		return -ENODEV;3307	}3308 3309	dst_addr = (struct sockaddr *)((char *)ev + sizeof(*ev));3310	err = transport->send_ping(shost, ev->u.iscsi_ping.iface_num,3311				   ev->u.iscsi_ping.iface_type,3312				   ev->u.iscsi_ping.payload_size,3313				   ev->u.iscsi_ping.pid,3314				   dst_addr);3315	scsi_host_put(shost);3316	return err;3317}3318 3319static int3320iscsi_get_chap(struct iscsi_transport *transport, struct nlmsghdr *nlh)3321{3322	struct iscsi_uevent *ev = nlmsg_data(nlh);3323	struct Scsi_Host *shost = NULL;3324	struct iscsi_chap_rec *chap_rec;3325	struct iscsi_internal *priv;3326	struct sk_buff *skbchap;3327	struct nlmsghdr *nlhchap;3328	struct iscsi_uevent *evchap;3329	uint32_t chap_buf_size;3330	int len, err = 0;3331	char *buf;3332 3333	if (!transport->get_chap)3334		return -EINVAL;3335 3336	priv = iscsi_if_transport_lookup(transport);3337	if (!priv)3338		return -EINVAL;3339 3340	chap_buf_size = (ev->u.get_chap.num_entries * sizeof(*chap_rec));3341	len = nlmsg_total_size(sizeof(*ev) + chap_buf_size);3342 3343	shost = scsi_host_lookup(ev->u.get_chap.host_no);3344	if (!shost) {3345		printk(KERN_ERR "%s: failed. Could not find host no %u\n",3346		       __func__, ev->u.get_chap.host_no);3347		return -ENODEV;3348	}3349 3350	do {3351		int actual_size;3352 3353		skbchap = alloc_skb(len, GFP_KERNEL);3354		if (!skbchap) {3355			printk(KERN_ERR "can not deliver chap: OOM\n");3356			err = -ENOMEM;3357			goto exit_get_chap;3358		}3359 3360		nlhchap = __nlmsg_put(skbchap, 0, 0, 0,3361				      (len - sizeof(*nlhchap)), 0);3362		evchap = nlmsg_data(nlhchap);3363		memset(evchap, 0, sizeof(*evchap));3364		evchap->transport_handle = iscsi_handle(transport);3365		evchap->type = nlh->nlmsg_type;3366		evchap->u.get_chap.host_no = ev->u.get_chap.host_no;3367		evchap->u.get_chap.chap_tbl_idx = ev->u.get_chap.chap_tbl_idx;3368		evchap->u.get_chap.num_entries = ev->u.get_chap.num_entries;3369		buf = (char *)evchap + sizeof(*evchap);3370		memset(buf, 0, chap_buf_size);3371 3372		err = transport->get_chap(shost, ev->u.get_chap.chap_tbl_idx,3373				    &evchap->u.get_chap.num_entries, buf);3374 3375		actual_size = nlmsg_total_size(sizeof(*ev) + chap_buf_size);3376		skb_trim(skbchap, NLMSG_ALIGN(actual_size));3377		nlhchap->nlmsg_len = actual_size;3378 3379		err = iscsi_multicast_skb(skbchap, ISCSI_NL_GRP_ISCSID,3380					  GFP_KERNEL);3381	} while (err < 0 && err != -ECONNREFUSED);3382 3383exit_get_chap:3384	scsi_host_put(shost);3385	return err;3386}3387 3388static int iscsi_set_chap(struct iscsi_transport *transport,3389			  struct iscsi_uevent *ev, uint32_t len)3390{3391	char *data = (char *)ev + sizeof(*ev);3392	struct Scsi_Host *shost;3393	int err = 0;3394 3395	if (!transport->set_chap)3396		return -ENOSYS;3397 3398	shost = scsi_host_lookup(ev->u.set_path.host_no);3399	if (!shost) {3400		pr_err("%s could not find host no %u\n",3401		       __func__, ev->u.set_path.host_no);3402		return -ENODEV;3403	}3404 3405	err = transport->set_chap(shost, data, len);3406	scsi_host_put(shost);3407	return err;3408}3409 3410static int iscsi_delete_chap(struct iscsi_transport *transport,3411			     struct iscsi_uevent *ev)3412{3413	struct Scsi_Host *shost;3414	int err = 0;3415 3416	if (!transport->delete_chap)3417		return -ENOSYS;3418 3419	shost = scsi_host_lookup(ev->u.delete_chap.host_no);3420	if (!shost) {3421		printk(KERN_ERR "%s could not find host no %u\n",3422		       __func__, ev->u.delete_chap.host_no);3423		return -ENODEV;3424	}3425 3426	err = transport->delete_chap(shost, ev->u.delete_chap.chap_tbl_idx);3427	scsi_host_put(shost);3428	return err;3429}3430 3431static const struct {3432	enum iscsi_discovery_parent_type value;3433	char				*name;3434} iscsi_discovery_parent_names[] = {3435	{ISCSI_DISC_PARENT_UNKNOWN,	"Unknown" },3436	{ISCSI_DISC_PARENT_SENDTGT,	"Sendtarget" },3437	{ISCSI_DISC_PARENT_ISNS,	"isns" },3438};3439 3440char *iscsi_get_discovery_parent_name(int parent_type)3441{3442	int i;3443	char *state = "Unknown!";3444 3445	for (i = 0; i < ARRAY_SIZE(iscsi_discovery_parent_names); i++) {3446		if (iscsi_discovery_parent_names[i].value & parent_type) {3447			state = iscsi_discovery_parent_names[i].name;3448			break;3449		}3450	}3451	return state;3452}3453EXPORT_SYMBOL_GPL(iscsi_get_discovery_parent_name);3454 3455static int iscsi_set_flashnode_param(struct iscsi_transport *transport,3456				     struct iscsi_uevent *ev, uint32_t len)3457{3458	char *data = (char *)ev + sizeof(*ev);3459	struct Scsi_Host *shost;3460	struct iscsi_bus_flash_session *fnode_sess;3461	struct iscsi_bus_flash_conn *fnode_conn;3462	struct device *dev;3463	uint32_t idx;3464	int err = 0;3465 3466	if (!transport->set_flashnode_param) {3467		err = -ENOSYS;3468		goto exit_set_fnode;3469	}3470 3471	shost = scsi_host_lookup(ev->u.set_flashnode.host_no);3472	if (!shost) {3473		pr_err("%s could not find host no %u\n",3474		       __func__, ev->u.set_flashnode.host_no);3475		err = -ENODEV;3476		goto exit_set_fnode;3477	}3478 3479	idx = ev->u.set_flashnode.flashnode_idx;3480	fnode_sess = iscsi_get_flashnode_by_index(shost, idx);3481	if (!fnode_sess) {3482		pr_err("%s could not find flashnode %u for host no %u\n",3483		       __func__, idx, ev->u.set_flashnode.host_no);3484		err = -ENODEV;3485		goto put_host;3486	}3487 3488	dev = iscsi_find_flashnode_conn(fnode_sess);3489	if (!dev) {3490		err = -ENODEV;3491		goto put_sess;3492	}3493 3494	fnode_conn = iscsi_dev_to_flash_conn(dev);3495	err = transport->set_flashnode_param(fnode_sess, fnode_conn, data, len);3496	put_device(dev);3497 3498put_sess:3499	put_device(&fnode_sess->dev);3500 3501put_host:3502	scsi_host_put(shost);3503 3504exit_set_fnode:3505	return err;3506}3507 3508static int iscsi_new_flashnode(struct iscsi_transport *transport,3509			       struct iscsi_uevent *ev, uint32_t len)3510{3511	char *data = (char *)ev + sizeof(*ev);3512	struct Scsi_Host *shost;3513	int index;3514	int err = 0;3515 3516	if (!transport->new_flashnode) {3517		err = -ENOSYS;3518		goto exit_new_fnode;3519	}3520 3521	shost = scsi_host_lookup(ev->u.new_flashnode.host_no);3522	if (!shost) {3523		pr_err("%s could not find host no %u\n",3524		       __func__, ev->u.new_flashnode.host_no);3525		err = -ENODEV;3526		goto put_host;3527	}3528 3529	index = transport->new_flashnode(shost, data, len);3530 3531	if (index >= 0)3532		ev->r.new_flashnode_ret.flashnode_idx = index;3533	else3534		err = -EIO;3535 3536put_host:3537	scsi_host_put(shost);3538 3539exit_new_fnode:3540	return err;3541}3542 3543static int iscsi_del_flashnode(struct iscsi_transport *transport,3544			       struct iscsi_uevent *ev)3545{3546	struct Scsi_Host *shost;3547	struct iscsi_bus_flash_session *fnode_sess;3548	uint32_t idx;3549	int err = 0;3550 3551	if (!transport->del_flashnode) {3552		err = -ENOSYS;3553		goto exit_del_fnode;3554	}3555 3556	shost = scsi_host_lookup(ev->u.del_flashnode.host_no);3557	if (!shost) {3558		pr_err("%s could not find host no %u\n",3559		       __func__, ev->u.del_flashnode.host_no);3560		err = -ENODEV;3561		goto put_host;3562	}3563 3564	idx = ev->u.del_flashnode.flashnode_idx;3565	fnode_sess = iscsi_get_flashnode_by_index(shost, idx);3566	if (!fnode_sess) {3567		pr_err("%s could not find flashnode %u for host no %u\n",3568		       __func__, idx, ev->u.del_flashnode.host_no);3569		err = -ENODEV;3570		goto put_host;3571	}3572 3573	err = transport->del_flashnode(fnode_sess);3574	put_device(&fnode_sess->dev);3575 3576put_host:3577	scsi_host_put(shost);3578 3579exit_del_fnode:3580	return err;3581}3582 3583static int iscsi_login_flashnode(struct iscsi_transport *transport,3584				 struct iscsi_uevent *ev)3585{3586	struct Scsi_Host *shost;3587	struct iscsi_bus_flash_session *fnode_sess;3588	struct iscsi_bus_flash_conn *fnode_conn;3589	struct device *dev;3590	uint32_t idx;3591	int err = 0;3592 3593	if (!transport->login_flashnode) {3594		err = -ENOSYS;3595		goto exit_login_fnode;3596	}3597 3598	shost = scsi_host_lookup(ev->u.login_flashnode.host_no);3599	if (!shost) {3600		pr_err("%s could not find host no %u\n",3601		       __func__, ev->u.login_flashnode.host_no);3602		err = -ENODEV;3603		goto put_host;3604	}3605 3606	idx = ev->u.login_flashnode.flashnode_idx;3607	fnode_sess = iscsi_get_flashnode_by_index(shost, idx);3608	if (!fnode_sess) {3609		pr_err("%s could not find flashnode %u for host no %u\n",3610		       __func__, idx, ev->u.login_flashnode.host_no);3611		err = -ENODEV;3612		goto put_host;3613	}3614 3615	dev = iscsi_find_flashnode_conn(fnode_sess);3616	if (!dev) {3617		err = -ENODEV;3618		goto put_sess;3619	}3620 3621	fnode_conn = iscsi_dev_to_flash_conn(dev);3622	err = transport->login_flashnode(fnode_sess, fnode_conn);3623	put_device(dev);3624 3625put_sess:3626	put_device(&fnode_sess->dev);3627 3628put_host:3629	scsi_host_put(shost);3630 3631exit_login_fnode:3632	return err;3633}3634 3635static int iscsi_logout_flashnode(struct iscsi_transport *transport,3636				  struct iscsi_uevent *ev)3637{3638	struct Scsi_Host *shost;3639	struct iscsi_bus_flash_session *fnode_sess;3640	struct iscsi_bus_flash_conn *fnode_conn;3641	struct device *dev;3642	uint32_t idx;3643	int err = 0;3644 3645	if (!transport->logout_flashnode) {3646		err = -ENOSYS;3647		goto exit_logout_fnode;3648	}3649 3650	shost = scsi_host_lookup(ev->u.logout_flashnode.host_no);3651	if (!shost) {3652		pr_err("%s could not find host no %u\n",3653		       __func__, ev->u.logout_flashnode.host_no);3654		err = -ENODEV;3655		goto put_host;3656	}3657 3658	idx = ev->u.logout_flashnode.flashnode_idx;3659	fnode_sess = iscsi_get_flashnode_by_index(shost, idx);3660	if (!fnode_sess) {3661		pr_err("%s could not find flashnode %u for host no %u\n",3662		       __func__, idx, ev->u.logout_flashnode.host_no);3663		err = -ENODEV;3664		goto put_host;3665	}3666 3667	dev = iscsi_find_flashnode_conn(fnode_sess);3668	if (!dev) {3669		err = -ENODEV;3670		goto put_sess;3671	}3672 3673	fnode_conn = iscsi_dev_to_flash_conn(dev);3674 3675	err = transport->logout_flashnode(fnode_sess, fnode_conn);3676	put_device(dev);3677 3678put_sess:3679	put_device(&fnode_sess->dev);3680 3681put_host:3682	scsi_host_put(shost);3683 3684exit_logout_fnode:3685	return err;3686}3687 3688static int iscsi_logout_flashnode_sid(struct iscsi_transport *transport,3689				      struct iscsi_uevent *ev)3690{3691	struct Scsi_Host *shost;3692	struct iscsi_cls_session *session;3693	int err = 0;3694 3695	if (!transport->logout_flashnode_sid) {3696		err = -ENOSYS;3697		goto exit_logout_sid;3698	}3699 3700	shost = scsi_host_lookup(ev->u.logout_flashnode_sid.host_no);3701	if (!shost) {3702		pr_err("%s could not find host no %u\n",3703		       __func__, ev->u.logout_flashnode.host_no);3704		err = -ENODEV;3705		goto put_host;3706	}3707 3708	session = iscsi_session_lookup(ev->u.logout_flashnode_sid.sid);3709	if (!session) {3710		pr_err("%s could not find session id %u\n",3711		       __func__, ev->u.logout_flashnode_sid.sid);3712		err = -EINVAL;3713		goto put_host;3714	}3715 3716	err = transport->logout_flashnode_sid(session);3717 3718put_host:3719	scsi_host_put(shost);3720 3721exit_logout_sid:3722	return err;3723}3724 3725static int3726iscsi_get_host_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)3727{3728	struct iscsi_uevent *ev = nlmsg_data(nlh);3729	struct Scsi_Host *shost = NULL;3730	struct iscsi_internal *priv;3731	struct sk_buff *skbhost_stats;3732	struct nlmsghdr *nlhhost_stats;3733	struct iscsi_uevent *evhost_stats;3734	int host_stats_size = 0;3735	int len, err = 0;3736	char *buf;3737 3738	if (!transport->get_host_stats)3739		return -ENOSYS;3740 3741	priv = iscsi_if_transport_lookup(transport);3742	if (!priv)3743		return -EINVAL;3744 3745	host_stats_size = sizeof(struct iscsi_offload_host_stats);3746	len = nlmsg_total_size(sizeof(*ev) + host_stats_size);3747 3748	shost = scsi_host_lookup(ev->u.get_host_stats.host_no);3749	if (!shost) {3750		pr_err("%s: failed. Could not find host no %u\n",3751		       __func__, ev->u.get_host_stats.host_no);3752		return -ENODEV;3753	}3754 3755	do {3756		int actual_size;3757 3758		skbhost_stats = alloc_skb(len, GFP_KERNEL);3759		if (!skbhost_stats) {3760			pr_err("cannot deliver host stats: OOM\n");3761			err = -ENOMEM;3762			goto exit_host_stats;3763		}3764 3765		nlhhost_stats = __nlmsg_put(skbhost_stats, 0, 0, 0,3766				      (len - sizeof(*nlhhost_stats)), 0);3767		evhost_stats = nlmsg_data(nlhhost_stats);3768		memset(evhost_stats, 0, sizeof(*evhost_stats));3769		evhost_stats->transport_handle = iscsi_handle(transport);3770		evhost_stats->type = nlh->nlmsg_type;3771		evhost_stats->u.get_host_stats.host_no =3772					ev->u.get_host_stats.host_no;3773		buf = (char *)evhost_stats + sizeof(*evhost_stats);3774		memset(buf, 0, host_stats_size);3775 3776		err = transport->get_host_stats(shost, buf, host_stats_size);3777		if (err) {3778			kfree_skb(skbhost_stats);3779			goto exit_host_stats;3780		}3781 3782		actual_size = nlmsg_total_size(sizeof(*ev) + host_stats_size);3783		skb_trim(skbhost_stats, NLMSG_ALIGN(actual_size));3784		nlhhost_stats->nlmsg_len = actual_size;3785 3786		err = iscsi_multicast_skb(skbhost_stats, ISCSI_NL_GRP_ISCSID,3787					  GFP_KERNEL);3788	} while (err < 0 && err != -ECONNREFUSED);3789 3790exit_host_stats:3791	scsi_host_put(shost);3792	return err;3793}3794 3795static int iscsi_if_transport_conn(struct iscsi_transport *transport,3796				   struct nlmsghdr *nlh, u32 pdu_len)3797{3798	struct iscsi_uevent *ev = nlmsg_data(nlh);3799	struct iscsi_cls_session *session;3800	struct iscsi_cls_conn *conn = NULL;3801	struct iscsi_endpoint *ep;3802	int err = 0;3803 3804	switch (nlh->nlmsg_type) {3805	case ISCSI_UEVENT_CREATE_CONN:3806		return iscsi_if_create_conn(transport, ev);3807	case ISCSI_UEVENT_DESTROY_CONN:3808		return iscsi_if_destroy_conn(transport, ev);3809	case ISCSI_UEVENT_STOP_CONN:3810		conn = iscsi_conn_lookup(ev->u.stop_conn.sid,3811					 ev->u.stop_conn.cid);3812		if (!conn)3813			return -EINVAL;3814 3815		return iscsi_if_stop_conn(conn, ev->u.stop_conn.flag);3816	}3817 3818	/*3819	 * The following cmds need to be run under the ep_mutex so in kernel3820	 * conn cleanup (ep_disconnect + unbind and conn) is not done while3821	 * these are running. They also must not run if we have just run a conn3822	 * cleanup because they would set the state in a way that might allow3823	 * IO or send IO themselves.3824	 */3825	switch (nlh->nlmsg_type) {3826	case ISCSI_UEVENT_START_CONN:3827		conn = iscsi_conn_lookup(ev->u.start_conn.sid,3828					 ev->u.start_conn.cid);3829		break;3830	case ISCSI_UEVENT_BIND_CONN:3831		conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid);3832		break;3833	case ISCSI_UEVENT_SEND_PDU:3834		conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid);3835		break;3836	}3837 3838	if (!conn)3839		return -EINVAL;3840 3841	mutex_lock(&conn->ep_mutex);3842	spin_lock_irq(&conn->lock);3843	if (test_bit(ISCSI_CLS_CONN_BIT_CLEANUP, &conn->flags)) {3844		spin_unlock_irq(&conn->lock);3845		mutex_unlock(&conn->ep_mutex);3846		ev->r.retcode = -ENOTCONN;3847		return 0;3848	}3849	spin_unlock_irq(&conn->lock);3850 3851	switch (nlh->nlmsg_type) {3852	case ISCSI_UEVENT_BIND_CONN:3853		session = iscsi_session_lookup(ev->u.b_conn.sid);3854		if (!session) {3855			err = -EINVAL;3856			break;3857		}3858 3859		ev->r.retcode =	transport->bind_conn(session, conn,3860						ev->u.b_conn.transport_eph,3861						ev->u.b_conn.is_leading);3862		if (!ev->r.retcode)3863			WRITE_ONCE(conn->state, ISCSI_CONN_BOUND);3864 3865		if (ev->r.retcode || !transport->ep_connect)3866			break;3867 3868		ep = iscsi_lookup_endpoint(ev->u.b_conn.transport_eph);3869		if (ep) {3870			ep->conn = conn;3871			conn->ep = ep;3872			iscsi_put_endpoint(ep);3873		} else {3874			err = -ENOTCONN;3875			iscsi_cls_conn_printk(KERN_ERR, conn,3876					      "Could not set ep conn binding\n");3877		}3878		break;3879	case ISCSI_UEVENT_START_CONN:3880		ev->r.retcode = transport->start_conn(conn);3881		if (!ev->r.retcode)3882			WRITE_ONCE(conn->state, ISCSI_CONN_UP);3883 3884		break;3885	case ISCSI_UEVENT_SEND_PDU:3886		if ((ev->u.send_pdu.hdr_size > pdu_len) ||3887		    (ev->u.send_pdu.data_size > (pdu_len - ev->u.send_pdu.hdr_size))) {3888			err = -EINVAL;3889			break;3890		}3891 3892		ev->r.retcode =	transport->send_pdu(conn,3893				(struct iscsi_hdr *)((char *)ev + sizeof(*ev)),3894				(char *)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,3895				ev->u.send_pdu.data_size);3896		break;3897	default:3898		err = -ENOSYS;3899	}3900 3901	mutex_unlock(&conn->ep_mutex);3902	return err;3903}3904 3905static int3906iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, uint32_t *group)3907{3908	int err = 0;3909	u32 portid;3910	struct iscsi_uevent *ev = nlmsg_data(nlh);3911	struct iscsi_transport *transport = NULL;3912	struct iscsi_internal *priv;3913	struct iscsi_cls_session *session;3914	struct iscsi_endpoint *ep = NULL;3915	u32 rlen;3916 3917	if (!netlink_capable(skb, CAP_SYS_ADMIN))3918		return -EPERM;3919 3920	if (nlh->nlmsg_type == ISCSI_UEVENT_PATH_UPDATE)3921		*group = ISCSI_NL_GRP_UIP;3922	else3923		*group = ISCSI_NL_GRP_ISCSID;3924 3925	priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle));3926	if (!priv)3927		return -EINVAL;3928	transport = priv->iscsi_transport;3929 3930	if (!try_module_get(transport->owner))3931		return -EINVAL;3932 3933	portid = NETLINK_CB(skb).portid;3934 3935	/*3936	 * Even though the remaining payload may not be regarded as nlattr,3937	 * (like address or something else), calculate the remaining length3938	 * here to ease following length checks.3939	 */3940	rlen = nlmsg_attrlen(nlh, sizeof(*ev));3941 3942	switch (nlh->nlmsg_type) {3943	case ISCSI_UEVENT_CREATE_SESSION:3944		err = iscsi_if_create_session(priv, ep, ev,3945					      portid,3946					      ev->u.c_session.initial_cmdsn,3947					      ev->u.c_session.cmds_max,3948					      ev->u.c_session.queue_depth);3949		break;3950	case ISCSI_UEVENT_CREATE_BOUND_SESSION:3951		ep = iscsi_lookup_endpoint(ev->u.c_bound_session.ep_handle);3952		if (!ep) {3953			err = -EINVAL;3954			break;3955		}3956 3957		err = iscsi_if_create_session(priv, ep, ev,3958					portid,3959					ev->u.c_bound_session.initial_cmdsn,3960					ev->u.c_bound_session.cmds_max,3961					ev->u.c_bound_session.queue_depth);3962		iscsi_put_endpoint(ep);3963		break;3964	case ISCSI_UEVENT_DESTROY_SESSION:3965		session = iscsi_session_lookup(ev->u.d_session.sid);3966		if (!session)3967			err = -EINVAL;3968		else if (iscsi_session_has_conns(ev->u.d_session.sid))3969			err = -EBUSY;3970		else3971			transport->destroy_session(session);3972		break;3973	case ISCSI_UEVENT_DESTROY_SESSION_ASYNC:3974		session = iscsi_session_lookup(ev->u.d_session.sid);3975		if (!session)3976			err = -EINVAL;3977		else if (iscsi_session_has_conns(ev->u.d_session.sid))3978			err = -EBUSY;3979		else {3980			unsigned long flags;3981 3982			/* Prevent this session from being found again */3983			spin_lock_irqsave(&sesslock, flags);3984			list_del_init(&session->sess_list);3985			spin_unlock_irqrestore(&sesslock, flags);3986 3987			queue_work(system_unbound_wq, &session->destroy_work);3988		}3989		break;3990	case ISCSI_UEVENT_UNBIND_SESSION:3991		session = iscsi_session_lookup(ev->u.d_session.sid);3992		if (session)3993			queue_work(session->workq, &session->unbind_work);3994		else3995			err = -EINVAL;3996		break;3997	case ISCSI_UEVENT_SET_PARAM:3998		err = iscsi_if_set_param(transport, ev, rlen);3999		break;4000	case ISCSI_UEVENT_CREATE_CONN:4001	case ISCSI_UEVENT_DESTROY_CONN:4002	case ISCSI_UEVENT_STOP_CONN:4003	case ISCSI_UEVENT_START_CONN:4004	case ISCSI_UEVENT_BIND_CONN:4005	case ISCSI_UEVENT_SEND_PDU:4006		err = iscsi_if_transport_conn(transport, nlh, rlen);4007		break;4008	case ISCSI_UEVENT_GET_STATS:4009		err = iscsi_if_get_stats(transport, nlh);4010		break;4011	case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:4012	case ISCSI_UEVENT_TRANSPORT_EP_POLL:4013	case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:4014	case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST:4015		err = iscsi_if_transport_ep(transport, ev, nlh->nlmsg_type, rlen);4016		break;4017	case ISCSI_UEVENT_TGT_DSCVR:4018		err = iscsi_tgt_dscvr(transport, ev, rlen);4019		break;4020	case ISCSI_UEVENT_SET_HOST_PARAM:4021		err = iscsi_set_host_param(transport, ev, rlen);4022		break;4023	case ISCSI_UEVENT_PATH_UPDATE:4024		err = iscsi_set_path(transport, ev, rlen);4025		break;4026	case ISCSI_UEVENT_SET_IFACE_PARAMS:4027		err = iscsi_set_iface_params(transport, ev, rlen);4028		break;4029	case ISCSI_UEVENT_PING:4030		err = iscsi_send_ping(transport, ev, rlen);4031		break;4032	case ISCSI_UEVENT_GET_CHAP:4033		err = iscsi_get_chap(transport, nlh);4034		break;4035	case ISCSI_UEVENT_DELETE_CHAP:4036		err = iscsi_delete_chap(transport, ev);4037		break;4038	case ISCSI_UEVENT_SET_FLASHNODE_PARAMS:4039		err = iscsi_set_flashnode_param(transport, ev, rlen);4040		break;4041	case ISCSI_UEVENT_NEW_FLASHNODE:4042		err = iscsi_new_flashnode(transport, ev, rlen);4043		break;4044	case ISCSI_UEVENT_DEL_FLASHNODE:4045		err = iscsi_del_flashnode(transport, ev);4046		break;4047	case ISCSI_UEVENT_LOGIN_FLASHNODE:4048		err = iscsi_login_flashnode(transport, ev);4049		break;4050	case ISCSI_UEVENT_LOGOUT_FLASHNODE:4051		err = iscsi_logout_flashnode(transport, ev);4052		break;4053	case ISCSI_UEVENT_LOGOUT_FLASHNODE_SID:4054		err = iscsi_logout_flashnode_sid(transport, ev);4055		break;4056	case ISCSI_UEVENT_SET_CHAP:4057		err = iscsi_set_chap(transport, ev, rlen);4058		break;4059	case ISCSI_UEVENT_GET_HOST_STATS:4060		err = iscsi_get_host_stats(transport, nlh);4061		break;4062	default:4063		err = -ENOSYS;4064		break;4065	}4066 4067	module_put(transport->owner);4068	return err;4069}4070 4071/*4072 * Get message from skb.  Each message is processed by iscsi_if_recv_msg.4073 * Malformed skbs with wrong lengths or invalid creds are not processed.4074 */4075static void4076iscsi_if_rx(struct sk_buff *skb)4077{4078	u32 portid = NETLINK_CB(skb).portid;4079 4080	mutex_lock(&rx_queue_mutex);4081	while (skb->len >= NLMSG_HDRLEN) {4082		int err;4083		uint32_t rlen;4084		struct nlmsghdr	*nlh;4085		struct iscsi_uevent *ev;4086		uint32_t group;4087		int retries = ISCSI_SEND_MAX_ALLOWED;4088 4089		nlh = nlmsg_hdr(skb);4090		if (nlh->nlmsg_len < sizeof(*nlh) + sizeof(*ev) ||4091		    skb->len < nlh->nlmsg_len) {4092			break;4093		}4094 4095		ev = nlmsg_data(nlh);4096		rlen = NLMSG_ALIGN(nlh->nlmsg_len);4097		if (rlen > skb->len)4098			rlen = skb->len;4099 4100		err = iscsi_if_recv_msg(skb, nlh, &group);4101		if (err) {4102			ev->type = ISCSI_KEVENT_IF_ERROR;4103			ev->iferror = err;4104		}4105		do {4106			/*4107			 * special case for GET_STATS:4108			 * on success - sending reply and stats from4109			 * inside of if_recv_msg(),4110			 * on error - fall through.4111			 */4112			if (ev->type == ISCSI_UEVENT_GET_STATS && !err)4113				break;4114			if (ev->type == ISCSI_UEVENT_GET_CHAP && !err)4115				break;4116			err = iscsi_if_send_reply(portid, nlh->nlmsg_type,4117						  ev, sizeof(*ev));4118			if (err == -EAGAIN && --retries < 0) {4119				printk(KERN_WARNING "Send reply failed, error %d\n", err);4120				break;4121			}4122		} while (err < 0 && err != -ECONNREFUSED && err != -ESRCH);4123		skb_pull(skb, rlen);4124	}4125	mutex_unlock(&rx_queue_mutex);4126}4127 4128#define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store)		\4129struct device_attribute dev_attr_##_prefix##_##_name =	\4130	__ATTR(_name,_mode,_show,_store)4131 4132/*4133 * iSCSI connection attrs4134 */4135#define iscsi_conn_attr_show(param)					\4136static ssize_t								\4137show_conn_param_##param(struct device *dev, 				\4138			struct device_attribute *attr, char *buf)	\4139{									\4140	struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent);	\4141	struct iscsi_transport *t = conn->transport;			\4142	return t->get_conn_param(conn, param, buf);			\4143}4144 4145#define iscsi_conn_attr(field, param)					\4146	iscsi_conn_attr_show(param)					\4147static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param,	\4148			NULL);4149 4150iscsi_conn_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH);4151iscsi_conn_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH);4152iscsi_conn_attr(header_digest, ISCSI_PARAM_HDRDGST_EN);4153iscsi_conn_attr(data_digest, ISCSI_PARAM_DATADGST_EN);4154iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN);4155iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN);4156iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT);4157iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN);4158iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS);4159iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);4160iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);4161iscsi_conn_attr(local_port, ISCSI_PARAM_LOCAL_PORT);4162iscsi_conn_attr(statsn, ISCSI_PARAM_STATSN);4163iscsi_conn_attr(keepalive_tmo, ISCSI_PARAM_KEEPALIVE_TMO);4164iscsi_conn_attr(max_segment_size, ISCSI_PARAM_MAX_SEGMENT_SIZE);4165iscsi_conn_attr(tcp_timestamp_stat, ISCSI_PARAM_TCP_TIMESTAMP_STAT);4166iscsi_conn_attr(tcp_wsf_disable, ISCSI_PARAM_TCP_WSF_DISABLE);4167iscsi_conn_attr(tcp_nagle_disable, ISCSI_PARAM_TCP_NAGLE_DISABLE);4168iscsi_conn_attr(tcp_timer_scale, ISCSI_PARAM_TCP_TIMER_SCALE);4169iscsi_conn_attr(tcp_timestamp_enable, ISCSI_PARAM_TCP_TIMESTAMP_EN);4170iscsi_conn_attr(fragment_disable, ISCSI_PARAM_IP_FRAGMENT_DISABLE);4171iscsi_conn_attr(ipv4_tos, ISCSI_PARAM_IPV4_TOS);4172iscsi_conn_attr(ipv6_traffic_class, ISCSI_PARAM_IPV6_TC);4173iscsi_conn_attr(ipv6_flow_label, ISCSI_PARAM_IPV6_FLOW_LABEL);4174iscsi_conn_attr(is_fw_assigned_ipv6, ISCSI_PARAM_IS_FW_ASSIGNED_IPV6);4175iscsi_conn_attr(tcp_xmit_wsf, ISCSI_PARAM_TCP_XMIT_WSF);4176iscsi_conn_attr(tcp_recv_wsf, ISCSI_PARAM_TCP_RECV_WSF);4177iscsi_conn_attr(local_ipaddr, ISCSI_PARAM_LOCAL_IPADDR);4178 4179static const char *const connection_state_names[] = {4180	[ISCSI_CONN_UP] = "up",4181	[ISCSI_CONN_DOWN] = "down",4182	[ISCSI_CONN_FAILED] = "failed",4183	[ISCSI_CONN_BOUND] = "bound"4184};4185 4186static ssize_t show_conn_state(struct device *dev,4187			       struct device_attribute *attr, char *buf)4188{4189	struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent);4190	const char *state = "unknown";4191	int conn_state = READ_ONCE(conn->state);4192 4193	if (conn_state >= 0 &&4194	    conn_state < ARRAY_SIZE(connection_state_names))4195		state = connection_state_names[conn_state];4196 4197	return sysfs_emit(buf, "%s\n", state);4198}4199static ISCSI_CLASS_ATTR(conn, state, S_IRUGO, show_conn_state,4200			NULL);4201 4202#define iscsi_conn_ep_attr_show(param)					\4203static ssize_t show_conn_ep_param_##param(struct device *dev,		\4204					  struct device_attribute *attr,\4205					  char *buf)			\4206{									\4207	struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent);	\4208	struct iscsi_transport *t = conn->transport;			\4209	struct iscsi_endpoint *ep;					\4210	ssize_t rc;							\4211									\4212	/*								\4213	 * Need to make sure ep_disconnect does not free the LLD's	\4214	 * interconnect resources while we are trying to read them.	\4215	 */								\4216	mutex_lock(&conn->ep_mutex);					\4217	ep = conn->ep;							\4218	if (!ep && t->ep_connect) {					\4219		mutex_unlock(&conn->ep_mutex);				\4220		return -ENOTCONN;					\4221	}								\4222									\4223	if (ep)								\4224		rc = t->get_ep_param(ep, param, buf);			\4225	else								\4226		rc = t->get_conn_param(conn, param, buf);		\4227	mutex_unlock(&conn->ep_mutex);					\4228	return rc;							\4229}4230 4231#define iscsi_conn_ep_attr(field, param)				\4232	iscsi_conn_ep_attr_show(param)					\4233static ISCSI_CLASS_ATTR(conn, field, S_IRUGO,				\4234			show_conn_ep_param_##param, NULL);4235 4236iscsi_conn_ep_attr(address, ISCSI_PARAM_CONN_ADDRESS);4237iscsi_conn_ep_attr(port, ISCSI_PARAM_CONN_PORT);4238 4239static struct attribute *iscsi_conn_attrs[] = {4240	&dev_attr_conn_max_recv_dlength.attr,4241	&dev_attr_conn_max_xmit_dlength.attr,4242	&dev_attr_conn_header_digest.attr,4243	&dev_attr_conn_data_digest.attr,4244	&dev_attr_conn_ifmarker.attr,4245	&dev_attr_conn_ofmarker.attr,4246	&dev_attr_conn_address.attr,4247	&dev_attr_conn_port.attr,4248	&dev_attr_conn_exp_statsn.attr,4249	&dev_attr_conn_persistent_address.attr,4250	&dev_attr_conn_persistent_port.attr,4251	&dev_attr_conn_ping_tmo.attr,4252	&dev_attr_conn_recv_tmo.attr,4253	&dev_attr_conn_local_port.attr,4254	&dev_attr_conn_statsn.attr,4255	&dev_attr_conn_keepalive_tmo.attr,4256	&dev_attr_conn_max_segment_size.attr,4257	&dev_attr_conn_tcp_timestamp_stat.attr,4258	&dev_attr_conn_tcp_wsf_disable.attr,4259	&dev_attr_conn_tcp_nagle_disable.attr,4260	&dev_attr_conn_tcp_timer_scale.attr,4261	&dev_attr_conn_tcp_timestamp_enable.attr,4262	&dev_attr_conn_fragment_disable.attr,4263	&dev_attr_conn_ipv4_tos.attr,4264	&dev_attr_conn_ipv6_traffic_class.attr,4265	&dev_attr_conn_ipv6_flow_label.attr,4266	&dev_attr_conn_is_fw_assigned_ipv6.attr,4267	&dev_attr_conn_tcp_xmit_wsf.attr,4268	&dev_attr_conn_tcp_recv_wsf.attr,4269	&dev_attr_conn_local_ipaddr.attr,4270	&dev_attr_conn_state.attr,4271	NULL,4272};4273 4274static umode_t iscsi_conn_attr_is_visible(struct kobject *kobj,4275					 struct attribute *attr, int i)4276{4277	struct device *cdev = container_of(kobj, struct device, kobj);4278	struct iscsi_cls_conn *conn = transport_class_to_conn(cdev);4279	struct iscsi_transport *t = conn->transport;4280	int param;4281 4282	if (attr == &dev_attr_conn_max_recv_dlength.attr)4283		param = ISCSI_PARAM_MAX_RECV_DLENGTH;4284	else if (attr == &dev_attr_conn_max_xmit_dlength.attr)4285		param = ISCSI_PARAM_MAX_XMIT_DLENGTH;4286	else if (attr == &dev_attr_conn_header_digest.attr)4287		param = ISCSI_PARAM_HDRDGST_EN;4288	else if (attr == &dev_attr_conn_data_digest.attr)4289		param = ISCSI_PARAM_DATADGST_EN;4290	else if (attr == &dev_attr_conn_ifmarker.attr)4291		param = ISCSI_PARAM_IFMARKER_EN;4292	else if (attr == &dev_attr_conn_ofmarker.attr)4293		param = ISCSI_PARAM_OFMARKER_EN;4294	else if (attr == &dev_attr_conn_address.attr)4295		param = ISCSI_PARAM_CONN_ADDRESS;4296	else if (attr == &dev_attr_conn_port.attr)4297		param = ISCSI_PARAM_CONN_PORT;4298	else if (attr == &dev_attr_conn_exp_statsn.attr)4299		param = ISCSI_PARAM_EXP_STATSN;4300	else if (attr == &dev_attr_conn_persistent_address.attr)4301		param = ISCSI_PARAM_PERSISTENT_ADDRESS;4302	else if (attr == &dev_attr_conn_persistent_port.attr)4303		param = ISCSI_PARAM_PERSISTENT_PORT;4304	else if (attr == &dev_attr_conn_ping_tmo.attr)4305		param = ISCSI_PARAM_PING_TMO;4306	else if (attr == &dev_attr_conn_recv_tmo.attr)4307		param = ISCSI_PARAM_RECV_TMO;4308	else if (attr == &dev_attr_conn_local_port.attr)4309		param = ISCSI_PARAM_LOCAL_PORT;4310	else if (attr == &dev_attr_conn_statsn.attr)4311		param = ISCSI_PARAM_STATSN;4312	else if (attr == &dev_attr_conn_keepalive_tmo.attr)4313		param = ISCSI_PARAM_KEEPALIVE_TMO;4314	else if (attr == &dev_attr_conn_max_segment_size.attr)4315		param = ISCSI_PARAM_MAX_SEGMENT_SIZE;4316	else if (attr == &dev_attr_conn_tcp_timestamp_stat.attr)4317		param = ISCSI_PARAM_TCP_TIMESTAMP_STAT;4318	else if (attr == &dev_attr_conn_tcp_wsf_disable.attr)4319		param = ISCSI_PARAM_TCP_WSF_DISABLE;4320	else if (attr == &dev_attr_conn_tcp_nagle_disable.attr)4321		param = ISCSI_PARAM_TCP_NAGLE_DISABLE;4322	else if (attr == &dev_attr_conn_tcp_timer_scale.attr)4323		param = ISCSI_PARAM_TCP_TIMER_SCALE;4324	else if (attr == &dev_attr_conn_tcp_timestamp_enable.attr)4325		param = ISCSI_PARAM_TCP_TIMESTAMP_EN;4326	else if (attr == &dev_attr_conn_fragment_disable.attr)4327		param = ISCSI_PARAM_IP_FRAGMENT_DISABLE;4328	else if (attr == &dev_attr_conn_ipv4_tos.attr)4329		param = ISCSI_PARAM_IPV4_TOS;4330	else if (attr == &dev_attr_conn_ipv6_traffic_class.attr)4331		param = ISCSI_PARAM_IPV6_TC;4332	else if (attr == &dev_attr_conn_ipv6_flow_label.attr)4333		param = ISCSI_PARAM_IPV6_FLOW_LABEL;4334	else if (attr == &dev_attr_conn_is_fw_assigned_ipv6.attr)4335		param = ISCSI_PARAM_IS_FW_ASSIGNED_IPV6;4336	else if (attr == &dev_attr_conn_tcp_xmit_wsf.attr)4337		param = ISCSI_PARAM_TCP_XMIT_WSF;4338	else if (attr == &dev_attr_conn_tcp_recv_wsf.attr)4339		param = ISCSI_PARAM_TCP_RECV_WSF;4340	else if (attr == &dev_attr_conn_local_ipaddr.attr)4341		param = ISCSI_PARAM_LOCAL_IPADDR;4342	else if (attr == &dev_attr_conn_state.attr)4343		return S_IRUGO;4344	else {4345		WARN_ONCE(1, "Invalid conn attr");4346		return 0;4347	}4348 4349	return t->attr_is_visible(ISCSI_PARAM, param);4350}4351 4352static struct attribute_group iscsi_conn_group = {4353	.attrs = iscsi_conn_attrs,4354	.is_visible = iscsi_conn_attr_is_visible,4355};4356 4357/*4358 * iSCSI session attrs4359 */4360#define iscsi_session_attr_show(param, perm)				\4361static ssize_t								\4362show_session_param_##param(struct device *dev,				\4363			   struct device_attribute *attr, char *buf)	\4364{									\4365	struct iscsi_cls_session *session = 				\4366		iscsi_dev_to_session(dev->parent);			\4367	struct iscsi_transport *t = session->transport;			\4368									\4369	if (perm && !capable(CAP_SYS_ADMIN))				\4370		return -EACCES;						\4371	return t->get_session_param(session, param, buf);		\4372}4373 4374#define iscsi_session_attr(field, param, perm)				\4375	iscsi_session_attr_show(param, perm)				\4376static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \4377			NULL);4378iscsi_session_attr(targetname, ISCSI_PARAM_TARGET_NAME, 0);4379iscsi_session_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN, 0);4380iscsi_session_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T, 0);4381iscsi_session_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN, 0);4382iscsi_session_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST, 0);4383iscsi_session_attr(max_burst_len, ISCSI_PARAM_MAX_BURST, 0);4384iscsi_session_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN, 0);4385iscsi_session_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN, 0);4386iscsi_session_attr(erl, ISCSI_PARAM_ERL, 0);4387iscsi_session_attr(tpgt, ISCSI_PARAM_TPGT, 0);4388iscsi_session_attr(username, ISCSI_PARAM_USERNAME, 1);4389iscsi_session_attr(username_in, ISCSI_PARAM_USERNAME_IN, 1);4390iscsi_session_attr(password, ISCSI_PARAM_PASSWORD, 1);4391iscsi_session_attr(password_in, ISCSI_PARAM_PASSWORD_IN, 1);4392iscsi_session_attr(chap_out_idx, ISCSI_PARAM_CHAP_OUT_IDX, 1);4393iscsi_session_attr(chap_in_idx, ISCSI_PARAM_CHAP_IN_IDX, 1);4394iscsi_session_attr(fast_abort, ISCSI_PARAM_FAST_ABORT, 0);4395iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0);4396iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0);4397iscsi_session_attr(tgt_reset_tmo, ISCSI_PARAM_TGT_RESET_TMO, 0);4398iscsi_session_attr(ifacename, ISCSI_PARAM_IFACE_NAME, 0);4399iscsi_session_attr(initiatorname, ISCSI_PARAM_INITIATOR_NAME, 0);4400iscsi_session_attr(targetalias, ISCSI_PARAM_TARGET_ALIAS, 0);4401iscsi_session_attr(boot_root, ISCSI_PARAM_BOOT_ROOT, 0);4402iscsi_session_attr(boot_nic, ISCSI_PARAM_BOOT_NIC, 0);4403iscsi_session_attr(boot_target, ISCSI_PARAM_BOOT_TARGET, 0);4404iscsi_session_attr(auto_snd_tgt_disable, ISCSI_PARAM_AUTO_SND_TGT_DISABLE, 0);4405iscsi_session_attr(discovery_session, ISCSI_PARAM_DISCOVERY_SESS, 0);4406iscsi_session_attr(portal_type, ISCSI_PARAM_PORTAL_TYPE, 0);4407iscsi_session_attr(chap_auth, ISCSI_PARAM_CHAP_AUTH_EN, 0);4408iscsi_session_attr(discovery_logout, ISCSI_PARAM_DISCOVERY_LOGOUT_EN, 0);4409iscsi_session_attr(bidi_chap, ISCSI_PARAM_BIDI_CHAP_EN, 0);4410iscsi_session_attr(discovery_auth_optional,4411		   ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL, 0);4412iscsi_session_attr(def_time2wait, ISCSI_PARAM_DEF_TIME2WAIT, 0);4413iscsi_session_attr(def_time2retain, ISCSI_PARAM_DEF_TIME2RETAIN, 0);4414iscsi_session_attr(isid, ISCSI_PARAM_ISID, 0);4415iscsi_session_attr(tsid, ISCSI_PARAM_TSID, 0);4416iscsi_session_attr(def_taskmgmt_tmo, ISCSI_PARAM_DEF_TASKMGMT_TMO, 0);4417iscsi_session_attr(discovery_parent_idx, ISCSI_PARAM_DISCOVERY_PARENT_IDX, 0);4418iscsi_session_attr(discovery_parent_type, ISCSI_PARAM_DISCOVERY_PARENT_TYPE, 0);4419 4420static ssize_t4421show_priv_session_target_state(struct device *dev, struct device_attribute *attr,4422			char *buf)4423{4424	struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);4425 4426	return sysfs_emit(buf, "%s\n",4427			iscsi_session_target_state_name[session->target_state]);4428}4429 4430static ISCSI_CLASS_ATTR(priv_sess, target_state, S_IRUGO,4431			show_priv_session_target_state, NULL);4432 4433static ssize_t4434show_priv_session_state(struct device *dev, struct device_attribute *attr,4435			char *buf)4436{4437	struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);4438	return sysfs_emit(buf, "%s\n", iscsi_session_state_name(session->state));4439}4440static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,4441			NULL);4442static ssize_t4443show_priv_session_creator(struct device *dev, struct device_attribute *attr,4444			char *buf)4445{4446	struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);4447	return sysfs_emit(buf, "%d\n", session->creator);4448}4449static ISCSI_CLASS_ATTR(priv_sess, creator, S_IRUGO, show_priv_session_creator,4450			NULL);4451static ssize_t4452show_priv_session_target_id(struct device *dev, struct device_attribute *attr,4453			    char *buf)4454{4455	struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);4456	return sysfs_emit(buf, "%d\n", session->target_id);4457}4458static ISCSI_CLASS_ATTR(priv_sess, target_id, S_IRUGO,4459			show_priv_session_target_id, NULL);4460 4461#define iscsi_priv_session_attr_show(field, format)			\4462static ssize_t								\4463show_priv_session_##field(struct device *dev, 				\4464			  struct device_attribute *attr, char *buf)	\4465{									\4466	struct iscsi_cls_session *session = 				\4467			iscsi_dev_to_session(dev->parent);		\4468	if (session->field == -1)					\4469		return sysfs_emit(buf, "off\n");			\4470	return sysfs_emit(buf, format"\n", session->field);		\4471}4472 4473#define iscsi_priv_session_attr_store(field)				\4474static ssize_t								\4475store_priv_session_##field(struct device *dev,				\4476			   struct device_attribute *attr,		\4477			   const char *buf, size_t count)		\4478{									\4479	int val;							\4480	char *cp;							\4481	struct iscsi_cls_session *session =				\4482		iscsi_dev_to_session(dev->parent);			\4483	if ((session->state == ISCSI_SESSION_FREE) ||			\4484	    (session->state == ISCSI_SESSION_FAILED))			\4485		return -EBUSY;						\4486	if (strncmp(buf, "off", 3) == 0) {				\4487		session->field = -1;					\4488		session->field##_sysfs_override = true;			\4489	} else {							\4490		val = simple_strtoul(buf, &cp, 0);			\4491		if (*cp != '\0' && *cp != '\n')				\4492			return -EINVAL;					\4493		session->field = val;					\4494		session->field##_sysfs_override = true;			\4495	}								\4496	return count;							\4497}4498 4499#define iscsi_priv_session_rw_attr(field, format)			\4500	iscsi_priv_session_attr_show(field, format)			\4501	iscsi_priv_session_attr_store(field)				\4502static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO | S_IWUSR,		\4503			show_priv_session_##field,			\4504			store_priv_session_##field)4505 4506iscsi_priv_session_rw_attr(recovery_tmo, "%d");4507 4508static struct attribute *iscsi_session_attrs[] = {4509	&dev_attr_sess_initial_r2t.attr,4510	&dev_attr_sess_max_outstanding_r2t.attr,4511	&dev_attr_sess_immediate_data.attr,4512	&dev_attr_sess_first_burst_len.attr,4513	&dev_attr_sess_max_burst_len.attr,4514	&dev_attr_sess_data_pdu_in_order.attr,4515	&dev_attr_sess_data_seq_in_order.attr,4516	&dev_attr_sess_erl.attr,4517	&dev_attr_sess_targetname.attr,4518	&dev_attr_sess_tpgt.attr,4519	&dev_attr_sess_password.attr,4520	&dev_attr_sess_password_in.attr,4521	&dev_attr_sess_username.attr,4522	&dev_attr_sess_username_in.attr,4523	&dev_attr_sess_fast_abort.attr,4524	&dev_attr_sess_abort_tmo.attr,4525	&dev_attr_sess_lu_reset_tmo.attr,4526	&dev_attr_sess_tgt_reset_tmo.attr,4527	&dev_attr_sess_ifacename.attr,4528	&dev_attr_sess_initiatorname.attr,4529	&dev_attr_sess_targetalias.attr,4530	&dev_attr_sess_boot_root.attr,4531	&dev_attr_sess_boot_nic.attr,4532	&dev_attr_sess_boot_target.attr,4533	&dev_attr_priv_sess_recovery_tmo.attr,4534	&dev_attr_priv_sess_state.attr,4535	&dev_attr_priv_sess_target_state.attr,4536	&dev_attr_priv_sess_creator.attr,4537	&dev_attr_sess_chap_out_idx.attr,4538	&dev_attr_sess_chap_in_idx.attr,4539	&dev_attr_priv_sess_target_id.attr,4540	&dev_attr_sess_auto_snd_tgt_disable.attr,4541	&dev_attr_sess_discovery_session.attr,4542	&dev_attr_sess_portal_type.attr,4543	&dev_attr_sess_chap_auth.attr,4544	&dev_attr_sess_discovery_logout.attr,4545	&dev_attr_sess_bidi_chap.attr,4546	&dev_attr_sess_discovery_auth_optional.attr,4547	&dev_attr_sess_def_time2wait.attr,4548	&dev_attr_sess_def_time2retain.attr,4549	&dev_attr_sess_isid.attr,4550	&dev_attr_sess_tsid.attr,4551	&dev_attr_sess_def_taskmgmt_tmo.attr,4552	&dev_attr_sess_discovery_parent_idx.attr,4553	&dev_attr_sess_discovery_parent_type.attr,4554	NULL,4555};4556 4557static umode_t iscsi_session_attr_is_visible(struct kobject *kobj,4558					    struct attribute *attr, int i)4559{4560	struct device *cdev = container_of(kobj, struct device, kobj);4561	struct iscsi_cls_session *session = transport_class_to_session(cdev);4562	struct iscsi_transport *t = session->transport;4563	int param;4564 4565	if (attr == &dev_attr_sess_initial_r2t.attr)4566		param = ISCSI_PARAM_INITIAL_R2T_EN;4567	else if (attr == &dev_attr_sess_max_outstanding_r2t.attr)4568		param = ISCSI_PARAM_MAX_R2T;4569	else if (attr == &dev_attr_sess_immediate_data.attr)4570		param = ISCSI_PARAM_IMM_DATA_EN;4571	else if (attr == &dev_attr_sess_first_burst_len.attr)4572		param = ISCSI_PARAM_FIRST_BURST;4573	else if (attr == &dev_attr_sess_max_burst_len.attr)4574		param = ISCSI_PARAM_MAX_BURST;4575	else if (attr == &dev_attr_sess_data_pdu_in_order.attr)4576		param = ISCSI_PARAM_PDU_INORDER_EN;4577	else if (attr == &dev_attr_sess_data_seq_in_order.attr)4578		param = ISCSI_PARAM_DATASEQ_INORDER_EN;4579	else if (attr == &dev_attr_sess_erl.attr)4580		param = ISCSI_PARAM_ERL;4581	else if (attr == &dev_attr_sess_targetname.attr)4582		param = ISCSI_PARAM_TARGET_NAME;4583	else if (attr == &dev_attr_sess_tpgt.attr)4584		param = ISCSI_PARAM_TPGT;4585	else if (attr == &dev_attr_sess_chap_in_idx.attr)4586		param = ISCSI_PARAM_CHAP_IN_IDX;4587	else if (attr == &dev_attr_sess_chap_out_idx.attr)4588		param = ISCSI_PARAM_CHAP_OUT_IDX;4589	else if (attr == &dev_attr_sess_password.attr)4590		param = ISCSI_PARAM_USERNAME;4591	else if (attr == &dev_attr_sess_password_in.attr)4592		param = ISCSI_PARAM_USERNAME_IN;4593	else if (attr == &dev_attr_sess_username.attr)4594		param = ISCSI_PARAM_PASSWORD;4595	else if (attr == &dev_attr_sess_username_in.attr)4596		param = ISCSI_PARAM_PASSWORD_IN;4597	else if (attr == &dev_attr_sess_fast_abort.attr)4598		param = ISCSI_PARAM_FAST_ABORT;4599	else if (attr == &dev_attr_sess_abort_tmo.attr)4600		param = ISCSI_PARAM_ABORT_TMO;4601	else if (attr == &dev_attr_sess_lu_reset_tmo.attr)4602		param = ISCSI_PARAM_LU_RESET_TMO;4603	else if (attr == &dev_attr_sess_tgt_reset_tmo.attr)4604		param = ISCSI_PARAM_TGT_RESET_TMO;4605	else if (attr == &dev_attr_sess_ifacename.attr)4606		param = ISCSI_PARAM_IFACE_NAME;4607	else if (attr == &dev_attr_sess_initiatorname.attr)4608		param = ISCSI_PARAM_INITIATOR_NAME;4609	else if (attr == &dev_attr_sess_targetalias.attr)4610		param = ISCSI_PARAM_TARGET_ALIAS;4611	else if (attr == &dev_attr_sess_boot_root.attr)4612		param = ISCSI_PARAM_BOOT_ROOT;4613	else if (attr == &dev_attr_sess_boot_nic.attr)4614		param = ISCSI_PARAM_BOOT_NIC;4615	else if (attr == &dev_attr_sess_boot_target.attr)4616		param = ISCSI_PARAM_BOOT_TARGET;4617	else if (attr == &dev_attr_sess_auto_snd_tgt_disable.attr)4618		param = ISCSI_PARAM_AUTO_SND_TGT_DISABLE;4619	else if (attr == &dev_attr_sess_discovery_session.attr)4620		param = ISCSI_PARAM_DISCOVERY_SESS;4621	else if (attr == &dev_attr_sess_portal_type.attr)4622		param = ISCSI_PARAM_PORTAL_TYPE;4623	else if (attr == &dev_attr_sess_chap_auth.attr)4624		param = ISCSI_PARAM_CHAP_AUTH_EN;4625	else if (attr == &dev_attr_sess_discovery_logout.attr)4626		param = ISCSI_PARAM_DISCOVERY_LOGOUT_EN;4627	else if (attr == &dev_attr_sess_bidi_chap.attr)4628		param = ISCSI_PARAM_BIDI_CHAP_EN;4629	else if (attr == &dev_attr_sess_discovery_auth_optional.attr)4630		param = ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL;4631	else if (attr == &dev_attr_sess_def_time2wait.attr)4632		param = ISCSI_PARAM_DEF_TIME2WAIT;4633	else if (attr == &dev_attr_sess_def_time2retain.attr)4634		param = ISCSI_PARAM_DEF_TIME2RETAIN;4635	else if (attr == &dev_attr_sess_isid.attr)4636		param = ISCSI_PARAM_ISID;4637	else if (attr == &dev_attr_sess_tsid.attr)4638		param = ISCSI_PARAM_TSID;4639	else if (attr == &dev_attr_sess_def_taskmgmt_tmo.attr)4640		param = ISCSI_PARAM_DEF_TASKMGMT_TMO;4641	else if (attr == &dev_attr_sess_discovery_parent_idx.attr)4642		param = ISCSI_PARAM_DISCOVERY_PARENT_IDX;4643	else if (attr == &dev_attr_sess_discovery_parent_type.attr)4644		param = ISCSI_PARAM_DISCOVERY_PARENT_TYPE;4645	else if (attr == &dev_attr_priv_sess_recovery_tmo.attr)4646		return S_IRUGO | S_IWUSR;4647	else if (attr == &dev_attr_priv_sess_state.attr)4648		return S_IRUGO;4649	else if (attr == &dev_attr_priv_sess_target_state.attr)4650		return S_IRUGO;4651	else if (attr == &dev_attr_priv_sess_creator.attr)4652		return S_IRUGO;4653	else if (attr == &dev_attr_priv_sess_target_id.attr)4654		return S_IRUGO;4655	else {4656		WARN_ONCE(1, "Invalid session attr");4657		return 0;4658	}4659 4660	return t->attr_is_visible(ISCSI_PARAM, param);4661}4662 4663static struct attribute_group iscsi_session_group = {4664	.attrs = iscsi_session_attrs,4665	.is_visible = iscsi_session_attr_is_visible,4666};4667 4668/*4669 * iSCSI host attrs4670 */4671#define iscsi_host_attr_show(param)					\4672static ssize_t								\4673show_host_param_##param(struct device *dev, 				\4674			struct device_attribute *attr, char *buf)	\4675{									\4676	struct Scsi_Host *shost = transport_class_to_shost(dev);	\4677	struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \4678	return priv->iscsi_transport->get_host_param(shost, param, buf); \4679}4680 4681#define iscsi_host_attr(field, param)					\4682	iscsi_host_attr_show(param)					\4683static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param,	\4684			NULL);4685 4686iscsi_host_attr(netdev, ISCSI_HOST_PARAM_NETDEV_NAME);4687iscsi_host_attr(hwaddress, ISCSI_HOST_PARAM_HWADDRESS);4688iscsi_host_attr(ipaddress, ISCSI_HOST_PARAM_IPADDRESS);4689iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME);4690iscsi_host_attr(port_state, ISCSI_HOST_PARAM_PORT_STATE);4691iscsi_host_attr(port_speed, ISCSI_HOST_PARAM_PORT_SPEED);4692 4693static struct attribute *iscsi_host_attrs[] = {4694	&dev_attr_host_netdev.attr,4695	&dev_attr_host_hwaddress.attr,4696	&dev_attr_host_ipaddress.attr,4697	&dev_attr_host_initiatorname.attr,4698	&dev_attr_host_port_state.attr,4699	&dev_attr_host_port_speed.attr,4700	NULL,4701};4702 4703static umode_t iscsi_host_attr_is_visible(struct kobject *kobj,4704					 struct attribute *attr, int i)4705{4706	struct device *cdev = container_of(kobj, struct device, kobj);4707	struct Scsi_Host *shost = transport_class_to_shost(cdev);4708	struct iscsi_internal *priv = to_iscsi_internal(shost->transportt);4709	int param;4710 4711	if (attr == &dev_attr_host_netdev.attr)4712		param = ISCSI_HOST_PARAM_NETDEV_NAME;4713	else if (attr == &dev_attr_host_hwaddress.attr)4714		param = ISCSI_HOST_PARAM_HWADDRESS;4715	else if (attr == &dev_attr_host_ipaddress.attr)4716		param = ISCSI_HOST_PARAM_IPADDRESS;4717	else if (attr == &dev_attr_host_initiatorname.attr)4718		param = ISCSI_HOST_PARAM_INITIATOR_NAME;4719	else if (attr == &dev_attr_host_port_state.attr)4720		param = ISCSI_HOST_PARAM_PORT_STATE;4721	else if (attr == &dev_attr_host_port_speed.attr)4722		param = ISCSI_HOST_PARAM_PORT_SPEED;4723	else {4724		WARN_ONCE(1, "Invalid host attr");4725		return 0;4726	}4727 4728	return priv->iscsi_transport->attr_is_visible(ISCSI_HOST_PARAM, param);4729}4730 4731static struct attribute_group iscsi_host_group = {4732	.attrs = iscsi_host_attrs,4733	.is_visible = iscsi_host_attr_is_visible,4734};4735 4736/* convert iscsi_port_speed values to ascii string name */4737static const struct {4738	enum iscsi_port_speed	value;4739	char			*name;4740} iscsi_port_speed_names[] = {4741	{ISCSI_PORT_SPEED_UNKNOWN,	"Unknown" },4742	{ISCSI_PORT_SPEED_10MBPS,	"10 Mbps" },4743	{ISCSI_PORT_SPEED_100MBPS,	"100 Mbps" },4744	{ISCSI_PORT_SPEED_1GBPS,	"1 Gbps" },4745	{ISCSI_PORT_SPEED_10GBPS,	"10 Gbps" },4746	{ISCSI_PORT_SPEED_25GBPS,       "25 Gbps" },4747	{ISCSI_PORT_SPEED_40GBPS,       "40 Gbps" },4748};4749 4750char *iscsi_get_port_speed_name(struct Scsi_Host *shost)4751{4752	int i;4753	char *speed = "Unknown!";4754	struct iscsi_cls_host *ihost = shost->shost_data;4755	uint32_t port_speed = ihost->port_speed;4756 4757	for (i = 0; i < ARRAY_SIZE(iscsi_port_speed_names); i++) {4758		if (iscsi_port_speed_names[i].value & port_speed) {4759			speed = iscsi_port_speed_names[i].name;4760			break;4761		}4762	}4763	return speed;4764}4765EXPORT_SYMBOL_GPL(iscsi_get_port_speed_name);4766 4767/* convert iscsi_port_state values to ascii string name */4768static const struct {4769	enum iscsi_port_state	value;4770	char			*name;4771} iscsi_port_state_names[] = {4772	{ISCSI_PORT_STATE_DOWN,		"LINK DOWN" },4773	{ISCSI_PORT_STATE_UP,		"LINK UP" },4774};4775 4776char *iscsi_get_port_state_name(struct Scsi_Host *shost)4777{4778	int i;4779	char *state = "Unknown!";4780	struct iscsi_cls_host *ihost = shost->shost_data;4781	uint32_t port_state = ihost->port_state;4782 4783	for (i = 0; i < ARRAY_SIZE(iscsi_port_state_names); i++) {4784		if (iscsi_port_state_names[i].value & port_state) {4785			state = iscsi_port_state_names[i].name;4786			break;4787		}4788	}4789	return state;4790}4791EXPORT_SYMBOL_GPL(iscsi_get_port_state_name);4792 4793static int iscsi_session_match(struct attribute_container *cont,4794			   struct device *dev)4795{4796	struct iscsi_cls_session *session;4797	struct Scsi_Host *shost;4798	struct iscsi_internal *priv;4799 4800	if (!iscsi_is_session_dev(dev))4801		return 0;4802 4803	session = iscsi_dev_to_session(dev);4804	shost = iscsi_session_to_shost(session);4805	if (!shost->transportt)4806		return 0;4807 4808	priv = to_iscsi_internal(shost->transportt);4809	if (priv->session_cont.ac.class != &iscsi_session_class.class)4810		return 0;4811 4812	return &priv->session_cont.ac == cont;4813}4814 4815static int iscsi_conn_match(struct attribute_container *cont,4816			   struct device *dev)4817{4818	struct iscsi_cls_session *session;4819	struct iscsi_cls_conn *conn;4820	struct Scsi_Host *shost;4821	struct iscsi_internal *priv;4822 4823	if (!iscsi_is_conn_dev(dev))4824		return 0;4825 4826	conn = iscsi_dev_to_conn(dev);4827	session = iscsi_dev_to_session(conn->dev.parent);4828	shost = iscsi_session_to_shost(session);4829 4830	if (!shost->transportt)4831		return 0;4832 4833	priv = to_iscsi_internal(shost->transportt);4834	if (priv->conn_cont.ac.class != &iscsi_connection_class.class)4835		return 0;4836 4837	return &priv->conn_cont.ac == cont;4838}4839 4840static int iscsi_host_match(struct attribute_container *cont,4841			    struct device *dev)4842{4843	struct Scsi_Host *shost;4844	struct iscsi_internal *priv;4845 4846	if (!scsi_is_host_device(dev))4847		return 0;4848 4849	shost = dev_to_shost(dev);4850	if (!shost->transportt  ||4851	    shost->transportt->host_attrs.ac.class != &iscsi_host_class.class)4852		return 0;4853 4854        priv = to_iscsi_internal(shost->transportt);4855        return &priv->t.host_attrs.ac == cont;4856}4857 4858struct scsi_transport_template *4859iscsi_register_transport(struct iscsi_transport *tt)4860{4861	struct iscsi_internal *priv;4862	unsigned long flags;4863	int err;4864 4865	BUG_ON(!tt);4866	WARN_ON(tt->ep_disconnect && !tt->unbind_conn);4867 4868	priv = iscsi_if_transport_lookup(tt);4869	if (priv)4870		return NULL;4871 4872	priv = kzalloc(sizeof(*priv), GFP_KERNEL);4873	if (!priv)4874		return NULL;4875	INIT_LIST_HEAD(&priv->list);4876	priv->iscsi_transport = tt;4877	priv->t.user_scan = iscsi_user_scan;4878 4879	priv->dev.class = &iscsi_transport_class;4880	dev_set_name(&priv->dev, "%s", tt->name);4881	err = device_register(&priv->dev);4882	if (err)4883		goto put_dev;4884 4885	err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group);4886	if (err)4887		goto unregister_dev;4888 4889	/* host parameters */4890	priv->t.host_attrs.ac.class = &iscsi_host_class.class;4891	priv->t.host_attrs.ac.match = iscsi_host_match;4892	priv->t.host_attrs.ac.grp = &iscsi_host_group;4893	priv->t.host_size = sizeof(struct iscsi_cls_host);4894	transport_container_register(&priv->t.host_attrs);4895 4896	/* connection parameters */4897	priv->conn_cont.ac.class = &iscsi_connection_class.class;4898	priv->conn_cont.ac.match = iscsi_conn_match;4899	priv->conn_cont.ac.grp = &iscsi_conn_group;4900	transport_container_register(&priv->conn_cont);4901 4902	/* session parameters */4903	priv->session_cont.ac.class = &iscsi_session_class.class;4904	priv->session_cont.ac.match = iscsi_session_match;4905	priv->session_cont.ac.grp = &iscsi_session_group;4906	transport_container_register(&priv->session_cont);4907 4908	spin_lock_irqsave(&iscsi_transport_lock, flags);4909	list_add(&priv->list, &iscsi_transports);4910	spin_unlock_irqrestore(&iscsi_transport_lock, flags);4911 4912	printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);4913	return &priv->t;4914 4915unregister_dev:4916	device_unregister(&priv->dev);4917	return NULL;4918put_dev:4919	put_device(&priv->dev);4920	return NULL;4921}4922EXPORT_SYMBOL_GPL(iscsi_register_transport);4923 4924void iscsi_unregister_transport(struct iscsi_transport *tt)4925{4926	struct iscsi_internal *priv;4927	unsigned long flags;4928 4929	BUG_ON(!tt);4930 4931	mutex_lock(&rx_queue_mutex);4932 4933	priv = iscsi_if_transport_lookup(tt);4934	BUG_ON (!priv);4935 4936	spin_lock_irqsave(&iscsi_transport_lock, flags);4937	list_del(&priv->list);4938	spin_unlock_irqrestore(&iscsi_transport_lock, flags);4939 4940	transport_container_unregister(&priv->conn_cont);4941	transport_container_unregister(&priv->session_cont);4942	transport_container_unregister(&priv->t.host_attrs);4943 4944	sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group);4945	device_unregister(&priv->dev);4946	mutex_unlock(&rx_queue_mutex);4947}4948EXPORT_SYMBOL_GPL(iscsi_unregister_transport);4949 4950void iscsi_dbg_trace(void (*trace)(struct device *dev, struct va_format *),4951		     struct device *dev, const char *fmt, ...)4952{4953	struct va_format vaf;4954	va_list args;4955 4956	va_start(args, fmt);4957	vaf.fmt = fmt;4958	vaf.va = &args;4959	trace(dev, &vaf);4960	va_end(args);4961}4962EXPORT_SYMBOL_GPL(iscsi_dbg_trace);4963 4964static __init int iscsi_transport_init(void)4965{4966	int err;4967	struct netlink_kernel_cfg cfg = {4968		.groups	= 1,4969		.input	= iscsi_if_rx,4970	};4971	printk(KERN_INFO "Loading iSCSI transport class v%s.\n",4972		ISCSI_TRANSPORT_VERSION);4973 4974	atomic_set(&iscsi_session_nr, 0);4975 4976	err = class_register(&iscsi_transport_class);4977	if (err)4978		return err;4979 4980	err = class_register(&iscsi_endpoint_class);4981	if (err)4982		goto unregister_transport_class;4983 4984	err = class_register(&iscsi_iface_class);4985	if (err)4986		goto unregister_endpoint_class;4987 4988	err = transport_class_register(&iscsi_host_class);4989	if (err)4990		goto unregister_iface_class;4991 4992	err = transport_class_register(&iscsi_connection_class);4993	if (err)4994		goto unregister_host_class;4995 4996	err = transport_class_register(&iscsi_session_class);4997	if (err)4998		goto unregister_conn_class;4999 5000	err = bus_register(&iscsi_flashnode_bus);5001	if (err)5002		goto unregister_session_class;5003 5004	nls = netlink_kernel_create(&init_net, NETLINK_ISCSI, &cfg);5005	if (!nls) {5006		err = -ENOBUFS;5007		goto unregister_flashnode_bus;5008	}5009 5010	iscsi_conn_cleanup_workq = alloc_workqueue("%s",5011			WQ_SYSFS | WQ_MEM_RECLAIM | WQ_UNBOUND, 0,5012			"iscsi_conn_cleanup");5013	if (!iscsi_conn_cleanup_workq) {5014		err = -ENOMEM;5015		goto release_nls;5016	}5017 5018	return 0;5019 5020release_nls:5021	netlink_kernel_release(nls);5022unregister_flashnode_bus:5023	bus_unregister(&iscsi_flashnode_bus);5024unregister_session_class:5025	transport_class_unregister(&iscsi_session_class);5026unregister_conn_class:5027	transport_class_unregister(&iscsi_connection_class);5028unregister_host_class:5029	transport_class_unregister(&iscsi_host_class);5030unregister_iface_class:5031	class_unregister(&iscsi_iface_class);5032unregister_endpoint_class:5033	class_unregister(&iscsi_endpoint_class);5034unregister_transport_class:5035	class_unregister(&iscsi_transport_class);5036	return err;5037}5038 5039static void __exit iscsi_transport_exit(void)5040{5041	destroy_workqueue(iscsi_conn_cleanup_workq);5042	netlink_kernel_release(nls);5043	bus_unregister(&iscsi_flashnode_bus);5044	transport_class_unregister(&iscsi_connection_class);5045	transport_class_unregister(&iscsi_session_class);5046	transport_class_unregister(&iscsi_host_class);5047	class_unregister(&iscsi_endpoint_class);5048	class_unregister(&iscsi_iface_class);5049	class_unregister(&iscsi_transport_class);5050}5051 5052module_init(iscsi_transport_init);5053module_exit(iscsi_transport_exit);5054 5055MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "5056	      "Dmitry Yusupov <dmitry_yus@yahoo.com>, "5057	      "Alex Aizman <itn780@yahoo.com>");5058MODULE_DESCRIPTION("iSCSI Transport Interface");5059MODULE_LICENSE("GPL");5060MODULE_VERSION(ISCSI_TRANSPORT_VERSION);5061MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_ISCSI);5062