drivers/scsi/scsi_transport_iscsi.c

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