drivers/target/iscsi/iscsi_target_erl0.c

   1 /******************************************************************************
   2  * This file contains error recovery level zero functions used by
   3  * the iSCSI Target driver.
   4  *
   5  * (c) Copyright 2007-2013 Datera, Inc.
   6  *
   7  * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  ******************************************************************************/
  19
  20 #include <scsi/iscsi_proto.h>
  21 #include <target/target_core_base.h>
  22 #include <target/target_core_fabric.h>
  23
  24 #include <target/iscsi/iscsi_target_core.h>
  25 #include <target/iscsi/iscsi_transport.h>
  26 #include "iscsi_target_seq_pdu_list.h"
  27 #include "iscsi_target_tq.h"
  28 #include "iscsi_target_erl0.h"
  29 #include "iscsi_target_erl1.h"
  30 #include "iscsi_target_erl2.h"
  31 #include "iscsi_target_util.h"
  32 #include "iscsi_target.h"
  33
  34 /*
  35  *      Used to set values in struct iscsi_cmd that iscsit_dataout_check_sequence()
  36  *      checks against to determine a PDU's Offset+Length is within the current
  37  *      DataOUT Sequence.  Used for DataSequenceInOrder=Yes only.
  38  */
  39 void iscsit_set_dataout_sequence_values(
  40         struct iscsi_cmd *cmd)
  41 {
  42         struct iscsi_conn *conn = cmd->conn;
  43         /*
  44          * Still set seq_start_offset and seq_end_offset for Unsolicited
  45          * DataOUT, even if DataSequenceInOrder=No.
  46          */
  47         if (cmd->unsolicited_data) {
  48                 cmd->seq_start_offset = cmd->write_data_done;
  49                 cmd->seq_end_offset = (cmd->write_data_done +
  50                         ((cmd->se_cmd.data_length >
  51                           conn->sess->sess_ops->FirstBurstLength) ?
  52                          conn->sess->sess_ops->FirstBurstLength : cmd->se_cmd.data_length));
  53                 return;
  54         }
  55
  56         if (!conn->sess->sess_ops->DataSequenceInOrder)
  57                 return;
  58
  59         if (!cmd->seq_start_offset && !cmd->seq_end_offset) {
  60                 cmd->seq_start_offset = cmd->write_data_done;
  61                 cmd->seq_end_offset = (cmd->se_cmd.data_length >
  62                         conn->sess->sess_ops->MaxBurstLength) ?
  63                         (cmd->write_data_done +
  64                         conn->sess->sess_ops->MaxBurstLength) : cmd->se_cmd.data_length;
  65         } else {
  66                 cmd->seq_start_offset = cmd->seq_end_offset;
  67                 cmd->seq_end_offset = ((cmd->seq_end_offset +
  68                         conn->sess->sess_ops->MaxBurstLength) >=
  69                         cmd->se_cmd.data_length) ? cmd->se_cmd.data_length :
  70                         (cmd->seq_end_offset +
  71                          conn->sess->sess_ops->MaxBurstLength);
  72         }
  73 }
  74
  75 static int iscsit_dataout_within_command_recovery_check(
  76         struct iscsi_cmd *cmd,
  77         unsigned char *buf)
  78 {
  79         struct iscsi_conn *conn = cmd->conn;
  80         struct iscsi_data *hdr = (struct iscsi_data *) buf;
  81         u32 payload_length = ntoh24(hdr->dlength);
  82
  83         /*
  84          * We do the within-command recovery checks here as it is
  85          * the first function called in iscsi_check_pre_dataout().
  86          * Basically, if we are in within-command recovery and
  87          * the PDU does not contain the offset the sequence needs,
  88          * dump the payload.
  89          *
  90          * This only applies to DataPDUInOrder=Yes, for
  91          * DataPDUInOrder=No we only re-request the failed PDU
  92          * and check that all PDUs in a sequence are received
  93          * upon end of sequence.
  94          */
  95         if (conn->sess->sess_ops->DataSequenceInOrder) {
  96                 if ((cmd->cmd_flags & ICF_WITHIN_COMMAND_RECOVERY) &&
  97                     cmd->write_data_done != be32_to_cpu(hdr->offset))
  98                         goto dump;
  99
 100                 cmd->cmd_flags &= ~ICF_WITHIN_COMMAND_RECOVERY;
 101         } else {
 102                 struct iscsi_seq *seq;
 103
 104                 seq = iscsit_get_seq_holder(cmd, be32_to_cpu(hdr->offset),
 105                                             payload_length);
 106                 if (!seq)
 107                         return DATAOUT_CANNOT_RECOVER;
 108                 /*
 109                  * Set the struct iscsi_seq pointer to reuse later.
 110                  */
 111                 cmd->seq_ptr = seq;
 112
 113                 if (conn->sess->sess_ops->DataPDUInOrder) {
 114                         if (seq->status ==
 115                             DATAOUT_SEQUENCE_WITHIN_COMMAND_RECOVERY &&
 116                            (seq->offset != be32_to_cpu(hdr->offset) ||
 117                             seq->data_sn != be32_to_cpu(hdr->datasn)))
 118                                 goto dump;
 119                 } else {
 120                         if (seq->status ==
 121                              DATAOUT_SEQUENCE_WITHIN_COMMAND_RECOVERY &&
 122                             seq->data_sn != be32_to_cpu(hdr->datasn))
 123                                 goto dump;
 124                 }
 125
 126                 if (seq->status == DATAOUT_SEQUENCE_COMPLETE)
 127                         goto dump;
 128
 129                 if (seq->status != DATAOUT_SEQUENCE_COMPLETE)
 130                         seq->status = 0;
 131         }
 132
 133         return DATAOUT_NORMAL;
 134
 135 dump:
 136         pr_err("Dumping DataOUT PDU Offset: %u Length: %d DataSN:"
 137                 " 0x%08x\n", hdr->offset, payload_length, hdr->datasn);
 138         return iscsit_dump_data_payload(conn, payload_length, 1);
 139 }
 140
 141 static int iscsit_dataout_check_unsolicited_sequence(
 142         struct iscsi_cmd *cmd,
 143         unsigned char *buf)
 144 {
 145         u32 first_burst_len;
 146         struct iscsi_conn *conn = cmd->conn;
 147         struct iscsi_data *hdr = (struct iscsi_data *) buf;
 148         u32 payload_length = ntoh24(hdr->dlength);
 149
 150
 151         if ((be32_to_cpu(hdr->offset) < cmd->seq_start_offset) ||
 152            ((be32_to_cpu(hdr->offset) + payload_length) > cmd->seq_end_offset)) {
 153                 pr_err("Command ITT: 0x%08x with Offset: %u,"
 154                 " Length: %u outside of Unsolicited Sequence %u:%u while"
 155                 " DataSequenceInOrder=Yes.\n", cmd->init_task_tag,
 156                 be32_to_cpu(hdr->offset), payload_length, cmd->seq_start_offset,
 157                         cmd->seq_end_offset);
 158                 return DATAOUT_CANNOT_RECOVER;
 159         }
 160
 161         first_burst_len = (cmd->first_burst_len + payload_length);
 162
 163         if (first_burst_len > conn->sess->sess_ops->FirstBurstLength) {
 164                 pr_err("Total %u bytes exceeds FirstBurstLength: %u"
 165                         " for this Unsolicited DataOut Burst.\n",
 166                         first_burst_len, conn->sess->sess_ops->FirstBurstLength);
 167                 transport_send_check_condition_and_sense(&cmd->se_cmd,
 168                                 TCM_INCORRECT_AMOUNT_OF_DATA, 0);
 169                 return DATAOUT_CANNOT_RECOVER;
 170         }
 171
 172         /*
 173          * Perform various MaxBurstLength and ISCSI_FLAG_CMD_FINAL sanity
 174          * checks for the current Unsolicited DataOUT Sequence.
 175          */
 176         if (hdr->flags & ISCSI_FLAG_CMD_FINAL) {
 177                 /*
 178                  * Ignore ISCSI_FLAG_CMD_FINAL checks while DataPDUInOrder=No, end of
 179                  * sequence checks are handled in
 180                  * iscsit_dataout_datapduinorder_no_fbit().
 181                  */
 182                 if (!conn->sess->sess_ops->DataPDUInOrder)
 183                         goto out;
 184
 185                 if ((first_burst_len != cmd->se_cmd.data_length) &&
 186                     (first_burst_len != conn->sess->sess_ops->FirstBurstLength)) {
 187                         pr_err("Unsolicited non-immediate data"
 188                         " received %u does not equal FirstBurstLength: %u, and"
 189                         " does not equal ExpXferLen %u.\n", first_burst_len,
 190                                 conn->sess->sess_ops->FirstBurstLength,
 191                                 cmd->se_cmd.data_length);
 192                         transport_send_check_condition_and_sense(&cmd->se_cmd,
 193                                         TCM_INCORRECT_AMOUNT_OF_DATA, 0);
 194                         return DATAOUT_CANNOT_RECOVER;
 195                 }
 196         } else {
 197                 if (first_burst_len == conn->sess->sess_ops->FirstBurstLength) {
 198                         pr_err("Command ITT: 0x%08x reached"
 199                         " FirstBurstLength: %u, but ISCSI_FLAG_CMD_FINAL is not set. protocol"
 200                                 " error.\n", cmd->init_task_tag,
 201                                 conn->sess->sess_ops->FirstBurstLength);
 202                         return DATAOUT_CANNOT_RECOVER;
 203                 }
 204                 if (first_burst_len == cmd->se_cmd.data_length) {
 205                         pr_err("Command ITT: 0x%08x reached"
 206                         " ExpXferLen: %u, but ISCSI_FLAG_CMD_FINAL is not set. protocol"
 207                         " error.\n", cmd->init_task_tag, cmd->se_cmd.data_length);
 208                         return DATAOUT_CANNOT_RECOVER;
 209                 }
 210         }
 211
 212 out:
 213         return DATAOUT_NORMAL;
 214 }
 215
 216 static int iscsit_dataout_check_sequence(
 217         struct iscsi_cmd *cmd,
 218         unsigned char *buf)
 219 {
 220         u32 next_burst_len;
 221         struct iscsi_conn *conn = cmd->conn;
 222         struct iscsi_seq *seq = NULL;
 223         struct iscsi_data *hdr = (struct iscsi_data *) buf;
 224         u32 payload_length = ntoh24(hdr->dlength);
 225
 226         /*
 227          * For DataSequenceInOrder=Yes: Check that the offset and offset+length
 228          * is within range as defined by iscsi_set_dataout_sequence_values().
 229          *
 230          * For DataSequenceInOrder=No: Check that an struct iscsi_seq exists for
 231          * offset+length tuple.
 232          */
 233         if (conn->sess->sess_ops->DataSequenceInOrder) {
 234                 /*
 235                  * Due to possibility of recovery DataOUT sent by the initiator
 236                  * fullfilling an Recovery R2T, it's best to just dump the
 237                  * payload here, instead of erroring out.
 238                  */
 239                 if ((be32_to_cpu(hdr->offset) < cmd->seq_start_offset) ||
 240                    ((be32_to_cpu(hdr->offset) + payload_length) > cmd->seq_end_offset)) {
 241                         pr_err("Command ITT: 0x%08x with Offset: %u,"
 242                         " Length: %u outside of Sequence %u:%u while"
 243                         " DataSequenceInOrder=Yes.\n", cmd->init_task_tag,
 244                         be32_to_cpu(hdr->offset), payload_length, cmd->seq_start_offset,
 245                                 cmd->seq_end_offset);
 246
 247                         if (iscsit_dump_data_payload(conn, payload_length, 1) < 0)
 248                                 return DATAOUT_CANNOT_RECOVER;
 249                         return DATAOUT_WITHIN_COMMAND_RECOVERY;
 250                 }
 251
 252                 next_burst_len = (cmd->next_burst_len + payload_length);
 253         } else {
 254                 seq = iscsit_get_seq_holder(cmd, be32_to_cpu(hdr->offset),
 255                                             payload_length);
 256                 if (!seq)
 257                         return DATAOUT_CANNOT_RECOVER;
 258                 /*
 259                  * Set the struct iscsi_seq pointer to reuse later.
 260                  */
 261                 cmd->seq_ptr = seq;
 262
 263                 if (seq->status == DATAOUT_SEQUENCE_COMPLETE) {
 264                         if (iscsit_dump_data_payload(conn, payload_length, 1) < 0)
 265                                 return DATAOUT_CANNOT_RECOVER;
 266                         return DATAOUT_WITHIN_COMMAND_RECOVERY;
 267                 }
 268
 269                 next_burst_len = (seq->next_burst_len + payload_length);
 270         }
 271
 272         if (next_burst_len > conn->sess->sess_ops->MaxBurstLength) {
 273                 pr_err("Command ITT: 0x%08x, NextBurstLength: %u and"
 274                         " Length: %u exceeds MaxBurstLength: %u. protocol"
 275                         " error.\n", cmd->init_task_tag,
 276                         (next_burst_len - payload_length),
 277                         payload_length, conn->sess->sess_ops->MaxBurstLength);
 278                 return DATAOUT_CANNOT_RECOVER;
 279         }
 280
 281         /*
 282          * Perform various MaxBurstLength and ISCSI_FLAG_CMD_FINAL sanity
 283          * checks for the current DataOUT Sequence.
 284          */
 285         if (hdr->flags & ISCSI_FLAG_CMD_FINAL) {
 286                 /*
 287                  * Ignore ISCSI_FLAG_CMD_FINAL checks while DataPDUInOrder=No, end of
 288                  * sequence checks are handled in
 289                  * iscsit_dataout_datapduinorder_no_fbit().
 290                  */
 291                 if (!conn->sess->sess_ops->DataPDUInOrder)
 292                         goto out;
 293
 294                 if (conn->sess->sess_ops->DataSequenceInOrder) {
 295                         if ((next_burst_len <
 296                              conn->sess->sess_ops->MaxBurstLength) &&
 297                            ((cmd->write_data_done + payload_length) <
 298                              cmd->se_cmd.data_length)) {
 299                                 pr_err("Command ITT: 0x%08x set ISCSI_FLAG_CMD_FINAL"
 300                                 " before end of DataOUT sequence, protocol"
 301                                 " error.\n", cmd->init_task_tag);
 302                                 return DATAOUT_CANNOT_RECOVER;
 303                         }
 304                 } else {
 305                         if (next_burst_len < seq->xfer_len) {
 306                                 pr_err("Command ITT: 0x%08x set ISCSI_FLAG_CMD_FINAL"
 307                                 " before end of DataOUT sequence, protocol"
 308                                 " error.\n", cmd->init_task_tag);
 309                                 return DATAOUT_CANNOT_RECOVER;
 310                         }
 311                 }
 312         } else {
 313                 if (conn->sess->sess_ops->DataSequenceInOrder) {
 314                         if (next_burst_len ==
 315                                         conn->sess->sess_ops->MaxBurstLength) {
 316                                 pr_err("Command ITT: 0x%08x reached"
 317                                 " MaxBurstLength: %u, but ISCSI_FLAG_CMD_FINAL is"
 318                                 " not set, protocol error.", cmd->init_task_tag,
 319                                         conn->sess->sess_ops->MaxBurstLength);
 320                                 return DATAOUT_CANNOT_RECOVER;
 321                         }
 322                         if ((cmd->write_data_done + payload_length) ==
 323                                         cmd->se_cmd.data_length) {
 324                                 pr_err("Command ITT: 0x%08x reached"
 325                                 " last DataOUT PDU in sequence but ISCSI_FLAG_"
 326                                 "CMD_FINAL is not set, protocol error.\n",
 327                                         cmd->init_task_tag);
 328                                 return DATAOUT_CANNOT_RECOVER;
 329                         }
 330                 } else {
 331                         if (next_burst_len == seq->xfer_len) {
 332                                 pr_err("Command ITT: 0x%08x reached"
 333                                 " last DataOUT PDU in sequence but ISCSI_FLAG_"
 334                                 "CMD_FINAL is not set, protocol error.\n",
 335                                         cmd->init_task_tag);
 336                                 return DATAOUT_CANNOT_RECOVER;
 337                         }
 338                 }
 339         }
 340
 341 out:
 342         return DATAOUT_NORMAL;
 343 }
 344
 345 static int iscsit_dataout_check_datasn(
 346         struct iscsi_cmd *cmd,
 347         unsigned char *buf)
 348 {
 349         u32 data_sn = 0;
 350         struct iscsi_conn *conn = cmd->conn;
 351         struct iscsi_data *hdr = (struct iscsi_data *) buf;
 352         u32 payload_length = ntoh24(hdr->dlength);
 353
 354         /*
 355          * Considering the target has no method of re-requesting DataOUT
 356          * by DataSN, if we receieve a greater DataSN than expected we
 357          * assume the functions for DataPDUInOrder=[Yes,No] below will
 358          * handle it.
 359          *
 360          * If the DataSN is less than expected, dump the payload.
 361          */
 362         if (conn->sess->sess_ops->DataSequenceInOrder)
 363                 data_sn = cmd->data_sn;
 364         else {
 365                 struct iscsi_seq *seq = cmd->seq_ptr;
 366                 data_sn = seq->data_sn;
 367         }
 368
 369         if (be32_to_cpu(hdr->datasn) > data_sn) {
 370                 pr_err("Command ITT: 0x%08x, received DataSN: 0x%08x"
 371                         " higher than expected 0x%08x.\n", cmd->init_task_tag,
 372                                 be32_to_cpu(hdr->datasn), data_sn);
 373                 goto recover;
 374         } else if (be32_to_cpu(hdr->datasn) < data_sn) {
 375                 pr_err("Command ITT: 0x%08x, received DataSN: 0x%08x"
 376                         " lower than expected 0x%08x, discarding payload.\n",
 377                         cmd->init_task_tag, be32_to_cpu(hdr->datasn), data_sn);
 378                 goto dump;
 379         }
 380
 381         return DATAOUT_NORMAL;
 382
 383 recover:
 384         if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
 385                 pr_err("Unable to perform within-command recovery"
 386                                 " while ERL=0.\n");
 387                 return DATAOUT_CANNOT_RECOVER;
 388         }
 389 dump:
 390         if (iscsit_dump_data_payload(conn, payload_length, 1) < 0)
 391                 return DATAOUT_CANNOT_RECOVER;
 392
 393         return DATAOUT_WITHIN_COMMAND_RECOVERY;
 394 }
 395
 396 static int iscsit_dataout_pre_datapduinorder_yes(
 397         struct iscsi_cmd *cmd,
 398         unsigned char *buf)
 399 {
 400         int dump = 0, recovery = 0;
 401         struct iscsi_conn *conn = cmd->conn;
 402         struct iscsi_data *hdr = (struct iscsi_data *) buf;
 403         u32 payload_length = ntoh24(hdr->dlength);
 404
 405         /*
 406          * For DataSequenceInOrder=Yes: If the offset is greater than the global
 407          * DataPDUInOrder=Yes offset counter in struct iscsi_cmd a protcol error has
 408          * occurred and fail the connection.
 409          *
 410          * For DataSequenceInOrder=No: If the offset is greater than the per
 411          * sequence DataPDUInOrder=Yes offset counter in struct iscsi_seq a protocol
 412          * error has occurred and fail the connection.
 413          */
 414         if (conn->sess->sess_ops->DataSequenceInOrder) {
 415                 if (be32_to_cpu(hdr->offset) != cmd->write_data_done) {
 416                         pr_err("Command ITT: 0x%08x, received offset"
 417                         " %u different than expected %u.\n", cmd->init_task_tag,
 418                                 be32_to_cpu(hdr->offset), cmd->write_data_done);
 419                         recovery = 1;
 420                         goto recover;
 421                 }
 422         } else {
 423                 struct iscsi_seq *seq = cmd->seq_ptr;
 424
 425                 if (be32_to_cpu(hdr->offset) > seq->offset) {
 426                         pr_err("Command ITT: 0x%08x, received offset"
 427                         " %u greater than expected %u.\n", cmd->init_task_tag,
 428                                 be32_to_cpu(hdr->offset), seq->offset);
 429                         recovery = 1;
 430                         goto recover;
 431                 } else if (be32_to_cpu(hdr->offset) < seq->offset) {
 432                         pr_err("Command ITT: 0x%08x, received offset"
 433                         " %u less than expected %u, discarding payload.\n",
 434                                 cmd->init_task_tag, be32_to_cpu(hdr->offset),
 435                                 seq->offset);
 436                         dump = 1;
 437                         goto dump;
 438                 }
 439         }
 440
 441         return DATAOUT_NORMAL;
 442
 443 recover:
 444         if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
 445                 pr_err("Unable to perform within-command recovery"
 446                                 " while ERL=0.\n");
 447                 return DATAOUT_CANNOT_RECOVER;
 448         }
 449 dump:
 450         if (iscsit_dump_data_payload(conn, payload_length, 1) < 0)
 451                 return DATAOUT_CANNOT_RECOVER;
 452
 453         return (recovery) ? iscsit_recover_dataout_sequence(cmd,
 454                 be32_to_cpu(hdr->offset), payload_length) :
 455                (dump) ? DATAOUT_WITHIN_COMMAND_RECOVERY : DATAOUT_NORMAL;
 456 }
 457
 458 static int iscsit_dataout_pre_datapduinorder_no(
 459         struct iscsi_cmd *cmd,
 460         unsigned char *buf)
 461 {
 462         struct iscsi_pdu *pdu;
 463         struct iscsi_data *hdr = (struct iscsi_data *) buf;
 464         u32 payload_length = ntoh24(hdr->dlength);
 465
 466         pdu = iscsit_get_pdu_holder(cmd, be32_to_cpu(hdr->offset),
 467                                     payload_length);
 468         if (!pdu)
 469                 return DATAOUT_CANNOT_RECOVER;
 470
 471         cmd->pdu_ptr = pdu;
 472
 473         switch (pdu->status) {
 474         case ISCSI_PDU_NOT_RECEIVED:
 475         case ISCSI_PDU_CRC_FAILED:
 476         case ISCSI_PDU_TIMED_OUT:
 477                 break;
 478         case ISCSI_PDU_RECEIVED_OK:
 479                 pr_err("Command ITT: 0x%08x received already gotten"
 480                         " Offset: %u, Length: %u\n", cmd->init_task_tag,
 481                                 be32_to_cpu(hdr->offset), payload_length);
 482                 return iscsit_dump_data_payload(cmd->conn, payload_length, 1);
 483         default:
 484                 return DATAOUT_CANNOT_RECOVER;
 485         }
 486
 487         return DATAOUT_NORMAL;
 488 }
 489
 490 static int iscsit_dataout_update_r2t(struct iscsi_cmd *cmd, u32 offset, u32 length)
 491 {
 492         struct iscsi_r2t *r2t;
 493
 494         if (cmd->unsolicited_data)
 495                 return 0;
 496
 497         r2t = iscsit_get_r2t_for_eos(cmd, offset, length);
 498         if (!r2t)
 499                 return -1;
 500
 501         spin_lock_bh(&cmd->r2t_lock);
 502         r2t->seq_complete = 1;
 503         cmd->outstanding_r2ts--;
 504         spin_unlock_bh(&cmd->r2t_lock);
 505
 506         return 0;
 507 }
 508
 509 static int iscsit_dataout_update_datapduinorder_no(
 510         struct iscsi_cmd *cmd,
 511         u32 data_sn,
 512         int f_bit)
 513 {
 514         int ret = 0;
 515         struct iscsi_pdu *pdu = cmd->pdu_ptr;
 516
 517         pdu->data_sn = data_sn;
 518
 519         switch (pdu->status) {
 520         case ISCSI_PDU_NOT_RECEIVED:
 521                 pdu->status = ISCSI_PDU_RECEIVED_OK;
 522                 break;
 523         case ISCSI_PDU_CRC_FAILED:
 524                 pdu->status = ISCSI_PDU_RECEIVED_OK;
 525                 break;
 526         case ISCSI_PDU_TIMED_OUT:
 527                 pdu->status = ISCSI_PDU_RECEIVED_OK;
 528                 break;
 529         default:
 530                 return DATAOUT_CANNOT_RECOVER;
 531         }
 532
 533         if (f_bit) {
 534                 ret = iscsit_dataout_datapduinorder_no_fbit(cmd, pdu);
 535                 if (ret == DATAOUT_CANNOT_RECOVER)
 536                         return ret;
 537         }
 538
 539         return DATAOUT_NORMAL;
 540 }
 541
 542 static int iscsit_dataout_post_crc_passed(
 543         struct iscsi_cmd *cmd,
 544         unsigned char *buf)
 545 {
 546         int ret, send_r2t = 0;
 547         struct iscsi_conn *conn = cmd->conn;
 548         struct iscsi_seq *seq = NULL;
 549         struct iscsi_data *hdr = (struct iscsi_data *) buf;
 550         u32 payload_length = ntoh24(hdr->dlength);
 551
 552         if (cmd->unsolicited_data) {
 553                 if ((cmd->first_burst_len + payload_length) ==
 554                      conn->sess->sess_ops->FirstBurstLength) {
 555                         if (iscsit_dataout_update_r2t(cmd, be32_to_cpu(hdr->offset),
 556                                         payload_length) < 0)
 557                                 return DATAOUT_CANNOT_RECOVER;
 558                         send_r2t = 1;
 559                 }
 560
 561                 if (!conn->sess->sess_ops->DataPDUInOrder) {
 562                         ret = iscsit_dataout_update_datapduinorder_no(cmd,
 563                                 be32_to_cpu(hdr->datasn),
 564                                 (hdr->flags & ISCSI_FLAG_CMD_FINAL));
 565                         if (ret == DATAOUT_CANNOT_RECOVER)
 566                                 return ret;
 567                 }
 568
 569                 cmd->first_burst_len += payload_length;
 570
 571                 if (conn->sess->sess_ops->DataSequenceInOrder)
 572                         cmd->data_sn++;
 573                 else {
 574                         seq = cmd->seq_ptr;
 575                         seq->data_sn++;
 576                         seq->offset += payload_length;
 577                 }
 578
 579                 if (send_r2t) {
 580                         if (seq)
 581                                 seq->status = DATAOUT_SEQUENCE_COMPLETE;
 582                         cmd->first_burst_len = 0;
 583                         cmd->unsolicited_data = 0;
 584                 }
 585         } else {
 586                 if (conn->sess->sess_ops->DataSequenceInOrder) {
 587                         if ((cmd->next_burst_len + payload_length) ==
 588                              conn->sess->sess_ops->MaxBurstLength) {
 589                                 if (iscsit_dataout_update_r2t(cmd,
 590                                                 be32_to_cpu(hdr->offset),
 591                                                 payload_length) < 0)
 592                                         return DATAOUT_CANNOT_RECOVER;
 593                                 send_r2t = 1;
 594                         }
 595
 596                         if (!conn->sess->sess_ops->DataPDUInOrder) {
 597                                 ret = iscsit_dataout_update_datapduinorder_no(
 598                                                 cmd, be32_to_cpu(hdr->datasn),
 599                                                 (hdr->flags & ISCSI_FLAG_CMD_FINAL));
 600                                 if (ret == DATAOUT_CANNOT_RECOVER)
 601                                         return ret;
 602                         }
 603
 604                         cmd->next_burst_len += payload_length;
 605                         cmd->data_sn++;
 606
 607                         if (send_r2t)
 608                                 cmd->next_burst_len = 0;
 609                 } else {
 610                         seq = cmd->seq_ptr;
 611
 612                         if ((seq->next_burst_len + payload_length) ==
 613                              seq->xfer_len) {
 614                                 if (iscsit_dataout_update_r2t(cmd,
 615                                                 be32_to_cpu(hdr->offset),
 616                                                 payload_length) < 0)
 617                                         return DATAOUT_CANNOT_RECOVER;
 618                                 send_r2t = 1;
 619                         }
 620
 621                         if (!conn->sess->sess_ops->DataPDUInOrder) {
 622                                 ret = iscsit_dataout_update_datapduinorder_no(
 623                                                 cmd, be32_to_cpu(hdr->datasn),
 624                                                 (hdr->flags & ISCSI_FLAG_CMD_FINAL));
 625                                 if (ret == DATAOUT_CANNOT_RECOVER)
 626                                         return ret;
 627                         }
 628
 629                         seq->data_sn++;
 630                         seq->offset += payload_length;
 631                         seq->next_burst_len += payload_length;
 632
 633                         if (send_r2t) {
 634                                 seq->next_burst_len = 0;
 635                                 seq->status = DATAOUT_SEQUENCE_COMPLETE;
 636                         }
 637                 }
 638         }
 639
 640         if (send_r2t && conn->sess->sess_ops->DataSequenceInOrder)
 641                 cmd->data_sn = 0;
 642
 643         cmd->write_data_done += payload_length;
 644
 645         if (cmd->write_data_done == cmd->se_cmd.data_length)
 646                 return DATAOUT_SEND_TO_TRANSPORT;
 647         else if (send_r2t)
 648                 return DATAOUT_SEND_R2T;
 649         else
 650                 return DATAOUT_NORMAL;
 651 }
 652
 653 static int iscsit_dataout_post_crc_failed(
 654         struct iscsi_cmd *cmd,
 655         unsigned char *buf)
 656 {
 657         struct iscsi_conn *conn = cmd->conn;
 658         struct iscsi_pdu *pdu;
 659         struct iscsi_data *hdr = (struct iscsi_data *) buf;
 660         u32 payload_length = ntoh24(hdr->dlength);
 661
 662         if (conn->sess->sess_ops->DataPDUInOrder)
 663                 goto recover;
 664         /*
 665          * The rest of this function is only called when DataPDUInOrder=No.
 666          */
 667         pdu = cmd->pdu_ptr;
 668
 669         switch (pdu->status) {
 670         case ISCSI_PDU_NOT_RECEIVED:
 671                 pdu->status = ISCSI_PDU_CRC_FAILED;
 672                 break;
 673         case ISCSI_PDU_CRC_FAILED:
 674                 break;
 675         case ISCSI_PDU_TIMED_OUT:
 676                 pdu->status = ISCSI_PDU_CRC_FAILED;
 677                 break;
 678         default:
 679                 return DATAOUT_CANNOT_RECOVER;
 680         }
 681
 682 recover:
 683         return iscsit_recover_dataout_sequence(cmd, be32_to_cpu(hdr->offset),
 684                                                 payload_length);
 685 }
 686
 687 /*
 688  *      Called from iscsit_handle_data_out() before DataOUT Payload is received
 689  *      and CRC computed.
 690  */
 691 int iscsit_check_pre_dataout(
 692         struct iscsi_cmd *cmd,
 693         unsigned char *buf)
 694 {
 695         int ret;
 696         struct iscsi_conn *conn = cmd->conn;
 697
 698         ret = iscsit_dataout_within_command_recovery_check(cmd, buf);
 699         if ((ret == DATAOUT_WITHIN_COMMAND_RECOVERY) ||
 700             (ret == DATAOUT_CANNOT_RECOVER))
 701                 return ret;
 702
 703         ret = iscsit_dataout_check_datasn(cmd, buf);
 704         if ((ret == DATAOUT_WITHIN_COMMAND_RECOVERY) ||
 705             (ret == DATAOUT_CANNOT_RECOVER))
 706                 return ret;
 707
 708         if (cmd->unsolicited_data) {
 709                 ret = iscsit_dataout_check_unsolicited_sequence(cmd, buf);
 710                 if ((ret == DATAOUT_WITHIN_COMMAND_RECOVERY) ||
 711                     (ret == DATAOUT_CANNOT_RECOVER))
 712                         return ret;
 713         } else {
 714                 ret = iscsit_dataout_check_sequence(cmd, buf);
 715                 if ((ret == DATAOUT_WITHIN_COMMAND_RECOVERY) ||
 716                     (ret == DATAOUT_CANNOT_RECOVER))
 717                         return ret;
 718         }
 719
 720         return (conn->sess->sess_ops->DataPDUInOrder) ?
 721                 iscsit_dataout_pre_datapduinorder_yes(cmd, buf) :
 722                 iscsit_dataout_pre_datapduinorder_no(cmd, buf);
 723 }
 724
 725 /*
 726  *      Called from iscsit_handle_data_out() after DataOUT Payload is received
 727  *      and CRC computed.
 728  */
 729 int iscsit_check_post_dataout(
 730         struct iscsi_cmd *cmd,
 731         unsigned char *buf,
 732         u8 data_crc_failed)
 733 {
 734         struct iscsi_conn *conn = cmd->conn;
 735
 736         cmd->dataout_timeout_retries = 0;
 737
 738         if (!data_crc_failed)
 739                 return iscsit_dataout_post_crc_passed(cmd, buf);
 740         else {
 741                 if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
 742                         pr_err("Unable to recover from DataOUT CRC"
 743                                 " failure while ERL=0, closing session.\n");
 744                         iscsit_reject_cmd(cmd, ISCSI_REASON_DATA_DIGEST_ERROR,
 745                                           buf);
 746                         return DATAOUT_CANNOT_RECOVER;
 747                 }
 748
 749                 iscsit_reject_cmd(cmd, ISCSI_REASON_DATA_DIGEST_ERROR, buf);
 750                 return iscsit_dataout_post_crc_failed(cmd, buf);
 751         }
 752 }
 753
 754 static void iscsit_handle_time2retain_timeout(unsigned long data)
 755 {
 756         struct iscsi_session *sess = (struct iscsi_session *) data;
 757         struct iscsi_portal_group *tpg = sess->tpg;
 758         struct se_portal_group *se_tpg = &tpg->tpg_se_tpg;
 759
 760         spin_lock_bh(&se_tpg->session_lock);
 761         if (sess->time2retain_timer_flags & ISCSI_TF_STOP) {
 762                 spin_unlock_bh(&se_tpg->session_lock);
 763                 return;
 764         }
 765         if (atomic_read(&sess->session_reinstatement)) {
 766                 pr_err("Exiting Time2Retain handler because"
 767                                 " session_reinstatement=1\n");
 768                 spin_unlock_bh(&se_tpg->session_lock);
 769                 return;
 770         }
 771         sess->time2retain_timer_flags |= ISCSI_TF_EXPIRED;
 772
 773         pr_err("Time2Retain timer expired for SID: %u, cleaning up"
 774                         " iSCSI session.\n", sess->sid);
 775         {
 776         struct iscsi_tiqn *tiqn = tpg->tpg_tiqn;
 777
 778         if (tiqn) {
 779                 spin_lock(&tiqn->sess_err_stats.lock);
 780                 strcpy(tiqn->sess_err_stats.last_sess_fail_rem_name,
 781                         (void *)sess->sess_ops->InitiatorName);
 782                 tiqn->sess_err_stats.last_sess_failure_type =
 783                                 ISCSI_SESS_ERR_CXN_TIMEOUT;
 784                 tiqn->sess_err_stats.cxn_timeout_errors++;
 785                 atomic_long_inc(&sess->conn_timeout_errors);
 786                 spin_unlock(&tiqn->sess_err_stats.lock);
 787         }
 788         }
 789
 790         spin_unlock_bh(&se_tpg->session_lock);
 791         target_put_session(sess->se_sess);
 792 }
 793
 794 void iscsit_start_time2retain_handler(struct iscsi_session *sess)
 795 {
 796         int tpg_active;
 797         /*
 798          * Only start Time2Retain timer when the associated TPG is still in
 799          * an ACTIVE (eg: not disabled or shutdown) state.
 800          */
 801         spin_lock(&sess->tpg->tpg_state_lock);
 802         tpg_active = (sess->tpg->tpg_state == TPG_STATE_ACTIVE);
 803         spin_unlock(&sess->tpg->tpg_state_lock);
 804
 805         if (!tpg_active)
 806                 return;
 807
 808         if (sess->time2retain_timer_flags & ISCSI_TF_RUNNING)
 809                 return;
 810
 811         pr_debug("Starting Time2Retain timer for %u seconds on"
 812                 " SID: %u\n", sess->sess_ops->DefaultTime2Retain, sess->sid);
 813
 814         init_timer(&sess->time2retain_timer);
 815         sess->time2retain_timer.expires =
 816                 (get_jiffies_64() + sess->sess_ops->DefaultTime2Retain * HZ);
 817         sess->time2retain_timer.data = (unsigned long)sess;
 818         sess->time2retain_timer.function = iscsit_handle_time2retain_timeout;
 819         sess->time2retain_timer_flags &= ~ISCSI_TF_STOP;
 820         sess->time2retain_timer_flags |= ISCSI_TF_RUNNING;
 821         add_timer(&sess->time2retain_timer);
 822 }
 823
 824 /*
 825  *      Called with spin_lock_bh(&struct se_portal_group->session_lock) held
 826  */
 827 int iscsit_stop_time2retain_timer(struct iscsi_session *sess)
 828 {
 829         struct iscsi_portal_group *tpg = sess->tpg;
 830         struct se_portal_group *se_tpg = &tpg->tpg_se_tpg;
 831
 832         if (sess->time2retain_timer_flags & ISCSI_TF_EXPIRED)
 833                 return -1;
 834
 835         if (!(sess->time2retain_timer_flags & ISCSI_TF_RUNNING))
 836                 return 0;
 837
 838         sess->time2retain_timer_flags |= ISCSI_TF_STOP;
 839         spin_unlock(&se_tpg->session_lock);
 840
 841         del_timer_sync(&sess->time2retain_timer);
 842
 843         spin_lock(&se_tpg->session_lock);
 844         sess->time2retain_timer_flags &= ~ISCSI_TF_RUNNING;
 845         pr_debug("Stopped Time2Retain Timer for SID: %u\n",
 846                         sess->sid);
 847         return 0;
 848 }
 849
 850 void iscsit_connection_reinstatement_rcfr(struct iscsi_conn *conn)
 851 {
 852         spin_lock_bh(&conn->state_lock);
 853         if (atomic_read(&conn->connection_exit)) {
 854                 spin_unlock_bh(&conn->state_lock);
 855                 goto sleep;
 856         }
 857
 858         if (atomic_read(&conn->transport_failed)) {
 859                 spin_unlock_bh(&conn->state_lock);
 860                 goto sleep;
 861         }
 862         spin_unlock_bh(&conn->state_lock);
 863
 864         iscsi_thread_set_force_reinstatement(conn);
 865
 866 sleep:
 867         wait_for_completion(&conn->conn_wait_rcfr_comp);
 868         complete(&conn->conn_post_wait_comp);
 869 }
 870
 871 void iscsit_cause_connection_reinstatement(struct iscsi_conn *conn, int sleep)
 872 {
 873         spin_lock_bh(&conn->state_lock);
 874         if (atomic_read(&conn->connection_exit)) {
 875                 spin_unlock_bh(&conn->state_lock);
 876                 return;
 877         }
 878
 879         if (atomic_read(&conn->transport_failed)) {
 880                 spin_unlock_bh(&conn->state_lock);
 881                 return;
 882         }
 883
 884         if (atomic_read(&conn->connection_reinstatement)) {
 885                 spin_unlock_bh(&conn->state_lock);
 886                 return;
 887         }
 888
 889         if (iscsi_thread_set_force_reinstatement(conn) < 0) {
 890                 spin_unlock_bh(&conn->state_lock);
 891                 return;
 892         }
 893
 894         atomic_set(&conn->connection_reinstatement, 1);
 895         if (!sleep) {
 896                 spin_unlock_bh(&conn->state_lock);
 897                 return;
 898         }
 899
 900         atomic_set(&conn->sleep_on_conn_wait_comp, 1);
 901         spin_unlock_bh(&conn->state_lock);
 902
 903         wait_for_completion(&conn->conn_wait_comp);
 904         complete(&conn->conn_post_wait_comp);
 905 }
 906 EXPORT_SYMBOL(iscsit_cause_connection_reinstatement);
 907
 908 void iscsit_fall_back_to_erl0(struct iscsi_session *sess)
 909 {
 910         pr_debug("Falling back to ErrorRecoveryLevel=0 for SID:"
 911                         " %u\n", sess->sid);
 912
 913         atomic_set(&sess->session_fall_back_to_erl0, 1);
 914 }
 915
 916 static void iscsit_handle_connection_cleanup(struct iscsi_conn *conn)
 917 {
 918         struct iscsi_session *sess = conn->sess;
 919
 920         if ((sess->sess_ops->ErrorRecoveryLevel == 2) &&
 921             !atomic_read(&sess->session_reinstatement) &&
 922             !atomic_read(&sess->session_fall_back_to_erl0))
 923                 iscsit_connection_recovery_transport_reset(conn);
 924         else {
 925                 pr_debug("Performing cleanup for failed iSCSI"
 926                         " Connection ID: %hu from %s\n", conn->cid,
 927                         sess->sess_ops->InitiatorName);
 928                 iscsit_close_connection(conn);
 929         }
 930 }
 931
 932 void iscsit_take_action_for_connection_exit(struct iscsi_conn *conn)
 933 {
 934         spin_lock_bh(&conn->state_lock);
 935         if (atomic_read(&conn->connection_exit)) {
 936                 spin_unlock_bh(&conn->state_lock);
 937                 return;
 938         }
 939         atomic_set(&conn->connection_exit, 1);
 940
 941         if (conn->conn_state == TARG_CONN_STATE_IN_LOGOUT) {
 942                 spin_unlock_bh(&conn->state_lock);
 943                 if (conn->conn_transport->transport_type == ISCSI_TCP)
 944                         iscsit_close_connection(conn);
 945                 return;
 946         }
 947
 948         if (conn->conn_state == TARG_CONN_STATE_CLEANUP_WAIT) {
 949                 spin_unlock_bh(&conn->state_lock);
 950                 return;
 951         }
 952
 953         pr_debug("Moving to TARG_CONN_STATE_CLEANUP_WAIT.\n");
 954         conn->conn_state = TARG_CONN_STATE_CLEANUP_WAIT;
 955         spin_unlock_bh(&conn->state_lock);
 956
 957         iscsit_handle_connection_cleanup(conn);
 958 }
 959
 960 /*
 961  *      This is the simple function that makes the magic of
 962  *      sync and steering happen in the follow paradoxical order:
 963  *
 964  *      0) Receive conn->of_marker (bytes left until next OFMarker)
 965  *         bytes into an offload buffer.  When we pass the exact number
 966  *         of bytes in conn->of_marker, iscsit_dump_data_payload() and hence
 967  *         rx_data() will automatically receive the identical u32 marker
 968  *         values and store it in conn->of_marker_offset;
 969  *      1) Now conn->of_marker_offset will contain the offset to the start
 970  *         of the next iSCSI PDU.  Dump these remaining bytes into another
 971  *         offload buffer.
 972  *      2) We are done!
 973  *         Next byte in the TCP stream will contain the next iSCSI PDU!
 974  *         Cool Huh?!
 975  */
 976 int iscsit_recover_from_unknown_opcode(struct iscsi_conn *conn)
 977 {
 978         /*
 979          * Make sure the remaining bytes to next maker is a sane value.
 980          */
 981         if (conn->of_marker > (conn->conn_ops->OFMarkInt * 4)) {
 982                 pr_err("Remaining bytes to OFMarker: %u exceeds"
 983                         " OFMarkInt bytes: %u.\n", conn->of_marker,
 984                                 conn->conn_ops->OFMarkInt * 4);
 985                 return -1;
 986         }
 987
 988         pr_debug("Advancing %u bytes in TCP stream to get to the"
 989                         " next OFMarker.\n", conn->of_marker);
 990
 991         if (iscsit_dump_data_payload(conn, conn->of_marker, 0) < 0)
 992                 return -1;
 993
 994         /*
 995          * Make sure the offset marker we retrived is a valid value.
 996          */
 997         if (conn->of_marker_offset > (ISCSI_HDR_LEN + (ISCSI_CRC_LEN * 2) +
 998             conn->conn_ops->MaxRecvDataSegmentLength)) {
 999                 pr_err("OfMarker offset value: %u exceeds limit.\n",
1000                         conn->of_marker_offset);
1001                 return -1;
1002         }
1003
1004         pr_debug("Discarding %u bytes of TCP stream to get to the"
1005                         " next iSCSI Opcode.\n", conn->of_marker_offset);
1006
1007         if (iscsit_dump_data_payload(conn, conn->of_marker_offset, 0) < 0)
1008                 return -1;
1009
1010         return 0;
1011 }