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