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