2 * iSCSI transport class definitions
4 * Copyright (C) IBM Corporation, 2004
5 * Copyright (C) Mike Christie, 2004 - 2005
6 * Copyright (C) Dmitry Yusupov, 2004 - 2005
7 * Copyright (C) Alex Aizman, 2004 - 2005
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 #include <linux/module.h>
24 #include <linux/mutex.h>
25 #include <linux/slab.h>
26 #include <linux/bsg-lib.h>
27 #include <linux/idr.h>
28 #include <linux/list.h>
30 #include <scsi/scsi.h>
31 #include <scsi/scsi_host.h>
32 #include <scsi/scsi_device.h>
33 #include <scsi/scsi_transport.h>
34 #include <scsi/scsi_transport_iscsi.h>
35 #include <scsi/iscsi_if.h>
36 #include <scsi/scsi_cmnd.h>
37 #include <scsi/scsi_bsg_iscsi.h>
39 #define ISCSI_TRANSPORT_VERSION "2.0-870"
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, \
65 #define ISCSI_DBG_TRANS_CONN(_conn, dbg_fmt, arg...) \
68 iscsi_cls_conn_printk(KERN_INFO, _conn, \
73 struct iscsi_internal {
74 struct scsi_transport_template t;
75 struct iscsi_transport *iscsi_transport;
76 struct list_head list;
79 struct transport_container conn_cont;
80 struct transport_container session_cont;
83 static atomic_t iscsi_session_nr; /* sysfs session id for next new session */
84 static struct workqueue_struct *iscsi_eh_timer_workq;
86 static DEFINE_IDA(iscsi_sess_ida);
88 * list of registered transports and lock that must
89 * be held while accessing list. The iscsi_transport_lock must
90 * be acquired after the rx_queue_mutex.
92 static LIST_HEAD(iscsi_transports);
93 static DEFINE_SPINLOCK(iscsi_transport_lock);
95 #define to_iscsi_internal(tmpl) \
96 container_of(tmpl, struct iscsi_internal, t)
98 #define dev_to_iscsi_internal(_dev) \
99 container_of(_dev, struct iscsi_internal, dev)
101 static void iscsi_transport_release(struct device *dev)
103 struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
108 * iscsi_transport_class represents the iscsi_transports that are
111 static struct class iscsi_transport_class = {
112 .name = "iscsi_transport",
113 .dev_release = iscsi_transport_release,
117 show_transport_handle(struct device *dev, struct device_attribute *attr,
120 struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
121 return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
123 static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
125 #define show_transport_attr(name, format) \
127 show_transport_##name(struct device *dev, \
128 struct device_attribute *attr,char *buf) \
130 struct iscsi_internal *priv = dev_to_iscsi_internal(dev); \
131 return sprintf(buf, format"\n", priv->iscsi_transport->name); \
133 static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
135 show_transport_attr(caps, "0x%x");
137 static struct attribute *iscsi_transport_attrs[] = {
138 &dev_attr_handle.attr,
143 static struct attribute_group iscsi_transport_group = {
144 .attrs = iscsi_transport_attrs,
148 * iSCSI endpoint attrs
150 #define iscsi_dev_to_endpoint(_dev) \
151 container_of(_dev, struct iscsi_endpoint, dev)
153 #define ISCSI_ATTR(_prefix,_name,_mode,_show,_store) \
154 struct device_attribute dev_attr_##_prefix##_##_name = \
155 __ATTR(_name,_mode,_show,_store)
157 static void iscsi_endpoint_release(struct device *dev)
159 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
163 static struct class iscsi_endpoint_class = {
164 .name = "iscsi_endpoint",
165 .dev_release = iscsi_endpoint_release,
169 show_ep_handle(struct device *dev, struct device_attribute *attr, char *buf)
171 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
172 return sprintf(buf, "%llu\n", (unsigned long long) ep->id);
174 static ISCSI_ATTR(ep, handle, S_IRUGO, show_ep_handle, NULL);
176 static struct attribute *iscsi_endpoint_attrs[] = {
177 &dev_attr_ep_handle.attr,
181 static struct attribute_group iscsi_endpoint_group = {
182 .attrs = iscsi_endpoint_attrs,
185 #define ISCSI_MAX_EPID -1
187 static int iscsi_match_epid(struct device *dev, const void *data)
189 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
190 const uint64_t *epid = data;
192 return *epid == ep->id;
195 struct iscsi_endpoint *
196 iscsi_create_endpoint(int dd_size)
199 struct iscsi_endpoint *ep;
203 for (id = 1; id < ISCSI_MAX_EPID; id++) {
204 dev = class_find_device(&iscsi_endpoint_class, NULL, &id,
209 if (id == ISCSI_MAX_EPID) {
210 printk(KERN_ERR "Too many connections. Max supported %u\n",
215 ep = kzalloc(sizeof(*ep) + dd_size, GFP_KERNEL);
220 ep->dev.class = &iscsi_endpoint_class;
221 dev_set_name(&ep->dev, "ep-%llu", (unsigned long long) id);
222 err = device_register(&ep->dev);
226 err = sysfs_create_group(&ep->dev.kobj, &iscsi_endpoint_group);
231 ep->dd_data = &ep[1];
235 device_unregister(&ep->dev);
242 EXPORT_SYMBOL_GPL(iscsi_create_endpoint);
244 void iscsi_destroy_endpoint(struct iscsi_endpoint *ep)
246 sysfs_remove_group(&ep->dev.kobj, &iscsi_endpoint_group);
247 device_unregister(&ep->dev);
249 EXPORT_SYMBOL_GPL(iscsi_destroy_endpoint);
251 struct iscsi_endpoint *iscsi_lookup_endpoint(u64 handle)
253 struct iscsi_endpoint *ep;
256 dev = class_find_device(&iscsi_endpoint_class, NULL, &handle,
261 ep = iscsi_dev_to_endpoint(dev);
263 * we can drop this now because the interface will prevent
264 * removals and lookups from racing.
269 EXPORT_SYMBOL_GPL(iscsi_lookup_endpoint);
272 * Interface to display network param to sysfs
275 static void iscsi_iface_release(struct device *dev)
277 struct iscsi_iface *iface = iscsi_dev_to_iface(dev);
278 struct device *parent = iface->dev.parent;
285 static struct class iscsi_iface_class = {
286 .name = "iscsi_iface",
287 .dev_release = iscsi_iface_release,
290 #define ISCSI_IFACE_ATTR(_prefix, _name, _mode, _show, _store) \
291 struct device_attribute dev_attr_##_prefix##_##_name = \
292 __ATTR(_name, _mode, _show, _store)
294 /* iface attrs show */
295 #define iscsi_iface_attr_show(type, name, param_type, param) \
297 show_##type##_##name(struct device *dev, struct device_attribute *attr, \
300 struct iscsi_iface *iface = iscsi_dev_to_iface(dev); \
301 struct iscsi_transport *t = iface->transport; \
302 return t->get_iface_param(iface, param_type, param, buf); \
305 #define iscsi_iface_net_attr(type, name, param) \
306 iscsi_iface_attr_show(type, name, ISCSI_NET_PARAM, param) \
307 static ISCSI_IFACE_ATTR(type, name, S_IRUGO, show_##type##_##name, NULL);
309 /* generic read only ipvi4 attribute */
310 iscsi_iface_net_attr(ipv4_iface, ipaddress, ISCSI_NET_PARAM_IPV4_ADDR);
311 iscsi_iface_net_attr(ipv4_iface, gateway, ISCSI_NET_PARAM_IPV4_GW);
312 iscsi_iface_net_attr(ipv4_iface, subnet, ISCSI_NET_PARAM_IPV4_SUBNET);
313 iscsi_iface_net_attr(ipv4_iface, bootproto, ISCSI_NET_PARAM_IPV4_BOOTPROTO);
315 /* generic read only ipv6 attribute */
316 iscsi_iface_net_attr(ipv6_iface, ipaddress, ISCSI_NET_PARAM_IPV6_ADDR);
317 iscsi_iface_net_attr(ipv6_iface, link_local_addr, ISCSI_NET_PARAM_IPV6_LINKLOCAL);
318 iscsi_iface_net_attr(ipv6_iface, router_addr, ISCSI_NET_PARAM_IPV6_ROUTER);
319 iscsi_iface_net_attr(ipv6_iface, ipaddr_autocfg,
320 ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG);
321 iscsi_iface_net_attr(ipv6_iface, link_local_autocfg,
322 ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG);
324 /* common read only iface attribute */
325 iscsi_iface_net_attr(iface, enabled, ISCSI_NET_PARAM_IFACE_ENABLE);
326 iscsi_iface_net_attr(iface, vlan_id, ISCSI_NET_PARAM_VLAN_ID);
327 iscsi_iface_net_attr(iface, vlan_priority, ISCSI_NET_PARAM_VLAN_PRIORITY);
328 iscsi_iface_net_attr(iface, vlan_enabled, ISCSI_NET_PARAM_VLAN_ENABLED);
329 iscsi_iface_net_attr(iface, mtu, ISCSI_NET_PARAM_MTU);
330 iscsi_iface_net_attr(iface, port, ISCSI_NET_PARAM_PORT);
332 static umode_t iscsi_iface_attr_is_visible(struct kobject *kobj,
333 struct attribute *attr, int i)
335 struct device *dev = container_of(kobj, struct device, kobj);
336 struct iscsi_iface *iface = iscsi_dev_to_iface(dev);
337 struct iscsi_transport *t = iface->transport;
340 if (attr == &dev_attr_iface_enabled.attr)
341 param = ISCSI_NET_PARAM_IFACE_ENABLE;
342 else if (attr == &dev_attr_iface_vlan_id.attr)
343 param = ISCSI_NET_PARAM_VLAN_ID;
344 else if (attr == &dev_attr_iface_vlan_priority.attr)
345 param = ISCSI_NET_PARAM_VLAN_PRIORITY;
346 else if (attr == &dev_attr_iface_vlan_enabled.attr)
347 param = ISCSI_NET_PARAM_VLAN_ENABLED;
348 else if (attr == &dev_attr_iface_mtu.attr)
349 param = ISCSI_NET_PARAM_MTU;
350 else if (attr == &dev_attr_iface_port.attr)
351 param = ISCSI_NET_PARAM_PORT;
352 else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
353 if (attr == &dev_attr_ipv4_iface_ipaddress.attr)
354 param = ISCSI_NET_PARAM_IPV4_ADDR;
355 else if (attr == &dev_attr_ipv4_iface_gateway.attr)
356 param = ISCSI_NET_PARAM_IPV4_GW;
357 else if (attr == &dev_attr_ipv4_iface_subnet.attr)
358 param = ISCSI_NET_PARAM_IPV4_SUBNET;
359 else if (attr == &dev_attr_ipv4_iface_bootproto.attr)
360 param = ISCSI_NET_PARAM_IPV4_BOOTPROTO;
363 } else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6) {
364 if (attr == &dev_attr_ipv6_iface_ipaddress.attr)
365 param = ISCSI_NET_PARAM_IPV6_ADDR;
366 else if (attr == &dev_attr_ipv6_iface_link_local_addr.attr)
367 param = ISCSI_NET_PARAM_IPV6_LINKLOCAL;
368 else if (attr == &dev_attr_ipv6_iface_router_addr.attr)
369 param = ISCSI_NET_PARAM_IPV6_ROUTER;
370 else if (attr == &dev_attr_ipv6_iface_ipaddr_autocfg.attr)
371 param = ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG;
372 else if (attr == &dev_attr_ipv6_iface_link_local_autocfg.attr)
373 param = ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG;
377 WARN_ONCE(1, "Invalid iface attr");
381 return t->attr_is_visible(ISCSI_NET_PARAM, param);
384 static struct attribute *iscsi_iface_attrs[] = {
385 &dev_attr_iface_enabled.attr,
386 &dev_attr_iface_vlan_id.attr,
387 &dev_attr_iface_vlan_priority.attr,
388 &dev_attr_iface_vlan_enabled.attr,
389 &dev_attr_ipv4_iface_ipaddress.attr,
390 &dev_attr_ipv4_iface_gateway.attr,
391 &dev_attr_ipv4_iface_subnet.attr,
392 &dev_attr_ipv4_iface_bootproto.attr,
393 &dev_attr_ipv6_iface_ipaddress.attr,
394 &dev_attr_ipv6_iface_link_local_addr.attr,
395 &dev_attr_ipv6_iface_router_addr.attr,
396 &dev_attr_ipv6_iface_ipaddr_autocfg.attr,
397 &dev_attr_ipv6_iface_link_local_autocfg.attr,
398 &dev_attr_iface_mtu.attr,
399 &dev_attr_iface_port.attr,
403 static struct attribute_group iscsi_iface_group = {
404 .attrs = iscsi_iface_attrs,
405 .is_visible = iscsi_iface_attr_is_visible,
409 iscsi_create_iface(struct Scsi_Host *shost, struct iscsi_transport *transport,
410 uint32_t iface_type, uint32_t iface_num, int dd_size)
412 struct iscsi_iface *iface;
415 iface = kzalloc(sizeof(*iface) + dd_size, GFP_KERNEL);
419 iface->transport = transport;
420 iface->iface_type = iface_type;
421 iface->iface_num = iface_num;
422 iface->dev.release = iscsi_iface_release;
423 iface->dev.class = &iscsi_iface_class;
424 /* parent reference released in iscsi_iface_release */
425 iface->dev.parent = get_device(&shost->shost_gendev);
426 if (iface_type == ISCSI_IFACE_TYPE_IPV4)
427 dev_set_name(&iface->dev, "ipv4-iface-%u-%u", shost->host_no,
430 dev_set_name(&iface->dev, "ipv6-iface-%u-%u", shost->host_no,
433 err = device_register(&iface->dev);
437 err = sysfs_create_group(&iface->dev.kobj, &iscsi_iface_group);
442 iface->dd_data = &iface[1];
446 device_unregister(&iface->dev);
450 put_device(iface->dev.parent);
454 EXPORT_SYMBOL_GPL(iscsi_create_iface);
456 void iscsi_destroy_iface(struct iscsi_iface *iface)
458 sysfs_remove_group(&iface->dev.kobj, &iscsi_iface_group);
459 device_unregister(&iface->dev);
461 EXPORT_SYMBOL_GPL(iscsi_destroy_iface);
464 * Interface to display flash node params to sysfs
467 #define ISCSI_FLASHNODE_ATTR(_prefix, _name, _mode, _show, _store) \
468 struct device_attribute dev_attr_##_prefix##_##_name = \
469 __ATTR(_name, _mode, _show, _store)
471 /* flash node session attrs show */
472 #define iscsi_flashnode_sess_attr_show(type, name, param) \
474 show_##type##_##name(struct device *dev, struct device_attribute *attr, \
477 struct iscsi_bus_flash_session *fnode_sess = \
478 iscsi_dev_to_flash_session(dev);\
479 struct iscsi_transport *t = fnode_sess->transport; \
480 return t->get_flashnode_param(fnode_sess, param, buf); \
484 #define iscsi_flashnode_sess_attr(type, name, param) \
485 iscsi_flashnode_sess_attr_show(type, name, param) \
486 static ISCSI_FLASHNODE_ATTR(type, name, S_IRUGO, \
487 show_##type##_##name, NULL);
489 /* Flash node session attributes */
491 iscsi_flashnode_sess_attr(fnode, auto_snd_tgt_disable,
492 ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE);
493 iscsi_flashnode_sess_attr(fnode, discovery_session,
494 ISCSI_FLASHNODE_DISCOVERY_SESS);
495 iscsi_flashnode_sess_attr(fnode, portal_type, ISCSI_FLASHNODE_PORTAL_TYPE);
496 iscsi_flashnode_sess_attr(fnode, entry_enable, ISCSI_FLASHNODE_ENTRY_EN);
497 iscsi_flashnode_sess_attr(fnode, immediate_data, ISCSI_FLASHNODE_IMM_DATA_EN);
498 iscsi_flashnode_sess_attr(fnode, initial_r2t, ISCSI_FLASHNODE_INITIAL_R2T_EN);
499 iscsi_flashnode_sess_attr(fnode, data_seq_in_order,
500 ISCSI_FLASHNODE_DATASEQ_INORDER);
501 iscsi_flashnode_sess_attr(fnode, data_pdu_in_order,
502 ISCSI_FLASHNODE_PDU_INORDER);
503 iscsi_flashnode_sess_attr(fnode, chap_auth, ISCSI_FLASHNODE_CHAP_AUTH_EN);
504 iscsi_flashnode_sess_attr(fnode, discovery_logout,
505 ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN);
506 iscsi_flashnode_sess_attr(fnode, bidi_chap, ISCSI_FLASHNODE_BIDI_CHAP_EN);
507 iscsi_flashnode_sess_attr(fnode, discovery_auth_optional,
508 ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL);
509 iscsi_flashnode_sess_attr(fnode, erl, ISCSI_FLASHNODE_ERL);
510 iscsi_flashnode_sess_attr(fnode, first_burst_len, ISCSI_FLASHNODE_FIRST_BURST);
511 iscsi_flashnode_sess_attr(fnode, def_time2wait, ISCSI_FLASHNODE_DEF_TIME2WAIT);
512 iscsi_flashnode_sess_attr(fnode, def_time2retain,
513 ISCSI_FLASHNODE_DEF_TIME2RETAIN);
514 iscsi_flashnode_sess_attr(fnode, max_outstanding_r2t, ISCSI_FLASHNODE_MAX_R2T);
515 iscsi_flashnode_sess_attr(fnode, isid, ISCSI_FLASHNODE_ISID);
516 iscsi_flashnode_sess_attr(fnode, tsid, ISCSI_FLASHNODE_TSID);
517 iscsi_flashnode_sess_attr(fnode, max_burst_len, ISCSI_FLASHNODE_MAX_BURST);
518 iscsi_flashnode_sess_attr(fnode, def_taskmgmt_tmo,
519 ISCSI_FLASHNODE_DEF_TASKMGMT_TMO);
520 iscsi_flashnode_sess_attr(fnode, targetalias, ISCSI_FLASHNODE_ALIAS);
521 iscsi_flashnode_sess_attr(fnode, targetname, ISCSI_FLASHNODE_NAME);
522 iscsi_flashnode_sess_attr(fnode, tpgt, ISCSI_FLASHNODE_TPGT);
523 iscsi_flashnode_sess_attr(fnode, discovery_parent_idx,
524 ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX);
525 iscsi_flashnode_sess_attr(fnode, discovery_parent_type,
526 ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE);
527 iscsi_flashnode_sess_attr(fnode, chap_in_idx, ISCSI_FLASHNODE_CHAP_IN_IDX);
528 iscsi_flashnode_sess_attr(fnode, chap_out_idx, ISCSI_FLASHNODE_CHAP_OUT_IDX);
529 iscsi_flashnode_sess_attr(fnode, username, ISCSI_FLASHNODE_USERNAME);
530 iscsi_flashnode_sess_attr(fnode, username_in, ISCSI_FLASHNODE_USERNAME_IN);
531 iscsi_flashnode_sess_attr(fnode, password, ISCSI_FLASHNODE_PASSWORD);
532 iscsi_flashnode_sess_attr(fnode, password_in, ISCSI_FLASHNODE_PASSWORD_IN);
533 iscsi_flashnode_sess_attr(fnode, is_boot_target, ISCSI_FLASHNODE_IS_BOOT_TGT);
535 static struct attribute *iscsi_flashnode_sess_attrs[] = {
536 &dev_attr_fnode_auto_snd_tgt_disable.attr,
537 &dev_attr_fnode_discovery_session.attr,
538 &dev_attr_fnode_portal_type.attr,
539 &dev_attr_fnode_entry_enable.attr,
540 &dev_attr_fnode_immediate_data.attr,
541 &dev_attr_fnode_initial_r2t.attr,
542 &dev_attr_fnode_data_seq_in_order.attr,
543 &dev_attr_fnode_data_pdu_in_order.attr,
544 &dev_attr_fnode_chap_auth.attr,
545 &dev_attr_fnode_discovery_logout.attr,
546 &dev_attr_fnode_bidi_chap.attr,
547 &dev_attr_fnode_discovery_auth_optional.attr,
548 &dev_attr_fnode_erl.attr,
549 &dev_attr_fnode_first_burst_len.attr,
550 &dev_attr_fnode_def_time2wait.attr,
551 &dev_attr_fnode_def_time2retain.attr,
552 &dev_attr_fnode_max_outstanding_r2t.attr,
553 &dev_attr_fnode_isid.attr,
554 &dev_attr_fnode_tsid.attr,
555 &dev_attr_fnode_max_burst_len.attr,
556 &dev_attr_fnode_def_taskmgmt_tmo.attr,
557 &dev_attr_fnode_targetalias.attr,
558 &dev_attr_fnode_targetname.attr,
559 &dev_attr_fnode_tpgt.attr,
560 &dev_attr_fnode_discovery_parent_idx.attr,
561 &dev_attr_fnode_discovery_parent_type.attr,
562 &dev_attr_fnode_chap_in_idx.attr,
563 &dev_attr_fnode_chap_out_idx.attr,
564 &dev_attr_fnode_username.attr,
565 &dev_attr_fnode_username_in.attr,
566 &dev_attr_fnode_password.attr,
567 &dev_attr_fnode_password_in.attr,
568 &dev_attr_fnode_is_boot_target.attr,
572 static umode_t iscsi_flashnode_sess_attr_is_visible(struct kobject *kobj,
573 struct attribute *attr,
576 struct device *dev = container_of(kobj, struct device, kobj);
577 struct iscsi_bus_flash_session *fnode_sess =
578 iscsi_dev_to_flash_session(dev);
579 struct iscsi_transport *t = fnode_sess->transport;
582 if (attr == &dev_attr_fnode_auto_snd_tgt_disable.attr) {
583 param = ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE;
584 } else if (attr == &dev_attr_fnode_discovery_session.attr) {
585 param = ISCSI_FLASHNODE_DISCOVERY_SESS;
586 } else if (attr == &dev_attr_fnode_portal_type.attr) {
587 param = ISCSI_FLASHNODE_PORTAL_TYPE;
588 } else if (attr == &dev_attr_fnode_entry_enable.attr) {
589 param = ISCSI_FLASHNODE_ENTRY_EN;
590 } else if (attr == &dev_attr_fnode_immediate_data.attr) {
591 param = ISCSI_FLASHNODE_IMM_DATA_EN;
592 } else if (attr == &dev_attr_fnode_initial_r2t.attr) {
593 param = ISCSI_FLASHNODE_INITIAL_R2T_EN;
594 } else if (attr == &dev_attr_fnode_data_seq_in_order.attr) {
595 param = ISCSI_FLASHNODE_DATASEQ_INORDER;
596 } else if (attr == &dev_attr_fnode_data_pdu_in_order.attr) {
597 param = ISCSI_FLASHNODE_PDU_INORDER;
598 } else if (attr == &dev_attr_fnode_chap_auth.attr) {
599 param = ISCSI_FLASHNODE_CHAP_AUTH_EN;
600 } else if (attr == &dev_attr_fnode_discovery_logout.attr) {
601 param = ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN;
602 } else if (attr == &dev_attr_fnode_bidi_chap.attr) {
603 param = ISCSI_FLASHNODE_BIDI_CHAP_EN;
604 } else if (attr == &dev_attr_fnode_discovery_auth_optional.attr) {
605 param = ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL;
606 } else if (attr == &dev_attr_fnode_erl.attr) {
607 param = ISCSI_FLASHNODE_ERL;
608 } else if (attr == &dev_attr_fnode_first_burst_len.attr) {
609 param = ISCSI_FLASHNODE_FIRST_BURST;
610 } else if (attr == &dev_attr_fnode_def_time2wait.attr) {
611 param = ISCSI_FLASHNODE_DEF_TIME2WAIT;
612 } else if (attr == &dev_attr_fnode_def_time2retain.attr) {
613 param = ISCSI_FLASHNODE_DEF_TIME2RETAIN;
614 } else if (attr == &dev_attr_fnode_max_outstanding_r2t.attr) {
615 param = ISCSI_FLASHNODE_MAX_R2T;
616 } else if (attr == &dev_attr_fnode_isid.attr) {
617 param = ISCSI_FLASHNODE_ISID;
618 } else if (attr == &dev_attr_fnode_tsid.attr) {
619 param = ISCSI_FLASHNODE_TSID;
620 } else if (attr == &dev_attr_fnode_max_burst_len.attr) {
621 param = ISCSI_FLASHNODE_MAX_BURST;
622 } else if (attr == &dev_attr_fnode_def_taskmgmt_tmo.attr) {
623 param = ISCSI_FLASHNODE_DEF_TASKMGMT_TMO;
624 } else if (attr == &dev_attr_fnode_targetalias.attr) {
625 param = ISCSI_FLASHNODE_ALIAS;
626 } else if (attr == &dev_attr_fnode_targetname.attr) {
627 param = ISCSI_FLASHNODE_NAME;
628 } else if (attr == &dev_attr_fnode_tpgt.attr) {
629 param = ISCSI_FLASHNODE_TPGT;
630 } else if (attr == &dev_attr_fnode_discovery_parent_idx.attr) {
631 param = ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX;
632 } else if (attr == &dev_attr_fnode_discovery_parent_type.attr) {
633 param = ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE;
634 } else if (attr == &dev_attr_fnode_chap_in_idx.attr) {
635 param = ISCSI_FLASHNODE_CHAP_IN_IDX;
636 } else if (attr == &dev_attr_fnode_chap_out_idx.attr) {
637 param = ISCSI_FLASHNODE_CHAP_OUT_IDX;
638 } else if (attr == &dev_attr_fnode_username.attr) {
639 param = ISCSI_FLASHNODE_USERNAME;
640 } else if (attr == &dev_attr_fnode_username_in.attr) {
641 param = ISCSI_FLASHNODE_USERNAME_IN;
642 } else if (attr == &dev_attr_fnode_password.attr) {
643 param = ISCSI_FLASHNODE_PASSWORD;
644 } else if (attr == &dev_attr_fnode_password_in.attr) {
645 param = ISCSI_FLASHNODE_PASSWORD_IN;
646 } else if (attr == &dev_attr_fnode_is_boot_target.attr) {
647 param = ISCSI_FLASHNODE_IS_BOOT_TGT;
649 WARN_ONCE(1, "Invalid flashnode session attr");
653 return t->attr_is_visible(ISCSI_FLASHNODE_PARAM, param);
656 static struct attribute_group iscsi_flashnode_sess_attr_group = {
657 .attrs = iscsi_flashnode_sess_attrs,
658 .is_visible = iscsi_flashnode_sess_attr_is_visible,
661 static const struct attribute_group *iscsi_flashnode_sess_attr_groups[] = {
662 &iscsi_flashnode_sess_attr_group,
666 static void iscsi_flashnode_sess_release(struct device *dev)
668 struct iscsi_bus_flash_session *fnode_sess =
669 iscsi_dev_to_flash_session(dev);
671 kfree(fnode_sess->targetname);
672 kfree(fnode_sess->targetalias);
673 kfree(fnode_sess->portal_type);
677 struct device_type iscsi_flashnode_sess_dev_type = {
678 .name = "iscsi_flashnode_sess_dev_type",
679 .groups = iscsi_flashnode_sess_attr_groups,
680 .release = iscsi_flashnode_sess_release,
683 /* flash node connection attrs show */
684 #define iscsi_flashnode_conn_attr_show(type, name, param) \
686 show_##type##_##name(struct device *dev, struct device_attribute *attr, \
689 struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev);\
690 struct iscsi_bus_flash_session *fnode_sess = \
691 iscsi_flash_conn_to_flash_session(fnode_conn);\
692 struct iscsi_transport *t = fnode_conn->transport; \
693 return t->get_flashnode_param(fnode_sess, param, buf); \
697 #define iscsi_flashnode_conn_attr(type, name, param) \
698 iscsi_flashnode_conn_attr_show(type, name, param) \
699 static ISCSI_FLASHNODE_ATTR(type, name, S_IRUGO, \
700 show_##type##_##name, NULL);
702 /* Flash node connection attributes */
704 iscsi_flashnode_conn_attr(fnode, is_fw_assigned_ipv6,
705 ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6);
706 iscsi_flashnode_conn_attr(fnode, header_digest, ISCSI_FLASHNODE_HDR_DGST_EN);
707 iscsi_flashnode_conn_attr(fnode, data_digest, ISCSI_FLASHNODE_DATA_DGST_EN);
708 iscsi_flashnode_conn_attr(fnode, snack_req, ISCSI_FLASHNODE_SNACK_REQ_EN);
709 iscsi_flashnode_conn_attr(fnode, tcp_timestamp_stat,
710 ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT);
711 iscsi_flashnode_conn_attr(fnode, tcp_nagle_disable,
712 ISCSI_FLASHNODE_TCP_NAGLE_DISABLE);
713 iscsi_flashnode_conn_attr(fnode, tcp_wsf_disable,
714 ISCSI_FLASHNODE_TCP_WSF_DISABLE);
715 iscsi_flashnode_conn_attr(fnode, tcp_timer_scale,
716 ISCSI_FLASHNODE_TCP_TIMER_SCALE);
717 iscsi_flashnode_conn_attr(fnode, tcp_timestamp_enable,
718 ISCSI_FLASHNODE_TCP_TIMESTAMP_EN);
719 iscsi_flashnode_conn_attr(fnode, fragment_disable,
720 ISCSI_FLASHNODE_IP_FRAG_DISABLE);
721 iscsi_flashnode_conn_attr(fnode, keepalive_tmo, ISCSI_FLASHNODE_KEEPALIVE_TMO);
722 iscsi_flashnode_conn_attr(fnode, port, ISCSI_FLASHNODE_PORT);
723 iscsi_flashnode_conn_attr(fnode, ipaddress, ISCSI_FLASHNODE_IPADDR);
724 iscsi_flashnode_conn_attr(fnode, max_recv_dlength,
725 ISCSI_FLASHNODE_MAX_RECV_DLENGTH);
726 iscsi_flashnode_conn_attr(fnode, max_xmit_dlength,
727 ISCSI_FLASHNODE_MAX_XMIT_DLENGTH);
728 iscsi_flashnode_conn_attr(fnode, local_port, ISCSI_FLASHNODE_LOCAL_PORT);
729 iscsi_flashnode_conn_attr(fnode, ipv4_tos, ISCSI_FLASHNODE_IPV4_TOS);
730 iscsi_flashnode_conn_attr(fnode, ipv6_traffic_class, ISCSI_FLASHNODE_IPV6_TC);
731 iscsi_flashnode_conn_attr(fnode, ipv6_flow_label,
732 ISCSI_FLASHNODE_IPV6_FLOW_LABEL);
733 iscsi_flashnode_conn_attr(fnode, redirect_ipaddr,
734 ISCSI_FLASHNODE_REDIRECT_IPADDR);
735 iscsi_flashnode_conn_attr(fnode, max_segment_size,
736 ISCSI_FLASHNODE_MAX_SEGMENT_SIZE);
737 iscsi_flashnode_conn_attr(fnode, link_local_ipv6,
738 ISCSI_FLASHNODE_LINK_LOCAL_IPV6);
739 iscsi_flashnode_conn_attr(fnode, tcp_xmit_wsf, ISCSI_FLASHNODE_TCP_XMIT_WSF);
740 iscsi_flashnode_conn_attr(fnode, tcp_recv_wsf, ISCSI_FLASHNODE_TCP_RECV_WSF);
741 iscsi_flashnode_conn_attr(fnode, statsn, ISCSI_FLASHNODE_STATSN);
742 iscsi_flashnode_conn_attr(fnode, exp_statsn, ISCSI_FLASHNODE_EXP_STATSN);
744 static struct attribute *iscsi_flashnode_conn_attrs[] = {
745 &dev_attr_fnode_is_fw_assigned_ipv6.attr,
746 &dev_attr_fnode_header_digest.attr,
747 &dev_attr_fnode_data_digest.attr,
748 &dev_attr_fnode_snack_req.attr,
749 &dev_attr_fnode_tcp_timestamp_stat.attr,
750 &dev_attr_fnode_tcp_nagle_disable.attr,
751 &dev_attr_fnode_tcp_wsf_disable.attr,
752 &dev_attr_fnode_tcp_timer_scale.attr,
753 &dev_attr_fnode_tcp_timestamp_enable.attr,
754 &dev_attr_fnode_fragment_disable.attr,
755 &dev_attr_fnode_max_recv_dlength.attr,
756 &dev_attr_fnode_max_xmit_dlength.attr,
757 &dev_attr_fnode_keepalive_tmo.attr,
758 &dev_attr_fnode_port.attr,
759 &dev_attr_fnode_ipaddress.attr,
760 &dev_attr_fnode_redirect_ipaddr.attr,
761 &dev_attr_fnode_max_segment_size.attr,
762 &dev_attr_fnode_local_port.attr,
763 &dev_attr_fnode_ipv4_tos.attr,
764 &dev_attr_fnode_ipv6_traffic_class.attr,
765 &dev_attr_fnode_ipv6_flow_label.attr,
766 &dev_attr_fnode_link_local_ipv6.attr,
767 &dev_attr_fnode_tcp_xmit_wsf.attr,
768 &dev_attr_fnode_tcp_recv_wsf.attr,
769 &dev_attr_fnode_statsn.attr,
770 &dev_attr_fnode_exp_statsn.attr,
774 static umode_t iscsi_flashnode_conn_attr_is_visible(struct kobject *kobj,
775 struct attribute *attr,
778 struct device *dev = container_of(kobj, struct device, kobj);
779 struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev);
780 struct iscsi_transport *t = fnode_conn->transport;
783 if (attr == &dev_attr_fnode_is_fw_assigned_ipv6.attr) {
784 param = ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6;
785 } else if (attr == &dev_attr_fnode_header_digest.attr) {
786 param = ISCSI_FLASHNODE_HDR_DGST_EN;
787 } else if (attr == &dev_attr_fnode_data_digest.attr) {
788 param = ISCSI_FLASHNODE_DATA_DGST_EN;
789 } else if (attr == &dev_attr_fnode_snack_req.attr) {
790 param = ISCSI_FLASHNODE_SNACK_REQ_EN;
791 } else if (attr == &dev_attr_fnode_tcp_timestamp_stat.attr) {
792 param = ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT;
793 } else if (attr == &dev_attr_fnode_tcp_nagle_disable.attr) {
794 param = ISCSI_FLASHNODE_TCP_NAGLE_DISABLE;
795 } else if (attr == &dev_attr_fnode_tcp_wsf_disable.attr) {
796 param = ISCSI_FLASHNODE_TCP_WSF_DISABLE;
797 } else if (attr == &dev_attr_fnode_tcp_timer_scale.attr) {
798 param = ISCSI_FLASHNODE_TCP_TIMER_SCALE;
799 } else if (attr == &dev_attr_fnode_tcp_timestamp_enable.attr) {
800 param = ISCSI_FLASHNODE_TCP_TIMESTAMP_EN;
801 } else if (attr == &dev_attr_fnode_fragment_disable.attr) {
802 param = ISCSI_FLASHNODE_IP_FRAG_DISABLE;
803 } else if (attr == &dev_attr_fnode_max_recv_dlength.attr) {
804 param = ISCSI_FLASHNODE_MAX_RECV_DLENGTH;
805 } else if (attr == &dev_attr_fnode_max_xmit_dlength.attr) {
806 param = ISCSI_FLASHNODE_MAX_XMIT_DLENGTH;
807 } else if (attr == &dev_attr_fnode_keepalive_tmo.attr) {
808 param = ISCSI_FLASHNODE_KEEPALIVE_TMO;
809 } else if (attr == &dev_attr_fnode_port.attr) {
810 param = ISCSI_FLASHNODE_PORT;
811 } else if (attr == &dev_attr_fnode_ipaddress.attr) {
812 param = ISCSI_FLASHNODE_IPADDR;
813 } else if (attr == &dev_attr_fnode_redirect_ipaddr.attr) {
814 param = ISCSI_FLASHNODE_REDIRECT_IPADDR;
815 } else if (attr == &dev_attr_fnode_max_segment_size.attr) {
816 param = ISCSI_FLASHNODE_MAX_SEGMENT_SIZE;
817 } else if (attr == &dev_attr_fnode_local_port.attr) {
818 param = ISCSI_FLASHNODE_LOCAL_PORT;
819 } else if (attr == &dev_attr_fnode_ipv4_tos.attr) {
820 param = ISCSI_FLASHNODE_IPV4_TOS;
821 } else if (attr == &dev_attr_fnode_ipv6_traffic_class.attr) {
822 param = ISCSI_FLASHNODE_IPV6_TC;
823 } else if (attr == &dev_attr_fnode_ipv6_flow_label.attr) {
824 param = ISCSI_FLASHNODE_IPV6_FLOW_LABEL;
825 } else if (attr == &dev_attr_fnode_link_local_ipv6.attr) {
826 param = ISCSI_FLASHNODE_LINK_LOCAL_IPV6;
827 } else if (attr == &dev_attr_fnode_tcp_xmit_wsf.attr) {
828 param = ISCSI_FLASHNODE_TCP_XMIT_WSF;
829 } else if (attr == &dev_attr_fnode_tcp_recv_wsf.attr) {
830 param = ISCSI_FLASHNODE_TCP_RECV_WSF;
831 } else if (attr == &dev_attr_fnode_statsn.attr) {
832 param = ISCSI_FLASHNODE_STATSN;
833 } else if (attr == &dev_attr_fnode_exp_statsn.attr) {
834 param = ISCSI_FLASHNODE_EXP_STATSN;
836 WARN_ONCE(1, "Invalid flashnode connection attr");
840 return t->attr_is_visible(ISCSI_FLASHNODE_PARAM, param);
843 static struct attribute_group iscsi_flashnode_conn_attr_group = {
844 .attrs = iscsi_flashnode_conn_attrs,
845 .is_visible = iscsi_flashnode_conn_attr_is_visible,
848 static const struct attribute_group *iscsi_flashnode_conn_attr_groups[] = {
849 &iscsi_flashnode_conn_attr_group,
853 static void iscsi_flashnode_conn_release(struct device *dev)
855 struct iscsi_bus_flash_conn *fnode_conn = iscsi_dev_to_flash_conn(dev);
857 kfree(fnode_conn->ipaddress);
858 kfree(fnode_conn->redirect_ipaddr);
859 kfree(fnode_conn->link_local_ipv6_addr);
863 struct device_type iscsi_flashnode_conn_dev_type = {
864 .name = "iscsi_flashnode_conn_dev_type",
865 .groups = iscsi_flashnode_conn_attr_groups,
866 .release = iscsi_flashnode_conn_release,
869 struct bus_type iscsi_flashnode_bus;
871 int iscsi_flashnode_bus_match(struct device *dev,
872 struct device_driver *drv)
874 if (dev->bus == &iscsi_flashnode_bus)
878 EXPORT_SYMBOL_GPL(iscsi_flashnode_bus_match);
880 struct bus_type iscsi_flashnode_bus = {
881 .name = "iscsi_flashnode",
882 .match = &iscsi_flashnode_bus_match,
886 * iscsi_create_flashnode_sess - Add flashnode session entry in sysfs
887 * @shost: pointer to host data
888 * @index: index of flashnode to add in sysfs
889 * @transport: pointer to transport data
890 * @dd_size: total size to allocate
892 * Adds a sysfs entry for the flashnode session attributes
895 * pointer to allocated flashnode sess on sucess
898 struct iscsi_bus_flash_session *
899 iscsi_create_flashnode_sess(struct Scsi_Host *shost, int index,
900 struct iscsi_transport *transport,
903 struct iscsi_bus_flash_session *fnode_sess;
906 fnode_sess = kzalloc(sizeof(*fnode_sess) + dd_size, GFP_KERNEL);
910 fnode_sess->transport = transport;
911 fnode_sess->target_id = index;
912 fnode_sess->dev.type = &iscsi_flashnode_sess_dev_type;
913 fnode_sess->dev.bus = &iscsi_flashnode_bus;
914 fnode_sess->dev.parent = &shost->shost_gendev;
915 dev_set_name(&fnode_sess->dev, "flashnode_sess-%u:%u",
916 shost->host_no, index);
918 err = device_register(&fnode_sess->dev);
920 goto free_fnode_sess;
923 fnode_sess->dd_data = &fnode_sess[1];
931 EXPORT_SYMBOL_GPL(iscsi_create_flashnode_sess);
934 * iscsi_create_flashnode_conn - Add flashnode conn entry in sysfs
935 * @shost: pointer to host data
936 * @fnode_sess: pointer to the parent flashnode session entry
937 * @transport: pointer to transport data
938 * @dd_size: total size to allocate
940 * Adds a sysfs entry for the flashnode connection attributes
943 * pointer to allocated flashnode conn on success
946 struct iscsi_bus_flash_conn *
947 iscsi_create_flashnode_conn(struct Scsi_Host *shost,
948 struct iscsi_bus_flash_session *fnode_sess,
949 struct iscsi_transport *transport,
952 struct iscsi_bus_flash_conn *fnode_conn;
955 fnode_conn = kzalloc(sizeof(*fnode_conn) + dd_size, GFP_KERNEL);
959 fnode_conn->transport = transport;
960 fnode_conn->dev.type = &iscsi_flashnode_conn_dev_type;
961 fnode_conn->dev.bus = &iscsi_flashnode_bus;
962 fnode_conn->dev.parent = &fnode_sess->dev;
963 dev_set_name(&fnode_conn->dev, "flashnode_conn-%u:%u:0",
964 shost->host_no, fnode_sess->target_id);
966 err = device_register(&fnode_conn->dev);
968 goto free_fnode_conn;
971 fnode_conn->dd_data = &fnode_conn[1];
979 EXPORT_SYMBOL_GPL(iscsi_create_flashnode_conn);
982 * iscsi_is_flashnode_conn_dev - verify passed device is to be flashnode conn
983 * @dev: device to verify
984 * @data: pointer to data containing value to use for verification
986 * Verifies if the passed device is flashnode conn device
992 int iscsi_is_flashnode_conn_dev(struct device *dev, void *data)
994 return dev->bus == &iscsi_flashnode_bus;
996 EXPORT_SYMBOL_GPL(iscsi_is_flashnode_conn_dev);
998 static int iscsi_destroy_flashnode_conn(struct iscsi_bus_flash_conn *fnode_conn)
1000 device_unregister(&fnode_conn->dev);
1004 static int flashnode_match_index(struct device *dev, void *data)
1006 struct iscsi_bus_flash_session *fnode_sess = NULL;
1009 if (!iscsi_flashnode_bus_match(dev, NULL))
1010 goto exit_match_index;
1012 fnode_sess = iscsi_dev_to_flash_session(dev);
1013 ret = (fnode_sess->target_id == *((int *)data)) ? 1 : 0;
1020 * iscsi_get_flashnode_by_index -finds flashnode session entry by index
1021 * @shost: pointer to host data
1022 * @data: pointer to data containing value to use for comparison
1023 * @fn: function pointer that does actual comparison
1025 * Finds the flashnode session object for the passed index
1028 * pointer to found flashnode session object on success
1031 static struct iscsi_bus_flash_session *
1032 iscsi_get_flashnode_by_index(struct Scsi_Host *shost, void *data,
1033 int (*fn)(struct device *dev, void *data))
1035 struct iscsi_bus_flash_session *fnode_sess = NULL;
1038 dev = device_find_child(&shost->shost_gendev, data, fn);
1040 fnode_sess = iscsi_dev_to_flash_session(dev);
1046 * iscsi_find_flashnode_sess - finds flashnode session entry
1047 * @shost: pointer to host data
1048 * @data: pointer to data containing value to use for comparison
1049 * @fn: function pointer that does actual comparison
1051 * Finds the flashnode session object comparing the data passed using logic
1052 * defined in passed function pointer
1055 * pointer to found flashnode session device object on success
1059 iscsi_find_flashnode_sess(struct Scsi_Host *shost, void *data,
1060 int (*fn)(struct device *dev, void *data))
1064 dev = device_find_child(&shost->shost_gendev, data, fn);
1067 EXPORT_SYMBOL_GPL(iscsi_find_flashnode_sess);
1070 * iscsi_find_flashnode_conn - finds flashnode connection entry
1071 * @fnode_sess: pointer to parent flashnode session entry
1072 * @data: pointer to data containing value to use for comparison
1073 * @fn: function pointer that does actual comparison
1075 * Finds the flashnode connection object comparing the data passed using logic
1076 * defined in passed function pointer
1079 * pointer to found flashnode connection device object on success
1083 iscsi_find_flashnode_conn(struct iscsi_bus_flash_session *fnode_sess,
1085 int (*fn)(struct device *dev, void *data))
1089 dev = device_find_child(&fnode_sess->dev, data, fn);
1092 EXPORT_SYMBOL_GPL(iscsi_find_flashnode_conn);
1094 static int iscsi_iter_destroy_flashnode_conn_fn(struct device *dev, void *data)
1096 if (!iscsi_is_flashnode_conn_dev(dev, NULL))
1099 return iscsi_destroy_flashnode_conn(iscsi_dev_to_flash_conn(dev));
1103 * iscsi_destroy_flashnode_sess - destory flashnode session entry
1104 * @fnode_sess: pointer to flashnode session entry to be destroyed
1106 * Deletes the flashnode session entry and all children flashnode connection
1107 * entries from sysfs
1109 void iscsi_destroy_flashnode_sess(struct iscsi_bus_flash_session *fnode_sess)
1113 err = device_for_each_child(&fnode_sess->dev, NULL,
1114 iscsi_iter_destroy_flashnode_conn_fn);
1116 pr_err("Could not delete all connections for %s. Error %d.\n",
1117 fnode_sess->dev.kobj.name, err);
1119 device_unregister(&fnode_sess->dev);
1121 EXPORT_SYMBOL_GPL(iscsi_destroy_flashnode_sess);
1123 static int iscsi_iter_destroy_flashnode_fn(struct device *dev, void *data)
1125 if (!iscsi_flashnode_bus_match(dev, NULL))
1128 iscsi_destroy_flashnode_sess(iscsi_dev_to_flash_session(dev));
1133 * iscsi_destroy_all_flashnode - destory all flashnode session entries
1134 * @shost: pointer to host data
1136 * Destroys all the flashnode session entries and all corresponding children
1137 * flashnode connection entries from sysfs
1139 void iscsi_destroy_all_flashnode(struct Scsi_Host *shost)
1141 device_for_each_child(&shost->shost_gendev, NULL,
1142 iscsi_iter_destroy_flashnode_fn);
1144 EXPORT_SYMBOL_GPL(iscsi_destroy_all_flashnode);
1150 * iscsi_bsg_host_dispatch - Dispatch command to LLD.
1151 * @job: bsg job to be processed
1153 static int iscsi_bsg_host_dispatch(struct bsg_job *job)
1155 struct Scsi_Host *shost = iscsi_job_to_shost(job);
1156 struct iscsi_bsg_request *req = job->request;
1157 struct iscsi_bsg_reply *reply = job->reply;
1158 struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
1159 int cmdlen = sizeof(uint32_t); /* start with length of msgcode */
1162 /* check if we have the msgcode value at least */
1163 if (job->request_len < sizeof(uint32_t)) {
1168 /* Validate the host command */
1169 switch (req->msgcode) {
1170 case ISCSI_BSG_HST_VENDOR:
1171 cmdlen += sizeof(struct iscsi_bsg_host_vendor);
1172 if ((shost->hostt->vendor_id == 0L) ||
1173 (req->rqst_data.h_vendor.vendor_id !=
1174 shost->hostt->vendor_id)) {
1184 /* check if we really have all the request data needed */
1185 if (job->request_len < cmdlen) {
1190 ret = i->iscsi_transport->bsg_request(job);
1195 /* return the errno failure code as the only status */
1196 BUG_ON(job->reply_len < sizeof(uint32_t));
1197 reply->reply_payload_rcv_len = 0;
1198 reply->result = ret;
1199 job->reply_len = sizeof(uint32_t);
1200 bsg_job_done(job, ret, 0);
1205 * iscsi_bsg_host_add - Create and add the bsg hooks to receive requests
1206 * @shost: shost for iscsi_host
1207 * @ihost: iscsi_cls_host adding the structures to
1210 iscsi_bsg_host_add(struct Scsi_Host *shost, struct iscsi_cls_host *ihost)
1212 struct device *dev = &shost->shost_gendev;
1213 struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
1214 struct request_queue *q;
1218 if (!i->iscsi_transport->bsg_request)
1221 snprintf(bsg_name, sizeof(bsg_name), "iscsi_host%d", shost->host_no);
1223 q = __scsi_alloc_queue(shost, bsg_request_fn);
1227 ret = bsg_setup_queue(dev, q, bsg_name, iscsi_bsg_host_dispatch, 0);
1229 shost_printk(KERN_ERR, shost, "bsg interface failed to "
1230 "initialize - no request queue\n");
1231 blk_cleanup_queue(q);
1239 static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
1240 struct device *cdev)
1242 struct Scsi_Host *shost = dev_to_shost(dev);
1243 struct iscsi_cls_host *ihost = shost->shost_data;
1245 memset(ihost, 0, sizeof(*ihost));
1246 atomic_set(&ihost->nr_scans, 0);
1247 mutex_init(&ihost->mutex);
1249 iscsi_bsg_host_add(shost, ihost);
1250 /* ignore any bsg add error - we just can't do sgio */
1255 static int iscsi_remove_host(struct transport_container *tc,
1256 struct device *dev, struct device *cdev)
1258 struct Scsi_Host *shost = dev_to_shost(dev);
1259 struct iscsi_cls_host *ihost = shost->shost_data;
1262 bsg_unregister_queue(ihost->bsg_q);
1263 blk_cleanup_queue(ihost->bsg_q);
1268 static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
1274 static DECLARE_TRANSPORT_CLASS(iscsi_session_class,
1280 static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
1286 static struct sock *nls;
1287 static DEFINE_MUTEX(rx_queue_mutex);
1289 static LIST_HEAD(sesslist);
1290 static DEFINE_SPINLOCK(sesslock);
1291 static LIST_HEAD(connlist);
1292 static DEFINE_SPINLOCK(connlock);
1294 static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn *conn)
1296 struct iscsi_cls_session *sess = iscsi_dev_to_session(conn->dev.parent);
1301 * Returns the matching session to a given sid
1303 static struct iscsi_cls_session *iscsi_session_lookup(uint32_t sid)
1305 unsigned long flags;
1306 struct iscsi_cls_session *sess;
1308 spin_lock_irqsave(&sesslock, flags);
1309 list_for_each_entry(sess, &sesslist, sess_list) {
1310 if (sess->sid == sid) {
1311 spin_unlock_irqrestore(&sesslock, flags);
1315 spin_unlock_irqrestore(&sesslock, flags);
1320 * Returns the matching connection to a given sid / cid tuple
1322 static struct iscsi_cls_conn *iscsi_conn_lookup(uint32_t sid, uint32_t cid)
1324 unsigned long flags;
1325 struct iscsi_cls_conn *conn;
1327 spin_lock_irqsave(&connlock, flags);
1328 list_for_each_entry(conn, &connlist, conn_list) {
1329 if ((conn->cid == cid) && (iscsi_conn_get_sid(conn) == sid)) {
1330 spin_unlock_irqrestore(&connlock, flags);
1334 spin_unlock_irqrestore(&connlock, flags);
1339 * The following functions can be used by LLDs that allocate
1340 * their own scsi_hosts or by software iscsi LLDs
1345 } iscsi_session_state_names[] = {
1346 { ISCSI_SESSION_LOGGED_IN, "LOGGED_IN" },
1347 { ISCSI_SESSION_FAILED, "FAILED" },
1348 { ISCSI_SESSION_FREE, "FREE" },
1351 static const char *iscsi_session_state_name(int state)
1356 for (i = 0; i < ARRAY_SIZE(iscsi_session_state_names); i++) {
1357 if (iscsi_session_state_names[i].value == state) {
1358 name = iscsi_session_state_names[i].name;
1365 int iscsi_session_chkready(struct iscsi_cls_session *session)
1367 unsigned long flags;
1370 spin_lock_irqsave(&session->lock, flags);
1371 switch (session->state) {
1372 case ISCSI_SESSION_LOGGED_IN:
1375 case ISCSI_SESSION_FAILED:
1376 err = DID_IMM_RETRY << 16;
1378 case ISCSI_SESSION_FREE:
1379 err = DID_TRANSPORT_FAILFAST << 16;
1382 err = DID_NO_CONNECT << 16;
1385 spin_unlock_irqrestore(&session->lock, flags);
1388 EXPORT_SYMBOL_GPL(iscsi_session_chkready);
1390 int iscsi_is_session_online(struct iscsi_cls_session *session)
1392 unsigned long flags;
1395 spin_lock_irqsave(&session->lock, flags);
1396 if (session->state == ISCSI_SESSION_LOGGED_IN)
1398 spin_unlock_irqrestore(&session->lock, flags);
1401 EXPORT_SYMBOL_GPL(iscsi_is_session_online);
1403 static void iscsi_session_release(struct device *dev)
1405 struct iscsi_cls_session *session = iscsi_dev_to_session(dev);
1406 struct Scsi_Host *shost;
1408 shost = iscsi_session_to_shost(session);
1409 scsi_host_put(shost);
1410 ISCSI_DBG_TRANS_SESSION(session, "Completing session release\n");
1414 int iscsi_is_session_dev(const struct device *dev)
1416 return dev->release == iscsi_session_release;
1418 EXPORT_SYMBOL_GPL(iscsi_is_session_dev);
1420 static int iscsi_iter_session_fn(struct device *dev, void *data)
1422 void (* fn) (struct iscsi_cls_session *) = data;
1424 if (!iscsi_is_session_dev(dev))
1426 fn(iscsi_dev_to_session(dev));
1430 void iscsi_host_for_each_session(struct Scsi_Host *shost,
1431 void (*fn)(struct iscsi_cls_session *))
1433 device_for_each_child(&shost->shost_gendev, fn,
1434 iscsi_iter_session_fn);
1436 EXPORT_SYMBOL_GPL(iscsi_host_for_each_session);
1439 * iscsi_scan_finished - helper to report when running scans are done
1441 * @time: scan run time
1443 * This function can be used by drives like qla4xxx to report to the scsi
1444 * layer when the scans it kicked off at module load time are done.
1446 int iscsi_scan_finished(struct Scsi_Host *shost, unsigned long time)
1448 struct iscsi_cls_host *ihost = shost->shost_data;
1450 * qla4xxx will have kicked off some session unblocks before calling
1451 * scsi_scan_host, so just wait for them to complete.
1453 return !atomic_read(&ihost->nr_scans);
1455 EXPORT_SYMBOL_GPL(iscsi_scan_finished);
1457 struct iscsi_scan_data {
1458 unsigned int channel;
1463 static int iscsi_user_scan_session(struct device *dev, void *data)
1465 struct iscsi_scan_data *scan_data = data;
1466 struct iscsi_cls_session *session;
1467 struct Scsi_Host *shost;
1468 struct iscsi_cls_host *ihost;
1469 unsigned long flags;
1472 if (!iscsi_is_session_dev(dev))
1475 session = iscsi_dev_to_session(dev);
1477 ISCSI_DBG_TRANS_SESSION(session, "Scanning session\n");
1479 shost = iscsi_session_to_shost(session);
1480 ihost = shost->shost_data;
1482 mutex_lock(&ihost->mutex);
1483 spin_lock_irqsave(&session->lock, flags);
1484 if (session->state != ISCSI_SESSION_LOGGED_IN) {
1485 spin_unlock_irqrestore(&session->lock, flags);
1486 goto user_scan_exit;
1488 id = session->target_id;
1489 spin_unlock_irqrestore(&session->lock, flags);
1491 if (id != ISCSI_MAX_TARGET) {
1492 if ((scan_data->channel == SCAN_WILD_CARD ||
1493 scan_data->channel == 0) &&
1494 (scan_data->id == SCAN_WILD_CARD ||
1495 scan_data->id == id))
1496 scsi_scan_target(&session->dev, 0, id,
1501 mutex_unlock(&ihost->mutex);
1502 ISCSI_DBG_TRANS_SESSION(session, "Completed session scan\n");
1506 static int iscsi_user_scan(struct Scsi_Host *shost, uint channel,
1509 struct iscsi_scan_data scan_data;
1511 scan_data.channel = channel;
1513 scan_data.lun = lun;
1515 return device_for_each_child(&shost->shost_gendev, &scan_data,
1516 iscsi_user_scan_session);
1519 static void iscsi_scan_session(struct work_struct *work)
1521 struct iscsi_cls_session *session =
1522 container_of(work, struct iscsi_cls_session, scan_work);
1523 struct Scsi_Host *shost = iscsi_session_to_shost(session);
1524 struct iscsi_cls_host *ihost = shost->shost_data;
1525 struct iscsi_scan_data scan_data;
1527 scan_data.channel = 0;
1528 scan_data.id = SCAN_WILD_CARD;
1529 scan_data.lun = SCAN_WILD_CARD;
1531 iscsi_user_scan_session(&session->dev, &scan_data);
1532 atomic_dec(&ihost->nr_scans);
1536 * iscsi_block_scsi_eh - block scsi eh until session state has transistioned
1537 * @cmd: scsi cmd passed to scsi eh handler
1539 * If the session is down this function will wait for the recovery
1540 * timer to fire or for the session to be logged back in. If the
1541 * recovery timer fires then FAST_IO_FAIL is returned. The caller
1542 * should pass this error value to the scsi eh.
1544 int iscsi_block_scsi_eh(struct scsi_cmnd *cmd)
1546 struct iscsi_cls_session *session =
1547 starget_to_session(scsi_target(cmd->device));
1548 unsigned long flags;
1551 spin_lock_irqsave(&session->lock, flags);
1552 while (session->state != ISCSI_SESSION_LOGGED_IN) {
1553 if (session->state == ISCSI_SESSION_FREE) {
1557 spin_unlock_irqrestore(&session->lock, flags);
1559 spin_lock_irqsave(&session->lock, flags);
1561 spin_unlock_irqrestore(&session->lock, flags);
1564 EXPORT_SYMBOL_GPL(iscsi_block_scsi_eh);
1566 static void session_recovery_timedout(struct work_struct *work)
1568 struct iscsi_cls_session *session =
1569 container_of(work, struct iscsi_cls_session,
1570 recovery_work.work);
1571 unsigned long flags;
1573 iscsi_cls_session_printk(KERN_INFO, session,
1574 "session recovery timed out after %d secs\n",
1575 session->recovery_tmo);
1577 spin_lock_irqsave(&session->lock, flags);
1578 switch (session->state) {
1579 case ISCSI_SESSION_FAILED:
1580 session->state = ISCSI_SESSION_FREE;
1582 case ISCSI_SESSION_LOGGED_IN:
1583 case ISCSI_SESSION_FREE:
1584 /* we raced with the unblock's flush */
1585 spin_unlock_irqrestore(&session->lock, flags);
1588 spin_unlock_irqrestore(&session->lock, flags);
1590 if (session->transport->session_recovery_timedout)
1591 session->transport->session_recovery_timedout(session);
1593 ISCSI_DBG_TRANS_SESSION(session, "Unblocking SCSI target\n");
1594 scsi_target_unblock(&session->dev, SDEV_TRANSPORT_OFFLINE);
1595 ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking SCSI target\n");
1598 static void __iscsi_unblock_session(struct work_struct *work)
1600 struct iscsi_cls_session *session =
1601 container_of(work, struct iscsi_cls_session,
1603 struct Scsi_Host *shost = iscsi_session_to_shost(session);
1604 struct iscsi_cls_host *ihost = shost->shost_data;
1605 unsigned long flags;
1607 ISCSI_DBG_TRANS_SESSION(session, "Unblocking session\n");
1609 * The recovery and unblock work get run from the same workqueue,
1610 * so try to cancel it if it was going to run after this unblock.
1612 cancel_delayed_work(&session->recovery_work);
1613 spin_lock_irqsave(&session->lock, flags);
1614 session->state = ISCSI_SESSION_LOGGED_IN;
1615 spin_unlock_irqrestore(&session->lock, flags);
1617 scsi_target_unblock(&session->dev, SDEV_RUNNING);
1619 * Only do kernel scanning if the driver is properly hooked into
1620 * the async scanning code (drivers like iscsi_tcp do login and
1621 * scanning from userspace).
1623 if (shost->hostt->scan_finished) {
1624 if (scsi_queue_work(shost, &session->scan_work))
1625 atomic_inc(&ihost->nr_scans);
1627 ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking session\n");
1631 * iscsi_unblock_session - set a session as logged in and start IO.
1632 * @session: iscsi session
1634 * Mark a session as ready to accept IO.
1636 void iscsi_unblock_session(struct iscsi_cls_session *session)
1638 queue_work(iscsi_eh_timer_workq, &session->unblock_work);
1640 * make sure all the events have completed before tell the driver
1643 flush_workqueue(iscsi_eh_timer_workq);
1645 EXPORT_SYMBOL_GPL(iscsi_unblock_session);
1647 static void __iscsi_block_session(struct work_struct *work)
1649 struct iscsi_cls_session *session =
1650 container_of(work, struct iscsi_cls_session,
1652 unsigned long flags;
1654 ISCSI_DBG_TRANS_SESSION(session, "Blocking session\n");
1655 spin_lock_irqsave(&session->lock, flags);
1656 session->state = ISCSI_SESSION_FAILED;
1657 spin_unlock_irqrestore(&session->lock, flags);
1658 scsi_target_block(&session->dev);
1659 ISCSI_DBG_TRANS_SESSION(session, "Completed SCSI target blocking\n");
1660 if (session->recovery_tmo >= 0)
1661 queue_delayed_work(iscsi_eh_timer_workq,
1662 &session->recovery_work,
1663 session->recovery_tmo * HZ);
1666 void iscsi_block_session(struct iscsi_cls_session *session)
1668 queue_work(iscsi_eh_timer_workq, &session->block_work);
1670 EXPORT_SYMBOL_GPL(iscsi_block_session);
1672 static void __iscsi_unbind_session(struct work_struct *work)
1674 struct iscsi_cls_session *session =
1675 container_of(work, struct iscsi_cls_session,
1677 struct Scsi_Host *shost = iscsi_session_to_shost(session);
1678 struct iscsi_cls_host *ihost = shost->shost_data;
1679 unsigned long flags;
1680 unsigned int target_id;
1682 ISCSI_DBG_TRANS_SESSION(session, "Unbinding session\n");
1684 /* Prevent new scans and make sure scanning is not in progress */
1685 mutex_lock(&ihost->mutex);
1686 spin_lock_irqsave(&session->lock, flags);
1687 if (session->target_id == ISCSI_MAX_TARGET) {
1688 spin_unlock_irqrestore(&session->lock, flags);
1689 mutex_unlock(&ihost->mutex);
1693 target_id = session->target_id;
1694 session->target_id = ISCSI_MAX_TARGET;
1695 spin_unlock_irqrestore(&session->lock, flags);
1696 mutex_unlock(&ihost->mutex);
1698 if (session->ida_used)
1699 ida_simple_remove(&iscsi_sess_ida, target_id);
1701 scsi_remove_target(&session->dev);
1702 iscsi_session_event(session, ISCSI_KEVENT_UNBIND_SESSION);
1703 ISCSI_DBG_TRANS_SESSION(session, "Completed target removal\n");
1706 struct iscsi_cls_session *
1707 iscsi_alloc_session(struct Scsi_Host *shost, struct iscsi_transport *transport,
1710 struct iscsi_cls_session *session;
1712 session = kzalloc(sizeof(*session) + dd_size,
1717 session->transport = transport;
1718 session->creator = -1;
1719 session->recovery_tmo = 120;
1720 session->state = ISCSI_SESSION_FREE;
1721 INIT_DELAYED_WORK(&session->recovery_work, session_recovery_timedout);
1722 INIT_LIST_HEAD(&session->sess_list);
1723 INIT_WORK(&session->unblock_work, __iscsi_unblock_session);
1724 INIT_WORK(&session->block_work, __iscsi_block_session);
1725 INIT_WORK(&session->unbind_work, __iscsi_unbind_session);
1726 INIT_WORK(&session->scan_work, iscsi_scan_session);
1727 spin_lock_init(&session->lock);
1729 /* this is released in the dev's release function */
1730 scsi_host_get(shost);
1731 session->dev.parent = &shost->shost_gendev;
1732 session->dev.release = iscsi_session_release;
1733 device_initialize(&session->dev);
1735 session->dd_data = &session[1];
1737 ISCSI_DBG_TRANS_SESSION(session, "Completed session allocation\n");
1740 EXPORT_SYMBOL_GPL(iscsi_alloc_session);
1742 int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id)
1744 struct Scsi_Host *shost = iscsi_session_to_shost(session);
1745 struct iscsi_cls_host *ihost;
1746 unsigned long flags;
1750 ihost = shost->shost_data;
1751 session->sid = atomic_add_return(1, &iscsi_session_nr);
1753 if (target_id == ISCSI_MAX_TARGET) {
1754 id = ida_simple_get(&iscsi_sess_ida, 0, 0, GFP_KERNEL);
1757 iscsi_cls_session_printk(KERN_ERR, session,
1758 "Failure in Target ID Allocation\n");
1761 session->target_id = (unsigned int)id;
1762 session->ida_used = true;
1764 session->target_id = target_id;
1766 dev_set_name(&session->dev, "session%u", session->sid);
1767 err = device_add(&session->dev);
1769 iscsi_cls_session_printk(KERN_ERR, session,
1770 "could not register session's dev\n");
1773 transport_register_device(&session->dev);
1775 spin_lock_irqsave(&sesslock, flags);
1776 list_add(&session->sess_list, &sesslist);
1777 spin_unlock_irqrestore(&sesslock, flags);
1779 iscsi_session_event(session, ISCSI_KEVENT_CREATE_SESSION);
1780 ISCSI_DBG_TRANS_SESSION(session, "Completed session adding\n");
1784 if (session->ida_used)
1785 ida_simple_remove(&iscsi_sess_ida, session->target_id);
1789 EXPORT_SYMBOL_GPL(iscsi_add_session);
1792 * iscsi_create_session - create iscsi class session
1794 * @transport: iscsi transport
1795 * @dd_size: private driver data size
1796 * @target_id: which target
1798 * This can be called from a LLD or iscsi_transport.
1800 struct iscsi_cls_session *
1801 iscsi_create_session(struct Scsi_Host *shost, struct iscsi_transport *transport,
1802 int dd_size, unsigned int target_id)
1804 struct iscsi_cls_session *session;
1806 session = iscsi_alloc_session(shost, transport, dd_size);
1810 if (iscsi_add_session(session, target_id)) {
1811 iscsi_free_session(session);
1816 EXPORT_SYMBOL_GPL(iscsi_create_session);
1818 static void iscsi_conn_release(struct device *dev)
1820 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev);
1821 struct device *parent = conn->dev.parent;
1823 ISCSI_DBG_TRANS_CONN(conn, "Releasing conn\n");
1828 static int iscsi_is_conn_dev(const struct device *dev)
1830 return dev->release == iscsi_conn_release;
1833 static int iscsi_iter_destroy_conn_fn(struct device *dev, void *data)
1835 if (!iscsi_is_conn_dev(dev))
1837 return iscsi_destroy_conn(iscsi_dev_to_conn(dev));
1840 void iscsi_remove_session(struct iscsi_cls_session *session)
1842 struct Scsi_Host *shost = iscsi_session_to_shost(session);
1843 unsigned long flags;
1846 ISCSI_DBG_TRANS_SESSION(session, "Removing session\n");
1848 spin_lock_irqsave(&sesslock, flags);
1849 list_del(&session->sess_list);
1850 spin_unlock_irqrestore(&sesslock, flags);
1852 /* make sure there are no blocks/unblocks queued */
1853 flush_workqueue(iscsi_eh_timer_workq);
1854 /* make sure the timedout callout is not running */
1855 if (!cancel_delayed_work(&session->recovery_work))
1856 flush_workqueue(iscsi_eh_timer_workq);
1858 * If we are blocked let commands flow again. The lld or iscsi
1859 * layer should set up the queuecommand to fail commands.
1860 * We assume that LLD will not be calling block/unblock while
1861 * removing the session.
1863 spin_lock_irqsave(&session->lock, flags);
1864 session->state = ISCSI_SESSION_FREE;
1865 spin_unlock_irqrestore(&session->lock, flags);
1867 scsi_target_unblock(&session->dev, SDEV_TRANSPORT_OFFLINE);
1868 /* flush running scans then delete devices */
1869 scsi_flush_work(shost);
1870 __iscsi_unbind_session(&session->unbind_work);
1872 /* hw iscsi may not have removed all connections from session */
1873 err = device_for_each_child(&session->dev, NULL,
1874 iscsi_iter_destroy_conn_fn);
1876 iscsi_cls_session_printk(KERN_ERR, session,
1877 "Could not delete all connections "
1878 "for session. Error %d.\n", err);
1880 transport_unregister_device(&session->dev);
1882 ISCSI_DBG_TRANS_SESSION(session, "Completing session removal\n");
1883 device_del(&session->dev);
1885 EXPORT_SYMBOL_GPL(iscsi_remove_session);
1887 void iscsi_free_session(struct iscsi_cls_session *session)
1889 ISCSI_DBG_TRANS_SESSION(session, "Freeing session\n");
1890 iscsi_session_event(session, ISCSI_KEVENT_DESTROY_SESSION);
1891 put_device(&session->dev);
1893 EXPORT_SYMBOL_GPL(iscsi_free_session);
1896 * iscsi_destroy_session - destroy iscsi session
1897 * @session: iscsi_session
1899 * Can be called by a LLD or iscsi_transport. There must not be
1900 * any running connections.
1902 int iscsi_destroy_session(struct iscsi_cls_session *session)
1904 iscsi_remove_session(session);
1905 ISCSI_DBG_TRANS_SESSION(session, "Completing session destruction\n");
1906 iscsi_free_session(session);
1909 EXPORT_SYMBOL_GPL(iscsi_destroy_session);
1912 * iscsi_create_conn - create iscsi class connection
1913 * @session: iscsi cls session
1914 * @dd_size: private driver data size
1915 * @cid: connection id
1917 * This can be called from a LLD or iscsi_transport. The connection
1918 * is child of the session so cid must be unique for all connections
1921 * Since we do not support MCS, cid will normally be zero. In some cases
1922 * for software iscsi we could be trying to preallocate a connection struct
1923 * in which case there could be two connection structs and cid would be
1926 struct iscsi_cls_conn *
1927 iscsi_create_conn(struct iscsi_cls_session *session, int dd_size, uint32_t cid)
1929 struct iscsi_transport *transport = session->transport;
1930 struct iscsi_cls_conn *conn;
1931 unsigned long flags;
1934 conn = kzalloc(sizeof(*conn) + dd_size, GFP_KERNEL);
1938 conn->dd_data = &conn[1];
1940 mutex_init(&conn->ep_mutex);
1941 INIT_LIST_HEAD(&conn->conn_list);
1942 conn->transport = transport;
1945 /* this is released in the dev's release function */
1946 if (!get_device(&session->dev))
1949 dev_set_name(&conn->dev, "connection%d:%u", session->sid, cid);
1950 conn->dev.parent = &session->dev;
1951 conn->dev.release = iscsi_conn_release;
1952 err = device_register(&conn->dev);
1954 iscsi_cls_session_printk(KERN_ERR, session, "could not "
1955 "register connection's dev\n");
1956 goto release_parent_ref;
1958 transport_register_device(&conn->dev);
1960 spin_lock_irqsave(&connlock, flags);
1961 list_add(&conn->conn_list, &connlist);
1962 spin_unlock_irqrestore(&connlock, flags);
1964 ISCSI_DBG_TRANS_CONN(conn, "Completed conn creation\n");
1968 put_device(&session->dev);
1974 EXPORT_SYMBOL_GPL(iscsi_create_conn);
1977 * iscsi_destroy_conn - destroy iscsi class connection
1978 * @conn: iscsi cls session
1980 * This can be called from a LLD or iscsi_transport.
1982 int iscsi_destroy_conn(struct iscsi_cls_conn *conn)
1984 unsigned long flags;
1986 spin_lock_irqsave(&connlock, flags);
1987 list_del(&conn->conn_list);
1988 spin_unlock_irqrestore(&connlock, flags);
1990 transport_unregister_device(&conn->dev);
1991 ISCSI_DBG_TRANS_CONN(conn, "Completing conn destruction\n");
1992 device_unregister(&conn->dev);
1995 EXPORT_SYMBOL_GPL(iscsi_destroy_conn);
1998 * iscsi interface functions
2000 static struct iscsi_internal *
2001 iscsi_if_transport_lookup(struct iscsi_transport *tt)
2003 struct iscsi_internal *priv;
2004 unsigned long flags;
2006 spin_lock_irqsave(&iscsi_transport_lock, flags);
2007 list_for_each_entry(priv, &iscsi_transports, list) {
2008 if (tt == priv->iscsi_transport) {
2009 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
2013 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
2018 iscsi_multicast_skb(struct sk_buff *skb, uint32_t group, gfp_t gfp)
2020 return nlmsg_multicast(nls, skb, 0, group, gfp);
2023 int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
2024 char *data, uint32_t data_size)
2026 struct nlmsghdr *nlh;
2027 struct sk_buff *skb;
2028 struct iscsi_uevent *ev;
2030 struct iscsi_internal *priv;
2031 int len = nlmsg_total_size(sizeof(*ev) + sizeof(struct iscsi_hdr) +
2034 priv = iscsi_if_transport_lookup(conn->transport);
2038 skb = alloc_skb(len, GFP_ATOMIC);
2040 iscsi_conn_error_event(conn, ISCSI_ERR_CONN_FAILED);
2041 iscsi_cls_conn_printk(KERN_ERR, conn, "can not deliver "
2042 "control PDU: OOM\n");
2046 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2047 ev = nlmsg_data(nlh);
2048 memset(ev, 0, sizeof(*ev));
2049 ev->transport_handle = iscsi_handle(conn->transport);
2050 ev->type = ISCSI_KEVENT_RECV_PDU;
2051 ev->r.recv_req.cid = conn->cid;
2052 ev->r.recv_req.sid = iscsi_conn_get_sid(conn);
2053 pdu = (char*)ev + sizeof(*ev);
2054 memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
2055 memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
2057 return iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
2059 EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
2061 int iscsi_offload_mesg(struct Scsi_Host *shost,
2062 struct iscsi_transport *transport, uint32_t type,
2063 char *data, uint16_t data_size)
2065 struct nlmsghdr *nlh;
2066 struct sk_buff *skb;
2067 struct iscsi_uevent *ev;
2068 int len = nlmsg_total_size(sizeof(*ev) + data_size);
2070 skb = alloc_skb(len, GFP_ATOMIC);
2072 printk(KERN_ERR "can not deliver iscsi offload message:OOM\n");
2076 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2077 ev = nlmsg_data(nlh);
2078 memset(ev, 0, sizeof(*ev));
2080 ev->transport_handle = iscsi_handle(transport);
2082 case ISCSI_KEVENT_PATH_REQ:
2083 ev->r.req_path.host_no = shost->host_no;
2085 case ISCSI_KEVENT_IF_DOWN:
2086 ev->r.notify_if_down.host_no = shost->host_no;
2090 memcpy((char *)ev + sizeof(*ev), data, data_size);
2092 return iscsi_multicast_skb(skb, ISCSI_NL_GRP_UIP, GFP_ATOMIC);
2094 EXPORT_SYMBOL_GPL(iscsi_offload_mesg);
2096 void iscsi_conn_error_event(struct iscsi_cls_conn *conn, enum iscsi_err error)
2098 struct nlmsghdr *nlh;
2099 struct sk_buff *skb;
2100 struct iscsi_uevent *ev;
2101 struct iscsi_internal *priv;
2102 int len = nlmsg_total_size(sizeof(*ev));
2104 priv = iscsi_if_transport_lookup(conn->transport);
2108 skb = alloc_skb(len, GFP_ATOMIC);
2110 iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored "
2111 "conn error (%d)\n", error);
2115 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2116 ev = nlmsg_data(nlh);
2117 ev->transport_handle = iscsi_handle(conn->transport);
2118 ev->type = ISCSI_KEVENT_CONN_ERROR;
2119 ev->r.connerror.error = error;
2120 ev->r.connerror.cid = conn->cid;
2121 ev->r.connerror.sid = iscsi_conn_get_sid(conn);
2123 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
2125 iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn error (%d)\n",
2128 EXPORT_SYMBOL_GPL(iscsi_conn_error_event);
2130 void iscsi_conn_login_event(struct iscsi_cls_conn *conn,
2131 enum iscsi_conn_state state)
2133 struct nlmsghdr *nlh;
2134 struct sk_buff *skb;
2135 struct iscsi_uevent *ev;
2136 struct iscsi_internal *priv;
2137 int len = nlmsg_total_size(sizeof(*ev));
2139 priv = iscsi_if_transport_lookup(conn->transport);
2143 skb = alloc_skb(len, GFP_ATOMIC);
2145 iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored "
2146 "conn login (%d)\n", state);
2150 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2151 ev = nlmsg_data(nlh);
2152 ev->transport_handle = iscsi_handle(conn->transport);
2153 ev->type = ISCSI_KEVENT_CONN_LOGIN_STATE;
2154 ev->r.conn_login.state = state;
2155 ev->r.conn_login.cid = conn->cid;
2156 ev->r.conn_login.sid = iscsi_conn_get_sid(conn);
2157 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
2159 iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn login (%d)\n",
2162 EXPORT_SYMBOL_GPL(iscsi_conn_login_event);
2164 void iscsi_post_host_event(uint32_t host_no, struct iscsi_transport *transport,
2165 enum iscsi_host_event_code code, uint32_t data_size,
2168 struct nlmsghdr *nlh;
2169 struct sk_buff *skb;
2170 struct iscsi_uevent *ev;
2171 int len = nlmsg_total_size(sizeof(*ev) + data_size);
2173 skb = alloc_skb(len, GFP_NOIO);
2175 printk(KERN_ERR "gracefully ignored host event (%d):%d OOM\n",
2180 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2181 ev = nlmsg_data(nlh);
2182 ev->transport_handle = iscsi_handle(transport);
2183 ev->type = ISCSI_KEVENT_HOST_EVENT;
2184 ev->r.host_event.host_no = host_no;
2185 ev->r.host_event.code = code;
2186 ev->r.host_event.data_size = data_size;
2189 memcpy((char *)ev + sizeof(*ev), data, data_size);
2191 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_NOIO);
2193 EXPORT_SYMBOL_GPL(iscsi_post_host_event);
2195 void iscsi_ping_comp_event(uint32_t host_no, struct iscsi_transport *transport,
2196 uint32_t status, uint32_t pid, uint32_t data_size,
2199 struct nlmsghdr *nlh;
2200 struct sk_buff *skb;
2201 struct iscsi_uevent *ev;
2202 int len = nlmsg_total_size(sizeof(*ev) + data_size);
2204 skb = alloc_skb(len, GFP_NOIO);
2206 printk(KERN_ERR "gracefully ignored ping comp: OOM\n");
2210 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2211 ev = nlmsg_data(nlh);
2212 ev->transport_handle = iscsi_handle(transport);
2213 ev->type = ISCSI_KEVENT_PING_COMP;
2214 ev->r.ping_comp.host_no = host_no;
2215 ev->r.ping_comp.status = status;
2216 ev->r.ping_comp.pid = pid;
2217 ev->r.ping_comp.data_size = data_size;
2218 memcpy((char *)ev + sizeof(*ev), data, data_size);
2220 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_NOIO);
2222 EXPORT_SYMBOL_GPL(iscsi_ping_comp_event);
2225 iscsi_if_send_reply(uint32_t group, int seq, int type, int done, int multi,
2226 void *payload, int size)
2228 struct sk_buff *skb;
2229 struct nlmsghdr *nlh;
2230 int len = nlmsg_total_size(size);
2231 int flags = multi ? NLM_F_MULTI : 0;
2232 int t = done ? NLMSG_DONE : type;
2234 skb = alloc_skb(len, GFP_ATOMIC);
2236 printk(KERN_ERR "Could not allocate skb to send reply.\n");
2240 nlh = __nlmsg_put(skb, 0, 0, t, (len - sizeof(*nlh)), 0);
2241 nlh->nlmsg_flags = flags;
2242 memcpy(nlmsg_data(nlh), payload, size);
2243 return iscsi_multicast_skb(skb, group, GFP_ATOMIC);
2247 iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
2249 struct iscsi_uevent *ev = nlmsg_data(nlh);
2250 struct iscsi_stats *stats;
2251 struct sk_buff *skbstat;
2252 struct iscsi_cls_conn *conn;
2253 struct nlmsghdr *nlhstat;
2254 struct iscsi_uevent *evstat;
2255 struct iscsi_internal *priv;
2256 int len = nlmsg_total_size(sizeof(*ev) +
2257 sizeof(struct iscsi_stats) +
2258 sizeof(struct iscsi_stats_custom) *
2259 ISCSI_STATS_CUSTOM_MAX);
2262 priv = iscsi_if_transport_lookup(transport);
2266 conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid);
2273 skbstat = alloc_skb(len, GFP_ATOMIC);
2275 iscsi_cls_conn_printk(KERN_ERR, conn, "can not "
2276 "deliver stats: OOM\n");
2280 nlhstat = __nlmsg_put(skbstat, 0, 0, 0,
2281 (len - sizeof(*nlhstat)), 0);
2282 evstat = nlmsg_data(nlhstat);
2283 memset(evstat, 0, sizeof(*evstat));
2284 evstat->transport_handle = iscsi_handle(conn->transport);
2285 evstat->type = nlh->nlmsg_type;
2286 evstat->u.get_stats.cid =
2287 ev->u.get_stats.cid;
2288 evstat->u.get_stats.sid =
2289 ev->u.get_stats.sid;
2290 stats = (struct iscsi_stats *)
2291 ((char*)evstat + sizeof(*evstat));
2292 memset(stats, 0, sizeof(*stats));
2294 transport->get_stats(conn, stats);
2295 actual_size = nlmsg_total_size(sizeof(struct iscsi_uevent) +
2296 sizeof(struct iscsi_stats) +
2297 sizeof(struct iscsi_stats_custom) *
2298 stats->custom_length);
2299 actual_size -= sizeof(*nlhstat);
2300 actual_size = nlmsg_msg_size(actual_size);
2301 skb_trim(skbstat, NLMSG_ALIGN(actual_size));
2302 nlhstat->nlmsg_len = actual_size;
2304 err = iscsi_multicast_skb(skbstat, ISCSI_NL_GRP_ISCSID,
2306 } while (err < 0 && err != -ECONNREFUSED);
2312 * iscsi_session_event - send session destr. completion event
2313 * @session: iscsi class session
2314 * @event: type of event
2316 int iscsi_session_event(struct iscsi_cls_session *session,
2317 enum iscsi_uevent_e event)
2319 struct iscsi_internal *priv;
2320 struct Scsi_Host *shost;
2321 struct iscsi_uevent *ev;
2322 struct sk_buff *skb;
2323 struct nlmsghdr *nlh;
2324 int rc, len = nlmsg_total_size(sizeof(*ev));
2326 priv = iscsi_if_transport_lookup(session->transport);
2329 shost = iscsi_session_to_shost(session);
2331 skb = alloc_skb(len, GFP_KERNEL);
2333 iscsi_cls_session_printk(KERN_ERR, session,
2334 "Cannot notify userspace of session "
2335 "event %u\n", event);
2339 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
2340 ev = nlmsg_data(nlh);
2341 ev->transport_handle = iscsi_handle(session->transport);
2345 case ISCSI_KEVENT_DESTROY_SESSION:
2346 ev->r.d_session.host_no = shost->host_no;
2347 ev->r.d_session.sid = session->sid;
2349 case ISCSI_KEVENT_CREATE_SESSION:
2350 ev->r.c_session_ret.host_no = shost->host_no;
2351 ev->r.c_session_ret.sid = session->sid;
2353 case ISCSI_KEVENT_UNBIND_SESSION:
2354 ev->r.unbind_session.host_no = shost->host_no;
2355 ev->r.unbind_session.sid = session->sid;
2358 iscsi_cls_session_printk(KERN_ERR, session, "Invalid event "
2365 * this will occur if the daemon is not up, so we just warn
2366 * the user and when the daemon is restarted it will handle it
2368 rc = iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_KERNEL);
2370 iscsi_cls_session_printk(KERN_ERR, session,
2371 "Cannot notify userspace of session "
2372 "event %u. Check iscsi daemon\n",
2375 ISCSI_DBG_TRANS_SESSION(session, "Completed handling event %d rc %d\n",
2379 EXPORT_SYMBOL_GPL(iscsi_session_event);
2382 iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_endpoint *ep,
2383 struct iscsi_uevent *ev, pid_t pid,
2384 uint32_t initial_cmdsn, uint16_t cmds_max,
2385 uint16_t queue_depth)
2387 struct iscsi_transport *transport = priv->iscsi_transport;
2388 struct iscsi_cls_session *session;
2389 struct Scsi_Host *shost;
2391 session = transport->create_session(ep, cmds_max, queue_depth,
2396 session->creator = pid;
2397 shost = iscsi_session_to_shost(session);
2398 ev->r.c_session_ret.host_no = shost->host_no;
2399 ev->r.c_session_ret.sid = session->sid;
2400 ISCSI_DBG_TRANS_SESSION(session,
2401 "Completed creating transport session\n");
2406 iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
2408 struct iscsi_cls_conn *conn;
2409 struct iscsi_cls_session *session;
2411 session = iscsi_session_lookup(ev->u.c_conn.sid);
2413 printk(KERN_ERR "iscsi: invalid session %d.\n",
2418 conn = transport->create_conn(session, ev->u.c_conn.cid);
2420 iscsi_cls_session_printk(KERN_ERR, session,
2421 "couldn't create a new connection.");
2425 ev->r.c_conn_ret.sid = session->sid;
2426 ev->r.c_conn_ret.cid = conn->cid;
2428 ISCSI_DBG_TRANS_CONN(conn, "Completed creating transport conn\n");
2433 iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
2435 struct iscsi_cls_conn *conn;
2437 conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid);
2441 ISCSI_DBG_TRANS_CONN(conn, "Destroying transport conn\n");
2442 if (transport->destroy_conn)
2443 transport->destroy_conn(conn);
2449 iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev)
2451 char *data = (char*)ev + sizeof(*ev);
2452 struct iscsi_cls_conn *conn;
2453 struct iscsi_cls_session *session;
2454 int err = 0, value = 0;
2456 session = iscsi_session_lookup(ev->u.set_param.sid);
2457 conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid);
2458 if (!conn || !session)
2461 switch (ev->u.set_param.param) {
2462 case ISCSI_PARAM_SESS_RECOVERY_TMO:
2463 sscanf(data, "%d", &value);
2464 session->recovery_tmo = value;
2467 err = transport->set_param(conn, ev->u.set_param.param,
2468 data, ev->u.set_param.len);
2474 static int iscsi_if_ep_connect(struct iscsi_transport *transport,
2475 struct iscsi_uevent *ev, int msg_type)
2477 struct iscsi_endpoint *ep;
2478 struct sockaddr *dst_addr;
2479 struct Scsi_Host *shost = NULL;
2480 int non_blocking, err = 0;
2482 if (!transport->ep_connect)
2485 if (msg_type == ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST) {
2486 shost = scsi_host_lookup(ev->u.ep_connect_through_host.host_no);
2488 printk(KERN_ERR "ep connect failed. Could not find "
2490 ev->u.ep_connect_through_host.host_no);
2493 non_blocking = ev->u.ep_connect_through_host.non_blocking;
2495 non_blocking = ev->u.ep_connect.non_blocking;
2497 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
2498 ep = transport->ep_connect(shost, dst_addr, non_blocking);
2504 ev->r.ep_connect_ret.handle = ep->id;
2507 scsi_host_put(shost);
2511 static int iscsi_if_ep_disconnect(struct iscsi_transport *transport,
2514 struct iscsi_cls_conn *conn;
2515 struct iscsi_endpoint *ep;
2517 if (!transport->ep_disconnect)
2520 ep = iscsi_lookup_endpoint(ep_handle);
2525 mutex_lock(&conn->ep_mutex);
2527 mutex_unlock(&conn->ep_mutex);
2530 transport->ep_disconnect(ep);
2535 iscsi_if_transport_ep(struct iscsi_transport *transport,
2536 struct iscsi_uevent *ev, int msg_type)
2538 struct iscsi_endpoint *ep;
2542 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST:
2543 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
2544 rc = iscsi_if_ep_connect(transport, ev, msg_type);
2546 case ISCSI_UEVENT_TRANSPORT_EP_POLL:
2547 if (!transport->ep_poll)
2550 ep = iscsi_lookup_endpoint(ev->u.ep_poll.ep_handle);
2554 ev->r.retcode = transport->ep_poll(ep,
2555 ev->u.ep_poll.timeout_ms);
2557 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
2558 rc = iscsi_if_ep_disconnect(transport,
2559 ev->u.ep_disconnect.ep_handle);
2566 iscsi_tgt_dscvr(struct iscsi_transport *transport,
2567 struct iscsi_uevent *ev)
2569 struct Scsi_Host *shost;
2570 struct sockaddr *dst_addr;
2573 if (!transport->tgt_dscvr)
2576 shost = scsi_host_lookup(ev->u.tgt_dscvr.host_no);
2578 printk(KERN_ERR "target discovery could not find host no %u\n",
2579 ev->u.tgt_dscvr.host_no);
2584 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
2585 err = transport->tgt_dscvr(shost, ev->u.tgt_dscvr.type,
2586 ev->u.tgt_dscvr.enable, dst_addr);
2587 scsi_host_put(shost);
2592 iscsi_set_host_param(struct iscsi_transport *transport,
2593 struct iscsi_uevent *ev)
2595 char *data = (char*)ev + sizeof(*ev);
2596 struct Scsi_Host *shost;
2599 if (!transport->set_host_param)
2602 shost = scsi_host_lookup(ev->u.set_host_param.host_no);
2604 printk(KERN_ERR "set_host_param could not find host no %u\n",
2605 ev->u.set_host_param.host_no);
2609 err = transport->set_host_param(shost, ev->u.set_host_param.param,
2610 data, ev->u.set_host_param.len);
2611 scsi_host_put(shost);
2616 iscsi_set_path(struct iscsi_transport *transport, struct iscsi_uevent *ev)
2618 struct Scsi_Host *shost;
2619 struct iscsi_path *params;
2622 if (!transport->set_path)
2625 shost = scsi_host_lookup(ev->u.set_path.host_no);
2627 printk(KERN_ERR "set path could not find host no %u\n",
2628 ev->u.set_path.host_no);
2632 params = (struct iscsi_path *)((char *)ev + sizeof(*ev));
2633 err = transport->set_path(shost, params);
2635 scsi_host_put(shost);
2640 iscsi_set_iface_params(struct iscsi_transport *transport,
2641 struct iscsi_uevent *ev, uint32_t len)
2643 char *data = (char *)ev + sizeof(*ev);
2644 struct Scsi_Host *shost;
2647 if (!transport->set_iface_param)
2650 shost = scsi_host_lookup(ev->u.set_iface_params.host_no);
2652 printk(KERN_ERR "set_iface_params could not find host no %u\n",
2653 ev->u.set_iface_params.host_no);
2657 err = transport->set_iface_param(shost, data, len);
2658 scsi_host_put(shost);
2663 iscsi_send_ping(struct iscsi_transport *transport, struct iscsi_uevent *ev)
2665 struct Scsi_Host *shost;
2666 struct sockaddr *dst_addr;
2669 if (!transport->send_ping)
2672 shost = scsi_host_lookup(ev->u.iscsi_ping.host_no);
2674 printk(KERN_ERR "iscsi_ping could not find host no %u\n",
2675 ev->u.iscsi_ping.host_no);
2679 dst_addr = (struct sockaddr *)((char *)ev + sizeof(*ev));
2680 err = transport->send_ping(shost, ev->u.iscsi_ping.iface_num,
2681 ev->u.iscsi_ping.iface_type,
2682 ev->u.iscsi_ping.payload_size,
2683 ev->u.iscsi_ping.pid,
2685 scsi_host_put(shost);
2690 iscsi_get_chap(struct iscsi_transport *transport, struct nlmsghdr *nlh)
2692 struct iscsi_uevent *ev = nlmsg_data(nlh);
2693 struct Scsi_Host *shost = NULL;
2694 struct iscsi_chap_rec *chap_rec;
2695 struct iscsi_internal *priv;
2696 struct sk_buff *skbchap;
2697 struct nlmsghdr *nlhchap;
2698 struct iscsi_uevent *evchap;
2699 uint32_t chap_buf_size;
2703 if (!transport->get_chap)
2706 priv = iscsi_if_transport_lookup(transport);
2710 chap_buf_size = (ev->u.get_chap.num_entries * sizeof(*chap_rec));
2711 len = nlmsg_total_size(sizeof(*ev) + chap_buf_size);
2713 shost = scsi_host_lookup(ev->u.get_chap.host_no);
2715 printk(KERN_ERR "%s: failed. Cound not find host no %u\n",
2716 __func__, ev->u.get_chap.host_no);
2723 skbchap = alloc_skb(len, GFP_KERNEL);
2725 printk(KERN_ERR "can not deliver chap: OOM\n");
2730 nlhchap = __nlmsg_put(skbchap, 0, 0, 0,
2731 (len - sizeof(*nlhchap)), 0);
2732 evchap = nlmsg_data(nlhchap);
2733 memset(evchap, 0, sizeof(*evchap));
2734 evchap->transport_handle = iscsi_handle(transport);
2735 evchap->type = nlh->nlmsg_type;
2736 evchap->u.get_chap.host_no = ev->u.get_chap.host_no;
2737 evchap->u.get_chap.chap_tbl_idx = ev->u.get_chap.chap_tbl_idx;
2738 evchap->u.get_chap.num_entries = ev->u.get_chap.num_entries;
2739 buf = (char *) ((char *)evchap + sizeof(*evchap));
2740 memset(buf, 0, chap_buf_size);
2742 err = transport->get_chap(shost, ev->u.get_chap.chap_tbl_idx,
2743 &evchap->u.get_chap.num_entries, buf);
2745 actual_size = nlmsg_total_size(sizeof(*ev) + chap_buf_size);
2746 skb_trim(skbchap, NLMSG_ALIGN(actual_size));
2747 nlhchap->nlmsg_len = actual_size;
2749 err = iscsi_multicast_skb(skbchap, ISCSI_NL_GRP_ISCSID,
2751 } while (err < 0 && err != -ECONNREFUSED);
2754 scsi_host_put(shost);
2758 static int iscsi_delete_chap(struct iscsi_transport *transport,
2759 struct iscsi_uevent *ev)
2761 struct Scsi_Host *shost;
2764 if (!transport->delete_chap)
2767 shost = scsi_host_lookup(ev->u.delete_chap.host_no);
2769 printk(KERN_ERR "%s could not find host no %u\n",
2770 __func__, ev->u.delete_chap.host_no);
2774 err = transport->delete_chap(shost, ev->u.delete_chap.chap_tbl_idx);
2775 scsi_host_put(shost);
2779 static const struct {
2780 enum iscsi_discovery_parent_type value;
2782 } iscsi_discovery_parent_names[] = {
2783 {ISCSI_DISC_PARENT_UNKNOWN, "Unknown" },
2784 {ISCSI_DISC_PARENT_SENDTGT, "Sendtarget" },
2785 {ISCSI_DISC_PARENT_ISNS, "isns" },
2788 char *iscsi_get_discovery_parent_name(int parent_type)
2791 char *state = "Unknown!";
2793 for (i = 0; i < ARRAY_SIZE(iscsi_discovery_parent_names); i++) {
2794 if (iscsi_discovery_parent_names[i].value & parent_type) {
2795 state = iscsi_discovery_parent_names[i].name;
2801 EXPORT_SYMBOL_GPL(iscsi_get_discovery_parent_name);
2803 static int iscsi_set_flashnode_param(struct iscsi_transport *transport,
2804 struct iscsi_uevent *ev, uint32_t len)
2806 char *data = (char *)ev + sizeof(*ev);
2807 struct Scsi_Host *shost;
2808 struct iscsi_bus_flash_session *fnode_sess;
2809 struct iscsi_bus_flash_conn *fnode_conn;
2814 if (!transport->set_flashnode_param) {
2816 goto exit_set_fnode;
2819 shost = scsi_host_lookup(ev->u.set_flashnode.host_no);
2821 pr_err("%s could not find host no %u\n",
2822 __func__, ev->u.set_flashnode.host_no);
2827 idx = &ev->u.set_flashnode.flashnode_idx;
2828 fnode_sess = iscsi_get_flashnode_by_index(shost, idx,
2829 flashnode_match_index);
2831 pr_err("%s could not find flashnode %u for host no %u\n",
2832 __func__, *idx, ev->u.set_flashnode.host_no);
2837 dev = iscsi_find_flashnode_conn(fnode_sess, NULL,
2838 iscsi_is_flashnode_conn_dev);
2844 fnode_conn = iscsi_dev_to_flash_conn(dev);
2845 err = transport->set_flashnode_param(fnode_sess, fnode_conn, data, len);
2848 scsi_host_put(shost);
2854 static int iscsi_new_flashnode(struct iscsi_transport *transport,
2855 struct iscsi_uevent *ev, uint32_t len)
2857 char *data = (char *)ev + sizeof(*ev);
2858 struct Scsi_Host *shost;
2862 if (!transport->new_flashnode) {
2864 goto exit_new_fnode;
2867 shost = scsi_host_lookup(ev->u.new_flashnode.host_no);
2869 pr_err("%s could not find host no %u\n",
2870 __func__, ev->u.new_flashnode.host_no);
2875 index = transport->new_flashnode(shost, data, len);
2878 ev->r.new_flashnode_ret.flashnode_idx = index;
2883 scsi_host_put(shost);
2889 static int iscsi_del_flashnode(struct iscsi_transport *transport,
2890 struct iscsi_uevent *ev)
2892 struct Scsi_Host *shost;
2893 struct iscsi_bus_flash_session *fnode_sess;
2897 if (!transport->del_flashnode) {
2899 goto exit_del_fnode;
2902 shost = scsi_host_lookup(ev->u.del_flashnode.host_no);
2904 pr_err("%s could not find host no %u\n",
2905 __func__, ev->u.del_flashnode.host_no);
2910 idx = &ev->u.del_flashnode.flashnode_idx;
2911 fnode_sess = iscsi_get_flashnode_by_index(shost, idx,
2912 flashnode_match_index);
2914 pr_err("%s could not find flashnode %u for host no %u\n",
2915 __func__, *idx, ev->u.del_flashnode.host_no);
2920 err = transport->del_flashnode(fnode_sess);
2923 scsi_host_put(shost);
2929 static int iscsi_login_flashnode(struct iscsi_transport *transport,
2930 struct iscsi_uevent *ev)
2932 struct Scsi_Host *shost;
2933 struct iscsi_bus_flash_session *fnode_sess;
2934 struct iscsi_bus_flash_conn *fnode_conn;
2939 if (!transport->login_flashnode) {
2941 goto exit_login_fnode;
2944 shost = scsi_host_lookup(ev->u.login_flashnode.host_no);
2946 pr_err("%s could not find host no %u\n",
2947 __func__, ev->u.login_flashnode.host_no);
2952 idx = &ev->u.login_flashnode.flashnode_idx;
2953 fnode_sess = iscsi_get_flashnode_by_index(shost, idx,
2954 flashnode_match_index);
2956 pr_err("%s could not find flashnode %u for host no %u\n",
2957 __func__, *idx, ev->u.login_flashnode.host_no);
2962 dev = iscsi_find_flashnode_conn(fnode_sess, NULL,
2963 iscsi_is_flashnode_conn_dev);
2969 fnode_conn = iscsi_dev_to_flash_conn(dev);
2970 err = transport->login_flashnode(fnode_sess, fnode_conn);
2973 scsi_host_put(shost);
2979 static int iscsi_logout_flashnode(struct iscsi_transport *transport,
2980 struct iscsi_uevent *ev)
2982 struct Scsi_Host *shost;
2983 struct iscsi_bus_flash_session *fnode_sess;
2984 struct iscsi_bus_flash_conn *fnode_conn;
2989 if (!transport->logout_flashnode) {
2991 goto exit_logout_fnode;
2994 shost = scsi_host_lookup(ev->u.logout_flashnode.host_no);
2996 pr_err("%s could not find host no %u\n",
2997 __func__, ev->u.logout_flashnode.host_no);
3002 idx = &ev->u.logout_flashnode.flashnode_idx;
3003 fnode_sess = iscsi_get_flashnode_by_index(shost, idx,
3004 flashnode_match_index);
3006 pr_err("%s could not find flashnode %u for host no %u\n",
3007 __func__, *idx, ev->u.logout_flashnode.host_no);
3012 dev = iscsi_find_flashnode_conn(fnode_sess, NULL,
3013 iscsi_is_flashnode_conn_dev);
3019 fnode_conn = iscsi_dev_to_flash_conn(dev);
3021 err = transport->logout_flashnode(fnode_sess, fnode_conn);
3024 scsi_host_put(shost);
3030 static int iscsi_logout_flashnode_sid(struct iscsi_transport *transport,
3031 struct iscsi_uevent *ev)
3033 struct Scsi_Host *shost;
3034 struct iscsi_cls_session *session;
3037 if (!transport->logout_flashnode_sid) {
3039 goto exit_logout_sid;
3042 shost = scsi_host_lookup(ev->u.logout_flashnode_sid.host_no);
3044 pr_err("%s could not find host no %u\n",
3045 __func__, ev->u.logout_flashnode.host_no);
3050 session = iscsi_session_lookup(ev->u.logout_flashnode_sid.sid);
3052 pr_err("%s could not find session id %u\n",
3053 __func__, ev->u.logout_flashnode_sid.sid);
3058 err = transport->logout_flashnode_sid(session);
3061 scsi_host_put(shost);
3068 iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, uint32_t *group)
3071 struct iscsi_uevent *ev = nlmsg_data(nlh);
3072 struct iscsi_transport *transport = NULL;
3073 struct iscsi_internal *priv;
3074 struct iscsi_cls_session *session;
3075 struct iscsi_cls_conn *conn;
3076 struct iscsi_endpoint *ep = NULL;
3078 if (nlh->nlmsg_type == ISCSI_UEVENT_PATH_UPDATE)
3079 *group = ISCSI_NL_GRP_UIP;
3081 *group = ISCSI_NL_GRP_ISCSID;
3083 priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle));
3086 transport = priv->iscsi_transport;
3088 if (!try_module_get(transport->owner))
3091 switch (nlh->nlmsg_type) {
3092 case ISCSI_UEVENT_CREATE_SESSION:
3093 err = iscsi_if_create_session(priv, ep, ev,
3094 NETLINK_CB(skb).portid,
3095 ev->u.c_session.initial_cmdsn,
3096 ev->u.c_session.cmds_max,
3097 ev->u.c_session.queue_depth);
3099 case ISCSI_UEVENT_CREATE_BOUND_SESSION:
3100 ep = iscsi_lookup_endpoint(ev->u.c_bound_session.ep_handle);
3106 err = iscsi_if_create_session(priv, ep, ev,
3107 NETLINK_CB(skb).portid,
3108 ev->u.c_bound_session.initial_cmdsn,
3109 ev->u.c_bound_session.cmds_max,
3110 ev->u.c_bound_session.queue_depth);
3112 case ISCSI_UEVENT_DESTROY_SESSION:
3113 session = iscsi_session_lookup(ev->u.d_session.sid);
3115 transport->destroy_session(session);
3119 case ISCSI_UEVENT_UNBIND_SESSION:
3120 session = iscsi_session_lookup(ev->u.d_session.sid);
3122 scsi_queue_work(iscsi_session_to_shost(session),
3123 &session->unbind_work);
3127 case ISCSI_UEVENT_CREATE_CONN:
3128 err = iscsi_if_create_conn(transport, ev);
3130 case ISCSI_UEVENT_DESTROY_CONN:
3131 err = iscsi_if_destroy_conn(transport, ev);
3133 case ISCSI_UEVENT_BIND_CONN:
3134 session = iscsi_session_lookup(ev->u.b_conn.sid);
3135 conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid);
3137 if (conn && conn->ep)
3138 iscsi_if_ep_disconnect(transport, conn->ep->id);
3140 if (!session || !conn) {
3145 ev->r.retcode = transport->bind_conn(session, conn,
3146 ev->u.b_conn.transport_eph,
3147 ev->u.b_conn.is_leading);
3148 if (ev->r.retcode || !transport->ep_connect)
3151 ep = iscsi_lookup_endpoint(ev->u.b_conn.transport_eph);
3155 mutex_lock(&conn->ep_mutex);
3157 mutex_unlock(&conn->ep_mutex);
3159 iscsi_cls_conn_printk(KERN_ERR, conn,
3160 "Could not set ep conn "
3163 case ISCSI_UEVENT_SET_PARAM:
3164 err = iscsi_set_param(transport, ev);
3166 case ISCSI_UEVENT_START_CONN:
3167 conn = iscsi_conn_lookup(ev->u.start_conn.sid, ev->u.start_conn.cid);
3169 ev->r.retcode = transport->start_conn(conn);
3173 case ISCSI_UEVENT_STOP_CONN:
3174 conn = iscsi_conn_lookup(ev->u.stop_conn.sid, ev->u.stop_conn.cid);
3176 transport->stop_conn(conn, ev->u.stop_conn.flag);
3180 case ISCSI_UEVENT_SEND_PDU:
3181 conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid);
3183 ev->r.retcode = transport->send_pdu(conn,
3184 (struct iscsi_hdr*)((char*)ev + sizeof(*ev)),
3185 (char*)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,
3186 ev->u.send_pdu.data_size);
3190 case ISCSI_UEVENT_GET_STATS:
3191 err = iscsi_if_get_stats(transport, nlh);
3193 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
3194 case ISCSI_UEVENT_TRANSPORT_EP_POLL:
3195 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
3196 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST:
3197 err = iscsi_if_transport_ep(transport, ev, nlh->nlmsg_type);
3199 case ISCSI_UEVENT_TGT_DSCVR:
3200 err = iscsi_tgt_dscvr(transport, ev);
3202 case ISCSI_UEVENT_SET_HOST_PARAM:
3203 err = iscsi_set_host_param(transport, ev);
3205 case ISCSI_UEVENT_PATH_UPDATE:
3206 err = iscsi_set_path(transport, ev);
3208 case ISCSI_UEVENT_SET_IFACE_PARAMS:
3209 err = iscsi_set_iface_params(transport, ev,
3210 nlmsg_attrlen(nlh, sizeof(*ev)));
3212 case ISCSI_UEVENT_PING:
3213 err = iscsi_send_ping(transport, ev);
3215 case ISCSI_UEVENT_GET_CHAP:
3216 err = iscsi_get_chap(transport, nlh);
3218 case ISCSI_UEVENT_DELETE_CHAP:
3219 err = iscsi_delete_chap(transport, ev);
3221 case ISCSI_UEVENT_SET_FLASHNODE_PARAMS:
3222 err = iscsi_set_flashnode_param(transport, ev,
3226 case ISCSI_UEVENT_NEW_FLASHNODE:
3227 err = iscsi_new_flashnode(transport, ev,
3228 nlmsg_attrlen(nlh, sizeof(*ev)));
3230 case ISCSI_UEVENT_DEL_FLASHNODE:
3231 err = iscsi_del_flashnode(transport, ev);
3233 case ISCSI_UEVENT_LOGIN_FLASHNODE:
3234 err = iscsi_login_flashnode(transport, ev);
3236 case ISCSI_UEVENT_LOGOUT_FLASHNODE:
3237 err = iscsi_logout_flashnode(transport, ev);
3239 case ISCSI_UEVENT_LOGOUT_FLASHNODE_SID:
3240 err = iscsi_logout_flashnode_sid(transport, ev);
3247 module_put(transport->owner);
3252 * Get message from skb. Each message is processed by iscsi_if_recv_msg.
3253 * Malformed skbs with wrong lengths or invalid creds are not processed.
3256 iscsi_if_rx(struct sk_buff *skb)
3258 mutex_lock(&rx_queue_mutex);
3259 while (skb->len >= NLMSG_HDRLEN) {
3262 struct nlmsghdr *nlh;
3263 struct iscsi_uevent *ev;
3266 nlh = nlmsg_hdr(skb);
3267 if (nlh->nlmsg_len < sizeof(*nlh) ||
3268 skb->len < nlh->nlmsg_len) {
3272 ev = nlmsg_data(nlh);
3273 rlen = NLMSG_ALIGN(nlh->nlmsg_len);
3274 if (rlen > skb->len)
3277 err = iscsi_if_recv_msg(skb, nlh, &group);
3279 ev->type = ISCSI_KEVENT_IF_ERROR;
3284 * special case for GET_STATS:
3285 * on success - sending reply and stats from
3286 * inside of if_recv_msg(),
3287 * on error - fall through.
3289 if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
3291 if (ev->type == ISCSI_UEVENT_GET_CHAP && !err)
3293 err = iscsi_if_send_reply(group, nlh->nlmsg_seq,
3294 nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
3295 } while (err < 0 && err != -ECONNREFUSED && err != -ESRCH);
3296 skb_pull(skb, rlen);
3298 mutex_unlock(&rx_queue_mutex);
3301 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \
3302 struct device_attribute dev_attr_##_prefix##_##_name = \
3303 __ATTR(_name,_mode,_show,_store)
3306 * iSCSI connection attrs
3308 #define iscsi_conn_attr_show(param) \
3310 show_conn_param_##param(struct device *dev, \
3311 struct device_attribute *attr, char *buf) \
3313 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
3314 struct iscsi_transport *t = conn->transport; \
3315 return t->get_conn_param(conn, param, buf); \
3318 #define iscsi_conn_attr(field, param) \
3319 iscsi_conn_attr_show(param) \
3320 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param, \
3323 iscsi_conn_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH);
3324 iscsi_conn_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH);
3325 iscsi_conn_attr(header_digest, ISCSI_PARAM_HDRDGST_EN);
3326 iscsi_conn_attr(data_digest, ISCSI_PARAM_DATADGST_EN);
3327 iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN);
3328 iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN);
3329 iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT);
3330 iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN);
3331 iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS);
3332 iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);
3333 iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);
3335 #define iscsi_conn_ep_attr_show(param) \
3336 static ssize_t show_conn_ep_param_##param(struct device *dev, \
3337 struct device_attribute *attr,\
3340 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
3341 struct iscsi_transport *t = conn->transport; \
3342 struct iscsi_endpoint *ep; \
3346 * Need to make sure ep_disconnect does not free the LLD's \
3347 * interconnect resources while we are trying to read them. \
3349 mutex_lock(&conn->ep_mutex); \
3351 if (!ep && t->ep_connect) { \
3352 mutex_unlock(&conn->ep_mutex); \
3357 rc = t->get_ep_param(ep, param, buf); \
3359 rc = t->get_conn_param(conn, param, buf); \
3360 mutex_unlock(&conn->ep_mutex); \
3364 #define iscsi_conn_ep_attr(field, param) \
3365 iscsi_conn_ep_attr_show(param) \
3366 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, \
3367 show_conn_ep_param_##param, NULL);
3369 iscsi_conn_ep_attr(address, ISCSI_PARAM_CONN_ADDRESS);
3370 iscsi_conn_ep_attr(port, ISCSI_PARAM_CONN_PORT);
3372 static struct attribute *iscsi_conn_attrs[] = {
3373 &dev_attr_conn_max_recv_dlength.attr,
3374 &dev_attr_conn_max_xmit_dlength.attr,
3375 &dev_attr_conn_header_digest.attr,
3376 &dev_attr_conn_data_digest.attr,
3377 &dev_attr_conn_ifmarker.attr,
3378 &dev_attr_conn_ofmarker.attr,
3379 &dev_attr_conn_address.attr,
3380 &dev_attr_conn_port.attr,
3381 &dev_attr_conn_exp_statsn.attr,
3382 &dev_attr_conn_persistent_address.attr,
3383 &dev_attr_conn_persistent_port.attr,
3384 &dev_attr_conn_ping_tmo.attr,
3385 &dev_attr_conn_recv_tmo.attr,
3389 static umode_t iscsi_conn_attr_is_visible(struct kobject *kobj,
3390 struct attribute *attr, int i)
3392 struct device *cdev = container_of(kobj, struct device, kobj);
3393 struct iscsi_cls_conn *conn = transport_class_to_conn(cdev);
3394 struct iscsi_transport *t = conn->transport;
3397 if (attr == &dev_attr_conn_max_recv_dlength.attr)
3398 param = ISCSI_PARAM_MAX_RECV_DLENGTH;
3399 else if (attr == &dev_attr_conn_max_xmit_dlength.attr)
3400 param = ISCSI_PARAM_MAX_XMIT_DLENGTH;
3401 else if (attr == &dev_attr_conn_header_digest.attr)
3402 param = ISCSI_PARAM_HDRDGST_EN;
3403 else if (attr == &dev_attr_conn_data_digest.attr)
3404 param = ISCSI_PARAM_DATADGST_EN;
3405 else if (attr == &dev_attr_conn_ifmarker.attr)
3406 param = ISCSI_PARAM_IFMARKER_EN;
3407 else if (attr == &dev_attr_conn_ofmarker.attr)
3408 param = ISCSI_PARAM_OFMARKER_EN;
3409 else if (attr == &dev_attr_conn_address.attr)
3410 param = ISCSI_PARAM_CONN_ADDRESS;
3411 else if (attr == &dev_attr_conn_port.attr)
3412 param = ISCSI_PARAM_CONN_PORT;
3413 else if (attr == &dev_attr_conn_exp_statsn.attr)
3414 param = ISCSI_PARAM_EXP_STATSN;
3415 else if (attr == &dev_attr_conn_persistent_address.attr)
3416 param = ISCSI_PARAM_PERSISTENT_ADDRESS;
3417 else if (attr == &dev_attr_conn_persistent_port.attr)
3418 param = ISCSI_PARAM_PERSISTENT_PORT;
3419 else if (attr == &dev_attr_conn_ping_tmo.attr)
3420 param = ISCSI_PARAM_PING_TMO;
3421 else if (attr == &dev_attr_conn_recv_tmo.attr)
3422 param = ISCSI_PARAM_RECV_TMO;
3424 WARN_ONCE(1, "Invalid conn attr");
3428 return t->attr_is_visible(ISCSI_PARAM, param);
3431 static struct attribute_group iscsi_conn_group = {
3432 .attrs = iscsi_conn_attrs,
3433 .is_visible = iscsi_conn_attr_is_visible,
3437 * iSCSI session attrs
3439 #define iscsi_session_attr_show(param, perm) \
3441 show_session_param_##param(struct device *dev, \
3442 struct device_attribute *attr, char *buf) \
3444 struct iscsi_cls_session *session = \
3445 iscsi_dev_to_session(dev->parent); \
3446 struct iscsi_transport *t = session->transport; \
3448 if (perm && !capable(CAP_SYS_ADMIN)) \
3450 return t->get_session_param(session, param, buf); \
3453 #define iscsi_session_attr(field, param, perm) \
3454 iscsi_session_attr_show(param, perm) \
3455 static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
3457 iscsi_session_attr(targetname, ISCSI_PARAM_TARGET_NAME, 0);
3458 iscsi_session_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN, 0);
3459 iscsi_session_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T, 0);
3460 iscsi_session_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN, 0);
3461 iscsi_session_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST, 0);
3462 iscsi_session_attr(max_burst_len, ISCSI_PARAM_MAX_BURST, 0);
3463 iscsi_session_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN, 0);
3464 iscsi_session_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN, 0);
3465 iscsi_session_attr(erl, ISCSI_PARAM_ERL, 0);
3466 iscsi_session_attr(tpgt, ISCSI_PARAM_TPGT, 0);
3467 iscsi_session_attr(username, ISCSI_PARAM_USERNAME, 1);
3468 iscsi_session_attr(username_in, ISCSI_PARAM_USERNAME_IN, 1);
3469 iscsi_session_attr(password, ISCSI_PARAM_PASSWORD, 1);
3470 iscsi_session_attr(password_in, ISCSI_PARAM_PASSWORD_IN, 1);
3471 iscsi_session_attr(chap_out_idx, ISCSI_PARAM_CHAP_OUT_IDX, 1);
3472 iscsi_session_attr(chap_in_idx, ISCSI_PARAM_CHAP_IN_IDX, 1);
3473 iscsi_session_attr(fast_abort, ISCSI_PARAM_FAST_ABORT, 0);
3474 iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0);
3475 iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0);
3476 iscsi_session_attr(tgt_reset_tmo, ISCSI_PARAM_TGT_RESET_TMO, 0);
3477 iscsi_session_attr(ifacename, ISCSI_PARAM_IFACE_NAME, 0);
3478 iscsi_session_attr(initiatorname, ISCSI_PARAM_INITIATOR_NAME, 0);
3479 iscsi_session_attr(targetalias, ISCSI_PARAM_TARGET_ALIAS, 0);
3482 show_priv_session_state(struct device *dev, struct device_attribute *attr,
3485 struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
3486 return sprintf(buf, "%s\n", iscsi_session_state_name(session->state));
3488 static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
3491 show_priv_session_creator(struct device *dev, struct device_attribute *attr,
3494 struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
3495 return sprintf(buf, "%d\n", session->creator);
3497 static ISCSI_CLASS_ATTR(priv_sess, creator, S_IRUGO, show_priv_session_creator,
3500 show_priv_session_target_id(struct device *dev, struct device_attribute *attr,
3503 struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
3504 return sprintf(buf, "%d\n", session->target_id);
3506 static ISCSI_CLASS_ATTR(priv_sess, target_id, S_IRUGO,
3507 show_priv_session_target_id, NULL);
3509 #define iscsi_priv_session_attr_show(field, format) \
3511 show_priv_session_##field(struct device *dev, \
3512 struct device_attribute *attr, char *buf) \
3514 struct iscsi_cls_session *session = \
3515 iscsi_dev_to_session(dev->parent); \
3516 if (session->field == -1) \
3517 return sprintf(buf, "off\n"); \
3518 return sprintf(buf, format"\n", session->field); \
3521 #define iscsi_priv_session_attr_store(field) \
3523 store_priv_session_##field(struct device *dev, \
3524 struct device_attribute *attr, \
3525 const char *buf, size_t count) \
3529 struct iscsi_cls_session *session = \
3530 iscsi_dev_to_session(dev->parent); \
3531 if ((session->state == ISCSI_SESSION_FREE) || \
3532 (session->state == ISCSI_SESSION_FAILED)) \
3534 if (strncmp(buf, "off", 3) == 0) \
3535 session->field = -1; \
3537 val = simple_strtoul(buf, &cp, 0); \
3538 if (*cp != '\0' && *cp != '\n') \
3540 session->field = val; \
3545 #define iscsi_priv_session_rw_attr(field, format) \
3546 iscsi_priv_session_attr_show(field, format) \
3547 iscsi_priv_session_attr_store(field) \
3548 static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO | S_IWUSR, \
3549 show_priv_session_##field, \
3550 store_priv_session_##field)
3551 iscsi_priv_session_rw_attr(recovery_tmo, "%d");
3553 static struct attribute *iscsi_session_attrs[] = {
3554 &dev_attr_sess_initial_r2t.attr,
3555 &dev_attr_sess_max_outstanding_r2t.attr,
3556 &dev_attr_sess_immediate_data.attr,
3557 &dev_attr_sess_first_burst_len.attr,
3558 &dev_attr_sess_max_burst_len.attr,
3559 &dev_attr_sess_data_pdu_in_order.attr,
3560 &dev_attr_sess_data_seq_in_order.attr,
3561 &dev_attr_sess_erl.attr,
3562 &dev_attr_sess_targetname.attr,
3563 &dev_attr_sess_tpgt.attr,
3564 &dev_attr_sess_password.attr,
3565 &dev_attr_sess_password_in.attr,
3566 &dev_attr_sess_username.attr,
3567 &dev_attr_sess_username_in.attr,
3568 &dev_attr_sess_fast_abort.attr,
3569 &dev_attr_sess_abort_tmo.attr,
3570 &dev_attr_sess_lu_reset_tmo.attr,
3571 &dev_attr_sess_tgt_reset_tmo.attr,
3572 &dev_attr_sess_ifacename.attr,
3573 &dev_attr_sess_initiatorname.attr,
3574 &dev_attr_sess_targetalias.attr,
3575 &dev_attr_priv_sess_recovery_tmo.attr,
3576 &dev_attr_priv_sess_state.attr,
3577 &dev_attr_priv_sess_creator.attr,
3578 &dev_attr_sess_chap_out_idx.attr,
3579 &dev_attr_sess_chap_in_idx.attr,
3580 &dev_attr_priv_sess_target_id.attr,
3584 static umode_t iscsi_session_attr_is_visible(struct kobject *kobj,
3585 struct attribute *attr, int i)
3587 struct device *cdev = container_of(kobj, struct device, kobj);
3588 struct iscsi_cls_session *session = transport_class_to_session(cdev);
3589 struct iscsi_transport *t = session->transport;
3592 if (attr == &dev_attr_sess_initial_r2t.attr)
3593 param = ISCSI_PARAM_INITIAL_R2T_EN;
3594 else if (attr == &dev_attr_sess_max_outstanding_r2t.attr)
3595 param = ISCSI_PARAM_MAX_R2T;
3596 else if (attr == &dev_attr_sess_immediate_data.attr)
3597 param = ISCSI_PARAM_IMM_DATA_EN;
3598 else if (attr == &dev_attr_sess_first_burst_len.attr)
3599 param = ISCSI_PARAM_FIRST_BURST;
3600 else if (attr == &dev_attr_sess_max_burst_len.attr)
3601 param = ISCSI_PARAM_MAX_BURST;
3602 else if (attr == &dev_attr_sess_data_pdu_in_order.attr)
3603 param = ISCSI_PARAM_PDU_INORDER_EN;
3604 else if (attr == &dev_attr_sess_data_seq_in_order.attr)
3605 param = ISCSI_PARAM_DATASEQ_INORDER_EN;
3606 else if (attr == &dev_attr_sess_erl.attr)
3607 param = ISCSI_PARAM_ERL;
3608 else if (attr == &dev_attr_sess_targetname.attr)
3609 param = ISCSI_PARAM_TARGET_NAME;
3610 else if (attr == &dev_attr_sess_tpgt.attr)
3611 param = ISCSI_PARAM_TPGT;
3612 else if (attr == &dev_attr_sess_chap_in_idx.attr)
3613 param = ISCSI_PARAM_CHAP_IN_IDX;
3614 else if (attr == &dev_attr_sess_chap_out_idx.attr)
3615 param = ISCSI_PARAM_CHAP_OUT_IDX;
3616 else if (attr == &dev_attr_sess_password.attr)
3617 param = ISCSI_PARAM_USERNAME;
3618 else if (attr == &dev_attr_sess_password_in.attr)
3619 param = ISCSI_PARAM_USERNAME_IN;
3620 else if (attr == &dev_attr_sess_username.attr)
3621 param = ISCSI_PARAM_PASSWORD;
3622 else if (attr == &dev_attr_sess_username_in.attr)
3623 param = ISCSI_PARAM_PASSWORD_IN;
3624 else if (attr == &dev_attr_sess_fast_abort.attr)
3625 param = ISCSI_PARAM_FAST_ABORT;
3626 else if (attr == &dev_attr_sess_abort_tmo.attr)
3627 param = ISCSI_PARAM_ABORT_TMO;
3628 else if (attr == &dev_attr_sess_lu_reset_tmo.attr)
3629 param = ISCSI_PARAM_LU_RESET_TMO;
3630 else if (attr == &dev_attr_sess_tgt_reset_tmo.attr)
3631 param = ISCSI_PARAM_TGT_RESET_TMO;
3632 else if (attr == &dev_attr_sess_ifacename.attr)
3633 param = ISCSI_PARAM_IFACE_NAME;
3634 else if (attr == &dev_attr_sess_initiatorname.attr)
3635 param = ISCSI_PARAM_INITIATOR_NAME;
3636 else if (attr == &dev_attr_sess_targetalias.attr)
3637 param = ISCSI_PARAM_TARGET_ALIAS;
3638 else if (attr == &dev_attr_priv_sess_recovery_tmo.attr)
3639 return S_IRUGO | S_IWUSR;
3640 else if (attr == &dev_attr_priv_sess_state.attr)
3642 else if (attr == &dev_attr_priv_sess_creator.attr)
3644 else if (attr == &dev_attr_priv_sess_target_id.attr)
3647 WARN_ONCE(1, "Invalid session attr");
3651 return t->attr_is_visible(ISCSI_PARAM, param);
3654 static struct attribute_group iscsi_session_group = {
3655 .attrs = iscsi_session_attrs,
3656 .is_visible = iscsi_session_attr_is_visible,
3662 #define iscsi_host_attr_show(param) \
3664 show_host_param_##param(struct device *dev, \
3665 struct device_attribute *attr, char *buf) \
3667 struct Scsi_Host *shost = transport_class_to_shost(dev); \
3668 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
3669 return priv->iscsi_transport->get_host_param(shost, param, buf); \
3672 #define iscsi_host_attr(field, param) \
3673 iscsi_host_attr_show(param) \
3674 static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param, \
3677 iscsi_host_attr(netdev, ISCSI_HOST_PARAM_NETDEV_NAME);
3678 iscsi_host_attr(hwaddress, ISCSI_HOST_PARAM_HWADDRESS);
3679 iscsi_host_attr(ipaddress, ISCSI_HOST_PARAM_IPADDRESS);
3680 iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME);
3681 iscsi_host_attr(port_state, ISCSI_HOST_PARAM_PORT_STATE);
3682 iscsi_host_attr(port_speed, ISCSI_HOST_PARAM_PORT_SPEED);
3684 static struct attribute *iscsi_host_attrs[] = {
3685 &dev_attr_host_netdev.attr,
3686 &dev_attr_host_hwaddress.attr,
3687 &dev_attr_host_ipaddress.attr,
3688 &dev_attr_host_initiatorname.attr,
3689 &dev_attr_host_port_state.attr,
3690 &dev_attr_host_port_speed.attr,
3694 static umode_t iscsi_host_attr_is_visible(struct kobject *kobj,
3695 struct attribute *attr, int i)
3697 struct device *cdev = container_of(kobj, struct device, kobj);
3698 struct Scsi_Host *shost = transport_class_to_shost(cdev);
3699 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt);
3702 if (attr == &dev_attr_host_netdev.attr)
3703 param = ISCSI_HOST_PARAM_NETDEV_NAME;
3704 else if (attr == &dev_attr_host_hwaddress.attr)
3705 param = ISCSI_HOST_PARAM_HWADDRESS;
3706 else if (attr == &dev_attr_host_ipaddress.attr)
3707 param = ISCSI_HOST_PARAM_IPADDRESS;
3708 else if (attr == &dev_attr_host_initiatorname.attr)
3709 param = ISCSI_HOST_PARAM_INITIATOR_NAME;
3710 else if (attr == &dev_attr_host_port_state.attr)
3711 param = ISCSI_HOST_PARAM_PORT_STATE;
3712 else if (attr == &dev_attr_host_port_speed.attr)
3713 param = ISCSI_HOST_PARAM_PORT_SPEED;
3715 WARN_ONCE(1, "Invalid host attr");
3719 return priv->iscsi_transport->attr_is_visible(ISCSI_HOST_PARAM, param);
3722 static struct attribute_group iscsi_host_group = {
3723 .attrs = iscsi_host_attrs,
3724 .is_visible = iscsi_host_attr_is_visible,
3727 /* convert iscsi_port_speed values to ascii string name */
3728 static const struct {
3729 enum iscsi_port_speed value;
3731 } iscsi_port_speed_names[] = {
3732 {ISCSI_PORT_SPEED_UNKNOWN, "Unknown" },
3733 {ISCSI_PORT_SPEED_10MBPS, "10 Mbps" },
3734 {ISCSI_PORT_SPEED_100MBPS, "100 Mbps" },
3735 {ISCSI_PORT_SPEED_1GBPS, "1 Gbps" },
3736 {ISCSI_PORT_SPEED_10GBPS, "10 Gbps" },
3739 char *iscsi_get_port_speed_name(struct Scsi_Host *shost)
3742 char *speed = "Unknown!";
3743 struct iscsi_cls_host *ihost = shost->shost_data;
3744 uint32_t port_speed = ihost->port_speed;
3746 for (i = 0; i < ARRAY_SIZE(iscsi_port_speed_names); i++) {
3747 if (iscsi_port_speed_names[i].value & port_speed) {
3748 speed = iscsi_port_speed_names[i].name;
3754 EXPORT_SYMBOL_GPL(iscsi_get_port_speed_name);
3756 /* convert iscsi_port_state values to ascii string name */
3757 static const struct {
3758 enum iscsi_port_state value;
3760 } iscsi_port_state_names[] = {
3761 {ISCSI_PORT_STATE_DOWN, "LINK DOWN" },
3762 {ISCSI_PORT_STATE_UP, "LINK UP" },
3765 char *iscsi_get_port_state_name(struct Scsi_Host *shost)
3768 char *state = "Unknown!";
3769 struct iscsi_cls_host *ihost = shost->shost_data;
3770 uint32_t port_state = ihost->port_state;
3772 for (i = 0; i < ARRAY_SIZE(iscsi_port_state_names); i++) {
3773 if (iscsi_port_state_names[i].value & port_state) {
3774 state = iscsi_port_state_names[i].name;
3780 EXPORT_SYMBOL_GPL(iscsi_get_port_state_name);
3782 static int iscsi_session_match(struct attribute_container *cont,
3785 struct iscsi_cls_session *session;
3786 struct Scsi_Host *shost;
3787 struct iscsi_internal *priv;
3789 if (!iscsi_is_session_dev(dev))
3792 session = iscsi_dev_to_session(dev);
3793 shost = iscsi_session_to_shost(session);
3794 if (!shost->transportt)
3797 priv = to_iscsi_internal(shost->transportt);
3798 if (priv->session_cont.ac.class != &iscsi_session_class.class)
3801 return &priv->session_cont.ac == cont;
3804 static int iscsi_conn_match(struct attribute_container *cont,
3807 struct iscsi_cls_session *session;
3808 struct iscsi_cls_conn *conn;
3809 struct Scsi_Host *shost;
3810 struct iscsi_internal *priv;
3812 if (!iscsi_is_conn_dev(dev))
3815 conn = iscsi_dev_to_conn(dev);
3816 session = iscsi_dev_to_session(conn->dev.parent);
3817 shost = iscsi_session_to_shost(session);
3819 if (!shost->transportt)
3822 priv = to_iscsi_internal(shost->transportt);
3823 if (priv->conn_cont.ac.class != &iscsi_connection_class.class)
3826 return &priv->conn_cont.ac == cont;
3829 static int iscsi_host_match(struct attribute_container *cont,
3832 struct Scsi_Host *shost;
3833 struct iscsi_internal *priv;
3835 if (!scsi_is_host_device(dev))
3838 shost = dev_to_shost(dev);
3839 if (!shost->transportt ||
3840 shost->transportt->host_attrs.ac.class != &iscsi_host_class.class)
3843 priv = to_iscsi_internal(shost->transportt);
3844 return &priv->t.host_attrs.ac == cont;
3847 struct scsi_transport_template *
3848 iscsi_register_transport(struct iscsi_transport *tt)
3850 struct iscsi_internal *priv;
3851 unsigned long flags;
3856 priv = iscsi_if_transport_lookup(tt);
3860 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
3863 INIT_LIST_HEAD(&priv->list);
3864 priv->iscsi_transport = tt;
3865 priv->t.user_scan = iscsi_user_scan;
3866 priv->t.create_work_queue = 1;
3868 priv->dev.class = &iscsi_transport_class;
3869 dev_set_name(&priv->dev, "%s", tt->name);
3870 err = device_register(&priv->dev);
3874 err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group);
3876 goto unregister_dev;
3878 /* host parameters */
3879 priv->t.host_attrs.ac.class = &iscsi_host_class.class;
3880 priv->t.host_attrs.ac.match = iscsi_host_match;
3881 priv->t.host_attrs.ac.grp = &iscsi_host_group;
3882 priv->t.host_size = sizeof(struct iscsi_cls_host);
3883 transport_container_register(&priv->t.host_attrs);
3885 /* connection parameters */
3886 priv->conn_cont.ac.class = &iscsi_connection_class.class;
3887 priv->conn_cont.ac.match = iscsi_conn_match;
3888 priv->conn_cont.ac.grp = &iscsi_conn_group;
3889 transport_container_register(&priv->conn_cont);
3891 /* session parameters */
3892 priv->session_cont.ac.class = &iscsi_session_class.class;
3893 priv->session_cont.ac.match = iscsi_session_match;
3894 priv->session_cont.ac.grp = &iscsi_session_group;
3895 transport_container_register(&priv->session_cont);
3897 spin_lock_irqsave(&iscsi_transport_lock, flags);
3898 list_add(&priv->list, &iscsi_transports);
3899 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
3901 printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
3905 device_unregister(&priv->dev);
3911 EXPORT_SYMBOL_GPL(iscsi_register_transport);
3913 int iscsi_unregister_transport(struct iscsi_transport *tt)
3915 struct iscsi_internal *priv;
3916 unsigned long flags;
3920 mutex_lock(&rx_queue_mutex);
3922 priv = iscsi_if_transport_lookup(tt);
3925 spin_lock_irqsave(&iscsi_transport_lock, flags);
3926 list_del(&priv->list);
3927 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
3929 transport_container_unregister(&priv->conn_cont);
3930 transport_container_unregister(&priv->session_cont);
3931 transport_container_unregister(&priv->t.host_attrs);
3933 sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group);
3934 device_unregister(&priv->dev);
3935 mutex_unlock(&rx_queue_mutex);
3939 EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
3941 static __init int iscsi_transport_init(void)
3944 struct netlink_kernel_cfg cfg = {
3946 .input = iscsi_if_rx,
3948 printk(KERN_INFO "Loading iSCSI transport class v%s.\n",
3949 ISCSI_TRANSPORT_VERSION);
3951 atomic_set(&iscsi_session_nr, 0);
3953 err = class_register(&iscsi_transport_class);
3957 err = class_register(&iscsi_endpoint_class);
3959 goto unregister_transport_class;
3961 err = class_register(&iscsi_iface_class);
3963 goto unregister_endpoint_class;
3965 err = transport_class_register(&iscsi_host_class);
3967 goto unregister_iface_class;
3969 err = transport_class_register(&iscsi_connection_class);
3971 goto unregister_host_class;
3973 err = transport_class_register(&iscsi_session_class);
3975 goto unregister_conn_class;
3977 err = bus_register(&iscsi_flashnode_bus);
3979 goto unregister_session_class;
3981 nls = netlink_kernel_create(&init_net, NETLINK_ISCSI, &cfg);
3984 goto unregister_flashnode_bus;
3987 iscsi_eh_timer_workq = create_singlethread_workqueue("iscsi_eh");
3988 if (!iscsi_eh_timer_workq)
3994 netlink_kernel_release(nls);
3995 unregister_flashnode_bus:
3996 bus_unregister(&iscsi_flashnode_bus);
3997 unregister_session_class:
3998 transport_class_unregister(&iscsi_session_class);
3999 unregister_conn_class:
4000 transport_class_unregister(&iscsi_connection_class);
4001 unregister_host_class:
4002 transport_class_unregister(&iscsi_host_class);
4003 unregister_iface_class:
4004 class_unregister(&iscsi_iface_class);
4005 unregister_endpoint_class:
4006 class_unregister(&iscsi_endpoint_class);
4007 unregister_transport_class:
4008 class_unregister(&iscsi_transport_class);
4012 static void __exit iscsi_transport_exit(void)
4014 destroy_workqueue(iscsi_eh_timer_workq);
4015 netlink_kernel_release(nls);
4016 bus_unregister(&iscsi_flashnode_bus);
4017 transport_class_unregister(&iscsi_connection_class);
4018 transport_class_unregister(&iscsi_session_class);
4019 transport_class_unregister(&iscsi_host_class);
4020 class_unregister(&iscsi_endpoint_class);
4021 class_unregister(&iscsi_iface_class);
4022 class_unregister(&iscsi_transport_class);
4025 module_init(iscsi_transport_init);
4026 module_exit(iscsi_transport_exit);
4028 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
4029 "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
4030 "Alex Aizman <itn780@yahoo.com>");
4031 MODULE_DESCRIPTION("iSCSI Transport Interface");
4032 MODULE_LICENSE("GPL");
4033 MODULE_VERSION(ISCSI_TRANSPORT_VERSION);
4034 MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_ISCSI);