vhost-scsi: Rename struct tcm_vhost_cmd *tv_cmd to *cmd

This way, we use cmd for struct tcm_vhost_cmd and evt for struct
tcm_vhost_cmd.

Signed-off-by: Asias He <asias@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>

1 files changed, 71 insertions, 71 deletions

diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c
index 7fb18595c744..03765e17c154 100644
--- a/drivers/vhost/scsi.c
+++ b/drivers/vhost/scsi.c
@@ -494,28 +494,28 @@ static int tcm_vhost_get_cmd_state(struct se_cmd *se_cmd)
         return 0;
 }
 
-static void vhost_scsi_complete_cmd(struct tcm_vhost_cmd *tv_cmd)
+static void vhost_scsi_complete_cmd(struct tcm_vhost_cmd *cmd)
 {
-        struct vhost_scsi *vs = tv_cmd->tvc_vhost;
+        struct vhost_scsi *vs = cmd->tvc_vhost;
 
-        llist_add(&tv_cmd->tvc_completion_list, &vs->vs_completion_list);
+        llist_add(&cmd->tvc_completion_list, &vs->vs_completion_list);
 
         vhost_work_queue(&vs->dev, &vs->vs_completion_work);
 }
 
 static int tcm_vhost_queue_data_in(struct se_cmd *se_cmd)
 {
-        struct tcm_vhost_cmd *tv_cmd = container_of(se_cmd,
+        struct tcm_vhost_cmd *cmd = container_of(se_cmd,
                                 struct tcm_vhost_cmd, tvc_se_cmd);
-        vhost_scsi_complete_cmd(tv_cmd);
+        vhost_scsi_complete_cmd(cmd);
         return 0;
 }
 
 static int tcm_vhost_queue_status(struct se_cmd *se_cmd)
 {
-        struct tcm_vhost_cmd *tv_cmd = container_of(se_cmd,
+        struct tcm_vhost_cmd *cmd = container_of(se_cmd,
                                 struct tcm_vhost_cmd, tvc_se_cmd);
-        vhost_scsi_complete_cmd(tv_cmd);
+        vhost_scsi_complete_cmd(cmd);
         return 0;
 }
 
@@ -556,24 +556,24 @@ tcm_vhost_allocate_evt(struct vhost_scsi *vs,
         return evt;
 }
 
-static void vhost_scsi_free_cmd(struct tcm_vhost_cmd *tv_cmd)
+static void vhost_scsi_free_cmd(struct tcm_vhost_cmd *cmd)
 {
-        struct se_cmd *se_cmd = &tv_cmd->tvc_se_cmd;
+        struct se_cmd *se_cmd = &cmd->tvc_se_cmd;
 
         /* TODO locking against target/backend threads? */
         transport_generic_free_cmd(se_cmd, 1);
 
-        if (tv_cmd->tvc_sgl_count) {
+        if (cmd->tvc_sgl_count) {
                 u32 i;
-                for (i = 0; i < tv_cmd->tvc_sgl_count; i++)
-                        put_page(sg_page(&tv_cmd->tvc_sgl[i]));
+                for (i = 0; i < cmd->tvc_sgl_count; i++)
+                        put_page(sg_page(&cmd->tvc_sgl[i]));
 
-                kfree(tv_cmd->tvc_sgl);
+                kfree(cmd->tvc_sgl);
         }
 
-        tcm_vhost_put_inflight(tv_cmd->inflight);
+        tcm_vhost_put_inflight(cmd->inflight);
 
-        kfree(tv_cmd);
+        kfree(cmd);
 }
 
 static void
@@ -656,7 +656,7 @@ static void vhost_scsi_complete_cmd_work(struct vhost_work *work)
                                         vs_completion_work);
         DECLARE_BITMAP(signal, VHOST_SCSI_MAX_VQ);
         struct virtio_scsi_cmd_resp v_rsp;
-        struct tcm_vhost_cmd *tv_cmd;
+        struct tcm_vhost_cmd *cmd;
         struct llist_node *llnode;
         struct se_cmd *se_cmd;
         int ret, vq;
@@ -664,32 +664,32 @@ static void vhost_scsi_complete_cmd_work(struct vhost_work *work)
         bitmap_zero(signal, VHOST_SCSI_MAX_VQ);
         llnode = llist_del_all(&vs->vs_completion_list);
         while (llnode) {
-                tv_cmd = llist_entry(llnode, struct tcm_vhost_cmd,
+                cmd = llist_entry(llnode, struct tcm_vhost_cmd,
                                      tvc_completion_list);
                 llnode = llist_next(llnode);
-                se_cmd = &tv_cmd->tvc_se_cmd;
+                se_cmd = &cmd->tvc_se_cmd;
 
                 pr_debug("%s tv_cmd %p resid %u status %#02x\n", __func__,
-                        tv_cmd, se_cmd->residual_count, se_cmd->scsi_status);
+                        cmd, se_cmd->residual_count, se_cmd->scsi_status);
 
                 memset(&v_rsp, 0, sizeof(v_rsp));
                 v_rsp.resid = se_cmd->residual_count;
                 /* TODO is status_qualifier field needed? */
                 v_rsp.status = se_cmd->scsi_status;
                 v_rsp.sense_len = se_cmd->scsi_sense_length;
-                memcpy(v_rsp.sense, tv_cmd->tvc_sense_buf,
+                memcpy(v_rsp.sense, cmd->tvc_sense_buf,
                        v_rsp.sense_len);
-                ret = copy_to_user(tv_cmd->tvc_resp, &v_rsp, sizeof(v_rsp));
+                ret = copy_to_user(cmd->tvc_resp, &v_rsp, sizeof(v_rsp));
                 if (likely(ret == 0)) {
                         struct vhost_scsi_virtqueue *q;
-                        vhost_add_used(tv_cmd->tvc_vq, tv_cmd->tvc_vq_desc, 0);
-                        q = container_of(tv_cmd->tvc_vq, struct vhost_scsi_virtqueue, vq);
+                        vhost_add_used(cmd->tvc_vq, cmd->tvc_vq_desc, 0);
+                        q = container_of(cmd->tvc_vq, struct vhost_scsi_virtqueue, vq);
                         vq = q - vs->vqs;
                         __set_bit(vq, signal);
                 } else
                         pr_err("Faulted on virtio_scsi_cmd_resp\n");
 
-                vhost_scsi_free_cmd(tv_cmd);
+                vhost_scsi_free_cmd(cmd);
         }
 
         vq = -1;
@@ -705,7 +705,7 @@ vhost_scsi_allocate_cmd(struct vhost_virtqueue *vq,
                         u32 exp_data_len,
                         int data_direction)
 {
-        struct tcm_vhost_cmd *tv_cmd;
+        struct tcm_vhost_cmd *cmd;
         struct tcm_vhost_nexus *tv_nexus;
 
         tv_nexus = tpg->tpg_nexus;
@@ -714,19 +714,19 @@ vhost_scsi_allocate_cmd(struct vhost_virtqueue *vq,
                 return ERR_PTR(-EIO);
         }
 
-        tv_cmd = kzalloc(sizeof(struct tcm_vhost_cmd), GFP_ATOMIC);
-        if (!tv_cmd) {
+        cmd = kzalloc(sizeof(struct tcm_vhost_cmd), GFP_ATOMIC);
+        if (!cmd) {
                 pr_err("Unable to allocate struct tcm_vhost_cmd\n");
                 return ERR_PTR(-ENOMEM);
         }
-        tv_cmd->tvc_tag = v_req->tag;
-        tv_cmd->tvc_task_attr = v_req->task_attr;
-        tv_cmd->tvc_exp_data_len = exp_data_len;
-        tv_cmd->tvc_data_direction = data_direction;
-        tv_cmd->tvc_nexus = tv_nexus;
-        tv_cmd->inflight = tcm_vhost_get_inflight(vq);
+        cmd->tvc_tag = v_req->tag;
+        cmd->tvc_task_attr = v_req->task_attr;
+        cmd->tvc_exp_data_len = exp_data_len;
+        cmd->tvc_data_direction = data_direction;
+        cmd->tvc_nexus = tv_nexus;
+        cmd->inflight = tcm_vhost_get_inflight(vq);
 
-        return tv_cmd;
+        return cmd;
 }
 
 /*
@@ -783,7 +783,7 @@ out:
 }
 
 static int
-vhost_scsi_map_iov_to_sgl(struct tcm_vhost_cmd *tv_cmd,
+vhost_scsi_map_iov_to_sgl(struct tcm_vhost_cmd *cmd,
                           struct iovec *iov,
                           unsigned int niov,
                           int write)
@@ -802,25 +802,25 @@ vhost_scsi_map_iov_to_sgl(struct tcm_vhost_cmd *tv_cmd,
 
         /* TODO overflow checking */
 
-        sg = kmalloc(sizeof(tv_cmd->tvc_sgl[0]) * sgl_count, GFP_ATOMIC);
+        sg = kmalloc(sizeof(cmd->tvc_sgl[0]) * sgl_count, GFP_ATOMIC);
         if (!sg)
                 return -ENOMEM;
         pr_debug("%s sg %p sgl_count %u is_err %d\n", __func__,
                sg, sgl_count, !sg);
         sg_init_table(sg, sgl_count);
 
-        tv_cmd->tvc_sgl = sg;
-        tv_cmd->tvc_sgl_count = sgl_count;
+        cmd->tvc_sgl = sg;
+        cmd->tvc_sgl_count = sgl_count;
 
         pr_debug("Mapping %u iovecs for %u pages\n", niov, sgl_count);
         for (i = 0; i < niov; i++) {
                 ret = vhost_scsi_map_to_sgl(sg, sgl_count, &iov[i], write);
                 if (ret < 0) {
-                        for (i = 0; i < tv_cmd->tvc_sgl_count; i++)
-                                put_page(sg_page(&tv_cmd->tvc_sgl[i]));
-                        kfree(tv_cmd->tvc_sgl);
-                        tv_cmd->tvc_sgl = NULL;
-                        tv_cmd->tvc_sgl_count = 0;
+                        for (i = 0; i < cmd->tvc_sgl_count; i++)
+                                put_page(sg_page(&cmd->tvc_sgl[i]));
+                        kfree(cmd->tvc_sgl);
+                        cmd->tvc_sgl = NULL;
+                        cmd->tvc_sgl_count = 0;
                         return ret;
                 }
 
@@ -832,15 +832,15 @@ vhost_scsi_map_iov_to_sgl(struct tcm_vhost_cmd *tv_cmd,
 
 static void tcm_vhost_submission_work(struct work_struct *work)
 {
-        struct tcm_vhost_cmd *tv_cmd =
+        struct tcm_vhost_cmd *cmd =
                 container_of(work, struct tcm_vhost_cmd, work);
         struct tcm_vhost_nexus *tv_nexus;
-        struct se_cmd *se_cmd = &tv_cmd->tvc_se_cmd;
+        struct se_cmd *se_cmd = &cmd->tvc_se_cmd;
         struct scatterlist *sg_ptr, *sg_bidi_ptr = NULL;
         int rc, sg_no_bidi = 0;
 
-        if (tv_cmd->tvc_sgl_count) {
-                sg_ptr = tv_cmd->tvc_sgl;
+        if (cmd->tvc_sgl_count) {
+                sg_ptr = cmd->tvc_sgl;
 /* FIXME: Fix BIDI operation in tcm_vhost_submission_work() */
 #if 0
                 if (se_cmd->se_cmd_flags & SCF_BIDI) {
@@ -851,13 +851,13 @@ static void tcm_vhost_submission_work(struct work_struct *work)
         } else {
                 sg_ptr = NULL;
         }
-        tv_nexus = tv_cmd->tvc_nexus;
+        tv_nexus = cmd->tvc_nexus;
 
         rc = target_submit_cmd_map_sgls(se_cmd, tv_nexus->tvn_se_sess,
-                        tv_cmd->tvc_cdb, &tv_cmd->tvc_sense_buf[0],
-                        tv_cmd->tvc_lun, tv_cmd->tvc_exp_data_len,
-                        tv_cmd->tvc_task_attr, tv_cmd->tvc_data_direction,
-                        0, sg_ptr, tv_cmd->tvc_sgl_count,
+                        cmd->tvc_cdb, &cmd->tvc_sense_buf[0],
+                        cmd->tvc_lun, cmd->tvc_exp_data_len,
+                        cmd->tvc_task_attr, cmd->tvc_data_direction,
+                        0, sg_ptr, cmd->tvc_sgl_count,
                         sg_bidi_ptr, sg_no_bidi);
         if (rc < 0) {
                 transport_send_check_condition_and_sense(se_cmd,
@@ -891,7 +891,7 @@ vhost_scsi_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
         struct tcm_vhost_tpg **vs_tpg;
         struct virtio_scsi_cmd_req v_req;
         struct tcm_vhost_tpg *tpg;
-        struct tcm_vhost_cmd *tv_cmd;
+        struct tcm_vhost_cmd *cmd;
         u32 exp_data_len, data_first, data_num, data_direction;
         unsigned out, in, i;
         int head, ret;
@@ -988,46 +988,46 @@ vhost_scsi_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
                 for (i = 0; i < data_num; i++)
                         exp_data_len += vq->iov[data_first + i].iov_len;
 
-                tv_cmd = vhost_scsi_allocate_cmd(vq, tpg, &v_req,
+                cmd = vhost_scsi_allocate_cmd(vq, tpg, &v_req,
                                         exp_data_len, data_direction);
-                if (IS_ERR(tv_cmd)) {
+                if (IS_ERR(cmd)) {
                         vq_err(vq, "vhost_scsi_allocate_cmd failed %ld\n",
-                                        PTR_ERR(tv_cmd));
+                                        PTR_ERR(cmd));
                         goto err_cmd;
                 }
                 pr_debug("Allocated tv_cmd: %p exp_data_len: %d, data_direction"
-                        ": %d\n", tv_cmd, exp_data_len, data_direction);
+                        ": %d\n", cmd, exp_data_len, data_direction);
 
-                tv_cmd->tvc_vhost = vs;
-                tv_cmd->tvc_vq = vq;
-                tv_cmd->tvc_resp = vq->iov[out].iov_base;
+                cmd->tvc_vhost = vs;
+                cmd->tvc_vq = vq;
+                cmd->tvc_resp = vq->iov[out].iov_base;
 
                 /*
-                 * Copy in the recieved CDB descriptor into tv_cmd->tvc_cdb
+                 * Copy in the recieved CDB descriptor into cmd->tvc_cdb
                  * that will be used by tcm_vhost_new_cmd_map() and down into
                  * target_setup_cmd_from_cdb()
                  */
-                memcpy(tv_cmd->tvc_cdb, v_req.cdb, TCM_VHOST_MAX_CDB_SIZE);
+                memcpy(cmd->tvc_cdb, v_req.cdb, TCM_VHOST_MAX_CDB_SIZE);
                 /*
                  * Check that the recieved CDB size does not exceeded our
                  * hardcoded max for tcm_vhost
                  */
                 /* TODO what if cdb was too small for varlen cdb header? */
-                if (unlikely(scsi_command_size(tv_cmd->tvc_cdb) >
+                if (unlikely(scsi_command_size(cmd->tvc_cdb) >
                                         TCM_VHOST_MAX_CDB_SIZE)) {
                         vq_err(vq, "Received SCSI CDB with command_size: %d that"
                                 " exceeds SCSI_MAX_VARLEN_CDB_SIZE: %d\n",
-                                scsi_command_size(tv_cmd->tvc_cdb),
+                                scsi_command_size(cmd->tvc_cdb),
                                 TCM_VHOST_MAX_CDB_SIZE);
                         goto err_free;
                 }
-                tv_cmd->tvc_lun = ((v_req.lun[2] << 8) | v_req.lun[3]) & 0x3FFF;
+                cmd->tvc_lun = ((v_req.lun[2] << 8) | v_req.lun[3]) & 0x3FFF;
 
                 pr_debug("vhost_scsi got command opcode: %#02x, lun: %d\n",
-                        tv_cmd->tvc_cdb[0], tv_cmd->tvc_lun);
+                        cmd->tvc_cdb[0], cmd->tvc_lun);
 
                 if (data_direction != DMA_NONE) {
-                        ret = vhost_scsi_map_iov_to_sgl(tv_cmd,
+                        ret = vhost_scsi_map_iov_to_sgl(cmd,
                                         &vq->iov[data_first], data_num,
                                         data_direction == DMA_TO_DEVICE);
                         if (unlikely(ret)) {
@@ -1041,22 +1041,22 @@ vhost_scsi_handle_vq(struct vhost_scsi *vs, struct vhost_virtqueue *vq)
                  * complete the virtio-scsi request in TCM callback context via
                  * tcm_vhost_queue_data_in() and tcm_vhost_queue_status()
                  */
-                tv_cmd->tvc_vq_desc = head;
+                cmd->tvc_vq_desc = head;
                 /*
                  * Dispatch tv_cmd descriptor for cmwq execution in process
                  * context provided by tcm_vhost_workqueue.  This also ensures
                  * tv_cmd is executed on the same kworker CPU as this vhost
                  * thread to gain positive L2 cache locality effects..
                  */
-                INIT_WORK(&tv_cmd->work, tcm_vhost_submission_work);
-                queue_work(tcm_vhost_workqueue, &tv_cmd->work);
+                INIT_WORK(&cmd->work, tcm_vhost_submission_work);
+                queue_work(tcm_vhost_workqueue, &cmd->work);
         }
 
         mutex_unlock(&vq->mutex);
         return;
 
 err_free:
-        vhost_scsi_free_cmd(tv_cmd);
+        vhost_scsi_free_cmd(cmd);
 err_cmd:
         vhost_scsi_send_bad_target(vs, vq, head, out);
         mutex_unlock(&vq->mutex);