1 /******************************************************************************* 2 * This file contains error recovery level one used by the iSCSI Target driver. 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 <linux/list.h> 22 #include <scsi/iscsi_proto.h> 23 #include <target/target_core_base.h> 24 #include <target/target_core_fabric.h> 25 #include <target/iscsi/iscsi_transport.h> 26 27 #include "iscsi_target_core.h" 28 #include "iscsi_target_seq_pdu_list.h" 29 #include "iscsi_target_datain_values.h" 30 #include "iscsi_target_device.h" 31 #include "iscsi_target_tpg.h" 32 #include "iscsi_target_util.h" 33 #include "iscsi_target_erl0.h" 34 #include "iscsi_target_erl1.h" 35 #include "iscsi_target_erl2.h" 36 #include "iscsi_target.h" 37 38 #define OFFLOAD_BUF_SIZE 32768 39 40 /* 41 * Used to dump excess datain payload for certain error recovery 42 * situations. Receive in OFFLOAD_BUF_SIZE max of datain per rx_data(). 43 * 44 * dump_padding_digest denotes if padding and data digests need 45 * to be dumped. 46 */ 47 int iscsit_dump_data_payload( 48 struct iscsi_conn *conn, 49 u32 buf_len, 50 int dump_padding_digest) 51 { 52 char *buf, pad_bytes[4]; 53 int ret = DATAOUT_WITHIN_COMMAND_RECOVERY, rx_got; 54 u32 length, padding, offset = 0, size; 55 struct kvec iov; 56 57 if (conn->sess->sess_ops->RDMAExtensions) 58 return 0; 59 60 length = (buf_len > OFFLOAD_BUF_SIZE) ? OFFLOAD_BUF_SIZE : buf_len; 61 62 buf = kzalloc(length, GFP_ATOMIC); 63 if (!buf) { 64 pr_err("Unable to allocate %u bytes for offload" 65 " buffer.\n", length); 66 return -1; 67 } 68 memset(&iov, 0, sizeof(struct kvec)); 69 70 while (offset < buf_len) { 71 size = ((offset + length) > buf_len) ? 72 (buf_len - offset) : length; 73 74 iov.iov_len = size; 75 iov.iov_base = buf; 76 77 rx_got = rx_data(conn, &iov, 1, size); 78 if (rx_got != size) { 79 ret = DATAOUT_CANNOT_RECOVER; 80 goto out; 81 } 82 83 offset += size; 84 } 85 86 if (!dump_padding_digest) 87 goto out; 88 89 padding = ((-buf_len) & 3); 90 if (padding != 0) { 91 iov.iov_len = padding; 92 iov.iov_base = pad_bytes; 93 94 rx_got = rx_data(conn, &iov, 1, padding); 95 if (rx_got != padding) { 96 ret = DATAOUT_CANNOT_RECOVER; 97 goto out; 98 } 99 } 100 101 if (conn->conn_ops->DataDigest) { 102 u32 data_crc; 103 104 iov.iov_len = ISCSI_CRC_LEN; 105 iov.iov_base = &data_crc; 106 107 rx_got = rx_data(conn, &iov, 1, ISCSI_CRC_LEN); 108 if (rx_got != ISCSI_CRC_LEN) { 109 ret = DATAOUT_CANNOT_RECOVER; 110 goto out; 111 } 112 } 113 114 out: 115 kfree(buf); 116 return ret; 117 } 118 119 /* 120 * Used for retransmitting R2Ts from a R2T SNACK request. 121 */ 122 static int iscsit_send_recovery_r2t_for_snack( 123 struct iscsi_cmd *cmd, 124 struct iscsi_r2t *r2t) 125 { 126 /* 127 * If the struct iscsi_r2t has not been sent yet, we can safely 128 * ignore retransmission 129 * of the R2TSN in question. 130 */ 131 spin_lock_bh(&cmd->r2t_lock); 132 if (!r2t->sent_r2t) { 133 spin_unlock_bh(&cmd->r2t_lock); 134 return 0; 135 } 136 r2t->sent_r2t = 0; 137 spin_unlock_bh(&cmd->r2t_lock); 138 139 iscsit_add_cmd_to_immediate_queue(cmd, cmd->conn, ISTATE_SEND_R2T); 140 141 return 0; 142 } 143 144 static int iscsit_handle_r2t_snack( 145 struct iscsi_cmd *cmd, 146 unsigned char *buf, 147 u32 begrun, 148 u32 runlength) 149 { 150 u32 last_r2tsn; 151 struct iscsi_r2t *r2t; 152 153 /* 154 * Make sure the initiator is not requesting retransmission 155 * of R2TSNs already acknowledged by a TMR TASK_REASSIGN. 156 */ 157 if ((cmd->cmd_flags & ICF_GOT_DATACK_SNACK) && 158 (begrun <= cmd->acked_data_sn)) { 159 pr_err("ITT: 0x%08x, R2T SNACK requesting" 160 " retransmission of R2TSN: 0x%08x to 0x%08x but already" 161 " acked to R2TSN: 0x%08x by TMR TASK_REASSIGN," 162 " protocol error.\n", cmd->init_task_tag, begrun, 163 (begrun + runlength), cmd->acked_data_sn); 164 165 return iscsit_add_reject_from_cmd( 166 ISCSI_REASON_PROTOCOL_ERROR, 167 1, 0, buf, cmd); 168 } 169 170 if (runlength) { 171 if ((begrun + runlength) > cmd->r2t_sn) { 172 pr_err("Command ITT: 0x%08x received R2T SNACK" 173 " with BegRun: 0x%08x, RunLength: 0x%08x, exceeds" 174 " current R2TSN: 0x%08x, protocol error.\n", 175 cmd->init_task_tag, begrun, runlength, cmd->r2t_sn); 176 return iscsit_add_reject_from_cmd( 177 ISCSI_REASON_BOOKMARK_INVALID, 1, 0, buf, cmd); 178 } 179 last_r2tsn = (begrun + runlength); 180 } else 181 last_r2tsn = cmd->r2t_sn; 182 183 while (begrun < last_r2tsn) { 184 r2t = iscsit_get_holder_for_r2tsn(cmd, begrun); 185 if (!r2t) 186 return -1; 187 if (iscsit_send_recovery_r2t_for_snack(cmd, r2t) < 0) 188 return -1; 189 190 begrun++; 191 } 192 193 return 0; 194 } 195 196 /* 197 * Generates Offsets and NextBurstLength based on Begrun and Runlength 198 * carried in a Data SNACK or ExpDataSN in TMR TASK_REASSIGN. 199 * 200 * For DataSequenceInOrder=Yes and DataPDUInOrder=[Yes,No] only. 201 * 202 * FIXME: How is this handled for a RData SNACK? 203 */ 204 int iscsit_create_recovery_datain_values_datasequenceinorder_yes( 205 struct iscsi_cmd *cmd, 206 struct iscsi_datain_req *dr) 207 { 208 u32 data_sn = 0, data_sn_count = 0; 209 u32 pdu_start = 0, seq_no = 0; 210 u32 begrun = dr->begrun; 211 struct iscsi_conn *conn = cmd->conn; 212 213 while (begrun > data_sn++) { 214 data_sn_count++; 215 if ((dr->next_burst_len + 216 conn->conn_ops->MaxRecvDataSegmentLength) < 217 conn->sess->sess_ops->MaxBurstLength) { 218 dr->read_data_done += 219 conn->conn_ops->MaxRecvDataSegmentLength; 220 dr->next_burst_len += 221 conn->conn_ops->MaxRecvDataSegmentLength; 222 } else { 223 dr->read_data_done += 224 (conn->sess->sess_ops->MaxBurstLength - 225 dr->next_burst_len); 226 dr->next_burst_len = 0; 227 pdu_start += data_sn_count; 228 data_sn_count = 0; 229 seq_no++; 230 } 231 } 232 233 if (!conn->sess->sess_ops->DataPDUInOrder) { 234 cmd->seq_no = seq_no; 235 cmd->pdu_start = pdu_start; 236 cmd->pdu_send_order = data_sn_count; 237 } 238 239 return 0; 240 } 241 242 /* 243 * Generates Offsets and NextBurstLength based on Begrun and Runlength 244 * carried in a Data SNACK or ExpDataSN in TMR TASK_REASSIGN. 245 * 246 * For DataSequenceInOrder=No and DataPDUInOrder=[Yes,No] only. 247 * 248 * FIXME: How is this handled for a RData SNACK? 249 */ 250 int iscsit_create_recovery_datain_values_datasequenceinorder_no( 251 struct iscsi_cmd *cmd, 252 struct iscsi_datain_req *dr) 253 { 254 int found_seq = 0, i; 255 u32 data_sn, read_data_done = 0, seq_send_order = 0; 256 u32 begrun = dr->begrun; 257 u32 runlength = dr->runlength; 258 struct iscsi_conn *conn = cmd->conn; 259 struct iscsi_seq *first_seq = NULL, *seq = NULL; 260 261 if (!cmd->seq_list) { 262 pr_err("struct iscsi_cmd->seq_list is NULL!\n"); 263 return -1; 264 } 265 266 /* 267 * Calculate read_data_done for all sequences containing a 268 * first_datasn and last_datasn less than the BegRun. 269 * 270 * Locate the struct iscsi_seq the BegRun lies within and calculate 271 * NextBurstLenghth up to the DataSN based on MaxRecvDataSegmentLength. 272 * 273 * Also use struct iscsi_seq->seq_send_order to determine where to start. 274 */ 275 for (i = 0; i < cmd->seq_count; i++) { 276 seq = &cmd->seq_list[i]; 277 278 if (!seq->seq_send_order) 279 first_seq = seq; 280 281 /* 282 * No data has been transferred for this DataIN sequence, so the 283 * seq->first_datasn and seq->last_datasn have not been set. 284 */ 285 if (!seq->sent) { 286 pr_err("Ignoring non-sent sequence 0x%08x ->" 287 " 0x%08x\n\n", seq->first_datasn, 288 seq->last_datasn); 289 continue; 290 } 291 292 /* 293 * This DataIN sequence is precedes the received BegRun, add the 294 * total xfer_len of the sequence to read_data_done and reset 295 * seq->pdu_send_order. 296 */ 297 if ((seq->first_datasn < begrun) && 298 (seq->last_datasn < begrun)) { 299 pr_err("Pre BegRun sequence 0x%08x ->" 300 " 0x%08x\n", seq->first_datasn, 301 seq->last_datasn); 302 303 read_data_done += cmd->seq_list[i].xfer_len; 304 seq->next_burst_len = seq->pdu_send_order = 0; 305 continue; 306 } 307 308 /* 309 * The BegRun lies within this DataIN sequence. 310 */ 311 if ((seq->first_datasn <= begrun) && 312 (seq->last_datasn >= begrun)) { 313 pr_err("Found sequence begrun: 0x%08x in" 314 " 0x%08x -> 0x%08x\n", begrun, 315 seq->first_datasn, seq->last_datasn); 316 317 seq_send_order = seq->seq_send_order; 318 data_sn = seq->first_datasn; 319 seq->next_burst_len = seq->pdu_send_order = 0; 320 found_seq = 1; 321 322 /* 323 * For DataPDUInOrder=Yes, while the first DataSN of 324 * the sequence is less than the received BegRun, add 325 * the MaxRecvDataSegmentLength to read_data_done and 326 * to the sequence's next_burst_len; 327 * 328 * For DataPDUInOrder=No, while the first DataSN of the 329 * sequence is less than the received BegRun, find the 330 * struct iscsi_pdu of the DataSN in question and add the 331 * MaxRecvDataSegmentLength to read_data_done and to the 332 * sequence's next_burst_len; 333 */ 334 if (conn->sess->sess_ops->DataPDUInOrder) { 335 while (data_sn < begrun) { 336 seq->pdu_send_order++; 337 read_data_done += 338 conn->conn_ops->MaxRecvDataSegmentLength; 339 seq->next_burst_len += 340 conn->conn_ops->MaxRecvDataSegmentLength; 341 data_sn++; 342 } 343 } else { 344 int j; 345 struct iscsi_pdu *pdu; 346 347 while (data_sn < begrun) { 348 seq->pdu_send_order++; 349 350 for (j = 0; j < seq->pdu_count; j++) { 351 pdu = &cmd->pdu_list[ 352 seq->pdu_start + j]; 353 if (pdu->data_sn == data_sn) { 354 read_data_done += 355 pdu->length; 356 seq->next_burst_len += 357 pdu->length; 358 } 359 } 360 data_sn++; 361 } 362 } 363 continue; 364 } 365 366 /* 367 * This DataIN sequence is larger than the received BegRun, 368 * reset seq->pdu_send_order and continue. 369 */ 370 if ((seq->first_datasn > begrun) || 371 (seq->last_datasn > begrun)) { 372 pr_err("Post BegRun sequence 0x%08x -> 0x%08x\n", 373 seq->first_datasn, seq->last_datasn); 374 375 seq->next_burst_len = seq->pdu_send_order = 0; 376 continue; 377 } 378 } 379 380 if (!found_seq) { 381 if (!begrun) { 382 if (!first_seq) { 383 pr_err("ITT: 0x%08x, Begrun: 0x%08x" 384 " but first_seq is NULL\n", 385 cmd->init_task_tag, begrun); 386 return -1; 387 } 388 seq_send_order = first_seq->seq_send_order; 389 seq->next_burst_len = seq->pdu_send_order = 0; 390 goto done; 391 } 392 393 pr_err("Unable to locate struct iscsi_seq for ITT: 0x%08x," 394 " BegRun: 0x%08x, RunLength: 0x%08x while" 395 " DataSequenceInOrder=No and DataPDUInOrder=%s.\n", 396 cmd->init_task_tag, begrun, runlength, 397 (conn->sess->sess_ops->DataPDUInOrder) ? "Yes" : "No"); 398 return -1; 399 } 400 401 done: 402 dr->read_data_done = read_data_done; 403 dr->seq_send_order = seq_send_order; 404 405 return 0; 406 } 407 408 static int iscsit_handle_recovery_datain( 409 struct iscsi_cmd *cmd, 410 unsigned char *buf, 411 u32 begrun, 412 u32 runlength) 413 { 414 struct iscsi_conn *conn = cmd->conn; 415 struct iscsi_datain_req *dr; 416 struct se_cmd *se_cmd = &cmd->se_cmd; 417 418 if (!(se_cmd->transport_state & CMD_T_COMPLETE)) { 419 pr_err("Ignoring ITT: 0x%08x Data SNACK\n", 420 cmd->init_task_tag); 421 return 0; 422 } 423 424 /* 425 * Make sure the initiator is not requesting retransmission 426 * of DataSNs already acknowledged by a Data ACK SNACK. 427 */ 428 if ((cmd->cmd_flags & ICF_GOT_DATACK_SNACK) && 429 (begrun <= cmd->acked_data_sn)) { 430 pr_err("ITT: 0x%08x, Data SNACK requesting" 431 " retransmission of DataSN: 0x%08x to 0x%08x but" 432 " already acked to DataSN: 0x%08x by Data ACK SNACK," 433 " protocol error.\n", cmd->init_task_tag, begrun, 434 (begrun + runlength), cmd->acked_data_sn); 435 436 return iscsit_add_reject_from_cmd(ISCSI_REASON_PROTOCOL_ERROR, 437 1, 0, buf, cmd); 438 } 439 440 /* 441 * Make sure BegRun and RunLength in the Data SNACK are sane. 442 * Note: (cmd->data_sn - 1) will carry the maximum DataSN sent. 443 */ 444 if ((begrun + runlength) > (cmd->data_sn - 1)) { 445 pr_err("Initiator requesting BegRun: 0x%08x, RunLength" 446 ": 0x%08x greater than maximum DataSN: 0x%08x.\n", 447 begrun, runlength, (cmd->data_sn - 1)); 448 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID, 449 1, 0, buf, cmd); 450 } 451 452 dr = iscsit_allocate_datain_req(); 453 if (!dr) 454 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 455 1, 0, buf, cmd); 456 457 dr->data_sn = dr->begrun = begrun; 458 dr->runlength = runlength; 459 dr->generate_recovery_values = 1; 460 dr->recovery = DATAIN_WITHIN_COMMAND_RECOVERY; 461 462 iscsit_attach_datain_req(cmd, dr); 463 464 cmd->i_state = ISTATE_SEND_DATAIN; 465 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 466 467 return 0; 468 } 469 470 int iscsit_handle_recovery_datain_or_r2t( 471 struct iscsi_conn *conn, 472 unsigned char *buf, 473 itt_t init_task_tag, 474 u32 targ_xfer_tag, 475 u32 begrun, 476 u32 runlength) 477 { 478 struct iscsi_cmd *cmd; 479 480 cmd = iscsit_find_cmd_from_itt(conn, init_task_tag); 481 if (!cmd) 482 return 0; 483 484 /* 485 * FIXME: This will not work for bidi commands. 486 */ 487 switch (cmd->data_direction) { 488 case DMA_TO_DEVICE: 489 return iscsit_handle_r2t_snack(cmd, buf, begrun, runlength); 490 case DMA_FROM_DEVICE: 491 return iscsit_handle_recovery_datain(cmd, buf, begrun, 492 runlength); 493 default: 494 pr_err("Unknown cmd->data_direction: 0x%02x\n", 495 cmd->data_direction); 496 return -1; 497 } 498 499 return 0; 500 } 501 502 /* #warning FIXME: Status SNACK needs to be dependent on OPCODE!!! */ 503 int iscsit_handle_status_snack( 504 struct iscsi_conn *conn, 505 itt_t init_task_tag, 506 u32 targ_xfer_tag, 507 u32 begrun, 508 u32 runlength) 509 { 510 struct iscsi_cmd *cmd = NULL; 511 u32 last_statsn; 512 int found_cmd; 513 514 if (conn->exp_statsn > begrun) { 515 pr_err("Got Status SNACK Begrun: 0x%08x, RunLength:" 516 " 0x%08x but already got ExpStatSN: 0x%08x on CID:" 517 " %hu.\n", begrun, runlength, conn->exp_statsn, 518 conn->cid); 519 return 0; 520 } 521 522 last_statsn = (!runlength) ? conn->stat_sn : (begrun + runlength); 523 524 while (begrun < last_statsn) { 525 found_cmd = 0; 526 527 spin_lock_bh(&conn->cmd_lock); 528 list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) { 529 if (cmd->stat_sn == begrun) { 530 found_cmd = 1; 531 break; 532 } 533 } 534 spin_unlock_bh(&conn->cmd_lock); 535 536 if (!found_cmd) { 537 pr_err("Unable to find StatSN: 0x%08x for" 538 " a Status SNACK, assuming this was a" 539 " protactic SNACK for an untransmitted" 540 " StatSN, ignoring.\n", begrun); 541 begrun++; 542 continue; 543 } 544 545 spin_lock_bh(&cmd->istate_lock); 546 if (cmd->i_state == ISTATE_SEND_DATAIN) { 547 spin_unlock_bh(&cmd->istate_lock); 548 pr_err("Ignoring Status SNACK for BegRun:" 549 " 0x%08x, RunLength: 0x%08x, assuming this was" 550 " a protactic SNACK for an untransmitted" 551 " StatSN\n", begrun, runlength); 552 begrun++; 553 continue; 554 } 555 spin_unlock_bh(&cmd->istate_lock); 556 557 cmd->i_state = ISTATE_SEND_STATUS_RECOVERY; 558 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 559 begrun++; 560 } 561 562 return 0; 563 } 564 565 int iscsit_handle_data_ack( 566 struct iscsi_conn *conn, 567 u32 targ_xfer_tag, 568 u32 begrun, 569 u32 runlength) 570 { 571 struct iscsi_cmd *cmd = NULL; 572 573 cmd = iscsit_find_cmd_from_ttt(conn, targ_xfer_tag); 574 if (!cmd) { 575 pr_err("Data ACK SNACK for TTT: 0x%08x is" 576 " invalid.\n", targ_xfer_tag); 577 return -1; 578 } 579 580 if (begrun <= cmd->acked_data_sn) { 581 pr_err("ITT: 0x%08x Data ACK SNACK BegRUN: 0x%08x is" 582 " less than the already acked DataSN: 0x%08x.\n", 583 cmd->init_task_tag, begrun, cmd->acked_data_sn); 584 return -1; 585 } 586 587 /* 588 * For Data ACK SNACK, BegRun is the next expected DataSN. 589 * (see iSCSI v19: 10.16.6) 590 */ 591 cmd->cmd_flags |= ICF_GOT_DATACK_SNACK; 592 cmd->acked_data_sn = (begrun - 1); 593 594 pr_debug("Received Data ACK SNACK for ITT: 0x%08x," 595 " updated acked DataSN to 0x%08x.\n", 596 cmd->init_task_tag, cmd->acked_data_sn); 597 598 return 0; 599 } 600 601 static int iscsit_send_recovery_r2t( 602 struct iscsi_cmd *cmd, 603 u32 offset, 604 u32 xfer_len) 605 { 606 int ret; 607 608 spin_lock_bh(&cmd->r2t_lock); 609 ret = iscsit_add_r2t_to_list(cmd, offset, xfer_len, 1, 0); 610 spin_unlock_bh(&cmd->r2t_lock); 611 612 return ret; 613 } 614 615 int iscsit_dataout_datapduinorder_no_fbit( 616 struct iscsi_cmd *cmd, 617 struct iscsi_pdu *pdu) 618 { 619 int i, send_recovery_r2t = 0, recovery = 0; 620 u32 length = 0, offset = 0, pdu_count = 0, xfer_len = 0; 621 struct iscsi_conn *conn = cmd->conn; 622 struct iscsi_pdu *first_pdu = NULL; 623 624 /* 625 * Get an struct iscsi_pdu pointer to the first PDU, and total PDU count 626 * of the DataOUT sequence. 627 */ 628 if (conn->sess->sess_ops->DataSequenceInOrder) { 629 for (i = 0; i < cmd->pdu_count; i++) { 630 if (cmd->pdu_list[i].seq_no == pdu->seq_no) { 631 if (!first_pdu) 632 first_pdu = &cmd->pdu_list[i]; 633 xfer_len += cmd->pdu_list[i].length; 634 pdu_count++; 635 } else if (pdu_count) 636 break; 637 } 638 } else { 639 struct iscsi_seq *seq = cmd->seq_ptr; 640 641 first_pdu = &cmd->pdu_list[seq->pdu_start]; 642 pdu_count = seq->pdu_count; 643 } 644 645 if (!first_pdu || !pdu_count) 646 return DATAOUT_CANNOT_RECOVER; 647 648 /* 649 * Loop through the ending DataOUT Sequence checking each struct iscsi_pdu. 650 * The following ugly logic does batching of not received PDUs. 651 */ 652 for (i = 0; i < pdu_count; i++) { 653 if (first_pdu[i].status == ISCSI_PDU_RECEIVED_OK) { 654 if (!send_recovery_r2t) 655 continue; 656 657 if (iscsit_send_recovery_r2t(cmd, offset, length) < 0) 658 return DATAOUT_CANNOT_RECOVER; 659 660 send_recovery_r2t = length = offset = 0; 661 continue; 662 } 663 /* 664 * Set recovery = 1 for any missing, CRC failed, or timed 665 * out PDUs to let the DataOUT logic know that this sequence 666 * has not been completed yet. 667 * 668 * Also, only send a Recovery R2T for ISCSI_PDU_NOT_RECEIVED. 669 * We assume if the PDU either failed CRC or timed out 670 * that a Recovery R2T has already been sent. 671 */ 672 recovery = 1; 673 674 if (first_pdu[i].status != ISCSI_PDU_NOT_RECEIVED) 675 continue; 676 677 if (!offset) 678 offset = first_pdu[i].offset; 679 length += first_pdu[i].length; 680 681 send_recovery_r2t = 1; 682 } 683 684 if (send_recovery_r2t) 685 if (iscsit_send_recovery_r2t(cmd, offset, length) < 0) 686 return DATAOUT_CANNOT_RECOVER; 687 688 return (!recovery) ? DATAOUT_NORMAL : DATAOUT_WITHIN_COMMAND_RECOVERY; 689 } 690 691 static int iscsit_recalculate_dataout_values( 692 struct iscsi_cmd *cmd, 693 u32 pdu_offset, 694 u32 pdu_length, 695 u32 *r2t_offset, 696 u32 *r2t_length) 697 { 698 int i; 699 struct iscsi_conn *conn = cmd->conn; 700 struct iscsi_pdu *pdu = NULL; 701 702 if (conn->sess->sess_ops->DataSequenceInOrder) { 703 cmd->data_sn = 0; 704 705 if (conn->sess->sess_ops->DataPDUInOrder) { 706 *r2t_offset = cmd->write_data_done; 707 *r2t_length = (cmd->seq_end_offset - 708 cmd->write_data_done); 709 return 0; 710 } 711 712 *r2t_offset = cmd->seq_start_offset; 713 *r2t_length = (cmd->seq_end_offset - cmd->seq_start_offset); 714 715 for (i = 0; i < cmd->pdu_count; i++) { 716 pdu = &cmd->pdu_list[i]; 717 718 if (pdu->status != ISCSI_PDU_RECEIVED_OK) 719 continue; 720 721 if ((pdu->offset >= cmd->seq_start_offset) && 722 ((pdu->offset + pdu->length) <= 723 cmd->seq_end_offset)) { 724 if (!cmd->unsolicited_data) 725 cmd->next_burst_len -= pdu->length; 726 else 727 cmd->first_burst_len -= pdu->length; 728 729 cmd->write_data_done -= pdu->length; 730 pdu->status = ISCSI_PDU_NOT_RECEIVED; 731 } 732 } 733 } else { 734 struct iscsi_seq *seq = NULL; 735 736 seq = iscsit_get_seq_holder(cmd, pdu_offset, pdu_length); 737 if (!seq) 738 return -1; 739 740 *r2t_offset = seq->orig_offset; 741 *r2t_length = seq->xfer_len; 742 743 cmd->write_data_done -= (seq->offset - seq->orig_offset); 744 if (cmd->immediate_data) 745 cmd->first_burst_len = cmd->write_data_done; 746 747 seq->data_sn = 0; 748 seq->offset = seq->orig_offset; 749 seq->next_burst_len = 0; 750 seq->status = DATAOUT_SEQUENCE_WITHIN_COMMAND_RECOVERY; 751 752 if (conn->sess->sess_ops->DataPDUInOrder) 753 return 0; 754 755 for (i = 0; i < seq->pdu_count; i++) { 756 pdu = &cmd->pdu_list[i+seq->pdu_start]; 757 758 if (pdu->status != ISCSI_PDU_RECEIVED_OK) 759 continue; 760 761 pdu->status = ISCSI_PDU_NOT_RECEIVED; 762 } 763 } 764 765 return 0; 766 } 767 768 int iscsit_recover_dataout_sequence( 769 struct iscsi_cmd *cmd, 770 u32 pdu_offset, 771 u32 pdu_length) 772 { 773 u32 r2t_length = 0, r2t_offset = 0; 774 775 spin_lock_bh(&cmd->istate_lock); 776 cmd->cmd_flags |= ICF_WITHIN_COMMAND_RECOVERY; 777 spin_unlock_bh(&cmd->istate_lock); 778 779 if (iscsit_recalculate_dataout_values(cmd, pdu_offset, pdu_length, 780 &r2t_offset, &r2t_length) < 0) 781 return DATAOUT_CANNOT_RECOVER; 782 783 iscsit_send_recovery_r2t(cmd, r2t_offset, r2t_length); 784 785 return DATAOUT_WITHIN_COMMAND_RECOVERY; 786 } 787 788 static struct iscsi_ooo_cmdsn *iscsit_allocate_ooo_cmdsn(void) 789 { 790 struct iscsi_ooo_cmdsn *ooo_cmdsn = NULL; 791 792 ooo_cmdsn = kmem_cache_zalloc(lio_ooo_cache, GFP_ATOMIC); 793 if (!ooo_cmdsn) { 794 pr_err("Unable to allocate memory for" 795 " struct iscsi_ooo_cmdsn.\n"); 796 return NULL; 797 } 798 INIT_LIST_HEAD(&ooo_cmdsn->ooo_list); 799 800 return ooo_cmdsn; 801 } 802 803 /* 804 * Called with sess->cmdsn_mutex held. 805 */ 806 static int iscsit_attach_ooo_cmdsn( 807 struct iscsi_session *sess, 808 struct iscsi_ooo_cmdsn *ooo_cmdsn) 809 { 810 struct iscsi_ooo_cmdsn *ooo_tail, *ooo_tmp; 811 /* 812 * We attach the struct iscsi_ooo_cmdsn entry to the out of order 813 * list in increasing CmdSN order. 814 * This allows iscsi_execute_ooo_cmdsns() to detect any 815 * additional CmdSN holes while performing delayed execution. 816 */ 817 if (list_empty(&sess->sess_ooo_cmdsn_list)) 818 list_add_tail(&ooo_cmdsn->ooo_list, 819 &sess->sess_ooo_cmdsn_list); 820 else { 821 ooo_tail = list_entry(sess->sess_ooo_cmdsn_list.prev, 822 typeof(*ooo_tail), ooo_list); 823 /* 824 * CmdSN is greater than the tail of the list. 825 */ 826 if (iscsi_sna_lt(ooo_tail->cmdsn, ooo_cmdsn->cmdsn)) 827 list_add_tail(&ooo_cmdsn->ooo_list, 828 &sess->sess_ooo_cmdsn_list); 829 else { 830 /* 831 * CmdSN is either lower than the head, or somewhere 832 * in the middle. 833 */ 834 list_for_each_entry(ooo_tmp, &sess->sess_ooo_cmdsn_list, 835 ooo_list) { 836 if (iscsi_sna_lt(ooo_tmp->cmdsn, ooo_cmdsn->cmdsn)) 837 continue; 838 839 /* Insert before this entry */ 840 list_add(&ooo_cmdsn->ooo_list, 841 ooo_tmp->ooo_list.prev); 842 break; 843 } 844 } 845 } 846 847 return 0; 848 } 849 850 /* 851 * Removes an struct iscsi_ooo_cmdsn from a session's list, 852 * called with struct iscsi_session->cmdsn_mutex held. 853 */ 854 void iscsit_remove_ooo_cmdsn( 855 struct iscsi_session *sess, 856 struct iscsi_ooo_cmdsn *ooo_cmdsn) 857 { 858 list_del(&ooo_cmdsn->ooo_list); 859 kmem_cache_free(lio_ooo_cache, ooo_cmdsn); 860 } 861 862 void iscsit_clear_ooo_cmdsns_for_conn(struct iscsi_conn *conn) 863 { 864 struct iscsi_ooo_cmdsn *ooo_cmdsn; 865 struct iscsi_session *sess = conn->sess; 866 867 mutex_lock(&sess->cmdsn_mutex); 868 list_for_each_entry(ooo_cmdsn, &sess->sess_ooo_cmdsn_list, ooo_list) { 869 if (ooo_cmdsn->cid != conn->cid) 870 continue; 871 872 ooo_cmdsn->cmd = NULL; 873 } 874 mutex_unlock(&sess->cmdsn_mutex); 875 } 876 877 /* 878 * Called with sess->cmdsn_mutex held. 879 */ 880 int iscsit_execute_ooo_cmdsns(struct iscsi_session *sess) 881 { 882 int ooo_count = 0; 883 struct iscsi_cmd *cmd = NULL; 884 struct iscsi_ooo_cmdsn *ooo_cmdsn, *ooo_cmdsn_tmp; 885 886 list_for_each_entry_safe(ooo_cmdsn, ooo_cmdsn_tmp, 887 &sess->sess_ooo_cmdsn_list, ooo_list) { 888 if (ooo_cmdsn->cmdsn != sess->exp_cmd_sn) 889 continue; 890 891 if (!ooo_cmdsn->cmd) { 892 sess->exp_cmd_sn++; 893 iscsit_remove_ooo_cmdsn(sess, ooo_cmdsn); 894 continue; 895 } 896 897 cmd = ooo_cmdsn->cmd; 898 cmd->i_state = cmd->deferred_i_state; 899 ooo_count++; 900 sess->exp_cmd_sn++; 901 pr_debug("Executing out of order CmdSN: 0x%08x," 902 " incremented ExpCmdSN to 0x%08x.\n", 903 cmd->cmd_sn, sess->exp_cmd_sn); 904 905 iscsit_remove_ooo_cmdsn(sess, ooo_cmdsn); 906 907 if (iscsit_execute_cmd(cmd, 1) < 0) 908 return -1; 909 910 continue; 911 } 912 913 return ooo_count; 914 } 915 916 /* 917 * Called either: 918 * 919 * 1. With sess->cmdsn_mutex held from iscsi_execute_ooo_cmdsns() 920 * or iscsi_check_received_cmdsn(). 921 * 2. With no locks held directly from iscsi_handle_XXX_pdu() functions 922 * for immediate commands. 923 */ 924 int iscsit_execute_cmd(struct iscsi_cmd *cmd, int ooo) 925 { 926 struct se_cmd *se_cmd = &cmd->se_cmd; 927 struct iscsi_conn *conn = cmd->conn; 928 int lr = 0; 929 930 spin_lock_bh(&cmd->istate_lock); 931 if (ooo) 932 cmd->cmd_flags &= ~ICF_OOO_CMDSN; 933 934 switch (cmd->iscsi_opcode) { 935 case ISCSI_OP_SCSI_CMD: 936 /* 937 * Go ahead and send the CHECK_CONDITION status for 938 * any SCSI CDB exceptions that may have occurred. 939 */ 940 if (cmd->sense_reason) { 941 if (cmd->sense_reason == TCM_RESERVATION_CONFLICT) { 942 cmd->i_state = ISTATE_SEND_STATUS; 943 spin_unlock_bh(&cmd->istate_lock); 944 iscsit_add_cmd_to_response_queue(cmd, cmd->conn, 945 cmd->i_state); 946 return 0; 947 } 948 spin_unlock_bh(&cmd->istate_lock); 949 /* 950 * Determine if delayed TASK_ABORTED status for WRITEs 951 * should be sent now if no unsolicited data out 952 * payloads are expected, or if the delayed status 953 * should be sent after unsolicited data out with 954 * ISCSI_FLAG_CMD_FINAL set in iscsi_handle_data_out() 955 */ 956 if (transport_check_aborted_status(se_cmd, 957 (cmd->unsolicited_data == 0)) != 0) 958 return 0; 959 /* 960 * Otherwise send CHECK_CONDITION and sense for 961 * exception 962 */ 963 return transport_send_check_condition_and_sense(se_cmd, 964 cmd->sense_reason, 0); 965 } 966 /* 967 * Special case for delayed CmdSN with Immediate 968 * Data and/or Unsolicited Data Out attached. 969 */ 970 if (cmd->immediate_data) { 971 if (cmd->cmd_flags & ICF_GOT_LAST_DATAOUT) { 972 spin_unlock_bh(&cmd->istate_lock); 973 target_execute_cmd(&cmd->se_cmd); 974 return 0; 975 } 976 spin_unlock_bh(&cmd->istate_lock); 977 978 if (!(cmd->cmd_flags & 979 ICF_NON_IMMEDIATE_UNSOLICITED_DATA)) { 980 /* 981 * Send the delayed TASK_ABORTED status for 982 * WRITEs if no more unsolicitied data is 983 * expected. 984 */ 985 if (transport_check_aborted_status(se_cmd, 1) 986 != 0) 987 return 0; 988 989 iscsit_set_dataout_sequence_values(cmd); 990 conn->conn_transport->iscsit_get_dataout(conn, cmd, false); 991 } 992 return 0; 993 } 994 /* 995 * The default handler. 996 */ 997 spin_unlock_bh(&cmd->istate_lock); 998 999 if ((cmd->data_direction == DMA_TO_DEVICE) && 1000 !(cmd->cmd_flags & ICF_NON_IMMEDIATE_UNSOLICITED_DATA)) { 1001 /* 1002 * Send the delayed TASK_ABORTED status for WRITEs if 1003 * no more nsolicitied data is expected. 1004 */ 1005 if (transport_check_aborted_status(se_cmd, 1) != 0) 1006 return 0; 1007 1008 iscsit_set_unsoliticed_dataout(cmd); 1009 } 1010 return transport_handle_cdb_direct(&cmd->se_cmd); 1011 1012 case ISCSI_OP_NOOP_OUT: 1013 case ISCSI_OP_TEXT: 1014 spin_unlock_bh(&cmd->istate_lock); 1015 iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state); 1016 break; 1017 case ISCSI_OP_SCSI_TMFUNC: 1018 if (cmd->se_cmd.se_tmr_req->response) { 1019 spin_unlock_bh(&cmd->istate_lock); 1020 iscsit_add_cmd_to_response_queue(cmd, cmd->conn, 1021 cmd->i_state); 1022 return 0; 1023 } 1024 spin_unlock_bh(&cmd->istate_lock); 1025 1026 return transport_generic_handle_tmr(&cmd->se_cmd); 1027 case ISCSI_OP_LOGOUT: 1028 spin_unlock_bh(&cmd->istate_lock); 1029 switch (cmd->logout_reason) { 1030 case ISCSI_LOGOUT_REASON_CLOSE_SESSION: 1031 lr = iscsit_logout_closesession(cmd, cmd->conn); 1032 break; 1033 case ISCSI_LOGOUT_REASON_CLOSE_CONNECTION: 1034 lr = iscsit_logout_closeconnection(cmd, cmd->conn); 1035 break; 1036 case ISCSI_LOGOUT_REASON_RECOVERY: 1037 lr = iscsit_logout_removeconnforrecovery(cmd, cmd->conn); 1038 break; 1039 default: 1040 pr_err("Unknown iSCSI Logout Request Code:" 1041 " 0x%02x\n", cmd->logout_reason); 1042 return -1; 1043 } 1044 1045 return lr; 1046 default: 1047 spin_unlock_bh(&cmd->istate_lock); 1048 pr_err("Cannot perform out of order execution for" 1049 " unknown iSCSI Opcode: 0x%02x\n", cmd->iscsi_opcode); 1050 return -1; 1051 } 1052 1053 return 0; 1054 } 1055 1056 void iscsit_free_all_ooo_cmdsns(struct iscsi_session *sess) 1057 { 1058 struct iscsi_ooo_cmdsn *ooo_cmdsn, *ooo_cmdsn_tmp; 1059 1060 mutex_lock(&sess->cmdsn_mutex); 1061 list_for_each_entry_safe(ooo_cmdsn, ooo_cmdsn_tmp, 1062 &sess->sess_ooo_cmdsn_list, ooo_list) { 1063 1064 list_del(&ooo_cmdsn->ooo_list); 1065 kmem_cache_free(lio_ooo_cache, ooo_cmdsn); 1066 } 1067 mutex_unlock(&sess->cmdsn_mutex); 1068 } 1069 1070 int iscsit_handle_ooo_cmdsn( 1071 struct iscsi_session *sess, 1072 struct iscsi_cmd *cmd, 1073 u32 cmdsn) 1074 { 1075 int batch = 0; 1076 struct iscsi_ooo_cmdsn *ooo_cmdsn = NULL, *ooo_tail = NULL; 1077 1078 cmd->deferred_i_state = cmd->i_state; 1079 cmd->i_state = ISTATE_DEFERRED_CMD; 1080 cmd->cmd_flags |= ICF_OOO_CMDSN; 1081 1082 if (list_empty(&sess->sess_ooo_cmdsn_list)) 1083 batch = 1; 1084 else { 1085 ooo_tail = list_entry(sess->sess_ooo_cmdsn_list.prev, 1086 typeof(*ooo_tail), ooo_list); 1087 if (ooo_tail->cmdsn != (cmdsn - 1)) 1088 batch = 1; 1089 } 1090 1091 ooo_cmdsn = iscsit_allocate_ooo_cmdsn(); 1092 if (!ooo_cmdsn) 1093 return CMDSN_ERROR_CANNOT_RECOVER; 1094 1095 ooo_cmdsn->cmd = cmd; 1096 ooo_cmdsn->batch_count = (batch) ? 1097 (cmdsn - sess->exp_cmd_sn) : 1; 1098 ooo_cmdsn->cid = cmd->conn->cid; 1099 ooo_cmdsn->exp_cmdsn = sess->exp_cmd_sn; 1100 ooo_cmdsn->cmdsn = cmdsn; 1101 1102 if (iscsit_attach_ooo_cmdsn(sess, ooo_cmdsn) < 0) { 1103 kmem_cache_free(lio_ooo_cache, ooo_cmdsn); 1104 return CMDSN_ERROR_CANNOT_RECOVER; 1105 } 1106 1107 return CMDSN_HIGHER_THAN_EXP; 1108 } 1109 1110 static int iscsit_set_dataout_timeout_values( 1111 struct iscsi_cmd *cmd, 1112 u32 *offset, 1113 u32 *length) 1114 { 1115 struct iscsi_conn *conn = cmd->conn; 1116 struct iscsi_r2t *r2t; 1117 1118 if (cmd->unsolicited_data) { 1119 *offset = 0; 1120 *length = (conn->sess->sess_ops->FirstBurstLength > 1121 cmd->se_cmd.data_length) ? 1122 cmd->se_cmd.data_length : 1123 conn->sess->sess_ops->FirstBurstLength; 1124 return 0; 1125 } 1126 1127 spin_lock_bh(&cmd->r2t_lock); 1128 if (list_empty(&cmd->cmd_r2t_list)) { 1129 pr_err("cmd->cmd_r2t_list is empty!\n"); 1130 spin_unlock_bh(&cmd->r2t_lock); 1131 return -1; 1132 } 1133 1134 list_for_each_entry(r2t, &cmd->cmd_r2t_list, r2t_list) { 1135 if (r2t->sent_r2t && !r2t->recovery_r2t && !r2t->seq_complete) { 1136 *offset = r2t->offset; 1137 *length = r2t->xfer_len; 1138 spin_unlock_bh(&cmd->r2t_lock); 1139 return 0; 1140 } 1141 } 1142 spin_unlock_bh(&cmd->r2t_lock); 1143 1144 pr_err("Unable to locate any incomplete DataOUT" 1145 " sequences for ITT: 0x%08x.\n", cmd->init_task_tag); 1146 1147 return -1; 1148 } 1149 1150 /* 1151 * NOTE: Called from interrupt (timer) context. 1152 */ 1153 static void iscsit_handle_dataout_timeout(unsigned long data) 1154 { 1155 u32 pdu_length = 0, pdu_offset = 0; 1156 u32 r2t_length = 0, r2t_offset = 0; 1157 struct iscsi_cmd *cmd = (struct iscsi_cmd *) data; 1158 struct iscsi_conn *conn = cmd->conn; 1159 struct iscsi_session *sess = NULL; 1160 struct iscsi_node_attrib *na; 1161 1162 iscsit_inc_conn_usage_count(conn); 1163 1164 spin_lock_bh(&cmd->dataout_timeout_lock); 1165 if (cmd->dataout_timer_flags & ISCSI_TF_STOP) { 1166 spin_unlock_bh(&cmd->dataout_timeout_lock); 1167 iscsit_dec_conn_usage_count(conn); 1168 return; 1169 } 1170 cmd->dataout_timer_flags &= ~ISCSI_TF_RUNNING; 1171 sess = conn->sess; 1172 na = iscsit_tpg_get_node_attrib(sess); 1173 1174 if (!sess->sess_ops->ErrorRecoveryLevel) { 1175 pr_debug("Unable to recover from DataOut timeout while" 1176 " in ERL=0.\n"); 1177 goto failure; 1178 } 1179 1180 if (++cmd->dataout_timeout_retries == na->dataout_timeout_retries) { 1181 pr_debug("Command ITT: 0x%08x exceeded max retries" 1182 " for DataOUT timeout %u, closing iSCSI connection.\n", 1183 cmd->init_task_tag, na->dataout_timeout_retries); 1184 goto failure; 1185 } 1186 1187 cmd->cmd_flags |= ICF_WITHIN_COMMAND_RECOVERY; 1188 1189 if (conn->sess->sess_ops->DataSequenceInOrder) { 1190 if (conn->sess->sess_ops->DataPDUInOrder) { 1191 pdu_offset = cmd->write_data_done; 1192 if ((pdu_offset + (conn->sess->sess_ops->MaxBurstLength - 1193 cmd->next_burst_len)) > cmd->se_cmd.data_length) 1194 pdu_length = (cmd->se_cmd.data_length - 1195 cmd->write_data_done); 1196 else 1197 pdu_length = (conn->sess->sess_ops->MaxBurstLength - 1198 cmd->next_burst_len); 1199 } else { 1200 pdu_offset = cmd->seq_start_offset; 1201 pdu_length = (cmd->seq_end_offset - 1202 cmd->seq_start_offset); 1203 } 1204 } else { 1205 if (iscsit_set_dataout_timeout_values(cmd, &pdu_offset, 1206 &pdu_length) < 0) 1207 goto failure; 1208 } 1209 1210 if (iscsit_recalculate_dataout_values(cmd, pdu_offset, pdu_length, 1211 &r2t_offset, &r2t_length) < 0) 1212 goto failure; 1213 1214 pr_debug("Command ITT: 0x%08x timed out waiting for" 1215 " completion of %sDataOUT Sequence Offset: %u, Length: %u\n", 1216 cmd->init_task_tag, (cmd->unsolicited_data) ? "Unsolicited " : 1217 "", r2t_offset, r2t_length); 1218 1219 if (iscsit_send_recovery_r2t(cmd, r2t_offset, r2t_length) < 0) 1220 goto failure; 1221 1222 iscsit_start_dataout_timer(cmd, conn); 1223 spin_unlock_bh(&cmd->dataout_timeout_lock); 1224 iscsit_dec_conn_usage_count(conn); 1225 1226 return; 1227 1228 failure: 1229 spin_unlock_bh(&cmd->dataout_timeout_lock); 1230 iscsit_cause_connection_reinstatement(conn, 0); 1231 iscsit_dec_conn_usage_count(conn); 1232 } 1233 1234 void iscsit_mod_dataout_timer(struct iscsi_cmd *cmd) 1235 { 1236 struct iscsi_conn *conn = cmd->conn; 1237 struct iscsi_session *sess = conn->sess; 1238 struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess); 1239 1240 spin_lock_bh(&cmd->dataout_timeout_lock); 1241 if (!(cmd->dataout_timer_flags & ISCSI_TF_RUNNING)) { 1242 spin_unlock_bh(&cmd->dataout_timeout_lock); 1243 return; 1244 } 1245 1246 mod_timer(&cmd->dataout_timer, 1247 (get_jiffies_64() + na->dataout_timeout * HZ)); 1248 pr_debug("Updated DataOUT timer for ITT: 0x%08x", 1249 cmd->init_task_tag); 1250 spin_unlock_bh(&cmd->dataout_timeout_lock); 1251 } 1252 1253 /* 1254 * Called with cmd->dataout_timeout_lock held. 1255 */ 1256 void iscsit_start_dataout_timer( 1257 struct iscsi_cmd *cmd, 1258 struct iscsi_conn *conn) 1259 { 1260 struct iscsi_session *sess = conn->sess; 1261 struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess); 1262 1263 if (cmd->dataout_timer_flags & ISCSI_TF_RUNNING) 1264 return; 1265 1266 pr_debug("Starting DataOUT timer for ITT: 0x%08x on" 1267 " CID: %hu.\n", cmd->init_task_tag, conn->cid); 1268 1269 init_timer(&cmd->dataout_timer); 1270 cmd->dataout_timer.expires = (get_jiffies_64() + na->dataout_timeout * HZ); 1271 cmd->dataout_timer.data = (unsigned long)cmd; 1272 cmd->dataout_timer.function = iscsit_handle_dataout_timeout; 1273 cmd->dataout_timer_flags &= ~ISCSI_TF_STOP; 1274 cmd->dataout_timer_flags |= ISCSI_TF_RUNNING; 1275 add_timer(&cmd->dataout_timer); 1276 } 1277 1278 void iscsit_stop_dataout_timer(struct iscsi_cmd *cmd) 1279 { 1280 spin_lock_bh(&cmd->dataout_timeout_lock); 1281 if (!(cmd->dataout_timer_flags & ISCSI_TF_RUNNING)) { 1282 spin_unlock_bh(&cmd->dataout_timeout_lock); 1283 return; 1284 } 1285 cmd->dataout_timer_flags |= ISCSI_TF_STOP; 1286 spin_unlock_bh(&cmd->dataout_timeout_lock); 1287 1288 del_timer_sync(&cmd->dataout_timer); 1289 1290 spin_lock_bh(&cmd->dataout_timeout_lock); 1291 cmd->dataout_timer_flags &= ~ISCSI_TF_RUNNING; 1292 pr_debug("Stopped DataOUT Timer for ITT: 0x%08x\n", 1293 cmd->init_task_tag); 1294 spin_unlock_bh(&cmd->dataout_timeout_lock); 1295 } 1296 EXPORT_SYMBOL(iscsit_stop_dataout_timer); 1297