1 /*******************************************************************************
2 * This file contains the iSCSI Target specific utility functions.
4 * \u00a9 Copyright 2007-2011 RisingTide Systems LLC.
6 * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
8 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
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.
19 ******************************************************************************/
21 #include <linux/list.h>
22 #include <scsi/scsi_tcq.h>
23 #include <scsi/iscsi_proto.h>
24 #include <target/target_core_base.h>
25 #include <target/target_core_transport.h>
26 #include <target/target_core_tmr.h>
27 #include <target/target_core_fabric_ops.h>
28 #include <target/target_core_configfs.h>
30 #include "iscsi_target_core.h"
31 #include "iscsi_target_parameters.h"
32 #include "iscsi_target_seq_pdu_list.h"
33 #include "iscsi_target_datain_values.h"
34 #include "iscsi_target_erl0.h"
35 #include "iscsi_target_erl1.h"
36 #include "iscsi_target_erl2.h"
37 #include "iscsi_target_tpg.h"
38 #include "iscsi_target_tq.h"
39 #include "iscsi_target_util.h"
40 #include "iscsi_target.h"
42 #define PRINT_BUFF(buff, len) \
46 pr_debug("%d:\n", __LINE__); \
47 for (zzz = 0; zzz < len; zzz++) { \
48 if (zzz % 16 == 0) { \
51 pr_debug("%4i: ", zzz); \
53 pr_debug("%02x ", (unsigned char) (buff)[zzz]); \
59 extern struct list_head g_tiqn_list
;
60 extern spinlock_t tiqn_lock
;
63 * Called with cmd->r2t_lock held.
65 int iscsit_add_r2t_to_list(
66 struct iscsi_cmd
*cmd
,
72 struct iscsi_r2t
*r2t
;
74 r2t
= kmem_cache_zalloc(lio_r2t_cache
, GFP_ATOMIC
);
76 pr_err("Unable to allocate memory for struct iscsi_r2t.\n");
79 INIT_LIST_HEAD(&r2t
->r2t_list
);
81 r2t
->recovery_r2t
= recovery
;
82 r2t
->r2t_sn
= (!r2t_sn
) ? cmd
->r2t_sn
++ : r2t_sn
;
84 r2t
->xfer_len
= xfer_len
;
85 list_add_tail(&r2t
->r2t_list
, &cmd
->cmd_r2t_list
);
86 spin_unlock_bh(&cmd
->r2t_lock
);
88 iscsit_add_cmd_to_immediate_queue(cmd
, cmd
->conn
, ISTATE_SEND_R2T
);
90 spin_lock_bh(&cmd
->r2t_lock
);
94 struct iscsi_r2t
*iscsit_get_r2t_for_eos(
95 struct iscsi_cmd
*cmd
,
99 struct iscsi_r2t
*r2t
;
101 spin_lock_bh(&cmd
->r2t_lock
);
102 list_for_each_entry(r2t
, &cmd
->cmd_r2t_list
, r2t_list
) {
103 if ((r2t
->offset
<= offset
) &&
104 (r2t
->offset
+ r2t
->xfer_len
) >= (offset
+ length
)) {
105 spin_unlock_bh(&cmd
->r2t_lock
);
109 spin_unlock_bh(&cmd
->r2t_lock
);
111 pr_err("Unable to locate R2T for Offset: %u, Length:"
112 " %u\n", offset
, length
);
116 struct iscsi_r2t
*iscsit_get_r2t_from_list(struct iscsi_cmd
*cmd
)
118 struct iscsi_r2t
*r2t
;
120 spin_lock_bh(&cmd
->r2t_lock
);
121 list_for_each_entry(r2t
, &cmd
->cmd_r2t_list
, r2t_list
) {
122 if (!r2t
->sent_r2t
) {
123 spin_unlock_bh(&cmd
->r2t_lock
);
127 spin_unlock_bh(&cmd
->r2t_lock
);
129 pr_err("Unable to locate next R2T to send for ITT:"
130 " 0x%08x.\n", cmd
->init_task_tag
);
135 * Called with cmd->r2t_lock held.
137 void iscsit_free_r2t(struct iscsi_r2t
*r2t
, struct iscsi_cmd
*cmd
)
139 list_del(&r2t
->r2t_list
);
140 kmem_cache_free(lio_r2t_cache
, r2t
);
143 void iscsit_free_r2ts_from_list(struct iscsi_cmd
*cmd
)
145 struct iscsi_r2t
*r2t
, *r2t_tmp
;
147 spin_lock_bh(&cmd
->r2t_lock
);
148 list_for_each_entry_safe(r2t
, r2t_tmp
, &cmd
->cmd_r2t_list
, r2t_list
)
149 iscsit_free_r2t(r2t
, cmd
);
150 spin_unlock_bh(&cmd
->r2t_lock
);
154 * May be called from software interrupt (timer) context for allocating
157 struct iscsi_cmd
*iscsit_allocate_cmd(struct iscsi_conn
*conn
, gfp_t gfp_mask
)
159 struct iscsi_cmd
*cmd
;
161 cmd
= kmem_cache_zalloc(lio_cmd_cache
, gfp_mask
);
163 pr_err("Unable to allocate memory for struct iscsi_cmd.\n");
168 INIT_LIST_HEAD(&cmd
->i_list
);
169 INIT_LIST_HEAD(&cmd
->datain_list
);
170 INIT_LIST_HEAD(&cmd
->cmd_r2t_list
);
171 init_completion(&cmd
->reject_comp
);
172 spin_lock_init(&cmd
->datain_lock
);
173 spin_lock_init(&cmd
->dataout_timeout_lock
);
174 spin_lock_init(&cmd
->istate_lock
);
175 spin_lock_init(&cmd
->error_lock
);
176 spin_lock_init(&cmd
->r2t_lock
);
182 * Called from iscsi_handle_scsi_cmd()
184 struct iscsi_cmd
*iscsit_allocate_se_cmd(
185 struct iscsi_conn
*conn
,
190 struct iscsi_cmd
*cmd
;
191 struct se_cmd
*se_cmd
;
194 cmd
= iscsit_allocate_cmd(conn
, GFP_KERNEL
);
198 cmd
->data_direction
= data_direction
;
199 cmd
->data_length
= data_length
;
201 * Figure out the SAM Task Attribute for the incoming SCSI CDB
203 if ((iscsi_task_attr
== ISCSI_ATTR_UNTAGGED
) ||
204 (iscsi_task_attr
== ISCSI_ATTR_SIMPLE
))
205 sam_task_attr
= MSG_SIMPLE_TAG
;
206 else if (iscsi_task_attr
== ISCSI_ATTR_ORDERED
)
207 sam_task_attr
= MSG_ORDERED_TAG
;
208 else if (iscsi_task_attr
== ISCSI_ATTR_HEAD_OF_QUEUE
)
209 sam_task_attr
= MSG_HEAD_TAG
;
210 else if (iscsi_task_attr
== ISCSI_ATTR_ACA
)
211 sam_task_attr
= MSG_ACA_TAG
;
213 pr_debug("Unknown iSCSI Task Attribute: 0x%02x, using"
214 " MSG_SIMPLE_TAG\n", iscsi_task_attr
);
215 sam_task_attr
= MSG_SIMPLE_TAG
;
218 se_cmd
= &cmd
->se_cmd
;
220 * Initialize struct se_cmd descriptor from target_core_mod infrastructure
222 transport_init_se_cmd(se_cmd
, &lio_target_fabric_configfs
->tf_ops
,
223 conn
->sess
->se_sess
, data_length
, data_direction
,
224 sam_task_attr
, &cmd
->sense_buffer
[0]);
228 struct iscsi_cmd
*iscsit_allocate_se_cmd_for_tmr(
229 struct iscsi_conn
*conn
,
232 struct iscsi_cmd
*cmd
;
233 struct se_cmd
*se_cmd
;
236 cmd
= iscsit_allocate_cmd(conn
, GFP_KERNEL
);
240 cmd
->data_direction
= DMA_NONE
;
242 cmd
->tmr_req
= kzalloc(sizeof(struct iscsi_tmr_req
), GFP_KERNEL
);
244 pr_err("Unable to allocate memory for"
245 " Task Management command!\n");
249 * TASK_REASSIGN for ERL=2 / connection stays inside of
250 * LIO-Target $FABRIC_MOD
252 if (function
== ISCSI_TM_FUNC_TASK_REASSIGN
)
255 se_cmd
= &cmd
->se_cmd
;
257 * Initialize struct se_cmd descriptor from target_core_mod infrastructure
259 transport_init_se_cmd(se_cmd
, &lio_target_fabric_configfs
->tf_ops
,
260 conn
->sess
->se_sess
, 0, DMA_NONE
,
261 MSG_SIMPLE_TAG
, &cmd
->sense_buffer
[0]);
264 case ISCSI_TM_FUNC_ABORT_TASK
:
265 tcm_function
= TMR_ABORT_TASK
;
267 case ISCSI_TM_FUNC_ABORT_TASK_SET
:
268 tcm_function
= TMR_ABORT_TASK_SET
;
270 case ISCSI_TM_FUNC_CLEAR_ACA
:
271 tcm_function
= TMR_CLEAR_ACA
;
273 case ISCSI_TM_FUNC_CLEAR_TASK_SET
:
274 tcm_function
= TMR_CLEAR_TASK_SET
;
276 case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET
:
277 tcm_function
= TMR_LUN_RESET
;
279 case ISCSI_TM_FUNC_TARGET_WARM_RESET
:
280 tcm_function
= TMR_TARGET_WARM_RESET
;
282 case ISCSI_TM_FUNC_TARGET_COLD_RESET
:
283 tcm_function
= TMR_TARGET_COLD_RESET
;
286 pr_err("Unknown iSCSI TMR Function:"
287 " 0x%02x\n", function
);
291 se_cmd
->se_tmr_req
= core_tmr_alloc_req(se_cmd
,
292 (void *)cmd
->tmr_req
, tcm_function
);
293 if (!se_cmd
->se_tmr_req
)
296 cmd
->tmr_req
->se_tmr_req
= se_cmd
->se_tmr_req
;
300 iscsit_release_cmd(cmd
);
304 int iscsit_decide_list_to_build(
305 struct iscsi_cmd
*cmd
,
306 u32 immediate_data_length
)
308 struct iscsi_build_list bl
;
309 struct iscsi_conn
*conn
= cmd
->conn
;
310 struct iscsi_session
*sess
= conn
->sess
;
311 struct iscsi_node_attrib
*na
;
313 if (sess
->sess_ops
->DataSequenceInOrder
&&
314 sess
->sess_ops
->DataPDUInOrder
)
317 if (cmd
->data_direction
== DMA_NONE
)
320 na
= iscsit_tpg_get_node_attrib(sess
);
321 memset(&bl
, 0, sizeof(struct iscsi_build_list
));
323 if (cmd
->data_direction
== DMA_FROM_DEVICE
) {
324 bl
.data_direction
= ISCSI_PDU_READ
;
325 bl
.type
= PDULIST_NORMAL
;
326 if (na
->random_datain_pdu_offsets
)
327 bl
.randomize
|= RANDOM_DATAIN_PDU_OFFSETS
;
328 if (na
->random_datain_seq_offsets
)
329 bl
.randomize
|= RANDOM_DATAIN_SEQ_OFFSETS
;
331 bl
.data_direction
= ISCSI_PDU_WRITE
;
332 bl
.immediate_data_length
= immediate_data_length
;
333 if (na
->random_r2t_offsets
)
334 bl
.randomize
|= RANDOM_R2T_OFFSETS
;
336 if (!cmd
->immediate_data
&& !cmd
->unsolicited_data
)
337 bl
.type
= PDULIST_NORMAL
;
338 else if (cmd
->immediate_data
&& !cmd
->unsolicited_data
)
339 bl
.type
= PDULIST_IMMEDIATE
;
340 else if (!cmd
->immediate_data
&& cmd
->unsolicited_data
)
341 bl
.type
= PDULIST_UNSOLICITED
;
342 else if (cmd
->immediate_data
&& cmd
->unsolicited_data
)
343 bl
.type
= PDULIST_IMMEDIATE_AND_UNSOLICITED
;
346 return iscsit_do_build_list(cmd
, &bl
);
349 struct iscsi_seq
*iscsit_get_seq_holder_for_datain(
350 struct iscsi_cmd
*cmd
,
355 for (i
= 0; i
< cmd
->seq_count
; i
++)
356 if (cmd
->seq_list
[i
].seq_send_order
== seq_send_order
)
357 return &cmd
->seq_list
[i
];
362 struct iscsi_seq
*iscsit_get_seq_holder_for_r2t(struct iscsi_cmd
*cmd
)
366 if (!cmd
->seq_list
) {
367 pr_err("struct iscsi_cmd->seq_list is NULL!\n");
371 for (i
= 0; i
< cmd
->seq_count
; i
++) {
372 if (cmd
->seq_list
[i
].type
!= SEQTYPE_NORMAL
)
374 if (cmd
->seq_list
[i
].seq_send_order
== cmd
->seq_send_order
) {
375 cmd
->seq_send_order
++;
376 return &cmd
->seq_list
[i
];
383 struct iscsi_r2t
*iscsit_get_holder_for_r2tsn(
384 struct iscsi_cmd
*cmd
,
387 struct iscsi_r2t
*r2t
;
389 spin_lock_bh(&cmd
->r2t_lock
);
390 list_for_each_entry(r2t
, &cmd
->cmd_r2t_list
, r2t_list
) {
391 if (r2t
->r2t_sn
== r2t_sn
) {
392 spin_unlock_bh(&cmd
->r2t_lock
);
396 spin_unlock_bh(&cmd
->r2t_lock
);
401 static inline int iscsit_check_received_cmdsn(struct iscsi_session
*sess
, u32 cmdsn
)
406 * This is the proper method of checking received CmdSN against
407 * ExpCmdSN and MaxCmdSN values, as well as accounting for out
408 * or order CmdSNs due to multiple connection sessions and/or
411 if (iscsi_sna_gt(cmdsn
, sess
->max_cmd_sn
)) {
412 pr_err("Received CmdSN: 0x%08x is greater than"
413 " MaxCmdSN: 0x%08x, protocol error.\n", cmdsn
,
415 ret
= CMDSN_ERROR_CANNOT_RECOVER
;
417 } else if (cmdsn
== sess
->exp_cmd_sn
) {
419 pr_debug("Received CmdSN matches ExpCmdSN,"
420 " incremented ExpCmdSN to: 0x%08x\n",
422 ret
= CMDSN_NORMAL_OPERATION
;
424 } else if (iscsi_sna_gt(cmdsn
, sess
->exp_cmd_sn
)) {
425 pr_debug("Received CmdSN: 0x%08x is greater"
426 " than ExpCmdSN: 0x%08x, not acknowledging.\n",
427 cmdsn
, sess
->exp_cmd_sn
);
428 ret
= CMDSN_HIGHER_THAN_EXP
;
431 pr_err("Received CmdSN: 0x%08x is less than"
432 " ExpCmdSN: 0x%08x, ignoring.\n", cmdsn
,
434 ret
= CMDSN_LOWER_THAN_EXP
;
441 * Commands may be received out of order if MC/S is in use.
442 * Ensure they are executed in CmdSN order.
444 int iscsit_sequence_cmd(
445 struct iscsi_conn
*conn
,
446 struct iscsi_cmd
*cmd
,
452 mutex_lock(&conn
->sess
->cmdsn_mutex
);
454 cmdsn_ret
= iscsit_check_received_cmdsn(conn
->sess
, cmdsn
);
456 case CMDSN_NORMAL_OPERATION
:
457 ret
= iscsit_execute_cmd(cmd
, 0);
458 if ((ret
>= 0) && !list_empty(&conn
->sess
->sess_ooo_cmdsn_list
))
459 iscsit_execute_ooo_cmdsns(conn
->sess
);
461 case CMDSN_HIGHER_THAN_EXP
:
462 ret
= iscsit_handle_ooo_cmdsn(conn
->sess
, cmd
, cmdsn
);
464 case CMDSN_LOWER_THAN_EXP
:
465 cmd
->i_state
= ISTATE_REMOVE
;
466 iscsit_add_cmd_to_immediate_queue(cmd
, conn
, cmd
->i_state
);
473 mutex_unlock(&conn
->sess
->cmdsn_mutex
);
478 int iscsit_check_unsolicited_dataout(struct iscsi_cmd
*cmd
, unsigned char *buf
)
480 struct iscsi_conn
*conn
= cmd
->conn
;
481 struct se_cmd
*se_cmd
= &cmd
->se_cmd
;
482 struct iscsi_data
*hdr
= (struct iscsi_data
*) buf
;
483 u32 payload_length
= ntoh24(hdr
->dlength
);
485 if (conn
->sess
->sess_ops
->InitialR2T
) {
486 pr_err("Received unexpected unsolicited data"
487 " while InitialR2T=Yes, protocol error.\n");
488 transport_send_check_condition_and_sense(se_cmd
,
489 TCM_UNEXPECTED_UNSOLICITED_DATA
, 0);
493 if ((cmd
->first_burst_len
+ payload_length
) >
494 conn
->sess
->sess_ops
->FirstBurstLength
) {
495 pr_err("Total %u bytes exceeds FirstBurstLength: %u"
496 " for this Unsolicited DataOut Burst.\n",
497 (cmd
->first_burst_len
+ payload_length
),
498 conn
->sess
->sess_ops
->FirstBurstLength
);
499 transport_send_check_condition_and_sense(se_cmd
,
500 TCM_INCORRECT_AMOUNT_OF_DATA
, 0);
504 if (!(hdr
->flags
& ISCSI_FLAG_CMD_FINAL
))
507 if (((cmd
->first_burst_len
+ payload_length
) != cmd
->data_length
) &&
508 ((cmd
->first_burst_len
+ payload_length
) !=
509 conn
->sess
->sess_ops
->FirstBurstLength
)) {
510 pr_err("Unsolicited non-immediate data received %u"
511 " does not equal FirstBurstLength: %u, and does"
512 " not equal ExpXferLen %u.\n",
513 (cmd
->first_burst_len
+ payload_length
),
514 conn
->sess
->sess_ops
->FirstBurstLength
, cmd
->data_length
);
515 transport_send_check_condition_and_sense(se_cmd
,
516 TCM_INCORRECT_AMOUNT_OF_DATA
, 0);
522 struct iscsi_cmd
*iscsit_find_cmd_from_itt(
523 struct iscsi_conn
*conn
,
526 struct iscsi_cmd
*cmd
;
528 spin_lock_bh(&conn
->cmd_lock
);
529 list_for_each_entry(cmd
, &conn
->conn_cmd_list
, i_list
) {
530 if (cmd
->init_task_tag
== init_task_tag
) {
531 spin_unlock_bh(&conn
->cmd_lock
);
535 spin_unlock_bh(&conn
->cmd_lock
);
537 pr_err("Unable to locate ITT: 0x%08x on CID: %hu",
538 init_task_tag
, conn
->cid
);
542 struct iscsi_cmd
*iscsit_find_cmd_from_itt_or_dump(
543 struct iscsi_conn
*conn
,
547 struct iscsi_cmd
*cmd
;
549 spin_lock_bh(&conn
->cmd_lock
);
550 list_for_each_entry(cmd
, &conn
->conn_cmd_list
, i_list
) {
551 if (cmd
->init_task_tag
== init_task_tag
) {
552 spin_unlock_bh(&conn
->cmd_lock
);
556 spin_unlock_bh(&conn
->cmd_lock
);
558 pr_err("Unable to locate ITT: 0x%08x on CID: %hu,"
559 " dumping payload\n", init_task_tag
, conn
->cid
);
561 iscsit_dump_data_payload(conn
, length
, 1);
566 struct iscsi_cmd
*iscsit_find_cmd_from_ttt(
567 struct iscsi_conn
*conn
,
570 struct iscsi_cmd
*cmd
= NULL
;
572 spin_lock_bh(&conn
->cmd_lock
);
573 list_for_each_entry(cmd
, &conn
->conn_cmd_list
, i_list
) {
574 if (cmd
->targ_xfer_tag
== targ_xfer_tag
) {
575 spin_unlock_bh(&conn
->cmd_lock
);
579 spin_unlock_bh(&conn
->cmd_lock
);
581 pr_err("Unable to locate TTT: 0x%08x on CID: %hu\n",
582 targ_xfer_tag
, conn
->cid
);
586 int iscsit_find_cmd_for_recovery(
587 struct iscsi_session
*sess
,
588 struct iscsi_cmd
**cmd_ptr
,
589 struct iscsi_conn_recovery
**cr_ptr
,
592 struct iscsi_cmd
*cmd
= NULL
;
593 struct iscsi_conn_recovery
*cr
;
595 * Scan through the inactive connection recovery list's command list.
596 * If init_task_tag matches the command is still alligent.
598 spin_lock(&sess
->cr_i_lock
);
599 list_for_each_entry(cr
, &sess
->cr_inactive_list
, cr_list
) {
600 spin_lock(&cr
->conn_recovery_cmd_lock
);
601 list_for_each_entry(cmd
, &cr
->conn_recovery_cmd_list
, i_list
) {
602 if (cmd
->init_task_tag
== init_task_tag
) {
603 spin_unlock(&cr
->conn_recovery_cmd_lock
);
604 spin_unlock(&sess
->cr_i_lock
);
611 spin_unlock(&cr
->conn_recovery_cmd_lock
);
613 spin_unlock(&sess
->cr_i_lock
);
615 * Scan through the active connection recovery list's command list.
616 * If init_task_tag matches the command is ready to be reassigned.
618 spin_lock(&sess
->cr_a_lock
);
619 list_for_each_entry(cr
, &sess
->cr_active_list
, cr_list
) {
620 spin_lock(&cr
->conn_recovery_cmd_lock
);
621 list_for_each_entry(cmd
, &cr
->conn_recovery_cmd_list
, i_list
) {
622 if (cmd
->init_task_tag
== init_task_tag
) {
623 spin_unlock(&cr
->conn_recovery_cmd_lock
);
624 spin_unlock(&sess
->cr_a_lock
);
631 spin_unlock(&cr
->conn_recovery_cmd_lock
);
633 spin_unlock(&sess
->cr_a_lock
);
638 void iscsit_add_cmd_to_immediate_queue(
639 struct iscsi_cmd
*cmd
,
640 struct iscsi_conn
*conn
,
643 struct iscsi_queue_req
*qr
;
645 qr
= kmem_cache_zalloc(lio_qr_cache
, GFP_ATOMIC
);
647 pr_err("Unable to allocate memory for"
648 " struct iscsi_queue_req\n");
651 INIT_LIST_HEAD(&qr
->qr_list
);
655 spin_lock_bh(&conn
->immed_queue_lock
);
656 list_add_tail(&qr
->qr_list
, &conn
->immed_queue_list
);
657 atomic_inc(&cmd
->immed_queue_count
);
658 atomic_set(&conn
->check_immediate_queue
, 1);
659 spin_unlock_bh(&conn
->immed_queue_lock
);
661 wake_up_process(conn
->thread_set
->tx_thread
);
664 struct iscsi_queue_req
*iscsit_get_cmd_from_immediate_queue(struct iscsi_conn
*conn
)
666 struct iscsi_queue_req
*qr
;
668 spin_lock_bh(&conn
->immed_queue_lock
);
669 if (list_empty(&conn
->immed_queue_list
)) {
670 spin_unlock_bh(&conn
->immed_queue_lock
);
673 list_for_each_entry(qr
, &conn
->immed_queue_list
, qr_list
)
676 list_del(&qr
->qr_list
);
678 atomic_dec(&qr
->cmd
->immed_queue_count
);
679 spin_unlock_bh(&conn
->immed_queue_lock
);
684 static void iscsit_remove_cmd_from_immediate_queue(
685 struct iscsi_cmd
*cmd
,
686 struct iscsi_conn
*conn
)
688 struct iscsi_queue_req
*qr
, *qr_tmp
;
690 spin_lock_bh(&conn
->immed_queue_lock
);
691 if (!atomic_read(&cmd
->immed_queue_count
)) {
692 spin_unlock_bh(&conn
->immed_queue_lock
);
696 list_for_each_entry_safe(qr
, qr_tmp
, &conn
->immed_queue_list
, qr_list
) {
700 atomic_dec(&qr
->cmd
->immed_queue_count
);
701 list_del(&qr
->qr_list
);
702 kmem_cache_free(lio_qr_cache
, qr
);
704 spin_unlock_bh(&conn
->immed_queue_lock
);
706 if (atomic_read(&cmd
->immed_queue_count
)) {
707 pr_err("ITT: 0x%08x immed_queue_count: %d\n",
709 atomic_read(&cmd
->immed_queue_count
));
713 void iscsit_add_cmd_to_response_queue(
714 struct iscsi_cmd
*cmd
,
715 struct iscsi_conn
*conn
,
718 struct iscsi_queue_req
*qr
;
720 qr
= kmem_cache_zalloc(lio_qr_cache
, GFP_ATOMIC
);
722 pr_err("Unable to allocate memory for"
723 " struct iscsi_queue_req\n");
726 INIT_LIST_HEAD(&qr
->qr_list
);
730 spin_lock_bh(&conn
->response_queue_lock
);
731 list_add_tail(&qr
->qr_list
, &conn
->response_queue_list
);
732 atomic_inc(&cmd
->response_queue_count
);
733 spin_unlock_bh(&conn
->response_queue_lock
);
735 wake_up_process(conn
->thread_set
->tx_thread
);
738 struct iscsi_queue_req
*iscsit_get_cmd_from_response_queue(struct iscsi_conn
*conn
)
740 struct iscsi_queue_req
*qr
;
742 spin_lock_bh(&conn
->response_queue_lock
);
743 if (list_empty(&conn
->response_queue_list
)) {
744 spin_unlock_bh(&conn
->response_queue_lock
);
748 list_for_each_entry(qr
, &conn
->response_queue_list
, qr_list
)
751 list_del(&qr
->qr_list
);
753 atomic_dec(&qr
->cmd
->response_queue_count
);
754 spin_unlock_bh(&conn
->response_queue_lock
);
759 static void iscsit_remove_cmd_from_response_queue(
760 struct iscsi_cmd
*cmd
,
761 struct iscsi_conn
*conn
)
763 struct iscsi_queue_req
*qr
, *qr_tmp
;
765 spin_lock_bh(&conn
->response_queue_lock
);
766 if (!atomic_read(&cmd
->response_queue_count
)) {
767 spin_unlock_bh(&conn
->response_queue_lock
);
771 list_for_each_entry_safe(qr
, qr_tmp
, &conn
->response_queue_list
,
776 atomic_dec(&qr
->cmd
->response_queue_count
);
777 list_del(&qr
->qr_list
);
778 kmem_cache_free(lio_qr_cache
, qr
);
780 spin_unlock_bh(&conn
->response_queue_lock
);
782 if (atomic_read(&cmd
->response_queue_count
)) {
783 pr_err("ITT: 0x%08x response_queue_count: %d\n",
785 atomic_read(&cmd
->response_queue_count
));
789 void iscsit_free_queue_reqs_for_conn(struct iscsi_conn
*conn
)
791 struct iscsi_queue_req
*qr
, *qr_tmp
;
793 spin_lock_bh(&conn
->immed_queue_lock
);
794 list_for_each_entry_safe(qr
, qr_tmp
, &conn
->immed_queue_list
, qr_list
) {
795 list_del(&qr
->qr_list
);
797 atomic_dec(&qr
->cmd
->immed_queue_count
);
799 kmem_cache_free(lio_qr_cache
, qr
);
801 spin_unlock_bh(&conn
->immed_queue_lock
);
803 spin_lock_bh(&conn
->response_queue_lock
);
804 list_for_each_entry_safe(qr
, qr_tmp
, &conn
->response_queue_list
,
806 list_del(&qr
->qr_list
);
808 atomic_dec(&qr
->cmd
->response_queue_count
);
810 kmem_cache_free(lio_qr_cache
, qr
);
812 spin_unlock_bh(&conn
->response_queue_lock
);
815 void iscsit_release_cmd(struct iscsi_cmd
*cmd
)
817 struct iscsi_conn
*conn
= cmd
->conn
;
820 iscsit_free_r2ts_from_list(cmd
);
821 iscsit_free_all_datain_reqs(cmd
);
824 kfree(cmd
->pdu_list
);
825 kfree(cmd
->seq_list
);
827 kfree(cmd
->iov_data
);
829 for (i
= 0; i
< cmd
->t_mem_sg_nents
; i
++)
830 __free_page(sg_page(&cmd
->t_mem_sg
[i
]));
832 kfree(cmd
->t_mem_sg
);
835 iscsit_remove_cmd_from_immediate_queue(cmd
, conn
);
836 iscsit_remove_cmd_from_response_queue(cmd
, conn
);
839 kmem_cache_free(lio_cmd_cache
, cmd
);
842 int iscsit_check_session_usage_count(struct iscsi_session
*sess
)
844 spin_lock_bh(&sess
->session_usage_lock
);
845 if (sess
->session_usage_count
!= 0) {
846 sess
->session_waiting_on_uc
= 1;
847 spin_unlock_bh(&sess
->session_usage_lock
);
851 wait_for_completion(&sess
->session_waiting_on_uc_comp
);
854 spin_unlock_bh(&sess
->session_usage_lock
);
859 void iscsit_dec_session_usage_count(struct iscsi_session
*sess
)
861 spin_lock_bh(&sess
->session_usage_lock
);
862 sess
->session_usage_count
--;
864 if (!sess
->session_usage_count
&& sess
->session_waiting_on_uc
)
865 complete(&sess
->session_waiting_on_uc_comp
);
867 spin_unlock_bh(&sess
->session_usage_lock
);
870 void iscsit_inc_session_usage_count(struct iscsi_session
*sess
)
872 spin_lock_bh(&sess
->session_usage_lock
);
873 sess
->session_usage_count
++;
874 spin_unlock_bh(&sess
->session_usage_lock
);
878 * Used before iscsi_do[rx,tx]_data() to determine iov and [rx,tx]_marker
879 * array counts needed for sync and steering.
881 static int iscsit_determine_sync_and_steering_counts(
882 struct iscsi_conn
*conn
,
883 struct iscsi_data_count
*count
)
885 u32 length
= count
->data_length
;
888 count
->sync_and_steering
= 1;
890 marker
= (count
->type
== ISCSI_RX_DATA
) ?
891 conn
->of_marker
: conn
->if_marker
;
892 markint
= (count
->type
== ISCSI_RX_DATA
) ?
893 (conn
->conn_ops
->OFMarkInt
* 4) :
894 (conn
->conn_ops
->IFMarkInt
* 4);
895 count
->ss_iov_count
= count
->iov_count
;
898 if (length
>= marker
) {
899 count
->ss_iov_count
+= 3;
900 count
->ss_marker_count
+= 2;
912 * Setup conn->if_marker and conn->of_marker values based upon
913 * the initial marker-less interval. (see iSCSI v19 A.2)
915 int iscsit_set_sync_and_steering_values(struct iscsi_conn
*conn
)
917 int login_ifmarker_count
= 0, login_ofmarker_count
= 0, next_marker
= 0;
919 * IFMarkInt and OFMarkInt are negotiated as 32-bit words.
921 u32 IFMarkInt
= (conn
->conn_ops
->IFMarkInt
* 4);
922 u32 OFMarkInt
= (conn
->conn_ops
->OFMarkInt
* 4);
924 if (conn
->conn_ops
->OFMarker
) {
926 * Account for the first Login Command received not
927 * via iscsi_recv_msg().
929 conn
->of_marker
+= ISCSI_HDR_LEN
;
930 if (conn
->of_marker
<= OFMarkInt
) {
931 conn
->of_marker
= (OFMarkInt
- conn
->of_marker
);
933 login_ofmarker_count
= (conn
->of_marker
/ OFMarkInt
);
934 next_marker
= (OFMarkInt
* (login_ofmarker_count
+ 1)) +
935 (login_ofmarker_count
* MARKER_SIZE
);
936 conn
->of_marker
= (next_marker
- conn
->of_marker
);
938 conn
->of_marker_offset
= 0;
939 pr_debug("Setting OFMarker value to %u based on Initial"
940 " Markerless Interval.\n", conn
->of_marker
);
943 if (conn
->conn_ops
->IFMarker
) {
944 if (conn
->if_marker
<= IFMarkInt
) {
945 conn
->if_marker
= (IFMarkInt
- conn
->if_marker
);
947 login_ifmarker_count
= (conn
->if_marker
/ IFMarkInt
);
948 next_marker
= (IFMarkInt
* (login_ifmarker_count
+ 1)) +
949 (login_ifmarker_count
* MARKER_SIZE
);
950 conn
->if_marker
= (next_marker
- conn
->if_marker
);
952 pr_debug("Setting IFMarker value to %u based on Initial"
953 " Markerless Interval.\n", conn
->if_marker
);
959 struct iscsi_conn
*iscsit_get_conn_from_cid(struct iscsi_session
*sess
, u16 cid
)
961 struct iscsi_conn
*conn
;
963 spin_lock_bh(&sess
->conn_lock
);
964 list_for_each_entry(conn
, &sess
->sess_conn_list
, conn_list
) {
965 if ((conn
->cid
== cid
) &&
966 (conn
->conn_state
== TARG_CONN_STATE_LOGGED_IN
)) {
967 iscsit_inc_conn_usage_count(conn
);
968 spin_unlock_bh(&sess
->conn_lock
);
972 spin_unlock_bh(&sess
->conn_lock
);
977 struct iscsi_conn
*iscsit_get_conn_from_cid_rcfr(struct iscsi_session
*sess
, u16 cid
)
979 struct iscsi_conn
*conn
;
981 spin_lock_bh(&sess
->conn_lock
);
982 list_for_each_entry(conn
, &sess
->sess_conn_list
, conn_list
) {
983 if (conn
->cid
== cid
) {
984 iscsit_inc_conn_usage_count(conn
);
985 spin_lock(&conn
->state_lock
);
986 atomic_set(&conn
->connection_wait_rcfr
, 1);
987 spin_unlock(&conn
->state_lock
);
988 spin_unlock_bh(&sess
->conn_lock
);
992 spin_unlock_bh(&sess
->conn_lock
);
997 void iscsit_check_conn_usage_count(struct iscsi_conn
*conn
)
999 spin_lock_bh(&conn
->conn_usage_lock
);
1000 if (conn
->conn_usage_count
!= 0) {
1001 conn
->conn_waiting_on_uc
= 1;
1002 spin_unlock_bh(&conn
->conn_usage_lock
);
1004 wait_for_completion(&conn
->conn_waiting_on_uc_comp
);
1007 spin_unlock_bh(&conn
->conn_usage_lock
);
1010 void iscsit_dec_conn_usage_count(struct iscsi_conn
*conn
)
1012 spin_lock_bh(&conn
->conn_usage_lock
);
1013 conn
->conn_usage_count
--;
1015 if (!conn
->conn_usage_count
&& conn
->conn_waiting_on_uc
)
1016 complete(&conn
->conn_waiting_on_uc_comp
);
1018 spin_unlock_bh(&conn
->conn_usage_lock
);
1021 void iscsit_inc_conn_usage_count(struct iscsi_conn
*conn
)
1023 spin_lock_bh(&conn
->conn_usage_lock
);
1024 conn
->conn_usage_count
++;
1025 spin_unlock_bh(&conn
->conn_usage_lock
);
1028 static int iscsit_add_nopin(struct iscsi_conn
*conn
, int want_response
)
1031 struct iscsi_cmd
*cmd
;
1033 cmd
= iscsit_allocate_cmd(conn
, GFP_ATOMIC
);
1037 cmd
->iscsi_opcode
= ISCSI_OP_NOOP_IN
;
1038 state
= (want_response
) ? ISTATE_SEND_NOPIN_WANT_RESPONSE
:
1039 ISTATE_SEND_NOPIN_NO_RESPONSE
;
1040 cmd
->init_task_tag
= 0xFFFFFFFF;
1041 spin_lock_bh(&conn
->sess
->ttt_lock
);
1042 cmd
->targ_xfer_tag
= (want_response
) ? conn
->sess
->targ_xfer_tag
++ :
1044 if (want_response
&& (cmd
->targ_xfer_tag
== 0xFFFFFFFF))
1045 cmd
->targ_xfer_tag
= conn
->sess
->targ_xfer_tag
++;
1046 spin_unlock_bh(&conn
->sess
->ttt_lock
);
1048 spin_lock_bh(&conn
->cmd_lock
);
1049 list_add_tail(&cmd
->i_list
, &conn
->conn_cmd_list
);
1050 spin_unlock_bh(&conn
->cmd_lock
);
1053 iscsit_start_nopin_response_timer(conn
);
1054 iscsit_add_cmd_to_immediate_queue(cmd
, conn
, state
);
1059 static void iscsit_handle_nopin_response_timeout(unsigned long data
)
1061 struct iscsi_conn
*conn
= (struct iscsi_conn
*) data
;
1063 iscsit_inc_conn_usage_count(conn
);
1065 spin_lock_bh(&conn
->nopin_timer_lock
);
1066 if (conn
->nopin_response_timer_flags
& ISCSI_TF_STOP
) {
1067 spin_unlock_bh(&conn
->nopin_timer_lock
);
1068 iscsit_dec_conn_usage_count(conn
);
1072 pr_debug("Did not receive response to NOPIN on CID: %hu on"
1073 " SID: %u, failing connection.\n", conn
->cid
,
1075 conn
->nopin_response_timer_flags
&= ~ISCSI_TF_RUNNING
;
1076 spin_unlock_bh(&conn
->nopin_timer_lock
);
1079 struct iscsi_portal_group
*tpg
= conn
->sess
->tpg
;
1080 struct iscsi_tiqn
*tiqn
= tpg
->tpg_tiqn
;
1083 spin_lock_bh(&tiqn
->sess_err_stats
.lock
);
1084 strcpy(tiqn
->sess_err_stats
.last_sess_fail_rem_name
,
1085 (void *)conn
->sess
->sess_ops
->InitiatorName
);
1086 tiqn
->sess_err_stats
.last_sess_failure_type
=
1087 ISCSI_SESS_ERR_CXN_TIMEOUT
;
1088 tiqn
->sess_err_stats
.cxn_timeout_errors
++;
1089 conn
->sess
->conn_timeout_errors
++;
1090 spin_unlock_bh(&tiqn
->sess_err_stats
.lock
);
1094 iscsit_cause_connection_reinstatement(conn
, 0);
1095 iscsit_dec_conn_usage_count(conn
);
1098 void iscsit_mod_nopin_response_timer(struct iscsi_conn
*conn
)
1100 struct iscsi_session
*sess
= conn
->sess
;
1101 struct iscsi_node_attrib
*na
= iscsit_tpg_get_node_attrib(sess
);
1103 spin_lock_bh(&conn
->nopin_timer_lock
);
1104 if (!(conn
->nopin_response_timer_flags
& ISCSI_TF_RUNNING
)) {
1105 spin_unlock_bh(&conn
->nopin_timer_lock
);
1109 mod_timer(&conn
->nopin_response_timer
,
1110 (get_jiffies_64() + na
->nopin_response_timeout
* HZ
));
1111 spin_unlock_bh(&conn
->nopin_timer_lock
);
1115 * Called with conn->nopin_timer_lock held.
1117 void iscsit_start_nopin_response_timer(struct iscsi_conn
*conn
)
1119 struct iscsi_session
*sess
= conn
->sess
;
1120 struct iscsi_node_attrib
*na
= iscsit_tpg_get_node_attrib(sess
);
1122 spin_lock_bh(&conn
->nopin_timer_lock
);
1123 if (conn
->nopin_response_timer_flags
& ISCSI_TF_RUNNING
) {
1124 spin_unlock_bh(&conn
->nopin_timer_lock
);
1128 init_timer(&conn
->nopin_response_timer
);
1129 conn
->nopin_response_timer
.expires
=
1130 (get_jiffies_64() + na
->nopin_response_timeout
* HZ
);
1131 conn
->nopin_response_timer
.data
= (unsigned long)conn
;
1132 conn
->nopin_response_timer
.function
= iscsit_handle_nopin_response_timeout
;
1133 conn
->nopin_response_timer_flags
&= ~ISCSI_TF_STOP
;
1134 conn
->nopin_response_timer_flags
|= ISCSI_TF_RUNNING
;
1135 add_timer(&conn
->nopin_response_timer
);
1137 pr_debug("Started NOPIN Response Timer on CID: %d to %u"
1138 " seconds\n", conn
->cid
, na
->nopin_response_timeout
);
1139 spin_unlock_bh(&conn
->nopin_timer_lock
);
1142 void iscsit_stop_nopin_response_timer(struct iscsi_conn
*conn
)
1144 spin_lock_bh(&conn
->nopin_timer_lock
);
1145 if (!(conn
->nopin_response_timer_flags
& ISCSI_TF_RUNNING
)) {
1146 spin_unlock_bh(&conn
->nopin_timer_lock
);
1149 conn
->nopin_response_timer_flags
|= ISCSI_TF_STOP
;
1150 spin_unlock_bh(&conn
->nopin_timer_lock
);
1152 del_timer_sync(&conn
->nopin_response_timer
);
1154 spin_lock_bh(&conn
->nopin_timer_lock
);
1155 conn
->nopin_response_timer_flags
&= ~ISCSI_TF_RUNNING
;
1156 spin_unlock_bh(&conn
->nopin_timer_lock
);
1159 static void iscsit_handle_nopin_timeout(unsigned long data
)
1161 struct iscsi_conn
*conn
= (struct iscsi_conn
*) data
;
1163 iscsit_inc_conn_usage_count(conn
);
1165 spin_lock_bh(&conn
->nopin_timer_lock
);
1166 if (conn
->nopin_timer_flags
& ISCSI_TF_STOP
) {
1167 spin_unlock_bh(&conn
->nopin_timer_lock
);
1168 iscsit_dec_conn_usage_count(conn
);
1171 conn
->nopin_timer_flags
&= ~ISCSI_TF_RUNNING
;
1172 spin_unlock_bh(&conn
->nopin_timer_lock
);
1174 iscsit_add_nopin(conn
, 1);
1175 iscsit_dec_conn_usage_count(conn
);
1179 * Called with conn->nopin_timer_lock held.
1181 void __iscsit_start_nopin_timer(struct iscsi_conn
*conn
)
1183 struct iscsi_session
*sess
= conn
->sess
;
1184 struct iscsi_node_attrib
*na
= iscsit_tpg_get_node_attrib(sess
);
1186 * NOPIN timeout is disabled.
1188 if (!na
->nopin_timeout
)
1191 if (conn
->nopin_timer_flags
& ISCSI_TF_RUNNING
)
1194 init_timer(&conn
->nopin_timer
);
1195 conn
->nopin_timer
.expires
= (get_jiffies_64() + na
->nopin_timeout
* HZ
);
1196 conn
->nopin_timer
.data
= (unsigned long)conn
;
1197 conn
->nopin_timer
.function
= iscsit_handle_nopin_timeout
;
1198 conn
->nopin_timer_flags
&= ~ISCSI_TF_STOP
;
1199 conn
->nopin_timer_flags
|= ISCSI_TF_RUNNING
;
1200 add_timer(&conn
->nopin_timer
);
1202 pr_debug("Started NOPIN Timer on CID: %d at %u second"
1203 " interval\n", conn
->cid
, na
->nopin_timeout
);
1206 void iscsit_start_nopin_timer(struct iscsi_conn
*conn
)
1208 struct iscsi_session
*sess
= conn
->sess
;
1209 struct iscsi_node_attrib
*na
= iscsit_tpg_get_node_attrib(sess
);
1211 * NOPIN timeout is disabled..
1213 if (!na
->nopin_timeout
)
1216 spin_lock_bh(&conn
->nopin_timer_lock
);
1217 if (conn
->nopin_timer_flags
& ISCSI_TF_RUNNING
) {
1218 spin_unlock_bh(&conn
->nopin_timer_lock
);
1222 init_timer(&conn
->nopin_timer
);
1223 conn
->nopin_timer
.expires
= (get_jiffies_64() + na
->nopin_timeout
* HZ
);
1224 conn
->nopin_timer
.data
= (unsigned long)conn
;
1225 conn
->nopin_timer
.function
= iscsit_handle_nopin_timeout
;
1226 conn
->nopin_timer_flags
&= ~ISCSI_TF_STOP
;
1227 conn
->nopin_timer_flags
|= ISCSI_TF_RUNNING
;
1228 add_timer(&conn
->nopin_timer
);
1230 pr_debug("Started NOPIN Timer on CID: %d at %u second"
1231 " interval\n", conn
->cid
, na
->nopin_timeout
);
1232 spin_unlock_bh(&conn
->nopin_timer_lock
);
1235 void iscsit_stop_nopin_timer(struct iscsi_conn
*conn
)
1237 spin_lock_bh(&conn
->nopin_timer_lock
);
1238 if (!(conn
->nopin_timer_flags
& ISCSI_TF_RUNNING
)) {
1239 spin_unlock_bh(&conn
->nopin_timer_lock
);
1242 conn
->nopin_timer_flags
|= ISCSI_TF_STOP
;
1243 spin_unlock_bh(&conn
->nopin_timer_lock
);
1245 del_timer_sync(&conn
->nopin_timer
);
1247 spin_lock_bh(&conn
->nopin_timer_lock
);
1248 conn
->nopin_timer_flags
&= ~ISCSI_TF_RUNNING
;
1249 spin_unlock_bh(&conn
->nopin_timer_lock
);
1252 int iscsit_send_tx_data(
1253 struct iscsi_cmd
*cmd
,
1254 struct iscsi_conn
*conn
,
1257 int tx_sent
, tx_size
;
1262 tx_size
= cmd
->tx_size
;
1265 iov
= &cmd
->iov_data
[0];
1266 iov_count
= cmd
->iov_data_count
;
1268 iov
= &cmd
->iov_misc
[0];
1269 iov_count
= cmd
->iov_misc_count
;
1272 tx_sent
= tx_data(conn
, &iov
[0], iov_count
, tx_size
);
1273 if (tx_size
!= tx_sent
) {
1274 if (tx_sent
== -EAGAIN
) {
1275 pr_err("tx_data() returned -EAGAIN\n");
1285 int iscsit_fe_sendpage_sg(
1286 struct iscsi_cmd
*cmd
,
1287 struct iscsi_conn
*conn
)
1289 struct scatterlist
*sg
= cmd
->first_data_sg
;
1291 u32 tx_hdr_size
, data_len
;
1292 u32 offset
= cmd
->first_data_sg_off
;
1296 tx_hdr_size
= ISCSI_HDR_LEN
;
1297 if (conn
->conn_ops
->HeaderDigest
)
1298 tx_hdr_size
+= ISCSI_CRC_LEN
;
1300 iov
.iov_base
= cmd
->pdu
;
1301 iov
.iov_len
= tx_hdr_size
;
1303 tx_sent
= tx_data(conn
, &iov
, 1, tx_hdr_size
);
1304 if (tx_hdr_size
!= tx_sent
) {
1305 if (tx_sent
== -EAGAIN
) {
1306 pr_err("tx_data() returned -EAGAIN\n");
1312 data_len
= cmd
->tx_size
- tx_hdr_size
- cmd
->padding
;
1313 if (conn
->conn_ops
->DataDigest
)
1314 data_len
-= ISCSI_CRC_LEN
;
1317 * Perform sendpage() for each page in the scatterlist
1320 u32 space
= (sg
->length
- offset
);
1321 u32 sub_len
= min_t(u32
, data_len
, space
);
1323 tx_sent
= conn
->sock
->ops
->sendpage(conn
->sock
,
1324 sg_page(sg
), sg
->offset
+ offset
, sub_len
, 0);
1325 if (tx_sent
!= sub_len
) {
1326 if (tx_sent
== -EAGAIN
) {
1327 pr_err("tcp_sendpage() returned"
1332 pr_err("tcp_sendpage() failure: %d\n",
1337 data_len
-= sub_len
;
1344 struct kvec
*iov_p
=
1345 &cmd
->iov_data
[cmd
->iov_data_count
-1];
1347 tx_sent
= tx_data(conn
, iov_p
, 1, cmd
->padding
);
1348 if (cmd
->padding
!= tx_sent
) {
1349 if (tx_sent
== -EAGAIN
) {
1350 pr_err("tx_data() returned -EAGAIN\n");
1358 if (conn
->conn_ops
->DataDigest
) {
1359 struct kvec
*iov_d
=
1360 &cmd
->iov_data
[cmd
->iov_data_count
];
1362 tx_sent
= tx_data(conn
, iov_d
, 1, ISCSI_CRC_LEN
);
1363 if (ISCSI_CRC_LEN
!= tx_sent
) {
1364 if (tx_sent
== -EAGAIN
) {
1365 pr_err("tx_data() returned -EAGAIN\n");
1376 * This function is used for mainly sending a ISCSI_TARG_LOGIN_RSP PDU
1377 * back to the Initiator when an expection condition occurs with the
1378 * errors set in status_class and status_detail.
1380 * Parameters: iSCSI Connection, Status Class, Status Detail.
1381 * Returns: 0 on success, -1 on error.
1383 int iscsit_tx_login_rsp(struct iscsi_conn
*conn
, u8 status_class
, u8 status_detail
)
1385 u8 iscsi_hdr
[ISCSI_HDR_LEN
];
1388 struct iscsi_login_rsp
*hdr
;
1390 iscsit_collect_login_stats(conn
, status_class
, status_detail
);
1392 memset(&iov
, 0, sizeof(struct kvec
));
1393 memset(&iscsi_hdr
, 0x0, ISCSI_HDR_LEN
);
1395 hdr
= (struct iscsi_login_rsp
*)&iscsi_hdr
;
1396 hdr
->opcode
= ISCSI_OP_LOGIN_RSP
;
1397 hdr
->status_class
= status_class
;
1398 hdr
->status_detail
= status_detail
;
1399 hdr
->itt
= cpu_to_be32(conn
->login_itt
);
1401 iov
.iov_base
= &iscsi_hdr
;
1402 iov
.iov_len
= ISCSI_HDR_LEN
;
1404 PRINT_BUFF(iscsi_hdr
, ISCSI_HDR_LEN
);
1406 err
= tx_data(conn
, &iov
, 1, ISCSI_HDR_LEN
);
1407 if (err
!= ISCSI_HDR_LEN
) {
1408 pr_err("tx_data returned less than expected\n");
1415 void iscsit_print_session_params(struct iscsi_session
*sess
)
1417 struct iscsi_conn
*conn
;
1419 pr_debug("-----------------------------[Session Params for"
1420 " SID: %u]-----------------------------\n", sess
->sid
);
1421 spin_lock_bh(&sess
->conn_lock
);
1422 list_for_each_entry(conn
, &sess
->sess_conn_list
, conn_list
)
1423 iscsi_dump_conn_ops(conn
->conn_ops
);
1424 spin_unlock_bh(&sess
->conn_lock
);
1426 iscsi_dump_sess_ops(sess
->sess_ops
);
1429 static int iscsit_do_rx_data(
1430 struct iscsi_conn
*conn
,
1431 struct iscsi_data_count
*count
)
1433 int data
= count
->data_length
, rx_loop
= 0, total_rx
= 0, iov_len
;
1434 u32 rx_marker_val
[count
->ss_marker_count
], rx_marker_iov
= 0;
1435 struct kvec iov
[count
->ss_iov_count
], *iov_p
;
1438 if (!conn
|| !conn
->sock
|| !conn
->conn_ops
)
1441 memset(&msg
, 0, sizeof(struct msghdr
));
1443 if (count
->sync_and_steering
) {
1445 u32 i
, orig_iov_count
= 0;
1446 u32 orig_iov_len
= 0, orig_iov_loc
= 0;
1447 u32 iov_count
= 0, per_iov_bytes
= 0;
1448 u32
*rx_marker
, old_rx_marker
= 0;
1449 struct kvec
*iov_record
;
1451 memset(&rx_marker_val
, 0,
1452 count
->ss_marker_count
* sizeof(u32
));
1453 memset(&iov
, 0, count
->ss_iov_count
* sizeof(struct kvec
));
1455 iov_record
= count
->iov
;
1456 orig_iov_count
= count
->iov_count
;
1457 rx_marker
= &conn
->of_marker
;
1461 orig_iov_len
= iov_record
[orig_iov_loc
].iov_len
;
1463 pr_debug("rx_data: #1 orig_iov_len %u,"
1464 " orig_iov_loc %u\n", orig_iov_len
, orig_iov_loc
);
1465 pr_debug("rx_data: #2 rx_marker %u, size"
1466 " %u\n", *rx_marker
, size
);
1468 if (orig_iov_len
>= *rx_marker
) {
1469 iov
[iov_count
].iov_len
= *rx_marker
;
1470 iov
[iov_count
++].iov_base
=
1471 (iov_record
[orig_iov_loc
].iov_base
+
1474 iov
[iov_count
].iov_len
= (MARKER_SIZE
/ 2);
1475 iov
[iov_count
++].iov_base
=
1476 &rx_marker_val
[rx_marker_iov
++];
1477 iov
[iov_count
].iov_len
= (MARKER_SIZE
/ 2);
1478 iov
[iov_count
++].iov_base
=
1479 &rx_marker_val
[rx_marker_iov
++];
1480 old_rx_marker
= *rx_marker
;
1483 * OFMarkInt is in 32-bit words.
1485 *rx_marker
= (conn
->conn_ops
->OFMarkInt
* 4);
1486 size
-= old_rx_marker
;
1487 orig_iov_len
-= old_rx_marker
;
1488 per_iov_bytes
+= old_rx_marker
;
1490 pr_debug("rx_data: #3 new_rx_marker"
1491 " %u, size %u\n", *rx_marker
, size
);
1493 iov
[iov_count
].iov_len
= orig_iov_len
;
1494 iov
[iov_count
++].iov_base
=
1495 (iov_record
[orig_iov_loc
].iov_base
+
1499 *rx_marker
-= orig_iov_len
;
1500 size
-= orig_iov_len
;
1504 iov_record
[++orig_iov_loc
].iov_len
;
1506 pr_debug("rx_data: #4 new_rx_marker"
1507 " %u, size %u\n", *rx_marker
, size
);
1510 data
+= (rx_marker_iov
* (MARKER_SIZE
/ 2));
1513 iov_len
= iov_count
;
1515 if (iov_count
> count
->ss_iov_count
) {
1516 pr_err("iov_count: %d, count->ss_iov_count:"
1517 " %d\n", iov_count
, count
->ss_iov_count
);
1520 if (rx_marker_iov
> count
->ss_marker_count
) {
1521 pr_err("rx_marker_iov: %d, count->ss_marker"
1522 "_count: %d\n", rx_marker_iov
,
1523 count
->ss_marker_count
);
1528 iov_len
= count
->iov_count
;
1531 while (total_rx
< data
) {
1532 rx_loop
= kernel_recvmsg(conn
->sock
, &msg
, iov_p
, iov_len
,
1533 (data
- total_rx
), MSG_WAITALL
);
1535 pr_debug("rx_loop: %d total_rx: %d\n",
1539 total_rx
+= rx_loop
;
1540 pr_debug("rx_loop: %d, total_rx: %d, data: %d\n",
1541 rx_loop
, total_rx
, data
);
1544 if (count
->sync_and_steering
) {
1546 for (j
= 0; j
< rx_marker_iov
; j
++) {
1547 pr_debug("rx_data: #5 j: %d, offset: %d\n",
1548 j
, rx_marker_val
[j
]);
1549 conn
->of_marker_offset
= rx_marker_val
[j
];
1551 total_rx
-= (rx_marker_iov
* (MARKER_SIZE
/ 2));
1557 static int iscsit_do_tx_data(
1558 struct iscsi_conn
*conn
,
1559 struct iscsi_data_count
*count
)
1561 int data
= count
->data_length
, total_tx
= 0, tx_loop
= 0, iov_len
;
1562 u32 tx_marker_val
[count
->ss_marker_count
], tx_marker_iov
= 0;
1563 struct kvec iov
[count
->ss_iov_count
], *iov_p
;
1566 if (!conn
|| !conn
->sock
|| !conn
->conn_ops
)
1570 pr_err("Data length is: %d\n", data
);
1574 memset(&msg
, 0, sizeof(struct msghdr
));
1576 if (count
->sync_and_steering
) {
1578 u32 i
, orig_iov_count
= 0;
1579 u32 orig_iov_len
= 0, orig_iov_loc
= 0;
1580 u32 iov_count
= 0, per_iov_bytes
= 0;
1581 u32
*tx_marker
, old_tx_marker
= 0;
1582 struct kvec
*iov_record
;
1584 memset(&tx_marker_val
, 0,
1585 count
->ss_marker_count
* sizeof(u32
));
1586 memset(&iov
, 0, count
->ss_iov_count
* sizeof(struct kvec
));
1588 iov_record
= count
->iov
;
1589 orig_iov_count
= count
->iov_count
;
1590 tx_marker
= &conn
->if_marker
;
1594 orig_iov_len
= iov_record
[orig_iov_loc
].iov_len
;
1596 pr_debug("tx_data: #1 orig_iov_len %u,"
1597 " orig_iov_loc %u\n", orig_iov_len
, orig_iov_loc
);
1598 pr_debug("tx_data: #2 tx_marker %u, size"
1599 " %u\n", *tx_marker
, size
);
1601 if (orig_iov_len
>= *tx_marker
) {
1602 iov
[iov_count
].iov_len
= *tx_marker
;
1603 iov
[iov_count
++].iov_base
=
1604 (iov_record
[orig_iov_loc
].iov_base
+
1607 tx_marker_val
[tx_marker_iov
] =
1608 (size
- *tx_marker
);
1609 iov
[iov_count
].iov_len
= (MARKER_SIZE
/ 2);
1610 iov
[iov_count
++].iov_base
=
1611 &tx_marker_val
[tx_marker_iov
++];
1612 iov
[iov_count
].iov_len
= (MARKER_SIZE
/ 2);
1613 iov
[iov_count
++].iov_base
=
1614 &tx_marker_val
[tx_marker_iov
++];
1615 old_tx_marker
= *tx_marker
;
1618 * IFMarkInt is in 32-bit words.
1620 *tx_marker
= (conn
->conn_ops
->IFMarkInt
* 4);
1621 size
-= old_tx_marker
;
1622 orig_iov_len
-= old_tx_marker
;
1623 per_iov_bytes
+= old_tx_marker
;
1625 pr_debug("tx_data: #3 new_tx_marker"
1626 " %u, size %u\n", *tx_marker
, size
);
1627 pr_debug("tx_data: #4 offset %u\n",
1628 tx_marker_val
[tx_marker_iov
-1]);
1630 iov
[iov_count
].iov_len
= orig_iov_len
;
1631 iov
[iov_count
++].iov_base
1632 = (iov_record
[orig_iov_loc
].iov_base
+
1636 *tx_marker
-= orig_iov_len
;
1637 size
-= orig_iov_len
;
1641 iov_record
[++orig_iov_loc
].iov_len
;
1643 pr_debug("tx_data: #5 new_tx_marker"
1644 " %u, size %u\n", *tx_marker
, size
);
1648 data
+= (tx_marker_iov
* (MARKER_SIZE
/ 2));
1651 iov_len
= iov_count
;
1653 if (iov_count
> count
->ss_iov_count
) {
1654 pr_err("iov_count: %d, count->ss_iov_count:"
1655 " %d\n", iov_count
, count
->ss_iov_count
);
1658 if (tx_marker_iov
> count
->ss_marker_count
) {
1659 pr_err("tx_marker_iov: %d, count->ss_marker"
1660 "_count: %d\n", tx_marker_iov
,
1661 count
->ss_marker_count
);
1666 iov_len
= count
->iov_count
;
1669 while (total_tx
< data
) {
1670 tx_loop
= kernel_sendmsg(conn
->sock
, &msg
, iov_p
, iov_len
,
1673 pr_debug("tx_loop: %d total_tx %d\n",
1677 total_tx
+= tx_loop
;
1678 pr_debug("tx_loop: %d, total_tx: %d, data: %d\n",
1679 tx_loop
, total_tx
, data
);
1682 if (count
->sync_and_steering
)
1683 total_tx
-= (tx_marker_iov
* (MARKER_SIZE
/ 2));
1689 struct iscsi_conn
*conn
,
1694 struct iscsi_data_count c
;
1696 if (!conn
|| !conn
->sock
|| !conn
->conn_ops
)
1699 memset(&c
, 0, sizeof(struct iscsi_data_count
));
1701 c
.iov_count
= iov_count
;
1702 c
.data_length
= data
;
1703 c
.type
= ISCSI_RX_DATA
;
1705 if (conn
->conn_ops
->OFMarker
&&
1706 (conn
->conn_state
>= TARG_CONN_STATE_LOGGED_IN
)) {
1707 if (iscsit_determine_sync_and_steering_counts(conn
, &c
) < 0)
1711 return iscsit_do_rx_data(conn
, &c
);
1715 struct iscsi_conn
*conn
,
1720 struct iscsi_data_count c
;
1722 if (!conn
|| !conn
->sock
|| !conn
->conn_ops
)
1725 memset(&c
, 0, sizeof(struct iscsi_data_count
));
1727 c
.iov_count
= iov_count
;
1728 c
.data_length
= data
;
1729 c
.type
= ISCSI_TX_DATA
;
1731 if (conn
->conn_ops
->IFMarker
&&
1732 (conn
->conn_state
>= TARG_CONN_STATE_LOGGED_IN
)) {
1733 if (iscsit_determine_sync_and_steering_counts(conn
, &c
) < 0)
1737 return iscsit_do_tx_data(conn
, &c
);
1740 void iscsit_collect_login_stats(
1741 struct iscsi_conn
*conn
,
1745 struct iscsi_param
*intrname
= NULL
;
1746 struct iscsi_tiqn
*tiqn
;
1747 struct iscsi_login_stats
*ls
;
1749 tiqn
= iscsit_snmp_get_tiqn(conn
);
1753 ls
= &tiqn
->login_stats
;
1755 spin_lock(&ls
->lock
);
1756 if (!strcmp(conn
->login_ip
, ls
->last_intr_fail_ip_addr
) &&
1757 ((get_jiffies_64() - ls
->last_fail_time
) < 10)) {
1758 /* We already have the failure info for this login */
1759 spin_unlock(&ls
->lock
);
1763 if (status_class
== ISCSI_STATUS_CLS_SUCCESS
)
1765 else if (status_class
== ISCSI_STATUS_CLS_REDIRECT
) {
1767 ls
->last_fail_type
= ISCSI_LOGIN_FAIL_REDIRECT
;
1768 } else if ((status_class
== ISCSI_STATUS_CLS_INITIATOR_ERR
) &&
1769 (status_detail
== ISCSI_LOGIN_STATUS_AUTH_FAILED
)) {
1770 ls
->authenticate_fails
++;
1771 ls
->last_fail_type
= ISCSI_LOGIN_FAIL_AUTHENTICATE
;
1772 } else if ((status_class
== ISCSI_STATUS_CLS_INITIATOR_ERR
) &&
1773 (status_detail
== ISCSI_LOGIN_STATUS_TGT_FORBIDDEN
)) {
1774 ls
->authorize_fails
++;
1775 ls
->last_fail_type
= ISCSI_LOGIN_FAIL_AUTHORIZE
;
1776 } else if ((status_class
== ISCSI_STATUS_CLS_INITIATOR_ERR
) &&
1777 (status_detail
== ISCSI_LOGIN_STATUS_INIT_ERR
)) {
1778 ls
->negotiate_fails
++;
1779 ls
->last_fail_type
= ISCSI_LOGIN_FAIL_NEGOTIATE
;
1782 ls
->last_fail_type
= ISCSI_LOGIN_FAIL_OTHER
;
1785 /* Save initiator name, ip address and time, if it is a failed login */
1786 if (status_class
!= ISCSI_STATUS_CLS_SUCCESS
) {
1787 if (conn
->param_list
)
1788 intrname
= iscsi_find_param_from_key(INITIATORNAME
,
1790 strcpy(ls
->last_intr_fail_name
,
1791 (intrname
? intrname
->value
: "Unknown"));
1793 ls
->last_intr_fail_ip_family
= conn
->sock
->sk
->sk_family
;
1794 snprintf(ls
->last_intr_fail_ip_addr
, IPV6_ADDRESS_SPACE
,
1795 "%s", conn
->login_ip
);
1796 ls
->last_fail_time
= get_jiffies_64();
1799 spin_unlock(&ls
->lock
);
1802 struct iscsi_tiqn
*iscsit_snmp_get_tiqn(struct iscsi_conn
*conn
)
1804 struct iscsi_portal_group
*tpg
;
1806 if (!conn
|| !conn
->sess
)
1809 tpg
= conn
->sess
->tpg
;
1816 return tpg
->tpg_tiqn
;