target/iscsi/iscsi_target_erl2.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*******************************************************************************
0003  * This file contains error recovery level two functions used by
0004  * the iSCSI Target driver.
0005  *
0006  * (c) Copyright 2007-2013 Datera, Inc.
0007  *
0008  * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
0009  *
0010  ******************************************************************************/
0011
0012 #include <linux/slab.h>
0013 #include <scsi/iscsi_proto.h>
0014 #include <target/target_core_base.h>
0015 #include <target/target_core_fabric.h>
0016
0017 #include <target/iscsi/iscsi_target_core.h>
0018 #include "iscsi_target_datain_values.h"
0019 #include "iscsi_target_util.h"
0020 #include "iscsi_target_erl0.h"
0021 #include "iscsi_target_erl1.h"
0022 #include "iscsi_target_erl2.h"
0023 #include "iscsi_target.h"
0024
0025 /*
0026  *  FIXME: Does RData SNACK apply here as well?
0027  */
0028 void iscsit_create_conn_recovery_datain_values(
0029     struct iscsit_cmd *cmd,
0030     __be32 exp_data_sn)
0031 {
0032     u32 data_sn = 0;
0033     struct iscsit_conn *conn = cmd->conn;
0034
0035     cmd->next_burst_len = 0;
0036     cmd->read_data_done = 0;
0037
0038     while (be32_to_cpu(exp_data_sn) > data_sn) {
0039         if ((cmd->next_burst_len +
0040              conn->conn_ops->MaxRecvDataSegmentLength) <
0041              conn->sess->sess_ops->MaxBurstLength) {
0042             cmd->read_data_done +=
0043                    conn->conn_ops->MaxRecvDataSegmentLength;
0044             cmd->next_burst_len +=
0045                    conn->conn_ops->MaxRecvDataSegmentLength;
0046         } else {
0047             cmd->read_data_done +=
0048                 (conn->sess->sess_ops->MaxBurstLength -
0049                 cmd->next_burst_len);
0050             cmd->next_burst_len = 0;
0051         }
0052         data_sn++;
0053     }
0054 }
0055
0056 void iscsit_create_conn_recovery_dataout_values(
0057     struct iscsit_cmd *cmd)
0058 {
0059     u32 write_data_done = 0;
0060     struct iscsit_conn *conn = cmd->conn;
0061
0062     cmd->data_sn = 0;
0063     cmd->next_burst_len = 0;
0064
0065     while (cmd->write_data_done > write_data_done) {
0066         if ((write_data_done + conn->sess->sess_ops->MaxBurstLength) <=
0067              cmd->write_data_done)
0068             write_data_done += conn->sess->sess_ops->MaxBurstLength;
0069         else
0070             break;
0071     }
0072
0073     cmd->write_data_done = write_data_done;
0074 }
0075
0076 static int iscsit_attach_active_connection_recovery_entry(
0077     struct iscsit_session *sess,
0078     struct iscsi_conn_recovery *cr)
0079 {
0080     spin_lock(&sess->cr_a_lock);
0081     list_add_tail(&cr->cr_list, &sess->cr_active_list);
0082     spin_unlock(&sess->cr_a_lock);
0083
0084     return 0;
0085 }
0086
0087 static int iscsit_attach_inactive_connection_recovery_entry(
0088     struct iscsit_session *sess,
0089     struct iscsi_conn_recovery *cr)
0090 {
0091     spin_lock(&sess->cr_i_lock);
0092     list_add_tail(&cr->cr_list, &sess->cr_inactive_list);
0093
0094     sess->conn_recovery_count++;
0095     pr_debug("Incremented connection recovery count to %u for"
0096         " SID: %u\n", sess->conn_recovery_count, sess->sid);
0097     spin_unlock(&sess->cr_i_lock);
0098
0099     return 0;
0100 }
0101
0102 struct iscsi_conn_recovery *iscsit_get_inactive_connection_recovery_entry(
0103     struct iscsit_session *sess,
0104     u16 cid)
0105 {
0106     struct iscsi_conn_recovery *cr;
0107
0108     spin_lock(&sess->cr_i_lock);
0109     list_for_each_entry(cr, &sess->cr_inactive_list, cr_list) {
0110         if (cr->cid == cid) {
0111             spin_unlock(&sess->cr_i_lock);
0112             return cr;
0113         }
0114     }
0115     spin_unlock(&sess->cr_i_lock);
0116
0117     return NULL;
0118 }
0119
0120 void iscsit_free_connection_recovery_entries(struct iscsit_session *sess)
0121 {
0122     struct iscsit_cmd *cmd, *cmd_tmp;
0123     struct iscsi_conn_recovery *cr, *cr_tmp;
0124
0125     spin_lock(&sess->cr_a_lock);
0126     list_for_each_entry_safe(cr, cr_tmp, &sess->cr_active_list, cr_list) {
0127         list_del(&cr->cr_list);
0128         spin_unlock(&sess->cr_a_lock);
0129
0130         spin_lock(&cr->conn_recovery_cmd_lock);
0131         list_for_each_entry_safe(cmd, cmd_tmp,
0132                 &cr->conn_recovery_cmd_list, i_conn_node) {
0133
0134             list_del_init(&cmd->i_conn_node);
0135             cmd->conn = NULL;
0136             spin_unlock(&cr->conn_recovery_cmd_lock);
0137             iscsit_free_cmd(cmd, true);
0138             spin_lock(&cr->conn_recovery_cmd_lock);
0139         }
0140         spin_unlock(&cr->conn_recovery_cmd_lock);
0141         spin_lock(&sess->cr_a_lock);
0142
0143         kfree(cr);
0144     }
0145     spin_unlock(&sess->cr_a_lock);
0146
0147     spin_lock(&sess->cr_i_lock);
0148     list_for_each_entry_safe(cr, cr_tmp, &sess->cr_inactive_list, cr_list) {
0149         list_del(&cr->cr_list);
0150         spin_unlock(&sess->cr_i_lock);
0151
0152         spin_lock(&cr->conn_recovery_cmd_lock);
0153         list_for_each_entry_safe(cmd, cmd_tmp,
0154                 &cr->conn_recovery_cmd_list, i_conn_node) {
0155
0156             list_del_init(&cmd->i_conn_node);
0157             cmd->conn = NULL;
0158             spin_unlock(&cr->conn_recovery_cmd_lock);
0159             iscsit_free_cmd(cmd, true);
0160             spin_lock(&cr->conn_recovery_cmd_lock);
0161         }
0162         spin_unlock(&cr->conn_recovery_cmd_lock);
0163         spin_lock(&sess->cr_i_lock);
0164
0165         kfree(cr);
0166     }
0167     spin_unlock(&sess->cr_i_lock);
0168 }
0169
0170 int iscsit_remove_active_connection_recovery_entry(
0171     struct iscsi_conn_recovery *cr,
0172     struct iscsit_session *sess)
0173 {
0174     spin_lock(&sess->cr_a_lock);
0175     list_del(&cr->cr_list);
0176
0177     sess->conn_recovery_count--;
0178     pr_debug("Decremented connection recovery count to %u for"
0179         " SID: %u\n", sess->conn_recovery_count, sess->sid);
0180     spin_unlock(&sess->cr_a_lock);
0181
0182     kfree(cr);
0183
0184     return 0;
0185 }
0186
0187 static void iscsit_remove_inactive_connection_recovery_entry(
0188     struct iscsi_conn_recovery *cr,
0189     struct iscsit_session *sess)
0190 {
0191     spin_lock(&sess->cr_i_lock);
0192     list_del(&cr->cr_list);
0193     spin_unlock(&sess->cr_i_lock);
0194 }
0195
0196 /*
0197  *  Called with cr->conn_recovery_cmd_lock help.
0198  */
0199 int iscsit_remove_cmd_from_connection_recovery(
0200     struct iscsit_cmd *cmd,
0201     struct iscsit_session *sess)
0202 {
0203     struct iscsi_conn_recovery *cr;
0204
0205     if (!cmd->cr) {
0206         pr_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
0207             " is NULL!\n", cmd->init_task_tag);
0208         BUG();
0209     }
0210     cr = cmd->cr;
0211
0212     list_del_init(&cmd->i_conn_node);
0213     return --cr->cmd_count;
0214 }
0215
0216 void iscsit_discard_cr_cmds_by_expstatsn(
0217     struct iscsi_conn_recovery *cr,
0218     u32 exp_statsn)
0219 {
0220     u32 dropped_count = 0;
0221     struct iscsit_cmd *cmd, *cmd_tmp;
0222     struct iscsit_session *sess = cr->sess;
0223
0224     spin_lock(&cr->conn_recovery_cmd_lock);
0225     list_for_each_entry_safe(cmd, cmd_tmp,
0226             &cr->conn_recovery_cmd_list, i_conn_node) {
0227
0228         if (((cmd->deferred_i_state != ISTATE_SENT_STATUS) &&
0229              (cmd->deferred_i_state != ISTATE_REMOVE)) ||
0230              (cmd->stat_sn >= exp_statsn)) {
0231             continue;
0232         }
0233
0234         dropped_count++;
0235         pr_debug("Dropping Acknowledged ITT: 0x%08x, StatSN:"
0236             " 0x%08x, CID: %hu.\n", cmd->init_task_tag,
0237                 cmd->stat_sn, cr->cid);
0238
0239         iscsit_remove_cmd_from_connection_recovery(cmd, sess);
0240
0241         spin_unlock(&cr->conn_recovery_cmd_lock);
0242         iscsit_free_cmd(cmd, true);
0243         spin_lock(&cr->conn_recovery_cmd_lock);
0244     }
0245     spin_unlock(&cr->conn_recovery_cmd_lock);
0246
0247     pr_debug("Dropped %u total acknowledged commands on"
0248         " CID: %hu less than old ExpStatSN: 0x%08x\n",
0249             dropped_count, cr->cid, exp_statsn);
0250
0251     if (!cr->cmd_count) {
0252         pr_debug("No commands to be reassigned for failed"
0253             " connection CID: %hu on SID: %u\n",
0254             cr->cid, sess->sid);
0255         iscsit_remove_inactive_connection_recovery_entry(cr, sess);
0256         iscsit_attach_active_connection_recovery_entry(sess, cr);
0257         pr_debug("iSCSI connection recovery successful for CID:"
0258             " %hu on SID: %u\n", cr->cid, sess->sid);
0259         iscsit_remove_active_connection_recovery_entry(cr, sess);
0260     } else {
0261         iscsit_remove_inactive_connection_recovery_entry(cr, sess);
0262         iscsit_attach_active_connection_recovery_entry(sess, cr);
0263     }
0264 }
0265
0266 int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsit_conn *conn)
0267 {
0268     u32 dropped_count = 0;
0269     struct iscsit_cmd *cmd, *cmd_tmp;
0270     struct iscsi_ooo_cmdsn *ooo_cmdsn, *ooo_cmdsn_tmp;
0271     struct iscsit_session *sess = conn->sess;
0272
0273     mutex_lock(&sess->cmdsn_mutex);
0274     list_for_each_entry_safe(ooo_cmdsn, ooo_cmdsn_tmp,
0275             &sess->sess_ooo_cmdsn_list, ooo_list) {
0276
0277         if (ooo_cmdsn->cid != conn->cid)
0278             continue;
0279
0280         dropped_count++;
0281         pr_debug("Dropping unacknowledged CmdSN:"
0282         " 0x%08x during connection recovery on CID: %hu\n",
0283             ooo_cmdsn->cmdsn, conn->cid);
0284         iscsit_remove_ooo_cmdsn(sess, ooo_cmdsn);
0285     }
0286     mutex_unlock(&sess->cmdsn_mutex);
0287
0288     spin_lock_bh(&conn->cmd_lock);
0289     list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_conn_node) {
0290         if (!(cmd->cmd_flags & ICF_OOO_CMDSN))
0291             continue;
0292
0293         list_del_init(&cmd->i_conn_node);
0294
0295         spin_unlock_bh(&conn->cmd_lock);
0296         iscsit_free_cmd(cmd, true);
0297         spin_lock_bh(&conn->cmd_lock);
0298     }
0299     spin_unlock_bh(&conn->cmd_lock);
0300
0301     pr_debug("Dropped %u total unacknowledged commands on CID:"
0302         " %hu for ExpCmdSN: 0x%08x.\n", dropped_count, conn->cid,
0303                 sess->exp_cmd_sn);
0304     return 0;
0305 }
0306
0307 int iscsit_prepare_cmds_for_reallegiance(struct iscsit_conn *conn)
0308 {
0309     u32 cmd_count = 0;
0310     struct iscsit_cmd *cmd, *cmd_tmp;
0311     struct iscsi_conn_recovery *cr;
0312
0313     /*
0314      * Allocate an struct iscsi_conn_recovery for this connection.
0315      * Each struct iscsit_cmd contains an struct iscsi_conn_recovery pointer
0316      * (struct iscsit_cmd->cr) so we need to allocate this before preparing the
0317      * connection's command list for connection recovery.
0318      */
0319     cr = kzalloc(sizeof(struct iscsi_conn_recovery), GFP_KERNEL);
0320     if (!cr) {
0321         pr_err("Unable to allocate memory for"
0322             " struct iscsi_conn_recovery.\n");
0323         return -1;
0324     }
0325     INIT_LIST_HEAD(&cr->cr_list);
0326     INIT_LIST_HEAD(&cr->conn_recovery_cmd_list);
0327     spin_lock_init(&cr->conn_recovery_cmd_lock);
0328     /*
0329      * Only perform connection recovery on ISCSI_OP_SCSI_CMD or
0330      * ISCSI_OP_NOOP_OUT opcodes.  For all other opcodes call
0331      * list_del_init(&cmd->i_conn_node); to release the command to the
0332      * session pool and remove it from the connection's list.
0333      *
0334      * Also stop the DataOUT timer, which will be restarted after
0335      * sending the TMR response.
0336      */
0337     spin_lock_bh(&conn->cmd_lock);
0338     list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_conn_node) {
0339
0340         if ((cmd->iscsi_opcode != ISCSI_OP_SCSI_CMD) &&
0341             (cmd->iscsi_opcode != ISCSI_OP_NOOP_OUT)) {
0342             pr_debug("Not performing reallegiance on"
0343                 " Opcode: 0x%02x, ITT: 0x%08x, CmdSN: 0x%08x,"
0344                 " CID: %hu\n", cmd->iscsi_opcode,
0345                 cmd->init_task_tag, cmd->cmd_sn, conn->cid);
0346
0347             list_del_init(&cmd->i_conn_node);
0348             spin_unlock_bh(&conn->cmd_lock);
0349             iscsit_free_cmd(cmd, true);
0350             spin_lock_bh(&conn->cmd_lock);
0351             continue;
0352         }
0353
0354         /*
0355          * Special case where commands greater than or equal to
0356          * the session's ExpCmdSN are attached to the connection
0357          * list but not to the out of order CmdSN list.  The one
0358          * obvious case is when a command with immediate data
0359          * attached must only check the CmdSN against ExpCmdSN
0360          * after the data is received.  The special case below
0361          * is when the connection fails before data is received,
0362          * but also may apply to other PDUs, so it has been
0363          * made generic here.
0364          */
0365         if (!(cmd->cmd_flags & ICF_OOO_CMDSN) && !cmd->immediate_cmd &&
0366              iscsi_sna_gte(cmd->cmd_sn, conn->sess->exp_cmd_sn)) {
0367             list_del_init(&cmd->i_conn_node);
0368             spin_unlock_bh(&conn->cmd_lock);
0369             iscsit_free_cmd(cmd, true);
0370             spin_lock_bh(&conn->cmd_lock);
0371             continue;
0372         }
0373
0374         cmd_count++;
0375         pr_debug("Preparing Opcode: 0x%02x, ITT: 0x%08x,"
0376             " CmdSN: 0x%08x, StatSN: 0x%08x, CID: %hu for"
0377             " reallegiance.\n", cmd->iscsi_opcode,
0378             cmd->init_task_tag, cmd->cmd_sn, cmd->stat_sn,
0379             conn->cid);
0380
0381         cmd->deferred_i_state = cmd->i_state;
0382         cmd->i_state = ISTATE_IN_CONNECTION_RECOVERY;
0383
0384         if (cmd->data_direction == DMA_TO_DEVICE)
0385             iscsit_stop_dataout_timer(cmd);
0386
0387         cmd->sess = conn->sess;
0388
0389         list_del_init(&cmd->i_conn_node);
0390         spin_unlock_bh(&conn->cmd_lock);
0391
0392         iscsit_free_all_datain_reqs(cmd);
0393
0394         transport_wait_for_tasks(&cmd->se_cmd);
0395         /*
0396          * Add the struct iscsit_cmd to the connection recovery cmd list
0397          */
0398         spin_lock(&cr->conn_recovery_cmd_lock);
0399         list_add_tail(&cmd->i_conn_node, &cr->conn_recovery_cmd_list);
0400         spin_unlock(&cr->conn_recovery_cmd_lock);
0401
0402         spin_lock_bh(&conn->cmd_lock);
0403         cmd->cr = cr;
0404         cmd->conn = NULL;
0405     }
0406     spin_unlock_bh(&conn->cmd_lock);
0407     /*
0408      * Fill in the various values in the preallocated struct iscsi_conn_recovery.
0409      */
0410     cr->cid = conn->cid;
0411     cr->cmd_count = cmd_count;
0412     cr->maxrecvdatasegmentlength = conn->conn_ops->MaxRecvDataSegmentLength;
0413     cr->maxxmitdatasegmentlength = conn->conn_ops->MaxXmitDataSegmentLength;
0414     cr->sess = conn->sess;
0415
0416     iscsit_attach_inactive_connection_recovery_entry(conn->sess, cr);
0417
0418     return 0;
0419 }
0420
0421 int iscsit_connection_recovery_transport_reset(struct iscsit_conn *conn)
0422 {
0423     atomic_set(&conn->connection_recovery, 1);
0424
0425     if (iscsit_close_connection(conn) < 0)
0426         return -1;
0427
0428     return 0;
0429 }