Merge by Hand
[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/string.h>
25 #include <linux/slab.h>
26 #include <linux/mempool.h>
27 #include <net/tcp.h>
28
29 #include <scsi/scsi.h>
30 #include <scsi/scsi_host.h>
31 #include <scsi/scsi_device.h>
32 #include <scsi/scsi_transport.h>
33 #include <scsi/scsi_transport_iscsi.h>
34 #include <scsi/iscsi_if.h>
35
36 #define ISCSI_SESSION_ATTRS 8
37 #define ISCSI_CONN_ATTRS 6
38
39 struct iscsi_internal {
40         struct scsi_transport_template t;
41         struct iscsi_transport *iscsi_transport;
42         struct list_head list;
43         /*
44          * List of sessions for this transport
45          */
46         struct list_head sessions;
47         /*
48          * lock to serialize access to the sessions list which must
49          * be taken after the rx_queue_sema
50          */
51         spinlock_t session_lock;
52         /*
53          * based on transport capabilities, at register time we set these
54          * bits to tell the transport class it wants attributes displayed
55          * in sysfs or that it can support different iSCSI Data-Path
56          * capabilities
57          */
58         uint32_t param_mask;
59
60         struct class_device cdev;
61         /*
62          * We do not have any private or other attrs.
63          */
64         struct transport_container conn_cont;
65         struct class_device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1];
66         struct transport_container session_cont;
67         struct class_device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
68 };
69
70 /*
71  * list of registered transports and lock that must
72  * be held while accessing list. The iscsi_transport_lock must
73  * be acquired after the rx_queue_sema.
74  */
75 static LIST_HEAD(iscsi_transports);
76 static DEFINE_SPINLOCK(iscsi_transport_lock);
77
78 #define to_iscsi_internal(tmpl) \
79         container_of(tmpl, struct iscsi_internal, t)
80
81 #define cdev_to_iscsi_internal(_cdev) \
82         container_of(_cdev, struct iscsi_internal, cdev)
83
84 static void iscsi_transport_release(struct class_device *cdev)
85 {
86         struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
87         kfree(priv);
88 }
89
90 /*
91  * iscsi_transport_class represents the iscsi_transports that are
92  * registered.
93  */
94 static struct class iscsi_transport_class = {
95         .name = "iscsi_transport",
96         .release = iscsi_transport_release,
97 };
98
99 static ssize_t
100 show_transport_handle(struct class_device *cdev, char *buf)
101 {
102         struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
103         return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
104 }
105 static CLASS_DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
106
107 #define show_transport_attr(name, format)                               \
108 static ssize_t                                                          \
109 show_transport_##name(struct class_device *cdev, char *buf)             \
110 {                                                                       \
111         struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);     \
112         return sprintf(buf, format"\n", priv->iscsi_transport->name);   \
113 }                                                                       \
114 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
115
116 show_transport_attr(caps, "0x%x");
117 show_transport_attr(max_lun, "%d");
118 show_transport_attr(max_conn, "%d");
119 show_transport_attr(max_cmd_len, "%d");
120
121 static struct attribute *iscsi_transport_attrs[] = {
122         &class_device_attr_handle.attr,
123         &class_device_attr_caps.attr,
124         &class_device_attr_max_lun.attr,
125         &class_device_attr_max_conn.attr,
126         &class_device_attr_max_cmd_len.attr,
127         NULL,
128 };
129
130 static struct attribute_group iscsi_transport_group = {
131         .attrs = iscsi_transport_attrs,
132 };
133
134 static DECLARE_TRANSPORT_CLASS(iscsi_session_class,
135                                "iscsi_session",
136                                NULL,
137                                NULL,
138                                NULL);
139
140 static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
141                                "iscsi_connection",
142                                NULL,
143                                NULL,
144                                NULL);
145
146 static struct sock *nls;
147 static int daemon_pid;
148 static DECLARE_MUTEX(rx_queue_sema);
149
150 struct mempool_zone {
151         mempool_t *pool;
152         atomic_t allocated;
153         int size;
154         int hiwat;
155         struct list_head freequeue;
156         spinlock_t freelock;
157 };
158
159 static struct mempool_zone z_reply;
160
161 /*
162  * Z_MAX_* - actual mempool size allocated at the mempool_zone_init() time
163  * Z_HIWAT_* - zone's high watermark when if_error bit will be set to -ENOMEM
164  *             so daemon will notice OOM on NETLINK tranposrt level and will
165  *             be able to predict or change operational behavior
166  */
167 #define Z_MAX_REPLY     8
168 #define Z_HIWAT_REPLY   6
169 #define Z_MAX_PDU       8
170 #define Z_HIWAT_PDU     6
171 #define Z_MAX_ERROR     16
172 #define Z_HIWAT_ERROR   12
173
174 struct iscsi_if_conn {
175         struct list_head conn_list;     /* item in connlist */
176         struct list_head session_list;  /* item in session->connections */
177         iscsi_connh_t connh;
178         int active;                     /* must be accessed with the connlock */
179         struct Scsi_Host *host;         /* originated shost */
180         struct device dev;              /* sysfs transport/container device */
181         struct iscsi_transport *transport;
182         struct mempool_zone z_error;
183         struct mempool_zone z_pdu;
184         struct list_head freequeue;
185 };
186
187 #define iscsi_dev_to_if_conn(_dev) \
188         container_of(_dev, struct iscsi_if_conn, dev)
189
190 #define iscsi_cdev_to_if_conn(_cdev) \
191         iscsi_dev_to_if_conn(_cdev->dev)
192
193 static LIST_HEAD(connlist);
194 static DEFINE_SPINLOCK(connlock);
195
196 struct iscsi_if_session {
197         struct list_head list;  /* item in session_list */
198         struct list_head connections;
199         iscsi_sessionh_t sessionh;
200         struct iscsi_transport *transport;
201         struct device dev;      /* sysfs transport/container device */
202 };
203
204 #define iscsi_dev_to_if_session(_dev) \
205         container_of(_dev, struct iscsi_if_session, dev)
206
207 #define iscsi_cdev_to_if_session(_cdev) \
208         iscsi_dev_to_if_session(_cdev->dev)
209
210 #define iscsi_if_session_to_shost(_session) \
211         dev_to_shost(_session->dev.parent)
212
213 static struct iscsi_if_conn*
214 iscsi_if_find_conn(uint64_t key)
215 {
216         unsigned long flags;
217         struct iscsi_if_conn *conn;
218
219         spin_lock_irqsave(&connlock, flags);
220         list_for_each_entry(conn, &connlist, conn_list)
221                 if (conn->connh == key) {
222                         spin_unlock_irqrestore(&connlock, flags);
223                         return conn;
224                 }
225         spin_unlock_irqrestore(&connlock, flags);
226         return NULL;
227 }
228
229 static struct iscsi_internal *
230 iscsi_if_transport_lookup(struct iscsi_transport *tt)
231 {
232         struct iscsi_internal *priv;
233         unsigned long flags;
234
235         spin_lock_irqsave(&iscsi_transport_lock, flags);
236         list_for_each_entry(priv, &iscsi_transports, list) {
237                 if (tt == priv->iscsi_transport) {
238                         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
239                         return priv;
240                 }
241         }
242         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
243         return NULL;
244 }
245
246 static inline struct list_head *skb_to_lh(struct sk_buff *skb)
247 {
248         return (struct list_head *)&skb->cb;
249 }
250
251 static void*
252 mempool_zone_alloc_skb(unsigned int gfp_mask, void *pool_data)
253 {
254         struct mempool_zone *zone = pool_data;
255
256         return alloc_skb(zone->size, gfp_mask);
257 }
258
259 static void
260 mempool_zone_free_skb(void *element, void *pool_data)
261 {
262         kfree_skb(element);
263 }
264
265 static void
266 mempool_zone_complete(struct mempool_zone *zone)
267 {
268         unsigned long flags;
269         struct list_head *lh, *n;
270
271         spin_lock_irqsave(&zone->freelock, flags);
272         list_for_each_safe(lh, n, &zone->freequeue) {
273                 struct sk_buff *skb = (struct sk_buff *)((char *)lh -
274                                 offsetof(struct sk_buff, cb));
275                 if (!skb_shared(skb)) {
276                         list_del(skb_to_lh(skb));
277                         mempool_free(skb, zone->pool);
278                         atomic_dec(&zone->allocated);
279                 }
280         }
281         spin_unlock_irqrestore(&zone->freelock, flags);
282 }
283
284 static int
285 mempool_zone_init(struct mempool_zone *zp, unsigned max, unsigned size,
286                 unsigned hiwat)
287 {
288         zp->pool = mempool_create(max, mempool_zone_alloc_skb,
289                                   mempool_zone_free_skb, zp);
290         if (!zp->pool)
291                 return -ENOMEM;
292
293         zp->size = size;
294         zp->hiwat = hiwat;
295
296         INIT_LIST_HEAD(&zp->freequeue);
297         spin_lock_init(&zp->freelock);
298         atomic_set(&zp->allocated, 0);
299
300         return 0;
301 }
302
303
304 static struct sk_buff*
305 mempool_zone_get_skb(struct mempool_zone *zone)
306 {
307         struct sk_buff *skb;
308
309         skb = mempool_alloc(zone->pool, GFP_ATOMIC);
310         if (skb)
311                 atomic_inc(&zone->allocated);
312         return skb;
313 }
314
315 static int
316 iscsi_unicast_skb(struct mempool_zone *zone, struct sk_buff *skb)
317 {
318         unsigned long flags;
319         int rc;
320
321         skb_get(skb);
322         rc = netlink_unicast(nls, skb, daemon_pid, MSG_DONTWAIT);
323         if (rc < 0) {
324                 mempool_free(skb, zone->pool);
325                 printk(KERN_ERR "iscsi: can not unicast skb (%d)\n", rc);
326                 return rc;
327         }
328
329         spin_lock_irqsave(&zone->freelock, flags);
330         list_add(skb_to_lh(skb), &zone->freequeue);
331         spin_unlock_irqrestore(&zone->freelock, flags);
332
333         return 0;
334 }
335
336 int iscsi_recv_pdu(iscsi_connh_t connh, struct iscsi_hdr *hdr,
337                    char *data, uint32_t data_size)
338 {
339         struct nlmsghdr *nlh;
340         struct sk_buff *skb;
341         struct iscsi_uevent *ev;
342         struct iscsi_if_conn *conn;
343         char *pdu;
344         int len = NLMSG_SPACE(sizeof(*ev) + sizeof(struct iscsi_hdr) +
345                               data_size);
346
347         conn = iscsi_if_find_conn(connh);
348         BUG_ON(!conn);
349
350         mempool_zone_complete(&conn->z_pdu);
351
352         skb = mempool_zone_get_skb(&conn->z_pdu);
353         if (!skb) {
354                 iscsi_conn_error(connh, ISCSI_ERR_CONN_FAILED);
355                 printk(KERN_ERR "iscsi%d: can not deliver control PDU: OOM\n",
356                        conn->host->host_no);
357                 return -ENOMEM;
358         }
359
360         nlh = __nlmsg_put(skb, daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
361         ev = NLMSG_DATA(nlh);
362         memset(ev, 0, sizeof(*ev));
363         ev->transport_handle = iscsi_handle(conn->transport);
364         ev->type = ISCSI_KEVENT_RECV_PDU;
365         if (atomic_read(&conn->z_pdu.allocated) >= conn->z_pdu.hiwat)
366                 ev->iferror = -ENOMEM;
367         ev->r.recv_req.conn_handle = connh;
368         pdu = (char*)ev + sizeof(*ev);
369         memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
370         memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
371
372         return iscsi_unicast_skb(&conn->z_pdu, skb);
373 }
374 EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
375
376 void iscsi_conn_error(iscsi_connh_t connh, enum iscsi_err error)
377 {
378         struct nlmsghdr *nlh;
379         struct sk_buff  *skb;
380         struct iscsi_uevent *ev;
381         struct iscsi_if_conn *conn;
382         int len = NLMSG_SPACE(sizeof(*ev));
383
384         conn = iscsi_if_find_conn(connh);
385         BUG_ON(!conn);
386
387         mempool_zone_complete(&conn->z_error);
388
389         skb = mempool_zone_get_skb(&conn->z_error);
390         if (!skb) {
391                 printk(KERN_ERR "iscsi%d: gracefully ignored conn error (%d)\n",
392                        conn->host->host_no, error);
393                 return;
394         }
395
396         nlh = __nlmsg_put(skb, daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
397         ev = NLMSG_DATA(nlh);
398         ev->transport_handle = iscsi_handle(conn->transport);
399         ev->type = ISCSI_KEVENT_CONN_ERROR;
400         if (atomic_read(&conn->z_error.allocated) >= conn->z_error.hiwat)
401                 ev->iferror = -ENOMEM;
402         ev->r.connerror.error = error;
403         ev->r.connerror.conn_handle = connh;
404
405         iscsi_unicast_skb(&conn->z_error, skb);
406
407         printk(KERN_INFO "iscsi%d: detected conn error (%d)\n",
408                conn->host->host_no, error);
409 }
410 EXPORT_SYMBOL_GPL(iscsi_conn_error);
411
412 static int
413 iscsi_if_send_reply(int pid, int seq, int type, int done, int multi,
414                       void *payload, int size)
415 {
416         struct sk_buff  *skb;
417         struct nlmsghdr *nlh;
418         int len = NLMSG_SPACE(size);
419         int flags = multi ? NLM_F_MULTI : 0;
420         int t = done ? NLMSG_DONE : type;
421
422         mempool_zone_complete(&z_reply);
423
424         skb = mempool_zone_get_skb(&z_reply);
425         /*
426          * FIXME:
427          * user is supposed to react on iferror == -ENOMEM;
428          * see iscsi_if_rx().
429          */
430         BUG_ON(!skb);
431
432         nlh = __nlmsg_put(skb, pid, seq, t, (len - sizeof(*nlh)), 0);
433         nlh->nlmsg_flags = flags;
434         memcpy(NLMSG_DATA(nlh), payload, size);
435         return iscsi_unicast_skb(&z_reply, skb);
436 }
437
438 /*
439  * iSCSI Session's hostdata organization:
440  *
441  *    *------------------* <== host->hostdata
442  *    | transport        |
443  *    |------------------| <== iscsi_hostdata(host->hostdata)
444  *    | transport's data |
445  *    |------------------| <== hostdata_session(host->hostdata)
446  *    | interface's data |
447  *    *------------------*
448  */
449
450 #define hostdata_privsize(_t)   (sizeof(unsigned long) + _t->hostdata_size + \
451                                  _t->hostdata_size % sizeof(unsigned long) + \
452                                  sizeof(struct iscsi_if_session))
453
454 #define hostdata_session(_hostdata) ((void*)_hostdata + sizeof(unsigned long) + \
455                         ((struct iscsi_transport *) \
456                          iscsi_ptr(*(uint64_t *)_hostdata))->hostdata_size)
457
458 static void iscsi_if_session_dev_release(struct device *dev)
459 {
460         struct iscsi_if_session *session = iscsi_dev_to_if_session(dev);
461         struct iscsi_transport *transport = session->transport;
462         struct Scsi_Host *shost = iscsi_if_session_to_shost(session);
463         struct iscsi_if_conn *conn, *tmp;
464         unsigned long flags;
465
466         /* now free connections */
467         spin_lock_irqsave(&connlock, flags);
468         list_for_each_entry_safe(conn, tmp, &session->connections,
469                                  session_list) {
470                 list_del(&conn->session_list);
471                 mempool_destroy(conn->z_pdu.pool);
472                 mempool_destroy(conn->z_error.pool);
473                 kfree(conn);
474         }
475         spin_unlock_irqrestore(&connlock, flags);
476         scsi_host_put(shost);
477         module_put(transport->owner);
478 }
479
480 static int
481 iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_uevent *ev)
482 {
483         struct iscsi_transport *transport = priv->iscsi_transport;
484         struct iscsi_if_session *session;
485         struct Scsi_Host *shost;
486         unsigned long flags;
487         int error;
488
489         if (!try_module_get(transport->owner))
490                 return -EPERM;
491
492         shost = scsi_host_alloc(transport->host_template,
493                                 hostdata_privsize(transport));
494         if (!shost) {
495                 ev->r.c_session_ret.session_handle = iscsi_handle(NULL);
496                 printk(KERN_ERR "iscsi: can not allocate SCSI host for "
497                        "session\n");
498                 error = -ENOMEM;
499                 goto out_module_put;
500         }
501         shost->max_id = 1;
502         shost->max_channel = 0;
503         shost->max_lun = transport->max_lun;
504         shost->max_cmd_len = transport->max_cmd_len;
505         shost->transportt = &priv->t;
506
507         /* store struct iscsi_transport in hostdata */
508         *(uint64_t*)shost->hostdata = ev->transport_handle;
509
510         ev->r.c_session_ret.session_handle = transport->create_session(
511                                         ev->u.c_session.initial_cmdsn, shost);
512         if (ev->r.c_session_ret.session_handle == iscsi_handle(NULL)) {
513                 error = 0;
514                 goto out_host_put;
515         }
516
517         /* host_no becomes assigned SID */
518         ev->r.c_session_ret.sid = shost->host_no;
519         /* initialize session */
520         session = hostdata_session(shost->hostdata);
521         INIT_LIST_HEAD(&session->connections);
522         INIT_LIST_HEAD(&session->list);
523         session->sessionh = ev->r.c_session_ret.session_handle;
524         session->transport = transport;
525
526         error = scsi_add_host(shost, NULL);
527         if (error)
528                 goto out_destroy_session;
529
530         /*
531          * this is released in the dev's release function)
532          */
533         scsi_host_get(shost);
534         snprintf(session->dev.bus_id, BUS_ID_SIZE, "session%u", shost->host_no);
535         session->dev.parent = &shost->shost_gendev;
536         session->dev.release = iscsi_if_session_dev_release;
537         error = device_register(&session->dev);
538         if (error) {
539                 printk(KERN_ERR "iscsi: could not register session%d's dev\n",
540                        shost->host_no);
541                 goto out_remove_host;
542         }
543         transport_register_device(&session->dev);
544
545         /* add this session to the list of active sessions */
546         spin_lock_irqsave(&priv->session_lock, flags);
547         list_add(&session->list, &priv->sessions);
548         spin_unlock_irqrestore(&priv->session_lock, flags);
549
550         return 0;
551
552 out_remove_host:
553         scsi_remove_host(shost);
554 out_destroy_session:
555         transport->destroy_session(ev->r.c_session_ret.session_handle);
556         ev->r.c_session_ret.session_handle = iscsi_handle(NULL);
557 out_host_put:
558         scsi_host_put(shost);
559 out_module_put:
560         module_put(transport->owner);
561         return error;
562 }
563
564 static int
565 iscsi_if_destroy_session(struct iscsi_internal *priv, struct iscsi_uevent *ev)
566 {
567         struct iscsi_transport *transport = priv->iscsi_transport;
568         struct Scsi_Host *shost;
569         struct iscsi_if_session *session;
570         unsigned long flags;
571         struct iscsi_if_conn *conn;
572         int error = 0;
573
574         shost = scsi_host_lookup(ev->u.d_session.sid);
575         if (shost == ERR_PTR(-ENXIO))
576                 return -EEXIST;
577         session = hostdata_session(shost->hostdata);
578
579         /* check if we have active connections */
580         spin_lock_irqsave(&connlock, flags);
581         list_for_each_entry(conn, &session->connections, session_list) {
582                 if (conn->active) {
583                         printk(KERN_ERR "iscsi%d: can not destroy session: "
584                                "has active connection (%p)\n",
585                                shost->host_no, iscsi_ptr(conn->connh));
586                         spin_unlock_irqrestore(&connlock, flags);
587                         error = EIO;
588                         goto out_release_ref;
589                 }
590         }
591         spin_unlock_irqrestore(&connlock, flags);
592
593         scsi_remove_host(shost);
594         transport->destroy_session(ev->u.d_session.session_handle);
595         transport_unregister_device(&session->dev);
596         device_unregister(&session->dev);
597
598         /* remove this session from the list of active sessions */
599         spin_lock_irqsave(&priv->session_lock, flags);
600         list_del(&session->list);
601         spin_unlock_irqrestore(&priv->session_lock, flags);
602
603         /* ref from host alloc */
604         scsi_host_put(shost);
605 out_release_ref:
606         /* ref from host lookup */
607         scsi_host_put(shost);
608         return error;
609 }
610
611 static void iscsi_if_conn_dev_release(struct device *dev)
612 {
613         struct iscsi_if_conn *conn = iscsi_dev_to_if_conn(dev);
614         struct Scsi_Host *shost = conn->host;
615
616         scsi_host_put(shost);
617 }
618
619 static int
620 iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
621 {
622         struct iscsi_if_session *session;
623         struct Scsi_Host *shost;
624         struct iscsi_if_conn *conn;
625         unsigned long flags;
626         int error;
627
628         shost = scsi_host_lookup(ev->u.c_conn.sid);
629         if (shost == ERR_PTR(-ENXIO))
630                 return -EEXIST;
631         session = hostdata_session(shost->hostdata);
632
633         conn = kmalloc(sizeof(struct iscsi_if_conn), GFP_KERNEL);
634         if (!conn) {
635                 error = -ENOMEM;
636                 goto out_release_ref;
637         }
638         memset(conn, 0, sizeof(struct iscsi_if_conn));
639         INIT_LIST_HEAD(&conn->session_list);
640         INIT_LIST_HEAD(&conn->conn_list);
641         conn->host = shost;
642         conn->transport = transport;
643
644         error = mempool_zone_init(&conn->z_pdu, Z_MAX_PDU,
645                         NLMSG_SPACE(sizeof(struct iscsi_uevent) +
646                                     sizeof(struct iscsi_hdr) +
647                                     DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH),
648                         Z_HIWAT_PDU);
649         if (error) {
650                 printk(KERN_ERR "iscsi%d: can not allocate pdu zone for new "
651                        "conn\n", shost->host_no);
652                 goto out_free_conn;
653         }
654         error = mempool_zone_init(&conn->z_error, Z_MAX_ERROR,
655                         NLMSG_SPACE(sizeof(struct iscsi_uevent)),
656                         Z_HIWAT_ERROR);
657         if (error) {
658                 printk(KERN_ERR "iscsi%d: can not allocate error zone for "
659                        "new conn\n", shost->host_no);
660                 goto out_free_pdu_pool;
661         }
662
663         ev->r.handle = transport->create_conn(ev->u.c_conn.session_handle,
664                                         ev->u.c_conn.cid);
665         if (!ev->r.handle) {
666                 error = -ENODEV;
667                 goto out_free_error_pool;
668         }
669
670         conn->connh = ev->r.handle;
671
672         /*
673          * this is released in the dev's release function
674          */
675         if (!scsi_host_get(shost))
676                 goto out_destroy_conn;
677         snprintf(conn->dev.bus_id, BUS_ID_SIZE, "connection%d:%u",
678                  shost->host_no, ev->u.c_conn.cid);
679         conn->dev.parent = &session->dev;
680         conn->dev.release = iscsi_if_conn_dev_release;
681         error = device_register(&conn->dev);
682         if (error) {
683                 printk(KERN_ERR "iscsi%d: could not register connections%u "
684                        "dev\n", shost->host_no, ev->u.c_conn.cid);
685                 goto out_release_parent_ref;
686         }
687         transport_register_device(&conn->dev);
688
689         spin_lock_irqsave(&connlock, flags);
690         list_add(&conn->conn_list, &connlist);
691         list_add(&conn->session_list, &session->connections);
692         conn->active = 1;
693         spin_unlock_irqrestore(&connlock, flags);
694
695         scsi_host_put(shost);
696         return 0;
697
698 out_release_parent_ref:
699         scsi_host_put(shost);
700 out_destroy_conn:
701         transport->destroy_conn(ev->r.handle);
702 out_free_error_pool:
703         mempool_destroy(conn->z_error.pool);
704 out_free_pdu_pool:
705         mempool_destroy(conn->z_pdu.pool);
706 out_free_conn:
707         kfree(conn);
708 out_release_ref:
709         scsi_host_put(shost);
710         return error;
711 }
712
713 static int
714 iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
715 {
716         unsigned long flags;
717         struct iscsi_if_conn *conn;
718
719         conn = iscsi_if_find_conn(ev->u.d_conn.conn_handle);
720         if (!conn)
721                 return -EEXIST;
722
723         transport->destroy_conn(ev->u.d_conn.conn_handle);
724
725         spin_lock_irqsave(&connlock, flags);
726         conn->active = 0;
727         list_del(&conn->conn_list);
728         spin_unlock_irqrestore(&connlock, flags);
729
730         transport_unregister_device(&conn->dev);
731         device_unregister(&conn->dev);
732         return 0;
733 }
734
735 static int
736 iscsi_if_get_stats(struct iscsi_transport *transport, struct sk_buff *skb,
737                    struct nlmsghdr *nlh)
738 {
739         struct iscsi_uevent *ev = NLMSG_DATA(nlh);
740         struct iscsi_stats *stats;
741         struct sk_buff *skbstat;
742         struct iscsi_if_conn *conn;
743         struct nlmsghdr *nlhstat;
744         struct iscsi_uevent *evstat;
745         int len = NLMSG_SPACE(sizeof(*ev) +
746                               sizeof(struct iscsi_stats) +
747                               sizeof(struct iscsi_stats_custom) *
748                               ISCSI_STATS_CUSTOM_MAX);
749         int err = 0;
750
751         conn = iscsi_if_find_conn(ev->u.get_stats.conn_handle);
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                         printk(KERN_ERR "iscsi%d: can not deliver stats: OOM\n",
763                                conn->host->host_no);
764                         return -ENOMEM;
765                 }
766
767                 nlhstat = __nlmsg_put(skbstat, 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.conn_handle =
776                         ev->u.get_stats.conn_handle;
777                 stats = (struct iscsi_stats *)
778                         ((char*)evstat + sizeof(*evstat));
779                 memset(stats, 0, sizeof(*stats));
780
781                 transport->get_stats(ev->u.get_stats.conn_handle, stats);
782                 actual_size = NLMSG_SPACE(sizeof(struct iscsi_uevent) +
783                                           sizeof(struct iscsi_stats) +
784                                           sizeof(struct iscsi_stats_custom) *
785                                           stats->custom_length);
786                 actual_size -= sizeof(*nlhstat);
787                 actual_size = NLMSG_LENGTH(actual_size);
788                 skb_trim(skb, NLMSG_ALIGN(actual_size));
789                 nlhstat->nlmsg_len = actual_size;
790
791                 err = iscsi_unicast_skb(&conn->z_pdu, skbstat);
792         } while (err < 0 && err != -ECONNREFUSED);
793
794         return err;
795 }
796
797 static int
798 iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
799 {
800         int err = 0;
801         struct iscsi_uevent *ev = NLMSG_DATA(nlh);
802         struct iscsi_transport *transport = NULL;
803         struct iscsi_internal *priv;
804
805         if (NETLINK_CREDS(skb)->uid)
806                 return -EPERM;
807
808         priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle));
809         if (!priv)
810                 return -EINVAL;
811         transport = priv->iscsi_transport;
812
813         daemon_pid = NETLINK_CREDS(skb)->pid;
814
815         switch (nlh->nlmsg_type) {
816         case ISCSI_UEVENT_CREATE_SESSION:
817                 err = iscsi_if_create_session(priv, ev);
818                 break;
819         case ISCSI_UEVENT_DESTROY_SESSION:
820                 err = iscsi_if_destroy_session(priv, ev);
821                 break;
822         case ISCSI_UEVENT_CREATE_CONN:
823                 err = iscsi_if_create_conn(transport, ev);
824                 break;
825         case ISCSI_UEVENT_DESTROY_CONN:
826                 err = iscsi_if_destroy_conn(transport, ev);
827                 break;
828         case ISCSI_UEVENT_BIND_CONN:
829                 if (!iscsi_if_find_conn(ev->u.b_conn.conn_handle))
830                         return -EEXIST;
831                 ev->r.retcode = transport->bind_conn(
832                         ev->u.b_conn.session_handle,
833                         ev->u.b_conn.conn_handle,
834                         ev->u.b_conn.transport_fd,
835                         ev->u.b_conn.is_leading);
836                 break;
837         case ISCSI_UEVENT_SET_PARAM:
838                 if (!iscsi_if_find_conn(ev->u.set_param.conn_handle))
839                         return -EEXIST;
840                 ev->r.retcode = transport->set_param(
841                         ev->u.set_param.conn_handle,
842                         ev->u.set_param.param, ev->u.set_param.value);
843                 break;
844         case ISCSI_UEVENT_START_CONN:
845                 if (!iscsi_if_find_conn(ev->u.start_conn.conn_handle))
846                         return -EEXIST;
847                 ev->r.retcode = transport->start_conn(
848                         ev->u.start_conn.conn_handle);
849                 break;
850         case ISCSI_UEVENT_STOP_CONN:
851                 if (!iscsi_if_find_conn(ev->u.stop_conn.conn_handle))
852                         return -EEXIST;
853                 transport->stop_conn(ev->u.stop_conn.conn_handle,
854                         ev->u.stop_conn.flag);
855                 break;
856         case ISCSI_UEVENT_SEND_PDU:
857                 if (!iscsi_if_find_conn(ev->u.send_pdu.conn_handle))
858                         return -EEXIST;
859                 ev->r.retcode = transport->send_pdu(
860                        ev->u.send_pdu.conn_handle,
861                        (struct iscsi_hdr*)((char*)ev + sizeof(*ev)),
862                        (char*)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,
863                         ev->u.send_pdu.data_size);
864                 break;
865         case ISCSI_UEVENT_GET_STATS:
866                 err = iscsi_if_get_stats(transport, skb, nlh);
867                 break;
868         default:
869                 err = -EINVAL;
870                 break;
871         }
872
873         return err;
874 }
875
876 /* Get message from skb (based on rtnetlink_rcv_skb).  Each message is
877  * processed by iscsi_if_recv_msg.  Malformed skbs with wrong length are
878  * discarded silently.  */
879 static void
880 iscsi_if_rx(struct sock *sk, int len)
881 {
882         struct sk_buff *skb;
883
884         down(&rx_queue_sema);
885         while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
886                 while (skb->len >= NLMSG_SPACE(0)) {
887                         int err;
888                         uint32_t rlen;
889                         struct nlmsghdr *nlh;
890                         struct iscsi_uevent *ev;
891
892                         nlh = (struct nlmsghdr *)skb->data;
893                         if (nlh->nlmsg_len < sizeof(*nlh) ||
894                             skb->len < nlh->nlmsg_len) {
895                                 break;
896                         }
897                         ev = NLMSG_DATA(nlh);
898                         rlen = NLMSG_ALIGN(nlh->nlmsg_len);
899                         if (rlen > skb->len)
900                                 rlen = skb->len;
901                         err = iscsi_if_recv_msg(skb, nlh);
902                         if (err) {
903                                 ev->type = ISCSI_KEVENT_IF_ERROR;
904                                 ev->iferror = err;
905                         }
906                         do {
907                                 /*
908                                  * special case for GET_STATS:
909                                  * on success - sending reply and stats from
910                                  * inside of if_recv_msg(),
911                                  * on error - fall through.
912                                  */
913                                 if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
914                                         break;
915                                 err = iscsi_if_send_reply(
916                                         NETLINK_CREDS(skb)->pid, nlh->nlmsg_seq,
917                                         nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
918                                 if (atomic_read(&z_reply.allocated) >=
919                                                 z_reply.hiwat)
920                                         ev->iferror = -ENOMEM;
921                         } while (err < 0 && err != -ECONNREFUSED);
922                         skb_pull(skb, rlen);
923                 }
924                 kfree_skb(skb);
925         }
926         up(&rx_queue_sema);
927 }
928
929 /*
930  * iSCSI connection attrs
931  */
932 #define iscsi_conn_int_attr_show(param, format)                         \
933 static ssize_t                                                          \
934 show_conn_int_param_##param(struct class_device *cdev, char *buf)       \
935 {                                                                       \
936         uint32_t value = 0;                                             \
937         struct iscsi_if_conn *conn = iscsi_cdev_to_if_conn(cdev);       \
938         struct iscsi_internal *priv;                                    \
939                                                                         \
940         priv = to_iscsi_internal(conn->host->transportt);               \
941         if (priv->param_mask & (1 << param))                            \
942                 priv->iscsi_transport->get_param(conn->connh, param, &value); \
943         return snprintf(buf, 20, format"\n", value);                    \
944 }
945
946 #define iscsi_conn_int_attr(field, param, format)                       \
947         iscsi_conn_int_attr_show(param, format)                         \
948 static CLASS_DEVICE_ATTR(field, S_IRUGO, show_conn_int_param_##param, NULL);
949
950 iscsi_conn_int_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH, "%u");
951 iscsi_conn_int_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH, "%u");
952 iscsi_conn_int_attr(header_digest, ISCSI_PARAM_HDRDGST_EN, "%d");
953 iscsi_conn_int_attr(data_digest, ISCSI_PARAM_DATADGST_EN, "%d");
954 iscsi_conn_int_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN, "%d");
955 iscsi_conn_int_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN, "%d");
956
957 /*
958  * iSCSI session attrs
959  */
960 #define iscsi_session_int_attr_show(param, format)                      \
961 static ssize_t                                                          \
962 show_session_int_param_##param(struct class_device *cdev, char *buf)    \
963 {                                                                       \
964         uint32_t value = 0;                                             \
965         struct iscsi_if_session *session = iscsi_cdev_to_if_session(cdev); \
966         struct Scsi_Host *shost = iscsi_if_session_to_shost(session);   \
967         struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
968         struct iscsi_if_conn *conn = NULL;                              \
969         unsigned long  flags;                                           \
970                                                                         \
971         spin_lock_irqsave(&connlock, flags);                            \
972         if (!list_empty(&session->connections))                         \
973                 conn = list_entry(session->connections.next,            \
974                                   struct iscsi_if_conn, session_list);  \
975         spin_unlock_irqrestore(&connlock, flags);                       \
976                                                                         \
977         if (conn && (priv->param_mask & (1 << param)))                  \
978                 priv->iscsi_transport->get_param(conn->connh, param, &value);\
979         return snprintf(buf, 20, format"\n", value);                    \
980 }
981
982 #define iscsi_session_int_attr(field, param, format)                    \
983         iscsi_session_int_attr_show(param, format)                      \
984 static CLASS_DEVICE_ATTR(field, S_IRUGO, show_session_int_param_##param, NULL);
985
986 iscsi_session_int_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN, "%d");
987 iscsi_session_int_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T, "%hu");
988 iscsi_session_int_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN, "%d");
989 iscsi_session_int_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST, "%u");
990 iscsi_session_int_attr(max_burst_len, ISCSI_PARAM_MAX_BURST, "%u");
991 iscsi_session_int_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN, "%d");
992 iscsi_session_int_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN, "%d");
993 iscsi_session_int_attr(erl, ISCSI_PARAM_ERL, "%d");
994
995 #define SETUP_SESSION_RD_ATTR(field, param)                             \
996         if (priv->param_mask & (1 << param)) {                          \
997                 priv->session_attrs[count] = &class_device_attr_##field;\
998                 count++;                                                \
999         }
1000
1001 #define SETUP_CONN_RD_ATTR(field, param)                                \
1002         if (priv->param_mask & (1 << param)) {                          \
1003                 priv->conn_attrs[count] = &class_device_attr_##field;   \
1004                 count++;                                                \
1005         }
1006
1007 static int iscsi_is_session_dev(const struct device *dev)
1008 {
1009         return dev->release == iscsi_if_session_dev_release;
1010 }
1011
1012 static int iscsi_session_match(struct attribute_container *cont,
1013                            struct device *dev)
1014 {
1015         struct iscsi_if_session *session;
1016         struct Scsi_Host *shost;
1017         struct iscsi_internal *priv;
1018
1019         if (!iscsi_is_session_dev(dev))
1020                 return 0;
1021
1022         session = iscsi_dev_to_if_session(dev);
1023         shost = iscsi_if_session_to_shost(session);
1024         if (!shost->transportt)
1025                 return 0;
1026
1027         priv = to_iscsi_internal(shost->transportt);
1028         if (priv->session_cont.ac.class != &iscsi_session_class.class)
1029                 return 0;
1030
1031         return &priv->session_cont.ac == cont;
1032 }
1033
1034 static int iscsi_is_conn_dev(const struct device *dev)
1035 {
1036         return dev->release == iscsi_if_conn_dev_release;
1037 }
1038
1039 static int iscsi_conn_match(struct attribute_container *cont,
1040                            struct device *dev)
1041 {
1042         struct iscsi_if_conn *conn;
1043         struct Scsi_Host *shost;
1044         struct iscsi_internal *priv;
1045
1046         if (!iscsi_is_conn_dev(dev))
1047                 return 0;
1048
1049         conn = iscsi_dev_to_if_conn(dev);
1050         shost = conn->host;
1051         if (!shost->transportt)
1052                 return 0;
1053
1054         priv = to_iscsi_internal(shost->transportt);
1055         if (priv->conn_cont.ac.class != &iscsi_connection_class.class)
1056                 return 0;
1057
1058         return &priv->conn_cont.ac == cont;
1059 }
1060
1061 int iscsi_register_transport(struct iscsi_transport *tt)
1062 {
1063         struct iscsi_internal *priv;
1064         unsigned long flags;
1065         int count = 0, err;
1066
1067         BUG_ON(!tt);
1068
1069         priv = iscsi_if_transport_lookup(tt);
1070         if (priv)
1071                 return -EEXIST;
1072
1073         priv = kmalloc(sizeof(*priv), GFP_KERNEL);
1074         if (!priv)
1075                 return -ENOMEM;
1076         memset(priv, 0, sizeof(*priv));
1077         INIT_LIST_HEAD(&priv->list);
1078         INIT_LIST_HEAD(&priv->sessions);
1079         spin_lock_init(&priv->session_lock);
1080         priv->iscsi_transport = tt;
1081
1082         priv->cdev.class = &iscsi_transport_class;
1083         snprintf(priv->cdev.class_id, BUS_ID_SIZE, "%s", tt->name);
1084         err = class_device_register(&priv->cdev);
1085         if (err)
1086                 goto free_priv;
1087
1088         err = sysfs_create_group(&priv->cdev.kobj, &iscsi_transport_group);
1089         if (err)
1090                 goto unregister_cdev;
1091
1092         /* setup parameters mask */
1093         priv->param_mask = 0xFFFFFFFF;
1094         if (!(tt->caps & CAP_MULTI_R2T))
1095                 priv->param_mask &= ~(1 << ISCSI_PARAM_MAX_R2T);
1096         if (!(tt->caps & CAP_HDRDGST))
1097                 priv->param_mask &= ~(1 << ISCSI_PARAM_HDRDGST_EN);
1098         if (!(tt->caps & CAP_DATADGST))
1099                 priv->param_mask &= ~(1 << ISCSI_PARAM_DATADGST_EN);
1100         if (!(tt->caps & CAP_MARKERS)) {
1101                 priv->param_mask &= ~(1 << ISCSI_PARAM_IFMARKER_EN);
1102                 priv->param_mask &= ~(1 << ISCSI_PARAM_OFMARKER_EN);
1103         }
1104
1105         /* connection parameters */
1106         priv->conn_cont.ac.attrs = &priv->conn_attrs[0];
1107         priv->conn_cont.ac.class = &iscsi_connection_class.class;
1108         priv->conn_cont.ac.match = iscsi_conn_match;
1109         transport_container_register(&priv->conn_cont);
1110
1111         SETUP_CONN_RD_ATTR(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH);
1112         SETUP_CONN_RD_ATTR(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH);
1113         SETUP_CONN_RD_ATTR(header_digest, ISCSI_PARAM_HDRDGST_EN);
1114         SETUP_CONN_RD_ATTR(data_digest, ISCSI_PARAM_DATADGST_EN);
1115         SETUP_CONN_RD_ATTR(ifmarker, ISCSI_PARAM_IFMARKER_EN);
1116         SETUP_CONN_RD_ATTR(ofmarker, ISCSI_PARAM_OFMARKER_EN);
1117
1118         BUG_ON(count > ISCSI_CONN_ATTRS);
1119         priv->conn_attrs[count] = NULL;
1120         count = 0;
1121
1122         /* session parameters */
1123         priv->session_cont.ac.attrs = &priv->session_attrs[0];
1124         priv->session_cont.ac.class = &iscsi_session_class.class;
1125         priv->session_cont.ac.match = iscsi_session_match;
1126         transport_container_register(&priv->session_cont);
1127
1128         SETUP_SESSION_RD_ATTR(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN);
1129         SETUP_SESSION_RD_ATTR(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T);
1130         SETUP_SESSION_RD_ATTR(immediate_data, ISCSI_PARAM_IMM_DATA_EN);
1131         SETUP_SESSION_RD_ATTR(first_burst_len, ISCSI_PARAM_FIRST_BURST);
1132         SETUP_SESSION_RD_ATTR(max_burst_len, ISCSI_PARAM_MAX_BURST);
1133         SETUP_SESSION_RD_ATTR(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN);
1134         SETUP_SESSION_RD_ATTR(data_seq_in_order,ISCSI_PARAM_DATASEQ_INORDER_EN)
1135         SETUP_SESSION_RD_ATTR(erl, ISCSI_PARAM_ERL);
1136
1137         BUG_ON(count > ISCSI_SESSION_ATTRS);
1138         priv->session_attrs[count] = NULL;
1139
1140         spin_lock_irqsave(&iscsi_transport_lock, flags);
1141         list_add(&priv->list, &iscsi_transports);
1142         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
1143
1144         printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
1145         return 0;
1146
1147 unregister_cdev:
1148         class_device_unregister(&priv->cdev);
1149 free_priv:
1150         kfree(priv);
1151         return err;
1152 }
1153 EXPORT_SYMBOL_GPL(iscsi_register_transport);
1154
1155 int iscsi_unregister_transport(struct iscsi_transport *tt)
1156 {
1157         struct iscsi_internal *priv;
1158         unsigned long flags;
1159
1160         BUG_ON(!tt);
1161
1162         down(&rx_queue_sema);
1163
1164         priv = iscsi_if_transport_lookup(tt);
1165         BUG_ON (!priv);
1166
1167         spin_lock_irqsave(&priv->session_lock, flags);
1168         if (!list_empty(&priv->sessions)) {
1169                 spin_unlock_irqrestore(&priv->session_lock, flags);
1170                 up(&rx_queue_sema);
1171                 return -EPERM;
1172         }
1173         spin_unlock_irqrestore(&priv->session_lock, flags);
1174
1175         spin_lock_irqsave(&iscsi_transport_lock, flags);
1176         list_del(&priv->list);
1177         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
1178
1179         transport_container_unregister(&priv->conn_cont);
1180         transport_container_unregister(&priv->session_cont);
1181
1182         sysfs_remove_group(&priv->cdev.kobj, &iscsi_transport_group);
1183         class_device_unregister(&priv->cdev);
1184         up(&rx_queue_sema);
1185
1186         return 0;
1187 }
1188 EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
1189
1190 static int
1191 iscsi_rcv_nl_event(struct notifier_block *this, unsigned long event, void *ptr)
1192 {
1193         struct netlink_notify *n = ptr;
1194
1195         if (event == NETLINK_URELEASE &&
1196             n->protocol == NETLINK_ISCSI && n->pid) {
1197                 struct iscsi_if_conn *conn;
1198                 unsigned long flags;
1199
1200                 mempool_zone_complete(&z_reply);
1201                 spin_lock_irqsave(&connlock, flags);
1202                 list_for_each_entry(conn, &connlist, conn_list) {
1203                         mempool_zone_complete(&conn->z_error);
1204                         mempool_zone_complete(&conn->z_pdu);
1205                 }
1206                 spin_unlock_irqrestore(&connlock, flags);
1207         }
1208
1209         return NOTIFY_DONE;
1210 }
1211
1212 static struct notifier_block iscsi_nl_notifier = {
1213         .notifier_call  = iscsi_rcv_nl_event,
1214 };
1215
1216 static __init int iscsi_transport_init(void)
1217 {
1218         int err;
1219
1220         err = class_register(&iscsi_transport_class);
1221         if (err)
1222                 return err;
1223
1224         err = transport_class_register(&iscsi_connection_class);
1225         if (err)
1226                 goto unregister_transport_class;
1227
1228         err = transport_class_register(&iscsi_session_class);
1229         if (err)
1230                 goto unregister_conn_class;
1231
1232         err = netlink_register_notifier(&iscsi_nl_notifier);
1233         if (err)
1234                 goto unregister_session_class;
1235
1236         nls = netlink_kernel_create(NETLINK_ISCSI, 1, iscsi_if_rx,
1237                                     THIS_MODULE);
1238         if (!nls) {
1239                 err = -ENOBUFS;
1240                 goto unregister_notifier;
1241         }
1242
1243         err = mempool_zone_init(&z_reply, Z_MAX_REPLY,
1244                 NLMSG_SPACE(sizeof(struct iscsi_uevent)), Z_HIWAT_REPLY);
1245         if (!err)
1246                 return 0;
1247
1248         sock_release(nls->sk_socket);
1249 unregister_notifier:
1250         netlink_unregister_notifier(&iscsi_nl_notifier);
1251 unregister_session_class:
1252         transport_class_unregister(&iscsi_session_class);
1253 unregister_conn_class:
1254         transport_class_unregister(&iscsi_connection_class);
1255 unregister_transport_class:
1256         class_unregister(&iscsi_transport_class);
1257         return err;
1258 }
1259
1260 static void __exit iscsi_transport_exit(void)
1261 {
1262         mempool_destroy(z_reply.pool);
1263         sock_release(nls->sk_socket);
1264         netlink_unregister_notifier(&iscsi_nl_notifier);
1265         transport_class_unregister(&iscsi_connection_class);
1266         transport_class_unregister(&iscsi_session_class);
1267         class_unregister(&iscsi_transport_class);
1268 }
1269
1270 module_init(iscsi_transport_init);
1271 module_exit(iscsi_transport_exit);
1272
1273 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
1274               "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
1275               "Alex Aizman <itn780@yahoo.com>");
1276 MODULE_DESCRIPTION("iSCSI Transport Interface");
1277 MODULE_LICENSE("GPL");