Loading...
1/*******************************************************************************
2 * This file contains the iSCSI Target specific Task Management functions.
3 *
4 * \u00a9 Copyright 2007-2011 RisingTide Systems LLC.
5 *
6 * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
7 *
8 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
9 *
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.
14 *
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 ******************************************************************************/
20
21#include <asm/unaligned.h>
22#include <scsi/iscsi_proto.h>
23#include <target/target_core_base.h>
24#include <target/target_core_transport.h>
25
26#include "iscsi_target_core.h"
27#include "iscsi_target_seq_pdu_list.h"
28#include "iscsi_target_datain_values.h"
29#include "iscsi_target_device.h"
30#include "iscsi_target_erl0.h"
31#include "iscsi_target_erl1.h"
32#include "iscsi_target_erl2.h"
33#include "iscsi_target_tmr.h"
34#include "iscsi_target_tpg.h"
35#include "iscsi_target_util.h"
36#include "iscsi_target.h"
37
38u8 iscsit_tmr_abort_task(
39 struct iscsi_cmd *cmd,
40 unsigned char *buf)
41{
42 struct iscsi_cmd *ref_cmd;
43 struct iscsi_conn *conn = cmd->conn;
44 struct iscsi_tmr_req *tmr_req = cmd->tmr_req;
45 struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
46 struct iscsi_tm *hdr = (struct iscsi_tm *) buf;
47
48 ref_cmd = iscsit_find_cmd_from_itt(conn, hdr->rtt);
49 if (!ref_cmd) {
50 pr_err("Unable to locate RefTaskTag: 0x%08x on CID:"
51 " %hu.\n", hdr->rtt, conn->cid);
52 return ((hdr->refcmdsn >= conn->sess->exp_cmd_sn) &&
53 (hdr->refcmdsn <= conn->sess->max_cmd_sn)) ?
54 ISCSI_TMF_RSP_COMPLETE : ISCSI_TMF_RSP_NO_TASK;
55 }
56 if (ref_cmd->cmd_sn != hdr->refcmdsn) {
57 pr_err("RefCmdSN 0x%08x does not equal"
58 " task's CmdSN 0x%08x. Rejecting ABORT_TASK.\n",
59 hdr->refcmdsn, ref_cmd->cmd_sn);
60 return ISCSI_TMF_RSP_REJECTED;
61 }
62
63 se_tmr->ref_task_tag = hdr->rtt;
64 se_tmr->ref_cmd = &ref_cmd->se_cmd;
65 tmr_req->ref_cmd_sn = hdr->refcmdsn;
66 tmr_req->exp_data_sn = hdr->exp_datasn;
67
68 return ISCSI_TMF_RSP_COMPLETE;
69}
70
71/*
72 * Called from iscsit_handle_task_mgt_cmd().
73 */
74int iscsit_tmr_task_warm_reset(
75 struct iscsi_conn *conn,
76 struct iscsi_tmr_req *tmr_req,
77 unsigned char *buf)
78{
79 struct iscsi_session *sess = conn->sess;
80 struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
81#if 0
82 struct iscsi_init_task_mgt_cmnd *hdr =
83 (struct iscsi_init_task_mgt_cmnd *) buf;
84#endif
85 if (!na->tmr_warm_reset) {
86 pr_err("TMR Opcode TARGET_WARM_RESET authorization"
87 " failed for Initiator Node: %s\n",
88 sess->se_sess->se_node_acl->initiatorname);
89 return -1;
90 }
91 /*
92 * Do the real work in transport_generic_do_tmr().
93 */
94 return 0;
95}
96
97int iscsit_tmr_task_cold_reset(
98 struct iscsi_conn *conn,
99 struct iscsi_tmr_req *tmr_req,
100 unsigned char *buf)
101{
102 struct iscsi_session *sess = conn->sess;
103 struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
104
105 if (!na->tmr_cold_reset) {
106 pr_err("TMR Opcode TARGET_COLD_RESET authorization"
107 " failed for Initiator Node: %s\n",
108 sess->se_sess->se_node_acl->initiatorname);
109 return -1;
110 }
111 /*
112 * Do the real work in transport_generic_do_tmr().
113 */
114 return 0;
115}
116
117u8 iscsit_tmr_task_reassign(
118 struct iscsi_cmd *cmd,
119 unsigned char *buf)
120{
121 struct iscsi_cmd *ref_cmd = NULL;
122 struct iscsi_conn *conn = cmd->conn;
123 struct iscsi_conn_recovery *cr = NULL;
124 struct iscsi_tmr_req *tmr_req = cmd->tmr_req;
125 struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
126 struct iscsi_tm *hdr = (struct iscsi_tm *) buf;
127 int ret;
128
129 pr_debug("Got TASK_REASSIGN TMR ITT: 0x%08x,"
130 " RefTaskTag: 0x%08x, ExpDataSN: 0x%08x, CID: %hu\n",
131 hdr->itt, hdr->rtt, hdr->exp_datasn, conn->cid);
132
133 if (conn->sess->sess_ops->ErrorRecoveryLevel != 2) {
134 pr_err("TMR TASK_REASSIGN not supported in ERL<2,"
135 " ignoring request.\n");
136 return ISCSI_TMF_RSP_NOT_SUPPORTED;
137 }
138
139 ret = iscsit_find_cmd_for_recovery(conn->sess, &ref_cmd, &cr, hdr->rtt);
140 if (ret == -2) {
141 pr_err("Command ITT: 0x%08x is still alligent to CID:"
142 " %hu\n", ref_cmd->init_task_tag, cr->cid);
143 return ISCSI_TMF_RSP_TASK_ALLEGIANT;
144 } else if (ret == -1) {
145 pr_err("Unable to locate RefTaskTag: 0x%08x in"
146 " connection recovery command list.\n", hdr->rtt);
147 return ISCSI_TMF_RSP_NO_TASK;
148 }
149 /*
150 * Temporary check to prevent connection recovery for
151 * connections with a differing MaxRecvDataSegmentLength.
152 */
153 if (cr->maxrecvdatasegmentlength !=
154 conn->conn_ops->MaxRecvDataSegmentLength) {
155 pr_err("Unable to perform connection recovery for"
156 " differing MaxRecvDataSegmentLength, rejecting"
157 " TMR TASK_REASSIGN.\n");
158 return ISCSI_TMF_RSP_REJECTED;
159 }
160
161 se_tmr->ref_task_tag = hdr->rtt;
162 se_tmr->ref_cmd = &ref_cmd->se_cmd;
163 se_tmr->ref_task_lun = get_unaligned_le64(&hdr->lun);
164 tmr_req->ref_cmd_sn = hdr->refcmdsn;
165 tmr_req->exp_data_sn = hdr->exp_datasn;
166 tmr_req->conn_recovery = cr;
167 tmr_req->task_reassign = 1;
168 /*
169 * Command can now be reassigned to a new connection.
170 * The task management response must be sent before the
171 * reassignment actually happens. See iscsi_tmr_post_handler().
172 */
173 return ISCSI_TMF_RSP_COMPLETE;
174}
175
176static void iscsit_task_reassign_remove_cmd(
177 struct iscsi_cmd *cmd,
178 struct iscsi_conn_recovery *cr,
179 struct iscsi_session *sess)
180{
181 int ret;
182
183 spin_lock(&cr->conn_recovery_cmd_lock);
184 ret = iscsit_remove_cmd_from_connection_recovery(cmd, sess);
185 spin_unlock(&cr->conn_recovery_cmd_lock);
186 if (!ret) {
187 pr_debug("iSCSI connection recovery successful for CID:"
188 " %hu on SID: %u\n", cr->cid, sess->sid);
189 iscsit_remove_active_connection_recovery_entry(cr, sess);
190 }
191}
192
193static int iscsit_task_reassign_complete_nop_out(
194 struct iscsi_tmr_req *tmr_req,
195 struct iscsi_conn *conn)
196{
197 struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
198 struct se_cmd *se_cmd = se_tmr->ref_cmd;
199 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
200 struct iscsi_conn_recovery *cr;
201
202 if (!cmd->cr) {
203 pr_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
204 " is NULL!\n", cmd->init_task_tag);
205 return -1;
206 }
207 cr = cmd->cr;
208
209 /*
210 * Reset the StatSN so a new one for this commands new connection
211 * will be assigned.
212 * Reset the ExpStatSN as well so we may receive Status SNACKs.
213 */
214 cmd->stat_sn = cmd->exp_stat_sn = 0;
215
216 iscsit_task_reassign_remove_cmd(cmd, cr, conn->sess);
217
218 spin_lock_bh(&conn->cmd_lock);
219 list_add_tail(&cmd->i_list, &conn->conn_cmd_list);
220 spin_unlock_bh(&conn->cmd_lock);
221
222 cmd->i_state = ISTATE_SEND_NOPIN;
223 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
224 return 0;
225}
226
227static int iscsit_task_reassign_complete_write(
228 struct iscsi_cmd *cmd,
229 struct iscsi_tmr_req *tmr_req)
230{
231 int no_build_r2ts = 0;
232 u32 length = 0, offset = 0;
233 struct iscsi_conn *conn = cmd->conn;
234 struct se_cmd *se_cmd = &cmd->se_cmd;
235 /*
236 * The Initiator must not send a R2T SNACK with a Begrun less than
237 * the TMR TASK_REASSIGN's ExpDataSN.
238 */
239 if (!tmr_req->exp_data_sn) {
240 cmd->cmd_flags &= ~ICF_GOT_DATACK_SNACK;
241 cmd->acked_data_sn = 0;
242 } else {
243 cmd->cmd_flags |= ICF_GOT_DATACK_SNACK;
244 cmd->acked_data_sn = (tmr_req->exp_data_sn - 1);
245 }
246
247 /*
248 * The TMR TASK_REASSIGN's ExpDataSN contains the next R2TSN the
249 * Initiator is expecting. The Target controls all WRITE operations
250 * so if we have received all DataOUT we can safety ignore Initiator.
251 */
252 if (cmd->cmd_flags & ICF_GOT_LAST_DATAOUT) {
253 if (!atomic_read(&cmd->transport_sent)) {
254 pr_debug("WRITE ITT: 0x%08x: t_state: %d"
255 " never sent to transport\n",
256 cmd->init_task_tag, cmd->se_cmd.t_state);
257 return transport_generic_handle_data(se_cmd);
258 }
259
260 cmd->i_state = ISTATE_SEND_STATUS;
261 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
262 return 0;
263 }
264
265 /*
266 * Special case to deal with DataSequenceInOrder=No and Non-Immeidate
267 * Unsolicited DataOut.
268 */
269 if (cmd->unsolicited_data) {
270 cmd->unsolicited_data = 0;
271
272 offset = cmd->next_burst_len = cmd->write_data_done;
273
274 if ((conn->sess->sess_ops->FirstBurstLength - offset) >=
275 cmd->data_length) {
276 no_build_r2ts = 1;
277 length = (cmd->data_length - offset);
278 } else
279 length = (conn->sess->sess_ops->FirstBurstLength - offset);
280
281 spin_lock_bh(&cmd->r2t_lock);
282 if (iscsit_add_r2t_to_list(cmd, offset, length, 0, 0) < 0) {
283 spin_unlock_bh(&cmd->r2t_lock);
284 return -1;
285 }
286 cmd->outstanding_r2ts++;
287 spin_unlock_bh(&cmd->r2t_lock);
288
289 if (no_build_r2ts)
290 return 0;
291 }
292 /*
293 * iscsit_build_r2ts_for_cmd() can handle the rest from here.
294 */
295 return iscsit_build_r2ts_for_cmd(cmd, conn, 2);
296}
297
298static int iscsit_task_reassign_complete_read(
299 struct iscsi_cmd *cmd,
300 struct iscsi_tmr_req *tmr_req)
301{
302 struct iscsi_conn *conn = cmd->conn;
303 struct iscsi_datain_req *dr;
304 struct se_cmd *se_cmd = &cmd->se_cmd;
305 /*
306 * The Initiator must not send a Data SNACK with a BegRun less than
307 * the TMR TASK_REASSIGN's ExpDataSN.
308 */
309 if (!tmr_req->exp_data_sn) {
310 cmd->cmd_flags &= ~ICF_GOT_DATACK_SNACK;
311 cmd->acked_data_sn = 0;
312 } else {
313 cmd->cmd_flags |= ICF_GOT_DATACK_SNACK;
314 cmd->acked_data_sn = (tmr_req->exp_data_sn - 1);
315 }
316
317 if (!atomic_read(&cmd->transport_sent)) {
318 pr_debug("READ ITT: 0x%08x: t_state: %d never sent to"
319 " transport\n", cmd->init_task_tag,
320 cmd->se_cmd.t_state);
321 transport_generic_handle_cdb(se_cmd);
322 return 0;
323 }
324
325 if (!atomic_read(&se_cmd->t_transport_complete)) {
326 pr_err("READ ITT: 0x%08x: t_state: %d, never returned"
327 " from transport\n", cmd->init_task_tag,
328 cmd->se_cmd.t_state);
329 return -1;
330 }
331
332 dr = iscsit_allocate_datain_req();
333 if (!dr)
334 return -1;
335 /*
336 * The TMR TASK_REASSIGN's ExpDataSN contains the next DataSN the
337 * Initiator is expecting.
338 */
339 dr->data_sn = dr->begrun = tmr_req->exp_data_sn;
340 dr->runlength = 0;
341 dr->generate_recovery_values = 1;
342 dr->recovery = DATAIN_CONNECTION_RECOVERY;
343
344 iscsit_attach_datain_req(cmd, dr);
345
346 cmd->i_state = ISTATE_SEND_DATAIN;
347 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
348 return 0;
349}
350
351static int iscsit_task_reassign_complete_none(
352 struct iscsi_cmd *cmd,
353 struct iscsi_tmr_req *tmr_req)
354{
355 struct iscsi_conn *conn = cmd->conn;
356
357 cmd->i_state = ISTATE_SEND_STATUS;
358 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
359 return 0;
360}
361
362static int iscsit_task_reassign_complete_scsi_cmnd(
363 struct iscsi_tmr_req *tmr_req,
364 struct iscsi_conn *conn)
365{
366 struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
367 struct se_cmd *se_cmd = se_tmr->ref_cmd;
368 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
369 struct iscsi_conn_recovery *cr;
370
371 if (!cmd->cr) {
372 pr_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
373 " is NULL!\n", cmd->init_task_tag);
374 return -1;
375 }
376 cr = cmd->cr;
377
378 /*
379 * Reset the StatSN so a new one for this commands new connection
380 * will be assigned.
381 * Reset the ExpStatSN as well so we may receive Status SNACKs.
382 */
383 cmd->stat_sn = cmd->exp_stat_sn = 0;
384
385 iscsit_task_reassign_remove_cmd(cmd, cr, conn->sess);
386
387 spin_lock_bh(&conn->cmd_lock);
388 list_add_tail(&cmd->i_list, &conn->conn_cmd_list);
389 spin_unlock_bh(&conn->cmd_lock);
390
391 if (se_cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION) {
392 cmd->i_state = ISTATE_SEND_STATUS;
393 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
394 return 0;
395 }
396
397 switch (cmd->data_direction) {
398 case DMA_TO_DEVICE:
399 return iscsit_task_reassign_complete_write(cmd, tmr_req);
400 case DMA_FROM_DEVICE:
401 return iscsit_task_reassign_complete_read(cmd, tmr_req);
402 case DMA_NONE:
403 return iscsit_task_reassign_complete_none(cmd, tmr_req);
404 default:
405 pr_err("Unknown cmd->data_direction: 0x%02x\n",
406 cmd->data_direction);
407 return -1;
408 }
409
410 return 0;
411}
412
413static int iscsit_task_reassign_complete(
414 struct iscsi_tmr_req *tmr_req,
415 struct iscsi_conn *conn)
416{
417 struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
418 struct se_cmd *se_cmd;
419 struct iscsi_cmd *cmd;
420 int ret = 0;
421
422 if (!se_tmr->ref_cmd) {
423 pr_err("TMR Request is missing a RefCmd struct iscsi_cmd.\n");
424 return -1;
425 }
426 se_cmd = se_tmr->ref_cmd;
427 cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
428
429 cmd->conn = conn;
430
431 switch (cmd->iscsi_opcode) {
432 case ISCSI_OP_NOOP_OUT:
433 ret = iscsit_task_reassign_complete_nop_out(tmr_req, conn);
434 break;
435 case ISCSI_OP_SCSI_CMD:
436 ret = iscsit_task_reassign_complete_scsi_cmnd(tmr_req, conn);
437 break;
438 default:
439 pr_err("Illegal iSCSI Opcode 0x%02x during"
440 " command realligence\n", cmd->iscsi_opcode);
441 return -1;
442 }
443
444 if (ret != 0)
445 return ret;
446
447 pr_debug("Completed connection realligence for Opcode: 0x%02x,"
448 " ITT: 0x%08x to CID: %hu.\n", cmd->iscsi_opcode,
449 cmd->init_task_tag, conn->cid);
450
451 return 0;
452}
453
454/*
455 * Handles special after-the-fact actions related to TMRs.
456 * Right now the only one that its really needed for is
457 * connection recovery releated TASK_REASSIGN.
458 */
459extern int iscsit_tmr_post_handler(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
460{
461 struct iscsi_tmr_req *tmr_req = cmd->tmr_req;
462 struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
463
464 if (tmr_req->task_reassign &&
465 (se_tmr->response == ISCSI_TMF_RSP_COMPLETE))
466 return iscsit_task_reassign_complete(tmr_req, conn);
467
468 return 0;
469}
470
471/*
472 * Nothing to do here, but leave it for good measure. :-)
473 */
474int iscsit_task_reassign_prepare_read(
475 struct iscsi_tmr_req *tmr_req,
476 struct iscsi_conn *conn)
477{
478 return 0;
479}
480
481static void iscsit_task_reassign_prepare_unsolicited_dataout(
482 struct iscsi_cmd *cmd,
483 struct iscsi_conn *conn)
484{
485 int i, j;
486 struct iscsi_pdu *pdu = NULL;
487 struct iscsi_seq *seq = NULL;
488
489 if (conn->sess->sess_ops->DataSequenceInOrder) {
490 cmd->data_sn = 0;
491
492 if (cmd->immediate_data)
493 cmd->r2t_offset += (cmd->first_burst_len -
494 cmd->seq_start_offset);
495
496 if (conn->sess->sess_ops->DataPDUInOrder) {
497 cmd->write_data_done -= (cmd->immediate_data) ?
498 (cmd->first_burst_len -
499 cmd->seq_start_offset) :
500 cmd->first_burst_len;
501 cmd->first_burst_len = 0;
502 return;
503 }
504
505 for (i = 0; i < cmd->pdu_count; i++) {
506 pdu = &cmd->pdu_list[i];
507
508 if (pdu->status != ISCSI_PDU_RECEIVED_OK)
509 continue;
510
511 if ((pdu->offset >= cmd->seq_start_offset) &&
512 ((pdu->offset + pdu->length) <=
513 cmd->seq_end_offset)) {
514 cmd->first_burst_len -= pdu->length;
515 cmd->write_data_done -= pdu->length;
516 pdu->status = ISCSI_PDU_NOT_RECEIVED;
517 }
518 }
519 } else {
520 for (i = 0; i < cmd->seq_count; i++) {
521 seq = &cmd->seq_list[i];
522
523 if (seq->type != SEQTYPE_UNSOLICITED)
524 continue;
525
526 cmd->write_data_done -=
527 (seq->offset - seq->orig_offset);
528 cmd->first_burst_len = 0;
529 seq->data_sn = 0;
530 seq->offset = seq->orig_offset;
531 seq->next_burst_len = 0;
532 seq->status = DATAOUT_SEQUENCE_WITHIN_COMMAND_RECOVERY;
533
534 if (conn->sess->sess_ops->DataPDUInOrder)
535 continue;
536
537 for (j = 0; j < seq->pdu_count; j++) {
538 pdu = &cmd->pdu_list[j+seq->pdu_start];
539
540 if (pdu->status != ISCSI_PDU_RECEIVED_OK)
541 continue;
542
543 pdu->status = ISCSI_PDU_NOT_RECEIVED;
544 }
545 }
546 }
547}
548
549int iscsit_task_reassign_prepare_write(
550 struct iscsi_tmr_req *tmr_req,
551 struct iscsi_conn *conn)
552{
553 struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
554 struct se_cmd *se_cmd = se_tmr->ref_cmd;
555 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
556 struct iscsi_pdu *pdu = NULL;
557 struct iscsi_r2t *r2t = NULL, *r2t_tmp;
558 int first_incomplete_r2t = 1, i = 0;
559
560 /*
561 * The command was in the process of receiving Unsolicited DataOUT when
562 * the connection failed.
563 */
564 if (cmd->unsolicited_data)
565 iscsit_task_reassign_prepare_unsolicited_dataout(cmd, conn);
566
567 /*
568 * The Initiator is requesting R2Ts starting from zero, skip
569 * checking acknowledged R2Ts and start checking struct iscsi_r2ts
570 * greater than zero.
571 */
572 if (!tmr_req->exp_data_sn)
573 goto drop_unacknowledged_r2ts;
574
575 /*
576 * We now check that the PDUs in DataOUT sequences below
577 * the TMR TASK_REASSIGN ExpDataSN (R2TSN the Initiator is
578 * expecting next) have all the DataOUT they require to complete
579 * the DataOUT sequence. First scan from R2TSN 0 to TMR
580 * TASK_REASSIGN ExpDataSN-1.
581 *
582 * If we have not received all DataOUT in question, we must
583 * make sure to make the appropriate changes to values in
584 * struct iscsi_cmd (and elsewhere depending on session parameters)
585 * so iscsit_build_r2ts_for_cmd() in iscsit_task_reassign_complete_write()
586 * will resend a new R2T for the DataOUT sequences in question.
587 */
588 spin_lock_bh(&cmd->r2t_lock);
589 if (list_empty(&cmd->cmd_r2t_list)) {
590 spin_unlock_bh(&cmd->r2t_lock);
591 return -1;
592 }
593
594 list_for_each_entry(r2t, &cmd->cmd_r2t_list, r2t_list) {
595
596 if (r2t->r2t_sn >= tmr_req->exp_data_sn)
597 continue;
598 /*
599 * Safely ignore Recovery R2Ts and R2Ts that have completed
600 * DataOUT sequences.
601 */
602 if (r2t->seq_complete)
603 continue;
604
605 if (r2t->recovery_r2t)
606 continue;
607
608 /*
609 * DataSequenceInOrder=Yes:
610 *
611 * Taking into account the iSCSI implementation requirement of
612 * MaxOutstandingR2T=1 while ErrorRecoveryLevel>0 and
613 * DataSequenceInOrder=Yes, we must take into consideration
614 * the following:
615 *
616 * DataSequenceInOrder=No:
617 *
618 * Taking into account that the Initiator controls the (possibly
619 * random) PDU Order in (possibly random) Sequence Order of
620 * DataOUT the target requests with R2Ts, we must take into
621 * consideration the following:
622 *
623 * DataPDUInOrder=Yes for DataSequenceInOrder=[Yes,No]:
624 *
625 * While processing non-complete R2T DataOUT sequence requests
626 * the Target will re-request only the total sequence length
627 * minus current received offset. This is because we must
628 * assume the initiator will continue sending DataOUT from the
629 * last PDU before the connection failed.
630 *
631 * DataPDUInOrder=No for DataSequenceInOrder=[Yes,No]:
632 *
633 * While processing non-complete R2T DataOUT sequence requests
634 * the Target will re-request the entire DataOUT sequence if
635 * any single PDU is missing from the sequence. This is because
636 * we have no logical method to determine the next PDU offset,
637 * and we must assume the Initiator will be sending any random
638 * PDU offset in the current sequence after TASK_REASSIGN
639 * has completed.
640 */
641 if (conn->sess->sess_ops->DataSequenceInOrder) {
642 if (!first_incomplete_r2t) {
643 cmd->r2t_offset -= r2t->xfer_len;
644 goto next;
645 }
646
647 if (conn->sess->sess_ops->DataPDUInOrder) {
648 cmd->data_sn = 0;
649 cmd->r2t_offset -= (r2t->xfer_len -
650 cmd->next_burst_len);
651 first_incomplete_r2t = 0;
652 goto next;
653 }
654
655 cmd->data_sn = 0;
656 cmd->r2t_offset -= r2t->xfer_len;
657
658 for (i = 0; i < cmd->pdu_count; i++) {
659 pdu = &cmd->pdu_list[i];
660
661 if (pdu->status != ISCSI_PDU_RECEIVED_OK)
662 continue;
663
664 if ((pdu->offset >= r2t->offset) &&
665 (pdu->offset < (r2t->offset +
666 r2t->xfer_len))) {
667 cmd->next_burst_len -= pdu->length;
668 cmd->write_data_done -= pdu->length;
669 pdu->status = ISCSI_PDU_NOT_RECEIVED;
670 }
671 }
672
673 first_incomplete_r2t = 0;
674 } else {
675 struct iscsi_seq *seq;
676
677 seq = iscsit_get_seq_holder(cmd, r2t->offset,
678 r2t->xfer_len);
679 if (!seq) {
680 spin_unlock_bh(&cmd->r2t_lock);
681 return -1;
682 }
683
684 cmd->write_data_done -=
685 (seq->offset - seq->orig_offset);
686 seq->data_sn = 0;
687 seq->offset = seq->orig_offset;
688 seq->next_burst_len = 0;
689 seq->status = DATAOUT_SEQUENCE_WITHIN_COMMAND_RECOVERY;
690
691 cmd->seq_send_order--;
692
693 if (conn->sess->sess_ops->DataPDUInOrder)
694 goto next;
695
696 for (i = 0; i < seq->pdu_count; i++) {
697 pdu = &cmd->pdu_list[i+seq->pdu_start];
698
699 if (pdu->status != ISCSI_PDU_RECEIVED_OK)
700 continue;
701
702 pdu->status = ISCSI_PDU_NOT_RECEIVED;
703 }
704 }
705
706next:
707 cmd->outstanding_r2ts--;
708 }
709 spin_unlock_bh(&cmd->r2t_lock);
710
711 /*
712 * We now drop all unacknowledged R2Ts, ie: ExpDataSN from TMR
713 * TASK_REASSIGN to the last R2T in the list.. We are also careful
714 * to check that the Initiator is not requesting R2Ts for DataOUT
715 * sequences it has already completed.
716 *
717 * Free each R2T in question and adjust values in struct iscsi_cmd
718 * accordingly so iscsit_build_r2ts_for_cmd() do the rest of
719 * the work after the TMR TASK_REASSIGN Response is sent.
720 */
721drop_unacknowledged_r2ts:
722
723 cmd->cmd_flags &= ~ICF_SENT_LAST_R2T;
724 cmd->r2t_sn = tmr_req->exp_data_sn;
725
726 spin_lock_bh(&cmd->r2t_lock);
727 list_for_each_entry_safe(r2t, r2t_tmp, &cmd->cmd_r2t_list, r2t_list) {
728 /*
729 * Skip up to the R2T Sequence number provided by the
730 * iSCSI TASK_REASSIGN TMR
731 */
732 if (r2t->r2t_sn < tmr_req->exp_data_sn)
733 continue;
734
735 if (r2t->seq_complete) {
736 pr_err("Initiator is requesting R2Ts from"
737 " R2TSN: 0x%08x, but R2TSN: 0x%08x, Offset: %u,"
738 " Length: %u is already complete."
739 " BAD INITIATOR ERL=2 IMPLEMENTATION!\n",
740 tmr_req->exp_data_sn, r2t->r2t_sn,
741 r2t->offset, r2t->xfer_len);
742 spin_unlock_bh(&cmd->r2t_lock);
743 return -1;
744 }
745
746 if (r2t->recovery_r2t) {
747 iscsit_free_r2t(r2t, cmd);
748 continue;
749 }
750
751 /* DataSequenceInOrder=Yes:
752 *
753 * Taking into account the iSCSI implementation requirement of
754 * MaxOutstandingR2T=1 while ErrorRecoveryLevel>0 and
755 * DataSequenceInOrder=Yes, it's safe to subtract the R2Ts
756 * entire transfer length from the commands R2T offset marker.
757 *
758 * DataSequenceInOrder=No:
759 *
760 * We subtract the difference from struct iscsi_seq between the
761 * current offset and original offset from cmd->write_data_done
762 * for account for DataOUT PDUs already received. Then reset
763 * the current offset to the original and zero out the current
764 * burst length, to make sure we re-request the entire DataOUT
765 * sequence.
766 */
767 if (conn->sess->sess_ops->DataSequenceInOrder)
768 cmd->r2t_offset -= r2t->xfer_len;
769 else
770 cmd->seq_send_order--;
771
772 cmd->outstanding_r2ts--;
773 iscsit_free_r2t(r2t, cmd);
774 }
775 spin_unlock_bh(&cmd->r2t_lock);
776
777 return 0;
778}
779
780/*
781 * Performs sanity checks TMR TASK_REASSIGN's ExpDataSN for
782 * a given struct iscsi_cmd.
783 */
784int iscsit_check_task_reassign_expdatasn(
785 struct iscsi_tmr_req *tmr_req,
786 struct iscsi_conn *conn)
787{
788 struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
789 struct se_cmd *se_cmd = se_tmr->ref_cmd;
790 struct iscsi_cmd *ref_cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
791
792 if (ref_cmd->iscsi_opcode != ISCSI_OP_SCSI_CMD)
793 return 0;
794
795 if (se_cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION)
796 return 0;
797
798 if (ref_cmd->data_direction == DMA_NONE)
799 return 0;
800
801 /*
802 * For READs the TMR TASK_REASSIGNs ExpDataSN contains the next DataSN
803 * of DataIN the Initiator is expecting.
804 *
805 * Also check that the Initiator is not re-requesting DataIN that has
806 * already been acknowledged with a DataAck SNACK.
807 */
808 if (ref_cmd->data_direction == DMA_FROM_DEVICE) {
809 if (tmr_req->exp_data_sn > ref_cmd->data_sn) {
810 pr_err("Received ExpDataSN: 0x%08x for READ"
811 " in TMR TASK_REASSIGN greater than command's"
812 " DataSN: 0x%08x.\n", tmr_req->exp_data_sn,
813 ref_cmd->data_sn);
814 return -1;
815 }
816 if ((ref_cmd->cmd_flags & ICF_GOT_DATACK_SNACK) &&
817 (tmr_req->exp_data_sn <= ref_cmd->acked_data_sn)) {
818 pr_err("Received ExpDataSN: 0x%08x for READ"
819 " in TMR TASK_REASSIGN for previously"
820 " acknowledged DataIN: 0x%08x,"
821 " protocol error\n", tmr_req->exp_data_sn,
822 ref_cmd->acked_data_sn);
823 return -1;
824 }
825 return iscsit_task_reassign_prepare_read(tmr_req, conn);
826 }
827
828 /*
829 * For WRITEs the TMR TASK_REASSIGNs ExpDataSN contains the next R2TSN
830 * for R2Ts the Initiator is expecting.
831 *
832 * Do the magic in iscsit_task_reassign_prepare_write().
833 */
834 if (ref_cmd->data_direction == DMA_TO_DEVICE) {
835 if (tmr_req->exp_data_sn > ref_cmd->r2t_sn) {
836 pr_err("Received ExpDataSN: 0x%08x for WRITE"
837 " in TMR TASK_REASSIGN greater than command's"
838 " R2TSN: 0x%08x.\n", tmr_req->exp_data_sn,
839 ref_cmd->r2t_sn);
840 return -1;
841 }
842 return iscsit_task_reassign_prepare_write(tmr_req, conn);
843 }
844
845 pr_err("Unknown iSCSI data_direction: 0x%02x\n",
846 ref_cmd->data_direction);
847
848 return -1;
849}
1/*******************************************************************************
2 * This file contains the iSCSI Target specific Task Management functions.
3 *
4 * \u00a9 Copyright 2007-2011 RisingTide Systems LLC.
5 *
6 * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
7 *
8 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
9 *
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.
14 *
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 ******************************************************************************/
20
21#include <asm/unaligned.h>
22#include <scsi/iscsi_proto.h>
23#include <target/target_core_base.h>
24#include <target/target_core_fabric.h>
25
26#include "iscsi_target_core.h"
27#include "iscsi_target_seq_pdu_list.h"
28#include "iscsi_target_datain_values.h"
29#include "iscsi_target_device.h"
30#include "iscsi_target_erl0.h"
31#include "iscsi_target_erl1.h"
32#include "iscsi_target_erl2.h"
33#include "iscsi_target_tmr.h"
34#include "iscsi_target_tpg.h"
35#include "iscsi_target_util.h"
36#include "iscsi_target.h"
37
38u8 iscsit_tmr_abort_task(
39 struct iscsi_cmd *cmd,
40 unsigned char *buf)
41{
42 struct iscsi_cmd *ref_cmd;
43 struct iscsi_conn *conn = cmd->conn;
44 struct iscsi_tmr_req *tmr_req = cmd->tmr_req;
45 struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
46 struct iscsi_tm *hdr = (struct iscsi_tm *) buf;
47
48 ref_cmd = iscsit_find_cmd_from_itt(conn, hdr->rtt);
49 if (!ref_cmd) {
50 pr_err("Unable to locate RefTaskTag: 0x%08x on CID:"
51 " %hu.\n", hdr->rtt, conn->cid);
52 return ((hdr->refcmdsn >= conn->sess->exp_cmd_sn) &&
53 (hdr->refcmdsn <= conn->sess->max_cmd_sn)) ?
54 ISCSI_TMF_RSP_COMPLETE : ISCSI_TMF_RSP_NO_TASK;
55 }
56 if (ref_cmd->cmd_sn != hdr->refcmdsn) {
57 pr_err("RefCmdSN 0x%08x does not equal"
58 " task's CmdSN 0x%08x. Rejecting ABORT_TASK.\n",
59 hdr->refcmdsn, ref_cmd->cmd_sn);
60 return ISCSI_TMF_RSP_REJECTED;
61 }
62
63 se_tmr->ref_task_tag = hdr->rtt;
64 se_tmr->ref_cmd = &ref_cmd->se_cmd;
65 tmr_req->ref_cmd_sn = hdr->refcmdsn;
66 tmr_req->exp_data_sn = hdr->exp_datasn;
67
68 return ISCSI_TMF_RSP_COMPLETE;
69}
70
71/*
72 * Called from iscsit_handle_task_mgt_cmd().
73 */
74int iscsit_tmr_task_warm_reset(
75 struct iscsi_conn *conn,
76 struct iscsi_tmr_req *tmr_req,
77 unsigned char *buf)
78{
79 struct iscsi_session *sess = conn->sess;
80 struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
81
82 if (!na->tmr_warm_reset) {
83 pr_err("TMR Opcode TARGET_WARM_RESET authorization"
84 " failed for Initiator Node: %s\n",
85 sess->se_sess->se_node_acl->initiatorname);
86 return -1;
87 }
88 /*
89 * Do the real work in transport_generic_do_tmr().
90 */
91 return 0;
92}
93
94int iscsit_tmr_task_cold_reset(
95 struct iscsi_conn *conn,
96 struct iscsi_tmr_req *tmr_req,
97 unsigned char *buf)
98{
99 struct iscsi_session *sess = conn->sess;
100 struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
101
102 if (!na->tmr_cold_reset) {
103 pr_err("TMR Opcode TARGET_COLD_RESET authorization"
104 " failed for Initiator Node: %s\n",
105 sess->se_sess->se_node_acl->initiatorname);
106 return -1;
107 }
108 /*
109 * Do the real work in transport_generic_do_tmr().
110 */
111 return 0;
112}
113
114u8 iscsit_tmr_task_reassign(
115 struct iscsi_cmd *cmd,
116 unsigned char *buf)
117{
118 struct iscsi_cmd *ref_cmd = NULL;
119 struct iscsi_conn *conn = cmd->conn;
120 struct iscsi_conn_recovery *cr = NULL;
121 struct iscsi_tmr_req *tmr_req = cmd->tmr_req;
122 struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
123 struct iscsi_tm *hdr = (struct iscsi_tm *) buf;
124 int ret;
125
126 pr_debug("Got TASK_REASSIGN TMR ITT: 0x%08x,"
127 " RefTaskTag: 0x%08x, ExpDataSN: 0x%08x, CID: %hu\n",
128 hdr->itt, hdr->rtt, hdr->exp_datasn, conn->cid);
129
130 if (conn->sess->sess_ops->ErrorRecoveryLevel != 2) {
131 pr_err("TMR TASK_REASSIGN not supported in ERL<2,"
132 " ignoring request.\n");
133 return ISCSI_TMF_RSP_NOT_SUPPORTED;
134 }
135
136 ret = iscsit_find_cmd_for_recovery(conn->sess, &ref_cmd, &cr, hdr->rtt);
137 if (ret == -2) {
138 pr_err("Command ITT: 0x%08x is still alligent to CID:"
139 " %hu\n", ref_cmd->init_task_tag, cr->cid);
140 return ISCSI_TMF_RSP_TASK_ALLEGIANT;
141 } else if (ret == -1) {
142 pr_err("Unable to locate RefTaskTag: 0x%08x in"
143 " connection recovery command list.\n", hdr->rtt);
144 return ISCSI_TMF_RSP_NO_TASK;
145 }
146 /*
147 * Temporary check to prevent connection recovery for
148 * connections with a differing MaxRecvDataSegmentLength.
149 */
150 if (cr->maxrecvdatasegmentlength !=
151 conn->conn_ops->MaxRecvDataSegmentLength) {
152 pr_err("Unable to perform connection recovery for"
153 " differing MaxRecvDataSegmentLength, rejecting"
154 " TMR TASK_REASSIGN.\n");
155 return ISCSI_TMF_RSP_REJECTED;
156 }
157
158 se_tmr->ref_task_tag = hdr->rtt;
159 se_tmr->ref_cmd = &ref_cmd->se_cmd;
160 se_tmr->ref_task_lun = get_unaligned_le64(&hdr->lun);
161 tmr_req->ref_cmd_sn = hdr->refcmdsn;
162 tmr_req->exp_data_sn = hdr->exp_datasn;
163 tmr_req->conn_recovery = cr;
164 tmr_req->task_reassign = 1;
165 /*
166 * Command can now be reassigned to a new connection.
167 * The task management response must be sent before the
168 * reassignment actually happens. See iscsi_tmr_post_handler().
169 */
170 return ISCSI_TMF_RSP_COMPLETE;
171}
172
173static void iscsit_task_reassign_remove_cmd(
174 struct iscsi_cmd *cmd,
175 struct iscsi_conn_recovery *cr,
176 struct iscsi_session *sess)
177{
178 int ret;
179
180 spin_lock(&cr->conn_recovery_cmd_lock);
181 ret = iscsit_remove_cmd_from_connection_recovery(cmd, sess);
182 spin_unlock(&cr->conn_recovery_cmd_lock);
183 if (!ret) {
184 pr_debug("iSCSI connection recovery successful for CID:"
185 " %hu on SID: %u\n", cr->cid, sess->sid);
186 iscsit_remove_active_connection_recovery_entry(cr, sess);
187 }
188}
189
190static int iscsit_task_reassign_complete_nop_out(
191 struct iscsi_tmr_req *tmr_req,
192 struct iscsi_conn *conn)
193{
194 struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
195 struct se_cmd *se_cmd = se_tmr->ref_cmd;
196 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
197 struct iscsi_conn_recovery *cr;
198
199 if (!cmd->cr) {
200 pr_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
201 " is NULL!\n", cmd->init_task_tag);
202 return -1;
203 }
204 cr = cmd->cr;
205
206 /*
207 * Reset the StatSN so a new one for this commands new connection
208 * will be assigned.
209 * Reset the ExpStatSN as well so we may receive Status SNACKs.
210 */
211 cmd->stat_sn = cmd->exp_stat_sn = 0;
212
213 iscsit_task_reassign_remove_cmd(cmd, cr, conn->sess);
214
215 spin_lock_bh(&conn->cmd_lock);
216 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
217 spin_unlock_bh(&conn->cmd_lock);
218
219 cmd->i_state = ISTATE_SEND_NOPIN;
220 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
221 return 0;
222}
223
224static int iscsit_task_reassign_complete_write(
225 struct iscsi_cmd *cmd,
226 struct iscsi_tmr_req *tmr_req)
227{
228 int no_build_r2ts = 0;
229 u32 length = 0, offset = 0;
230 struct iscsi_conn *conn = cmd->conn;
231 struct se_cmd *se_cmd = &cmd->se_cmd;
232 /*
233 * The Initiator must not send a R2T SNACK with a Begrun less than
234 * the TMR TASK_REASSIGN's ExpDataSN.
235 */
236 if (!tmr_req->exp_data_sn) {
237 cmd->cmd_flags &= ~ICF_GOT_DATACK_SNACK;
238 cmd->acked_data_sn = 0;
239 } else {
240 cmd->cmd_flags |= ICF_GOT_DATACK_SNACK;
241 cmd->acked_data_sn = (tmr_req->exp_data_sn - 1);
242 }
243
244 /*
245 * The TMR TASK_REASSIGN's ExpDataSN contains the next R2TSN the
246 * Initiator is expecting. The Target controls all WRITE operations
247 * so if we have received all DataOUT we can safety ignore Initiator.
248 */
249 if (cmd->cmd_flags & ICF_GOT_LAST_DATAOUT) {
250 if (!(cmd->se_cmd.transport_state & CMD_T_SENT)) {
251 pr_debug("WRITE ITT: 0x%08x: t_state: %d"
252 " never sent to transport\n",
253 cmd->init_task_tag, cmd->se_cmd.t_state);
254 return transport_generic_handle_data(se_cmd);
255 }
256
257 cmd->i_state = ISTATE_SEND_STATUS;
258 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
259 return 0;
260 }
261
262 /*
263 * Special case to deal with DataSequenceInOrder=No and Non-Immeidate
264 * Unsolicited DataOut.
265 */
266 if (cmd->unsolicited_data) {
267 cmd->unsolicited_data = 0;
268
269 offset = cmd->next_burst_len = cmd->write_data_done;
270
271 if ((conn->sess->sess_ops->FirstBurstLength - offset) >=
272 cmd->se_cmd.data_length) {
273 no_build_r2ts = 1;
274 length = (cmd->se_cmd.data_length - offset);
275 } else
276 length = (conn->sess->sess_ops->FirstBurstLength - offset);
277
278 spin_lock_bh(&cmd->r2t_lock);
279 if (iscsit_add_r2t_to_list(cmd, offset, length, 0, 0) < 0) {
280 spin_unlock_bh(&cmd->r2t_lock);
281 return -1;
282 }
283 cmd->outstanding_r2ts++;
284 spin_unlock_bh(&cmd->r2t_lock);
285
286 if (no_build_r2ts)
287 return 0;
288 }
289 /*
290 * iscsit_build_r2ts_for_cmd() can handle the rest from here.
291 */
292 return iscsit_build_r2ts_for_cmd(cmd, conn, true);
293}
294
295static int iscsit_task_reassign_complete_read(
296 struct iscsi_cmd *cmd,
297 struct iscsi_tmr_req *tmr_req)
298{
299 struct iscsi_conn *conn = cmd->conn;
300 struct iscsi_datain_req *dr;
301 struct se_cmd *se_cmd = &cmd->se_cmd;
302 /*
303 * The Initiator must not send a Data SNACK with a BegRun less than
304 * the TMR TASK_REASSIGN's ExpDataSN.
305 */
306 if (!tmr_req->exp_data_sn) {
307 cmd->cmd_flags &= ~ICF_GOT_DATACK_SNACK;
308 cmd->acked_data_sn = 0;
309 } else {
310 cmd->cmd_flags |= ICF_GOT_DATACK_SNACK;
311 cmd->acked_data_sn = (tmr_req->exp_data_sn - 1);
312 }
313
314 if (!(cmd->se_cmd.transport_state & CMD_T_SENT)) {
315 pr_debug("READ ITT: 0x%08x: t_state: %d never sent to"
316 " transport\n", cmd->init_task_tag,
317 cmd->se_cmd.t_state);
318 transport_handle_cdb_direct(se_cmd);
319 return 0;
320 }
321
322 if (!(se_cmd->transport_state & CMD_T_COMPLETE)) {
323 pr_err("READ ITT: 0x%08x: t_state: %d, never returned"
324 " from transport\n", cmd->init_task_tag,
325 cmd->se_cmd.t_state);
326 return -1;
327 }
328
329 dr = iscsit_allocate_datain_req();
330 if (!dr)
331 return -1;
332 /*
333 * The TMR TASK_REASSIGN's ExpDataSN contains the next DataSN the
334 * Initiator is expecting.
335 */
336 dr->data_sn = dr->begrun = tmr_req->exp_data_sn;
337 dr->runlength = 0;
338 dr->generate_recovery_values = 1;
339 dr->recovery = DATAIN_CONNECTION_RECOVERY;
340
341 iscsit_attach_datain_req(cmd, dr);
342
343 cmd->i_state = ISTATE_SEND_DATAIN;
344 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
345 return 0;
346}
347
348static int iscsit_task_reassign_complete_none(
349 struct iscsi_cmd *cmd,
350 struct iscsi_tmr_req *tmr_req)
351{
352 struct iscsi_conn *conn = cmd->conn;
353
354 cmd->i_state = ISTATE_SEND_STATUS;
355 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
356 return 0;
357}
358
359static int iscsit_task_reassign_complete_scsi_cmnd(
360 struct iscsi_tmr_req *tmr_req,
361 struct iscsi_conn *conn)
362{
363 struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
364 struct se_cmd *se_cmd = se_tmr->ref_cmd;
365 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
366 struct iscsi_conn_recovery *cr;
367
368 if (!cmd->cr) {
369 pr_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
370 " is NULL!\n", cmd->init_task_tag);
371 return -1;
372 }
373 cr = cmd->cr;
374
375 /*
376 * Reset the StatSN so a new one for this commands new connection
377 * will be assigned.
378 * Reset the ExpStatSN as well so we may receive Status SNACKs.
379 */
380 cmd->stat_sn = cmd->exp_stat_sn = 0;
381
382 iscsit_task_reassign_remove_cmd(cmd, cr, conn->sess);
383
384 spin_lock_bh(&conn->cmd_lock);
385 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
386 spin_unlock_bh(&conn->cmd_lock);
387
388 if (se_cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION) {
389 cmd->i_state = ISTATE_SEND_STATUS;
390 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
391 return 0;
392 }
393
394 switch (cmd->data_direction) {
395 case DMA_TO_DEVICE:
396 return iscsit_task_reassign_complete_write(cmd, tmr_req);
397 case DMA_FROM_DEVICE:
398 return iscsit_task_reassign_complete_read(cmd, tmr_req);
399 case DMA_NONE:
400 return iscsit_task_reassign_complete_none(cmd, tmr_req);
401 default:
402 pr_err("Unknown cmd->data_direction: 0x%02x\n",
403 cmd->data_direction);
404 return -1;
405 }
406
407 return 0;
408}
409
410static int iscsit_task_reassign_complete(
411 struct iscsi_tmr_req *tmr_req,
412 struct iscsi_conn *conn)
413{
414 struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
415 struct se_cmd *se_cmd;
416 struct iscsi_cmd *cmd;
417 int ret = 0;
418
419 if (!se_tmr->ref_cmd) {
420 pr_err("TMR Request is missing a RefCmd struct iscsi_cmd.\n");
421 return -1;
422 }
423 se_cmd = se_tmr->ref_cmd;
424 cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
425
426 cmd->conn = conn;
427
428 switch (cmd->iscsi_opcode) {
429 case ISCSI_OP_NOOP_OUT:
430 ret = iscsit_task_reassign_complete_nop_out(tmr_req, conn);
431 break;
432 case ISCSI_OP_SCSI_CMD:
433 ret = iscsit_task_reassign_complete_scsi_cmnd(tmr_req, conn);
434 break;
435 default:
436 pr_err("Illegal iSCSI Opcode 0x%02x during"
437 " command realligence\n", cmd->iscsi_opcode);
438 return -1;
439 }
440
441 if (ret != 0)
442 return ret;
443
444 pr_debug("Completed connection realligence for Opcode: 0x%02x,"
445 " ITT: 0x%08x to CID: %hu.\n", cmd->iscsi_opcode,
446 cmd->init_task_tag, conn->cid);
447
448 return 0;
449}
450
451/*
452 * Handles special after-the-fact actions related to TMRs.
453 * Right now the only one that its really needed for is
454 * connection recovery releated TASK_REASSIGN.
455 */
456extern int iscsit_tmr_post_handler(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
457{
458 struct iscsi_tmr_req *tmr_req = cmd->tmr_req;
459 struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
460
461 if (tmr_req->task_reassign &&
462 (se_tmr->response == ISCSI_TMF_RSP_COMPLETE))
463 return iscsit_task_reassign_complete(tmr_req, conn);
464
465 return 0;
466}
467
468/*
469 * Nothing to do here, but leave it for good measure. :-)
470 */
471int iscsit_task_reassign_prepare_read(
472 struct iscsi_tmr_req *tmr_req,
473 struct iscsi_conn *conn)
474{
475 return 0;
476}
477
478static void iscsit_task_reassign_prepare_unsolicited_dataout(
479 struct iscsi_cmd *cmd,
480 struct iscsi_conn *conn)
481{
482 int i, j;
483 struct iscsi_pdu *pdu = NULL;
484 struct iscsi_seq *seq = NULL;
485
486 if (conn->sess->sess_ops->DataSequenceInOrder) {
487 cmd->data_sn = 0;
488
489 if (cmd->immediate_data)
490 cmd->r2t_offset += (cmd->first_burst_len -
491 cmd->seq_start_offset);
492
493 if (conn->sess->sess_ops->DataPDUInOrder) {
494 cmd->write_data_done -= (cmd->immediate_data) ?
495 (cmd->first_burst_len -
496 cmd->seq_start_offset) :
497 cmd->first_burst_len;
498 cmd->first_burst_len = 0;
499 return;
500 }
501
502 for (i = 0; i < cmd->pdu_count; i++) {
503 pdu = &cmd->pdu_list[i];
504
505 if (pdu->status != ISCSI_PDU_RECEIVED_OK)
506 continue;
507
508 if ((pdu->offset >= cmd->seq_start_offset) &&
509 ((pdu->offset + pdu->length) <=
510 cmd->seq_end_offset)) {
511 cmd->first_burst_len -= pdu->length;
512 cmd->write_data_done -= pdu->length;
513 pdu->status = ISCSI_PDU_NOT_RECEIVED;
514 }
515 }
516 } else {
517 for (i = 0; i < cmd->seq_count; i++) {
518 seq = &cmd->seq_list[i];
519
520 if (seq->type != SEQTYPE_UNSOLICITED)
521 continue;
522
523 cmd->write_data_done -=
524 (seq->offset - seq->orig_offset);
525 cmd->first_burst_len = 0;
526 seq->data_sn = 0;
527 seq->offset = seq->orig_offset;
528 seq->next_burst_len = 0;
529 seq->status = DATAOUT_SEQUENCE_WITHIN_COMMAND_RECOVERY;
530
531 if (conn->sess->sess_ops->DataPDUInOrder)
532 continue;
533
534 for (j = 0; j < seq->pdu_count; j++) {
535 pdu = &cmd->pdu_list[j+seq->pdu_start];
536
537 if (pdu->status != ISCSI_PDU_RECEIVED_OK)
538 continue;
539
540 pdu->status = ISCSI_PDU_NOT_RECEIVED;
541 }
542 }
543 }
544}
545
546int iscsit_task_reassign_prepare_write(
547 struct iscsi_tmr_req *tmr_req,
548 struct iscsi_conn *conn)
549{
550 struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
551 struct se_cmd *se_cmd = se_tmr->ref_cmd;
552 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
553 struct iscsi_pdu *pdu = NULL;
554 struct iscsi_r2t *r2t = NULL, *r2t_tmp;
555 int first_incomplete_r2t = 1, i = 0;
556
557 /*
558 * The command was in the process of receiving Unsolicited DataOUT when
559 * the connection failed.
560 */
561 if (cmd->unsolicited_data)
562 iscsit_task_reassign_prepare_unsolicited_dataout(cmd, conn);
563
564 /*
565 * The Initiator is requesting R2Ts starting from zero, skip
566 * checking acknowledged R2Ts and start checking struct iscsi_r2ts
567 * greater than zero.
568 */
569 if (!tmr_req->exp_data_sn)
570 goto drop_unacknowledged_r2ts;
571
572 /*
573 * We now check that the PDUs in DataOUT sequences below
574 * the TMR TASK_REASSIGN ExpDataSN (R2TSN the Initiator is
575 * expecting next) have all the DataOUT they require to complete
576 * the DataOUT sequence. First scan from R2TSN 0 to TMR
577 * TASK_REASSIGN ExpDataSN-1.
578 *
579 * If we have not received all DataOUT in question, we must
580 * make sure to make the appropriate changes to values in
581 * struct iscsi_cmd (and elsewhere depending on session parameters)
582 * so iscsit_build_r2ts_for_cmd() in iscsit_task_reassign_complete_write()
583 * will resend a new R2T for the DataOUT sequences in question.
584 */
585 spin_lock_bh(&cmd->r2t_lock);
586 if (list_empty(&cmd->cmd_r2t_list)) {
587 spin_unlock_bh(&cmd->r2t_lock);
588 return -1;
589 }
590
591 list_for_each_entry(r2t, &cmd->cmd_r2t_list, r2t_list) {
592
593 if (r2t->r2t_sn >= tmr_req->exp_data_sn)
594 continue;
595 /*
596 * Safely ignore Recovery R2Ts and R2Ts that have completed
597 * DataOUT sequences.
598 */
599 if (r2t->seq_complete)
600 continue;
601
602 if (r2t->recovery_r2t)
603 continue;
604
605 /*
606 * DataSequenceInOrder=Yes:
607 *
608 * Taking into account the iSCSI implementation requirement of
609 * MaxOutstandingR2T=1 while ErrorRecoveryLevel>0 and
610 * DataSequenceInOrder=Yes, we must take into consideration
611 * the following:
612 *
613 * DataSequenceInOrder=No:
614 *
615 * Taking into account that the Initiator controls the (possibly
616 * random) PDU Order in (possibly random) Sequence Order of
617 * DataOUT the target requests with R2Ts, we must take into
618 * consideration the following:
619 *
620 * DataPDUInOrder=Yes for DataSequenceInOrder=[Yes,No]:
621 *
622 * While processing non-complete R2T DataOUT sequence requests
623 * the Target will re-request only the total sequence length
624 * minus current received offset. This is because we must
625 * assume the initiator will continue sending DataOUT from the
626 * last PDU before the connection failed.
627 *
628 * DataPDUInOrder=No for DataSequenceInOrder=[Yes,No]:
629 *
630 * While processing non-complete R2T DataOUT sequence requests
631 * the Target will re-request the entire DataOUT sequence if
632 * any single PDU is missing from the sequence. This is because
633 * we have no logical method to determine the next PDU offset,
634 * and we must assume the Initiator will be sending any random
635 * PDU offset in the current sequence after TASK_REASSIGN
636 * has completed.
637 */
638 if (conn->sess->sess_ops->DataSequenceInOrder) {
639 if (!first_incomplete_r2t) {
640 cmd->r2t_offset -= r2t->xfer_len;
641 goto next;
642 }
643
644 if (conn->sess->sess_ops->DataPDUInOrder) {
645 cmd->data_sn = 0;
646 cmd->r2t_offset -= (r2t->xfer_len -
647 cmd->next_burst_len);
648 first_incomplete_r2t = 0;
649 goto next;
650 }
651
652 cmd->data_sn = 0;
653 cmd->r2t_offset -= r2t->xfer_len;
654
655 for (i = 0; i < cmd->pdu_count; i++) {
656 pdu = &cmd->pdu_list[i];
657
658 if (pdu->status != ISCSI_PDU_RECEIVED_OK)
659 continue;
660
661 if ((pdu->offset >= r2t->offset) &&
662 (pdu->offset < (r2t->offset +
663 r2t->xfer_len))) {
664 cmd->next_burst_len -= pdu->length;
665 cmd->write_data_done -= pdu->length;
666 pdu->status = ISCSI_PDU_NOT_RECEIVED;
667 }
668 }
669
670 first_incomplete_r2t = 0;
671 } else {
672 struct iscsi_seq *seq;
673
674 seq = iscsit_get_seq_holder(cmd, r2t->offset,
675 r2t->xfer_len);
676 if (!seq) {
677 spin_unlock_bh(&cmd->r2t_lock);
678 return -1;
679 }
680
681 cmd->write_data_done -=
682 (seq->offset - seq->orig_offset);
683 seq->data_sn = 0;
684 seq->offset = seq->orig_offset;
685 seq->next_burst_len = 0;
686 seq->status = DATAOUT_SEQUENCE_WITHIN_COMMAND_RECOVERY;
687
688 cmd->seq_send_order--;
689
690 if (conn->sess->sess_ops->DataPDUInOrder)
691 goto next;
692
693 for (i = 0; i < seq->pdu_count; i++) {
694 pdu = &cmd->pdu_list[i+seq->pdu_start];
695
696 if (pdu->status != ISCSI_PDU_RECEIVED_OK)
697 continue;
698
699 pdu->status = ISCSI_PDU_NOT_RECEIVED;
700 }
701 }
702
703next:
704 cmd->outstanding_r2ts--;
705 }
706 spin_unlock_bh(&cmd->r2t_lock);
707
708 /*
709 * We now drop all unacknowledged R2Ts, ie: ExpDataSN from TMR
710 * TASK_REASSIGN to the last R2T in the list.. We are also careful
711 * to check that the Initiator is not requesting R2Ts for DataOUT
712 * sequences it has already completed.
713 *
714 * Free each R2T in question and adjust values in struct iscsi_cmd
715 * accordingly so iscsit_build_r2ts_for_cmd() do the rest of
716 * the work after the TMR TASK_REASSIGN Response is sent.
717 */
718drop_unacknowledged_r2ts:
719
720 cmd->cmd_flags &= ~ICF_SENT_LAST_R2T;
721 cmd->r2t_sn = tmr_req->exp_data_sn;
722
723 spin_lock_bh(&cmd->r2t_lock);
724 list_for_each_entry_safe(r2t, r2t_tmp, &cmd->cmd_r2t_list, r2t_list) {
725 /*
726 * Skip up to the R2T Sequence number provided by the
727 * iSCSI TASK_REASSIGN TMR
728 */
729 if (r2t->r2t_sn < tmr_req->exp_data_sn)
730 continue;
731
732 if (r2t->seq_complete) {
733 pr_err("Initiator is requesting R2Ts from"
734 " R2TSN: 0x%08x, but R2TSN: 0x%08x, Offset: %u,"
735 " Length: %u is already complete."
736 " BAD INITIATOR ERL=2 IMPLEMENTATION!\n",
737 tmr_req->exp_data_sn, r2t->r2t_sn,
738 r2t->offset, r2t->xfer_len);
739 spin_unlock_bh(&cmd->r2t_lock);
740 return -1;
741 }
742
743 if (r2t->recovery_r2t) {
744 iscsit_free_r2t(r2t, cmd);
745 continue;
746 }
747
748 /* DataSequenceInOrder=Yes:
749 *
750 * Taking into account the iSCSI implementation requirement of
751 * MaxOutstandingR2T=1 while ErrorRecoveryLevel>0 and
752 * DataSequenceInOrder=Yes, it's safe to subtract the R2Ts
753 * entire transfer length from the commands R2T offset marker.
754 *
755 * DataSequenceInOrder=No:
756 *
757 * We subtract the difference from struct iscsi_seq between the
758 * current offset and original offset from cmd->write_data_done
759 * for account for DataOUT PDUs already received. Then reset
760 * the current offset to the original and zero out the current
761 * burst length, to make sure we re-request the entire DataOUT
762 * sequence.
763 */
764 if (conn->sess->sess_ops->DataSequenceInOrder)
765 cmd->r2t_offset -= r2t->xfer_len;
766 else
767 cmd->seq_send_order--;
768
769 cmd->outstanding_r2ts--;
770 iscsit_free_r2t(r2t, cmd);
771 }
772 spin_unlock_bh(&cmd->r2t_lock);
773
774 return 0;
775}
776
777/*
778 * Performs sanity checks TMR TASK_REASSIGN's ExpDataSN for
779 * a given struct iscsi_cmd.
780 */
781int iscsit_check_task_reassign_expdatasn(
782 struct iscsi_tmr_req *tmr_req,
783 struct iscsi_conn *conn)
784{
785 struct se_tmr_req *se_tmr = tmr_req->se_tmr_req;
786 struct se_cmd *se_cmd = se_tmr->ref_cmd;
787 struct iscsi_cmd *ref_cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
788
789 if (ref_cmd->iscsi_opcode != ISCSI_OP_SCSI_CMD)
790 return 0;
791
792 if (se_cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION)
793 return 0;
794
795 if (ref_cmd->data_direction == DMA_NONE)
796 return 0;
797
798 /*
799 * For READs the TMR TASK_REASSIGNs ExpDataSN contains the next DataSN
800 * of DataIN the Initiator is expecting.
801 *
802 * Also check that the Initiator is not re-requesting DataIN that has
803 * already been acknowledged with a DataAck SNACK.
804 */
805 if (ref_cmd->data_direction == DMA_FROM_DEVICE) {
806 if (tmr_req->exp_data_sn > ref_cmd->data_sn) {
807 pr_err("Received ExpDataSN: 0x%08x for READ"
808 " in TMR TASK_REASSIGN greater than command's"
809 " DataSN: 0x%08x.\n", tmr_req->exp_data_sn,
810 ref_cmd->data_sn);
811 return -1;
812 }
813 if ((ref_cmd->cmd_flags & ICF_GOT_DATACK_SNACK) &&
814 (tmr_req->exp_data_sn <= ref_cmd->acked_data_sn)) {
815 pr_err("Received ExpDataSN: 0x%08x for READ"
816 " in TMR TASK_REASSIGN for previously"
817 " acknowledged DataIN: 0x%08x,"
818 " protocol error\n", tmr_req->exp_data_sn,
819 ref_cmd->acked_data_sn);
820 return -1;
821 }
822 return iscsit_task_reassign_prepare_read(tmr_req, conn);
823 }
824
825 /*
826 * For WRITEs the TMR TASK_REASSIGNs ExpDataSN contains the next R2TSN
827 * for R2Ts the Initiator is expecting.
828 *
829 * Do the magic in iscsit_task_reassign_prepare_write().
830 */
831 if (ref_cmd->data_direction == DMA_TO_DEVICE) {
832 if (tmr_req->exp_data_sn > ref_cmd->r2t_sn) {
833 pr_err("Received ExpDataSN: 0x%08x for WRITE"
834 " in TMR TASK_REASSIGN greater than command's"
835 " R2TSN: 0x%08x.\n", tmr_req->exp_data_sn,
836 ref_cmd->r2t_sn);
837 return -1;
838 }
839 return iscsit_task_reassign_prepare_write(tmr_req, conn);
840 }
841
842 pr_err("Unknown iSCSI data_direction: 0x%02x\n",
843 ref_cmd->data_direction);
844
845 return -1;
846}