target: simplify alua support

We always support ALUA for virtual backends, and never for physical ones.  Simplify
the code to just deal with these two cases and remove the superflous abstractions.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>

6 files changed, 65 insertions, 153 deletions

diff --git a/drivers/target/target_core_alua.c b/drivers/target/target_core_alua.c
index 15c127b780d8..b3302a9200a2 100644
--- a/drivers/target/target_core_alua.c
+++ b/drivers/target/target_core_alua.c
@@ -522,40 +522,26 @@ static inline int core_alua_state_transition(
 }
 
 /*
- * Used for alua_type SPC_ALUA_PASSTHROUGH and SPC2_ALUA_DISABLED
- * in transport_cmd_sequencer().  This function is assigned to
- * struct t10_alua *->state_check() in core_setup_alua()
- */
-static int core_alua_state_check_nop(
-        struct se_cmd *cmd,
-        unsigned char *cdb,
-        u8 *alua_ascq)
-{
-        return 0;
-}
-
-/*
- * Used for alua_type SPC3_ALUA_EMULATED in transport_cmd_sequencer().
- * This function is assigned to struct t10_alua *->state_check() in
- * core_setup_alua()
- *
- * Also, this function can return three different return codes to
- * signal transport_generic_cmd_sequencer()
- *
  * return 1: Is used to signal LUN not accecsable, and check condition/not ready
  * return 0: Used to signal success
  * reutrn -1: Used to signal failure, and invalid cdb field
  */
-static int core_alua_state_check(
-        struct se_cmd *cmd,
-        unsigned char *cdb,
-        u8 *alua_ascq)
+int target_alua_state_check(struct se_cmd *cmd)
 {
+        struct se_device *dev = cmd->se_dev;
+        unsigned char *cdb = cmd->t_task_cdb;
         struct se_lun *lun = cmd->se_lun;
         struct se_port *port = lun->lun_sep;
         struct t10_alua_tg_pt_gp *tg_pt_gp;
         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
         int out_alua_state, nonop_delay_msecs;
+        u8 alua_ascq;
+        int ret;
+
+        if (dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE)
+                return 0;
+        if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV)
+                return 0;
 
         if (!port)
                 return 0;
@@ -564,11 +550,11 @@ static int core_alua_state_check(
          * access state: OFFLINE
          */
         if (atomic_read(&port->sep_tg_pt_secondary_offline)) {
-                *alua_ascq = ASCQ_04H_ALUA_OFFLINE;
                 pr_debug("ALUA: Got secondary offline status for local"
                                 " target port\n");
-                *alua_ascq = ASCQ_04H_ALUA_OFFLINE;
-                return 1;
+                alua_ascq = ASCQ_04H_ALUA_OFFLINE;
+                ret = 1;
+                goto out;
         }
          /*
          * Second, obtain the struct t10_alua_tg_pt_gp_member pointer to the
@@ -593,14 +579,18 @@ static int core_alua_state_check(
 
         switch (out_alua_state) {
         case ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED:
-                return core_alua_state_nonoptimized(cmd, cdb,
-                                        nonop_delay_msecs, alua_ascq);
+                ret = core_alua_state_nonoptimized(cmd, cdb,
+                                        nonop_delay_msecs, &alua_ascq);
+                break;
         case ALUA_ACCESS_STATE_STANDBY:
-                return core_alua_state_standby(cmd, cdb, alua_ascq);
+                ret = core_alua_state_standby(cmd, cdb, &alua_ascq);
+                break;
         case ALUA_ACCESS_STATE_UNAVAILABLE:
-                return core_alua_state_unavailable(cmd, cdb, alua_ascq);
+                ret = core_alua_state_unavailable(cmd, cdb, &alua_ascq);
+                break;
         case ALUA_ACCESS_STATE_TRANSITION:
-                return core_alua_state_transition(cmd, cdb, alua_ascq);
+                ret = core_alua_state_transition(cmd, cdb, &alua_ascq);
+                break;
         /*
          * OFFLINE is a secondary ALUA target port group access state, that is
          * handled above with struct se_port->sep_tg_pt_secondary_offline=1
@@ -609,10 +599,27 @@ static int core_alua_state_check(
         default:
                 pr_err("Unknown ALUA access state: 0x%02x\n",
                                 out_alua_state);
-                return -EINVAL;
+                ret = -EINVAL;
+                break;
         }
 
-        return 0;
+out:
+        if (ret > 0) {
+                /*
+                 * Set SCSI additional sense code (ASC) to 'LUN Not Accessible';
+                 * The ALUA additional sense code qualifier (ASCQ) is determined
+                 * by the ALUA primary or secondary access state..
+                 */
+                pr_debug("[%s]: ALUA TG Port not available, "
+                        "SenseKey: NOT_READY, ASC/ASCQ: "
+                        "0x04/0x%02x\n",
+                        cmd->se_tfo->get_fabric_name(), alua_ascq);
+
+                cmd->scsi_asc = 0x04;
+                cmd->scsi_ascq = alua_ascq;
+        }
+
+        return ret;
 }
 
 /*
@@ -1264,13 +1271,9 @@ void core_alua_free_lu_gp(struct t10_alua_lu_gp *lu_gp)
 
 void core_alua_free_lu_gp_mem(struct se_device *dev)
 {
-        struct t10_alua *alua = &dev->t10_alua;
         struct t10_alua_lu_gp *lu_gp;
         struct t10_alua_lu_gp_member *lu_gp_mem;
 
-        if (alua->alua_type != SPC3_ALUA_EMULATED)
-                return;
-
         lu_gp_mem = dev->dev_alua_lu_gp_mem;
         if (!lu_gp_mem)
                 return;
@@ -1538,13 +1541,9 @@ void core_alua_free_tg_pt_gp(
 
 void core_alua_free_tg_pt_gp_mem(struct se_port *port)
 {
-        struct t10_alua *alua = &port->sep_lun->lun_se_dev->t10_alua;
         struct t10_alua_tg_pt_gp *tg_pt_gp;
         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
 
-        if (alua->alua_type != SPC3_ALUA_EMULATED)
-                return;
-
         tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
         if (!tg_pt_gp_mem)
                 return;
@@ -1636,14 +1635,10 @@ static void __core_alua_drop_tg_pt_gp_mem(
 ssize_t core_alua_show_tg_pt_gp_info(struct se_port *port, char *page)
 {
         struct config_item *tg_pt_ci;
-        struct t10_alua *alua = &port->sep_lun->lun_se_dev->t10_alua;
         struct t10_alua_tg_pt_gp *tg_pt_gp;
         struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
         ssize_t len = 0;
 
-        if (alua->alua_type != SPC3_ALUA_EMULATED)
-                return len;
-
         tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
         if (!tg_pt_gp_mem)
                 return len;
@@ -1686,13 +1681,9 @@ ssize_t core_alua_store_tg_pt_gp_info(
         tpg = port->sep_tpg;
         lun = port->sep_lun;
 
-        if (dev->t10_alua.alua_type != SPC3_ALUA_EMULATED) {
-                pr_warn("SPC3_ALUA_EMULATED not enabled for"
-                        " %s/tpgt_%hu/%s\n", tpg->se_tpg_tfo->tpg_get_wwn(tpg),
-                        tpg->se_tpg_tfo->tpg_get_tag(tpg),
-                        config_item_name(&lun->lun_group.cg_item));
-                return -EINVAL;
-        }
+        tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
+        if (!tg_pt_gp_mem)
+                return 0;
 
         if (count > TG_PT_GROUP_NAME_BUF) {
                 pr_err("ALUA Target Port Group alias too large!\n");
@@ -1715,13 +1706,6 @@ ssize_t core_alua_store_tg_pt_gp_info(
                 if (!tg_pt_gp_new)
                         return -ENODEV;
         }
-        tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
-        if (!tg_pt_gp_mem) {
-                if (tg_pt_gp_new)
-                        core_alua_put_tg_pt_gp_from_name(tg_pt_gp_new);
-                pr_err("NULL struct se_port->sep_alua_tg_pt_gp_mem pointer\n");
-                return -EINVAL;
-        }
 
         spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
         tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
@@ -2050,26 +2034,9 @@ ssize_t core_alua_store_secondary_write_metadata(
 
 int core_setup_alua(struct se_device *dev)
 {
-        struct t10_alua *alua = &dev->t10_alua;
-        struct t10_alua_lu_gp_member *lu_gp_mem;
-
-        /*
-         * If this device is from Target_Core_Mod/pSCSI, use the ALUA logic
-         * of the Underlying SCSI hardware.  In Linux/SCSI terms, this can
-         * cause a problem because libata and some SATA RAID HBAs appear
-         * under Linux/SCSI, but emulate SCSI logic themselves.
-         */
-        if ((dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE) ||
-            (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV &&
-             !dev->dev_attrib.emulate_alua)) {
-                pr_debug("%s: Using SPC_ALUA_PASSTHROUGH, no ALUA"
-                        " emulation\n", dev->transport->name);
-
-                alua->alua_type = SPC_ALUA_PASSTHROUGH;
-                alua->alua_state_check = &core_alua_state_check_nop;
-        } else if (dev->transport->get_device_rev(dev) >= SCSI_3) {
-                pr_debug("%s: Enabling ALUA Emulation for SPC-3"
-                        " device\n", dev->transport->name);
+        if (dev->transport->transport_type != TRANSPORT_PLUGIN_PHBA_PDEV &&
+            !(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE)) {
+                struct t10_alua_lu_gp_member *lu_gp_mem;
 
                 /*
                  * Associate this struct se_device with the default ALUA
@@ -2079,8 +2046,6 @@ int core_setup_alua(struct se_device *dev)
                 if (IS_ERR(lu_gp_mem))
                         return PTR_ERR(lu_gp_mem);
 
-                alua->alua_type = SPC3_ALUA_EMULATED;
-                alua->alua_state_check = &core_alua_state_check;
                 spin_lock(&lu_gp_mem->lu_gp_mem_lock);
                 __core_alua_attach_lu_gp_mem(lu_gp_mem,
                                 default_lu_gp);
@@ -2089,12 +2054,6 @@ int core_setup_alua(struct se_device *dev)
                 pr_debug("%s: Adding to default ALUA LU Group:"
                         " core/alua/lu_gps/default_lu_gp\n",
                         dev->transport->name);
-        } else {
-                pr_debug("%s: Disabling ALUA Emulation for SPC-2"
-                        " device\n", dev->transport->name);
-
-                alua->alua_type = SPC2_ALUA_DISABLED;
-                alua->alua_state_check = &core_alua_state_check_nop;
         }
 
         return 0;
diff --git a/drivers/target/target_core_alua.h b/drivers/target/target_core_alua.h
index 5019157ffe69..a2af8aa15b98 100644
--- a/drivers/target/target_core_alua.h
+++ b/drivers/target/target_core_alua.h
@@ -132,5 +132,6 @@ extern ssize_t core_alua_show_secondary_write_metadata(struct se_lun *,
 extern ssize_t core_alua_store_secondary_write_metadata(struct se_lun *,
                                         const char *, size_t);
 extern int core_setup_alua(struct se_device *);
+extern int target_alua_state_check(struct se_cmd *cmd);
 
 #endif /* TARGET_CORE_ALUA_H */
diff --git a/drivers/target/target_core_configfs.c b/drivers/target/target_core_configfs.c
index 3d5570da41eb..7b473b66da7b 100644
--- a/drivers/target/target_core_configfs.c
+++ b/drivers/target/target_core_configfs.c
@@ -1615,15 +1615,9 @@ static ssize_t target_core_show_alua_lu_gp(void *p, char *page)
         struct t10_alua_lu_gp_member *lu_gp_mem;
         ssize_t len = 0;
 
-        if (dev->t10_alua.alua_type != SPC3_ALUA_EMULATED)
-                return len;
-
         lu_gp_mem = dev->dev_alua_lu_gp_mem;
-        if (!lu_gp_mem) {
-                pr_err("NULL struct se_device->dev_alua_lu_gp_mem"
-                                " pointer\n");
-                return -EINVAL;
-        }
+        if (!lu_gp_mem)
+                return 0;
 
         spin_lock(&lu_gp_mem->lu_gp_mem_lock);
         lu_gp = lu_gp_mem->lu_gp;
@@ -1649,12 +1643,10 @@ static ssize_t target_core_store_alua_lu_gp(
         unsigned char buf[LU_GROUP_NAME_BUF];
         int move = 0;
 
-        if (dev->t10_alua.alua_type != SPC3_ALUA_EMULATED) {
-                pr_warn("SPC3_ALUA_EMULATED not enabled for %s/%s\n",
-                        config_item_name(&hba->hba_group.cg_item),
-                        config_item_name(&dev->dev_group.cg_item));
-                return -EINVAL;
-        }
+        lu_gp_mem = dev->dev_alua_lu_gp_mem;
+        if (!lu_gp_mem)
+                return 0;
+
         if (count > LU_GROUP_NAME_BUF) {
                 pr_err("ALUA LU Group Alias too large!\n");
                 return -EINVAL;
@@ -1675,14 +1667,6 @@ static ssize_t target_core_store_alua_lu_gp(
                 if (!lu_gp_new)
                         return -ENODEV;
         }
-        lu_gp_mem = dev->dev_alua_lu_gp_mem;
-        if (!lu_gp_mem) {
-                if (lu_gp_new)
-                        core_alua_put_lu_gp_from_name(lu_gp_new);
-                pr_err("NULL struct se_device->dev_alua_lu_gp_mem"
-                                " pointer\n");
-                return -EINVAL;
-        }
 
         spin_lock(&lu_gp_mem->lu_gp_mem_lock);
         lu_gp = lu_gp_mem->lu_gp;
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index 4ae1d3913821..3c3a3019ce7b 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -556,7 +556,8 @@ static void core_export_port(
         list_add_tail(&port->sep_list, &dev->dev_sep_list);
         spin_unlock(&dev->se_port_lock);
 
-        if (dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) {
+        if (dev->transport->transport_type != TRANSPORT_PLUGIN_PHBA_PDEV &&
+            !(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE)) {
                 tg_pt_gp_mem = core_alua_allocate_tg_pt_gp_mem(port);
                 if (IS_ERR(tg_pt_gp_mem) || !tg_pt_gp_mem) {
                         pr_err("Unable to allocate t10_alua_tg_pt"
@@ -1398,7 +1399,6 @@ struct se_device *target_alloc_device(struct se_hba *hba, const char *name)
         dev->dev_attrib.emulate_tas = DA_EMULATE_TAS;
         dev->dev_attrib.emulate_tpu = DA_EMULATE_TPU;
         dev->dev_attrib.emulate_tpws = DA_EMULATE_TPWS;
-        dev->dev_attrib.emulate_alua = DA_EMULATE_ALUA;
         dev->dev_attrib.enforce_pr_isids = DA_ENFORCE_PR_ISIDS;
         dev->dev_attrib.is_nonrot = DA_IS_NONROT;
         dev->dev_attrib.emulate_rest_reord = DA_EMULATE_REST_REORD;
diff --git a/drivers/target/target_core_spc.c b/drivers/target/target_core_spc.c
index 862e4347f68f..7ecac453b11a 100644
--- a/drivers/target/target_core_spc.c
+++ b/drivers/target/target_core_spc.c
@@ -95,8 +95,7 @@ static int spc_emulate_inquiry_std(struct se_cmd *cmd, char *buf)
         /*
          * Enable SCCS and TPGS fields for Emulated ALUA
          */
-        if (dev->t10_alua.alua_type == SPC3_ALUA_EMULATED)
-                spc_fill_alua_data(lun->lun_sep, buf);
+        spc_fill_alua_data(lun->lun_sep, buf);
 
         buf[7] = 0x2; /* CmdQue=1 */
 
@@ -294,9 +293,6 @@ check_t10_vend_desc:
                  * Get the PROTOCOL IDENTIFIER as defined by spc4r17
                  * section 7.5.1 Table 362
                  */
-                if (dev->t10_alua.alua_type != SPC3_ALUA_EMULATED)
-                        goto check_scsi_name;
-
                 tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
                 if (!tg_pt_gp_mem)
                         goto check_lu_gp;
@@ -1083,8 +1079,7 @@ int spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
                          * MAINTENANCE_IN from SCC-2
                          * Check for emulated MI_REPORT_TARGET_PGS
                          */
-                        if ((cdb[1] & 0x1f) == MI_REPORT_TARGET_PGS &&
-                            dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) {
+                        if ((cdb[1] & 0x1f) == MI_REPORT_TARGET_PGS) {
                                 cmd->execute_cmd =
                                         target_emulate_report_target_port_groups;
                         }
@@ -1102,8 +1097,7 @@ int spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
                          * MAINTENANCE_OUT from SCC-2
                          * Check for emulated MO_SET_TARGET_PGS.
                          */
-                        if (cdb[1] == MO_SET_TARGET_PGS &&
-                            dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) {
+                        if (cdb[1] == MO_SET_TARGET_PGS) {
                                 cmd->execute_cmd =
                                         target_emulate_set_target_port_groups;
                         }
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index e996bdf480cf..c4c931b525d2 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -70,7 +70,6 @@ static void transport_handle_queue_full(struct se_cmd *cmd,
 static int transport_generic_get_mem(struct se_cmd *cmd);
 static int target_get_sess_cmd(struct se_session *, struct se_cmd *, bool);
 static void transport_put_cmd(struct se_cmd *cmd);
-static int transport_set_sense_codes(struct se_cmd *cmd, u8 asc, u8 ascq);
 static void target_complete_ok_work(struct work_struct *work);
 
 int init_se_kmem_caches(void)
@@ -1103,7 +1102,6 @@ int target_setup_cmd_from_cdb(
         unsigned char *cdb)
 {
         struct se_device *dev = cmd->se_dev;
-        u8 alua_ascq = 0;
         unsigned long flags;
         int ret;
 
@@ -1153,26 +1151,13 @@ int target_setup_cmd_from_cdb(
                 return -EINVAL;
         }
 
-        ret = dev->t10_alua.alua_state_check(cmd, cdb, &alua_ascq);
-        if (ret != 0) {
-                /*
-                 * Set SCSI additional sense code (ASC) to 'LUN Not Accessible';
-                 * The ALUA additional sense code qualifier (ASCQ) is determined
-                 * by the ALUA primary or secondary access state..
-                 */
-                if (ret > 0) {
-                        pr_debug("[%s]: ALUA TG Port not available, "
-                                "SenseKey: NOT_READY, ASC/ASCQ: "
-                                "0x04/0x%02x\n",
-                                cmd->se_tfo->get_fabric_name(), alua_ascq);
-
-                        transport_set_sense_codes(cmd, 0x04, alua_ascq);
-                        cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
-                        cmd->scsi_sense_reason = TCM_CHECK_CONDITION_NOT_READY;
-                        return -EINVAL;
-                }
+        ret = target_alua_state_check(cmd);
+        if (ret) {
                 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
-                cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD;
+                if (ret > 0)
+                        cmd->scsi_sense_reason = TCM_CHECK_CONDITION_NOT_READY;
+                else
+                        cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD;
                 return -EINVAL;
         }
 
@@ -2640,17 +2625,6 @@ static int transport_get_sense_codes(
         return 0;
 }
 
-static int transport_set_sense_codes(
-        struct se_cmd *cmd,
-        u8 asc,
-        u8 ascq)
-{
-        cmd->scsi_asc = asc;
-        cmd->scsi_ascq = ascq;
-
-        return 0;
-}
-
 int transport_send_check_condition_and_sense(
         struct se_cmd *cmd,
         u8 reason,