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