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 <linux/slab.h>
29 #include <linux/module.h>
30 #include <asm/unaligned.h>
32 #include <scsi/scsi_cmnd.h>
33 #include <scsi/scsi_device.h>
34 #include <scsi/scsi_eh.h>
35 #include <scsi/scsi_tcq.h>
36 #include <scsi/scsi_host.h>
37 #include <scsi/scsi.h>
38 #include <scsi/iscsi_proto.h>
39 #include <scsi/scsi_transport.h>
40 #include <scsi/scsi_transport_iscsi.h>
41 #include <scsi/libiscsi.h>
43 static int iscsi_dbg_lib_conn
;
44 module_param_named(debug_libiscsi_conn
, iscsi_dbg_lib_conn
, int,
46 MODULE_PARM_DESC(debug_libiscsi_conn
,
47 "Turn on debugging for connections in libiscsi module. "
48 "Set to 1 to turn on, and zero to turn off. Default is off.");
50 static int iscsi_dbg_lib_session
;
51 module_param_named(debug_libiscsi_session
, iscsi_dbg_lib_session
, int,
53 MODULE_PARM_DESC(debug_libiscsi_session
,
54 "Turn on debugging for sessions in libiscsi module. "
55 "Set to 1 to turn on, and zero to turn off. Default is off.");
57 static int iscsi_dbg_lib_eh
;
58 module_param_named(debug_libiscsi_eh
, iscsi_dbg_lib_eh
, int,
60 MODULE_PARM_DESC(debug_libiscsi_eh
,
61 "Turn on debugging for error handling in libiscsi module. "
62 "Set to 1 to turn on, and zero to turn off. Default is off.");
64 #define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...) \
66 if (iscsi_dbg_lib_conn) \
67 iscsi_conn_printk(KERN_INFO, _conn, \
72 #define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...) \
74 if (iscsi_dbg_lib_session) \
75 iscsi_session_printk(KERN_INFO, _session, \
80 #define ISCSI_DBG_EH(_session, dbg_fmt, arg...) \
82 if (iscsi_dbg_lib_eh) \
83 iscsi_session_printk(KERN_INFO, _session, \
88 inline void iscsi_conn_queue_work(struct iscsi_conn
*conn
)
90 struct Scsi_Host
*shost
= conn
->session
->host
;
91 struct iscsi_host
*ihost
= shost_priv(shost
);
94 queue_work(ihost
->workq
, &conn
->xmitwork
);
96 EXPORT_SYMBOL_GPL(iscsi_conn_queue_work
);
98 static void __iscsi_update_cmdsn(struct iscsi_session
*session
,
99 uint32_t exp_cmdsn
, uint32_t max_cmdsn
)
102 * standard specifies this check for when to update expected and
103 * max sequence numbers
105 if (iscsi_sna_lt(max_cmdsn
, exp_cmdsn
- 1))
108 if (exp_cmdsn
!= session
->exp_cmdsn
&&
109 !iscsi_sna_lt(exp_cmdsn
, session
->exp_cmdsn
))
110 session
->exp_cmdsn
= exp_cmdsn
;
112 if (max_cmdsn
!= session
->max_cmdsn
&&
113 !iscsi_sna_lt(max_cmdsn
, session
->max_cmdsn
))
114 session
->max_cmdsn
= max_cmdsn
;
117 void iscsi_update_cmdsn(struct iscsi_session
*session
, struct iscsi_nopin
*hdr
)
119 __iscsi_update_cmdsn(session
, be32_to_cpu(hdr
->exp_cmdsn
),
120 be32_to_cpu(hdr
->max_cmdsn
));
122 EXPORT_SYMBOL_GPL(iscsi_update_cmdsn
);
125 * iscsi_prep_data_out_pdu - initialize Data-Out
126 * @task: scsi command task
128 * @hdr: iscsi data in pdu
131 * Initialize Data-Out within this R2T sequence and finds
132 * proper data_offset within this SCSI command.
134 * This function is called with connection lock taken.
136 void iscsi_prep_data_out_pdu(struct iscsi_task
*task
, struct iscsi_r2t_info
*r2t
,
137 struct iscsi_data
*hdr
)
139 struct iscsi_conn
*conn
= task
->conn
;
140 unsigned int left
= r2t
->data_length
- r2t
->sent
;
142 task
->hdr_len
= sizeof(struct iscsi_data
);
144 memset(hdr
, 0, sizeof(struct iscsi_data
));
146 hdr
->datasn
= cpu_to_be32(r2t
->datasn
);
148 hdr
->opcode
= ISCSI_OP_SCSI_DATA_OUT
;
149 hdr
->lun
= task
->lun
;
150 hdr
->itt
= task
->hdr_itt
;
151 hdr
->exp_statsn
= r2t
->exp_statsn
;
152 hdr
->offset
= cpu_to_be32(r2t
->data_offset
+ r2t
->sent
);
153 if (left
> conn
->max_xmit_dlength
) {
154 hton24(hdr
->dlength
, conn
->max_xmit_dlength
);
155 r2t
->data_count
= conn
->max_xmit_dlength
;
158 hton24(hdr
->dlength
, left
);
159 r2t
->data_count
= left
;
160 hdr
->flags
= ISCSI_FLAG_CMD_FINAL
;
162 conn
->dataout_pdus_cnt
++;
164 EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu
);
166 static int iscsi_add_hdr(struct iscsi_task
*task
, unsigned len
)
168 unsigned exp_len
= task
->hdr_len
+ len
;
170 if (exp_len
> task
->hdr_max
) {
175 WARN_ON(len
& (ISCSI_PAD_LEN
- 1)); /* caller must pad the AHS */
176 task
->hdr_len
= exp_len
;
181 * make an extended cdb AHS
183 static int iscsi_prep_ecdb_ahs(struct iscsi_task
*task
)
185 struct scsi_cmnd
*cmd
= task
->sc
;
186 unsigned rlen
, pad_len
;
187 unsigned short ahslength
;
188 struct iscsi_ecdb_ahdr
*ecdb_ahdr
;
191 ecdb_ahdr
= iscsi_next_hdr(task
);
192 rlen
= cmd
->cmd_len
- ISCSI_CDB_SIZE
;
194 BUG_ON(rlen
> sizeof(ecdb_ahdr
->ecdb
));
195 ahslength
= rlen
+ sizeof(ecdb_ahdr
->reserved
);
197 pad_len
= iscsi_padding(rlen
);
199 rc
= iscsi_add_hdr(task
, sizeof(ecdb_ahdr
->ahslength
) +
200 sizeof(ecdb_ahdr
->ahstype
) + ahslength
+ pad_len
);
205 memset(&ecdb_ahdr
->ecdb
[rlen
], 0, pad_len
);
207 ecdb_ahdr
->ahslength
= cpu_to_be16(ahslength
);
208 ecdb_ahdr
->ahstype
= ISCSI_AHSTYPE_CDB
;
209 ecdb_ahdr
->reserved
= 0;
210 memcpy(ecdb_ahdr
->ecdb
, cmd
->cmnd
+ ISCSI_CDB_SIZE
, rlen
);
212 ISCSI_DBG_SESSION(task
->conn
->session
,
213 "iscsi_prep_ecdb_ahs: varlen_cdb_len %d "
214 "rlen %d pad_len %d ahs_length %d iscsi_headers_size "
215 "%u\n", cmd
->cmd_len
, rlen
, pad_len
, ahslength
,
220 static int iscsi_prep_bidi_ahs(struct iscsi_task
*task
)
222 struct scsi_cmnd
*sc
= task
->sc
;
223 struct iscsi_rlength_ahdr
*rlen_ahdr
;
226 rlen_ahdr
= iscsi_next_hdr(task
);
227 rc
= iscsi_add_hdr(task
, sizeof(*rlen_ahdr
));
231 rlen_ahdr
->ahslength
=
232 cpu_to_be16(sizeof(rlen_ahdr
->read_length
) +
233 sizeof(rlen_ahdr
->reserved
));
234 rlen_ahdr
->ahstype
= ISCSI_AHSTYPE_RLENGTH
;
235 rlen_ahdr
->reserved
= 0;
236 rlen_ahdr
->read_length
= cpu_to_be32(scsi_in(sc
)->length
);
238 ISCSI_DBG_SESSION(task
->conn
->session
,
239 "bidi-in rlen_ahdr->read_length(%d) "
240 "rlen_ahdr->ahslength(%d)\n",
241 be32_to_cpu(rlen_ahdr
->read_length
),
242 be16_to_cpu(rlen_ahdr
->ahslength
));
247 * iscsi_check_tmf_restrictions - check if a task is affected by TMF
249 * @opcode: opcode to check for
251 * During TMF a task has to be checked if it's affected.
252 * All unrelated I/O can be passed through, but I/O to the
253 * affected LUN should be restricted.
254 * If 'fast_abort' is set we won't be sending any I/O to the
256 * Otherwise the target is waiting for all TTTs to be completed,
257 * so we have to send all outstanding Data-Out PDUs to the target.
259 static int iscsi_check_tmf_restrictions(struct iscsi_task
*task
, int opcode
)
261 struct iscsi_conn
*conn
= task
->conn
;
262 struct iscsi_tm
*tmf
= &conn
->tmhdr
;
265 if (conn
->tmf_state
== TMF_INITIAL
)
268 if ((tmf
->opcode
& ISCSI_OPCODE_MASK
) != ISCSI_OP_SCSI_TMFUNC
)
271 switch (ISCSI_TM_FUNC_VALUE(tmf
)) {
272 case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET
:
274 * Allow PDUs for unrelated LUNs
276 hdr_lun
= scsilun_to_int(&tmf
->lun
);
277 if (hdr_lun
!= task
->sc
->device
->lun
)
280 case ISCSI_TM_FUNC_TARGET_WARM_RESET
:
282 * Fail all SCSI cmd PDUs
284 if (opcode
!= ISCSI_OP_SCSI_DATA_OUT
) {
285 iscsi_conn_printk(KERN_INFO
, conn
,
286 "task [op %x/%x itt "
289 task
->hdr
->opcode
, opcode
,
290 task
->itt
, task
->hdr_itt
);
294 * And also all data-out PDUs in response to R2T
295 * if fast_abort is set.
297 if (conn
->session
->fast_abort
) {
298 iscsi_conn_printk(KERN_INFO
, conn
,
299 "task [op %x/%x itt "
300 "0x%x/0x%x] fast abort.\n",
301 task
->hdr
->opcode
, opcode
,
302 task
->itt
, task
->hdr_itt
);
306 case ISCSI_TM_FUNC_ABORT_TASK
:
308 * the caller has already checked if the task
309 * they want to abort was in the pending queue so if
310 * we are here the cmd pdu has gone out already, and
311 * we will only hit this for data-outs
313 if (opcode
== ISCSI_OP_SCSI_DATA_OUT
&&
314 task
->hdr_itt
== tmf
->rtt
) {
315 ISCSI_DBG_SESSION(conn
->session
,
316 "Preventing task %x/%x from sending "
317 "data-out due to abort task in "
318 "progress\n", task
->itt
,
329 * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu
332 * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set
333 * fields like dlength or final based on how much data it sends
335 static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task
*task
)
337 struct iscsi_conn
*conn
= task
->conn
;
338 struct iscsi_session
*session
= conn
->session
;
339 struct scsi_cmnd
*sc
= task
->sc
;
340 struct iscsi_scsi_req
*hdr
;
341 unsigned hdrlength
, cmd_len
, transfer_length
;
345 rc
= iscsi_check_tmf_restrictions(task
, ISCSI_OP_SCSI_CMD
);
349 if (conn
->session
->tt
->alloc_pdu
) {
350 rc
= conn
->session
->tt
->alloc_pdu(task
, ISCSI_OP_SCSI_CMD
);
354 hdr
= (struct iscsi_scsi_req
*)task
->hdr
;
356 memset(hdr
, 0, sizeof(*hdr
));
358 if (session
->tt
->parse_pdu_itt
)
359 hdr
->itt
= task
->hdr_itt
= itt
;
361 hdr
->itt
= task
->hdr_itt
= build_itt(task
->itt
,
362 task
->conn
->session
->age
);
364 rc
= iscsi_add_hdr(task
, sizeof(*hdr
));
367 hdr
->opcode
= ISCSI_OP_SCSI_CMD
;
368 hdr
->flags
= ISCSI_ATTR_SIMPLE
;
369 int_to_scsilun(sc
->device
->lun
, &hdr
->lun
);
370 task
->lun
= hdr
->lun
;
371 hdr
->exp_statsn
= cpu_to_be32(conn
->exp_statsn
);
372 cmd_len
= sc
->cmd_len
;
373 if (cmd_len
< ISCSI_CDB_SIZE
)
374 memset(&hdr
->cdb
[cmd_len
], 0, ISCSI_CDB_SIZE
- cmd_len
);
375 else if (cmd_len
> ISCSI_CDB_SIZE
) {
376 rc
= iscsi_prep_ecdb_ahs(task
);
379 cmd_len
= ISCSI_CDB_SIZE
;
381 memcpy(hdr
->cdb
, sc
->cmnd
, cmd_len
);
384 if (scsi_bidi_cmnd(sc
)) {
385 hdr
->flags
|= ISCSI_FLAG_CMD_READ
;
386 rc
= iscsi_prep_bidi_ahs(task
);
391 if (scsi_get_prot_op(sc
) != SCSI_PROT_NORMAL
)
392 task
->protected = true;
394 transfer_length
= scsi_transfer_length(sc
);
395 hdr
->data_length
= cpu_to_be32(transfer_length
);
396 if (sc
->sc_data_direction
== DMA_TO_DEVICE
) {
397 struct iscsi_r2t_info
*r2t
= &task
->unsol_r2t
;
399 hdr
->flags
|= ISCSI_FLAG_CMD_WRITE
;
403 * imm_count bytes to be sent right after
406 * unsol_count bytes(as Data-Out) to be sent
407 * without R2T ack right after
410 * r2t data_length bytes to be sent via R2T ack's
412 * pad_count bytes to be sent as zero-padding
414 memset(r2t
, 0, sizeof(*r2t
));
416 if (session
->imm_data_en
) {
417 if (transfer_length
>= session
->first_burst
)
418 task
->imm_count
= min(session
->first_burst
,
419 conn
->max_xmit_dlength
);
421 task
->imm_count
= min(transfer_length
,
422 conn
->max_xmit_dlength
);
423 hton24(hdr
->dlength
, task
->imm_count
);
425 zero_data(hdr
->dlength
);
427 if (!session
->initial_r2t_en
) {
428 r2t
->data_length
= min(session
->first_burst
,
431 r2t
->data_offset
= task
->imm_count
;
432 r2t
->ttt
= cpu_to_be32(ISCSI_RESERVED_TAG
);
433 r2t
->exp_statsn
= cpu_to_be32(conn
->exp_statsn
);
436 if (!task
->unsol_r2t
.data_length
)
437 /* No unsolicit Data-Out's */
438 hdr
->flags
|= ISCSI_FLAG_CMD_FINAL
;
440 hdr
->flags
|= ISCSI_FLAG_CMD_FINAL
;
441 zero_data(hdr
->dlength
);
443 if (sc
->sc_data_direction
== DMA_FROM_DEVICE
)
444 hdr
->flags
|= ISCSI_FLAG_CMD_READ
;
447 /* calculate size of additional header segments (AHSs) */
448 hdrlength
= task
->hdr_len
- sizeof(*hdr
);
450 WARN_ON(hdrlength
& (ISCSI_PAD_LEN
-1));
451 hdrlength
/= ISCSI_PAD_LEN
;
453 WARN_ON(hdrlength
>= 256);
454 hdr
->hlength
= hdrlength
& 0xFF;
455 hdr
->cmdsn
= task
->cmdsn
= cpu_to_be32(session
->cmdsn
);
457 if (session
->tt
->init_task
&& session
->tt
->init_task(task
))
460 task
->state
= ISCSI_TASK_RUNNING
;
463 conn
->scsicmd_pdus_cnt
++;
464 ISCSI_DBG_SESSION(session
, "iscsi prep [%s cid %d sc %p cdb 0x%x "
465 "itt 0x%x len %d bidi_len %d cmdsn %d win %d]\n",
466 scsi_bidi_cmnd(sc
) ? "bidirectional" :
467 sc
->sc_data_direction
== DMA_TO_DEVICE
?
468 "write" : "read", conn
->id
, sc
, sc
->cmnd
[0],
469 task
->itt
, transfer_length
,
470 scsi_bidi_cmnd(sc
) ? scsi_in(sc
)->length
: 0,
472 session
->max_cmdsn
- session
->exp_cmdsn
+ 1);
477 * iscsi_free_task - free a task
478 * @task: iscsi cmd task
480 * Must be called with session back_lock.
481 * This function returns the scsi command to scsi-ml or cleans
482 * up mgmt tasks then returns the task to the pool.
484 static void iscsi_free_task(struct iscsi_task
*task
)
486 struct iscsi_conn
*conn
= task
->conn
;
487 struct iscsi_session
*session
= conn
->session
;
488 struct scsi_cmnd
*sc
= task
->sc
;
489 int oldstate
= task
->state
;
491 ISCSI_DBG_SESSION(session
, "freeing task itt 0x%x state %d sc %p\n",
492 task
->itt
, task
->state
, task
->sc
);
494 session
->tt
->cleanup_task(task
);
495 task
->state
= ISCSI_TASK_FREE
;
498 * login task is preallocated so do not free
500 if (conn
->login_task
== task
)
503 kfifo_in(&session
->cmdpool
.queue
, (void*)&task
, sizeof(void*));
506 /* SCSI eh reuses commands to verify us */
509 * queue command may call this to free the task, so
510 * it will decide how to return sc to scsi-ml.
512 if (oldstate
!= ISCSI_TASK_REQUEUE_SCSIQ
)
517 void __iscsi_get_task(struct iscsi_task
*task
)
519 atomic_inc(&task
->refcount
);
521 EXPORT_SYMBOL_GPL(__iscsi_get_task
);
523 void __iscsi_put_task(struct iscsi_task
*task
)
525 if (atomic_dec_and_test(&task
->refcount
))
526 iscsi_free_task(task
);
528 EXPORT_SYMBOL_GPL(__iscsi_put_task
);
530 void iscsi_put_task(struct iscsi_task
*task
)
532 struct iscsi_session
*session
= task
->conn
->session
;
534 /* regular RX path uses back_lock */
535 spin_lock_bh(&session
->back_lock
);
536 __iscsi_put_task(task
);
537 spin_unlock_bh(&session
->back_lock
);
539 EXPORT_SYMBOL_GPL(iscsi_put_task
);
542 * iscsi_complete_task - finish a task
543 * @task: iscsi cmd task
544 * @state: state to complete task with
546 * Must be called with session back_lock.
548 static void iscsi_complete_task(struct iscsi_task
*task
, int state
)
550 struct iscsi_conn
*conn
= task
->conn
;
552 ISCSI_DBG_SESSION(conn
->session
,
553 "complete task itt 0x%x state %d sc %p\n",
554 task
->itt
, task
->state
, task
->sc
);
555 if (task
->state
== ISCSI_TASK_COMPLETED
||
556 task
->state
== ISCSI_TASK_ABRT_TMF
||
557 task
->state
== ISCSI_TASK_ABRT_SESS_RECOV
||
558 task
->state
== ISCSI_TASK_REQUEUE_SCSIQ
)
560 WARN_ON_ONCE(task
->state
== ISCSI_TASK_FREE
);
563 spin_lock_bh(&conn
->taskqueuelock
);
564 if (!list_empty(&task
->running
)) {
565 pr_debug_once("%s while task on list", __func__
);
566 list_del_init(&task
->running
);
568 spin_unlock_bh(&conn
->taskqueuelock
);
570 if (conn
->task
== task
)
573 if (conn
->ping_task
== task
)
574 conn
->ping_task
= NULL
;
576 /* release get from queueing */
577 __iscsi_put_task(task
);
581 * iscsi_complete_scsi_task - finish scsi task normally
582 * @task: iscsi task for scsi cmd
583 * @exp_cmdsn: expected cmd sn in cpu format
584 * @max_cmdsn: max cmd sn in cpu format
586 * This is used when drivers do not need or cannot perform
587 * lower level pdu processing.
589 * Called with session back_lock
591 void iscsi_complete_scsi_task(struct iscsi_task
*task
,
592 uint32_t exp_cmdsn
, uint32_t max_cmdsn
)
594 struct iscsi_conn
*conn
= task
->conn
;
596 ISCSI_DBG_SESSION(conn
->session
, "[itt 0x%x]\n", task
->itt
);
598 conn
->last_recv
= jiffies
;
599 __iscsi_update_cmdsn(conn
->session
, exp_cmdsn
, max_cmdsn
);
600 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
602 EXPORT_SYMBOL_GPL(iscsi_complete_scsi_task
);
606 * session back_lock must be held and if not called for a task that is
607 * still pending or from the xmit thread, then xmit thread must
610 static void fail_scsi_task(struct iscsi_task
*task
, int err
)
612 struct iscsi_conn
*conn
= task
->conn
;
613 struct scsi_cmnd
*sc
;
617 * if a command completes and we get a successful tmf response
618 * we will hit this because the scsi eh abort code does not take
625 if (task
->state
== ISCSI_TASK_PENDING
) {
627 * cmd never made it to the xmit thread, so we should not count
628 * the cmd in the sequencing
630 conn
->session
->queued_cmdsn
--;
631 /* it was never sent so just complete like normal */
632 state
= ISCSI_TASK_COMPLETED
;
633 } else if (err
== DID_TRANSPORT_DISRUPTED
)
634 state
= ISCSI_TASK_ABRT_SESS_RECOV
;
636 state
= ISCSI_TASK_ABRT_TMF
;
638 sc
->result
= err
<< 16;
639 if (!scsi_bidi_cmnd(sc
))
640 scsi_set_resid(sc
, scsi_bufflen(sc
));
642 scsi_out(sc
)->resid
= scsi_out(sc
)->length
;
643 scsi_in(sc
)->resid
= scsi_in(sc
)->length
;
646 /* regular RX path uses back_lock */
647 spin_lock_bh(&conn
->session
->back_lock
);
648 iscsi_complete_task(task
, state
);
649 spin_unlock_bh(&conn
->session
->back_lock
);
652 static int iscsi_prep_mgmt_task(struct iscsi_conn
*conn
,
653 struct iscsi_task
*task
)
655 struct iscsi_session
*session
= conn
->session
;
656 struct iscsi_hdr
*hdr
= task
->hdr
;
657 struct iscsi_nopout
*nop
= (struct iscsi_nopout
*)hdr
;
658 uint8_t opcode
= hdr
->opcode
& ISCSI_OPCODE_MASK
;
660 if (conn
->session
->state
== ISCSI_STATE_LOGGING_OUT
)
663 if (opcode
!= ISCSI_OP_LOGIN
&& opcode
!= ISCSI_OP_TEXT
)
664 nop
->exp_statsn
= cpu_to_be32(conn
->exp_statsn
);
666 * pre-format CmdSN for outgoing PDU.
668 nop
->cmdsn
= cpu_to_be32(session
->cmdsn
);
669 if (hdr
->itt
!= RESERVED_ITT
) {
671 * TODO: We always use immediate for normal session pdus.
672 * If we start to send tmfs or nops as non-immediate then
673 * we should start checking the cmdsn numbers for mgmt tasks.
675 * During discovery sessions iscsid sends TEXT as non immediate,
676 * but we always only send one PDU at a time.
678 if (conn
->c_stage
== ISCSI_CONN_STARTED
&&
679 !(hdr
->opcode
& ISCSI_OP_IMMEDIATE
)) {
680 session
->queued_cmdsn
++;
685 if (session
->tt
->init_task
&& session
->tt
->init_task(task
))
688 if ((hdr
->opcode
& ISCSI_OPCODE_MASK
) == ISCSI_OP_LOGOUT
)
689 session
->state
= ISCSI_STATE_LOGGING_OUT
;
691 task
->state
= ISCSI_TASK_RUNNING
;
692 ISCSI_DBG_SESSION(session
, "mgmtpdu [op 0x%x hdr->itt 0x%x "
693 "datalen %d]\n", hdr
->opcode
& ISCSI_OPCODE_MASK
,
694 hdr
->itt
, task
->data_count
);
698 static struct iscsi_task
*
699 __iscsi_conn_send_pdu(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
,
700 char *data
, uint32_t data_size
)
702 struct iscsi_session
*session
= conn
->session
;
703 struct iscsi_host
*ihost
= shost_priv(session
->host
);
704 uint8_t opcode
= hdr
->opcode
& ISCSI_OPCODE_MASK
;
705 struct iscsi_task
*task
;
708 if (session
->state
== ISCSI_STATE_TERMINATE
)
711 if (opcode
== ISCSI_OP_LOGIN
|| opcode
== ISCSI_OP_TEXT
) {
713 * Login and Text are sent serially, in
714 * request-followed-by-response sequence.
715 * Same task can be used. Same ITT must be used.
716 * Note that login_task is preallocated at conn_create().
718 if (conn
->login_task
->state
!= ISCSI_TASK_FREE
) {
719 iscsi_conn_printk(KERN_ERR
, conn
, "Login/Text in "
720 "progress. Cannot start new task.\n");
724 if (data_size
> ISCSI_DEF_MAX_RECV_SEG_LEN
) {
725 iscsi_conn_printk(KERN_ERR
, conn
, "Invalid buffer len of %u for login task. Max len is %u\n", data_size
, ISCSI_DEF_MAX_RECV_SEG_LEN
);
729 task
= conn
->login_task
;
731 if (session
->state
!= ISCSI_STATE_LOGGED_IN
)
734 if (data_size
!= 0) {
735 iscsi_conn_printk(KERN_ERR
, conn
, "Can not send data buffer of len %u for op 0x%x\n", data_size
, opcode
);
739 BUG_ON(conn
->c_stage
== ISCSI_CONN_INITIAL_STAGE
);
740 BUG_ON(conn
->c_stage
== ISCSI_CONN_STOPPED
);
742 if (!kfifo_out(&session
->cmdpool
.queue
,
743 (void*)&task
, sizeof(void*)))
747 * released in complete pdu for task we expect a response for, and
748 * released by the lld when it has transmitted the task for
749 * pdus we do not expect a response for.
751 atomic_set(&task
->refcount
, 1);
754 INIT_LIST_HEAD(&task
->running
);
755 task
->state
= ISCSI_TASK_PENDING
;
758 memcpy(task
->data
, data
, data_size
);
759 task
->data_count
= data_size
;
761 task
->data_count
= 0;
763 if (conn
->session
->tt
->alloc_pdu
) {
764 if (conn
->session
->tt
->alloc_pdu(task
, hdr
->opcode
)) {
765 iscsi_conn_printk(KERN_ERR
, conn
, "Could not allocate "
766 "pdu for mgmt task.\n");
771 itt
= task
->hdr
->itt
;
772 task
->hdr_len
= sizeof(struct iscsi_hdr
);
773 memcpy(task
->hdr
, hdr
, sizeof(struct iscsi_hdr
));
775 if (hdr
->itt
!= RESERVED_ITT
) {
776 if (session
->tt
->parse_pdu_itt
)
777 task
->hdr
->itt
= itt
;
779 task
->hdr
->itt
= build_itt(task
->itt
,
780 task
->conn
->session
->age
);
784 if (iscsi_prep_mgmt_task(conn
, task
))
787 if (session
->tt
->xmit_task(task
))
790 spin_lock_bh(&conn
->taskqueuelock
);
791 list_add_tail(&task
->running
, &conn
->mgmtqueue
);
792 spin_unlock_bh(&conn
->taskqueuelock
);
793 iscsi_conn_queue_work(conn
);
799 /* regular RX path uses back_lock */
800 spin_lock(&session
->back_lock
);
801 __iscsi_put_task(task
);
802 spin_unlock(&session
->back_lock
);
806 int iscsi_conn_send_pdu(struct iscsi_cls_conn
*cls_conn
, struct iscsi_hdr
*hdr
,
807 char *data
, uint32_t data_size
)
809 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
810 struct iscsi_session
*session
= conn
->session
;
813 spin_lock_bh(&session
->frwd_lock
);
814 if (!__iscsi_conn_send_pdu(conn
, hdr
, data
, data_size
))
816 spin_unlock_bh(&session
->frwd_lock
);
819 EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu
);
822 * iscsi_cmd_rsp - SCSI Command Response processing
823 * @conn: iscsi connection
825 * @task: scsi command task
826 * @data: cmd data buffer
827 * @datalen: len of buffer
829 * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and
830 * then completes the command and task.
832 static void iscsi_scsi_cmd_rsp(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
,
833 struct iscsi_task
*task
, char *data
,
836 struct iscsi_scsi_rsp
*rhdr
= (struct iscsi_scsi_rsp
*)hdr
;
837 struct iscsi_session
*session
= conn
->session
;
838 struct scsi_cmnd
*sc
= task
->sc
;
840 iscsi_update_cmdsn(session
, (struct iscsi_nopin
*)rhdr
);
841 conn
->exp_statsn
= be32_to_cpu(rhdr
->statsn
) + 1;
843 sc
->result
= (DID_OK
<< 16) | rhdr
->cmd_status
;
845 if (task
->protected) {
850 * Transports that didn't implement check_protection
851 * callback but still published T10-PI support to scsi-mid
852 * deserve this BUG_ON.
854 BUG_ON(!session
->tt
->check_protection
);
856 ascq
= session
->tt
->check_protection(task
, §or
);
858 sc
->result
= DRIVER_SENSE
<< 24 |
859 SAM_STAT_CHECK_CONDITION
;
860 scsi_build_sense_buffer(1, sc
->sense_buffer
,
861 ILLEGAL_REQUEST
, 0x10, ascq
);
862 scsi_set_sense_information(sc
->sense_buffer
,
863 SCSI_SENSE_BUFFERSIZE
,
869 if (rhdr
->response
!= ISCSI_STATUS_CMD_COMPLETED
) {
870 sc
->result
= DID_ERROR
<< 16;
874 if (rhdr
->cmd_status
== SAM_STAT_CHECK_CONDITION
) {
879 iscsi_conn_printk(KERN_ERR
, conn
,
880 "Got CHECK_CONDITION but invalid data "
881 "buffer size of %d\n", datalen
);
882 sc
->result
= DID_BAD_TARGET
<< 16;
886 senselen
= get_unaligned_be16(data
);
887 if (datalen
< senselen
)
888 goto invalid_datalen
;
890 memcpy(sc
->sense_buffer
, data
+ 2,
891 min_t(uint16_t, senselen
, SCSI_SENSE_BUFFERSIZE
));
892 ISCSI_DBG_SESSION(session
, "copied %d bytes of sense\n",
893 min_t(uint16_t, senselen
,
894 SCSI_SENSE_BUFFERSIZE
));
897 if (rhdr
->flags
& (ISCSI_FLAG_CMD_BIDI_UNDERFLOW
|
898 ISCSI_FLAG_CMD_BIDI_OVERFLOW
)) {
899 int res_count
= be32_to_cpu(rhdr
->bi_residual_count
);
901 if (scsi_bidi_cmnd(sc
) && res_count
> 0 &&
902 (rhdr
->flags
& ISCSI_FLAG_CMD_BIDI_OVERFLOW
||
903 res_count
<= scsi_in(sc
)->length
))
904 scsi_in(sc
)->resid
= res_count
;
906 sc
->result
= (DID_BAD_TARGET
<< 16) | rhdr
->cmd_status
;
909 if (rhdr
->flags
& (ISCSI_FLAG_CMD_UNDERFLOW
|
910 ISCSI_FLAG_CMD_OVERFLOW
)) {
911 int res_count
= be32_to_cpu(rhdr
->residual_count
);
914 (rhdr
->flags
& ISCSI_FLAG_CMD_OVERFLOW
||
915 res_count
<= scsi_bufflen(sc
)))
916 /* write side for bidi or uni-io set_resid */
917 scsi_set_resid(sc
, res_count
);
919 sc
->result
= (DID_BAD_TARGET
<< 16) | rhdr
->cmd_status
;
922 ISCSI_DBG_SESSION(session
, "cmd rsp done [sc %p res %d itt 0x%x]\n",
923 sc
, sc
->result
, task
->itt
);
924 conn
->scsirsp_pdus_cnt
++;
925 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
929 * iscsi_data_in_rsp - SCSI Data-In Response processing
930 * @conn: iscsi connection
932 * @task: scsi command task
935 iscsi_data_in_rsp(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
,
936 struct iscsi_task
*task
)
938 struct iscsi_data_rsp
*rhdr
= (struct iscsi_data_rsp
*)hdr
;
939 struct scsi_cmnd
*sc
= task
->sc
;
941 if (!(rhdr
->flags
& ISCSI_FLAG_DATA_STATUS
))
944 iscsi_update_cmdsn(conn
->session
, (struct iscsi_nopin
*)hdr
);
945 sc
->result
= (DID_OK
<< 16) | rhdr
->cmd_status
;
946 conn
->exp_statsn
= be32_to_cpu(rhdr
->statsn
) + 1;
947 if (rhdr
->flags
& (ISCSI_FLAG_DATA_UNDERFLOW
|
948 ISCSI_FLAG_DATA_OVERFLOW
)) {
949 int res_count
= be32_to_cpu(rhdr
->residual_count
);
952 (rhdr
->flags
& ISCSI_FLAG_CMD_OVERFLOW
||
953 res_count
<= scsi_in(sc
)->length
))
954 scsi_in(sc
)->resid
= res_count
;
956 sc
->result
= (DID_BAD_TARGET
<< 16) | rhdr
->cmd_status
;
959 ISCSI_DBG_SESSION(conn
->session
, "data in with status done "
960 "[sc %p res %d itt 0x%x]\n",
961 sc
, sc
->result
, task
->itt
);
962 conn
->scsirsp_pdus_cnt
++;
963 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
966 static void iscsi_tmf_rsp(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
)
968 struct iscsi_tm_rsp
*tmf
= (struct iscsi_tm_rsp
*)hdr
;
970 conn
->exp_statsn
= be32_to_cpu(hdr
->statsn
) + 1;
971 conn
->tmfrsp_pdus_cnt
++;
973 if (conn
->tmf_state
!= TMF_QUEUED
)
976 if (tmf
->response
== ISCSI_TMF_RSP_COMPLETE
)
977 conn
->tmf_state
= TMF_SUCCESS
;
978 else if (tmf
->response
== ISCSI_TMF_RSP_NO_TASK
)
979 conn
->tmf_state
= TMF_NOT_FOUND
;
981 conn
->tmf_state
= TMF_FAILED
;
982 wake_up(&conn
->ehwait
);
985 static int iscsi_send_nopout(struct iscsi_conn
*conn
, struct iscsi_nopin
*rhdr
)
987 struct iscsi_nopout hdr
;
988 struct iscsi_task
*task
;
990 if (!rhdr
&& conn
->ping_task
)
993 memset(&hdr
, 0, sizeof(struct iscsi_nopout
));
994 hdr
.opcode
= ISCSI_OP_NOOP_OUT
| ISCSI_OP_IMMEDIATE
;
995 hdr
.flags
= ISCSI_FLAG_CMD_FINAL
;
1000 hdr
.itt
= RESERVED_ITT
;
1002 hdr
.ttt
= RESERVED_ITT
;
1004 task
= __iscsi_conn_send_pdu(conn
, (struct iscsi_hdr
*)&hdr
, NULL
, 0);
1006 iscsi_conn_printk(KERN_ERR
, conn
, "Could not send nopout\n");
1009 /* only track our nops */
1010 conn
->ping_task
= task
;
1011 conn
->last_ping
= jiffies
;
1017 static int iscsi_nop_out_rsp(struct iscsi_task
*task
,
1018 struct iscsi_nopin
*nop
, char *data
, int datalen
)
1020 struct iscsi_conn
*conn
= task
->conn
;
1023 if (conn
->ping_task
!= task
) {
1025 * If this is not in response to one of our
1026 * nops then it must be from userspace.
1028 if (iscsi_recv_pdu(conn
->cls_conn
, (struct iscsi_hdr
*)nop
,
1030 rc
= ISCSI_ERR_CONN_FAILED
;
1032 mod_timer(&conn
->transport_timer
, jiffies
+ conn
->recv_timeout
);
1033 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
1037 static int iscsi_handle_reject(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
,
1038 char *data
, int datalen
)
1040 struct iscsi_reject
*reject
= (struct iscsi_reject
*)hdr
;
1041 struct iscsi_hdr rejected_pdu
;
1044 conn
->exp_statsn
= be32_to_cpu(reject
->statsn
) + 1;
1046 if (ntoh24(reject
->dlength
) > datalen
||
1047 ntoh24(reject
->dlength
) < sizeof(struct iscsi_hdr
)) {
1048 iscsi_conn_printk(KERN_ERR
, conn
, "Cannot handle rejected "
1049 "pdu. Invalid data length (pdu dlength "
1050 "%u, datalen %d\n", ntoh24(reject
->dlength
),
1052 return ISCSI_ERR_PROTO
;
1054 memcpy(&rejected_pdu
, data
, sizeof(struct iscsi_hdr
));
1055 opcode
= rejected_pdu
.opcode
& ISCSI_OPCODE_MASK
;
1057 switch (reject
->reason
) {
1058 case ISCSI_REASON_DATA_DIGEST_ERROR
:
1059 iscsi_conn_printk(KERN_ERR
, conn
,
1060 "pdu (op 0x%x itt 0x%x) rejected "
1061 "due to DataDigest error.\n",
1062 opcode
, rejected_pdu
.itt
);
1064 case ISCSI_REASON_IMM_CMD_REJECT
:
1065 iscsi_conn_printk(KERN_ERR
, conn
,
1066 "pdu (op 0x%x itt 0x%x) rejected. Too many "
1067 "immediate commands.\n",
1068 opcode
, rejected_pdu
.itt
);
1070 * We only send one TMF at a time so if the target could not
1071 * handle it, then it should get fixed (RFC mandates that
1072 * a target can handle one immediate TMF per conn).
1074 * For nops-outs, we could have sent more than one if
1075 * the target is sending us lots of nop-ins
1077 if (opcode
!= ISCSI_OP_NOOP_OUT
)
1080 if (rejected_pdu
.itt
== cpu_to_be32(ISCSI_RESERVED_TAG
)) {
1082 * nop-out in response to target's nop-out rejected.
1085 /* In RX path we are under back lock */
1086 spin_unlock(&conn
->session
->back_lock
);
1087 spin_lock(&conn
->session
->frwd_lock
);
1088 iscsi_send_nopout(conn
,
1089 (struct iscsi_nopin
*)&rejected_pdu
);
1090 spin_unlock(&conn
->session
->frwd_lock
);
1091 spin_lock(&conn
->session
->back_lock
);
1093 struct iscsi_task
*task
;
1095 * Our nop as ping got dropped. We know the target
1096 * and transport are ok so just clean up
1098 task
= iscsi_itt_to_task(conn
, rejected_pdu
.itt
);
1100 iscsi_conn_printk(KERN_ERR
, conn
,
1101 "Invalid pdu reject. Could "
1102 "not lookup rejected task.\n");
1103 rc
= ISCSI_ERR_BAD_ITT
;
1105 rc
= iscsi_nop_out_rsp(task
,
1106 (struct iscsi_nopin
*)&rejected_pdu
,
1111 iscsi_conn_printk(KERN_ERR
, conn
,
1112 "pdu (op 0x%x itt 0x%x) rejected. Reason "
1113 "code 0x%x\n", rejected_pdu
.opcode
,
1114 rejected_pdu
.itt
, reject
->reason
);
1121 * iscsi_itt_to_task - look up task by itt
1122 * @conn: iscsi connection
1125 * This should be used for mgmt tasks like login and nops, or if
1126 * the LDD's itt space does not include the session age.
1128 * The session back_lock must be held.
1130 struct iscsi_task
*iscsi_itt_to_task(struct iscsi_conn
*conn
, itt_t itt
)
1132 struct iscsi_session
*session
= conn
->session
;
1135 if (itt
== RESERVED_ITT
)
1138 if (session
->tt
->parse_pdu_itt
)
1139 session
->tt
->parse_pdu_itt(conn
, itt
, &i
, NULL
);
1142 if (i
>= session
->cmds_max
)
1145 return session
->cmds
[i
];
1147 EXPORT_SYMBOL_GPL(iscsi_itt_to_task
);
1150 * __iscsi_complete_pdu - complete pdu
1152 * @hdr: iscsi header
1153 * @data: data buffer
1154 * @datalen: len of data buffer
1156 * Completes pdu processing by freeing any resources allocated at
1157 * queuecommand or send generic. session back_lock must be held and verify
1158 * itt must have been called.
1160 int __iscsi_complete_pdu(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
,
1161 char *data
, int datalen
)
1163 struct iscsi_session
*session
= conn
->session
;
1164 int opcode
= hdr
->opcode
& ISCSI_OPCODE_MASK
, rc
= 0;
1165 struct iscsi_task
*task
;
1168 conn
->last_recv
= jiffies
;
1169 rc
= iscsi_verify_itt(conn
, hdr
->itt
);
1173 if (hdr
->itt
!= RESERVED_ITT
)
1174 itt
= get_itt(hdr
->itt
);
1178 ISCSI_DBG_SESSION(session
, "[op 0x%x cid %d itt 0x%x len %d]\n",
1179 opcode
, conn
->id
, itt
, datalen
);
1182 iscsi_update_cmdsn(session
, (struct iscsi_nopin
*)hdr
);
1185 case ISCSI_OP_NOOP_IN
:
1187 rc
= ISCSI_ERR_PROTO
;
1191 if (hdr
->ttt
== cpu_to_be32(ISCSI_RESERVED_TAG
))
1194 /* In RX path we are under back lock */
1195 spin_unlock(&session
->back_lock
);
1196 spin_lock(&session
->frwd_lock
);
1197 iscsi_send_nopout(conn
, (struct iscsi_nopin
*)hdr
);
1198 spin_unlock(&session
->frwd_lock
);
1199 spin_lock(&session
->back_lock
);
1201 case ISCSI_OP_REJECT
:
1202 rc
= iscsi_handle_reject(conn
, hdr
, data
, datalen
);
1204 case ISCSI_OP_ASYNC_EVENT
:
1205 conn
->exp_statsn
= be32_to_cpu(hdr
->statsn
) + 1;
1206 if (iscsi_recv_pdu(conn
->cls_conn
, hdr
, data
, datalen
))
1207 rc
= ISCSI_ERR_CONN_FAILED
;
1210 rc
= ISCSI_ERR_BAD_OPCODE
;
1217 case ISCSI_OP_SCSI_CMD_RSP
:
1218 case ISCSI_OP_SCSI_DATA_IN
:
1219 task
= iscsi_itt_to_ctask(conn
, hdr
->itt
);
1221 return ISCSI_ERR_BAD_ITT
;
1222 task
->last_xfer
= jiffies
;
1226 * LLD handles R2Ts if they need to.
1229 case ISCSI_OP_LOGOUT_RSP
:
1230 case ISCSI_OP_LOGIN_RSP
:
1231 case ISCSI_OP_TEXT_RSP
:
1232 case ISCSI_OP_SCSI_TMFUNC_RSP
:
1233 case ISCSI_OP_NOOP_IN
:
1234 task
= iscsi_itt_to_task(conn
, hdr
->itt
);
1236 return ISCSI_ERR_BAD_ITT
;
1239 return ISCSI_ERR_BAD_OPCODE
;
1243 case ISCSI_OP_SCSI_CMD_RSP
:
1244 iscsi_scsi_cmd_rsp(conn
, hdr
, task
, data
, datalen
);
1246 case ISCSI_OP_SCSI_DATA_IN
:
1247 iscsi_data_in_rsp(conn
, hdr
, task
);
1249 case ISCSI_OP_LOGOUT_RSP
:
1250 iscsi_update_cmdsn(session
, (struct iscsi_nopin
*)hdr
);
1252 rc
= ISCSI_ERR_PROTO
;
1255 conn
->exp_statsn
= be32_to_cpu(hdr
->statsn
) + 1;
1257 case ISCSI_OP_LOGIN_RSP
:
1258 case ISCSI_OP_TEXT_RSP
:
1259 iscsi_update_cmdsn(session
, (struct iscsi_nopin
*)hdr
);
1261 * login related PDU's exp_statsn is handled in
1265 case ISCSI_OP_SCSI_TMFUNC_RSP
:
1266 iscsi_update_cmdsn(session
, (struct iscsi_nopin
*)hdr
);
1268 rc
= ISCSI_ERR_PROTO
;
1272 iscsi_tmf_rsp(conn
, hdr
);
1273 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
1275 case ISCSI_OP_NOOP_IN
:
1276 iscsi_update_cmdsn(session
, (struct iscsi_nopin
*)hdr
);
1277 if (hdr
->ttt
!= cpu_to_be32(ISCSI_RESERVED_TAG
) || datalen
) {
1278 rc
= ISCSI_ERR_PROTO
;
1281 conn
->exp_statsn
= be32_to_cpu(hdr
->statsn
) + 1;
1283 rc
= iscsi_nop_out_rsp(task
, (struct iscsi_nopin
*)hdr
,
1287 rc
= ISCSI_ERR_BAD_OPCODE
;
1294 if (iscsi_recv_pdu(conn
->cls_conn
, hdr
, data
, datalen
))
1295 rc
= ISCSI_ERR_CONN_FAILED
;
1296 iscsi_complete_task(task
, ISCSI_TASK_COMPLETED
);
1299 EXPORT_SYMBOL_GPL(__iscsi_complete_pdu
);
1301 int iscsi_complete_pdu(struct iscsi_conn
*conn
, struct iscsi_hdr
*hdr
,
1302 char *data
, int datalen
)
1306 spin_lock(&conn
->session
->back_lock
);
1307 rc
= __iscsi_complete_pdu(conn
, hdr
, data
, datalen
);
1308 spin_unlock(&conn
->session
->back_lock
);
1311 EXPORT_SYMBOL_GPL(iscsi_complete_pdu
);
1313 int iscsi_verify_itt(struct iscsi_conn
*conn
, itt_t itt
)
1315 struct iscsi_session
*session
= conn
->session
;
1318 if (itt
== RESERVED_ITT
)
1321 if (session
->tt
->parse_pdu_itt
)
1322 session
->tt
->parse_pdu_itt(conn
, itt
, &i
, &age
);
1325 age
= ((__force u32
)itt
>> ISCSI_AGE_SHIFT
) & ISCSI_AGE_MASK
;
1328 if (age
!= session
->age
) {
1329 iscsi_conn_printk(KERN_ERR
, conn
,
1330 "received itt %x expected session age (%x)\n",
1331 (__force u32
)itt
, session
->age
);
1332 return ISCSI_ERR_BAD_ITT
;
1335 if (i
>= session
->cmds_max
) {
1336 iscsi_conn_printk(KERN_ERR
, conn
,
1337 "received invalid itt index %u (max cmds "
1338 "%u.\n", i
, session
->cmds_max
);
1339 return ISCSI_ERR_BAD_ITT
;
1343 EXPORT_SYMBOL_GPL(iscsi_verify_itt
);
1346 * iscsi_itt_to_ctask - look up ctask by itt
1347 * @conn: iscsi connection
1350 * This should be used for cmd tasks.
1352 * The session back_lock must be held.
1354 struct iscsi_task
*iscsi_itt_to_ctask(struct iscsi_conn
*conn
, itt_t itt
)
1356 struct iscsi_task
*task
;
1358 if (iscsi_verify_itt(conn
, itt
))
1361 task
= iscsi_itt_to_task(conn
, itt
);
1362 if (!task
|| !task
->sc
)
1365 if (task
->sc
->SCp
.phase
!= conn
->session
->age
) {
1366 iscsi_session_printk(KERN_ERR
, conn
->session
,
1367 "task's session age %d, expected %d\n",
1368 task
->sc
->SCp
.phase
, conn
->session
->age
);
1374 EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask
);
1376 void iscsi_session_failure(struct iscsi_session
*session
,
1379 struct iscsi_conn
*conn
;
1382 spin_lock_bh(&session
->frwd_lock
);
1383 conn
= session
->leadconn
;
1384 if (session
->state
== ISCSI_STATE_TERMINATE
|| !conn
) {
1385 spin_unlock_bh(&session
->frwd_lock
);
1389 dev
= get_device(&conn
->cls_conn
->dev
);
1390 spin_unlock_bh(&session
->frwd_lock
);
1394 * if the host is being removed bypass the connection
1395 * recovery initialization because we are going to kill
1398 if (err
== ISCSI_ERR_INVALID_HOST
)
1399 iscsi_conn_error_event(conn
->cls_conn
, err
);
1401 iscsi_conn_failure(conn
, err
);
1404 EXPORT_SYMBOL_GPL(iscsi_session_failure
);
1406 void iscsi_conn_failure(struct iscsi_conn
*conn
, enum iscsi_err err
)
1408 struct iscsi_session
*session
= conn
->session
;
1410 spin_lock_bh(&session
->frwd_lock
);
1411 if (session
->state
== ISCSI_STATE_FAILED
) {
1412 spin_unlock_bh(&session
->frwd_lock
);
1416 if (conn
->stop_stage
== 0)
1417 session
->state
= ISCSI_STATE_FAILED
;
1418 spin_unlock_bh(&session
->frwd_lock
);
1420 set_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_tx
);
1421 set_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_rx
);
1422 iscsi_conn_error_event(conn
->cls_conn
, err
);
1424 EXPORT_SYMBOL_GPL(iscsi_conn_failure
);
1426 static int iscsi_check_cmdsn_window_closed(struct iscsi_conn
*conn
)
1428 struct iscsi_session
*session
= conn
->session
;
1431 * Check for iSCSI window and take care of CmdSN wrap-around
1433 if (!iscsi_sna_lte(session
->queued_cmdsn
, session
->max_cmdsn
)) {
1434 ISCSI_DBG_SESSION(session
, "iSCSI CmdSN closed. ExpCmdSn "
1435 "%u MaxCmdSN %u CmdSN %u/%u\n",
1436 session
->exp_cmdsn
, session
->max_cmdsn
,
1437 session
->cmdsn
, session
->queued_cmdsn
);
1443 static int iscsi_xmit_task(struct iscsi_conn
*conn
)
1445 struct iscsi_task
*task
= conn
->task
;
1448 if (test_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_tx
))
1451 __iscsi_get_task(task
);
1452 spin_unlock_bh(&conn
->session
->frwd_lock
);
1453 rc
= conn
->session
->tt
->xmit_task(task
);
1454 spin_lock_bh(&conn
->session
->frwd_lock
);
1456 /* done with this task */
1457 task
->last_xfer
= jiffies
;
1460 /* regular RX path uses back_lock */
1461 spin_lock(&conn
->session
->back_lock
);
1462 __iscsi_put_task(task
);
1463 spin_unlock(&conn
->session
->back_lock
);
1468 * iscsi_requeue_task - requeue task to run from session workqueue
1469 * @task: task to requeue
1471 * LLDs that need to run a task from the session workqueue should call
1472 * this. The session frwd_lock must be held. This should only be called
1473 * by software drivers.
1475 void iscsi_requeue_task(struct iscsi_task
*task
)
1477 struct iscsi_conn
*conn
= task
->conn
;
1480 * this may be on the requeue list already if the xmit_task callout
1481 * is handling the r2ts while we are adding new ones
1483 spin_lock_bh(&conn
->taskqueuelock
);
1484 if (list_empty(&task
->running
))
1485 list_add_tail(&task
->running
, &conn
->requeue
);
1486 spin_unlock_bh(&conn
->taskqueuelock
);
1487 iscsi_conn_queue_work(conn
);
1489 EXPORT_SYMBOL_GPL(iscsi_requeue_task
);
1492 * iscsi_data_xmit - xmit any command into the scheduled connection
1493 * @conn: iscsi connection
1496 * The function can return -EAGAIN in which case the caller must
1497 * re-schedule it again later or recover. '0' return code means
1500 static int iscsi_data_xmit(struct iscsi_conn
*conn
)
1502 struct iscsi_task
*task
;
1505 spin_lock_bh(&conn
->session
->frwd_lock
);
1506 if (test_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_tx
)) {
1507 ISCSI_DBG_SESSION(conn
->session
, "Tx suspended!\n");
1508 spin_unlock_bh(&conn
->session
->frwd_lock
);
1513 rc
= iscsi_xmit_task(conn
);
1519 * process mgmt pdus like nops before commands since we should
1520 * only have one nop-out as a ping from us and targets should not
1521 * overflow us with nop-ins
1523 spin_lock_bh(&conn
->taskqueuelock
);
1525 while (!list_empty(&conn
->mgmtqueue
)) {
1526 conn
->task
= list_entry(conn
->mgmtqueue
.next
,
1527 struct iscsi_task
, running
);
1528 list_del_init(&conn
->task
->running
);
1529 spin_unlock_bh(&conn
->taskqueuelock
);
1530 if (iscsi_prep_mgmt_task(conn
, conn
->task
)) {
1531 /* regular RX path uses back_lock */
1532 spin_lock_bh(&conn
->session
->back_lock
);
1533 __iscsi_put_task(conn
->task
);
1534 spin_unlock_bh(&conn
->session
->back_lock
);
1536 spin_lock_bh(&conn
->taskqueuelock
);
1539 rc
= iscsi_xmit_task(conn
);
1542 spin_lock_bh(&conn
->taskqueuelock
);
1545 /* process pending command queue */
1546 while (!list_empty(&conn
->cmdqueue
)) {
1547 conn
->task
= list_entry(conn
->cmdqueue
.next
, struct iscsi_task
,
1549 list_del_init(&conn
->task
->running
);
1550 spin_unlock_bh(&conn
->taskqueuelock
);
1551 if (conn
->session
->state
== ISCSI_STATE_LOGGING_OUT
) {
1552 fail_scsi_task(conn
->task
, DID_IMM_RETRY
);
1553 spin_lock_bh(&conn
->taskqueuelock
);
1556 rc
= iscsi_prep_scsi_cmd_pdu(conn
->task
);
1558 if (rc
== -ENOMEM
|| rc
== -EACCES
) {
1559 spin_lock_bh(&conn
->taskqueuelock
);
1560 list_add_tail(&conn
->task
->running
,
1563 spin_unlock_bh(&conn
->taskqueuelock
);
1566 fail_scsi_task(conn
->task
, DID_ABORT
);
1567 spin_lock_bh(&conn
->taskqueuelock
);
1570 rc
= iscsi_xmit_task(conn
);
1574 * we could continuously get new task requests so
1575 * we need to check the mgmt queue for nops that need to
1576 * be sent to aviod starvation
1578 spin_lock_bh(&conn
->taskqueuelock
);
1579 if (!list_empty(&conn
->mgmtqueue
))
1583 while (!list_empty(&conn
->requeue
)) {
1585 * we always do fastlogout - conn stop code will clean up.
1587 if (conn
->session
->state
== ISCSI_STATE_LOGGING_OUT
)
1590 task
= list_entry(conn
->requeue
.next
, struct iscsi_task
,
1592 if (iscsi_check_tmf_restrictions(task
, ISCSI_OP_SCSI_DATA_OUT
))
1596 list_del_init(&conn
->task
->running
);
1597 conn
->task
->state
= ISCSI_TASK_RUNNING
;
1598 spin_unlock_bh(&conn
->taskqueuelock
);
1599 rc
= iscsi_xmit_task(conn
);
1602 spin_lock_bh(&conn
->taskqueuelock
);
1603 if (!list_empty(&conn
->mgmtqueue
))
1606 spin_unlock_bh(&conn
->taskqueuelock
);
1607 spin_unlock_bh(&conn
->session
->frwd_lock
);
1611 spin_unlock_bh(&conn
->session
->frwd_lock
);
1615 static void iscsi_xmitworker(struct work_struct
*work
)
1617 struct iscsi_conn
*conn
=
1618 container_of(work
, struct iscsi_conn
, xmitwork
);
1621 * serialize Xmit worker on a per-connection basis.
1624 rc
= iscsi_data_xmit(conn
);
1625 } while (rc
>= 0 || rc
== -EAGAIN
);
1628 static inline struct iscsi_task
*iscsi_alloc_task(struct iscsi_conn
*conn
,
1629 struct scsi_cmnd
*sc
)
1631 struct iscsi_task
*task
;
1633 if (!kfifo_out(&conn
->session
->cmdpool
.queue
,
1634 (void *) &task
, sizeof(void *)))
1637 sc
->SCp
.phase
= conn
->session
->age
;
1638 sc
->SCp
.ptr
= (char *) task
;
1640 atomic_set(&task
->refcount
, 1);
1641 task
->state
= ISCSI_TASK_PENDING
;
1644 task
->have_checked_conn
= false;
1645 task
->last_timeout
= jiffies
;
1646 task
->last_xfer
= jiffies
;
1647 task
->protected = false;
1648 INIT_LIST_HEAD(&task
->running
);
1653 FAILURE_BAD_HOST
= 1,
1654 FAILURE_SESSION_FAILED
,
1655 FAILURE_SESSION_FREED
,
1656 FAILURE_WINDOW_CLOSED
,
1658 FAILURE_SESSION_TERMINATE
,
1659 FAILURE_SESSION_IN_RECOVERY
,
1660 FAILURE_SESSION_RECOVERY_TIMEOUT
,
1661 FAILURE_SESSION_LOGGING_OUT
,
1662 FAILURE_SESSION_NOT_READY
,
1665 int iscsi_queuecommand(struct Scsi_Host
*host
, struct scsi_cmnd
*sc
)
1667 struct iscsi_cls_session
*cls_session
;
1668 struct iscsi_host
*ihost
;
1670 struct iscsi_session
*session
;
1671 struct iscsi_conn
*conn
;
1672 struct iscsi_task
*task
= NULL
;
1677 ihost
= shost_priv(host
);
1679 cls_session
= starget_to_session(scsi_target(sc
->device
));
1680 session
= cls_session
->dd_data
;
1681 spin_lock_bh(&session
->frwd_lock
);
1683 reason
= iscsi_session_chkready(cls_session
);
1685 sc
->result
= reason
;
1689 if (session
->state
!= ISCSI_STATE_LOGGED_IN
) {
1691 * to handle the race between when we set the recovery state
1692 * and block the session we requeue here (commands could
1693 * be entering our queuecommand while a block is starting
1694 * up because the block code is not locked)
1696 switch (session
->state
) {
1697 case ISCSI_STATE_FAILED
:
1698 case ISCSI_STATE_IN_RECOVERY
:
1699 reason
= FAILURE_SESSION_IN_RECOVERY
;
1700 sc
->result
= DID_IMM_RETRY
<< 16;
1702 case ISCSI_STATE_LOGGING_OUT
:
1703 reason
= FAILURE_SESSION_LOGGING_OUT
;
1704 sc
->result
= DID_IMM_RETRY
<< 16;
1706 case ISCSI_STATE_RECOVERY_FAILED
:
1707 reason
= FAILURE_SESSION_RECOVERY_TIMEOUT
;
1708 sc
->result
= DID_TRANSPORT_FAILFAST
<< 16;
1710 case ISCSI_STATE_TERMINATE
:
1711 reason
= FAILURE_SESSION_TERMINATE
;
1712 sc
->result
= DID_NO_CONNECT
<< 16;
1715 reason
= FAILURE_SESSION_FREED
;
1716 sc
->result
= DID_NO_CONNECT
<< 16;
1721 conn
= session
->leadconn
;
1723 reason
= FAILURE_SESSION_FREED
;
1724 sc
->result
= DID_NO_CONNECT
<< 16;
1728 if (test_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_tx
)) {
1729 reason
= FAILURE_SESSION_IN_RECOVERY
;
1730 sc
->result
= DID_REQUEUE
;
1734 if (iscsi_check_cmdsn_window_closed(conn
)) {
1735 reason
= FAILURE_WINDOW_CLOSED
;
1739 task
= iscsi_alloc_task(conn
, sc
);
1741 reason
= FAILURE_OOM
;
1745 if (!ihost
->workq
) {
1746 reason
= iscsi_prep_scsi_cmd_pdu(task
);
1748 if (reason
== -ENOMEM
|| reason
== -EACCES
) {
1749 reason
= FAILURE_OOM
;
1752 sc
->result
= DID_ABORT
<< 16;
1756 if (session
->tt
->xmit_task(task
)) {
1758 reason
= FAILURE_SESSION_NOT_READY
;
1762 spin_lock_bh(&conn
->taskqueuelock
);
1763 list_add_tail(&task
->running
, &conn
->cmdqueue
);
1764 spin_unlock_bh(&conn
->taskqueuelock
);
1765 iscsi_conn_queue_work(conn
);
1768 session
->queued_cmdsn
++;
1769 spin_unlock_bh(&session
->frwd_lock
);
1773 iscsi_complete_task(task
, ISCSI_TASK_REQUEUE_SCSIQ
);
1775 spin_unlock_bh(&session
->frwd_lock
);
1776 ISCSI_DBG_SESSION(session
, "cmd 0x%x rejected (%d)\n",
1777 sc
->cmnd
[0], reason
);
1778 return SCSI_MLQUEUE_TARGET_BUSY
;
1781 iscsi_complete_task(task
, ISCSI_TASK_REQUEUE_SCSIQ
);
1783 spin_unlock_bh(&session
->frwd_lock
);
1784 ISCSI_DBG_SESSION(session
, "iscsi: cmd 0x%x is not queued (%d)\n",
1785 sc
->cmnd
[0], reason
);
1786 if (!scsi_bidi_cmnd(sc
))
1787 scsi_set_resid(sc
, scsi_bufflen(sc
));
1789 scsi_out(sc
)->resid
= scsi_out(sc
)->length
;
1790 scsi_in(sc
)->resid
= scsi_in(sc
)->length
;
1795 EXPORT_SYMBOL_GPL(iscsi_queuecommand
);
1797 int iscsi_target_alloc(struct scsi_target
*starget
)
1799 struct iscsi_cls_session
*cls_session
= starget_to_session(starget
);
1800 struct iscsi_session
*session
= cls_session
->dd_data
;
1802 starget
->can_queue
= session
->scsi_cmds_max
;
1805 EXPORT_SYMBOL_GPL(iscsi_target_alloc
);
1807 static void iscsi_tmf_timedout(unsigned long data
)
1809 struct iscsi_conn
*conn
= (struct iscsi_conn
*)data
;
1810 struct iscsi_session
*session
= conn
->session
;
1812 spin_lock(&session
->frwd_lock
);
1813 if (conn
->tmf_state
== TMF_QUEUED
) {
1814 conn
->tmf_state
= TMF_TIMEDOUT
;
1815 ISCSI_DBG_EH(session
, "tmf timedout\n");
1816 /* unblock eh_abort() */
1817 wake_up(&conn
->ehwait
);
1819 spin_unlock(&session
->frwd_lock
);
1822 static int iscsi_exec_task_mgmt_fn(struct iscsi_conn
*conn
,
1823 struct iscsi_tm
*hdr
, int age
,
1826 struct iscsi_session
*session
= conn
->session
;
1827 struct iscsi_task
*task
;
1829 task
= __iscsi_conn_send_pdu(conn
, (struct iscsi_hdr
*)hdr
,
1832 spin_unlock_bh(&session
->frwd_lock
);
1833 iscsi_conn_printk(KERN_ERR
, conn
, "Could not send TMF.\n");
1834 iscsi_conn_failure(conn
, ISCSI_ERR_CONN_FAILED
);
1835 spin_lock_bh(&session
->frwd_lock
);
1838 conn
->tmfcmd_pdus_cnt
++;
1839 conn
->tmf_timer
.expires
= timeout
* HZ
+ jiffies
;
1840 conn
->tmf_timer
.function
= iscsi_tmf_timedout
;
1841 conn
->tmf_timer
.data
= (unsigned long)conn
;
1842 add_timer(&conn
->tmf_timer
);
1843 ISCSI_DBG_EH(session
, "tmf set timeout\n");
1845 spin_unlock_bh(&session
->frwd_lock
);
1846 mutex_unlock(&session
->eh_mutex
);
1849 * block eh thread until:
1853 * 3) session is terminated or restarted or userspace has
1854 * given up on recovery
1856 wait_event_interruptible(conn
->ehwait
, age
!= session
->age
||
1857 session
->state
!= ISCSI_STATE_LOGGED_IN
||
1858 conn
->tmf_state
!= TMF_QUEUED
);
1859 if (signal_pending(current
))
1860 flush_signals(current
);
1861 del_timer_sync(&conn
->tmf_timer
);
1863 mutex_lock(&session
->eh_mutex
);
1864 spin_lock_bh(&session
->frwd_lock
);
1865 /* if the session drops it will clean up the task */
1866 if (age
!= session
->age
||
1867 session
->state
!= ISCSI_STATE_LOGGED_IN
)
1873 * Fail commands. session lock held and recv side suspended and xmit
1876 static void fail_scsi_tasks(struct iscsi_conn
*conn
, u64 lun
, int error
)
1878 struct iscsi_task
*task
;
1881 for (i
= 0; i
< conn
->session
->cmds_max
; i
++) {
1882 task
= conn
->session
->cmds
[i
];
1883 if (!task
->sc
|| task
->state
== ISCSI_TASK_FREE
)
1886 if (lun
!= -1 && lun
!= task
->sc
->device
->lun
)
1889 ISCSI_DBG_SESSION(conn
->session
,
1890 "failing sc %p itt 0x%x state %d\n",
1891 task
->sc
, task
->itt
, task
->state
);
1892 fail_scsi_task(task
, error
);
1897 * iscsi_suspend_queue - suspend iscsi_queuecommand
1898 * @conn: iscsi conn to stop queueing IO on
1900 * This grabs the session frwd_lock to make sure no one is in
1901 * xmit_task/queuecommand, and then sets suspend to prevent
1902 * new commands from being queued. This only needs to be called
1903 * by offload drivers that need to sync a path like ep disconnect
1904 * with the iscsi_queuecommand/xmit_task. To start IO again libiscsi
1905 * will call iscsi_start_tx and iscsi_unblock_session when in FFP.
1907 void iscsi_suspend_queue(struct iscsi_conn
*conn
)
1909 spin_lock_bh(&conn
->session
->frwd_lock
);
1910 set_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_tx
);
1911 spin_unlock_bh(&conn
->session
->frwd_lock
);
1913 EXPORT_SYMBOL_GPL(iscsi_suspend_queue
);
1916 * iscsi_suspend_tx - suspend iscsi_data_xmit
1917 * @conn: iscsi conn tp stop processing IO on.
1919 * This function sets the suspend bit to prevent iscsi_data_xmit
1920 * from sending new IO, and if work is queued on the xmit thread
1921 * it will wait for it to be completed.
1923 void iscsi_suspend_tx(struct iscsi_conn
*conn
)
1925 struct Scsi_Host
*shost
= conn
->session
->host
;
1926 struct iscsi_host
*ihost
= shost_priv(shost
);
1928 set_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_tx
);
1930 flush_workqueue(ihost
->workq
);
1932 EXPORT_SYMBOL_GPL(iscsi_suspend_tx
);
1934 static void iscsi_start_tx(struct iscsi_conn
*conn
)
1936 clear_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_tx
);
1937 iscsi_conn_queue_work(conn
);
1941 * We want to make sure a ping is in flight. It has timed out.
1942 * And we are not busy processing a pdu that is making
1943 * progress but got started before the ping and is taking a while
1944 * to complete so the ping is just stuck behind it in a queue.
1946 static int iscsi_has_ping_timed_out(struct iscsi_conn
*conn
)
1948 if (conn
->ping_task
&&
1949 time_before_eq(conn
->last_recv
+ (conn
->recv_timeout
* HZ
) +
1950 (conn
->ping_timeout
* HZ
), jiffies
))
1956 static enum blk_eh_timer_return
iscsi_eh_cmd_timed_out(struct scsi_cmnd
*sc
)
1958 enum blk_eh_timer_return rc
= BLK_EH_NOT_HANDLED
;
1959 struct iscsi_task
*task
= NULL
, *running_task
;
1960 struct iscsi_cls_session
*cls_session
;
1961 struct iscsi_session
*session
;
1962 struct iscsi_conn
*conn
;
1965 cls_session
= starget_to_session(scsi_target(sc
->device
));
1966 session
= cls_session
->dd_data
;
1968 ISCSI_DBG_EH(session
, "scsi cmd %p timedout\n", sc
);
1970 spin_lock(&session
->frwd_lock
);
1971 task
= (struct iscsi_task
*)sc
->SCp
.ptr
;
1974 * Raced with completion. Blk layer has taken ownership
1975 * so let timeout code complete it now.
1977 rc
= BLK_EH_HANDLED
;
1981 if (session
->state
!= ISCSI_STATE_LOGGED_IN
) {
1983 * We are probably in the middle of iscsi recovery so let
1984 * that complete and handle the error.
1986 rc
= BLK_EH_RESET_TIMER
;
1990 conn
= session
->leadconn
;
1992 /* In the middle of shuting down */
1993 rc
= BLK_EH_RESET_TIMER
;
1998 * If we have sent (at least queued to the network layer) a pdu or
1999 * recvd one for the task since the last timeout ask for
2000 * more time. If on the next timeout we have not made progress
2001 * we can check if it is the task or connection when we send the
2004 if (time_after(task
->last_xfer
, task
->last_timeout
)) {
2005 ISCSI_DBG_EH(session
, "Command making progress. Asking "
2006 "scsi-ml for more time to complete. "
2007 "Last data xfer at %lu. Last timeout was at "
2008 "%lu\n.", task
->last_xfer
, task
->last_timeout
);
2009 task
->have_checked_conn
= false;
2010 rc
= BLK_EH_RESET_TIMER
;
2014 if (!conn
->recv_timeout
&& !conn
->ping_timeout
)
2017 * if the ping timedout then we are in the middle of cleaning up
2018 * and can let the iscsi eh handle it
2020 if (iscsi_has_ping_timed_out(conn
)) {
2021 rc
= BLK_EH_RESET_TIMER
;
2025 for (i
= 0; i
< conn
->session
->cmds_max
; i
++) {
2026 running_task
= conn
->session
->cmds
[i
];
2027 if (!running_task
->sc
|| running_task
== task
||
2028 running_task
->state
!= ISCSI_TASK_RUNNING
)
2032 * Only check if cmds started before this one have made
2033 * progress, or this could never fail
2035 if (time_after(running_task
->sc
->jiffies_at_alloc
,
2036 task
->sc
->jiffies_at_alloc
))
2039 if (time_after(running_task
->last_xfer
, task
->last_timeout
)) {
2041 * This task has not made progress, but a task
2042 * started before us has transferred data since
2043 * we started/last-checked. We could be queueing
2044 * too many tasks or the LU is bad.
2046 * If the device is bad the cmds ahead of us on
2047 * other devs will complete, and this loop will
2048 * eventually fail starting the scsi eh.
2050 ISCSI_DBG_EH(session
, "Command has not made progress "
2051 "but commands ahead of it have. "
2052 "Asking scsi-ml for more time to "
2053 "complete. Our last xfer vs running task "
2054 "last xfer %lu/%lu. Last check %lu.\n",
2055 task
->last_xfer
, running_task
->last_xfer
,
2056 task
->last_timeout
);
2057 rc
= BLK_EH_RESET_TIMER
;
2062 /* Assumes nop timeout is shorter than scsi cmd timeout */
2063 if (task
->have_checked_conn
)
2067 * Checking the transport already or nop from a cmd timeout still
2070 if (conn
->ping_task
) {
2071 task
->have_checked_conn
= true;
2072 rc
= BLK_EH_RESET_TIMER
;
2076 /* Make sure there is a transport check done */
2077 iscsi_send_nopout(conn
, NULL
);
2078 task
->have_checked_conn
= true;
2079 rc
= BLK_EH_RESET_TIMER
;
2083 task
->last_timeout
= jiffies
;
2084 spin_unlock(&session
->frwd_lock
);
2085 ISCSI_DBG_EH(session
, "return %s\n", rc
== BLK_EH_RESET_TIMER
?
2086 "timer reset" : "nh");
2090 static void iscsi_check_transport_timeouts(unsigned long data
)
2092 struct iscsi_conn
*conn
= (struct iscsi_conn
*)data
;
2093 struct iscsi_session
*session
= conn
->session
;
2094 unsigned long recv_timeout
, next_timeout
= 0, last_recv
;
2096 spin_lock(&session
->frwd_lock
);
2097 if (session
->state
!= ISCSI_STATE_LOGGED_IN
)
2100 recv_timeout
= conn
->recv_timeout
;
2105 last_recv
= conn
->last_recv
;
2107 if (iscsi_has_ping_timed_out(conn
)) {
2108 iscsi_conn_printk(KERN_ERR
, conn
, "ping timeout of %d secs "
2109 "expired, recv timeout %d, last rx %lu, "
2110 "last ping %lu, now %lu\n",
2111 conn
->ping_timeout
, conn
->recv_timeout
,
2112 last_recv
, conn
->last_ping
, jiffies
);
2113 spin_unlock(&session
->frwd_lock
);
2114 iscsi_conn_failure(conn
, ISCSI_ERR_NOP_TIMEDOUT
);
2118 if (time_before_eq(last_recv
+ recv_timeout
, jiffies
)) {
2119 /* send a ping to try to provoke some traffic */
2120 ISCSI_DBG_CONN(conn
, "Sending nopout as ping\n");
2121 if (iscsi_send_nopout(conn
, NULL
))
2122 next_timeout
= jiffies
+ (1 * HZ
);
2124 next_timeout
= conn
->last_ping
+ (conn
->ping_timeout
* HZ
);
2126 next_timeout
= last_recv
+ recv_timeout
;
2128 ISCSI_DBG_CONN(conn
, "Setting next tmo %lu\n", next_timeout
);
2129 mod_timer(&conn
->transport_timer
, next_timeout
);
2131 spin_unlock(&session
->frwd_lock
);
2134 static void iscsi_prep_abort_task_pdu(struct iscsi_task
*task
,
2135 struct iscsi_tm
*hdr
)
2137 memset(hdr
, 0, sizeof(*hdr
));
2138 hdr
->opcode
= ISCSI_OP_SCSI_TMFUNC
| ISCSI_OP_IMMEDIATE
;
2139 hdr
->flags
= ISCSI_TM_FUNC_ABORT_TASK
& ISCSI_FLAG_TM_FUNC_MASK
;
2140 hdr
->flags
|= ISCSI_FLAG_CMD_FINAL
;
2141 hdr
->lun
= task
->lun
;
2142 hdr
->rtt
= task
->hdr_itt
;
2143 hdr
->refcmdsn
= task
->cmdsn
;
2146 int iscsi_eh_abort(struct scsi_cmnd
*sc
)
2148 struct iscsi_cls_session
*cls_session
;
2149 struct iscsi_session
*session
;
2150 struct iscsi_conn
*conn
;
2151 struct iscsi_task
*task
;
2152 struct iscsi_tm
*hdr
;
2155 cls_session
= starget_to_session(scsi_target(sc
->device
));
2156 session
= cls_session
->dd_data
;
2158 ISCSI_DBG_EH(session
, "aborting sc %p\n", sc
);
2160 mutex_lock(&session
->eh_mutex
);
2161 spin_lock_bh(&session
->frwd_lock
);
2163 * if session was ISCSI_STATE_IN_RECOVERY then we may not have
2167 ISCSI_DBG_EH(session
, "sc never reached iscsi layer or "
2169 spin_unlock_bh(&session
->frwd_lock
);
2170 mutex_unlock(&session
->eh_mutex
);
2175 * If we are not logged in or we have started a new session
2176 * then let the host reset code handle this
2178 if (!session
->leadconn
|| session
->state
!= ISCSI_STATE_LOGGED_IN
||
2179 sc
->SCp
.phase
!= session
->age
) {
2180 spin_unlock_bh(&session
->frwd_lock
);
2181 mutex_unlock(&session
->eh_mutex
);
2182 ISCSI_DBG_EH(session
, "failing abort due to dropped "
2187 conn
= session
->leadconn
;
2188 conn
->eh_abort_cnt
++;
2191 task
= (struct iscsi_task
*)sc
->SCp
.ptr
;
2192 ISCSI_DBG_EH(session
, "aborting [sc %p itt 0x%x]\n",
2195 /* task completed before time out */
2197 ISCSI_DBG_EH(session
, "sc completed while abort in progress\n");
2201 if (task
->state
== ISCSI_TASK_PENDING
) {
2202 fail_scsi_task(task
, DID_ABORT
);
2206 /* only have one tmf outstanding at a time */
2207 if (conn
->tmf_state
!= TMF_INITIAL
)
2209 conn
->tmf_state
= TMF_QUEUED
;
2212 iscsi_prep_abort_task_pdu(task
, hdr
);
2214 if (iscsi_exec_task_mgmt_fn(conn
, hdr
, age
, session
->abort_timeout
))
2217 switch (conn
->tmf_state
) {
2219 spin_unlock_bh(&session
->frwd_lock
);
2221 * stop tx side incase the target had sent a abort rsp but
2222 * the initiator was still writing out data.
2224 iscsi_suspend_tx(conn
);
2226 * we do not stop the recv side because targets have been
2227 * good and have never sent us a successful tmf response
2228 * then sent more data for the cmd.
2230 spin_lock_bh(&session
->frwd_lock
);
2231 fail_scsi_task(task
, DID_ABORT
);
2232 conn
->tmf_state
= TMF_INITIAL
;
2233 memset(hdr
, 0, sizeof(*hdr
));
2234 spin_unlock_bh(&session
->frwd_lock
);
2235 iscsi_start_tx(conn
);
2236 goto success_unlocked
;
2238 spin_unlock_bh(&session
->frwd_lock
);
2239 iscsi_conn_failure(conn
, ISCSI_ERR_SCSI_EH_SESSION_RST
);
2240 goto failed_unlocked
;
2243 conn
->tmf_state
= TMF_INITIAL
;
2244 memset(hdr
, 0, sizeof(*hdr
));
2245 /* task completed before tmf abort response */
2246 ISCSI_DBG_EH(session
, "sc completed while abort in "
2252 conn
->tmf_state
= TMF_INITIAL
;
2257 spin_unlock_bh(&session
->frwd_lock
);
2259 ISCSI_DBG_EH(session
, "abort success [sc %p itt 0x%x]\n",
2261 mutex_unlock(&session
->eh_mutex
);
2265 spin_unlock_bh(&session
->frwd_lock
);
2267 ISCSI_DBG_EH(session
, "abort failed [sc %p itt 0x%x]\n", sc
,
2268 task
? task
->itt
: 0);
2269 mutex_unlock(&session
->eh_mutex
);
2272 EXPORT_SYMBOL_GPL(iscsi_eh_abort
);
2274 static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd
*sc
, struct iscsi_tm
*hdr
)
2276 memset(hdr
, 0, sizeof(*hdr
));
2277 hdr
->opcode
= ISCSI_OP_SCSI_TMFUNC
| ISCSI_OP_IMMEDIATE
;
2278 hdr
->flags
= ISCSI_TM_FUNC_LOGICAL_UNIT_RESET
& ISCSI_FLAG_TM_FUNC_MASK
;
2279 hdr
->flags
|= ISCSI_FLAG_CMD_FINAL
;
2280 int_to_scsilun(sc
->device
->lun
, &hdr
->lun
);
2281 hdr
->rtt
= RESERVED_ITT
;
2284 int iscsi_eh_device_reset(struct scsi_cmnd
*sc
)
2286 struct iscsi_cls_session
*cls_session
;
2287 struct iscsi_session
*session
;
2288 struct iscsi_conn
*conn
;
2289 struct iscsi_tm
*hdr
;
2292 cls_session
= starget_to_session(scsi_target(sc
->device
));
2293 session
= cls_session
->dd_data
;
2295 ISCSI_DBG_EH(session
, "LU Reset [sc %p lun %llu]\n", sc
,
2298 mutex_lock(&session
->eh_mutex
);
2299 spin_lock_bh(&session
->frwd_lock
);
2301 * Just check if we are not logged in. We cannot check for
2302 * the phase because the reset could come from a ioctl.
2304 if (!session
->leadconn
|| session
->state
!= ISCSI_STATE_LOGGED_IN
)
2306 conn
= session
->leadconn
;
2308 /* only have one tmf outstanding at a time */
2309 if (conn
->tmf_state
!= TMF_INITIAL
)
2311 conn
->tmf_state
= TMF_QUEUED
;
2314 iscsi_prep_lun_reset_pdu(sc
, hdr
);
2316 if (iscsi_exec_task_mgmt_fn(conn
, hdr
, session
->age
,
2317 session
->lu_reset_timeout
)) {
2322 switch (conn
->tmf_state
) {
2326 spin_unlock_bh(&session
->frwd_lock
);
2327 iscsi_conn_failure(conn
, ISCSI_ERR_SCSI_EH_SESSION_RST
);
2330 conn
->tmf_state
= TMF_INITIAL
;
2335 spin_unlock_bh(&session
->frwd_lock
);
2337 iscsi_suspend_tx(conn
);
2339 spin_lock_bh(&session
->frwd_lock
);
2340 memset(hdr
, 0, sizeof(*hdr
));
2341 fail_scsi_tasks(conn
, sc
->device
->lun
, DID_ERROR
);
2342 conn
->tmf_state
= TMF_INITIAL
;
2343 spin_unlock_bh(&session
->frwd_lock
);
2345 iscsi_start_tx(conn
);
2349 spin_unlock_bh(&session
->frwd_lock
);
2351 ISCSI_DBG_EH(session
, "dev reset result = %s\n",
2352 rc
== SUCCESS
? "SUCCESS" : "FAILED");
2353 mutex_unlock(&session
->eh_mutex
);
2356 EXPORT_SYMBOL_GPL(iscsi_eh_device_reset
);
2358 void iscsi_session_recovery_timedout(struct iscsi_cls_session
*cls_session
)
2360 struct iscsi_session
*session
= cls_session
->dd_data
;
2362 spin_lock_bh(&session
->frwd_lock
);
2363 if (session
->state
!= ISCSI_STATE_LOGGED_IN
) {
2364 session
->state
= ISCSI_STATE_RECOVERY_FAILED
;
2365 if (session
->leadconn
)
2366 wake_up(&session
->leadconn
->ehwait
);
2368 spin_unlock_bh(&session
->frwd_lock
);
2370 EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout
);
2373 * iscsi_eh_session_reset - drop session and attempt relogin
2376 * This function will wait for a relogin, session termination from
2377 * userspace, or a recovery/replacement timeout.
2379 int iscsi_eh_session_reset(struct scsi_cmnd
*sc
)
2381 struct iscsi_cls_session
*cls_session
;
2382 struct iscsi_session
*session
;
2383 struct iscsi_conn
*conn
;
2385 cls_session
= starget_to_session(scsi_target(sc
->device
));
2386 session
= cls_session
->dd_data
;
2387 conn
= session
->leadconn
;
2389 mutex_lock(&session
->eh_mutex
);
2390 spin_lock_bh(&session
->frwd_lock
);
2391 if (session
->state
== ISCSI_STATE_TERMINATE
) {
2393 ISCSI_DBG_EH(session
,
2394 "failing session reset: Could not log back into "
2395 "%s, %s [age %d]\n", session
->targetname
,
2396 conn
->persistent_address
, session
->age
);
2397 spin_unlock_bh(&session
->frwd_lock
);
2398 mutex_unlock(&session
->eh_mutex
);
2402 spin_unlock_bh(&session
->frwd_lock
);
2403 mutex_unlock(&session
->eh_mutex
);
2405 * we drop the lock here but the leadconn cannot be destoyed while
2406 * we are in the scsi eh
2408 iscsi_conn_failure(conn
, ISCSI_ERR_SCSI_EH_SESSION_RST
);
2410 ISCSI_DBG_EH(session
, "wait for relogin\n");
2411 wait_event_interruptible(conn
->ehwait
,
2412 session
->state
== ISCSI_STATE_TERMINATE
||
2413 session
->state
== ISCSI_STATE_LOGGED_IN
||
2414 session
->state
== ISCSI_STATE_RECOVERY_FAILED
);
2415 if (signal_pending(current
))
2416 flush_signals(current
);
2418 mutex_lock(&session
->eh_mutex
);
2419 spin_lock_bh(&session
->frwd_lock
);
2420 if (session
->state
== ISCSI_STATE_LOGGED_IN
) {
2421 ISCSI_DBG_EH(session
,
2422 "session reset succeeded for %s,%s\n",
2423 session
->targetname
, conn
->persistent_address
);
2426 spin_unlock_bh(&session
->frwd_lock
);
2427 mutex_unlock(&session
->eh_mutex
);
2430 EXPORT_SYMBOL_GPL(iscsi_eh_session_reset
);
2432 static void iscsi_prep_tgt_reset_pdu(struct scsi_cmnd
*sc
, struct iscsi_tm
*hdr
)
2434 memset(hdr
, 0, sizeof(*hdr
));
2435 hdr
->opcode
= ISCSI_OP_SCSI_TMFUNC
| ISCSI_OP_IMMEDIATE
;
2436 hdr
->flags
= ISCSI_TM_FUNC_TARGET_WARM_RESET
& ISCSI_FLAG_TM_FUNC_MASK
;
2437 hdr
->flags
|= ISCSI_FLAG_CMD_FINAL
;
2438 hdr
->rtt
= RESERVED_ITT
;
2442 * iscsi_eh_target_reset - reset target
2445 * This will attempt to send a warm target reset.
2447 static int iscsi_eh_target_reset(struct scsi_cmnd
*sc
)
2449 struct iscsi_cls_session
*cls_session
;
2450 struct iscsi_session
*session
;
2451 struct iscsi_conn
*conn
;
2452 struct iscsi_tm
*hdr
;
2455 cls_session
= starget_to_session(scsi_target(sc
->device
));
2456 session
= cls_session
->dd_data
;
2458 ISCSI_DBG_EH(session
, "tgt Reset [sc %p tgt %s]\n", sc
,
2459 session
->targetname
);
2461 mutex_lock(&session
->eh_mutex
);
2462 spin_lock_bh(&session
->frwd_lock
);
2464 * Just check if we are not logged in. We cannot check for
2465 * the phase because the reset could come from a ioctl.
2467 if (!session
->leadconn
|| session
->state
!= ISCSI_STATE_LOGGED_IN
)
2469 conn
= session
->leadconn
;
2471 /* only have one tmf outstanding at a time */
2472 if (conn
->tmf_state
!= TMF_INITIAL
)
2474 conn
->tmf_state
= TMF_QUEUED
;
2477 iscsi_prep_tgt_reset_pdu(sc
, hdr
);
2479 if (iscsi_exec_task_mgmt_fn(conn
, hdr
, session
->age
,
2480 session
->tgt_reset_timeout
)) {
2485 switch (conn
->tmf_state
) {
2489 spin_unlock_bh(&session
->frwd_lock
);
2490 iscsi_conn_failure(conn
, ISCSI_ERR_SCSI_EH_SESSION_RST
);
2493 conn
->tmf_state
= TMF_INITIAL
;
2498 spin_unlock_bh(&session
->frwd_lock
);
2500 iscsi_suspend_tx(conn
);
2502 spin_lock_bh(&session
->frwd_lock
);
2503 memset(hdr
, 0, sizeof(*hdr
));
2504 fail_scsi_tasks(conn
, -1, DID_ERROR
);
2505 conn
->tmf_state
= TMF_INITIAL
;
2506 spin_unlock_bh(&session
->frwd_lock
);
2508 iscsi_start_tx(conn
);
2512 spin_unlock_bh(&session
->frwd_lock
);
2514 ISCSI_DBG_EH(session
, "tgt %s reset result = %s\n", session
->targetname
,
2515 rc
== SUCCESS
? "SUCCESS" : "FAILED");
2516 mutex_unlock(&session
->eh_mutex
);
2521 * iscsi_eh_recover_target - reset target and possibly the session
2524 * This will attempt to send a warm target reset. If that fails,
2525 * we will escalate to ERL0 session recovery.
2527 int iscsi_eh_recover_target(struct scsi_cmnd
*sc
)
2531 rc
= iscsi_eh_target_reset(sc
);
2533 rc
= iscsi_eh_session_reset(sc
);
2536 EXPORT_SYMBOL_GPL(iscsi_eh_recover_target
);
2539 * Pre-allocate a pool of @max items of @item_size. By default, the pool
2540 * should be accessed via kfifo_{get,put} on q->queue.
2541 * Optionally, the caller can obtain the array of object pointers
2542 * by passing in a non-NULL @items pointer
2545 iscsi_pool_init(struct iscsi_pool
*q
, int max
, void ***items
, int item_size
)
2547 int i
, num_arrays
= 1;
2549 memset(q
, 0, sizeof(*q
));
2553 /* If the user passed an items pointer, he wants a copy of
2557 q
->pool
= kzalloc(num_arrays
* max
* sizeof(void*), GFP_KERNEL
);
2558 if (q
->pool
== NULL
)
2561 kfifo_init(&q
->queue
, (void*)q
->pool
, max
* sizeof(void*));
2563 for (i
= 0; i
< max
; i
++) {
2564 q
->pool
[i
] = kzalloc(item_size
, GFP_KERNEL
);
2565 if (q
->pool
[i
] == NULL
) {
2569 kfifo_in(&q
->queue
, (void*)&q
->pool
[i
], sizeof(void*));
2573 *items
= q
->pool
+ max
;
2574 memcpy(*items
, q
->pool
, max
* sizeof(void *));
2583 EXPORT_SYMBOL_GPL(iscsi_pool_init
);
2585 void iscsi_pool_free(struct iscsi_pool
*q
)
2589 for (i
= 0; i
< q
->max
; i
++)
2593 EXPORT_SYMBOL_GPL(iscsi_pool_free
);
2596 * iscsi_host_add - add host to system
2598 * @pdev: parent device
2600 * This should be called by partial offload and software iscsi drivers
2601 * to add a host to the system.
2603 int iscsi_host_add(struct Scsi_Host
*shost
, struct device
*pdev
)
2605 if (!shost
->can_queue
)
2606 shost
->can_queue
= ISCSI_DEF_XMIT_CMDS_MAX
;
2608 if (!shost
->cmd_per_lun
)
2609 shost
->cmd_per_lun
= ISCSI_DEF_CMD_PER_LUN
;
2611 if (!shost
->transportt
->eh_timed_out
)
2612 shost
->transportt
->eh_timed_out
= iscsi_eh_cmd_timed_out
;
2613 return scsi_add_host(shost
, pdev
);
2615 EXPORT_SYMBOL_GPL(iscsi_host_add
);
2618 * iscsi_host_alloc - allocate a host and driver data
2619 * @sht: scsi host template
2620 * @dd_data_size: driver host data size
2621 * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue
2623 * This should be called by partial offload and software iscsi drivers.
2624 * To access the driver specific memory use the iscsi_host_priv() macro.
2626 struct Scsi_Host
*iscsi_host_alloc(struct scsi_host_template
*sht
,
2627 int dd_data_size
, bool xmit_can_sleep
)
2629 struct Scsi_Host
*shost
;
2630 struct iscsi_host
*ihost
;
2632 shost
= scsi_host_alloc(sht
, sizeof(struct iscsi_host
) + dd_data_size
);
2635 ihost
= shost_priv(shost
);
2637 if (xmit_can_sleep
) {
2638 snprintf(ihost
->workq_name
, sizeof(ihost
->workq_name
),
2639 "iscsi_q_%d", shost
->host_no
);
2640 ihost
->workq
= create_singlethread_workqueue(ihost
->workq_name
);
2645 spin_lock_init(&ihost
->lock
);
2646 ihost
->state
= ISCSI_HOST_SETUP
;
2647 ihost
->num_sessions
= 0;
2648 init_waitqueue_head(&ihost
->session_removal_wq
);
2652 scsi_host_put(shost
);
2655 EXPORT_SYMBOL_GPL(iscsi_host_alloc
);
2657 static void iscsi_notify_host_removed(struct iscsi_cls_session
*cls_session
)
2659 iscsi_session_failure(cls_session
->dd_data
, ISCSI_ERR_INVALID_HOST
);
2663 * iscsi_host_remove - remove host and sessions
2666 * If there are any sessions left, this will initiate the removal and wait
2667 * for the completion.
2669 void iscsi_host_remove(struct Scsi_Host
*shost
)
2671 struct iscsi_host
*ihost
= shost_priv(shost
);
2672 unsigned long flags
;
2674 spin_lock_irqsave(&ihost
->lock
, flags
);
2675 ihost
->state
= ISCSI_HOST_REMOVED
;
2676 spin_unlock_irqrestore(&ihost
->lock
, flags
);
2678 iscsi_host_for_each_session(shost
, iscsi_notify_host_removed
);
2679 wait_event_interruptible(ihost
->session_removal_wq
,
2680 ihost
->num_sessions
== 0);
2681 if (signal_pending(current
))
2682 flush_signals(current
);
2684 scsi_remove_host(shost
);
2686 destroy_workqueue(ihost
->workq
);
2688 EXPORT_SYMBOL_GPL(iscsi_host_remove
);
2690 void iscsi_host_free(struct Scsi_Host
*shost
)
2692 struct iscsi_host
*ihost
= shost_priv(shost
);
2694 kfree(ihost
->netdev
);
2695 kfree(ihost
->hwaddress
);
2696 kfree(ihost
->initiatorname
);
2697 scsi_host_put(shost
);
2699 EXPORT_SYMBOL_GPL(iscsi_host_free
);
2701 static void iscsi_host_dec_session_cnt(struct Scsi_Host
*shost
)
2703 struct iscsi_host
*ihost
= shost_priv(shost
);
2704 unsigned long flags
;
2706 shost
= scsi_host_get(shost
);
2708 printk(KERN_ERR
"Invalid state. Cannot notify host removal "
2709 "of session teardown event because host already "
2714 spin_lock_irqsave(&ihost
->lock
, flags
);
2715 ihost
->num_sessions
--;
2716 if (ihost
->num_sessions
== 0)
2717 wake_up(&ihost
->session_removal_wq
);
2718 spin_unlock_irqrestore(&ihost
->lock
, flags
);
2719 scsi_host_put(shost
);
2723 * iscsi_session_setup - create iscsi cls session and host and session
2724 * @iscsit: iscsi transport template
2726 * @cmds_max: session can queue
2727 * @cmd_task_size: LLD task private data size
2728 * @initial_cmdsn: initial CmdSN
2730 * This can be used by software iscsi_transports that allocate
2731 * a session per scsi host.
2733 * Callers should set cmds_max to the largest total numer (mgmt + scsi) of
2734 * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks
2735 * for nop handling and login/logout requests.
2737 struct iscsi_cls_session
*
2738 iscsi_session_setup(struct iscsi_transport
*iscsit
, struct Scsi_Host
*shost
,
2739 uint16_t cmds_max
, int dd_size
, int cmd_task_size
,
2740 uint32_t initial_cmdsn
, unsigned int id
)
2742 struct iscsi_host
*ihost
= shost_priv(shost
);
2743 struct iscsi_session
*session
;
2744 struct iscsi_cls_session
*cls_session
;
2745 int cmd_i
, scsi_cmds
, total_cmds
= cmds_max
;
2746 unsigned long flags
;
2748 spin_lock_irqsave(&ihost
->lock
, flags
);
2749 if (ihost
->state
== ISCSI_HOST_REMOVED
) {
2750 spin_unlock_irqrestore(&ihost
->lock
, flags
);
2753 ihost
->num_sessions
++;
2754 spin_unlock_irqrestore(&ihost
->lock
, flags
);
2757 total_cmds
= ISCSI_DEF_XMIT_CMDS_MAX
;
2759 * The iscsi layer needs some tasks for nop handling and tmfs,
2760 * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX
2761 * + 1 command for scsi IO.
2763 if (total_cmds
< ISCSI_TOTAL_CMDS_MIN
) {
2764 printk(KERN_ERR
"iscsi: invalid can_queue of %d. can_queue "
2765 "must be a power of two that is at least %d.\n",
2766 total_cmds
, ISCSI_TOTAL_CMDS_MIN
);
2767 goto dec_session_count
;
2770 if (total_cmds
> ISCSI_TOTAL_CMDS_MAX
) {
2771 printk(KERN_ERR
"iscsi: invalid can_queue of %d. can_queue "
2772 "must be a power of 2 less than or equal to %d.\n",
2773 cmds_max
, ISCSI_TOTAL_CMDS_MAX
);
2774 total_cmds
= ISCSI_TOTAL_CMDS_MAX
;
2777 if (!is_power_of_2(total_cmds
)) {
2778 printk(KERN_ERR
"iscsi: invalid can_queue of %d. can_queue "
2779 "must be a power of 2.\n", total_cmds
);
2780 total_cmds
= rounddown_pow_of_two(total_cmds
);
2781 if (total_cmds
< ISCSI_TOTAL_CMDS_MIN
)
2783 printk(KERN_INFO
"iscsi: Rounding can_queue to %d.\n",
2786 scsi_cmds
= total_cmds
- ISCSI_MGMT_CMDS_MAX
;
2788 cls_session
= iscsi_alloc_session(shost
, iscsit
,
2789 sizeof(struct iscsi_session
) +
2792 goto dec_session_count
;
2793 session
= cls_session
->dd_data
;
2794 session
->cls_session
= cls_session
;
2795 session
->host
= shost
;
2796 session
->state
= ISCSI_STATE_FREE
;
2797 session
->fast_abort
= 1;
2798 session
->tgt_reset_timeout
= 30;
2799 session
->lu_reset_timeout
= 15;
2800 session
->abort_timeout
= 10;
2801 session
->scsi_cmds_max
= scsi_cmds
;
2802 session
->cmds_max
= total_cmds
;
2803 session
->queued_cmdsn
= session
->cmdsn
= initial_cmdsn
;
2804 session
->exp_cmdsn
= initial_cmdsn
+ 1;
2805 session
->max_cmdsn
= initial_cmdsn
+ 1;
2806 session
->max_r2t
= 1;
2807 session
->tt
= iscsit
;
2808 session
->dd_data
= cls_session
->dd_data
+ sizeof(*session
);
2810 mutex_init(&session
->eh_mutex
);
2811 spin_lock_init(&session
->frwd_lock
);
2812 spin_lock_init(&session
->back_lock
);
2814 /* initialize SCSI PDU commands pool */
2815 if (iscsi_pool_init(&session
->cmdpool
, session
->cmds_max
,
2816 (void***)&session
->cmds
,
2817 cmd_task_size
+ sizeof(struct iscsi_task
)))
2818 goto cmdpool_alloc_fail
;
2820 /* pre-format cmds pool with ITT */
2821 for (cmd_i
= 0; cmd_i
< session
->cmds_max
; cmd_i
++) {
2822 struct iscsi_task
*task
= session
->cmds
[cmd_i
];
2825 task
->dd_data
= &task
[1];
2827 task
->state
= ISCSI_TASK_FREE
;
2828 INIT_LIST_HEAD(&task
->running
);
2831 if (!try_module_get(iscsit
->owner
))
2832 goto module_get_fail
;
2834 if (iscsi_add_session(cls_session
, id
))
2835 goto cls_session_fail
;
2840 module_put(iscsit
->owner
);
2842 iscsi_pool_free(&session
->cmdpool
);
2844 iscsi_free_session(cls_session
);
2846 iscsi_host_dec_session_cnt(shost
);
2849 EXPORT_SYMBOL_GPL(iscsi_session_setup
);
2852 * iscsi_session_teardown - destroy session, host, and cls_session
2853 * @cls_session: iscsi session
2855 * The driver must have called iscsi_remove_session before
2858 void iscsi_session_teardown(struct iscsi_cls_session
*cls_session
)
2860 struct iscsi_session
*session
= cls_session
->dd_data
;
2861 struct module
*owner
= cls_session
->transport
->owner
;
2862 struct Scsi_Host
*shost
= session
->host
;
2864 iscsi_pool_free(&session
->cmdpool
);
2866 kfree(session
->password
);
2867 kfree(session
->password_in
);
2868 kfree(session
->username
);
2869 kfree(session
->username_in
);
2870 kfree(session
->targetname
);
2871 kfree(session
->targetalias
);
2872 kfree(session
->initiatorname
);
2873 kfree(session
->boot_root
);
2874 kfree(session
->boot_nic
);
2875 kfree(session
->boot_target
);
2876 kfree(session
->ifacename
);
2877 kfree(session
->portal_type
);
2878 kfree(session
->discovery_parent_type
);
2880 iscsi_destroy_session(cls_session
);
2881 iscsi_host_dec_session_cnt(shost
);
2884 EXPORT_SYMBOL_GPL(iscsi_session_teardown
);
2887 * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn
2888 * @cls_session: iscsi_cls_session
2889 * @dd_size: private driver data size
2892 struct iscsi_cls_conn
*
2893 iscsi_conn_setup(struct iscsi_cls_session
*cls_session
, int dd_size
,
2896 struct iscsi_session
*session
= cls_session
->dd_data
;
2897 struct iscsi_conn
*conn
;
2898 struct iscsi_cls_conn
*cls_conn
;
2901 cls_conn
= iscsi_create_conn(cls_session
, sizeof(*conn
) + dd_size
,
2905 conn
= cls_conn
->dd_data
;
2906 memset(conn
, 0, sizeof(*conn
) + dd_size
);
2908 conn
->dd_data
= cls_conn
->dd_data
+ sizeof(*conn
);
2909 conn
->session
= session
;
2910 conn
->cls_conn
= cls_conn
;
2911 conn
->c_stage
= ISCSI_CONN_INITIAL_STAGE
;
2912 conn
->id
= conn_idx
;
2913 conn
->exp_statsn
= 0;
2914 conn
->tmf_state
= TMF_INITIAL
;
2916 init_timer(&conn
->transport_timer
);
2917 conn
->transport_timer
.data
= (unsigned long)conn
;
2918 conn
->transport_timer
.function
= iscsi_check_transport_timeouts
;
2920 INIT_LIST_HEAD(&conn
->mgmtqueue
);
2921 INIT_LIST_HEAD(&conn
->cmdqueue
);
2922 INIT_LIST_HEAD(&conn
->requeue
);
2923 spin_lock_init(&conn
->taskqueuelock
);
2924 INIT_WORK(&conn
->xmitwork
, iscsi_xmitworker
);
2926 /* allocate login_task used for the login/text sequences */
2927 spin_lock_bh(&session
->frwd_lock
);
2928 if (!kfifo_out(&session
->cmdpool
.queue
,
2929 (void*)&conn
->login_task
,
2931 spin_unlock_bh(&session
->frwd_lock
);
2932 goto login_task_alloc_fail
;
2934 spin_unlock_bh(&session
->frwd_lock
);
2936 data
= (char *) __get_free_pages(GFP_KERNEL
,
2937 get_order(ISCSI_DEF_MAX_RECV_SEG_LEN
));
2939 goto login_task_data_alloc_fail
;
2940 conn
->login_task
->data
= conn
->data
= data
;
2942 init_timer(&conn
->tmf_timer
);
2943 init_waitqueue_head(&conn
->ehwait
);
2947 login_task_data_alloc_fail
:
2948 kfifo_in(&session
->cmdpool
.queue
, (void*)&conn
->login_task
,
2950 login_task_alloc_fail
:
2951 iscsi_destroy_conn(cls_conn
);
2954 EXPORT_SYMBOL_GPL(iscsi_conn_setup
);
2957 * iscsi_conn_teardown - teardown iscsi connection
2958 * cls_conn: iscsi class connection
2960 * TODO: we may need to make this into a two step process
2961 * like scsi-mls remove + put host
2963 void iscsi_conn_teardown(struct iscsi_cls_conn
*cls_conn
)
2965 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
2966 struct iscsi_session
*session
= conn
->session
;
2968 del_timer_sync(&conn
->transport_timer
);
2970 mutex_lock(&session
->eh_mutex
);
2971 spin_lock_bh(&session
->frwd_lock
);
2972 conn
->c_stage
= ISCSI_CONN_CLEANUP_WAIT
;
2973 if (session
->leadconn
== conn
) {
2975 * leading connection? then give up on recovery.
2977 session
->state
= ISCSI_STATE_TERMINATE
;
2978 wake_up(&conn
->ehwait
);
2980 spin_unlock_bh(&session
->frwd_lock
);
2982 /* flush queued up work because we free the connection below */
2983 iscsi_suspend_tx(conn
);
2985 spin_lock_bh(&session
->frwd_lock
);
2986 free_pages((unsigned long) conn
->data
,
2987 get_order(ISCSI_DEF_MAX_RECV_SEG_LEN
));
2988 kfree(conn
->persistent_address
);
2989 kfree(conn
->local_ipaddr
);
2990 /* regular RX path uses back_lock */
2991 spin_lock_bh(&session
->back_lock
);
2992 kfifo_in(&session
->cmdpool
.queue
, (void*)&conn
->login_task
,
2994 spin_unlock_bh(&session
->back_lock
);
2995 if (session
->leadconn
== conn
)
2996 session
->leadconn
= NULL
;
2997 spin_unlock_bh(&session
->frwd_lock
);
2998 mutex_unlock(&session
->eh_mutex
);
3000 iscsi_destroy_conn(cls_conn
);
3002 EXPORT_SYMBOL_GPL(iscsi_conn_teardown
);
3004 int iscsi_conn_start(struct iscsi_cls_conn
*cls_conn
)
3006 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
3007 struct iscsi_session
*session
= conn
->session
;
3010 iscsi_conn_printk(KERN_ERR
, conn
,
3011 "can't start unbound connection\n");
3015 if ((session
->imm_data_en
|| !session
->initial_r2t_en
) &&
3016 session
->first_burst
> session
->max_burst
) {
3017 iscsi_conn_printk(KERN_INFO
, conn
, "invalid burst lengths: "
3018 "first_burst %d max_burst %d\n",
3019 session
->first_burst
, session
->max_burst
);
3023 if (conn
->ping_timeout
&& !conn
->recv_timeout
) {
3024 iscsi_conn_printk(KERN_ERR
, conn
, "invalid recv timeout of "
3025 "zero. Using 5 seconds\n.");
3026 conn
->recv_timeout
= 5;
3029 if (conn
->recv_timeout
&& !conn
->ping_timeout
) {
3030 iscsi_conn_printk(KERN_ERR
, conn
, "invalid ping timeout of "
3031 "zero. Using 5 seconds.\n");
3032 conn
->ping_timeout
= 5;
3035 spin_lock_bh(&session
->frwd_lock
);
3036 conn
->c_stage
= ISCSI_CONN_STARTED
;
3037 session
->state
= ISCSI_STATE_LOGGED_IN
;
3038 session
->queued_cmdsn
= session
->cmdsn
;
3040 conn
->last_recv
= jiffies
;
3041 conn
->last_ping
= jiffies
;
3042 if (conn
->recv_timeout
&& conn
->ping_timeout
)
3043 mod_timer(&conn
->transport_timer
,
3044 jiffies
+ (conn
->recv_timeout
* HZ
));
3046 switch(conn
->stop_stage
) {
3047 case STOP_CONN_RECOVER
:
3049 * unblock eh_abort() if it is blocked. re-try all
3050 * commands after successful recovery
3052 conn
->stop_stage
= 0;
3053 conn
->tmf_state
= TMF_INITIAL
;
3055 if (session
->age
== 16)
3058 case STOP_CONN_TERM
:
3059 conn
->stop_stage
= 0;
3064 spin_unlock_bh(&session
->frwd_lock
);
3066 iscsi_unblock_session(session
->cls_session
);
3067 wake_up(&conn
->ehwait
);
3070 EXPORT_SYMBOL_GPL(iscsi_conn_start
);
3073 fail_mgmt_tasks(struct iscsi_session
*session
, struct iscsi_conn
*conn
)
3075 struct iscsi_task
*task
;
3078 for (i
= 0; i
< conn
->session
->cmds_max
; i
++) {
3079 task
= conn
->session
->cmds
[i
];
3083 if (task
->state
== ISCSI_TASK_FREE
)
3086 ISCSI_DBG_SESSION(conn
->session
,
3087 "failing mgmt itt 0x%x state %d\n",
3088 task
->itt
, task
->state
);
3089 state
= ISCSI_TASK_ABRT_SESS_RECOV
;
3090 if (task
->state
== ISCSI_TASK_PENDING
)
3091 state
= ISCSI_TASK_COMPLETED
;
3092 iscsi_complete_task(task
, state
);
3097 static void iscsi_start_session_recovery(struct iscsi_session
*session
,
3098 struct iscsi_conn
*conn
, int flag
)
3102 mutex_lock(&session
->eh_mutex
);
3103 spin_lock_bh(&session
->frwd_lock
);
3104 if (conn
->stop_stage
== STOP_CONN_TERM
) {
3105 spin_unlock_bh(&session
->frwd_lock
);
3106 mutex_unlock(&session
->eh_mutex
);
3111 * When this is called for the in_login state, we only want to clean
3112 * up the login task and connection. We do not need to block and set
3113 * the recovery state again
3115 if (flag
== STOP_CONN_TERM
)
3116 session
->state
= ISCSI_STATE_TERMINATE
;
3117 else if (conn
->stop_stage
!= STOP_CONN_RECOVER
)
3118 session
->state
= ISCSI_STATE_IN_RECOVERY
;
3120 old_stop_stage
= conn
->stop_stage
;
3121 conn
->stop_stage
= flag
;
3122 spin_unlock_bh(&session
->frwd_lock
);
3124 del_timer_sync(&conn
->transport_timer
);
3125 iscsi_suspend_tx(conn
);
3127 spin_lock_bh(&session
->frwd_lock
);
3128 conn
->c_stage
= ISCSI_CONN_STOPPED
;
3129 spin_unlock_bh(&session
->frwd_lock
);
3132 * for connection level recovery we should not calculate
3133 * header digest. conn->hdr_size used for optimization
3134 * in hdr_extract() and will be re-negotiated at
3137 if (flag
== STOP_CONN_RECOVER
) {
3138 conn
->hdrdgst_en
= 0;
3139 conn
->datadgst_en
= 0;
3140 if (session
->state
== ISCSI_STATE_IN_RECOVERY
&&
3141 old_stop_stage
!= STOP_CONN_RECOVER
) {
3142 ISCSI_DBG_SESSION(session
, "blocking session\n");
3143 iscsi_block_session(session
->cls_session
);
3150 spin_lock_bh(&session
->frwd_lock
);
3151 fail_scsi_tasks(conn
, -1, DID_TRANSPORT_DISRUPTED
);
3152 fail_mgmt_tasks(session
, conn
);
3153 memset(&conn
->tmhdr
, 0, sizeof(conn
->tmhdr
));
3154 spin_unlock_bh(&session
->frwd_lock
);
3155 mutex_unlock(&session
->eh_mutex
);
3158 void iscsi_conn_stop(struct iscsi_cls_conn
*cls_conn
, int flag
)
3160 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
3161 struct iscsi_session
*session
= conn
->session
;
3164 case STOP_CONN_RECOVER
:
3165 case STOP_CONN_TERM
:
3166 iscsi_start_session_recovery(session
, conn
, flag
);
3169 iscsi_conn_printk(KERN_ERR
, conn
,
3170 "invalid stop flag %d\n", flag
);
3173 EXPORT_SYMBOL_GPL(iscsi_conn_stop
);
3175 int iscsi_conn_bind(struct iscsi_cls_session
*cls_session
,
3176 struct iscsi_cls_conn
*cls_conn
, int is_leading
)
3178 struct iscsi_session
*session
= cls_session
->dd_data
;
3179 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
3181 spin_lock_bh(&session
->frwd_lock
);
3183 session
->leadconn
= conn
;
3184 spin_unlock_bh(&session
->frwd_lock
);
3187 * Unblock xmitworker(), Login Phase will pass through.
3189 clear_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_rx
);
3190 clear_bit(ISCSI_SUSPEND_BIT
, &conn
->suspend_tx
);
3193 EXPORT_SYMBOL_GPL(iscsi_conn_bind
);
3195 int iscsi_switch_str_param(char **param
, char *new_val_buf
)
3200 if (!strcmp(*param
, new_val_buf
))
3204 new_val
= kstrdup(new_val_buf
, GFP_NOIO
);
3212 EXPORT_SYMBOL_GPL(iscsi_switch_str_param
);
3214 int iscsi_set_param(struct iscsi_cls_conn
*cls_conn
,
3215 enum iscsi_param param
, char *buf
, int buflen
)
3217 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
3218 struct iscsi_session
*session
= conn
->session
;
3222 case ISCSI_PARAM_FAST_ABORT
:
3223 sscanf(buf
, "%d", &session
->fast_abort
);
3225 case ISCSI_PARAM_ABORT_TMO
:
3226 sscanf(buf
, "%d", &session
->abort_timeout
);
3228 case ISCSI_PARAM_LU_RESET_TMO
:
3229 sscanf(buf
, "%d", &session
->lu_reset_timeout
);
3231 case ISCSI_PARAM_TGT_RESET_TMO
:
3232 sscanf(buf
, "%d", &session
->tgt_reset_timeout
);
3234 case ISCSI_PARAM_PING_TMO
:
3235 sscanf(buf
, "%d", &conn
->ping_timeout
);
3237 case ISCSI_PARAM_RECV_TMO
:
3238 sscanf(buf
, "%d", &conn
->recv_timeout
);
3240 case ISCSI_PARAM_MAX_RECV_DLENGTH
:
3241 sscanf(buf
, "%d", &conn
->max_recv_dlength
);
3243 case ISCSI_PARAM_MAX_XMIT_DLENGTH
:
3244 sscanf(buf
, "%d", &conn
->max_xmit_dlength
);
3246 case ISCSI_PARAM_HDRDGST_EN
:
3247 sscanf(buf
, "%d", &conn
->hdrdgst_en
);
3249 case ISCSI_PARAM_DATADGST_EN
:
3250 sscanf(buf
, "%d", &conn
->datadgst_en
);
3252 case ISCSI_PARAM_INITIAL_R2T_EN
:
3253 sscanf(buf
, "%d", &session
->initial_r2t_en
);
3255 case ISCSI_PARAM_MAX_R2T
:
3256 sscanf(buf
, "%hu", &session
->max_r2t
);
3258 case ISCSI_PARAM_IMM_DATA_EN
:
3259 sscanf(buf
, "%d", &session
->imm_data_en
);
3261 case ISCSI_PARAM_FIRST_BURST
:
3262 sscanf(buf
, "%d", &session
->first_burst
);
3264 case ISCSI_PARAM_MAX_BURST
:
3265 sscanf(buf
, "%d", &session
->max_burst
);
3267 case ISCSI_PARAM_PDU_INORDER_EN
:
3268 sscanf(buf
, "%d", &session
->pdu_inorder_en
);
3270 case ISCSI_PARAM_DATASEQ_INORDER_EN
:
3271 sscanf(buf
, "%d", &session
->dataseq_inorder_en
);
3273 case ISCSI_PARAM_ERL
:
3274 sscanf(buf
, "%d", &session
->erl
);
3276 case ISCSI_PARAM_EXP_STATSN
:
3277 sscanf(buf
, "%u", &conn
->exp_statsn
);
3279 case ISCSI_PARAM_USERNAME
:
3280 return iscsi_switch_str_param(&session
->username
, buf
);
3281 case ISCSI_PARAM_USERNAME_IN
:
3282 return iscsi_switch_str_param(&session
->username_in
, buf
);
3283 case ISCSI_PARAM_PASSWORD
:
3284 return iscsi_switch_str_param(&session
->password
, buf
);
3285 case ISCSI_PARAM_PASSWORD_IN
:
3286 return iscsi_switch_str_param(&session
->password_in
, buf
);
3287 case ISCSI_PARAM_TARGET_NAME
:
3288 return iscsi_switch_str_param(&session
->targetname
, buf
);
3289 case ISCSI_PARAM_TARGET_ALIAS
:
3290 return iscsi_switch_str_param(&session
->targetalias
, buf
);
3291 case ISCSI_PARAM_TPGT
:
3292 sscanf(buf
, "%d", &session
->tpgt
);
3294 case ISCSI_PARAM_PERSISTENT_PORT
:
3295 sscanf(buf
, "%d", &conn
->persistent_port
);
3297 case ISCSI_PARAM_PERSISTENT_ADDRESS
:
3298 return iscsi_switch_str_param(&conn
->persistent_address
, buf
);
3299 case ISCSI_PARAM_IFACE_NAME
:
3300 return iscsi_switch_str_param(&session
->ifacename
, buf
);
3301 case ISCSI_PARAM_INITIATOR_NAME
:
3302 return iscsi_switch_str_param(&session
->initiatorname
, buf
);
3303 case ISCSI_PARAM_BOOT_ROOT
:
3304 return iscsi_switch_str_param(&session
->boot_root
, buf
);
3305 case ISCSI_PARAM_BOOT_NIC
:
3306 return iscsi_switch_str_param(&session
->boot_nic
, buf
);
3307 case ISCSI_PARAM_BOOT_TARGET
:
3308 return iscsi_switch_str_param(&session
->boot_target
, buf
);
3309 case ISCSI_PARAM_PORTAL_TYPE
:
3310 return iscsi_switch_str_param(&session
->portal_type
, buf
);
3311 case ISCSI_PARAM_DISCOVERY_PARENT_TYPE
:
3312 return iscsi_switch_str_param(&session
->discovery_parent_type
,
3314 case ISCSI_PARAM_DISCOVERY_SESS
:
3315 sscanf(buf
, "%d", &val
);
3316 session
->discovery_sess
= !!val
;
3318 case ISCSI_PARAM_LOCAL_IPADDR
:
3319 return iscsi_switch_str_param(&conn
->local_ipaddr
, buf
);
3326 EXPORT_SYMBOL_GPL(iscsi_set_param
);
3328 int iscsi_session_get_param(struct iscsi_cls_session
*cls_session
,
3329 enum iscsi_param param
, char *buf
)
3331 struct iscsi_session
*session
= cls_session
->dd_data
;
3335 case ISCSI_PARAM_FAST_ABORT
:
3336 len
= sprintf(buf
, "%d\n", session
->fast_abort
);
3338 case ISCSI_PARAM_ABORT_TMO
:
3339 len
= sprintf(buf
, "%d\n", session
->abort_timeout
);
3341 case ISCSI_PARAM_LU_RESET_TMO
:
3342 len
= sprintf(buf
, "%d\n", session
->lu_reset_timeout
);
3344 case ISCSI_PARAM_TGT_RESET_TMO
:
3345 len
= sprintf(buf
, "%d\n", session
->tgt_reset_timeout
);
3347 case ISCSI_PARAM_INITIAL_R2T_EN
:
3348 len
= sprintf(buf
, "%d\n", session
->initial_r2t_en
);
3350 case ISCSI_PARAM_MAX_R2T
:
3351 len
= sprintf(buf
, "%hu\n", session
->max_r2t
);
3353 case ISCSI_PARAM_IMM_DATA_EN
:
3354 len
= sprintf(buf
, "%d\n", session
->imm_data_en
);
3356 case ISCSI_PARAM_FIRST_BURST
:
3357 len
= sprintf(buf
, "%u\n", session
->first_burst
);
3359 case ISCSI_PARAM_MAX_BURST
:
3360 len
= sprintf(buf
, "%u\n", session
->max_burst
);
3362 case ISCSI_PARAM_PDU_INORDER_EN
:
3363 len
= sprintf(buf
, "%d\n", session
->pdu_inorder_en
);
3365 case ISCSI_PARAM_DATASEQ_INORDER_EN
:
3366 len
= sprintf(buf
, "%d\n", session
->dataseq_inorder_en
);
3368 case ISCSI_PARAM_DEF_TASKMGMT_TMO
:
3369 len
= sprintf(buf
, "%d\n", session
->def_taskmgmt_tmo
);
3371 case ISCSI_PARAM_ERL
:
3372 len
= sprintf(buf
, "%d\n", session
->erl
);
3374 case ISCSI_PARAM_TARGET_NAME
:
3375 len
= sprintf(buf
, "%s\n", session
->targetname
);
3377 case ISCSI_PARAM_TARGET_ALIAS
:
3378 len
= sprintf(buf
, "%s\n", session
->targetalias
);
3380 case ISCSI_PARAM_TPGT
:
3381 len
= sprintf(buf
, "%d\n", session
->tpgt
);
3383 case ISCSI_PARAM_USERNAME
:
3384 len
= sprintf(buf
, "%s\n", session
->username
);
3386 case ISCSI_PARAM_USERNAME_IN
:
3387 len
= sprintf(buf
, "%s\n", session
->username_in
);
3389 case ISCSI_PARAM_PASSWORD
:
3390 len
= sprintf(buf
, "%s\n", session
->password
);
3392 case ISCSI_PARAM_PASSWORD_IN
:
3393 len
= sprintf(buf
, "%s\n", session
->password_in
);
3395 case ISCSI_PARAM_IFACE_NAME
:
3396 len
= sprintf(buf
, "%s\n", session
->ifacename
);
3398 case ISCSI_PARAM_INITIATOR_NAME
:
3399 len
= sprintf(buf
, "%s\n", session
->initiatorname
);
3401 case ISCSI_PARAM_BOOT_ROOT
:
3402 len
= sprintf(buf
, "%s\n", session
->boot_root
);
3404 case ISCSI_PARAM_BOOT_NIC
:
3405 len
= sprintf(buf
, "%s\n", session
->boot_nic
);
3407 case ISCSI_PARAM_BOOT_TARGET
:
3408 len
= sprintf(buf
, "%s\n", session
->boot_target
);
3410 case ISCSI_PARAM_AUTO_SND_TGT_DISABLE
:
3411 len
= sprintf(buf
, "%u\n", session
->auto_snd_tgt_disable
);
3413 case ISCSI_PARAM_DISCOVERY_SESS
:
3414 len
= sprintf(buf
, "%u\n", session
->discovery_sess
);
3416 case ISCSI_PARAM_PORTAL_TYPE
:
3417 len
= sprintf(buf
, "%s\n", session
->portal_type
);
3419 case ISCSI_PARAM_CHAP_AUTH_EN
:
3420 len
= sprintf(buf
, "%u\n", session
->chap_auth_en
);
3422 case ISCSI_PARAM_DISCOVERY_LOGOUT_EN
:
3423 len
= sprintf(buf
, "%u\n", session
->discovery_logout_en
);
3425 case ISCSI_PARAM_BIDI_CHAP_EN
:
3426 len
= sprintf(buf
, "%u\n", session
->bidi_chap_en
);
3428 case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL
:
3429 len
= sprintf(buf
, "%u\n", session
->discovery_auth_optional
);
3431 case ISCSI_PARAM_DEF_TIME2WAIT
:
3432 len
= sprintf(buf
, "%d\n", session
->time2wait
);
3434 case ISCSI_PARAM_DEF_TIME2RETAIN
:
3435 len
= sprintf(buf
, "%d\n", session
->time2retain
);
3437 case ISCSI_PARAM_TSID
:
3438 len
= sprintf(buf
, "%u\n", session
->tsid
);
3440 case ISCSI_PARAM_ISID
:
3441 len
= sprintf(buf
, "%02x%02x%02x%02x%02x%02x\n",
3442 session
->isid
[0], session
->isid
[1],
3443 session
->isid
[2], session
->isid
[3],
3444 session
->isid
[4], session
->isid
[5]);
3446 case ISCSI_PARAM_DISCOVERY_PARENT_IDX
:
3447 len
= sprintf(buf
, "%u\n", session
->discovery_parent_idx
);
3449 case ISCSI_PARAM_DISCOVERY_PARENT_TYPE
:
3450 if (session
->discovery_parent_type
)
3451 len
= sprintf(buf
, "%s\n",
3452 session
->discovery_parent_type
);
3454 len
= sprintf(buf
, "\n");
3462 EXPORT_SYMBOL_GPL(iscsi_session_get_param
);
3464 int iscsi_conn_get_addr_param(struct sockaddr_storage
*addr
,
3465 enum iscsi_param param
, char *buf
)
3467 struct sockaddr_in6
*sin6
= NULL
;
3468 struct sockaddr_in
*sin
= NULL
;
3471 switch (addr
->ss_family
) {
3473 sin
= (struct sockaddr_in
*)addr
;
3476 sin6
= (struct sockaddr_in6
*)addr
;
3483 case ISCSI_PARAM_CONN_ADDRESS
:
3484 case ISCSI_HOST_PARAM_IPADDRESS
:
3486 len
= sprintf(buf
, "%pI4\n", &sin
->sin_addr
.s_addr
);
3488 len
= sprintf(buf
, "%pI6\n", &sin6
->sin6_addr
);
3490 case ISCSI_PARAM_CONN_PORT
:
3491 case ISCSI_PARAM_LOCAL_PORT
:
3493 len
= sprintf(buf
, "%hu\n", be16_to_cpu(sin
->sin_port
));
3495 len
= sprintf(buf
, "%hu\n",
3496 be16_to_cpu(sin6
->sin6_port
));
3504 EXPORT_SYMBOL_GPL(iscsi_conn_get_addr_param
);
3506 int iscsi_conn_get_param(struct iscsi_cls_conn
*cls_conn
,
3507 enum iscsi_param param
, char *buf
)
3509 struct iscsi_conn
*conn
= cls_conn
->dd_data
;
3513 case ISCSI_PARAM_PING_TMO
:
3514 len
= sprintf(buf
, "%u\n", conn
->ping_timeout
);
3516 case ISCSI_PARAM_RECV_TMO
:
3517 len
= sprintf(buf
, "%u\n", conn
->recv_timeout
);
3519 case ISCSI_PARAM_MAX_RECV_DLENGTH
:
3520 len
= sprintf(buf
, "%u\n", conn
->max_recv_dlength
);
3522 case ISCSI_PARAM_MAX_XMIT_DLENGTH
:
3523 len
= sprintf(buf
, "%u\n", conn
->max_xmit_dlength
);
3525 case ISCSI_PARAM_HDRDGST_EN
:
3526 len
= sprintf(buf
, "%d\n", conn
->hdrdgst_en
);
3528 case ISCSI_PARAM_DATADGST_EN
:
3529 len
= sprintf(buf
, "%d\n", conn
->datadgst_en
);
3531 case ISCSI_PARAM_IFMARKER_EN
:
3532 len
= sprintf(buf
, "%d\n", conn
->ifmarker_en
);
3534 case ISCSI_PARAM_OFMARKER_EN
:
3535 len
= sprintf(buf
, "%d\n", conn
->ofmarker_en
);
3537 case ISCSI_PARAM_EXP_STATSN
:
3538 len
= sprintf(buf
, "%u\n", conn
->exp_statsn
);
3540 case ISCSI_PARAM_PERSISTENT_PORT
:
3541 len
= sprintf(buf
, "%d\n", conn
->persistent_port
);
3543 case ISCSI_PARAM_PERSISTENT_ADDRESS
:
3544 len
= sprintf(buf
, "%s\n", conn
->persistent_address
);
3546 case ISCSI_PARAM_STATSN
:
3547 len
= sprintf(buf
, "%u\n", conn
->statsn
);
3549 case ISCSI_PARAM_MAX_SEGMENT_SIZE
:
3550 len
= sprintf(buf
, "%u\n", conn
->max_segment_size
);
3552 case ISCSI_PARAM_KEEPALIVE_TMO
:
3553 len
= sprintf(buf
, "%u\n", conn
->keepalive_tmo
);
3555 case ISCSI_PARAM_LOCAL_PORT
:
3556 len
= sprintf(buf
, "%u\n", conn
->local_port
);
3558 case ISCSI_PARAM_TCP_TIMESTAMP_STAT
:
3559 len
= sprintf(buf
, "%u\n", conn
->tcp_timestamp_stat
);
3561 case ISCSI_PARAM_TCP_NAGLE_DISABLE
:
3562 len
= sprintf(buf
, "%u\n", conn
->tcp_nagle_disable
);
3564 case ISCSI_PARAM_TCP_WSF_DISABLE
:
3565 len
= sprintf(buf
, "%u\n", conn
->tcp_wsf_disable
);
3567 case ISCSI_PARAM_TCP_TIMER_SCALE
:
3568 len
= sprintf(buf
, "%u\n", conn
->tcp_timer_scale
);
3570 case ISCSI_PARAM_TCP_TIMESTAMP_EN
:
3571 len
= sprintf(buf
, "%u\n", conn
->tcp_timestamp_en
);
3573 case ISCSI_PARAM_IP_FRAGMENT_DISABLE
:
3574 len
= sprintf(buf
, "%u\n", conn
->fragment_disable
);
3576 case ISCSI_PARAM_IPV4_TOS
:
3577 len
= sprintf(buf
, "%u\n", conn
->ipv4_tos
);
3579 case ISCSI_PARAM_IPV6_TC
:
3580 len
= sprintf(buf
, "%u\n", conn
->ipv6_traffic_class
);
3582 case ISCSI_PARAM_IPV6_FLOW_LABEL
:
3583 len
= sprintf(buf
, "%u\n", conn
->ipv6_flow_label
);
3585 case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6
:
3586 len
= sprintf(buf
, "%u\n", conn
->is_fw_assigned_ipv6
);
3588 case ISCSI_PARAM_TCP_XMIT_WSF
:
3589 len
= sprintf(buf
, "%u\n", conn
->tcp_xmit_wsf
);
3591 case ISCSI_PARAM_TCP_RECV_WSF
:
3592 len
= sprintf(buf
, "%u\n", conn
->tcp_recv_wsf
);
3594 case ISCSI_PARAM_LOCAL_IPADDR
:
3595 len
= sprintf(buf
, "%s\n", conn
->local_ipaddr
);
3603 EXPORT_SYMBOL_GPL(iscsi_conn_get_param
);
3605 int iscsi_host_get_param(struct Scsi_Host
*shost
, enum iscsi_host_param param
,
3608 struct iscsi_host
*ihost
= shost_priv(shost
);
3612 case ISCSI_HOST_PARAM_NETDEV_NAME
:
3613 len
= sprintf(buf
, "%s\n", ihost
->netdev
);
3615 case ISCSI_HOST_PARAM_HWADDRESS
:
3616 len
= sprintf(buf
, "%s\n", ihost
->hwaddress
);
3618 case ISCSI_HOST_PARAM_INITIATOR_NAME
:
3619 len
= sprintf(buf
, "%s\n", ihost
->initiatorname
);
3627 EXPORT_SYMBOL_GPL(iscsi_host_get_param
);
3629 int iscsi_host_set_param(struct Scsi_Host
*shost
, enum iscsi_host_param param
,
3630 char *buf
, int buflen
)
3632 struct iscsi_host
*ihost
= shost_priv(shost
);
3635 case ISCSI_HOST_PARAM_NETDEV_NAME
:
3636 return iscsi_switch_str_param(&ihost
->netdev
, buf
);
3637 case ISCSI_HOST_PARAM_HWADDRESS
:
3638 return iscsi_switch_str_param(&ihost
->hwaddress
, buf
);
3639 case ISCSI_HOST_PARAM_INITIATOR_NAME
:
3640 return iscsi_switch_str_param(&ihost
->initiatorname
, buf
);
3647 EXPORT_SYMBOL_GPL(iscsi_host_set_param
);
3649 MODULE_AUTHOR("Mike Christie");
3650 MODULE_DESCRIPTION("iSCSI library functions");
3651 MODULE_LICENSE("GPL");