Pileus Git - ~andy/linux/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/mutex.h>
  25 #include <linux/slab.h>
  26 #include <linux/bsg-lib.h>
  27 #include <net/tcp.h>
  28 #include <scsi/scsi.h>
  29 #include <scsi/scsi_host.h>
  30 #include <scsi/scsi_device.h>
  31 #include <scsi/scsi_transport.h>
  32 #include <scsi/scsi_transport_iscsi.h>
  33 #include <scsi/iscsi_if.h>
  34 #include <scsi/scsi_cmnd.h>
  35 #include <scsi/scsi_bsg_iscsi.h>
  36
  37 #define ISCSI_TRANSPORT_VERSION "2.0-870"
  38
  39 static int dbg_session;
  40 module_param_named(debug_session, dbg_session, int,
  41                    S_IRUGO | S_IWUSR);
  42 MODULE_PARM_DESC(debug_session,
  43                  "Turn on debugging for sessions in scsi_transport_iscsi "
  44                  "module. Set to 1 to turn on, and zero to turn off. Default "
  45                  "is off.");
  46
  47 static int dbg_conn;
  48 module_param_named(debug_conn, dbg_conn, int,
  49                    S_IRUGO | S_IWUSR);
  50 MODULE_PARM_DESC(debug_conn,
  51                  "Turn on debugging for connections in scsi_transport_iscsi "
  52                  "module. Set to 1 to turn on, and zero to turn off. Default "
  53                  "is off.");
  54
  55 #define ISCSI_DBG_TRANS_SESSION(_session, dbg_fmt, arg...)              \
  56         do {                                                            \
  57                 if (dbg_session)                                        \
  58                         iscsi_cls_session_printk(KERN_INFO, _session,   \
  59                                                  "%s: " dbg_fmt,        \
  60                                                  __func__, ##arg);      \
  61         } while (0);
  62
  63 #define ISCSI_DBG_TRANS_CONN(_conn, dbg_fmt, arg...)                    \
  64         do {                                                            \
  65                 if (dbg_conn)                                           \
  66                         iscsi_cls_conn_printk(KERN_INFO, _conn,         \
  67                                               "%s: " dbg_fmt,           \
  68                                               __func__, ##arg); \
  69         } while (0);
  70
  71 struct iscsi_internal {
  72         struct scsi_transport_template t;
  73         struct iscsi_transport *iscsi_transport;
  74         struct list_head list;
  75         struct device dev;
  76
  77         struct transport_container conn_cont;
  78         struct transport_container session_cont;
  79 };
  80
  81 static atomic_t iscsi_session_nr; /* sysfs session id for next new session */
  82 static struct workqueue_struct *iscsi_eh_timer_workq;
  83
  84 /*
  85  * list of registered transports and lock that must
  86  * be held while accessing list. The iscsi_transport_lock must
  87  * be acquired after the rx_queue_mutex.
  88  */
  89 static LIST_HEAD(iscsi_transports);
  90 static DEFINE_SPINLOCK(iscsi_transport_lock);
  91
  92 #define to_iscsi_internal(tmpl) \
  93         container_of(tmpl, struct iscsi_internal, t)
  94
  95 #define dev_to_iscsi_internal(_dev) \
  96         container_of(_dev, struct iscsi_internal, dev)
  97
  98 static void iscsi_transport_release(struct device *dev)
  99 {
 100         struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
 101         kfree(priv);
 102 }
 103
 104 /*
 105  * iscsi_transport_class represents the iscsi_transports that are
 106  * registered.
 107  */
 108 static struct class iscsi_transport_class = {
 109         .name = "iscsi_transport",
 110         .dev_release = iscsi_transport_release,
 111 };
 112
 113 static ssize_t
 114 show_transport_handle(struct device *dev, struct device_attribute *attr,
 115                       char *buf)
 116 {
 117         struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
 118         return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
 119 }
 120 static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
 121
 122 #define show_transport_attr(name, format)                               \
 123 static ssize_t                                                          \
 124 show_transport_##name(struct device *dev,                               \
 125                       struct device_attribute *attr,char *buf)          \
 126 {                                                                       \
 127         struct iscsi_internal *priv = dev_to_iscsi_internal(dev);       \
 128         return sprintf(buf, format"\n", priv->iscsi_transport->name);   \
 129 }                                                                       \
 130 static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
 131
 132 show_transport_attr(caps, "0x%x");
 133
 134 static struct attribute *iscsi_transport_attrs[] = {
 135         &dev_attr_handle.attr,
 136         &dev_attr_caps.attr,
 137         NULL,
 138 };
 139
 140 static struct attribute_group iscsi_transport_group = {
 141         .attrs = iscsi_transport_attrs,
 142 };
 143
 144 /*
 145  * iSCSI endpoint attrs
 146  */
 147 #define iscsi_dev_to_endpoint(_dev) \
 148         container_of(_dev, struct iscsi_endpoint, dev)
 149
 150 #define ISCSI_ATTR(_prefix,_name,_mode,_show,_store)    \
 151 struct device_attribute dev_attr_##_prefix##_##_name =  \
 152         __ATTR(_name,_mode,_show,_store)
 153
 154 static void iscsi_endpoint_release(struct device *dev)
 155 {
 156         struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
 157         kfree(ep);
 158 }
 159
 160 static struct class iscsi_endpoint_class = {
 161         .name = "iscsi_endpoint",
 162         .dev_release = iscsi_endpoint_release,
 163 };
 164
 165 static ssize_t
 166 show_ep_handle(struct device *dev, struct device_attribute *attr, char *buf)
 167 {
 168         struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
 169         return sprintf(buf, "%llu\n", (unsigned long long) ep->id);
 170 }
 171 static ISCSI_ATTR(ep, handle, S_IRUGO, show_ep_handle, NULL);
 172
 173 static struct attribute *iscsi_endpoint_attrs[] = {
 174         &dev_attr_ep_handle.attr,
 175         NULL,
 176 };
 177
 178 static struct attribute_group iscsi_endpoint_group = {
 179         .attrs = iscsi_endpoint_attrs,
 180 };
 181
 182 #define ISCSI_MAX_EPID -1
 183
 184 static int iscsi_match_epid(struct device *dev, void *data)
 185 {
 186         struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
 187         uint64_t *epid = (uint64_t *) data;
 188
 189         return *epid == ep->id;
 190 }
 191
 192 struct iscsi_endpoint *
 193 iscsi_create_endpoint(int dd_size)
 194 {
 195         struct device *dev;
 196         struct iscsi_endpoint *ep;
 197         uint64_t id;
 198         int err;
 199
 200         for (id = 1; id < ISCSI_MAX_EPID; id++) {
 201                 dev = class_find_device(&iscsi_endpoint_class, NULL, &id,
 202                                         iscsi_match_epid);
 203                 if (!dev)
 204                         break;
 205         }
 206         if (id == ISCSI_MAX_EPID) {
 207                 printk(KERN_ERR "Too many connections. Max supported %u\n",
 208                        ISCSI_MAX_EPID - 1);
 209                 return NULL;
 210         }
 211
 212         ep = kzalloc(sizeof(*ep) + dd_size, GFP_KERNEL);
 213         if (!ep)
 214                 return NULL;
 215
 216         ep->id = id;
 217         ep->dev.class = &iscsi_endpoint_class;
 218         dev_set_name(&ep->dev, "ep-%llu", (unsigned long long) id);
 219         err = device_register(&ep->dev);
 220         if (err)
 221                 goto free_ep;
 222
 223         err = sysfs_create_group(&ep->dev.kobj, &iscsi_endpoint_group);
 224         if (err)
 225                 goto unregister_dev;
 226
 227         if (dd_size)
 228                 ep->dd_data = &ep[1];
 229         return ep;
 230
 231 unregister_dev:
 232         device_unregister(&ep->dev);
 233         return NULL;
 234
 235 free_ep:
 236         kfree(ep);
 237         return NULL;
 238 }
 239 EXPORT_SYMBOL_GPL(iscsi_create_endpoint);
 240
 241 void iscsi_destroy_endpoint(struct iscsi_endpoint *ep)
 242 {
 243         sysfs_remove_group(&ep->dev.kobj, &iscsi_endpoint_group);
 244         device_unregister(&ep->dev);
 245 }
 246 EXPORT_SYMBOL_GPL(iscsi_destroy_endpoint);
 247
 248 struct iscsi_endpoint *iscsi_lookup_endpoint(u64 handle)
 249 {
 250         struct iscsi_endpoint *ep;
 251         struct device *dev;
 252
 253         dev = class_find_device(&iscsi_endpoint_class, NULL, &handle,
 254                                 iscsi_match_epid);
 255         if (!dev)
 256                 return NULL;
 257
 258         ep = iscsi_dev_to_endpoint(dev);
 259         /*
 260          * we can drop this now because the interface will prevent
 261          * removals and lookups from racing.
 262          */
 263         put_device(dev);
 264         return ep;
 265 }
 266 EXPORT_SYMBOL_GPL(iscsi_lookup_endpoint);
 267
 268 /*
 269  * Interface to display network param to sysfs
 270  */
 271
 272 static void iscsi_iface_release(struct device *dev)
 273 {
 274         struct iscsi_iface *iface = iscsi_dev_to_iface(dev);
 275         struct device *parent = iface->dev.parent;
 276
 277         kfree(iface);
 278         put_device(parent);
 279 }
 280
 281
 282 static struct class iscsi_iface_class = {
 283         .name = "iscsi_iface",
 284         .dev_release = iscsi_iface_release,
 285 };
 286
 287 #define ISCSI_IFACE_ATTR(_prefix, _name, _mode, _show, _store)  \
 288 struct device_attribute dev_attr_##_prefix##_##_name =          \
 289         __ATTR(_name, _mode, _show, _store)
 290
 291 /* iface attrs show */
 292 #define iscsi_iface_attr_show(type, name, param_type, param)            \
 293 static ssize_t                                                          \
 294 show_##type##_##name(struct device *dev, struct device_attribute *attr, \
 295                      char *buf)                                         \
 296 {                                                                       \
 297         struct iscsi_iface *iface = iscsi_dev_to_iface(dev);            \
 298         struct iscsi_transport *t = iface->transport;                   \
 299         return t->get_iface_param(iface, param_type, param, buf);       \
 300 }                                                                       \
 301
 302 #define iscsi_iface_net_attr(type, name, param)                         \
 303         iscsi_iface_attr_show(type, name, ISCSI_NET_PARAM, param)       \
 304 static ISCSI_IFACE_ATTR(type, name, S_IRUGO, show_##type##_##name, NULL);
 305
 306 /* generic read only ipvi4 attribute */
 307 iscsi_iface_net_attr(ipv4_iface, ipaddress, ISCSI_NET_PARAM_IPV4_ADDR);
 308 iscsi_iface_net_attr(ipv4_iface, gateway, ISCSI_NET_PARAM_IPV4_GW);
 309 iscsi_iface_net_attr(ipv4_iface, subnet, ISCSI_NET_PARAM_IPV4_SUBNET);
 310 iscsi_iface_net_attr(ipv4_iface, bootproto, ISCSI_NET_PARAM_IPV4_BOOTPROTO);
 311
 312 /* generic read only ipv6 attribute */
 313 iscsi_iface_net_attr(ipv6_iface, ipaddress, ISCSI_NET_PARAM_IPV6_ADDR);
 314 iscsi_iface_net_attr(ipv6_iface, link_local_addr, ISCSI_NET_PARAM_IPV6_LINKLOCAL);
 315 iscsi_iface_net_attr(ipv6_iface, router_addr, ISCSI_NET_PARAM_IPV6_ROUTER);
 316 iscsi_iface_net_attr(ipv6_iface, ipaddr_autocfg,
 317                      ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG);
 318 iscsi_iface_net_attr(ipv6_iface, linklocal_autocfg,
 319                      ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG);
 320
 321 /* common read only iface attribute */
 322 iscsi_iface_net_attr(iface, enabled, ISCSI_NET_PARAM_IFACE_ENABLE);
 323 iscsi_iface_net_attr(iface, vlan, ISCSI_NET_PARAM_VLAN_ID);
 324 iscsi_iface_net_attr(iface, vlan_priority, ISCSI_NET_PARAM_VLAN_PRIORITY);
 325 iscsi_iface_net_attr(iface, vlan_enabled, ISCSI_NET_PARAM_VLAN_ENABLED);
 326
 327 static mode_t iscsi_iface_attr_is_visible(struct kobject *kobj,
 328                                           struct attribute *attr, int i)
 329 {
 330         struct device *dev = container_of(kobj, struct device, kobj);
 331         struct iscsi_iface *iface = iscsi_dev_to_iface(dev);
 332         struct iscsi_transport *t = iface->transport;
 333         int param;
 334
 335         if (attr == &dev_attr_iface_enabled.attr)
 336                 param = ISCSI_NET_PARAM_IFACE_ENABLE;
 337         else if (attr == &dev_attr_iface_vlan.attr)
 338                 param = ISCSI_NET_PARAM_VLAN_ID;
 339         else if (attr == &dev_attr_iface_vlan_priority.attr)
 340                 param = ISCSI_NET_PARAM_VLAN_PRIORITY;
 341         else if (attr == &dev_attr_iface_vlan_enabled.attr)
 342                 param = ISCSI_NET_PARAM_VLAN_ENABLED;
 343         else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV4) {
 344                 if (attr == &dev_attr_ipv4_iface_ipaddress.attr)
 345                         param = ISCSI_NET_PARAM_IPV4_ADDR;
 346                 else if (attr == &dev_attr_ipv4_iface_gateway.attr)
 347                         param = ISCSI_NET_PARAM_IPV4_GW;
 348                 else if (attr == &dev_attr_ipv4_iface_subnet.attr)
 349                         param = ISCSI_NET_PARAM_IPV4_SUBNET;
 350                 else if (attr == &dev_attr_ipv4_iface_bootproto.attr)
 351                         param = ISCSI_NET_PARAM_IPV4_BOOTPROTO;
 352                 else
 353                         return 0;
 354         } else if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6) {
 355                 if (attr == &dev_attr_ipv6_iface_ipaddress.attr)
 356                         param = ISCSI_NET_PARAM_IPV6_ADDR;
 357                 else if (attr == &dev_attr_ipv6_iface_link_local_addr.attr)
 358                         param = ISCSI_NET_PARAM_IPV6_LINKLOCAL;
 359                 else if (attr == &dev_attr_ipv6_iface_router_addr.attr)
 360                         param = ISCSI_NET_PARAM_IPV6_ROUTER;
 361                 else if (attr == &dev_attr_ipv6_iface_ipaddr_autocfg.attr)
 362                         param = ISCSI_NET_PARAM_IPV6_ADDR_AUTOCFG;
 363                 else if (attr == &dev_attr_ipv6_iface_linklocal_autocfg.attr)
 364                         param = ISCSI_NET_PARAM_IPV6_LINKLOCAL_AUTOCFG;
 365                 else
 366                         return 0;
 367         } else {
 368                 WARN_ONCE(1, "Invalid iface attr");
 369                 return 0;
 370         }
 371
 372         return t->attr_is_visible(ISCSI_NET_PARAM, param);
 373 }
 374
 375 static struct attribute *iscsi_iface_attrs[] = {
 376         &dev_attr_iface_enabled.attr,
 377         &dev_attr_iface_vlan.attr,
 378         &dev_attr_iface_vlan_priority.attr,
 379         &dev_attr_iface_vlan_enabled.attr,
 380         &dev_attr_ipv4_iface_ipaddress.attr,
 381         &dev_attr_ipv4_iface_gateway.attr,
 382         &dev_attr_ipv4_iface_subnet.attr,
 383         &dev_attr_ipv4_iface_bootproto.attr,
 384         &dev_attr_ipv6_iface_ipaddress.attr,
 385         &dev_attr_ipv6_iface_link_local_addr.attr,
 386         &dev_attr_ipv6_iface_router_addr.attr,
 387         &dev_attr_ipv6_iface_ipaddr_autocfg.attr,
 388         &dev_attr_ipv6_iface_linklocal_autocfg.attr,
 389         NULL,
 390 };
 391
 392 static struct attribute_group iscsi_iface_group = {
 393         .attrs = iscsi_iface_attrs,
 394         .is_visible = iscsi_iface_attr_is_visible,
 395 };
 396
 397 struct iscsi_iface *
 398 iscsi_create_iface(struct Scsi_Host *shost, struct iscsi_transport *transport,
 399                    uint32_t iface_type, uint32_t iface_num, int dd_size)
 400 {
 401         struct iscsi_iface *iface;
 402         int err;
 403
 404         iface = kzalloc(sizeof(*iface) + dd_size, GFP_KERNEL);
 405         if (!iface)
 406                 return NULL;
 407
 408         iface->transport = transport;
 409         iface->iface_type = iface_type;
 410         iface->iface_num = iface_num;
 411         iface->dev.release = iscsi_iface_release;
 412         iface->dev.class = &iscsi_iface_class;
 413         /* parent reference released in iscsi_iface_release */
 414         iface->dev.parent = get_device(&shost->shost_gendev);
 415         if (iface_type == ISCSI_IFACE_TYPE_IPV4)
 416                 dev_set_name(&iface->dev, "ipv4-iface-%u-%u", shost->host_no,
 417                              iface_num);
 418         else
 419                 dev_set_name(&iface->dev, "ipv6-iface-%u-%u", shost->host_no,
 420                              iface_num);
 421
 422         err = device_register(&iface->dev);
 423         if (err)
 424                 goto free_iface;
 425
 426         err = sysfs_create_group(&iface->dev.kobj, &iscsi_iface_group);
 427         if (err)
 428                 goto unreg_iface;
 429
 430         if (dd_size)
 431                 iface->dd_data = &iface[1];
 432         return iface;
 433
 434 unreg_iface:
 435         device_unregister(&iface->dev);
 436         return NULL;
 437
 438 free_iface:
 439         put_device(iface->dev.parent);
 440         kfree(iface);
 441         return NULL;
 442 }
 443 EXPORT_SYMBOL_GPL(iscsi_create_iface);
 444
 445 void iscsi_destroy_iface(struct iscsi_iface *iface)
 446 {
 447         sysfs_remove_group(&iface->dev.kobj, &iscsi_iface_group);
 448         device_unregister(&iface->dev);
 449 }
 450 EXPORT_SYMBOL_GPL(iscsi_destroy_iface);
 451
 452 /*
 453  * BSG support
 454  */
 455 /**
 456  * iscsi_bsg_host_dispatch - Dispatch command to LLD.
 457  * @job: bsg job to be processed
 458  */
 459 static int iscsi_bsg_host_dispatch(struct bsg_job *job)
 460 {
 461         struct Scsi_Host *shost = iscsi_job_to_shost(job);
 462         struct iscsi_bsg_request *req = job->request;
 463         struct iscsi_bsg_reply *reply = job->reply;
 464         struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
 465         int cmdlen = sizeof(uint32_t);  /* start with length of msgcode */
 466         int ret;
 467
 468         /* check if we have the msgcode value at least */
 469         if (job->request_len < sizeof(uint32_t)) {
 470                 ret = -ENOMSG;
 471                 goto fail_host_msg;
 472         }
 473
 474         /* Validate the host command */
 475         switch (req->msgcode) {
 476         case ISCSI_BSG_HST_VENDOR:
 477                 cmdlen += sizeof(struct iscsi_bsg_host_vendor);
 478                 if ((shost->hostt->vendor_id == 0L) ||
 479                     (req->rqst_data.h_vendor.vendor_id !=
 480                         shost->hostt->vendor_id)) {
 481                         ret = -ESRCH;
 482                         goto fail_host_msg;
 483                 }
 484                 break;
 485         default:
 486                 ret = -EBADR;
 487                 goto fail_host_msg;
 488         }
 489
 490         /* check if we really have all the request data needed */
 491         if (job->request_len < cmdlen) {
 492                 ret = -ENOMSG;
 493                 goto fail_host_msg;
 494         }
 495
 496         ret = i->iscsi_transport->bsg_request(job);
 497         if (!ret)
 498                 return 0;
 499
 500 fail_host_msg:
 501         /* return the errno failure code as the only status */
 502         BUG_ON(job->reply_len < sizeof(uint32_t));
 503         reply->reply_payload_rcv_len = 0;
 504         reply->result = ret;
 505         job->reply_len = sizeof(uint32_t);
 506         bsg_job_done(job, ret, 0);
 507         return 0;
 508 }
 509
 510 /**
 511  * iscsi_bsg_host_add - Create and add the bsg hooks to receive requests
 512  * @shost: shost for iscsi_host
 513  * @cls_host: iscsi_cls_host adding the structures to
 514  */
 515 static int
 516 iscsi_bsg_host_add(struct Scsi_Host *shost, struct iscsi_cls_host *ihost)
 517 {
 518         struct device *dev = &shost->shost_gendev;
 519         struct iscsi_internal *i = to_iscsi_internal(shost->transportt);
 520         struct request_queue *q;
 521         char bsg_name[20];
 522         int ret;
 523
 524         if (!i->iscsi_transport->bsg_request)
 525                 return -ENOTSUPP;
 526
 527         snprintf(bsg_name, sizeof(bsg_name), "iscsi_host%d", shost->host_no);
 528
 529         q = __scsi_alloc_queue(shost, bsg_request_fn);
 530         if (!q)
 531                 return -ENOMEM;
 532
 533         ret = bsg_setup_queue(dev, q, bsg_name, iscsi_bsg_host_dispatch, 0);
 534         if (ret) {
 535                 shost_printk(KERN_ERR, shost, "bsg interface failed to "
 536                              "initialize - no request queue\n");
 537                 blk_cleanup_queue(q);
 538                 return ret;
 539         }
 540
 541         ihost->bsg_q = q;
 542         return 0;
 543 }
 544
 545 static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
 546                             struct device *cdev)
 547 {
 548         struct Scsi_Host *shost = dev_to_shost(dev);
 549         struct iscsi_cls_host *ihost = shost->shost_data;
 550
 551         memset(ihost, 0, sizeof(*ihost));
 552         atomic_set(&ihost->nr_scans, 0);
 553         mutex_init(&ihost->mutex);
 554
 555         iscsi_bsg_host_add(shost, ihost);
 556         /* ignore any bsg add error - we just can't do sgio */
 557
 558         return 0;
 559 }
 560
 561 static int iscsi_remove_host(struct transport_container *tc,
 562                              struct device *dev, struct device *cdev)
 563 {
 564         struct Scsi_Host *shost = dev_to_shost(dev);
 565         struct iscsi_cls_host *ihost = shost->shost_data;
 566
 567         if (ihost->bsg_q) {
 568                 bsg_remove_queue(ihost->bsg_q);
 569                 blk_cleanup_queue(ihost->bsg_q);
 570         }
 571         return 0;
 572 }
 573
 574 static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
 575                                "iscsi_host",
 576                                iscsi_setup_host,
 577                                iscsi_remove_host,
 578                                NULL);
 579
 580 static DECLARE_TRANSPORT_CLASS(iscsi_session_class,
 581                                "iscsi_session",
 582                                NULL,
 583                                NULL,
 584                                NULL);
 585
 586 static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
 587                                "iscsi_connection",
 588                                NULL,
 589                                NULL,
 590                                NULL);
 591
 592 static struct sock *nls;
 593 static DEFINE_MUTEX(rx_queue_mutex);
 594
 595 static LIST_HEAD(sesslist);
 596 static DEFINE_SPINLOCK(sesslock);
 597 static LIST_HEAD(connlist);
 598 static DEFINE_SPINLOCK(connlock);
 599
 600 static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn *conn)
 601 {
 602         struct iscsi_cls_session *sess = iscsi_dev_to_session(conn->dev.parent);
 603         return sess->sid;
 604 }
 605
 606 /*
 607  * Returns the matching session to a given sid
 608  */
 609 static struct iscsi_cls_session *iscsi_session_lookup(uint32_t sid)
 610 {
 611         unsigned long flags;
 612         struct iscsi_cls_session *sess;
 613
 614         spin_lock_irqsave(&sesslock, flags);
 615         list_for_each_entry(sess, &sesslist, sess_list) {
 616                 if (sess->sid == sid) {
 617                         spin_unlock_irqrestore(&sesslock, flags);
 618                         return sess;
 619                 }
 620         }
 621         spin_unlock_irqrestore(&sesslock, flags);
 622         return NULL;
 623 }
 624
 625 /*
 626  * Returns the matching connection to a given sid / cid tuple
 627  */
 628 static struct iscsi_cls_conn *iscsi_conn_lookup(uint32_t sid, uint32_t cid)
 629 {
 630         unsigned long flags;
 631         struct iscsi_cls_conn *conn;
 632
 633         spin_lock_irqsave(&connlock, flags);
 634         list_for_each_entry(conn, &connlist, conn_list) {
 635                 if ((conn->cid == cid) && (iscsi_conn_get_sid(conn) == sid)) {
 636                         spin_unlock_irqrestore(&connlock, flags);
 637                         return conn;
 638                 }
 639         }
 640         spin_unlock_irqrestore(&connlock, flags);
 641         return NULL;
 642 }
 643
 644 /*
 645  * The following functions can be used by LLDs that allocate
 646  * their own scsi_hosts or by software iscsi LLDs
 647  */
 648 static struct {
 649         int value;
 650         char *name;
 651 } iscsi_session_state_names[] = {
 652         { ISCSI_SESSION_LOGGED_IN,      "LOGGED_IN" },
 653         { ISCSI_SESSION_FAILED,         "FAILED" },
 654         { ISCSI_SESSION_FREE,           "FREE" },
 655 };
 656
 657 static const char *iscsi_session_state_name(int state)
 658 {
 659         int i;
 660         char *name = NULL;
 661
 662         for (i = 0; i < ARRAY_SIZE(iscsi_session_state_names); i++) {
 663                 if (iscsi_session_state_names[i].value == state) {
 664                         name = iscsi_session_state_names[i].name;
 665                         break;
 666                 }
 667         }
 668         return name;
 669 }
 670
 671 int iscsi_session_chkready(struct iscsi_cls_session *session)
 672 {
 673         unsigned long flags;
 674         int err;
 675
 676         spin_lock_irqsave(&session->lock, flags);
 677         switch (session->state) {
 678         case ISCSI_SESSION_LOGGED_IN:
 679                 err = 0;
 680                 break;
 681         case ISCSI_SESSION_FAILED:
 682                 err = DID_IMM_RETRY << 16;
 683                 break;
 684         case ISCSI_SESSION_FREE:
 685                 err = DID_TRANSPORT_FAILFAST << 16;
 686                 break;
 687         default:
 688                 err = DID_NO_CONNECT << 16;
 689                 break;
 690         }
 691         spin_unlock_irqrestore(&session->lock, flags);
 692         return err;
 693 }
 694 EXPORT_SYMBOL_GPL(iscsi_session_chkready);
 695
 696 int iscsi_is_session_online(struct iscsi_cls_session *session)
 697 {
 698         unsigned long flags;
 699         int ret = 0;
 700
 701         spin_lock_irqsave(&session->lock, flags);
 702         if (session->state == ISCSI_SESSION_LOGGED_IN)
 703                 ret = 1;
 704         spin_unlock_irqrestore(&session->lock, flags);
 705         return ret;
 706 }
 707 EXPORT_SYMBOL_GPL(iscsi_is_session_online);
 708
 709 static void iscsi_session_release(struct device *dev)
 710 {
 711         struct iscsi_cls_session *session = iscsi_dev_to_session(dev);
 712         struct Scsi_Host *shost;
 713
 714         shost = iscsi_session_to_shost(session);
 715         scsi_host_put(shost);
 716         ISCSI_DBG_TRANS_SESSION(session, "Completing session release\n");
 717         kfree(session);
 718 }
 719
 720 static int iscsi_is_session_dev(const struct device *dev)
 721 {
 722         return dev->release == iscsi_session_release;
 723 }
 724
 725 static int iscsi_iter_session_fn(struct device *dev, void *data)
 726 {
 727         void (* fn) (struct iscsi_cls_session *) = data;
 728
 729         if (!iscsi_is_session_dev(dev))
 730                 return 0;
 731         fn(iscsi_dev_to_session(dev));
 732         return 0;
 733 }
 734
 735 void iscsi_host_for_each_session(struct Scsi_Host *shost,
 736                                  void (*fn)(struct iscsi_cls_session *))
 737 {
 738         device_for_each_child(&shost->shost_gendev, fn,
 739                               iscsi_iter_session_fn);
 740 }
 741 EXPORT_SYMBOL_GPL(iscsi_host_for_each_session);
 742
 743 /**
 744  * iscsi_scan_finished - helper to report when running scans are done
 745  * @shost: scsi host
 746  * @time: scan run time
 747  *
 748  * This function can be used by drives like qla4xxx to report to the scsi
 749  * layer when the scans it kicked off at module load time are done.
 750  */
 751 int iscsi_scan_finished(struct Scsi_Host *shost, unsigned long time)
 752 {
 753         struct iscsi_cls_host *ihost = shost->shost_data;
 754         /*
 755          * qla4xxx will have kicked off some session unblocks before calling
 756          * scsi_scan_host, so just wait for them to complete.
 757          */
 758         return !atomic_read(&ihost->nr_scans);
 759 }
 760 EXPORT_SYMBOL_GPL(iscsi_scan_finished);
 761
 762 struct iscsi_scan_data {
 763         unsigned int channel;
 764         unsigned int id;
 765         unsigned int lun;
 766 };
 767
 768 static int iscsi_user_scan_session(struct device *dev, void *data)
 769 {
 770         struct iscsi_scan_data *scan_data = data;
 771         struct iscsi_cls_session *session;
 772         struct Scsi_Host *shost;
 773         struct iscsi_cls_host *ihost;
 774         unsigned long flags;
 775         unsigned int id;
 776
 777         if (!iscsi_is_session_dev(dev))
 778                 return 0;
 779
 780         session = iscsi_dev_to_session(dev);
 781
 782         ISCSI_DBG_TRANS_SESSION(session, "Scanning session\n");
 783
 784         shost = iscsi_session_to_shost(session);
 785         ihost = shost->shost_data;
 786
 787         mutex_lock(&ihost->mutex);
 788         spin_lock_irqsave(&session->lock, flags);
 789         if (session->state != ISCSI_SESSION_LOGGED_IN) {
 790                 spin_unlock_irqrestore(&session->lock, flags);
 791                 goto user_scan_exit;
 792         }
 793         id = session->target_id;
 794         spin_unlock_irqrestore(&session->lock, flags);
 795
 796         if (id != ISCSI_MAX_TARGET) {
 797                 if ((scan_data->channel == SCAN_WILD_CARD ||
 798                      scan_data->channel == 0) &&
 799                     (scan_data->id == SCAN_WILD_CARD ||
 800                      scan_data->id == id))
 801                         scsi_scan_target(&session->dev, 0, id,
 802                                          scan_data->lun, 1);
 803         }
 804
 805 user_scan_exit:
 806         mutex_unlock(&ihost->mutex);
 807         ISCSI_DBG_TRANS_SESSION(session, "Completed session scan\n");
 808         return 0;
 809 }
 810
 811 static int iscsi_user_scan(struct Scsi_Host *shost, uint channel,
 812                            uint id, uint lun)
 813 {
 814         struct iscsi_scan_data scan_data;
 815
 816         scan_data.channel = channel;
 817         scan_data.id = id;
 818         scan_data.lun = lun;
 819
 820         return device_for_each_child(&shost->shost_gendev, &scan_data,
 821                                      iscsi_user_scan_session);
 822 }
 823
 824 static void iscsi_scan_session(struct work_struct *work)
 825 {
 826         struct iscsi_cls_session *session =
 827                         container_of(work, struct iscsi_cls_session, scan_work);
 828         struct Scsi_Host *shost = iscsi_session_to_shost(session);
 829         struct iscsi_cls_host *ihost = shost->shost_data;
 830         struct iscsi_scan_data scan_data;
 831
 832         scan_data.channel = 0;
 833         scan_data.id = SCAN_WILD_CARD;
 834         scan_data.lun = SCAN_WILD_CARD;
 835
 836         iscsi_user_scan_session(&session->dev, &scan_data);
 837         atomic_dec(&ihost->nr_scans);
 838 }
 839
 840 /**
 841  * iscsi_block_scsi_eh - block scsi eh until session state has transistioned
 842  * @cmd: scsi cmd passed to scsi eh handler
 843  *
 844  * If the session is down this function will wait for the recovery
 845  * timer to fire or for the session to be logged back in. If the
 846  * recovery timer fires then FAST_IO_FAIL is returned. The caller
 847  * should pass this error value to the scsi eh.
 848  */
 849 int iscsi_block_scsi_eh(struct scsi_cmnd *cmd)
 850 {
 851         struct iscsi_cls_session *session =
 852                         starget_to_session(scsi_target(cmd->device));
 853         unsigned long flags;
 854         int ret = 0;
 855
 856         spin_lock_irqsave(&session->lock, flags);
 857         while (session->state != ISCSI_SESSION_LOGGED_IN) {
 858                 if (session->state == ISCSI_SESSION_FREE) {
 859                         ret = FAST_IO_FAIL;
 860                         break;
 861                 }
 862                 spin_unlock_irqrestore(&session->lock, flags);
 863                 msleep(1000);
 864                 spin_lock_irqsave(&session->lock, flags);
 865         }
 866         spin_unlock_irqrestore(&session->lock, flags);
 867         return ret;
 868 }
 869 EXPORT_SYMBOL_GPL(iscsi_block_scsi_eh);
 870
 871 static void session_recovery_timedout(struct work_struct *work)
 872 {
 873         struct iscsi_cls_session *session =
 874                 container_of(work, struct iscsi_cls_session,
 875                              recovery_work.work);
 876         unsigned long flags;
 877
 878         iscsi_cls_session_printk(KERN_INFO, session,
 879                                  "session recovery timed out after %d secs\n",
 880                                  session->recovery_tmo);
 881
 882         spin_lock_irqsave(&session->lock, flags);
 883         switch (session->state) {
 884         case ISCSI_SESSION_FAILED:
 885                 session->state = ISCSI_SESSION_FREE;
 886                 break;
 887         case ISCSI_SESSION_LOGGED_IN:
 888         case ISCSI_SESSION_FREE:
 889                 /* we raced with the unblock's flush */
 890                 spin_unlock_irqrestore(&session->lock, flags);
 891                 return;
 892         }
 893         spin_unlock_irqrestore(&session->lock, flags);
 894
 895         if (session->transport->session_recovery_timedout)
 896                 session->transport->session_recovery_timedout(session);
 897
 898         ISCSI_DBG_TRANS_SESSION(session, "Unblocking SCSI target\n");
 899         scsi_target_unblock(&session->dev);
 900         ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking SCSI target\n");
 901 }
 902
 903 static void __iscsi_unblock_session(struct work_struct *work)
 904 {
 905         struct iscsi_cls_session *session =
 906                         container_of(work, struct iscsi_cls_session,
 907                                      unblock_work);
 908         struct Scsi_Host *shost = iscsi_session_to_shost(session);
 909         struct iscsi_cls_host *ihost = shost->shost_data;
 910         unsigned long flags;
 911
 912         ISCSI_DBG_TRANS_SESSION(session, "Unblocking session\n");
 913         /*
 914          * The recovery and unblock work get run from the same workqueue,
 915          * so try to cancel it if it was going to run after this unblock.
 916          */
 917         cancel_delayed_work(&session->recovery_work);
 918         spin_lock_irqsave(&session->lock, flags);
 919         session->state = ISCSI_SESSION_LOGGED_IN;
 920         spin_unlock_irqrestore(&session->lock, flags);
 921         /* start IO */
 922         scsi_target_unblock(&session->dev);
 923         /*
 924          * Only do kernel scanning if the driver is properly hooked into
 925          * the async scanning code (drivers like iscsi_tcp do login and
 926          * scanning from userspace).
 927          */
 928         if (shost->hostt->scan_finished) {
 929                 if (scsi_queue_work(shost, &session->scan_work))
 930                         atomic_inc(&ihost->nr_scans);
 931         }
 932         ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking session\n");
 933 }
 934
 935 /**
 936  * iscsi_unblock_session - set a session as logged in and start IO.
 937  * @session: iscsi session
 938  *
 939  * Mark a session as ready to accept IO.
 940  */
 941 void iscsi_unblock_session(struct iscsi_cls_session *session)
 942 {
 943         queue_work(iscsi_eh_timer_workq, &session->unblock_work);
 944         /*
 945          * make sure all the events have completed before tell the driver
 946          * it is safe
 947          */
 948         flush_workqueue(iscsi_eh_timer_workq);
 949 }
 950 EXPORT_SYMBOL_GPL(iscsi_unblock_session);
 951
 952 static void __iscsi_block_session(struct work_struct *work)
 953 {
 954         struct iscsi_cls_session *session =
 955                         container_of(work, struct iscsi_cls_session,
 956                                      block_work);
 957         unsigned long flags;
 958
 959         ISCSI_DBG_TRANS_SESSION(session, "Blocking session\n");
 960         spin_lock_irqsave(&session->lock, flags);
 961         session->state = ISCSI_SESSION_FAILED;
 962         spin_unlock_irqrestore(&session->lock, flags);
 963         scsi_target_block(&session->dev);
 964         ISCSI_DBG_TRANS_SESSION(session, "Completed SCSI target blocking\n");
 965         if (session->recovery_tmo >= 0)
 966                 queue_delayed_work(iscsi_eh_timer_workq,
 967                                    &session->recovery_work,
 968                                    session->recovery_tmo * HZ);
 969 }
 970
 971 void iscsi_block_session(struct iscsi_cls_session *session)
 972 {
 973         queue_work(iscsi_eh_timer_workq, &session->block_work);
 974 }
 975 EXPORT_SYMBOL_GPL(iscsi_block_session);
 976
 977 static void __iscsi_unbind_session(struct work_struct *work)
 978 {
 979         struct iscsi_cls_session *session =
 980                         container_of(work, struct iscsi_cls_session,
 981                                      unbind_work);
 982         struct Scsi_Host *shost = iscsi_session_to_shost(session);
 983         struct iscsi_cls_host *ihost = shost->shost_data;
 984         unsigned long flags;
 985
 986         ISCSI_DBG_TRANS_SESSION(session, "Unbinding session\n");
 987
 988         /* Prevent new scans and make sure scanning is not in progress */
 989         mutex_lock(&ihost->mutex);
 990         spin_lock_irqsave(&session->lock, flags);
 991         if (session->target_id == ISCSI_MAX_TARGET) {
 992                 spin_unlock_irqrestore(&session->lock, flags);
 993                 mutex_unlock(&ihost->mutex);
 994                 return;
 995         }
 996         session->target_id = ISCSI_MAX_TARGET;
 997         spin_unlock_irqrestore(&session->lock, flags);
 998         mutex_unlock(&ihost->mutex);
 999
1000         scsi_remove_target(&session->dev);
1001         iscsi_session_event(session, ISCSI_KEVENT_UNBIND_SESSION);
1002         ISCSI_DBG_TRANS_SESSION(session, "Completed target removal\n");
1003 }
1004
1005 struct iscsi_cls_session *
1006 iscsi_alloc_session(struct Scsi_Host *shost, struct iscsi_transport *transport,
1007                     int dd_size)
1008 {
1009         struct iscsi_cls_session *session;
1010
1011         session = kzalloc(sizeof(*session) + dd_size,
1012                           GFP_KERNEL);
1013         if (!session)
1014                 return NULL;
1015
1016         session->transport = transport;
1017         session->recovery_tmo = 120;
1018         session->state = ISCSI_SESSION_FREE;
1019         INIT_DELAYED_WORK(&session->recovery_work, session_recovery_timedout);
1020         INIT_LIST_HEAD(&session->sess_list);
1021         INIT_WORK(&session->unblock_work, __iscsi_unblock_session);
1022         INIT_WORK(&session->block_work, __iscsi_block_session);
1023         INIT_WORK(&session->unbind_work, __iscsi_unbind_session);
1024         INIT_WORK(&session->scan_work, iscsi_scan_session);
1025         spin_lock_init(&session->lock);
1026
1027         /* this is released in the dev's release function */
1028         scsi_host_get(shost);
1029         session->dev.parent = &shost->shost_gendev;
1030         session->dev.release = iscsi_session_release;
1031         device_initialize(&session->dev);
1032         if (dd_size)
1033                 session->dd_data = &session[1];
1034
1035         ISCSI_DBG_TRANS_SESSION(session, "Completed session allocation\n");
1036         return session;
1037 }
1038 EXPORT_SYMBOL_GPL(iscsi_alloc_session);
1039
1040 static int iscsi_get_next_target_id(struct device *dev, void *data)
1041 {
1042         struct iscsi_cls_session *session;
1043         unsigned long flags;
1044         int err = 0;
1045
1046         if (!iscsi_is_session_dev(dev))
1047                 return 0;
1048
1049         session = iscsi_dev_to_session(dev);
1050         spin_lock_irqsave(&session->lock, flags);
1051         if (*((unsigned int *) data) == session->target_id)
1052                 err = -EEXIST;
1053         spin_unlock_irqrestore(&session->lock, flags);
1054         return err;
1055 }
1056
1057 int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id)
1058 {
1059         struct Scsi_Host *shost = iscsi_session_to_shost(session);
1060         struct iscsi_cls_host *ihost;
1061         unsigned long flags;
1062         unsigned int id = target_id;
1063         int err;
1064
1065         ihost = shost->shost_data;
1066         session->sid = atomic_add_return(1, &iscsi_session_nr);
1067
1068         if (id == ISCSI_MAX_TARGET) {
1069                 for (id = 0; id < ISCSI_MAX_TARGET; id++) {
1070                         err = device_for_each_child(&shost->shost_gendev, &id,
1071                                                     iscsi_get_next_target_id);
1072                         if (!err)
1073                                 break;
1074                 }
1075
1076                 if (id == ISCSI_MAX_TARGET) {
1077                         iscsi_cls_session_printk(KERN_ERR, session,
1078                                                  "Too many iscsi targets. Max "
1079                                                  "number of targets is %d.\n",
1080                                                  ISCSI_MAX_TARGET - 1);
1081                         err = -EOVERFLOW;
1082                         goto release_host;
1083                 }
1084         }
1085         session->target_id = id;
1086
1087         dev_set_name(&session->dev, "session%u", session->sid);
1088         err = device_add(&session->dev);
1089         if (err) {
1090                 iscsi_cls_session_printk(KERN_ERR, session,
1091                                          "could not register session's dev\n");
1092                 goto release_host;
1093         }
1094         transport_register_device(&session->dev);
1095
1096         spin_lock_irqsave(&sesslock, flags);
1097         list_add(&session->sess_list, &sesslist);
1098         spin_unlock_irqrestore(&sesslock, flags);
1099
1100         iscsi_session_event(session, ISCSI_KEVENT_CREATE_SESSION);
1101         ISCSI_DBG_TRANS_SESSION(session, "Completed session adding\n");
1102         return 0;
1103
1104 release_host:
1105         scsi_host_put(shost);
1106         return err;
1107 }
1108 EXPORT_SYMBOL_GPL(iscsi_add_session);
1109
1110 /**
1111  * iscsi_create_session - create iscsi class session
1112  * @shost: scsi host
1113  * @transport: iscsi transport
1114  * @dd_size: private driver data size
1115  * @target_id: which target
1116  *
1117  * This can be called from a LLD or iscsi_transport.
1118  */
1119 struct iscsi_cls_session *
1120 iscsi_create_session(struct Scsi_Host *shost, struct iscsi_transport *transport,
1121                      int dd_size, unsigned int target_id)
1122 {
1123         struct iscsi_cls_session *session;
1124
1125         session = iscsi_alloc_session(shost, transport, dd_size);
1126         if (!session)
1127                 return NULL;
1128
1129         if (iscsi_add_session(session, target_id)) {
1130                 iscsi_free_session(session);
1131                 return NULL;
1132         }
1133         return session;
1134 }
1135 EXPORT_SYMBOL_GPL(iscsi_create_session);
1136
1137 static void iscsi_conn_release(struct device *dev)
1138 {
1139         struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev);
1140         struct device *parent = conn->dev.parent;
1141
1142         ISCSI_DBG_TRANS_CONN(conn, "Releasing conn\n");
1143         kfree(conn);
1144         put_device(parent);
1145 }
1146
1147 static int iscsi_is_conn_dev(const struct device *dev)
1148 {
1149         return dev->release == iscsi_conn_release;
1150 }
1151
1152 static int iscsi_iter_destroy_conn_fn(struct device *dev, void *data)
1153 {
1154         if (!iscsi_is_conn_dev(dev))
1155                 return 0;
1156         return iscsi_destroy_conn(iscsi_dev_to_conn(dev));
1157 }
1158
1159 void iscsi_remove_session(struct iscsi_cls_session *session)
1160 {
1161         struct Scsi_Host *shost = iscsi_session_to_shost(session);
1162         unsigned long flags;
1163         int err;
1164
1165         ISCSI_DBG_TRANS_SESSION(session, "Removing session\n");
1166
1167         spin_lock_irqsave(&sesslock, flags);
1168         list_del(&session->sess_list);
1169         spin_unlock_irqrestore(&sesslock, flags);
1170
1171         /* make sure there are no blocks/unblocks queued */
1172         flush_workqueue(iscsi_eh_timer_workq);
1173         /* make sure the timedout callout is not running */
1174         if (!cancel_delayed_work(&session->recovery_work))
1175                 flush_workqueue(iscsi_eh_timer_workq);
1176         /*
1177          * If we are blocked let commands flow again. The lld or iscsi
1178          * layer should set up the queuecommand to fail commands.
1179          * We assume that LLD will not be calling block/unblock while
1180          * removing the session.
1181          */
1182         spin_lock_irqsave(&session->lock, flags);
1183         session->state = ISCSI_SESSION_FREE;
1184         spin_unlock_irqrestore(&session->lock, flags);
1185
1186         scsi_target_unblock(&session->dev);
1187         /* flush running scans then delete devices */
1188         scsi_flush_work(shost);
1189         __iscsi_unbind_session(&session->unbind_work);
1190
1191         /* hw iscsi may not have removed all connections from session */
1192         err = device_for_each_child(&session->dev, NULL,
1193                                     iscsi_iter_destroy_conn_fn);
1194         if (err)
1195                 iscsi_cls_session_printk(KERN_ERR, session,
1196                                          "Could not delete all connections "
1197                                          "for session. Error %d.\n", err);
1198
1199         transport_unregister_device(&session->dev);
1200
1201         ISCSI_DBG_TRANS_SESSION(session, "Completing session removal\n");
1202         device_del(&session->dev);
1203 }
1204 EXPORT_SYMBOL_GPL(iscsi_remove_session);
1205
1206 void iscsi_free_session(struct iscsi_cls_session *session)
1207 {
1208         ISCSI_DBG_TRANS_SESSION(session, "Freeing session\n");
1209         iscsi_session_event(session, ISCSI_KEVENT_DESTROY_SESSION);
1210         put_device(&session->dev);
1211 }
1212 EXPORT_SYMBOL_GPL(iscsi_free_session);
1213
1214 /**
1215  * iscsi_destroy_session - destroy iscsi session
1216  * @session: iscsi_session
1217  *
1218  * Can be called by a LLD or iscsi_transport. There must not be
1219  * any running connections.
1220  */
1221 int iscsi_destroy_session(struct iscsi_cls_session *session)
1222 {
1223         iscsi_remove_session(session);
1224         ISCSI_DBG_TRANS_SESSION(session, "Completing session destruction\n");
1225         iscsi_free_session(session);
1226         return 0;
1227 }
1228 EXPORT_SYMBOL_GPL(iscsi_destroy_session);
1229
1230 /**
1231  * iscsi_create_conn - create iscsi class connection
1232  * @session: iscsi cls session
1233  * @dd_size: private driver data size
1234  * @cid: connection id
1235  *
1236  * This can be called from a LLD or iscsi_transport. The connection
1237  * is child of the session so cid must be unique for all connections
1238  * on the session.
1239  *
1240  * Since we do not support MCS, cid will normally be zero. In some cases
1241  * for software iscsi we could be trying to preallocate a connection struct
1242  * in which case there could be two connection structs and cid would be
1243  * non-zero.
1244  */
1245 struct iscsi_cls_conn *
1246 iscsi_create_conn(struct iscsi_cls_session *session, int dd_size, uint32_t cid)
1247 {
1248         struct iscsi_transport *transport = session->transport;
1249         struct iscsi_cls_conn *conn;
1250         unsigned long flags;
1251         int err;
1252
1253         conn = kzalloc(sizeof(*conn) + dd_size, GFP_KERNEL);
1254         if (!conn)
1255                 return NULL;
1256         if (dd_size)
1257                 conn->dd_data = &conn[1];
1258
1259         mutex_init(&conn->ep_mutex);
1260         INIT_LIST_HEAD(&conn->conn_list);
1261         conn->transport = transport;
1262         conn->cid = cid;
1263
1264         /* this is released in the dev's release function */
1265         if (!get_device(&session->dev))
1266                 goto free_conn;
1267
1268         dev_set_name(&conn->dev, "connection%d:%u", session->sid, cid);
1269         conn->dev.parent = &session->dev;
1270         conn->dev.release = iscsi_conn_release;
1271         err = device_register(&conn->dev);
1272         if (err) {
1273                 iscsi_cls_session_printk(KERN_ERR, session, "could not "
1274                                          "register connection's dev\n");
1275                 goto release_parent_ref;
1276         }
1277         transport_register_device(&conn->dev);
1278
1279         spin_lock_irqsave(&connlock, flags);
1280         list_add(&conn->conn_list, &connlist);
1281         spin_unlock_irqrestore(&connlock, flags);
1282
1283         ISCSI_DBG_TRANS_CONN(conn, "Completed conn creation\n");
1284         return conn;
1285
1286 release_parent_ref:
1287         put_device(&session->dev);
1288 free_conn:
1289         kfree(conn);
1290         return NULL;
1291 }
1292
1293 EXPORT_SYMBOL_GPL(iscsi_create_conn);
1294
1295 /**
1296  * iscsi_destroy_conn - destroy iscsi class connection
1297  * @conn: iscsi cls session
1298  *
1299  * This can be called from a LLD or iscsi_transport.
1300  */
1301 int iscsi_destroy_conn(struct iscsi_cls_conn *conn)
1302 {
1303         unsigned long flags;
1304
1305         spin_lock_irqsave(&connlock, flags);
1306         list_del(&conn->conn_list);
1307         spin_unlock_irqrestore(&connlock, flags);
1308
1309         transport_unregister_device(&conn->dev);
1310         ISCSI_DBG_TRANS_CONN(conn, "Completing conn destruction\n");
1311         device_unregister(&conn->dev);
1312         return 0;
1313 }
1314 EXPORT_SYMBOL_GPL(iscsi_destroy_conn);
1315
1316 /*
1317  * iscsi interface functions
1318  */
1319 static struct iscsi_internal *
1320 iscsi_if_transport_lookup(struct iscsi_transport *tt)
1321 {
1322         struct iscsi_internal *priv;
1323         unsigned long flags;
1324
1325         spin_lock_irqsave(&iscsi_transport_lock, flags);
1326         list_for_each_entry(priv, &iscsi_transports, list) {
1327                 if (tt == priv->iscsi_transport) {
1328                         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
1329                         return priv;
1330                 }
1331         }
1332         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
1333         return NULL;
1334 }
1335
1336 static int
1337 iscsi_multicast_skb(struct sk_buff *skb, uint32_t group, gfp_t gfp)
1338 {
1339         return nlmsg_multicast(nls, skb, 0, group, gfp);
1340 }
1341
1342 int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
1343                    char *data, uint32_t data_size)
1344 {
1345         struct nlmsghdr *nlh;
1346         struct sk_buff *skb;
1347         struct iscsi_uevent *ev;
1348         char *pdu;
1349         struct iscsi_internal *priv;
1350         int len = NLMSG_SPACE(sizeof(*ev) + sizeof(struct iscsi_hdr) +
1351                               data_size);
1352
1353         priv = iscsi_if_transport_lookup(conn->transport);
1354         if (!priv)
1355                 return -EINVAL;
1356
1357         skb = alloc_skb(len, GFP_ATOMIC);
1358         if (!skb) {
1359                 iscsi_conn_error_event(conn, ISCSI_ERR_CONN_FAILED);
1360                 iscsi_cls_conn_printk(KERN_ERR, conn, "can not deliver "
1361                                       "control PDU: OOM\n");
1362                 return -ENOMEM;
1363         }
1364
1365         nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
1366         ev = NLMSG_DATA(nlh);
1367         memset(ev, 0, sizeof(*ev));
1368         ev->transport_handle = iscsi_handle(conn->transport);
1369         ev->type = ISCSI_KEVENT_RECV_PDU;
1370         ev->r.recv_req.cid = conn->cid;
1371         ev->r.recv_req.sid = iscsi_conn_get_sid(conn);
1372         pdu = (char*)ev + sizeof(*ev);
1373         memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
1374         memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
1375
1376         return iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
1377 }
1378 EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
1379
1380 int iscsi_offload_mesg(struct Scsi_Host *shost,
1381                        struct iscsi_transport *transport, uint32_t type,
1382                        char *data, uint16_t data_size)
1383 {
1384         struct nlmsghdr *nlh;
1385         struct sk_buff *skb;
1386         struct iscsi_uevent *ev;
1387         int len = NLMSG_SPACE(sizeof(*ev) + data_size);
1388
1389         skb = alloc_skb(len, GFP_ATOMIC);
1390         if (!skb) {
1391                 printk(KERN_ERR "can not deliver iscsi offload message:OOM\n");
1392                 return -ENOMEM;
1393         }
1394
1395         nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
1396         ev = NLMSG_DATA(nlh);
1397         memset(ev, 0, sizeof(*ev));
1398         ev->type = type;
1399         ev->transport_handle = iscsi_handle(transport);
1400         switch (type) {
1401         case ISCSI_KEVENT_PATH_REQ:
1402                 ev->r.req_path.host_no = shost->host_no;
1403                 break;
1404         case ISCSI_KEVENT_IF_DOWN:
1405                 ev->r.notify_if_down.host_no = shost->host_no;
1406                 break;
1407         }
1408
1409         memcpy((char *)ev + sizeof(*ev), data, data_size);
1410
1411         return iscsi_multicast_skb(skb, ISCSI_NL_GRP_UIP, GFP_ATOMIC);
1412 }
1413 EXPORT_SYMBOL_GPL(iscsi_offload_mesg);
1414
1415 void iscsi_conn_error_event(struct iscsi_cls_conn *conn, enum iscsi_err error)
1416 {
1417         struct nlmsghdr *nlh;
1418         struct sk_buff  *skb;
1419         struct iscsi_uevent *ev;
1420         struct iscsi_internal *priv;
1421         int len = NLMSG_SPACE(sizeof(*ev));
1422
1423         priv = iscsi_if_transport_lookup(conn->transport);
1424         if (!priv)
1425                 return;
1426
1427         skb = alloc_skb(len, GFP_ATOMIC);
1428         if (!skb) {
1429                 iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored "
1430                                       "conn error (%d)\n", error);
1431                 return;
1432         }
1433
1434         nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
1435         ev = NLMSG_DATA(nlh);
1436         ev->transport_handle = iscsi_handle(conn->transport);
1437         ev->type = ISCSI_KEVENT_CONN_ERROR;
1438         ev->r.connerror.error = error;
1439         ev->r.connerror.cid = conn->cid;
1440         ev->r.connerror.sid = iscsi_conn_get_sid(conn);
1441
1442         iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
1443
1444         iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn error (%d)\n",
1445                               error);
1446 }
1447 EXPORT_SYMBOL_GPL(iscsi_conn_error_event);
1448
1449 void iscsi_conn_login_event(struct iscsi_cls_conn *conn,
1450                             enum iscsi_conn_state state)
1451 {
1452         struct nlmsghdr *nlh;
1453         struct sk_buff  *skb;
1454         struct iscsi_uevent *ev;
1455         struct iscsi_internal *priv;
1456         int len = NLMSG_SPACE(sizeof(*ev));
1457
1458         priv = iscsi_if_transport_lookup(conn->transport);
1459         if (!priv)
1460                 return;
1461
1462         skb = alloc_skb(len, GFP_ATOMIC);
1463         if (!skb) {
1464                 iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored "
1465                                       "conn login (%d)\n", state);
1466                 return;
1467         }
1468
1469         nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
1470         ev = NLMSG_DATA(nlh);
1471         ev->transport_handle = iscsi_handle(conn->transport);
1472         ev->type = ISCSI_KEVENT_CONN_LOGIN_STATE;
1473         ev->r.conn_login.state = state;
1474         ev->r.conn_login.cid = conn->cid;
1475         ev->r.conn_login.sid = iscsi_conn_get_sid(conn);
1476         iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
1477
1478         iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn login (%d)\n",
1479                               state);
1480 }
1481 EXPORT_SYMBOL_GPL(iscsi_conn_login_event);
1482
1483 static int
1484 iscsi_if_send_reply(uint32_t group, int seq, int type, int done, int multi,
1485                     void *payload, int size)
1486 {
1487         struct sk_buff  *skb;
1488         struct nlmsghdr *nlh;
1489         int len = NLMSG_SPACE(size);
1490         int flags = multi ? NLM_F_MULTI : 0;
1491         int t = done ? NLMSG_DONE : type;
1492
1493         skb = alloc_skb(len, GFP_ATOMIC);
1494         if (!skb) {
1495                 printk(KERN_ERR "Could not allocate skb to send reply.\n");
1496                 return -ENOMEM;
1497         }
1498
1499         nlh = __nlmsg_put(skb, 0, 0, t, (len - sizeof(*nlh)), 0);
1500         nlh->nlmsg_flags = flags;
1501         memcpy(NLMSG_DATA(nlh), payload, size);
1502         return iscsi_multicast_skb(skb, group, GFP_ATOMIC);
1503 }
1504
1505 static int
1506 iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
1507 {
1508         struct iscsi_uevent *ev = NLMSG_DATA(nlh);
1509         struct iscsi_stats *stats;
1510         struct sk_buff *skbstat;
1511         struct iscsi_cls_conn *conn;
1512         struct nlmsghdr *nlhstat;
1513         struct iscsi_uevent *evstat;
1514         struct iscsi_internal *priv;
1515         int len = NLMSG_SPACE(sizeof(*ev) +
1516                               sizeof(struct iscsi_stats) +
1517                               sizeof(struct iscsi_stats_custom) *
1518                               ISCSI_STATS_CUSTOM_MAX);
1519         int err = 0;
1520
1521         priv = iscsi_if_transport_lookup(transport);
1522         if (!priv)
1523                 return -EINVAL;
1524
1525         conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid);
1526         if (!conn)
1527                 return -EEXIST;
1528
1529         do {
1530                 int actual_size;
1531
1532                 skbstat = alloc_skb(len, GFP_ATOMIC);
1533                 if (!skbstat) {
1534                         iscsi_cls_conn_printk(KERN_ERR, conn, "can not "
1535                                               "deliver stats: OOM\n");
1536                         return -ENOMEM;
1537                 }
1538
1539                 nlhstat = __nlmsg_put(skbstat, 0, 0, 0,
1540                                       (len - sizeof(*nlhstat)), 0);
1541                 evstat = NLMSG_DATA(nlhstat);
1542                 memset(evstat, 0, sizeof(*evstat));
1543                 evstat->transport_handle = iscsi_handle(conn->transport);
1544                 evstat->type = nlh->nlmsg_type;
1545                 evstat->u.get_stats.cid =
1546                         ev->u.get_stats.cid;
1547                 evstat->u.get_stats.sid =
1548                         ev->u.get_stats.sid;
1549                 stats = (struct iscsi_stats *)
1550                         ((char*)evstat + sizeof(*evstat));
1551                 memset(stats, 0, sizeof(*stats));
1552
1553                 transport->get_stats(conn, stats);
1554                 actual_size = NLMSG_SPACE(sizeof(struct iscsi_uevent) +
1555                                           sizeof(struct iscsi_stats) +
1556                                           sizeof(struct iscsi_stats_custom) *
1557                                           stats->custom_length);
1558                 actual_size -= sizeof(*nlhstat);
1559                 actual_size = NLMSG_LENGTH(actual_size);
1560                 skb_trim(skbstat, NLMSG_ALIGN(actual_size));
1561                 nlhstat->nlmsg_len = actual_size;
1562
1563                 err = iscsi_multicast_skb(skbstat, ISCSI_NL_GRP_ISCSID,
1564                                           GFP_ATOMIC);
1565         } while (err < 0 && err != -ECONNREFUSED);
1566
1567         return err;
1568 }
1569
1570 /**
1571  * iscsi_session_event - send session destr. completion event
1572  * @session: iscsi class session
1573  * @event: type of event
1574  */
1575 int iscsi_session_event(struct iscsi_cls_session *session,
1576                         enum iscsi_uevent_e event)
1577 {
1578         struct iscsi_internal *priv;
1579         struct Scsi_Host *shost;
1580         struct iscsi_uevent *ev;
1581         struct sk_buff  *skb;
1582         struct nlmsghdr *nlh;
1583         int rc, len = NLMSG_SPACE(sizeof(*ev));
1584
1585         priv = iscsi_if_transport_lookup(session->transport);
1586         if (!priv)
1587                 return -EINVAL;
1588         shost = iscsi_session_to_shost(session);
1589
1590         skb = alloc_skb(len, GFP_KERNEL);
1591         if (!skb) {
1592                 iscsi_cls_session_printk(KERN_ERR, session,
1593                                          "Cannot notify userspace of session "
1594                                          "event %u\n", event);
1595                 return -ENOMEM;
1596         }
1597
1598         nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
1599         ev = NLMSG_DATA(nlh);
1600         ev->transport_handle = iscsi_handle(session->transport);
1601
1602         ev->type = event;
1603         switch (event) {
1604         case ISCSI_KEVENT_DESTROY_SESSION:
1605                 ev->r.d_session.host_no = shost->host_no;
1606                 ev->r.d_session.sid = session->sid;
1607                 break;
1608         case ISCSI_KEVENT_CREATE_SESSION:
1609                 ev->r.c_session_ret.host_no = shost->host_no;
1610                 ev->r.c_session_ret.sid = session->sid;
1611                 break;
1612         case ISCSI_KEVENT_UNBIND_SESSION:
1613                 ev->r.unbind_session.host_no = shost->host_no;
1614                 ev->r.unbind_session.sid = session->sid;
1615                 break;
1616         default:
1617                 iscsi_cls_session_printk(KERN_ERR, session, "Invalid event "
1618                                          "%u.\n", event);
1619                 kfree_skb(skb);
1620                 return -EINVAL;
1621         }
1622
1623         /*
1624          * this will occur if the daemon is not up, so we just warn
1625          * the user and when the daemon is restarted it will handle it
1626          */
1627         rc = iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_KERNEL);
1628         if (rc == -ESRCH)
1629                 iscsi_cls_session_printk(KERN_ERR, session,
1630                                          "Cannot notify userspace of session "
1631                                          "event %u. Check iscsi daemon\n",
1632                                          event);
1633
1634         ISCSI_DBG_TRANS_SESSION(session, "Completed handling event %d rc %d\n",
1635                                 event, rc);
1636         return rc;
1637 }
1638 EXPORT_SYMBOL_GPL(iscsi_session_event);
1639
1640 static int
1641 iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_endpoint *ep,
1642                         struct iscsi_uevent *ev, uint32_t initial_cmdsn,
1643                         uint16_t cmds_max, uint16_t queue_depth)
1644 {
1645         struct iscsi_transport *transport = priv->iscsi_transport;
1646         struct iscsi_cls_session *session;
1647         struct Scsi_Host *shost;
1648
1649         session = transport->create_session(ep, cmds_max, queue_depth,
1650                                             initial_cmdsn);
1651         if (!session)
1652                 return -ENOMEM;
1653
1654         shost = iscsi_session_to_shost(session);
1655         ev->r.c_session_ret.host_no = shost->host_no;
1656         ev->r.c_session_ret.sid = session->sid;
1657         ISCSI_DBG_TRANS_SESSION(session,
1658                                 "Completed creating transport session\n");
1659         return 0;
1660 }
1661
1662 static int
1663 iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
1664 {
1665         struct iscsi_cls_conn *conn;
1666         struct iscsi_cls_session *session;
1667
1668         session = iscsi_session_lookup(ev->u.c_conn.sid);
1669         if (!session) {
1670                 printk(KERN_ERR "iscsi: invalid session %d.\n",
1671                        ev->u.c_conn.sid);
1672                 return -EINVAL;
1673         }
1674
1675         conn = transport->create_conn(session, ev->u.c_conn.cid);
1676         if (!conn) {
1677                 iscsi_cls_session_printk(KERN_ERR, session,
1678                                          "couldn't create a new connection.");
1679                 return -ENOMEM;
1680         }
1681
1682         ev->r.c_conn_ret.sid = session->sid;
1683         ev->r.c_conn_ret.cid = conn->cid;
1684
1685         ISCSI_DBG_TRANS_CONN(conn, "Completed creating transport conn\n");
1686         return 0;
1687 }
1688
1689 static int
1690 iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
1691 {
1692         struct iscsi_cls_conn *conn;
1693
1694         conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid);
1695         if (!conn)
1696                 return -EINVAL;
1697
1698         ISCSI_DBG_TRANS_CONN(conn, "Destroying transport conn\n");
1699         if (transport->destroy_conn)
1700                 transport->destroy_conn(conn);
1701
1702         return 0;
1703 }
1704
1705 static int
1706 iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev)
1707 {
1708         char *data = (char*)ev + sizeof(*ev);
1709         struct iscsi_cls_conn *conn;
1710         struct iscsi_cls_session *session;
1711         int err = 0, value = 0;
1712
1713         session = iscsi_session_lookup(ev->u.set_param.sid);
1714         conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid);
1715         if (!conn || !session)
1716                 return -EINVAL;
1717
1718         switch (ev->u.set_param.param) {
1719         case ISCSI_PARAM_SESS_RECOVERY_TMO:
1720                 sscanf(data, "%d", &value);
1721                 session->recovery_tmo = value;
1722                 break;
1723         default:
1724                 err = transport->set_param(conn, ev->u.set_param.param,
1725                                            data, ev->u.set_param.len);
1726         }
1727
1728         return err;
1729 }
1730
1731 static int iscsi_if_ep_connect(struct iscsi_transport *transport,
1732                                struct iscsi_uevent *ev, int msg_type)
1733 {
1734         struct iscsi_endpoint *ep;
1735         struct sockaddr *dst_addr;
1736         struct Scsi_Host *shost = NULL;
1737         int non_blocking, err = 0;
1738
1739         if (!transport->ep_connect)
1740                 return -EINVAL;
1741
1742         if (msg_type == ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST) {
1743                 shost = scsi_host_lookup(ev->u.ep_connect_through_host.host_no);
1744                 if (!shost) {
1745                         printk(KERN_ERR "ep connect failed. Could not find "
1746                                "host no %u\n",
1747                                ev->u.ep_connect_through_host.host_no);
1748                         return -ENODEV;
1749                 }
1750                 non_blocking = ev->u.ep_connect_through_host.non_blocking;
1751         } else
1752                 non_blocking = ev->u.ep_connect.non_blocking;
1753
1754         dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
1755         ep = transport->ep_connect(shost, dst_addr, non_blocking);
1756         if (IS_ERR(ep)) {
1757                 err = PTR_ERR(ep);
1758                 goto release_host;
1759         }
1760
1761         ev->r.ep_connect_ret.handle = ep->id;
1762 release_host:
1763         if (shost)
1764                 scsi_host_put(shost);
1765         return err;
1766 }
1767
1768 static int iscsi_if_ep_disconnect(struct iscsi_transport *transport,
1769                                   u64 ep_handle)
1770 {
1771         struct iscsi_cls_conn *conn;
1772         struct iscsi_endpoint *ep;
1773
1774         if (!transport->ep_disconnect)
1775                 return -EINVAL;
1776
1777         ep = iscsi_lookup_endpoint(ep_handle);
1778         if (!ep)
1779                 return -EINVAL;
1780         conn = ep->conn;
1781         if (conn) {
1782                 mutex_lock(&conn->ep_mutex);
1783                 conn->ep = NULL;
1784                 mutex_unlock(&conn->ep_mutex);
1785         }
1786
1787         transport->ep_disconnect(ep);
1788         return 0;
1789 }
1790
1791 static int
1792 iscsi_if_transport_ep(struct iscsi_transport *transport,
1793                       struct iscsi_uevent *ev, int msg_type)
1794 {
1795         struct iscsi_endpoint *ep;
1796         int rc = 0;
1797
1798         switch (msg_type) {
1799         case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST:
1800         case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
1801                 rc = iscsi_if_ep_connect(transport, ev, msg_type);
1802                 break;
1803         case ISCSI_UEVENT_TRANSPORT_EP_POLL:
1804                 if (!transport->ep_poll)
1805                         return -EINVAL;
1806
1807                 ep = iscsi_lookup_endpoint(ev->u.ep_poll.ep_handle);
1808                 if (!ep)
1809                         return -EINVAL;
1810
1811                 ev->r.retcode = transport->ep_poll(ep,
1812                                                    ev->u.ep_poll.timeout_ms);
1813                 break;
1814         case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
1815                 rc = iscsi_if_ep_disconnect(transport,
1816                                             ev->u.ep_disconnect.ep_handle);
1817                 break;
1818         }
1819         return rc;
1820 }
1821
1822 static int
1823 iscsi_tgt_dscvr(struct iscsi_transport *transport,
1824                 struct iscsi_uevent *ev)
1825 {
1826         struct Scsi_Host *shost;
1827         struct sockaddr *dst_addr;
1828         int err;
1829
1830         if (!transport->tgt_dscvr)
1831                 return -EINVAL;
1832
1833         shost = scsi_host_lookup(ev->u.tgt_dscvr.host_no);
1834         if (!shost) {
1835                 printk(KERN_ERR "target discovery could not find host no %u\n",
1836                        ev->u.tgt_dscvr.host_no);
1837                 return -ENODEV;
1838         }
1839
1840
1841         dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
1842         err = transport->tgt_dscvr(shost, ev->u.tgt_dscvr.type,
1843                                    ev->u.tgt_dscvr.enable, dst_addr);
1844         scsi_host_put(shost);
1845         return err;
1846 }
1847
1848 static int
1849 iscsi_set_host_param(struct iscsi_transport *transport,
1850                      struct iscsi_uevent *ev)
1851 {
1852         char *data = (char*)ev + sizeof(*ev);
1853         struct Scsi_Host *shost;
1854         int err;
1855
1856         if (!transport->set_host_param)
1857                 return -ENOSYS;
1858
1859         shost = scsi_host_lookup(ev->u.set_host_param.host_no);
1860         if (!shost) {
1861                 printk(KERN_ERR "set_host_param could not find host no %u\n",
1862                        ev->u.set_host_param.host_no);
1863                 return -ENODEV;
1864         }
1865
1866         err = transport->set_host_param(shost, ev->u.set_host_param.param,
1867                                         data, ev->u.set_host_param.len);
1868         scsi_host_put(shost);
1869         return err;
1870 }
1871
1872 static int
1873 iscsi_set_path(struct iscsi_transport *transport, struct iscsi_uevent *ev)
1874 {
1875         struct Scsi_Host *shost;
1876         struct iscsi_path *params;
1877         int err;
1878
1879         if (!transport->set_path)
1880                 return -ENOSYS;
1881
1882         shost = scsi_host_lookup(ev->u.set_path.host_no);
1883         if (!shost) {
1884                 printk(KERN_ERR "set path could not find host no %u\n",
1885                        ev->u.set_path.host_no);
1886                 return -ENODEV;
1887         }
1888
1889         params = (struct iscsi_path *)((char *)ev + sizeof(*ev));
1890         err = transport->set_path(shost, params);
1891
1892         scsi_host_put(shost);
1893         return err;
1894 }
1895
1896 static int
1897 iscsi_set_iface_params(struct iscsi_transport *transport,
1898                        struct iscsi_uevent *ev)
1899 {
1900         char *data = (char *)ev + sizeof(*ev);
1901         struct Scsi_Host *shost;
1902         int err;
1903
1904         if (!transport->set_iface_param)
1905                 return -ENOSYS;
1906
1907         shost = scsi_host_lookup(ev->u.set_iface_params.host_no);
1908         if (!shost) {
1909                 printk(KERN_ERR "set_iface_params could not find host no %u\n",
1910                        ev->u.set_iface_params.host_no);
1911                 return -ENODEV;
1912         }
1913
1914         err = transport->set_iface_param(shost, data,
1915                                          ev->u.set_iface_params.count);
1916         scsi_host_put(shost);
1917         return err;
1918 }
1919
1920 static int
1921 iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, uint32_t *group)
1922 {
1923         int err = 0;
1924         struct iscsi_uevent *ev = NLMSG_DATA(nlh);
1925         struct iscsi_transport *transport = NULL;
1926         struct iscsi_internal *priv;
1927         struct iscsi_cls_session *session;
1928         struct iscsi_cls_conn *conn;
1929         struct iscsi_endpoint *ep = NULL;
1930
1931         if (nlh->nlmsg_type == ISCSI_UEVENT_PATH_UPDATE)
1932                 *group = ISCSI_NL_GRP_UIP;
1933         else
1934                 *group = ISCSI_NL_GRP_ISCSID;
1935
1936         priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle));
1937         if (!priv)
1938                 return -EINVAL;
1939         transport = priv->iscsi_transport;
1940
1941         if (!try_module_get(transport->owner))
1942                 return -EINVAL;
1943
1944         switch (nlh->nlmsg_type) {
1945         case ISCSI_UEVENT_CREATE_SESSION:
1946                 err = iscsi_if_create_session(priv, ep, ev,
1947                                               ev->u.c_session.initial_cmdsn,
1948                                               ev->u.c_session.cmds_max,
1949                                               ev->u.c_session.queue_depth);
1950                 break;
1951         case ISCSI_UEVENT_CREATE_BOUND_SESSION:
1952                 ep = iscsi_lookup_endpoint(ev->u.c_bound_session.ep_handle);
1953                 if (!ep) {
1954                         err = -EINVAL;
1955                         break;
1956                 }
1957
1958                 err = iscsi_if_create_session(priv, ep, ev,
1959                                         ev->u.c_bound_session.initial_cmdsn,
1960                                         ev->u.c_bound_session.cmds_max,
1961                                         ev->u.c_bound_session.queue_depth);
1962                 break;
1963         case ISCSI_UEVENT_DESTROY_SESSION:
1964                 session = iscsi_session_lookup(ev->u.d_session.sid);
1965                 if (session)
1966                         transport->destroy_session(session);
1967                 else
1968                         err = -EINVAL;
1969                 break;
1970         case ISCSI_UEVENT_UNBIND_SESSION:
1971                 session = iscsi_session_lookup(ev->u.d_session.sid);
1972                 if (session)
1973                         scsi_queue_work(iscsi_session_to_shost(session),
1974                                         &session->unbind_work);
1975                 else
1976                         err = -EINVAL;
1977                 break;
1978         case ISCSI_UEVENT_CREATE_CONN:
1979                 err = iscsi_if_create_conn(transport, ev);
1980                 break;
1981         case ISCSI_UEVENT_DESTROY_CONN:
1982                 err = iscsi_if_destroy_conn(transport, ev);
1983                 break;
1984         case ISCSI_UEVENT_BIND_CONN:
1985                 session = iscsi_session_lookup(ev->u.b_conn.sid);
1986                 conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid);
1987
1988                 if (conn && conn->ep)
1989                         iscsi_if_ep_disconnect(transport, conn->ep->id);
1990
1991                 if (!session || !conn) {
1992                         err = -EINVAL;
1993                         break;
1994                 }
1995
1996                 ev->r.retcode = transport->bind_conn(session, conn,
1997                                                 ev->u.b_conn.transport_eph,
1998                                                 ev->u.b_conn.is_leading);
1999                 if (ev->r.retcode || !transport->ep_connect)
2000                         break;
2001
2002                 ep = iscsi_lookup_endpoint(ev->u.b_conn.transport_eph);
2003                 if (ep) {
2004                         ep->conn = conn;
2005
2006                         mutex_lock(&conn->ep_mutex);
2007                         conn->ep = ep;
2008                         mutex_unlock(&conn->ep_mutex);
2009                 } else
2010                         iscsi_cls_conn_printk(KERN_ERR, conn,
2011                                               "Could not set ep conn "
2012                                               "binding\n");
2013                 break;
2014         case ISCSI_UEVENT_SET_PARAM:
2015                 err = iscsi_set_param(transport, ev);
2016                 break;
2017         case ISCSI_UEVENT_START_CONN:
2018                 conn = iscsi_conn_lookup(ev->u.start_conn.sid, ev->u.start_conn.cid);
2019                 if (conn)
2020                         ev->r.retcode = transport->start_conn(conn);
2021                 else
2022                         err = -EINVAL;
2023                 break;
2024         case ISCSI_UEVENT_STOP_CONN:
2025                 conn = iscsi_conn_lookup(ev->u.stop_conn.sid, ev->u.stop_conn.cid);
2026                 if (conn)
2027                         transport->stop_conn(conn, ev->u.stop_conn.flag);
2028                 else
2029                         err = -EINVAL;
2030                 break;
2031         case ISCSI_UEVENT_SEND_PDU:
2032                 conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid);
2033                 if (conn)
2034                         ev->r.retcode = transport->send_pdu(conn,
2035                                 (struct iscsi_hdr*)((char*)ev + sizeof(*ev)),
2036                                 (char*)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,
2037                                 ev->u.send_pdu.data_size);
2038                 else
2039                         err = -EINVAL;
2040                 break;
2041         case ISCSI_UEVENT_GET_STATS:
2042                 err = iscsi_if_get_stats(transport, nlh);
2043                 break;
2044         case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
2045         case ISCSI_UEVENT_TRANSPORT_EP_POLL:
2046         case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
2047         case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST:
2048                 err = iscsi_if_transport_ep(transport, ev, nlh->nlmsg_type);
2049                 break;
2050         case ISCSI_UEVENT_TGT_DSCVR:
2051                 err = iscsi_tgt_dscvr(transport, ev);
2052                 break;
2053         case ISCSI_UEVENT_SET_HOST_PARAM:
2054                 err = iscsi_set_host_param(transport, ev);
2055                 break;
2056         case ISCSI_UEVENT_PATH_UPDATE:
2057                 err = iscsi_set_path(transport, ev);
2058                 break;
2059         case ISCSI_UEVENT_SET_IFACE_PARAMS:
2060                 err = iscsi_set_iface_params(transport, ev);
2061                 break;
2062         default:
2063                 err = -ENOSYS;
2064                 break;
2065         }
2066
2067         module_put(transport->owner);
2068         return err;
2069 }
2070
2071 /*
2072  * Get message from skb.  Each message is processed by iscsi_if_recv_msg.
2073  * Malformed skbs with wrong lengths or invalid creds are not processed.
2074  */
2075 static void
2076 iscsi_if_rx(struct sk_buff *skb)
2077 {
2078         mutex_lock(&rx_queue_mutex);
2079         while (skb->len >= NLMSG_SPACE(0)) {
2080                 int err;
2081                 uint32_t rlen;
2082                 struct nlmsghdr *nlh;
2083                 struct iscsi_uevent *ev;
2084                 uint32_t group;
2085
2086                 nlh = nlmsg_hdr(skb);
2087                 if (nlh->nlmsg_len < sizeof(*nlh) ||
2088                     skb->len < nlh->nlmsg_len) {
2089                         break;
2090                 }
2091
2092                 ev = NLMSG_DATA(nlh);
2093                 rlen = NLMSG_ALIGN(nlh->nlmsg_len);
2094                 if (rlen > skb->len)
2095                         rlen = skb->len;
2096
2097                 err = iscsi_if_recv_msg(skb, nlh, &group);
2098                 if (err) {
2099                         ev->type = ISCSI_KEVENT_IF_ERROR;
2100                         ev->iferror = err;
2101                 }
2102                 do {
2103                         /*
2104                          * special case for GET_STATS:
2105                          * on success - sending reply and stats from
2106                          * inside of if_recv_msg(),
2107                          * on error - fall through.
2108                          */
2109                         if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
2110                                 break;
2111                         err = iscsi_if_send_reply(group, nlh->nlmsg_seq,
2112                                 nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
2113                 } while (err < 0 && err != -ECONNREFUSED);
2114                 skb_pull(skb, rlen);
2115         }
2116         mutex_unlock(&rx_queue_mutex);
2117 }
2118
2119 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store)              \
2120 struct device_attribute dev_attr_##_prefix##_##_name =  \
2121         __ATTR(_name,_mode,_show,_store)
2122
2123 /*
2124  * iSCSI connection attrs
2125  */
2126 #define iscsi_conn_attr_show(param)                                     \
2127 static ssize_t                                                          \
2128 show_conn_param_##param(struct device *dev,                             \
2129                         struct device_attribute *attr, char *buf)       \
2130 {                                                                       \
2131         struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent);   \
2132         struct iscsi_transport *t = conn->transport;                    \
2133         return t->get_conn_param(conn, param, buf);                     \
2134 }
2135
2136 #define iscsi_conn_attr(field, param)                                   \
2137         iscsi_conn_attr_show(param)                                     \
2138 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param,  \
2139                         NULL);
2140
2141 iscsi_conn_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH);
2142 iscsi_conn_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH);
2143 iscsi_conn_attr(header_digest, ISCSI_PARAM_HDRDGST_EN);
2144 iscsi_conn_attr(data_digest, ISCSI_PARAM_DATADGST_EN);
2145 iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN);
2146 iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN);
2147 iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT);
2148 iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN);
2149 iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS);
2150 iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);
2151 iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);
2152
2153 #define iscsi_conn_ep_attr_show(param)                                  \
2154 static ssize_t show_conn_ep_param_##param(struct device *dev,           \
2155                                           struct device_attribute *attr,\
2156                                           char *buf)                    \
2157 {                                                                       \
2158         struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent);   \
2159         struct iscsi_transport *t = conn->transport;                    \
2160         struct iscsi_endpoint *ep;                                      \
2161         ssize_t rc;                                                     \
2162                                                                         \
2163         /*                                                              \
2164          * Need to make sure ep_disconnect does not free the LLD's      \
2165          * interconnect resources while we are trying to read them.     \
2166          */                                                             \
2167         mutex_lock(&conn->ep_mutex);                                    \
2168         ep = conn->ep;                                                  \
2169         if (!ep && t->ep_connect) {                                     \
2170                 mutex_unlock(&conn->ep_mutex);                          \
2171                 return -ENOTCONN;                                       \
2172         }                                                               \
2173                                                                         \
2174         if (ep)                                                         \
2175                 rc = t->get_ep_param(ep, param, buf);                   \
2176         else                                                            \
2177                 rc = t->get_conn_param(conn, param, buf);               \
2178         mutex_unlock(&conn->ep_mutex);                                  \
2179         return rc;                                                      \
2180 }
2181
2182 #define iscsi_conn_ep_attr(field, param)                                \
2183         iscsi_conn_ep_attr_show(param)                                  \
2184 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO,                           \
2185                         show_conn_ep_param_##param, NULL);
2186
2187 iscsi_conn_ep_attr(address, ISCSI_PARAM_CONN_ADDRESS);
2188 iscsi_conn_ep_attr(port, ISCSI_PARAM_CONN_PORT);
2189
2190 static struct attribute *iscsi_conn_attrs[] = {
2191         &dev_attr_conn_max_recv_dlength.attr,
2192         &dev_attr_conn_max_xmit_dlength.attr,
2193         &dev_attr_conn_header_digest.attr,
2194         &dev_attr_conn_data_digest.attr,
2195         &dev_attr_conn_ifmarker.attr,
2196         &dev_attr_conn_ofmarker.attr,
2197         &dev_attr_conn_address.attr,
2198         &dev_attr_conn_port.attr,
2199         &dev_attr_conn_exp_statsn.attr,
2200         &dev_attr_conn_persistent_address.attr,
2201         &dev_attr_conn_persistent_port.attr,
2202         &dev_attr_conn_ping_tmo.attr,
2203         &dev_attr_conn_recv_tmo.attr,
2204         NULL,
2205 };
2206
2207 static mode_t iscsi_conn_attr_is_visible(struct kobject *kobj,
2208                                          struct attribute *attr, int i)
2209 {
2210         struct device *cdev = container_of(kobj, struct device, kobj);
2211         struct iscsi_cls_conn *conn = transport_class_to_conn(cdev);
2212         struct iscsi_transport *t = conn->transport;
2213         int param;
2214
2215         if (attr == &dev_attr_conn_max_recv_dlength.attr)
2216                 param = ISCSI_PARAM_MAX_RECV_DLENGTH;
2217         else if (attr == &dev_attr_conn_max_xmit_dlength.attr)
2218                 param = ISCSI_PARAM_MAX_XMIT_DLENGTH;
2219         else if (attr == &dev_attr_conn_header_digest.attr)
2220                 param = ISCSI_PARAM_HDRDGST_EN;
2221         else if (attr == &dev_attr_conn_data_digest.attr)
2222                 param = ISCSI_PARAM_DATADGST_EN;
2223         else if (attr == &dev_attr_conn_ifmarker.attr)
2224                 param = ISCSI_PARAM_IFMARKER_EN;
2225         else if (attr == &dev_attr_conn_ofmarker.attr)
2226                 param = ISCSI_PARAM_OFMARKER_EN;
2227         else if (attr == &dev_attr_conn_address.attr)
2228                 param = ISCSI_PARAM_CONN_ADDRESS;
2229         else if (attr == &dev_attr_conn_port.attr)
2230                 param = ISCSI_PARAM_CONN_PORT;
2231         else if (attr == &dev_attr_conn_exp_statsn.attr)
2232                 param = ISCSI_PARAM_EXP_STATSN;
2233         else if (attr == &dev_attr_conn_persistent_address.attr)
2234                 param = ISCSI_PARAM_PERSISTENT_ADDRESS;
2235         else if (attr == &dev_attr_conn_persistent_port.attr)
2236                 param = ISCSI_PARAM_PERSISTENT_PORT;
2237         else if (attr == &dev_attr_conn_ping_tmo.attr)
2238                 param = ISCSI_PARAM_PING_TMO;
2239         else if (attr == &dev_attr_conn_recv_tmo.attr)
2240                 param = ISCSI_PARAM_RECV_TMO;
2241         else {
2242                 WARN_ONCE(1, "Invalid conn attr");
2243                 return 0;
2244         }
2245
2246         return t->attr_is_visible(ISCSI_PARAM, param);
2247 }
2248
2249 static struct attribute_group iscsi_conn_group = {
2250         .attrs = iscsi_conn_attrs,
2251         .is_visible = iscsi_conn_attr_is_visible,
2252 };
2253
2254 /*
2255  * iSCSI session attrs
2256  */
2257 #define iscsi_session_attr_show(param, perm)                            \
2258 static ssize_t                                                          \
2259 show_session_param_##param(struct device *dev,                          \
2260                            struct device_attribute *attr, char *buf)    \
2261 {                                                                       \
2262         struct iscsi_cls_session *session =                             \
2263                 iscsi_dev_to_session(dev->parent);                      \
2264         struct iscsi_transport *t = session->transport;                 \
2265                                                                         \
2266         if (perm && !capable(CAP_SYS_ADMIN))                            \
2267                 return -EACCES;                                         \
2268         return t->get_session_param(session, param, buf);               \
2269 }
2270
2271 #define iscsi_session_attr(field, param, perm)                          \
2272         iscsi_session_attr_show(param, perm)                            \
2273 static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
2274                         NULL);
2275 iscsi_session_attr(targetname, ISCSI_PARAM_TARGET_NAME, 0);
2276 iscsi_session_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN, 0);
2277 iscsi_session_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T, 0);
2278 iscsi_session_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN, 0);
2279 iscsi_session_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST, 0);
2280 iscsi_session_attr(max_burst_len, ISCSI_PARAM_MAX_BURST, 0);
2281 iscsi_session_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN, 0);
2282 iscsi_session_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN, 0);
2283 iscsi_session_attr(erl, ISCSI_PARAM_ERL, 0);
2284 iscsi_session_attr(tpgt, ISCSI_PARAM_TPGT, 0);
2285 iscsi_session_attr(username, ISCSI_PARAM_USERNAME, 1);
2286 iscsi_session_attr(username_in, ISCSI_PARAM_USERNAME_IN, 1);
2287 iscsi_session_attr(password, ISCSI_PARAM_PASSWORD, 1);
2288 iscsi_session_attr(password_in, ISCSI_PARAM_PASSWORD_IN, 1);
2289 iscsi_session_attr(fast_abort, ISCSI_PARAM_FAST_ABORT, 0);
2290 iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0);
2291 iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0);
2292 iscsi_session_attr(tgt_reset_tmo, ISCSI_PARAM_TGT_RESET_TMO, 0);
2293 iscsi_session_attr(ifacename, ISCSI_PARAM_IFACE_NAME, 0);
2294 iscsi_session_attr(initiatorname, ISCSI_PARAM_INITIATOR_NAME, 0);
2295 iscsi_session_attr(targetalias, ISCSI_PARAM_TARGET_ALIAS, 0);
2296
2297 static ssize_t
2298 show_priv_session_state(struct device *dev, struct device_attribute *attr,
2299                         char *buf)
2300 {
2301         struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
2302         return sprintf(buf, "%s\n", iscsi_session_state_name(session->state));
2303 }
2304 static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
2305                         NULL);
2306
2307 #define iscsi_priv_session_attr_show(field, format)                     \
2308 static ssize_t                                                          \
2309 show_priv_session_##field(struct device *dev,                           \
2310                           struct device_attribute *attr, char *buf)     \
2311 {                                                                       \
2312         struct iscsi_cls_session *session =                             \
2313                         iscsi_dev_to_session(dev->parent);              \
2314         if (session->field == -1)                                       \
2315                 return sprintf(buf, "off\n");                           \
2316         return sprintf(buf, format"\n", session->field);                \
2317 }
2318
2319 #define iscsi_priv_session_attr_store(field)                            \
2320 static ssize_t                                                          \
2321 store_priv_session_##field(struct device *dev,                          \
2322                            struct device_attribute *attr,               \
2323                            const char *buf, size_t count)               \
2324 {                                                                       \
2325         int val;                                                        \
2326         char *cp;                                                       \
2327         struct iscsi_cls_session *session =                             \
2328                 iscsi_dev_to_session(dev->parent);                      \
2329         if ((session->state == ISCSI_SESSION_FREE) ||                   \
2330             (session->state == ISCSI_SESSION_FAILED))                   \
2331                 return -EBUSY;                                          \
2332         if (strncmp(buf, "off", 3) == 0)                                \
2333                 session->field = -1;                                    \
2334         else {                                                          \
2335                 val = simple_strtoul(buf, &cp, 0);                      \
2336                 if (*cp != '\0' && *cp != '\n')                         \
2337                         return -EINVAL;                                 \
2338                 session->field = val;                                   \
2339         }                                                               \
2340         return count;                                                   \
2341 }
2342
2343 #define iscsi_priv_session_rw_attr(field, format)                       \
2344         iscsi_priv_session_attr_show(field, format)                     \
2345         iscsi_priv_session_attr_store(field)                            \
2346 static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO | S_IWUSR,            \
2347                         show_priv_session_##field,                      \
2348                         store_priv_session_##field)
2349 iscsi_priv_session_rw_attr(recovery_tmo, "%d");
2350
2351 static struct attribute *iscsi_session_attrs[] = {
2352         &dev_attr_sess_initial_r2t.attr,
2353         &dev_attr_sess_max_outstanding_r2t.attr,
2354         &dev_attr_sess_immediate_data.attr,
2355         &dev_attr_sess_first_burst_len.attr,
2356         &dev_attr_sess_max_burst_len.attr,
2357         &dev_attr_sess_data_pdu_in_order.attr,
2358         &dev_attr_sess_data_seq_in_order.attr,
2359         &dev_attr_sess_erl.attr,
2360         &dev_attr_sess_targetname.attr,
2361         &dev_attr_sess_tpgt.attr,
2362         &dev_attr_sess_password.attr,
2363         &dev_attr_sess_password_in.attr,
2364         &dev_attr_sess_username.attr,
2365         &dev_attr_sess_username_in.attr,
2366         &dev_attr_sess_fast_abort.attr,
2367         &dev_attr_sess_abort_tmo.attr,
2368         &dev_attr_sess_lu_reset_tmo.attr,
2369         &dev_attr_sess_tgt_reset_tmo.attr,
2370         &dev_attr_sess_ifacename.attr,
2371         &dev_attr_sess_initiatorname.attr,
2372         &dev_attr_sess_targetalias.attr,
2373         &dev_attr_priv_sess_recovery_tmo.attr,
2374         &dev_attr_priv_sess_state.attr,
2375         NULL,
2376 };
2377
2378 static mode_t iscsi_session_attr_is_visible(struct kobject *kobj,
2379                                             struct attribute *attr, int i)
2380 {
2381         struct device *cdev = container_of(kobj, struct device, kobj);
2382         struct iscsi_cls_session *session = transport_class_to_session(cdev);
2383         struct iscsi_transport *t = session->transport;
2384         int param;
2385
2386         if (attr == &dev_attr_sess_initial_r2t.attr)
2387                 param = ISCSI_PARAM_INITIAL_R2T_EN;
2388         else if (attr == &dev_attr_sess_max_outstanding_r2t.attr)
2389                 param = ISCSI_PARAM_MAX_R2T;
2390         else if (attr == &dev_attr_sess_immediate_data.attr)
2391                 param = ISCSI_PARAM_IMM_DATA_EN;
2392         else if (attr == &dev_attr_sess_first_burst_len.attr)
2393                 param = ISCSI_PARAM_FIRST_BURST;
2394         else if (attr == &dev_attr_sess_max_burst_len.attr)
2395                 param = ISCSI_PARAM_MAX_BURST;
2396         else if (attr == &dev_attr_sess_data_pdu_in_order.attr)
2397                 param = ISCSI_PARAM_PDU_INORDER_EN;
2398         else if (attr == &dev_attr_sess_data_seq_in_order.attr)
2399                 param = ISCSI_PARAM_DATASEQ_INORDER_EN;
2400         else if (attr == &dev_attr_sess_erl.attr)
2401                 param = ISCSI_PARAM_ERL;
2402         else if (attr == &dev_attr_sess_targetname.attr)
2403                 param = ISCSI_PARAM_TARGET_NAME;
2404         else if (attr == &dev_attr_sess_tpgt.attr)
2405                 param = ISCSI_PARAM_TPGT;
2406         else if (attr == &dev_attr_sess_password.attr)
2407                 param = ISCSI_PARAM_USERNAME;
2408         else if (attr == &dev_attr_sess_password_in.attr)
2409                 param = ISCSI_PARAM_USERNAME_IN;
2410         else if (attr == &dev_attr_sess_username.attr)
2411                 param = ISCSI_PARAM_PASSWORD;
2412         else if (attr == &dev_attr_sess_username_in.attr)
2413                 param = ISCSI_PARAM_PASSWORD_IN;
2414         else if (attr == &dev_attr_sess_fast_abort.attr)
2415                 param = ISCSI_PARAM_FAST_ABORT;
2416         else if (attr == &dev_attr_sess_abort_tmo.attr)
2417                 param = ISCSI_PARAM_ABORT_TMO;
2418         else if (attr == &dev_attr_sess_lu_reset_tmo.attr)
2419                 param = ISCSI_PARAM_LU_RESET_TMO;
2420         else if (attr == &dev_attr_sess_tgt_reset_tmo.attr)
2421                 param = ISCSI_PARAM_TGT_RESET_TMO;
2422         else if (attr == &dev_attr_sess_ifacename.attr)
2423                 param = ISCSI_PARAM_IFACE_NAME;
2424         else if (attr == &dev_attr_sess_initiatorname.attr)
2425                 param = ISCSI_PARAM_INITIATOR_NAME;
2426         else if (attr == &dev_attr_sess_targetalias.attr)
2427                 param = ISCSI_PARAM_TARGET_ALIAS;
2428         else if (attr == &dev_attr_priv_sess_recovery_tmo.attr)
2429                 return S_IRUGO | S_IWUSR;
2430         else if (attr == &dev_attr_priv_sess_state.attr)
2431                 return S_IRUGO;
2432         else {
2433                 WARN_ONCE(1, "Invalid session attr");
2434                 return 0;
2435         }
2436
2437         return t->attr_is_visible(ISCSI_PARAM, param);
2438 }
2439
2440 static struct attribute_group iscsi_session_group = {
2441         .attrs = iscsi_session_attrs,
2442         .is_visible = iscsi_session_attr_is_visible,
2443 };
2444
2445 /*
2446  * iSCSI host attrs
2447  */
2448 #define iscsi_host_attr_show(param)                                     \
2449 static ssize_t                                                          \
2450 show_host_param_##param(struct device *dev,                             \
2451                         struct device_attribute *attr, char *buf)       \
2452 {                                                                       \
2453         struct Scsi_Host *shost = transport_class_to_shost(dev);        \
2454         struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
2455         return priv->iscsi_transport->get_host_param(shost, param, buf); \
2456 }
2457
2458 #define iscsi_host_attr(field, param)                                   \
2459         iscsi_host_attr_show(param)                                     \
2460 static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param,  \
2461                         NULL);
2462
2463 iscsi_host_attr(netdev, ISCSI_HOST_PARAM_NETDEV_NAME);
2464 iscsi_host_attr(hwaddress, ISCSI_HOST_PARAM_HWADDRESS);
2465 iscsi_host_attr(ipaddress, ISCSI_HOST_PARAM_IPADDRESS);
2466 iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME);
2467
2468 static struct attribute *iscsi_host_attrs[] = {
2469         &dev_attr_host_netdev.attr,
2470         &dev_attr_host_hwaddress.attr,
2471         &dev_attr_host_ipaddress.attr,
2472         &dev_attr_host_initiatorname.attr,
2473         NULL,
2474 };
2475
2476 static mode_t iscsi_host_attr_is_visible(struct kobject *kobj,
2477                                          struct attribute *attr, int i)
2478 {
2479         struct device *cdev = container_of(kobj, struct device, kobj);
2480         struct Scsi_Host *shost = transport_class_to_shost(cdev);
2481         struct iscsi_internal *priv = to_iscsi_internal(shost->transportt);
2482         int param;
2483
2484         if (attr == &dev_attr_host_netdev.attr)
2485                 param = ISCSI_HOST_PARAM_NETDEV_NAME;
2486         else if (attr == &dev_attr_host_hwaddress.attr)
2487                 param = ISCSI_HOST_PARAM_HWADDRESS;
2488         else if (attr == &dev_attr_host_ipaddress.attr)
2489                 param = ISCSI_HOST_PARAM_IPADDRESS;
2490         else if (attr == &dev_attr_host_initiatorname.attr)
2491                 param = ISCSI_HOST_PARAM_INITIATOR_NAME;
2492         else {
2493                 WARN_ONCE(1, "Invalid host attr");
2494                 return 0;
2495         }
2496
2497         return priv->iscsi_transport->attr_is_visible(ISCSI_HOST_PARAM, param);
2498 }
2499
2500 static struct attribute_group iscsi_host_group = {
2501         .attrs = iscsi_host_attrs,
2502         .is_visible = iscsi_host_attr_is_visible,
2503 };
2504
2505 static int iscsi_session_match(struct attribute_container *cont,
2506                            struct device *dev)
2507 {
2508         struct iscsi_cls_session *session;
2509         struct Scsi_Host *shost;
2510         struct iscsi_internal *priv;
2511
2512         if (!iscsi_is_session_dev(dev))
2513                 return 0;
2514
2515         session = iscsi_dev_to_session(dev);
2516         shost = iscsi_session_to_shost(session);
2517         if (!shost->transportt)
2518                 return 0;
2519
2520         priv = to_iscsi_internal(shost->transportt);
2521         if (priv->session_cont.ac.class != &iscsi_session_class.class)
2522                 return 0;
2523
2524         return &priv->session_cont.ac == cont;
2525 }
2526
2527 static int iscsi_conn_match(struct attribute_container *cont,
2528                            struct device *dev)
2529 {
2530         struct iscsi_cls_session *session;
2531         struct iscsi_cls_conn *conn;
2532         struct Scsi_Host *shost;
2533         struct iscsi_internal *priv;
2534
2535         if (!iscsi_is_conn_dev(dev))
2536                 return 0;
2537
2538         conn = iscsi_dev_to_conn(dev);
2539         session = iscsi_dev_to_session(conn->dev.parent);
2540         shost = iscsi_session_to_shost(session);
2541
2542         if (!shost->transportt)
2543                 return 0;
2544
2545         priv = to_iscsi_internal(shost->transportt);
2546         if (priv->conn_cont.ac.class != &iscsi_connection_class.class)
2547                 return 0;
2548
2549         return &priv->conn_cont.ac == cont;
2550 }
2551
2552 static int iscsi_host_match(struct attribute_container *cont,
2553                             struct device *dev)
2554 {
2555         struct Scsi_Host *shost;
2556         struct iscsi_internal *priv;
2557
2558         if (!scsi_is_host_device(dev))
2559                 return 0;
2560
2561         shost = dev_to_shost(dev);
2562         if (!shost->transportt  ||
2563             shost->transportt->host_attrs.ac.class != &iscsi_host_class.class)
2564                 return 0;
2565
2566         priv = to_iscsi_internal(shost->transportt);
2567         return &priv->t.host_attrs.ac == cont;
2568 }
2569
2570 struct scsi_transport_template *
2571 iscsi_register_transport(struct iscsi_transport *tt)
2572 {
2573         struct iscsi_internal *priv;
2574         unsigned long flags;
2575         int err;
2576
2577         BUG_ON(!tt);
2578
2579         priv = iscsi_if_transport_lookup(tt);
2580         if (priv)
2581                 return NULL;
2582
2583         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
2584         if (!priv)
2585                 return NULL;
2586         INIT_LIST_HEAD(&priv->list);
2587         priv->iscsi_transport = tt;
2588         priv->t.user_scan = iscsi_user_scan;
2589         priv->t.create_work_queue = 1;
2590
2591         priv->dev.class = &iscsi_transport_class;
2592         dev_set_name(&priv->dev, "%s", tt->name);
2593         err = device_register(&priv->dev);
2594         if (err)
2595                 goto free_priv;
2596
2597         err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group);
2598         if (err)
2599                 goto unregister_dev;
2600
2601         /* host parameters */
2602         priv->t.host_attrs.ac.class = &iscsi_host_class.class;
2603         priv->t.host_attrs.ac.match = iscsi_host_match;
2604         priv->t.host_attrs.ac.grp = &iscsi_host_group;
2605         priv->t.host_size = sizeof(struct iscsi_cls_host);
2606         transport_container_register(&priv->t.host_attrs);
2607
2608         /* connection parameters */
2609         priv->conn_cont.ac.class = &iscsi_connection_class.class;
2610         priv->conn_cont.ac.match = iscsi_conn_match;
2611         priv->conn_cont.ac.grp = &iscsi_conn_group;
2612         transport_container_register(&priv->conn_cont);
2613
2614         /* session parameters */
2615         priv->session_cont.ac.class = &iscsi_session_class.class;
2616         priv->session_cont.ac.match = iscsi_session_match;
2617         priv->session_cont.ac.grp = &iscsi_session_group;
2618         transport_container_register(&priv->session_cont);
2619
2620         spin_lock_irqsave(&iscsi_transport_lock, flags);
2621         list_add(&priv->list, &iscsi_transports);
2622         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
2623
2624         printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
2625         return &priv->t;
2626
2627 unregister_dev:
2628         device_unregister(&priv->dev);
2629         return NULL;
2630 free_priv:
2631         kfree(priv);
2632         return NULL;
2633 }
2634 EXPORT_SYMBOL_GPL(iscsi_register_transport);
2635
2636 int iscsi_unregister_transport(struct iscsi_transport *tt)
2637 {
2638         struct iscsi_internal *priv;
2639         unsigned long flags;
2640
2641         BUG_ON(!tt);
2642
2643         mutex_lock(&rx_queue_mutex);
2644
2645         priv = iscsi_if_transport_lookup(tt);
2646         BUG_ON (!priv);
2647
2648         spin_lock_irqsave(&iscsi_transport_lock, flags);
2649         list_del(&priv->list);
2650         spin_unlock_irqrestore(&iscsi_transport_lock, flags);
2651
2652         transport_container_unregister(&priv->conn_cont);
2653         transport_container_unregister(&priv->session_cont);
2654         transport_container_unregister(&priv->t.host_attrs);
2655
2656         sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group);
2657         device_unregister(&priv->dev);
2658         mutex_unlock(&rx_queue_mutex);
2659
2660         return 0;
2661 }
2662 EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
2663
2664 static __init int iscsi_transport_init(void)
2665 {
2666         int err;
2667
2668         printk(KERN_INFO "Loading iSCSI transport class v%s.\n",
2669                 ISCSI_TRANSPORT_VERSION);
2670
2671         atomic_set(&iscsi_session_nr, 0);
2672
2673         err = class_register(&iscsi_transport_class);
2674         if (err)
2675                 return err;
2676
2677         err = class_register(&iscsi_endpoint_class);
2678         if (err)
2679                 goto unregister_transport_class;
2680
2681         err = class_register(&iscsi_iface_class);
2682         if (err)
2683                 goto unregister_endpoint_class;
2684
2685         err = transport_class_register(&iscsi_host_class);
2686         if (err)
2687                 goto unregister_iface_class;
2688
2689         err = transport_class_register(&iscsi_connection_class);
2690         if (err)
2691                 goto unregister_host_class;
2692
2693         err = transport_class_register(&iscsi_session_class);
2694         if (err)
2695                 goto unregister_conn_class;
2696
2697         nls = netlink_kernel_create(&init_net, NETLINK_ISCSI, 1, iscsi_if_rx,
2698                                     NULL, THIS_MODULE);
2699         if (!nls) {
2700                 err = -ENOBUFS;
2701                 goto unregister_session_class;
2702         }
2703
2704         iscsi_eh_timer_workq = create_singlethread_workqueue("iscsi_eh");
2705         if (!iscsi_eh_timer_workq)
2706                 goto release_nls;
2707
2708         return 0;
2709
2710 release_nls:
2711         netlink_kernel_release(nls);
2712 unregister_session_class:
2713         transport_class_unregister(&iscsi_session_class);
2714 unregister_conn_class:
2715         transport_class_unregister(&iscsi_connection_class);
2716 unregister_host_class:
2717         transport_class_unregister(&iscsi_host_class);
2718 unregister_iface_class:
2719         class_unregister(&iscsi_iface_class);
2720 unregister_endpoint_class:
2721         class_unregister(&iscsi_endpoint_class);
2722 unregister_transport_class:
2723         class_unregister(&iscsi_transport_class);
2724         return err;
2725 }
2726
2727 static void __exit iscsi_transport_exit(void)
2728 {
2729         destroy_workqueue(iscsi_eh_timer_workq);
2730         netlink_kernel_release(nls);
2731         transport_class_unregister(&iscsi_connection_class);
2732         transport_class_unregister(&iscsi_session_class);
2733         transport_class_unregister(&iscsi_host_class);
2734         class_unregister(&iscsi_endpoint_class);
2735         class_unregister(&iscsi_iface_class);
2736         class_unregister(&iscsi_transport_class);
2737 }
2738
2739 module_init(iscsi_transport_init);
2740 module_exit(iscsi_transport_exit);
2741
2742 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
2743               "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
2744               "Alex Aizman <itn780@yahoo.com>");
2745 MODULE_DESCRIPTION("iSCSI Transport Interface");
2746 MODULE_LICENSE("GPL");
2747 MODULE_VERSION(ISCSI_TRANSPORT_VERSION);
2748 MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_ISCSI);