4 * Copyright (C) 2006 Red Hat, Inc. All rights reserved.
5 * Copyright (C) 2004 - 2006 Mike Christie
6 * Copyright (C) 2004 - 2005 Dmitry Yusupov
7 * Copyright (C) 2004 - 2005 Alex Aizman
8 * maintained by open-iscsi@googlegroups.com
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 #include <linux/types.h>
25 #include <linux/kfifo.h>
26 #include <linux/delay.h>
27 #include <linux/log2.h>
28 #include <asm/unaligned.h>
30 #include <scsi/scsi_cmnd.h>
31 #include <scsi/scsi_device.h>
32 #include <scsi/scsi_eh.h>
33 #include <scsi/scsi_tcq.h>
34 #include <scsi/scsi_host.h>
35 #include <scsi/scsi.h>
36 #include <scsi/iscsi_proto.h>
37 #include <scsi/scsi_transport.h>
38 #include <scsi/scsi_transport_iscsi.h>
39 #include <scsi/libiscsi.h>
41 static int iscsi_dbg_lib
;
42 module_param_named(debug_libiscsi
, iscsi_dbg_lib
, int, S_IRUGO
| S_IWUSR
);
43 MODULE_PARM_DESC(debug_libiscsi
, "Turn on debugging for libiscsi module. "
44 "Set to 1 to turn on, and zero to turn off. Default "
47 #define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...) \
50 iscsi_conn_printk(KERN_INFO, _conn, \
55 #define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...) \
58 iscsi_session_printk(KERN_INFO, _session, \
63 /* Serial Number Arithmetic, 32 bits, less than, RFC1982 */
64 #define SNA32_CHECK 2147483648UL
66 static int iscsi_sna_lt(u32 n1
, u32 n2
)
68 return n1
!= n2
&& ((n1
< n2
&& (n2
- n1
< SNA32_CHECK
)) ||
69 (n1
> n2
&& (n2
- n1
< SNA32_CHECK
)));
72 /* Serial Number Arithmetic, 32 bits, less than, RFC1982 */
73 static int iscsi_sna_lte(u32 n1
, u32 n2
)
75 return n1
== n2
|| ((n1
< n2
&& (n2
- n1
< SNA32_CHECK
)) ||
76 (n1
> n2
&& (n2
- n1
< SNA32_CHECK
)));
79 inline void iscsi_conn_queue_work(struct iscsi_conn
*conn
)
81 struct Scsi_Host
*shost
= conn
->session
->host
;
82 struct iscsi_host
*ihost
= shost_priv(shost
);
85 queue_work(ihost
->workq
, &conn
->xmitwork
);
87 EXPORT_SYMBOL_GPL(iscsi_conn_queue_work
);
90 iscsi_update_cmdsn(struct iscsi_session
*session
, struct iscsi_nopin
*hdr
)
92 uint32_t max_cmdsn
= be32_to_cpu(hdr
->max_cmdsn
);
93 uint32_t exp_cmdsn
= be32_to_cpu(hdr
->exp_cmdsn
);
96 * standard specifies this check for when to update expected and
97 * max sequence numbers
99 if (iscsi_sna_lt(max_cmdsn
, exp_cmdsn
- 1))
102 if (exp_cmdsn
!= session
->exp_cmdsn
&&
103 !iscsi_sna_lt(exp_cmdsn
, session
->exp_cmdsn
))
104 session
->exp_cmdsn
= exp_cmdsn
;
106 if (max_cmdsn
!= session
->max_cmdsn
&&
107 !iscsi_sna_lt(max_cmdsn
, session
->max_cmdsn
)) {
108 session
->max_cmdsn
= max_cmdsn
;
110 * if the window closed with IO queued, then kick the
113 if (!list_empty(&session
->leadconn
->cmdqueue
) ||
114 !list_empty(&session
->leadconn
->mgmtqueue
))
115 iscsi_conn_queue_work(session
->leadconn
);
118 EXPORT_SYMBOL_GPL(iscsi_update_cmdsn
);
121 * iscsi_prep_data_out_pdu - initialize Data-Out
122 * @task: scsi command task
124 * @hdr: iscsi data in pdu
127 * Initialize Data-Out within this R2T sequence and finds
128 * proper data_offset within this SCSI command.
130 * This function is called with connection lock taken.
132 void iscsi_prep_data_out_pdu(struct iscsi_task
*task
, struct iscsi_r2t_info
*r2t
,
133 struct iscsi_data
*hdr
)
135 struct iscsi_conn
*conn
= task
->conn
;
136 unsigned int left
= r2t
->data_length
- r2t
->sent
;
138 task
->hdr_len
= sizeof(struct iscsi_data
);
140 memset(hdr
, 0, sizeof(struct iscsi_data
));
142 hdr
->datasn
= cpu_to_be32(r2t
->datasn
);
144 hdr
->opcode
= ISCSI_OP_SCSI_DATA_OUT
;
145 memcpy(hdr
->lun
, task
->lun
, sizeof(hdr
->lun
));
146 hdr
->itt
= task
->hdr_itt
;
147 hdr
->exp_statsn
= r2t
->exp_statsn
;
148 hdr
->offset
= cpu_to_be32(r2t
->data_offset
+ r2t
->sent
);
149 if (left
> conn
->max_xmit_dlength
) {
150 hton24(hdr
->dlength
, conn
->max_xmit_dlength
);
151 r2t
->data_count
= conn
->max_xmit_dlength
;
154 hton24(hdr
->dlength
, left
);
155 r2t
->data_count
= left
;
156 hdr
->flags
= ISCSI_FLAG_CMD_FINAL
;
158 conn
->dataout_pdus_cnt
++;
160 EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu
);
162 static int iscsi_add_hdr(struct iscsi_task
*task
, unsigned len
)
164 unsigned exp_len
= task
->hdr_len
+ len
;
166 if (exp_len
> task
->hdr_max
) {
171 WARN_ON(len
& (ISCSI_PAD_LEN
- 1)); /* caller must pad the AHS */
172 task
->hdr_len
= exp_len
;
177 * make an extended cdb AHS
179 static int iscsi_prep_ecdb_ahs(struct iscsi_task
*task
)
181 struct scsi_cmnd
*cmd
= task
->sc
;
182 unsigned rlen
, pad_len
;
183 unsigned short ahslength
;
184 struct iscsi_ecdb_ahdr
*ecdb_ahdr
;
187 ecdb_ahdr
= iscsi_next_hdr(task
);
188 rlen
= cmd
->cmd_len
- ISCSI_CDB_SIZE
;
190 BUG_ON(rlen
> sizeof(ecdb_ahdr
->ecdb
));
191 ahslength
= rlen
+ sizeof(ecdb_ahdr
->reserved
);
193 pad_len
= iscsi_padding(rlen
);
195 rc
= iscsi_add_hdr(task
, sizeof(ecdb_ahdr
->ahslength
) +
196 sizeof(ecdb_ahdr
->ahstype
) + ahslength
+ pad_len
);
201 memset(&ecdb_ahdr
->ecdb
[rlen
], 0, pad_len
);
203 ecdb_ahdr
->ahslength
= cpu_to_be16(ahslength
);
204 ecdb_ahdr
->ahstype
= ISCSI_AHSTYPE_CDB
;
205 ecdb_ahdr
->reserved
= 0;
206 memcpy(ecdb_ahdr
->ecdb
, cmd
->cmnd
+ ISCSI_CDB_SIZE
, rlen
);
208 ISCSI_DBG_SESSION(task
->conn
->session
,
209 "iscsi_prep_ecdb_ahs: varlen_cdb_len %d "
210 "rlen %d pad_len %d ahs_length %d iscsi_headers_size "
211 "%u\n", cmd
->cmd_len
, rlen
, pad_len
, ahslength
,
216 static int iscsi_prep_bidi_ahs(struct iscsi_task
*task
)
218 struct scsi_cmnd
*sc
= task
->sc
;
219 struct iscsi_rlength_ahdr
*rlen_ahdr
;
222 rlen_ahdr
= iscsi_next_hdr(task
);
223 rc
= iscsi_add_hdr(task
, sizeof(*rlen_ahdr
));
227 rlen_ahdr
->ahslength
=
228 cpu_to_be16(sizeof(rlen_ahdr
->read_length
) +
229 sizeof(rlen_ahdr
->reserved
));
230 rlen_ahdr
->ahstype
= ISCSI_AHSTYPE_RLENGTH
;
231 rlen_ahdr
->reserved
= 0;
232 rlen_ahdr
->read_length
= cpu_to_be32(scsi_in(sc
)->length
);
234 ISCSI_DBG_SESSION(task
->conn
->session
,
235 "bidi-in rlen_ahdr->read_length(%d) "
236 "rlen_ahdr->ahslength(%d)\n",
237 be32_to_cpu(rlen_ahdr
->read_length
),
238 be16_to_cpu(rlen_ahdr
->ahslength
));
243 * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu
246 * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set
247 * fields like dlength or final based on how much data it sends
249 static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task
*task
)
251 struct iscsi_conn
*conn
= task
->conn
;
252 struct iscsi_session
*session
= conn
->session
;
253 struct scsi_cmnd
*sc
= task
->sc
;
254 struct iscsi_cmd
*hdr
;
255 unsigned hdrlength
, cmd_len
;
259 if (conn
->session
->tt
->alloc_pdu
) {
260 rc
= conn
->session
->tt
->alloc_pdu(task
, ISCSI_OP_SCSI_CMD
);
264 hdr
= (struct iscsi_cmd
*) task
->hdr
;
266 memset(hdr
, 0, sizeof(*hdr
));
268 if (session
->tt
->parse_pdu_itt
)
269 hdr
->itt
= task
->hdr_itt
= itt
;
271 hdr
->itt
= task
->hdr_itt
= build_itt(task
->itt
,
272 task
->conn
->session
->age
);
274 rc
= iscsi_add_hdr(task
, sizeof(*hdr
));
277 hdr
->opcode
= ISCSI_OP_SCSI_CMD
;
278 hdr
->flags
= ISCSI_ATTR_SIMPLE
;
279 int_to_scsilun(sc
->device
->lun
, (struct scsi_lun
*)hdr
->lun
);
280 memcpy(task
->lun
, hdr
->lun
, sizeof(task
->lun
));
281 hdr
->cmdsn
= task
->cmdsn
= cpu_to_be32(session
->cmdsn
);
283 hdr
->exp_statsn
= cpu_to_be32(conn
->exp_statsn
);
284 cmd_len
= sc
->cmd_len
;
285 if (cmd_len
< ISCSI_CDB_SIZE
)
286 memset(&hdr
->cdb
[cmd_len
], 0, ISCSI_CDB_SIZE
- cmd_len
);
287 else if (cmd_len
> ISCSI_CDB_SIZE
) {
288 rc
= iscsi_prep_ecdb_ahs(task
);
291 cmd_len
= ISCSI_CDB_SIZE
;
293 memcpy(hdr
->cdb
, sc
->cmnd
, cmd_len
);
296 if (scsi_bidi_cmnd(sc
)) {
297 hdr
->flags
|= ISCSI_FLAG_CMD_READ
;
298 rc
= iscsi_prep_bidi_ahs(task
);
302 if (sc
->sc_data_direction
== DMA_TO_DEVICE
) {
303 unsigned out_len
= scsi_out(sc
)->length
;
304 struct iscsi_r2t_info
*r2t
= &task
->unsol_r2t
;
306 hdr
->data_length
= cpu_to_be32(out_len
);
307 hdr
->flags
|= ISCSI_FLAG_CMD_WRITE
;
311 * imm_count bytes to be sent right after
314 * unsol_count bytes(as Data-Out) to be sent
315 * without R2T ack right after
318 * r2t data_length bytes to be sent via R2T ack's
320 * pad_count bytes to be sent as zero-padding
322 memset(r2t
, 0, sizeof(*r2t
));
324 if (session
->imm_data_en
) {
325 if (out_len
>= session
->first_burst
)
326 task
->imm_count
= min(session
->first_burst
,
327 conn
->max_xmit_dlength
);
329 task
->imm_count
= min(out_len
,
330 conn
->max_xmit_dlength
);
331 hton24(hdr
->dlength
, task
->imm_count
);
333 zero_data(hdr
->dlength
);
335 if (!session
->initial_r2t_en
) {
336 r2t
->data_length
= min(session
->first_burst
, out_len
) -
338 r2t
->data_offset
= task
->imm_count
;
339 r2t
->ttt
= cpu_to_be32(ISCSI_RESERVED_TAG
);
340 r2t
->exp_statsn
= cpu_to_be32(conn
->exp_statsn
);
343 if (!task
->unsol_r2t
.data_length
)
344 /* No unsolicit Data-Out's */
345 hdr
->flags
|= ISCSI_FLAG_CMD_FINAL
;
347 hdr
->flags
|= ISCSI_FLAG_CMD_FINAL
;
348 zero_data(hdr
->dlength
);
349 hdr
->data_length
= cpu_to_be32(scsi_in(sc
)->length
);
351 if (sc
->sc_data_direction
== DMA_FROM_DEVICE
)
352 hdr
->flags
|= ISCSI_FLAG_CMD_READ
;
355 /* calculate size of additional header segments (AHSs) */
356 hdrlength
= task
->hdr_len
- sizeof(*hdr
);
358 WARN_ON(hdrlength
& (ISCSI_PAD_LEN
-1));
359 hdrlength
/= ISCSI_PAD_LEN
;
361 WARN_ON(hdrlength
>= 256);
362 hdr
->hlength
= hdrlength
& 0xFF;
364 if (session
->tt
->init_task
&& session
->tt
->init_task(task
))
367 task
->state
= ISCSI_TASK_RUNNING
;
369 conn
->scsicmd_pdus_cnt
++;
370 ISCSI_DBG_SESSION(session
, "iscsi prep [%s cid %d sc %p cdb 0x%x "
371 "itt 0x%x len %d bidi_len %d cmdsn %d win %d]\n",
372 scsi_bidi_cmnd(sc
) ? "bidirectional" :
373 sc
->sc_data_direction
== DMA_TO_DEVICE
?
374 "write" : "read", conn
->id
, sc
, sc
->cmnd
[0],
375 task
->itt
, scsi_bufflen(sc
),
376 scsi_bidi_cmnd(sc
) ? scsi_in(sc
)->length
: 0,
378 session
->max_cmdsn
- session
->exp_cmdsn
+ 1);
383 * iscsi_free_task - free a task
384 * @task: iscsi cmd task
386 * Must be called with session lock.
387 * This function returns the scsi command to scsi-ml or cleans
388 * up mgmt tasks then returns the task to the pool.
390 static void iscsi_free_task(struct iscsi_task
*task
)
392 struct iscsi_conn
*conn
= task
->conn
;
393 struct iscsi_session
*session
= conn
->session
;
394 struct scsi_cmnd
*sc
= task
->sc
;
396 ISCSI_DBG_SESSION(session
, "freeing task itt 0x%x state %d sc %p\n",
397 task
->itt
, task
->state
, task
->sc
);
399 session
->tt
->cleanup_task(task
);
400 task
->state
= ISCSI_TASK_FREE
;
403 * login task is preallocated so do not free
405 if (conn
->login_task
== task
)
408 __kfifo_put(session
->cmdpool
.queue
, (void*)&task
, sizeof(void*));
412 /* SCSI eh reuses commands to verify us */
415 * queue command may call this to free the task, but
416 * not have setup the sc callback
423 void __iscsi_get_task(struct iscsi_task
*task
)
425 atomic_inc(&task
->refcount
);
427 EXPORT_SYMBOL_GPL(__iscsi_get_task
);
429 static void __iscsi_put_task(struct iscsi_task
*task
)
431 if (atomic_dec_and_test(&task
->refcount
))
432 iscsi_free_task(task
);
435 void iscsi_put_task(struct iscsi_task
*task
)
437 struct iscsi_session
*session
= task
->conn
->session
;
439 spin_lock_bh(&session
->lock
);
440 __iscsi_put_task(task
);
441 spin_unlock_bh(&session
->lock
);
443 EXPORT_SYMBOL_GPL(iscsi_put_task
);
446 * iscsi_complete_task - finish a task
447 * @task: iscsi cmd task
448 * @state: state to complete task with
450 * Must be called with session lock.
452 static void iscsi_complete_task(struct iscsi_task
*task
, int state
)
454 struct iscsi_conn
*conn
= task
->conn
;
456 ISCSI_DBG_SESSION(conn
->session
,
457 "complete task itt 0x%x state %d sc %p\n",
458 task
->itt
, task
->state
, task
->sc
);
459 if (task
->state
== ISCSI_TASK_COMPLETED
||
460 task
->state
== ISCSI_TASK_ABRT_TMF
||
461 task
->state
== ISCSI_TASK_ABRT_SESS_RECOV
)
463 WARN_ON_ONCE(task
->state
== ISCSI_TASK_FREE
);
466 if (!list_empty(&task
->running
))
467 list_del_init(&task
->running
);
469 if (conn
->task
== task
)
472 if (conn
->ping_task
== task
)
473 conn
->ping_task
= NULL
;
475 /* release get from queueing */
476 __iscsi_put_task(task
);
480 * session lock must be held and if not called for a task that is
481 * still pending or from the xmit thread, then xmit thread must
484 static void fail_scsi_task(struct iscsi_task
*task
, int err
)
486 struct iscsi_conn
*conn
= task
->conn
;
487 struct scsi_cmnd
*sc
;
491 * if a command completes and we get a successful tmf response
492 * we will hit this because the scsi eh abort code does not take
499 if (task
->state
== ISCSI_TASK_PENDING
) {
501 * cmd never made it to the xmit thread, so we should not count
502 * the cmd in the sequencing
504 conn
->session
->queued_cmdsn
--;
505 /* it was never sent so just complete like normal */
506 state
= ISCSI_TASK_COMPLETED
;
507 } else if (err
== DID_TRANSPORT_DISRUPTED
)
508 state
= ISCSI_TASK_ABRT_SESS_RECOV
;
510 state
= ISCSI_TASK_ABRT_TMF
;
512 sc
->result
= err
<< 16;
513 if (!scsi_bidi_cmnd(sc
))
514 scsi_set_resid(sc
, scsi_bufflen(sc
));
516 scsi_out(sc
)->resid
= scsi_out(sc
)->length
;
517 scsi_in(sc
)->resid
= scsi_in(sc
)->length
;
520 iscsi_complete_task(task
, state
);
523 static int iscsi_prep_mgmt_task(struct iscsi_conn
*conn
,
524 struct iscsi_task
*task
)
526 struct iscsi_session
*session
= conn
->session
;
527 struct iscsi_hdr
*hdr
= task
->hdr
;
528 struct iscsi_nopout
*nop
= (struct iscsi_nopout
*)hdr
;
530 if (conn
->session
->state
== ISCSI_STATE_LOGGING_OUT
)
533 if (hdr
->opcode
!= (ISCSI_OP_LOGIN
| ISCSI_OP_IMMEDIATE
) &&
534 hdr
->opcode
!= (ISCSI_OP_TEXT
| ISCSI_OP_IMMEDIATE
))
535 nop
->exp_statsn
= cpu_to_be32(conn
->exp_statsn
);
537 * pre-format CmdSN for outgoing PDU.
539 nop
->cmdsn
= cpu_to_be32(session
->cmdsn
);
540 if (hdr
->itt
!= RESERVED_ITT
) {
542 * TODO: We always use immediate, so we never hit this.
543 * If we start to send tmfs or nops as non-immediate then
544 * we should start checking the cmdsn numbers for mgmt tasks.
546 if (conn
->c_stage
== ISCSI_CONN_STARTED
&&
547 !(hdr
->opcode
& ISCSI_OP_IMMEDIATE
)) {
548 session
->queued_cmdsn
++;
553 if (session
->tt
->init_task
&& session
->tt
->init_task(task
))
556 if ((hdr
->opcode
& ISCSI_OPCODE_MASK
) == ISCSI_OP_LOGOUT
)
557 session
->state
= ISCSI_STATE_LOGGING_OUT
;
559 task
->state
= ISCSI_TASK_RUNNING
;
560 ISCSI_DBG_SESSION(session
, "mgmtpdu [op 0x%x hdr->itt 0x%x "
561 "datalen %d]\n", hdr
->opcode
& ISCSI_OPCODE_MASK
,
562 hdr
->itt
, task
->data_count
);
566 static struct iscsi_task
*
567 __iscsi_conn_send_pdu(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
,
568 char *data
, uint32_t data_size
)
570 struct iscsi_session
*session
= conn
->session
;
571 struct iscsi_host
*ihost
= shost_priv(session
->host
);
572 struct iscsi_task
*task
;
575 if (session
->state
== ISCSI_STATE_TERMINATE
)
578 if (hdr
->opcode
== (ISCSI_OP_LOGIN
| ISCSI_OP_IMMEDIATE
) ||
579 hdr
->opcode
== (ISCSI_OP_TEXT
| ISCSI_OP_IMMEDIATE
))
581 * Login and Text are sent serially, in
582 * request-followed-by-response sequence.
583 * Same task can be used. Same ITT must be used.
584 * Note that login_task is preallocated at conn_create().
586 task
= conn
->login_task
;
588 if (session
->state
!= ISCSI_STATE_LOGGED_IN
)
591 BUG_ON(conn
->c_stage
== ISCSI_CONN_INITIAL_STAGE
);
592 BUG_ON(conn
->c_stage
== ISCSI_CONN_STOPPED
);
594 if (!__kfifo_get(session
->cmdpool
.queue
,
595 (void*)&task
, sizeof(void*)))
599 * released in complete pdu for task we expect a response for, and
600 * released by the lld when it has transmitted the task for
601 * pdus we do not expect a response for.
603 atomic_set(&task
->refcount
, 1);
606 INIT_LIST_HEAD(&task
->running
);
607 task
->state
= ISCSI_TASK_PENDING
;
610 memcpy(task
->data
, data
, data_size
);
611 task
->data_count
= data_size
;
613 task
->data_count
= 0;
615 if (conn
->session
->tt
->alloc_pdu
) {
616 if (conn
->session
->tt
->alloc_pdu(task
, hdr
->opcode
)) {
617 iscsi_conn_printk(KERN_ERR
, conn
, "Could not allocate "
618 "pdu for mgmt task.\n");
623 itt
= task
->hdr
->itt
;
624 task
->hdr_len
= sizeof(struct iscsi_hdr
);
625 memcpy(task
->hdr
, hdr
, sizeof(struct iscsi_hdr
));
627 if (hdr
->itt
!= RESERVED_ITT
) {
628 if (session
->tt
->parse_pdu_itt
)
629 task
->hdr
->itt
= itt
;
631 task
->hdr
->itt
= build_itt(task
->itt
,
632 task
->conn
->session
->age
);
636 if (iscsi_prep_mgmt_task(conn
, task
))
639 if (session
->tt
->xmit_task(task
))
642 list_add_tail(&task
->running
, &conn
->mgmtqueue
);
643 iscsi_conn_queue_work(conn
);
649 __iscsi_put_task(task
);
653 int iscsi_conn_send_pdu(struct iscsi_cls_conn
*cls_conn
, struct iscsi_hdr
*hdr
,
654 char *data
, uint32_t data_size
)
656 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
657 struct iscsi_session
*session
= conn
->session
;
660 spin_lock_bh(&session
->lock
);
661 if (!__iscsi_conn_send_pdu(conn
, hdr
, data
, data_size
))
663 spin_unlock_bh(&session
->lock
);
666 EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu
);
669 * iscsi_cmd_rsp - SCSI Command Response processing
670 * @conn: iscsi connection
672 * @task: scsi command task
673 * @data: cmd data buffer
674 * @datalen: len of buffer
676 * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and
677 * then completes the command and task.
679 static void iscsi_scsi_cmd_rsp(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
,
680 struct iscsi_task
*task
, char *data
,
683 struct iscsi_cmd_rsp
*rhdr
= (struct iscsi_cmd_rsp
*)hdr
;
684 struct iscsi_session
*session
= conn
->session
;
685 struct scsi_cmnd
*sc
= task
->sc
;
687 iscsi_update_cmdsn(session
, (struct iscsi_nopin
*)rhdr
);
688 conn
->exp_statsn
= be32_to_cpu(rhdr
->statsn
) + 1;
690 sc
->result
= (DID_OK
<< 16) | rhdr
->cmd_status
;
692 if (rhdr
->response
!= ISCSI_STATUS_CMD_COMPLETED
) {
693 sc
->result
= DID_ERROR
<< 16;
697 if (rhdr
->cmd_status
== SAM_STAT_CHECK_CONDITION
) {
702 iscsi_conn_printk(KERN_ERR
, conn
,
703 "Got CHECK_CONDITION but invalid data "
704 "buffer size of %d\n", datalen
);
705 sc
->result
= DID_BAD_TARGET
<< 16;
709 senselen
= get_unaligned_be16(data
);
710 if (datalen
< senselen
)
711 goto invalid_datalen
;
713 memcpy(sc
->sense_buffer
, data
+ 2,
714 min_t(uint16_t, senselen
, SCSI_SENSE_BUFFERSIZE
));
715 ISCSI_DBG_SESSION(session
, "copied %d bytes of sense\n",
716 min_t(uint16_t, senselen
,
717 SCSI_SENSE_BUFFERSIZE
));
720 if (rhdr
->flags
& (ISCSI_FLAG_CMD_BIDI_UNDERFLOW
|
721 ISCSI_FLAG_CMD_BIDI_OVERFLOW
)) {
722 int res_count
= be32_to_cpu(rhdr
->bi_residual_count
);
724 if (scsi_bidi_cmnd(sc
) && res_count
> 0 &&
725 (rhdr
->flags
& ISCSI_FLAG_CMD_BIDI_OVERFLOW
||
726 res_count
<= scsi_in(sc
)->length
))
727 scsi_in(sc
)->resid
= res_count
;
729 sc
->result
= (DID_BAD_TARGET
<< 16) | rhdr
->cmd_status
;
732 if (rhdr
->flags
& (ISCSI_FLAG_CMD_UNDERFLOW
|
733 ISCSI_FLAG_CMD_OVERFLOW
)) {
734 int res_count
= be32_to_cpu(rhdr
->residual_count
);
737 (rhdr
->flags
& ISCSI_FLAG_CMD_OVERFLOW
||
738 res_count
<= scsi_bufflen(sc
)))
739 /* write side for bidi or uni-io set_resid */
740 scsi_set_resid(sc
, res_count
);
742 sc
->result
= (DID_BAD_TARGET
<< 16) | rhdr
->cmd_status
;
745 ISCSI_DBG_SESSION(session
, "cmd rsp done [sc %p res %d itt 0x%x]\n",
746 sc
, sc
->result
, task
->itt
);
747 conn
->scsirsp_pdus_cnt
++;
748 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
752 * iscsi_data_in_rsp - SCSI Data-In Response processing
753 * @conn: iscsi connection
755 * @task: scsi command task
758 iscsi_data_in_rsp(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
,
759 struct iscsi_task
*task
)
761 struct iscsi_data_rsp
*rhdr
= (struct iscsi_data_rsp
*)hdr
;
762 struct scsi_cmnd
*sc
= task
->sc
;
764 if (!(rhdr
->flags
& ISCSI_FLAG_DATA_STATUS
))
767 iscsi_update_cmdsn(conn
->session
, (struct iscsi_nopin
*)hdr
);
768 sc
->result
= (DID_OK
<< 16) | rhdr
->cmd_status
;
769 conn
->exp_statsn
= be32_to_cpu(rhdr
->statsn
) + 1;
770 if (rhdr
->flags
& (ISCSI_FLAG_DATA_UNDERFLOW
|
771 ISCSI_FLAG_DATA_OVERFLOW
)) {
772 int res_count
= be32_to_cpu(rhdr
->residual_count
);
775 (rhdr
->flags
& ISCSI_FLAG_CMD_OVERFLOW
||
776 res_count
<= scsi_in(sc
)->length
))
777 scsi_in(sc
)->resid
= res_count
;
779 sc
->result
= (DID_BAD_TARGET
<< 16) | rhdr
->cmd_status
;
782 ISCSI_DBG_SESSION(conn
->session
, "data in with status done "
783 "[sc %p res %d itt 0x%x]\n",
784 sc
, sc
->result
, task
->itt
);
785 conn
->scsirsp_pdus_cnt
++;
786 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
789 static void iscsi_tmf_rsp(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
)
791 struct iscsi_tm_rsp
*tmf
= (struct iscsi_tm_rsp
*)hdr
;
793 conn
->exp_statsn
= be32_to_cpu(hdr
->statsn
) + 1;
794 conn
->tmfrsp_pdus_cnt
++;
796 if (conn
->tmf_state
!= TMF_QUEUED
)
799 if (tmf
->response
== ISCSI_TMF_RSP_COMPLETE
)
800 conn
->tmf_state
= TMF_SUCCESS
;
801 else if (tmf
->response
== ISCSI_TMF_RSP_NO_TASK
)
802 conn
->tmf_state
= TMF_NOT_FOUND
;
804 conn
->tmf_state
= TMF_FAILED
;
805 wake_up(&conn
->ehwait
);
808 static void iscsi_send_nopout(struct iscsi_conn
*conn
, struct iscsi_nopin
*rhdr
)
810 struct iscsi_nopout hdr
;
811 struct iscsi_task
*task
;
813 if (!rhdr
&& conn
->ping_task
)
816 memset(&hdr
, 0, sizeof(struct iscsi_nopout
));
817 hdr
.opcode
= ISCSI_OP_NOOP_OUT
| ISCSI_OP_IMMEDIATE
;
818 hdr
.flags
= ISCSI_FLAG_CMD_FINAL
;
821 memcpy(hdr
.lun
, rhdr
->lun
, 8);
823 hdr
.itt
= RESERVED_ITT
;
825 hdr
.ttt
= RESERVED_ITT
;
827 task
= __iscsi_conn_send_pdu(conn
, (struct iscsi_hdr
*)&hdr
, NULL
, 0);
829 iscsi_conn_printk(KERN_ERR
, conn
, "Could not send nopout\n");
831 /* only track our nops */
832 conn
->ping_task
= task
;
833 conn
->last_ping
= jiffies
;
837 static int iscsi_handle_reject(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
,
838 char *data
, int datalen
)
840 struct iscsi_reject
*reject
= (struct iscsi_reject
*)hdr
;
841 struct iscsi_hdr rejected_pdu
;
843 conn
->exp_statsn
= be32_to_cpu(reject
->statsn
) + 1;
845 if (reject
->reason
== ISCSI_REASON_DATA_DIGEST_ERROR
) {
846 if (ntoh24(reject
->dlength
) > datalen
)
847 return ISCSI_ERR_PROTO
;
849 if (ntoh24(reject
->dlength
) >= sizeof(struct iscsi_hdr
)) {
850 memcpy(&rejected_pdu
, data
, sizeof(struct iscsi_hdr
));
851 iscsi_conn_printk(KERN_ERR
, conn
,
852 "pdu (op 0x%x) rejected "
853 "due to DataDigest error.\n",
854 rejected_pdu
.opcode
);
861 * iscsi_itt_to_task - look up task by itt
862 * @conn: iscsi connection
865 * This should be used for mgmt tasks like login and nops, or if
866 * the LDD's itt space does not include the session age.
868 * The session lock must be held.
870 struct iscsi_task
*iscsi_itt_to_task(struct iscsi_conn
*conn
, itt_t itt
)
872 struct iscsi_session
*session
= conn
->session
;
875 if (itt
== RESERVED_ITT
)
878 if (session
->tt
->parse_pdu_itt
)
879 session
->tt
->parse_pdu_itt(conn
, itt
, &i
, NULL
);
882 if (i
>= session
->cmds_max
)
885 return session
->cmds
[i
];
887 EXPORT_SYMBOL_GPL(iscsi_itt_to_task
);
890 * __iscsi_complete_pdu - complete pdu
894 * @datalen: len of data buffer
896 * Completes pdu processing by freeing any resources allocated at
897 * queuecommand or send generic. session lock must be held and verify
898 * itt must have been called.
900 int __iscsi_complete_pdu(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
,
901 char *data
, int datalen
)
903 struct iscsi_session
*session
= conn
->session
;
904 int opcode
= hdr
->opcode
& ISCSI_OPCODE_MASK
, rc
= 0;
905 struct iscsi_task
*task
;
908 conn
->last_recv
= jiffies
;
909 rc
= iscsi_verify_itt(conn
, hdr
->itt
);
913 if (hdr
->itt
!= RESERVED_ITT
)
914 itt
= get_itt(hdr
->itt
);
918 ISCSI_DBG_SESSION(session
, "[op 0x%x cid %d itt 0x%x len %d]\n",
919 opcode
, conn
->id
, itt
, datalen
);
922 iscsi_update_cmdsn(session
, (struct iscsi_nopin
*)hdr
);
925 case ISCSI_OP_NOOP_IN
:
927 rc
= ISCSI_ERR_PROTO
;
931 if (hdr
->ttt
== cpu_to_be32(ISCSI_RESERVED_TAG
))
934 iscsi_send_nopout(conn
, (struct iscsi_nopin
*)hdr
);
936 case ISCSI_OP_REJECT
:
937 rc
= iscsi_handle_reject(conn
, hdr
, data
, datalen
);
939 case ISCSI_OP_ASYNC_EVENT
:
940 conn
->exp_statsn
= be32_to_cpu(hdr
->statsn
) + 1;
941 if (iscsi_recv_pdu(conn
->cls_conn
, hdr
, data
, datalen
))
942 rc
= ISCSI_ERR_CONN_FAILED
;
945 rc
= ISCSI_ERR_BAD_OPCODE
;
952 case ISCSI_OP_SCSI_CMD_RSP
:
953 case ISCSI_OP_SCSI_DATA_IN
:
954 task
= iscsi_itt_to_ctask(conn
, hdr
->itt
);
956 return ISCSI_ERR_BAD_ITT
;
960 * LLD handles R2Ts if they need to.
963 case ISCSI_OP_LOGOUT_RSP
:
964 case ISCSI_OP_LOGIN_RSP
:
965 case ISCSI_OP_TEXT_RSP
:
966 case ISCSI_OP_SCSI_TMFUNC_RSP
:
967 case ISCSI_OP_NOOP_IN
:
968 task
= iscsi_itt_to_task(conn
, hdr
->itt
);
970 return ISCSI_ERR_BAD_ITT
;
973 return ISCSI_ERR_BAD_OPCODE
;
977 case ISCSI_OP_SCSI_CMD_RSP
:
978 iscsi_scsi_cmd_rsp(conn
, hdr
, task
, data
, datalen
);
980 case ISCSI_OP_SCSI_DATA_IN
:
981 iscsi_data_in_rsp(conn
, hdr
, task
);
983 case ISCSI_OP_LOGOUT_RSP
:
984 iscsi_update_cmdsn(session
, (struct iscsi_nopin
*)hdr
);
986 rc
= ISCSI_ERR_PROTO
;
989 conn
->exp_statsn
= be32_to_cpu(hdr
->statsn
) + 1;
991 case ISCSI_OP_LOGIN_RSP
:
992 case ISCSI_OP_TEXT_RSP
:
993 iscsi_update_cmdsn(session
, (struct iscsi_nopin
*)hdr
);
995 * login related PDU's exp_statsn is handled in
999 case ISCSI_OP_SCSI_TMFUNC_RSP
:
1000 iscsi_update_cmdsn(session
, (struct iscsi_nopin
*)hdr
);
1002 rc
= ISCSI_ERR_PROTO
;
1006 iscsi_tmf_rsp(conn
, hdr
);
1007 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
1009 case ISCSI_OP_NOOP_IN
:
1010 iscsi_update_cmdsn(session
, (struct iscsi_nopin
*)hdr
);
1011 if (hdr
->ttt
!= cpu_to_be32(ISCSI_RESERVED_TAG
) || datalen
) {
1012 rc
= ISCSI_ERR_PROTO
;
1015 conn
->exp_statsn
= be32_to_cpu(hdr
->statsn
) + 1;
1017 if (conn
->ping_task
!= task
)
1019 * If this is not in response to one of our
1020 * nops then it must be from userspace.
1024 mod_timer(&conn
->transport_timer
, jiffies
+ conn
->recv_timeout
);
1025 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
1028 rc
= ISCSI_ERR_BAD_OPCODE
;
1035 if (iscsi_recv_pdu(conn
->cls_conn
, hdr
, data
, datalen
))
1036 rc
= ISCSI_ERR_CONN_FAILED
;
1037 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
1040 EXPORT_SYMBOL_GPL(__iscsi_complete_pdu
);
1042 int iscsi_complete_pdu(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
,
1043 char *data
, int datalen
)
1047 spin_lock(&conn
->session
->lock
);
1048 rc
= __iscsi_complete_pdu(conn
, hdr
, data
, datalen
);
1049 spin_unlock(&conn
->session
->lock
);
1052 EXPORT_SYMBOL_GPL(iscsi_complete_pdu
);
1054 int iscsi_verify_itt(struct iscsi_conn
*conn
, itt_t itt
)
1056 struct iscsi_session
*session
= conn
->session
;
1059 if (itt
== RESERVED_ITT
)
1062 if (session
->tt
->parse_pdu_itt
)
1063 session
->tt
->parse_pdu_itt(conn
, itt
, &i
, &age
);
1066 age
= ((__force u32
)itt
>> ISCSI_AGE_SHIFT
) & ISCSI_AGE_MASK
;
1069 if (age
!= session
->age
) {
1070 iscsi_conn_printk(KERN_ERR
, conn
,
1071 "received itt %x expected session age (%x)\n",
1072 (__force u32
)itt
, session
->age
);
1073 return ISCSI_ERR_BAD_ITT
;
1076 if (i
>= session
->cmds_max
) {
1077 iscsi_conn_printk(KERN_ERR
, conn
,
1078 "received invalid itt index %u (max cmds "
1079 "%u.\n", i
, session
->cmds_max
);
1080 return ISCSI_ERR_BAD_ITT
;
1084 EXPORT_SYMBOL_GPL(iscsi_verify_itt
);
1087 * iscsi_itt_to_ctask - look up ctask by itt
1088 * @conn: iscsi connection
1091 * This should be used for cmd tasks.
1093 * The session lock must be held.
1095 struct iscsi_task
*iscsi_itt_to_ctask(struct iscsi_conn
*conn
, itt_t itt
)
1097 struct iscsi_task
*task
;
1099 if (iscsi_verify_itt(conn
, itt
))
1102 task
= iscsi_itt_to_task(conn
, itt
);
1103 if (!task
|| !task
->sc
)
1106 if (task
->sc
->SCp
.phase
!= conn
->session
->age
) {
1107 iscsi_session_printk(KERN_ERR
, conn
->session
,
1108 "task's session age %d, expected %d\n",
1109 task
->sc
->SCp
.phase
, conn
->session
->age
);
1115 EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask
);
1117 void iscsi_session_failure(struct iscsi_session
*session
,
1120 struct iscsi_conn
*conn
;
1122 unsigned long flags
;
1124 spin_lock_irqsave(&session
->lock
, flags
);
1125 conn
= session
->leadconn
;
1126 if (session
->state
== ISCSI_STATE_TERMINATE
|| !conn
) {
1127 spin_unlock_irqrestore(&session
->lock
, flags
);
1131 dev
= get_device(&conn
->cls_conn
->dev
);
1132 spin_unlock_irqrestore(&session
->lock
, flags
);
1136 * if the host is being removed bypass the connection
1137 * recovery initialization because we are going to kill
1140 if (err
== ISCSI_ERR_INVALID_HOST
)
1141 iscsi_conn_error_event(conn
->cls_conn
, err
);
1143 iscsi_conn_failure(conn
, err
);
1146 EXPORT_SYMBOL_GPL(iscsi_session_failure
);
1148 void iscsi_conn_failure(struct iscsi_conn
*conn
, enum iscsi_err err
)
1150 struct iscsi_session
*session
= conn
->session
;
1151 unsigned long flags
;
1153 spin_lock_irqsave(&session
->lock
, flags
);
1154 if (session
->state
== ISCSI_STATE_FAILED
) {
1155 spin_unlock_irqrestore(&session
->lock
, flags
);
1159 if (conn
->stop_stage
== 0)
1160 session
->state
= ISCSI_STATE_FAILED
;
1161 spin_unlock_irqrestore(&session
->lock
, flags
);
1163 set_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_tx
);
1164 set_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_rx
);
1165 iscsi_conn_error_event(conn
->cls_conn
, err
);
1167 EXPORT_SYMBOL_GPL(iscsi_conn_failure
);
1169 static int iscsi_check_cmdsn_window_closed(struct iscsi_conn
*conn
)
1171 struct iscsi_session
*session
= conn
->session
;
1174 * Check for iSCSI window and take care of CmdSN wrap-around
1176 if (!iscsi_sna_lte(session
->queued_cmdsn
, session
->max_cmdsn
)) {
1177 ISCSI_DBG_SESSION(session
, "iSCSI CmdSN closed. ExpCmdSn "
1178 "%u MaxCmdSN %u CmdSN %u/%u\n",
1179 session
->exp_cmdsn
, session
->max_cmdsn
,
1180 session
->cmdsn
, session
->queued_cmdsn
);
1186 static int iscsi_xmit_task(struct iscsi_conn
*conn
)
1188 struct iscsi_task
*task
= conn
->task
;
1191 __iscsi_get_task(task
);
1192 spin_unlock_bh(&conn
->session
->lock
);
1193 rc
= conn
->session
->tt
->xmit_task(task
);
1194 spin_lock_bh(&conn
->session
->lock
);
1195 __iscsi_put_task(task
);
1197 /* done with this task */
1203 * iscsi_requeue_task - requeue task to run from session workqueue
1204 * @task: task to requeue
1206 * LLDs that need to run a task from the session workqueue should call
1207 * this. The session lock must be held. This should only be called
1208 * by software drivers.
1210 void iscsi_requeue_task(struct iscsi_task
*task
)
1212 struct iscsi_conn
*conn
= task
->conn
;
1215 * this may be on the requeue list already if the xmit_task callout
1216 * is handling the r2ts while we are adding new ones
1218 if (list_empty(&task
->running
))
1219 list_add_tail(&task
->running
, &conn
->requeue
);
1220 iscsi_conn_queue_work(conn
);
1222 EXPORT_SYMBOL_GPL(iscsi_requeue_task
);
1225 * iscsi_data_xmit - xmit any command into the scheduled connection
1226 * @conn: iscsi connection
1229 * The function can return -EAGAIN in which case the caller must
1230 * re-schedule it again later or recover. '0' return code means
1233 static int iscsi_data_xmit(struct iscsi_conn
*conn
)
1237 spin_lock_bh(&conn
->session
->lock
);
1238 if (unlikely(conn
->suspend_tx
)) {
1239 ISCSI_DBG_SESSION(conn
->session
, "Tx suspended!\n");
1240 spin_unlock_bh(&conn
->session
->lock
);
1245 rc
= iscsi_xmit_task(conn
);
1251 * process mgmt pdus like nops before commands since we should
1252 * only have one nop-out as a ping from us and targets should not
1253 * overflow us with nop-ins
1256 while (!list_empty(&conn
->mgmtqueue
)) {
1257 conn
->task
= list_entry(conn
->mgmtqueue
.next
,
1258 struct iscsi_task
, running
);
1259 list_del_init(&conn
->task
->running
);
1260 if (iscsi_prep_mgmt_task(conn
, conn
->task
)) {
1261 __iscsi_put_task(conn
->task
);
1265 rc
= iscsi_xmit_task(conn
);
1270 /* process pending command queue */
1271 while (!list_empty(&conn
->cmdqueue
)) {
1272 if (conn
->tmf_state
== TMF_QUEUED
)
1275 conn
->task
= list_entry(conn
->cmdqueue
.next
,
1276 struct iscsi_task
, running
);
1277 list_del_init(&conn
->task
->running
);
1278 if (conn
->session
->state
== ISCSI_STATE_LOGGING_OUT
) {
1279 fail_scsi_task(conn
->task
, DID_IMM_RETRY
);
1282 rc
= iscsi_prep_scsi_cmd_pdu(conn
->task
);
1284 if (rc
== -ENOMEM
) {
1285 list_add_tail(&conn
->task
->running
,
1290 fail_scsi_task(conn
->task
, DID_ABORT
);
1293 rc
= iscsi_xmit_task(conn
);
1297 * we could continuously get new task requests so
1298 * we need to check the mgmt queue for nops that need to
1299 * be sent to aviod starvation
1301 if (!list_empty(&conn
->mgmtqueue
))
1305 while (!list_empty(&conn
->requeue
)) {
1306 if (conn
->session
->fast_abort
&& conn
->tmf_state
!= TMF_INITIAL
)
1310 * we always do fastlogout - conn stop code will clean up.
1312 if (conn
->session
->state
== ISCSI_STATE_LOGGING_OUT
)
1315 conn
->task
= list_entry(conn
->requeue
.next
,
1316 struct iscsi_task
, running
);
1317 list_del_init(&conn
->task
->running
);
1318 conn
->task
->state
= ISCSI_TASK_RUNNING
;
1319 rc
= iscsi_xmit_task(conn
);
1322 if (!list_empty(&conn
->mgmtqueue
))
1325 spin_unlock_bh(&conn
->session
->lock
);
1329 if (unlikely(conn
->suspend_tx
))
1331 spin_unlock_bh(&conn
->session
->lock
);
1335 static void iscsi_xmitworker(struct work_struct
*work
)
1337 struct iscsi_conn
*conn
=
1338 container_of(work
, struct iscsi_conn
, xmitwork
);
1341 * serialize Xmit worker on a per-connection basis.
1344 rc
= iscsi_data_xmit(conn
);
1345 } while (rc
>= 0 || rc
== -EAGAIN
);
1348 static inline struct iscsi_task
*iscsi_alloc_task(struct iscsi_conn
*conn
,
1349 struct scsi_cmnd
*sc
)
1351 struct iscsi_task
*task
;
1353 if (!__kfifo_get(conn
->session
->cmdpool
.queue
,
1354 (void *) &task
, sizeof(void *)))
1357 sc
->SCp
.phase
= conn
->session
->age
;
1358 sc
->SCp
.ptr
= (char *) task
;
1360 atomic_set(&task
->refcount
, 1);
1361 task
->state
= ISCSI_TASK_PENDING
;
1364 INIT_LIST_HEAD(&task
->running
);
1369 FAILURE_BAD_HOST
= 1,
1370 FAILURE_SESSION_FAILED
,
1371 FAILURE_SESSION_FREED
,
1372 FAILURE_WINDOW_CLOSED
,
1374 FAILURE_SESSION_TERMINATE
,
1375 FAILURE_SESSION_IN_RECOVERY
,
1376 FAILURE_SESSION_RECOVERY_TIMEOUT
,
1377 FAILURE_SESSION_LOGGING_OUT
,
1378 FAILURE_SESSION_NOT_READY
,
1381 int iscsi_queuecommand(struct scsi_cmnd
*sc
, void (*done
)(struct scsi_cmnd
*))
1383 struct iscsi_cls_session
*cls_session
;
1384 struct Scsi_Host
*host
;
1385 struct iscsi_host
*ihost
;
1387 struct iscsi_session
*session
;
1388 struct iscsi_conn
*conn
;
1389 struct iscsi_task
*task
= NULL
;
1391 sc
->scsi_done
= done
;
1395 host
= sc
->device
->host
;
1396 ihost
= shost_priv(host
);
1397 spin_unlock(host
->host_lock
);
1399 cls_session
= starget_to_session(scsi_target(sc
->device
));
1400 session
= cls_session
->dd_data
;
1401 spin_lock(&session
->lock
);
1403 reason
= iscsi_session_chkready(cls_session
);
1405 sc
->result
= reason
;
1409 if (session
->state
!= ISCSI_STATE_LOGGED_IN
) {
1411 * to handle the race between when we set the recovery state
1412 * and block the session we requeue here (commands could
1413 * be entering our queuecommand while a block is starting
1414 * up because the block code is not locked)
1416 switch (session
->state
) {
1417 case ISCSI_STATE_FAILED
:
1418 case ISCSI_STATE_IN_RECOVERY
:
1419 reason
= FAILURE_SESSION_IN_RECOVERY
;
1420 sc
->result
= DID_IMM_RETRY
<< 16;
1422 case ISCSI_STATE_LOGGING_OUT
:
1423 reason
= FAILURE_SESSION_LOGGING_OUT
;
1424 sc
->result
= DID_IMM_RETRY
<< 16;
1426 case ISCSI_STATE_RECOVERY_FAILED
:
1427 reason
= FAILURE_SESSION_RECOVERY_TIMEOUT
;
1428 sc
->result
= DID_TRANSPORT_FAILFAST
<< 16;
1430 case ISCSI_STATE_TERMINATE
:
1431 reason
= FAILURE_SESSION_TERMINATE
;
1432 sc
->result
= DID_NO_CONNECT
<< 16;
1435 reason
= FAILURE_SESSION_FREED
;
1436 sc
->result
= DID_NO_CONNECT
<< 16;
1441 conn
= session
->leadconn
;
1443 reason
= FAILURE_SESSION_FREED
;
1444 sc
->result
= DID_NO_CONNECT
<< 16;
1448 if (iscsi_check_cmdsn_window_closed(conn
)) {
1449 reason
= FAILURE_WINDOW_CLOSED
;
1453 task
= iscsi_alloc_task(conn
, sc
);
1455 reason
= FAILURE_OOM
;
1459 if (!ihost
->workq
) {
1460 reason
= iscsi_prep_scsi_cmd_pdu(task
);
1462 if (reason
== -ENOMEM
) {
1463 reason
= FAILURE_OOM
;
1466 sc
->result
= DID_ABORT
<< 16;
1470 if (session
->tt
->xmit_task(task
)) {
1471 reason
= FAILURE_SESSION_NOT_READY
;
1475 list_add_tail(&task
->running
, &conn
->cmdqueue
);
1476 iscsi_conn_queue_work(conn
);
1479 session
->queued_cmdsn
++;
1480 spin_unlock(&session
->lock
);
1481 spin_lock(host
->host_lock
);
1485 sc
->scsi_done
= NULL
;
1486 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
1488 spin_unlock(&session
->lock
);
1489 ISCSI_DBG_SESSION(session
, "cmd 0x%x rejected (%d)\n",
1490 sc
->cmnd
[0], reason
);
1491 spin_lock(host
->host_lock
);
1492 return SCSI_MLQUEUE_TARGET_BUSY
;
1495 sc
->scsi_done
= NULL
;
1496 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
1498 spin_unlock(&session
->lock
);
1499 ISCSI_DBG_SESSION(session
, "iscsi: cmd 0x%x is not queued (%d)\n",
1500 sc
->cmnd
[0], reason
);
1501 if (!scsi_bidi_cmnd(sc
))
1502 scsi_set_resid(sc
, scsi_bufflen(sc
));
1504 scsi_out(sc
)->resid
= scsi_out(sc
)->length
;
1505 scsi_in(sc
)->resid
= scsi_in(sc
)->length
;
1508 spin_lock(host
->host_lock
);
1511 EXPORT_SYMBOL_GPL(iscsi_queuecommand
);
1513 int iscsi_change_queue_depth(struct scsi_device
*sdev
, int depth
)
1515 scsi_adjust_queue_depth(sdev
, scsi_get_tag_type(sdev
), depth
);
1516 return sdev
->queue_depth
;
1518 EXPORT_SYMBOL_GPL(iscsi_change_queue_depth
);
1520 int iscsi_target_alloc(struct scsi_target
*starget
)
1522 struct iscsi_cls_session
*cls_session
= starget_to_session(starget
);
1523 struct iscsi_session
*session
= cls_session
->dd_data
;
1525 starget
->can_queue
= session
->scsi_cmds_max
;
1528 EXPORT_SYMBOL_GPL(iscsi_target_alloc
);
1530 void iscsi_session_recovery_timedout(struct iscsi_cls_session
*cls_session
)
1532 struct iscsi_session
*session
= cls_session
->dd_data
;
1534 spin_lock_bh(&session
->lock
);
1535 if (session
->state
!= ISCSI_STATE_LOGGED_IN
) {
1536 session
->state
= ISCSI_STATE_RECOVERY_FAILED
;
1537 if (session
->leadconn
)
1538 wake_up(&session
->leadconn
->ehwait
);
1540 spin_unlock_bh(&session
->lock
);
1542 EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout
);
1544 int iscsi_eh_target_reset(struct scsi_cmnd
*sc
)
1546 struct iscsi_cls_session
*cls_session
;
1547 struct iscsi_session
*session
;
1548 struct iscsi_conn
*conn
;
1550 cls_session
= starget_to_session(scsi_target(sc
->device
));
1551 session
= cls_session
->dd_data
;
1552 conn
= session
->leadconn
;
1554 mutex_lock(&session
->eh_mutex
);
1555 spin_lock_bh(&session
->lock
);
1556 if (session
->state
== ISCSI_STATE_TERMINATE
) {
1558 iscsi_session_printk(KERN_INFO
, session
,
1559 "failing target reset: Could not log "
1560 "back into target [age %d]\n",
1562 spin_unlock_bh(&session
->lock
);
1563 mutex_unlock(&session
->eh_mutex
);
1567 spin_unlock_bh(&session
->lock
);
1568 mutex_unlock(&session
->eh_mutex
);
1570 * we drop the lock here but the leadconn cannot be destoyed while
1571 * we are in the scsi eh
1573 iscsi_conn_failure(conn
, ISCSI_ERR_CONN_FAILED
);
1575 ISCSI_DBG_SESSION(session
, "wait for relogin\n");
1576 wait_event_interruptible(conn
->ehwait
,
1577 session
->state
== ISCSI_STATE_TERMINATE
||
1578 session
->state
== ISCSI_STATE_LOGGED_IN
||
1579 session
->state
== ISCSI_STATE_RECOVERY_FAILED
);
1580 if (signal_pending(current
))
1581 flush_signals(current
);
1583 mutex_lock(&session
->eh_mutex
);
1584 spin_lock_bh(&session
->lock
);
1585 if (session
->state
== ISCSI_STATE_LOGGED_IN
)
1586 iscsi_session_printk(KERN_INFO
, session
,
1587 "target reset succeeded\n");
1590 spin_unlock_bh(&session
->lock
);
1591 mutex_unlock(&session
->eh_mutex
);
1594 EXPORT_SYMBOL_GPL(iscsi_eh_target_reset
);
1596 static void iscsi_tmf_timedout(unsigned long data
)
1598 struct iscsi_conn
*conn
= (struct iscsi_conn
*)data
;
1599 struct iscsi_session
*session
= conn
->session
;
1601 spin_lock(&session
->lock
);
1602 if (conn
->tmf_state
== TMF_QUEUED
) {
1603 conn
->tmf_state
= TMF_TIMEDOUT
;
1604 ISCSI_DBG_SESSION(session
, "tmf timedout\n");
1605 /* unblock eh_abort() */
1606 wake_up(&conn
->ehwait
);
1608 spin_unlock(&session
->lock
);
1611 static int iscsi_exec_task_mgmt_fn(struct iscsi_conn
*conn
,
1612 struct iscsi_tm
*hdr
, int age
,
1615 struct iscsi_session
*session
= conn
->session
;
1616 struct iscsi_task
*task
;
1618 task
= __iscsi_conn_send_pdu(conn
, (struct iscsi_hdr
*)hdr
,
1621 spin_unlock_bh(&session
->lock
);
1622 iscsi_conn_failure(conn
, ISCSI_ERR_CONN_FAILED
);
1623 spin_lock_bh(&session
->lock
);
1624 ISCSI_DBG_SESSION(session
, "tmf exec failure\n");
1627 conn
->tmfcmd_pdus_cnt
++;
1628 conn
->tmf_timer
.expires
= timeout
* HZ
+ jiffies
;
1629 conn
->tmf_timer
.function
= iscsi_tmf_timedout
;
1630 conn
->tmf_timer
.data
= (unsigned long)conn
;
1631 add_timer(&conn
->tmf_timer
);
1632 ISCSI_DBG_SESSION(session
, "tmf set timeout\n");
1634 spin_unlock_bh(&session
->lock
);
1635 mutex_unlock(&session
->eh_mutex
);
1638 * block eh thread until:
1642 * 3) session is terminated or restarted or userspace has
1643 * given up on recovery
1645 wait_event_interruptible(conn
->ehwait
, age
!= session
->age
||
1646 session
->state
!= ISCSI_STATE_LOGGED_IN
||
1647 conn
->tmf_state
!= TMF_QUEUED
);
1648 if (signal_pending(current
))
1649 flush_signals(current
);
1650 del_timer_sync(&conn
->tmf_timer
);
1652 mutex_lock(&session
->eh_mutex
);
1653 spin_lock_bh(&session
->lock
);
1654 /* if the session drops it will clean up the task */
1655 if (age
!= session
->age
||
1656 session
->state
!= ISCSI_STATE_LOGGED_IN
)
1662 * Fail commands. session lock held and recv side suspended and xmit
1665 static void fail_scsi_tasks(struct iscsi_conn
*conn
, unsigned lun
,
1668 struct iscsi_task
*task
;
1671 for (i
= 0; i
< conn
->session
->cmds_max
; i
++) {
1672 task
= conn
->session
->cmds
[i
];
1673 if (!task
->sc
|| task
->state
== ISCSI_TASK_FREE
)
1676 if (lun
!= -1 && lun
!= task
->sc
->device
->lun
)
1679 ISCSI_DBG_SESSION(conn
->session
,
1680 "failing sc %p itt 0x%x state %d\n",
1681 task
->sc
, task
->itt
, task
->state
);
1682 fail_scsi_task(task
, error
);
1686 void iscsi_suspend_tx(struct iscsi_conn
*conn
)
1688 struct Scsi_Host
*shost
= conn
->session
->host
;
1689 struct iscsi_host
*ihost
= shost_priv(shost
);
1691 set_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_tx
);
1693 flush_workqueue(ihost
->workq
);
1695 EXPORT_SYMBOL_GPL(iscsi_suspend_tx
);
1697 static void iscsi_start_tx(struct iscsi_conn
*conn
)
1699 clear_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_tx
);
1700 iscsi_conn_queue_work(conn
);
1704 * We want to make sure a ping is in flight. It has timed out.
1705 * And we are not busy processing a pdu that is making
1706 * progress but got started before the ping and is taking a while
1707 * to complete so the ping is just stuck behind it in a queue.
1709 static int iscsi_has_ping_timed_out(struct iscsi_conn
*conn
)
1711 if (conn
->ping_task
&&
1712 time_before_eq(conn
->last_recv
+ (conn
->recv_timeout
* HZ
) +
1713 (conn
->ping_timeout
* HZ
), jiffies
))
1719 static enum blk_eh_timer_return
iscsi_eh_cmd_timed_out(struct scsi_cmnd
*scmd
)
1721 struct iscsi_cls_session
*cls_session
;
1722 struct iscsi_session
*session
;
1723 struct iscsi_conn
*conn
;
1724 enum blk_eh_timer_return rc
= BLK_EH_NOT_HANDLED
;
1726 cls_session
= starget_to_session(scsi_target(scmd
->device
));
1727 session
= cls_session
->dd_data
;
1729 ISCSI_DBG_SESSION(session
, "scsi cmd %p timedout\n", scmd
);
1731 spin_lock(&session
->lock
);
1732 if (session
->state
!= ISCSI_STATE_LOGGED_IN
) {
1734 * We are probably in the middle of iscsi recovery so let
1735 * that complete and handle the error.
1737 rc
= BLK_EH_RESET_TIMER
;
1741 conn
= session
->leadconn
;
1743 /* In the middle of shuting down */
1744 rc
= BLK_EH_RESET_TIMER
;
1748 if (!conn
->recv_timeout
&& !conn
->ping_timeout
)
1751 * if the ping timedout then we are in the middle of cleaning up
1752 * and can let the iscsi eh handle it
1754 if (iscsi_has_ping_timed_out(conn
)) {
1755 rc
= BLK_EH_RESET_TIMER
;
1759 * if we are about to check the transport then give the command
1762 if (time_before_eq(conn
->last_recv
+ (conn
->recv_timeout
* HZ
),
1764 rc
= BLK_EH_RESET_TIMER
;
1768 /* if in the middle of checking the transport then give us more time */
1769 if (conn
->ping_task
)
1770 rc
= BLK_EH_RESET_TIMER
;
1772 spin_unlock(&session
->lock
);
1773 ISCSI_DBG_SESSION(session
, "return %s\n", rc
== BLK_EH_RESET_TIMER
?
1774 "timer reset" : "nh");
1778 static void iscsi_check_transport_timeouts(unsigned long data
)
1780 struct iscsi_conn
*conn
= (struct iscsi_conn
*)data
;
1781 struct iscsi_session
*session
= conn
->session
;
1782 unsigned long recv_timeout
, next_timeout
= 0, last_recv
;
1784 spin_lock(&session
->lock
);
1785 if (session
->state
!= ISCSI_STATE_LOGGED_IN
)
1788 recv_timeout
= conn
->recv_timeout
;
1793 last_recv
= conn
->last_recv
;
1795 if (iscsi_has_ping_timed_out(conn
)) {
1796 iscsi_conn_printk(KERN_ERR
, conn
, "ping timeout of %d secs "
1797 "expired, recv timeout %d, last rx %lu, "
1798 "last ping %lu, now %lu\n",
1799 conn
->ping_timeout
, conn
->recv_timeout
,
1800 last_recv
, conn
->last_ping
, jiffies
);
1801 spin_unlock(&session
->lock
);
1802 iscsi_conn_failure(conn
, ISCSI_ERR_CONN_FAILED
);
1806 if (time_before_eq(last_recv
+ recv_timeout
, jiffies
)) {
1807 /* send a ping to try to provoke some traffic */
1808 ISCSI_DBG_CONN(conn
, "Sending nopout as ping\n");
1809 iscsi_send_nopout(conn
, NULL
);
1810 next_timeout
= conn
->last_ping
+ (conn
->ping_timeout
* HZ
);
1812 next_timeout
= last_recv
+ recv_timeout
;
1814 ISCSI_DBG_CONN(conn
, "Setting next tmo %lu\n", next_timeout
);
1815 mod_timer(&conn
->transport_timer
, next_timeout
);
1817 spin_unlock(&session
->lock
);
1820 static void iscsi_prep_abort_task_pdu(struct iscsi_task
*task
,
1821 struct iscsi_tm
*hdr
)
1823 memset(hdr
, 0, sizeof(*hdr
));
1824 hdr
->opcode
= ISCSI_OP_SCSI_TMFUNC
| ISCSI_OP_IMMEDIATE
;
1825 hdr
->flags
= ISCSI_TM_FUNC_ABORT_TASK
& ISCSI_FLAG_TM_FUNC_MASK
;
1826 hdr
->flags
|= ISCSI_FLAG_CMD_FINAL
;
1827 memcpy(hdr
->lun
, task
->lun
, sizeof(hdr
->lun
));
1828 hdr
->rtt
= task
->hdr_itt
;
1829 hdr
->refcmdsn
= task
->cmdsn
;
1832 int iscsi_eh_abort(struct scsi_cmnd
*sc
)
1834 struct iscsi_cls_session
*cls_session
;
1835 struct iscsi_session
*session
;
1836 struct iscsi_conn
*conn
;
1837 struct iscsi_task
*task
;
1838 struct iscsi_tm
*hdr
;
1841 cls_session
= starget_to_session(scsi_target(sc
->device
));
1842 session
= cls_session
->dd_data
;
1844 ISCSI_DBG_SESSION(session
, "aborting sc %p\n", sc
);
1846 mutex_lock(&session
->eh_mutex
);
1847 spin_lock_bh(&session
->lock
);
1849 * if session was ISCSI_STATE_IN_RECOVERY then we may not have
1853 ISCSI_DBG_SESSION(session
, "sc never reached iscsi layer or "
1855 spin_unlock_bh(&session
->lock
);
1856 mutex_unlock(&session
->eh_mutex
);
1861 * If we are not logged in or we have started a new session
1862 * then let the host reset code handle this
1864 if (!session
->leadconn
|| session
->state
!= ISCSI_STATE_LOGGED_IN
||
1865 sc
->SCp
.phase
!= session
->age
) {
1866 spin_unlock_bh(&session
->lock
);
1867 mutex_unlock(&session
->eh_mutex
);
1868 ISCSI_DBG_SESSION(session
, "failing abort due to dropped "
1873 conn
= session
->leadconn
;
1874 conn
->eh_abort_cnt
++;
1877 task
= (struct iscsi_task
*)sc
->SCp
.ptr
;
1878 ISCSI_DBG_SESSION(session
, "aborting [sc %p itt 0x%x]\n",
1881 /* task completed before time out */
1883 ISCSI_DBG_SESSION(session
, "sc completed while abort in "
1888 if (task
->state
== ISCSI_TASK_PENDING
) {
1889 fail_scsi_task(task
, DID_ABORT
);
1893 /* only have one tmf outstanding at a time */
1894 if (conn
->tmf_state
!= TMF_INITIAL
)
1896 conn
->tmf_state
= TMF_QUEUED
;
1899 iscsi_prep_abort_task_pdu(task
, hdr
);
1901 if (iscsi_exec_task_mgmt_fn(conn
, hdr
, age
, session
->abort_timeout
)) {
1906 switch (conn
->tmf_state
) {
1908 spin_unlock_bh(&session
->lock
);
1910 * stop tx side incase the target had sent a abort rsp but
1911 * the initiator was still writing out data.
1913 iscsi_suspend_tx(conn
);
1915 * we do not stop the recv side because targets have been
1916 * good and have never sent us a successful tmf response
1917 * then sent more data for the cmd.
1919 spin_lock(&session
->lock
);
1920 fail_scsi_task(task
, DID_ABORT
);
1921 conn
->tmf_state
= TMF_INITIAL
;
1922 spin_unlock(&session
->lock
);
1923 iscsi_start_tx(conn
);
1924 goto success_unlocked
;
1926 spin_unlock_bh(&session
->lock
);
1927 iscsi_conn_failure(conn
, ISCSI_ERR_CONN_FAILED
);
1928 goto failed_unlocked
;
1931 conn
->tmf_state
= TMF_INITIAL
;
1932 /* task completed before tmf abort response */
1933 ISCSI_DBG_SESSION(session
, "sc completed while abort "
1939 conn
->tmf_state
= TMF_INITIAL
;
1944 spin_unlock_bh(&session
->lock
);
1946 ISCSI_DBG_SESSION(session
, "abort success [sc %p itt 0x%x]\n",
1948 mutex_unlock(&session
->eh_mutex
);
1952 spin_unlock_bh(&session
->lock
);
1954 ISCSI_DBG_SESSION(session
, "abort failed [sc %p itt 0x%x]\n", sc
,
1955 task
? task
->itt
: 0);
1956 mutex_unlock(&session
->eh_mutex
);
1959 EXPORT_SYMBOL_GPL(iscsi_eh_abort
);
1961 static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd
*sc
, struct iscsi_tm
*hdr
)
1963 memset(hdr
, 0, sizeof(*hdr
));
1964 hdr
->opcode
= ISCSI_OP_SCSI_TMFUNC
| ISCSI_OP_IMMEDIATE
;
1965 hdr
->flags
= ISCSI_TM_FUNC_LOGICAL_UNIT_RESET
& ISCSI_FLAG_TM_FUNC_MASK
;
1966 hdr
->flags
|= ISCSI_FLAG_CMD_FINAL
;
1967 int_to_scsilun(sc
->device
->lun
, (struct scsi_lun
*)hdr
->lun
);
1968 hdr
->rtt
= RESERVED_ITT
;
1971 int iscsi_eh_device_reset(struct scsi_cmnd
*sc
)
1973 struct iscsi_cls_session
*cls_session
;
1974 struct iscsi_session
*session
;
1975 struct iscsi_conn
*conn
;
1976 struct iscsi_tm
*hdr
;
1979 cls_session
= starget_to_session(scsi_target(sc
->device
));
1980 session
= cls_session
->dd_data
;
1982 ISCSI_DBG_SESSION(session
, "LU Reset [sc %p lun %u]\n",
1983 sc
, sc
->device
->lun
);
1985 mutex_lock(&session
->eh_mutex
);
1986 spin_lock_bh(&session
->lock
);
1988 * Just check if we are not logged in. We cannot check for
1989 * the phase because the reset could come from a ioctl.
1991 if (!session
->leadconn
|| session
->state
!= ISCSI_STATE_LOGGED_IN
)
1993 conn
= session
->leadconn
;
1995 /* only have one tmf outstanding at a time */
1996 if (conn
->tmf_state
!= TMF_INITIAL
)
1998 conn
->tmf_state
= TMF_QUEUED
;
2001 iscsi_prep_lun_reset_pdu(sc
, hdr
);
2003 if (iscsi_exec_task_mgmt_fn(conn
, hdr
, session
->age
,
2004 session
->lu_reset_timeout
)) {
2009 switch (conn
->tmf_state
) {
2013 spin_unlock_bh(&session
->lock
);
2014 iscsi_conn_failure(conn
, ISCSI_ERR_CONN_FAILED
);
2017 conn
->tmf_state
= TMF_INITIAL
;
2022 spin_unlock_bh(&session
->lock
);
2024 iscsi_suspend_tx(conn
);
2026 spin_lock_bh(&session
->lock
);
2027 fail_scsi_tasks(conn
, sc
->device
->lun
, DID_ERROR
);
2028 conn
->tmf_state
= TMF_INITIAL
;
2029 spin_unlock_bh(&session
->lock
);
2031 iscsi_start_tx(conn
);
2035 spin_unlock_bh(&session
->lock
);
2037 ISCSI_DBG_SESSION(session
, "dev reset result = %s\n",
2038 rc
== SUCCESS
? "SUCCESS" : "FAILED");
2039 mutex_unlock(&session
->eh_mutex
);
2042 EXPORT_SYMBOL_GPL(iscsi_eh_device_reset
);
2045 * Pre-allocate a pool of @max items of @item_size. By default, the pool
2046 * should be accessed via kfifo_{get,put} on q->queue.
2047 * Optionally, the caller can obtain the array of object pointers
2048 * by passing in a non-NULL @items pointer
2051 iscsi_pool_init(struct iscsi_pool
*q
, int max
, void ***items
, int item_size
)
2053 int i
, num_arrays
= 1;
2055 memset(q
, 0, sizeof(*q
));
2059 /* If the user passed an items pointer, he wants a copy of
2063 q
->pool
= kzalloc(num_arrays
* max
* sizeof(void*), GFP_KERNEL
);
2064 if (q
->pool
== NULL
)
2067 q
->queue
= kfifo_init((void*)q
->pool
, max
* sizeof(void*),
2069 if (IS_ERR(q
->queue
)) {
2074 for (i
= 0; i
< max
; i
++) {
2075 q
->pool
[i
] = kzalloc(item_size
, GFP_KERNEL
);
2076 if (q
->pool
[i
] == NULL
) {
2080 __kfifo_put(q
->queue
, (void*)&q
->pool
[i
], sizeof(void*));
2084 *items
= q
->pool
+ max
;
2085 memcpy(*items
, q
->pool
, max
* sizeof(void *));
2094 EXPORT_SYMBOL_GPL(iscsi_pool_init
);
2096 void iscsi_pool_free(struct iscsi_pool
*q
)
2100 for (i
= 0; i
< q
->max
; i
++)
2105 EXPORT_SYMBOL_GPL(iscsi_pool_free
);
2108 * iscsi_host_add - add host to system
2110 * @pdev: parent device
2112 * This should be called by partial offload and software iscsi drivers
2113 * to add a host to the system.
2115 int iscsi_host_add(struct Scsi_Host
*shost
, struct device
*pdev
)
2117 if (!shost
->can_queue
)
2118 shost
->can_queue
= ISCSI_DEF_XMIT_CMDS_MAX
;
2120 if (!shost
->cmd_per_lun
)
2121 shost
->cmd_per_lun
= ISCSI_DEF_CMD_PER_LUN
;
2123 if (!shost
->transportt
->eh_timed_out
)
2124 shost
->transportt
->eh_timed_out
= iscsi_eh_cmd_timed_out
;
2125 return scsi_add_host(shost
, pdev
);
2127 EXPORT_SYMBOL_GPL(iscsi_host_add
);
2130 * iscsi_host_alloc - allocate a host and driver data
2131 * @sht: scsi host template
2132 * @dd_data_size: driver host data size
2133 * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue
2135 * This should be called by partial offload and software iscsi drivers.
2136 * To access the driver specific memory use the iscsi_host_priv() macro.
2138 struct Scsi_Host
*iscsi_host_alloc(struct scsi_host_template
*sht
,
2139 int dd_data_size
, bool xmit_can_sleep
)
2141 struct Scsi_Host
*shost
;
2142 struct iscsi_host
*ihost
;
2144 shost
= scsi_host_alloc(sht
, sizeof(struct iscsi_host
) + dd_data_size
);
2147 ihost
= shost_priv(shost
);
2149 if (xmit_can_sleep
) {
2150 snprintf(ihost
->workq_name
, sizeof(ihost
->workq_name
),
2151 "iscsi_q_%d", shost
->host_no
);
2152 ihost
->workq
= create_singlethread_workqueue(ihost
->workq_name
);
2157 spin_lock_init(&ihost
->lock
);
2158 ihost
->state
= ISCSI_HOST_SETUP
;
2159 ihost
->num_sessions
= 0;
2160 init_waitqueue_head(&ihost
->session_removal_wq
);
2164 scsi_host_put(shost
);
2167 EXPORT_SYMBOL_GPL(iscsi_host_alloc
);
2169 static void iscsi_notify_host_removed(struct iscsi_cls_session
*cls_session
)
2171 iscsi_session_failure(cls_session
->dd_data
, ISCSI_ERR_INVALID_HOST
);
2175 * iscsi_host_remove - remove host and sessions
2178 * If there are any sessions left, this will initiate the removal and wait
2179 * for the completion.
2181 void iscsi_host_remove(struct Scsi_Host
*shost
)
2183 struct iscsi_host
*ihost
= shost_priv(shost
);
2184 unsigned long flags
;
2186 spin_lock_irqsave(&ihost
->lock
, flags
);
2187 ihost
->state
= ISCSI_HOST_REMOVED
;
2188 spin_unlock_irqrestore(&ihost
->lock
, flags
);
2190 iscsi_host_for_each_session(shost
, iscsi_notify_host_removed
);
2191 wait_event_interruptible(ihost
->session_removal_wq
,
2192 ihost
->num_sessions
== 0);
2193 if (signal_pending(current
))
2194 flush_signals(current
);
2196 scsi_remove_host(shost
);
2198 destroy_workqueue(ihost
->workq
);
2200 EXPORT_SYMBOL_GPL(iscsi_host_remove
);
2202 void iscsi_host_free(struct Scsi_Host
*shost
)
2204 struct iscsi_host
*ihost
= shost_priv(shost
);
2206 kfree(ihost
->netdev
);
2207 kfree(ihost
->hwaddress
);
2208 kfree(ihost
->initiatorname
);
2209 scsi_host_put(shost
);
2211 EXPORT_SYMBOL_GPL(iscsi_host_free
);
2213 static void iscsi_host_dec_session_cnt(struct Scsi_Host
*shost
)
2215 struct iscsi_host
*ihost
= shost_priv(shost
);
2216 unsigned long flags
;
2218 shost
= scsi_host_get(shost
);
2220 printk(KERN_ERR
"Invalid state. Cannot notify host removal "
2221 "of session teardown event because host already "
2226 spin_lock_irqsave(&ihost
->lock
, flags
);
2227 ihost
->num_sessions
--;
2228 if (ihost
->num_sessions
== 0)
2229 wake_up(&ihost
->session_removal_wq
);
2230 spin_unlock_irqrestore(&ihost
->lock
, flags
);
2231 scsi_host_put(shost
);
2235 * iscsi_session_setup - create iscsi cls session and host and session
2236 * @iscsit: iscsi transport template
2238 * @cmds_max: session can queue
2239 * @cmd_task_size: LLD task private data size
2240 * @initial_cmdsn: initial CmdSN
2242 * This can be used by software iscsi_transports that allocate
2243 * a session per scsi host.
2245 * Callers should set cmds_max to the largest total numer (mgmt + scsi) of
2246 * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks
2247 * for nop handling and login/logout requests.
2249 struct iscsi_cls_session
*
2250 iscsi_session_setup(struct iscsi_transport
*iscsit
, struct Scsi_Host
*shost
,
2251 uint16_t cmds_max
, int cmd_task_size
,
2252 uint32_t initial_cmdsn
, unsigned int id
)
2254 struct iscsi_host
*ihost
= shost_priv(shost
);
2255 struct iscsi_session
*session
;
2256 struct iscsi_cls_session
*cls_session
;
2257 int cmd_i
, scsi_cmds
, total_cmds
= cmds_max
;
2258 unsigned long flags
;
2260 spin_lock_irqsave(&ihost
->lock
, flags
);
2261 if (ihost
->state
== ISCSI_HOST_REMOVED
) {
2262 spin_unlock_irqrestore(&ihost
->lock
, flags
);
2265 ihost
->num_sessions
++;
2266 spin_unlock_irqrestore(&ihost
->lock
, flags
);
2269 total_cmds
= ISCSI_DEF_XMIT_CMDS_MAX
;
2271 * The iscsi layer needs some tasks for nop handling and tmfs,
2272 * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX
2273 * + 1 command for scsi IO.
2275 if (total_cmds
< ISCSI_TOTAL_CMDS_MIN
) {
2276 printk(KERN_ERR
"iscsi: invalid can_queue of %d. can_queue "
2277 "must be a power of two that is at least %d.\n",
2278 total_cmds
, ISCSI_TOTAL_CMDS_MIN
);
2279 goto dec_session_count
;
2282 if (total_cmds
> ISCSI_TOTAL_CMDS_MAX
) {
2283 printk(KERN_ERR
"iscsi: invalid can_queue of %d. can_queue "
2284 "must be a power of 2 less than or equal to %d.\n",
2285 cmds_max
, ISCSI_TOTAL_CMDS_MAX
);
2286 total_cmds
= ISCSI_TOTAL_CMDS_MAX
;
2289 if (!is_power_of_2(total_cmds
)) {
2290 printk(KERN_ERR
"iscsi: invalid can_queue of %d. can_queue "
2291 "must be a power of 2.\n", total_cmds
);
2292 total_cmds
= rounddown_pow_of_two(total_cmds
);
2293 if (total_cmds
< ISCSI_TOTAL_CMDS_MIN
)
2295 printk(KERN_INFO
"iscsi: Rounding can_queue to %d.\n",
2298 scsi_cmds
= total_cmds
- ISCSI_MGMT_CMDS_MAX
;
2300 cls_session
= iscsi_alloc_session(shost
, iscsit
,
2301 sizeof(struct iscsi_session
));
2303 goto dec_session_count
;
2304 session
= cls_session
->dd_data
;
2305 session
->cls_session
= cls_session
;
2306 session
->host
= shost
;
2307 session
->state
= ISCSI_STATE_FREE
;
2308 session
->fast_abort
= 1;
2309 session
->lu_reset_timeout
= 15;
2310 session
->abort_timeout
= 10;
2311 session
->scsi_cmds_max
= scsi_cmds
;
2312 session
->cmds_max
= total_cmds
;
2313 session
->queued_cmdsn
= session
->cmdsn
= initial_cmdsn
;
2314 session
->exp_cmdsn
= initial_cmdsn
+ 1;
2315 session
->max_cmdsn
= initial_cmdsn
+ 1;
2316 session
->max_r2t
= 1;
2317 session
->tt
= iscsit
;
2318 mutex_init(&session
->eh_mutex
);
2319 spin_lock_init(&session
->lock
);
2321 /* initialize SCSI PDU commands pool */
2322 if (iscsi_pool_init(&session
->cmdpool
, session
->cmds_max
,
2323 (void***)&session
->cmds
,
2324 cmd_task_size
+ sizeof(struct iscsi_task
)))
2325 goto cmdpool_alloc_fail
;
2327 /* pre-format cmds pool with ITT */
2328 for (cmd_i
= 0; cmd_i
< session
->cmds_max
; cmd_i
++) {
2329 struct iscsi_task
*task
= session
->cmds
[cmd_i
];
2332 task
->dd_data
= &task
[1];
2334 task
->state
= ISCSI_TASK_FREE
;
2335 INIT_LIST_HEAD(&task
->running
);
2338 if (!try_module_get(iscsit
->owner
))
2339 goto module_get_fail
;
2341 if (iscsi_add_session(cls_session
, id
))
2342 goto cls_session_fail
;
2347 module_put(iscsit
->owner
);
2349 iscsi_pool_free(&session
->cmdpool
);
2351 iscsi_free_session(cls_session
);
2353 iscsi_host_dec_session_cnt(shost
);
2356 EXPORT_SYMBOL_GPL(iscsi_session_setup
);
2359 * iscsi_session_teardown - destroy session, host, and cls_session
2360 * @cls_session: iscsi session
2362 * The driver must have called iscsi_remove_session before
2365 void iscsi_session_teardown(struct iscsi_cls_session
*cls_session
)
2367 struct iscsi_session
*session
= cls_session
->dd_data
;
2368 struct module
*owner
= cls_session
->transport
->owner
;
2369 struct Scsi_Host
*shost
= session
->host
;
2371 iscsi_pool_free(&session
->cmdpool
);
2373 kfree(session
->password
);
2374 kfree(session
->password_in
);
2375 kfree(session
->username
);
2376 kfree(session
->username_in
);
2377 kfree(session
->targetname
);
2378 kfree(session
->initiatorname
);
2379 kfree(session
->ifacename
);
2381 iscsi_destroy_session(cls_session
);
2382 iscsi_host_dec_session_cnt(shost
);
2385 EXPORT_SYMBOL_GPL(iscsi_session_teardown
);
2388 * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn
2389 * @cls_session: iscsi_cls_session
2390 * @dd_size: private driver data size
2393 struct iscsi_cls_conn
*
2394 iscsi_conn_setup(struct iscsi_cls_session
*cls_session
, int dd_size
,
2397 struct iscsi_session
*session
= cls_session
->dd_data
;
2398 struct iscsi_conn
*conn
;
2399 struct iscsi_cls_conn
*cls_conn
;
2402 cls_conn
= iscsi_create_conn(cls_session
, sizeof(*conn
) + dd_size
,
2406 conn
= cls_conn
->dd_data
;
2407 memset(conn
, 0, sizeof(*conn
) + dd_size
);
2409 conn
->dd_data
= cls_conn
->dd_data
+ sizeof(*conn
);
2410 conn
->session
= session
;
2411 conn
->cls_conn
= cls_conn
;
2412 conn
->c_stage
= ISCSI_CONN_INITIAL_STAGE
;
2413 conn
->id
= conn_idx
;
2414 conn
->exp_statsn
= 0;
2415 conn
->tmf_state
= TMF_INITIAL
;
2417 init_timer(&conn
->transport_timer
);
2418 conn
->transport_timer
.data
= (unsigned long)conn
;
2419 conn
->transport_timer
.function
= iscsi_check_transport_timeouts
;
2421 INIT_LIST_HEAD(&conn
->mgmtqueue
);
2422 INIT_LIST_HEAD(&conn
->cmdqueue
);
2423 INIT_LIST_HEAD(&conn
->requeue
);
2424 INIT_WORK(&conn
->xmitwork
, iscsi_xmitworker
);
2426 /* allocate login_task used for the login/text sequences */
2427 spin_lock_bh(&session
->lock
);
2428 if (!__kfifo_get(session
->cmdpool
.queue
,
2429 (void*)&conn
->login_task
,
2431 spin_unlock_bh(&session
->lock
);
2432 goto login_task_alloc_fail
;
2434 spin_unlock_bh(&session
->lock
);
2436 data
= (char *) __get_free_pages(GFP_KERNEL
,
2437 get_order(ISCSI_DEF_MAX_RECV_SEG_LEN
));
2439 goto login_task_data_alloc_fail
;
2440 conn
->login_task
->data
= conn
->data
= data
;
2442 init_timer(&conn
->tmf_timer
);
2443 init_waitqueue_head(&conn
->ehwait
);
2447 login_task_data_alloc_fail
:
2448 __kfifo_put(session
->cmdpool
.queue
, (void*)&conn
->login_task
,
2450 login_task_alloc_fail
:
2451 iscsi_destroy_conn(cls_conn
);
2454 EXPORT_SYMBOL_GPL(iscsi_conn_setup
);
2457 * iscsi_conn_teardown - teardown iscsi connection
2458 * cls_conn: iscsi class connection
2460 * TODO: we may need to make this into a two step process
2461 * like scsi-mls remove + put host
2463 void iscsi_conn_teardown(struct iscsi_cls_conn
*cls_conn
)
2465 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
2466 struct iscsi_session
*session
= conn
->session
;
2467 unsigned long flags
;
2469 del_timer_sync(&conn
->transport_timer
);
2471 spin_lock_bh(&session
->lock
);
2472 conn
->c_stage
= ISCSI_CONN_CLEANUP_WAIT
;
2473 if (session
->leadconn
== conn
) {
2475 * leading connection? then give up on recovery.
2477 session
->state
= ISCSI_STATE_TERMINATE
;
2478 wake_up(&conn
->ehwait
);
2480 spin_unlock_bh(&session
->lock
);
2483 * Block until all in-progress commands for this connection
2487 spin_lock_irqsave(session
->host
->host_lock
, flags
);
2488 if (!session
->host
->host_busy
) { /* OK for ERL == 0 */
2489 spin_unlock_irqrestore(session
->host
->host_lock
, flags
);
2492 spin_unlock_irqrestore(session
->host
->host_lock
, flags
);
2493 msleep_interruptible(500);
2494 iscsi_conn_printk(KERN_INFO
, conn
, "iscsi conn_destroy(): "
2495 "host_busy %d host_failed %d\n",
2496 session
->host
->host_busy
,
2497 session
->host
->host_failed
);
2499 * force eh_abort() to unblock
2501 wake_up(&conn
->ehwait
);
2504 /* flush queued up work because we free the connection below */
2505 iscsi_suspend_tx(conn
);
2507 spin_lock_bh(&session
->lock
);
2508 free_pages((unsigned long) conn
->data
,
2509 get_order(ISCSI_DEF_MAX_RECV_SEG_LEN
));
2510 kfree(conn
->persistent_address
);
2511 __kfifo_put(session
->cmdpool
.queue
, (void*)&conn
->login_task
,
2513 if (session
->leadconn
== conn
)
2514 session
->leadconn
= NULL
;
2515 spin_unlock_bh(&session
->lock
);
2517 iscsi_destroy_conn(cls_conn
);
2519 EXPORT_SYMBOL_GPL(iscsi_conn_teardown
);
2521 int iscsi_conn_start(struct iscsi_cls_conn
*cls_conn
)
2523 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
2524 struct iscsi_session
*session
= conn
->session
;
2527 iscsi_conn_printk(KERN_ERR
, conn
,
2528 "can't start unbound connection\n");
2532 if ((session
->imm_data_en
|| !session
->initial_r2t_en
) &&
2533 session
->first_burst
> session
->max_burst
) {
2534 iscsi_conn_printk(KERN_INFO
, conn
, "invalid burst lengths: "
2535 "first_burst %d max_burst %d\n",
2536 session
->first_burst
, session
->max_burst
);
2540 if (conn
->ping_timeout
&& !conn
->recv_timeout
) {
2541 iscsi_conn_printk(KERN_ERR
, conn
, "invalid recv timeout of "
2542 "zero. Using 5 seconds\n.");
2543 conn
->recv_timeout
= 5;
2546 if (conn
->recv_timeout
&& !conn
->ping_timeout
) {
2547 iscsi_conn_printk(KERN_ERR
, conn
, "invalid ping timeout of "
2548 "zero. Using 5 seconds.\n");
2549 conn
->ping_timeout
= 5;
2552 spin_lock_bh(&session
->lock
);
2553 conn
->c_stage
= ISCSI_CONN_STARTED
;
2554 session
->state
= ISCSI_STATE_LOGGED_IN
;
2555 session
->queued_cmdsn
= session
->cmdsn
;
2557 conn
->last_recv
= jiffies
;
2558 conn
->last_ping
= jiffies
;
2559 if (conn
->recv_timeout
&& conn
->ping_timeout
)
2560 mod_timer(&conn
->transport_timer
,
2561 jiffies
+ (conn
->recv_timeout
* HZ
));
2563 switch(conn
->stop_stage
) {
2564 case STOP_CONN_RECOVER
:
2566 * unblock eh_abort() if it is blocked. re-try all
2567 * commands after successful recovery
2569 conn
->stop_stage
= 0;
2570 conn
->tmf_state
= TMF_INITIAL
;
2572 if (session
->age
== 16)
2575 case STOP_CONN_TERM
:
2576 conn
->stop_stage
= 0;
2581 spin_unlock_bh(&session
->lock
);
2583 iscsi_unblock_session(session
->cls_session
);
2584 wake_up(&conn
->ehwait
);
2587 EXPORT_SYMBOL_GPL(iscsi_conn_start
);
2590 fail_mgmt_tasks(struct iscsi_session
*session
, struct iscsi_conn
*conn
)
2592 struct iscsi_task
*task
;
2595 for (i
= 0; i
< conn
->session
->cmds_max
; i
++) {
2596 task
= conn
->session
->cmds
[i
];
2600 if (task
->state
== ISCSI_TASK_FREE
)
2603 ISCSI_DBG_SESSION(conn
->session
,
2604 "failing mgmt itt 0x%x state %d\n",
2605 task
->itt
, task
->state
);
2606 state
= ISCSI_TASK_ABRT_SESS_RECOV
;
2607 if (task
->state
== ISCSI_TASK_PENDING
)
2608 state
= ISCSI_TASK_COMPLETED
;
2609 iscsi_complete_task(task
, state
);
2614 static void iscsi_start_session_recovery(struct iscsi_session
*session
,
2615 struct iscsi_conn
*conn
, int flag
)
2619 mutex_lock(&session
->eh_mutex
);
2620 spin_lock_bh(&session
->lock
);
2621 if (conn
->stop_stage
== STOP_CONN_TERM
) {
2622 spin_unlock_bh(&session
->lock
);
2623 mutex_unlock(&session
->eh_mutex
);
2628 * When this is called for the in_login state, we only want to clean
2629 * up the login task and connection. We do not need to block and set
2630 * the recovery state again
2632 if (flag
== STOP_CONN_TERM
)
2633 session
->state
= ISCSI_STATE_TERMINATE
;
2634 else if (conn
->stop_stage
!= STOP_CONN_RECOVER
)
2635 session
->state
= ISCSI_STATE_IN_RECOVERY
;
2636 spin_unlock_bh(&session
->lock
);
2638 del_timer_sync(&conn
->transport_timer
);
2639 iscsi_suspend_tx(conn
);
2641 spin_lock_bh(&session
->lock
);
2642 old_stop_stage
= conn
->stop_stage
;
2643 conn
->stop_stage
= flag
;
2644 conn
->c_stage
= ISCSI_CONN_STOPPED
;
2645 spin_unlock_bh(&session
->lock
);
2648 * for connection level recovery we should not calculate
2649 * header digest. conn->hdr_size used for optimization
2650 * in hdr_extract() and will be re-negotiated at
2653 if (flag
== STOP_CONN_RECOVER
) {
2654 conn
->hdrdgst_en
= 0;
2655 conn
->datadgst_en
= 0;
2656 if (session
->state
== ISCSI_STATE_IN_RECOVERY
&&
2657 old_stop_stage
!= STOP_CONN_RECOVER
) {
2658 ISCSI_DBG_SESSION(session
, "blocking session\n");
2659 iscsi_block_session(session
->cls_session
);
2666 spin_lock_bh(&session
->lock
);
2667 fail_scsi_tasks(conn
, -1, DID_TRANSPORT_DISRUPTED
);
2668 fail_mgmt_tasks(session
, conn
);
2669 spin_unlock_bh(&session
->lock
);
2670 mutex_unlock(&session
->eh_mutex
);
2673 void iscsi_conn_stop(struct iscsi_cls_conn
*cls_conn
, int flag
)
2675 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
2676 struct iscsi_session
*session
= conn
->session
;
2679 case STOP_CONN_RECOVER
:
2680 case STOP_CONN_TERM
:
2681 iscsi_start_session_recovery(session
, conn
, flag
);
2684 iscsi_conn_printk(KERN_ERR
, conn
,
2685 "invalid stop flag %d\n", flag
);
2688 EXPORT_SYMBOL_GPL(iscsi_conn_stop
);
2690 int iscsi_conn_bind(struct iscsi_cls_session
*cls_session
,
2691 struct iscsi_cls_conn
*cls_conn
, int is_leading
)
2693 struct iscsi_session
*session
= cls_session
->dd_data
;
2694 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
2696 spin_lock_bh(&session
->lock
);
2698 session
->leadconn
= conn
;
2699 spin_unlock_bh(&session
->lock
);
2702 * Unblock xmitworker(), Login Phase will pass through.
2704 clear_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_rx
);
2705 clear_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_tx
);
2708 EXPORT_SYMBOL_GPL(iscsi_conn_bind
);
2710 static int iscsi_switch_str_param(char **param
, char *new_val_buf
)
2715 if (!strcmp(*param
, new_val_buf
))
2719 new_val
= kstrdup(new_val_buf
, GFP_NOIO
);
2728 int iscsi_set_param(struct iscsi_cls_conn
*cls_conn
,
2729 enum iscsi_param param
, char *buf
, int buflen
)
2731 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
2732 struct iscsi_session
*session
= conn
->session
;
2736 case ISCSI_PARAM_FAST_ABORT
:
2737 sscanf(buf
, "%d", &session
->fast_abort
);
2739 case ISCSI_PARAM_ABORT_TMO
:
2740 sscanf(buf
, "%d", &session
->abort_timeout
);
2742 case ISCSI_PARAM_LU_RESET_TMO
:
2743 sscanf(buf
, "%d", &session
->lu_reset_timeout
);
2745 case ISCSI_PARAM_PING_TMO
:
2746 sscanf(buf
, "%d", &conn
->ping_timeout
);
2748 case ISCSI_PARAM_RECV_TMO
:
2749 sscanf(buf
, "%d", &conn
->recv_timeout
);
2751 case ISCSI_PARAM_MAX_RECV_DLENGTH
:
2752 sscanf(buf
, "%d", &conn
->max_recv_dlength
);
2754 case ISCSI_PARAM_MAX_XMIT_DLENGTH
:
2755 sscanf(buf
, "%d", &conn
->max_xmit_dlength
);
2757 case ISCSI_PARAM_HDRDGST_EN
:
2758 sscanf(buf
, "%d", &conn
->hdrdgst_en
);
2760 case ISCSI_PARAM_DATADGST_EN
:
2761 sscanf(buf
, "%d", &conn
->datadgst_en
);
2763 case ISCSI_PARAM_INITIAL_R2T_EN
:
2764 sscanf(buf
, "%d", &session
->initial_r2t_en
);
2766 case ISCSI_PARAM_MAX_R2T
:
2767 sscanf(buf
, "%d", &session
->max_r2t
);
2769 case ISCSI_PARAM_IMM_DATA_EN
:
2770 sscanf(buf
, "%d", &session
->imm_data_en
);
2772 case ISCSI_PARAM_FIRST_BURST
:
2773 sscanf(buf
, "%d", &session
->first_burst
);
2775 case ISCSI_PARAM_MAX_BURST
:
2776 sscanf(buf
, "%d", &session
->max_burst
);
2778 case ISCSI_PARAM_PDU_INORDER_EN
:
2779 sscanf(buf
, "%d", &session
->pdu_inorder_en
);
2781 case ISCSI_PARAM_DATASEQ_INORDER_EN
:
2782 sscanf(buf
, "%d", &session
->dataseq_inorder_en
);
2784 case ISCSI_PARAM_ERL
:
2785 sscanf(buf
, "%d", &session
->erl
);
2787 case ISCSI_PARAM_IFMARKER_EN
:
2788 sscanf(buf
, "%d", &value
);
2791 case ISCSI_PARAM_OFMARKER_EN
:
2792 sscanf(buf
, "%d", &value
);
2795 case ISCSI_PARAM_EXP_STATSN
:
2796 sscanf(buf
, "%u", &conn
->exp_statsn
);
2798 case ISCSI_PARAM_USERNAME
:
2799 return iscsi_switch_str_param(&session
->username
, buf
);
2800 case ISCSI_PARAM_USERNAME_IN
:
2801 return iscsi_switch_str_param(&session
->username_in
, buf
);
2802 case ISCSI_PARAM_PASSWORD
:
2803 return iscsi_switch_str_param(&session
->password
, buf
);
2804 case ISCSI_PARAM_PASSWORD_IN
:
2805 return iscsi_switch_str_param(&session
->password_in
, buf
);
2806 case ISCSI_PARAM_TARGET_NAME
:
2807 return iscsi_switch_str_param(&session
->targetname
, buf
);
2808 case ISCSI_PARAM_TPGT
:
2809 sscanf(buf
, "%d", &session
->tpgt
);
2811 case ISCSI_PARAM_PERSISTENT_PORT
:
2812 sscanf(buf
, "%d", &conn
->persistent_port
);
2814 case ISCSI_PARAM_PERSISTENT_ADDRESS
:
2815 return iscsi_switch_str_param(&conn
->persistent_address
, buf
);
2816 case ISCSI_PARAM_IFACE_NAME
:
2817 return iscsi_switch_str_param(&session
->ifacename
, buf
);
2818 case ISCSI_PARAM_INITIATOR_NAME
:
2819 return iscsi_switch_str_param(&session
->initiatorname
, buf
);
2826 EXPORT_SYMBOL_GPL(iscsi_set_param
);
2828 int iscsi_session_get_param(struct iscsi_cls_session
*cls_session
,
2829 enum iscsi_param param
, char *buf
)
2831 struct iscsi_session
*session
= cls_session
->dd_data
;
2835 case ISCSI_PARAM_FAST_ABORT
:
2836 len
= sprintf(buf
, "%d\n", session
->fast_abort
);
2838 case ISCSI_PARAM_ABORT_TMO
:
2839 len
= sprintf(buf
, "%d\n", session
->abort_timeout
);
2841 case ISCSI_PARAM_LU_RESET_TMO
:
2842 len
= sprintf(buf
, "%d\n", session
->lu_reset_timeout
);
2844 case ISCSI_PARAM_INITIAL_R2T_EN
:
2845 len
= sprintf(buf
, "%d\n", session
->initial_r2t_en
);
2847 case ISCSI_PARAM_MAX_R2T
:
2848 len
= sprintf(buf
, "%hu\n", session
->max_r2t
);
2850 case ISCSI_PARAM_IMM_DATA_EN
:
2851 len
= sprintf(buf
, "%d\n", session
->imm_data_en
);
2853 case ISCSI_PARAM_FIRST_BURST
:
2854 len
= sprintf(buf
, "%u\n", session
->first_burst
);
2856 case ISCSI_PARAM_MAX_BURST
:
2857 len
= sprintf(buf
, "%u\n", session
->max_burst
);
2859 case ISCSI_PARAM_PDU_INORDER_EN
:
2860 len
= sprintf(buf
, "%d\n", session
->pdu_inorder_en
);
2862 case ISCSI_PARAM_DATASEQ_INORDER_EN
:
2863 len
= sprintf(buf
, "%d\n", session
->dataseq_inorder_en
);
2865 case ISCSI_PARAM_ERL
:
2866 len
= sprintf(buf
, "%d\n", session
->erl
);
2868 case ISCSI_PARAM_TARGET_NAME
:
2869 len
= sprintf(buf
, "%s\n", session
->targetname
);
2871 case ISCSI_PARAM_TPGT
:
2872 len
= sprintf(buf
, "%d\n", session
->tpgt
);
2874 case ISCSI_PARAM_USERNAME
:
2875 len
= sprintf(buf
, "%s\n", session
->username
);
2877 case ISCSI_PARAM_USERNAME_IN
:
2878 len
= sprintf(buf
, "%s\n", session
->username_in
);
2880 case ISCSI_PARAM_PASSWORD
:
2881 len
= sprintf(buf
, "%s\n", session
->password
);
2883 case ISCSI_PARAM_PASSWORD_IN
:
2884 len
= sprintf(buf
, "%s\n", session
->password_in
);
2886 case ISCSI_PARAM_IFACE_NAME
:
2887 len
= sprintf(buf
, "%s\n", session
->ifacename
);
2889 case ISCSI_PARAM_INITIATOR_NAME
:
2890 len
= sprintf(buf
, "%s\n", session
->initiatorname
);
2898 EXPORT_SYMBOL_GPL(iscsi_session_get_param
);
2900 int iscsi_conn_get_param(struct iscsi_cls_conn
*cls_conn
,
2901 enum iscsi_param param
, char *buf
)
2903 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
2907 case ISCSI_PARAM_PING_TMO
:
2908 len
= sprintf(buf
, "%u\n", conn
->ping_timeout
);
2910 case ISCSI_PARAM_RECV_TMO
:
2911 len
= sprintf(buf
, "%u\n", conn
->recv_timeout
);
2913 case ISCSI_PARAM_MAX_RECV_DLENGTH
:
2914 len
= sprintf(buf
, "%u\n", conn
->max_recv_dlength
);
2916 case ISCSI_PARAM_MAX_XMIT_DLENGTH
:
2917 len
= sprintf(buf
, "%u\n", conn
->max_xmit_dlength
);
2919 case ISCSI_PARAM_HDRDGST_EN
:
2920 len
= sprintf(buf
, "%d\n", conn
->hdrdgst_en
);
2922 case ISCSI_PARAM_DATADGST_EN
:
2923 len
= sprintf(buf
, "%d\n", conn
->datadgst_en
);
2925 case ISCSI_PARAM_IFMARKER_EN
:
2926 len
= sprintf(buf
, "%d\n", conn
->ifmarker_en
);
2928 case ISCSI_PARAM_OFMARKER_EN
:
2929 len
= sprintf(buf
, "%d\n", conn
->ofmarker_en
);
2931 case ISCSI_PARAM_EXP_STATSN
:
2932 len
= sprintf(buf
, "%u\n", conn
->exp_statsn
);
2934 case ISCSI_PARAM_PERSISTENT_PORT
:
2935 len
= sprintf(buf
, "%d\n", conn
->persistent_port
);
2937 case ISCSI_PARAM_PERSISTENT_ADDRESS
:
2938 len
= sprintf(buf
, "%s\n", conn
->persistent_address
);
2946 EXPORT_SYMBOL_GPL(iscsi_conn_get_param
);
2948 int iscsi_host_get_param(struct Scsi_Host
*shost
, enum iscsi_host_param param
,
2951 struct iscsi_host
*ihost
= shost_priv(shost
);
2955 case ISCSI_HOST_PARAM_NETDEV_NAME
:
2956 len
= sprintf(buf
, "%s\n", ihost
->netdev
);
2958 case ISCSI_HOST_PARAM_HWADDRESS
:
2959 len
= sprintf(buf
, "%s\n", ihost
->hwaddress
);
2961 case ISCSI_HOST_PARAM_INITIATOR_NAME
:
2962 len
= sprintf(buf
, "%s\n", ihost
->initiatorname
);
2964 case ISCSI_HOST_PARAM_IPADDRESS
:
2965 len
= sprintf(buf
, "%s\n", ihost
->local_address
);
2973 EXPORT_SYMBOL_GPL(iscsi_host_get_param
);
2975 int iscsi_host_set_param(struct Scsi_Host
*shost
, enum iscsi_host_param param
,
2976 char *buf
, int buflen
)
2978 struct iscsi_host
*ihost
= shost_priv(shost
);
2981 case ISCSI_HOST_PARAM_NETDEV_NAME
:
2982 return iscsi_switch_str_param(&ihost
->netdev
, buf
);
2983 case ISCSI_HOST_PARAM_HWADDRESS
:
2984 return iscsi_switch_str_param(&ihost
->hwaddress
, buf
);
2985 case ISCSI_HOST_PARAM_INITIATOR_NAME
:
2986 return iscsi_switch_str_param(&ihost
->initiatorname
, buf
);
2993 EXPORT_SYMBOL_GPL(iscsi_host_set_param
);
2995 MODULE_AUTHOR("Mike Christie");
2996 MODULE_DESCRIPTION("iSCSI library functions");
2997 MODULE_LICENSE("GPL");