drivers/target/iscsi/iscsi_target_erl2.c

   1 /*******************************************************************************
   2  * This file contains error recovery level two functions used by
   3  * the iSCSI Target driver.
   4  *
   5  * \u00a9 Copyright 2007-2011 RisingTide Systems LLC.
   6  *
   7  * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
   8  *
   9  * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  ******************************************************************************/
  21
  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_datain_values.h"
  28 #include "iscsi_target_util.h"
  29 #include "iscsi_target_erl0.h"
  30 #include "iscsi_target_erl1.h"
  31 #include "iscsi_target_erl2.h"
  32 #include "iscsi_target.h"
  33
  34 /*
  35  *      FIXME: Does RData SNACK apply here as well?
  36  */
  37 void iscsit_create_conn_recovery_datain_values(
  38         struct iscsi_cmd *cmd,
  39         u32 exp_data_sn)
  40 {
  41         u32 data_sn = 0;
  42         struct iscsi_conn *conn = cmd->conn;
  43
  44         cmd->next_burst_len = 0;
  45         cmd->read_data_done = 0;
  46
  47         while (exp_data_sn > data_sn) {
  48                 if ((cmd->next_burst_len +
  49                      conn->conn_ops->MaxRecvDataSegmentLength) <
  50                      conn->sess->sess_ops->MaxBurstLength) {
  51                         cmd->read_data_done +=
  52                                conn->conn_ops->MaxRecvDataSegmentLength;
  53                         cmd->next_burst_len +=
  54                                conn->conn_ops->MaxRecvDataSegmentLength;
  55                 } else {
  56                         cmd->read_data_done +=
  57                                 (conn->sess->sess_ops->MaxBurstLength -
  58                                 cmd->next_burst_len);
  59                         cmd->next_burst_len = 0;
  60                 }
  61                 data_sn++;
  62         }
  63 }
  64
  65 void iscsit_create_conn_recovery_dataout_values(
  66         struct iscsi_cmd *cmd)
  67 {
  68         u32 write_data_done = 0;
  69         struct iscsi_conn *conn = cmd->conn;
  70
  71         cmd->data_sn = 0;
  72         cmd->next_burst_len = 0;
  73
  74         while (cmd->write_data_done > write_data_done) {
  75                 if ((write_data_done + conn->sess->sess_ops->MaxBurstLength) <=
  76                      cmd->write_data_done)
  77                         write_data_done += conn->sess->sess_ops->MaxBurstLength;
  78                 else
  79                         break;
  80         }
  81
  82         cmd->write_data_done = write_data_done;
  83 }
  84
  85 static int iscsit_attach_active_connection_recovery_entry(
  86         struct iscsi_session *sess,
  87         struct iscsi_conn_recovery *cr)
  88 {
  89         spin_lock(&sess->cr_a_lock);
  90         list_add_tail(&cr->cr_list, &sess->cr_active_list);
  91         spin_unlock(&sess->cr_a_lock);
  92
  93         return 0;
  94 }
  95
  96 static int iscsit_attach_inactive_connection_recovery_entry(
  97         struct iscsi_session *sess,
  98         struct iscsi_conn_recovery *cr)
  99 {
 100         spin_lock(&sess->cr_i_lock);
 101         list_add_tail(&cr->cr_list, &sess->cr_inactive_list);
 102
 103         sess->conn_recovery_count++;
 104         pr_debug("Incremented connection recovery count to %u for"
 105                 " SID: %u\n", sess->conn_recovery_count, sess->sid);
 106         spin_unlock(&sess->cr_i_lock);
 107
 108         return 0;
 109 }
 110
 111 struct iscsi_conn_recovery *iscsit_get_inactive_connection_recovery_entry(
 112         struct iscsi_session *sess,
 113         u16 cid)
 114 {
 115         struct iscsi_conn_recovery *cr;
 116
 117         spin_lock(&sess->cr_i_lock);
 118         list_for_each_entry(cr, &sess->cr_inactive_list, cr_list) {
 119                 if (cr->cid == cid) {
 120                         spin_unlock(&sess->cr_i_lock);
 121                         return cr;
 122                 }
 123         }
 124         spin_unlock(&sess->cr_i_lock);
 125
 126         return NULL;
 127 }
 128
 129 void iscsit_free_connection_recovery_entires(struct iscsi_session *sess)
 130 {
 131         struct iscsi_cmd *cmd, *cmd_tmp;
 132         struct iscsi_conn_recovery *cr, *cr_tmp;
 133
 134         spin_lock(&sess->cr_a_lock);
 135         list_for_each_entry_safe(cr, cr_tmp, &sess->cr_active_list, cr_list) {
 136                 list_del(&cr->cr_list);
 137                 spin_unlock(&sess->cr_a_lock);
 138
 139                 spin_lock(&cr->conn_recovery_cmd_lock);
 140                 list_for_each_entry_safe(cmd, cmd_tmp,
 141                                 &cr->conn_recovery_cmd_list, i_list) {
 142
 143                         list_del(&cmd->i_list);
 144                         cmd->conn = NULL;
 145                         spin_unlock(&cr->conn_recovery_cmd_lock);
 146                         if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) ||
 147                             !(cmd->se_cmd.transport_wait_for_tasks))
 148                                 iscsit_release_cmd(cmd);
 149                         else
 150                                 cmd->se_cmd.transport_wait_for_tasks(
 151                                                 &cmd->se_cmd, 1, 1);
 152                         spin_lock(&cr->conn_recovery_cmd_lock);
 153                 }
 154                 spin_unlock(&cr->conn_recovery_cmd_lock);
 155                 spin_lock(&sess->cr_a_lock);
 156
 157                 kfree(cr);
 158         }
 159         spin_unlock(&sess->cr_a_lock);
 160
 161         spin_lock(&sess->cr_i_lock);
 162         list_for_each_entry_safe(cr, cr_tmp, &sess->cr_inactive_list, cr_list) {
 163                 list_del(&cr->cr_list);
 164                 spin_unlock(&sess->cr_i_lock);
 165
 166                 spin_lock(&cr->conn_recovery_cmd_lock);
 167                 list_for_each_entry_safe(cmd, cmd_tmp,
 168                                 &cr->conn_recovery_cmd_list, i_list) {
 169
 170                         list_del(&cmd->i_list);
 171                         cmd->conn = NULL;
 172                         spin_unlock(&cr->conn_recovery_cmd_lock);
 173                         if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) ||
 174                             !(cmd->se_cmd.transport_wait_for_tasks))
 175                                 iscsit_release_cmd(cmd);
 176                         else
 177                                 cmd->se_cmd.transport_wait_for_tasks(
 178                                                 &cmd->se_cmd, 1, 1);
 179                         spin_lock(&cr->conn_recovery_cmd_lock);
 180                 }
 181                 spin_unlock(&cr->conn_recovery_cmd_lock);
 182                 spin_lock(&sess->cr_i_lock);
 183
 184                 kfree(cr);
 185         }
 186         spin_unlock(&sess->cr_i_lock);
 187 }
 188
 189 int iscsit_remove_active_connection_recovery_entry(
 190         struct iscsi_conn_recovery *cr,
 191         struct iscsi_session *sess)
 192 {
 193         spin_lock(&sess->cr_a_lock);
 194         list_del(&cr->cr_list);
 195
 196         sess->conn_recovery_count--;
 197         pr_debug("Decremented connection recovery count to %u for"
 198                 " SID: %u\n", sess->conn_recovery_count, sess->sid);
 199         spin_unlock(&sess->cr_a_lock);
 200
 201         kfree(cr);
 202
 203         return 0;
 204 }
 205
 206 int iscsit_remove_inactive_connection_recovery_entry(
 207         struct iscsi_conn_recovery *cr,
 208         struct iscsi_session *sess)
 209 {
 210         spin_lock(&sess->cr_i_lock);
 211         list_del(&cr->cr_list);
 212         spin_unlock(&sess->cr_i_lock);
 213
 214         return 0;
 215 }
 216
 217 /*
 218  *      Called with cr->conn_recovery_cmd_lock help.
 219  */
 220 int iscsit_remove_cmd_from_connection_recovery(
 221         struct iscsi_cmd *cmd,
 222         struct iscsi_session *sess)
 223 {
 224         struct iscsi_conn_recovery *cr;
 225
 226         if (!cmd->cr) {
 227                 pr_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
 228                         " is NULL!\n", cmd->init_task_tag);
 229                 BUG();
 230         }
 231         cr = cmd->cr;
 232
 233         list_del(&cmd->i_list);
 234         return --cr->cmd_count;
 235 }
 236
 237 void iscsit_discard_cr_cmds_by_expstatsn(
 238         struct iscsi_conn_recovery *cr,
 239         u32 exp_statsn)
 240 {
 241         u32 dropped_count = 0;
 242         struct iscsi_cmd *cmd, *cmd_tmp;
 243         struct iscsi_session *sess = cr->sess;
 244
 245         spin_lock(&cr->conn_recovery_cmd_lock);
 246         list_for_each_entry_safe(cmd, cmd_tmp,
 247                         &cr->conn_recovery_cmd_list, i_list) {
 248
 249                 if (((cmd->deferred_i_state != ISTATE_SENT_STATUS) &&
 250                      (cmd->deferred_i_state != ISTATE_REMOVE)) ||
 251                      (cmd->stat_sn >= exp_statsn)) {
 252                         continue;
 253                 }
 254
 255                 dropped_count++;
 256                 pr_debug("Dropping Acknowledged ITT: 0x%08x, StatSN:"
 257                         " 0x%08x, CID: %hu.\n", cmd->init_task_tag,
 258                                 cmd->stat_sn, cr->cid);
 259
 260                 iscsit_remove_cmd_from_connection_recovery(cmd, sess);
 261
 262                 spin_unlock(&cr->conn_recovery_cmd_lock);
 263                 if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) ||
 264                     !(cmd->se_cmd.transport_wait_for_tasks))
 265                         iscsit_release_cmd(cmd);
 266                 else
 267                         cmd->se_cmd.transport_wait_for_tasks(
 268                                         &cmd->se_cmd, 1, 0);
 269                 spin_lock(&cr->conn_recovery_cmd_lock);
 270         }
 271         spin_unlock(&cr->conn_recovery_cmd_lock);
 272
 273         pr_debug("Dropped %u total acknowledged commands on"
 274                 " CID: %hu less than old ExpStatSN: 0x%08x\n",
 275                         dropped_count, cr->cid, exp_statsn);
 276
 277         if (!cr->cmd_count) {
 278                 pr_debug("No commands to be reassigned for failed"
 279                         " connection CID: %hu on SID: %u\n",
 280                         cr->cid, sess->sid);
 281                 iscsit_remove_inactive_connection_recovery_entry(cr, sess);
 282                 iscsit_attach_active_connection_recovery_entry(sess, cr);
 283                 pr_debug("iSCSI connection recovery successful for CID:"
 284                         " %hu on SID: %u\n", cr->cid, sess->sid);
 285                 iscsit_remove_active_connection_recovery_entry(cr, sess);
 286         } else {
 287                 iscsit_remove_inactive_connection_recovery_entry(cr, sess);
 288                 iscsit_attach_active_connection_recovery_entry(sess, cr);
 289         }
 290 }
 291
 292 int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsi_conn *conn)
 293 {
 294         u32 dropped_count = 0;
 295         struct iscsi_cmd *cmd, *cmd_tmp;
 296         struct iscsi_ooo_cmdsn *ooo_cmdsn, *ooo_cmdsn_tmp;
 297         struct iscsi_session *sess = conn->sess;
 298
 299         mutex_lock(&sess->cmdsn_mutex);
 300         list_for_each_entry_safe(ooo_cmdsn, ooo_cmdsn_tmp,
 301                         &sess->sess_ooo_cmdsn_list, ooo_list) {
 302
 303                 if (ooo_cmdsn->cid != conn->cid)
 304                         continue;
 305
 306                 dropped_count++;
 307                 pr_debug("Dropping unacknowledged CmdSN:"
 308                 " 0x%08x during connection recovery on CID: %hu\n",
 309                         ooo_cmdsn->cmdsn, conn->cid);
 310                 iscsit_remove_ooo_cmdsn(sess, ooo_cmdsn);
 311         }
 312         mutex_unlock(&sess->cmdsn_mutex);
 313
 314         spin_lock_bh(&conn->cmd_lock);
 315         list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_list) {
 316                 if (!(cmd->cmd_flags & ICF_OOO_CMDSN))
 317                         continue;
 318
 319                 list_del(&cmd->i_list);
 320
 321                 spin_unlock_bh(&conn->cmd_lock);
 322                 if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) ||
 323                     !(cmd->se_cmd.transport_wait_for_tasks))
 324                         iscsit_release_cmd(cmd);
 325                 else
 326                         cmd->se_cmd.transport_wait_for_tasks(
 327                                         &cmd->se_cmd, 1, 1);
 328                 spin_lock_bh(&conn->cmd_lock);
 329         }
 330         spin_unlock_bh(&conn->cmd_lock);
 331
 332         pr_debug("Dropped %u total unacknowledged commands on CID:"
 333                 " %hu for ExpCmdSN: 0x%08x.\n", dropped_count, conn->cid,
 334                                 sess->exp_cmd_sn);
 335         return 0;
 336 }
 337
 338 int iscsit_prepare_cmds_for_realligance(struct iscsi_conn *conn)
 339 {
 340         u32 cmd_count = 0;
 341         struct iscsi_cmd *cmd, *cmd_tmp;
 342         struct iscsi_conn_recovery *cr;
 343
 344         /*
 345          * Allocate an struct iscsi_conn_recovery for this connection.
 346          * Each struct iscsi_cmd contains an struct iscsi_conn_recovery pointer
 347          * (struct iscsi_cmd->cr) so we need to allocate this before preparing the
 348          * connection's command list for connection recovery.
 349          */
 350         cr = kzalloc(sizeof(struct iscsi_conn_recovery), GFP_KERNEL);
 351         if (!cr) {
 352                 pr_err("Unable to allocate memory for"
 353                         " struct iscsi_conn_recovery.\n");
 354                 return -1;
 355         }
 356         INIT_LIST_HEAD(&cr->cr_list);
 357         INIT_LIST_HEAD(&cr->conn_recovery_cmd_list);
 358         spin_lock_init(&cr->conn_recovery_cmd_lock);
 359         /*
 360          * Only perform connection recovery on ISCSI_OP_SCSI_CMD or
 361          * ISCSI_OP_NOOP_OUT opcodes.  For all other opcodes call
 362          * list_del(&cmd->i_list); to release the command to the
 363          * session pool and remove it from the connection's list.
 364          *
 365          * Also stop the DataOUT timer, which will be restarted after
 366          * sending the TMR response.
 367          */
 368         spin_lock_bh(&conn->cmd_lock);
 369         list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_list) {
 370
 371                 if ((cmd->iscsi_opcode != ISCSI_OP_SCSI_CMD) &&
 372                     (cmd->iscsi_opcode != ISCSI_OP_NOOP_OUT)) {
 373                         pr_debug("Not performing realligence on"
 374                                 " Opcode: 0x%02x, ITT: 0x%08x, CmdSN: 0x%08x,"
 375                                 " CID: %hu\n", cmd->iscsi_opcode,
 376                                 cmd->init_task_tag, cmd->cmd_sn, conn->cid);
 377
 378                         list_del(&cmd->i_list);
 379                         spin_unlock_bh(&conn->cmd_lock);
 380
 381                         if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) ||
 382                             !(cmd->se_cmd.transport_wait_for_tasks))
 383                                 iscsit_release_cmd(cmd);
 384                         else
 385                                 cmd->se_cmd.transport_wait_for_tasks(
 386                                                 &cmd->se_cmd, 1, 0);
 387                         spin_lock_bh(&conn->cmd_lock);
 388                         continue;
 389                 }
 390
 391                 /*
 392                  * Special case where commands greater than or equal to
 393                  * the session's ExpCmdSN are attached to the connection
 394                  * list but not to the out of order CmdSN list.  The one
 395                  * obvious case is when a command with immediate data
 396                  * attached must only check the CmdSN against ExpCmdSN
 397                  * after the data is received.  The special case below
 398                  * is when the connection fails before data is received,
 399                  * but also may apply to other PDUs, so it has been
 400                  * made generic here.
 401                  */
 402                 if (!(cmd->cmd_flags & ICF_OOO_CMDSN) && !cmd->immediate_cmd &&
 403                      (cmd->cmd_sn >= conn->sess->exp_cmd_sn)) {
 404                         list_del(&cmd->i_list);
 405                         spin_unlock_bh(&conn->cmd_lock);
 406
 407                         if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) ||
 408                             !(cmd->se_cmd.transport_wait_for_tasks))
 409                                 iscsit_release_cmd(cmd);
 410                         else
 411                                 cmd->se_cmd.transport_wait_for_tasks(
 412                                                 &cmd->se_cmd, 1, 1);
 413                         spin_lock_bh(&conn->cmd_lock);
 414                         continue;
 415                 }
 416
 417                 cmd_count++;
 418                 pr_debug("Preparing Opcode: 0x%02x, ITT: 0x%08x,"
 419                         " CmdSN: 0x%08x, StatSN: 0x%08x, CID: %hu for"
 420                         " realligence.\n", cmd->iscsi_opcode,
 421                         cmd->init_task_tag, cmd->cmd_sn, cmd->stat_sn,
 422                         conn->cid);
 423
 424                 cmd->deferred_i_state = cmd->i_state;
 425                 cmd->i_state = ISTATE_IN_CONNECTION_RECOVERY;
 426
 427                 if (cmd->data_direction == DMA_TO_DEVICE)
 428                         iscsit_stop_dataout_timer(cmd);
 429
 430                 cmd->sess = conn->sess;
 431
 432                 list_del(&cmd->i_list);
 433                 spin_unlock_bh(&conn->cmd_lock);
 434
 435                 iscsit_free_all_datain_reqs(cmd);
 436
 437                 if ((cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) &&
 438                      cmd->se_cmd.transport_wait_for_tasks)
 439                         cmd->se_cmd.transport_wait_for_tasks(&cmd->se_cmd,
 440                                         0, 0);
 441                 /*
 442                  * Add the struct iscsi_cmd to the connection recovery cmd list
 443                  */
 444                 spin_lock(&cr->conn_recovery_cmd_lock);
 445                 list_add_tail(&cmd->i_list, &cr->conn_recovery_cmd_list);
 446                 spin_unlock(&cr->conn_recovery_cmd_lock);
 447
 448                 spin_lock_bh(&conn->cmd_lock);
 449                 cmd->cr = cr;
 450                 cmd->conn = NULL;
 451         }
 452         spin_unlock_bh(&conn->cmd_lock);
 453         /*
 454          * Fill in the various values in the preallocated struct iscsi_conn_recovery.
 455          */
 456         cr->cid = conn->cid;
 457         cr->cmd_count = cmd_count;
 458         cr->maxrecvdatasegmentlength = conn->conn_ops->MaxRecvDataSegmentLength;
 459         cr->sess = conn->sess;
 460
 461         iscsit_attach_inactive_connection_recovery_entry(conn->sess, cr);
 462
 463         return 0;
 464 }
 465
 466 int iscsit_connection_recovery_transport_reset(struct iscsi_conn *conn)
 467 {
 468         atomic_set(&conn->connection_recovery, 1);
 469
 470         if (iscsit_close_connection(conn) < 0)
 471                 return -1;
 472
 473         return 0;
 474 }