2 * iSCSI transport class definitions
4 * Copyright (C) IBM Corporation, 2004
5 * Copyright (C) Mike Christie, 2004 - 2005
6 * Copyright (C) Dmitry Yusupov, 2004 - 2005
7 * Copyright (C) Alex Aizman, 2004 - 2005
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 #include <linux/module.h>
24 #include <linux/mutex.h>
25 #include <linux/slab.h>
26 #include <linux/bsg-lib.h>
27 #include <linux/idr.h>
29 #include <scsi/scsi.h>
30 #include <scsi/scsi_host.h>
31 #include <scsi/scsi_device.h>
32 #include <scsi/scsi_transport.h>
33 #include <scsi/scsi_transport_iscsi.h>
34 #include <scsi/iscsi_if.h>
35 #include <scsi/scsi_cmnd.h>
36 #include <scsi/scsi_bsg_iscsi.h>
38 #define ISCSI_TRANSPORT_VERSION "2.0-870"
40 static int dbg_session
;
41 module_param_named(debug_session
, dbg_session
, int,
43 MODULE_PARM_DESC(debug_session
,
44 "Turn on debugging for sessions in scsi_transport_iscsi "
45 "module. Set to 1 to turn on, and zero to turn off. Default "
49 module_param_named(debug_conn
, dbg_conn
, int,
51 MODULE_PARM_DESC(debug_conn
,
52 "Turn on debugging for connections in scsi_transport_iscsi "
53 "module. Set to 1 to turn on, and zero to turn off. Default "
56 #define ISCSI_DBG_TRANS_SESSION(_session, dbg_fmt, arg...) \
59 iscsi_cls_session_printk(KERN_INFO, _session, \
64 #define ISCSI_DBG_TRANS_CONN(_conn, dbg_fmt, arg...) \
67 iscsi_cls_conn_printk(KERN_INFO, _conn, \
72 struct iscsi_internal
{
73 struct scsi_transport_template t
;
74 struct iscsi_transport
*iscsi_transport
;
75 struct list_head list
;
78 struct transport_container conn_cont
;
79 struct transport_container session_cont
;
82 static atomic_t iscsi_session_nr
; /* sysfs session id for next new session */
83 static struct workqueue_struct
*iscsi_eh_timer_workq
;
85 static DEFINE_IDA(iscsi_sess_ida
);
87 * list of registered transports and lock that must
88 * be held while accessing list. The iscsi_transport_lock must
89 * be acquired after the rx_queue_mutex.
91 static LIST_HEAD(iscsi_transports
);
92 static DEFINE_SPINLOCK(iscsi_transport_lock
);
94 #define to_iscsi_internal(tmpl) \
95 container_of(tmpl, struct iscsi_internal, t)
97 #define dev_to_iscsi_internal(_dev) \
98 container_of(_dev, struct iscsi_internal, dev)
100 static void iscsi_transport_release(struct device
*dev
)
102 struct iscsi_internal
*priv
= dev_to_iscsi_internal(dev
);
107 * iscsi_transport_class represents the iscsi_transports that are
110 static struct class iscsi_transport_class
= {
111 .name
= "iscsi_transport",
112 .dev_release
= iscsi_transport_release
,
116 show_transport_handle(struct device
*dev
, struct device_attribute
*attr
,
119 struct iscsi_internal
*priv
= dev_to_iscsi_internal(dev
);
120 return sprintf(buf
, "%llu\n", (unsigned long long)iscsi_handle(priv
->iscsi_transport
));
122 static DEVICE_ATTR(handle
, S_IRUGO
, show_transport_handle
, NULL
);
124 #define show_transport_attr(name, format) \
126 show_transport_##name(struct device *dev, \
127 struct device_attribute *attr,char *buf) \
129 struct iscsi_internal *priv = dev_to_iscsi_internal(dev); \
130 return sprintf(buf, format"\n", priv->iscsi_transport->name); \
132 static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
134 show_transport_attr(caps
, "0x%x");
136 static struct attribute
*iscsi_transport_attrs
[] = {
137 &dev_attr_handle
.attr
,
142 static struct attribute_group iscsi_transport_group
= {
143 .attrs
= iscsi_transport_attrs
,
147 * iSCSI endpoint attrs
149 #define iscsi_dev_to_endpoint(_dev) \
150 container_of(_dev, struct iscsi_endpoint, dev)
152 #define ISCSI_ATTR(_prefix,_name,_mode,_show,_store) \
153 struct device_attribute dev_attr_##_prefix##_##_name = \
154 __ATTR(_name,_mode,_show,_store)
156 static void iscsi_endpoint_release(struct device
*dev
)
158 struct iscsi_endpoint
*ep
= iscsi_dev_to_endpoint(dev
);
162 static struct class iscsi_endpoint_class
= {
163 .name
= "iscsi_endpoint",
164 .dev_release
= iscsi_endpoint_release
,
168 show_ep_handle(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
170 struct iscsi_endpoint
*ep
= iscsi_dev_to_endpoint(dev
);
171 return sprintf(buf
, "%llu\n", (unsigned long long) ep
->id
);
173 static ISCSI_ATTR(ep
, handle
, S_IRUGO
, show_ep_handle
, NULL
);
175 static struct attribute
*iscsi_endpoint_attrs
[] = {
176 &dev_attr_ep_handle
.attr
,
180 static struct attribute_group iscsi_endpoint_group
= {
181 .attrs
= iscsi_endpoint_attrs
,
184 #define ISCSI_MAX_EPID -1
186 static int iscsi_match_epid(struct device
*dev
, const void *data
)
188 struct iscsi_endpoint
*ep
= iscsi_dev_to_endpoint(dev
);
189 const uint64_t *epid
= data
;
191 return *epid
== ep
->id
;
194 struct iscsi_endpoint
*
195 iscsi_create_endpoint(int dd_size
)
198 struct iscsi_endpoint
*ep
;
202 for (id
= 1; id
< ISCSI_MAX_EPID
; id
++) {
203 dev
= class_find_device(&iscsi_endpoint_class
, NULL
, &id
,
210 if (id
== ISCSI_MAX_EPID
) {
211 printk(KERN_ERR
"Too many connections. Max supported %u\n",
216 ep
= kzalloc(sizeof(*ep
) + dd_size
, GFP_KERNEL
);
221 ep
->dev
.class = &iscsi_endpoint_class
;
222 dev_set_name(&ep
->dev
, "ep-%llu", (unsigned long long) id
);
223 err
= device_register(&ep
->dev
);
227 err
= sysfs_create_group(&ep
->dev
.kobj
, &iscsi_endpoint_group
);
232 ep
->dd_data
= &ep
[1];
236 device_unregister(&ep
->dev
);
243 EXPORT_SYMBOL_GPL(iscsi_create_endpoint
);
245 void iscsi_destroy_endpoint(struct iscsi_endpoint
*ep
)
247 sysfs_remove_group(&ep
->dev
.kobj
, &iscsi_endpoint_group
);
248 device_unregister(&ep
->dev
);
250 EXPORT_SYMBOL_GPL(iscsi_destroy_endpoint
);
252 struct iscsi_endpoint
*iscsi_lookup_endpoint(u64 handle
)
254 struct iscsi_endpoint
*ep
;
257 dev
= class_find_device(&iscsi_endpoint_class
, NULL
, &handle
,
262 ep
= iscsi_dev_to_endpoint(dev
);
264 * we can drop this now because the interface will prevent
265 * removals and lookups from racing.
270 EXPORT_SYMBOL_GPL(iscsi_lookup_endpoint
);
273 * Interface to display network param to sysfs
276 static void iscsi_iface_release(struct device
*dev
)
278 struct iscsi_iface
*iface
= iscsi_dev_to_iface(dev
);
279 struct device
*parent
= iface
->dev
.parent
;
286 static struct class iscsi_iface_class
= {
287 .name
= "iscsi_iface",
288 .dev_release
= iscsi_iface_release
,
291 #define ISCSI_IFACE_ATTR(_prefix, _name, _mode, _show, _store) \
292 struct device_attribute dev_attr_##_prefix##_##_name = \
293 __ATTR(_name, _mode, _show, _store)
295 /* iface attrs show */
296 #define iscsi_iface_attr_show(type, name, param_type, param) \
298 show_##type##_##name(struct device *dev, struct device_attribute *attr, \
301 struct iscsi_iface *iface = iscsi_dev_to_iface(dev); \
302 struct iscsi_transport *t = iface->transport; \
303 return t->get_iface_param(iface, param_type, param, buf); \
306 #define iscsi_iface_net_attr(type, name, param) \
307 iscsi_iface_attr_show(type, name, ISCSI_NET_PARAM, param) \
308 static ISCSI_IFACE_ATTR(type, name, S_IRUGO, show_##type##_##name, NULL);
310 #define iscsi_iface_attr(type, name, param) \
311 iscsi_iface_attr_show(type, name, ISCSI_IFACE_PARAM, param) \
312 static ISCSI_IFACE_ATTR(type, name, S_IRUGO, show_##type##_##name, NULL);
314 /* generic read only ipv4 attribute */
315 iscsi_iface_net_attr(ipv4_iface
, ipaddress
, ISCSI_NET_PARAM_IPV4_ADDR
);
316 iscsi_iface_net_attr(ipv4_iface
, gateway
, ISCSI_NET_PARAM_IPV4_GW
);
317 iscsi_iface_net_attr(ipv4_iface
, subnet
, ISCSI_NET_PARAM_IPV4_SUBNET
);
318 iscsi_iface_net_attr(ipv4_iface
, bootproto
, ISCSI_NET_PARAM_IPV4_BOOTPROTO
);
319 iscsi_iface_net_attr(ipv4_iface
, dhcp_dns_address_en
,
320 ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN
);
321 iscsi_iface_net_attr(ipv4_iface
, dhcp_slp_da_info_en
,
322 ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN
);
323 iscsi_iface_net_attr(ipv4_iface
, tos_en
, ISCSI_NET_PARAM_IPV4_TOS_EN
);
324 iscsi_iface_net_attr(ipv4_iface
, tos
, ISCSI_NET_PARAM_IPV4_TOS
);
325 iscsi_iface_net_attr(ipv4_iface
, grat_arp_en
,
326 ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN
);
327 iscsi_iface_net_attr(ipv4_iface
, dhcp_alt_client_id_en
,
328 ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN
);
329 iscsi_iface_net_attr(ipv4_iface
, dhcp_alt_client_id
,
330 ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID
);
331 iscsi_iface_net_attr(ipv4_iface
, dhcp_req_vendor_id_en
,
332 ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN
);
333 iscsi_iface_net_attr(ipv4_iface
, dhcp_use_vendor_id_en
,
334 ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN
);
335 iscsi_iface_net_attr(ipv4_iface
, dhcp_vendor_id
,
336 ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID
);
337 iscsi_iface_net_attr(ipv4_iface
, dhcp_learn_iqn_en
,
338 ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN
);
339 iscsi_iface_net_attr(ipv4_iface
, fragment_disable
,
340 ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE
);
341 iscsi_iface_net_attr(ipv4_iface
, incoming_forwarding_en
,
342 ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN
);
343 iscsi_iface_net_attr(ipv4_iface
, ttl
, ISCSI_NET_PARAM_IPV4_TTL
);
345 /* generic read only ipv6 attribute */
346 iscsi_iface_net_attr(ipv6_iface
, ipaddress
, ISCSI_NET_PARAM_IPV6_ADDR
);
347 iscsi_iface_net_attr(ipv6_iface
, link_local_addr
,
348 ISCSI_NET_PARAM_IPV6_LINKLOCAL
);
349 iscsi_iface_net_attr(ipv6_iface
, router_addr
, ISCSI_NET_PARAM_IPV6_ROUTER
);
350 iscsi_iface_net_attr(ipv6_iface
, ipaddr_autocfg
,
351 ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG
);
352 iscsi_iface_net_attr(ipv6_iface
, link_local_autocfg
,
353 ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG
);
354 iscsi_iface_net_attr(ipv6_iface
, link_local_state
,
355 ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE
);
356 iscsi_iface_net_attr(ipv6_iface
, router_state
,
357 ISCSI_NET_PARAM_IPV6_ROUTER_STATE
);
358 iscsi_iface_net_attr(ipv6_iface
, grat_neighbor_adv_en
,
359 ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN
);
360 iscsi_iface_net_attr(ipv6_iface
, mld_en
, ISCSI_NET_PARAM_IPV6_MLD_EN
);
361 iscsi_iface_net_attr(ipv6_iface
, flow_label
, ISCSI_NET_PARAM_IPV6_FLOW_LABEL
);
362 iscsi_iface_net_attr(ipv6_iface
, traffic_class
,
363 ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS
);
364 iscsi_iface_net_attr(ipv6_iface
, hop_limit
, ISCSI_NET_PARAM_IPV6_HOP_LIMIT
);
365 iscsi_iface_net_attr(ipv6_iface
, nd_reachable_tmo
,
366 ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO
);
367 iscsi_iface_net_attr(ipv6_iface
, nd_rexmit_time
,
368 ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME
);
369 iscsi_iface_net_attr(ipv6_iface
, nd_stale_tmo
,
370 ISCSI_NET_PARAM_IPV6_ND_STALE_TMO
);
371 iscsi_iface_net_attr(ipv6_iface
, dup_addr_detect_cnt
,
372 ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT
);
373 iscsi_iface_net_attr(ipv6_iface
, router_adv_link_mtu
,
374 ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU
);
376 /* common read only iface attribute */
377 iscsi_iface_net_attr(iface
, enabled
, ISCSI_NET_PARAM_IFACE_ENABLE
);
378 iscsi_iface_net_attr(iface
, vlan_id
, ISCSI_NET_PARAM_VLAN_ID
);
379 iscsi_iface_net_attr(iface
, vlan_priority
, ISCSI_NET_PARAM_VLAN_PRIORITY
);
380 iscsi_iface_net_attr(iface
, vlan_enabled
, ISCSI_NET_PARAM_VLAN_ENABLED
);
381 iscsi_iface_net_attr(iface
, mtu
, ISCSI_NET_PARAM_MTU
);
382 iscsi_iface_net_attr(iface
, port
, ISCSI_NET_PARAM_PORT
);
383 iscsi_iface_net_attr(iface
, ipaddress_state
, ISCSI_NET_PARAM_IPADDR_STATE
);
384 iscsi_iface_net_attr(iface
, delayed_ack_en
, ISCSI_NET_PARAM_DELAYED_ACK_EN
);
385 iscsi_iface_net_attr(iface
, tcp_nagle_disable
,
386 ISCSI_NET_PARAM_TCP_NAGLE_DISABLE
);
387 iscsi_iface_net_attr(iface
, tcp_wsf_disable
, ISCSI_NET_PARAM_TCP_WSF_DISABLE
);
388 iscsi_iface_net_attr(iface
, tcp_wsf
, ISCSI_NET_PARAM_TCP_WSF
);
389 iscsi_iface_net_attr(iface
, tcp_timer_scale
, ISCSI_NET_PARAM_TCP_TIMER_SCALE
);
390 iscsi_iface_net_attr(iface
, tcp_timestamp_en
, ISCSI_NET_PARAM_TCP_TIMESTAMP_EN
);
391 iscsi_iface_net_attr(iface
, cache_id
, ISCSI_NET_PARAM_CACHE_ID
);
392 iscsi_iface_net_attr(iface
, redirect_en
, ISCSI_NET_PARAM_REDIRECT_EN
);
394 /* common iscsi specific settings attributes */
395 iscsi_iface_attr(iface
, def_taskmgmt_tmo
, ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO
);
396 iscsi_iface_attr(iface
, header_digest
, ISCSI_IFACE_PARAM_HDRDGST_EN
);
397 iscsi_iface_attr(iface
, data_digest
, ISCSI_IFACE_PARAM_DATADGST_EN
);
398 iscsi_iface_attr(iface
, immediate_data
, ISCSI_IFACE_PARAM_IMM_DATA_EN
);
399 iscsi_iface_attr(iface
, initial_r2t
, ISCSI_IFACE_PARAM_INITIAL_R2T_EN
);
400 iscsi_iface_attr(iface
, data_seq_in_order
,
401 ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN
);
402 iscsi_iface_attr(iface
, data_pdu_in_order
, ISCSI_IFACE_PARAM_PDU_INORDER_EN
);
403 iscsi_iface_attr(iface
, erl
, ISCSI_IFACE_PARAM_ERL
);
404 iscsi_iface_attr(iface
, max_recv_dlength
, ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH
);
405 iscsi_iface_attr(iface
, first_burst_len
, ISCSI_IFACE_PARAM_FIRST_BURST
);
406 iscsi_iface_attr(iface
, max_outstanding_r2t
, ISCSI_IFACE_PARAM_MAX_R2T
);
407 iscsi_iface_attr(iface
, max_burst_len
, ISCSI_IFACE_PARAM_MAX_BURST
);
408 iscsi_iface_attr(iface
, chap_auth
, ISCSI_IFACE_PARAM_CHAP_AUTH_EN
);
409 iscsi_iface_attr(iface
, bidi_chap
, ISCSI_IFACE_PARAM_BIDI_CHAP_EN
);
410 iscsi_iface_attr(iface
, discovery_auth_optional
,
411 ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL
);
412 iscsi_iface_attr(iface
, discovery_logout
,
413 ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN
);
414 iscsi_iface_attr(iface
, strict_login_comp_en
,
415 ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN
);
416 iscsi_iface_attr(iface
, initiator_name
, ISCSI_IFACE_PARAM_INITIATOR_NAME
);
418 static umode_t
iscsi_iface_attr_is_visible(struct kobject
*kobj
,
419 struct attribute
*attr
, int i
)
421 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
422 struct iscsi_iface
*iface
= iscsi_dev_to_iface(dev
);
423 struct iscsi_transport
*t
= iface
->transport
;
427 if (attr
== &dev_attr_iface_enabled
.attr
)
428 param
= ISCSI_NET_PARAM_IFACE_ENABLE
;
429 else if (attr
== &dev_attr_iface_vlan_id
.attr
)
430 param
= ISCSI_NET_PARAM_VLAN_ID
;
431 else if (attr
== &dev_attr_iface_vlan_priority
.attr
)
432 param
= ISCSI_NET_PARAM_VLAN_PRIORITY
;
433 else if (attr
== &dev_attr_iface_vlan_enabled
.attr
)
434 param
= ISCSI_NET_PARAM_VLAN_ENABLED
;
435 else if (attr
== &dev_attr_iface_mtu
.attr
)
436 param
= ISCSI_NET_PARAM_MTU
;
437 else if (attr
== &dev_attr_iface_port
.attr
)
438 param
= ISCSI_NET_PARAM_PORT
;
439 else if (attr
== &dev_attr_iface_ipaddress_state
.attr
)
440 param
= ISCSI_NET_PARAM_IPADDR_STATE
;
441 else if (attr
== &dev_attr_iface_delayed_ack_en
.attr
)
442 param
= ISCSI_NET_PARAM_DELAYED_ACK_EN
;
443 else if (attr
== &dev_attr_iface_tcp_nagle_disable
.attr
)
444 param
= ISCSI_NET_PARAM_TCP_NAGLE_DISABLE
;
445 else if (attr
== &dev_attr_iface_tcp_wsf_disable
.attr
)
446 param
= ISCSI_NET_PARAM_TCP_WSF_DISABLE
;
447 else if (attr
== &dev_attr_iface_tcp_wsf
.attr
)
448 param
= ISCSI_NET_PARAM_TCP_WSF
;
449 else if (attr
== &dev_attr_iface_tcp_timer_scale
.attr
)
450 param
= ISCSI_NET_PARAM_TCP_TIMER_SCALE
;
451 else if (attr
== &dev_attr_iface_tcp_timestamp_en
.attr
)
452 param
= ISCSI_NET_PARAM_TCP_TIMESTAMP_EN
;
453 else if (attr
== &dev_attr_iface_cache_id
.attr
)
454 param
= ISCSI_NET_PARAM_CACHE_ID
;
455 else if (attr
== &dev_attr_iface_redirect_en
.attr
)
456 param
= ISCSI_NET_PARAM_REDIRECT_EN
;
457 else if (attr
== &dev_attr_iface_def_taskmgmt_tmo
.attr
)
458 param
= ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO
;
459 else if (attr
== &dev_attr_iface_header_digest
.attr
)
460 param
= ISCSI_IFACE_PARAM_HDRDGST_EN
;
461 else if (attr
== &dev_attr_iface_data_digest
.attr
)
462 param
= ISCSI_IFACE_PARAM_DATADGST_EN
;
463 else if (attr
== &dev_attr_iface_immediate_data
.attr
)
464 param
= ISCSI_IFACE_PARAM_IMM_DATA_EN
;
465 else if (attr
== &dev_attr_iface_initial_r2t
.attr
)
466 param
= ISCSI_IFACE_PARAM_INITIAL_R2T_EN
;
467 else if (attr
== &dev_attr_iface_data_seq_in_order
.attr
)
468 param
= ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN
;
469 else if (attr
== &dev_attr_iface_data_pdu_in_order
.attr
)
470 param
= ISCSI_IFACE_PARAM_PDU_INORDER_EN
;
471 else if (attr
== &dev_attr_iface_erl
.attr
)
472 param
= ISCSI_IFACE_PARAM_ERL
;
473 else if (attr
== &dev_attr_iface_max_recv_dlength
.attr
)
474 param
= ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH
;
475 else if (attr
== &dev_attr_iface_first_burst_len
.attr
)
476 param
= ISCSI_IFACE_PARAM_FIRST_BURST
;
477 else if (attr
== &dev_attr_iface_max_outstanding_r2t
.attr
)
478 param
= ISCSI_IFACE_PARAM_MAX_R2T
;
479 else if (attr
== &dev_attr_iface_max_burst_len
.attr
)
480 param
= ISCSI_IFACE_PARAM_MAX_BURST
;
481 else if (attr
== &dev_attr_iface_chap_auth
.attr
)
482 param
= ISCSI_IFACE_PARAM_CHAP_AUTH_EN
;
483 else if (attr
== &dev_attr_iface_bidi_chap
.attr
)
484 param
= ISCSI_IFACE_PARAM_BIDI_CHAP_EN
;
485 else if (attr
== &dev_attr_iface_discovery_auth_optional
.attr
)
486 param
= ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL
;
487 else if (attr
== &dev_attr_iface_discovery_logout
.attr
)
488 param
= ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN
;
489 else if (attr
== &dev_attr_iface_strict_login_comp_en
.attr
)
490 param
= ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN
;
491 else if (attr
== &dev_attr_iface_initiator_name
.attr
)
492 param
= ISCSI_IFACE_PARAM_INITIATOR_NAME
;
493 else if (iface
->iface_type
== ISCSI_IFACE_TYPE_IPV4
) {
494 if (attr
== &dev_attr_ipv4_iface_ipaddress
.attr
)
495 param
= ISCSI_NET_PARAM_IPV4_ADDR
;
496 else if (attr
== &dev_attr_ipv4_iface_gateway
.attr
)
497 param
= ISCSI_NET_PARAM_IPV4_GW
;
498 else if (attr
== &dev_attr_ipv4_iface_subnet
.attr
)
499 param
= ISCSI_NET_PARAM_IPV4_SUBNET
;
500 else if (attr
== &dev_attr_ipv4_iface_bootproto
.attr
)
501 param
= ISCSI_NET_PARAM_IPV4_BOOTPROTO
;
503 &dev_attr_ipv4_iface_dhcp_dns_address_en
.attr
)
504 param
= ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN
;
506 &dev_attr_ipv4_iface_dhcp_slp_da_info_en
.attr
)
507 param
= ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN
;
508 else if (attr
== &dev_attr_ipv4_iface_tos_en
.attr
)
509 param
= ISCSI_NET_PARAM_IPV4_TOS_EN
;
510 else if (attr
== &dev_attr_ipv4_iface_tos
.attr
)
511 param
= ISCSI_NET_PARAM_IPV4_TOS
;
512 else if (attr
== &dev_attr_ipv4_iface_grat_arp_en
.attr
)
513 param
= ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN
;
515 &dev_attr_ipv4_iface_dhcp_alt_client_id_en
.attr
)
516 param
= ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN
;
517 else if (attr
== &dev_attr_ipv4_iface_dhcp_alt_client_id
.attr
)
518 param
= ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID
;
520 &dev_attr_ipv4_iface_dhcp_req_vendor_id_en
.attr
)
521 param
= ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN
;
523 &dev_attr_ipv4_iface_dhcp_use_vendor_id_en
.attr
)
524 param
= ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN
;
525 else if (attr
== &dev_attr_ipv4_iface_dhcp_vendor_id
.attr
)
526 param
= ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID
;
528 &dev_attr_ipv4_iface_dhcp_learn_iqn_en
.attr
)
529 param
= ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN
;
531 &dev_attr_ipv4_iface_fragment_disable
.attr
)
532 param
= ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE
;
534 &dev_attr_ipv4_iface_incoming_forwarding_en
.attr
)
535 param
= ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN
;
536 else if (attr
== &dev_attr_ipv4_iface_ttl
.attr
)
537 param
= ISCSI_NET_PARAM_IPV4_TTL
;
540 } else if (iface
->iface_type
== ISCSI_IFACE_TYPE_IPV6
) {
541 if (attr
== &dev_attr_ipv6_iface_ipaddress
.attr
)
542 param
= ISCSI_NET_PARAM_IPV6_ADDR
;
543 else if (attr
== &dev_attr_ipv6_iface_link_local_addr
.attr
)
544 param
= ISCSI_NET_PARAM_IPV6_LINKLOCAL
;
545 else if (attr
== &dev_attr_ipv6_iface_router_addr
.attr
)
546 param
= ISCSI_NET_PARAM_IPV6_ROUTER
;
547 else if (attr
== &dev_attr_ipv6_iface_ipaddr_autocfg
.attr
)
548 param
= ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG
;
549 else if (attr
== &dev_attr_ipv6_iface_link_local_autocfg
.attr
)
550 param
= ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG
;
551 else if (attr
== &dev_attr_ipv6_iface_link_local_state
.attr
)
552 param
= ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE
;
553 else if (attr
== &dev_attr_ipv6_iface_router_state
.attr
)
554 param
= ISCSI_NET_PARAM_IPV6_ROUTER_STATE
;
556 &dev_attr_ipv6_iface_grat_neighbor_adv_en
.attr
)
557 param
= ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN
;
558 else if (attr
== &dev_attr_ipv6_iface_mld_en
.attr
)
559 param
= ISCSI_NET_PARAM_IPV6_MLD_EN
;
560 else if (attr
== &dev_attr_ipv6_iface_flow_label
.attr
)
561 param
= ISCSI_NET_PARAM_IPV6_FLOW_LABEL
;
562 else if (attr
== &dev_attr_ipv6_iface_traffic_class
.attr
)
563 param
= ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS
;
564 else if (attr
== &dev_attr_ipv6_iface_hop_limit
.attr
)
565 param
= ISCSI_NET_PARAM_IPV6_HOP_LIMIT
;
566 else if (attr
== &dev_attr_ipv6_iface_nd_reachable_tmo
.attr
)
567 param
= ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO
;
568 else if (attr
== &dev_attr_ipv6_iface_nd_rexmit_time
.attr
)
569 param
= ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME
;
570 else if (attr
== &dev_attr_ipv6_iface_nd_stale_tmo
.attr
)
571 param
= ISCSI_NET_PARAM_IPV6_ND_STALE_TMO
;
572 else if (attr
== &dev_attr_ipv6_iface_dup_addr_detect_cnt
.attr
)
573 param
= ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT
;
574 else if (attr
== &dev_attr_ipv6_iface_router_adv_link_mtu
.attr
)
575 param
= ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU
;
579 WARN_ONCE(1, "Invalid iface attr");
584 case ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO
:
585 case ISCSI_IFACE_PARAM_HDRDGST_EN
:
586 case ISCSI_IFACE_PARAM_DATADGST_EN
:
587 case ISCSI_IFACE_PARAM_IMM_DATA_EN
:
588 case ISCSI_IFACE_PARAM_INITIAL_R2T_EN
:
589 case ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN
:
590 case ISCSI_IFACE_PARAM_PDU_INORDER_EN
:
591 case ISCSI_IFACE_PARAM_ERL
:
592 case ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH
:
593 case ISCSI_IFACE_PARAM_FIRST_BURST
:
594 case ISCSI_IFACE_PARAM_MAX_R2T
:
595 case ISCSI_IFACE_PARAM_MAX_BURST
:
596 case ISCSI_IFACE_PARAM_CHAP_AUTH_EN
:
597 case ISCSI_IFACE_PARAM_BIDI_CHAP_EN
:
598 case ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL
:
599 case ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN
:
600 case ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN
:
601 case ISCSI_IFACE_PARAM_INITIATOR_NAME
:
602 param_type
= ISCSI_IFACE_PARAM
;
605 param_type
= ISCSI_NET_PARAM
;
608 return t
->attr_is_visible(param_type
, param
);
611 static struct attribute
*iscsi_iface_attrs
[] = {
612 &dev_attr_iface_enabled
.attr
,
613 &dev_attr_iface_vlan_id
.attr
,
614 &dev_attr_iface_vlan_priority
.attr
,
615 &dev_attr_iface_vlan_enabled
.attr
,
616 &dev_attr_ipv4_iface_ipaddress
.attr
,
617 &dev_attr_ipv4_iface_gateway
.attr
,
618 &dev_attr_ipv4_iface_subnet
.attr
,
619 &dev_attr_ipv4_iface_bootproto
.attr
,
620 &dev_attr_ipv6_iface_ipaddress
.attr
,
621 &dev_attr_ipv6_iface_link_local_addr
.attr
,
622 &dev_attr_ipv6_iface_router_addr
.attr
,
623 &dev_attr_ipv6_iface_ipaddr_autocfg
.attr
,
624 &dev_attr_ipv6_iface_link_local_autocfg
.attr
,
625 &dev_attr_iface_mtu
.attr
,
626 &dev_attr_iface_port
.attr
,
627 &dev_attr_iface_ipaddress_state
.attr
,
628 &dev_attr_iface_delayed_ack_en
.attr
,
629 &dev_attr_iface_tcp_nagle_disable
.attr
,
630 &dev_attr_iface_tcp_wsf_disable
.attr
,
631 &dev_attr_iface_tcp_wsf
.attr
,
632 &dev_attr_iface_tcp_timer_scale
.attr
,
633 &dev_attr_iface_tcp_timestamp_en
.attr
,
634 &dev_attr_iface_cache_id
.attr
,
635 &dev_attr_iface_redirect_en
.attr
,
636 &dev_attr_iface_def_taskmgmt_tmo
.attr
,
637 &dev_attr_iface_header_digest
.attr
,
638 &dev_attr_iface_data_digest
.attr
,
639 &dev_attr_iface_immediate_data
.attr
,
640 &dev_attr_iface_initial_r2t
.attr
,
641 &dev_attr_iface_data_seq_in_order
.attr
,
642 &dev_attr_iface_data_pdu_in_order
.attr
,
643 &dev_attr_iface_erl
.attr
,
644 &dev_attr_iface_max_recv_dlength
.attr
,
645 &dev_attr_iface_first_burst_len
.attr
,
646 &dev_attr_iface_max_outstanding_r2t
.attr
,
647 &dev_attr_iface_max_burst_len
.attr
,
648 &dev_attr_iface_chap_auth
.attr
,
649 &dev_attr_iface_bidi_chap
.attr
,
650 &dev_attr_iface_discovery_auth_optional
.attr
,
651 &dev_attr_iface_discovery_logout
.attr
,
652 &dev_attr_iface_strict_login_comp_en
.attr
,
653 &dev_attr_iface_initiator_name
.attr
,
654 &dev_attr_ipv4_iface_dhcp_dns_address_en
.attr
,
655 &dev_attr_ipv4_iface_dhcp_slp_da_info_en
.attr
,
656 &dev_attr_ipv4_iface_tos_en
.attr
,
657 &dev_attr_ipv4_iface_tos
.attr
,
658 &dev_attr_ipv4_iface_grat_arp_en
.attr
,
659 &dev_attr_ipv4_iface_dhcp_alt_client_id_en
.attr
,
660 &dev_attr_ipv4_iface_dhcp_alt_client_id
.attr
,
661 &dev_attr_ipv4_iface_dhcp_req_vendor_id_en
.attr
,
662 &dev_attr_ipv4_iface_dhcp_use_vendor_id_en
.attr
,
663 &dev_attr_ipv4_iface_dhcp_vendor_id
.attr
,
664 &dev_attr_ipv4_iface_dhcp_learn_iqn_en
.attr
,
665 &dev_attr_ipv4_iface_fragment_disable
.attr
,
666 &dev_attr_ipv4_iface_incoming_forwarding_en
.attr
,
667 &dev_attr_ipv4_iface_ttl
.attr
,
668 &dev_attr_ipv6_iface_link_local_state
.attr
,
669 &dev_attr_ipv6_iface_router_state
.attr
,
670 &dev_attr_ipv6_iface_grat_neighbor_adv_en
.attr
,
671 &dev_attr_ipv6_iface_mld_en
.attr
,
672 &dev_attr_ipv6_iface_flow_label
.attr
,
673 &dev_attr_ipv6_iface_traffic_class
.attr
,
674 &dev_attr_ipv6_iface_hop_limit
.attr
,
675 &dev_attr_ipv6_iface_nd_reachable_tmo
.attr
,
676 &dev_attr_ipv6_iface_nd_rexmit_time
.attr
,
677 &dev_attr_ipv6_iface_nd_stale_tmo
.attr
,
678 &dev_attr_ipv6_iface_dup_addr_detect_cnt
.attr
,
679 &dev_attr_ipv6_iface_router_adv_link_mtu
.attr
,
683 static struct attribute_group iscsi_iface_group
= {
684 .attrs
= iscsi_iface_attrs
,
685 .is_visible
= iscsi_iface_attr_is_visible
,
688 /* convert iscsi_ipaddress_state values to ascii string name */
689 static const struct {
690 enum iscsi_ipaddress_state value
;
692 } iscsi_ipaddress_state_names
[] = {
693 {ISCSI_IPDDRESS_STATE_UNCONFIGURED
, "Unconfigured" },
694 {ISCSI_IPDDRESS_STATE_ACQUIRING
, "Acquiring" },
695 {ISCSI_IPDDRESS_STATE_TENTATIVE
, "Tentative" },
696 {ISCSI_IPDDRESS_STATE_VALID
, "Valid" },
697 {ISCSI_IPDDRESS_STATE_DISABLING
, "Disabling" },
698 {ISCSI_IPDDRESS_STATE_INVALID
, "Invalid" },
699 {ISCSI_IPDDRESS_STATE_DEPRECATED
, "Deprecated" },
702 char *iscsi_get_ipaddress_state_name(enum iscsi_ipaddress_state port_state
)
707 for (i
= 0; i
< ARRAY_SIZE(iscsi_ipaddress_state_names
); i
++) {
708 if (iscsi_ipaddress_state_names
[i
].value
== port_state
) {
709 state
= iscsi_ipaddress_state_names
[i
].name
;
715 EXPORT_SYMBOL_GPL(iscsi_get_ipaddress_state_name
);
717 /* convert iscsi_router_state values to ascii string name */
718 static const struct {
719 enum iscsi_router_state value
;
721 } iscsi_router_state_names
[] = {
722 {ISCSI_ROUTER_STATE_UNKNOWN
, "Unknown" },
723 {ISCSI_ROUTER_STATE_ADVERTISED
, "Advertised" },
724 {ISCSI_ROUTER_STATE_MANUAL
, "Manual" },
725 {ISCSI_ROUTER_STATE_STALE
, "Stale" },
728 char *iscsi_get_router_state_name(enum iscsi_router_state router_state
)
733 for (i
= 0; i
< ARRAY_SIZE(iscsi_router_state_names
); i
++) {
734 if (iscsi_router_state_names
[i
].value
== router_state
) {
735 state
= iscsi_router_state_names
[i
].name
;
741 EXPORT_SYMBOL_GPL(iscsi_get_router_state_name
);
744 iscsi_create_iface(struct Scsi_Host
*shost
, struct iscsi_transport
*transport
,
745 uint32_t iface_type
, uint32_t iface_num
, int dd_size
)
747 struct iscsi_iface
*iface
;
750 iface
= kzalloc(sizeof(*iface
) + dd_size
, GFP_KERNEL
);
754 iface
->transport
= transport
;
755 iface
->iface_type
= iface_type
;
756 iface
->iface_num
= iface_num
;
757 iface
->dev
.release
= iscsi_iface_release
;
758 iface
->dev
.class = &iscsi_iface_class
;
759 /* parent reference released in iscsi_iface_release */
760 iface
->dev
.parent
= get_device(&shost
->shost_gendev
);
761 if (iface_type
== ISCSI_IFACE_TYPE_IPV4
)
762 dev_set_name(&iface
->dev
, "ipv4-iface-%u-%u", shost
->host_no
,
765 dev_set_name(&iface
->dev
, "ipv6-iface-%u-%u", shost
->host_no
,
768 err
= device_register(&iface
->dev
);
772 err
= sysfs_create_group(&iface
->dev
.kobj
, &iscsi_iface_group
);
777 iface
->dd_data
= &iface
[1];
781 device_unregister(&iface
->dev
);
785 put_device(iface
->dev
.parent
);
789 EXPORT_SYMBOL_GPL(iscsi_create_iface
);
791 void iscsi_destroy_iface(struct iscsi_iface
*iface
)
793 sysfs_remove_group(&iface
->dev
.kobj
, &iscsi_iface_group
);
794 device_unregister(&iface
->dev
);
796 EXPORT_SYMBOL_GPL(iscsi_destroy_iface
);
799 * Interface to display flash node params to sysfs
802 #define ISCSI_FLASHNODE_ATTR(_prefix, _name, _mode, _show, _store) \
803 struct device_attribute dev_attr_##_prefix##_##_name = \
804 __ATTR(_name, _mode, _show, _store)
806 /* flash node session attrs show */
807 #define iscsi_flashnode_sess_attr_show(type, name, param) \
809 show_##type##_##name(struct device *dev, struct device_attribute *attr, \
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); \
819 #define iscsi_flashnode_sess_attr(type, name, param) \
820 iscsi_flashnode_sess_attr_show(type, name, param) \
821 static ISCSI_FLASHNODE_ATTR(type, name, S_IRUGO, \
822 show_##type##_##name, NULL);
824 /* Flash node session attributes */
826 iscsi_flashnode_sess_attr(fnode
, auto_snd_tgt_disable
,
827 ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE
);
828 iscsi_flashnode_sess_attr(fnode
, discovery_session
,
829 ISCSI_FLASHNODE_DISCOVERY_SESS
);
830 iscsi_flashnode_sess_attr(fnode
, portal_type
, ISCSI_FLASHNODE_PORTAL_TYPE
);
831 iscsi_flashnode_sess_attr(fnode
, entry_enable
, ISCSI_FLASHNODE_ENTRY_EN
);
832 iscsi_flashnode_sess_attr(fnode
, immediate_data
, ISCSI_FLASHNODE_IMM_DATA_EN
);
833 iscsi_flashnode_sess_attr(fnode
, initial_r2t
, ISCSI_FLASHNODE_INITIAL_R2T_EN
);
834 iscsi_flashnode_sess_attr(fnode
, data_seq_in_order
,
835 ISCSI_FLASHNODE_DATASEQ_INORDER
);
836 iscsi_flashnode_sess_attr(fnode
, data_pdu_in_order
,
837 ISCSI_FLASHNODE_PDU_INORDER
);
838 iscsi_flashnode_sess_attr(fnode
, chap_auth
, ISCSI_FLASHNODE_CHAP_AUTH_EN
);
839 iscsi_flashnode_sess_attr(fnode
, discovery_logout
,
840 ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN
);
841 iscsi_flashnode_sess_attr(fnode
, bidi_chap
, ISCSI_FLASHNODE_BIDI_CHAP_EN
);
842 iscsi_flashnode_sess_attr(fnode
, discovery_auth_optional
,
843 ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL
);
844 iscsi_flashnode_sess_attr(fnode
, erl
, ISCSI_FLASHNODE_ERL
);
845 iscsi_flashnode_sess_attr(fnode
, first_burst_len
, ISCSI_FLASHNODE_FIRST_BURST
);
846 iscsi_flashnode_sess_attr(fnode
, def_time2wait
, ISCSI_FLASHNODE_DEF_TIME2WAIT
);
847 iscsi_flashnode_sess_attr(fnode
, def_time2retain
,
848 ISCSI_FLASHNODE_DEF_TIME2RETAIN
);
849 iscsi_flashnode_sess_attr(fnode
, max_outstanding_r2t
, ISCSI_FLASHNODE_MAX_R2T
);
850 iscsi_flashnode_sess_attr(fnode
, isid
, ISCSI_FLASHNODE_ISID
);
851 iscsi_flashnode_sess_attr(fnode
, tsid
, ISCSI_FLASHNODE_TSID
);
852 iscsi_flashnode_sess_attr(fnode
, max_burst_len
, ISCSI_FLASHNODE_MAX_BURST
);
853 iscsi_flashnode_sess_attr(fnode
, def_taskmgmt_tmo
,
854 ISCSI_FLASHNODE_DEF_TASKMGMT_TMO
);
855 iscsi_flashnode_sess_attr(fnode
, targetalias
, ISCSI_FLASHNODE_ALIAS
);
856 iscsi_flashnode_sess_attr(fnode
, targetname
, ISCSI_FLASHNODE_NAME
);
857 iscsi_flashnode_sess_attr(fnode
, tpgt
, ISCSI_FLASHNODE_TPGT
);
858 iscsi_flashnode_sess_attr(fnode
, discovery_parent_idx
,
859 ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX
);
860 iscsi_flashnode_sess_attr(fnode
, discovery_parent_type
,
861 ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE
);
862 iscsi_flashnode_sess_attr(fnode
, chap_in_idx
, ISCSI_FLASHNODE_CHAP_IN_IDX
);
863 iscsi_flashnode_sess_attr(fnode
, chap_out_idx
, ISCSI_FLASHNODE_CHAP_OUT_IDX
);
864 iscsi_flashnode_sess_attr(fnode
, username
, ISCSI_FLASHNODE_USERNAME
);
865 iscsi_flashnode_sess_attr(fnode
, username_in
, ISCSI_FLASHNODE_USERNAME_IN
);
866 iscsi_flashnode_sess_attr(fnode
, password
, ISCSI_FLASHNODE_PASSWORD
);
867 iscsi_flashnode_sess_attr(fnode
, password_in
, ISCSI_FLASHNODE_PASSWORD_IN
);
868 iscsi_flashnode_sess_attr(fnode
, is_boot_target
, ISCSI_FLASHNODE_IS_BOOT_TGT
);
870 static 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
,
907 static umode_t
iscsi_flashnode_sess_attr_is_visible(struct kobject
*kobj
,
908 struct attribute
*attr
,
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
;
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
;
984 WARN_ONCE(1, "Invalid flashnode session attr");
988 return t
->attr_is_visible(ISCSI_FLASHNODE_PARAM
, param
);
991 static struct attribute_group iscsi_flashnode_sess_attr_group
= {
992 .attrs
= iscsi_flashnode_sess_attrs
,
993 .is_visible
= iscsi_flashnode_sess_attr_is_visible
,
996 static const struct attribute_group
*iscsi_flashnode_sess_attr_groups
[] = {
997 &iscsi_flashnode_sess_attr_group
,
1001 static void iscsi_flashnode_sess_release(struct device
*dev
)
1003 struct iscsi_bus_flash_session
*fnode_sess
=
1004 iscsi_dev_to_flash_session(dev
);
1006 kfree(fnode_sess
->targetname
);
1007 kfree(fnode_sess
->targetalias
);
1008 kfree(fnode_sess
->portal_type
);
1012 static 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
,
1018 /* flash node connection attrs show */
1019 #define iscsi_flashnode_conn_attr_show(type, name, param) \
1021 show_##type##_##name(struct device *dev, struct device_attribute *attr, \
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); \
1032 #define iscsi_flashnode_conn_attr(type, name, param) \
1033 iscsi_flashnode_conn_attr_show(type, name, param) \
1034 static ISCSI_FLASHNODE_ATTR(type, name, S_IRUGO, \
1035 show_##type##_##name, NULL);
1037 /* Flash node connection attributes */
1039 iscsi_flashnode_conn_attr(fnode
, is_fw_assigned_ipv6
,
1040 ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6
);
1041 iscsi_flashnode_conn_attr(fnode
, header_digest
, ISCSI_FLASHNODE_HDR_DGST_EN
);
1042 iscsi_flashnode_conn_attr(fnode
, data_digest
, ISCSI_FLASHNODE_DATA_DGST_EN
);
1043 iscsi_flashnode_conn_attr(fnode
, snack_req
, ISCSI_FLASHNODE_SNACK_REQ_EN
);
1044 iscsi_flashnode_conn_attr(fnode
, tcp_timestamp_stat
,
1045 ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT
);
1046 iscsi_flashnode_conn_attr(fnode
, tcp_nagle_disable
,
1047 ISCSI_FLASHNODE_TCP_NAGLE_DISABLE
);
1048 iscsi_flashnode_conn_attr(fnode
, tcp_wsf_disable
,
1049 ISCSI_FLASHNODE_TCP_WSF_DISABLE
);
1050 iscsi_flashnode_conn_attr(fnode
, tcp_timer_scale
,
1051 ISCSI_FLASHNODE_TCP_TIMER_SCALE
);
1052 iscsi_flashnode_conn_attr(fnode
, tcp_timestamp_enable
,
1053 ISCSI_FLASHNODE_TCP_TIMESTAMP_EN
);
1054 iscsi_flashnode_conn_attr(fnode
, fragment_disable
,
1055 ISCSI_FLASHNODE_IP_FRAG_DISABLE
);
1056 iscsi_flashnode_conn_attr(fnode
, keepalive_tmo
, ISCSI_FLASHNODE_KEEPALIVE_TMO
);
1057 iscsi_flashnode_conn_attr(fnode
, port
, ISCSI_FLASHNODE_PORT
);
1058 iscsi_flashnode_conn_attr(fnode
, ipaddress
, ISCSI_FLASHNODE_IPADDR
);
1059 iscsi_flashnode_conn_attr(fnode
, max_recv_dlength
,
1060 ISCSI_FLASHNODE_MAX_RECV_DLENGTH
);
1061 iscsi_flashnode_conn_attr(fnode
, max_xmit_dlength
,
1062 ISCSI_FLASHNODE_MAX_XMIT_DLENGTH
);
1063 iscsi_flashnode_conn_attr(fnode
, local_port
, ISCSI_FLASHNODE_LOCAL_PORT
);
1064 iscsi_flashnode_conn_attr(fnode
, ipv4_tos
, ISCSI_FLASHNODE_IPV4_TOS
);
1065 iscsi_flashnode_conn_attr(fnode
, ipv6_traffic_class
, ISCSI_FLASHNODE_IPV6_TC
);
1066 iscsi_flashnode_conn_attr(fnode
, ipv6_flow_label
,
1067 ISCSI_FLASHNODE_IPV6_FLOW_LABEL
);
1068 iscsi_flashnode_conn_attr(fnode
, redirect_ipaddr
,
1069 ISCSI_FLASHNODE_REDIRECT_IPADDR
);
1070 iscsi_flashnode_conn_attr(fnode
, max_segment_size
,
1071 ISCSI_FLASHNODE_MAX_SEGMENT_SIZE
);
1072 iscsi_flashnode_conn_attr(fnode
, link_local_ipv6
,
1073 ISCSI_FLASHNODE_LINK_LOCAL_IPV6
);
1074 iscsi_flashnode_conn_attr(fnode
, tcp_xmit_wsf
, ISCSI_FLASHNODE_TCP_XMIT_WSF
);
1075 iscsi_flashnode_conn_attr(fnode
, tcp_recv_wsf
, ISCSI_FLASHNODE_TCP_RECV_WSF
);
1076 iscsi_flashnode_conn_attr(fnode
, statsn
, ISCSI_FLASHNODE_STATSN
);
1077 iscsi_flashnode_conn_attr(fnode
, exp_statsn
, ISCSI_FLASHNODE_EXP_STATSN
);
1079 static 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
,
1109 static umode_t
iscsi_flashnode_conn_attr_is_visible(struct kobject
*kobj
,
1110 struct attribute
*attr
,
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
;
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
;
1171 WARN_ONCE(1, "Invalid flashnode connection attr");
1175 return t
->attr_is_visible(ISCSI_FLASHNODE_PARAM
, param
);
1178 static struct attribute_group iscsi_flashnode_conn_attr_group
= {
1179 .attrs
= iscsi_flashnode_conn_attrs
,
1180 .is_visible
= iscsi_flashnode_conn_attr_is_visible
,
1183 static const struct attribute_group
*iscsi_flashnode_conn_attr_groups
[] = {
1184 &iscsi_flashnode_conn_attr_group
,
1188 static void iscsi_flashnode_conn_release(struct device
*dev
)
1190 struct iscsi_bus_flash_conn
*fnode_conn
= iscsi_dev_to_flash_conn(dev
);
1192 kfree(fnode_conn
->ipaddress
);
1193 kfree(fnode_conn
->redirect_ipaddr
);
1194 kfree(fnode_conn
->link_local_ipv6_addr
);
1198 static 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
,
1204 static struct bus_type iscsi_flashnode_bus
;
1206 int iscsi_flashnode_bus_match(struct device
*dev
,
1207 struct device_driver
*drv
)
1209 if (dev
->bus
== &iscsi_flashnode_bus
)
1213 EXPORT_SYMBOL_GPL(iscsi_flashnode_bus_match
);
1215 static struct bus_type iscsi_flashnode_bus
= {
1216 .name
= "iscsi_flashnode",
1217 .match
= &iscsi_flashnode_bus_match
,
1221 * iscsi_create_flashnode_sess - Add flashnode session entry in sysfs
1222 * @shost: pointer to host data
1223 * @index: index of flashnode to add in sysfs
1224 * @transport: pointer to transport data
1225 * @dd_size: total size to allocate
1227 * Adds a sysfs entry for the flashnode session attributes
1230 * pointer to allocated flashnode sess on success
1233 struct iscsi_bus_flash_session
*
1234 iscsi_create_flashnode_sess(struct Scsi_Host
*shost
, int index
,
1235 struct iscsi_transport
*transport
,
1238 struct iscsi_bus_flash_session
*fnode_sess
;
1241 fnode_sess
= kzalloc(sizeof(*fnode_sess
) + dd_size
, GFP_KERNEL
);
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
);
1253 err
= device_register(&fnode_sess
->dev
);
1255 goto free_fnode_sess
;
1258 fnode_sess
->dd_data
= &fnode_sess
[1];
1266 EXPORT_SYMBOL_GPL(iscsi_create_flashnode_sess
);
1269 * iscsi_create_flashnode_conn - Add flashnode conn entry in sysfs
1270 * @shost: pointer to host data
1271 * @fnode_sess: pointer to the parent flashnode session entry
1272 * @transport: pointer to transport data
1273 * @dd_size: total size to allocate
1275 * Adds a sysfs entry for the flashnode connection attributes
1278 * pointer to allocated flashnode conn on success
1281 struct iscsi_bus_flash_conn
*
1282 iscsi_create_flashnode_conn(struct Scsi_Host
*shost
,
1283 struct iscsi_bus_flash_session
*fnode_sess
,
1284 struct iscsi_transport
*transport
,
1287 struct iscsi_bus_flash_conn
*fnode_conn
;
1290 fnode_conn
= kzalloc(sizeof(*fnode_conn
) + dd_size
, GFP_KERNEL
);
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
);
1301 err
= device_register(&fnode_conn
->dev
);
1303 goto free_fnode_conn
;
1306 fnode_conn
->dd_data
= &fnode_conn
[1];
1314 EXPORT_SYMBOL_GPL(iscsi_create_flashnode_conn
);
1317 * iscsi_is_flashnode_conn_dev - verify passed device is to be flashnode conn
1318 * @dev: device to verify
1319 * @data: pointer to data containing value to use for verification
1321 * Verifies if the passed device is flashnode conn device
1327 static int iscsi_is_flashnode_conn_dev(struct device
*dev
, void *data
)
1329 return dev
->bus
== &iscsi_flashnode_bus
;
1332 static int iscsi_destroy_flashnode_conn(struct iscsi_bus_flash_conn
*fnode_conn
)
1334 device_unregister(&fnode_conn
->dev
);
1338 static int flashnode_match_index(struct device
*dev
, void *data
)
1340 struct iscsi_bus_flash_session
*fnode_sess
= NULL
;
1343 if (!iscsi_flashnode_bus_match(dev
, NULL
))
1344 goto exit_match_index
;
1346 fnode_sess
= iscsi_dev_to_flash_session(dev
);
1347 ret
= (fnode_sess
->target_id
== *((int *)data
)) ? 1 : 0;
1354 * iscsi_get_flashnode_by_index -finds flashnode session entry by index
1355 * @shost: pointer to host data
1356 * @idx: index to match
1358 * Finds the flashnode session object for the passed index
1361 * pointer to found flashnode session object on success
1364 static struct iscsi_bus_flash_session
*
1365 iscsi_get_flashnode_by_index(struct Scsi_Host
*shost
, uint32_t idx
)
1367 struct iscsi_bus_flash_session
*fnode_sess
= NULL
;
1370 dev
= device_find_child(&shost
->shost_gendev
, &idx
,
1371 flashnode_match_index
);
1373 fnode_sess
= iscsi_dev_to_flash_session(dev
);
1379 * iscsi_find_flashnode_sess - finds flashnode session entry
1380 * @shost: pointer to host data
1381 * @data: pointer to data containing value to use for comparison
1382 * @fn: function pointer that does actual comparison
1384 * Finds the flashnode session object comparing the data passed using logic
1385 * defined in passed function pointer
1388 * pointer to found flashnode session device object on success
1392 iscsi_find_flashnode_sess(struct Scsi_Host
*shost
, void *data
,
1393 int (*fn
)(struct device
*dev
, void *data
))
1395 return device_find_child(&shost
->shost_gendev
, data
, fn
);
1397 EXPORT_SYMBOL_GPL(iscsi_find_flashnode_sess
);
1400 * iscsi_find_flashnode_conn - finds flashnode connection entry
1401 * @fnode_sess: pointer to parent flashnode session entry
1403 * Finds the flashnode connection object comparing the data passed using logic
1404 * defined in passed function pointer
1407 * pointer to found flashnode connection device object on success
1411 iscsi_find_flashnode_conn(struct iscsi_bus_flash_session
*fnode_sess
)
1413 return device_find_child(&fnode_sess
->dev
, NULL
,
1414 iscsi_is_flashnode_conn_dev
);
1416 EXPORT_SYMBOL_GPL(iscsi_find_flashnode_conn
);
1418 static int iscsi_iter_destroy_flashnode_conn_fn(struct device
*dev
, void *data
)
1420 if (!iscsi_is_flashnode_conn_dev(dev
, NULL
))
1423 return iscsi_destroy_flashnode_conn(iscsi_dev_to_flash_conn(dev
));
1427 * iscsi_destroy_flashnode_sess - destroy flashnode session entry
1428 * @fnode_sess: pointer to flashnode session entry to be destroyed
1430 * Deletes the flashnode session entry and all children flashnode connection
1431 * entries from sysfs
1433 void iscsi_destroy_flashnode_sess(struct iscsi_bus_flash_session
*fnode_sess
)
1437 err
= device_for_each_child(&fnode_sess
->dev
, NULL
,
1438 iscsi_iter_destroy_flashnode_conn_fn
);
1440 pr_err("Could not delete all connections for %s. Error %d.\n",
1441 fnode_sess
->dev
.kobj
.name
, err
);
1443 device_unregister(&fnode_sess
->dev
);
1445 EXPORT_SYMBOL_GPL(iscsi_destroy_flashnode_sess
);
1447 static int iscsi_iter_destroy_flashnode_fn(struct device
*dev
, void *data
)
1449 if (!iscsi_flashnode_bus_match(dev
, NULL
))
1452 iscsi_destroy_flashnode_sess(iscsi_dev_to_flash_session(dev
));
1457 * iscsi_destroy_all_flashnode - destroy all flashnode session entries
1458 * @shost: pointer to host data
1460 * Destroys all the flashnode session entries and all corresponding children
1461 * flashnode connection entries from sysfs
1463 void iscsi_destroy_all_flashnode(struct Scsi_Host
*shost
)
1465 device_for_each_child(&shost
->shost_gendev
, NULL
,
1466 iscsi_iter_destroy_flashnode_fn
);
1468 EXPORT_SYMBOL_GPL(iscsi_destroy_all_flashnode
);
1474 * iscsi_bsg_host_dispatch - Dispatch command to LLD.
1475 * @job: bsg job to be processed
1477 static int iscsi_bsg_host_dispatch(struct bsg_job
*job
)
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 */
1486 /* check if we have the msgcode value at least */
1487 if (job
->request_len
< sizeof(uint32_t)) {
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
)) {
1508 /* check if we really have all the request data needed */
1509 if (job
->request_len
< cmdlen
) {
1514 ret
= i
->iscsi_transport
->bsg_request(job
);
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);
1529 * iscsi_bsg_host_add - Create and add the bsg hooks to receive requests
1530 * @shost: shost for iscsi_host
1531 * @ihost: iscsi_cls_host adding the structures to
1534 iscsi_bsg_host_add(struct Scsi_Host
*shost
, struct iscsi_cls_host
*ihost
)
1536 struct device
*dev
= &shost
->shost_gendev
;
1537 struct iscsi_internal
*i
= to_iscsi_internal(shost
->transportt
);
1538 struct request_queue
*q
;
1541 if (!i
->iscsi_transport
->bsg_request
)
1544 snprintf(bsg_name
, sizeof(bsg_name
), "iscsi_host%d", shost
->host_no
);
1545 q
= bsg_setup_queue(dev
, bsg_name
, iscsi_bsg_host_dispatch
, 0, NULL
);
1547 shost_printk(KERN_ERR
, shost
, "bsg interface failed to "
1548 "initialize - no request queue\n");
1551 __scsi_init_queue(shost
, q
);
1557 static int iscsi_setup_host(struct transport_container
*tc
, struct device
*dev
,
1558 struct device
*cdev
)
1560 struct Scsi_Host
*shost
= dev_to_shost(dev
);
1561 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
1563 memset(ihost
, 0, sizeof(*ihost
));
1564 atomic_set(&ihost
->nr_scans
, 0);
1565 mutex_init(&ihost
->mutex
);
1567 iscsi_bsg_host_add(shost
, ihost
);
1568 /* ignore any bsg add error - we just can't do sgio */
1573 static int iscsi_remove_host(struct transport_container
*tc
,
1574 struct device
*dev
, struct device
*cdev
)
1576 struct Scsi_Host
*shost
= dev_to_shost(dev
);
1577 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
1580 bsg_unregister_queue(ihost
->bsg_q
);
1581 blk_cleanup_queue(ihost
->bsg_q
);
1586 static DECLARE_TRANSPORT_CLASS(iscsi_host_class
,
1592 static DECLARE_TRANSPORT_CLASS(iscsi_session_class
,
1598 static DECLARE_TRANSPORT_CLASS(iscsi_connection_class
,
1604 static struct sock
*nls
;
1605 static DEFINE_MUTEX(rx_queue_mutex
);
1607 static LIST_HEAD(sesslist
);
1608 static DEFINE_SPINLOCK(sesslock
);
1609 static LIST_HEAD(connlist
);
1610 static DEFINE_SPINLOCK(connlock
);
1612 static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn
*conn
)
1614 struct iscsi_cls_session
*sess
= iscsi_dev_to_session(conn
->dev
.parent
);
1619 * Returns the matching session to a given sid
1621 static struct iscsi_cls_session
*iscsi_session_lookup(uint32_t sid
)
1623 unsigned long flags
;
1624 struct iscsi_cls_session
*sess
;
1626 spin_lock_irqsave(&sesslock
, flags
);
1627 list_for_each_entry(sess
, &sesslist
, sess_list
) {
1628 if (sess
->sid
== sid
) {
1629 spin_unlock_irqrestore(&sesslock
, flags
);
1633 spin_unlock_irqrestore(&sesslock
, flags
);
1638 * Returns the matching connection to a given sid / cid tuple
1640 static struct iscsi_cls_conn
*iscsi_conn_lookup(uint32_t sid
, uint32_t cid
)
1642 unsigned long flags
;
1643 struct iscsi_cls_conn
*conn
;
1645 spin_lock_irqsave(&connlock
, flags
);
1646 list_for_each_entry(conn
, &connlist
, conn_list
) {
1647 if ((conn
->cid
== cid
) && (iscsi_conn_get_sid(conn
) == sid
)) {
1648 spin_unlock_irqrestore(&connlock
, flags
);
1652 spin_unlock_irqrestore(&connlock
, flags
);
1657 * The following functions can be used by LLDs that allocate
1658 * their own scsi_hosts or by software iscsi LLDs
1663 } iscsi_session_state_names
[] = {
1664 { ISCSI_SESSION_LOGGED_IN
, "LOGGED_IN" },
1665 { ISCSI_SESSION_FAILED
, "FAILED" },
1666 { ISCSI_SESSION_FREE
, "FREE" },
1669 static const char *iscsi_session_state_name(int state
)
1674 for (i
= 0; i
< ARRAY_SIZE(iscsi_session_state_names
); i
++) {
1675 if (iscsi_session_state_names
[i
].value
== state
) {
1676 name
= iscsi_session_state_names
[i
].name
;
1683 int iscsi_session_chkready(struct iscsi_cls_session
*session
)
1685 unsigned long flags
;
1688 spin_lock_irqsave(&session
->lock
, flags
);
1689 switch (session
->state
) {
1690 case ISCSI_SESSION_LOGGED_IN
:
1693 case ISCSI_SESSION_FAILED
:
1694 err
= DID_IMM_RETRY
<< 16;
1696 case ISCSI_SESSION_FREE
:
1697 err
= DID_TRANSPORT_FAILFAST
<< 16;
1700 err
= DID_NO_CONNECT
<< 16;
1703 spin_unlock_irqrestore(&session
->lock
, flags
);
1706 EXPORT_SYMBOL_GPL(iscsi_session_chkready
);
1708 int iscsi_is_session_online(struct iscsi_cls_session
*session
)
1710 unsigned long flags
;
1713 spin_lock_irqsave(&session
->lock
, flags
);
1714 if (session
->state
== ISCSI_SESSION_LOGGED_IN
)
1716 spin_unlock_irqrestore(&session
->lock
, flags
);
1719 EXPORT_SYMBOL_GPL(iscsi_is_session_online
);
1721 static void iscsi_session_release(struct device
*dev
)
1723 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
);
1724 struct Scsi_Host
*shost
;
1726 shost
= iscsi_session_to_shost(session
);
1727 scsi_host_put(shost
);
1728 ISCSI_DBG_TRANS_SESSION(session
, "Completing session release\n");
1732 int iscsi_is_session_dev(const struct device
*dev
)
1734 return dev
->release
== iscsi_session_release
;
1736 EXPORT_SYMBOL_GPL(iscsi_is_session_dev
);
1738 static int iscsi_iter_session_fn(struct device
*dev
, void *data
)
1740 void (* fn
) (struct iscsi_cls_session
*) = data
;
1742 if (!iscsi_is_session_dev(dev
))
1744 fn(iscsi_dev_to_session(dev
));
1748 void iscsi_host_for_each_session(struct Scsi_Host
*shost
,
1749 void (*fn
)(struct iscsi_cls_session
*))
1751 device_for_each_child(&shost
->shost_gendev
, fn
,
1752 iscsi_iter_session_fn
);
1754 EXPORT_SYMBOL_GPL(iscsi_host_for_each_session
);
1757 * iscsi_scan_finished - helper to report when running scans are done
1759 * @time: scan run time
1761 * This function can be used by drives like qla4xxx to report to the scsi
1762 * layer when the scans it kicked off at module load time are done.
1764 int iscsi_scan_finished(struct Scsi_Host
*shost
, unsigned long time
)
1766 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
1768 * qla4xxx will have kicked off some session unblocks before calling
1769 * scsi_scan_host, so just wait for them to complete.
1771 return !atomic_read(&ihost
->nr_scans
);
1773 EXPORT_SYMBOL_GPL(iscsi_scan_finished
);
1775 struct iscsi_scan_data
{
1776 unsigned int channel
;
1779 enum scsi_scan_mode rescan
;
1782 static int iscsi_user_scan_session(struct device
*dev
, void *data
)
1784 struct iscsi_scan_data
*scan_data
= data
;
1785 struct iscsi_cls_session
*session
;
1786 struct Scsi_Host
*shost
;
1787 struct iscsi_cls_host
*ihost
;
1788 unsigned long flags
;
1791 if (!iscsi_is_session_dev(dev
))
1794 session
= iscsi_dev_to_session(dev
);
1796 ISCSI_DBG_TRANS_SESSION(session
, "Scanning session\n");
1798 shost
= iscsi_session_to_shost(session
);
1799 ihost
= shost
->shost_data
;
1801 mutex_lock(&ihost
->mutex
);
1802 spin_lock_irqsave(&session
->lock
, flags
);
1803 if (session
->state
!= ISCSI_SESSION_LOGGED_IN
) {
1804 spin_unlock_irqrestore(&session
->lock
, flags
);
1805 goto user_scan_exit
;
1807 id
= session
->target_id
;
1808 spin_unlock_irqrestore(&session
->lock
, flags
);
1810 if (id
!= ISCSI_MAX_TARGET
) {
1811 if ((scan_data
->channel
== SCAN_WILD_CARD
||
1812 scan_data
->channel
== 0) &&
1813 (scan_data
->id
== SCAN_WILD_CARD
||
1814 scan_data
->id
== id
))
1815 scsi_scan_target(&session
->dev
, 0, id
,
1816 scan_data
->lun
, scan_data
->rescan
);
1820 mutex_unlock(&ihost
->mutex
);
1821 ISCSI_DBG_TRANS_SESSION(session
, "Completed session scan\n");
1825 static int iscsi_user_scan(struct Scsi_Host
*shost
, uint channel
,
1828 struct iscsi_scan_data scan_data
;
1830 scan_data
.channel
= channel
;
1832 scan_data
.lun
= lun
;
1833 scan_data
.rescan
= SCSI_SCAN_MANUAL
;
1835 return device_for_each_child(&shost
->shost_gendev
, &scan_data
,
1836 iscsi_user_scan_session
);
1839 static void iscsi_scan_session(struct work_struct
*work
)
1841 struct iscsi_cls_session
*session
=
1842 container_of(work
, struct iscsi_cls_session
, scan_work
);
1843 struct Scsi_Host
*shost
= iscsi_session_to_shost(session
);
1844 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
1845 struct iscsi_scan_data scan_data
;
1847 scan_data
.channel
= 0;
1848 scan_data
.id
= SCAN_WILD_CARD
;
1849 scan_data
.lun
= SCAN_WILD_CARD
;
1850 scan_data
.rescan
= SCSI_SCAN_RESCAN
;
1852 iscsi_user_scan_session(&session
->dev
, &scan_data
);
1853 atomic_dec(&ihost
->nr_scans
);
1857 * iscsi_block_scsi_eh - block scsi eh until session state has transistioned
1858 * @cmd: scsi cmd passed to scsi eh handler
1860 * If the session is down this function will wait for the recovery
1861 * timer to fire or for the session to be logged back in. If the
1862 * recovery timer fires then FAST_IO_FAIL is returned. The caller
1863 * should pass this error value to the scsi eh.
1865 int iscsi_block_scsi_eh(struct scsi_cmnd
*cmd
)
1867 struct iscsi_cls_session
*session
=
1868 starget_to_session(scsi_target(cmd
->device
));
1869 unsigned long flags
;
1872 spin_lock_irqsave(&session
->lock
, flags
);
1873 while (session
->state
!= ISCSI_SESSION_LOGGED_IN
) {
1874 if (session
->state
== ISCSI_SESSION_FREE
) {
1878 spin_unlock_irqrestore(&session
->lock
, flags
);
1880 spin_lock_irqsave(&session
->lock
, flags
);
1882 spin_unlock_irqrestore(&session
->lock
, flags
);
1885 EXPORT_SYMBOL_GPL(iscsi_block_scsi_eh
);
1887 static void session_recovery_timedout(struct work_struct
*work
)
1889 struct iscsi_cls_session
*session
=
1890 container_of(work
, struct iscsi_cls_session
,
1891 recovery_work
.work
);
1892 unsigned long flags
;
1894 iscsi_cls_session_printk(KERN_INFO
, session
,
1895 "session recovery timed out after %d secs\n",
1896 session
->recovery_tmo
);
1898 spin_lock_irqsave(&session
->lock
, flags
);
1899 switch (session
->state
) {
1900 case ISCSI_SESSION_FAILED
:
1901 session
->state
= ISCSI_SESSION_FREE
;
1903 case ISCSI_SESSION_LOGGED_IN
:
1904 case ISCSI_SESSION_FREE
:
1905 /* we raced with the unblock's flush */
1906 spin_unlock_irqrestore(&session
->lock
, flags
);
1909 spin_unlock_irqrestore(&session
->lock
, flags
);
1911 if (session
->transport
->session_recovery_timedout
)
1912 session
->transport
->session_recovery_timedout(session
);
1914 ISCSI_DBG_TRANS_SESSION(session
, "Unblocking SCSI target\n");
1915 scsi_target_unblock(&session
->dev
, SDEV_TRANSPORT_OFFLINE
);
1916 ISCSI_DBG_TRANS_SESSION(session
, "Completed unblocking SCSI target\n");
1919 static void __iscsi_unblock_session(struct work_struct
*work
)
1921 struct iscsi_cls_session
*session
=
1922 container_of(work
, struct iscsi_cls_session
,
1924 struct Scsi_Host
*shost
= iscsi_session_to_shost(session
);
1925 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
1926 unsigned long flags
;
1928 ISCSI_DBG_TRANS_SESSION(session
, "Unblocking session\n");
1930 * The recovery and unblock work get run from the same workqueue,
1931 * so try to cancel it if it was going to run after this unblock.
1933 cancel_delayed_work(&session
->recovery_work
);
1934 spin_lock_irqsave(&session
->lock
, flags
);
1935 session
->state
= ISCSI_SESSION_LOGGED_IN
;
1936 spin_unlock_irqrestore(&session
->lock
, flags
);
1938 scsi_target_unblock(&session
->dev
, SDEV_RUNNING
);
1940 * Only do kernel scanning if the driver is properly hooked into
1941 * the async scanning code (drivers like iscsi_tcp do login and
1942 * scanning from userspace).
1944 if (shost
->hostt
->scan_finished
) {
1945 if (scsi_queue_work(shost
, &session
->scan_work
))
1946 atomic_inc(&ihost
->nr_scans
);
1948 ISCSI_DBG_TRANS_SESSION(session
, "Completed unblocking session\n");
1952 * iscsi_unblock_session - set a session as logged in and start IO.
1953 * @session: iscsi session
1955 * Mark a session as ready to accept IO.
1957 void iscsi_unblock_session(struct iscsi_cls_session
*session
)
1959 queue_work(iscsi_eh_timer_workq
, &session
->unblock_work
);
1961 * make sure all the events have completed before tell the driver
1964 flush_workqueue(iscsi_eh_timer_workq
);
1966 EXPORT_SYMBOL_GPL(iscsi_unblock_session
);
1968 static void __iscsi_block_session(struct work_struct
*work
)
1970 struct iscsi_cls_session
*session
=
1971 container_of(work
, struct iscsi_cls_session
,
1973 unsigned long flags
;
1975 ISCSI_DBG_TRANS_SESSION(session
, "Blocking session\n");
1976 spin_lock_irqsave(&session
->lock
, flags
);
1977 session
->state
= ISCSI_SESSION_FAILED
;
1978 spin_unlock_irqrestore(&session
->lock
, flags
);
1979 scsi_target_block(&session
->dev
);
1980 ISCSI_DBG_TRANS_SESSION(session
, "Completed SCSI target blocking\n");
1981 if (session
->recovery_tmo
>= 0)
1982 queue_delayed_work(iscsi_eh_timer_workq
,
1983 &session
->recovery_work
,
1984 session
->recovery_tmo
* HZ
);
1987 void iscsi_block_session(struct iscsi_cls_session
*session
)
1989 queue_work(iscsi_eh_timer_workq
, &session
->block_work
);
1991 EXPORT_SYMBOL_GPL(iscsi_block_session
);
1993 static void __iscsi_unbind_session(struct work_struct
*work
)
1995 struct iscsi_cls_session
*session
=
1996 container_of(work
, struct iscsi_cls_session
,
1998 struct Scsi_Host
*shost
= iscsi_session_to_shost(session
);
1999 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
2000 unsigned long flags
;
2001 unsigned int target_id
;
2003 ISCSI_DBG_TRANS_SESSION(session
, "Unbinding session\n");
2005 /* Prevent new scans and make sure scanning is not in progress */
2006 mutex_lock(&ihost
->mutex
);
2007 spin_lock_irqsave(&session
->lock
, flags
);
2008 if (session
->target_id
== ISCSI_MAX_TARGET
) {
2009 spin_unlock_irqrestore(&session
->lock
, flags
);
2010 mutex_unlock(&ihost
->mutex
);
2014 target_id
= session
->target_id
;
2015 session
->target_id
= ISCSI_MAX_TARGET
;
2016 spin_unlock_irqrestore(&session
->lock
, flags
);
2017 mutex_unlock(&ihost
->mutex
);
2019 if (session
->ida_used
)
2020 ida_simple_remove(&iscsi_sess_ida
, target_id
);
2022 scsi_remove_target(&session
->dev
);
2023 iscsi_session_event(session
, ISCSI_KEVENT_UNBIND_SESSION
);
2024 ISCSI_DBG_TRANS_SESSION(session
, "Completed target removal\n");
2027 struct iscsi_cls_session
*
2028 iscsi_alloc_session(struct Scsi_Host
*shost
, struct iscsi_transport
*transport
,
2031 struct iscsi_cls_session
*session
;
2033 session
= kzalloc(sizeof(*session
) + dd_size
,
2038 session
->transport
= transport
;
2039 session
->creator
= -1;
2040 session
->recovery_tmo
= 120;
2041 session
->recovery_tmo_sysfs_override
= false;
2042 session
->state
= ISCSI_SESSION_FREE
;
2043 INIT_DELAYED_WORK(&session
->recovery_work
, session_recovery_timedout
);
2044 INIT_LIST_HEAD(&session
->sess_list
);
2045 INIT_WORK(&session
->unblock_work
, __iscsi_unblock_session
);
2046 INIT_WORK(&session
->block_work
, __iscsi_block_session
);
2047 INIT_WORK(&session
->unbind_work
, __iscsi_unbind_session
);
2048 INIT_WORK(&session
->scan_work
, iscsi_scan_session
);
2049 spin_lock_init(&session
->lock
);
2051 /* this is released in the dev's release function */
2052 scsi_host_get(shost
);
2053 session
->dev
.parent
= &shost
->shost_gendev
;
2054 session
->dev
.release
= iscsi_session_release
;
2055 device_initialize(&session
->dev
);
2057 session
->dd_data
= &session
[1];
2059 ISCSI_DBG_TRANS_SESSION(session
, "Completed session allocation\n");
2062 EXPORT_SYMBOL_GPL(iscsi_alloc_session
);
2064 int iscsi_add_session(struct iscsi_cls_session
*session
, unsigned int target_id
)
2066 unsigned long flags
;
2070 session
->sid
= atomic_add_return(1, &iscsi_session_nr
);
2072 if (target_id
== ISCSI_MAX_TARGET
) {
2073 id
= ida_simple_get(&iscsi_sess_ida
, 0, 0, GFP_KERNEL
);
2076 iscsi_cls_session_printk(KERN_ERR
, session
,
2077 "Failure in Target ID Allocation\n");
2080 session
->target_id
= (unsigned int)id
;
2081 session
->ida_used
= true;
2083 session
->target_id
= target_id
;
2085 dev_set_name(&session
->dev
, "session%u", session
->sid
);
2086 err
= device_add(&session
->dev
);
2088 iscsi_cls_session_printk(KERN_ERR
, session
,
2089 "could not register session's dev\n");
2092 transport_register_device(&session
->dev
);
2094 spin_lock_irqsave(&sesslock
, flags
);
2095 list_add(&session
->sess_list
, &sesslist
);
2096 spin_unlock_irqrestore(&sesslock
, flags
);
2098 iscsi_session_event(session
, ISCSI_KEVENT_CREATE_SESSION
);
2099 ISCSI_DBG_TRANS_SESSION(session
, "Completed session adding\n");
2103 if (session
->ida_used
)
2104 ida_simple_remove(&iscsi_sess_ida
, session
->target_id
);
2108 EXPORT_SYMBOL_GPL(iscsi_add_session
);
2111 * iscsi_create_session - create iscsi class session
2113 * @transport: iscsi transport
2114 * @dd_size: private driver data size
2115 * @target_id: which target
2117 * This can be called from a LLD or iscsi_transport.
2119 struct iscsi_cls_session
*
2120 iscsi_create_session(struct Scsi_Host
*shost
, struct iscsi_transport
*transport
,
2121 int dd_size
, unsigned int target_id
)
2123 struct iscsi_cls_session
*session
;
2125 session
= iscsi_alloc_session(shost
, transport
, dd_size
);
2129 if (iscsi_add_session(session
, target_id
)) {
2130 iscsi_free_session(session
);
2135 EXPORT_SYMBOL_GPL(iscsi_create_session
);
2137 static void iscsi_conn_release(struct device
*dev
)
2139 struct iscsi_cls_conn
*conn
= iscsi_dev_to_conn(dev
);
2140 struct device
*parent
= conn
->dev
.parent
;
2142 ISCSI_DBG_TRANS_CONN(conn
, "Releasing conn\n");
2147 static int iscsi_is_conn_dev(const struct device
*dev
)
2149 return dev
->release
== iscsi_conn_release
;
2152 static int iscsi_iter_destroy_conn_fn(struct device
*dev
, void *data
)
2154 if (!iscsi_is_conn_dev(dev
))
2156 return iscsi_destroy_conn(iscsi_dev_to_conn(dev
));
2159 void iscsi_remove_session(struct iscsi_cls_session
*session
)
2161 unsigned long flags
;
2164 ISCSI_DBG_TRANS_SESSION(session
, "Removing session\n");
2166 spin_lock_irqsave(&sesslock
, flags
);
2167 list_del(&session
->sess_list
);
2168 spin_unlock_irqrestore(&sesslock
, flags
);
2170 /* make sure there are no blocks/unblocks queued */
2171 flush_workqueue(iscsi_eh_timer_workq
);
2172 /* make sure the timedout callout is not running */
2173 if (!cancel_delayed_work(&session
->recovery_work
))
2174 flush_workqueue(iscsi_eh_timer_workq
);
2176 * If we are blocked let commands flow again. The lld or iscsi
2177 * layer should set up the queuecommand to fail commands.
2178 * We assume that LLD will not be calling block/unblock while
2179 * removing the session.
2181 spin_lock_irqsave(&session
->lock
, flags
);
2182 session
->state
= ISCSI_SESSION_FREE
;
2183 spin_unlock_irqrestore(&session
->lock
, flags
);
2185 scsi_target_unblock(&session
->dev
, SDEV_TRANSPORT_OFFLINE
);
2186 /* flush running scans then delete devices */
2187 flush_work(&session
->scan_work
);
2188 __iscsi_unbind_session(&session
->unbind_work
);
2190 /* hw iscsi may not have removed all connections from session */
2191 err
= device_for_each_child(&session
->dev
, NULL
,
2192 iscsi_iter_destroy_conn_fn
);
2194 iscsi_cls_session_printk(KERN_ERR
, session
,
2195 "Could not delete all connections "
2196 "for session. Error %d.\n", err
);
2198 transport_unregister_device(&session
->dev
);
2200 ISCSI_DBG_TRANS_SESSION(session
, "Completing session removal\n");
2201 device_del(&session
->dev
);
2203 EXPORT_SYMBOL_GPL(iscsi_remove_session
);
2205 void iscsi_free_session(struct iscsi_cls_session
*session
)
2207 ISCSI_DBG_TRANS_SESSION(session
, "Freeing session\n");
2208 iscsi_session_event(session
, ISCSI_KEVENT_DESTROY_SESSION
);
2209 put_device(&session
->dev
);
2211 EXPORT_SYMBOL_GPL(iscsi_free_session
);
2214 * iscsi_create_conn - create iscsi class connection
2215 * @session: iscsi cls session
2216 * @dd_size: private driver data size
2217 * @cid: connection id
2219 * This can be called from a LLD or iscsi_transport. The connection
2220 * is child of the session so cid must be unique for all connections
2223 * Since we do not support MCS, cid will normally be zero. In some cases
2224 * for software iscsi we could be trying to preallocate a connection struct
2225 * in which case there could be two connection structs and cid would be
2228 struct iscsi_cls_conn
*
2229 iscsi_create_conn(struct iscsi_cls_session
*session
, int dd_size
, uint32_t cid
)
2231 struct iscsi_transport
*transport
= session
->transport
;
2232 struct iscsi_cls_conn
*conn
;
2233 unsigned long flags
;
2236 conn
= kzalloc(sizeof(*conn
) + dd_size
, GFP_KERNEL
);
2240 conn
->dd_data
= &conn
[1];
2242 mutex_init(&conn
->ep_mutex
);
2243 INIT_LIST_HEAD(&conn
->conn_list
);
2244 conn
->transport
= transport
;
2247 /* this is released in the dev's release function */
2248 if (!get_device(&session
->dev
))
2251 dev_set_name(&conn
->dev
, "connection%d:%u", session
->sid
, cid
);
2252 conn
->dev
.parent
= &session
->dev
;
2253 conn
->dev
.release
= iscsi_conn_release
;
2254 err
= device_register(&conn
->dev
);
2256 iscsi_cls_session_printk(KERN_ERR
, session
, "could not "
2257 "register connection's dev\n");
2258 goto release_parent_ref
;
2260 transport_register_device(&conn
->dev
);
2262 spin_lock_irqsave(&connlock
, flags
);
2263 list_add(&conn
->conn_list
, &connlist
);
2264 spin_unlock_irqrestore(&connlock
, flags
);
2266 ISCSI_DBG_TRANS_CONN(conn
, "Completed conn creation\n");
2270 put_device(&session
->dev
);
2276 EXPORT_SYMBOL_GPL(iscsi_create_conn
);
2279 * iscsi_destroy_conn - destroy iscsi class connection
2280 * @conn: iscsi cls session
2282 * This can be called from a LLD or iscsi_transport.
2284 int iscsi_destroy_conn(struct iscsi_cls_conn
*conn
)
2286 unsigned long flags
;
2288 spin_lock_irqsave(&connlock
, flags
);
2289 list_del(&conn
->conn_list
);
2290 spin_unlock_irqrestore(&connlock
, flags
);
2292 transport_unregister_device(&conn
->dev
);
2293 ISCSI_DBG_TRANS_CONN(conn
, "Completing conn destruction\n");
2294 device_unregister(&conn
->dev
);
2297 EXPORT_SYMBOL_GPL(iscsi_destroy_conn
);
2300 * iscsi interface functions
2302 static struct iscsi_internal
*
2303 iscsi_if_transport_lookup(struct iscsi_transport
*tt
)
2305 struct iscsi_internal
*priv
;
2306 unsigned long flags
;
2308 spin_lock_irqsave(&iscsi_transport_lock
, flags
);
2309 list_for_each_entry(priv
, &iscsi_transports
, list
) {
2310 if (tt
== priv
->iscsi_transport
) {
2311 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
2315 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
2320 iscsi_multicast_skb(struct sk_buff
*skb
, uint32_t group
, gfp_t gfp
)
2322 return nlmsg_multicast(nls
, skb
, 0, group
, gfp
);
2325 int iscsi_recv_pdu(struct iscsi_cls_conn
*conn
, struct iscsi_hdr
*hdr
,
2326 char *data
, uint32_t data_size
)
2328 struct nlmsghdr
*nlh
;
2329 struct sk_buff
*skb
;
2330 struct iscsi_uevent
*ev
;
2332 struct iscsi_internal
*priv
;
2333 int len
= nlmsg_total_size(sizeof(*ev
) + sizeof(struct iscsi_hdr
) +
2336 priv
= iscsi_if_transport_lookup(conn
->transport
);
2340 skb
= alloc_skb(len
, GFP_ATOMIC
);
2342 iscsi_conn_error_event(conn
, ISCSI_ERR_CONN_FAILED
);
2343 iscsi_cls_conn_printk(KERN_ERR
, conn
, "can not deliver "
2344 "control PDU: OOM\n");
2348 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2349 ev
= nlmsg_data(nlh
);
2350 memset(ev
, 0, sizeof(*ev
));
2351 ev
->transport_handle
= iscsi_handle(conn
->transport
);
2352 ev
->type
= ISCSI_KEVENT_RECV_PDU
;
2353 ev
->r
.recv_req
.cid
= conn
->cid
;
2354 ev
->r
.recv_req
.sid
= iscsi_conn_get_sid(conn
);
2355 pdu
= (char*)ev
+ sizeof(*ev
);
2356 memcpy(pdu
, hdr
, sizeof(struct iscsi_hdr
));
2357 memcpy(pdu
+ sizeof(struct iscsi_hdr
), data
, data_size
);
2359 return iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_ATOMIC
);
2361 EXPORT_SYMBOL_GPL(iscsi_recv_pdu
);
2363 int iscsi_offload_mesg(struct Scsi_Host
*shost
,
2364 struct iscsi_transport
*transport
, uint32_t type
,
2365 char *data
, uint16_t data_size
)
2367 struct nlmsghdr
*nlh
;
2368 struct sk_buff
*skb
;
2369 struct iscsi_uevent
*ev
;
2370 int len
= nlmsg_total_size(sizeof(*ev
) + data_size
);
2372 skb
= alloc_skb(len
, GFP_ATOMIC
);
2374 printk(KERN_ERR
"can not deliver iscsi offload message:OOM\n");
2378 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2379 ev
= nlmsg_data(nlh
);
2380 memset(ev
, 0, sizeof(*ev
));
2382 ev
->transport_handle
= iscsi_handle(transport
);
2384 case ISCSI_KEVENT_PATH_REQ
:
2385 ev
->r
.req_path
.host_no
= shost
->host_no
;
2387 case ISCSI_KEVENT_IF_DOWN
:
2388 ev
->r
.notify_if_down
.host_no
= shost
->host_no
;
2392 memcpy((char *)ev
+ sizeof(*ev
), data
, data_size
);
2394 return iscsi_multicast_skb(skb
, ISCSI_NL_GRP_UIP
, GFP_ATOMIC
);
2396 EXPORT_SYMBOL_GPL(iscsi_offload_mesg
);
2398 void iscsi_conn_error_event(struct iscsi_cls_conn
*conn
, enum iscsi_err error
)
2400 struct nlmsghdr
*nlh
;
2401 struct sk_buff
*skb
;
2402 struct iscsi_uevent
*ev
;
2403 struct iscsi_internal
*priv
;
2404 int len
= nlmsg_total_size(sizeof(*ev
));
2406 priv
= iscsi_if_transport_lookup(conn
->transport
);
2410 skb
= alloc_skb(len
, GFP_ATOMIC
);
2412 iscsi_cls_conn_printk(KERN_ERR
, conn
, "gracefully ignored "
2413 "conn error (%d)\n", error
);
2417 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2418 ev
= nlmsg_data(nlh
);
2419 ev
->transport_handle
= iscsi_handle(conn
->transport
);
2420 ev
->type
= ISCSI_KEVENT_CONN_ERROR
;
2421 ev
->r
.connerror
.error
= error
;
2422 ev
->r
.connerror
.cid
= conn
->cid
;
2423 ev
->r
.connerror
.sid
= iscsi_conn_get_sid(conn
);
2425 iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_ATOMIC
);
2427 iscsi_cls_conn_printk(KERN_INFO
, conn
, "detected conn error (%d)\n",
2430 EXPORT_SYMBOL_GPL(iscsi_conn_error_event
);
2432 void iscsi_conn_login_event(struct iscsi_cls_conn
*conn
,
2433 enum iscsi_conn_state state
)
2435 struct nlmsghdr
*nlh
;
2436 struct sk_buff
*skb
;
2437 struct iscsi_uevent
*ev
;
2438 struct iscsi_internal
*priv
;
2439 int len
= nlmsg_total_size(sizeof(*ev
));
2441 priv
= iscsi_if_transport_lookup(conn
->transport
);
2445 skb
= alloc_skb(len
, GFP_ATOMIC
);
2447 iscsi_cls_conn_printk(KERN_ERR
, conn
, "gracefully ignored "
2448 "conn login (%d)\n", state
);
2452 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2453 ev
= nlmsg_data(nlh
);
2454 ev
->transport_handle
= iscsi_handle(conn
->transport
);
2455 ev
->type
= ISCSI_KEVENT_CONN_LOGIN_STATE
;
2456 ev
->r
.conn_login
.state
= state
;
2457 ev
->r
.conn_login
.cid
= conn
->cid
;
2458 ev
->r
.conn_login
.sid
= iscsi_conn_get_sid(conn
);
2459 iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_ATOMIC
);
2461 iscsi_cls_conn_printk(KERN_INFO
, conn
, "detected conn login (%d)\n",
2464 EXPORT_SYMBOL_GPL(iscsi_conn_login_event
);
2466 void iscsi_post_host_event(uint32_t host_no
, struct iscsi_transport
*transport
,
2467 enum iscsi_host_event_code code
, uint32_t data_size
,
2470 struct nlmsghdr
*nlh
;
2471 struct sk_buff
*skb
;
2472 struct iscsi_uevent
*ev
;
2473 int len
= nlmsg_total_size(sizeof(*ev
) + data_size
);
2475 skb
= alloc_skb(len
, GFP_NOIO
);
2477 printk(KERN_ERR
"gracefully ignored host event (%d):%d OOM\n",
2482 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2483 ev
= nlmsg_data(nlh
);
2484 ev
->transport_handle
= iscsi_handle(transport
);
2485 ev
->type
= ISCSI_KEVENT_HOST_EVENT
;
2486 ev
->r
.host_event
.host_no
= host_no
;
2487 ev
->r
.host_event
.code
= code
;
2488 ev
->r
.host_event
.data_size
= data_size
;
2491 memcpy((char *)ev
+ sizeof(*ev
), data
, data_size
);
2493 iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_NOIO
);
2495 EXPORT_SYMBOL_GPL(iscsi_post_host_event
);
2497 void iscsi_ping_comp_event(uint32_t host_no
, struct iscsi_transport
*transport
,
2498 uint32_t status
, uint32_t pid
, uint32_t data_size
,
2501 struct nlmsghdr
*nlh
;
2502 struct sk_buff
*skb
;
2503 struct iscsi_uevent
*ev
;
2504 int len
= nlmsg_total_size(sizeof(*ev
) + data_size
);
2506 skb
= alloc_skb(len
, GFP_NOIO
);
2508 printk(KERN_ERR
"gracefully ignored ping comp: OOM\n");
2512 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2513 ev
= nlmsg_data(nlh
);
2514 ev
->transport_handle
= iscsi_handle(transport
);
2515 ev
->type
= ISCSI_KEVENT_PING_COMP
;
2516 ev
->r
.ping_comp
.host_no
= host_no
;
2517 ev
->r
.ping_comp
.status
= status
;
2518 ev
->r
.ping_comp
.pid
= pid
;
2519 ev
->r
.ping_comp
.data_size
= data_size
;
2520 memcpy((char *)ev
+ sizeof(*ev
), data
, data_size
);
2522 iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_NOIO
);
2524 EXPORT_SYMBOL_GPL(iscsi_ping_comp_event
);
2527 iscsi_if_send_reply(uint32_t group
, int seq
, int type
, int done
, int multi
,
2528 void *payload
, int size
)
2530 struct sk_buff
*skb
;
2531 struct nlmsghdr
*nlh
;
2532 int len
= nlmsg_total_size(size
);
2533 int flags
= multi
? NLM_F_MULTI
: 0;
2534 int t
= done
? NLMSG_DONE
: type
;
2536 skb
= alloc_skb(len
, GFP_ATOMIC
);
2538 printk(KERN_ERR
"Could not allocate skb to send reply.\n");
2542 nlh
= __nlmsg_put(skb
, 0, 0, t
, (len
- sizeof(*nlh
)), 0);
2543 nlh
->nlmsg_flags
= flags
;
2544 memcpy(nlmsg_data(nlh
), payload
, size
);
2545 return iscsi_multicast_skb(skb
, group
, GFP_ATOMIC
);
2549 iscsi_if_get_stats(struct iscsi_transport
*transport
, struct nlmsghdr
*nlh
)
2551 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
2552 struct iscsi_stats
*stats
;
2553 struct sk_buff
*skbstat
;
2554 struct iscsi_cls_conn
*conn
;
2555 struct nlmsghdr
*nlhstat
;
2556 struct iscsi_uevent
*evstat
;
2557 struct iscsi_internal
*priv
;
2558 int len
= nlmsg_total_size(sizeof(*ev
) +
2559 sizeof(struct iscsi_stats
) +
2560 sizeof(struct iscsi_stats_custom
) *
2561 ISCSI_STATS_CUSTOM_MAX
);
2564 priv
= iscsi_if_transport_lookup(transport
);
2568 conn
= iscsi_conn_lookup(ev
->u
.get_stats
.sid
, ev
->u
.get_stats
.cid
);
2575 skbstat
= alloc_skb(len
, GFP_ATOMIC
);
2577 iscsi_cls_conn_printk(KERN_ERR
, conn
, "can not "
2578 "deliver stats: OOM\n");
2582 nlhstat
= __nlmsg_put(skbstat
, 0, 0, 0,
2583 (len
- sizeof(*nlhstat
)), 0);
2584 evstat
= nlmsg_data(nlhstat
);
2585 memset(evstat
, 0, sizeof(*evstat
));
2586 evstat
->transport_handle
= iscsi_handle(conn
->transport
);
2587 evstat
->type
= nlh
->nlmsg_type
;
2588 evstat
->u
.get_stats
.cid
=
2589 ev
->u
.get_stats
.cid
;
2590 evstat
->u
.get_stats
.sid
=
2591 ev
->u
.get_stats
.sid
;
2592 stats
= (struct iscsi_stats
*)
2593 ((char*)evstat
+ sizeof(*evstat
));
2594 memset(stats
, 0, sizeof(*stats
));
2596 transport
->get_stats(conn
, stats
);
2597 actual_size
= nlmsg_total_size(sizeof(struct iscsi_uevent
) +
2598 sizeof(struct iscsi_stats
) +
2599 sizeof(struct iscsi_stats_custom
) *
2600 stats
->custom_length
);
2601 actual_size
-= sizeof(*nlhstat
);
2602 actual_size
= nlmsg_msg_size(actual_size
);
2603 skb_trim(skbstat
, NLMSG_ALIGN(actual_size
));
2604 nlhstat
->nlmsg_len
= actual_size
;
2606 err
= iscsi_multicast_skb(skbstat
, ISCSI_NL_GRP_ISCSID
,
2608 } while (err
< 0 && err
!= -ECONNREFUSED
);
2614 * iscsi_session_event - send session destr. completion event
2615 * @session: iscsi class session
2616 * @event: type of event
2618 int iscsi_session_event(struct iscsi_cls_session
*session
,
2619 enum iscsi_uevent_e event
)
2621 struct iscsi_internal
*priv
;
2622 struct Scsi_Host
*shost
;
2623 struct iscsi_uevent
*ev
;
2624 struct sk_buff
*skb
;
2625 struct nlmsghdr
*nlh
;
2626 int rc
, len
= nlmsg_total_size(sizeof(*ev
));
2628 priv
= iscsi_if_transport_lookup(session
->transport
);
2631 shost
= iscsi_session_to_shost(session
);
2633 skb
= alloc_skb(len
, GFP_KERNEL
);
2635 iscsi_cls_session_printk(KERN_ERR
, session
,
2636 "Cannot notify userspace of session "
2637 "event %u\n", event
);
2641 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2642 ev
= nlmsg_data(nlh
);
2643 ev
->transport_handle
= iscsi_handle(session
->transport
);
2647 case ISCSI_KEVENT_DESTROY_SESSION
:
2648 ev
->r
.d_session
.host_no
= shost
->host_no
;
2649 ev
->r
.d_session
.sid
= session
->sid
;
2651 case ISCSI_KEVENT_CREATE_SESSION
:
2652 ev
->r
.c_session_ret
.host_no
= shost
->host_no
;
2653 ev
->r
.c_session_ret
.sid
= session
->sid
;
2655 case ISCSI_KEVENT_UNBIND_SESSION
:
2656 ev
->r
.unbind_session
.host_no
= shost
->host_no
;
2657 ev
->r
.unbind_session
.sid
= session
->sid
;
2660 iscsi_cls_session_printk(KERN_ERR
, session
, "Invalid event "
2667 * this will occur if the daemon is not up, so we just warn
2668 * the user and when the daemon is restarted it will handle it
2670 rc
= iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_KERNEL
);
2672 iscsi_cls_session_printk(KERN_ERR
, session
,
2673 "Cannot notify userspace of session "
2674 "event %u. Check iscsi daemon\n",
2677 ISCSI_DBG_TRANS_SESSION(session
, "Completed handling event %d rc %d\n",
2681 EXPORT_SYMBOL_GPL(iscsi_session_event
);
2684 iscsi_if_create_session(struct iscsi_internal
*priv
, struct iscsi_endpoint
*ep
,
2685 struct iscsi_uevent
*ev
, pid_t pid
,
2686 uint32_t initial_cmdsn
, uint16_t cmds_max
,
2687 uint16_t queue_depth
)
2689 struct iscsi_transport
*transport
= priv
->iscsi_transport
;
2690 struct iscsi_cls_session
*session
;
2691 struct Scsi_Host
*shost
;
2693 session
= transport
->create_session(ep
, cmds_max
, queue_depth
,
2698 session
->creator
= pid
;
2699 shost
= iscsi_session_to_shost(session
);
2700 ev
->r
.c_session_ret
.host_no
= shost
->host_no
;
2701 ev
->r
.c_session_ret
.sid
= session
->sid
;
2702 ISCSI_DBG_TRANS_SESSION(session
,
2703 "Completed creating transport session\n");
2708 iscsi_if_create_conn(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
2710 struct iscsi_cls_conn
*conn
;
2711 struct iscsi_cls_session
*session
;
2713 session
= iscsi_session_lookup(ev
->u
.c_conn
.sid
);
2715 printk(KERN_ERR
"iscsi: invalid session %d.\n",
2720 conn
= transport
->create_conn(session
, ev
->u
.c_conn
.cid
);
2722 iscsi_cls_session_printk(KERN_ERR
, session
,
2723 "couldn't create a new connection.");
2727 ev
->r
.c_conn_ret
.sid
= session
->sid
;
2728 ev
->r
.c_conn_ret
.cid
= conn
->cid
;
2730 ISCSI_DBG_TRANS_CONN(conn
, "Completed creating transport conn\n");
2735 iscsi_if_destroy_conn(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
2737 struct iscsi_cls_conn
*conn
;
2739 conn
= iscsi_conn_lookup(ev
->u
.d_conn
.sid
, ev
->u
.d_conn
.cid
);
2743 ISCSI_DBG_TRANS_CONN(conn
, "Destroying transport conn\n");
2744 if (transport
->destroy_conn
)
2745 transport
->destroy_conn(conn
);
2751 iscsi_set_param(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
2753 char *data
= (char*)ev
+ sizeof(*ev
);
2754 struct iscsi_cls_conn
*conn
;
2755 struct iscsi_cls_session
*session
;
2756 int err
= 0, value
= 0;
2758 session
= iscsi_session_lookup(ev
->u
.set_param
.sid
);
2759 conn
= iscsi_conn_lookup(ev
->u
.set_param
.sid
, ev
->u
.set_param
.cid
);
2760 if (!conn
|| !session
)
2763 switch (ev
->u
.set_param
.param
) {
2764 case ISCSI_PARAM_SESS_RECOVERY_TMO
:
2765 sscanf(data
, "%d", &value
);
2766 if (!session
->recovery_tmo_sysfs_override
)
2767 session
->recovery_tmo
= value
;
2770 err
= transport
->set_param(conn
, ev
->u
.set_param
.param
,
2771 data
, ev
->u
.set_param
.len
);
2777 static int iscsi_if_ep_connect(struct iscsi_transport
*transport
,
2778 struct iscsi_uevent
*ev
, int msg_type
)
2780 struct iscsi_endpoint
*ep
;
2781 struct sockaddr
*dst_addr
;
2782 struct Scsi_Host
*shost
= NULL
;
2783 int non_blocking
, err
= 0;
2785 if (!transport
->ep_connect
)
2788 if (msg_type
== ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST
) {
2789 shost
= scsi_host_lookup(ev
->u
.ep_connect_through_host
.host_no
);
2791 printk(KERN_ERR
"ep connect failed. Could not find "
2793 ev
->u
.ep_connect_through_host
.host_no
);
2796 non_blocking
= ev
->u
.ep_connect_through_host
.non_blocking
;
2798 non_blocking
= ev
->u
.ep_connect
.non_blocking
;
2800 dst_addr
= (struct sockaddr
*)((char*)ev
+ sizeof(*ev
));
2801 ep
= transport
->ep_connect(shost
, dst_addr
, non_blocking
);
2807 ev
->r
.ep_connect_ret
.handle
= ep
->id
;
2810 scsi_host_put(shost
);
2814 static int iscsi_if_ep_disconnect(struct iscsi_transport
*transport
,
2817 struct iscsi_cls_conn
*conn
;
2818 struct iscsi_endpoint
*ep
;
2820 if (!transport
->ep_disconnect
)
2823 ep
= iscsi_lookup_endpoint(ep_handle
);
2828 mutex_lock(&conn
->ep_mutex
);
2830 mutex_unlock(&conn
->ep_mutex
);
2833 transport
->ep_disconnect(ep
);
2838 iscsi_if_transport_ep(struct iscsi_transport
*transport
,
2839 struct iscsi_uevent
*ev
, int msg_type
)
2841 struct iscsi_endpoint
*ep
;
2845 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST
:
2846 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT
:
2847 rc
= iscsi_if_ep_connect(transport
, ev
, msg_type
);
2849 case ISCSI_UEVENT_TRANSPORT_EP_POLL
:
2850 if (!transport
->ep_poll
)
2853 ep
= iscsi_lookup_endpoint(ev
->u
.ep_poll
.ep_handle
);
2857 ev
->r
.retcode
= transport
->ep_poll(ep
,
2858 ev
->u
.ep_poll
.timeout_ms
);
2860 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT
:
2861 rc
= iscsi_if_ep_disconnect(transport
,
2862 ev
->u
.ep_disconnect
.ep_handle
);
2869 iscsi_tgt_dscvr(struct iscsi_transport
*transport
,
2870 struct iscsi_uevent
*ev
)
2872 struct Scsi_Host
*shost
;
2873 struct sockaddr
*dst_addr
;
2876 if (!transport
->tgt_dscvr
)
2879 shost
= scsi_host_lookup(ev
->u
.tgt_dscvr
.host_no
);
2881 printk(KERN_ERR
"target discovery could not find host no %u\n",
2882 ev
->u
.tgt_dscvr
.host_no
);
2887 dst_addr
= (struct sockaddr
*)((char*)ev
+ sizeof(*ev
));
2888 err
= transport
->tgt_dscvr(shost
, ev
->u
.tgt_dscvr
.type
,
2889 ev
->u
.tgt_dscvr
.enable
, dst_addr
);
2890 scsi_host_put(shost
);
2895 iscsi_set_host_param(struct iscsi_transport
*transport
,
2896 struct iscsi_uevent
*ev
)
2898 char *data
= (char*)ev
+ sizeof(*ev
);
2899 struct Scsi_Host
*shost
;
2902 if (!transport
->set_host_param
)
2905 shost
= scsi_host_lookup(ev
->u
.set_host_param
.host_no
);
2907 printk(KERN_ERR
"set_host_param could not find host no %u\n",
2908 ev
->u
.set_host_param
.host_no
);
2912 err
= transport
->set_host_param(shost
, ev
->u
.set_host_param
.param
,
2913 data
, ev
->u
.set_host_param
.len
);
2914 scsi_host_put(shost
);
2919 iscsi_set_path(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
2921 struct Scsi_Host
*shost
;
2922 struct iscsi_path
*params
;
2925 if (!transport
->set_path
)
2928 shost
= scsi_host_lookup(ev
->u
.set_path
.host_no
);
2930 printk(KERN_ERR
"set path could not find host no %u\n",
2931 ev
->u
.set_path
.host_no
);
2935 params
= (struct iscsi_path
*)((char *)ev
+ sizeof(*ev
));
2936 err
= transport
->set_path(shost
, params
);
2938 scsi_host_put(shost
);
2943 iscsi_set_iface_params(struct iscsi_transport
*transport
,
2944 struct iscsi_uevent
*ev
, uint32_t len
)
2946 char *data
= (char *)ev
+ sizeof(*ev
);
2947 struct Scsi_Host
*shost
;
2950 if (!transport
->set_iface_param
)
2953 shost
= scsi_host_lookup(ev
->u
.set_iface_params
.host_no
);
2955 printk(KERN_ERR
"set_iface_params could not find host no %u\n",
2956 ev
->u
.set_iface_params
.host_no
);
2960 err
= transport
->set_iface_param(shost
, data
, len
);
2961 scsi_host_put(shost
);
2966 iscsi_send_ping(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
2968 struct Scsi_Host
*shost
;
2969 struct sockaddr
*dst_addr
;
2972 if (!transport
->send_ping
)
2975 shost
= scsi_host_lookup(ev
->u
.iscsi_ping
.host_no
);
2977 printk(KERN_ERR
"iscsi_ping could not find host no %u\n",
2978 ev
->u
.iscsi_ping
.host_no
);
2982 dst_addr
= (struct sockaddr
*)((char *)ev
+ sizeof(*ev
));
2983 err
= transport
->send_ping(shost
, ev
->u
.iscsi_ping
.iface_num
,
2984 ev
->u
.iscsi_ping
.iface_type
,
2985 ev
->u
.iscsi_ping
.payload_size
,
2986 ev
->u
.iscsi_ping
.pid
,
2988 scsi_host_put(shost
);
2993 iscsi_get_chap(struct iscsi_transport
*transport
, struct nlmsghdr
*nlh
)
2995 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
2996 struct Scsi_Host
*shost
= NULL
;
2997 struct iscsi_chap_rec
*chap_rec
;
2998 struct iscsi_internal
*priv
;
2999 struct sk_buff
*skbchap
;
3000 struct nlmsghdr
*nlhchap
;
3001 struct iscsi_uevent
*evchap
;
3002 uint32_t chap_buf_size
;
3006 if (!transport
->get_chap
)
3009 priv
= iscsi_if_transport_lookup(transport
);
3013 chap_buf_size
= (ev
->u
.get_chap
.num_entries
* sizeof(*chap_rec
));
3014 len
= nlmsg_total_size(sizeof(*ev
) + chap_buf_size
);
3016 shost
= scsi_host_lookup(ev
->u
.get_chap
.host_no
);
3018 printk(KERN_ERR
"%s: failed. Could not find host no %u\n",
3019 __func__
, ev
->u
.get_chap
.host_no
);
3026 skbchap
= alloc_skb(len
, GFP_KERNEL
);
3028 printk(KERN_ERR
"can not deliver chap: OOM\n");
3033 nlhchap
= __nlmsg_put(skbchap
, 0, 0, 0,
3034 (len
- sizeof(*nlhchap
)), 0);
3035 evchap
= nlmsg_data(nlhchap
);
3036 memset(evchap
, 0, sizeof(*evchap
));
3037 evchap
->transport_handle
= iscsi_handle(transport
);
3038 evchap
->type
= nlh
->nlmsg_type
;
3039 evchap
->u
.get_chap
.host_no
= ev
->u
.get_chap
.host_no
;
3040 evchap
->u
.get_chap
.chap_tbl_idx
= ev
->u
.get_chap
.chap_tbl_idx
;
3041 evchap
->u
.get_chap
.num_entries
= ev
->u
.get_chap
.num_entries
;
3042 buf
= (char *)evchap
+ sizeof(*evchap
);
3043 memset(buf
, 0, chap_buf_size
);
3045 err
= transport
->get_chap(shost
, ev
->u
.get_chap
.chap_tbl_idx
,
3046 &evchap
->u
.get_chap
.num_entries
, buf
);
3048 actual_size
= nlmsg_total_size(sizeof(*ev
) + chap_buf_size
);
3049 skb_trim(skbchap
, NLMSG_ALIGN(actual_size
));
3050 nlhchap
->nlmsg_len
= actual_size
;
3052 err
= iscsi_multicast_skb(skbchap
, ISCSI_NL_GRP_ISCSID
,
3054 } while (err
< 0 && err
!= -ECONNREFUSED
);
3057 scsi_host_put(shost
);
3061 static int iscsi_set_chap(struct iscsi_transport
*transport
,
3062 struct iscsi_uevent
*ev
, uint32_t len
)
3064 char *data
= (char *)ev
+ sizeof(*ev
);
3065 struct Scsi_Host
*shost
;
3068 if (!transport
->set_chap
)
3071 shost
= scsi_host_lookup(ev
->u
.set_path
.host_no
);
3073 pr_err("%s could not find host no %u\n",
3074 __func__
, ev
->u
.set_path
.host_no
);
3078 err
= transport
->set_chap(shost
, data
, len
);
3079 scsi_host_put(shost
);
3083 static int iscsi_delete_chap(struct iscsi_transport
*transport
,
3084 struct iscsi_uevent
*ev
)
3086 struct Scsi_Host
*shost
;
3089 if (!transport
->delete_chap
)
3092 shost
= scsi_host_lookup(ev
->u
.delete_chap
.host_no
);
3094 printk(KERN_ERR
"%s could not find host no %u\n",
3095 __func__
, ev
->u
.delete_chap
.host_no
);
3099 err
= transport
->delete_chap(shost
, ev
->u
.delete_chap
.chap_tbl_idx
);
3100 scsi_host_put(shost
);
3104 static const struct {
3105 enum iscsi_discovery_parent_type value
;
3107 } iscsi_discovery_parent_names
[] = {
3108 {ISCSI_DISC_PARENT_UNKNOWN
, "Unknown" },
3109 {ISCSI_DISC_PARENT_SENDTGT
, "Sendtarget" },
3110 {ISCSI_DISC_PARENT_ISNS
, "isns" },
3113 char *iscsi_get_discovery_parent_name(int parent_type
)
3116 char *state
= "Unknown!";
3118 for (i
= 0; i
< ARRAY_SIZE(iscsi_discovery_parent_names
); i
++) {
3119 if (iscsi_discovery_parent_names
[i
].value
& parent_type
) {
3120 state
= iscsi_discovery_parent_names
[i
].name
;
3126 EXPORT_SYMBOL_GPL(iscsi_get_discovery_parent_name
);
3128 static int iscsi_set_flashnode_param(struct iscsi_transport
*transport
,
3129 struct iscsi_uevent
*ev
, uint32_t len
)
3131 char *data
= (char *)ev
+ sizeof(*ev
);
3132 struct Scsi_Host
*shost
;
3133 struct iscsi_bus_flash_session
*fnode_sess
;
3134 struct iscsi_bus_flash_conn
*fnode_conn
;
3139 if (!transport
->set_flashnode_param
) {
3141 goto exit_set_fnode
;
3144 shost
= scsi_host_lookup(ev
->u
.set_flashnode
.host_no
);
3146 pr_err("%s could not find host no %u\n",
3147 __func__
, ev
->u
.set_flashnode
.host_no
);
3152 idx
= ev
->u
.set_flashnode
.flashnode_idx
;
3153 fnode_sess
= iscsi_get_flashnode_by_index(shost
, idx
);
3155 pr_err("%s could not find flashnode %u for host no %u\n",
3156 __func__
, idx
, ev
->u
.set_flashnode
.host_no
);
3161 dev
= iscsi_find_flashnode_conn(fnode_sess
);
3167 fnode_conn
= iscsi_dev_to_flash_conn(dev
);
3168 err
= transport
->set_flashnode_param(fnode_sess
, fnode_conn
, data
, len
);
3172 put_device(&fnode_sess
->dev
);
3175 scsi_host_put(shost
);
3181 static int iscsi_new_flashnode(struct iscsi_transport
*transport
,
3182 struct iscsi_uevent
*ev
, uint32_t len
)
3184 char *data
= (char *)ev
+ sizeof(*ev
);
3185 struct Scsi_Host
*shost
;
3189 if (!transport
->new_flashnode
) {
3191 goto exit_new_fnode
;
3194 shost
= scsi_host_lookup(ev
->u
.new_flashnode
.host_no
);
3196 pr_err("%s could not find host no %u\n",
3197 __func__
, ev
->u
.new_flashnode
.host_no
);
3202 index
= transport
->new_flashnode(shost
, data
, len
);
3205 ev
->r
.new_flashnode_ret
.flashnode_idx
= index
;
3210 scsi_host_put(shost
);
3216 static int iscsi_del_flashnode(struct iscsi_transport
*transport
,
3217 struct iscsi_uevent
*ev
)
3219 struct Scsi_Host
*shost
;
3220 struct iscsi_bus_flash_session
*fnode_sess
;
3224 if (!transport
->del_flashnode
) {
3226 goto exit_del_fnode
;
3229 shost
= scsi_host_lookup(ev
->u
.del_flashnode
.host_no
);
3231 pr_err("%s could not find host no %u\n",
3232 __func__
, ev
->u
.del_flashnode
.host_no
);
3237 idx
= ev
->u
.del_flashnode
.flashnode_idx
;
3238 fnode_sess
= iscsi_get_flashnode_by_index(shost
, idx
);
3240 pr_err("%s could not find flashnode %u for host no %u\n",
3241 __func__
, idx
, ev
->u
.del_flashnode
.host_no
);
3246 err
= transport
->del_flashnode(fnode_sess
);
3247 put_device(&fnode_sess
->dev
);
3250 scsi_host_put(shost
);
3256 static int iscsi_login_flashnode(struct iscsi_transport
*transport
,
3257 struct iscsi_uevent
*ev
)
3259 struct Scsi_Host
*shost
;
3260 struct iscsi_bus_flash_session
*fnode_sess
;
3261 struct iscsi_bus_flash_conn
*fnode_conn
;
3266 if (!transport
->login_flashnode
) {
3268 goto exit_login_fnode
;
3271 shost
= scsi_host_lookup(ev
->u
.login_flashnode
.host_no
);
3273 pr_err("%s could not find host no %u\n",
3274 __func__
, ev
->u
.login_flashnode
.host_no
);
3279 idx
= ev
->u
.login_flashnode
.flashnode_idx
;
3280 fnode_sess
= iscsi_get_flashnode_by_index(shost
, idx
);
3282 pr_err("%s could not find flashnode %u for host no %u\n",
3283 __func__
, idx
, ev
->u
.login_flashnode
.host_no
);
3288 dev
= iscsi_find_flashnode_conn(fnode_sess
);
3294 fnode_conn
= iscsi_dev_to_flash_conn(dev
);
3295 err
= transport
->login_flashnode(fnode_sess
, fnode_conn
);
3299 put_device(&fnode_sess
->dev
);
3302 scsi_host_put(shost
);
3308 static int iscsi_logout_flashnode(struct iscsi_transport
*transport
,
3309 struct iscsi_uevent
*ev
)
3311 struct Scsi_Host
*shost
;
3312 struct iscsi_bus_flash_session
*fnode_sess
;
3313 struct iscsi_bus_flash_conn
*fnode_conn
;
3318 if (!transport
->logout_flashnode
) {
3320 goto exit_logout_fnode
;
3323 shost
= scsi_host_lookup(ev
->u
.logout_flashnode
.host_no
);
3325 pr_err("%s could not find host no %u\n",
3326 __func__
, ev
->u
.logout_flashnode
.host_no
);
3331 idx
= ev
->u
.logout_flashnode
.flashnode_idx
;
3332 fnode_sess
= iscsi_get_flashnode_by_index(shost
, idx
);
3334 pr_err("%s could not find flashnode %u for host no %u\n",
3335 __func__
, idx
, ev
->u
.logout_flashnode
.host_no
);
3340 dev
= iscsi_find_flashnode_conn(fnode_sess
);
3346 fnode_conn
= iscsi_dev_to_flash_conn(dev
);
3348 err
= transport
->logout_flashnode(fnode_sess
, fnode_conn
);
3352 put_device(&fnode_sess
->dev
);
3355 scsi_host_put(shost
);
3361 static int iscsi_logout_flashnode_sid(struct iscsi_transport
*transport
,
3362 struct iscsi_uevent
*ev
)
3364 struct Scsi_Host
*shost
;
3365 struct iscsi_cls_session
*session
;
3368 if (!transport
->logout_flashnode_sid
) {
3370 goto exit_logout_sid
;
3373 shost
= scsi_host_lookup(ev
->u
.logout_flashnode_sid
.host_no
);
3375 pr_err("%s could not find host no %u\n",
3376 __func__
, ev
->u
.logout_flashnode
.host_no
);
3381 session
= iscsi_session_lookup(ev
->u
.logout_flashnode_sid
.sid
);
3383 pr_err("%s could not find session id %u\n",
3384 __func__
, ev
->u
.logout_flashnode_sid
.sid
);
3389 err
= transport
->logout_flashnode_sid(session
);
3392 scsi_host_put(shost
);
3399 iscsi_get_host_stats(struct iscsi_transport
*transport
, struct nlmsghdr
*nlh
)
3401 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
3402 struct Scsi_Host
*shost
= NULL
;
3403 struct iscsi_internal
*priv
;
3404 struct sk_buff
*skbhost_stats
;
3405 struct nlmsghdr
*nlhhost_stats
;
3406 struct iscsi_uevent
*evhost_stats
;
3407 int host_stats_size
= 0;
3411 if (!transport
->get_host_stats
)
3414 priv
= iscsi_if_transport_lookup(transport
);
3418 host_stats_size
= sizeof(struct iscsi_offload_host_stats
);
3419 len
= nlmsg_total_size(sizeof(*ev
) + host_stats_size
);
3421 shost
= scsi_host_lookup(ev
->u
.get_host_stats
.host_no
);
3423 pr_err("%s: failed. Could not find host no %u\n",
3424 __func__
, ev
->u
.get_host_stats
.host_no
);
3431 skbhost_stats
= alloc_skb(len
, GFP_KERNEL
);
3432 if (!skbhost_stats
) {
3433 pr_err("cannot deliver host stats: OOM\n");
3435 goto exit_host_stats
;
3438 nlhhost_stats
= __nlmsg_put(skbhost_stats
, 0, 0, 0,
3439 (len
- sizeof(*nlhhost_stats
)), 0);
3440 evhost_stats
= nlmsg_data(nlhhost_stats
);
3441 memset(evhost_stats
, 0, sizeof(*evhost_stats
));
3442 evhost_stats
->transport_handle
= iscsi_handle(transport
);
3443 evhost_stats
->type
= nlh
->nlmsg_type
;
3444 evhost_stats
->u
.get_host_stats
.host_no
=
3445 ev
->u
.get_host_stats
.host_no
;
3446 buf
= (char *)evhost_stats
+ sizeof(*evhost_stats
);
3447 memset(buf
, 0, host_stats_size
);
3449 err
= transport
->get_host_stats(shost
, buf
, host_stats_size
);
3451 kfree_skb(skbhost_stats
);
3452 goto exit_host_stats
;
3455 actual_size
= nlmsg_total_size(sizeof(*ev
) + host_stats_size
);
3456 skb_trim(skbhost_stats
, NLMSG_ALIGN(actual_size
));
3457 nlhhost_stats
->nlmsg_len
= actual_size
;
3459 err
= iscsi_multicast_skb(skbhost_stats
, ISCSI_NL_GRP_ISCSID
,
3461 } while (err
< 0 && err
!= -ECONNREFUSED
);
3464 scsi_host_put(shost
);
3470 iscsi_if_recv_msg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, uint32_t *group
)
3473 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
3474 struct iscsi_transport
*transport
= NULL
;
3475 struct iscsi_internal
*priv
;
3476 struct iscsi_cls_session
*session
;
3477 struct iscsi_cls_conn
*conn
;
3478 struct iscsi_endpoint
*ep
= NULL
;
3480 if (nlh
->nlmsg_type
== ISCSI_UEVENT_PATH_UPDATE
)
3481 *group
= ISCSI_NL_GRP_UIP
;
3483 *group
= ISCSI_NL_GRP_ISCSID
;
3485 priv
= iscsi_if_transport_lookup(iscsi_ptr(ev
->transport_handle
));
3488 transport
= priv
->iscsi_transport
;
3490 if (!try_module_get(transport
->owner
))
3493 switch (nlh
->nlmsg_type
) {
3494 case ISCSI_UEVENT_CREATE_SESSION
:
3495 err
= iscsi_if_create_session(priv
, ep
, ev
,
3496 NETLINK_CB(skb
).portid
,
3497 ev
->u
.c_session
.initial_cmdsn
,
3498 ev
->u
.c_session
.cmds_max
,
3499 ev
->u
.c_session
.queue_depth
);
3501 case ISCSI_UEVENT_CREATE_BOUND_SESSION
:
3502 ep
= iscsi_lookup_endpoint(ev
->u
.c_bound_session
.ep_handle
);
3508 err
= iscsi_if_create_session(priv
, ep
, ev
,
3509 NETLINK_CB(skb
).portid
,
3510 ev
->u
.c_bound_session
.initial_cmdsn
,
3511 ev
->u
.c_bound_session
.cmds_max
,
3512 ev
->u
.c_bound_session
.queue_depth
);
3514 case ISCSI_UEVENT_DESTROY_SESSION
:
3515 session
= iscsi_session_lookup(ev
->u
.d_session
.sid
);
3517 transport
->destroy_session(session
);
3521 case ISCSI_UEVENT_UNBIND_SESSION
:
3522 session
= iscsi_session_lookup(ev
->u
.d_session
.sid
);
3524 scsi_queue_work(iscsi_session_to_shost(session
),
3525 &session
->unbind_work
);
3529 case ISCSI_UEVENT_CREATE_CONN
:
3530 err
= iscsi_if_create_conn(transport
, ev
);
3532 case ISCSI_UEVENT_DESTROY_CONN
:
3533 err
= iscsi_if_destroy_conn(transport
, ev
);
3535 case ISCSI_UEVENT_BIND_CONN
:
3536 session
= iscsi_session_lookup(ev
->u
.b_conn
.sid
);
3537 conn
= iscsi_conn_lookup(ev
->u
.b_conn
.sid
, ev
->u
.b_conn
.cid
);
3539 if (conn
&& conn
->ep
)
3540 iscsi_if_ep_disconnect(transport
, conn
->ep
->id
);
3542 if (!session
|| !conn
) {
3547 ev
->r
.retcode
= transport
->bind_conn(session
, conn
,
3548 ev
->u
.b_conn
.transport_eph
,
3549 ev
->u
.b_conn
.is_leading
);
3550 if (ev
->r
.retcode
|| !transport
->ep_connect
)
3553 ep
= iscsi_lookup_endpoint(ev
->u
.b_conn
.transport_eph
);
3557 mutex_lock(&conn
->ep_mutex
);
3559 mutex_unlock(&conn
->ep_mutex
);
3561 iscsi_cls_conn_printk(KERN_ERR
, conn
,
3562 "Could not set ep conn "
3565 case ISCSI_UEVENT_SET_PARAM
:
3566 err
= iscsi_set_param(transport
, ev
);
3568 case ISCSI_UEVENT_START_CONN
:
3569 conn
= iscsi_conn_lookup(ev
->u
.start_conn
.sid
, ev
->u
.start_conn
.cid
);
3571 ev
->r
.retcode
= transport
->start_conn(conn
);
3575 case ISCSI_UEVENT_STOP_CONN
:
3576 conn
= iscsi_conn_lookup(ev
->u
.stop_conn
.sid
, ev
->u
.stop_conn
.cid
);
3578 transport
->stop_conn(conn
, ev
->u
.stop_conn
.flag
);
3582 case ISCSI_UEVENT_SEND_PDU
:
3583 conn
= iscsi_conn_lookup(ev
->u
.send_pdu
.sid
, ev
->u
.send_pdu
.cid
);
3585 ev
->r
.retcode
= transport
->send_pdu(conn
,
3586 (struct iscsi_hdr
*)((char*)ev
+ sizeof(*ev
)),
3587 (char*)ev
+ sizeof(*ev
) + ev
->u
.send_pdu
.hdr_size
,
3588 ev
->u
.send_pdu
.data_size
);
3592 case ISCSI_UEVENT_GET_STATS
:
3593 err
= iscsi_if_get_stats(transport
, nlh
);
3595 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT
:
3596 case ISCSI_UEVENT_TRANSPORT_EP_POLL
:
3597 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT
:
3598 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST
:
3599 err
= iscsi_if_transport_ep(transport
, ev
, nlh
->nlmsg_type
);
3601 case ISCSI_UEVENT_TGT_DSCVR
:
3602 err
= iscsi_tgt_dscvr(transport
, ev
);
3604 case ISCSI_UEVENT_SET_HOST_PARAM
:
3605 err
= iscsi_set_host_param(transport
, ev
);
3607 case ISCSI_UEVENT_PATH_UPDATE
:
3608 err
= iscsi_set_path(transport
, ev
);
3610 case ISCSI_UEVENT_SET_IFACE_PARAMS
:
3611 err
= iscsi_set_iface_params(transport
, ev
,
3612 nlmsg_attrlen(nlh
, sizeof(*ev
)));
3614 case ISCSI_UEVENT_PING
:
3615 err
= iscsi_send_ping(transport
, ev
);
3617 case ISCSI_UEVENT_GET_CHAP
:
3618 err
= iscsi_get_chap(transport
, nlh
);
3620 case ISCSI_UEVENT_DELETE_CHAP
:
3621 err
= iscsi_delete_chap(transport
, ev
);
3623 case ISCSI_UEVENT_SET_FLASHNODE_PARAMS
:
3624 err
= iscsi_set_flashnode_param(transport
, ev
,
3628 case ISCSI_UEVENT_NEW_FLASHNODE
:
3629 err
= iscsi_new_flashnode(transport
, ev
,
3630 nlmsg_attrlen(nlh
, sizeof(*ev
)));
3632 case ISCSI_UEVENT_DEL_FLASHNODE
:
3633 err
= iscsi_del_flashnode(transport
, ev
);
3635 case ISCSI_UEVENT_LOGIN_FLASHNODE
:
3636 err
= iscsi_login_flashnode(transport
, ev
);
3638 case ISCSI_UEVENT_LOGOUT_FLASHNODE
:
3639 err
= iscsi_logout_flashnode(transport
, ev
);
3641 case ISCSI_UEVENT_LOGOUT_FLASHNODE_SID
:
3642 err
= iscsi_logout_flashnode_sid(transport
, ev
);
3644 case ISCSI_UEVENT_SET_CHAP
:
3645 err
= iscsi_set_chap(transport
, ev
,
3646 nlmsg_attrlen(nlh
, sizeof(*ev
)));
3648 case ISCSI_UEVENT_GET_HOST_STATS
:
3649 err
= iscsi_get_host_stats(transport
, nlh
);
3656 module_put(transport
->owner
);
3661 * Get message from skb. Each message is processed by iscsi_if_recv_msg.
3662 * Malformed skbs with wrong lengths or invalid creds are not processed.
3665 iscsi_if_rx(struct sk_buff
*skb
)
3667 mutex_lock(&rx_queue_mutex
);
3668 while (skb
->len
>= NLMSG_HDRLEN
) {
3671 struct nlmsghdr
*nlh
;
3672 struct iscsi_uevent
*ev
;
3675 nlh
= nlmsg_hdr(skb
);
3676 if (nlh
->nlmsg_len
< sizeof(*nlh
) + sizeof(*ev
) ||
3677 skb
->len
< nlh
->nlmsg_len
) {
3681 ev
= nlmsg_data(nlh
);
3682 rlen
= NLMSG_ALIGN(nlh
->nlmsg_len
);
3683 if (rlen
> skb
->len
)
3686 err
= iscsi_if_recv_msg(skb
, nlh
, &group
);
3688 ev
->type
= ISCSI_KEVENT_IF_ERROR
;
3693 * special case for GET_STATS:
3694 * on success - sending reply and stats from
3695 * inside of if_recv_msg(),
3696 * on error - fall through.
3698 if (ev
->type
== ISCSI_UEVENT_GET_STATS
&& !err
)
3700 if (ev
->type
== ISCSI_UEVENT_GET_CHAP
&& !err
)
3702 err
= iscsi_if_send_reply(group
, nlh
->nlmsg_seq
,
3703 nlh
->nlmsg_type
, 0, 0, ev
, sizeof(*ev
));
3704 } while (err
< 0 && err
!= -ECONNREFUSED
&& err
!= -ESRCH
);
3705 skb_pull(skb
, rlen
);
3707 mutex_unlock(&rx_queue_mutex
);
3710 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \
3711 struct device_attribute dev_attr_##_prefix##_##_name = \
3712 __ATTR(_name,_mode,_show,_store)
3715 * iSCSI connection attrs
3717 #define iscsi_conn_attr_show(param) \
3719 show_conn_param_##param(struct device *dev, \
3720 struct device_attribute *attr, char *buf) \
3722 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
3723 struct iscsi_transport *t = conn->transport; \
3724 return t->get_conn_param(conn, param, buf); \
3727 #define iscsi_conn_attr(field, param) \
3728 iscsi_conn_attr_show(param) \
3729 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param, \
3732 iscsi_conn_attr(max_recv_dlength
, ISCSI_PARAM_MAX_RECV_DLENGTH
);
3733 iscsi_conn_attr(max_xmit_dlength
, ISCSI_PARAM_MAX_XMIT_DLENGTH
);
3734 iscsi_conn_attr(header_digest
, ISCSI_PARAM_HDRDGST_EN
);
3735 iscsi_conn_attr(data_digest
, ISCSI_PARAM_DATADGST_EN
);
3736 iscsi_conn_attr(ifmarker
, ISCSI_PARAM_IFMARKER_EN
);
3737 iscsi_conn_attr(ofmarker
, ISCSI_PARAM_OFMARKER_EN
);
3738 iscsi_conn_attr(persistent_port
, ISCSI_PARAM_PERSISTENT_PORT
);
3739 iscsi_conn_attr(exp_statsn
, ISCSI_PARAM_EXP_STATSN
);
3740 iscsi_conn_attr(persistent_address
, ISCSI_PARAM_PERSISTENT_ADDRESS
);
3741 iscsi_conn_attr(ping_tmo
, ISCSI_PARAM_PING_TMO
);
3742 iscsi_conn_attr(recv_tmo
, ISCSI_PARAM_RECV_TMO
);
3743 iscsi_conn_attr(local_port
, ISCSI_PARAM_LOCAL_PORT
);
3744 iscsi_conn_attr(statsn
, ISCSI_PARAM_STATSN
);
3745 iscsi_conn_attr(keepalive_tmo
, ISCSI_PARAM_KEEPALIVE_TMO
);
3746 iscsi_conn_attr(max_segment_size
, ISCSI_PARAM_MAX_SEGMENT_SIZE
);
3747 iscsi_conn_attr(tcp_timestamp_stat
, ISCSI_PARAM_TCP_TIMESTAMP_STAT
);
3748 iscsi_conn_attr(tcp_wsf_disable
, ISCSI_PARAM_TCP_WSF_DISABLE
);
3749 iscsi_conn_attr(tcp_nagle_disable
, ISCSI_PARAM_TCP_NAGLE_DISABLE
);
3750 iscsi_conn_attr(tcp_timer_scale
, ISCSI_PARAM_TCP_TIMER_SCALE
);
3751 iscsi_conn_attr(tcp_timestamp_enable
, ISCSI_PARAM_TCP_TIMESTAMP_EN
);
3752 iscsi_conn_attr(fragment_disable
, ISCSI_PARAM_IP_FRAGMENT_DISABLE
);
3753 iscsi_conn_attr(ipv4_tos
, ISCSI_PARAM_IPV4_TOS
);
3754 iscsi_conn_attr(ipv6_traffic_class
, ISCSI_PARAM_IPV6_TC
);
3755 iscsi_conn_attr(ipv6_flow_label
, ISCSI_PARAM_IPV6_FLOW_LABEL
);
3756 iscsi_conn_attr(is_fw_assigned_ipv6
, ISCSI_PARAM_IS_FW_ASSIGNED_IPV6
);
3757 iscsi_conn_attr(tcp_xmit_wsf
, ISCSI_PARAM_TCP_XMIT_WSF
);
3758 iscsi_conn_attr(tcp_recv_wsf
, ISCSI_PARAM_TCP_RECV_WSF
);
3759 iscsi_conn_attr(local_ipaddr
, ISCSI_PARAM_LOCAL_IPADDR
);
3762 #define iscsi_conn_ep_attr_show(param) \
3763 static ssize_t show_conn_ep_param_##param(struct device *dev, \
3764 struct device_attribute *attr,\
3767 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
3768 struct iscsi_transport *t = conn->transport; \
3769 struct iscsi_endpoint *ep; \
3773 * Need to make sure ep_disconnect does not free the LLD's \
3774 * interconnect resources while we are trying to read them. \
3776 mutex_lock(&conn->ep_mutex); \
3778 if (!ep && t->ep_connect) { \
3779 mutex_unlock(&conn->ep_mutex); \
3784 rc = t->get_ep_param(ep, param, buf); \
3786 rc = t->get_conn_param(conn, param, buf); \
3787 mutex_unlock(&conn->ep_mutex); \
3791 #define iscsi_conn_ep_attr(field, param) \
3792 iscsi_conn_ep_attr_show(param) \
3793 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, \
3794 show_conn_ep_param_##param, NULL);
3796 iscsi_conn_ep_attr(address
, ISCSI_PARAM_CONN_ADDRESS
);
3797 iscsi_conn_ep_attr(port
, ISCSI_PARAM_CONN_PORT
);
3799 static struct attribute
*iscsi_conn_attrs
[] = {
3800 &dev_attr_conn_max_recv_dlength
.attr
,
3801 &dev_attr_conn_max_xmit_dlength
.attr
,
3802 &dev_attr_conn_header_digest
.attr
,
3803 &dev_attr_conn_data_digest
.attr
,
3804 &dev_attr_conn_ifmarker
.attr
,
3805 &dev_attr_conn_ofmarker
.attr
,
3806 &dev_attr_conn_address
.attr
,
3807 &dev_attr_conn_port
.attr
,
3808 &dev_attr_conn_exp_statsn
.attr
,
3809 &dev_attr_conn_persistent_address
.attr
,
3810 &dev_attr_conn_persistent_port
.attr
,
3811 &dev_attr_conn_ping_tmo
.attr
,
3812 &dev_attr_conn_recv_tmo
.attr
,
3813 &dev_attr_conn_local_port
.attr
,
3814 &dev_attr_conn_statsn
.attr
,
3815 &dev_attr_conn_keepalive_tmo
.attr
,
3816 &dev_attr_conn_max_segment_size
.attr
,
3817 &dev_attr_conn_tcp_timestamp_stat
.attr
,
3818 &dev_attr_conn_tcp_wsf_disable
.attr
,
3819 &dev_attr_conn_tcp_nagle_disable
.attr
,
3820 &dev_attr_conn_tcp_timer_scale
.attr
,
3821 &dev_attr_conn_tcp_timestamp_enable
.attr
,
3822 &dev_attr_conn_fragment_disable
.attr
,
3823 &dev_attr_conn_ipv4_tos
.attr
,
3824 &dev_attr_conn_ipv6_traffic_class
.attr
,
3825 &dev_attr_conn_ipv6_flow_label
.attr
,
3826 &dev_attr_conn_is_fw_assigned_ipv6
.attr
,
3827 &dev_attr_conn_tcp_xmit_wsf
.attr
,
3828 &dev_attr_conn_tcp_recv_wsf
.attr
,
3829 &dev_attr_conn_local_ipaddr
.attr
,
3833 static umode_t
iscsi_conn_attr_is_visible(struct kobject
*kobj
,
3834 struct attribute
*attr
, int i
)
3836 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
3837 struct iscsi_cls_conn
*conn
= transport_class_to_conn(cdev
);
3838 struct iscsi_transport
*t
= conn
->transport
;
3841 if (attr
== &dev_attr_conn_max_recv_dlength
.attr
)
3842 param
= ISCSI_PARAM_MAX_RECV_DLENGTH
;
3843 else if (attr
== &dev_attr_conn_max_xmit_dlength
.attr
)
3844 param
= ISCSI_PARAM_MAX_XMIT_DLENGTH
;
3845 else if (attr
== &dev_attr_conn_header_digest
.attr
)
3846 param
= ISCSI_PARAM_HDRDGST_EN
;
3847 else if (attr
== &dev_attr_conn_data_digest
.attr
)
3848 param
= ISCSI_PARAM_DATADGST_EN
;
3849 else if (attr
== &dev_attr_conn_ifmarker
.attr
)
3850 param
= ISCSI_PARAM_IFMARKER_EN
;
3851 else if (attr
== &dev_attr_conn_ofmarker
.attr
)
3852 param
= ISCSI_PARAM_OFMARKER_EN
;
3853 else if (attr
== &dev_attr_conn_address
.attr
)
3854 param
= ISCSI_PARAM_CONN_ADDRESS
;
3855 else if (attr
== &dev_attr_conn_port
.attr
)
3856 param
= ISCSI_PARAM_CONN_PORT
;
3857 else if (attr
== &dev_attr_conn_exp_statsn
.attr
)
3858 param
= ISCSI_PARAM_EXP_STATSN
;
3859 else if (attr
== &dev_attr_conn_persistent_address
.attr
)
3860 param
= ISCSI_PARAM_PERSISTENT_ADDRESS
;
3861 else if (attr
== &dev_attr_conn_persistent_port
.attr
)
3862 param
= ISCSI_PARAM_PERSISTENT_PORT
;
3863 else if (attr
== &dev_attr_conn_ping_tmo
.attr
)
3864 param
= ISCSI_PARAM_PING_TMO
;
3865 else if (attr
== &dev_attr_conn_recv_tmo
.attr
)
3866 param
= ISCSI_PARAM_RECV_TMO
;
3867 else if (attr
== &dev_attr_conn_local_port
.attr
)
3868 param
= ISCSI_PARAM_LOCAL_PORT
;
3869 else if (attr
== &dev_attr_conn_statsn
.attr
)
3870 param
= ISCSI_PARAM_STATSN
;
3871 else if (attr
== &dev_attr_conn_keepalive_tmo
.attr
)
3872 param
= ISCSI_PARAM_KEEPALIVE_TMO
;
3873 else if (attr
== &dev_attr_conn_max_segment_size
.attr
)
3874 param
= ISCSI_PARAM_MAX_SEGMENT_SIZE
;
3875 else if (attr
== &dev_attr_conn_tcp_timestamp_stat
.attr
)
3876 param
= ISCSI_PARAM_TCP_TIMESTAMP_STAT
;
3877 else if (attr
== &dev_attr_conn_tcp_wsf_disable
.attr
)
3878 param
= ISCSI_PARAM_TCP_WSF_DISABLE
;
3879 else if (attr
== &dev_attr_conn_tcp_nagle_disable
.attr
)
3880 param
= ISCSI_PARAM_TCP_NAGLE_DISABLE
;
3881 else if (attr
== &dev_attr_conn_tcp_timer_scale
.attr
)
3882 param
= ISCSI_PARAM_TCP_TIMER_SCALE
;
3883 else if (attr
== &dev_attr_conn_tcp_timestamp_enable
.attr
)
3884 param
= ISCSI_PARAM_TCP_TIMESTAMP_EN
;
3885 else if (attr
== &dev_attr_conn_fragment_disable
.attr
)
3886 param
= ISCSI_PARAM_IP_FRAGMENT_DISABLE
;
3887 else if (attr
== &dev_attr_conn_ipv4_tos
.attr
)
3888 param
= ISCSI_PARAM_IPV4_TOS
;
3889 else if (attr
== &dev_attr_conn_ipv6_traffic_class
.attr
)
3890 param
= ISCSI_PARAM_IPV6_TC
;
3891 else if (attr
== &dev_attr_conn_ipv6_flow_label
.attr
)
3892 param
= ISCSI_PARAM_IPV6_FLOW_LABEL
;
3893 else if (attr
== &dev_attr_conn_is_fw_assigned_ipv6
.attr
)
3894 param
= ISCSI_PARAM_IS_FW_ASSIGNED_IPV6
;
3895 else if (attr
== &dev_attr_conn_tcp_xmit_wsf
.attr
)
3896 param
= ISCSI_PARAM_TCP_XMIT_WSF
;
3897 else if (attr
== &dev_attr_conn_tcp_recv_wsf
.attr
)
3898 param
= ISCSI_PARAM_TCP_RECV_WSF
;
3899 else if (attr
== &dev_attr_conn_local_ipaddr
.attr
)
3900 param
= ISCSI_PARAM_LOCAL_IPADDR
;
3902 WARN_ONCE(1, "Invalid conn attr");
3906 return t
->attr_is_visible(ISCSI_PARAM
, param
);
3909 static struct attribute_group iscsi_conn_group
= {
3910 .attrs
= iscsi_conn_attrs
,
3911 .is_visible
= iscsi_conn_attr_is_visible
,
3915 * iSCSI session attrs
3917 #define iscsi_session_attr_show(param, perm) \
3919 show_session_param_##param(struct device *dev, \
3920 struct device_attribute *attr, char *buf) \
3922 struct iscsi_cls_session *session = \
3923 iscsi_dev_to_session(dev->parent); \
3924 struct iscsi_transport *t = session->transport; \
3926 if (perm && !capable(CAP_SYS_ADMIN)) \
3928 return t->get_session_param(session, param, buf); \
3931 #define iscsi_session_attr(field, param, perm) \
3932 iscsi_session_attr_show(param, perm) \
3933 static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
3935 iscsi_session_attr(targetname
, ISCSI_PARAM_TARGET_NAME
, 0);
3936 iscsi_session_attr(initial_r2t
, ISCSI_PARAM_INITIAL_R2T_EN
, 0);
3937 iscsi_session_attr(max_outstanding_r2t
, ISCSI_PARAM_MAX_R2T
, 0);
3938 iscsi_session_attr(immediate_data
, ISCSI_PARAM_IMM_DATA_EN
, 0);
3939 iscsi_session_attr(first_burst_len
, ISCSI_PARAM_FIRST_BURST
, 0);
3940 iscsi_session_attr(max_burst_len
, ISCSI_PARAM_MAX_BURST
, 0);
3941 iscsi_session_attr(data_pdu_in_order
, ISCSI_PARAM_PDU_INORDER_EN
, 0);
3942 iscsi_session_attr(data_seq_in_order
, ISCSI_PARAM_DATASEQ_INORDER_EN
, 0);
3943 iscsi_session_attr(erl
, ISCSI_PARAM_ERL
, 0);
3944 iscsi_session_attr(tpgt
, ISCSI_PARAM_TPGT
, 0);
3945 iscsi_session_attr(username
, ISCSI_PARAM_USERNAME
, 1);
3946 iscsi_session_attr(username_in
, ISCSI_PARAM_USERNAME_IN
, 1);
3947 iscsi_session_attr(password
, ISCSI_PARAM_PASSWORD
, 1);
3948 iscsi_session_attr(password_in
, ISCSI_PARAM_PASSWORD_IN
, 1);
3949 iscsi_session_attr(chap_out_idx
, ISCSI_PARAM_CHAP_OUT_IDX
, 1);
3950 iscsi_session_attr(chap_in_idx
, ISCSI_PARAM_CHAP_IN_IDX
, 1);
3951 iscsi_session_attr(fast_abort
, ISCSI_PARAM_FAST_ABORT
, 0);
3952 iscsi_session_attr(abort_tmo
, ISCSI_PARAM_ABORT_TMO
, 0);
3953 iscsi_session_attr(lu_reset_tmo
, ISCSI_PARAM_LU_RESET_TMO
, 0);
3954 iscsi_session_attr(tgt_reset_tmo
, ISCSI_PARAM_TGT_RESET_TMO
, 0);
3955 iscsi_session_attr(ifacename
, ISCSI_PARAM_IFACE_NAME
, 0);
3956 iscsi_session_attr(initiatorname
, ISCSI_PARAM_INITIATOR_NAME
, 0);
3957 iscsi_session_attr(targetalias
, ISCSI_PARAM_TARGET_ALIAS
, 0);
3958 iscsi_session_attr(boot_root
, ISCSI_PARAM_BOOT_ROOT
, 0);
3959 iscsi_session_attr(boot_nic
, ISCSI_PARAM_BOOT_NIC
, 0);
3960 iscsi_session_attr(boot_target
, ISCSI_PARAM_BOOT_TARGET
, 0);
3961 iscsi_session_attr(auto_snd_tgt_disable
, ISCSI_PARAM_AUTO_SND_TGT_DISABLE
, 0);
3962 iscsi_session_attr(discovery_session
, ISCSI_PARAM_DISCOVERY_SESS
, 0);
3963 iscsi_session_attr(portal_type
, ISCSI_PARAM_PORTAL_TYPE
, 0);
3964 iscsi_session_attr(chap_auth
, ISCSI_PARAM_CHAP_AUTH_EN
, 0);
3965 iscsi_session_attr(discovery_logout
, ISCSI_PARAM_DISCOVERY_LOGOUT_EN
, 0);
3966 iscsi_session_attr(bidi_chap
, ISCSI_PARAM_BIDI_CHAP_EN
, 0);
3967 iscsi_session_attr(discovery_auth_optional
,
3968 ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL
, 0);
3969 iscsi_session_attr(def_time2wait
, ISCSI_PARAM_DEF_TIME2WAIT
, 0);
3970 iscsi_session_attr(def_time2retain
, ISCSI_PARAM_DEF_TIME2RETAIN
, 0);
3971 iscsi_session_attr(isid
, ISCSI_PARAM_ISID
, 0);
3972 iscsi_session_attr(tsid
, ISCSI_PARAM_TSID
, 0);
3973 iscsi_session_attr(def_taskmgmt_tmo
, ISCSI_PARAM_DEF_TASKMGMT_TMO
, 0);
3974 iscsi_session_attr(discovery_parent_idx
, ISCSI_PARAM_DISCOVERY_PARENT_IDX
, 0);
3975 iscsi_session_attr(discovery_parent_type
, ISCSI_PARAM_DISCOVERY_PARENT_TYPE
, 0);
3978 show_priv_session_state(struct device
*dev
, struct device_attribute
*attr
,
3981 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
->parent
);
3982 return sprintf(buf
, "%s\n", iscsi_session_state_name(session
->state
));
3984 static ISCSI_CLASS_ATTR(priv_sess
, state
, S_IRUGO
, show_priv_session_state
,
3987 show_priv_session_creator(struct device
*dev
, struct device_attribute
*attr
,
3990 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
->parent
);
3991 return sprintf(buf
, "%d\n", session
->creator
);
3993 static ISCSI_CLASS_ATTR(priv_sess
, creator
, S_IRUGO
, show_priv_session_creator
,
3996 show_priv_session_target_id(struct device
*dev
, struct device_attribute
*attr
,
3999 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
->parent
);
4000 return sprintf(buf
, "%d\n", session
->target_id
);
4002 static ISCSI_CLASS_ATTR(priv_sess
, target_id
, S_IRUGO
,
4003 show_priv_session_target_id
, NULL
);
4005 #define iscsi_priv_session_attr_show(field, format) \
4007 show_priv_session_##field(struct device *dev, \
4008 struct device_attribute *attr, char *buf) \
4010 struct iscsi_cls_session *session = \
4011 iscsi_dev_to_session(dev->parent); \
4012 if (session->field == -1) \
4013 return sprintf(buf, "off\n"); \
4014 return sprintf(buf, format"\n", session->field); \
4017 #define iscsi_priv_session_attr_store(field) \
4019 store_priv_session_##field(struct device *dev, \
4020 struct device_attribute *attr, \
4021 const char *buf, size_t count) \
4025 struct iscsi_cls_session *session = \
4026 iscsi_dev_to_session(dev->parent); \
4027 if ((session->state == ISCSI_SESSION_FREE) || \
4028 (session->state == ISCSI_SESSION_FAILED)) \
4030 if (strncmp(buf, "off", 3) == 0) { \
4031 session->field = -1; \
4032 session->field##_sysfs_override = true; \
4034 val = simple_strtoul(buf, &cp, 0); \
4035 if (*cp != '\0' && *cp != '\n') \
4037 session->field = val; \
4038 session->field##_sysfs_override = true; \
4043 #define iscsi_priv_session_rw_attr(field, format) \
4044 iscsi_priv_session_attr_show(field, format) \
4045 iscsi_priv_session_attr_store(field) \
4046 static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO | S_IWUSR, \
4047 show_priv_session_##field, \
4048 store_priv_session_##field)
4050 iscsi_priv_session_rw_attr(recovery_tmo
, "%d");
4052 static struct attribute
*iscsi_session_attrs
[] = {
4053 &dev_attr_sess_initial_r2t
.attr
,
4054 &dev_attr_sess_max_outstanding_r2t
.attr
,
4055 &dev_attr_sess_immediate_data
.attr
,
4056 &dev_attr_sess_first_burst_len
.attr
,
4057 &dev_attr_sess_max_burst_len
.attr
,
4058 &dev_attr_sess_data_pdu_in_order
.attr
,
4059 &dev_attr_sess_data_seq_in_order
.attr
,
4060 &dev_attr_sess_erl
.attr
,
4061 &dev_attr_sess_targetname
.attr
,
4062 &dev_attr_sess_tpgt
.attr
,
4063 &dev_attr_sess_password
.attr
,
4064 &dev_attr_sess_password_in
.attr
,
4065 &dev_attr_sess_username
.attr
,
4066 &dev_attr_sess_username_in
.attr
,
4067 &dev_attr_sess_fast_abort
.attr
,
4068 &dev_attr_sess_abort_tmo
.attr
,
4069 &dev_attr_sess_lu_reset_tmo
.attr
,
4070 &dev_attr_sess_tgt_reset_tmo
.attr
,
4071 &dev_attr_sess_ifacename
.attr
,
4072 &dev_attr_sess_initiatorname
.attr
,
4073 &dev_attr_sess_targetalias
.attr
,
4074 &dev_attr_sess_boot_root
.attr
,
4075 &dev_attr_sess_boot_nic
.attr
,
4076 &dev_attr_sess_boot_target
.attr
,
4077 &dev_attr_priv_sess_recovery_tmo
.attr
,
4078 &dev_attr_priv_sess_state
.attr
,
4079 &dev_attr_priv_sess_creator
.attr
,
4080 &dev_attr_sess_chap_out_idx
.attr
,
4081 &dev_attr_sess_chap_in_idx
.attr
,
4082 &dev_attr_priv_sess_target_id
.attr
,
4083 &dev_attr_sess_auto_snd_tgt_disable
.attr
,
4084 &dev_attr_sess_discovery_session
.attr
,
4085 &dev_attr_sess_portal_type
.attr
,
4086 &dev_attr_sess_chap_auth
.attr
,
4087 &dev_attr_sess_discovery_logout
.attr
,
4088 &dev_attr_sess_bidi_chap
.attr
,
4089 &dev_attr_sess_discovery_auth_optional
.attr
,
4090 &dev_attr_sess_def_time2wait
.attr
,
4091 &dev_attr_sess_def_time2retain
.attr
,
4092 &dev_attr_sess_isid
.attr
,
4093 &dev_attr_sess_tsid
.attr
,
4094 &dev_attr_sess_def_taskmgmt_tmo
.attr
,
4095 &dev_attr_sess_discovery_parent_idx
.attr
,
4096 &dev_attr_sess_discovery_parent_type
.attr
,
4100 static umode_t
iscsi_session_attr_is_visible(struct kobject
*kobj
,
4101 struct attribute
*attr
, int i
)
4103 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4104 struct iscsi_cls_session
*session
= transport_class_to_session(cdev
);
4105 struct iscsi_transport
*t
= session
->transport
;
4108 if (attr
== &dev_attr_sess_initial_r2t
.attr
)
4109 param
= ISCSI_PARAM_INITIAL_R2T_EN
;
4110 else if (attr
== &dev_attr_sess_max_outstanding_r2t
.attr
)
4111 param
= ISCSI_PARAM_MAX_R2T
;
4112 else if (attr
== &dev_attr_sess_immediate_data
.attr
)
4113 param
= ISCSI_PARAM_IMM_DATA_EN
;
4114 else if (attr
== &dev_attr_sess_first_burst_len
.attr
)
4115 param
= ISCSI_PARAM_FIRST_BURST
;
4116 else if (attr
== &dev_attr_sess_max_burst_len
.attr
)
4117 param
= ISCSI_PARAM_MAX_BURST
;
4118 else if (attr
== &dev_attr_sess_data_pdu_in_order
.attr
)
4119 param
= ISCSI_PARAM_PDU_INORDER_EN
;
4120 else if (attr
== &dev_attr_sess_data_seq_in_order
.attr
)
4121 param
= ISCSI_PARAM_DATASEQ_INORDER_EN
;
4122 else if (attr
== &dev_attr_sess_erl
.attr
)
4123 param
= ISCSI_PARAM_ERL
;
4124 else if (attr
== &dev_attr_sess_targetname
.attr
)
4125 param
= ISCSI_PARAM_TARGET_NAME
;
4126 else if (attr
== &dev_attr_sess_tpgt
.attr
)
4127 param
= ISCSI_PARAM_TPGT
;
4128 else if (attr
== &dev_attr_sess_chap_in_idx
.attr
)
4129 param
= ISCSI_PARAM_CHAP_IN_IDX
;
4130 else if (attr
== &dev_attr_sess_chap_out_idx
.attr
)
4131 param
= ISCSI_PARAM_CHAP_OUT_IDX
;
4132 else if (attr
== &dev_attr_sess_password
.attr
)
4133 param
= ISCSI_PARAM_USERNAME
;
4134 else if (attr
== &dev_attr_sess_password_in
.attr
)
4135 param
= ISCSI_PARAM_USERNAME_IN
;
4136 else if (attr
== &dev_attr_sess_username
.attr
)
4137 param
= ISCSI_PARAM_PASSWORD
;
4138 else if (attr
== &dev_attr_sess_username_in
.attr
)
4139 param
= ISCSI_PARAM_PASSWORD_IN
;
4140 else if (attr
== &dev_attr_sess_fast_abort
.attr
)
4141 param
= ISCSI_PARAM_FAST_ABORT
;
4142 else if (attr
== &dev_attr_sess_abort_tmo
.attr
)
4143 param
= ISCSI_PARAM_ABORT_TMO
;
4144 else if (attr
== &dev_attr_sess_lu_reset_tmo
.attr
)
4145 param
= ISCSI_PARAM_LU_RESET_TMO
;
4146 else if (attr
== &dev_attr_sess_tgt_reset_tmo
.attr
)
4147 param
= ISCSI_PARAM_TGT_RESET_TMO
;
4148 else if (attr
== &dev_attr_sess_ifacename
.attr
)
4149 param
= ISCSI_PARAM_IFACE_NAME
;
4150 else if (attr
== &dev_attr_sess_initiatorname
.attr
)
4151 param
= ISCSI_PARAM_INITIATOR_NAME
;
4152 else if (attr
== &dev_attr_sess_targetalias
.attr
)
4153 param
= ISCSI_PARAM_TARGET_ALIAS
;
4154 else if (attr
== &dev_attr_sess_boot_root
.attr
)
4155 param
= ISCSI_PARAM_BOOT_ROOT
;
4156 else if (attr
== &dev_attr_sess_boot_nic
.attr
)
4157 param
= ISCSI_PARAM_BOOT_NIC
;
4158 else if (attr
== &dev_attr_sess_boot_target
.attr
)
4159 param
= ISCSI_PARAM_BOOT_TARGET
;
4160 else if (attr
== &dev_attr_sess_auto_snd_tgt_disable
.attr
)
4161 param
= ISCSI_PARAM_AUTO_SND_TGT_DISABLE
;
4162 else if (attr
== &dev_attr_sess_discovery_session
.attr
)
4163 param
= ISCSI_PARAM_DISCOVERY_SESS
;
4164 else if (attr
== &dev_attr_sess_portal_type
.attr
)
4165 param
= ISCSI_PARAM_PORTAL_TYPE
;
4166 else if (attr
== &dev_attr_sess_chap_auth
.attr
)
4167 param
= ISCSI_PARAM_CHAP_AUTH_EN
;
4168 else if (attr
== &dev_attr_sess_discovery_logout
.attr
)
4169 param
= ISCSI_PARAM_DISCOVERY_LOGOUT_EN
;
4170 else if (attr
== &dev_attr_sess_bidi_chap
.attr
)
4171 param
= ISCSI_PARAM_BIDI_CHAP_EN
;
4172 else if (attr
== &dev_attr_sess_discovery_auth_optional
.attr
)
4173 param
= ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL
;
4174 else if (attr
== &dev_attr_sess_def_time2wait
.attr
)
4175 param
= ISCSI_PARAM_DEF_TIME2WAIT
;
4176 else if (attr
== &dev_attr_sess_def_time2retain
.attr
)
4177 param
= ISCSI_PARAM_DEF_TIME2RETAIN
;
4178 else if (attr
== &dev_attr_sess_isid
.attr
)
4179 param
= ISCSI_PARAM_ISID
;
4180 else if (attr
== &dev_attr_sess_tsid
.attr
)
4181 param
= ISCSI_PARAM_TSID
;
4182 else if (attr
== &dev_attr_sess_def_taskmgmt_tmo
.attr
)
4183 param
= ISCSI_PARAM_DEF_TASKMGMT_TMO
;
4184 else if (attr
== &dev_attr_sess_discovery_parent_idx
.attr
)
4185 param
= ISCSI_PARAM_DISCOVERY_PARENT_IDX
;
4186 else if (attr
== &dev_attr_sess_discovery_parent_type
.attr
)
4187 param
= ISCSI_PARAM_DISCOVERY_PARENT_TYPE
;
4188 else if (attr
== &dev_attr_priv_sess_recovery_tmo
.attr
)
4189 return S_IRUGO
| S_IWUSR
;
4190 else if (attr
== &dev_attr_priv_sess_state
.attr
)
4192 else if (attr
== &dev_attr_priv_sess_creator
.attr
)
4194 else if (attr
== &dev_attr_priv_sess_target_id
.attr
)
4197 WARN_ONCE(1, "Invalid session attr");
4201 return t
->attr_is_visible(ISCSI_PARAM
, param
);
4204 static struct attribute_group iscsi_session_group
= {
4205 .attrs
= iscsi_session_attrs
,
4206 .is_visible
= iscsi_session_attr_is_visible
,
4212 #define iscsi_host_attr_show(param) \
4214 show_host_param_##param(struct device *dev, \
4215 struct device_attribute *attr, char *buf) \
4217 struct Scsi_Host *shost = transport_class_to_shost(dev); \
4218 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
4219 return priv->iscsi_transport->get_host_param(shost, param, buf); \
4222 #define iscsi_host_attr(field, param) \
4223 iscsi_host_attr_show(param) \
4224 static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param, \
4227 iscsi_host_attr(netdev
, ISCSI_HOST_PARAM_NETDEV_NAME
);
4228 iscsi_host_attr(hwaddress
, ISCSI_HOST_PARAM_HWADDRESS
);
4229 iscsi_host_attr(ipaddress
, ISCSI_HOST_PARAM_IPADDRESS
);
4230 iscsi_host_attr(initiatorname
, ISCSI_HOST_PARAM_INITIATOR_NAME
);
4231 iscsi_host_attr(port_state
, ISCSI_HOST_PARAM_PORT_STATE
);
4232 iscsi_host_attr(port_speed
, ISCSI_HOST_PARAM_PORT_SPEED
);
4234 static struct attribute
*iscsi_host_attrs
[] = {
4235 &dev_attr_host_netdev
.attr
,
4236 &dev_attr_host_hwaddress
.attr
,
4237 &dev_attr_host_ipaddress
.attr
,
4238 &dev_attr_host_initiatorname
.attr
,
4239 &dev_attr_host_port_state
.attr
,
4240 &dev_attr_host_port_speed
.attr
,
4244 static umode_t
iscsi_host_attr_is_visible(struct kobject
*kobj
,
4245 struct attribute
*attr
, int i
)
4247 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4248 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
4249 struct iscsi_internal
*priv
= to_iscsi_internal(shost
->transportt
);
4252 if (attr
== &dev_attr_host_netdev
.attr
)
4253 param
= ISCSI_HOST_PARAM_NETDEV_NAME
;
4254 else if (attr
== &dev_attr_host_hwaddress
.attr
)
4255 param
= ISCSI_HOST_PARAM_HWADDRESS
;
4256 else if (attr
== &dev_attr_host_ipaddress
.attr
)
4257 param
= ISCSI_HOST_PARAM_IPADDRESS
;
4258 else if (attr
== &dev_attr_host_initiatorname
.attr
)
4259 param
= ISCSI_HOST_PARAM_INITIATOR_NAME
;
4260 else if (attr
== &dev_attr_host_port_state
.attr
)
4261 param
= ISCSI_HOST_PARAM_PORT_STATE
;
4262 else if (attr
== &dev_attr_host_port_speed
.attr
)
4263 param
= ISCSI_HOST_PARAM_PORT_SPEED
;
4265 WARN_ONCE(1, "Invalid host attr");
4269 return priv
->iscsi_transport
->attr_is_visible(ISCSI_HOST_PARAM
, param
);
4272 static struct attribute_group iscsi_host_group
= {
4273 .attrs
= iscsi_host_attrs
,
4274 .is_visible
= iscsi_host_attr_is_visible
,
4277 /* convert iscsi_port_speed values to ascii string name */
4278 static const struct {
4279 enum iscsi_port_speed value
;
4281 } iscsi_port_speed_names
[] = {
4282 {ISCSI_PORT_SPEED_UNKNOWN
, "Unknown" },
4283 {ISCSI_PORT_SPEED_10MBPS
, "10 Mbps" },
4284 {ISCSI_PORT_SPEED_100MBPS
, "100 Mbps" },
4285 {ISCSI_PORT_SPEED_1GBPS
, "1 Gbps" },
4286 {ISCSI_PORT_SPEED_10GBPS
, "10 Gbps" },
4287 {ISCSI_PORT_SPEED_25GBPS
, "25 Gbps" },
4288 {ISCSI_PORT_SPEED_40GBPS
, "40 Gbps" },
4291 char *iscsi_get_port_speed_name(struct Scsi_Host
*shost
)
4294 char *speed
= "Unknown!";
4295 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
4296 uint32_t port_speed
= ihost
->port_speed
;
4298 for (i
= 0; i
< ARRAY_SIZE(iscsi_port_speed_names
); i
++) {
4299 if (iscsi_port_speed_names
[i
].value
& port_speed
) {
4300 speed
= iscsi_port_speed_names
[i
].name
;
4306 EXPORT_SYMBOL_GPL(iscsi_get_port_speed_name
);
4308 /* convert iscsi_port_state values to ascii string name */
4309 static const struct {
4310 enum iscsi_port_state value
;
4312 } iscsi_port_state_names
[] = {
4313 {ISCSI_PORT_STATE_DOWN
, "LINK DOWN" },
4314 {ISCSI_PORT_STATE_UP
, "LINK UP" },
4317 char *iscsi_get_port_state_name(struct Scsi_Host
*shost
)
4320 char *state
= "Unknown!";
4321 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
4322 uint32_t port_state
= ihost
->port_state
;
4324 for (i
= 0; i
< ARRAY_SIZE(iscsi_port_state_names
); i
++) {
4325 if (iscsi_port_state_names
[i
].value
& port_state
) {
4326 state
= iscsi_port_state_names
[i
].name
;
4332 EXPORT_SYMBOL_GPL(iscsi_get_port_state_name
);
4334 static int iscsi_session_match(struct attribute_container
*cont
,
4337 struct iscsi_cls_session
*session
;
4338 struct Scsi_Host
*shost
;
4339 struct iscsi_internal
*priv
;
4341 if (!iscsi_is_session_dev(dev
))
4344 session
= iscsi_dev_to_session(dev
);
4345 shost
= iscsi_session_to_shost(session
);
4346 if (!shost
->transportt
)
4349 priv
= to_iscsi_internal(shost
->transportt
);
4350 if (priv
->session_cont
.ac
.class != &iscsi_session_class
.class)
4353 return &priv
->session_cont
.ac
== cont
;
4356 static int iscsi_conn_match(struct attribute_container
*cont
,
4359 struct iscsi_cls_session
*session
;
4360 struct iscsi_cls_conn
*conn
;
4361 struct Scsi_Host
*shost
;
4362 struct iscsi_internal
*priv
;
4364 if (!iscsi_is_conn_dev(dev
))
4367 conn
= iscsi_dev_to_conn(dev
);
4368 session
= iscsi_dev_to_session(conn
->dev
.parent
);
4369 shost
= iscsi_session_to_shost(session
);
4371 if (!shost
->transportt
)
4374 priv
= to_iscsi_internal(shost
->transportt
);
4375 if (priv
->conn_cont
.ac
.class != &iscsi_connection_class
.class)
4378 return &priv
->conn_cont
.ac
== cont
;
4381 static int iscsi_host_match(struct attribute_container
*cont
,
4384 struct Scsi_Host
*shost
;
4385 struct iscsi_internal
*priv
;
4387 if (!scsi_is_host_device(dev
))
4390 shost
= dev_to_shost(dev
);
4391 if (!shost
->transportt
||
4392 shost
->transportt
->host_attrs
.ac
.class != &iscsi_host_class
.class)
4395 priv
= to_iscsi_internal(shost
->transportt
);
4396 return &priv
->t
.host_attrs
.ac
== cont
;
4399 struct scsi_transport_template
*
4400 iscsi_register_transport(struct iscsi_transport
*tt
)
4402 struct iscsi_internal
*priv
;
4403 unsigned long flags
;
4408 priv
= iscsi_if_transport_lookup(tt
);
4412 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
4415 INIT_LIST_HEAD(&priv
->list
);
4416 priv
->iscsi_transport
= tt
;
4417 priv
->t
.user_scan
= iscsi_user_scan
;
4418 priv
->t
.create_work_queue
= 1;
4420 priv
->dev
.class = &iscsi_transport_class
;
4421 dev_set_name(&priv
->dev
, "%s", tt
->name
);
4422 err
= device_register(&priv
->dev
);
4426 err
= sysfs_create_group(&priv
->dev
.kobj
, &iscsi_transport_group
);
4428 goto unregister_dev
;
4430 /* host parameters */
4431 priv
->t
.host_attrs
.ac
.class = &iscsi_host_class
.class;
4432 priv
->t
.host_attrs
.ac
.match
= iscsi_host_match
;
4433 priv
->t
.host_attrs
.ac
.grp
= &iscsi_host_group
;
4434 priv
->t
.host_size
= sizeof(struct iscsi_cls_host
);
4435 transport_container_register(&priv
->t
.host_attrs
);
4437 /* connection parameters */
4438 priv
->conn_cont
.ac
.class = &iscsi_connection_class
.class;
4439 priv
->conn_cont
.ac
.match
= iscsi_conn_match
;
4440 priv
->conn_cont
.ac
.grp
= &iscsi_conn_group
;
4441 transport_container_register(&priv
->conn_cont
);
4443 /* session parameters */
4444 priv
->session_cont
.ac
.class = &iscsi_session_class
.class;
4445 priv
->session_cont
.ac
.match
= iscsi_session_match
;
4446 priv
->session_cont
.ac
.grp
= &iscsi_session_group
;
4447 transport_container_register(&priv
->session_cont
);
4449 spin_lock_irqsave(&iscsi_transport_lock
, flags
);
4450 list_add(&priv
->list
, &iscsi_transports
);
4451 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
4453 printk(KERN_NOTICE
"iscsi: registered transport (%s)\n", tt
->name
);
4457 device_unregister(&priv
->dev
);
4463 EXPORT_SYMBOL_GPL(iscsi_register_transport
);
4465 int iscsi_unregister_transport(struct iscsi_transport
*tt
)
4467 struct iscsi_internal
*priv
;
4468 unsigned long flags
;
4472 mutex_lock(&rx_queue_mutex
);
4474 priv
= iscsi_if_transport_lookup(tt
);
4477 spin_lock_irqsave(&iscsi_transport_lock
, flags
);
4478 list_del(&priv
->list
);
4479 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
4481 transport_container_unregister(&priv
->conn_cont
);
4482 transport_container_unregister(&priv
->session_cont
);
4483 transport_container_unregister(&priv
->t
.host_attrs
);
4485 sysfs_remove_group(&priv
->dev
.kobj
, &iscsi_transport_group
);
4486 device_unregister(&priv
->dev
);
4487 mutex_unlock(&rx_queue_mutex
);
4491 EXPORT_SYMBOL_GPL(iscsi_unregister_transport
);
4493 static __init
int iscsi_transport_init(void)
4496 struct netlink_kernel_cfg cfg
= {
4498 .input
= iscsi_if_rx
,
4500 printk(KERN_INFO
"Loading iSCSI transport class v%s.\n",
4501 ISCSI_TRANSPORT_VERSION
);
4503 atomic_set(&iscsi_session_nr
, 0);
4505 err
= class_register(&iscsi_transport_class
);
4509 err
= class_register(&iscsi_endpoint_class
);
4511 goto unregister_transport_class
;
4513 err
= class_register(&iscsi_iface_class
);
4515 goto unregister_endpoint_class
;
4517 err
= transport_class_register(&iscsi_host_class
);
4519 goto unregister_iface_class
;
4521 err
= transport_class_register(&iscsi_connection_class
);
4523 goto unregister_host_class
;
4525 err
= transport_class_register(&iscsi_session_class
);
4527 goto unregister_conn_class
;
4529 err
= bus_register(&iscsi_flashnode_bus
);
4531 goto unregister_session_class
;
4533 nls
= netlink_kernel_create(&init_net
, NETLINK_ISCSI
, &cfg
);
4536 goto unregister_flashnode_bus
;
4539 iscsi_eh_timer_workq
= create_singlethread_workqueue("iscsi_eh");
4540 if (!iscsi_eh_timer_workq
) {
4548 netlink_kernel_release(nls
);
4549 unregister_flashnode_bus
:
4550 bus_unregister(&iscsi_flashnode_bus
);
4551 unregister_session_class
:
4552 transport_class_unregister(&iscsi_session_class
);
4553 unregister_conn_class
:
4554 transport_class_unregister(&iscsi_connection_class
);
4555 unregister_host_class
:
4556 transport_class_unregister(&iscsi_host_class
);
4557 unregister_iface_class
:
4558 class_unregister(&iscsi_iface_class
);
4559 unregister_endpoint_class
:
4560 class_unregister(&iscsi_endpoint_class
);
4561 unregister_transport_class
:
4562 class_unregister(&iscsi_transport_class
);
4566 static void __exit
iscsi_transport_exit(void)
4568 destroy_workqueue(iscsi_eh_timer_workq
);
4569 netlink_kernel_release(nls
);
4570 bus_unregister(&iscsi_flashnode_bus
);
4571 transport_class_unregister(&iscsi_connection_class
);
4572 transport_class_unregister(&iscsi_session_class
);
4573 transport_class_unregister(&iscsi_host_class
);
4574 class_unregister(&iscsi_endpoint_class
);
4575 class_unregister(&iscsi_iface_class
);
4576 class_unregister(&iscsi_transport_class
);
4579 module_init(iscsi_transport_init
);
4580 module_exit(iscsi_transport_exit
);
4582 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
4583 "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
4584 "Alex Aizman <itn780@yahoo.com>");
4585 MODULE_DESCRIPTION("iSCSI Transport Interface");
4586 MODULE_LICENSE("GPL");
4587 MODULE_VERSION(ISCSI_TRANSPORT_VERSION
);
4588 MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK
, NETLINK_ISCSI
);