2 * iSCSI Initiator over iSER Data-Path
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
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:
16 * Redistribution and use in source and binary forms, with or
17 * without modification, are permitted provided that the following
20 * - Redistributions of source code must retain the above
21 * copyright notice, this list of conditions and the following
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.
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
47 * $Id: iscsi_iser.c 6965 2006-05-07 11:36:20Z ogerlitz $
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>
59 #include <linux/net.h>
60 #include <linux/scatterlist.h>
61 #include <linux/delay.h>
65 #include <asm/uaccess.h>
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>
75 #include "iscsi_iser.h"
77 static unsigned int iscsi_max_lun
= 512;
78 module_param_named(max_lun
, iscsi_max_lun
, uint
, S_IRUGO
);
80 int iser_debug_level
= 0;
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");
87 module_param_named(debug_level
, iser_debug_level
, int, 0644);
88 MODULE_PARM_DESC(debug_level
, "Enable debug tracing if > 0 (default:disabled)");
90 struct iser_global ig
;
93 iscsi_iser_recv(struct iscsi_conn
*conn
,
94 struct iscsi_hdr
*hdr
, char *rx_data
, int rx_data_len
)
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
;
111 ahslen
= hdr
->hlength
* 4;
113 /* verify itt (itt encoding: age+cid+itt) */
114 rc
= iscsi_verify_itt(conn
, hdr
, &ret_itt
);
117 rc
= iscsi_complete_pdu(conn
, hdr
, rx_data
, rx_data_len
);
119 if (rc
&& rc
!= ISCSI_ERR_NO_SCSI_CMD
)
124 iscsi_conn_failure(conn
, rc
);
129 * iscsi_iser_cmd_init - Initialize iSCSI SCSI_READ or SCSI_WRITE commands
133 iscsi_iser_cmd_init(struct iscsi_cmd_task
*ctask
)
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
;
139 iser_ctask
->command_sent
= 0;
140 iser_ctask
->iser_conn
= iser_conn
;
142 if (sc
->sc_data_direction
== DMA_TO_DEVICE
) {
143 BUG_ON(ctask
->total_length
== 0);
144 /* bytes to be sent via RDMA operations */
145 iser_ctask
->rdma_data_count
= ctask
->total_length
-
149 debug_scsi("cmd [itt %x total %d imm %d unsol_data %d "
151 ctask
->itt
, ctask
->total_length
, ctask
->imm_count
,
152 ctask
->unsol_count
, iser_ctask
->rdma_data_count
);
154 /* bytes to be sent via RDMA operations */
155 iser_ctask
->rdma_data_count
= ctask
->total_length
;
157 iser_ctask_rdma_init(iser_ctask
);
161 * iscsi_mtask_xmit - xmit management(immediate) task
162 * @conn: iscsi connection
163 * @mtask: task management task
166 * The function can return -EAGAIN in which case caller must
167 * call it again later, or recover. '0' return code means successful
172 iscsi_iser_mtask_xmit(struct iscsi_conn
*conn
,
173 struct iscsi_mgmt_task
*mtask
)
177 debug_scsi("mtask deq [cid %d itt 0x%x]\n", conn
->id
, mtask
->itt
);
179 error
= iser_send_control(conn
, mtask
);
181 /* since iser xmits control with zero copy, mtasks can not be recycled
182 * right after sending them.
183 * The recycling scheme is based on whether a response is expected
184 * - if yes, the mtask is recycled at iscsi_complete_pdu
185 * - if no, the mtask is recycled at iser_snd_completion
187 if (error
&& error
!= -EAGAIN
)
188 iscsi_conn_failure(conn
, ISCSI_ERR_CONN_FAILED
);
194 iscsi_iser_ctask_xmit_unsol_data(struct iscsi_conn
*conn
,
195 struct iscsi_cmd_task
*ctask
)
197 struct iscsi_data hdr
;
199 struct iscsi_iser_cmd_task
*iser_ctask
= ctask
->dd_data
;
201 /* Send data-out PDUs while there's still unsolicited data to send */
202 while (ctask
->unsol_count
> 0) {
203 iscsi_prep_unsolicit_data_pdu(ctask
, &hdr
,
204 iser_ctask
->rdma_data_count
);
206 debug_scsi("Sending data-out: itt 0x%x, data count %d\n",
207 hdr
.itt
, ctask
->data_count
);
209 /* the buffer description has been passed with the command */
210 /* Send the command */
211 error
= iser_send_data_out(conn
, ctask
, &hdr
);
213 ctask
->unsol_datasn
--;
214 goto iscsi_iser_ctask_xmit_unsol_data_exit
;
216 ctask
->unsol_count
-= ctask
->data_count
;
217 debug_scsi("Need to send %d more as data-out PDUs\n",
221 iscsi_iser_ctask_xmit_unsol_data_exit
:
226 iscsi_iser_ctask_xmit(struct iscsi_conn
*conn
,
227 struct iscsi_cmd_task
*ctask
)
229 struct iscsi_iser_cmd_task
*iser_ctask
= ctask
->dd_data
;
232 debug_scsi("ctask deq [cid %d itt 0x%x]\n",
233 conn
->id
, ctask
->itt
);
236 * serialize with TMF AbortTask
241 /* Send the cmd PDU */
242 if (!iser_ctask
->command_sent
) {
243 error
= iser_send_command(conn
, ctask
);
245 goto iscsi_iser_ctask_xmit_exit
;
246 iser_ctask
->command_sent
= 1;
249 /* Send unsolicited data-out PDU(s) if necessary */
250 if (ctask
->unsol_count
)
251 error
= iscsi_iser_ctask_xmit_unsol_data(conn
, ctask
);
253 iscsi_iser_ctask_xmit_exit
:
254 if (error
&& error
!= -EAGAIN
)
255 iscsi_conn_failure(conn
, ISCSI_ERR_CONN_FAILED
);
260 iscsi_iser_cleanup_ctask(struct iscsi_conn
*conn
, struct iscsi_cmd_task
*ctask
)
262 struct iscsi_iser_cmd_task
*iser_ctask
= ctask
->dd_data
;
264 if (iser_ctask
->status
== ISER_TASK_STATUS_STARTED
) {
265 iser_ctask
->status
= ISER_TASK_STATUS_COMPLETED
;
266 iser_ctask_rdma_finalize(iser_ctask
);
270 static struct iser_conn
*
271 iscsi_iser_ib_conn_lookup(__u64 ep_handle
)
273 struct iser_conn
*ib_conn
;
274 struct iser_conn
*uib_conn
= (struct iser_conn
*)(unsigned long)ep_handle
;
276 mutex_lock(&ig
.connlist_mutex
);
277 list_for_each_entry(ib_conn
, &ig
.connlist
, conn_list
) {
278 if (ib_conn
== uib_conn
) {
279 mutex_unlock(&ig
.connlist_mutex
);
283 mutex_unlock(&ig
.connlist_mutex
);
284 iser_err("no conn exists for eph %llx\n",(unsigned long long)ep_handle
);
288 static struct iscsi_cls_conn
*
289 iscsi_iser_conn_create(struct iscsi_cls_session
*cls_session
, uint32_t conn_idx
)
291 struct iscsi_conn
*conn
;
292 struct iscsi_cls_conn
*cls_conn
;
293 struct iscsi_iser_conn
*iser_conn
;
295 cls_conn
= iscsi_conn_setup(cls_session
, conn_idx
);
298 conn
= cls_conn
->dd_data
;
301 * due to issues with the login code re iser sematics
302 * this not set in iscsi_conn_setup - FIXME
304 conn
->max_recv_dlength
= 128;
306 iser_conn
= kzalloc(sizeof(*iser_conn
), GFP_KERNEL
);
308 goto conn_alloc_fail
;
310 /* currently this is the only field which need to be initiated */
311 rwlock_init(&iser_conn
->lock
);
313 conn
->dd_data
= iser_conn
;
314 iser_conn
->iscsi_conn
= conn
;
319 iscsi_conn_teardown(cls_conn
);
324 iscsi_iser_conn_destroy(struct iscsi_cls_conn
*cls_conn
)
326 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
327 struct iscsi_iser_conn
*iser_conn
= conn
->dd_data
;
329 iscsi_conn_teardown(cls_conn
);
334 iscsi_iser_conn_bind(struct iscsi_cls_session
*cls_session
,
335 struct iscsi_cls_conn
*cls_conn
, uint64_t transport_eph
,
338 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
339 struct iscsi_iser_conn
*iser_conn
;
340 struct iser_conn
*ib_conn
;
343 error
= iscsi_conn_bind(cls_session
, cls_conn
, is_leading
);
347 /* the transport ep handle comes from user space so it must be
348 * verified against the global ib connections list */
349 ib_conn
= iscsi_iser_ib_conn_lookup(transport_eph
);
351 iser_err("can't bind eph %llx\n",
352 (unsigned long long)transport_eph
);
355 /* binds the iSER connection retrieved from the previously
356 * connected ep_handle to the iSCSI layer connection. exchanges
357 * connection pointers */
358 iser_err("binding iscsi conn %p to iser_conn %p\n",conn
,ib_conn
);
359 iser_conn
= conn
->dd_data
;
360 ib_conn
->iser_conn
= iser_conn
;
361 iser_conn
->ib_conn
= ib_conn
;
363 conn
->recv_lock
= &iser_conn
->lock
;
369 iscsi_iser_conn_start(struct iscsi_cls_conn
*cls_conn
)
371 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
374 err
= iscsi_conn_start(cls_conn
);
378 return iser_conn_set_full_featured_mode(conn
);
382 iscsi_iser_conn_terminate(struct iscsi_conn
*conn
)
384 struct iscsi_iser_conn
*iser_conn
= conn
->dd_data
;
385 struct iser_conn
*ib_conn
= iser_conn
->ib_conn
;
388 /* starts conn teardown process, waits until all previously *
389 * posted buffers get flushed, deallocates all conn resources */
390 iser_conn_terminate(ib_conn
);
391 iser_conn
->ib_conn
= NULL
;
392 conn
->recv_lock
= NULL
;
396 static struct iscsi_transport iscsi_iser_transport
;
398 static struct iscsi_cls_session
*
399 iscsi_iser_session_create(struct iscsi_transport
*iscsit
,
400 struct scsi_transport_template
*scsit
,
401 uint32_t initial_cmdsn
, uint32_t *hostno
)
403 struct iscsi_cls_session
*cls_session
;
404 struct iscsi_session
*session
;
407 struct iscsi_cmd_task
*ctask
;
408 struct iscsi_mgmt_task
*mtask
;
409 struct iscsi_iser_cmd_task
*iser_ctask
;
410 struct iser_desc
*desc
;
412 cls_session
= iscsi_session_setup(iscsit
, scsit
,
413 sizeof(struct iscsi_iser_cmd_task
),
414 sizeof(struct iser_desc
),
420 session
= class_to_transport_session(cls_session
);
422 /* libiscsi setup itts, data and pool so just set desc fields */
423 for (i
= 0; i
< session
->cmds_max
; i
++) {
424 ctask
= session
->cmds
[i
];
425 iser_ctask
= ctask
->dd_data
;
426 ctask
->hdr
= (struct iscsi_cmd
*)&iser_ctask
->desc
.iscsi_header
;
429 for (i
= 0; i
< session
->mgmtpool_max
; i
++) {
430 mtask
= session
->mgmt_cmds
[i
];
431 desc
= mtask
->dd_data
;
432 mtask
->hdr
= &desc
->iscsi_header
;
433 desc
->data
= mtask
->data
;
440 iscsi_iser_conn_set_param(struct iscsi_cls_conn
*cls_conn
,
441 enum iscsi_param param
, uint32_t value
)
443 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
444 struct iscsi_session
*session
= conn
->session
;
446 spin_lock_bh(&session
->lock
);
447 if (conn
->c_stage
!= ISCSI_CONN_INITIAL_STAGE
&&
448 conn
->stop_stage
!= STOP_CONN_RECOVER
) {
449 printk(KERN_ERR
"iscsi_iser: can not change parameter [%d]\n",
451 spin_unlock_bh(&session
->lock
);
454 spin_unlock_bh(&session
->lock
);
457 case ISCSI_PARAM_MAX_RECV_DLENGTH
:
460 case ISCSI_PARAM_MAX_XMIT_DLENGTH
:
461 conn
->max_xmit_dlength
= value
;
463 case ISCSI_PARAM_HDRDGST_EN
:
465 printk(KERN_ERR
"DataDigest wasn't negotiated to None");
469 case ISCSI_PARAM_DATADGST_EN
:
471 printk(KERN_ERR
"DataDigest wasn't negotiated to None");
475 case ISCSI_PARAM_INITIAL_R2T_EN
:
476 session
->initial_r2t_en
= value
;
478 case ISCSI_PARAM_IMM_DATA_EN
:
479 session
->imm_data_en
= value
;
481 case ISCSI_PARAM_FIRST_BURST
:
482 session
->first_burst
= value
;
484 case ISCSI_PARAM_MAX_BURST
:
485 session
->max_burst
= value
;
487 case ISCSI_PARAM_PDU_INORDER_EN
:
488 session
->pdu_inorder_en
= value
;
490 case ISCSI_PARAM_DATASEQ_INORDER_EN
:
491 session
->dataseq_inorder_en
= value
;
493 case ISCSI_PARAM_ERL
:
494 session
->erl
= value
;
496 case ISCSI_PARAM_IFMARKER_EN
:
498 printk(KERN_ERR
"IFMarker wasn't negotiated to No");
502 case ISCSI_PARAM_OFMARKER_EN
:
504 printk(KERN_ERR
"OFMarker wasn't negotiated to No");
516 iscsi_iser_session_get_param(struct iscsi_cls_session
*cls_session
,
517 enum iscsi_param param
, uint32_t *value
)
519 struct Scsi_Host
*shost
= iscsi_session_to_shost(cls_session
);
520 struct iscsi_session
*session
= iscsi_hostdata(shost
->hostdata
);
523 case ISCSI_PARAM_INITIAL_R2T_EN
:
524 *value
= session
->initial_r2t_en
;
526 case ISCSI_PARAM_MAX_R2T
:
527 *value
= session
->max_r2t
;
529 case ISCSI_PARAM_IMM_DATA_EN
:
530 *value
= session
->imm_data_en
;
532 case ISCSI_PARAM_FIRST_BURST
:
533 *value
= session
->first_burst
;
535 case ISCSI_PARAM_MAX_BURST
:
536 *value
= session
->max_burst
;
538 case ISCSI_PARAM_PDU_INORDER_EN
:
539 *value
= session
->pdu_inorder_en
;
541 case ISCSI_PARAM_DATASEQ_INORDER_EN
:
542 *value
= session
->dataseq_inorder_en
;
544 case ISCSI_PARAM_ERL
:
545 *value
= session
->erl
;
547 case ISCSI_PARAM_IFMARKER_EN
:
550 case ISCSI_PARAM_OFMARKER_EN
:
554 return ISCSI_ERR_PARAM_NOT_FOUND
;
561 iscsi_iser_conn_get_param(struct iscsi_cls_conn
*cls_conn
,
562 enum iscsi_param param
, uint32_t *value
)
564 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
567 case ISCSI_PARAM_MAX_RECV_DLENGTH
:
568 *value
= conn
->max_recv_dlength
;
570 case ISCSI_PARAM_MAX_XMIT_DLENGTH
:
571 *value
= conn
->max_xmit_dlength
;
573 case ISCSI_PARAM_HDRDGST_EN
:
576 case ISCSI_PARAM_DATADGST_EN
:
579 /*case ISCSI_PARAM_TARGET_RECV_DLENGTH:
580 *value = conn->target_recv_dlength;
582 case ISCSI_PARAM_INITIATOR_RECV_DLENGTH:
583 *value = conn->initiator_recv_dlength;
586 return ISCSI_ERR_PARAM_NOT_FOUND
;
594 iscsi_iser_conn_get_stats(struct iscsi_cls_conn
*cls_conn
, struct iscsi_stats
*stats
)
596 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
598 stats
->txdata_octets
= conn
->txdata_octets
;
599 stats
->rxdata_octets
= conn
->rxdata_octets
;
600 stats
->scsicmd_pdus
= conn
->scsicmd_pdus_cnt
;
601 stats
->dataout_pdus
= conn
->dataout_pdus_cnt
;
602 stats
->scsirsp_pdus
= conn
->scsirsp_pdus_cnt
;
603 stats
->datain_pdus
= conn
->datain_pdus_cnt
; /* always 0 */
604 stats
->r2t_pdus
= conn
->r2t_pdus_cnt
; /* always 0 */
605 stats
->tmfcmd_pdus
= conn
->tmfcmd_pdus_cnt
;
606 stats
->tmfrsp_pdus
= conn
->tmfrsp_pdus_cnt
;
607 stats
->custom_length
= 3;
608 strcpy(stats
->custom
[0].desc
, "qp_tx_queue_full");
609 stats
->custom
[0].value
= 0; /* TB iser_conn->qp_tx_queue_full; */
610 strcpy(stats
->custom
[1].desc
, "fmr_map_not_avail");
611 stats
->custom
[1].value
= 0; /* TB iser_conn->fmr_map_not_avail */;
612 strcpy(stats
->custom
[2].desc
, "eh_abort_cnt");
613 stats
->custom
[2].value
= conn
->eh_abort_cnt
;
617 iscsi_iser_ep_connect(struct sockaddr
*dst_addr
, int non_blocking
,
621 struct iser_conn
*ib_conn
;
623 err
= iser_conn_init(&ib_conn
);
627 err
= iser_connect(ib_conn
, NULL
, (struct sockaddr_in
*)dst_addr
, non_blocking
);
629 *ep_handle
= (__u64
)(unsigned long)ib_conn
;
636 iscsi_iser_ep_poll(__u64 ep_handle
, int timeout_ms
)
638 struct iser_conn
*ib_conn
= iscsi_iser_ib_conn_lookup(ep_handle
);
644 rc
= wait_event_interruptible_timeout(ib_conn
->wait
,
645 ib_conn
->state
== ISER_CONN_UP
,
646 msecs_to_jiffies(timeout_ms
));
648 /* if conn establishment failed, return error code to iscsi */
650 (ib_conn
->state
== ISER_CONN_TERMINATING
||
651 ib_conn
->state
== ISER_CONN_DOWN
))
654 iser_err("ib conn %p rc = %d\n", ib_conn
, rc
);
657 return 1; /* success, this is the equivalent of POLLOUT */
659 return 0; /* timeout */
661 return rc
; /* signal */
665 iscsi_iser_ep_disconnect(__u64 ep_handle
)
667 struct iser_conn
*ib_conn
= iscsi_iser_ib_conn_lookup(ep_handle
);
672 iser_err("ib conn %p state %d\n",ib_conn
, ib_conn
->state
);
674 iser_conn_terminate(ib_conn
);
677 static struct scsi_host_template iscsi_iser_sht
= {
678 .name
= "iSCSI Initiator over iSER, v." DRV_VER
,
679 .queuecommand
= iscsi_queuecommand
,
680 .can_queue
= ISCSI_XMIT_CMDS_MAX
- 1,
681 .sg_tablesize
= ISCSI_ISER_SG_TABLESIZE
,
682 .cmd_per_lun
= ISCSI_MAX_CMD_PER_LUN
,
683 .eh_abort_handler
= iscsi_eh_abort
,
684 .eh_host_reset_handler
= iscsi_eh_host_reset
,
685 .use_clustering
= DISABLE_CLUSTERING
,
686 .proc_name
= "iscsi_iser",
690 static struct iscsi_transport iscsi_iser_transport
= {
691 .owner
= THIS_MODULE
,
693 .caps
= CAP_RECOVERY_L0
| CAP_MULTI_R2T
,
694 .param_mask
= ISCSI_MAX_RECV_DLENGTH
|
695 ISCSI_MAX_XMIT_DLENGTH
|
698 ISCSI_INITIAL_R2T_EN
|
703 ISCSI_PDU_INORDER_EN
|
704 ISCSI_DATASEQ_INORDER_EN
,
705 .host_template
= &iscsi_iser_sht
,
706 .conndata_size
= sizeof(struct iscsi_conn
),
707 .max_lun
= ISCSI_ISER_MAX_LUN
,
708 .max_cmd_len
= ISCSI_ISER_MAX_CMD_LEN
,
709 /* session management */
710 .create_session
= iscsi_iser_session_create
,
711 .destroy_session
= iscsi_session_teardown
,
712 /* connection management */
713 .create_conn
= iscsi_iser_conn_create
,
714 .bind_conn
= iscsi_iser_conn_bind
,
715 .destroy_conn
= iscsi_iser_conn_destroy
,
716 .set_param
= iscsi_iser_conn_set_param
,
717 .get_conn_param
= iscsi_iser_conn_get_param
,
718 .get_session_param
= iscsi_iser_session_get_param
,
719 .start_conn
= iscsi_iser_conn_start
,
720 .stop_conn
= iscsi_conn_stop
,
721 /* these are called as part of conn recovery */
722 .suspend_conn_recv
= NULL
, /* FIXME is/how this relvant to iser? */
723 .terminate_conn
= iscsi_iser_conn_terminate
,
725 .send_pdu
= iscsi_conn_send_pdu
,
726 .get_stats
= iscsi_iser_conn_get_stats
,
727 .init_cmd_task
= iscsi_iser_cmd_init
,
728 .xmit_cmd_task
= iscsi_iser_ctask_xmit
,
729 .xmit_mgmt_task
= iscsi_iser_mtask_xmit
,
730 .cleanup_cmd_task
= iscsi_iser_cleanup_ctask
,
732 .session_recovery_timedout
= iscsi_session_recovery_timedout
,
734 .ep_connect
= iscsi_iser_ep_connect
,
735 .ep_poll
= iscsi_iser_ep_poll
,
736 .ep_disconnect
= iscsi_iser_ep_disconnect
739 static int __init
iser_init(void)
743 iser_dbg("Starting iSER datamover...\n");
745 if (iscsi_max_lun
< 1) {
746 printk(KERN_ERR
"Invalid max_lun value of %u\n", iscsi_max_lun
);
750 iscsi_iser_transport
.max_lun
= iscsi_max_lun
;
752 memset(&ig
, 0, sizeof(struct iser_global
));
754 ig
.desc_cache
= kmem_cache_create("iser_descriptors",
755 sizeof (struct iser_desc
),
756 0, SLAB_HWCACHE_ALIGN
,
758 if (ig
.desc_cache
== NULL
)
761 /* device init is called only after the first addr resolution */
762 mutex_init(&ig
.device_list_mutex
);
763 INIT_LIST_HEAD(&ig
.device_list
);
764 mutex_init(&ig
.connlist_mutex
);
765 INIT_LIST_HEAD(&ig
.connlist
);
767 if (!iscsi_register_transport(&iscsi_iser_transport
)) {
768 iser_err("iscsi_register_transport failed\n");
770 goto register_transport_failure
;
775 register_transport_failure
:
776 kmem_cache_destroy(ig
.desc_cache
);
781 static void __exit
iser_exit(void)
783 iser_dbg("Removing iSER datamover...\n");
784 iscsi_unregister_transport(&iscsi_iser_transport
);
785 kmem_cache_destroy(ig
.desc_cache
);
788 module_init(iser_init
);
789 module_exit(iser_exit
);