target: Move task tag into struct se_cmd + support 64-bit tags
authorBart Van Assche <bart.vanassche@sandisk.com>
Tue, 14 Apr 2015 11:26:44 +0000 (13:26 +0200)
committerNicholas Bellinger <nab@linux-iscsi.org>
Sun, 31 May 2015 05:42:31 +0000 (22:42 -0700)
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:
Documentation/target/tcm_mod_builder.py
drivers/infiniband/ulp/srpt/ib_srpt.c
drivers/infiniband/ulp/srpt/ib_srpt.h
drivers/scsi/qla2xxx/qla_target.c
drivers/scsi/qla2xxx/qla_target.h
drivers/scsi/qla2xxx/tcm_qla2xxx.c
drivers/target/iscsi/iscsi_target.c
drivers/target/iscsi/iscsi_target_configfs.c
drivers/target/loopback/tcm_loop.c
drivers/target/sbp/sbp_target.c
drivers/target/target_core_configfs.c
drivers/target/target_core_tmr.c
drivers/target/target_core_transport.c
drivers/target/target_core_xcopy.c
drivers/target/tcm_fc/tcm_fc.h
drivers/target/tcm_fc/tfc_cmd.c
drivers/target/tcm_fc/tfc_conf.c
drivers/usb/gadget/legacy/tcm_usb_gadget.c
drivers/vhost/scsi.c
drivers/xen/xen-scsiback.c
include/target/target_core_base.h
include/target/target_core_fabric.h

index 0dbd70cccde11a462ab9a7c03239069f53a3638f..71e1f586331046bfd2dcf7689eb930f96e6ead42 100755 (executable)
@@ -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"
index 98e00360f97e1c3463bca514f741ca2facde854e..56df5cd918c5bd9ff9205ccfa6b85de84020015d 100644 (file)
@@ -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,
index 33b2c88b73ba8db825785a763790d8a59d6a4aba..6fec740742bdeef5b281532504890641796429dd 100644 (file)
@@ -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;
index fe8a8d157e225df6018f101ec0f3a0be3d3e786f..e7515069e1ce6cd35bc1d61e2a68a9c137db0e8d 100644 (file)
@@ -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);
 
index 332086776dfe94db4be404cca5c621518d600b1f..985d76dd706b71b3da1b3685169a21c24af90fa0 100644 (file)
@@ -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;
index bd0f9eb6790160174fa4ebb892178fa31250699e..8e331220adda22856312a93ef7a29e0836a5c181 100644 (file)
@@ -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,
index 866c167c0986cb7f7025cfbeb3f9dfb7705c973e..3c4431f711583de956a172f571d2d004afb4f4de 100644 (file)
@@ -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) {
index bd8af8764f4bfc511ce599b758b40f7401cc9d02..aa4fc4d8e176e0b1d7693693474a0101278e2387 100644 (file)
@@ -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,
index b788406977f6f0b43361f4e107aa6ddb7c6b850a..07d3b52c88eb2bb9e4fcc1a53025c7be875d6e41 100644 (file)
@@ -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,
index 89f172dc8678b2ea9d3d92b9cff4966d32c804a4..2916a4023e7146b063a776ba57951ea58be1a5d0 100644 (file)
@@ -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,
index 5e2649fc6919da1c268064c4ec672d92d541f6de..fc598c0845238fb27f8668a407ae504a5844d04e 100644 (file)
@@ -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;
index b2e169fba3c68aec6deadfd6ba9add772ba75963..393aca8bb3eb5782a99986053539e2b6518804d8 100644 (file)
@@ -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);
index 85b021e749e6426710caa64a758fb66142d9eb5e..0d8662bb470e2a21ad15b5fe6587647518b718f8 100644 (file)
@@ -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);
index 8fd680ac941bde49cd7803134da5beb77c7092b0..5545619d3045c0b1acafb022e2ec819d2827bc73 100644 (file)
@@ -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;
index 4ceaeb9a4b93130e4de2939b4b8011efb10af517..39909dadef3e82476ad2747aa42974ee6647162d 100644 (file)
@@ -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 *);
index edcafa4490c0850bfc01115357ce4e817773ee72..a8fe6ed5262f59f0658f002b3ae6271af3d7ab10 100644 (file)
@@ -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.
index 6ad7404b7dd15f73e5c18e09d65e4d7cc502ed74..f0821967f0a1b171c57fcb8c792891e3636db07b 100644 (file)
@@ -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,
index 77cdbb56e1d53447064ecda77ffa98a87b151541..a000d89dc78a188e0ee3692f393d0ee2b69042d5 100644 (file)
@@ -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,
index db9f4b474214dc972a7de4e4d0ef0d7d52b5c31a..4a003948b07f0a88ee57a09cd8277c65626bb5bb 100644 (file)
@@ -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,
index 10c71a5616fa9f52fea66d32cc8635ba90a7a164..ea929baf7ad0cdf41e95cb1dbcee3369a7645dcb 100644 (file)
@@ -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,
index c462fb0a47f48e56ceb9aef472bbd4499ddc2740..042a73464966d12610cb76a158dee533d77702b6 100644 (file)
@@ -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 */
index a420f434c6c56bcddd8528c41fbe4e0e5bdedf82..f64d493f888b642fd75b54df730247578f3a15d4 100644 (file)
@@ -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 *);