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 ISCSI_DBG_TRANS_SESSION(session
, "Unblocking SCSI target\n");
1903 scsi_target_unblock(&session
->dev
, SDEV_TRANSPORT_OFFLINE
);
1904 ISCSI_DBG_TRANS_SESSION(session
, "Completed unblocking SCSI target\n");
1906 if (session
->transport
->session_recovery_timedout
)
1907 session
->transport
->session_recovery_timedout(session
);
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 void iscsi_ep_disconnect(struct iscsi_cls_conn
*conn
, bool is_active
)
2241 struct iscsi_cls_session
*session
= iscsi_conn_to_session(conn
);
2242 struct iscsi_endpoint
*ep
;
2244 ISCSI_DBG_TRANS_CONN(conn
, "disconnect ep.\n");
2245 conn
->state
= ISCSI_CONN_FAILED
;
2247 if (!conn
->ep
|| !session
->transport
->ep_disconnect
)
2253 session
->transport
->unbind_conn(conn
, is_active
);
2254 session
->transport
->ep_disconnect(ep
);
2255 ISCSI_DBG_TRANS_CONN(conn
, "disconnect ep done.\n");
2258 static void iscsi_if_disconnect_bound_ep(struct iscsi_cls_conn
*conn
,
2259 struct iscsi_endpoint
*ep
,
2262 /* Check if this was a conn error and the kernel took ownership */
2263 if (!test_bit(ISCSI_CLS_CONN_BIT_CLEANUP
, &conn
->flags
)) {
2264 iscsi_ep_disconnect(conn
, is_active
);
2266 ISCSI_DBG_TRANS_CONN(conn
, "flush kernel conn cleanup.\n");
2267 mutex_unlock(&conn
->ep_mutex
);
2269 flush_work(&conn
->cleanup_work
);
2271 * Userspace is now done with the EP so we can release the ref
2272 * iscsi_cleanup_conn_work_fn took.
2274 iscsi_put_endpoint(ep
);
2275 mutex_lock(&conn
->ep_mutex
);
2279 static int iscsi_if_stop_conn(struct iscsi_transport
*transport
,
2280 struct iscsi_uevent
*ev
)
2282 int flag
= ev
->u
.stop_conn
.flag
;
2283 struct iscsi_cls_conn
*conn
;
2285 conn
= iscsi_conn_lookup(ev
->u
.stop_conn
.sid
, ev
->u
.stop_conn
.cid
);
2289 ISCSI_DBG_TRANS_CONN(conn
, "iscsi if conn stop.\n");
2291 * If this is a termination we have to call stop_conn with that flag
2292 * so the correct states get set. If we haven't run the work yet try to
2293 * avoid the extra run.
2295 if (flag
== STOP_CONN_TERM
) {
2296 cancel_work_sync(&conn
->cleanup_work
);
2297 iscsi_stop_conn(conn
, flag
);
2300 * For offload, when iscsid is restarted it won't know about
2301 * existing endpoints so it can't do a ep_disconnect. We clean
2302 * it up here for userspace.
2304 mutex_lock(&conn
->ep_mutex
);
2306 iscsi_if_disconnect_bound_ep(conn
, conn
->ep
, true);
2307 mutex_unlock(&conn
->ep_mutex
);
2310 * Figure out if it was the kernel or userspace initiating this.
2312 if (!test_and_set_bit(ISCSI_CLS_CONN_BIT_CLEANUP
, &conn
->flags
)) {
2313 iscsi_stop_conn(conn
, flag
);
2315 ISCSI_DBG_TRANS_CONN(conn
,
2316 "flush kernel conn cleanup.\n");
2317 flush_work(&conn
->cleanup_work
);
2320 * Only clear for recovery to avoid extra cleanup runs during
2323 clear_bit(ISCSI_CLS_CONN_BIT_CLEANUP
, &conn
->flags
);
2325 ISCSI_DBG_TRANS_CONN(conn
, "iscsi if conn stop done.\n");
2329 static void iscsi_cleanup_conn_work_fn(struct work_struct
*work
)
2331 struct iscsi_cls_conn
*conn
= container_of(work
, struct iscsi_cls_conn
,
2333 struct iscsi_cls_session
*session
= iscsi_conn_to_session(conn
);
2335 mutex_lock(&conn
->ep_mutex
);
2337 * If we are not at least bound there is nothing for us to do. Userspace
2338 * will do a ep_disconnect call if offload is used, but will not be
2339 * doing a stop since there is nothing to clean up, so we have to clear
2340 * the cleanup bit here.
2342 if (conn
->state
!= ISCSI_CONN_BOUND
&& conn
->state
!= ISCSI_CONN_UP
) {
2343 ISCSI_DBG_TRANS_CONN(conn
, "Got error while conn is already failed. Ignoring.\n");
2344 clear_bit(ISCSI_CLS_CONN_BIT_CLEANUP
, &conn
->flags
);
2345 mutex_unlock(&conn
->ep_mutex
);
2350 * Get a ref to the ep, so we don't release its ID until after
2351 * userspace is done referencing it in iscsi_if_disconnect_bound_ep.
2354 get_device(&conn
->ep
->dev
);
2355 iscsi_ep_disconnect(conn
, false);
2357 if (system_state
!= SYSTEM_RUNNING
) {
2359 * If the user has set up for the session to never timeout
2360 * then hang like they wanted. For all other cases fail right
2361 * away since userspace is not going to relogin.
2363 if (session
->recovery_tmo
> 0)
2364 session
->recovery_tmo
= 0;
2367 iscsi_stop_conn(conn
, STOP_CONN_RECOVER
);
2368 mutex_unlock(&conn
->ep_mutex
);
2369 ISCSI_DBG_TRANS_CONN(conn
, "cleanup done.\n");
2372 void iscsi_free_session(struct iscsi_cls_session
*session
)
2374 ISCSI_DBG_TRANS_SESSION(session
, "Freeing session\n");
2375 iscsi_session_event(session
, ISCSI_KEVENT_DESTROY_SESSION
);
2376 put_device(&session
->dev
);
2378 EXPORT_SYMBOL_GPL(iscsi_free_session
);
2381 * iscsi_create_conn - create iscsi class connection
2382 * @session: iscsi cls session
2383 * @dd_size: private driver data size
2384 * @cid: connection id
2386 * This can be called from a LLD or iscsi_transport. The connection
2387 * is child of the session so cid must be unique for all connections
2390 * Since we do not support MCS, cid will normally be zero. In some cases
2391 * for software iscsi we could be trying to preallocate a connection struct
2392 * in which case there could be two connection structs and cid would be
2395 struct iscsi_cls_conn
*
2396 iscsi_create_conn(struct iscsi_cls_session
*session
, int dd_size
, uint32_t cid
)
2398 struct iscsi_transport
*transport
= session
->transport
;
2399 struct iscsi_cls_conn
*conn
;
2400 unsigned long flags
;
2403 conn
= kzalloc(sizeof(*conn
) + dd_size
, GFP_KERNEL
);
2407 conn
->dd_data
= &conn
[1];
2409 mutex_init(&conn
->ep_mutex
);
2410 INIT_LIST_HEAD(&conn
->conn_list
);
2411 INIT_WORK(&conn
->cleanup_work
, iscsi_cleanup_conn_work_fn
);
2412 conn
->transport
= transport
;
2414 conn
->state
= ISCSI_CONN_DOWN
;
2416 /* this is released in the dev's release function */
2417 if (!get_device(&session
->dev
))
2420 dev_set_name(&conn
->dev
, "connection%d:%u", session
->sid
, cid
);
2421 conn
->dev
.parent
= &session
->dev
;
2422 conn
->dev
.release
= iscsi_conn_release
;
2423 err
= device_register(&conn
->dev
);
2425 iscsi_cls_session_printk(KERN_ERR
, session
, "could not "
2426 "register connection's dev\n");
2427 goto release_parent_ref
;
2429 err
= transport_register_device(&conn
->dev
);
2431 iscsi_cls_session_printk(KERN_ERR
, session
, "could not "
2432 "register transport's dev\n");
2433 goto release_conn_ref
;
2436 spin_lock_irqsave(&connlock
, flags
);
2437 list_add(&conn
->conn_list
, &connlist
);
2438 spin_unlock_irqrestore(&connlock
, flags
);
2440 ISCSI_DBG_TRANS_CONN(conn
, "Completed conn creation\n");
2444 device_unregister(&conn
->dev
);
2445 put_device(&session
->dev
);
2448 put_device(&session
->dev
);
2454 EXPORT_SYMBOL_GPL(iscsi_create_conn
);
2457 * iscsi_destroy_conn - destroy iscsi class connection
2458 * @conn: iscsi cls session
2460 * This can be called from a LLD or iscsi_transport.
2462 int iscsi_destroy_conn(struct iscsi_cls_conn
*conn
)
2464 unsigned long flags
;
2466 spin_lock_irqsave(&connlock
, flags
);
2467 list_del(&conn
->conn_list
);
2468 spin_unlock_irqrestore(&connlock
, flags
);
2470 transport_unregister_device(&conn
->dev
);
2471 ISCSI_DBG_TRANS_CONN(conn
, "Completing conn destruction\n");
2472 device_unregister(&conn
->dev
);
2475 EXPORT_SYMBOL_GPL(iscsi_destroy_conn
);
2477 void iscsi_put_conn(struct iscsi_cls_conn
*conn
)
2479 put_device(&conn
->dev
);
2481 EXPORT_SYMBOL_GPL(iscsi_put_conn
);
2483 void iscsi_get_conn(struct iscsi_cls_conn
*conn
)
2485 get_device(&conn
->dev
);
2487 EXPORT_SYMBOL_GPL(iscsi_get_conn
);
2490 * iscsi interface functions
2492 static struct iscsi_internal
*
2493 iscsi_if_transport_lookup(struct iscsi_transport
*tt
)
2495 struct iscsi_internal
*priv
;
2496 unsigned long flags
;
2498 spin_lock_irqsave(&iscsi_transport_lock
, flags
);
2499 list_for_each_entry(priv
, &iscsi_transports
, list
) {
2500 if (tt
== priv
->iscsi_transport
) {
2501 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
2505 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
2510 iscsi_multicast_skb(struct sk_buff
*skb
, uint32_t group
, gfp_t gfp
)
2512 return nlmsg_multicast(nls
, skb
, 0, group
, gfp
);
2516 iscsi_unicast_skb(struct sk_buff
*skb
, u32 portid
)
2518 return nlmsg_unicast(nls
, skb
, portid
);
2521 int iscsi_recv_pdu(struct iscsi_cls_conn
*conn
, struct iscsi_hdr
*hdr
,
2522 char *data
, uint32_t data_size
)
2524 struct nlmsghdr
*nlh
;
2525 struct sk_buff
*skb
;
2526 struct iscsi_uevent
*ev
;
2528 struct iscsi_internal
*priv
;
2529 int len
= nlmsg_total_size(sizeof(*ev
) + sizeof(struct iscsi_hdr
) +
2532 priv
= iscsi_if_transport_lookup(conn
->transport
);
2536 skb
= alloc_skb(len
, GFP_ATOMIC
);
2538 iscsi_conn_error_event(conn
, ISCSI_ERR_CONN_FAILED
);
2539 iscsi_cls_conn_printk(KERN_ERR
, conn
, "can not deliver "
2540 "control PDU: OOM\n");
2544 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2545 ev
= nlmsg_data(nlh
);
2546 memset(ev
, 0, sizeof(*ev
));
2547 ev
->transport_handle
= iscsi_handle(conn
->transport
);
2548 ev
->type
= ISCSI_KEVENT_RECV_PDU
;
2549 ev
->r
.recv_req
.cid
= conn
->cid
;
2550 ev
->r
.recv_req
.sid
= iscsi_conn_get_sid(conn
);
2551 pdu
= (char*)ev
+ sizeof(*ev
);
2552 memcpy(pdu
, hdr
, sizeof(struct iscsi_hdr
));
2553 memcpy(pdu
+ sizeof(struct iscsi_hdr
), data
, data_size
);
2555 return iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_ATOMIC
);
2557 EXPORT_SYMBOL_GPL(iscsi_recv_pdu
);
2559 int iscsi_offload_mesg(struct Scsi_Host
*shost
,
2560 struct iscsi_transport
*transport
, uint32_t type
,
2561 char *data
, uint16_t data_size
)
2563 struct nlmsghdr
*nlh
;
2564 struct sk_buff
*skb
;
2565 struct iscsi_uevent
*ev
;
2566 int len
= nlmsg_total_size(sizeof(*ev
) + data_size
);
2568 skb
= alloc_skb(len
, GFP_ATOMIC
);
2570 printk(KERN_ERR
"can not deliver iscsi offload message:OOM\n");
2574 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2575 ev
= nlmsg_data(nlh
);
2576 memset(ev
, 0, sizeof(*ev
));
2578 ev
->transport_handle
= iscsi_handle(transport
);
2580 case ISCSI_KEVENT_PATH_REQ
:
2581 ev
->r
.req_path
.host_no
= shost
->host_no
;
2583 case ISCSI_KEVENT_IF_DOWN
:
2584 ev
->r
.notify_if_down
.host_no
= shost
->host_no
;
2588 memcpy((char *)ev
+ sizeof(*ev
), data
, data_size
);
2590 return iscsi_multicast_skb(skb
, ISCSI_NL_GRP_UIP
, GFP_ATOMIC
);
2592 EXPORT_SYMBOL_GPL(iscsi_offload_mesg
);
2594 void iscsi_conn_error_event(struct iscsi_cls_conn
*conn
, enum iscsi_err error
)
2596 struct nlmsghdr
*nlh
;
2597 struct sk_buff
*skb
;
2598 struct iscsi_uevent
*ev
;
2599 struct iscsi_internal
*priv
;
2600 int len
= nlmsg_total_size(sizeof(*ev
));
2602 if (!test_and_set_bit(ISCSI_CLS_CONN_BIT_CLEANUP
, &conn
->flags
))
2603 queue_work(iscsi_conn_cleanup_workq
, &conn
->cleanup_work
);
2605 priv
= iscsi_if_transport_lookup(conn
->transport
);
2609 skb
= alloc_skb(len
, GFP_ATOMIC
);
2611 iscsi_cls_conn_printk(KERN_ERR
, conn
, "gracefully ignored "
2612 "conn error (%d)\n", error
);
2616 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2617 ev
= nlmsg_data(nlh
);
2618 ev
->transport_handle
= iscsi_handle(conn
->transport
);
2619 ev
->type
= ISCSI_KEVENT_CONN_ERROR
;
2620 ev
->r
.connerror
.error
= error
;
2621 ev
->r
.connerror
.cid
= conn
->cid
;
2622 ev
->r
.connerror
.sid
= iscsi_conn_get_sid(conn
);
2624 iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_ATOMIC
);
2626 iscsi_cls_conn_printk(KERN_INFO
, conn
, "detected conn error (%d)\n",
2629 EXPORT_SYMBOL_GPL(iscsi_conn_error_event
);
2631 void iscsi_conn_login_event(struct iscsi_cls_conn
*conn
,
2632 enum iscsi_conn_state state
)
2634 struct nlmsghdr
*nlh
;
2635 struct sk_buff
*skb
;
2636 struct iscsi_uevent
*ev
;
2637 struct iscsi_internal
*priv
;
2638 int len
= nlmsg_total_size(sizeof(*ev
));
2640 priv
= iscsi_if_transport_lookup(conn
->transport
);
2644 skb
= alloc_skb(len
, GFP_ATOMIC
);
2646 iscsi_cls_conn_printk(KERN_ERR
, conn
, "gracefully ignored "
2647 "conn login (%d)\n", state
);
2651 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2652 ev
= nlmsg_data(nlh
);
2653 ev
->transport_handle
= iscsi_handle(conn
->transport
);
2654 ev
->type
= ISCSI_KEVENT_CONN_LOGIN_STATE
;
2655 ev
->r
.conn_login
.state
= state
;
2656 ev
->r
.conn_login
.cid
= conn
->cid
;
2657 ev
->r
.conn_login
.sid
= iscsi_conn_get_sid(conn
);
2658 iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_ATOMIC
);
2660 iscsi_cls_conn_printk(KERN_INFO
, conn
, "detected conn login (%d)\n",
2663 EXPORT_SYMBOL_GPL(iscsi_conn_login_event
);
2665 void iscsi_post_host_event(uint32_t host_no
, struct iscsi_transport
*transport
,
2666 enum iscsi_host_event_code code
, uint32_t data_size
,
2669 struct nlmsghdr
*nlh
;
2670 struct sk_buff
*skb
;
2671 struct iscsi_uevent
*ev
;
2672 int len
= nlmsg_total_size(sizeof(*ev
) + data_size
);
2674 skb
= alloc_skb(len
, GFP_NOIO
);
2676 printk(KERN_ERR
"gracefully ignored host event (%d):%d OOM\n",
2681 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2682 ev
= nlmsg_data(nlh
);
2683 ev
->transport_handle
= iscsi_handle(transport
);
2684 ev
->type
= ISCSI_KEVENT_HOST_EVENT
;
2685 ev
->r
.host_event
.host_no
= host_no
;
2686 ev
->r
.host_event
.code
= code
;
2687 ev
->r
.host_event
.data_size
= data_size
;
2690 memcpy((char *)ev
+ sizeof(*ev
), data
, data_size
);
2692 iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_NOIO
);
2694 EXPORT_SYMBOL_GPL(iscsi_post_host_event
);
2696 void iscsi_ping_comp_event(uint32_t host_no
, struct iscsi_transport
*transport
,
2697 uint32_t status
, uint32_t pid
, uint32_t data_size
,
2700 struct nlmsghdr
*nlh
;
2701 struct sk_buff
*skb
;
2702 struct iscsi_uevent
*ev
;
2703 int len
= nlmsg_total_size(sizeof(*ev
) + data_size
);
2705 skb
= alloc_skb(len
, GFP_NOIO
);
2707 printk(KERN_ERR
"gracefully ignored ping comp: OOM\n");
2711 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2712 ev
= nlmsg_data(nlh
);
2713 ev
->transport_handle
= iscsi_handle(transport
);
2714 ev
->type
= ISCSI_KEVENT_PING_COMP
;
2715 ev
->r
.ping_comp
.host_no
= host_no
;
2716 ev
->r
.ping_comp
.status
= status
;
2717 ev
->r
.ping_comp
.pid
= pid
;
2718 ev
->r
.ping_comp
.data_size
= data_size
;
2719 memcpy((char *)ev
+ sizeof(*ev
), data
, data_size
);
2721 iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_NOIO
);
2723 EXPORT_SYMBOL_GPL(iscsi_ping_comp_event
);
2726 iscsi_if_send_reply(u32 portid
, int type
, void *payload
, int size
)
2728 struct sk_buff
*skb
;
2729 struct nlmsghdr
*nlh
;
2730 int len
= nlmsg_total_size(size
);
2732 skb
= alloc_skb(len
, GFP_ATOMIC
);
2734 printk(KERN_ERR
"Could not allocate skb to send reply.\n");
2738 nlh
= __nlmsg_put(skb
, 0, 0, type
, (len
- sizeof(*nlh
)), 0);
2739 memcpy(nlmsg_data(nlh
), payload
, size
);
2740 return iscsi_unicast_skb(skb
, portid
);
2744 iscsi_if_get_stats(struct iscsi_transport
*transport
, struct nlmsghdr
*nlh
)
2746 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
2747 struct iscsi_stats
*stats
;
2748 struct sk_buff
*skbstat
;
2749 struct iscsi_cls_conn
*conn
;
2750 struct nlmsghdr
*nlhstat
;
2751 struct iscsi_uevent
*evstat
;
2752 struct iscsi_internal
*priv
;
2753 int len
= nlmsg_total_size(sizeof(*ev
) +
2754 sizeof(struct iscsi_stats
) +
2755 sizeof(struct iscsi_stats_custom
) *
2756 ISCSI_STATS_CUSTOM_MAX
);
2759 priv
= iscsi_if_transport_lookup(transport
);
2763 conn
= iscsi_conn_lookup(ev
->u
.get_stats
.sid
, ev
->u
.get_stats
.cid
);
2770 skbstat
= alloc_skb(len
, GFP_ATOMIC
);
2772 iscsi_cls_conn_printk(KERN_ERR
, conn
, "can not "
2773 "deliver stats: OOM\n");
2777 nlhstat
= __nlmsg_put(skbstat
, 0, 0, 0,
2778 (len
- sizeof(*nlhstat
)), 0);
2779 evstat
= nlmsg_data(nlhstat
);
2780 memset(evstat
, 0, sizeof(*evstat
));
2781 evstat
->transport_handle
= iscsi_handle(conn
->transport
);
2782 evstat
->type
= nlh
->nlmsg_type
;
2783 evstat
->u
.get_stats
.cid
=
2784 ev
->u
.get_stats
.cid
;
2785 evstat
->u
.get_stats
.sid
=
2786 ev
->u
.get_stats
.sid
;
2787 stats
= (struct iscsi_stats
*)
2788 ((char*)evstat
+ sizeof(*evstat
));
2789 memset(stats
, 0, sizeof(*stats
));
2791 transport
->get_stats(conn
, stats
);
2792 actual_size
= nlmsg_total_size(sizeof(struct iscsi_uevent
) +
2793 sizeof(struct iscsi_stats
) +
2794 sizeof(struct iscsi_stats_custom
) *
2795 stats
->custom_length
);
2796 actual_size
-= sizeof(*nlhstat
);
2797 actual_size
= nlmsg_msg_size(actual_size
);
2798 skb_trim(skbstat
, NLMSG_ALIGN(actual_size
));
2799 nlhstat
->nlmsg_len
= actual_size
;
2801 err
= iscsi_multicast_skb(skbstat
, ISCSI_NL_GRP_ISCSID
,
2803 } while (err
< 0 && err
!= -ECONNREFUSED
);
2809 * iscsi_session_event - send session destr. completion event
2810 * @session: iscsi class session
2811 * @event: type of event
2813 int iscsi_session_event(struct iscsi_cls_session
*session
,
2814 enum iscsi_uevent_e event
)
2816 struct iscsi_internal
*priv
;
2817 struct Scsi_Host
*shost
;
2818 struct iscsi_uevent
*ev
;
2819 struct sk_buff
*skb
;
2820 struct nlmsghdr
*nlh
;
2821 int rc
, len
= nlmsg_total_size(sizeof(*ev
));
2823 priv
= iscsi_if_transport_lookup(session
->transport
);
2826 shost
= iscsi_session_to_shost(session
);
2828 skb
= alloc_skb(len
, GFP_KERNEL
);
2830 iscsi_cls_session_printk(KERN_ERR
, session
,
2831 "Cannot notify userspace of session "
2832 "event %u\n", event
);
2836 nlh
= __nlmsg_put(skb
, 0, 0, 0, (len
- sizeof(*nlh
)), 0);
2837 ev
= nlmsg_data(nlh
);
2838 ev
->transport_handle
= iscsi_handle(session
->transport
);
2842 case ISCSI_KEVENT_DESTROY_SESSION
:
2843 ev
->r
.d_session
.host_no
= shost
->host_no
;
2844 ev
->r
.d_session
.sid
= session
->sid
;
2846 case ISCSI_KEVENT_CREATE_SESSION
:
2847 ev
->r
.c_session_ret
.host_no
= shost
->host_no
;
2848 ev
->r
.c_session_ret
.sid
= session
->sid
;
2850 case ISCSI_KEVENT_UNBIND_SESSION
:
2851 ev
->r
.unbind_session
.host_no
= shost
->host_no
;
2852 ev
->r
.unbind_session
.sid
= session
->sid
;
2855 iscsi_cls_session_printk(KERN_ERR
, session
, "Invalid event "
2862 * this will occur if the daemon is not up, so we just warn
2863 * the user and when the daemon is restarted it will handle it
2865 rc
= iscsi_multicast_skb(skb
, ISCSI_NL_GRP_ISCSID
, GFP_KERNEL
);
2867 iscsi_cls_session_printk(KERN_ERR
, session
,
2868 "Cannot notify userspace of session "
2869 "event %u. Check iscsi daemon\n",
2872 ISCSI_DBG_TRANS_SESSION(session
, "Completed handling event %d rc %d\n",
2876 EXPORT_SYMBOL_GPL(iscsi_session_event
);
2879 iscsi_if_create_session(struct iscsi_internal
*priv
, struct iscsi_endpoint
*ep
,
2880 struct iscsi_uevent
*ev
, pid_t pid
,
2881 uint32_t initial_cmdsn
, uint16_t cmds_max
,
2882 uint16_t queue_depth
)
2884 struct iscsi_transport
*transport
= priv
->iscsi_transport
;
2885 struct iscsi_cls_session
*session
;
2886 struct Scsi_Host
*shost
;
2888 session
= transport
->create_session(ep
, cmds_max
, queue_depth
,
2893 session
->creator
= pid
;
2894 shost
= iscsi_session_to_shost(session
);
2895 ev
->r
.c_session_ret
.host_no
= shost
->host_no
;
2896 ev
->r
.c_session_ret
.sid
= session
->sid
;
2897 ISCSI_DBG_TRANS_SESSION(session
,
2898 "Completed creating transport session\n");
2903 iscsi_if_create_conn(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
2905 struct iscsi_cls_conn
*conn
;
2906 struct iscsi_cls_session
*session
;
2908 session
= iscsi_session_lookup(ev
->u
.c_conn
.sid
);
2910 printk(KERN_ERR
"iscsi: invalid session %d.\n",
2915 conn
= transport
->create_conn(session
, ev
->u
.c_conn
.cid
);
2917 iscsi_cls_session_printk(KERN_ERR
, session
,
2918 "couldn't create a new connection.");
2922 ev
->r
.c_conn_ret
.sid
= session
->sid
;
2923 ev
->r
.c_conn_ret
.cid
= conn
->cid
;
2925 ISCSI_DBG_TRANS_CONN(conn
, "Completed creating transport conn\n");
2930 iscsi_if_destroy_conn(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
2932 struct iscsi_cls_conn
*conn
;
2934 conn
= iscsi_conn_lookup(ev
->u
.d_conn
.sid
, ev
->u
.d_conn
.cid
);
2938 ISCSI_DBG_TRANS_CONN(conn
, "Flushing cleanup during destruction\n");
2939 flush_work(&conn
->cleanup_work
);
2940 ISCSI_DBG_TRANS_CONN(conn
, "Destroying transport conn\n");
2942 if (transport
->destroy_conn
)
2943 transport
->destroy_conn(conn
);
2948 iscsi_set_param(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
2950 char *data
= (char*)ev
+ sizeof(*ev
);
2951 struct iscsi_cls_conn
*conn
;
2952 struct iscsi_cls_session
*session
;
2953 int err
= 0, value
= 0;
2955 if (ev
->u
.set_param
.len
> PAGE_SIZE
)
2958 session
= iscsi_session_lookup(ev
->u
.set_param
.sid
);
2959 conn
= iscsi_conn_lookup(ev
->u
.set_param
.sid
, ev
->u
.set_param
.cid
);
2960 if (!conn
|| !session
)
2963 switch (ev
->u
.set_param
.param
) {
2964 case ISCSI_PARAM_SESS_RECOVERY_TMO
:
2965 sscanf(data
, "%d", &value
);
2966 if (!session
->recovery_tmo_sysfs_override
)
2967 session
->recovery_tmo
= value
;
2970 if ((conn
->state
== ISCSI_CONN_BOUND
) ||
2971 (conn
->state
== ISCSI_CONN_UP
)) {
2972 err
= transport
->set_param(conn
, ev
->u
.set_param
.param
,
2973 data
, ev
->u
.set_param
.len
);
2982 static int iscsi_if_ep_connect(struct iscsi_transport
*transport
,
2983 struct iscsi_uevent
*ev
, int msg_type
)
2985 struct iscsi_endpoint
*ep
;
2986 struct sockaddr
*dst_addr
;
2987 struct Scsi_Host
*shost
= NULL
;
2988 int non_blocking
, err
= 0;
2990 if (!transport
->ep_connect
)
2993 if (msg_type
== ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST
) {
2994 shost
= scsi_host_lookup(ev
->u
.ep_connect_through_host
.host_no
);
2996 printk(KERN_ERR
"ep connect failed. Could not find "
2998 ev
->u
.ep_connect_through_host
.host_no
);
3001 non_blocking
= ev
->u
.ep_connect_through_host
.non_blocking
;
3003 non_blocking
= ev
->u
.ep_connect
.non_blocking
;
3005 dst_addr
= (struct sockaddr
*)((char*)ev
+ sizeof(*ev
));
3006 ep
= transport
->ep_connect(shost
, dst_addr
, non_blocking
);
3012 ev
->r
.ep_connect_ret
.handle
= ep
->id
;
3015 scsi_host_put(shost
);
3019 static int iscsi_if_ep_disconnect(struct iscsi_transport
*transport
,
3022 struct iscsi_cls_conn
*conn
;
3023 struct iscsi_endpoint
*ep
;
3025 if (!transport
->ep_disconnect
)
3028 ep
= iscsi_lookup_endpoint(ep_handle
);
3035 * conn was not even bound yet, so we can't get iscsi conn
3038 transport
->ep_disconnect(ep
);
3042 mutex_lock(&conn
->ep_mutex
);
3043 iscsi_if_disconnect_bound_ep(conn
, ep
, false);
3044 mutex_unlock(&conn
->ep_mutex
);
3046 iscsi_put_endpoint(ep
);
3051 iscsi_if_transport_ep(struct iscsi_transport
*transport
,
3052 struct iscsi_uevent
*ev
, int msg_type
)
3054 struct iscsi_endpoint
*ep
;
3058 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST
:
3059 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT
:
3060 rc
= iscsi_if_ep_connect(transport
, ev
, msg_type
);
3062 case ISCSI_UEVENT_TRANSPORT_EP_POLL
:
3063 if (!transport
->ep_poll
)
3066 ep
= iscsi_lookup_endpoint(ev
->u
.ep_poll
.ep_handle
);
3070 ev
->r
.retcode
= transport
->ep_poll(ep
,
3071 ev
->u
.ep_poll
.timeout_ms
);
3072 iscsi_put_endpoint(ep
);
3074 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT
:
3075 rc
= iscsi_if_ep_disconnect(transport
,
3076 ev
->u
.ep_disconnect
.ep_handle
);
3083 iscsi_tgt_dscvr(struct iscsi_transport
*transport
,
3084 struct iscsi_uevent
*ev
)
3086 struct Scsi_Host
*shost
;
3087 struct sockaddr
*dst_addr
;
3090 if (!transport
->tgt_dscvr
)
3093 shost
= scsi_host_lookup(ev
->u
.tgt_dscvr
.host_no
);
3095 printk(KERN_ERR
"target discovery could not find host no %u\n",
3096 ev
->u
.tgt_dscvr
.host_no
);
3101 dst_addr
= (struct sockaddr
*)((char*)ev
+ sizeof(*ev
));
3102 err
= transport
->tgt_dscvr(shost
, ev
->u
.tgt_dscvr
.type
,
3103 ev
->u
.tgt_dscvr
.enable
, dst_addr
);
3104 scsi_host_put(shost
);
3109 iscsi_set_host_param(struct iscsi_transport
*transport
,
3110 struct iscsi_uevent
*ev
)
3112 char *data
= (char*)ev
+ sizeof(*ev
);
3113 struct Scsi_Host
*shost
;
3116 if (!transport
->set_host_param
)
3119 if (ev
->u
.set_host_param
.len
> PAGE_SIZE
)
3122 shost
= scsi_host_lookup(ev
->u
.set_host_param
.host_no
);
3124 printk(KERN_ERR
"set_host_param could not find host no %u\n",
3125 ev
->u
.set_host_param
.host_no
);
3129 err
= transport
->set_host_param(shost
, ev
->u
.set_host_param
.param
,
3130 data
, ev
->u
.set_host_param
.len
);
3131 scsi_host_put(shost
);
3136 iscsi_set_path(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
3138 struct Scsi_Host
*shost
;
3139 struct iscsi_path
*params
;
3142 if (!transport
->set_path
)
3145 shost
= scsi_host_lookup(ev
->u
.set_path
.host_no
);
3147 printk(KERN_ERR
"set path could not find host no %u\n",
3148 ev
->u
.set_path
.host_no
);
3152 params
= (struct iscsi_path
*)((char *)ev
+ sizeof(*ev
));
3153 err
= transport
->set_path(shost
, params
);
3155 scsi_host_put(shost
);
3159 static int iscsi_session_has_conns(int sid
)
3161 struct iscsi_cls_conn
*conn
;
3162 unsigned long flags
;
3165 spin_lock_irqsave(&connlock
, flags
);
3166 list_for_each_entry(conn
, &connlist
, conn_list
) {
3167 if (iscsi_conn_get_sid(conn
) == sid
) {
3172 spin_unlock_irqrestore(&connlock
, flags
);
3178 iscsi_set_iface_params(struct iscsi_transport
*transport
,
3179 struct iscsi_uevent
*ev
, uint32_t len
)
3181 char *data
= (char *)ev
+ sizeof(*ev
);
3182 struct Scsi_Host
*shost
;
3185 if (!transport
->set_iface_param
)
3188 shost
= scsi_host_lookup(ev
->u
.set_iface_params
.host_no
);
3190 printk(KERN_ERR
"set_iface_params could not find host no %u\n",
3191 ev
->u
.set_iface_params
.host_no
);
3195 err
= transport
->set_iface_param(shost
, data
, len
);
3196 scsi_host_put(shost
);
3201 iscsi_send_ping(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
3203 struct Scsi_Host
*shost
;
3204 struct sockaddr
*dst_addr
;
3207 if (!transport
->send_ping
)
3210 shost
= scsi_host_lookup(ev
->u
.iscsi_ping
.host_no
);
3212 printk(KERN_ERR
"iscsi_ping could not find host no %u\n",
3213 ev
->u
.iscsi_ping
.host_no
);
3217 dst_addr
= (struct sockaddr
*)((char *)ev
+ sizeof(*ev
));
3218 err
= transport
->send_ping(shost
, ev
->u
.iscsi_ping
.iface_num
,
3219 ev
->u
.iscsi_ping
.iface_type
,
3220 ev
->u
.iscsi_ping
.payload_size
,
3221 ev
->u
.iscsi_ping
.pid
,
3223 scsi_host_put(shost
);
3228 iscsi_get_chap(struct iscsi_transport
*transport
, struct nlmsghdr
*nlh
)
3230 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
3231 struct Scsi_Host
*shost
= NULL
;
3232 struct iscsi_chap_rec
*chap_rec
;
3233 struct iscsi_internal
*priv
;
3234 struct sk_buff
*skbchap
;
3235 struct nlmsghdr
*nlhchap
;
3236 struct iscsi_uevent
*evchap
;
3237 uint32_t chap_buf_size
;
3241 if (!transport
->get_chap
)
3244 priv
= iscsi_if_transport_lookup(transport
);
3248 chap_buf_size
= (ev
->u
.get_chap
.num_entries
* sizeof(*chap_rec
));
3249 len
= nlmsg_total_size(sizeof(*ev
) + chap_buf_size
);
3251 shost
= scsi_host_lookup(ev
->u
.get_chap
.host_no
);
3253 printk(KERN_ERR
"%s: failed. Could not find host no %u\n",
3254 __func__
, ev
->u
.get_chap
.host_no
);
3261 skbchap
= alloc_skb(len
, GFP_KERNEL
);
3263 printk(KERN_ERR
"can not deliver chap: OOM\n");
3268 nlhchap
= __nlmsg_put(skbchap
, 0, 0, 0,
3269 (len
- sizeof(*nlhchap
)), 0);
3270 evchap
= nlmsg_data(nlhchap
);
3271 memset(evchap
, 0, sizeof(*evchap
));
3272 evchap
->transport_handle
= iscsi_handle(transport
);
3273 evchap
->type
= nlh
->nlmsg_type
;
3274 evchap
->u
.get_chap
.host_no
= ev
->u
.get_chap
.host_no
;
3275 evchap
->u
.get_chap
.chap_tbl_idx
= ev
->u
.get_chap
.chap_tbl_idx
;
3276 evchap
->u
.get_chap
.num_entries
= ev
->u
.get_chap
.num_entries
;
3277 buf
= (char *)evchap
+ sizeof(*evchap
);
3278 memset(buf
, 0, chap_buf_size
);
3280 err
= transport
->get_chap(shost
, ev
->u
.get_chap
.chap_tbl_idx
,
3281 &evchap
->u
.get_chap
.num_entries
, buf
);
3283 actual_size
= nlmsg_total_size(sizeof(*ev
) + chap_buf_size
);
3284 skb_trim(skbchap
, NLMSG_ALIGN(actual_size
));
3285 nlhchap
->nlmsg_len
= actual_size
;
3287 err
= iscsi_multicast_skb(skbchap
, ISCSI_NL_GRP_ISCSID
,
3289 } while (err
< 0 && err
!= -ECONNREFUSED
);
3292 scsi_host_put(shost
);
3296 static int iscsi_set_chap(struct iscsi_transport
*transport
,
3297 struct iscsi_uevent
*ev
, uint32_t len
)
3299 char *data
= (char *)ev
+ sizeof(*ev
);
3300 struct Scsi_Host
*shost
;
3303 if (!transport
->set_chap
)
3306 shost
= scsi_host_lookup(ev
->u
.set_path
.host_no
);
3308 pr_err("%s could not find host no %u\n",
3309 __func__
, ev
->u
.set_path
.host_no
);
3313 err
= transport
->set_chap(shost
, data
, len
);
3314 scsi_host_put(shost
);
3318 static int iscsi_delete_chap(struct iscsi_transport
*transport
,
3319 struct iscsi_uevent
*ev
)
3321 struct Scsi_Host
*shost
;
3324 if (!transport
->delete_chap
)
3327 shost
= scsi_host_lookup(ev
->u
.delete_chap
.host_no
);
3329 printk(KERN_ERR
"%s could not find host no %u\n",
3330 __func__
, ev
->u
.delete_chap
.host_no
);
3334 err
= transport
->delete_chap(shost
, ev
->u
.delete_chap
.chap_tbl_idx
);
3335 scsi_host_put(shost
);
3339 static const struct {
3340 enum iscsi_discovery_parent_type value
;
3342 } iscsi_discovery_parent_names
[] = {
3343 {ISCSI_DISC_PARENT_UNKNOWN
, "Unknown" },
3344 {ISCSI_DISC_PARENT_SENDTGT
, "Sendtarget" },
3345 {ISCSI_DISC_PARENT_ISNS
, "isns" },
3348 char *iscsi_get_discovery_parent_name(int parent_type
)
3351 char *state
= "Unknown!";
3353 for (i
= 0; i
< ARRAY_SIZE(iscsi_discovery_parent_names
); i
++) {
3354 if (iscsi_discovery_parent_names
[i
].value
& parent_type
) {
3355 state
= iscsi_discovery_parent_names
[i
].name
;
3361 EXPORT_SYMBOL_GPL(iscsi_get_discovery_parent_name
);
3363 static int iscsi_set_flashnode_param(struct iscsi_transport
*transport
,
3364 struct iscsi_uevent
*ev
, uint32_t len
)
3366 char *data
= (char *)ev
+ sizeof(*ev
);
3367 struct Scsi_Host
*shost
;
3368 struct iscsi_bus_flash_session
*fnode_sess
;
3369 struct iscsi_bus_flash_conn
*fnode_conn
;
3374 if (!transport
->set_flashnode_param
) {
3376 goto exit_set_fnode
;
3379 shost
= scsi_host_lookup(ev
->u
.set_flashnode
.host_no
);
3381 pr_err("%s could not find host no %u\n",
3382 __func__
, ev
->u
.set_flashnode
.host_no
);
3384 goto exit_set_fnode
;
3387 idx
= ev
->u
.set_flashnode
.flashnode_idx
;
3388 fnode_sess
= iscsi_get_flashnode_by_index(shost
, idx
);
3390 pr_err("%s could not find flashnode %u for host no %u\n",
3391 __func__
, idx
, ev
->u
.set_flashnode
.host_no
);
3396 dev
= iscsi_find_flashnode_conn(fnode_sess
);
3402 fnode_conn
= iscsi_dev_to_flash_conn(dev
);
3403 err
= transport
->set_flashnode_param(fnode_sess
, fnode_conn
, data
, len
);
3407 put_device(&fnode_sess
->dev
);
3410 scsi_host_put(shost
);
3416 static int iscsi_new_flashnode(struct iscsi_transport
*transport
,
3417 struct iscsi_uevent
*ev
, uint32_t len
)
3419 char *data
= (char *)ev
+ sizeof(*ev
);
3420 struct Scsi_Host
*shost
;
3424 if (!transport
->new_flashnode
) {
3426 goto exit_new_fnode
;
3429 shost
= scsi_host_lookup(ev
->u
.new_flashnode
.host_no
);
3431 pr_err("%s could not find host no %u\n",
3432 __func__
, ev
->u
.new_flashnode
.host_no
);
3437 index
= transport
->new_flashnode(shost
, data
, len
);
3440 ev
->r
.new_flashnode_ret
.flashnode_idx
= index
;
3445 scsi_host_put(shost
);
3451 static int iscsi_del_flashnode(struct iscsi_transport
*transport
,
3452 struct iscsi_uevent
*ev
)
3454 struct Scsi_Host
*shost
;
3455 struct iscsi_bus_flash_session
*fnode_sess
;
3459 if (!transport
->del_flashnode
) {
3461 goto exit_del_fnode
;
3464 shost
= scsi_host_lookup(ev
->u
.del_flashnode
.host_no
);
3466 pr_err("%s could not find host no %u\n",
3467 __func__
, ev
->u
.del_flashnode
.host_no
);
3472 idx
= ev
->u
.del_flashnode
.flashnode_idx
;
3473 fnode_sess
= iscsi_get_flashnode_by_index(shost
, idx
);
3475 pr_err("%s could not find flashnode %u for host no %u\n",
3476 __func__
, idx
, ev
->u
.del_flashnode
.host_no
);
3481 err
= transport
->del_flashnode(fnode_sess
);
3482 put_device(&fnode_sess
->dev
);
3485 scsi_host_put(shost
);
3491 static int iscsi_login_flashnode(struct iscsi_transport
*transport
,
3492 struct iscsi_uevent
*ev
)
3494 struct Scsi_Host
*shost
;
3495 struct iscsi_bus_flash_session
*fnode_sess
;
3496 struct iscsi_bus_flash_conn
*fnode_conn
;
3501 if (!transport
->login_flashnode
) {
3503 goto exit_login_fnode
;
3506 shost
= scsi_host_lookup(ev
->u
.login_flashnode
.host_no
);
3508 pr_err("%s could not find host no %u\n",
3509 __func__
, ev
->u
.login_flashnode
.host_no
);
3514 idx
= ev
->u
.login_flashnode
.flashnode_idx
;
3515 fnode_sess
= iscsi_get_flashnode_by_index(shost
, idx
);
3517 pr_err("%s could not find flashnode %u for host no %u\n",
3518 __func__
, idx
, ev
->u
.login_flashnode
.host_no
);
3523 dev
= iscsi_find_flashnode_conn(fnode_sess
);
3529 fnode_conn
= iscsi_dev_to_flash_conn(dev
);
3530 err
= transport
->login_flashnode(fnode_sess
, fnode_conn
);
3534 put_device(&fnode_sess
->dev
);
3537 scsi_host_put(shost
);
3543 static int iscsi_logout_flashnode(struct iscsi_transport
*transport
,
3544 struct iscsi_uevent
*ev
)
3546 struct Scsi_Host
*shost
;
3547 struct iscsi_bus_flash_session
*fnode_sess
;
3548 struct iscsi_bus_flash_conn
*fnode_conn
;
3553 if (!transport
->logout_flashnode
) {
3555 goto exit_logout_fnode
;
3558 shost
= scsi_host_lookup(ev
->u
.logout_flashnode
.host_no
);
3560 pr_err("%s could not find host no %u\n",
3561 __func__
, ev
->u
.logout_flashnode
.host_no
);
3566 idx
= ev
->u
.logout_flashnode
.flashnode_idx
;
3567 fnode_sess
= iscsi_get_flashnode_by_index(shost
, idx
);
3569 pr_err("%s could not find flashnode %u for host no %u\n",
3570 __func__
, idx
, ev
->u
.logout_flashnode
.host_no
);
3575 dev
= iscsi_find_flashnode_conn(fnode_sess
);
3581 fnode_conn
= iscsi_dev_to_flash_conn(dev
);
3583 err
= transport
->logout_flashnode(fnode_sess
, fnode_conn
);
3587 put_device(&fnode_sess
->dev
);
3590 scsi_host_put(shost
);
3596 static int iscsi_logout_flashnode_sid(struct iscsi_transport
*transport
,
3597 struct iscsi_uevent
*ev
)
3599 struct Scsi_Host
*shost
;
3600 struct iscsi_cls_session
*session
;
3603 if (!transport
->logout_flashnode_sid
) {
3605 goto exit_logout_sid
;
3608 shost
= scsi_host_lookup(ev
->u
.logout_flashnode_sid
.host_no
);
3610 pr_err("%s could not find host no %u\n",
3611 __func__
, ev
->u
.logout_flashnode
.host_no
);
3616 session
= iscsi_session_lookup(ev
->u
.logout_flashnode_sid
.sid
);
3618 pr_err("%s could not find session id %u\n",
3619 __func__
, ev
->u
.logout_flashnode_sid
.sid
);
3624 err
= transport
->logout_flashnode_sid(session
);
3627 scsi_host_put(shost
);
3634 iscsi_get_host_stats(struct iscsi_transport
*transport
, struct nlmsghdr
*nlh
)
3636 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
3637 struct Scsi_Host
*shost
= NULL
;
3638 struct iscsi_internal
*priv
;
3639 struct sk_buff
*skbhost_stats
;
3640 struct nlmsghdr
*nlhhost_stats
;
3641 struct iscsi_uevent
*evhost_stats
;
3642 int host_stats_size
= 0;
3646 if (!transport
->get_host_stats
)
3649 priv
= iscsi_if_transport_lookup(transport
);
3653 host_stats_size
= sizeof(struct iscsi_offload_host_stats
);
3654 len
= nlmsg_total_size(sizeof(*ev
) + host_stats_size
);
3656 shost
= scsi_host_lookup(ev
->u
.get_host_stats
.host_no
);
3658 pr_err("%s: failed. Could not find host no %u\n",
3659 __func__
, ev
->u
.get_host_stats
.host_no
);
3666 skbhost_stats
= alloc_skb(len
, GFP_KERNEL
);
3667 if (!skbhost_stats
) {
3668 pr_err("cannot deliver host stats: OOM\n");
3670 goto exit_host_stats
;
3673 nlhhost_stats
= __nlmsg_put(skbhost_stats
, 0, 0, 0,
3674 (len
- sizeof(*nlhhost_stats
)), 0);
3675 evhost_stats
= nlmsg_data(nlhhost_stats
);
3676 memset(evhost_stats
, 0, sizeof(*evhost_stats
));
3677 evhost_stats
->transport_handle
= iscsi_handle(transport
);
3678 evhost_stats
->type
= nlh
->nlmsg_type
;
3679 evhost_stats
->u
.get_host_stats
.host_no
=
3680 ev
->u
.get_host_stats
.host_no
;
3681 buf
= (char *)evhost_stats
+ sizeof(*evhost_stats
);
3682 memset(buf
, 0, host_stats_size
);
3684 err
= transport
->get_host_stats(shost
, buf
, host_stats_size
);
3686 kfree_skb(skbhost_stats
);
3687 goto exit_host_stats
;
3690 actual_size
= nlmsg_total_size(sizeof(*ev
) + host_stats_size
);
3691 skb_trim(skbhost_stats
, NLMSG_ALIGN(actual_size
));
3692 nlhhost_stats
->nlmsg_len
= actual_size
;
3694 err
= iscsi_multicast_skb(skbhost_stats
, ISCSI_NL_GRP_ISCSID
,
3696 } while (err
< 0 && err
!= -ECONNREFUSED
);
3699 scsi_host_put(shost
);
3703 static int iscsi_if_transport_conn(struct iscsi_transport
*transport
,
3704 struct nlmsghdr
*nlh
)
3706 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
3707 struct iscsi_cls_session
*session
;
3708 struct iscsi_cls_conn
*conn
= NULL
;
3709 struct iscsi_endpoint
*ep
;
3713 switch (nlh
->nlmsg_type
) {
3714 case ISCSI_UEVENT_CREATE_CONN
:
3715 return iscsi_if_create_conn(transport
, ev
);
3716 case ISCSI_UEVENT_DESTROY_CONN
:
3717 return iscsi_if_destroy_conn(transport
, ev
);
3718 case ISCSI_UEVENT_STOP_CONN
:
3719 return iscsi_if_stop_conn(transport
, ev
);
3723 * The following cmds need to be run under the ep_mutex so in kernel
3724 * conn cleanup (ep_disconnect + unbind and conn) is not done while
3725 * these are running. They also must not run if we have just run a conn
3726 * cleanup because they would set the state in a way that might allow
3727 * IO or send IO themselves.
3729 switch (nlh
->nlmsg_type
) {
3730 case ISCSI_UEVENT_START_CONN
:
3731 conn
= iscsi_conn_lookup(ev
->u
.start_conn
.sid
,
3732 ev
->u
.start_conn
.cid
);
3734 case ISCSI_UEVENT_BIND_CONN
:
3735 conn
= iscsi_conn_lookup(ev
->u
.b_conn
.sid
, ev
->u
.b_conn
.cid
);
3737 case ISCSI_UEVENT_SEND_PDU
:
3738 conn
= iscsi_conn_lookup(ev
->u
.send_pdu
.sid
, ev
->u
.send_pdu
.cid
);
3745 mutex_lock(&conn
->ep_mutex
);
3746 if (test_bit(ISCSI_CLS_CONN_BIT_CLEANUP
, &conn
->flags
)) {
3747 mutex_unlock(&conn
->ep_mutex
);
3748 ev
->r
.retcode
= -ENOTCONN
;
3752 switch (nlh
->nlmsg_type
) {
3753 case ISCSI_UEVENT_BIND_CONN
:
3754 session
= iscsi_session_lookup(ev
->u
.b_conn
.sid
);
3760 ev
->r
.retcode
= transport
->bind_conn(session
, conn
,
3761 ev
->u
.b_conn
.transport_eph
,
3762 ev
->u
.b_conn
.is_leading
);
3764 conn
->state
= ISCSI_CONN_BOUND
;
3766 if (ev
->r
.retcode
|| !transport
->ep_connect
)
3769 ep
= iscsi_lookup_endpoint(ev
->u
.b_conn
.transport_eph
);
3773 iscsi_put_endpoint(ep
);
3776 iscsi_cls_conn_printk(KERN_ERR
, conn
,
3777 "Could not set ep conn binding\n");
3780 case ISCSI_UEVENT_START_CONN
:
3781 ev
->r
.retcode
= transport
->start_conn(conn
);
3783 conn
->state
= ISCSI_CONN_UP
;
3785 case ISCSI_UEVENT_SEND_PDU
:
3786 pdu_len
= nlh
->nlmsg_len
- sizeof(*nlh
) - sizeof(*ev
);
3788 if ((ev
->u
.send_pdu
.hdr_size
> pdu_len
) ||
3789 (ev
->u
.send_pdu
.data_size
> (pdu_len
- ev
->u
.send_pdu
.hdr_size
))) {
3794 ev
->r
.retcode
= transport
->send_pdu(conn
,
3795 (struct iscsi_hdr
*)((char *)ev
+ sizeof(*ev
)),
3796 (char *)ev
+ sizeof(*ev
) + ev
->u
.send_pdu
.hdr_size
,
3797 ev
->u
.send_pdu
.data_size
);
3803 mutex_unlock(&conn
->ep_mutex
);
3808 iscsi_if_recv_msg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, uint32_t *group
)
3812 struct iscsi_uevent
*ev
= nlmsg_data(nlh
);
3813 struct iscsi_transport
*transport
= NULL
;
3814 struct iscsi_internal
*priv
;
3815 struct iscsi_cls_session
*session
;
3816 struct iscsi_endpoint
*ep
= NULL
;
3818 if (!netlink_capable(skb
, CAP_SYS_ADMIN
))
3821 if (nlh
->nlmsg_type
== ISCSI_UEVENT_PATH_UPDATE
)
3822 *group
= ISCSI_NL_GRP_UIP
;
3824 *group
= ISCSI_NL_GRP_ISCSID
;
3826 priv
= iscsi_if_transport_lookup(iscsi_ptr(ev
->transport_handle
));
3829 transport
= priv
->iscsi_transport
;
3831 if (!try_module_get(transport
->owner
))
3834 portid
= NETLINK_CB(skb
).portid
;
3836 switch (nlh
->nlmsg_type
) {
3837 case ISCSI_UEVENT_CREATE_SESSION
:
3838 err
= iscsi_if_create_session(priv
, ep
, ev
,
3840 ev
->u
.c_session
.initial_cmdsn
,
3841 ev
->u
.c_session
.cmds_max
,
3842 ev
->u
.c_session
.queue_depth
);
3844 case ISCSI_UEVENT_CREATE_BOUND_SESSION
:
3845 ep
= iscsi_lookup_endpoint(ev
->u
.c_bound_session
.ep_handle
);
3851 err
= iscsi_if_create_session(priv
, ep
, ev
,
3853 ev
->u
.c_bound_session
.initial_cmdsn
,
3854 ev
->u
.c_bound_session
.cmds_max
,
3855 ev
->u
.c_bound_session
.queue_depth
);
3856 iscsi_put_endpoint(ep
);
3858 case ISCSI_UEVENT_DESTROY_SESSION
:
3859 session
= iscsi_session_lookup(ev
->u
.d_session
.sid
);
3862 else if (iscsi_session_has_conns(ev
->u
.d_session
.sid
))
3865 transport
->destroy_session(session
);
3867 case ISCSI_UEVENT_DESTROY_SESSION_ASYNC
:
3868 session
= iscsi_session_lookup(ev
->u
.d_session
.sid
);
3871 else if (iscsi_session_has_conns(ev
->u
.d_session
.sid
))
3874 unsigned long flags
;
3876 /* Prevent this session from being found again */
3877 spin_lock_irqsave(&sesslock
, flags
);
3878 list_del_init(&session
->sess_list
);
3879 spin_unlock_irqrestore(&sesslock
, flags
);
3881 queue_work(system_unbound_wq
, &session
->destroy_work
);
3884 case ISCSI_UEVENT_UNBIND_SESSION
:
3885 session
= iscsi_session_lookup(ev
->u
.d_session
.sid
);
3887 scsi_queue_work(iscsi_session_to_shost(session
),
3888 &session
->unbind_work
);
3892 case ISCSI_UEVENT_SET_PARAM
:
3893 err
= iscsi_set_param(transport
, ev
);
3895 case ISCSI_UEVENT_CREATE_CONN
:
3896 case ISCSI_UEVENT_DESTROY_CONN
:
3897 case ISCSI_UEVENT_STOP_CONN
:
3898 case ISCSI_UEVENT_START_CONN
:
3899 case ISCSI_UEVENT_BIND_CONN
:
3900 case ISCSI_UEVENT_SEND_PDU
:
3901 err
= iscsi_if_transport_conn(transport
, nlh
);
3903 case ISCSI_UEVENT_GET_STATS
:
3904 err
= iscsi_if_get_stats(transport
, nlh
);
3906 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT
:
3907 case ISCSI_UEVENT_TRANSPORT_EP_POLL
:
3908 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT
:
3909 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST
:
3910 err
= iscsi_if_transport_ep(transport
, ev
, nlh
->nlmsg_type
);
3912 case ISCSI_UEVENT_TGT_DSCVR
:
3913 err
= iscsi_tgt_dscvr(transport
, ev
);
3915 case ISCSI_UEVENT_SET_HOST_PARAM
:
3916 err
= iscsi_set_host_param(transport
, ev
);
3918 case ISCSI_UEVENT_PATH_UPDATE
:
3919 err
= iscsi_set_path(transport
, ev
);
3921 case ISCSI_UEVENT_SET_IFACE_PARAMS
:
3922 err
= iscsi_set_iface_params(transport
, ev
,
3923 nlmsg_attrlen(nlh
, sizeof(*ev
)));
3925 case ISCSI_UEVENT_PING
:
3926 err
= iscsi_send_ping(transport
, ev
);
3928 case ISCSI_UEVENT_GET_CHAP
:
3929 err
= iscsi_get_chap(transport
, nlh
);
3931 case ISCSI_UEVENT_DELETE_CHAP
:
3932 err
= iscsi_delete_chap(transport
, ev
);
3934 case ISCSI_UEVENT_SET_FLASHNODE_PARAMS
:
3935 err
= iscsi_set_flashnode_param(transport
, ev
,
3939 case ISCSI_UEVENT_NEW_FLASHNODE
:
3940 err
= iscsi_new_flashnode(transport
, ev
,
3941 nlmsg_attrlen(nlh
, sizeof(*ev
)));
3943 case ISCSI_UEVENT_DEL_FLASHNODE
:
3944 err
= iscsi_del_flashnode(transport
, ev
);
3946 case ISCSI_UEVENT_LOGIN_FLASHNODE
:
3947 err
= iscsi_login_flashnode(transport
, ev
);
3949 case ISCSI_UEVENT_LOGOUT_FLASHNODE
:
3950 err
= iscsi_logout_flashnode(transport
, ev
);
3952 case ISCSI_UEVENT_LOGOUT_FLASHNODE_SID
:
3953 err
= iscsi_logout_flashnode_sid(transport
, ev
);
3955 case ISCSI_UEVENT_SET_CHAP
:
3956 err
= iscsi_set_chap(transport
, ev
,
3957 nlmsg_attrlen(nlh
, sizeof(*ev
)));
3959 case ISCSI_UEVENT_GET_HOST_STATS
:
3960 err
= iscsi_get_host_stats(transport
, nlh
);
3967 module_put(transport
->owner
);
3972 * Get message from skb. Each message is processed by iscsi_if_recv_msg.
3973 * Malformed skbs with wrong lengths or invalid creds are not processed.
3976 iscsi_if_rx(struct sk_buff
*skb
)
3978 u32 portid
= NETLINK_CB(skb
).portid
;
3980 mutex_lock(&rx_queue_mutex
);
3981 while (skb
->len
>= NLMSG_HDRLEN
) {
3984 struct nlmsghdr
*nlh
;
3985 struct iscsi_uevent
*ev
;
3987 int retries
= ISCSI_SEND_MAX_ALLOWED
;
3989 nlh
= nlmsg_hdr(skb
);
3990 if (nlh
->nlmsg_len
< sizeof(*nlh
) + sizeof(*ev
) ||
3991 skb
->len
< nlh
->nlmsg_len
) {
3995 ev
= nlmsg_data(nlh
);
3996 rlen
= NLMSG_ALIGN(nlh
->nlmsg_len
);
3997 if (rlen
> skb
->len
)
4000 err
= iscsi_if_recv_msg(skb
, nlh
, &group
);
4002 ev
->type
= ISCSI_KEVENT_IF_ERROR
;
4007 * special case for GET_STATS:
4008 * on success - sending reply and stats from
4009 * inside of if_recv_msg(),
4010 * on error - fall through.
4012 if (ev
->type
== ISCSI_UEVENT_GET_STATS
&& !err
)
4014 if (ev
->type
== ISCSI_UEVENT_GET_CHAP
&& !err
)
4016 err
= iscsi_if_send_reply(portid
, nlh
->nlmsg_type
,
4018 if (err
== -EAGAIN
&& --retries
< 0) {
4019 printk(KERN_WARNING
"Send reply failed, error %d\n", err
);
4022 } while (err
< 0 && err
!= -ECONNREFUSED
&& err
!= -ESRCH
);
4023 skb_pull(skb
, rlen
);
4025 mutex_unlock(&rx_queue_mutex
);
4028 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \
4029 struct device_attribute dev_attr_##_prefix##_##_name = \
4030 __ATTR(_name,_mode,_show,_store)
4033 * iSCSI connection attrs
4035 #define iscsi_conn_attr_show(param) \
4037 show_conn_param_##param(struct device *dev, \
4038 struct device_attribute *attr, char *buf) \
4040 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
4041 struct iscsi_transport *t = conn->transport; \
4042 return t->get_conn_param(conn, param, buf); \
4045 #define iscsi_conn_attr(field, param) \
4046 iscsi_conn_attr_show(param) \
4047 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param, \
4050 iscsi_conn_attr(max_recv_dlength
, ISCSI_PARAM_MAX_RECV_DLENGTH
);
4051 iscsi_conn_attr(max_xmit_dlength
, ISCSI_PARAM_MAX_XMIT_DLENGTH
);
4052 iscsi_conn_attr(header_digest
, ISCSI_PARAM_HDRDGST_EN
);
4053 iscsi_conn_attr(data_digest
, ISCSI_PARAM_DATADGST_EN
);
4054 iscsi_conn_attr(ifmarker
, ISCSI_PARAM_IFMARKER_EN
);
4055 iscsi_conn_attr(ofmarker
, ISCSI_PARAM_OFMARKER_EN
);
4056 iscsi_conn_attr(persistent_port
, ISCSI_PARAM_PERSISTENT_PORT
);
4057 iscsi_conn_attr(exp_statsn
, ISCSI_PARAM_EXP_STATSN
);
4058 iscsi_conn_attr(persistent_address
, ISCSI_PARAM_PERSISTENT_ADDRESS
);
4059 iscsi_conn_attr(ping_tmo
, ISCSI_PARAM_PING_TMO
);
4060 iscsi_conn_attr(recv_tmo
, ISCSI_PARAM_RECV_TMO
);
4061 iscsi_conn_attr(local_port
, ISCSI_PARAM_LOCAL_PORT
);
4062 iscsi_conn_attr(statsn
, ISCSI_PARAM_STATSN
);
4063 iscsi_conn_attr(keepalive_tmo
, ISCSI_PARAM_KEEPALIVE_TMO
);
4064 iscsi_conn_attr(max_segment_size
, ISCSI_PARAM_MAX_SEGMENT_SIZE
);
4065 iscsi_conn_attr(tcp_timestamp_stat
, ISCSI_PARAM_TCP_TIMESTAMP_STAT
);
4066 iscsi_conn_attr(tcp_wsf_disable
, ISCSI_PARAM_TCP_WSF_DISABLE
);
4067 iscsi_conn_attr(tcp_nagle_disable
, ISCSI_PARAM_TCP_NAGLE_DISABLE
);
4068 iscsi_conn_attr(tcp_timer_scale
, ISCSI_PARAM_TCP_TIMER_SCALE
);
4069 iscsi_conn_attr(tcp_timestamp_enable
, ISCSI_PARAM_TCP_TIMESTAMP_EN
);
4070 iscsi_conn_attr(fragment_disable
, ISCSI_PARAM_IP_FRAGMENT_DISABLE
);
4071 iscsi_conn_attr(ipv4_tos
, ISCSI_PARAM_IPV4_TOS
);
4072 iscsi_conn_attr(ipv6_traffic_class
, ISCSI_PARAM_IPV6_TC
);
4073 iscsi_conn_attr(ipv6_flow_label
, ISCSI_PARAM_IPV6_FLOW_LABEL
);
4074 iscsi_conn_attr(is_fw_assigned_ipv6
, ISCSI_PARAM_IS_FW_ASSIGNED_IPV6
);
4075 iscsi_conn_attr(tcp_xmit_wsf
, ISCSI_PARAM_TCP_XMIT_WSF
);
4076 iscsi_conn_attr(tcp_recv_wsf
, ISCSI_PARAM_TCP_RECV_WSF
);
4077 iscsi_conn_attr(local_ipaddr
, ISCSI_PARAM_LOCAL_IPADDR
);
4079 static const char *const connection_state_names
[] = {
4080 [ISCSI_CONN_UP
] = "up",
4081 [ISCSI_CONN_DOWN
] = "down",
4082 [ISCSI_CONN_FAILED
] = "failed",
4083 [ISCSI_CONN_BOUND
] = "bound"
4086 static ssize_t
show_conn_state(struct device
*dev
,
4087 struct device_attribute
*attr
, char *buf
)
4089 struct iscsi_cls_conn
*conn
= iscsi_dev_to_conn(dev
->parent
);
4090 const char *state
= "unknown";
4092 if (conn
->state
>= 0 &&
4093 conn
->state
< ARRAY_SIZE(connection_state_names
))
4094 state
= connection_state_names
[conn
->state
];
4096 return sysfs_emit(buf
, "%s\n", state
);
4098 static ISCSI_CLASS_ATTR(conn
, state
, S_IRUGO
, show_conn_state
,
4101 #define iscsi_conn_ep_attr_show(param) \
4102 static ssize_t show_conn_ep_param_##param(struct device *dev, \
4103 struct device_attribute *attr,\
4106 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
4107 struct iscsi_transport *t = conn->transport; \
4108 struct iscsi_endpoint *ep; \
4112 * Need to make sure ep_disconnect does not free the LLD's \
4113 * interconnect resources while we are trying to read them. \
4115 mutex_lock(&conn->ep_mutex); \
4117 if (!ep && t->ep_connect) { \
4118 mutex_unlock(&conn->ep_mutex); \
4123 rc = t->get_ep_param(ep, param, buf); \
4125 rc = t->get_conn_param(conn, param, buf); \
4126 mutex_unlock(&conn->ep_mutex); \
4130 #define iscsi_conn_ep_attr(field, param) \
4131 iscsi_conn_ep_attr_show(param) \
4132 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, \
4133 show_conn_ep_param_##param, NULL);
4135 iscsi_conn_ep_attr(address
, ISCSI_PARAM_CONN_ADDRESS
);
4136 iscsi_conn_ep_attr(port
, ISCSI_PARAM_CONN_PORT
);
4138 static struct attribute
*iscsi_conn_attrs
[] = {
4139 &dev_attr_conn_max_recv_dlength
.attr
,
4140 &dev_attr_conn_max_xmit_dlength
.attr
,
4141 &dev_attr_conn_header_digest
.attr
,
4142 &dev_attr_conn_data_digest
.attr
,
4143 &dev_attr_conn_ifmarker
.attr
,
4144 &dev_attr_conn_ofmarker
.attr
,
4145 &dev_attr_conn_address
.attr
,
4146 &dev_attr_conn_port
.attr
,
4147 &dev_attr_conn_exp_statsn
.attr
,
4148 &dev_attr_conn_persistent_address
.attr
,
4149 &dev_attr_conn_persistent_port
.attr
,
4150 &dev_attr_conn_ping_tmo
.attr
,
4151 &dev_attr_conn_recv_tmo
.attr
,
4152 &dev_attr_conn_local_port
.attr
,
4153 &dev_attr_conn_statsn
.attr
,
4154 &dev_attr_conn_keepalive_tmo
.attr
,
4155 &dev_attr_conn_max_segment_size
.attr
,
4156 &dev_attr_conn_tcp_timestamp_stat
.attr
,
4157 &dev_attr_conn_tcp_wsf_disable
.attr
,
4158 &dev_attr_conn_tcp_nagle_disable
.attr
,
4159 &dev_attr_conn_tcp_timer_scale
.attr
,
4160 &dev_attr_conn_tcp_timestamp_enable
.attr
,
4161 &dev_attr_conn_fragment_disable
.attr
,
4162 &dev_attr_conn_ipv4_tos
.attr
,
4163 &dev_attr_conn_ipv6_traffic_class
.attr
,
4164 &dev_attr_conn_ipv6_flow_label
.attr
,
4165 &dev_attr_conn_is_fw_assigned_ipv6
.attr
,
4166 &dev_attr_conn_tcp_xmit_wsf
.attr
,
4167 &dev_attr_conn_tcp_recv_wsf
.attr
,
4168 &dev_attr_conn_local_ipaddr
.attr
,
4169 &dev_attr_conn_state
.attr
,
4173 static umode_t
iscsi_conn_attr_is_visible(struct kobject
*kobj
,
4174 struct attribute
*attr
, int i
)
4176 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4177 struct iscsi_cls_conn
*conn
= transport_class_to_conn(cdev
);
4178 struct iscsi_transport
*t
= conn
->transport
;
4181 if (attr
== &dev_attr_conn_max_recv_dlength
.attr
)
4182 param
= ISCSI_PARAM_MAX_RECV_DLENGTH
;
4183 else if (attr
== &dev_attr_conn_max_xmit_dlength
.attr
)
4184 param
= ISCSI_PARAM_MAX_XMIT_DLENGTH
;
4185 else if (attr
== &dev_attr_conn_header_digest
.attr
)
4186 param
= ISCSI_PARAM_HDRDGST_EN
;
4187 else if (attr
== &dev_attr_conn_data_digest
.attr
)
4188 param
= ISCSI_PARAM_DATADGST_EN
;
4189 else if (attr
== &dev_attr_conn_ifmarker
.attr
)
4190 param
= ISCSI_PARAM_IFMARKER_EN
;
4191 else if (attr
== &dev_attr_conn_ofmarker
.attr
)
4192 param
= ISCSI_PARAM_OFMARKER_EN
;
4193 else if (attr
== &dev_attr_conn_address
.attr
)
4194 param
= ISCSI_PARAM_CONN_ADDRESS
;
4195 else if (attr
== &dev_attr_conn_port
.attr
)
4196 param
= ISCSI_PARAM_CONN_PORT
;
4197 else if (attr
== &dev_attr_conn_exp_statsn
.attr
)
4198 param
= ISCSI_PARAM_EXP_STATSN
;
4199 else if (attr
== &dev_attr_conn_persistent_address
.attr
)
4200 param
= ISCSI_PARAM_PERSISTENT_ADDRESS
;
4201 else if (attr
== &dev_attr_conn_persistent_port
.attr
)
4202 param
= ISCSI_PARAM_PERSISTENT_PORT
;
4203 else if (attr
== &dev_attr_conn_ping_tmo
.attr
)
4204 param
= ISCSI_PARAM_PING_TMO
;
4205 else if (attr
== &dev_attr_conn_recv_tmo
.attr
)
4206 param
= ISCSI_PARAM_RECV_TMO
;
4207 else if (attr
== &dev_attr_conn_local_port
.attr
)
4208 param
= ISCSI_PARAM_LOCAL_PORT
;
4209 else if (attr
== &dev_attr_conn_statsn
.attr
)
4210 param
= ISCSI_PARAM_STATSN
;
4211 else if (attr
== &dev_attr_conn_keepalive_tmo
.attr
)
4212 param
= ISCSI_PARAM_KEEPALIVE_TMO
;
4213 else if (attr
== &dev_attr_conn_max_segment_size
.attr
)
4214 param
= ISCSI_PARAM_MAX_SEGMENT_SIZE
;
4215 else if (attr
== &dev_attr_conn_tcp_timestamp_stat
.attr
)
4216 param
= ISCSI_PARAM_TCP_TIMESTAMP_STAT
;
4217 else if (attr
== &dev_attr_conn_tcp_wsf_disable
.attr
)
4218 param
= ISCSI_PARAM_TCP_WSF_DISABLE
;
4219 else if (attr
== &dev_attr_conn_tcp_nagle_disable
.attr
)
4220 param
= ISCSI_PARAM_TCP_NAGLE_DISABLE
;
4221 else if (attr
== &dev_attr_conn_tcp_timer_scale
.attr
)
4222 param
= ISCSI_PARAM_TCP_TIMER_SCALE
;
4223 else if (attr
== &dev_attr_conn_tcp_timestamp_enable
.attr
)
4224 param
= ISCSI_PARAM_TCP_TIMESTAMP_EN
;
4225 else if (attr
== &dev_attr_conn_fragment_disable
.attr
)
4226 param
= ISCSI_PARAM_IP_FRAGMENT_DISABLE
;
4227 else if (attr
== &dev_attr_conn_ipv4_tos
.attr
)
4228 param
= ISCSI_PARAM_IPV4_TOS
;
4229 else if (attr
== &dev_attr_conn_ipv6_traffic_class
.attr
)
4230 param
= ISCSI_PARAM_IPV6_TC
;
4231 else if (attr
== &dev_attr_conn_ipv6_flow_label
.attr
)
4232 param
= ISCSI_PARAM_IPV6_FLOW_LABEL
;
4233 else if (attr
== &dev_attr_conn_is_fw_assigned_ipv6
.attr
)
4234 param
= ISCSI_PARAM_IS_FW_ASSIGNED_IPV6
;
4235 else if (attr
== &dev_attr_conn_tcp_xmit_wsf
.attr
)
4236 param
= ISCSI_PARAM_TCP_XMIT_WSF
;
4237 else if (attr
== &dev_attr_conn_tcp_recv_wsf
.attr
)
4238 param
= ISCSI_PARAM_TCP_RECV_WSF
;
4239 else if (attr
== &dev_attr_conn_local_ipaddr
.attr
)
4240 param
= ISCSI_PARAM_LOCAL_IPADDR
;
4241 else if (attr
== &dev_attr_conn_state
.attr
)
4244 WARN_ONCE(1, "Invalid conn attr");
4248 return t
->attr_is_visible(ISCSI_PARAM
, param
);
4251 static struct attribute_group iscsi_conn_group
= {
4252 .attrs
= iscsi_conn_attrs
,
4253 .is_visible
= iscsi_conn_attr_is_visible
,
4257 * iSCSI session attrs
4259 #define iscsi_session_attr_show(param, perm) \
4261 show_session_param_##param(struct device *dev, \
4262 struct device_attribute *attr, char *buf) \
4264 struct iscsi_cls_session *session = \
4265 iscsi_dev_to_session(dev->parent); \
4266 struct iscsi_transport *t = session->transport; \
4268 if (perm && !capable(CAP_SYS_ADMIN)) \
4270 return t->get_session_param(session, param, buf); \
4273 #define iscsi_session_attr(field, param, perm) \
4274 iscsi_session_attr_show(param, perm) \
4275 static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
4277 iscsi_session_attr(targetname
, ISCSI_PARAM_TARGET_NAME
, 0);
4278 iscsi_session_attr(initial_r2t
, ISCSI_PARAM_INITIAL_R2T_EN
, 0);
4279 iscsi_session_attr(max_outstanding_r2t
, ISCSI_PARAM_MAX_R2T
, 0);
4280 iscsi_session_attr(immediate_data
, ISCSI_PARAM_IMM_DATA_EN
, 0);
4281 iscsi_session_attr(first_burst_len
, ISCSI_PARAM_FIRST_BURST
, 0);
4282 iscsi_session_attr(max_burst_len
, ISCSI_PARAM_MAX_BURST
, 0);
4283 iscsi_session_attr(data_pdu_in_order
, ISCSI_PARAM_PDU_INORDER_EN
, 0);
4284 iscsi_session_attr(data_seq_in_order
, ISCSI_PARAM_DATASEQ_INORDER_EN
, 0);
4285 iscsi_session_attr(erl
, ISCSI_PARAM_ERL
, 0);
4286 iscsi_session_attr(tpgt
, ISCSI_PARAM_TPGT
, 0);
4287 iscsi_session_attr(username
, ISCSI_PARAM_USERNAME
, 1);
4288 iscsi_session_attr(username_in
, ISCSI_PARAM_USERNAME_IN
, 1);
4289 iscsi_session_attr(password
, ISCSI_PARAM_PASSWORD
, 1);
4290 iscsi_session_attr(password_in
, ISCSI_PARAM_PASSWORD_IN
, 1);
4291 iscsi_session_attr(chap_out_idx
, ISCSI_PARAM_CHAP_OUT_IDX
, 1);
4292 iscsi_session_attr(chap_in_idx
, ISCSI_PARAM_CHAP_IN_IDX
, 1);
4293 iscsi_session_attr(fast_abort
, ISCSI_PARAM_FAST_ABORT
, 0);
4294 iscsi_session_attr(abort_tmo
, ISCSI_PARAM_ABORT_TMO
, 0);
4295 iscsi_session_attr(lu_reset_tmo
, ISCSI_PARAM_LU_RESET_TMO
, 0);
4296 iscsi_session_attr(tgt_reset_tmo
, ISCSI_PARAM_TGT_RESET_TMO
, 0);
4297 iscsi_session_attr(ifacename
, ISCSI_PARAM_IFACE_NAME
, 0);
4298 iscsi_session_attr(initiatorname
, ISCSI_PARAM_INITIATOR_NAME
, 0);
4299 iscsi_session_attr(targetalias
, ISCSI_PARAM_TARGET_ALIAS
, 0);
4300 iscsi_session_attr(boot_root
, ISCSI_PARAM_BOOT_ROOT
, 0);
4301 iscsi_session_attr(boot_nic
, ISCSI_PARAM_BOOT_NIC
, 0);
4302 iscsi_session_attr(boot_target
, ISCSI_PARAM_BOOT_TARGET
, 0);
4303 iscsi_session_attr(auto_snd_tgt_disable
, ISCSI_PARAM_AUTO_SND_TGT_DISABLE
, 0);
4304 iscsi_session_attr(discovery_session
, ISCSI_PARAM_DISCOVERY_SESS
, 0);
4305 iscsi_session_attr(portal_type
, ISCSI_PARAM_PORTAL_TYPE
, 0);
4306 iscsi_session_attr(chap_auth
, ISCSI_PARAM_CHAP_AUTH_EN
, 0);
4307 iscsi_session_attr(discovery_logout
, ISCSI_PARAM_DISCOVERY_LOGOUT_EN
, 0);
4308 iscsi_session_attr(bidi_chap
, ISCSI_PARAM_BIDI_CHAP_EN
, 0);
4309 iscsi_session_attr(discovery_auth_optional
,
4310 ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL
, 0);
4311 iscsi_session_attr(def_time2wait
, ISCSI_PARAM_DEF_TIME2WAIT
, 0);
4312 iscsi_session_attr(def_time2retain
, ISCSI_PARAM_DEF_TIME2RETAIN
, 0);
4313 iscsi_session_attr(isid
, ISCSI_PARAM_ISID
, 0);
4314 iscsi_session_attr(tsid
, ISCSI_PARAM_TSID
, 0);
4315 iscsi_session_attr(def_taskmgmt_tmo
, ISCSI_PARAM_DEF_TASKMGMT_TMO
, 0);
4316 iscsi_session_attr(discovery_parent_idx
, ISCSI_PARAM_DISCOVERY_PARENT_IDX
, 0);
4317 iscsi_session_attr(discovery_parent_type
, ISCSI_PARAM_DISCOVERY_PARENT_TYPE
, 0);
4320 show_priv_session_state(struct device
*dev
, struct device_attribute
*attr
,
4323 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
->parent
);
4324 return sysfs_emit(buf
, "%s\n", iscsi_session_state_name(session
->state
));
4326 static ISCSI_CLASS_ATTR(priv_sess
, state
, S_IRUGO
, show_priv_session_state
,
4329 show_priv_session_creator(struct device
*dev
, struct device_attribute
*attr
,
4332 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
->parent
);
4333 return sysfs_emit(buf
, "%d\n", session
->creator
);
4335 static ISCSI_CLASS_ATTR(priv_sess
, creator
, S_IRUGO
, show_priv_session_creator
,
4338 show_priv_session_target_id(struct device
*dev
, struct device_attribute
*attr
,
4341 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
->parent
);
4342 return sysfs_emit(buf
, "%d\n", session
->target_id
);
4344 static ISCSI_CLASS_ATTR(priv_sess
, target_id
, S_IRUGO
,
4345 show_priv_session_target_id
, NULL
);
4347 #define iscsi_priv_session_attr_show(field, format) \
4349 show_priv_session_##field(struct device *dev, \
4350 struct device_attribute *attr, char *buf) \
4352 struct iscsi_cls_session *session = \
4353 iscsi_dev_to_session(dev->parent); \
4354 if (session->field == -1) \
4355 return sysfs_emit(buf, "off\n"); \
4356 return sysfs_emit(buf, format"\n", session->field); \
4359 #define iscsi_priv_session_attr_store(field) \
4361 store_priv_session_##field(struct device *dev, \
4362 struct device_attribute *attr, \
4363 const char *buf, size_t count) \
4367 struct iscsi_cls_session *session = \
4368 iscsi_dev_to_session(dev->parent); \
4369 if ((session->state == ISCSI_SESSION_FREE) || \
4370 (session->state == ISCSI_SESSION_FAILED)) \
4372 if (strncmp(buf, "off", 3) == 0) { \
4373 session->field = -1; \
4374 session->field##_sysfs_override = true; \
4376 val = simple_strtoul(buf, &cp, 0); \
4377 if (*cp != '\0' && *cp != '\n') \
4379 session->field = val; \
4380 session->field##_sysfs_override = true; \
4385 #define iscsi_priv_session_rw_attr(field, format) \
4386 iscsi_priv_session_attr_show(field, format) \
4387 iscsi_priv_session_attr_store(field) \
4388 static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO | S_IWUSR, \
4389 show_priv_session_##field, \
4390 store_priv_session_##field)
4392 iscsi_priv_session_rw_attr(recovery_tmo
, "%d");
4394 static struct attribute
*iscsi_session_attrs
[] = {
4395 &dev_attr_sess_initial_r2t
.attr
,
4396 &dev_attr_sess_max_outstanding_r2t
.attr
,
4397 &dev_attr_sess_immediate_data
.attr
,
4398 &dev_attr_sess_first_burst_len
.attr
,
4399 &dev_attr_sess_max_burst_len
.attr
,
4400 &dev_attr_sess_data_pdu_in_order
.attr
,
4401 &dev_attr_sess_data_seq_in_order
.attr
,
4402 &dev_attr_sess_erl
.attr
,
4403 &dev_attr_sess_targetname
.attr
,
4404 &dev_attr_sess_tpgt
.attr
,
4405 &dev_attr_sess_password
.attr
,
4406 &dev_attr_sess_password_in
.attr
,
4407 &dev_attr_sess_username
.attr
,
4408 &dev_attr_sess_username_in
.attr
,
4409 &dev_attr_sess_fast_abort
.attr
,
4410 &dev_attr_sess_abort_tmo
.attr
,
4411 &dev_attr_sess_lu_reset_tmo
.attr
,
4412 &dev_attr_sess_tgt_reset_tmo
.attr
,
4413 &dev_attr_sess_ifacename
.attr
,
4414 &dev_attr_sess_initiatorname
.attr
,
4415 &dev_attr_sess_targetalias
.attr
,
4416 &dev_attr_sess_boot_root
.attr
,
4417 &dev_attr_sess_boot_nic
.attr
,
4418 &dev_attr_sess_boot_target
.attr
,
4419 &dev_attr_priv_sess_recovery_tmo
.attr
,
4420 &dev_attr_priv_sess_state
.attr
,
4421 &dev_attr_priv_sess_creator
.attr
,
4422 &dev_attr_sess_chap_out_idx
.attr
,
4423 &dev_attr_sess_chap_in_idx
.attr
,
4424 &dev_attr_priv_sess_target_id
.attr
,
4425 &dev_attr_sess_auto_snd_tgt_disable
.attr
,
4426 &dev_attr_sess_discovery_session
.attr
,
4427 &dev_attr_sess_portal_type
.attr
,
4428 &dev_attr_sess_chap_auth
.attr
,
4429 &dev_attr_sess_discovery_logout
.attr
,
4430 &dev_attr_sess_bidi_chap
.attr
,
4431 &dev_attr_sess_discovery_auth_optional
.attr
,
4432 &dev_attr_sess_def_time2wait
.attr
,
4433 &dev_attr_sess_def_time2retain
.attr
,
4434 &dev_attr_sess_isid
.attr
,
4435 &dev_attr_sess_tsid
.attr
,
4436 &dev_attr_sess_def_taskmgmt_tmo
.attr
,
4437 &dev_attr_sess_discovery_parent_idx
.attr
,
4438 &dev_attr_sess_discovery_parent_type
.attr
,
4442 static umode_t
iscsi_session_attr_is_visible(struct kobject
*kobj
,
4443 struct attribute
*attr
, int i
)
4445 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4446 struct iscsi_cls_session
*session
= transport_class_to_session(cdev
);
4447 struct iscsi_transport
*t
= session
->transport
;
4450 if (attr
== &dev_attr_sess_initial_r2t
.attr
)
4451 param
= ISCSI_PARAM_INITIAL_R2T_EN
;
4452 else if (attr
== &dev_attr_sess_max_outstanding_r2t
.attr
)
4453 param
= ISCSI_PARAM_MAX_R2T
;
4454 else if (attr
== &dev_attr_sess_immediate_data
.attr
)
4455 param
= ISCSI_PARAM_IMM_DATA_EN
;
4456 else if (attr
== &dev_attr_sess_first_burst_len
.attr
)
4457 param
= ISCSI_PARAM_FIRST_BURST
;
4458 else if (attr
== &dev_attr_sess_max_burst_len
.attr
)
4459 param
= ISCSI_PARAM_MAX_BURST
;
4460 else if (attr
== &dev_attr_sess_data_pdu_in_order
.attr
)
4461 param
= ISCSI_PARAM_PDU_INORDER_EN
;
4462 else if (attr
== &dev_attr_sess_data_seq_in_order
.attr
)
4463 param
= ISCSI_PARAM_DATASEQ_INORDER_EN
;
4464 else if (attr
== &dev_attr_sess_erl
.attr
)
4465 param
= ISCSI_PARAM_ERL
;
4466 else if (attr
== &dev_attr_sess_targetname
.attr
)
4467 param
= ISCSI_PARAM_TARGET_NAME
;
4468 else if (attr
== &dev_attr_sess_tpgt
.attr
)
4469 param
= ISCSI_PARAM_TPGT
;
4470 else if (attr
== &dev_attr_sess_chap_in_idx
.attr
)
4471 param
= ISCSI_PARAM_CHAP_IN_IDX
;
4472 else if (attr
== &dev_attr_sess_chap_out_idx
.attr
)
4473 param
= ISCSI_PARAM_CHAP_OUT_IDX
;
4474 else if (attr
== &dev_attr_sess_password
.attr
)
4475 param
= ISCSI_PARAM_USERNAME
;
4476 else if (attr
== &dev_attr_sess_password_in
.attr
)
4477 param
= ISCSI_PARAM_USERNAME_IN
;
4478 else if (attr
== &dev_attr_sess_username
.attr
)
4479 param
= ISCSI_PARAM_PASSWORD
;
4480 else if (attr
== &dev_attr_sess_username_in
.attr
)
4481 param
= ISCSI_PARAM_PASSWORD_IN
;
4482 else if (attr
== &dev_attr_sess_fast_abort
.attr
)
4483 param
= ISCSI_PARAM_FAST_ABORT
;
4484 else if (attr
== &dev_attr_sess_abort_tmo
.attr
)
4485 param
= ISCSI_PARAM_ABORT_TMO
;
4486 else if (attr
== &dev_attr_sess_lu_reset_tmo
.attr
)
4487 param
= ISCSI_PARAM_LU_RESET_TMO
;
4488 else if (attr
== &dev_attr_sess_tgt_reset_tmo
.attr
)
4489 param
= ISCSI_PARAM_TGT_RESET_TMO
;
4490 else if (attr
== &dev_attr_sess_ifacename
.attr
)
4491 param
= ISCSI_PARAM_IFACE_NAME
;
4492 else if (attr
== &dev_attr_sess_initiatorname
.attr
)
4493 param
= ISCSI_PARAM_INITIATOR_NAME
;
4494 else if (attr
== &dev_attr_sess_targetalias
.attr
)
4495 param
= ISCSI_PARAM_TARGET_ALIAS
;
4496 else if (attr
== &dev_attr_sess_boot_root
.attr
)
4497 param
= ISCSI_PARAM_BOOT_ROOT
;
4498 else if (attr
== &dev_attr_sess_boot_nic
.attr
)
4499 param
= ISCSI_PARAM_BOOT_NIC
;
4500 else if (attr
== &dev_attr_sess_boot_target
.attr
)
4501 param
= ISCSI_PARAM_BOOT_TARGET
;
4502 else if (attr
== &dev_attr_sess_auto_snd_tgt_disable
.attr
)
4503 param
= ISCSI_PARAM_AUTO_SND_TGT_DISABLE
;
4504 else if (attr
== &dev_attr_sess_discovery_session
.attr
)
4505 param
= ISCSI_PARAM_DISCOVERY_SESS
;
4506 else if (attr
== &dev_attr_sess_portal_type
.attr
)
4507 param
= ISCSI_PARAM_PORTAL_TYPE
;
4508 else if (attr
== &dev_attr_sess_chap_auth
.attr
)
4509 param
= ISCSI_PARAM_CHAP_AUTH_EN
;
4510 else if (attr
== &dev_attr_sess_discovery_logout
.attr
)
4511 param
= ISCSI_PARAM_DISCOVERY_LOGOUT_EN
;
4512 else if (attr
== &dev_attr_sess_bidi_chap
.attr
)
4513 param
= ISCSI_PARAM_BIDI_CHAP_EN
;
4514 else if (attr
== &dev_attr_sess_discovery_auth_optional
.attr
)
4515 param
= ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL
;
4516 else if (attr
== &dev_attr_sess_def_time2wait
.attr
)
4517 param
= ISCSI_PARAM_DEF_TIME2WAIT
;
4518 else if (attr
== &dev_attr_sess_def_time2retain
.attr
)
4519 param
= ISCSI_PARAM_DEF_TIME2RETAIN
;
4520 else if (attr
== &dev_attr_sess_isid
.attr
)
4521 param
= ISCSI_PARAM_ISID
;
4522 else if (attr
== &dev_attr_sess_tsid
.attr
)
4523 param
= ISCSI_PARAM_TSID
;
4524 else if (attr
== &dev_attr_sess_def_taskmgmt_tmo
.attr
)
4525 param
= ISCSI_PARAM_DEF_TASKMGMT_TMO
;
4526 else if (attr
== &dev_attr_sess_discovery_parent_idx
.attr
)
4527 param
= ISCSI_PARAM_DISCOVERY_PARENT_IDX
;
4528 else if (attr
== &dev_attr_sess_discovery_parent_type
.attr
)
4529 param
= ISCSI_PARAM_DISCOVERY_PARENT_TYPE
;
4530 else if (attr
== &dev_attr_priv_sess_recovery_tmo
.attr
)
4531 return S_IRUGO
| S_IWUSR
;
4532 else if (attr
== &dev_attr_priv_sess_state
.attr
)
4534 else if (attr
== &dev_attr_priv_sess_creator
.attr
)
4536 else if (attr
== &dev_attr_priv_sess_target_id
.attr
)
4539 WARN_ONCE(1, "Invalid session attr");
4543 return t
->attr_is_visible(ISCSI_PARAM
, param
);
4546 static struct attribute_group iscsi_session_group
= {
4547 .attrs
= iscsi_session_attrs
,
4548 .is_visible
= iscsi_session_attr_is_visible
,
4554 #define iscsi_host_attr_show(param) \
4556 show_host_param_##param(struct device *dev, \
4557 struct device_attribute *attr, char *buf) \
4559 struct Scsi_Host *shost = transport_class_to_shost(dev); \
4560 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
4561 return priv->iscsi_transport->get_host_param(shost, param, buf); \
4564 #define iscsi_host_attr(field, param) \
4565 iscsi_host_attr_show(param) \
4566 static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param, \
4569 iscsi_host_attr(netdev
, ISCSI_HOST_PARAM_NETDEV_NAME
);
4570 iscsi_host_attr(hwaddress
, ISCSI_HOST_PARAM_HWADDRESS
);
4571 iscsi_host_attr(ipaddress
, ISCSI_HOST_PARAM_IPADDRESS
);
4572 iscsi_host_attr(initiatorname
, ISCSI_HOST_PARAM_INITIATOR_NAME
);
4573 iscsi_host_attr(port_state
, ISCSI_HOST_PARAM_PORT_STATE
);
4574 iscsi_host_attr(port_speed
, ISCSI_HOST_PARAM_PORT_SPEED
);
4576 static struct attribute
*iscsi_host_attrs
[] = {
4577 &dev_attr_host_netdev
.attr
,
4578 &dev_attr_host_hwaddress
.attr
,
4579 &dev_attr_host_ipaddress
.attr
,
4580 &dev_attr_host_initiatorname
.attr
,
4581 &dev_attr_host_port_state
.attr
,
4582 &dev_attr_host_port_speed
.attr
,
4586 static umode_t
iscsi_host_attr_is_visible(struct kobject
*kobj
,
4587 struct attribute
*attr
, int i
)
4589 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4590 struct Scsi_Host
*shost
= transport_class_to_shost(cdev
);
4591 struct iscsi_internal
*priv
= to_iscsi_internal(shost
->transportt
);
4594 if (attr
== &dev_attr_host_netdev
.attr
)
4595 param
= ISCSI_HOST_PARAM_NETDEV_NAME
;
4596 else if (attr
== &dev_attr_host_hwaddress
.attr
)
4597 param
= ISCSI_HOST_PARAM_HWADDRESS
;
4598 else if (attr
== &dev_attr_host_ipaddress
.attr
)
4599 param
= ISCSI_HOST_PARAM_IPADDRESS
;
4600 else if (attr
== &dev_attr_host_initiatorname
.attr
)
4601 param
= ISCSI_HOST_PARAM_INITIATOR_NAME
;
4602 else if (attr
== &dev_attr_host_port_state
.attr
)
4603 param
= ISCSI_HOST_PARAM_PORT_STATE
;
4604 else if (attr
== &dev_attr_host_port_speed
.attr
)
4605 param
= ISCSI_HOST_PARAM_PORT_SPEED
;
4607 WARN_ONCE(1, "Invalid host attr");
4611 return priv
->iscsi_transport
->attr_is_visible(ISCSI_HOST_PARAM
, param
);
4614 static struct attribute_group iscsi_host_group
= {
4615 .attrs
= iscsi_host_attrs
,
4616 .is_visible
= iscsi_host_attr_is_visible
,
4619 /* convert iscsi_port_speed values to ascii string name */
4620 static const struct {
4621 enum iscsi_port_speed value
;
4623 } iscsi_port_speed_names
[] = {
4624 {ISCSI_PORT_SPEED_UNKNOWN
, "Unknown" },
4625 {ISCSI_PORT_SPEED_10MBPS
, "10 Mbps" },
4626 {ISCSI_PORT_SPEED_100MBPS
, "100 Mbps" },
4627 {ISCSI_PORT_SPEED_1GBPS
, "1 Gbps" },
4628 {ISCSI_PORT_SPEED_10GBPS
, "10 Gbps" },
4629 {ISCSI_PORT_SPEED_25GBPS
, "25 Gbps" },
4630 {ISCSI_PORT_SPEED_40GBPS
, "40 Gbps" },
4633 char *iscsi_get_port_speed_name(struct Scsi_Host
*shost
)
4636 char *speed
= "Unknown!";
4637 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
4638 uint32_t port_speed
= ihost
->port_speed
;
4640 for (i
= 0; i
< ARRAY_SIZE(iscsi_port_speed_names
); i
++) {
4641 if (iscsi_port_speed_names
[i
].value
& port_speed
) {
4642 speed
= iscsi_port_speed_names
[i
].name
;
4648 EXPORT_SYMBOL_GPL(iscsi_get_port_speed_name
);
4650 /* convert iscsi_port_state values to ascii string name */
4651 static const struct {
4652 enum iscsi_port_state value
;
4654 } iscsi_port_state_names
[] = {
4655 {ISCSI_PORT_STATE_DOWN
, "LINK DOWN" },
4656 {ISCSI_PORT_STATE_UP
, "LINK UP" },
4659 char *iscsi_get_port_state_name(struct Scsi_Host
*shost
)
4662 char *state
= "Unknown!";
4663 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
4664 uint32_t port_state
= ihost
->port_state
;
4666 for (i
= 0; i
< ARRAY_SIZE(iscsi_port_state_names
); i
++) {
4667 if (iscsi_port_state_names
[i
].value
& port_state
) {
4668 state
= iscsi_port_state_names
[i
].name
;
4674 EXPORT_SYMBOL_GPL(iscsi_get_port_state_name
);
4676 static int iscsi_session_match(struct attribute_container
*cont
,
4679 struct iscsi_cls_session
*session
;
4680 struct Scsi_Host
*shost
;
4681 struct iscsi_internal
*priv
;
4683 if (!iscsi_is_session_dev(dev
))
4686 session
= iscsi_dev_to_session(dev
);
4687 shost
= iscsi_session_to_shost(session
);
4688 if (!shost
->transportt
)
4691 priv
= to_iscsi_internal(shost
->transportt
);
4692 if (priv
->session_cont
.ac
.class != &iscsi_session_class
.class)
4695 return &priv
->session_cont
.ac
== cont
;
4698 static int iscsi_conn_match(struct attribute_container
*cont
,
4701 struct iscsi_cls_session
*session
;
4702 struct iscsi_cls_conn
*conn
;
4703 struct Scsi_Host
*shost
;
4704 struct iscsi_internal
*priv
;
4706 if (!iscsi_is_conn_dev(dev
))
4709 conn
= iscsi_dev_to_conn(dev
);
4710 session
= iscsi_dev_to_session(conn
->dev
.parent
);
4711 shost
= iscsi_session_to_shost(session
);
4713 if (!shost
->transportt
)
4716 priv
= to_iscsi_internal(shost
->transportt
);
4717 if (priv
->conn_cont
.ac
.class != &iscsi_connection_class
.class)
4720 return &priv
->conn_cont
.ac
== cont
;
4723 static int iscsi_host_match(struct attribute_container
*cont
,
4726 struct Scsi_Host
*shost
;
4727 struct iscsi_internal
*priv
;
4729 if (!scsi_is_host_device(dev
))
4732 shost
= dev_to_shost(dev
);
4733 if (!shost
->transportt
||
4734 shost
->transportt
->host_attrs
.ac
.class != &iscsi_host_class
.class)
4737 priv
= to_iscsi_internal(shost
->transportt
);
4738 return &priv
->t
.host_attrs
.ac
== cont
;
4741 struct scsi_transport_template
*
4742 iscsi_register_transport(struct iscsi_transport
*tt
)
4744 struct iscsi_internal
*priv
;
4745 unsigned long flags
;
4749 WARN_ON(tt
->ep_disconnect
&& !tt
->unbind_conn
);
4751 priv
= iscsi_if_transport_lookup(tt
);
4755 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
4758 INIT_LIST_HEAD(&priv
->list
);
4759 priv
->iscsi_transport
= tt
;
4760 priv
->t
.user_scan
= iscsi_user_scan
;
4761 priv
->t
.create_work_queue
= 1;
4763 priv
->dev
.class = &iscsi_transport_class
;
4764 dev_set_name(&priv
->dev
, "%s", tt
->name
);
4765 err
= device_register(&priv
->dev
);
4769 err
= sysfs_create_group(&priv
->dev
.kobj
, &iscsi_transport_group
);
4771 goto unregister_dev
;
4773 /* host parameters */
4774 priv
->t
.host_attrs
.ac
.class = &iscsi_host_class
.class;
4775 priv
->t
.host_attrs
.ac
.match
= iscsi_host_match
;
4776 priv
->t
.host_attrs
.ac
.grp
= &iscsi_host_group
;
4777 priv
->t
.host_size
= sizeof(struct iscsi_cls_host
);
4778 transport_container_register(&priv
->t
.host_attrs
);
4780 /* connection parameters */
4781 priv
->conn_cont
.ac
.class = &iscsi_connection_class
.class;
4782 priv
->conn_cont
.ac
.match
= iscsi_conn_match
;
4783 priv
->conn_cont
.ac
.grp
= &iscsi_conn_group
;
4784 transport_container_register(&priv
->conn_cont
);
4786 /* session parameters */
4787 priv
->session_cont
.ac
.class = &iscsi_session_class
.class;
4788 priv
->session_cont
.ac
.match
= iscsi_session_match
;
4789 priv
->session_cont
.ac
.grp
= &iscsi_session_group
;
4790 transport_container_register(&priv
->session_cont
);
4792 spin_lock_irqsave(&iscsi_transport_lock
, flags
);
4793 list_add(&priv
->list
, &iscsi_transports
);
4794 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
4796 printk(KERN_NOTICE
"iscsi: registered transport (%s)\n", tt
->name
);
4800 device_unregister(&priv
->dev
);
4806 EXPORT_SYMBOL_GPL(iscsi_register_transport
);
4808 int iscsi_unregister_transport(struct iscsi_transport
*tt
)
4810 struct iscsi_internal
*priv
;
4811 unsigned long flags
;
4815 mutex_lock(&rx_queue_mutex
);
4817 priv
= iscsi_if_transport_lookup(tt
);
4820 spin_lock_irqsave(&iscsi_transport_lock
, flags
);
4821 list_del(&priv
->list
);
4822 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
4824 transport_container_unregister(&priv
->conn_cont
);
4825 transport_container_unregister(&priv
->session_cont
);
4826 transport_container_unregister(&priv
->t
.host_attrs
);
4828 sysfs_remove_group(&priv
->dev
.kobj
, &iscsi_transport_group
);
4829 device_unregister(&priv
->dev
);
4830 mutex_unlock(&rx_queue_mutex
);
4834 EXPORT_SYMBOL_GPL(iscsi_unregister_transport
);
4836 void iscsi_dbg_trace(void (*trace
)(struct device
*dev
, struct va_format
*),
4837 struct device
*dev
, const char *fmt
, ...)
4839 struct va_format vaf
;
4842 va_start(args
, fmt
);
4848 EXPORT_SYMBOL_GPL(iscsi_dbg_trace
);
4850 static __init
int iscsi_transport_init(void)
4853 struct netlink_kernel_cfg cfg
= {
4855 .input
= iscsi_if_rx
,
4857 printk(KERN_INFO
"Loading iSCSI transport class v%s.\n",
4858 ISCSI_TRANSPORT_VERSION
);
4860 atomic_set(&iscsi_session_nr
, 0);
4862 err
= class_register(&iscsi_transport_class
);
4866 err
= class_register(&iscsi_endpoint_class
);
4868 goto unregister_transport_class
;
4870 err
= class_register(&iscsi_iface_class
);
4872 goto unregister_endpoint_class
;
4874 err
= transport_class_register(&iscsi_host_class
);
4876 goto unregister_iface_class
;
4878 err
= transport_class_register(&iscsi_connection_class
);
4880 goto unregister_host_class
;
4882 err
= transport_class_register(&iscsi_session_class
);
4884 goto unregister_conn_class
;
4886 err
= bus_register(&iscsi_flashnode_bus
);
4888 goto unregister_session_class
;
4890 nls
= netlink_kernel_create(&init_net
, NETLINK_ISCSI
, &cfg
);
4893 goto unregister_flashnode_bus
;
4896 iscsi_eh_timer_workq
= alloc_workqueue("%s",
4897 WQ_SYSFS
| __WQ_LEGACY
| WQ_MEM_RECLAIM
| WQ_UNBOUND
,
4899 if (!iscsi_eh_timer_workq
) {
4904 iscsi_conn_cleanup_workq
= alloc_workqueue("%s",
4905 WQ_SYSFS
| WQ_MEM_RECLAIM
| WQ_UNBOUND
, 0,
4906 "iscsi_conn_cleanup");
4907 if (!iscsi_conn_cleanup_workq
) {
4915 destroy_workqueue(iscsi_eh_timer_workq
);
4917 netlink_kernel_release(nls
);
4918 unregister_flashnode_bus
:
4919 bus_unregister(&iscsi_flashnode_bus
);
4920 unregister_session_class
:
4921 transport_class_unregister(&iscsi_session_class
);
4922 unregister_conn_class
:
4923 transport_class_unregister(&iscsi_connection_class
);
4924 unregister_host_class
:
4925 transport_class_unregister(&iscsi_host_class
);
4926 unregister_iface_class
:
4927 class_unregister(&iscsi_iface_class
);
4928 unregister_endpoint_class
:
4929 class_unregister(&iscsi_endpoint_class
);
4930 unregister_transport_class
:
4931 class_unregister(&iscsi_transport_class
);
4935 static void __exit
iscsi_transport_exit(void)
4937 destroy_workqueue(iscsi_conn_cleanup_workq
);
4938 destroy_workqueue(iscsi_eh_timer_workq
);
4939 netlink_kernel_release(nls
);
4940 bus_unregister(&iscsi_flashnode_bus
);
4941 transport_class_unregister(&iscsi_connection_class
);
4942 transport_class_unregister(&iscsi_session_class
);
4943 transport_class_unregister(&iscsi_host_class
);
4944 class_unregister(&iscsi_endpoint_class
);
4945 class_unregister(&iscsi_iface_class
);
4946 class_unregister(&iscsi_transport_class
);
4949 module_init(iscsi_transport_init
);
4950 module_exit(iscsi_transport_exit
);
4952 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
4953 "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
4954 "Alex Aizman <itn780@yahoo.com>");
4955 MODULE_DESCRIPTION("iSCSI Transport Interface");
4956 MODULE_LICENSE("GPL");
4957 MODULE_VERSION(ISCSI_TRANSPORT_VERSION
);
4958 MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK
, NETLINK_ISCSI
);