f39da0cf5f1864335ca9335876dfd2e37d79eacc
[linux-2.6.git] / drivers / scsi / scsi_transport_iscsi.c
1 /*
2  * iSCSI transport class definitions
3  *
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
8  *
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.
13  *
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.
18  *
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.
22  */
23 #include <linux/module.h>
24 #include <linux/mempool.h>
25 #include <linux/mutex.h>
26 #include <net/tcp.h>
27 #include <scsi/scsi.h>
28 #include <scsi/scsi_host.h>
29 #include <scsi/scsi_device.h>
30 #include <scsi/scsi_transport.h>
31 #include <scsi/scsi_transport_iscsi.h>
32 #include <scsi/iscsi_if.h>
33
34 #define ISCSI_SESSION_ATTRS 11
35 #define ISCSI_CONN_ATTRS 11
36 #define ISCSI_HOST_ATTRS 0
37
38 struct iscsi_internal {
39         int daemon_pid;
40         struct scsi_transport_template t;
41         struct iscsi_transport *iscsi_transport;
42         struct list_head list;
43         struct class_device cdev;
44
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];
50 };
51
52 static int iscsi_session_nr;    /* sysfs session id for next new session */
53
54 /*
55  * list of registered transports and lock that must
56  * be held while accessing list. The iscsi_transport_lock must
57  * be acquired after the rx_queue_mutex.
58  */
59 static LIST_HEAD(iscsi_transports);
60 static DEFINE_SPINLOCK(iscsi_transport_lock);
61
62 #define to_iscsi_internal(tmpl) \
63         container_of(tmpl, struct iscsi_internal, t)
64
65 #define cdev_to_iscsi_internal(_cdev) \
66         container_of(_cdev, struct iscsi_internal, cdev)
67
68 static void iscsi_transport_release(struct class_device *cdev)
69 {
70         struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
71         kfree(priv);
72 }
73
74 /*
75  * iscsi_transport_class represents the iscsi_transports that are
76  * registered.
77  */
78 static struct class iscsi_transport_class = {
79         .name = "iscsi_transport",
80         .release = iscsi_transport_release,
81 };
82
83 static ssize_t
84 show_transport_handle(struct class_device *cdev, char *buf)
85 {
86         struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
87         return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
88 }
89 static CLASS_DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
90
91 #define show_transport_attr(name, format)                               \
92 static ssize_t                                                          \
93 show_transport_##name(struct class_device *cdev, char *buf)             \
94 {                                                                       \
95         struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);     \
96         return sprintf(buf, format"\n", priv->iscsi_transport->name);   \
97 }                                                                       \
98 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
99
100 show_transport_attr(caps, "0x%x");
101 show_transport_attr(max_lun, "%d");
102 show_transport_attr(max_conn, "%d");
103 show_transport_attr(max_cmd_len, "%d");
104
105 static struct attribute *iscsi_transport_attrs[] = {
106         &class_device_attr_handle.attr,
107         &class_device_attr_caps.attr,
108         &class_device_attr_max_lun.attr,
109         &class_device_attr_max_conn.attr,
110         &class_device_attr_max_cmd_len.attr,
111         NULL,
112 };
113
114 static struct attribute_group iscsi_transport_group = {
115         .attrs = iscsi_transport_attrs,
116 };
117
118 static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
119                             struct class_device *cdev)
120 {
121         struct Scsi_Host *shost = dev_to_shost(dev);
122         struct iscsi_host *ihost = shost->shost_data;
123
124         memset(ihost, 0, sizeof(*ihost));
125         INIT_LIST_HEAD(&ihost->sessions);
126         mutex_init(&ihost->mutex);
127         return 0;
128 }
129
130 static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
131                                "iscsi_host",
132                                iscsi_setup_host,
133                                NULL,
134                                NULL);
135
136 static DECLARE_TRANSPORT_CLASS(iscsi_session_class,
137                                "iscsi_session",
138                                NULL,
139                                NULL,
140                                NULL);
141
142 static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
143                                "iscsi_connection",
144                                NULL,
145                                NULL,
146                                NULL);
147
148 static struct sock *nls;
149 static DEFINE_MUTEX(rx_queue_mutex);
150
151 struct mempool_zone {
152         mempool_t *pool;
153         atomic_t allocated;
154         int size;
155         int hiwat;
156         struct list_head freequeue;
157         spinlock_t freelock;
158 };
159
160 static struct mempool_zone *z_reply;
161
162 /*
163  * Z_MAX_* - actual mempool size allocated at the mempool_zone_init() time
164  * Z_HIWAT_* - zone's high watermark when if_error bit will be set to -ENOMEM
165  *             so daemon will notice OOM on NETLINK tranposrt level and will
166  *             be able to predict or change operational behavior
167  */
168 #define Z_MAX_REPLY     8
169 #define Z_HIWAT_REPLY   6
170 #define Z_MAX_PDU       8
171 #define Z_HIWAT_PDU     6
172 #define Z_MAX_ERROR     16
173 #define Z_HIWAT_ERROR   12
174
175 static LIST_HEAD(sesslist);
176 static DEFINE_SPINLOCK(sesslock);
177 static LIST_HEAD(connlist);
178 static DEFINE_SPINLOCK(connlock);
179
180 static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn *conn)
181 {
182         struct iscsi_cls_session *sess = iscsi_dev_to_session(conn->dev.parent);
183         return sess->sid;
184 }
185
186 /*
187  * Returns the matching session to a given sid
188  */
189 static struct iscsi_cls_session *iscsi_session_lookup(uint32_t sid)
190 {
191         unsigned long flags;
192         struct iscsi_cls_session *sess;
193
194         spin_lock_irqsave(&sesslock, flags);
195         list_for_each_entry(sess, &sesslist, sess_list) {
196                 if (sess->sid == sid) {
197                         spin_unlock_irqrestore(&sesslock, flags);
198                         return sess;
199                 }
200         }
201         spin_unlock_irqrestore(&sesslock, flags);
202         return NULL;
203 }
204
205 /*
206  * Returns the matching connection to a given sid / cid tuple
207  */
208 static struct iscsi_cls_conn *iscsi_conn_lookup(uint32_t sid, uint32_t cid)
209 {
210         unsigned long flags;
211         struct iscsi_cls_conn *conn;
212
213         spin_lock_irqsave(&connlock, flags);
214         list_for_each_entry(conn, &connlist, conn_list) {
215                 if ((conn->cid == cid) && (iscsi_conn_get_sid(conn) == sid)) {
216                         spin_unlock_irqrestore(&connlock, flags);
217                         return conn;
218                 }
219         }
220         spin_unlock_irqrestore(&connlock, flags);
221         return NULL;
222 }
223
224 /*
225  * The following functions can be used by LLDs that allocate
226  * their own scsi_hosts or by software iscsi LLDs
227  */
228 static void iscsi_session_release(struct device *dev)
229 {
230         struct iscsi_cls_session *session = iscsi_dev_to_session(dev);
231         struct Scsi_Host *shost;
232
233         shost = iscsi_session_to_shost(session);
234         scsi_host_put(shost);
235         kfree(session);
236 }
237
238 static int iscsi_is_session_dev(const struct device *dev)
239 {
240         return dev->release == iscsi_session_release;
241 }
242
243 static int iscsi_user_scan(struct Scsi_Host *shost, uint channel,
244                            uint id, uint lun)
245 {
246         struct iscsi_host *ihost = shost->shost_data;
247         struct iscsi_cls_session *session;
248
249         mutex_lock(&ihost->mutex);
250         list_for_each_entry(session, &ihost->sessions, host_list) {
251                 if ((channel == SCAN_WILD_CARD || channel == 0) &&
252                     (id == SCAN_WILD_CARD || id == session->target_id))
253                         scsi_scan_target(&session->dev, 0,
254                                          session->target_id, lun, 1);
255         }
256         mutex_unlock(&ihost->mutex);
257
258         return 0;
259 }
260
261 static void session_recovery_timedout(void *data)
262 {
263         struct iscsi_cls_session *session = data;
264
265         dev_printk(KERN_INFO, &session->dev, "iscsi: session recovery timed "
266                   "out after %d secs\n", session->recovery_tmo);
267
268         if (session->transport->session_recovery_timedout)
269                 session->transport->session_recovery_timedout(session);
270
271         scsi_target_unblock(&session->dev);
272 }
273
274 void iscsi_unblock_session(struct iscsi_cls_session *session)
275 {
276         if (!cancel_delayed_work(&session->recovery_work))
277                 flush_scheduled_work();
278         scsi_target_unblock(&session->dev);
279 }
280 EXPORT_SYMBOL_GPL(iscsi_unblock_session);
281
282 void iscsi_block_session(struct iscsi_cls_session *session)
283 {
284         scsi_target_block(&session->dev);
285         schedule_delayed_work(&session->recovery_work,
286                              session->recovery_tmo * HZ);
287 }
288 EXPORT_SYMBOL_GPL(iscsi_block_session);
289
290 struct iscsi_cls_session *
291 iscsi_alloc_session(struct Scsi_Host *shost,
292                     struct iscsi_transport *transport)
293 {
294         struct iscsi_cls_session *session;
295
296         session = kzalloc(sizeof(*session) + transport->sessiondata_size,
297                           GFP_KERNEL);
298         if (!session)
299                 return NULL;
300
301         session->transport = transport;
302         session->recovery_tmo = 120;
303         INIT_WORK(&session->recovery_work, session_recovery_timedout, session);
304         INIT_LIST_HEAD(&session->host_list);
305         INIT_LIST_HEAD(&session->sess_list);
306
307         session->dev.parent = &shost->shost_gendev;
308         session->dev.release = iscsi_session_release;
309         device_initialize(&session->dev);
310         if (transport->sessiondata_size)
311                 session->dd_data = &session[1];
312         return session;
313 }
314 EXPORT_SYMBOL_GPL(iscsi_alloc_session);
315
316 int iscsi_add_session(struct iscsi_cls_session *session)
317 {
318         struct Scsi_Host *shost = iscsi_session_to_shost(session);
319         struct iscsi_host *ihost;
320         int err;
321
322         /* this is released in the dev's release function */
323         scsi_host_get(shost);
324         ihost = shost->shost_data;
325
326         session->sid = iscsi_session_nr++;
327         session->target_id = ihost->next_target_id++;
328
329         snprintf(session->dev.bus_id, BUS_ID_SIZE, "session%u",
330                  session->sid);
331         err = device_add(&session->dev);
332         if (err) {
333                 dev_printk(KERN_ERR, &session->dev, "iscsi: could not "
334                            "register session's dev\n");
335                 goto release_host;
336         }
337         transport_register_device(&session->dev);
338
339         mutex_lock(&ihost->mutex);
340         list_add(&session->host_list, &ihost->sessions);
341         mutex_unlock(&ihost->mutex);
342         return 0;
343
344 release_host:
345         scsi_host_put(shost);
346         return err;
347 }
348 EXPORT_SYMBOL_GPL(iscsi_add_session);
349
350 /**
351  * iscsi_create_session - create iscsi class session
352  * @shost: scsi host
353  * @transport: iscsi transport
354  *
355  * This can be called from a LLD or iscsi_transport.
356  **/
357 struct iscsi_cls_session *
358 iscsi_create_session(struct Scsi_Host *shost,
359                      struct iscsi_transport *transport)
360 {
361         struct iscsi_cls_session *session;
362
363         session = iscsi_alloc_session(shost, transport);
364         if (!session)
365                 return NULL;
366
367         if (iscsi_add_session(session)) {
368                 iscsi_free_session(session);
369                 return NULL;
370         }
371         return session;
372 }
373 EXPORT_SYMBOL_GPL(iscsi_create_session);
374
375 void iscsi_remove_session(struct iscsi_cls_session *session)
376 {
377         struct Scsi_Host *shost = iscsi_session_to_shost(session);
378         struct iscsi_host *ihost = shost->shost_data;
379
380         if (!cancel_delayed_work(&session->recovery_work))
381                 flush_scheduled_work();
382
383         mutex_lock(&ihost->mutex);
384         list_del(&session->host_list);
385         mutex_unlock(&ihost->mutex);
386
387         scsi_remove_target(&session->dev);
388
389         transport_unregister_device(&session->dev);
390         device_del(&session->dev);
391 }
392 EXPORT_SYMBOL_GPL(iscsi_remove_session);
393
394 void iscsi_free_session(struct iscsi_cls_session *session)
395 {
396         put_device(&session->dev);
397 }
398
399 EXPORT_SYMBOL_GPL(iscsi_free_session);
400
401 /**
402  * iscsi_destroy_session - destroy iscsi session
403  * @session: iscsi_session
404  *
405  * Can be called by a LLD or iscsi_transport. There must not be
406  * any running connections.
407  **/
408 int iscsi_destroy_session(struct iscsi_cls_session *session)
409 {
410         iscsi_remove_session(session);
411         iscsi_free_session(session);
412         return 0;
413 }
414 EXPORT_SYMBOL_GPL(iscsi_destroy_session);
415
416 static void iscsi_conn_release(struct device *dev)
417 {
418         struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev);
419         struct device *parent = conn->dev.parent;
420
421         kfree(conn);
422         put_device(parent);
423 }
424
425 static int iscsi_is_conn_dev(const struct device *dev)
426 {
427         return dev->release == iscsi_conn_release;
428 }
429
430 /**
431  * iscsi_create_conn - create iscsi class connection
432  * @session: iscsi cls session
433  * @cid: connection id
434  *
435  * This can be called from a LLD or iscsi_transport. The connection
436  * is child of the session so cid must be unique for all connections
437  * on the session.
438  *
439  * Since we do not support MCS, cid will normally be zero. In some cases
440  * for software iscsi we could be trying to preallocate a connection struct
441  * in which case there could be two connection structs and cid would be
442  * non-zero.
443  **/
444 struct iscsi_cls_conn *
445 iscsi_create_conn(struct iscsi_cls_session *session, uint32_t cid)
446 {
447         struct iscsi_transport *transport = session->transport;
448         struct iscsi_cls_conn *conn;
449         int err;
450
451         conn = kzalloc(sizeof(*conn) + transport->conndata_size, GFP_KERNEL);
452         if (!conn)
453                 return NULL;
454
455         if (transport->conndata_size)
456                 conn->dd_data = &conn[1];
457
458         INIT_LIST_HEAD(&conn->conn_list);
459         conn->transport = transport;
460         conn->cid = cid;
461
462         /* this is released in the dev's release function */
463         if (!get_device(&session->dev))
464                 goto free_conn;
465
466         snprintf(conn->dev.bus_id, BUS_ID_SIZE, "connection%d:%u",
467                  session->sid, cid);
468         conn->dev.parent = &session->dev;
469         conn->dev.release = iscsi_conn_release;
470         err = device_register(&conn->dev);
471         if (err) {
472                 dev_printk(KERN_ERR, &conn->dev, "iscsi: could not register "
473                            "connection's dev\n");
474                 goto release_parent_ref;
475         }
476         transport_register_device(&conn->dev);
477         return conn;
478
479 release_parent_ref:
480         put_device(&session->dev);
481 free_conn:
482         kfree(conn);
483         return NULL;
484 }
485
486 EXPORT_SYMBOL_GPL(iscsi_create_conn);
487
488 /**
489  * iscsi_destroy_conn - destroy iscsi class connection
490  * @session: iscsi cls session
491  *
492  * This can be called from a LLD or iscsi_transport.
493  **/
494 int iscsi_destroy_conn(struct iscsi_cls_conn *conn)
495 {
496         transport_unregister_device(&conn->dev);
497         device_unregister(&conn->dev);
498         return 0;
499 }
500
501 EXPORT_SYMBOL_GPL(iscsi_destroy_conn);
502
503 /*
504  * iscsi interface functions
505  */
506 static struct iscsi_internal *
507 iscsi_if_transport_lookup(struct iscsi_transport *tt)
508 {
509         struct iscsi_internal *priv;
510         unsigned long flags;
511
512         spin_lock_irqsave(&iscsi_transport_lock, flags);
513         list_for_each_entry(priv, &iscsi_transports, list) {
514                 if (tt == priv->iscsi_transport) {
515                         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
516                         return priv;
517                 }
518         }
519         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
520         return NULL;
521 }
522
523 static inline struct list_head *skb_to_lh(struct sk_buff *skb)
524 {
525         return (struct list_head *)&skb->cb;
526 }
527
528 static void*
529 mempool_zone_alloc_skb(gfp_t gfp_mask, void *pool_data)
530 {
531         struct mempool_zone *zone = pool_data;
532
533         return alloc_skb(zone->size, gfp_mask);
534 }
535
536 static void
537 mempool_zone_free_skb(void *element, void *pool_data)
538 {
539         kfree_skb(element);
540 }
541
542 static void
543 mempool_zone_complete(struct mempool_zone *zone)
544 {
545         unsigned long flags;
546         struct list_head *lh, *n;
547
548         spin_lock_irqsave(&zone->freelock, flags);
549         list_for_each_safe(lh, n, &zone->freequeue) {
550                 struct sk_buff *skb = (struct sk_buff *)((char *)lh -
551                                 offsetof(struct sk_buff, cb));
552                 if (!skb_shared(skb)) {
553                         list_del(skb_to_lh(skb));
554                         mempool_free(skb, zone->pool);
555                         atomic_dec(&zone->allocated);
556                 }
557         }
558         spin_unlock_irqrestore(&zone->freelock, flags);
559 }
560
561 static struct mempool_zone *
562 mempool_zone_init(unsigned max, unsigned size, unsigned hiwat)
563 {
564         struct mempool_zone *zp;
565
566         zp = kzalloc(sizeof(*zp), GFP_KERNEL);
567         if (!zp)
568                 return NULL;
569
570         zp->size = size;
571         zp->hiwat = hiwat;
572         INIT_LIST_HEAD(&zp->freequeue);
573         spin_lock_init(&zp->freelock);
574         atomic_set(&zp->allocated, 0);
575
576         zp->pool = mempool_create(max, mempool_zone_alloc_skb,
577                                   mempool_zone_free_skb, zp);
578         if (!zp->pool) {
579                 kfree(zp);
580                 return NULL;
581         }
582
583         return zp;
584 }
585
586 static void mempool_zone_destroy(struct mempool_zone *zp)
587 {
588         mempool_destroy(zp->pool);
589         kfree(zp);
590 }
591
592 static struct sk_buff*
593 mempool_zone_get_skb(struct mempool_zone *zone)
594 {
595         struct sk_buff *skb;
596
597         skb = mempool_alloc(zone->pool, GFP_ATOMIC);
598         if (skb)
599                 atomic_inc(&zone->allocated);
600         return skb;
601 }
602
603 static int
604 iscsi_unicast_skb(struct mempool_zone *zone, struct sk_buff *skb, int pid)
605 {
606         unsigned long flags;
607         int rc;
608
609         skb_get(skb);
610         rc = netlink_unicast(nls, skb, pid, MSG_DONTWAIT);
611         if (rc < 0) {
612                 mempool_free(skb, zone->pool);
613                 printk(KERN_ERR "iscsi: can not unicast skb (%d)\n", rc);
614                 return rc;
615         }
616
617         spin_lock_irqsave(&zone->freelock, flags);
618         INIT_LIST_HEAD(skb_to_lh(skb));
619         list_add(skb_to_lh(skb), &zone->freequeue);
620         spin_unlock_irqrestore(&zone->freelock, flags);
621
622         return 0;
623 }
624
625 int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
626                    char *data, uint32_t data_size)
627 {
628         struct nlmsghdr *nlh;
629         struct sk_buff *skb;
630         struct iscsi_uevent *ev;
631         char *pdu;
632         struct iscsi_internal *priv;
633         int len = NLMSG_SPACE(sizeof(*ev) + sizeof(struct iscsi_hdr) +
634                               data_size);
635
636         priv = iscsi_if_transport_lookup(conn->transport);
637         if (!priv)
638                 return -EINVAL;
639
640         mempool_zone_complete(conn->z_pdu);
641
642         skb = mempool_zone_get_skb(conn->z_pdu);
643         if (!skb) {
644                 iscsi_conn_error(conn, ISCSI_ERR_CONN_FAILED);
645                 dev_printk(KERN_ERR, &conn->dev, "iscsi: can not deliver "
646                            "control PDU: OOM\n");
647                 return -ENOMEM;
648         }
649
650         nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
651         ev = NLMSG_DATA(nlh);
652         memset(ev, 0, sizeof(*ev));
653         ev->transport_handle = iscsi_handle(conn->transport);
654         ev->type = ISCSI_KEVENT_RECV_PDU;
655         if (atomic_read(&conn->z_pdu->allocated) >= conn->z_pdu->hiwat)
656                 ev->iferror = -ENOMEM;
657         ev->r.recv_req.cid = conn->cid;
658         ev->r.recv_req.sid = iscsi_conn_get_sid(conn);
659         pdu = (char*)ev + sizeof(*ev);
660         memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
661         memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
662
663         return iscsi_unicast_skb(conn->z_pdu, skb, priv->daemon_pid);
664 }
665 EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
666
667 void iscsi_conn_error(struct iscsi_cls_conn *conn, enum iscsi_err error)
668 {
669         struct nlmsghdr *nlh;
670         struct sk_buff  *skb;
671         struct iscsi_uevent *ev;
672         struct iscsi_internal *priv;
673         int len = NLMSG_SPACE(sizeof(*ev));
674
675         priv = iscsi_if_transport_lookup(conn->transport);
676         if (!priv)
677                 return;
678
679         mempool_zone_complete(conn->z_error);
680
681         skb = mempool_zone_get_skb(conn->z_error);
682         if (!skb) {
683                 dev_printk(KERN_ERR, &conn->dev, "iscsi: gracefully ignored "
684                           "conn error (%d)\n", error);
685                 return;
686         }
687
688         nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
689         ev = NLMSG_DATA(nlh);
690         ev->transport_handle = iscsi_handle(conn->transport);
691         ev->type = ISCSI_KEVENT_CONN_ERROR;
692         if (atomic_read(&conn->z_error->allocated) >= conn->z_error->hiwat)
693                 ev->iferror = -ENOMEM;
694         ev->r.connerror.error = error;
695         ev->r.connerror.cid = conn->cid;
696         ev->r.connerror.sid = iscsi_conn_get_sid(conn);
697
698         iscsi_unicast_skb(conn->z_error, skb, priv->daemon_pid);
699
700         dev_printk(KERN_INFO, &conn->dev, "iscsi: detected conn error (%d)\n",
701                    error);
702 }
703 EXPORT_SYMBOL_GPL(iscsi_conn_error);
704
705 static int
706 iscsi_if_send_reply(int pid, int seq, int type, int done, int multi,
707                       void *payload, int size)
708 {
709         struct sk_buff  *skb;
710         struct nlmsghdr *nlh;
711         int len = NLMSG_SPACE(size);
712         int flags = multi ? NLM_F_MULTI : 0;
713         int t = done ? NLMSG_DONE : type;
714
715         mempool_zone_complete(z_reply);
716
717         skb = mempool_zone_get_skb(z_reply);
718         /*
719          * FIXME:
720          * user is supposed to react on iferror == -ENOMEM;
721          * see iscsi_if_rx().
722          */
723         BUG_ON(!skb);
724
725         nlh = __nlmsg_put(skb, pid, seq, t, (len - sizeof(*nlh)), 0);
726         nlh->nlmsg_flags = flags;
727         memcpy(NLMSG_DATA(nlh), payload, size);
728         return iscsi_unicast_skb(z_reply, skb, pid);
729 }
730
731 static int
732 iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
733 {
734         struct iscsi_uevent *ev = NLMSG_DATA(nlh);
735         struct iscsi_stats *stats;
736         struct sk_buff *skbstat;
737         struct iscsi_cls_conn *conn;
738         struct nlmsghdr *nlhstat;
739         struct iscsi_uevent *evstat;
740         struct iscsi_internal *priv;
741         int len = NLMSG_SPACE(sizeof(*ev) +
742                               sizeof(struct iscsi_stats) +
743                               sizeof(struct iscsi_stats_custom) *
744                               ISCSI_STATS_CUSTOM_MAX);
745         int err = 0;
746
747         priv = iscsi_if_transport_lookup(transport);
748         if (!priv)
749                 return -EINVAL;
750
751         conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid);
752         if (!conn)
753                 return -EEXIST;
754
755         do {
756                 int actual_size;
757
758                 mempool_zone_complete(conn->z_pdu);
759
760                 skbstat = mempool_zone_get_skb(conn->z_pdu);
761                 if (!skbstat) {
762                         dev_printk(KERN_ERR, &conn->dev, "iscsi: can not "
763                                    "deliver stats: OOM\n");
764                         return -ENOMEM;
765                 }
766
767                 nlhstat = __nlmsg_put(skbstat, priv->daemon_pid, 0, 0,
768                                       (len - sizeof(*nlhstat)), 0);
769                 evstat = NLMSG_DATA(nlhstat);
770                 memset(evstat, 0, sizeof(*evstat));
771                 evstat->transport_handle = iscsi_handle(conn->transport);
772                 evstat->type = nlh->nlmsg_type;
773                 if (atomic_read(&conn->z_pdu->allocated) >= conn->z_pdu->hiwat)
774                         evstat->iferror = -ENOMEM;
775                 evstat->u.get_stats.cid =
776                         ev->u.get_stats.cid;
777                 evstat->u.get_stats.sid =
778                         ev->u.get_stats.sid;
779                 stats = (struct iscsi_stats *)
780                         ((char*)evstat + sizeof(*evstat));
781                 memset(stats, 0, sizeof(*stats));
782
783                 transport->get_stats(conn, stats);
784                 actual_size = NLMSG_SPACE(sizeof(struct iscsi_uevent) +
785                                           sizeof(struct iscsi_stats) +
786                                           sizeof(struct iscsi_stats_custom) *
787                                           stats->custom_length);
788                 actual_size -= sizeof(*nlhstat);
789                 actual_size = NLMSG_LENGTH(actual_size);
790                 skb_trim(skbstat, NLMSG_ALIGN(actual_size));
791                 nlhstat->nlmsg_len = actual_size;
792
793                 err = iscsi_unicast_skb(conn->z_pdu, skbstat, priv->daemon_pid);
794         } while (err < 0 && err != -ECONNREFUSED);
795
796         return err;
797 }
798
799 static int
800 iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_uevent *ev)
801 {
802         struct iscsi_transport *transport = priv->iscsi_transport;
803         struct iscsi_cls_session *session;
804         unsigned long flags;
805         uint32_t hostno;
806
807         session = transport->create_session(transport, &priv->t,
808                                             ev->u.c_session.initial_cmdsn,
809                                             &hostno);
810         if (!session)
811                 return -ENOMEM;
812
813         spin_lock_irqsave(&sesslock, flags);
814         list_add(&session->sess_list, &sesslist);
815         spin_unlock_irqrestore(&sesslock, flags);
816
817         ev->r.c_session_ret.host_no = hostno;
818         ev->r.c_session_ret.sid = session->sid;
819         return 0;
820 }
821
822 static int
823 iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
824 {
825         struct iscsi_cls_conn *conn;
826         struct iscsi_cls_session *session;
827         unsigned long flags;
828
829         session = iscsi_session_lookup(ev->u.c_conn.sid);
830         if (!session) {
831                 printk(KERN_ERR "iscsi: invalid session %d\n",
832                        ev->u.c_conn.sid);
833                 return -EINVAL;
834         }
835
836         conn = transport->create_conn(session, ev->u.c_conn.cid);
837         if (!conn) {
838                 printk(KERN_ERR "iscsi: couldn't create a new "
839                            "connection for session %d\n",
840                            session->sid);
841                 return -ENOMEM;
842         }
843
844         conn->z_pdu = mempool_zone_init(Z_MAX_PDU,
845                         NLMSG_SPACE(sizeof(struct iscsi_uevent) +
846                                     sizeof(struct iscsi_hdr) +
847                                     DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH),
848                         Z_HIWAT_PDU);
849         if (!conn->z_pdu) {
850                 dev_printk(KERN_ERR, &conn->dev, "iscsi: can not allocate "
851                            "pdu zone for new conn\n");
852                 goto destroy_conn;
853         }
854
855         conn->z_error = mempool_zone_init(Z_MAX_ERROR,
856                         NLMSG_SPACE(sizeof(struct iscsi_uevent)),
857                         Z_HIWAT_ERROR);
858         if (!conn->z_error) {
859                 dev_printk(KERN_ERR, &conn->dev, "iscsi: can not allocate "
860                            "error zone for new conn\n");
861                 goto free_pdu_pool;
862         }
863
864         ev->r.c_conn_ret.sid = session->sid;
865         ev->r.c_conn_ret.cid = conn->cid;
866
867         spin_lock_irqsave(&connlock, flags);
868         list_add(&conn->conn_list, &connlist);
869         conn->active = 1;
870         spin_unlock_irqrestore(&connlock, flags);
871
872         return 0;
873
874 free_pdu_pool:
875         mempool_zone_destroy(conn->z_pdu);
876 destroy_conn:
877         if (transport->destroy_conn)
878                 transport->destroy_conn(conn->dd_data);
879         return -ENOMEM;
880 }
881
882 static int
883 iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
884 {
885         unsigned long flags;
886         struct iscsi_cls_conn *conn;
887         struct mempool_zone *z_error, *z_pdu;
888
889         conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid);
890         if (!conn)
891                 return -EINVAL;
892         spin_lock_irqsave(&connlock, flags);
893         conn->active = 0;
894         list_del(&conn->conn_list);
895         spin_unlock_irqrestore(&connlock, flags);
896
897         z_pdu = conn->z_pdu;
898         z_error = conn->z_error;
899
900         if (transport->destroy_conn)
901                 transport->destroy_conn(conn);
902
903         mempool_zone_destroy(z_pdu);
904         mempool_zone_destroy(z_error);
905
906         return 0;
907 }
908
909 static int
910 iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev)
911 {
912         char *data = (char*)ev + sizeof(*ev);
913         struct iscsi_cls_conn *conn;
914         struct iscsi_cls_session *session;
915         int err = 0, value = 0;
916
917         session = iscsi_session_lookup(ev->u.set_param.sid);
918         conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid);
919         if (!conn || !session)
920                 return -EINVAL;
921
922         switch (ev->u.set_param.param) {
923         case ISCSI_PARAM_SESS_RECOVERY_TMO:
924                 sscanf(data, "%d", &value);
925                 if (value != 0)
926                         session->recovery_tmo = value;
927                 break;
928         default:
929                 err = transport->set_param(conn, ev->u.set_param.param,
930                                            data, ev->u.set_param.len);
931         }
932
933         return err;
934 }
935
936 static int
937 iscsi_if_transport_ep(struct iscsi_transport *transport,
938                       struct iscsi_uevent *ev, int msg_type)
939 {
940         struct sockaddr *dst_addr;
941         int rc = 0;
942
943         switch (msg_type) {
944         case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
945                 if (!transport->ep_connect)
946                         return -EINVAL;
947
948                 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
949                 rc = transport->ep_connect(dst_addr,
950                                            ev->u.ep_connect.non_blocking,
951                                            &ev->r.ep_connect_ret.handle);
952                 break;
953         case ISCSI_UEVENT_TRANSPORT_EP_POLL:
954                 if (!transport->ep_poll)
955                         return -EINVAL;
956
957                 ev->r.retcode = transport->ep_poll(ev->u.ep_poll.ep_handle,
958                                                    ev->u.ep_poll.timeout_ms);
959                 break;
960         case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
961                 if (!transport->ep_disconnect)
962                         return -EINVAL;
963
964                 transport->ep_disconnect(ev->u.ep_disconnect.ep_handle);
965                 break;
966         }
967         return rc;
968 }
969
970 static int
971 iscsi_tgt_dscvr(struct iscsi_transport *transport,
972                 struct iscsi_uevent *ev)
973 {
974         struct sockaddr *dst_addr;
975
976         if (!transport->tgt_dscvr)
977                 return -EINVAL;
978
979         dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
980         return transport->tgt_dscvr(ev->u.tgt_dscvr.type,
981                                     ev->u.tgt_dscvr.host_no,
982                                     ev->u.tgt_dscvr.enable, dst_addr);
983 }
984
985 static int
986 iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
987 {
988         int err = 0;
989         struct iscsi_uevent *ev = NLMSG_DATA(nlh);
990         struct iscsi_transport *transport = NULL;
991         struct iscsi_internal *priv;
992         struct iscsi_cls_session *session;
993         struct iscsi_cls_conn *conn;
994         unsigned long flags;
995
996         priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle));
997         if (!priv)
998                 return -EINVAL;
999         transport = priv->iscsi_transport;
1000
1001         if (!try_module_get(transport->owner))
1002                 return -EINVAL;
1003
1004         priv->daemon_pid = NETLINK_CREDS(skb)->pid;
1005
1006         switch (nlh->nlmsg_type) {
1007         case ISCSI_UEVENT_CREATE_SESSION:
1008                 err = iscsi_if_create_session(priv, ev);
1009                 break;
1010         case ISCSI_UEVENT_DESTROY_SESSION:
1011                 session = iscsi_session_lookup(ev->u.d_session.sid);
1012                 if (session) {
1013                         spin_lock_irqsave(&sesslock, flags);
1014                         list_del(&session->sess_list);
1015                         spin_unlock_irqrestore(&sesslock, flags);
1016
1017                         transport->destroy_session(session);
1018                 } else
1019                         err = -EINVAL;
1020                 break;
1021         case ISCSI_UEVENT_CREATE_CONN:
1022                 err = iscsi_if_create_conn(transport, ev);
1023                 break;
1024         case ISCSI_UEVENT_DESTROY_CONN:
1025                 err = iscsi_if_destroy_conn(transport, ev);
1026                 break;
1027         case ISCSI_UEVENT_BIND_CONN:
1028                 session = iscsi_session_lookup(ev->u.b_conn.sid);
1029                 conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid);
1030
1031                 if (session && conn)
1032                         ev->r.retcode = transport->bind_conn(session, conn,
1033                                         ev->u.b_conn.transport_eph,
1034                                         ev->u.b_conn.is_leading);
1035                 else
1036                         err = -EINVAL;
1037                 break;
1038         case ISCSI_UEVENT_SET_PARAM:
1039                 err = iscsi_set_param(transport, ev);
1040                 break;
1041         case ISCSI_UEVENT_START_CONN:
1042                 conn = iscsi_conn_lookup(ev->u.start_conn.sid, ev->u.start_conn.cid);
1043                 if (conn)
1044                         ev->r.retcode = transport->start_conn(conn);
1045                 else
1046                         err = -EINVAL;
1047                 break;
1048         case ISCSI_UEVENT_STOP_CONN:
1049                 conn = iscsi_conn_lookup(ev->u.stop_conn.sid, ev->u.stop_conn.cid);
1050                 if (conn)
1051                         transport->stop_conn(conn, ev->u.stop_conn.flag);
1052                 else
1053                         err = -EINVAL;
1054                 break;
1055         case ISCSI_UEVENT_SEND_PDU:
1056                 conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid);
1057                 if (conn)
1058                         ev->r.retcode = transport->send_pdu(conn,
1059                                 (struct iscsi_hdr*)((char*)ev + sizeof(*ev)),
1060                                 (char*)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,
1061                                 ev->u.send_pdu.data_size);
1062                 else
1063                         err = -EINVAL;
1064                 break;
1065         case ISCSI_UEVENT_GET_STATS:
1066                 err = iscsi_if_get_stats(transport, nlh);
1067                 break;
1068         case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
1069         case ISCSI_UEVENT_TRANSPORT_EP_POLL:
1070         case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
1071                 err = iscsi_if_transport_ep(transport, ev, nlh->nlmsg_type);
1072                 break;
1073         case ISCSI_UEVENT_TGT_DSCVR:
1074                 err = iscsi_tgt_dscvr(transport, ev);
1075                 break;
1076         default:
1077                 err = -EINVAL;
1078                 break;
1079         }
1080
1081         module_put(transport->owner);
1082         return err;
1083 }
1084
1085 /*
1086  * Get message from skb (based on rtnetlink_rcv_skb).  Each message is
1087  * processed by iscsi_if_recv_msg.  Malformed skbs with wrong lengths or
1088  * invalid creds are discarded silently.
1089  */
1090 static void
1091 iscsi_if_rx(struct sock *sk, int len)
1092 {
1093         struct sk_buff *skb;
1094
1095         mutex_lock(&rx_queue_mutex);
1096         while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
1097                 if (NETLINK_CREDS(skb)->uid) {
1098                         skb_pull(skb, skb->len);
1099                         goto free_skb;
1100                 }
1101
1102                 while (skb->len >= NLMSG_SPACE(0)) {
1103                         int err;
1104                         uint32_t rlen;
1105                         struct nlmsghdr *nlh;
1106                         struct iscsi_uevent *ev;
1107
1108                         nlh = (struct nlmsghdr *)skb->data;
1109                         if (nlh->nlmsg_len < sizeof(*nlh) ||
1110                             skb->len < nlh->nlmsg_len) {
1111                                 break;
1112                         }
1113
1114                         ev = NLMSG_DATA(nlh);
1115                         rlen = NLMSG_ALIGN(nlh->nlmsg_len);
1116                         if (rlen > skb->len)
1117                                 rlen = skb->len;
1118
1119                         err = iscsi_if_recv_msg(skb, nlh);
1120                         if (err) {
1121                                 ev->type = ISCSI_KEVENT_IF_ERROR;
1122                                 ev->iferror = err;
1123                         }
1124                         do {
1125                                 /*
1126                                  * special case for GET_STATS:
1127                                  * on success - sending reply and stats from
1128                                  * inside of if_recv_msg(),
1129                                  * on error - fall through.
1130                                  */
1131                                 if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
1132                                         break;
1133                                 err = iscsi_if_send_reply(
1134                                         NETLINK_CREDS(skb)->pid, nlh->nlmsg_seq,
1135                                         nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
1136                                 if (atomic_read(&z_reply->allocated) >=
1137                                                 z_reply->hiwat)
1138                                         ev->iferror = -ENOMEM;
1139                         } while (err < 0 && err != -ECONNREFUSED);
1140                         skb_pull(skb, rlen);
1141                 }
1142 free_skb:
1143                 kfree_skb(skb);
1144         }
1145         mutex_unlock(&rx_queue_mutex);
1146 }
1147
1148 #define iscsi_cdev_to_conn(_cdev) \
1149         iscsi_dev_to_conn(_cdev->dev)
1150
1151 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store)              \
1152 struct class_device_attribute class_device_attr_##_prefix##_##_name =   \
1153         __ATTR(_name,_mode,_show,_store)
1154
1155 /*
1156  * iSCSI connection attrs
1157  */
1158 #define iscsi_conn_attr_show(param)                                     \
1159 static ssize_t                                                          \
1160 show_conn_param_##param(struct class_device *cdev, char *buf)           \
1161 {                                                                       \
1162         struct iscsi_cls_conn *conn = iscsi_cdev_to_conn(cdev);         \
1163         struct iscsi_transport *t = conn->transport;                    \
1164         return t->get_conn_param(conn, param, buf);                     \
1165 }
1166
1167 #define iscsi_conn_attr(field, param)                                   \
1168         iscsi_conn_attr_show(param)                                     \
1169 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param,  \
1170                         NULL);
1171
1172 iscsi_conn_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH);
1173 iscsi_conn_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH);
1174 iscsi_conn_attr(header_digest, ISCSI_PARAM_HDRDGST_EN);
1175 iscsi_conn_attr(data_digest, ISCSI_PARAM_DATADGST_EN);
1176 iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN);
1177 iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN);
1178 iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT);
1179 iscsi_conn_attr(port, ISCSI_PARAM_CONN_PORT);
1180 iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN);
1181 iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS);
1182 iscsi_conn_attr(address, ISCSI_PARAM_CONN_ADDRESS);
1183
1184 #define iscsi_cdev_to_session(_cdev) \
1185         iscsi_dev_to_session(_cdev->dev)
1186
1187 /*
1188  * iSCSI session attrs
1189  */
1190 #define iscsi_session_attr_show(param)                                  \
1191 static ssize_t                                                          \
1192 show_session_param_##param(struct class_device *cdev, char *buf)        \
1193 {                                                                       \
1194         struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev); \
1195         struct iscsi_transport *t = session->transport;                 \
1196         return t->get_session_param(session, param, buf);               \
1197 }
1198
1199 #define iscsi_session_attr(field, param)                                \
1200         iscsi_session_attr_show(param)                                  \
1201 static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
1202                         NULL);
1203
1204 iscsi_session_attr(targetname, ISCSI_PARAM_TARGET_NAME);
1205 iscsi_session_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN);
1206 iscsi_session_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T);
1207 iscsi_session_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN);
1208 iscsi_session_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST);
1209 iscsi_session_attr(max_burst_len, ISCSI_PARAM_MAX_BURST);
1210 iscsi_session_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN);
1211 iscsi_session_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN);
1212 iscsi_session_attr(erl, ISCSI_PARAM_ERL);
1213 iscsi_session_attr(tpgt, ISCSI_PARAM_TPGT);
1214
1215 #define iscsi_priv_session_attr_show(field, format)                     \
1216 static ssize_t                                                          \
1217 show_priv_session_##field(struct class_device *cdev, char *buf)         \
1218 {                                                                       \
1219         struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);\
1220         return sprintf(buf, format"\n", session->field);                \
1221 }
1222
1223 #define iscsi_priv_session_attr(field, format)                          \
1224         iscsi_priv_session_attr_show(field, format)                     \
1225 static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO, show_priv_session_##field, \
1226                         NULL)
1227 iscsi_priv_session_attr(recovery_tmo, "%d");
1228
1229 #define SETUP_PRIV_SESSION_RD_ATTR(field)                               \
1230 do {                                                                    \
1231         priv->session_attrs[count] = &class_device_attr_priv_sess_##field; \
1232         count++;                                                        \
1233 } while (0)
1234
1235
1236 #define SETUP_SESSION_RD_ATTR(field, param_flag)                        \
1237 do {                                                                    \
1238         if (tt->param_mask & param_flag) {                              \
1239                 priv->session_attrs[count] = &class_device_attr_sess_##field; \
1240                 count++;                                                \
1241         }                                                               \
1242 } while (0)
1243
1244 #define SETUP_CONN_RD_ATTR(field, param_flag)                           \
1245 do {                                                                    \
1246         if (tt->param_mask & param_flag) {                              \
1247                 priv->conn_attrs[count] = &class_device_attr_conn_##field; \
1248                 count++;                                                \
1249         }                                                               \
1250 } while (0)
1251
1252 static int iscsi_session_match(struct attribute_container *cont,
1253                            struct device *dev)
1254 {
1255         struct iscsi_cls_session *session;
1256         struct Scsi_Host *shost;
1257         struct iscsi_internal *priv;
1258
1259         if (!iscsi_is_session_dev(dev))
1260                 return 0;
1261
1262         session = iscsi_dev_to_session(dev);
1263         shost = iscsi_session_to_shost(session);
1264         if (!shost->transportt)
1265                 return 0;
1266
1267         priv = to_iscsi_internal(shost->transportt);
1268         if (priv->session_cont.ac.class != &iscsi_session_class.class)
1269                 return 0;
1270
1271         return &priv->session_cont.ac == cont;
1272 }
1273
1274 static int iscsi_conn_match(struct attribute_container *cont,
1275                            struct device *dev)
1276 {
1277         struct iscsi_cls_session *session;
1278         struct iscsi_cls_conn *conn;
1279         struct Scsi_Host *shost;
1280         struct iscsi_internal *priv;
1281
1282         if (!iscsi_is_conn_dev(dev))
1283                 return 0;
1284
1285         conn = iscsi_dev_to_conn(dev);
1286         session = iscsi_dev_to_session(conn->dev.parent);
1287         shost = iscsi_session_to_shost(session);
1288
1289         if (!shost->transportt)
1290                 return 0;
1291
1292         priv = to_iscsi_internal(shost->transportt);
1293         if (priv->conn_cont.ac.class != &iscsi_connection_class.class)
1294                 return 0;
1295
1296         return &priv->conn_cont.ac == cont;
1297 }
1298
1299 static int iscsi_host_match(struct attribute_container *cont,
1300                             struct device *dev)
1301 {
1302         struct Scsi_Host *shost;
1303         struct iscsi_internal *priv;
1304
1305         if (!scsi_is_host_device(dev))
1306                 return 0;
1307
1308         shost = dev_to_shost(dev);
1309         if (!shost->transportt  ||
1310             shost->transportt->host_attrs.ac.class != &iscsi_host_class.class)
1311                 return 0;
1312
1313         priv = to_iscsi_internal(shost->transportt);
1314         return &priv->t.host_attrs.ac == cont;
1315 }
1316
1317 struct scsi_transport_template *
1318 iscsi_register_transport(struct iscsi_transport *tt)
1319 {
1320         struct iscsi_internal *priv;
1321         unsigned long flags;
1322         int count = 0, err;
1323
1324         BUG_ON(!tt);
1325
1326         priv = iscsi_if_transport_lookup(tt);
1327         if (priv)
1328                 return NULL;
1329
1330         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1331         if (!priv)
1332                 return NULL;
1333         INIT_LIST_HEAD(&priv->list);
1334         priv->iscsi_transport = tt;
1335         priv->t.user_scan = iscsi_user_scan;
1336
1337         priv->cdev.class = &iscsi_transport_class;
1338         snprintf(priv->cdev.class_id, BUS_ID_SIZE, "%s", tt->name);
1339         err = class_device_register(&priv->cdev);
1340         if (err)
1341                 goto free_priv;
1342
1343         err = sysfs_create_group(&priv->cdev.kobj, &iscsi_transport_group);
1344         if (err)
1345                 goto unregister_cdev;
1346
1347         /* host parameters */
1348         priv->t.host_attrs.ac.attrs = &priv->host_attrs[0];
1349         priv->t.host_attrs.ac.class = &iscsi_host_class.class;
1350         priv->t.host_attrs.ac.match = iscsi_host_match;
1351         priv->t.host_size = sizeof(struct iscsi_host);
1352         priv->host_attrs[0] = NULL;
1353         transport_container_register(&priv->t.host_attrs);
1354
1355         /* connection parameters */
1356         priv->conn_cont.ac.attrs = &priv->conn_attrs[0];
1357         priv->conn_cont.ac.class = &iscsi_connection_class.class;
1358         priv->conn_cont.ac.match = iscsi_conn_match;
1359         transport_container_register(&priv->conn_cont);
1360
1361         SETUP_CONN_RD_ATTR(max_recv_dlength, ISCSI_MAX_RECV_DLENGTH);
1362         SETUP_CONN_RD_ATTR(max_xmit_dlength, ISCSI_MAX_XMIT_DLENGTH);
1363         SETUP_CONN_RD_ATTR(header_digest, ISCSI_HDRDGST_EN);
1364         SETUP_CONN_RD_ATTR(data_digest, ISCSI_DATADGST_EN);
1365         SETUP_CONN_RD_ATTR(ifmarker, ISCSI_IFMARKER_EN);
1366         SETUP_CONN_RD_ATTR(ofmarker, ISCSI_OFMARKER_EN);
1367         SETUP_CONN_RD_ATTR(address, ISCSI_CONN_ADDRESS);
1368         SETUP_CONN_RD_ATTR(port, ISCSI_CONN_PORT);
1369         SETUP_CONN_RD_ATTR(exp_statsn, ISCSI_EXP_STATSN);
1370         SETUP_CONN_RD_ATTR(persistent_address, ISCSI_PERSISTENT_ADDRESS);
1371         SETUP_CONN_RD_ATTR(persistent_port, ISCSI_PERSISTENT_PORT);
1372
1373         BUG_ON(count > ISCSI_CONN_ATTRS);
1374         priv->conn_attrs[count] = NULL;
1375         count = 0;
1376
1377         /* session parameters */
1378         priv->session_cont.ac.attrs = &priv->session_attrs[0];
1379         priv->session_cont.ac.class = &iscsi_session_class.class;
1380         priv->session_cont.ac.match = iscsi_session_match;
1381         transport_container_register(&priv->session_cont);
1382
1383         SETUP_SESSION_RD_ATTR(initial_r2t, ISCSI_INITIAL_R2T_EN);
1384         SETUP_SESSION_RD_ATTR(max_outstanding_r2t, ISCSI_MAX_R2T);
1385         SETUP_SESSION_RD_ATTR(immediate_data, ISCSI_IMM_DATA_EN);
1386         SETUP_SESSION_RD_ATTR(first_burst_len, ISCSI_FIRST_BURST);
1387         SETUP_SESSION_RD_ATTR(max_burst_len, ISCSI_MAX_BURST);
1388         SETUP_SESSION_RD_ATTR(data_pdu_in_order, ISCSI_PDU_INORDER_EN);
1389         SETUP_SESSION_RD_ATTR(data_seq_in_order, ISCSI_DATASEQ_INORDER_EN);
1390         SETUP_SESSION_RD_ATTR(erl, ISCSI_ERL);
1391         SETUP_SESSION_RD_ATTR(targetname, ISCSI_TARGET_NAME);
1392         SETUP_SESSION_RD_ATTR(tpgt, ISCSI_TPGT);
1393         SETUP_PRIV_SESSION_RD_ATTR(recovery_tmo);
1394
1395         BUG_ON(count > ISCSI_SESSION_ATTRS);
1396         priv->session_attrs[count] = NULL;
1397
1398         spin_lock_irqsave(&iscsi_transport_lock, flags);
1399         list_add(&priv->list, &iscsi_transports);
1400         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
1401
1402         printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
1403         return &priv->t;
1404
1405 unregister_cdev:
1406         class_device_unregister(&priv->cdev);
1407 free_priv:
1408         kfree(priv);
1409         return NULL;
1410 }
1411 EXPORT_SYMBOL_GPL(iscsi_register_transport);
1412
1413 int iscsi_unregister_transport(struct iscsi_transport *tt)
1414 {
1415         struct iscsi_internal *priv;
1416         unsigned long flags;
1417
1418         BUG_ON(!tt);
1419
1420         mutex_lock(&rx_queue_mutex);
1421
1422         priv = iscsi_if_transport_lookup(tt);
1423         BUG_ON (!priv);
1424
1425         spin_lock_irqsave(&iscsi_transport_lock, flags);
1426         list_del(&priv->list);
1427         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
1428
1429         transport_container_unregister(&priv->conn_cont);
1430         transport_container_unregister(&priv->session_cont);
1431         transport_container_unregister(&priv->t.host_attrs);
1432
1433         sysfs_remove_group(&priv->cdev.kobj, &iscsi_transport_group);
1434         class_device_unregister(&priv->cdev);
1435         mutex_unlock(&rx_queue_mutex);
1436
1437         return 0;
1438 }
1439 EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
1440
1441 static int
1442 iscsi_rcv_nl_event(struct notifier_block *this, unsigned long event, void *ptr)
1443 {
1444         struct netlink_notify *n = ptr;
1445
1446         if (event == NETLINK_URELEASE &&
1447             n->protocol == NETLINK_ISCSI && n->pid) {
1448                 struct iscsi_cls_conn *conn;
1449                 unsigned long flags;
1450
1451                 mempool_zone_complete(z_reply);
1452                 spin_lock_irqsave(&connlock, flags);
1453                 list_for_each_entry(conn, &connlist, conn_list) {
1454                         mempool_zone_complete(conn->z_error);
1455                         mempool_zone_complete(conn->z_pdu);
1456                 }
1457                 spin_unlock_irqrestore(&connlock, flags);
1458         }
1459
1460         return NOTIFY_DONE;
1461 }
1462
1463 static struct notifier_block iscsi_nl_notifier = {
1464         .notifier_call  = iscsi_rcv_nl_event,
1465 };
1466
1467 static __init int iscsi_transport_init(void)
1468 {
1469         int err;
1470
1471         err = class_register(&iscsi_transport_class);
1472         if (err)
1473                 return err;
1474
1475         err = transport_class_register(&iscsi_host_class);
1476         if (err)
1477                 goto unregister_transport_class;
1478
1479         err = transport_class_register(&iscsi_connection_class);
1480         if (err)
1481                 goto unregister_host_class;
1482
1483         err = transport_class_register(&iscsi_session_class);
1484         if (err)
1485                 goto unregister_conn_class;
1486
1487         err = netlink_register_notifier(&iscsi_nl_notifier);
1488         if (err)
1489                 goto unregister_session_class;
1490
1491         nls = netlink_kernel_create(NETLINK_ISCSI, 1, iscsi_if_rx,
1492                         THIS_MODULE);
1493         if (!nls) {
1494                 err = -ENOBUFS;
1495                 goto unregister_notifier;
1496         }
1497
1498         z_reply = mempool_zone_init(Z_MAX_REPLY,
1499                 NLMSG_SPACE(sizeof(struct iscsi_uevent)), Z_HIWAT_REPLY);
1500         if (z_reply)
1501                 return 0;
1502
1503         sock_release(nls->sk_socket);
1504 unregister_notifier:
1505         netlink_unregister_notifier(&iscsi_nl_notifier);
1506 unregister_session_class:
1507         transport_class_unregister(&iscsi_session_class);
1508 unregister_conn_class:
1509         transport_class_unregister(&iscsi_connection_class);
1510 unregister_host_class:
1511         transport_class_unregister(&iscsi_host_class);
1512 unregister_transport_class:
1513         class_unregister(&iscsi_transport_class);
1514         return err;
1515 }
1516
1517 static void __exit iscsi_transport_exit(void)
1518 {
1519         mempool_zone_destroy(z_reply);
1520         sock_release(nls->sk_socket);
1521         netlink_unregister_notifier(&iscsi_nl_notifier);
1522         transport_class_unregister(&iscsi_connection_class);
1523         transport_class_unregister(&iscsi_session_class);
1524         transport_class_unregister(&iscsi_host_class);
1525         class_unregister(&iscsi_transport_class);
1526 }
1527
1528 module_init(iscsi_transport_init);
1529 module_exit(iscsi_transport_exit);
1530
1531 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
1532               "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
1533               "Alex Aizman <itn780@yahoo.com>");
1534 MODULE_DESCRIPTION("iSCSI Transport Interface");
1535 MODULE_LICENSE("GPL");