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>
26 #include <scsi/scsi.h>
27 #include <scsi/scsi_host.h>
28 #include <scsi/scsi_device.h>
29 #include <scsi/scsi_transport.h>
30 #include <scsi/scsi_transport_iscsi.h>
31 #include <scsi/iscsi_if.h>
33 #define ISCSI_SESSION_ATTRS 19
34 #define ISCSI_CONN_ATTRS 13
35 #define ISCSI_HOST_ATTRS 4
36 #define ISCSI_TRANSPORT_VERSION "2.0-867"
38 struct iscsi_internal {
40 struct scsi_transport_template t;
41 struct iscsi_transport *iscsi_transport;
42 struct list_head list;
43 struct class_device cdev;
45 struct class_device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
46 struct transport_container conn_cont;
47 struct class_device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1];
48 struct transport_container session_cont;
49 struct class_device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
52 static atomic_t iscsi_session_nr; /* sysfs session id for next new session */
53 static struct workqueue_struct *iscsi_eh_timer_workq;
56 * list of registered transports and lock that must
57 * be held while accessing list. The iscsi_transport_lock must
58 * be acquired after the rx_queue_mutex.
60 static LIST_HEAD(iscsi_transports);
61 static DEFINE_SPINLOCK(iscsi_transport_lock);
63 #define to_iscsi_internal(tmpl) \
64 container_of(tmpl, struct iscsi_internal, t)
66 #define cdev_to_iscsi_internal(_cdev) \
67 container_of(_cdev, struct iscsi_internal, cdev)
69 static void iscsi_transport_release(struct class_device *cdev)
71 struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
76 * iscsi_transport_class represents the iscsi_transports that are
79 static struct class iscsi_transport_class = {
80 .name = "iscsi_transport",
81 .release = iscsi_transport_release,
85 show_transport_handle(struct class_device *cdev, char *buf)
87 struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
88 return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
90 static CLASS_DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
92 #define show_transport_attr(name, format) \
94 show_transport_##name(struct class_device *cdev, char *buf) \
96 struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev); \
97 return sprintf(buf, format"\n", priv->iscsi_transport->name); \
99 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
101 show_transport_attr(caps, "0x%x");
102 show_transport_attr(max_lun, "%d");
103 show_transport_attr(max_conn, "%d");
104 show_transport_attr(max_cmd_len, "%d");
106 static struct attribute *iscsi_transport_attrs[] = {
107 &class_device_attr_handle.attr,
108 &class_device_attr_caps.attr,
109 &class_device_attr_max_lun.attr,
110 &class_device_attr_max_conn.attr,
111 &class_device_attr_max_cmd_len.attr,
115 static struct attribute_group iscsi_transport_group = {
116 .attrs = iscsi_transport_attrs,
121 static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
122 struct class_device *cdev)
124 struct Scsi_Host *shost = dev_to_shost(dev);
125 struct iscsi_host *ihost = shost->shost_data;
127 memset(ihost, 0, sizeof(*ihost));
128 INIT_LIST_HEAD(&ihost->sessions);
129 mutex_init(&ihost->mutex);
130 atomic_set(&ihost->nr_scans, 0);
132 snprintf(ihost->scan_workq_name, KOBJ_NAME_LEN, "iscsi_scan_%d",
134 ihost->scan_workq = create_singlethread_workqueue(
135 ihost->scan_workq_name);
136 if (!ihost->scan_workq)
141 static int iscsi_remove_host(struct transport_container *tc, struct device *dev,
142 struct class_device *cdev)
144 struct Scsi_Host *shost = dev_to_shost(dev);
145 struct iscsi_host *ihost = shost->shost_data;
147 destroy_workqueue(ihost->scan_workq);
151 static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
157 static DECLARE_TRANSPORT_CLASS(iscsi_session_class,
163 static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
169 static struct sock *nls;
170 static DEFINE_MUTEX(rx_queue_mutex);
172 static LIST_HEAD(sesslist);
173 static DEFINE_SPINLOCK(sesslock);
174 static LIST_HEAD(connlist);
175 static DEFINE_SPINLOCK(connlock);
177 static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn *conn)
179 struct iscsi_cls_session *sess = iscsi_dev_to_session(conn->dev.parent);
184 * Returns the matching session to a given sid
186 static struct iscsi_cls_session *iscsi_session_lookup(uint32_t sid)
189 struct iscsi_cls_session *sess;
191 spin_lock_irqsave(&sesslock, flags);
192 list_for_each_entry(sess, &sesslist, sess_list) {
193 if (sess->sid == sid) {
194 spin_unlock_irqrestore(&sesslock, flags);
198 spin_unlock_irqrestore(&sesslock, flags);
203 * Returns the matching connection to a given sid / cid tuple
205 static struct iscsi_cls_conn *iscsi_conn_lookup(uint32_t sid, uint32_t cid)
208 struct iscsi_cls_conn *conn;
210 spin_lock_irqsave(&connlock, flags);
211 list_for_each_entry(conn, &connlist, conn_list) {
212 if ((conn->cid == cid) && (iscsi_conn_get_sid(conn) == sid)) {
213 spin_unlock_irqrestore(&connlock, flags);
217 spin_unlock_irqrestore(&connlock, flags);
222 * The following functions can be used by LLDs that allocate
223 * their own scsi_hosts or by software iscsi LLDs
228 } iscsi_session_state_names[] = {
229 { ISCSI_SESSION_LOGGED_IN, "LOGGED_IN" },
230 { ISCSI_SESSION_FAILED, "FAILED" },
231 { ISCSI_SESSION_FREE, "FREE" },
234 const char *iscsi_session_state_name(int state)
239 for (i = 0; i < ARRAY_SIZE(iscsi_session_state_names); i++) {
240 if (iscsi_session_state_names[i].value == state) {
241 name = iscsi_session_state_names[i].name;
248 int iscsi_session_chkready(struct iscsi_cls_session *session)
253 spin_lock_irqsave(&session->lock, flags);
254 switch (session->state) {
255 case ISCSI_SESSION_LOGGED_IN:
258 case ISCSI_SESSION_FAILED:
259 err = DID_IMM_RETRY << 16;
261 case ISCSI_SESSION_FREE:
262 err = DID_NO_CONNECT << 16;
265 err = DID_NO_CONNECT << 16;
268 spin_unlock_irqrestore(&session->lock, flags);
271 EXPORT_SYMBOL_GPL(iscsi_session_chkready);
273 static void iscsi_session_release(struct device *dev)
275 struct iscsi_cls_session *session = iscsi_dev_to_session(dev);
276 struct Scsi_Host *shost;
278 shost = iscsi_session_to_shost(session);
279 scsi_host_put(shost);
283 static int iscsi_is_session_dev(const struct device *dev)
285 return dev->release == iscsi_session_release;
289 * iscsi_scan_finished - helper to report when running scans are done
291 * @time: scan run time
293 * This function can be used by drives like qla4xxx to report to the scsi
294 * layer when the scans it kicked off at module load time are done.
296 int iscsi_scan_finished(struct Scsi_Host *shost, unsigned long time)
298 struct iscsi_host *ihost = shost->shost_data;
300 * qla4xxx will have kicked off some session unblocks before calling
301 * scsi_scan_host, so just wait for them to complete.
303 return !atomic_read(&ihost->nr_scans);
305 EXPORT_SYMBOL_GPL(iscsi_scan_finished);
307 static int iscsi_user_scan(struct Scsi_Host *shost, uint channel,
310 struct iscsi_host *ihost = shost->shost_data;
311 struct iscsi_cls_session *session;
313 mutex_lock(&ihost->mutex);
314 list_for_each_entry(session, &ihost->sessions, host_list) {
315 if ((channel == SCAN_WILD_CARD || channel == 0) &&
316 (id == SCAN_WILD_CARD || id == session->target_id))
317 scsi_scan_target(&session->dev, 0,
318 session->target_id, lun, 1);
320 mutex_unlock(&ihost->mutex);
325 static void iscsi_scan_session(struct work_struct *work)
327 struct iscsi_cls_session *session =
328 container_of(work, struct iscsi_cls_session, scan_work);
329 struct Scsi_Host *shost = iscsi_session_to_shost(session);
330 struct iscsi_host *ihost = shost->shost_data;
333 spin_lock_irqsave(&session->lock, flags);
334 if (session->state != ISCSI_SESSION_LOGGED_IN) {
335 spin_unlock_irqrestore(&session->lock, flags);
338 spin_unlock_irqrestore(&session->lock, flags);
340 scsi_scan_target(&session->dev, 0, session->target_id,
343 atomic_dec(&ihost->nr_scans);
346 static void session_recovery_timedout(struct work_struct *work)
348 struct iscsi_cls_session *session =
349 container_of(work, struct iscsi_cls_session,
353 dev_printk(KERN_INFO, &session->dev, "iscsi: session recovery timed "
354 "out after %d secs\n", session->recovery_tmo);
356 spin_lock_irqsave(&session->lock, flags);
357 switch (session->state) {
358 case ISCSI_SESSION_FAILED:
359 session->state = ISCSI_SESSION_FREE;
361 case ISCSI_SESSION_LOGGED_IN:
362 case ISCSI_SESSION_FREE:
363 /* we raced with the unblock's flush */
364 spin_unlock_irqrestore(&session->lock, flags);
367 spin_unlock_irqrestore(&session->lock, flags);
369 if (session->transport->session_recovery_timedout)
370 session->transport->session_recovery_timedout(session);
372 scsi_target_unblock(&session->dev);
375 void __iscsi_unblock_session(struct iscsi_cls_session *session)
377 if (!cancel_delayed_work(&session->recovery_work))
378 flush_workqueue(iscsi_eh_timer_workq);
379 scsi_target_unblock(&session->dev);
382 void iscsi_unblock_session(struct iscsi_cls_session *session)
384 struct Scsi_Host *shost = iscsi_session_to_shost(session);
385 struct iscsi_host *ihost = shost->shost_data;
388 spin_lock_irqsave(&session->lock, flags);
389 session->state = ISCSI_SESSION_LOGGED_IN;
390 spin_unlock_irqrestore(&session->lock, flags);
392 __iscsi_unblock_session(session);
394 * Only do kernel scanning if the driver is properly hooked into
395 * the async scanning code (drivers like iscsi_tcp do login and
396 * scanning from userspace).
398 if (shost->hostt->scan_finished) {
399 if (queue_work(ihost->scan_workq, &session->scan_work))
400 atomic_inc(&ihost->nr_scans);
403 EXPORT_SYMBOL_GPL(iscsi_unblock_session);
405 void iscsi_block_session(struct iscsi_cls_session *session)
409 spin_lock_irqsave(&session->lock, flags);
410 session->state = ISCSI_SESSION_FAILED;
411 spin_unlock_irqrestore(&session->lock, flags);
413 scsi_target_block(&session->dev);
414 queue_delayed_work(iscsi_eh_timer_workq, &session->recovery_work,
415 session->recovery_tmo * HZ);
417 EXPORT_SYMBOL_GPL(iscsi_block_session);
419 static void __iscsi_unbind_session(struct work_struct *work)
421 struct iscsi_cls_session *session =
422 container_of(work, struct iscsi_cls_session,
424 struct Scsi_Host *shost = iscsi_session_to_shost(session);
425 struct iscsi_host *ihost = shost->shost_data;
427 /* Prevent new scans and make sure scanning is not in progress */
428 mutex_lock(&ihost->mutex);
429 if (list_empty(&session->host_list)) {
430 mutex_unlock(&ihost->mutex);
433 list_del_init(&session->host_list);
434 mutex_unlock(&ihost->mutex);
436 scsi_remove_target(&session->dev);
437 iscsi_session_event(session, ISCSI_KEVENT_UNBIND_SESSION);
440 static int iscsi_unbind_session(struct iscsi_cls_session *session)
442 struct Scsi_Host *shost = iscsi_session_to_shost(session);
443 struct iscsi_host *ihost = shost->shost_data;
445 return queue_work(ihost->scan_workq, &session->unbind_work);
448 struct iscsi_cls_session *
449 iscsi_alloc_session(struct Scsi_Host *shost,
450 struct iscsi_transport *transport)
452 struct iscsi_cls_session *session;
454 session = kzalloc(sizeof(*session) + transport->sessiondata_size,
459 session->transport = transport;
460 session->recovery_tmo = 120;
461 session->state = ISCSI_SESSION_FREE;
462 INIT_DELAYED_WORK(&session->recovery_work, session_recovery_timedout);
463 INIT_LIST_HEAD(&session->host_list);
464 INIT_LIST_HEAD(&session->sess_list);
465 INIT_WORK(&session->unbind_work, __iscsi_unbind_session);
466 INIT_WORK(&session->scan_work, iscsi_scan_session);
467 spin_lock_init(&session->lock);
469 /* this is released in the dev's release function */
470 scsi_host_get(shost);
471 session->dev.parent = &shost->shost_gendev;
472 session->dev.release = iscsi_session_release;
473 device_initialize(&session->dev);
474 if (transport->sessiondata_size)
475 session->dd_data = &session[1];
478 EXPORT_SYMBOL_GPL(iscsi_alloc_session);
480 int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id)
482 struct Scsi_Host *shost = iscsi_session_to_shost(session);
483 struct iscsi_host *ihost;
487 ihost = shost->shost_data;
488 session->sid = atomic_add_return(1, &iscsi_session_nr);
489 session->target_id = target_id;
491 snprintf(session->dev.bus_id, BUS_ID_SIZE, "session%u",
493 err = device_add(&session->dev);
495 dev_printk(KERN_ERR, &session->dev, "iscsi: could not "
496 "register session's dev\n");
499 transport_register_device(&session->dev);
501 spin_lock_irqsave(&sesslock, flags);
502 list_add(&session->sess_list, &sesslist);
503 spin_unlock_irqrestore(&sesslock, flags);
505 mutex_lock(&ihost->mutex);
506 list_add(&session->host_list, &ihost->sessions);
507 mutex_unlock(&ihost->mutex);
509 iscsi_session_event(session, ISCSI_KEVENT_CREATE_SESSION);
513 scsi_host_put(shost);
516 EXPORT_SYMBOL_GPL(iscsi_add_session);
519 * iscsi_create_session - create iscsi class session
521 * @transport: iscsi transport
522 * @target_id: which target
524 * This can be called from a LLD or iscsi_transport.
526 struct iscsi_cls_session *
527 iscsi_create_session(struct Scsi_Host *shost,
528 struct iscsi_transport *transport,
529 unsigned int target_id)
531 struct iscsi_cls_session *session;
533 session = iscsi_alloc_session(shost, transport);
537 if (iscsi_add_session(session, target_id)) {
538 iscsi_free_session(session);
543 EXPORT_SYMBOL_GPL(iscsi_create_session);
545 static void iscsi_conn_release(struct device *dev)
547 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev);
548 struct device *parent = conn->dev.parent;
554 static int iscsi_is_conn_dev(const struct device *dev)
556 return dev->release == iscsi_conn_release;
559 static int iscsi_iter_destroy_conn_fn(struct device *dev, void *data)
561 if (!iscsi_is_conn_dev(dev))
563 return iscsi_destroy_conn(iscsi_dev_to_conn(dev));
566 void iscsi_remove_session(struct iscsi_cls_session *session)
568 struct Scsi_Host *shost = iscsi_session_to_shost(session);
569 struct iscsi_host *ihost = shost->shost_data;
573 spin_lock_irqsave(&sesslock, flags);
574 list_del(&session->sess_list);
575 spin_unlock_irqrestore(&sesslock, flags);
578 * If we are blocked let commands flow again. The lld or iscsi
579 * layer should set up the queuecommand to fail commands.
581 spin_lock_irqsave(&session->lock, flags);
582 session->state = ISCSI_SESSION_FREE;
583 spin_unlock_irqrestore(&session->lock, flags);
584 __iscsi_unblock_session(session);
585 __iscsi_unbind_session(&session->unbind_work);
587 /* flush running scans */
588 flush_workqueue(ihost->scan_workq);
590 * If the session dropped while removing devices then we need to make
591 * sure it is not blocked
593 if (!cancel_delayed_work(&session->recovery_work))
594 flush_workqueue(iscsi_eh_timer_workq);
596 /* hw iscsi may not have removed all connections from session */
597 err = device_for_each_child(&session->dev, NULL,
598 iscsi_iter_destroy_conn_fn);
600 dev_printk(KERN_ERR, &session->dev, "iscsi: Could not delete "
601 "all connections for session. Error %d.\n", err);
603 transport_unregister_device(&session->dev);
604 device_del(&session->dev);
606 EXPORT_SYMBOL_GPL(iscsi_remove_session);
608 void iscsi_free_session(struct iscsi_cls_session *session)
610 iscsi_session_event(session, ISCSI_KEVENT_DESTROY_SESSION);
611 put_device(&session->dev);
613 EXPORT_SYMBOL_GPL(iscsi_free_session);
616 * iscsi_destroy_session - destroy iscsi session
617 * @session: iscsi_session
619 * Can be called by a LLD or iscsi_transport. There must not be
620 * any running connections.
622 int iscsi_destroy_session(struct iscsi_cls_session *session)
624 iscsi_remove_session(session);
625 iscsi_free_session(session);
628 EXPORT_SYMBOL_GPL(iscsi_destroy_session);
631 * iscsi_create_conn - create iscsi class connection
632 * @session: iscsi cls session
633 * @cid: connection id
635 * This can be called from a LLD or iscsi_transport. The connection
636 * is child of the session so cid must be unique for all connections
639 * Since we do not support MCS, cid will normally be zero. In some cases
640 * for software iscsi we could be trying to preallocate a connection struct
641 * in which case there could be two connection structs and cid would be
644 struct iscsi_cls_conn *
645 iscsi_create_conn(struct iscsi_cls_session *session, uint32_t cid)
647 struct iscsi_transport *transport = session->transport;
648 struct iscsi_cls_conn *conn;
652 conn = kzalloc(sizeof(*conn) + transport->conndata_size, GFP_KERNEL);
656 if (transport->conndata_size)
657 conn->dd_data = &conn[1];
659 INIT_LIST_HEAD(&conn->conn_list);
660 conn->transport = transport;
663 /* this is released in the dev's release function */
664 if (!get_device(&session->dev))
667 snprintf(conn->dev.bus_id, BUS_ID_SIZE, "connection%d:%u",
669 conn->dev.parent = &session->dev;
670 conn->dev.release = iscsi_conn_release;
671 err = device_register(&conn->dev);
673 dev_printk(KERN_ERR, &conn->dev, "iscsi: could not register "
674 "connection's dev\n");
675 goto release_parent_ref;
677 transport_register_device(&conn->dev);
679 spin_lock_irqsave(&connlock, flags);
680 list_add(&conn->conn_list, &connlist);
682 spin_unlock_irqrestore(&connlock, flags);
686 put_device(&session->dev);
692 EXPORT_SYMBOL_GPL(iscsi_create_conn);
695 * iscsi_destroy_conn - destroy iscsi class connection
696 * @conn: iscsi cls session
698 * This can be called from a LLD or iscsi_transport.
700 int iscsi_destroy_conn(struct iscsi_cls_conn *conn)
704 spin_lock_irqsave(&connlock, flags);
706 list_del(&conn->conn_list);
707 spin_unlock_irqrestore(&connlock, flags);
709 transport_unregister_device(&conn->dev);
710 device_unregister(&conn->dev);
713 EXPORT_SYMBOL_GPL(iscsi_destroy_conn);
716 * iscsi interface functions
718 static struct iscsi_internal *
719 iscsi_if_transport_lookup(struct iscsi_transport *tt)
721 struct iscsi_internal *priv;
724 spin_lock_irqsave(&iscsi_transport_lock, flags);
725 list_for_each_entry(priv, &iscsi_transports, list) {
726 if (tt == priv->iscsi_transport) {
727 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
731 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
736 iscsi_broadcast_skb(struct sk_buff *skb, gfp_t gfp)
740 rc = netlink_broadcast(nls, skb, 0, 1, gfp);
742 printk(KERN_ERR "iscsi: can not broadcast skb (%d)\n", rc);
750 iscsi_unicast_skb(struct sk_buff *skb, int pid)
754 rc = netlink_unicast(nls, skb, pid, MSG_DONTWAIT);
756 printk(KERN_ERR "iscsi: can not unicast skb (%d)\n", rc);
763 int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
764 char *data, uint32_t data_size)
766 struct nlmsghdr *nlh;
768 struct iscsi_uevent *ev;
770 struct iscsi_internal *priv;
771 int len = NLMSG_SPACE(sizeof(*ev) + sizeof(struct iscsi_hdr) +
774 priv = iscsi_if_transport_lookup(conn->transport);
778 skb = alloc_skb(len, GFP_ATOMIC);
780 iscsi_conn_error(conn, ISCSI_ERR_CONN_FAILED);
781 dev_printk(KERN_ERR, &conn->dev, "iscsi: can not deliver "
782 "control PDU: OOM\n");
786 nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
787 ev = NLMSG_DATA(nlh);
788 memset(ev, 0, sizeof(*ev));
789 ev->transport_handle = iscsi_handle(conn->transport);
790 ev->type = ISCSI_KEVENT_RECV_PDU;
791 ev->r.recv_req.cid = conn->cid;
792 ev->r.recv_req.sid = iscsi_conn_get_sid(conn);
793 pdu = (char*)ev + sizeof(*ev);
794 memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
795 memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
797 return iscsi_unicast_skb(skb, priv->daemon_pid);
799 EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
801 void iscsi_conn_error(struct iscsi_cls_conn *conn, enum iscsi_err error)
803 struct iscsi_cls_session *session = iscsi_conn_to_session(conn);
804 struct nlmsghdr *nlh;
806 struct iscsi_uevent *ev;
807 struct iscsi_internal *priv;
808 int len = NLMSG_SPACE(sizeof(*ev));
811 priv = iscsi_if_transport_lookup(conn->transport);
815 spin_lock_irqsave(&session->lock, flags);
816 if (session->state == ISCSI_SESSION_LOGGED_IN)
817 session->state = ISCSI_SESSION_FAILED;
818 spin_unlock_irqrestore(&session->lock, flags);
820 skb = alloc_skb(len, GFP_ATOMIC);
822 dev_printk(KERN_ERR, &conn->dev, "iscsi: gracefully ignored "
823 "conn error (%d)\n", error);
827 nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
828 ev = NLMSG_DATA(nlh);
829 ev->transport_handle = iscsi_handle(conn->transport);
830 ev->type = ISCSI_KEVENT_CONN_ERROR;
831 ev->r.connerror.error = error;
832 ev->r.connerror.cid = conn->cid;
833 ev->r.connerror.sid = iscsi_conn_get_sid(conn);
835 iscsi_broadcast_skb(skb, GFP_ATOMIC);
837 dev_printk(KERN_INFO, &conn->dev, "iscsi: detected conn error (%d)\n",
840 EXPORT_SYMBOL_GPL(iscsi_conn_error);
843 iscsi_if_send_reply(int pid, int seq, int type, int done, int multi,
844 void *payload, int size)
847 struct nlmsghdr *nlh;
848 int len = NLMSG_SPACE(size);
849 int flags = multi ? NLM_F_MULTI : 0;
850 int t = done ? NLMSG_DONE : type;
852 skb = alloc_skb(len, GFP_ATOMIC);
854 printk(KERN_ERR "Could not allocate skb to send reply.\n");
858 nlh = __nlmsg_put(skb, pid, seq, t, (len - sizeof(*nlh)), 0);
859 nlh->nlmsg_flags = flags;
860 memcpy(NLMSG_DATA(nlh), payload, size);
861 return iscsi_unicast_skb(skb, pid);
865 iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
867 struct iscsi_uevent *ev = NLMSG_DATA(nlh);
868 struct iscsi_stats *stats;
869 struct sk_buff *skbstat;
870 struct iscsi_cls_conn *conn;
871 struct nlmsghdr *nlhstat;
872 struct iscsi_uevent *evstat;
873 struct iscsi_internal *priv;
874 int len = NLMSG_SPACE(sizeof(*ev) +
875 sizeof(struct iscsi_stats) +
876 sizeof(struct iscsi_stats_custom) *
877 ISCSI_STATS_CUSTOM_MAX);
880 priv = iscsi_if_transport_lookup(transport);
884 conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid);
891 skbstat = alloc_skb(len, GFP_ATOMIC);
893 dev_printk(KERN_ERR, &conn->dev, "iscsi: can not "
894 "deliver stats: OOM\n");
898 nlhstat = __nlmsg_put(skbstat, priv->daemon_pid, 0, 0,
899 (len - sizeof(*nlhstat)), 0);
900 evstat = NLMSG_DATA(nlhstat);
901 memset(evstat, 0, sizeof(*evstat));
902 evstat->transport_handle = iscsi_handle(conn->transport);
903 evstat->type = nlh->nlmsg_type;
904 evstat->u.get_stats.cid =
906 evstat->u.get_stats.sid =
908 stats = (struct iscsi_stats *)
909 ((char*)evstat + sizeof(*evstat));
910 memset(stats, 0, sizeof(*stats));
912 transport->get_stats(conn, stats);
913 actual_size = NLMSG_SPACE(sizeof(struct iscsi_uevent) +
914 sizeof(struct iscsi_stats) +
915 sizeof(struct iscsi_stats_custom) *
916 stats->custom_length);
917 actual_size -= sizeof(*nlhstat);
918 actual_size = NLMSG_LENGTH(actual_size);
919 skb_trim(skbstat, NLMSG_ALIGN(actual_size));
920 nlhstat->nlmsg_len = actual_size;
922 err = iscsi_unicast_skb(skbstat, priv->daemon_pid);
923 } while (err < 0 && err != -ECONNREFUSED);
929 * iscsi_session_event - send session destr. completion event
930 * @session: iscsi class session
931 * @event: type of event
933 int iscsi_session_event(struct iscsi_cls_session *session,
934 enum iscsi_uevent_e event)
936 struct iscsi_internal *priv;
937 struct Scsi_Host *shost;
938 struct iscsi_uevent *ev;
940 struct nlmsghdr *nlh;
941 int rc, len = NLMSG_SPACE(sizeof(*ev));
943 priv = iscsi_if_transport_lookup(session->transport);
946 shost = iscsi_session_to_shost(session);
948 skb = alloc_skb(len, GFP_KERNEL);
950 dev_printk(KERN_ERR, &session->dev, "Cannot notify userspace "
951 "of session event %u\n", event);
955 nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
956 ev = NLMSG_DATA(nlh);
957 ev->transport_handle = iscsi_handle(session->transport);
961 case ISCSI_KEVENT_DESTROY_SESSION:
962 ev->r.d_session.host_no = shost->host_no;
963 ev->r.d_session.sid = session->sid;
965 case ISCSI_KEVENT_CREATE_SESSION:
966 ev->r.c_session_ret.host_no = shost->host_no;
967 ev->r.c_session_ret.sid = session->sid;
969 case ISCSI_KEVENT_UNBIND_SESSION:
970 ev->r.unbind_session.host_no = shost->host_no;
971 ev->r.unbind_session.sid = session->sid;
974 dev_printk(KERN_ERR, &session->dev, "Invalid event %u.\n",
981 * this will occur if the daemon is not up, so we just warn
982 * the user and when the daemon is restarted it will handle it
984 rc = iscsi_broadcast_skb(skb, GFP_KERNEL);
986 dev_printk(KERN_ERR, &session->dev, "Cannot notify userspace "
987 "of session event %u. Check iscsi daemon\n", event);
990 EXPORT_SYMBOL_GPL(iscsi_session_event);
993 iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_uevent *ev)
995 struct iscsi_transport *transport = priv->iscsi_transport;
996 struct iscsi_cls_session *session;
999 session = transport->create_session(transport, &priv->t,
1000 ev->u.c_session.cmds_max,
1001 ev->u.c_session.queue_depth,
1002 ev->u.c_session.initial_cmdsn,
1007 ev->r.c_session_ret.host_no = hostno;
1008 ev->r.c_session_ret.sid = session->sid;
1013 iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
1015 struct iscsi_cls_conn *conn;
1016 struct iscsi_cls_session *session;
1018 session = iscsi_session_lookup(ev->u.c_conn.sid);
1020 printk(KERN_ERR "iscsi: invalid session %d\n",
1025 conn = transport->create_conn(session, ev->u.c_conn.cid);
1027 printk(KERN_ERR "iscsi: couldn't create a new "
1028 "connection for session %d\n",
1033 ev->r.c_conn_ret.sid = session->sid;
1034 ev->r.c_conn_ret.cid = conn->cid;
1039 iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
1041 struct iscsi_cls_conn *conn;
1043 conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid);
1047 if (transport->destroy_conn)
1048 transport->destroy_conn(conn);
1053 iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev)
1055 char *data = (char*)ev + sizeof(*ev);
1056 struct iscsi_cls_conn *conn;
1057 struct iscsi_cls_session *session;
1058 int err = 0, value = 0;
1060 session = iscsi_session_lookup(ev->u.set_param.sid);
1061 conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid);
1062 if (!conn || !session)
1065 switch (ev->u.set_param.param) {
1066 case ISCSI_PARAM_SESS_RECOVERY_TMO:
1067 sscanf(data, "%d", &value);
1069 session->recovery_tmo = value;
1072 err = transport->set_param(conn, ev->u.set_param.param,
1073 data, ev->u.set_param.len);
1080 iscsi_if_transport_ep(struct iscsi_transport *transport,
1081 struct iscsi_uevent *ev, int msg_type)
1083 struct sockaddr *dst_addr;
1087 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
1088 if (!transport->ep_connect)
1091 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
1092 rc = transport->ep_connect(dst_addr,
1093 ev->u.ep_connect.non_blocking,
1094 &ev->r.ep_connect_ret.handle);
1096 case ISCSI_UEVENT_TRANSPORT_EP_POLL:
1097 if (!transport->ep_poll)
1100 ev->r.retcode = transport->ep_poll(ev->u.ep_poll.ep_handle,
1101 ev->u.ep_poll.timeout_ms);
1103 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
1104 if (!transport->ep_disconnect)
1107 transport->ep_disconnect(ev->u.ep_disconnect.ep_handle);
1114 iscsi_tgt_dscvr(struct iscsi_transport *transport,
1115 struct iscsi_uevent *ev)
1117 struct Scsi_Host *shost;
1118 struct sockaddr *dst_addr;
1121 if (!transport->tgt_dscvr)
1124 shost = scsi_host_lookup(ev->u.tgt_dscvr.host_no);
1125 if (IS_ERR(shost)) {
1126 printk(KERN_ERR "target discovery could not find host no %u\n",
1127 ev->u.tgt_dscvr.host_no);
1132 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
1133 err = transport->tgt_dscvr(shost, ev->u.tgt_dscvr.type,
1134 ev->u.tgt_dscvr.enable, dst_addr);
1135 scsi_host_put(shost);
1140 iscsi_set_host_param(struct iscsi_transport *transport,
1141 struct iscsi_uevent *ev)
1143 char *data = (char*)ev + sizeof(*ev);
1144 struct Scsi_Host *shost;
1147 if (!transport->set_host_param)
1150 shost = scsi_host_lookup(ev->u.set_host_param.host_no);
1151 if (IS_ERR(shost)) {
1152 printk(KERN_ERR "set_host_param could not find host no %u\n",
1153 ev->u.set_host_param.host_no);
1157 err = transport->set_host_param(shost, ev->u.set_host_param.param,
1158 data, ev->u.set_host_param.len);
1159 scsi_host_put(shost);
1164 iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
1167 struct iscsi_uevent *ev = NLMSG_DATA(nlh);
1168 struct iscsi_transport *transport = NULL;
1169 struct iscsi_internal *priv;
1170 struct iscsi_cls_session *session;
1171 struct iscsi_cls_conn *conn;
1173 priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle));
1176 transport = priv->iscsi_transport;
1178 if (!try_module_get(transport->owner))
1181 priv->daemon_pid = NETLINK_CREDS(skb)->pid;
1183 switch (nlh->nlmsg_type) {
1184 case ISCSI_UEVENT_CREATE_SESSION:
1185 err = iscsi_if_create_session(priv, ev);
1187 case ISCSI_UEVENT_DESTROY_SESSION:
1188 session = iscsi_session_lookup(ev->u.d_session.sid);
1190 transport->destroy_session(session);
1194 case ISCSI_UEVENT_UNBIND_SESSION:
1195 session = iscsi_session_lookup(ev->u.d_session.sid);
1197 iscsi_unbind_session(session);
1201 case ISCSI_UEVENT_CREATE_CONN:
1202 err = iscsi_if_create_conn(transport, ev);
1204 case ISCSI_UEVENT_DESTROY_CONN:
1205 err = iscsi_if_destroy_conn(transport, ev);
1207 case ISCSI_UEVENT_BIND_CONN:
1208 session = iscsi_session_lookup(ev->u.b_conn.sid);
1209 conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid);
1211 if (session && conn)
1212 ev->r.retcode = transport->bind_conn(session, conn,
1213 ev->u.b_conn.transport_eph,
1214 ev->u.b_conn.is_leading);
1218 case ISCSI_UEVENT_SET_PARAM:
1219 err = iscsi_set_param(transport, ev);
1221 case ISCSI_UEVENT_START_CONN:
1222 conn = iscsi_conn_lookup(ev->u.start_conn.sid, ev->u.start_conn.cid);
1224 ev->r.retcode = transport->start_conn(conn);
1228 case ISCSI_UEVENT_STOP_CONN:
1229 conn = iscsi_conn_lookup(ev->u.stop_conn.sid, ev->u.stop_conn.cid);
1231 transport->stop_conn(conn, ev->u.stop_conn.flag);
1235 case ISCSI_UEVENT_SEND_PDU:
1236 conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid);
1238 ev->r.retcode = transport->send_pdu(conn,
1239 (struct iscsi_hdr*)((char*)ev + sizeof(*ev)),
1240 (char*)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,
1241 ev->u.send_pdu.data_size);
1245 case ISCSI_UEVENT_GET_STATS:
1246 err = iscsi_if_get_stats(transport, nlh);
1248 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
1249 case ISCSI_UEVENT_TRANSPORT_EP_POLL:
1250 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
1251 err = iscsi_if_transport_ep(transport, ev, nlh->nlmsg_type);
1253 case ISCSI_UEVENT_TGT_DSCVR:
1254 err = iscsi_tgt_dscvr(transport, ev);
1256 case ISCSI_UEVENT_SET_HOST_PARAM:
1257 err = iscsi_set_host_param(transport, ev);
1264 module_put(transport->owner);
1269 * Get message from skb. Each message is processed by iscsi_if_recv_msg.
1270 * Malformed skbs with wrong lengths or invalid creds are not processed.
1273 iscsi_if_rx(struct sk_buff *skb)
1275 mutex_lock(&rx_queue_mutex);
1276 while (skb->len >= NLMSG_SPACE(0)) {
1279 struct nlmsghdr *nlh;
1280 struct iscsi_uevent *ev;
1282 nlh = nlmsg_hdr(skb);
1283 if (nlh->nlmsg_len < sizeof(*nlh) ||
1284 skb->len < nlh->nlmsg_len) {
1288 ev = NLMSG_DATA(nlh);
1289 rlen = NLMSG_ALIGN(nlh->nlmsg_len);
1290 if (rlen > skb->len)
1293 err = iscsi_if_recv_msg(skb, nlh);
1295 ev->type = ISCSI_KEVENT_IF_ERROR;
1300 * special case for GET_STATS:
1301 * on success - sending reply and stats from
1302 * inside of if_recv_msg(),
1303 * on error - fall through.
1305 if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
1307 err = iscsi_if_send_reply(
1308 NETLINK_CREDS(skb)->pid, nlh->nlmsg_seq,
1309 nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
1310 } while (err < 0 && err != -ECONNREFUSED);
1311 skb_pull(skb, rlen);
1313 mutex_unlock(&rx_queue_mutex);
1316 #define iscsi_cdev_to_conn(_cdev) \
1317 iscsi_dev_to_conn(_cdev->dev)
1319 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \
1320 struct class_device_attribute class_device_attr_##_prefix##_##_name = \
1321 __ATTR(_name,_mode,_show,_store)
1324 * iSCSI connection attrs
1326 #define iscsi_conn_attr_show(param) \
1328 show_conn_param_##param(struct class_device *cdev, char *buf) \
1330 struct iscsi_cls_conn *conn = iscsi_cdev_to_conn(cdev); \
1331 struct iscsi_transport *t = conn->transport; \
1332 return t->get_conn_param(conn, param, buf); \
1335 #define iscsi_conn_attr(field, param) \
1336 iscsi_conn_attr_show(param) \
1337 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param, \
1340 iscsi_conn_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH);
1341 iscsi_conn_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH);
1342 iscsi_conn_attr(header_digest, ISCSI_PARAM_HDRDGST_EN);
1343 iscsi_conn_attr(data_digest, ISCSI_PARAM_DATADGST_EN);
1344 iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN);
1345 iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN);
1346 iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT);
1347 iscsi_conn_attr(port, ISCSI_PARAM_CONN_PORT);
1348 iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN);
1349 iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS);
1350 iscsi_conn_attr(address, ISCSI_PARAM_CONN_ADDRESS);
1351 iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);
1352 iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);
1354 #define iscsi_cdev_to_session(_cdev) \
1355 iscsi_dev_to_session(_cdev->dev)
1358 * iSCSI session attrs
1360 #define iscsi_session_attr_show(param, perm) \
1362 show_session_param_##param(struct class_device *cdev, char *buf) \
1364 struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev); \
1365 struct iscsi_transport *t = session->transport; \
1367 if (perm && !capable(CAP_SYS_ADMIN)) \
1369 return t->get_session_param(session, param, buf); \
1372 #define iscsi_session_attr(field, param, perm) \
1373 iscsi_session_attr_show(param, perm) \
1374 static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
1377 iscsi_session_attr(targetname, ISCSI_PARAM_TARGET_NAME, 0);
1378 iscsi_session_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN, 0);
1379 iscsi_session_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T, 0);
1380 iscsi_session_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN, 0);
1381 iscsi_session_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST, 0);
1382 iscsi_session_attr(max_burst_len, ISCSI_PARAM_MAX_BURST, 0);
1383 iscsi_session_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN, 0);
1384 iscsi_session_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN, 0);
1385 iscsi_session_attr(erl, ISCSI_PARAM_ERL, 0);
1386 iscsi_session_attr(tpgt, ISCSI_PARAM_TPGT, 0);
1387 iscsi_session_attr(username, ISCSI_PARAM_USERNAME, 1);
1388 iscsi_session_attr(username_in, ISCSI_PARAM_USERNAME_IN, 1);
1389 iscsi_session_attr(password, ISCSI_PARAM_PASSWORD, 1);
1390 iscsi_session_attr(password_in, ISCSI_PARAM_PASSWORD_IN, 1);
1391 iscsi_session_attr(fast_abort, ISCSI_PARAM_FAST_ABORT, 0);
1392 iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0);
1393 iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0);
1396 show_priv_session_state(struct class_device *cdev, char *buf)
1398 struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);
1399 return sprintf(buf, "%s\n", iscsi_session_state_name(session->state));
1401 static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
1404 #define iscsi_priv_session_attr_show(field, format) \
1406 show_priv_session_##field(struct class_device *cdev, char *buf) \
1408 struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);\
1409 return sprintf(buf, format"\n", session->field); \
1412 #define iscsi_priv_session_attr(field, format) \
1413 iscsi_priv_session_attr_show(field, format) \
1414 static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO, show_priv_session_##field, \
1416 iscsi_priv_session_attr(recovery_tmo, "%d");
1421 #define iscsi_host_attr_show(param) \
1423 show_host_param_##param(struct class_device *cdev, char *buf) \
1425 struct Scsi_Host *shost = transport_class_to_shost(cdev); \
1426 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
1427 return priv->iscsi_transport->get_host_param(shost, param, buf); \
1430 #define iscsi_host_attr(field, param) \
1431 iscsi_host_attr_show(param) \
1432 static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param, \
1435 iscsi_host_attr(netdev, ISCSI_HOST_PARAM_NETDEV_NAME);
1436 iscsi_host_attr(hwaddress, ISCSI_HOST_PARAM_HWADDRESS);
1437 iscsi_host_attr(ipaddress, ISCSI_HOST_PARAM_IPADDRESS);
1438 iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME);
1440 #define SETUP_PRIV_SESSION_RD_ATTR(field) \
1442 priv->session_attrs[count] = &class_device_attr_priv_sess_##field; \
1447 #define SETUP_SESSION_RD_ATTR(field, param_flag) \
1449 if (tt->param_mask & param_flag) { \
1450 priv->session_attrs[count] = &class_device_attr_sess_##field; \
1455 #define SETUP_CONN_RD_ATTR(field, param_flag) \
1457 if (tt->param_mask & param_flag) { \
1458 priv->conn_attrs[count] = &class_device_attr_conn_##field; \
1463 #define SETUP_HOST_RD_ATTR(field, param_flag) \
1465 if (tt->host_param_mask & param_flag) { \
1466 priv->host_attrs[count] = &class_device_attr_host_##field; \
1471 static int iscsi_session_match(struct attribute_container *cont,
1474 struct iscsi_cls_session *session;
1475 struct Scsi_Host *shost;
1476 struct iscsi_internal *priv;
1478 if (!iscsi_is_session_dev(dev))
1481 session = iscsi_dev_to_session(dev);
1482 shost = iscsi_session_to_shost(session);
1483 if (!shost->transportt)
1486 priv = to_iscsi_internal(shost->transportt);
1487 if (priv->session_cont.ac.class != &iscsi_session_class.class)
1490 return &priv->session_cont.ac == cont;
1493 static int iscsi_conn_match(struct attribute_container *cont,
1496 struct iscsi_cls_session *session;
1497 struct iscsi_cls_conn *conn;
1498 struct Scsi_Host *shost;
1499 struct iscsi_internal *priv;
1501 if (!iscsi_is_conn_dev(dev))
1504 conn = iscsi_dev_to_conn(dev);
1505 session = iscsi_dev_to_session(conn->dev.parent);
1506 shost = iscsi_session_to_shost(session);
1508 if (!shost->transportt)
1511 priv = to_iscsi_internal(shost->transportt);
1512 if (priv->conn_cont.ac.class != &iscsi_connection_class.class)
1515 return &priv->conn_cont.ac == cont;
1518 static int iscsi_host_match(struct attribute_container *cont,
1521 struct Scsi_Host *shost;
1522 struct iscsi_internal *priv;
1524 if (!scsi_is_host_device(dev))
1527 shost = dev_to_shost(dev);
1528 if (!shost->transportt ||
1529 shost->transportt->host_attrs.ac.class != &iscsi_host_class.class)
1532 priv = to_iscsi_internal(shost->transportt);
1533 return &priv->t.host_attrs.ac == cont;
1536 struct scsi_transport_template *
1537 iscsi_register_transport(struct iscsi_transport *tt)
1539 struct iscsi_internal *priv;
1540 unsigned long flags;
1545 priv = iscsi_if_transport_lookup(tt);
1549 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1552 INIT_LIST_HEAD(&priv->list);
1553 priv->daemon_pid = -1;
1554 priv->iscsi_transport = tt;
1555 priv->t.user_scan = iscsi_user_scan;
1557 priv->cdev.class = &iscsi_transport_class;
1558 snprintf(priv->cdev.class_id, BUS_ID_SIZE, "%s", tt->name);
1559 err = class_device_register(&priv->cdev);
1563 err = sysfs_create_group(&priv->cdev.kobj, &iscsi_transport_group);
1565 goto unregister_cdev;
1567 /* host parameters */
1568 priv->t.host_attrs.ac.attrs = &priv->host_attrs[0];
1569 priv->t.host_attrs.ac.class = &iscsi_host_class.class;
1570 priv->t.host_attrs.ac.match = iscsi_host_match;
1571 priv->t.host_size = sizeof(struct iscsi_host);
1572 transport_container_register(&priv->t.host_attrs);
1574 SETUP_HOST_RD_ATTR(netdev, ISCSI_HOST_NETDEV_NAME);
1575 SETUP_HOST_RD_ATTR(ipaddress, ISCSI_HOST_IPADDRESS);
1576 SETUP_HOST_RD_ATTR(hwaddress, ISCSI_HOST_HWADDRESS);
1577 SETUP_HOST_RD_ATTR(initiatorname, ISCSI_HOST_INITIATOR_NAME);
1578 BUG_ON(count > ISCSI_HOST_ATTRS);
1579 priv->host_attrs[count] = NULL;
1582 /* connection parameters */
1583 priv->conn_cont.ac.attrs = &priv->conn_attrs[0];
1584 priv->conn_cont.ac.class = &iscsi_connection_class.class;
1585 priv->conn_cont.ac.match = iscsi_conn_match;
1586 transport_container_register(&priv->conn_cont);
1588 SETUP_CONN_RD_ATTR(max_recv_dlength, ISCSI_MAX_RECV_DLENGTH);
1589 SETUP_CONN_RD_ATTR(max_xmit_dlength, ISCSI_MAX_XMIT_DLENGTH);
1590 SETUP_CONN_RD_ATTR(header_digest, ISCSI_HDRDGST_EN);
1591 SETUP_CONN_RD_ATTR(data_digest, ISCSI_DATADGST_EN);
1592 SETUP_CONN_RD_ATTR(ifmarker, ISCSI_IFMARKER_EN);
1593 SETUP_CONN_RD_ATTR(ofmarker, ISCSI_OFMARKER_EN);
1594 SETUP_CONN_RD_ATTR(address, ISCSI_CONN_ADDRESS);
1595 SETUP_CONN_RD_ATTR(port, ISCSI_CONN_PORT);
1596 SETUP_CONN_RD_ATTR(exp_statsn, ISCSI_EXP_STATSN);
1597 SETUP_CONN_RD_ATTR(persistent_address, ISCSI_PERSISTENT_ADDRESS);
1598 SETUP_CONN_RD_ATTR(persistent_port, ISCSI_PERSISTENT_PORT);
1599 SETUP_CONN_RD_ATTR(ping_tmo, ISCSI_PING_TMO);
1600 SETUP_CONN_RD_ATTR(recv_tmo, ISCSI_RECV_TMO);
1602 BUG_ON(count > ISCSI_CONN_ATTRS);
1603 priv->conn_attrs[count] = NULL;
1606 /* session parameters */
1607 priv->session_cont.ac.attrs = &priv->session_attrs[0];
1608 priv->session_cont.ac.class = &iscsi_session_class.class;
1609 priv->session_cont.ac.match = iscsi_session_match;
1610 transport_container_register(&priv->session_cont);
1612 SETUP_SESSION_RD_ATTR(initial_r2t, ISCSI_INITIAL_R2T_EN);
1613 SETUP_SESSION_RD_ATTR(max_outstanding_r2t, ISCSI_MAX_R2T);
1614 SETUP_SESSION_RD_ATTR(immediate_data, ISCSI_IMM_DATA_EN);
1615 SETUP_SESSION_RD_ATTR(first_burst_len, ISCSI_FIRST_BURST);
1616 SETUP_SESSION_RD_ATTR(max_burst_len, ISCSI_MAX_BURST);
1617 SETUP_SESSION_RD_ATTR(data_pdu_in_order, ISCSI_PDU_INORDER_EN);
1618 SETUP_SESSION_RD_ATTR(data_seq_in_order, ISCSI_DATASEQ_INORDER_EN);
1619 SETUP_SESSION_RD_ATTR(erl, ISCSI_ERL);
1620 SETUP_SESSION_RD_ATTR(targetname, ISCSI_TARGET_NAME);
1621 SETUP_SESSION_RD_ATTR(tpgt, ISCSI_TPGT);
1622 SETUP_SESSION_RD_ATTR(password, ISCSI_USERNAME);
1623 SETUP_SESSION_RD_ATTR(password_in, ISCSI_USERNAME_IN);
1624 SETUP_SESSION_RD_ATTR(username, ISCSI_PASSWORD);
1625 SETUP_SESSION_RD_ATTR(username_in, ISCSI_PASSWORD_IN);
1626 SETUP_SESSION_RD_ATTR(fast_abort, ISCSI_FAST_ABORT);
1627 SETUP_SESSION_RD_ATTR(abort_tmo, ISCSI_ABORT_TMO);
1628 SETUP_SESSION_RD_ATTR(lu_reset_tmo,ISCSI_LU_RESET_TMO);
1629 SETUP_PRIV_SESSION_RD_ATTR(recovery_tmo);
1630 SETUP_PRIV_SESSION_RD_ATTR(state);
1632 BUG_ON(count > ISCSI_SESSION_ATTRS);
1633 priv->session_attrs[count] = NULL;
1635 spin_lock_irqsave(&iscsi_transport_lock, flags);
1636 list_add(&priv->list, &iscsi_transports);
1637 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
1639 printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
1643 class_device_unregister(&priv->cdev);
1648 EXPORT_SYMBOL_GPL(iscsi_register_transport);
1650 int iscsi_unregister_transport(struct iscsi_transport *tt)
1652 struct iscsi_internal *priv;
1653 unsigned long flags;
1657 mutex_lock(&rx_queue_mutex);
1659 priv = iscsi_if_transport_lookup(tt);
1662 spin_lock_irqsave(&iscsi_transport_lock, flags);
1663 list_del(&priv->list);
1664 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
1666 transport_container_unregister(&priv->conn_cont);
1667 transport_container_unregister(&priv->session_cont);
1668 transport_container_unregister(&priv->t.host_attrs);
1670 sysfs_remove_group(&priv->cdev.kobj, &iscsi_transport_group);
1671 class_device_unregister(&priv->cdev);
1672 mutex_unlock(&rx_queue_mutex);
1676 EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
1678 static __init int iscsi_transport_init(void)
1682 printk(KERN_INFO "Loading iSCSI transport class v%s.\n",
1683 ISCSI_TRANSPORT_VERSION);
1685 atomic_set(&iscsi_session_nr, 0);
1687 err = class_register(&iscsi_transport_class);
1691 err = transport_class_register(&iscsi_host_class);
1693 goto unregister_transport_class;
1695 err = transport_class_register(&iscsi_connection_class);
1697 goto unregister_host_class;
1699 err = transport_class_register(&iscsi_session_class);
1701 goto unregister_conn_class;
1703 nls = netlink_kernel_create(&init_net, NETLINK_ISCSI, 1, iscsi_if_rx, NULL,
1707 goto unregister_session_class;
1710 iscsi_eh_timer_workq = create_singlethread_workqueue("iscsi_eh");
1711 if (!iscsi_eh_timer_workq)
1717 netlink_kernel_release(nls);
1718 unregister_session_class:
1719 transport_class_unregister(&iscsi_session_class);
1720 unregister_conn_class:
1721 transport_class_unregister(&iscsi_connection_class);
1722 unregister_host_class:
1723 transport_class_unregister(&iscsi_host_class);
1724 unregister_transport_class:
1725 class_unregister(&iscsi_transport_class);
1729 static void __exit iscsi_transport_exit(void)
1731 destroy_workqueue(iscsi_eh_timer_workq);
1732 netlink_kernel_release(nls);
1733 transport_class_unregister(&iscsi_connection_class);
1734 transport_class_unregister(&iscsi_session_class);
1735 transport_class_unregister(&iscsi_host_class);
1736 class_unregister(&iscsi_transport_class);
1739 module_init(iscsi_transport_init);
1740 module_exit(iscsi_transport_exit);
1742 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
1743 "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
1744 "Alex Aizman <itn780@yahoo.com>");
1745 MODULE_DESCRIPTION("iSCSI Transport Interface");
1746 MODULE_LICENSE("GPL");
1747 MODULE_VERSION(ISCSI_TRANSPORT_VERSION);