Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending

Pull scsi target updates from Nicholas Bellinger: "The highlights in this series include: - Improve sg_table lookup scalability in RAMDISK_MCP (martin) - Add device attribute to expose config name for INQUIRY model (tregaron) - Convert tcm_vhost to use lock-less list for cmd completion (asias) - Add tcm_vhost support for multiple target's per endpoint (asias) - Add tcm_vhost support for multiple queues per vhost (asias) - Add missing mapped_lun bounds checking during make_mappedlun setup in generic fabric configfs code (jan engelhardt + nab) - Enforce individual iscsi-target network portal export once per TargetName endpoint (grover + nab) - Add WRITE_SAME w/ UNMAP=0 emulation to FILEIO backend (nab) Things have been mostly quiet this round, with majority of the work being done on the iser-target WIP driver + associated iscsi-target refactoring patches currently in flight for v3.10 code. At this point there is one patch series left outstanding from Asias to add support for UNMAP + WRITE_SAME w/ UNMAP=1 to FILEIO awaiting feedback from hch & Co, that will likely be included in a post v3.9-rc1 PULL request if there are no objections. Also, there is a regression bug recently reported off-list that seems to be effecting v3.5 and v3.6 kernels with MSFT iSCSI initiators that is still being tracked down. No word if this effects >= v3.7 just yet, but if so there will likely another PULL request coming your way.." * 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending: (26 commits) target: Rename spc_get_write_same_sectors -> sbc_get_write_same_sectors target/file: Add WRITE_SAME w/ UNMAP=0 emulation support iscsi-target: Enforce individual network portal export once per TargetName iscsi-target: Refactor iscsit_get_np sockaddr matching into iscsit_check_np_match target: Add missing mapped_lun bounds checking during make_mappedlun setup target: Fix lookup of dynamic NodeACLs during cached demo-mode operation target: Fix parameter list length checking in MODE SELECT target: Fix error checking for UNMAP commands target: Fix sense data for out-of-bounds IO operations target_core_rd: break out unterminated loop during copy tcm_vhost: Multi-queue support tcm_vhost: Multi-target support target: Add device attribute to expose config_item_name for INQUIRY model target: don't truncate the fail intr address target: don't always say "ipv6" as address type target/iblock: Use backend REQ_FLUSH hint for WriteCacheEnabled status iscsi-target: make some temporary buffers larger tcm_vhost: Optimize gup in vhost_scsi_map_to_sgl tcm_vhost: Use iov_num_pages to calculate sgl_count tcm_vhost: Introduce iov_num_pages ...

Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending
Pull scsi target updates from Nicholas Bellinger: "The highlights in this series include: - Improve sg_table lookup scalability in RAMDISK_MCP (martin) - Add device attribute to expose config name for INQUIRY model (tregaron) - Convert tcm_vhost to use lock-less list for cmd completion (asias) - Add tcm_vhost support for multiple target's per endpoint (asias) - Add tcm_vhost support for multiple queues per vhost (asias) - Add missing mapped_lun bounds checking during make_mappedlun setup in generic fabric configfs code (jan engelhardt + nab) - Enforce individual iscsi-target network portal export once per TargetName endpoint (grover + nab) - Add WRITE_SAME w/ UNMAP=0 emulation to FILEIO backend (nab) Things have been mostly quiet this round, with majority of the work being done on the iser-target WIP driver + associated iscsi-target refactoring patches currently in flight for v3.10 code. At this point there is one patch series left outstanding from Asias to add support for UNMAP + WRITE_SAME w/ UNMAP=1 to FILEIO awaiting feedback from hch & Co, that will likely be included in a post v3.9-rc1 PULL request if there are no objections. Also, there is a regression bug recently reported off-list that seems to be effecting v3.5 and v3.6 kernels with MSFT iSCSI initiators that is still being tracked down. No word if this effects >= v3.7 just yet, but if so there will likely another PULL request coming your way.." * 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending: (26 commits) target: Rename spc_get_write_same_sectors -> sbc_get_write_same_sectors target/file: Add WRITE_SAME w/ UNMAP=0 emulation support iscsi-target: Enforce individual network portal export once per TargetName iscsi-target: Refactor iscsit_get_np sockaddr matching into iscsit_check_np_match target: Add missing mapped_lun bounds checking during make_mappedlun setup target: Fix lookup of dynamic NodeACLs during cached demo-mode operation target: Fix parameter list length checking in MODE SELECT target: Fix error checking for UNMAP commands target: Fix sense data for out-of-bounds IO operations target_core_rd: break out unterminated loop during copy tcm_vhost: Multi-queue support tcm_vhost: Multi-target support target: Add device attribute to expose config_item_name for INQUIRY model target: don't truncate the fail intr address target: don't always say "ipv6" as address type target/iblock: Use backend REQ_FLUSH hint for WriteCacheEnabled status iscsi-target: make some temporary buffers larger tcm_vhost: Optimize gup in vhost_scsi_map_to_sgl tcm_vhost: Use iov_num_pages to calculate sgl_count tcm_vhost: Introduce iov_num_pages ...
Linus Torvalds
2 parents 70a3a06d01 972b29c8f8
Showing 21 changed files Side-by-side Diff
drivers/target/iscsi/iscsi_target.c
drivers/target/iscsi/iscsi_target.h
drivers/target/iscsi/iscsi_target_parameters.c
drivers/target/iscsi/iscsi_target_stat.c
drivers/target/iscsi/iscsi_target_tpg.c
drivers/target/target_core_configfs.c
drivers/target/target_core_device.c
drivers/target/target_core_fabric_configfs.c
drivers/target/target_core_file.c
drivers/target/target_core_iblock.c
drivers/target/target_core_internal.h
drivers/target/target_core_rd.c
drivers/target/target_core_sbc.c
drivers/target/target_core_spc.c
drivers/target/target_core_tmr.c
drivers/target/target_core_tpg.c
drivers/target/target_core_transport.c
drivers/vhost/tcm_vhost.c
drivers/vhost/tcm_vhost.h
include/target/target_core_backend.h
@@ -264,16 +264,50 @@
 	return 0;
 }
  
-static struct iscsi_np *iscsit_get_np(
+bool iscsit_check_np_match(
 	struct __kernel_sockaddr_storage *sockaddr,
+	struct iscsi_np *np,
 	int network_transport)
 {
 	struct sockaddr_in *sock_in, *sock_in_e;
 	struct sockaddr_in6 *sock_in6, *sock_in6_e;
-	struct iscsi_np *np;
-	int ip_match = 0;
+	bool ip_match = false;
 	u16 port;
  
+	if (sockaddr->ss_family == AF_INET6) {
+		sock_in6 = (struct sockaddr_in6 *)sockaddr;
+		sock_in6_e = (struct sockaddr_in6 *)&np->np_sockaddr;
+
+		if (!memcmp(&sock_in6->sin6_addr.in6_u,
+			    &sock_in6_e->sin6_addr.in6_u,
+			    sizeof(struct in6_addr)))
+			ip_match = true;
+
+		port = ntohs(sock_in6->sin6_port);
+	} else {
+		sock_in = (struct sockaddr_in *)sockaddr;
+		sock_in_e = (struct sockaddr_in *)&np->np_sockaddr;
+
+		if (sock_in->sin_addr.s_addr == sock_in_e->sin_addr.s_addr)
+			ip_match = true;
+
+		port = ntohs(sock_in->sin_port);
+	}
+
+	if ((ip_match == true) && (np->np_port == port) &&
+	    (np->np_network_transport == network_transport))
+		return true;
+
+	return false;
+}
+
+static struct iscsi_np *iscsit_get_np(
+	struct __kernel_sockaddr_storage *sockaddr,
+	int network_transport)
+{
+	struct iscsi_np *np;
+	bool match;
+
 	spin_lock_bh(&np_lock);
 	list_for_each_entry(np, &g_np_list, np_list) {
 		spin_lock(&np->np_thread_lock);
@@ -282,29 +316,8 @@
 			continue;
 		}
  
-		if (sockaddr->ss_family == AF_INET6) {
-			sock_in6 = (struct sockaddr_in6 *)sockaddr;
-			sock_in6_e = (struct sockaddr_in6 *)&np->np_sockaddr;
-
-			if (!memcmp(&sock_in6->sin6_addr.in6_u,
-				    &sock_in6_e->sin6_addr.in6_u,
-				    sizeof(struct in6_addr)))
-				ip_match = 1;
-
-			port = ntohs(sock_in6->sin6_port);
-		} else {
-			sock_in = (struct sockaddr_in *)sockaddr;
-			sock_in_e = (struct sockaddr_in *)&np->np_sockaddr;
-
-			if (sock_in->sin_addr.s_addr ==
-			    sock_in_e->sin_addr.s_addr)
-				ip_match = 1;
-
-			port = ntohs(sock_in->sin_port);
-		}
-
-		if ((ip_match == 1) && (np->np_port == port) &&
-		    (np->np_network_transport == network_transport)) {
+		match = iscsit_check_np_match(sockaddr, np, network_transport);
+		if (match == true) {
 			/*
 			 * Increment the np_exports reference count now to
 			 * prevent iscsit_del_np() below from being called
@@ -8,6 +8,8 @@
 extern void iscsit_del_tiqn(struct iscsi_tiqn *);
 extern int iscsit_access_np(struct iscsi_np *, struct iscsi_portal_group *);
 extern int iscsit_deaccess_np(struct iscsi_np *, struct iscsi_portal_group *);
+extern bool iscsit_check_np_match(struct __kernel_sockaddr_storage *,
+				struct iscsi_np *, int);
 extern struct iscsi_np *iscsit_add_np(struct __kernel_sockaddr_storage *,
 				char *, int);
 extern int iscsit_reset_np_thread(struct iscsi_np *, struct iscsi_tpg_np *,
@@ -1095,11 +1095,11 @@
 				SET_PSTATE_REPLY_OPTIONAL(param);
 		}
 	} else if (IS_TYPE_NUMBER(param)) {
-		char *tmpptr, buf[10];
+		char *tmpptr, buf[11];
 		u32 acceptor_value = simple_strtoul(param->value, &tmpptr, 0);
 		u32 proposer_value = simple_strtoul(value, &tmpptr, 0);
  
-		memset(buf, 0, 10);
+		memset(buf, 0, sizeof(buf));
  
 		if (!strcmp(param->name, MAXCONNECTIONS) ||
 		    !strcmp(param->name, MAXBURSTLENGTH) ||
@@ -1503,8 +1503,8 @@
 			FirstBurstLength = simple_strtoul(param->value,
 					&tmpptr, 0);
 			if (FirstBurstLength > MaxBurstLength) {
-				char tmpbuf[10];
-				memset(tmpbuf, 0, 10);
+				char tmpbuf[11];
+				memset(tmpbuf, 0, sizeof(tmpbuf));
 				sprintf(tmpbuf, "%u", MaxBurstLength);
 				if (iscsi_update_param_value(param, tmpbuf))
 					return -1;
@@ -410,14 +410,16 @@
 	struct iscsi_tiqn *tiqn = container_of(igrps,
 			struct iscsi_tiqn, tiqn_stat_grps);
 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
-	unsigned char buf[8];
+	int ret;
  
 	spin_lock(&lstat->lock);
-	snprintf(buf, 8, "%s", (lstat->last_intr_fail_ip_addr != NULL) ?
-				"ipv6" : "ipv4");
+	if (lstat->last_intr_fail_ip_family == AF_INET6)
+		ret = snprintf(page, PAGE_SIZE, "ipv6\n");
+	else
+		ret = snprintf(page, PAGE_SIZE, "ipv4\n");
 	spin_unlock(&lstat->lock);
  
-	return snprintf(page, PAGE_SIZE, "%s\n", buf);
+	return ret;
 }
 ISCSI_STAT_TGT_ATTR_RO(fail_intr_addr_type);
  
  
  
@@ -427,16 +429,19 @@
 	struct iscsi_tiqn *tiqn = container_of(igrps,
 			struct iscsi_tiqn, tiqn_stat_grps);
 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
-	unsigned char buf[32];
+	int ret;
  
 	spin_lock(&lstat->lock);
-	if (lstat->last_intr_fail_ip_family == AF_INET6)
-		snprintf(buf, 32, "[%s]", lstat->last_intr_fail_ip_addr);
-	else
-		snprintf(buf, 32, "%s", lstat->last_intr_fail_ip_addr);
+	if (lstat->last_intr_fail_ip_family == AF_INET6) {
+		ret = snprintf(page, PAGE_SIZE, "[%s]\n",
+			       lstat->last_intr_fail_ip_addr);
+	} else {
+		ret = snprintf(page, PAGE_SIZE, "%s\n",
+			       lstat->last_intr_fail_ip_addr);
+	}
 	spin_unlock(&lstat->lock);
  
-	return snprintf(page, PAGE_SIZE, "%s\n", buf);
+	return ret;
 }
 ISCSI_STAT_TGT_ATTR_RO(fail_intr_addr);
  
@@ -422,6 +422,35 @@
 	return NULL;
 }
  
+static bool iscsit_tpg_check_network_portal(
+	struct iscsi_tiqn *tiqn,
+	struct __kernel_sockaddr_storage *sockaddr,
+	int network_transport)
+{
+	struct iscsi_portal_group *tpg;
+	struct iscsi_tpg_np *tpg_np;
+	struct iscsi_np *np;
+	bool match = false;
+
+	spin_lock(&tiqn->tiqn_tpg_lock);
+	list_for_each_entry(tpg, &tiqn->tiqn_tpg_list, tpg_list) {
+
+		spin_lock(&tpg->tpg_np_lock);
+		list_for_each_entry(tpg_np, &tpg->tpg_gnp_list, tpg_np_list) {
+			np = tpg_np->tpg_np;
+
+			match = iscsit_check_np_match(sockaddr, np,
+						network_transport);
+			if (match == true)
+				break;
+		}
+		spin_unlock(&tpg->tpg_np_lock);
+	}
+	spin_unlock(&tiqn->tiqn_tpg_lock);
+
+	return match;
+}
+
 struct iscsi_tpg_np *iscsit_tpg_add_network_portal(
 	struct iscsi_portal_group *tpg,
 	struct __kernel_sockaddr_storage *sockaddr,
@@ -431,6 +460,16 @@
 {
 	struct iscsi_np *np;
 	struct iscsi_tpg_np *tpg_np;
+
+	if (!tpg_np_parent) {
+		if (iscsit_tpg_check_network_portal(tpg->tpg_tiqn, sockaddr,
+				network_transport) == true) {
+			pr_err("Network Portal: %s already exists on a"
+				" different TPG on %s\n", ip_str,
+				tpg->tpg_tiqn->tiqn);
+			return ERR_PTR(-EEXIST);
+		}
+	}
  
 	tpg_np = kzalloc(sizeof(struct iscsi_tpg_np), GFP_KERNEL);
 	if (!tpg_np) {
@@ -609,6 +609,9 @@
 	__CONFIGFS_EATTR_RO(_name,					\
 	target_core_dev_show_attr_##_name);
  
+DEF_DEV_ATTRIB(emulate_model_alias);
+SE_DEV_ATTR(emulate_model_alias, S_IRUGO | S_IWUSR);
+
 DEF_DEV_ATTRIB(emulate_dpo);
 SE_DEV_ATTR(emulate_dpo, S_IRUGO | S_IWUSR);
  
@@ -681,6 +684,7 @@
 CONFIGFS_EATTR_OPS(target_core_dev_attrib, se_dev_attrib, da_group);
  
 static struct configfs_attribute *target_core_dev_attrib_attrs[] = {
+	&target_core_dev_attrib_emulate_model_alias.attr,
 	&target_core_dev_attrib_emulate_dpo.attr,
 	&target_core_dev_attrib_emulate_fua_write.attr,
 	&target_core_dev_attrib_emulate_fua_read.attr,
@@ -713,6 +713,44 @@
 	return 0;
 }
  
+static void dev_set_t10_wwn_model_alias(struct se_device *dev)
+{
+	const char *configname;
+
+	configname = config_item_name(&dev->dev_group.cg_item);
+	if (strlen(configname) >= 16) {
+		pr_warn("dev[%p]: Backstore name '%s' is too long for "
+			"INQUIRY_MODEL, truncating to 16 bytes\n", dev,
+			configname);
+	}
+	snprintf(&dev->t10_wwn.model[0], 16, "%s", configname);
+}
+
+int se_dev_set_emulate_model_alias(struct se_device *dev, int flag)
+{
+	if (dev->export_count) {
+		pr_err("dev[%p]: Unable to change model alias"
+			" while export_count is %d\n",
+			dev, dev->export_count);
+			return -EINVAL;
+	}
+
+	if (flag != 0 && flag != 1) {
+		pr_err("Illegal value %d\n", flag);
+		return -EINVAL;
+	}
+
+	if (flag) {
+		dev_set_t10_wwn_model_alias(dev);
+	} else {
+		strncpy(&dev->t10_wwn.model[0],
+			dev->transport->inquiry_prod, 16);
+	}
+	dev->dev_attrib.emulate_model_alias = flag;
+
+	return 0;
+}
+
 int se_dev_set_emulate_dpo(struct se_device *dev, int flag)
 {
 	if (flag != 0 && flag != 1) {
@@ -772,6 +810,12 @@
 		pr_err("emulate_write_cache not supported for pSCSI\n");
 		return -EINVAL;
 	}
+	if (dev->transport->get_write_cache) {
+		pr_warn("emulate_write_cache cannot be changed when underlying"
+			" HW reports WriteCacheEnabled, ignoring request\n");
+		return 0;
+	}
+
 	dev->dev_attrib.emulate_write_cache = flag;
 	pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",
 			dev, dev->dev_attrib.emulate_write_cache);
  
  
  
  
@@ -1182,24 +1226,18 @@
  
 struct se_lun_acl *core_dev_init_initiator_node_lun_acl(
 	struct se_portal_group *tpg,
+	struct se_node_acl *nacl,
 	u32 mapped_lun,
-	char *initiatorname,
 	int *ret)
 {
 	struct se_lun_acl *lacl;
-	struct se_node_acl *nacl;
  
-	if (strlen(initiatorname) >= TRANSPORT_IQN_LEN) {
+	if (strlen(nacl->initiatorname) >= TRANSPORT_IQN_LEN) {
 		pr_err("%s InitiatorName exceeds maximum size.\n",
 			tpg->se_tpg_tfo->get_fabric_name());
 		*ret = -EOVERFLOW;
 		return NULL;
 	}
-	nacl = core_tpg_get_initiator_node_acl(tpg, initiatorname);
-	if (!nacl) {
-		*ret = -EINVAL;
-		return NULL;
-	}
 	lacl = kzalloc(sizeof(struct se_lun_acl), GFP_KERNEL);
 	if (!lacl) {
 		pr_err("Unable to allocate memory for struct se_lun_acl.\n");
@@ -1210,7 +1248,8 @@
 	INIT_LIST_HEAD(&lacl->lacl_list);
 	lacl->mapped_lun = mapped_lun;
 	lacl->se_lun_nacl = nacl;
-	snprintf(lacl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname);
+	snprintf(lacl->initiatorname, TRANSPORT_IQN_LEN, "%s",
+		 nacl->initiatorname);
  
 	return lacl;
 }
@@ -1390,6 +1429,7 @@
 	dev->t10_alua.t10_dev = dev;
  
 	dev->dev_attrib.da_dev = dev;
+	dev->dev_attrib.emulate_model_alias = DA_EMULATE_MODEL_ALIAS;
 	dev->dev_attrib.emulate_dpo = DA_EMULATE_DPO;
 	dev->dev_attrib.emulate_fua_write = DA_EMULATE_FUA_WRITE;
 	dev->dev_attrib.emulate_fua_read = DA_EMULATE_FUA_READ;
@@ -354,9 +354,17 @@
 		ret = -EINVAL;
 		goto out;
 	}
+	if (mapped_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
+		pr_err("Mapped LUN: %lu exceeds TRANSPORT_MAX_LUNS_PER_TPG"
+			"-1: %u for Target Portal Group: %u\n", mapped_lun,
+			TRANSPORT_MAX_LUNS_PER_TPG-1,
+			se_tpg->se_tpg_tfo->tpg_get_tag(se_tpg));
+		ret = -EINVAL;
+		goto out;
+	}
  
-	lacl = core_dev_init_initiator_node_lun_acl(se_tpg, mapped_lun,
-			config_item_name(acl_ci), &ret);
+	lacl = core_dev_init_initiator_node_lun_acl(se_tpg, se_nacl,
+			mapped_lun, &ret);
 	if (!lacl) {
 		ret = -EINVAL;
 		goto out;
@@ -190,6 +190,11 @@
  
 	fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++;
 	fd_dev->fd_queue_depth = dev->queue_depth;
+	/*
+	 * Limit WRITE_SAME w/ UNMAP=0 emulation to 8k Number of LBAs (NoLB)
+	 * based upon struct iovec limit for vfs_writev()
+	 */
+	dev->dev_attrib.max_write_same_len = 0x1000;
  
 	pr_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s,"
 		" %llu total bytes\n", fd_host->fd_host_id, fd_dev->fd_dev_id,
  
@@ -328,7 +333,115 @@
 	return 0;
 }
  
+static unsigned char *
+fd_setup_write_same_buf(struct se_cmd *cmd, struct scatterlist *sg,
+		    unsigned int len)
+{
+	struct se_device *se_dev = cmd->se_dev;
+	unsigned int block_size = se_dev->dev_attrib.block_size;
+	unsigned int i = 0, end;
+	unsigned char *buf, *p, *kmap_buf;
+
+	buf = kzalloc(min_t(unsigned int, len, PAGE_SIZE), GFP_KERNEL);
+	if (!buf) {
+		pr_err("Unable to allocate fd_execute_write_same buf\n");
+		return NULL;
+	}
+
+	kmap_buf = kmap(sg_page(sg)) + sg->offset;
+	if (!kmap_buf) {
+		pr_err("kmap() failed in fd_setup_write_same\n");
+		kfree(buf);
+		return NULL;
+	}
+	/*
+	 * Fill local *buf to contain multiple WRITE_SAME blocks up to
+	 * min(len, PAGE_SIZE)
+	 */
+	p = buf;
+	end = min_t(unsigned int, len, PAGE_SIZE);
+
+	while (i < end) {
+		memcpy(p, kmap_buf, block_size);
+
+		i += block_size;
+		p += block_size;
+	}
+	kunmap(sg_page(sg));
+
+	return buf;
+}
+
 static sense_reason_t
+fd_execute_write_same(struct se_cmd *cmd)
+{
+	struct se_device *se_dev = cmd->se_dev;
+	struct fd_dev *fd_dev = FD_DEV(se_dev);
+	struct file *f = fd_dev->fd_file;
+	struct scatterlist *sg;
+	struct iovec *iov;
+	mm_segment_t old_fs;
+	sector_t nolb = sbc_get_write_same_sectors(cmd);
+	loff_t pos = cmd->t_task_lba * se_dev->dev_attrib.block_size;
+	unsigned int len, len_tmp, iov_num;
+	int i, rc;
+	unsigned char *buf;
+
+	if (!nolb) {
+		target_complete_cmd(cmd, SAM_STAT_GOOD);
+		return 0;
+	}
+	sg = &cmd->t_data_sg[0];
+
+	if (cmd->t_data_nents > 1 ||
+	    sg->length != cmd->se_dev->dev_attrib.block_size) {
+		pr_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);
+		return TCM_INVALID_CDB_FIELD;
+	}
+
+	len = len_tmp = nolb * se_dev->dev_attrib.block_size;
+	iov_num = DIV_ROUND_UP(len, PAGE_SIZE);
+
+	buf = fd_setup_write_same_buf(cmd, sg, len);
+	if (!buf)
+		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+
+	iov = vzalloc(sizeof(struct iovec) * iov_num);
+	if (!iov) {
+		pr_err("Unable to allocate fd_execute_write_same iovecs\n");
+		kfree(buf);
+		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+	}
+	/*
+	 * Map the single fabric received scatterlist block now populated
+	 * in *buf into each iovec for I/O submission.
+	 */
+	for (i = 0; i < iov_num; i++) {
+		iov[i].iov_base = buf;
+		iov[i].iov_len = min_t(unsigned int, len_tmp, PAGE_SIZE);
+		len_tmp -= iov[i].iov_len;
+	}
+
+	old_fs = get_fs();
+	set_fs(get_ds());
+	rc = vfs_writev(f, &iov[0], iov_num, &pos);
+	set_fs(old_fs);
+
+	vfree(iov);
+	kfree(buf);
+
+	if (rc < 0 || rc != len) {
+		pr_err("vfs_writev() returned %d for write same\n", rc);
+		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
+	}
+
+	target_complete_cmd(cmd, SAM_STAT_GOOD);
+	return 0;
+}
+
+static sense_reason_t
 fd_execute_rw(struct se_cmd *cmd)
 {
 	struct scatterlist *sgl = cmd->t_data_sg;
@@ -486,6 +599,7 @@
 static struct sbc_ops fd_sbc_ops = {
 	.execute_rw		= fd_execute_rw,
 	.execute_sync_cache	= fd_execute_sync_cache,
+	.execute_write_same	= fd_execute_write_same,
 };
  
 static sense_reason_t
@@ -154,6 +154,7 @@
  
 	if (blk_queue_nonrot(q))
 		dev->dev_attrib.is_nonrot = 1;
+
 	return 0;
  
 out_free_bioset:
  
@@ -390,10 +391,19 @@
 	sense_reason_t ret = 0;
 	int dl, bd_dl, err;
  
+	/* We never set ANC_SUP */
+	if (cmd->t_task_cdb[1])
+		return TCM_INVALID_CDB_FIELD;
+
+	if (cmd->data_length == 0) {
+		target_complete_cmd(cmd, SAM_STAT_GOOD);
+		return 0;
+	}
+
 	if (cmd->data_length < 8) {
 		pr_warn("UNMAP parameter list length %u too small\n",
 			cmd->data_length);
-		return TCM_INVALID_PARAMETER_LIST;
+		return TCM_PARAMETER_LIST_LENGTH_ERROR;
 	}
  
 	buf = transport_kmap_data_sg(cmd);
@@ -463,7 +473,7 @@
 	int rc;
  
 	rc = blkdev_issue_discard(ib_dev->ibd_bd, cmd->t_task_lba,
-			spc_get_write_same_sectors(cmd), GFP_KERNEL, 0);
+			sbc_get_write_same_sectors(cmd), GFP_KERNEL, 0);
 	if (rc < 0) {
 		pr_warn("blkdev_issue_discard() failed: %d\n", rc);
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
@@ -481,7 +491,7 @@
 	struct bio *bio;
 	struct bio_list list;
 	sector_t block_lba = cmd->t_task_lba;
-	sector_t sectors = spc_get_write_same_sectors(cmd);
+	sector_t sectors = sbc_get_write_same_sectors(cmd);
  
 	sg = &cmd->t_data_sg[0];
  
  
  
  
  
@@ -654,20 +664,24 @@
 	u32 sg_num = sgl_nents;
 	sector_t block_lba;
 	unsigned bio_cnt;
-	int rw;
+	int rw = 0;
 	int i;
  
 	if (data_direction == DMA_TO_DEVICE) {
+		struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
+		struct request_queue *q = bdev_get_queue(ib_dev->ibd_bd);
 		/*
-		 * Force data to disk if we pretend to not have a volatile
-		 * write cache, or the initiator set the Force Unit Access bit.
+		 * Force writethrough using WRITE_FUA if a volatile write cache
+		 * is not enabled, or if initiator set the Force Unit Access bit.
 		 */
-		if (dev->dev_attrib.emulate_write_cache == 0 ||
-		    (dev->dev_attrib.emulate_fua_write > 0 &&
-		     (cmd->se_cmd_flags & SCF_FUA)))
-			rw = WRITE_FUA;
-		else
+		if (q->flush_flags & REQ_FUA) {
+			if (cmd->se_cmd_flags & SCF_FUA)
+				rw = WRITE_FUA;
+			else if (!(q->flush_flags & REQ_FLUSH))
+				rw = WRITE_FUA;
+		} else {
 			rw = WRITE;
+		}
 	} else {
 		rw = READ;
 	}
@@ -774,6 +788,15 @@
 	return sbc_parse_cdb(cmd, &iblock_sbc_ops);
 }
  
+bool iblock_get_write_cache(struct se_device *dev)
+{
+	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
+	struct block_device *bd = ib_dev->ibd_bd;
+	struct request_queue *q = bdev_get_queue(bd);
+
+	return q->flush_flags & REQ_FLUSH;
+}
+
 static struct se_subsystem_api iblock_template = {
 	.name			= "iblock",
 	.inquiry_prod		= "IBLOCK",
@@ -790,6 +813,7 @@
 	.show_configfs_dev_params = iblock_show_configfs_dev_params,
 	.get_device_type	= sbc_get_device_type,
 	.get_blocks		= iblock_get_blocks,
+	.get_write_cache	= iblock_get_write_cache,
 };
  
 static int __init iblock_module_init(void)
@@ -25,6 +25,7 @@
 int	se_dev_set_unmap_granularity(struct se_device *, u32);
 int	se_dev_set_unmap_granularity_alignment(struct se_device *, u32);
 int	se_dev_set_max_write_same_len(struct se_device *, u32);
+int	se_dev_set_emulate_model_alias(struct se_device *, int);
 int	se_dev_set_emulate_dpo(struct se_device *, int);
 int	se_dev_set_emulate_fua_write(struct se_device *, int);
 int	se_dev_set_emulate_fua_read(struct se_device *, int);
@@ -45,7 +46,7 @@
 int	core_dev_del_lun(struct se_portal_group *, u32);
 struct se_lun *core_get_lun_from_tpg(struct se_portal_group *, u32);
 struct se_lun_acl *core_dev_init_initiator_node_lun_acl(struct se_portal_group *,
-		u32, char *, int *);
+		struct se_node_acl *, u32, int *);
 int	core_dev_add_initiator_node_lun_acl(struct se_portal_group *,
 		struct se_lun_acl *, u32, u32);
 int	core_dev_del_initiator_node_lun_acl(struct se_portal_group *,
@@ -256,10 +256,12 @@
  
 static struct rd_dev_sg_table *rd_get_sg_table(struct rd_dev *rd_dev, u32 page)
 {
-	u32 i;
 	struct rd_dev_sg_table *sg_table;
+	u32 i, sg_per_table = (RD_MAX_ALLOCATION_SIZE /
+				sizeof(struct scatterlist));
  
-	for (i = 0; i < rd_dev->sg_table_count; i++) {
+	i = page / sg_per_table;
+	if (i < rd_dev->sg_table_count) {
 		sg_table = &rd_dev->sg_table_array[i];
 		if ((sg_table->page_start_offset <= page) &&
 		    (sg_table->page_end_offset >= page))
  
@@ -314,7 +316,19 @@
 		void *rd_addr;
  
 		sg_miter_next(&m);
+		if (!(u32)m.length) {
+			pr_debug("RD[%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) {
+			pr_debug("RD[%u]: size underrun page %d offset %d "
+				 "size %d\n", dev->rd_dev_id,
+				 rd_page, rd_offset, rd_size);
+			len = rd_size;
+		}
 		m.consumed = len;
  
 		rd_addr = sg_virt(rd_sg) + rd_offset;
@@ -105,7 +105,7 @@
 	return 0;
 }
  
-sector_t spc_get_write_same_sectors(struct se_cmd *cmd)
+sector_t sbc_get_write_same_sectors(struct se_cmd *cmd)
 {
 	u32 num_blocks;
  
@@ -126,7 +126,7 @@
 	return cmd->se_dev->transport->get_blocks(cmd->se_dev) -
 		cmd->t_task_lba + 1;
 }
-EXPORT_SYMBOL(spc_get_write_same_sectors);
+EXPORT_SYMBOL(sbc_get_write_same_sectors);
  
 static sense_reason_t
 sbc_emulate_noop(struct se_cmd *cmd)
@@ -233,7 +233,7 @@
 static sense_reason_t
 sbc_setup_write_same(struct se_cmd *cmd, unsigned char *flags, struct sbc_ops *ops)
 {
-	unsigned int sectors = spc_get_write_same_sectors(cmd);
+	unsigned int sectors = sbc_get_write_same_sectors(cmd);
  
 	if ((flags[0] & 0x04) || (flags[0] & 0x02)) {
 		pr_err("WRITE_SAME PBDATA and LBDATA"
@@ -486,7 +486,7 @@
 		 */
 		if (cmd->t_task_lba || sectors) {
 			if (sbc_check_valid_sectors(cmd) < 0)
-				return TCM_INVALID_CDB_FIELD;
+				return TCM_ADDRESS_OUT_OF_RANGE;
 		}
 		cmd->execute_cmd = ops->execute_sync_cache;
 		break;
@@ -66,8 +66,8 @@
 	spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 }
  
-static sense_reason_t
-spc_emulate_inquiry_std(struct se_cmd *cmd, char *buf)
+sense_reason_t
+spc_emulate_inquiry_std(struct se_cmd *cmd, unsigned char *buf)
 {
 	struct se_lun *lun = cmd->se_lun;
 	struct se_device *dev = cmd->se_dev;
@@ -104,6 +104,7 @@
  
 	return 0;
 }
+EXPORT_SYMBOL(spc_emulate_inquiry_std);
  
 /* unit serial number */
 static sense_reason_t
@@ -160,7 +161,7 @@
  * Device identification VPD, for a complete list of
  * DESIGNATOR TYPEs see spc4r17 Table 459.
  */
-static sense_reason_t
+sense_reason_t
 spc_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)
 {
 	struct se_device *dev = cmd->se_dev;
  
  
  
@@ -404,17 +405,33 @@
 	buf[3] = (len & 0xff); /* Page Length for VPD 0x83 */
 	return 0;
 }
+EXPORT_SYMBOL(spc_emulate_evpd_83);
  
+static bool
+spc_check_dev_wce(struct se_device *dev)
+{
+	bool wce = false;
+
+	if (dev->transport->get_write_cache)
+		wce = dev->transport->get_write_cache(dev);
+	else if (dev->dev_attrib.emulate_write_cache > 0)
+		wce = true;
+
+	return wce;
+}
+
 /* Extended INQUIRY Data VPD Page */
 static sense_reason_t
 spc_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf)
 {
+	struct se_device *dev = cmd->se_dev;
+
 	buf[3] = 0x3c;
 	/* Set HEADSUP, ORDSUP, SIMPSUP */
 	buf[5] = 0x07;
  
 	/* If WriteCache emulation is enabled, set V_SUP */
-	if (cmd->se_dev->dev_attrib.emulate_write_cache > 0)
+	if (spc_check_dev_wce(dev))
 		buf[6] = 0x01;
 	return 0;
 }
@@ -764,7 +781,7 @@
 	if (pc == 1)
 		goto out;
  
-	if (dev->dev_attrib.emulate_write_cache > 0)
+	if (spc_check_dev_wce(dev))
 		p[2] = 0x04; /* Write Cache Enable */
 	p[12] = 0x20; /* Disabled Read Ahead */
  
@@ -876,7 +893,7 @@
 	     (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)))
 		spc_modesense_write_protect(&buf[length], type);
  
-	if ((dev->dev_attrib.emulate_write_cache > 0) &&
+	if ((spc_check_dev_wce(dev)) &&
 	    (dev->dev_attrib.emulate_fua_write > 0))
 		spc_modesense_dpofua(&buf[length], type);
  
@@ -983,6 +1000,14 @@
 	int ret = 0;
 	int i;
  
+	if (!cmd->data_length) {
+		target_complete_cmd(cmd, GOOD);
+		return 0;
+	}
+
+	if (cmd->data_length < off + 2)
+		return TCM_PARAMETER_LIST_LENGTH_ERROR;
+
 	buf = transport_kmap_data_sg(cmd);
 	if (!buf)
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
@@ -1007,6 +1032,11 @@
 	goto out;
  
 check_contents:
+	if (cmd->data_length < off + length) {
+		ret = TCM_PARAMETER_LIST_LENGTH_ERROR;
+		goto out;
+	}
+
 	if (memcmp(buf + off, tbuf, length))
 		ret = TCM_INVALID_PARAMETER_LIST;
  
@@ -331,18 +331,6 @@
  
 		fe_count = atomic_read(&cmd->t_fe_count);
  
-		if (!(cmd->transport_state & CMD_T_ACTIVE)) {
-			pr_debug("LUN_RESET: got CMD_T_ACTIVE for"
-				" cdb: %p, t_fe_count: %d dev: %p\n", cmd,
-				fe_count, dev);
-			cmd->transport_state |= CMD_T_ABORTED;
-			spin_unlock_irqrestore(&cmd->t_state_lock, flags);
-
-			core_tmr_handle_tas_abort(tmr_nacl, cmd, tas, fe_count);
-			continue;
-		}
-		pr_debug("LUN_RESET: Got !CMD_T_ACTIVE for cdb: %p,"
-			" t_fe_count: %d dev: %p\n", cmd, fe_count, dev);
 		cmd->transport_state |= CMD_T_ABORTED;
 		spin_unlock_irqrestore(&cmd->t_state_lock, flags);
  
@@ -111,16 +111,10 @@
 	struct se_node_acl *acl;
  
 	spin_lock_irq(&tpg->acl_node_lock);
-	list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {
-		if (!strcmp(acl->initiatorname, initiatorname) &&
-		    !acl->dynamic_node_acl) {
-			spin_unlock_irq(&tpg->acl_node_lock);
-			return acl;
-		}
-	}
+	acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
 	spin_unlock_irq(&tpg->acl_node_lock);
  
-	return NULL;
+	return acl;
 }
  
 /*	core_tpg_add_node_to_devs():
@@ -907,15 +907,18 @@
  
 	switch (vpd->device_identifier_code_set) {
 	case 0x01: /* Binary */
-		sprintf(buf, "T10 VPD Binary Device Identifier: %s\n",
+		snprintf(buf, sizeof(buf),
+			"T10 VPD Binary Device Identifier: %s\n",
 			&vpd->device_identifier[0]);
 		break;
 	case 0x02: /* ASCII */
-		sprintf(buf, "T10 VPD ASCII Device Identifier: %s\n",
+		snprintf(buf, sizeof(buf),
+			"T10 VPD ASCII Device Identifier: %s\n",
 			&vpd->device_identifier[0]);
 		break;
 	case 0x03: /* UTF-8 */
-		sprintf(buf, "T10 VPD UTF-8 Device Identifier: %s\n",
+		snprintf(buf, sizeof(buf),
+			"T10 VPD UTF-8 Device Identifier: %s\n",
 			&vpd->device_identifier[0]);
 		break;
 	default:
@@ -1514,6 +1517,7 @@
 	case TCM_UNSUPPORTED_SCSI_OPCODE:
 	case TCM_INVALID_CDB_FIELD:
 	case TCM_INVALID_PARAMETER_LIST:
+	case TCM_PARAMETER_LIST_LENGTH_ERROR:
 	case TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE:
 	case TCM_UNKNOWN_MODE_PAGE:
 	case TCM_WRITE_PROTECTED:
@@ -2673,6 +2677,15 @@
 		buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST;
 		/* INVALID FIELD IN PARAMETER LIST */
 		buffer[SPC_ASC_KEY_OFFSET] = 0x26;
+		break;
+	case TCM_PARAMETER_LIST_LENGTH_ERROR:
+		/* CURRENT ERROR */
+		buffer[0] = 0x70;
+		buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10;
+		/* ILLEGAL REQUEST */
+		buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST;
+		/* PARAMETER LIST LENGTH ERROR */
+		buffer[SPC_ASC_KEY_OFFSET] = 0x1a;
 		break;
 	case TCM_UNEXPECTED_UNSOLICITED_DATA:
 		/* CURRENT ERROR */
@@ -47,6 +47,8 @@
 #include <linux/vhost.h>
 #include <linux/virtio_net.h> /* TODO vhost.h currently depends on this */
 #include <linux/virtio_scsi.h>
+#include <linux/llist.h>
+#include <linux/bitmap.h>
  
 #include "vhost.c"
 #include "vhost.h"
  
  
  
@@ -58,14 +60,20 @@
 	VHOST_SCSI_VQ_IO = 2,
 };
  
+#define VHOST_SCSI_MAX_TARGET	256
+#define VHOST_SCSI_MAX_VQ	128
+
 struct vhost_scsi {
-	struct tcm_vhost_tpg *vs_tpg;	/* Protected by vhost_scsi->dev.mutex */
+	/* Protected by vhost_scsi->dev.mutex */
+	struct tcm_vhost_tpg *vs_tpg[VHOST_SCSI_MAX_TARGET];
+	char vs_vhost_wwpn[TRANSPORT_IQN_LEN];
+	bool vs_endpoint;
+
 	struct vhost_dev dev;
-	struct vhost_virtqueue vqs[3];
+	struct vhost_virtqueue vqs[VHOST_SCSI_MAX_VQ];
  
 	struct vhost_work vs_completion_work; /* cmd completion work item */
-	struct list_head vs_completion_list;  /* cmd completion queue */
-	spinlock_t vs_completion_lock;        /* protects s_completion_list */
+	struct llist_head vs_completion_list; /* cmd completion queue */
 };
  
 /* Local pointer to allocated TCM configfs fabric module */
@@ -77,6 +85,12 @@
 static DEFINE_MUTEX(tcm_vhost_mutex);
 static LIST_HEAD(tcm_vhost_list);
  
+static int iov_num_pages(struct iovec *iov)
+{
+	return (PAGE_ALIGN((unsigned long)iov->iov_base + iov->iov_len) -
+	       ((unsigned long)iov->iov_base & PAGE_MASK)) >> PAGE_SHIFT;
+}
+
 static int tcm_vhost_check_true(struct se_portal_group *se_tpg)
 {
 	return 1;
@@ -301,9 +315,7 @@
 {
 	struct vhost_scsi *vs = tv_cmd->tvc_vhost;
  
-	spin_lock_bh(&vs->vs_completion_lock);
-	list_add_tail(&tv_cmd->tvc_completion_list, &vs->vs_completion_list);
-	spin_unlock_bh(&vs->vs_completion_lock);
+	llist_add(&tv_cmd->tvc_completion_list, &vs->vs_completion_list);
  
 	vhost_work_queue(&vs->dev, &vs->vs_completion_work);
 }
@@ -347,27 +359,6 @@
 	kfree(tv_cmd);
 }
  
-/* Dequeue a command from the completion list */
-static struct tcm_vhost_cmd *vhost_scsi_get_cmd_from_completion(
-	struct vhost_scsi *vs)
-{
-	struct tcm_vhost_cmd *tv_cmd = NULL;
-
-	spin_lock_bh(&vs->vs_completion_lock);
-	if (list_empty(&vs->vs_completion_list)) {
-		spin_unlock_bh(&vs->vs_completion_lock);
-		return NULL;
-	}
-
-	list_for_each_entry(tv_cmd, &vs->vs_completion_list,
-			    tvc_completion_list) {
-		list_del(&tv_cmd->tvc_completion_list);
-		break;
-	}
-	spin_unlock_bh(&vs->vs_completion_lock);
-	return tv_cmd;
-}
-
 /* Fill in status and signal that we are done processing this command
  *
  * This is scheduled in the vhost work queue so we are called with the owner
  
  
@@ -377,12 +368,20 @@
 {
 	struct vhost_scsi *vs = container_of(work, struct vhost_scsi,
 					vs_completion_work);
+	DECLARE_BITMAP(signal, VHOST_SCSI_MAX_VQ);
+	struct virtio_scsi_cmd_resp v_rsp;
 	struct tcm_vhost_cmd *tv_cmd;
+	struct llist_node *llnode;
+	struct se_cmd *se_cmd;
+	int ret, vq;
  
-	while ((tv_cmd = vhost_scsi_get_cmd_from_completion(vs))) {
-		struct virtio_scsi_cmd_resp v_rsp;
-		struct se_cmd *se_cmd = &tv_cmd->tvc_se_cmd;
-		int ret;
+	bitmap_zero(signal, VHOST_SCSI_MAX_VQ);
+	llnode = llist_del_all(&vs->vs_completion_list);
+	while (llnode) {
+		tv_cmd = llist_entry(llnode, struct tcm_vhost_cmd,
+				     tvc_completion_list);
+		llnode = llist_next(llnode);
+		se_cmd = &tv_cmd->tvc_se_cmd;
  
 		pr_debug("%s tv_cmd %p resid %u status %#02x\n", __func__,
 			tv_cmd, se_cmd->residual_count, se_cmd->scsi_status);
  
@@ -395,15 +394,20 @@
 		memcpy(v_rsp.sense, tv_cmd->tvc_sense_buf,
 		       v_rsp.sense_len);
 		ret = copy_to_user(tv_cmd->tvc_resp, &v_rsp, sizeof(v_rsp));
-		if (likely(ret == 0))
-			vhost_add_used(&vs->vqs[2], tv_cmd->tvc_vq_desc, 0);
-		else
+		if (likely(ret == 0)) {
+			vhost_add_used(tv_cmd->tvc_vq, tv_cmd->tvc_vq_desc, 0);
+			vq = tv_cmd->tvc_vq - vs->vqs;
+			__set_bit(vq, signal);
+		} else
 			pr_err("Faulted on virtio_scsi_cmd_resp\n");
  
 		vhost_scsi_free_cmd(tv_cmd);
 	}
  
-	vhost_signal(&vs->dev, &vs->vqs[2]);
+	vq = -1;
+	while ((vq = find_next_bit(signal, VHOST_SCSI_MAX_VQ, vq + 1))
+		< VHOST_SCSI_MAX_VQ)
+		vhost_signal(&vs->dev, &vs->vqs[vq]);
 }
  
 static struct tcm_vhost_cmd *vhost_scsi_allocate_cmd(
@@ -426,7 +430,6 @@
 		pr_err("Unable to allocate struct tcm_vhost_cmd\n");
 		return ERR_PTR(-ENOMEM);
 	}
-	INIT_LIST_HEAD(&tv_cmd->tvc_completion_list);
 	tv_cmd->tvc_tag = v_req->tag;
 	tv_cmd->tvc_task_attr = v_req->task_attr;
 	tv_cmd->tvc_exp_data_len = exp_data_len;
  
  
  
  
  
  
  
  
@@ -442,40 +445,47 @@
  * Returns the number of scatterlist entries used or -errno on error.
  */
 static int vhost_scsi_map_to_sgl(struct scatterlist *sgl,
-	unsigned int sgl_count, void __user *ptr, size_t len, int write)
+	unsigned int sgl_count, struct iovec *iov, int write)
 {
+	unsigned int npages = 0, pages_nr, offset, nbytes;
 	struct scatterlist *sg = sgl;
-	unsigned int npages = 0;
-	int ret;
+	void __user *ptr = iov->iov_base;
+	size_t len = iov->iov_len;
+	struct page **pages;
+	int ret, i;
  
-	while (len > 0) {
-		struct page *page;
-		unsigned int offset = (uintptr_t)ptr & ~PAGE_MASK;
-		unsigned int nbytes = min_t(unsigned int,
-				PAGE_SIZE - offset, len);
+	pages_nr = iov_num_pages(iov);
+	if (pages_nr > sgl_count)
+		return -ENOBUFS;
  
-		if (npages == sgl_count) {
-			ret = -ENOBUFS;
-			goto err;
-		}
+	pages = kmalloc(pages_nr * sizeof(struct page *), GFP_KERNEL);
+	if (!pages)
+		return -ENOMEM;
  
-		ret = get_user_pages_fast((unsigned long)ptr, 1, write, &page);
-		BUG_ON(ret == 0); /* we should either get our page or fail */
-		if (ret < 0)
-			goto err;
+	ret = get_user_pages_fast((unsigned long)ptr, pages_nr, write, pages);
+	/* No pages were pinned */
+	if (ret < 0)
+		goto out;
+	/* Less pages pinned than wanted */
+	if (ret != pages_nr) {
+		for (i = 0; i < ret; i++)
+			put_page(pages[i]);
+		ret = -EFAULT;
+		goto out;
+	}
  
-		sg_set_page(sg, page, nbytes, offset);
+	while (len > 0) {
+		offset = (uintptr_t)ptr & ~PAGE_MASK;
+		nbytes = min_t(unsigned int, PAGE_SIZE - offset, len);
+		sg_set_page(sg, pages[npages], nbytes, offset);
 		ptr += nbytes;
 		len -= nbytes;
 		sg++;
 		npages++;
 	}
-	return npages;
  
-err:
-	/* Put pages that we hold */
-	for (sg = sgl; sg != &sgl[npages]; sg++)
-		put_page(sg_page(sg));
+out:
+	kfree(pages);
 	return ret;
 }
  
@@ -491,11 +501,9 @@
 	 * Find out how long sglist needs to be
 	 */
 	sgl_count = 0;
-	for (i = 0; i < niov; i++) {
-		sgl_count += (((uintptr_t)iov[i].iov_base + iov[i].iov_len +
-				PAGE_SIZE - 1) >> PAGE_SHIFT) -
-				((uintptr_t)iov[i].iov_base >> PAGE_SHIFT);
-	}
+	for (i = 0; i < niov; i++)
+		sgl_count += iov_num_pages(&iov[i]);
+
 	/* TODO overflow checking */
  
 	sg = kmalloc(sizeof(tv_cmd->tvc_sgl[0]) * sgl_count, GFP_ATOMIC);
@@ -510,8 +518,7 @@
  
 	pr_debug("Mapping %u iovecs for %u pages\n", niov, sgl_count);
 	for (i = 0; i < niov; i++) {
-		ret = vhost_scsi_map_to_sgl(sg, sgl_count, iov[i].iov_base,
-					iov[i].iov_len, write);
+		ret = vhost_scsi_map_to_sgl(sg, sgl_count, &iov[i], write);
 		if (ret < 0) {
 			for (i = 0; i < tv_cmd->tvc_sgl_count; i++)
 				put_page(sg_page(&tv_cmd->tvc_sgl[i]));
  
  
  
@@ -563,19 +570,19 @@
 	}
 }
  
-static void vhost_scsi_handle_vq(struct vhost_scsi *vs)
+static void vhost_scsi_handle_vq(struct vhost_scsi *vs,
+	struct vhost_virtqueue *vq)
 {
-	struct vhost_virtqueue *vq = &vs->vqs[2];
 	struct virtio_scsi_cmd_req v_req;
 	struct tcm_vhost_tpg *tv_tpg;
 	struct tcm_vhost_cmd *tv_cmd;
 	u32 exp_data_len, data_first, data_num, data_direction;
 	unsigned out, in, i;
 	int head, ret;
+	u8 target;
  
 	/* Must use ioctl VHOST_SCSI_SET_ENDPOINT */
-	tv_tpg = vs->vs_tpg;
-	if (unlikely(!tv_tpg))
+	if (unlikely(!vs->vs_endpoint))
 		return;
  
 	mutex_lock(&vq->mutex);
@@ -643,6 +650,28 @@
 			break;
 		}
  
+		/* Extract the tpgt */
+		target = v_req.lun[1];
+		tv_tpg = vs->vs_tpg[target];
+
+		/* Target does not exist, fail the request */
+		if (unlikely(!tv_tpg)) {
+			struct virtio_scsi_cmd_resp __user *resp;
+			struct virtio_scsi_cmd_resp rsp;
+
+			memset(&rsp, 0, sizeof(rsp));
+			rsp.response = VIRTIO_SCSI_S_BAD_TARGET;
+			resp = vq->iov[out].iov_base;
+			ret = __copy_to_user(resp, &rsp, sizeof(rsp));
+			if (!ret)
+				vhost_add_used_and_signal(&vs->dev,
+							  vq, head, 0);
+			else
+				pr_err("Faulted on virtio_scsi_cmd_resp\n");
+
+			continue;
+		}
+
 		exp_data_len = 0;
 		for (i = 0; i < data_num; i++)
 			exp_data_len += vq->iov[data_first + i].iov_len;
@@ -658,6 +687,7 @@
 			": %d\n", tv_cmd, exp_data_len, data_direction);
  
 		tv_cmd->tvc_vhost = vs;
+		tv_cmd->tvc_vq = vq;
  
 		if (unlikely(vq->iov[out].iov_len !=
 				sizeof(struct virtio_scsi_cmd_resp))) {
@@ -738,7 +768,7 @@
 						poll.work);
 	struct vhost_scsi *vs = container_of(vq->dev, struct vhost_scsi, dev);
  
-	vhost_scsi_handle_vq(vs);
+	vhost_scsi_handle_vq(vs, vq);
 }
  
 /*
@@ -751,7 +781,8 @@
 {
 	struct tcm_vhost_tport *tv_tport;
 	struct tcm_vhost_tpg *tv_tpg;
-	int index;
+	bool match = false;
+	int index, ret;
  
 	mutex_lock(&vs->dev.mutex);
 	/* Verify that ring has been setup correctly. */
@@ -762,7 +793,6 @@
 			return -EFAULT;
 		}
 	}
-	mutex_unlock(&vs->dev.mutex);
  
 	mutex_lock(&tcm_vhost_mutex);
 	list_for_each_entry(tv_tpg, &tcm_vhost_list, tv_tpg_list) {
  
  
  
  
@@ -777,30 +807,33 @@
 		}
 		tv_tport = tv_tpg->tport;
  
-		if (!strcmp(tv_tport->tport_name, t->vhost_wwpn) &&
-		    (tv_tpg->tport_tpgt == t->vhost_tpgt)) {
-			tv_tpg->tv_tpg_vhost_count++;
-			mutex_unlock(&tv_tpg->tv_tpg_mutex);
-			mutex_unlock(&tcm_vhost_mutex);
-
-			mutex_lock(&vs->dev.mutex);
-			if (vs->vs_tpg) {
-				mutex_unlock(&vs->dev.mutex);
-				mutex_lock(&tv_tpg->tv_tpg_mutex);
-				tv_tpg->tv_tpg_vhost_count--;
+		if (!strcmp(tv_tport->tport_name, t->vhost_wwpn)) {
+			if (vs->vs_tpg[tv_tpg->tport_tpgt]) {
 				mutex_unlock(&tv_tpg->tv_tpg_mutex);
+				mutex_unlock(&tcm_vhost_mutex);
+				mutex_unlock(&vs->dev.mutex);
 				return -EEXIST;
 			}
-
-			vs->vs_tpg = tv_tpg;
+			tv_tpg->tv_tpg_vhost_count++;
+			vs->vs_tpg[tv_tpg->tport_tpgt] = tv_tpg;
 			smp_mb__after_atomic_inc();
-			mutex_unlock(&vs->dev.mutex);
-			return 0;
+			match = true;
 		}
 		mutex_unlock(&tv_tpg->tv_tpg_mutex);
 	}
 	mutex_unlock(&tcm_vhost_mutex);
-	return -EINVAL;
+
+	if (match) {
+		memcpy(vs->vs_vhost_wwpn, t->vhost_wwpn,
+		       sizeof(vs->vs_vhost_wwpn));
+		vs->vs_endpoint = true;
+		ret = 0;
+	} else {
+		ret = -EEXIST;
+	}
+
+	mutex_unlock(&vs->dev.mutex);
+	return ret;
 }
  
 static int vhost_scsi_clear_endpoint(
@@ -809,7 +842,8 @@
 {
 	struct tcm_vhost_tport *tv_tport;
 	struct tcm_vhost_tpg *tv_tpg;
-	int index, ret;
+	int index, ret, i;
+	u8 target;
  
 	mutex_lock(&vs->dev.mutex);
 	/* Verify that ring has been setup correctly. */
  
  
  
  
@@ -819,27 +853,32 @@
 			goto err;
 		}
 	}
+	for (i = 0; i < VHOST_SCSI_MAX_TARGET; i++) {
+		target = i;
  
-	if (!vs->vs_tpg) {
-		ret = -ENODEV;
-		goto err;
-	}
-	tv_tpg = vs->vs_tpg;
-	tv_tport = tv_tpg->tport;
+		tv_tpg = vs->vs_tpg[target];
+		if (!tv_tpg)
+			continue;
  
-	if (strcmp(tv_tport->tport_name, t->vhost_wwpn) ||
-	    (tv_tpg->tport_tpgt != t->vhost_tpgt)) {
-		pr_warn("tv_tport->tport_name: %s, tv_tpg->tport_tpgt: %hu"
-			" does not match t->vhost_wwpn: %s, t->vhost_tpgt: %hu\n",
-			tv_tport->tport_name, tv_tpg->tport_tpgt,
-			t->vhost_wwpn, t->vhost_tpgt);
-		ret = -EINVAL;
-		goto err;
+		tv_tport = tv_tpg->tport;
+		if (!tv_tport) {
+			ret = -ENODEV;
+			goto err;
+		}
+
+		if (strcmp(tv_tport->tport_name, t->vhost_wwpn)) {
+			pr_warn("tv_tport->tport_name: %s, tv_tpg->tport_tpgt: %hu"
+				" does not match t->vhost_wwpn: %s, t->vhost_tpgt: %hu\n",
+				tv_tport->tport_name, tv_tpg->tport_tpgt,
+				t->vhost_wwpn, t->vhost_tpgt);
+			ret = -EINVAL;
+			goto err;
+		}
+		tv_tpg->tv_tpg_vhost_count--;
+		vs->vs_tpg[target] = NULL;
+		vs->vs_endpoint = false;
 	}
-	tv_tpg->tv_tpg_vhost_count--;
-	vs->vs_tpg = NULL;
 	mutex_unlock(&vs->dev.mutex);
-
 	return 0;
  
 err:
  
  
@@ -850,20 +889,19 @@
 static int vhost_scsi_open(struct inode *inode, struct file *f)
 {
 	struct vhost_scsi *s;
-	int r;
+	int r, i;
  
 	s = kzalloc(sizeof(*s), GFP_KERNEL);
 	if (!s)
 		return -ENOMEM;
  
 	vhost_work_init(&s->vs_completion_work, vhost_scsi_complete_cmd_work);
-	INIT_LIST_HEAD(&s->vs_completion_list);
-	spin_lock_init(&s->vs_completion_lock);
  
 	s->vqs[VHOST_SCSI_VQ_CTL].handle_kick = vhost_scsi_ctl_handle_kick;
 	s->vqs[VHOST_SCSI_VQ_EVT].handle_kick = vhost_scsi_evt_handle_kick;
-	s->vqs[VHOST_SCSI_VQ_IO].handle_kick = vhost_scsi_handle_kick;
-	r = vhost_dev_init(&s->dev, s->vqs, 3);
+	for (i = VHOST_SCSI_VQ_IO; i < VHOST_SCSI_MAX_VQ; i++)
+		s->vqs[i].handle_kick = vhost_scsi_handle_kick;
+	r = vhost_dev_init(&s->dev, s->vqs, VHOST_SCSI_MAX_VQ);
 	if (r < 0) {
 		kfree(s);
 		return r;
  
@@ -876,16 +914,12 @@
 static int vhost_scsi_release(struct inode *inode, struct file *f)
 {
 	struct vhost_scsi *s = f->private_data;
+	struct vhost_scsi_target t;
  
-	if (s->vs_tpg && s->vs_tpg->tport) {
-		struct vhost_scsi_target backend;
-
-		memcpy(backend.vhost_wwpn, s->vs_tpg->tport->tport_name,
-				sizeof(backend.vhost_wwpn));
-		backend.vhost_tpgt = s->vs_tpg->tport_tpgt;
-		vhost_scsi_clear_endpoint(s, &backend);
-	}
-
+	mutex_lock(&s->dev.mutex);
+	memcpy(t.vhost_wwpn, s->vs_vhost_wwpn, sizeof(t.vhost_wwpn));
+	mutex_unlock(&s->dev.mutex);
+	vhost_scsi_clear_endpoint(s, &t);
 	vhost_dev_stop(&s->dev);
 	vhost_dev_cleanup(&s->dev, false);
 	kfree(s);
@@ -899,9 +933,10 @@
  
 static void vhost_scsi_flush(struct vhost_scsi *vs)
 {
-	vhost_scsi_flush_vq(vs, VHOST_SCSI_VQ_CTL);
-	vhost_scsi_flush_vq(vs, VHOST_SCSI_VQ_EVT);
-	vhost_scsi_flush_vq(vs, VHOST_SCSI_VQ_IO);
+	int i;
+
+	for (i = 0; i < VHOST_SCSI_MAX_VQ; i++)
+		vhost_scsi_flush_vq(vs, i);
 }
  
 static int vhost_scsi_set_features(struct vhost_scsi *vs, u64 features)
@@ -23,6 +23,8 @@
 	struct virtio_scsi_cmd_resp __user *tvc_resp;
 	/* Pointer to vhost_scsi for our device */
 	struct vhost_scsi *tvc_vhost;
+	/* Pointer to vhost_virtqueue for the cmd */
+	struct vhost_virtqueue *tvc_vq;
 	/* Pointer to vhost nexus memory */
 	struct tcm_vhost_nexus *tvc_nexus;
 	/* The TCM I/O descriptor that is accessed via container_of() */
@@ -34,7 +36,7 @@
 	/* Sense buffer that will be mapped into outgoing status */
 	unsigned char tvc_sense_buf[TRANSPORT_SENSE_BUFFER];
 	/* Completed commands list, serviced from vhost worker thread */
-	struct list_head tvc_completion_list;
+	struct llist_node tvc_completion_list;
 };
  
 struct tcm_vhost_nexus {
  
@@ -93,9 +95,11 @@
  *
  * ABI Rev 0: July 2012 version starting point for v3.6-rc merge candidate +
  *            RFC-v2 vhost-scsi userspace.  Add GET_ABI_VERSION ioctl usage
+ * ABI Rev 1: January 2013. Ignore vhost_tpgt filed in struct vhost_scsi_target.
+ *            All the targets under vhost_wwpn can be seen and used by guset.
  */
  
-#define VHOST_SCSI_ABI_VERSION	0
+#define VHOST_SCSI_ABI_VERSION	1
  
 struct vhost_scsi_target {
 	int abi_version;
@@ -35,6 +35,7 @@
 	u32 (*get_device_type)(struct se_device *);
 	sector_t (*get_blocks)(struct se_device *);
 	unsigned char *(*get_sense_buffer)(struct se_cmd *);
+	bool (*get_write_cache)(struct se_device *);
 };
  
 struct sbc_ops {
  
@@ -52,11 +53,13 @@
  
 sense_reason_t	spc_parse_cdb(struct se_cmd *cmd, unsigned int *size);
 sense_reason_t	spc_emulate_report_luns(struct se_cmd *cmd);
-sector_t	spc_get_write_same_sectors(struct se_cmd *cmd);
+sense_reason_t	spc_emulate_inquiry_std(struct se_cmd *, unsigned char *);
+sense_reason_t	spc_emulate_evpd_83(struct se_cmd *, unsigned char *);
  
 sense_reason_t	sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops);
 u32	sbc_get_device_rev(struct se_device *dev);
 u32	sbc_get_device_type(struct se_device *dev);
+sector_t	sbc_get_write_same_sectors(struct se_cmd *cmd);
  
 void	transport_set_vpd_proto_id(struct t10_vpd *, unsigned char *);
 int	transport_set_vpd_assoc(struct t10_vpd *, unsigned char *);
@@ -44,7 +44,7 @@
 /* Used by core_alua_store_tg_pt_gp_info() and target_core_alua_tg_pt_gp_show_attr_members() */
 #define TG_PT_GROUP_NAME_BUF			256
 /* Used to parse VPD into struct t10_vpd */
-#define VPD_TMP_BUF_SIZE			128
+#define VPD_TMP_BUF_SIZE			254
 /* Used by transport_generic_cmd_sequencer() */
 #define READ_BLOCK_LEN          		6
 #define READ_CAP_LEN            		8
@@ -75,6 +75,8 @@
 #define DA_MAX_WRITE_SAME_LEN			0
 /* Default max transfer length */
 #define DA_FABRIC_MAX_SECTORS			8192
+/* Use a model alias based on the configfs backend device name */
+#define DA_EMULATE_MODEL_ALIAS			0
 /* Emulation for Direct Page Out */
 #define DA_EMULATE_DPO				0
 /* Emulation for Forced Unit Access WRITEs */
@@ -193,6 +195,7 @@
 	TCM_RESERVATION_CONFLICT		= R(0x10),
 	TCM_ADDRESS_OUT_OF_RANGE		= R(0x11),
 	TCM_OUT_OF_RESOURCES			= R(0x12),
+	TCM_PARAMETER_LIST_LENGTH_ERROR		= R(0x13),
 #undef R
 };
  
@@ -211,7 +214,6 @@
 	TMR_LUN_RESET		= 5,
 	TMR_TARGET_WARM_RESET	= 6,
 	TMR_TARGET_COLD_RESET	= 7,
-	TMR_FABRIC_TMR		= 255,
 };
  
 /* fabric independent task management response values */
@@ -592,6 +594,7 @@
 };
  
 struct se_dev_attrib {
+	int		emulate_model_alias;
 	int		emulate_dpo;
 	int		emulate_fua_write;
 	int		emulate_fua_read;
...	...	@@ -264,16 +264,50 @@
264	264	return 0;
265	265	}
266	266
267		-static struct iscsi_np *iscsit_get_np(
	267	+bool iscsit_check_np_match(
268	268	struct __kernel_sockaddr_storage *sockaddr,
	269	+ struct iscsi_np *np,
269	270	int network_transport)
270	271	{
271	272	struct sockaddr_in sock_in, sock_in_e;
272	273	struct sockaddr_in6 sock_in6, sock_in6_e;
273		- struct iscsi_np *np;
274		- int ip_match = 0;
	274	+ bool ip_match = false;
275	275	u16 port;
276	276
	277	+ if (sockaddr->ss_family == AF_INET6) {
	278	+ sock_in6 = (struct sockaddr_in6 *)sockaddr;
	279	+ sock_in6_e = (struct sockaddr_in6 *)&np->np_sockaddr;
	280	+
	281	+ if (!memcmp(&sock_in6->sin6_addr.in6_u,
	282	+ &sock_in6_e->sin6_addr.in6_u,
	283	+ sizeof(struct in6_addr)))
	284	+ ip_match = true;
	285	+
	286	+ port = ntohs(sock_in6->sin6_port);
	287	+ } else {
	288	+ sock_in = (struct sockaddr_in *)sockaddr;
	289	+ sock_in_e = (struct sockaddr_in *)&np->np_sockaddr;
	290	+
	291	+ if (sock_in->sin_addr.s_addr == sock_in_e->sin_addr.s_addr)
	292	+ ip_match = true;
	293	+
	294	+ port = ntohs(sock_in->sin_port);
	295	+ }
	296	+
	297	+ if ((ip_match == true) && (np->np_port == port) &&
	298	+ (np->np_network_transport == network_transport))
	299	+ return true;
	300	+
	301	+ return false;
	302	+}
	303	+
	304	+static struct iscsi_np *iscsit_get_np(
	305	+ struct __kernel_sockaddr_storage *sockaddr,
	306	+ int network_transport)
	307	+{
	308	+ struct iscsi_np *np;
	309	+ bool match;
	310	+
277	311	spin_lock_bh(&np_lock);
278	312	list_for_each_entry(np, &g_np_list, np_list) {
279	313	spin_lock(&np->np_thread_lock);
...	...	@@ -282,29 +316,8 @@
282	316	continue;
283	317	}
284	318
285		- if (sockaddr->ss_family == AF_INET6) {
286		- sock_in6 = (struct sockaddr_in6 *)sockaddr;
287		- sock_in6_e = (struct sockaddr_in6 *)&np->np_sockaddr;
288		-
289		- if (!memcmp(&sock_in6->sin6_addr.in6_u,
290		- &sock_in6_e->sin6_addr.in6_u,
291		- sizeof(struct in6_addr)))
292		- ip_match = 1;
293		-
294		- port = ntohs(sock_in6->sin6_port);
295		- } else {
296		- sock_in = (struct sockaddr_in *)sockaddr;
297		- sock_in_e = (struct sockaddr_in *)&np->np_sockaddr;
298		-
299		- if (sock_in->sin_addr.s_addr ==
300		- sock_in_e->sin_addr.s_addr)
301		- ip_match = 1;
302		-
303		- port = ntohs(sock_in->sin_port);
304		- }
305		-
306		- if ((ip_match == 1) && (np->np_port == port) &&
307		- (np->np_network_transport == network_transport)) {
	319	+ match = iscsit_check_np_match(sockaddr, np, network_transport);
	320	+ if (match == true) {
308	321	/*
309	322	* Increment the np_exports reference count now to
310	323	* prevent iscsit_del_np() below from being called
...	...	@@ -8,6 +8,8 @@
8	8	extern void iscsit_del_tiqn(struct iscsi_tiqn *);
9	9	extern int iscsit_access_np(struct iscsi_np , struct iscsi_portal_group );
10	10	extern int iscsit_deaccess_np(struct iscsi_np , struct iscsi_portal_group );
	11	+extern bool iscsit_check_np_match(struct __kernel_sockaddr_storage *,
	12	+ struct iscsi_np *, int);
11	13	extern struct iscsi_np iscsit_add_np(struct __kernel_sockaddr_storage ,
12	14	char *, int);
13	15	extern int iscsit_reset_np_thread(struct iscsi_np , struct iscsi_tpg_np ,
...	...	@@ -1095,11 +1095,11 @@
1095	1095	SET_PSTATE_REPLY_OPTIONAL(param);
1096	1096	}
1097	1097	} else if (IS_TYPE_NUMBER(param)) {
1098		- char *tmpptr, buf[10];
	1098	+ char *tmpptr, buf[11];
1099	1099	u32 acceptor_value = simple_strtoul(param->value, &tmpptr, 0);
1100	1100	u32 proposer_value = simple_strtoul(value, &tmpptr, 0);
1101	1101
1102		- memset(buf, 0, 10);
	1102	+ memset(buf, 0, sizeof(buf));
1103	1103
1104	1104	if (!strcmp(param->name, MAXCONNECTIONS) \|\|
1105	1105	!strcmp(param->name, MAXBURSTLENGTH) \|\|
...	...	@@ -1503,8 +1503,8 @@
1503	1503	FirstBurstLength = simple_strtoul(param->value,
1504	1504	&tmpptr, 0);
1505	1505	if (FirstBurstLength > MaxBurstLength) {
1506		- char tmpbuf[10];
1507		- memset(tmpbuf, 0, 10);
	1506	+ char tmpbuf[11];
	1507	+ memset(tmpbuf, 0, sizeof(tmpbuf));
1508	1508	sprintf(tmpbuf, "%u", MaxBurstLength);
1509	1509	if (iscsi_update_param_value(param, tmpbuf))
1510	1510	return -1;
...	...	@@ -410,14 +410,16 @@
410	410	struct iscsi_tiqn *tiqn = container_of(igrps,
411	411	struct iscsi_tiqn, tiqn_stat_grps);
412	412	struct iscsi_login_stats *lstat = &tiqn->login_stats;
413		- unsigned char buf[8];
	413	+ int ret;
414	414
415	415	spin_lock(&lstat->lock);
416		- snprintf(buf, 8, "%s", (lstat->last_intr_fail_ip_addr != NULL) ?
417		- "ipv6" : "ipv4");
	416	+ if (lstat->last_intr_fail_ip_family == AF_INET6)
	417	+ ret = snprintf(page, PAGE_SIZE, "ipv6\n");
	418	+ else
	419	+ ret = snprintf(page, PAGE_SIZE, "ipv4\n");
418	420	spin_unlock(&lstat->lock);
419	421
420		- return snprintf(page, PAGE_SIZE, "%s\n", buf);
	422	+ return ret;
421	423	}
422	424	ISCSI_STAT_TGT_ATTR_RO(fail_intr_addr_type);
423	425
424	426
425	427
...	...	@@ -427,16 +429,19 @@
427	429	struct iscsi_tiqn *tiqn = container_of(igrps,
428	430	struct iscsi_tiqn, tiqn_stat_grps);
429	431	struct iscsi_login_stats *lstat = &tiqn->login_stats;
430		- unsigned char buf[32];
	432	+ int ret;
431	433
432	434	spin_lock(&lstat->lock);
433		- if (lstat->last_intr_fail_ip_family == AF_INET6)
434		- snprintf(buf, 32, "[%s]", lstat->last_intr_fail_ip_addr);
435		- else
436		- snprintf(buf, 32, "%s", lstat->last_intr_fail_ip_addr);
	435	+ if (lstat->last_intr_fail_ip_family == AF_INET6) {
	436	+ ret = snprintf(page, PAGE_SIZE, "[%s]\n",
	437	+ lstat->last_intr_fail_ip_addr);
	438	+ } else {
	439	+ ret = snprintf(page, PAGE_SIZE, "%s\n",
	440	+ lstat->last_intr_fail_ip_addr);
	441	+ }
437	442	spin_unlock(&lstat->lock);
438	443
439		- return snprintf(page, PAGE_SIZE, "%s\n", buf);
	444	+ return ret;
440	445	}
441	446	ISCSI_STAT_TGT_ATTR_RO(fail_intr_addr);
442	447
...	...	@@ -422,6 +422,35 @@
422	422	return NULL;
423	423	}
424	424
	425	+static bool iscsit_tpg_check_network_portal(
	426	+ struct iscsi_tiqn *tiqn,
	427	+ struct __kernel_sockaddr_storage *sockaddr,
	428	+ int network_transport)
	429	+{
	430	+ struct iscsi_portal_group *tpg;
	431	+ struct iscsi_tpg_np *tpg_np;
	432	+ struct iscsi_np *np;
	433	+ bool match = false;
	434	+
	435	+ spin_lock(&tiqn->tiqn_tpg_lock);
	436	+ list_for_each_entry(tpg, &tiqn->tiqn_tpg_list, tpg_list) {
	437	+
	438	+ spin_lock(&tpg->tpg_np_lock);
	439	+ list_for_each_entry(tpg_np, &tpg->tpg_gnp_list, tpg_np_list) {
	440	+ np = tpg_np->tpg_np;
	441	+
	442	+ match = iscsit_check_np_match(sockaddr, np,
	443	+ network_transport);
	444	+ if (match == true)
	445	+ break;
	446	+ }
	447	+ spin_unlock(&tpg->tpg_np_lock);
	448	+ }
	449	+ spin_unlock(&tiqn->tiqn_tpg_lock);
	450	+
	451	+ return match;
	452	+}
	453	+
425	454	struct iscsi_tpg_np *iscsit_tpg_add_network_portal(
426	455	struct iscsi_portal_group *tpg,
427	456	struct __kernel_sockaddr_storage *sockaddr,
...	...	@@ -431,6 +460,16 @@
431	460	{
432	461	struct iscsi_np *np;
433	462	struct iscsi_tpg_np *tpg_np;
	463	+
	464	+ if (!tpg_np_parent) {
	465	+ if (iscsit_tpg_check_network_portal(tpg->tpg_tiqn, sockaddr,
	466	+ network_transport) == true) {
	467	+ pr_err("Network Portal: %s already exists on a"
	468	+ " different TPG on %s\n", ip_str,
	469	+ tpg->tpg_tiqn->tiqn);
	470	+ return ERR_PTR(-EEXIST);
	471	+ }
	472	+ }
434	473
435	474	tpg_np = kzalloc(sizeof(struct iscsi_tpg_np), GFP_KERNEL);
436	475	if (!tpg_np) {
...	...	@@ -609,6 +609,9 @@
609	609	__CONFIGFS_EATTR_RO(_name, \
610	610	target_core_dev_show_attr_##_name);
611	611
	612	+DEF_DEV_ATTRIB(emulate_model_alias);
	613	+SE_DEV_ATTR(emulate_model_alias, S_IRUGO \| S_IWUSR);
	614	+
612	615	DEF_DEV_ATTRIB(emulate_dpo);
613	616	SE_DEV_ATTR(emulate_dpo, S_IRUGO \| S_IWUSR);
614	617
...	...	@@ -681,6 +684,7 @@
681	684	CONFIGFS_EATTR_OPS(target_core_dev_attrib, se_dev_attrib, da_group);
682	685
683	686	static struct configfs_attribute *target_core_dev_attrib_attrs[] = {
	687	+ &target_core_dev_attrib_emulate_model_alias.attr,
684	688	&target_core_dev_attrib_emulate_dpo.attr,
685	689	&target_core_dev_attrib_emulate_fua_write.attr,
686	690	&target_core_dev_attrib_emulate_fua_read.attr,
...	...	@@ -713,6 +713,44 @@
713	713	return 0;
714	714	}
715	715
	716	+static void dev_set_t10_wwn_model_alias(struct se_device *dev)
	717	+{
	718	+ const char *configname;
	719	+
	720	+ configname = config_item_name(&dev->dev_group.cg_item);
	721	+ if (strlen(configname) >= 16) {
	722	+ pr_warn("dev[%p]: Backstore name '%s' is too long for "
	723	+ "INQUIRY_MODEL, truncating to 16 bytes\n", dev,
	724	+ configname);
	725	+ }
	726	+ snprintf(&dev->t10_wwn.model[0], 16, "%s", configname);
	727	+}
	728	+
	729	+int se_dev_set_emulate_model_alias(struct se_device *dev, int flag)
	730	+{
	731	+ if (dev->export_count) {
	732	+ pr_err("dev[%p]: Unable to change model alias"
	733	+ " while export_count is %d\n",
	734	+ dev, dev->export_count);
	735	+ return -EINVAL;
	736	+ }
	737	+
	738	+ if (flag != 0 && flag != 1) {
	739	+ pr_err("Illegal value %d\n", flag);
	740	+ return -EINVAL;
	741	+ }
	742	+
	743	+ if (flag) {
	744	+ dev_set_t10_wwn_model_alias(dev);
	745	+ } else {
	746	+ strncpy(&dev->t10_wwn.model[0],
	747	+ dev->transport->inquiry_prod, 16);
	748	+ }
	749	+ dev->dev_attrib.emulate_model_alias = flag;
	750	+
	751	+ return 0;
	752	+}
	753	+
716	754	int se_dev_set_emulate_dpo(struct se_device *dev, int flag)
717	755	{
718	756	if (flag != 0 && flag != 1) {
...	...	@@ -772,6 +810,12 @@
772	810	pr_err("emulate_write_cache not supported for pSCSI\n");
773	811	return -EINVAL;
774	812	}
	813	+ if (dev->transport->get_write_cache) {
	814	+ pr_warn("emulate_write_cache cannot be changed when underlying"
	815	+ " HW reports WriteCacheEnabled, ignoring request\n");
	816	+ return 0;
	817	+ }
	818	+
775	819	dev->dev_attrib.emulate_write_cache = flag;
776	820	pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",
777	821	dev, dev->dev_attrib.emulate_write_cache);
778	822
779	823
780	824
781	825
...	...	@@ -1182,24 +1226,18 @@
1182	1226
1183	1227	struct se_lun_acl *core_dev_init_initiator_node_lun_acl(
1184	1228	struct se_portal_group *tpg,
	1229	+ struct se_node_acl *nacl,
1185	1230	u32 mapped_lun,
1186		- char *initiatorname,
1187	1231	int *ret)
1188	1232	{
1189	1233	struct se_lun_acl *lacl;
1190		- struct se_node_acl *nacl;
1191	1234
1192		- if (strlen(initiatorname) >= TRANSPORT_IQN_LEN) {
	1235	+ if (strlen(nacl->initiatorname) >= TRANSPORT_IQN_LEN) {
1193	1236	pr_err("%s InitiatorName exceeds maximum size.\n",
1194	1237	tpg->se_tpg_tfo->get_fabric_name());
1195	1238	*ret = -EOVERFLOW;
1196	1239	return NULL;
1197	1240	}
1198		- nacl = core_tpg_get_initiator_node_acl(tpg, initiatorname);
1199		- if (!nacl) {
1200		- *ret = -EINVAL;
1201		- return NULL;
1202		- }
1203	1241	lacl = kzalloc(sizeof(struct se_lun_acl), GFP_KERNEL);
1204	1242	if (!lacl) {
1205	1243	pr_err("Unable to allocate memory for struct se_lun_acl.\n");
...	...	@@ -1210,7 +1248,8 @@
1210	1248	INIT_LIST_HEAD(&lacl->lacl_list);
1211	1249	lacl->mapped_lun = mapped_lun;
1212	1250	lacl->se_lun_nacl = nacl;
1213		- snprintf(lacl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname);
	1251	+ snprintf(lacl->initiatorname, TRANSPORT_IQN_LEN, "%s",
	1252	+ nacl->initiatorname);
1214	1253
1215	1254	return lacl;
1216	1255	}
...	...	@@ -1390,6 +1429,7 @@
1390	1429	dev->t10_alua.t10_dev = dev;
1391	1430
1392	1431	dev->dev_attrib.da_dev = dev;
	1432	+ dev->dev_attrib.emulate_model_alias = DA_EMULATE_MODEL_ALIAS;
1393	1433	dev->dev_attrib.emulate_dpo = DA_EMULATE_DPO;
1394	1434	dev->dev_attrib.emulate_fua_write = DA_EMULATE_FUA_WRITE;
1395	1435	dev->dev_attrib.emulate_fua_read = DA_EMULATE_FUA_READ;
...	...	@@ -354,9 +354,17 @@
354	354	ret = -EINVAL;
355	355	goto out;
356	356	}
	357	+ if (mapped_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
	358	+ pr_err("Mapped LUN: %lu exceeds TRANSPORT_MAX_LUNS_PER_TPG"
	359	+ "-1: %u for Target Portal Group: %u\n", mapped_lun,
	360	+ TRANSPORT_MAX_LUNS_PER_TPG-1,
	361	+ se_tpg->se_tpg_tfo->tpg_get_tag(se_tpg));
	362	+ ret = -EINVAL;
	363	+ goto out;
	364	+ }
357	365
358		- lacl = core_dev_init_initiator_node_lun_acl(se_tpg, mapped_lun,
359		- config_item_name(acl_ci), &ret);
	366	+ lacl = core_dev_init_initiator_node_lun_acl(se_tpg, se_nacl,
	367	+ mapped_lun, &ret);
360	368	if (!lacl) {
361	369	ret = -EINVAL;
362	370	goto out;
...	...	@@ -190,6 +190,11 @@
190	190
191	191	fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++;
192	192	fd_dev->fd_queue_depth = dev->queue_depth;
	193	+ /*
	194	+ * Limit WRITE_SAME w/ UNMAP=0 emulation to 8k Number of LBAs (NoLB)
	195	+ * based upon struct iovec limit for vfs_writev()
	196	+ */
	197	+ dev->dev_attrib.max_write_same_len = 0x1000;
193	198
194	199	pr_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s,"
195	200	" %llu total bytes\n", fd_host->fd_host_id, fd_dev->fd_dev_id,
196	201
...	...	@@ -328,7 +333,115 @@
328	333	return 0;
329	334	}
330	335
	336	+static unsigned char *
	337	+fd_setup_write_same_buf(struct se_cmd cmd, struct scatterlist sg,
	338	+ unsigned int len)
	339	+{
	340	+ struct se_device *se_dev = cmd->se_dev;
	341	+ unsigned int block_size = se_dev->dev_attrib.block_size;
	342	+ unsigned int i = 0, end;
	343	+ unsigned char buf, p, *kmap_buf;
	344	+
	345	+ buf = kzalloc(min_t(unsigned int, len, PAGE_SIZE), GFP_KERNEL);
	346	+ if (!buf) {
	347	+ pr_err("Unable to allocate fd_execute_write_same buf\n");
	348	+ return NULL;
	349	+ }
	350	+
	351	+ kmap_buf = kmap(sg_page(sg)) + sg->offset;
	352	+ if (!kmap_buf) {
	353	+ pr_err("kmap() failed in fd_setup_write_same\n");
	354	+ kfree(buf);
	355	+ return NULL;
	356	+ }
	357	+ /*
	358	+ * Fill local *buf to contain multiple WRITE_SAME blocks up to
	359	+ * min(len, PAGE_SIZE)
	360	+ */
	361	+ p = buf;
	362	+ end = min_t(unsigned int, len, PAGE_SIZE);
	363	+
	364	+ while (i < end) {
	365	+ memcpy(p, kmap_buf, block_size);
	366	+
	367	+ i += block_size;
	368	+ p += block_size;
	369	+ }
	370	+ kunmap(sg_page(sg));
	371	+
	372	+ return buf;
	373	+}
	374	+
331	375	static sense_reason_t
	376	+fd_execute_write_same(struct se_cmd *cmd)
	377	+{
	378	+ struct se_device *se_dev = cmd->se_dev;
	379	+ struct fd_dev *fd_dev = FD_DEV(se_dev);
	380	+ struct file *f = fd_dev->fd_file;
	381	+ struct scatterlist *sg;
	382	+ struct iovec *iov;
	383	+ mm_segment_t old_fs;
	384	+ sector_t nolb = sbc_get_write_same_sectors(cmd);
	385	+ loff_t pos = cmd->t_task_lba * se_dev->dev_attrib.block_size;
	386	+ unsigned int len, len_tmp, iov_num;
	387	+ int i, rc;
	388	+ unsigned char *buf;
	389	+
	390	+ if (!nolb) {
	391	+ target_complete_cmd(cmd, SAM_STAT_GOOD);
	392	+ return 0;
	393	+ }
	394	+ sg = &cmd->t_data_sg[0];
	395	+
	396	+ if (cmd->t_data_nents > 1 \|\|
	397	+ sg->length != cmd->se_dev->dev_attrib.block_size) {
	398	+ pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"
	399	+ " block_size: %u\n", cmd->t_data_nents, sg->length,
	400	+ cmd->se_dev->dev_attrib.block_size);
	401	+ return TCM_INVALID_CDB_FIELD;
	402	+ }
	403	+
	404	+ len = len_tmp = nolb * se_dev->dev_attrib.block_size;
	405	+ iov_num = DIV_ROUND_UP(len, PAGE_SIZE);
	406	+
	407	+ buf = fd_setup_write_same_buf(cmd, sg, len);
	408	+ if (!buf)
	409	+ return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
	410	+
	411	+ iov = vzalloc(sizeof(struct iovec) * iov_num);
	412	+ if (!iov) {
	413	+ pr_err("Unable to allocate fd_execute_write_same iovecs\n");
	414	+ kfree(buf);
	415	+ return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
	416	+ }
	417	+ /*
	418	+ * Map the single fabric received scatterlist block now populated
	419	+ * in *buf into each iovec for I/O submission.
	420	+ */
	421	+ for (i = 0; i < iov_num; i++) {
	422	+ iov[i].iov_base = buf;
	423	+ iov[i].iov_len = min_t(unsigned int, len_tmp, PAGE_SIZE);
	424	+ len_tmp -= iov[i].iov_len;
	425	+ }
	426	+
	427	+ old_fs = get_fs();
	428	+ set_fs(get_ds());
	429	+ rc = vfs_writev(f, &iov[0], iov_num, &pos);
	430	+ set_fs(old_fs);
	431	+
	432	+ vfree(iov);
	433	+ kfree(buf);
	434	+
	435	+ if (rc < 0 \|\| rc != len) {
	436	+ pr_err("vfs_writev() returned %d for write same\n", rc);
	437	+ return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
	438	+ }
	439	+
	440	+ target_complete_cmd(cmd, SAM_STAT_GOOD);
	441	+ return 0;
	442	+}
	443	+
	444	+static sense_reason_t
332	445	fd_execute_rw(struct se_cmd *cmd)
333	446	{
334	447	struct scatterlist *sgl = cmd->t_data_sg;
...	...	@@ -486,6 +599,7 @@
486	599	static struct sbc_ops fd_sbc_ops = {
487	600	.execute_rw = fd_execute_rw,
488	601	.execute_sync_cache = fd_execute_sync_cache,
	602	+ .execute_write_same = fd_execute_write_same,
489	603	};
490	604
491	605	static sense_reason_t
...	...	@@ -154,6 +154,7 @@
154	154
155	155	if (blk_queue_nonrot(q))
156	156	dev->dev_attrib.is_nonrot = 1;
	157	+
157	158	return 0;
158	159
159	160	out_free_bioset:
160	161
...	...	@@ -390,10 +391,19 @@
390	391	sense_reason_t ret = 0;
391	392	int dl, bd_dl, err;
392	393
	394	+ /* We never set ANC_SUP */
	395	+ if (cmd->t_task_cdb[1])
	396	+ return TCM_INVALID_CDB_FIELD;
	397	+
	398	+ if (cmd->data_length == 0) {
	399	+ target_complete_cmd(cmd, SAM_STAT_GOOD);
	400	+ return 0;
	401	+ }
	402	+
393	403	if (cmd->data_length < 8) {
394	404	pr_warn("UNMAP parameter list length %u too small\n",
395	405	cmd->data_length);
396		- return TCM_INVALID_PARAMETER_LIST;
	406	+ return TCM_PARAMETER_LIST_LENGTH_ERROR;
397	407	}
398	408
399	409	buf = transport_kmap_data_sg(cmd);
...	...	@@ -463,7 +473,7 @@
463	473	int rc;
464	474
465	475	rc = blkdev_issue_discard(ib_dev->ibd_bd, cmd->t_task_lba,
466		- spc_get_write_same_sectors(cmd), GFP_KERNEL, 0);
	476	+ sbc_get_write_same_sectors(cmd), GFP_KERNEL, 0);
467	477	if (rc < 0) {
468	478	pr_warn("blkdev_issue_discard() failed: %d\n", rc);
469	479	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
...	...	@@ -481,7 +491,7 @@
481	491	struct bio *bio;
482	492	struct bio_list list;
483	493	sector_t block_lba = cmd->t_task_lba;
484		- sector_t sectors = spc_get_write_same_sectors(cmd);
	494	+ sector_t sectors = sbc_get_write_same_sectors(cmd);
485	495
486	496	sg = &cmd->t_data_sg[0];
487	497
488	498
489	499
490	500
491	501
...	...	@@ -654,20 +664,24 @@
654	664	u32 sg_num = sgl_nents;
655	665	sector_t block_lba;
656	666	unsigned bio_cnt;
657		- int rw;
	667	+ int rw = 0;
658	668	int i;
659	669
660	670	if (data_direction == DMA_TO_DEVICE) {
	671	+ struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
	672	+ struct request_queue *q = bdev_get_queue(ib_dev->ibd_bd);
661	673	/*
662		- * Force data to disk if we pretend to not have a volatile
663		- * write cache, or the initiator set the Force Unit Access bit.
	674	+ * Force writethrough using WRITE_FUA if a volatile write cache
	675	+ * is not enabled, or if initiator set the Force Unit Access bit.
664	676	*/
665		- if (dev->dev_attrib.emulate_write_cache == 0 \|\|
666		- (dev->dev_attrib.emulate_fua_write > 0 &&
667		- (cmd->se_cmd_flags & SCF_FUA)))
668		- rw = WRITE_FUA;
669		- else
	677	+ if (q->flush_flags & REQ_FUA) {
	678	+ if (cmd->se_cmd_flags & SCF_FUA)
	679	+ rw = WRITE_FUA;
	680	+ else if (!(q->flush_flags & REQ_FLUSH))
	681	+ rw = WRITE_FUA;
	682	+ } else {
670	683	rw = WRITE;
	684	+ }
671	685	} else {
672	686	rw = READ;
673	687	}
...	...	@@ -774,6 +788,15 @@
774	788	return sbc_parse_cdb(cmd, &iblock_sbc_ops);
775	789	}
776	790
	791	+bool iblock_get_write_cache(struct se_device *dev)
	792	+{
	793	+ struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
	794	+ struct block_device *bd = ib_dev->ibd_bd;
	795	+ struct request_queue *q = bdev_get_queue(bd);
	796	+
	797	+ return q->flush_flags & REQ_FLUSH;
	798	+}
	799	+
777	800	static struct se_subsystem_api iblock_template = {
778	801	.name = "iblock",
779	802	.inquiry_prod = "IBLOCK",
...	...	@@ -790,6 +813,7 @@
790	813	.show_configfs_dev_params = iblock_show_configfs_dev_params,
791	814	.get_device_type = sbc_get_device_type,
792	815	.get_blocks = iblock_get_blocks,
	816	+ .get_write_cache = iblock_get_write_cache,
793	817	};
794	818
795	819	static int __init iblock_module_init(void)