1 /* 2 * iSCSI Initiator over iSER Data-Path 3 * 4 * Copyright (C) 2004 Dmitry Yusupov 5 * Copyright (C) 2004 Alex Aizman 6 * Copyright (C) 2005 Mike Christie 7 * Copyright (c) 2005, 2006 Voltaire, Inc. All rights reserved. 8 * maintained by openib-general@openib.org 9 * 10 * This software is available to you under a choice of one of two 11 * licenses. You may choose to be licensed under the terms of the GNU 12 * General Public License (GPL) Version 2, available from the file 13 * COPYING in the main directory of this source tree, or the 14 * OpenIB.org BSD license below: 15 * 16 * Redistribution and use in source and binary forms, with or 17 * without modification, are permitted provided that the following 18 * conditions are met: 19 * 20 * - Redistributions of source code must retain the above 21 * copyright notice, this list of conditions and the following 22 * disclaimer. 23 * 24 * - Redistributions in binary form must reproduce the above 25 * copyright notice, this list of conditions and the following 26 * disclaimer in the documentation and/or other materials 27 * provided with the distribution. 28 * 29 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 30 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 31 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 32 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 33 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 34 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 35 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 36 * SOFTWARE. 37 * 38 * Credits: 39 * Christoph Hellwig 40 * FUJITA Tomonori 41 * Arne Redlich 42 * Zhenyu Wang 43 * Modified by: 44 * Erez Zilber 45 * 46 * 47 * $Id: iscsi_iser.c 6965 2006-05-07 11:36:20Z ogerlitz $ 48 */ 49 50 #include <linux/types.h> 51 #include <linux/list.h> 52 #include <linux/hardirq.h> 53 #include <linux/kfifo.h> 54 #include <linux/blkdev.h> 55 #include <linux/init.h> 56 #include <linux/ioctl.h> 57 #include <linux/cdev.h> 58 #include <linux/in.h> 59 #include <linux/net.h> 60 #include <linux/scatterlist.h> 61 #include <linux/delay.h> 62 63 #include <net/sock.h> 64 65 #include <asm/uaccess.h> 66 67 #include <scsi/scsi_cmnd.h> 68 #include <scsi/scsi_device.h> 69 #include <scsi/scsi_eh.h> 70 #include <scsi/scsi_tcq.h> 71 #include <scsi/scsi_host.h> 72 #include <scsi/scsi.h> 73 #include <scsi/scsi_transport_iscsi.h> 74 75 #include "iscsi_iser.h" 76 77 static unsigned int iscsi_max_lun = 512; 78 module_param_named(max_lun, iscsi_max_lun, uint, S_IRUGO); 79 80 int iser_debug_level = 0; 81 82 MODULE_DESCRIPTION("iSER (iSCSI Extensions for RDMA) Datamover " 83 "v" DRV_VER " (" DRV_DATE ")"); 84 MODULE_LICENSE("Dual BSD/GPL"); 85 MODULE_AUTHOR("Alex Nezhinsky, Dan Bar Dov, Or Gerlitz"); 86 87 module_param_named(debug_level, iser_debug_level, int, 0644); 88 MODULE_PARM_DESC(debug_level, "Enable debug tracing if > 0 (default:disabled)"); 89 90 struct iser_global ig; 91 92 void 93 iscsi_iser_recv(struct iscsi_conn *conn, 94 struct iscsi_hdr *hdr, char *rx_data, int rx_data_len) 95 { 96 int rc = 0; 97 uint32_t ret_itt; 98 int datalen; 99 int ahslen; 100 101 /* verify PDU length */ 102 datalen = ntoh24(hdr->dlength); 103 if (datalen != rx_data_len) { 104 printk(KERN_ERR "iscsi_iser: datalen %d (hdr) != %d (IB) \n", 105 datalen, rx_data_len); 106 rc = ISCSI_ERR_DATALEN; 107 goto error; 108 } 109 110 /* read AHS */ 111 ahslen = hdr->hlength * 4; 112 113 /* verify itt (itt encoding: age+cid+itt) */ 114 rc = iscsi_verify_itt(conn, hdr, &ret_itt); 115 116 if (!rc) 117 rc = iscsi_complete_pdu(conn, hdr, rx_data, rx_data_len); 118 119 if (rc && rc != ISCSI_ERR_NO_SCSI_CMD) 120 goto error; 121 122 return; 123 error: 124 iscsi_conn_failure(conn, rc); 125 } 126 127 128 /** 129 * iscsi_iser_cmd_init - Initialize iSCSI SCSI_READ or SCSI_WRITE commands 130 * 131 **/ 132 static void 133 iscsi_iser_cmd_init(struct iscsi_cmd_task *ctask) 134 { 135 struct iscsi_iser_conn *iser_conn = ctask->conn->dd_data; 136 struct iscsi_iser_cmd_task *iser_ctask = ctask->dd_data; 137 struct scsi_cmnd *sc = ctask->sc; 138 139 iser_ctask->command_sent = 0; 140 iser_ctask->iser_conn = iser_conn; 141 142 if (sc->sc_data_direction == DMA_TO_DEVICE) { 143 BUG_ON(ctask->total_length == 0); 144 145 debug_scsi("cmd [itt %x total %d imm %d unsol_data %d\n", 146 ctask->itt, ctask->total_length, ctask->imm_count, 147 ctask->unsol_count); 148 } 149 150 iser_ctask_rdma_init(iser_ctask); 151 } 152 153 /** 154 * iscsi_mtask_xmit - xmit management(immediate) task 155 * @conn: iscsi connection 156 * @mtask: task management task 157 * 158 * Notes: 159 * The function can return -EAGAIN in which case caller must 160 * call it again later, or recover. '0' return code means successful 161 * xmit. 162 * 163 **/ 164 static int 165 iscsi_iser_mtask_xmit(struct iscsi_conn *conn, 166 struct iscsi_mgmt_task *mtask) 167 { 168 int error = 0; 169 170 debug_scsi("mtask deq [cid %d itt 0x%x]\n", conn->id, mtask->itt); 171 172 error = iser_send_control(conn, mtask); 173 174 /* since iser xmits control with zero copy, mtasks can not be recycled 175 * right after sending them. 176 * The recycling scheme is based on whether a response is expected 177 * - if yes, the mtask is recycled at iscsi_complete_pdu 178 * - if no, the mtask is recycled at iser_snd_completion 179 */ 180 if (error && error != -ENOBUFS) 181 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 182 183 return error; 184 } 185 186 static int 187 iscsi_iser_ctask_xmit_unsol_data(struct iscsi_conn *conn, 188 struct iscsi_cmd_task *ctask) 189 { 190 struct iscsi_data hdr; 191 int error = 0; 192 193 /* Send data-out PDUs while there's still unsolicited data to send */ 194 while (ctask->unsol_count > 0) { 195 iscsi_prep_unsolicit_data_pdu(ctask, &hdr); 196 debug_scsi("Sending data-out: itt 0x%x, data count %d\n", 197 hdr.itt, ctask->data_count); 198 199 /* the buffer description has been passed with the command */ 200 /* Send the command */ 201 error = iser_send_data_out(conn, ctask, &hdr); 202 if (error) { 203 ctask->unsol_datasn--; 204 goto iscsi_iser_ctask_xmit_unsol_data_exit; 205 } 206 ctask->unsol_count -= ctask->data_count; 207 debug_scsi("Need to send %d more as data-out PDUs\n", 208 ctask->unsol_count); 209 } 210 211 iscsi_iser_ctask_xmit_unsol_data_exit: 212 return error; 213 } 214 215 static int 216 iscsi_iser_ctask_xmit(struct iscsi_conn *conn, 217 struct iscsi_cmd_task *ctask) 218 { 219 struct iscsi_iser_cmd_task *iser_ctask = ctask->dd_data; 220 int error = 0; 221 222 debug_scsi("ctask deq [cid %d itt 0x%x]\n", 223 conn->id, ctask->itt); 224 225 /* 226 * serialize with TMF AbortTask 227 */ 228 if (ctask->mtask) 229 return error; 230 231 /* Send the cmd PDU */ 232 if (!iser_ctask->command_sent) { 233 error = iser_send_command(conn, ctask); 234 if (error) 235 goto iscsi_iser_ctask_xmit_exit; 236 iser_ctask->command_sent = 1; 237 } 238 239 /* Send unsolicited data-out PDU(s) if necessary */ 240 if (ctask->unsol_count) 241 error = iscsi_iser_ctask_xmit_unsol_data(conn, ctask); 242 243 iscsi_iser_ctask_xmit_exit: 244 if (error && error != -ENOBUFS) 245 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 246 return error; 247 } 248 249 static void 250 iscsi_iser_cleanup_ctask(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask) 251 { 252 struct iscsi_iser_cmd_task *iser_ctask = ctask->dd_data; 253 254 if (iser_ctask->status == ISER_TASK_STATUS_STARTED) { 255 iser_ctask->status = ISER_TASK_STATUS_COMPLETED; 256 iser_ctask_rdma_finalize(iser_ctask); 257 } 258 } 259 260 static struct iser_conn * 261 iscsi_iser_ib_conn_lookup(__u64 ep_handle) 262 { 263 struct iser_conn *ib_conn; 264 struct iser_conn *uib_conn = (struct iser_conn *)(unsigned long)ep_handle; 265 266 mutex_lock(&ig.connlist_mutex); 267 list_for_each_entry(ib_conn, &ig.connlist, conn_list) { 268 if (ib_conn == uib_conn) { 269 mutex_unlock(&ig.connlist_mutex); 270 return ib_conn; 271 } 272 } 273 mutex_unlock(&ig.connlist_mutex); 274 iser_err("no conn exists for eph %llx\n",(unsigned long long)ep_handle); 275 return NULL; 276 } 277 278 static struct iscsi_cls_conn * 279 iscsi_iser_conn_create(struct iscsi_cls_session *cls_session, uint32_t conn_idx) 280 { 281 struct iscsi_conn *conn; 282 struct iscsi_cls_conn *cls_conn; 283 struct iscsi_iser_conn *iser_conn; 284 285 cls_conn = iscsi_conn_setup(cls_session, conn_idx); 286 if (!cls_conn) 287 return NULL; 288 conn = cls_conn->dd_data; 289 290 /* 291 * due to issues with the login code re iser sematics 292 * this not set in iscsi_conn_setup - FIXME 293 */ 294 conn->max_recv_dlength = 128; 295 296 iser_conn = kzalloc(sizeof(*iser_conn), GFP_KERNEL); 297 if (!iser_conn) 298 goto conn_alloc_fail; 299 300 /* currently this is the only field which need to be initiated */ 301 rwlock_init(&iser_conn->lock); 302 303 conn->dd_data = iser_conn; 304 iser_conn->iscsi_conn = conn; 305 306 return cls_conn; 307 308 conn_alloc_fail: 309 iscsi_conn_teardown(cls_conn); 310 return NULL; 311 } 312 313 static void 314 iscsi_iser_conn_destroy(struct iscsi_cls_conn *cls_conn) 315 { 316 struct iscsi_conn *conn = cls_conn->dd_data; 317 struct iscsi_iser_conn *iser_conn = conn->dd_data; 318 319 iscsi_conn_teardown(cls_conn); 320 if (iser_conn->ib_conn) 321 iser_conn->ib_conn->iser_conn = NULL; 322 kfree(iser_conn); 323 } 324 325 static int 326 iscsi_iser_conn_bind(struct iscsi_cls_session *cls_session, 327 struct iscsi_cls_conn *cls_conn, uint64_t transport_eph, 328 int is_leading) 329 { 330 struct iscsi_conn *conn = cls_conn->dd_data; 331 struct iscsi_iser_conn *iser_conn; 332 struct iser_conn *ib_conn; 333 int error; 334 335 error = iscsi_conn_bind(cls_session, cls_conn, is_leading); 336 if (error) 337 return error; 338 339 /* the transport ep handle comes from user space so it must be 340 * verified against the global ib connections list */ 341 ib_conn = iscsi_iser_ib_conn_lookup(transport_eph); 342 if (!ib_conn) { 343 iser_err("can't bind eph %llx\n", 344 (unsigned long long)transport_eph); 345 return -EINVAL; 346 } 347 /* binds the iSER connection retrieved from the previously 348 * connected ep_handle to the iSCSI layer connection. exchanges 349 * connection pointers */ 350 iser_err("binding iscsi conn %p to iser_conn %p\n",conn,ib_conn); 351 iser_conn = conn->dd_data; 352 ib_conn->iser_conn = iser_conn; 353 iser_conn->ib_conn = ib_conn; 354 355 conn->recv_lock = &iser_conn->lock; 356 357 return 0; 358 } 359 360 static int 361 iscsi_iser_conn_start(struct iscsi_cls_conn *cls_conn) 362 { 363 struct iscsi_conn *conn = cls_conn->dd_data; 364 int err; 365 366 err = iser_conn_set_full_featured_mode(conn); 367 if (err) 368 return err; 369 370 return iscsi_conn_start(cls_conn); 371 } 372 373 static struct iscsi_transport iscsi_iser_transport; 374 375 static struct iscsi_cls_session * 376 iscsi_iser_session_create(struct iscsi_transport *iscsit, 377 struct scsi_transport_template *scsit, 378 uint32_t initial_cmdsn, uint32_t *hostno) 379 { 380 struct iscsi_cls_session *cls_session; 381 struct iscsi_session *session; 382 int i; 383 uint32_t hn; 384 struct iscsi_cmd_task *ctask; 385 struct iscsi_mgmt_task *mtask; 386 struct iscsi_iser_cmd_task *iser_ctask; 387 struct iser_desc *desc; 388 389 cls_session = iscsi_session_setup(iscsit, scsit, 390 sizeof(struct iscsi_iser_cmd_task), 391 sizeof(struct iser_desc), 392 initial_cmdsn, &hn); 393 if (!cls_session) 394 return NULL; 395 396 *hostno = hn; 397 session = class_to_transport_session(cls_session); 398 399 /* libiscsi setup itts, data and pool so just set desc fields */ 400 for (i = 0; i < session->cmds_max; i++) { 401 ctask = session->cmds[i]; 402 iser_ctask = ctask->dd_data; 403 ctask->hdr = (struct iscsi_cmd *)&iser_ctask->desc.iscsi_header; 404 } 405 406 for (i = 0; i < session->mgmtpool_max; i++) { 407 mtask = session->mgmt_cmds[i]; 408 desc = mtask->dd_data; 409 mtask->hdr = &desc->iscsi_header; 410 desc->data = mtask->data; 411 } 412 413 return cls_session; 414 } 415 416 static int 417 iscsi_iser_set_param(struct iscsi_cls_conn *cls_conn, 418 enum iscsi_param param, char *buf, int buflen) 419 { 420 int value; 421 422 switch (param) { 423 case ISCSI_PARAM_MAX_RECV_DLENGTH: 424 /* TBD */ 425 break; 426 case ISCSI_PARAM_HDRDGST_EN: 427 sscanf(buf, "%d", &value); 428 if (value) { 429 printk(KERN_ERR "DataDigest wasn't negotiated to None"); 430 return -EPROTO; 431 } 432 break; 433 case ISCSI_PARAM_DATADGST_EN: 434 sscanf(buf, "%d", &value); 435 if (value) { 436 printk(KERN_ERR "DataDigest wasn't negotiated to None"); 437 return -EPROTO; 438 } 439 break; 440 case ISCSI_PARAM_IFMARKER_EN: 441 sscanf(buf, "%d", &value); 442 if (value) { 443 printk(KERN_ERR "IFMarker wasn't negotiated to No"); 444 return -EPROTO; 445 } 446 break; 447 case ISCSI_PARAM_OFMARKER_EN: 448 sscanf(buf, "%d", &value); 449 if (value) { 450 printk(KERN_ERR "OFMarker wasn't negotiated to No"); 451 return -EPROTO; 452 } 453 break; 454 default: 455 return iscsi_set_param(cls_conn, param, buf, buflen); 456 } 457 458 return 0; 459 } 460 461 static void 462 iscsi_iser_conn_get_stats(struct iscsi_cls_conn *cls_conn, struct iscsi_stats *stats) 463 { 464 struct iscsi_conn *conn = cls_conn->dd_data; 465 466 stats->txdata_octets = conn->txdata_octets; 467 stats->rxdata_octets = conn->rxdata_octets; 468 stats->scsicmd_pdus = conn->scsicmd_pdus_cnt; 469 stats->dataout_pdus = conn->dataout_pdus_cnt; 470 stats->scsirsp_pdus = conn->scsirsp_pdus_cnt; 471 stats->datain_pdus = conn->datain_pdus_cnt; /* always 0 */ 472 stats->r2t_pdus = conn->r2t_pdus_cnt; /* always 0 */ 473 stats->tmfcmd_pdus = conn->tmfcmd_pdus_cnt; 474 stats->tmfrsp_pdus = conn->tmfrsp_pdus_cnt; 475 stats->custom_length = 3; 476 strcpy(stats->custom[0].desc, "qp_tx_queue_full"); 477 stats->custom[0].value = 0; /* TB iser_conn->qp_tx_queue_full; */ 478 strcpy(stats->custom[1].desc, "fmr_map_not_avail"); 479 stats->custom[1].value = 0; /* TB iser_conn->fmr_map_not_avail */; 480 strcpy(stats->custom[2].desc, "eh_abort_cnt"); 481 stats->custom[2].value = conn->eh_abort_cnt; 482 } 483 484 static int 485 iscsi_iser_ep_connect(struct sockaddr *dst_addr, int non_blocking, 486 __u64 *ep_handle) 487 { 488 int err; 489 struct iser_conn *ib_conn; 490 491 err = iser_conn_init(&ib_conn); 492 if (err) 493 goto out; 494 495 err = iser_connect(ib_conn, NULL, (struct sockaddr_in *)dst_addr, non_blocking); 496 if (!err) 497 *ep_handle = (__u64)(unsigned long)ib_conn; 498 499 out: 500 return err; 501 } 502 503 static int 504 iscsi_iser_ep_poll(__u64 ep_handle, int timeout_ms) 505 { 506 struct iser_conn *ib_conn = iscsi_iser_ib_conn_lookup(ep_handle); 507 int rc; 508 509 if (!ib_conn) 510 return -EINVAL; 511 512 rc = wait_event_interruptible_timeout(ib_conn->wait, 513 ib_conn->state == ISER_CONN_UP, 514 msecs_to_jiffies(timeout_ms)); 515 516 /* if conn establishment failed, return error code to iscsi */ 517 if (!rc && 518 (ib_conn->state == ISER_CONN_TERMINATING || 519 ib_conn->state == ISER_CONN_DOWN)) 520 rc = -1; 521 522 iser_err("ib conn %p rc = %d\n", ib_conn, rc); 523 524 if (rc > 0) 525 return 1; /* success, this is the equivalent of POLLOUT */ 526 else if (!rc) 527 return 0; /* timeout */ 528 else 529 return rc; /* signal */ 530 } 531 532 static void 533 iscsi_iser_ep_disconnect(__u64 ep_handle) 534 { 535 struct iser_conn *ib_conn; 536 537 ib_conn = iscsi_iser_ib_conn_lookup(ep_handle); 538 if (!ib_conn) 539 return; 540 541 iser_err("ib conn %p state %d\n",ib_conn, ib_conn->state); 542 iser_conn_terminate(ib_conn); 543 } 544 545 static struct scsi_host_template iscsi_iser_sht = { 546 .name = "iSCSI Initiator over iSER, v." DRV_VER, 547 .queuecommand = iscsi_queuecommand, 548 .can_queue = ISCSI_XMIT_CMDS_MAX - 1, 549 .sg_tablesize = ISCSI_ISER_SG_TABLESIZE, 550 .max_sectors = 1024, 551 .cmd_per_lun = ISCSI_MAX_CMD_PER_LUN, 552 .eh_abort_handler = iscsi_eh_abort, 553 .eh_host_reset_handler = iscsi_eh_host_reset, 554 .use_clustering = DISABLE_CLUSTERING, 555 .proc_name = "iscsi_iser", 556 .this_id = -1, 557 }; 558 559 static struct iscsi_transport iscsi_iser_transport = { 560 .owner = THIS_MODULE, 561 .name = "iser", 562 .caps = CAP_RECOVERY_L0 | CAP_MULTI_R2T, 563 .param_mask = ISCSI_MAX_RECV_DLENGTH | 564 ISCSI_MAX_XMIT_DLENGTH | 565 ISCSI_HDRDGST_EN | 566 ISCSI_DATADGST_EN | 567 ISCSI_INITIAL_R2T_EN | 568 ISCSI_MAX_R2T | 569 ISCSI_IMM_DATA_EN | 570 ISCSI_FIRST_BURST | 571 ISCSI_MAX_BURST | 572 ISCSI_PDU_INORDER_EN | 573 ISCSI_DATASEQ_INORDER_EN | 574 ISCSI_EXP_STATSN | 575 ISCSI_PERSISTENT_PORT | 576 ISCSI_PERSISTENT_ADDRESS | 577 ISCSI_TARGET_NAME | 578 ISCSI_TPGT, 579 .host_template = &iscsi_iser_sht, 580 .conndata_size = sizeof(struct iscsi_conn), 581 .max_lun = ISCSI_ISER_MAX_LUN, 582 .max_cmd_len = ISCSI_ISER_MAX_CMD_LEN, 583 /* session management */ 584 .create_session = iscsi_iser_session_create, 585 .destroy_session = iscsi_session_teardown, 586 /* connection management */ 587 .create_conn = iscsi_iser_conn_create, 588 .bind_conn = iscsi_iser_conn_bind, 589 .destroy_conn = iscsi_iser_conn_destroy, 590 .set_param = iscsi_iser_set_param, 591 .get_conn_param = iscsi_conn_get_param, 592 .get_session_param = iscsi_session_get_param, 593 .start_conn = iscsi_iser_conn_start, 594 .stop_conn = iscsi_conn_stop, 595 /* IO */ 596 .send_pdu = iscsi_conn_send_pdu, 597 .get_stats = iscsi_iser_conn_get_stats, 598 .init_cmd_task = iscsi_iser_cmd_init, 599 .xmit_cmd_task = iscsi_iser_ctask_xmit, 600 .xmit_mgmt_task = iscsi_iser_mtask_xmit, 601 .cleanup_cmd_task = iscsi_iser_cleanup_ctask, 602 /* recovery */ 603 .session_recovery_timedout = iscsi_session_recovery_timedout, 604 605 .ep_connect = iscsi_iser_ep_connect, 606 .ep_poll = iscsi_iser_ep_poll, 607 .ep_disconnect = iscsi_iser_ep_disconnect 608 }; 609 610 static int __init iser_init(void) 611 { 612 int err; 613 614 iser_dbg("Starting iSER datamover...\n"); 615 616 if (iscsi_max_lun < 1) { 617 printk(KERN_ERR "Invalid max_lun value of %u\n", iscsi_max_lun); 618 return -EINVAL; 619 } 620 621 iscsi_iser_transport.max_lun = iscsi_max_lun; 622 623 memset(&ig, 0, sizeof(struct iser_global)); 624 625 ig.desc_cache = kmem_cache_create("iser_descriptors", 626 sizeof (struct iser_desc), 627 0, SLAB_HWCACHE_ALIGN, 628 NULL, NULL); 629 if (ig.desc_cache == NULL) 630 return -ENOMEM; 631 632 /* device init is called only after the first addr resolution */ 633 mutex_init(&ig.device_list_mutex); 634 INIT_LIST_HEAD(&ig.device_list); 635 mutex_init(&ig.connlist_mutex); 636 INIT_LIST_HEAD(&ig.connlist); 637 638 if (!iscsi_register_transport(&iscsi_iser_transport)) { 639 iser_err("iscsi_register_transport failed\n"); 640 err = -EINVAL; 641 goto register_transport_failure; 642 } 643 644 return 0; 645 646 register_transport_failure: 647 kmem_cache_destroy(ig.desc_cache); 648 649 return err; 650 } 651 652 static void __exit iser_exit(void) 653 { 654 iser_dbg("Removing iSER datamover...\n"); 655 iscsi_unregister_transport(&iscsi_iser_transport); 656 kmem_cache_destroy(ig.desc_cache); 657 } 658 659 module_init(iser_init); 660 module_exit(iser_exit); 661