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-869"
38 struct iscsi_internal
{
40 struct scsi_transport_template t
;
41 struct iscsi_transport
*iscsi_transport
;
42 struct list_head list
;
45 struct device_attribute
*host_attrs
[ISCSI_HOST_ATTRS
+ 1];
46 struct transport_container conn_cont
;
47 struct device_attribute
*conn_attrs
[ISCSI_CONN_ATTRS
+ 1];
48 struct transport_container session_cont
;
49 struct 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 dev_to_iscsi_internal(_dev) \
67 container_of(_dev, struct iscsi_internal, dev)
69 static void iscsi_transport_release(struct device
*dev
)
71 struct iscsi_internal
*priv
= dev_to_iscsi_internal(dev
);
76 * iscsi_transport_class represents the iscsi_transports that are
79 static struct class iscsi_transport_class
= {
80 .name
= "iscsi_transport",
81 .dev_release
= iscsi_transport_release
,
85 show_transport_handle(struct device
*dev
, struct device_attribute
*attr
,
88 struct iscsi_internal
*priv
= dev_to_iscsi_internal(dev
);
89 return sprintf(buf
, "%llu\n", (unsigned long long)iscsi_handle(priv
->iscsi_transport
));
91 static DEVICE_ATTR(handle
, S_IRUGO
, show_transport_handle
, NULL
);
93 #define show_transport_attr(name, format) \
95 show_transport_##name(struct device *dev, \
96 struct device_attribute *attr,char *buf) \
98 struct iscsi_internal *priv = dev_to_iscsi_internal(dev); \
99 return sprintf(buf, format"\n", priv->iscsi_transport->name); \
101 static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
103 show_transport_attr(caps
, "0x%x");
105 static struct attribute
*iscsi_transport_attrs
[] = {
106 &dev_attr_handle
.attr
,
111 static struct attribute_group iscsi_transport_group
= {
112 .attrs
= iscsi_transport_attrs
,
115 static int iscsi_setup_host(struct transport_container
*tc
, struct device
*dev
,
118 struct Scsi_Host
*shost
= dev_to_shost(dev
);
119 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
121 memset(ihost
, 0, sizeof(*ihost
));
122 INIT_LIST_HEAD(&ihost
->sessions
);
123 mutex_init(&ihost
->mutex
);
124 atomic_set(&ihost
->nr_scans
, 0);
126 snprintf(ihost
->scan_workq_name
, KOBJ_NAME_LEN
, "iscsi_scan_%d",
128 ihost
->scan_workq
= create_singlethread_workqueue(
129 ihost
->scan_workq_name
);
130 if (!ihost
->scan_workq
)
135 static int iscsi_remove_host(struct transport_container
*tc
, struct device
*dev
,
138 struct Scsi_Host
*shost
= dev_to_shost(dev
);
139 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
141 destroy_workqueue(ihost
->scan_workq
);
145 static DECLARE_TRANSPORT_CLASS(iscsi_host_class
,
151 static DECLARE_TRANSPORT_CLASS(iscsi_session_class
,
157 static DECLARE_TRANSPORT_CLASS(iscsi_connection_class
,
163 static struct sock
*nls
;
164 static DEFINE_MUTEX(rx_queue_mutex
);
166 static LIST_HEAD(sesslist
);
167 static DEFINE_SPINLOCK(sesslock
);
168 static LIST_HEAD(connlist
);
169 static DEFINE_SPINLOCK(connlock
);
171 static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn
*conn
)
173 struct iscsi_cls_session
*sess
= iscsi_dev_to_session(conn
->dev
.parent
);
178 * Returns the matching session to a given sid
180 static struct iscsi_cls_session
*iscsi_session_lookup(uint32_t sid
)
183 struct iscsi_cls_session
*sess
;
185 spin_lock_irqsave(&sesslock
, flags
);
186 list_for_each_entry(sess
, &sesslist
, sess_list
) {
187 if (sess
->sid
== sid
) {
188 spin_unlock_irqrestore(&sesslock
, flags
);
192 spin_unlock_irqrestore(&sesslock
, flags
);
197 * Returns the matching connection to a given sid / cid tuple
199 static struct iscsi_cls_conn
*iscsi_conn_lookup(uint32_t sid
, uint32_t cid
)
202 struct iscsi_cls_conn
*conn
;
204 spin_lock_irqsave(&connlock
, flags
);
205 list_for_each_entry(conn
, &connlist
, conn_list
) {
206 if ((conn
->cid
== cid
) && (iscsi_conn_get_sid(conn
) == sid
)) {
207 spin_unlock_irqrestore(&connlock
, flags
);
211 spin_unlock_irqrestore(&connlock
, flags
);
216 * The following functions can be used by LLDs that allocate
217 * their own scsi_hosts or by software iscsi LLDs
222 } iscsi_session_state_names
[] = {
223 { ISCSI_SESSION_LOGGED_IN
, "LOGGED_IN" },
224 { ISCSI_SESSION_FAILED
, "FAILED" },
225 { ISCSI_SESSION_FREE
, "FREE" },
228 static const char *iscsi_session_state_name(int state
)
233 for (i
= 0; i
< ARRAY_SIZE(iscsi_session_state_names
); i
++) {
234 if (iscsi_session_state_names
[i
].value
== state
) {
235 name
= iscsi_session_state_names
[i
].name
;
242 int iscsi_session_chkready(struct iscsi_cls_session
*session
)
247 spin_lock_irqsave(&session
->lock
, flags
);
248 switch (session
->state
) {
249 case ISCSI_SESSION_LOGGED_IN
:
252 case ISCSI_SESSION_FAILED
:
253 err
= DID_IMM_RETRY
<< 16;
255 case ISCSI_SESSION_FREE
:
256 err
= DID_NO_CONNECT
<< 16;
259 err
= DID_NO_CONNECT
<< 16;
262 spin_unlock_irqrestore(&session
->lock
, flags
);
265 EXPORT_SYMBOL_GPL(iscsi_session_chkready
);
267 static void iscsi_session_release(struct device
*dev
)
269 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
);
270 struct Scsi_Host
*shost
;
272 shost
= iscsi_session_to_shost(session
);
273 scsi_host_put(shost
);
277 static int iscsi_is_session_dev(const struct device
*dev
)
279 return dev
->release
== iscsi_session_release
;
282 static int iscsi_iter_session_fn(struct device
*dev
, void *data
)
284 void (* fn
) (struct iscsi_cls_session
*) = data
;
286 if (!iscsi_is_session_dev(dev
))
288 fn(iscsi_dev_to_session(dev
));
292 void iscsi_host_for_each_session(struct Scsi_Host
*shost
,
293 void (*fn
)(struct iscsi_cls_session
*))
295 device_for_each_child(&shost
->shost_gendev
, fn
,
296 iscsi_iter_session_fn
);
298 EXPORT_SYMBOL_GPL(iscsi_host_for_each_session
);
301 * iscsi_scan_finished - helper to report when running scans are done
303 * @time: scan run time
305 * This function can be used by drives like qla4xxx to report to the scsi
306 * layer when the scans it kicked off at module load time are done.
308 int iscsi_scan_finished(struct Scsi_Host
*shost
, unsigned long time
)
310 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
312 * qla4xxx will have kicked off some session unblocks before calling
313 * scsi_scan_host, so just wait for them to complete.
315 return !atomic_read(&ihost
->nr_scans
);
317 EXPORT_SYMBOL_GPL(iscsi_scan_finished
);
319 static int iscsi_user_scan(struct Scsi_Host
*shost
, uint channel
,
322 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
323 struct iscsi_cls_session
*session
;
325 mutex_lock(&ihost
->mutex
);
326 list_for_each_entry(session
, &ihost
->sessions
, host_list
) {
327 if ((channel
== SCAN_WILD_CARD
|| channel
== 0) &&
328 (id
== SCAN_WILD_CARD
|| id
== session
->target_id
))
329 scsi_scan_target(&session
->dev
, 0,
330 session
->target_id
, lun
, 1);
332 mutex_unlock(&ihost
->mutex
);
337 static void iscsi_scan_session(struct work_struct
*work
)
339 struct iscsi_cls_session
*session
=
340 container_of(work
, struct iscsi_cls_session
, scan_work
);
341 struct Scsi_Host
*shost
= iscsi_session_to_shost(session
);
342 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
345 spin_lock_irqsave(&session
->lock
, flags
);
346 if (session
->state
!= ISCSI_SESSION_LOGGED_IN
) {
347 spin_unlock_irqrestore(&session
->lock
, flags
);
350 spin_unlock_irqrestore(&session
->lock
, flags
);
352 scsi_scan_target(&session
->dev
, 0, session
->target_id
,
355 atomic_dec(&ihost
->nr_scans
);
358 static void session_recovery_timedout(struct work_struct
*work
)
360 struct iscsi_cls_session
*session
=
361 container_of(work
, struct iscsi_cls_session
,
365 iscsi_cls_session_printk(KERN_INFO
, session
,
366 "session recovery timed out after %d secs\n",
367 session
->recovery_tmo
);
369 spin_lock_irqsave(&session
->lock
, flags
);
370 switch (session
->state
) {
371 case ISCSI_SESSION_FAILED
:
372 session
->state
= ISCSI_SESSION_FREE
;
374 case ISCSI_SESSION_LOGGED_IN
:
375 case ISCSI_SESSION_FREE
:
376 /* we raced with the unblock's flush */
377 spin_unlock_irqrestore(&session
->lock
, flags
);
380 spin_unlock_irqrestore(&session
->lock
, flags
);
382 if (session
->transport
->session_recovery_timedout
)
383 session
->transport
->session_recovery_timedout(session
);
385 scsi_target_unblock(&session
->dev
);
388 static void __iscsi_unblock_session(struct work_struct
*work
)
390 struct iscsi_cls_session
*session
=
391 container_of(work
, struct iscsi_cls_session
,
393 struct Scsi_Host
*shost
= iscsi_session_to_shost(session
);
394 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
398 * The recovery and unblock work get run from the same workqueue,
399 * so try to cancel it if it was going to run after this unblock.
401 cancel_delayed_work(&session
->recovery_work
);
402 spin_lock_irqsave(&session
->lock
, flags
);
403 session
->state
= ISCSI_SESSION_LOGGED_IN
;
404 spin_unlock_irqrestore(&session
->lock
, flags
);
406 scsi_target_unblock(&session
->dev
);
408 * Only do kernel scanning if the driver is properly hooked into
409 * the async scanning code (drivers like iscsi_tcp do login and
410 * scanning from userspace).
412 if (shost
->hostt
->scan_finished
) {
413 if (queue_work(ihost
->scan_workq
, &session
->scan_work
))
414 atomic_inc(&ihost
->nr_scans
);
419 * iscsi_unblock_session - set a session as logged in and start IO.
420 * @session: iscsi session
422 * Mark a session as ready to accept IO.
424 void iscsi_unblock_session(struct iscsi_cls_session
*session
)
426 queue_work(iscsi_eh_timer_workq
, &session
->unblock_work
);
428 * make sure all the events have completed before tell the driver
431 flush_workqueue(iscsi_eh_timer_workq
);
433 EXPORT_SYMBOL_GPL(iscsi_unblock_session
);
435 static void __iscsi_block_session(struct work_struct
*work
)
437 struct iscsi_cls_session
*session
=
438 container_of(work
, struct iscsi_cls_session
,
442 spin_lock_irqsave(&session
->lock
, flags
);
443 session
->state
= ISCSI_SESSION_FAILED
;
444 spin_unlock_irqrestore(&session
->lock
, flags
);
445 scsi_target_block(&session
->dev
);
446 queue_delayed_work(iscsi_eh_timer_workq
, &session
->recovery_work
,
447 session
->recovery_tmo
* HZ
);
450 void iscsi_block_session(struct iscsi_cls_session
*session
)
452 queue_work(iscsi_eh_timer_workq
, &session
->block_work
);
454 EXPORT_SYMBOL_GPL(iscsi_block_session
);
456 static void __iscsi_unbind_session(struct work_struct
*work
)
458 struct iscsi_cls_session
*session
=
459 container_of(work
, struct iscsi_cls_session
,
461 struct Scsi_Host
*shost
= iscsi_session_to_shost(session
);
462 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
464 /* Prevent new scans and make sure scanning is not in progress */
465 mutex_lock(&ihost
->mutex
);
466 if (list_empty(&session
->host_list
)) {
467 mutex_unlock(&ihost
->mutex
);
470 list_del_init(&session
->host_list
);
471 mutex_unlock(&ihost
->mutex
);
473 scsi_remove_target(&session
->dev
);
474 iscsi_session_event(session
, ISCSI_KEVENT_UNBIND_SESSION
);
477 static int iscsi_unbind_session(struct iscsi_cls_session
*session
)
479 struct Scsi_Host
*shost
= iscsi_session_to_shost(session
);
480 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
482 return queue_work(ihost
->scan_workq
, &session
->unbind_work
);
485 struct iscsi_cls_session
*
486 iscsi_alloc_session(struct Scsi_Host
*shost
,
487 struct iscsi_transport
*transport
)
489 struct iscsi_cls_session
*session
;
491 session
= kzalloc(sizeof(*session
) + transport
->sessiondata_size
,
496 session
->transport
= transport
;
497 session
->recovery_tmo
= 120;
498 session
->state
= ISCSI_SESSION_FREE
;
499 INIT_DELAYED_WORK(&session
->recovery_work
, session_recovery_timedout
);
500 INIT_LIST_HEAD(&session
->host_list
);
501 INIT_LIST_HEAD(&session
->sess_list
);
502 INIT_WORK(&session
->unblock_work
, __iscsi_unblock_session
);
503 INIT_WORK(&session
->block_work
, __iscsi_block_session
);
504 INIT_WORK(&session
->unbind_work
, __iscsi_unbind_session
);
505 INIT_WORK(&session
->scan_work
, iscsi_scan_session
);
506 spin_lock_init(&session
->lock
);
508 /* this is released in the dev's release function */
509 scsi_host_get(shost
);
510 session
->dev
.parent
= &shost
->shost_gendev
;
511 session
->dev
.release
= iscsi_session_release
;
512 device_initialize(&session
->dev
);
513 if (transport
->sessiondata_size
)
514 session
->dd_data
= &session
[1];
517 EXPORT_SYMBOL_GPL(iscsi_alloc_session
);
519 int iscsi_add_session(struct iscsi_cls_session
*session
, unsigned int target_id
)
521 struct Scsi_Host
*shost
= iscsi_session_to_shost(session
);
522 struct iscsi_cls_host
*ihost
;
526 ihost
= shost
->shost_data
;
527 session
->sid
= atomic_add_return(1, &iscsi_session_nr
);
528 session
->target_id
= target_id
;
530 snprintf(session
->dev
.bus_id
, BUS_ID_SIZE
, "session%u",
532 err
= device_add(&session
->dev
);
534 iscsi_cls_session_printk(KERN_ERR
, session
,
535 "could not register session's dev\n");
538 transport_register_device(&session
->dev
);
540 spin_lock_irqsave(&sesslock
, flags
);
541 list_add(&session
->sess_list
, &sesslist
);
542 spin_unlock_irqrestore(&sesslock
, flags
);
544 mutex_lock(&ihost
->mutex
);
545 list_add(&session
->host_list
, &ihost
->sessions
);
546 mutex_unlock(&ihost
->mutex
);
548 iscsi_session_event(session
, ISCSI_KEVENT_CREATE_SESSION
);
552 scsi_host_put(shost
);
555 EXPORT_SYMBOL_GPL(iscsi_add_session
);
558 * iscsi_create_session - create iscsi class session
560 * @transport: iscsi transport
561 * @target_id: which target
563 * This can be called from a LLD or iscsi_transport.
565 struct iscsi_cls_session
*
566 iscsi_create_session(struct Scsi_Host
*shost
,
567 struct iscsi_transport
*transport
,
568 unsigned int target_id
)
570 struct iscsi_cls_session
*session
;
572 session
= iscsi_alloc_session(shost
, transport
);
576 if (iscsi_add_session(session
, target_id
)) {
577 iscsi_free_session(session
);
582 EXPORT_SYMBOL_GPL(iscsi_create_session
);
584 static void iscsi_conn_release(struct device
*dev
)
586 struct iscsi_cls_conn
*conn
= iscsi_dev_to_conn(dev
);
587 struct device
*parent
= conn
->dev
.parent
;
593 static int iscsi_is_conn_dev(const struct device
*dev
)
595 return dev
->release
== iscsi_conn_release
;
598 static int iscsi_iter_destroy_conn_fn(struct device
*dev
, void *data
)
600 if (!iscsi_is_conn_dev(dev
))
602 return iscsi_destroy_conn(iscsi_dev_to_conn(dev
));
605 void iscsi_remove_session(struct iscsi_cls_session
*session
)
607 struct Scsi_Host
*shost
= iscsi_session_to_shost(session
);
608 struct iscsi_cls_host
*ihost
= shost
->shost_data
;
612 spin_lock_irqsave(&sesslock
, flags
);
613 list_del(&session
->sess_list
);
614 spin_unlock_irqrestore(&sesslock
, flags
);
616 /* make sure there are no blocks/unblocks queued */
617 flush_workqueue(iscsi_eh_timer_workq
);
618 /* make sure the timedout callout is not running */
619 if (!cancel_delayed_work(&session
->recovery_work
))
620 flush_workqueue(iscsi_eh_timer_workq
);
622 * If we are blocked let commands flow again. The lld or iscsi
623 * layer should set up the queuecommand to fail commands.
624 * We assume that LLD will not be calling block/unblock while
625 * removing the session.
627 spin_lock_irqsave(&session
->lock
, flags
);
628 session
->state
= ISCSI_SESSION_FREE
;
629 spin_unlock_irqrestore(&session
->lock
, flags
);
631 scsi_target_unblock(&session
->dev
);
632 /* flush running scans then delete devices */
633 flush_workqueue(ihost
->scan_workq
);
634 __iscsi_unbind_session(&session
->unbind_work
);
636 /* hw iscsi may not have removed all connections from session */
637 err
= device_for_each_child(&session
->dev
, NULL
,
638 iscsi_iter_destroy_conn_fn
);
640 iscsi_cls_session_printk(KERN_ERR
, session
,
641 "Could not delete all connections "
642 "for session. Error %d.\n", err
);
644 transport_unregister_device(&session
->dev
);
645 device_del(&session
->dev
);
647 EXPORT_SYMBOL_GPL(iscsi_remove_session
);
649 void iscsi_free_session(struct iscsi_cls_session
*session
)
651 iscsi_session_event(session
, ISCSI_KEVENT_DESTROY_SESSION
);
652 put_device(&session
->dev
);
654 EXPORT_SYMBOL_GPL(iscsi_free_session
);
657 * iscsi_destroy_session - destroy iscsi session
658 * @session: iscsi_session
660 * Can be called by a LLD or iscsi_transport. There must not be
661 * any running connections.
663 int iscsi_destroy_session(struct iscsi_cls_session
*session
)
665 iscsi_remove_session(session
);
666 iscsi_free_session(session
);
669 EXPORT_SYMBOL_GPL(iscsi_destroy_session
);
672 * iscsi_create_conn - create iscsi class connection
673 * @session: iscsi cls session
674 * @cid: connection id
676 * This can be called from a LLD or iscsi_transport. The connection
677 * is child of the session so cid must be unique for all connections
680 * Since we do not support MCS, cid will normally be zero. In some cases
681 * for software iscsi we could be trying to preallocate a connection struct
682 * in which case there could be two connection structs and cid would be
685 struct iscsi_cls_conn
*
686 iscsi_create_conn(struct iscsi_cls_session
*session
, uint32_t cid
)
688 struct iscsi_transport
*transport
= session
->transport
;
689 struct iscsi_cls_conn
*conn
;
693 conn
= kzalloc(sizeof(*conn
) + transport
->conndata_size
, GFP_KERNEL
);
697 if (transport
->conndata_size
)
698 conn
->dd_data
= &conn
[1];
700 INIT_LIST_HEAD(&conn
->conn_list
);
701 conn
->transport
= transport
;
704 /* this is released in the dev's release function */
705 if (!get_device(&session
->dev
))
708 snprintf(conn
->dev
.bus_id
, BUS_ID_SIZE
, "connection%d:%u",
710 conn
->dev
.parent
= &session
->dev
;
711 conn
->dev
.release
= iscsi_conn_release
;
712 err
= device_register(&conn
->dev
);
714 iscsi_cls_session_printk(KERN_ERR
, session
, "could not "
715 "register connection's dev\n");
716 goto release_parent_ref
;
718 transport_register_device(&conn
->dev
);
720 spin_lock_irqsave(&connlock
, flags
);
721 list_add(&conn
->conn_list
, &connlist
);
723 spin_unlock_irqrestore(&connlock
, flags
);
727 put_device(&session
->dev
);
733 EXPORT_SYMBOL_GPL(iscsi_create_conn
);
736 * iscsi_destroy_conn - destroy iscsi class connection
737 * @conn: iscsi cls session
739 * This can be called from a LLD or iscsi_transport.
741 int iscsi_destroy_conn(struct iscsi_cls_conn
*conn
)
745 spin_lock_irqsave(&connlock
, flags
);
747 list_del(&conn
->conn_list
);
748 spin_unlock_irqrestore(&connlock
, flags
);
750 transport_unregister_device(&conn
->dev
);
751 device_unregister(&conn
->dev
);
754 EXPORT_SYMBOL_GPL(iscsi_destroy_conn
);
757 * iscsi interface functions
759 static struct iscsi_internal
*
760 iscsi_if_transport_lookup(struct iscsi_transport
*tt
)
762 struct iscsi_internal
*priv
;
765 spin_lock_irqsave(&iscsi_transport_lock
, flags
);
766 list_for_each_entry(priv
, &iscsi_transports
, list
) {
767 if (tt
== priv
->iscsi_transport
) {
768 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
772 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
777 iscsi_broadcast_skb(struct sk_buff
*skb
, gfp_t gfp
)
781 rc
= netlink_broadcast(nls
, skb
, 0, 1, gfp
);
783 printk(KERN_ERR
"iscsi: can not broadcast skb (%d)\n", rc
);
791 iscsi_unicast_skb(struct sk_buff
*skb
, int pid
)
795 rc
= netlink_unicast(nls
, skb
, pid
, MSG_DONTWAIT
);
797 printk(KERN_ERR
"iscsi: can not unicast skb (%d)\n", rc
);
804 int iscsi_recv_pdu(struct iscsi_cls_conn
*conn
, struct iscsi_hdr
*hdr
,
805 char *data
, uint32_t data_size
)
807 struct nlmsghdr
*nlh
;
809 struct iscsi_uevent
*ev
;
811 struct iscsi_internal
*priv
;
812 int len
= NLMSG_SPACE(sizeof(*ev
) + sizeof(struct iscsi_hdr
) +
815 priv
= iscsi_if_transport_lookup(conn
->transport
);
819 skb
= alloc_skb(len
, GFP_ATOMIC
);
821 iscsi_conn_error(conn
, ISCSI_ERR_CONN_FAILED
);
822 iscsi_cls_conn_printk(KERN_ERR
, conn
, "can not deliver "
823 "control PDU: OOM\n");
827 nlh
= __nlmsg_put(skb
, priv
->daemon_pid
, 0, 0, (len
- sizeof(*nlh
)), 0);
828 ev
= NLMSG_DATA(nlh
);
829 memset(ev
, 0, sizeof(*ev
));
830 ev
->transport_handle
= iscsi_handle(conn
->transport
);
831 ev
->type
= ISCSI_KEVENT_RECV_PDU
;
832 ev
->r
.recv_req
.cid
= conn
->cid
;
833 ev
->r
.recv_req
.sid
= iscsi_conn_get_sid(conn
);
834 pdu
= (char*)ev
+ sizeof(*ev
);
835 memcpy(pdu
, hdr
, sizeof(struct iscsi_hdr
));
836 memcpy(pdu
+ sizeof(struct iscsi_hdr
), data
, data_size
);
838 return iscsi_unicast_skb(skb
, priv
->daemon_pid
);
840 EXPORT_SYMBOL_GPL(iscsi_recv_pdu
);
842 void iscsi_conn_error(struct iscsi_cls_conn
*conn
, enum iscsi_err error
)
844 struct nlmsghdr
*nlh
;
846 struct iscsi_uevent
*ev
;
847 struct iscsi_internal
*priv
;
848 int len
= NLMSG_SPACE(sizeof(*ev
));
850 priv
= iscsi_if_transport_lookup(conn
->transport
);
854 skb
= alloc_skb(len
, GFP_ATOMIC
);
856 iscsi_cls_conn_printk(KERN_ERR
, conn
, "gracefully ignored "
857 "conn error (%d)\n", error
);
861 nlh
= __nlmsg_put(skb
, priv
->daemon_pid
, 0, 0, (len
- sizeof(*nlh
)), 0);
862 ev
= NLMSG_DATA(nlh
);
863 ev
->transport_handle
= iscsi_handle(conn
->transport
);
864 ev
->type
= ISCSI_KEVENT_CONN_ERROR
;
865 ev
->r
.connerror
.error
= error
;
866 ev
->r
.connerror
.cid
= conn
->cid
;
867 ev
->r
.connerror
.sid
= iscsi_conn_get_sid(conn
);
869 iscsi_broadcast_skb(skb
, GFP_ATOMIC
);
871 iscsi_cls_conn_printk(KERN_INFO
, conn
, "detected conn error (%d)\n",
874 EXPORT_SYMBOL_GPL(iscsi_conn_error
);
877 iscsi_if_send_reply(int pid
, int seq
, int type
, int done
, int multi
,
878 void *payload
, int size
)
881 struct nlmsghdr
*nlh
;
882 int len
= NLMSG_SPACE(size
);
883 int flags
= multi
? NLM_F_MULTI
: 0;
884 int t
= done
? NLMSG_DONE
: type
;
886 skb
= alloc_skb(len
, GFP_ATOMIC
);
888 printk(KERN_ERR
"Could not allocate skb to send reply.\n");
892 nlh
= __nlmsg_put(skb
, pid
, seq
, t
, (len
- sizeof(*nlh
)), 0);
893 nlh
->nlmsg_flags
= flags
;
894 memcpy(NLMSG_DATA(nlh
), payload
, size
);
895 return iscsi_unicast_skb(skb
, pid
);
899 iscsi_if_get_stats(struct iscsi_transport
*transport
, struct nlmsghdr
*nlh
)
901 struct iscsi_uevent
*ev
= NLMSG_DATA(nlh
);
902 struct iscsi_stats
*stats
;
903 struct sk_buff
*skbstat
;
904 struct iscsi_cls_conn
*conn
;
905 struct nlmsghdr
*nlhstat
;
906 struct iscsi_uevent
*evstat
;
907 struct iscsi_internal
*priv
;
908 int len
= NLMSG_SPACE(sizeof(*ev
) +
909 sizeof(struct iscsi_stats
) +
910 sizeof(struct iscsi_stats_custom
) *
911 ISCSI_STATS_CUSTOM_MAX
);
914 priv
= iscsi_if_transport_lookup(transport
);
918 conn
= iscsi_conn_lookup(ev
->u
.get_stats
.sid
, ev
->u
.get_stats
.cid
);
925 skbstat
= alloc_skb(len
, GFP_ATOMIC
);
927 iscsi_cls_conn_printk(KERN_ERR
, conn
, "can not "
928 "deliver stats: OOM\n");
932 nlhstat
= __nlmsg_put(skbstat
, priv
->daemon_pid
, 0, 0,
933 (len
- sizeof(*nlhstat
)), 0);
934 evstat
= NLMSG_DATA(nlhstat
);
935 memset(evstat
, 0, sizeof(*evstat
));
936 evstat
->transport_handle
= iscsi_handle(conn
->transport
);
937 evstat
->type
= nlh
->nlmsg_type
;
938 evstat
->u
.get_stats
.cid
=
940 evstat
->u
.get_stats
.sid
=
942 stats
= (struct iscsi_stats
*)
943 ((char*)evstat
+ sizeof(*evstat
));
944 memset(stats
, 0, sizeof(*stats
));
946 transport
->get_stats(conn
, stats
);
947 actual_size
= NLMSG_SPACE(sizeof(struct iscsi_uevent
) +
948 sizeof(struct iscsi_stats
) +
949 sizeof(struct iscsi_stats_custom
) *
950 stats
->custom_length
);
951 actual_size
-= sizeof(*nlhstat
);
952 actual_size
= NLMSG_LENGTH(actual_size
);
953 skb_trim(skbstat
, NLMSG_ALIGN(actual_size
));
954 nlhstat
->nlmsg_len
= actual_size
;
956 err
= iscsi_unicast_skb(skbstat
, priv
->daemon_pid
);
957 } while (err
< 0 && err
!= -ECONNREFUSED
);
963 * iscsi_session_event - send session destr. completion event
964 * @session: iscsi class session
965 * @event: type of event
967 int iscsi_session_event(struct iscsi_cls_session
*session
,
968 enum iscsi_uevent_e event
)
970 struct iscsi_internal
*priv
;
971 struct Scsi_Host
*shost
;
972 struct iscsi_uevent
*ev
;
974 struct nlmsghdr
*nlh
;
975 int rc
, len
= NLMSG_SPACE(sizeof(*ev
));
977 priv
= iscsi_if_transport_lookup(session
->transport
);
980 shost
= iscsi_session_to_shost(session
);
982 skb
= alloc_skb(len
, GFP_KERNEL
);
984 iscsi_cls_session_printk(KERN_ERR
, session
,
985 "Cannot notify userspace of session "
986 "event %u\n", event
);
990 nlh
= __nlmsg_put(skb
, priv
->daemon_pid
, 0, 0, (len
- sizeof(*nlh
)), 0);
991 ev
= NLMSG_DATA(nlh
);
992 ev
->transport_handle
= iscsi_handle(session
->transport
);
996 case ISCSI_KEVENT_DESTROY_SESSION
:
997 ev
->r
.d_session
.host_no
= shost
->host_no
;
998 ev
->r
.d_session
.sid
= session
->sid
;
1000 case ISCSI_KEVENT_CREATE_SESSION
:
1001 ev
->r
.c_session_ret
.host_no
= shost
->host_no
;
1002 ev
->r
.c_session_ret
.sid
= session
->sid
;
1004 case ISCSI_KEVENT_UNBIND_SESSION
:
1005 ev
->r
.unbind_session
.host_no
= shost
->host_no
;
1006 ev
->r
.unbind_session
.sid
= session
->sid
;
1009 iscsi_cls_session_printk(KERN_ERR
, session
, "Invalid event "
1016 * this will occur if the daemon is not up, so we just warn
1017 * the user and when the daemon is restarted it will handle it
1019 rc
= iscsi_broadcast_skb(skb
, GFP_KERNEL
);
1021 iscsi_cls_session_printk(KERN_ERR
, session
,
1022 "Cannot notify userspace of session "
1023 "event %u. Check iscsi daemon\n",
1027 EXPORT_SYMBOL_GPL(iscsi_session_event
);
1030 iscsi_if_create_session(struct iscsi_internal
*priv
, struct iscsi_uevent
*ev
,
1031 uint32_t host_no
, uint32_t initial_cmdsn
,
1032 uint16_t cmds_max
, uint16_t queue_depth
)
1034 struct iscsi_transport
*transport
= priv
->iscsi_transport
;
1035 struct iscsi_cls_session
*session
;
1036 struct Scsi_Host
*shost
= NULL
;
1039 * Software iscsi allocates a host per session, but
1040 * offload drivers (and possibly iser one day) allocate a host per
1041 * hba/nic/rnic. Offload will match a host here, but software will
1042 * return a new hostno after the create_session callback has returned.
1044 if (host_no
!= UINT_MAX
) {
1045 shost
= scsi_host_lookup(host_no
);
1046 if (IS_ERR(shost
)) {
1047 printk(KERN_ERR
"Could not find host no %u to "
1048 "create session\n", host_no
);
1053 session
= transport
->create_session(shost
, cmds_max
, queue_depth
,
1054 initial_cmdsn
, &host_no
);
1056 scsi_host_put(shost
);
1060 ev
->r
.c_session_ret
.host_no
= host_no
;
1061 ev
->r
.c_session_ret
.sid
= session
->sid
;
1066 iscsi_if_create_conn(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
1068 struct iscsi_cls_conn
*conn
;
1069 struct iscsi_cls_session
*session
;
1071 session
= iscsi_session_lookup(ev
->u
.c_conn
.sid
);
1073 printk(KERN_ERR
"iscsi: invalid session %d.\n",
1078 conn
= transport
->create_conn(session
, ev
->u
.c_conn
.cid
);
1080 iscsi_cls_session_printk(KERN_ERR
, session
,
1081 "couldn't create a new connection.");
1085 ev
->r
.c_conn_ret
.sid
= session
->sid
;
1086 ev
->r
.c_conn_ret
.cid
= conn
->cid
;
1091 iscsi_if_destroy_conn(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
1093 struct iscsi_cls_conn
*conn
;
1095 conn
= iscsi_conn_lookup(ev
->u
.d_conn
.sid
, ev
->u
.d_conn
.cid
);
1099 if (transport
->destroy_conn
)
1100 transport
->destroy_conn(conn
);
1105 iscsi_set_param(struct iscsi_transport
*transport
, struct iscsi_uevent
*ev
)
1107 char *data
= (char*)ev
+ sizeof(*ev
);
1108 struct iscsi_cls_conn
*conn
;
1109 struct iscsi_cls_session
*session
;
1110 int err
= 0, value
= 0;
1112 session
= iscsi_session_lookup(ev
->u
.set_param
.sid
);
1113 conn
= iscsi_conn_lookup(ev
->u
.set_param
.sid
, ev
->u
.set_param
.cid
);
1114 if (!conn
|| !session
)
1117 switch (ev
->u
.set_param
.param
) {
1118 case ISCSI_PARAM_SESS_RECOVERY_TMO
:
1119 sscanf(data
, "%d", &value
);
1121 session
->recovery_tmo
= value
;
1124 err
= transport
->set_param(conn
, ev
->u
.set_param
.param
,
1125 data
, ev
->u
.set_param
.len
);
1132 iscsi_if_transport_ep(struct iscsi_transport
*transport
,
1133 struct iscsi_uevent
*ev
, int msg_type
)
1135 struct sockaddr
*dst_addr
;
1139 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT
:
1140 if (!transport
->ep_connect
)
1143 dst_addr
= (struct sockaddr
*)((char*)ev
+ sizeof(*ev
));
1144 rc
= transport
->ep_connect(dst_addr
,
1145 ev
->u
.ep_connect
.non_blocking
,
1146 &ev
->r
.ep_connect_ret
.handle
);
1148 case ISCSI_UEVENT_TRANSPORT_EP_POLL
:
1149 if (!transport
->ep_poll
)
1152 ev
->r
.retcode
= transport
->ep_poll(ev
->u
.ep_poll
.ep_handle
,
1153 ev
->u
.ep_poll
.timeout_ms
);
1155 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT
:
1156 if (!transport
->ep_disconnect
)
1159 transport
->ep_disconnect(ev
->u
.ep_disconnect
.ep_handle
);
1166 iscsi_tgt_dscvr(struct iscsi_transport
*transport
,
1167 struct iscsi_uevent
*ev
)
1169 struct Scsi_Host
*shost
;
1170 struct sockaddr
*dst_addr
;
1173 if (!transport
->tgt_dscvr
)
1176 shost
= scsi_host_lookup(ev
->u
.tgt_dscvr
.host_no
);
1177 if (IS_ERR(shost
)) {
1178 printk(KERN_ERR
"target discovery could not find host no %u\n",
1179 ev
->u
.tgt_dscvr
.host_no
);
1184 dst_addr
= (struct sockaddr
*)((char*)ev
+ sizeof(*ev
));
1185 err
= transport
->tgt_dscvr(shost
, ev
->u
.tgt_dscvr
.type
,
1186 ev
->u
.tgt_dscvr
.enable
, dst_addr
);
1187 scsi_host_put(shost
);
1192 iscsi_set_host_param(struct iscsi_transport
*transport
,
1193 struct iscsi_uevent
*ev
)
1195 char *data
= (char*)ev
+ sizeof(*ev
);
1196 struct Scsi_Host
*shost
;
1199 if (!transport
->set_host_param
)
1202 shost
= scsi_host_lookup(ev
->u
.set_host_param
.host_no
);
1203 if (IS_ERR(shost
)) {
1204 printk(KERN_ERR
"set_host_param could not find host no %u\n",
1205 ev
->u
.set_host_param
.host_no
);
1209 err
= transport
->set_host_param(shost
, ev
->u
.set_host_param
.param
,
1210 data
, ev
->u
.set_host_param
.len
);
1211 scsi_host_put(shost
);
1216 iscsi_if_recv_msg(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
1219 uint32_t host_no
= UINT_MAX
;
1220 struct iscsi_uevent
*ev
= NLMSG_DATA(nlh
);
1221 struct iscsi_transport
*transport
= NULL
;
1222 struct iscsi_internal
*priv
;
1223 struct iscsi_cls_session
*session
;
1224 struct iscsi_cls_conn
*conn
;
1226 priv
= iscsi_if_transport_lookup(iscsi_ptr(ev
->transport_handle
));
1229 transport
= priv
->iscsi_transport
;
1231 if (!try_module_get(transport
->owner
))
1234 priv
->daemon_pid
= NETLINK_CREDS(skb
)->pid
;
1236 switch (nlh
->nlmsg_type
) {
1237 case ISCSI_UEVENT_CREATE_SESSION
:
1238 err
= iscsi_if_create_session(priv
, ev
, host_no
,
1239 ev
->u
.c_session
.initial_cmdsn
,
1240 ev
->u
.c_session
.cmds_max
,
1241 ev
->u
.c_session
.queue_depth
);
1243 case ISCSI_UEVENT_CREATE_BOUND_SESSION
:
1244 err
= iscsi_if_create_session(priv
, ev
,
1245 ev
->u
.c_bound_session
.host_no
,
1246 ev
->u
.c_bound_session
.initial_cmdsn
,
1247 ev
->u
.c_bound_session
.cmds_max
,
1248 ev
->u
.c_bound_session
.queue_depth
);
1250 case ISCSI_UEVENT_DESTROY_SESSION
:
1251 session
= iscsi_session_lookup(ev
->u
.d_session
.sid
);
1253 transport
->destroy_session(session
);
1257 case ISCSI_UEVENT_UNBIND_SESSION
:
1258 session
= iscsi_session_lookup(ev
->u
.d_session
.sid
);
1260 iscsi_unbind_session(session
);
1264 case ISCSI_UEVENT_CREATE_CONN
:
1265 err
= iscsi_if_create_conn(transport
, ev
);
1267 case ISCSI_UEVENT_DESTROY_CONN
:
1268 err
= iscsi_if_destroy_conn(transport
, ev
);
1270 case ISCSI_UEVENT_BIND_CONN
:
1271 session
= iscsi_session_lookup(ev
->u
.b_conn
.sid
);
1272 conn
= iscsi_conn_lookup(ev
->u
.b_conn
.sid
, ev
->u
.b_conn
.cid
);
1274 if (session
&& conn
)
1275 ev
->r
.retcode
= transport
->bind_conn(session
, conn
,
1276 ev
->u
.b_conn
.transport_eph
,
1277 ev
->u
.b_conn
.is_leading
);
1281 case ISCSI_UEVENT_SET_PARAM
:
1282 err
= iscsi_set_param(transport
, ev
);
1284 case ISCSI_UEVENT_START_CONN
:
1285 conn
= iscsi_conn_lookup(ev
->u
.start_conn
.sid
, ev
->u
.start_conn
.cid
);
1287 ev
->r
.retcode
= transport
->start_conn(conn
);
1291 case ISCSI_UEVENT_STOP_CONN
:
1292 conn
= iscsi_conn_lookup(ev
->u
.stop_conn
.sid
, ev
->u
.stop_conn
.cid
);
1294 transport
->stop_conn(conn
, ev
->u
.stop_conn
.flag
);
1298 case ISCSI_UEVENT_SEND_PDU
:
1299 conn
= iscsi_conn_lookup(ev
->u
.send_pdu
.sid
, ev
->u
.send_pdu
.cid
);
1301 ev
->r
.retcode
= transport
->send_pdu(conn
,
1302 (struct iscsi_hdr
*)((char*)ev
+ sizeof(*ev
)),
1303 (char*)ev
+ sizeof(*ev
) + ev
->u
.send_pdu
.hdr_size
,
1304 ev
->u
.send_pdu
.data_size
);
1308 case ISCSI_UEVENT_GET_STATS
:
1309 err
= iscsi_if_get_stats(transport
, nlh
);
1311 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT
:
1312 case ISCSI_UEVENT_TRANSPORT_EP_POLL
:
1313 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT
:
1314 err
= iscsi_if_transport_ep(transport
, ev
, nlh
->nlmsg_type
);
1316 case ISCSI_UEVENT_TGT_DSCVR
:
1317 err
= iscsi_tgt_dscvr(transport
, ev
);
1319 case ISCSI_UEVENT_SET_HOST_PARAM
:
1320 err
= iscsi_set_host_param(transport
, ev
);
1327 module_put(transport
->owner
);
1332 * Get message from skb. Each message is processed by iscsi_if_recv_msg.
1333 * Malformed skbs with wrong lengths or invalid creds are not processed.
1336 iscsi_if_rx(struct sk_buff
*skb
)
1338 mutex_lock(&rx_queue_mutex
);
1339 while (skb
->len
>= NLMSG_SPACE(0)) {
1342 struct nlmsghdr
*nlh
;
1343 struct iscsi_uevent
*ev
;
1345 nlh
= nlmsg_hdr(skb
);
1346 if (nlh
->nlmsg_len
< sizeof(*nlh
) ||
1347 skb
->len
< nlh
->nlmsg_len
) {
1351 ev
= NLMSG_DATA(nlh
);
1352 rlen
= NLMSG_ALIGN(nlh
->nlmsg_len
);
1353 if (rlen
> skb
->len
)
1356 err
= iscsi_if_recv_msg(skb
, nlh
);
1358 ev
->type
= ISCSI_KEVENT_IF_ERROR
;
1363 * special case for GET_STATS:
1364 * on success - sending reply and stats from
1365 * inside of if_recv_msg(),
1366 * on error - fall through.
1368 if (ev
->type
== ISCSI_UEVENT_GET_STATS
&& !err
)
1370 err
= iscsi_if_send_reply(
1371 NETLINK_CREDS(skb
)->pid
, nlh
->nlmsg_seq
,
1372 nlh
->nlmsg_type
, 0, 0, ev
, sizeof(*ev
));
1373 } while (err
< 0 && err
!= -ECONNREFUSED
);
1374 skb_pull(skb
, rlen
);
1376 mutex_unlock(&rx_queue_mutex
);
1379 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \
1380 struct device_attribute dev_attr_##_prefix##_##_name = \
1381 __ATTR(_name,_mode,_show,_store)
1384 * iSCSI connection attrs
1386 #define iscsi_conn_attr_show(param) \
1388 show_conn_param_##param(struct device *dev, \
1389 struct device_attribute *attr, char *buf) \
1391 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
1392 struct iscsi_transport *t = conn->transport; \
1393 return t->get_conn_param(conn, param, buf); \
1396 #define iscsi_conn_attr(field, param) \
1397 iscsi_conn_attr_show(param) \
1398 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param, \
1401 iscsi_conn_attr(max_recv_dlength
, ISCSI_PARAM_MAX_RECV_DLENGTH
);
1402 iscsi_conn_attr(max_xmit_dlength
, ISCSI_PARAM_MAX_XMIT_DLENGTH
);
1403 iscsi_conn_attr(header_digest
, ISCSI_PARAM_HDRDGST_EN
);
1404 iscsi_conn_attr(data_digest
, ISCSI_PARAM_DATADGST_EN
);
1405 iscsi_conn_attr(ifmarker
, ISCSI_PARAM_IFMARKER_EN
);
1406 iscsi_conn_attr(ofmarker
, ISCSI_PARAM_OFMARKER_EN
);
1407 iscsi_conn_attr(persistent_port
, ISCSI_PARAM_PERSISTENT_PORT
);
1408 iscsi_conn_attr(port
, ISCSI_PARAM_CONN_PORT
);
1409 iscsi_conn_attr(exp_statsn
, ISCSI_PARAM_EXP_STATSN
);
1410 iscsi_conn_attr(persistent_address
, ISCSI_PARAM_PERSISTENT_ADDRESS
);
1411 iscsi_conn_attr(address
, ISCSI_PARAM_CONN_ADDRESS
);
1412 iscsi_conn_attr(ping_tmo
, ISCSI_PARAM_PING_TMO
);
1413 iscsi_conn_attr(recv_tmo
, ISCSI_PARAM_RECV_TMO
);
1416 * iSCSI session attrs
1418 #define iscsi_session_attr_show(param, perm) \
1420 show_session_param_##param(struct device *dev, \
1421 struct device_attribute *attr, char *buf) \
1423 struct iscsi_cls_session *session = \
1424 iscsi_dev_to_session(dev->parent); \
1425 struct iscsi_transport *t = session->transport; \
1427 if (perm && !capable(CAP_SYS_ADMIN)) \
1429 return t->get_session_param(session, param, buf); \
1432 #define iscsi_session_attr(field, param, perm) \
1433 iscsi_session_attr_show(param, perm) \
1434 static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
1437 iscsi_session_attr(targetname
, ISCSI_PARAM_TARGET_NAME
, 0);
1438 iscsi_session_attr(initial_r2t
, ISCSI_PARAM_INITIAL_R2T_EN
, 0);
1439 iscsi_session_attr(max_outstanding_r2t
, ISCSI_PARAM_MAX_R2T
, 0);
1440 iscsi_session_attr(immediate_data
, ISCSI_PARAM_IMM_DATA_EN
, 0);
1441 iscsi_session_attr(first_burst_len
, ISCSI_PARAM_FIRST_BURST
, 0);
1442 iscsi_session_attr(max_burst_len
, ISCSI_PARAM_MAX_BURST
, 0);
1443 iscsi_session_attr(data_pdu_in_order
, ISCSI_PARAM_PDU_INORDER_EN
, 0);
1444 iscsi_session_attr(data_seq_in_order
, ISCSI_PARAM_DATASEQ_INORDER_EN
, 0);
1445 iscsi_session_attr(erl
, ISCSI_PARAM_ERL
, 0);
1446 iscsi_session_attr(tpgt
, ISCSI_PARAM_TPGT
, 0);
1447 iscsi_session_attr(username
, ISCSI_PARAM_USERNAME
, 1);
1448 iscsi_session_attr(username_in
, ISCSI_PARAM_USERNAME_IN
, 1);
1449 iscsi_session_attr(password
, ISCSI_PARAM_PASSWORD
, 1);
1450 iscsi_session_attr(password_in
, ISCSI_PARAM_PASSWORD_IN
, 1);
1451 iscsi_session_attr(fast_abort
, ISCSI_PARAM_FAST_ABORT
, 0);
1452 iscsi_session_attr(abort_tmo
, ISCSI_PARAM_ABORT_TMO
, 0);
1453 iscsi_session_attr(lu_reset_tmo
, ISCSI_PARAM_LU_RESET_TMO
, 0);
1456 show_priv_session_state(struct device
*dev
, struct device_attribute
*attr
,
1459 struct iscsi_cls_session
*session
= iscsi_dev_to_session(dev
->parent
);
1460 return sprintf(buf
, "%s\n", iscsi_session_state_name(session
->state
));
1462 static ISCSI_CLASS_ATTR(priv_sess
, state
, S_IRUGO
, show_priv_session_state
,
1465 #define iscsi_priv_session_attr_show(field, format) \
1467 show_priv_session_##field(struct device *dev, \
1468 struct device_attribute *attr, char *buf) \
1470 struct iscsi_cls_session *session = \
1471 iscsi_dev_to_session(dev->parent); \
1472 return sprintf(buf, format"\n", session->field); \
1475 #define iscsi_priv_session_attr(field, format) \
1476 iscsi_priv_session_attr_show(field, format) \
1477 static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO, show_priv_session_##field, \
1479 iscsi_priv_session_attr(recovery_tmo
, "%d");
1484 #define iscsi_host_attr_show(param) \
1486 show_host_param_##param(struct device *dev, \
1487 struct device_attribute *attr, char *buf) \
1489 struct Scsi_Host *shost = transport_class_to_shost(dev); \
1490 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
1491 return priv->iscsi_transport->get_host_param(shost, param, buf); \
1494 #define iscsi_host_attr(field, param) \
1495 iscsi_host_attr_show(param) \
1496 static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param, \
1499 iscsi_host_attr(netdev
, ISCSI_HOST_PARAM_NETDEV_NAME
);
1500 iscsi_host_attr(hwaddress
, ISCSI_HOST_PARAM_HWADDRESS
);
1501 iscsi_host_attr(ipaddress
, ISCSI_HOST_PARAM_IPADDRESS
);
1502 iscsi_host_attr(initiatorname
, ISCSI_HOST_PARAM_INITIATOR_NAME
);
1504 #define SETUP_PRIV_SESSION_RD_ATTR(field) \
1506 priv->session_attrs[count] = &dev_attr_priv_sess_##field; \
1511 #define SETUP_SESSION_RD_ATTR(field, param_flag) \
1513 if (tt->param_mask & param_flag) { \
1514 priv->session_attrs[count] = &dev_attr_sess_##field; \
1519 #define SETUP_CONN_RD_ATTR(field, param_flag) \
1521 if (tt->param_mask & param_flag) { \
1522 priv->conn_attrs[count] = &dev_attr_conn_##field; \
1527 #define SETUP_HOST_RD_ATTR(field, param_flag) \
1529 if (tt->host_param_mask & param_flag) { \
1530 priv->host_attrs[count] = &dev_attr_host_##field; \
1535 static int iscsi_session_match(struct attribute_container
*cont
,
1538 struct iscsi_cls_session
*session
;
1539 struct Scsi_Host
*shost
;
1540 struct iscsi_internal
*priv
;
1542 if (!iscsi_is_session_dev(dev
))
1545 session
= iscsi_dev_to_session(dev
);
1546 shost
= iscsi_session_to_shost(session
);
1547 if (!shost
->transportt
)
1550 priv
= to_iscsi_internal(shost
->transportt
);
1551 if (priv
->session_cont
.ac
.class != &iscsi_session_class
.class)
1554 return &priv
->session_cont
.ac
== cont
;
1557 static int iscsi_conn_match(struct attribute_container
*cont
,
1560 struct iscsi_cls_session
*session
;
1561 struct iscsi_cls_conn
*conn
;
1562 struct Scsi_Host
*shost
;
1563 struct iscsi_internal
*priv
;
1565 if (!iscsi_is_conn_dev(dev
))
1568 conn
= iscsi_dev_to_conn(dev
);
1569 session
= iscsi_dev_to_session(conn
->dev
.parent
);
1570 shost
= iscsi_session_to_shost(session
);
1572 if (!shost
->transportt
)
1575 priv
= to_iscsi_internal(shost
->transportt
);
1576 if (priv
->conn_cont
.ac
.class != &iscsi_connection_class
.class)
1579 return &priv
->conn_cont
.ac
== cont
;
1582 static int iscsi_host_match(struct attribute_container
*cont
,
1585 struct Scsi_Host
*shost
;
1586 struct iscsi_internal
*priv
;
1588 if (!scsi_is_host_device(dev
))
1591 shost
= dev_to_shost(dev
);
1592 if (!shost
->transportt
||
1593 shost
->transportt
->host_attrs
.ac
.class != &iscsi_host_class
.class)
1596 priv
= to_iscsi_internal(shost
->transportt
);
1597 return &priv
->t
.host_attrs
.ac
== cont
;
1600 struct scsi_transport_template
*
1601 iscsi_register_transport(struct iscsi_transport
*tt
)
1603 struct iscsi_internal
*priv
;
1604 unsigned long flags
;
1609 priv
= iscsi_if_transport_lookup(tt
);
1613 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
1616 INIT_LIST_HEAD(&priv
->list
);
1617 priv
->daemon_pid
= -1;
1618 priv
->iscsi_transport
= tt
;
1619 priv
->t
.user_scan
= iscsi_user_scan
;
1620 if (!(tt
->caps
& CAP_DATA_PATH_OFFLOAD
))
1621 priv
->t
.create_work_queue
= 1;
1623 priv
->dev
.class = &iscsi_transport_class
;
1624 snprintf(priv
->dev
.bus_id
, BUS_ID_SIZE
, "%s", tt
->name
);
1625 err
= device_register(&priv
->dev
);
1629 err
= sysfs_create_group(&priv
->dev
.kobj
, &iscsi_transport_group
);
1631 goto unregister_dev
;
1633 /* host parameters */
1634 priv
->t
.host_attrs
.ac
.attrs
= &priv
->host_attrs
[0];
1635 priv
->t
.host_attrs
.ac
.class = &iscsi_host_class
.class;
1636 priv
->t
.host_attrs
.ac
.match
= iscsi_host_match
;
1637 priv
->t
.host_size
= sizeof(struct iscsi_cls_host
);
1638 transport_container_register(&priv
->t
.host_attrs
);
1640 SETUP_HOST_RD_ATTR(netdev
, ISCSI_HOST_NETDEV_NAME
);
1641 SETUP_HOST_RD_ATTR(ipaddress
, ISCSI_HOST_IPADDRESS
);
1642 SETUP_HOST_RD_ATTR(hwaddress
, ISCSI_HOST_HWADDRESS
);
1643 SETUP_HOST_RD_ATTR(initiatorname
, ISCSI_HOST_INITIATOR_NAME
);
1644 BUG_ON(count
> ISCSI_HOST_ATTRS
);
1645 priv
->host_attrs
[count
] = NULL
;
1648 /* connection parameters */
1649 priv
->conn_cont
.ac
.attrs
= &priv
->conn_attrs
[0];
1650 priv
->conn_cont
.ac
.class = &iscsi_connection_class
.class;
1651 priv
->conn_cont
.ac
.match
= iscsi_conn_match
;
1652 transport_container_register(&priv
->conn_cont
);
1654 SETUP_CONN_RD_ATTR(max_recv_dlength
, ISCSI_MAX_RECV_DLENGTH
);
1655 SETUP_CONN_RD_ATTR(max_xmit_dlength
, ISCSI_MAX_XMIT_DLENGTH
);
1656 SETUP_CONN_RD_ATTR(header_digest
, ISCSI_HDRDGST_EN
);
1657 SETUP_CONN_RD_ATTR(data_digest
, ISCSI_DATADGST_EN
);
1658 SETUP_CONN_RD_ATTR(ifmarker
, ISCSI_IFMARKER_EN
);
1659 SETUP_CONN_RD_ATTR(ofmarker
, ISCSI_OFMARKER_EN
);
1660 SETUP_CONN_RD_ATTR(address
, ISCSI_CONN_ADDRESS
);
1661 SETUP_CONN_RD_ATTR(port
, ISCSI_CONN_PORT
);
1662 SETUP_CONN_RD_ATTR(exp_statsn
, ISCSI_EXP_STATSN
);
1663 SETUP_CONN_RD_ATTR(persistent_address
, ISCSI_PERSISTENT_ADDRESS
);
1664 SETUP_CONN_RD_ATTR(persistent_port
, ISCSI_PERSISTENT_PORT
);
1665 SETUP_CONN_RD_ATTR(ping_tmo
, ISCSI_PING_TMO
);
1666 SETUP_CONN_RD_ATTR(recv_tmo
, ISCSI_RECV_TMO
);
1668 BUG_ON(count
> ISCSI_CONN_ATTRS
);
1669 priv
->conn_attrs
[count
] = NULL
;
1672 /* session parameters */
1673 priv
->session_cont
.ac
.attrs
= &priv
->session_attrs
[0];
1674 priv
->session_cont
.ac
.class = &iscsi_session_class
.class;
1675 priv
->session_cont
.ac
.match
= iscsi_session_match
;
1676 transport_container_register(&priv
->session_cont
);
1678 SETUP_SESSION_RD_ATTR(initial_r2t
, ISCSI_INITIAL_R2T_EN
);
1679 SETUP_SESSION_RD_ATTR(max_outstanding_r2t
, ISCSI_MAX_R2T
);
1680 SETUP_SESSION_RD_ATTR(immediate_data
, ISCSI_IMM_DATA_EN
);
1681 SETUP_SESSION_RD_ATTR(first_burst_len
, ISCSI_FIRST_BURST
);
1682 SETUP_SESSION_RD_ATTR(max_burst_len
, ISCSI_MAX_BURST
);
1683 SETUP_SESSION_RD_ATTR(data_pdu_in_order
, ISCSI_PDU_INORDER_EN
);
1684 SETUP_SESSION_RD_ATTR(data_seq_in_order
, ISCSI_DATASEQ_INORDER_EN
);
1685 SETUP_SESSION_RD_ATTR(erl
, ISCSI_ERL
);
1686 SETUP_SESSION_RD_ATTR(targetname
, ISCSI_TARGET_NAME
);
1687 SETUP_SESSION_RD_ATTR(tpgt
, ISCSI_TPGT
);
1688 SETUP_SESSION_RD_ATTR(password
, ISCSI_USERNAME
);
1689 SETUP_SESSION_RD_ATTR(password_in
, ISCSI_USERNAME_IN
);
1690 SETUP_SESSION_RD_ATTR(username
, ISCSI_PASSWORD
);
1691 SETUP_SESSION_RD_ATTR(username_in
, ISCSI_PASSWORD_IN
);
1692 SETUP_SESSION_RD_ATTR(fast_abort
, ISCSI_FAST_ABORT
);
1693 SETUP_SESSION_RD_ATTR(abort_tmo
, ISCSI_ABORT_TMO
);
1694 SETUP_SESSION_RD_ATTR(lu_reset_tmo
,ISCSI_LU_RESET_TMO
);
1695 SETUP_PRIV_SESSION_RD_ATTR(recovery_tmo
);
1696 SETUP_PRIV_SESSION_RD_ATTR(state
);
1698 BUG_ON(count
> ISCSI_SESSION_ATTRS
);
1699 priv
->session_attrs
[count
] = NULL
;
1701 spin_lock_irqsave(&iscsi_transport_lock
, flags
);
1702 list_add(&priv
->list
, &iscsi_transports
);
1703 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
1705 printk(KERN_NOTICE
"iscsi: registered transport (%s)\n", tt
->name
);
1709 device_unregister(&priv
->dev
);
1714 EXPORT_SYMBOL_GPL(iscsi_register_transport
);
1716 int iscsi_unregister_transport(struct iscsi_transport
*tt
)
1718 struct iscsi_internal
*priv
;
1719 unsigned long flags
;
1723 mutex_lock(&rx_queue_mutex
);
1725 priv
= iscsi_if_transport_lookup(tt
);
1728 spin_lock_irqsave(&iscsi_transport_lock
, flags
);
1729 list_del(&priv
->list
);
1730 spin_unlock_irqrestore(&iscsi_transport_lock
, flags
);
1732 transport_container_unregister(&priv
->conn_cont
);
1733 transport_container_unregister(&priv
->session_cont
);
1734 transport_container_unregister(&priv
->t
.host_attrs
);
1736 sysfs_remove_group(&priv
->dev
.kobj
, &iscsi_transport_group
);
1737 device_unregister(&priv
->dev
);
1738 mutex_unlock(&rx_queue_mutex
);
1742 EXPORT_SYMBOL_GPL(iscsi_unregister_transport
);
1744 static __init
int iscsi_transport_init(void)
1748 printk(KERN_INFO
"Loading iSCSI transport class v%s.\n",
1749 ISCSI_TRANSPORT_VERSION
);
1751 atomic_set(&iscsi_session_nr
, 0);
1753 err
= class_register(&iscsi_transport_class
);
1757 err
= transport_class_register(&iscsi_host_class
);
1759 goto unregister_transport_class
;
1761 err
= transport_class_register(&iscsi_connection_class
);
1763 goto unregister_host_class
;
1765 err
= transport_class_register(&iscsi_session_class
);
1767 goto unregister_conn_class
;
1769 nls
= netlink_kernel_create(&init_net
, NETLINK_ISCSI
, 1, iscsi_if_rx
, NULL
,
1773 goto unregister_session_class
;
1776 iscsi_eh_timer_workq
= create_singlethread_workqueue("iscsi_eh");
1777 if (!iscsi_eh_timer_workq
)
1783 netlink_kernel_release(nls
);
1784 unregister_session_class
:
1785 transport_class_unregister(&iscsi_session_class
);
1786 unregister_conn_class
:
1787 transport_class_unregister(&iscsi_connection_class
);
1788 unregister_host_class
:
1789 transport_class_unregister(&iscsi_host_class
);
1790 unregister_transport_class
:
1791 class_unregister(&iscsi_transport_class
);
1795 static void __exit
iscsi_transport_exit(void)
1797 destroy_workqueue(iscsi_eh_timer_workq
);
1798 netlink_kernel_release(nls
);
1799 transport_class_unregister(&iscsi_connection_class
);
1800 transport_class_unregister(&iscsi_session_class
);
1801 transport_class_unregister(&iscsi_host_class
);
1802 class_unregister(&iscsi_transport_class
);
1805 module_init(iscsi_transport_init
);
1806 module_exit(iscsi_transport_exit
);
1808 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
1809 "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
1810 "Alex Aizman <itn780@yahoo.com>");
1811 MODULE_DESCRIPTION("iSCSI Transport Interface");
1812 MODULE_LICENSE("GPL");
1813 MODULE_VERSION(ISCSI_TRANSPORT_VERSION
);