Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending

Pull SCSI target updates from Nicholas Bellinger:
 "The highlights this round include:

   - Add support for T10 PI pass-through between vhost-scsi +
     virtio-scsi (MST + Paolo + MKP + nab)
   - Add support for T10 PI in qla2xxx target mode (Quinn + MKP + hch +
     nab, merged through scsi.git)
   - Add support for percpu-ida pre-allocation in qla2xxx target code
     (Quinn + nab)
   - A number of iser-target fixes related to hardening the network
     portal shutdown path (Sagi + Slava)
   - Fix response length residual handling for a number of control CDBs
     (Roland + Christophe V.)
   - Various iscsi RFC conformance fixes in the CHAP authentication path
     (Tejas and Calsoft folks + nab)
   - Return TASK_SET_FULL status for tcm_fc(FCoE) DataIn + Response
     failures (Vasu + Jun + nab)
   - Fix long-standing ABORT_TASK + session reset hang (nab)
   - Convert iser-initiator + iser-target to include T10 bytes into EDTL
     (Sagi + Or + MKP + Mike Christie)
   - Fix NULL pointer dereference regression related to XCOPY introduced
     in v3.15 + CC'ed to v3.12.y (nab)"

* 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending: (34 commits)
  target: Fix NULL pointer dereference for XCOPY in target_put_sess_cmd
  vhost-scsi: Include prot_bytes into expected data transfer length
  TARGET/sbc,loopback: Adjust command data length in case pi exists on the wire
  libiscsi, iser: Adjust data_length to include protection information
  scsi_cmnd: Introduce scsi_transfer_length helper
  target: Report correct response length for some commands
  target/sbc: Check that the LBA and number of blocks are correct in VERIFY
  target/sbc: Remove sbc_check_valid_sectors()
  Target/iscsi: Fix sendtargets response pdu for iser transport
  Target/iser: Fix a wrong dereference in case discovery session is over iser
  iscsi-target: Fix ABORT_TASK + connection reset iscsi_queue_req memory leak
  target: Use complete_all for se_cmd->t_transport_stop_comp
  target: Set CMD_T_ACTIVE bit for Task Management Requests
  target: cleanup some boolean tests
  target/spc: Simplify INQUIRY EVPD=0x80
  tcm_fc: Generate TASK_SET_FULL status for response failures
  tcm_fc: Generate TASK_SET_FULL status for DataIN failures
  iscsi-target: Reject mutual authentication with reflected CHAP_C
  iscsi-target: Remove no-op from iscsit_tpg_del_portal_group
  iscsi-target: Fix CHAP_A parameter list handling
  ...

15 files changed, 210 insertions, 115 deletions

diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index 9189bc0a87ae..5663f4d19d02 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -300,7 +300,7 @@ bool iscsit_check_np_match(
                 port = ntohs(sock_in->sin_port);
         }
 
-        if ((ip_match == true) && (np->np_port == port) &&
+        if (ip_match && (np->np_port == port) &&
             (np->np_network_transport == network_transport))
                 return true;
 
@@ -325,7 +325,7 @@ static struct iscsi_np *iscsit_get_np(
                 }
 
                 match = iscsit_check_np_match(sockaddr, np, network_transport);
-                if (match == true) {
+                if (match) {
                         /*
                          * Increment the np_exports reference count now to
                          * prevent iscsit_del_np() below from being called
@@ -1121,7 +1121,7 @@ iscsit_get_immediate_data(struct iscsi_cmd *cmd, struct iscsi_scsi_req *hdr,
         /*
          * Special case for Unsupported SAM WRITE Opcodes and ImmediateData=Yes.
          */
-        if (dump_payload == true)
+        if (dump_payload)
                 goto after_immediate_data;
 
         immed_ret = iscsit_handle_immediate_data(cmd, hdr,
@@ -3390,7 +3390,9 @@ static bool iscsit_check_inaddr_any(struct iscsi_np *np)
 
 #define SENDTARGETS_BUF_LIMIT 32768U
 
-static int iscsit_build_sendtargets_response(struct iscsi_cmd *cmd)
+static int
+iscsit_build_sendtargets_response(struct iscsi_cmd *cmd,
+                                  enum iscsit_transport_type network_transport)
 {
         char *payload = NULL;
         struct iscsi_conn *conn = cmd->conn;
@@ -3467,6 +3469,9 @@ static int iscsit_build_sendtargets_response(struct iscsi_cmd *cmd)
                                 struct iscsi_np *np = tpg_np->tpg_np;
                                 bool inaddr_any = iscsit_check_inaddr_any(np);
 
+                                if (np->np_network_transport != network_transport)
+                                        continue;
+
                                 if (!target_name_printed) {
                                         len = sprintf(buf, "TargetName=%s",
                                                       tiqn->tiqn);
@@ -3485,10 +3490,8 @@ static int iscsit_build_sendtargets_response(struct iscsi_cmd *cmd)
 
                                 len = sprintf(buf, "TargetAddress="
                                         "%s:%hu,%hu",
-                                        (inaddr_any == false) ?
-                                                np->np_ip : conn->local_ip,
-                                        (inaddr_any == false) ?
-                                                np->np_port : conn->local_port,
+                                        inaddr_any ? conn->local_ip : np->np_ip,
+                                        inaddr_any ? conn->local_port : np->np_port,
                                         tpg->tpgt);
                                 len += 1;
 
@@ -3520,11 +3523,12 @@ eob:
 
 int
 iscsit_build_text_rsp(struct iscsi_cmd *cmd, struct iscsi_conn *conn,
-                      struct iscsi_text_rsp *hdr)
+                      struct iscsi_text_rsp *hdr,
+                      enum iscsit_transport_type network_transport)
 {
         int text_length, padding;
 
-        text_length = iscsit_build_sendtargets_response(cmd);
+        text_length = iscsit_build_sendtargets_response(cmd, network_transport);
         if (text_length < 0)
                 return text_length;
 
@@ -3562,7 +3566,7 @@ static int iscsit_send_text_rsp(
         u32 tx_size = 0;
         int text_length, iov_count = 0, rc;
 
-        rc = iscsit_build_text_rsp(cmd, conn, hdr);
+        rc = iscsit_build_text_rsp(cmd, conn, hdr, ISCSI_TCP);
         if (rc < 0)
                 return rc;
 
@@ -4234,8 +4238,6 @@ int iscsit_close_connection(
         if (conn->conn_transport->iscsit_wait_conn)
                 conn->conn_transport->iscsit_wait_conn(conn);
 
-        iscsit_free_queue_reqs_for_conn(conn);
-
         /*
          * During Connection recovery drop unacknowledged out of order
          * commands for this connection, and prepare the other commands
@@ -4252,6 +4254,7 @@ int iscsit_close_connection(
                 iscsit_clear_ooo_cmdsns_for_conn(conn);
                 iscsit_release_commands_from_conn(conn);
         }
+        iscsit_free_queue_reqs_for_conn(conn);
 
         /*
          * Handle decrementing session or connection usage count if
diff --git a/drivers/target/iscsi/iscsi_target_auth.c b/drivers/target/iscsi/iscsi_target_auth.c
index de77d9aa22c6..19b842c3e0b3 100644
--- a/drivers/target/iscsi/iscsi_target_auth.c
+++ b/drivers/target/iscsi/iscsi_target_auth.c
@@ -71,6 +71,40 @@ static void chap_gen_challenge(
                         challenge_asciihex);
 }
 
+static int chap_check_algorithm(const char *a_str)
+{
+        char *tmp, *orig, *token;
+
+        tmp = kstrdup(a_str, GFP_KERNEL);
+        if (!tmp) {
+                pr_err("Memory allocation failed for CHAP_A temporary buffer\n");
+                return CHAP_DIGEST_UNKNOWN;
+        }
+        orig = tmp;
+
+        token = strsep(&tmp, "=");
+        if (!token)
+                goto out;
+
+        if (strcmp(token, "CHAP_A")) {
+                pr_err("Unable to locate CHAP_A key\n");
+                goto out;
+        }
+        while (token) {
+                token = strsep(&tmp, ",");
+                if (!token)
+                        goto out;
+
+                if (!strncmp(token, "5", 1)) {
+                        pr_debug("Selected MD5 Algorithm\n");
+                        kfree(orig);
+                        return CHAP_DIGEST_MD5;
+                }
+        }
+out:
+        kfree(orig);
+        return CHAP_DIGEST_UNKNOWN;
+}
 
 static struct iscsi_chap *chap_server_open(
         struct iscsi_conn *conn,
@@ -79,6 +113,7 @@ static struct iscsi_chap *chap_server_open(
         char *aic_str,
         unsigned int *aic_len)
 {
+        int ret;
         struct iscsi_chap *chap;
 
         if (!(auth->naf_flags & NAF_USERID_SET) ||
@@ -93,21 +128,24 @@ static struct iscsi_chap *chap_server_open(
                 return NULL;
 
         chap = conn->auth_protocol;
-        /*
-         * We only support MD5 MDA presently.
-         */
-        if (strncmp(a_str, "CHAP_A=5", 8)) {
-                pr_err("CHAP_A is not MD5.\n");
+        ret = chap_check_algorithm(a_str);
+        switch (ret) {
+        case CHAP_DIGEST_MD5:
+                pr_debug("[server] Got CHAP_A=5\n");
+                /*
+                 * Send back CHAP_A set to MD5.
+                */
+                *aic_len = sprintf(aic_str, "CHAP_A=5");
+                *aic_len += 1;
+                chap->digest_type = CHAP_DIGEST_MD5;
+                pr_debug("[server] Sending CHAP_A=%d\n", chap->digest_type);
+                break;
+        case CHAP_DIGEST_UNKNOWN:
+        default:
+                pr_err("Unsupported CHAP_A value\n");
                 return NULL;
         }
-        pr_debug("[server] Got CHAP_A=5\n");
-        /*
-         * Send back CHAP_A set to MD5.
-         */
-        *aic_len = sprintf(aic_str, "CHAP_A=5");
-        *aic_len += 1;
-        chap->digest_type = CHAP_DIGEST_MD5;
-        pr_debug("[server] Sending CHAP_A=%d\n", chap->digest_type);
+
         /*
          * Set Identifier.
          */
@@ -314,6 +352,16 @@ static int chap_server_compute_md5(
                 goto out;
         }
         /*
+         * During mutual authentication, the CHAP_C generated by the
+         * initiator must not match the original CHAP_C generated by
+         * the target.
+         */
+        if (!memcmp(challenge_binhex, chap->challenge, CHAP_CHALLENGE_LENGTH)) {
+                pr_err("initiator CHAP_C matches target CHAP_C, failing"
+                       " login attempt\n");
+                goto out;
+        }
+        /*
          * Generate CHAP_N and CHAP_R for mutual authentication.
          */
         tfm = crypto_alloc_hash("md5", 0, CRYPTO_ALG_ASYNC);
diff --git a/drivers/target/iscsi/iscsi_target_auth.h b/drivers/target/iscsi/iscsi_target_auth.h
index 2f463c09626d..d22f7b96a06c 100644
--- a/drivers/target/iscsi/iscsi_target_auth.h
+++ b/drivers/target/iscsi/iscsi_target_auth.h
@@ -1,6 +1,7 @@
 #ifndef _ISCSI_CHAP_H_
 #define _ISCSI_CHAP_H_
 
+#define CHAP_DIGEST_UNKNOWN     0
 #define CHAP_DIGEST_MD5         5
 #define CHAP_DIGEST_SHA         6
 
diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
index d9b1d88e1ad3..fecb69535a15 100644
--- a/drivers/target/iscsi/iscsi_target_login.c
+++ b/drivers/target/iscsi/iscsi_target_login.c
@@ -1145,7 +1145,7 @@ iscsit_conn_set_transport(struct iscsi_conn *conn, struct iscsit_transport *t)
 void iscsi_target_login_sess_out(struct iscsi_conn *conn,
                 struct iscsi_np *np, bool zero_tsih, bool new_sess)
 {
-        if (new_sess == false)
+        if (!new_sess)
                 goto old_sess_out;
 
         pr_err("iSCSI Login negotiation failed.\n");
diff --git a/drivers/target/iscsi/iscsi_target_nego.c b/drivers/target/iscsi/iscsi_target_nego.c
index 75b685960e80..62a095f36bf2 100644
--- a/drivers/target/iscsi/iscsi_target_nego.c
+++ b/drivers/target/iscsi/iscsi_target_nego.c
@@ -404,7 +404,7 @@ static void iscsi_target_sk_data_ready(struct sock *sk)
         }
 
         rc = schedule_delayed_work(&conn->login_work, 0);
-        if (rc == false) {
+        if (!rc) {
                 pr_debug("iscsi_target_sk_data_ready, schedule_delayed_work"
                          " got false\n");
         }
@@ -513,7 +513,7 @@ static void iscsi_target_do_login_rx(struct work_struct *work)
         state = (tpg->tpg_state == TPG_STATE_ACTIVE);
         spin_unlock(&tpg->tpg_state_lock);
 
-        if (state == false) {
+        if (!state) {
                 pr_debug("iscsi_target_do_login_rx: tpg_state != TPG_STATE_ACTIVE\n");
                 iscsi_target_restore_sock_callbacks(conn);
                 iscsi_target_login_drop(conn, login);
@@ -528,7 +528,7 @@ static void iscsi_target_do_login_rx(struct work_struct *work)
                 state = iscsi_target_sk_state_check(sk);
                 read_unlock_bh(&sk->sk_callback_lock);
 
-                if (state == false) {
+                if (!state) {
                         pr_debug("iscsi_target_do_login_rx, TCP state CLOSE\n");
                         iscsi_target_restore_sock_callbacks(conn);
                         iscsi_target_login_drop(conn, login);
@@ -773,6 +773,12 @@ static int iscsi_target_handle_csg_zero(
                 }
 
                 goto do_auth;
+        } else if (!payload_length) {
+                pr_err("Initiator sent zero length security payload,"
+                       " login failed\n");
+                iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
+                                    ISCSI_LOGIN_STATUS_AUTH_FAILED);
+                return -1;
         }
 
         if (login->first_request)
diff --git a/drivers/target/iscsi/iscsi_target_parameters.c b/drivers/target/iscsi/iscsi_target_parameters.c
index 4d2e23fc76fd..02f9de26f38a 100644
--- a/drivers/target/iscsi/iscsi_target_parameters.c
+++ b/drivers/target/iscsi/iscsi_target_parameters.c
@@ -474,10 +474,10 @@ int iscsi_set_keys_to_negotiate(
                 if (!strcmp(param->name, AUTHMETHOD)) {
                         SET_PSTATE_NEGOTIATE(param);
                 } else if (!strcmp(param->name, HEADERDIGEST)) {
-                        if (iser == false)
+                        if (!iser)
                                 SET_PSTATE_NEGOTIATE(param);
                 } else if (!strcmp(param->name, DATADIGEST)) {
-                        if (iser == false)
+                        if (!iser)
                                 SET_PSTATE_NEGOTIATE(param);
                 } else if (!strcmp(param->name, MAXCONNECTIONS)) {
                         SET_PSTATE_NEGOTIATE(param);
@@ -497,7 +497,7 @@ int iscsi_set_keys_to_negotiate(
                 } else if (!strcmp(param->name, IMMEDIATEDATA)) {
                         SET_PSTATE_NEGOTIATE(param);
                 } else if (!strcmp(param->name, MAXRECVDATASEGMENTLENGTH)) {
-                        if (iser == false)
+                        if (!iser)
                                 SET_PSTATE_NEGOTIATE(param);
                 } else if (!strcmp(param->name, MAXXMITDATASEGMENTLENGTH)) {
                         continue;
@@ -528,13 +528,13 @@ int iscsi_set_keys_to_negotiate(
                 } else if (!strcmp(param->name, OFMARKINT)) {
                         SET_PSTATE_NEGOTIATE(param);
                 } else if (!strcmp(param->name, RDMAEXTENSIONS)) {
-                        if (iser == true)
+                        if (iser)
                                 SET_PSTATE_NEGOTIATE(param);
                 } else if (!strcmp(param->name, INITIATORRECVDATASEGMENTLENGTH)) {
-                        if (iser == true)
+                        if (iser)
                                 SET_PSTATE_NEGOTIATE(param);
                 } else if (!strcmp(param->name, TARGETRECVDATASEGMENTLENGTH)) {
-                        if (iser == true)
+                        if (iser)
                                 SET_PSTATE_NEGOTIATE(param);
                 }
         }
@@ -1605,7 +1605,7 @@ int iscsi_decode_text_input(
 
         tmpbuf = kzalloc(length + 1, GFP_KERNEL);
         if (!tmpbuf) {
-                pr_err("Unable to allocate memory for tmpbuf.\n");
+                pr_err("Unable to allocate %u + 1 bytes for tmpbuf.\n", length);
                 return -1;
         }
 
diff --git a/drivers/target/iscsi/iscsi_target_tpg.c b/drivers/target/iscsi/iscsi_target_tpg.c
index 1431e8400d28..c3cb5c15efda 100644
--- a/drivers/target/iscsi/iscsi_target_tpg.c
+++ b/drivers/target/iscsi/iscsi_target_tpg.c
@@ -189,7 +189,7 @@ static void iscsit_clear_tpg_np_login_thread(
         iscsit_reset_np_thread(tpg_np->tpg_np, tpg_np, tpg, shutdown);
 }
 
-void iscsit_clear_tpg_np_login_threads(
+static void iscsit_clear_tpg_np_login_threads(
         struct iscsi_portal_group *tpg,
         bool shutdown)
 {
@@ -276,8 +276,6 @@ int iscsit_tpg_del_portal_group(
         tpg->tpg_state = TPG_STATE_INACTIVE;
         spin_unlock(&tpg->tpg_state_lock);
 
-        iscsit_clear_tpg_np_login_threads(tpg, true);
-
         if (iscsit_release_sessions_for_tpg(tpg, force) < 0) {
                 pr_err("Unable to delete iSCSI Target Portal Group:"
                         " %hu while active sessions exist, and force=0\n",
@@ -453,7 +451,7 @@ static bool iscsit_tpg_check_network_portal(
 
                         match = iscsit_check_np_match(sockaddr, np,
                                                 network_transport);
-                        if (match == true)
+                        if (match)
                                 break;
                 }
                 spin_unlock(&tpg->tpg_np_lock);
@@ -475,7 +473,7 @@ struct iscsi_tpg_np *iscsit_tpg_add_network_portal(
 
         if (!tpg_np_parent) {
                 if (iscsit_tpg_check_network_portal(tpg->tpg_tiqn, sockaddr,
-                                network_transport) == true) {
+                                network_transport)) {
                         pr_err("Network Portal: %s already exists on a"
                                 " different TPG on %s\n", ip_str,
                                 tpg->tpg_tiqn->tiqn);
diff --git a/drivers/target/iscsi/iscsi_target_tpg.h b/drivers/target/iscsi/iscsi_target_tpg.h
index 0a182f2aa8a2..e7265337bc43 100644
--- a/drivers/target/iscsi/iscsi_target_tpg.h
+++ b/drivers/target/iscsi/iscsi_target_tpg.h
@@ -8,7 +8,6 @@ extern struct iscsi_portal_group *iscsit_get_tpg_from_np(struct iscsi_tiqn *,
                         struct iscsi_np *, struct iscsi_tpg_np **);
 extern int iscsit_get_tpg(struct iscsi_portal_group *);
 extern void iscsit_put_tpg(struct iscsi_portal_group *);
-extern void iscsit_clear_tpg_np_login_threads(struct iscsi_portal_group *, bool);
 extern void iscsit_tpg_dump_params(struct iscsi_portal_group *);
 extern int iscsit_tpg_add_portal_group(struct iscsi_tiqn *, struct iscsi_portal_group *);
 extern int iscsit_tpg_del_portal_group(struct iscsi_tiqn *, struct iscsi_portal_group *,
diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c
index 73ab75ddaf42..6d2f37578b29 100644
--- a/drivers/target/loopback/tcm_loop.c
+++ b/drivers/target/loopback/tcm_loop.c
@@ -179,7 +179,7 @@ static void tcm_loop_submission_work(struct work_struct *work)
         struct tcm_loop_hba *tl_hba;
         struct tcm_loop_tpg *tl_tpg;
         struct scatterlist *sgl_bidi = NULL;
-        u32 sgl_bidi_count = 0;
+        u32 sgl_bidi_count = 0, transfer_length;
         int rc;
 
         tl_hba = *(struct tcm_loop_hba **)shost_priv(sc->device->host);
@@ -213,12 +213,21 @@ static void tcm_loop_submission_work(struct work_struct *work)
 
         }
 
-        if (!scsi_prot_sg_count(sc) && scsi_get_prot_op(sc) != SCSI_PROT_NORMAL)
+        transfer_length = scsi_transfer_length(sc);
+        if (!scsi_prot_sg_count(sc) &&
+            scsi_get_prot_op(sc) != SCSI_PROT_NORMAL) {
                 se_cmd->prot_pto = true;
+                /*
+                 * loopback transport doesn't support
+                 * WRITE_GENERATE, READ_STRIP protection
+                 * information operations, go ahead unprotected.
+                 */
+                transfer_length = scsi_bufflen(sc);
+        }
 
         rc = target_submit_cmd_map_sgls(se_cmd, tl_nexus->se_sess, sc->cmnd,
                         &tl_cmd->tl_sense_buf[0], tl_cmd->sc->device->lun,
-                        scsi_bufflen(sc), tcm_loop_sam_attr(sc),
+                        transfer_length, tcm_loop_sam_attr(sc),
                         sc->sc_data_direction, 0,
                         scsi_sglist(sc), scsi_sg_count(sc),
                         sgl_bidi, sgl_bidi_count,
diff --git a/drivers/target/target_core_sbc.c b/drivers/target/target_core_sbc.c
index e0229592ec55..bd78d9235ac6 100644
--- a/drivers/target/target_core_sbc.c
+++ b/drivers/target/target_core_sbc.c
@@ -81,7 +81,7 @@ sbc_emulate_readcapacity(struct se_cmd *cmd)
                 transport_kunmap_data_sg(cmd);
         }
 
-        target_complete_cmd(cmd, GOOD);
+        target_complete_cmd_with_length(cmd, GOOD, 8);
         return 0;
 }
 
@@ -137,7 +137,7 @@ sbc_emulate_readcapacity_16(struct se_cmd *cmd)
                 transport_kunmap_data_sg(cmd);
         }
 
-        target_complete_cmd(cmd, GOOD);
+        target_complete_cmd_with_length(cmd, GOOD, 32);
         return 0;
 }
 
@@ -176,24 +176,6 @@ static inline u32 sbc_get_size(struct se_cmd *cmd, u32 sectors)
         return cmd->se_dev->dev_attrib.block_size * sectors;
 }
 
-static int sbc_check_valid_sectors(struct se_cmd *cmd)
-{
-        struct se_device *dev = cmd->se_dev;
-        unsigned long long end_lba;
-        u32 sectors;
-
-        sectors = cmd->data_length / dev->dev_attrib.block_size;
-        end_lba = dev->transport->get_blocks(dev) + 1;
-
-        if (cmd->t_task_lba + sectors > end_lba) {
-                pr_err("target: lba %llu, sectors %u exceeds end lba %llu\n",
-                        cmd->t_task_lba, sectors, end_lba);
-                return -EINVAL;
-        }
-
-        return 0;
-}
-
 static inline u32 transport_get_sectors_6(unsigned char *cdb)
 {
         /*
@@ -665,8 +647,19 @@ sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb,
 
         cmd->prot_type = dev->dev_attrib.pi_prot_type;
         cmd->prot_length = dev->prot_length * sectors;
-        pr_debug("%s: prot_type=%d, prot_length=%d prot_op=%d prot_checks=%d\n",
-                 __func__, cmd->prot_type, cmd->prot_length,
+
+        /**
+         * In case protection information exists over the wire
+         * we modify command data length to describe pure data.
+         * The actual transfer length is data length + protection
+         * length
+         **/
+        if (protect)
+                cmd->data_length = sectors * dev->dev_attrib.block_size;
+
+        pr_debug("%s: prot_type=%d, data_length=%d, prot_length=%d "
+                 "prot_op=%d prot_checks=%d\n",
+                 __func__, cmd->prot_type, cmd->data_length, cmd->prot_length,
                  cmd->prot_op, cmd->prot_checks);
 
         return true;
@@ -877,15 +870,6 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 break;
         case SYNCHRONIZE_CACHE:
         case SYNCHRONIZE_CACHE_16:
-                if (!ops->execute_sync_cache) {
-                        size = 0;
-                        cmd->execute_cmd = sbc_emulate_noop;
-                        break;
-                }
-
-                /*
-                 * Extract LBA and range to be flushed for emulated SYNCHRONIZE_CACHE
-                 */
                 if (cdb[0] == SYNCHRONIZE_CACHE) {
                         sectors = transport_get_sectors_10(cdb);
                         cmd->t_task_lba = transport_lba_32(cdb);
@@ -893,18 +877,12 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                         sectors = transport_get_sectors_16(cdb);
                         cmd->t_task_lba = transport_lba_64(cdb);
                 }
-
-                size = sbc_get_size(cmd, sectors);
-
-                /*
-                 * Check to ensure that LBA + Range does not exceed past end of
-                 * device for IBLOCK and FILEIO ->do_sync_cache() backend calls
-                 */
-                if (cmd->t_task_lba || sectors) {
-                        if (sbc_check_valid_sectors(cmd) < 0)
-                                return TCM_ADDRESS_OUT_OF_RANGE;
+                if (ops->execute_sync_cache) {
+                        cmd->execute_cmd = ops->execute_sync_cache;
+                        goto check_lba;
                 }
-                cmd->execute_cmd = ops->execute_sync_cache;
+                size = 0;
+                cmd->execute_cmd = sbc_emulate_noop;
                 break;
         case UNMAP:
                 if (!ops->execute_unmap)
@@ -947,8 +925,10 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 break;
         case VERIFY:
                 size = 0;
+                sectors = transport_get_sectors_10(cdb);
+                cmd->t_task_lba = transport_lba_32(cdb);
                 cmd->execute_cmd = sbc_emulate_noop;
-                break;
+                goto check_lba;
         case REZERO_UNIT:
         case SEEK_6:
         case SEEK_10:
@@ -988,7 +968,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                                 dev->dev_attrib.hw_max_sectors);
                         return TCM_INVALID_CDB_FIELD;
                 }
-
+check_lba:
                 end_lba = dev->transport->get_blocks(dev) + 1;
                 if (cmd->t_task_lba + sectors > end_lba) {
                         pr_err("cmd exceeds last lba %llu "
diff --git a/drivers/target/target_core_spc.c b/drivers/target/target_core_spc.c
index 8653666612a8..6cd7222738fc 100644
--- a/drivers/target/target_core_spc.c
+++ b/drivers/target/target_core_spc.c
@@ -129,15 +129,10 @@ static sense_reason_t
 spc_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf)
 {
         struct se_device *dev = cmd->se_dev;
-        u16 len = 0;
+        u16 len;
 
         if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
-                u32 unit_serial_len;
-
-                unit_serial_len = strlen(dev->t10_wwn.unit_serial);
-                unit_serial_len++; /* For NULL Terminator */
-
-                len += sprintf(&buf[4], "%s", dev->t10_wwn.unit_serial);
+                len = sprintf(&buf[4], "%s", dev->t10_wwn.unit_serial);
                 len++; /* Extra Byte for NULL Terminator */
                 buf[3] = len;
         }
@@ -721,6 +716,7 @@ spc_emulate_inquiry(struct se_cmd *cmd)
         unsigned char *buf;
         sense_reason_t ret;
         int p;
+        int len = 0;
 
         buf = kzalloc(SE_INQUIRY_BUF, GFP_KERNEL);
         if (!buf) {
@@ -742,6 +738,7 @@ spc_emulate_inquiry(struct se_cmd *cmd)
                 }
 
                 ret = spc_emulate_inquiry_std(cmd, buf);
+                len = buf[4] + 5;
                 goto out;
         }
 
@@ -749,6 +746,7 @@ spc_emulate_inquiry(struct se_cmd *cmd)
                 if (cdb[2] == evpd_handlers[p].page) {
                         buf[1] = cdb[2];
                         ret = evpd_handlers[p].emulate(cmd, buf);
+                        len = get_unaligned_be16(&buf[2]) + 4;
                         goto out;
                 }
         }
@@ -765,7 +763,7 @@ out:
         kfree(buf);
 
         if (!ret)
-                target_complete_cmd(cmd, GOOD);
+                target_complete_cmd_with_length(cmd, GOOD, len);
         return ret;
 }
 
@@ -1103,7 +1101,7 @@ set_length:
                 transport_kunmap_data_sg(cmd);
         }
 
-        target_complete_cmd(cmd, GOOD);
+        target_complete_cmd_with_length(cmd, GOOD, length);
         return 0;
 }
 
@@ -1279,7 +1277,7 @@ done:
         buf[3] = (lun_count & 0xff);
         transport_kunmap_data_sg(cmd);
 
-        target_complete_cmd(cmd, GOOD);
+        target_complete_cmd_with_length(cmd, GOOD, 8 + lun_count * 8);
         return 0;
 }
 EXPORT_SYMBOL(spc_emulate_report_luns);
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index 2179feed0d63..7fa62fc93e0b 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -504,7 +504,7 @@ void transport_deregister_session(struct se_session *se_sess)
          * ->acl_free_comp caller to wakeup configfs se_node_acl->acl_group
          * removal context.
          */
-        if (se_nacl && comp_nacl == true)
+        if (se_nacl && comp_nacl)
                 target_put_nacl(se_nacl);
 
         transport_free_session(se_sess);
@@ -562,7 +562,7 @@ static int transport_cmd_check_stop(struct se_cmd *cmd, bool remove_from_lists,
 
                 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
-                complete(&cmd->t_transport_stop_comp);
+                complete_all(&cmd->t_transport_stop_comp);
                 return 1;
         }
 
@@ -687,7 +687,7 @@ void target_complete_cmd(struct se_cmd *cmd, u8 scsi_status)
         if (cmd->transport_state & CMD_T_ABORTED &&
             cmd->transport_state & CMD_T_STOP) {
                 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
-                complete(&cmd->t_transport_stop_comp);
+                complete_all(&cmd->t_transport_stop_comp);
                 return;
         } else if (!success) {
                 INIT_WORK(&cmd->work, target_complete_failure_work);
@@ -703,6 +703,23 @@ void target_complete_cmd(struct se_cmd *cmd, u8 scsi_status)
 }
 EXPORT_SYMBOL(target_complete_cmd);
 
+void target_complete_cmd_with_length(struct se_cmd *cmd, u8 scsi_status, int length)
+{
+        if (scsi_status == SAM_STAT_GOOD && length < cmd->data_length) {
+                if (cmd->se_cmd_flags & SCF_UNDERFLOW_BIT) {
+                        cmd->residual_count += cmd->data_length - length;
+                } else {
+                        cmd->se_cmd_flags |= SCF_UNDERFLOW_BIT;
+                        cmd->residual_count = cmd->data_length - length;
+                }
+
+                cmd->data_length = length;
+        }
+
+        target_complete_cmd(cmd, scsi_status);
+}
+EXPORT_SYMBOL(target_complete_cmd_with_length);
+
 static void target_add_to_state_list(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
@@ -1761,7 +1778,7 @@ void target_execute_cmd(struct se_cmd *cmd)
                         cmd->se_tfo->get_task_tag(cmd));
 
                 spin_unlock_irq(&cmd->t_state_lock);
-                complete(&cmd->t_transport_stop_comp);
+                complete_all(&cmd->t_transport_stop_comp);
                 return;
         }
 
@@ -2363,7 +2380,7 @@ int target_get_sess_cmd(struct se_session *se_sess, struct se_cmd *se_cmd,
          * fabric acknowledgement that requires two target_put_sess_cmd()
          * invocations before se_cmd descriptor release.
          */
-        if (ack_kref == true) {
+        if (ack_kref) {
                 kref_get(&se_cmd->cmd_kref);
                 se_cmd->se_cmd_flags |= SCF_ACK_KREF;
         }
@@ -2407,6 +2424,10 @@ static void target_release_cmd_kref(struct kref *kref)
  */
 int target_put_sess_cmd(struct se_session *se_sess, struct se_cmd *se_cmd)
 {
+        if (!se_sess) {
+                se_cmd->se_tfo->release_cmd(se_cmd);
+                return 1;
+        }
         return kref_put_spinlock_irqsave(&se_cmd->cmd_kref, target_release_cmd_kref,
                         &se_sess->sess_cmd_lock);
 }
@@ -2934,6 +2955,12 @@ static void target_tmr_work(struct work_struct *work)
 int transport_generic_handle_tmr(
         struct se_cmd *cmd)
 {
+        unsigned long flags;
+
+        spin_lock_irqsave(&cmd->t_state_lock, flags);
+        cmd->transport_state |= CMD_T_ACTIVE;
+        spin_unlock_irqrestore(&cmd->t_state_lock, flags);
+
         INIT_WORK(&cmd->work, target_tmr_work);
         queue_work(cmd->se_dev->tmr_wq, &cmd->work);
         return 0;
diff --git a/drivers/target/target_core_xcopy.c b/drivers/target/target_core_xcopy.c
index 669c536fd959..e9186cdf35e9 100644
--- a/drivers/target/target_core_xcopy.c
+++ b/drivers/target/target_core_xcopy.c
@@ -70,7 +70,7 @@ static int target_xcopy_locate_se_dev_e4(struct se_cmd *se_cmd, struct xcopy_op
         unsigned char tmp_dev_wwn[XCOPY_NAA_IEEE_REGEX_LEN], *dev_wwn;
         int rc;
 
-        if (src == true)
+        if (src)
                 dev_wwn = &xop->dst_tid_wwn[0];
         else
                 dev_wwn = &xop->src_tid_wwn[0];
@@ -88,7 +88,7 @@ static int target_xcopy_locate_se_dev_e4(struct se_cmd *se_cmd, struct xcopy_op
                 if (rc != 0)
                         continue;
 
-                if (src == true) {
+                if (src) {
                         xop->dst_dev = se_dev;
                         pr_debug("XCOPY 0xe4: Setting xop->dst_dev: %p from located"
                                 " se_dev\n", xop->dst_dev);
@@ -166,7 +166,7 @@ static int target_xcopy_parse_tiddesc_e4(struct se_cmd *se_cmd, struct xcopy_op
                 return -EINVAL;
         }
 
-        if (src == true) {
+        if (src) {
                 memcpy(&xop->src_tid_wwn[0], &desc[8], XCOPY_NAA_IEEE_REGEX_LEN);
                 /*
                  * Determine if the source designator matches the local device
@@ -236,7 +236,7 @@ static int target_xcopy_parse_target_descriptors(struct se_cmd *se_cmd,
                         /*
                          * Assume target descriptors are in source -> destination order..
                          */
-                        if (src == true)
+                        if (src)
                                 src = false;
                         else
                                 src = true;
@@ -560,7 +560,7 @@ static int target_xcopy_init_pt_lun(
          * reservations.  The pt_cmd->se_lun pointer will be setup from within
          * target_xcopy_setup_pt_port()
          */
-        if (remote_port == false) {
+        if (!remote_port) {
                 pt_cmd->se_cmd_flags |= SCF_SE_LUN_CMD | SCF_CMD_XCOPY_PASSTHROUGH;
                 return 0;
         }
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index f5fd515b2bee..be0c0d08c56a 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -128,6 +128,7 @@ int ft_queue_status(struct se_cmd *se_cmd)
         struct fc_lport *lport;
         struct fc_exch *ep;
         size_t len;
+        int rc;
 
         if (cmd->aborted)
                 return 0;
@@ -137,9 +138,10 @@ int ft_queue_status(struct se_cmd *se_cmd)
         len = sizeof(*fcp) + se_cmd->scsi_sense_length;
         fp = fc_frame_alloc(lport, len);
         if (!fp) {
-                /* XXX shouldn't just drop it - requeue and retry? */
-                return 0;
+                se_cmd->scsi_status = SAM_STAT_TASK_SET_FULL;
+                return -ENOMEM;
         }
+
         fcp = fc_frame_payload_get(fp, len);
         memset(fcp, 0, len);
         fcp->resp.fr_status = se_cmd->scsi_status;
@@ -170,7 +172,18 @@ int ft_queue_status(struct se_cmd *se_cmd)
         fc_fill_fc_hdr(fp, FC_RCTL_DD_CMD_STATUS, ep->did, ep->sid, FC_TYPE_FCP,
                        FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ, 0);
 
-        lport->tt.seq_send(lport, cmd->seq, fp);
+        rc = lport->tt.seq_send(lport, cmd->seq, fp);
+        if (rc) {
+                pr_info_ratelimited("%s: Failed to send response frame %p, "
+                                    "xid <0x%x>\n", __func__, fp, ep->xid);
+                /*
+                 * Generate a TASK_SET_FULL status to notify the initiator
+                 * to reduce it's queue_depth after the se_cmd response has
+                 * been re-queued by target-core.
+                 */
+                se_cmd->scsi_status = SAM_STAT_TASK_SET_FULL;
+                return -ENOMEM;
+        }
         lport->tt.exch_done(cmd->seq);
         return 0;
 }
diff --git a/drivers/target/tcm_fc/tfc_io.c b/drivers/target/tcm_fc/tfc_io.c
index e415af32115a..97b486c3dda1 100644
--- a/drivers/target/tcm_fc/tfc_io.c
+++ b/drivers/target/tcm_fc/tfc_io.c
@@ -82,6 +82,10 @@ int ft_queue_data_in(struct se_cmd *se_cmd)
 
         if (cmd->aborted)
                 return 0;
+
+        if (se_cmd->scsi_status == SAM_STAT_TASK_SET_FULL)
+                goto queue_status;
+
         ep = fc_seq_exch(cmd->seq);
         lport = ep->lp;
         cmd->seq = lport->tt.seq_start_next(cmd->seq);
@@ -178,14 +182,23 @@ int ft_queue_data_in(struct se_cmd *se_cmd)
                                FC_TYPE_FCP, f_ctl, fh_off);
                 error = lport->tt.seq_send(lport, seq, fp);
                 if (error) {
-                        /* XXX For now, initiator will retry */
-                        pr_err_ratelimited("%s: Failed to send frame %p, "
+                        pr_info_ratelimited("%s: Failed to send frame %p, "
                                                 "xid <0x%x>, remaining %zu, "
                                                 "lso_max <0x%x>\n",
                                                 __func__, fp, ep->xid,
                                                 remaining, lport->lso_max);
+                        /*
+                         * Go ahead and set TASK_SET_FULL status ignoring the
+                         * rest of the DataIN, and immediately attempt to
+                         * send the response via ft_queue_status() in order
+                         * to notify the initiator that it should reduce it's
+                         * per LUN queue_depth.
+                         */
+                        se_cmd->scsi_status = SAM_STAT_TASK_SET_FULL;
+                        break;
                 }
         }
+queue_status:
         return ft_queue_status(se_cmd);
 }