target: Move task tag into struct se_cmd + support 64-bit tags

Simplify target core and target drivers by storing the task tag
a.k.a. command identifier inside struct se_cmd.

For several transports (e.g. SRP) tags are 64 bits wide.
Hence add support for 64-bit tags.

(Fix core_tmr_abort_task conversion spec warnings - nab)
(Fix up usb-gadget to use 16-bit tags - HCH + bart)

Signed-off-by: Bart Van Assche <bart.vanassche@sandisk.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Andy Grover <agrover@redhat.com>
Cc: Sagi Grimberg <sagig@mellanox.com>
Cc: <qla2xxx-upstream@qlogic.com>
Cc: Felipe Balbi <balbi@ti.com>
Cc: Michael S. Tsirkin <mst@redhat.com>
Cc: Juergen Gross <jgross@suse.com>
Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>

22 files changed, 76 insertions, 182 deletions

diff --git a/Documentation/target/tcm_mod_builder.py b/Documentation/target/tcm_mod_builder.py
index 0dbd70cccde1..71e1f5863310 100755
--- a/Documentation/target/tcm_mod_builder.py
+++ b/Documentation/target/tcm_mod_builder.py
@@ -310,7 +310,6 @@ def tcm_mod_build_configfs(proto_ident, fabric_mod_dir_var, fabric_mod_name):
         buf += "        .write_pending                  = " + fabric_mod_name + "_write_pending,\n"
         buf += "        .write_pending_status           = " + fabric_mod_name + "_write_pending_status,\n"
         buf += "        .set_default_node_attributes    = " + fabric_mod_name + "_set_default_node_attrs,\n"
-        buf += "        .get_task_tag                   = " + fabric_mod_name + "_get_task_tag,\n"
         buf += "        .get_cmd_state                  = " + fabric_mod_name + "_get_cmd_state,\n"
         buf += "        .queue_data_in                  = " + fabric_mod_name + "_queue_data_in,\n"
         buf += "        .queue_status                   = " + fabric_mod_name + "_queue_status,\n"
@@ -525,13 +524,6 @@ def tcm_mod_dump_fabric_ops(proto_ident, fabric_mod_dir_var, fabric_mod_name):
                         buf += "}\n\n"
                         bufi += "void " + fabric_mod_name + "_set_default_node_attrs(struct se_node_acl *);\n"
 
-                if re.search('get_task_tag\)\(', fo):
-                        buf += "u32 " + fabric_mod_name + "_get_task_tag(struct se_cmd *se_cmd)\n"
-                        buf += "{\n"
-                        buf += "        return 0;\n"
-                        buf += "}\n\n"
-                        bufi += "u32 " + fabric_mod_name + "_get_task_tag(struct se_cmd *);\n"
-
                 if re.search('get_cmd_state\)\(', fo):
                         buf += "int " + fabric_mod_name + "_get_cmd_state(struct se_cmd *se_cmd)\n"
                         buf += "{\n"
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c
index 98e00360f97e..56df5cd918c5 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.c
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.c
@@ -1339,7 +1339,7 @@ static int srpt_abort_cmd(struct srpt_send_ioctx *ioctx)
         }
 
         pr_debug("Aborting cmd with state %d and tag %lld\n", state,
-                 ioctx->tag);
+                 ioctx->cmd.tag);
 
         switch (state) {
         case SRPT_STATE_NEW:
@@ -1701,7 +1701,7 @@ static int srpt_handle_cmd(struct srpt_rdma_ch *ch,
 
         srp_cmd = recv_ioctx->ioctx.buf;
         cmd = &send_ioctx->cmd;
-        send_ioctx->tag = srp_cmd->tag;
+        cmd->tag = srp_cmd->tag;
 
         switch (srp_cmd->task_attr) {
         case SRP_CMD_SIMPLE_Q:
@@ -1772,7 +1772,7 @@ static int srpt_rx_mgmt_fn_tag(struct srpt_send_ioctx *ioctx, u64 tag)
         for (i = 0; i < ch->rq_size; ++i) {
                 target = ch->ioctx_ring[i];
                 if (target->cmd.se_lun == ioctx->cmd.se_lun &&
-                    target->tag == tag &&
+                    target->cmd.tag == tag &&
                     srpt_get_cmd_state(target) != SRPT_STATE_DONE) {
                         ret = 0;
                         /* now let the target core abort &target->cmd; */
@@ -1831,7 +1831,7 @@ static void srpt_handle_tsk_mgmt(struct srpt_rdma_ch *ch,
                  srp_tsk->task_tag, srp_tsk->tag, ch->cm_id, ch->sess);
 
         srpt_set_cmd_state(send_ioctx, SRPT_STATE_MGMT);
-        send_ioctx->tag = srp_tsk->tag;
+        send_ioctx->cmd.tag = srp_tsk->tag;
         tcm_tmr = srp_tmr_to_tcm(srp_tsk->tsk_mgmt_func);
         if (tcm_tmr < 0) {
                 send_ioctx->cmd.se_tmr_req->response =
@@ -2979,7 +2979,7 @@ static int srpt_write_pending(struct se_cmd *se_cmd)
         case CH_DRAINING:
         case CH_RELEASING:
                 pr_debug("cmd with tag %lld: channel disconnecting\n",
-                         ioctx->tag);
+                         ioctx->cmd.tag);
                 srpt_set_cmd_state(ioctx, SRPT_STATE_DATA_IN);
                 ret = -EINVAL;
                 goto out;
@@ -3054,24 +3054,24 @@ static void srpt_queue_response(struct se_cmd *cmd)
                 ret = srpt_xfer_data(ch, ioctx);
                 if (ret) {
                         pr_err("xfer_data failed for tag %llu\n",
-                               ioctx->tag);
+                               ioctx->cmd.tag);
                         return;
                 }
         }
 
         if (state != SRPT_STATE_MGMT)
-                resp_len = srpt_build_cmd_rsp(ch, ioctx, ioctx->tag,
+                resp_len = srpt_build_cmd_rsp(ch, ioctx, ioctx->cmd.tag,
                                               cmd->scsi_status);
         else {
                 srp_tm_status
                         = tcm_to_srp_tsk_mgmt_status(cmd->se_tmr_req->response);
                 resp_len = srpt_build_tskmgmt_rsp(ch, ioctx, srp_tm_status,
-                                                 ioctx->tag);
+                                                 ioctx->cmd.tag);
         }
         ret = srpt_post_send(ch, ioctx, resp_len);
         if (ret) {
                 pr_err("sending cmd response failed for tag %llu\n",
-                       ioctx->tag);
+                       ioctx->cmd.tag);
                 srpt_unmap_sg_to_ib_sge(ch, ioctx);
                 srpt_set_cmd_state(ioctx, SRPT_STATE_DONE);
                 target_put_sess_cmd(&ioctx->cmd);
@@ -3479,14 +3479,6 @@ static void srpt_set_default_node_attrs(struct se_node_acl *nacl)
 {
 }
 
-static u32 srpt_get_task_tag(struct se_cmd *se_cmd)
-{
-        struct srpt_send_ioctx *ioctx;
-
-        ioctx = container_of(se_cmd, struct srpt_send_ioctx, cmd);
-        return ioctx->tag;
-}
-
 /* Note: only used from inside debug printk's by the TCM core. */
 static int srpt_get_tcm_cmd_state(struct se_cmd *se_cmd)
 {
@@ -3838,7 +3830,6 @@ static const struct target_core_fabric_ops srpt_template = {
         .write_pending                  = srpt_write_pending,
         .write_pending_status           = srpt_write_pending_status,
         .set_default_node_attributes    = srpt_set_default_node_attrs,
-        .get_task_tag                   = srpt_get_task_tag,
         .get_cmd_state                  = srpt_get_tcm_cmd_state,
         .queue_data_in                  = srpt_queue_data_in,
         .queue_status                   = srpt_queue_status,
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.h b/drivers/infiniband/ulp/srpt/ib_srpt.h
index 33b2c88b73ba..6fec740742bd 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.h
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.h
@@ -238,7 +238,6 @@ struct srpt_send_ioctx {
         bool                    rdma_aborted;
         struct se_cmd           cmd;
         struct completion       tx_done;
-        u64                     tag;
         int                     sg_cnt;
         int                     mapped_sg_count;
         u16                     n_rdma_ius;
diff --git a/drivers/scsi/qla2xxx/qla_target.c b/drivers/scsi/qla2xxx/qla_target.c
index fe8a8d157e22..e7515069e1ce 100644
--- a/drivers/scsi/qla2xxx/qla_target.c
+++ b/drivers/scsi/qla2xxx/qla_target.c
@@ -1191,7 +1191,7 @@ static int __qlt_24xx_handle_abts(struct scsi_qla_host *vha,
         list_for_each_entry(se_cmd, &se_sess->sess_cmd_list, se_cmd_list) {
                 struct qla_tgt_cmd *cmd =
                         container_of(se_cmd, struct qla_tgt_cmd, se_cmd);
-                if (cmd->tag == abts->exchange_addr_to_abort) {
+                if (se_cmd->tag == abts->exchange_addr_to_abort) {
                         lun = cmd->unpacked_lun;
                         found_lun = true;
                         break;
@@ -1728,9 +1728,8 @@ static int qlt_pre_xmit_response(struct qla_tgt_cmd *cmd,
 
         if (unlikely(cmd->aborted)) {
                 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf014,
-                    "qla_target(%d): terminating exchange "
-                    "for aborted cmd=%p (se_cmd=%p, tag=%d)", vha->vp_idx, cmd,
-                    se_cmd, cmd->tag);
+                       "qla_target(%d): terminating exchange for aborted cmd=%p (se_cmd=%p, tag=%lld)",
+                       vha->vp_idx, cmd, se_cmd, se_cmd->tag);
 
                 cmd->state = QLA_TGT_STATE_ABORTED;
                 cmd->cmd_flags |= BIT_6;
@@ -1765,18 +1764,17 @@ static int qlt_pre_xmit_response(struct qla_tgt_cmd *cmd,
         if (se_cmd->se_cmd_flags & SCF_UNDERFLOW_BIT) {
                 prm->residual = se_cmd->residual_count;
                 ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x305c,
-                    "Residual underflow: %d (tag %d, "
-                    "op %x, bufflen %d, rq_result %x)\n", prm->residual,
-                    cmd->tag, se_cmd->t_task_cdb ? se_cmd->t_task_cdb[0] : 0,
-                    cmd->bufflen, prm->rq_result);
+                    "Residual underflow: %d (tag %lld, op %x, bufflen %d, rq_result %x)\n",
+                       prm->residual, se_cmd->tag,
+                       se_cmd->t_task_cdb ? se_cmd->t_task_cdb[0] : 0,
+                       cmd->bufflen, prm->rq_result);
                 prm->rq_result |= SS_RESIDUAL_UNDER;
         } else if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {
                 prm->residual = se_cmd->residual_count;
                 ql_dbg(ql_dbg_io, vha, 0x305d,
-                    "Residual overflow: %d (tag %d, "
-                    "op %x, bufflen %d, rq_result %x)\n", prm->residual,
-                    cmd->tag, se_cmd->t_task_cdb ? se_cmd->t_task_cdb[0] : 0,
-                    cmd->bufflen, prm->rq_result);
+                    "Residual overflow: %d (tag %lld, op %x, bufflen %d, rq_result %x)\n",
+                       prm->residual, se_cmd->tag, se_cmd->t_task_cdb ?
+                       se_cmd->t_task_cdb[0] : 0, cmd->bufflen, prm->rq_result);
                 prm->rq_result |= SS_RESIDUAL_OVER;
         }
 
@@ -1849,7 +1847,7 @@ static void qlt_check_srr_debug(struct qla_tgt_cmd *cmd, int *xmit_type)
             == 50) {
                 *xmit_type &= ~QLA_TGT_XMIT_STATUS;
                 ql_dbg(ql_dbg_tgt_mgt, cmd->vha, 0xf015,
-                    "Dropping cmd %p (tag %d) status", cmd, cmd->tag);
+                    "Dropping cmd %p (tag %d) status", cmd, se_cmd->tag);
         }
 #endif
         /*
@@ -1873,7 +1871,7 @@ static void qlt_check_srr_debug(struct qla_tgt_cmd *cmd, int *xmit_type)
                 ql_dbg(ql_dbg_tgt_mgt, cmd->vha, 0xf016,
                     "Cutting cmd %p (tag %d) buffer"
                     " tail to len %d, sg_cnt %d (cmd->bufflen %d,"
-                    " cmd->sg_cnt %d)", cmd, cmd->tag, tot_len, leave,
+                    " cmd->sg_cnt %d)", cmd, se_cmd->tag, tot_len, leave,
                     cmd->bufflen, cmd->sg_cnt);
 
                 cmd->bufflen = tot_len;
@@ -1885,13 +1883,13 @@ static void qlt_check_srr_debug(struct qla_tgt_cmd *cmd, int *xmit_type)
 
                 ql_dbg(ql_dbg_tgt_mgt, cmd->vha, 0xf017,
                     "Cutting cmd %p (tag %d) buffer head "
-                    "to offset %d (cmd->bufflen %d)", cmd, cmd->tag, offset,
+                    "to offset %d (cmd->bufflen %d)", cmd, se_cmd->tag, offset,
                     cmd->bufflen);
                 if (offset == 0)
                         *xmit_type &= ~QLA_TGT_XMIT_DATA;
                 else if (qlt_set_data_offset(cmd, offset)) {
                         ql_dbg(ql_dbg_tgt_mgt, cmd->vha, 0xf018,
-                            "qlt_set_data_offset() failed (tag %d)", cmd->tag);
+                            "qlt_set_data_offset() failed (tag %d)", se_cmd->tag);
                 }
         }
 }
@@ -3194,7 +3192,7 @@ skip_term:
                 return;
         } else if (cmd->state == QLA_TGT_STATE_ABORTED) {
                 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf01e,
-                    "Aborted command %p (tag %d) finished\n", cmd, cmd->tag);
+                  "Aborted command %p (tag %lld) finished\n", cmd, se_cmd->tag);
         } else {
                 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf05c,
                     "qla_target(%d): A command in state (%d) should "
@@ -3266,7 +3264,7 @@ static void __qlt_do_work(struct qla_tgt_cmd *cmd)
                 goto out_term;
 
         cdb = &atio->u.isp24.fcp_cmnd.cdb[0];
-        cmd->tag = atio->u.isp24.exchange_addr;
+        cmd->se_cmd.tag = atio->u.isp24.exchange_addr;
         cmd->unpacked_lun = scsilun_to_int(
             (struct scsi_lun *)&atio->u.isp24.fcp_cmnd.lun);
 
@@ -3891,9 +3889,8 @@ static void qlt_handle_srr(struct scsi_qla_host *vha,
                         resp = 1;
                 } else {
                         ql_dbg(ql_dbg_tgt_mgt, vha, 0xf064,
-                            "qla_target(%d): SRR for in data for cmd "
-                            "without them (tag %d, SCSI status %d), "
-                            "reject", vha->vp_idx, cmd->tag,
+                               "qla_target(%d): SRR for in data for cmd without them (tag %lld, SCSI status %d), reject",
+                               vha->vp_idx, se_cmd->tag,
                             cmd->se_cmd.scsi_status);
                         goto out_reject;
                 }
@@ -3927,10 +3924,8 @@ static void qlt_handle_srr(struct scsi_qla_host *vha,
                         }
                 } else {
                         ql_dbg(ql_dbg_tgt_mgt, vha, 0xf066,
-                            "qla_target(%d): SRR for out data for cmd "
-                            "without them (tag %d, SCSI status %d), "
-                            "reject", vha->vp_idx, cmd->tag,
-                            cmd->se_cmd.scsi_status);
+                            "qla_target(%d): SRR for out data for cmd without them (tag %lld, SCSI status %d), reject",
+                               vha->vp_idx, se_cmd->tag, cmd->se_cmd.scsi_status);
                         goto out_reject;
                 }
                 break;
@@ -4051,10 +4046,9 @@ restart:
                 cmd->sg = se_cmd->t_data_sg;
 
                 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf02c,
-                    "SRR cmd %p (se_cmd %p, tag %d, op %x), "
-                    "sg_cnt=%d, offset=%d", cmd, &cmd->se_cmd, cmd->tag,
-                    se_cmd->t_task_cdb ? se_cmd->t_task_cdb[0] : 0,
-                    cmd->sg_cnt, cmd->offset);
+                       "SRR cmd %p (se_cmd %p, tag %lld, op %x), sg_cnt=%d, offset=%d",
+                       cmd, &cmd->se_cmd, se_cmd->tag, se_cmd->t_task_cdb ?
+                       se_cmd->t_task_cdb[0] : 0, cmd->sg_cnt, cmd->offset);
 
                 qlt_handle_srr(vha, sctio, imm);
 
diff --git a/drivers/scsi/qla2xxx/qla_target.h b/drivers/scsi/qla2xxx/qla_target.h
index 332086776dfe..985d76dd706b 100644
--- a/drivers/scsi/qla2xxx/qla_target.h
+++ b/drivers/scsi/qla2xxx/qla_target.h
@@ -924,7 +924,6 @@ struct qla_tgt_cmd {
         int sg_cnt;             /* SG segments count */
         int bufflen;            /* cmd buffer length */
         int offset;
-        uint32_t tag;
         uint32_t unpacked_lun;
         enum dma_data_direction dma_data_direction;
         uint32_t reset_count;
diff --git a/drivers/scsi/qla2xxx/tcm_qla2xxx.c b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
index bd0f9eb67901..8e331220adda 100644
--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.c
+++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
@@ -421,19 +421,6 @@ static void tcm_qla2xxx_set_default_node_attrs(struct se_node_acl *nacl)
         return;
 }
 
-static u32 tcm_qla2xxx_get_task_tag(struct se_cmd *se_cmd)
-{
-        struct qla_tgt_cmd *cmd;
-
-        /* check for task mgmt cmd */
-        if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)
-                return 0xffffffff;
-
-        cmd = container_of(se_cmd, struct qla_tgt_cmd, se_cmd);
-
-        return cmd->tag;
-}
-
 static int tcm_qla2xxx_get_cmd_state(struct se_cmd *se_cmd)
 {
         return 0;
@@ -1865,7 +1852,6 @@ static const struct target_core_fabric_ops tcm_qla2xxx_ops = {
         .write_pending                  = tcm_qla2xxx_write_pending,
         .write_pending_status           = tcm_qla2xxx_write_pending_status,
         .set_default_node_attributes    = tcm_qla2xxx_set_default_node_attrs,
-        .get_task_tag                   = tcm_qla2xxx_get_task_tag,
         .get_cmd_state                  = tcm_qla2xxx_get_cmd_state,
         .queue_data_in                  = tcm_qla2xxx_queue_data_in,
         .queue_status                   = tcm_qla2xxx_queue_status,
@@ -1910,7 +1896,6 @@ static const struct target_core_fabric_ops tcm_qla2xxx_npiv_ops = {
         .write_pending                  = tcm_qla2xxx_write_pending,
         .write_pending_status           = tcm_qla2xxx_write_pending_status,
         .set_default_node_attributes    = tcm_qla2xxx_set_default_node_attrs,
-        .get_task_tag                   = tcm_qla2xxx_get_task_tag,
         .get_cmd_state                  = tcm_qla2xxx_get_cmd_state,
         .queue_data_in                  = tcm_qla2xxx_queue_data_in,
         .queue_status                   = tcm_qla2xxx_queue_status,
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index 866c167c0986..3c4431f71158 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -1008,6 +1008,8 @@ int iscsit_setup_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
         if (cmd->sense_reason)
                 goto attach_cmd;
 
+        /* only used for printks or comparing with ->ref_task_tag */
+        cmd->se_cmd.tag = (__force u32)cmd->init_task_tag;
         cmd->sense_reason = target_setup_cmd_from_cdb(&cmd->se_cmd, hdr->cdb);
         if (cmd->sense_reason) {
                 if (cmd->sense_reason == TCM_OUT_OF_RESOURCES) {
diff --git a/drivers/target/iscsi/iscsi_target_configfs.c b/drivers/target/iscsi/iscsi_target_configfs.c
index bd8af8764f4b..aa4fc4d8e176 100644
--- a/drivers/target/iscsi/iscsi_target_configfs.c
+++ b/drivers/target/iscsi/iscsi_target_configfs.c
@@ -1692,14 +1692,6 @@ static char *iscsi_get_fabric_name(void)
         return "iSCSI";
 }
 
-static u32 iscsi_get_task_tag(struct se_cmd *se_cmd)
-{
-        struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
-
-        /* only used for printks or comparism with ->ref_task_tag */
-        return (__force u32)cmd->init_task_tag;
-}
-
 static int iscsi_get_cmd_state(struct se_cmd *se_cmd)
 {
         struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
@@ -1938,7 +1930,6 @@ const struct target_core_fabric_ops iscsi_ops = {
         .write_pending                  = lio_write_pending,
         .write_pending_status           = lio_write_pending_status,
         .set_default_node_attributes    = lio_set_default_node_attributes,
-        .get_task_tag                   = iscsi_get_task_tag,
         .get_cmd_state                  = iscsi_get_cmd_state,
         .queue_data_in                  = lio_queue_data_in,
         .queue_status                   = lio_queue_status,
diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c
index b788406977f6..07d3b52c88eb 100644
--- a/drivers/target/loopback/tcm_loop.c
+++ b/drivers/target/loopback/tcm_loop.c
@@ -165,6 +165,7 @@ static void tcm_loop_submission_work(struct work_struct *work)
                 transfer_length = scsi_bufflen(sc);
         }
 
+        se_cmd->tag = tl_cmd->sc_cmd_tag;
         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,
                         transfer_length, TCM_SIMPLE_TAG,
@@ -597,14 +598,6 @@ static void tcm_loop_set_default_node_attributes(struct se_node_acl *se_acl)
         return;
 }
 
-static u32 tcm_loop_get_task_tag(struct se_cmd *se_cmd)
-{
-        struct tcm_loop_cmd *tl_cmd = container_of(se_cmd,
-                        struct tcm_loop_cmd, tl_se_cmd);
-
-        return tl_cmd->sc_cmd_tag;
-}
-
 static int tcm_loop_get_cmd_state(struct se_cmd *se_cmd)
 {
         struct tcm_loop_cmd *tl_cmd = container_of(se_cmd,
@@ -1259,7 +1252,6 @@ static const struct target_core_fabric_ops loop_ops = {
         .write_pending                  = tcm_loop_write_pending,
         .write_pending_status           = tcm_loop_write_pending_status,
         .set_default_node_attributes    = tcm_loop_set_default_node_attributes,
-        .get_task_tag                   = tcm_loop_get_task_tag,
         .get_cmd_state                  = tcm_loop_get_cmd_state,
         .queue_data_in                  = tcm_loop_queue_data_in,
         .queue_status                   = tcm_loop_queue_status,
diff --git a/drivers/target/sbp/sbp_target.c b/drivers/target/sbp/sbp_target.c
index 89f172dc8678..2916a4023e71 100644
--- a/drivers/target/sbp/sbp_target.c
+++ b/drivers/target/sbp/sbp_target.c
@@ -1234,6 +1234,8 @@ static void sbp_handle_command(struct sbp_target_request *req)
         pr_debug("sbp_handle_command ORB:0x%llx unpacked_lun:%d data_len:%d data_dir:%d\n",
                         req->orb_pointer, unpacked_lun, data_length, data_dir);
 
+        /* only used for printk until we do TMRs */
+        req->se_cmd.tag = req->orb_pointer;
         if (target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf,
                               req->sense_buf, unpacked_lun, data_length,
                               TCM_SIMPLE_TAG, data_dir, 0))
@@ -1768,15 +1770,6 @@ static void sbp_set_default_node_attrs(struct se_node_acl *nacl)
         return;
 }
 
-static u32 sbp_get_task_tag(struct se_cmd *se_cmd)
-{
-        struct sbp_target_request *req = container_of(se_cmd,
-                        struct sbp_target_request, se_cmd);
-
-        /* only used for printk until we do TMRs */
-        return (u32)req->orb_pointer;
-}
-
 static int sbp_get_cmd_state(struct se_cmd *se_cmd)
 {
         return 0;
@@ -2377,7 +2370,6 @@ static const struct target_core_fabric_ops sbp_ops = {
         .write_pending                  = sbp_write_pending,
         .write_pending_status           = sbp_write_pending_status,
         .set_default_node_attributes    = sbp_set_default_node_attrs,
-        .get_task_tag                   = sbp_get_task_tag,
         .get_cmd_state                  = sbp_get_cmd_state,
         .queue_data_in                  = sbp_queue_data_in,
         .queue_status                   = sbp_queue_status,
diff --git a/drivers/target/target_core_configfs.c b/drivers/target/target_core_configfs.c
index 5e2649fc6919..fc598c084523 100644
--- a/drivers/target/target_core_configfs.c
+++ b/drivers/target/target_core_configfs.c
@@ -374,10 +374,6 @@ static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo)
                 pr_err("Missing tfo->set_default_node_attributes()\n");
                 return -EINVAL;
         }
-        if (!tfo->get_task_tag) {
-                pr_err("Missing tfo->get_task_tag()\n");
-                return -EINVAL;
-        }
         if (!tfo->get_cmd_state) {
                 pr_err("Missing tfo->get_cmd_state()\n");
                 return -EINVAL;
diff --git a/drivers/target/target_core_tmr.c b/drivers/target/target_core_tmr.c
index b2e169fba3c6..393aca8bb3eb 100644
--- a/drivers/target/target_core_tmr.c
+++ b/drivers/target/target_core_tmr.c
@@ -117,7 +117,7 @@ void core_tmr_abort_task(
 {
         struct se_cmd *se_cmd;
         unsigned long flags;
-        int ref_tag;
+        u64 ref_tag;
 
         spin_lock_irqsave(&se_sess->sess_cmd_lock, flags);
         list_for_each_entry(se_cmd, &se_sess->sess_cmd_list, se_cmd_list) {
@@ -129,16 +129,17 @@ void core_tmr_abort_task(
                 if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)
                         continue;
 
-                ref_tag = se_cmd->se_tfo->get_task_tag(se_cmd);
+                ref_tag = se_cmd->tag;
                 if (tmr->ref_task_tag != ref_tag)
                         continue;
 
-                printk("ABORT_TASK: Found referenced %s task_tag: %u\n",
+                printk("ABORT_TASK: Found referenced %s task_tag: %llu\n",
                         se_cmd->se_tfo->get_fabric_name(), ref_tag);
 
                 spin_lock(&se_cmd->t_state_lock);
                 if (se_cmd->transport_state & CMD_T_COMPLETE) {
-                        printk("ABORT_TASK: ref_tag: %u already complete, skipping\n", ref_tag);
+                        printk("ABORT_TASK: ref_tag: %llu already complete,"
+                               " skipping\n", ref_tag);
                         spin_unlock(&se_cmd->t_state_lock);
                         spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
                         goto out;
@@ -157,14 +158,14 @@ void core_tmr_abort_task(
                 transport_cmd_finish_abort(se_cmd, true);
 
                 printk("ABORT_TASK: Sending TMR_FUNCTION_COMPLETE for"
-                                " ref_tag: %d\n", ref_tag);
+                                " ref_tag: %llu\n", ref_tag);
                 tmr->response = TMR_FUNCTION_COMPLETE;
                 return;
         }
         spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
 
 out:
-        printk("ABORT_TASK: Sending TMR_TASK_DOES_NOT_EXIST for ref_tag: %d\n",
+        printk("ABORT_TASK: Sending TMR_TASK_DOES_NOT_EXIST for ref_tag: %lld\n",
                         tmr->ref_task_tag);
         tmr->response = TMR_TASK_DOES_NOT_EXIST;
 }
@@ -289,16 +290,16 @@ static void core_tmr_drain_state_list(
                 list_del(&cmd->state_list);
 
                 pr_debug("LUN_RESET: %s cmd: %p"
-                        " ITT/CmdSN: 0x%08x/0x%08x, i_state: %d, t_state: %d"
+                        " ITT/CmdSN: 0x%08llx/0x%08x, i_state: %d, t_state: %d"
                         "cdb: 0x%02x\n",
                         (preempt_and_abort_list) ? "Preempt" : "", cmd,
-                        cmd->se_tfo->get_task_tag(cmd), 0,
+                        cmd->tag, 0,
                         cmd->se_tfo->get_cmd_state(cmd), cmd->t_state,
                         cmd->t_task_cdb[0]);
-                pr_debug("LUN_RESET: ITT[0x%08x] - pr_res_key: 0x%016Lx"
+                pr_debug("LUN_RESET: ITT[0x%08llx] - pr_res_key: 0x%016Lx"
                         " -- CMD_T_ACTIVE: %d"
                         " CMD_T_STOP: %d CMD_T_SENT: %d\n",
-                        cmd->se_tfo->get_task_tag(cmd), cmd->pr_res_key,
+                        cmd->tag, cmd->pr_res_key,
                         (cmd->transport_state & CMD_T_ACTIVE) != 0,
                         (cmd->transport_state & CMD_T_STOP) != 0,
                         (cmd->transport_state & CMD_T_SENT) != 0);
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index 85b021e749e6..0d8662bb470e 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -600,9 +600,8 @@ static int transport_cmd_check_stop(struct se_cmd *cmd, bool remove_from_lists,
          * this command for frontend exceptions.
          */
         if (cmd->transport_state & CMD_T_STOP) {
-                pr_debug("%s:%d CMD_T_STOP for ITT: 0x%08x\n",
-                        __func__, __LINE__,
-                        cmd->se_tfo->get_task_tag(cmd));
+                pr_debug("%s:%d CMD_T_STOP for ITT: 0x%08llx\n",
+                        __func__, __LINE__, cmd->tag);
 
                 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
@@ -1155,6 +1154,8 @@ target_cmd_size_check(struct se_cmd *cmd, unsigned int size)
 /*
  * Used by fabric modules containing a local struct se_cmd within their
  * fabric dependent per I/O descriptor.
+ *
+ * Preserves the value of @cmd->tag.
  */
 void transport_init_se_cmd(
         struct se_cmd *cmd,
@@ -1380,6 +1381,8 @@ transport_generic_map_mem_to_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
  * @sgl_prot: struct scatterlist memory protection information
  * @sgl_prot_count: scatterlist count for protection information
  *
+ * Task tags are supported if the caller has set @se_cmd->tag.
+ *
  * Returns non zero to signal active I/O shutdown failure.  All other
  * setup exceptions will be returned as a SCSI CHECK_CONDITION response,
  * but still return zero here.
@@ -1512,6 +1515,8 @@ EXPORT_SYMBOL(target_submit_cmd_map_sgls);
  * @data_dir: DMA data direction
  * @flags: flags for command submission from target_sc_flags_tables
  *
+ * Task tags are supported if the caller has set @se_cmd->tag.
+ *
  * Returns non zero to signal active I/O shutdown failure.  All other
  * setup exceptions will be returned as a SCSI CHECK_CONDITION response,
  * but still return zero here.
@@ -1639,9 +1644,8 @@ void transport_generic_request_failure(struct se_cmd *cmd,
 {
         int ret = 0;
 
-        pr_debug("-----[ Storage Engine Exception for cmd: %p ITT: 0x%08x"
-                " CDB: 0x%02x\n", cmd, cmd->se_tfo->get_task_tag(cmd),
-                cmd->t_task_cdb[0]);
+        pr_debug("-----[ Storage Engine Exception for cmd: %p ITT: 0x%08llx"
+                " CDB: 0x%02x\n", cmd, cmd->tag, cmd->t_task_cdb[0]);
         pr_debug("-----[ i_state: %d t_state: %d sense_reason: %d\n",
                 cmd->se_tfo->get_cmd_state(cmd),
                 cmd->t_state, sense_reason);
@@ -1849,9 +1853,8 @@ void target_execute_cmd(struct se_cmd *cmd)
          */
         spin_lock_irq(&cmd->t_state_lock);
         if (cmd->transport_state & CMD_T_STOP) {
-                pr_debug("%s:%d CMD_T_STOP for ITT: 0x%08x\n",
-                        __func__, __LINE__,
-                        cmd->se_tfo->get_task_tag(cmd));
+                pr_debug("%s:%d CMD_T_STOP for ITT: 0x%08llx\n",
+                        __func__, __LINE__, cmd->tag);
 
                 spin_unlock_irq(&cmd->t_state_lock);
                 complete_all(&cmd->t_transport_stop_comp);
@@ -2658,10 +2661,8 @@ bool transport_wait_for_tasks(struct se_cmd *cmd)
 
         cmd->transport_state |= CMD_T_STOP;
 
-        pr_debug("wait_for_tasks: Stopping %p ITT: 0x%08x"
-                " i_state: %d, t_state: %d, CMD_T_STOP\n",
-                cmd, cmd->se_tfo->get_task_tag(cmd),
-                cmd->se_tfo->get_cmd_state(cmd), cmd->t_state);
+        pr_debug("wait_for_tasks: Stopping %p ITT: 0x%08llx i_state: %d, t_state: %d, CMD_T_STOP\n",
+                cmd, cmd->tag, cmd->se_tfo->get_cmd_state(cmd), cmd->t_state);
 
         spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
@@ -2670,9 +2671,8 @@ bool transport_wait_for_tasks(struct se_cmd *cmd)
         spin_lock_irqsave(&cmd->t_state_lock, flags);
         cmd->transport_state &= ~(CMD_T_ACTIVE | CMD_T_STOP);
 
-        pr_debug("wait_for_tasks: Stopped wait_for_completion("
-                "&cmd->t_transport_stop_comp) for ITT: 0x%08x\n",
-                cmd->se_tfo->get_task_tag(cmd));
+        pr_debug("wait_for_tasks: Stopped wait_for_completion(&cmd->t_transport_stop_comp) for ITT: 0x%08llx\n",
+                cmd->tag);
 
         spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
@@ -2974,8 +2974,8 @@ int transport_check_aborted_status(struct se_cmd *cmd, int send_status)
         if (!send_status || !(cmd->se_cmd_flags & SCF_SEND_DELAYED_TAS))
                 return 1;
 
-        pr_debug("Sending delayed SAM_STAT_TASK_ABORTED status for CDB: 0x%02x ITT: 0x%08x\n",
-                 cmd->t_task_cdb[0], cmd->se_tfo->get_task_tag(cmd));
+        pr_debug("Sending delayed SAM_STAT_TASK_ABORTED status for CDB: 0x%02x ITT: 0x%08llx\n",
+                 cmd->t_task_cdb[0], cmd->tag);
 
         cmd->se_cmd_flags &= ~SCF_SEND_DELAYED_TAS;
         cmd->scsi_status = SAM_STAT_TASK_ABORTED;
@@ -3014,9 +3014,8 @@ void transport_send_task_abort(struct se_cmd *cmd)
 
         transport_lun_remove_cmd(cmd);
 
-        pr_debug("Setting SAM_STAT_TASK_ABORTED status for CDB: 0x%02x,"
-                " ITT: 0x%08x\n", cmd->t_task_cdb[0],
-                cmd->se_tfo->get_task_tag(cmd));
+        pr_debug("Setting SAM_STAT_TASK_ABORTED status for CDB: 0x%02x, ITT: 0x%08llx\n",
+                 cmd->t_task_cdb[0], cmd->tag);
 
         trace_target_cmd_complete(cmd);
         cmd->se_tfo->queue_status(cmd);
diff --git a/drivers/target/target_core_xcopy.c b/drivers/target/target_core_xcopy.c
index 8fd680ac941b..5545619d3045 100644
--- a/drivers/target/target_core_xcopy.c
+++ b/drivers/target/target_core_xcopy.c
@@ -359,11 +359,6 @@ static char *xcopy_pt_get_fabric_name(void)
         return "xcopy-pt";
 }
 
-static u32 xcopy_pt_get_tag(struct se_cmd *se_cmd)
-{
-        return 0;
-}
-
 static int xcopy_pt_get_cmd_state(struct se_cmd *se_cmd)
 {
         return 0;
@@ -424,7 +419,6 @@ static int xcopy_pt_queue_status(struct se_cmd *se_cmd)
 
 static const struct target_core_fabric_ops xcopy_pt_tfo = {
         .get_fabric_name        = xcopy_pt_get_fabric_name,
-        .get_task_tag           = xcopy_pt_get_tag,
         .get_cmd_state          = xcopy_pt_get_cmd_state,
         .release_cmd            = xcopy_pt_release_cmd,
         .check_stop_free        = xcopy_pt_check_stop_free,
@@ -575,6 +569,7 @@ static int target_xcopy_setup_pt_cmd(
         xpt_cmd->xcopy_op = xop;
         target_xcopy_setup_pt_port(xpt_cmd, xop, remote_port);
 
+        cmd->tag = 0;
         sense_rc = target_setup_cmd_from_cdb(cmd, cdb);
         if (sense_rc) {
                 ret = -EINVAL;
diff --git a/drivers/target/tcm_fc/tcm_fc.h b/drivers/target/tcm_fc/tcm_fc.h
index 4ceaeb9a4b93..39909dadef3e 100644
--- a/drivers/target/tcm_fc/tcm_fc.h
+++ b/drivers/target/tcm_fc/tcm_fc.h
@@ -157,7 +157,6 @@ int ft_queue_status(struct se_cmd *);
 int ft_queue_data_in(struct se_cmd *);
 int ft_write_pending(struct se_cmd *);
 int ft_write_pending_status(struct se_cmd *);
-u32 ft_get_task_tag(struct se_cmd *);
 int ft_get_cmd_state(struct se_cmd *);
 void ft_queue_tm_resp(struct se_cmd *);
 void ft_aborted_task(struct se_cmd *);
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index edcafa4490c0..a8fe6ed5262f 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -247,15 +247,6 @@ int ft_write_pending(struct se_cmd *se_cmd)
         return 0;
 }
 
-u32 ft_get_task_tag(struct se_cmd *se_cmd)
-{
-        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
-
-        if (cmd->aborted)
-                return ~0;
-        return fc_seq_exch(cmd->seq)->rxid;
-}
-
 int ft_get_cmd_state(struct se_cmd *se_cmd)
 {
         return 0;
@@ -568,6 +559,7 @@ static void ft_send_work(struct work_struct *work)
         }
 
         fc_seq_exch(cmd->seq)->lp->tt.seq_set_resp(cmd->seq, ft_recv_seq, cmd);
+        cmd->se_cmd.tag = fc_seq_exch(cmd->seq)->rxid;
         /*
          * Use a single se_cmd->cmd_kref as we expect to release se_cmd
          * directly from ft_check_stop_free callback in response path.
diff --git a/drivers/target/tcm_fc/tfc_conf.c b/drivers/target/tcm_fc/tfc_conf.c
index 6ad7404b7dd1..f0821967f0a1 100644
--- a/drivers/target/tcm_fc/tfc_conf.c
+++ b/drivers/target/tcm_fc/tfc_conf.c
@@ -468,7 +468,6 @@ static const struct target_core_fabric_ops ft_fabric_ops = {
         .write_pending =                ft_write_pending,
         .write_pending_status =         ft_write_pending_status,
         .set_default_node_attributes =  ft_set_default_node_attr,
-        .get_task_tag =                 ft_get_task_tag,
         .get_cmd_state =                ft_get_cmd_state,
         .queue_data_in =                ft_queue_data_in,
         .queue_status =                 ft_queue_status,
diff --git a/drivers/usb/gadget/legacy/tcm_usb_gadget.c b/drivers/usb/gadget/legacy/tcm_usb_gadget.c
index 77cdbb56e1d5..a000d89dc78a 100644
--- a/drivers/usb/gadget/legacy/tcm_usb_gadget.c
+++ b/drivers/usb/gadget/legacy/tcm_usb_gadget.c
@@ -1112,6 +1112,7 @@ static int usbg_submit_command(struct f_uas *fu,
         memcpy(cmd->cmd_buf, cmd_iu->cdb, cmd_len);
 
         cmd->tag = be16_to_cpup(&cmd_iu->tag);
+        cmd->se_cmd.tag = cmd->tag;
         if (fu->flags & USBG_USE_STREAMS) {
                 if (cmd->tag > UASP_SS_EP_COMP_NUM_STREAMS)
                         goto err;
@@ -1245,6 +1246,7 @@ static int bot_submit_command(struct f_uas *fu,
         cmd->unpacked_lun = cbw->Lun;
         cmd->is_read = cbw->Flags & US_BULK_FLAG_IN ? 1 : 0;
         cmd->data_len = le32_to_cpu(cbw->DataTransferLength);
+        cmd->se_cmd.tag = le32_to_cpu(cmd->bot_tag);
 
         INIT_WORK(&cmd->work, bot_cmd_work);
         ret = queue_work(tpg->workqueue, &cmd->work);
@@ -1340,18 +1342,6 @@ static void usbg_set_default_node_attrs(struct se_node_acl *nacl)
         return;
 }
 
-static u32 usbg_get_task_tag(struct se_cmd *se_cmd)
-{
-        struct usbg_cmd *cmd = container_of(se_cmd, struct usbg_cmd,
-                        se_cmd);
-        struct f_uas *fu = cmd->fu;
-
-        if (fu->flags & USBG_IS_BOT)
-                return le32_to_cpu(cmd->bot_tag);
-        else
-                return cmd->tag;
-}
-
 static int usbg_get_cmd_state(struct se_cmd *se_cmd)
 {
         return 0;
@@ -1739,7 +1729,6 @@ static const struct target_core_fabric_ops usbg_ops = {
         .write_pending                  = usbg_send_write_request,
         .write_pending_status           = usbg_write_pending_status,
         .set_default_node_attributes    = usbg_set_default_node_attrs,
-        .get_task_tag                   = usbg_get_task_tag,
         .get_cmd_state                  = usbg_get_cmd_state,
         .queue_data_in                  = usbg_send_read_response,
         .queue_status                   = usbg_send_status_response,
diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c
index db9f4b474214..4a003948b07f 100644
--- a/drivers/vhost/scsi.c
+++ b/drivers/vhost/scsi.c
@@ -369,11 +369,6 @@ static void vhost_scsi_set_default_node_attrs(struct se_node_acl *nacl)
         return;
 }
 
-static u32 vhost_scsi_get_task_tag(struct se_cmd *se_cmd)
-{
-        return 0;
-}
-
 static int vhost_scsi_get_cmd_state(struct se_cmd *se_cmd)
 {
         return 0;
@@ -818,6 +813,7 @@ static void vhost_scsi_submission_work(struct work_struct *work)
         }
         tv_nexus = cmd->tvc_nexus;
 
+        se_cmd->tag = 0;
         rc = target_submit_cmd_map_sgls(se_cmd, tv_nexus->tvn_se_sess,
                         cmd->tvc_cdb, &cmd->tvc_sense_buf[0],
                         cmd->tvc_lun, cmd->tvc_exp_data_len,
@@ -2148,7 +2144,6 @@ static struct target_core_fabric_ops vhost_scsi_ops = {
         .write_pending                  = vhost_scsi_write_pending,
         .write_pending_status           = vhost_scsi_write_pending_status,
         .set_default_node_attributes    = vhost_scsi_set_default_node_attrs,
-        .get_task_tag                   = vhost_scsi_get_task_tag,
         .get_cmd_state                  = vhost_scsi_get_cmd_state,
         .queue_data_in                  = vhost_scsi_queue_data_in,
         .queue_status                   = vhost_scsi_queue_status,
diff --git a/drivers/xen/xen-scsiback.c b/drivers/xen/xen-scsiback.c
index 10c71a5616fa..ea929baf7ad0 100644
--- a/drivers/xen/xen-scsiback.c
+++ b/drivers/xen/xen-scsiback.c
@@ -400,6 +400,7 @@ static void scsiback_cmd_exec(struct vscsibk_pend *pending_req)
         memset(se_cmd, 0, sizeof(*se_cmd));
 
         scsiback_get(pending_req->info);
+        se_cmd->tag = pending_req->rqid;
         rc = target_submit_cmd_map_sgls(se_cmd, sess, pending_req->cmnd,
                         pending_req->sense_buffer, pending_req->v2p->lun,
                         pending_req->data_len, 0,
@@ -1394,14 +1395,6 @@ static void scsiback_set_default_node_attrs(struct se_node_acl *nacl)
 {
 }
 
-static u32 scsiback_get_task_tag(struct se_cmd *se_cmd)
-{
-        struct vscsibk_pend *pending_req = container_of(se_cmd,
-                                struct vscsibk_pend, se_cmd);
-
-        return pending_req->rqid;
-}
-
 static int scsiback_get_cmd_state(struct se_cmd *se_cmd)
 {
         return 0;
@@ -1833,7 +1826,6 @@ static const struct target_core_fabric_ops scsiback_ops = {
         .write_pending                  = scsiback_write_pending,
         .write_pending_status           = scsiback_write_pending_status,
         .set_default_node_attributes    = scsiback_set_default_node_attrs,
-        .get_task_tag                   = scsiback_get_task_tag,
         .get_cmd_state                  = scsiback_get_cmd_state,
         .queue_data_in                  = scsiback_queue_data_in,
         .queue_status                   = scsiback_queue_status,
diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h
index c462fb0a47f4..042a73464966 100644
--- a/include/target/target_core_base.h
+++ b/include/target/target_core_base.h
@@ -420,7 +420,7 @@ struct se_tmr_req {
         u8                      response;
         int                     call_transport;
         /* Reference to ITT that Task Mgmt should be performed */
-        u32                     ref_task_tag;
+        u64                     ref_task_tag;
         void                    *fabric_tmr_ptr;
         struct se_cmd           *task_cmd;
         struct se_device        *tmr_dev;
@@ -473,6 +473,7 @@ struct se_cmd {
         u8                      scsi_asc;
         u8                      scsi_ascq;
         u16                     scsi_sense_length;
+        u64                     tag; /* SAM command identifier aka task tag */
         /* Delay for ALUA Active/NonOptimized state access in milliseconds */
         int                     alua_nonop_delay;
         /* See include/linux/dma-mapping.h */
diff --git a/include/target/target_core_fabric.h b/include/target/target_core_fabric.h
index a420f434c6c5..f64d493f888b 100644
--- a/include/target/target_core_fabric.h
+++ b/include/target/target_core_fabric.h
@@ -53,7 +53,6 @@ struct target_core_fabric_ops {
         int (*write_pending)(struct se_cmd *);
         int (*write_pending_status)(struct se_cmd *);
         void (*set_default_node_attributes)(struct se_node_acl *);
-        u32 (*get_task_tag)(struct se_cmd *);
         int (*get_cmd_state)(struct se_cmd *);
         int (*queue_data_in)(struct se_cmd *);
         int (*queue_status)(struct se_cmd *);