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 <net/tcp.h> 26 #include <scsi/scsi.h> 27 #include <scsi/scsi_host.h> 28 #include <scsi/scsi_device.h> 29 #include <scsi/scsi_transport.h> 30 #include <scsi/scsi_transport_iscsi.h> 31 #include <scsi/iscsi_if.h> 32 33 #define ISCSI_SESSION_ATTRS 21 34 #define ISCSI_CONN_ATTRS 13 35 #define ISCSI_HOST_ATTRS 4 36 37 #define ISCSI_TRANSPORT_VERSION "2.0-870" 38 39 struct iscsi_internal { 40 int daemon_pid; 41 struct scsi_transport_template t; 42 struct iscsi_transport *iscsi_transport; 43 struct list_head list; 44 struct device dev; 45 46 struct device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1]; 47 struct transport_container conn_cont; 48 struct device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1]; 49 struct transport_container session_cont; 50 struct device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1]; 51 }; 52 53 static atomic_t iscsi_session_nr; /* sysfs session id for next new session */ 54 static struct workqueue_struct *iscsi_eh_timer_workq; 55 56 /* 57 * list of registered transports and lock that must 58 * be held while accessing list. The iscsi_transport_lock must 59 * be acquired after the rx_queue_mutex. 60 */ 61 static LIST_HEAD(iscsi_transports); 62 static DEFINE_SPINLOCK(iscsi_transport_lock); 63 64 #define to_iscsi_internal(tmpl) \ 65 container_of(tmpl, struct iscsi_internal, t) 66 67 #define dev_to_iscsi_internal(_dev) \ 68 container_of(_dev, struct iscsi_internal, dev) 69 70 static void iscsi_transport_release(struct device *dev) 71 { 72 struct iscsi_internal *priv = dev_to_iscsi_internal(dev); 73 kfree(priv); 74 } 75 76 /* 77 * iscsi_transport_class represents the iscsi_transports that are 78 * registered. 79 */ 80 static struct class iscsi_transport_class = { 81 .name = "iscsi_transport", 82 .dev_release = iscsi_transport_release, 83 }; 84 85 static ssize_t 86 show_transport_handle(struct device *dev, struct device_attribute *attr, 87 char *buf) 88 { 89 struct iscsi_internal *priv = dev_to_iscsi_internal(dev); 90 return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport)); 91 } 92 static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL); 93 94 #define show_transport_attr(name, format) \ 95 static ssize_t \ 96 show_transport_##name(struct device *dev, \ 97 struct device_attribute *attr,char *buf) \ 98 { \ 99 struct iscsi_internal *priv = dev_to_iscsi_internal(dev); \ 100 return sprintf(buf, format"\n", priv->iscsi_transport->name); \ 101 } \ 102 static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL); 103 104 show_transport_attr(caps, "0x%x"); 105 106 static struct attribute *iscsi_transport_attrs[] = { 107 &dev_attr_handle.attr, 108 &dev_attr_caps.attr, 109 NULL, 110 }; 111 112 static struct attribute_group iscsi_transport_group = { 113 .attrs = iscsi_transport_attrs, 114 }; 115 116 /* 117 * iSCSI endpoint attrs 118 */ 119 #define iscsi_dev_to_endpoint(_dev) \ 120 container_of(_dev, struct iscsi_endpoint, dev) 121 122 #define ISCSI_ATTR(_prefix,_name,_mode,_show,_store) \ 123 struct device_attribute dev_attr_##_prefix##_##_name = \ 124 __ATTR(_name,_mode,_show,_store) 125 126 static void iscsi_endpoint_release(struct device *dev) 127 { 128 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev); 129 kfree(ep); 130 } 131 132 static struct class iscsi_endpoint_class = { 133 .name = "iscsi_endpoint", 134 .dev_release = iscsi_endpoint_release, 135 }; 136 137 static ssize_t 138 show_ep_handle(struct device *dev, struct device_attribute *attr, char *buf) 139 { 140 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev); 141 return sprintf(buf, "%llu\n", (unsigned long long) ep->id); 142 } 143 static ISCSI_ATTR(ep, handle, S_IRUGO, show_ep_handle, NULL); 144 145 static struct attribute *iscsi_endpoint_attrs[] = { 146 &dev_attr_ep_handle.attr, 147 NULL, 148 }; 149 150 static struct attribute_group iscsi_endpoint_group = { 151 .attrs = iscsi_endpoint_attrs, 152 }; 153 154 #define ISCSI_MAX_EPID -1 155 156 static int iscsi_match_epid(struct device *dev, void *data) 157 { 158 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev); 159 uint64_t *epid = (uint64_t *) data; 160 161 return *epid == ep->id; 162 } 163 164 struct iscsi_endpoint * 165 iscsi_create_endpoint(int dd_size) 166 { 167 struct device *dev; 168 struct iscsi_endpoint *ep; 169 uint64_t id; 170 int err; 171 172 for (id = 1; id < ISCSI_MAX_EPID; id++) { 173 dev = class_find_device(&iscsi_endpoint_class, NULL, &id, 174 iscsi_match_epid); 175 if (!dev) 176 break; 177 } 178 if (id == ISCSI_MAX_EPID) { 179 printk(KERN_ERR "Too many connections. Max supported %u\n", 180 ISCSI_MAX_EPID - 1); 181 return NULL; 182 } 183 184 ep = kzalloc(sizeof(*ep) + dd_size, GFP_KERNEL); 185 if (!ep) 186 return NULL; 187 188 ep->id = id; 189 ep->dev.class = &iscsi_endpoint_class; 190 dev_set_name(&ep->dev, "ep-%llu", (unsigned long long) id); 191 err = device_register(&ep->dev); 192 if (err) 193 goto free_ep; 194 195 err = sysfs_create_group(&ep->dev.kobj, &iscsi_endpoint_group); 196 if (err) 197 goto unregister_dev; 198 199 if (dd_size) 200 ep->dd_data = &ep[1]; 201 return ep; 202 203 unregister_dev: 204 device_unregister(&ep->dev); 205 return NULL; 206 207 free_ep: 208 kfree(ep); 209 return NULL; 210 } 211 EXPORT_SYMBOL_GPL(iscsi_create_endpoint); 212 213 void iscsi_destroy_endpoint(struct iscsi_endpoint *ep) 214 { 215 sysfs_remove_group(&ep->dev.kobj, &iscsi_endpoint_group); 216 device_unregister(&ep->dev); 217 } 218 EXPORT_SYMBOL_GPL(iscsi_destroy_endpoint); 219 220 struct iscsi_endpoint *iscsi_lookup_endpoint(u64 handle) 221 { 222 struct iscsi_endpoint *ep; 223 struct device *dev; 224 225 dev = class_find_device(&iscsi_endpoint_class, NULL, &handle, 226 iscsi_match_epid); 227 if (!dev) 228 return NULL; 229 230 ep = iscsi_dev_to_endpoint(dev); 231 /* 232 * we can drop this now because the interface will prevent 233 * removals and lookups from racing. 234 */ 235 put_device(dev); 236 return ep; 237 } 238 EXPORT_SYMBOL_GPL(iscsi_lookup_endpoint); 239 240 static int iscsi_setup_host(struct transport_container *tc, struct device *dev, 241 struct device *cdev) 242 { 243 struct Scsi_Host *shost = dev_to_shost(dev); 244 struct iscsi_cls_host *ihost = shost->shost_data; 245 246 memset(ihost, 0, sizeof(*ihost)); 247 atomic_set(&ihost->nr_scans, 0); 248 mutex_init(&ihost->mutex); 249 return 0; 250 } 251 252 static DECLARE_TRANSPORT_CLASS(iscsi_host_class, 253 "iscsi_host", 254 iscsi_setup_host, 255 NULL, 256 NULL); 257 258 static DECLARE_TRANSPORT_CLASS(iscsi_session_class, 259 "iscsi_session", 260 NULL, 261 NULL, 262 NULL); 263 264 static DECLARE_TRANSPORT_CLASS(iscsi_connection_class, 265 "iscsi_connection", 266 NULL, 267 NULL, 268 NULL); 269 270 static struct sock *nls; 271 static DEFINE_MUTEX(rx_queue_mutex); 272 273 static LIST_HEAD(sesslist); 274 static DEFINE_SPINLOCK(sesslock); 275 static LIST_HEAD(connlist); 276 static DEFINE_SPINLOCK(connlock); 277 278 static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn *conn) 279 { 280 struct iscsi_cls_session *sess = iscsi_dev_to_session(conn->dev.parent); 281 return sess->sid; 282 } 283 284 /* 285 * Returns the matching session to a given sid 286 */ 287 static struct iscsi_cls_session *iscsi_session_lookup(uint32_t sid) 288 { 289 unsigned long flags; 290 struct iscsi_cls_session *sess; 291 292 spin_lock_irqsave(&sesslock, flags); 293 list_for_each_entry(sess, &sesslist, sess_list) { 294 if (sess->sid == sid) { 295 spin_unlock_irqrestore(&sesslock, flags); 296 return sess; 297 } 298 } 299 spin_unlock_irqrestore(&sesslock, flags); 300 return NULL; 301 } 302 303 /* 304 * Returns the matching connection to a given sid / cid tuple 305 */ 306 static struct iscsi_cls_conn *iscsi_conn_lookup(uint32_t sid, uint32_t cid) 307 { 308 unsigned long flags; 309 struct iscsi_cls_conn *conn; 310 311 spin_lock_irqsave(&connlock, flags); 312 list_for_each_entry(conn, &connlist, conn_list) { 313 if ((conn->cid == cid) && (iscsi_conn_get_sid(conn) == sid)) { 314 spin_unlock_irqrestore(&connlock, flags); 315 return conn; 316 } 317 } 318 spin_unlock_irqrestore(&connlock, flags); 319 return NULL; 320 } 321 322 /* 323 * The following functions can be used by LLDs that allocate 324 * their own scsi_hosts or by software iscsi LLDs 325 */ 326 static struct { 327 int value; 328 char *name; 329 } iscsi_session_state_names[] = { 330 { ISCSI_SESSION_LOGGED_IN, "LOGGED_IN" }, 331 { ISCSI_SESSION_FAILED, "FAILED" }, 332 { ISCSI_SESSION_FREE, "FREE" }, 333 }; 334 335 static const char *iscsi_session_state_name(int state) 336 { 337 int i; 338 char *name = NULL; 339 340 for (i = 0; i < ARRAY_SIZE(iscsi_session_state_names); i++) { 341 if (iscsi_session_state_names[i].value == state) { 342 name = iscsi_session_state_names[i].name; 343 break; 344 } 345 } 346 return name; 347 } 348 349 int iscsi_session_chkready(struct iscsi_cls_session *session) 350 { 351 unsigned long flags; 352 int err; 353 354 spin_lock_irqsave(&session->lock, flags); 355 switch (session->state) { 356 case ISCSI_SESSION_LOGGED_IN: 357 err = 0; 358 break; 359 case ISCSI_SESSION_FAILED: 360 err = DID_IMM_RETRY << 16; 361 break; 362 case ISCSI_SESSION_FREE: 363 err = DID_TRANSPORT_FAILFAST << 16; 364 break; 365 default: 366 err = DID_NO_CONNECT << 16; 367 break; 368 } 369 spin_unlock_irqrestore(&session->lock, flags); 370 return err; 371 } 372 EXPORT_SYMBOL_GPL(iscsi_session_chkready); 373 374 static void iscsi_session_release(struct device *dev) 375 { 376 struct iscsi_cls_session *session = iscsi_dev_to_session(dev); 377 struct Scsi_Host *shost; 378 379 shost = iscsi_session_to_shost(session); 380 scsi_host_put(shost); 381 kfree(session); 382 } 383 384 static int iscsi_is_session_dev(const struct device *dev) 385 { 386 return dev->release == iscsi_session_release; 387 } 388 389 static int iscsi_iter_session_fn(struct device *dev, void *data) 390 { 391 void (* fn) (struct iscsi_cls_session *) = data; 392 393 if (!iscsi_is_session_dev(dev)) 394 return 0; 395 fn(iscsi_dev_to_session(dev)); 396 return 0; 397 } 398 399 void iscsi_host_for_each_session(struct Scsi_Host *shost, 400 void (*fn)(struct iscsi_cls_session *)) 401 { 402 device_for_each_child(&shost->shost_gendev, fn, 403 iscsi_iter_session_fn); 404 } 405 EXPORT_SYMBOL_GPL(iscsi_host_for_each_session); 406 407 /** 408 * iscsi_scan_finished - helper to report when running scans are done 409 * @shost: scsi host 410 * @time: scan run time 411 * 412 * This function can be used by drives like qla4xxx to report to the scsi 413 * layer when the scans it kicked off at module load time are done. 414 */ 415 int iscsi_scan_finished(struct Scsi_Host *shost, unsigned long time) 416 { 417 struct iscsi_cls_host *ihost = shost->shost_data; 418 /* 419 * qla4xxx will have kicked off some session unblocks before calling 420 * scsi_scan_host, so just wait for them to complete. 421 */ 422 return !atomic_read(&ihost->nr_scans); 423 } 424 EXPORT_SYMBOL_GPL(iscsi_scan_finished); 425 426 struct iscsi_scan_data { 427 unsigned int channel; 428 unsigned int id; 429 unsigned int lun; 430 }; 431 432 static int iscsi_user_scan_session(struct device *dev, void *data) 433 { 434 struct iscsi_scan_data *scan_data = data; 435 struct iscsi_cls_session *session; 436 struct Scsi_Host *shost; 437 struct iscsi_cls_host *ihost; 438 unsigned long flags; 439 unsigned int id; 440 441 if (!iscsi_is_session_dev(dev)) 442 return 0; 443 444 session = iscsi_dev_to_session(dev); 445 shost = iscsi_session_to_shost(session); 446 ihost = shost->shost_data; 447 448 mutex_lock(&ihost->mutex); 449 spin_lock_irqsave(&session->lock, flags); 450 if (session->state != ISCSI_SESSION_LOGGED_IN) { 451 spin_unlock_irqrestore(&session->lock, flags); 452 mutex_unlock(&ihost->mutex); 453 return 0; 454 } 455 id = session->target_id; 456 spin_unlock_irqrestore(&session->lock, flags); 457 458 if (id != ISCSI_MAX_TARGET) { 459 if ((scan_data->channel == SCAN_WILD_CARD || 460 scan_data->channel == 0) && 461 (scan_data->id == SCAN_WILD_CARD || 462 scan_data->id == id)) 463 scsi_scan_target(&session->dev, 0, id, 464 scan_data->lun, 1); 465 } 466 mutex_unlock(&ihost->mutex); 467 return 0; 468 } 469 470 static int iscsi_user_scan(struct Scsi_Host *shost, uint channel, 471 uint id, uint lun) 472 { 473 struct iscsi_scan_data scan_data; 474 475 scan_data.channel = channel; 476 scan_data.id = id; 477 scan_data.lun = lun; 478 479 return device_for_each_child(&shost->shost_gendev, &scan_data, 480 iscsi_user_scan_session); 481 } 482 483 static void iscsi_scan_session(struct work_struct *work) 484 { 485 struct iscsi_cls_session *session = 486 container_of(work, struct iscsi_cls_session, scan_work); 487 struct Scsi_Host *shost = iscsi_session_to_shost(session); 488 struct iscsi_cls_host *ihost = shost->shost_data; 489 struct iscsi_scan_data scan_data; 490 491 scan_data.channel = 0; 492 scan_data.id = SCAN_WILD_CARD; 493 scan_data.lun = SCAN_WILD_CARD; 494 495 iscsi_user_scan_session(&session->dev, &scan_data); 496 atomic_dec(&ihost->nr_scans); 497 } 498 499 static void session_recovery_timedout(struct work_struct *work) 500 { 501 struct iscsi_cls_session *session = 502 container_of(work, struct iscsi_cls_session, 503 recovery_work.work); 504 unsigned long flags; 505 506 iscsi_cls_session_printk(KERN_INFO, session, 507 "session recovery timed out after %d secs\n", 508 session->recovery_tmo); 509 510 spin_lock_irqsave(&session->lock, flags); 511 switch (session->state) { 512 case ISCSI_SESSION_FAILED: 513 session->state = ISCSI_SESSION_FREE; 514 break; 515 case ISCSI_SESSION_LOGGED_IN: 516 case ISCSI_SESSION_FREE: 517 /* we raced with the unblock's flush */ 518 spin_unlock_irqrestore(&session->lock, flags); 519 return; 520 } 521 spin_unlock_irqrestore(&session->lock, flags); 522 523 if (session->transport->session_recovery_timedout) 524 session->transport->session_recovery_timedout(session); 525 526 scsi_target_unblock(&session->dev); 527 } 528 529 static void __iscsi_unblock_session(struct work_struct *work) 530 { 531 struct iscsi_cls_session *session = 532 container_of(work, struct iscsi_cls_session, 533 unblock_work); 534 struct Scsi_Host *shost = iscsi_session_to_shost(session); 535 struct iscsi_cls_host *ihost = shost->shost_data; 536 unsigned long flags; 537 538 /* 539 * The recovery and unblock work get run from the same workqueue, 540 * so try to cancel it if it was going to run after this unblock. 541 */ 542 cancel_delayed_work(&session->recovery_work); 543 spin_lock_irqsave(&session->lock, flags); 544 session->state = ISCSI_SESSION_LOGGED_IN; 545 spin_unlock_irqrestore(&session->lock, flags); 546 /* start IO */ 547 scsi_target_unblock(&session->dev); 548 /* 549 * Only do kernel scanning if the driver is properly hooked into 550 * the async scanning code (drivers like iscsi_tcp do login and 551 * scanning from userspace). 552 */ 553 if (shost->hostt->scan_finished) { 554 if (scsi_queue_work(shost, &session->scan_work)) 555 atomic_inc(&ihost->nr_scans); 556 } 557 } 558 559 /** 560 * iscsi_unblock_session - set a session as logged in and start IO. 561 * @session: iscsi session 562 * 563 * Mark a session as ready to accept IO. 564 */ 565 void iscsi_unblock_session(struct iscsi_cls_session *session) 566 { 567 queue_work(iscsi_eh_timer_workq, &session->unblock_work); 568 /* 569 * make sure all the events have completed before tell the driver 570 * it is safe 571 */ 572 flush_workqueue(iscsi_eh_timer_workq); 573 } 574 EXPORT_SYMBOL_GPL(iscsi_unblock_session); 575 576 static void __iscsi_block_session(struct work_struct *work) 577 { 578 struct iscsi_cls_session *session = 579 container_of(work, struct iscsi_cls_session, 580 block_work); 581 unsigned long flags; 582 583 spin_lock_irqsave(&session->lock, flags); 584 session->state = ISCSI_SESSION_FAILED; 585 spin_unlock_irqrestore(&session->lock, flags); 586 scsi_target_block(&session->dev); 587 queue_delayed_work(iscsi_eh_timer_workq, &session->recovery_work, 588 session->recovery_tmo * HZ); 589 } 590 591 void iscsi_block_session(struct iscsi_cls_session *session) 592 { 593 queue_work(iscsi_eh_timer_workq, &session->block_work); 594 } 595 EXPORT_SYMBOL_GPL(iscsi_block_session); 596 597 static void __iscsi_unbind_session(struct work_struct *work) 598 { 599 struct iscsi_cls_session *session = 600 container_of(work, struct iscsi_cls_session, 601 unbind_work); 602 struct Scsi_Host *shost = iscsi_session_to_shost(session); 603 struct iscsi_cls_host *ihost = shost->shost_data; 604 unsigned long flags; 605 606 /* Prevent new scans and make sure scanning is not in progress */ 607 mutex_lock(&ihost->mutex); 608 spin_lock_irqsave(&session->lock, flags); 609 if (session->target_id == ISCSI_MAX_TARGET) { 610 spin_unlock_irqrestore(&session->lock, flags); 611 mutex_unlock(&ihost->mutex); 612 return; 613 } 614 session->target_id = ISCSI_MAX_TARGET; 615 spin_unlock_irqrestore(&session->lock, flags); 616 mutex_unlock(&ihost->mutex); 617 618 scsi_remove_target(&session->dev); 619 iscsi_session_event(session, ISCSI_KEVENT_UNBIND_SESSION); 620 } 621 622 struct iscsi_cls_session * 623 iscsi_alloc_session(struct Scsi_Host *shost, struct iscsi_transport *transport, 624 int dd_size) 625 { 626 struct iscsi_cls_session *session; 627 628 session = kzalloc(sizeof(*session) + dd_size, 629 GFP_KERNEL); 630 if (!session) 631 return NULL; 632 633 session->transport = transport; 634 session->recovery_tmo = 120; 635 session->state = ISCSI_SESSION_FREE; 636 INIT_DELAYED_WORK(&session->recovery_work, session_recovery_timedout); 637 INIT_LIST_HEAD(&session->sess_list); 638 INIT_WORK(&session->unblock_work, __iscsi_unblock_session); 639 INIT_WORK(&session->block_work, __iscsi_block_session); 640 INIT_WORK(&session->unbind_work, __iscsi_unbind_session); 641 INIT_WORK(&session->scan_work, iscsi_scan_session); 642 spin_lock_init(&session->lock); 643 644 /* this is released in the dev's release function */ 645 scsi_host_get(shost); 646 session->dev.parent = &shost->shost_gendev; 647 session->dev.release = iscsi_session_release; 648 device_initialize(&session->dev); 649 if (dd_size) 650 session->dd_data = &session[1]; 651 return session; 652 } 653 EXPORT_SYMBOL_GPL(iscsi_alloc_session); 654 655 static int iscsi_get_next_target_id(struct device *dev, void *data) 656 { 657 struct iscsi_cls_session *session; 658 unsigned long flags; 659 int err = 0; 660 661 if (!iscsi_is_session_dev(dev)) 662 return 0; 663 664 session = iscsi_dev_to_session(dev); 665 spin_lock_irqsave(&session->lock, flags); 666 if (*((unsigned int *) data) == session->target_id) 667 err = -EEXIST; 668 spin_unlock_irqrestore(&session->lock, flags); 669 return err; 670 } 671 672 int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id) 673 { 674 struct Scsi_Host *shost = iscsi_session_to_shost(session); 675 struct iscsi_cls_host *ihost; 676 unsigned long flags; 677 unsigned int id = target_id; 678 int err; 679 680 ihost = shost->shost_data; 681 session->sid = atomic_add_return(1, &iscsi_session_nr); 682 683 if (id == ISCSI_MAX_TARGET) { 684 for (id = 0; id < ISCSI_MAX_TARGET; id++) { 685 err = device_for_each_child(&shost->shost_gendev, &id, 686 iscsi_get_next_target_id); 687 if (!err) 688 break; 689 } 690 691 if (id == ISCSI_MAX_TARGET) { 692 iscsi_cls_session_printk(KERN_ERR, session, 693 "Too many iscsi targets. Max " 694 "number of targets is %d.\n", 695 ISCSI_MAX_TARGET - 1); 696 goto release_host; 697 } 698 } 699 session->target_id = id; 700 701 dev_set_name(&session->dev, "session%u", session->sid); 702 err = device_add(&session->dev); 703 if (err) { 704 iscsi_cls_session_printk(KERN_ERR, session, 705 "could not register session's dev\n"); 706 goto release_host; 707 } 708 transport_register_device(&session->dev); 709 710 spin_lock_irqsave(&sesslock, flags); 711 list_add(&session->sess_list, &sesslist); 712 spin_unlock_irqrestore(&sesslock, flags); 713 714 iscsi_session_event(session, ISCSI_KEVENT_CREATE_SESSION); 715 return 0; 716 717 release_host: 718 scsi_host_put(shost); 719 return err; 720 } 721 EXPORT_SYMBOL_GPL(iscsi_add_session); 722 723 /** 724 * iscsi_create_session - create iscsi class session 725 * @shost: scsi host 726 * @transport: iscsi transport 727 * @dd_size: private driver data size 728 * @target_id: which target 729 * 730 * This can be called from a LLD or iscsi_transport. 731 */ 732 struct iscsi_cls_session * 733 iscsi_create_session(struct Scsi_Host *shost, struct iscsi_transport *transport, 734 int dd_size, unsigned int target_id) 735 { 736 struct iscsi_cls_session *session; 737 738 session = iscsi_alloc_session(shost, transport, dd_size); 739 if (!session) 740 return NULL; 741 742 if (iscsi_add_session(session, target_id)) { 743 iscsi_free_session(session); 744 return NULL; 745 } 746 return session; 747 } 748 EXPORT_SYMBOL_GPL(iscsi_create_session); 749 750 static void iscsi_conn_release(struct device *dev) 751 { 752 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev); 753 struct device *parent = conn->dev.parent; 754 755 kfree(conn); 756 put_device(parent); 757 } 758 759 static int iscsi_is_conn_dev(const struct device *dev) 760 { 761 return dev->release == iscsi_conn_release; 762 } 763 764 static int iscsi_iter_destroy_conn_fn(struct device *dev, void *data) 765 { 766 if (!iscsi_is_conn_dev(dev)) 767 return 0; 768 return iscsi_destroy_conn(iscsi_dev_to_conn(dev)); 769 } 770 771 void iscsi_remove_session(struct iscsi_cls_session *session) 772 { 773 struct Scsi_Host *shost = iscsi_session_to_shost(session); 774 unsigned long flags; 775 int err; 776 777 spin_lock_irqsave(&sesslock, flags); 778 list_del(&session->sess_list); 779 spin_unlock_irqrestore(&sesslock, flags); 780 781 /* make sure there are no blocks/unblocks queued */ 782 flush_workqueue(iscsi_eh_timer_workq); 783 /* make sure the timedout callout is not running */ 784 if (!cancel_delayed_work(&session->recovery_work)) 785 flush_workqueue(iscsi_eh_timer_workq); 786 /* 787 * If we are blocked let commands flow again. The lld or iscsi 788 * layer should set up the queuecommand to fail commands. 789 * We assume that LLD will not be calling block/unblock while 790 * removing the session. 791 */ 792 spin_lock_irqsave(&session->lock, flags); 793 session->state = ISCSI_SESSION_FREE; 794 spin_unlock_irqrestore(&session->lock, flags); 795 796 scsi_target_unblock(&session->dev); 797 /* flush running scans then delete devices */ 798 scsi_flush_work(shost); 799 __iscsi_unbind_session(&session->unbind_work); 800 801 /* hw iscsi may not have removed all connections from session */ 802 err = device_for_each_child(&session->dev, NULL, 803 iscsi_iter_destroy_conn_fn); 804 if (err) 805 iscsi_cls_session_printk(KERN_ERR, session, 806 "Could not delete all connections " 807 "for session. Error %d.\n", err); 808 809 transport_unregister_device(&session->dev); 810 device_del(&session->dev); 811 } 812 EXPORT_SYMBOL_GPL(iscsi_remove_session); 813 814 void iscsi_free_session(struct iscsi_cls_session *session) 815 { 816 iscsi_session_event(session, ISCSI_KEVENT_DESTROY_SESSION); 817 put_device(&session->dev); 818 } 819 EXPORT_SYMBOL_GPL(iscsi_free_session); 820 821 /** 822 * iscsi_destroy_session - destroy iscsi session 823 * @session: iscsi_session 824 * 825 * Can be called by a LLD or iscsi_transport. There must not be 826 * any running connections. 827 */ 828 int iscsi_destroy_session(struct iscsi_cls_session *session) 829 { 830 iscsi_remove_session(session); 831 iscsi_free_session(session); 832 return 0; 833 } 834 EXPORT_SYMBOL_GPL(iscsi_destroy_session); 835 836 /** 837 * iscsi_create_conn - create iscsi class connection 838 * @session: iscsi cls session 839 * @dd_size: private driver data size 840 * @cid: connection id 841 * 842 * This can be called from a LLD or iscsi_transport. The connection 843 * is child of the session so cid must be unique for all connections 844 * on the session. 845 * 846 * Since we do not support MCS, cid will normally be zero. In some cases 847 * for software iscsi we could be trying to preallocate a connection struct 848 * in which case there could be two connection structs and cid would be 849 * non-zero. 850 */ 851 struct iscsi_cls_conn * 852 iscsi_create_conn(struct iscsi_cls_session *session, int dd_size, uint32_t cid) 853 { 854 struct iscsi_transport *transport = session->transport; 855 struct iscsi_cls_conn *conn; 856 unsigned long flags; 857 int err; 858 859 conn = kzalloc(sizeof(*conn) + dd_size, GFP_KERNEL); 860 if (!conn) 861 return NULL; 862 if (dd_size) 863 conn->dd_data = &conn[1]; 864 865 INIT_LIST_HEAD(&conn->conn_list); 866 conn->transport = transport; 867 conn->cid = cid; 868 869 /* this is released in the dev's release function */ 870 if (!get_device(&session->dev)) 871 goto free_conn; 872 873 dev_set_name(&conn->dev, "connection%d:%u", session->sid, cid); 874 conn->dev.parent = &session->dev; 875 conn->dev.release = iscsi_conn_release; 876 err = device_register(&conn->dev); 877 if (err) { 878 iscsi_cls_session_printk(KERN_ERR, session, "could not " 879 "register connection's dev\n"); 880 goto release_parent_ref; 881 } 882 transport_register_device(&conn->dev); 883 884 spin_lock_irqsave(&connlock, flags); 885 list_add(&conn->conn_list, &connlist); 886 conn->active = 1; 887 spin_unlock_irqrestore(&connlock, flags); 888 return conn; 889 890 release_parent_ref: 891 put_device(&session->dev); 892 free_conn: 893 kfree(conn); 894 return NULL; 895 } 896 897 EXPORT_SYMBOL_GPL(iscsi_create_conn); 898 899 /** 900 * iscsi_destroy_conn - destroy iscsi class connection 901 * @conn: iscsi cls session 902 * 903 * This can be called from a LLD or iscsi_transport. 904 */ 905 int iscsi_destroy_conn(struct iscsi_cls_conn *conn) 906 { 907 unsigned long flags; 908 909 spin_lock_irqsave(&connlock, flags); 910 conn->active = 0; 911 list_del(&conn->conn_list); 912 spin_unlock_irqrestore(&connlock, flags); 913 914 transport_unregister_device(&conn->dev); 915 device_unregister(&conn->dev); 916 return 0; 917 } 918 EXPORT_SYMBOL_GPL(iscsi_destroy_conn); 919 920 /* 921 * iscsi interface functions 922 */ 923 static struct iscsi_internal * 924 iscsi_if_transport_lookup(struct iscsi_transport *tt) 925 { 926 struct iscsi_internal *priv; 927 unsigned long flags; 928 929 spin_lock_irqsave(&iscsi_transport_lock, flags); 930 list_for_each_entry(priv, &iscsi_transports, list) { 931 if (tt == priv->iscsi_transport) { 932 spin_unlock_irqrestore(&iscsi_transport_lock, flags); 933 return priv; 934 } 935 } 936 spin_unlock_irqrestore(&iscsi_transport_lock, flags); 937 return NULL; 938 } 939 940 static int 941 iscsi_broadcast_skb(struct sk_buff *skb, gfp_t gfp) 942 { 943 return netlink_broadcast(nls, skb, 0, 1, gfp); 944 } 945 946 static int 947 iscsi_unicast_skb(struct sk_buff *skb, int pid) 948 { 949 int rc; 950 951 rc = netlink_unicast(nls, skb, pid, MSG_DONTWAIT); 952 if (rc < 0) { 953 printk(KERN_ERR "iscsi: can not unicast skb (%d)\n", rc); 954 return rc; 955 } 956 957 return 0; 958 } 959 960 int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr, 961 char *data, uint32_t data_size) 962 { 963 struct nlmsghdr *nlh; 964 struct sk_buff *skb; 965 struct iscsi_uevent *ev; 966 char *pdu; 967 struct iscsi_internal *priv; 968 int len = NLMSG_SPACE(sizeof(*ev) + sizeof(struct iscsi_hdr) + 969 data_size); 970 971 priv = iscsi_if_transport_lookup(conn->transport); 972 if (!priv) 973 return -EINVAL; 974 975 skb = alloc_skb(len, GFP_ATOMIC); 976 if (!skb) { 977 iscsi_conn_error_event(conn, ISCSI_ERR_CONN_FAILED); 978 iscsi_cls_conn_printk(KERN_ERR, conn, "can not deliver " 979 "control PDU: OOM\n"); 980 return -ENOMEM; 981 } 982 983 nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0); 984 ev = NLMSG_DATA(nlh); 985 memset(ev, 0, sizeof(*ev)); 986 ev->transport_handle = iscsi_handle(conn->transport); 987 ev->type = ISCSI_KEVENT_RECV_PDU; 988 ev->r.recv_req.cid = conn->cid; 989 ev->r.recv_req.sid = iscsi_conn_get_sid(conn); 990 pdu = (char*)ev + sizeof(*ev); 991 memcpy(pdu, hdr, sizeof(struct iscsi_hdr)); 992 memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size); 993 994 return iscsi_unicast_skb(skb, priv->daemon_pid); 995 } 996 EXPORT_SYMBOL_GPL(iscsi_recv_pdu); 997 998 void iscsi_conn_error_event(struct iscsi_cls_conn *conn, enum iscsi_err error) 999 { 1000 struct nlmsghdr *nlh; 1001 struct sk_buff *skb; 1002 struct iscsi_uevent *ev; 1003 struct iscsi_internal *priv; 1004 int len = NLMSG_SPACE(sizeof(*ev)); 1005 1006 priv = iscsi_if_transport_lookup(conn->transport); 1007 if (!priv) 1008 return; 1009 1010 skb = alloc_skb(len, GFP_ATOMIC); 1011 if (!skb) { 1012 iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored " 1013 "conn error (%d)\n", error); 1014 return; 1015 } 1016 1017 nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0); 1018 ev = NLMSG_DATA(nlh); 1019 ev->transport_handle = iscsi_handle(conn->transport); 1020 ev->type = ISCSI_KEVENT_CONN_ERROR; 1021 ev->r.connerror.error = error; 1022 ev->r.connerror.cid = conn->cid; 1023 ev->r.connerror.sid = iscsi_conn_get_sid(conn); 1024 1025 iscsi_broadcast_skb(skb, GFP_ATOMIC); 1026 1027 iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn error (%d)\n", 1028 error); 1029 } 1030 EXPORT_SYMBOL_GPL(iscsi_conn_error_event); 1031 1032 static int 1033 iscsi_if_send_reply(int pid, int seq, int type, int done, int multi, 1034 void *payload, int size) 1035 { 1036 struct sk_buff *skb; 1037 struct nlmsghdr *nlh; 1038 int len = NLMSG_SPACE(size); 1039 int flags = multi ? NLM_F_MULTI : 0; 1040 int t = done ? NLMSG_DONE : type; 1041 1042 skb = alloc_skb(len, GFP_ATOMIC); 1043 if (!skb) { 1044 printk(KERN_ERR "Could not allocate skb to send reply.\n"); 1045 return -ENOMEM; 1046 } 1047 1048 nlh = __nlmsg_put(skb, pid, seq, t, (len - sizeof(*nlh)), 0); 1049 nlh->nlmsg_flags = flags; 1050 memcpy(NLMSG_DATA(nlh), payload, size); 1051 return iscsi_unicast_skb(skb, pid); 1052 } 1053 1054 static int 1055 iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh) 1056 { 1057 struct iscsi_uevent *ev = NLMSG_DATA(nlh); 1058 struct iscsi_stats *stats; 1059 struct sk_buff *skbstat; 1060 struct iscsi_cls_conn *conn; 1061 struct nlmsghdr *nlhstat; 1062 struct iscsi_uevent *evstat; 1063 struct iscsi_internal *priv; 1064 int len = NLMSG_SPACE(sizeof(*ev) + 1065 sizeof(struct iscsi_stats) + 1066 sizeof(struct iscsi_stats_custom) * 1067 ISCSI_STATS_CUSTOM_MAX); 1068 int err = 0; 1069 1070 priv = iscsi_if_transport_lookup(transport); 1071 if (!priv) 1072 return -EINVAL; 1073 1074 conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid); 1075 if (!conn) 1076 return -EEXIST; 1077 1078 do { 1079 int actual_size; 1080 1081 skbstat = alloc_skb(len, GFP_ATOMIC); 1082 if (!skbstat) { 1083 iscsi_cls_conn_printk(KERN_ERR, conn, "can not " 1084 "deliver stats: OOM\n"); 1085 return -ENOMEM; 1086 } 1087 1088 nlhstat = __nlmsg_put(skbstat, priv->daemon_pid, 0, 0, 1089 (len - sizeof(*nlhstat)), 0); 1090 evstat = NLMSG_DATA(nlhstat); 1091 memset(evstat, 0, sizeof(*evstat)); 1092 evstat->transport_handle = iscsi_handle(conn->transport); 1093 evstat->type = nlh->nlmsg_type; 1094 evstat->u.get_stats.cid = 1095 ev->u.get_stats.cid; 1096 evstat->u.get_stats.sid = 1097 ev->u.get_stats.sid; 1098 stats = (struct iscsi_stats *) 1099 ((char*)evstat + sizeof(*evstat)); 1100 memset(stats, 0, sizeof(*stats)); 1101 1102 transport->get_stats(conn, stats); 1103 actual_size = NLMSG_SPACE(sizeof(struct iscsi_uevent) + 1104 sizeof(struct iscsi_stats) + 1105 sizeof(struct iscsi_stats_custom) * 1106 stats->custom_length); 1107 actual_size -= sizeof(*nlhstat); 1108 actual_size = NLMSG_LENGTH(actual_size); 1109 skb_trim(skbstat, NLMSG_ALIGN(actual_size)); 1110 nlhstat->nlmsg_len = actual_size; 1111 1112 err = iscsi_unicast_skb(skbstat, priv->daemon_pid); 1113 } while (err < 0 && err != -ECONNREFUSED); 1114 1115 return err; 1116 } 1117 1118 /** 1119 * iscsi_session_event - send session destr. completion event 1120 * @session: iscsi class session 1121 * @event: type of event 1122 */ 1123 int iscsi_session_event(struct iscsi_cls_session *session, 1124 enum iscsi_uevent_e event) 1125 { 1126 struct iscsi_internal *priv; 1127 struct Scsi_Host *shost; 1128 struct iscsi_uevent *ev; 1129 struct sk_buff *skb; 1130 struct nlmsghdr *nlh; 1131 int rc, len = NLMSG_SPACE(sizeof(*ev)); 1132 1133 priv = iscsi_if_transport_lookup(session->transport); 1134 if (!priv) 1135 return -EINVAL; 1136 shost = iscsi_session_to_shost(session); 1137 1138 skb = alloc_skb(len, GFP_KERNEL); 1139 if (!skb) { 1140 iscsi_cls_session_printk(KERN_ERR, session, 1141 "Cannot notify userspace of session " 1142 "event %u\n", event); 1143 return -ENOMEM; 1144 } 1145 1146 nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0); 1147 ev = NLMSG_DATA(nlh); 1148 ev->transport_handle = iscsi_handle(session->transport); 1149 1150 ev->type = event; 1151 switch (event) { 1152 case ISCSI_KEVENT_DESTROY_SESSION: 1153 ev->r.d_session.host_no = shost->host_no; 1154 ev->r.d_session.sid = session->sid; 1155 break; 1156 case ISCSI_KEVENT_CREATE_SESSION: 1157 ev->r.c_session_ret.host_no = shost->host_no; 1158 ev->r.c_session_ret.sid = session->sid; 1159 break; 1160 case ISCSI_KEVENT_UNBIND_SESSION: 1161 ev->r.unbind_session.host_no = shost->host_no; 1162 ev->r.unbind_session.sid = session->sid; 1163 break; 1164 default: 1165 iscsi_cls_session_printk(KERN_ERR, session, "Invalid event " 1166 "%u.\n", event); 1167 kfree_skb(skb); 1168 return -EINVAL; 1169 } 1170 1171 /* 1172 * this will occur if the daemon is not up, so we just warn 1173 * the user and when the daemon is restarted it will handle it 1174 */ 1175 rc = iscsi_broadcast_skb(skb, GFP_KERNEL); 1176 if (rc == -ESRCH) 1177 iscsi_cls_session_printk(KERN_ERR, session, 1178 "Cannot notify userspace of session " 1179 "event %u. Check iscsi daemon\n", 1180 event); 1181 return rc; 1182 } 1183 EXPORT_SYMBOL_GPL(iscsi_session_event); 1184 1185 static int 1186 iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_endpoint *ep, 1187 struct iscsi_uevent *ev, uint32_t initial_cmdsn, 1188 uint16_t cmds_max, uint16_t queue_depth) 1189 { 1190 struct iscsi_transport *transport = priv->iscsi_transport; 1191 struct iscsi_cls_session *session; 1192 struct Scsi_Host *shost; 1193 1194 session = transport->create_session(ep, cmds_max, queue_depth, 1195 initial_cmdsn); 1196 if (!session) 1197 return -ENOMEM; 1198 1199 shost = iscsi_session_to_shost(session); 1200 ev->r.c_session_ret.host_no = shost->host_no; 1201 ev->r.c_session_ret.sid = session->sid; 1202 return 0; 1203 } 1204 1205 static int 1206 iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev) 1207 { 1208 struct iscsi_cls_conn *conn; 1209 struct iscsi_cls_session *session; 1210 1211 session = iscsi_session_lookup(ev->u.c_conn.sid); 1212 if (!session) { 1213 printk(KERN_ERR "iscsi: invalid session %d.\n", 1214 ev->u.c_conn.sid); 1215 return -EINVAL; 1216 } 1217 1218 conn = transport->create_conn(session, ev->u.c_conn.cid); 1219 if (!conn) { 1220 iscsi_cls_session_printk(KERN_ERR, session, 1221 "couldn't create a new connection."); 1222 return -ENOMEM; 1223 } 1224 1225 ev->r.c_conn_ret.sid = session->sid; 1226 ev->r.c_conn_ret.cid = conn->cid; 1227 return 0; 1228 } 1229 1230 static int 1231 iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev) 1232 { 1233 struct iscsi_cls_conn *conn; 1234 1235 conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid); 1236 if (!conn) 1237 return -EINVAL; 1238 1239 if (transport->destroy_conn) 1240 transport->destroy_conn(conn); 1241 return 0; 1242 } 1243 1244 static int 1245 iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev) 1246 { 1247 char *data = (char*)ev + sizeof(*ev); 1248 struct iscsi_cls_conn *conn; 1249 struct iscsi_cls_session *session; 1250 int err = 0, value = 0; 1251 1252 session = iscsi_session_lookup(ev->u.set_param.sid); 1253 conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid); 1254 if (!conn || !session) 1255 return -EINVAL; 1256 1257 switch (ev->u.set_param.param) { 1258 case ISCSI_PARAM_SESS_RECOVERY_TMO: 1259 sscanf(data, "%d", &value); 1260 if (value != 0) 1261 session->recovery_tmo = value; 1262 break; 1263 default: 1264 err = transport->set_param(conn, ev->u.set_param.param, 1265 data, ev->u.set_param.len); 1266 } 1267 1268 return err; 1269 } 1270 1271 static int 1272 iscsi_if_transport_ep(struct iscsi_transport *transport, 1273 struct iscsi_uevent *ev, int msg_type) 1274 { 1275 struct iscsi_endpoint *ep; 1276 struct sockaddr *dst_addr; 1277 int rc = 0; 1278 1279 switch (msg_type) { 1280 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT: 1281 if (!transport->ep_connect) 1282 return -EINVAL; 1283 1284 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev)); 1285 ep = transport->ep_connect(dst_addr, 1286 ev->u.ep_connect.non_blocking); 1287 if (IS_ERR(ep)) 1288 return PTR_ERR(ep); 1289 1290 ev->r.ep_connect_ret.handle = ep->id; 1291 break; 1292 case ISCSI_UEVENT_TRANSPORT_EP_POLL: 1293 if (!transport->ep_poll) 1294 return -EINVAL; 1295 1296 ep = iscsi_lookup_endpoint(ev->u.ep_poll.ep_handle); 1297 if (!ep) 1298 return -EINVAL; 1299 1300 ev->r.retcode = transport->ep_poll(ep, 1301 ev->u.ep_poll.timeout_ms); 1302 break; 1303 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT: 1304 if (!transport->ep_disconnect) 1305 return -EINVAL; 1306 1307 ep = iscsi_lookup_endpoint(ev->u.ep_disconnect.ep_handle); 1308 if (!ep) 1309 return -EINVAL; 1310 1311 transport->ep_disconnect(ep); 1312 break; 1313 } 1314 return rc; 1315 } 1316 1317 static int 1318 iscsi_tgt_dscvr(struct iscsi_transport *transport, 1319 struct iscsi_uevent *ev) 1320 { 1321 struct Scsi_Host *shost; 1322 struct sockaddr *dst_addr; 1323 int err; 1324 1325 if (!transport->tgt_dscvr) 1326 return -EINVAL; 1327 1328 shost = scsi_host_lookup(ev->u.tgt_dscvr.host_no); 1329 if (!shost) { 1330 printk(KERN_ERR "target discovery could not find host no %u\n", 1331 ev->u.tgt_dscvr.host_no); 1332 return -ENODEV; 1333 } 1334 1335 1336 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev)); 1337 err = transport->tgt_dscvr(shost, ev->u.tgt_dscvr.type, 1338 ev->u.tgt_dscvr.enable, dst_addr); 1339 scsi_host_put(shost); 1340 return err; 1341 } 1342 1343 static int 1344 iscsi_set_host_param(struct iscsi_transport *transport, 1345 struct iscsi_uevent *ev) 1346 { 1347 char *data = (char*)ev + sizeof(*ev); 1348 struct Scsi_Host *shost; 1349 int err; 1350 1351 if (!transport->set_host_param) 1352 return -ENOSYS; 1353 1354 shost = scsi_host_lookup(ev->u.set_host_param.host_no); 1355 if (!shost) { 1356 printk(KERN_ERR "set_host_param could not find host no %u\n", 1357 ev->u.set_host_param.host_no); 1358 return -ENODEV; 1359 } 1360 1361 err = transport->set_host_param(shost, ev->u.set_host_param.param, 1362 data, ev->u.set_host_param.len); 1363 scsi_host_put(shost); 1364 return err; 1365 } 1366 1367 static int 1368 iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) 1369 { 1370 int err = 0; 1371 struct iscsi_uevent *ev = NLMSG_DATA(nlh); 1372 struct iscsi_transport *transport = NULL; 1373 struct iscsi_internal *priv; 1374 struct iscsi_cls_session *session; 1375 struct iscsi_cls_conn *conn; 1376 struct iscsi_endpoint *ep = NULL; 1377 1378 priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle)); 1379 if (!priv) 1380 return -EINVAL; 1381 transport = priv->iscsi_transport; 1382 1383 if (!try_module_get(transport->owner)) 1384 return -EINVAL; 1385 1386 priv->daemon_pid = NETLINK_CREDS(skb)->pid; 1387 1388 switch (nlh->nlmsg_type) { 1389 case ISCSI_UEVENT_CREATE_SESSION: 1390 err = iscsi_if_create_session(priv, ep, ev, 1391 ev->u.c_session.initial_cmdsn, 1392 ev->u.c_session.cmds_max, 1393 ev->u.c_session.queue_depth); 1394 break; 1395 case ISCSI_UEVENT_CREATE_BOUND_SESSION: 1396 ep = iscsi_lookup_endpoint(ev->u.c_bound_session.ep_handle); 1397 if (!ep) { 1398 err = -EINVAL; 1399 break; 1400 } 1401 1402 err = iscsi_if_create_session(priv, ep, ev, 1403 ev->u.c_bound_session.initial_cmdsn, 1404 ev->u.c_bound_session.cmds_max, 1405 ev->u.c_bound_session.queue_depth); 1406 break; 1407 case ISCSI_UEVENT_DESTROY_SESSION: 1408 session = iscsi_session_lookup(ev->u.d_session.sid); 1409 if (session) 1410 transport->destroy_session(session); 1411 else 1412 err = -EINVAL; 1413 break; 1414 case ISCSI_UEVENT_UNBIND_SESSION: 1415 session = iscsi_session_lookup(ev->u.d_session.sid); 1416 if (session) 1417 scsi_queue_work(iscsi_session_to_shost(session), 1418 &session->unbind_work); 1419 else 1420 err = -EINVAL; 1421 break; 1422 case ISCSI_UEVENT_CREATE_CONN: 1423 err = iscsi_if_create_conn(transport, ev); 1424 break; 1425 case ISCSI_UEVENT_DESTROY_CONN: 1426 err = iscsi_if_destroy_conn(transport, ev); 1427 break; 1428 case ISCSI_UEVENT_BIND_CONN: 1429 session = iscsi_session_lookup(ev->u.b_conn.sid); 1430 conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid); 1431 1432 if (session && conn) 1433 ev->r.retcode = transport->bind_conn(session, conn, 1434 ev->u.b_conn.transport_eph, 1435 ev->u.b_conn.is_leading); 1436 else 1437 err = -EINVAL; 1438 break; 1439 case ISCSI_UEVENT_SET_PARAM: 1440 err = iscsi_set_param(transport, ev); 1441 break; 1442 case ISCSI_UEVENT_START_CONN: 1443 conn = iscsi_conn_lookup(ev->u.start_conn.sid, ev->u.start_conn.cid); 1444 if (conn) 1445 ev->r.retcode = transport->start_conn(conn); 1446 else 1447 err = -EINVAL; 1448 break; 1449 case ISCSI_UEVENT_STOP_CONN: 1450 conn = iscsi_conn_lookup(ev->u.stop_conn.sid, ev->u.stop_conn.cid); 1451 if (conn) 1452 transport->stop_conn(conn, ev->u.stop_conn.flag); 1453 else 1454 err = -EINVAL; 1455 break; 1456 case ISCSI_UEVENT_SEND_PDU: 1457 conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid); 1458 if (conn) 1459 ev->r.retcode = transport->send_pdu(conn, 1460 (struct iscsi_hdr*)((char*)ev + sizeof(*ev)), 1461 (char*)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size, 1462 ev->u.send_pdu.data_size); 1463 else 1464 err = -EINVAL; 1465 break; 1466 case ISCSI_UEVENT_GET_STATS: 1467 err = iscsi_if_get_stats(transport, nlh); 1468 break; 1469 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT: 1470 case ISCSI_UEVENT_TRANSPORT_EP_POLL: 1471 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT: 1472 err = iscsi_if_transport_ep(transport, ev, nlh->nlmsg_type); 1473 break; 1474 case ISCSI_UEVENT_TGT_DSCVR: 1475 err = iscsi_tgt_dscvr(transport, ev); 1476 break; 1477 case ISCSI_UEVENT_SET_HOST_PARAM: 1478 err = iscsi_set_host_param(transport, ev); 1479 break; 1480 default: 1481 err = -ENOSYS; 1482 break; 1483 } 1484 1485 module_put(transport->owner); 1486 return err; 1487 } 1488 1489 /* 1490 * Get message from skb. Each message is processed by iscsi_if_recv_msg. 1491 * Malformed skbs with wrong lengths or invalid creds are not processed. 1492 */ 1493 static void 1494 iscsi_if_rx(struct sk_buff *skb) 1495 { 1496 mutex_lock(&rx_queue_mutex); 1497 while (skb->len >= NLMSG_SPACE(0)) { 1498 int err; 1499 uint32_t rlen; 1500 struct nlmsghdr *nlh; 1501 struct iscsi_uevent *ev; 1502 1503 nlh = nlmsg_hdr(skb); 1504 if (nlh->nlmsg_len < sizeof(*nlh) || 1505 skb->len < nlh->nlmsg_len) { 1506 break; 1507 } 1508 1509 ev = NLMSG_DATA(nlh); 1510 rlen = NLMSG_ALIGN(nlh->nlmsg_len); 1511 if (rlen > skb->len) 1512 rlen = skb->len; 1513 1514 err = iscsi_if_recv_msg(skb, nlh); 1515 if (err) { 1516 ev->type = ISCSI_KEVENT_IF_ERROR; 1517 ev->iferror = err; 1518 } 1519 do { 1520 /* 1521 * special case for GET_STATS: 1522 * on success - sending reply and stats from 1523 * inside of if_recv_msg(), 1524 * on error - fall through. 1525 */ 1526 if (ev->type == ISCSI_UEVENT_GET_STATS && !err) 1527 break; 1528 err = iscsi_if_send_reply( 1529 NETLINK_CREDS(skb)->pid, nlh->nlmsg_seq, 1530 nlh->nlmsg_type, 0, 0, ev, sizeof(*ev)); 1531 } while (err < 0 && err != -ECONNREFUSED); 1532 skb_pull(skb, rlen); 1533 } 1534 mutex_unlock(&rx_queue_mutex); 1535 } 1536 1537 #define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \ 1538 struct device_attribute dev_attr_##_prefix##_##_name = \ 1539 __ATTR(_name,_mode,_show,_store) 1540 1541 /* 1542 * iSCSI connection attrs 1543 */ 1544 #define iscsi_conn_attr_show(param) \ 1545 static ssize_t \ 1546 show_conn_param_##param(struct device *dev, \ 1547 struct device_attribute *attr, char *buf) \ 1548 { \ 1549 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \ 1550 struct iscsi_transport *t = conn->transport; \ 1551 return t->get_conn_param(conn, param, buf); \ 1552 } 1553 1554 #define iscsi_conn_attr(field, param) \ 1555 iscsi_conn_attr_show(param) \ 1556 static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param, \ 1557 NULL); 1558 1559 iscsi_conn_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH); 1560 iscsi_conn_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH); 1561 iscsi_conn_attr(header_digest, ISCSI_PARAM_HDRDGST_EN); 1562 iscsi_conn_attr(data_digest, ISCSI_PARAM_DATADGST_EN); 1563 iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN); 1564 iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN); 1565 iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT); 1566 iscsi_conn_attr(port, ISCSI_PARAM_CONN_PORT); 1567 iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN); 1568 iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS); 1569 iscsi_conn_attr(address, ISCSI_PARAM_CONN_ADDRESS); 1570 iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO); 1571 iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO); 1572 1573 /* 1574 * iSCSI session attrs 1575 */ 1576 #define iscsi_session_attr_show(param, perm) \ 1577 static ssize_t \ 1578 show_session_param_##param(struct device *dev, \ 1579 struct device_attribute *attr, char *buf) \ 1580 { \ 1581 struct iscsi_cls_session *session = \ 1582 iscsi_dev_to_session(dev->parent); \ 1583 struct iscsi_transport *t = session->transport; \ 1584 \ 1585 if (perm && !capable(CAP_SYS_ADMIN)) \ 1586 return -EACCES; \ 1587 return t->get_session_param(session, param, buf); \ 1588 } 1589 1590 #define iscsi_session_attr(field, param, perm) \ 1591 iscsi_session_attr_show(param, perm) \ 1592 static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \ 1593 NULL); 1594 1595 iscsi_session_attr(targetname, ISCSI_PARAM_TARGET_NAME, 0); 1596 iscsi_session_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN, 0); 1597 iscsi_session_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T, 0); 1598 iscsi_session_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN, 0); 1599 iscsi_session_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST, 0); 1600 iscsi_session_attr(max_burst_len, ISCSI_PARAM_MAX_BURST, 0); 1601 iscsi_session_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN, 0); 1602 iscsi_session_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN, 0); 1603 iscsi_session_attr(erl, ISCSI_PARAM_ERL, 0); 1604 iscsi_session_attr(tpgt, ISCSI_PARAM_TPGT, 0); 1605 iscsi_session_attr(username, ISCSI_PARAM_USERNAME, 1); 1606 iscsi_session_attr(username_in, ISCSI_PARAM_USERNAME_IN, 1); 1607 iscsi_session_attr(password, ISCSI_PARAM_PASSWORD, 1); 1608 iscsi_session_attr(password_in, ISCSI_PARAM_PASSWORD_IN, 1); 1609 iscsi_session_attr(fast_abort, ISCSI_PARAM_FAST_ABORT, 0); 1610 iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0); 1611 iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0); 1612 iscsi_session_attr(ifacename, ISCSI_PARAM_IFACE_NAME, 0); 1613 iscsi_session_attr(initiatorname, ISCSI_PARAM_INITIATOR_NAME, 0) 1614 1615 static ssize_t 1616 show_priv_session_state(struct device *dev, struct device_attribute *attr, 1617 char *buf) 1618 { 1619 struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent); 1620 return sprintf(buf, "%s\n", iscsi_session_state_name(session->state)); 1621 } 1622 static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state, 1623 NULL); 1624 1625 #define iscsi_priv_session_attr_show(field, format) \ 1626 static ssize_t \ 1627 show_priv_session_##field(struct device *dev, \ 1628 struct device_attribute *attr, char *buf) \ 1629 { \ 1630 struct iscsi_cls_session *session = \ 1631 iscsi_dev_to_session(dev->parent); \ 1632 return sprintf(buf, format"\n", session->field); \ 1633 } 1634 1635 #define iscsi_priv_session_attr(field, format) \ 1636 iscsi_priv_session_attr_show(field, format) \ 1637 static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO, show_priv_session_##field, \ 1638 NULL) 1639 iscsi_priv_session_attr(recovery_tmo, "%d"); 1640 1641 /* 1642 * iSCSI host attrs 1643 */ 1644 #define iscsi_host_attr_show(param) \ 1645 static ssize_t \ 1646 show_host_param_##param(struct device *dev, \ 1647 struct device_attribute *attr, char *buf) \ 1648 { \ 1649 struct Scsi_Host *shost = transport_class_to_shost(dev); \ 1650 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \ 1651 return priv->iscsi_transport->get_host_param(shost, param, buf); \ 1652 } 1653 1654 #define iscsi_host_attr(field, param) \ 1655 iscsi_host_attr_show(param) \ 1656 static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param, \ 1657 NULL); 1658 1659 iscsi_host_attr(netdev, ISCSI_HOST_PARAM_NETDEV_NAME); 1660 iscsi_host_attr(hwaddress, ISCSI_HOST_PARAM_HWADDRESS); 1661 iscsi_host_attr(ipaddress, ISCSI_HOST_PARAM_IPADDRESS); 1662 iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME); 1663 1664 #define SETUP_PRIV_SESSION_RD_ATTR(field) \ 1665 do { \ 1666 priv->session_attrs[count] = &dev_attr_priv_sess_##field; \ 1667 count++; \ 1668 } while (0) 1669 1670 1671 #define SETUP_SESSION_RD_ATTR(field, param_flag) \ 1672 do { \ 1673 if (tt->param_mask & param_flag) { \ 1674 priv->session_attrs[count] = &dev_attr_sess_##field; \ 1675 count++; \ 1676 } \ 1677 } while (0) 1678 1679 #define SETUP_CONN_RD_ATTR(field, param_flag) \ 1680 do { \ 1681 if (tt->param_mask & param_flag) { \ 1682 priv->conn_attrs[count] = &dev_attr_conn_##field; \ 1683 count++; \ 1684 } \ 1685 } while (0) 1686 1687 #define SETUP_HOST_RD_ATTR(field, param_flag) \ 1688 do { \ 1689 if (tt->host_param_mask & param_flag) { \ 1690 priv->host_attrs[count] = &dev_attr_host_##field; \ 1691 count++; \ 1692 } \ 1693 } while (0) 1694 1695 static int iscsi_session_match(struct attribute_container *cont, 1696 struct device *dev) 1697 { 1698 struct iscsi_cls_session *session; 1699 struct Scsi_Host *shost; 1700 struct iscsi_internal *priv; 1701 1702 if (!iscsi_is_session_dev(dev)) 1703 return 0; 1704 1705 session = iscsi_dev_to_session(dev); 1706 shost = iscsi_session_to_shost(session); 1707 if (!shost->transportt) 1708 return 0; 1709 1710 priv = to_iscsi_internal(shost->transportt); 1711 if (priv->session_cont.ac.class != &iscsi_session_class.class) 1712 return 0; 1713 1714 return &priv->session_cont.ac == cont; 1715 } 1716 1717 static int iscsi_conn_match(struct attribute_container *cont, 1718 struct device *dev) 1719 { 1720 struct iscsi_cls_session *session; 1721 struct iscsi_cls_conn *conn; 1722 struct Scsi_Host *shost; 1723 struct iscsi_internal *priv; 1724 1725 if (!iscsi_is_conn_dev(dev)) 1726 return 0; 1727 1728 conn = iscsi_dev_to_conn(dev); 1729 session = iscsi_dev_to_session(conn->dev.parent); 1730 shost = iscsi_session_to_shost(session); 1731 1732 if (!shost->transportt) 1733 return 0; 1734 1735 priv = to_iscsi_internal(shost->transportt); 1736 if (priv->conn_cont.ac.class != &iscsi_connection_class.class) 1737 return 0; 1738 1739 return &priv->conn_cont.ac == cont; 1740 } 1741 1742 static int iscsi_host_match(struct attribute_container *cont, 1743 struct device *dev) 1744 { 1745 struct Scsi_Host *shost; 1746 struct iscsi_internal *priv; 1747 1748 if (!scsi_is_host_device(dev)) 1749 return 0; 1750 1751 shost = dev_to_shost(dev); 1752 if (!shost->transportt || 1753 shost->transportt->host_attrs.ac.class != &iscsi_host_class.class) 1754 return 0; 1755 1756 priv = to_iscsi_internal(shost->transportt); 1757 return &priv->t.host_attrs.ac == cont; 1758 } 1759 1760 struct scsi_transport_template * 1761 iscsi_register_transport(struct iscsi_transport *tt) 1762 { 1763 struct iscsi_internal *priv; 1764 unsigned long flags; 1765 int count = 0, err; 1766 1767 BUG_ON(!tt); 1768 1769 priv = iscsi_if_transport_lookup(tt); 1770 if (priv) 1771 return NULL; 1772 1773 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 1774 if (!priv) 1775 return NULL; 1776 INIT_LIST_HEAD(&priv->list); 1777 priv->daemon_pid = -1; 1778 priv->iscsi_transport = tt; 1779 priv->t.user_scan = iscsi_user_scan; 1780 priv->t.create_work_queue = 1; 1781 1782 priv->dev.class = &iscsi_transport_class; 1783 dev_set_name(&priv->dev, "%s", tt->name); 1784 err = device_register(&priv->dev); 1785 if (err) 1786 goto free_priv; 1787 1788 err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group); 1789 if (err) 1790 goto unregister_dev; 1791 1792 /* host parameters */ 1793 priv->t.host_attrs.ac.attrs = &priv->host_attrs[0]; 1794 priv->t.host_attrs.ac.class = &iscsi_host_class.class; 1795 priv->t.host_attrs.ac.match = iscsi_host_match; 1796 priv->t.host_size = sizeof(struct iscsi_cls_host); 1797 transport_container_register(&priv->t.host_attrs); 1798 1799 SETUP_HOST_RD_ATTR(netdev, ISCSI_HOST_NETDEV_NAME); 1800 SETUP_HOST_RD_ATTR(ipaddress, ISCSI_HOST_IPADDRESS); 1801 SETUP_HOST_RD_ATTR(hwaddress, ISCSI_HOST_HWADDRESS); 1802 SETUP_HOST_RD_ATTR(initiatorname, ISCSI_HOST_INITIATOR_NAME); 1803 BUG_ON(count > ISCSI_HOST_ATTRS); 1804 priv->host_attrs[count] = NULL; 1805 count = 0; 1806 1807 /* connection parameters */ 1808 priv->conn_cont.ac.attrs = &priv->conn_attrs[0]; 1809 priv->conn_cont.ac.class = &iscsi_connection_class.class; 1810 priv->conn_cont.ac.match = iscsi_conn_match; 1811 transport_container_register(&priv->conn_cont); 1812 1813 SETUP_CONN_RD_ATTR(max_recv_dlength, ISCSI_MAX_RECV_DLENGTH); 1814 SETUP_CONN_RD_ATTR(max_xmit_dlength, ISCSI_MAX_XMIT_DLENGTH); 1815 SETUP_CONN_RD_ATTR(header_digest, ISCSI_HDRDGST_EN); 1816 SETUP_CONN_RD_ATTR(data_digest, ISCSI_DATADGST_EN); 1817 SETUP_CONN_RD_ATTR(ifmarker, ISCSI_IFMARKER_EN); 1818 SETUP_CONN_RD_ATTR(ofmarker, ISCSI_OFMARKER_EN); 1819 SETUP_CONN_RD_ATTR(address, ISCSI_CONN_ADDRESS); 1820 SETUP_CONN_RD_ATTR(port, ISCSI_CONN_PORT); 1821 SETUP_CONN_RD_ATTR(exp_statsn, ISCSI_EXP_STATSN); 1822 SETUP_CONN_RD_ATTR(persistent_address, ISCSI_PERSISTENT_ADDRESS); 1823 SETUP_CONN_RD_ATTR(persistent_port, ISCSI_PERSISTENT_PORT); 1824 SETUP_CONN_RD_ATTR(ping_tmo, ISCSI_PING_TMO); 1825 SETUP_CONN_RD_ATTR(recv_tmo, ISCSI_RECV_TMO); 1826 1827 BUG_ON(count > ISCSI_CONN_ATTRS); 1828 priv->conn_attrs[count] = NULL; 1829 count = 0; 1830 1831 /* session parameters */ 1832 priv->session_cont.ac.attrs = &priv->session_attrs[0]; 1833 priv->session_cont.ac.class = &iscsi_session_class.class; 1834 priv->session_cont.ac.match = iscsi_session_match; 1835 transport_container_register(&priv->session_cont); 1836 1837 SETUP_SESSION_RD_ATTR(initial_r2t, ISCSI_INITIAL_R2T_EN); 1838 SETUP_SESSION_RD_ATTR(max_outstanding_r2t, ISCSI_MAX_R2T); 1839 SETUP_SESSION_RD_ATTR(immediate_data, ISCSI_IMM_DATA_EN); 1840 SETUP_SESSION_RD_ATTR(first_burst_len, ISCSI_FIRST_BURST); 1841 SETUP_SESSION_RD_ATTR(max_burst_len, ISCSI_MAX_BURST); 1842 SETUP_SESSION_RD_ATTR(data_pdu_in_order, ISCSI_PDU_INORDER_EN); 1843 SETUP_SESSION_RD_ATTR(data_seq_in_order, ISCSI_DATASEQ_INORDER_EN); 1844 SETUP_SESSION_RD_ATTR(erl, ISCSI_ERL); 1845 SETUP_SESSION_RD_ATTR(targetname, ISCSI_TARGET_NAME); 1846 SETUP_SESSION_RD_ATTR(tpgt, ISCSI_TPGT); 1847 SETUP_SESSION_RD_ATTR(password, ISCSI_USERNAME); 1848 SETUP_SESSION_RD_ATTR(password_in, ISCSI_USERNAME_IN); 1849 SETUP_SESSION_RD_ATTR(username, ISCSI_PASSWORD); 1850 SETUP_SESSION_RD_ATTR(username_in, ISCSI_PASSWORD_IN); 1851 SETUP_SESSION_RD_ATTR(fast_abort, ISCSI_FAST_ABORT); 1852 SETUP_SESSION_RD_ATTR(abort_tmo, ISCSI_ABORT_TMO); 1853 SETUP_SESSION_RD_ATTR(lu_reset_tmo,ISCSI_LU_RESET_TMO); 1854 SETUP_SESSION_RD_ATTR(ifacename, ISCSI_IFACE_NAME); 1855 SETUP_SESSION_RD_ATTR(initiatorname, ISCSI_INITIATOR_NAME); 1856 SETUP_PRIV_SESSION_RD_ATTR(recovery_tmo); 1857 SETUP_PRIV_SESSION_RD_ATTR(state); 1858 1859 BUG_ON(count > ISCSI_SESSION_ATTRS); 1860 priv->session_attrs[count] = NULL; 1861 1862 spin_lock_irqsave(&iscsi_transport_lock, flags); 1863 list_add(&priv->list, &iscsi_transports); 1864 spin_unlock_irqrestore(&iscsi_transport_lock, flags); 1865 1866 printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name); 1867 return &priv->t; 1868 1869 unregister_dev: 1870 device_unregister(&priv->dev); 1871 return NULL; 1872 free_priv: 1873 kfree(priv); 1874 return NULL; 1875 } 1876 EXPORT_SYMBOL_GPL(iscsi_register_transport); 1877 1878 int iscsi_unregister_transport(struct iscsi_transport *tt) 1879 { 1880 struct iscsi_internal *priv; 1881 unsigned long flags; 1882 1883 BUG_ON(!tt); 1884 1885 mutex_lock(&rx_queue_mutex); 1886 1887 priv = iscsi_if_transport_lookup(tt); 1888 BUG_ON (!priv); 1889 1890 spin_lock_irqsave(&iscsi_transport_lock, flags); 1891 list_del(&priv->list); 1892 spin_unlock_irqrestore(&iscsi_transport_lock, flags); 1893 1894 transport_container_unregister(&priv->conn_cont); 1895 transport_container_unregister(&priv->session_cont); 1896 transport_container_unregister(&priv->t.host_attrs); 1897 1898 sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group); 1899 device_unregister(&priv->dev); 1900 mutex_unlock(&rx_queue_mutex); 1901 1902 return 0; 1903 } 1904 EXPORT_SYMBOL_GPL(iscsi_unregister_transport); 1905 1906 static __init int iscsi_transport_init(void) 1907 { 1908 int err; 1909 1910 printk(KERN_INFO "Loading iSCSI transport class v%s.\n", 1911 ISCSI_TRANSPORT_VERSION); 1912 1913 atomic_set(&iscsi_session_nr, 0); 1914 1915 err = class_register(&iscsi_transport_class); 1916 if (err) 1917 return err; 1918 1919 err = class_register(&iscsi_endpoint_class); 1920 if (err) 1921 goto unregister_transport_class; 1922 1923 err = transport_class_register(&iscsi_host_class); 1924 if (err) 1925 goto unregister_endpoint_class; 1926 1927 err = transport_class_register(&iscsi_connection_class); 1928 if (err) 1929 goto unregister_host_class; 1930 1931 err = transport_class_register(&iscsi_session_class); 1932 if (err) 1933 goto unregister_conn_class; 1934 1935 nls = netlink_kernel_create(&init_net, NETLINK_ISCSI, 1, iscsi_if_rx, 1936 NULL, THIS_MODULE); 1937 if (!nls) { 1938 err = -ENOBUFS; 1939 goto unregister_session_class; 1940 } 1941 1942 iscsi_eh_timer_workq = create_singlethread_workqueue("iscsi_eh"); 1943 if (!iscsi_eh_timer_workq) 1944 goto release_nls; 1945 1946 return 0; 1947 1948 release_nls: 1949 netlink_kernel_release(nls); 1950 unregister_session_class: 1951 transport_class_unregister(&iscsi_session_class); 1952 unregister_conn_class: 1953 transport_class_unregister(&iscsi_connection_class); 1954 unregister_host_class: 1955 transport_class_unregister(&iscsi_host_class); 1956 unregister_endpoint_class: 1957 class_unregister(&iscsi_endpoint_class); 1958 unregister_transport_class: 1959 class_unregister(&iscsi_transport_class); 1960 return err; 1961 } 1962 1963 static void __exit iscsi_transport_exit(void) 1964 { 1965 destroy_workqueue(iscsi_eh_timer_workq); 1966 netlink_kernel_release(nls); 1967 transport_class_unregister(&iscsi_connection_class); 1968 transport_class_unregister(&iscsi_session_class); 1969 transport_class_unregister(&iscsi_host_class); 1970 class_unregister(&iscsi_endpoint_class); 1971 class_unregister(&iscsi_transport_class); 1972 } 1973 1974 module_init(iscsi_transport_init); 1975 module_exit(iscsi_transport_exit); 1976 1977 MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, " 1978 "Dmitry Yusupov <dmitry_yus@yahoo.com>, " 1979 "Alex Aizman <itn780@yahoo.com>"); 1980 MODULE_DESCRIPTION("iSCSI Transport Interface"); 1981 MODULE_LICENSE("GPL"); 1982 MODULE_VERSION(ISCSI_TRANSPORT_VERSION); 1983