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