target: Core cleanups from AGrover (round 1)

This patch contains the squashed version of a number of cleanups and
minor fixes from Andy's initial series (round 1) for target core this
past spring.  The condensed log looks like:

target: use errno values instead of returning -1 for everything
target: Rename transport_calc_sg_num to transport_init_task_sg
target: Fix leak in error path in transport_init_task_sg
target/pscsi: Remove pscsi_get_sh() usage
target: Make two runtime checks into WARN_ONs
target: Remove hba queue depth and convert to spin_lock_irq usage
target: dev->dev_status_queue_obj is unused
target: Make struct se_queue_req.cmd type struct se_cmd *
target: Remove __transport_get_qr_from_queue()
target: Rename se_dev->g_se_dev_list to se_dev_node
target: Remove struct se_global
target: Simplify scsi mib index table code
target: Make dev_queue_obj a member of se_device instead of a pointer
target: remove extraneous returns at end of void functions
target: Ensure transport_dump_vpd_ident_type returns null-terminated str
target: Function pointers don't need to use '&' to be assigned
target: Fix comment in __transport_execute_tasks()
target: Misc style cleanups
target: rename struct pr_reservation_template to pr_reservation
target: Remove #defines that just perform indirection
target: Inline transport_get_task_from_execute_queue()
target: Minor header comment fixes

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

1 files changed, 42 insertions, 42 deletions

diff --git a/drivers/target/target_core_tmr.c b/drivers/target/target_core_tmr.c
index 179063d81cdd..2f73749b8151 100644
--- a/drivers/target/target_core_tmr.c
+++ b/drivers/target/target_core_tmr.c
@@ -117,7 +117,7 @@ int core_tmr_lun_reset(
         struct se_queue_req *qr, *qr_tmp;
         struct se_node_acl *tmr_nacl = NULL;
         struct se_portal_group *tmr_tpg = NULL;
-        struct se_queue_obj *qobj = dev->dev_queue_obj;
+        struct se_queue_obj *qobj = &dev->dev_queue_obj;
         struct se_tmr_req *tmr_p, *tmr_pp;
         struct se_task *task, *task_tmp;
         unsigned long flags;
@@ -133,7 +133,7 @@ int core_tmr_lun_reset(
          * which the command was received shall be completed with TASK ABORTED
          * status (see SAM-4).
          */
-        tas = DEV_ATTRIB(dev)->emulate_tas;
+        tas = dev->se_sub_dev->se_dev_attrib.emulate_tas;
         /*
          * Determine if this se_tmr is coming from a $FABRIC_MOD
          * or struct se_device passthrough..
@@ -144,13 +144,13 @@ int core_tmr_lun_reset(
                 if (tmr_nacl && tmr_tpg) {
                         DEBUG_LR("LUN_RESET: TMR caller fabric: %s"
                                 " initiator port %s\n",
-                                TPG_TFO(tmr_tpg)->get_fabric_name(),
+                                tmr_tpg->se_tpg_tfo->get_fabric_name(),
                                 tmr_nacl->initiatorname);
                 }
         }
         DEBUG_LR("LUN_RESET: %s starting for [%s], tas: %d\n",
                 (preempt_and_abort_list) ? "Preempt" : "TMR",
-                TRANSPORT(dev)->name, tas);
+                dev->transport->name, tas);
         /*
          * Release all pending and outgoing TMRs aside from the received
          * LUN_RESET tmr..
@@ -179,14 +179,14 @@ int core_tmr_lun_reset(
                         continue;
                 spin_unlock(&dev->se_tmr_lock);
 
-                spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags);
-                if (!(atomic_read(&T_TASK(cmd)->t_transport_active))) {
-                        spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags);
+                spin_lock_irqsave(&cmd->t_task->t_state_lock, flags);
+                if (!(atomic_read(&cmd->t_task->t_transport_active))) {
+                        spin_unlock_irqrestore(&cmd->t_task->t_state_lock, flags);
                         spin_lock(&dev->se_tmr_lock);
                         continue;
                 }
                 if (cmd->t_state == TRANSPORT_ISTATE_PROCESSING) {
-                        spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags);
+                        spin_unlock_irqrestore(&cmd->t_task->t_state_lock, flags);
                         spin_lock(&dev->se_tmr_lock);
                         continue;
                 }
@@ -194,7 +194,7 @@ int core_tmr_lun_reset(
                         " Response: 0x%02x, t_state: %d\n",
                         (preempt_and_abort_list) ? "Preempt" : "", tmr_p,
                         tmr_p->function, tmr_p->response, cmd->t_state);
-                spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags);
+                spin_unlock_irqrestore(&cmd->t_task->t_state_lock, flags);
 
                 transport_cmd_finish_abort_tmr(cmd);
                 spin_lock(&dev->se_tmr_lock);
@@ -224,16 +224,16 @@ int core_tmr_lun_reset(
         spin_lock_irqsave(&dev->execute_task_lock, flags);
         list_for_each_entry_safe(task, task_tmp, &dev->state_task_list,
                                 t_state_list) {
-                if (!(TASK_CMD(task))) {
-                        printk(KERN_ERR "TASK_CMD(task) is NULL!\n");
+                if (!task->task_se_cmd) {
+                        printk(KERN_ERR "task->task_se_cmd is NULL!\n");
                         continue;
                 }
-                cmd = TASK_CMD(task);
+                cmd = task->task_se_cmd;
 
-                if (!T_TASK(cmd)) {
-                        printk(KERN_ERR "T_TASK(cmd) is NULL for task: %p cmd:"
+                if (!cmd->t_task) {
+                        printk(KERN_ERR "cmd->t_task is NULL for task: %p cmd:"
                                 " %p ITT: 0x%08x\n", task, cmd,
-                                CMD_TFO(cmd)->get_task_tag(cmd));
+                                cmd->se_tfo->get_task_tag(cmd));
                         continue;
                 }
                 /*
@@ -254,38 +254,38 @@ int core_tmr_lun_reset(
                 atomic_set(&task->task_state_active, 0);
                 spin_unlock_irqrestore(&dev->execute_task_lock, flags);
 
-                spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags);
+                spin_lock_irqsave(&cmd->t_task->t_state_lock, flags);
                 DEBUG_LR("LUN_RESET: %s cmd: %p task: %p"
                         " ITT/CmdSN: 0x%08x/0x%08x, i_state: %d, t_state/"
                         "def_t_state: %d/%d cdb: 0x%02x\n",
                         (preempt_and_abort_list) ? "Preempt" : "", cmd, task,
-                        CMD_TFO(cmd)->get_task_tag(cmd), 0,
-                        CMD_TFO(cmd)->get_cmd_state(cmd), cmd->t_state,
-                        cmd->deferred_t_state, T_TASK(cmd)->t_task_cdb[0]);
+                        cmd->se_tfo->get_task_tag(cmd), 0,
+                        cmd->se_tfo->get_cmd_state(cmd), cmd->t_state,
+                        cmd->deferred_t_state, cmd->t_task->t_task_cdb[0]);
                 DEBUG_LR("LUN_RESET: ITT[0x%08x] - pr_res_key: 0x%016Lx"
                         " t_task_cdbs: %d t_task_cdbs_left: %d"
                         " t_task_cdbs_sent: %d -- t_transport_active: %d"
                         " t_transport_stop: %d t_transport_sent: %d\n",
-                        CMD_TFO(cmd)->get_task_tag(cmd), cmd->pr_res_key,
-                        T_TASK(cmd)->t_task_cdbs,
-                        atomic_read(&T_TASK(cmd)->t_task_cdbs_left),
-                        atomic_read(&T_TASK(cmd)->t_task_cdbs_sent),
-                        atomic_read(&T_TASK(cmd)->t_transport_active),
-                        atomic_read(&T_TASK(cmd)->t_transport_stop),
-                        atomic_read(&T_TASK(cmd)->t_transport_sent));
+                        cmd->se_tfo->get_task_tag(cmd), cmd->pr_res_key,
+                        cmd->t_task->t_task_cdbs,
+                        atomic_read(&cmd->t_task->t_task_cdbs_left),
+                        atomic_read(&cmd->t_task->t_task_cdbs_sent),
+                        atomic_read(&cmd->t_task->t_transport_active),
+                        atomic_read(&cmd->t_task->t_transport_stop),
+                        atomic_read(&cmd->t_task->t_transport_sent));
 
                 if (atomic_read(&task->task_active)) {
                         atomic_set(&task->task_stop, 1);
                         spin_unlock_irqrestore(
-                                &T_TASK(cmd)->t_state_lock, flags);
+                                &cmd->t_task->t_state_lock, flags);
 
                         DEBUG_LR("LUN_RESET: Waiting for task: %p to shutdown"
                                 " for dev: %p\n", task, dev);
                         wait_for_completion(&task->task_stop_comp);
                         DEBUG_LR("LUN_RESET Completed task: %p shutdown for"
                                 " dev: %p\n", task, dev);
-                        spin_lock_irqsave(&T_TASK(cmd)->t_state_lock, flags);
-                        atomic_dec(&T_TASK(cmd)->t_task_cdbs_left);
+                        spin_lock_irqsave(&cmd->t_task->t_state_lock, flags);
+                        atomic_dec(&cmd->t_task->t_task_cdbs_left);
 
                         atomic_set(&task->task_active, 0);
                         atomic_set(&task->task_stop, 0);
@@ -295,24 +295,24 @@ int core_tmr_lun_reset(
                 }
                 __transport_stop_task_timer(task, &flags);
 
-                if (!(atomic_dec_and_test(&T_TASK(cmd)->t_task_cdbs_ex_left))) {
+                if (!(atomic_dec_and_test(&cmd->t_task->t_task_cdbs_ex_left))) {
                         spin_unlock_irqrestore(
-                                        &T_TASK(cmd)->t_state_lock, flags);
+                                        &cmd->t_task->t_state_lock, flags);
                         DEBUG_LR("LUN_RESET: Skipping task: %p, dev: %p for"
                                 " t_task_cdbs_ex_left: %d\n", task, dev,
-                                atomic_read(&T_TASK(cmd)->t_task_cdbs_ex_left));
+                                atomic_read(&cmd->t_task->t_task_cdbs_ex_left));
 
                         spin_lock_irqsave(&dev->execute_task_lock, flags);
                         continue;
                 }
-                fe_count = atomic_read(&T_TASK(cmd)->t_fe_count);
+                fe_count = atomic_read(&cmd->t_task->t_fe_count);
 
-                if (atomic_read(&T_TASK(cmd)->t_transport_active)) {
+                if (atomic_read(&cmd->t_task->t_transport_active)) {
                         DEBUG_LR("LUN_RESET: got t_transport_active = 1 for"
                                 " task: %p, t_fe_count: %d dev: %p\n", task,
                                 fe_count, dev);
-                        atomic_set(&T_TASK(cmd)->t_transport_aborted, 1);
-                        spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock,
+                        atomic_set(&cmd->t_task->t_transport_aborted, 1);
+                        spin_unlock_irqrestore(&cmd->t_task->t_state_lock,
                                                 flags);
                         core_tmr_handle_tas_abort(tmr_nacl, cmd, tas, fe_count);
 
@@ -321,8 +321,8 @@ int core_tmr_lun_reset(
                 }
                 DEBUG_LR("LUN_RESET: Got t_transport_active = 0 for task: %p,"
                         " t_fe_count: %d dev: %p\n", task, fe_count, dev);
-                atomic_set(&T_TASK(cmd)->t_transport_aborted, 1);
-                spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags);
+                atomic_set(&cmd->t_task->t_transport_aborted, 1);
+                spin_unlock_irqrestore(&cmd->t_task->t_state_lock, flags);
                 core_tmr_handle_tas_abort(tmr_nacl, cmd, tas, fe_count);
 
                 spin_lock_irqsave(&dev->execute_task_lock, flags);
@@ -365,7 +365,7 @@ int core_tmr_lun_reset(
                 if (prout_cmd == cmd)
                         continue;
 
-                atomic_dec(&T_TASK(cmd)->t_transport_queue_active);
+                atomic_dec(&cmd->t_task->t_transport_queue_active);
                 atomic_dec(&qobj->queue_cnt);
                 list_del(&qr->qr_list);
                 spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
@@ -376,7 +376,7 @@ int core_tmr_lun_reset(
                 DEBUG_LR("LUN_RESET: %s from Device Queue: cmd: %p t_state:"
                         " %d t_fe_count: %d\n", (preempt_and_abort_list) ?
                         "Preempt" : "", cmd, state,
-                        atomic_read(&T_TASK(cmd)->t_fe_count));
+                        atomic_read(&cmd->t_task->t_fe_count));
                 /*
                  * Signal that the command has failed via cmd->se_cmd_flags,
                  * and call TFO->new_cmd_failure() to wakeup any fabric
@@ -388,7 +388,7 @@ int core_tmr_lun_reset(
                 transport_new_cmd_failure(cmd);
 
                 core_tmr_handle_tas_abort(tmr_nacl, cmd, tas,
-                                atomic_read(&T_TASK(cmd)->t_fe_count));
+                                atomic_read(&cmd->t_task->t_fe_count));
                 spin_lock_irqsave(&qobj->cmd_queue_lock, flags);
         }
         spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
@@ -411,6 +411,6 @@ int core_tmr_lun_reset(
 
         DEBUG_LR("LUN_RESET: %s for [%s] Complete\n",
                         (preempt_and_abort_list) ? "Preempt" : "TMR",
-                        TRANSPORT(dev)->name);
+                        dev->transport->name);
         return 0;
 }