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