target/iscsi: Eliminate iscsi_cmd.data_length

Redundant, just use iscsi_cmd->se_cmd.data_length once se_cmd is
initialized, or hdr->data_length before then.

Signed-off-by: Andy Grover <agrover@redhat.com>
Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>

8 files changed, 60 insertions, 67 deletions

diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index 1b51a3ed17f5..a29a1bb279d5 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -968,7 +968,6 @@ done:
                                          buf, conn);
 
         cmd->data_direction = data_direction;
-        cmd->data_length = hdr->data_length;
         iscsi_task_attr = hdr->flags & ISCSI_FLAG_CMD_ATTR_MASK;
         /*
          * Figure out the SAM Task Attribute for the incoming SCSI CDB
@@ -1026,7 +1025,7 @@ done:
          * Initialize struct se_cmd descriptor from target_core_mod infrastructure
          */
         transport_init_se_cmd(&cmd->se_cmd, &lio_target_fabric_configfs->tf_ops,
-                        conn->sess->se_sess, cmd->data_length, cmd->data_direction,
+                        conn->sess->se_sess, hdr->data_length, cmd->data_direction,
                         sam_task_attr, &cmd->sense_buffer[0]);
 
         pr_debug("Got SCSI Command, ITT: 0x%08x, CmdSN: 0x%08x,"
@@ -1061,8 +1060,6 @@ done:
                  */
                 send_check_condition = 1;
         } else {
-                cmd->data_length = cmd->se_cmd.data_length;
-
                 if (iscsit_decide_list_to_build(cmd, payload_length) < 0)
                         return iscsit_add_reject_from_cmd(
                                 ISCSI_REASON_BOOKMARK_NO_RESOURCES,
@@ -1329,10 +1326,10 @@ static int iscsit_handle_data_out(struct iscsi_conn *conn, unsigned char *buf)
         se_cmd = &cmd->se_cmd;
         iscsit_mod_dataout_timer(cmd);
 
-        if ((hdr->offset + payload_length) > cmd->data_length) {
+        if ((hdr->offset + payload_length) > cmd->se_cmd.data_length) {
                 pr_err("DataOut Offset: %u, Length %u greater than"
                         " iSCSI Command EDTL %u, protocol error.\n",
-                        hdr->offset, payload_length, cmd->data_length);
+                        hdr->offset, payload_length, cmd->se_cmd.data_length);
                 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID,
                                 1, 0, buf, cmd);
         }
@@ -2427,7 +2424,7 @@ static int iscsit_handle_immediate_data(
 
         cmd->write_data_done += length;
 
-        if (cmd->write_data_done == cmd->data_length) {
+        if (cmd->write_data_done == cmd->se_cmd.data_length) {
                 spin_lock_bh(&cmd->istate_lock);
                 cmd->cmd_flags |= ICF_GOT_LAST_DATAOUT;
                 cmd->i_state = ISTATE_RECEIVED_LAST_DATAOUT;
@@ -2559,11 +2556,11 @@ static int iscsit_send_data_in(
         /*
          * Be paranoid and double check the logic for now.
          */
-        if ((datain.offset + datain.length) > cmd->data_length) {
+        if ((datain.offset + datain.length) > cmd->se_cmd.data_length) {
                 pr_err("Command ITT: 0x%08x, datain.offset: %u and"
                         " datain.length: %u exceeds cmd->data_length: %u\n",
                         cmd->init_task_tag, datain.offset, datain.length,
-                                cmd->data_length);
+                                cmd->se_cmd.data_length);
                 return -1;
         }
 
@@ -3071,8 +3068,8 @@ int iscsit_build_r2ts_for_cmd(
                                         conn->sess->sess_ops->MaxBurstLength -
                                         cmd->next_burst_len;
 
-                                if (new_data_end > cmd->data_length)
-                                        xfer_len = cmd->data_length - offset;
+                                if (new_data_end > cmd->se_cmd.data_length)
+                                        xfer_len = cmd->se_cmd.data_length - offset;
                                 else
                                         xfer_len =
                                                 conn->sess->sess_ops->MaxBurstLength -
@@ -3081,14 +3078,14 @@ int iscsit_build_r2ts_for_cmd(
                                 int new_data_end = offset +
                                         conn->sess->sess_ops->MaxBurstLength;
 
-                                if (new_data_end > cmd->data_length)
-                                        xfer_len = cmd->data_length - offset;
+                                if (new_data_end > cmd->se_cmd.data_length)
+                                        xfer_len = cmd->se_cmd.data_length - offset;
                                 else
                                         xfer_len = conn->sess->sess_ops->MaxBurstLength;
                         }
                         cmd->r2t_offset += xfer_len;
 
-                        if (cmd->r2t_offset == cmd->data_length)
+                        if (cmd->r2t_offset == cmd->se_cmd.data_length)
                                 cmd->cmd_flags |= ICF_SENT_LAST_R2T;
                 } else {
                         struct iscsi_seq *seq;
diff --git a/drivers/target/iscsi/iscsi_target_core.h b/drivers/target/iscsi/iscsi_target_core.h
index 1a9a64ab4feb..94c736e3a640 100644
--- a/drivers/target/iscsi/iscsi_target_core.h
+++ b/drivers/target/iscsi/iscsi_target_core.h
@@ -380,8 +380,6 @@ struct iscsi_cmd {
         u32                     buf_ptr_size;
         /* Used to store DataDigest */
         u32                     data_crc;
-        /* Total size in bytes associated with command */
-        u32                     data_length;
         /* Counter for MaxOutstandingR2T */
         u32                     outstanding_r2ts;
         /* Next R2T Offset when DataSequenceInOrder=Yes */
diff --git a/drivers/target/iscsi/iscsi_target_datain_values.c b/drivers/target/iscsi/iscsi_target_datain_values.c
index c19ca42eac67..848fee768948 100644
--- a/drivers/target/iscsi/iscsi_target_datain_values.c
+++ b/drivers/target/iscsi/iscsi_target_datain_values.c
@@ -110,7 +110,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_yes_and_yes(
         read_data_done = (!dr->recovery) ?
                         cmd->read_data_done : dr->read_data_done;
 
-        read_data_left = (cmd->data_length - read_data_done);
+        read_data_left = (cmd->se_cmd.data_length - read_data_done);
         if (!read_data_left) {
                 pr_err("ITT: 0x%08x read_data_left is zero!\n",
                                 cmd->init_task_tag);
@@ -209,7 +209,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_no_and_yes(
         seq_send_order = (!dr->recovery) ?
                         cmd->seq_send_order : dr->seq_send_order;
 
-        read_data_left = (cmd->data_length - read_data_done);
+        read_data_left = (cmd->se_cmd.data_length - read_data_done);
         if (!read_data_left) {
                 pr_err("ITT: 0x%08x read_data_left is zero!\n",
                                 cmd->init_task_tag);
@@ -228,8 +228,8 @@ static struct iscsi_datain_req *iscsit_set_datain_values_no_and_yes(
         offset = (seq->offset + seq->next_burst_len);
 
         if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >=
-             cmd->data_length) {
-                datain->length = (cmd->data_length - offset);
+             cmd->se_cmd.data_length) {
+                datain->length = (cmd->se_cmd.data_length - offset);
                 datain->offset = offset;
 
                 datain->flags |= ISCSI_FLAG_CMD_FINAL;
@@ -261,7 +261,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_no_and_yes(
                 }
         }
 
-        if ((read_data_done + datain->length) == cmd->data_length)
+        if ((read_data_done + datain->length) == cmd->se_cmd.data_length)
                 datain->flags |= ISCSI_FLAG_DATA_STATUS;
 
         datain->data_sn = (!dr->recovery) ? cmd->data_sn++ : dr->data_sn++;
@@ -330,7 +330,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_yes_and_no(
         read_data_done = (!dr->recovery) ?
                         cmd->read_data_done : dr->read_data_done;
 
-        read_data_left = (cmd->data_length - read_data_done);
+        read_data_left = (cmd->se_cmd.data_length - read_data_done);
         if (!read_data_left) {
                 pr_err("ITT: 0x%08x read_data_left is zero!\n",
                                 cmd->init_task_tag);
@@ -341,7 +341,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_yes_and_no(
         if (!pdu)
                 return dr;
 
-        if ((read_data_done + pdu->length) == cmd->data_length) {
+        if ((read_data_done + pdu->length) == cmd->se_cmd.data_length) {
                 pdu->flags |= (ISCSI_FLAG_CMD_FINAL | ISCSI_FLAG_DATA_STATUS);
                 if (conn->sess->sess_ops->ErrorRecoveryLevel > 0)
                         pdu->flags |= ISCSI_FLAG_DATA_ACK;
@@ -430,7 +430,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_no_and_no(
         seq_send_order = (!dr->recovery) ?
                         cmd->seq_send_order : dr->seq_send_order;
 
-        read_data_left = (cmd->data_length - read_data_done);
+        read_data_left = (cmd->se_cmd.data_length - read_data_done);
         if (!read_data_left) {
                 pr_err("ITT: 0x%08x read_data_left is zero!\n",
                                 cmd->init_task_tag);
@@ -460,7 +460,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_no_and_no(
         } else
                 seq->next_burst_len += pdu->length;
 
-        if ((read_data_done + pdu->length) == cmd->data_length)
+        if ((read_data_done + pdu->length) == cmd->se_cmd.data_length)
                 pdu->flags |= ISCSI_FLAG_DATA_STATUS;
 
         pdu->data_sn = (!dr->recovery) ? cmd->data_sn++ : dr->data_sn++;
diff --git a/drivers/target/iscsi/iscsi_target_erl0.c b/drivers/target/iscsi/iscsi_target_erl0.c
index dd11520eb8b4..1a02016ecdab 100644
--- a/drivers/target/iscsi/iscsi_target_erl0.c
+++ b/drivers/target/iscsi/iscsi_target_erl0.c
@@ -48,9 +48,9 @@ void iscsit_set_dataout_sequence_values(
         if (cmd->unsolicited_data) {
                 cmd->seq_start_offset = cmd->write_data_done;
                 cmd->seq_end_offset = (cmd->write_data_done +
-                        (cmd->data_length >
+                        (cmd->se_cmd.data_length >
                          conn->sess->sess_ops->FirstBurstLength) ?
-                        conn->sess->sess_ops->FirstBurstLength : cmd->data_length);
+                        conn->sess->sess_ops->FirstBurstLength : cmd->se_cmd.data_length);
                 return;
         }
 
@@ -59,15 +59,15 @@ void iscsit_set_dataout_sequence_values(
 
         if (!cmd->seq_start_offset && !cmd->seq_end_offset) {
                 cmd->seq_start_offset = cmd->write_data_done;
-                cmd->seq_end_offset = (cmd->data_length >
+                cmd->seq_end_offset = (cmd->se_cmd.data_length >
                         conn->sess->sess_ops->MaxBurstLength) ?
                         (cmd->write_data_done +
-                        conn->sess->sess_ops->MaxBurstLength) : cmd->data_length;
+                        conn->sess->sess_ops->MaxBurstLength) : cmd->se_cmd.data_length;
         } else {
                 cmd->seq_start_offset = cmd->seq_end_offset;
                 cmd->seq_end_offset = ((cmd->seq_end_offset +
                         conn->sess->sess_ops->MaxBurstLength) >=
-                        cmd->data_length) ? cmd->data_length :
+                        cmd->se_cmd.data_length) ? cmd->se_cmd.data_length :
                         (cmd->seq_end_offset +
                          conn->sess->sess_ops->MaxBurstLength);
         }
@@ -182,13 +182,13 @@ static int iscsit_dataout_check_unsolicited_sequence(
                 if (!conn->sess->sess_ops->DataPDUInOrder)
                         goto out;
 
-                if ((first_burst_len != cmd->data_length) &&
+                if ((first_burst_len != cmd->se_cmd.data_length) &&
                     (first_burst_len != conn->sess->sess_ops->FirstBurstLength)) {
                         pr_err("Unsolicited non-immediate data"
                         " received %u does not equal FirstBurstLength: %u, and"
                         " does not equal ExpXferLen %u.\n", first_burst_len,
                                 conn->sess->sess_ops->FirstBurstLength,
-                                cmd->data_length);
+                                cmd->se_cmd.data_length);
                         transport_send_check_condition_and_sense(&cmd->se_cmd,
                                         TCM_INCORRECT_AMOUNT_OF_DATA, 0);
                         return DATAOUT_CANNOT_RECOVER;
@@ -201,10 +201,10 @@ static int iscsit_dataout_check_unsolicited_sequence(
                                 conn->sess->sess_ops->FirstBurstLength);
                         return DATAOUT_CANNOT_RECOVER;
                 }
-                if (first_burst_len == cmd->data_length) {
+                if (first_burst_len == cmd->se_cmd.data_length) {
                         pr_err("Command ITT: 0x%08x reached"
                         " ExpXferLen: %u, but ISCSI_FLAG_CMD_FINAL is not set. protocol"
-                        " error.\n", cmd->init_task_tag, cmd->data_length);
+                        " error.\n", cmd->init_task_tag, cmd->se_cmd.data_length);
                         return DATAOUT_CANNOT_RECOVER;
                 }
         }
@@ -294,7 +294,7 @@ static int iscsit_dataout_check_sequence(
                         if ((next_burst_len <
                              conn->sess->sess_ops->MaxBurstLength) &&
                            ((cmd->write_data_done + payload_length) <
-                             cmd->data_length)) {
+                             cmd->se_cmd.data_length)) {
                                 pr_err("Command ITT: 0x%08x set ISCSI_FLAG_CMD_FINAL"
                                 " before end of DataOUT sequence, protocol"
                                 " error.\n", cmd->init_task_tag);
@@ -319,7 +319,7 @@ static int iscsit_dataout_check_sequence(
                                 return DATAOUT_CANNOT_RECOVER;
                         }
                         if ((cmd->write_data_done + payload_length) ==
-                                        cmd->data_length) {
+                                        cmd->se_cmd.data_length) {
                                 pr_err("Command ITT: 0x%08x reached"
                                 " last DataOUT PDU in sequence but ISCSI_FLAG_"
                                 "CMD_FINAL is not set, protocol error.\n",
@@ -640,7 +640,7 @@ static int iscsit_dataout_post_crc_passed(
 
         cmd->write_data_done += payload_length;
 
-        if (cmd->write_data_done == cmd->data_length)
+        if (cmd->write_data_done == cmd->se_cmd.data_length)
                 return DATAOUT_SEND_TO_TRANSPORT;
         else if (send_r2t)
                 return DATAOUT_SEND_R2T;
diff --git a/drivers/target/iscsi/iscsi_target_erl1.c b/drivers/target/iscsi/iscsi_target_erl1.c
index 6deb8495d5f2..ecdd46deedda 100644
--- a/drivers/target/iscsi/iscsi_target_erl1.c
+++ b/drivers/target/iscsi/iscsi_target_erl1.c
@@ -1116,8 +1116,8 @@ static int iscsit_set_dataout_timeout_values(
         if (cmd->unsolicited_data) {
                 *offset = 0;
                 *length = (conn->sess->sess_ops->FirstBurstLength >
-                           cmd->data_length) ?
-                           cmd->data_length :
+                           cmd->se_cmd.data_length) ?
+                           cmd->se_cmd.data_length :
                            conn->sess->sess_ops->FirstBurstLength;
                 return 0;
         }
@@ -1188,8 +1188,8 @@ static void iscsit_handle_dataout_timeout(unsigned long data)
                 if (conn->sess->sess_ops->DataPDUInOrder) {
                         pdu_offset = cmd->write_data_done;
                         if ((pdu_offset + (conn->sess->sess_ops->MaxBurstLength -
-                             cmd->next_burst_len)) > cmd->data_length)
-                                pdu_length = (cmd->data_length -
+                             cmd->next_burst_len)) > cmd->se_cmd.data_length)
+                                pdu_length = (cmd->se_cmd.data_length -
                                         cmd->write_data_done);
                         else
                                 pdu_length = (conn->sess->sess_ops->MaxBurstLength -
diff --git a/drivers/target/iscsi/iscsi_target_seq_pdu_list.c b/drivers/target/iscsi/iscsi_target_seq_pdu_list.c
index c69c7577ad14..d98276581a19 100644
--- a/drivers/target/iscsi/iscsi_target_seq_pdu_list.c
+++ b/drivers/target/iscsi/iscsi_target_seq_pdu_list.c
@@ -226,11 +226,10 @@ static void iscsit_determine_counts_for_list(
 
         if ((bl->type == PDULIST_UNSOLICITED) ||
             (bl->type == PDULIST_IMMEDIATE_AND_UNSOLICITED))
-                unsolicited_data_length = (cmd->data_length >
-                        conn->sess->sess_ops->FirstBurstLength) ?
-                        conn->sess->sess_ops->FirstBurstLength : cmd->data_length;
+                unsolicited_data_length = min(cmd->se_cmd.data_length,
+                        conn->sess->sess_ops->FirstBurstLength);
 
-        while (offset < cmd->data_length) {
+        while (offset < cmd->se_cmd.data_length) {
                 *pdu_count += 1;
 
                 if (check_immediate) {
@@ -244,10 +243,10 @@ static void iscsit_determine_counts_for_list(
                 }
                 if (unsolicited_data_length > 0) {
                         if ((offset + conn->conn_ops->MaxRecvDataSegmentLength)
-                                        >= cmd->data_length) {
+                                        >= cmd->se_cmd.data_length) {
                                 unsolicited_data_length -=
-                                        (cmd->data_length - offset);
-                                offset += (cmd->data_length - offset);
+                                        (cmd->se_cmd.data_length - offset);
+                                offset += (cmd->se_cmd.data_length - offset);
                                 continue;
                         }
                         if ((offset + conn->conn_ops->MaxRecvDataSegmentLength)
@@ -268,8 +267,8 @@ static void iscsit_determine_counts_for_list(
                         continue;
                 }
                 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >=
-                     cmd->data_length) {
-                        offset += (cmd->data_length - offset);
+                     cmd->se_cmd.data_length) {
+                        offset += (cmd->se_cmd.data_length - offset);
                         continue;
                 }
                 if ((burstlength + conn->conn_ops->MaxRecvDataSegmentLength) >=
@@ -311,11 +310,10 @@ static int iscsit_build_pdu_and_seq_list(
 
         if ((bl->type == PDULIST_UNSOLICITED) ||
             (bl->type == PDULIST_IMMEDIATE_AND_UNSOLICITED))
-                unsolicited_data_length = (cmd->data_length >
-                        conn->sess->sess_ops->FirstBurstLength) ?
-                        conn->sess->sess_ops->FirstBurstLength : cmd->data_length;
+                unsolicited_data_length = min(cmd->se_cmd.data_length,
+                        conn->sess->sess_ops->FirstBurstLength);
 
-        while (offset < cmd->data_length) {
+        while (offset < cmd->se_cmd.data_length) {
                 pdu_count++;
                 if (!datapduinorder) {
                         pdu[i].offset = offset;
@@ -351,21 +349,21 @@ static int iscsit_build_pdu_and_seq_list(
                 if (unsolicited_data_length > 0) {
                         if ((offset +
                              conn->conn_ops->MaxRecvDataSegmentLength) >=
-                             cmd->data_length) {
+                             cmd->se_cmd.data_length) {
                                 if (!datapduinorder) {
                                         pdu[i].type = PDUTYPE_UNSOLICITED;
                                         pdu[i].length =
-                                                (cmd->data_length - offset);
+                                                (cmd->se_cmd.data_length - offset);
                                 }
                                 if (!datasequenceinorder) {
                                         seq[seq_no].type = SEQTYPE_UNSOLICITED;
                                         seq[seq_no].pdu_count = pdu_count;
                                         seq[seq_no].xfer_len = (burstlength +
-                                                (cmd->data_length - offset));
+                                                (cmd->se_cmd.data_length - offset));
                                 }
                                 unsolicited_data_length -=
-                                                (cmd->data_length - offset);
-                                offset += (cmd->data_length - offset);
+                                                (cmd->se_cmd.data_length - offset);
+                                offset += (cmd->se_cmd.data_length - offset);
                                 continue;
                         }
                         if ((offset +
@@ -407,18 +405,18 @@ static int iscsit_build_pdu_and_seq_list(
                         continue;
                 }
                 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >=
-                     cmd->data_length) {
+                     cmd->se_cmd.data_length) {
                         if (!datapduinorder) {
                                 pdu[i].type = PDUTYPE_NORMAL;
-                                pdu[i].length = (cmd->data_length - offset);
+                                pdu[i].length = (cmd->se_cmd.data_length - offset);
                         }
                         if (!datasequenceinorder) {
                                 seq[seq_no].type = SEQTYPE_NORMAL;
                                 seq[seq_no].pdu_count = pdu_count;
                                 seq[seq_no].xfer_len = (burstlength +
-                                        (cmd->data_length - offset));
+                                        (cmd->se_cmd.data_length - offset));
                         }
-                        offset += (cmd->data_length - offset);
+                        offset += (cmd->se_cmd.data_length - offset);
                         continue;
                 }
                 if ((burstlength + conn->conn_ops->MaxRecvDataSegmentLength) >=
diff --git a/drivers/target/iscsi/iscsi_target_tmr.c b/drivers/target/iscsi/iscsi_target_tmr.c
index 3f025fa10467..f4e640b51fd1 100644
--- a/drivers/target/iscsi/iscsi_target_tmr.c
+++ b/drivers/target/iscsi/iscsi_target_tmr.c
@@ -269,9 +269,9 @@ static int iscsit_task_reassign_complete_write(
                 offset = cmd->next_burst_len = cmd->write_data_done;
 
                 if ((conn->sess->sess_ops->FirstBurstLength - offset) >=
-                     cmd->data_length) {
+                     cmd->se_cmd.data_length) {
                         no_build_r2ts = 1;
-                        length = (cmd->data_length - offset);
+                        length = (cmd->se_cmd.data_length - offset);
                 } else
                         length = (conn->sess->sess_ops->FirstBurstLength - offset);
 
diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c
index 66a6e9ba86fe..1f5a456f26b4 100644
--- a/drivers/target/iscsi/iscsi_target_util.c
+++ b/drivers/target/iscsi/iscsi_target_util.c
@@ -379,14 +379,14 @@ int iscsit_check_unsolicited_dataout(struct iscsi_cmd *cmd, unsigned char *buf)
         if (!(hdr->flags & ISCSI_FLAG_CMD_FINAL))
                 return 0;
 
-        if (((cmd->first_burst_len + payload_length) != cmd->data_length) &&
+        if (((cmd->first_burst_len + payload_length) != cmd->se_cmd.data_length) &&
             ((cmd->first_burst_len + payload_length) !=
               conn->sess->sess_ops->FirstBurstLength)) {
                 pr_err("Unsolicited non-immediate data received %u"
                         " does not equal FirstBurstLength: %u, and does"
                         " not equal ExpXferLen %u.\n",
                         (cmd->first_burst_len + payload_length),
-                        conn->sess->sess_ops->FirstBurstLength, cmd->data_length);
+                        conn->sess->sess_ops->FirstBurstLength, cmd->se_cmd.data_length);
                 transport_send_check_condition_and_sense(se_cmd,
                                 TCM_INCORRECT_AMOUNT_OF_DATA, 0);
                 return -1;