68 files changed, 3163 insertions, 6312 deletions

diff --git a/Documentation/target/tcm_mod_builder.py b/Documentation/target/tcm_mod_builder.py
index 6085e1f19c9d..949de191fcdc 100755
--- a/Documentation/target/tcm_mod_builder.py
+++ b/Documentation/target/tcm_mod_builder.py
@@ -50,15 +50,6 @@ def tcm_mod_build_FC_include(fabric_mod_dir_var, fabric_mod_name):
         buf = "#define " + fabric_mod_name.upper() + "_VERSION  \"v0.1\"\n"
         buf += "#define " + fabric_mod_name.upper() + "_NAMELEN 32\n"
         buf += "\n"
-        buf += "struct " + fabric_mod_name + "_nacl {\n"
-        buf += "        /* Binary World Wide unique Port Name for FC Initiator Nport */\n"
-        buf += "        u64 nport_wwpn;\n"
-        buf += "        /* ASCII formatted WWPN for FC Initiator Nport */\n"
-        buf += "        char nport_name[" + fabric_mod_name.upper() + "_NAMELEN];\n"
-        buf += "        /* Returned by " + fabric_mod_name + "_make_nodeacl() */\n"
-        buf += "        struct se_node_acl se_node_acl;\n"
-        buf += "};\n"
-        buf += "\n"
         buf += "struct " + fabric_mod_name + "_tpg {\n"
         buf += "        /* FC lport target portal group tag for TCM */\n"
         buf += "        u16 lport_tpgt;\n"
@@ -69,8 +60,6 @@ def tcm_mod_build_FC_include(fabric_mod_dir_var, fabric_mod_name):
         buf += "};\n"
         buf += "\n"
         buf += "struct " + fabric_mod_name + "_lport {\n"
-        buf += "        /* SCSI protocol the lport is providing */\n"
-        buf += "        u8 lport_proto_id;\n"
         buf += "        /* Binary World Wide unique Port Name for FC Target Lport */\n"
         buf += "        u64 lport_wwpn;\n"
         buf += "        /* ASCII formatted WWPN for FC Target Lport */\n"
@@ -105,14 +94,6 @@ def tcm_mod_build_SAS_include(fabric_mod_dir_var, fabric_mod_name):
         buf = "#define " + fabric_mod_name.upper() + "_VERSION  \"v0.1\"\n"
         buf += "#define " + fabric_mod_name.upper() + "_NAMELEN 32\n"
         buf += "\n"
-        buf += "struct " + fabric_mod_name + "_nacl {\n"
-        buf += "        /* Binary World Wide unique Port Name for SAS Initiator port */\n"
-        buf += "        u64 iport_wwpn;\n"
-        buf += "        /* ASCII formatted WWPN for Sas Initiator port */\n"
-        buf += "        char iport_name[" + fabric_mod_name.upper() + "_NAMELEN];\n"
-        buf += "        /* Returned by " + fabric_mod_name + "_make_nodeacl() */\n"
-        buf += "        struct se_node_acl se_node_acl;\n"
-        buf += "};\n\n"
         buf += "struct " + fabric_mod_name + "_tpg {\n"
         buf += "        /* SAS port target portal group tag for TCM */\n"
         buf += "        u16 tport_tpgt;\n"
@@ -122,8 +103,6 @@ def tcm_mod_build_SAS_include(fabric_mod_dir_var, fabric_mod_name):
         buf += "        struct se_portal_group se_tpg;\n"
         buf += "};\n\n"
         buf += "struct " + fabric_mod_name + "_tport {\n"
-        buf += "        /* SCSI protocol the tport is providing */\n"
-        buf += "        u8 tport_proto_id;\n"
         buf += "        /* Binary World Wide unique Port Name for SAS Target port */\n"
         buf += "        u64 tport_wwpn;\n"
         buf += "        /* ASCII formatted WWPN for SAS Target port */\n"
@@ -158,12 +137,6 @@ def tcm_mod_build_iSCSI_include(fabric_mod_dir_var, fabric_mod_name):
         buf = "#define " + fabric_mod_name.upper() + "_VERSION  \"v0.1\"\n"
         buf += "#define " + fabric_mod_name.upper() + "_NAMELEN 32\n"
         buf += "\n"
-        buf += "struct " + fabric_mod_name + "_nacl {\n"
-        buf += "        /* ASCII formatted InitiatorName */\n"
-        buf += "        char iport_name[" + fabric_mod_name.upper() + "_NAMELEN];\n"
-        buf += "        /* Returned by " + fabric_mod_name + "_make_nodeacl() */\n"
-        buf += "        struct se_node_acl se_node_acl;\n"
-        buf += "};\n\n"
         buf += "struct " + fabric_mod_name + "_tpg {\n"
         buf += "        /* iSCSI target portal group tag for TCM */\n"
         buf += "        u16 tport_tpgt;\n"
@@ -173,8 +146,6 @@ def tcm_mod_build_iSCSI_include(fabric_mod_dir_var, fabric_mod_name):
         buf += "        struct se_portal_group se_tpg;\n"
         buf += "};\n\n"
         buf += "struct " + fabric_mod_name + "_tport {\n"
-        buf += "        /* SCSI protocol the tport is providing */\n"
-        buf += "        u8 tport_proto_id;\n"
         buf += "        /* ASCII formatted TargetName for IQN */\n"
         buf += "        char tport_name[" + fabric_mod_name.upper() + "_NAMELEN];\n"
         buf += "        /* Returned by " + fabric_mod_name + "_make_tport() */\n"
@@ -232,61 +203,12 @@ def tcm_mod_build_configfs(proto_ident, fabric_mod_dir_var, fabric_mod_name):
         buf += "#include <target/target_core_base.h>\n"
         buf += "#include <target/target_core_fabric.h>\n"
         buf += "#include <target/target_core_fabric_configfs.h>\n"
-        buf += "#include <target/target_core_configfs.h>\n"
         buf += "#include <target/configfs_macros.h>\n\n"
         buf += "#include \"" + fabric_mod_name + "_base.h\"\n"
         buf += "#include \"" + fabric_mod_name + "_fabric.h\"\n\n"
 
         buf += "static const struct target_core_fabric_ops " + fabric_mod_name + "_ops;\n\n"
 
-        buf += "static struct se_node_acl *" + fabric_mod_name + "_make_nodeacl(\n"
-        buf += "        struct se_portal_group *se_tpg,\n"
-        buf += "        struct config_group *group,\n"
-        buf += "        const char *name)\n"
-        buf += "{\n"
-        buf += "        struct se_node_acl *se_nacl, *se_nacl_new;\n"
-        buf += "        struct " + fabric_mod_name + "_nacl *nacl;\n"
-
-        if proto_ident == "FC" or proto_ident == "SAS":
-                buf += "        u64 wwpn = 0;\n"
-
-        buf += "        u32 nexus_depth;\n\n"
-        buf += "        /* " + fabric_mod_name + "_parse_wwn(name, &wwpn, 1) < 0)\n"
-        buf += "                return ERR_PTR(-EINVAL); */\n"
-        buf += "        se_nacl_new = " + fabric_mod_name + "_alloc_fabric_acl(se_tpg);\n"
-        buf += "        if (!se_nacl_new)\n"
-        buf += "                return ERR_PTR(-ENOMEM);\n"
-        buf += "//#warning FIXME: Hardcoded nexus depth in " + fabric_mod_name + "_make_nodeacl()\n"
-        buf += "        nexus_depth = 1;\n"
-        buf += "        /*\n"
-        buf += "         * se_nacl_new may be released by core_tpg_add_initiator_node_acl()\n"
-        buf += "         * when converting a NodeACL from demo mode -> explict\n"
-        buf += "         */\n"
-        buf += "        se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new,\n"
-        buf += "                                name, nexus_depth);\n"
-        buf += "        if (IS_ERR(se_nacl)) {\n"
-        buf += "                " + fabric_mod_name + "_release_fabric_acl(se_tpg, se_nacl_new);\n"
-        buf += "                return se_nacl;\n"
-        buf += "        }\n"
-        buf += "        /*\n"
-        buf += "         * Locate our struct " + fabric_mod_name + "_nacl and set the FC Nport WWPN\n"
-        buf += "         */\n"
-        buf += "        nacl = container_of(se_nacl, struct " + fabric_mod_name + "_nacl, se_node_acl);\n"
-
-        if proto_ident == "FC" or proto_ident == "SAS":
-                buf += "        nacl->" + fabric_mod_init_port + "_wwpn = wwpn;\n"
-
-        buf += "        /* " + fabric_mod_name + "_format_wwn(&nacl->" + fabric_mod_init_port + "_name[0], " + fabric_mod_name.upper() + "_NAMELEN, wwpn); */\n\n"
-        buf += "        return se_nacl;\n"
-        buf += "}\n\n"
-        buf += "static void " + fabric_mod_name + "_drop_nodeacl(struct se_node_acl *se_acl)\n"
-        buf += "{\n"
-        buf += "        struct " + fabric_mod_name + "_nacl *nacl = container_of(se_acl,\n"
-        buf += "                                struct " + fabric_mod_name + "_nacl, se_node_acl);\n"
-        buf += "        core_tpg_del_initiator_node_acl(se_acl->se_tpg, se_acl, 1);\n"
-        buf += "        kfree(nacl);\n"
-        buf += "}\n\n"
-
         buf += "static struct se_portal_group *" + fabric_mod_name + "_make_tpg(\n"
         buf += "        struct se_wwn *wwn,\n"
         buf += "        struct config_group *group,\n"
@@ -309,8 +231,7 @@ def tcm_mod_build_configfs(proto_ident, fabric_mod_dir_var, fabric_mod_name):
         buf += "        tpg->" + fabric_mod_port + " = " + fabric_mod_port + ";\n"
         buf += "        tpg->" + fabric_mod_port + "_tpgt = tpgt;\n\n"
         buf += "        ret = core_tpg_register(&" + fabric_mod_name + "_ops, wwn,\n"
-        buf += "                                &tpg->se_tpg, tpg,\n"
-        buf += "                                TRANSPORT_TPG_TYPE_NORMAL);\n"
+        buf += "                                &tpg->se_tpg, SCSI_PROTOCOL_SAS);\n"
         buf += "        if (ret < 0) {\n"
         buf += "                kfree(tpg);\n"
         buf += "                return NULL;\n"
@@ -372,21 +293,13 @@ def tcm_mod_build_configfs(proto_ident, fabric_mod_dir_var, fabric_mod_name):
         buf += "static const struct target_core_fabric_ops " + fabric_mod_name + "_ops = {\n"
         buf += "        .module                         = THIS_MODULE,\n"
         buf += "        .name                           = " + fabric_mod_name + ",\n"
-        buf += "        .get_fabric_proto_ident         = " + fabric_mod_name + "_get_fabric_proto_ident,\n"
         buf += "        .get_fabric_name                = " + fabric_mod_name + "_get_fabric_name,\n"
-        buf += "        .get_fabric_proto_ident         = " + fabric_mod_name + "_get_fabric_proto_ident,\n"
         buf += "        .tpg_get_wwn                    = " + fabric_mod_name + "_get_fabric_wwn,\n"
         buf += "        .tpg_get_tag                    = " + fabric_mod_name + "_get_tag,\n"
-        buf += "        .tpg_get_default_depth          = " + fabric_mod_name + "_get_default_depth,\n"
-        buf += "        .tpg_get_pr_transport_id        = " + fabric_mod_name + "_get_pr_transport_id,\n"
-        buf += "        .tpg_get_pr_transport_id_len    = " + fabric_mod_name + "_get_pr_transport_id_len,\n"
-        buf += "        .tpg_parse_pr_out_transport_id  = " + fabric_mod_name + "_parse_pr_out_transport_id,\n"
         buf += "        .tpg_check_demo_mode            = " + fabric_mod_name + "_check_false,\n"
         buf += "        .tpg_check_demo_mode_cache      = " + fabric_mod_name + "_check_true,\n"
         buf += "        .tpg_check_demo_mode_write_protect = " + fabric_mod_name + "_check_true,\n"
         buf += "        .tpg_check_prod_mode_write_protect = " + fabric_mod_name + "_check_false,\n"
-        buf += "        .tpg_alloc_fabric_acl           = " + fabric_mod_name + "_alloc_fabric_acl,\n"
-        buf += "        .tpg_release_fabric_acl         = " + fabric_mod_name + "_release_fabric_acl,\n"
         buf += "        .tpg_get_inst_index             = " + fabric_mod_name + "_tpg_get_inst_index,\n"
         buf += "        .release_cmd                    = " + fabric_mod_name + "_release_cmd,\n"
         buf += "        .shutdown_session               = " + fabric_mod_name + "_shutdown_session,\n"
@@ -396,7 +309,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"
@@ -409,12 +321,6 @@ def tcm_mod_build_configfs(proto_ident, fabric_mod_dir_var, fabric_mod_name):
         buf += "        .fabric_drop_wwn                = " + fabric_mod_name + "_drop_" + fabric_mod_port + ",\n"
         buf += "        .fabric_make_tpg                = " + fabric_mod_name + "_make_tpg,\n"
         buf += "        .fabric_drop_tpg                = " + fabric_mod_name + "_drop_tpg,\n"
-        buf += "        .fabric_post_link               = NULL,\n"
-        buf += "        .fabric_pre_unlink              = NULL,\n"
-        buf += "        .fabric_make_np                 = NULL,\n"
-        buf += "        .fabric_drop_np                 = NULL,\n"
-        buf += "        .fabric_make_nodeacl            = " + fabric_mod_name + "_make_nodeacl,\n"
-        buf += "        .fabric_drop_nodeacl            = " + fabric_mod_name + "_drop_nodeacl,\n"
         buf += "\n"
         buf += "        .tfc_wwn_attrs                  = " + fabric_mod_name + "_wwn_attrs;\n"
         buf += "};\n\n"
@@ -507,7 +413,6 @@ def tcm_mod_dump_fabric_ops(proto_ident, fabric_mod_dir_var, fabric_mod_name):
         buf += "#include <scsi/scsi_proto.h>\n"
         buf += "#include <target/target_core_base.h>\n"
         buf += "#include <target/target_core_fabric.h>\n"
-        buf += "#include <target/target_core_configfs.h>\n\n"
         buf += "#include \"" + fabric_mod_name + "_base.h\"\n"
         buf += "#include \"" + fabric_mod_name + "_fabric.h\"\n\n"
 
@@ -539,35 +444,6 @@ def tcm_mod_dump_fabric_ops(proto_ident, fabric_mod_dir_var, fabric_mod_name):
                         bufi += "char *" + fabric_mod_name + "_get_fabric_name(void);\n"
                         continue
 
-                if re.search('get_fabric_proto_ident', fo):
-                        buf += "u8 " + fabric_mod_name + "_get_fabric_proto_ident(struct se_portal_group *se_tpg)\n"
-                        buf += "{\n"
-                        buf += "        struct " + fabric_mod_name + "_tpg *tpg = container_of(se_tpg,\n"
-                        buf += "                                struct " + fabric_mod_name + "_tpg, se_tpg);\n"
-                        buf += "        struct " + fabric_mod_name + "_" + fabric_mod_port + " *" + fabric_mod_port + " = tpg->" + fabric_mod_port + ";\n"
-                        buf += "        u8 proto_id;\n\n"
-                        buf += "        switch (" + fabric_mod_port + "->" + fabric_mod_port + "_proto_id) {\n"
-                        if proto_ident == "FC":
-                                buf += "        case SCSI_PROTOCOL_FCP:\n"
-                                buf += "        default:\n"
-                                buf += "                proto_id = fc_get_fabric_proto_ident(se_tpg);\n"
-                                buf += "                break;\n"
-                        elif proto_ident == "SAS":
-                                buf += "        case SCSI_PROTOCOL_SAS:\n"
-                                buf += "        default:\n"
-                                buf += "                proto_id = sas_get_fabric_proto_ident(se_tpg);\n"
-                                buf += "                break;\n"
-                        elif proto_ident == "iSCSI":
-                                buf += "        case SCSI_PROTOCOL_ISCSI:\n"
-                                buf += "        default:\n"
-                                buf += "                proto_id = iscsi_get_fabric_proto_ident(se_tpg);\n"
-                                buf += "                break;\n"
-
-                        buf += "        }\n\n"
-                        buf += "        return proto_id;\n"
-                        buf += "}\n\n"
-                        bufi += "u8 " + fabric_mod_name + "_get_fabric_proto_ident(struct se_portal_group *);\n"
-
                 if re.search('get_wwn', fo):
                         buf += "char *" + fabric_mod_name + "_get_fabric_wwn(struct se_portal_group *se_tpg)\n"
                         buf += "{\n"
@@ -587,150 +463,6 @@ def tcm_mod_dump_fabric_ops(proto_ident, fabric_mod_dir_var, fabric_mod_name):
                         buf += "}\n\n"
                         bufi += "u16 " + fabric_mod_name + "_get_tag(struct se_portal_group *);\n"
 
-                if re.search('get_default_depth', fo):
-                        buf += "u32 " + fabric_mod_name + "_get_default_depth(struct se_portal_group *se_tpg)\n"
-                        buf += "{\n"
-                        buf += "        return 1;\n"
-                        buf += "}\n\n"
-                        bufi += "u32 " + fabric_mod_name + "_get_default_depth(struct se_portal_group *);\n"
-
-                if re.search('get_pr_transport_id\)\(', fo):
-                        buf += "u32 " + fabric_mod_name + "_get_pr_transport_id(\n"
-                        buf += "        struct se_portal_group *se_tpg,\n"
-                        buf += "        struct se_node_acl *se_nacl,\n"
-                        buf += "        struct t10_pr_registration *pr_reg,\n"
-                        buf += "        int *format_code,\n"
-                        buf += "        unsigned char *buf)\n"
-                        buf += "{\n"
-                        buf += "        struct " + fabric_mod_name + "_tpg *tpg = container_of(se_tpg,\n"
-                        buf += "                                struct " + fabric_mod_name + "_tpg, se_tpg);\n"
-                        buf += "        struct " + fabric_mod_name + "_" + fabric_mod_port + " *" + fabric_mod_port + " = tpg->" + fabric_mod_port + ";\n"
-                        buf += "        int ret = 0;\n\n"
-                        buf += "        switch (" + fabric_mod_port + "->" + fabric_mod_port + "_proto_id) {\n"
-                        if proto_ident == "FC":
-                                buf += "        case SCSI_PROTOCOL_FCP:\n"
-                                buf += "        default:\n"
-                                buf += "                ret = fc_get_pr_transport_id(se_tpg, se_nacl, pr_reg,\n"
-                                buf += "                                        format_code, buf);\n"
-                                buf += "                break;\n"
-                        elif proto_ident == "SAS":
-                                buf += "        case SCSI_PROTOCOL_SAS:\n"
-                                buf += "        default:\n"
-                                buf += "                ret = sas_get_pr_transport_id(se_tpg, se_nacl, pr_reg,\n"
-                                buf += "                                        format_code, buf);\n"
-                                buf += "                break;\n"
-                        elif proto_ident == "iSCSI":
-                                buf += "        case SCSI_PROTOCOL_ISCSI:\n"
-                                buf += "        default:\n"
-                                buf += "                ret = iscsi_get_pr_transport_id(se_tpg, se_nacl, pr_reg,\n"
-                                buf += "                                        format_code, buf);\n"
-                                buf += "                break;\n"
-
-                        buf += "        }\n\n"
-                        buf += "        return ret;\n"
-                        buf += "}\n\n"
-                        bufi += "u32 " + fabric_mod_name + "_get_pr_transport_id(struct se_portal_group *,\n"
-                        bufi += "                       struct se_node_acl *, struct t10_pr_registration *,\n"
-                        bufi += "                       int *, unsigned char *);\n"
-
-                if re.search('get_pr_transport_id_len\)\(', fo):
-                        buf += "u32 " + fabric_mod_name + "_get_pr_transport_id_len(\n"
-                        buf += "        struct se_portal_group *se_tpg,\n"
-                        buf += "        struct se_node_acl *se_nacl,\n"
-                        buf += "        struct t10_pr_registration *pr_reg,\n"
-                        buf += "        int *format_code)\n"
-                        buf += "{\n"
-                        buf += "        struct " + fabric_mod_name + "_tpg *tpg = container_of(se_tpg,\n"
-                        buf += "                                struct " + fabric_mod_name + "_tpg, se_tpg);\n"
-                        buf += "        struct " + fabric_mod_name + "_" + fabric_mod_port + " *" + fabric_mod_port + " = tpg->" + fabric_mod_port + ";\n"
-                        buf += "        int ret = 0;\n\n"
-                        buf += "        switch (" + fabric_mod_port + "->" + fabric_mod_port + "_proto_id) {\n"
-                        if proto_ident == "FC":
-                                buf += "        case SCSI_PROTOCOL_FCP:\n"
-                                buf += "        default:\n"
-                                buf += "                ret = fc_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,\n"
-                                buf += "                                        format_code);\n"
-                                buf += "                break;\n"
-                        elif proto_ident == "SAS":
-                                buf += "        case SCSI_PROTOCOL_SAS:\n"
-                                buf += "        default:\n"
-                                buf += "                ret = sas_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,\n"
-                                buf += "                                        format_code);\n"
-                                buf += "                break;\n"
-                        elif proto_ident == "iSCSI":
-                                buf += "        case SCSI_PROTOCOL_ISCSI:\n"
-                                buf += "        default:\n"
-                                buf += "                ret = iscsi_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,\n"
-                                buf += "                                        format_code);\n"
-                                buf += "                break;\n"
-
-
-                        buf += "        }\n\n"
-                        buf += "        return ret;\n"
-                        buf += "}\n\n"
-                        bufi += "u32 " + fabric_mod_name + "_get_pr_transport_id_len(struct se_portal_group *,\n"
-                        bufi += "                       struct se_node_acl *, struct t10_pr_registration *,\n"
-                        bufi += "                       int *);\n"
-
-                if re.search('parse_pr_out_transport_id\)\(', fo):
-                        buf += "char *" + fabric_mod_name + "_parse_pr_out_transport_id(\n"
-                        buf += "        struct se_portal_group *se_tpg,\n"
-                        buf += "        const char *buf,\n"
-                        buf += "        u32 *out_tid_len,\n"
-                        buf += "        char **port_nexus_ptr)\n"
-                        buf += "{\n"
-                        buf += "        struct " + fabric_mod_name + "_tpg *tpg = container_of(se_tpg,\n"
-                        buf += "                                struct " + fabric_mod_name + "_tpg, se_tpg);\n"
-                        buf += "        struct " + fabric_mod_name + "_" + fabric_mod_port + " *" + fabric_mod_port + " = tpg->" + fabric_mod_port + ";\n"
-                        buf += "        char *tid = NULL;\n\n"
-                        buf += "        switch (" + fabric_mod_port + "->" + fabric_mod_port + "_proto_id) {\n"
-                        if proto_ident == "FC":
-                                buf += "        case SCSI_PROTOCOL_FCP:\n"
-                                buf += "        default:\n"
-                                buf += "                tid = fc_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,\n"
-                                buf += "                                        port_nexus_ptr);\n"
-                        elif proto_ident == "SAS":
-                                buf += "        case SCSI_PROTOCOL_SAS:\n"
-                                buf += "        default:\n"
-                                buf += "                tid = sas_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,\n"
-                                buf += "                                        port_nexus_ptr);\n"
-                        elif proto_ident == "iSCSI":
-                                buf += "        case SCSI_PROTOCOL_ISCSI:\n"
-                                buf += "        default:\n"
-                                buf += "                tid = iscsi_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,\n"
-                                buf += "                                        port_nexus_ptr);\n"
-
-                        buf += "        }\n\n"
-                        buf += "        return tid;\n"
-                        buf += "}\n\n"
-                        bufi += "char *" + fabric_mod_name + "_parse_pr_out_transport_id(struct se_portal_group *,\n"
-                        bufi += "                       const char *, u32 *, char **);\n"
-
-                if re.search('alloc_fabric_acl\)\(', fo):
-                        buf += "struct se_node_acl *" + fabric_mod_name + "_alloc_fabric_acl(struct se_portal_group *se_tpg)\n"
-                        buf += "{\n"
-                        buf += "        struct " + fabric_mod_name + "_nacl *nacl;\n\n"
-                        buf += "        nacl = kzalloc(sizeof(struct " + fabric_mod_name + "_nacl), GFP_KERNEL);\n"
-                        buf += "        if (!nacl) {\n"
-                        buf += "                printk(KERN_ERR \"Unable to allocate struct " + fabric_mod_name + "_nacl\\n\");\n"
-                        buf += "                return NULL;\n"
-                        buf += "        }\n\n"
-                        buf += "        return &nacl->se_node_acl;\n"
-                        buf += "}\n\n"
-                        bufi += "struct se_node_acl *" + fabric_mod_name + "_alloc_fabric_acl(struct se_portal_group *);\n"
-
-                if re.search('release_fabric_acl\)\(', fo):
-                        buf += "void " + fabric_mod_name + "_release_fabric_acl(\n"
-                        buf += "        struct se_portal_group *se_tpg,\n"
-                        buf += "        struct se_node_acl *se_nacl)\n"
-                        buf += "{\n"
-                        buf += "        struct " + fabric_mod_name + "_nacl *nacl = container_of(se_nacl,\n"
-                        buf += "                        struct " + fabric_mod_name + "_nacl, se_node_acl);\n"
-                        buf += "        kfree(nacl);\n"
-                        buf += "}\n\n"
-                        bufi += "void " + fabric_mod_name + "_release_fabric_acl(struct se_portal_group *,\n"
-                        bufi += "                       struct se_node_acl *);\n"
-
                 if re.search('tpg_get_inst_index\)\(', fo):
                         buf += "u32 " + fabric_mod_name + "_tpg_get_inst_index(struct se_portal_group *se_tpg)\n"
                         buf += "{\n"
@@ -787,13 +519,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"
diff --git a/Documentation/target/tcm_mod_builder.txt b/Documentation/target/tcm_mod_builder.txt
index 84533d8e747f..ae22f7005540 100644
--- a/Documentation/target/tcm_mod_builder.txt
+++ b/Documentation/target/tcm_mod_builder.txt
@@ -13,8 +13,8 @@ fabric skeleton, by simply using:
 This script will create a new drivers/target/$TCM_NEW_MOD/, and will do the following
 
         *) Generate new API callers for drivers/target/target_core_fabric_configs.c logic
-           ->make_nodeacl(), ->drop_nodeacl(), ->make_tpg(), ->drop_tpg()
-           ->make_wwn(), ->drop_wwn().  These are created into $TCM_NEW_MOD/$TCM_NEW_MOD_configfs.c
+           ->make_tpg(), ->drop_tpg(), ->make_wwn(), ->drop_wwn().  These are created
+           into $TCM_NEW_MOD/$TCM_NEW_MOD_configfs.c
         *) Generate basic infrastructure for loading/unloading LKMs and TCM/ConfigFS fabric module
            using a skeleton struct target_core_fabric_ops API template.
         *) Based on user defined T10 Proto_Ident for the new fabric module being built,
diff --git a/Documentation/target/tcmu-design.txt b/Documentation/target/tcmu-design.txt
index 263b907517ac..bef81e42788f 100644
--- a/Documentation/target/tcmu-design.txt
+++ b/Documentation/target/tcmu-design.txt
@@ -152,7 +152,7 @@ overall shared memory region, not the entry. The data in/out buffers
 are accessible via tht req.iov[] array. iov_cnt contains the number of
 entries in iov[] needed to describe either the Data-In or Data-Out
 buffers. For bidirectional commands, iov_cnt specifies how many iovec
-entries cover the Data-Out area, and iov_bidi_count specifies how many
+entries cover the Data-Out area, and iov_bidi_cnt specifies how many
 iovec entries immediately after that in iov[] cover the Data-In
 area. Just like other fields, iov.iov_base is an offset from the start
 of the region.
diff --git a/drivers/infiniband/ulp/isert/ib_isert.c b/drivers/infiniband/ulp/isert/ib_isert.c
index f3b7a34e10d8..771700963127 100644
--- a/drivers/infiniband/ulp/isert/ib_isert.c
+++ b/drivers/infiniband/ulp/isert/ib_isert.c
@@ -1356,7 +1356,7 @@ sequence_cmd:
         if (!rc && dump_payload == false && unsol_data)
                 iscsit_set_unsoliticed_dataout(cmd);
         else if (dump_payload && imm_data)
-                target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
+                target_put_sess_cmd(&cmd->se_cmd);
 
         return 0;
 }
@@ -1781,7 +1781,7 @@ isert_put_cmd(struct isert_cmd *isert_cmd, bool comp_err)
                             cmd->se_cmd.t_state == TRANSPORT_WRITE_PENDING) {
                                 struct se_cmd *se_cmd = &cmd->se_cmd;
 
-                                target_put_sess_cmd(se_cmd->se_sess, se_cmd);
+                                target_put_sess_cmd(se_cmd);
                         }
                 }
 
@@ -1954,7 +1954,7 @@ isert_completion_rdma_read(struct iser_tx_desc *tx_desc,
         spin_unlock_bh(&cmd->istate_lock);
 
         if (ret) {
-                target_put_sess_cmd(se_cmd->se_sess, se_cmd);
+                target_put_sess_cmd(se_cmd);
                 transport_send_check_condition_and_sense(se_cmd,
                                                          se_cmd->pi_err, 0);
         } else {
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c
index 4556cd11288e..82897ca17f32 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.c
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.c
@@ -47,7 +47,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric_configfs.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 #include "ib_srpt.h"
 
 /* Name of this kernel module. */
@@ -94,7 +93,6 @@ MODULE_PARM_DESC(srpt_service_guid,
                  " instead of using the node_guid of the first HCA.");
 
 static struct ib_client srpt_client;
-static const struct target_core_fabric_ops srpt_template;
 static void srpt_release_channel(struct srpt_rdma_ch *ch);
 static int srpt_queue_status(struct se_cmd *cmd);
 
@@ -1336,12 +1334,12 @@ static int srpt_abort_cmd(struct srpt_send_ioctx *ioctx)
 
                 BUG_ON(ch->sess == NULL);
 
-                target_put_sess_cmd(ch->sess, &ioctx->cmd);
+                target_put_sess_cmd(&ioctx->cmd);
                 goto out;
         }
 
         pr_debug("Aborting cmd with state %d and tag %lld\n", state,
-                 ioctx->tag);
+                 ioctx->cmd.tag);
 
         switch (state) {
         case SRPT_STATE_NEW:
@@ -1367,11 +1365,11 @@ static int srpt_abort_cmd(struct srpt_send_ioctx *ioctx)
                  * not been received in time.
                  */
                 srpt_unmap_sg_to_ib_sge(ioctx->ch, ioctx);
-                target_put_sess_cmd(ioctx->ch->sess, &ioctx->cmd);
+                target_put_sess_cmd(&ioctx->cmd);
                 break;
         case SRPT_STATE_MGMT_RSP_SENT:
                 srpt_set_cmd_state(ioctx, SRPT_STATE_DONE);
-                target_put_sess_cmd(ioctx->ch->sess, &ioctx->cmd);
+                target_put_sess_cmd(&ioctx->cmd);
                 break;
         default:
                 WARN(1, "Unexpected command state (%d)", state);
@@ -1389,7 +1387,6 @@ static void srpt_handle_send_err_comp(struct srpt_rdma_ch *ch, u64 wr_id)
 {
         struct srpt_send_ioctx *ioctx;
         enum srpt_command_state state;
-        struct se_cmd *cmd;
         u32 index;
 
         atomic_inc(&ch->sq_wr_avail);
@@ -1397,7 +1394,6 @@ static void srpt_handle_send_err_comp(struct srpt_rdma_ch *ch, u64 wr_id)
         index = idx_from_wr_id(wr_id);
         ioctx = ch->ioctx_ring[index];
         state = srpt_get_cmd_state(ioctx);
-        cmd = &ioctx->cmd;
 
         WARN_ON(state != SRPT_STATE_CMD_RSP_SENT
                 && state != SRPT_STATE_MGMT_RSP_SENT
@@ -1474,10 +1470,8 @@ static void srpt_handle_rdma_err_comp(struct srpt_rdma_ch *ch,
                                       struct srpt_send_ioctx *ioctx,
                                       enum srpt_opcode opcode)
 {
-        struct se_cmd *cmd;
         enum srpt_command_state state;
 
-        cmd = &ioctx->cmd;
         state = srpt_get_cmd_state(ioctx);
         switch (opcode) {
         case SRPT_RDMA_READ_LAST:
@@ -1681,7 +1675,7 @@ static int srpt_check_stop_free(struct se_cmd *cmd)
         struct srpt_send_ioctx *ioctx = container_of(cmd,
                                 struct srpt_send_ioctx, cmd);
 
-        return target_put_sess_cmd(ioctx->ch->sess, &ioctx->cmd);
+        return target_put_sess_cmd(&ioctx->cmd);
 }
 
 /**
@@ -1703,7 +1697,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:
@@ -1774,7 +1768,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; */
@@ -1833,7 +1827,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 =
@@ -2180,12 +2174,9 @@ static void srpt_destroy_ch_ib(struct srpt_rdma_ch *ch)
  */
 static void __srpt_close_ch(struct srpt_rdma_ch *ch)
 {
-        struct srpt_device *sdev;
         enum rdma_ch_state prev_state;
         unsigned long flags;
 
-        sdev = ch->sport->sdev;
-
         spin_lock_irqsave(&ch->spinlock, flags);
         prev_state = ch->state;
         switch (prev_state) {
@@ -2983,7 +2974,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;
@@ -3058,27 +3049,27 @@ 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->ch->sess, &ioctx->cmd);
+                target_put_sess_cmd(&ioctx->cmd);
         }
 }
 
@@ -3398,11 +3389,6 @@ static char *srpt_get_fabric_name(void)
         return "srpt";
 }
 
-static u8 srpt_get_fabric_proto_ident(struct se_portal_group *se_tpg)
-{
-        return SCSI_TRANSPORTID_PROTOCOLID_SRP;
-}
-
 static char *srpt_get_fabric_wwn(struct se_portal_group *tpg)
 {
         struct srpt_port *sport = container_of(tpg, struct srpt_port, port_tpg_1);
@@ -3415,69 +3401,6 @@ static u16 srpt_get_tag(struct se_portal_group *tpg)
         return 1;
 }
 
-static u32 srpt_get_default_depth(struct se_portal_group *se_tpg)
-{
-        return 1;
-}
-
-static u32 srpt_get_pr_transport_id(struct se_portal_group *se_tpg,
-                                    struct se_node_acl *se_nacl,
-                                    struct t10_pr_registration *pr_reg,
-                                    int *format_code, unsigned char *buf)
-{
-        struct srpt_node_acl *nacl;
-        struct spc_rdma_transport_id *tr_id;
-
-        nacl = container_of(se_nacl, struct srpt_node_acl, nacl);
-        tr_id = (void *)buf;
-        tr_id->protocol_identifier = SCSI_TRANSPORTID_PROTOCOLID_SRP;
-        memcpy(tr_id->i_port_id, nacl->i_port_id, sizeof(tr_id->i_port_id));
-        return sizeof(*tr_id);
-}
-
-static u32 srpt_get_pr_transport_id_len(struct se_portal_group *se_tpg,
-                                        struct se_node_acl *se_nacl,
-                                        struct t10_pr_registration *pr_reg,
-                                        int *format_code)
-{
-        *format_code = 0;
-        return sizeof(struct spc_rdma_transport_id);
-}
-
-static char *srpt_parse_pr_out_transport_id(struct se_portal_group *se_tpg,
-                                            const char *buf, u32 *out_tid_len,
-                                            char **port_nexus_ptr)
-{
-        struct spc_rdma_transport_id *tr_id;
-
-        *port_nexus_ptr = NULL;
-        *out_tid_len = sizeof(struct spc_rdma_transport_id);
-        tr_id = (void *)buf;
-        return (char *)tr_id->i_port_id;
-}
-
-static struct se_node_acl *srpt_alloc_fabric_acl(struct se_portal_group *se_tpg)
-{
-        struct srpt_node_acl *nacl;
-
-        nacl = kzalloc(sizeof(struct srpt_node_acl), GFP_KERNEL);
-        if (!nacl) {
-                pr_err("Unable to allocate struct srpt_node_acl\n");
-                return NULL;
-        }
-
-        return &nacl->nacl;
-}
-
-static void srpt_release_fabric_acl(struct se_portal_group *se_tpg,
-                                    struct se_node_acl *se_nacl)
-{
-        struct srpt_node_acl *nacl;
-
-        nacl = container_of(se_nacl, struct srpt_node_acl, nacl);
-        kfree(nacl);
-}
-
 static u32 srpt_tpg_get_inst_index(struct se_portal_group *se_tpg)
 {
         return 1;
@@ -3551,14 +3474,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)
 {
@@ -3601,40 +3516,19 @@ out:
  * configfs callback function invoked for
  * mkdir /sys/kernel/config/target/$driver/$port/$tpg/acls/$i_port_id
  */
-static struct se_node_acl *srpt_make_nodeacl(struct se_portal_group *tpg,
-                                             struct config_group *group,
-                                             const char *name)
+static int srpt_init_nodeacl(struct se_node_acl *se_nacl, const char *name)
 {
-        struct srpt_port *sport = container_of(tpg, struct srpt_port, port_tpg_1);
-        struct se_node_acl *se_nacl, *se_nacl_new;
-        struct srpt_node_acl *nacl;
-        int ret = 0;
-        u32 nexus_depth = 1;
+        struct srpt_port *sport =
+                container_of(se_nacl->se_tpg, struct srpt_port, port_tpg_1);
+        struct srpt_node_acl *nacl =
+                container_of(se_nacl, struct srpt_node_acl, nacl);
         u8 i_port_id[16];
 
         if (srpt_parse_i_port_id(i_port_id, name) < 0) {
                 pr_err("invalid initiator port ID %s\n", name);
-                ret = -EINVAL;
-                goto err;
+                return -EINVAL;
         }
 
-        se_nacl_new = srpt_alloc_fabric_acl(tpg);
-        if (!se_nacl_new) {
-                ret = -ENOMEM;
-                goto err;
-        }
-        /*
-         * nacl_new may be released by core_tpg_add_initiator_node_acl()
-         * when converting a node ACL from demo mode to explict
-         */
-        se_nacl = core_tpg_add_initiator_node_acl(tpg, se_nacl_new, name,
-                                                  nexus_depth);
-        if (IS_ERR(se_nacl)) {
-                ret = PTR_ERR(se_nacl);
-                goto err;
-        }
-        /* Locate our struct srpt_node_acl and set sdev and i_port_id. */
-        nacl = container_of(se_nacl, struct srpt_node_acl, nacl);
         memcpy(&nacl->i_port_id[0], &i_port_id[0], 16);
         nacl->sport = sport;
 
@@ -3642,29 +3536,22 @@ static struct se_node_acl *srpt_make_nodeacl(struct se_portal_group *tpg,
         list_add_tail(&nacl->list, &sport->port_acl_list);
         spin_unlock_irq(&sport->port_acl_lock);
 
-        return se_nacl;
-err:
-        return ERR_PTR(ret);
+        return 0;
 }
 
 /*
  * configfs callback function invoked for
  * rmdir /sys/kernel/config/target/$driver/$port/$tpg/acls/$i_port_id
  */
-static void srpt_drop_nodeacl(struct se_node_acl *se_nacl)
+static void srpt_cleanup_nodeacl(struct se_node_acl *se_nacl)
 {
-        struct srpt_node_acl *nacl;
-        struct srpt_device *sdev;
-        struct srpt_port *sport;
+        struct srpt_node_acl *nacl =
+                container_of(se_nacl, struct srpt_node_acl, nacl);
+        struct srpt_port *sport = nacl->sport;
 
-        nacl = container_of(se_nacl, struct srpt_node_acl, nacl);
-        sport = nacl->sport;
-        sdev = sport->sdev;
         spin_lock_irq(&sport->port_acl_lock);
         list_del(&nacl->list);
         spin_unlock_irq(&sport->port_acl_lock);
-        core_tpg_del_initiator_node_acl(&sport->port_tpg_1, se_nacl, 1);
-        srpt_release_fabric_acl(NULL, se_nacl);
 }
 
 static ssize_t srpt_tpg_attrib_show_srp_max_rdma_size(
@@ -3849,8 +3736,7 @@ static struct se_portal_group *srpt_make_tpg(struct se_wwn *wwn,
         int res;
 
         /* Initialize sport->port_wwn and sport->port_tpg_1 */
-        res = core_tpg_register(&srpt_template, &sport->port_wwn,
-                        &sport->port_tpg_1, sport, TRANSPORT_TPG_TYPE_NORMAL);
+        res = core_tpg_register(&sport->port_wwn, &sport->port_tpg_1, SCSI_PROTOCOL_SRP);
         if (res)
                 return ERR_PTR(res);
 
@@ -3920,20 +3806,14 @@ static struct configfs_attribute *srpt_wwn_attrs[] = {
 static const struct target_core_fabric_ops srpt_template = {
         .module                         = THIS_MODULE,
         .name                           = "srpt",
+        .node_acl_size                  = sizeof(struct srpt_node_acl),
         .get_fabric_name                = srpt_get_fabric_name,
-        .get_fabric_proto_ident         = srpt_get_fabric_proto_ident,
         .tpg_get_wwn                    = srpt_get_fabric_wwn,
         .tpg_get_tag                    = srpt_get_tag,
-        .tpg_get_default_depth          = srpt_get_default_depth,
-        .tpg_get_pr_transport_id        = srpt_get_pr_transport_id,
-        .tpg_get_pr_transport_id_len    = srpt_get_pr_transport_id_len,
-        .tpg_parse_pr_out_transport_id  = srpt_parse_pr_out_transport_id,
         .tpg_check_demo_mode            = srpt_check_false,
         .tpg_check_demo_mode_cache      = srpt_check_true,
         .tpg_check_demo_mode_write_protect = srpt_check_true,
         .tpg_check_prod_mode_write_protect = srpt_check_false,
-        .tpg_alloc_fabric_acl           = srpt_alloc_fabric_acl,
-        .tpg_release_fabric_acl         = srpt_release_fabric_acl,
         .tpg_get_inst_index             = srpt_tpg_get_inst_index,
         .release_cmd                    = srpt_release_cmd,
         .check_stop_free                = srpt_check_stop_free,
@@ -3944,7 +3824,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,
@@ -3958,12 +3837,8 @@ static const struct target_core_fabric_ops srpt_template = {
         .fabric_drop_wwn                = srpt_drop_tport,
         .fabric_make_tpg                = srpt_make_tpg,
         .fabric_drop_tpg                = srpt_drop_tpg,
-        .fabric_post_link               = NULL,
-        .fabric_pre_unlink              = NULL,
-        .fabric_make_np                 = NULL,
-        .fabric_drop_np                 = NULL,
-        .fabric_make_nodeacl            = srpt_make_nodeacl,
-        .fabric_drop_nodeacl            = srpt_drop_nodeacl,
+        .fabric_init_nodeacl            = srpt_init_nodeacl,
+        .fabric_cleanup_nodeacl         = srpt_cleanup_nodeacl,
 
         .tfc_wwn_attrs                  = srpt_wwn_attrs,
         .tfc_tpg_base_attrs             = srpt_tpg_attrs,
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.h b/drivers/infiniband/ulp/srpt/ib_srpt.h
index d85c0c205625..21f8df67522a 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.h
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.h
@@ -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;
@@ -410,34 +409,16 @@ struct srpt_device {
 
 /**
  * struct srpt_node_acl - Per-initiator ACL data (managed via configfs).
+ * @nacl:      Target core node ACL information.
  * @i_port_id: 128-bit SRP initiator port ID.
  * @sport:     port information.
- * @nacl:      Target core node ACL information.
  * @list:      Element of the per-HCA ACL list.
  */
 struct srpt_node_acl {
+        struct se_node_acl      nacl;
         u8                      i_port_id[16];
         struct srpt_port        *sport;
-        struct se_node_acl      nacl;
         struct list_head        list;
 };
 
-/*
- * SRP-releated SCSI persistent reservation definitions.
- *
- * See also SPC4r28, section 7.6.1 (Protocol specific parameters introduction).
- * See also SPC4r28, section 7.6.4.5 (TransportID for initiator ports using
- * SCSI over an RDMA interface).
- */
-
-enum {
-        SCSI_TRANSPORTID_PROTOCOLID_SRP = 4,
-};
-
-struct spc_rdma_transport_id {
-        uint8_t protocol_identifier;
-        uint8_t reserved[7];
-        uint8_t i_port_id[16];
-};
-
 #endif                          /* IB_SRPT_H */
diff --git a/drivers/scsi/qla2xxx/qla_target.c b/drivers/scsi/qla2xxx/qla_target.c
index 4a484d60be0d..b749026aa592 100644
--- a/drivers/scsi/qla2xxx/qla_target.c
+++ b/drivers/scsi/qla2xxx/qla_target.c
@@ -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);
 
@@ -3893,9 +3891,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;
                 }
@@ -3929,10 +3926,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;
@@ -4053,10 +4048,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);
 
diff --git a/drivers/scsi/qla2xxx/qla_target.h b/drivers/scsi/qla2xxx/qla_target.h
index 332086776dfe..985d76dd706b 100644
--- a/drivers/scsi/qla2xxx/qla_target.h
+++ b/drivers/scsi/qla2xxx/qla_target.h
@@ -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;
diff --git a/drivers/scsi/qla2xxx/tcm_qla2xxx.c b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
index e32d24ec7a11..d9a8c6084346 100644
--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.c
+++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
@@ -44,7 +44,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 #include <target/target_core_fabric_configfs.h>
-#include <target/target_core_configfs.h>
 #include <target/configfs_macros.h>
 
 #include "qla_def.h"
@@ -54,9 +53,6 @@
 static struct workqueue_struct *tcm_qla2xxx_free_wq;
 static struct workqueue_struct *tcm_qla2xxx_cmd_wq;
 
-static const struct target_core_fabric_ops tcm_qla2xxx_ops;
-static const struct target_core_fabric_ops tcm_qla2xxx_npiv_ops;
-
 /*
  * Parse WWN.
  * If strict, we require lower-case hex and colon separators to be sure
@@ -191,23 +187,6 @@ static char *tcm_qla2xxx_npiv_get_fabric_name(void)
         return "qla2xxx_npiv";
 }
 
-static u8 tcm_qla2xxx_get_fabric_proto_ident(struct se_portal_group *se_tpg)
-{
-        struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
-                                struct tcm_qla2xxx_tpg, se_tpg);
-        struct tcm_qla2xxx_lport *lport = tpg->lport;
-        u8 proto_id;
-
-        switch (lport->lport_proto_id) {
-        case SCSI_PROTOCOL_FCP:
-        default:
-                proto_id = fc_get_fabric_proto_ident(se_tpg);
-                break;
-        }
-
-        return proto_id;
-}
-
 static char *tcm_qla2xxx_get_fabric_wwn(struct se_portal_group *se_tpg)
 {
         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
@@ -224,78 +203,6 @@ static u16 tcm_qla2xxx_get_tag(struct se_portal_group *se_tpg)
         return tpg->lport_tpgt;
 }
 
-static u32 tcm_qla2xxx_get_default_depth(struct se_portal_group *se_tpg)
-{
-        return 1;
-}
-
-static u32 tcm_qla2xxx_get_pr_transport_id(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl,
-        struct t10_pr_registration *pr_reg,
-        int *format_code,
-        unsigned char *buf)
-{
-        struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
-                                struct tcm_qla2xxx_tpg, se_tpg);
-        struct tcm_qla2xxx_lport *lport = tpg->lport;
-        int ret = 0;
-
-        switch (lport->lport_proto_id) {
-        case SCSI_PROTOCOL_FCP:
-        default:
-                ret = fc_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                                        format_code, buf);
-                break;
-        }
-
-        return ret;
-}
-
-static u32 tcm_qla2xxx_get_pr_transport_id_len(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl,
-        struct t10_pr_registration *pr_reg,
-        int *format_code)
-{
-        struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
-                                struct tcm_qla2xxx_tpg, se_tpg);
-        struct tcm_qla2xxx_lport *lport = tpg->lport;
-        int ret = 0;
-
-        switch (lport->lport_proto_id) {
-        case SCSI_PROTOCOL_FCP:
-        default:
-                ret = fc_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                                        format_code);
-                break;
-        }
-
-        return ret;
-}
-
-static char *tcm_qla2xxx_parse_pr_out_transport_id(
-        struct se_portal_group *se_tpg,
-        const char *buf,
-        u32 *out_tid_len,
-        char **port_nexus_ptr)
-{
-        struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
-                                struct tcm_qla2xxx_tpg, se_tpg);
-        struct tcm_qla2xxx_lport *lport = tpg->lport;
-        char *tid = NULL;
-
-        switch (lport->lport_proto_id) {
-        case SCSI_PROTOCOL_FCP:
-        default:
-                tid = fc_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                                        port_nexus_ptr);
-                break;
-        }
-
-        return tid;
-}
-
 static int tcm_qla2xxx_check_demo_mode(struct se_portal_group *se_tpg)
 {
         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
@@ -344,29 +251,6 @@ static int tcm_qla2xxx_check_prot_fabric_only(struct se_portal_group *se_tpg)
         return tpg->tpg_attrib.fabric_prot_type;
 }
 
-static struct se_node_acl *tcm_qla2xxx_alloc_fabric_acl(
-        struct se_portal_group *se_tpg)
-{
-        struct tcm_qla2xxx_nacl *nacl;
-
-        nacl = kzalloc(sizeof(struct tcm_qla2xxx_nacl), GFP_KERNEL);
-        if (!nacl) {
-                pr_err("Unable to allocate struct tcm_qla2xxx_nacl\n");
-                return NULL;
-        }
-
-        return &nacl->se_node_acl;
-}
-
-static void tcm_qla2xxx_release_fabric_acl(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl)
-{
-        struct tcm_qla2xxx_nacl *nacl = container_of(se_nacl,
-                        struct tcm_qla2xxx_nacl, se_node_acl);
-        kfree(nacl);
-}
-
 static u32 tcm_qla2xxx_tpg_get_inst_index(struct se_portal_group *se_tpg)
 {
         struct tcm_qla2xxx_tpg *tpg = container_of(se_tpg,
@@ -430,7 +314,7 @@ static int tcm_qla2xxx_check_stop_free(struct se_cmd *se_cmd)
                 cmd->cmd_flags |= BIT_14;
         }
 
-        return target_put_sess_cmd(se_cmd->se_sess, se_cmd);
+        return target_put_sess_cmd(se_cmd);
 }
 
 /* tcm_qla2xxx_release_cmd - Callback from TCM Core to release underlying
@@ -534,19 +418,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;
@@ -827,17 +698,6 @@ static void tcm_qla2xxx_release_session(struct kref *kref)
         qlt_unreg_sess(se_sess->fabric_sess_ptr);
 }
 
-static void tcm_qla2xxx_put_session(struct se_session *se_sess)
-{
-        struct qla_tgt_sess *sess = se_sess->fabric_sess_ptr;
-        struct qla_hw_data *ha = sess->vha->hw;
-        unsigned long flags;
-
-        spin_lock_irqsave(&ha->hardware_lock, flags);
-        kref_put(&se_sess->sess_kref, tcm_qla2xxx_release_session);
-        spin_unlock_irqrestore(&ha->hardware_lock, flags);
-}
-
 static void tcm_qla2xxx_put_sess(struct qla_tgt_sess *sess)
 {
         if (!sess)
@@ -853,53 +713,20 @@ static void tcm_qla2xxx_shutdown_sess(struct qla_tgt_sess *sess)
         target_sess_cmd_list_set_waiting(sess->se_sess);
 }
 
-static struct se_node_acl *tcm_qla2xxx_make_nodeacl(
-        struct se_portal_group *se_tpg,
-        struct config_group *group,
-        const char *name)
+static int tcm_qla2xxx_init_nodeacl(struct se_node_acl *se_nacl,
+                const char *name)
 {
-        struct se_node_acl *se_nacl, *se_nacl_new;
-        struct tcm_qla2xxx_nacl *nacl;
+        struct tcm_qla2xxx_nacl *nacl =
+                container_of(se_nacl, struct tcm_qla2xxx_nacl, se_node_acl);
         u64 wwnn;
-        u32 qla2xxx_nexus_depth;
 
         if (tcm_qla2xxx_parse_wwn(name, &wwnn, 1) < 0)
-                return ERR_PTR(-EINVAL);
-
-        se_nacl_new = tcm_qla2xxx_alloc_fabric_acl(se_tpg);
-        if (!se_nacl_new)
-                return ERR_PTR(-ENOMEM);
-/* #warning FIXME: Hardcoded qla2xxx_nexus depth in tcm_qla2xxx_make_nodeacl */
-        qla2xxx_nexus_depth = 1;
+                return -EINVAL;
 
-        /*
-         * se_nacl_new may be released by core_tpg_add_initiator_node_acl()
-         * when converting a NodeACL from demo mode -> explict
-         */
-        se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new,
-                                name, qla2xxx_nexus_depth);
-        if (IS_ERR(se_nacl)) {
-                tcm_qla2xxx_release_fabric_acl(se_tpg, se_nacl_new);
-                return se_nacl;
-        }
-        /*
-         * Locate our struct tcm_qla2xxx_nacl and set the FC Nport WWPN
-         */
-        nacl = container_of(se_nacl, struct tcm_qla2xxx_nacl, se_node_acl);
         nacl->nport_wwnn = wwnn;
         tcm_qla2xxx_format_wwn(&nacl->nport_name[0], TCM_QLA2XXX_NAMELEN, wwnn);
 
-        return se_nacl;
-}
-
-static void tcm_qla2xxx_drop_nodeacl(struct se_node_acl *se_acl)
-{
-        struct se_portal_group *se_tpg = se_acl->se_tpg;
-        struct tcm_qla2xxx_nacl *nacl = container_of(se_acl,
-                                struct tcm_qla2xxx_nacl, se_node_acl);
-
-        core_tpg_del_initiator_node_acl(se_tpg, se_acl, 1);
-        kfree(nacl);
+        return 0;
 }
 
 /* Start items for tcm_qla2xxx_tpg_attrib_cit */
@@ -1175,8 +1002,7 @@ static struct se_portal_group *tcm_qla2xxx_make_tpg(
         tpg->tpg_attrib.cache_dynamic_acls = 1;
         tpg->tpg_attrib.demo_mode_login_only = 1;
 
-        ret = core_tpg_register(&tcm_qla2xxx_ops, wwn,
-                                &tpg->se_tpg, tpg, TRANSPORT_TPG_TYPE_NORMAL);
+        ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_FCP);
         if (ret < 0) {
                 kfree(tpg);
                 return NULL;
@@ -1295,8 +1121,7 @@ static struct se_portal_group *tcm_qla2xxx_npiv_make_tpg(
         tpg->tpg_attrib.cache_dynamic_acls = 1;
         tpg->tpg_attrib.demo_mode_login_only = 1;
 
-        ret = core_tpg_register(&tcm_qla2xxx_npiv_ops, wwn,
-                                &tpg->se_tpg, tpg, TRANSPORT_TPG_TYPE_NORMAL);
+        ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_FCP);
         if (ret < 0) {
                 kfree(tpg);
                 return NULL;
@@ -1988,14 +1813,10 @@ static struct configfs_attribute *tcm_qla2xxx_wwn_attrs[] = {
 static const struct target_core_fabric_ops tcm_qla2xxx_ops = {
         .module                         = THIS_MODULE,
         .name                           = "qla2xxx",
+        .node_acl_size                  = sizeof(struct tcm_qla2xxx_nacl),
         .get_fabric_name                = tcm_qla2xxx_get_fabric_name,
-        .get_fabric_proto_ident         = tcm_qla2xxx_get_fabric_proto_ident,
         .tpg_get_wwn                    = tcm_qla2xxx_get_fabric_wwn,
         .tpg_get_tag                    = tcm_qla2xxx_get_tag,
-        .tpg_get_default_depth          = tcm_qla2xxx_get_default_depth,
-        .tpg_get_pr_transport_id        = tcm_qla2xxx_get_pr_transport_id,
-        .tpg_get_pr_transport_id_len    = tcm_qla2xxx_get_pr_transport_id_len,
-        .tpg_parse_pr_out_transport_id  = tcm_qla2xxx_parse_pr_out_transport_id,
         .tpg_check_demo_mode            = tcm_qla2xxx_check_demo_mode,
         .tpg_check_demo_mode_cache      = tcm_qla2xxx_check_demo_mode_cache,
         .tpg_check_demo_mode_write_protect =
@@ -2004,12 +1825,9 @@ static const struct target_core_fabric_ops tcm_qla2xxx_ops = {
                                         tcm_qla2xxx_check_prod_write_protect,
         .tpg_check_prot_fabric_only     = tcm_qla2xxx_check_prot_fabric_only,
         .tpg_check_demo_mode_login_only = tcm_qla2xxx_check_demo_mode_login_only,
-        .tpg_alloc_fabric_acl           = tcm_qla2xxx_alloc_fabric_acl,
-        .tpg_release_fabric_acl         = tcm_qla2xxx_release_fabric_acl,
         .tpg_get_inst_index             = tcm_qla2xxx_tpg_get_inst_index,
         .check_stop_free                = tcm_qla2xxx_check_stop_free,
         .release_cmd                    = tcm_qla2xxx_release_cmd,
-        .put_session                    = tcm_qla2xxx_put_session,
         .shutdown_session               = tcm_qla2xxx_shutdown_session,
         .close_session                  = tcm_qla2xxx_close_session,
         .sess_get_index                 = tcm_qla2xxx_sess_get_index,
@@ -2017,7 +1835,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,
@@ -2031,12 +1848,7 @@ static const struct target_core_fabric_ops tcm_qla2xxx_ops = {
         .fabric_drop_wwn                = tcm_qla2xxx_drop_lport,
         .fabric_make_tpg                = tcm_qla2xxx_make_tpg,
         .fabric_drop_tpg                = tcm_qla2xxx_drop_tpg,
-        .fabric_post_link               = NULL,
-        .fabric_pre_unlink              = NULL,
-        .fabric_make_np                 = NULL,
-        .fabric_drop_np                 = NULL,
-        .fabric_make_nodeacl            = tcm_qla2xxx_make_nodeacl,
-        .fabric_drop_nodeacl            = tcm_qla2xxx_drop_nodeacl,
+        .fabric_init_nodeacl            = tcm_qla2xxx_init_nodeacl,
 
         .tfc_wwn_attrs                  = tcm_qla2xxx_wwn_attrs,
         .tfc_tpg_base_attrs             = tcm_qla2xxx_tpg_attrs,
@@ -2046,26 +1858,19 @@ static const struct target_core_fabric_ops tcm_qla2xxx_ops = {
 static const struct target_core_fabric_ops tcm_qla2xxx_npiv_ops = {
         .module                         = THIS_MODULE,
         .name                           = "qla2xxx_npiv",
+        .node_acl_size                  = sizeof(struct tcm_qla2xxx_nacl),
         .get_fabric_name                = tcm_qla2xxx_npiv_get_fabric_name,
-        .get_fabric_proto_ident         = tcm_qla2xxx_get_fabric_proto_ident,
         .tpg_get_wwn                    = tcm_qla2xxx_get_fabric_wwn,
         .tpg_get_tag                    = tcm_qla2xxx_get_tag,
-        .tpg_get_default_depth          = tcm_qla2xxx_get_default_depth,
-        .tpg_get_pr_transport_id        = tcm_qla2xxx_get_pr_transport_id,
-        .tpg_get_pr_transport_id_len    = tcm_qla2xxx_get_pr_transport_id_len,
-        .tpg_parse_pr_out_transport_id  = tcm_qla2xxx_parse_pr_out_transport_id,
         .tpg_check_demo_mode            = tcm_qla2xxx_check_demo_mode,
         .tpg_check_demo_mode_cache      = tcm_qla2xxx_check_demo_mode_cache,
         .tpg_check_demo_mode_write_protect = tcm_qla2xxx_check_demo_mode,
         .tpg_check_prod_mode_write_protect =
             tcm_qla2xxx_check_prod_write_protect,
         .tpg_check_demo_mode_login_only = tcm_qla2xxx_check_demo_mode_login_only,
-        .tpg_alloc_fabric_acl           = tcm_qla2xxx_alloc_fabric_acl,
-        .tpg_release_fabric_acl         = tcm_qla2xxx_release_fabric_acl,
         .tpg_get_inst_index             = tcm_qla2xxx_tpg_get_inst_index,
         .check_stop_free                = tcm_qla2xxx_check_stop_free,
         .release_cmd                    = tcm_qla2xxx_release_cmd,
-        .put_session                    = tcm_qla2xxx_put_session,
         .shutdown_session               = tcm_qla2xxx_shutdown_session,
         .close_session                  = tcm_qla2xxx_close_session,
         .sess_get_index                 = tcm_qla2xxx_sess_get_index,
@@ -2073,7 +1878,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,
@@ -2087,12 +1891,7 @@ static const struct target_core_fabric_ops tcm_qla2xxx_npiv_ops = {
         .fabric_drop_wwn                = tcm_qla2xxx_npiv_drop_lport,
         .fabric_make_tpg                = tcm_qla2xxx_npiv_make_tpg,
         .fabric_drop_tpg                = tcm_qla2xxx_drop_tpg,
-        .fabric_post_link               = NULL,
-        .fabric_pre_unlink              = NULL,
-        .fabric_make_np                 = NULL,
-        .fabric_drop_np                 = NULL,
-        .fabric_make_nodeacl            = tcm_qla2xxx_make_nodeacl,
-        .fabric_drop_nodeacl            = tcm_qla2xxx_drop_nodeacl,
+        .fabric_init_nodeacl            = tcm_qla2xxx_init_nodeacl,
 
         .tfc_wwn_attrs                  = tcm_qla2xxx_wwn_attrs,
         .tfc_tpg_base_attrs             = tcm_qla2xxx_npiv_tpg_attrs,
diff --git a/drivers/scsi/qla2xxx/tcm_qla2xxx.h b/drivers/scsi/qla2xxx/tcm_qla2xxx.h
index 23295115c9fc..3bbf4cb6fd97 100644
--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.h
+++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.h
@@ -13,6 +13,8 @@
 #include "qla_target.h"
 
 struct tcm_qla2xxx_nacl {
+        struct se_node_acl se_node_acl;
+
         /* From libfc struct fc_rport->port_id */
         u32 nport_id;
         /* Binary World Wide unique Node Name for remote FC Initiator Nport */
@@ -23,8 +25,6 @@ struct tcm_qla2xxx_nacl {
         struct qla_tgt_sess *qla_tgt_sess;
         /* Pointer to TCM FC nexus */
         struct se_session *nport_nexus;
-        /* Returned by tcm_qla2xxx_make_nodeacl() */
-        struct se_node_acl se_node_acl;
 };
 
 struct tcm_qla2xxx_tpg_attrib {
@@ -57,8 +57,6 @@ struct tcm_qla2xxx_fc_loopid {
 };
 
 struct tcm_qla2xxx_lport {
-        /* SCSI protocol the lport is providing */
-        u8 lport_proto_id;
         /* Binary World Wide unique Port Name for FC Target Lport */
         u64 lport_wwpn;
         /* Binary World Wide unique Port Name for FC NPIV Target Lport */
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index a3fba366cebe..4e68b62193ed 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -29,7 +29,6 @@
 #include <scsi/scsi_tcq.h>
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 
 #include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_parameters.h"
@@ -716,7 +715,7 @@ static int iscsit_add_reject_from_cmd(
          */
         if (cmd->se_cmd.se_tfo != NULL) {
                 pr_debug("iscsi reject: calling target_put_sess_cmd >>>>>>\n");
-                target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
+                target_put_sess_cmd(&cmd->se_cmd);
         }
         return -1;
 }
@@ -1002,13 +1001,15 @@ int iscsit_setup_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
                 hdr->cmdsn, be32_to_cpu(hdr->data_length), payload_length,
                 conn->cid);
 
-        target_get_sess_cmd(conn->sess->se_sess, &cmd->se_cmd, true);
+        target_get_sess_cmd(&cmd->se_cmd, true);
 
         cmd->sense_reason = transport_lookup_cmd_lun(&cmd->se_cmd,
                                                      scsilun_to_int(&hdr->lun));
         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) {
@@ -1068,7 +1069,7 @@ int iscsit_process_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
                 if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER)
                         return -1;
                 else if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) {
-                        target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
+                        target_put_sess_cmd(&cmd->se_cmd);
                         return 0;
                 }
         }
@@ -1084,7 +1085,7 @@ int iscsit_process_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
                 if (!cmd->sense_reason)
                         return 0;
 
-                target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
+                target_put_sess_cmd(&cmd->se_cmd);
                 return 0;
         }
 
@@ -1115,7 +1116,6 @@ static int
 iscsit_get_immediate_data(struct iscsi_cmd *cmd, struct iscsi_scsi_req *hdr,
                           bool dump_payload)
 {
-        struct iscsi_conn *conn = cmd->conn;
         int cmdsn_ret = 0, immed_ret = IMMEDIATE_DATA_NORMAL_OPERATION;
         /*
          * Special case for Unsupported SAM WRITE Opcodes and ImmediateData=Yes.
@@ -1142,7 +1142,7 @@ after_immediate_data:
 
                         rc = iscsit_dump_data_payload(cmd->conn,
                                                       cmd->first_burst_len, 1);
-                        target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
+                        target_put_sess_cmd(&cmd->se_cmd);
                         return rc;
                 } else if (cmd->unsolicited_data)
                         iscsit_set_unsoliticed_dataout(cmd);
@@ -1811,7 +1811,7 @@ iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
                                       conn->sess->se_sess, 0, DMA_NONE,
                                       TCM_SIMPLE_TAG, cmd->sense_buffer + 2);
 
-                target_get_sess_cmd(conn->sess->se_sess, &cmd->se_cmd, true);
+                target_get_sess_cmd(&cmd->se_cmd, true);
                 sess_ref = true;
 
                 switch (function) {
@@ -1953,7 +1953,7 @@ attach:
          */
         if (sess_ref) {
                 pr_debug("Handle TMR, using sess_ref=true check\n");
-                target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
+                target_put_sess_cmd(&cmd->se_cmd);
         }
 
         iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
@@ -2737,11 +2737,7 @@ static int iscsit_send_datain(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
         cmd->iov_data_count = iov_count;
         cmd->tx_size = tx_size;
 
-        /* sendpage is preferred but can't insert markers */
-        if (!conn->conn_ops->IFMarker)
-                ret = iscsit_fe_sendpage_sg(cmd, conn);
-        else
-                ret = iscsit_send_tx_data(cmd, conn, 0);
+        ret = iscsit_fe_sendpage_sg(cmd, conn);
 
         iscsit_unmap_iovec(cmd);
 
@@ -4073,17 +4069,9 @@ static int iscsi_target_rx_opcode(struct iscsi_conn *conn, unsigned char *buf)
                         " opcode while ERL=0, closing iSCSI connection.\n");
                         return -1;
                 }
-                if (!conn->conn_ops->OFMarker) {
-                        pr_err("Unable to recover from unknown"
-                        " opcode while OFMarker=No, closing iSCSI"
-                                " connection.\n");
-                        return -1;
-                }
-                if (iscsit_recover_from_unknown_opcode(conn) < 0) {
-                        pr_err("Unable to recover from unknown"
-                                " opcode, closing iSCSI connection.\n");
-                        return -1;
-                }
+                pr_err("Unable to recover from unknown opcode while OFMarker=No,"
+                       " closing iSCSI connection.\n");
+                ret = -1;
                 break;
         }
 
diff --git a/drivers/target/iscsi/iscsi_target_configfs.c b/drivers/target/iscsi/iscsi_target_configfs.c
index 469fce44ebad..c1898c84b3d2 100644
--- a/drivers/target/iscsi/iscsi_target_configfs.c
+++ b/drivers/target/iscsi/iscsi_target_configfs.c
@@ -24,7 +24,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 #include <target/target_core_fabric_configfs.h>
-#include <target/target_core_configfs.h>
 #include <target/configfs_macros.h>
 #include <target/iscsi/iscsi_transport.h>
 
@@ -860,57 +859,19 @@ static struct configfs_attribute *lio_target_initiator_attrs[] = {
         NULL,
 };
 
-static struct se_node_acl *lio_tpg_alloc_fabric_acl(
-        struct se_portal_group *se_tpg)
+static int lio_target_init_nodeacl(struct se_node_acl *se_nacl,
+                const char *name)
 {
-        struct iscsi_node_acl *acl;
-
-        acl = kzalloc(sizeof(struct iscsi_node_acl), GFP_KERNEL);
-        if (!acl) {
-                pr_err("Unable to allocate memory for struct iscsi_node_acl\n");
-                return NULL;
-        }
-
-        return &acl->se_node_acl;
-}
-
-static struct se_node_acl *lio_target_make_nodeacl(
-        struct se_portal_group *se_tpg,
-        struct config_group *group,
-        const char *name)
-{
-        struct config_group *stats_cg;
-        struct iscsi_node_acl *acl;
-        struct se_node_acl *se_nacl_new, *se_nacl;
-        struct iscsi_portal_group *tpg = container_of(se_tpg,
-                        struct iscsi_portal_group, tpg_se_tpg);
-        u32 cmdsn_depth;
-
-        se_nacl_new = lio_tpg_alloc_fabric_acl(se_tpg);
-        if (!se_nacl_new)
-                return ERR_PTR(-ENOMEM);
-
-        cmdsn_depth = tpg->tpg_attrib.default_cmdsn_depth;
-        /*
-         * se_nacl_new may be released by core_tpg_add_initiator_node_acl()
-         * when converting a NdoeACL from demo mode -> explict
-         */
-        se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new,
-                                name, cmdsn_depth);
-        if (IS_ERR(se_nacl))
-                return se_nacl;
-
-        acl = container_of(se_nacl, struct iscsi_node_acl, se_node_acl);
-        stats_cg = &se_nacl->acl_fabric_stat_group;
+        struct iscsi_node_acl *acl =
+                container_of(se_nacl, struct iscsi_node_acl, se_node_acl);
+        struct config_group *stats_cg = &se_nacl->acl_fabric_stat_group;
 
         stats_cg->default_groups = kmalloc(sizeof(struct config_group *) * 2,
                                 GFP_KERNEL);
         if (!stats_cg->default_groups) {
                 pr_err("Unable to allocate memory for"
                                 " stats_cg->default_groups\n");
-                core_tpg_del_initiator_node_acl(se_tpg, se_nacl, 1);
-                kfree(acl);
-                return ERR_PTR(-ENOMEM);
+                return -ENOMEM;
         }
 
         stats_cg->default_groups[0] = &acl->node_stat_grps.iscsi_sess_stats_group;
@@ -918,13 +879,11 @@ static struct se_node_acl *lio_target_make_nodeacl(
         config_group_init_type_name(&acl->node_stat_grps.iscsi_sess_stats_group,
                         "iscsi_sess_stats", &iscsi_stat_sess_cit);
 
-        return se_nacl;
+        return 0;
 }
 
-static void lio_target_drop_nodeacl(
-        struct se_node_acl *se_nacl)
+static void lio_target_cleanup_nodeacl( struct se_node_acl *se_nacl)
 {
-        struct se_portal_group *se_tpg = se_nacl->se_tpg;
         struct iscsi_node_acl *acl = container_of(se_nacl,
                         struct iscsi_node_acl, se_node_acl);
         struct config_item *df_item;
@@ -938,9 +897,6 @@ static void lio_target_drop_nodeacl(
                 config_item_put(df_item);
         }
         kfree(stats_cg->default_groups);
-
-        core_tpg_del_initiator_node_acl(se_tpg, se_nacl, 1);
-        kfree(acl);
 }
 
 /* End items for lio_target_acl_cit */
@@ -1463,8 +1419,7 @@ static struct se_portal_group *lio_target_tiqn_addtpg(
         if (!tpg)
                 return NULL;
 
-        ret = core_tpg_register(&iscsi_ops, wwn, &tpg->tpg_se_tpg,
-                                tpg, TRANSPORT_TPG_TYPE_NORMAL);
+        ret = core_tpg_register(wwn, &tpg->tpg_se_tpg, SCSI_PROTOCOL_ISCSI);
         if (ret < 0)
                 return NULL;
 
@@ -1735,14 +1690,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);
@@ -1832,78 +1779,58 @@ static void lio_aborted_task(struct se_cmd *se_cmd)
         cmd->conn->conn_transport->iscsit_aborted_task(cmd->conn, cmd);
 }
 
-static char *lio_tpg_get_endpoint_wwn(struct se_portal_group *se_tpg)
+static inline struct iscsi_portal_group *iscsi_tpg(struct se_portal_group *se_tpg)
 {
-        struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
+        return container_of(se_tpg, struct iscsi_portal_group, tpg_se_tpg);
+}
 
-        return &tpg->tpg_tiqn->tiqn[0];
+static char *lio_tpg_get_endpoint_wwn(struct se_portal_group *se_tpg)
+{
+        return iscsi_tpg(se_tpg)->tpg_tiqn->tiqn;
 }
 
 static u16 lio_tpg_get_tag(struct se_portal_group *se_tpg)
 {
-        struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
-
-        return tpg->tpgt;
+        return iscsi_tpg(se_tpg)->tpgt;
 }
 
 static u32 lio_tpg_get_default_depth(struct se_portal_group *se_tpg)
 {
-        struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
-
-        return tpg->tpg_attrib.default_cmdsn_depth;
+        return iscsi_tpg(se_tpg)->tpg_attrib.default_cmdsn_depth;
 }
 
 static int lio_tpg_check_demo_mode(struct se_portal_group *se_tpg)
 {
-        struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
-
-        return tpg->tpg_attrib.generate_node_acls;
+        return iscsi_tpg(se_tpg)->tpg_attrib.generate_node_acls;
 }
 
 static int lio_tpg_check_demo_mode_cache(struct se_portal_group *se_tpg)
 {
-        struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
-
-        return tpg->tpg_attrib.cache_dynamic_acls;
+        return iscsi_tpg(se_tpg)->tpg_attrib.cache_dynamic_acls;
 }
 
 static int lio_tpg_check_demo_mode_write_protect(
         struct se_portal_group *se_tpg)
 {
-        struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
-
-        return tpg->tpg_attrib.demo_mode_write_protect;
+        return iscsi_tpg(se_tpg)->tpg_attrib.demo_mode_write_protect;
 }
 
 static int lio_tpg_check_prod_mode_write_protect(
         struct se_portal_group *se_tpg)
 {
-        struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
-
-        return tpg->tpg_attrib.prod_mode_write_protect;
+        return iscsi_tpg(se_tpg)->tpg_attrib.prod_mode_write_protect;
 }
 
 static int lio_tpg_check_prot_fabric_only(
         struct se_portal_group *se_tpg)
 {
-        struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
         /*
          * Only report fabric_prot_type if t10_pi has also been enabled
          * for incoming ib_isert sessions.
          */
-        if (!tpg->tpg_attrib.t10_pi)
+        if (!iscsi_tpg(se_tpg)->tpg_attrib.t10_pi)
                 return 0;
-
-        return tpg->tpg_attrib.fabric_prot_type;
-}
-
-static void lio_tpg_release_fabric_acl(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_acl)
-{
-        struct iscsi_node_acl *acl = container_of(se_acl,
-                                struct iscsi_node_acl, se_node_acl);
-        kfree(acl);
+        return iscsi_tpg(se_tpg)->tpg_attrib.fabric_prot_type;
 }
 
 /*
@@ -1948,9 +1875,7 @@ static void lio_tpg_close_session(struct se_session *se_sess)
 
 static u32 lio_tpg_get_inst_index(struct se_portal_group *se_tpg)
 {
-        struct iscsi_portal_group *tpg = se_tpg->se_tpg_fabric_ptr;
-
-        return tpg->tpg_tiqn->tiqn_index;
+        return iscsi_tpg(se_tpg)->tpg_tiqn->tiqn_index;
 }
 
 static void lio_set_default_node_attributes(struct se_node_acl *se_acl)
@@ -1967,7 +1892,7 @@ static void lio_set_default_node_attributes(struct se_node_acl *se_acl)
 
 static int lio_check_stop_free(struct se_cmd *se_cmd)
 {
-        return target_put_sess_cmd(se_cmd->se_sess, se_cmd);
+        return target_put_sess_cmd(se_cmd);
 }
 
 static void lio_release_cmd(struct se_cmd *se_cmd)
@@ -1981,14 +1906,11 @@ static void lio_release_cmd(struct se_cmd *se_cmd)
 const struct target_core_fabric_ops iscsi_ops = {
         .module                         = THIS_MODULE,
         .name                           = "iscsi",
+        .node_acl_size                  = sizeof(struct iscsi_node_acl),
         .get_fabric_name                = iscsi_get_fabric_name,
-        .get_fabric_proto_ident         = iscsi_get_fabric_proto_ident,
         .tpg_get_wwn                    = lio_tpg_get_endpoint_wwn,
         .tpg_get_tag                    = lio_tpg_get_tag,
         .tpg_get_default_depth          = lio_tpg_get_default_depth,
-        .tpg_get_pr_transport_id        = iscsi_get_pr_transport_id,
-        .tpg_get_pr_transport_id_len    = iscsi_get_pr_transport_id_len,
-        .tpg_parse_pr_out_transport_id  = iscsi_parse_pr_out_transport_id,
         .tpg_check_demo_mode            = lio_tpg_check_demo_mode,
         .tpg_check_demo_mode_cache      = lio_tpg_check_demo_mode_cache,
         .tpg_check_demo_mode_write_protect =
@@ -1996,8 +1918,6 @@ const struct target_core_fabric_ops iscsi_ops = {
         .tpg_check_prod_mode_write_protect =
                         lio_tpg_check_prod_mode_write_protect,
         .tpg_check_prot_fabric_only     = &lio_tpg_check_prot_fabric_only,
-        .tpg_alloc_fabric_acl           = lio_tpg_alloc_fabric_acl,
-        .tpg_release_fabric_acl         = lio_tpg_release_fabric_acl,
         .tpg_get_inst_index             = lio_tpg_get_inst_index,
         .check_stop_free                = lio_check_stop_free,
         .release_cmd                    = lio_release_cmd,
@@ -2008,7 +1928,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,
@@ -2020,8 +1939,8 @@ const struct target_core_fabric_ops iscsi_ops = {
         .fabric_drop_tpg                = lio_target_tiqn_deltpg,
         .fabric_make_np                 = lio_target_call_addnptotpg,
         .fabric_drop_np                 = lio_target_call_delnpfromtpg,
-        .fabric_make_nodeacl            = lio_target_make_nodeacl,
-        .fabric_drop_nodeacl            = lio_target_drop_nodeacl,
+        .fabric_init_nodeacl            = lio_target_init_nodeacl,
+        .fabric_cleanup_nodeacl         = lio_target_cleanup_nodeacl,
 
         .tfc_discovery_attrs            = lio_target_discovery_auth_attrs,
         .tfc_wwn_attrs                  = lio_target_wwn_attrs,
diff --git a/drivers/target/iscsi/iscsi_target_erl0.c b/drivers/target/iscsi/iscsi_target_erl0.c
index 959a14c9dd5d..210f6e4830e3 100644
--- a/drivers/target/iscsi/iscsi_target_erl0.c
+++ b/drivers/target/iscsi/iscsi_target_erl0.c
@@ -956,56 +956,3 @@ void iscsit_take_action_for_connection_exit(struct iscsi_conn *conn)
 
         iscsit_handle_connection_cleanup(conn);
 }
-
-/*
- *      This is the simple function that makes the magic of
- *      sync and steering happen in the follow paradoxical order:
- *
- *      0) Receive conn->of_marker (bytes left until next OFMarker)
- *         bytes into an offload buffer.  When we pass the exact number
- *         of bytes in conn->of_marker, iscsit_dump_data_payload() and hence
- *         rx_data() will automatically receive the identical u32 marker
- *         values and store it in conn->of_marker_offset;
- *      1) Now conn->of_marker_offset will contain the offset to the start
- *         of the next iSCSI PDU.  Dump these remaining bytes into another
- *         offload buffer.
- *      2) We are done!
- *         Next byte in the TCP stream will contain the next iSCSI PDU!
- *         Cool Huh?!
- */
-int iscsit_recover_from_unknown_opcode(struct iscsi_conn *conn)
-{
-        /*
-         * Make sure the remaining bytes to next maker is a sane value.
-         */
-        if (conn->of_marker > (conn->conn_ops->OFMarkInt * 4)) {
-                pr_err("Remaining bytes to OFMarker: %u exceeds"
-                        " OFMarkInt bytes: %u.\n", conn->of_marker,
-                                conn->conn_ops->OFMarkInt * 4);
-                return -1;
-        }
-
-        pr_debug("Advancing %u bytes in TCP stream to get to the"
-                        " next OFMarker.\n", conn->of_marker);
-
-        if (iscsit_dump_data_payload(conn, conn->of_marker, 0) < 0)
-                return -1;
-
-        /*
-         * Make sure the offset marker we retrived is a valid value.
-         */
-        if (conn->of_marker_offset > (ISCSI_HDR_LEN + (ISCSI_CRC_LEN * 2) +
-            conn->conn_ops->MaxRecvDataSegmentLength)) {
-                pr_err("OfMarker offset value: %u exceeds limit.\n",
-                        conn->of_marker_offset);
-                return -1;
-        }
-
-        pr_debug("Discarding %u bytes of TCP stream to get to the"
-                        " next iSCSI Opcode.\n", conn->of_marker_offset);
-
-        if (iscsit_dump_data_payload(conn, conn->of_marker_offset, 0) < 0)
-                return -1;
-
-        return 0;
-}
diff --git a/drivers/target/iscsi/iscsi_target_erl0.h b/drivers/target/iscsi/iscsi_target_erl0.h
index 21acc9a06376..a9e2f9497fb2 100644
--- a/drivers/target/iscsi/iscsi_target_erl0.h
+++ b/drivers/target/iscsi/iscsi_target_erl0.h
@@ -10,6 +10,5 @@ extern void iscsit_connection_reinstatement_rcfr(struct iscsi_conn *);
 extern void iscsit_cause_connection_reinstatement(struct iscsi_conn *, int);
 extern void iscsit_fall_back_to_erl0(struct iscsi_session *);
 extern void iscsit_take_action_for_connection_exit(struct iscsi_conn *);
-extern int iscsit_recover_from_unknown_opcode(struct iscsi_conn *);
 
 #endif   /*** ISCSI_TARGET_ERL0_H ***/
diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
index 70d799dfab03..3d0fe4ff5590 100644
--- a/drivers/target/iscsi/iscsi_target_login.c
+++ b/drivers/target/iscsi/iscsi_target_login.c
@@ -410,8 +410,6 @@ static int iscsi_login_zero_tsih_s2(
         if (iscsi_change_param_sprintf(conn, "ErrorRecoveryLevel=%d", na->default_erl))
                 return -1;
 
-        if (iscsi_login_disable_FIM_keys(conn->param_list, conn) < 0)
-                return -1;
         /*
          * Set RDMAExtensions=Yes by default for iSER enabled network portals
          */
@@ -477,59 +475,6 @@ check_prot:
         return 0;
 }
 
-/*
- * Remove PSTATE_NEGOTIATE for the four FIM related keys.
- * The Initiator node will be able to enable FIM by proposing them itself.
- */
-int iscsi_login_disable_FIM_keys(
-        struct iscsi_param_list *param_list,
-        struct iscsi_conn *conn)
-{
-        struct iscsi_param *param;
-
-        param = iscsi_find_param_from_key("OFMarker", param_list);
-        if (!param) {
-                pr_err("iscsi_find_param_from_key() for"
-                                " OFMarker failed\n");
-                iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
-                                ISCSI_LOGIN_STATUS_NO_RESOURCES);
-                return -1;
-        }
-        param->state &= ~PSTATE_NEGOTIATE;
-
-        param = iscsi_find_param_from_key("OFMarkInt", param_list);
-        if (!param) {
-                pr_err("iscsi_find_param_from_key() for"
-                                " IFMarker failed\n");
-                iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
-                                ISCSI_LOGIN_STATUS_NO_RESOURCES);
-                return -1;
-        }
-        param->state &= ~PSTATE_NEGOTIATE;
-
-        param = iscsi_find_param_from_key("IFMarker", param_list);
-        if (!param) {
-                pr_err("iscsi_find_param_from_key() for"
-                                " IFMarker failed\n");
-                iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
-                                ISCSI_LOGIN_STATUS_NO_RESOURCES);
-                return -1;
-        }
-        param->state &= ~PSTATE_NEGOTIATE;
-
-        param = iscsi_find_param_from_key("IFMarkInt", param_list);
-        if (!param) {
-                pr_err("iscsi_find_param_from_key() for"
-                                " IFMarker failed\n");
-                iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
-                                ISCSI_LOGIN_STATUS_NO_RESOURCES);
-                return -1;
-        }
-        param->state &= ~PSTATE_NEGOTIATE;
-
-        return 0;
-}
-
 static int iscsi_login_non_zero_tsih_s1(
         struct iscsi_conn *conn,
         unsigned char *buf)
@@ -616,7 +561,7 @@ static int iscsi_login_non_zero_tsih_s2(
         if (iscsi_change_param_sprintf(conn, "TargetPortalGroupTag=%hu", sess->tpg->tpgt))
                 return -1;
 
-        return iscsi_login_disable_FIM_keys(conn->param_list, conn);
+        return 0;
 }
 
 int iscsi_login_post_auth_non_zero_tsih(
@@ -765,7 +710,6 @@ int iscsi_post_login_handler(
         conn->conn_state = TARG_CONN_STATE_LOGGED_IN;
 
         iscsi_set_connection_parameters(conn->conn_ops, conn->param_list);
-        iscsit_set_sync_and_steering_values(conn);
         /*
          * SCSI Initiator -> SCSI Target Port Mapping
          */
diff --git a/drivers/target/iscsi/iscsi_target_login.h b/drivers/target/iscsi/iscsi_target_login.h
index 29d098324b7f..1c7358081533 100644
--- a/drivers/target/iscsi/iscsi_target_login.h
+++ b/drivers/target/iscsi/iscsi_target_login.h
@@ -16,6 +16,5 @@ extern int iscsi_post_login_handler(struct iscsi_np *, struct iscsi_conn *, u8);
 extern void iscsi_target_login_sess_out(struct iscsi_conn *, struct iscsi_np *,
                                 bool, bool);
 extern int iscsi_target_login_thread(void *);
-extern int iscsi_login_disable_FIM_keys(struct iscsi_param_list *, struct iscsi_conn *);
 
 #endif   /*** ISCSI_TARGET_LOGIN_H ***/
diff --git a/drivers/target/iscsi/iscsi_target_parameters.c b/drivers/target/iscsi/iscsi_target_parameters.c
index d4f9e9645697..e8a52f7d6204 100644
--- a/drivers/target/iscsi/iscsi_target_parameters.c
+++ b/drivers/target/iscsi/iscsi_target_parameters.c
@@ -34,13 +34,6 @@ int iscsi_login_rx_data(
         iov.iov_len     = length;
         iov.iov_base    = buf;
 
-        /*
-         * Initial Marker-less Interval.
-         * Add the values regardless of IFMarker/OFMarker, considering
-         * it may not be negoitated yet.
-         */
-        conn->of_marker += length;
-
         rx_got = rx_data(conn, &iov, 1, length);
         if (rx_got != length) {
                 pr_err("rx_data returned %d, expecting %d.\n",
@@ -72,13 +65,6 @@ int iscsi_login_tx_data(
                 iov_cnt++;
         }
 
-        /*
-         * Initial Marker-less Interval.
-         * Add the values regardless of IFMarker/OFMarker, considering
-         * it may not be negoitated yet.
-         */
-        conn->if_marker += length;
-
         tx_sent = tx_data(conn, &iov[0], iov_cnt, length);
         if (tx_sent != length) {
                 pr_err("tx_data returned %d, expecting %d.\n",
@@ -97,12 +83,6 @@ void iscsi_dump_conn_ops(struct iscsi_conn_ops *conn_ops)
                                 "CRC32C" : "None");
         pr_debug("MaxRecvDataSegmentLength: %u\n",
                                 conn_ops->MaxRecvDataSegmentLength);
-        pr_debug("OFMarker: %s\n", (conn_ops->OFMarker) ? "Yes" : "No");
-        pr_debug("IFMarker: %s\n", (conn_ops->IFMarker) ? "Yes" : "No");
-        if (conn_ops->OFMarker)
-                pr_debug("OFMarkInt: %u\n", conn_ops->OFMarkInt);
-        if (conn_ops->IFMarker)
-                pr_debug("IFMarkInt: %u\n", conn_ops->IFMarkInt);
 }
 
 void iscsi_dump_sess_ops(struct iscsi_sess_ops *sess_ops)
@@ -194,10 +174,6 @@ static struct iscsi_param *iscsi_set_default_param(struct iscsi_param_list *para
         case TYPERANGE_DIGEST:
                 param->type = TYPE_VALUE_LIST | TYPE_STRING;
                 break;
-        case TYPERANGE_MARKINT:
-                param->type = TYPE_NUMBER_RANGE;
-                param->type_range |= TYPERANGE_1_TO_65535;
-                break;
         case TYPERANGE_ISCSINAME:
         case TYPERANGE_SESSIONTYPE:
         case TYPERANGE_TARGETADDRESS:
@@ -422,13 +398,13 @@ int iscsi_create_default_params(struct iscsi_param_list **param_list_ptr)
 
         param = iscsi_set_default_param(pl, IFMARKINT, INITIAL_IFMARKINT,
                         PHASE_OPERATIONAL, SCOPE_CONNECTION_ONLY, SENDER_BOTH,
-                        TYPERANGE_MARKINT, USE_INITIAL_ONLY);
+                        TYPERANGE_UTF8, USE_INITIAL_ONLY);
         if (!param)
                 goto out;
 
         param = iscsi_set_default_param(pl, OFMARKINT, INITIAL_OFMARKINT,
                         PHASE_OPERATIONAL, SCOPE_CONNECTION_ONLY, SENDER_BOTH,
-                        TYPERANGE_MARKINT, USE_INITIAL_ONLY);
+                        TYPERANGE_UTF8, USE_INITIAL_ONLY);
         if (!param)
                 goto out;
         /*
@@ -524,9 +500,9 @@ int iscsi_set_keys_to_negotiate(
                 } else if (!strcmp(param->name, OFMARKER)) {
                         SET_PSTATE_NEGOTIATE(param);
                 } else if (!strcmp(param->name, IFMARKINT)) {
-                        SET_PSTATE_NEGOTIATE(param);
+                        SET_PSTATE_REJECT(param);
                 } else if (!strcmp(param->name, OFMARKINT)) {
-                        SET_PSTATE_NEGOTIATE(param);
+                        SET_PSTATE_REJECT(param);
                 } else if (!strcmp(param->name, RDMAEXTENSIONS)) {
                         if (iser)
                                 SET_PSTATE_NEGOTIATE(param);
@@ -906,91 +882,6 @@ static int iscsi_check_numerical_value(struct iscsi_param *param, char *value_pt
         return 0;
 }
 
-static int iscsi_check_numerical_range_value(struct iscsi_param *param, char *value)
-{
-        char *left_val_ptr = NULL, *right_val_ptr = NULL;
-        char *tilde_ptr = NULL;
-        u32 left_val, right_val, local_left_val;
-
-        if (strcmp(param->name, IFMARKINT) &&
-            strcmp(param->name, OFMARKINT)) {
-                pr_err("Only parameters \"%s\" or \"%s\" may contain a"
-                       " numerical range value.\n", IFMARKINT, OFMARKINT);
-                return -1;
-        }
-
-        if (IS_PSTATE_PROPOSER(param))
-                return 0;
-
-        tilde_ptr = strchr(value, '~');
-        if (!tilde_ptr) {
-                pr_err("Unable to locate numerical range indicator"
-                        " \"~\" for \"%s\".\n", param->name);
-                return -1;
-        }
-        *tilde_ptr = '\0';
-
-        left_val_ptr = value;
-        right_val_ptr = value + strlen(left_val_ptr) + 1;
-
-        if (iscsi_check_numerical_value(param, left_val_ptr) < 0)
-                return -1;
-        if (iscsi_check_numerical_value(param, right_val_ptr) < 0)
-                return -1;
-
-        left_val = simple_strtoul(left_val_ptr, NULL, 0);
-        right_val = simple_strtoul(right_val_ptr, NULL, 0);
-        *tilde_ptr = '~';
-
-        if (right_val < left_val) {
-                pr_err("Numerical range for parameter \"%s\" contains"
-                        " a right value which is less than the left.\n",
-                                param->name);
-                return -1;
-        }
-
-        /*
-         * For now,  enforce reasonable defaults for [I,O]FMarkInt.
-         */
-        tilde_ptr = strchr(param->value, '~');
-        if (!tilde_ptr) {
-                pr_err("Unable to locate numerical range indicator"
-                        " \"~\" for \"%s\".\n", param->name);
-                return -1;
-        }
-        *tilde_ptr = '\0';
-
-        left_val_ptr = param->value;
-        right_val_ptr = param->value + strlen(left_val_ptr) + 1;
-
-        local_left_val = simple_strtoul(left_val_ptr, NULL, 0);
-        *tilde_ptr = '~';
-
-        if (param->set_param) {
-                if ((left_val < local_left_val) ||
-                    (right_val < local_left_val)) {
-                        pr_err("Passed value range \"%u~%u\" is below"
-                                " minimum left value \"%u\" for key \"%s\","
-                                " rejecting.\n", left_val, right_val,
-                                local_left_val, param->name);
-                        return -1;
-                }
-        } else {
-                if ((left_val < local_left_val) &&
-                    (right_val < local_left_val)) {
-                        pr_err("Received value range \"%u~%u\" is"
-                                " below minimum left value \"%u\" for key"
-                                " \"%s\", rejecting.\n", left_val, right_val,
-                                local_left_val, param->name);
-                        SET_PSTATE_REJECT(param);
-                        if (iscsi_update_param_value(param, REJECT) < 0)
-                                return -1;
-                }
-        }
-
-        return 0;
-}
-
 static int iscsi_check_string_or_list_value(struct iscsi_param *param, char *value)
 {
         if (IS_PSTATE_PROPOSER(param))
@@ -1027,33 +918,6 @@ static int iscsi_check_string_or_list_value(struct iscsi_param *param, char *val
         return 0;
 }
 
-/*
- *      This function is used to pick a value range number,  currently just
- *      returns the lesser of both right values.
- */
-static char *iscsi_get_value_from_number_range(
-        struct iscsi_param *param,
-        char *value)
-{
-        char *end_ptr, *tilde_ptr1 = NULL, *tilde_ptr2 = NULL;
-        u32 acceptor_right_value, proposer_right_value;
-
-        tilde_ptr1 = strchr(value, '~');
-        if (!tilde_ptr1)
-                return NULL;
-        *tilde_ptr1++ = '\0';
-        proposer_right_value = simple_strtoul(tilde_ptr1, &end_ptr, 0);
-
-        tilde_ptr2 = strchr(param->value, '~');
-        if (!tilde_ptr2)
-                return NULL;
-        *tilde_ptr2++ = '\0';
-        acceptor_right_value = simple_strtoul(tilde_ptr2, &end_ptr, 0);
-
-        return (acceptor_right_value >= proposer_right_value) ?
-                tilde_ptr1 : tilde_ptr2;
-}
-
 static char *iscsi_check_valuelist_for_support(
         struct iscsi_param *param,
         char *value)
@@ -1103,7 +967,7 @@ static int iscsi_check_acceptor_state(struct iscsi_param *param, char *value,
                                 struct iscsi_conn *conn)
 {
         u8 acceptor_boolean_value = 0, proposer_boolean_value = 0;
-        char *negoitated_value = NULL;
+        char *negotiated_value = NULL;
 
         if (IS_PSTATE_ACCEPTOR(param)) {
                 pr_err("Received key \"%s\" twice, protocol error.\n",
@@ -1203,24 +1067,16 @@ static int iscsi_check_acceptor_state(struct iscsi_param *param, char *value,
                         pr_debug("Updated %s to target MXDSL value: %s\n",
                                         param->name, param->value);
                 }
-
-        } else if (IS_TYPE_NUMBER_RANGE(param)) {
-                negoitated_value = iscsi_get_value_from_number_range(
-                                        param, value);
-                if (!negoitated_value)
-                        return -1;
-                if (iscsi_update_param_value(param, negoitated_value) < 0)
-                        return -1;
         } else if (IS_TYPE_VALUE_LIST(param)) {
-                negoitated_value = iscsi_check_valuelist_for_support(
+                negotiated_value = iscsi_check_valuelist_for_support(
                                         param, value);
-                if (!negoitated_value) {
+                if (!negotiated_value) {
                         pr_err("Proposer's value list \"%s\" contains"
                                 " no valid values from Acceptor's value list"
                                 " \"%s\".\n", value, param->value);
                         return -1;
                 }
-                if (iscsi_update_param_value(param, negoitated_value) < 0)
+                if (iscsi_update_param_value(param, negotiated_value) < 0)
                         return -1;
         } else if (IS_PHASE_DECLARATIVE(param)) {
                 if (iscsi_update_param_value(param, value) < 0)
@@ -1239,47 +1095,7 @@ static int iscsi_check_proposer_state(struct iscsi_param *param, char *value)
                 return -1;
         }
 
-        if (IS_TYPE_NUMBER_RANGE(param)) {
-                u32 left_val = 0, right_val = 0, recieved_value = 0;
-                char *left_val_ptr = NULL, *right_val_ptr = NULL;
-                char *tilde_ptr = NULL;
-
-                if (!strcmp(value, IRRELEVANT) || !strcmp(value, REJECT)) {
-                        if (iscsi_update_param_value(param, value) < 0)
-                                return -1;
-                        return 0;
-                }
-
-                tilde_ptr = strchr(value, '~');
-                if (tilde_ptr) {
-                        pr_err("Illegal \"~\" in response for \"%s\".\n",
-                                        param->name);
-                        return -1;
-                }
-                tilde_ptr = strchr(param->value, '~');
-                if (!tilde_ptr) {
-                        pr_err("Unable to locate numerical range"
-                                " indicator \"~\" for \"%s\".\n", param->name);
-                        return -1;
-                }
-                *tilde_ptr = '\0';
-
-                left_val_ptr = param->value;
-                right_val_ptr = param->value + strlen(left_val_ptr) + 1;
-                left_val = simple_strtoul(left_val_ptr, NULL, 0);
-                right_val = simple_strtoul(right_val_ptr, NULL, 0);
-                recieved_value = simple_strtoul(value, NULL, 0);
-
-                *tilde_ptr = '~';
-
-                if ((recieved_value < left_val) ||
-                    (recieved_value > right_val)) {
-                        pr_err("Illegal response \"%s=%u\", value must"
-                                " be between %u and %u.\n", param->name,
-                                recieved_value, left_val, right_val);
-                        return -1;
-                }
-        } else if (IS_TYPE_VALUE_LIST(param)) {
+        if (IS_TYPE_VALUE_LIST(param)) {
                 char *comma_ptr = NULL, *tmp_ptr = NULL;
 
                 comma_ptr = strchr(value, ',');
@@ -1361,9 +1177,6 @@ static int iscsi_check_value(struct iscsi_param *param, char *value)
                 } else if (IS_TYPE_NUMBER(param)) {
                         if (iscsi_check_numerical_value(param, value) < 0)
                                 return -1;
-                } else if (IS_TYPE_NUMBER_RANGE(param)) {
-                        if (iscsi_check_numerical_range_value(param, value) < 0)
-                                return -1;
                 } else if (IS_TYPE_STRING(param) || IS_TYPE_VALUE_LIST(param)) {
                         if (iscsi_check_string_or_list_value(param, value) < 0)
                                 return -1;
@@ -1483,8 +1296,6 @@ static int iscsi_enforce_integrity_rules(
         char *tmpptr;
         u8 DataSequenceInOrder = 0;
         u8 ErrorRecoveryLevel = 0, SessionType = 0;
-        u8 IFMarker = 0, OFMarker = 0;
-        u8 IFMarkInt_Reject = 1, OFMarkInt_Reject = 1;
         u32 FirstBurstLength = 0, MaxBurstLength = 0;
         struct iscsi_param *param = NULL;
 
@@ -1503,28 +1314,12 @@ static int iscsi_enforce_integrity_rules(
                 if (!strcmp(param->name, MAXBURSTLENGTH))
                         MaxBurstLength = simple_strtoul(param->value,
                                         &tmpptr, 0);
-                if (!strcmp(param->name, IFMARKER))
-                        if (!strcmp(param->value, YES))
-                                IFMarker = 1;
-                if (!strcmp(param->name, OFMARKER))
-                        if (!strcmp(param->value, YES))
-                                OFMarker = 1;
-                if (!strcmp(param->name, IFMARKINT))
-                        if (!strcmp(param->value, REJECT))
-                                IFMarkInt_Reject = 1;
-                if (!strcmp(param->name, OFMARKINT))
-                        if (!strcmp(param->value, REJECT))
-                                OFMarkInt_Reject = 1;
         }
 
         list_for_each_entry(param, &param_list->param_list, p_list) {
                 if (!(param->phase & phase))
                         continue;
-                if (!SessionType && (!IS_PSTATE_ACCEPTOR(param) &&
-                     (strcmp(param->name, IFMARKER) &&
-                      strcmp(param->name, OFMARKER) &&
-                      strcmp(param->name, IFMARKINT) &&
-                      strcmp(param->name, OFMARKINT))))
+                if (!SessionType && !IS_PSTATE_ACCEPTOR(param))
                         continue;
                 if (!strcmp(param->name, MAXOUTSTANDINGR2T) &&
                     DataSequenceInOrder && (ErrorRecoveryLevel > 0)) {
@@ -1556,38 +1351,6 @@ static int iscsi_enforce_integrity_rules(
                                         param->name, param->value);
                         }
                 }
-                if (!strcmp(param->name, IFMARKER) && IFMarkInt_Reject) {
-                        if (iscsi_update_param_value(param, NO) < 0)
-                                return -1;
-                        IFMarker = 0;
-                        pr_debug("Reset \"%s\" to \"%s\".\n",
-                                        param->name, param->value);
-                }
-                if (!strcmp(param->name, OFMARKER) && OFMarkInt_Reject) {
-                        if (iscsi_update_param_value(param, NO) < 0)
-                                return -1;
-                        OFMarker = 0;
-                        pr_debug("Reset \"%s\" to \"%s\".\n",
-                                         param->name, param->value);
-                }
-                if (!strcmp(param->name, IFMARKINT) && !IFMarker) {
-                        if (!strcmp(param->value, REJECT))
-                                continue;
-                        param->state &= ~PSTATE_NEGOTIATE;
-                        if (iscsi_update_param_value(param, IRRELEVANT) < 0)
-                                return -1;
-                        pr_debug("Reset \"%s\" to \"%s\".\n",
-                                        param->name, param->value);
-                }
-                if (!strcmp(param->name, OFMARKINT) && !OFMarker) {
-                        if (!strcmp(param->value, REJECT))
-                                continue;
-                        param->state &= ~PSTATE_NEGOTIATE;
-                        if (iscsi_update_param_value(param, IRRELEVANT) < 0)
-                                return -1;
-                        pr_debug("Reset \"%s\" to \"%s\".\n",
-                                        param->name, param->value);
-                }
         }
 
         return 0;
@@ -1824,24 +1587,6 @@ void iscsi_set_connection_parameters(
                          */
                         pr_debug("MaxRecvDataSegmentLength:     %u\n",
                                 ops->MaxRecvDataSegmentLength);
-                } else if (!strcmp(param->name, OFMARKER)) {
-                        ops->OFMarker = !strcmp(param->value, YES);
-                        pr_debug("OFMarker:                     %s\n",
-                                param->value);
-                } else if (!strcmp(param->name, IFMARKER)) {
-                        ops->IFMarker = !strcmp(param->value, YES);
-                        pr_debug("IFMarker:                     %s\n",
-                                param->value);
-                } else if (!strcmp(param->name, OFMARKINT)) {
-                        ops->OFMarkInt =
-                                simple_strtoul(param->value, &tmpptr, 0);
-                        pr_debug("OFMarkInt:                    %s\n",
-                                param->value);
-                } else if (!strcmp(param->name, IFMARKINT)) {
-                        ops->IFMarkInt =
-                                simple_strtoul(param->value, &tmpptr, 0);
-                        pr_debug("IFMarkInt:                    %s\n",
-                                param->value);
                 } else if (!strcmp(param->name, INITIATORRECVDATASEGMENTLENGTH)) {
                         ops->InitiatorRecvDataSegmentLength =
                                 simple_strtoul(param->value, &tmpptr, 0);
diff --git a/drivers/target/iscsi/iscsi_target_parameters.h b/drivers/target/iscsi/iscsi_target_parameters.h
index a47046a752aa..a0751e3f0813 100644
--- a/drivers/target/iscsi/iscsi_target_parameters.h
+++ b/drivers/target/iscsi/iscsi_target_parameters.h
@@ -138,8 +138,8 @@ extern void iscsi_set_session_parameters(struct iscsi_sess_ops *,
 #define INITIAL_SESSIONTYPE                     NORMAL
 #define INITIAL_IFMARKER                        NO
 #define INITIAL_OFMARKER                        NO
-#define INITIAL_IFMARKINT                       "2048~65535"
-#define INITIAL_OFMARKINT                       "2048~65535"
+#define INITIAL_IFMARKINT                       REJECT
+#define INITIAL_OFMARKINT                       REJECT
 
 /*
  * Initial values for iSER parameters following RFC-5046 Section 6
@@ -239,10 +239,9 @@ extern void iscsi_set_session_parameters(struct iscsi_sess_ops *,
 #define TYPERANGE_AUTH                  0x0200
 #define TYPERANGE_DIGEST                0x0400
 #define TYPERANGE_ISCSINAME             0x0800
-#define TYPERANGE_MARKINT               0x1000
-#define TYPERANGE_SESSIONTYPE           0x2000
-#define TYPERANGE_TARGETADDRESS         0x4000
-#define TYPERANGE_UTF8                  0x8000
+#define TYPERANGE_SESSIONTYPE           0x1000
+#define TYPERANGE_TARGETADDRESS         0x2000
+#define TYPERANGE_UTF8                  0x4000
 
 #define IS_TYPERANGE_0_TO_2(p)          ((p)->type_range & TYPERANGE_0_TO_2)
 #define IS_TYPERANGE_0_TO_3600(p)       ((p)->type_range & TYPERANGE_0_TO_3600)
diff --git a/drivers/target/iscsi/iscsi_target_tmr.c b/drivers/target/iscsi/iscsi_target_tmr.c
index fe9a582ca6af..cf59c397007b 100644
--- a/drivers/target/iscsi/iscsi_target_tmr.c
+++ b/drivers/target/iscsi/iscsi_target_tmr.c
@@ -120,7 +120,7 @@ u8 iscsit_tmr_task_reassign(
         struct iscsi_tmr_req *tmr_req = cmd->tmr_req;
         struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
         struct iscsi_tm *hdr = (struct iscsi_tm *) buf;
-        int ret, ref_lun;
+        u64 ret, ref_lun;
 
         pr_debug("Got TASK_REASSIGN TMR ITT: 0x%08x,"
                 " RefTaskTag: 0x%08x, ExpDataSN: 0x%08x, CID: %hu\n",
@@ -164,7 +164,7 @@ u8 iscsit_tmr_task_reassign(
         ref_lun = scsilun_to_int(&hdr->lun);
         if (ref_lun != ref_cmd->se_cmd.orig_fe_lun) {
                 pr_err("Unable to perform connection recovery for"
-                        " differing ref_lun: %d ref_cmd orig_fe_lun: %u\n",
+                        " differing ref_lun: %llu ref_cmd orig_fe_lun: %llu\n",
                         ref_lun, ref_cmd->se_cmd.orig_fe_lun);
                 return ISCSI_TMF_RSP_REJECTED;
         }
diff --git a/drivers/target/iscsi/iscsi_target_tpg.c b/drivers/target/iscsi/iscsi_target_tpg.c
index 5e3295fe404d..968068ffcb1c 100644
--- a/drivers/target/iscsi/iscsi_target_tpg.c
+++ b/drivers/target/iscsi/iscsi_target_tpg.c
@@ -18,7 +18,6 @@
 
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 
 #include <target/iscsi/iscsi_target_core.h>
 #include "iscsi_target_erl0.h"
@@ -67,9 +66,12 @@ int iscsit_load_discovery_tpg(void)
                 pr_err("Unable to allocate struct iscsi_portal_group\n");
                 return -1;
         }
-
-        ret = core_tpg_register(&iscsi_ops, NULL, &tpg->tpg_se_tpg,
-                                tpg, TRANSPORT_TPG_TYPE_DISCOVERY);
+        /*
+         * Save iscsi_ops pointer for special case discovery TPG that
+         * doesn't exist as se_wwn->wwn_group within configfs.
+         */
+        tpg->tpg_se_tpg.se_tpg_tfo = &iscsi_ops;
+        ret = core_tpg_register(NULL, &tpg->tpg_se_tpg, -1);
         if (ret < 0) {
                 kfree(tpg);
                 return -1;
@@ -280,8 +282,6 @@ int iscsit_tpg_del_portal_group(
                 return -EPERM;
         }
 
-        core_tpg_clear_object_luns(&tpg->tpg_se_tpg);
-
         if (tpg->param_list) {
                 iscsi_release_param_list(tpg->param_list);
                 tpg->param_list = NULL;
diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c
index b18edda3e8af..a2bff0702eb2 100644
--- a/drivers/target/iscsi/iscsi_target_util.c
+++ b/drivers/target/iscsi/iscsi_target_util.c
@@ -22,7 +22,6 @@
 #include <scsi/iscsi_proto.h>
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 #include <target/iscsi/iscsi_transport.h>
 
 #include <target/iscsi/iscsi_target_core.h>
@@ -746,7 +745,7 @@ void iscsit_free_cmd(struct iscsi_cmd *cmd, bool shutdown)
                 rc = transport_generic_free_cmd(&cmd->se_cmd, shutdown);
                 if (!rc && shutdown && se_cmd && se_cmd->se_sess) {
                         __iscsit_free_cmd(cmd, true, shutdown);
-                        target_put_sess_cmd(se_cmd->se_sess, se_cmd);
+                        target_put_sess_cmd(se_cmd);
                 }
                 break;
         case ISCSI_OP_REJECT:
@@ -762,7 +761,7 @@ void iscsit_free_cmd(struct iscsi_cmd *cmd, bool shutdown)
                         rc = transport_generic_free_cmd(&cmd->se_cmd, shutdown);
                         if (!rc && shutdown && se_cmd->se_sess) {
                                 __iscsit_free_cmd(cmd, true, shutdown);
-                                target_put_sess_cmd(se_cmd->se_sess, se_cmd);
+                                target_put_sess_cmd(se_cmd);
                         }
                         break;
                 }
@@ -809,54 +808,6 @@ void iscsit_inc_session_usage_count(struct iscsi_session *sess)
         spin_unlock_bh(&sess->session_usage_lock);
 }
 
-/*
- *      Setup conn->if_marker and conn->of_marker values based upon
- *      the initial marker-less interval. (see iSCSI v19 A.2)
- */
-int iscsit_set_sync_and_steering_values(struct iscsi_conn *conn)
-{
-        int login_ifmarker_count = 0, login_ofmarker_count = 0, next_marker = 0;
-        /*
-         * IFMarkInt and OFMarkInt are negotiated as 32-bit words.
-         */
-        u32 IFMarkInt = (conn->conn_ops->IFMarkInt * 4);
-        u32 OFMarkInt = (conn->conn_ops->OFMarkInt * 4);
-
-        if (conn->conn_ops->OFMarker) {
-                /*
-                 * Account for the first Login Command received not
-                 * via iscsi_recv_msg().
-                 */
-                conn->of_marker += ISCSI_HDR_LEN;
-                if (conn->of_marker <= OFMarkInt) {
-                        conn->of_marker = (OFMarkInt - conn->of_marker);
-                } else {
-                        login_ofmarker_count = (conn->of_marker / OFMarkInt);
-                        next_marker = (OFMarkInt * (login_ofmarker_count + 1)) +
-                                        (login_ofmarker_count * MARKER_SIZE);
-                        conn->of_marker = (next_marker - conn->of_marker);
-                }
-                conn->of_marker_offset = 0;
-                pr_debug("Setting OFMarker value to %u based on Initial"
-                        " Markerless Interval.\n", conn->of_marker);
-        }
-
-        if (conn->conn_ops->IFMarker) {
-                if (conn->if_marker <= IFMarkInt) {
-                        conn->if_marker = (IFMarkInt - conn->if_marker);
-                } else {
-                        login_ifmarker_count = (conn->if_marker / IFMarkInt);
-                        next_marker = (IFMarkInt * (login_ifmarker_count + 1)) +
-                                        (login_ifmarker_count * MARKER_SIZE);
-                        conn->if_marker = (next_marker - conn->if_marker);
-                }
-                pr_debug("Setting IFMarker value to %u based on Initial"
-                        " Markerless Interval.\n", conn->if_marker);
-        }
-
-        return 0;
-}
-
 struct iscsi_conn *iscsit_get_conn_from_cid(struct iscsi_session *sess, u16 cid)
 {
         struct iscsi_conn *conn;
diff --git a/drivers/target/iscsi/iscsi_target_util.h b/drivers/target/iscsi/iscsi_target_util.h
index 1ab754a671ff..995f1cb29d0e 100644
--- a/drivers/target/iscsi/iscsi_target_util.h
+++ b/drivers/target/iscsi/iscsi_target_util.h
@@ -34,7 +34,6 @@ extern void iscsit_free_cmd(struct iscsi_cmd *, bool);
 extern int iscsit_check_session_usage_count(struct iscsi_session *);
 extern void iscsit_dec_session_usage_count(struct iscsi_session *);
 extern void iscsit_inc_session_usage_count(struct iscsi_session *);
-extern int iscsit_set_sync_and_steering_values(struct iscsi_conn *);
 extern struct iscsi_conn *iscsit_get_conn_from_cid(struct iscsi_session *, u16);
 extern struct iscsi_conn *iscsit_get_conn_from_cid_rcfr(struct iscsi_session *, u16);
 extern void iscsit_check_conn_usage_count(struct iscsi_conn *);
diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c
index 51f0c895c6a5..a556bdebd775 100644
--- a/drivers/target/loopback/tcm_loop.c
+++ b/drivers/target/loopback/tcm_loop.c
@@ -35,14 +35,11 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 #include <target/target_core_fabric_configfs.h>
-#include <target/target_core_configfs.h>
 
 #include "tcm_loop.h"
 
 #define to_tcm_loop_hba(hba)    container_of(hba, struct tcm_loop_hba, dev)
 
-static const struct target_core_fabric_ops loop_ops;
-
 static struct workqueue_struct *tcm_loop_workqueue;
 static struct kmem_cache *tcm_loop_cmd_cache;
 
@@ -165,6 +162,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,
@@ -217,7 +215,7 @@ static int tcm_loop_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *sc)
  * to struct scsi_device
  */
 static int tcm_loop_issue_tmr(struct tcm_loop_tpg *tl_tpg,
-                              int lun, int task, enum tcm_tmreq_table tmr)
+                              u64 lun, int task, enum tcm_tmreq_table tmr)
 {
         struct se_cmd *se_cmd = NULL;
         struct se_session *se_sess;
@@ -409,7 +407,7 @@ static int tcm_loop_driver_probe(struct device *dev)
         sh->max_id = 2;
         sh->max_lun = 0;
         sh->max_channel = 0;
-        sh->max_cmd_len = TL_SCSI_MAX_CMD_LEN;
+        sh->max_cmd_len = SCSI_MAX_VARLEN_CDB_SIZE;
 
         host_prot = SHOST_DIF_TYPE1_PROTECTION | SHOST_DIF_TYPE2_PROTECTION |
                     SHOST_DIF_TYPE3_PROTECTION | SHOST_DIX_TYPE1_PROTECTION |
@@ -520,147 +518,26 @@ static char *tcm_loop_get_fabric_name(void)
         return "loopback";
 }
 
-static u8 tcm_loop_get_fabric_proto_ident(struct se_portal_group *se_tpg)
+static inline struct tcm_loop_tpg *tl_tpg(struct se_portal_group *se_tpg)
 {
-        struct tcm_loop_tpg *tl_tpg = se_tpg->se_tpg_fabric_ptr;
-        struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba;
-        /*
-         * tl_proto_id is set at tcm_loop_configfs.c:tcm_loop_make_scsi_hba()
-         * time based on the protocol dependent prefix of the passed configfs group.
-         *
-         * Based upon tl_proto_id, TCM_Loop emulates the requested fabric
-         * ProtocolID using target_core_fabric_lib.c symbols.
-         */
-        switch (tl_hba->tl_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-                return sas_get_fabric_proto_ident(se_tpg);
-        case SCSI_PROTOCOL_FCP:
-                return fc_get_fabric_proto_ident(se_tpg);
-        case SCSI_PROTOCOL_ISCSI:
-                return iscsi_get_fabric_proto_ident(se_tpg);
-        default:
-                pr_err("Unknown tl_proto_id: 0x%02x, using"
-                        " SAS emulation\n", tl_hba->tl_proto_id);
-                break;
-        }
-
-        return sas_get_fabric_proto_ident(se_tpg);
+        return container_of(se_tpg, struct tcm_loop_tpg, tl_se_tpg);
 }
 
 static char *tcm_loop_get_endpoint_wwn(struct se_portal_group *se_tpg)
 {
-        struct tcm_loop_tpg *tl_tpg = se_tpg->se_tpg_fabric_ptr;
         /*
          * Return the passed NAA identifier for the SAS Target Port
          */
-        return &tl_tpg->tl_hba->tl_wwn_address[0];
+        return &tl_tpg(se_tpg)->tl_hba->tl_wwn_address[0];
 }
 
 static u16 tcm_loop_get_tag(struct se_portal_group *se_tpg)
 {
-        struct tcm_loop_tpg *tl_tpg = se_tpg->se_tpg_fabric_ptr;
         /*
          * This Tag is used when forming SCSI Name identifier in EVPD=1 0x83
          * to represent the SCSI Target Port.
          */
-        return tl_tpg->tl_tpgt;
-}
-
-static u32 tcm_loop_get_default_depth(struct se_portal_group *se_tpg)
-{
-        return 1;
-}
-
-static u32 tcm_loop_get_pr_transport_id(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl,
-        struct t10_pr_registration *pr_reg,
-        int *format_code,
-        unsigned char *buf)
-{
-        struct tcm_loop_tpg *tl_tpg = se_tpg->se_tpg_fabric_ptr;
-        struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba;
-
-        switch (tl_hba->tl_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-                return sas_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                                        format_code, buf);
-        case SCSI_PROTOCOL_FCP:
-                return fc_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                                        format_code, buf);
-        case SCSI_PROTOCOL_ISCSI:
-                return iscsi_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                                        format_code, buf);
-        default:
-                pr_err("Unknown tl_proto_id: 0x%02x, using"
-                        " SAS emulation\n", tl_hba->tl_proto_id);
-                break;
-        }
-
-        return sas_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                        format_code, buf);
-}
-
-static u32 tcm_loop_get_pr_transport_id_len(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl,
-        struct t10_pr_registration *pr_reg,
-        int *format_code)
-{
-        struct tcm_loop_tpg *tl_tpg = se_tpg->se_tpg_fabric_ptr;
-        struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba;
-
-        switch (tl_hba->tl_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-                return sas_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                                        format_code);
-        case SCSI_PROTOCOL_FCP:
-                return fc_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                                        format_code);
-        case SCSI_PROTOCOL_ISCSI:
-                return iscsi_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                                        format_code);
-        default:
-                pr_err("Unknown tl_proto_id: 0x%02x, using"
-                        " SAS emulation\n", tl_hba->tl_proto_id);
-                break;
-        }
-
-        return sas_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                        format_code);
-}
-
-/*
- * Used for handling SCSI fabric dependent TransportIDs in SPC-3 and above
- * Persistent Reservation SPEC_I_PT=1 and PROUT REGISTER_AND_MOVE operations.
- */
-static char *tcm_loop_parse_pr_out_transport_id(
-        struct se_portal_group *se_tpg,
-        const char *buf,
-        u32 *out_tid_len,
-        char **port_nexus_ptr)
-{
-        struct tcm_loop_tpg *tl_tpg = se_tpg->se_tpg_fabric_ptr;
-        struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba;
-
-        switch (tl_hba->tl_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-                return sas_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                                        port_nexus_ptr);
-        case SCSI_PROTOCOL_FCP:
-                return fc_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                                        port_nexus_ptr);
-        case SCSI_PROTOCOL_ISCSI:
-                return iscsi_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                                        port_nexus_ptr);
-        default:
-                pr_err("Unknown tl_proto_id: 0x%02x, using"
-                        " SAS emulation\n", tl_hba->tl_proto_id);
-                break;
-        }
-
-        return sas_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                        port_nexus_ptr);
+        return tl_tpg(se_tpg)->tl_tpgt;
 }
 
 /*
@@ -703,30 +580,6 @@ static int tcm_loop_check_prot_fabric_only(struct se_portal_group *se_tpg)
         return tl_tpg->tl_fabric_prot_type;
 }
 
-static struct se_node_acl *tcm_loop_tpg_alloc_fabric_acl(
-        struct se_portal_group *se_tpg)
-{
-        struct tcm_loop_nacl *tl_nacl;
-
-        tl_nacl = kzalloc(sizeof(struct tcm_loop_nacl), GFP_KERNEL);
-        if (!tl_nacl) {
-                pr_err("Unable to allocate struct tcm_loop_nacl\n");
-                return NULL;
-        }
-
-        return &tl_nacl->se_node_acl;
-}
-
-static void tcm_loop_tpg_release_fabric_acl(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl)
-{
-        struct tcm_loop_nacl *tl_nacl = container_of(se_nacl,
-                                struct tcm_loop_nacl, se_node_acl);
-
-        kfree(tl_nacl);
-}
-
 static u32 tcm_loop_get_inst_index(struct se_portal_group *se_tpg)
 {
         return 1;
@@ -742,14 +595,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,
@@ -902,7 +747,7 @@ static void tcm_loop_port_unlink(
                                 se_lun->unpacked_lun);
         if (!sd) {
                 pr_err("Unable to locate struct scsi_device for %d:%d:"
-                        "%d\n", 0, tl_tpg->tl_tpgt, se_lun->unpacked_lun);
+                        "%llu\n", 0, tl_tpg->tl_tpgt, se_lun->unpacked_lun);
                 return;
         }
         /*
@@ -1234,8 +1079,7 @@ static struct se_portal_group *tcm_loop_make_naa_tpg(
         /*
          * Register the tl_tpg as a emulated SAS TCM Target Endpoint
          */
-        ret = core_tpg_register(&loop_ops, wwn, &tl_tpg->tl_se_tpg, tl_tpg,
-                        TRANSPORT_TPG_TYPE_NORMAL);
+        ret = core_tpg_register(wwn, &tl_tpg->tl_se_tpg, tl_hba->tl_proto_id);
         if (ret < 0)
                 return ERR_PTR(-ENOMEM);
 
@@ -1386,13 +1230,8 @@ static const struct target_core_fabric_ops loop_ops = {
         .module                         = THIS_MODULE,
         .name                           = "loopback",
         .get_fabric_name                = tcm_loop_get_fabric_name,
-        .get_fabric_proto_ident         = tcm_loop_get_fabric_proto_ident,
         .tpg_get_wwn                    = tcm_loop_get_endpoint_wwn,
         .tpg_get_tag                    = tcm_loop_get_tag,
-        .tpg_get_default_depth          = tcm_loop_get_default_depth,
-        .tpg_get_pr_transport_id        = tcm_loop_get_pr_transport_id,
-        .tpg_get_pr_transport_id_len    = tcm_loop_get_pr_transport_id_len,
-        .tpg_parse_pr_out_transport_id  = tcm_loop_parse_pr_out_transport_id,
         .tpg_check_demo_mode            = tcm_loop_check_demo_mode,
         .tpg_check_demo_mode_cache      = tcm_loop_check_demo_mode_cache,
         .tpg_check_demo_mode_write_protect =
@@ -1400,8 +1239,6 @@ static const struct target_core_fabric_ops loop_ops = {
         .tpg_check_prod_mode_write_protect =
                                 tcm_loop_check_prod_mode_write_protect,
         .tpg_check_prot_fabric_only     = tcm_loop_check_prot_fabric_only,
-        .tpg_alloc_fabric_acl           = tcm_loop_tpg_alloc_fabric_acl,
-        .tpg_release_fabric_acl         = tcm_loop_tpg_release_fabric_acl,
         .tpg_get_inst_index             = tcm_loop_get_inst_index,
         .check_stop_free                = tcm_loop_check_stop_free,
         .release_cmd                    = tcm_loop_release_cmd,
@@ -1411,7 +1248,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,
diff --git a/drivers/target/loopback/tcm_loop.h b/drivers/target/loopback/tcm_loop.h
index 1e72ff77cac9..4346462094a1 100644
--- a/drivers/target/loopback/tcm_loop.h
+++ b/drivers/target/loopback/tcm_loop.h
@@ -2,11 +2,6 @@
 #define TL_WWN_ADDR_LEN                 256
 #define TL_TPGS_PER_HBA                 32
 
-/*
- * Used in tcm_loop_driver_probe() for struct Scsi_Host->max_cmd_len
- */
-#define TL_SCSI_MAX_CMD_LEN             32
-
 struct tcm_loop_cmd {
         /* State of Linux/SCSI CDB+Data descriptor */
         u32 sc_cmd_state;
@@ -33,10 +28,6 @@ struct tcm_loop_nexus {
         struct se_session *se_sess;
 };
 
-struct tcm_loop_nacl {
-        struct se_node_acl se_node_acl;
-};
-
 #define TCM_TRANSPORT_ONLINE 0
 #define TCM_TRANSPORT_OFFLINE 1
 
diff --git a/drivers/target/sbp/sbp_target.c b/drivers/target/sbp/sbp_target.c
index ce81f17ad1ba..0edf320fb685 100644
--- a/drivers/target/sbp/sbp_target.c
+++ b/drivers/target/sbp/sbp_target.c
@@ -36,7 +36,6 @@
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
 #include <target/target_core_fabric_configfs.h>
-#include <target/target_core_configfs.h>
 #include <target/configfs_macros.h>
 #include <asm/unaligned.h>
 
@@ -109,13 +108,13 @@ static struct sbp_session *sbp_session_find_by_guid(
 }
 
 static struct sbp_login_descriptor *sbp_login_find_by_lun(
-                struct sbp_session *session, struct se_lun *lun)
+                struct sbp_session *session, u32 unpacked_lun)
 {
         struct sbp_login_descriptor *login, *found = NULL;
 
         spin_lock_bh(&session->lock);
         list_for_each_entry(login, &session->login_list, link) {
-                if (login->lun == lun)
+                if (login->login_lun == unpacked_lun)
                         found = login;
         }
         spin_unlock_bh(&session->lock);
@@ -125,7 +124,7 @@ static struct sbp_login_descriptor *sbp_login_find_by_lun(
 
 static int sbp_login_count_all_by_lun(
                 struct sbp_tpg *tpg,
-                struct se_lun *lun,
+                u32 unpacked_lun,
                 int exclusive)
 {
         struct se_session *se_sess;
@@ -139,7 +138,7 @@ static int sbp_login_count_all_by_lun(
 
                 spin_lock_bh(&sess->lock);
                 list_for_each_entry(login, &sess->login_list, link) {
-                        if (login->lun != lun)
+                        if (login->login_lun != unpacked_lun)
                                 continue;
 
                         if (!exclusive || login->exclusive)
@@ -175,23 +174,23 @@ static struct sbp_login_descriptor *sbp_login_find_by_id(
         return found;
 }
 
-static struct se_lun *sbp_get_lun_from_tpg(struct sbp_tpg *tpg, int lun)
+static u32 sbp_get_lun_from_tpg(struct sbp_tpg *tpg, u32 login_lun, int *err)
 {
         struct se_portal_group *se_tpg = &tpg->se_tpg;
         struct se_lun *se_lun;
 
-        if (lun >= TRANSPORT_MAX_LUNS_PER_TPG)
-                return ERR_PTR(-EINVAL);
-
-        spin_lock(&se_tpg->tpg_lun_lock);
-        se_lun = se_tpg->tpg_lun_list[lun];
-
-        if (se_lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE)
-                se_lun = ERR_PTR(-ENODEV);
-
-        spin_unlock(&se_tpg->tpg_lun_lock);
+        rcu_read_lock();
+        hlist_for_each_entry_rcu(se_lun, &se_tpg->tpg_lun_hlist, link) {
+                if (se_lun->unpacked_lun == login_lun) {
+                        rcu_read_unlock();
+                        *err = 0;
+                        return login_lun;
+                }
+        }
+        rcu_read_unlock();
 
-        return se_lun;
+        *err = -ENODEV;
+        return login_lun;
 }
 
 static struct sbp_session *sbp_session_create(
@@ -295,17 +294,16 @@ static void sbp_management_request_login(
 {
         struct sbp_tport *tport = agent->tport;
         struct sbp_tpg *tpg = tport->tpg;
-        struct se_lun *se_lun;
-        int ret;
-        u64 guid;
         struct sbp_session *sess;
         struct sbp_login_descriptor *login;
         struct sbp_login_response_block *response;
-        int login_response_len;
+        u64 guid;
+        u32 unpacked_lun;
+        int login_response_len, ret;
 
-        se_lun = sbp_get_lun_from_tpg(tpg,
-                        LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)));
-        if (IS_ERR(se_lun)) {
+        unpacked_lun = sbp_get_lun_from_tpg(tpg,
+                        LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)), &ret);
+        if (ret) {
                 pr_notice("login to unknown LUN: %d\n",
                         LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)));
 
@@ -326,11 +324,11 @@ static void sbp_management_request_login(
         }
 
         pr_notice("mgt_agent LOGIN to LUN %d from %016llx\n",
-                se_lun->unpacked_lun, guid);
+                unpacked_lun, guid);
 
         sess = sbp_session_find_by_guid(tpg, guid);
         if (sess) {
-                login = sbp_login_find_by_lun(sess, se_lun);
+                login = sbp_login_find_by_lun(sess, unpacked_lun);
                 if (login) {
                         pr_notice("initiator already logged-in\n");
 
@@ -358,7 +356,7 @@ static void sbp_management_request_login(
          * reject with access_denied if any logins present
          */
         if (LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc)) &&
-                        sbp_login_count_all_by_lun(tpg, se_lun, 0)) {
+                        sbp_login_count_all_by_lun(tpg, unpacked_lun, 0)) {
                 pr_warn("refusing exclusive login with other active logins\n");
 
                 req->status.status = cpu_to_be32(
@@ -371,7 +369,7 @@ static void sbp_management_request_login(
          * check exclusive bit in any existing login descriptor
          * reject with access_denied if any exclusive logins present
          */
-        if (sbp_login_count_all_by_lun(tpg, se_lun, 1)) {
+        if (sbp_login_count_all_by_lun(tpg, unpacked_lun, 1)) {
                 pr_warn("refusing login while another exclusive login present\n");
 
                 req->status.status = cpu_to_be32(
@@ -384,7 +382,7 @@ static void sbp_management_request_login(
          * check we haven't exceeded the number of allowed logins
          * reject with resources_unavailable if we have
          */
-        if (sbp_login_count_all_by_lun(tpg, se_lun, 0) >=
+        if (sbp_login_count_all_by_lun(tpg, unpacked_lun, 0) >=
                         tport->max_logins_per_lun) {
                 pr_warn("max number of logins reached\n");
 
@@ -440,7 +438,7 @@ static void sbp_management_request_login(
         }
 
         login->sess = sess;
-        login->lun = se_lun;
+        login->login_lun = unpacked_lun;
         login->status_fifo_addr = sbp2_pointer_to_addr(&req->orb.status_fifo);
         login->exclusive = LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc));
         login->login_id = atomic_inc_return(&login_id);
@@ -602,7 +600,7 @@ static void sbp_management_request_logout(
         }
 
         pr_info("mgt_agent LOGOUT from LUN %d session %d\n",
-                login->lun->unpacked_lun, login->login_id);
+                login->login_lun, login->login_id);
 
         if (req->node_addr != login->sess->node_id) {
                 pr_warn("logout from different node ID\n");
@@ -1228,12 +1226,14 @@ static void sbp_handle_command(struct sbp_target_request *req)
                 goto err;
         }
 
-        unpacked_lun = req->login->lun->unpacked_lun;
+        unpacked_lun = req->login->login_lun;
         sbp_calc_data_length_direction(req, &data_length, &data_dir);
 
         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))
@@ -1707,33 +1707,6 @@ static u16 sbp_get_tag(struct se_portal_group *se_tpg)
         return tpg->tport_tpgt;
 }
 
-static u32 sbp_get_default_depth(struct se_portal_group *se_tpg)
-{
-        return 1;
-}
-
-static struct se_node_acl *sbp_alloc_fabric_acl(struct se_portal_group *se_tpg)
-{
-        struct sbp_nacl *nacl;
-
-        nacl = kzalloc(sizeof(struct sbp_nacl), GFP_KERNEL);
-        if (!nacl) {
-                pr_err("Unable to allocate struct sbp_nacl\n");
-                return NULL;
-        }
-
-        return &nacl->se_node_acl;
-}
-
-static void sbp_release_fabric_acl(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl)
-{
-        struct sbp_nacl *nacl =
-                container_of(se_nacl, struct sbp_nacl, se_node_acl);
-        kfree(nacl);
-}
-
 static u32 sbp_tpg_get_inst_index(struct se_portal_group *se_tpg)
 {
         return 1;
@@ -1795,15 +1768,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;
@@ -1859,106 +1823,23 @@ static int sbp_check_stop_free(struct se_cmd *se_cmd)
         return 1;
 }
 
-/*
- * Handlers for Serial Bus Protocol 2/3 (SBP-2 / SBP-3)
- */
-static u8 sbp_get_fabric_proto_ident(struct se_portal_group *se_tpg)
-{
-        /*
-         * Return a IEEE 1394 SCSI Protocol identifier for loopback operations
-         * This is defined in section 7.5.1 Table 362 in spc4r17
-         */
-        return SCSI_PROTOCOL_SBP;
-}
-
-static u32 sbp_get_pr_transport_id(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl,
-        struct t10_pr_registration *pr_reg,
-        int *format_code,
-        unsigned char *buf)
-{
-        int ret;
-
-        /*
-         * Set PROTOCOL IDENTIFIER to 3h for SBP
-         */
-        buf[0] = SCSI_PROTOCOL_SBP;
-        /*
-         * From spc4r17, 7.5.4.4 TransportID for initiator ports using SCSI
-         * over IEEE 1394
-         */
-        ret = hex2bin(&buf[8], se_nacl->initiatorname, 8);
-        if (ret < 0)
-                pr_debug("sbp transport_id: invalid hex string\n");
-
-        /*
-         * The IEEE 1394 Transport ID is a hardcoded 24-byte length
-         */
-        return 24;
-}
-
-static u32 sbp_get_pr_transport_id_len(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl,
-        struct t10_pr_registration *pr_reg,
-        int *format_code)
-{
-        *format_code = 0;
-        /*
-         * From spc4r17, 7.5.4.4 TransportID for initiator ports using SCSI
-         * over IEEE 1394
-         *
-         * The SBP Transport ID is a hardcoded 24-byte length
-         */
-        return 24;
-}
-
-/*
- * Used for handling SCSI fabric dependent TransportIDs in SPC-3 and above
- * Persistent Reservation SPEC_I_PT=1 and PROUT REGISTER_AND_MOVE operations.
- */
-static char *sbp_parse_pr_out_transport_id(
-        struct se_portal_group *se_tpg,
-        const char *buf,
-        u32 *out_tid_len,
-        char **port_nexus_ptr)
-{
-        /*
-         * Assume the FORMAT CODE 00b from spc4r17, 7.5.4.4 TransportID
-         * for initiator ports using SCSI over SBP Serial SCSI Protocol
-         *
-         * The TransportID for a IEEE 1394 Initiator Port is of fixed size of
-         * 24 bytes, and IEEE 1394 does not contain a I_T nexus identifier,
-         * so we return the **port_nexus_ptr set to NULL.
-         */
-        *port_nexus_ptr = NULL;
-        *out_tid_len = 24;
-
-        return (char *)&buf[8];
-}
-
 static int sbp_count_se_tpg_luns(struct se_portal_group *tpg)
 {
-        int i, count = 0;
-
-        spin_lock(&tpg->tpg_lun_lock);
-        for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
-                struct se_lun *se_lun = tpg->tpg_lun_list[i];
-
-                if (se_lun->lun_status == TRANSPORT_LUN_STATUS_FREE)
-                        continue;
+        struct se_lun *lun;
+        int count = 0;
 
+        rcu_read_lock();
+        hlist_for_each_entry_rcu(lun, &tpg->tpg_lun_hlist, link)
                 count++;
-        }
-        spin_unlock(&tpg->tpg_lun_lock);
+        rcu_read_unlock();
 
         return count;
 }
 
 static int sbp_update_unit_directory(struct sbp_tport *tport)
 {
-        int num_luns, num_entries, idx = 0, mgt_agt_addr, ret, i;
+        struct se_lun *lun;
+        int num_luns, num_entries, idx = 0, mgt_agt_addr, ret;
         u32 *data;
 
         if (tport->unit_directory.data) {
@@ -2020,28 +1901,23 @@ static int sbp_update_unit_directory(struct sbp_tport *tport)
         /* unit unique ID (leaf is just after LUNs) */
         data[idx++] = 0x8d000000 | (num_luns + 1);
 
-        spin_lock(&tport->tpg->se_tpg.tpg_lun_lock);
-        for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
-                struct se_lun *se_lun = tport->tpg->se_tpg.tpg_lun_list[i];
+        rcu_read_lock();
+        hlist_for_each_entry_rcu(lun, &tport->tpg->se_tpg.tpg_lun_hlist, link) {
                 struct se_device *dev;
                 int type;
-
-                if (se_lun->lun_status == TRANSPORT_LUN_STATUS_FREE)
-                        continue;
-
-                spin_unlock(&tport->tpg->se_tpg.tpg_lun_lock);
-
-                dev = se_lun->lun_se_dev;
+                /*
+                 * rcu_dereference_raw protected by se_lun->lun_group symlink
+                 * reference to se_device->dev_group.
+                 */
+                dev = rcu_dereference_raw(lun->lun_se_dev);
                 type = dev->transport->get_device_type(dev);
 
                 /* logical_unit_number */
                 data[idx++] = 0x14000000 |
                         ((type << 16) & 0x1f0000) |
-                        (se_lun->unpacked_lun & 0xffff);
-
-                spin_lock(&tport->tpg->se_tpg.tpg_lun_lock);
+                        (lun->unpacked_lun & 0xffff);
         }
-        spin_unlock(&tport->tpg->se_tpg.tpg_lun_lock);
+        rcu_read_unlock();
 
         /* unit unique ID leaf */
         data[idx++] = 2 << 16;
@@ -2100,48 +1976,13 @@ static ssize_t sbp_format_wwn(char *buf, size_t len, u64 wwn)
         return snprintf(buf, len, "%016llx", wwn);
 }
 
-static struct se_node_acl *sbp_make_nodeacl(
-                struct se_portal_group *se_tpg,
-                struct config_group *group,
-                const char *name)
+static int sbp_init_nodeacl(struct se_node_acl *se_nacl, const char *name)
 {
-        struct se_node_acl *se_nacl, *se_nacl_new;
-        struct sbp_nacl *nacl;
         u64 guid = 0;
-        u32 nexus_depth = 1;
 
         if (sbp_parse_wwn(name, &guid) < 0)
-                return ERR_PTR(-EINVAL);
-
-        se_nacl_new = sbp_alloc_fabric_acl(se_tpg);
-        if (!se_nacl_new)
-                return ERR_PTR(-ENOMEM);
-
-        /*
-         * se_nacl_new may be released by core_tpg_add_initiator_node_acl()
-         * when converting a NodeACL from demo mode -> explict
-         */
-        se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new,
-                        name, nexus_depth);
-        if (IS_ERR(se_nacl)) {
-                sbp_release_fabric_acl(se_tpg, se_nacl_new);
-                return se_nacl;
-        }
-
-        nacl = container_of(se_nacl, struct sbp_nacl, se_node_acl);
-        nacl->guid = guid;
-        sbp_format_wwn(nacl->iport_name, SBP_NAMELEN, guid);
-
-        return se_nacl;
-}
-
-static void sbp_drop_nodeacl(struct se_node_acl *se_acl)
-{
-        struct sbp_nacl *nacl =
-                container_of(se_acl, struct sbp_nacl, se_node_acl);
-
-        core_tpg_del_initiator_node_acl(se_acl->se_tpg, se_acl, 1);
-        kfree(nacl);
+                return -EINVAL;
+        return 0;
 }
 
 static int sbp_post_link_lun(
@@ -2214,8 +2055,7 @@ static struct se_portal_group *sbp_make_tpg(
                 goto out_free_tpg;
         }
 
-        ret = core_tpg_register(&sbp_ops, wwn, &tpg->se_tpg, tpg,
-                        TRANSPORT_TPG_TYPE_NORMAL);
+        ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_SBP);
         if (ret < 0)
                 goto out_unreg_mgt_agt;
 
@@ -2505,19 +2345,12 @@ static const struct target_core_fabric_ops sbp_ops = {
         .module                         = THIS_MODULE,
         .name                           = "sbp",
         .get_fabric_name                = sbp_get_fabric_name,
-        .get_fabric_proto_ident         = sbp_get_fabric_proto_ident,
         .tpg_get_wwn                    = sbp_get_fabric_wwn,
         .tpg_get_tag                    = sbp_get_tag,
-        .tpg_get_default_depth          = sbp_get_default_depth,
-        .tpg_get_pr_transport_id        = sbp_get_pr_transport_id,
-        .tpg_get_pr_transport_id_len    = sbp_get_pr_transport_id_len,
-        .tpg_parse_pr_out_transport_id  = sbp_parse_pr_out_transport_id,
         .tpg_check_demo_mode            = sbp_check_true,
         .tpg_check_demo_mode_cache      = sbp_check_true,
         .tpg_check_demo_mode_write_protect = sbp_check_false,
         .tpg_check_prod_mode_write_protect = sbp_check_false,
-        .tpg_alloc_fabric_acl           = sbp_alloc_fabric_acl,
-        .tpg_release_fabric_acl         = sbp_release_fabric_acl,
         .tpg_get_inst_index             = sbp_tpg_get_inst_index,
         .release_cmd                    = sbp_release_cmd,
         .shutdown_session               = sbp_shutdown_session,
@@ -2526,7 +2359,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,
@@ -2542,8 +2374,7 @@ static const struct target_core_fabric_ops sbp_ops = {
         .fabric_pre_unlink              = sbp_pre_unlink_lun,
         .fabric_make_np                 = NULL,
         .fabric_drop_np                 = NULL,
-        .fabric_make_nodeacl            = sbp_make_nodeacl,
-        .fabric_drop_nodeacl            = sbp_drop_nodeacl,
+        .fabric_init_nodeacl            = sbp_init_nodeacl,
 
         .tfc_wwn_attrs                  = sbp_wwn_attrs,
         .tfc_tpg_base_attrs             = sbp_tpg_base_attrs,
diff --git a/drivers/target/sbp/sbp_target.h b/drivers/target/sbp/sbp_target.h
index 6d0d74a2c545..73bcb1208832 100644
--- a/drivers/target/sbp/sbp_target.h
+++ b/drivers/target/sbp/sbp_target.h
@@ -125,7 +125,7 @@ struct sbp_login_descriptor {
         struct sbp_session *sess;
         struct list_head link;
 
-        struct se_lun *lun;
+        u32 login_lun;
 
         u64 status_fifo_addr;
         int exclusive;
@@ -151,15 +151,6 @@ struct sbp_session {
         u64 reconnect_expires;
 };
 
-struct sbp_nacl {
-        /* Initiator EUI-64 */
-        u64 guid;
-        /* ASCII formatted GUID for SBP Initiator port */
-        char iport_name[SBP_NAMELEN];
-        /* Returned by sbp_make_nodeacl() */
-        struct se_node_acl se_node_acl;
-};
-
 struct sbp_tpg {
         /* Target portal group tag for TCM */
         u16 tport_tpgt;
diff --git a/drivers/target/target_core_alua.c b/drivers/target/target_core_alua.c
index 8ca373774276..49aba4a31747 100644
--- a/drivers/target/target_core_alua.c
+++ b/drivers/target/target_core_alua.c
@@ -34,7 +34,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 
 #include "target_core_internal.h"
 #include "target_core_alua.h"
@@ -43,11 +42,13 @@
 static sense_reason_t core_alua_check_transition(int state, int valid,
                                                  int *primary);
 static int core_alua_set_tg_pt_secondary_state(
-                struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem,
-                struct se_port *port, int explicit, int offline);
+                struct se_lun *lun, int explicit, int offline);
 
 static char *core_alua_dump_state(int state);
 
+static void __target_attach_tg_pt_gp(struct se_lun *lun,
+                struct t10_alua_tg_pt_gp *tg_pt_gp);
+
 static u16 alua_lu_gps_counter;
 static u32 alua_lu_gps_count;
 
@@ -145,9 +146,8 @@ sense_reason_t
 target_emulate_report_target_port_groups(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
-        struct se_port *port;
         struct t10_alua_tg_pt_gp *tg_pt_gp;
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
+        struct se_lun *lun;
         unsigned char *buf;
         u32 rd_len = 0, off;
         int ext_hdr = (cmd->t_task_cdb[1] & 0x20);
@@ -222,9 +222,8 @@ target_emulate_report_target_port_groups(struct se_cmd *cmd)
                 rd_len += 8;
 
                 spin_lock(&tg_pt_gp->tg_pt_gp_lock);
-                list_for_each_entry(tg_pt_gp_mem, &tg_pt_gp->tg_pt_gp_mem_list,
-                                tg_pt_gp_mem_list) {
-                        port = tg_pt_gp_mem->tg_pt;
+                list_for_each_entry(lun, &tg_pt_gp->tg_pt_gp_lun_list,
+                                lun_tg_pt_gp_link) {
                         /*
                          * Start Target Port descriptor format
                          *
@@ -234,8 +233,8 @@ target_emulate_report_target_port_groups(struct se_cmd *cmd)
                         /*
                          * Set RELATIVE TARGET PORT IDENTIFIER
                          */
-                        buf[off++] = ((port->sep_rtpi >> 8) & 0xff);
-                        buf[off++] = (port->sep_rtpi & 0xff);
+                        buf[off++] = ((lun->lun_rtpi >> 8) & 0xff);
+                        buf[off++] = (lun->lun_rtpi & 0xff);
                         rd_len += 4;
                 }
                 spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
@@ -259,15 +258,11 @@ target_emulate_report_target_port_groups(struct se_cmd *cmd)
                  * this CDB was received upon to determine this value individually
                  * for ALUA target port group.
                  */
-                port = cmd->se_lun->lun_sep;
-                tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
-                if (tg_pt_gp_mem) {
-                        spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-                        tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
-                        if (tg_pt_gp)
-                                buf[5] = tg_pt_gp->tg_pt_gp_implicit_trans_secs;
-                        spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-                }
+                spin_lock(&cmd->se_lun->lun_tg_pt_gp_lock);
+                tg_pt_gp = cmd->se_lun->lun_tg_pt_gp;
+                if (tg_pt_gp)
+                        buf[5] = tg_pt_gp->tg_pt_gp_implicit_trans_secs;
+                spin_unlock(&cmd->se_lun->lun_tg_pt_gp_lock);
         }
         transport_kunmap_data_sg(cmd);
 
@@ -284,10 +279,9 @@ sense_reason_t
 target_emulate_set_target_port_groups(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
-        struct se_port *port, *l_port = cmd->se_lun->lun_sep;
+        struct se_lun *l_lun = cmd->se_lun;
         struct se_node_acl *nacl = cmd->se_sess->se_node_acl;
         struct t10_alua_tg_pt_gp *tg_pt_gp = NULL, *l_tg_pt_gp;
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem, *l_tg_pt_gp_mem;
         unsigned char *buf;
         unsigned char *ptr;
         sense_reason_t rc = TCM_NO_SENSE;
@@ -295,9 +289,6 @@ target_emulate_set_target_port_groups(struct se_cmd *cmd)
         int alua_access_state, primary = 0, valid_states;
         u16 tg_pt_id, rtpi;
 
-        if (!l_port)
-                return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
-
         if (cmd->data_length < 4) {
                 pr_warn("SET TARGET PORT GROUPS parameter list length %u too"
                         " small\n", cmd->data_length);
@@ -312,29 +303,24 @@ target_emulate_set_target_port_groups(struct se_cmd *cmd)
          * Determine if explicit ALUA via SET_TARGET_PORT_GROUPS is allowed
          * for the local tg_pt_gp.
          */
-        l_tg_pt_gp_mem = l_port->sep_alua_tg_pt_gp_mem;
-        if (!l_tg_pt_gp_mem) {
-                pr_err("Unable to access l_port->sep_alua_tg_pt_gp_mem\n");
-                rc = TCM_UNSUPPORTED_SCSI_OPCODE;
-                goto out;
-        }
-        spin_lock(&l_tg_pt_gp_mem->tg_pt_gp_mem_lock);
-        l_tg_pt_gp = l_tg_pt_gp_mem->tg_pt_gp;
+        spin_lock(&l_lun->lun_tg_pt_gp_lock);
+        l_tg_pt_gp = l_lun->lun_tg_pt_gp;
         if (!l_tg_pt_gp) {
-                spin_unlock(&l_tg_pt_gp_mem->tg_pt_gp_mem_lock);
-                pr_err("Unable to access *l_tg_pt_gp_mem->tg_pt_gp\n");
+                spin_unlock(&l_lun->lun_tg_pt_gp_lock);
+                pr_err("Unable to access l_lun->tg_pt_gp\n");
                 rc = TCM_UNSUPPORTED_SCSI_OPCODE;
                 goto out;
         }
-        spin_unlock(&l_tg_pt_gp_mem->tg_pt_gp_mem_lock);
 
         if (!(l_tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA)) {
+                spin_unlock(&l_lun->lun_tg_pt_gp_lock);
                 pr_debug("Unable to process SET_TARGET_PORT_GROUPS"
                                 " while TPGS_EXPLICIT_ALUA is disabled\n");
                 rc = TCM_UNSUPPORTED_SCSI_OPCODE;
                 goto out;
         }
         valid_states = l_tg_pt_gp->tg_pt_gp_alua_supported_states;
+        spin_unlock(&l_lun->lun_tg_pt_gp_lock);
 
         ptr = &buf[4]; /* Skip over RESERVED area in header */
 
@@ -396,7 +382,7 @@ target_emulate_set_target_port_groups(struct se_cmd *cmd)
                                 spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
 
                                 if (!core_alua_do_port_transition(tg_pt_gp,
-                                                dev, l_port, nacl,
+                                                dev, l_lun, nacl,
                                                 alua_access_state, 1))
                                         found = true;
 
@@ -406,6 +392,8 @@ target_emulate_set_target_port_groups(struct se_cmd *cmd)
                         }
                         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
                 } else {
+                        struct se_lun *lun;
+
                         /*
                          * Extract the RELATIVE TARGET PORT IDENTIFIER to identify
                          * the Target Port in question for the the incoming
@@ -417,17 +405,16 @@ target_emulate_set_target_port_groups(struct se_cmd *cmd)
                          * for the struct se_device storage object.
                          */
                         spin_lock(&dev->se_port_lock);
-                        list_for_each_entry(port, &dev->dev_sep_list,
-                                                        sep_list) {
-                                if (port->sep_rtpi != rtpi)
+                        list_for_each_entry(lun, &dev->dev_sep_list,
+                                                        lun_dev_link) {
+                                if (lun->lun_rtpi != rtpi)
                                         continue;
 
-                                tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
-
+                                // XXX: racy unlock
                                 spin_unlock(&dev->se_port_lock);
 
                                 if (!core_alua_set_tg_pt_secondary_state(
-                                                tg_pt_gp_mem, port, 1, 1))
+                                                lun, 1, 1))
                                         found = true;
 
                                 spin_lock(&dev->se_port_lock);
@@ -696,9 +683,7 @@ 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;
 
         if (dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE)
@@ -706,33 +691,27 @@ target_alua_state_check(struct se_cmd *cmd)
         if (dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH)
                 return 0;
 
-        if (!port)
-                return 0;
         /*
          * First, check for a struct se_port specific secondary ALUA target port
          * access state: OFFLINE
          */
-        if (atomic_read(&port->sep_tg_pt_secondary_offline)) {
+        if (atomic_read(&lun->lun_tg_pt_secondary_offline)) {
                 pr_debug("ALUA: Got secondary offline status for local"
                                 " target port\n");
                 set_ascq(cmd, ASCQ_04H_ALUA_OFFLINE);
                 return TCM_CHECK_CONDITION_NOT_READY;
         }
-         /*
-         * Second, obtain the struct t10_alua_tg_pt_gp_member pointer to the
-         * ALUA target port group, to obtain current ALUA access state.
-         * Otherwise look for the underlying struct se_device association with
-         * a ALUA logical unit group.
-         */
-        tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
-        if (!tg_pt_gp_mem)
+
+        if (!lun->lun_tg_pt_gp)
                 return 0;
 
-        spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-        tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
+        spin_lock(&lun->lun_tg_pt_gp_lock);
+        tg_pt_gp = lun->lun_tg_pt_gp;
         out_alua_state = atomic_read(&tg_pt_gp->tg_pt_gp_alua_access_state);
         nonop_delay_msecs = tg_pt_gp->tg_pt_gp_nonop_delay_msecs;
-        spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
+
+        // XXX: keeps using tg_pt_gp witout reference after unlock
+        spin_unlock(&lun->lun_tg_pt_gp_lock);
         /*
          * Process ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED in a separate conditional
          * statement so the compiler knows explicitly to check this case first.
@@ -764,7 +743,7 @@ target_alua_state_check(struct se_cmd *cmd)
                 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
+         * handled above with struct se_lun->lun_tg_pt_secondary_offline=1
          */
         case ALUA_ACCESS_STATE_OFFLINE:
         default:
@@ -906,10 +885,6 @@ int core_alua_check_nonop_delay(
 }
 EXPORT_SYMBOL(core_alua_check_nonop_delay);
 
-/*
- * Called with tg_pt_gp->tg_pt_gp_md_mutex or tg_pt_gp_mem->sep_tg_pt_md_mutex
- *
- */
 static int core_alua_write_tpg_metadata(
         const char *path,
         unsigned char *md_buf,
@@ -965,22 +940,15 @@ static int core_alua_update_tpg_primary_metadata(
         return rc;
 }
 
-static void core_alua_do_transition_tg_pt_work(struct work_struct *work)
+static void core_alua_queue_state_change_ua(struct t10_alua_tg_pt_gp *tg_pt_gp)
 {
-        struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(work,
-                struct t10_alua_tg_pt_gp, tg_pt_gp_transition_work.work);
-        struct se_device *dev = tg_pt_gp->tg_pt_gp_dev;
         struct se_dev_entry *se_deve;
+        struct se_lun *lun;
         struct se_lun_acl *lacl;
-        struct se_port *port;
-        struct t10_alua_tg_pt_gp_member *mem;
-        bool explicit = (tg_pt_gp->tg_pt_gp_alua_access_status ==
-                         ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG);
 
         spin_lock(&tg_pt_gp->tg_pt_gp_lock);
-        list_for_each_entry(mem, &tg_pt_gp->tg_pt_gp_mem_list,
-                                tg_pt_gp_mem_list) {
-                port = mem->tg_pt;
+        list_for_each_entry(lun, &tg_pt_gp->tg_pt_gp_lun_list,
+                                lun_tg_pt_gp_link) {
                 /*
                  * After an implicit target port asymmetric access state
                  * change, a device server shall establish a unit attention
@@ -995,38 +963,58 @@ static void core_alua_do_transition_tg_pt_work(struct work_struct *work)
                  * every I_T nexus other than the I_T nexus on which the SET
                  * TARGET PORT GROUPS command
                  */
-                atomic_inc_mb(&mem->tg_pt_gp_mem_ref_cnt);
+                if (!percpu_ref_tryget_live(&lun->lun_ref))
+                        continue;
                 spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
 
-                spin_lock_bh(&port->sep_alua_lock);
-                list_for_each_entry(se_deve, &port->sep_alua_list,
-                                        alua_port_list) {
-                        lacl = se_deve->se_lun_acl;
+                spin_lock(&lun->lun_deve_lock);
+                list_for_each_entry(se_deve, &lun->lun_deve_list, lun_link) {
+                        lacl = rcu_dereference_check(se_deve->se_lun_acl,
+                                        lockdep_is_held(&lun->lun_deve_lock));
+
                         /*
-                         * se_deve->se_lun_acl pointer may be NULL for a
-                         * entry created without explicit Node+MappedLUN ACLs
+                         * spc4r37 p.242:
+                         * After an explicit target port asymmetric access
+                         * state change, a device server shall establish a
+                         * unit attention condition with the additional sense
+                         * code set to ASYMMETRIC ACCESS STATE CHANGED for
+                         * the initiator port associated with every I_T nexus
+                         * other than the I_T nexus on which the SET TARGET
+                         * PORT GROUPS command was received.
                          */
-                        if (!lacl)
-                                continue;
-
                         if ((tg_pt_gp->tg_pt_gp_alua_access_status ==
                              ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG) &&
-                           (tg_pt_gp->tg_pt_gp_alua_nacl != NULL) &&
-                            (tg_pt_gp->tg_pt_gp_alua_nacl == lacl->se_lun_nacl) &&
-                           (tg_pt_gp->tg_pt_gp_alua_port != NULL) &&
-                            (tg_pt_gp->tg_pt_gp_alua_port == port))
+                           (tg_pt_gp->tg_pt_gp_alua_lun != NULL) &&
+                            (tg_pt_gp->tg_pt_gp_alua_lun == lun))
                                 continue;
 
-                        core_scsi3_ua_allocate(lacl->se_lun_nacl,
-                                se_deve->mapped_lun, 0x2A,
+                        /*
+                         * se_deve->se_lun_acl pointer may be NULL for a
+                         * entry created without explicit Node+MappedLUN ACLs
+                         */
+                        if (lacl && (tg_pt_gp->tg_pt_gp_alua_nacl != NULL) &&
+                            (tg_pt_gp->tg_pt_gp_alua_nacl == lacl->se_lun_nacl))
+                                continue;
+
+                        core_scsi3_ua_allocate(se_deve, 0x2A,
                                 ASCQ_2AH_ASYMMETRIC_ACCESS_STATE_CHANGED);
                 }
-                spin_unlock_bh(&port->sep_alua_lock);
+                spin_unlock(&lun->lun_deve_lock);
 
                 spin_lock(&tg_pt_gp->tg_pt_gp_lock);
-                atomic_dec_mb(&mem->tg_pt_gp_mem_ref_cnt);
+                percpu_ref_put(&lun->lun_ref);
         }
         spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
+}
+
+static void core_alua_do_transition_tg_pt_work(struct work_struct *work)
+{
+        struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(work,
+                struct t10_alua_tg_pt_gp, tg_pt_gp_transition_work.work);
+        struct se_device *dev = tg_pt_gp->tg_pt_gp_dev;
+        bool explicit = (tg_pt_gp->tg_pt_gp_alua_access_status ==
+                         ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG);
+
         /*
          * Update the ALUA metadata buf that has been allocated in
          * core_alua_do_port_transition(), this metadata will be written
@@ -1056,6 +1044,9 @@ static void core_alua_do_transition_tg_pt_work(struct work_struct *work)
                 tg_pt_gp->tg_pt_gp_id,
                 core_alua_dump_state(tg_pt_gp->tg_pt_gp_alua_previous_state),
                 core_alua_dump_state(tg_pt_gp->tg_pt_gp_alua_pending_state));
+
+        core_alua_queue_state_change_ua(tg_pt_gp);
+
         spin_lock(&dev->t10_alua.tg_pt_gps_lock);
         atomic_dec(&tg_pt_gp->tg_pt_gp_ref_cnt);
         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
@@ -1108,6 +1099,8 @@ static int core_alua_do_transition_tg_pt(
                                 ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG :
                                 ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA;
 
+        core_alua_queue_state_change_ua(tg_pt_gp);
+
         /*
          * Check for the optional ALUA primary state transition delay
          */
@@ -1142,7 +1135,7 @@ static int core_alua_do_transition_tg_pt(
 int core_alua_do_port_transition(
         struct t10_alua_tg_pt_gp *l_tg_pt_gp,
         struct se_device *l_dev,
-        struct se_port *l_port,
+        struct se_lun *l_lun,
         struct se_node_acl *l_nacl,
         int new_state,
         int explicit)
@@ -1172,7 +1165,7 @@ int core_alua_do_port_transition(
                  * core_alua_do_transition_tg_pt() will always return
                  * success.
                  */
-                l_tg_pt_gp->tg_pt_gp_alua_port = l_port;
+                l_tg_pt_gp->tg_pt_gp_alua_lun = l_lun;
                 l_tg_pt_gp->tg_pt_gp_alua_nacl = l_nacl;
                 rc = core_alua_do_transition_tg_pt(l_tg_pt_gp,
                                                    new_state, explicit);
@@ -1211,10 +1204,10 @@ int core_alua_do_port_transition(
                                 continue;
 
                         if (l_tg_pt_gp == tg_pt_gp) {
-                                tg_pt_gp->tg_pt_gp_alua_port = l_port;
+                                tg_pt_gp->tg_pt_gp_alua_lun = l_lun;
                                 tg_pt_gp->tg_pt_gp_alua_nacl = l_nacl;
                         } else {
-                                tg_pt_gp->tg_pt_gp_alua_port = NULL;
+                                tg_pt_gp->tg_pt_gp_alua_lun = NULL;
                                 tg_pt_gp->tg_pt_gp_alua_nacl = NULL;
                         }
                         atomic_inc_mb(&tg_pt_gp->tg_pt_gp_ref_cnt);
@@ -1251,22 +1244,20 @@ int core_alua_do_port_transition(
         return rc;
 }
 
-/*
- * Called with tg_pt_gp_mem->sep_tg_pt_md_mutex held
- */
-static int core_alua_update_tpg_secondary_metadata(
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem,
-        struct se_port *port)
+static int core_alua_update_tpg_secondary_metadata(struct se_lun *lun)
 {
+        struct se_portal_group *se_tpg = lun->lun_tpg;
         unsigned char *md_buf;
-        struct se_portal_group *se_tpg = port->sep_tpg;
         char path[ALUA_METADATA_PATH_LEN], wwn[ALUA_SECONDARY_METADATA_WWN_LEN];
         int len, rc;
 
+        mutex_lock(&lun->lun_tg_pt_md_mutex);
+
         md_buf = kzalloc(ALUA_MD_BUF_LEN, GFP_KERNEL);
         if (!md_buf) {
                 pr_err("Unable to allocate buf for ALUA metadata\n");
-                return -ENOMEM;
+                rc = -ENOMEM;
+                goto out_unlock;
         }
 
         memset(path, 0, ALUA_METADATA_PATH_LEN);
@@ -1281,32 +1272,33 @@ static int core_alua_update_tpg_secondary_metadata(
 
         len = snprintf(md_buf, ALUA_MD_BUF_LEN, "alua_tg_pt_offline=%d\n"
                         "alua_tg_pt_status=0x%02x\n",
-                        atomic_read(&port->sep_tg_pt_secondary_offline),
-                        port->sep_tg_pt_secondary_stat);
+                        atomic_read(&lun->lun_tg_pt_secondary_offline),
+                        lun->lun_tg_pt_secondary_stat);
 
-        snprintf(path, ALUA_METADATA_PATH_LEN, "/var/target/alua/%s/%s/lun_%u",
+        snprintf(path, ALUA_METADATA_PATH_LEN, "/var/target/alua/%s/%s/lun_%llu",
                         se_tpg->se_tpg_tfo->get_fabric_name(), wwn,
-                        port->sep_lun->unpacked_lun);
+                        lun->unpacked_lun);
 
         rc = core_alua_write_tpg_metadata(path, md_buf, len);
         kfree(md_buf);
 
+out_unlock:
+        mutex_unlock(&lun->lun_tg_pt_md_mutex);
         return rc;
 }
 
 static int core_alua_set_tg_pt_secondary_state(
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem,
-        struct se_port *port,
+        struct se_lun *lun,
         int explicit,
         int offline)
 {
         struct t10_alua_tg_pt_gp *tg_pt_gp;
         int trans_delay_msecs;
 
-        spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-        tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
+        spin_lock(&lun->lun_tg_pt_gp_lock);
+        tg_pt_gp = lun->lun_tg_pt_gp;
         if (!tg_pt_gp) {
-                spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
+                spin_unlock(&lun->lun_tg_pt_gp_lock);
                 pr_err("Unable to complete secondary state"
                                 " transition\n");
                 return -EINVAL;
@@ -1314,14 +1306,14 @@ static int core_alua_set_tg_pt_secondary_state(
         trans_delay_msecs = tg_pt_gp->tg_pt_gp_trans_delay_msecs;
         /*
          * Set the secondary ALUA target port access state to OFFLINE
-         * or release the previously secondary state for struct se_port
+         * or release the previously secondary state for struct se_lun
          */
         if (offline)
-                atomic_set(&port->sep_tg_pt_secondary_offline, 1);
+                atomic_set(&lun->lun_tg_pt_secondary_offline, 1);
         else
-                atomic_set(&port->sep_tg_pt_secondary_offline, 0);
+                atomic_set(&lun->lun_tg_pt_secondary_offline, 0);
 
-        port->sep_tg_pt_secondary_stat = (explicit) ?
+        lun->lun_tg_pt_secondary_stat = (explicit) ?
                         ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG :
                         ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA;
 
@@ -1330,7 +1322,7 @@ static int core_alua_set_tg_pt_secondary_state(
                 "implicit", config_item_name(&tg_pt_gp->tg_pt_gp_group.cg_item),
                 tg_pt_gp->tg_pt_gp_id, (offline) ? "OFFLINE" : "ONLINE");
 
-        spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
+        spin_unlock(&lun->lun_tg_pt_gp_lock);
         /*
          * Do the optional transition delay after we set the secondary
          * ALUA access state.
@@ -1341,11 +1333,8 @@ static int core_alua_set_tg_pt_secondary_state(
          * See if we need to update the ALUA fabric port metadata for
          * secondary state and status
          */
-        if (port->sep_tg_pt_secondary_write_md) {
-                mutex_lock(&port->sep_tg_pt_md_mutex);
-                core_alua_update_tpg_secondary_metadata(tg_pt_gp_mem, port);
-                mutex_unlock(&port->sep_tg_pt_md_mutex);
-        }
+        if (lun->lun_tg_pt_secondary_write_md)
+                core_alua_update_tpg_secondary_metadata(lun);
 
         return 0;
 }
@@ -1699,7 +1688,7 @@ struct t10_alua_tg_pt_gp *core_alua_allocate_tg_pt_gp(struct se_device *dev,
                 return NULL;
         }
         INIT_LIST_HEAD(&tg_pt_gp->tg_pt_gp_list);
-        INIT_LIST_HEAD(&tg_pt_gp->tg_pt_gp_mem_list);
+        INIT_LIST_HEAD(&tg_pt_gp->tg_pt_gp_lun_list);
         mutex_init(&tg_pt_gp->tg_pt_gp_md_mutex);
         spin_lock_init(&tg_pt_gp->tg_pt_gp_lock);
         atomic_set(&tg_pt_gp->tg_pt_gp_ref_cnt, 0);
@@ -1793,32 +1782,11 @@ again:
         return 0;
 }
 
-struct t10_alua_tg_pt_gp_member *core_alua_allocate_tg_pt_gp_mem(
-        struct se_port *port)
-{
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
-
-        tg_pt_gp_mem = kmem_cache_zalloc(t10_alua_tg_pt_gp_mem_cache,
-                                GFP_KERNEL);
-        if (!tg_pt_gp_mem) {
-                pr_err("Unable to allocate struct t10_alua_tg_pt_gp_member\n");
-                return ERR_PTR(-ENOMEM);
-        }
-        INIT_LIST_HEAD(&tg_pt_gp_mem->tg_pt_gp_mem_list);
-        spin_lock_init(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-        atomic_set(&tg_pt_gp_mem->tg_pt_gp_mem_ref_cnt, 0);
-
-        tg_pt_gp_mem->tg_pt = port;
-        port->sep_alua_tg_pt_gp_mem = tg_pt_gp_mem;
-
-        return tg_pt_gp_mem;
-}
-
 void core_alua_free_tg_pt_gp(
         struct t10_alua_tg_pt_gp *tg_pt_gp)
 {
         struct se_device *dev = tg_pt_gp->tg_pt_gp_dev;
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem, *tg_pt_gp_mem_tmp;
+        struct se_lun *lun, *next;
 
         /*
          * Once we have reached this point, config_item_put() has already
@@ -1849,30 +1817,24 @@ void core_alua_free_tg_pt_gp(
          * struct se_port.
          */
         spin_lock(&tg_pt_gp->tg_pt_gp_lock);
-        list_for_each_entry_safe(tg_pt_gp_mem, tg_pt_gp_mem_tmp,
-                        &tg_pt_gp->tg_pt_gp_mem_list, tg_pt_gp_mem_list) {
-                if (tg_pt_gp_mem->tg_pt_gp_assoc) {
-                        list_del(&tg_pt_gp_mem->tg_pt_gp_mem_list);
-                        tg_pt_gp->tg_pt_gp_members--;
-                        tg_pt_gp_mem->tg_pt_gp_assoc = 0;
-                }
+        list_for_each_entry_safe(lun, next,
+                        &tg_pt_gp->tg_pt_gp_lun_list, lun_tg_pt_gp_link) {
+                list_del_init(&lun->lun_tg_pt_gp_link);
+                tg_pt_gp->tg_pt_gp_members--;
+
                 spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
                 /*
-                 * tg_pt_gp_mem is associated with a single
-                 * se_port->sep_alua_tg_pt_gp_mem, and is released via
-                 * core_alua_free_tg_pt_gp_mem().
-                 *
                  * If the passed tg_pt_gp does NOT match the default_tg_pt_gp,
                  * assume we want to re-associate a given tg_pt_gp_mem with
                  * default_tg_pt_gp.
                  */
-                spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
+                spin_lock(&lun->lun_tg_pt_gp_lock);
                 if (tg_pt_gp != dev->t10_alua.default_tg_pt_gp) {
-                        __core_alua_attach_tg_pt_gp_mem(tg_pt_gp_mem,
+                        __target_attach_tg_pt_gp(lun,
                                         dev->t10_alua.default_tg_pt_gp);
                 } else
-                        tg_pt_gp_mem->tg_pt_gp = NULL;
-                spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
+                        lun->lun_tg_pt_gp = NULL;
+                spin_unlock(&lun->lun_tg_pt_gp_lock);
 
                 spin_lock(&tg_pt_gp->tg_pt_gp_lock);
         }
@@ -1881,35 +1843,6 @@ void core_alua_free_tg_pt_gp(
         kmem_cache_free(t10_alua_tg_pt_gp_cache, tg_pt_gp);
 }
 
-void core_alua_free_tg_pt_gp_mem(struct se_port *port)
-{
-        struct t10_alua_tg_pt_gp *tg_pt_gp;
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
-
-        tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
-        if (!tg_pt_gp_mem)
-                return;
-
-        while (atomic_read(&tg_pt_gp_mem->tg_pt_gp_mem_ref_cnt))
-                cpu_relax();
-
-        spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-        tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
-        if (tg_pt_gp) {
-                spin_lock(&tg_pt_gp->tg_pt_gp_lock);
-                if (tg_pt_gp_mem->tg_pt_gp_assoc) {
-                        list_del(&tg_pt_gp_mem->tg_pt_gp_mem_list);
-                        tg_pt_gp->tg_pt_gp_members--;
-                        tg_pt_gp_mem->tg_pt_gp_assoc = 0;
-                }
-                spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
-                tg_pt_gp_mem->tg_pt_gp = NULL;
-        }
-        spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-
-        kmem_cache_free(t10_alua_tg_pt_gp_mem_cache, tg_pt_gp_mem);
-}
-
 static struct t10_alua_tg_pt_gp *core_alua_get_tg_pt_gp_by_name(
                 struct se_device *dev, const char *name)
 {
@@ -1943,50 +1876,65 @@ static void core_alua_put_tg_pt_gp_from_name(
         spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
 }
 
-/*
- * Called with struct t10_alua_tg_pt_gp_member->tg_pt_gp_mem_lock held
- */
-void __core_alua_attach_tg_pt_gp_mem(
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem,
-        struct t10_alua_tg_pt_gp *tg_pt_gp)
+static void __target_attach_tg_pt_gp(struct se_lun *lun,
+                struct t10_alua_tg_pt_gp *tg_pt_gp)
 {
+        struct se_dev_entry *se_deve;
+
+        assert_spin_locked(&lun->lun_tg_pt_gp_lock);
+
         spin_lock(&tg_pt_gp->tg_pt_gp_lock);
-        tg_pt_gp_mem->tg_pt_gp = tg_pt_gp;
-        tg_pt_gp_mem->tg_pt_gp_assoc = 1;
-        list_add_tail(&tg_pt_gp_mem->tg_pt_gp_mem_list,
-                        &tg_pt_gp->tg_pt_gp_mem_list);
+        lun->lun_tg_pt_gp = tg_pt_gp;
+        list_add_tail(&lun->lun_tg_pt_gp_link, &tg_pt_gp->tg_pt_gp_lun_list);
         tg_pt_gp->tg_pt_gp_members++;
+        spin_lock(&lun->lun_deve_lock);
+        list_for_each_entry(se_deve, &lun->lun_deve_list, lun_link)
+                core_scsi3_ua_allocate(se_deve, 0x3f,
+                                       ASCQ_3FH_INQUIRY_DATA_HAS_CHANGED);
+        spin_unlock(&lun->lun_deve_lock);
         spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
 }
 
-/*
- * Called with struct t10_alua_tg_pt_gp_member->tg_pt_gp_mem_lock held
- */
-static void __core_alua_drop_tg_pt_gp_mem(
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem,
-        struct t10_alua_tg_pt_gp *tg_pt_gp)
+void target_attach_tg_pt_gp(struct se_lun *lun,
+                struct t10_alua_tg_pt_gp *tg_pt_gp)
 {
+        spin_lock(&lun->lun_tg_pt_gp_lock);
+        __target_attach_tg_pt_gp(lun, tg_pt_gp);
+        spin_unlock(&lun->lun_tg_pt_gp_lock);
+}
+
+static void __target_detach_tg_pt_gp(struct se_lun *lun,
+                struct t10_alua_tg_pt_gp *tg_pt_gp)
+{
+        assert_spin_locked(&lun->lun_tg_pt_gp_lock);
+
         spin_lock(&tg_pt_gp->tg_pt_gp_lock);
-        list_del(&tg_pt_gp_mem->tg_pt_gp_mem_list);
-        tg_pt_gp_mem->tg_pt_gp = NULL;
-        tg_pt_gp_mem->tg_pt_gp_assoc = 0;
+        list_del_init(&lun->lun_tg_pt_gp_link);
         tg_pt_gp->tg_pt_gp_members--;
         spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
+
+        lun->lun_tg_pt_gp = NULL;
 }
 
-ssize_t core_alua_show_tg_pt_gp_info(struct se_port *port, char *page)
+void target_detach_tg_pt_gp(struct se_lun *lun)
+{
+        struct t10_alua_tg_pt_gp *tg_pt_gp;
+
+        spin_lock(&lun->lun_tg_pt_gp_lock);
+        tg_pt_gp = lun->lun_tg_pt_gp;
+        if (tg_pt_gp)
+                __target_detach_tg_pt_gp(lun, tg_pt_gp);
+        spin_unlock(&lun->lun_tg_pt_gp_lock);
+}
+
+ssize_t core_alua_show_tg_pt_gp_info(struct se_lun *lun, char *page)
 {
         struct config_item *tg_pt_ci;
         struct t10_alua_tg_pt_gp *tg_pt_gp;
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
         ssize_t len = 0;
 
-        tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
-        if (!tg_pt_gp_mem)
-                return len;
-
-        spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-        tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
+        spin_lock(&lun->lun_tg_pt_gp_lock);
+        tg_pt_gp = lun->lun_tg_pt_gp;
         if (tg_pt_gp) {
                 tg_pt_ci = &tg_pt_gp->tg_pt_gp_group.cg_item;
                 len += sprintf(page, "TG Port Alias: %s\nTG Port Group ID:"
@@ -1998,34 +1946,33 @@ ssize_t core_alua_show_tg_pt_gp_info(struct se_port *port, char *page)
                                         &tg_pt_gp->tg_pt_gp_alua_access_state)),
                         core_alua_dump_status(
                                 tg_pt_gp->tg_pt_gp_alua_access_status),
-                        (atomic_read(&port->sep_tg_pt_secondary_offline)) ?
+                        atomic_read(&lun->lun_tg_pt_secondary_offline) ?
                         "Offline" : "None",
-                        core_alua_dump_status(port->sep_tg_pt_secondary_stat));
+                        core_alua_dump_status(lun->lun_tg_pt_secondary_stat));
         }
-        spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
+        spin_unlock(&lun->lun_tg_pt_gp_lock);
 
         return len;
 }
 
 ssize_t core_alua_store_tg_pt_gp_info(
-        struct se_port *port,
+        struct se_lun *lun,
         const char *page,
         size_t count)
 {
-        struct se_portal_group *tpg;
-        struct se_lun *lun;
-        struct se_device *dev = port->sep_lun->lun_se_dev;
+        struct se_portal_group *tpg = lun->lun_tpg;
+        /*
+         * rcu_dereference_raw protected by se_lun->lun_group symlink
+         * reference to se_device->dev_group.
+         */
+        struct se_device *dev = rcu_dereference_raw(lun->lun_se_dev);
         struct t10_alua_tg_pt_gp *tg_pt_gp = NULL, *tg_pt_gp_new = NULL;
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
         unsigned char buf[TG_PT_GROUP_NAME_BUF];
         int move = 0;
 
-        tpg = port->sep_tpg;
-        lun = port->sep_lun;
-
-        tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
-        if (!tg_pt_gp_mem)
-                return 0;
+        if (dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH ||
+            (dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE))
+                return -ENODEV;
 
         if (count > TG_PT_GROUP_NAME_BUF) {
                 pr_err("ALUA Target Port Group alias too large!\n");
@@ -2049,8 +1996,8 @@ ssize_t core_alua_store_tg_pt_gp_info(
                         return -ENODEV;
         }
 
-        spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-        tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
+        spin_lock(&lun->lun_tg_pt_gp_lock);
+        tg_pt_gp = lun->lun_tg_pt_gp;
         if (tg_pt_gp) {
                 /*
                  * Clearing an existing tg_pt_gp association, and replacing
@@ -2068,24 +2015,19 @@ ssize_t core_alua_store_tg_pt_gp_info(
                                         &tg_pt_gp->tg_pt_gp_group.cg_item),
                                 tg_pt_gp->tg_pt_gp_id);
 
-                        __core_alua_drop_tg_pt_gp_mem(tg_pt_gp_mem, tg_pt_gp);
-                        __core_alua_attach_tg_pt_gp_mem(tg_pt_gp_mem,
+                        __target_detach_tg_pt_gp(lun, tg_pt_gp);
+                        __target_attach_tg_pt_gp(lun,
                                         dev->t10_alua.default_tg_pt_gp);
-                        spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
+                        spin_unlock(&lun->lun_tg_pt_gp_lock);
 
                         return count;
                 }
-                /*
-                 * Removing existing association of tg_pt_gp_mem with tg_pt_gp
-                 */
-                __core_alua_drop_tg_pt_gp_mem(tg_pt_gp_mem, tg_pt_gp);
+                __target_detach_tg_pt_gp(lun, tg_pt_gp);
                 move = 1;
         }
-        /*
-         * Associate tg_pt_gp_mem with tg_pt_gp_new.
-         */
-        __core_alua_attach_tg_pt_gp_mem(tg_pt_gp_mem, tg_pt_gp_new);
-        spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
+
+        __target_attach_tg_pt_gp(lun, tg_pt_gp_new);
+        spin_unlock(&lun->lun_tg_pt_gp_lock);
         pr_debug("Target_Core_ConfigFS: %s %s/tpgt_%hu/%s to ALUA"
                 " Target Port Group: alua/%s, ID: %hu\n", (move) ?
                 "Moving" : "Adding", tpg->se_tpg_tfo->tpg_get_wwn(tpg),
@@ -2268,11 +2210,8 @@ ssize_t core_alua_store_preferred_bit(
 
 ssize_t core_alua_show_offline_bit(struct se_lun *lun, char *page)
 {
-        if (!lun->lun_sep)
-                return -ENODEV;
-
         return sprintf(page, "%d\n",
-                atomic_read(&lun->lun_sep->sep_tg_pt_secondary_offline));
+                atomic_read(&lun->lun_tg_pt_secondary_offline));
 }
 
 ssize_t core_alua_store_offline_bit(
@@ -2280,11 +2219,16 @@ ssize_t core_alua_store_offline_bit(
         const char *page,
         size_t count)
 {
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
+        /*
+         * rcu_dereference_raw protected by se_lun->lun_group symlink
+         * reference to se_device->dev_group.
+         */
+        struct se_device *dev = rcu_dereference_raw(lun->lun_se_dev);
         unsigned long tmp;
         int ret;
 
-        if (!lun->lun_sep)
+        if (dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH ||
+            (dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE))
                 return -ENODEV;
 
         ret = kstrtoul(page, 0, &tmp);
@@ -2297,14 +2241,8 @@ ssize_t core_alua_store_offline_bit(
                                 tmp);
                 return -EINVAL;
         }
-        tg_pt_gp_mem = lun->lun_sep->sep_alua_tg_pt_gp_mem;
-        if (!tg_pt_gp_mem) {
-                pr_err("Unable to locate *tg_pt_gp_mem\n");
-                return -EINVAL;
-        }
 
-        ret = core_alua_set_tg_pt_secondary_state(tg_pt_gp_mem,
-                        lun->lun_sep, 0, (int)tmp);
+        ret = core_alua_set_tg_pt_secondary_state(lun, 0, (int)tmp);
         if (ret < 0)
                 return -EINVAL;
 
@@ -2315,7 +2253,7 @@ ssize_t core_alua_show_secondary_status(
         struct se_lun *lun,
         char *page)
 {
-        return sprintf(page, "%d\n", lun->lun_sep->sep_tg_pt_secondary_stat);
+        return sprintf(page, "%d\n", lun->lun_tg_pt_secondary_stat);
 }
 
 ssize_t core_alua_store_secondary_status(
@@ -2338,7 +2276,7 @@ ssize_t core_alua_store_secondary_status(
                                 tmp);
                 return -EINVAL;
         }
-        lun->lun_sep->sep_tg_pt_secondary_stat = (int)tmp;
+        lun->lun_tg_pt_secondary_stat = (int)tmp;
 
         return count;
 }
@@ -2347,8 +2285,7 @@ ssize_t core_alua_show_secondary_write_metadata(
         struct se_lun *lun,
         char *page)
 {
-        return sprintf(page, "%d\n",
-                        lun->lun_sep->sep_tg_pt_secondary_write_md);
+        return sprintf(page, "%d\n", lun->lun_tg_pt_secondary_write_md);
 }
 
 ssize_t core_alua_store_secondary_write_metadata(
@@ -2369,7 +2306,7 @@ ssize_t core_alua_store_secondary_write_metadata(
                                 " %lu\n", tmp);
                 return -EINVAL;
         }
-        lun->lun_sep->sep_tg_pt_secondary_write_md = (int)tmp;
+        lun->lun_tg_pt_secondary_write_md = (int)tmp;
 
         return count;
 }
diff --git a/drivers/target/target_core_alua.h b/drivers/target/target_core_alua.h
index 0a7d65e80404..9b250f9b33bf 100644
--- a/drivers/target/target_core_alua.h
+++ b/drivers/target/target_core_alua.h
@@ -85,7 +85,6 @@
 extern struct kmem_cache *t10_alua_lu_gp_cache;
 extern struct kmem_cache *t10_alua_lu_gp_mem_cache;
 extern struct kmem_cache *t10_alua_tg_pt_gp_cache;
-extern struct kmem_cache *t10_alua_tg_pt_gp_mem_cache;
 extern struct kmem_cache *t10_alua_lba_map_cache;
 extern struct kmem_cache *t10_alua_lba_map_mem_cache;
 
@@ -94,7 +93,7 @@ extern sense_reason_t target_emulate_set_target_port_groups(struct se_cmd *);
 extern sense_reason_t target_emulate_report_referrals(struct se_cmd *);
 extern int core_alua_check_nonop_delay(struct se_cmd *);
 extern int core_alua_do_port_transition(struct t10_alua_tg_pt_gp *,
-                                struct se_device *, struct se_port *,
+                                struct se_device *, struct se_lun *,
                                 struct se_node_acl *, int, int);
 extern char *core_alua_dump_status(int);
 extern struct t10_alua_lba_map *core_alua_allocate_lba_map(
@@ -117,14 +116,11 @@ extern void core_alua_drop_lu_gp_dev(struct se_device *);
 extern struct t10_alua_tg_pt_gp *core_alua_allocate_tg_pt_gp(
                         struct se_device *, const char *, int);
 extern int core_alua_set_tg_pt_gp_id(struct t10_alua_tg_pt_gp *, u16);
-extern struct t10_alua_tg_pt_gp_member *core_alua_allocate_tg_pt_gp_mem(
-                                        struct se_port *);
 extern void core_alua_free_tg_pt_gp(struct t10_alua_tg_pt_gp *);
-extern void core_alua_free_tg_pt_gp_mem(struct se_port *);
-extern void __core_alua_attach_tg_pt_gp_mem(struct t10_alua_tg_pt_gp_member *,
-                                        struct t10_alua_tg_pt_gp *);
-extern ssize_t core_alua_show_tg_pt_gp_info(struct se_port *, char *);
-extern ssize_t core_alua_store_tg_pt_gp_info(struct se_port *, const char *,
+extern void target_detach_tg_pt_gp(struct se_lun *);
+extern void target_attach_tg_pt_gp(struct se_lun *, struct t10_alua_tg_pt_gp *);
+extern ssize_t core_alua_show_tg_pt_gp_info(struct se_lun *, char *);
+extern ssize_t core_alua_store_tg_pt_gp_info(struct se_lun *, const char *,
                                                 size_t);
 extern ssize_t core_alua_show_access_type(struct t10_alua_tg_pt_gp *, char *);
 extern ssize_t core_alua_store_access_type(struct t10_alua_tg_pt_gp *,
diff --git a/drivers/target/target_core_configfs.c b/drivers/target/target_core_configfs.c
index e7b0430a0575..0b0de3647478 100644
--- a/drivers/target/target_core_configfs.c
+++ b/drivers/target/target_core_configfs.c
@@ -41,7 +41,6 @@
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
 #include <target/target_core_fabric_configfs.h>
-#include <target/target_core_configfs.h>
 #include <target/configfs_macros.h>
 
 #include "target_core_internal.h"
@@ -51,15 +50,26 @@
 #include "target_core_xcopy.h"
 
 #define TB_CIT_SETUP(_name, _item_ops, _group_ops, _attrs)              \
-static void target_core_setup_##_name##_cit(struct se_subsystem_api *sa) \
+static void target_core_setup_##_name##_cit(struct target_backend *tb)  \
 {                                                                       \
-        struct target_backend_cits *tbc = &sa->tb_cits;                 \
-        struct config_item_type *cit = &tbc->tb_##_name##_cit;          \
+        struct config_item_type *cit = &tb->tb_##_name##_cit;           \
                                                                         \
         cit->ct_item_ops = _item_ops;                                   \
         cit->ct_group_ops = _group_ops;                                 \
         cit->ct_attrs = _attrs;                                         \
-        cit->ct_owner = sa->owner;                                      \
+        cit->ct_owner = tb->ops->owner;                                 \
+        pr_debug("Setup generic %s\n", __stringify(_name));             \
+}
+
+#define TB_CIT_SETUP_DRV(_name, _item_ops, _group_ops)                  \
+static void target_core_setup_##_name##_cit(struct target_backend *tb)  \
+{                                                                       \
+        struct config_item_type *cit = &tb->tb_##_name##_cit;           \
+                                                                        \
+        cit->ct_item_ops = _item_ops;                                   \
+        cit->ct_group_ops = _group_ops;                                 \
+        cit->ct_attrs = tb->ops->tb_##_name##_attrs;                    \
+        cit->ct_owner = tb->ops->owner;                                 \
         pr_debug("Setup generic %s\n", __stringify(_name));             \
 }
 
@@ -92,7 +102,7 @@ static ssize_t target_core_attr_show(struct config_item *item,
                                       char *page)
 {
         return sprintf(page, "Target Engine Core ConfigFS Infrastructure %s"
-                " on %s/%s on "UTS_RELEASE"\n", TARGET_CORE_CONFIGFS_VERSION,
+                " on %s/%s on "UTS_RELEASE"\n", TARGET_CORE_VERSION,
                 utsname()->sysname, utsname()->machine);
 }
 
@@ -116,7 +126,7 @@ static struct target_fabric_configfs *target_core_get_fabric(
 
         mutex_lock(&g_tf_lock);
         list_for_each_entry(tf, &g_tf_list, tf_list) {
-                if (!strcmp(tf->tf_name, name)) {
+                if (!strcmp(tf->tf_ops->name, name)) {
                         atomic_inc(&tf->tf_access_cnt);
                         mutex_unlock(&g_tf_lock);
                         return tf;
@@ -193,29 +203,24 @@ static struct config_group *target_core_register_fabric(
                 return ERR_PTR(-EINVAL);
         }
         pr_debug("Target_Core_ConfigFS: REGISTER -> Located fabric:"
-                        " %s\n", tf->tf_name);
+                        " %s\n", tf->tf_ops->name);
         /*
          * On a successful target_core_get_fabric() look, the returned
          * struct target_fabric_configfs *tf will contain a usage reference.
          */
         pr_debug("Target_Core_ConfigFS: REGISTER tfc_wwn_cit -> %p\n",
-                        &tf->tf_cit_tmpl.tfc_wwn_cit);
+                        &tf->tf_wwn_cit);
 
         tf->tf_group.default_groups = tf->tf_default_groups;
         tf->tf_group.default_groups[0] = &tf->tf_disc_group;
         tf->tf_group.default_groups[1] = NULL;
 
-        config_group_init_type_name(&tf->tf_group, name,
-                        &tf->tf_cit_tmpl.tfc_wwn_cit);
+        config_group_init_type_name(&tf->tf_group, name, &tf->tf_wwn_cit);
         config_group_init_type_name(&tf->tf_disc_group, "discovery_auth",
-                        &tf->tf_cit_tmpl.tfc_discovery_cit);
+                        &tf->tf_discovery_cit);
 
         pr_debug("Target_Core_ConfigFS: REGISTER -> Allocated Fabric:"
                         " %s\n", tf->tf_group.cg_item.ci_name);
-        tf->tf_fabric = &tf->tf_group.cg_item;
-        pr_debug("Target_Core_ConfigFS: REGISTER -> Set tf->tf_fabric"
-                        " for %s\n", name);
-
         return &tf->tf_group;
 }
 
@@ -236,13 +241,9 @@ static void target_core_deregister_fabric(
                 " tf list\n", config_item_name(item));
 
         pr_debug("Target_Core_ConfigFS: DEREGISTER -> located fabric:"
-                        " %s\n", tf->tf_name);
+                        " %s\n", tf->tf_ops->name);
         atomic_dec(&tf->tf_access_cnt);
 
-        pr_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing"
-                        " tf->tf_fabric for %s\n", tf->tf_name);
-        tf->tf_fabric = NULL;
-
         pr_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing ci"
                         " %s\n", config_item_name(item));
 
@@ -318,10 +319,6 @@ static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo)
                 pr_err("Missing tfo->get_fabric_name()\n");
                 return -EINVAL;
         }
-        if (!tfo->get_fabric_proto_ident) {
-                pr_err("Missing tfo->get_fabric_proto_ident()\n");
-                return -EINVAL;
-        }
         if (!tfo->tpg_get_wwn) {
                 pr_err("Missing tfo->tpg_get_wwn()\n");
                 return -EINVAL;
@@ -330,18 +327,6 @@ static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo)
                 pr_err("Missing tfo->tpg_get_tag()\n");
                 return -EINVAL;
         }
-        if (!tfo->tpg_get_default_depth) {
-                pr_err("Missing tfo->tpg_get_default_depth()\n");
-                return -EINVAL;
-        }
-        if (!tfo->tpg_get_pr_transport_id) {
-                pr_err("Missing tfo->tpg_get_pr_transport_id()\n");
-                return -EINVAL;
-        }
-        if (!tfo->tpg_get_pr_transport_id_len) {
-                pr_err("Missing tfo->tpg_get_pr_transport_id_len()\n");
-                return -EINVAL;
-        }
         if (!tfo->tpg_check_demo_mode) {
                 pr_err("Missing tfo->tpg_check_demo_mode()\n");
                 return -EINVAL;
@@ -358,14 +343,6 @@ static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo)
                 pr_err("Missing tfo->tpg_check_prod_mode_write_protect()\n");
                 return -EINVAL;
         }
-        if (!tfo->tpg_alloc_fabric_acl) {
-                pr_err("Missing tfo->tpg_alloc_fabric_acl()\n");
-                return -EINVAL;
-        }
-        if (!tfo->tpg_release_fabric_acl) {
-                pr_err("Missing tfo->tpg_release_fabric_acl()\n");
-                return -EINVAL;
-        }
         if (!tfo->tpg_get_inst_index) {
                 pr_err("Missing tfo->tpg_get_inst_index()\n");
                 return -EINVAL;
@@ -398,10 +375,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;
@@ -464,15 +437,7 @@ int target_register_template(const struct target_core_fabric_ops *fo)
 
         INIT_LIST_HEAD(&tf->tf_list);
         atomic_set(&tf->tf_access_cnt, 0);
-
-        /*
-         * Setup the default generic struct config_item_type's (cits) in
-         * struct target_fabric_configfs->tf_cit_tmpl
-         */
-        tf->tf_module = fo->module;
-        snprintf(tf->tf_name, TARGET_FABRIC_NAME_SIZE, "%s", fo->name);
-
-        tf->tf_ops = *fo;
+        tf->tf_ops = fo;
         target_fabric_setup_cits(tf);
 
         mutex_lock(&g_tf_lock);
@@ -489,7 +454,7 @@ void target_unregister_template(const struct target_core_fabric_ops *fo)
 
         mutex_lock(&g_tf_lock);
         list_for_each_entry(t, &g_tf_list, tf_list) {
-                if (!strcmp(t->tf_name, fo->name)) {
+                if (!strcmp(t->tf_ops->name, fo->name)) {
                         BUG_ON(atomic_read(&t->tf_access_cnt));
                         list_del(&t->tf_list);
                         kfree(t);
@@ -505,16 +470,605 @@ EXPORT_SYMBOL(target_unregister_template);
 //############################################################################*/
 
 /* Start functions for struct config_item_type tb_dev_attrib_cit */
+#define DEF_TB_DEV_ATTRIB_SHOW(_name)                                   \
+static ssize_t show_##_name(struct se_dev_attrib *da, char *page)       \
+{                                                                       \
+        return snprintf(page, PAGE_SIZE, "%u\n", da->_name);            \
+}
+
+DEF_TB_DEV_ATTRIB_SHOW(emulate_model_alias);
+DEF_TB_DEV_ATTRIB_SHOW(emulate_dpo);
+DEF_TB_DEV_ATTRIB_SHOW(emulate_fua_write);
+DEF_TB_DEV_ATTRIB_SHOW(emulate_fua_read);
+DEF_TB_DEV_ATTRIB_SHOW(emulate_write_cache);
+DEF_TB_DEV_ATTRIB_SHOW(emulate_ua_intlck_ctrl);
+DEF_TB_DEV_ATTRIB_SHOW(emulate_tas);
+DEF_TB_DEV_ATTRIB_SHOW(emulate_tpu);
+DEF_TB_DEV_ATTRIB_SHOW(emulate_tpws);
+DEF_TB_DEV_ATTRIB_SHOW(emulate_caw);
+DEF_TB_DEV_ATTRIB_SHOW(emulate_3pc);
+DEF_TB_DEV_ATTRIB_SHOW(pi_prot_type);
+DEF_TB_DEV_ATTRIB_SHOW(hw_pi_prot_type);
+DEF_TB_DEV_ATTRIB_SHOW(pi_prot_format);
+DEF_TB_DEV_ATTRIB_SHOW(enforce_pr_isids);
+DEF_TB_DEV_ATTRIB_SHOW(is_nonrot);
+DEF_TB_DEV_ATTRIB_SHOW(emulate_rest_reord);
+DEF_TB_DEV_ATTRIB_SHOW(force_pr_aptpl);
+DEF_TB_DEV_ATTRIB_SHOW(hw_block_size);
+DEF_TB_DEV_ATTRIB_SHOW(block_size);
+DEF_TB_DEV_ATTRIB_SHOW(hw_max_sectors);
+DEF_TB_DEV_ATTRIB_SHOW(optimal_sectors);
+DEF_TB_DEV_ATTRIB_SHOW(hw_queue_depth);
+DEF_TB_DEV_ATTRIB_SHOW(queue_depth);
+DEF_TB_DEV_ATTRIB_SHOW(max_unmap_lba_count);
+DEF_TB_DEV_ATTRIB_SHOW(max_unmap_block_desc_count);
+DEF_TB_DEV_ATTRIB_SHOW(unmap_granularity);
+DEF_TB_DEV_ATTRIB_SHOW(unmap_granularity_alignment);
+DEF_TB_DEV_ATTRIB_SHOW(max_write_same_len);
+
+#define DEF_TB_DEV_ATTRIB_STORE_U32(_name)                              \
+static ssize_t store_##_name(struct se_dev_attrib *da, const char *page,\
+                size_t count)                                           \
+{                                                                       \
+        u32 val;                                                        \
+        int ret;                                                        \
+                                                                        \
+        ret = kstrtou32(page, 0, &val);                                 \
+        if (ret < 0)                                                    \
+                return ret;                                             \
+        da->_name = val;                                                \
+        return count;                                                   \
+}
+
+DEF_TB_DEV_ATTRIB_STORE_U32(max_unmap_lba_count);
+DEF_TB_DEV_ATTRIB_STORE_U32(max_unmap_block_desc_count);
+DEF_TB_DEV_ATTRIB_STORE_U32(unmap_granularity);
+DEF_TB_DEV_ATTRIB_STORE_U32(unmap_granularity_alignment);
+DEF_TB_DEV_ATTRIB_STORE_U32(max_write_same_len);
+
+#define DEF_TB_DEV_ATTRIB_STORE_BOOL(_name)                             \
+static ssize_t store_##_name(struct se_dev_attrib *da, const char *page,\
+                size_t count)                                           \
+{                                                                       \
+        bool flag;                                                      \
+        int ret;                                                        \
+                                                                        \
+        ret = strtobool(page, &flag);                                   \
+        if (ret < 0)                                                    \
+                return ret;                                             \
+        da->_name = flag;                                               \
+        return count;                                                   \
+}
+
+DEF_TB_DEV_ATTRIB_STORE_BOOL(emulate_fua_write);
+DEF_TB_DEV_ATTRIB_STORE_BOOL(emulate_caw);
+DEF_TB_DEV_ATTRIB_STORE_BOOL(emulate_3pc);
+DEF_TB_DEV_ATTRIB_STORE_BOOL(enforce_pr_isids);
+DEF_TB_DEV_ATTRIB_STORE_BOOL(is_nonrot);
+
+#define DEF_TB_DEV_ATTRIB_STORE_STUB(_name)                             \
+static ssize_t store_##_name(struct se_dev_attrib *da, const char *page,\
+                size_t count)                                           \
+{                                                                       \
+        printk_once(KERN_WARNING                                        \
+                "ignoring deprecated ##_name## attribute\n");   \
+        return count;                                                   \
+}
+
+DEF_TB_DEV_ATTRIB_STORE_STUB(emulate_dpo);
+DEF_TB_DEV_ATTRIB_STORE_STUB(emulate_fua_read);
+
+static void dev_set_t10_wwn_model_alias(struct se_device *dev)
+{
+        const char *configname;
+
+        configname = config_item_name(&dev->dev_group.cg_item);
+        if (strlen(configname) >= 16) {
+                pr_warn("dev[%p]: Backstore name '%s' is too long for "
+                        "INQUIRY_MODEL, truncating to 16 bytes\n", dev,
+                        configname);
+        }
+        snprintf(&dev->t10_wwn.model[0], 16, "%s", configname);
+}
+
+static ssize_t store_emulate_model_alias(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        struct se_device *dev = da->da_dev;
+        bool flag;
+        int ret;
+
+        if (dev->export_count) {
+                pr_err("dev[%p]: Unable to change model alias"
+                        " while export_count is %d\n",
+                        dev, dev->export_count);
+                return -EINVAL;
+        }
+
+        ret = strtobool(page, &flag);
+        if (ret < 0)
+                return ret;
+
+        if (flag) {
+                dev_set_t10_wwn_model_alias(dev);
+        } else {
+                strncpy(&dev->t10_wwn.model[0],
+                        dev->transport->inquiry_prod, 16);
+        }
+        da->emulate_model_alias = flag;
+        return count;
+}
+
+static ssize_t store_emulate_write_cache(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        bool flag;
+        int ret;
+
+        ret = strtobool(page, &flag);
+        if (ret < 0)
+                return ret;
+
+        if (flag && da->da_dev->transport->get_write_cache) {
+                pr_err("emulate_write_cache not supported for this device\n");
+                return -EINVAL;
+        }
+
+        da->emulate_write_cache = flag;
+        pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",
+                        da->da_dev, flag);
+        return count;
+}
+
+static ssize_t store_emulate_ua_intlck_ctrl(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        u32 val;
+        int ret;
+
+        ret = kstrtou32(page, 0, &val);
+        if (ret < 0)
+                return ret;
+
+        if (val != 0 && val != 1 && val != 2) {
+                pr_err("Illegal value %d\n", val);
+                return -EINVAL;
+        }
+
+        if (da->da_dev->export_count) {
+                pr_err("dev[%p]: Unable to change SE Device"
+                        " UA_INTRLCK_CTRL while export_count is %d\n",
+                        da->da_dev, da->da_dev->export_count);
+                return -EINVAL;
+        }
+        da->emulate_ua_intlck_ctrl = val;
+        pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n",
+                da->da_dev, val);
+        return count;
+}
+
+static ssize_t store_emulate_tas(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        bool flag;
+        int ret;
+
+        ret = strtobool(page, &flag);
+        if (ret < 0)
+                return ret;
+
+        if (da->da_dev->export_count) {
+                pr_err("dev[%p]: Unable to change SE Device TAS while"
+                        " export_count is %d\n",
+                        da->da_dev, da->da_dev->export_count);
+                return -EINVAL;
+        }
+        da->emulate_tas = flag;
+        pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n",
+                da->da_dev, flag ? "Enabled" : "Disabled");
+
+        return count;
+}
+
+static ssize_t store_emulate_tpu(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        bool flag;
+        int ret;
+
+        ret = strtobool(page, &flag);
+        if (ret < 0)
+                return ret;
+
+        /*
+         * We expect this value to be non-zero when generic Block Layer
+         * Discard supported is detected iblock_create_virtdevice().
+         */
+        if (flag && !da->max_unmap_block_desc_count) {
+                pr_err("Generic Block Discard not supported\n");
+                return -ENOSYS;
+        }
+
+        da->emulate_tpu = flag;
+        pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n",
+                da->da_dev, flag);
+        return count;
+}
+
+static ssize_t store_emulate_tpws(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        bool flag;
+        int ret;
+
+        ret = strtobool(page, &flag);
+        if (ret < 0)
+                return ret;
+
+        /*
+         * We expect this value to be non-zero when generic Block Layer
+         * Discard supported is detected iblock_create_virtdevice().
+         */
+        if (flag && !da->max_unmap_block_desc_count) {
+                pr_err("Generic Block Discard not supported\n");
+                return -ENOSYS;
+        }
+
+        da->emulate_tpws = flag;
+        pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n",
+                                da->da_dev, flag);
+        return count;
+}
+
+static ssize_t store_pi_prot_type(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        int old_prot = da->pi_prot_type, ret;
+        struct se_device *dev = da->da_dev;
+        u32 flag;
+
+        ret = kstrtou32(page, 0, &flag);
+        if (ret < 0)
+                return ret;
+
+        if (flag != 0 && flag != 1 && flag != 2 && flag != 3) {
+                pr_err("Illegal value %d for pi_prot_type\n", flag);
+                return -EINVAL;
+        }
+        if (flag == 2) {
+                pr_err("DIF TYPE2 protection currently not supported\n");
+                return -ENOSYS;
+        }
+        if (da->hw_pi_prot_type) {
+                pr_warn("DIF protection enabled on underlying hardware,"
+                        " ignoring\n");
+                return count;
+        }
+        if (!dev->transport->init_prot || !dev->transport->free_prot) {
+                /* 0 is only allowed value for non-supporting backends */
+                if (flag == 0)
+                        return 0;
+
+                pr_err("DIF protection not supported by backend: %s\n",
+                       dev->transport->name);
+                return -ENOSYS;
+        }
+        if (!(dev->dev_flags & DF_CONFIGURED)) {
+                pr_err("DIF protection requires device to be configured\n");
+                return -ENODEV;
+        }
+        if (dev->export_count) {
+                pr_err("dev[%p]: Unable to change SE Device PROT type while"
+                       " export_count is %d\n", dev, dev->export_count);
+                return -EINVAL;
+        }
+
+        da->pi_prot_type = flag;
+
+        if (flag && !old_prot) {
+                ret = dev->transport->init_prot(dev);
+                if (ret) {
+                        da->pi_prot_type = old_prot;
+                        return ret;
+                }
+
+        } else if (!flag && old_prot) {
+                dev->transport->free_prot(dev);
+        }
+
+        pr_debug("dev[%p]: SE Device Protection Type: %d\n", dev, flag);
+        return count;
+}
+
+static ssize_t store_pi_prot_format(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        struct se_device *dev = da->da_dev;
+        bool flag;
+        int ret;
+
+        ret = strtobool(page, &flag);
+        if (ret < 0)
+                return ret;
+
+        if (!flag)
+                return count;
+
+        if (!dev->transport->format_prot) {
+                pr_err("DIF protection format not supported by backend %s\n",
+                       dev->transport->name);
+                return -ENOSYS;
+        }
+        if (!(dev->dev_flags & DF_CONFIGURED)) {
+                pr_err("DIF protection format requires device to be configured\n");
+                return -ENODEV;
+        }
+        if (dev->export_count) {
+                pr_err("dev[%p]: Unable to format SE Device PROT type while"
+                       " export_count is %d\n", dev, dev->export_count);
+                return -EINVAL;
+        }
+
+        ret = dev->transport->format_prot(dev);
+        if (ret)
+                return ret;
+
+        pr_debug("dev[%p]: SE Device Protection Format complete\n", dev);
+        return count;
+}
+
+static ssize_t store_force_pr_aptpl(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        bool flag;
+        int ret;
+
+        ret = strtobool(page, &flag);
+        if (ret < 0)
+                return ret;
+        if (da->da_dev->export_count) {
+                pr_err("dev[%p]: Unable to set force_pr_aptpl while"
+                       " export_count is %d\n",
+                       da->da_dev, da->da_dev->export_count);
+                return -EINVAL;
+        }
+
+        da->force_pr_aptpl = flag;
+        pr_debug("dev[%p]: SE Device force_pr_aptpl: %d\n", da->da_dev, flag);
+        return count;
+}
+
+static ssize_t store_emulate_rest_reord(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        bool flag;
+        int ret;
+
+        ret = strtobool(page, &flag);
+        if (ret < 0)
+                return ret;
+
+        if (flag != 0) {
+                printk(KERN_ERR "dev[%p]: SE Device emulation of restricted"
+                        " reordering not implemented\n", da->da_dev);
+                return -ENOSYS;
+        }
+        da->emulate_rest_reord = flag;
+        pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n",
+                da->da_dev, flag);
+        return count;
+}
+
+/*
+ * Note, this can only be called on unexported SE Device Object.
+ */
+static ssize_t store_queue_depth(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        struct se_device *dev = da->da_dev;
+        u32 val;
+        int ret;
+
+        ret = kstrtou32(page, 0, &val);
+        if (ret < 0)
+                return ret;
+
+        if (dev->export_count) {
+                pr_err("dev[%p]: Unable to change SE Device TCQ while"
+                        " export_count is %d\n",
+                        dev, dev->export_count);
+                return -EINVAL;
+        }
+        if (!val) {
+                pr_err("dev[%p]: Illegal ZERO value for queue_depth\n", dev);
+                return -EINVAL;
+        }
+
+        if (val > dev->dev_attrib.queue_depth) {
+                if (val > dev->dev_attrib.hw_queue_depth) {
+                        pr_err("dev[%p]: Passed queue_depth:"
+                                " %u exceeds TCM/SE_Device MAX"
+                                " TCQ: %u\n", dev, val,
+                                dev->dev_attrib.hw_queue_depth);
+                        return -EINVAL;
+                }
+        }
+        da->queue_depth = dev->queue_depth = val;
+        pr_debug("dev[%p]: SE Device TCQ Depth changed to: %u\n", dev, val);
+        return count;
+}
+
+static ssize_t store_optimal_sectors(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        u32 val;
+        int ret;
+
+        ret = kstrtou32(page, 0, &val);
+        if (ret < 0)
+                return ret;
+
+        if (da->da_dev->export_count) {
+                pr_err("dev[%p]: Unable to change SE Device"
+                        " optimal_sectors while export_count is %d\n",
+                        da->da_dev, da->da_dev->export_count);
+                return -EINVAL;
+        }
+        if (val > da->hw_max_sectors) {
+                pr_err("dev[%p]: Passed optimal_sectors %u cannot be"
+                        " greater than hw_max_sectors: %u\n",
+                        da->da_dev, val, da->hw_max_sectors);
+                return -EINVAL;
+        }
+
+        da->optimal_sectors = val;
+        pr_debug("dev[%p]: SE Device optimal_sectors changed to %u\n",
+                        da->da_dev, val);
+        return count;
+}
+
+static ssize_t store_block_size(struct se_dev_attrib *da,
+                const char *page, size_t count)
+{
+        u32 val;
+        int ret;
+
+        ret = kstrtou32(page, 0, &val);
+        if (ret < 0)
+                return ret;
+
+        if (da->da_dev->export_count) {
+                pr_err("dev[%p]: Unable to change SE Device block_size"
+                        " while export_count is %d\n",
+                        da->da_dev, da->da_dev->export_count);
+                return -EINVAL;
+        }
+
+        if (val != 512 && val != 1024 && val != 2048 && val != 4096) {
+                pr_err("dev[%p]: Illegal value for block_device: %u"
+                        " for SE device, must be 512, 1024, 2048 or 4096\n",
+                        da->da_dev, val);
+                return -EINVAL;
+        }
+
+        da->block_size = val;
+        if (da->max_bytes_per_io)
+                da->hw_max_sectors = da->max_bytes_per_io / val;
+
+        pr_debug("dev[%p]: SE Device block_size changed to %u\n",
+                        da->da_dev, val);
+        return count;
+}
+
+CONFIGFS_EATTR_STRUCT(target_backend_dev_attrib, se_dev_attrib);
+#define TB_DEV_ATTR(_backend, _name, _mode)                             \
+static struct target_backend_dev_attrib_attribute _backend##_dev_attrib_##_name = \
+        __CONFIGFS_EATTR(_name, _mode,                                  \
+        show_##_name,                                                   \
+        store_##_name);
+
+#define TB_DEV_ATTR_RO(_backend, _name)                                 \
+static struct target_backend_dev_attrib_attribute _backend##_dev_attrib_##_name = \
+        __CONFIGFS_EATTR_RO(_name,                                      \
+        show_##_name);
+
+TB_DEV_ATTR(target_core, emulate_model_alias, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, emulate_dpo, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, emulate_fua_write, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, emulate_fua_read, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, emulate_write_cache, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, emulate_ua_intlck_ctrl, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, emulate_tas, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, emulate_tpu, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, emulate_tpws, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, emulate_caw, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, emulate_3pc, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, pi_prot_type, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR_RO(target_core, hw_pi_prot_type);
+TB_DEV_ATTR(target_core, pi_prot_format, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, enforce_pr_isids, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, is_nonrot, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, emulate_rest_reord, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, force_pr_aptpl, S_IRUGO | S_IWUSR)
+TB_DEV_ATTR_RO(target_core, hw_block_size);
+TB_DEV_ATTR(target_core, block_size, S_IRUGO | S_IWUSR)
+TB_DEV_ATTR_RO(target_core, hw_max_sectors);
+TB_DEV_ATTR(target_core, optimal_sectors, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR_RO(target_core, hw_queue_depth);
+TB_DEV_ATTR(target_core, queue_depth, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, max_unmap_lba_count, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, max_unmap_block_desc_count, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, unmap_granularity, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, unmap_granularity_alignment, S_IRUGO | S_IWUSR);
+TB_DEV_ATTR(target_core, max_write_same_len, S_IRUGO | S_IWUSR);
 
 CONFIGFS_EATTR_STRUCT(target_core_dev_attrib, se_dev_attrib);
 CONFIGFS_EATTR_OPS(target_core_dev_attrib, se_dev_attrib, da_group);
 
+/*
+ * dev_attrib attributes for devices using the target core SBC/SPC
+ * interpreter.  Any backend using spc_parse_cdb should be using
+ * these.
+ */
+struct configfs_attribute *sbc_attrib_attrs[] = {
+        &target_core_dev_attrib_emulate_model_alias.attr,
+        &target_core_dev_attrib_emulate_dpo.attr,
+        &target_core_dev_attrib_emulate_fua_write.attr,
+        &target_core_dev_attrib_emulate_fua_read.attr,
+        &target_core_dev_attrib_emulate_write_cache.attr,
+        &target_core_dev_attrib_emulate_ua_intlck_ctrl.attr,
+        &target_core_dev_attrib_emulate_tas.attr,
+        &target_core_dev_attrib_emulate_tpu.attr,
+        &target_core_dev_attrib_emulate_tpws.attr,
+        &target_core_dev_attrib_emulate_caw.attr,
+        &target_core_dev_attrib_emulate_3pc.attr,
+        &target_core_dev_attrib_pi_prot_type.attr,
+        &target_core_dev_attrib_hw_pi_prot_type.attr,
+        &target_core_dev_attrib_pi_prot_format.attr,
+        &target_core_dev_attrib_enforce_pr_isids.attr,
+        &target_core_dev_attrib_is_nonrot.attr,
+        &target_core_dev_attrib_emulate_rest_reord.attr,
+        &target_core_dev_attrib_force_pr_aptpl.attr,
+        &target_core_dev_attrib_hw_block_size.attr,
+        &target_core_dev_attrib_block_size.attr,
+        &target_core_dev_attrib_hw_max_sectors.attr,
+        &target_core_dev_attrib_optimal_sectors.attr,
+        &target_core_dev_attrib_hw_queue_depth.attr,
+        &target_core_dev_attrib_queue_depth.attr,
+        &target_core_dev_attrib_max_unmap_lba_count.attr,
+        &target_core_dev_attrib_max_unmap_block_desc_count.attr,
+        &target_core_dev_attrib_unmap_granularity.attr,
+        &target_core_dev_attrib_unmap_granularity_alignment.attr,
+        &target_core_dev_attrib_max_write_same_len.attr,
+        NULL,
+};
+EXPORT_SYMBOL(sbc_attrib_attrs);
+
+TB_DEV_ATTR_RO(target_pt, hw_pi_prot_type);
+TB_DEV_ATTR_RO(target_pt, hw_block_size);
+TB_DEV_ATTR_RO(target_pt, hw_max_sectors);
+TB_DEV_ATTR_RO(target_pt, hw_queue_depth);
+
+/*
+ * Minimal dev_attrib attributes for devices passing through CDBs.
+ * In this case we only provide a few read-only attributes for
+ * backwards compatibility.
+ */
+struct configfs_attribute *passthrough_attrib_attrs[] = {
+        &target_pt_dev_attrib_hw_pi_prot_type.attr,
+        &target_pt_dev_attrib_hw_block_size.attr,
+        &target_pt_dev_attrib_hw_max_sectors.attr,
+        &target_pt_dev_attrib_hw_queue_depth.attr,
+        NULL,
+};
+EXPORT_SYMBOL(passthrough_attrib_attrs);
+
 static struct configfs_item_operations target_core_dev_attrib_ops = {
         .show_attribute         = target_core_dev_attrib_attr_show,
         .store_attribute        = target_core_dev_attrib_attr_store,
 };
 
-TB_CIT_SETUP(dev_attrib, &target_core_dev_attrib_ops, NULL, NULL);
+TB_CIT_SETUP_DRV(dev_attrib, &target_core_dev_attrib_ops, NULL);
 
 /* End functions for struct config_item_type tb_dev_attrib_cit */
 
@@ -862,7 +1416,6 @@ static ssize_t target_core_dev_pr_show_attr_res_pr_holder_tg_port(
                 struct se_device *dev, char *page)
 {
         struct se_node_acl *se_nacl;
-        struct se_lun *lun;
         struct se_portal_group *se_tpg;
         struct t10_pr_registration *pr_reg;
         const struct target_core_fabric_ops *tfo;
@@ -877,7 +1430,6 @@ static ssize_t target_core_dev_pr_show_attr_res_pr_holder_tg_port(
 
         se_nacl = pr_reg->pr_reg_nacl;
         se_tpg = se_nacl->se_tpg;
-        lun = pr_reg->pr_reg_tg_pt_lun;
         tfo = se_tpg->se_tpg_tfo;
 
         len += sprintf(page+len, "SPC-3 Reservation: %s"
@@ -885,9 +1437,9 @@ static ssize_t target_core_dev_pr_show_attr_res_pr_holder_tg_port(
                 tfo->tpg_get_wwn(se_tpg));
         len += sprintf(page+len, "SPC-3 Reservation: Relative Port"
                 " Identifier Tag: %hu %s Portal Group Tag: %hu"
-                " %s Logical Unit: %u\n", lun->lun_sep->sep_rtpi,
+                " %s Logical Unit: %llu\n", pr_reg->tg_pt_sep_rtpi,
                 tfo->get_fabric_name(), tfo->tpg_get_tag(se_tpg),
-                tfo->get_fabric_name(), lun->unpacked_lun);
+                tfo->get_fabric_name(), pr_reg->pr_aptpl_target_lun);
 
 out_unlock:
         spin_unlock(&dev->dev_reservation_lock);
@@ -1012,12 +1564,12 @@ static match_table_t tokens = {
         {Opt_res_type, "res_type=%d"},
         {Opt_res_scope, "res_scope=%d"},
         {Opt_res_all_tg_pt, "res_all_tg_pt=%d"},
-        {Opt_mapped_lun, "mapped_lun=%d"},
+        {Opt_mapped_lun, "mapped_lun=%lld"},
         {Opt_target_fabric, "target_fabric=%s"},
         {Opt_target_node, "target_node=%s"},
         {Opt_tpgt, "tpgt=%d"},
         {Opt_port_rtpi, "port_rtpi=%d"},
-        {Opt_target_lun, "target_lun=%d"},
+        {Opt_target_lun, "target_lun=%lld"},
         {Opt_err, NULL}
 };
 
@@ -1032,10 +1584,10 @@ static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata(
         substring_t args[MAX_OPT_ARGS];
         unsigned long long tmp_ll;
         u64 sa_res_key = 0;
-        u32 mapped_lun = 0, target_lun = 0;
+        u64 mapped_lun = 0, target_lun = 0;
         int ret = -1, res_holder = 0, all_tg_pt = 0, arg, token;
-        u16 port_rpti = 0, tpgt = 0;
-        u8 type = 0, scope;
+        u16 tpgt = 0;
+        u8 type = 0;
 
         if (dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH)
                 return 0;
@@ -1115,7 +1667,6 @@ static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata(
                         break;
                 case Opt_res_scope:
                         match_int(args, &arg);
-                        scope = (u8)arg;
                         break;
                 case Opt_res_all_tg_pt:
                         match_int(args, &arg);
@@ -1123,7 +1674,7 @@ static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata(
                         break;
                 case Opt_mapped_lun:
                         match_int(args, &arg);
-                        mapped_lun = (u32)arg;
+                        mapped_lun = (u64)arg;
                         break;
                 /*
                  * PR APTPL Metadata for Target Port
@@ -1155,11 +1706,10 @@ static ssize_t target_core_dev_pr_store_attr_res_aptpl_metadata(
                         break;
                 case Opt_port_rtpi:
                         match_int(args, &arg);
-                        port_rpti = (u16)arg;
                         break;
                 case Opt_target_lun:
                         match_int(args, &arg);
-                        target_lun = (u32)arg;
+                        target_lun = (u64)arg;
                         break;
                 default:
                         break;
@@ -1223,13 +1773,13 @@ TB_CIT_SETUP(dev_pr, &target_core_dev_pr_ops, NULL, target_core_dev_pr_attrs);
 static ssize_t target_core_show_dev_info(void *p, char *page)
 {
         struct se_device *dev = p;
-        struct se_subsystem_api *t = dev->transport;
         int bl = 0;
         ssize_t read_bytes = 0;
 
         transport_dump_dev_state(dev, page, &bl);
         read_bytes += bl;
-        read_bytes += t->show_configfs_dev_params(dev, page+read_bytes);
+        read_bytes += dev->transport->show_configfs_dev_params(dev,
+                        page+read_bytes);
         return read_bytes;
 }
 
@@ -1247,9 +1797,8 @@ static ssize_t target_core_store_dev_control(
         size_t count)
 {
         struct se_device *dev = p;
-        struct se_subsystem_api *t = dev->transport;
 
-        return t->set_configfs_dev_params(dev, page, count);
+        return dev->transport->set_configfs_dev_params(dev, page, count);
 }
 
 static struct target_core_configfs_attribute target_core_attr_dev_control = {
@@ -2339,21 +2888,16 @@ static ssize_t target_core_alua_tg_pt_gp_show_attr_members(
         struct t10_alua_tg_pt_gp *tg_pt_gp,
         char *page)
 {
-        struct se_port *port;
-        struct se_portal_group *tpg;
         struct se_lun *lun;
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
         ssize_t len = 0, cur_len;
         unsigned char buf[TG_PT_GROUP_NAME_BUF];
 
         memset(buf, 0, TG_PT_GROUP_NAME_BUF);
 
         spin_lock(&tg_pt_gp->tg_pt_gp_lock);
-        list_for_each_entry(tg_pt_gp_mem, &tg_pt_gp->tg_pt_gp_mem_list,
-                        tg_pt_gp_mem_list) {
-                port = tg_pt_gp_mem->tg_pt;
-                tpg = port->sep_tpg;
-                lun = port->sep_lun;
+        list_for_each_entry(lun, &tg_pt_gp->tg_pt_gp_lun_list,
+                        lun_tg_pt_gp_link) {
+                struct se_portal_group *tpg = lun->lun_tpg;
 
                 cur_len = snprintf(buf, TG_PT_GROUP_NAME_BUF, "%s/%s/tpgt_%hu"
                         "/%s\n", tpg->se_tpg_tfo->get_fabric_name(),
@@ -2526,9 +3070,9 @@ static struct config_group *target_core_make_subdev(
         const char *name)
 {
         struct t10_alua_tg_pt_gp *tg_pt_gp;
-        struct se_subsystem_api *t;
         struct config_item *hba_ci = &group->cg_item;
         struct se_hba *hba = item_to_hba(hba_ci);
+        struct target_backend *tb = hba->backend;
         struct se_device *dev;
         struct config_group *dev_cg = NULL, *tg_pt_gp_cg = NULL;
         struct config_group *dev_stat_grp = NULL;
@@ -2537,10 +3081,6 @@ static struct config_group *target_core_make_subdev(
         ret = mutex_lock_interruptible(&hba->hba_access_mutex);
         if (ret)
                 return ERR_PTR(ret);
-        /*
-         * Locate the struct se_subsystem_api from parent's struct se_hba.
-         */
-        t = hba->transport;
 
         dev = target_alloc_device(hba, name);
         if (!dev)
@@ -2553,17 +3093,17 @@ static struct config_group *target_core_make_subdev(
         if (!dev_cg->default_groups)
                 goto out_free_device;
 
-        config_group_init_type_name(dev_cg, name, &t->tb_cits.tb_dev_cit);
+        config_group_init_type_name(dev_cg, name, &tb->tb_dev_cit);
         config_group_init_type_name(&dev->dev_attrib.da_group, "attrib",
-                        &t->tb_cits.tb_dev_attrib_cit);
+                        &tb->tb_dev_attrib_cit);
         config_group_init_type_name(&dev->dev_pr_group, "pr",
-                        &t->tb_cits.tb_dev_pr_cit);
+                        &tb->tb_dev_pr_cit);
         config_group_init_type_name(&dev->t10_wwn.t10_wwn_group, "wwn",
-                        &t->tb_cits.tb_dev_wwn_cit);
+                        &tb->tb_dev_wwn_cit);
         config_group_init_type_name(&dev->t10_alua.alua_tg_pt_gps_group,
-                        "alua", &t->tb_cits.tb_dev_alua_tg_pt_gps_cit);
+                        "alua", &tb->tb_dev_alua_tg_pt_gps_cit);
         config_group_init_type_name(&dev->dev_stat_grps.stat_group,
-                        "statistics", &t->tb_cits.tb_dev_stat_cit);
+                        "statistics", &tb->tb_dev_stat_cit);
 
         dev_cg->default_groups[0] = &dev->dev_attrib.da_group;
         dev_cg->default_groups[1] = &dev->dev_pr_group;
@@ -2693,8 +3233,8 @@ static ssize_t target_core_hba_show_attr_hba_info(
         char *page)
 {
         return sprintf(page, "HBA Index: %d plugin: %s version: %s\n",
-                        hba->hba_id, hba->transport->name,
-                        TARGET_CORE_CONFIGFS_VERSION);
+                        hba->hba_id, hba->backend->ops->name,
+                        TARGET_CORE_VERSION);
 }
 
 SE_HBA_ATTR_RO(hba_info);
@@ -2713,11 +3253,10 @@ static ssize_t target_core_hba_show_attr_hba_mode(struct se_hba *hba,
 static ssize_t target_core_hba_store_attr_hba_mode(struct se_hba *hba,
                                 const char *page, size_t count)
 {
-        struct se_subsystem_api *transport = hba->transport;
         unsigned long mode_flag;
         int ret;
 
-        if (transport->pmode_enable_hba == NULL)
+        if (hba->backend->ops->pmode_enable_hba == NULL)
                 return -EINVAL;
 
         ret = kstrtoul(page, 0, &mode_flag);
@@ -2731,7 +3270,7 @@ static ssize_t target_core_hba_store_attr_hba_mode(struct se_hba *hba,
                 return -EINVAL;
         }
 
-        ret = transport->pmode_enable_hba(hba, mode_flag);
+        ret = hba->backend->ops->pmode_enable_hba(hba, mode_flag);
         if (ret < 0)
                 return -EINVAL;
         if (ret > 0)
@@ -2857,16 +3396,15 @@ static struct config_item_type target_core_cit = {
 
 /* Stop functions for struct config_item_type target_core_hba_cit */
 
-void target_core_setup_sub_cits(struct se_subsystem_api *sa)
+void target_setup_backend_cits(struct target_backend *tb)
 {
-        target_core_setup_dev_cit(sa);
-        target_core_setup_dev_attrib_cit(sa);
-        target_core_setup_dev_pr_cit(sa);
-        target_core_setup_dev_wwn_cit(sa);
-        target_core_setup_dev_alua_tg_pt_gps_cit(sa);
-        target_core_setup_dev_stat_cit(sa);
+        target_core_setup_dev_cit(tb);
+        target_core_setup_dev_attrib_cit(tb);
+        target_core_setup_dev_pr_cit(tb);
+        target_core_setup_dev_wwn_cit(tb);
+        target_core_setup_dev_alua_tg_pt_gps_cit(tb);
+        target_core_setup_dev_stat_cit(tb);
 }
-EXPORT_SYMBOL(target_core_setup_sub_cits);
 
 static int __init target_core_init_configfs(void)
 {
@@ -2968,7 +3506,7 @@ static int __init target_core_init_configfs(void)
                 goto out_global;
         }
         pr_debug("TARGET_CORE[0]: Initialized ConfigFS Fabric"
-                " Infrastructure: "TARGET_CORE_CONFIGFS_VERSION" on %s/%s"
+                " Infrastructure: "TARGET_CORE_VERSION" on %s/%s"
                 " on "UTS_RELEASE"\n", utsname()->sysname, utsname()->machine);
         /*
          * Register built-in RAMDISK subsystem logic for virtual LUN 0
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index 417f88b498c7..09e682b1c549 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -56,40 +56,37 @@ static struct se_hba *lun0_hba;
 struct se_device *g_lun0_dev;
 
 sense_reason_t
-transport_lookup_cmd_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
+transport_lookup_cmd_lun(struct se_cmd *se_cmd, u64 unpacked_lun)
 {
         struct se_lun *se_lun = NULL;
         struct se_session *se_sess = se_cmd->se_sess;
-        struct se_device *dev;
-        unsigned long flags;
-
-        if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG)
-                return TCM_NON_EXISTENT_LUN;
-
-        spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);
-        se_cmd->se_deve = se_sess->se_node_acl->device_list[unpacked_lun];
-        if (se_cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
-                struct se_dev_entry *deve = se_cmd->se_deve;
+        struct se_node_acl *nacl = se_sess->se_node_acl;
+        struct se_dev_entry *deve;
 
-                deve->total_cmds++;
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, unpacked_lun);
+        if (deve) {
+                atomic_long_inc(&deve->total_cmds);
 
                 if ((se_cmd->data_direction == DMA_TO_DEVICE) &&
                     (deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)) {
                         pr_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN"
-                                " Access for 0x%08x\n",
+                                " Access for 0x%08llx\n",
                                 se_cmd->se_tfo->get_fabric_name(),
                                 unpacked_lun);
-                        spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
+                        rcu_read_unlock();
                         return TCM_WRITE_PROTECTED;
                 }
 
                 if (se_cmd->data_direction == DMA_TO_DEVICE)
-                        deve->write_bytes += se_cmd->data_length;
+                        atomic_long_add(se_cmd->data_length,
+                                        &deve->write_bytes);
                 else if (se_cmd->data_direction == DMA_FROM_DEVICE)
-                        deve->read_bytes += se_cmd->data_length;
+                        atomic_long_add(se_cmd->data_length,
+                                        &deve->read_bytes);
 
-                se_lun = deve->se_lun;
-                se_cmd->se_lun = deve->se_lun;
+                se_lun = rcu_dereference(deve->se_lun);
+                se_cmd->se_lun = rcu_dereference(deve->se_lun);
                 se_cmd->pr_res_key = deve->pr_res_key;
                 se_cmd->orig_fe_lun = unpacked_lun;
                 se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;
@@ -97,7 +94,7 @@ transport_lookup_cmd_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
                 percpu_ref_get(&se_lun->lun_ref);
                 se_cmd->lun_ref_active = true;
         }
-        spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
+        rcu_read_unlock();
 
         if (!se_lun) {
                 /*
@@ -107,7 +104,7 @@ transport_lookup_cmd_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
                  */
                 if (unpacked_lun != 0) {
                         pr_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
-                                " Access for 0x%08x\n",
+                                " Access for 0x%08llx\n",
                                 se_cmd->se_tfo->get_fabric_name(),
                                 unpacked_lun);
                         return TCM_NON_EXISTENT_LUN;
@@ -119,64 +116,66 @@ transport_lookup_cmd_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
                     (se_cmd->data_direction != DMA_NONE))
                         return TCM_WRITE_PROTECTED;
 
-                se_lun = &se_sess->se_tpg->tpg_virt_lun0;
-                se_cmd->se_lun = &se_sess->se_tpg->tpg_virt_lun0;
+                se_lun = se_sess->se_tpg->tpg_virt_lun0;
+                se_cmd->se_lun = se_sess->se_tpg->tpg_virt_lun0;
                 se_cmd->orig_fe_lun = 0;
                 se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;
 
                 percpu_ref_get(&se_lun->lun_ref);
                 se_cmd->lun_ref_active = true;
         }
+        /*
+         * RCU reference protected by percpu se_lun->lun_ref taken above that
+         * must drop to zero (including initial reference) before this se_lun
+         * pointer can be kfree_rcu() by the final se_lun->lun_group put via
+         * target_core_fabric_configfs.c:target_fabric_port_release
+         */
+        se_cmd->se_dev = rcu_dereference_raw(se_lun->lun_se_dev);
+        atomic_long_inc(&se_cmd->se_dev->num_cmds);
 
-        /* Directly associate cmd with se_dev */
-        se_cmd->se_dev = se_lun->lun_se_dev;
-
-        dev = se_lun->lun_se_dev;
-        atomic_long_inc(&dev->num_cmds);
         if (se_cmd->data_direction == DMA_TO_DEVICE)
-                atomic_long_add(se_cmd->data_length, &dev->write_bytes);
+                atomic_long_add(se_cmd->data_length,
+                                &se_cmd->se_dev->write_bytes);
         else if (se_cmd->data_direction == DMA_FROM_DEVICE)
-                atomic_long_add(se_cmd->data_length, &dev->read_bytes);
+                atomic_long_add(se_cmd->data_length,
+                                &se_cmd->se_dev->read_bytes);
 
         return 0;
 }
 EXPORT_SYMBOL(transport_lookup_cmd_lun);
 
-int transport_lookup_tmr_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
+int transport_lookup_tmr_lun(struct se_cmd *se_cmd, u64 unpacked_lun)
 {
         struct se_dev_entry *deve;
         struct se_lun *se_lun = NULL;
         struct se_session *se_sess = se_cmd->se_sess;
+        struct se_node_acl *nacl = se_sess->se_node_acl;
         struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;
         unsigned long flags;
 
-        if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG)
-                return -ENODEV;
-
-        spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);
-        se_cmd->se_deve = se_sess->se_node_acl->device_list[unpacked_lun];
-        deve = se_cmd->se_deve;
-
-        if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
-                se_tmr->tmr_lun = deve->se_lun;
-                se_cmd->se_lun = deve->se_lun;
-                se_lun = deve->se_lun;
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, unpacked_lun);
+        if (deve) {
+                se_tmr->tmr_lun = rcu_dereference(deve->se_lun);
+                se_cmd->se_lun = rcu_dereference(deve->se_lun);
+                se_lun = rcu_dereference(deve->se_lun);
                 se_cmd->pr_res_key = deve->pr_res_key;
                 se_cmd->orig_fe_lun = unpacked_lun;
         }
-        spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
+        rcu_read_unlock();
 
         if (!se_lun) {
                 pr_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
-                        " Access for 0x%08x\n",
+                        " Access for 0x%08llx\n",
                         se_cmd->se_tfo->get_fabric_name(),
                         unpacked_lun);
                 return -ENODEV;
         }
-
-        /* Directly associate cmd with se_dev */
-        se_cmd->se_dev = se_lun->lun_se_dev;
-        se_tmr->tmr_dev = se_lun->lun_se_dev;
+        /*
+         * XXX: Add percpu se_lun->lun_ref reference count for TMR
+         */
+        se_cmd->se_dev = rcu_dereference_raw(se_lun->lun_se_dev);
+        se_tmr->tmr_dev = rcu_dereference_raw(se_lun->lun_se_dev);
 
         spin_lock_irqsave(&se_tmr->tmr_dev->se_tmr_lock, flags);
         list_add_tail(&se_tmr->tmr_list, &se_tmr->tmr_dev->dev_tmr_list);
@@ -186,9 +185,24 @@ int transport_lookup_tmr_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
 }
 EXPORT_SYMBOL(transport_lookup_tmr_lun);
 
+bool target_lun_is_rdonly(struct se_cmd *cmd)
+{
+        struct se_session *se_sess = cmd->se_sess;
+        struct se_dev_entry *deve;
+        bool ret;
+
+        rcu_read_lock();
+        deve = target_nacl_find_deve(se_sess->se_node_acl, cmd->orig_fe_lun);
+        ret = (deve && deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY);
+        rcu_read_unlock();
+
+        return ret;
+}
+EXPORT_SYMBOL(target_lun_is_rdonly);
+
 /*
  * This function is called from core_scsi3_emulate_pro_register_and_move()
- * and core_scsi3_decode_spec_i_port(), and will increment &deve->pr_ref_count
+ * and core_scsi3_decode_spec_i_port(), and will increment &deve->pr_kref
  * when a matching rtpi is found.
  */
 struct se_dev_entry *core_get_se_deve_from_rtpi(
@@ -197,231 +211,238 @@ struct se_dev_entry *core_get_se_deve_from_rtpi(
 {
         struct se_dev_entry *deve;
         struct se_lun *lun;
-        struct se_port *port;
         struct se_portal_group *tpg = nacl->se_tpg;
-        u32 i;
-
-        spin_lock_irq(&nacl->device_list_lock);
-        for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
-                deve = nacl->device_list[i];
 
-                if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
-                        continue;
-
-                lun = deve->se_lun;
+        rcu_read_lock();
+        hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) {
+                lun = rcu_dereference(deve->se_lun);
                 if (!lun) {
                         pr_err("%s device entries device pointer is"
                                 " NULL, but Initiator has access.\n",
                                 tpg->se_tpg_tfo->get_fabric_name());
                         continue;
                 }
-                port = lun->lun_sep;
-                if (!port) {
-                        pr_err("%s device entries device pointer is"
-                                " NULL, but Initiator has access.\n",
-                                tpg->se_tpg_tfo->get_fabric_name());
-                        continue;
-                }
-                if (port->sep_rtpi != rtpi)
+                if (lun->lun_rtpi != rtpi)
                         continue;
 
-                atomic_inc_mb(&deve->pr_ref_count);
-                spin_unlock_irq(&nacl->device_list_lock);
+                kref_get(&deve->pr_kref);
+                rcu_read_unlock();
 
                 return deve;
         }
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
 
         return NULL;
 }
 
-int core_free_device_list_for_node(
+void core_free_device_list_for_node(
         struct se_node_acl *nacl,
         struct se_portal_group *tpg)
 {
         struct se_dev_entry *deve;
-        struct se_lun *lun;
-        u32 i;
-
-        if (!nacl->device_list)
-                return 0;
-
-        spin_lock_irq(&nacl->device_list_lock);
-        for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
-                deve = nacl->device_list[i];
-
-                if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
-                        continue;
-
-                if (!deve->se_lun) {
-                        pr_err("%s device entries device pointer is"
-                                " NULL, but Initiator has access.\n",
-                                tpg->se_tpg_tfo->get_fabric_name());
-                        continue;
-                }
-                lun = deve->se_lun;
 
-                spin_unlock_irq(&nacl->device_list_lock);
-                core_disable_device_list_for_node(lun, NULL, deve->mapped_lun,
-                        TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);
-                spin_lock_irq(&nacl->device_list_lock);
+        mutex_lock(&nacl->lun_entry_mutex);
+        hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) {
+                struct se_lun *lun = rcu_dereference_check(deve->se_lun,
+                                        lockdep_is_held(&nacl->lun_entry_mutex));
+                core_disable_device_list_for_node(lun, deve, nacl, tpg);
         }
-        spin_unlock_irq(&nacl->device_list_lock);
-
-        array_free(nacl->device_list, TRANSPORT_MAX_LUNS_PER_TPG);
-        nacl->device_list = NULL;
-
-        return 0;
+        mutex_unlock(&nacl->lun_entry_mutex);
 }
 
 void core_update_device_list_access(
-        u32 mapped_lun,
+        u64 mapped_lun,
         u32 lun_access,
         struct se_node_acl *nacl)
 {
         struct se_dev_entry *deve;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[mapped_lun];
-        if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
-                deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
-                deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;
-        } else {
-                deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
-                deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;
+        mutex_lock(&nacl->lun_entry_mutex);
+        deve = target_nacl_find_deve(nacl, mapped_lun);
+        if (deve) {
+                if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
+                        deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
+                        deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;
+                } else {
+                        deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
+                        deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;
+                }
         }
-        spin_unlock_irq(&nacl->device_list_lock);
+        mutex_unlock(&nacl->lun_entry_mutex);
 }
 
-/*      core_enable_device_list_for_node():
- *
- *
+/*
+ * Called with rcu_read_lock or nacl->device_list_lock held.
  */
+struct se_dev_entry *target_nacl_find_deve(struct se_node_acl *nacl, u64 mapped_lun)
+{
+        struct se_dev_entry *deve;
+
+        hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link)
+                if (deve->mapped_lun == mapped_lun)
+                        return deve;
+
+        return NULL;
+}
+EXPORT_SYMBOL(target_nacl_find_deve);
+
+void target_pr_kref_release(struct kref *kref)
+{
+        struct se_dev_entry *deve = container_of(kref, struct se_dev_entry,
+                                                 pr_kref);
+        complete(&deve->pr_comp);
+}
+
+static void
+target_luns_data_has_changed(struct se_node_acl *nacl, struct se_dev_entry *new,
+                             bool skip_new)
+{
+        struct se_dev_entry *tmp;
+
+        rcu_read_lock();
+        hlist_for_each_entry_rcu(tmp, &nacl->lun_entry_hlist, link) {
+                if (skip_new && tmp == new)
+                        continue;
+                core_scsi3_ua_allocate(tmp, 0x3F,
+                                       ASCQ_3FH_REPORTED_LUNS_DATA_HAS_CHANGED);
+        }
+        rcu_read_unlock();
+}
+
 int core_enable_device_list_for_node(
         struct se_lun *lun,
         struct se_lun_acl *lun_acl,
-        u32 mapped_lun,
+        u64 mapped_lun,
         u32 lun_access,
         struct se_node_acl *nacl,
         struct se_portal_group *tpg)
 {
-        struct se_port *port = lun->lun_sep;
-        struct se_dev_entry *deve;
-
-        spin_lock_irq(&nacl->device_list_lock);
-
-        deve = nacl->device_list[mapped_lun];
-
-        /*
-         * Check if the call is handling demo mode -> explicit LUN ACL
-         * transition.  This transition must be for the same struct se_lun
-         * + mapped_lun that was setup in demo mode..
-         */
-        if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
-                if (deve->se_lun_acl != NULL) {
-                        pr_err("struct se_dev_entry->se_lun_acl"
-                               " already set for demo mode -> explicit"
-                               " LUN ACL transition\n");
-                        spin_unlock_irq(&nacl->device_list_lock);
+        struct se_dev_entry *orig, *new;
+
+        new = kzalloc(sizeof(*new), GFP_KERNEL);
+        if (!new) {
+                pr_err("Unable to allocate se_dev_entry memory\n");
+                return -ENOMEM;
+        }
+
+        atomic_set(&new->ua_count, 0);
+        spin_lock_init(&new->ua_lock);
+        INIT_LIST_HEAD(&new->ua_list);
+        INIT_LIST_HEAD(&new->lun_link);
+
+        new->mapped_lun = mapped_lun;
+        kref_init(&new->pr_kref);
+        init_completion(&new->pr_comp);
+
+        if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE)
+                new->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;
+        else
+                new->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;
+
+        new->creation_time = get_jiffies_64();
+        new->attach_count++;
+
+        mutex_lock(&nacl->lun_entry_mutex);
+        orig = target_nacl_find_deve(nacl, mapped_lun);
+        if (orig && orig->se_lun) {
+                struct se_lun *orig_lun = rcu_dereference_check(orig->se_lun,
+                                        lockdep_is_held(&nacl->lun_entry_mutex));
+
+                if (orig_lun != lun) {
+                        pr_err("Existing orig->se_lun doesn't match new lun"
+                               " for dynamic -> explicit NodeACL conversion:"
+                                " %s\n", nacl->initiatorname);
+                        mutex_unlock(&nacl->lun_entry_mutex);
+                        kfree(new);
                         return -EINVAL;
                 }
-                if (deve->se_lun != lun) {
-                        pr_err("struct se_dev_entry->se_lun does"
-                               " match passed struct se_lun for demo mode"
-                               " -> explicit LUN ACL transition\n");
-                        spin_unlock_irq(&nacl->device_list_lock);
-                        return -EINVAL;
-                }
-                deve->se_lun_acl = lun_acl;
+                BUG_ON(orig->se_lun_acl != NULL);
 
-                if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
-                        deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
-                        deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;
-                } else {
-                        deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
-                        deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;
-                }
+                rcu_assign_pointer(new->se_lun, lun);
+                rcu_assign_pointer(new->se_lun_acl, lun_acl);
+                hlist_del_rcu(&orig->link);
+                hlist_add_head_rcu(&new->link, &nacl->lun_entry_hlist);
+                mutex_unlock(&nacl->lun_entry_mutex);
 
-                spin_unlock_irq(&nacl->device_list_lock);
-                return 0;
-        }
+                spin_lock(&lun->lun_deve_lock);
+                list_del(&orig->lun_link);
+                list_add_tail(&new->lun_link, &lun->lun_deve_list);
+                spin_unlock(&lun->lun_deve_lock);
+
+                kref_put(&orig->pr_kref, target_pr_kref_release);
+                wait_for_completion(&orig->pr_comp);
 
-        deve->se_lun = lun;
-        deve->se_lun_acl = lun_acl;
-        deve->mapped_lun = mapped_lun;
-        deve->lun_flags |= TRANSPORT_LUNFLAGS_INITIATOR_ACCESS;
-
-        if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
-                deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
-                deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;
-        } else {
-                deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
-                deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;
+                target_luns_data_has_changed(nacl, new, true);
+                kfree_rcu(orig, rcu_head);
+                return 0;
         }
 
-        deve->creation_time = get_jiffies_64();
-        deve->attach_count++;
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_assign_pointer(new->se_lun, lun);
+        rcu_assign_pointer(new->se_lun_acl, lun_acl);
+        hlist_add_head_rcu(&new->link, &nacl->lun_entry_hlist);
+        mutex_unlock(&nacl->lun_entry_mutex);
 
-        spin_lock_bh(&port->sep_alua_lock);
-        list_add_tail(&deve->alua_port_list, &port->sep_alua_list);
-        spin_unlock_bh(&port->sep_alua_lock);
+        spin_lock(&lun->lun_deve_lock);
+        list_add_tail(&new->lun_link, &lun->lun_deve_list);
+        spin_unlock(&lun->lun_deve_lock);
 
+        target_luns_data_has_changed(nacl, new, true);
         return 0;
 }
 
-/*      core_disable_device_list_for_node():
- *
- *
+/*
+ *      Called with se_node_acl->lun_entry_mutex held.
  */
-int core_disable_device_list_for_node(
+void core_disable_device_list_for_node(
         struct se_lun *lun,
-        struct se_lun_acl *lun_acl,
-        u32 mapped_lun,
-        u32 lun_access,
+        struct se_dev_entry *orig,
         struct se_node_acl *nacl,
         struct se_portal_group *tpg)
 {
-        struct se_port *port = lun->lun_sep;
-        struct se_dev_entry *deve = nacl->device_list[mapped_lun];
-
+        /*
+         * rcu_dereference_raw protected by se_lun->lun_group symlink
+         * reference to se_device->dev_group.
+         */
+        struct se_device *dev = rcu_dereference_raw(lun->lun_se_dev);
         /*
          * If the MappedLUN entry is being disabled, the entry in
-         * port->sep_alua_list must be removed now before clearing the
+         * lun->lun_deve_list must be removed now before clearing the
          * struct se_dev_entry pointers below as logic in
          * core_alua_do_transition_tg_pt() depends on these being present.
          *
          * deve->se_lun_acl will be NULL for demo-mode created LUNs
          * that have not been explicitly converted to MappedLUNs ->
-         * struct se_lun_acl, but we remove deve->alua_port_list from
-         * port->sep_alua_list. This also means that active UAs and
+         * struct se_lun_acl, but we remove deve->lun_link from
+         * lun->lun_deve_list. This also means that active UAs and
          * NodeACL context specific PR metadata for demo-mode
          * MappedLUN *deve will be released below..
          */
-        spin_lock_bh(&port->sep_alua_lock);
-        list_del(&deve->alua_port_list);
-        spin_unlock_bh(&port->sep_alua_lock);
+        spin_lock(&lun->lun_deve_lock);
+        list_del(&orig->lun_link);
+        spin_unlock(&lun->lun_deve_lock);
         /*
-         * Wait for any in process SPEC_I_PT=1 or REGISTER_AND_MOVE
-         * PR operation to complete.
+         * Disable struct se_dev_entry LUN ACL mapping
          */
-        while (atomic_read(&deve->pr_ref_count) != 0)
-                cpu_relax();
-
-        spin_lock_irq(&nacl->device_list_lock);
+        core_scsi3_ua_release_all(orig);
+
+        hlist_del_rcu(&orig->link);
+        clear_bit(DEF_PR_REG_ACTIVE, &orig->deve_flags);
+        rcu_assign_pointer(orig->se_lun, NULL);
+        rcu_assign_pointer(orig->se_lun_acl, NULL);
+        orig->lun_flags = 0;
+        orig->creation_time = 0;
+        orig->attach_count--;
         /*
-         * Disable struct se_dev_entry LUN ACL mapping
+         * Before firing off RCU callback, wait for any in process SPEC_I_PT=1
+         * or REGISTER_AND_MOVE PR operation to complete.
          */
-        core_scsi3_ua_release_all(deve);
-        deve->se_lun = NULL;
-        deve->se_lun_acl = NULL;
-        deve->lun_flags = 0;
-        deve->creation_time = 0;
-        deve->attach_count--;
-        spin_unlock_irq(&nacl->device_list_lock);
-
-        core_scsi3_free_pr_reg_from_nacl(lun->lun_se_dev, nacl);
-        return 0;
+        kref_put(&orig->pr_kref, target_pr_kref_release);
+        wait_for_completion(&orig->pr_comp);
+
+        kfree_rcu(orig, rcu_head);
+
+        core_scsi3_free_pr_reg_from_nacl(dev, nacl);
+        target_luns_data_has_changed(nacl, NULL, false);
 }
 
 /*      core_clear_lun_from_tpg():
@@ -432,53 +453,35 @@ void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg)
 {
         struct se_node_acl *nacl;
         struct se_dev_entry *deve;
-        u32 i;
 
-        spin_lock_irq(&tpg->acl_node_lock);
+        mutex_lock(&tpg->acl_node_mutex);
         list_for_each_entry(nacl, &tpg->acl_node_list, acl_list) {
-                spin_unlock_irq(&tpg->acl_node_lock);
 
-                spin_lock_irq(&nacl->device_list_lock);
-                for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
-                        deve = nacl->device_list[i];
-                        if (lun != deve->se_lun)
-                                continue;
-                        spin_unlock_irq(&nacl->device_list_lock);
+                mutex_lock(&nacl->lun_entry_mutex);
+                hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) {
+                        struct se_lun *tmp_lun = rcu_dereference_check(deve->se_lun,
+                                        lockdep_is_held(&nacl->lun_entry_mutex));
 
-                        core_disable_device_list_for_node(lun, NULL,
-                                deve->mapped_lun, TRANSPORT_LUNFLAGS_NO_ACCESS,
-                                nacl, tpg);
+                        if (lun != tmp_lun)
+                                continue;
 
-                        spin_lock_irq(&nacl->device_list_lock);
+                        core_disable_device_list_for_node(lun, deve, nacl, tpg);
                 }
-                spin_unlock_irq(&nacl->device_list_lock);
-
-                spin_lock_irq(&tpg->acl_node_lock);
+                mutex_unlock(&nacl->lun_entry_mutex);
         }
-        spin_unlock_irq(&tpg->acl_node_lock);
+        mutex_unlock(&tpg->acl_node_mutex);
 }
 
-static struct se_port *core_alloc_port(struct se_device *dev)
+int core_alloc_rtpi(struct se_lun *lun, struct se_device *dev)
 {
-        struct se_port *port, *port_tmp;
-
-        port = kzalloc(sizeof(struct se_port), GFP_KERNEL);
-        if (!port) {
-                pr_err("Unable to allocate struct se_port\n");
-                return ERR_PTR(-ENOMEM);
-        }
-        INIT_LIST_HEAD(&port->sep_alua_list);
-        INIT_LIST_HEAD(&port->sep_list);
-        atomic_set(&port->sep_tg_pt_secondary_offline, 0);
-        spin_lock_init(&port->sep_alua_lock);
-        mutex_init(&port->sep_tg_pt_md_mutex);
+        struct se_lun *tmp;
 
         spin_lock(&dev->se_port_lock);
-        if (dev->dev_port_count == 0x0000ffff) {
+        if (dev->export_count == 0x0000ffff) {
                 pr_warn("Reached dev->dev_port_count =="
                                 " 0x0000ffff\n");
                 spin_unlock(&dev->se_port_lock);
-                return ERR_PTR(-ENOSPC);
+                return -ENOSPC;
         }
 again:
         /*
@@ -493,133 +496,23 @@ again:
          * 2h        Relative port 2, historically known as port B
          * 3h to FFFFh    Relative port 3 through 65 535
          */
-        port->sep_rtpi = dev->dev_rpti_counter++;
-        if (!port->sep_rtpi)
+        lun->lun_rtpi = dev->dev_rpti_counter++;
+        if (!lun->lun_rtpi)
                 goto again;
 
-        list_for_each_entry(port_tmp, &dev->dev_sep_list, sep_list) {
+        list_for_each_entry(tmp, &dev->dev_sep_list, lun_dev_link) {
                 /*
                  * Make sure RELATIVE TARGET PORT IDENTIFIER is unique
                  * for 16-bit wrap..
                  */
-                if (port->sep_rtpi == port_tmp->sep_rtpi)
+                if (lun->lun_rtpi == tmp->lun_rtpi)
                         goto again;
         }
         spin_unlock(&dev->se_port_lock);
 
-        return port;
-}
-
-static void core_export_port(
-        struct se_device *dev,
-        struct se_portal_group *tpg,
-        struct se_port *port,
-        struct se_lun *lun)
-{
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem = NULL;
-
-        spin_lock(&dev->se_port_lock);
-        spin_lock(&lun->lun_sep_lock);
-        port->sep_tpg = tpg;
-        port->sep_lun = lun;
-        lun->lun_sep = port;
-        spin_unlock(&lun->lun_sep_lock);
-
-        list_add_tail(&port->sep_list, &dev->dev_sep_list);
-        spin_unlock(&dev->se_port_lock);
-
-        if (!(dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH) &&
-            !(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"
-                                        "_gp_member_t\n");
-                        return;
-                }
-                spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-                __core_alua_attach_tg_pt_gp_mem(tg_pt_gp_mem,
-                        dev->t10_alua.default_tg_pt_gp);
-                spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-                pr_debug("%s/%s: Adding to default ALUA Target Port"
-                        " Group: alua/default_tg_pt_gp\n",
-                        dev->transport->name, tpg->se_tpg_tfo->get_fabric_name());
-        }
-
-        dev->dev_port_count++;
-        port->sep_index = port->sep_rtpi; /* RELATIVE TARGET PORT IDENTIFIER */
-}
-
-/*
- *      Called with struct se_device->se_port_lock spinlock held.
- */
-static void core_release_port(struct se_device *dev, struct se_port *port)
-        __releases(&dev->se_port_lock) __acquires(&dev->se_port_lock)
-{
-        /*
-         * Wait for any port reference for PR ALL_TG_PT=1 operation
-         * to complete in __core_scsi3_alloc_registration()
-         */
-        spin_unlock(&dev->se_port_lock);
-        if (atomic_read(&port->sep_tg_pt_ref_cnt))
-                cpu_relax();
-        spin_lock(&dev->se_port_lock);
-
-        core_alua_free_tg_pt_gp_mem(port);
-
-        list_del(&port->sep_list);
-        dev->dev_port_count--;
-        kfree(port);
-}
-
-int core_dev_export(
-        struct se_device *dev,
-        struct se_portal_group *tpg,
-        struct se_lun *lun)
-{
-        struct se_hba *hba = dev->se_hba;
-        struct se_port *port;
-
-        port = core_alloc_port(dev);
-        if (IS_ERR(port))
-                return PTR_ERR(port);
-
-        lun->lun_se_dev = dev;
-
-        spin_lock(&hba->device_lock);
-        dev->export_count++;
-        spin_unlock(&hba->device_lock);
-
-        core_export_port(dev, tpg, port, lun);
         return 0;
 }
 
-void core_dev_unexport(
-        struct se_device *dev,
-        struct se_portal_group *tpg,
-        struct se_lun *lun)
-{
-        struct se_hba *hba = dev->se_hba;
-        struct se_port *port = lun->lun_sep;
-
-        spin_lock(&lun->lun_sep_lock);
-        if (lun->lun_se_dev == NULL) {
-                spin_unlock(&lun->lun_sep_lock);
-                return;
-        }
-        spin_unlock(&lun->lun_sep_lock);
-
-        spin_lock(&dev->se_port_lock);
-        core_release_port(dev, port);
-        spin_unlock(&dev->se_port_lock);
-
-        spin_lock(&hba->device_lock);
-        dev->export_count--;
-        spin_unlock(&hba->device_lock);
-
-        lun->lun_sep = NULL;
-        lun->lun_se_dev = NULL;
-}
-
 static void se_release_vpd_for_dev(struct se_device *dev)
 {
         struct t10_vpd *vpd, *vpd_tmp;
@@ -651,556 +544,19 @@ static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)
         return aligned_max_sectors;
 }
 
-bool se_dev_check_wce(struct se_device *dev)
-{
-        bool wce = false;
-
-        if (dev->transport->get_write_cache)
-                wce = dev->transport->get_write_cache(dev);
-        else if (dev->dev_attrib.emulate_write_cache > 0)
-                wce = true;
-
-        return wce;
-}
-
-int se_dev_set_max_unmap_lba_count(
-        struct se_device *dev,
-        u32 max_unmap_lba_count)
-{
-        dev->dev_attrib.max_unmap_lba_count = max_unmap_lba_count;
-        pr_debug("dev[%p]: Set max_unmap_lba_count: %u\n",
-                        dev, dev->dev_attrib.max_unmap_lba_count);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_max_unmap_lba_count);
-
-int se_dev_set_max_unmap_block_desc_count(
-        struct se_device *dev,
-        u32 max_unmap_block_desc_count)
-{
-        dev->dev_attrib.max_unmap_block_desc_count =
-                max_unmap_block_desc_count;
-        pr_debug("dev[%p]: Set max_unmap_block_desc_count: %u\n",
-                        dev, dev->dev_attrib.max_unmap_block_desc_count);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_max_unmap_block_desc_count);
-
-int se_dev_set_unmap_granularity(
-        struct se_device *dev,
-        u32 unmap_granularity)
-{
-        dev->dev_attrib.unmap_granularity = unmap_granularity;
-        pr_debug("dev[%p]: Set unmap_granularity: %u\n",
-                        dev, dev->dev_attrib.unmap_granularity);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_unmap_granularity);
-
-int se_dev_set_unmap_granularity_alignment(
-        struct se_device *dev,
-        u32 unmap_granularity_alignment)
-{
-        dev->dev_attrib.unmap_granularity_alignment = unmap_granularity_alignment;
-        pr_debug("dev[%p]: Set unmap_granularity_alignment: %u\n",
-                        dev, dev->dev_attrib.unmap_granularity_alignment);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_unmap_granularity_alignment);
-
-int se_dev_set_max_write_same_len(
-        struct se_device *dev,
-        u32 max_write_same_len)
-{
-        dev->dev_attrib.max_write_same_len = max_write_same_len;
-        pr_debug("dev[%p]: Set max_write_same_len: %u\n",
-                        dev, dev->dev_attrib.max_write_same_len);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_max_write_same_len);
-
-static void dev_set_t10_wwn_model_alias(struct se_device *dev)
-{
-        const char *configname;
-
-        configname = config_item_name(&dev->dev_group.cg_item);
-        if (strlen(configname) >= 16) {
-                pr_warn("dev[%p]: Backstore name '%s' is too long for "
-                        "INQUIRY_MODEL, truncating to 16 bytes\n", dev,
-                        configname);
-        }
-        snprintf(&dev->t10_wwn.model[0], 16, "%s", configname);
-}
-
-int se_dev_set_emulate_model_alias(struct se_device *dev, int flag)
-{
-        if (dev->export_count) {
-                pr_err("dev[%p]: Unable to change model alias"
-                        " while export_count is %d\n",
-                        dev, dev->export_count);
-                        return -EINVAL;
-        }
-
-        if (flag != 0 && flag != 1) {
-                pr_err("Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-
-        if (flag) {
-                dev_set_t10_wwn_model_alias(dev);
-        } else {
-                strncpy(&dev->t10_wwn.model[0],
-                        dev->transport->inquiry_prod, 16);
-        }
-        dev->dev_attrib.emulate_model_alias = flag;
-
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_emulate_model_alias);
-
-int se_dev_set_emulate_dpo(struct se_device *dev, int flag)
-{
-        if (flag != 0 && flag != 1) {
-                pr_err("Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-
-        if (flag) {
-                pr_err("dpo_emulated not supported\n");
-                return -EINVAL;
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_emulate_dpo);
-
-int se_dev_set_emulate_fua_write(struct se_device *dev, int flag)
-{
-        if (flag != 0 && flag != 1) {
-                pr_err("Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-        if (flag &&
-            dev->transport->get_write_cache) {
-                pr_warn("emulate_fua_write not supported for this device, ignoring\n");
-                return 0;
-        }
-        if (dev->export_count) {
-                pr_err("emulate_fua_write cannot be changed with active"
-                       " exports: %d\n", dev->export_count);
-                return -EINVAL;
-        }
-        dev->dev_attrib.emulate_fua_write = flag;
-        pr_debug("dev[%p]: SE Device Forced Unit Access WRITEs: %d\n",
-                        dev, dev->dev_attrib.emulate_fua_write);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_emulate_fua_write);
-
-int se_dev_set_emulate_fua_read(struct se_device *dev, int flag)
-{
-        if (flag != 0 && flag != 1) {
-                pr_err("Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-
-        if (flag) {
-                pr_err("ua read emulated not supported\n");
-                return -EINVAL;
-        }
-
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_emulate_fua_read);
-
-int se_dev_set_emulate_write_cache(struct se_device *dev, int flag)
-{
-        if (flag != 0 && flag != 1) {
-                pr_err("Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-        if (flag &&
-            dev->transport->get_write_cache) {
-                pr_err("emulate_write_cache not supported for this device\n");
-                return -EINVAL;
-        }
-        if (dev->export_count) {
-                pr_err("emulate_write_cache cannot be changed with active"
-                       " exports: %d\n", dev->export_count);
-                return -EINVAL;
-        }
-        dev->dev_attrib.emulate_write_cache = flag;
-        pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",
-                        dev, dev->dev_attrib.emulate_write_cache);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_emulate_write_cache);
-
-int se_dev_set_emulate_ua_intlck_ctrl(struct se_device *dev, int flag)
-{
-        if ((flag != 0) && (flag != 1) && (flag != 2)) {
-                pr_err("Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-
-        if (dev->export_count) {
-                pr_err("dev[%p]: Unable to change SE Device"
-                        " UA_INTRLCK_CTRL while export_count is %d\n",
-                        dev, dev->export_count);
-                return -EINVAL;
-        }
-        dev->dev_attrib.emulate_ua_intlck_ctrl = flag;
-        pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n",
-                dev, dev->dev_attrib.emulate_ua_intlck_ctrl);
-
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_emulate_ua_intlck_ctrl);
-
-int se_dev_set_emulate_tas(struct se_device *dev, int flag)
-{
-        if ((flag != 0) && (flag != 1)) {
-                pr_err("Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-
-        if (dev->export_count) {
-                pr_err("dev[%p]: Unable to change SE Device TAS while"
-                        " export_count is %d\n",
-                        dev, dev->export_count);
-                return -EINVAL;
-        }
-        dev->dev_attrib.emulate_tas = flag;
-        pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n",
-                dev, (dev->dev_attrib.emulate_tas) ? "Enabled" : "Disabled");
-
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_emulate_tas);
-
-int se_dev_set_emulate_tpu(struct se_device *dev, int flag)
-{
-        if ((flag != 0) && (flag != 1)) {
-                pr_err("Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-        /*
-         * We expect this value to be non-zero when generic Block Layer
-         * Discard supported is detected iblock_create_virtdevice().
-         */
-        if (flag && !dev->dev_attrib.max_unmap_block_desc_count) {
-                pr_err("Generic Block Discard not supported\n");
-                return -ENOSYS;
-        }
-
-        dev->dev_attrib.emulate_tpu = flag;
-        pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n",
-                                dev, flag);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_emulate_tpu);
-
-int se_dev_set_emulate_tpws(struct se_device *dev, int flag)
-{
-        if ((flag != 0) && (flag != 1)) {
-                pr_err("Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-        /*
-         * We expect this value to be non-zero when generic Block Layer
-         * Discard supported is detected iblock_create_virtdevice().
-         */
-        if (flag && !dev->dev_attrib.max_unmap_block_desc_count) {
-                pr_err("Generic Block Discard not supported\n");
-                return -ENOSYS;
-        }
-
-        dev->dev_attrib.emulate_tpws = flag;
-        pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n",
-                                dev, flag);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_emulate_tpws);
-
-int se_dev_set_emulate_caw(struct se_device *dev, int flag)
-{
-        if (flag != 0 && flag != 1) {
-                pr_err("Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-        dev->dev_attrib.emulate_caw = flag;
-        pr_debug("dev[%p]: SE Device CompareAndWrite (AtomicTestandSet): %d\n",
-                 dev, flag);
-
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_emulate_caw);
-
-int se_dev_set_emulate_3pc(struct se_device *dev, int flag)
-{
-        if (flag != 0 && flag != 1) {
-                pr_err("Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-        dev->dev_attrib.emulate_3pc = flag;
-        pr_debug("dev[%p]: SE Device 3rd Party Copy (EXTENDED_COPY): %d\n",
-                dev, flag);
-
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_emulate_3pc);
-
-int se_dev_set_pi_prot_type(struct se_device *dev, int flag)
-{
-        int rc, old_prot = dev->dev_attrib.pi_prot_type;
-
-        if (flag != 0 && flag != 1 && flag != 2 && flag != 3) {
-                pr_err("Illegal value %d for pi_prot_type\n", flag);
-                return -EINVAL;
-        }
-        if (flag == 2) {
-                pr_err("DIF TYPE2 protection currently not supported\n");
-                return -ENOSYS;
-        }
-        if (dev->dev_attrib.hw_pi_prot_type) {
-                pr_warn("DIF protection enabled on underlying hardware,"
-                        " ignoring\n");
-                return 0;
-        }
-        if (!dev->transport->init_prot || !dev->transport->free_prot) {
-                /* 0 is only allowed value for non-supporting backends */
-                if (flag == 0)
-                        return 0;
-
-                pr_err("DIF protection not supported by backend: %s\n",
-                       dev->transport->name);
-                return -ENOSYS;
-        }
-        if (!(dev->dev_flags & DF_CONFIGURED)) {
-                pr_err("DIF protection requires device to be configured\n");
-                return -ENODEV;
-        }
-        if (dev->export_count) {
-                pr_err("dev[%p]: Unable to change SE Device PROT type while"
-                       " export_count is %d\n", dev, dev->export_count);
-                return -EINVAL;
-        }
-
-        dev->dev_attrib.pi_prot_type = flag;
-
-        if (flag && !old_prot) {
-                rc = dev->transport->init_prot(dev);
-                if (rc) {
-                        dev->dev_attrib.pi_prot_type = old_prot;
-                        return rc;
-                }
-
-        } else if (!flag && old_prot) {
-                dev->transport->free_prot(dev);
-        }
-        pr_debug("dev[%p]: SE Device Protection Type: %d\n", dev, flag);
-
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_pi_prot_type);
-
-int se_dev_set_pi_prot_format(struct se_device *dev, int flag)
-{
-        int rc;
-
-        if (!flag)
-                return 0;
-
-        if (flag != 1) {
-                pr_err("Illegal value %d for pi_prot_format\n", flag);
-                return -EINVAL;
-        }
-        if (!dev->transport->format_prot) {
-                pr_err("DIF protection format not supported by backend %s\n",
-                       dev->transport->name);
-                return -ENOSYS;
-        }
-        if (!(dev->dev_flags & DF_CONFIGURED)) {
-                pr_err("DIF protection format requires device to be configured\n");
-                return -ENODEV;
-        }
-        if (dev->export_count) {
-                pr_err("dev[%p]: Unable to format SE Device PROT type while"
-                       " export_count is %d\n", dev, dev->export_count);
-                return -EINVAL;
-        }
-
-        rc = dev->transport->format_prot(dev);
-        if (rc)
-                return rc;
-
-        pr_debug("dev[%p]: SE Device Protection Format complete\n", dev);
-
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_pi_prot_format);
-
-int se_dev_set_enforce_pr_isids(struct se_device *dev, int flag)
-{
-        if ((flag != 0) && (flag != 1)) {
-                pr_err("Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-        dev->dev_attrib.enforce_pr_isids = flag;
-        pr_debug("dev[%p]: SE Device enforce_pr_isids bit: %s\n", dev,
-                (dev->dev_attrib.enforce_pr_isids) ? "Enabled" : "Disabled");
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_enforce_pr_isids);
-
-int se_dev_set_force_pr_aptpl(struct se_device *dev, int flag)
-{
-        if ((flag != 0) && (flag != 1)) {
-                printk(KERN_ERR "Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-        if (dev->export_count) {
-                pr_err("dev[%p]: Unable to set force_pr_aptpl while"
-                       " export_count is %d\n", dev, dev->export_count);
-                return -EINVAL;
-        }
-
-        dev->dev_attrib.force_pr_aptpl = flag;
-        pr_debug("dev[%p]: SE Device force_pr_aptpl: %d\n", dev, flag);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_force_pr_aptpl);
-
-int se_dev_set_is_nonrot(struct se_device *dev, int flag)
-{
-        if ((flag != 0) && (flag != 1)) {
-                printk(KERN_ERR "Illegal value %d\n", flag);
-                return -EINVAL;
-        }
-        dev->dev_attrib.is_nonrot = flag;
-        pr_debug("dev[%p]: SE Device is_nonrot bit: %d\n",
-               dev, flag);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_is_nonrot);
-
-int se_dev_set_emulate_rest_reord(struct se_device *dev, int flag)
-{
-        if (flag != 0) {
-                printk(KERN_ERR "dev[%p]: SE Device emulatation of restricted"
-                        " reordering not implemented\n", dev);
-                return -ENOSYS;
-        }
-        dev->dev_attrib.emulate_rest_reord = flag;
-        pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n", dev, flag);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_emulate_rest_reord);
-
-/*
- * Note, this can only be called on unexported SE Device Object.
- */
-int se_dev_set_queue_depth(struct se_device *dev, u32 queue_depth)
-{
-        if (dev->export_count) {
-                pr_err("dev[%p]: Unable to change SE Device TCQ while"
-                        " export_count is %d\n",
-                        dev, dev->export_count);
-                return -EINVAL;
-        }
-        if (!queue_depth) {
-                pr_err("dev[%p]: Illegal ZERO value for queue"
-                        "_depth\n", dev);
-                return -EINVAL;
-        }
-
-        if (queue_depth > dev->dev_attrib.queue_depth) {
-                if (queue_depth > dev->dev_attrib.hw_queue_depth) {
-                        pr_err("dev[%p]: Passed queue_depth:"
-                                " %u exceeds TCM/SE_Device MAX"
-                                " TCQ: %u\n", dev, queue_depth,
-                                dev->dev_attrib.hw_queue_depth);
-                        return -EINVAL;
-                }
-        }
-        dev->dev_attrib.queue_depth = dev->queue_depth = queue_depth;
-        pr_debug("dev[%p]: SE Device TCQ Depth changed to: %u\n",
-                        dev, queue_depth);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_queue_depth);
-
-int se_dev_set_optimal_sectors(struct se_device *dev, u32 optimal_sectors)
-{
-        if (dev->export_count) {
-                pr_err("dev[%p]: Unable to change SE Device"
-                        " optimal_sectors while export_count is %d\n",
-                        dev, dev->export_count);
-                return -EINVAL;
-        }
-        if (optimal_sectors > dev->dev_attrib.hw_max_sectors) {
-                pr_err("dev[%p]: Passed optimal_sectors %u cannot be"
-                        " greater than hw_max_sectors: %u\n", dev,
-                        optimal_sectors, dev->dev_attrib.hw_max_sectors);
-                return -EINVAL;
-        }
-
-        dev->dev_attrib.optimal_sectors = optimal_sectors;
-        pr_debug("dev[%p]: SE Device optimal_sectors changed to %u\n",
-                        dev, optimal_sectors);
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_optimal_sectors);
-
-int se_dev_set_block_size(struct se_device *dev, u32 block_size)
-{
-        if (dev->export_count) {
-                pr_err("dev[%p]: Unable to change SE Device block_size"
-                        " while export_count is %d\n",
-                        dev, dev->export_count);
-                return -EINVAL;
-        }
-
-        if ((block_size != 512) &&
-            (block_size != 1024) &&
-            (block_size != 2048) &&
-            (block_size != 4096)) {
-                pr_err("dev[%p]: Illegal value for block_device: %u"
-                        " for SE device, must be 512, 1024, 2048 or 4096\n",
-                        dev, block_size);
-                return -EINVAL;
-        }
-
-        dev->dev_attrib.block_size = block_size;
-        pr_debug("dev[%p]: SE Device block_size changed to %u\n",
-                        dev, block_size);
-
-        if (dev->dev_attrib.max_bytes_per_io)
-                dev->dev_attrib.hw_max_sectors =
-                        dev->dev_attrib.max_bytes_per_io / block_size;
-
-        return 0;
-}
-EXPORT_SYMBOL(se_dev_set_block_size);
-
-struct se_lun *core_dev_add_lun(
+int core_dev_add_lun(
         struct se_portal_group *tpg,
         struct se_device *dev,
-        u32 unpacked_lun)
+        struct se_lun *lun)
 {
-        struct se_lun *lun;
         int rc;
 
-        lun = core_tpg_alloc_lun(tpg, unpacked_lun);
-        if (IS_ERR(lun))
-                return lun;
-
         rc = core_tpg_add_lun(tpg, lun,
                                 TRANSPORT_LUNFLAGS_READ_WRITE, dev);
         if (rc < 0)
-                return ERR_PTR(rc);
+                return rc;
 
-        pr_debug("%s_TPG[%u]_LUN[%u] - Activated %s Logical Unit from"
+        pr_debug("%s_TPG[%u]_LUN[%llu] - Activated %s Logical Unit from"
                 " CORE HBA: %u\n", tpg->se_tpg_tfo->get_fabric_name(),
                 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
                 tpg->se_tpg_tfo->get_fabric_name(), dev->se_hba->hba_id);
@@ -1210,20 +566,19 @@ struct se_lun *core_dev_add_lun(
          */
         if (tpg->se_tpg_tfo->tpg_check_demo_mode(tpg)) {
                 struct se_node_acl *acl;
-                spin_lock_irq(&tpg->acl_node_lock);
+
+                mutex_lock(&tpg->acl_node_mutex);
                 list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {
                         if (acl->dynamic_node_acl &&
                             (!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only ||
                              !tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg))) {
-                                spin_unlock_irq(&tpg->acl_node_lock);
-                                core_tpg_add_node_to_devs(acl, tpg);
-                                spin_lock_irq(&tpg->acl_node_lock);
+                                core_tpg_add_node_to_devs(acl, tpg, lun);
                         }
                 }
-                spin_unlock_irq(&tpg->acl_node_lock);
+                mutex_unlock(&tpg->acl_node_mutex);
         }
 
-        return lun;
+        return 0;
 }
 
 /*      core_dev_del_lun():
@@ -1234,7 +589,7 @@ void core_dev_del_lun(
         struct se_portal_group *tpg,
         struct se_lun *lun)
 {
-        pr_debug("%s_TPG[%u]_LUN[%u] - Deactivating %s Logical Unit from"
+        pr_debug("%s_TPG[%u]_LUN[%llu] - Deactivating %s Logical Unit from"
                 " device object\n", tpg->se_tpg_tfo->get_fabric_name(),
                 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
                 tpg->se_tpg_tfo->get_fabric_name());
@@ -1242,72 +597,10 @@ void core_dev_del_lun(
         core_tpg_remove_lun(tpg, lun);
 }
 
-struct se_lun *core_get_lun_from_tpg(struct se_portal_group *tpg, u32 unpacked_lun)
-{
-        struct se_lun *lun;
-
-        spin_lock(&tpg->tpg_lun_lock);
-        if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
-                pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS"
-                        "_PER_TPG-1: %u for Target Portal Group: %hu\n",
-                        tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
-                        TRANSPORT_MAX_LUNS_PER_TPG-1,
-                        tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                spin_unlock(&tpg->tpg_lun_lock);
-                return NULL;
-        }
-        lun = tpg->tpg_lun_list[unpacked_lun];
-
-        if (lun->lun_status != TRANSPORT_LUN_STATUS_FREE) {
-                pr_err("%s Logical Unit Number: %u is not free on"
-                        " Target Portal Group: %hu, ignoring request.\n",
-                        tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
-                        tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                spin_unlock(&tpg->tpg_lun_lock);
-                return NULL;
-        }
-        spin_unlock(&tpg->tpg_lun_lock);
-
-        return lun;
-}
-
-/*      core_dev_get_lun():
- *
- *
- */
-static struct se_lun *core_dev_get_lun(struct se_portal_group *tpg, u32 unpacked_lun)
-{
-        struct se_lun *lun;
-
-        spin_lock(&tpg->tpg_lun_lock);
-        if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
-                pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS_PER"
-                        "_TPG-1: %u for Target Portal Group: %hu\n",
-                        tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
-                        TRANSPORT_MAX_LUNS_PER_TPG-1,
-                        tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                spin_unlock(&tpg->tpg_lun_lock);
-                return NULL;
-        }
-        lun = tpg->tpg_lun_list[unpacked_lun];
-
-        if (lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) {
-                pr_err("%s Logical Unit Number: %u is not active on"
-                        " Target Portal Group: %hu, ignoring request.\n",
-                        tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
-                        tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                spin_unlock(&tpg->tpg_lun_lock);
-                return NULL;
-        }
-        spin_unlock(&tpg->tpg_lun_lock);
-
-        return lun;
-}
-
 struct se_lun_acl *core_dev_init_initiator_node_lun_acl(
         struct se_portal_group *tpg,
         struct se_node_acl *nacl,
-        u32 mapped_lun,
+        u64 mapped_lun,
         int *ret)
 {
         struct se_lun_acl *lacl;
@@ -1325,7 +618,6 @@ struct se_lun_acl *core_dev_init_initiator_node_lun_acl(
                 return NULL;
         }
 
-        INIT_LIST_HEAD(&lacl->lacl_list);
         lacl->mapped_lun = mapped_lun;
         lacl->se_lun_nacl = nacl;
         snprintf(lacl->initiatorname, TRANSPORT_IQN_LEN, "%s",
@@ -1337,22 +629,16 @@ struct se_lun_acl *core_dev_init_initiator_node_lun_acl(
 int core_dev_add_initiator_node_lun_acl(
         struct se_portal_group *tpg,
         struct se_lun_acl *lacl,
-        u32 unpacked_lun,
+        struct se_lun *lun,
         u32 lun_access)
 {
-        struct se_lun *lun;
-        struct se_node_acl *nacl;
-
-        lun = core_dev_get_lun(tpg, unpacked_lun);
-        if (!lun) {
-                pr_err("%s Logical Unit Number: %u is not active on"
-                        " Target Portal Group: %hu, ignoring request.\n",
-                        tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
-                        tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                return -EINVAL;
-        }
+        struct se_node_acl *nacl = lacl->se_lun_nacl;
+        /*
+         * rcu_dereference_raw protected by se_lun->lun_group symlink
+         * reference to se_device->dev_group.
+         */
+        struct se_device *dev = rcu_dereference_raw(lun->lun_se_dev);
 
-        nacl = lacl->se_lun_nacl;
         if (!nacl)
                 return -EINVAL;
 
@@ -1366,52 +652,40 @@ int core_dev_add_initiator_node_lun_acl(
                         lun_access, nacl, tpg) < 0)
                 return -EINVAL;
 
-        spin_lock(&lun->lun_acl_lock);
-        list_add_tail(&lacl->lacl_list, &lun->lun_acl_list);
-        atomic_inc_mb(&lun->lun_acl_count);
-        spin_unlock(&lun->lun_acl_lock);
-
-        pr_debug("%s_TPG[%hu]_LUN[%u->%u] - Added %s ACL for "
+        pr_debug("%s_TPG[%hu]_LUN[%llu->%llu] - Added %s ACL for "
                 " InitiatorNode: %s\n", tpg->se_tpg_tfo->get_fabric_name(),
-                tpg->se_tpg_tfo->tpg_get_tag(tpg), unpacked_lun, lacl->mapped_lun,
+                tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, lacl->mapped_lun,
                 (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) ? "RW" : "RO",
                 lacl->initiatorname);
         /*
          * Check to see if there are any existing persistent reservation APTPL
          * pre-registrations that need to be enabled for this LUN ACL..
          */
-        core_scsi3_check_aptpl_registration(lun->lun_se_dev, tpg, lun, nacl,
+        core_scsi3_check_aptpl_registration(dev, tpg, lun, nacl,
                                             lacl->mapped_lun);
         return 0;
 }
 
-/*      core_dev_del_initiator_node_lun_acl():
- *
- *
- */
 int core_dev_del_initiator_node_lun_acl(
-        struct se_portal_group *tpg,
         struct se_lun *lun,
         struct se_lun_acl *lacl)
 {
+        struct se_portal_group *tpg = lun->lun_tpg;
         struct se_node_acl *nacl;
+        struct se_dev_entry *deve;
 
         nacl = lacl->se_lun_nacl;
         if (!nacl)
                 return -EINVAL;
 
-        spin_lock(&lun->lun_acl_lock);
-        list_del(&lacl->lacl_list);
-        atomic_dec_mb(&lun->lun_acl_count);
-        spin_unlock(&lun->lun_acl_lock);
-
-        core_disable_device_list_for_node(lun, NULL, lacl->mapped_lun,
-                TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);
-
-        lacl->se_lun = NULL;
+        mutex_lock(&nacl->lun_entry_mutex);
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (deve)
+                core_disable_device_list_for_node(lun, deve, nacl, tpg);
+        mutex_unlock(&nacl->lun_entry_mutex);
 
-        pr_debug("%s_TPG[%hu]_LUN[%u] - Removed ACL for"
-                " InitiatorNode: %s Mapped LUN: %u\n",
+        pr_debug("%s_TPG[%hu]_LUN[%llu] - Removed ACL for"
+                " InitiatorNode: %s Mapped LUN: %llu\n",
                 tpg->se_tpg_tfo->get_fabric_name(),
                 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
                 lacl->initiatorname, lacl->mapped_lun);
@@ -1424,7 +698,7 @@ void core_dev_free_initiator_node_lun_acl(
         struct se_lun_acl *lacl)
 {
         pr_debug("%s_TPG[%hu] - Freeing ACL for %s InitiatorNode: %s"
-                " Mapped LUN: %u\n", tpg->se_tpg_tfo->get_fabric_name(),
+                " Mapped LUN: %llu\n", tpg->se_tpg_tfo->get_fabric_name(),
                 tpg->se_tpg_tfo->tpg_get_tag(tpg),
                 tpg->se_tpg_tfo->get_fabric_name(),
                 lacl->initiatorname, lacl->mapped_lun);
@@ -1473,14 +747,15 @@ struct se_device *target_alloc_device(struct se_hba *hba, const char *name)
         struct se_device *dev;
         struct se_lun *xcopy_lun;
 
-        dev = hba->transport->alloc_device(hba, name);
+        dev = hba->backend->ops->alloc_device(hba, name);
         if (!dev)
                 return NULL;
 
         dev->dev_link_magic = SE_DEV_LINK_MAGIC;
         dev->se_hba = hba;
-        dev->transport = hba->transport;
+        dev->transport = hba->backend->ops;
         dev->prot_length = sizeof(struct se_dif_v1_tuple);
+        dev->hba_index = hba->hba_index;
 
         INIT_LIST_HEAD(&dev->dev_list);
         INIT_LIST_HEAD(&dev->dev_sep_list);
@@ -1513,9 +788,9 @@ struct se_device *target_alloc_device(struct se_hba *hba, const char *name)
 
         dev->dev_attrib.da_dev = dev;
         dev->dev_attrib.emulate_model_alias = DA_EMULATE_MODEL_ALIAS;
-        dev->dev_attrib.emulate_dpo = DA_EMULATE_DPO;
-        dev->dev_attrib.emulate_fua_write = DA_EMULATE_FUA_WRITE;
-        dev->dev_attrib.emulate_fua_read = DA_EMULATE_FUA_READ;
+        dev->dev_attrib.emulate_dpo = 1;
+        dev->dev_attrib.emulate_fua_write = 1;
+        dev->dev_attrib.emulate_fua_read = 1;
         dev->dev_attrib.emulate_write_cache = DA_EMULATE_WRITE_CACHE;
         dev->dev_attrib.emulate_ua_intlck_ctrl = DA_EMULATE_UA_INTLLCK_CTRL;
         dev->dev_attrib.emulate_tas = DA_EMULATE_TAS;
@@ -1537,12 +812,12 @@ struct se_device *target_alloc_device(struct se_hba *hba, const char *name)
         dev->dev_attrib.max_write_same_len = DA_MAX_WRITE_SAME_LEN;
 
         xcopy_lun = &dev->xcopy_lun;
-        xcopy_lun->lun_se_dev = dev;
-        init_completion(&xcopy_lun->lun_shutdown_comp);
-        INIT_LIST_HEAD(&xcopy_lun->lun_acl_list);
-        spin_lock_init(&xcopy_lun->lun_acl_lock);
-        spin_lock_init(&xcopy_lun->lun_sep_lock);
+        rcu_assign_pointer(xcopy_lun->lun_se_dev, dev);
         init_completion(&xcopy_lun->lun_ref_comp);
+        INIT_LIST_HEAD(&xcopy_lun->lun_deve_list);
+        INIT_LIST_HEAD(&xcopy_lun->lun_dev_link);
+        mutex_init(&xcopy_lun->lun_tg_pt_md_mutex);
+        xcopy_lun->lun_tpg = &xcopy_pt_tpg;
 
         return dev;
 }
@@ -1679,7 +954,7 @@ int core_dev_setup_virtual_lun0(void)
                 goto out_free_hba;
         }
 
-        hba->transport->set_configfs_dev_params(dev, buf, sizeof(buf));
+        hba->backend->ops->set_configfs_dev_params(dev, buf, sizeof(buf));
 
         ret = target_configure_device(dev);
         if (ret)
diff --git a/drivers/target/target_core_fabric_configfs.c b/drivers/target/target_core_fabric_configfs.c
index 1f7886bb16bf..48a36989c1a6 100644
--- a/drivers/target/target_core_fabric_configfs.c
+++ b/drivers/target/target_core_fabric_configfs.c
@@ -36,7 +36,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 #include <target/target_core_fabric_configfs.h>
-#include <target/target_core_configfs.h>
 #include <target/configfs_macros.h>
 
 #include "target_core_internal.h"
@@ -46,27 +45,25 @@
 #define TF_CIT_SETUP(_name, _item_ops, _group_ops, _attrs)              \
 static void target_fabric_setup_##_name##_cit(struct target_fabric_configfs *tf) \
 {                                                                       \
-        struct target_fabric_configfs_template *tfc = &tf->tf_cit_tmpl; \
-        struct config_item_type *cit = &tfc->tfc_##_name##_cit;         \
+        struct config_item_type *cit = &tf->tf_##_name##_cit;           \
                                                                         \
         cit->ct_item_ops = _item_ops;                                   \
         cit->ct_group_ops = _group_ops;                                 \
         cit->ct_attrs = _attrs;                                         \
-        cit->ct_owner = tf->tf_module;                                  \
+        cit->ct_owner = tf->tf_ops->module;                             \
         pr_debug("Setup generic %s\n", __stringify(_name));             \
 }
 
 #define TF_CIT_SETUP_DRV(_name, _item_ops, _group_ops)          \
 static void target_fabric_setup_##_name##_cit(struct target_fabric_configfs *tf) \
 {                                                                       \
-        struct target_fabric_configfs_template *tfc = &tf->tf_cit_tmpl; \
-        struct config_item_type *cit = &tfc->tfc_##_name##_cit;         \
-        struct configfs_attribute **attrs = tf->tf_ops.tfc_##_name##_attrs; \
+        struct config_item_type *cit = &tf->tf_##_name##_cit;           \
+        struct configfs_attribute **attrs = tf->tf_ops->tfc_##_name##_attrs; \
                                                                         \
         cit->ct_item_ops = _item_ops;                                   \
         cit->ct_group_ops = _group_ops;                                 \
         cit->ct_attrs = attrs;                                          \
-        cit->ct_owner = tf->tf_module;                                  \
+        cit->ct_owner = tf->tf_ops->module;                             \
         pr_debug("Setup generic %s\n", __stringify(_name));             \
 }
 
@@ -83,7 +80,7 @@ static int target_fabric_mappedlun_link(
                         struct se_lun_acl, se_lun_group);
         struct se_portal_group *se_tpg;
         struct config_item *nacl_ci, *tpg_ci, *tpg_ci_s, *wwn_ci, *wwn_ci_s;
-        int ret = 0, lun_access;
+        int lun_access;
 
         if (lun->lun_link_magic != SE_LUN_LINK_MAGIC) {
                 pr_err("Bad lun->lun_link_magic, not a valid lun_ci pointer:"
@@ -93,12 +90,11 @@ static int target_fabric_mappedlun_link(
         /*
          * Ensure that the source port exists
          */
-        if (!lun->lun_sep || !lun->lun_sep->sep_tpg) {
-                pr_err("Source se_lun->lun_sep or lun->lun_sep->sep"
-                                "_tpg does not exist\n");
+        if (!lun->lun_se_dev) {
+                pr_err("Source se_lun->lun_se_dev does not exist\n");
                 return -EINVAL;
         }
-        se_tpg = lun->lun_sep->sep_tpg;
+        se_tpg = lun->lun_tpg;
 
         nacl_ci = &lun_acl_ci->ci_parent->ci_group->cg_item;
         tpg_ci = &nacl_ci->ci_group->cg_item;
@@ -125,49 +121,35 @@ static int target_fabric_mappedlun_link(
          * which be will write protected (READ-ONLY) when
          * tpg_1/attrib/demo_mode_write_protect=1
          */
-        spin_lock_irq(&lacl->se_lun_nacl->device_list_lock);
-        deve = lacl->se_lun_nacl->device_list[lacl->mapped_lun];
-        if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS)
+        rcu_read_lock();
+        deve = target_nacl_find_deve(lacl->se_lun_nacl, lacl->mapped_lun);
+        if (deve)
                 lun_access = deve->lun_flags;
         else
                 lun_access =
                         (se_tpg->se_tpg_tfo->tpg_check_prod_mode_write_protect(
                                 se_tpg)) ? TRANSPORT_LUNFLAGS_READ_ONLY :
                                            TRANSPORT_LUNFLAGS_READ_WRITE;
-        spin_unlock_irq(&lacl->se_lun_nacl->device_list_lock);
+        rcu_read_unlock();
         /*
          * Determine the actual mapped LUN value user wants..
          *
          * This value is what the SCSI Initiator actually sees the
-         * iscsi/$IQN/$TPGT/lun/lun_* as on their SCSI Initiator Ports.
+         * $FABRIC/$WWPN/$TPGT/lun/lun_* as on their SCSI Initiator Ports.
          */
-        ret = core_dev_add_initiator_node_lun_acl(se_tpg, lacl,
-                        lun->unpacked_lun, lun_access);
-
-        return (ret < 0) ? -EINVAL : 0;
+        return core_dev_add_initiator_node_lun_acl(se_tpg, lacl, lun, lun_access);
 }
 
 static int target_fabric_mappedlun_unlink(
         struct config_item *lun_acl_ci,
         struct config_item *lun_ci)
 {
-        struct se_lun *lun;
         struct se_lun_acl *lacl = container_of(to_config_group(lun_acl_ci),
                         struct se_lun_acl, se_lun_group);
-        struct se_node_acl *nacl = lacl->se_lun_nacl;
-        struct se_dev_entry *deve = nacl->device_list[lacl->mapped_lun];
-        struct se_portal_group *se_tpg;
-        /*
-         * Determine if the underlying MappedLUN has already been released..
-         */
-        if (!deve->se_lun)
-                return 0;
-
-        lun = container_of(to_config_group(lun_ci), struct se_lun, lun_group);
-        se_tpg = lun->lun_sep->sep_tpg;
+        struct se_lun *lun = container_of(to_config_group(lun_ci),
+                        struct se_lun, lun_group);
 
-        core_dev_del_initiator_node_lun_acl(se_tpg, lun, lacl);
-        return 0;
+        return core_dev_del_initiator_node_lun_acl(lun, lacl);
 }
 
 CONFIGFS_EATTR_STRUCT(target_fabric_mappedlun, se_lun_acl);
@@ -183,14 +165,15 @@ static ssize_t target_fabric_mappedlun_show_write_protect(
 {
         struct se_node_acl *se_nacl = lacl->se_lun_nacl;
         struct se_dev_entry *deve;
-        ssize_t len;
+        ssize_t len = 0;
 
-        spin_lock_irq(&se_nacl->device_list_lock);
-        deve = se_nacl->device_list[lacl->mapped_lun];
-        len = sprintf(page, "%d\n",
-                        (deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY) ?
-                        1 : 0);
-        spin_unlock_irq(&se_nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(se_nacl, lacl->mapped_lun);
+        if (deve) {
+                len = sprintf(page, "%d\n",
+                        (deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY) ? 1 : 0);
+        }
+        rcu_read_unlock();
 
         return len;
 }
@@ -218,7 +201,7 @@ static ssize_t target_fabric_mappedlun_store_write_protect(
                         lacl->se_lun_nacl);
 
         pr_debug("%s_ConfigFS: Changed Initiator ACL: %s"
-                " Mapped LUN: %u Write Protect bit to %s\n",
+                " Mapped LUN: %llu Write Protect bit to %s\n",
                 se_tpg->se_tpg_tfo->get_fabric_name(),
                 lacl->initiatorname, lacl->mapped_lun, (op) ? "ON" : "OFF");
 
@@ -338,7 +321,7 @@ static struct config_group *target_fabric_make_mappedlun(
         struct config_item *acl_ci;
         struct config_group *lacl_cg = NULL, *ml_stat_grp = NULL;
         char *buf;
-        unsigned long mapped_lun;
+        unsigned long long mapped_lun;
         int ret = 0;
 
         acl_ci = &group->cg_item;
@@ -366,21 +349,9 @@ static struct config_group *target_fabric_make_mappedlun(
          * Determine the Mapped LUN value.  This is what the SCSI Initiator
          * Port will actually see.
          */
-        ret = kstrtoul(buf + 4, 0, &mapped_lun);
+        ret = kstrtoull(buf + 4, 0, &mapped_lun);
         if (ret)
                 goto out;
-        if (mapped_lun > UINT_MAX) {
-                ret = -EINVAL;
-                goto out;
-        }
-        if (mapped_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
-                pr_err("Mapped LUN: %lu exceeds TRANSPORT_MAX_LUNS_PER_TPG"
-                        "-1: %u for Target Portal Group: %u\n", mapped_lun,
-                        TRANSPORT_MAX_LUNS_PER_TPG-1,
-                        se_tpg->se_tpg_tfo->tpg_get_tag(se_tpg));
-                ret = -EINVAL;
-                goto out;
-        }
 
         lacl = core_dev_init_initiator_node_lun_acl(se_tpg, se_nacl,
                         mapped_lun, &ret);
@@ -399,9 +370,9 @@ static struct config_group *target_fabric_make_mappedlun(
         }
 
         config_group_init_type_name(&lacl->se_lun_group, name,
-                        &tf->tf_cit_tmpl.tfc_tpg_mappedlun_cit);
+                        &tf->tf_tpg_mappedlun_cit);
         config_group_init_type_name(&lacl->ml_stat_grps.stat_group,
-                        "statistics", &tf->tf_cit_tmpl.tfc_tpg_mappedlun_stat_cit);
+                        "statistics", &tf->tf_tpg_mappedlun_stat_cit);
         lacl_cg->default_groups[0] = &lacl->ml_stat_grps.stat_group;
         lacl_cg->default_groups[1] = NULL;
 
@@ -458,10 +429,11 @@ static void target_fabric_nacl_base_release(struct config_item *item)
 {
         struct se_node_acl *se_nacl = container_of(to_config_group(item),
                         struct se_node_acl, acl_group);
-        struct se_portal_group *se_tpg = se_nacl->se_tpg;
-        struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
+        struct target_fabric_configfs *tf = se_nacl->se_tpg->se_tpg_wwn->wwn_tf;
 
-        tf->tf_ops.fabric_drop_nodeacl(se_nacl);
+        if (tf->tf_ops->fabric_cleanup_nodeacl)
+                tf->tf_ops->fabric_cleanup_nodeacl(se_nacl);
+        core_tpg_del_initiator_node_acl(se_nacl);
 }
 
 static struct configfs_item_operations target_fabric_nacl_base_item_ops = {
@@ -501,15 +473,18 @@ static struct config_group *target_fabric_make_nodeacl(
         struct se_node_acl *se_nacl;
         struct config_group *nacl_cg;
 
-        if (!tf->tf_ops.fabric_make_nodeacl) {
-                pr_err("tf->tf_ops.fabric_make_nodeacl is NULL\n");
-                return ERR_PTR(-ENOSYS);
-        }
-
-        se_nacl = tf->tf_ops.fabric_make_nodeacl(se_tpg, group, name);
+        se_nacl = core_tpg_add_initiator_node_acl(se_tpg, name);
         if (IS_ERR(se_nacl))
                 return ERR_CAST(se_nacl);
 
+        if (tf->tf_ops->fabric_init_nodeacl) {
+                int ret = tf->tf_ops->fabric_init_nodeacl(se_nacl, name);
+                if (ret) {
+                        core_tpg_del_initiator_node_acl(se_nacl);
+                        return ERR_PTR(ret);
+                }
+        }
+
         nacl_cg = &se_nacl->acl_group;
         nacl_cg->default_groups = se_nacl->acl_default_groups;
         nacl_cg->default_groups[0] = &se_nacl->acl_attrib_group;
@@ -519,16 +494,15 @@ static struct config_group *target_fabric_make_nodeacl(
         nacl_cg->default_groups[4] = NULL;
 
         config_group_init_type_name(&se_nacl->acl_group, name,
-                        &tf->tf_cit_tmpl.tfc_tpg_nacl_base_cit);
+                        &tf->tf_tpg_nacl_base_cit);
         config_group_init_type_name(&se_nacl->acl_attrib_group, "attrib",
-                        &tf->tf_cit_tmpl.tfc_tpg_nacl_attrib_cit);
+                        &tf->tf_tpg_nacl_attrib_cit);
         config_group_init_type_name(&se_nacl->acl_auth_group, "auth",
-                        &tf->tf_cit_tmpl.tfc_tpg_nacl_auth_cit);
+                        &tf->tf_tpg_nacl_auth_cit);
         config_group_init_type_name(&se_nacl->acl_param_group, "param",
-                        &tf->tf_cit_tmpl.tfc_tpg_nacl_param_cit);
+                        &tf->tf_tpg_nacl_param_cit);
         config_group_init_type_name(&se_nacl->acl_fabric_stat_group,
-                        "fabric_statistics",
-                        &tf->tf_cit_tmpl.tfc_tpg_nacl_stat_cit);
+                        "fabric_statistics", &tf->tf_tpg_nacl_stat_cit);
 
         return &se_nacl->acl_group;
 }
@@ -575,7 +549,7 @@ static void target_fabric_np_base_release(struct config_item *item)
         struct se_portal_group *se_tpg = se_tpg_np->tpg_np_parent;
         struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
 
-        tf->tf_ops.fabric_drop_np(se_tpg_np);
+        tf->tf_ops->fabric_drop_np(se_tpg_np);
 }
 
 static struct configfs_item_operations target_fabric_np_base_item_ops = {
@@ -599,18 +573,18 @@ static struct config_group *target_fabric_make_np(
         struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
         struct se_tpg_np *se_tpg_np;
 
-        if (!tf->tf_ops.fabric_make_np) {
+        if (!tf->tf_ops->fabric_make_np) {
                 pr_err("tf->tf_ops.fabric_make_np is NULL\n");
                 return ERR_PTR(-ENOSYS);
         }
 
-        se_tpg_np = tf->tf_ops.fabric_make_np(se_tpg, group, name);
+        se_tpg_np = tf->tf_ops->fabric_make_np(se_tpg, group, name);
         if (!se_tpg_np || IS_ERR(se_tpg_np))
                 return ERR_PTR(-EINVAL);
 
         se_tpg_np->tpg_np_parent = se_tpg;
         config_group_init_type_name(&se_tpg_np->tpg_np_group, name,
-                        &tf->tf_cit_tmpl.tfc_tpg_np_base_cit);
+                        &tf->tf_tpg_np_base_cit);
 
         return &se_tpg_np->tpg_np_group;
 }
@@ -654,10 +628,10 @@ static ssize_t target_fabric_port_show_attr_alua_tg_pt_gp(
         struct se_lun *lun,
         char *page)
 {
-        if (!lun || !lun->lun_sep)
+        if (!lun || !lun->lun_se_dev)
                 return -ENODEV;
 
-        return core_alua_show_tg_pt_gp_info(lun->lun_sep, page);
+        return core_alua_show_tg_pt_gp_info(lun, page);
 }
 
 static ssize_t target_fabric_port_store_attr_alua_tg_pt_gp(
@@ -665,10 +639,10 @@ static ssize_t target_fabric_port_store_attr_alua_tg_pt_gp(
         const char *page,
         size_t count)
 {
-        if (!lun || !lun->lun_sep)
+        if (!lun || !lun->lun_se_dev)
                 return -ENODEV;
 
-        return core_alua_store_tg_pt_gp_info(lun->lun_sep, page, count);
+        return core_alua_store_tg_pt_gp_info(lun, page, count);
 }
 
 TCM_PORT_ATTR(alua_tg_pt_gp, S_IRUGO | S_IWUSR);
@@ -680,7 +654,7 @@ static ssize_t target_fabric_port_show_attr_alua_tg_pt_offline(
         struct se_lun *lun,
         char *page)
 {
-        if (!lun || !lun->lun_sep)
+        if (!lun || !lun->lun_se_dev)
                 return -ENODEV;
 
         return core_alua_show_offline_bit(lun, page);
@@ -691,7 +665,7 @@ static ssize_t target_fabric_port_store_attr_alua_tg_pt_offline(
         const char *page,
         size_t count)
 {
-        if (!lun || !lun->lun_sep)
+        if (!lun || !lun->lun_se_dev)
                 return -ENODEV;
 
         return core_alua_store_offline_bit(lun, page, count);
@@ -706,7 +680,7 @@ static ssize_t target_fabric_port_show_attr_alua_tg_pt_status(
         struct se_lun *lun,
         char *page)
 {
-        if (!lun || !lun->lun_sep)
+        if (!lun || !lun->lun_se_dev)
                 return -ENODEV;
 
         return core_alua_show_secondary_status(lun, page);
@@ -717,7 +691,7 @@ static ssize_t target_fabric_port_store_attr_alua_tg_pt_status(
         const char *page,
         size_t count)
 {
-        if (!lun || !lun->lun_sep)
+        if (!lun || !lun->lun_se_dev)
                 return -ENODEV;
 
         return core_alua_store_secondary_status(lun, page, count);
@@ -732,7 +706,7 @@ static ssize_t target_fabric_port_show_attr_alua_tg_pt_write_md(
         struct se_lun *lun,
         char *page)
 {
-        if (!lun || !lun->lun_sep)
+        if (!lun || !lun->lun_se_dev)
                 return -ENODEV;
 
         return core_alua_show_secondary_write_metadata(lun, page);
@@ -743,7 +717,7 @@ static ssize_t target_fabric_port_store_attr_alua_tg_pt_write_md(
         const char *page,
         size_t count)
 {
-        if (!lun || !lun->lun_sep)
+        if (!lun || !lun->lun_se_dev)
                 return -ENODEV;
 
         return core_alua_store_secondary_write_metadata(lun, page, count);
@@ -769,7 +743,6 @@ static int target_fabric_port_link(
         struct config_item *tpg_ci;
         struct se_lun *lun = container_of(to_config_group(lun_ci),
                                 struct se_lun, lun_group);
-        struct se_lun *lun_p;
         struct se_portal_group *se_tpg;
         struct se_device *dev =
                 container_of(to_config_group(se_dev_ci), struct se_device, dev_group);
@@ -797,20 +770,19 @@ static int target_fabric_port_link(
                 return -EEXIST;
         }
 
-        lun_p = core_dev_add_lun(se_tpg, dev, lun->unpacked_lun);
-        if (IS_ERR(lun_p)) {
-                pr_err("core_dev_add_lun() failed\n");
-                ret = PTR_ERR(lun_p);
+        ret = core_dev_add_lun(se_tpg, dev, lun);
+        if (ret) {
+                pr_err("core_dev_add_lun() failed: %d\n", ret);
                 goto out;
         }
 
-        if (tf->tf_ops.fabric_post_link) {
+        if (tf->tf_ops->fabric_post_link) {
                 /*
                  * Call the optional fabric_post_link() to allow a
                  * fabric module to setup any additional state once
                  * core_dev_add_lun() has been called..
                  */
-                tf->tf_ops.fabric_post_link(se_tpg, lun);
+                tf->tf_ops->fabric_post_link(se_tpg, lun);
         }
 
         return 0;
@@ -824,25 +796,34 @@ static int target_fabric_port_unlink(
 {
         struct se_lun *lun = container_of(to_config_group(lun_ci),
                                 struct se_lun, lun_group);
-        struct se_portal_group *se_tpg = lun->lun_sep->sep_tpg;
+        struct se_portal_group *se_tpg = lun->lun_tpg;
         struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
 
-        if (tf->tf_ops.fabric_pre_unlink) {
+        if (tf->tf_ops->fabric_pre_unlink) {
                 /*
                  * Call the optional fabric_pre_unlink() to allow a
                  * fabric module to release any additional stat before
                  * core_dev_del_lun() is called.
                 */
-                tf->tf_ops.fabric_pre_unlink(se_tpg, lun);
+                tf->tf_ops->fabric_pre_unlink(se_tpg, lun);
         }
 
         core_dev_del_lun(se_tpg, lun);
         return 0;
 }
 
+static void target_fabric_port_release(struct config_item *item)
+{
+        struct se_lun *lun = container_of(to_config_group(item),
+                                          struct se_lun, lun_group);
+
+        kfree_rcu(lun, rcu_head);
+}
+
 static struct configfs_item_operations target_fabric_port_item_ops = {
         .show_attribute         = target_fabric_port_attr_show,
         .store_attribute        = target_fabric_port_attr_store,
+        .release                = target_fabric_port_release,
         .allow_link             = target_fabric_port_link,
         .drop_link              = target_fabric_port_unlink,
 };
@@ -887,7 +868,7 @@ static struct config_group *target_fabric_make_lun(
                         struct se_portal_group, tpg_lun_group);
         struct target_fabric_configfs *tf = se_tpg->se_tpg_wwn->wwn_tf;
         struct config_group *lun_cg = NULL, *port_stat_grp = NULL;
-        unsigned long unpacked_lun;
+        unsigned long long unpacked_lun;
         int errno;
 
         if (strstr(name, "lun_") != name) {
@@ -895,28 +876,27 @@ static struct config_group *target_fabric_make_lun(
                                 " \"lun_$LUN_NUMBER\"\n");
                 return ERR_PTR(-EINVAL);
         }
-        errno = kstrtoul(name + 4, 0, &unpacked_lun);
+        errno = kstrtoull(name + 4, 0, &unpacked_lun);
         if (errno)
                 return ERR_PTR(errno);
-        if (unpacked_lun > UINT_MAX)
-                return ERR_PTR(-EINVAL);
 
-        lun = core_get_lun_from_tpg(se_tpg, unpacked_lun);
-        if (!lun)
-                return ERR_PTR(-EINVAL);
+        lun = core_tpg_alloc_lun(se_tpg, unpacked_lun);
+        if (IS_ERR(lun))
+                return ERR_CAST(lun);
 
         lun_cg = &lun->lun_group;
         lun_cg->default_groups = kmalloc(sizeof(struct config_group *) * 2,
                                 GFP_KERNEL);
         if (!lun_cg->default_groups) {
                 pr_err("Unable to allocate lun_cg->default_groups\n");
+                kfree(lun);
                 return ERR_PTR(-ENOMEM);
         }
 
         config_group_init_type_name(&lun->lun_group, name,
-                        &tf->tf_cit_tmpl.tfc_tpg_port_cit);
+                        &tf->tf_tpg_port_cit);
         config_group_init_type_name(&lun->port_stat_grps.stat_group,
-                        "statistics", &tf->tf_cit_tmpl.tfc_tpg_port_stat_cit);
+                        "statistics", &tf->tf_tpg_port_stat_cit);
         lun_cg->default_groups[0] = &lun->port_stat_grps.stat_group;
         lun_cg->default_groups[1] = NULL;
 
@@ -926,6 +906,7 @@ static struct config_group *target_fabric_make_lun(
         if (!port_stat_grp->default_groups) {
                 pr_err("Unable to allocate port_stat_grp->default_groups\n");
                 kfree(lun_cg->default_groups);
+                kfree(lun);
                 return ERR_PTR(-ENOMEM);
         }
         target_stat_setup_port_default_groups(lun);
@@ -1023,7 +1004,7 @@ static void target_fabric_tpg_release(struct config_item *item)
         struct se_wwn *wwn = se_tpg->se_tpg_wwn;
         struct target_fabric_configfs *tf = wwn->wwn_tf;
 
-        tf->tf_ops.fabric_drop_tpg(se_tpg);
+        tf->tf_ops->fabric_drop_tpg(se_tpg);
 }
 
 static struct configfs_item_operations target_fabric_tpg_base_item_ops = {
@@ -1046,12 +1027,12 @@ static struct config_group *target_fabric_make_tpg(
         struct target_fabric_configfs *tf = wwn->wwn_tf;
         struct se_portal_group *se_tpg;
 
-        if (!tf->tf_ops.fabric_make_tpg) {
-                pr_err("tf->tf_ops.fabric_make_tpg is NULL\n");
+        if (!tf->tf_ops->fabric_make_tpg) {
+                pr_err("tf->tf_ops->fabric_make_tpg is NULL\n");
                 return ERR_PTR(-ENOSYS);
         }
 
-        se_tpg = tf->tf_ops.fabric_make_tpg(wwn, group, name);
+        se_tpg = tf->tf_ops->fabric_make_tpg(wwn, group, name);
         if (!se_tpg || IS_ERR(se_tpg))
                 return ERR_PTR(-EINVAL);
         /*
@@ -1067,19 +1048,19 @@ static struct config_group *target_fabric_make_tpg(
         se_tpg->tpg_group.default_groups[6] = NULL;
 
         config_group_init_type_name(&se_tpg->tpg_group, name,
-                        &tf->tf_cit_tmpl.tfc_tpg_base_cit);
+                        &tf->tf_tpg_base_cit);
         config_group_init_type_name(&se_tpg->tpg_lun_group, "lun",
-                        &tf->tf_cit_tmpl.tfc_tpg_lun_cit);
+                        &tf->tf_tpg_lun_cit);
         config_group_init_type_name(&se_tpg->tpg_np_group, "np",
-                        &tf->tf_cit_tmpl.tfc_tpg_np_cit);
+                        &tf->tf_tpg_np_cit);
         config_group_init_type_name(&se_tpg->tpg_acl_group, "acls",
-                        &tf->tf_cit_tmpl.tfc_tpg_nacl_cit);
+                        &tf->tf_tpg_nacl_cit);
         config_group_init_type_name(&se_tpg->tpg_attrib_group, "attrib",
-                        &tf->tf_cit_tmpl.tfc_tpg_attrib_cit);
+                        &tf->tf_tpg_attrib_cit);
         config_group_init_type_name(&se_tpg->tpg_auth_group, "auth",
-                        &tf->tf_cit_tmpl.tfc_tpg_auth_cit);
+                        &tf->tf_tpg_auth_cit);
         config_group_init_type_name(&se_tpg->tpg_param_group, "param",
-                        &tf->tf_cit_tmpl.tfc_tpg_param_cit);
+                        &tf->tf_tpg_param_cit);
 
         return &se_tpg->tpg_group;
 }
@@ -1112,7 +1093,7 @@ static void target_fabric_release_wwn(struct config_item *item)
                                 struct se_wwn, wwn_group);
         struct target_fabric_configfs *tf = wwn->wwn_tf;
 
-        tf->tf_ops.fabric_drop_wwn(wwn);
+        tf->tf_ops->fabric_drop_wwn(wwn);
 }
 
 static struct configfs_item_operations target_fabric_tpg_item_ops = {
@@ -1148,12 +1129,12 @@ static struct config_group *target_fabric_make_wwn(
                                 struct target_fabric_configfs, tf_group);
         struct se_wwn *wwn;
 
-        if (!tf->tf_ops.fabric_make_wwn) {
+        if (!tf->tf_ops->fabric_make_wwn) {
                 pr_err("tf->tf_ops.fabric_make_wwn is NULL\n");
                 return ERR_PTR(-ENOSYS);
         }
 
-        wwn = tf->tf_ops.fabric_make_wwn(tf, group, name);
+        wwn = tf->tf_ops->fabric_make_wwn(tf, group, name);
         if (!wwn || IS_ERR(wwn))
                 return ERR_PTR(-EINVAL);
 
@@ -1165,10 +1146,9 @@ static struct config_group *target_fabric_make_wwn(
         wwn->wwn_group.default_groups[0] = &wwn->fabric_stat_group;
         wwn->wwn_group.default_groups[1] = NULL;
 
-        config_group_init_type_name(&wwn->wwn_group, name,
-                        &tf->tf_cit_tmpl.tfc_tpg_cit);
+        config_group_init_type_name(&wwn->wwn_group, name, &tf->tf_tpg_cit);
         config_group_init_type_name(&wwn->fabric_stat_group, "fabric_statistics",
-                        &tf->tf_cit_tmpl.tfc_wwn_fabric_stats_cit);
+                        &tf->tf_wwn_fabric_stats_cit);
 
         return &wwn->wwn_group;
 }
diff --git a/drivers/target/target_core_fabric_lib.c b/drivers/target/target_core_fabric_lib.c
index 41f4f270f919..cb6497ce4b61 100644
--- a/drivers/target/target_core_fabric_lib.c
+++ b/drivers/target/target_core_fabric_lib.c
@@ -24,6 +24,11 @@
  *
  ******************************************************************************/
 
+/*
+ * See SPC4, section 7.5 "Protocol specific parameters" for details
+ * on the formats implemented in this file.
+ */
+
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/ctype.h>
@@ -34,124 +39,30 @@
 
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 
 #include "target_core_internal.h"
 #include "target_core_pr.h"
 
-/*
- * Handlers for Serial Attached SCSI (SAS)
- */
-u8 sas_get_fabric_proto_ident(struct se_portal_group *se_tpg)
-{
-        /*
-         * Return a SAS Serial SCSI Protocol identifier for loopback operations
-         * This is defined in  section 7.5.1 Table 362 in spc4r17
-         */
-        return 0x6;
-}
-EXPORT_SYMBOL(sas_get_fabric_proto_ident);
 
-u32 sas_get_pr_transport_id(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl,
-        struct t10_pr_registration *pr_reg,
+static int sas_get_pr_transport_id(
+        struct se_node_acl *nacl,
         int *format_code,
         unsigned char *buf)
 {
-        unsigned char *ptr;
         int ret;
 
-        /*
-         * Set PROTOCOL IDENTIFIER to 6h for SAS
-         */
-        buf[0] = 0x06;
-        /*
-         * From spc4r17, 7.5.4.7 TransportID for initiator ports using SCSI
-         * over SAS Serial SCSI Protocol
-         */
-        ptr = &se_nacl->initiatorname[4]; /* Skip over 'naa. prefix */
-
-        ret = hex2bin(&buf[4], ptr, 8);
-        if (ret < 0)
-                pr_debug("sas transport_id: invalid hex string\n");
-
-        /*
-         * The SAS Transport ID is a hardcoded 24-byte length
-         */
-        return 24;
-}
-EXPORT_SYMBOL(sas_get_pr_transport_id);
-
-u32 sas_get_pr_transport_id_len(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl,
-        struct t10_pr_registration *pr_reg,
-        int *format_code)
-{
-        *format_code = 0;
-        /*
-         * From spc4r17, 7.5.4.7 TransportID for initiator ports using SCSI
-         * over SAS Serial SCSI Protocol
-         *
-         * The SAS Transport ID is a hardcoded 24-byte length
-         */
-        return 24;
-}
-EXPORT_SYMBOL(sas_get_pr_transport_id_len);
-
-/*
- * Used for handling SCSI fabric dependent TransportIDs in SPC-3 and above
- * Persistent Reservation SPEC_I_PT=1 and PROUT REGISTER_AND_MOVE operations.
- */
-char *sas_parse_pr_out_transport_id(
-        struct se_portal_group *se_tpg,
-        const char *buf,
-        u32 *out_tid_len,
-        char **port_nexus_ptr)
-{
-        /*
-         * Assume the FORMAT CODE 00b from spc4r17, 7.5.4.7 TransportID
-         * for initiator ports using SCSI over SAS Serial SCSI Protocol
-         *
-         * The TransportID for a SAS Initiator Port is of fixed size of
-         * 24 bytes, and SAS does not contain a I_T nexus identifier,
-         * so we return the **port_nexus_ptr set to NULL.
-         */
-        *port_nexus_ptr = NULL;
-        *out_tid_len = 24;
-
-        return (char *)&buf[4];
-}
-EXPORT_SYMBOL(sas_parse_pr_out_transport_id);
-
-/*
- * Handlers for Fibre Channel Protocol (FCP)
- */
-u8 fc_get_fabric_proto_ident(struct se_portal_group *se_tpg)
-{
-        return 0x0;     /* 0 = fcp-2 per SPC4 section 7.5.1 */
-}
-EXPORT_SYMBOL(fc_get_fabric_proto_ident);
+        /* Skip over 'naa. prefix */
+        ret = hex2bin(&buf[4], &nacl->initiatorname[4], 8);
+        if (ret) {
+                pr_debug("%s: invalid hex string\n", __func__);
+                return ret;
+        }
 
-u32 fc_get_pr_transport_id_len(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl,
-        struct t10_pr_registration *pr_reg,
-        int *format_code)
-{
-        *format_code = 0;
-        /*
-         * The FC Transport ID is a hardcoded 24-byte length
-         */
         return 24;
 }
-EXPORT_SYMBOL(fc_get_pr_transport_id_len);
 
-u32 fc_get_pr_transport_id(
-        struct se_portal_group *se_tpg,
+static int fc_get_pr_transport_id(
         struct se_node_acl *se_nacl,
-        struct t10_pr_registration *pr_reg,
         int *format_code,
         unsigned char *buf)
 {
@@ -160,24 +71,20 @@ u32 fc_get_pr_transport_id(
         u32 off = 8;
 
         /*
-         * PROTOCOL IDENTIFIER is 0h for FCP-2
-         *
-         * From spc4r17, 7.5.4.2 TransportID for initiator ports using
-         * SCSI over Fibre Channel
-         *
          * We convert the ASCII formatted N Port name into a binary
          * encoded TransportID.
          */
         ptr = &se_nacl->initiatorname[0];
-
         for (i = 0; i < 24; ) {
                 if (!strncmp(&ptr[i], ":", 1)) {
                         i++;
                         continue;
                 }
                 ret = hex2bin(&buf[off++], &ptr[i], 1);
-                if (ret < 0)
-                        pr_debug("fc transport_id: invalid hex string\n");
+                if (ret < 0) {
+                        pr_debug("%s: invalid hex string\n", __func__);
+                        return ret;
+                }
                 i += 2;
         }
         /*
@@ -185,42 +92,52 @@ u32 fc_get_pr_transport_id(
          */
         return 24;
 }
-EXPORT_SYMBOL(fc_get_pr_transport_id);
 
-char *fc_parse_pr_out_transport_id(
-        struct se_portal_group *se_tpg,
-        const char *buf,
-        u32 *out_tid_len,
-        char **port_nexus_ptr)
+static int sbp_get_pr_transport_id(
+        struct se_node_acl *nacl,
+        int *format_code,
+        unsigned char *buf)
 {
-        /*
-         * The TransportID for a FC N Port is of fixed size of
-         * 24 bytes, and FC does not contain a I_T nexus identifier,
-         * so we return the **port_nexus_ptr set to NULL.
-         */
-        *port_nexus_ptr = NULL;
-        *out_tid_len = 24;
+        int ret;
 
-         return (char *)&buf[8];
-}
-EXPORT_SYMBOL(fc_parse_pr_out_transport_id);
+        ret = hex2bin(&buf[8], nacl->initiatorname, 8);
+        if (ret) {
+                pr_debug("%s: invalid hex string\n", __func__);
+                return ret;
+        }
 
-/*
- * Handlers for Internet Small Computer Systems Interface (iSCSI)
- */
+        return 24;
+}
 
-u8 iscsi_get_fabric_proto_ident(struct se_portal_group *se_tpg)
+static int srp_get_pr_transport_id(
+        struct se_node_acl *nacl,
+        int *format_code,
+        unsigned char *buf)
 {
-        /*
-         * This value is defined for "Internet SCSI (iSCSI)"
-         * in spc4r17 section 7.5.1 Table 362
-         */
-        return 0x5;
+        const char *p;
+        unsigned len, count, leading_zero_bytes;
+        int rc;
+
+        p = nacl->initiatorname;
+        if (strncasecmp(p, "0x", 2) == 0)
+                p += 2;
+        len = strlen(p);
+        if (len % 2)
+                return -EINVAL;
+
+        count = min(len / 2, 16U);
+        leading_zero_bytes = 16 - count;
+        memset(buf + 8, 0, leading_zero_bytes);
+        rc = hex2bin(buf + 8 + leading_zero_bytes, p, count);
+        if (rc < 0) {
+                pr_debug("hex2bin failed for %s: %d\n", __func__, rc);
+                return rc;
+        }
+
+        return 24;
 }
-EXPORT_SYMBOL(iscsi_get_fabric_proto_ident);
 
-u32 iscsi_get_pr_transport_id(
-        struct se_portal_group *se_tpg,
+static int iscsi_get_pr_transport_id(
         struct se_node_acl *se_nacl,
         struct t10_pr_registration *pr_reg,
         int *format_code,
@@ -231,10 +148,6 @@ u32 iscsi_get_pr_transport_id(
 
         spin_lock_irq(&se_nacl->nacl_sess_lock);
         /*
-         * Set PROTOCOL IDENTIFIER to 5h for iSCSI
-        */
-        buf[0] = 0x05;
-        /*
          * From spc4r17 Section 7.5.4.6: TransportID for initiator
          * ports using SCSI over iSCSI.
          *
@@ -313,10 +226,8 @@ u32 iscsi_get_pr_transport_id(
 
         return len;
 }
-EXPORT_SYMBOL(iscsi_get_pr_transport_id);
 
-u32 iscsi_get_pr_transport_id_len(
-        struct se_portal_group *se_tpg,
+static int iscsi_get_pr_transport_id_len(
         struct se_node_acl *se_nacl,
         struct t10_pr_registration *pr_reg,
         int *format_code)
@@ -359,9 +270,8 @@ u32 iscsi_get_pr_transport_id_len(
 
         return len;
 }
-EXPORT_SYMBOL(iscsi_get_pr_transport_id_len);
 
-char *iscsi_parse_pr_out_transport_id(
+static char *iscsi_parse_pr_out_transport_id(
         struct se_portal_group *se_tpg,
         const char *buf,
         u32 *out_tid_len,
@@ -448,4 +358,79 @@ char *iscsi_parse_pr_out_transport_id(
 
         return (char *)&buf[4];
 }
-EXPORT_SYMBOL(iscsi_parse_pr_out_transport_id);
+
+int target_get_pr_transport_id_len(struct se_node_acl *nacl,
+                struct t10_pr_registration *pr_reg, int *format_code)
+{
+        switch (nacl->se_tpg->proto_id) {
+        case SCSI_PROTOCOL_FCP:
+        case SCSI_PROTOCOL_SBP:
+        case SCSI_PROTOCOL_SRP:
+        case SCSI_PROTOCOL_SAS:
+                break;
+        case SCSI_PROTOCOL_ISCSI:
+                return iscsi_get_pr_transport_id_len(nacl, pr_reg, format_code);
+        default:
+                pr_err("Unknown proto_id: 0x%02x\n", nacl->se_tpg->proto_id);
+                return -EINVAL;
+        }
+
+        /*
+         * Most transports use a fixed length 24 byte identifier.
+         */
+        *format_code = 0;
+        return 24;
+}
+
+int target_get_pr_transport_id(struct se_node_acl *nacl,
+                struct t10_pr_registration *pr_reg, int *format_code,
+                unsigned char *buf)
+{
+        switch (nacl->se_tpg->proto_id) {
+        case SCSI_PROTOCOL_SAS:
+                return sas_get_pr_transport_id(nacl, format_code, buf);
+        case SCSI_PROTOCOL_SBP:
+                return sbp_get_pr_transport_id(nacl, format_code, buf);
+        case SCSI_PROTOCOL_SRP:
+                return srp_get_pr_transport_id(nacl, format_code, buf);
+        case SCSI_PROTOCOL_FCP:
+                return fc_get_pr_transport_id(nacl, format_code, buf);
+        case SCSI_PROTOCOL_ISCSI:
+                return iscsi_get_pr_transport_id(nacl, pr_reg, format_code,
+                                buf);
+        default:
+                pr_err("Unknown proto_id: 0x%02x\n", nacl->se_tpg->proto_id);
+                return -EINVAL;
+        }
+}
+
+const char *target_parse_pr_out_transport_id(struct se_portal_group *tpg,
+                const char *buf, u32 *out_tid_len, char **port_nexus_ptr)
+{
+        u32 offset;
+
+        switch (tpg->proto_id) {
+        case SCSI_PROTOCOL_SAS:
+                /*
+                 * Assume the FORMAT CODE 00b from spc4r17, 7.5.4.7 TransportID
+                 * for initiator ports using SCSI over SAS Serial SCSI Protocol.
+                 */
+                offset = 4;
+                break;
+        case SCSI_PROTOCOL_SBP:
+        case SCSI_PROTOCOL_SRP:
+        case SCSI_PROTOCOL_FCP:
+                offset = 8;
+                break;
+        case SCSI_PROTOCOL_ISCSI:
+                return iscsi_parse_pr_out_transport_id(tpg, buf, out_tid_len,
+                                        port_nexus_ptr);
+        default:
+                pr_err("Unknown proto_id: 0x%02x\n", tpg->proto_id);
+                return NULL;
+        }
+
+        *port_nexus_ptr = NULL;
+        *out_tid_len = 24;
+        return buf + offset;
+}
diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c
index 664171353289..e3195700211a 100644
--- a/drivers/target/target_core_file.c
+++ b/drivers/target/target_core_file.c
@@ -37,7 +37,6 @@
 
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
-#include <target/target_core_backend_configfs.h>
 
 #include "target_core_file.h"
 
@@ -46,10 +45,6 @@ static inline struct fd_dev *FD_DEV(struct se_device *dev)
         return container_of(dev, struct fd_dev, dev);
 }
 
-/*      fd_attach_hba(): (Part of se_subsystem_api_t template)
- *
- *
- */
 static int fd_attach_hba(struct se_hba *hba, u32 host_id)
 {
         struct fd_host *fd_host;
@@ -66,7 +61,7 @@ static int fd_attach_hba(struct se_hba *hba, u32 host_id)
 
         pr_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic"
                 " Target Core Stack %s\n", hba->hba_id, FD_VERSION,
-                TARGET_CORE_MOD_VERSION);
+                TARGET_CORE_VERSION);
         pr_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic\n",
                 hba->hba_id, fd_host->fd_host_id);
 
@@ -246,87 +241,34 @@ fail:
         return ret;
 }
 
-static void fd_free_device(struct se_device *dev)
+static void fd_dev_call_rcu(struct rcu_head *p)
 {
+        struct se_device *dev = container_of(p, struct se_device, rcu_head);
         struct fd_dev *fd_dev = FD_DEV(dev);
 
-        if (fd_dev->fd_file) {
-                filp_close(fd_dev->fd_file, NULL);
-                fd_dev->fd_file = NULL;
-        }
-
         kfree(fd_dev);
 }
 
-static int fd_do_prot_rw(struct se_cmd *cmd, struct fd_prot *fd_prot,
-                         int is_write)
+static void fd_free_device(struct se_device *dev)
 {
-        struct se_device *se_dev = cmd->se_dev;
-        struct fd_dev *dev = FD_DEV(se_dev);
-        struct file *prot_fd = dev->fd_prot_file;
-        loff_t pos = (cmd->t_task_lba * se_dev->prot_length);
-        unsigned char *buf;
-        u32 prot_size;
-        int rc, ret = 1;
-
-        prot_size = (cmd->data_length / se_dev->dev_attrib.block_size) *
-                     se_dev->prot_length;
-
-        if (!is_write) {
-                fd_prot->prot_buf = kzalloc(prot_size, GFP_KERNEL);
-                if (!fd_prot->prot_buf) {
-                        pr_err("Unable to allocate fd_prot->prot_buf\n");
-                        return -ENOMEM;
-                }
-                buf = fd_prot->prot_buf;
-
-                fd_prot->prot_sg_nents = 1;
-                fd_prot->prot_sg = kzalloc(sizeof(struct scatterlist),
-                                           GFP_KERNEL);
-                if (!fd_prot->prot_sg) {
-                        pr_err("Unable to allocate fd_prot->prot_sg\n");
-                        kfree(fd_prot->prot_buf);
-                        return -ENOMEM;
-                }
-                sg_init_table(fd_prot->prot_sg, fd_prot->prot_sg_nents);
-                sg_set_buf(fd_prot->prot_sg, buf, prot_size);
-        }
-
-        if (is_write) {
-                rc = kernel_write(prot_fd, fd_prot->prot_buf, prot_size, pos);
-                if (rc < 0 || prot_size != rc) {
-                        pr_err("kernel_write() for fd_do_prot_rw failed:"
-                               " %d\n", rc);
-                        ret = -EINVAL;
-                }
-        } else {
-                rc = kernel_read(prot_fd, pos, fd_prot->prot_buf, prot_size);
-                if (rc < 0) {
-                        pr_err("kernel_read() for fd_do_prot_rw failed:"
-                               " %d\n", rc);
-                        ret = -EINVAL;
-                }
-        }
+        struct fd_dev *fd_dev = FD_DEV(dev);
 
-        if (is_write || ret < 0) {
-                kfree(fd_prot->prot_sg);
-                kfree(fd_prot->prot_buf);
+        if (fd_dev->fd_file) {
+                filp_close(fd_dev->fd_file, NULL);
+                fd_dev->fd_file = NULL;
         }
-
-        return ret;
+        call_rcu(&dev->rcu_head, fd_dev_call_rcu);
 }
 
-static int fd_do_rw(struct se_cmd *cmd, struct scatterlist *sgl,
-                u32 sgl_nents, int is_write)
+static int fd_do_rw(struct se_cmd *cmd, struct file *fd,
+                    u32 block_size, struct scatterlist *sgl,
+                    u32 sgl_nents, u32 data_length, int is_write)
 {
-        struct se_device *se_dev = cmd->se_dev;
-        struct fd_dev *dev = FD_DEV(se_dev);
-        struct file *fd = dev->fd_file;
         struct scatterlist *sg;
         struct iov_iter iter;
         struct bio_vec *bvec;
         ssize_t len = 0;
-        loff_t pos = (cmd->t_task_lba * se_dev->dev_attrib.block_size);
+        loff_t pos = (cmd->t_task_lba * block_size);
         int ret = 0, i;
 
         bvec = kcalloc(sgl_nents, sizeof(struct bio_vec), GFP_KERNEL);
@@ -352,7 +294,7 @@ static int fd_do_rw(struct se_cmd *cmd, struct scatterlist *sgl,
         kfree(bvec);
 
         if (is_write) {
-                if (ret < 0 || ret != cmd->data_length) {
+                if (ret < 0 || ret != data_length) {
                         pr_err("%s() write returned %d\n", __func__, ret);
                         return (ret < 0 ? ret : -EINVAL);
                 }
@@ -363,10 +305,10 @@ static int fd_do_rw(struct se_cmd *cmd, struct scatterlist *sgl,
                  * block_device.
                  */
                 if (S_ISBLK(file_inode(fd)->i_mode)) {
-                        if (ret < 0 || ret != cmd->data_length) {
+                        if (ret < 0 || ret != data_length) {
                                 pr_err("%s() returned %d, expecting %u for "
                                                 "S_ISBLK\n", __func__, ret,
-                                                cmd->data_length);
+                                                data_length);
                                 return (ret < 0 ? ret : -EINVAL);
                         }
                 } else {
@@ -533,9 +475,9 @@ fd_do_prot_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)
 }
 
 static sense_reason_t
-fd_do_unmap(struct se_cmd *cmd, void *priv, sector_t lba, sector_t nolb)
+fd_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)
 {
-        struct file *file = priv;
+        struct file *file = FD_DEV(cmd->se_dev)->fd_file;
         struct inode *inode = file->f_mapping->host;
         int ret;
 
@@ -577,42 +519,13 @@ fd_do_unmap(struct se_cmd *cmd, void *priv, sector_t lba, sector_t nolb)
 }
 
 static sense_reason_t
-fd_execute_write_same_unmap(struct se_cmd *cmd)
-{
-        struct se_device *se_dev = cmd->se_dev;
-        struct fd_dev *fd_dev = FD_DEV(se_dev);
-        struct file *file = fd_dev->fd_file;
-        sector_t lba = cmd->t_task_lba;
-        sector_t nolb = sbc_get_write_same_sectors(cmd);
-        sense_reason_t ret;
-
-        if (!nolb) {
-                target_complete_cmd(cmd, SAM_STAT_GOOD);
-                return 0;
-        }
-
-        ret = fd_do_unmap(cmd, file, lba, nolb);
-        if (ret)
-                return ret;
-
-        target_complete_cmd(cmd, GOOD);
-        return 0;
-}
-
-static sense_reason_t
-fd_execute_unmap(struct se_cmd *cmd)
-{
-        struct file *file = FD_DEV(cmd->se_dev)->fd_file;
-
-        return sbc_execute_unmap(cmd, fd_do_unmap, file);
-}
-
-static sense_reason_t
 fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
               enum dma_data_direction data_direction)
 {
         struct se_device *dev = cmd->se_dev;
-        struct fd_prot fd_prot;
+        struct fd_dev *fd_dev = FD_DEV(dev);
+        struct file *file = fd_dev->fd_file;
+        struct file *pfile = fd_dev->fd_prot_file;
         sense_reason_t rc;
         int ret = 0;
         /*
@@ -630,58 +543,45 @@ fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
          * physical memory addresses to struct iovec virtual memory.
          */
         if (data_direction == DMA_FROM_DEVICE) {
-                memset(&fd_prot, 0, sizeof(struct fd_prot));
-
                 if (cmd->prot_type && dev->dev_attrib.pi_prot_type) {
-                        ret = fd_do_prot_rw(cmd, &fd_prot, false);
+                        ret = fd_do_rw(cmd, pfile, dev->prot_length,
+                                       cmd->t_prot_sg, cmd->t_prot_nents,
+                                       cmd->prot_length, 0);
                         if (ret < 0)
                                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
                 }
 
-                ret = fd_do_rw(cmd, sgl, sgl_nents, 0);
+                ret = fd_do_rw(cmd, file, dev->dev_attrib.block_size,
+                               sgl, sgl_nents, cmd->data_length, 0);
 
                 if (ret > 0 && cmd->prot_type && dev->dev_attrib.pi_prot_type) {
-                        u32 sectors = cmd->data_length / dev->dev_attrib.block_size;
+                        u32 sectors = cmd->data_length >>
+                                        ilog2(dev->dev_attrib.block_size);
 
-                        rc = sbc_dif_verify_read(cmd, cmd->t_task_lba, sectors,
-                                                 0, fd_prot.prot_sg, 0);
-                        if (rc) {
-                                kfree(fd_prot.prot_sg);
-                                kfree(fd_prot.prot_buf);
+                        rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors,
+                                            0, cmd->t_prot_sg, 0);
+                        if (rc)
                                 return rc;
-                        }
-                        kfree(fd_prot.prot_sg);
-                        kfree(fd_prot.prot_buf);
                 }
         } else {
-                memset(&fd_prot, 0, sizeof(struct fd_prot));
-
                 if (cmd->prot_type && dev->dev_attrib.pi_prot_type) {
-                        u32 sectors = cmd->data_length / dev->dev_attrib.block_size;
+                        u32 sectors = cmd->data_length >>
+                                        ilog2(dev->dev_attrib.block_size);
 
-                        ret = fd_do_prot_rw(cmd, &fd_prot, false);
-                        if (ret < 0)
-                                return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
-
-                        rc = sbc_dif_verify_write(cmd, cmd->t_task_lba, sectors,
-                                                  0, fd_prot.prot_sg, 0);
-                        if (rc) {
-                                kfree(fd_prot.prot_sg);
-                                kfree(fd_prot.prot_buf);
+                        rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors,
+                                            0, cmd->t_prot_sg, 0);
+                        if (rc)
                                 return rc;
-                        }
                 }
 
-                ret = fd_do_rw(cmd, sgl, sgl_nents, 1);
+                ret = fd_do_rw(cmd, file, dev->dev_attrib.block_size,
+                               sgl, sgl_nents, cmd->data_length, 1);
                 /*
                  * Perform implicit vfs_fsync_range() for fd_do_writev() ops
                  * for SCSI WRITEs with Forced Unit Access (FUA) set.
                  * Allow this to happen independent of WCE=0 setting.
                  */
-                if (ret > 0 &&
-                    dev->dev_attrib.emulate_fua_write > 0 &&
-                    (cmd->se_cmd_flags & SCF_FUA)) {
-                        struct fd_dev *fd_dev = FD_DEV(dev);
+                if (ret > 0 && (cmd->se_cmd_flags & SCF_FUA)) {
                         loff_t start = cmd->t_task_lba *
                                 dev->dev_attrib.block_size;
                         loff_t end;
@@ -695,17 +595,16 @@ fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
                 }
 
                 if (ret > 0 && cmd->prot_type && dev->dev_attrib.pi_prot_type) {
-                        ret = fd_do_prot_rw(cmd, &fd_prot, true);
+                        ret = fd_do_rw(cmd, pfile, dev->prot_length,
+                                       cmd->t_prot_sg, cmd->t_prot_nents,
+                                       cmd->prot_length, 1);
                         if (ret < 0)
                                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
                 }
         }
 
-        if (ret < 0) {
-                kfree(fd_prot.prot_sg);
-                kfree(fd_prot.prot_buf);
+        if (ret < 0)
                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
-        }
 
         if (ret)
                 target_complete_cmd(cmd, SAM_STAT_GOOD);
@@ -908,7 +807,6 @@ static struct sbc_ops fd_sbc_ops = {
         .execute_rw             = fd_execute_rw,
         .execute_sync_cache     = fd_execute_sync_cache,
         .execute_write_same     = fd_execute_write_same,
-        .execute_write_same_unmap = fd_execute_write_same_unmap,
         .execute_unmap          = fd_execute_unmap,
 };
 
@@ -918,42 +816,7 @@ fd_parse_cdb(struct se_cmd *cmd)
         return sbc_parse_cdb(cmd, &fd_sbc_ops);
 }
 
-DEF_TB_DEFAULT_ATTRIBS(fileio);
-
-static struct configfs_attribute *fileio_backend_dev_attrs[] = {
-        &fileio_dev_attrib_emulate_model_alias.attr,
-        &fileio_dev_attrib_emulate_dpo.attr,
-        &fileio_dev_attrib_emulate_fua_write.attr,
-        &fileio_dev_attrib_emulate_fua_read.attr,
-        &fileio_dev_attrib_emulate_write_cache.attr,
-        &fileio_dev_attrib_emulate_ua_intlck_ctrl.attr,
-        &fileio_dev_attrib_emulate_tas.attr,
-        &fileio_dev_attrib_emulate_tpu.attr,
-        &fileio_dev_attrib_emulate_tpws.attr,
-        &fileio_dev_attrib_emulate_caw.attr,
-        &fileio_dev_attrib_emulate_3pc.attr,
-        &fileio_dev_attrib_pi_prot_type.attr,
-        &fileio_dev_attrib_hw_pi_prot_type.attr,
-        &fileio_dev_attrib_pi_prot_format.attr,
-        &fileio_dev_attrib_enforce_pr_isids.attr,
-        &fileio_dev_attrib_is_nonrot.attr,
-        &fileio_dev_attrib_emulate_rest_reord.attr,
-        &fileio_dev_attrib_force_pr_aptpl.attr,
-        &fileio_dev_attrib_hw_block_size.attr,
-        &fileio_dev_attrib_block_size.attr,
-        &fileio_dev_attrib_hw_max_sectors.attr,
-        &fileio_dev_attrib_optimal_sectors.attr,
-        &fileio_dev_attrib_hw_queue_depth.attr,
-        &fileio_dev_attrib_queue_depth.attr,
-        &fileio_dev_attrib_max_unmap_lba_count.attr,
-        &fileio_dev_attrib_max_unmap_block_desc_count.attr,
-        &fileio_dev_attrib_unmap_granularity.attr,
-        &fileio_dev_attrib_unmap_granularity_alignment.attr,
-        &fileio_dev_attrib_max_write_same_len.attr,
-        NULL,
-};
-
-static struct se_subsystem_api fileio_template = {
+static const struct target_backend_ops fileio_ops = {
         .name                   = "fileio",
         .inquiry_prod           = "FILEIO",
         .inquiry_rev            = FD_VERSION,
@@ -971,21 +834,17 @@ static struct se_subsystem_api fileio_template = {
         .init_prot              = fd_init_prot,
         .format_prot            = fd_format_prot,
         .free_prot              = fd_free_prot,
+        .tb_dev_attrib_attrs    = sbc_attrib_attrs,
 };
 
 static int __init fileio_module_init(void)
 {
-        struct target_backend_cits *tbc = &fileio_template.tb_cits;
-
-        target_core_setup_sub_cits(&fileio_template);
-        tbc->tb_dev_attrib_cit.ct_attrs = fileio_backend_dev_attrs;
-
-        return transport_subsystem_register(&fileio_template);
+        return transport_backend_register(&fileio_ops);
 }
 
 static void __exit fileio_module_exit(void)
 {
-        transport_subsystem_release(&fileio_template);
+        target_backend_unregister(&fileio_ops);
 }
 
 MODULE_DESCRIPTION("TCM FILEIO subsystem plugin");
diff --git a/drivers/target/target_core_file.h b/drivers/target/target_core_file.h
index 182cbb295039..068966fce308 100644
--- a/drivers/target/target_core_file.h
+++ b/drivers/target/target_core_file.h
@@ -21,12 +21,6 @@
 #define FDBD_HAS_BUFFERED_IO_WCE 0x04
 #define FDBD_FORMAT_UNIT_SIZE   2048
 
-struct fd_prot {
-        unsigned char   *prot_buf;
-        struct scatterlist *prot_sg;
-        u32 prot_sg_nents;
-};
-
 struct fd_dev {
         struct se_device dev;
 
diff --git a/drivers/target/target_core_hba.c b/drivers/target/target_core_hba.c
index ff95f95dcd13..62ea4e8e70a8 100644
--- a/drivers/target/target_core_hba.c
+++ b/drivers/target/target_core_hba.c
@@ -36,67 +36,78 @@
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 
 #include "target_core_internal.h"
 
-static LIST_HEAD(subsystem_list);
-static DEFINE_MUTEX(subsystem_mutex);
+static LIST_HEAD(backend_list);
+static DEFINE_MUTEX(backend_mutex);
 
 static u32 hba_id_counter;
 
 static DEFINE_SPINLOCK(hba_lock);
 static LIST_HEAD(hba_list);
 
-int transport_subsystem_register(struct se_subsystem_api *sub_api)
-{
-        struct se_subsystem_api *s;
-
-        INIT_LIST_HEAD(&sub_api->sub_api_list);
 
-        mutex_lock(&subsystem_mutex);
-        list_for_each_entry(s, &subsystem_list, sub_api_list) {
-                if (!strcmp(s->name, sub_api->name)) {
-                        pr_err("%p is already registered with"
-                                " duplicate name %s, unable to process"
-                                " request\n", s, s->name);
-                        mutex_unlock(&subsystem_mutex);
+int transport_backend_register(const struct target_backend_ops *ops)
+{
+        struct target_backend *tb, *old;
+
+        tb = kzalloc(sizeof(*tb), GFP_KERNEL);
+        if (!tb)
+                return -ENOMEM;
+        tb->ops = ops;
+
+        mutex_lock(&backend_mutex);
+        list_for_each_entry(old, &backend_list, list) {
+                if (!strcmp(old->ops->name, ops->name)) {
+                        pr_err("backend %s already registered.\n", ops->name);
+                        mutex_unlock(&backend_mutex);
+                        kfree(tb);
                         return -EEXIST;
                 }
         }
-        list_add_tail(&sub_api->sub_api_list, &subsystem_list);
-        mutex_unlock(&subsystem_mutex);
+        target_setup_backend_cits(tb);
+        list_add_tail(&tb->list, &backend_list);
+        mutex_unlock(&backend_mutex);
 
-        pr_debug("TCM: Registered subsystem plugin: %s struct module:"
-                        " %p\n", sub_api->name, sub_api->owner);
+        pr_debug("TCM: Registered subsystem plugin: %s struct module: %p\n",
+                        ops->name, ops->owner);
         return 0;
 }
-EXPORT_SYMBOL(transport_subsystem_register);
+EXPORT_SYMBOL(transport_backend_register);
 
-void transport_subsystem_release(struct se_subsystem_api *sub_api)
+void target_backend_unregister(const struct target_backend_ops *ops)
 {
-        mutex_lock(&subsystem_mutex);
-        list_del(&sub_api->sub_api_list);
-        mutex_unlock(&subsystem_mutex);
+        struct target_backend *tb;
+
+        mutex_lock(&backend_mutex);
+        list_for_each_entry(tb, &backend_list, list) {
+                if (tb->ops == ops) {
+                        list_del(&tb->list);
+                        kfree(tb);
+                        break;
+                }
+        }
+        mutex_unlock(&backend_mutex);
 }
-EXPORT_SYMBOL(transport_subsystem_release);
+EXPORT_SYMBOL(target_backend_unregister);
 
-static struct se_subsystem_api *core_get_backend(const char *sub_name)
+static struct target_backend *core_get_backend(const char *name)
 {
-        struct se_subsystem_api *s;
+        struct target_backend *tb;
 
-        mutex_lock(&subsystem_mutex);
-        list_for_each_entry(s, &subsystem_list, sub_api_list) {
-                if (!strcmp(s->name, sub_name))
+        mutex_lock(&backend_mutex);
+        list_for_each_entry(tb, &backend_list, list) {
+                if (!strcmp(tb->ops->name, name))
                         goto found;
         }
-        mutex_unlock(&subsystem_mutex);
+        mutex_unlock(&backend_mutex);
         return NULL;
 found:
-        if (s->owner && !try_module_get(s->owner))
-                s = NULL;
-        mutex_unlock(&subsystem_mutex);
-        return s;
+        if (tb->ops->owner && !try_module_get(tb->ops->owner))
+                tb = NULL;
+        mutex_unlock(&backend_mutex);
+        return tb;
 }
 
 struct se_hba *
@@ -117,13 +128,13 @@ core_alloc_hba(const char *plugin_name, u32 plugin_dep_id, u32 hba_flags)
         hba->hba_index = scsi_get_new_index(SCSI_INST_INDEX);
         hba->hba_flags |= hba_flags;
 
-        hba->transport = core_get_backend(plugin_name);
-        if (!hba->transport) {
+        hba->backend = core_get_backend(plugin_name);
+        if (!hba->backend) {
                 ret = -EINVAL;
                 goto out_free_hba;
         }
 
-        ret = hba->transport->attach_hba(hba, plugin_dep_id);
+        ret = hba->backend->ops->attach_hba(hba, plugin_dep_id);
         if (ret < 0)
                 goto out_module_put;
 
@@ -138,8 +149,8 @@ core_alloc_hba(const char *plugin_name, u32 plugin_dep_id, u32 hba_flags)
         return hba;
 
 out_module_put:
-        module_put(hba->transport->owner);
-        hba->transport = NULL;
+        module_put(hba->backend->ops->owner);
+        hba->backend = NULL;
 out_free_hba:
         kfree(hba);
         return ERR_PTR(ret);
@@ -150,7 +161,7 @@ core_delete_hba(struct se_hba *hba)
 {
         WARN_ON(hba->dev_count);
 
-        hba->transport->detach_hba(hba);
+        hba->backend->ops->detach_hba(hba);
 
         spin_lock(&hba_lock);
         list_del(&hba->hba_node);
@@ -159,9 +170,9 @@ core_delete_hba(struct se_hba *hba)
         pr_debug("CORE_HBA[%d] - Detached HBA from Generic Target"
                         " Core\n", hba->hba_id);
 
-        module_put(hba->transport->owner);
+        module_put(hba->backend->ops->owner);
 
-        hba->transport = NULL;
+        hba->backend = NULL;
         kfree(hba);
         return 0;
 }
diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
index 972ed1781ae2..6d88d24e6cce 100644
--- a/drivers/target/target_core_iblock.c
+++ b/drivers/target/target_core_iblock.c
@@ -40,7 +40,6 @@
 
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
-#include <target/target_core_backend_configfs.h>
 
 #include "target_core_iblock.h"
 
@@ -53,17 +52,11 @@ static inline struct iblock_dev *IBLOCK_DEV(struct se_device *dev)
 }
 
 
-static struct se_subsystem_api iblock_template;
-
-/*      iblock_attach_hba(): (Part of se_subsystem_api_t template)
- *
- *
- */
 static int iblock_attach_hba(struct se_hba *hba, u32 host_id)
 {
         pr_debug("CORE_HBA[%d] - TCM iBlock HBA Driver %s on"
                 " Generic Target Core Stack %s\n", hba->hba_id,
-                IBLOCK_VERSION, TARGET_CORE_MOD_VERSION);
+                IBLOCK_VERSION, TARGET_CORE_VERSION);
         return 0;
 }
 
@@ -197,6 +190,14 @@ out:
         return ret;
 }
 
+static void iblock_dev_call_rcu(struct rcu_head *p)
+{
+        struct se_device *dev = container_of(p, struct se_device, rcu_head);
+        struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
+
+        kfree(ib_dev);
+}
+
 static void iblock_free_device(struct se_device *dev)
 {
         struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
@@ -206,7 +207,7 @@ static void iblock_free_device(struct se_device *dev)
         if (ib_dev->ibd_bio_set != NULL)
                 bioset_free(ib_dev->ibd_bio_set);
 
-        kfree(ib_dev);
+        call_rcu(&dev->rcu_head, iblock_dev_call_rcu);
 }
 
 static unsigned long long iblock_emulate_read_cap_with_block_size(
@@ -414,10 +415,9 @@ iblock_execute_sync_cache(struct se_cmd *cmd)
 }
 
 static sense_reason_t
-iblock_do_unmap(struct se_cmd *cmd, void *priv,
-                sector_t lba, sector_t nolb)
+iblock_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)
 {
-        struct block_device *bdev = priv;
+        struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd;
         int ret;
 
         ret = blkdev_issue_discard(bdev, lba, nolb, GFP_KERNEL, 0);
@@ -430,30 +430,6 @@ iblock_do_unmap(struct se_cmd *cmd, void *priv,
 }
 
 static sense_reason_t
-iblock_execute_unmap(struct se_cmd *cmd)
-{
-        struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd;
-
-        return sbc_execute_unmap(cmd, iblock_do_unmap, bdev);
-}
-
-static sense_reason_t
-iblock_execute_write_same_unmap(struct se_cmd *cmd)
-{
-        struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd;
-        sector_t lba = cmd->t_task_lba;
-        sector_t nolb = sbc_get_write_same_sectors(cmd);
-        sense_reason_t ret;
-
-        ret = iblock_do_unmap(cmd, bdev, lba, nolb);
-        if (ret)
-                return ret;
-
-        target_complete_cmd(cmd, GOOD);
-        return 0;
-}
-
-static sense_reason_t
 iblock_execute_write_same(struct se_cmd *cmd)
 {
         struct iblock_req *ibr;
@@ -844,7 +820,6 @@ static struct sbc_ops iblock_sbc_ops = {
         .execute_rw             = iblock_execute_rw,
         .execute_sync_cache     = iblock_execute_sync_cache,
         .execute_write_same     = iblock_execute_write_same,
-        .execute_write_same_unmap = iblock_execute_write_same_unmap,
         .execute_unmap          = iblock_execute_unmap,
 };
 
@@ -863,42 +838,7 @@ static bool iblock_get_write_cache(struct se_device *dev)
         return q->flush_flags & REQ_FLUSH;
 }
 
-DEF_TB_DEFAULT_ATTRIBS(iblock);
-
-static struct configfs_attribute *iblock_backend_dev_attrs[] = {
-        &iblock_dev_attrib_emulate_model_alias.attr,
-        &iblock_dev_attrib_emulate_dpo.attr,
-        &iblock_dev_attrib_emulate_fua_write.attr,
-        &iblock_dev_attrib_emulate_fua_read.attr,
-        &iblock_dev_attrib_emulate_write_cache.attr,
-        &iblock_dev_attrib_emulate_ua_intlck_ctrl.attr,
-        &iblock_dev_attrib_emulate_tas.attr,
-        &iblock_dev_attrib_emulate_tpu.attr,
-        &iblock_dev_attrib_emulate_tpws.attr,
-        &iblock_dev_attrib_emulate_caw.attr,
-        &iblock_dev_attrib_emulate_3pc.attr,
-        &iblock_dev_attrib_pi_prot_type.attr,
-        &iblock_dev_attrib_hw_pi_prot_type.attr,
-        &iblock_dev_attrib_pi_prot_format.attr,
-        &iblock_dev_attrib_enforce_pr_isids.attr,
-        &iblock_dev_attrib_is_nonrot.attr,
-        &iblock_dev_attrib_emulate_rest_reord.attr,
-        &iblock_dev_attrib_force_pr_aptpl.attr,
-        &iblock_dev_attrib_hw_block_size.attr,
-        &iblock_dev_attrib_block_size.attr,
-        &iblock_dev_attrib_hw_max_sectors.attr,
-        &iblock_dev_attrib_optimal_sectors.attr,
-        &iblock_dev_attrib_hw_queue_depth.attr,
-        &iblock_dev_attrib_queue_depth.attr,
-        &iblock_dev_attrib_max_unmap_lba_count.attr,
-        &iblock_dev_attrib_max_unmap_block_desc_count.attr,
-        &iblock_dev_attrib_unmap_granularity.attr,
-        &iblock_dev_attrib_unmap_granularity_alignment.attr,
-        &iblock_dev_attrib_max_write_same_len.attr,
-        NULL,
-};
-
-static struct se_subsystem_api iblock_template = {
+static const struct target_backend_ops iblock_ops = {
         .name                   = "iblock",
         .inquiry_prod           = "IBLOCK",
         .inquiry_rev            = IBLOCK_VERSION,
@@ -918,21 +858,17 @@ static struct se_subsystem_api iblock_template = {
         .get_io_min             = iblock_get_io_min,
         .get_io_opt             = iblock_get_io_opt,
         .get_write_cache        = iblock_get_write_cache,
+        .tb_dev_attrib_attrs    = sbc_attrib_attrs,
 };
 
 static int __init iblock_module_init(void)
 {
-        struct target_backend_cits *tbc = &iblock_template.tb_cits;
-
-        target_core_setup_sub_cits(&iblock_template);
-        tbc->tb_dev_attrib_cit.ct_attrs = iblock_backend_dev_attrs;
-
-        return transport_subsystem_register(&iblock_template);
+        return transport_backend_register(&iblock_ops);
 }
 
 static void __exit iblock_module_exit(void)
 {
-        transport_subsystem_release(&iblock_template);
+        target_backend_unregister(&iblock_ops);
 }
 
 MODULE_DESCRIPTION("TCM IBLOCK subsystem plugin");
diff --git a/drivers/target/target_core_internal.h b/drivers/target/target_core_internal.h
index 68bd7f5d9f73..99c24acfe676 100644
--- a/drivers/target/target_core_internal.h
+++ b/drivers/target/target_core_internal.h
@@ -1,6 +1,53 @@
 #ifndef TARGET_CORE_INTERNAL_H
 #define TARGET_CORE_INTERNAL_H
 
+#define TARGET_CORE_NAME_MAX_LEN        64
+#define TARGET_FABRIC_NAME_SIZE         32
+
+struct target_backend {
+        struct list_head list;
+
+        const struct target_backend_ops *ops;
+
+        struct config_item_type tb_dev_cit;
+        struct config_item_type tb_dev_attrib_cit;
+        struct config_item_type tb_dev_pr_cit;
+        struct config_item_type tb_dev_wwn_cit;
+        struct config_item_type tb_dev_alua_tg_pt_gps_cit;
+        struct config_item_type tb_dev_stat_cit;
+};
+
+struct target_fabric_configfs {
+        atomic_t                tf_access_cnt;
+        struct list_head        tf_list;
+        struct config_group     tf_group;
+        struct config_group     tf_disc_group;
+        struct config_group     *tf_default_groups[2];
+        const struct target_core_fabric_ops *tf_ops;
+
+        struct config_item_type tf_discovery_cit;
+        struct config_item_type tf_wwn_cit;
+        struct config_item_type tf_wwn_fabric_stats_cit;
+        struct config_item_type tf_tpg_cit;
+        struct config_item_type tf_tpg_base_cit;
+        struct config_item_type tf_tpg_lun_cit;
+        struct config_item_type tf_tpg_port_cit;
+        struct config_item_type tf_tpg_port_stat_cit;
+        struct config_item_type tf_tpg_np_cit;
+        struct config_item_type tf_tpg_np_base_cit;
+        struct config_item_type tf_tpg_attrib_cit;
+        struct config_item_type tf_tpg_auth_cit;
+        struct config_item_type tf_tpg_param_cit;
+        struct config_item_type tf_tpg_nacl_cit;
+        struct config_item_type tf_tpg_nacl_base_cit;
+        struct config_item_type tf_tpg_nacl_attrib_cit;
+        struct config_item_type tf_tpg_nacl_auth_cit;
+        struct config_item_type tf_tpg_nacl_param_cit;
+        struct config_item_type tf_tpg_nacl_stat_cit;
+        struct config_item_type tf_tpg_mappedlun_cit;
+        struct config_item_type tf_tpg_mappedlun_stat_cit;
+};
+
 /* target_core_alua.c */
 extern struct t10_alua_lu_gp *default_lu_gp;
 
@@ -8,28 +55,27 @@ extern struct t10_alua_lu_gp *default_lu_gp;
 extern struct mutex g_device_mutex;
 extern struct list_head g_device_list;
 
+int     core_alloc_rtpi(struct se_lun *lun, struct se_device *dev);
 struct se_dev_entry *core_get_se_deve_from_rtpi(struct se_node_acl *, u16);
-int     core_free_device_list_for_node(struct se_node_acl *,
+void    target_pr_kref_release(struct kref *);
+void    core_free_device_list_for_node(struct se_node_acl *,
                 struct se_portal_group *);
-void    core_update_device_list_access(u32, u32, struct se_node_acl *);
+void    core_update_device_list_access(u64, u32, struct se_node_acl *);
+struct se_dev_entry *target_nacl_find_deve(struct se_node_acl *, u64);
 int     core_enable_device_list_for_node(struct se_lun *, struct se_lun_acl *,
-                u32, u32, struct se_node_acl *, struct se_portal_group *);
-int     core_disable_device_list_for_node(struct se_lun *, struct se_lun_acl *,
-                u32, u32, struct se_node_acl *, struct se_portal_group *);
+                u64, u32, struct se_node_acl *, struct se_portal_group *);
+void    core_disable_device_list_for_node(struct se_lun *, struct se_dev_entry *,
+                struct se_node_acl *, struct se_portal_group *);
 void    core_clear_lun_from_tpg(struct se_lun *, struct se_portal_group *);
-int     core_dev_export(struct se_device *, struct se_portal_group *,
-                struct se_lun *);
-void    core_dev_unexport(struct se_device *, struct se_portal_group *,
-                struct se_lun *);
-struct se_lun *core_dev_add_lun(struct se_portal_group *, struct se_device *, u32);
+int     core_dev_add_lun(struct se_portal_group *, struct se_device *,
+                struct se_lun *lun);
 void    core_dev_del_lun(struct se_portal_group *, struct se_lun *);
-struct se_lun *core_get_lun_from_tpg(struct se_portal_group *, u32);
 struct se_lun_acl *core_dev_init_initiator_node_lun_acl(struct se_portal_group *,
-                struct se_node_acl *, u32, int *);
+                struct se_node_acl *, u64, int *);
 int     core_dev_add_initiator_node_lun_acl(struct se_portal_group *,
-                struct se_lun_acl *, u32, u32);
-int     core_dev_del_initiator_node_lun_acl(struct se_portal_group *,
-                struct se_lun *, struct se_lun_acl *);
+                struct se_lun_acl *, struct se_lun *lun, u32);
+int     core_dev_del_initiator_node_lun_acl(struct se_lun *,
+                struct se_lun_acl *);
 void    core_dev_free_initiator_node_lun_acl(struct se_portal_group *,
                 struct se_lun_acl *lacl);
 int     core_dev_setup_virtual_lun0(void);
@@ -38,6 +84,18 @@ struct se_device *target_alloc_device(struct se_hba *hba, const char *name);
 int     target_configure_device(struct se_device *dev);
 void    target_free_device(struct se_device *);
 
+/* target_core_configfs.c */
+void    target_setup_backend_cits(struct target_backend *);
+
+/* target_core_fabric_lib.c */
+int     target_get_pr_transport_id_len(struct se_node_acl *nacl,
+                struct t10_pr_registration *pr_reg, int *format_code);
+int     target_get_pr_transport_id(struct se_node_acl *nacl,
+                struct t10_pr_registration *pr_reg, int *format_code,
+                unsigned char *buf);
+const char *target_parse_pr_out_transport_id(struct se_portal_group *tpg,
+                const char *buf, u32 *out_tid_len, char **port_nexus_ptr);
+
 /* target_core_hba.c */
 struct se_hba *core_alloc_hba(const char *, u32, u32);
 int     core_delete_hba(struct se_hba *);
@@ -53,12 +111,16 @@ extern struct se_device *g_lun0_dev;
 
 struct se_node_acl *__core_tpg_get_initiator_node_acl(struct se_portal_group *tpg,
                 const char *);
-void    core_tpg_add_node_to_devs(struct se_node_acl *, struct se_portal_group *);
+void    core_tpg_add_node_to_devs(struct se_node_acl *, struct se_portal_group *,
+                                  struct se_lun *);
 void    core_tpg_wait_for_nacl_pr_ref(struct se_node_acl *);
-struct se_lun *core_tpg_alloc_lun(struct se_portal_group *, u32);
+struct se_lun *core_tpg_alloc_lun(struct se_portal_group *, u64);
 int     core_tpg_add_lun(struct se_portal_group *, struct se_lun *,
                 u32, struct se_device *);
 void core_tpg_remove_lun(struct se_portal_group *, struct se_lun *);
+struct se_node_acl *core_tpg_add_initiator_node_acl(struct se_portal_group *tpg,
+                const char *initiatorname);
+void core_tpg_del_initiator_node_acl(struct se_node_acl *acl);
 
 /* target_core_transport.c */
 extern struct kmem_cache *se_tmr_req_cache;
@@ -77,14 +139,19 @@ int	transport_dump_vpd_assoc(struct t10_vpd *, unsigned char *, int);
 int     transport_dump_vpd_ident_type(struct t10_vpd *, unsigned char *, int);
 int     transport_dump_vpd_ident(struct t10_vpd *, unsigned char *, int);
 bool    target_stop_cmd(struct se_cmd *cmd, unsigned long *flags);
-int     transport_clear_lun_ref(struct se_lun *);
+void    transport_clear_lun_ref(struct se_lun *);
 void    transport_send_task_abort(struct se_cmd *);
 sense_reason_t  target_cmd_size_check(struct se_cmd *cmd, unsigned int size);
 void    target_qf_do_work(struct work_struct *work);
+bool    target_check_wce(struct se_device *dev);
+bool    target_check_fua(struct se_device *dev);
 
 /* target_core_stat.c */
 void    target_stat_setup_dev_default_groups(struct se_device *);
 void    target_stat_setup_port_default_groups(struct se_lun *);
 void    target_stat_setup_mappedlun_default_groups(struct se_lun_acl *);
 
+/* target_core_xcopy.c */
+extern struct se_portal_group xcopy_pt_tpg;
+
 #endif /* TARGET_CORE_INTERNAL_H */
diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c
index 8e5fa291f878..0fdbe43b7dad 100644
--- a/drivers/target/target_core_pr.c
+++ b/drivers/target/target_core_pr.c
@@ -35,7 +35,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 
 #include "target_core_internal.h"
 #include "target_core_pr.h"
@@ -45,7 +44,6 @@
  * Used for Specify Initiator Ports Capable Bit (SPEC_I_PT)
  */
 struct pr_transport_id_holder {
-        int dest_local_nexus;
         struct t10_pr_registration *dest_pr_reg;
         struct se_portal_group *dest_tpg;
         struct se_node_acl *dest_node_acl;
@@ -231,9 +229,10 @@ target_scsi2_reservation_release(struct se_cmd *cmd)
                 dev->dev_reservation_flags &= ~DRF_SPC2_RESERVATIONS_WITH_ISID;
         }
         tpg = sess->se_tpg;
-        pr_debug("SCSI-2 Released reservation for %s LUN: %u ->"
-                " MAPPED LUN: %u for %s\n", tpg->se_tpg_tfo->get_fabric_name(),
-                cmd->se_lun->unpacked_lun, cmd->se_deve->mapped_lun,
+        pr_debug("SCSI-2 Released reservation for %s LUN: %llu ->"
+                " MAPPED LUN: %llu for %s\n",
+                tpg->se_tpg_tfo->get_fabric_name(),
+                cmd->se_lun->unpacked_lun, cmd->orig_fe_lun,
                 sess->se_node_acl->initiatorname);
 
 out_unlock:
@@ -277,12 +276,12 @@ target_scsi2_reservation_reserve(struct se_cmd *cmd)
            (dev->dev_reserved_node_acl != sess->se_node_acl)) {
                 pr_err("SCSI-2 RESERVATION CONFLIFT for %s fabric\n",
                         tpg->se_tpg_tfo->get_fabric_name());
-                pr_err("Original reserver LUN: %u %s\n",
+                pr_err("Original reserver LUN: %llu %s\n",
                         cmd->se_lun->unpacked_lun,
                         dev->dev_reserved_node_acl->initiatorname);
-                pr_err("Current attempt - LUN: %u -> MAPPED LUN: %u"
+                pr_err("Current attempt - LUN: %llu -> MAPPED LUN: %llu"
                         " from %s \n", cmd->se_lun->unpacked_lun,
-                        cmd->se_deve->mapped_lun,
+                        cmd->orig_fe_lun,
                         sess->se_node_acl->initiatorname);
                 ret = TCM_RESERVATION_CONFLICT;
                 goto out_unlock;
@@ -294,9 +293,9 @@ target_scsi2_reservation_reserve(struct se_cmd *cmd)
                 dev->dev_res_bin_isid = sess->sess_bin_isid;
                 dev->dev_reservation_flags |= DRF_SPC2_RESERVATIONS_WITH_ISID;
         }
-        pr_debug("SCSI-2 Reserved %s LUN: %u -> MAPPED LUN: %u"
+        pr_debug("SCSI-2 Reserved %s LUN: %llu -> MAPPED LUN: %llu"
                 " for %s\n", tpg->se_tpg_tfo->get_fabric_name(),
-                cmd->se_lun->unpacked_lun, cmd->se_deve->mapped_lun,
+                cmd->se_lun->unpacked_lun, cmd->orig_fe_lun,
                 sess->se_node_acl->initiatorname);
 
 out_unlock:
@@ -314,28 +313,31 @@ out:
  * This function is called by those initiator ports who are *NOT*
  * the active PR reservation holder when a reservation is present.
  */
-static int core_scsi3_pr_seq_non_holder(
-        struct se_cmd *cmd,
-        u32 pr_reg_type)
+static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
+                                        bool isid_mismatch)
 {
         unsigned char *cdb = cmd->t_task_cdb;
-        struct se_dev_entry *se_deve;
         struct se_session *se_sess = cmd->se_sess;
-        int other_cdb = 0, ignore_reg;
+        struct se_node_acl *nacl = se_sess->se_node_acl;
+        int other_cdb = 0;
         int registered_nexus = 0, ret = 1; /* Conflict by default */
         int all_reg = 0, reg_only = 0; /* ALL_REG, REG_ONLY */
         int we = 0; /* Write Exclusive */
         int legacy = 0; /* Act like a legacy device and return
                          * RESERVATION CONFLICT on some CDBs */
 
-        se_deve = se_sess->se_node_acl->device_list[cmd->orig_fe_lun];
-        /*
-         * Determine if the registration should be ignored due to
-         * non-matching ISIDs in target_scsi3_pr_reservation_check().
-         */
-        ignore_reg = (pr_reg_type & 0x80000000);
-        if (ignore_reg)
-                pr_reg_type &= ~0x80000000;
+        if (isid_mismatch) {
+                registered_nexus = 0;
+        } else {
+                struct se_dev_entry *se_deve;
+
+                rcu_read_lock();
+                se_deve = target_nacl_find_deve(nacl, cmd->orig_fe_lun);
+                if (se_deve)
+                        registered_nexus = test_bit(DEF_PR_REG_ACTIVE,
+                                                    &se_deve->deve_flags);
+                rcu_read_unlock();
+        }
 
         switch (pr_reg_type) {
         case PR_TYPE_WRITE_EXCLUSIVE:
@@ -345,8 +347,6 @@ static int core_scsi3_pr_seq_non_holder(
                  * Some commands are only allowed for the persistent reservation
                  * holder.
                  */
-                if ((se_deve->def_pr_registered) && !(ignore_reg))
-                        registered_nexus = 1;
                 break;
         case PR_TYPE_WRITE_EXCLUSIVE_REGONLY:
                 we = 1;
@@ -355,8 +355,6 @@ static int core_scsi3_pr_seq_non_holder(
                  * Some commands are only allowed for registered I_T Nexuses.
                  */
                 reg_only = 1;
-                if ((se_deve->def_pr_registered) && !(ignore_reg))
-                        registered_nexus = 1;
                 break;
         case PR_TYPE_WRITE_EXCLUSIVE_ALLREG:
                 we = 1;
@@ -365,8 +363,6 @@ static int core_scsi3_pr_seq_non_holder(
                  * Each registered I_T Nexus is a reservation holder.
                  */
                 all_reg = 1;
-                if ((se_deve->def_pr_registered) && !(ignore_reg))
-                        registered_nexus = 1;
                 break;
         default:
                 return -EINVAL;
@@ -572,6 +568,7 @@ target_scsi3_pr_reservation_check(struct se_cmd *cmd)
         struct se_device *dev = cmd->se_dev;
         struct se_session *sess = cmd->se_sess;
         u32 pr_reg_type;
+        bool isid_mismatch = false;
 
         if (!dev->dev_pr_res_holder)
                 return 0;
@@ -584,7 +581,7 @@ target_scsi3_pr_reservation_check(struct se_cmd *cmd)
         if (dev->dev_pr_res_holder->isid_present_at_reg) {
                 if (dev->dev_pr_res_holder->pr_reg_bin_isid !=
                     sess->sess_bin_isid) {
-                        pr_reg_type |= 0x80000000;
+                        isid_mismatch = true;
                         goto check_nonholder;
                 }
         }
@@ -592,7 +589,7 @@ target_scsi3_pr_reservation_check(struct se_cmd *cmd)
         return 0;
 
 check_nonholder:
-        if (core_scsi3_pr_seq_non_holder(cmd, pr_reg_type))
+        if (core_scsi3_pr_seq_non_holder(cmd, pr_reg_type, isid_mismatch))
                 return TCM_RESERVATION_CONFLICT;
         return 0;
 }
@@ -620,7 +617,9 @@ static u32 core_scsi3_pr_generation(struct se_device *dev)
 static struct t10_pr_registration *__core_scsi3_do_alloc_registration(
         struct se_device *dev,
         struct se_node_acl *nacl,
+        struct se_lun *lun,
         struct se_dev_entry *deve,
+        u64 mapped_lun,
         unsigned char *isid,
         u64 sa_res_key,
         int all_tg_pt,
@@ -642,12 +641,12 @@ static struct t10_pr_registration *__core_scsi3_do_alloc_registration(
         atomic_set(&pr_reg->pr_res_holders, 0);
         pr_reg->pr_reg_nacl = nacl;
         pr_reg->pr_reg_deve = deve;
-        pr_reg->pr_res_mapped_lun = deve->mapped_lun;
-        pr_reg->pr_aptpl_target_lun = deve->se_lun->unpacked_lun;
+        pr_reg->pr_res_mapped_lun = mapped_lun;
+        pr_reg->pr_aptpl_target_lun = lun->unpacked_lun;
+        pr_reg->tg_pt_sep_rtpi = lun->lun_rtpi;
         pr_reg->pr_res_key = sa_res_key;
         pr_reg->pr_reg_all_tg_pt = all_tg_pt;
         pr_reg->pr_reg_aptpl = aptpl;
-        pr_reg->pr_reg_tg_pt_lun = deve->se_lun;
         /*
          * If an ISID value for this SCSI Initiator Port exists,
          * save it to the registration now.
@@ -671,7 +670,9 @@ static void core_scsi3_lunacl_undepend_item(struct se_dev_entry *);
 static struct t10_pr_registration *__core_scsi3_alloc_registration(
         struct se_device *dev,
         struct se_node_acl *nacl,
+        struct se_lun *lun,
         struct se_dev_entry *deve,
+        u64 mapped_lun,
         unsigned char *isid,
         u64 sa_res_key,
         int all_tg_pt,
@@ -679,7 +680,8 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
 {
         struct se_dev_entry *deve_tmp;
         struct se_node_acl *nacl_tmp;
-        struct se_port *port, *port_tmp;
+        struct se_lun_acl *lacl_tmp;
+        struct se_lun *lun_tmp, *next, *dest_lun;
         const struct target_core_fabric_ops *tfo = nacl->se_tpg->se_tpg_tfo;
         struct t10_pr_registration *pr_reg, *pr_reg_atp, *pr_reg_tmp, *pr_reg_tmp_safe;
         int ret;
@@ -687,8 +689,9 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
          * Create a registration for the I_T Nexus upon which the
          * PROUT REGISTER was received.
          */
-        pr_reg = __core_scsi3_do_alloc_registration(dev, nacl, deve, isid,
-                        sa_res_key, all_tg_pt, aptpl);
+        pr_reg = __core_scsi3_do_alloc_registration(dev, nacl, lun, deve, mapped_lun,
+                                                    isid, sa_res_key, all_tg_pt,
+                                                    aptpl);
         if (!pr_reg)
                 return NULL;
         /*
@@ -701,13 +704,13 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
          * for ALL_TG_PT=1
          */
         spin_lock(&dev->se_port_lock);
-        list_for_each_entry_safe(port, port_tmp, &dev->dev_sep_list, sep_list) {
-                atomic_inc_mb(&port->sep_tg_pt_ref_cnt);
+        list_for_each_entry_safe(lun_tmp, next, &dev->dev_sep_list, lun_dev_link) {
+                if (!percpu_ref_tryget_live(&lun_tmp->lun_ref))
+                        continue;
                 spin_unlock(&dev->se_port_lock);
 
-                spin_lock_bh(&port->sep_alua_lock);
-                list_for_each_entry(deve_tmp, &port->sep_alua_list,
-                                        alua_port_list) {
+                spin_lock(&lun_tmp->lun_deve_lock);
+                list_for_each_entry(deve_tmp, &lun_tmp->lun_deve_list, lun_link) {
                         /*
                          * This pointer will be NULL for demo mode MappedLUNs
                          * that have not been make explicit via a ConfigFS
@@ -716,7 +719,9 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
                         if (!deve_tmp->se_lun_acl)
                                 continue;
 
-                        nacl_tmp = deve_tmp->se_lun_acl->se_lun_nacl;
+                        lacl_tmp = rcu_dereference_check(deve_tmp->se_lun_acl,
+                                                lockdep_is_held(&lun_tmp->lun_deve_lock));
+                        nacl_tmp = lacl_tmp->se_lun_nacl;
                         /*
                          * Skip the matching struct se_node_acl that is allocated
                          * above..
@@ -736,8 +741,8 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
                         if (strcmp(nacl->initiatorname, nacl_tmp->initiatorname))
                                 continue;
 
-                        atomic_inc_mb(&deve_tmp->pr_ref_count);
-                        spin_unlock_bh(&port->sep_alua_lock);
+                        kref_get(&deve_tmp->pr_kref);
+                        spin_unlock(&lun_tmp->lun_deve_lock);
                         /*
                          * Grab a configfs group dependency that is released
                          * for the exception path at label out: below, or upon
@@ -748,8 +753,8 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
                         if (ret < 0) {
                                 pr_err("core_scsi3_lunacl_depend"
                                                 "_item() failed\n");
-                                atomic_dec_mb(&port->sep_tg_pt_ref_cnt);
-                                atomic_dec_mb(&deve_tmp->pr_ref_count);
+                                percpu_ref_put(&lun_tmp->lun_ref);
+                                kref_put(&deve_tmp->pr_kref, target_pr_kref_release);
                                 goto out;
                         }
                         /*
@@ -759,24 +764,27 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
                          * the original *pr_reg is processed in
                          * __core_scsi3_add_registration()
                          */
+                        dest_lun = rcu_dereference_check(deve_tmp->se_lun,
+                                atomic_read(&deve_tmp->pr_kref.refcount) != 0);
+
                         pr_reg_atp = __core_scsi3_do_alloc_registration(dev,
-                                                nacl_tmp, deve_tmp, NULL,
+                                                nacl_tmp, dest_lun, deve_tmp,
+                                                deve_tmp->mapped_lun, NULL,
                                                 sa_res_key, all_tg_pt, aptpl);
                         if (!pr_reg_atp) {
-                                atomic_dec_mb(&port->sep_tg_pt_ref_cnt);
-                                atomic_dec_mb(&deve_tmp->pr_ref_count);
+                                percpu_ref_put(&lun_tmp->lun_ref);
                                 core_scsi3_lunacl_undepend_item(deve_tmp);
                                 goto out;
                         }
 
                         list_add_tail(&pr_reg_atp->pr_reg_atp_mem_list,
                                       &pr_reg->pr_reg_atp_list);
-                        spin_lock_bh(&port->sep_alua_lock);
+                        spin_lock(&lun_tmp->lun_deve_lock);
                 }
-                spin_unlock_bh(&port->sep_alua_lock);
+                spin_unlock(&lun_tmp->lun_deve_lock);
 
                 spin_lock(&dev->se_port_lock);
-                atomic_dec_mb(&port->sep_tg_pt_ref_cnt);
+                percpu_ref_put(&lun_tmp->lun_ref);
         }
         spin_unlock(&dev->se_port_lock);
 
@@ -797,10 +805,10 @@ int core_scsi3_alloc_aptpl_registration(
         u64 sa_res_key,
         unsigned char *i_port,
         unsigned char *isid,
-        u32 mapped_lun,
+        u64 mapped_lun,
         unsigned char *t_port,
         u16 tpgt,
-        u32 target_lun,
+        u64 target_lun,
         int res_holder,
         int all_tg_pt,
         u8 type)
@@ -831,7 +839,6 @@ int core_scsi3_alloc_aptpl_registration(
         pr_reg->pr_res_key = sa_res_key;
         pr_reg->pr_reg_all_tg_pt = all_tg_pt;
         pr_reg->pr_reg_aptpl = 1;
-        pr_reg->pr_reg_tg_pt_lun = NULL;
         pr_reg->pr_res_scope = 0; /* Always LUN_SCOPE */
         pr_reg->pr_res_type = type;
         /*
@@ -895,9 +902,9 @@ static int __core_scsi3_check_aptpl_registration(
         struct se_device *dev,
         struct se_portal_group *tpg,
         struct se_lun *lun,
-        u32 target_lun,
+        u64 target_lun,
         struct se_node_acl *nacl,
-        struct se_dev_entry *deve)
+        u64 mapped_lun)
 {
         struct t10_pr_registration *pr_reg, *pr_reg_tmp;
         struct t10_reservation *pr_tmpl = &dev->t10_pr;
@@ -925,14 +932,13 @@ static int __core_scsi3_check_aptpl_registration(
                                 pr_reg_aptpl_list) {
 
                 if (!strcmp(pr_reg->pr_iport, i_port) &&
-                     (pr_reg->pr_res_mapped_lun == deve->mapped_lun) &&
+                     (pr_reg->pr_res_mapped_lun == mapped_lun) &&
                     !(strcmp(pr_reg->pr_tport, t_port)) &&
                      (pr_reg->pr_reg_tpgt == tpgt) &&
                      (pr_reg->pr_aptpl_target_lun == target_lun)) {
 
                         pr_reg->pr_reg_nacl = nacl;
-                        pr_reg->pr_reg_deve = deve;
-                        pr_reg->pr_reg_tg_pt_lun = lun;
+                        pr_reg->tg_pt_sep_rtpi = lun->lun_rtpi;
 
                         list_del(&pr_reg->pr_reg_aptpl_list);
                         spin_unlock(&pr_tmpl->aptpl_reg_lock);
@@ -967,15 +973,14 @@ int core_scsi3_check_aptpl_registration(
         struct se_portal_group *tpg,
         struct se_lun *lun,
         struct se_node_acl *nacl,
-        u32 mapped_lun)
+        u64 mapped_lun)
 {
-        struct se_dev_entry *deve = nacl->device_list[mapped_lun];
-
         if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
                 return 0;
 
         return __core_scsi3_check_aptpl_registration(dev, tpg, lun,
-                                lun->unpacked_lun, nacl, deve);
+                                                     lun->unpacked_lun, nacl,
+                                                     mapped_lun);
 }
 
 static void __core_scsi3_dump_registration(
@@ -1009,10 +1014,6 @@ static void __core_scsi3_dump_registration(
                 pr_reg->pr_reg_aptpl);
 }
 
-/*
- * this function can be called with struct se_device->dev_reservation_lock
- * when register_move = 1
- */
 static void __core_scsi3_add_registration(
         struct se_device *dev,
         struct se_node_acl *nacl,
@@ -1023,6 +1024,7 @@ static void __core_scsi3_add_registration(
         const struct target_core_fabric_ops *tfo = nacl->se_tpg->se_tpg_tfo;
         struct t10_pr_registration *pr_reg_tmp, *pr_reg_tmp_safe;
         struct t10_reservation *pr_tmpl = &dev->t10_pr;
+        struct se_dev_entry *deve;
 
         /*
          * Increment PRgeneration counter for struct se_device upon a successful
@@ -1039,10 +1041,16 @@ static void __core_scsi3_add_registration(
 
         spin_lock(&pr_tmpl->registration_lock);
         list_add_tail(&pr_reg->pr_reg_list, &pr_tmpl->registration_list);
-        pr_reg->pr_reg_deve->def_pr_registered = 1;
 
         __core_scsi3_dump_registration(tfo, dev, nacl, pr_reg, register_type);
         spin_unlock(&pr_tmpl->registration_lock);
+
+        rcu_read_lock();
+        deve = pr_reg->pr_reg_deve;
+        if (deve)
+                set_bit(DEF_PR_REG_ACTIVE, &deve->deve_flags);
+        rcu_read_unlock();
+
         /*
          * Skip extra processing for ALL_TG_PT=0 or REGISTER_AND_MOVE.
          */
@@ -1054,6 +1062,8 @@ static void __core_scsi3_add_registration(
          */
         list_for_each_entry_safe(pr_reg_tmp, pr_reg_tmp_safe,
                         &pr_reg->pr_reg_atp_list, pr_reg_atp_mem_list) {
+                struct se_node_acl *nacl_tmp = pr_reg_tmp->pr_reg_nacl;
+
                 list_del(&pr_reg_tmp->pr_reg_atp_mem_list);
 
                 pr_reg_tmp->pr_res_generation = core_scsi3_pr_generation(dev);
@@ -1061,12 +1071,17 @@ static void __core_scsi3_add_registration(
                 spin_lock(&pr_tmpl->registration_lock);
                 list_add_tail(&pr_reg_tmp->pr_reg_list,
                               &pr_tmpl->registration_list);
-                pr_reg_tmp->pr_reg_deve->def_pr_registered = 1;
 
-                __core_scsi3_dump_registration(tfo, dev,
-                                pr_reg_tmp->pr_reg_nacl, pr_reg_tmp,
-                                register_type);
+                __core_scsi3_dump_registration(tfo, dev, nacl_tmp, pr_reg_tmp,
+                                               register_type);
                 spin_unlock(&pr_tmpl->registration_lock);
+
+                rcu_read_lock();
+                deve = pr_reg_tmp->pr_reg_deve;
+                if (deve)
+                        set_bit(DEF_PR_REG_ACTIVE, &deve->deve_flags);
+                rcu_read_unlock();
+
                 /*
                  * Drop configfs group dependency reference from
                  * __core_scsi3_alloc_registration()
@@ -1078,7 +1093,9 @@ static void __core_scsi3_add_registration(
 static int core_scsi3_alloc_registration(
         struct se_device *dev,
         struct se_node_acl *nacl,
+        struct se_lun *lun,
         struct se_dev_entry *deve,
+        u64 mapped_lun,
         unsigned char *isid,
         u64 sa_res_key,
         int all_tg_pt,
@@ -1088,8 +1105,9 @@ static int core_scsi3_alloc_registration(
 {
         struct t10_pr_registration *pr_reg;
 
-        pr_reg = __core_scsi3_alloc_registration(dev, nacl, deve, isid,
-                        sa_res_key, all_tg_pt, aptpl);
+        pr_reg = __core_scsi3_alloc_registration(dev, nacl, lun, deve, mapped_lun,
+                                                 isid, sa_res_key, all_tg_pt,
+                                                 aptpl);
         if (!pr_reg)
                 return -EPERM;
 
@@ -1242,13 +1260,13 @@ static void __core_scsi3_free_registration(
         const struct target_core_fabric_ops *tfo =
                         pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo;
         struct t10_reservation *pr_tmpl = &dev->t10_pr;
+        struct se_node_acl *nacl = pr_reg->pr_reg_nacl;
+        struct se_dev_entry *deve;
         char i_buf[PR_REG_ISID_ID_LEN];
 
         memset(i_buf, 0, PR_REG_ISID_ID_LEN);
         core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
 
-        pr_reg->pr_reg_deve->def_pr_registered = 0;
-        pr_reg->pr_reg_deve->pr_res_key = 0;
         if (!list_empty(&pr_reg->pr_reg_list))
                 list_del(&pr_reg->pr_reg_list);
         /*
@@ -1257,6 +1275,8 @@ static void __core_scsi3_free_registration(
          */
         if (dec_holders)
                 core_scsi3_put_pr_reg(pr_reg);
+
+        spin_unlock(&pr_tmpl->registration_lock);
         /*
          * Wait until all reference from any other I_T nexuses for this
          * *pr_reg have been released.  Because list_del() is called above,
@@ -1264,13 +1284,18 @@ static void __core_scsi3_free_registration(
          * count back to zero, and we release *pr_reg.
          */
         while (atomic_read(&pr_reg->pr_res_holders) != 0) {
-                spin_unlock(&pr_tmpl->registration_lock);
                 pr_debug("SPC-3 PR [%s] waiting for pr_res_holders\n",
                                 tfo->get_fabric_name());
                 cpu_relax();
-                spin_lock(&pr_tmpl->registration_lock);
         }
 
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, pr_reg->pr_res_mapped_lun);
+        if (deve)
+                clear_bit(DEF_PR_REG_ACTIVE, &deve->deve_flags);
+        rcu_read_unlock();
+
+        spin_lock(&pr_tmpl->registration_lock);
         pr_debug("SPC-3 PR [%s] Service Action: UNREGISTER Initiator"
                 " Node: %s%s\n", tfo->get_fabric_name(),
                 pr_reg->pr_reg_nacl->initiatorname,
@@ -1392,12 +1417,14 @@ static void core_scsi3_nodeacl_undepend_item(struct se_node_acl *nacl)
 
 static int core_scsi3_lunacl_depend_item(struct se_dev_entry *se_deve)
 {
-        struct se_lun_acl *lun_acl = se_deve->se_lun_acl;
+        struct se_lun_acl *lun_acl;
         struct se_node_acl *nacl;
         struct se_portal_group *tpg;
         /*
          * For nacl->dynamic_node_acl=1
          */
+        lun_acl = rcu_dereference_check(se_deve->se_lun_acl,
+                                atomic_read(&se_deve->pr_kref.refcount) != 0);
         if (!lun_acl)
                 return 0;
 
@@ -1409,21 +1436,23 @@ static int core_scsi3_lunacl_depend_item(struct se_dev_entry *se_deve)
 
 static void core_scsi3_lunacl_undepend_item(struct se_dev_entry *se_deve)
 {
-        struct se_lun_acl *lun_acl = se_deve->se_lun_acl;
+        struct se_lun_acl *lun_acl;
         struct se_node_acl *nacl;
         struct se_portal_group *tpg;
         /*
          * For nacl->dynamic_node_acl=1
          */
+        lun_acl = rcu_dereference_check(se_deve->se_lun_acl,
+                                atomic_read(&se_deve->pr_kref.refcount) != 0);
         if (!lun_acl) {
-                atomic_dec_mb(&se_deve->pr_ref_count);
+                kref_put(&se_deve->pr_kref, target_pr_kref_release);
                 return;
         }
         nacl = lun_acl->se_lun_nacl;
         tpg = nacl->se_tpg;
 
         target_undepend_item(&lun_acl->se_lun_group.cg_item);
-        atomic_dec_mb(&se_deve->pr_ref_count);
+        kref_put(&se_deve->pr_kref, target_pr_kref_release);
 }
 
 static sense_reason_t
@@ -1436,30 +1465,25 @@ core_scsi3_decode_spec_i_port(
         int aptpl)
 {
         struct se_device *dev = cmd->se_dev;
-        struct se_port *tmp_port;
         struct se_portal_group *dest_tpg = NULL, *tmp_tpg;
         struct se_session *se_sess = cmd->se_sess;
         struct se_node_acl *dest_node_acl = NULL;
-        struct se_dev_entry *dest_se_deve = NULL, *local_se_deve;
+        struct se_dev_entry *dest_se_deve = NULL;
         struct t10_pr_registration *dest_pr_reg, *local_pr_reg, *pr_reg_e;
         struct t10_pr_registration *pr_reg_tmp, *pr_reg_tmp_safe;
         LIST_HEAD(tid_dest_list);
         struct pr_transport_id_holder *tidh_new, *tidh, *tidh_tmp;
-        const struct target_core_fabric_ops *tmp_tf_ops;
-        unsigned char *buf;
-        unsigned char *ptr, *i_str = NULL, proto_ident, tmp_proto_ident;
+        unsigned char *buf, *ptr, proto_ident;
+        const unsigned char *i_str;
         char *iport_ptr = NULL, i_buf[PR_REG_ISID_ID_LEN];
         sense_reason_t ret;
         u32 tpdl, tid_len = 0;
-        int dest_local_nexus;
         u32 dest_rtpi = 0;
 
-        local_se_deve = se_sess->se_node_acl->device_list[cmd->orig_fe_lun];
         /*
          * Allocate a struct pr_transport_id_holder and setup the
-         * local_node_acl and local_se_deve pointers and add to
-         * struct list_head tid_dest_list for add registration
-         * processing in the loop of tid_dest_list below.
+         * local_node_acl pointer and add to struct list_head tid_dest_list
+         * for add registration processing in the loop of tid_dest_list below.
          */
         tidh_new = kzalloc(sizeof(struct pr_transport_id_holder), GFP_KERNEL);
         if (!tidh_new) {
@@ -1469,10 +1493,10 @@ core_scsi3_decode_spec_i_port(
         INIT_LIST_HEAD(&tidh_new->dest_list);
         tidh_new->dest_tpg = tpg;
         tidh_new->dest_node_acl = se_sess->se_node_acl;
-        tidh_new->dest_se_deve = local_se_deve;
 
         local_pr_reg = __core_scsi3_alloc_registration(cmd->se_dev,
-                                se_sess->se_node_acl, local_se_deve, l_isid,
+                                se_sess->se_node_acl, cmd->se_lun,
+                                NULL, cmd->orig_fe_lun, l_isid,
                                 sa_res_key, all_tg_pt, aptpl);
         if (!local_pr_reg) {
                 kfree(tidh_new);
@@ -1481,10 +1505,10 @@ core_scsi3_decode_spec_i_port(
         tidh_new->dest_pr_reg = local_pr_reg;
         /*
          * The local I_T nexus does not hold any configfs dependances,
-         * so we set tid_h->dest_local_nexus=1 to prevent the
+         * so we set tidh_new->dest_se_deve to NULL to prevent the
          * configfs_undepend_item() calls in the tid_dest_list loops below.
          */
-        tidh_new->dest_local_nexus = 1;
+        tidh_new->dest_se_deve = NULL;
         list_add_tail(&tidh_new->dest_list, &tid_dest_list);
 
         if (cmd->data_length < 28) {
@@ -1525,32 +1549,25 @@ core_scsi3_decode_spec_i_port(
         ptr = &buf[28];
 
         while (tpdl > 0) {
+                struct se_lun *dest_lun, *tmp_lun;
+
                 proto_ident = (ptr[0] & 0x0f);
                 dest_tpg = NULL;
 
                 spin_lock(&dev->se_port_lock);
-                list_for_each_entry(tmp_port, &dev->dev_sep_list, sep_list) {
-                        tmp_tpg = tmp_port->sep_tpg;
-                        if (!tmp_tpg)
-                                continue;
-                        tmp_tf_ops = tmp_tpg->se_tpg_tfo;
-                        if (!tmp_tf_ops)
-                                continue;
-                        if (!tmp_tf_ops->get_fabric_proto_ident ||
-                            !tmp_tf_ops->tpg_parse_pr_out_transport_id)
-                                continue;
+                list_for_each_entry(tmp_lun, &dev->dev_sep_list, lun_dev_link) {
+                        tmp_tpg = tmp_lun->lun_tpg;
+
                         /*
                          * Look for the matching proto_ident provided by
                          * the received TransportID
                          */
-                        tmp_proto_ident = tmp_tf_ops->get_fabric_proto_ident(tmp_tpg);
-                        if (tmp_proto_ident != proto_ident)
+                        if (tmp_tpg->proto_id != proto_ident)
                                 continue;
-                        dest_rtpi = tmp_port->sep_rtpi;
+                        dest_rtpi = tmp_lun->lun_rtpi;
 
-                        i_str = tmp_tf_ops->tpg_parse_pr_out_transport_id(
-                                        tmp_tpg, (const char *)ptr, &tid_len,
-                                        &iport_ptr);
+                        i_str = target_parse_pr_out_transport_id(tmp_tpg,
+                                        (const char *)ptr, &tid_len, &iport_ptr);
                         if (!i_str)
                                 continue;
 
@@ -1569,12 +1586,12 @@ core_scsi3_decode_spec_i_port(
                          * from the decoded fabric module specific TransportID
                          * at *i_str.
                          */
-                        spin_lock_irq(&tmp_tpg->acl_node_lock);
+                        mutex_lock(&tmp_tpg->acl_node_mutex);
                         dest_node_acl = __core_tpg_get_initiator_node_acl(
                                                 tmp_tpg, i_str);
                         if (dest_node_acl)
                                 atomic_inc_mb(&dest_node_acl->acl_pr_ref_count);
-                        spin_unlock_irq(&tmp_tpg->acl_node_lock);
+                        mutex_unlock(&tmp_tpg->acl_node_mutex);
 
                         if (!dest_node_acl) {
                                 core_scsi3_tpg_undepend_item(tmp_tpg);
@@ -1644,7 +1661,7 @@ core_scsi3_decode_spec_i_port(
                 if (core_scsi3_lunacl_depend_item(dest_se_deve)) {
                         pr_err("core_scsi3_lunacl_depend_item()"
                                         " failed\n");
-                        atomic_dec_mb(&dest_se_deve->pr_ref_count);
+                        kref_put(&dest_se_deve->pr_kref, target_pr_kref_release);
                         core_scsi3_nodeacl_undepend_item(dest_node_acl);
                         core_scsi3_tpg_undepend_item(dest_tpg);
                         ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
@@ -1652,7 +1669,7 @@ core_scsi3_decode_spec_i_port(
                 }
 
                 pr_debug("SPC-3 PR SPEC_I_PT: Located %s Node: %s"
-                        " dest_se_deve mapped_lun: %u\n",
+                        " dest_se_deve mapped_lun: %llu\n",
                         dest_tpg->se_tpg_tfo->get_fabric_name(),
                         dest_node_acl->initiatorname, dest_se_deve->mapped_lun);
 
@@ -1708,9 +1725,13 @@ core_scsi3_decode_spec_i_port(
                  * and then call __core_scsi3_add_registration() in the
                  * 2nd loop which will never fail.
                  */
+                dest_lun = rcu_dereference_check(dest_se_deve->se_lun,
+                                atomic_read(&dest_se_deve->pr_kref.refcount) != 0);
+
                 dest_pr_reg = __core_scsi3_alloc_registration(cmd->se_dev,
-                                dest_node_acl, dest_se_deve, iport_ptr,
-                                sa_res_key, all_tg_pt, aptpl);
+                                        dest_node_acl, dest_lun, dest_se_deve,
+                                        dest_se_deve->mapped_lun, iport_ptr,
+                                        sa_res_key, all_tg_pt, aptpl);
                 if (!dest_pr_reg) {
                         core_scsi3_lunacl_undepend_item(dest_se_deve);
                         core_scsi3_nodeacl_undepend_item(dest_node_acl);
@@ -1748,7 +1769,6 @@ core_scsi3_decode_spec_i_port(
                 dest_node_acl = tidh->dest_node_acl;
                 dest_se_deve = tidh->dest_se_deve;
                 dest_pr_reg = tidh->dest_pr_reg;
-                dest_local_nexus = tidh->dest_local_nexus;
 
                 list_del(&tidh->dest_list);
                 kfree(tidh);
@@ -1761,10 +1781,11 @@ core_scsi3_decode_spec_i_port(
 
                 pr_debug("SPC-3 PR [%s] SPEC_I_PT: Successfully"
                         " registered Transport ID for Node: %s%s Mapped LUN:"
-                        " %u\n", dest_tpg->se_tpg_tfo->get_fabric_name(),
-                        dest_node_acl->initiatorname, i_buf, dest_se_deve->mapped_lun);
+                        " %llu\n", dest_tpg->se_tpg_tfo->get_fabric_name(),
+                        dest_node_acl->initiatorname, i_buf, (dest_se_deve) ?
+                        dest_se_deve->mapped_lun : 0);
 
-                if (dest_local_nexus)
+                if (!dest_se_deve)
                         continue;
 
                 core_scsi3_lunacl_undepend_item(dest_se_deve);
@@ -1785,7 +1806,6 @@ out:
                 dest_node_acl = tidh->dest_node_acl;
                 dest_se_deve = tidh->dest_se_deve;
                 dest_pr_reg = tidh->dest_pr_reg;
-                dest_local_nexus = tidh->dest_local_nexus;
 
                 list_del(&tidh->dest_list);
                 kfree(tidh);
@@ -1803,7 +1823,7 @@ out:
 
                 kmem_cache_free(t10_pr_reg_cache, dest_pr_reg);
 
-                if (dest_local_nexus)
+                if (!dest_se_deve)
                         continue;
 
                 core_scsi3_lunacl_undepend_item(dest_se_deve);
@@ -1818,7 +1838,6 @@ static int core_scsi3_update_aptpl_buf(
         unsigned char *buf,
         u32 pr_aptpl_buf_len)
 {
-        struct se_lun *lun;
         struct se_portal_group *tpg;
         struct t10_pr_registration *pr_reg;
         unsigned char tmp[512], isid_buf[32];
@@ -1837,7 +1856,6 @@ static int core_scsi3_update_aptpl_buf(
                 tmp[0] = '\0';
                 isid_buf[0] = '\0';
                 tpg = pr_reg->pr_reg_nacl->se_tpg;
-                lun = pr_reg->pr_reg_tg_pt_lun;
                 /*
                  * Write out any ISID value to APTPL metadata that was included
                  * in the original registration.
@@ -1856,7 +1874,7 @@ static int core_scsi3_update_aptpl_buf(
                                 "sa_res_key=%llu\n"
                                 "res_holder=1\nres_type=%02x\n"
                                 "res_scope=%02x\nres_all_tg_pt=%d\n"
-                                "mapped_lun=%u\n", reg_count,
+                                "mapped_lun=%llu\n", reg_count,
                                 tpg->se_tpg_tfo->get_fabric_name(),
                                 pr_reg->pr_reg_nacl->initiatorname, isid_buf,
                                 pr_reg->pr_res_key, pr_reg->pr_res_type,
@@ -1866,7 +1884,7 @@ static int core_scsi3_update_aptpl_buf(
                         snprintf(tmp, 512, "PR_REG_START: %d\n"
                                 "initiator_fabric=%s\ninitiator_node=%s\n%s"
                                 "sa_res_key=%llu\nres_holder=0\n"
-                                "res_all_tg_pt=%d\nmapped_lun=%u\n",
+                                "res_all_tg_pt=%d\nmapped_lun=%llu\n",
                                 reg_count, tpg->se_tpg_tfo->get_fabric_name(),
                                 pr_reg->pr_reg_nacl->initiatorname, isid_buf,
                                 pr_reg->pr_res_key, pr_reg->pr_reg_all_tg_pt,
@@ -1885,11 +1903,12 @@ static int core_scsi3_update_aptpl_buf(
                  * Include information about the associated SCSI target port.
                  */
                 snprintf(tmp, 512, "target_fabric=%s\ntarget_node=%s\n"
-                        "tpgt=%hu\nport_rtpi=%hu\ntarget_lun=%u\nPR_REG_END:"
+                        "tpgt=%hu\nport_rtpi=%hu\ntarget_lun=%llu\nPR_REG_END:"
                         " %d\n", tpg->se_tpg_tfo->get_fabric_name(),
                         tpg->se_tpg_tfo->tpg_get_wwn(tpg),
                         tpg->se_tpg_tfo->tpg_get_tag(tpg),
-                        lun->lun_sep->sep_rtpi, lun->unpacked_lun, reg_count);
+                        pr_reg->tg_pt_sep_rtpi, pr_reg->pr_aptpl_target_lun,
+                        reg_count);
 
                 if ((len + strlen(tmp) >= pr_aptpl_buf_len)) {
                         pr_err("Unable to update renaming APTPL metadata,"
@@ -2000,7 +2019,6 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
 {
         struct se_session *se_sess = cmd->se_sess;
         struct se_device *dev = cmd->se_dev;
-        struct se_dev_entry *se_deve;
         struct se_lun *se_lun = cmd->se_lun;
         struct se_portal_group *se_tpg;
         struct t10_pr_registration *pr_reg, *pr_reg_p, *pr_reg_tmp;
@@ -2014,7 +2032,6 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
         }
         se_tpg = se_sess->se_tpg;
-        se_deve = se_sess->se_node_acl->device_list[cmd->orig_fe_lun];
 
         if (se_tpg->se_tpg_tfo->sess_get_initiator_sid) {
                 memset(&isid_buf[0], 0, PR_REG_ISID_LEN);
@@ -2045,7 +2062,8 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
                          * Logical Unit of the SCSI device server.
                          */
                         if (core_scsi3_alloc_registration(cmd->se_dev,
-                                        se_sess->se_node_acl, se_deve, isid_ptr,
+                                        se_sess->se_node_acl, cmd->se_lun,
+                                        NULL, cmd->orig_fe_lun, isid_ptr,
                                         sa_res_key, all_tg_pt, aptpl,
                                         register_type, 0)) {
                                 pr_err("Unable to allocate"
@@ -2066,7 +2084,6 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
                         if (ret != 0)
                                 return ret;
                 }
-
                 return core_scsi3_update_and_write_aptpl(dev, aptpl);
         }
 
@@ -2180,7 +2197,7 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
                                         &pr_tmpl->registration_list,
                                         pr_reg_list) {
 
-                                core_scsi3_ua_allocate(
+                                target_ua_allocate_lun(
                                         pr_reg_p->pr_reg_nacl,
                                         pr_reg_p->pr_res_mapped_lun,
                                         0x2A,
@@ -2607,7 +2624,7 @@ core_scsi3_emulate_pro_release(struct se_cmd *cmd, int type, int scope,
                 if (pr_reg_p == pr_reg)
                         continue;
 
-                core_scsi3_ua_allocate(pr_reg_p->pr_reg_nacl,
+                target_ua_allocate_lun(pr_reg_p->pr_reg_nacl,
                                 pr_reg_p->pr_res_mapped_lun,
                                 0x2A, ASCQ_2AH_RESERVATIONS_RELEASED);
         }
@@ -2630,7 +2647,7 @@ core_scsi3_emulate_pro_clear(struct se_cmd *cmd, u64 res_key)
         struct se_session *se_sess = cmd->se_sess;
         struct t10_reservation *pr_tmpl = &dev->t10_pr;
         struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_reg_n, *pr_res_holder;
-        u32 pr_res_mapped_lun = 0;
+        u64 pr_res_mapped_lun = 0;
         int calling_it_nexus = 0;
         /*
          * Locate the existing *pr_reg via struct se_node_acl pointers
@@ -2692,7 +2709,7 @@ core_scsi3_emulate_pro_clear(struct se_cmd *cmd, u64 res_key)
                  *    additional sense code set to RESERVATIONS PREEMPTED.
                  */
                 if (!calling_it_nexus)
-                        core_scsi3_ua_allocate(pr_reg_nacl, pr_res_mapped_lun,
+                        target_ua_allocate_lun(pr_reg_nacl, pr_res_mapped_lun,
                                 0x2A, ASCQ_2AH_RESERVATIONS_PREEMPTED);
         }
         spin_unlock(&pr_tmpl->registration_lock);
@@ -2786,7 +2803,7 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
         LIST_HEAD(preempt_and_abort_list);
         struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_reg_n, *pr_res_holder;
         struct t10_reservation *pr_tmpl = &dev->t10_pr;
-        u32 pr_res_mapped_lun = 0;
+        u64 pr_res_mapped_lun = 0;
         int all_reg = 0, calling_it_nexus = 0;
         bool sa_res_key_unmatched = sa_res_key != 0;
         int prh_type = 0, prh_scope = 0;
@@ -2901,7 +2918,7 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
                                                 NULL, 0);
                         }
                         if (!calling_it_nexus)
-                                core_scsi3_ua_allocate(pr_reg_nacl,
+                                target_ua_allocate_lun(pr_reg_nacl,
                                         pr_res_mapped_lun, 0x2A,
                                         ASCQ_2AH_REGISTRATIONS_PREEMPTED);
                 }
@@ -3007,7 +3024,7 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
                  *    persistent reservation and/or registration, with the
                  *    additional sense code set to REGISTRATIONS PREEMPTED;
                  */
-                core_scsi3_ua_allocate(pr_reg_nacl, pr_res_mapped_lun, 0x2A,
+                target_ua_allocate_lun(pr_reg_nacl, pr_res_mapped_lun, 0x2A,
                                 ASCQ_2AH_REGISTRATIONS_PREEMPTED);
         }
         spin_unlock(&pr_tmpl->registration_lock);
@@ -3040,7 +3057,7 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
                         if (calling_it_nexus)
                                 continue;
 
-                        core_scsi3_ua_allocate(pr_reg->pr_reg_nacl,
+                        target_ua_allocate_lun(pr_reg->pr_reg_nacl,
                                         pr_reg->pr_res_mapped_lun, 0x2A,
                                         ASCQ_2AH_RESERVATIONS_RELEASED);
                 }
@@ -3099,15 +3116,14 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
         struct se_session *se_sess = cmd->se_sess;
         struct se_device *dev = cmd->se_dev;
         struct se_dev_entry *dest_se_deve = NULL;
-        struct se_lun *se_lun = cmd->se_lun;
+        struct se_lun *se_lun = cmd->se_lun, *tmp_lun;
         struct se_node_acl *pr_res_nacl, *pr_reg_nacl, *dest_node_acl = NULL;
-        struct se_port *se_port;
         struct se_portal_group *se_tpg, *dest_se_tpg = NULL;
         const struct target_core_fabric_ops *dest_tf_ops = NULL, *tf_ops;
         struct t10_pr_registration *pr_reg, *pr_res_holder, *dest_pr_reg;
         struct t10_reservation *pr_tmpl = &dev->t10_pr;
         unsigned char *buf;
-        unsigned char *initiator_str;
+        const unsigned char *initiator_str;
         char *iport_ptr = NULL, i_buf[PR_REG_ISID_ID_LEN];
         u32 tid_len, tmp_tid_len;
         int new_reg = 0, type, scope, matching_iname;
@@ -3186,12 +3202,10 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
         }
 
         spin_lock(&dev->se_port_lock);
-        list_for_each_entry(se_port, &dev->dev_sep_list, sep_list) {
-                if (se_port->sep_rtpi != rtpi)
-                        continue;
-                dest_se_tpg = se_port->sep_tpg;
-                if (!dest_se_tpg)
+        list_for_each_entry(tmp_lun, &dev->dev_sep_list, lun_dev_link) {
+                if (tmp_lun->lun_rtpi != rtpi)
                         continue;
+                dest_se_tpg = tmp_lun->lun_tpg;
                 dest_tf_ops = dest_se_tpg->se_tpg_tfo;
                 if (!dest_tf_ops)
                         continue;
@@ -3230,23 +3244,16 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
         pr_debug("SPC-3 PR REGISTER_AND_MOVE: Extracted Protocol Identifier:"
                         " 0x%02x\n", proto_ident);
 
-        if (proto_ident != dest_tf_ops->get_fabric_proto_ident(dest_se_tpg)) {
+        if (proto_ident != dest_se_tpg->proto_id) {
                 pr_err("SPC-3 PR REGISTER_AND_MOVE: Received"
                         " proto_ident: 0x%02x does not match ident: 0x%02x"
                         " from fabric: %s\n", proto_ident,
-                        dest_tf_ops->get_fabric_proto_ident(dest_se_tpg),
+                        dest_se_tpg->proto_id,
                         dest_tf_ops->get_fabric_name());
                 ret = TCM_INVALID_PARAMETER_LIST;
                 goto out;
         }
-        if (dest_tf_ops->tpg_parse_pr_out_transport_id == NULL) {
-                pr_err("SPC-3 PR REGISTER_AND_MOVE: Fabric does not"
-                        " containg a valid tpg_parse_pr_out_transport_id"
-                        " function pointer\n");
-                ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
-                goto out;
-        }
-        initiator_str = dest_tf_ops->tpg_parse_pr_out_transport_id(dest_se_tpg,
+        initiator_str = target_parse_pr_out_transport_id(dest_se_tpg,
                         (const char *)&buf[24], &tmp_tid_len, &iport_ptr);
         if (!initiator_str) {
                 pr_err("SPC-3 PR REGISTER_AND_MOVE: Unable to locate"
@@ -3295,12 +3302,12 @@ after_iport_check:
         /*
          * Locate the destination struct se_node_acl from the received Transport ID
          */
-        spin_lock_irq(&dest_se_tpg->acl_node_lock);
+        mutex_lock(&dest_se_tpg->acl_node_mutex);
         dest_node_acl = __core_tpg_get_initiator_node_acl(dest_se_tpg,
                                 initiator_str);
         if (dest_node_acl)
                 atomic_inc_mb(&dest_node_acl->acl_pr_ref_count);
-        spin_unlock_irq(&dest_se_tpg->acl_node_lock);
+        mutex_unlock(&dest_se_tpg->acl_node_mutex);
 
         if (!dest_node_acl) {
                 pr_err("Unable to locate %s dest_node_acl for"
@@ -3337,14 +3344,14 @@ after_iport_check:
 
         if (core_scsi3_lunacl_depend_item(dest_se_deve)) {
                 pr_err("core_scsi3_lunacl_depend_item() failed\n");
-                atomic_dec_mb(&dest_se_deve->pr_ref_count);
+                kref_put(&dest_se_deve->pr_kref, target_pr_kref_release);
                 dest_se_deve = NULL;
                 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
                 goto out;
         }
 
         pr_debug("SPC-3 PR REGISTER_AND_MOVE: Located %s node %s LUN"
-                " ACL for dest_se_deve->mapped_lun: %u\n",
+                " ACL for dest_se_deve->mapped_lun: %llu\n",
                 dest_tf_ops->get_fabric_name(), dest_node_acl->initiatorname,
                 dest_se_deve->mapped_lun);
 
@@ -3421,13 +3428,17 @@ after_iport_check:
         dest_pr_reg = __core_scsi3_locate_pr_reg(dev, dest_node_acl,
                                         iport_ptr);
         if (!dest_pr_reg) {
-                if (core_scsi3_alloc_registration(cmd->se_dev,
-                                dest_node_acl, dest_se_deve, iport_ptr,
-                                sa_res_key, 0, aptpl, 2, 1)) {
-                        spin_unlock(&dev->dev_reservation_lock);
+                struct se_lun *dest_lun = rcu_dereference_check(dest_se_deve->se_lun,
+                                atomic_read(&dest_se_deve->pr_kref.refcount) != 0);
+
+                spin_unlock(&dev->dev_reservation_lock);
+                if (core_scsi3_alloc_registration(cmd->se_dev, dest_node_acl,
+                                        dest_lun, dest_se_deve, dest_se_deve->mapped_lun,
+                                        iport_ptr, sa_res_key, 0, aptpl, 2, 1)) {
                         ret = TCM_INVALID_PARAMETER_LIST;
                         goto out;
                 }
+                spin_lock(&dev->dev_reservation_lock);
                 dest_pr_reg = __core_scsi3_locate_pr_reg(dev, dest_node_acl,
                                                 iport_ptr);
                 new_reg = 1;
@@ -3883,9 +3894,10 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
         struct t10_pr_registration *pr_reg, *pr_reg_tmp;
         struct t10_reservation *pr_tmpl = &dev->t10_pr;
         unsigned char *buf;
-        u32 add_desc_len = 0, add_len = 0, desc_len, exp_desc_len;
+        u32 add_desc_len = 0, add_len = 0;
         u32 off = 8; /* off into first Full Status descriptor */
         int format_code = 0, pr_res_type = 0, pr_res_scope = 0;
+        int exp_desc_len, desc_len;
         bool all_reg = false;
 
         if (cmd->data_length < 8) {
@@ -3930,10 +3942,10 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
                  * Determine expected length of $FABRIC_MOD specific
                  * TransportID full status descriptor..
                  */
-                exp_desc_len = se_tpg->se_tpg_tfo->tpg_get_pr_transport_id_len(
-                                se_tpg, se_nacl, pr_reg, &format_code);
-
-                if ((exp_desc_len + add_len) > cmd->data_length) {
+                exp_desc_len = target_get_pr_transport_id_len(se_nacl, pr_reg,
+                                        &format_code);
+                if (exp_desc_len < 0 ||
+                    exp_desc_len + add_len > cmd->data_length) {
                         pr_warn("SPC-3 PRIN READ_FULL_STATUS ran"
                                 " out of buffer: %d\n", cmd->data_length);
                         spin_lock(&pr_tmpl->registration_lock);
@@ -3990,21 +4002,26 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
                  * IDENTIFIER field are not defined by this standard.
                  */
                 if (!pr_reg->pr_reg_all_tg_pt) {
-                        struct se_port *port = pr_reg->pr_reg_tg_pt_lun->lun_sep;
+                        u16 sep_rtpi = pr_reg->tg_pt_sep_rtpi;
 
-                        buf[off++] = ((port->sep_rtpi >> 8) & 0xff);
-                        buf[off++] = (port->sep_rtpi & 0xff);
+                        buf[off++] = ((sep_rtpi >> 8) & 0xff);
+                        buf[off++] = (sep_rtpi & 0xff);
                 } else
                         off += 2; /* Skip over RELATIVE TARGET PORT IDENTIFIER */
 
+                buf[off+4] = se_tpg->proto_id;
+
                 /*
-                 * Now, have the $FABRIC_MOD fill in the protocol identifier
+                 * Now, have the $FABRIC_MOD fill in the transport ID.
                  */
-                desc_len = se_tpg->se_tpg_tfo->tpg_get_pr_transport_id(se_tpg,
-                                se_nacl, pr_reg, &format_code, &buf[off+4]);
+                desc_len = target_get_pr_transport_id(se_nacl, pr_reg,
+                                &format_code, &buf[off+4]);
 
                 spin_lock(&pr_tmpl->registration_lock);
                 atomic_dec_mb(&pr_reg->pr_res_holders);
+
+                if (desc_len < 0)
+                        break;
                 /*
                  * Set the ADDITIONAL DESCRIPTOR LENGTH
                  */
diff --git a/drivers/target/target_core_pr.h b/drivers/target/target_core_pr.h
index 749fd7bb7510..e3d26e9126a0 100644
--- a/drivers/target/target_core_pr.h
+++ b/drivers/target/target_core_pr.h
@@ -56,11 +56,11 @@ extern sense_reason_t target_scsi2_reservation_release(struct se_cmd *);
 extern sense_reason_t target_scsi2_reservation_reserve(struct se_cmd *);
 extern int core_scsi3_alloc_aptpl_registration(
                         struct t10_reservation *, u64,
-                        unsigned char *, unsigned char *, u32,
-                        unsigned char *, u16, u32, int, int, u8);
+                        unsigned char *, unsigned char *, u64,
+                        unsigned char *, u16, u64, int, int, u8);
 extern int core_scsi3_check_aptpl_registration(struct se_device *,
                         struct se_portal_group *, struct se_lun *,
-                        struct se_node_acl *, u32);
+                        struct se_node_acl *, u64);
 extern void core_scsi3_free_pr_reg_from_nacl(struct se_device *,
                                              struct se_node_acl *);
 extern void core_scsi3_free_all_registrations(struct se_device *);
diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c
index 26581e215141..08e9084ee615 100644
--- a/drivers/target/target_core_pscsi.c
+++ b/drivers/target/target_core_pscsi.c
@@ -42,9 +42,9 @@
 
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
-#include <target/target_core_backend_configfs.h>
 
 #include "target_core_alua.h"
+#include "target_core_internal.h"
 #include "target_core_pscsi.h"
 
 #define ISPRINT(a)  ((a >= ' ') && (a <= '~'))
@@ -54,8 +54,6 @@ static inline struct pscsi_dev_virt *PSCSI_DEV(struct se_device *dev)
         return container_of(dev, struct pscsi_dev_virt, dev);
 }
 
-static struct se_subsystem_api pscsi_template;
-
 static sense_reason_t pscsi_execute_cmd(struct se_cmd *cmd);
 static void pscsi_req_done(struct request *, int);
 
@@ -80,7 +78,7 @@ static int pscsi_attach_hba(struct se_hba *hba, u32 host_id)
 
         pr_debug("CORE_HBA[%d] - TCM SCSI HBA Driver %s on"
                 " Generic Target Core Stack %s\n", hba->hba_id,
-                PSCSI_VERSION, TARGET_CORE_MOD_VERSION);
+                PSCSI_VERSION, TARGET_CORE_VERSION);
         pr_debug("CORE_HBA[%d] - Attached SCSI HBA to Generic\n",
                hba->hba_id);
 
@@ -579,6 +577,14 @@ static int pscsi_configure_device(struct se_device *dev)
         return -ENODEV;
 }
 
+static void pscsi_dev_call_rcu(struct rcu_head *p)
+{
+        struct se_device *dev = container_of(p, struct se_device, rcu_head);
+        struct pscsi_dev_virt *pdv = PSCSI_DEV(dev);
+
+        kfree(pdv);
+}
+
 static void pscsi_free_device(struct se_device *dev)
 {
         struct pscsi_dev_virt *pdv = PSCSI_DEV(dev);
@@ -610,8 +616,7 @@ static void pscsi_free_device(struct se_device *dev)
 
                 pdv->pdv_sd = NULL;
         }
-
-        kfree(pdv);
+        call_rcu(&dev->rcu_head, pscsi_dev_call_rcu);
 }
 
 static void pscsi_transport_complete(struct se_cmd *cmd, struct scatterlist *sg,
@@ -635,12 +640,14 @@ static void pscsi_transport_complete(struct se_cmd *cmd, struct scatterlist *sg,
          * Hack to make sure that Write-Protect modepage is set if R/O mode is
          * forced.
          */
-        if (!cmd->se_deve || !cmd->data_length)
+        if (!cmd->data_length)
                 goto after_mode_sense;
 
         if (((cdb[0] == MODE_SENSE) || (cdb[0] == MODE_SENSE_10)) &&
              (status_byte(result) << 1) == SAM_STAT_GOOD) {
-                if (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY) {
+                bool read_only = target_lun_is_rdonly(cmd);
+
+                if (read_only) {
                         unsigned char *buf;
 
                         buf = transport_kmap_data_sg(cmd);
@@ -1116,27 +1123,7 @@ static void pscsi_req_done(struct request *req, int uptodate)
         kfree(pt);
 }
 
-DEF_TB_DEV_ATTRIB_RO(pscsi, hw_pi_prot_type);
-TB_DEV_ATTR_RO(pscsi, hw_pi_prot_type);
-
-DEF_TB_DEV_ATTRIB_RO(pscsi, hw_block_size);
-TB_DEV_ATTR_RO(pscsi, hw_block_size);
-
-DEF_TB_DEV_ATTRIB_RO(pscsi, hw_max_sectors);
-TB_DEV_ATTR_RO(pscsi, hw_max_sectors);
-
-DEF_TB_DEV_ATTRIB_RO(pscsi, hw_queue_depth);
-TB_DEV_ATTR_RO(pscsi, hw_queue_depth);
-
-static struct configfs_attribute *pscsi_backend_dev_attrs[] = {
-        &pscsi_dev_attrib_hw_pi_prot_type.attr,
-        &pscsi_dev_attrib_hw_block_size.attr,
-        &pscsi_dev_attrib_hw_max_sectors.attr,
-        &pscsi_dev_attrib_hw_queue_depth.attr,
-        NULL,
-};
-
-static struct se_subsystem_api pscsi_template = {
+static const struct target_backend_ops pscsi_ops = {
         .name                   = "pscsi",
         .owner                  = THIS_MODULE,
         .transport_flags        = TRANSPORT_FLAG_PASSTHROUGH,
@@ -1152,21 +1139,17 @@ static struct se_subsystem_api pscsi_template = {
         .show_configfs_dev_params = pscsi_show_configfs_dev_params,
         .get_device_type        = pscsi_get_device_type,
         .get_blocks             = pscsi_get_blocks,
+        .tb_dev_attrib_attrs    = passthrough_attrib_attrs,
 };
 
 static int __init pscsi_module_init(void)
 {
-        struct target_backend_cits *tbc = &pscsi_template.tb_cits;
-
-        target_core_setup_sub_cits(&pscsi_template);
-        tbc->tb_dev_attrib_cit.ct_attrs = pscsi_backend_dev_attrs;
-
-        return transport_subsystem_register(&pscsi_template);
+        return transport_backend_register(&pscsi_ops);
 }
 
 static void __exit pscsi_module_exit(void)
 {
-        transport_subsystem_release(&pscsi_template);
+        target_backend_unregister(&pscsi_ops);
 }
 
 MODULE_DESCRIPTION("TCM PSCSI subsystem plugin");
diff --git a/drivers/target/target_core_rd.c b/drivers/target/target_core_rd.c
index b2d8f6f91633..4703f403f31c 100644
--- a/drivers/target/target_core_rd.c
+++ b/drivers/target/target_core_rd.c
@@ -33,7 +33,6 @@
 
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
-#include <target/target_core_backend_configfs.h>
 
 #include "target_core_rd.h"
 
@@ -42,10 +41,6 @@ static inline struct rd_dev *RD_DEV(struct se_device *dev)
         return container_of(dev, struct rd_dev, dev);
 }
 
-/*      rd_attach_hba(): (Part of se_subsystem_api_t template)
- *
- *
- */
 static int rd_attach_hba(struct se_hba *hba, u32 host_id)
 {
         struct rd_host *rd_host;
@@ -62,7 +57,7 @@ static int rd_attach_hba(struct se_hba *hba, u32 host_id)
 
         pr_debug("CORE_HBA[%d] - TCM Ramdisk HBA Driver %s on"
                 " Generic Target Core Stack %s\n", hba->hba_id,
-                RD_HBA_VERSION, TARGET_CORE_MOD_VERSION);
+                RD_HBA_VERSION, TARGET_CORE_VERSION);
 
         return 0;
 }
@@ -354,12 +349,20 @@ fail:
         return ret;
 }
 
+static void rd_dev_call_rcu(struct rcu_head *p)
+{
+        struct se_device *dev = container_of(p, struct se_device, rcu_head);
+        struct rd_dev *rd_dev = RD_DEV(dev);
+
+        kfree(rd_dev);
+}
+
 static void rd_free_device(struct se_device *dev)
 {
         struct rd_dev *rd_dev = RD_DEV(dev);
 
         rd_release_device_space(rd_dev);
-        kfree(rd_dev);
+        call_rcu(&dev->rcu_head, rd_dev_call_rcu);
 }
 
 static struct rd_dev_sg_table *rd_get_sg_table(struct rd_dev *rd_dev, u32 page)
@@ -402,10 +405,7 @@ static struct rd_dev_sg_table *rd_get_prot_table(struct rd_dev *rd_dev, u32 page
         return NULL;
 }
 
-typedef sense_reason_t (*dif_verify)(struct se_cmd *, sector_t, unsigned int,
-                                     unsigned int, struct scatterlist *, int);
-
-static sense_reason_t rd_do_prot_rw(struct se_cmd *cmd, dif_verify dif_verify)
+static sense_reason_t rd_do_prot_rw(struct se_cmd *cmd, bool is_read)
 {
         struct se_device *se_dev = cmd->se_dev;
         struct rd_dev *dev = RD_DEV(se_dev);
@@ -465,7 +465,16 @@ static sense_reason_t rd_do_prot_rw(struct se_cmd *cmd, dif_verify dif_verify)
 
 #endif /* !CONFIG_ARCH_HAS_SG_CHAIN */
 
-        rc = dif_verify(cmd, cmd->t_task_lba, sectors, 0, prot_sg, prot_offset);
+        if (is_read)
+                rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors, 0,
+                                    prot_sg, prot_offset);
+        else
+                rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors, 0,
+                                    cmd->t_prot_sg, 0);
+
+        if (!rc)
+                sbc_dif_copy_prot(cmd, sectors, is_read, prot_sg, prot_offset);
+
         if (need_to_release)
                 kfree(prot_sg);
 
@@ -511,7 +520,7 @@ rd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 
         if (cmd->prot_type && se_dev->dev_attrib.pi_prot_type &&
             data_direction == DMA_TO_DEVICE) {
-                rc = rd_do_prot_rw(cmd, sbc_dif_verify_write);
+                rc = rd_do_prot_rw(cmd, false);
                 if (rc)
                         return rc;
         }
@@ -579,7 +588,7 @@ rd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 
         if (cmd->prot_type && se_dev->dev_attrib.pi_prot_type &&
             data_direction == DMA_FROM_DEVICE) {
-                rc = rd_do_prot_rw(cmd, sbc_dif_verify_read);
+                rc = rd_do_prot_rw(cmd, true);
                 if (rc)
                         return rc;
         }
@@ -693,42 +702,7 @@ rd_parse_cdb(struct se_cmd *cmd)
         return sbc_parse_cdb(cmd, &rd_sbc_ops);
 }
 
-DEF_TB_DEFAULT_ATTRIBS(rd_mcp);
-
-static struct configfs_attribute *rd_mcp_backend_dev_attrs[] = {
-        &rd_mcp_dev_attrib_emulate_model_alias.attr,
-        &rd_mcp_dev_attrib_emulate_dpo.attr,
-        &rd_mcp_dev_attrib_emulate_fua_write.attr,
-        &rd_mcp_dev_attrib_emulate_fua_read.attr,
-        &rd_mcp_dev_attrib_emulate_write_cache.attr,
-        &rd_mcp_dev_attrib_emulate_ua_intlck_ctrl.attr,
-        &rd_mcp_dev_attrib_emulate_tas.attr,
-        &rd_mcp_dev_attrib_emulate_tpu.attr,
-        &rd_mcp_dev_attrib_emulate_tpws.attr,
-        &rd_mcp_dev_attrib_emulate_caw.attr,
-        &rd_mcp_dev_attrib_emulate_3pc.attr,
-        &rd_mcp_dev_attrib_pi_prot_type.attr,
-        &rd_mcp_dev_attrib_hw_pi_prot_type.attr,
-        &rd_mcp_dev_attrib_pi_prot_format.attr,
-        &rd_mcp_dev_attrib_enforce_pr_isids.attr,
-        &rd_mcp_dev_attrib_is_nonrot.attr,
-        &rd_mcp_dev_attrib_emulate_rest_reord.attr,
-        &rd_mcp_dev_attrib_force_pr_aptpl.attr,
-        &rd_mcp_dev_attrib_hw_block_size.attr,
-        &rd_mcp_dev_attrib_block_size.attr,
-        &rd_mcp_dev_attrib_hw_max_sectors.attr,
-        &rd_mcp_dev_attrib_optimal_sectors.attr,
-        &rd_mcp_dev_attrib_hw_queue_depth.attr,
-        &rd_mcp_dev_attrib_queue_depth.attr,
-        &rd_mcp_dev_attrib_max_unmap_lba_count.attr,
-        &rd_mcp_dev_attrib_max_unmap_block_desc_count.attr,
-        &rd_mcp_dev_attrib_unmap_granularity.attr,
-        &rd_mcp_dev_attrib_unmap_granularity_alignment.attr,
-        &rd_mcp_dev_attrib_max_write_same_len.attr,
-        NULL,
-};
-
-static struct se_subsystem_api rd_mcp_template = {
+static const struct target_backend_ops rd_mcp_ops = {
         .name                   = "rd_mcp",
         .inquiry_prod           = "RAMDISK-MCP",
         .inquiry_rev            = RD_MCP_VERSION,
@@ -744,25 +718,15 @@ static struct se_subsystem_api rd_mcp_template = {
         .get_blocks             = rd_get_blocks,
         .init_prot              = rd_init_prot,
         .free_prot              = rd_free_prot,
+        .tb_dev_attrib_attrs    = sbc_attrib_attrs,
 };
 
 int __init rd_module_init(void)
 {
-        struct target_backend_cits *tbc = &rd_mcp_template.tb_cits;
-        int ret;
-
-        target_core_setup_sub_cits(&rd_mcp_template);
-        tbc->tb_dev_attrib_cit.ct_attrs = rd_mcp_backend_dev_attrs;
-
-        ret = transport_subsystem_register(&rd_mcp_template);
-        if (ret < 0) {
-                return ret;
-        }
-
-        return 0;
+        return transport_backend_register(&rd_mcp_ops);
 }
 
 void rd_module_exit(void)
 {
-        transport_subsystem_release(&rd_mcp_template);
+        target_backend_unregister(&rd_mcp_ops);
 }
diff --git a/drivers/target/target_core_sbc.c b/drivers/target/target_core_sbc.c
index 43719b393ca9..e318ddbe15da 100644
--- a/drivers/target/target_core_sbc.c
+++ b/drivers/target/target_core_sbc.c
@@ -38,6 +38,7 @@
 
 static sense_reason_t
 sbc_check_prot(struct se_device *, struct se_cmd *, unsigned char *, u32, bool);
+static sense_reason_t sbc_execute_unmap(struct se_cmd *cmd);
 
 static sense_reason_t
 sbc_emulate_readcapacity(struct se_cmd *cmd)
@@ -177,6 +178,23 @@ sector_t sbc_get_write_same_sectors(struct se_cmd *cmd)
 EXPORT_SYMBOL(sbc_get_write_same_sectors);
 
 static sense_reason_t
+sbc_execute_write_same_unmap(struct se_cmd *cmd)
+{
+        struct sbc_ops *ops = cmd->protocol_data;
+        sector_t nolb = sbc_get_write_same_sectors(cmd);
+        sense_reason_t ret;
+
+        if (nolb) {
+                ret = ops->execute_unmap(cmd, cmd->t_task_lba, nolb);
+                if (ret)
+                        return ret;
+        }
+
+        target_complete_cmd(cmd, GOOD);
+        return 0;
+}
+
+static sense_reason_t
 sbc_emulate_noop(struct se_cmd *cmd)
 {
         target_complete_cmd(cmd, GOOD);
@@ -299,7 +317,7 @@ sbc_setup_write_same(struct se_cmd *cmd, unsigned char *flags, struct sbc_ops *o
          * translated into block discard requests within backend code.
          */
         if (flags[0] & 0x08) {
-                if (!ops->execute_write_same_unmap)
+                if (!ops->execute_unmap)
                         return TCM_UNSUPPORTED_SCSI_OPCODE;
 
                 if (!dev->dev_attrib.emulate_tpws) {
@@ -307,7 +325,7 @@ sbc_setup_write_same(struct se_cmd *cmd, unsigned char *flags, struct sbc_ops *o
                                " has emulate_tpws disabled\n");
                         return TCM_UNSUPPORTED_SCSI_OPCODE;
                 }
-                cmd->execute_cmd = ops->execute_write_same_unmap;
+                cmd->execute_cmd = sbc_execute_write_same_unmap;
                 return 0;
         }
         if (!ops->execute_write_same)
@@ -381,7 +399,9 @@ out:
 static sense_reason_t
 sbc_execute_rw(struct se_cmd *cmd)
 {
-        return cmd->execute_rw(cmd, cmd->t_data_sg, cmd->t_data_nents,
+        struct sbc_ops *ops = cmd->protocol_data;
+
+        return ops->execute_rw(cmd, cmd->t_data_sg, cmd->t_data_nents,
                                cmd->data_direction);
 }
 
@@ -560,6 +580,7 @@ out:
 static sense_reason_t
 sbc_compare_and_write(struct se_cmd *cmd)
 {
+        struct sbc_ops *ops = cmd->protocol_data;
         struct se_device *dev = cmd->se_dev;
         sense_reason_t ret;
         int rc;
@@ -579,7 +600,7 @@ sbc_compare_and_write(struct se_cmd *cmd)
          */
         cmd->data_length = cmd->t_task_nolb * dev->dev_attrib.block_size;
 
-        ret = cmd->execute_rw(cmd, cmd->t_bidi_data_sg, cmd->t_bidi_data_nents,
+        ret = ops->execute_rw(cmd, cmd->t_bidi_data_sg, cmd->t_bidi_data_nents,
                               DMA_FROM_DEVICE);
         if (ret) {
                 cmd->transport_complete_callback = NULL;
@@ -738,14 +759,15 @@ static int
 sbc_check_dpofua(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb)
 {
         if (cdb[1] & 0x10) {
-                if (!dev->dev_attrib.emulate_dpo) {
+                /* see explanation in spc_emulate_modesense */
+                if (!target_check_fua(dev)) {
                         pr_err("Got CDB: 0x%02x with DPO bit set, but device"
                                " does not advertise support for DPO\n", cdb[0]);
                         return -EINVAL;
                 }
         }
         if (cdb[1] & 0x8) {
-                if (!dev->dev_attrib.emulate_fua_write || !se_dev_check_wce(dev)) {
+                if (!target_check_fua(dev)) {
                         pr_err("Got CDB: 0x%02x with FUA bit set, but device"
                                " does not advertise support for FUA write\n",
                                cdb[0]);
@@ -765,12 +787,13 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
         u32 sectors = 0;
         sense_reason_t ret;
 
+        cmd->protocol_data = ops;
+
         switch (cdb[0]) {
         case READ_6:
                 sectors = transport_get_sectors_6(cdb);
                 cmd->t_task_lba = transport_lba_21(cdb);
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
-                cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
                 break;
         case READ_10:
@@ -785,7 +808,6 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                         return ret;
 
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
-                cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
                 break;
         case READ_12:
@@ -800,7 +822,6 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                         return ret;
 
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
-                cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
                 break;
         case READ_16:
@@ -815,14 +836,12 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                         return ret;
 
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
-                cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
                 break;
         case WRITE_6:
                 sectors = transport_get_sectors_6(cdb);
                 cmd->t_task_lba = transport_lba_21(cdb);
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
-                cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
                 break;
         case WRITE_10:
@@ -838,7 +857,6 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                         return ret;
 
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
-                cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
                 break;
         case WRITE_12:
@@ -853,7 +871,6 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                         return ret;
 
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
-                cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
                 break;
         case WRITE_16:
@@ -868,7 +885,6 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                         return ret;
 
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
-                cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
                 break;
         case XDWRITEREAD_10:
@@ -886,7 +902,6 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 /*
                  * Setup BIDI XOR callback to be run after I/O completion.
                  */
-                cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_execute_rw;
                 cmd->transport_complete_callback = &xdreadwrite_callback;
                 break;
@@ -910,7 +925,6 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                          * Setup BIDI XOR callback to be run during after I/O
                          * completion.
                          */
-                        cmd->execute_rw = ops->execute_rw;
                         cmd->execute_cmd = sbc_execute_rw;
                         cmd->transport_complete_callback = &xdreadwrite_callback;
                         break;
@@ -954,7 +968,6 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                 cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
                 cmd->t_task_nolb = sectors;
                 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB | SCF_COMPARE_AND_WRITE;
-                cmd->execute_rw = ops->execute_rw;
                 cmd->execute_cmd = sbc_compare_and_write;
                 cmd->transport_complete_callback = compare_and_write_callback;
                 break;
@@ -1004,7 +1017,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
                         return TCM_UNSUPPORTED_SCSI_OPCODE;
                 }
                 size = get_unaligned_be16(&cdb[7]);
-                cmd->execute_cmd = ops->execute_unmap;
+                cmd->execute_cmd = sbc_execute_unmap;
                 break;
         case WRITE_SAME_16:
                 sectors = transport_get_sectors_16(cdb);
@@ -1092,12 +1105,10 @@ u32 sbc_get_device_type(struct se_device *dev)
 }
 EXPORT_SYMBOL(sbc_get_device_type);
 
-sense_reason_t
-sbc_execute_unmap(struct se_cmd *cmd,
-        sense_reason_t (*do_unmap_fn)(struct se_cmd *, void *,
-                                      sector_t, sector_t),
-        void *priv)
+static sense_reason_t
+sbc_execute_unmap(struct se_cmd *cmd)
 {
+        struct sbc_ops *ops = cmd->protocol_data;
         struct se_device *dev = cmd->se_dev;
         unsigned char *buf, *ptr = NULL;
         sector_t lba;
@@ -1161,7 +1172,7 @@ sbc_execute_unmap(struct se_cmd *cmd,
                         goto err;
                 }
 
-                ret = do_unmap_fn(cmd, priv, lba, range);
+                ret = ops->execute_unmap(cmd, lba, range);
                 if (ret)
                         goto err;
 
@@ -1175,34 +1186,56 @@ err:
                 target_complete_cmd(cmd, GOOD);
         return ret;
 }
-EXPORT_SYMBOL(sbc_execute_unmap);
 
 void
 sbc_dif_generate(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
         struct se_dif_v1_tuple *sdt;
-        struct scatterlist *dsg, *psg = cmd->t_prot_sg;
+        struct scatterlist *dsg = cmd->t_data_sg, *psg;
         sector_t sector = cmd->t_task_lba;
         void *daddr, *paddr;
         int i, j, offset = 0;
+        unsigned int block_size = dev->dev_attrib.block_size;
 
-        for_each_sg(cmd->t_data_sg, dsg, cmd->t_data_nents, i) {
-                daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
+        for_each_sg(cmd->t_prot_sg, psg, cmd->t_prot_nents, i) {
                 paddr = kmap_atomic(sg_page(psg)) + psg->offset;
+                daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
 
-                for (j = 0; j < dsg->length; j += dev->dev_attrib.block_size) {
+                for (j = 0; j < psg->length;
+                                j += sizeof(struct se_dif_v1_tuple)) {
+                        __u16 crc;
+                        unsigned int avail;
+
+                        if (offset >= dsg->length) {
+                                offset -= dsg->length;
+                                kunmap_atomic(daddr - dsg->offset);
+                                dsg = sg_next(dsg);
+                                if (!dsg) {
+                                        kunmap_atomic(paddr - psg->offset);
+                                        return;
+                                }
+                                daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
+                        }
 
-                        if (offset >= psg->length) {
-                                kunmap_atomic(paddr);
-                                psg = sg_next(psg);
-                                paddr = kmap_atomic(sg_page(psg)) + psg->offset;
-                                offset = 0;
+                        sdt = paddr + j;
+                        avail = min(block_size, dsg->length - offset);
+                        crc = crc_t10dif(daddr + offset, avail);
+                        if (avail < block_size) {
+                                kunmap_atomic(daddr - dsg->offset);
+                                dsg = sg_next(dsg);
+                                if (!dsg) {
+                                        kunmap_atomic(paddr - psg->offset);
+                                        return;
+                                }
+                                daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
+                                offset = block_size - avail;
+                                crc = crc_t10dif_update(crc, daddr, offset);
+                        } else {
+                                offset += block_size;
                         }
 
-                        sdt = paddr + offset;
-                        sdt->guard_tag = cpu_to_be16(crc_t10dif(daddr + j,
-                                                dev->dev_attrib.block_size));
+                        sdt->guard_tag = cpu_to_be16(crc);
                         if (cmd->prot_type == TARGET_DIF_TYPE1_PROT)
                                 sdt->ref_tag = cpu_to_be32(sector & 0xffffffff);
                         sdt->app_tag = 0;
@@ -1215,26 +1248,23 @@ sbc_dif_generate(struct se_cmd *cmd)
                                  be32_to_cpu(sdt->ref_tag));
 
                         sector++;
-                        offset += sizeof(struct se_dif_v1_tuple);
                 }
 
-                kunmap_atomic(paddr);
-                kunmap_atomic(daddr);
+                kunmap_atomic(daddr - dsg->offset);
+                kunmap_atomic(paddr - psg->offset);
         }
 }
 
 static sense_reason_t
 sbc_dif_v1_verify(struct se_cmd *cmd, struct se_dif_v1_tuple *sdt,
-                  const void *p, sector_t sector, unsigned int ei_lba)
+                  __u16 crc, sector_t sector, unsigned int ei_lba)
 {
-        struct se_device *dev = cmd->se_dev;
-        int block_size = dev->dev_attrib.block_size;
         __be16 csum;
 
         if (!(cmd->prot_checks & TARGET_DIF_CHECK_GUARD))
                 goto check_ref;
 
-        csum = cpu_to_be16(crc_t10dif(p, block_size));
+        csum = cpu_to_be16(crc);
 
         if (sdt->guard_tag != csum) {
                 pr_err("DIFv1 checksum failed on sector %llu guard tag 0x%04x"
@@ -1266,9 +1296,8 @@ check_ref:
         return 0;
 }
 
-static void
-sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read,
-                  struct scatterlist *sg, int sg_off)
+void sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read,
+                       struct scatterlist *sg, int sg_off)
 {
         struct se_device *dev = cmd->se_dev;
         struct scatterlist *psg;
@@ -1300,100 +1329,54 @@ sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read,
                         copied += len;
                         psg_len -= len;
 
+                        kunmap_atomic(addr - sg->offset - offset);
+
                         if (offset >= sg->length) {
                                 sg = sg_next(sg);
                                 offset = 0;
                         }
-                        kunmap_atomic(addr);
                 }
-                kunmap_atomic(paddr);
+                kunmap_atomic(paddr - psg->offset);
         }
 }
+EXPORT_SYMBOL(sbc_dif_copy_prot);
 
 sense_reason_t
-sbc_dif_verify_write(struct se_cmd *cmd, sector_t start, unsigned int sectors,
-                     unsigned int ei_lba, struct scatterlist *sg, int sg_off)
+sbc_dif_verify(struct se_cmd *cmd, sector_t start, unsigned int sectors,
+               unsigned int ei_lba, struct scatterlist *psg, int psg_off)
 {
         struct se_device *dev = cmd->se_dev;
         struct se_dif_v1_tuple *sdt;
-        struct scatterlist *dsg, *psg = cmd->t_prot_sg;
+        struct scatterlist *dsg = cmd->t_data_sg;
         sector_t sector = start;
         void *daddr, *paddr;
-        int i, j, offset = 0;
+        int i;
         sense_reason_t rc;
+        int dsg_off = 0;
+        unsigned int block_size = dev->dev_attrib.block_size;
 
-        for_each_sg(cmd->t_data_sg, dsg, cmd->t_data_nents, i) {
-                daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
+        for (; psg && sector < start + sectors; psg = sg_next(psg)) {
                 paddr = kmap_atomic(sg_page(psg)) + psg->offset;
-
-                for (j = 0; j < dsg->length; j += dev->dev_attrib.block_size) {
-
-                        if (offset >= psg->length) {
-                                kunmap_atomic(paddr);
-                                psg = sg_next(psg);
-                                paddr = kmap_atomic(sg_page(psg)) + psg->offset;
-                                offset = 0;
-                        }
-
-                        sdt = paddr + offset;
-
-                        pr_debug("DIF WRITE sector: %llu guard_tag: 0x%04x"
-                                 " app_tag: 0x%04x ref_tag: %u\n",
-                                 (unsigned long long)sector, sdt->guard_tag,
-                                 sdt->app_tag, be32_to_cpu(sdt->ref_tag));
-
-                        rc = sbc_dif_v1_verify(cmd, sdt, daddr + j, sector,
-                                               ei_lba);
-                        if (rc) {
-                                kunmap_atomic(paddr);
-                                kunmap_atomic(daddr);
-                                cmd->bad_sector = sector;
-                                return rc;
-                        }
-
-                        sector++;
-                        ei_lba++;
-                        offset += sizeof(struct se_dif_v1_tuple);
-                }
-
-                kunmap_atomic(paddr);
-                kunmap_atomic(daddr);
-        }
-        if (!sg)
-                return 0;
-
-        sbc_dif_copy_prot(cmd, sectors, false, sg, sg_off);
-
-        return 0;
-}
-EXPORT_SYMBOL(sbc_dif_verify_write);
-
-static sense_reason_t
-__sbc_dif_verify_read(struct se_cmd *cmd, sector_t start, unsigned int sectors,
-                      unsigned int ei_lba, struct scatterlist *sg, int sg_off)
-{
-        struct se_device *dev = cmd->se_dev;
-        struct se_dif_v1_tuple *sdt;
-        struct scatterlist *dsg, *psg = sg;
-        sector_t sector = start;
-        void *daddr, *paddr;
-        int i, j, offset = sg_off;
-        sense_reason_t rc;
-
-        for_each_sg(cmd->t_data_sg, dsg, cmd->t_data_nents, i) {
                 daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
-                paddr = kmap_atomic(sg_page(psg)) + sg->offset;
-
-                for (j = 0; j < dsg->length; j += dev->dev_attrib.block_size) {
 
-                        if (offset >= psg->length) {
-                                kunmap_atomic(paddr);
-                                psg = sg_next(psg);
-                                paddr = kmap_atomic(sg_page(psg)) + psg->offset;
-                                offset = 0;
+                for (i = psg_off; i < psg->length &&
+                                sector < start + sectors;
+                                i += sizeof(struct se_dif_v1_tuple)) {
+                        __u16 crc;
+                        unsigned int avail;
+
+                        if (dsg_off >= dsg->length) {
+                                dsg_off -= dsg->length;
+                                kunmap_atomic(daddr - dsg->offset);
+                                dsg = sg_next(dsg);
+                                if (!dsg) {
+                                        kunmap_atomic(paddr - psg->offset);
+                                        return 0;
+                                }
+                                daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
                         }
 
-                        sdt = paddr + offset;
+                        sdt = paddr + i;
 
                         pr_debug("DIF READ sector: %llu guard_tag: 0x%04x"
                                  " app_tag: 0x%04x ref_tag: %u\n",
@@ -1401,53 +1384,43 @@ __sbc_dif_verify_read(struct se_cmd *cmd, sector_t start, unsigned int sectors,
                                  sdt->app_tag, be32_to_cpu(sdt->ref_tag));
 
                         if (sdt->app_tag == cpu_to_be16(0xffff)) {
-                                sector++;
-                                offset += sizeof(struct se_dif_v1_tuple);
-                                continue;
+                                dsg_off += block_size;
+                                goto next;
+                        }
+
+                        avail = min(block_size, dsg->length - dsg_off);
+                        crc = crc_t10dif(daddr + dsg_off, avail);
+                        if (avail < block_size) {
+                                kunmap_atomic(daddr - dsg->offset);
+                                dsg = sg_next(dsg);
+                                if (!dsg) {
+                                        kunmap_atomic(paddr - psg->offset);
+                                        return 0;
+                                }
+                                daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
+                                dsg_off = block_size - avail;
+                                crc = crc_t10dif_update(crc, daddr, dsg_off);
+                        } else {
+                                dsg_off += block_size;
                         }
 
-                        rc = sbc_dif_v1_verify(cmd, sdt, daddr + j, sector,
-                                               ei_lba);
+                        rc = sbc_dif_v1_verify(cmd, sdt, crc, sector, ei_lba);
                         if (rc) {
-                                kunmap_atomic(paddr);
-                                kunmap_atomic(daddr);
+                                kunmap_atomic(daddr - dsg->offset);
+                                kunmap_atomic(paddr - psg->offset);
                                 cmd->bad_sector = sector;
                                 return rc;
                         }
-
+next:
                         sector++;
                         ei_lba++;
-                        offset += sizeof(struct se_dif_v1_tuple);
                 }
 
-                kunmap_atomic(paddr);
-                kunmap_atomic(daddr);
+                psg_off = 0;
+                kunmap_atomic(daddr - dsg->offset);
+                kunmap_atomic(paddr - psg->offset);
         }
 
         return 0;
 }
-
-sense_reason_t
-sbc_dif_read_strip(struct se_cmd *cmd)
-{
-        struct se_device *dev = cmd->se_dev;
-        u32 sectors = cmd->prot_length / dev->prot_length;
-
-        return __sbc_dif_verify_read(cmd, cmd->t_task_lba, sectors, 0,
-                                     cmd->t_prot_sg, 0);
-}
-
-sense_reason_t
-sbc_dif_verify_read(struct se_cmd *cmd, sector_t start, unsigned int sectors,
-                    unsigned int ei_lba, struct scatterlist *sg, int sg_off)
-{
-        sense_reason_t rc;
-
-        rc = __sbc_dif_verify_read(cmd, start, sectors, ei_lba, sg, sg_off);
-        if (rc)
-                return rc;
-
-        sbc_dif_copy_prot(cmd, sectors, true, sg, sg_off);
-        return 0;
-}
-EXPORT_SYMBOL(sbc_dif_verify_read);
+EXPORT_SYMBOL(sbc_dif_verify);
diff --git a/drivers/target/target_core_spc.c b/drivers/target/target_core_spc.c
index 52ea640274f4..b0744433315a 100644
--- a/drivers/target/target_core_spc.c
+++ b/drivers/target/target_core_spc.c
@@ -38,10 +38,9 @@
 #include "target_core_ua.h"
 #include "target_core_xcopy.h"
 
-static void spc_fill_alua_data(struct se_port *port, unsigned char *buf)
+static void spc_fill_alua_data(struct se_lun *lun, unsigned char *buf)
 {
         struct t10_alua_tg_pt_gp *tg_pt_gp;
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
 
         /*
          * Set SCCS for MAINTENANCE_IN + REPORT_TARGET_PORT_GROUPS.
@@ -54,17 +53,11 @@ static void spc_fill_alua_data(struct se_port *port, unsigned char *buf)
          *
          * See spc4r17 section 6.4.2 Table 135
          */
-        if (!port)
-                return;
-        tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
-        if (!tg_pt_gp_mem)
-                return;
-
-        spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-        tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
+        spin_lock(&lun->lun_tg_pt_gp_lock);
+        tg_pt_gp = lun->lun_tg_pt_gp;
         if (tg_pt_gp)
                 buf[5] |= tg_pt_gp->tg_pt_gp_alua_access_type;
-        spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
+        spin_unlock(&lun->lun_tg_pt_gp_lock);
 }
 
 sense_reason_t
@@ -95,7 +88,7 @@ spc_emulate_inquiry_std(struct se_cmd *cmd, unsigned char *buf)
         /*
          * Enable SCCS and TPGS fields for Emulated ALUA
          */
-        spc_fill_alua_data(lun->lun_sep, buf);
+        spc_fill_alua_data(lun, buf);
 
         /*
          * Set Third-Party Copy (3PC) bit to indicate support for EXTENDED_COPY
@@ -182,11 +175,9 @@ spc_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)
 {
         struct se_device *dev = cmd->se_dev;
         struct se_lun *lun = cmd->se_lun;
-        struct se_port *port = NULL;
         struct se_portal_group *tpg = NULL;
         struct t10_alua_lu_gp_member *lu_gp_mem;
         struct t10_alua_tg_pt_gp *tg_pt_gp;
-        struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
         unsigned char *prod = &dev->t10_wwn.model[0];
         u32 prod_len;
         u32 unit_serial_len, off = 0;
@@ -268,18 +259,15 @@ check_t10_vend_desc:
         /* Header size for Designation descriptor */
         len += (id_len + 4);
         off += (id_len + 4);
-        /*
-         * struct se_port is only set for INQUIRY VPD=1 through $FABRIC_MOD
-         */
-        port = lun->lun_sep;
-        if (port) {
+
+        if (1) {
                 struct t10_alua_lu_gp *lu_gp;
                 u32 padding, scsi_name_len, scsi_target_len;
                 u16 lu_gp_id = 0;
                 u16 tg_pt_gp_id = 0;
                 u16 tpgt;
 
-                tpg = port->sep_tpg;
+                tpg = lun->lun_tpg;
                 /*
                  * Relative target port identifer, see spc4r17
                  * section 7.7.3.7
@@ -287,8 +275,7 @@ check_t10_vend_desc:
                  * Get the PROTOCOL IDENTIFIER as defined by spc4r17
                  * section 7.5.1 Table 362
                  */
-                buf[off] =
-                        (tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4);
+                buf[off] = tpg->proto_id << 4;
                 buf[off++] |= 0x1; /* CODE SET == Binary */
                 buf[off] = 0x80; /* Set PIV=1 */
                 /* Set ASSOCIATION == target port: 01b */
@@ -300,8 +287,8 @@ check_t10_vend_desc:
                 /* Skip over Obsolete field in RTPI payload
                  * in Table 472 */
                 off += 2;
-                buf[off++] = ((port->sep_rtpi >> 8) & 0xff);
-                buf[off++] = (port->sep_rtpi & 0xff);
+                buf[off++] = ((lun->lun_rtpi >> 8) & 0xff);
+                buf[off++] = (lun->lun_rtpi & 0xff);
                 len += 8; /* Header size + Designation descriptor */
                 /*
                  * Target port group identifier, see spc4r17
@@ -310,21 +297,16 @@ check_t10_vend_desc:
                  * Get the PROTOCOL IDENTIFIER as defined by spc4r17
                  * section 7.5.1 Table 362
                  */
-                tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
-                if (!tg_pt_gp_mem)
-                        goto check_lu_gp;
-
-                spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
-                tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
+                spin_lock(&lun->lun_tg_pt_gp_lock);
+                tg_pt_gp = lun->lun_tg_pt_gp;
                 if (!tg_pt_gp) {
-                        spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
+                        spin_unlock(&lun->lun_tg_pt_gp_lock);
                         goto check_lu_gp;
                 }
                 tg_pt_gp_id = tg_pt_gp->tg_pt_gp_id;
-                spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
+                spin_unlock(&lun->lun_tg_pt_gp_lock);
 
-                buf[off] =
-                        (tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4);
+                buf[off] = tpg->proto_id << 4;
                 buf[off++] |= 0x1; /* CODE SET == Binary */
                 buf[off] = 0x80; /* Set PIV=1 */
                 /* Set ASSOCIATION == target port: 01b */
@@ -372,8 +354,7 @@ check_lu_gp:
                  * section 7.5.1 Table 362
                  */
 check_scsi_name:
-                buf[off] =
-                        (tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4);
+                buf[off] = tpg->proto_id << 4;
                 buf[off++] |= 0x3; /* CODE SET == UTF-8 */
                 buf[off] = 0x80; /* Set PIV=1 */
                 /* Set ASSOCIATION == target port: 01b */
@@ -413,8 +394,7 @@ check_scsi_name:
                 /*
                  * Target device designator
                  */
-                buf[off] =
-                        (tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4);
+                buf[off] = tpg->proto_id << 4;
                 buf[off++] |= 0x3; /* CODE SET == UTF-8 */
                 buf[off] = 0x80; /* Set PIV=1 */
                 /* Set ASSOCIATION == target device: 10b */
@@ -482,7 +462,7 @@ spc_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf)
         buf[5] = 0x07;
 
         /* If WriteCache emulation is enabled, set V_SUP */
-        if (se_dev_check_wce(dev))
+        if (target_check_wce(dev))
                 buf[6] = 0x01;
         /* If an LBA map is present set R_SUP */
         spin_lock(&cmd->se_dev->t10_alua.lba_map_lock);
@@ -699,7 +679,7 @@ static sense_reason_t
 spc_emulate_inquiry(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
-        struct se_portal_group *tpg = cmd->se_lun->lun_sep->sep_tpg;
+        struct se_portal_group *tpg = cmd->se_lun->lun_tpg;
         unsigned char *rbuf;
         unsigned char *cdb = cmd->t_task_cdb;
         unsigned char *buf;
@@ -713,7 +693,7 @@ spc_emulate_inquiry(struct se_cmd *cmd)
                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
         }
 
-        if (dev == tpg->tpg_virt_lun0.lun_se_dev)
+        if (dev == rcu_access_pointer(tpg->tpg_virt_lun0->lun_se_dev))
                 buf[0] = 0x3f; /* Not connected */
         else
                 buf[0] = dev->transport->get_device_type(dev);
@@ -889,7 +869,7 @@ static int spc_modesense_caching(struct se_cmd *cmd, u8 pc, u8 *p)
         if (pc == 1)
                 goto out;
 
-        if (se_dev_check_wce(dev))
+        if (target_check_wce(dev))
                 p[2] = 0x04; /* Write Cache Enable */
         p[12] = 0x20; /* Disabled Read Ahead */
 
@@ -986,6 +966,7 @@ static sense_reason_t spc_emulate_modesense(struct se_cmd *cmd)
         int length = 0;
         int ret;
         int i;
+        bool read_only = target_lun_is_rdonly(cmd);;
 
         memset(buf, 0, SE_MODE_PAGE_BUF);
 
@@ -996,13 +977,15 @@ static sense_reason_t spc_emulate_modesense(struct se_cmd *cmd)
         length = ten ? 3 : 2;
 
         /* DEVICE-SPECIFIC PARAMETER */
-        if ((cmd->se_lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) ||
-            (cmd->se_deve &&
-             (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)))
+        if ((cmd->se_lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) || read_only)
                 spc_modesense_write_protect(&buf[length], type);
 
-        if ((se_dev_check_wce(dev)) &&
-            (dev->dev_attrib.emulate_fua_write > 0))
+        /*
+         * SBC only allows us to enable FUA and DPO together.  Fortunately
+         * DPO is explicitly specified as a hint, so a noop is a perfectly
+         * valid implementation.
+         */
+        if (target_check_fua(dev))
                 spc_modesense_dpofua(&buf[length], type);
 
         ++length;
@@ -1212,8 +1195,9 @@ sense_reason_t spc_emulate_report_luns(struct se_cmd *cmd)
 {
         struct se_dev_entry *deve;
         struct se_session *sess = cmd->se_sess;
+        struct se_node_acl *nacl;
         unsigned char *buf;
-        u32 lun_count = 0, offset = 8, i;
+        u32 lun_count = 0, offset = 8;
 
         if (cmd->data_length < 16) {
                 pr_warn("REPORT LUNS allocation length %u too small\n",
@@ -1235,12 +1219,10 @@ sense_reason_t spc_emulate_report_luns(struct se_cmd *cmd)
                 lun_count = 1;
                 goto done;
         }
+        nacl = sess->se_node_acl;
 
-        spin_lock_irq(&sess->se_node_acl->device_list_lock);
-        for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
-                deve = sess->se_node_acl->device_list[i];
-                if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
-                        continue;
+        rcu_read_lock();
+        hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) {
                 /*
                  * We determine the correct LUN LIST LENGTH even once we
                  * have reached the initial allocation length.
@@ -1253,7 +1235,7 @@ sense_reason_t spc_emulate_report_luns(struct se_cmd *cmd)
                 int_to_scsilun(deve->mapped_lun, (struct scsi_lun *)&buf[offset]);
                 offset += 8;
         }
-        spin_unlock_irq(&sess->se_node_acl->device_list_lock);
+        rcu_read_unlock();
 
         /*
          * See SPC3 r07, page 159.
diff --git a/drivers/target/target_core_stat.c b/drivers/target/target_core_stat.c
index 40f6c1378041..20ed5d2e151a 100644
--- a/drivers/target/target_core_stat.c
+++ b/drivers/target/target_core_stat.c
@@ -37,7 +37,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 #include <target/configfs_macros.h>
 
 #include "target_core_internal.h"
@@ -104,7 +103,7 @@ static ssize_t target_stat_scsi_dev_show_attr_ports(
         struct se_device *dev =
                 container_of(sgrps, struct se_device, dev_stat_grps);
 
-        return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_port_count);
+        return snprintf(page, PAGE_SIZE, "%u\n", dev->export_count);
 }
 DEV_STAT_SCSI_DEV_ATTR_RO(ports);
 
@@ -540,20 +539,14 @@ static ssize_t target_stat_scsi_port_show_attr_inst(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        struct se_device *dev = lun->lun_se_dev;
-        struct se_hba *hba;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-        hba = dev->se_hba;
-        ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_PORT_ATTR_RO(inst);
@@ -562,18 +555,14 @@ static ssize_t target_stat_scsi_port_show_attr_dev(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        struct se_device *dev = lun->lun_se_dev;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-        ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_PORT_ATTR_RO(dev);
@@ -582,17 +571,14 @@ static ssize_t target_stat_scsi_port_show_attr_indx(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-        ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_PORT_ATTR_RO(indx);
@@ -601,21 +587,14 @@ static ssize_t target_stat_scsi_port_show_attr_role(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_device *dev = lun->lun_se_dev;
-        struct se_port *sep;
-        ssize_t ret;
-
-        if (!dev)
-                return -ENODEV;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-        ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_PORT_ATTR_RO(role);
@@ -624,18 +603,16 @@ static ssize_t target_stat_scsi_port_show_attr_busy_count(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev) {
+                /* FIXME: scsiPortBusyStatuses  */
+                ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
         }
-        /* FIXME: scsiPortBusyStatuses  */
-        ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
-        spin_unlock(&lun->lun_sep_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_PORT_ATTR_RO(busy_count);
@@ -683,20 +660,14 @@ static ssize_t target_stat_scsi_tgt_port_show_attr_inst(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_device *dev = lun->lun_se_dev;
-        struct se_port *sep;
-        struct se_hba *hba;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-        hba = dev->se_hba;
-        ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(inst);
@@ -705,18 +676,14 @@ static ssize_t target_stat_scsi_tgt_port_show_attr_dev(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_device *dev = lun->lun_se_dev;
-        struct se_port *sep;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-        ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(dev);
@@ -725,17 +692,14 @@ static ssize_t target_stat_scsi_tgt_port_show_attr_indx(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-        ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(indx);
@@ -744,21 +708,17 @@ static ssize_t target_stat_scsi_tgt_port_show_attr_name(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        struct se_portal_group *tpg;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-        tpg = sep->sep_tpg;
-
-        ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
-                tpg->se_tpg_tfo->get_fabric_name(), sep->sep_index);
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_portal_group *tpg = lun->lun_tpg;
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
+                        tpg->se_tpg_tfo->get_fabric_name(),
+                        lun->lun_rtpi);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(name);
@@ -767,22 +727,17 @@ static ssize_t target_stat_scsi_tgt_port_show_attr_port_index(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        struct se_portal_group *tpg;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-        tpg = sep->sep_tpg;
-
-        ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
-                tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
-                tpg->se_tpg_tfo->tpg_get_tag(tpg));
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_portal_group *tpg = lun->lun_tpg;
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
+                        tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
+                        tpg->se_tpg_tfo->tpg_get_tag(tpg));
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(port_index);
@@ -791,18 +746,15 @@ static ssize_t target_stat_scsi_tgt_port_show_attr_in_cmds(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-
-        ret = snprintf(page, PAGE_SIZE, "%llu\n", sep->sep_stats.cmd_pdus);
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%lu\n",
+                               atomic_long_read(&lun->lun_stats.cmd_pdus));
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(in_cmds);
@@ -811,19 +763,15 @@ static ssize_t target_stat_scsi_tgt_port_show_attr_write_mbytes(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-
-        ret = snprintf(page, PAGE_SIZE, "%u\n",
-                        (u32)(sep->sep_stats.rx_data_octets >> 20));
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%u\n",
+                        (u32)(atomic_long_read(&lun->lun_stats.rx_data_octets) >> 20));
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(write_mbytes);
@@ -832,19 +780,15 @@ static ssize_t target_stat_scsi_tgt_port_show_attr_read_mbytes(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-
-        ret = snprintf(page, PAGE_SIZE, "%u\n",
-                        (u32)(sep->sep_stats.tx_data_octets >> 20));
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%u\n",
+                                (u32)(atomic_long_read(&lun->lun_stats.tx_data_octets) >> 20));
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(read_mbytes);
@@ -853,19 +797,16 @@ static ssize_t target_stat_scsi_tgt_port_show_attr_hs_in_cmds(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev) {
+                /* FIXME: scsiTgtPortHsInCommands */
+                ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
         }
-
-        /* FIXME: scsiTgtPortHsInCommands */
-        ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
-        spin_unlock(&lun->lun_sep_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(hs_in_cmds);
@@ -919,21 +860,14 @@ static ssize_t target_stat_scsi_transport_show_attr_inst(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_device *dev = lun->lun_se_dev;
-        struct se_port *sep;
-        struct se_hba *hba;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-
-        hba = dev->se_hba;
-        ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_device *dev;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(inst);
@@ -942,21 +876,18 @@ static ssize_t target_stat_scsi_transport_show_attr_device(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        struct se_portal_group *tpg;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
+        struct se_device *dev;
+        struct se_portal_group *tpg = lun->lun_tpg;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev) {
+                /* scsiTransportType */
+                ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
+                               tpg->se_tpg_tfo->get_fabric_name());
         }
-        tpg = sep->sep_tpg;
-        /* scsiTransportType */
-        ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
-                        tpg->se_tpg_tfo->get_fabric_name());
-        spin_unlock(&lun->lun_sep_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(device);
@@ -965,20 +896,16 @@ static ssize_t target_stat_scsi_transport_show_attr_indx(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_port *sep;
-        struct se_portal_group *tpg;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
-        }
-        tpg = sep->sep_tpg;
-        ret = snprintf(page, PAGE_SIZE, "%u\n",
-                        tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
-        spin_unlock(&lun->lun_sep_lock);
+        struct se_device *dev;
+        struct se_portal_group *tpg = lun->lun_tpg;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev)
+                ret = snprintf(page, PAGE_SIZE, "%u\n",
+                               tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(indx);
@@ -987,26 +914,22 @@ static ssize_t target_stat_scsi_transport_show_attr_dev_name(
         struct se_port_stat_grps *pgrps, char *page)
 {
         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
-        struct se_device *dev = lun->lun_se_dev;
-        struct se_port *sep;
-        struct se_portal_group *tpg;
+        struct se_device *dev;
+        struct se_portal_group *tpg = lun->lun_tpg;
         struct t10_wwn *wwn;
-        ssize_t ret;
-
-        spin_lock(&lun->lun_sep_lock);
-        sep = lun->lun_sep;
-        if (!sep) {
-                spin_unlock(&lun->lun_sep_lock);
-                return -ENODEV;
+        ssize_t ret = -ENODEV;
+
+        rcu_read_lock();
+        dev = rcu_dereference(lun->lun_se_dev);
+        if (dev) {
+                wwn = &dev->t10_wwn;
+                /* scsiTransportDevName */
+                ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
+                                tpg->se_tpg_tfo->tpg_get_wwn(tpg),
+                                (strlen(wwn->unit_serial)) ? wwn->unit_serial :
+                                wwn->vendor);
         }
-        tpg = sep->sep_tpg;
-        wwn = &dev->t10_wwn;
-        /* scsiTransportDevName */
-        ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
-                        tpg->se_tpg_tfo->tpg_get_wwn(tpg),
-                        (strlen(wwn->unit_serial)) ? wwn->unit_serial :
-                        wwn->vendor);
-        spin_unlock(&lun->lun_sep_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(dev_name);
@@ -1082,17 +1005,17 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_inst(
         struct se_portal_group *tpg;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         tpg = nacl->se_tpg;
         /* scsiInstIndex */
         ret = snprintf(page, PAGE_SIZE, "%u\n",
                         tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(inst);
@@ -1107,16 +1030,16 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_dev(
         struct se_lun *lun;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
-        lun = deve->se_lun;
+        lun = rcu_dereference(deve->se_lun);
         /* scsiDeviceIndex */
-        ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
-        spin_unlock_irq(&nacl->device_list_lock);
+        ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev);
@@ -1131,16 +1054,16 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_port(
         struct se_portal_group *tpg;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         tpg = nacl->se_tpg;
         /* scsiAuthIntrTgtPortIndex */
         ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(port);
@@ -1154,15 +1077,15 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_indx(
         struct se_dev_entry *deve;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         /* scsiAuthIntrIndex */
         ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(indx);
@@ -1176,15 +1099,15 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_dev_or_port(
         struct se_dev_entry *deve;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         /* scsiAuthIntrDevOrPort */
         ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev_or_port);
@@ -1198,15 +1121,15 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_intr_name(
         struct se_dev_entry *deve;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         /* scsiAuthIntrName */
         ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(intr_name);
@@ -1220,15 +1143,15 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_map_indx(
         struct se_dev_entry *deve;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         /* FIXME: scsiAuthIntrLunMapIndex */
         ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(map_indx);
@@ -1242,15 +1165,15 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_att_count(
         struct se_dev_entry *deve;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         /* scsiAuthIntrAttachedTimes */
         ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(att_count);
@@ -1264,15 +1187,16 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_num_cmds(
         struct se_dev_entry *deve;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         /* scsiAuthIntrOutCommands */
-        ret = snprintf(page, PAGE_SIZE, "%u\n", deve->total_cmds);
-        spin_unlock_irq(&nacl->device_list_lock);
+        ret = snprintf(page, PAGE_SIZE, "%lu\n",
+                       atomic_long_read(&deve->total_cmds));
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(num_cmds);
@@ -1286,15 +1210,16 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_read_mbytes(
         struct se_dev_entry *deve;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         /* scsiAuthIntrReadMegaBytes */
-        ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->read_bytes >> 20));
-        spin_unlock_irq(&nacl->device_list_lock);
+        ret = snprintf(page, PAGE_SIZE, "%u\n",
+                      (u32)(atomic_long_read(&deve->read_bytes) >> 20));
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(read_mbytes);
@@ -1308,15 +1233,16 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_write_mbytes(
         struct se_dev_entry *deve;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         /* scsiAuthIntrWrittenMegaBytes */
-        ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->write_bytes >> 20));
-        spin_unlock_irq(&nacl->device_list_lock);
+        ret = snprintf(page, PAGE_SIZE, "%u\n",
+                      (u32)(atomic_long_read(&deve->write_bytes) >> 20));
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(write_mbytes);
@@ -1330,15 +1256,15 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_hs_num_cmds(
         struct se_dev_entry *deve;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         /* FIXME: scsiAuthIntrHSOutCommands */
         ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(hs_num_cmds);
@@ -1352,16 +1278,16 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_creation_time(
         struct se_dev_entry *deve;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         /* scsiAuthIntrLastCreation */
         ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
                                 INITIAL_JIFFIES) * 100 / HZ));
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(creation_time);
@@ -1375,15 +1301,15 @@ static ssize_t target_stat_scsi_auth_intr_show_attr_row_status(
         struct se_dev_entry *deve;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         /* FIXME: scsiAuthIntrRowStatus */
         ret = snprintf(page, PAGE_SIZE, "Ready\n");
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(row_status);
@@ -1448,17 +1374,17 @@ static ssize_t target_stat_scsi_att_intr_port_show_attr_inst(
         struct se_portal_group *tpg;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         tpg = nacl->se_tpg;
         /* scsiInstIndex */
         ret = snprintf(page, PAGE_SIZE, "%u\n",
                         tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(inst);
@@ -1473,16 +1399,16 @@ static ssize_t target_stat_scsi_att_intr_port_show_attr_dev(
         struct se_lun *lun;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
-        lun = deve->se_lun;
+        lun = rcu_dereference(deve->se_lun);
         /* scsiDeviceIndex */
-        ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
-        spin_unlock_irq(&nacl->device_list_lock);
+        ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(dev);
@@ -1497,16 +1423,16 @@ static ssize_t target_stat_scsi_att_intr_port_show_attr_port(
         struct se_portal_group *tpg;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         tpg = nacl->se_tpg;
         /* scsiPortIndex */
         ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port);
@@ -1546,15 +1472,15 @@ static ssize_t target_stat_scsi_att_intr_port_show_attr_port_auth_indx(
         struct se_dev_entry *deve;
         ssize_t ret;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[lacl->mapped_lun];
-        if (!deve->se_lun || !deve->se_lun_acl) {
-                spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return -ENODEV;
         }
         /* scsiAttIntrPortAuthIntrIdx */
         ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
         return ret;
 }
 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_auth_indx);
diff --git a/drivers/target/target_core_tmr.c b/drivers/target/target_core_tmr.c
index a5bb0c46e57e..5b2820312310 100644
--- a/drivers/target/target_core_tmr.c
+++ b/drivers/target/target_core_tmr.c
@@ -31,7 +31,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 
 #include "target_core_internal.h"
 #include "target_core_alua.h"
@@ -115,7 +114,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) {
@@ -127,16 +126,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;
@@ -151,18 +151,18 @@ void core_tmr_abort_task(
                 cancel_work_sync(&se_cmd->work);
                 transport_wait_for_tasks(se_cmd);
 
-                target_put_sess_cmd(se_sess, se_cmd);
+                target_put_sess_cmd(se_cmd);
                 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;
 }
@@ -287,16 +287,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);
diff --git a/drivers/target/target_core_tpg.c b/drivers/target/target_core_tpg.c
index 84de757bd458..babde4ad841f 100644
--- a/drivers/target/target_core_tpg.c
+++ b/drivers/target/target_core_tpg.c
@@ -39,6 +39,7 @@
 #include <target/target_core_fabric.h>
 
 #include "target_core_internal.h"
+#include "target_core_alua.h"
 #include "target_core_pr.h"
 
 extern struct se_device *g_lun0_dev;
@@ -46,45 +47,9 @@ extern struct se_device *g_lun0_dev;
 static DEFINE_SPINLOCK(tpg_lock);
 static LIST_HEAD(tpg_list);
 
-/*      core_clear_initiator_node_from_tpg():
- *
- *
- */
-static void core_clear_initiator_node_from_tpg(
-        struct se_node_acl *nacl,
-        struct se_portal_group *tpg)
-{
-        int i;
-        struct se_dev_entry *deve;
-        struct se_lun *lun;
-
-        spin_lock_irq(&nacl->device_list_lock);
-        for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
-                deve = nacl->device_list[i];
-
-                if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
-                        continue;
-
-                if (!deve->se_lun) {
-                        pr_err("%s device entries device pointer is"
-                                " NULL, but Initiator has access.\n",
-                                tpg->se_tpg_tfo->get_fabric_name());
-                        continue;
-                }
-
-                lun = deve->se_lun;
-                spin_unlock_irq(&nacl->device_list_lock);
-                core_disable_device_list_for_node(lun, NULL, deve->mapped_lun,
-                        TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);
-
-                spin_lock_irq(&nacl->device_list_lock);
-        }
-        spin_unlock_irq(&nacl->device_list_lock);
-}
-
 /*      __core_tpg_get_initiator_node_acl():
  *
- *      spin_lock_bh(&tpg->acl_node_lock); must be held when calling
+ *      mutex_lock(&tpg->acl_node_mutex); must be held when calling
  */
 struct se_node_acl *__core_tpg_get_initiator_node_acl(
         struct se_portal_group *tpg,
@@ -110,9 +75,9 @@ struct se_node_acl *core_tpg_get_initiator_node_acl(
 {
         struct se_node_acl *acl;
 
-        spin_lock_irq(&tpg->acl_node_lock);
+        mutex_lock(&tpg->acl_node_mutex);
         acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
-        spin_unlock_irq(&tpg->acl_node_lock);
+        mutex_unlock(&tpg->acl_node_mutex);
 
         return acl;
 }
@@ -124,22 +89,20 @@ EXPORT_SYMBOL(core_tpg_get_initiator_node_acl);
  */
 void core_tpg_add_node_to_devs(
         struct se_node_acl *acl,
-        struct se_portal_group *tpg)
+        struct se_portal_group *tpg,
+        struct se_lun *lun_orig)
 {
-        int i = 0;
         u32 lun_access = 0;
         struct se_lun *lun;
         struct se_device *dev;
 
-        spin_lock(&tpg->tpg_lun_lock);
-        for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
-                lun = tpg->tpg_lun_list[i];
-                if (lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE)
+        mutex_lock(&tpg->tpg_lun_mutex);
+        hlist_for_each_entry_rcu(lun, &tpg->tpg_lun_hlist, link) {
+                if (lun_orig && lun != lun_orig)
                         continue;
 
-                spin_unlock(&tpg->tpg_lun_lock);
-
-                dev = lun->lun_se_dev;
+                dev = rcu_dereference_check(lun->lun_se_dev,
+                                            lockdep_is_held(&tpg->tpg_lun_mutex));
                 /*
                  * By default in LIO-Target $FABRIC_MOD,
                  * demo_mode_write_protect is ON, or READ_ONLY;
@@ -157,7 +120,7 @@ void core_tpg_add_node_to_devs(
                                 lun_access = TRANSPORT_LUNFLAGS_READ_WRITE;
                 }
 
-                pr_debug("TARGET_CORE[%s]->TPG[%u]_LUN[%u] - Adding %s"
+                pr_debug("TARGET_CORE[%s]->TPG[%u]_LUN[%llu] - Adding %s"
                         " access for LUN in Demo Mode\n",
                         tpg->se_tpg_tfo->get_fabric_name(),
                         tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
@@ -165,7 +128,7 @@ void core_tpg_add_node_to_devs(
                         "READ-WRITE" : "READ-ONLY");
 
                 core_enable_device_list_for_node(lun, NULL, lun->unpacked_lun,
-                                lun_access, acl, tpg);
+                                                 lun_access, acl, tpg);
                 /*
                  * Check to see if there are any existing persistent reservation
                  * APTPL pre-registrations that need to be enabled for this dynamic
@@ -173,9 +136,8 @@ void core_tpg_add_node_to_devs(
                  */
                 core_scsi3_check_aptpl_registration(dev, tpg, lun, acl,
                                                     lun->unpacked_lun);
-                spin_lock(&tpg->tpg_lun_lock);
         }
-        spin_unlock(&tpg->tpg_lun_lock);
+        mutex_unlock(&tpg->tpg_lun_mutex);
 }
 
 /*      core_set_queue_depth_for_node():
@@ -196,67 +158,63 @@ static int core_set_queue_depth_for_node(
         return 0;
 }
 
-void array_free(void *array, int n)
+static struct se_node_acl *target_alloc_node_acl(struct se_portal_group *tpg,
+                const unsigned char *initiatorname)
 {
-        void **a = array;
-        int i;
+        struct se_node_acl *acl;
 
-        for (i = 0; i < n; i++)
-                kfree(a[i]);
-        kfree(a);
-}
+        acl = kzalloc(max(sizeof(*acl), tpg->se_tpg_tfo->node_acl_size),
+                        GFP_KERNEL);
+        if (!acl)
+                return NULL;
 
-static void *array_zalloc(int n, size_t size, gfp_t flags)
-{
-        void **a;
-        int i;
+        INIT_LIST_HEAD(&acl->acl_list);
+        INIT_LIST_HEAD(&acl->acl_sess_list);
+        INIT_HLIST_HEAD(&acl->lun_entry_hlist);
+        kref_init(&acl->acl_kref);
+        init_completion(&acl->acl_free_comp);
+        spin_lock_init(&acl->nacl_sess_lock);
+        mutex_init(&acl->lun_entry_mutex);
+        atomic_set(&acl->acl_pr_ref_count, 0);
+        if (tpg->se_tpg_tfo->tpg_get_default_depth)
+                acl->queue_depth = tpg->se_tpg_tfo->tpg_get_default_depth(tpg);
+        else
+                acl->queue_depth = 1;
+        snprintf(acl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname);
+        acl->se_tpg = tpg;
+        acl->acl_index = scsi_get_new_index(SCSI_AUTH_INTR_INDEX);
 
-        a = kzalloc(n * sizeof(void*), flags);
-        if (!a)
-                return NULL;
-        for (i = 0; i < n; i++) {
-                a[i] = kzalloc(size, flags);
-                if (!a[i]) {
-                        array_free(a, n);
-                        return NULL;
-                }
-        }
-        return a;
+        tpg->se_tpg_tfo->set_default_node_attributes(acl);
+
+        if (core_set_queue_depth_for_node(tpg, acl) < 0)
+                goto out_free_acl;
+
+        return acl;
+
+out_free_acl:
+        kfree(acl);
+        return NULL;
 }
 
-/*      core_create_device_list_for_node():
- *
- *
- */
-static int core_create_device_list_for_node(struct se_node_acl *nacl)
+static void target_add_node_acl(struct se_node_acl *acl)
 {
-        struct se_dev_entry *deve;
-        int i;
-
-        nacl->device_list = array_zalloc(TRANSPORT_MAX_LUNS_PER_TPG,
-                        sizeof(struct se_dev_entry), GFP_KERNEL);
-        if (!nacl->device_list) {
-                pr_err("Unable to allocate memory for"
-                        " struct se_node_acl->device_list\n");
-                return -ENOMEM;
-        }
-        for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
-                deve = nacl->device_list[i];
-
-                atomic_set(&deve->ua_count, 0);
-                atomic_set(&deve->pr_ref_count, 0);
-                spin_lock_init(&deve->ua_lock);
-                INIT_LIST_HEAD(&deve->alua_port_list);
-                INIT_LIST_HEAD(&deve->ua_list);
-        }
+        struct se_portal_group *tpg = acl->se_tpg;
 
-        return 0;
+        mutex_lock(&tpg->acl_node_mutex);
+        list_add_tail(&acl->acl_list, &tpg->acl_node_list);
+        tpg->num_node_acls++;
+        mutex_unlock(&tpg->acl_node_mutex);
+
+        pr_debug("%s_TPG[%hu] - Added %s ACL with TCQ Depth: %d for %s"
+                " Initiator Node: %s\n",
+                tpg->se_tpg_tfo->get_fabric_name(),
+                tpg->se_tpg_tfo->tpg_get_tag(tpg),
+                acl->dynamic_node_acl ? "DYNAMIC" : "",
+                acl->queue_depth,
+                tpg->se_tpg_tfo->get_fabric_name(),
+                acl->initiatorname);
 }
 
-/*      core_tpg_check_initiator_node_acl()
- *
- *
- */
 struct se_node_acl *core_tpg_check_initiator_node_acl(
         struct se_portal_group *tpg,
         unsigned char *initiatorname)
@@ -270,35 +228,11 @@ struct se_node_acl *core_tpg_check_initiator_node_acl(
         if (!tpg->se_tpg_tfo->tpg_check_demo_mode(tpg))
                 return NULL;
 
-        acl =  tpg->se_tpg_tfo->tpg_alloc_fabric_acl(tpg);
+        acl = target_alloc_node_acl(tpg, initiatorname);
         if (!acl)
                 return NULL;
-
-        INIT_LIST_HEAD(&acl->acl_list);
-        INIT_LIST_HEAD(&acl->acl_sess_list);
-        kref_init(&acl->acl_kref);
-        init_completion(&acl->acl_free_comp);
-        spin_lock_init(&acl->device_list_lock);
-        spin_lock_init(&acl->nacl_sess_lock);
-        atomic_set(&acl->acl_pr_ref_count, 0);
-        acl->queue_depth = tpg->se_tpg_tfo->tpg_get_default_depth(tpg);
-        snprintf(acl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname);
-        acl->se_tpg = tpg;
-        acl->acl_index = scsi_get_new_index(SCSI_AUTH_INTR_INDEX);
         acl->dynamic_node_acl = 1;
 
-        tpg->se_tpg_tfo->set_default_node_attributes(acl);
-
-        if (core_create_device_list_for_node(acl) < 0) {
-                tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl);
-                return NULL;
-        }
-
-        if (core_set_queue_depth_for_node(tpg, acl) < 0) {
-                core_free_device_list_for_node(acl, tpg);
-                tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl);
-                return NULL;
-        }
         /*
          * Here we only create demo-mode MappedLUNs from the active
          * TPG LUNs if the fabric is not explicitly asking for
@@ -306,18 +240,9 @@ struct se_node_acl *core_tpg_check_initiator_node_acl(
          */
         if ((tpg->se_tpg_tfo->tpg_check_demo_mode_login_only == NULL) ||
             (tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg) != 1))
-                core_tpg_add_node_to_devs(acl, tpg);
-
-        spin_lock_irq(&tpg->acl_node_lock);
-        list_add_tail(&acl->acl_list, &tpg->acl_node_list);
-        tpg->num_node_acls++;
-        spin_unlock_irq(&tpg->acl_node_lock);
-
-        pr_debug("%s_TPG[%u] - Added DYNAMIC ACL with TCQ Depth: %d for %s"
-                " Initiator Node: %s\n", tpg->se_tpg_tfo->get_fabric_name(),
-                tpg->se_tpg_tfo->tpg_get_tag(tpg), acl->queue_depth,
-                tpg->se_tpg_tfo->get_fabric_name(), initiatorname);
+                core_tpg_add_node_to_devs(acl, tpg, NULL);
 
+        target_add_node_acl(acl);
         return acl;
 }
 EXPORT_SYMBOL(core_tpg_check_initiator_node_acl);
@@ -328,40 +253,13 @@ void core_tpg_wait_for_nacl_pr_ref(struct se_node_acl *nacl)
                 cpu_relax();
 }
 
-void core_tpg_clear_object_luns(struct se_portal_group *tpg)
-{
-        int i;
-        struct se_lun *lun;
-
-        spin_lock(&tpg->tpg_lun_lock);
-        for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
-                lun = tpg->tpg_lun_list[i];
-
-                if ((lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) ||
-                    (lun->lun_se_dev == NULL))
-                        continue;
-
-                spin_unlock(&tpg->tpg_lun_lock);
-                core_dev_del_lun(tpg, lun);
-                spin_lock(&tpg->tpg_lun_lock);
-        }
-        spin_unlock(&tpg->tpg_lun_lock);
-}
-EXPORT_SYMBOL(core_tpg_clear_object_luns);
-
-/*      core_tpg_add_initiator_node_acl():
- *
- *
- */
 struct se_node_acl *core_tpg_add_initiator_node_acl(
         struct se_portal_group *tpg,
-        struct se_node_acl *se_nacl,
-        const char *initiatorname,
-        u32 queue_depth)
+        const char *initiatorname)
 {
-        struct se_node_acl *acl = NULL;
+        struct se_node_acl *acl;
 
-        spin_lock_irq(&tpg->acl_node_lock);
+        mutex_lock(&tpg->acl_node_mutex);
         acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
         if (acl) {
                 if (acl->dynamic_node_acl) {
@@ -369,99 +267,42 @@ struct se_node_acl *core_tpg_add_initiator_node_acl(
                         pr_debug("%s_TPG[%u] - Replacing dynamic ACL"
                                 " for %s\n", tpg->se_tpg_tfo->get_fabric_name(),
                                 tpg->se_tpg_tfo->tpg_get_tag(tpg), initiatorname);
-                        spin_unlock_irq(&tpg->acl_node_lock);
-                        /*
-                         * Release the locally allocated struct se_node_acl
-                         * because * core_tpg_add_initiator_node_acl() returned
-                         * a pointer to an existing demo mode node ACL.
-                         */
-                        if (se_nacl)
-                                tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg,
-                                                        se_nacl);
-                        goto done;
+                        mutex_unlock(&tpg->acl_node_mutex);
+                        return acl;
                 }
 
                 pr_err("ACL entry for %s Initiator"
                         " Node %s already exists for TPG %u, ignoring"
                         " request.\n",  tpg->se_tpg_tfo->get_fabric_name(),
                         initiatorname, tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                spin_unlock_irq(&tpg->acl_node_lock);
+                mutex_unlock(&tpg->acl_node_mutex);
                 return ERR_PTR(-EEXIST);
         }
-        spin_unlock_irq(&tpg->acl_node_lock);
-
-        if (!se_nacl) {
-                pr_err("struct se_node_acl pointer is NULL\n");
-                return ERR_PTR(-EINVAL);
-        }
-        /*
-         * For v4.x logic the se_node_acl_s is hanging off a fabric
-         * dependent structure allocated via
-         * struct target_core_fabric_ops->fabric_make_nodeacl()
-         */
-        acl = se_nacl;
+        mutex_unlock(&tpg->acl_node_mutex);
 
-        INIT_LIST_HEAD(&acl->acl_list);
-        INIT_LIST_HEAD(&acl->acl_sess_list);
-        kref_init(&acl->acl_kref);
-        init_completion(&acl->acl_free_comp);
-        spin_lock_init(&acl->device_list_lock);
-        spin_lock_init(&acl->nacl_sess_lock);
-        atomic_set(&acl->acl_pr_ref_count, 0);
-        acl->queue_depth = queue_depth;
-        snprintf(acl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname);
-        acl->se_tpg = tpg;
-        acl->acl_index = scsi_get_new_index(SCSI_AUTH_INTR_INDEX);
-
-        tpg->se_tpg_tfo->set_default_node_attributes(acl);
-
-        if (core_create_device_list_for_node(acl) < 0) {
-                tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl);
+        acl = target_alloc_node_acl(tpg, initiatorname);
+        if (!acl)
                 return ERR_PTR(-ENOMEM);
-        }
-
-        if (core_set_queue_depth_for_node(tpg, acl) < 0) {
-                core_free_device_list_for_node(acl, tpg);
-                tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl);
-                return ERR_PTR(-EINVAL);
-        }
-
-        spin_lock_irq(&tpg->acl_node_lock);
-        list_add_tail(&acl->acl_list, &tpg->acl_node_list);
-        tpg->num_node_acls++;
-        spin_unlock_irq(&tpg->acl_node_lock);
-
-done:
-        pr_debug("%s_TPG[%hu] - Added ACL with TCQ Depth: %d for %s"
-                " Initiator Node: %s\n", tpg->se_tpg_tfo->get_fabric_name(),
-                tpg->se_tpg_tfo->tpg_get_tag(tpg), acl->queue_depth,
-                tpg->se_tpg_tfo->get_fabric_name(), initiatorname);
 
+        target_add_node_acl(acl);
         return acl;
 }
-EXPORT_SYMBOL(core_tpg_add_initiator_node_acl);
 
-/*      core_tpg_del_initiator_node_acl():
- *
- *
- */
-int core_tpg_del_initiator_node_acl(
-        struct se_portal_group *tpg,
-        struct se_node_acl *acl,
-        int force)
+void core_tpg_del_initiator_node_acl(struct se_node_acl *acl)
 {
+        struct se_portal_group *tpg = acl->se_tpg;
         LIST_HEAD(sess_list);
         struct se_session *sess, *sess_tmp;
         unsigned long flags;
         int rc;
 
-        spin_lock_irq(&tpg->acl_node_lock);
+        mutex_lock(&tpg->acl_node_mutex);
         if (acl->dynamic_node_acl) {
                 acl->dynamic_node_acl = 0;
         }
         list_del(&acl->acl_list);
         tpg->num_node_acls--;
-        spin_unlock_irq(&tpg->acl_node_lock);
+        mutex_unlock(&tpg->acl_node_mutex);
 
         spin_lock_irqsave(&acl->nacl_sess_lock, flags);
         acl->acl_stop = 1;
@@ -493,7 +334,6 @@ int core_tpg_del_initiator_node_acl(
         wait_for_completion(&acl->acl_free_comp);
 
         core_tpg_wait_for_nacl_pr_ref(acl);
-        core_clear_initiator_node_from_tpg(acl, tpg);
         core_free_device_list_for_node(acl, tpg);
 
         pr_debug("%s_TPG[%hu] - Deleted ACL with TCQ Depth: %d for %s"
@@ -501,9 +341,8 @@ int core_tpg_del_initiator_node_acl(
                 tpg->se_tpg_tfo->tpg_get_tag(tpg), acl->queue_depth,
                 tpg->se_tpg_tfo->get_fabric_name(), acl->initiatorname);
 
-        return 0;
+        kfree(acl);
 }
-EXPORT_SYMBOL(core_tpg_del_initiator_node_acl);
 
 /*      core_tpg_set_initiator_node_queue_depth():
  *
@@ -520,21 +359,21 @@ int core_tpg_set_initiator_node_queue_depth(
         unsigned long flags;
         int dynamic_acl = 0;
 
-        spin_lock_irq(&tpg->acl_node_lock);
+        mutex_lock(&tpg->acl_node_mutex);
         acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
         if (!acl) {
                 pr_err("Access Control List entry for %s Initiator"
                         " Node %s does not exists for TPG %hu, ignoring"
                         " request.\n", tpg->se_tpg_tfo->get_fabric_name(),
                         initiatorname, tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                spin_unlock_irq(&tpg->acl_node_lock);
+                mutex_unlock(&tpg->acl_node_mutex);
                 return -ENODEV;
         }
         if (acl->dynamic_node_acl) {
                 acl->dynamic_node_acl = 0;
                 dynamic_acl = 1;
         }
-        spin_unlock_irq(&tpg->acl_node_lock);
+        mutex_unlock(&tpg->acl_node_mutex);
 
         spin_lock_irqsave(&tpg->session_lock, flags);
         list_for_each_entry(sess, &tpg->tpg_sess_list, sess_list) {
@@ -550,10 +389,10 @@ int core_tpg_set_initiator_node_queue_depth(
                                 tpg->se_tpg_tfo->get_fabric_name(), initiatorname);
                         spin_unlock_irqrestore(&tpg->session_lock, flags);
 
-                        spin_lock_irq(&tpg->acl_node_lock);
+                        mutex_lock(&tpg->acl_node_mutex);
                         if (dynamic_acl)
                                 acl->dynamic_node_acl = 1;
-                        spin_unlock_irq(&tpg->acl_node_lock);
+                        mutex_unlock(&tpg->acl_node_mutex);
                         return -EEXIST;
                 }
                 /*
@@ -588,10 +427,10 @@ int core_tpg_set_initiator_node_queue_depth(
                 if (init_sess)
                         tpg->se_tpg_tfo->close_session(init_sess);
 
-                spin_lock_irq(&tpg->acl_node_lock);
+                mutex_lock(&tpg->acl_node_mutex);
                 if (dynamic_acl)
                         acl->dynamic_node_acl = 1;
-                spin_unlock_irq(&tpg->acl_node_lock);
+                mutex_unlock(&tpg->acl_node_mutex);
                 return -EINVAL;
         }
         spin_unlock_irqrestore(&tpg->session_lock, flags);
@@ -607,10 +446,10 @@ int core_tpg_set_initiator_node_queue_depth(
                 initiatorname, tpg->se_tpg_tfo->get_fabric_name(),
                 tpg->se_tpg_tfo->tpg_get_tag(tpg));
 
-        spin_lock_irq(&tpg->acl_node_lock);
+        mutex_lock(&tpg->acl_node_mutex);
         if (dynamic_acl)
                 acl->dynamic_node_acl = 1;
-        spin_unlock_irq(&tpg->acl_node_lock);
+        mutex_unlock(&tpg->acl_node_mutex);
 
         return 0;
 }
@@ -646,78 +485,54 @@ static void core_tpg_lun_ref_release(struct percpu_ref *ref)
         complete(&lun->lun_ref_comp);
 }
 
-static int core_tpg_setup_virtual_lun0(struct se_portal_group *se_tpg)
-{
-        /* Set in core_dev_setup_virtual_lun0() */
-        struct se_device *dev = g_lun0_dev;
-        struct se_lun *lun = &se_tpg->tpg_virt_lun0;
-        u32 lun_access = TRANSPORT_LUNFLAGS_READ_ONLY;
-        int ret;
-
-        lun->unpacked_lun = 0;
-        lun->lun_status = TRANSPORT_LUN_STATUS_FREE;
-        atomic_set(&lun->lun_acl_count, 0);
-        init_completion(&lun->lun_shutdown_comp);
-        INIT_LIST_HEAD(&lun->lun_acl_list);
-        spin_lock_init(&lun->lun_acl_lock);
-        spin_lock_init(&lun->lun_sep_lock);
-        init_completion(&lun->lun_ref_comp);
-
-        ret = core_tpg_add_lun(se_tpg, lun, lun_access, dev);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
 int core_tpg_register(
-        const struct target_core_fabric_ops *tfo,
         struct se_wwn *se_wwn,
         struct se_portal_group *se_tpg,
-        void *tpg_fabric_ptr,
-        int se_tpg_type)
+        int proto_id)
 {
-        struct se_lun *lun;
-        u32 i;
-
-        se_tpg->tpg_lun_list = array_zalloc(TRANSPORT_MAX_LUNS_PER_TPG,
-                        sizeof(struct se_lun), GFP_KERNEL);
-        if (!se_tpg->tpg_lun_list) {
-                pr_err("Unable to allocate struct se_portal_group->"
-                                "tpg_lun_list\n");
-                return -ENOMEM;
-        }
+        int ret;
+
+        if (!se_tpg)
+                return -EINVAL;
+        /*
+         * For the typical case where core_tpg_register() is called by a
+         * fabric driver from target_core_fabric_ops->fabric_make_tpg()
+         * configfs context, use the original tf_ops pointer already saved
+         * by target-core in target_fabric_make_wwn().
+         *
+         * Otherwise, for special cases like iscsi-target discovery TPGs
+         * the caller is responsible for setting ->se_tpg_tfo ahead of
+         * calling core_tpg_register().
+         */
+        if (se_wwn)
+                se_tpg->se_tpg_tfo = se_wwn->wwn_tf->tf_ops;
 
-        for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
-                lun = se_tpg->tpg_lun_list[i];
-                lun->unpacked_lun = i;
-                lun->lun_link_magic = SE_LUN_LINK_MAGIC;
-                lun->lun_status = TRANSPORT_LUN_STATUS_FREE;
-                atomic_set(&lun->lun_acl_count, 0);
-                init_completion(&lun->lun_shutdown_comp);
-                INIT_LIST_HEAD(&lun->lun_acl_list);
-                spin_lock_init(&lun->lun_acl_lock);
-                spin_lock_init(&lun->lun_sep_lock);
-                init_completion(&lun->lun_ref_comp);
+        if (!se_tpg->se_tpg_tfo) {
+                pr_err("Unable to locate se_tpg->se_tpg_tfo pointer\n");
+                return -EINVAL;
         }
 
-        se_tpg->se_tpg_type = se_tpg_type;
-        se_tpg->se_tpg_fabric_ptr = tpg_fabric_ptr;
-        se_tpg->se_tpg_tfo = tfo;
+        INIT_HLIST_HEAD(&se_tpg->tpg_lun_hlist);
+        se_tpg->proto_id = proto_id;
         se_tpg->se_tpg_wwn = se_wwn;
         atomic_set(&se_tpg->tpg_pr_ref_count, 0);
         INIT_LIST_HEAD(&se_tpg->acl_node_list);
         INIT_LIST_HEAD(&se_tpg->se_tpg_node);
         INIT_LIST_HEAD(&se_tpg->tpg_sess_list);
-        spin_lock_init(&se_tpg->acl_node_lock);
         spin_lock_init(&se_tpg->session_lock);
-        spin_lock_init(&se_tpg->tpg_lun_lock);
-
-        if (se_tpg->se_tpg_type == TRANSPORT_TPG_TYPE_NORMAL) {
-                if (core_tpg_setup_virtual_lun0(se_tpg) < 0) {
-                        array_free(se_tpg->tpg_lun_list,
-                                   TRANSPORT_MAX_LUNS_PER_TPG);
-                        return -ENOMEM;
+        mutex_init(&se_tpg->tpg_lun_mutex);
+        mutex_init(&se_tpg->acl_node_mutex);
+
+        if (se_tpg->proto_id >= 0) {
+                se_tpg->tpg_virt_lun0 = core_tpg_alloc_lun(se_tpg, 0);
+                if (IS_ERR(se_tpg->tpg_virt_lun0))
+                        return PTR_ERR(se_tpg->tpg_virt_lun0);
+
+                ret = core_tpg_add_lun(se_tpg, se_tpg->tpg_virt_lun0,
+                                TRANSPORT_LUNFLAGS_READ_ONLY, g_lun0_dev);
+                if (ret < 0) {
+                        kfree(se_tpg->tpg_virt_lun0);
+                        return ret;
                 }
         }
 
@@ -725,11 +540,11 @@ int core_tpg_register(
         list_add_tail(&se_tpg->se_tpg_node, &tpg_list);
         spin_unlock_bh(&tpg_lock);
 
-        pr_debug("TARGET_CORE[%s]: Allocated %s struct se_portal_group for"
-                " endpoint: %s, Portal Tag: %u\n", tfo->get_fabric_name(),
-                (se_tpg->se_tpg_type == TRANSPORT_TPG_TYPE_NORMAL) ?
-                "Normal" : "Discovery", (tfo->tpg_get_wwn(se_tpg) == NULL) ?
-                "None" : tfo->tpg_get_wwn(se_tpg), tfo->tpg_get_tag(se_tpg));
+        pr_debug("TARGET_CORE[%s]: Allocated portal_group for endpoint: %s, "
+                 "Proto: %d, Portal Tag: %u\n", se_tpg->se_tpg_tfo->get_fabric_name(),
+                se_tpg->se_tpg_tfo->tpg_get_wwn(se_tpg) ?
+                se_tpg->se_tpg_tfo->tpg_get_wwn(se_tpg) : NULL,
+                se_tpg->proto_id, se_tpg->se_tpg_tfo->tpg_get_tag(se_tpg));
 
         return 0;
 }
@@ -737,14 +552,14 @@ EXPORT_SYMBOL(core_tpg_register);
 
 int core_tpg_deregister(struct se_portal_group *se_tpg)
 {
+        const struct target_core_fabric_ops *tfo = se_tpg->se_tpg_tfo;
         struct se_node_acl *nacl, *nacl_tmp;
+        LIST_HEAD(node_list);
 
-        pr_debug("TARGET_CORE[%s]: Deallocating %s struct se_portal_group"
-                " for endpoint: %s Portal Tag %u\n",
-                (se_tpg->se_tpg_type == TRANSPORT_TPG_TYPE_NORMAL) ?
-                "Normal" : "Discovery", se_tpg->se_tpg_tfo->get_fabric_name(),
-                se_tpg->se_tpg_tfo->tpg_get_wwn(se_tpg),
-                se_tpg->se_tpg_tfo->tpg_get_tag(se_tpg));
+        pr_debug("TARGET_CORE[%s]: Deallocating portal_group for endpoint: %s, "
+                 "Proto: %d, Portal Tag: %u\n", tfo->get_fabric_name(),
+                tfo->tpg_get_wwn(se_tpg) ? tfo->tpg_get_wwn(se_tpg) : NULL,
+                se_tpg->proto_id, tfo->tpg_get_tag(se_tpg));
 
         spin_lock_bh(&tpg_lock);
         list_del(&se_tpg->se_tpg_node);
@@ -752,61 +567,56 @@ int core_tpg_deregister(struct se_portal_group *se_tpg)
 
         while (atomic_read(&se_tpg->tpg_pr_ref_count) != 0)
                 cpu_relax();
+
+        mutex_lock(&se_tpg->acl_node_mutex);
+        list_splice_init(&se_tpg->acl_node_list, &node_list);
+        mutex_unlock(&se_tpg->acl_node_mutex);
         /*
          * Release any remaining demo-mode generated se_node_acl that have
          * not been released because of TFO->tpg_check_demo_mode_cache() == 1
          * in transport_deregister_session().
          */
-        spin_lock_irq(&se_tpg->acl_node_lock);
-        list_for_each_entry_safe(nacl, nacl_tmp, &se_tpg->acl_node_list,
-                        acl_list) {
+        list_for_each_entry_safe(nacl, nacl_tmp, &node_list, acl_list) {
                 list_del(&nacl->acl_list);
                 se_tpg->num_node_acls--;
-                spin_unlock_irq(&se_tpg->acl_node_lock);
 
                 core_tpg_wait_for_nacl_pr_ref(nacl);
                 core_free_device_list_for_node(nacl, se_tpg);
-                se_tpg->se_tpg_tfo->tpg_release_fabric_acl(se_tpg, nacl);
-
-                spin_lock_irq(&se_tpg->acl_node_lock);
+                kfree(nacl);
         }
-        spin_unlock_irq(&se_tpg->acl_node_lock);
 
-        if (se_tpg->se_tpg_type == TRANSPORT_TPG_TYPE_NORMAL)
-                core_tpg_remove_lun(se_tpg, &se_tpg->tpg_virt_lun0);
+        if (se_tpg->proto_id >= 0) {
+                core_tpg_remove_lun(se_tpg, se_tpg->tpg_virt_lun0);
+                kfree_rcu(se_tpg->tpg_virt_lun0, rcu_head);
+        }
 
-        se_tpg->se_tpg_fabric_ptr = NULL;
-        array_free(se_tpg->tpg_lun_list, TRANSPORT_MAX_LUNS_PER_TPG);
         return 0;
 }
 EXPORT_SYMBOL(core_tpg_deregister);
 
 struct se_lun *core_tpg_alloc_lun(
         struct se_portal_group *tpg,
-        u32 unpacked_lun)
+        u64 unpacked_lun)
 {
         struct se_lun *lun;
 
-        if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
-                pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS_PER_TPG"
-                        "-1: %u for Target Portal Group: %u\n",
-                        tpg->se_tpg_tfo->get_fabric_name(),
-                        unpacked_lun, TRANSPORT_MAX_LUNS_PER_TPG-1,
-                        tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                return ERR_PTR(-EOVERFLOW);
-        }
-
-        spin_lock(&tpg->tpg_lun_lock);
-        lun = tpg->tpg_lun_list[unpacked_lun];
-        if (lun->lun_status == TRANSPORT_LUN_STATUS_ACTIVE) {
-                pr_err("TPG Logical Unit Number: %u is already active"
-                        " on %s Target Portal Group: %u, ignoring request.\n",
-                        unpacked_lun, tpg->se_tpg_tfo->get_fabric_name(),
-                        tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                spin_unlock(&tpg->tpg_lun_lock);
-                return ERR_PTR(-EINVAL);
+        lun = kzalloc(sizeof(*lun), GFP_KERNEL);
+        if (!lun) {
+                pr_err("Unable to allocate se_lun memory\n");
+                return ERR_PTR(-ENOMEM);
         }
-        spin_unlock(&tpg->tpg_lun_lock);
+        lun->unpacked_lun = unpacked_lun;
+        lun->lun_link_magic = SE_LUN_LINK_MAGIC;
+        atomic_set(&lun->lun_acl_count, 0);
+        init_completion(&lun->lun_ref_comp);
+        INIT_LIST_HEAD(&lun->lun_deve_list);
+        INIT_LIST_HEAD(&lun->lun_dev_link);
+        atomic_set(&lun->lun_tg_pt_secondary_offline, 0);
+        spin_lock_init(&lun->lun_deve_lock);
+        mutex_init(&lun->lun_tg_pt_md_mutex);
+        INIT_LIST_HEAD(&lun->lun_tg_pt_gp_link);
+        spin_lock_init(&lun->lun_tg_pt_gp_lock);
+        lun->lun_tpg = tpg;
 
         return lun;
 }
@@ -822,34 +632,70 @@ int core_tpg_add_lun(
         ret = percpu_ref_init(&lun->lun_ref, core_tpg_lun_ref_release, 0,
                               GFP_KERNEL);
         if (ret < 0)
-                return ret;
+                goto out;
 
-        ret = core_dev_export(dev, tpg, lun);
-        if (ret < 0) {
-                percpu_ref_exit(&lun->lun_ref);
-                return ret;
-        }
+        ret = core_alloc_rtpi(lun, dev);
+        if (ret)
+                goto out_kill_ref;
+
+        if (!(dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH) &&
+            !(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE))
+                target_attach_tg_pt_gp(lun, dev->t10_alua.default_tg_pt_gp);
+
+        mutex_lock(&tpg->tpg_lun_mutex);
+
+        spin_lock(&dev->se_port_lock);
+        lun->lun_index = dev->dev_index;
+        rcu_assign_pointer(lun->lun_se_dev, dev);
+        dev->export_count++;
+        list_add_tail(&lun->lun_dev_link, &dev->dev_sep_list);
+        spin_unlock(&dev->se_port_lock);
 
-        spin_lock(&tpg->tpg_lun_lock);
         lun->lun_access = lun_access;
-        lun->lun_status = TRANSPORT_LUN_STATUS_ACTIVE;
-        spin_unlock(&tpg->tpg_lun_lock);
+        if (!(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE))
+                hlist_add_head_rcu(&lun->link, &tpg->tpg_lun_hlist);
+        mutex_unlock(&tpg->tpg_lun_mutex);
 
         return 0;
+
+out_kill_ref:
+        percpu_ref_exit(&lun->lun_ref);
+out:
+        return ret;
 }
 
 void core_tpg_remove_lun(
         struct se_portal_group *tpg,
         struct se_lun *lun)
 {
+        /*
+         * rcu_dereference_raw protected by se_lun->lun_group symlink
+         * reference to se_device->dev_group.
+         */
+        struct se_device *dev = rcu_dereference_raw(lun->lun_se_dev);
+
         core_clear_lun_from_tpg(lun, tpg);
+        /*
+         * Wait for any active I/O references to percpu se_lun->lun_ref to
+         * be released.  Also, se_lun->lun_ref is now used by PR and ALUA
+         * logic when referencing a remote target port during ALL_TGT_PT=1
+         * and generating UNIT_ATTENTIONs for ALUA access state transition.
+         */
         transport_clear_lun_ref(lun);
 
-        core_dev_unexport(lun->lun_se_dev, tpg, lun);
+        mutex_lock(&tpg->tpg_lun_mutex);
+        if (lun->lun_se_dev) {
+                target_detach_tg_pt_gp(lun);
 
-        spin_lock(&tpg->tpg_lun_lock);
-        lun->lun_status = TRANSPORT_LUN_STATUS_FREE;
-        spin_unlock(&tpg->tpg_lun_lock);
+                spin_lock(&dev->se_port_lock);
+                list_del(&lun->lun_dev_link);
+                dev->export_count--;
+                rcu_assign_pointer(lun->lun_se_dev, NULL);
+                spin_unlock(&dev->se_port_lock);
+        }
+        if (!(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE))
+                hlist_del_rcu(&lun->link);
+        mutex_unlock(&tpg->tpg_lun_mutex);
 
         percpu_ref_exit(&lun->lun_ref);
 }
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index cd3bfc16d25f..ce8574b7220c 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -43,7 +43,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 
 #include "target_core_internal.h"
 #include "target_core_alua.h"
@@ -60,7 +59,6 @@ struct kmem_cache *t10_pr_reg_cache;
 struct kmem_cache *t10_alua_lu_gp_cache;
 struct kmem_cache *t10_alua_lu_gp_mem_cache;
 struct kmem_cache *t10_alua_tg_pt_gp_cache;
-struct kmem_cache *t10_alua_tg_pt_gp_mem_cache;
 struct kmem_cache *t10_alua_lba_map_cache;
 struct kmem_cache *t10_alua_lba_map_mem_cache;
 
@@ -119,16 +117,6 @@ int init_se_kmem_caches(void)
                                 "cache failed\n");
                 goto out_free_lu_gp_mem_cache;
         }
-        t10_alua_tg_pt_gp_mem_cache = kmem_cache_create(
-                        "t10_alua_tg_pt_gp_mem_cache",
-                        sizeof(struct t10_alua_tg_pt_gp_member),
-                        __alignof__(struct t10_alua_tg_pt_gp_member),
-                        0, NULL);
-        if (!t10_alua_tg_pt_gp_mem_cache) {
-                pr_err("kmem_cache_create() for t10_alua_tg_pt_gp_"
-                                "mem_t failed\n");
-                goto out_free_tg_pt_gp_cache;
-        }
         t10_alua_lba_map_cache = kmem_cache_create(
                         "t10_alua_lba_map_cache",
                         sizeof(struct t10_alua_lba_map),
@@ -136,7 +124,7 @@ int init_se_kmem_caches(void)
         if (!t10_alua_lba_map_cache) {
                 pr_err("kmem_cache_create() for t10_alua_lba_map_"
                                 "cache failed\n");
-                goto out_free_tg_pt_gp_mem_cache;
+                goto out_free_tg_pt_gp_cache;
         }
         t10_alua_lba_map_mem_cache = kmem_cache_create(
                         "t10_alua_lba_map_mem_cache",
@@ -159,8 +147,6 @@ out_free_lba_map_mem_cache:
         kmem_cache_destroy(t10_alua_lba_map_mem_cache);
 out_free_lba_map_cache:
         kmem_cache_destroy(t10_alua_lba_map_cache);
-out_free_tg_pt_gp_mem_cache:
-        kmem_cache_destroy(t10_alua_tg_pt_gp_mem_cache);
 out_free_tg_pt_gp_cache:
         kmem_cache_destroy(t10_alua_tg_pt_gp_cache);
 out_free_lu_gp_mem_cache:
@@ -186,7 +172,6 @@ void release_se_kmem_caches(void)
         kmem_cache_destroy(t10_alua_lu_gp_cache);
         kmem_cache_destroy(t10_alua_lu_gp_mem_cache);
         kmem_cache_destroy(t10_alua_tg_pt_gp_cache);
-        kmem_cache_destroy(t10_alua_tg_pt_gp_mem_cache);
         kmem_cache_destroy(t10_alua_lba_map_cache);
         kmem_cache_destroy(t10_alua_lba_map_mem_cache);
 }
@@ -406,12 +391,6 @@ EXPORT_SYMBOL(target_get_session);
 
 void target_put_session(struct se_session *se_sess)
 {
-        struct se_portal_group *tpg = se_sess->se_tpg;
-
-        if (tpg->se_tpg_tfo->put_session != NULL) {
-                tpg->se_tpg_tfo->put_session(se_sess);
-                return;
-        }
         kref_put(&se_sess->sess_kref, target_release_session);
 }
 EXPORT_SYMBOL(target_put_session);
@@ -498,7 +477,7 @@ void transport_deregister_session(struct se_session *se_sess)
         const struct target_core_fabric_ops *se_tfo;
         struct se_node_acl *se_nacl;
         unsigned long flags;
-        bool comp_nacl = true;
+        bool comp_nacl = true, drop_nacl = false;
 
         if (!se_tpg) {
                 transport_free_session(se_sess);
@@ -518,22 +497,22 @@ void transport_deregister_session(struct se_session *se_sess)
          */
         se_nacl = se_sess->se_node_acl;
 
-        spin_lock_irqsave(&se_tpg->acl_node_lock, flags);
+        mutex_lock(&se_tpg->acl_node_mutex);
         if (se_nacl && se_nacl->dynamic_node_acl) {
                 if (!se_tfo->tpg_check_demo_mode_cache(se_tpg)) {
                         list_del(&se_nacl->acl_list);
                         se_tpg->num_node_acls--;
-                        spin_unlock_irqrestore(&se_tpg->acl_node_lock, flags);
-                        core_tpg_wait_for_nacl_pr_ref(se_nacl);
-                        core_free_device_list_for_node(se_nacl, se_tpg);
-                        se_tfo->tpg_release_fabric_acl(se_tpg, se_nacl);
-
-                        comp_nacl = false;
-                        spin_lock_irqsave(&se_tpg->acl_node_lock, flags);
+                        drop_nacl = true;
                 }
         }
-        spin_unlock_irqrestore(&se_tpg->acl_node_lock, flags);
+        mutex_unlock(&se_tpg->acl_node_mutex);
 
+        if (drop_nacl) {
+                core_tpg_wait_for_nacl_pr_ref(se_nacl);
+                core_free_device_list_for_node(se_nacl, se_tpg);
+                kfree(se_nacl);
+                comp_nacl = false;
+        }
         pr_debug("TARGET_CORE[%s]: Deregistered fabric_sess\n",
                 se_tpg->se_tpg_tfo->get_fabric_name());
         /*
@@ -593,9 +572,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);
 
@@ -1148,6 +1126,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,
@@ -1274,11 +1254,7 @@ target_setup_cmd_from_cdb(struct se_cmd *cmd, unsigned char *cdb)
                 return ret;
 
         cmd->se_cmd_flags |= SCF_SUPPORTED_SAM_OPCODE;
-
-        spin_lock(&cmd->se_lun->lun_sep_lock);
-        if (cmd->se_lun->lun_sep)
-                cmd->se_lun->lun_sep->sep_stats.cmd_pdus++;
-        spin_unlock(&cmd->se_lun->lun_sep_lock);
+        atomic_long_inc(&cmd->se_lun->lun_stats.cmd_pdus);
         return 0;
 }
 EXPORT_SYMBOL(target_setup_cmd_from_cdb);
@@ -1346,11 +1322,9 @@ transport_generic_map_mem_to_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
 
         cmd->t_data_sg = sgl;
         cmd->t_data_nents = sgl_count;
+        cmd->t_bidi_data_sg = sgl_bidi;
+        cmd->t_bidi_data_nents = sgl_bidi_count;
 
-        if (sgl_bidi && sgl_bidi_count) {
-                cmd->t_bidi_data_sg = sgl_bidi;
-                cmd->t_bidi_data_nents = sgl_bidi_count;
-        }
         cmd->se_cmd_flags |= SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC;
         return 0;
 }
@@ -1375,6 +1349,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.
@@ -1383,7 +1359,7 @@ transport_generic_map_mem_to_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
  * assumes internal allocation of fabric payload buffer by target-core.
  */
 int target_submit_cmd_map_sgls(struct se_cmd *se_cmd, struct se_session *se_sess,
-                unsigned char *cdb, unsigned char *sense, u32 unpacked_lun,
+                unsigned char *cdb, unsigned char *sense, u64 unpacked_lun,
                 u32 data_length, int task_attr, int data_dir, int flags,
                 struct scatterlist *sgl, u32 sgl_count,
                 struct scatterlist *sgl_bidi, u32 sgl_bidi_count,
@@ -1412,7 +1388,7 @@ int target_submit_cmd_map_sgls(struct se_cmd *se_cmd, struct se_session *se_sess
          * for fabrics using TARGET_SCF_ACK_KREF that expect a second
          * kref_put() to happen during fabric packet acknowledgement.
          */
-        ret = target_get_sess_cmd(se_sess, se_cmd, (flags & TARGET_SCF_ACK_KREF));
+        ret = target_get_sess_cmd(se_cmd, flags & TARGET_SCF_ACK_KREF);
         if (ret)
                 return ret;
         /*
@@ -1426,7 +1402,7 @@ int target_submit_cmd_map_sgls(struct se_cmd *se_cmd, struct se_session *se_sess
         rc = transport_lookup_cmd_lun(se_cmd, unpacked_lun);
         if (rc) {
                 transport_send_check_condition_and_sense(se_cmd, rc, 0);
-                target_put_sess_cmd(se_sess, se_cmd);
+                target_put_sess_cmd(se_cmd);
                 return 0;
         }
 
@@ -1443,6 +1419,7 @@ int target_submit_cmd_map_sgls(struct se_cmd *se_cmd, struct se_session *se_sess
         if (sgl_prot_count) {
                 se_cmd->t_prot_sg = sgl_prot;
                 se_cmd->t_prot_nents = sgl_prot_count;
+                se_cmd->se_cmd_flags |= SCF_PASSTHROUGH_PROT_SG_TO_MEM_NOALLOC;
         }
 
         /*
@@ -1506,6 +1483,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.
@@ -1516,7 +1495,7 @@ EXPORT_SYMBOL(target_submit_cmd_map_sgls);
  * It also assumes interal target core SGL memory allocation.
  */
 int target_submit_cmd(struct se_cmd *se_cmd, struct se_session *se_sess,
-                unsigned char *cdb, unsigned char *sense, u32 unpacked_lun,
+                unsigned char *cdb, unsigned char *sense, u64 unpacked_lun,
                 u32 data_length, int task_attr, int data_dir, int flags)
 {
         return target_submit_cmd_map_sgls(se_cmd, se_sess, cdb, sense,
@@ -1553,7 +1532,7 @@ static void target_complete_tmr_failure(struct work_struct *work)
  **/
 
 int target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess,
-                unsigned char *sense, u32 unpacked_lun,
+                unsigned char *sense, u64 unpacked_lun,
                 void *fabric_tmr_ptr, unsigned char tm_type,
                 gfp_t gfp, unsigned int tag, int flags)
 {
@@ -1577,7 +1556,7 @@ int target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess,
                 se_cmd->se_tmr_req->ref_task_tag = tag;
 
         /* See target_submit_cmd for commentary */
-        ret = target_get_sess_cmd(se_sess, se_cmd, (flags & TARGET_SCF_ACK_KREF));
+        ret = target_get_sess_cmd(se_cmd, flags & TARGET_SCF_ACK_KREF);
         if (ret) {
                 core_tmr_release_req(se_cmd->se_tmr_req);
                 return ret;
@@ -1633,9 +1612,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);
@@ -1692,13 +1670,13 @@ void transport_generic_request_failure(struct se_cmd *cmd,
                  * See spc4r17, section 7.4.6 Control Mode Page, Table 349
                  */
                 if (cmd->se_sess &&
-                    cmd->se_dev->dev_attrib.emulate_ua_intlck_ctrl == 2)
-                        core_scsi3_ua_allocate(cmd->se_sess->se_node_acl,
-                                cmd->orig_fe_lun, 0x2C,
-                                ASCQ_2CH_PREVIOUS_RESERVATION_CONFLICT_STATUS);
-
+                    cmd->se_dev->dev_attrib.emulate_ua_intlck_ctrl == 2) {
+                        target_ua_allocate_lun(cmd->se_sess->se_node_acl,
+                                               cmd->orig_fe_lun, 0x2C,
+                                        ASCQ_2CH_PREVIOUS_RESERVATION_CONFLICT_STATUS);
+                }
                 trace_target_cmd_complete(cmd);
-                ret = cmd->se_tfo-> queue_status(cmd);
+                ret = cmd->se_tfo->queue_status(cmd);
                 if (ret == -EAGAIN || ret == -ENOMEM)
                         goto queue_full;
                 goto check_stop;
@@ -1759,8 +1737,8 @@ static int target_write_prot_action(struct se_cmd *cmd)
                         break;
 
                 sectors = cmd->data_length >> ilog2(cmd->se_dev->dev_attrib.block_size);
-                cmd->pi_err = sbc_dif_verify_write(cmd, cmd->t_task_lba,
-                                                   sectors, 0, NULL, 0);
+                cmd->pi_err = sbc_dif_verify(cmd, cmd->t_task_lba,
+                                             sectors, 0, cmd->t_prot_sg, 0);
                 if (unlikely(cmd->pi_err)) {
                         spin_lock_irq(&cmd->t_state_lock);
                         cmd->transport_state &= ~(CMD_T_BUSY|CMD_T_SENT);
@@ -1843,9 +1821,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);
@@ -1984,16 +1961,17 @@ static void transport_handle_queue_full(
 
 static bool target_read_prot_action(struct se_cmd *cmd)
 {
-        sense_reason_t rc;
-
         switch (cmd->prot_op) {
         case TARGET_PROT_DIN_STRIP:
                 if (!(cmd->se_sess->sup_prot_ops & TARGET_PROT_DIN_STRIP)) {
-                        rc = sbc_dif_read_strip(cmd);
-                        if (rc) {
-                                cmd->pi_err = rc;
+                        u32 sectors = cmd->data_length >>
+                                  ilog2(cmd->se_dev->dev_attrib.block_size);
+
+                        cmd->pi_err = sbc_dif_verify(cmd, cmd->t_task_lba,
+                                                     sectors, 0, cmd->t_prot_sg,
+                                                     0);
+                        if (cmd->pi_err)
                                 return true;
-                        }
                 }
                 break;
         case TARGET_PROT_DIN_INSERT:
@@ -2072,12 +2050,8 @@ static void target_complete_ok_work(struct work_struct *work)
 queue_rsp:
         switch (cmd->data_direction) {
         case DMA_FROM_DEVICE:
-                spin_lock(&cmd->se_lun->lun_sep_lock);
-                if (cmd->se_lun->lun_sep) {
-                        cmd->se_lun->lun_sep->sep_stats.tx_data_octets +=
-                                        cmd->data_length;
-                }
-                spin_unlock(&cmd->se_lun->lun_sep_lock);
+                atomic_long_add(cmd->data_length,
+                                &cmd->se_lun->lun_stats.tx_data_octets);
                 /*
                  * Perform READ_STRIP of PI using software emulation when
                  * backend had PI enabled, if the transport will not be
@@ -2100,22 +2074,14 @@ queue_rsp:
                         goto queue_full;
                 break;
         case DMA_TO_DEVICE:
-                spin_lock(&cmd->se_lun->lun_sep_lock);
-                if (cmd->se_lun->lun_sep) {
-                        cmd->se_lun->lun_sep->sep_stats.rx_data_octets +=
-                                cmd->data_length;
-                }
-                spin_unlock(&cmd->se_lun->lun_sep_lock);
+                atomic_long_add(cmd->data_length,
+                                &cmd->se_lun->lun_stats.rx_data_octets);
                 /*
                  * Check if we need to send READ payload for BIDI-COMMAND
                  */
                 if (cmd->se_cmd_flags & SCF_BIDI) {
-                        spin_lock(&cmd->se_lun->lun_sep_lock);
-                        if (cmd->se_lun->lun_sep) {
-                                cmd->se_lun->lun_sep->sep_stats.tx_data_octets +=
-                                        cmd->data_length;
-                        }
-                        spin_unlock(&cmd->se_lun->lun_sep_lock);
+                        atomic_long_add(cmd->data_length,
+                                        &cmd->se_lun->lun_stats.tx_data_octets);
                         ret = cmd->se_tfo->queue_data_in(cmd);
                         if (ret == -EAGAIN || ret == -ENOMEM)
                                 goto queue_full;
@@ -2172,6 +2138,12 @@ static inline void transport_reset_sgl_orig(struct se_cmd *cmd)
 
 static inline void transport_free_pages(struct se_cmd *cmd)
 {
+        if (!(cmd->se_cmd_flags & SCF_PASSTHROUGH_PROT_SG_TO_MEM_NOALLOC)) {
+                transport_free_sgl(cmd->t_prot_sg, cmd->t_prot_nents);
+                cmd->t_prot_sg = NULL;
+                cmd->t_prot_nents = 0;
+        }
+
         if (cmd->se_cmd_flags & SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC) {
                 /*
                  * Release special case READ buffer payload required for
@@ -2195,10 +2167,6 @@ static inline void transport_free_pages(struct se_cmd *cmd)
         transport_free_sgl(cmd->t_bidi_data_sg, cmd->t_bidi_data_nents);
         cmd->t_bidi_data_sg = NULL;
         cmd->t_bidi_data_nents = 0;
-
-        transport_free_sgl(cmd->t_prot_sg, cmd->t_prot_nents);
-        cmd->t_prot_sg = NULL;
-        cmd->t_prot_nents = 0;
 }
 
 /**
@@ -2220,7 +2188,7 @@ static int transport_release_cmd(struct se_cmd *cmd)
          * If this cmd has been setup with target_get_sess_cmd(), drop
          * the kref and call ->release_cmd() in kref callback.
          */
-        return target_put_sess_cmd(cmd->se_sess, cmd);
+        return target_put_sess_cmd(cmd);
 }
 
 /**
@@ -2337,6 +2305,14 @@ transport_generic_new_cmd(struct se_cmd *cmd)
         int ret = 0;
         bool zero_flag = !(cmd->se_cmd_flags & SCF_SCSI_DATA_CDB);
 
+        if (cmd->prot_op != TARGET_PROT_NORMAL &&
+            !(cmd->se_cmd_flags & SCF_PASSTHROUGH_PROT_SG_TO_MEM_NOALLOC)) {
+                ret = target_alloc_sgl(&cmd->t_prot_sg, &cmd->t_prot_nents,
+                                       cmd->prot_length, true);
+                if (ret < 0)
+                        return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+        }
+
         /*
          * Determine is the TCM fabric module has already allocated physical
          * memory, and is directly calling transport_generic_map_mem_to_cmd()
@@ -2362,14 +2338,6 @@ transport_generic_new_cmd(struct se_cmd *cmd)
                                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
                 }
 
-                if (cmd->prot_op != TARGET_PROT_NORMAL) {
-                        ret = target_alloc_sgl(&cmd->t_prot_sg,
-                                               &cmd->t_prot_nents,
-                                               cmd->prot_length, true);
-                        if (ret < 0)
-                                return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
-                }
-
                 ret = target_alloc_sgl(&cmd->t_data_sg, &cmd->t_data_nents,
                                        cmd->data_length, zero_flag);
                 if (ret < 0)
@@ -2464,13 +2432,12 @@ int transport_generic_free_cmd(struct se_cmd *cmd, int wait_for_tasks)
 EXPORT_SYMBOL(transport_generic_free_cmd);
 
 /* target_get_sess_cmd - Add command to active ->sess_cmd_list
- * @se_sess:    session to reference
  * @se_cmd:     command descriptor to add
  * @ack_kref:   Signal that fabric will perform an ack target_put_sess_cmd()
  */
-int target_get_sess_cmd(struct se_session *se_sess, struct se_cmd *se_cmd,
-                               bool ack_kref)
+int target_get_sess_cmd(struct se_cmd *se_cmd, bool ack_kref)
 {
+        struct se_session *se_sess = se_cmd->se_sess;
         unsigned long flags;
         int ret = 0;
 
@@ -2492,7 +2459,7 @@ out:
         spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
 
         if (ret && ack_kref)
-                target_put_sess_cmd(se_sess, se_cmd);
+                target_put_sess_cmd(se_cmd);
 
         return ret;
 }
@@ -2521,11 +2488,12 @@ static void target_release_cmd_kref(struct kref *kref)
 }
 
 /* target_put_sess_cmd - Check for active I/O shutdown via kref_put
- * @se_sess:    session to reference
  * @se_cmd:     command descriptor to drop
  */
-int target_put_sess_cmd(struct se_session *se_sess, struct se_cmd *se_cmd)
+int target_put_sess_cmd(struct se_cmd *se_cmd)
 {
+        struct se_session *se_sess = se_cmd->se_sess;
+
         if (!se_sess) {
                 se_cmd->se_tfo->release_cmd(se_cmd);
                 return 1;
@@ -2591,31 +2559,10 @@ void target_wait_for_sess_cmds(struct se_session *se_sess)
 }
 EXPORT_SYMBOL(target_wait_for_sess_cmds);
 
-static int transport_clear_lun_ref_thread(void *p)
+void transport_clear_lun_ref(struct se_lun *lun)
 {
-        struct se_lun *lun = p;
-
         percpu_ref_kill(&lun->lun_ref);
-
         wait_for_completion(&lun->lun_ref_comp);
-        complete(&lun->lun_shutdown_comp);
-
-        return 0;
-}
-
-int transport_clear_lun_ref(struct se_lun *lun)
-{
-        struct task_struct *kt;
-
-        kt = kthread_run(transport_clear_lun_ref_thread, lun,
-                        "tcm_cl_%u", lun->unpacked_lun);
-        if (IS_ERR(kt)) {
-                pr_err("Unable to start clear_lun thread\n");
-                return PTR_ERR(kt);
-        }
-        wait_for_completion(&lun->lun_shutdown_comp);
-
-        return 0;
 }
 
 /**
@@ -2649,10 +2596,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);
 
@@ -2661,9 +2606,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);
 
@@ -2965,8 +2909,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;
@@ -3005,9 +2949,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);
@@ -3033,6 +2976,11 @@ static void target_tmr_work(struct work_struct *work)
                 ret = core_tmr_lun_reset(dev, tmr, NULL, NULL);
                 tmr->response = (!ret) ? TMR_FUNCTION_COMPLETE :
                                          TMR_FUNCTION_REJECTED;
+                if (tmr->response == TMR_FUNCTION_COMPLETE) {
+                        target_ua_allocate_lun(cmd->se_sess->se_node_acl,
+                                               cmd->orig_fe_lun, 0x29,
+                                               ASCQ_29H_BUS_DEVICE_RESET_FUNCTION_OCCURRED);
+                }
                 break;
         case TMR_TARGET_WARM_RESET:
                 tmr->response = TMR_FUNCTION_REJECTED;
@@ -3067,3 +3015,22 @@ int transport_generic_handle_tmr(
         return 0;
 }
 EXPORT_SYMBOL(transport_generic_handle_tmr);
+
+bool
+target_check_wce(struct se_device *dev)
+{
+        bool wce = false;
+
+        if (dev->transport->get_write_cache)
+                wce = dev->transport->get_write_cache(dev);
+        else if (dev->dev_attrib.emulate_write_cache > 0)
+                wce = true;
+
+        return wce;
+}
+
+bool
+target_check_fua(struct se_device *dev)
+{
+        return target_check_wce(dev) && dev->dev_attrib.emulate_fua_write > 0;
+}
diff --git a/drivers/target/target_core_ua.c b/drivers/target/target_core_ua.c
index e44cc94b12cb..be25eb807a5f 100644
--- a/drivers/target/target_core_ua.c
+++ b/drivers/target/target_core_ua.c
@@ -29,7 +29,6 @@
 
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 
 #include "target_core_internal.h"
 #include "target_core_alua.h"
@@ -50,9 +49,17 @@ target_scsi3_ua_check(struct se_cmd *cmd)
         if (!nacl)
                 return 0;
 
-        deve = nacl->device_list[cmd->orig_fe_lun];
-        if (!atomic_read(&deve->ua_count))
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, cmd->orig_fe_lun);
+        if (!deve) {
+                rcu_read_unlock();
                 return 0;
+        }
+        if (!atomic_read(&deve->ua_count)) {
+                rcu_read_unlock();
+                return 0;
+        }
+        rcu_read_unlock();
         /*
          * From sam4r14, section 5.14 Unit attention condition:
          *
@@ -79,18 +86,11 @@ target_scsi3_ua_check(struct se_cmd *cmd)
 }
 
 int core_scsi3_ua_allocate(
-        struct se_node_acl *nacl,
-        u32 unpacked_lun,
+        struct se_dev_entry *deve,
         u8 asc,
         u8 ascq)
 {
-        struct se_dev_entry *deve;
         struct se_ua *ua, *ua_p, *ua_tmp;
-        /*
-         * PASSTHROUGH OPS
-         */
-        if (!nacl)
-                return -EINVAL;
 
         ua = kmem_cache_zalloc(se_ua_cache, GFP_ATOMIC);
         if (!ua) {
@@ -99,13 +99,9 @@ int core_scsi3_ua_allocate(
         }
         INIT_LIST_HEAD(&ua->ua_nacl_list);
 
-        ua->ua_nacl = nacl;
         ua->ua_asc = asc;
         ua->ua_ascq = ascq;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[unpacked_lun];
-
         spin_lock(&deve->ua_lock);
         list_for_each_entry_safe(ua_p, ua_tmp, &deve->ua_list, ua_nacl_list) {
                 /*
@@ -113,7 +109,6 @@ int core_scsi3_ua_allocate(
                  */
                 if ((ua_p->ua_asc == asc) && (ua_p->ua_ascq == ascq)) {
                         spin_unlock(&deve->ua_lock);
-                        spin_unlock_irq(&nacl->device_list_lock);
                         kmem_cache_free(se_ua_cache, ua);
                         return 0;
                 }
@@ -158,24 +153,40 @@ int core_scsi3_ua_allocate(
                         list_add_tail(&ua->ua_nacl_list,
                                 &deve->ua_list);
                 spin_unlock(&deve->ua_lock);
-                spin_unlock_irq(&nacl->device_list_lock);
 
                 atomic_inc_mb(&deve->ua_count);
                 return 0;
         }
         list_add_tail(&ua->ua_nacl_list, &deve->ua_list);
         spin_unlock(&deve->ua_lock);
-        spin_unlock_irq(&nacl->device_list_lock);
 
-        pr_debug("[%s]: Allocated UNIT ATTENTION, mapped LUN: %u, ASC:"
-                " 0x%02x, ASCQ: 0x%02x\n",
-                nacl->se_tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
+        pr_debug("Allocated UNIT ATTENTION, mapped LUN: %llu, ASC:"
+                " 0x%02x, ASCQ: 0x%02x\n", deve->mapped_lun,
                 asc, ascq);
 
         atomic_inc_mb(&deve->ua_count);
         return 0;
 }
 
+void target_ua_allocate_lun(struct se_node_acl *nacl,
+                            u32 unpacked_lun, u8 asc, u8 ascq)
+{
+        struct se_dev_entry *deve;
+
+        if (!nacl)
+                return;
+
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, unpacked_lun);
+        if (!deve) {
+                rcu_read_unlock();
+                return;
+        }
+
+        core_scsi3_ua_allocate(deve, asc, ascq);
+        rcu_read_unlock();
+}
+
 void core_scsi3_ua_release_all(
         struct se_dev_entry *deve)
 {
@@ -210,10 +221,14 @@ void core_scsi3_ua_for_check_condition(
         if (!nacl)
                 return;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[cmd->orig_fe_lun];
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, cmd->orig_fe_lun);
+        if (!deve) {
+                rcu_read_unlock();
+                return;
+        }
         if (!atomic_read(&deve->ua_count)) {
-                spin_unlock_irq(&nacl->device_list_lock);
+                rcu_read_unlock();
                 return;
         }
         /*
@@ -249,10 +264,10 @@ void core_scsi3_ua_for_check_condition(
                 atomic_dec_mb(&deve->ua_count);
         }
         spin_unlock(&deve->ua_lock);
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
 
         pr_debug("[%s]: %s UNIT ATTENTION condition with"
-                " INTLCK_CTRL: %d, mapped LUN: %u, got CDB: 0x%02x"
+                " INTLCK_CTRL: %d, mapped LUN: %llu, got CDB: 0x%02x"
                 " reported ASC: 0x%02x, ASCQ: 0x%02x\n",
                 nacl->se_tpg->se_tpg_tfo->get_fabric_name(),
                 (dev->dev_attrib.emulate_ua_intlck_ctrl != 0) ? "Reporting" :
@@ -278,10 +293,14 @@ int core_scsi3_ua_clear_for_request_sense(
         if (!nacl)
                 return -EINVAL;
 
-        spin_lock_irq(&nacl->device_list_lock);
-        deve = nacl->device_list[cmd->orig_fe_lun];
+        rcu_read_lock();
+        deve = target_nacl_find_deve(nacl, cmd->orig_fe_lun);
+        if (!deve) {
+                rcu_read_unlock();
+                return -EINVAL;
+        }
         if (!atomic_read(&deve->ua_count)) {
-                spin_unlock_irq(&nacl->device_list_lock);
+                rcu_read_unlock();
                 return -EPERM;
         }
         /*
@@ -307,10 +326,10 @@ int core_scsi3_ua_clear_for_request_sense(
                 atomic_dec_mb(&deve->ua_count);
         }
         spin_unlock(&deve->ua_lock);
-        spin_unlock_irq(&nacl->device_list_lock);
+        rcu_read_unlock();
 
         pr_debug("[%s]: Released UNIT ATTENTION condition, mapped"
-                " LUN: %u, got REQUEST_SENSE reported ASC: 0x%02x,"
+                " LUN: %llu, got REQUEST_SENSE reported ASC: 0x%02x,"
                 " ASCQ: 0x%02x\n", nacl->se_tpg->se_tpg_tfo->get_fabric_name(),
                 cmd->orig_fe_lun, *asc, *ascq);
 
diff --git a/drivers/target/target_core_ua.h b/drivers/target/target_core_ua.h
index a6b56b364e7a..bd6e78ba153d 100644
--- a/drivers/target/target_core_ua.h
+++ b/drivers/target/target_core_ua.h
@@ -25,10 +25,14 @@
 
 #define ASCQ_2CH_PREVIOUS_RESERVATION_CONFLICT_STATUS           0x09
 
+#define ASCQ_3FH_INQUIRY_DATA_HAS_CHANGED                       0x03
+#define ASCQ_3FH_REPORTED_LUNS_DATA_HAS_CHANGED                 0x0E
+
 extern struct kmem_cache *se_ua_cache;
 
 extern sense_reason_t target_scsi3_ua_check(struct se_cmd *);
-extern int core_scsi3_ua_allocate(struct se_node_acl *, u32, u8, u8);
+extern int core_scsi3_ua_allocate(struct se_dev_entry *, u8, u8);
+extern void target_ua_allocate_lun(struct se_node_acl *, u32, u8, u8);
 extern void core_scsi3_ua_release_all(struct se_dev_entry *);
 extern void core_scsi3_ua_for_check_condition(struct se_cmd *, u8 *, u8 *);
 extern int core_scsi3_ua_clear_for_request_sense(struct se_cmd *,
diff --git a/drivers/target/target_core_user.c b/drivers/target/target_core_user.c
index 549af9847c28..c448ef421ce7 100644
--- a/drivers/target/target_core_user.c
+++ b/drivers/target/target_core_user.c
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2013 Shaohua Li <shli@kernel.org>
  * Copyright (C) 2014 Red Hat, Inc.
+ * Copyright (C) 2015 Arrikto, Inc.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -30,7 +31,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 #include <target/target_core_backend.h>
-#include <target/target_core_backend_configfs.h>
 
 #include <linux/target_core_user.h>
 
@@ -168,6 +168,11 @@ static struct tcmu_cmd *tcmu_alloc_cmd(struct se_cmd *se_cmd)
         tcmu_cmd->tcmu_dev = udev;
         tcmu_cmd->data_length = se_cmd->data_length;
 
+        if (se_cmd->se_cmd_flags & SCF_BIDI) {
+                BUG_ON(!(se_cmd->t_bidi_data_sg && se_cmd->t_bidi_data_nents));
+                tcmu_cmd->data_length += se_cmd->t_bidi_data_sg->length;
+        }
+
         tcmu_cmd->deadline = jiffies + msecs_to_jiffies(TCMU_TIME_OUT);
 
         idr_preload(GFP_KERNEL);
@@ -226,9 +231,106 @@ static inline size_t head_to_end(size_t head, size_t size)
 
 #define UPDATE_HEAD(head, used, size) smp_store_release(&head, ((head % size) + used) % size)
 
+static void alloc_and_scatter_data_area(struct tcmu_dev *udev,
+        struct scatterlist *data_sg, unsigned int data_nents,
+        struct iovec **iov, int *iov_cnt, bool copy_data)
+{
+        int i;
+        void *from, *to;
+        size_t copy_bytes;
+        struct scatterlist *sg;
+
+        for_each_sg(data_sg, sg, data_nents, i) {
+                copy_bytes = min_t(size_t, sg->length,
+                                 head_to_end(udev->data_head, udev->data_size));
+                from = kmap_atomic(sg_page(sg)) + sg->offset;
+                to = (void *) udev->mb_addr + udev->data_off + udev->data_head;
+
+                if (copy_data) {
+                        memcpy(to, from, copy_bytes);
+                        tcmu_flush_dcache_range(to, copy_bytes);
+                }
+
+                /* Even iov_base is relative to mb_addr */
+                (*iov)->iov_len = copy_bytes;
+                (*iov)->iov_base = (void __user *) udev->data_off +
+                                                udev->data_head;
+                (*iov_cnt)++;
+                (*iov)++;
+
+                UPDATE_HEAD(udev->data_head, copy_bytes, udev->data_size);
+
+                /* Uh oh, we wrapped the buffer. Must split sg across 2 iovs. */
+                if (sg->length != copy_bytes) {
+                        void *from_skip = from + copy_bytes;
+
+                        copy_bytes = sg->length - copy_bytes;
+
+                        (*iov)->iov_len = copy_bytes;
+                        (*iov)->iov_base = (void __user *) udev->data_off +
+                                                        udev->data_head;
+
+                        if (copy_data) {
+                                to = (void *) udev->mb_addr +
+                                        udev->data_off + udev->data_head;
+                                memcpy(to, from_skip, copy_bytes);
+                                tcmu_flush_dcache_range(to, copy_bytes);
+                        }
+
+                        (*iov_cnt)++;
+                        (*iov)++;
+
+                        UPDATE_HEAD(udev->data_head,
+                                copy_bytes, udev->data_size);
+                }
+
+                kunmap_atomic(from - sg->offset);
+        }
+}
+
+static void gather_and_free_data_area(struct tcmu_dev *udev,
+        struct scatterlist *data_sg, unsigned int data_nents)
+{
+        int i;
+        void *from, *to;
+        size_t copy_bytes;
+        struct scatterlist *sg;
+
+        /* It'd be easier to look at entry's iovec again, but UAM */
+        for_each_sg(data_sg, sg, data_nents, i) {
+                copy_bytes = min_t(size_t, sg->length,
+                                 head_to_end(udev->data_tail, udev->data_size));
+
+                to = kmap_atomic(sg_page(sg)) + sg->offset;
+                WARN_ON(sg->length + sg->offset > PAGE_SIZE);
+                from = (void *) udev->mb_addr +
+                        udev->data_off + udev->data_tail;
+                tcmu_flush_dcache_range(from, copy_bytes);
+                memcpy(to, from, copy_bytes);
+
+                UPDATE_HEAD(udev->data_tail, copy_bytes, udev->data_size);
+
+                /* Uh oh, wrapped the data buffer for this sg's data */
+                if (sg->length != copy_bytes) {
+                        void *to_skip = to + copy_bytes;
+
+                        from = (void *) udev->mb_addr +
+                                udev->data_off + udev->data_tail;
+                        WARN_ON(udev->data_tail);
+                        copy_bytes = sg->length - copy_bytes;
+                        tcmu_flush_dcache_range(from, copy_bytes);
+                        memcpy(to_skip, from, copy_bytes);
+
+                        UPDATE_HEAD(udev->data_tail,
+                                copy_bytes, udev->data_size);
+                }
+                kunmap_atomic(to - sg->offset);
+        }
+}
+
 /*
- * We can't queue a command until we have space available on the cmd ring *and* space
- * space avail on the data ring.
+ * We can't queue a command until we have space available on the cmd ring *and*
+ * space available on the data ring.
  *
  * Called with ring lock held.
  */
@@ -276,12 +378,11 @@ static int tcmu_queue_cmd_ring(struct tcmu_cmd *tcmu_cmd)
         size_t base_command_size, command_size;
         struct tcmu_mailbox *mb;
         struct tcmu_cmd_entry *entry;
-        int i;
-        struct scatterlist *sg;
         struct iovec *iov;
-        int iov_cnt = 0;
+        int iov_cnt;
         uint32_t cmd_head;
         uint64_t cdb_off;
+        bool copy_to_data_area;
 
         if (test_bit(TCMU_DEV_BIT_BROKEN, &udev->flags))
                 return -EINVAL;
@@ -294,7 +395,8 @@ static int tcmu_queue_cmd_ring(struct tcmu_cmd *tcmu_cmd)
          * b/c size == offsetof one-past-element.
         */
         base_command_size = max(offsetof(struct tcmu_cmd_entry,
-                                         req.iov[se_cmd->t_data_nents + 2]),
+                                         req.iov[se_cmd->t_bidi_data_nents +
+                                                 se_cmd->t_data_nents + 2]),
                                 sizeof(struct tcmu_cmd_entry));
         command_size = base_command_size
                 + round_up(scsi_command_size(se_cmd->t_task_cdb), TCMU_OP_ALIGN_SIZE);
@@ -362,53 +464,20 @@ static int tcmu_queue_cmd_ring(struct tcmu_cmd *tcmu_cmd)
          * Fix up iovecs, and handle if allocation in data ring wrapped.
          */
         iov = &entry->req.iov[0];
-        for_each_sg(se_cmd->t_data_sg, sg, se_cmd->t_data_nents, i) {
-                size_t copy_bytes = min((size_t)sg->length,
-                                     head_to_end(udev->data_head, udev->data_size));
-                void *from = kmap_atomic(sg_page(sg)) + sg->offset;
-                void *to = (void *) mb + udev->data_off + udev->data_head;
-
-                if (tcmu_cmd->se_cmd->data_direction == DMA_TO_DEVICE) {
-                        memcpy(to, from, copy_bytes);
-                        tcmu_flush_dcache_range(to, copy_bytes);
-                }
-
-                /* Even iov_base is relative to mb_addr */
-                iov->iov_len = copy_bytes;
-                iov->iov_base = (void __user *) udev->data_off +
-                                                udev->data_head;
-                iov_cnt++;
-                iov++;
-
-                UPDATE_HEAD(udev->data_head, copy_bytes, udev->data_size);
-
-                /* Uh oh, we wrapped the buffer. Must split sg across 2 iovs. */
-                if (sg->length != copy_bytes) {
-                        from += copy_bytes;
-                        copy_bytes = sg->length - copy_bytes;
-
-                        iov->iov_len = copy_bytes;
-                        iov->iov_base = (void __user *) udev->data_off +
-                                                        udev->data_head;
-
-                        if (se_cmd->data_direction == DMA_TO_DEVICE) {
-                                to = (void *) mb + udev->data_off + udev->data_head;
-                                memcpy(to, from, copy_bytes);
-                                tcmu_flush_dcache_range(to, copy_bytes);
-                        }
-
-                        iov_cnt++;
-                        iov++;
-
-                        UPDATE_HEAD(udev->data_head, copy_bytes, udev->data_size);
-                }
-
-                kunmap_atomic(from);
-        }
+        iov_cnt = 0;
+        copy_to_data_area = (se_cmd->data_direction == DMA_TO_DEVICE
+                || se_cmd->se_cmd_flags & SCF_BIDI);
+        alloc_and_scatter_data_area(udev, se_cmd->t_data_sg,
+                se_cmd->t_data_nents, &iov, &iov_cnt, copy_to_data_area);
         entry->req.iov_cnt = iov_cnt;
-        entry->req.iov_bidi_cnt = 0;
         entry->req.iov_dif_cnt = 0;
 
+        /* Handle BIDI commands */
+        iov_cnt = 0;
+        alloc_and_scatter_data_area(udev, se_cmd->t_bidi_data_sg,
+                se_cmd->t_bidi_data_nents, &iov, &iov_cnt, false);
+        entry->req.iov_bidi_cnt = iov_cnt;
+
         /* All offsets relative to mb_addr, not start of entry! */
         cdb_off = CMDR_OFF + cmd_head + base_command_size;
         memcpy((void *) mb + cdb_off, se_cmd->t_task_cdb, scsi_command_size(se_cmd->t_task_cdb));
@@ -481,47 +550,22 @@ static void tcmu_handle_completion(struct tcmu_cmd *cmd, struct tcmu_cmd_entry *
                                se_cmd->scsi_sense_length);
 
                 UPDATE_HEAD(udev->data_tail, cmd->data_length, udev->data_size);
-        }
-        else if (se_cmd->data_direction == DMA_FROM_DEVICE) {
-                struct scatterlist *sg;
-                int i;
-
-                /* It'd be easier to look at entry's iovec again, but UAM */
-                for_each_sg(se_cmd->t_data_sg, sg, se_cmd->t_data_nents, i) {
-                        size_t copy_bytes;
-                        void *to;
-                        void *from;
-
-                        copy_bytes = min((size_t)sg->length,
-                                         head_to_end(udev->data_tail, udev->data_size));
-
-                        to = kmap_atomic(sg_page(sg)) + sg->offset;
-                        WARN_ON(sg->length + sg->offset > PAGE_SIZE);
-                        from = (void *) udev->mb_addr + udev->data_off + udev->data_tail;
-                        tcmu_flush_dcache_range(from, copy_bytes);
-                        memcpy(to, from, copy_bytes);
-
-                        UPDATE_HEAD(udev->data_tail, copy_bytes, udev->data_size);
-
-                        /* Uh oh, wrapped the data buffer for this sg's data */
-                        if (sg->length != copy_bytes) {
-                                from = (void *) udev->mb_addr + udev->data_off + udev->data_tail;
-                                WARN_ON(udev->data_tail);
-                                to += copy_bytes;
-                                copy_bytes = sg->length - copy_bytes;
-                                tcmu_flush_dcache_range(from, copy_bytes);
-                                memcpy(to, from, copy_bytes);
-
-                                UPDATE_HEAD(udev->data_tail, copy_bytes, udev->data_size);
-                        }
-
-                        kunmap_atomic(to);
-                }
-
+        } else if (se_cmd->se_cmd_flags & SCF_BIDI) {
+                /* Discard data_out buffer */
+                UPDATE_HEAD(udev->data_tail,
+                        (size_t)se_cmd->t_data_sg->length, udev->data_size);
+
+                /* Get Data-In buffer */
+                gather_and_free_data_area(udev,
+                        se_cmd->t_bidi_data_sg, se_cmd->t_bidi_data_nents);
+        } else if (se_cmd->data_direction == DMA_FROM_DEVICE) {
+                gather_and_free_data_area(udev,
+                        se_cmd->t_data_sg, se_cmd->t_data_nents);
         } else if (se_cmd->data_direction == DMA_TO_DEVICE) {
                 UPDATE_HEAD(udev->data_tail, cmd->data_length, udev->data_size);
-        } else {
-                pr_warn("TCMU: data direction was %d!\n", se_cmd->data_direction);
+        } else if (se_cmd->data_direction != DMA_NONE) {
+                pr_warn("TCMU: data direction was %d!\n",
+                        se_cmd->data_direction);
         }
 
         target_complete_cmd(cmd->se_cmd, entry->rsp.scsi_status);
@@ -910,6 +954,14 @@ static int tcmu_check_pending_cmd(int id, void *p, void *data)
         return -EINVAL;
 }
 
+static void tcmu_dev_call_rcu(struct rcu_head *p)
+{
+        struct se_device *dev = container_of(p, struct se_device, rcu_head);
+        struct tcmu_dev *udev = TCMU_DEV(dev);
+
+        kfree(udev);
+}
+
 static void tcmu_free_device(struct se_device *dev)
 {
         struct tcmu_dev *udev = TCMU_DEV(dev);
@@ -935,8 +987,7 @@ static void tcmu_free_device(struct se_device *dev)
                 kfree(udev->uio_info.name);
                 kfree(udev->name);
         }
-
-        kfree(udev);
+        call_rcu(&dev->rcu_head, tcmu_dev_call_rcu);
 }
 
 enum {
@@ -1054,27 +1105,7 @@ tcmu_parse_cdb(struct se_cmd *cmd)
         return passthrough_parse_cdb(cmd, tcmu_pass_op);
 }
 
-DEF_TB_DEV_ATTRIB_RO(tcmu, hw_pi_prot_type);
-TB_DEV_ATTR_RO(tcmu, hw_pi_prot_type);
-
-DEF_TB_DEV_ATTRIB_RO(tcmu, hw_block_size);
-TB_DEV_ATTR_RO(tcmu, hw_block_size);
-
-DEF_TB_DEV_ATTRIB_RO(tcmu, hw_max_sectors);
-TB_DEV_ATTR_RO(tcmu, hw_max_sectors);
-
-DEF_TB_DEV_ATTRIB_RO(tcmu, hw_queue_depth);
-TB_DEV_ATTR_RO(tcmu, hw_queue_depth);
-
-static struct configfs_attribute *tcmu_backend_dev_attrs[] = {
-        &tcmu_dev_attrib_hw_pi_prot_type.attr,
-        &tcmu_dev_attrib_hw_block_size.attr,
-        &tcmu_dev_attrib_hw_max_sectors.attr,
-        &tcmu_dev_attrib_hw_queue_depth.attr,
-        NULL,
-};
-
-static struct se_subsystem_api tcmu_template = {
+static const struct target_backend_ops tcmu_ops = {
         .name                   = "user",
         .inquiry_prod           = "USER",
         .inquiry_rev            = TCMU_VERSION,
@@ -1090,11 +1121,11 @@ static struct se_subsystem_api tcmu_template = {
         .show_configfs_dev_params = tcmu_show_configfs_dev_params,
         .get_device_type        = sbc_get_device_type,
         .get_blocks             = tcmu_get_blocks,
+        .tb_dev_attrib_attrs    = passthrough_attrib_attrs,
 };
 
 static int __init tcmu_module_init(void)
 {
-        struct target_backend_cits *tbc = &tcmu_template.tb_cits;
         int ret;
 
         BUILD_BUG_ON((sizeof(struct tcmu_cmd_entry) % TCMU_OP_ALIGN_SIZE) != 0);
@@ -1117,10 +1148,7 @@ static int __init tcmu_module_init(void)
                 goto out_unreg_device;
         }
 
-        target_core_setup_sub_cits(&tcmu_template);
-        tbc->tb_dev_attrib_cit.ct_attrs = tcmu_backend_dev_attrs;
-
-        ret = transport_subsystem_register(&tcmu_template);
+        ret = transport_backend_register(&tcmu_ops);
         if (ret)
                 goto out_unreg_genl;
 
@@ -1138,7 +1166,7 @@ out_free_cache:
 
 static void __exit tcmu_module_exit(void)
 {
-        transport_subsystem_release(&tcmu_template);
+        target_backend_unregister(&tcmu_ops);
         genl_unregister_family(&tcmu_genl_family);
         root_device_unregister(tcmu_root_device);
         kmem_cache_destroy(tcmu_cmd_cache);
diff --git a/drivers/target/target_core_xcopy.c b/drivers/target/target_core_xcopy.c
index 5ec0d00edaa3..4515f52546f8 100644
--- a/drivers/target/target_core_xcopy.c
+++ b/drivers/target/target_core_xcopy.c
@@ -31,7 +31,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 
 #include "target_core_internal.h"
 #include "target_core_pr.h"
@@ -348,8 +347,7 @@ struct xcopy_pt_cmd {
         unsigned char sense_buffer[TRANSPORT_SENSE_BUFFER];
 };
 
-static struct se_port xcopy_pt_port;
-static struct se_portal_group xcopy_pt_tpg;
+struct se_portal_group xcopy_pt_tpg;
 static struct se_session xcopy_pt_sess;
 static struct se_node_acl xcopy_pt_nacl;
 
@@ -358,11 +356,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;
@@ -423,7 +416,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,
@@ -445,17 +437,11 @@ int target_xcopy_setup_pt(void)
                 return -ENOMEM;
         }
 
-        memset(&xcopy_pt_port, 0, sizeof(struct se_port));
-        INIT_LIST_HEAD(&xcopy_pt_port.sep_alua_list);
-        INIT_LIST_HEAD(&xcopy_pt_port.sep_list);
-        mutex_init(&xcopy_pt_port.sep_tg_pt_md_mutex);
-
         memset(&xcopy_pt_tpg, 0, sizeof(struct se_portal_group));
         INIT_LIST_HEAD(&xcopy_pt_tpg.se_tpg_node);
         INIT_LIST_HEAD(&xcopy_pt_tpg.acl_node_list);
         INIT_LIST_HEAD(&xcopy_pt_tpg.tpg_sess_list);
 
-        xcopy_pt_port.sep_tpg = &xcopy_pt_tpg;
         xcopy_pt_tpg.se_tpg_tfo = &xcopy_pt_tfo;
 
         memset(&xcopy_pt_nacl, 0, sizeof(struct se_node_acl));
@@ -496,10 +482,6 @@ static void target_xcopy_setup_pt_port(
                  */
                 if (remote_port) {
                         xpt_cmd->remote_port = remote_port;
-                        pt_cmd->se_lun->lun_sep = &xcopy_pt_port;
-                        pr_debug("Setup emulated remote DEST xcopy_pt_port: %p to"
-                                " cmd->se_lun->lun_sep for X-COPY data PUSH\n",
-                                pt_cmd->se_lun->lun_sep);
                 } else {
                         pt_cmd->se_lun = ec_cmd->se_lun;
                         pt_cmd->se_dev = ec_cmd->se_dev;
@@ -519,10 +501,6 @@ static void target_xcopy_setup_pt_port(
                  */
                 if (remote_port) {
                         xpt_cmd->remote_port = remote_port;
-                        pt_cmd->se_lun->lun_sep = &xcopy_pt_port;
-                        pr_debug("Setup emulated remote SRC xcopy_pt_port: %p to"
-                                " cmd->se_lun->lun_sep for X-COPY data PULL\n",
-                                pt_cmd->se_lun->lun_sep);
                 } else {
                         pt_cmd->se_lun = ec_cmd->se_lun;
                         pt_cmd->se_dev = ec_cmd->se_dev;
@@ -574,6 +552,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;
diff --git a/drivers/target/tcm_fc/tcm_fc.h b/drivers/target/tcm_fc/tcm_fc.h
index 881deb3d499a..39909dadef3e 100644
--- a/drivers/target/tcm_fc/tcm_fc.h
+++ b/drivers/target/tcm_fc/tcm_fc.h
@@ -80,8 +80,8 @@ struct ft_node_auth {
  * Node ACL for FC remote port session.
  */
 struct ft_node_acl {
-        struct ft_node_auth node_auth;
         struct se_node_acl se_node_acl;
+        struct ft_node_auth node_auth;
 };
 
 struct ft_lun {
@@ -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 *);
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index 1bf78e7c994c..68031723e5be 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -36,7 +36,6 @@
 
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 #include <target/configfs_macros.h>
 
 #include "tcm_fc.h"
@@ -243,15 +242,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;
@@ -564,6 +554,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.
diff --git a/drivers/target/tcm_fc/tfc_conf.c b/drivers/target/tcm_fc/tfc_conf.c
index 86b699b94c7b..16670933013b 100644
--- a/drivers/target/tcm_fc/tfc_conf.c
+++ b/drivers/target/tcm_fc/tfc_conf.c
@@ -39,13 +39,10 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 #include <target/target_core_fabric_configfs.h>
-#include <target/target_core_configfs.h>
 #include <target/configfs_macros.h>
 
 #include "tcm_fc.h"
 
-static const struct target_core_fabric_ops ft_fabric_ops;
-
 static LIST_HEAD(ft_wwn_list);
 DEFINE_MUTEX(ft_lport_lock);
 
@@ -194,48 +191,17 @@ static struct configfs_attribute *ft_nacl_base_attrs[] = {
  * Add ACL for an initiator.  The ACL is named arbitrarily.
  * The port_name and/or node_name are attributes.
  */
-static struct se_node_acl *ft_add_acl(
-        struct se_portal_group *se_tpg,
-        struct config_group *group,
-        const char *name)
+static int ft_init_nodeacl(struct se_node_acl *nacl, const char *name)
 {
-        struct ft_node_acl *acl;
-        struct ft_tpg *tpg;
+        struct ft_node_acl *acl =
+                container_of(nacl, struct ft_node_acl, se_node_acl);
         u64 wwpn;
-        u32 q_depth;
-
-        pr_debug("add acl %s\n", name);
-        tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
 
         if (ft_parse_wwn(name, &wwpn, 1) < 0)
-                return ERR_PTR(-EINVAL);
+                return -EINVAL;
 
-        acl = kzalloc(sizeof(struct ft_node_acl), GFP_KERNEL);
-        if (!acl)
-                return ERR_PTR(-ENOMEM);
         acl->node_auth.port_name = wwpn;
-
-        q_depth = 32;           /* XXX bogus default - get from tpg? */
-        return core_tpg_add_initiator_node_acl(&tpg->se_tpg,
-                                &acl->se_node_acl, name, q_depth);
-}
-
-static void ft_del_acl(struct se_node_acl *se_acl)
-{
-        struct se_portal_group *se_tpg = se_acl->se_tpg;
-        struct ft_tpg *tpg;
-        struct ft_node_acl *acl = container_of(se_acl,
-                                struct ft_node_acl, se_node_acl);
-
-        pr_debug("del acl %s\n",
-                config_item_name(&se_acl->acl_group.cg_item));
-
-        tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
-        pr_debug("del acl %p se_acl %p tpg %p se_tpg %p\n",
-                    acl, se_acl, tpg, &tpg->se_tpg);
-
-        core_tpg_del_initiator_node_acl(&tpg->se_tpg, se_acl, 1);
-        kfree(acl);
+        return 0;
 }
 
 struct ft_node_acl *ft_acl_get(struct ft_tpg *tpg, struct fc_rport_priv *rdata)
@@ -245,7 +211,7 @@ struct ft_node_acl *ft_acl_get(struct ft_tpg *tpg, struct fc_rport_priv *rdata)
         struct se_portal_group *se_tpg = &tpg->se_tpg;
         struct se_node_acl *se_acl;
 
-        spin_lock_irq(&se_tpg->acl_node_lock);
+        mutex_lock(&se_tpg->acl_node_mutex);
         list_for_each_entry(se_acl, &se_tpg->acl_node_list, acl_list) {
                 acl = container_of(se_acl, struct ft_node_acl, se_node_acl);
                 pr_debug("acl %p port_name %llx\n",
@@ -259,33 +225,10 @@ struct ft_node_acl *ft_acl_get(struct ft_tpg *tpg, struct fc_rport_priv *rdata)
                         break;
                 }
         }
-        spin_unlock_irq(&se_tpg->acl_node_lock);
+        mutex_unlock(&se_tpg->acl_node_mutex);
         return found;
 }
 
-static struct se_node_acl *ft_tpg_alloc_fabric_acl(struct se_portal_group *se_tpg)
-{
-        struct ft_node_acl *acl;
-
-        acl = kzalloc(sizeof(*acl), GFP_KERNEL);
-        if (!acl) {
-                pr_err("Unable to allocate struct ft_node_acl\n");
-                return NULL;
-        }
-        pr_debug("acl %p\n", acl);
-        return &acl->se_node_acl;
-}
-
-static void ft_tpg_release_fabric_acl(struct se_portal_group *se_tpg,
-                                      struct se_node_acl *se_acl)
-{
-        struct ft_node_acl *acl = container_of(se_acl,
-                                struct ft_node_acl, se_node_acl);
-
-        pr_debug("acl %p\n", acl);
-        kfree(acl);
-}
-
 /*
  * local_port port_group (tpg) ops.
  */
@@ -333,8 +276,7 @@ static struct se_portal_group *ft_add_tpg(
                 return NULL;
         }
 
-        ret = core_tpg_register(&ft_fabric_ops, wwn, &tpg->se_tpg,
-                                tpg, TRANSPORT_TPG_TYPE_NORMAL);
+        ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_FCP);
         if (ret < 0) {
                 destroy_workqueue(wq);
                 kfree(tpg);
@@ -459,6 +401,11 @@ static struct configfs_attribute *ft_wwn_attrs[] = {
         NULL,
 };
 
+static inline struct ft_tpg *ft_tpg(struct se_portal_group *se_tpg)
+{
+        return container_of(se_tpg, struct ft_tpg, se_tpg);
+}
+
 static char *ft_get_fabric_name(void)
 {
         return "fc";
@@ -466,25 +413,16 @@ static char *ft_get_fabric_name(void)
 
 static char *ft_get_fabric_wwn(struct se_portal_group *se_tpg)
 {
-        struct ft_tpg *tpg = se_tpg->se_tpg_fabric_ptr;
-
-        return tpg->lport_wwn->name;
+        return ft_tpg(se_tpg)->lport_wwn->name;
 }
 
 static u16 ft_get_tag(struct se_portal_group *se_tpg)
 {
-        struct ft_tpg *tpg = se_tpg->se_tpg_fabric_ptr;
-
         /*
          * This tag is used when forming SCSI Name identifier in EVPD=1 0x83
          * to represent the SCSI Target Port.
          */
-        return tpg->index;
-}
-
-static u32 ft_get_default_depth(struct se_portal_group *se_tpg)
-{
-        return 1;
+        return ft_tpg(se_tpg)->index;
 }
 
 static int ft_check_false(struct se_portal_group *se_tpg)
@@ -498,28 +436,20 @@ static void ft_set_default_node_attr(struct se_node_acl *se_nacl)
 
 static u32 ft_tpg_get_inst_index(struct se_portal_group *se_tpg)
 {
-        struct ft_tpg *tpg = se_tpg->se_tpg_fabric_ptr;
-
-        return tpg->index;
+        return ft_tpg(se_tpg)->index;
 }
 
 static const struct target_core_fabric_ops ft_fabric_ops = {
         .module =                       THIS_MODULE,
         .name =                         "fc",
+        .node_acl_size =                sizeof(struct ft_node_acl),
         .get_fabric_name =              ft_get_fabric_name,
-        .get_fabric_proto_ident =       fc_get_fabric_proto_ident,
         .tpg_get_wwn =                  ft_get_fabric_wwn,
         .tpg_get_tag =                  ft_get_tag,
-        .tpg_get_default_depth =        ft_get_default_depth,
-        .tpg_get_pr_transport_id =      fc_get_pr_transport_id,
-        .tpg_get_pr_transport_id_len =  fc_get_pr_transport_id_len,
-        .tpg_parse_pr_out_transport_id = fc_parse_pr_out_transport_id,
         .tpg_check_demo_mode =          ft_check_false,
         .tpg_check_demo_mode_cache =    ft_check_false,
         .tpg_check_demo_mode_write_protect = ft_check_false,
         .tpg_check_prod_mode_write_protect = ft_check_false,
-        .tpg_alloc_fabric_acl =         ft_tpg_alloc_fabric_acl,
-        .tpg_release_fabric_acl =       ft_tpg_release_fabric_acl,
         .tpg_get_inst_index =           ft_tpg_get_inst_index,
         .check_stop_free =              ft_check_stop_free,
         .release_cmd =                  ft_release_cmd,
@@ -530,7 +460,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,
@@ -544,12 +473,7 @@ static const struct target_core_fabric_ops ft_fabric_ops = {
         .fabric_drop_wwn =              &ft_del_wwn,
         .fabric_make_tpg =              &ft_add_tpg,
         .fabric_drop_tpg =              &ft_del_tpg,
-        .fabric_post_link =             NULL,
-        .fabric_pre_unlink =            NULL,
-        .fabric_make_np =               NULL,
-        .fabric_drop_np =               NULL,
-        .fabric_make_nodeacl =          &ft_add_acl,
-        .fabric_drop_nodeacl =          &ft_del_acl,
+        .fabric_init_nodeacl =          &ft_init_nodeacl,
 
         .tfc_wwn_attrs                  = ft_wwn_attrs,
         .tfc_tpg_nacl_base_attrs        = ft_nacl_base_attrs,
diff --git a/drivers/target/tcm_fc/tfc_io.c b/drivers/target/tcm_fc/tfc_io.c
index fe585d1cce23..4b0fedd6bd4b 100644
--- a/drivers/target/tcm_fc/tfc_io.c
+++ b/drivers/target/tcm_fc/tfc_io.c
@@ -44,7 +44,6 @@
 
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 #include <target/configfs_macros.h>
 
 #include "tcm_fc.h"
diff --git a/drivers/target/tcm_fc/tfc_sess.c b/drivers/target/tcm_fc/tfc_sess.c
index f2a616d4f2c4..31a9e3fb98c5 100644
--- a/drivers/target/tcm_fc/tfc_sess.c
+++ b/drivers/target/tcm_fc/tfc_sess.c
@@ -36,7 +36,6 @@
 
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 #include <target/configfs_macros.h>
 
 #include "tcm_fc.h"
diff --git a/drivers/usb/gadget/legacy/tcm_usb_gadget.c b/drivers/usb/gadget/legacy/tcm_usb_gadget.c
index 6ce932f90ef8..c3c48088fced 100644
--- a/drivers/usb/gadget/legacy/tcm_usb_gadget.c
+++ b/drivers/usb/gadget/legacy/tcm_usb_gadget.c
@@ -20,7 +20,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 #include <target/target_core_fabric_configfs.h>
-#include <target/target_core_configfs.h>
 #include <target/configfs_macros.h>
 #include <asm/unaligned.h>
 
@@ -28,8 +27,6 @@
 
 USB_GADGET_COMPOSITE_OPTIONS();
 
-static const struct target_core_fabric_ops usbg_ops;
-
 static inline struct f_uas *to_f_uas(struct usb_function *f)
 {
         return container_of(f, struct f_uas, function);
@@ -1111,6 +1108,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;
@@ -1244,6 +1242,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);
@@ -1273,23 +1272,6 @@ static char *usbg_get_fabric_name(void)
         return "usb_gadget";
 }
 
-static u8 usbg_get_fabric_proto_ident(struct se_portal_group *se_tpg)
-{
-        struct usbg_tpg *tpg = container_of(se_tpg,
-                                struct usbg_tpg, se_tpg);
-        struct usbg_tport *tport = tpg->tport;
-        u8 proto_id;
-
-        switch (tport->tport_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-        default:
-                proto_id = sas_get_fabric_proto_ident(se_tpg);
-                break;
-        }
-
-        return proto_id;
-}
-
 static char *usbg_get_fabric_wwn(struct se_portal_group *se_tpg)
 {
         struct usbg_tpg *tpg = container_of(se_tpg,
@@ -1306,97 +1288,6 @@ static u16 usbg_get_tag(struct se_portal_group *se_tpg)
         return tpg->tport_tpgt;
 }
 
-static u32 usbg_get_default_depth(struct se_portal_group *se_tpg)
-{
-        return 1;
-}
-
-static u32 usbg_get_pr_transport_id(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl,
-        struct t10_pr_registration *pr_reg,
-        int *format_code,
-        unsigned char *buf)
-{
-        struct usbg_tpg *tpg = container_of(se_tpg,
-                                struct usbg_tpg, se_tpg);
-        struct usbg_tport *tport = tpg->tport;
-        int ret = 0;
-
-        switch (tport->tport_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-        default:
-                ret = sas_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                                        format_code, buf);
-                break;
-        }
-
-        return ret;
-}
-
-static u32 usbg_get_pr_transport_id_len(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl,
-        struct t10_pr_registration *pr_reg,
-        int *format_code)
-{
-        struct usbg_tpg *tpg = container_of(se_tpg,
-                                struct usbg_tpg, se_tpg);
-        struct usbg_tport *tport = tpg->tport;
-        int ret = 0;
-
-        switch (tport->tport_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-        default:
-                ret = sas_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                                        format_code);
-                break;
-        }
-
-        return ret;
-}
-
-static char *usbg_parse_pr_out_transport_id(
-        struct se_portal_group *se_tpg,
-        const char *buf,
-        u32 *out_tid_len,
-        char **port_nexus_ptr)
-{
-        struct usbg_tpg *tpg = container_of(se_tpg,
-                                struct usbg_tpg, se_tpg);
-        struct usbg_tport *tport = tpg->tport;
-        char *tid = NULL;
-
-        switch (tport->tport_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-        default:
-                tid = sas_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                                        port_nexus_ptr);
-        }
-
-        return tid;
-}
-
-static struct se_node_acl *usbg_alloc_fabric_acl(struct se_portal_group *se_tpg)
-{
-        struct usbg_nacl *nacl;
-
-        nacl = kzalloc(sizeof(struct usbg_nacl), GFP_KERNEL);
-        if (!nacl)
-                return NULL;
-
-        return &nacl->se_node_acl;
-}
-
-static void usbg_release_fabric_acl(
-        struct se_portal_group *se_tpg,
-        struct se_node_acl *se_nacl)
-{
-        struct usbg_nacl *nacl = container_of(se_nacl,
-                        struct usbg_nacl, se_node_acl);
-        kfree(nacl);
-}
-
 static u32 usbg_tpg_get_inst_index(struct se_portal_group *se_tpg)
 {
         return 1;
@@ -1447,18 +1338,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;
@@ -1488,50 +1367,11 @@ static const char *usbg_check_wwn(const char *name)
         return n;
 }
 
-static struct se_node_acl *usbg_make_nodeacl(
-        struct se_portal_group *se_tpg,
-        struct config_group *group,
-        const char *name)
-{
-        struct se_node_acl *se_nacl, *se_nacl_new;
-        struct usbg_nacl *nacl;
-        u64 wwpn = 0;
-        u32 nexus_depth;
-        const char *wnn_name;
-
-        wnn_name = usbg_check_wwn(name);
-        if (!wnn_name)
-                return ERR_PTR(-EINVAL);
-        se_nacl_new = usbg_alloc_fabric_acl(se_tpg);
-        if (!(se_nacl_new))
-                return ERR_PTR(-ENOMEM);
-
-        nexus_depth = 1;
-        /*
-         * se_nacl_new may be released by core_tpg_add_initiator_node_acl()
-         * when converting a NodeACL from demo mode -> explict
-         */
-        se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new,
-                                name, nexus_depth);
-        if (IS_ERR(se_nacl)) {
-                usbg_release_fabric_acl(se_tpg, se_nacl_new);
-                return se_nacl;
-        }
-        /*
-         * Locate our struct usbg_nacl and set the FC Nport WWPN
-         */
-        nacl = container_of(se_nacl, struct usbg_nacl, se_node_acl);
-        nacl->iport_wwpn = wwpn;
-        snprintf(nacl->iport_name, sizeof(nacl->iport_name), "%s", name);
-        return se_nacl;
-}
-
-static void usbg_drop_nodeacl(struct se_node_acl *se_acl)
+static int usbg_init_nodeacl(struct se_node_acl *se_nacl, const char *name)
 {
-        struct usbg_nacl *nacl = container_of(se_acl,
-                                struct usbg_nacl, se_node_acl);
-        core_tpg_del_initiator_node_acl(se_acl->se_tpg, se_acl, 1);
-        kfree(nacl);
+        if (!usbg_check_wwn(name))
+                return -EINVAL;
+        return 0;
 }
 
 struct usbg_tpg *the_only_tpg_I_currently_have;
@@ -1571,8 +1411,11 @@ static struct se_portal_group *usbg_make_tpg(
         tpg->tport = tport;
         tpg->tport_tpgt = tpgt;
 
-        ret = core_tpg_register(&usbg_ops, wwn, &tpg->se_tpg, tpg,
-                                TRANSPORT_TPG_TYPE_NORMAL);
+        /*
+         * SPC doesn't assign a protocol identifier for USB-SCSI, so we
+         * pretend to be SAS..
+         */
+        ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_SAS);
         if (ret < 0) {
                 destroy_workqueue(tpg->workqueue);
                 kfree(tpg);
@@ -1866,19 +1709,12 @@ static const struct target_core_fabric_ops usbg_ops = {
         .module                         = THIS_MODULE,
         .name                           = "usb_gadget",
         .get_fabric_name                = usbg_get_fabric_name,
-        .get_fabric_proto_ident         = usbg_get_fabric_proto_ident,
         .tpg_get_wwn                    = usbg_get_fabric_wwn,
         .tpg_get_tag                    = usbg_get_tag,
-        .tpg_get_default_depth          = usbg_get_default_depth,
-        .tpg_get_pr_transport_id        = usbg_get_pr_transport_id,
-        .tpg_get_pr_transport_id_len    = usbg_get_pr_transport_id_len,
-        .tpg_parse_pr_out_transport_id  = usbg_parse_pr_out_transport_id,
         .tpg_check_demo_mode            = usbg_check_true,
         .tpg_check_demo_mode_cache      = usbg_check_false,
         .tpg_check_demo_mode_write_protect = usbg_check_false,
         .tpg_check_prod_mode_write_protect = usbg_check_false,
-        .tpg_alloc_fabric_acl           = usbg_alloc_fabric_acl,
-        .tpg_release_fabric_acl         = usbg_release_fabric_acl,
         .tpg_get_inst_index             = usbg_tpg_get_inst_index,
         .release_cmd                    = usbg_release_cmd,
         .shutdown_session               = usbg_shutdown_session,
@@ -1888,7 +1724,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,
@@ -1902,10 +1737,7 @@ static const struct target_core_fabric_ops usbg_ops = {
         .fabric_drop_tpg                = usbg_drop_tpg,
         .fabric_post_link               = usbg_port_link,
         .fabric_pre_unlink              = usbg_port_unlink,
-        .fabric_make_np                 = NULL,
-        .fabric_drop_np                 = NULL,
-        .fabric_make_nodeacl            = usbg_make_nodeacl,
-        .fabric_drop_nodeacl            = usbg_drop_nodeacl,
+        .fabric_init_nodeacl            = usbg_init_nodeacl,
 
         .tfc_wwn_attrs                  = usbg_wwn_attrs,
         .tfc_tpg_base_attrs             = usbg_base_attrs,
diff --git a/drivers/usb/gadget/legacy/tcm_usb_gadget.h b/drivers/usb/gadget/legacy/tcm_usb_gadget.h
index 9fb3544cc80f..0b749e1aa2f1 100644
--- a/drivers/usb/gadget/legacy/tcm_usb_gadget.h
+++ b/drivers/usb/gadget/legacy/tcm_usb_gadget.h
@@ -24,15 +24,6 @@ enum {
 #define USB_G_ALT_INT_BBB       0
 #define USB_G_ALT_INT_UAS       1
 
-struct usbg_nacl {
-        /* Binary World Wide unique Port Name for SAS Initiator port */
-        u64 iport_wwpn;
-        /* ASCII formatted WWPN for Sas Initiator port */
-        char iport_name[USBG_NAMELEN];
-        /* Returned by usbg_make_nodeacl() */
-        struct se_node_acl se_node_acl;
-};
-
 struct tcm_usbg_nexus {
         struct se_session *tvn_se_sess;
 };
@@ -52,8 +43,6 @@ struct usbg_tpg {
 };
 
 struct usbg_tport {
-        /* SCSI protocol the tport is providing */
-        u8 tport_proto_id;
         /* Binary World Wide unique Port Name for SAS Target port */
         u64 tport_wwpn;
         /* ASCII formatted WWPN for SAS Target port */
diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c
index 55722feeb898..dfcc02c93648 100644
--- a/drivers/vhost/scsi.c
+++ b/drivers/vhost/scsi.c
@@ -43,7 +43,6 @@
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
 #include <target/target_core_fabric_configfs.h>
-#include <target/target_core_configfs.h>
 #include <target/configfs_macros.h>
 #include <linux/vhost.h>
 #include <linux/virtio_scsi.h>
@@ -117,15 +116,6 @@ struct vhost_scsi_nexus {
         struct se_session *tvn_se_sess;
 };
 
-struct vhost_scsi_nacl {
-        /* Binary World Wide unique Port Name for Vhost Initiator port */
-        u64 iport_wwpn;
-        /* ASCII formatted WWPN for Sas Initiator port */
-        char iport_name[VHOST_SCSI_NAMELEN];
-        /* Returned by vhost_scsi_make_nodeacl() */
-        struct se_node_acl se_node_acl;
-};
-
 struct vhost_scsi_tpg {
         /* Vhost port target portal group tag for TCM */
         u16 tport_tpgt;
@@ -218,7 +208,6 @@ struct vhost_scsi {
         int vs_events_nr; /* num of pending events, protected by vq->mutex */
 };
 
-static struct target_core_fabric_ops vhost_scsi_ops;
 static struct workqueue_struct *vhost_scsi_workqueue;
 
 /* Global spinlock to protect vhost_scsi TPG list for vhost IOCTL access */
@@ -299,28 +288,6 @@ static char *vhost_scsi_get_fabric_name(void)
         return "vhost";
 }
 
-static u8 vhost_scsi_get_fabric_proto_ident(struct se_portal_group *se_tpg)
-{
-        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
-                                struct vhost_scsi_tpg, se_tpg);
-        struct vhost_scsi_tport *tport = tpg->tport;
-
-        switch (tport->tport_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-                return sas_get_fabric_proto_ident(se_tpg);
-        case SCSI_PROTOCOL_FCP:
-                return fc_get_fabric_proto_ident(se_tpg);
-        case SCSI_PROTOCOL_ISCSI:
-                return iscsi_get_fabric_proto_ident(se_tpg);
-        default:
-                pr_err("Unknown tport_proto_id: 0x%02x, using"
-                        " SAS emulation\n", tport->tport_proto_id);
-                break;
-        }
-
-        return sas_get_fabric_proto_ident(se_tpg);
-}
-
 static char *vhost_scsi_get_fabric_wwn(struct se_portal_group *se_tpg)
 {
         struct vhost_scsi_tpg *tpg = container_of(se_tpg,
@@ -337,102 +304,6 @@ static u16 vhost_scsi_get_tpgt(struct se_portal_group *se_tpg)
         return tpg->tport_tpgt;
 }
 
-static u32 vhost_scsi_get_default_depth(struct se_portal_group *se_tpg)
-{
-        return 1;
-}
-
-static u32
-vhost_scsi_get_pr_transport_id(struct se_portal_group *se_tpg,
-                              struct se_node_acl *se_nacl,
-                              struct t10_pr_registration *pr_reg,
-                              int *format_code,
-                              unsigned char *buf)
-{
-        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
-                                struct vhost_scsi_tpg, se_tpg);
-        struct vhost_scsi_tport *tport = tpg->tport;
-
-        switch (tport->tport_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-                return sas_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                                        format_code, buf);
-        case SCSI_PROTOCOL_FCP:
-                return fc_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                                        format_code, buf);
-        case SCSI_PROTOCOL_ISCSI:
-                return iscsi_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                                        format_code, buf);
-        default:
-                pr_err("Unknown tport_proto_id: 0x%02x, using"
-                        " SAS emulation\n", tport->tport_proto_id);
-                break;
-        }
-
-        return sas_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                        format_code, buf);
-}
-
-static u32
-vhost_scsi_get_pr_transport_id_len(struct se_portal_group *se_tpg,
-                                  struct se_node_acl *se_nacl,
-                                  struct t10_pr_registration *pr_reg,
-                                  int *format_code)
-{
-        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
-                                struct vhost_scsi_tpg, se_tpg);
-        struct vhost_scsi_tport *tport = tpg->tport;
-
-        switch (tport->tport_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-                return sas_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                                        format_code);
-        case SCSI_PROTOCOL_FCP:
-                return fc_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                                        format_code);
-        case SCSI_PROTOCOL_ISCSI:
-                return iscsi_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                                        format_code);
-        default:
-                pr_err("Unknown tport_proto_id: 0x%02x, using"
-                        " SAS emulation\n", tport->tport_proto_id);
-                break;
-        }
-
-        return sas_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                        format_code);
-}
-
-static char *
-vhost_scsi_parse_pr_out_transport_id(struct se_portal_group *se_tpg,
-                                    const char *buf,
-                                    u32 *out_tid_len,
-                                    char **port_nexus_ptr)
-{
-        struct vhost_scsi_tpg *tpg = container_of(se_tpg,
-                                struct vhost_scsi_tpg, se_tpg);
-        struct vhost_scsi_tport *tport = tpg->tport;
-
-        switch (tport->tport_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-                return sas_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                                        port_nexus_ptr);
-        case SCSI_PROTOCOL_FCP:
-                return fc_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                                        port_nexus_ptr);
-        case SCSI_PROTOCOL_ISCSI:
-                return iscsi_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                                        port_nexus_ptr);
-        default:
-                pr_err("Unknown tport_proto_id: 0x%02x, using"
-                        " SAS emulation\n", tport->tport_proto_id);
-                break;
-        }
-
-        return sas_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                        port_nexus_ptr);
-}
-
 static int vhost_scsi_check_prot_fabric_only(struct se_portal_group *se_tpg)
 {
         struct vhost_scsi_tpg *tpg = container_of(se_tpg,
@@ -441,29 +312,6 @@ static int vhost_scsi_check_prot_fabric_only(struct se_portal_group *se_tpg)
         return tpg->tv_fabric_prot_type;
 }
 
-static struct se_node_acl *
-vhost_scsi_alloc_fabric_acl(struct se_portal_group *se_tpg)
-{
-        struct vhost_scsi_nacl *nacl;
-
-        nacl = kzalloc(sizeof(struct vhost_scsi_nacl), GFP_KERNEL);
-        if (!nacl) {
-                pr_err("Unable to allocate struct vhost_scsi_nacl\n");
-                return NULL;
-        }
-
-        return &nacl->se_node_acl;
-}
-
-static void
-vhost_scsi_release_fabric_acl(struct se_portal_group *se_tpg,
-                             struct se_node_acl *se_nacl)
-{
-        struct vhost_scsi_nacl *nacl = container_of(se_nacl,
-                        struct vhost_scsi_nacl, se_node_acl);
-        kfree(nacl);
-}
-
 static u32 vhost_scsi_tpg_get_inst_index(struct se_portal_group *se_tpg)
 {
         return 1;
@@ -521,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;
@@ -609,7 +452,7 @@ static void vhost_scsi_free_cmd(struct vhost_scsi_cmd *cmd)
 
 static int vhost_scsi_check_stop_free(struct se_cmd *se_cmd)
 {
-        return target_put_sess_cmd(se_cmd->se_sess, se_cmd);
+        return target_put_sess_cmd(se_cmd);
 }
 
 static void
@@ -970,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,
@@ -1824,50 +1668,6 @@ static void vhost_scsi_port_unlink(struct se_portal_group *se_tpg,
         mutex_unlock(&vhost_scsi_mutex);
 }
 
-static struct se_node_acl *
-vhost_scsi_make_nodeacl(struct se_portal_group *se_tpg,
-                       struct config_group *group,
-                       const char *name)
-{
-        struct se_node_acl *se_nacl, *se_nacl_new;
-        struct vhost_scsi_nacl *nacl;
-        u64 wwpn = 0;
-        u32 nexus_depth;
-
-        /* vhost_scsi_parse_wwn(name, &wwpn, 1) < 0)
-                return ERR_PTR(-EINVAL); */
-        se_nacl_new = vhost_scsi_alloc_fabric_acl(se_tpg);
-        if (!se_nacl_new)
-                return ERR_PTR(-ENOMEM);
-
-        nexus_depth = 1;
-        /*
-         * se_nacl_new may be released by core_tpg_add_initiator_node_acl()
-         * when converting a NodeACL from demo mode -> explict
-         */
-        se_nacl = core_tpg_add_initiator_node_acl(se_tpg, se_nacl_new,
-                                name, nexus_depth);
-        if (IS_ERR(se_nacl)) {
-                vhost_scsi_release_fabric_acl(se_tpg, se_nacl_new);
-                return se_nacl;
-        }
-        /*
-         * Locate our struct vhost_scsi_nacl and set the FC Nport WWPN
-         */
-        nacl = container_of(se_nacl, struct vhost_scsi_nacl, se_node_acl);
-        nacl->iport_wwpn = wwpn;
-
-        return se_nacl;
-}
-
-static void vhost_scsi_drop_nodeacl(struct se_node_acl *se_acl)
-{
-        struct vhost_scsi_nacl *nacl = container_of(se_acl,
-                                struct vhost_scsi_nacl, se_node_acl);
-        core_tpg_del_initiator_node_acl(se_acl->se_tpg, se_acl, 1);
-        kfree(nacl);
-}
-
 static void vhost_scsi_free_cmd_map_res(struct vhost_scsi_nexus *nexus,
                                        struct se_session *se_sess)
 {
@@ -2202,8 +2002,7 @@ vhost_scsi_make_tpg(struct se_wwn *wwn,
         tpg->tport = tport;
         tpg->tport_tpgt = tpgt;
 
-        ret = core_tpg_register(&vhost_scsi_ops, wwn,
-                                &tpg->se_tpg, tpg, TRANSPORT_TPG_TYPE_NORMAL);
+        ret = core_tpg_register(wwn, &tpg->se_tpg, tport->tport_proto_id);
         if (ret < 0) {
                 kfree(tpg);
                 return NULL;
@@ -2327,20 +2126,13 @@ static struct target_core_fabric_ops vhost_scsi_ops = {
         .module                         = THIS_MODULE,
         .name                           = "vhost",
         .get_fabric_name                = vhost_scsi_get_fabric_name,
-        .get_fabric_proto_ident         = vhost_scsi_get_fabric_proto_ident,
         .tpg_get_wwn                    = vhost_scsi_get_fabric_wwn,
         .tpg_get_tag                    = vhost_scsi_get_tpgt,
-        .tpg_get_default_depth          = vhost_scsi_get_default_depth,
-        .tpg_get_pr_transport_id        = vhost_scsi_get_pr_transport_id,
-        .tpg_get_pr_transport_id_len    = vhost_scsi_get_pr_transport_id_len,
-        .tpg_parse_pr_out_transport_id  = vhost_scsi_parse_pr_out_transport_id,
         .tpg_check_demo_mode            = vhost_scsi_check_true,
         .tpg_check_demo_mode_cache      = vhost_scsi_check_true,
         .tpg_check_demo_mode_write_protect = vhost_scsi_check_false,
         .tpg_check_prod_mode_write_protect = vhost_scsi_check_false,
         .tpg_check_prot_fabric_only     = vhost_scsi_check_prot_fabric_only,
-        .tpg_alloc_fabric_acl           = vhost_scsi_alloc_fabric_acl,
-        .tpg_release_fabric_acl         = vhost_scsi_release_fabric_acl,
         .tpg_get_inst_index             = vhost_scsi_tpg_get_inst_index,
         .release_cmd                    = vhost_scsi_release_cmd,
         .check_stop_free                = vhost_scsi_check_stop_free,
@@ -2351,7 +2143,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,
@@ -2366,10 +2157,6 @@ static struct target_core_fabric_ops vhost_scsi_ops = {
         .fabric_drop_tpg                = vhost_scsi_drop_tpg,
         .fabric_post_link               = vhost_scsi_port_link,
         .fabric_pre_unlink              = vhost_scsi_port_unlink,
-        .fabric_make_np                 = NULL,
-        .fabric_drop_np                 = NULL,
-        .fabric_make_nodeacl            = vhost_scsi_make_nodeacl,
-        .fabric_drop_nodeacl            = vhost_scsi_drop_nodeacl,
 
         .tfc_wwn_attrs                  = vhost_scsi_wwn_attrs,
         .tfc_tpg_base_attrs             = vhost_scsi_tpg_attrs,
diff --git a/drivers/xen/xen-scsiback.c b/drivers/xen/xen-scsiback.c
index 39223c3e99ad..9eeefd7cad41 100644
--- a/drivers/xen/xen-scsiback.c
+++ b/drivers/xen/xen-scsiback.c
@@ -53,7 +53,6 @@
 
 #include <target/target_core_base.h>
 #include <target/target_core_fabric.h>
-#include <target/target_core_configfs.h>
 #include <target/target_core_fabric_configfs.h>
 
 #include <asm/hypervisor.h>
@@ -201,8 +200,6 @@ static LIST_HEAD(scsiback_free_pages);
 static DEFINE_MUTEX(scsiback_mutex);
 static LIST_HEAD(scsiback_list);
 
-static const struct target_core_fabric_ops scsiback_ops;
-
 static void scsiback_get(struct vscsibk_info *info)
 {
         atomic_inc(&info->nr_unreplied_reqs);
@@ -397,6 +394,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,
@@ -863,7 +861,8 @@ static int scsiback_add_translation_entry(struct vscsibk_info *info,
         struct list_head *head = &(info->v2p_entry_lists);
         unsigned long flags;
         char *lunp;
-        unsigned int lun;
+        unsigned long long unpacked_lun;
+        struct se_lun *se_lun;
         struct scsiback_tpg *tpg_entry, *tpg = NULL;
         char *error = "doesn't exist";
 
@@ -874,24 +873,27 @@ static int scsiback_add_translation_entry(struct vscsibk_info *info,
         }
         *lunp = 0;
         lunp++;
-        if (kstrtouint(lunp, 10, &lun) || lun >= TRANSPORT_MAX_LUNS_PER_TPG) {
+        err = kstrtoull(lunp, 10, &unpacked_lun);
+        if (err < 0) {
                 pr_err("lun number not valid: %s\n", lunp);
-                return -EINVAL;
+                return err;
         }
 
         mutex_lock(&scsiback_mutex);
         list_for_each_entry(tpg_entry, &scsiback_list, tv_tpg_list) {
                 if (!strcmp(phy, tpg_entry->tport->tport_name) ||
                     !strcmp(phy, tpg_entry->param_alias)) {
-                        spin_lock(&tpg_entry->se_tpg.tpg_lun_lock);
-                        if (tpg_entry->se_tpg.tpg_lun_list[lun]->lun_status ==
-                            TRANSPORT_LUN_STATUS_ACTIVE) {
-                                if (!tpg_entry->tpg_nexus)
-                                        error = "nexus undefined";
-                                else
-                                        tpg = tpg_entry;
+                        mutex_lock(&tpg_entry->se_tpg.tpg_lun_mutex);
+                        hlist_for_each_entry(se_lun, &tpg_entry->se_tpg.tpg_lun_hlist, link) {
+                                if (se_lun->unpacked_lun == unpacked_lun) {
+                                        if (!tpg_entry->tpg_nexus)
+                                                error = "nexus undefined";
+                                        else
+                                                tpg = tpg_entry;
+                                        break;
+                                }
                         }
-                        spin_unlock(&tpg_entry->se_tpg.tpg_lun_lock);
+                        mutex_unlock(&tpg_entry->se_tpg.tpg_lun_mutex);
                         break;
                 }
         }
@@ -903,7 +905,7 @@ static int scsiback_add_translation_entry(struct vscsibk_info *info,
         mutex_unlock(&scsiback_mutex);
 
         if (!tpg) {
-                pr_err("%s:%d %s\n", phy, lun, error);
+                pr_err("%s:%llu %s\n", phy, unpacked_lun, error);
                 return -ENODEV;
         }
 
@@ -931,7 +933,7 @@ static int scsiback_add_translation_entry(struct vscsibk_info *info,
         kref_init(&new->kref);
         new->v = *v;
         new->tpg = tpg;
-        new->lun = lun;
+        new->lun = unpacked_lun;
         list_add_tail(&new->l, head);
 
 out:
@@ -1251,28 +1253,6 @@ static char *scsiback_dump_proto_id(struct scsiback_tport *tport)
         return "Unknown";
 }
 
-static u8 scsiback_get_fabric_proto_ident(struct se_portal_group *se_tpg)
-{
-        struct scsiback_tpg *tpg = container_of(se_tpg,
-                                struct scsiback_tpg, se_tpg);
-        struct scsiback_tport *tport = tpg->tport;
-
-        switch (tport->tport_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-                return sas_get_fabric_proto_ident(se_tpg);
-        case SCSI_PROTOCOL_FCP:
-                return fc_get_fabric_proto_ident(se_tpg);
-        case SCSI_PROTOCOL_ISCSI:
-                return iscsi_get_fabric_proto_ident(se_tpg);
-        default:
-                pr_err("Unknown tport_proto_id: 0x%02x, using SAS emulation\n",
-                        tport->tport_proto_id);
-                break;
-        }
-
-        return sas_get_fabric_proto_ident(se_tpg);
-}
-
 static char *scsiback_get_fabric_wwn(struct se_portal_group *se_tpg)
 {
         struct scsiback_tpg *tpg = container_of(se_tpg,
@@ -1289,102 +1269,6 @@ static u16 scsiback_get_tag(struct se_portal_group *se_tpg)
         return tpg->tport_tpgt;
 }
 
-static u32 scsiback_get_default_depth(struct se_portal_group *se_tpg)
-{
-        return 1;
-}
-
-static u32
-scsiback_get_pr_transport_id(struct se_portal_group *se_tpg,
-                              struct se_node_acl *se_nacl,
-                              struct t10_pr_registration *pr_reg,
-                              int *format_code,
-                              unsigned char *buf)
-{
-        struct scsiback_tpg *tpg = container_of(se_tpg,
-                                struct scsiback_tpg, se_tpg);
-        struct scsiback_tport *tport = tpg->tport;
-
-        switch (tport->tport_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-                return sas_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                                        format_code, buf);
-        case SCSI_PROTOCOL_FCP:
-                return fc_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                                        format_code, buf);
-        case SCSI_PROTOCOL_ISCSI:
-                return iscsi_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                                        format_code, buf);
-        default:
-                pr_err("Unknown tport_proto_id: 0x%02x, using SAS emulation\n",
-                        tport->tport_proto_id);
-                break;
-        }
-
-        return sas_get_pr_transport_id(se_tpg, se_nacl, pr_reg,
-                        format_code, buf);
-}
-
-static u32
-scsiback_get_pr_transport_id_len(struct se_portal_group *se_tpg,
-                                  struct se_node_acl *se_nacl,
-                                  struct t10_pr_registration *pr_reg,
-                                  int *format_code)
-{
-        struct scsiback_tpg *tpg = container_of(se_tpg,
-                                struct scsiback_tpg, se_tpg);
-        struct scsiback_tport *tport = tpg->tport;
-
-        switch (tport->tport_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-                return sas_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                                        format_code);
-        case SCSI_PROTOCOL_FCP:
-                return fc_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                                        format_code);
-        case SCSI_PROTOCOL_ISCSI:
-                return iscsi_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                                        format_code);
-        default:
-                pr_err("Unknown tport_proto_id: 0x%02x, using SAS emulation\n",
-                        tport->tport_proto_id);
-                break;
-        }
-
-        return sas_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,
-                        format_code);
-}
-
-static char *
-scsiback_parse_pr_out_transport_id(struct se_portal_group *se_tpg,
-                                    const char *buf,
-                                    u32 *out_tid_len,
-                                    char **port_nexus_ptr)
-{
-        struct scsiback_tpg *tpg = container_of(se_tpg,
-                                struct scsiback_tpg, se_tpg);
-        struct scsiback_tport *tport = tpg->tport;
-
-        switch (tport->tport_proto_id) {
-        case SCSI_PROTOCOL_SAS:
-                return sas_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                                        port_nexus_ptr);
-        case SCSI_PROTOCOL_FCP:
-                return fc_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                                        port_nexus_ptr);
-        case SCSI_PROTOCOL_ISCSI:
-                return iscsi_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                                        port_nexus_ptr);
-        default:
-                pr_err("Unknown tport_proto_id: 0x%02x, using SAS emulation\n",
-                        tport->tport_proto_id);
-                break;
-        }
-
-        return sas_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,
-                        port_nexus_ptr);
-}
-
 static struct se_wwn *
 scsiback_make_tport(struct target_fabric_configfs *tf,
                      struct config_group *group,
@@ -1451,19 +1335,6 @@ static void scsiback_drop_tport(struct se_wwn *wwn)
         kfree(tport);
 }
 
-static struct se_node_acl *
-scsiback_alloc_fabric_acl(struct se_portal_group *se_tpg)
-{
-        return kzalloc(sizeof(struct se_node_acl), GFP_KERNEL);
-}
-
-static void
-scsiback_release_fabric_acl(struct se_portal_group *se_tpg,
-                             struct se_node_acl *se_nacl)
-{
-        kfree(se_nacl);
-}
-
 static u32 scsiback_tpg_get_inst_index(struct se_portal_group *se_tpg)
 {
         return 1;
@@ -1522,14 +1393,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;
@@ -1898,8 +1761,7 @@ scsiback_make_tpg(struct se_wwn *wwn,
         tpg->tport = tport;
         tpg->tport_tpgt = tpgt;
 
-        ret = core_tpg_register(&scsiback_ops, wwn,
-                                &tpg->se_tpg, tpg, TRANSPORT_TPG_TYPE_NORMAL);
+        ret = core_tpg_register(wwn, &tpg->se_tpg, tport->tport_proto_id);
         if (ret < 0) {
                 kfree(tpg);
                 return NULL;
@@ -1944,23 +1806,15 @@ static const struct target_core_fabric_ops scsiback_ops = {
         .module                         = THIS_MODULE,
         .name                           = "xen-pvscsi",
         .get_fabric_name                = scsiback_get_fabric_name,
-        .get_fabric_proto_ident         = scsiback_get_fabric_proto_ident,
         .tpg_get_wwn                    = scsiback_get_fabric_wwn,
         .tpg_get_tag                    = scsiback_get_tag,
-        .tpg_get_default_depth          = scsiback_get_default_depth,
-        .tpg_get_pr_transport_id        = scsiback_get_pr_transport_id,
-        .tpg_get_pr_transport_id_len    = scsiback_get_pr_transport_id_len,
-        .tpg_parse_pr_out_transport_id  = scsiback_parse_pr_out_transport_id,
         .tpg_check_demo_mode            = scsiback_check_true,
         .tpg_check_demo_mode_cache      = scsiback_check_true,
         .tpg_check_demo_mode_write_protect = scsiback_check_false,
         .tpg_check_prod_mode_write_protect = scsiback_check_false,
-        .tpg_alloc_fabric_acl           = scsiback_alloc_fabric_acl,
-        .tpg_release_fabric_acl         = scsiback_release_fabric_acl,
         .tpg_get_inst_index             = scsiback_tpg_get_inst_index,
         .check_stop_free                = scsiback_check_stop_free,
         .release_cmd                    = scsiback_release_cmd,
-        .put_session                    = NULL,
         .shutdown_session               = scsiback_shutdown_session,
         .close_session                  = scsiback_close_session,
         .sess_get_index                 = scsiback_sess_get_index,
@@ -1968,7 +1822,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,
@@ -1983,12 +1836,6 @@ static const struct target_core_fabric_ops scsiback_ops = {
         .fabric_drop_tpg                = scsiback_drop_tpg,
         .fabric_post_link               = scsiback_port_link,
         .fabric_pre_unlink              = scsiback_port_unlink,
-        .fabric_make_np                 = NULL,
-        .fabric_drop_np                 = NULL,
-#if 0
-        .fabric_make_nodeacl            = scsiback_make_nodeacl,
-        .fabric_drop_nodeacl            = scsiback_drop_nodeacl,
-#endif
 
         .tfc_wwn_attrs                  = scsiback_wwn_attrs,
         .tfc_tpg_base_attrs             = scsiback_tpg_attrs,
diff --git a/include/linux/crc-t10dif.h b/include/linux/crc-t10dif.h
index cf53d0773ce3..d81961e9e37d 100644
--- a/include/linux/crc-t10dif.h
+++ b/include/linux/crc-t10dif.h
@@ -9,5 +9,6 @@
 extern __u16 crc_t10dif_generic(__u16 crc, const unsigned char *buffer,
                                 size_t len);
 extern __u16 crc_t10dif(unsigned char const *, size_t);
+extern __u16 crc_t10dif_update(__u16 crc, unsigned char const *, size_t);
 
 #endif
diff --git a/include/target/iscsi/iscsi_target_core.h b/include/target/iscsi/iscsi_target_core.h
index 006983b296dd..34117b8b72e4 100644
--- a/include/target/iscsi/iscsi_target_core.h
+++ b/include/target/iscsi/iscsi_target_core.h
@@ -247,10 +247,6 @@ struct iscsi_conn_ops {
         u8      DataDigest;                     /* [0,1] == [None,CRC32C] */
         u32     MaxRecvDataSegmentLength;       /* [512..2**24-1] */
         u32     MaxXmitDataSegmentLength;       /* [512..2**24-1] */
-        u8      OFMarker;                       /* [0,1] == [No,Yes] */
-        u8      IFMarker;                       /* [0,1] == [No,Yes] */
-        u32     OFMarkInt;                      /* [1..65535] */
-        u32     IFMarkInt;                      /* [1..65535] */
         /*
          * iSER specific connection parameters
          */
@@ -531,12 +527,6 @@ struct iscsi_conn {
         u32                     exp_statsn;
         /* Per connection status sequence number */
         u32                     stat_sn;
-        /* IFMarkInt's Current Value */
-        u32                     if_marker;
-        /* OFMarkInt's Current Value */
-        u32                     of_marker;
-        /* Used for calculating OFMarker offset to next PDU */
-        u32                     of_marker_offset;
 #define IPV6_ADDRESS_SPACE                              48
         unsigned char           login_ip[IPV6_ADDRESS_SPACE];
         unsigned char           local_ip[IPV6_ADDRESS_SPACE];
@@ -754,10 +744,10 @@ struct iscsi_node_stat_grps {
 };
 
 struct iscsi_node_acl {
+        struct se_node_acl      se_node_acl;
         struct iscsi_node_attrib node_attrib;
         struct iscsi_node_auth  node_auth;
         struct iscsi_node_stat_grps node_stat_grps;
-        struct se_node_acl      se_node_acl;
 };
 
 struct iscsi_tpg_attrib {
diff --git a/include/target/target_core_backend.h b/include/target/target_core_backend.h
index 5f1225706993..1e5c8f949bae 100644
--- a/include/target/target_core_backend.h
+++ b/include/target/target_core_backend.h
@@ -3,18 +3,7 @@
 
 #define TRANSPORT_FLAG_PASSTHROUGH              1
 
-struct target_backend_cits {
-        struct config_item_type tb_dev_cit;
-        struct config_item_type tb_dev_attrib_cit;
-        struct config_item_type tb_dev_pr_cit;
-        struct config_item_type tb_dev_wwn_cit;
-        struct config_item_type tb_dev_alua_tg_pt_gps_cit;
-        struct config_item_type tb_dev_stat_cit;
-};
-
-struct se_subsystem_api {
-        struct list_head sub_api_list;
-
+struct target_backend_ops {
         char name[16];
         char inquiry_prod[16];
         char inquiry_rev[4];
@@ -52,7 +41,7 @@ struct se_subsystem_api {
         int (*format_prot)(struct se_device *);
         void (*free_prot)(struct se_device *);
 
-        struct target_backend_cits tb_cits;
+        struct configfs_attribute **tb_dev_attrib_attrs;
 };
 
 struct sbc_ops {
@@ -60,12 +49,12 @@ struct sbc_ops {
                                      u32, enum dma_data_direction);
         sense_reason_t (*execute_sync_cache)(struct se_cmd *cmd);
         sense_reason_t (*execute_write_same)(struct se_cmd *cmd);
-        sense_reason_t (*execute_write_same_unmap)(struct se_cmd *cmd);
-        sense_reason_t (*execute_unmap)(struct se_cmd *cmd);
+        sense_reason_t (*execute_unmap)(struct se_cmd *cmd,
+                                sector_t lba, sector_t nolb);
 };
 
-int     transport_subsystem_register(struct se_subsystem_api *);
-void    transport_subsystem_release(struct se_subsystem_api *);
+int     transport_backend_register(const struct target_backend_ops *);
+void    target_backend_unregister(const struct target_backend_ops *);
 
 void    target_complete_cmd(struct se_cmd *, u8);
 void    target_complete_cmd_with_length(struct se_cmd *, u8, int);
@@ -79,22 +68,19 @@ sense_reason_t	sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops);
 u32     sbc_get_device_rev(struct se_device *dev);
 u32     sbc_get_device_type(struct se_device *dev);
 sector_t        sbc_get_write_same_sectors(struct se_cmd *cmd);
-sense_reason_t sbc_execute_unmap(struct se_cmd *cmd,
-        sense_reason_t (*do_unmap_fn)(struct se_cmd *cmd, void *priv,
-                                      sector_t lba, sector_t nolb),
-        void *priv);
 void    sbc_dif_generate(struct se_cmd *);
-sense_reason_t  sbc_dif_verify_write(struct se_cmd *, sector_t, unsigned int,
+sense_reason_t  sbc_dif_verify(struct se_cmd *, sector_t, unsigned int,
                                      unsigned int, struct scatterlist *, int);
-sense_reason_t  sbc_dif_verify_read(struct se_cmd *, sector_t, unsigned int,
-                                    unsigned int, struct scatterlist *, int);
-sense_reason_t  sbc_dif_read_strip(struct se_cmd *);
-
+void sbc_dif_copy_prot(struct se_cmd *, unsigned int, bool,
+                       struct scatterlist *, int);
 void    transport_set_vpd_proto_id(struct t10_vpd *, unsigned char *);
 int     transport_set_vpd_assoc(struct t10_vpd *, unsigned char *);
 int     transport_set_vpd_ident_type(struct t10_vpd *, unsigned char *);
 int     transport_set_vpd_ident(struct t10_vpd *, unsigned char *);
 
+extern struct configfs_attribute *sbc_attrib_attrs[];
+extern struct configfs_attribute *passthrough_attrib_attrs[];
+
 /* core helpers also used by command snooping in pscsi */
 void    *transport_kmap_data_sg(struct se_cmd *);
 void    transport_kunmap_data_sg(struct se_cmd *);
@@ -103,39 +89,7 @@ int	target_alloc_sgl(struct scatterlist **, unsigned int *, u32, bool);
 sense_reason_t  transport_generic_map_mem_to_cmd(struct se_cmd *,
                 struct scatterlist *, u32, struct scatterlist *, u32);
 
-void    array_free(void *array, int n);
-
-/* From target_core_configfs.c to setup default backend config_item_types */
-void    target_core_setup_sub_cits(struct se_subsystem_api *);
-
-/* attribute helpers from target_core_device.c for backend drivers */
-bool    se_dev_check_wce(struct se_device *);
-int     se_dev_set_max_unmap_lba_count(struct se_device *, u32);
-int     se_dev_set_max_unmap_block_desc_count(struct se_device *, u32);
-int     se_dev_set_unmap_granularity(struct se_device *, u32);
-int     se_dev_set_unmap_granularity_alignment(struct se_device *, u32);
-int     se_dev_set_max_write_same_len(struct se_device *, u32);
-int     se_dev_set_emulate_model_alias(struct se_device *, int);
-int     se_dev_set_emulate_dpo(struct se_device *, int);
-int     se_dev_set_emulate_fua_write(struct se_device *, int);
-int     se_dev_set_emulate_fua_read(struct se_device *, int);
-int     se_dev_set_emulate_write_cache(struct se_device *, int);
-int     se_dev_set_emulate_ua_intlck_ctrl(struct se_device *, int);
-int     se_dev_set_emulate_tas(struct se_device *, int);
-int     se_dev_set_emulate_tpu(struct se_device *, int);
-int     se_dev_set_emulate_tpws(struct se_device *, int);
-int     se_dev_set_emulate_caw(struct se_device *, int);
-int     se_dev_set_emulate_3pc(struct se_device *, int);
-int     se_dev_set_pi_prot_type(struct se_device *, int);
-int     se_dev_set_pi_prot_format(struct se_device *, int);
-int     se_dev_set_enforce_pr_isids(struct se_device *, int);
-int     se_dev_set_force_pr_aptpl(struct se_device *, int);
-int     se_dev_set_is_nonrot(struct se_device *, int);
-int     se_dev_set_emulate_rest_reord(struct se_device *dev, int);
-int     se_dev_set_queue_depth(struct se_device *, u32);
-int     se_dev_set_max_sectors(struct se_device *, u32);
-int     se_dev_set_optimal_sectors(struct se_device *, u32);
-int     se_dev_set_block_size(struct se_device *, u32);
+bool    target_lun_is_rdonly(struct se_cmd *);
 sense_reason_t passthrough_parse_cdb(struct se_cmd *cmd,
         sense_reason_t (*exec_cmd)(struct se_cmd *cmd));
 
diff --git a/include/target/target_core_backend_configfs.h b/include/target/target_core_backend_configfs.h
deleted file mode 100644
index 186f7a923570..000000000000
--- a/include/target/target_core_backend_configfs.h
+++ /dev/null
@@ -1,118 +0,0 @@
-#ifndef TARGET_CORE_BACKEND_CONFIGFS_H
-#define TARGET_CORE_BACKEND_CONFIGFS_H
-
-#include <target/configfs_macros.h>
-
-#define DEF_TB_DEV_ATTRIB_SHOW(_backend, _name)                         \
-static ssize_t _backend##_dev_show_attr_##_name(                        \
-        struct se_dev_attrib *da,                                       \
-        char *page)                                                     \
-{                                                                       \
-        return snprintf(page, PAGE_SIZE, "%u\n",                        \
-                        (u32)da->da_dev->dev_attrib._name);             \
-}
-
-#define DEF_TB_DEV_ATTRIB_STORE(_backend, _name)                        \
-static ssize_t _backend##_dev_store_attr_##_name(                       \
-        struct se_dev_attrib *da,                                       \
-        const char *page,                                               \
-        size_t count)                                                   \
-{                                                                       \
-        unsigned long val;                                              \
-        int ret;                                                        \
-                                                                        \
-        ret = kstrtoul(page, 0, &val);                                  \
-        if (ret < 0) {                                                  \
-                pr_err("kstrtoul() failed with ret: %d\n", ret);        \
-                return -EINVAL;                                         \
-        }                                                               \
-        ret = se_dev_set_##_name(da->da_dev, (u32)val);                 \
-                                                                        \
-        return (!ret) ? count : -EINVAL;                                \
-}
-
-#define DEF_TB_DEV_ATTRIB(_backend, _name)                              \
-DEF_TB_DEV_ATTRIB_SHOW(_backend, _name);                                \
-DEF_TB_DEV_ATTRIB_STORE(_backend, _name);
-
-#define DEF_TB_DEV_ATTRIB_RO(_backend, name)                            \
-DEF_TB_DEV_ATTRIB_SHOW(_backend, name);
-
-CONFIGFS_EATTR_STRUCT(target_backend_dev_attrib, se_dev_attrib);
-#define TB_DEV_ATTR(_backend, _name, _mode)                             \
-static struct target_backend_dev_attrib_attribute _backend##_dev_attrib_##_name = \
-                __CONFIGFS_EATTR(_name, _mode,                          \
-                _backend##_dev_show_attr_##_name,                       \
-                _backend##_dev_store_attr_##_name);
-
-#define TB_DEV_ATTR_RO(_backend, _name)                                         \
-static struct target_backend_dev_attrib_attribute _backend##_dev_attrib_##_name = \
-        __CONFIGFS_EATTR_RO(_name,                                      \
-        _backend##_dev_show_attr_##_name);
-
-/*
- * Default list of target backend device attributes as defined by
- * struct se_dev_attrib
- */
-
-#define DEF_TB_DEFAULT_ATTRIBS(_backend)                                \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_model_alias);               \
-        TB_DEV_ATTR(_backend, emulate_model_alias, S_IRUGO | S_IWUSR);  \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_dpo);                       \
-        TB_DEV_ATTR(_backend, emulate_dpo, S_IRUGO | S_IWUSR);          \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_fua_write);                 \
-        TB_DEV_ATTR(_backend, emulate_fua_write, S_IRUGO | S_IWUSR);    \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_fua_read);                  \
-        TB_DEV_ATTR(_backend, emulate_fua_read, S_IRUGO | S_IWUSR);     \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_write_cache);               \
-        TB_DEV_ATTR(_backend, emulate_write_cache, S_IRUGO | S_IWUSR);  \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_ua_intlck_ctrl);            \
-        TB_DEV_ATTR(_backend, emulate_ua_intlck_ctrl, S_IRUGO | S_IWUSR); \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_tas);                       \
-        TB_DEV_ATTR(_backend, emulate_tas, S_IRUGO | S_IWUSR);          \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_tpu);                       \
-        TB_DEV_ATTR(_backend, emulate_tpu, S_IRUGO | S_IWUSR);          \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_tpws);                      \
-        TB_DEV_ATTR(_backend, emulate_tpws, S_IRUGO | S_IWUSR);         \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_caw);                       \
-        TB_DEV_ATTR(_backend, emulate_caw, S_IRUGO | S_IWUSR);          \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_3pc);                       \
-        TB_DEV_ATTR(_backend, emulate_3pc, S_IRUGO | S_IWUSR);          \
-        DEF_TB_DEV_ATTRIB(_backend, pi_prot_type);                      \
-        TB_DEV_ATTR(_backend, pi_prot_type, S_IRUGO | S_IWUSR);         \
-        DEF_TB_DEV_ATTRIB_RO(_backend, hw_pi_prot_type);                \
-        TB_DEV_ATTR_RO(_backend, hw_pi_prot_type);                      \
-        DEF_TB_DEV_ATTRIB(_backend, pi_prot_format);                    \
-        TB_DEV_ATTR(_backend, pi_prot_format, S_IRUGO | S_IWUSR);       \
-        DEF_TB_DEV_ATTRIB(_backend, enforce_pr_isids);                  \
-        TB_DEV_ATTR(_backend, enforce_pr_isids, S_IRUGO | S_IWUSR);     \
-        DEF_TB_DEV_ATTRIB(_backend, is_nonrot);                         \
-        TB_DEV_ATTR(_backend, is_nonrot, S_IRUGO | S_IWUSR);            \
-        DEF_TB_DEV_ATTRIB(_backend, emulate_rest_reord);                \
-        TB_DEV_ATTR(_backend, emulate_rest_reord, S_IRUGO | S_IWUSR);   \
-        DEF_TB_DEV_ATTRIB(_backend, force_pr_aptpl);                    \
-        TB_DEV_ATTR(_backend, force_pr_aptpl, S_IRUGO | S_IWUSR);       \
-        DEF_TB_DEV_ATTRIB_RO(_backend, hw_block_size);                  \
-        TB_DEV_ATTR_RO(_backend, hw_block_size);                        \
-        DEF_TB_DEV_ATTRIB(_backend, block_size);                        \
-        TB_DEV_ATTR(_backend, block_size, S_IRUGO | S_IWUSR);           \
-        DEF_TB_DEV_ATTRIB_RO(_backend, hw_max_sectors);                 \
-        TB_DEV_ATTR_RO(_backend, hw_max_sectors);                       \
-        DEF_TB_DEV_ATTRIB(_backend, optimal_sectors);                   \
-        TB_DEV_ATTR(_backend, optimal_sectors, S_IRUGO | S_IWUSR);      \
-        DEF_TB_DEV_ATTRIB_RO(_backend, hw_queue_depth);                 \
-        TB_DEV_ATTR_RO(_backend, hw_queue_depth);                       \
-        DEF_TB_DEV_ATTRIB(_backend, queue_depth);                       \
-        TB_DEV_ATTR(_backend, queue_depth, S_IRUGO | S_IWUSR);          \
-        DEF_TB_DEV_ATTRIB(_backend, max_unmap_lba_count);               \
-        TB_DEV_ATTR(_backend, max_unmap_lba_count, S_IRUGO | S_IWUSR);  \
-        DEF_TB_DEV_ATTRIB(_backend, max_unmap_block_desc_count);        \
-        TB_DEV_ATTR(_backend, max_unmap_block_desc_count, S_IRUGO | S_IWUSR); \
-        DEF_TB_DEV_ATTRIB(_backend, unmap_granularity);                 \
-        TB_DEV_ATTR(_backend, unmap_granularity, S_IRUGO | S_IWUSR);    \
-        DEF_TB_DEV_ATTRIB(_backend, unmap_granularity_alignment);       \
-        TB_DEV_ATTR(_backend, unmap_granularity_alignment, S_IRUGO | S_IWUSR); \
-        DEF_TB_DEV_ATTRIB(_backend, max_write_same_len);                \
-        TB_DEV_ATTR(_backend, max_write_same_len, S_IRUGO | S_IWUSR);
-
-#endif /* TARGET_CORE_BACKEND_CONFIGFS_H */
diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h
index aec6f6a4477c..17ae2d6a4891 100644
--- a/include/target/target_core_base.h
+++ b/include/target/target_core_base.h
@@ -9,12 +9,8 @@
 #include <net/sock.h>
 #include <net/tcp.h>
 
-#define TARGET_CORE_MOD_VERSION         "v4.1.0"
-#define TARGET_CORE_VERSION             TARGET_CORE_MOD_VERSION
+#define TARGET_CORE_VERSION             "v5.0"
 
-/* Maximum Number of LUNs per Target Portal Group */
-/* Don't raise above 511 or REPORT_LUNS needs to handle >1 page */
-#define TRANSPORT_MAX_LUNS_PER_TPG              256
 /*
  * Maximum size of a CDB that can be stored in se_cmd without allocating
  * memory dynamically for the CDB.
@@ -70,12 +66,6 @@
 #define DA_MAX_WRITE_SAME_LEN                   0
 /* Use a model alias based on the configfs backend device name */
 #define DA_EMULATE_MODEL_ALIAS                  0
-/* Emulation for Direct Page Out */
-#define DA_EMULATE_DPO                          0
-/* Emulation for Forced Unit Access WRITEs */
-#define DA_EMULATE_FUA_WRITE                    1
-/* Emulation for Forced Unit Access READs */
-#define DA_EMULATE_FUA_READ                     0
 /* Emulation for WriteCache and SYNCHRONIZE_CACHE */
 #define DA_EMULATE_WRITE_CACHE                  0
 /* Emulation for UNIT ATTENTION Interlock Control */
@@ -116,18 +106,6 @@ enum hba_flags_table {
         HBA_FLAGS_PSCSI_MODE    = 0x02,
 };
 
-/* struct se_lun->lun_status */
-enum transport_lun_status_table {
-        TRANSPORT_LUN_STATUS_FREE = 0,
-        TRANSPORT_LUN_STATUS_ACTIVE = 1,
-};
-
-/* struct se_portal_group->se_tpg_type */
-enum transport_tpg_type_table {
-        TRANSPORT_TPG_TYPE_NORMAL = 0,
-        TRANSPORT_TPG_TYPE_DISCOVERY = 1,
-};
-
 /* Special transport agnostic struct se_cmd->t_states */
 enum transport_state_table {
         TRANSPORT_NO_STATE      = 0,
@@ -158,14 +136,13 @@ enum se_cmd_flags_table {
         SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC = 0x00020000,
         SCF_COMPARE_AND_WRITE           = 0x00080000,
         SCF_COMPARE_AND_WRITE_POST      = 0x00100000,
+        SCF_PASSTHROUGH_PROT_SG_TO_MEM_NOALLOC = 0x00200000,
 };
 
 /* struct se_dev_entry->lun_flags and struct se_lun->lun_access */
 enum transport_lunflags_table {
-        TRANSPORT_LUNFLAGS_NO_ACCESS            = 0x00,
-        TRANSPORT_LUNFLAGS_INITIATOR_ACCESS     = 0x01,
-        TRANSPORT_LUNFLAGS_READ_ONLY            = 0x02,
-        TRANSPORT_LUNFLAGS_READ_WRITE           = 0x04,
+        TRANSPORT_LUNFLAGS_READ_ONLY            = 0x01,
+        TRANSPORT_LUNFLAGS_READ_WRITE           = 0x02,
 };
 
 /*
@@ -314,22 +291,13 @@ struct t10_alua_tg_pt_gp {
         struct se_device *tg_pt_gp_dev;
         struct config_group tg_pt_gp_group;
         struct list_head tg_pt_gp_list;
-        struct list_head tg_pt_gp_mem_list;
-        struct se_port *tg_pt_gp_alua_port;
+        struct list_head tg_pt_gp_lun_list;
+        struct se_lun *tg_pt_gp_alua_lun;
         struct se_node_acl *tg_pt_gp_alua_nacl;
         struct delayed_work tg_pt_gp_transition_work;
         struct completion *tg_pt_gp_transition_complete;
 };
 
-struct t10_alua_tg_pt_gp_member {
-        bool tg_pt_gp_assoc;
-        atomic_t tg_pt_gp_mem_ref_cnt;
-        spinlock_t tg_pt_gp_mem_lock;
-        struct t10_alua_tg_pt_gp *tg_pt_gp;
-        struct se_port *tg_pt;
-        struct list_head tg_pt_gp_mem_list;
-};
-
 struct t10_vpd {
         unsigned char device_identifier[INQUIRY_VPD_DEVICE_IDENTIFIER_LEN];
         int protocol_identifier_set;
@@ -374,15 +342,16 @@ struct t10_pr_registration {
         int pr_res_scope;
         /* Used for fabric initiator WWPNs using a ISID */
         bool isid_present_at_reg;
-        u32 pr_res_mapped_lun;
-        u32 pr_aptpl_target_lun;
+        u64 pr_res_mapped_lun;
+        u64 pr_aptpl_target_lun;
+        u16 tg_pt_sep_rtpi;
         u32 pr_res_generation;
         u64 pr_reg_bin_isid;
         u64 pr_res_key;
         atomic_t pr_res_holders;
         struct se_node_acl *pr_reg_nacl;
+        /* Used by ALL_TG_PT=1 registration with deve->pr_ref taken */
         struct se_dev_entry *pr_reg_deve;
-        struct se_lun *pr_reg_tg_pt_lun;
         struct list_head pr_reg_list;
         struct list_head pr_reg_abort_list;
         struct list_head pr_reg_aptpl_list;
@@ -422,7 +391,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;
@@ -475,6 +444,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 */
@@ -493,7 +463,7 @@ struct se_cmd {
         /* Total size in bytes associated with command */
         u32                     data_length;
         u32                     residual_count;
-        u32                     orig_fe_lun;
+        u64                     orig_fe_lun;
         /* Persistent Reservation key */
         u64                     pr_res_key;
         /* Used for sense data */
@@ -501,7 +471,6 @@ struct se_cmd {
         struct list_head        se_delayed_node;
         struct list_head        se_qf_node;
         struct se_device      *se_dev;
-        struct se_dev_entry   *se_deve;
         struct se_lun           *se_lun;
         /* Only used for internal passthrough and legacy TCM fabric modules */
         struct se_session       *se_sess;
@@ -511,9 +480,8 @@ struct se_cmd {
         struct kref             cmd_kref;
         const struct target_core_fabric_ops *se_tfo;
         sense_reason_t          (*execute_cmd)(struct se_cmd *);
-        sense_reason_t          (*execute_rw)(struct se_cmd *, struct scatterlist *,
-                                              u32, enum dma_data_direction);
         sense_reason_t (*transport_complete_callback)(struct se_cmd *, bool);
+        void                    *protocol_data;
 
         unsigned char           *t_task_cdb;
         unsigned char           __t_task_cdb[TCM_MAX_COMMAND_SIZE];
@@ -569,7 +537,6 @@ struct se_cmd {
 struct se_ua {
         u8                      ua_asc;
         u8                      ua_ascq;
-        struct se_node_acl      *ua_nacl;
         struct list_head        ua_nacl_list;
 };
 
@@ -585,10 +552,10 @@ struct se_node_acl {
         char                    acl_tag[MAX_ACL_TAG_SIZE];
         /* Used for PR SPEC_I_PT=1 and REGISTER_AND_MOVE */
         atomic_t                acl_pr_ref_count;
-        struct se_dev_entry     **device_list;
+        struct hlist_head       lun_entry_hlist;
         struct se_session       *nacl_sess;
         struct se_portal_group *se_tpg;
-        spinlock_t              device_list_lock;
+        struct mutex            lun_entry_mutex;
         spinlock_t              nacl_sess_lock;
         struct config_group     acl_group;
         struct config_group     acl_attrib_group;
@@ -632,33 +599,37 @@ struct se_ml_stat_grps {
 
 struct se_lun_acl {
         char                    initiatorname[TRANSPORT_IQN_LEN];
-        u32                     mapped_lun;
+        u64                     mapped_lun;
         struct se_node_acl      *se_lun_nacl;
         struct se_lun           *se_lun;
-        struct list_head        lacl_list;
         struct config_group     se_lun_group;
         struct se_ml_stat_grps  ml_stat_grps;
 };
 
 struct se_dev_entry {
-        bool                    def_pr_registered;
         /* See transport_lunflags_table */
-        u32                     lun_flags;
-        u32                     mapped_lun;
-        u32                     total_cmds;
+        u64                     mapped_lun;
         u64                     pr_res_key;
         u64                     creation_time;
+        u32                     lun_flags;
         u32                     attach_count;
-        u64                     read_bytes;
-        u64                     write_bytes;
+        atomic_long_t           total_cmds;
+        atomic_long_t           read_bytes;
+        atomic_long_t           write_bytes;
         atomic_t                ua_count;
         /* Used for PR SPEC_I_PT=1 and REGISTER_AND_MOVE */
-        atomic_t                pr_ref_count;
-        struct se_lun_acl       *se_lun_acl;
+        struct kref             pr_kref;
+        struct completion       pr_comp;
+        struct se_lun_acl __rcu *se_lun_acl;
         spinlock_t              ua_lock;
-        struct se_lun           *se_lun;
+        struct se_lun __rcu     *se_lun;
+#define DEF_PR_REG_ACTIVE               1
+        unsigned long           deve_flags;
         struct list_head        alua_port_list;
+        struct list_head        lun_link;
         struct list_head        ua_list;
+        struct hlist_node       link;
+        struct rcu_head         rcu_head;
 };
 
 struct se_dev_attrib {
@@ -703,25 +674,48 @@ struct se_port_stat_grps {
         struct config_group scsi_transport_group;
 };
 
+struct scsi_port_stats {
+        atomic_long_t   cmd_pdus;
+        atomic_long_t   tx_data_octets;
+        atomic_long_t   rx_data_octets;
+};
+
 struct se_lun {
+        u64                     unpacked_lun;
 #define SE_LUN_LINK_MAGIC                       0xffff7771
         u32                     lun_link_magic;
-        /* See transport_lun_status_table */
-        enum transport_lun_status_table lun_status;
         u32                     lun_access;
         u32                     lun_flags;
-        u32                     unpacked_lun;
+        u32                     lun_index;
+
+        /* RELATIVE TARGET PORT IDENTIFER */
+        u16                     lun_rtpi;
         atomic_t                lun_acl_count;
-        spinlock_t              lun_acl_lock;
-        spinlock_t              lun_sep_lock;
-        struct completion       lun_shutdown_comp;
-        struct list_head        lun_acl_list;
-        struct se_device        *lun_se_dev;
-        struct se_port          *lun_sep;
+        struct se_device __rcu  *lun_se_dev;
+
+        struct list_head        lun_deve_list;
+        spinlock_t              lun_deve_lock;
+
+        /* ALUA state */
+        int                     lun_tg_pt_secondary_stat;
+        int                     lun_tg_pt_secondary_write_md;
+        atomic_t                lun_tg_pt_secondary_offline;
+        struct mutex            lun_tg_pt_md_mutex;
+
+        /* ALUA target port group linkage */
+        struct list_head        lun_tg_pt_gp_link;
+        struct t10_alua_tg_pt_gp *lun_tg_pt_gp;
+        spinlock_t              lun_tg_pt_gp_lock;
+
+        struct se_portal_group  *lun_tpg;
+        struct scsi_port_stats  lun_stats;
         struct config_group     lun_group;
         struct se_port_stat_grps port_stat_grps;
         struct completion       lun_ref_comp;
         struct percpu_ref       lun_ref;
+        struct list_head        lun_dev_link;
+        struct hlist_node       link;
+        struct rcu_head         rcu_head;
 };
 
 struct se_dev_stat_grps {
@@ -744,7 +738,6 @@ struct se_device {
 #define DF_EMULATED_VPD_UNIT_SERIAL             0x00000004
 #define DF_USING_UDEV_PATH                      0x00000008
 #define DF_USING_ALIAS                          0x00000010
-        u32                     dev_port_count;
         /* Physical device queue depth */
         u32                     queue_depth;
         /* Used for SPC-2 reservations enforce of ISIDs */
@@ -761,7 +754,7 @@ struct se_device {
         atomic_t                dev_ordered_id;
         atomic_t                dev_ordered_sync;
         atomic_t                dev_qf_count;
-        int                     export_count;
+        u32                     export_count;
         spinlock_t              delayed_cmd_lock;
         spinlock_t              execute_task_lock;
         spinlock_t              dev_reservation_lock;
@@ -803,12 +796,15 @@ struct se_device {
 #define SE_UDEV_PATH_LEN 512            /* must be less than PAGE_SIZE */
         unsigned char           udev_path[SE_UDEV_PATH_LEN];
         /* Pointer to template of function pointers for transport */
-        struct se_subsystem_api *transport;
+        const struct target_backend_ops *transport;
         /* Linked list for struct se_hba struct se_device list */
         struct list_head        dev_list;
         struct se_lun           xcopy_lun;
         /* Protection Information */
         int                     prot_length;
+        /* For se_lun->lun_se_dev RCU read-side critical access */
+        u32                     hba_index;
+        struct rcu_head         rcu_head;
 };
 
 struct se_hba {
@@ -825,33 +821,7 @@ struct se_hba {
         spinlock_t              device_lock;
         struct config_group     hba_group;
         struct mutex            hba_access_mutex;
-        struct se_subsystem_api *transport;
-};
-
-struct scsi_port_stats {
-       u64     cmd_pdus;
-       u64     tx_data_octets;
-       u64     rx_data_octets;
-};
-
-struct se_port {
-        /* RELATIVE TARGET PORT IDENTIFER */
-        u16             sep_rtpi;
-        int             sep_tg_pt_secondary_stat;
-        int             sep_tg_pt_secondary_write_md;
-        u32             sep_index;
-        struct scsi_port_stats sep_stats;
-        /* Used for ALUA Target Port Groups membership */
-        atomic_t        sep_tg_pt_secondary_offline;
-        /* Used for PR ALL_TG_PT=1 */
-        atomic_t        sep_tg_pt_ref_cnt;
-        spinlock_t      sep_alua_lock;
-        struct mutex    sep_tg_pt_md_mutex;
-        struct t10_alua_tg_pt_gp_member *sep_alua_tg_pt_gp_mem;
-        struct se_lun *sep_lun;
-        struct se_portal_group *sep_tpg;
-        struct list_head sep_alua_list;
-        struct list_head sep_list;
+        struct target_backend   *backend;
 };
 
 struct se_tpg_np {
@@ -860,24 +830,26 @@ struct se_tpg_np {
 };
 
 struct se_portal_group {
-        /* Type of target portal group, see transport_tpg_type_table */
-        enum transport_tpg_type_table se_tpg_type;
+        /*
+         * PROTOCOL IDENTIFIER value per SPC4, 7.5.1.
+         *
+         * Negative values can be used by fabric drivers for internal use TPGs.
+         */
+        int                     proto_id;
         /* Number of ACLed Initiator Nodes for this TPG */
         u32                     num_node_acls;
         /* Used for PR SPEC_I_PT=1 and REGISTER_AND_MOVE */
         atomic_t                tpg_pr_ref_count;
         /* Spinlock for adding/removing ACLed Nodes */
-        spinlock_t              acl_node_lock;
+        struct mutex            acl_node_mutex;
         /* Spinlock for adding/removing sessions */
         spinlock_t              session_lock;
-        spinlock_t              tpg_lun_lock;
-        /* Pointer to $FABRIC_MOD portal group */
-        void                    *se_tpg_fabric_ptr;
+        struct mutex            tpg_lun_mutex;
         struct list_head        se_tpg_node;
         /* linked list for initiator ACL list */
         struct list_head        acl_node_list;
-        struct se_lun           **tpg_lun_list;
-        struct se_lun           tpg_virt_lun0;
+        struct hlist_head       tpg_lun_hlist;
+        struct se_lun           *tpg_virt_lun0;
         /* List of TCM sessions associated wth this TPG */
         struct list_head        tpg_sess_list;
         /* Pointer to $FABRIC_MOD dependent code */
diff --git a/include/target/target_core_configfs.h b/include/target/target_core_configfs.h
deleted file mode 100644
index b99c01170392..000000000000
--- a/include/target/target_core_configfs.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#define TARGET_CORE_CONFIGFS_VERSION TARGET_CORE_MOD_VERSION
-
-#define TARGET_CORE_CONFIG_ROOT "/sys/kernel/config"
-
-#define TARGET_CORE_NAME_MAX_LEN        64
-#define TARGET_FABRIC_NAME_SIZE         32
-
-struct target_fabric_configfs_template {
-        struct config_item_type tfc_discovery_cit;
-        struct config_item_type tfc_wwn_cit;
-        struct config_item_type tfc_wwn_fabric_stats_cit;
-        struct config_item_type tfc_tpg_cit;
-        struct config_item_type tfc_tpg_base_cit;
-        struct config_item_type tfc_tpg_lun_cit;
-        struct config_item_type tfc_tpg_port_cit;
-        struct config_item_type tfc_tpg_port_stat_cit;
-        struct config_item_type tfc_tpg_np_cit;
-        struct config_item_type tfc_tpg_np_base_cit;
-        struct config_item_type tfc_tpg_attrib_cit;
-        struct config_item_type tfc_tpg_auth_cit;
-        struct config_item_type tfc_tpg_param_cit;
-        struct config_item_type tfc_tpg_nacl_cit;
-        struct config_item_type tfc_tpg_nacl_base_cit;
-        struct config_item_type tfc_tpg_nacl_attrib_cit;
-        struct config_item_type tfc_tpg_nacl_auth_cit;
-        struct config_item_type tfc_tpg_nacl_param_cit;
-        struct config_item_type tfc_tpg_nacl_stat_cit;
-        struct config_item_type tfc_tpg_mappedlun_cit;
-        struct config_item_type tfc_tpg_mappedlun_stat_cit;
-};
-
-struct target_fabric_configfs {
-        char                    tf_name[TARGET_FABRIC_NAME_SIZE];
-        atomic_t                tf_access_cnt;
-        struct list_head        tf_list;
-        struct config_group     tf_group;
-        struct config_group     tf_disc_group;
-        struct config_group     *tf_default_groups[2];
-        /* Pointer to fabric's config_item */
-        struct config_item      *tf_fabric;
-        /* Passed from fabric modules */
-        struct config_item_type *tf_fabric_cit;
-        /* Pointer to fabric's struct module */
-        struct module *tf_module;
-        struct target_core_fabric_ops tf_ops;
-        struct target_fabric_configfs_template tf_cit_tmpl;
-};
-
diff --git a/include/target/target_core_fabric.h b/include/target/target_core_fabric.h
index 0f4dc3768587..18afef91b447 100644
--- a/include/target/target_core_fabric.h
+++ b/include/target/target_core_fabric.h
@@ -4,20 +4,11 @@
 struct target_core_fabric_ops {
         struct module *module;
         const char *name;
+        size_t node_acl_size;
         char *(*get_fabric_name)(void);
-        u8 (*get_fabric_proto_ident)(struct se_portal_group *);
         char *(*tpg_get_wwn)(struct se_portal_group *);
         u16 (*tpg_get_tag)(struct se_portal_group *);
         u32 (*tpg_get_default_depth)(struct se_portal_group *);
-        u32 (*tpg_get_pr_transport_id)(struct se_portal_group *,
-                                struct se_node_acl *,
-                                struct t10_pr_registration *, int *,
-                                unsigned char *);
-        u32 (*tpg_get_pr_transport_id_len)(struct se_portal_group *,
-                                struct se_node_acl *,
-                                struct t10_pr_registration *, int *);
-        char *(*tpg_parse_pr_out_transport_id)(struct se_portal_group *,
-                                const char *, u32 *, char **);
         int (*tpg_check_demo_mode)(struct se_portal_group *);
         int (*tpg_check_demo_mode_cache)(struct se_portal_group *);
         int (*tpg_check_demo_mode_write_protect)(struct se_portal_group *);
@@ -36,10 +27,6 @@ struct target_core_fabric_ops {
          * WRITE_STRIP and READ_INSERT operations.
          */
         int (*tpg_check_prot_fabric_only)(struct se_portal_group *);
-        struct se_node_acl *(*tpg_alloc_fabric_acl)(
-                                        struct se_portal_group *);
-        void (*tpg_release_fabric_acl)(struct se_portal_group *,
-                                        struct se_node_acl *);
         u32 (*tpg_get_inst_index)(struct se_portal_group *);
         /*
          * Optional to release struct se_cmd and fabric dependent allocated
@@ -50,7 +37,6 @@ struct target_core_fabric_ops {
          */
         int (*check_stop_free)(struct se_cmd *);
         void (*release_cmd)(struct se_cmd *);
-        void (*put_session)(struct se_session *);
         /*
          * Called with spin_lock_bh(struct se_portal_group->session_lock held.
          */
@@ -66,7 +52,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 *);
@@ -88,9 +73,8 @@ struct target_core_fabric_ops {
         struct se_tpg_np *(*fabric_make_np)(struct se_portal_group *,
                                 struct config_group *, const char *);
         void (*fabric_drop_np)(struct se_tpg_np *);
-        struct se_node_acl *(*fabric_make_nodeacl)(struct se_portal_group *,
-                                struct config_group *, const char *);
-        void (*fabric_drop_nodeacl)(struct se_node_acl *);
+        int (*fabric_init_nodeacl)(struct se_node_acl *, const char *);
+        void (*fabric_cleanup_nodeacl)(struct se_node_acl *);
 
         struct configfs_attribute **tfc_discovery_attrs;
         struct configfs_attribute **tfc_wwn_attrs;
@@ -132,16 +116,16 @@ void	transport_deregister_session(struct se_session *);
 void    transport_init_se_cmd(struct se_cmd *,
                 const struct target_core_fabric_ops *,
                 struct se_session *, u32, int, int, unsigned char *);
-sense_reason_t transport_lookup_cmd_lun(struct se_cmd *, u32);
+sense_reason_t transport_lookup_cmd_lun(struct se_cmd *, u64);
 sense_reason_t target_setup_cmd_from_cdb(struct se_cmd *, unsigned char *);
 int     target_submit_cmd_map_sgls(struct se_cmd *, struct se_session *,
-                unsigned char *, unsigned char *, u32, u32, int, int, int,
+                unsigned char *, unsigned char *, u64, u32, int, int, int,
                 struct scatterlist *, u32, struct scatterlist *, u32,
                 struct scatterlist *, u32);
 int     target_submit_cmd(struct se_cmd *, struct se_session *, unsigned char *,
-                unsigned char *, u32, u32, int, int, int);
+                unsigned char *, u64, u32, int, int, int);
 int     target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess,
-                unsigned char *sense, u32 unpacked_lun,
+                unsigned char *sense, u64 unpacked_lun,
                 void *fabric_tmr_ptr, unsigned char tm_type,
                 gfp_t, unsigned int, int);
 int     transport_handle_cdb_direct(struct se_cmd *);
@@ -155,8 +139,8 @@ bool	transport_wait_for_tasks(struct se_cmd *);
 int     transport_check_aborted_status(struct se_cmd *, int);
 int     transport_send_check_condition_and_sense(struct se_cmd *,
                 sense_reason_t, int);
-int     target_get_sess_cmd(struct se_session *, struct se_cmd *, bool);
-int     target_put_sess_cmd(struct se_session *, struct se_cmd *);
+int     target_get_sess_cmd(struct se_cmd *, bool);
+int     target_put_sess_cmd(struct se_cmd *);
 void    target_sess_cmd_list_set_waiting(struct se_session *);
 void    target_wait_for_sess_cmds(struct se_session *);
 
@@ -167,52 +151,19 @@ void	core_tmr_release_req(struct se_tmr_req *);
 int     transport_generic_handle_tmr(struct se_cmd *);
 void    transport_generic_request_failure(struct se_cmd *, sense_reason_t);
 void    __target_execute_cmd(struct se_cmd *);
-int     transport_lookup_tmr_lun(struct se_cmd *, u32);
+int     transport_lookup_tmr_lun(struct se_cmd *, u64);
 
 struct se_node_acl *core_tpg_get_initiator_node_acl(struct se_portal_group *tpg,
                 unsigned char *);
 struct se_node_acl *core_tpg_check_initiator_node_acl(struct se_portal_group *,
                 unsigned char *);
-void    core_tpg_clear_object_luns(struct se_portal_group *);
-struct se_node_acl *core_tpg_add_initiator_node_acl(struct se_portal_group *,
-                struct se_node_acl *, const char *, u32);
-int     core_tpg_del_initiator_node_acl(struct se_portal_group *,
-                struct se_node_acl *, int);
 int     core_tpg_set_initiator_node_queue_depth(struct se_portal_group *,
                 unsigned char *, u32, int);
 int     core_tpg_set_initiator_node_tag(struct se_portal_group *,
                 struct se_node_acl *, const char *);
-int     core_tpg_register(const struct target_core_fabric_ops *,
-                struct se_wwn *, struct se_portal_group *, void *, int);
+int     core_tpg_register(struct se_wwn *, struct se_portal_group *, int);
 int     core_tpg_deregister(struct se_portal_group *);
 
-/* SAS helpers */
-u8      sas_get_fabric_proto_ident(struct se_portal_group *);
-u32     sas_get_pr_transport_id(struct se_portal_group *, struct se_node_acl *,
-                struct t10_pr_registration *, int *, unsigned char *);
-u32     sas_get_pr_transport_id_len(struct se_portal_group *, struct se_node_acl *,
-                struct t10_pr_registration *, int *);
-char    *sas_parse_pr_out_transport_id(struct se_portal_group *, const char *,
-                u32 *, char **);
-
-/* FC helpers */
-u8      fc_get_fabric_proto_ident(struct se_portal_group *);
-u32     fc_get_pr_transport_id(struct se_portal_group *, struct se_node_acl *,
-                struct t10_pr_registration *, int *, unsigned char *);
-u32     fc_get_pr_transport_id_len(struct se_portal_group *, struct se_node_acl *,
-                struct t10_pr_registration *, int *);
-char    *fc_parse_pr_out_transport_id(struct se_portal_group *, const char *,
-                u32 *, char **);
-
-/* iSCSI helpers */
-u8      iscsi_get_fabric_proto_ident(struct se_portal_group *);
-u32     iscsi_get_pr_transport_id(struct se_portal_group *, struct se_node_acl *,
-                struct t10_pr_registration *, int *, unsigned char *);
-u32     iscsi_get_pr_transport_id_len(struct se_portal_group *, struct se_node_acl *,
-                struct t10_pr_registration *, int *);
-char    *iscsi_parse_pr_out_transport_id(struct se_portal_group *, const char *,
-                u32 *, char **);
-
 /*
  * The LIO target core uses DMA_TO_DEVICE to mean that data is going
  * to the target (eg handling a WRITE) and DMA_FROM_DEVICE to mean
diff --git a/lib/crc-t10dif.c b/lib/crc-t10dif.c
index dfe6ec17c0a5..1ad33e555805 100644
--- a/lib/crc-t10dif.c
+++ b/lib/crc-t10dif.c
@@ -19,7 +19,7 @@
 static struct crypto_shash *crct10dif_tfm;
 static struct static_key crct10dif_fallback __read_mostly;
 
-__u16 crc_t10dif(const unsigned char *buffer, size_t len)
+__u16 crc_t10dif_update(__u16 crc, const unsigned char *buffer, size_t len)
 {
         struct {
                 struct shash_desc shash;
@@ -28,17 +28,23 @@ __u16 crc_t10dif(const unsigned char *buffer, size_t len)
         int err;
 
         if (static_key_false(&crct10dif_fallback))
-                return crc_t10dif_generic(0, buffer, len);
+                return crc_t10dif_generic(crc, buffer, len);
 
         desc.shash.tfm = crct10dif_tfm;
         desc.shash.flags = 0;
-        *(__u16 *)desc.ctx = 0;
+        *(__u16 *)desc.ctx = crc;
 
         err = crypto_shash_update(&desc.shash, buffer, len);
         BUG_ON(err);
 
         return *(__u16 *)desc.ctx;
 }
+EXPORT_SYMBOL(crc_t10dif_update);
+
+__u16 crc_t10dif(const unsigned char *buffer, size_t len)
+{
+        return crc_t10dif_update(0, buffer, len);
+}
 EXPORT_SYMBOL(crc_t10dif);
 
 static int __init crc_t10dif_mod_init(void)