diff --git a/drivers/target/target_core_alua.c b/drivers/target/target_core_alua.c
index fd91a2a3b120..04916ecd6ed2 100644
--- a/drivers/target/target_core_alua.c
+++ b/drivers/target/target_core_alua.c
@@ -64,7 +64,8 @@ target_emulate_report_referrals(struct se_cmd *cmd)
 	u32 rd_len = 0, off;
 
 	if (cmd->data_length < 4) {
-		target_warn("REPORT REFERRALS allocation length %u too small\n", cmd->data_length);
+		target_cmd_warn(cmd, "REPORT REFERRALS allocation length %u too small\n",
+				cmd->data_length);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -153,8 +154,8 @@ target_emulate_report_target_port_groups(struct se_cmd *cmd)
 		off = 4;
 
 	if (cmd->data_length < off) {
-		target_warn("REPORT TARGET PORT GROUPS allocation length %u too small for %s header\n",
-			    cmd->data_length, (ext_hdr) ? "extended" : "normal");
+		target_cmd_warn(cmd, "REPORT TARGET PORT GROUPS allocation length %u too small for %s header\n",
+				cmd->data_length, (ext_hdr) ? "extended" : "normal");
 		return TCM_INVALID_CDB_FIELD;
 	}
 	buf = transport_kmap_data_sg(cmd);
@@ -282,8 +283,8 @@ target_emulate_set_target_port_groups(struct se_cmd *cmd)
 	u16 tg_pt_id, rtpi;
 
 	if (cmd->data_length < 4) {
-		target_warn("SET TARGET PORT GROUPS parameter list length %u too small\n",
-			    cmd->data_length);
+		target_cmd_warn(cmd, "SET TARGET PORT GROUPS parameter list length %u too small\n",
+				cmd->data_length);
 		return TCM_INVALID_PARAMETER_LIST;
 	}
 
@@ -299,14 +300,14 @@ target_emulate_set_target_port_groups(struct se_cmd *cmd)
 	l_tg_pt_gp = rcu_dereference(l_lun->lun_tg_pt_gp);
 	if (!l_tg_pt_gp) {
 		rcu_read_unlock();
-		target_err("Unable to access l_lun->tg_pt_gp\n");
+		target_cmd_err(cmd, "Unable to access l_lun->tg_pt_gp\n");
 		rc = TCM_UNSUPPORTED_SCSI_OPCODE;
 		goto out;
 	}
 
 	if (!(l_tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA)) {
 		rcu_read_unlock();
-		target_debug("Unable to process SET_TARGET_PORT_GROUPS while TPGS_EXPLICIT_ALUA is disabled\n");
+		target_cmd_debug(cmd, "Unable to process SET_TARGET_PORT_GROUPS while TPGS_EXPLICIT_ALUA is disabled\n");
 		rc = TCM_UNSUPPORTED_SCSI_OPCODE;
 		goto out;
 	}
@@ -662,7 +663,7 @@ target_alua_state_check(struct se_cmd *cmd)
 	 * access state: OFFLINE
 	 */
 	if (atomic_read(&lun->lun_tg_pt_secondary_offline)) {
-		target_debug("ALUA: Got secondary offline status for local target port\n");
+		target_cmd_debug(cmd, "ALUA: Got secondary offline status for local target port\n");
 		return TCM_ALUA_OFFLINE;
 	}
 	rcu_read_lock();
@@ -707,13 +708,13 @@ target_alua_state_check(struct se_cmd *cmd)
 	 */
 	case ALUA_ACCESS_STATE_OFFLINE:
 	default:
-		target_err("Unknown ALUA access state: 0x%02x\n", out_alua_state);
+		target_cmd_err(cmd, "Unknown ALUA access state: 0x%02x\n", out_alua_state);
 		rc = TCM_INVALID_CDB_FIELD;
 	}
 
 	if (rc && rc != TCM_INVALID_CDB_FIELD) {
-		target_debug("[%s]: ALUA TG Port not available, SenseKey: NOT_READY, ASC/rc: 0x04/%d\n",
-			     cmd->se_tfo->fabric_name, rc);
+		target_cmd_debug(cmd, "[%s]: ALUA TG Port not available, SenseKey: NOT_READY, ASC/rc: 0x04/%d\n",
+				 cmd->se_tfo->fabric_name, rc);
 	}
 
 	return rc;
@@ -1168,7 +1169,7 @@ static int core_alua_update_tpg_secondary_metadata(struct se_lun *lun)
 
 	md_buf = kzalloc(ALUA_MD_BUF_LEN, GFP_KERNEL);
 	if (!md_buf) {
-		target_err("Unable to allocate buf for ALUA metadata\n");
+		target_lun_err(lun, "Unable to allocate buf for ALUA metadata\n");
 		rc = -ENOMEM;
 		goto out_unlock;
 	}
@@ -1216,7 +1217,7 @@ static int core_alua_set_tg_pt_secondary_state(
 	tg_pt_gp = rcu_dereference(lun->lun_tg_pt_gp);
 	if (!tg_pt_gp) {
 		rcu_read_unlock();
-		target_err("Unable to complete secondary state transition\n");
+		target_lun_err(lun, "Unable to complete secondary state transition\n");
 		return -EINVAL;
 	}
 	trans_delay_msecs = tg_pt_gp->tg_pt_gp_trans_delay_msecs;
@@ -1233,10 +1234,10 @@ static int core_alua_set_tg_pt_secondary_state(
 			ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG :
 			ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA;
 
-	target_debug("Successful %s ALUA transition TG PT Group: %s ID: %u to secondary access state: %s\n",
-		     (explicit) ? "explicit" : "implicit",
-		     config_item_name(&tg_pt_gp->tg_pt_gp_group.cg_item), tg_pt_gp->tg_pt_gp_id,
-		     (offline) ? "OFFLINE" : "ONLINE");
+	target_lun_debug(lun, "Successful %s ALUA transition TG PT Group: %s ID: %u to secondary access state: %s\n",
+			 (explicit) ? "explicit" : "implicit",
+			 config_item_name(&tg_pt_gp->tg_pt_gp_group.cg_item), tg_pt_gp->tg_pt_gp_id,
+			 (offline) ? "OFFLINE" : "ONLINE");
 
 	rcu_read_unlock();
 	/*
@@ -1898,7 +1899,7 @@ ssize_t core_alua_store_tg_pt_gp_info(
 		return -ENODEV;
 
 	if (count > TG_PT_GROUP_NAME_BUF) {
-		target_err("ALUA Target Port Group alias too large!\n");
+		target_lun_err(lun, "ALUA Target Port Group alias too large!\n");
 		return -EINVAL;
 	}
 	memset(buf, 0, TG_PT_GROUP_NAME_BUF);
@@ -1928,12 +1929,12 @@ ssize_t core_alua_store_tg_pt_gp_info(
 		 * with the default_tg_pt_gp.
 		 */
 		if (!tg_pt_gp_new) {
-			target_debug("configfs: Moving %s/tpgt_%u/%s from ALUA Target Port Group: alua/%s, ID: %u back to default_tg_pt_gp\n",
-				     tpg->se_tpg_tfo->tpg_get_wwn(tpg),
-				     tpg->se_tpg_tfo->tpg_get_tag(tpg),
-				     config_item_name(&lun->lun_group.cg_item),
-				     config_item_name(&tg_pt_gp->tg_pt_gp_group.cg_item),
-				     tg_pt_gp->tg_pt_gp_id);
+			target_lun_debug(lun, "configfs: Moving %s/tpgt_%u/%s from ALUA Target Port Group: alua/%s, ID: %u back to default_tg_pt_gp\n",
+					 tpg->se_tpg_tfo->tpg_get_wwn(tpg),
+					 tpg->se_tpg_tfo->tpg_get_tag(tpg),
+					 config_item_name(&lun->lun_group.cg_item),
+					 config_item_name(&tg_pt_gp->tg_pt_gp_group.cg_item),
+					 tg_pt_gp->tg_pt_gp_id);
 
 			target_swap_tg_pt_gp(lun, tg_pt_gp,
 					dev->t10_alua.default_tg_pt_gp);
@@ -1946,11 +1947,12 @@ ssize_t core_alua_store_tg_pt_gp_info(
 
 	target_swap_tg_pt_gp(lun, tg_pt_gp, tg_pt_gp_new);
 	spin_unlock(&lun->lun_tg_pt_gp_lock);
-	target_debug("configfs: %s %s/tpgt_%u/%s to ALUA Target Port Group: alua/%s, ID: %u\n",
-		     (move) ? "Moving" : "Adding", tpg->se_tpg_tfo->tpg_get_wwn(tpg),
-		     tpg->se_tpg_tfo->tpg_get_tag(tpg), config_item_name(&lun->lun_group.cg_item),
-		     config_item_name(&tg_pt_gp_new->tg_pt_gp_group.cg_item),
-		     tg_pt_gp_new->tg_pt_gp_id);
+	target_lun_debug(lun, "configfs: %s %s/tpgt_%u/%s to ALUA Target Port Group: alua/%s, ID: %u\n",
+			 (move) ? "Moving" : "Adding", tpg->se_tpg_tfo->tpg_get_wwn(tpg),
+			 tpg->se_tpg_tfo->tpg_get_tag(tpg),
+			 config_item_name(&lun->lun_group.cg_item),
+			 config_item_name(&tg_pt_gp_new->tg_pt_gp_group.cg_item),
+			 tg_pt_gp_new->tg_pt_gp_id);
 
 	core_alua_put_tg_pt_gp_from_name(tg_pt_gp_new);
 sync_rcu:
@@ -2147,11 +2149,11 @@ ssize_t core_alua_store_offline_bit(
 
 	ret = kstrtoul(page, 0, &tmp);
 	if (ret < 0) {
-		target_err("Unable to extract alua_tg_pt_offline value\n");
+		target_lun_err(lun, "Unable to extract alua_tg_pt_offline value\n");
 		return ret;
 	}
 	if ((tmp != 0) && (tmp != 1)) {
-		target_err("Illegal value for alua_tg_pt_offline: %lu\n", tmp);
+		target_lun_err(lun, "Illegal value for alua_tg_pt_offline: %lu\n", tmp);
 		return -EINVAL;
 	}
 
@@ -2179,13 +2181,13 @@ ssize_t core_alua_store_secondary_status(
 
 	ret = kstrtoul(page, 0, &tmp);
 	if (ret < 0) {
-		target_err("Unable to extract alua_tg_pt_status\n");
+		target_lun_err(lun, "Unable to extract alua_tg_pt_status\n");
 		return ret;
 	}
 	if ((tmp != ALUA_STATUS_NONE) &&
 	    (tmp != ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG) &&
 	    (tmp != ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA)) {
-		target_err("Illegal value for alua_tg_pt_status: %lu\n", tmp);
+		target_lun_err(lun, "Illegal value for alua_tg_pt_status: %lu\n", tmp);
 		return -EINVAL;
 	}
 	lun->lun_tg_pt_secondary_stat = (int)tmp;
@@ -2210,11 +2212,11 @@ ssize_t core_alua_store_secondary_write_metadata(
 
 	ret = kstrtoul(page, 0, &tmp);
 	if (ret < 0) {
-		target_err("Unable to extract alua_tg_pt_write_md\n");
+		target_lun_err(lun, "Unable to extract alua_tg_pt_write_md\n");
 		return ret;
 	}
 	if ((tmp != 0) && (tmp != 1)) {
-		target_err("Illegal value for alua_tg_pt_write_md: %lu\n", tmp);
+		target_lun_err(lun, "Illegal value for alua_tg_pt_write_md: %lu\n", tmp);
 		return -EINVAL;
 	}
 	lun->lun_tg_pt_secondary_write_md = (int)tmp;
diff --git a/drivers/target/target_core_configfs.c b/drivers/target/target_core_configfs.c
index ea958b9a21b8..4c058472acb7 100644
--- a/drivers/target/target_core_configfs.c
+++ b/drivers/target/target_core_configfs.c
@@ -196,7 +196,7 @@ static struct config_group *target_core_register_fabric(
 
 	tf = target_core_get_fabric(name);
 	if (!tf) {
-		target_debug("target_core_register_fabric() trying autoload for %s\n", name);
+		target_debug("%s trying autoload for %s\n", __func__, name);
 
 		/*
 		 * Below are some hardcoded request_module() calls to automatically
@@ -3589,8 +3589,8 @@ static int __init target_core_init_configfs(void)
 	const struct cred *old_cred;
 	int ret;
 
-	target_debug("TARGET_CORE[0]: Loading Generic Kernel Storage Engine: %s on %s/%s on "
-		     UTS_RELEASE "\n", TARGET_CORE_VERSION, utsname()->sysname, utsname()->machine);
+	target_debug("Loading Generic Kernel Storage Engine: %s on %s/%s on " UTS_RELEASE "\n",
+		     TARGET_CORE_VERSION, utsname()->sysname, utsname()->machine);
 
 	config_group_init(&subsys->su_group);
 	mutex_init(&subsys->su_mutex);
@@ -3704,7 +3704,7 @@ static void __exit target_core_exit_configfs(void)
 	core_alua_free_lu_gp(default_lu_gp);
 	default_lu_gp = NULL;
 
-	target_debug("TARGET_CORE[0]: Released ConfigFS Fabric Infrastructure\n");
+	target_debug("Released ConfigFS Fabric Infrastructure\n");
 
 	core_dev_release_virtual_lun0();
 	rd_module_exit();
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index 1d54579ecca2..e95c5ce31457 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -68,8 +68,8 @@ transport_lookup_cmd_lun(struct se_cmd *se_cmd)
 
 		if ((se_cmd->data_direction == DMA_TO_DEVICE) &&
 		    deve->lun_access_ro) {
-			target_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN Access for 0x%08llx\n",
-				   se_cmd->se_tfo->fabric_name, se_cmd->orig_fe_lun);
+			target_cmd_err(se_cmd, "[%s]: Detected WRITE_PROTECTED LUN Access\n",
+				       se_cmd->se_tfo->fabric_name);
 			rcu_read_unlock();
 			return TCM_WRITE_PROTECTED;
 		}
@@ -96,9 +96,8 @@ transport_lookup_cmd_lun(struct se_cmd *se_cmd)
 		 * MappedLUN=0 exists for this Initiator Port.
 		 */
 		if (se_cmd->orig_fe_lun != 0) {
-			target_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN Access for 0x%08llx from %s\n",
-				   se_cmd->se_tfo->fabric_name, se_cmd->orig_fe_lun,
-				   nacl->initiatorname);
+			target_cmd_err(se_cmd, "[%s]: Detected NON_EXISTENT_LUN Access\n",
+				       se_cmd->se_tfo->fabric_name);
 			return TCM_NON_EXISTENT_LUN;
 		}
 
@@ -164,8 +163,8 @@ int transport_lookup_tmr_lun(struct se_cmd *se_cmd)
 	rcu_read_unlock();
 
 	if (!se_lun) {
-		target_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN Access for 0x%08llx for %s\n",
-			     se_cmd->se_tfo->fabric_name, se_cmd->orig_fe_lun, nacl->initiatorname);
+		target_cmd_debug(se_cmd, "[%s]: Detected NON_EXISTENT_LUN Access",
+				 se_cmd->se_tfo->fabric_name);
 		return -ENODEV;
 	}
 	se_cmd->se_dev = rcu_dereference_raw(se_lun->lun_se_dev);
@@ -207,7 +206,7 @@ struct se_dev_entry *core_get_se_deve_from_rtpi(
 	hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) {
 		lun = deve->se_lun;
 		if (!lun) {
-			target_err("%s device entries device pointer is NULL, but Initiator has access.\n",
+			target_err("[%s]: device entries lun pointer is NULL, but Initiator has access.\n",
 				   tpg->se_tpg_tfo->fabric_name);
 			continue;
 		}
@@ -319,7 +318,7 @@ int core_enable_device_list_for_node(
 
 	new = kzalloc(sizeof(*new), GFP_KERNEL);
 	if (!new) {
-		target_err("Unable to allocate se_dev_entry memory\n");
+		target_lun_err(lun, "Unable to allocate se_dev_entry memory\n");
 		return -ENOMEM;
 	}
 
@@ -341,15 +340,15 @@ int core_enable_device_list_for_node(
 		struct se_lun *orig_lun = orig->se_lun;
 
 		if (orig_lun != lun) {
-			target_err("Existing orig->se_lun doesn't match new lun for dynamic -> explicit NodeACL conversion: %s\n",
-				   nacl->initiatorname);
+			target_lun_err(lun, "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 (orig->se_lun_acl != NULL) {
-			target_warn_ratelimited("Detected existing explicit se_lun_acl->se_lun_group reference for %s mapped_lun: %llu, failing\n",
-						nacl->initiatorname, mapped_lun);
+			target_lun_warn_ratelimited(lun, "Detected existing explicit se_lun_acl->se_lun_group reference for %s mapped_lun: %llu, failing\n",
+						    nacl->initiatorname, mapped_lun);
 			mutex_unlock(&nacl->lun_entry_mutex);
 			kfree(new);
 			return -EINVAL;
@@ -506,9 +505,7 @@ int core_dev_add_lun(
 	if (rc < 0)
 		return rc;
 
-	target_debug("%s_TPG[%u]_LUN[%llu] - Activated %s Logical Unit from CORE HBA: %u\n",
-		     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
-		     lun->unpacked_lun, tpg->se_tpg_tfo->fabric_name, dev->se_hba->hba_id);
+	target_lun_debug(lun, "Activated Logical Unit from CORE HBA: %u\n", dev->se_hba->hba_id);
 	/*
 	 * Update LUN maps for dynamically added initiators when
 	 * generate_node_acl is enabled.
@@ -538,9 +535,7 @@ void core_dev_del_lun(
 	struct se_portal_group *tpg,
 	struct se_lun *lun)
 {
-	target_debug("%s_TPG[%u]_LUN[%llu] - Deactivating %s Logical Unit from device object\n",
-		     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
-		     lun->unpacked_lun, tpg->se_tpg_tfo->fabric_name);
+	target_lun_debug(lun, "Deactivating Logical Unit from device object\n");
 
 	core_tpg_remove_lun(tpg, lun);
 }
@@ -597,10 +592,8 @@ int core_dev_add_initiator_node_lun_acl(
 			lun_access_ro, nacl, tpg) < 0)
 		return -EINVAL;
 
-	target_debug("%s_TPG[%u]_LUN[%llu->%llu] - Added %s ACL for  InitiatorNode: %s\n",
-		     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
-		     lun->unpacked_lun, lacl->mapped_lun, lun_access_ro ? "RO" : "RW",
-		     nacl->initiatorname);
+	target_lun_debug(lun, "Added %s ACL for  InitiatorNode: %s, Mapped LUN %llu\n",
+			 lun_access_ro ? "RO" : "RW", nacl->initiatorname, lacl->mapped_lun);
 	/*
 	 * Check to see if there are any existing persistent reservation APTPL
 	 * pre-registrations that need to be enabled for this LUN ACL..
@@ -628,9 +621,8 @@ int core_dev_del_initiator_node_lun_acl(
 		core_disable_device_list_for_node(lun, deve, nacl, tpg);
 	mutex_unlock(&nacl->lun_entry_mutex);
 
-	target_debug("%s_TPG[%u]_LUN[%llu] - Removed ACL for InitiatorNode: %s Mapped LUN: %llu\n",
-		     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
-		     lun->unpacked_lun, nacl->initiatorname, lacl->mapped_lun);
+	target_lun_debug(lun, "Removed ACL for InitiatorNode: %s Mapped LUN: %llu\n",
+			 nacl->initiatorname, lacl->mapped_lun);
 
 	return 0;
 }
@@ -639,7 +631,7 @@ void core_dev_free_initiator_node_lun_acl(
 	struct se_portal_group *tpg,
 	struct se_lun_acl *lacl)
 {
-	target_debug("%s_TPG[%u] - Freeing ACL for %s InitiatorNode: %s Mapped LUN: %llu\n",
+	target_debug("%s_tpg[%u] - Freeing ACL for %s InitiatorNode: %s Mapped LUN: %llu\n",
 		     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
 		     tpg->se_tpg_tfo->fabric_name, lacl->se_lun_nacl->initiatorname,
 		     lacl->mapped_lun);
diff --git a/drivers/target/target_core_fabric_configfs.c b/drivers/target/target_core_fabric_configfs.c
index dec8f25c04d0..d524971e5174 100644
--- a/drivers/target/target_core_fabric_configfs.c
+++ b/drivers/target/target_core_fabric_configfs.c
@@ -106,13 +106,13 @@ static int target_fabric_mappedlun_link(
 	 * Make sure the SymLink is going to the same $FABRIC/$WWN/tpgt_$TPGT
 	 */
 	if (strcmp(config_item_name(wwn_ci), config_item_name(wwn_ci_s))) {
-		target_err("Illegal Initiator ACL SymLink outside of %s\n",
-			   config_item_name(wwn_ci));
+		target_lun_err(lun, "Illegal Initiator ACL SymLink outside of %s\n",
+			       config_item_name(wwn_ci));
 		return -EINVAL;
 	}
 	if (strcmp(config_item_name(tpg_ci), config_item_name(tpg_ci_s))) {
-		target_err("Illegal Initiator ACL Symlink outside of %s TPGT: %s\n",
-			   config_item_name(wwn_ci), config_item_name(tpg_ci));
+		target_lun_err(lun, "Illegal Initiator ACL Symlink outside of %s TPGT: %s\n",
+			       config_item_name(wwn_ci), config_item_name(tpg_ci));
 		return -EINVAL;
 	}
 	/*
diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c
index 503b53767b8b..7254c6327ed7 100644
--- a/drivers/target/target_core_file.c
+++ b/drivers/target/target_core_file.c
@@ -50,9 +50,9 @@ static int fd_attach_hba(struct se_hba *hba, u32 host_id)
 
 	hba->hba_ptr = fd_host;
 
-	target_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic Target Core Stack %s\n",
+	target_debug("hba[%d] - TCM FILEIO HBA Driver %s on Generic Target Core Stack %s\n",
 		     hba->hba_id, FD_VERSION, TARGET_CORE_VERSION);
-	target_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic\n", hba->hba_id,
+	target_debug("hba[%d] - Attached FILEIO HBA: %u to Generic\n", hba->hba_id,
 		     fd_host->fd_host_id);
 
 	return 0;
@@ -62,8 +62,8 @@ static void fd_detach_hba(struct se_hba *hba)
 {
 	struct fd_host *fd_host = hba->hba_ptr;
 
-	target_debug("CORE_HBA[%d] - Detached FILEIO HBA: %u from Generic Target Core\n",
-		     hba->hba_id, fd_host->fd_host_id);
+	target_debug("hba[%d] - Detached FILEIO HBA: %u from Generic Target Core\n", hba->hba_id,
+		     fd_host->fd_host_id);
 
 	kfree(fd_host);
 	hba->hba_ptr = NULL;
@@ -202,7 +202,7 @@ static int fd_configure_device(struct se_device *dev)
 	fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++;
 	fd_dev->fd_queue_depth = dev->queue_depth;
 
-	target_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s, %llu total bytes\n",
+	target_debug("Host[%u] - Added TCM FILEIO Device ID: %u at %s, %llu total bytes\n",
 		     fd_host->fd_host_id, fd_dev->fd_dev_id, fd_dev->fd_dev_name,
 		     fd_dev->fd_dev_size);
 
@@ -319,7 +319,7 @@ static int fd_do_rw(struct se_cmd *cmd, struct file *fd,
 
 	bvec = kcalloc(sgl_nents, sizeof(struct bio_vec), GFP_KERNEL);
 	if (!bvec) {
-		target_err("Unable to allocate fd_do_readv iov[]\n");
+		target_cmd_err(cmd, "Unable to allocate fd_do_readv iov[]\n");
 		return -ENOMEM;
 	}
 
@@ -336,7 +336,7 @@ static int fd_do_rw(struct se_cmd *cmd, struct file *fd,
 
 	if (is_write) {
 		if (ret < 0 || ret != data_length) {
-			target_err("%s() write returned %d\n", __func__, ret);
+			target_cmd_err(cmd, "%s() write returned %d\n", __func__, ret);
 			if (ret >= 0)
 				ret = -EINVAL;
 		}
@@ -348,14 +348,15 @@ static int fd_do_rw(struct se_cmd *cmd, struct file *fd,
 		 */
 		if (S_ISBLK(file_inode(fd)->i_mode)) {
 			if (ret < 0 || ret != data_length) {
-				target_err("%s() returned %d, expecting %u for S_ISBLK\n", __func__,
-					   ret, data_length);
+				target_cmd_err(cmd, "%s() returned %d, expecting %u for S_ISBLK\n",
+					       __func__, ret, data_length);
 				if (ret >= 0)
 					ret = -EINVAL;
 			}
 		} else {
 			if (ret < 0) {
-				target_err("%s() returned %d for non S_ISBLK\n", __func__, ret);
+				target_cmd_err(cmd, "%s() returned %d for non S_ISBLK\n", __func__,
+					       ret);
 			} else if (ret != data_length) {
 				/*
 				 * Short read case:
@@ -406,7 +407,7 @@ fd_execute_sync_cache(struct se_cmd *cmd)
 
 	ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);
 	if (ret != 0)
-		target_err("vfs_fsync_range() failed: %d\n", ret);
+		target_cmd_err(cmd, "vfs_fsync_range() failed: %d\n", ret);
 
 	if (immed)
 		return 0;
@@ -432,7 +433,7 @@ fd_execute_write_same(struct se_cmd *cmd)
 	ssize_t ret;
 
 	if (cmd->prot_op) {
-		target_err("WRITE_SAME: Protection information with FILEIO backends not supported\n");
+		target_cmd_err(cmd, "WRITE_SAME: Protection information with FILEIO backends not supported\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 
@@ -441,9 +442,9 @@ fd_execute_write_same(struct se_cmd *cmd)
 
 	if (cmd->t_data_nents > 1 ||
 	    cmd->t_data_sg[0].length != cmd->se_dev->dev_attrib.block_size) {
-		target_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u block_size: %u\n",
-			   cmd->t_data_nents, cmd->t_data_sg[0].length,
-			   cmd->se_dev->dev_attrib.block_size);
+		target_cmd_err(cmd, "WRITE_SAME: Illegal SGL t_data_nents: %u length: %u block_size: %u\n",
+			       cmd->t_data_nents, cmd->t_data_sg[0].length,
+			       cmd->se_dev->dev_attrib.block_size);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -463,7 +464,7 @@ fd_execute_write_same(struct se_cmd *cmd)
 
 	kfree(bvec);
 	if (ret < 0 || ret != len) {
-		target_err("vfs_iter_write() returned %zd for write same\n", ret);
+		target_cmd_err(cmd, "vfs_iter_write() returned %zd for write same\n", ret);
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 
@@ -510,7 +511,7 @@ fd_do_prot_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)
 
 	buf = (void *)__get_free_page(GFP_KERNEL);
 	if (!buf) {
-		target_err("Unable to allocate FILEIO prot buf\n");
+		target_cmd_err(cmd, "Unable to allocate FILEIO prot buf\n");
 		return -ENOMEM;
 	}
 
@@ -548,7 +549,7 @@ fd_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)
 					   target_to_linux_sector(dev,  nolb),
 					   GFP_KERNEL);
 		if (ret < 0) {
-			target_warn("blkdev_issue_discard() failed: %d\n", ret);
+			target_cmd_warn(cmd, "blkdev_issue_discard() failed: %d\n", ret);
 			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 		}
 	} else {
@@ -563,7 +564,7 @@ fd_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)
 
 		ret = file->f_op->fallocate(file, mode, pos, len);
 		if (ret < 0) {
-			target_warn("fallocate() failed: %d\n", ret);
+			target_cmd_warn(cmd, "fallocate() failed: %d\n", ret);
 			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 		}
 	}
@@ -667,8 +668,8 @@ fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 	 * single vfs_[writev,readv] call.
 	 */
 	if (cmd->data_length > FD_MAX_BYTES) {
-		target_err("Not able to process I/O of %u bytes due to FD_MAX_BYTES: %u iovec count limitation\n",
-			   cmd->data_length, FD_MAX_BYTES);
+		target_cmd_err(cmd, "Not able to process I/O of %u bytes due to FD_MAX_BYTES: %u iovec count limitation\n",
+			       cmd->data_length, FD_MAX_BYTES);
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 
@@ -821,7 +822,7 @@ static int fd_init_prot(struct se_device *dev)
 
 	inode = file->f_mapping->host;
 	if (S_ISBLK(inode->i_mode)) {
-		target_err("FILEIO Protection emulation only supported on !S_ISBLK\n");
+		target_err("Protection emulation only supported on !S_ISBLK\n");
 		return -ENOSYS;
 	}
 
diff --git a/drivers/target/target_core_hba.c b/drivers/target/target_core_hba.c
index 31a426fcb3d4..a5b5442d52ce 100644
--- a/drivers/target/target_core_hba.c
+++ b/drivers/target/target_core_hba.c
@@ -139,7 +139,7 @@ core_alloc_hba(const char *plugin_name, u32 plugin_dep_id, u32 hba_flags)
 	list_add_tail(&hba->hba_node, &hba_list);
 	spin_unlock(&hba_lock);
 
-	target_debug("CORE_HBA[%d] - Attached HBA to Generic Target Core\n", hba->hba_id);
+	target_debug("hba[%d] - Attached HBA to Generic Target Core\n", hba->hba_id);
 
 	return hba;
 
@@ -162,7 +162,7 @@ core_delete_hba(struct se_hba *hba)
 	list_del(&hba->hba_node);
 	spin_unlock(&hba_lock);
 
-	target_debug("CORE_HBA[%d] - Detached HBA from Generic Target Core\n", hba->hba_id);
+	target_debug("hba[%d] - Detached HBA from Generic Target Core\n", hba->hba_id);
 
 	module_put(hba->backend->ops->owner);
 
diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
index 25cc0815e590..bf6b95285d80 100644
--- a/drivers/target/target_core_iblock.c
+++ b/drivers/target/target_core_iblock.c
@@ -47,7 +47,7 @@ static inline struct iblock_dev *IBLOCK_DEV(struct se_device *dev)
 
 static int iblock_attach_hba(struct se_hba *hba, u32 host_id)
 {
-	target_debug("CORE_HBA[%d] - TCM iBlock HBA Driver %s on Generic Target Core Stack %s\n",
+	target_debug("hba[%d] - TCM iBlock HBA Driver %s on Generic Target Core Stack %s\n",
 		     hba->hba_id, IBLOCK_VERSION, TARGET_CORE_VERSION);
 	return 0;
 }
@@ -100,7 +100,7 @@ static int iblock_configure_device(struct se_device *dev)
 	int ret;
 
 	if (!(ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH)) {
-		target_err("Missing udev_path= parameters for IBLOCK\n");
+		target_err("Missing udev_path= parameters\n");
 		return -EINVAL;
 	}
 
@@ -175,8 +175,7 @@ static int iblock_configure_device(struct se_device *dev)
 			ret = -ENOMEM;
 			goto out_blkdev_put;
 		}
-		target_debug("IBLOCK setup BIP bs->bio_integrity_pool: %p\n",
-			     &bs->bio_integrity_pool);
+		target_debug("Setup BIP bs->bio_integrity_pool: %p\n", &bs->bio_integrity_pool);
 	}
 
 	dev->dev_attrib.hw_pi_prot_type = dev->dev_attrib.pi_prot_type;
@@ -344,7 +343,7 @@ static void iblock_bio_done(struct bio *bio)
 	blk_status_t blk_status = bio->bi_status;
 
 	if (bio->bi_status) {
-		target_err("bio error: %p,  err: %d\n", bio, bio->bi_status);
+		target_cmd_err(cmd, "bio error: %p,  err: %d\n", bio, bio->bi_status);
 		/*
 		 * Bump the ib_bio_err_cnt and release bio.
 		 */
@@ -370,7 +369,7 @@ static struct bio *iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num,
 	bio = bio_alloc_bioset(ib_dev->ibd_bd, bio_max_segs(sg_num), opf,
 			       GFP_NOIO, &ib_dev->ibd_bio_set);
 	if (!bio) {
-		target_err("Unable to allocate memory for bio\n");
+		target_cmd_err(cmd, "Unable to allocate memory for bio\n");
 		return NULL;
 	}
 
@@ -400,7 +399,7 @@ static void iblock_end_io_flush(struct bio *bio)
 	struct se_cmd *cmd = bio->bi_private;
 
 	if (bio->bi_status)
-		target_err("cache flush failed: %d\n", bio->bi_status);
+		target_cmd_err(cmd, "Cache flush failed: %d\n", bio->bi_status);
 
 	if (cmd) {
 		if (bio->bi_status)
@@ -451,7 +450,7 @@ iblock_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)
 				   target_to_linux_sector(dev,  nolb),
 				   GFP_KERNEL);
 	if (ret < 0) {
-		target_err("blkdev_issue_discard() failed: %d\n", ret);
+		target_cmd_err(cmd, "blkdev_issue_discard() failed: %d\n", ret);
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 
@@ -505,7 +504,7 @@ iblock_execute_write_same(struct se_cmd *cmd)
 					sbc_get_write_same_sectors(cmd));
 
 	if (cmd->prot_op) {
-		target_err("WRITE_SAME: Protection information with IBLOCK backends not supported\n");
+		target_cmd_err(cmd, "WRITE_SAME: Protection information with IBLOCK backends not supported\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 
@@ -516,8 +515,8 @@ iblock_execute_write_same(struct se_cmd *cmd)
 
 	if (cmd->t_data_nents > 1 ||
 	    sg->length != cmd->se_dev->dev_attrib.block_size) {
-		target_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u block_size: %u\n",
-			   cmd->t_data_nents, sg->length, cmd->se_dev->dev_attrib.block_size);
+		target_cmd_err(cmd, "WRITE_SAME: Illegal SGL t_data_nents: %u length: %u block_size: %u\n",
+			       cmd->t_data_nents, sg->length, cmd->se_dev->dev_attrib.block_size);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -680,13 +679,13 @@ iblock_alloc_bip(struct se_cmd *cmd, struct bio *bio,
 
 	bi = bdev_get_integrity(ib_dev->ibd_bd);
 	if (!bi) {
-		target_err("Unable to locate bio_integrity\n");
+		target_cmd_err(cmd, "Unable to locate bio_integrity\n");
 		return -ENODEV;
 	}
 
 	bip = bio_integrity_alloc(bio, GFP_NOIO, bio_max_segs(cmd->t_prot_nents));
 	if (IS_ERR(bip)) {
-		target_err("Unable to allocate bio_integrity_payload\n");
+		target_cmd_err(cmd, "Unable to allocate bio_integrity_payload\n");
 		return PTR_ERR(bip);
 	}
 
@@ -694,8 +693,8 @@ iblock_alloc_bip(struct se_cmd *cmd, struct bio *bio,
 	bip_set_seed(bip, bio->bi_iter.bi_sector >>
 				  (bi->interval_exp - SECTOR_SHIFT));
 
-	target_debug("IBLOCK BIP Size: %u Sector: %llu\n", bip->bip_iter.bi_size,
-		     (unsigned long long)bip->bip_iter.bi_sector);
+	target_cmd_debug(cmd, "BIP Size: %u Sector: %llu\n", bip->bip_iter.bi_size,
+			 (unsigned long long)bip->bip_iter.bi_sector);
 
 	resid = bio_integrity_bytes(bi, bio_sectors(bio));
 	while (resid > 0 && sg_miter_next(miter)) {
@@ -704,13 +703,13 @@ iblock_alloc_bip(struct se_cmd *cmd, struct bio *bio,
 		rc = bio_integrity_add_page(bio, miter->page, len,
 					    offset_in_page(miter->addr));
 		if (rc != len) {
-			target_err("bio_integrity_add_page() failed; %d\n", rc);
+			target_cmd_err(cmd, "bio_integrity_add_page() failed; %d\n", rc);
 			sg_miter_stop(miter);
 			return -ENOMEM;
 		}
 
-		target_debug("Added bio integrity page: %p length: %zu offset: %lu\n", miter->page,
-			     len, offset_in_page(miter->addr));
+		target_cmd_debug(cmd, "Added bio integrity page: %p length: %zu offset: %lu\n",
+				 miter->page, len, offset_in_page(miter->addr));
 
 		resid -= len;
 		if (len < miter->length)
diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c
index 879624812573..9c2b0da24111 100644
--- a/drivers/target/target_core_pr.c
+++ b/drivers/target/target_core_pr.c
@@ -61,11 +61,22 @@ enum register_type {
 	REGISTER_AND_MOVE,
 };
 
+static const char *const pr_register_type_table_str[] = {
+	"REGISTER",
+	"REGISTER_AND_IGNORE_EXISTING_KEY",
+	"REGISTER_AND_MOVE",
+};
+
 enum preempt_type {
 	PREEMPT,
 	PREEMPT_AND_ABORT,
 };
 
+static const char *const pr_preempt_type_table_str[] = {
+	"PREEMPT",
+	"PREEMPT_AND_ABORT",
+};
+
 static void __core_scsi3_complete_pro_release(struct se_device *, struct se_node_acl *,
 					      struct t10_pr_registration *, int, int);
 
@@ -180,7 +191,7 @@ static int target_check_scsi2_reservation_conflict(struct se_cmd *cmd)
 	}
 
 	if (conflict) {
-		target_err("Received legacy SPC-2 RESERVE/RELEASE while active SPC-3 registrations exist, returning RESERVATION_CONFLICT\n");
+		target_cmd_err(cmd, "Received legacy SPC-2 RESERVE/RELEASE while active SPC-3 registrations exist, returning RESERVATION_CONFLICT\n");
 		return -EBUSY;
 	}
 
@@ -225,9 +236,8 @@ target_scsi2_reservation_release(struct se_cmd *cmd)
 
 	target_release_reservation(dev);
 	tpg = sess->se_tpg;
-	target_debug("SCSI-2 Released reservation for %s LUN: %llu -> MAPPED LUN: %llu for %s\n",
-		     tpg->se_tpg_tfo->fabric_name, cmd->se_lun->unpacked_lun, cmd->orig_fe_lun,
-		     sess->se_node_acl->initiatorname);
+	target_cmd_debug(cmd, "SCSI-2 Released reservation for %s LUN: %llu\n",
+			 tpg->se_tpg_tfo->fabric_name, cmd->se_lun->unpacked_lun);
 
 out_unlock:
 	spin_unlock(&dev->dev_reservation_lock);
@@ -247,7 +257,7 @@ target_scsi2_reservation_reserve(struct se_cmd *cmd)
 
 	if ((cmd->t_task_cdb[1] & 0x01) &&
 	    (cmd->t_task_cdb[1] & 0x02)) {
-		target_err("LongIO and Obsolete Bits set, returning ILLEGAL_REQUEST\n");
+		target_cmd_err(cmd, "LongIO and Obsolete Bits set, returning ILLEGAL_REQUEST\n");
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 	/*
@@ -267,8 +277,8 @@ target_scsi2_reservation_reserve(struct se_cmd *cmd)
 	spin_lock(&dev->dev_reservation_lock);
 	if (dev->reservation_holder &&
 	    dev->reservation_holder->se_node_acl != sess->se_node_acl) {
-		target_err("SCSI-2 RESERVATION CONFLICT for %s fabric\n",
-			   tpg->se_tpg_tfo->fabric_name);
+		target_cmd_err(cmd, "SCSI-2 RESERVATION CONFLICT for %s fabric\n",
+			       tpg->se_tpg_tfo->fabric_name);
 		target_err("Original reserver LUN: %llu %s\n", cmd->se_lun->unpacked_lun,
 			   dev->reservation_holder->se_node_acl->initiatorname);
 		target_err("Current attempt - LUN: %llu -> MAPPED LUN: %llu from %s\n",
@@ -284,9 +294,8 @@ 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;
 	}
-	target_debug("SCSI-2 Reserved %s LUN: %llu -> MAPPED LUN: %llu for %s\n",
-		     tpg->se_tpg_tfo->fabric_name, cmd->se_lun->unpacked_lun, cmd->orig_fe_lun,
-		     sess->se_node_acl->initiatorname);
+	target_cmd_debug(cmd, "SCSI-2 Reserved %s LUN: %llu \n", tpg->se_tpg_tfo->fabric_name,
+			 cmd->se_lun->unpacked_lun);
 
 out_unlock:
 	spin_unlock(&dev->dev_reservation_lock);
@@ -408,8 +417,8 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 			ret = (registered_nexus) ? 0 : 1;
 			break;
 		default:
-			target_err("Unknown PERSISTENT_RESERVE_OUT service action: 0x%02x\n",
-				   cdb[1] & 0x1f);
+			target_cmd_err(cmd, "Unknown PERSISTENT_RESERVE_OUT service action: 0x%02x\n",
+				       cdb[1] & 0x1f);
 			return -EINVAL;
 		}
 		break;
@@ -455,7 +464,7 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 			ret = 0; /* Allowed */
 			break;
 		default:
-			target_err("Unknown MI Service Action: 0x%02x\n", (cdb[1] & 0x1f));
+			target_cmd_err(cmd, "Unknown MI Service Action: 0x%02x\n", (cdb[1] & 0x1f));
 			return -EINVAL;
 		}
 		break;
@@ -479,8 +488,8 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 	 * statement.
 	 */
 	if (!ret && !other_cdb) {
-		target_debug("Allowing explicit CDB: 0x%02x for %s reservation holder\n", cdb[0],
-			     core_scsi3_pr_dump_type(pr_reg_type));
+		target_cmd_debug(cmd, "Allowing explicit CDB: 0x%02x for %s reservation holder\n",
+				 cdb[0], core_scsi3_pr_dump_type(pr_reg_type));
 
 		return ret;
 	}
@@ -493,10 +502,10 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 			/*
 			 * Conflict for write exclusive
 			 */
-			target_debug("%s Conflict for unregistered nexus %s CDB: 0x%02x to %s reservation\n",
-				     transport_dump_cmd_direction(cmd),
-				     se_sess->se_node_acl->initiatorname, cdb[0],
-				     core_scsi3_pr_dump_type(pr_reg_type));
+			target_cmd_debug(cmd, "%s Conflict for unregistered nexus %s CDB: 0x%02x to %s reservation\n",
+					 transport_dump_cmd_direction(cmd),
+					 se_sess->se_node_acl->initiatorname,
+					 cdb[0], core_scsi3_pr_dump_type(pr_reg_type));
 			return 1;
 		} else {
 			/*
@@ -510,8 +519,8 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 			 */
 
 			if (!registered_nexus) {
-				target_debug("Allowing implicit CDB: 0x%02x for %s reservation on unregistered nexus\n",
-					     cdb[0], core_scsi3_pr_dump_type(pr_reg_type));
+				target_cmd_debug(cmd, "Allowing implicit CDB: 0x%02x for %s reservation on unregistered nexus\n",
+						 cdb[0], core_scsi3_pr_dump_type(pr_reg_type));
 			}
 
 			return 0;
@@ -523,8 +532,8 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 			 * allow commands from registered nexuses.
 			 */
 
-			target_debug("Allowing implicit CDB: 0x%02x for %s reservation\n", cdb[0],
-				     core_scsi3_pr_dump_type(pr_reg_type));
+			target_cmd_debug(cmd, "Allowing implicit CDB: 0x%02x for %s reservation\n",
+					 cdb[0], core_scsi3_pr_dump_type(pr_reg_type));
 
 			return 0;
 		}
@@ -534,16 +543,16 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 		 * from all registrants.
 		 */
 		if (cmd->data_direction == DMA_FROM_DEVICE) {
-			target_debug("Allowing READ CDB: 0x%02x for %s reservation\n", cdb[0],
-				     core_scsi3_pr_dump_type(pr_reg_type));
+			target_cmd_debug(cmd, "Allowing READ CDB: 0x%02x for %s reservation\n",
+					 cdb[0], core_scsi3_pr_dump_type(pr_reg_type));
 
 			return 0;
 		}
 	}
-	target_debug("%s Conflict for %sregistered nexus %s CDB: 0x%2x for %s reservation\n",
-		     transport_dump_cmd_direction(cmd), (registered_nexus) ? "" : "un",
-		     se_sess->se_node_acl->initiatorname, cdb[0],
-		     core_scsi3_pr_dump_type(pr_reg_type));
+	target_cmd_debug(cmd, "%s Conflict for %sregistered nexus %s CDB: 0x%2x for %s reservation\n",
+			 transport_dump_cmd_direction(cmd), (registered_nexus) ? "" : "un",
+			 se_sess->se_node_acl->initiatorname, cdb[0],
+			 core_scsi3_pr_dump_type(pr_reg_type));
 
 	return 1; /* Conflict by default */
 }
@@ -942,8 +951,8 @@ static int __core_scsi3_check_aptpl_registration(
 			rcu_read_lock();
 			pr_reg->pr_reg_deve = target_nacl_find_deve(nacl, mapped_lun);
 			if (!pr_reg->pr_reg_deve) {
-				target_err("Unable to locate PR APTPL %s mapped_lun: %llu\n",
-					   nacl->initiatorname, mapped_lun);
+				target_lun_err(lun, "Unable to locate PR APTPL %s mapped_lun: %llu\n",
+					       nacl->initiatorname, mapped_lun);
 				rcu_read_unlock();
 				continue;
 			}
@@ -1464,7 +1473,7 @@ core_scsi3_decode_spec_i_port(
 	 */
 	tidh_new = kzalloc(sizeof(struct pr_transport_id_holder), GFP_KERNEL);
 	if (!tidh_new) {
-		target_err("Unable to allocate tidh_new\n");
+		target_cmd_err(cmd, "Unable to allocate tidh_new\n");
 		return TCM_INSUFFICIENT_REGISTRATION_RESOURCES;
 	}
 	INIT_LIST_HEAD(&tidh_new->dest_list);
@@ -1492,8 +1501,8 @@ core_scsi3_decode_spec_i_port(
 	list_add_tail(&tidh_new->dest_list, &tid_dest_list);
 
 	if (cmd->data_length < 28) {
-		target_warn("SPC-PR: Received PR OUT parameter list length too small: %u\n",
-			    cmd->data_length);
+		target_cmd_warn(cmd, "SPC-PR: Received PR OUT parameter list length too small: %u\n",
+				cmd->data_length);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
@@ -1512,8 +1521,8 @@ core_scsi3_decode_spec_i_port(
 	tpdl = get_unaligned_be32(&buf[24]);
 
 	if ((tpdl + 28) != cmd->data_length) {
-		target_err("SPC-3 PR: Illegal tpdl: %u + 28 byte header does not equal CDB data_length: %u\n",
-			   tpdl, cmd->data_length);
+		target_cmd_err(cmd, "SPC-3 PR: Illegal tpdl: %u + 28 byte header does not equal CDB data_length: %u\n",
+			       tpdl, cmd->data_length);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out_unmap;
 	}
@@ -1555,8 +1564,8 @@ core_scsi3_decode_spec_i_port(
 			if (tpg->se_tpg_tfo->sess_get_initiator_sid &&
 			    dev->dev_attrib.enforce_pr_isids &&
 			    !iport_ptr) {
-				target_warn("SPC-PR: enforce_pr_isids is set but a isid has not been sent in the SPEC_I_PT data for %s.",
-					    i_str);
+				target_cmd_warn(cmd, "SPC-PR: enforce_pr_isids is set but a isid has not been sent in the SPEC_I_PT data for %s.\n",
+						i_str);
 				ret = TCM_INVALID_PARAMETER_LIST;
 				spin_unlock(&dev->se_port_lock);
 				goto out_unmap;
@@ -1566,7 +1575,7 @@ core_scsi3_decode_spec_i_port(
 			spin_unlock(&dev->se_port_lock);
 
 			if (core_scsi3_tpg_depend_item(tmp_tpg)) {
-				target_err(" core_scsi3_tpg_depend_item() for tmp_tpg\n");
+				target_cmd_err(cmd, "core_scsi3_tpg_depend_item() for tmp_tpg\n");
 				atomic_dec_mb(&tmp_tpg->tpg_pr_ref_count);
 				ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 				goto out_unmap;
@@ -1590,7 +1599,7 @@ core_scsi3_decode_spec_i_port(
 			}
 
 			if (core_scsi3_nodeacl_depend_item(dest_node_acl)) {
-				target_err("configfs_depend_item() failed for dest_node_acl->acl_group\n");
+				target_cmd_err(cmd, "configfs_depend_item() failed for dest_node_acl->acl_group\n");
 				atomic_dec_mb(&dest_node_acl->acl_pr_ref_count);
 				core_scsi3_tpg_undepend_item(tmp_tpg);
 				ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
@@ -1598,9 +1607,9 @@ core_scsi3_decode_spec_i_port(
 			}
 
 			dest_tpg = tmp_tpg;
-			target_debug("SPC-3 PR SPEC_I_PT: Located %s Node: %s Port RTPI: %u\n",
-				     dest_tpg->se_tpg_tfo->fabric_name,
-				     dest_node_acl->initiatorname, dest_rtpi);
+			target_cmd_debug(cmd, "SPC-3 PR SPEC_I_PT: Located %s Node: %s Port RTPI: %u\n",
+					 dest_tpg->se_tpg_tfo->fabric_name,
+					 dest_node_acl->initiatorname, dest_rtpi);
 
 			spin_lock(&dev->se_port_lock);
 			break;
@@ -1608,18 +1617,18 @@ core_scsi3_decode_spec_i_port(
 		spin_unlock(&dev->se_port_lock);
 
 		if (!dest_tpg) {
-			target_err("SPC-3 PR SPEC_I_PT: Unable to locate dest_tpg\n");
+			target_cmd_err(cmd, "SPC-3 PR SPEC_I_PT: Unable to locate dest_tpg\n");
 			ret = TCM_INVALID_PARAMETER_LIST;
 			goto out_unmap;
 		}
 
-		target_debug("SPC-3 PR SPEC_I_PT: Got %s data_length: %u tpdl: %u tid_len: %d for %s + %s\n",
-			     dest_tpg->se_tpg_tfo->fabric_name, cmd->data_length, tpdl, tid_len,
-			     i_str, iport_ptr);
+		target_cmd_debug(cmd, "SPC-3 PR SPEC_I_PT: Got %s data_length: %u tpdl: %u tid_len: %d for %s + %s\n",
+				 dest_tpg->se_tpg_tfo->fabric_name, cmd->data_length, tpdl, tid_len,
+				 i_str, iport_ptr);
 
 		if (tid_len > tpdl) {
-			target_err("SPC-3 PR SPEC_I_PT: Illegal tid_len: %u for Transport ID: %s\n",
-				   tid_len, ptr);
+			target_cmd_err(cmd, "SPC-3 PR SPEC_I_PT: Illegal tid_len: %u for Transport ID: %s\n",
+				       tid_len, ptr);
 			core_scsi3_nodeacl_undepend_item(dest_node_acl);
 			core_scsi3_tpg_undepend_item(dest_tpg);
 			ret = TCM_INVALID_PARAMETER_LIST;
@@ -1633,8 +1642,8 @@ core_scsi3_decode_spec_i_port(
 		dest_se_deve = core_get_se_deve_from_rtpi(dest_node_acl,
 					dest_rtpi);
 		if (!dest_se_deve) {
-			target_err("Unable to locate %s dest_se_deve from destination RTPI: %u\n",
-				   dest_tpg->se_tpg_tfo->fabric_name, dest_rtpi);
+			target_cmd_err(cmd, "Unable to locate %s dest_se_deve from destination RTPI: %u\n",
+				       dest_tpg->se_tpg_tfo->fabric_name, dest_rtpi);
 
 			core_scsi3_nodeacl_undepend_item(dest_node_acl);
 			core_scsi3_tpg_undepend_item(dest_tpg);
@@ -1643,7 +1652,7 @@ core_scsi3_decode_spec_i_port(
 		}
 
 		if (core_scsi3_lunacl_depend_item(dest_se_deve)) {
-			target_err("core_scsi3_lunacl_depend_item() failed\n");
+			target_cmd_err(cmd, "core_scsi3_lunacl_depend_item() failed\n");
 			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);
@@ -1651,9 +1660,9 @@ core_scsi3_decode_spec_i_port(
 			goto out_unmap;
 		}
 
-		target_debug("SPC-3 PR SPEC_I_PT: Located %s Node: %s dest_se_deve mapped_lun: %llu\n",
-			     dest_tpg->se_tpg_tfo->fabric_name, dest_node_acl->initiatorname,
-			     dest_se_deve->mapped_lun);
+		target_cmd_debug(cmd, "SPC-3 PR SPEC_I_PT: Located %s Node: %s dest_se_deve mapped_lun: %llu\n",
+				 dest_tpg->se_tpg_tfo->fabric_name, dest_node_acl->initiatorname,
+				 dest_se_deve->mapped_lun);
 
 		/*
 		 * Skip any TransportIDs that already have a registration for
@@ -1679,7 +1688,7 @@ core_scsi3_decode_spec_i_port(
 		tidh_new = kzalloc(sizeof(struct pr_transport_id_holder),
 				GFP_KERNEL);
 		if (!tidh_new) {
-			target_err("Unable to allocate tidh_new\n");
+			target_cmd_err(cmd, "Unable to allocate tidh_new\n");
 			core_scsi3_lunacl_undepend_item(dest_se_deve);
 			core_scsi3_nodeacl_undepend_item(dest_node_acl);
 			core_scsi3_tpg_undepend_item(dest_tpg);
@@ -1760,9 +1769,9 @@ core_scsi3_decode_spec_i_port(
 		__core_scsi3_add_registration(cmd->se_dev, dest_node_acl,
 					dest_pr_reg, 0, 0);
 
-		target_debug("SPC-3 PR [%s] SPEC_I_PT: Successfully registered Transport ID for Node: %s%s Mapped LUN: %llu\n",
-			     dest_tpg->se_tpg_tfo->fabric_name, dest_node_acl->initiatorname, i_buf,
-			     (dest_se_deve) ? dest_se_deve->mapped_lun : 0);
+		target_cmd_debug(cmd, "SPC-3 PR [%s] SPEC_I_PT: Successfully registered Transport ID for Node: %s%s Mapped LUN: %llu\n",
+				 dest_tpg->se_tpg_tfo->fabric_name, dest_node_acl->initiatorname,
+				 i_buf, (dest_se_deve) ? dest_se_deve->mapped_lun : 0);
 
 		if (dest_pr_reg == local_pr_reg)
 			continue;
@@ -2024,7 +2033,7 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
 	pr_reg = core_scsi3_locate_pr_reg(dev, se_sess->se_node_acl, se_sess);
 	if (!pr_reg) {
 		if (res_key) {
-			target_warn("SPC-3 PR: Reservation Key non-zero for SA REGISTER, returning CONFLICT\n");
+			target_cmd_warn(cmd, "SPC-3 PR: Reservation Key non-zero for SA REGISTER, returning CONFLICT\n");
 			return TCM_RESERVATION_CONFLICT;
 		}
 		/*
@@ -2044,7 +2053,7 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
 					NULL, cmd->orig_fe_lun, isid_ptr,
 					sa_res_key, all_tg_pt, aptpl,
 					register_type, 0)) {
-				target_err("Unable to allocate struct t10_pr_registration\n");
+				target_cmd_err(cmd, "Unable to allocate struct t10_pr_registration\n");
 				return TCM_INSUFFICIENT_REGISTRATION_RESOURCES;
 			}
 		} else {
@@ -2067,14 +2076,14 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
 	/* ok, existing registration */
 
 	if ((register_type == REGISTER) && (res_key != pr_reg->pr_res_key)) {
-		target_err("SPC-3 PR REGISTER: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
-			   res_key, pr_reg->pr_res_key);
+		target_cmd_err(cmd, "SPC-3 PR REGISTER: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
+			       res_key, pr_reg->pr_res_key);
 		ret = TCM_RESERVATION_CONFLICT;
 		goto out;
 	}
 
 	if (spec_i_pt) {
-		target_err("SPC-3 PR REGISTER: SPEC_I_PT set on a registered nexus\n");
+		target_cmd_err(cmd, "SPC-3 PR REGISTER: SPEC_I_PT set on a registered nexus\n");
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
@@ -2084,7 +2093,7 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
 	 * must also set ALL_TG_PT=1 in the incoming PROUT.
 	 */
 	if (pr_reg->pr_reg_all_tg_pt && !all_tg_pt) {
-		target_err("SPC-3 PR REGISTER: ALL_TG_PT=1 registration exists, but ALL_TG_PT=1 bit not present in received PROUT\n");
+		target_cmd_err(cmd, "SPC-3 PR REGISTER: ALL_TG_PT=1 registration exists, but ALL_TG_PT=1 bit not present in received PROUT\n");
 		ret = TCM_INVALID_CDB_FIELD;
 		goto out;
 	}
@@ -2100,11 +2109,12 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
 		 */
 		pr_reg->pr_res_generation = core_scsi3_pr_generation(cmd->se_dev);
 		pr_reg->pr_res_key = sa_res_key;
-		target_debug("SPC-3 PR [%s] REGISTER%s: Changed Reservation Key for %s to: 0x%016Lx PRgeneration: 0x%08x\n",
-			     cmd->se_tfo->fabric_name,
-			     (register_type == REGISTER_AND_IGNORE_EXISTING_KEY) ?
-			     "_AND_IGNORE_EXISTING_KEY" : "", pr_reg->pr_reg_nacl->initiatorname,
-			     pr_reg->pr_res_key, pr_reg->pr_res_generation);
+		target_cmd_debug(cmd, "SPC-3 PR [%s] REGISTER%s: Changed Reservation Key for %s to: 0x%016Lx PRgeneration: 0x%08x\n",
+				 cmd->se_tfo->fabric_name,
+				 (register_type == REGISTER_AND_IGNORE_EXISTING_KEY) ?
+				 "_AND_IGNORE_EXISTING_KEY" : "",
+				 pr_reg->pr_reg_nacl->initiatorname, pr_reg->pr_res_key,
+				 pr_reg->pr_res_generation);
 
 	} else {
 		/*
@@ -2229,7 +2239,7 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
 	pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
 				se_sess);
 	if (!pr_reg) {
-		target_err("SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for RESERVE\n");
+		target_cmd_err(cmd, "SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for RESERVE\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 	/*
@@ -2242,8 +2252,8 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
 	 *	 registered with the logical unit for the I_T nexus; and
 	 */
 	if (res_key != pr_reg->pr_res_key) {
-		target_err("SPC-3 PR RESERVE: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
-			   res_key, pr_reg->pr_res_key);
+		target_cmd_err(cmd, "SPC-3 PR RESERVE: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
+			       res_key, pr_reg->pr_res_key);
 		ret = TCM_RESERVATION_CONFLICT;
 		goto out_put_pr_reg;
 	}
@@ -2258,7 +2268,7 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
 	 * and that persistent reservation has a scope of LU_SCOPE.
 	 */
 	if (scope != PR_SCOPE_LU_SCOPE) {
-		target_err("SPC-3 PR: Illegal SCOPE: 0x%02x\n", scope);
+		target_cmd_err(cmd, "SPC-3 PR: Illegal SCOPE: 0x%02x\n", scope);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out_put_pr_reg;
 	}
@@ -2283,10 +2293,11 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
 		if (!is_reservation_holder(pr_res_holder, pr_reg)) {
 			struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl;
 
-			target_err("SPC-3 PR: Attempted RESERVE from [%s]: %s while reservation already held by [%s]: %s, returning RESERVATION_CONFLICT\n",
-				   cmd->se_tfo->fabric_name, se_sess->se_node_acl->initiatorname,
-				   pr_res_nacl->se_tpg->se_tpg_tfo->fabric_name,
-				   pr_res_holder->pr_reg_nacl->initiatorname);
+			target_cmd_err(cmd, "SPC-3 PR: Attempted RESERVE from [%s]: %s while reservation already held by [%s]: %s, returning RESERVATION_CONFLICT\n",
+				       cmd->se_tfo->fabric_name,
+				       se_sess->se_node_acl->initiatorname,
+				       pr_res_nacl->se_tpg->se_tpg_tfo->fabric_name,
+				       pr_res_holder->pr_reg_nacl->initiatorname);
 
 			spin_unlock(&dev->dev_reservation_lock);
 			ret = TCM_RESERVATION_CONFLICT;
@@ -2303,10 +2314,11 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
 		    (pr_res_holder->pr_res_scope != scope)) {
 			struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl;
 
-			target_err("SPC-3 PR: Attempted RESERVE from [%s]: %s trying to change TYPE and/or SCOPE, while reservation already held by [%s]: %s, returning RESERVATION_CONFLICT\n",
-				   cmd->se_tfo->fabric_name, se_sess->se_node_acl->initiatorname,
-				   pr_res_nacl->se_tpg->se_tpg_tfo->fabric_name,
-				   pr_res_holder->pr_reg_nacl->initiatorname);
+			target_cmd_err(cmd, "SPC-3 PR: Attempted RESERVE from [%s]: %s trying to change TYPE and/or SCOPE, while reservation already held by [%s]: %s, returning RESERVATION_CONFLICT\n",
+				       cmd->se_tfo->fabric_name,
+				       se_sess->se_node_acl->initiatorname,
+				       pr_res_nacl->se_tpg->se_tpg_tfo->fabric_name,
+				       pr_res_holder->pr_reg_nacl->initiatorname);
 
 			spin_unlock(&dev->dev_reservation_lock);
 			ret = TCM_RESERVATION_CONFLICT;
@@ -2336,11 +2348,11 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
 	dev->dev_pr_res_holder = pr_reg;
 	core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
 
-	target_debug("SPC-3 PR [%s] Service Action: RESERVE created new reservation holder TYPE: %s ALL_TG_PT: %d\n",
-		     cmd->se_tfo->fabric_name, core_scsi3_pr_dump_type(type),
-		     (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
-	target_debug("SPC-3 PR [%s] RESERVE Node: %s%s\n", cmd->se_tfo->fabric_name,
-		     se_sess->se_node_acl->initiatorname, i_buf);
+	target_cmd_err(cmd, "SPC-3 PR [%s] Service Action: RESERVE created new reservation holder TYPE: %s ALL_TG_PT: %d\n",
+		       cmd->se_tfo->fabric_name, core_scsi3_pr_dump_type(type),
+		       (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
+	target_cmd_err(cmd, "SPC-3 PR [%s] RESERVE Node: %s%s\n", cmd->se_tfo->fabric_name,
+		       se_sess->se_node_acl->initiatorname, i_buf);
 	spin_unlock(&dev->dev_reservation_lock);
 
 	if (pr_tmpl->pr_aptpl_active)
@@ -2365,7 +2377,8 @@ core_scsi3_emulate_pro_reserve(struct se_cmd *cmd, int type, int scope,
 	case PR_TYPE_EXCLUSIVE_ACCESS_ALLREG:
 		return core_scsi3_pro_reserve(cmd, type, scope, res_key);
 	default:
-		target_err("SPC-3 PR: Unknown Service Action RESERVE Type: 0x%02x\n", type);
+		target_cmd_err(cmd, "SPC-3 PR: Unknown Service Action RESERVE Type: 0x%02x\n",
+			       type);
 		return TCM_INVALID_CDB_FIELD;
 	}
 }
@@ -2455,7 +2468,7 @@ core_scsi3_emulate_pro_release(struct se_cmd *cmd, int type, int scope,
 	 */
 	pr_reg = core_scsi3_locate_pr_reg(dev, se_sess->se_node_acl, se_sess);
 	if (!pr_reg) {
-		target_err("SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for RELEASE\n");
+		target_cmd_err(cmd, "SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for RELEASE\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 	/*
@@ -2504,8 +2517,8 @@ core_scsi3_emulate_pro_release(struct se_cmd *cmd, int type, int scope,
 	 *	  that is registered with the logical unit for the I_T nexus;
 	 */
 	if (res_key != pr_reg->pr_res_key) {
-		target_err("SPC-3 PR RELEASE: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
-			   res_key, pr_reg->pr_res_key);
+		target_cmd_err(cmd, "SPC-3 PR RELEASE: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
+			       res_key, pr_reg->pr_res_key);
 		spin_unlock(&dev->dev_reservation_lock);
 		ret = TCM_RESERVATION_CONFLICT;
 		goto out_put_pr_reg;
@@ -2520,10 +2533,10 @@ core_scsi3_emulate_pro_release(struct se_cmd *cmd, int type, int scope,
 	    (pr_res_holder->pr_res_scope != scope)) {
 		struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl;
 
-		target_err("SPC-3 PR RELEASE: Attempted to release reservation from [%s]: %s with different TYPE and/or SCOPE  while reservation already held by [%s]: %s, returning RESERVATION_CONFLICT\n",
-			   cmd->se_tfo->fabric_name, se_sess->se_node_acl->initiatorname,
-			   pr_res_nacl->se_tpg->se_tpg_tfo->fabric_name,
-			   pr_res_holder->pr_reg_nacl->initiatorname);
+		target_cmd_err(cmd, "SPC-3 PR RELEASE: Attempted to release reservation from [%s]: %s with different TYPE and/or SCOPE  while reservation already held by [%s]: %s, returning RESERVATION_CONFLICT\n",
+			       cmd->se_tfo->fabric_name, se_sess->se_node_acl->initiatorname,
+			       pr_res_nacl->se_tpg->se_tpg_tfo->fabric_name,
+			       pr_res_holder->pr_reg_nacl->initiatorname);
 
 		spin_unlock(&dev->dev_reservation_lock);
 		ret = TCM_RESERVATION_CONFLICT;
@@ -2603,7 +2616,7 @@ core_scsi3_emulate_pro_clear(struct se_cmd *cmd, u64 res_key)
 	pr_reg_n = core_scsi3_locate_pr_reg(cmd->se_dev,
 			se_sess->se_node_acl, se_sess);
 	if (!pr_reg_n) {
-		target_err("SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for CLEAR\n");
+		target_cmd_err(cmd, "SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for CLEAR\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 	/*
@@ -2618,8 +2631,8 @@ core_scsi3_emulate_pro_clear(struct se_cmd *cmd, u64 res_key)
 	 *	   that is registered with the logical unit for the I_T nexus.
 	 */
 	if (res_key != pr_reg_n->pr_res_key) {
-		target_err("SPC-3 PR REGISTER: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
-			   res_key, pr_reg_n->pr_res_key);
+		target_cmd_err(cmd, "SPC-3 PR REGISTER: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
+			       res_key, pr_reg_n->pr_res_key);
 		core_scsi3_put_pr_reg(pr_reg_n);
 		return TCM_RESERVATION_CONFLICT;
 	}
@@ -2660,7 +2673,8 @@ core_scsi3_emulate_pro_clear(struct se_cmd *cmd, u64 res_key)
 	}
 	spin_unlock(&pr_tmpl->registration_lock);
 
-	target_debug("SPC-3 PR [%s] Service Action: CLEAR complete\n", cmd->se_tfo->fabric_name);
+	target_cmd_debug(cmd, "SPC-3 PR [%s] Service Action: CLEAR complete\n",
+			 cmd->se_tfo->fabric_name);
 
 	core_scsi3_update_and_write_aptpl(cmd->se_dev, false);
 
@@ -2755,8 +2769,8 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
 	pr_reg_n = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
 				se_sess);
 	if (!pr_reg_n) {
-		target_err("SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for PREEMPT%s\n",
-			   (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "");
+		target_cmd_err(cmd, "SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for PREEMPT%s\n",
+			       (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "");
 		return TCM_RESERVATION_CONFLICT;
 	}
 	if (pr_reg_n->pr_res_key != res_key) {
@@ -2764,7 +2778,7 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
 		return TCM_RESERVATION_CONFLICT;
 	}
 	if (scope != PR_SCOPE_LU_SCOPE) {
-		target_err("SPC-3 PR: Illegal SCOPE: 0x%02x\n", scope);
+		target_cmd_err(cmd, "SPC-3 PR: Illegal SCOPE: 0x%02x\n", scope);
 		core_scsi3_put_pr_reg(pr_reg_n);
 		return TCM_INVALID_PARAMETER_LIST;
 	}
@@ -3057,8 +3071,8 @@ core_scsi3_emulate_pro_preempt(struct se_cmd *cmd, int type, int scope,
 		return core_scsi3_pro_preempt(cmd, type, scope, res_key,
 					      sa_res_key, preempt_type);
 	default:
-		target_err("SPC-3 PR: Unknown Service Action PREEMPT%s Type: 0x%02x\n",
-			   (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "", type);
+		target_cmd_err(cmd, "SPC-3 PR: Unknown Service Action PREEMPT%s Type: 0x%02x\n",
+			       (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "", type);
 		return TCM_INVALID_CDB_FIELD;
 	}
 }
@@ -3102,7 +3116,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
 				se_sess);
 	if (!pr_reg) {
-		target_err("SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for REGISTER_AND_MOVE\n");
+		target_cmd_err(cmd, "SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for REGISTER_AND_MOVE\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 	/*
@@ -3110,8 +3124,8 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	 * provided during this initiator's I_T nexus registration.
 	 */
 	if (res_key != pr_reg->pr_res_key) {
-		target_warn("SPC-3 PR REGISTER_AND_MOVE: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
-			    res_key, pr_reg->pr_res_key);
+		target_cmd_warn(cmd, "SPC-3 PR REGISTER_AND_MOVE: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
+				res_key, pr_reg->pr_res_key);
 		ret = TCM_RESERVATION_CONFLICT;
 		goto out_put_pr_reg;
 	}
@@ -3119,7 +3133,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	 * The service active reservation key needs to be non zero
 	 */
 	if (!sa_res_key) {
-		target_warn("SPC-3 PR REGISTER_AND_MOVE: Received zero sa_res_key\n");
+		target_cmd_warn(cmd, "SPC-3 PR REGISTER_AND_MOVE: Received zero sa_res_key\n");
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out_put_pr_reg;
 	}
@@ -3141,8 +3155,8 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	buf = NULL;
 
 	if ((tid_len + 24) != cmd->data_length) {
-		target_err("SPC-3 PR: Illegal tid_len: %u + 24 byte header does not equal CDB data_length: %u\n",
-			   tid_len, cmd->data_length);
+		target_cmd_err(cmd, "SPC-3 PR: Illegal tid_len: %u + 24 byte header does not equal CDB data_length: %u\n",
+			       tid_len, cmd->data_length);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out_put_pr_reg;
 	}
@@ -3160,7 +3174,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 		spin_unlock(&dev->se_port_lock);
 
 		if (core_scsi3_tpg_depend_item(dest_se_tpg)) {
-			target_err("core_scsi3_tpg_depend_item() failed for dest_se_tpg\n");
+			target_cmd_err(cmd, "core_scsi3_tpg_depend_item() failed for dest_se_tpg\n");
 			atomic_dec_mb(&dest_se_tpg->tpg_pr_ref_count);
 			ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 			goto out_put_pr_reg;
@@ -3172,8 +3186,8 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	spin_unlock(&dev->se_port_lock);
 
 	if (!dest_se_tpg || !dest_tf_ops) {
-		target_err("SPC-3 PR REGISTER_AND_MOVE: Unable to locate fabric ops from Relative Target Port Identifier: %u\n",
-			   rtpi);
+		target_cmd_err(cmd, "SPC-3 PR REGISTER_AND_MOVE: Unable to locate fabric ops from Relative Target Port Identifier: %u\n",
+			       rtpi);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out_put_pr_reg;
 	}
@@ -3185,19 +3199,19 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	}
 	proto_ident = (buf[24] & 0x0f);
 
-	target_debug("SPC-3 PR REGISTER_AND_MOVE: Extracted Protocol Identifier: 0x%02x\n",
-		     proto_ident);
+	target_cmd_debug(cmd, "SPC-3 PR REGISTER_AND_MOVE: Extracted Protocol Identifier: 0x%02x\n",
+			 proto_ident);
 
 	if (proto_ident != dest_se_tpg->proto_id) {
-		target_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_se_tpg->proto_id, dest_tf_ops->fabric_name);
+		target_cmd_err(cmd, "SPC-3 PR REGISTER_AND_MOVE: Received proto_ident: 0x%02x does not match ident: 0x%02x from fabric: %s\n",
+			       proto_ident, dest_se_tpg->proto_id, dest_tf_ops->fabric_name);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
 	initiator_str = target_parse_pr_out_transport_id(dest_se_tpg,
 			&buf[24], &tmp_tid_len, &iport_ptr);
 	if (!initiator_str) {
-		target_err("SPC-3 PR REGISTER_AND_MOVE: Unable to locate initiator_str from Transport ID\n");
+		target_cmd_err(cmd, "SPC-3 PR REGISTER_AND_MOVE: Unable to locate initiator_str from Transport ID\n");
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
@@ -3205,9 +3219,9 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	transport_kunmap_data_sg(cmd);
 	buf = NULL;
 
-	target_debug("SPC-3 PR [%s] Extracted initiator %s identifier: %s %s\n",
-		     dest_tf_ops->fabric_name, (iport_ptr != NULL) ? "port" : "device",
-		     initiator_str, (iport_ptr != NULL) ? iport_ptr : "");
+	target_cmd_debug(cmd, "SPC-3 PR [%s] Extracted initiator %s identifier: %s %s\n",
+			 dest_tf_ops->fabric_name, (iport_ptr != NULL) ? "port" : "device",
+			 initiator_str, (iport_ptr != NULL) ? iport_ptr : "");
 	/*
 	 * If a PERSISTENT RESERVE OUT command with a REGISTER AND MOVE service
 	 * action specifies a TransportID that is the same as the initiator port
@@ -3223,8 +3237,8 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 		goto after_iport_check;
 
 	if (!iport_ptr || !pr_reg->isid_present_at_reg) {
-		target_err("SPC-3 PR REGISTER_AND_MOVE: TransportID: %s matches: %s on received I_T Nexus\n",
-			   initiator_str, pr_reg_nacl->initiatorname);
+		target_cmd_err(cmd, "SPC-3 PR REGISTER_AND_MOVE: TransportID: %s matches: %s on received I_T Nexus\n",
+			       initiator_str, pr_reg_nacl->initiatorname);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
@@ -3247,22 +3261,22 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	mutex_unlock(&dest_se_tpg->acl_node_mutex);
 
 	if (!dest_node_acl) {
-		target_err("Unable to locate %s dest_node_acl for TransportID%s\n",
-			   dest_tf_ops->fabric_name, initiator_str);
+		target_cmd_err(cmd, "Unable to locate %s dest_node_acl for TransportID%s\n",
+			       dest_tf_ops->fabric_name, initiator_str);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
 
 	if (core_scsi3_nodeacl_depend_item(dest_node_acl)) {
-		target_err("core_scsi3_nodeacl_depend_item() for dest_node_acl\n");
+		target_cmd_err(cmd, "core_scsi3_nodeacl_depend_item() for dest_node_acl\n");
 		atomic_dec_mb(&dest_node_acl->acl_pr_ref_count);
 		dest_node_acl = NULL;
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
 
-	target_debug("SPC-3 PR REGISTER_AND_MOVE: Found %s dest_node_acl: %s from TransportID\n",
-		     dest_tf_ops->fabric_name, dest_node_acl->initiatorname);
+	target_cmd_debug(cmd, "SPC-3 PR REGISTER_AND_MOVE: Found %s dest_node_acl: %s from TransportID\n",
+			 dest_tf_ops->fabric_name, dest_node_acl->initiatorname);
 
 	/*
 	 * Locate the struct se_dev_entry pointer for the matching RELATIVE TARGET
@@ -3270,23 +3284,23 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	 */
 	dest_se_deve = core_get_se_deve_from_rtpi(dest_node_acl, rtpi);
 	if (!dest_se_deve) {
-		target_err("Unable to locate %s dest_se_deve from RTPI: %u\n",
-			   dest_tf_ops->fabric_name, rtpi);
+		target_cmd_err(cmd, "Unable to locate %s dest_se_deve from RTPI: %u\n",
+			       dest_tf_ops->fabric_name, rtpi);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
 
 	if (core_scsi3_lunacl_depend_item(dest_se_deve)) {
-		target_err("core_scsi3_lunacl_depend_item() failed\n");
+		target_cmd_err(cmd, "core_scsi3_lunacl_depend_item() failed\n");
 		kref_put(&dest_se_deve->pr_kref, target_pr_kref_release);
 		dest_se_deve = NULL;
 		ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 		goto out;
 	}
 
-	target_debug("SPC-3 PR REGISTER_AND_MOVE: Located %s node %s LUN ACL for dest_se_deve->mapped_lun: %llu\n",
-		     dest_tf_ops->fabric_name, dest_node_acl->initiatorname,
-		     dest_se_deve->mapped_lun);
+	target_cmd_debug(cmd, "SPC-3 PR REGISTER_AND_MOVE: Located %s node %s LUN ACL for dest_se_deve->mapped_lun: %llu\n",
+			 dest_tf_ops->fabric_name, dest_node_acl->initiatorname,
+			 dest_se_deve->mapped_lun);
 
 	/*
 	 * A persistent reservation needs to already existing in order to
@@ -3295,7 +3309,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	spin_lock(&dev->dev_reservation_lock);
 	pr_res_holder = dev->dev_pr_res_holder;
 	if (!pr_res_holder) {
-		target_warn("SPC-3 PR REGISTER_AND_MOVE: No reservation currently held\n");
+		target_cmd_warn(cmd, "SPC-3 PR REGISTER_AND_MOVE: No reservation currently held\n");
 		spin_unlock(&dev->dev_reservation_lock);
 		ret = TCM_INVALID_CDB_FIELD;
 		goto out;
@@ -3307,7 +3321,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	 *	Register behaviors for a REGISTER AND MOVE service action
 	 */
 	if (!is_reservation_holder(pr_res_holder, pr_reg)) {
-		target_warn("SPC-3 PR REGISTER_AND_MOVE: Calling I_T Nexus is not reservation holder\n");
+		target_cmd_warn(cmd, "SPC-3 PR REGISTER_AND_MOVE: Calling I_T Nexus is not reservation holder\n");
 		spin_unlock(&dev->dev_reservation_lock);
 		ret = TCM_RESERVATION_CONFLICT;
 		goto out;
@@ -3323,8 +3337,8 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	 */
 	if ((pr_res_holder->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) ||
 	    (pr_res_holder->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG)) {
-		target_warn("SPC-3 PR REGISTER_AND_MOVE: Unable to move reservation for type: %s\n",
-			    core_scsi3_pr_dump_type(pr_res_holder->pr_res_type));
+		target_cmd_warn(cmd, "SPC-3 PR REGISTER_AND_MOVE: Unable to move reservation for type: %s\n",
+				core_scsi3_pr_dump_type(pr_res_holder->pr_res_type));
 		spin_unlock(&dev->dev_reservation_lock);
 		ret = TCM_RESERVATION_CONFLICT;
 		goto out;
@@ -3399,13 +3413,13 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 		dest_pr_reg->pr_res_generation = pr_tmpl->pr_generation++;
 	spin_unlock(&dev->dev_reservation_lock);
 
-	target_debug("SPC-3 PR [%s] Service Action: REGISTER_AND_MOVE created new reservation holder TYPE: %s on object RTPI: %u  PRGeneration: 0x%08x\n",
-		     dest_tf_ops->fabric_name, core_scsi3_pr_dump_type(type), rtpi,
-		     dest_pr_reg->pr_res_generation);
-	target_debug("SPC-3 PR Successfully moved reservation from %s Fabric Node: %s%s -> %s Fabric Node: %s %s\n",
-		     tf_ops->fabric_name, pr_reg_nacl->initiatorname, i_buf,
-		     dest_tf_ops->fabric_name, dest_node_acl->initiatorname,
-		     (iport_ptr != NULL) ? iport_ptr : "");
+	target_cmd_debug(cmd, "SPC-3 PR [%s] Service Action: REGISTER_AND_MOVE created new reservation holder TYPE: %s on object RTPI: %u  PRGeneration: 0x%08x\n",
+			 dest_tf_ops->fabric_name, core_scsi3_pr_dump_type(type), rtpi,
+			 dest_pr_reg->pr_res_generation);
+	target_cmd_debug(cmd, "SPC-3 PR Successfully moved reservation from %s Fabric Node: %s%s -> %s Fabric Node: %s %s\n",
+			 tf_ops->fabric_name, pr_reg_nacl->initiatorname, i_buf,
+			 dest_tf_ops->fabric_name, dest_node_acl->initiatorname,
+			 (iport_ptr != NULL) ? iport_ptr : "");
 	/*
 	 * It is now safe to release configfs group dependencies for destination
 	 * of Transport ID Initiator Device/Port Identifier
@@ -3454,19 +3468,19 @@ target_try_pr_out_pt(struct se_cmd *cmd, u8 sa, u64 res_key, u64 sa_res_key,
 	}
 
 	if (!ops->execute_pr_out) {
-		target_err("SPC-3 PR: Device has been configured for PR passthrough but it's not supported by the backend.\n");
+		target_cmd_err(cmd, "SPC-3 PR: Device has been configured for PR passthrough but it's not supported by the backend.\n");
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 
 	switch (sa) {
 	case PRO_REGISTER_AND_MOVE:
 	case PRO_REPLACE_LOST_RESERVATION:
-		target_err("SPC-3 PR: PRO_REGISTER_AND_MOVE and PRO_REPLACE_LOST_RESERVATION are not supported by PR passthrough.\n");
+		target_cmd_err(cmd, "SPC-3 PR: PRO_REGISTER_AND_MOVE and PRO_REPLACE_LOST_RESERVATION are not supported by PR passthrough.\n");
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 
 	if (spec_i_pt || all_tg_pt) {
-		target_err("SPC-3 PR: SPEC_I_PT and ALL_TG_PT are not supported by PR passthrough.\n");
+		target_cmd_err(cmd, "SPC-3 PR: SPEC_I_PT and ALL_TG_PT are not supported by PR passthrough.\n");
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 
@@ -3497,7 +3511,7 @@ target_scsi3_emulate_pr_out(struct se_cmd *cmd)
 	 * CONFLICT status.
 	 */
 	if (cmd->se_dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) {
-		target_err("Received PERSISTENT_RESERVE CDB while legacy SPC-2 reservation is held, returning RESERVATION_CONFLICT\n");
+		target_cmd_err(cmd, "Received PERSISTENT_RESERVE CDB while legacy SPC-2 reservation is held, returning RESERVATION_CONFLICT\n");
 		return TCM_RESERVATION_CONFLICT;
 	}
 
@@ -3509,8 +3523,8 @@ target_scsi3_emulate_pr_out(struct se_cmd *cmd)
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 
 	if (cmd->data_length < 24) {
-		target_warn("SPC-PR: Received PR OUT parameter list length too small: %u\n",
-			    cmd->data_length);
+		target_cmd_warn(cmd, "SPC-PR: Received PR OUT parameter list length too small: %u\n",
+				cmd->data_length);
 		return TCM_PARAMETER_LIST_LENGTH_ERROR;
 	}
 
@@ -3569,8 +3583,8 @@ target_scsi3_emulate_pr_out(struct se_cmd *cmd)
 	 */
 	if (!spec_i_pt && (sa != PRO_REGISTER_AND_MOVE) &&
 	    (cmd->data_length != 24)) {
-		target_warn("SPC-PR: Received PR OUT illegal parameter list length: %u\n",
-			    cmd->data_length);
+		target_cmd_warn(cmd, "SPC-PR: Received PR OUT illegal parameter list length: %u\n",
+				cmd->data_length);
 		return TCM_PARAMETER_LIST_LENGTH_ERROR;
 	}
 
@@ -3616,7 +3630,7 @@ target_scsi3_emulate_pr_out(struct se_cmd *cmd)
 				sa_res_key, aptpl, unreg);
 		break;
 	default:
-		target_err("Unknown PERSISTENT_RESERVE_OUT service action: 0x%02x\n", sa);
+		target_cmd_err(cmd, "Unknown PERSISTENT_RESERVE_OUT service action: 0x%02x\n", sa);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -3640,7 +3654,8 @@ core_scsi3_pri_read_keys(struct se_cmd *cmd)
 	u32 add_len = 0, off = 8;
 
 	if (cmd->data_length < 8) {
-		target_err("PRIN SA READ_KEYS SCSI Data Length: %u too small\n", cmd->data_length);
+		target_cmd_err(cmd, "PRIN SA READ_KEYS SCSI Data Length: %u too small\n",
+			       cmd->data_length);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -3694,8 +3709,8 @@ core_scsi3_pri_read_reservation(struct se_cmd *cmd)
 	u32 add_len = 0;
 
 	if (cmd->data_length < 8) {
-		target_err("PRIN SA READ_RESERVATIONS SCSI Data Length: %u too small\n",
-			   cmd->data_length);
+		target_cmd_err(cmd, "PRIN SA READ_RESERVATIONS SCSI Data Length: %u too small\n",
+			       cmd->data_length);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -3770,8 +3785,8 @@ core_scsi3_pri_report_capabilities(struct se_cmd *cmd)
 	u16 len = 8; /* Hardcoded to 8. */
 
 	if (cmd->data_length < 6) {
-		target_err("PRIN SA REPORT_CAPABILITIES SCSI Data Length: %u too small\n",
-			   cmd->data_length);
+		target_cmd_err(cmd, "PRIN SA REPORT_CAPABILITIES SCSI Data Length: %u too small\n",
+			       cmd->data_length);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -3836,8 +3851,8 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
 	bool all_reg = false;
 
 	if (cmd->data_length < 8) {
-		target_err("PRIN SA READ_FULL_STATUS SCSI Data Length: %u too small\n",
-			   cmd->data_length);
+		target_cmd_err(cmd, "PRIN SA READ_FULL_STATUS SCSI Data Length: %u too small\n",
+			       cmd->data_length);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -3878,8 +3893,8 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
 					&format_code);
 		if (exp_desc_len < 0 ||
 		    exp_desc_len + add_len > cmd->data_length) {
-			target_warn("SPC-3 PRIN READ_FULL_STATUS ran out of buffer: %d\n",
-				    cmd->data_length);
+			target_cmd_warn(cmd, "SPC-3 PRIN READ_FULL_STATUS ran out of buffer: %d\n",
+					cmd->data_length);
 			spin_lock(&pr_tmpl->registration_lock);
 			atomic_dec_mb(&pr_reg->pr_res_holders);
 			break;
@@ -3984,17 +3999,17 @@ static sense_reason_t target_try_pr_in_pt(struct se_cmd *cmd, u8 sa)
 	sense_reason_t ret;
 
 	if (cmd->data_length < 8) {
-		target_err("PRIN SA SCSI Data Length: %u too small\n", cmd->data_length);
+		target_cmd_err(cmd, "PRIN SA SCSI Data Length: %u too small\n", cmd->data_length);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
 	if (!ops->execute_pr_in) {
-		target_err("SPC-3 PR: Device has been configured for PR passthrough but it's not supported by the backend.\n");
+		target_cmd_err(cmd, "SPC-3 PR: Device has been configured for PR passthrough but it's not supported by the backend.\n");
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 
 	if (sa == PRI_READ_FULL_STATUS) {
-		target_err("SPC-3 PR: PRI_READ_FULL_STATUS is not supported by PR passthrough.\n");
+		target_cmd_err(cmd, "SPC-3 PR: PRI_READ_FULL_STATUS is not supported by PR passthrough.\n");
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 
@@ -4024,7 +4039,7 @@ target_scsi3_emulate_pr_in(struct se_cmd *cmd)
 	 * CONFLICT status.
 	 */
 	if (cmd->se_dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) {
-		target_err("Received PERSISTENT_RESERVE CDB while legacy SPC-2 reservation is held, returning RESERVATION_CONFLICT\n");
+		target_cmd_err(cmd, "Received PERSISTENT_RESERVE CDB while legacy SPC-2 reservation is held, returning RESERVATION_CONFLICT\n");
 		return TCM_RESERVATION_CONFLICT;
 	}
 
@@ -4047,8 +4062,8 @@ target_scsi3_emulate_pr_in(struct se_cmd *cmd)
 		ret = core_scsi3_pri_read_full_status(cmd);
 		break;
 	default:
-		target_err("Unknown PERSISTENT_RESERVE_IN service action: 0x%02x\n",
-			   cmd->t_task_cdb[1] & 0x1f);
+		target_cmd_err(cmd, "Unknown PERSISTENT_RESERVE_IN service action: 0x%02x\n",
+			       cmd->t_task_cdb[1] & 0x1f);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c
index 51b0998b9a9e..95f7c8dffaf2 100644
--- a/drivers/target/target_core_pscsi.c
+++ b/drivers/target/target_core_pscsi.c
@@ -62,9 +62,9 @@ static int pscsi_attach_hba(struct se_hba *hba, u32 host_id)
 
 	hba->hba_ptr = phv;
 
-	target_debug("CORE_HBA[%d] - TCM SCSI HBA Driver %s on Generic Target Core Stack %s\n",
+	target_debug("hba[%d] - TCM SCSI HBA Driver %s on Generic Target Core Stack %s\n",
 		     hba->hba_id, PSCSI_VERSION, TARGET_CORE_VERSION);
-	target_debug("CORE_HBA[%d] - Attached SCSI HBA to Generic\n", hba->hba_id);
+	target_debug("hba[%d] - Attached SCSI HBA to Generic\n", hba->hba_id);
 
 	return 0;
 }
@@ -77,11 +77,11 @@ static void pscsi_detach_hba(struct se_hba *hba)
 	if (scsi_host) {
 		scsi_host_put(scsi_host);
 
-		target_debug("CORE_HBA[%d] - Detached SCSI HBA: %s from Generic Target Core\n",
+		target_debug("hba[%d] - Detached SCSI HBA: %s from Generic Target Core\n",
 			     hba->hba_id,
 			     (scsi_host->hostt->name) ? (scsi_host->hostt->name) : "Unknown");
 	} else
-		target_debug("CORE_HBA[%d] - Detached Virtual SCSI HBA from Generic Target Core\n",
+		target_debug("hba[%d] - Detached Virtual SCSI HBA from Generic Target Core\n",
 			     hba->hba_id);
 
 	kfree(phv);
@@ -102,7 +102,7 @@ static int pscsi_pmode_enable_hba(struct se_hba *hba, unsigned long mode_flag)
 		phv->phv_lld_host = NULL;
 		phv->phv_mode = PHV_VIRTUAL_HOST_ID;
 
-		target_debug("CORE_HBA[%d] - Disabled pSCSI HBA Passthrough %s\n", hba->hba_id,
+		target_debug("hba[%d] - Disabled pSCSI HBA Passthrough %s\n", hba->hba_id,
 			     (sh->hostt->name) ? (sh->hostt->name) : "Unknown");
 
 		scsi_host_put(sh);
@@ -376,7 +376,7 @@ static int pscsi_create_type_disk(struct se_device *dev, struct scsi_device *sd)
 		return ret;
 	}
 
-	target_debug("CORE_PSCSI[%d] - Added TYPE_%s for %d:%d:%d:%llu\n", phv->phv_host_id,
+	target_debug("host[%d] - Added TYPE_%s for %d:%d:%d:%llu\n", phv->phv_host_id,
 		     sd->type == TYPE_DISK ? "DISK" : "ZBC", sh->host_no, sd->channel, sd->id,
 		     sd->lun);
 	return 0;
@@ -405,7 +405,7 @@ static int pscsi_create_type_nondisk(struct se_device *dev, struct scsi_device *
 		scsi_device_put(sd);
 		return ret;
 	}
-	target_debug("CORE_PSCSI[%d] - Added Type: %s for %d:%d:%d:%llu\n", phv->phv_host_id,
+	target_debug("host[%d] - Added Type: %s for %d:%d:%d:%llu\n", phv->phv_host_id,
 		     scsi_device_type(sd->type), sh->host_no, sd->channel, sd->id, sd->lun);
 
 	return 0;
@@ -635,7 +635,7 @@ static void pscsi_complete_cmd(struct se_cmd *cmd, u8 scsi_status,
 
 		buf = sg_virt(&cmd->t_data_sg[0]);
 		if (!buf) {
-			target_err("Unable to get buf for scatterlist\n");
+			target_cmd_err(cmd, "Unable to get buf for scatterlist\n");
 			goto after_mode_select;
 		}
 
@@ -674,7 +674,7 @@ static void pscsi_complete_cmd(struct se_cmd *cmd, u8 scsi_status,
 			if (req_sense[0] == 0xf0 &&	/* valid, fixed format */
 			    req_sense[2] & 0xe0 &&	/* FM, EOM, or ILI */
 			    (req_sense[2] & 0xf) == 0) { /* key==NO_SENSE */
-				target_debug("Tape FM/EOM/ILI status detected. Treat as normal read.\n");
+				target_cmd_debug(cmd, "Tape FM/EOM/ILI status detected. Treat as normal read.\n");
 				cmd->se_cmd_flags |= SCF_TREAT_READ_AS_NORMAL;
 			}
 		}
@@ -717,7 +717,7 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
 		switch (token) {
 		case Opt_scsi_host_id:
 			if (phv->phv_mode == PHV_LLD_SCSI_HOST_NO) {
-				target_err("PSCSI[%d]: Unable to accept scsi_host_id while phv_mode == PHV_LLD_SCSI_HOST_NO\n",
+				target_err("host[%d]: Unable to accept scsi_host_id while phv_mode == PHV_LLD_SCSI_HOST_NO\n",
 					   phv->phv_host_id);
 				ret = -EINVAL;
 				goto out;
@@ -726,7 +726,7 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
 			if (ret)
 				goto out;
 			pdv->pdv_host_id = arg;
-			target_debug("PSCSI[%d]: Referencing SCSI Host ID: %d\n", phv->phv_host_id,
+			target_debug("host[%d]: Referencing SCSI Host ID: %d\n", phv->phv_host_id,
 				     pdv->pdv_host_id);
 			pdv->pdv_flags |= PDF_HAS_VIRT_HOST_ID;
 			break;
@@ -735,7 +735,7 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
 			if (ret)
 				goto out;
 			pdv->pdv_channel_id = arg;
-			target_debug("PSCSI[%d]: Referencing SCSI Channel ID: %d\n",
+			target_debug("host[%d]: Referencing SCSI Channel ID: %d\n",
 				     phv->phv_host_id, pdv->pdv_channel_id);
 			pdv->pdv_flags |= PDF_HAS_CHANNEL_ID;
 			break;
@@ -744,8 +744,8 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
 			if (ret)
 				goto out;
 			pdv->pdv_target_id = arg;
-			target_debug("PSCSI[%d]: Referencing SCSI Target ID: %d\n",
-				     phv->phv_host_id, pdv->pdv_target_id);
+			target_debug("host[%d]: Referencing SCSI Target ID: %d\n", phv->phv_host_id,
+				     pdv->pdv_target_id);
 			pdv->pdv_flags |= PDF_HAS_TARGET_ID;
 			break;
 		case Opt_scsi_lun_id:
@@ -753,7 +753,7 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
 			if (ret)
 				goto out;
 			pdv->pdv_lun_id = arg;
-			target_debug("PSCSI[%d]: Referencing SCSI LUN ID: %d\n", phv->phv_host_id,
+			target_debug("host[%d]: Referencing SCSI LUN ID: %d\n", phv->phv_host_id,
 				     pdv->pdv_lun_id);
 			pdv->pdv_flags |= PDF_HAS_LUN_ID;
 			break;
@@ -818,7 +818,7 @@ pscsi_map_sg(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 
 	BUG_ON(!cmd->data_length);
 
-	target_debug("nr_pages: %d\n", nr_pages);
+	target_cmd_debug(cmd, "nr_pages: %d\n", nr_pages);
 
 	for_each_sg(sgl, sg, sgl_nents, i) {
 		page = sg_page(sg);
@@ -864,7 +864,7 @@ pscsi_map_sg(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 
 				rc = blk_rq_append_bio(req, bio);
 				if (rc) {
-					target_err("failed to append bio\n");
+					target_cmd_err(cmd, "Failed to append bio\n");
 					goto fail;
 				}
 
@@ -878,7 +878,7 @@ pscsi_map_sg(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 	if (bio) {
 		rc = blk_rq_append_bio(req, bio);
 		if (rc) {
-			target_err("failed to append bio\n");
+			target_cmd_err(cmd, "Failed to append bio\n");
 			goto fail;
 		}
 	}
@@ -990,8 +990,8 @@ static enum rq_end_io_ret pscsi_req_done(struct request *req,
 	u8 *cdb = cmd->priv;
 
 	if (scsi_status != SAM_STAT_GOOD) {
-		target_debug("PSCSI Status Byte exception at cmd: %p CDB: 0x%02x Result: 0x%08x\n",
-			     cmd, cdb[0], scmd->result);
+		target_cmd_debug(cmd, "Status Byte exception at cmd: %p CDB: 0x%02x Result: 0x%08x\n",
+				 cmd, cdb[0], scmd->result);
 	}
 
 	pscsi_complete_cmd(cmd, scsi_status, scmd->sense_buffer, valid_data);
@@ -1001,8 +1001,8 @@ static enum rq_end_io_ret pscsi_req_done(struct request *req,
 		target_complete_cmd_with_length(cmd, scsi_status, valid_data);
 		break;
 	default:
-		target_debug("PSCSI Host Byte exception at cmd: %p CDB: 0x%02x Result: 0x%08x\n",
-			     cmd, cdb[0], scmd->result);
+		target_cmd_debug(cmd, "Host Byte exception at cmd: %p CDB: 0x%02x Result: 0x%08x\n",
+				 cmd, cdb[0], scmd->result);
 		target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
 		break;
 	}
diff --git a/drivers/target/target_core_rd.c b/drivers/target/target_core_rd.c
index 3a109a61c83b..c460e9b4c83d 100644
--- a/drivers/target/target_core_rd.c
+++ b/drivers/target/target_core_rd.c
@@ -44,7 +44,7 @@ static int rd_attach_hba(struct se_hba *hba, u32 host_id)
 
 	hba->hba_ptr = rd_host;
 
-	target_debug("CORE_HBA[%d] - TCM Ramdisk HBA Driver %s on Generic Target Core Stack %s\n",
+	target_debug("hba[%d] - TCM Ramdisk HBA Driver %s on Generic Target Core Stack %s\n",
 		     hba->hba_id, RD_HBA_VERSION, TARGET_CORE_VERSION);
 
 	return 0;
@@ -54,8 +54,8 @@ static void rd_detach_hba(struct se_hba *hba)
 {
 	struct rd_host *rd_host = hba->hba_ptr;
 
-	target_debug("CORE_HBA[%d] - Detached Ramdisk HBA: %u from Generic Target Core\n",
-		     hba->hba_id, rd_host->rd_host_id);
+	target_debug("hba[%d] - Detached Ramdisk HBA: %u from Generic Target Core\n", hba->hba_id,
+		     rd_host->rd_host_id);
 
 	kfree(rd_host);
 	hba->hba_ptr = NULL;
@@ -96,7 +96,7 @@ static void rd_release_device_space(struct rd_dev *rd_dev)
 	page_count = rd_release_sgl_table(rd_dev, rd_dev->sg_table_array,
 					  rd_dev->sg_table_count);
 
-	target_debug("CORE_RD[%u] - Released device space for Ramdisk Device ID: %u, pages %u in %u tables total bytes %lu\n",
+	target_debug("host[%u] - Released device space for Ramdisk Device ID: %u, pages %u in %u tables total bytes %lu\n",
 		     rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, page_count,
 		     rd_dev->sg_table_count, (unsigned long)page_count * PAGE_SIZE);
 
@@ -201,7 +201,7 @@ static int rd_build_device_space(struct rd_dev *rd_dev)
 	if (rc)
 		return rc;
 
-	target_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u space of %u pages in %u tables\n",
+	target_debug("host[%u] - Built Ramdisk Device ID: %u space of %u pages in %u tables\n",
 		     rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, rd_dev->rd_page_count,
 		     rd_dev->sg_table_count);
 
@@ -218,7 +218,7 @@ static void rd_release_prot_space(struct rd_dev *rd_dev)
 	page_count = rd_release_sgl_table(rd_dev, rd_dev->sg_prot_array,
 					  rd_dev->sg_prot_count);
 
-	target_debug("CORE_RD[%u] - Released protection space for Ramdisk Device ID: %u, pages %u in %u tables total bytes %lu\n",
+	target_debug("host[%u] - Released protection space for Ramdisk Device ID: %u, pages %u in %u tables total bytes %lu\n",
 		     rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, page_count,
 		     rd_dev->sg_table_count, (unsigned long)page_count * PAGE_SIZE);
 
@@ -256,7 +256,7 @@ static int rd_build_prot_space(struct rd_dev *rd_dev, int prot_length, int block
 	if (rc)
 		return rc;
 
-	target_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u prot space of %u pages in %u tables\n",
+	target_debug("host[%u] - Built Ramdisk Device ID: %u prot space of %u pages in %u tables\n",
 		     rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, total_sg_needed,
 		     rd_dev->sg_prot_count);
 
@@ -299,7 +299,7 @@ static int rd_configure_device(struct se_device *dev)
 
 	rd_dev->rd_dev_id = rd_host->rd_host_dev_id_count++;
 
-	target_debug("CORE_RD[%u] - Added TCM MEMCPY Ramdisk Device ID: %u of %u pages in %u tables, %lu total bytes\n",
+	target_debug("host[%u] - Added TCM MEMCPY Ramdisk Device ID: %u of %u pages in %u tables, %lu total bytes\n",
 		     rd_host->rd_host_id, rd_dev->rd_dev_id, rd_dev->rd_page_count,
 		     rd_dev->sg_table_count, (unsigned long)(rd_dev->rd_page_count * PAGE_SIZE));
 
@@ -437,7 +437,7 @@ rd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 
 	rd_sg = &table->sg_table[rd_page - table->page_start_offset];
 
-	target_debug("RD[%u]: %s LBA: %llu, Size: %u Page: %u, Offset: %u\n", dev->rd_dev_id,
+	target_debug("device[%u]: %s LBA: %llu, Size: %u Page: %u, Offset: %u\n", dev->rd_dev_id,
 		     data_direction == DMA_FROM_DEVICE ? "Read" : "Write", cmd->t_task_lba, rd_size,
 		     rd_page, rd_offset);
 
@@ -458,14 +458,14 @@ rd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 
 		sg_miter_next(&m);
 		if (!(u32)m.length) {
-			target_debug("RD[%u]: invalid sgl %p len %zu\n", dev->rd_dev_id, m.addr,
+			target_debug("device[%u]: invalid sgl %p len %zu\n", dev->rd_dev_id, m.addr,
 				     m.length);
 			sg_miter_stop(&m);
 			return TCM_INCORRECT_AMOUNT_OF_DATA;
 		}
 		len = min((u32)m.length, src_len);
 		if (len > rd_size) {
-			target_debug("RD[%u]: size underrun page %d offset %d size %d\n",
+			target_debug("device[%u]: size underrun page %d offset %d size %d\n",
 				     dev->rd_dev_id, rd_page, rd_offset, rd_size);
 			len = rd_size;
 		}
diff --git a/drivers/target/target_core_sbc.c b/drivers/target/target_core_sbc.c
index 22b705bc7f91..caccb505fef2 100644
--- a/drivers/target/target_core_sbc.c
+++ b/drivers/target/target_core_sbc.c
@@ -282,12 +282,12 @@ sbc_setup_write_same(struct se_cmd *cmd, unsigned char flags,
 	sense_reason_t ret;
 
 	if ((flags & 0x04) || (flags & 0x02)) {
-		target_err("WRITE_SAME PBDATA and LBDATA bits not supported for Block Discard Emulation\n");
+		target_cmd_err(cmd, "WRITE_SAME PBDATA and LBDATA bits not supported for Block Discard Emulation\n");
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 	if (sectors > cmd->se_dev->dev_attrib.max_write_same_len) {
-		target_warn("WRITE_SAME sectors: %u exceeds max_write_same_len: %u\n", sectors,
-			    cmd->se_dev->dev_attrib.max_write_same_len);
+		target_cmd_warn(cmd, "WRITE_SAME sectors: %u exceeds max_write_same_len: %u\n",
+				sectors, cmd->se_dev->dev_attrib.max_write_same_len);
 		return TCM_INVALID_CDB_FIELD;
 	}
 	/*
@@ -295,19 +295,19 @@ sbc_setup_write_same(struct se_cmd *cmd, unsigned char flags,
 	 */
 	if (((cmd->t_task_lba + sectors) < cmd->t_task_lba) ||
 	    ((cmd->t_task_lba + sectors) > end_lba)) {
-		target_err("WRITE_SAME exceeds last lba %llu (lba %llu, sectors %u)\n",
-			   (unsigned long long)end_lba, cmd->t_task_lba, sectors);
+		target_cmd_err(cmd, "WRITE_SAME exceeds last lba %llu (lba %llu, sectors %u)\n",
+			       (unsigned long long)end_lba, cmd->t_task_lba, sectors);
 		return TCM_ADDRESS_OUT_OF_RANGE;
 	}
 
 	/* We always have ANC_SUP == 0 so setting ANCHOR is always an error */
 	if (flags & 0x10) {
-		target_warn("WRITE SAME with ANCHOR not supported\n");
+		target_cmd_warn(cmd, "WRITE SAME with ANCHOR not supported\n");
 		return TCM_INVALID_CDB_FIELD;
 	}
 
 	if (flags & 0x01) {
-		target_warn("WRITE SAME with NDOB not supported\n");
+		target_cmd_warn(cmd, "WRITE SAME with NDOB not supported\n");
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -320,7 +320,7 @@ sbc_setup_write_same(struct se_cmd *cmd, unsigned char flags,
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 
 		if (!dev->dev_attrib.emulate_tpws) {
-			target_err("Got WRITE_SAME w/ UNMAP=1, but backend device has emulate_tpws disabled\n");
+			target_cmd_err(cmd, "Got WRITE_SAME w/ UNMAP=1, but backend device has emulate_tpws disabled\n");
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		}
 		cmd->execute_cmd = sbc_execute_write_same_unmap;
@@ -473,8 +473,8 @@ static sense_reason_t compare_and_write_callback(struct se_cmd *cmd, bool succes
 	 * been failed with a non-zero SCSI status.
 	 */
 	if (cmd->scsi_status) {
-		target_debug("compare_and_write_callback: non zero scsi_status: 0x%02x\n",
-			     cmd->scsi_status);
+		target_cmd_debug(cmd, "%s: non zero scsi_status: 0x%02x\n", __func__,
+				 cmd->scsi_status);
 		*post_ret = 1;
 		if (cmd->scsi_status == SAM_STAT_CHECK_CONDITION)
 			ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
@@ -495,7 +495,7 @@ static sense_reason_t compare_and_write_callback(struct se_cmd *cmd, bool succes
 		goto out;
 
 	if (sg_alloc_table(&write_tbl, cmd->t_data_nents, GFP_KERNEL) < 0) {
-		target_err("Unable to allocate compare_and_write sg\n");
+		target_cmd_err(cmd, "Unable to allocate compare_and_write sg\n");
 		ret = TCM_OUT_OF_RESOURCES;
 		goto out;
 	}
@@ -624,7 +624,7 @@ sbc_set_prot_op_checks(u8 protect, bool fabric_prot, enum target_prot_type prot_
 			cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
 			break;
 		default:
-			target_err("Unsupported protect field %d\n", protect);
+			target_cmd_err(cmd, "Unsupported protect field %d\n", protect);
 			return -EINVAL;
 		}
 	} else {
@@ -650,7 +650,7 @@ sbc_set_prot_op_checks(u8 protect, bool fabric_prot, enum target_prot_type prot_
 			cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
 			break;
 		default:
-			target_err("Unsupported protect field %d\n", protect);
+			target_cmd_err(cmd, "Unsupported protect field %d\n", protect);
 			return -EINVAL;
 		}
 	}
@@ -669,7 +669,7 @@ sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char protect,
 	if (!cmd->t_prot_sg || !cmd->t_prot_nents) {
 		if (unlikely(protect &&
 		    !dev->dev_attrib.pi_prot_type && !cmd->se_sess->sess_prot_type)) {
-			target_err("CDB contains protect bit, but device + fabric does not advertise PROTECT=1 feature bit\n");
+			target_cmd_err(cmd, "CDB contains protect bit, but device + fabric does not advertise PROTECT=1 feature bit\n");
 			return TCM_INVALID_CDB_FIELD;
 		}
 		if (cmd->prot_pto)
@@ -707,8 +707,8 @@ sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char protect,
 			return TCM_NO_SENSE;
 		fallthrough;
 	default:
-		target_err("Unable to determine pi_prot_type for CDB: 0x%02x PROTECT: 0x%02x\n",
-			   cmd->t_task_cdb[0], protect);
+		target_cmd_err(cmd, "Unable to determine pi_prot_type for CDB: 0x%02x PROTECT: 0x%02x\n",
+			       cmd->t_task_cdb[0], protect);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -727,9 +727,9 @@ sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char protect,
 	if (protect)
 		cmd->data_length = sectors * dev->dev_attrib.block_size;
 
-	target_debug("%s: prot_type=%d, data_length=%d, prot_length=%d prot_op=%d prot_checks=%d\n",
-		     __func__, cmd->prot_type, cmd->data_length, cmd->prot_length, cmd->prot_op,
-		     cmd->prot_checks);
+	target_cmd_debug(cmd, "%s: prot_type=%d, data_length=%d, prot_length=%d prot_op=%d prot_checks=%d\n",
+			 __func__, cmd->prot_type, cmd->data_length, cmd->prot_length, cmd->prot_op,
+			 cmd->prot_checks);
 
 	return TCM_NO_SENSE;
 }
@@ -740,15 +740,15 @@ sbc_check_dpofua(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb)
 	if (cdb[1] & 0x10) {
 		/* see explanation in spc_emulate_modesense */
 		if (!target_check_fua(dev)) {
-			target_err("Got CDB: 0x%02x with DPO bit set, but device does not advertise support for DPO\n",
-				   cdb[0]);
+			target_cmd_err(cmd, "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 (!target_check_fua(dev)) {
-			target_err("Got CDB: 0x%02x with FUA bit set, but device does not advertise support for FUA write\n",
-				   cdb[0]);
+			target_cmd_err(cmd, "Got CDB: 0x%02x with FUA bit set, but device does not advertise support for FUA write\n",
+				       cdb[0]);
 			return -EINVAL;
 		}
 		cmd->se_cmd_flags |= SCF_FUA;
@@ -874,7 +874,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 		case WRITE_SAME_32:
 			sectors = transport_get_sectors_32(cdb);
 			if (!sectors) {
-				target_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
+				target_cmd_err(cmd, "WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
 				return TCM_INVALID_CDB_FIELD;
 			}
 
@@ -886,18 +886,18 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 				return ret;
 			break;
 		default:
-			target_err("VARIABLE_LENGTH_CMD service action 0x%04x not supported\n",
-				   service_action);
+			target_cmd_err(cmd, "VARIABLE_LENGTH_CMD service action 0x%04x not supported\n",
+				       service_action);
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		}
 		break;
 	}
 	case COMPARE_AND_WRITE:
 		if (!dev->dev_attrib.emulate_caw) {
-			target_err_ratelimited("se_device %s/%s (vpd_unit_serial %s) reject COMPARE_AND_WRITE\n",
-					       dev->se_hba->backend->ops->name,
-					       config_item_name(&dev->dev_group.cg_item),
-					       dev->t10_wwn.unit_serial);
+			target_cmd_err_ratelimited(cmd, "se_device %s/%s (vpd_unit_serial %s) reject COMPARE_AND_WRITE\n",
+						   dev->se_hba->backend->ops->name,
+						   config_item_name(&dev->dev_group.cg_item),
+						   dev->t10_wwn.unit_serial);
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		}
 		sectors = cdb[13];
@@ -905,7 +905,8 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 		 * Currently enforce COMPARE_AND_WRITE for a single sector
 		 */
 		if (sectors > 1) {
-			target_err("COMPARE_AND_WRITE contains NoLB: %u greater than 1\n", sectors);
+			target_cmd_err(cmd, "COMPARE_AND_WRITE contains NoLB: %u greater than 1\n",
+				       sectors);
 			return TCM_INVALID_CDB_FIELD;
 		}
 		if (sbc_check_dpofua(dev, cmd, cdb))
@@ -935,7 +936,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 			cmd->execute_cmd = target_emulate_report_referrals;
 			break;
 		default:
-			target_err("Unsupported SA: 0x%02x\n", cmd->t_task_cdb[1] & 0x1f);
+			target_cmd_err(cmd, "Unsupported SA: 0x%02x\n", cmd->t_task_cdb[1] & 0x1f);
 			return TCM_INVALID_CDB_FIELD;
 		}
 		size = get_unaligned_be32(&cdb[10]);
@@ -961,7 +962,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 
 		if (!dev->dev_attrib.emulate_tpu) {
-			target_err("Got UNMAP, but backend device has emulate_tpu disabled\n");
+			target_cmd_err(cmd, "Got UNMAP, but backend device has emulate_tpu disabled\n");
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		}
 		size = get_unaligned_be16(&cdb[7]);
@@ -970,7 +971,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 	case WRITE_SAME_16:
 		sectors = transport_get_sectors_16(cdb);
 		if (!sectors) {
-			target_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
+			target_cmd_err(cmd, "WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
 			return TCM_INVALID_CDB_FIELD;
 		}
 
@@ -984,7 +985,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 	case WRITE_SAME:
 		sectors = transport_get_sectors_10(cdb);
 		if (!sectors) {
-			target_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
+			target_cmd_err(cmd, "WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
 			return TCM_INVALID_CDB_FIELD;
 		}
 
@@ -1043,8 +1044,8 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 		end_lba = dev->transport->get_blocks(dev) + 1;
 		if (((cmd->t_task_lba + sectors) < cmd->t_task_lba) ||
 		    ((cmd->t_task_lba + sectors) > end_lba)) {
-			target_err("cmd exceeds last lba %llu (lba %llu, sectors %u)\n", end_lba,
-				   cmd->t_task_lba, sectors);
+			target_cmd_err(cmd, "cmd exceeds last lba %llu (lba %llu, sectors %u)\n",
+				       end_lba, cmd->t_task_lba, sectors);
 			return TCM_ADDRESS_OUT_OF_RANGE;
 		}
 
@@ -1084,7 +1085,8 @@ sbc_execute_unmap(struct se_cmd *cmd)
 	}
 
 	if (cmd->data_length < 8) {
-		target_warn("UNMAP parameter list length %u too small\n", cmd->data_length);
+		target_cmd_warn(cmd, "UNMAP parameter list length %u too small\n",
+				cmd->data_length);
 		return TCM_PARAMETER_LIST_LENGTH_ERROR;
 	}
 
@@ -1097,8 +1099,8 @@ sbc_execute_unmap(struct se_cmd *cmd)
 
 	size = cmd->data_length - 8;
 	if (bd_dl > size)
-		target_warn("UNMAP parameter list length %u too small, ignoring bd_dl %u\n",
-			    cmd->data_length, bd_dl);
+		target_cmd_warn(cmd, "UNMAP parameter list length %u too small, ignoring bd_dl %u\n",
+				cmd->data_length, bd_dl);
 	else
 		size = bd_dl;
 
@@ -1109,14 +1111,14 @@ sbc_execute_unmap(struct se_cmd *cmd)
 
 	/* First UNMAP block descriptor starts at 8 byte offset */
 	ptr = &buf[8];
-	target_debug("UNMAP: Sub: %s Using dl: %u bd_dl: %u size: %u ptr: %p\n",
-		     dev->transport->name, dl, bd_dl, size, ptr);
+	target_cmd_debug(cmd, "UNMAP: Sub: %s Using dl: %u bd_dl: %u size: %u ptr: %p\n",
+			 dev->transport->name, dl, bd_dl, size, ptr);
 
 	while (size >= 16) {
 		lba = get_unaligned_be64(&ptr[0]);
 		range = get_unaligned_be32(&ptr[8]);
-		target_debug("UNMAP: Using lba: %llu and range: %u\n", (unsigned long long)lba,
-			     range);
+		target_cmd_debug(cmd, "UNMAP: Using lba: %llu and range: %u\n",
+				 (unsigned long long)lba, range);
 
 		if (range > dev->dev_attrib.max_unmap_lba_count) {
 			ret = TCM_INVALID_PARAMETER_LIST;
@@ -1198,10 +1200,10 @@ sbc_dif_generate(struct se_cmd *cmd)
 				sdt->ref_tag = cpu_to_be32(sector & 0xffffffff);
 			sdt->app_tag = 0;
 
-			target_debug("DIF %s INSERT sector: %llu guard_tag: 0x%04x app_tag: 0x%04x ref_tag: %u\n",
-				     (cmd->data_direction == DMA_TO_DEVICE) ? "WRITE" : "READ",
-				     (unsigned long long)sector, sdt->guard_tag, sdt->app_tag,
-				     be32_to_cpu(sdt->ref_tag));
+			target_cmd_debug(cmd, "DIF %s INSERT sector: %llu guard_tag: 0x%04x app_tag: 0x%04x ref_tag: %u\n",
+					 (cmd->data_direction == DMA_TO_DEVICE) ? "WRITE" : "READ",
+					 (unsigned long long)sector, sdt->guard_tag, sdt->app_tag,
+					 be32_to_cpu(sdt->ref_tag));
 
 			sector++;
 		}
@@ -1223,9 +1225,9 @@ sbc_dif_v1_verify(struct se_cmd *cmd, struct t10_pi_tuple *sdt,
 	csum = cpu_to_be16(crc);
 
 	if (sdt->guard_tag != csum) {
-		target_err("DIFv1 checksum failed on sector %llu guard tag 0x%04x csum 0x%04x\n",
-			   (unsigned long long)sector, be16_to_cpu(sdt->guard_tag),
-			   be16_to_cpu(csum));
+		target_cmd_err(cmd, "DIFv1 checksum failed on sector %llu guard tag 0x%04x csum 0x%04x\n",
+			       (unsigned long long)sector, be16_to_cpu(sdt->guard_tag),
+			       be16_to_cpu(csum));
 		return TCM_LOGICAL_BLOCK_GUARD_CHECK_FAILED;
 	}
 
@@ -1235,16 +1237,16 @@ sbc_dif_v1_verify(struct se_cmd *cmd, struct t10_pi_tuple *sdt,
 
 	if (cmd->prot_type == TARGET_DIF_TYPE1_PROT &&
 	    be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
-		target_err("DIFv1 Type 1 reference failed on sector: %llu tag: 0x%08x sector MSB: 0x%08x\n",
-			   (unsigned long long)sector, be32_to_cpu(sdt->ref_tag),
-			   (u32)(sector & 0xffffffff));
+		target_cmd_err(cmd, "DIFv1 Type 1 reference failed on sector: %llu tag: 0x%08x sector MSB: 0x%08x\n",
+			       (unsigned long long)sector, be32_to_cpu(sdt->ref_tag),
+			       (u32)(sector & 0xffffffff));
 		return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED;
 	}
 
 	if (cmd->prot_type == TARGET_DIF_TYPE2_PROT &&
 	    be32_to_cpu(sdt->ref_tag) != ei_lba) {
-		target_err("DIFv1 Type 2 reference failed on sector: %llu tag: 0x%08x ei_lba: 0x%08x\n",
-			   (unsigned long long)sector, be32_to_cpu(sdt->ref_tag), ei_lba);
+		target_cmd_err(cmd, "DIFv1 Type 2 reference failed on sector: %llu tag: 0x%08x ei_lba: 0x%08x\n",
+			       (unsigned long long)sector, be32_to_cpu(sdt->ref_tag), ei_lba);
 		return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED;
 	}
 
@@ -1333,9 +1335,9 @@ sbc_dif_verify(struct se_cmd *cmd, sector_t start, unsigned int sectors,
 
 			sdt = paddr + i;
 
-			target_debug("DIF READ 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));
+			target_cmd_debug(cmd, "DIF READ 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));
 
 			if (sdt->app_tag == T10_PI_APP_ESCAPE) {
 				dsg_off += block_size;
diff --git a/drivers/target/target_core_spc.c b/drivers/target/target_core_spc.c
index ce59b5f02ef0..2d506e672bff 100644
--- a/drivers/target/target_core_spc.c
+++ b/drivers/target/target_core_spc.c
@@ -744,7 +744,7 @@ spc_emulate_inquiry(struct se_cmd *cmd)
 
 	buf = kzalloc(SE_INQUIRY_BUF, GFP_KERNEL);
 	if (!buf) {
-		target_err("Unable to allocate response buffer for INQUIRY\n");
+		target_cmd_err(cmd, "Unable to allocate response buffer for INQUIRY\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 
@@ -752,7 +752,7 @@ spc_emulate_inquiry(struct se_cmd *cmd)
 
 	if (!(cdb[1] & 0x1)) {
 		if (cdb[2]) {
-			target_err("INQUIRY with EVPD==0 but PAGE CODE=%02x\n", cdb[2]);
+			target_cmd_err(cmd, "INQUIRY with EVPD==0 but PAGE CODE=%02x\n", cdb[2]);
 			ret = TCM_INVALID_CDB_FIELD;
 			goto out;
 		}
@@ -771,7 +771,7 @@ spc_emulate_inquiry(struct se_cmd *cmd)
 		}
 	}
 
-	target_debug("Unknown VPD Code: 0x%02x\n", cdb[2]);
+	target_cmd_debug(cmd, "Unknown VPD Code: 0x%02x\n", cdb[2]);
 	ret = TCM_INVALID_CDB_FIELD;
 
 out:
@@ -1086,7 +1086,7 @@ static sense_reason_t spc_emulate_modesense(struct se_cmd *cmd)
 
 	if (page == 0x3f) {
 		if (subpage != 0x00 && subpage != 0xff) {
-			target_warn("MODE_SENSE: Invalid subpage code: 0x%02x\n", subpage);
+			target_cmd_warn(cmd, "MODE_SENSE: Invalid subpage code: 0x%02x\n", subpage);
 			return TCM_INVALID_CDB_FIELD;
 		}
 
@@ -1120,8 +1120,8 @@ static sense_reason_t spc_emulate_modesense(struct se_cmd *cmd)
 	 *  - obsolete page 03h "format parameters" (checked by Solaris)
 	 */
 	if (page != 0x03)
-		target_err("MODE SENSE: unimplemented page/subpage: 0x%02x/0x%02x\n", page,
-			   subpage);
+		target_cmd_debug(cmd, "MODE SENSE: unimplemented page/subpage: 0x%02x/0x%02x\n",
+				 page, subpage);
 
 	return TCM_UNKNOWN_MODE_PAGE;
 
@@ -1213,7 +1213,7 @@ static sense_reason_t spc_emulate_request_sense(struct se_cmd *cmd)
 	memset(buf, 0, SE_SENSE_BUF);
 
 	if (cdb[1] & 0x01) {
-		target_err("REQUEST_SENSE description emulation not supported\n");
+		target_cmd_err(cmd, "REQUEST_SENSE description emulation not supported\n");
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -2113,7 +2113,6 @@ static sense_reason_t
 spc_rsoc_get_descr(struct se_cmd *cmd, struct target_opcode_descriptor **opcode)
 {
 	struct target_opcode_descriptor *descr;
-	struct se_session *sess = cmd->se_sess;
 	unsigned char *cdb = cmd->t_task_cdb;
 	u8 opts = cdb[2] & 0x3;
 	u8 requested_opcode;
@@ -2125,9 +2124,8 @@ spc_rsoc_get_descr(struct se_cmd *cmd, struct target_opcode_descriptor **opcode)
 	*opcode = NULL;
 
 	if (opts > 3) {
-		target_debug("TARGET_CORE[%s]: Invalid REPORT SUPPORTED OPERATION CODES with unsupported REPORTING OPTIONS %#x for 0x%08llx from %s\n",
-			     cmd->se_tfo->fabric_name, opts, cmd->se_lun->unpacked_lun,
-			     sess->se_node_acl->initiatorname);
+		target_cmd_debug(cmd, "Invalid REPORT SUPPORTED OPERATION CODES with unsupported REPORTING OPTIONS %#x for 0x%08llx\n",
+				 opts, cmd->se_lun->unpacked_lun);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
diff --git a/drivers/target/target_core_tmr.c b/drivers/target/target_core_tmr.c
index db3b0467105d..867a2d604b2f 100644
--- a/drivers/target/target_core_tmr.c
+++ b/drivers/target/target_core_tmr.c
@@ -89,8 +89,8 @@ static bool __target_check_io_state(struct se_cmd *se_cmd,
 	 */
 	spin_lock(&se_cmd->t_state_lock);
 	if (se_cmd->transport_state & (CMD_T_COMPLETE | CMD_T_FABRIC_STOP)) {
-		target_debug("Attempted to abort io tag: %llu already complete or fabric stop, skipping\n",
-			     se_cmd->tag);
+		target_cmd_debug(se_cmd, "Attempted to abort io tag: %llu already complete or fabric stop, skipping\n",
+				 se_cmd->tag);
 		spin_unlock(&se_cmd->t_state_lock);
 		return false;
 	}
@@ -136,8 +136,8 @@ void core_tmr_abort_task(
 			if (tmr->ref_task_tag != ref_tag)
 				continue;
 
-			target_err("ABORT_TASK: Found referenced %s task_tag: %llu\n",
-				   se_cmd->se_tfo->fabric_name, ref_tag);
+			target_cmd_err(se_cmd, "ABORT_TASK: Found referenced %s task_tag: %llu\n",
+				       se_cmd->se_tfo->fabric_name, ref_tag);
 
 			spin_lock(&se_sess->sess_cmd_lock);
 			rc = __target_check_io_state(se_cmd, se_sess, 0);
@@ -237,9 +237,9 @@ static void core_tmr_drain_tmr_list(
 		list_del_init(&tmr_p->tmr_list);
 		cmd = tmr_p->task_cmd;
 
-		target_debug("LUN_RESET: %s releasing TMR %p Function: 0x%02x, Response: 0x%02x, t_state: %d\n",
-			     (preempt_and_abort_list) ? "Preempt" : "", tmr_p, tmr_p->function,
-			     tmr_p->response, cmd->t_state);
+		target_cmd_debug(cmd, "LUN_RESET: %s releasing TMR %p Function: 0x%02x, Response: 0x%02x, t_state: %d\n",
+				 (preempt_and_abort_list) ? "Preempt" : "", tmr_p, tmr_p->function,
+				 tmr_p->response, cmd->t_state);
 
 		target_put_cmd_and_wait(cmd);
 	}
@@ -344,8 +344,9 @@ static void core_tmr_drain_state_list(
 		list_del_init(&cmd->state_list);
 
 		target_show_cmd("LUN_RESET: ", cmd);
-		target_debug("LUN_RESET: ITT[0x%08llx] - %s pr_res_key: 0x%016Lx\n", cmd->tag,
-			     (preempt_and_abort_list) ? "preempt" : "", cmd->pr_res_key);
+		target_cmd_debug(cmd, "LUN_RESET: ITT[0x%08llx] - %s pr_res_key: 0x%016Lx\n",
+				 cmd->tag, (preempt_and_abort_list) ? "preempt" : "",
+				 cmd->pr_res_key);
 
 		target_put_cmd_and_wait(cmd);
 	}
diff --git a/drivers/target/target_core_tpg.c b/drivers/target/target_core_tpg.c
index 3f0b53032aeb..633f64b36aaf 100644
--- a/drivers/target/target_core_tpg.c
+++ b/drivers/target/target_core_tpg.c
@@ -136,9 +136,8 @@ void core_tpg_add_node_to_devs(
 				lun_access_ro = false;
 		}
 
-		target_debug("TARGET_CORE[%s]->TPG[%u]_LUN[%llu] - Adding %s access for LUN in Demo Mode\n",
-			     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
-			     lun->unpacked_lun, lun_access_ro ? "READ-ONLY" : "READ-WRITE");
+		target_lun_debug(lun, "Adding %s access for LUN in Demo Mode\n",
+				 lun_access_ro ? "READ-ONLY" : "READ-WRITE");
 
 		core_enable_device_list_for_node(lun, NULL, lun->unpacked_lun,
 						 lun_access_ro, acl, tpg);
@@ -544,7 +543,7 @@ int core_tpg_register(
 		}
 	}
 
-	target_debug("TARGET_CORE[%s]: Allocated portal_group for endpoint: %s, Proto: %d, Portal Tag: %u\n",
+	target_debug("[%s]: Allocated portal_group for endpoint: %s, Proto: %d, Portal Tag: %u\n",
 		     se_tpg->se_tpg_tfo->fabric_name,
 		     se_tpg->se_tpg_tfo->tpg_get_wwn(se_tpg) ?
 		     se_tpg->se_tpg_tfo->tpg_get_wwn(se_tpg) : NULL,
@@ -560,7 +559,7 @@ int core_tpg_deregister(struct se_portal_group *se_tpg)
 	struct se_node_acl *nacl, *nacl_tmp;
 	LIST_HEAD(node_list);
 
-	target_debug("TARGET_CORE[%s]: Deallocating portal_group for endpoint: %s, Proto: %d, Portal Tag: %u\n",
+	target_debug("[%s]: Deallocating portal_group for endpoint: %s, Proto: %d, Portal Tag: %u\n",
 		     tfo->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));
 
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index 13fddd94a792..6326eb520fc7 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -428,8 +428,7 @@ void __transport_register_session(
 	}
 	list_add_tail(&se_sess->sess_list, &se_tpg->tpg_sess_list);
 
-	target_debug("TARGET_CORE[%s]: Registered fabric_sess_ptr: %p\n",
-		     se_tpg->se_tpg_tfo->fabric_name, se_sess->fabric_sess_ptr);
+	target_sess_debug(se_sess, "Registered fabric_sess_ptr: %p\n", se_sess->fabric_sess_ptr);
 }
 EXPORT_SYMBOL(__transport_register_session);
 
@@ -664,8 +663,7 @@ void transport_deregister_session(struct se_session *se_sess)
 	 */
 	target_for_each_device(target_release_res, se_sess);
 
-	target_debug("TARGET_CORE[%s]: Deregistered fabric_sess\n",
-		     se_tpg->se_tpg_tfo->fabric_name);
+	target_debug("[%s]: Deregistered fabric_sess\n", se_tpg->se_tpg_tfo->fabric_name);
 	/*
 	 * If last kref is dropping now for an explicit NodeACL, awake sleeping
 	 * ->acl_free_comp caller to wakeup configfs se_node_acl->acl_group
@@ -734,7 +732,8 @@ static int transport_cmd_check_stop_to_fabric(struct se_cmd *cmd)
 	 * this command for frontend exceptions.
 	 */
 	if (cmd->transport_state & CMD_T_STOP) {
-		target_debug("%s:%d CMD_T_STOP for ITT: 0x%08llx\n", __func__, __LINE__, cmd->tag);
+		target_cmd_debug(cmd, "%s:%d CMD_T_STOP for ITT: 0x%08llx\n", __func__, __LINE__,
+				 cmd->tag);
 
 		spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
@@ -798,8 +797,8 @@ static unsigned char *transport_get_sense_buffer(struct se_cmd *cmd)
 
 	cmd->scsi_sense_length = TRANSPORT_SENSE_BUFFER;
 
-	target_debug("HBA_[%u]_PLUG[%s]: Requesting sense for SAM STATUS: 0x%02x\n",
-		     dev->se_hba->hba_id, dev->transport->name, cmd->scsi_status);
+	target_cmd_debug(cmd, "hba[%u], transport[%s] - Requesting sense for SAM STATUS: 0x%02x\n",
+			 dev->se_hba->hba_id, dev->transport->name, cmd->scsi_status);
 	return cmd->sense_buffer;
 }
 
@@ -827,13 +826,13 @@ static void target_handle_abort(struct se_cmd *cmd)
 	bool ack_kref = cmd->se_cmd_flags & SCF_ACK_KREF;
 	int ret;
 
-	target_debug("tag %#llx: send_abort_response = %d\n", cmd->tag, tas);
+	target_cmd_debug(cmd, "tag %#llx: send_abort_response = %d\n", cmd->tag, tas);
 
 	if (tas) {
 		if (!(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) {
 			cmd->scsi_status = SAM_STAT_TASK_ABORTED;
-			target_debug("Setting SAM_STAT_TASK_ABORTED status for CDB: 0x%02x, ITT: 0x%08llx\n",
-				     cmd->t_task_cdb[0], cmd->tag);
+			target_cmd_debug(cmd, "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);
 			ret = cmd->se_tfo->queue_status(cmd);
 			if (ret) {
@@ -1006,11 +1005,11 @@ void target_qf_do_work(struct work_struct *work)
 		list_del(&cmd->se_qf_node);
 		atomic_dec_mb(&dev->dev_qf_count);
 
-		target_debug("Processing %s cmd: %p QUEUE_FULL in work queue context: %s\n",
-			     cmd->se_tfo->fabric_name, cmd,
-			     (cmd->t_state == TRANSPORT_COMPLETE_QF_OK) ? "COMPLETE_OK" :
-			     (cmd->t_state == TRANSPORT_COMPLETE_QF_WP) ? "WRITE_PENDING"
-			     : "UNKNOWN");
+		target_cmd_debug(cmd, "Processing %s cmd: %p QUEUE_FULL in work queue context: %s\n",
+				 cmd->se_tfo->fabric_name, cmd,
+				 (cmd->t_state == TRANSPORT_COMPLETE_QF_OK) ? "COMPLETE_OK" :
+				 (cmd->t_state == TRANSPORT_COMPLETE_QF_WP) ? "WRITE_PENDING" :
+				 "UNKNOWN");
 
 		if (cmd->t_state == TRANSPORT_COMPLETE_QF_WP)
 			transport_write_pending_qf(cmd);
@@ -1382,9 +1381,8 @@ target_cmd_size_check(struct se_cmd *cmd, unsigned int size)
 	if (cmd->unknown_data_length) {
 		cmd->data_length = size;
 	} else if (size != cmd->data_length) {
-		target_warn_ratelimited("TARGET_CORE[%s]: Expected Transfer Length: %u does not match SCSI CDB Length: %u for SAM Opcode: 0x%02x\n",
-					cmd->se_tfo->fabric_name, cmd->data_length, size,
-					cmd->t_task_cdb[0]);
+		target_cmd_warn_ratelimited(cmd, "Expected Transfer Length: %u does not match SCSI CDB Length: %u for SAM Opcode: 0x%02x\n",
+					    cmd->data_length, size, cmd->t_task_cdb[0]);
 		/*
 		 * For READ command for the overflow case keep the existing
 		 * fabric provided ->data_length. Otherwise for the underflow
@@ -1408,7 +1406,7 @@ target_cmd_size_check(struct se_cmd *cmd, unsigned int size)
 
 		if (cmd->data_direction == DMA_TO_DEVICE) {
 			if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) {
-				target_err_ratelimited("Rejecting underflow/overflow for WRITE data CDB\n");
+				target_cmd_err_ratelimited(cmd, "Rejecting underflow/overflow for WRITE data CDB\n");
 				return TCM_INVALID_FIELD_IN_COMMAND_IU;
 			}
 			/*
@@ -1418,7 +1416,7 @@ target_cmd_size_check(struct se_cmd *cmd, unsigned int size)
 			 * is introduced tree-wide.
 			 */
 			if (size > cmd->data_length) {
-				target_err_ratelimited("Rejecting overflow for WRITE control CDB\n");
+				target_cmd_err_ratelimited(cmd, "Rejecting overflow for WRITE control CDB\n");
 				return TCM_INVALID_CDB_FIELD;
 			}
 		}
@@ -1481,7 +1479,7 @@ transport_check_alloc_task_attr(struct se_cmd *cmd)
 		return 0;
 
 	if (cmd->sam_task_attr == TCM_ACA_TAG) {
-		target_debug("SAM Task Attribute ACA emulation is not supported\n");
+		target_cmd_debug(cmd, "SAM Task Attribute ACA emulation is not supported\n");
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -1498,8 +1496,8 @@ target_cmd_init_cdb(struct se_cmd *cmd, unsigned char *cdb, gfp_t gfp)
 	 * for VARIABLE_LENGTH_CMD
 	 */
 	if (scsi_command_size(cdb) > SCSI_MAX_VARLEN_CDB_SIZE) {
-		target_err("Received SCSI CDB with command_size: %d that exceeds SCSI_MAX_VARLEN_CDB_SIZE: %d\n",
-			   scsi_command_size(cdb), SCSI_MAX_VARLEN_CDB_SIZE);
+		target_cmd_err(cmd, "Received SCSI CDB with command_size: %d that exceeds SCSI_MAX_VARLEN_CDB_SIZE: %d\n",
+			       scsi_command_size(cdb), SCSI_MAX_VARLEN_CDB_SIZE);
 		ret = TCM_INVALID_CDB_FIELD;
 		goto err;
 	}
@@ -1511,9 +1509,9 @@ target_cmd_init_cdb(struct se_cmd *cmd, unsigned char *cdb, gfp_t gfp)
 	if (scsi_command_size(cdb) > sizeof(cmd->__t_task_cdb)) {
 		cmd->t_task_cdb = kzalloc(scsi_command_size(cdb), gfp);
 		if (!cmd->t_task_cdb) {
-			target_err("Unable to allocate cmd->t_task_cdb %u > sizeof(cmd->__t_task_cdb): %lu ops\n",
-				   scsi_command_size(cdb),
-				   (unsigned long)sizeof(cmd->__t_task_cdb));
+			target_cmd_err(cmd, "Unable to allocate cmd->t_task_cdb %u > sizeof(cmd->__t_task_cdb): %lu ops\n",
+				       scsi_command_size(cdb),
+				       (unsigned long)sizeof(cmd->__t_task_cdb));
 			ret = TCM_OUT_OF_RESOURCES;
 			goto err;
 		}
@@ -1545,10 +1543,10 @@ target_cmd_parse_cdb(struct se_cmd *cmd)
 
 	ret = dev->transport->parse_cdb(cmd);
 	if (ret == TCM_UNSUPPORTED_SCSI_OPCODE)
-		target_debug_ratelimited("%s/%s: Unsupported SCSI Opcode 0x%02x, sending CHECK_CONDITION.\n",
-					 cmd->se_tfo->fabric_name,
-					 cmd->se_sess->se_node_acl->initiatorname,
-					 cmd->t_task_cdb[0]);
+		target_cmd_debug_ratelimited(cmd, "%s/%s: Unsupported SCSI Opcode 0x%02x, sending CHECK_CONDITION.\n",
+					     cmd->se_tfo->fabric_name,
+					     cmd->se_sess->se_node_acl->initiatorname,
+					     cmd->t_task_cdb[0]);
 	if (ret)
 		return ret;
 
@@ -1636,7 +1634,7 @@ transport_generic_map_mem_to_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
 	 * passes for the original expected data transfer length.
 	 */
 	if (cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {
-		target_warn("Rejecting SCSI DATA overflow for fabric using SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC\n");
+		target_cmd_warn(cmd, "Rejecting SCSI DATA overflow for fabric using SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC\n");
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -2093,8 +2091,8 @@ void transport_generic_request_failure(struct se_cmd *cmd,
 
 		goto queue_status;
 	default:
-		target_err("Unknown transport error for CDB 0x%02x: %d\n", cmd->t_task_cdb[0],
-			   sense_reason);
+		target_cmd_err(cmd, "Unknown transport error for CDB 0x%02x: %d\n",
+			       cmd->t_task_cdb[0], sense_reason);
 		sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
 		break;
 	}
@@ -2210,12 +2208,13 @@ static bool target_handle_task_attr(struct se_cmd *cmd)
 	switch (cmd->sam_task_attr) {
 	case TCM_HEAD_TAG:
 		atomic_inc_mb(&dev->non_ordered);
-		target_debug("Added HEAD_OF_QUEUE for CDB: 0x%02x\n", cmd->t_task_cdb[0]);
+		target_cmd_debug(cmd, "Added HEAD_OF_QUEUE for CDB: 0x%02x\n", cmd->t_task_cdb[0]);
 		return false;
 	case TCM_ORDERED_TAG:
 		atomic_inc_mb(&dev->delayed_cmd_count);
 
-		target_debug("Added ORDERED for CDB: 0x%02x to ordered list\n", cmd->t_task_cdb[0]);
+		target_cmd_debug(cmd, "Added ORDERED for CDB: 0x%02x to ordered list\n",
+				 cmd->t_task_cdb[0]);
 		break;
 	default:
 		/*
@@ -2245,8 +2244,8 @@ static bool target_handle_task_attr(struct se_cmd *cmd)
 	list_add_tail(&cmd->se_delayed_node, &dev->delayed_cmd_list);
 	spin_unlock(&dev->delayed_cmd_lock);
 
-	target_debug("Added CDB: 0x%02x Task Attr: 0x%02x to delayed CMD listn", cmd->t_task_cdb[0],
-		     cmd->sam_task_attr);
+	target_cmd_debug(cmd, "Added CDB: 0x%02x Task Attr: 0x%02x to delayed CMD listn",
+			 cmd->t_task_cdb[0], cmd->sam_task_attr);
 	/*
 	 * We may have no non ordered cmds when this function started or we
 	 * could have raced with the last simple/head cmd completing, so kick
@@ -2350,16 +2349,16 @@ static void transport_complete_task_attr(struct se_cmd *cmd)
 	} else if (cmd->sam_task_attr == TCM_HEAD_TAG) {
 		atomic_dec_mb(&dev->non_ordered);
 		dev->dev_cur_ordered_id++;
-		target_debug("Incremented dev_cur_ordered_id: %u for HEAD_OF_QUEUE\n",
-			     dev->dev_cur_ordered_id);
+		target_cmd_debug(cmd, "Incremented dev_cur_ordered_id: %u for HEAD_OF_QUEUE\n",
+				 dev->dev_cur_ordered_id);
 	} else if (cmd->sam_task_attr == TCM_ORDERED_TAG) {
 		spin_lock(&dev->delayed_cmd_lock);
 		dev->ordered_sync_in_progress = false;
 		spin_unlock(&dev->delayed_cmd_lock);
 
 		dev->dev_cur_ordered_id++;
-		target_debug("Incremented dev_cur_ordered_id: %u for ORDERED\n",
-			     dev->dev_cur_ordered_id);
+		target_cmd_debug(cmd, "Incremented dev_cur_ordered_id: %u for ORDERED\n",
+				 dev->dev_cur_ordered_id);
 	}
 	cmd->se_cmd_flags &= ~SCF_TASK_ATTR_SET;
 
@@ -2451,7 +2450,7 @@ static void transport_handle_queue_full(struct se_cmd *cmd, struct se_device *de
 		cmd->t_state = (write_pending) ? TRANSPORT_COMPLETE_QF_WP :
 						 TRANSPORT_COMPLETE_QF_OK;
 	} else {
-		target_warn_ratelimited("Got unknown fabric queue status: %d\n", err);
+		target_cmd_warn_ratelimited(cmd, "Got unknown fabric queue status: %d\n", err);
 		cmd->t_state = TRANSPORT_COMPLETE_QF_ERR;
 	}
 
@@ -2630,8 +2629,8 @@ static void target_complete_ok_work(struct work_struct *work)
 	return;
 
 queue_full:
-	target_debug("Handling complete_ok QUEUE_FULL: se_cmd: %p, data_direction: %d\n", cmd,
-		     cmd->data_direction);
+	target_cmd_debug(cmd, "Handling complete_ok QUEUE_FULL: se_cmd: %p, data_direction: %d\n",
+			 cmd, cmd->data_direction);
 
 	transport_handle_queue_full(cmd, cmd->se_dev, ret, false);
 }
@@ -2836,7 +2835,8 @@ transport_generic_new_cmd(struct se_cmd *cmd)
 	 */
 	if (cmd->transport_state & CMD_T_STOP &&
 	    !cmd->se_tfo->write_pending_must_be_called) {
-		target_debug("%s:%d CMD_T_STOP for ITT: 0x%08llx\n", __func__, __LINE__, cmd->tag);
+		target_cmd_debug(cmd, "%s:%d CMD_T_STOP for ITT: 0x%08llx\n", __func__, __LINE__,
+				 cmd->tag);
 
 		spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
@@ -2853,7 +2853,7 @@ transport_generic_new_cmd(struct se_cmd *cmd)
 	return 0;
 
 queue_full:
-	target_debug("Handling write_pending QUEUE__FULL: se_cmd: %p\n", cmd);
+	target_cmd_debug(cmd, "Handling write_pending QUEUE__FULL: se_cmd: %p\n", cmd);
 	transport_handle_queue_full(cmd, cmd->se_dev, ret, true);
 	return 0;
 }
@@ -2870,15 +2870,15 @@ static void transport_write_pending_qf(struct se_cmd *cmd)
 	spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
 	if (stop) {
-		target_debug("%s:%d CMD_T_STOP|CMD_T_ABORTED for ITT: 0x%08llx\n", __func__,
-			     __LINE__, cmd->tag);
+		target_cmd_debug(cmd, "%s:%d CMD_T_STOP|CMD_T_ABORTED for ITT: 0x%08llx\n",
+				 __func__, __LINE__, cmd->tag);
 		complete_all(&cmd->t_transport_stop_comp);
 		return;
 	}
 
 	ret = cmd->se_tfo->write_pending(cmd);
 	if (ret) {
-		target_debug("Handling write_pending QUEUE__FULL: se_cmd: %p\n", cmd);
+		target_cmd_debug(cmd, "Handling write_pending QUEUE__FULL: se_cmd: %p\n", cmd);
 		transport_handle_queue_full(cmd, cmd->se_dev, ret, true);
 	}
 }
@@ -3619,9 +3619,9 @@ int transport_generic_handle_tmr(
 	spin_unlock_irqrestore(&cmd->t_state_lock, flags);
 
 	if (aborted) {
-		target_warn_ratelimited("handle_tmr caught CMD_T_ABORTED TMR %d ref_tag: %llu tag: %llu\n",
-					cmd->se_tmr_req->function, cmd->se_tmr_req->ref_task_tag,
-					cmd->tag);
+		target_cmd_warn_ratelimited(cmd, "handle_tmr caught CMD_T_ABORTED TMR %d ref_tag: %llu tag: %llu\n",
+					    cmd->se_tmr_req->function,
+					    cmd->se_tmr_req->ref_task_tag, cmd->tag);
 		target_handle_abort(cmd);
 		return 0;
 	}
diff --git a/drivers/target/target_core_ua.c b/drivers/target/target_core_ua.c
index 11d50a1da03c..df4d884b76ae 100644
--- a/drivers/target/target_core_ua.c
+++ b/drivers/target/target_core_ua.c
@@ -253,11 +253,11 @@ bool core_scsi3_ua_for_check_condition(struct se_cmd *cmd, u8 *key, u8 *asc,
 	spin_unlock(&deve->ua_lock);
 	rcu_read_unlock();
 
-	target_debug("[%s]: %s UNIT ATTENTION condition with INTLCK_CTRL: %d, mapped LUN: %llu, got CDB: 0x%02x reported ASC: 0x%02x, ASCQ: 0x%02x\n",
-		     nacl->se_tpg->se_tpg_tfo->fabric_name,
-		     dev_ua_intlck_clear ? "Releasing" : "Reporting",
-		     dev->dev_attrib.emulate_ua_intlck_ctrl, cmd->orig_fe_lun, cmd->t_task_cdb[0],
-		     *asc, *ascq);
+	target_cmd_debug(cmd, "[%s]: %s UNIT ATTENTION condition with INTLCK_CTRL: %d, mapped LUN: %llu, got CDB: 0x%02x reported ASC: 0x%02x, ASCQ: 0x%02x\n",
+			 nacl->se_tpg->se_tpg_tfo->fabric_name,
+			 dev_ua_intlck_clear ? "Releasing" : "Reporting",
+			 dev->dev_attrib.emulate_ua_intlck_ctrl, cmd->orig_fe_lun,
+			 cmd->t_task_cdb[0], *asc, *ascq);
 
 	return head == 0;
 }
@@ -313,8 +313,8 @@ int core_scsi3_ua_clear_for_request_sense(
 	spin_unlock(&deve->ua_lock);
 	rcu_read_unlock();
 
-	target_debug("[%s]: Released UNIT ATTENTION condition, mapped LUN: %llu, got REQUEST_SENSE reported ASC: 0x%02x, ASCQ: 0x%02x\n",
-		     nacl->se_tpg->se_tpg_tfo->fabric_name, cmd->orig_fe_lun, *asc, *ascq);
+	target_cmd_debug(cmd, "[%s]: Released UNIT ATTENTION condition, mapped LUN: %llu, got REQUEST_SENSE reported ASC: 0x%02x, ASCQ: 0x%02x\n",
+			 nacl->se_tpg->se_tpg_tfo->fabric_name, cmd->orig_fe_lun, *asc, *ascq);
 
 	return (head) ? -EPERM : 0;
 }
diff --git a/drivers/target/target_core_xcopy.c b/drivers/target/target_core_xcopy.c
index 341adcc82db8..c6ebb9cfe6e5 100644
--- a/drivers/target/target_core_xcopy.c
+++ b/drivers/target/target_core_xcopy.c
@@ -59,10 +59,10 @@ static int target_xcopy_locate_se_dev_e4_iter(struct se_device *se_dev,
 
 	rc = memcmp(&tmp_dev_wwn[0], dev_wwn, XCOPY_NAA_IEEE_REGEX_LEN);
 	if (rc != 0) {
-		target_debug("skip non-matching: %*ph\n", XCOPY_NAA_IEEE_REGEX_LEN, tmp_dev_wwn);
+		target_debug("Skip non-matching: %*ph\n", XCOPY_NAA_IEEE_REGEX_LEN, tmp_dev_wwn);
 		return 0;
 	}
-	target_debug("XCOPY 0xe4: located se_dev: %p\n", se_dev);
+	target_debug("0xe4: located se_dev: %p\n", se_dev);
 
 	return 1;
 }
@@ -81,7 +81,7 @@ static int target_xcopy_locate_se_dev_e4(struct se_session *sess,
 	if (!sess)
 		goto err_out;
 
-	target_debug("XCOPY 0xe4: searching for: %*ph\n", XCOPY_NAA_IEEE_REGEX_LEN, dev_wwn);
+	target_sess_debug(sess, "0xe4: searching for: %*ph\n", XCOPY_NAA_IEEE_REGEX_LEN, dev_wwn);
 
 	nacl = sess->se_node_acl;
 	rcu_read_lock();
@@ -103,13 +103,13 @@ static int target_xcopy_locate_se_dev_e4(struct se_session *sess,
 	if (found_dev == NULL)
 		goto err_out;
 
-	target_debug("lun_ref held for se_dev: %p se_dev->se_dev_group: %p\n", found_dev,
-		     &found_dev->dev_group);
+	target_sess_debug(sess, "lun_ref held for se_dev: %p se_dev->se_dev_group: %p\n", found_dev,
+			  &found_dev->dev_group);
 	*_found_dev = found_dev;
 	*_found_lun_ref = &this_lun->lun_ref;
 	return 0;
 err_out:
-	target_debug_ratelimited("Unable to locate 0xe4 descriptor for EXTENDED_COPY\n");
+	target_sess_debug_ratelimited(sess, "Unable to locate 0xe4 descriptor for EXTENDED_COPY\n");
 	return -EINVAL;
 }
 
@@ -123,20 +123,21 @@ static int target_xcopy_parse_tiddesc_e4(struct se_cmd *se_cmd, struct xcopy_op
 	 * Extract RELATIVE INITIATOR PORT IDENTIFIER
 	 */
 	ript = get_unaligned_be16(&desc[2]);
-	target_debug("XCOPY 0xe4: RELATIVE INITIATOR PORT IDENTIFIER: %u\n", ript);
+	target_cmd_debug(se_cmd, "0xe4: RELATIVE INITIATOR PORT IDENTIFIER: %u\n", ript);
 	/*
 	 * Check for supported code set, association, and designator type
 	 */
 	if ((desc[4] & 0x0f) != 0x1) {
-		target_err("XCOPY 0xe4: code set of non binary type not supported\n");
+		target_cmd_err(se_cmd, "0xe4: code set of non binary type not supported\n");
 		return -EINVAL;
 	}
 	if ((desc[5] & 0x30) != 0x00) {
-		target_err("XCOPY 0xe4: association other than LUN not supported\n");
+		target_cmd_err(se_cmd, "0xe4: association other than LUN not supported\n");
 		return -EINVAL;
 	}
 	if ((desc[5] & 0x0f) != 0x3) {
-		target_err("XCOPY 0xe4: designator type unsupported: 0x%02x\n", (desc[5] & 0x0f));
+		target_cmd_err(se_cmd, "0xe4: designator type unsupported: 0x%02x\n",
+			       (desc[5] & 0x0f));
 		return -EINVAL;
 	}
 	/*
@@ -145,21 +146,22 @@ static int target_xcopy_parse_tiddesc_e4(struct se_cmd *se_cmd, struct xcopy_op
 	 */
 	desig_len = desc[7];
 	if (desig_len != XCOPY_NAA_IEEE_REGEX_LEN) {
-		target_err("XCOPY 0xe4: invalid desig_len: %d\n", (int)desig_len);
+		target_cmd_err(se_cmd, "0xe4: invalid desig_len: %d\n", (int)desig_len);
 		return -EINVAL;
 	}
-	target_debug("XCOPY 0xe4: desig_len: %d\n", (int)desig_len);
+	target_cmd_debug(se_cmd, "0xe4: desig_len: %d\n", (int)desig_len);
 	/*
 	 * Check for NAA IEEE Registered Extended Assigned header..
 	 */
 	if ((desc[8] & 0xf0) != 0x60) {
-		target_err("XCOPY 0xe4: Unsupported DESIGNATOR TYPE: 0x%02x\n", (desc[8] & 0xf0));
+		target_cmd_err(se_cmd, "0xe4: Unsupported DESIGNATOR TYPE: 0x%02x\n",
+			       (desc[8] & 0xf0));
 		return -EINVAL;
 	}
 
 	if (cscd_index != xop->stdi && cscd_index != xop->dtdi) {
-		target_debug("XCOPY 0xe4: ignoring CSCD entry %d - neither src nor dest\n",
-			     cscd_index);
+		target_cmd_debug(se_cmd, "0xe4: ignoring CSCD entry %d - neither src nor dest\n",
+				 cscd_index);
 		return 0;
 	}
 
@@ -172,8 +174,8 @@ static int target_xcopy_parse_tiddesc_e4(struct se_cmd *se_cmd, struct xcopy_op
 				XCOPY_NAA_IEEE_REGEX_LEN)) {
 			xop->op_origin = XCOL_SOURCE_RECV_OP;
 			xop->src_dev = se_cmd->se_dev;
-			target_debug("XCOPY 0xe4: Set xop->src_dev %p from source received xop\n",
-				     xop->src_dev);
+			target_cmd_debug(se_cmd, "0xe4: Set xop->src_dev %p from source received xop\n",
+					 xop->src_dev);
 		}
 	}
 
@@ -189,8 +191,8 @@ static int target_xcopy_parse_tiddesc_e4(struct se_cmd *se_cmd, struct xcopy_op
 				XCOPY_NAA_IEEE_REGEX_LEN)) {
 			xop->op_origin = XCOL_DEST_RECV_OP;
 			xop->dst_dev = se_cmd->se_dev;
-			target_debug("XCOPY 0xe4: Set xop->dst_dev: %p from destination received xop\n",
-				     xop->dst_dev);
+			target_cmd_debug(se_cmd, "0xe4: Set xop->dst_dev: %p from destination received xop\n",
+					 xop->dst_dev);
 		}
 	}
 
@@ -210,14 +212,14 @@ static int target_xcopy_parse_target_descriptors(struct se_cmd *se_cmd,
 	*sense_ret = TCM_INVALID_PARAMETER_LIST;
 
 	if (offset != 0) {
-		target_err("XCOPY target descriptor list length is not multiple of %d\n",
-			   XCOPY_TARGET_DESC_LEN);
+		target_cmd_err(se_cmd, "Target descriptor list length is not multiple of %d\n",
+			       XCOPY_TARGET_DESC_LEN);
 		*sense_ret = TCM_UNSUPPORTED_TARGET_DESC_TYPE_CODE;
 		return -EINVAL;
 	}
 	if (tdll > RCR_OP_MAX_TARGET_DESC_COUNT * XCOPY_TARGET_DESC_LEN) {
-		target_err("XCOPY target descriptor supports a maximum two src/dest descriptors, tdll: %u too large..\n",
-			   tdll);
+		target_cmd_err(se_cmd, "Target descriptor supports a maximum two src/dest descriptors, tdll: %u too large..\n",
+			       tdll);
 		/* spc4r37 6.4.3.4 CSCD DESCRIPTOR LIST LENGTH field */
 		*sense_ret = TCM_TOO_MANY_TARGET_DESCS;
 		return -EINVAL;
@@ -246,7 +248,8 @@ static int target_xcopy_parse_target_descriptors(struct se_cmd *se_cmd,
 			cscd_index++;
 			break;
 		default:
-			target_err("XCOPY unsupported descriptor type code: 0x%02x\n", desc[0]);
+			target_cmd_err(se_cmd, "Unsupported descriptor type code: 0x%02x\n",
+				       desc[0]);
 			*sense_ret = TCM_UNSUPPORTED_TARGET_DESC_TYPE_CODE;
 			goto out;
 		}
@@ -266,8 +269,8 @@ static int target_xcopy_parse_target_descriptors(struct se_cmd *se_cmd,
 						&xop->remote_lun_ref);
 		break;
 	default:
-		target_err("XCOPY CSCD descriptor IDs not found in CSCD list - stdi: %hu dtdi: %hu\n",
-			   xop->stdi, xop->dtdi);
+		target_cmd_err(se_cmd, "CSCD descriptor IDs not found in CSCD list - stdi: %hu dtdi: %hu\n",
+			       xop->stdi, xop->dtdi);
 		rc = -EINVAL;
 		break;
 	}
@@ -282,10 +285,10 @@ static int target_xcopy_parse_target_descriptors(struct se_cmd *se_cmd,
 		goto out;
 	}
 
-	target_debug("XCOPY TGT desc: Source dev: %p NAA IEEE WWN: 0x%16phN\n", xop->src_dev,
-		     &xop->src_tid_wwn[0]);
-	target_debug("XCOPY TGT desc: Dest dev: %p NAA IEEE WWN: 0x%16phN\n", xop->dst_dev,
-		     &xop->dst_tid_wwn[0]);
+	target_cmd_debug(se_cmd, "TGT desc: Source dev: %p NAA IEEE WWN: 0x%16phN\n", xop->src_dev,
+			 &xop->src_tid_wwn[0]);
+	target_cmd_debug(se_cmd, "TGT desc: Dest dev: %p NAA IEEE WWN: 0x%16phN\n", xop->dst_dev,
+			 &xop->dst_tid_wwn[0]);
 
 	return cscd_index;
 
@@ -301,7 +304,7 @@ static int target_xcopy_parse_segdesc_02(struct xcopy_op *xop, unsigned char *p)
 
 	desc_len = get_unaligned_be16(&desc[2]);
 	if (desc_len != 0x18) {
-		target_err("XCOPY segment desc 0x02: Illegal desc_len: %u\n", desc_len);
+		target_err("segment desc 0x02: Illegal desc_len: %u\n", desc_len);
 		return -EINVAL;
 	}
 
@@ -310,18 +313,18 @@ static int target_xcopy_parse_segdesc_02(struct xcopy_op *xop, unsigned char *p)
 
 	if (xop->stdi > XCOPY_CSCD_DESC_ID_LIST_OFF_MAX ||
 	    xop->dtdi > XCOPY_CSCD_DESC_ID_LIST_OFF_MAX) {
-		target_err("XCOPY segment desc 0x02: unsupported CSCD ID > 0x%x; stdi: %u dtdi: %u\n",
+		target_err("Segment desc 0x02: unsupported CSCD ID > 0x%x; stdi: %u dtdi: %u\n",
 			   XCOPY_CSCD_DESC_ID_LIST_OFF_MAX, xop->stdi, xop->dtdi);
 		return -EINVAL;
 	}
 
-	target_debug("XCOPY seg desc 0x02: desc_len: %hu stdi: %hu dtdi: %hu, DC: %d\n", desc_len,
-		     xop->stdi, xop->dtdi, dc);
+	target_debug("seg desc 0x02: desc_len: %hu stdi: %hu dtdi: %hu, DC: %d\n",
+		     desc_len, xop->stdi, xop->dtdi, dc);
 
 	xop->nolb = get_unaligned_be16(&desc[10]);
 	xop->src_lba = get_unaligned_be64(&desc[12]);
 	xop->dst_lba = get_unaligned_be64(&desc[20]);
-	target_debug("XCOPY seg desc 0x02: nolb: %u src_lba: %llu dst_lba: %llu\n", xop->nolb,
+	target_debug("seg desc 0x02: nolb: %u src_lba: %llu dst_lba: %llu\n", xop->nolb,
 		     (unsigned long long)xop->src_lba, (unsigned long long)xop->dst_lba);
 
 	return 0;
@@ -338,13 +341,13 @@ static int target_xcopy_parse_segment_descriptors(struct xcopy_op *xop,
 	*sense_ret = TCM_INVALID_PARAMETER_LIST;
 
 	if (offset != 0) {
-		target_err("XCOPY segment descriptor list length is not multiple of %d\n",
+		target_err("Segment descriptor list length is not multiple of %d\n",
 			   XCOPY_SEGMENT_DESC_LEN);
 		*sense_ret = TCM_UNSUPPORTED_SEGMENT_DESC_TYPE_CODE;
 		return -EINVAL;
 	}
 	if (sdll > RCR_OP_MAX_SG_DESC_COUNT * XCOPY_SEGMENT_DESC_LEN) {
-		target_err("XCOPY supports %u segment descriptor(s), sdll: %u too large..\n",
+		target_err("Supports %u segment descriptor(s), sdll: %u too large..\n",
 			   RCR_OP_MAX_SG_DESC_COUNT, sdll);
 		/* spc4r37 6.4.3.5 SEGMENT DESCRIPTOR LIST LENGTH field */
 		*sense_ret = TCM_TOO_MANY_SEGMENT_DESCS;
@@ -366,7 +369,8 @@ static int target_xcopy_parse_segment_descriptors(struct xcopy_op *xop,
 			desc += XCOPY_SEGMENT_DESC_LEN;
 			break;
 		default:
-			target_err("XCOPY unsupported segment descriptortype: 0x%02x\n", desc[0]);
+			target_err("Unsupported segment descriptor type: 0x%02x\n",
+				   desc[0]);
 			*sense_ret = TCM_UNSUPPORTED_SEGMENT_DESC_TYPE_CODE;
 			goto out;
 		}
@@ -535,8 +539,8 @@ static int target_xcopy_setup_pt_cmd(
 					xop->xop_data_nents, NULL, 0))
 		return -EINVAL;
 
-	target_debug("Setup PASSTHROUGH_NOALLOC t_data_sg: %p t_data_nents: %u\n", cmd->t_data_sg,
-		     cmd->t_data_nents);
+	target_cmd_debug(cmd, "Setup PASSTHROUGH_NOALLOC t_data_sg: %p t_data_nents: %u\n",
+			 cmd->t_data_sg, cmd->t_data_nents);
 
 	return 0;
 }
@@ -555,7 +559,7 @@ static int target_xcopy_issue_pt_cmd(struct xcopy_pt_cmd *xpt_cmd)
 
 	wait_for_completion_interruptible(&xpt_cmd->xpt_passthrough_sem);
 
-	target_debug("target_xcopy_issue_pt_cmd(): SCSI status: 0x%02x\n", se_cmd->scsi_status);
+	target_cmd_debug(se_cmd, "%s(): SCSI status: 0x%02x\n", __func__, se_cmd->scsi_status);
 
 	return (se_cmd->scsi_status) ? -EINVAL : 0;
 }
@@ -594,7 +598,7 @@ static int target_xcopy_read_source(
 		goto out;
 	}
 
-	target_debug("XCOPY-READ: Saved xop->xop_data_sg: %p, num: %u for READ memory\n",
+	target_debug("READ: Saved xop->xop_data_sg: %p, num: %u for READ memory\n",
 		     xop->xop_data_sg, xop->xop_data_nents);
 
 	rc = target_xcopy_issue_pt_cmd(&xpt_cmd);
@@ -692,10 +696,10 @@ static void target_xcopy_do_work(struct work_struct *work)
 	 */
 	max_blocks = max_bytes >> ilog2(src_dev->dev_attrib.block_size);
 
-	target_debug("%s: nolb: %u, max_blocks: %llu end_lba: %llu\n", __func__, nolb, max_blocks,
-		     (unsigned long long)end_lba);
-	target_debug("%s: Starting src_lba: %llu, dst_lba: %llu\n", __func__,
-		     (unsigned long long)src_lba, (unsigned long long)dst_lba);
+	target_cmd_debug(ec_cmd, "%s: nolb: %u, max_blocks: %llu end_lba: %llu\n", __func__, nolb,
+			 max_blocks, (unsigned long long)end_lba);
+	target_cmd_debug(ec_cmd, "%s: Starting src_lba: %llu, dst_lba: %llu\n", __func__,
+			 (unsigned long long)src_lba, (unsigned long long)dst_lba);
 
 	while (nolb) {
 		u32 cur_bytes = min_t(u64, max_bytes, nolb * src_dev->dev_attrib.block_size);
@@ -716,19 +720,19 @@ static void target_xcopy_do_work(struct work_struct *work)
 			xop->xop_data_bytes = cur_bytes;
 		}
 
-		target_debug("%s: Calling read src_dev: %p src_lba: %llu, cur_nolb: %hu\n",
-			     __func__, src_dev, (unsigned long long)src_lba, cur_nolb);
+		target_cmd_debug(ec_cmd, "%s: Calling read src_dev: %p src_lba: %llu, cur_nolb: %hu\n",
+				 __func__, src_dev, (unsigned long long)src_lba, cur_nolb);
 
 		rc = target_xcopy_read_source(ec_cmd, xop, src_dev, src_lba, cur_bytes);
 		if (rc < 0)
 			goto out;
 
 		src_lba += cur_bytes / src_dev->dev_attrib.block_size;
-		target_debug("%s: Incremented READ src_lba to %llu\n", __func__,
-			     (unsigned long long)src_lba);
+		target_cmd_debug(ec_cmd, "%s: Incremented READ src_lba to %llu\n", __func__,
+				 (unsigned long long)src_lba);
 
-		target_debug("%s: Calling write dst_dev: %p dst_lba: %llu, cur_nolb: %u\n",
-			     __func__, dst_dev, (unsigned long long)dst_lba, cur_nolb);
+		target_cmd_debug(ec_cmd, "%s: Calling write dst_dev: %p dst_lba: %llu, cur_nolb: %u\n",
+				 __func__, dst_dev, (unsigned long long)dst_lba, cur_nolb);
 
 		rc = target_xcopy_write_destination(ec_cmd, xop, dst_dev,
 						dst_lba, cur_bytes);
@@ -736,8 +740,8 @@ static void target_xcopy_do_work(struct work_struct *work)
 			goto out;
 
 		dst_lba += cur_bytes / dst_dev->dev_attrib.block_size;
-		target_debug("%s: Incremented WRITE dst_lba to %llu\n", __func__,
-			     (unsigned long long)dst_lba);
+		target_cmd_debug(ec_cmd, "%s: Incremented WRITE dst_lba to %llu\n", __func__,
+				 (unsigned long long)dst_lba);
 
 		copied_bytes += cur_bytes;
 		nolb -= cur_bytes / src_dev->dev_attrib.block_size;
@@ -747,12 +751,12 @@ static void target_xcopy_do_work(struct work_struct *work)
 	target_free_sgl(xop->xop_data_sg, xop->xop_data_nents);
 	kfree(xop);
 
-	target_debug("%s: Final src_lba: %llu, dst_lba: %llu\n", __func__,
-		     (unsigned long long)src_lba, (unsigned long long)dst_lba);
-	target_debug("%s: Blocks copied: %u, Bytes Copied: %u\n", __func__,
-		     copied_bytes / dst_dev->dev_attrib.block_size, copied_bytes);
+	target_cmd_debug(ec_cmd, "%s: Final src_lba: %llu, dst_lba: %llu\n", __func__,
+			 (unsigned long long)src_lba, (unsigned long long)dst_lba);
+	target_cmd_debug(ec_cmd, "%s: Blocks copied: %u, Bytes Copied: %u\n", __func__,
+			 copied_bytes / dst_dev->dev_attrib.block_size, copied_bytes);
 
-	target_debug("%s: Setting X-COPY GOOD status -> sending response\n", __func__);
+	target_cmd_debug(ec_cmd, "%s: Setting X-COPY GOOD status -> sending response\n", __func__);
 	target_complete_cmd(ec_cmd, SAM_STAT_GOOD);
 	return;
 
@@ -768,8 +772,8 @@ static void target_xcopy_do_work(struct work_struct *work)
 
 err_free:
 	kfree(xop);
-	target_warn_ratelimited("%s: rc: %d, sense: %u, XCOPY operation failed\n", __func__, rc,
-				sense_rc);
+	target_cmd_warn_ratelimited(ec_cmd, "%s: rc: %d, sense: %u, XCOPY operation failed\n",
+				    __func__, rc, sense_rc);
 	target_complete_cmd_with_sense(ec_cmd, SAM_STAT_CHECK_CONDITION, sense_rc);
 }
 
@@ -788,7 +792,7 @@ static sense_reason_t target_parse_xcopy_cmd(struct xcopy_op *xop)
 
 	p = transport_kmap_data_sg(se_cmd);
 	if (!p) {
-		target_err("transport_kmap_data_sg() failed in target_do_xcopy\n");
+		target_cmd_err(se_cmd, "transport_kmap_data_sg() failed in target_do_xcopy\n");
 		return TCM_OUT_OF_RESOURCES;
 	}
 
@@ -801,27 +805,27 @@ static sense_reason_t target_parse_xcopy_cmd(struct xcopy_op *xop)
 	tdll = get_unaligned_be16(&p[2]);
 	sdll = get_unaligned_be32(&p[8]);
 	if (tdll + sdll > RCR_OP_MAX_DESC_LIST_LEN) {
-		target_err("XCOPY descriptor list length %u exceeds maximum %u\n", tdll + sdll,
-			   RCR_OP_MAX_DESC_LIST_LEN);
+		target_cmd_err(se_cmd, "Descriptor list length %u exceeds maximum %u\n",
+			       tdll + sdll, RCR_OP_MAX_DESC_LIST_LEN);
 		ret = TCM_PARAMETER_LIST_LENGTH_ERROR;
 		goto out;
 	}
 
 	inline_dl = get_unaligned_be32(&p[12]);
 	if (inline_dl != 0) {
-		target_err("XCOPY with non zero inline data length\n");
+		target_cmd_err(se_cmd, "Command with non zero inline data length\n");
 		goto out;
 	}
 
 	if (se_cmd->data_length < (XCOPY_HDR_LEN + tdll + sdll + inline_dl)) {
-		target_err("XCOPY parameter truncation: data length %u too small for tdll: %u sdll: %u inline_dl: %u\n",
-			   se_cmd->data_length, tdll, sdll, inline_dl);
+		target_cmd_err(se_cmd, "Parameter truncation: data length %u too small for tdll: %u sdll: %u inline_dl: %u\n",
+			       se_cmd->data_length, tdll, sdll, inline_dl);
 		ret = TCM_PARAMETER_LIST_LENGTH_ERROR;
 		goto out;
 	}
 
-	target_debug("Processing XCOPY with list_id: 0x%02x list_id_usage: 0x%02x tdll: %hu sdll: %u inline_dl: %u\n",
-		     list_id, list_id_usage, tdll, sdll, inline_dl);
+	target_cmd_debug(se_cmd, "Processing  with list_id: 0x%02x list_id_usage: 0x%02x tdll: %hu sdll: %u inline_dl: %u\n",
+			 list_id, list_id_usage, tdll, sdll, inline_dl);
 
 	/*
 	 * skip over the target descriptors until segment descriptors
@@ -833,8 +837,8 @@ static sense_reason_t target_parse_xcopy_cmd(struct xcopy_op *xop)
 	if (rc <= 0)
 		goto out;
 
-	target_debug("Processed %d segment descriptors, length: %u\n", rc,
-		     rc * XCOPY_SEGMENT_DESC_LEN);
+	target_cmd_debug(se_cmd, "Processed %d segment descriptors, length: %u\n", rc,
+			 rc * XCOPY_SEGMENT_DESC_LEN);
 
 	rc = target_xcopy_parse_target_descriptors(se_cmd, xop, &p[16], tdll, &ret);
 	if (rc <= 0)
@@ -842,16 +846,16 @@ static sense_reason_t target_parse_xcopy_cmd(struct xcopy_op *xop)
 
 	if (xop->src_dev->dev_attrib.block_size !=
 	    xop->dst_dev->dev_attrib.block_size) {
-		target_err("Non matching src_dev block_size: %u + dst_dev block_size: %u currently unsupported\n",
-			   xop->src_dev->dev_attrib.block_size,
-			   xop->dst_dev->dev_attrib.block_size);
+		target_cmd_err(se_cmd, "Non matching src_dev block_size: %u + dst_dev block_size: %u currently unsupported\n",
+			       xop->src_dev->dev_attrib.block_size,
+			       xop->dst_dev->dev_attrib.block_size);
 		xcopy_pt_undepend_remotedev(xop);
 		ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 		goto out;
 	}
 
-	target_debug("Processed %d target descriptors, length: %u\n", rc,
-		     rc * XCOPY_TARGET_DESC_LEN);
+	target_cmd_debug(se_cmd, "Processed %d target descriptors, length: %u\n", rc,
+			 rc * XCOPY_TARGET_DESC_LEN);
 	transport_kunmap_data_sg(se_cmd);
 	return TCM_NO_SENSE;
 
@@ -868,13 +872,13 @@ sense_reason_t target_do_xcopy(struct se_cmd *se_cmd)
 	unsigned int sa;
 
 	if (!dev->dev_attrib.emulate_3pc) {
-		target_err("EXTENDED_COPY operation explicitly disabled\n");
+		target_cmd_err(se_cmd, "EXTENDED_COPY operation explicitly disabled\n");
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 
 	sa = se_cmd->t_task_cdb[1] & 0x1f;
 	if (sa != 0x00) {
-		target_err("EXTENDED_COPY(LID4) not supported\n");
+		target_cmd_err(se_cmd, "EXTENDED_COPY(LID4) not supported\n");
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 
@@ -883,8 +887,8 @@ sense_reason_t target_do_xcopy(struct se_cmd *se_cmd)
 		return TCM_NO_SENSE;
 	}
 	if (se_cmd->data_length < XCOPY_HDR_LEN) {
-		target_err("XCOPY parameter truncation: length %u < hdr_len %u\n",
-			   se_cmd->data_length, XCOPY_HDR_LEN);
+		target_cmd_err(se_cmd, "Parameter truncation: length %u < hdr_len %u\n",
+			       se_cmd->data_length, XCOPY_HDR_LEN);
 		return TCM_PARAMETER_LIST_LENGTH_ERROR;
 	}
 
@@ -910,13 +914,13 @@ static sense_reason_t target_rcr_operating_parameters(struct se_cmd *se_cmd)
 
 	p = transport_kmap_data_sg(se_cmd);
 	if (!p) {
-		target_err("transport_kmap_data_sg failed in target_rcr_operating_parameters\n");
+		target_cmd_err(se_cmd, "transport_kmap_data_sg failed in target_rcr_operating_parameters\n");
 		return TCM_OUT_OF_RESOURCES;
 	}
 
 	if (se_cmd->data_length < 54) {
-		target_err("Receive Copy Results Op Parameters length too small: %u\n",
-			   se_cmd->data_length);
+		target_cmd_err(se_cmd, "Receive Copy Results Op Parameters length too small: %u\n",
+			       se_cmd->data_length);
 		transport_kunmap_data_sg(se_cmd);
 		return TCM_INVALID_CDB_FIELD;
 	}
@@ -1001,15 +1005,15 @@ sense_reason_t target_do_receive_copy_results(struct se_cmd *se_cmd)
 	sense_reason_t rc = TCM_NO_SENSE;
 
 	if (!dev->dev_attrib.emulate_3pc) {
-		target_debug("Third-party copy operations explicitly disabled\n");
+		target_cmd_debug(se_cmd, "Third-party copy operations explicitly disabled\n");
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 
-	target_debug("Entering target_do_receive_copy_results: SA: 0x%02x, List ID: 0x%02x, AL: %u\n",
-		     sa, list_id, se_cmd->data_length);
+	target_cmd_debug(se_cmd, "Entering target_do_receive_copy_results: SA: 0x%02x, List ID: 0x%02x, AL: %u\n",
+			 sa, list_id, se_cmd->data_length);
 
 	if (list_id != 0) {
-		target_err("Receive Copy Results with non zero list identifier not supported\n");
+		target_cmd_err(se_cmd, "Receive Copy Results with non zero list identifier not supported\n");
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -1021,7 +1025,7 @@ sense_reason_t target_do_receive_copy_results(struct se_cmd *se_cmd)
 	case RCR_SA_RECEIVE_DATA:
 	case RCR_SA_FAILED_SEGMENT_DETAILS:
 	default:
-		target_err("Unsupported SA for receive copy results: 0x%02x\n", sa);
+		target_cmd_err(se_cmd, "Unsupported SA for receive copy results: 0x%02x\n", sa);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
