1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * iSCSI transport class definitions
5 * Copyright (C) IBM Corporation, 2004
6 * Copyright (C) Mike Christie, 2004 - 2005
7 * Copyright (C) Dmitry Yusupov, 2004 - 2005
8 * Copyright (C) Alex Aizman, 2004 - 2005
10 #include <linux/module.h>
11 #include <linux/mutex.h>
12 #include <linux/slab.h>
13 #include <linux/bsg-lib.h>
14 #include <linux/idr.h>
16 #include <scsi/scsi.h>
17 #include <scsi/scsi_host.h>
18 #include <scsi/scsi_device.h>
19 #include <scsi/scsi_transport.h>
20 #include <scsi/scsi_transport_iscsi.h>
21 #include <scsi/iscsi_if.h>
22 #include <scsi/scsi_cmnd.h>
23 #include <scsi/scsi_bsg_iscsi.h>
25 #define ISCSI_TRANSPORT_VERSION "2.0-870"
27 #define ISCSI_SEND_MAX_ALLOWED 10
29 #define CREATE_TRACE_POINTS
30 #include <trace/events/iscsi.h>
33 * Export tracepoint symbols to be used by other modules.
35 EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_conn
);
36 EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_eh
);
37 EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_session
);
38 EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_tcp
);
39 EXPORT_TRACEPOINT_SYMBOL_GPL(iscsi_dbg_sw_tcp
);
41 static int dbg_session
;
42 module_param_named(debug_session
, dbg_session
, int,
44 MODULE_PARM_DESC(debug_session
,
45 "Turn on debugging for sessions in scsi_transport_iscsi "
46 "module. Set to 1 to turn on, and zero to turn off. Default "
50 module_param_named(debug_conn
, dbg_conn
, int,
52 MODULE_PARM_DESC(debug_conn
,
53 "Turn on debugging for connections in scsi_transport_iscsi "
54 "module. Set to 1 to turn on, and zero to turn off. Default "
57 #define ISCSI_DBG_TRANS_SESSION(_session, dbg_fmt, arg...) \
60 iscsi_cls_session_printk(KERN_INFO, _session, \
63 iscsi_dbg_trace(trace_iscsi_dbg_trans_session, \
65 "%s " dbg_fmt, __func__, ##arg); \
68 #define ISCSI_DBG_TRANS_CONN(_conn, dbg_fmt, arg...) \
71 iscsi_cls_conn_printk(KERN_INFO, _conn, \
74 iscsi_dbg_trace(trace_iscsi_dbg_trans_conn, \
76 "%s " dbg_fmt, __func__, ##arg); \
79 struct iscsi_internal
{
80 struct scsi_transport_template t
;
81 struct iscsi_transport
*iscsi_transport
;
82 struct list_head list
;
85 struct transport_container conn_cont
;
86 struct transport_container session_cont
;
89 static atomic_t iscsi_session_nr
; /* sysfs session id for next new session */
90 static struct workqueue_struct
*iscsi_eh_timer_workq
;
92 static struct workqueue_struct
*iscsi_conn_cleanup_workq
;
94 static DEFINE_IDA(iscsi_sess_ida
);
96 * list of registered transports and lock that must
97 * be held while accessing list. The iscsi_transport_lock must
98 * be acquired after the rx_queue_mutex.
100 static LIST_HEAD(iscsi_transports
);
101 static DEFINE_SPINLOCK(iscsi_transport_lock
);
103 #define to_iscsi_internal(tmpl) \
104 container_of(tmpl, struct iscsi_internal, t)
106 #define dev_to_iscsi_internal(_dev) \
107 container_of(_dev, struct iscsi_internal, dev)
109 static void iscsi_transport_release(struct device
*dev
)
111 struct iscsi_internal
*priv
= dev_to_iscsi_internal(dev
);
116 * iscsi_transport_class represents the iscsi_transports that are
119 static struct class iscsi_transport_class
= {
120 .name
= "iscsi_transport",
121 .dev_release
= iscsi_transport_release
,
125 show_transport_handle(struct device
*dev
, struct device_attribute
*attr
,
128 struct iscsi_internal
*priv
= dev_to_iscsi_internal(dev
);
130 if (!capable(CAP_SYS_ADMIN
))
132 return sysfs_emit(buf
, "%llu\n",
133 (unsigned long long)iscsi_handle(priv
->iscsi_transport
));
135 static DEVICE_ATTR(handle
, S_IRUGO
, show_transport_handle
, NULL
);
137 #define show_transport_attr(name, format) \
139 show_transport_##name(struct device *dev, \
140 struct device_attribute *attr,char *buf) \
142 struct iscsi_internal *priv = dev_to_iscsi_internal(dev); \
143 return sysfs_emit(buf, format"\n", priv->iscsi_transport->name);\
145 static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
147 show_transport_attr(caps
, "0x%x");
149 static struct attribute
*iscsi_transport_attrs
[] = {
150 &dev_attr_handle
.attr
,
155 static struct attribute_group iscsi_transport_group
= {
156 .attrs
= iscsi_transport_attrs
,
160 * iSCSI endpoint attrs
162 #define iscsi_dev_to_endpoint(_dev) \
163 container_of(_dev, struct iscsi_endpoint, dev)
165 #define ISCSI_ATTR(_prefix,_name,_mode,_show,_store) \
166 struct device_attribute dev_attr_##_prefix##_##_name = \
167 __ATTR(_name,_mode,_show,_store)
169 static void iscsi_endpoint_release(struct device
*dev
)
171 struct iscsi_endpoint
*ep
= iscsi_dev_to_endpoint(dev
);
175 static struct class iscsi_endpoint_class
= {
176 .name
= "iscsi_endpoint",
177 .dev_release
= iscsi_endpoint_release
,
181 show_ep_handle(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
183 struct iscsi_endpoint
*ep
= iscsi_dev_to_endpoint(dev
);
184 return sysfs_emit(buf
, "%llu\n", (unsigned long long) ep
->id
);
186 static ISCSI_ATTR(ep
, handle
, S_IRUGO
, show_ep_handle
, NULL
);
188 static struct attribute
*iscsi_endpoint_attrs
[] = {
189 &dev_attr_ep_handle
.attr
,
193 static struct attribute_group iscsi_endpoint_group
= {
194 .attrs
= iscsi_endpoint_attrs
,
197 #define ISCSI_MAX_EPID -1
199 static int iscsi_match_epid(struct device
*dev
, const void *data
)
201 struct iscsi_endpoint
*ep
= iscsi_dev_to_endpoint(dev
);
202 const uint64_t *epid
= data
;
204 return *epid
== ep
->id
;
207 struct iscsi_endpoint
*
208 iscsi_create_endpoint(int dd_size
)
211 struct iscsi_endpoint
*ep
;
215 for (id
= 1; id
< ISCSI_MAX_EPID
; id
++) {
216 dev
= class_find_device(&iscsi_endpoint_class
, NULL
, &id
,
223 if (id
== ISCSI_MAX_EPID
) {
224 printk(KERN_ERR
"Too many connections. Max supported %u\n",
229 ep
= kzalloc(sizeof(*ep
) + dd_size
, GFP_KERNEL
);
234 ep
->dev
.class = &iscsi_endpoint_class
;
235 dev_set_name(&ep
->dev
, "ep-%llu", (unsigned long long) id
);
236 err
= device_register(&ep
->dev
);
240 err
= sysfs_create_group(&ep
->dev
.kobj
, &iscsi_endpoint_group
);
245 ep
->dd_data
= &ep
[1];
249 device_unregister(&ep
->dev
);
256 EXPORT_SYMBOL_GPL(iscsi_create_endpoint
);
258 void iscsi_destroy_endpoint(struct iscsi_endpoint
*ep
)
260 sysfs_remove_group(&ep
->dev
.kobj
, &iscsi_endpoint_group
);
261 device_unregister(&ep
->dev
);
263 EXPORT_SYMBOL_GPL(iscsi_destroy_endpoint
);
265 void iscsi_put_endpoint(struct iscsi_endpoint
*ep
)
267 put_device(&ep
->dev
);
269 EXPORT_SYMBOL_GPL(iscsi_put_endpoint
);
272 * iscsi_lookup_endpoint - get ep from handle
273 * @handle: endpoint handle
275 * Caller must do a iscsi_put_endpoint.
277 struct iscsi_endpoint
*iscsi_lookup_endpoint(u64 handle
)
281 dev
= class_find_device(&iscsi_endpoint_class
, NULL
, &handle
,
286 return iscsi_dev_to_endpoint(dev
);
288 EXPORT_SYMBOL_GPL(iscsi_lookup_endpoint
);
291 * Interface to display network param to sysfs
294 static void iscsi_iface_release(struct device
*dev
)
296 struct iscsi_iface
*iface
= iscsi_dev_to_iface(dev
);
297 struct device
*parent
= iface
->dev
.parent
;
304 static struct class iscsi_iface_class
= {
305 .name
= "iscsi_iface",
306 .dev_release
= iscsi_iface_release
,
309 #define ISCSI_IFACE_ATTR(_prefix, _name, _mode, _show, _store) \
310 struct device_attribute dev_attr_##_prefix##_##_name = \
311 __ATTR(_name, _mode, _show, _store)
313 /* iface attrs show */
314 #define iscsi_iface_attr_show(type, name, param_type, param) \
316 show_##type##_##name(struct device *dev, struct device_attribute *attr, \
319 struct iscsi_iface *iface = iscsi_dev_to_iface(dev); \
320 struct iscsi_transport *t = iface->transport; \
321 return t->get_iface_param(iface, param_type, param, buf); \
324 #define iscsi_iface_net_attr(type, name, param) \
325 iscsi_iface_attr_show(type, name, ISCSI_NET_PARAM, param) \
326 static ISCSI_IFACE_ATTR(type, name, S_IRUGO, show_##type##_##name, NULL);
328 #define iscsi_iface_attr(type, name, param) \
329 iscsi_iface_attr_show(type, name, ISCSI_IFACE_PARAM, param) \
330 static ISCSI_IFACE_ATTR(type, name, S_IRUGO, show_##type##_##name, NULL);
332 /* generic read only ipv4 attribute */
333 iscsi_iface_net_attr(ipv4_iface
, ipaddress
, ISCSI_NET_PARAM_IPV4_ADDR
);
334 iscsi_iface_net_attr(ipv4_iface
, gateway
, ISCSI_NET_PARAM_IPV4_GW
);
335 iscsi_iface_net_attr(ipv4_iface
, subnet
, ISCSI_NET_PARAM_IPV4_SUBNET
);
336 iscsi_iface_net_attr(ipv4_iface
, bootproto
, ISCSI_NET_PARAM_IPV4_BOOTPROTO
);
337 iscsi_iface_net_attr(ipv4_iface
, dhcp_dns_address_en
,
338 ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN
);
339 iscsi_iface_net_attr(ipv4_iface
, dhcp_slp_da_info_en
,
340 ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN
);
341 iscsi_iface_net_attr(ipv4_iface
, tos_en
, ISCSI_NET_PARAM_IPV4_TOS_EN
);
342 iscsi_iface_net_attr(ipv4_iface
, tos
, ISCSI_NET_PARAM_IPV4_TOS
);
343 iscsi_iface_net_attr(ipv4_iface
, grat_arp_en
,
344 ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN
);
345 iscsi_iface_net_attr(ipv4_iface
, dhcp_alt_client_id_en
,
346 ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN
);
347 iscsi_iface_net_attr(ipv4_iface
, dhcp_alt_client_id
,
348 ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID
);
349 iscsi_iface_net_attr(ipv4_iface
, dhcp_req_vendor_id_en
,
350 ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN
);
351 iscsi_iface_net_attr(ipv4_iface
, dhcp_use_vendor_id_en
,
352 ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN
);
353 iscsi_iface_net_attr(ipv4_iface
, dhcp_vendor_id
,
354 ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID
);
355 iscsi_iface_net_attr(ipv4_iface
, dhcp_learn_iqn_en
,
356 ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN
);
357 iscsi_iface_net_attr(ipv4_iface
, fragment_disable
,
358 ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE
);
359 iscsi_iface_net_attr(ipv4_iface
, incoming_forwarding_en
,
360 ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN
);
361 iscsi_iface_net_attr(ipv4_iface
, ttl
, ISCSI_NET_PARAM_IPV4_TTL
);
363 /* generic read only ipv6 attribute */
364 iscsi_iface_net_attr(ipv6_iface
, ipaddress
, ISCSI_NET_PARAM_IPV6_ADDR
);
365 iscsi_iface_net_attr(ipv6_iface
, link_local_addr
,
366 ISCSI_NET_PARAM_IPV6_LINKLOCAL
);
367 iscsi_iface_net_attr(ipv6_iface
, router_addr
, ISCSI_NET_PARAM_IPV6_ROUTER
);
368 iscsi_iface_net_attr(ipv6_iface
, ipaddr_autocfg
,
369 ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG
);
370 iscsi_iface_net_attr(ipv6_iface
, link_local_autocfg
,
371 ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG
);
372 iscsi_iface_net_attr(ipv6_iface
, link_local_state
,
373 ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE
);
374 iscsi_iface_net_attr(ipv6_iface
, router_state
,
375 ISCSI_NET_PARAM_IPV6_ROUTER_STATE
);
376 iscsi_iface_net_attr(ipv6_iface
, grat_neighbor_adv_en
,
377 ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN
);
378 iscsi_iface_net_attr(ipv6_iface
, mld_en
, ISCSI_NET_PARAM_IPV6_MLD_EN
);
379 iscsi_iface_net_attr(ipv6_iface
, flow_label
, ISCSI_NET_PARAM_IPV6_FLOW_LABEL
);
380 iscsi_iface_net_attr(ipv6_iface
, traffic_class
,
381 ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS
);
382 iscsi_iface_net_attr(ipv6_iface
, hop_limit
, ISCSI_NET_PARAM_IPV6_HOP_LIMIT
);
383 iscsi_iface_net_attr(ipv6_iface
, nd_reachable_tmo
,
384 ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO
);
385 iscsi_iface_net_attr(ipv6_iface
, nd_rexmit_time
,
386 ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME
);
387 iscsi_iface_net_attr(ipv6_iface
, nd_stale_tmo
,
388 ISCSI_NET_PARAM_IPV6_ND_STALE_TMO
);
389 iscsi_iface_net_attr(ipv6_iface
, dup_addr_detect_cnt
,
390 ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT
);
391 iscsi_iface_net_attr(ipv6_iface
, router_adv_link_mtu
,
392 ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU
);
394 /* common read only iface attribute */
395 iscsi_iface_net_attr(iface
, enabled
, ISCSI_NET_PARAM_IFACE_ENABLE
);
396 iscsi_iface_net_attr(iface
, vlan_id
, ISCSI_NET_PARAM_VLAN_ID
);
397 iscsi_iface_net_attr(iface
, vlan_priority
, ISCSI_NET_PARAM_VLAN_PRIORITY
);
398 iscsi_iface_net_attr(iface
, vlan_enabled
, ISCSI_NET_PARAM_VLAN_ENABLED
);
399 iscsi_iface_net_attr(iface
, mtu
, ISCSI_NET_PARAM_MTU
);
400 iscsi_iface_net_attr(iface
, port
, ISCSI_NET_PARAM_PORT
);
401 iscsi_iface_net_attr(iface
, ipaddress_state
, ISCSI_NET_PARAM_IPADDR_STATE
);
402 iscsi_iface_net_attr(iface
, delayed_ack_en
, ISCSI_NET_PARAM_DELAYED_ACK_EN
);
403 iscsi_iface_net_attr(iface
, tcp_nagle_disable
,
404 ISCSI_NET_PARAM_TCP_NAGLE_DISABLE
);
405 iscsi_iface_net_attr(iface
, tcp_wsf_disable
, ISCSI_NET_PARAM_TCP_WSF_DISABLE
);
406 iscsi_iface_net_attr(iface
, tcp_wsf
, ISCSI_NET_PARAM_TCP_WSF
);
407 iscsi_iface_net_attr(iface
, tcp_timer_scale
, ISCSI_NET_PARAM_TCP_TIMER_SCALE
);
408 iscsi_iface_net_attr(iface
, tcp_timestamp_en
, ISCSI_NET_PARAM_TCP_TIMESTAMP_EN
);
409 iscsi_iface_net_attr(iface
, cache_id
, ISCSI_NET_PARAM_CACHE_ID
);
410 iscsi_iface_net_attr(iface
, redirect_en
, ISCSI_NET_PARAM_REDIRECT_EN
);
412 /* common iscsi specific settings attributes */
413 iscsi_iface_attr(iface
, def_taskmgmt_tmo
, ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO
);
414 iscsi_iface_attr(iface
, header_digest
, ISCSI_IFACE_PARAM_HDRDGST_EN
);
415 iscsi_iface_attr(iface
, data_digest
, ISCSI_IFACE_PARAM_DATADGST_EN
);
416 iscsi_iface_attr(iface
, immediate_data
, ISCSI_IFACE_PARAM_IMM_DATA_EN
);
417 iscsi_iface_attr(iface
, initial_r2t
, ISCSI_IFACE_PARAM_INITIAL_R2T_EN
);
418 iscsi_iface_attr(iface
, data_seq_in_order
,
419 ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN
);
420 iscsi_iface_attr(iface
, data_pdu_in_order
, ISCSI_IFACE_PARAM_PDU_INORDER_EN
);
421 iscsi_iface_attr(iface
, erl
, ISCSI_IFACE_PARAM_ERL
);
422 iscsi_iface_attr(iface
, max_recv_dlength
, ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH
);
423 iscsi_iface_attr(iface
, first_burst_len
, ISCSI_IFACE_PARAM_FIRST_BURST
);
424 iscsi_iface_attr(iface
, max_outstanding_r2t
, ISCSI_IFACE_PARAM_MAX_R2T
);
425 iscsi_iface_attr(iface
, max_burst_len
, ISCSI_IFACE_PARAM_MAX_BURST
);
426 iscsi_iface_attr(iface
, chap_auth
, ISCSI_IFACE_PARAM_CHAP_AUTH_EN
);
427 iscsi_iface_attr(iface
, bidi_chap
, ISCSI_IFACE_PARAM_BIDI_CHAP_EN
);
428 iscsi_iface_attr(iface
, discovery_auth_optional
,
429 ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL
);
430 iscsi_iface_attr(iface
, discovery_logout
,
431 ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN
);
432 iscsi_iface_attr(iface
, strict_login_comp_en
,
433 ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN
);
434 iscsi_iface_attr(iface
, initiator_name
, ISCSI_IFACE_PARAM_INITIATOR_NAME
);
436 static umode_t
iscsi_iface_attr_is_visible(struct kobject
*kobj
,
437 struct attribute
*attr
, int i
)
439 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
440 struct iscsi_iface
*iface
= iscsi_dev_to_iface(dev
);
441 struct iscsi_transport
*t
= iface
->transport
;
444 if (attr
== &dev_attr_iface_def_taskmgmt_tmo
.attr
)
445 param
= ISCSI_IFACE_PARAM_DEF_TASKMGMT_TMO
;
446 else if (attr
== &dev_attr_iface_header_digest
.attr
)
447 param
= ISCSI_IFACE_PARAM_HDRDGST_EN
;
448 else if (attr
== &dev_attr_iface_data_digest
.attr
)
449 param
= ISCSI_IFACE_PARAM_DATADGST_EN
;
450 else if (attr
== &dev_attr_iface_immediate_data
.attr
)
451 param
= ISCSI_IFACE_PARAM_IMM_DATA_EN
;
452 else if (attr
== &dev_attr_iface_initial_r2t
.attr
)
453 param
= ISCSI_IFACE_PARAM_INITIAL_R2T_EN
;
454 else if (attr
== &dev_attr_iface_data_seq_in_order
.attr
)
455 param
= ISCSI_IFACE_PARAM_DATASEQ_INORDER_EN
;
456 else if (attr
== &dev_attr_iface_data_pdu_in_order
.attr
)
457 param
= ISCSI_IFACE_PARAM_PDU_INORDER_EN
;
458 else if (attr
== &dev_attr_iface_erl
.attr
)
459 param
= ISCSI_IFACE_PARAM_ERL
;
460 else if (attr
== &dev_attr_iface_max_recv_dlength
.attr
)
461 param
= ISCSI_IFACE_PARAM_MAX_RECV_DLENGTH
;
462 else if (attr
== &dev_attr_iface_first_burst_len
.attr
)
463 param
= ISCSI_IFACE_PARAM_FIRST_BURST
;
464 else if (attr
== &dev_attr_iface_max_outstanding_r2t
.attr
)
465 param
= ISCSI_IFACE_PARAM_MAX_R2T
;
466 else if (attr
== &dev_attr_iface_max_burst_len
.attr
)
467 param
= ISCSI_IFACE_PARAM_MAX_BURST
;
468 else if (attr
== &dev_attr_iface_chap_auth
.attr
)
469 param
= ISCSI_IFACE_PARAM_CHAP_AUTH_EN
;
470 else if (attr
== &dev_attr_iface_bidi_chap
.attr
)
471 param
= ISCSI_IFACE_PARAM_BIDI_CHAP_EN
;
472 else if (attr
== &dev_attr_iface_discovery_auth_optional
.attr
)
473 param
= ISCSI_IFACE_PARAM_DISCOVERY_AUTH_OPTIONAL
;
474 else if (attr
== &dev_attr_iface_discovery_logout
.attr
)
475 param
= ISCSI_IFACE_PARAM_DISCOVERY_LOGOUT_EN
;
476 else if (attr
== &dev_attr_iface_strict_login_comp_en
.attr
)
477 param
= ISCSI_IFACE_PARAM_STRICT_LOGIN_COMP_EN
;
478 else if (attr
== &dev_attr_iface_initiator_name
.attr
)
479 param
= ISCSI_IFACE_PARAM_INITIATOR_NAME
;
482 return t
->attr_is_visible(ISCSI_IFACE_PARAM
, param
);
484 if (attr
== &dev_attr_iface_enabled
.attr
)
485 param
= ISCSI_NET_PARAM_IFACE_ENABLE
;
486 else if (attr
== &dev_attr_iface_vlan_id
.attr
)
487 param
= ISCSI_NET_PARAM_VLAN_ID
;
488 else if (attr
== &dev_attr_iface_vlan_priority
.attr
)
489 param
= ISCSI_NET_PARAM_VLAN_PRIORITY
;
490 else if (attr
== &dev_attr_iface_vlan_enabled
.attr
)
491 param
= ISCSI_NET_PARAM_VLAN_ENABLED
;
492 else if (attr
== &dev_attr_iface_mtu
.attr
)
493 param
= ISCSI_NET_PARAM_MTU
;
494 else if (attr
== &dev_attr_iface_port
.attr
)
495 param
= ISCSI_NET_PARAM_PORT
;
496 else if (attr
== &dev_attr_iface_ipaddress_state
.attr
)
497 param
= ISCSI_NET_PARAM_IPADDR_STATE
;
498 else if (attr
== &dev_attr_iface_delayed_ack_en
.attr
)
499 param
= ISCSI_NET_PARAM_DELAYED_ACK_EN
;
500 else if (attr
== &dev_attr_iface_tcp_nagle_disable
.attr
)
501 param
= ISCSI_NET_PARAM_TCP_NAGLE_DISABLE
;
502 else if (attr
== &dev_attr_iface_tcp_wsf_disable
.attr
)
503 param
= ISCSI_NET_PARAM_TCP_WSF_DISABLE
;
504 else if (attr
== &dev_attr_iface_tcp_wsf
.attr
)
505 param
= ISCSI_NET_PARAM_TCP_WSF
;
506 else if (attr
== &dev_attr_iface_tcp_timer_scale
.attr
)
507 param
= ISCSI_NET_PARAM_TCP_TIMER_SCALE
;
508 else if (attr
== &dev_attr_iface_tcp_timestamp_en
.attr
)
509 param
= ISCSI_NET_PARAM_TCP_TIMESTAMP_EN
;
510 else if (attr
== &dev_attr_iface_cache_id
.attr
)
511 param
= ISCSI_NET_PARAM_CACHE_ID
;
512 else if (attr
== &dev_attr_iface_redirect_en
.attr
)
513 param
= ISCSI_NET_PARAM_REDIRECT_EN
;
514 else if (iface
->iface_type
== ISCSI_IFACE_TYPE_IPV4
) {
515 if (attr
== &dev_attr_ipv4_iface_ipaddress
.attr
)
516 param
= ISCSI_NET_PARAM_IPV4_ADDR
;
517 else if (attr
== &dev_attr_ipv4_iface_gateway
.attr
)
518 param
= ISCSI_NET_PARAM_IPV4_GW
;
519 else if (attr
== &dev_attr_ipv4_iface_subnet
.attr
)
520 param
= ISCSI_NET_PARAM_IPV4_SUBNET
;
521 else if (attr
== &dev_attr_ipv4_iface_bootproto
.attr
)
522 param
= ISCSI_NET_PARAM_IPV4_BOOTPROTO
;
524 &dev_attr_ipv4_iface_dhcp_dns_address_en
.attr
)
525 param
= ISCSI_NET_PARAM_IPV4_DHCP_DNS_ADDR_EN
;
527 &dev_attr_ipv4_iface_dhcp_slp_da_info_en
.attr
)
528 param
= ISCSI_NET_PARAM_IPV4_DHCP_SLP_DA_EN
;
529 else if (attr
== &dev_attr_ipv4_iface_tos_en
.attr
)
530 param
= ISCSI_NET_PARAM_IPV4_TOS_EN
;
531 else if (attr
== &dev_attr_ipv4_iface_tos
.attr
)
532 param
= ISCSI_NET_PARAM_IPV4_TOS
;
533 else if (attr
== &dev_attr_ipv4_iface_grat_arp_en
.attr
)
534 param
= ISCSI_NET_PARAM_IPV4_GRAT_ARP_EN
;
536 &dev_attr_ipv4_iface_dhcp_alt_client_id_en
.attr
)
537 param
= ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID_EN
;
538 else if (attr
== &dev_attr_ipv4_iface_dhcp_alt_client_id
.attr
)
539 param
= ISCSI_NET_PARAM_IPV4_DHCP_ALT_CLIENT_ID
;
541 &dev_attr_ipv4_iface_dhcp_req_vendor_id_en
.attr
)
542 param
= ISCSI_NET_PARAM_IPV4_DHCP_REQ_VENDOR_ID_EN
;
544 &dev_attr_ipv4_iface_dhcp_use_vendor_id_en
.attr
)
545 param
= ISCSI_NET_PARAM_IPV4_DHCP_USE_VENDOR_ID_EN
;
546 else if (attr
== &dev_attr_ipv4_iface_dhcp_vendor_id
.attr
)
547 param
= ISCSI_NET_PARAM_IPV4_DHCP_VENDOR_ID
;
549 &dev_attr_ipv4_iface_dhcp_learn_iqn_en
.attr
)
550 param
= ISCSI_NET_PARAM_IPV4_DHCP_LEARN_IQN_EN
;
552 &dev_attr_ipv4_iface_fragment_disable
.attr
)
553 param
= ISCSI_NET_PARAM_IPV4_FRAGMENT_DISABLE
;
555 &dev_attr_ipv4_iface_incoming_forwarding_en
.attr
)
556 param
= ISCSI_NET_PARAM_IPV4_IN_FORWARD_EN
;
557 else if (attr
== &dev_attr_ipv4_iface_ttl
.attr
)
558 param
= ISCSI_NET_PARAM_IPV4_TTL
;
561 } else if (iface
->iface_type
== ISCSI_IFACE_TYPE_IPV6
) {
562 if (attr
== &dev_attr_ipv6_iface_ipaddress
.attr
)
563 param
= ISCSI_NET_PARAM_IPV6_ADDR
;
564 else if (attr
== &dev_attr_ipv6_iface_link_local_addr
.attr
)
565 param
= ISCSI_NET_PARAM_IPV6_LINKLOCAL
;
566 else if (attr
== &dev_attr_ipv6_iface_router_addr
.attr
)
567 param
= ISCSI_NET_PARAM_IPV6_ROUTER
;
568 else if (attr
== &dev_attr_ipv6_iface_ipaddr_autocfg
.attr
)
569 param
= ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG
;
570 else if (attr
== &dev_attr_ipv6_iface_link_local_autocfg
.attr
)
571 param
= ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG
;
572 else if (attr
== &dev_attr_ipv6_iface_link_local_state
.attr
)
573 param
= ISCSI_NET_PARAM_IPV6_LINKLOCAL_STATE
;
574 else if (attr
== &dev_attr_ipv6_iface_router_state
.attr
)
575 param
= ISCSI_NET_PARAM_IPV6_ROUTER_STATE
;
577 &dev_attr_ipv6_iface_grat_neighbor_adv_en
.attr
)
578 param
= ISCSI_NET_PARAM_IPV6_GRAT_NEIGHBOR_ADV_EN
;
579 else if (attr
== &dev_attr_ipv6_iface_mld_en
.attr
)
580 param
= ISCSI_NET_PARAM_IPV6_MLD_EN
;
581 else if (attr
== &dev_attr_ipv6_iface_flow_label
.attr
)
582 param
= ISCSI_NET_PARAM_IPV6_FLOW_LABEL
;
583 else if (attr
== &dev_attr_ipv6_iface_traffic_class
.attr
)
584 param
= ISCSI_NET_PARAM_IPV6_TRAFFIC_CLASS
;
585 else if (attr
== &dev_attr_ipv6_iface_hop_limit
.attr
)
586 param
= ISCSI_NET_PARAM_IPV6_HOP_LIMIT
;
587 else if (attr
== &dev_attr_ipv6_iface_nd_reachable_tmo
.attr
)
588 param
= ISCSI_NET_PARAM_IPV6_ND_REACHABLE_TMO
;
589 else if (attr
== &dev_attr_ipv6_iface_nd_rexmit_time
.attr
)
590 param
= ISCSI_NET_PARAM_IPV6_ND_REXMIT_TIME
;
591 else if (attr
== &dev_attr_ipv6_iface_nd_stale_tmo
.attr
)
592 param
= ISCSI_NET_PARAM_IPV6_ND_STALE_TMO
;
593 else if (attr
== &dev_attr_ipv6_iface_dup_addr_detect_cnt
.attr
)
594 param
= ISCSI_NET_PARAM_IPV6_DUP_ADDR_DETECT_CNT
;
595 else if (attr
== &dev_attr_ipv6_iface_router_adv_link_mtu
.attr
)
596 param
= ISCSI_NET_PARAM_IPV6_RTR_ADV_LINK_MTU
;
600 WARN_ONCE(1, "Invalid iface attr");
604 return t
->attr_is_visible(ISCSI_NET_PARAM
, param
);
607 static struct attribute
*iscsi_iface_attrs
[] = {
608 &dev_attr_iface_enabled
.attr
,
609 &dev_attr_iface_vlan_id
.attr
,
610 &dev_attr_iface_vlan_priority
.attr
,
611 &dev_attr_iface_vlan_enabled
.attr
,
612 &dev_attr_ipv4_iface_ipaddress
.attr
,
613 &dev_attr_ipv4_iface_gateway
.attr
,
614 &dev_attr_ipv4_iface_subnet
.attr
,
615 &dev_attr_ipv4_iface_bootproto
.attr
,
616 &dev_attr_ipv6_iface_ipaddress
.attr
,
617 &dev_attr_ipv6_iface_link_local_addr
.attr
,
618 &dev_attr_ipv6_iface_router_addr
.attr
,
619 &dev_attr_ipv6_iface_ipaddr_autocfg
.attr
,
620 &dev_attr_ipv6_iface_link_local_autocfg
.attr
,
621 &dev_attr_iface_mtu
.attr
,
622 &dev_attr_iface_port
.attr
,
623 &dev_attr_iface_ipaddress_state
.attr
,
624 &dev_attr_iface_delayed_ack_en
.attr
,
625 &dev_attr_iface_tcp_nagle_disable
.attr
,
626 &dev_attr_iface_tcp_wsf_disable
.attr
,
627 &dev_attr_iface_tcp_wsf
.attr
,
628 &dev_attr_iface_tcp_timer_scale
.attr
,
629 &dev_attr_iface_tcp_timestamp_en
.attr
,
630 &dev_attr_iface_cache_id
.attr
,
631 &dev_attr_iface_redirect_en
.attr
,
632 &dev_attr_iface_def_taskmgmt_tmo
.attr
,
633 &dev_attr_iface_header_digest
.attr
,
634 &dev_attr_iface_data_digest
.attr
,
635 &dev_attr_iface_immediate_data
.attr
,
636 &dev_attr_iface_initial_r2t
.attr
,
637 &dev_attr_iface_data_seq_in_order
.attr
,
638 &dev_attr_iface_data_pdu_in_order
.attr
,
639 &dev_attr_iface_erl
.attr
,
640 &dev_attr_iface_max_recv_dlength
.attr
,
641 &dev_attr_iface_first_burst_len
.attr
,
642 &dev_attr_iface_max_outstanding_r2t
.attr
,
643 &dev_attr_iface_max_burst_len
.attr
,
644 &dev_attr_iface_chap_auth
.attr
,
645 &dev_attr_iface_bidi_chap
.attr
,
646 &dev_attr_iface_discovery_auth_optional
.attr
,
647 &dev_attr_iface_discovery_logout
.attr
,
648 &dev_attr_iface_strict_login_comp_en
.attr
,
649 &dev_attr_iface_initiator_name
.attr
,
650 &dev_attr_ipv4_iface_dhcp_dns_address_en
.attr
,
651 &dev_attr_ipv4_iface_dhcp_slp_da_info_en
.attr
,
652 &dev_attr_ipv4_iface_tos_en
.attr
,
653 &dev_attr_ipv4_iface_tos
.attr
,
654 &dev_attr_ipv4_iface_grat_arp_en
.attr
,
655 &dev_attr_ipv4_iface_dhcp_alt_client_id_en
.attr
,
656 &dev_attr_ipv4_iface_dhcp_alt_client_id
.attr
,
657 &dev_attr_ipv4_iface_dhcp_req_vendor_id_en
.attr
,
658 &dev_attr_ipv4_iface_dhcp_use_vendor_id_en
.attr
,
659 &dev_attr_ipv4_iface_dhcp_vendor_id
.attr
,
660 &dev_attr_ipv4_iface_dhcp_learn_iqn_en
.attr
,
661 &dev_attr_ipv4_iface_fragment_disable
.attr
,
662 &dev_attr_ipv4_iface_incoming_forwarding_en
.attr
,
663 &dev_attr_ipv4_iface_ttl
.attr
,
664 &dev_attr_ipv6_iface_link_local_state
.attr
,
665 &dev_attr_ipv6_iface_router_state
.attr
,
666 &dev_attr_ipv6_iface_grat_neighbor_adv_en
.attr
,
667 &dev_attr_ipv6_iface_mld_en
.attr
,
668 &dev_attr_ipv6_iface_flow_label
.attr
,
669 &dev_attr_ipv6_iface_traffic_class
.attr
,
670 &dev_attr_ipv6_iface_hop_limit
.attr
,
671 &dev_attr_ipv6_iface_nd_reachable_tmo
.attr
,
672 &dev_attr_ipv6_iface_nd_rexmit_time
.attr
,
673 &dev_attr_ipv6_iface_nd_stale_tmo
.attr
,
674 &dev_attr_ipv6_iface_dup_addr_detect_cnt
.attr
,
675 &dev_attr_ipv6_iface_router_adv_link_mtu
.attr
,
679 static struct attribute_group iscsi_iface_group
= {
680 .attrs
= iscsi_iface_attrs
,
681 .is_visible
= iscsi_iface_attr_is_visible
,
684 /* convert iscsi_ipaddress_state values to ascii string name */
685 static const struct {
686 enum iscsi_ipaddress_state value
;
688 } iscsi_ipaddress_state_names
[] = {
689 {ISCSI_IPDDRESS_STATE_UNCONFIGURED
, "Unconfigured" },
690 {ISCSI_IPDDRESS_STATE_ACQUIRING
, "Acquiring" },
691 {ISCSI_IPDDRESS_STATE_TENTATIVE
, "Tentative" },
692 {ISCSI_IPDDRESS_STATE_VALID
, "Valid" },
693 {ISCSI_IPDDRESS_STATE_DISABLING
, "Disabling" },
694 {ISCSI_IPDDRESS_STATE_INVALID
, "Invalid" },
695 {ISCSI_IPDDRESS_STATE_DEPRECATED
, "Deprecated" },
698 char *iscsi_get_ipaddress_state_name(enum iscsi_ipaddress_state port_state
)
703 for (i
= 0; i
< ARRAY_SIZE(iscsi_ipaddress_state_names
); i
++) {
704 if (iscsi_ipaddress_state_names
[i
].value
== port_state
) {
705 state
= iscsi_ipaddress_state_names
[i
].name
;
711 EXPORT_SYMBOL_GPL(iscsi_get_ipaddress_state_name
);
713 /* convert iscsi_router_state values to ascii string name */
714 static const struct {
715 enum iscsi_router_state value
;
717 } iscsi_router_state_names
[] = {
718 {ISCSI_ROUTER_STATE_UNKNOWN
, "Unknown" },
719 {ISCSI_ROUTER_STATE_ADVERTISED
, "Advertised" },
720 {ISCSI_ROUTER_STATE_MANUAL
, "Manual" },
721 {ISCSI_ROUTER_STATE_STALE
, "Stale" },
724 char *iscsi_get_router_state_name(enum iscsi_router_state router_state
)
729 for (i
= 0; i
< ARRAY_SIZE(iscsi_router_state_names
); i
++) {
730 if (iscsi_router_state_names
[i
].value
== router_state
) {
731 state
= iscsi_router_state_names
[i
].name
;
737 EXPORT_SYMBOL_GPL(iscsi_get_router_state_name
);
740 iscsi_create_iface(struct Scsi_Host
*shost
, struct iscsi_transport
*transport
,
741 uint32_t iface_type
, uint32_t iface_num
, int dd_size
)
743 struct iscsi_iface
*iface
;
746 iface
= kzalloc(sizeof(*iface
) + dd_size
, GFP_KERNEL
);
750 iface
->transport
= transport
;
751 iface
->iface_type
= iface_type
;
752 iface
->iface_num
= iface_num
;
753 iface
->dev
.release
= iscsi_iface_release
;
754 iface
->dev
.class = &iscsi_iface_class
;
755 /* parent reference released in iscsi_iface_release */
756 iface
->dev
.parent
= get_device(&shost
->shost_gendev
);
757 if (iface_type
== ISCSI_IFACE_TYPE_IPV4
)
758 dev_set_name(&iface
->dev
, "ipv4-iface-%u-%u", shost
->host_no
,
761 dev_set_name(&iface
->dev
, "ipv6-iface-%u-%u", shost
->host_no
,
764 err
= device_register(&iface
->dev
);
768 err
= sysfs_create_group(&iface
->dev
.kobj
, &iscsi_iface_group
);
773 iface
->dd_data
= &iface
[1];
777 device_unregister(&iface
->dev
);
781 put_device(iface
->dev
.parent
);
785 EXPORT_SYMBOL_GPL(iscsi_create_iface
);
787 void iscsi_destroy_iface(struct iscsi_iface
*iface
)
789 sysfs_remove_group(&iface
->dev
.kobj
, &iscsi_iface_group
);
790 device_unregister(&iface
->dev
);
792 EXPORT_SYMBOL_GPL(iscsi_destroy_iface
);
795 * Interface to display flash node params to sysfs
798 #define ISCSI_FLASHNODE_ATTR(_prefix, _name, _mode, _show, _store) \
799 struct device_attribute dev_attr_##_prefix##_##_name = \
800 __ATTR(_name, _mode, _show, _store)
802 /* flash node session attrs show */
803 #define iscsi_flashnode_sess_attr_show(type, name, param) \
805 show_##type##_##name(struct device *dev, struct device_attribute *attr, \
808 struct iscsi_bus_flash_session *fnode_sess = \
809 iscsi_dev_to_flash_session(dev);\
810 struct iscsi_transport *t = fnode_sess->transport; \
811 return t->get_flashnode_param(fnode_sess, param, buf); \
815 #define iscsi_flashnode_sess_attr(type, name, param) \
816 iscsi_flashnode_sess_attr_show(type, name, param) \
817 static ISCSI_FLASHNODE_ATTR(type, name, S_IRUGO, \
818 show_##type##_##name, NULL);
820 /* Flash node session attributes */
822 iscsi_flashnode_sess_attr(fnode
, auto_snd_tgt_disable
,
823 ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE
);
824 iscsi_flashnode_sess_attr(fnode
, discovery_session
,
825 ISCSI_FLASHNODE_DISCOVERY_SESS
);
826 iscsi_flashnode_sess_attr(fnode
, portal_type
, ISCSI_FLASHNODE_PORTAL_TYPE
);
827 iscsi_flashnode_sess_attr(fnode
, entry_enable
, ISCSI_FLASHNODE_ENTRY_EN
);
828 iscsi_flashnode_sess_attr(fnode
, immediate_data
, ISCSI_FLASHNODE_IMM_DATA_EN
);
829 iscsi_flashnode_sess_attr(fnode
, initial_r2t
, ISCSI_FLASHNODE_INITIAL_R2T_EN
);
830 iscsi_flashnode_sess_attr(fnode
, data_seq_in_order
,
831 ISCSI_FLASHNODE_DATASEQ_INORDER
);
832 iscsi_flashnode_sess_attr(fnode
, data_pdu_in_order
,
833 ISCSI_FLASHNODE_PDU_INORDER
);
834 iscsi_flashnode_sess_attr(fnode
, chap_auth
, ISCSI_FLASHNODE_CHAP_AUTH_EN
);
835 iscsi_flashnode_sess_attr(fnode
, discovery_logout
,
836 ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN
);
837 iscsi_flashnode_sess_attr(fnode
, bidi_chap
, ISCSI_FLASHNODE_BIDI_CHAP_EN
);
838 iscsi_flashnode_sess_attr(fnode
, discovery_auth_optional
,
839 ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL
);
840 iscsi_flashnode_sess_attr(fnode
, erl
, ISCSI_FLASHNODE_ERL
);
841 iscsi_flashnode_sess_attr(fnode
, first_burst_len
, ISCSI_FLASHNODE_FIRST_BURST
);
842 iscsi_flashnode_sess_attr(fnode
, def_time2wait
, ISCSI_FLASHNODE_DEF_TIME2WAIT
);
843 iscsi_flashnode_sess_attr(fnode
, def_time2retain
,
844 ISCSI_FLASHNODE_DEF_TIME2RETAIN
);
845 iscsi_flashnode_sess_attr(fnode
, max_outstanding_r2t
, ISCSI_FLASHNODE_MAX_R2T
);
846 iscsi_flashnode_sess_attr(fnode
, isid
, ISCSI_FLASHNODE_ISID
);
847 iscsi_flashnode_sess_attr(fnode
, tsid
, ISCSI_FLASHNODE_TSID
);
848 iscsi_flashnode_sess_attr(fnode
, max_burst_len
, ISCSI_FLASHNODE_MAX_BURST
);
849 iscsi_flashnode_sess_attr(fnode
, def_taskmgmt_tmo
,
850 ISCSI_FLASHNODE_DEF_TASKMGMT_TMO
);
851 iscsi_flashnode_sess_attr(fnode
, targetalias
, ISCSI_FLASHNODE_ALIAS
);
852 iscsi_flashnode_sess_attr(fnode
, targetname
, ISCSI_FLASHNODE_NAME
);
853 iscsi_flashnode_sess_attr(fnode
, tpgt
, ISCSI_FLASHNODE_TPGT
);
854 iscsi_flashnode_sess_attr(fnode
, discovery_parent_idx
,
855 ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX
);
856 iscsi_flashnode_sess_attr(fnode
, discovery_parent_type
,
857 ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE
);
858 iscsi_flashnode_sess_attr(fnode
, chap_in_idx
, ISCSI_FLASHNODE_CHAP_IN_IDX
);
859 iscsi_flashnode_sess_attr(fnode
, chap_out_idx
, ISCSI_FLASHNODE_CHAP_OUT_IDX
);
860 iscsi_flashnode_sess_attr(fnode
, username
, ISCSI_FLASHNODE_USERNAME
);
861 iscsi_flashnode_sess_attr(fnode
, username_in
, ISCSI_FLASHNODE_USERNAME_IN
);
862 iscsi_flashnode_sess_attr(fnode
, password
, ISCSI_FLASHNODE_PASSWORD
);
863 iscsi_flashnode_sess_attr(fnode
, password_in
, ISCSI_FLASHNODE_PASSWORD_IN
);
864 iscsi_flashnode_sess_attr(fnode
, is_boot_target
, ISCSI_FLASHNODE_IS_BOOT_TGT
);
866 static struct attribute
*iscsi_flashnode_sess_attrs
[] = {
867 &dev_attr_fnode_auto_snd_tgt_disable
.attr
,
868 &dev_attr_fnode_discovery_session
.attr
,
869 &dev_attr_fnode_portal_type
.attr
,
870 &dev_attr_fnode_entry_enable
.attr
,
871 &dev_attr_fnode_immediate_data
.attr
,
872 &dev_attr_fnode_initial_r2t
.attr
,
873 &dev_attr_fnode_data_seq_in_order
.attr
,
874 &dev_attr_fnode_data_pdu_in_order
.attr
,
875 &dev_attr_fnode_chap_auth
.attr
,
876 &dev_attr_fnode_discovery_logout
.attr
,
877 &dev_attr_fnode_bidi_chap
.attr
,
878 &dev_attr_fnode_discovery_auth_optional
.attr
,
879 &dev_attr_fnode_erl
.attr
,
880 &dev_attr_fnode_first_burst_len
.attr
,
881 &dev_attr_fnode_def_time2wait
.attr
,
882 &dev_attr_fnode_def_time2retain
.attr
,
883 &dev_attr_fnode_max_outstanding_r2t
.attr
,
884 &dev_attr_fnode_isid
.attr
,
885 &dev_attr_fnode_tsid
.attr
,
886 &dev_attr_fnode_max_burst_len
.attr
,
887 &dev_attr_fnode_def_taskmgmt_tmo
.attr
,
888 &dev_attr_fnode_targetalias
.attr
,
889 &dev_attr_fnode_targetname
.attr
,
890 &dev_attr_fnode_tpgt
.attr
,
891 &dev_attr_fnode_discovery_parent_idx
.attr
,
892 &dev_attr_fnode_discovery_parent_type
.attr
,
893 &dev_attr_fnode_chap_in_idx
.attr
,
894 &dev_attr_fnode_chap_out_idx
.attr
,
895 &dev_attr_fnode_username
.attr
,
896 &dev_attr_fnode_username_in
.attr
,
897 &dev_attr_fnode_password
.attr
,
898 &dev_attr_fnode_password_in
.attr
,
899 &dev_attr_fnode_is_boot_target
.attr
,
903 static umode_t
iscsi_flashnode_sess_attr_is_visible(struct kobject
*kobj
,
904 struct attribute
*attr
,
907 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
908 struct iscsi_bus_flash_session
*fnode_sess
=
909 iscsi_dev_to_flash_session(dev
);
910 struct iscsi_transport
*t
= fnode_sess
->transport
;
913 if (attr
== &dev_attr_fnode_auto_snd_tgt_disable
.attr
) {
914 param
= ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE
;
915 } else if (attr
== &dev_attr_fnode_discovery_session
.attr
) {
916 param
= ISCSI_FLASHNODE_DISCOVERY_SESS
;
917 } else if (attr
== &dev_attr_fnode_portal_type
.attr
) {
918 param
= ISCSI_FLASHNODE_PORTAL_TYPE
;
919 } else if (attr
== &dev_attr_fnode_entry_enable
.attr
) {
920 param
= ISCSI_FLASHNODE_ENTRY_EN
;
921 } else if (attr
== &dev_attr_fnode_immediate_data
.attr
) {
922 param
= ISCSI_FLASHNODE_IMM_DATA_EN
;
923 } else if (attr
== &dev_attr_fnode_initial_r2t
.attr
) {
924 param
= ISCSI_FLASHNODE_INITIAL_R2T_EN
;
925 } else if (attr
== &dev_attr_fnode_data_seq_in_order
.attr
) {
926 param
= ISCSI_FLASHNODE_DATASEQ_INORDER
;
927 } else if (attr
== &dev_attr_fnode_data_pdu_in_order
.attr
) {
928 param
= ISCSI_FLASHNODE_PDU_INORDER
;
929 } else if (attr
== &dev_attr_fnode_chap_auth
.attr
) {
930 param
= ISCSI_FLASHNODE_CHAP_AUTH_EN
;
931 } else if (attr
== &dev_attr_fnode_discovery_logout
.attr
) {
932 param
= ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN
;
933 } else if (attr
== &dev_attr_fnode_bidi_chap
.attr
) {
934 param
= ISCSI_FLASHNODE_BIDI_CHAP_EN
;
935 } else if (attr
== &dev_attr_fnode_discovery_auth_optional
.attr
) {
936 param
= ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL
;
937 } else if (attr
== &dev_attr_fnode_erl
.attr
) {
938 param
= ISCSI_FLASHNODE_ERL
;
939 } else if (attr
== &dev_attr_fnode_first_burst_len
.attr
) {
940 param
= ISCSI_FLASHNODE_FIRST_BURST
;
941 } else if (attr
== &dev_attr_fnode_def_time2wait
.attr
) {
942 param
= ISCSI_FLASHNODE_DEF_TIME2WAIT
;
943 } else if (attr
== &dev_attr_fnode_def_time2retain
.attr
) {
944 param
= ISCSI_FLASHNODE_DEF_TIME2RETAIN
;
945 } else if (attr
== &dev_attr_fnode_max_outstanding_r2t
.attr
) {
946 param
= ISCSI_FLASHNODE_MAX_R2T
;
947 } else if (attr
== &dev_attr_fnode_isid
.attr
) {
948 param
= ISCSI_FLASHNODE_ISID
;
949 } else if (attr
== &dev_attr_fnode_tsid
.attr
) {
950 param
= ISCSI_FLASHNODE_TSID
;
951 } else if (attr
== &dev_attr_fnode_max_burst_len
.attr
) {
952 param
= ISCSI_FLASHNODE_MAX_BURST
;
953 } else if (attr
== &dev_attr_fnode_def_taskmgmt_tmo
.attr
) {
954 param
= ISCSI_FLASHNODE_DEF_TASKMGMT_TMO
;
955 } else if (attr
== &dev_attr_fnode_targetalias
.attr
) {
956 param
= ISCSI_FLASHNODE_ALIAS
;
957 } else if (attr
== &dev_attr_fnode_targetname
.attr
) {
958 param
= ISCSI_FLASHNODE_NAME
;
959 } else if (attr
== &dev_attr_fnode_tpgt
.attr
) {
960 param
= ISCSI_FLASHNODE_TPGT
;
961 } else if (attr
== &dev_attr_fnode_discovery_parent_idx
.attr
) {
962 param
= ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX
;
963 } else if (attr
== &dev_attr_fnode_discovery_parent_type
.attr
) {
964 param
= ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE
;
965 } else if (attr
== &dev_attr_fnode_chap_in_idx
.attr
) {
966 param
= ISCSI_FLASHNODE_CHAP_IN_IDX
;
967 } else if (attr
== &dev_attr_fnode_chap_out_idx
.attr
) {
968 param
= ISCSI_FLASHNODE_CHAP_OUT_IDX
;
969 } else if (attr
== &dev_attr_fnode_username
.attr
) {
970 param
= ISCSI_FLASHNODE_USERNAME
;
971 } else if (attr
== &dev_attr_fnode_username_in
.attr
) {
972 param
= ISCSI_FLASHNODE_USERNAME_IN
;
973 } else if (attr
== &dev_attr_fnode_password
.attr
) {
974 param
= ISCSI_FLASHNODE_PASSWORD
;
975 } else if (attr
== &dev_attr_fnode_password_in
.attr
) {
976 param
= ISCSI_FLASHNODE_PASSWORD_IN
;
977 } else if (attr
== &dev_attr_fnode_is_boot_target
.attr
) {
978 param
= ISCSI_FLASHNODE_IS_BOOT_TGT
;
980 WARN_ONCE(1, "Invalid flashnode session attr");
984 return t
->attr_is_visible(ISCSI_FLASHNODE_PARAM
, param
);
987 static struct attribute_group iscsi_flashnode_sess_attr_group
= {
988 .attrs
= iscsi_flashnode_sess_attrs
,
989 .is_visible
= iscsi_flashnode_sess_attr_is_visible
,
992 static const struct attribute_group
*iscsi_flashnode_sess_attr_groups
[] = {
993 &iscsi_flashnode_sess_attr_group
,
997 static void iscsi_flashnode_sess_release(struct device
*dev
)
999 struct iscsi_bus_flash_session
*fnode_sess
=
1000 iscsi_dev_to_flash_session(dev
);
1002 kfree(fnode_sess
->targetname
);
1003 kfree(fnode_sess
->targetalias
);
1004 kfree(fnode_sess
->portal_type
);
1008 static const struct device_type iscsi_flashnode_sess_dev_type
= {
1009 .name
= "iscsi_flashnode_sess_dev_type",
1010 .groups
= iscsi_flashnode_sess_attr_groups
,
1011 .release
= iscsi_flashnode_sess_release
,
1014 /* flash node connection attrs show */
1015 #define iscsi_flashnode_conn_attr_show(type, name, param) \
1017 show_##type##_##name(struct device *dev, struct device_attribute *attr, \
1020 struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev);\
1021 struct iscsi_bus_flash_session *fnode_sess = \
1022 iscsi_flash_conn_to_flash_session(fnode_conn);\
1023 struct iscsi_transport *t = fnode_conn->transport; \
1024 return t->get_flashnode_param(fnode_sess, param, buf); \
1028 #define iscsi_flashnode_conn_attr(type, name, param) \
1029 iscsi_flashnode_conn_attr_show(type, name, param) \
1030 static ISCSI_FLASHNODE_ATTR(type, name, S_IRUGO, \
1031 show_##type##_##name, NULL);
1033 /* Flash node connection attributes */
1035 iscsi_flashnode_conn_attr(fnode
, is_fw_assigned_ipv6
,
1036 ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6
);
1037 iscsi_flashnode_conn_attr(fnode
, header_digest
, ISCSI_FLASHNODE_HDR_DGST_EN
);
1038 iscsi_flashnode_conn_attr(fnode
, data_digest
, ISCSI_FLASHNODE_DATA_DGST_EN
);
1039 iscsi_flashnode_conn_attr(fnode
, snack_req
, ISCSI_FLASHNODE_SNACK_REQ_EN
);
1040 iscsi_flashnode_conn_attr(fnode
, tcp_timestamp_stat
,
1041 ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT
);
1042 iscsi_flashnode_conn_attr(fnode
, tcp_nagle_disable
,
1043 ISCSI_FLASHNODE_TCP_NAGLE_DISABLE
);
1044 iscsi_flashnode_conn_attr(fnode
, tcp_wsf_disable
,
1045 ISCSI_FLASHNODE_TCP_WSF_DISABLE
);
1046 iscsi_flashnode_conn_attr(fnode
, tcp_timer_scale
,
1047 ISCSI_FLASHNODE_TCP_TIMER_SCALE
);
1048 iscsi_flashnode_conn_attr(fnode
, tcp_timestamp_enable
,
1049 ISCSI_FLASHNODE_TCP_TIMESTAMP_EN
);
1050 iscsi_flashnode_conn_attr(fnode
, fragment_disable
,
1051 ISCSI_FLASHNODE_IP_FRAG_DISABLE
);
1052 iscsi_flashnode_conn_attr(fnode
, keepalive_tmo
, ISCSI_FLASHNODE_KEEPALIVE_TMO
);
1053 iscsi_flashnode_conn_attr(fnode
, port
, ISCSI_FLASHNODE_PORT
);
1054 iscsi_flashnode_conn_attr(fnode
, ipaddress
, ISCSI_FLASHNODE_IPADDR
);
1055 iscsi_flashnode_conn_attr(fnode
, max_recv_dlength
,
1056 ISCSI_FLASHNODE_MAX_RECV_DLENGTH
);
1057 iscsi_flashnode_conn_attr(fnode
, max_xmit_dlength
,
1058 ISCSI_FLASHNODE_MAX_XMIT_DLENGTH
);
1059 iscsi_flashnode_conn_attr(fnode
, local_port
, ISCSI_FLASHNODE_LOCAL_PORT
);
1060 iscsi_flashnode_conn_attr(fnode
, ipv4_tos
, ISCSI_FLASHNODE_IPV4_TOS
);
1061 iscsi_flashnode_conn_attr(fnode
, ipv6_traffic_class
, ISCSI_FLASHNODE_IPV6_TC
);
1062 iscsi_flashnode_conn_attr(fnode
, ipv6_flow_label
,
1063 ISCSI_FLASHNODE_IPV6_FLOW_LABEL
);
1064 iscsi_flashnode_conn_attr(fnode
, redirect_ipaddr
,
1065 ISCSI_FLASHNODE_REDIRECT_IPADDR
);
1066 iscsi_flashnode_conn_attr(fnode
, max_segment_size
,
1067 ISCSI_FLASHNODE_MAX_SEGMENT_SIZE
);
1068 iscsi_flashnode_conn_attr(fnode
, link_local_ipv6
,
1069 ISCSI_FLASHNODE_LINK_LOCAL_IPV6
);
1070 iscsi_flashnode_conn_attr(fnode
, tcp_xmit_wsf
, ISCSI_FLASHNODE_TCP_XMIT_WSF
);
1071 iscsi_flashnode_conn_attr(fnode
, tcp_recv_wsf
, ISCSI_FLASHNODE_TCP_RECV_WSF
);
1072 iscsi_flashnode_conn_attr(fnode
, statsn
, ISCSI_FLASHNODE_STATSN
);
1073 iscsi_flashnode_conn_attr(fnode
, exp_statsn
, ISCSI_FLASHNODE_EXP_STATSN
);
1075 static struct attribute
*iscsi_flashnode_conn_attrs
[] = {
1076 &dev_attr_fnode_is_fw_assigned_ipv6
.attr
,
1077 &dev_attr_fnode_header_digest
.attr
,
1078 &dev_attr_fnode_data_digest
.attr
,
1079 &dev_attr_fnode_snack_req
.attr
,
1080 &dev_attr_fnode_tcp_timestamp_stat
.attr
,
1081 &dev_attr_fnode_tcp_nagle_disable
.attr
,
1082 &dev_attr_fnode_tcp_wsf_disable
.attr
,
1083 &dev_attr_fnode_tcp_timer_scale
.attr
,
1084 &dev_attr_fnode_tcp_timestamp_enable
.attr
,
1085 &dev_attr_fnode_fragment_disable
.attr
,
1086 &dev_attr_fnode_max_recv_dlength
.attr
,
1087 &dev_attr_fnode_max_xmit_dlength
.attr
,
1088 &dev_attr_fnode_keepalive_tmo
.attr
,
1089 &dev_attr_fnode_port
.attr
,
1090 &dev_attr_fnode_ipaddress
.attr
,
1091 &dev_attr_fnode_redirect_ipaddr
.attr
,
1092 &dev_attr_fnode_max_segment_size
.attr
,
1093 &dev_attr_fnode_local_port
.attr
,
1094 &dev_attr_fnode_ipv4_tos
.attr
,
1095 &dev_attr_fnode_ipv6_traffic_class
.attr
,
1096 &dev_attr_fnode_ipv6_flow_label
.attr
,
1097 &dev_attr_fnode_link_local_ipv6
.attr
,
1098 &dev_attr_fnode_tcp_xmit_wsf
.attr
,
1099 &dev_attr_fnode_tcp_recv_wsf
.attr
,
1100 &dev_attr_fnode_statsn
.attr
,
1101 &dev_attr_fnode_exp_statsn
.attr
,
1105 static umode_t
iscsi_flashnode_conn_attr_is_visible(struct kobject
*kobj
,
1106 struct attribute
*attr
,
1109 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
1110 struct iscsi_bus_flash_conn
*fnode_conn
= iscsi_dev_to_flash_conn(dev
);
1111 struct iscsi_transport
*t
= fnode_conn
->transport
;
1114 if (attr
== &dev_attr_fnode_is_fw_assigned_ipv6
.attr
) {
1115 param
= ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6
;
1116 } else if (attr
== &dev_attr_fnode_header_digest
.attr
) {
1117 param
= ISCSI_FLASHNODE_HDR_DGST_EN
;
1118 } else if (attr
== &dev_attr_fnode_data_digest
.attr
) {
1119 param
= ISCSI_FLASHNODE_DATA_DGST_EN
;
1120 } else if (attr
== &dev_attr_fnode_snack_req
.attr
) {
1121 param
= ISCSI_FLASHNODE_SNACK_REQ_EN
;
1122 } else if (attr
== &dev_attr_fnode_tcp_timestamp_stat
.attr
) {
1123 param
= ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT
;
1124 } else if (attr
== &dev_attr_fnode_tcp_nagle_disable
.attr
) {
1125 param
= ISCSI_FLASHNODE_TCP_NAGLE_DISABLE
;
1126 } else if (attr
== &dev_attr_fnode_tcp_wsf_disable
.attr
) {
1127 param
= ISCSI_FLASHNODE_TCP_WSF_DISABLE
;
1128 } else if (attr
== &dev_attr_fnode_tcp_timer_scale
.attr
) {
1129 param
= ISCSI_FLASHNODE_TCP_TIMER_SCALE
;
1130 } else if (attr
== &dev_attr_fnode_tcp_timestamp_enable
.attr
) {
1131 param
= ISCSI_FLASHNODE_TCP_TIMESTAMP_EN
;
1132 } else if (attr
== &dev_attr_fnode_fragment_disable
.attr
) {
1133 param
= ISCSI_FLASHNODE_IP_FRAG_DISABLE
;
1134 } else if (attr
== &dev_attr_fnode_max_recv_dlength
.attr
) {
1135 param
= ISCSI_FLASHNODE_MAX_RECV_DLENGTH
;
1136 } else if (attr
== &dev_attr_fnode_max_xmit_dlength
.attr
) {
1137 param
= ISCSI_FLASHNODE_MAX_XMIT_DLENGTH
;
1138 } else if (attr
== &dev_attr_fnode_keepalive_tmo
.attr
) {
1139 param
= ISCSI_FLASHNODE_KEEPALIVE_TMO
;
1140 } else if (attr
== &dev_attr_fnode_port
.attr
) {
1141 param
= ISCSI_FLASHNODE_PORT
;
1142 } else if (attr
== &dev_attr_fnode_ipaddress
.attr
) {
1143 param
= ISCSI_FLASHNODE_IPADDR
;
1144 } else if (attr
== &dev_attr_fnode_redirect_ipaddr
.attr
) {
1145 param
= ISCSI_FLASHNODE_REDIRECT_IPADDR
;
1146 } else if (attr
== &dev_attr_fnode_max_segment_size
.attr
) {
1147 param
= ISCSI_FLASHNODE_MAX_SEGMENT_SIZE
;
1148 } else if (attr
== &dev_attr_fnode_local_port
.attr
) {
1149 param
= ISCSI_FLASHNODE_LOCAL_PORT
;
1150 } else if (attr
== &dev_attr_fnode_ipv4_tos
.attr
) {
1151 param
= ISCSI_FLASHNODE_IPV4_TOS
;
1152 } else if (attr
== &dev_attr_fnode_ipv6_traffic_class
.attr
) {
1153 param
= ISCSI_FLASHNODE_IPV6_TC
;
1154 } else if (attr
== &dev_attr_fnode_ipv6_flow_label
.attr
) {
1155 param
= ISCSI_FLASHNODE_IPV6_FLOW_LABEL
;
1156 } else if (attr
== &dev_attr_fnode_link_local_ipv6
.attr
) {
1157 param
= ISCSI_FLASHNODE_LINK_LOCAL_IPV6
;
1158 } else if (attr
== &dev_attr_fnode_tcp_xmit_wsf
.attr
) {
1159 param
= ISCSI_FLASHNODE_TCP_XMIT_WSF
;
1160 } else if (attr
== &dev_attr_fnode_tcp_recv_wsf
.attr
) {
1161 param
= ISCSI_FLASHNODE_TCP_RECV_WSF
;
1162 } else if (attr
== &dev_attr_fnode_statsn
.attr
) {
1163 param
= ISCSI_FLASHNODE_STATSN
;
1164 } else if (attr
== &dev_attr_fnode_exp_statsn
.attr
) {
1165 param
= ISCSI_FLASHNODE_EXP_STATSN
;
1167 WARN_ONCE(1, "Invalid flashnode connection attr");
1171 return t
->attr_is_visible(ISCSI_FLASHNODE_PARAM
, param
);
1174 static struct attribute_group iscsi_flashnode_conn_attr_group
= {
1175 .attrs
= iscsi_flashnode_conn_attrs
,
1176 .is_visible
= iscsi_flashnode_conn_attr_is_visible
,
1179 static const struct attribute_group
*iscsi_flashnode_conn_attr_groups
[] = {
1180 &iscsi_flashnode_conn_attr_group
,
1184 static void iscsi_flashnode_conn_release(struct device
*dev
)
1186 struct iscsi_bus_flash_conn
*fnode_conn
= iscsi_dev_to_flash_conn(dev
);
1188 kfree(fnode_conn
->ipaddress
);
1189 kfree(fnode_conn
->redirect_ipaddr
);
1190 kfree(fnode_conn
->link_local_ipv6_addr
);
1194 static const struct device_type iscsi_flashnode_conn_dev_type
= {
1195 .name
= "iscsi_flashnode_conn_dev_type",
1196 .groups
= iscsi_flashnode_conn_attr_groups
,
1197 .release
= iscsi_flashnode_conn_release
,
1200 static struct bus_type iscsi_flashnode_bus
;
1202 int iscsi_flashnode_bus_match(struct device
*dev
,
1203 struct device_driver
*drv
)
1205 if (dev
->bus
== &iscsi_flashnode_bus
)
1209 EXPORT_SYMBOL_GPL(iscsi_flashnode_bus_match
);
1211 static struct bus_type iscsi_flashnode_bus
= {
1212 .name
= "iscsi_flashnode",
1213 .match
= &iscsi_flashnode_bus_match
,
1217 * iscsi_create_flashnode_sess - Add flashnode session entry in sysfs
1218 * @shost: pointer to host data
1219 * @index: index of flashnode to add in sysfs
1220 * @transport: pointer to transport data
1221 * @dd_size: total size to allocate
1223 * Adds a sysfs entry for the flashnode session attributes
1226 * pointer to allocated flashnode sess on success
1229 struct iscsi_bus_flash_session
*
1230 iscsi_create_flashnode_sess(struct Scsi_Host
*shost
, int index
,
1231 struct iscsi_transport
*transport
,
1234 struct iscsi_bus_flash_session
*fnode_sess
;
1237 fnode_sess
= kzalloc(sizeof(*fnode_sess
) + dd_size
, GFP_KERNEL
);
1241 fnode_sess
->transport
= transport
;
1242 fnode_sess
->target_id
= index
;
1243 fnode_sess
->dev
.type
= &iscsi_flashnode_sess_dev_type
;
1244 fnode_sess
->dev
.bus
= &iscsi_flashnode_bus
;
1245 fnode_sess
->dev
.parent
= &shost
->shost_gendev
;
1246 dev_set_name(&fnode_sess
->dev
, "flashnode_sess-%u:%u",
1247 shost
->host_no
, index
);
1249 err
= device_register(&fnode_sess
->dev
);
1251 goto free_fnode_sess
;
1254 fnode_sess
->dd_data
= &fnode_sess
[1];
1262 EXPORT_SYMBOL_GPL(iscsi_create_flashnode_sess
);
1265 * iscsi_create_flashnode_conn - Add flashnode conn entry in sysfs
1266 * @shost: pointer to host data
1267 * @fnode_sess: pointer to the parent flashnode session entry
1268 * @transport: pointer to transport data
1269 * @dd_size: total size to allocate
1271 * Adds a sysfs entry for the flashnode connection attributes
1274 * pointer to allocated flashnode conn on success
1277 struct iscsi_bus_flash_conn
*
1278 iscsi_create_flashnode_conn(struct Scsi_Host
*shost
,
1279 struct iscsi_bus_flash_session
*fnode_sess
,
1280 struct iscsi_transport
*transport
,
1283 struct iscsi_bus_flash_conn
*fnode_conn
;
1286 fnode_conn
= kzalloc(sizeof(*fnode_conn
) + dd_size
, GFP_KERNEL
);
1290 fnode_conn
->transport
= transport
;
1291 fnode_conn
->dev
.type
= &iscsi_flashnode_conn_dev_type
;
1292 fnode_conn
->dev
.bus
= &iscsi_flashnode_bus
;
1293 fnode_conn
->dev
.parent
= &fnode_sess
->dev
;
1294 dev_set_name(&fnode_conn
->dev
, "flashnode_conn-%u:%u:0",
1295 shost
->host_no
, fnode_sess
->target_id
);
1297 err
= device_register(&fnode_conn
->dev
);
1299 goto free_fnode_conn
;
1302 fnode_conn
->dd_data
= &fnode_conn
[1];
1310 EXPORT_SYMBOL_GPL(iscsi_create_flashnode_conn
);
1313 * iscsi_is_flashnode_conn_dev - verify passed device is to be flashnode conn
1314 * @dev: device to verify
1315 * @data: pointer to data containing value to use for verification
1317 * Verifies if the passed device is flashnode conn device
1323 static int iscsi_is_flashnode_conn_dev(struct device
*dev
, void *data
)
1325 return dev
->bus
== &iscsi_flashnode_bus
;
1328 static int iscsi_destroy_flashnode_conn(struct iscsi_bus_flash_conn
*fnode_conn
)
1330 device_unregister(&fnode_conn
->dev
);
1334 static int flashnode_match_index(struct device
*dev
, void *data
)
1336 struct iscsi_bus_flash_session
*fnode_sess
= NULL
;
1339 if (!iscsi_flashnode_bus_match(dev
, NULL
))
1340 goto exit_match_index
;
1342 fnode_sess
= iscsi_dev_to_flash_session(dev
);
1343 ret
= (fnode_sess
->target_id
== *((int *)data
)) ? 1 : 0;
1350 * iscsi_get_flashnode_by_index -finds flashnode session entry by index
1351 * @shost: pointer to host data
1352 * @idx: index to match
1354 * Finds the flashnode session object for the passed index
1357 * pointer to found flashnode session object on success
1360 static struct iscsi_bus_flash_session
*
1361 iscsi_get_flashnode_by_index(struct Scsi_Host
*shost
, uint32_t idx
)
1363 struct iscsi_bus_flash_session
*fnode_sess
= NULL
;
1366 dev
= device_find_child(&shost
->shost_gendev
, &idx
,
1367 flashnode_match_index
);
1369 fnode_sess
= iscsi_dev_to_flash_session(dev
);
1375 * iscsi_find_flashnode_sess - finds flashnode session entry
1376 * @shost: pointer to host data
1377 * @data: pointer to data containing value to use for comparison
1378 * @fn: function pointer that does actual comparison
1380 * Finds the flashnode session object comparing the data passed using logic
1381 * defined in passed function pointer
1384 * pointer to found flashnode session device object on success
1388 iscsi_find_flashnode_sess(struct Scsi_Host
*shost
, void *data
,
1389 int (*fn
)(struct device
*dev
, void *data
))
1391 return device_find_child(&shost
->shost_gendev
, data
, fn
);
1393 EXPORT_SYMBOL_GPL(iscsi_find_flashnode_sess
);
1396 * iscsi_find_flashnode_conn - finds flashnode connection entry
1397 * @fnode_sess: pointer to parent flashnode session entry
1399 * Finds the flashnode connection object comparing the data passed using logic
1400 * defined in passed function pointer
1403 * pointer to found flashnode connection device object on success
1407 iscsi_find_flashnode_conn(struct iscsi_bus_flash_session
*fnode_sess
)
1409 return device_find_child(&fnode_sess
->dev
, NULL
,
1410 iscsi_is_flashnode_conn_dev
);
1412 EXPORT_SYMBOL_GPL(iscsi_find_flashnode_conn
);
1414 static int iscsi_iter_destroy_flashnode_conn_fn(struct device
*dev
, void *data
)
1416 if (!iscsi_is_flashnode_conn_dev(dev
, NULL
))
1419 return iscsi_destroy_flashnode_conn(iscsi_dev_to_flash_conn(dev
));
1423 * iscsi_destroy_flashnode_sess - destroy flashnode session entry
1424 * @fnode_sess: pointer to flashnode session entry to be destroyed
1426 * Deletes the flashnode session entry and all children flashnode connection
1427 * entries from sysfs
1429 void iscsi_destroy_flashnode_sess(struct iscsi_bus_flash_session
*fnode_sess
)
1433 err
= device_for_each_child(&fnode_sess
->dev
, NULL
,
1434 iscsi_iter_destroy_flashnode_conn_fn
);
1436 pr_err("Could not delete all connections for %s. Error %d.\n",
1437 fnode_sess
->dev
.kobj
.name
, err
);
1439 device_unregister(&fnode_sess
->dev
);
1441 EXPORT_SYMBOL_GPL(iscsi_destroy_flashnode_sess
);
1443 static int iscsi_iter_destroy_flashnode_fn(struct device
*dev
, void *data
)
1445 if (!iscsi_flashnode_bus_match(dev
, NULL
))
1448 iscsi_destroy_flashnode_sess(iscsi_dev_to_flash_session(dev
));
1453 * iscsi_destroy_all_flashnode - destroy all flashnode session entries
1454 * @shost: pointer to host data
1456 * Destroys all the flashnode session entries and all corresponding children
1457 * flashnode connection entries from sysfs
1459 void iscsi_destroy_all_flashnode(struct Scsi_Host
*shost
)
1461 device_for_each_child(&shost
->shost_gendev
, NULL
,
1462 iscsi_iter_destroy_flashnode_fn
);
1464 EXPORT_SYMBOL_GPL(iscsi_destroy_all_flashnode
);
1470 * iscsi_bsg_host_dispatch - Dispatch command to LLD.
1471 * @job: bsg job to be processed
1473 static int iscsi_bsg_host_dispatch(struct bsg_job
*job
)
1475 struct Scsi_Host
*shost
= iscsi_job_to_shost(job
);
1476 struct iscsi_bsg_request
*req
= job
->request
;
1477 struct iscsi_bsg_reply
*reply
= job
->reply
;
1478 struct iscsi_internal
*i
= to_iscsi_internal(shost
->transportt
);
1479 int cmdlen
= sizeof(uint32_t); /* start with length of msgcode */
1482 /* check if we have the msgcode value at least */
1483 if (job
->request_len
< sizeof(uint32_t)) {
1488 /* Validate the host command */
1489 switch (req
->msgcode
) {
1490 case ISCSI_BSG_HST_VENDOR
:
1491 cmdlen
+= sizeof(struct iscsi_bsg_host_vendor
);
1492 if ((shost
->hostt
->vendor_id
== 0L) ||
1493 (req
->rqst_data
.h_vendor
.vendor_id
!=
1494 shost
->hostt
->vendor_id
)) {
1504 /* check if we really have all the request data needed */
1505 if (job
->request_len
< cmdlen
) {
1510 ret
= i
->iscsi_transport
->bsg_request(job
);
1515 /* return the errno failure code as the only status */
1516 BUG_ON(job
->reply_len
< sizeof(uint32_t));
1517 reply
->reply_payload_rcv_len
= 0;
1518 reply
->result
= ret
;
1519 job
->reply_len
= sizeof(uint32_t);
1520 bsg_job_done(job
, ret
, 0);
1525 * iscsi_bsg_host_add - Create and add the bsg hooks to receive requests
1526 * @shost: shost for iscsi_host
1527 * @ihost: iscsi_cls_host adding the structures to
1530 iscsi_bsg_host_add(struct Scsi_Host
*shost
, struct iscsi_cls_host
*ihost
)
1532 struct device
*dev
= &shost
->shost_gendev
;
1533 struct iscsi_internal
*i
= to_iscsi_internal(shost
->transportt
);
1534 struct request_queue
*q
;
1537 if (!i
->iscsi_transport
->bsg_request
)
1540 snprintf(bsg_name
, sizeof(bsg_name
), "iscsi_host%d", shost
->host_no
);
1541 q
= bsg_setup_queue(dev
, bsg_name
, iscsi_bsg_host_dispatch
, NULL
, 0);
1543 shost_printk(KERN_ERR
, shost
, "bsg interface failed to "
1544 "initialize - no request queue\n");
1547 __scsi_init_queue(shost
, q
);
1553 static int iscsi_setup_host(struct transport_container
*tc
, struct device
*dev
,
1554 struct device
*cdev
)
1556 struct Scsi_Host
*shost
= dev_to_shost(dev
);
1557 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
1559 memset(ihost
, 0, sizeof(*ihost
));
1560 atomic_set(&ihost
->nr_scans
, 0);
1561 mutex_init(&ihost
->mutex
);
1563 iscsi_bsg_host_add(shost
, ihost
);
1564 /* ignore any bsg add error - we just can't do sgio */
1569 static int iscsi_remove_host(struct transport_container
*tc
,
1570 struct device
*dev
, struct device
*cdev
)
1572 struct Scsi_Host
*shost
= dev_to_shost(dev
);
1573 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
1575 bsg_remove_queue(ihost
->bsg_q
);
1579 static DECLARE_TRANSPORT_CLASS(iscsi_host_class
,
1585 static DECLARE_TRANSPORT_CLASS(iscsi_session_class
,
1591 static DECLARE_TRANSPORT_CLASS(iscsi_connection_class
,
1597 static struct sock
*nls
;
1598 static DEFINE_MUTEX(rx_queue_mutex
);
1600 static LIST_HEAD(sesslist
);
1601 static DEFINE_SPINLOCK(sesslock
);
1602 static LIST_HEAD(connlist
);
1603 static LIST_HEAD(connlist_err
);
1604 static DEFINE_SPINLOCK(connlock
);
1606 static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn
*conn
)
1608 struct iscsi_cls_session
*sess
= iscsi_dev_to_session(conn
->dev
.parent
);
1613 * Returns the matching session to a given sid
1615 static struct iscsi_cls_session
*iscsi_session_lookup(uint32_t sid
)
1617 unsigned long flags
;
1618 struct iscsi_cls_session
*sess
;
1620 spin_lock_irqsave(&sesslock
, flags
);
1621 list_for_each_entry(sess
, &sesslist
, sess_list
) {
1622 if (sess
->sid
== sid
) {
1623 spin_unlock_irqrestore(&sesslock
, flags
);
1627 spin_unlock_irqrestore(&sesslock
, flags
);
1632 * Returns the matching connection to a given sid / cid tuple
1634 static struct iscsi_cls_conn
*iscsi_conn_lookup(uint32_t sid
, uint32_t cid
)
1636 unsigned long flags
;
1637 struct iscsi_cls_conn
*conn
;
1639 spin_lock_irqsave(&connlock
, flags
);
1640 list_for_each_entry(conn
, &connlist
, conn_list
) {
1641 if ((conn
->cid
== cid
) && (iscsi_conn_get_sid(conn
) == sid
)) {
1642 spin_unlock_irqrestore(&connlock
, flags
);
1646 spin_unlock_irqrestore(&connlock
, flags
);
1651 * The following functions can be used by LLDs that allocate
1652 * their own scsi_hosts or by software iscsi LLDs
1657 } iscsi_session_state_names
[] = {
1658 { ISCSI_SESSION_LOGGED_IN
, "LOGGED_IN" },
1659 { ISCSI_SESSION_FAILED
, "FAILED" },
1660 { ISCSI_SESSION_FREE
, "FREE" },
1663 static const char *iscsi_session_state_name(int state
)
1668 for (i
= 0; i
< ARRAY_SIZE(iscsi_session_state_names
); i
++) {
1669 if (iscsi_session_state_names
[i
].value
== state
) {
1670 name
= iscsi_session_state_names
[i
].name
;
1677 int iscsi_session_chkready(struct iscsi_cls_session
*session
)
1681 switch (session
->state
) {
1682 case ISCSI_SESSION_LOGGED_IN
:
1685 case ISCSI_SESSION_FAILED
:
1686 err
= DID_IMM_RETRY
<< 16;
1688 case ISCSI_SESSION_FREE
:
1689 err
= DID_TRANSPORT_FAILFAST
<< 16;
1692 err
= DID_NO_CONNECT
<< 16;
1697 EXPORT_SYMBOL_GPL(iscsi_session_chkready
);
1699 int iscsi_is_session_online(struct iscsi_cls_session
*session
)
1701 unsigned long flags
;
1704 spin_lock_irqsave(&session
->lock
, flags
);
1705 if (session
->state
== ISCSI_SESSION_LOGGED_IN
)
1707 spin_unlock_irqrestore(&session
->lock
, flags
);
1710 EXPORT_SYMBOL_GPL(iscsi_is_session_online
);
1712 static void iscsi_session_release(struct device
*dev
)
1714 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
);
1715 struct Scsi_Host
*shost
;
1717 shost
= iscsi_session_to_shost(session
);
1718 scsi_host_put(shost
);
1719 ISCSI_DBG_TRANS_SESSION(session
, "Completing session release\n");
1723 int iscsi_is_session_dev(const struct device
*dev
)
1725 return dev
->release
== iscsi_session_release
;
1727 EXPORT_SYMBOL_GPL(iscsi_is_session_dev
);
1729 static int iscsi_iter_session_fn(struct device
*dev
, void *data
)
1731 void (* fn
) (struct iscsi_cls_session
*) = data
;
1733 if (!iscsi_is_session_dev(dev
))
1735 fn(iscsi_dev_to_session(dev
));
1739 void iscsi_host_for_each_session(struct Scsi_Host
*shost
,
1740 void (*fn
)(struct iscsi_cls_session
*))
1742 device_for_each_child(&shost
->shost_gendev
, fn
,
1743 iscsi_iter_session_fn
);
1745 EXPORT_SYMBOL_GPL(iscsi_host_for_each_session
);
1748 * iscsi_scan_finished - helper to report when running scans are done
1750 * @time: scan run time
1752 * This function can be used by drives like qla4xxx to report to the scsi
1753 * layer when the scans it kicked off at module load time are done.
1755 int iscsi_scan_finished(struct Scsi_Host
*shost
, unsigned long time
)
1757 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
1759 * qla4xxx will have kicked off some session unblocks before calling
1760 * scsi_scan_host, so just wait for them to complete.
1762 return !atomic_read(&ihost
->nr_scans
);
1764 EXPORT_SYMBOL_GPL(iscsi_scan_finished
);
1766 struct iscsi_scan_data
{
1767 unsigned int channel
;
1770 enum scsi_scan_mode rescan
;
1773 static int iscsi_user_scan_session(struct device
*dev
, void *data
)
1775 struct iscsi_scan_data
*scan_data
= data
;
1776 struct iscsi_cls_session
*session
;
1777 struct Scsi_Host
*shost
;
1778 struct iscsi_cls_host
*ihost
;
1779 unsigned long flags
;
1782 if (!iscsi_is_session_dev(dev
))
1785 session
= iscsi_dev_to_session(dev
);
1787 ISCSI_DBG_TRANS_SESSION(session
, "Scanning session\n");
1789 shost
= iscsi_session_to_shost(session
);
1790 ihost
= shost
->shost_data
;
1792 mutex_lock(&ihost
->mutex
);
1793 spin_lock_irqsave(&session
->lock
, flags
);
1794 if (session
->state
!= ISCSI_SESSION_LOGGED_IN
) {
1795 spin_unlock_irqrestore(&session
->lock
, flags
);
1796 goto user_scan_exit
;
1798 id
= session
->target_id
;
1799 spin_unlock_irqrestore(&session
->lock
, flags
);
1801 if (id
!= ISCSI_MAX_TARGET
) {
1802 if ((scan_data
->channel
== SCAN_WILD_CARD
||
1803 scan_data
->channel
== 0) &&
1804 (scan_data
->id
== SCAN_WILD_CARD
||
1805 scan_data
->id
== id
))
1806 scsi_scan_target(&session
->dev
, 0, id
,
1807 scan_data
->lun
, scan_data
->rescan
);
1811 mutex_unlock(&ihost
->mutex
);
1812 ISCSI_DBG_TRANS_SESSION(session
, "Completed session scan\n");
1816 static int iscsi_user_scan(struct Scsi_Host
*shost
, uint channel
,
1819 struct iscsi_scan_data scan_data
;
1821 scan_data
.channel
= channel
;
1823 scan_data
.lun
= lun
;
1824 scan_data
.rescan
= SCSI_SCAN_MANUAL
;
1826 return device_for_each_child(&shost
->shost_gendev
, &scan_data
,
1827 iscsi_user_scan_session
);
1830 static void iscsi_scan_session(struct work_struct
*work
)
1832 struct iscsi_cls_session
*session
=
1833 container_of(work
, struct iscsi_cls_session
, scan_work
);
1834 struct Scsi_Host
*shost
= iscsi_session_to_shost(session
);
1835 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
1836 struct iscsi_scan_data scan_data
;
1838 scan_data
.channel
= 0;
1839 scan_data
.id
= SCAN_WILD_CARD
;
1840 scan_data
.lun
= SCAN_WILD_CARD
;
1841 scan_data
.rescan
= SCSI_SCAN_RESCAN
;
1843 iscsi_user_scan_session(&session
->dev
, &scan_data
);
1844 atomic_dec(&ihost
->nr_scans
);
1848 * iscsi_block_scsi_eh - block scsi eh until session state has transistioned
1849 * @cmd: scsi cmd passed to scsi eh handler
1851 * If the session is down this function will wait for the recovery
1852 * timer to fire or for the session to be logged back in. If the
1853 * recovery timer fires then FAST_IO_FAIL is returned. The caller
1854 * should pass this error value to the scsi eh.
1856 int iscsi_block_scsi_eh(struct scsi_cmnd
*cmd
)
1858 struct iscsi_cls_session
*session
=
1859 starget_to_session(scsi_target(cmd
->device
));
1860 unsigned long flags
;
1863 spin_lock_irqsave(&session
->lock
, flags
);
1864 while (session
->state
!= ISCSI_SESSION_LOGGED_IN
) {
1865 if (session
->state
== ISCSI_SESSION_FREE
) {
1869 spin_unlock_irqrestore(&session
->lock
, flags
);
1871 spin_lock_irqsave(&session
->lock
, flags
);
1873 spin_unlock_irqrestore(&session
->lock
, flags
);
1876 EXPORT_SYMBOL_GPL(iscsi_block_scsi_eh
);
1878 static void session_recovery_timedout(struct work_struct
*work
)
1880 struct iscsi_cls_session
*session
=
1881 container_of(work
, struct iscsi_cls_session
,
1882 recovery_work
.work
);
1883 unsigned long flags
;
1885 iscsi_cls_session_printk(KERN_INFO
, session
,
1886 "session recovery timed out after %d secs\n",
1887 session
->recovery_tmo
);
1889 spin_lock_irqsave(&session
->lock
, flags
);
1890 switch (session
->state
) {
1891 case ISCSI_SESSION_FAILED
:
1892 session
->state
= ISCSI_SESSION_FREE
;
1894 case ISCSI_SESSION_LOGGED_IN
:
1895 case ISCSI_SESSION_FREE
:
1896 /* we raced with the unblock's flush */
1897 spin_unlock_irqrestore(&session
->lock
, flags
);
1900 spin_unlock_irqrestore(&session
->lock
, flags
);
1902 if (session
->transport
->session_recovery_timedout
)
1903 session
->transport
->session_recovery_timedout(session
);
1905 ISCSI_DBG_TRANS_SESSION(session
, "Unblocking SCSI target\n");
1906 scsi_target_unblock(&session
->dev
, SDEV_TRANSPORT_OFFLINE
);
1907 ISCSI_DBG_TRANS_SESSION(session
, "Completed unblocking SCSI target\n");
1910 static void __iscsi_unblock_session(struct work_struct
*work
)
1912 struct iscsi_cls_session
*session
=
1913 container_of(work
, struct iscsi_cls_session
,
1915 struct Scsi_Host
*shost
= iscsi_session_to_shost(session
);
1916 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
1917 unsigned long flags
;
1919 ISCSI_DBG_TRANS_SESSION(session
, "Unblocking session\n");
1921 * The recovery and unblock work get run from the same workqueue,
1922 * so try to cancel it if it was going to run after this unblock.
1924 cancel_delayed_work(&session
->recovery_work
);
1925 spin_lock_irqsave(&session
->lock
, flags
);
1926 session
->state
= ISCSI_SESSION_LOGGED_IN
;
1927 spin_unlock_irqrestore(&session
->lock
, flags
);
1929 scsi_target_unblock(&session
->dev
, SDEV_RUNNING
);
1931 * Only do kernel scanning if the driver is properly hooked into
1932 * the async scanning code (drivers like iscsi_tcp do login and
1933 * scanning from userspace).
1935 if (shost
->hostt
->scan_finished
) {
1936 if (scsi_queue_work(shost
, &session
->scan_work
))
1937 atomic_inc(&ihost
->nr_scans
);
1939 ISCSI_DBG_TRANS_SESSION(session
, "Completed unblocking session\n");
1943 * iscsi_unblock_session - set a session as logged in and start IO.
1944 * @session: iscsi session
1946 * Mark a session as ready to accept IO.
1948 void iscsi_unblock_session(struct iscsi_cls_session
*session
)
1950 flush_work(&session
->block_work
);
1952 queue_work(iscsi_eh_timer_workq
, &session
->unblock_work
);
1954 * Blocking the session can be done from any context so we only
1955 * queue the block work. Make sure the unblock work has completed
1956 * because it flushes/cancels the other works and updates the state.
1958 flush_work(&session
->unblock_work
);
1960 EXPORT_SYMBOL_GPL(iscsi_unblock_session
);
1962 static void __iscsi_block_session(struct work_struct
*work
)
1964 struct iscsi_cls_session
*session
=
1965 container_of(work
, struct iscsi_cls_session
,
1967 unsigned long flags
;
1969 ISCSI_DBG_TRANS_SESSION(session
, "Blocking session\n");
1970 spin_lock_irqsave(&session
->lock
, flags
);
1971 session
->state
= ISCSI_SESSION_FAILED
;
1972 spin_unlock_irqrestore(&session
->lock
, flags
);
1973 scsi_target_block(&session
->dev
);
1974 ISCSI_DBG_TRANS_SESSION(session
, "Completed SCSI target blocking\n");
1975 if (session
->recovery_tmo
>= 0)
1976 queue_delayed_work(iscsi_eh_timer_workq
,
1977 &session
->recovery_work
,
1978 session
->recovery_tmo
* HZ
);
1981 void iscsi_block_session(struct iscsi_cls_session
*session
)
1983 queue_work(iscsi_eh_timer_workq
, &session
->block_work
);
1985 EXPORT_SYMBOL_GPL(iscsi_block_session
);
1987 static void __iscsi_unbind_session(struct work_struct
*work
)
1989 struct iscsi_cls_session
*session
=
1990 container_of(work
, struct iscsi_cls_session
,
1992 struct Scsi_Host
*shost
= iscsi_session_to_shost(session
);
1993 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
1994 unsigned long flags
;
1995 unsigned int target_id
;
1997 ISCSI_DBG_TRANS_SESSION(session
, "Unbinding session\n");
1999 /* Prevent new scans and make sure scanning is not in progress */
2000 mutex_lock(&ihost
->mutex
);
2001 spin_lock_irqsave(&session
->lock
, flags
);
2002 if (session
->target_id
== ISCSI_MAX_TARGET
) {
2003 spin_unlock_irqrestore(&session
->lock
, flags
);
2004 mutex_unlock(&ihost
->mutex
);
2005 goto unbind_session_exit
;
2008 target_id
= session
->target_id
;
2009 session
->target_id
= ISCSI_MAX_TARGET
;
2010 spin_unlock_irqrestore(&session
->lock
, flags
);
2011 mutex_unlock(&ihost
->mutex
);
2013 scsi_remove_target(&session
->dev
);
2015 if (session
->ida_used
)
2016 ida_simple_remove(&iscsi_sess_ida
, target_id
);
2018 unbind_session_exit
:
2019 iscsi_session_event(session
, ISCSI_KEVENT_UNBIND_SESSION
);
2020 ISCSI_DBG_TRANS_SESSION(session
, "Completed target removal\n");
2023 static void __iscsi_destroy_session(struct work_struct
*work
)
2025 struct iscsi_cls_session
*session
=
2026 container_of(work
, struct iscsi_cls_session
, destroy_work
);
2028 session
->transport
->destroy_session(session
);
2031 struct iscsi_cls_session
*
2032 iscsi_alloc_session(struct Scsi_Host
*shost
, struct iscsi_transport
*transport
,
2035 struct iscsi_cls_session
*session
;
2037 session
= kzalloc(sizeof(*session
) + dd_size
,
2042 session
->transport
= transport
;
2043 session
->creator
= -1;
2044 session
->recovery_tmo
= 120;
2045 session
->recovery_tmo_sysfs_override
= false;
2046 session
->state
= ISCSI_SESSION_FREE
;
2047 INIT_DELAYED_WORK(&session
->recovery_work
, session_recovery_timedout
);
2048 INIT_LIST_HEAD(&session
->sess_list
);
2049 INIT_WORK(&session
->unblock_work
, __iscsi_unblock_session
);
2050 INIT_WORK(&session
->block_work
, __iscsi_block_session
);
2051 INIT_WORK(&session
->unbind_work
, __iscsi_unbind_session
);
2052 INIT_WORK(&session
->scan_work
, iscsi_scan_session
);
2053 INIT_WORK(&session
->destroy_work
, __iscsi_destroy_session
);
2054 spin_lock_init(&session
->lock
);
2056 /* this is released in the dev's release function */
2057 scsi_host_get(shost
);
2058 session
->dev
.parent
= &shost
->shost_gendev
;
2059 session
->dev
.release
= iscsi_session_release
;
2060 device_initialize(&session
->dev
);
2062 session
->dd_data
= &session
[1];
2064 ISCSI_DBG_TRANS_SESSION(session
, "Completed session allocation\n");
2067 EXPORT_SYMBOL_GPL(iscsi_alloc_session
);
2069 int iscsi_add_session(struct iscsi_cls_session
*session
, unsigned int target_id
)
2071 unsigned long flags
;
2075 session
->sid
= atomic_add_return(1, &iscsi_session_nr
);
2077 if (target_id
== ISCSI_MAX_TARGET
) {
2078 id
= ida_simple_get(&iscsi_sess_ida
, 0, 0, GFP_KERNEL
);
2081 iscsi_cls_session_printk(KERN_ERR
, session
,
2082 "Failure in Target ID Allocation\n");
2085 session
->target_id
= (unsigned int)id
;
2086 session
->ida_used
= true;
2088 session
->target_id
= target_id
;
2090 dev_set_name(&session
->dev
, "session%u", session
->sid
);
2091 err
= device_add(&session
->dev
);
2093 iscsi_cls_session_printk(KERN_ERR
, session
,
2094 "could not register session's dev\n");
2097 err
= transport_register_device(&session
->dev
);
2099 iscsi_cls_session_printk(KERN_ERR
, session
,
2100 "could not register transport's dev\n");
2104 spin_lock_irqsave(&sesslock
, flags
);
2105 list_add(&session
->sess_list
, &sesslist
);
2106 spin_unlock_irqrestore(&sesslock
, flags
);
2108 iscsi_session_event(session
, ISCSI_KEVENT_CREATE_SESSION
);
2109 ISCSI_DBG_TRANS_SESSION(session
, "Completed session adding\n");
2113 device_del(&session
->dev
);
2115 if (session
->ida_used
)
2116 ida_simple_remove(&iscsi_sess_ida
, session
->target_id
);
2120 EXPORT_SYMBOL_GPL(iscsi_add_session
);
2123 * iscsi_create_session - create iscsi class session
2125 * @transport: iscsi transport
2126 * @dd_size: private driver data size
2127 * @target_id: which target
2129 * This can be called from a LLD or iscsi_transport.
2131 struct iscsi_cls_session
*
2132 iscsi_create_session(struct Scsi_Host
*shost
, struct iscsi_transport
*transport
,
2133 int dd_size
, unsigned int target_id
)
2135 struct iscsi_cls_session
*session
;
2137 session
= iscsi_alloc_session(shost
, transport
, dd_size
);
2141 if (iscsi_add_session(session
, target_id
)) {
2142 iscsi_free_session(session
);
2147 EXPORT_SYMBOL_GPL(iscsi_create_session
);
2149 static void iscsi_conn_release(struct device
*dev
)
2151 struct iscsi_cls_conn
*conn
= iscsi_dev_to_conn(dev
);
2152 struct device
*parent
= conn
->dev
.parent
;
2154 ISCSI_DBG_TRANS_CONN(conn
, "Releasing conn\n");
2159 static int iscsi_is_conn_dev(const struct device
*dev
)
2161 return dev
->release
== iscsi_conn_release
;
2164 static int iscsi_iter_destroy_conn_fn(struct device
*dev
, void *data
)
2166 if (!iscsi_is_conn_dev(dev
))
2168 return iscsi_destroy_conn(iscsi_dev_to_conn(dev
));
2171 void iscsi_remove_session(struct iscsi_cls_session
*session
)
2173 unsigned long flags
;
2176 ISCSI_DBG_TRANS_SESSION(session
, "Removing session\n");
2178 spin_lock_irqsave(&sesslock
, flags
);
2179 if (!list_empty(&session
->sess_list
))
2180 list_del(&session
->sess_list
);
2181 spin_unlock_irqrestore(&sesslock
, flags
);
2183 flush_work(&session
->block_work
);
2184 flush_work(&session
->unblock_work
);
2185 cancel_delayed_work_sync(&session
->recovery_work
);
2187 * If we are blocked let commands flow again. The lld or iscsi
2188 * layer should set up the queuecommand to fail commands.
2189 * We assume that LLD will not be calling block/unblock while
2190 * removing the session.
2192 spin_lock_irqsave(&session
->lock
, flags
);
2193 session
->state
= ISCSI_SESSION_FREE
;
2194 spin_unlock_irqrestore(&session
->lock
, flags
);
2196 scsi_target_unblock(&session
->dev
, SDEV_TRANSPORT_OFFLINE
);
2197 /* flush running scans then delete devices */
2198 flush_work(&session
->scan_work
);
2199 /* flush running unbind operations */
2200 flush_work(&session
->unbind_work
);
2201 __iscsi_unbind_session(&session
->unbind_work
);
2203 /* hw iscsi may not have removed all connections from session */
2204 err
= device_for_each_child(&session
->dev
, NULL
,
2205 iscsi_iter_destroy_conn_fn
);
2207 iscsi_cls_session_printk(KERN_ERR
, session
,
2208 "Could not delete all connections "
2209 "for session. Error %d.\n", err
);
2211 transport_unregister_device(&session
->dev
);
2213 ISCSI_DBG_TRANS_SESSION(session
, "Completing session removal\n");
2214 device_del(&session
->dev
);
2216 EXPORT_SYMBOL_GPL(iscsi_remove_session
);
2218 static void iscsi_stop_conn(struct iscsi_cls_conn
*conn
, int flag
)
2220 ISCSI_DBG_TRANS_CONN(conn
, "Stopping conn.\n");
2223 case STOP_CONN_RECOVER
:
2224 conn
->state
= ISCSI_CONN_FAILED
;
2226 case STOP_CONN_TERM
:
2227 conn
->state
= ISCSI_CONN_DOWN
;
2230 iscsi_cls_conn_printk(KERN_ERR
, conn
, "invalid stop flag %d\n",
2235 conn
->transport
->stop_conn(conn
, flag
);
2236 ISCSI_DBG_TRANS_CONN(conn
, "Stopping conn done.\n");
2239 static int iscsi_if_stop_conn(struct iscsi_transport
*transport
,
2240 struct iscsi_uevent
*ev
)
2242 int flag
= ev
->u
.stop_conn
.flag
;
2243 struct iscsi_cls_conn
*conn
;
2245 conn
= iscsi_conn_lookup(ev
->u
.stop_conn
.sid
, ev
->u
.stop_conn
.cid
);
2249 ISCSI_DBG_TRANS_CONN(conn
, "iscsi if conn stop.\n");
2251 * If this is a termination we have to call stop_conn with that flag
2252 * so the correct states get set. If we haven't run the work yet try to
2253 * avoid the extra run.
2255 if (flag
== STOP_CONN_TERM
) {
2256 cancel_work_sync(&conn
->cleanup_work
);
2257 iscsi_stop_conn(conn
, flag
);
2260 * Figure out if it was the kernel or userspace initiating this.
2262 if (!test_and_set_bit(ISCSI_CLS_CONN_BIT_CLEANUP
, &conn
->flags
)) {
2263 iscsi_stop_conn(conn
, flag
);
2265 ISCSI_DBG_TRANS_CONN(conn
,
2266 "flush kernel conn cleanup.\n");
2267 flush_work(&conn
->cleanup_work
);
2270 * Only clear for recovery to avoid extra cleanup runs during
2273 clear_bit(ISCSI_CLS_CONN_BIT_CLEANUP
, &conn
->flags
);
2275 ISCSI_DBG_TRANS_CONN(conn
, "iscsi if conn stop done.\n");
2279 static void iscsi_ep_disconnect(struct iscsi_cls_conn
*conn
, bool is_active
)
2281 struct iscsi_cls_session
*session
= iscsi_conn_to_session(conn
);
2282 struct iscsi_endpoint
*ep
;
2284 ISCSI_DBG_TRANS_CONN(conn
, "disconnect ep.\n");
2285 conn
->state
= ISCSI_CONN_FAILED
;
2287 if (!conn
->ep
|| !session
->transport
->ep_disconnect
)
2293 session
->transport
->unbind_conn(conn
, is_active
);
2294 session
->transport
->ep_disconnect(ep
);
2295 ISCSI_DBG_TRANS_CONN(conn
, "disconnect ep done.\n");
2298 static void iscsi_cleanup_conn_work_fn(struct work_struct
*work
)
2300 struct iscsi_cls_conn
*conn
= container_of(work
, struct iscsi_cls_conn
,
2302 struct iscsi_cls_session
*session
= iscsi_conn_to_session(conn
);
2304 mutex_lock(&conn
->ep_mutex
);
2306 * If we are not at least bound there is nothing for us to do. Userspace
2307 * will do a ep_disconnect call if offload is used, but will not be
2308 * doing a stop since there is nothing to clean up, so we have to clear
2309 * the cleanup bit here.
2311 if (conn
->state
!= ISCSI_CONN_BOUND
&& conn
->state
!= ISCSI_CONN_UP
) {
2312 ISCSI_DBG_TRANS_CONN(conn
, "Got error while conn is already failed. Ignoring.\n");
2313 clear_bit(ISCSI_CLS_CONN_BIT_CLEANUP
, &conn
->flags
);
2314 mutex_unlock(&conn
->ep_mutex
);
2318 iscsi_ep_disconnect(conn
, false);
2320 if (system_state
!= SYSTEM_RUNNING
) {
2322 * If the user has set up for the session to never timeout
2323 * then hang like they wanted. For all other cases fail right
2324 * away since userspace is not going to relogin.
2326 if (session
->recovery_tmo
> 0)
2327 session
->recovery_tmo
= 0;
2330 iscsi_stop_conn(conn
, STOP_CONN_RECOVER
);
2331 mutex_unlock(&conn
->ep_mutex
);
2332 ISCSI_DBG_TRANS_CONN(conn
, "cleanup done.\n");
2335 void iscsi_free_session(struct iscsi_cls_session
*session
)
2337 ISCSI_DBG_TRANS_SESSION(session
, "Freeing session\n");
2338 iscsi_session_event(session
, ISCSI_KEVENT_DESTROY_SESSION
);
2339 put_device(&session
->dev
);
2341 EXPORT_SYMBOL_GPL(iscsi_free_session
);
2344 * iscsi_create_conn - create iscsi class connection
2345 * @session: iscsi cls session
2346 * @dd_size: private driver data size
2347 * @cid: connection id
2349 * This can be called from a LLD or iscsi_transport. The connection
2350 * is child of the session so cid must be unique for all connections
2353 * Since we do not support MCS, cid will normally be zero. In some cases
2354 * for software iscsi we could be trying to preallocate a connection struct
2355 * in which case there could be two connection structs and cid would be
2358 struct iscsi_cls_conn
*
2359 iscsi_create_conn(struct iscsi_cls_session
*session
, int dd_size
, uint32_t cid
)
2361 struct iscsi_transport
*transport
= session
->transport
;
2362 struct iscsi_cls_conn
*conn
;
2363 unsigned long flags
;
2366 conn
= kzalloc(sizeof(*conn
) + dd_size
, GFP_KERNEL
);
2370 conn
->dd_data
= &conn
[1];
2372 mutex_init(&conn
->ep_mutex
);
2373 INIT_LIST_HEAD(&conn
->conn_list
);
2374 INIT_WORK(&conn
->cleanup_work
, iscsi_cleanup_conn_work_fn
);
2375 conn
->transport
= transport
;
2377 conn
->state
= ISCSI_CONN_DOWN
;
2379 /* this is released in the dev's release function */
2380 if (!get_device(&session
->dev
))
2383 dev_set_name(&conn
->dev
, "connection%d:%u", session
->sid
, cid
);
2384 conn
->dev
.parent
= &session
->dev
;
2385 conn
->dev
.release
= iscsi_conn_release
;
2386 err
= device_register(&conn
->dev
);
2388 iscsi_cls_session_printk(KERN_ERR
, session
, "could not "
2389 "register connection's dev\n");
2390 goto release_parent_ref
;
2392 err
= transport_register_device(&conn
->dev
);
2394 iscsi_cls_session_printk(KERN_ERR
, session
, "could not "
2395 "register transport's dev\n");
2396 goto release_conn_ref
;
2399 spin_lock_irqsave(&connlock
, flags
);
2400 list_add(&conn
->conn_list
, &connlist
);
2401 spin_unlock_irqrestore(&connlock
, flags
);
2403 ISCSI_DBG_TRANS_CONN(conn
, "Completed conn creation\n");
2407 device_unregister(&conn
->dev
);
2408 put_device(&session
->dev
);
2411 put_device(&session
->dev
);
2417 EXPORT_SYMBOL_GPL(iscsi_create_conn
);
2420 * iscsi_destroy_conn - destroy iscsi class connection
2421 * @conn: iscsi cls session
2423 * This can be called from a LLD or iscsi_transport.
2425 int iscsi_destroy_conn(struct iscsi_cls_conn
*conn
)
2427 unsigned long flags
;
2429 spin_lock_irqsave(&connlock
, flags
);
2430 list_del(&conn
->conn_list
);
2431 spin_unlock_irqrestore(&connlock
, flags
);
2433 transport_unregister_device(&conn
->dev
);
2434 ISCSI_DBG_TRANS_CONN(conn
, "Completing conn destruction\n");
2435 device_unregister(&conn
->dev
);
2438 EXPORT_SYMBOL_GPL(iscsi_destroy_conn
);
2440 void iscsi_put_conn(struct iscsi_cls_conn
*conn
)
2442 put_device(&conn
->dev
);
2444 EXPORT_SYMBOL_GPL(iscsi_put_conn
);
2446 void iscsi_get_conn(struct iscsi_cls_conn
*conn
)
2448 get_device(&conn
->dev
);
2450 EXPORT_SYMBOL_GPL(iscsi_get_conn
);
2453 * iscsi interface functions
2455 static struct iscsi_internal
*
2456 iscsi_if_transport_lookup(struct iscsi_transport
*tt
)
2458 struct iscsi_internal
*priv
;
2459 unsigned long flags
;
2461 spin_lock_irqsave(&iscsi_transport_lock
, flags
);
2462 list_for_each_entry(priv
, &iscsi_transports
, list
) {
2463 if (tt
== priv
->iscsi_transport
) {
2464 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
2468 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
2473 iscsi_multicast_skb(struct sk_buff
*skb
, uint32_t group
, gfp_t gfp
)
2475 return nlmsg_multicast(nls
, skb
, 0, group
, gfp
);
2479 iscsi_unicast_skb(struct sk_buff
*skb
, u32 portid
)
2481 return nlmsg_unicast(nls
, skb
, portid
);
2484 int iscsi_recv_pdu(struct iscsi_cls_conn
*conn
, struct iscsi_hdr
*hdr
,
2485 char *data
, uint32_t data_size
)
2487 struct nlmsghdr
*nlh
;
2488 struct sk_buff
*skb
;
2489 struct iscsi_uevent
*ev
;
2491 struct iscsi_internal
*priv
;
2492 int len
= nlmsg_total_size(sizeof(*ev
) + sizeof(struct iscsi_hdr
) +
2495 priv
= iscsi_if_transport_lookup(conn
->transport
);
2499 skb
= alloc_skb(len
, GFP_ATOMIC
);
2501 iscsi_conn_error_event(conn
, ISCSI_ERR_CONN_FAILED
);
2502 iscsi_cls_conn_printk(KERN_ERR
, conn
, "can not deliver "
2503 "control PDU: OOM\n");
2507 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2508 ev
= nlmsg_data(nlh
);
2509 memset(ev
, 0, sizeof(*ev
));
2510 ev
->transport_handle
= iscsi_handle(conn
->transport
);
2511 ev
->type
= ISCSI_KEVENT_RECV_PDU
;
2512 ev
->r
.recv_req
.cid
= conn
->cid
;
2513 ev
->r
.recv_req
.sid
= iscsi_conn_get_sid(conn
);
2514 pdu
= (char*)ev
+ sizeof(*ev
);
2515 memcpy(pdu
, hdr
, sizeof(struct iscsi_hdr
));
2516 memcpy(pdu
+ sizeof(struct iscsi_hdr
), data
, data_size
);
2518 return iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_ATOMIC
);
2520 EXPORT_SYMBOL_GPL(iscsi_recv_pdu
);
2522 int iscsi_offload_mesg(struct Scsi_Host
*shost
,
2523 struct iscsi_transport
*transport
, uint32_t type
,
2524 char *data
, uint16_t data_size
)
2526 struct nlmsghdr
*nlh
;
2527 struct sk_buff
*skb
;
2528 struct iscsi_uevent
*ev
;
2529 int len
= nlmsg_total_size(sizeof(*ev
) + data_size
);
2531 skb
= alloc_skb(len
, GFP_ATOMIC
);
2533 printk(KERN_ERR
"can not deliver iscsi offload message:OOM\n");
2537 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2538 ev
= nlmsg_data(nlh
);
2539 memset(ev
, 0, sizeof(*ev
));
2541 ev
->transport_handle
= iscsi_handle(transport
);
2543 case ISCSI_KEVENT_PATH_REQ
:
2544 ev
->r
.req_path
.host_no
= shost
->host_no
;
2546 case ISCSI_KEVENT_IF_DOWN
:
2547 ev
->r
.notify_if_down
.host_no
= shost
->host_no
;
2551 memcpy((char *)ev
+ sizeof(*ev
), data
, data_size
);
2553 return iscsi_multicast_skb(skb
, ISCSI_NL_GRP_UIP
, GFP_ATOMIC
);
2555 EXPORT_SYMBOL_GPL(iscsi_offload_mesg
);
2557 void iscsi_conn_error_event(struct iscsi_cls_conn
*conn
, enum iscsi_err error
)
2559 struct nlmsghdr
*nlh
;
2560 struct sk_buff
*skb
;
2561 struct iscsi_uevent
*ev
;
2562 struct iscsi_internal
*priv
;
2563 int len
= nlmsg_total_size(sizeof(*ev
));
2565 if (!test_and_set_bit(ISCSI_CLS_CONN_BIT_CLEANUP
, &conn
->flags
))
2566 queue_work(iscsi_conn_cleanup_workq
, &conn
->cleanup_work
);
2568 priv
= iscsi_if_transport_lookup(conn
->transport
);
2572 skb
= alloc_skb(len
, GFP_ATOMIC
);
2574 iscsi_cls_conn_printk(KERN_ERR
, conn
, "gracefully ignored "
2575 "conn error (%d)\n", error
);
2579 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2580 ev
= nlmsg_data(nlh
);
2581 ev
->transport_handle
= iscsi_handle(conn
->transport
);
2582 ev
->type
= ISCSI_KEVENT_CONN_ERROR
;
2583 ev
->r
.connerror
.error
= error
;
2584 ev
->r
.connerror
.cid
= conn
->cid
;
2585 ev
->r
.connerror
.sid
= iscsi_conn_get_sid(conn
);
2587 iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_ATOMIC
);
2589 iscsi_cls_conn_printk(KERN_INFO
, conn
, "detected conn error (%d)\n",
2592 EXPORT_SYMBOL_GPL(iscsi_conn_error_event
);
2594 void iscsi_conn_login_event(struct iscsi_cls_conn
*conn
,
2595 enum iscsi_conn_state state
)
2597 struct nlmsghdr
*nlh
;
2598 struct sk_buff
*skb
;
2599 struct iscsi_uevent
*ev
;
2600 struct iscsi_internal
*priv
;
2601 int len
= nlmsg_total_size(sizeof(*ev
));
2603 priv
= iscsi_if_transport_lookup(conn
->transport
);
2607 skb
= alloc_skb(len
, GFP_ATOMIC
);
2609 iscsi_cls_conn_printk(KERN_ERR
, conn
, "gracefully ignored "
2610 "conn login (%d)\n", state
);
2614 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2615 ev
= nlmsg_data(nlh
);
2616 ev
->transport_handle
= iscsi_handle(conn
->transport
);
2617 ev
->type
= ISCSI_KEVENT_CONN_LOGIN_STATE
;
2618 ev
->r
.conn_login
.state
= state
;
2619 ev
->r
.conn_login
.cid
= conn
->cid
;
2620 ev
->r
.conn_login
.sid
= iscsi_conn_get_sid(conn
);
2621 iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_ATOMIC
);
2623 iscsi_cls_conn_printk(KERN_INFO
, conn
, "detected conn login (%d)\n",
2626 EXPORT_SYMBOL_GPL(iscsi_conn_login_event
);
2628 void iscsi_post_host_event(uint32_t host_no
, struct iscsi_transport
*transport
,
2629 enum iscsi_host_event_code code
, uint32_t data_size
,
2632 struct nlmsghdr
*nlh
;
2633 struct sk_buff
*skb
;
2634 struct iscsi_uevent
*ev
;
2635 int len
= nlmsg_total_size(sizeof(*ev
) + data_size
);
2637 skb
= alloc_skb(len
, GFP_NOIO
);
2639 printk(KERN_ERR
"gracefully ignored host event (%d):%d OOM\n",
2644 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2645 ev
= nlmsg_data(nlh
);
2646 ev
->transport_handle
= iscsi_handle(transport
);
2647 ev
->type
= ISCSI_KEVENT_HOST_EVENT
;
2648 ev
->r
.host_event
.host_no
= host_no
;
2649 ev
->r
.host_event
.code
= code
;
2650 ev
->r
.host_event
.data_size
= data_size
;
2653 memcpy((char *)ev
+ sizeof(*ev
), data
, data_size
);
2655 iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_NOIO
);
2657 EXPORT_SYMBOL_GPL(iscsi_post_host_event
);
2659 void iscsi_ping_comp_event(uint32_t host_no
, struct iscsi_transport
*transport
,
2660 uint32_t status
, uint32_t pid
, uint32_t data_size
,
2663 struct nlmsghdr
*nlh
;
2664 struct sk_buff
*skb
;
2665 struct iscsi_uevent
*ev
;
2666 int len
= nlmsg_total_size(sizeof(*ev
) + data_size
);
2668 skb
= alloc_skb(len
, GFP_NOIO
);
2670 printk(KERN_ERR
"gracefully ignored ping comp: OOM\n");
2674 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2675 ev
= nlmsg_data(nlh
);
2676 ev
->transport_handle
= iscsi_handle(transport
);
2677 ev
->type
= ISCSI_KEVENT_PING_COMP
;
2678 ev
->r
.ping_comp
.host_no
= host_no
;
2679 ev
->r
.ping_comp
.status
= status
;
2680 ev
->r
.ping_comp
.pid
= pid
;
2681 ev
->r
.ping_comp
.data_size
= data_size
;
2682 memcpy((char *)ev
+ sizeof(*ev
), data
, data_size
);
2684 iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_NOIO
);
2686 EXPORT_SYMBOL_GPL(iscsi_ping_comp_event
);
2689 iscsi_if_send_reply(u32 portid
, int type
, void *payload
, int size
)
2691 struct sk_buff
*skb
;
2692 struct nlmsghdr
*nlh
;
2693 int len
= nlmsg_total_size(size
);
2695 skb
= alloc_skb(len
, GFP_ATOMIC
);
2697 printk(KERN_ERR
"Could not allocate skb to send reply.\n");
2701 nlh
= __nlmsg_put(skb
, 0, 0, type
, (len
- sizeof(*nlh
)), 0);
2702 memcpy(nlmsg_data(nlh
), payload
, size
);
2703 return iscsi_unicast_skb(skb
, portid
);
2707 iscsi_if_get_stats(struct iscsi_transport
*transport
, struct nlmsghdr
*nlh
)
2709 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
2710 struct iscsi_stats
*stats
;
2711 struct sk_buff
*skbstat
;
2712 struct iscsi_cls_conn
*conn
;
2713 struct nlmsghdr
*nlhstat
;
2714 struct iscsi_uevent
*evstat
;
2715 struct iscsi_internal
*priv
;
2716 int len
= nlmsg_total_size(sizeof(*ev
) +
2717 sizeof(struct iscsi_stats
) +
2718 sizeof(struct iscsi_stats_custom
) *
2719 ISCSI_STATS_CUSTOM_MAX
);
2722 priv
= iscsi_if_transport_lookup(transport
);
2726 conn
= iscsi_conn_lookup(ev
->u
.get_stats
.sid
, ev
->u
.get_stats
.cid
);
2733 skbstat
= alloc_skb(len
, GFP_ATOMIC
);
2735 iscsi_cls_conn_printk(KERN_ERR
, conn
, "can not "
2736 "deliver stats: OOM\n");
2740 nlhstat
= __nlmsg_put(skbstat
, 0, 0, 0,
2741 (len
- sizeof(*nlhstat
)), 0);
2742 evstat
= nlmsg_data(nlhstat
);
2743 memset(evstat
, 0, sizeof(*evstat
));
2744 evstat
->transport_handle
= iscsi_handle(conn
->transport
);
2745 evstat
->type
= nlh
->nlmsg_type
;
2746 evstat
->u
.get_stats
.cid
=
2747 ev
->u
.get_stats
.cid
;
2748 evstat
->u
.get_stats
.sid
=
2749 ev
->u
.get_stats
.sid
;
2750 stats
= (struct iscsi_stats
*)
2751 ((char*)evstat
+ sizeof(*evstat
));
2752 memset(stats
, 0, sizeof(*stats
));
2754 transport
->get_stats(conn
, stats
);
2755 actual_size
= nlmsg_total_size(sizeof(struct iscsi_uevent
) +
2756 sizeof(struct iscsi_stats
) +
2757 sizeof(struct iscsi_stats_custom
) *
2758 stats
->custom_length
);
2759 actual_size
-= sizeof(*nlhstat
);
2760 actual_size
= nlmsg_msg_size(actual_size
);
2761 skb_trim(skbstat
, NLMSG_ALIGN(actual_size
));
2762 nlhstat
->nlmsg_len
= actual_size
;
2764 err
= iscsi_multicast_skb(skbstat
, ISCSI_NL_GRP_ISCSID
,
2766 } while (err
< 0 && err
!= -ECONNREFUSED
);
2772 * iscsi_session_event - send session destr. completion event
2773 * @session: iscsi class session
2774 * @event: type of event
2776 int iscsi_session_event(struct iscsi_cls_session
*session
,
2777 enum iscsi_uevent_e event
)
2779 struct iscsi_internal
*priv
;
2780 struct Scsi_Host
*shost
;
2781 struct iscsi_uevent
*ev
;
2782 struct sk_buff
*skb
;
2783 struct nlmsghdr
*nlh
;
2784 int rc
, len
= nlmsg_total_size(sizeof(*ev
));
2786 priv
= iscsi_if_transport_lookup(session
->transport
);
2789 shost
= iscsi_session_to_shost(session
);
2791 skb
= alloc_skb(len
, GFP_KERNEL
);
2793 iscsi_cls_session_printk(KERN_ERR
, session
,
2794 "Cannot notify userspace of session "
2795 "event %u\n", event
);
2799 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2800 ev
= nlmsg_data(nlh
);
2801 ev
->transport_handle
= iscsi_handle(session
->transport
);
2805 case ISCSI_KEVENT_DESTROY_SESSION
:
2806 ev
->r
.d_session
.host_no
= shost
->host_no
;
2807 ev
->r
.d_session
.sid
= session
->sid
;
2809 case ISCSI_KEVENT_CREATE_SESSION
:
2810 ev
->r
.c_session_ret
.host_no
= shost
->host_no
;
2811 ev
->r
.c_session_ret
.sid
= session
->sid
;
2813 case ISCSI_KEVENT_UNBIND_SESSION
:
2814 ev
->r
.unbind_session
.host_no
= shost
->host_no
;
2815 ev
->r
.unbind_session
.sid
= session
->sid
;
2818 iscsi_cls_session_printk(KERN_ERR
, session
, "Invalid event "
2825 * this will occur if the daemon is not up, so we just warn
2826 * the user and when the daemon is restarted it will handle it
2828 rc
= iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_KERNEL
);
2830 iscsi_cls_session_printk(KERN_ERR
, session
,
2831 "Cannot notify userspace of session "
2832 "event %u. Check iscsi daemon\n",
2835 ISCSI_DBG_TRANS_SESSION(session
, "Completed handling event %d rc %d\n",
2839 EXPORT_SYMBOL_GPL(iscsi_session_event
);
2842 iscsi_if_create_session(struct iscsi_internal
*priv
, struct iscsi_endpoint
*ep
,
2843 struct iscsi_uevent
*ev
, pid_t pid
,
2844 uint32_t initial_cmdsn
, uint16_t cmds_max
,
2845 uint16_t queue_depth
)
2847 struct iscsi_transport
*transport
= priv
->iscsi_transport
;
2848 struct iscsi_cls_session
*session
;
2849 struct Scsi_Host
*shost
;
2851 session
= transport
->create_session(ep
, cmds_max
, queue_depth
,
2856 session
->creator
= pid
;
2857 shost
= iscsi_session_to_shost(session
);
2858 ev
->r
.c_session_ret
.host_no
= shost
->host_no
;
2859 ev
->r
.c_session_ret
.sid
= session
->sid
;
2860 ISCSI_DBG_TRANS_SESSION(session
,
2861 "Completed creating transport session\n");
2866 iscsi_if_create_conn(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
2868 struct iscsi_cls_conn
*conn
;
2869 struct iscsi_cls_session
*session
;
2871 session
= iscsi_session_lookup(ev
->u
.c_conn
.sid
);
2873 printk(KERN_ERR
"iscsi: invalid session %d.\n",
2878 conn
= transport
->create_conn(session
, ev
->u
.c_conn
.cid
);
2880 iscsi_cls_session_printk(KERN_ERR
, session
,
2881 "couldn't create a new connection.");
2885 ev
->r
.c_conn_ret
.sid
= session
->sid
;
2886 ev
->r
.c_conn_ret
.cid
= conn
->cid
;
2888 ISCSI_DBG_TRANS_CONN(conn
, "Completed creating transport conn\n");
2893 iscsi_if_destroy_conn(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
2895 struct iscsi_cls_conn
*conn
;
2897 conn
= iscsi_conn_lookup(ev
->u
.d_conn
.sid
, ev
->u
.d_conn
.cid
);
2901 ISCSI_DBG_TRANS_CONN(conn
, "Flushing cleanup during destruction\n");
2902 flush_work(&conn
->cleanup_work
);
2903 ISCSI_DBG_TRANS_CONN(conn
, "Destroying transport conn\n");
2905 if (transport
->destroy_conn
)
2906 transport
->destroy_conn(conn
);
2911 iscsi_set_param(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
2913 char *data
= (char*)ev
+ sizeof(*ev
);
2914 struct iscsi_cls_conn
*conn
;
2915 struct iscsi_cls_session
*session
;
2916 int err
= 0, value
= 0;
2918 if (ev
->u
.set_param
.len
> PAGE_SIZE
)
2921 session
= iscsi_session_lookup(ev
->u
.set_param
.sid
);
2922 conn
= iscsi_conn_lookup(ev
->u
.set_param
.sid
, ev
->u
.set_param
.cid
);
2923 if (!conn
|| !session
)
2926 switch (ev
->u
.set_param
.param
) {
2927 case ISCSI_PARAM_SESS_RECOVERY_TMO
:
2928 sscanf(data
, "%d", &value
);
2929 if (!session
->recovery_tmo_sysfs_override
)
2930 session
->recovery_tmo
= value
;
2933 if ((conn
->state
== ISCSI_CONN_BOUND
) ||
2934 (conn
->state
== ISCSI_CONN_UP
)) {
2935 err
= transport
->set_param(conn
, ev
->u
.set_param
.param
,
2936 data
, ev
->u
.set_param
.len
);
2945 static int iscsi_if_ep_connect(struct iscsi_transport
*transport
,
2946 struct iscsi_uevent
*ev
, int msg_type
)
2948 struct iscsi_endpoint
*ep
;
2949 struct sockaddr
*dst_addr
;
2950 struct Scsi_Host
*shost
= NULL
;
2951 int non_blocking
, err
= 0;
2953 if (!transport
->ep_connect
)
2956 if (msg_type
== ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST
) {
2957 shost
= scsi_host_lookup(ev
->u
.ep_connect_through_host
.host_no
);
2959 printk(KERN_ERR
"ep connect failed. Could not find "
2961 ev
->u
.ep_connect_through_host
.host_no
);
2964 non_blocking
= ev
->u
.ep_connect_through_host
.non_blocking
;
2966 non_blocking
= ev
->u
.ep_connect
.non_blocking
;
2968 dst_addr
= (struct sockaddr
*)((char*)ev
+ sizeof(*ev
));
2969 ep
= transport
->ep_connect(shost
, dst_addr
, non_blocking
);
2975 ev
->r
.ep_connect_ret
.handle
= ep
->id
;
2978 scsi_host_put(shost
);
2982 static int iscsi_if_ep_disconnect(struct iscsi_transport
*transport
,
2985 struct iscsi_cls_conn
*conn
;
2986 struct iscsi_endpoint
*ep
;
2988 if (!transport
->ep_disconnect
)
2991 ep
= iscsi_lookup_endpoint(ep_handle
);
2998 * conn was not even bound yet, so we can't get iscsi conn
3001 transport
->ep_disconnect(ep
);
3005 mutex_lock(&conn
->ep_mutex
);
3006 /* Check if this was a conn error and the kernel took ownership */
3007 if (test_bit(ISCSI_CLS_CONN_BIT_CLEANUP
, &conn
->flags
)) {
3008 ISCSI_DBG_TRANS_CONN(conn
, "flush kernel conn cleanup.\n");
3009 mutex_unlock(&conn
->ep_mutex
);
3011 flush_work(&conn
->cleanup_work
);
3015 iscsi_ep_disconnect(conn
, false);
3016 mutex_unlock(&conn
->ep_mutex
);
3018 iscsi_put_endpoint(ep
);
3023 iscsi_if_transport_ep(struct iscsi_transport
*transport
,
3024 struct iscsi_uevent
*ev
, int msg_type
)
3026 struct iscsi_endpoint
*ep
;
3030 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST
:
3031 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT
:
3032 rc
= iscsi_if_ep_connect(transport
, ev
, msg_type
);
3034 case ISCSI_UEVENT_TRANSPORT_EP_POLL
:
3035 if (!transport
->ep_poll
)
3038 ep
= iscsi_lookup_endpoint(ev
->u
.ep_poll
.ep_handle
);
3042 ev
->r
.retcode
= transport
->ep_poll(ep
,
3043 ev
->u
.ep_poll
.timeout_ms
);
3044 iscsi_put_endpoint(ep
);
3046 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT
:
3047 rc
= iscsi_if_ep_disconnect(transport
,
3048 ev
->u
.ep_disconnect
.ep_handle
);
3055 iscsi_tgt_dscvr(struct iscsi_transport
*transport
,
3056 struct iscsi_uevent
*ev
)
3058 struct Scsi_Host
*shost
;
3059 struct sockaddr
*dst_addr
;
3062 if (!transport
->tgt_dscvr
)
3065 shost
= scsi_host_lookup(ev
->u
.tgt_dscvr
.host_no
);
3067 printk(KERN_ERR
"target discovery could not find host no %u\n",
3068 ev
->u
.tgt_dscvr
.host_no
);
3073 dst_addr
= (struct sockaddr
*)((char*)ev
+ sizeof(*ev
));
3074 err
= transport
->tgt_dscvr(shost
, ev
->u
.tgt_dscvr
.type
,
3075 ev
->u
.tgt_dscvr
.enable
, dst_addr
);
3076 scsi_host_put(shost
);
3081 iscsi_set_host_param(struct iscsi_transport
*transport
,
3082 struct iscsi_uevent
*ev
)
3084 char *data
= (char*)ev
+ sizeof(*ev
);
3085 struct Scsi_Host
*shost
;
3088 if (!transport
->set_host_param
)
3091 if (ev
->u
.set_host_param
.len
> PAGE_SIZE
)
3094 shost
= scsi_host_lookup(ev
->u
.set_host_param
.host_no
);
3096 printk(KERN_ERR
"set_host_param could not find host no %u\n",
3097 ev
->u
.set_host_param
.host_no
);
3101 err
= transport
->set_host_param(shost
, ev
->u
.set_host_param
.param
,
3102 data
, ev
->u
.set_host_param
.len
);
3103 scsi_host_put(shost
);
3108 iscsi_set_path(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
3110 struct Scsi_Host
*shost
;
3111 struct iscsi_path
*params
;
3114 if (!transport
->set_path
)
3117 shost
= scsi_host_lookup(ev
->u
.set_path
.host_no
);
3119 printk(KERN_ERR
"set path could not find host no %u\n",
3120 ev
->u
.set_path
.host_no
);
3124 params
= (struct iscsi_path
*)((char *)ev
+ sizeof(*ev
));
3125 err
= transport
->set_path(shost
, params
);
3127 scsi_host_put(shost
);
3131 static int iscsi_session_has_conns(int sid
)
3133 struct iscsi_cls_conn
*conn
;
3134 unsigned long flags
;
3137 spin_lock_irqsave(&connlock
, flags
);
3138 list_for_each_entry(conn
, &connlist
, conn_list
) {
3139 if (iscsi_conn_get_sid(conn
) == sid
) {
3144 spin_unlock_irqrestore(&connlock
, flags
);
3150 iscsi_set_iface_params(struct iscsi_transport
*transport
,
3151 struct iscsi_uevent
*ev
, uint32_t len
)
3153 char *data
= (char *)ev
+ sizeof(*ev
);
3154 struct Scsi_Host
*shost
;
3157 if (!transport
->set_iface_param
)
3160 shost
= scsi_host_lookup(ev
->u
.set_iface_params
.host_no
);
3162 printk(KERN_ERR
"set_iface_params could not find host no %u\n",
3163 ev
->u
.set_iface_params
.host_no
);
3167 err
= transport
->set_iface_param(shost
, data
, len
);
3168 scsi_host_put(shost
);
3173 iscsi_send_ping(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
3175 struct Scsi_Host
*shost
;
3176 struct sockaddr
*dst_addr
;
3179 if (!transport
->send_ping
)
3182 shost
= scsi_host_lookup(ev
->u
.iscsi_ping
.host_no
);
3184 printk(KERN_ERR
"iscsi_ping could not find host no %u\n",
3185 ev
->u
.iscsi_ping
.host_no
);
3189 dst_addr
= (struct sockaddr
*)((char *)ev
+ sizeof(*ev
));
3190 err
= transport
->send_ping(shost
, ev
->u
.iscsi_ping
.iface_num
,
3191 ev
->u
.iscsi_ping
.iface_type
,
3192 ev
->u
.iscsi_ping
.payload_size
,
3193 ev
->u
.iscsi_ping
.pid
,
3195 scsi_host_put(shost
);
3200 iscsi_get_chap(struct iscsi_transport
*transport
, struct nlmsghdr
*nlh
)
3202 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
3203 struct Scsi_Host
*shost
= NULL
;
3204 struct iscsi_chap_rec
*chap_rec
;
3205 struct iscsi_internal
*priv
;
3206 struct sk_buff
*skbchap
;
3207 struct nlmsghdr
*nlhchap
;
3208 struct iscsi_uevent
*evchap
;
3209 uint32_t chap_buf_size
;
3213 if (!transport
->get_chap
)
3216 priv
= iscsi_if_transport_lookup(transport
);
3220 chap_buf_size
= (ev
->u
.get_chap
.num_entries
* sizeof(*chap_rec
));
3221 len
= nlmsg_total_size(sizeof(*ev
) + chap_buf_size
);
3223 shost
= scsi_host_lookup(ev
->u
.get_chap
.host_no
);
3225 printk(KERN_ERR
"%s: failed. Could not find host no %u\n",
3226 __func__
, ev
->u
.get_chap
.host_no
);
3233 skbchap
= alloc_skb(len
, GFP_KERNEL
);
3235 printk(KERN_ERR
"can not deliver chap: OOM\n");
3240 nlhchap
= __nlmsg_put(skbchap
, 0, 0, 0,
3241 (len
- sizeof(*nlhchap
)), 0);
3242 evchap
= nlmsg_data(nlhchap
);
3243 memset(evchap
, 0, sizeof(*evchap
));
3244 evchap
->transport_handle
= iscsi_handle(transport
);
3245 evchap
->type
= nlh
->nlmsg_type
;
3246 evchap
->u
.get_chap
.host_no
= ev
->u
.get_chap
.host_no
;
3247 evchap
->u
.get_chap
.chap_tbl_idx
= ev
->u
.get_chap
.chap_tbl_idx
;
3248 evchap
->u
.get_chap
.num_entries
= ev
->u
.get_chap
.num_entries
;
3249 buf
= (char *)evchap
+ sizeof(*evchap
);
3250 memset(buf
, 0, chap_buf_size
);
3252 err
= transport
->get_chap(shost
, ev
->u
.get_chap
.chap_tbl_idx
,
3253 &evchap
->u
.get_chap
.num_entries
, buf
);
3255 actual_size
= nlmsg_total_size(sizeof(*ev
) + chap_buf_size
);
3256 skb_trim(skbchap
, NLMSG_ALIGN(actual_size
));
3257 nlhchap
->nlmsg_len
= actual_size
;
3259 err
= iscsi_multicast_skb(skbchap
, ISCSI_NL_GRP_ISCSID
,
3261 } while (err
< 0 && err
!= -ECONNREFUSED
);
3264 scsi_host_put(shost
);
3268 static int iscsi_set_chap(struct iscsi_transport
*transport
,
3269 struct iscsi_uevent
*ev
, uint32_t len
)
3271 char *data
= (char *)ev
+ sizeof(*ev
);
3272 struct Scsi_Host
*shost
;
3275 if (!transport
->set_chap
)
3278 shost
= scsi_host_lookup(ev
->u
.set_path
.host_no
);
3280 pr_err("%s could not find host no %u\n",
3281 __func__
, ev
->u
.set_path
.host_no
);
3285 err
= transport
->set_chap(shost
, data
, len
);
3286 scsi_host_put(shost
);
3290 static int iscsi_delete_chap(struct iscsi_transport
*transport
,
3291 struct iscsi_uevent
*ev
)
3293 struct Scsi_Host
*shost
;
3296 if (!transport
->delete_chap
)
3299 shost
= scsi_host_lookup(ev
->u
.delete_chap
.host_no
);
3301 printk(KERN_ERR
"%s could not find host no %u\n",
3302 __func__
, ev
->u
.delete_chap
.host_no
);
3306 err
= transport
->delete_chap(shost
, ev
->u
.delete_chap
.chap_tbl_idx
);
3307 scsi_host_put(shost
);
3311 static const struct {
3312 enum iscsi_discovery_parent_type value
;
3314 } iscsi_discovery_parent_names
[] = {
3315 {ISCSI_DISC_PARENT_UNKNOWN
, "Unknown" },
3316 {ISCSI_DISC_PARENT_SENDTGT
, "Sendtarget" },
3317 {ISCSI_DISC_PARENT_ISNS
, "isns" },
3320 char *iscsi_get_discovery_parent_name(int parent_type
)
3323 char *state
= "Unknown!";
3325 for (i
= 0; i
< ARRAY_SIZE(iscsi_discovery_parent_names
); i
++) {
3326 if (iscsi_discovery_parent_names
[i
].value
& parent_type
) {
3327 state
= iscsi_discovery_parent_names
[i
].name
;
3333 EXPORT_SYMBOL_GPL(iscsi_get_discovery_parent_name
);
3335 static int iscsi_set_flashnode_param(struct iscsi_transport
*transport
,
3336 struct iscsi_uevent
*ev
, uint32_t len
)
3338 char *data
= (char *)ev
+ sizeof(*ev
);
3339 struct Scsi_Host
*shost
;
3340 struct iscsi_bus_flash_session
*fnode_sess
;
3341 struct iscsi_bus_flash_conn
*fnode_conn
;
3346 if (!transport
->set_flashnode_param
) {
3348 goto exit_set_fnode
;
3351 shost
= scsi_host_lookup(ev
->u
.set_flashnode
.host_no
);
3353 pr_err("%s could not find host no %u\n",
3354 __func__
, ev
->u
.set_flashnode
.host_no
);
3356 goto exit_set_fnode
;
3359 idx
= ev
->u
.set_flashnode
.flashnode_idx
;
3360 fnode_sess
= iscsi_get_flashnode_by_index(shost
, idx
);
3362 pr_err("%s could not find flashnode %u for host no %u\n",
3363 __func__
, idx
, ev
->u
.set_flashnode
.host_no
);
3368 dev
= iscsi_find_flashnode_conn(fnode_sess
);
3374 fnode_conn
= iscsi_dev_to_flash_conn(dev
);
3375 err
= transport
->set_flashnode_param(fnode_sess
, fnode_conn
, data
, len
);
3379 put_device(&fnode_sess
->dev
);
3382 scsi_host_put(shost
);
3388 static int iscsi_new_flashnode(struct iscsi_transport
*transport
,
3389 struct iscsi_uevent
*ev
, uint32_t len
)
3391 char *data
= (char *)ev
+ sizeof(*ev
);
3392 struct Scsi_Host
*shost
;
3396 if (!transport
->new_flashnode
) {
3398 goto exit_new_fnode
;
3401 shost
= scsi_host_lookup(ev
->u
.new_flashnode
.host_no
);
3403 pr_err("%s could not find host no %u\n",
3404 __func__
, ev
->u
.new_flashnode
.host_no
);
3409 index
= transport
->new_flashnode(shost
, data
, len
);
3412 ev
->r
.new_flashnode_ret
.flashnode_idx
= index
;
3417 scsi_host_put(shost
);
3423 static int iscsi_del_flashnode(struct iscsi_transport
*transport
,
3424 struct iscsi_uevent
*ev
)
3426 struct Scsi_Host
*shost
;
3427 struct iscsi_bus_flash_session
*fnode_sess
;
3431 if (!transport
->del_flashnode
) {
3433 goto exit_del_fnode
;
3436 shost
= scsi_host_lookup(ev
->u
.del_flashnode
.host_no
);
3438 pr_err("%s could not find host no %u\n",
3439 __func__
, ev
->u
.del_flashnode
.host_no
);
3444 idx
= ev
->u
.del_flashnode
.flashnode_idx
;
3445 fnode_sess
= iscsi_get_flashnode_by_index(shost
, idx
);
3447 pr_err("%s could not find flashnode %u for host no %u\n",
3448 __func__
, idx
, ev
->u
.del_flashnode
.host_no
);
3453 err
= transport
->del_flashnode(fnode_sess
);
3454 put_device(&fnode_sess
->dev
);
3457 scsi_host_put(shost
);
3463 static int iscsi_login_flashnode(struct iscsi_transport
*transport
,
3464 struct iscsi_uevent
*ev
)
3466 struct Scsi_Host
*shost
;
3467 struct iscsi_bus_flash_session
*fnode_sess
;
3468 struct iscsi_bus_flash_conn
*fnode_conn
;
3473 if (!transport
->login_flashnode
) {
3475 goto exit_login_fnode
;
3478 shost
= scsi_host_lookup(ev
->u
.login_flashnode
.host_no
);
3480 pr_err("%s could not find host no %u\n",
3481 __func__
, ev
->u
.login_flashnode
.host_no
);
3486 idx
= ev
->u
.login_flashnode
.flashnode_idx
;
3487 fnode_sess
= iscsi_get_flashnode_by_index(shost
, idx
);
3489 pr_err("%s could not find flashnode %u for host no %u\n",
3490 __func__
, idx
, ev
->u
.login_flashnode
.host_no
);
3495 dev
= iscsi_find_flashnode_conn(fnode_sess
);
3501 fnode_conn
= iscsi_dev_to_flash_conn(dev
);
3502 err
= transport
->login_flashnode(fnode_sess
, fnode_conn
);
3506 put_device(&fnode_sess
->dev
);
3509 scsi_host_put(shost
);
3515 static int iscsi_logout_flashnode(struct iscsi_transport
*transport
,
3516 struct iscsi_uevent
*ev
)
3518 struct Scsi_Host
*shost
;
3519 struct iscsi_bus_flash_session
*fnode_sess
;
3520 struct iscsi_bus_flash_conn
*fnode_conn
;
3525 if (!transport
->logout_flashnode
) {
3527 goto exit_logout_fnode
;
3530 shost
= scsi_host_lookup(ev
->u
.logout_flashnode
.host_no
);
3532 pr_err("%s could not find host no %u\n",
3533 __func__
, ev
->u
.logout_flashnode
.host_no
);
3538 idx
= ev
->u
.logout_flashnode
.flashnode_idx
;
3539 fnode_sess
= iscsi_get_flashnode_by_index(shost
, idx
);
3541 pr_err("%s could not find flashnode %u for host no %u\n",
3542 __func__
, idx
, ev
->u
.logout_flashnode
.host_no
);
3547 dev
= iscsi_find_flashnode_conn(fnode_sess
);
3553 fnode_conn
= iscsi_dev_to_flash_conn(dev
);
3555 err
= transport
->logout_flashnode(fnode_sess
, fnode_conn
);
3559 put_device(&fnode_sess
->dev
);
3562 scsi_host_put(shost
);
3568 static int iscsi_logout_flashnode_sid(struct iscsi_transport
*transport
,
3569 struct iscsi_uevent
*ev
)
3571 struct Scsi_Host
*shost
;
3572 struct iscsi_cls_session
*session
;
3575 if (!transport
->logout_flashnode_sid
) {
3577 goto exit_logout_sid
;
3580 shost
= scsi_host_lookup(ev
->u
.logout_flashnode_sid
.host_no
);
3582 pr_err("%s could not find host no %u\n",
3583 __func__
, ev
->u
.logout_flashnode
.host_no
);
3588 session
= iscsi_session_lookup(ev
->u
.logout_flashnode_sid
.sid
);
3590 pr_err("%s could not find session id %u\n",
3591 __func__
, ev
->u
.logout_flashnode_sid
.sid
);
3596 err
= transport
->logout_flashnode_sid(session
);
3599 scsi_host_put(shost
);
3606 iscsi_get_host_stats(struct iscsi_transport
*transport
, struct nlmsghdr
*nlh
)
3608 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
3609 struct Scsi_Host
*shost
= NULL
;
3610 struct iscsi_internal
*priv
;
3611 struct sk_buff
*skbhost_stats
;
3612 struct nlmsghdr
*nlhhost_stats
;
3613 struct iscsi_uevent
*evhost_stats
;
3614 int host_stats_size
= 0;
3618 if (!transport
->get_host_stats
)
3621 priv
= iscsi_if_transport_lookup(transport
);
3625 host_stats_size
= sizeof(struct iscsi_offload_host_stats
);
3626 len
= nlmsg_total_size(sizeof(*ev
) + host_stats_size
);
3628 shost
= scsi_host_lookup(ev
->u
.get_host_stats
.host_no
);
3630 pr_err("%s: failed. Could not find host no %u\n",
3631 __func__
, ev
->u
.get_host_stats
.host_no
);
3638 skbhost_stats
= alloc_skb(len
, GFP_KERNEL
);
3639 if (!skbhost_stats
) {
3640 pr_err("cannot deliver host stats: OOM\n");
3642 goto exit_host_stats
;
3645 nlhhost_stats
= __nlmsg_put(skbhost_stats
, 0, 0, 0,
3646 (len
- sizeof(*nlhhost_stats
)), 0);
3647 evhost_stats
= nlmsg_data(nlhhost_stats
);
3648 memset(evhost_stats
, 0, sizeof(*evhost_stats
));
3649 evhost_stats
->transport_handle
= iscsi_handle(transport
);
3650 evhost_stats
->type
= nlh
->nlmsg_type
;
3651 evhost_stats
->u
.get_host_stats
.host_no
=
3652 ev
->u
.get_host_stats
.host_no
;
3653 buf
= (char *)evhost_stats
+ sizeof(*evhost_stats
);
3654 memset(buf
, 0, host_stats_size
);
3656 err
= transport
->get_host_stats(shost
, buf
, host_stats_size
);
3658 kfree_skb(skbhost_stats
);
3659 goto exit_host_stats
;
3662 actual_size
= nlmsg_total_size(sizeof(*ev
) + host_stats_size
);
3663 skb_trim(skbhost_stats
, NLMSG_ALIGN(actual_size
));
3664 nlhhost_stats
->nlmsg_len
= actual_size
;
3666 err
= iscsi_multicast_skb(skbhost_stats
, ISCSI_NL_GRP_ISCSID
,
3668 } while (err
< 0 && err
!= -ECONNREFUSED
);
3671 scsi_host_put(shost
);
3675 static int iscsi_if_transport_conn(struct iscsi_transport
*transport
,
3676 struct nlmsghdr
*nlh
)
3678 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
3679 struct iscsi_cls_session
*session
;
3680 struct iscsi_cls_conn
*conn
= NULL
;
3681 struct iscsi_endpoint
*ep
;
3685 switch (nlh
->nlmsg_type
) {
3686 case ISCSI_UEVENT_CREATE_CONN
:
3687 return iscsi_if_create_conn(transport
, ev
);
3688 case ISCSI_UEVENT_DESTROY_CONN
:
3689 return iscsi_if_destroy_conn(transport
, ev
);
3690 case ISCSI_UEVENT_STOP_CONN
:
3691 return iscsi_if_stop_conn(transport
, ev
);
3695 * The following cmds need to be run under the ep_mutex so in kernel
3696 * conn cleanup (ep_disconnect + unbind and conn) is not done while
3697 * these are running. They also must not run if we have just run a conn
3698 * cleanup because they would set the state in a way that might allow
3699 * IO or send IO themselves.
3701 switch (nlh
->nlmsg_type
) {
3702 case ISCSI_UEVENT_START_CONN
:
3703 conn
= iscsi_conn_lookup(ev
->u
.start_conn
.sid
,
3704 ev
->u
.start_conn
.cid
);
3706 case ISCSI_UEVENT_BIND_CONN
:
3707 conn
= iscsi_conn_lookup(ev
->u
.b_conn
.sid
, ev
->u
.b_conn
.cid
);
3709 case ISCSI_UEVENT_SEND_PDU
:
3710 conn
= iscsi_conn_lookup(ev
->u
.send_pdu
.sid
, ev
->u
.send_pdu
.cid
);
3717 mutex_lock(&conn
->ep_mutex
);
3718 if (test_bit(ISCSI_CLS_CONN_BIT_CLEANUP
, &conn
->flags
)) {
3719 mutex_unlock(&conn
->ep_mutex
);
3720 ev
->r
.retcode
= -ENOTCONN
;
3724 switch (nlh
->nlmsg_type
) {
3725 case ISCSI_UEVENT_BIND_CONN
:
3728 * For offload boot support where iscsid is restarted
3729 * during the pivot root stage, the ep will be intact
3730 * here when the new iscsid instance starts up and
3733 iscsi_ep_disconnect(conn
, true);
3736 session
= iscsi_session_lookup(ev
->u
.b_conn
.sid
);
3742 ev
->r
.retcode
= transport
->bind_conn(session
, conn
,
3743 ev
->u
.b_conn
.transport_eph
,
3744 ev
->u
.b_conn
.is_leading
);
3746 conn
->state
= ISCSI_CONN_BOUND
;
3748 if (ev
->r
.retcode
|| !transport
->ep_connect
)
3751 ep
= iscsi_lookup_endpoint(ev
->u
.b_conn
.transport_eph
);
3755 iscsi_put_endpoint(ep
);
3758 iscsi_cls_conn_printk(KERN_ERR
, conn
,
3759 "Could not set ep conn binding\n");
3762 case ISCSI_UEVENT_START_CONN
:
3763 ev
->r
.retcode
= transport
->start_conn(conn
);
3765 conn
->state
= ISCSI_CONN_UP
;
3767 case ISCSI_UEVENT_SEND_PDU
:
3768 pdu_len
= nlh
->nlmsg_len
- sizeof(*nlh
) - sizeof(*ev
);
3770 if ((ev
->u
.send_pdu
.hdr_size
> pdu_len
) ||
3771 (ev
->u
.send_pdu
.data_size
> (pdu_len
- ev
->u
.send_pdu
.hdr_size
))) {
3776 ev
->r
.retcode
= transport
->send_pdu(conn
,
3777 (struct iscsi_hdr
*)((char *)ev
+ sizeof(*ev
)),
3778 (char *)ev
+ sizeof(*ev
) + ev
->u
.send_pdu
.hdr_size
,
3779 ev
->u
.send_pdu
.data_size
);
3785 mutex_unlock(&conn
->ep_mutex
);
3790 iscsi_if_recv_msg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, uint32_t *group
)
3794 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
3795 struct iscsi_transport
*transport
= NULL
;
3796 struct iscsi_internal
*priv
;
3797 struct iscsi_cls_session
*session
;
3798 struct iscsi_endpoint
*ep
= NULL
;
3800 if (!netlink_capable(skb
, CAP_SYS_ADMIN
))
3803 if (nlh
->nlmsg_type
== ISCSI_UEVENT_PATH_UPDATE
)
3804 *group
= ISCSI_NL_GRP_UIP
;
3806 *group
= ISCSI_NL_GRP_ISCSID
;
3808 priv
= iscsi_if_transport_lookup(iscsi_ptr(ev
->transport_handle
));
3811 transport
= priv
->iscsi_transport
;
3813 if (!try_module_get(transport
->owner
))
3816 portid
= NETLINK_CB(skb
).portid
;
3818 switch (nlh
->nlmsg_type
) {
3819 case ISCSI_UEVENT_CREATE_SESSION
:
3820 err
= iscsi_if_create_session(priv
, ep
, ev
,
3822 ev
->u
.c_session
.initial_cmdsn
,
3823 ev
->u
.c_session
.cmds_max
,
3824 ev
->u
.c_session
.queue_depth
);
3826 case ISCSI_UEVENT_CREATE_BOUND_SESSION
:
3827 ep
= iscsi_lookup_endpoint(ev
->u
.c_bound_session
.ep_handle
);
3833 err
= iscsi_if_create_session(priv
, ep
, ev
,
3835 ev
->u
.c_bound_session
.initial_cmdsn
,
3836 ev
->u
.c_bound_session
.cmds_max
,
3837 ev
->u
.c_bound_session
.queue_depth
);
3838 iscsi_put_endpoint(ep
);
3840 case ISCSI_UEVENT_DESTROY_SESSION
:
3841 session
= iscsi_session_lookup(ev
->u
.d_session
.sid
);
3844 else if (iscsi_session_has_conns(ev
->u
.d_session
.sid
))
3847 transport
->destroy_session(session
);
3849 case ISCSI_UEVENT_DESTROY_SESSION_ASYNC
:
3850 session
= iscsi_session_lookup(ev
->u
.d_session
.sid
);
3853 else if (iscsi_session_has_conns(ev
->u
.d_session
.sid
))
3856 unsigned long flags
;
3858 /* Prevent this session from being found again */
3859 spin_lock_irqsave(&sesslock
, flags
);
3860 list_del_init(&session
->sess_list
);
3861 spin_unlock_irqrestore(&sesslock
, flags
);
3863 queue_work(system_unbound_wq
, &session
->destroy_work
);
3866 case ISCSI_UEVENT_UNBIND_SESSION
:
3867 session
= iscsi_session_lookup(ev
->u
.d_session
.sid
);
3869 scsi_queue_work(iscsi_session_to_shost(session
),
3870 &session
->unbind_work
);
3874 case ISCSI_UEVENT_SET_PARAM
:
3875 err
= iscsi_set_param(transport
, ev
);
3877 case ISCSI_UEVENT_CREATE_CONN
:
3878 case ISCSI_UEVENT_DESTROY_CONN
:
3879 case ISCSI_UEVENT_STOP_CONN
:
3880 case ISCSI_UEVENT_START_CONN
:
3881 case ISCSI_UEVENT_BIND_CONN
:
3882 case ISCSI_UEVENT_SEND_PDU
:
3883 err
= iscsi_if_transport_conn(transport
, nlh
);
3885 case ISCSI_UEVENT_GET_STATS
:
3886 err
= iscsi_if_get_stats(transport
, nlh
);
3888 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT
:
3889 case ISCSI_UEVENT_TRANSPORT_EP_POLL
:
3890 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT
:
3891 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST
:
3892 err
= iscsi_if_transport_ep(transport
, ev
, nlh
->nlmsg_type
);
3894 case ISCSI_UEVENT_TGT_DSCVR
:
3895 err
= iscsi_tgt_dscvr(transport
, ev
);
3897 case ISCSI_UEVENT_SET_HOST_PARAM
:
3898 err
= iscsi_set_host_param(transport
, ev
);
3900 case ISCSI_UEVENT_PATH_UPDATE
:
3901 err
= iscsi_set_path(transport
, ev
);
3903 case ISCSI_UEVENT_SET_IFACE_PARAMS
:
3904 err
= iscsi_set_iface_params(transport
, ev
,
3905 nlmsg_attrlen(nlh
, sizeof(*ev
)));
3907 case ISCSI_UEVENT_PING
:
3908 err
= iscsi_send_ping(transport
, ev
);
3910 case ISCSI_UEVENT_GET_CHAP
:
3911 err
= iscsi_get_chap(transport
, nlh
);
3913 case ISCSI_UEVENT_DELETE_CHAP
:
3914 err
= iscsi_delete_chap(transport
, ev
);
3916 case ISCSI_UEVENT_SET_FLASHNODE_PARAMS
:
3917 err
= iscsi_set_flashnode_param(transport
, ev
,
3921 case ISCSI_UEVENT_NEW_FLASHNODE
:
3922 err
= iscsi_new_flashnode(transport
, ev
,
3923 nlmsg_attrlen(nlh
, sizeof(*ev
)));
3925 case ISCSI_UEVENT_DEL_FLASHNODE
:
3926 err
= iscsi_del_flashnode(transport
, ev
);
3928 case ISCSI_UEVENT_LOGIN_FLASHNODE
:
3929 err
= iscsi_login_flashnode(transport
, ev
);
3931 case ISCSI_UEVENT_LOGOUT_FLASHNODE
:
3932 err
= iscsi_logout_flashnode(transport
, ev
);
3934 case ISCSI_UEVENT_LOGOUT_FLASHNODE_SID
:
3935 err
= iscsi_logout_flashnode_sid(transport
, ev
);
3937 case ISCSI_UEVENT_SET_CHAP
:
3938 err
= iscsi_set_chap(transport
, ev
,
3939 nlmsg_attrlen(nlh
, sizeof(*ev
)));
3941 case ISCSI_UEVENT_GET_HOST_STATS
:
3942 err
= iscsi_get_host_stats(transport
, nlh
);
3949 module_put(transport
->owner
);
3954 * Get message from skb. Each message is processed by iscsi_if_recv_msg.
3955 * Malformed skbs with wrong lengths or invalid creds are not processed.
3958 iscsi_if_rx(struct sk_buff
*skb
)
3960 u32 portid
= NETLINK_CB(skb
).portid
;
3962 mutex_lock(&rx_queue_mutex
);
3963 while (skb
->len
>= NLMSG_HDRLEN
) {
3966 struct nlmsghdr
*nlh
;
3967 struct iscsi_uevent
*ev
;
3969 int retries
= ISCSI_SEND_MAX_ALLOWED
;
3971 nlh
= nlmsg_hdr(skb
);
3972 if (nlh
->nlmsg_len
< sizeof(*nlh
) + sizeof(*ev
) ||
3973 skb
->len
< nlh
->nlmsg_len
) {
3977 ev
= nlmsg_data(nlh
);
3978 rlen
= NLMSG_ALIGN(nlh
->nlmsg_len
);
3979 if (rlen
> skb
->len
)
3982 err
= iscsi_if_recv_msg(skb
, nlh
, &group
);
3984 ev
->type
= ISCSI_KEVENT_IF_ERROR
;
3989 * special case for GET_STATS:
3990 * on success - sending reply and stats from
3991 * inside of if_recv_msg(),
3992 * on error - fall through.
3994 if (ev
->type
== ISCSI_UEVENT_GET_STATS
&& !err
)
3996 if (ev
->type
== ISCSI_UEVENT_GET_CHAP
&& !err
)
3998 err
= iscsi_if_send_reply(portid
, nlh
->nlmsg_type
,
4000 if (err
== -EAGAIN
&& --retries
< 0) {
4001 printk(KERN_WARNING
"Send reply failed, error %d\n", err
);
4004 } while (err
< 0 && err
!= -ECONNREFUSED
&& err
!= -ESRCH
);
4005 skb_pull(skb
, rlen
);
4007 mutex_unlock(&rx_queue_mutex
);
4010 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \
4011 struct device_attribute dev_attr_##_prefix##_##_name = \
4012 __ATTR(_name,_mode,_show,_store)
4015 * iSCSI connection attrs
4017 #define iscsi_conn_attr_show(param) \
4019 show_conn_param_##param(struct device *dev, \
4020 struct device_attribute *attr, char *buf) \
4022 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
4023 struct iscsi_transport *t = conn->transport; \
4024 return t->get_conn_param(conn, param, buf); \
4027 #define iscsi_conn_attr(field, param) \
4028 iscsi_conn_attr_show(param) \
4029 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param, \
4032 iscsi_conn_attr(max_recv_dlength
, ISCSI_PARAM_MAX_RECV_DLENGTH
);
4033 iscsi_conn_attr(max_xmit_dlength
, ISCSI_PARAM_MAX_XMIT_DLENGTH
);
4034 iscsi_conn_attr(header_digest
, ISCSI_PARAM_HDRDGST_EN
);
4035 iscsi_conn_attr(data_digest
, ISCSI_PARAM_DATADGST_EN
);
4036 iscsi_conn_attr(ifmarker
, ISCSI_PARAM_IFMARKER_EN
);
4037 iscsi_conn_attr(ofmarker
, ISCSI_PARAM_OFMARKER_EN
);
4038 iscsi_conn_attr(persistent_port
, ISCSI_PARAM_PERSISTENT_PORT
);
4039 iscsi_conn_attr(exp_statsn
, ISCSI_PARAM_EXP_STATSN
);
4040 iscsi_conn_attr(persistent_address
, ISCSI_PARAM_PERSISTENT_ADDRESS
);
4041 iscsi_conn_attr(ping_tmo
, ISCSI_PARAM_PING_TMO
);
4042 iscsi_conn_attr(recv_tmo
, ISCSI_PARAM_RECV_TMO
);
4043 iscsi_conn_attr(local_port
, ISCSI_PARAM_LOCAL_PORT
);
4044 iscsi_conn_attr(statsn
, ISCSI_PARAM_STATSN
);
4045 iscsi_conn_attr(keepalive_tmo
, ISCSI_PARAM_KEEPALIVE_TMO
);
4046 iscsi_conn_attr(max_segment_size
, ISCSI_PARAM_MAX_SEGMENT_SIZE
);
4047 iscsi_conn_attr(tcp_timestamp_stat
, ISCSI_PARAM_TCP_TIMESTAMP_STAT
);
4048 iscsi_conn_attr(tcp_wsf_disable
, ISCSI_PARAM_TCP_WSF_DISABLE
);
4049 iscsi_conn_attr(tcp_nagle_disable
, ISCSI_PARAM_TCP_NAGLE_DISABLE
);
4050 iscsi_conn_attr(tcp_timer_scale
, ISCSI_PARAM_TCP_TIMER_SCALE
);
4051 iscsi_conn_attr(tcp_timestamp_enable
, ISCSI_PARAM_TCP_TIMESTAMP_EN
);
4052 iscsi_conn_attr(fragment_disable
, ISCSI_PARAM_IP_FRAGMENT_DISABLE
);
4053 iscsi_conn_attr(ipv4_tos
, ISCSI_PARAM_IPV4_TOS
);
4054 iscsi_conn_attr(ipv6_traffic_class
, ISCSI_PARAM_IPV6_TC
);
4055 iscsi_conn_attr(ipv6_flow_label
, ISCSI_PARAM_IPV6_FLOW_LABEL
);
4056 iscsi_conn_attr(is_fw_assigned_ipv6
, ISCSI_PARAM_IS_FW_ASSIGNED_IPV6
);
4057 iscsi_conn_attr(tcp_xmit_wsf
, ISCSI_PARAM_TCP_XMIT_WSF
);
4058 iscsi_conn_attr(tcp_recv_wsf
, ISCSI_PARAM_TCP_RECV_WSF
);
4059 iscsi_conn_attr(local_ipaddr
, ISCSI_PARAM_LOCAL_IPADDR
);
4061 static const char *const connection_state_names
[] = {
4062 [ISCSI_CONN_UP
] = "up",
4063 [ISCSI_CONN_DOWN
] = "down",
4064 [ISCSI_CONN_FAILED
] = "failed",
4065 [ISCSI_CONN_BOUND
] = "bound"
4068 static ssize_t
show_conn_state(struct device
*dev
,
4069 struct device_attribute
*attr
, char *buf
)
4071 struct iscsi_cls_conn
*conn
= iscsi_dev_to_conn(dev
->parent
);
4072 const char *state
= "unknown";
4074 if (conn
->state
>= 0 &&
4075 conn
->state
< ARRAY_SIZE(connection_state_names
))
4076 state
= connection_state_names
[conn
->state
];
4078 return sysfs_emit(buf
, "%s\n", state
);
4080 static ISCSI_CLASS_ATTR(conn
, state
, S_IRUGO
, show_conn_state
,
4083 #define iscsi_conn_ep_attr_show(param) \
4084 static ssize_t show_conn_ep_param_##param(struct device *dev, \
4085 struct device_attribute *attr,\
4088 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
4089 struct iscsi_transport *t = conn->transport; \
4090 struct iscsi_endpoint *ep; \
4094 * Need to make sure ep_disconnect does not free the LLD's \
4095 * interconnect resources while we are trying to read them. \
4097 mutex_lock(&conn->ep_mutex); \
4099 if (!ep && t->ep_connect) { \
4100 mutex_unlock(&conn->ep_mutex); \
4105 rc = t->get_ep_param(ep, param, buf); \
4107 rc = t->get_conn_param(conn, param, buf); \
4108 mutex_unlock(&conn->ep_mutex); \
4112 #define iscsi_conn_ep_attr(field, param) \
4113 iscsi_conn_ep_attr_show(param) \
4114 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, \
4115 show_conn_ep_param_##param, NULL);
4117 iscsi_conn_ep_attr(address
, ISCSI_PARAM_CONN_ADDRESS
);
4118 iscsi_conn_ep_attr(port
, ISCSI_PARAM_CONN_PORT
);
4120 static struct attribute
*iscsi_conn_attrs
[] = {
4121 &dev_attr_conn_max_recv_dlength
.attr
,
4122 &dev_attr_conn_max_xmit_dlength
.attr
,
4123 &dev_attr_conn_header_digest
.attr
,
4124 &dev_attr_conn_data_digest
.attr
,
4125 &dev_attr_conn_ifmarker
.attr
,
4126 &dev_attr_conn_ofmarker
.attr
,
4127 &dev_attr_conn_address
.attr
,
4128 &dev_attr_conn_port
.attr
,
4129 &dev_attr_conn_exp_statsn
.attr
,
4130 &dev_attr_conn_persistent_address
.attr
,
4131 &dev_attr_conn_persistent_port
.attr
,
4132 &dev_attr_conn_ping_tmo
.attr
,
4133 &dev_attr_conn_recv_tmo
.attr
,
4134 &dev_attr_conn_local_port
.attr
,
4135 &dev_attr_conn_statsn
.attr
,
4136 &dev_attr_conn_keepalive_tmo
.attr
,
4137 &dev_attr_conn_max_segment_size
.attr
,
4138 &dev_attr_conn_tcp_timestamp_stat
.attr
,
4139 &dev_attr_conn_tcp_wsf_disable
.attr
,
4140 &dev_attr_conn_tcp_nagle_disable
.attr
,
4141 &dev_attr_conn_tcp_timer_scale
.attr
,
4142 &dev_attr_conn_tcp_timestamp_enable
.attr
,
4143 &dev_attr_conn_fragment_disable
.attr
,
4144 &dev_attr_conn_ipv4_tos
.attr
,
4145 &dev_attr_conn_ipv6_traffic_class
.attr
,
4146 &dev_attr_conn_ipv6_flow_label
.attr
,
4147 &dev_attr_conn_is_fw_assigned_ipv6
.attr
,
4148 &dev_attr_conn_tcp_xmit_wsf
.attr
,
4149 &dev_attr_conn_tcp_recv_wsf
.attr
,
4150 &dev_attr_conn_local_ipaddr
.attr
,
4151 &dev_attr_conn_state
.attr
,
4155 static umode_t
iscsi_conn_attr_is_visible(struct kobject
*kobj
,
4156 struct attribute
*attr
, int i
)
4158 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4159 struct iscsi_cls_conn
*conn
= transport_class_to_conn(cdev
);
4160 struct iscsi_transport
*t
= conn
->transport
;
4163 if (attr
== &dev_attr_conn_max_recv_dlength
.attr
)
4164 param
= ISCSI_PARAM_MAX_RECV_DLENGTH
;
4165 else if (attr
== &dev_attr_conn_max_xmit_dlength
.attr
)
4166 param
= ISCSI_PARAM_MAX_XMIT_DLENGTH
;
4167 else if (attr
== &dev_attr_conn_header_digest
.attr
)
4168 param
= ISCSI_PARAM_HDRDGST_EN
;
4169 else if (attr
== &dev_attr_conn_data_digest
.attr
)
4170 param
= ISCSI_PARAM_DATADGST_EN
;
4171 else if (attr
== &dev_attr_conn_ifmarker
.attr
)
4172 param
= ISCSI_PARAM_IFMARKER_EN
;
4173 else if (attr
== &dev_attr_conn_ofmarker
.attr
)
4174 param
= ISCSI_PARAM_OFMARKER_EN
;
4175 else if (attr
== &dev_attr_conn_address
.attr
)
4176 param
= ISCSI_PARAM_CONN_ADDRESS
;
4177 else if (attr
== &dev_attr_conn_port
.attr
)
4178 param
= ISCSI_PARAM_CONN_PORT
;
4179 else if (attr
== &dev_attr_conn_exp_statsn
.attr
)
4180 param
= ISCSI_PARAM_EXP_STATSN
;
4181 else if (attr
== &dev_attr_conn_persistent_address
.attr
)
4182 param
= ISCSI_PARAM_PERSISTENT_ADDRESS
;
4183 else if (attr
== &dev_attr_conn_persistent_port
.attr
)
4184 param
= ISCSI_PARAM_PERSISTENT_PORT
;
4185 else if (attr
== &dev_attr_conn_ping_tmo
.attr
)
4186 param
= ISCSI_PARAM_PING_TMO
;
4187 else if (attr
== &dev_attr_conn_recv_tmo
.attr
)
4188 param
= ISCSI_PARAM_RECV_TMO
;
4189 else if (attr
== &dev_attr_conn_local_port
.attr
)
4190 param
= ISCSI_PARAM_LOCAL_PORT
;
4191 else if (attr
== &dev_attr_conn_statsn
.attr
)
4192 param
= ISCSI_PARAM_STATSN
;
4193 else if (attr
== &dev_attr_conn_keepalive_tmo
.attr
)
4194 param
= ISCSI_PARAM_KEEPALIVE_TMO
;
4195 else if (attr
== &dev_attr_conn_max_segment_size
.attr
)
4196 param
= ISCSI_PARAM_MAX_SEGMENT_SIZE
;
4197 else if (attr
== &dev_attr_conn_tcp_timestamp_stat
.attr
)
4198 param
= ISCSI_PARAM_TCP_TIMESTAMP_STAT
;
4199 else if (attr
== &dev_attr_conn_tcp_wsf_disable
.attr
)
4200 param
= ISCSI_PARAM_TCP_WSF_DISABLE
;
4201 else if (attr
== &dev_attr_conn_tcp_nagle_disable
.attr
)
4202 param
= ISCSI_PARAM_TCP_NAGLE_DISABLE
;
4203 else if (attr
== &dev_attr_conn_tcp_timer_scale
.attr
)
4204 param
= ISCSI_PARAM_TCP_TIMER_SCALE
;
4205 else if (attr
== &dev_attr_conn_tcp_timestamp_enable
.attr
)
4206 param
= ISCSI_PARAM_TCP_TIMESTAMP_EN
;
4207 else if (attr
== &dev_attr_conn_fragment_disable
.attr
)
4208 param
= ISCSI_PARAM_IP_FRAGMENT_DISABLE
;
4209 else if (attr
== &dev_attr_conn_ipv4_tos
.attr
)
4210 param
= ISCSI_PARAM_IPV4_TOS
;
4211 else if (attr
== &dev_attr_conn_ipv6_traffic_class
.attr
)
4212 param
= ISCSI_PARAM_IPV6_TC
;
4213 else if (attr
== &dev_attr_conn_ipv6_flow_label
.attr
)
4214 param
= ISCSI_PARAM_IPV6_FLOW_LABEL
;
4215 else if (attr
== &dev_attr_conn_is_fw_assigned_ipv6
.attr
)
4216 param
= ISCSI_PARAM_IS_FW_ASSIGNED_IPV6
;
4217 else if (attr
== &dev_attr_conn_tcp_xmit_wsf
.attr
)
4218 param
= ISCSI_PARAM_TCP_XMIT_WSF
;
4219 else if (attr
== &dev_attr_conn_tcp_recv_wsf
.attr
)
4220 param
= ISCSI_PARAM_TCP_RECV_WSF
;
4221 else if (attr
== &dev_attr_conn_local_ipaddr
.attr
)
4222 param
= ISCSI_PARAM_LOCAL_IPADDR
;
4223 else if (attr
== &dev_attr_conn_state
.attr
)
4226 WARN_ONCE(1, "Invalid conn attr");
4230 return t
->attr_is_visible(ISCSI_PARAM
, param
);
4233 static struct attribute_group iscsi_conn_group
= {
4234 .attrs
= iscsi_conn_attrs
,
4235 .is_visible
= iscsi_conn_attr_is_visible
,
4239 * iSCSI session attrs
4241 #define iscsi_session_attr_show(param, perm) \
4243 show_session_param_##param(struct device *dev, \
4244 struct device_attribute *attr, char *buf) \
4246 struct iscsi_cls_session *session = \
4247 iscsi_dev_to_session(dev->parent); \
4248 struct iscsi_transport *t = session->transport; \
4250 if (perm && !capable(CAP_SYS_ADMIN)) \
4252 return t->get_session_param(session, param, buf); \
4255 #define iscsi_session_attr(field, param, perm) \
4256 iscsi_session_attr_show(param, perm) \
4257 static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
4259 iscsi_session_attr(targetname
, ISCSI_PARAM_TARGET_NAME
, 0);
4260 iscsi_session_attr(initial_r2t
, ISCSI_PARAM_INITIAL_R2T_EN
, 0);
4261 iscsi_session_attr(max_outstanding_r2t
, ISCSI_PARAM_MAX_R2T
, 0);
4262 iscsi_session_attr(immediate_data
, ISCSI_PARAM_IMM_DATA_EN
, 0);
4263 iscsi_session_attr(first_burst_len
, ISCSI_PARAM_FIRST_BURST
, 0);
4264 iscsi_session_attr(max_burst_len
, ISCSI_PARAM_MAX_BURST
, 0);
4265 iscsi_session_attr(data_pdu_in_order
, ISCSI_PARAM_PDU_INORDER_EN
, 0);
4266 iscsi_session_attr(data_seq_in_order
, ISCSI_PARAM_DATASEQ_INORDER_EN
, 0);
4267 iscsi_session_attr(erl
, ISCSI_PARAM_ERL
, 0);
4268 iscsi_session_attr(tpgt
, ISCSI_PARAM_TPGT
, 0);
4269 iscsi_session_attr(username
, ISCSI_PARAM_USERNAME
, 1);
4270 iscsi_session_attr(username_in
, ISCSI_PARAM_USERNAME_IN
, 1);
4271 iscsi_session_attr(password
, ISCSI_PARAM_PASSWORD
, 1);
4272 iscsi_session_attr(password_in
, ISCSI_PARAM_PASSWORD_IN
, 1);
4273 iscsi_session_attr(chap_out_idx
, ISCSI_PARAM_CHAP_OUT_IDX
, 1);
4274 iscsi_session_attr(chap_in_idx
, ISCSI_PARAM_CHAP_IN_IDX
, 1);
4275 iscsi_session_attr(fast_abort
, ISCSI_PARAM_FAST_ABORT
, 0);
4276 iscsi_session_attr(abort_tmo
, ISCSI_PARAM_ABORT_TMO
, 0);
4277 iscsi_session_attr(lu_reset_tmo
, ISCSI_PARAM_LU_RESET_TMO
, 0);
4278 iscsi_session_attr(tgt_reset_tmo
, ISCSI_PARAM_TGT_RESET_TMO
, 0);
4279 iscsi_session_attr(ifacename
, ISCSI_PARAM_IFACE_NAME
, 0);
4280 iscsi_session_attr(initiatorname
, ISCSI_PARAM_INITIATOR_NAME
, 0);
4281 iscsi_session_attr(targetalias
, ISCSI_PARAM_TARGET_ALIAS
, 0);
4282 iscsi_session_attr(boot_root
, ISCSI_PARAM_BOOT_ROOT
, 0);
4283 iscsi_session_attr(boot_nic
, ISCSI_PARAM_BOOT_NIC
, 0);
4284 iscsi_session_attr(boot_target
, ISCSI_PARAM_BOOT_TARGET
, 0);
4285 iscsi_session_attr(auto_snd_tgt_disable
, ISCSI_PARAM_AUTO_SND_TGT_DISABLE
, 0);
4286 iscsi_session_attr(discovery_session
, ISCSI_PARAM_DISCOVERY_SESS
, 0);
4287 iscsi_session_attr(portal_type
, ISCSI_PARAM_PORTAL_TYPE
, 0);
4288 iscsi_session_attr(chap_auth
, ISCSI_PARAM_CHAP_AUTH_EN
, 0);
4289 iscsi_session_attr(discovery_logout
, ISCSI_PARAM_DISCOVERY_LOGOUT_EN
, 0);
4290 iscsi_session_attr(bidi_chap
, ISCSI_PARAM_BIDI_CHAP_EN
, 0);
4291 iscsi_session_attr(discovery_auth_optional
,
4292 ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL
, 0);
4293 iscsi_session_attr(def_time2wait
, ISCSI_PARAM_DEF_TIME2WAIT
, 0);
4294 iscsi_session_attr(def_time2retain
, ISCSI_PARAM_DEF_TIME2RETAIN
, 0);
4295 iscsi_session_attr(isid
, ISCSI_PARAM_ISID
, 0);
4296 iscsi_session_attr(tsid
, ISCSI_PARAM_TSID
, 0);
4297 iscsi_session_attr(def_taskmgmt_tmo
, ISCSI_PARAM_DEF_TASKMGMT_TMO
, 0);
4298 iscsi_session_attr(discovery_parent_idx
, ISCSI_PARAM_DISCOVERY_PARENT_IDX
, 0);
4299 iscsi_session_attr(discovery_parent_type
, ISCSI_PARAM_DISCOVERY_PARENT_TYPE
, 0);
4302 show_priv_session_state(struct device
*dev
, struct device_attribute
*attr
,
4305 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
->parent
);
4306 return sysfs_emit(buf
, "%s\n", iscsi_session_state_name(session
->state
));
4308 static ISCSI_CLASS_ATTR(priv_sess
, state
, S_IRUGO
, show_priv_session_state
,
4311 show_priv_session_creator(struct device
*dev
, struct device_attribute
*attr
,
4314 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
->parent
);
4315 return sysfs_emit(buf
, "%d\n", session
->creator
);
4317 static ISCSI_CLASS_ATTR(priv_sess
, creator
, S_IRUGO
, show_priv_session_creator
,
4320 show_priv_session_target_id(struct device
*dev
, struct device_attribute
*attr
,
4323 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
->parent
);
4324 return sysfs_emit(buf
, "%d\n", session
->target_id
);
4326 static ISCSI_CLASS_ATTR(priv_sess
, target_id
, S_IRUGO
,
4327 show_priv_session_target_id
, NULL
);
4329 #define iscsi_priv_session_attr_show(field, format) \
4331 show_priv_session_##field(struct device *dev, \
4332 struct device_attribute *attr, char *buf) \
4334 struct iscsi_cls_session *session = \
4335 iscsi_dev_to_session(dev->parent); \
4336 if (session->field == -1) \
4337 return sysfs_emit(buf, "off\n"); \
4338 return sysfs_emit(buf, format"\n", session->field); \
4341 #define iscsi_priv_session_attr_store(field) \
4343 store_priv_session_##field(struct device *dev, \
4344 struct device_attribute *attr, \
4345 const char *buf, size_t count) \
4349 struct iscsi_cls_session *session = \
4350 iscsi_dev_to_session(dev->parent); \
4351 if ((session->state == ISCSI_SESSION_FREE) || \
4352 (session->state == ISCSI_SESSION_FAILED)) \
4354 if (strncmp(buf, "off", 3) == 0) { \
4355 session->field = -1; \
4356 session->field##_sysfs_override = true; \
4358 val = simple_strtoul(buf, &cp, 0); \
4359 if (*cp != '\0' && *cp != '\n') \
4361 session->field = val; \
4362 session->field##_sysfs_override = true; \
4367 #define iscsi_priv_session_rw_attr(field, format) \
4368 iscsi_priv_session_attr_show(field, format) \
4369 iscsi_priv_session_attr_store(field) \
4370 static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO | S_IWUSR, \
4371 show_priv_session_##field, \
4372 store_priv_session_##field)
4374 iscsi_priv_session_rw_attr(recovery_tmo
, "%d");
4376 static struct attribute
*iscsi_session_attrs
[] = {
4377 &dev_attr_sess_initial_r2t
.attr
,
4378 &dev_attr_sess_max_outstanding_r2t
.attr
,
4379 &dev_attr_sess_immediate_data
.attr
,
4380 &dev_attr_sess_first_burst_len
.attr
,
4381 &dev_attr_sess_max_burst_len
.attr
,
4382 &dev_attr_sess_data_pdu_in_order
.attr
,
4383 &dev_attr_sess_data_seq_in_order
.attr
,
4384 &dev_attr_sess_erl
.attr
,
4385 &dev_attr_sess_targetname
.attr
,
4386 &dev_attr_sess_tpgt
.attr
,
4387 &dev_attr_sess_password
.attr
,
4388 &dev_attr_sess_password_in
.attr
,
4389 &dev_attr_sess_username
.attr
,
4390 &dev_attr_sess_username_in
.attr
,
4391 &dev_attr_sess_fast_abort
.attr
,
4392 &dev_attr_sess_abort_tmo
.attr
,
4393 &dev_attr_sess_lu_reset_tmo
.attr
,
4394 &dev_attr_sess_tgt_reset_tmo
.attr
,
4395 &dev_attr_sess_ifacename
.attr
,
4396 &dev_attr_sess_initiatorname
.attr
,
4397 &dev_attr_sess_targetalias
.attr
,
4398 &dev_attr_sess_boot_root
.attr
,
4399 &dev_attr_sess_boot_nic
.attr
,
4400 &dev_attr_sess_boot_target
.attr
,
4401 &dev_attr_priv_sess_recovery_tmo
.attr
,
4402 &dev_attr_priv_sess_state
.attr
,
4403 &dev_attr_priv_sess_creator
.attr
,
4404 &dev_attr_sess_chap_out_idx
.attr
,
4405 &dev_attr_sess_chap_in_idx
.attr
,
4406 &dev_attr_priv_sess_target_id
.attr
,
4407 &dev_attr_sess_auto_snd_tgt_disable
.attr
,
4408 &dev_attr_sess_discovery_session
.attr
,
4409 &dev_attr_sess_portal_type
.attr
,
4410 &dev_attr_sess_chap_auth
.attr
,
4411 &dev_attr_sess_discovery_logout
.attr
,
4412 &dev_attr_sess_bidi_chap
.attr
,
4413 &dev_attr_sess_discovery_auth_optional
.attr
,
4414 &dev_attr_sess_def_time2wait
.attr
,
4415 &dev_attr_sess_def_time2retain
.attr
,
4416 &dev_attr_sess_isid
.attr
,
4417 &dev_attr_sess_tsid
.attr
,
4418 &dev_attr_sess_def_taskmgmt_tmo
.attr
,
4419 &dev_attr_sess_discovery_parent_idx
.attr
,
4420 &dev_attr_sess_discovery_parent_type
.attr
,
4424 static umode_t
iscsi_session_attr_is_visible(struct kobject
*kobj
,
4425 struct attribute
*attr
, int i
)
4427 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4428 struct iscsi_cls_session
*session
= transport_class_to_session(cdev
);
4429 struct iscsi_transport
*t
= session
->transport
;
4432 if (attr
== &dev_attr_sess_initial_r2t
.attr
)
4433 param
= ISCSI_PARAM_INITIAL_R2T_EN
;
4434 else if (attr
== &dev_attr_sess_max_outstanding_r2t
.attr
)
4435 param
= ISCSI_PARAM_MAX_R2T
;
4436 else if (attr
== &dev_attr_sess_immediate_data
.attr
)
4437 param
= ISCSI_PARAM_IMM_DATA_EN
;
4438 else if (attr
== &dev_attr_sess_first_burst_len
.attr
)
4439 param
= ISCSI_PARAM_FIRST_BURST
;
4440 else if (attr
== &dev_attr_sess_max_burst_len
.attr
)
4441 param
= ISCSI_PARAM_MAX_BURST
;
4442 else if (attr
== &dev_attr_sess_data_pdu_in_order
.attr
)
4443 param
= ISCSI_PARAM_PDU_INORDER_EN
;
4444 else if (attr
== &dev_attr_sess_data_seq_in_order
.attr
)
4445 param
= ISCSI_PARAM_DATASEQ_INORDER_EN
;
4446 else if (attr
== &dev_attr_sess_erl
.attr
)
4447 param
= ISCSI_PARAM_ERL
;
4448 else if (attr
== &dev_attr_sess_targetname
.attr
)
4449 param
= ISCSI_PARAM_TARGET_NAME
;
4450 else if (attr
== &dev_attr_sess_tpgt
.attr
)
4451 param
= ISCSI_PARAM_TPGT
;
4452 else if (attr
== &dev_attr_sess_chap_in_idx
.attr
)
4453 param
= ISCSI_PARAM_CHAP_IN_IDX
;
4454 else if (attr
== &dev_attr_sess_chap_out_idx
.attr
)
4455 param
= ISCSI_PARAM_CHAP_OUT_IDX
;
4456 else if (attr
== &dev_attr_sess_password
.attr
)
4457 param
= ISCSI_PARAM_USERNAME
;
4458 else if (attr
== &dev_attr_sess_password_in
.attr
)
4459 param
= ISCSI_PARAM_USERNAME_IN
;
4460 else if (attr
== &dev_attr_sess_username
.attr
)
4461 param
= ISCSI_PARAM_PASSWORD
;
4462 else if (attr
== &dev_attr_sess_username_in
.attr
)
4463 param
= ISCSI_PARAM_PASSWORD_IN
;
4464 else if (attr
== &dev_attr_sess_fast_abort
.attr
)
4465 param
= ISCSI_PARAM_FAST_ABORT
;
4466 else if (attr
== &dev_attr_sess_abort_tmo
.attr
)
4467 param
= ISCSI_PARAM_ABORT_TMO
;
4468 else if (attr
== &dev_attr_sess_lu_reset_tmo
.attr
)
4469 param
= ISCSI_PARAM_LU_RESET_TMO
;
4470 else if (attr
== &dev_attr_sess_tgt_reset_tmo
.attr
)
4471 param
= ISCSI_PARAM_TGT_RESET_TMO
;
4472 else if (attr
== &dev_attr_sess_ifacename
.attr
)
4473 param
= ISCSI_PARAM_IFACE_NAME
;
4474 else if (attr
== &dev_attr_sess_initiatorname
.attr
)
4475 param
= ISCSI_PARAM_INITIATOR_NAME
;
4476 else if (attr
== &dev_attr_sess_targetalias
.attr
)
4477 param
= ISCSI_PARAM_TARGET_ALIAS
;
4478 else if (attr
== &dev_attr_sess_boot_root
.attr
)
4479 param
= ISCSI_PARAM_BOOT_ROOT
;
4480 else if (attr
== &dev_attr_sess_boot_nic
.attr
)
4481 param
= ISCSI_PARAM_BOOT_NIC
;
4482 else if (attr
== &dev_attr_sess_boot_target
.attr
)
4483 param
= ISCSI_PARAM_BOOT_TARGET
;
4484 else if (attr
== &dev_attr_sess_auto_snd_tgt_disable
.attr
)
4485 param
= ISCSI_PARAM_AUTO_SND_TGT_DISABLE
;
4486 else if (attr
== &dev_attr_sess_discovery_session
.attr
)
4487 param
= ISCSI_PARAM_DISCOVERY_SESS
;
4488 else if (attr
== &dev_attr_sess_portal_type
.attr
)
4489 param
= ISCSI_PARAM_PORTAL_TYPE
;
4490 else if (attr
== &dev_attr_sess_chap_auth
.attr
)
4491 param
= ISCSI_PARAM_CHAP_AUTH_EN
;
4492 else if (attr
== &dev_attr_sess_discovery_logout
.attr
)
4493 param
= ISCSI_PARAM_DISCOVERY_LOGOUT_EN
;
4494 else if (attr
== &dev_attr_sess_bidi_chap
.attr
)
4495 param
= ISCSI_PARAM_BIDI_CHAP_EN
;
4496 else if (attr
== &dev_attr_sess_discovery_auth_optional
.attr
)
4497 param
= ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL
;
4498 else if (attr
== &dev_attr_sess_def_time2wait
.attr
)
4499 param
= ISCSI_PARAM_DEF_TIME2WAIT
;
4500 else if (attr
== &dev_attr_sess_def_time2retain
.attr
)
4501 param
= ISCSI_PARAM_DEF_TIME2RETAIN
;
4502 else if (attr
== &dev_attr_sess_isid
.attr
)
4503 param
= ISCSI_PARAM_ISID
;
4504 else if (attr
== &dev_attr_sess_tsid
.attr
)
4505 param
= ISCSI_PARAM_TSID
;
4506 else if (attr
== &dev_attr_sess_def_taskmgmt_tmo
.attr
)
4507 param
= ISCSI_PARAM_DEF_TASKMGMT_TMO
;
4508 else if (attr
== &dev_attr_sess_discovery_parent_idx
.attr
)
4509 param
= ISCSI_PARAM_DISCOVERY_PARENT_IDX
;
4510 else if (attr
== &dev_attr_sess_discovery_parent_type
.attr
)
4511 param
= ISCSI_PARAM_DISCOVERY_PARENT_TYPE
;
4512 else if (attr
== &dev_attr_priv_sess_recovery_tmo
.attr
)
4513 return S_IRUGO
| S_IWUSR
;
4514 else if (attr
== &dev_attr_priv_sess_state
.attr
)
4516 else if (attr
== &dev_attr_priv_sess_creator
.attr
)
4518 else if (attr
== &dev_attr_priv_sess_target_id
.attr
)
4521 WARN_ONCE(1, "Invalid session attr");
4525 return t
->attr_is_visible(ISCSI_PARAM
, param
);
4528 static struct attribute_group iscsi_session_group
= {
4529 .attrs
= iscsi_session_attrs
,
4530 .is_visible
= iscsi_session_attr_is_visible
,
4536 #define iscsi_host_attr_show(param) \
4538 show_host_param_##param(struct device *dev, \
4539 struct device_attribute *attr, char *buf) \
4541 struct Scsi_Host *shost = transport_class_to_shost(dev); \
4542 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
4543 return priv->iscsi_transport->get_host_param(shost, param, buf); \
4546 #define iscsi_host_attr(field, param) \
4547 iscsi_host_attr_show(param) \
4548 static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param, \
4551 iscsi_host_attr(netdev
, ISCSI_HOST_PARAM_NETDEV_NAME
);
4552 iscsi_host_attr(hwaddress
, ISCSI_HOST_PARAM_HWADDRESS
);
4553 iscsi_host_attr(ipaddress
, ISCSI_HOST_PARAM_IPADDRESS
);
4554 iscsi_host_attr(initiatorname
, ISCSI_HOST_PARAM_INITIATOR_NAME
);
4555 iscsi_host_attr(port_state
, ISCSI_HOST_PARAM_PORT_STATE
);
4556 iscsi_host_attr(port_speed
, ISCSI_HOST_PARAM_PORT_SPEED
);
4558 static struct attribute
*iscsi_host_attrs
[] = {
4559 &dev_attr_host_netdev
.attr
,
4560 &dev_attr_host_hwaddress
.attr
,
4561 &dev_attr_host_ipaddress
.attr
,
4562 &dev_attr_host_initiatorname
.attr
,
4563 &dev_attr_host_port_state
.attr
,
4564 &dev_attr_host_port_speed
.attr
,
4568 static umode_t
iscsi_host_attr_is_visible(struct kobject
*kobj
,
4569 struct attribute
*attr
, int i
)
4571 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4572 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
4573 struct iscsi_internal
*priv
= to_iscsi_internal(shost
->transportt
);
4576 if (attr
== &dev_attr_host_netdev
.attr
)
4577 param
= ISCSI_HOST_PARAM_NETDEV_NAME
;
4578 else if (attr
== &dev_attr_host_hwaddress
.attr
)
4579 param
= ISCSI_HOST_PARAM_HWADDRESS
;
4580 else if (attr
== &dev_attr_host_ipaddress
.attr
)
4581 param
= ISCSI_HOST_PARAM_IPADDRESS
;
4582 else if (attr
== &dev_attr_host_initiatorname
.attr
)
4583 param
= ISCSI_HOST_PARAM_INITIATOR_NAME
;
4584 else if (attr
== &dev_attr_host_port_state
.attr
)
4585 param
= ISCSI_HOST_PARAM_PORT_STATE
;
4586 else if (attr
== &dev_attr_host_port_speed
.attr
)
4587 param
= ISCSI_HOST_PARAM_PORT_SPEED
;
4589 WARN_ONCE(1, "Invalid host attr");
4593 return priv
->iscsi_transport
->attr_is_visible(ISCSI_HOST_PARAM
, param
);
4596 static struct attribute_group iscsi_host_group
= {
4597 .attrs
= iscsi_host_attrs
,
4598 .is_visible
= iscsi_host_attr_is_visible
,
4601 /* convert iscsi_port_speed values to ascii string name */
4602 static const struct {
4603 enum iscsi_port_speed value
;
4605 } iscsi_port_speed_names
[] = {
4606 {ISCSI_PORT_SPEED_UNKNOWN
, "Unknown" },
4607 {ISCSI_PORT_SPEED_10MBPS
, "10 Mbps" },
4608 {ISCSI_PORT_SPEED_100MBPS
, "100 Mbps" },
4609 {ISCSI_PORT_SPEED_1GBPS
, "1 Gbps" },
4610 {ISCSI_PORT_SPEED_10GBPS
, "10 Gbps" },
4611 {ISCSI_PORT_SPEED_25GBPS
, "25 Gbps" },
4612 {ISCSI_PORT_SPEED_40GBPS
, "40 Gbps" },
4615 char *iscsi_get_port_speed_name(struct Scsi_Host
*shost
)
4618 char *speed
= "Unknown!";
4619 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
4620 uint32_t port_speed
= ihost
->port_speed
;
4622 for (i
= 0; i
< ARRAY_SIZE(iscsi_port_speed_names
); i
++) {
4623 if (iscsi_port_speed_names
[i
].value
& port_speed
) {
4624 speed
= iscsi_port_speed_names
[i
].name
;
4630 EXPORT_SYMBOL_GPL(iscsi_get_port_speed_name
);
4632 /* convert iscsi_port_state values to ascii string name */
4633 static const struct {
4634 enum iscsi_port_state value
;
4636 } iscsi_port_state_names
[] = {
4637 {ISCSI_PORT_STATE_DOWN
, "LINK DOWN" },
4638 {ISCSI_PORT_STATE_UP
, "LINK UP" },
4641 char *iscsi_get_port_state_name(struct Scsi_Host
*shost
)
4644 char *state
= "Unknown!";
4645 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
4646 uint32_t port_state
= ihost
->port_state
;
4648 for (i
= 0; i
< ARRAY_SIZE(iscsi_port_state_names
); i
++) {
4649 if (iscsi_port_state_names
[i
].value
& port_state
) {
4650 state
= iscsi_port_state_names
[i
].name
;
4656 EXPORT_SYMBOL_GPL(iscsi_get_port_state_name
);
4658 static int iscsi_session_match(struct attribute_container
*cont
,
4661 struct iscsi_cls_session
*session
;
4662 struct Scsi_Host
*shost
;
4663 struct iscsi_internal
*priv
;
4665 if (!iscsi_is_session_dev(dev
))
4668 session
= iscsi_dev_to_session(dev
);
4669 shost
= iscsi_session_to_shost(session
);
4670 if (!shost
->transportt
)
4673 priv
= to_iscsi_internal(shost
->transportt
);
4674 if (priv
->session_cont
.ac
.class != &iscsi_session_class
.class)
4677 return &priv
->session_cont
.ac
== cont
;
4680 static int iscsi_conn_match(struct attribute_container
*cont
,
4683 struct iscsi_cls_session
*session
;
4684 struct iscsi_cls_conn
*conn
;
4685 struct Scsi_Host
*shost
;
4686 struct iscsi_internal
*priv
;
4688 if (!iscsi_is_conn_dev(dev
))
4691 conn
= iscsi_dev_to_conn(dev
);
4692 session
= iscsi_dev_to_session(conn
->dev
.parent
);
4693 shost
= iscsi_session_to_shost(session
);
4695 if (!shost
->transportt
)
4698 priv
= to_iscsi_internal(shost
->transportt
);
4699 if (priv
->conn_cont
.ac
.class != &iscsi_connection_class
.class)
4702 return &priv
->conn_cont
.ac
== cont
;
4705 static int iscsi_host_match(struct attribute_container
*cont
,
4708 struct Scsi_Host
*shost
;
4709 struct iscsi_internal
*priv
;
4711 if (!scsi_is_host_device(dev
))
4714 shost
= dev_to_shost(dev
);
4715 if (!shost
->transportt
||
4716 shost
->transportt
->host_attrs
.ac
.class != &iscsi_host_class
.class)
4719 priv
= to_iscsi_internal(shost
->transportt
);
4720 return &priv
->t
.host_attrs
.ac
== cont
;
4723 struct scsi_transport_template
*
4724 iscsi_register_transport(struct iscsi_transport
*tt
)
4726 struct iscsi_internal
*priv
;
4727 unsigned long flags
;
4731 WARN_ON(tt
->ep_disconnect
&& !tt
->unbind_conn
);
4733 priv
= iscsi_if_transport_lookup(tt
);
4737 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
4740 INIT_LIST_HEAD(&priv
->list
);
4741 priv
->iscsi_transport
= tt
;
4742 priv
->t
.user_scan
= iscsi_user_scan
;
4743 priv
->t
.create_work_queue
= 1;
4745 priv
->dev
.class = &iscsi_transport_class
;
4746 dev_set_name(&priv
->dev
, "%s", tt
->name
);
4747 err
= device_register(&priv
->dev
);
4751 err
= sysfs_create_group(&priv
->dev
.kobj
, &iscsi_transport_group
);
4753 goto unregister_dev
;
4755 /* host parameters */
4756 priv
->t
.host_attrs
.ac
.class = &iscsi_host_class
.class;
4757 priv
->t
.host_attrs
.ac
.match
= iscsi_host_match
;
4758 priv
->t
.host_attrs
.ac
.grp
= &iscsi_host_group
;
4759 priv
->t
.host_size
= sizeof(struct iscsi_cls_host
);
4760 transport_container_register(&priv
->t
.host_attrs
);
4762 /* connection parameters */
4763 priv
->conn_cont
.ac
.class = &iscsi_connection_class
.class;
4764 priv
->conn_cont
.ac
.match
= iscsi_conn_match
;
4765 priv
->conn_cont
.ac
.grp
= &iscsi_conn_group
;
4766 transport_container_register(&priv
->conn_cont
);
4768 /* session parameters */
4769 priv
->session_cont
.ac
.class = &iscsi_session_class
.class;
4770 priv
->session_cont
.ac
.match
= iscsi_session_match
;
4771 priv
->session_cont
.ac
.grp
= &iscsi_session_group
;
4772 transport_container_register(&priv
->session_cont
);
4774 spin_lock_irqsave(&iscsi_transport_lock
, flags
);
4775 list_add(&priv
->list
, &iscsi_transports
);
4776 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
4778 printk(KERN_NOTICE
"iscsi: registered transport (%s)\n", tt
->name
);
4782 device_unregister(&priv
->dev
);
4788 EXPORT_SYMBOL_GPL(iscsi_register_transport
);
4790 int iscsi_unregister_transport(struct iscsi_transport
*tt
)
4792 struct iscsi_internal
*priv
;
4793 unsigned long flags
;
4797 mutex_lock(&rx_queue_mutex
);
4799 priv
= iscsi_if_transport_lookup(tt
);
4802 spin_lock_irqsave(&iscsi_transport_lock
, flags
);
4803 list_del(&priv
->list
);
4804 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
4806 transport_container_unregister(&priv
->conn_cont
);
4807 transport_container_unregister(&priv
->session_cont
);
4808 transport_container_unregister(&priv
->t
.host_attrs
);
4810 sysfs_remove_group(&priv
->dev
.kobj
, &iscsi_transport_group
);
4811 device_unregister(&priv
->dev
);
4812 mutex_unlock(&rx_queue_mutex
);
4816 EXPORT_SYMBOL_GPL(iscsi_unregister_transport
);
4818 void iscsi_dbg_trace(void (*trace
)(struct device
*dev
, struct va_format
*),
4819 struct device
*dev
, const char *fmt
, ...)
4821 struct va_format vaf
;
4824 va_start(args
, fmt
);
4830 EXPORT_SYMBOL_GPL(iscsi_dbg_trace
);
4832 static __init
int iscsi_transport_init(void)
4835 struct netlink_kernel_cfg cfg
= {
4837 .input
= iscsi_if_rx
,
4839 printk(KERN_INFO
"Loading iSCSI transport class v%s.\n",
4840 ISCSI_TRANSPORT_VERSION
);
4842 atomic_set(&iscsi_session_nr
, 0);
4844 err
= class_register(&iscsi_transport_class
);
4848 err
= class_register(&iscsi_endpoint_class
);
4850 goto unregister_transport_class
;
4852 err
= class_register(&iscsi_iface_class
);
4854 goto unregister_endpoint_class
;
4856 err
= transport_class_register(&iscsi_host_class
);
4858 goto unregister_iface_class
;
4860 err
= transport_class_register(&iscsi_connection_class
);
4862 goto unregister_host_class
;
4864 err
= transport_class_register(&iscsi_session_class
);
4866 goto unregister_conn_class
;
4868 err
= bus_register(&iscsi_flashnode_bus
);
4870 goto unregister_session_class
;
4872 nls
= netlink_kernel_create(&init_net
, NETLINK_ISCSI
, &cfg
);
4875 goto unregister_flashnode_bus
;
4878 iscsi_eh_timer_workq
= alloc_workqueue("%s",
4879 WQ_SYSFS
| __WQ_LEGACY
| WQ_MEM_RECLAIM
| WQ_UNBOUND
,
4881 if (!iscsi_eh_timer_workq
) {
4886 iscsi_conn_cleanup_workq
= alloc_workqueue("%s",
4887 WQ_SYSFS
| WQ_MEM_RECLAIM
| WQ_UNBOUND
, 0,
4888 "iscsi_conn_cleanup");
4889 if (!iscsi_conn_cleanup_workq
) {
4897 destroy_workqueue(iscsi_eh_timer_workq
);
4899 netlink_kernel_release(nls
);
4900 unregister_flashnode_bus
:
4901 bus_unregister(&iscsi_flashnode_bus
);
4902 unregister_session_class
:
4903 transport_class_unregister(&iscsi_session_class
);
4904 unregister_conn_class
:
4905 transport_class_unregister(&iscsi_connection_class
);
4906 unregister_host_class
:
4907 transport_class_unregister(&iscsi_host_class
);
4908 unregister_iface_class
:
4909 class_unregister(&iscsi_iface_class
);
4910 unregister_endpoint_class
:
4911 class_unregister(&iscsi_endpoint_class
);
4912 unregister_transport_class
:
4913 class_unregister(&iscsi_transport_class
);
4917 static void __exit
iscsi_transport_exit(void)
4919 destroy_workqueue(iscsi_conn_cleanup_workq
);
4920 destroy_workqueue(iscsi_eh_timer_workq
);
4921 netlink_kernel_release(nls
);
4922 bus_unregister(&iscsi_flashnode_bus
);
4923 transport_class_unregister(&iscsi_connection_class
);
4924 transport_class_unregister(&iscsi_session_class
);
4925 transport_class_unregister(&iscsi_host_class
);
4926 class_unregister(&iscsi_endpoint_class
);
4927 class_unregister(&iscsi_iface_class
);
4928 class_unregister(&iscsi_transport_class
);
4931 module_init(iscsi_transport_init
);
4932 module_exit(iscsi_transport_exit
);
4934 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
4935 "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
4936 "Alex Aizman <itn780@yahoo.com>");
4937 MODULE_DESCRIPTION("iSCSI Transport Interface");
4938 MODULE_LICENSE("GPL");
4939 MODULE_VERSION(ISCSI_TRANSPORT_VERSION
);
4940 MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK
, NETLINK_ISCSI
);