target: Add SCF_SCSI_TMR_CDB usage and drop se_tmr_req_cache

Change the test for if a cmd is a tmr request to checking if
SCF_SCSI_TMR_CDB (a new flag) is set in cmd->se_cmd_flags.

Also remove se_tmr_req_cache usage in favor of kzalloc usage,
and make core_tmr_alloc_req() return int + setup se_cmd->se_tmr_req
directly and fix up various fabric module usages

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

diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c
index e1e6b5b03c96cdd38137002afb0516d394195fd3..3290a57b248ec92d39f749c2ac1e07a785e81b5b 100644 (file)
--- a/drivers/infiniband/ulp/srpt/ib_srpt.c
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.c
@@ -1878,8 +1878,8 @@ static void srpt_handle_tsk_mgmt(struct srpt_rdma_ch *ch,
                        TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED;
                goto process_tmr;
        }
-       cmd->se_tmr_req = core_tmr_alloc_req(cmd, NULL, tcm_tmr, GFP_KERNEL);
-       if (!cmd->se_tmr_req) {
+       res = core_tmr_alloc_req(cmd, NULL, tcm_tmr, GFP_KERNEL);
+       if (res < 0) {
                send_ioctx->cmd.se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
                send_ioctx->cmd.se_tmr_req->response = TMR_FUNCTION_REJECTED;
                goto process_tmr;

diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c
index 11287e1ece134190b6541bdb2bea45a236e46515..4eba86d2bd8232091bbe1888a39254516569fa84 100644 (file)
--- a/drivers/target/iscsi/iscsi_target_util.c
+++ b/drivers/target/iscsi/iscsi_target_util.c
@@ -229,6 +229,7 @@ struct iscsi_cmd *iscsit_allocate_se_cmd_for_tmr(
 {
        struct iscsi_cmd *cmd;
        struct se_cmd *se_cmd;
+       int rc;
        u8 tcm_function;
 
        cmd = iscsit_allocate_cmd(conn, GFP_KERNEL);
@@ -286,10 +287,8 @@ struct iscsi_cmd *iscsit_allocate_se_cmd_for_tmr(
                goto out;
        }
 
-       se_cmd->se_tmr_req = core_tmr_alloc_req(se_cmd,
-                               cmd->tmr_req, tcm_function,
-                               GFP_KERNEL);
-       if (!se_cmd->se_tmr_req)
+       rc = core_tmr_alloc_req(se_cmd, cmd->tmr_req, tcm_function, GFP_KERNEL);
+       if (rc < 0)
                goto out;
 
        cmd->tmr_req->se_tmr_req = se_cmd->se_tmr_req;

diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c
index c47ff7f59e5733226702004617327a28b566f7f1..7cfbcb00b3c308369e1523e011885c5978f42bd3 100644 (file)
--- a/drivers/target/loopback/tcm_loop.c
+++ b/drivers/target/loopback/tcm_loop.c
@@ -187,7 +187,7 @@ static int tcm_loop_check_stop_free(struct se_cmd *se_cmd)
         * pointer.  These will be released directly in tcm_loop_device_reset()
         * with transport_generic_free_cmd().
         */
-       if (se_cmd->se_tmr_req)
+       if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)
                return 0;
        /*
         * Release the struct se_cmd, which will make a callback to release
@@ -324,7 +324,7 @@ static int tcm_loop_device_reset(struct scsi_cmnd *sc)
        struct tcm_loop_nexus *tl_nexus;
        struct tcm_loop_tmr *tl_tmr = NULL;
        struct tcm_loop_tpg *tl_tpg;
-       int ret = FAILED;
+       int ret = FAILED, rc;
        /*
         * Locate the tcm_loop_hba_t pointer
         */
@@ -365,12 +365,9 @@ static int tcm_loop_device_reset(struct scsi_cmnd *sc)
        transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, 0,
                                DMA_NONE, MSG_SIMPLE_TAG,
                                &tl_cmd->tl_sense_buf[0]);
-       /*
-        * Allocate the LUN_RESET TMR
-        */
-       se_cmd->se_tmr_req = core_tmr_alloc_req(se_cmd, tl_tmr,
-                                               TMR_LUN_RESET, GFP_KERNEL);
-       if (IS_ERR(se_cmd->se_tmr_req))
+
+       rc = core_tmr_alloc_req(se_cmd, tl_tmr, TMR_LUN_RESET, GFP_KERNEL);
+       if (rc < 0)
                goto release;
        /*
         * Locate the underlying TCM struct se_lun from sc->device->lun

diff --git a/drivers/target/target_core_tmr.c b/drivers/target/target_core_tmr.c
index a5c2e41debf82111d20d0d2bdfd5edaf53e2ee9f..5d3eb9e6c2ed2f60171bdff93e5435d71fd5844d 100644 (file)
--- a/drivers/target/target_core_tmr.c
+++ b/drivers/target/target_core_tmr.c
@@ -40,7 +40,7 @@
 #include "target_core_alua.h"
 #include "target_core_pr.h"
 
-struct se_tmr_req *core_tmr_alloc_req(
+int core_tmr_alloc_req(
        struct se_cmd *se_cmd,
        void *fabric_tmr_ptr,
        u8 function,
@@ -48,17 +48,20 @@ struct se_tmr_req *core_tmr_alloc_req(
 {
        struct se_tmr_req *tmr;
 
-       tmr = kmem_cache_zalloc(se_tmr_req_cache, gfp_flags);
+       tmr = kzalloc(sizeof(struct se_tmr_req), gfp_flags);
        if (!tmr) {
                pr_err("Unable to allocate struct se_tmr_req\n");
-               return ERR_PTR(-ENOMEM);
+               return -ENOMEM;
        }
+
+       se_cmd->se_cmd_flags |= SCF_SCSI_TMR_CDB;
+       se_cmd->se_tmr_req = tmr;
        tmr->task_cmd = se_cmd;
        tmr->fabric_tmr_ptr = fabric_tmr_ptr;
        tmr->function = function;
        INIT_LIST_HEAD(&tmr->tmr_list);
 
-       return tmr;
+       return 0;
 }
 EXPORT_SYMBOL(core_tmr_alloc_req);
 
@@ -69,7 +72,7 @@ void core_tmr_release_req(
        unsigned long flags;
 
        if (!dev) {
-               kmem_cache_free(se_tmr_req_cache, tmr);
+               kfree(tmr);
                return;
        }
 
@@ -77,7 +80,7 @@ void core_tmr_release_req(
        list_del(&tmr->tmr_list);
        spin_unlock_irqrestore(&dev->se_tmr_lock, flags);
 
-       kmem_cache_free(se_tmr_req_cache, tmr);
+       kfree(tmr);
 }
 
 static void core_tmr_handle_tas_abort(

diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index affbd4d1446a771fe49cc943f1e807a8915edb1b..c10c3653eabcfe47225fa6168e695c76c9b0df06 100644 (file)
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -58,7 +58,6 @@ static int sub_api_initialized;
 
 static struct workqueue_struct *target_completion_wq;
 static struct kmem_cache *se_sess_cache;
-struct kmem_cache *se_tmr_req_cache;
 struct kmem_cache *se_ua_cache;
 struct kmem_cache *t10_pr_reg_cache;
 struct kmem_cache *t10_alua_lu_gp_cache;
@@ -82,21 +81,13 @@ static void target_complete_ok_work(struct work_struct *work);
 
 int init_se_kmem_caches(void)
 {
-       se_tmr_req_cache = kmem_cache_create("se_tmr_cache",
-                       sizeof(struct se_tmr_req), __alignof__(struct se_tmr_req),
-                       0, NULL);
-       if (!se_tmr_req_cache) {
-               pr_err("kmem_cache_create() for struct se_tmr_req"
-                               " failed\n");
-               goto out;
-       }
        se_sess_cache = kmem_cache_create("se_sess_cache",
                        sizeof(struct se_session), __alignof__(struct se_session),
                        0, NULL);
        if (!se_sess_cache) {
                pr_err("kmem_cache_create() for struct se_session"
                                " failed\n");
-               goto out_free_tmr_req_cache;
+               goto out;
        }
        se_ua_cache = kmem_cache_create("se_ua_cache",
                        sizeof(struct se_ua), __alignof__(struct se_ua),
@@ -169,8 +160,6 @@ out_free_ua_cache:
        kmem_cache_destroy(se_ua_cache);
 out_free_sess_cache:
        kmem_cache_destroy(se_sess_cache);
-out_free_tmr_req_cache:
-       kmem_cache_destroy(se_tmr_req_cache);
 out:
        return -ENOMEM;
 }
@@ -178,7 +167,6 @@ out:
 void release_se_kmem_caches(void)
 {
        destroy_workqueue(target_completion_wq);
-       kmem_cache_destroy(se_tmr_req_cache);
        kmem_cache_destroy(se_sess_cache);
        kmem_cache_destroy(se_ua_cache);
        kmem_cache_destroy(t10_pr_reg_cache);
@@ -553,7 +541,7 @@ static void transport_lun_remove_cmd(struct se_cmd *cmd)
 
 void transport_cmd_finish_abort(struct se_cmd *cmd, int remove)
 {
-       if (!cmd->se_tmr_req)
+       if (!(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB))
                transport_lun_remove_cmd(cmd);
 
        if (transport_cmd_check_stop_to_fabric(cmd))
@@ -3367,7 +3355,7 @@ static void transport_release_cmd(struct se_cmd *cmd)
 {
        BUG_ON(!cmd->se_tfo);
 
-       if (cmd->se_tmr_req)
+       if (cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)
                core_tmr_release_req(cmd->se_tmr_req);
        if (cmd->t_task_cdb != cmd->__t_task_cdb)
                kfree(cmd->t_task_cdb);
@@ -3956,7 +3944,7 @@ queue_full:
 void transport_generic_free_cmd(struct se_cmd *cmd, int wait_for_tasks)
 {
        if (!(cmd->se_cmd_flags & SCF_SE_LUN_CMD)) {
-               if (wait_for_tasks && cmd->se_tmr_req)
+               if (wait_for_tasks && (cmd->se_cmd_flags & SCF_SCSI_TMR_CDB))
                         transport_wait_for_tasks(cmd);
 
                transport_release_cmd(cmd);
@@ -4282,7 +4270,8 @@ bool transport_wait_for_tasks(struct se_cmd *cmd)
        unsigned long flags;
 
        spin_lock_irqsave(&cmd->t_state_lock, flags);
-       if (!(cmd->se_cmd_flags & SCF_SE_LUN_CMD) && !(cmd->se_tmr_req)) {
+       if (!(cmd->se_cmd_flags & SCF_SE_LUN_CMD) &&
+           !(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) {
                spin_unlock_irqrestore(&cmd->t_state_lock, flags);
                return false;
        }
@@ -4290,7 +4279,8 @@ bool transport_wait_for_tasks(struct se_cmd *cmd)
         * Only perform a possible wait_for_tasks if SCF_SUPPORTED_SAM_OPCODE
         * has been set in transport_set_supported_SAM_opcode().
         */
-       if (!(cmd->se_cmd_flags & SCF_SUPPORTED_SAM_OPCODE) && !cmd->se_tmr_req) {
+       if (!(cmd->se_cmd_flags & SCF_SUPPORTED_SAM_OPCODE) &&
+           !(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) {
                spin_unlock_irqrestore(&cmd->t_state_lock, flags);
                return false;
        }

diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index a76661178d6b784cd8d5a66184e093812a3453be..bdf25593b81c8d422413c5fc00fe410c8e16c839 100644 (file)
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -356,6 +356,7 @@ static void ft_send_tm(struct ft_cmd *cmd)
        struct se_tmr_req *tmr;
        struct fcp_cmnd *fcp;
        struct ft_sess *sess;
+       int rc;
        u8 tm_func;
 
        transport_init_se_cmd(&cmd->se_cmd, &ft_configfs->tf_ops,
@@ -392,13 +393,12 @@ static void ft_send_tm(struct ft_cmd *cmd)
        }
 
        pr_debug("alloc tm cmd fn %d\n", tm_func);
-       tmr = core_tmr_alloc_req(&cmd->se_cmd, cmd, tm_func, GFP_KERNEL);
-       if (!tmr) {
+       rc = core_tmr_alloc_req(&cmd->se_cmd, cmd, tm_func, GFP_KERNEL);
+       if (rc < 0) {
                pr_debug("alloc failed\n");
                ft_send_resp_code_and_free(cmd, FCP_TMF_FAILED);
                return;
        }
-       cmd->se_cmd.se_tmr_req = tmr;
 
        switch (fcp->fc_tm_flags) {
        case FCP_TMF_LUN_RESET:

diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h
index 41dd91b98907a0b0d1ab3b840839f264f3011500..9d514e06625f7321adcbc7fbcbe48c7e0eb42bf6 100644 (file)
--- a/include/target/target_core_base.h
+++ b/include/target/target_core_base.h
@@ -169,7 +169,8 @@ enum se_cmd_flags_table {
        SCF_EMULATED_TASK_SENSE         = 0x00000004,
        SCF_SCSI_DATA_SG_IO_CDB         = 0x00000008,
        SCF_SCSI_CONTROL_SG_IO_CDB      = 0x00000010,
-       SCF_SCSI_NON_DATA_CDB           = 0x00000040,
+       SCF_SCSI_NON_DATA_CDB           = 0x00000020,
+       SCF_SCSI_TMR_CDB                = 0x00000040,
        SCF_SCSI_CDB_EXCEPTION          = 0x00000080,
        SCF_SCSI_RESERVATION_CONFLICT   = 0x00000100,
        SCF_FUA                         = 0x00000200,
@@ -498,6 +499,24 @@ struct se_task {
        struct completion       task_stop_comp;
 };
 
+struct se_tmr_req {
+       /* Task Management function to be performed */
+       u8                      function;
+       /* Task Management response to send */
+       u8                      response;
+       int                     call_transport;
+       /* Reference to ITT that Task Mgmt should be performed */
+       u32                     ref_task_tag;
+       /* 64-bit encoded SAM LUN from $FABRIC_MOD TMR header */
+       u64                     ref_task_lun;
+       void                    *fabric_tmr_ptr;
+       struct se_cmd           *task_cmd;
+       struct se_cmd           *ref_cmd;
+       struct se_device        *tmr_dev;
+       struct se_lun           *tmr_lun;
+       struct list_head        tmr_list;
+};
+
 struct se_cmd {
        /* SAM response code being sent to initiator */
        u8                      scsi_status;
@@ -586,24 +605,6 @@ struct se_cmd {
 
 };
 
-struct se_tmr_req {
-       /* Task Management function to be performed */
-       u8                      function;
-       /* Task Management response to send */
-       u8                      response;
-       int                     call_transport;
-       /* Reference to ITT that Task Mgmt should be performed */
-       u32                     ref_task_tag;
-       /* 64-bit encoded SAM LUN from $FABRIC_MOD TMR header */
-       u64                     ref_task_lun;
-       void                    *fabric_tmr_ptr;
-       struct se_cmd           *task_cmd;
-       struct se_cmd           *ref_cmd;
-       struct se_device        *tmr_dev;
-       struct se_lun           *tmr_lun;
-       struct list_head        tmr_list;
-};
-
 struct se_ua {
        u8                      ua_asc;
        u8                      ua_ascq;

diff --git a/include/target/target_core_fabric.h b/include/target/target_core_fabric.h
index d36fad317e78089ea95e13a9b414558379f6326d..c5c16efe396d535559efa7b293378fbbf26ff83c 100644 (file)
--- a/include/target/target_core_fabric.h
+++ b/include/target/target_core_fabric.h
@@ -139,7 +139,7 @@ void        target_wait_for_sess_cmds(struct se_session *, int);
 
 int    core_alua_check_nonop_delay(struct se_cmd *);
 
-struct se_tmr_req *core_tmr_alloc_req(struct se_cmd *, void *, u8, gfp_t);
+int    core_tmr_alloc_req(struct se_cmd *, void *, u8, gfp_t);
 void   core_tmr_release_req(struct se_tmr_req *);
 int    transport_generic_handle_tmr(struct se_cmd *);
 int    transport_lookup_tmr_lun(struct se_cmd *, u32);