drivers/scsi/scsi_transport_iscsi.c

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