Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit 82bc9d04f4281276b8941b09a9306e15d4dc53f6

Authored by Nicholas Bellinger 2015-01-07 08:10:37 +0800

Committed by Greg Kroah-Hartman 2015-01-28 00:29:45 +0800

1 parent e7b2033159

target: Drop arbitrary maximum I/O size limit

commit 046ba64285a4389ae5e9a7dfa253c6bff3d7c341 upstream.

This patch drops the arbitrary maximum I/O size limit in sbc_parse_cdb(),
which currently for fabric_max_sectors is hardcoded to 8192 (4 MB for 512
byte sector devices), and for hw_max_sectors is a backend driver dependent
value.

This limit is problematic because Linux initiators have only recently
started to honor block limits MAXIMUM TRANSFER LENGTH, and other non-Linux
based initiators (eg: MSFT Fibre Channel) can also generate I/Os larger
than 4 MB in size.

Currently when this happens, the following message will appear on the
target resulting in I/Os being returned with non recoverable status:

  SCSI OP 28h with too big sectors 16384 exceeds fabric_max_sectors: 8192

Instead, drop both [fabric,hw]_max_sector checks in sbc_parse_cdb(),
and convert the existing hw_max_sectors into a purely informational
attribute used to represent the granuality that backend driver and/or
subsystem code is splitting I/Os upon.

Also, update FILEIO with an explicit FD_MAX_BYTES check in fd_execute_rw()
to deal with the one special iovec limitiation case.

v2 changes:
  - Drop hw_max_sectors check in sbc_parse_cdb()

Reported-by: Lance Gropper <lance.gropper@qosserver.com>
Reported-by: Stefan Priebe <s.priebe@profihost.ag>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Martin K. Petersen <martin.petersen@oracle.com>
Cc: Roland Dreier <roland@purestorage.com>
Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Showing 5 changed files with 16 additions and 25 deletions Inline Diff

drivers/target/target_core_device.c
drivers/target/target_core_file.c
drivers/target/target_core_iblock.c
drivers/target/target_core_sbc.c
drivers/target/target_core_spc.c

drivers/target/target_core_device.c

Diff comments View file @ 82bc9d0

 /*******************************************************************************
  * Filename:  target_core_device.c (based on iscsi_target_device.c)
  *
  * This file contains the TCM Virtual Device and Disk Transport
  * agnostic related functions.
  *
  * (c) Copyright 2003-2013 Datera, Inc.
  *
  * Nicholas A. Bellinger <nab@kernel.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *
  ******************************************************************************/
 #include <linux/net.h>
 #include <linux/string.h>
 #include <linux/delay.h>
 #include <linux/timer.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/kthread.h>
 #include <linux/in.h>
 #include <linux/export.h>
 #include <net/sock.h>
 #include <net/tcp.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
 #include "target_core_internal.h"
 #include "target_core_alua.h"
 #include "target_core_pr.h"
 #include "target_core_ua.h"
 DEFINE_MUTEX(g_device_mutex);
 LIST_HEAD(g_device_list);
 static struct se_hba *lun0_hba;
 /* not static, needed by tpg.c */
 struct se_device *g_lun0_dev;
 sense_reason_t
 transport_lookup_cmd_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
 {
 	struct se_lun *se_lun = NULL;
 	struct se_session *se_sess = se_cmd->se_sess;
 	struct se_device *dev;
 	unsigned long flags;
 	if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG)
 		return TCM_NON_EXISTENT_LUN;
 	spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);
 	se_cmd->se_deve = se_sess->se_node_acl->device_list[unpacked_lun];
 	if (se_cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
 		struct se_dev_entry *deve = se_cmd->se_deve;
 		deve->total_cmds++;
 		if ((se_cmd->data_direction == DMA_TO_DEVICE) &&
 		    (deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)) {
 			pr_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN"
 				" Access for 0x%08x\n",
 				se_cmd->se_tfo->get_fabric_name(),
 				unpacked_lun);
 			spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
 			return TCM_WRITE_PROTECTED;
 		}
 		if (se_cmd->data_direction == DMA_TO_DEVICE)
 			deve->write_bytes += se_cmd->data_length;
 		else if (se_cmd->data_direction == DMA_FROM_DEVICE)
 			deve->read_bytes += se_cmd->data_length;
 		se_lun = deve->se_lun;
 		se_cmd->se_lun = deve->se_lun;
 		se_cmd->pr_res_key = deve->pr_res_key;
 		se_cmd->orig_fe_lun = unpacked_lun;
 		se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;
 		percpu_ref_get(&se_lun->lun_ref);
 		se_cmd->lun_ref_active = true;
 	}
 	spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
 	if (!se_lun) {
 		/*
 		 * Use the se_portal_group->tpg_virt_lun0 to allow for
 		 * REPORT_LUNS, et al to be returned when no active
 		 * MappedLUN=0 exists for this Initiator Port.
 		 */
 		if (unpacked_lun != 0) {
 			pr_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
 				" Access for 0x%08x\n",
 				se_cmd->se_tfo->get_fabric_name(),
 				unpacked_lun);
 			return TCM_NON_EXISTENT_LUN;
 		}
 		/*
 		 * Force WRITE PROTECT for virtual LUN 0
 		 */
 		if ((se_cmd->data_direction != DMA_FROM_DEVICE) &&
 		    (se_cmd->data_direction != DMA_NONE))
 			return TCM_WRITE_PROTECTED;
 		se_lun = &se_sess->se_tpg->tpg_virt_lun0;
 		se_cmd->se_lun = &se_sess->se_tpg->tpg_virt_lun0;
 		se_cmd->orig_fe_lun = 0;
 		se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;
 		percpu_ref_get(&se_lun->lun_ref);
 		se_cmd->lun_ref_active = true;
 	}
 	/* Directly associate cmd with se_dev */
 	se_cmd->se_dev = se_lun->lun_se_dev;
 	dev = se_lun->lun_se_dev;
 	atomic_long_inc(&dev->num_cmds);
 	if (se_cmd->data_direction == DMA_TO_DEVICE)
 		atomic_long_add(se_cmd->data_length, &dev->write_bytes);
 	else if (se_cmd->data_direction == DMA_FROM_DEVICE)
 		atomic_long_add(se_cmd->data_length, &dev->read_bytes);
 	return 0;
 }
 EXPORT_SYMBOL(transport_lookup_cmd_lun);
 int transport_lookup_tmr_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
 {
 	struct se_dev_entry *deve;
 	struct se_lun *se_lun = NULL;
 	struct se_session *se_sess = se_cmd->se_sess;
 	struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;
 	unsigned long flags;
 	if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG)
 		return -ENODEV;
 	spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);
 	se_cmd->se_deve = se_sess->se_node_acl->device_list[unpacked_lun];
 	deve = se_cmd->se_deve;
 	if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
 		se_tmr->tmr_lun = deve->se_lun;
 		se_cmd->se_lun = deve->se_lun;
 		se_lun = deve->se_lun;
 		se_cmd->pr_res_key = deve->pr_res_key;
 		se_cmd->orig_fe_lun = unpacked_lun;
 	}
 	spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
 	if (!se_lun) {
 		pr_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
 			" Access for 0x%08x\n",
 			se_cmd->se_tfo->get_fabric_name(),
 			unpacked_lun);
 		return -ENODEV;
 	}
 	/* Directly associate cmd with se_dev */
 	se_cmd->se_dev = se_lun->lun_se_dev;
 	se_tmr->tmr_dev = se_lun->lun_se_dev;
 	spin_lock_irqsave(&se_tmr->tmr_dev->se_tmr_lock, flags);
 	list_add_tail(&se_tmr->tmr_list, &se_tmr->tmr_dev->dev_tmr_list);
 	spin_unlock_irqrestore(&se_tmr->tmr_dev->se_tmr_lock, flags);
 	return 0;
 }
 EXPORT_SYMBOL(transport_lookup_tmr_lun);
 /*
  * This function is called from core_scsi3_emulate_pro_register_and_move()
  * and core_scsi3_decode_spec_i_port(), and will increment &deve->pr_ref_count
  * when a matching rtpi is found.
  */
 struct se_dev_entry *core_get_se_deve_from_rtpi(
 	struct se_node_acl *nacl,
 	u16 rtpi)
 {
 	struct se_dev_entry *deve;
 	struct se_lun *lun;
 	struct se_port *port;
 	struct se_portal_group *tpg = nacl->se_tpg;
 	u32 i;
 	spin_lock_irq(&nacl->device_list_lock);
 	for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
 		deve = nacl->device_list[i];
 		if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
 			continue;
 		lun = deve->se_lun;
 		if (!lun) {
 			pr_err("%s device entries device pointer is"
 				" NULL, but Initiator has access.\n",
 				tpg->se_tpg_tfo->get_fabric_name());
 			continue;
 		}
 		port = lun->lun_sep;
 		if (!port) {
 			pr_err("%s device entries device pointer is"
 				" NULL, but Initiator has access.\n",
 				tpg->se_tpg_tfo->get_fabric_name());
 			continue;
 		}
 		if (port->sep_rtpi != rtpi)
 			continue;
 		atomic_inc_mb(&deve->pr_ref_count);
 		spin_unlock_irq(&nacl->device_list_lock);
 		return deve;
 	}
 	spin_unlock_irq(&nacl->device_list_lock);
 	return NULL;
 }
 int core_free_device_list_for_node(
 	struct se_node_acl *nacl,
 	struct se_portal_group *tpg)
 {
 	struct se_dev_entry *deve;
 	struct se_lun *lun;
 	u32 i;
 	if (!nacl->device_list)
 		return 0;
 	spin_lock_irq(&nacl->device_list_lock);
 	for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
 		deve = nacl->device_list[i];
 		if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
 			continue;
 		if (!deve->se_lun) {
 			pr_err("%s device entries device pointer is"
 				" NULL, but Initiator has access.\n",
 				tpg->se_tpg_tfo->get_fabric_name());
 			continue;
 		}
 		lun = deve->se_lun;
 		spin_unlock_irq(&nacl->device_list_lock);
 		core_disable_device_list_for_node(lun, NULL, deve->mapped_lun,
 			TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);
 		spin_lock_irq(&nacl->device_list_lock);
 	}
 	spin_unlock_irq(&nacl->device_list_lock);
 	array_free(nacl->device_list, TRANSPORT_MAX_LUNS_PER_TPG);
 	nacl->device_list = NULL;
 	return 0;
 }
 void core_update_device_list_access(
 	u32 mapped_lun,
 	u32 lun_access,
 	struct se_node_acl *nacl)
 {
 	struct se_dev_entry *deve;
 	spin_lock_irq(&nacl->device_list_lock);
 	deve = nacl->device_list[mapped_lun];
 	if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
 		deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
 		deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;
 	} else {
 		deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
 		deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;
 	}
 	spin_unlock_irq(&nacl->device_list_lock);
 }
 /*      core_enable_device_list_for_node():
  *
  *
  */
 int core_enable_device_list_for_node(
 	struct se_lun *lun,
 	struct se_lun_acl *lun_acl,
 	u32 mapped_lun,
 	u32 lun_access,
 	struct se_node_acl *nacl,
 	struct se_portal_group *tpg)
 {
 	struct se_port *port = lun->lun_sep;
 	struct se_dev_entry *deve;
 	spin_lock_irq(&nacl->device_list_lock);
 	deve = nacl->device_list[mapped_lun];
 	/*
 	 * Check if the call is handling demo mode -> explicit LUN ACL
 	 * transition.  This transition must be for the same struct se_lun
 	 * + mapped_lun that was setup in demo mode..
 	 */
 	if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
 		if (deve->se_lun_acl != NULL) {
 			pr_err("struct se_dev_entry->se_lun_acl"
 			       " already set for demo mode -> explicit"
 			       " LUN ACL transition\n");
 			spin_unlock_irq(&nacl->device_list_lock);
 			return -EINVAL;
 		}
 		if (deve->se_lun != lun) {
 			pr_err("struct se_dev_entry->se_lun does"
 			       " match passed struct se_lun for demo mode"
 			       " -> explicit LUN ACL transition\n");
 			spin_unlock_irq(&nacl->device_list_lock);
 			return -EINVAL;
 		}
 		deve->se_lun_acl = lun_acl;
 		if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
 			deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
 			deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;
 		} else {
 			deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
 			deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;
 		}
 		spin_unlock_irq(&nacl->device_list_lock);
 		return 0;
 	}
 	deve->se_lun = lun;
 	deve->se_lun_acl = lun_acl;
 	deve->mapped_lun = mapped_lun;
 	deve->lun_flags |= TRANSPORT_LUNFLAGS_INITIATOR_ACCESS;
 	if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
 		deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
 		deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;
 	} else {
 		deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
 		deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;
 	}
 	deve->creation_time = get_jiffies_64();
 	deve->attach_count++;
 	spin_unlock_irq(&nacl->device_list_lock);
 	spin_lock_bh(&port->sep_alua_lock);
 	list_add_tail(&deve->alua_port_list, &port->sep_alua_list);
 	spin_unlock_bh(&port->sep_alua_lock);
 	return 0;
 }
 /*      core_disable_device_list_for_node():
  *
  *
  */
 int core_disable_device_list_for_node(
 	struct se_lun *lun,
 	struct se_lun_acl *lun_acl,
 	u32 mapped_lun,
 	u32 lun_access,
 	struct se_node_acl *nacl,
 	struct se_portal_group *tpg)
 {
 	struct se_port *port = lun->lun_sep;
 	struct se_dev_entry *deve = nacl->device_list[mapped_lun];
 	/*
 	 * If the MappedLUN entry is being disabled, the entry in
 	 * port->sep_alua_list must be removed now before clearing the
 	 * struct se_dev_entry pointers below as logic in
 	 * core_alua_do_transition_tg_pt() depends on these being present.
 	 *
 	 * deve->se_lun_acl will be NULL for demo-mode created LUNs
 	 * that have not been explicitly converted to MappedLUNs ->
 	 * struct se_lun_acl, but we remove deve->alua_port_list from
 	 * port->sep_alua_list. This also means that active UAs and
 	 * NodeACL context specific PR metadata for demo-mode
 	 * MappedLUN *deve will be released below..
 	 */
 	spin_lock_bh(&port->sep_alua_lock);
 	list_del(&deve->alua_port_list);
 	spin_unlock_bh(&port->sep_alua_lock);
 	/*
 	 * Wait for any in process SPEC_I_PT=1 or REGISTER_AND_MOVE
 	 * PR operation to complete.
 	 */
 	while (atomic_read(&deve->pr_ref_count) != 0)
 		cpu_relax();
 	spin_lock_irq(&nacl->device_list_lock);
 	/*
 	 * Disable struct se_dev_entry LUN ACL mapping
 	 */
 	core_scsi3_ua_release_all(deve);
 	deve->se_lun = NULL;
 	deve->se_lun_acl = NULL;
 	deve->lun_flags = 0;
 	deve->creation_time = 0;
 	deve->attach_count--;
 	spin_unlock_irq(&nacl->device_list_lock);
 	core_scsi3_free_pr_reg_from_nacl(lun->lun_se_dev, nacl);
 	return 0;
 }
 /*      core_clear_lun_from_tpg():
  *
  *
  */
 void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg)
 {
 	struct se_node_acl *nacl;
 	struct se_dev_entry *deve;
 	u32 i;
 	spin_lock_irq(&tpg->acl_node_lock);
 	list_for_each_entry(nacl, &tpg->acl_node_list, acl_list) {
 		spin_unlock_irq(&tpg->acl_node_lock);
 		spin_lock_irq(&nacl->device_list_lock);
 		for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
 			deve = nacl->device_list[i];
 			if (lun != deve->se_lun)
 				continue;
 			spin_unlock_irq(&nacl->device_list_lock);
 			core_disable_device_list_for_node(lun, NULL,
 				deve->mapped_lun, TRANSPORT_LUNFLAGS_NO_ACCESS,
 				nacl, tpg);
 			spin_lock_irq(&nacl->device_list_lock);
 		}
 		spin_unlock_irq(&nacl->device_list_lock);
 		spin_lock_irq(&tpg->acl_node_lock);
 	}
 	spin_unlock_irq(&tpg->acl_node_lock);
 }
 static struct se_port *core_alloc_port(struct se_device *dev)
 {
 	struct se_port *port, *port_tmp;
 	port = kzalloc(sizeof(struct se_port), GFP_KERNEL);
 	if (!port) {
 		pr_err("Unable to allocate struct se_port\n");
 		return ERR_PTR(-ENOMEM);
 	}
 	INIT_LIST_HEAD(&port->sep_alua_list);
 	INIT_LIST_HEAD(&port->sep_list);
 	atomic_set(&port->sep_tg_pt_secondary_offline, 0);
 	spin_lock_init(&port->sep_alua_lock);
 	mutex_init(&port->sep_tg_pt_md_mutex);
 	spin_lock(&dev->se_port_lock);
 	if (dev->dev_port_count == 0x0000ffff) {
 		pr_warn("Reached dev->dev_port_count =="
 				" 0x0000ffff\n");
 		spin_unlock(&dev->se_port_lock);
 		return ERR_PTR(-ENOSPC);
 	}
 again:
 	/*
 	 * Allocate the next RELATIVE TARGET PORT IDENTIFIER for this struct se_device
 	 * Here is the table from spc4r17 section 7.7.3.8.
 	 *
 	 *    Table 473 -- RELATIVE TARGET PORT IDENTIFIER field
 	 *
 	 * Code      Description
 	 * 0h        Reserved
 	 * 1h        Relative port 1, historically known as port A
 	 * 2h        Relative port 2, historically known as port B
 	 * 3h to FFFFh    Relative port 3 through 65 535
 	 */
 	port->sep_rtpi = dev->dev_rpti_counter++;
 	if (!port->sep_rtpi)
 		goto again;
 	list_for_each_entry(port_tmp, &dev->dev_sep_list, sep_list) {
 		/*
 		 * Make sure RELATIVE TARGET PORT IDENTIFIER is unique
 		 * for 16-bit wrap..
 		 */
 		if (port->sep_rtpi == port_tmp->sep_rtpi)
 			goto again;
 	}
 	spin_unlock(&dev->se_port_lock);
 	return port;
 }
 static void core_export_port(
 	struct se_device *dev,
 	struct se_portal_group *tpg,
 	struct se_port *port,
 	struct se_lun *lun)
 {
 	struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem = NULL;
 	spin_lock(&dev->se_port_lock);
 	spin_lock(&lun->lun_sep_lock);
 	port->sep_tpg = tpg;
 	port->sep_lun = lun;
 	lun->lun_sep = port;
 	spin_unlock(&lun->lun_sep_lock);
 	list_add_tail(&port->sep_list, &dev->dev_sep_list);
 	spin_unlock(&dev->se_port_lock);
 	if (dev->transport->transport_type != TRANSPORT_PLUGIN_PHBA_PDEV &&
 	    !(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE)) {
 		tg_pt_gp_mem = core_alua_allocate_tg_pt_gp_mem(port);
 		if (IS_ERR(tg_pt_gp_mem) || !tg_pt_gp_mem) {
 			pr_err("Unable to allocate t10_alua_tg_pt"
 					"_gp_member_t\n");
 			return;
 		}
 		spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 		__core_alua_attach_tg_pt_gp_mem(tg_pt_gp_mem,
 			dev->t10_alua.default_tg_pt_gp);
 		spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 		pr_debug("%s/%s: Adding to default ALUA Target Port"
 			" Group: alua/default_tg_pt_gp\n",
 			dev->transport->name, tpg->se_tpg_tfo->get_fabric_name());
 	}
 	dev->dev_port_count++;
 	port->sep_index = port->sep_rtpi; /* RELATIVE TARGET PORT IDENTIFIER */
 }
 /*
  *	Called with struct se_device->se_port_lock spinlock held.
  */
 static void core_release_port(struct se_device *dev, struct se_port *port)
 	__releases(&dev->se_port_lock) __acquires(&dev->se_port_lock)
 {
 	/*
 	 * Wait for any port reference for PR ALL_TG_PT=1 operation
 	 * to complete in __core_scsi3_alloc_registration()
 	 */
 	spin_unlock(&dev->se_port_lock);
 	if (atomic_read(&port->sep_tg_pt_ref_cnt))
 		cpu_relax();
 	spin_lock(&dev->se_port_lock);
 	core_alua_free_tg_pt_gp_mem(port);
 	list_del(&port->sep_list);
 	dev->dev_port_count--;
 	kfree(port);
 }
 int core_dev_export(
 	struct se_device *dev,
 	struct se_portal_group *tpg,
 	struct se_lun *lun)
 {
 	struct se_hba *hba = dev->se_hba;
 	struct se_port *port;
 	port = core_alloc_port(dev);
 	if (IS_ERR(port))
 		return PTR_ERR(port);
 	lun->lun_se_dev = dev;
 	spin_lock(&hba->device_lock);
 	dev->export_count++;
 	spin_unlock(&hba->device_lock);
 	core_export_port(dev, tpg, port, lun);
 	return 0;
 }
 void core_dev_unexport(
 	struct se_device *dev,
 	struct se_portal_group *tpg,
 	struct se_lun *lun)
 {
 	struct se_hba *hba = dev->se_hba;
 	struct se_port *port = lun->lun_sep;
 	spin_lock(&lun->lun_sep_lock);
 	if (lun->lun_se_dev == NULL) {
 		spin_unlock(&lun->lun_sep_lock);
 		return;
 	}
 	spin_unlock(&lun->lun_sep_lock);
 	spin_lock(&dev->se_port_lock);
 	core_release_port(dev, port);
 	spin_unlock(&dev->se_port_lock);
 	spin_lock(&hba->device_lock);
 	dev->export_count--;
 	spin_unlock(&hba->device_lock);
 	lun->lun_sep = NULL;
 	lun->lun_se_dev = NULL;
 }
 static void se_release_vpd_for_dev(struct se_device *dev)
 {
 	struct t10_vpd *vpd, *vpd_tmp;
 	spin_lock(&dev->t10_wwn.t10_vpd_lock);
 	list_for_each_entry_safe(vpd, vpd_tmp,
 			&dev->t10_wwn.t10_vpd_list, vpd_list) {
 		list_del(&vpd->vpd_list);
 		kfree(vpd);
 	}
 	spin_unlock(&dev->t10_wwn.t10_vpd_lock);
 }
 static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)
 {
 	u32 aligned_max_sectors;
 	u32 alignment;
 	/*
 	 * Limit max_sectors to a PAGE_SIZE aligned value for modern
 	 * transport_allocate_data_tasks() operation.
 	 */
 	alignment = max(1ul, PAGE_SIZE / block_size);
 	aligned_max_sectors = rounddown(max_sectors, alignment);
 	if (max_sectors != aligned_max_sectors)
 		pr_info("Rounding down aligned max_sectors from %u to %u\n",
 			max_sectors, aligned_max_sectors);
 	return aligned_max_sectors;
 }
 int se_dev_set_max_unmap_lba_count(
 	struct se_device *dev,
 	u32 max_unmap_lba_count)
 {
 	dev->dev_attrib.max_unmap_lba_count = max_unmap_lba_count;
 	pr_debug("dev[%p]: Set max_unmap_lba_count: %u\n",
 			dev, dev->dev_attrib.max_unmap_lba_count);
 	return 0;
 }
 int se_dev_set_max_unmap_block_desc_count(
 	struct se_device *dev,
 	u32 max_unmap_block_desc_count)
 {
 	dev->dev_attrib.max_unmap_block_desc_count =
 		max_unmap_block_desc_count;
 	pr_debug("dev[%p]: Set max_unmap_block_desc_count: %u\n",
 			dev, dev->dev_attrib.max_unmap_block_desc_count);
 	return 0;
 }
 int se_dev_set_unmap_granularity(
 	struct se_device *dev,
 	u32 unmap_granularity)
 {
 	dev->dev_attrib.unmap_granularity = unmap_granularity;
 	pr_debug("dev[%p]: Set unmap_granularity: %u\n",
 			dev, dev->dev_attrib.unmap_granularity);
 	return 0;
 }
 int se_dev_set_unmap_granularity_alignment(
 	struct se_device *dev,
 	u32 unmap_granularity_alignment)
 {
 	dev->dev_attrib.unmap_granularity_alignment = unmap_granularity_alignment;
 	pr_debug("dev[%p]: Set unmap_granularity_alignment: %u\n",
 			dev, dev->dev_attrib.unmap_granularity_alignment);
 	return 0;
 }
 int se_dev_set_max_write_same_len(
 	struct se_device *dev,
 	u32 max_write_same_len)
 {
 	dev->dev_attrib.max_write_same_len = max_write_same_len;
 	pr_debug("dev[%p]: Set max_write_same_len: %u\n",
 			dev, dev->dev_attrib.max_write_same_len);
 	return 0;
 }
 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) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (flag) {
 		pr_err("dpo_emulated not supported\n");
 		return -EINVAL;
 	}
 	return 0;
 }
 int se_dev_set_emulate_fua_write(struct se_device *dev, int flag)
 {
 	if (flag != 0 && flag != 1) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (flag &&
 	    dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
 		pr_err("emulate_fua_write not supported for pSCSI\n");
 		return -EINVAL;
 	}
 	dev->dev_attrib.emulate_fua_write = flag;
 	pr_debug("dev[%p]: SE Device Forced Unit Access WRITEs: %d\n",
 			dev, dev->dev_attrib.emulate_fua_write);
 	return 0;
 }
 int se_dev_set_emulate_fua_read(struct se_device *dev, int flag)
 {
 	if (flag != 0 && flag != 1) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (flag) {
 		pr_err("ua read emulated not supported\n");
 		return -EINVAL;
 	}
 	return 0;
 }
 int se_dev_set_emulate_write_cache(struct se_device *dev, int flag)
 {
 	if (flag != 0 && flag != 1) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (flag &&
 	    dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
 		pr_err("emulate_write_cache not supported for pSCSI\n");
 		return -EINVAL;
 	}
 	if (flag &&
 	    dev->transport->get_write_cache) {
 		pr_err("emulate_write_cache not supported for this device\n");
 		return -EINVAL;
 	}
 	dev->dev_attrib.emulate_write_cache = flag;
 	pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",
 			dev, dev->dev_attrib.emulate_write_cache);
 	return 0;
 }
 int se_dev_set_emulate_ua_intlck_ctrl(struct se_device *dev, int flag)
 {
 	if ((flag != 0) && (flag != 1) && (flag != 2)) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device"
 			" UA_INTRLCK_CTRL while export_count is %d\n",
 			dev, dev->export_count);
 		return -EINVAL;
 	}
 	dev->dev_attrib.emulate_ua_intlck_ctrl = flag;
 	pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n",
 		dev, dev->dev_attrib.emulate_ua_intlck_ctrl);
 	return 0;
 }
 int se_dev_set_emulate_tas(struct se_device *dev, int flag)
 {
 	if ((flag != 0) && (flag != 1)) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device TAS while"
 			" export_count is %d\n",
 			dev, dev->export_count);
 		return -EINVAL;
 	}
 	dev->dev_attrib.emulate_tas = flag;
 	pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n",
 		dev, (dev->dev_attrib.emulate_tas) ? "Enabled" : "Disabled");
 	return 0;
 }
 int se_dev_set_emulate_tpu(struct se_device *dev, int flag)
 {
 	if ((flag != 0) && (flag != 1)) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	/*
 	 * We expect this value to be non-zero when generic Block Layer
 	 * Discard supported is detected iblock_create_virtdevice().
 	 */
 	if (flag && !dev->dev_attrib.max_unmap_block_desc_count) {
 		pr_err("Generic Block Discard not supported\n");
 		return -ENOSYS;
 	}
 	dev->dev_attrib.emulate_tpu = flag;
 	pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n",
 				dev, flag);
 	return 0;
 }
 int se_dev_set_emulate_tpws(struct se_device *dev, int flag)
 {
 	if ((flag != 0) && (flag != 1)) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	/*
 	 * We expect this value to be non-zero when generic Block Layer
 	 * Discard supported is detected iblock_create_virtdevice().
 	 */
 	if (flag && !dev->dev_attrib.max_unmap_block_desc_count) {
 		pr_err("Generic Block Discard not supported\n");
 		return -ENOSYS;
 	}
 	dev->dev_attrib.emulate_tpws = flag;
 	pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n",
 				dev, flag);
 	return 0;
 }
 int se_dev_set_emulate_caw(struct se_device *dev, int flag)
 {
 	if (flag != 0 && flag != 1) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	dev->dev_attrib.emulate_caw = flag;
 	pr_debug("dev[%p]: SE Device CompareAndWrite (AtomicTestandSet): %d\n",
 		 dev, flag);
 	return 0;
 }
 int se_dev_set_emulate_3pc(struct se_device *dev, int flag)
 {
 	if (flag != 0 && flag != 1) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	dev->dev_attrib.emulate_3pc = flag;
 	pr_debug("dev[%p]: SE Device 3rd Party Copy (EXTENDED_COPY): %d\n",
 		dev, flag);
 	return 0;
 }
 int se_dev_set_pi_prot_type(struct se_device *dev, int flag)
 {
 	int rc, old_prot = dev->dev_attrib.pi_prot_type;
 	if (flag != 0 && flag != 1 && flag != 2 && flag != 3) {
 		pr_err("Illegal value %d for pi_prot_type\n", flag);
 		return -EINVAL;
 	}
 	if (flag == 2) {
 		pr_err("DIF TYPE2 protection currently not supported\n");
 		return -ENOSYS;
 	}
 	if (dev->dev_attrib.hw_pi_prot_type) {
 		pr_warn("DIF protection enabled on underlying hardware,"
 			" ignoring\n");
 		return 0;
 	}
 	if (!dev->transport->init_prot || !dev->transport->free_prot) {
 		/* 0 is only allowed value for non-supporting backends */
 		if (flag == 0)
 			return 0;
 		pr_err("DIF protection not supported by backend: %s\n",
 		       dev->transport->name);
 		return -ENOSYS;
 	}
 	if (!(dev->dev_flags & DF_CONFIGURED)) {
 		pr_err("DIF protection requires device to be configured\n");
 		return -ENODEV;
 	}
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device PROT type while"
 		       " export_count is %d\n", dev, dev->export_count);
 		return -EINVAL;
 	}
 	dev->dev_attrib.pi_prot_type = flag;
 	if (flag && !old_prot) {
 		rc = dev->transport->init_prot(dev);
 		if (rc) {
 			dev->dev_attrib.pi_prot_type = old_prot;
 			return rc;
 		}
 	} else if (!flag && old_prot) {
 		dev->transport->free_prot(dev);
 	}
 	pr_debug("dev[%p]: SE Device Protection Type: %d\n", dev, flag);
 	return 0;
 }
 int se_dev_set_pi_prot_format(struct se_device *dev, int flag)
 {
 	int rc;
 	if (!flag)
 		return 0;
 	if (flag != 1) {
 		pr_err("Illegal value %d for pi_prot_format\n", flag);
 		return -EINVAL;
 	}
 	if (!dev->transport->format_prot) {
 		pr_err("DIF protection format not supported by backend %s\n",
 		       dev->transport->name);
 		return -ENOSYS;
 	}
 	if (!(dev->dev_flags & DF_CONFIGURED)) {
 		pr_err("DIF protection format requires device to be configured\n");
 		return -ENODEV;
 	}
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to format SE Device PROT type while"
 		       " export_count is %d\n", dev, dev->export_count);
 		return -EINVAL;
 	}
 	rc = dev->transport->format_prot(dev);
 	if (rc)
 		return rc;
 	pr_debug("dev[%p]: SE Device Protection Format complete\n", dev);
 	return 0;
 }
 int se_dev_set_enforce_pr_isids(struct se_device *dev, int flag)
 {
 	if ((flag != 0) && (flag != 1)) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	dev->dev_attrib.enforce_pr_isids = flag;
 	pr_debug("dev[%p]: SE Device enforce_pr_isids bit: %s\n", dev,
 		(dev->dev_attrib.enforce_pr_isids) ? "Enabled" : "Disabled");
 	return 0;
 }
 int se_dev_set_force_pr_aptpl(struct se_device *dev, int flag)
 {
 	if ((flag != 0) && (flag != 1)) {
 		printk(KERN_ERR "Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to set force_pr_aptpl while"
 		       " export_count is %d\n", dev, dev->export_count);
 		return -EINVAL;
 	}
 	dev->dev_attrib.force_pr_aptpl = flag;
 	pr_debug("dev[%p]: SE Device force_pr_aptpl: %d\n", dev, flag);
 	return 0;
 }
 int se_dev_set_is_nonrot(struct se_device *dev, int flag)
 {
 	if ((flag != 0) && (flag != 1)) {
 		printk(KERN_ERR "Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	dev->dev_attrib.is_nonrot = flag;
 	pr_debug("dev[%p]: SE Device is_nonrot bit: %d\n",
 	       dev, flag);
 	return 0;
 }
 int se_dev_set_emulate_rest_reord(struct se_device *dev, int flag)
 {
 	if (flag != 0) {
 		printk(KERN_ERR "dev[%p]: SE Device emulatation of restricted"
 			" reordering not implemented\n", dev);
 		return -ENOSYS;
 	}
 	dev->dev_attrib.emulate_rest_reord = flag;
 	pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n", dev, flag);
 	return 0;
 }
 /*
  * Note, this can only be called on unexported SE Device Object.
  */
 int se_dev_set_queue_depth(struct se_device *dev, u32 queue_depth)
 {
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device TCQ while"
 			" export_count is %d\n",
 			dev, dev->export_count);
 		return -EINVAL;
 	}
 	if (!queue_depth) {
 		pr_err("dev[%p]: Illegal ZERO value for queue"
 			"_depth\n", dev);
 		return -EINVAL;
 	}
 	if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
 		if (queue_depth > dev->dev_attrib.hw_queue_depth) {
 			pr_err("dev[%p]: Passed queue_depth: %u"
 				" exceeds TCM/SE_Device TCQ: %u\n",
 				dev, queue_depth,
 				dev->dev_attrib.hw_queue_depth);
 			return -EINVAL;
 		}
 	} else {
 		if (queue_depth > dev->dev_attrib.queue_depth) {
 			if (queue_depth > dev->dev_attrib.hw_queue_depth) {
 				pr_err("dev[%p]: Passed queue_depth:"
 					" %u exceeds TCM/SE_Device MAX"
 					" TCQ: %u\n", dev, queue_depth,
 					dev->dev_attrib.hw_queue_depth);
 				return -EINVAL;
 			}
 		}
 	}
 	dev->dev_attrib.queue_depth = dev->queue_depth = queue_depth;
 	pr_debug("dev[%p]: SE Device TCQ Depth changed to: %u\n",
 			dev, queue_depth);
 	return 0;
 }
 int se_dev_set_fabric_max_sectors(struct se_device *dev, u32 fabric_max_sectors)
 {
 	int block_size = dev->dev_attrib.block_size;
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device"
 			" fabric_max_sectors while export_count is %d\n",
 			dev, dev->export_count);
 		return -EINVAL;
 	}
 	if (!fabric_max_sectors) {
 		pr_err("dev[%p]: Illegal ZERO value for"
 			" fabric_max_sectors\n", dev);
 		return -EINVAL;
 	}
 	if (fabric_max_sectors < DA_STATUS_MAX_SECTORS_MIN) {
 		pr_err("dev[%p]: Passed fabric_max_sectors: %u less than"
 			" DA_STATUS_MAX_SECTORS_MIN: %u\n", dev, fabric_max_sectors,
 				DA_STATUS_MAX_SECTORS_MIN);
 		return -EINVAL;
 	}
 	if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
 		if (fabric_max_sectors > dev->dev_attrib.hw_max_sectors) {
 			pr_err("dev[%p]: Passed fabric_max_sectors: %u"
 				" greater than TCM/SE_Device max_sectors:"
 				" %u\n", dev, fabric_max_sectors,
 				dev->dev_attrib.hw_max_sectors);
 			 return -EINVAL;
 		}
 	} else {
 		if (fabric_max_sectors > DA_STATUS_MAX_SECTORS_MAX) {
 			pr_err("dev[%p]: Passed fabric_max_sectors: %u"
 				" greater than DA_STATUS_MAX_SECTORS_MAX:"
 				" %u\n", dev, fabric_max_sectors,
 				DA_STATUS_MAX_SECTORS_MAX);
 			return -EINVAL;
 		}
 	}
 	/*
 	 * Align max_sectors down to PAGE_SIZE to follow transport_allocate_data_tasks()
 	 */
 	if (!block_size) {
 		block_size = 512;
 		pr_warn("Defaulting to 512 for zero block_size\n");
 	}
 	fabric_max_sectors = se_dev_align_max_sectors(fabric_max_sectors,
 						      block_size);
 	dev->dev_attrib.fabric_max_sectors = fabric_max_sectors;
 	pr_debug("dev[%p]: SE Device max_sectors changed to %u\n",
 			dev, fabric_max_sectors);
 	return 0;
 }
 int se_dev_set_optimal_sectors(struct se_device *dev, u32 optimal_sectors)
 {
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device"
 			" optimal_sectors while export_count is %d\n",
 			dev, dev->export_count);
 		return -EINVAL;
 	}
 	if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
 		pr_err("dev[%p]: Passed optimal_sectors cannot be"
 				" changed for TCM/pSCSI\n", dev);
 		return -EINVAL;
 	}
-	if (optimal_sectors > dev->dev_attrib.fabric_max_sectors) {
+	if (optimal_sectors > dev->dev_attrib.hw_max_sectors) {
 		pr_err("dev[%p]: Passed optimal_sectors %u cannot be"
-			" greater than fabric_max_sectors: %u\n", dev,
+			" greater than hw_max_sectors: %u\n", dev,
-			optimal_sectors, dev->dev_attrib.fabric_max_sectors);
+			optimal_sectors, dev->dev_attrib.hw_max_sectors);
 		return -EINVAL;
 	}
 	dev->dev_attrib.optimal_sectors = optimal_sectors;
 	pr_debug("dev[%p]: SE Device optimal_sectors changed to %u\n",
 			dev, optimal_sectors);
 	return 0;
 }
 int se_dev_set_block_size(struct se_device *dev, u32 block_size)
 {
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device block_size"
 			" while export_count is %d\n",
 			dev, dev->export_count);
 		return -EINVAL;
 	}
 	if ((block_size != 512) &&
 	    (block_size != 1024) &&
 	    (block_size != 2048) &&
 	    (block_size != 4096)) {
 		pr_err("dev[%p]: Illegal value for block_device: %u"
 			" for SE device, must be 512, 1024, 2048 or 4096\n",
 			dev, block_size);
 		return -EINVAL;
 	}
 	if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
 		pr_err("dev[%p]: Not allowed to change block_size for"
 			" Physical Device, use for Linux/SCSI to change"
 			" block_size for underlying hardware\n", dev);
 		return -EINVAL;
 	}
 	dev->dev_attrib.block_size = block_size;
 	pr_debug("dev[%p]: SE Device block_size changed to %u\n",
 			dev, block_size);
 	if (dev->dev_attrib.max_bytes_per_io)
 		dev->dev_attrib.hw_max_sectors =
 			dev->dev_attrib.max_bytes_per_io / block_size;
 	return 0;
 }
 struct se_lun *core_dev_add_lun(
 	struct se_portal_group *tpg,
 	struct se_device *dev,
 	u32 unpacked_lun)
 {
 	struct se_lun *lun;
 	int rc;
 	lun = core_tpg_alloc_lun(tpg, unpacked_lun);
 	if (IS_ERR(lun))
 		return lun;
 	rc = core_tpg_add_lun(tpg, lun,
 				TRANSPORT_LUNFLAGS_READ_WRITE, dev);
 	if (rc < 0)
 		return ERR_PTR(rc);
 	pr_debug("%s_TPG[%u]_LUN[%u] - Activated %s Logical Unit from"
 		" CORE HBA: %u\n", tpg->se_tpg_tfo->get_fabric_name(),
 		tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
 		tpg->se_tpg_tfo->get_fabric_name(), dev->se_hba->hba_id);
 	/*
 	 * Update LUN maps for dynamically added initiators when
 	 * generate_node_acl is enabled.
 	 */
 	if (tpg->se_tpg_tfo->tpg_check_demo_mode(tpg)) {
 		struct se_node_acl *acl;
 		spin_lock_irq(&tpg->acl_node_lock);
 		list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {
 			if (acl->dynamic_node_acl &&
 			    (!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only ||
 			     !tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg))) {
 				spin_unlock_irq(&tpg->acl_node_lock);
 				core_tpg_add_node_to_devs(acl, tpg);
 				spin_lock_irq(&tpg->acl_node_lock);
 			}
 		}
 		spin_unlock_irq(&tpg->acl_node_lock);
 	}
 	return lun;
 }
 /*      core_dev_del_lun():
  *
  *
  */
 void core_dev_del_lun(
 	struct se_portal_group *tpg,
 	struct se_lun *lun)
 {
 	pr_debug("%s_TPG[%u]_LUN[%u] - Deactivating %s Logical Unit from"
 		" device object\n", tpg->se_tpg_tfo->get_fabric_name(),
 		tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
 		tpg->se_tpg_tfo->get_fabric_name());
 	core_tpg_remove_lun(tpg, lun);
 }
 struct se_lun *core_get_lun_from_tpg(struct se_portal_group *tpg, u32 unpacked_lun)
 {
 	struct se_lun *lun;
 	spin_lock(&tpg->tpg_lun_lock);
 	if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
 		pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS"
 			"_PER_TPG-1: %u for Target Portal Group: %hu\n",
 			tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
 			TRANSPORT_MAX_LUNS_PER_TPG-1,
 			tpg->se_tpg_tfo->tpg_get_tag(tpg));
 		spin_unlock(&tpg->tpg_lun_lock);
 		return NULL;
 	}
 	lun = tpg->tpg_lun_list[unpacked_lun];
 	if (lun->lun_status != TRANSPORT_LUN_STATUS_FREE) {
 		pr_err("%s Logical Unit Number: %u is not free on"
 			" Target Portal Group: %hu, ignoring request.\n",
 			tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
 			tpg->se_tpg_tfo->tpg_get_tag(tpg));
 		spin_unlock(&tpg->tpg_lun_lock);
 		return NULL;
 	}
 	spin_unlock(&tpg->tpg_lun_lock);
 	return lun;
 }
 /*      core_dev_get_lun():
  *
  *
  */
 static struct se_lun *core_dev_get_lun(struct se_portal_group *tpg, u32 unpacked_lun)
 {
 	struct se_lun *lun;
 	spin_lock(&tpg->tpg_lun_lock);
 	if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
 		pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS_PER"
 			"_TPG-1: %u for Target Portal Group: %hu\n",
 			tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
 			TRANSPORT_MAX_LUNS_PER_TPG-1,
 			tpg->se_tpg_tfo->tpg_get_tag(tpg));
 		spin_unlock(&tpg->tpg_lun_lock);
 		return NULL;
 	}
 	lun = tpg->tpg_lun_list[unpacked_lun];
 	if (lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) {
 		pr_err("%s Logical Unit Number: %u is not active on"
 			" Target Portal Group: %hu, ignoring request.\n",
 			tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
 			tpg->se_tpg_tfo->tpg_get_tag(tpg));
 		spin_unlock(&tpg->tpg_lun_lock);
 		return NULL;
 	}
 	spin_unlock(&tpg->tpg_lun_lock);
 	return lun;
 }
 struct se_lun_acl *core_dev_init_initiator_node_lun_acl(
 	struct se_portal_group *tpg,
 	struct se_node_acl *nacl,
 	u32 mapped_lun,
 	int *ret)
 {
 	struct se_lun_acl *lacl;
 	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;
 	}
 	lacl = kzalloc(sizeof(struct se_lun_acl), GFP_KERNEL);
 	if (!lacl) {
 		pr_err("Unable to allocate memory for struct se_lun_acl.\n");
 		*ret = -ENOMEM;
 		return NULL;
 	}
 	INIT_LIST_HEAD(&lacl->lacl_list);
 	lacl->mapped_lun = mapped_lun;
 	lacl->se_lun_nacl = nacl;
 	snprintf(lacl->initiatorname, TRANSPORT_IQN_LEN, "%s",
 		 nacl->initiatorname);
 	return lacl;
 }
 int core_dev_add_initiator_node_lun_acl(
 	struct se_portal_group *tpg,
 	struct se_lun_acl *lacl,
 	u32 unpacked_lun,
 	u32 lun_access)
 {
 	struct se_lun *lun;
 	struct se_node_acl *nacl;
 	lun = core_dev_get_lun(tpg, unpacked_lun);
 	if (!lun) {
 		pr_err("%s Logical Unit Number: %u is not active on"
 			" Target Portal Group: %hu, ignoring request.\n",
 			tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
 			tpg->se_tpg_tfo->tpg_get_tag(tpg));
 		return -EINVAL;
 	}
 	nacl = lacl->se_lun_nacl;
 	if (!nacl)
 		return -EINVAL;
 	if ((lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) &&
 	    (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE))
 		lun_access = TRANSPORT_LUNFLAGS_READ_ONLY;
 	lacl->se_lun = lun;
 	if (core_enable_device_list_for_node(lun, lacl, lacl->mapped_lun,
 			lun_access, nacl, tpg) < 0)
 		return -EINVAL;
 	spin_lock(&lun->lun_acl_lock);
 	list_add_tail(&lacl->lacl_list, &lun->lun_acl_list);
 	atomic_inc_mb(&lun->lun_acl_count);
 	spin_unlock(&lun->lun_acl_lock);
 	pr_debug("%s_TPG[%hu]_LUN[%u->%u] - Added %s ACL for "
 		" InitiatorNode: %s\n", tpg->se_tpg_tfo->get_fabric_name(),
 		tpg->se_tpg_tfo->tpg_get_tag(tpg), unpacked_lun, lacl->mapped_lun,
 		(lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) ? "RW" : "RO",
 		lacl->initiatorname);
 	/*
 	 * Check to see if there are any existing persistent reservation APTPL
 	 * pre-registrations that need to be enabled for this LUN ACL..
 	 */
 	core_scsi3_check_aptpl_registration(lun->lun_se_dev, tpg, lun, nacl,
 					    lacl->mapped_lun);
 	return 0;
 }
 /*      core_dev_del_initiator_node_lun_acl():
  *
  *
  */
 int core_dev_del_initiator_node_lun_acl(
 	struct se_portal_group *tpg,
 	struct se_lun *lun,
 	struct se_lun_acl *lacl)
 {
 	struct se_node_acl *nacl;
 	nacl = lacl->se_lun_nacl;
 	if (!nacl)
 		return -EINVAL;
 	spin_lock(&lun->lun_acl_lock);
 	list_del(&lacl->lacl_list);
 	atomic_dec_mb(&lun->lun_acl_count);
 	spin_unlock(&lun->lun_acl_lock);
 	core_disable_device_list_for_node(lun, NULL, lacl->mapped_lun,
 		TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);
 	lacl->se_lun = NULL;
 	pr_debug("%s_TPG[%hu]_LUN[%u] - Removed ACL for"
 		" InitiatorNode: %s Mapped LUN: %u\n",
 		tpg->se_tpg_tfo->get_fabric_name(),
 		tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
 		lacl->initiatorname, lacl->mapped_lun);
 	return 0;
 }
 void core_dev_free_initiator_node_lun_acl(
 	struct se_portal_group *tpg,
 	struct se_lun_acl *lacl)
 {
 	pr_debug("%s_TPG[%hu] - Freeing ACL for %s InitiatorNode: %s"
 		" Mapped LUN: %u\n", tpg->se_tpg_tfo->get_fabric_name(),
 		tpg->se_tpg_tfo->tpg_get_tag(tpg),
 		tpg->se_tpg_tfo->get_fabric_name(),
 		lacl->initiatorname, lacl->mapped_lun);
 	kfree(lacl);
 }
 static void scsi_dump_inquiry(struct se_device *dev)
 {
 	struct t10_wwn *wwn = &dev->t10_wwn;
 	char buf[17];
 	int i, device_type;
 	/*
 	 * Print Linux/SCSI style INQUIRY formatting to the kernel ring buffer
 	 */
 	for (i = 0; i < 8; i++)
 		if (wwn->vendor[i] >= 0x20)
 			buf[i] = wwn->vendor[i];
 		else
 			buf[i] = ' ';
 	buf[i] = '\0';
 	pr_debug("  Vendor: %s\n", buf);
 	for (i = 0; i < 16; i++)
 		if (wwn->model[i] >= 0x20)
 			buf[i] = wwn->model[i];
 		else
 			buf[i] = ' ';
 	buf[i] = '\0';
 	pr_debug("  Model: %s\n", buf);
 	for (i = 0; i < 4; i++)
 		if (wwn->revision[i] >= 0x20)
 			buf[i] = wwn->revision[i];
 		else
 			buf[i] = ' ';
 	buf[i] = '\0';
 	pr_debug("  Revision: %s\n", buf);
 	device_type = dev->transport->get_device_type(dev);
 	pr_debug("  Type:   %s ", scsi_device_type(device_type));
 }
 struct se_device *target_alloc_device(struct se_hba *hba, const char *name)
 {
 	struct se_device *dev;
 	struct se_lun *xcopy_lun;
 	dev = hba->transport->alloc_device(hba, name);
 	if (!dev)
 		return NULL;
 	dev->dev_link_magic = SE_DEV_LINK_MAGIC;
 	dev->se_hba = hba;
 	dev->transport = hba->transport;
 	dev->prot_length = sizeof(struct se_dif_v1_tuple);
 	INIT_LIST_HEAD(&dev->dev_list);
 	INIT_LIST_HEAD(&dev->dev_sep_list);
 	INIT_LIST_HEAD(&dev->dev_tmr_list);
 	INIT_LIST_HEAD(&dev->delayed_cmd_list);
 	INIT_LIST_HEAD(&dev->state_list);
 	INIT_LIST_HEAD(&dev->qf_cmd_list);
 	INIT_LIST_HEAD(&dev->g_dev_node);
 	spin_lock_init(&dev->execute_task_lock);
 	spin_lock_init(&dev->delayed_cmd_lock);
 	spin_lock_init(&dev->dev_reservation_lock);
 	spin_lock_init(&dev->se_port_lock);
 	spin_lock_init(&dev->se_tmr_lock);
 	spin_lock_init(&dev->qf_cmd_lock);
 	sema_init(&dev->caw_sem, 1);
 	atomic_set(&dev->dev_ordered_id, 0);
 	INIT_LIST_HEAD(&dev->t10_wwn.t10_vpd_list);
 	spin_lock_init(&dev->t10_wwn.t10_vpd_lock);
 	INIT_LIST_HEAD(&dev->t10_pr.registration_list);
 	INIT_LIST_HEAD(&dev->t10_pr.aptpl_reg_list);
 	spin_lock_init(&dev->t10_pr.registration_lock);
 	spin_lock_init(&dev->t10_pr.aptpl_reg_lock);
 	INIT_LIST_HEAD(&dev->t10_alua.tg_pt_gps_list);
 	spin_lock_init(&dev->t10_alua.tg_pt_gps_lock);
 	INIT_LIST_HEAD(&dev->t10_alua.lba_map_list);
 	spin_lock_init(&dev->t10_alua.lba_map_lock);
 	dev->t10_wwn.t10_dev = dev;
 	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;
 	dev->dev_attrib.emulate_write_cache = DA_EMULATE_WRITE_CACHE;
 	dev->dev_attrib.emulate_ua_intlck_ctrl = DA_EMULATE_UA_INTLLCK_CTRL;
 	dev->dev_attrib.emulate_tas = DA_EMULATE_TAS;
 	dev->dev_attrib.emulate_tpu = DA_EMULATE_TPU;
 	dev->dev_attrib.emulate_tpws = DA_EMULATE_TPWS;
 	dev->dev_attrib.emulate_caw = DA_EMULATE_CAW;
 	dev->dev_attrib.emulate_3pc = DA_EMULATE_3PC;
 	dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE0_PROT;
 	dev->dev_attrib.enforce_pr_isids = DA_ENFORCE_PR_ISIDS;
 	dev->dev_attrib.force_pr_aptpl = DA_FORCE_PR_APTPL;
 	dev->dev_attrib.is_nonrot = DA_IS_NONROT;
 	dev->dev_attrib.emulate_rest_reord = DA_EMULATE_REST_REORD;
 	dev->dev_attrib.max_unmap_lba_count = DA_MAX_UNMAP_LBA_COUNT;
 	dev->dev_attrib.max_unmap_block_desc_count =
 		DA_MAX_UNMAP_BLOCK_DESC_COUNT;
 	dev->dev_attrib.unmap_granularity = DA_UNMAP_GRANULARITY_DEFAULT;
 	dev->dev_attrib.unmap_granularity_alignment =
 				DA_UNMAP_GRANULARITY_ALIGNMENT_DEFAULT;
 	dev->dev_attrib.max_write_same_len = DA_MAX_WRITE_SAME_LEN;
 	dev->dev_attrib.fabric_max_sectors = DA_FABRIC_MAX_SECTORS;
-	dev->dev_attrib.optimal_sectors = DA_FABRIC_MAX_SECTORS;
 	xcopy_lun = &dev->xcopy_lun;
 	xcopy_lun->lun_se_dev = dev;
 	init_completion(&xcopy_lun->lun_shutdown_comp);
 	INIT_LIST_HEAD(&xcopy_lun->lun_acl_list);
 	spin_lock_init(&xcopy_lun->lun_acl_lock);
 	spin_lock_init(&xcopy_lun->lun_sep_lock);
 	init_completion(&xcopy_lun->lun_ref_comp);
 	return dev;
 }
 int target_configure_device(struct se_device *dev)
 {
 	struct se_hba *hba = dev->se_hba;
 	int ret;
 	if (dev->dev_flags & DF_CONFIGURED) {
 		pr_err("se_dev->se_dev_ptr already set for storage"
 				" object\n");
 		return -EEXIST;
 	}
 	ret = dev->transport->configure_device(dev);
 	if (ret)
 		goto out;
 	dev->dev_flags |= DF_CONFIGURED;
 	/*
 	 * XXX: there is not much point to have two different values here..
 	 */
 	dev->dev_attrib.block_size = dev->dev_attrib.hw_block_size;
 	dev->dev_attrib.queue_depth = dev->dev_attrib.hw_queue_depth;
 	/*
 	 * Align max_hw_sectors down to PAGE_SIZE I/O transfers
 	 */
 	dev->dev_attrib.hw_max_sectors =
 		se_dev_align_max_sectors(dev->dev_attrib.hw_max_sectors,
 					 dev->dev_attrib.hw_block_size);
+	dev->dev_attrib.optimal_sectors = dev->dev_attrib.hw_max_sectors;
 	dev->dev_index = scsi_get_new_index(SCSI_DEVICE_INDEX);
 	dev->creation_time = get_jiffies_64();
 	ret = core_setup_alua(dev);
 	if (ret)
 		goto out;
 	/*
 	 * Startup the struct se_device processing thread
 	 */
 	dev->tmr_wq = alloc_workqueue("tmr-%s", WQ_MEM_RECLAIM | WQ_UNBOUND, 1,
 				      dev->transport->name);
 	if (!dev->tmr_wq) {
 		pr_err("Unable to create tmr workqueue for %s\n",
 			dev->transport->name);
 		ret = -ENOMEM;
 		goto out_free_alua;
 	}
 	/*
 	 * Setup work_queue for QUEUE_FULL
 	 */
 	INIT_WORK(&dev->qf_work_queue, target_qf_do_work);
 	/*
 	 * Preload the initial INQUIRY const values if we are doing
 	 * anything virtual (IBLOCK, FILEIO, RAMDISK), but not for TCM/pSCSI
 	 * passthrough because this is being provided by the backend LLD.
 	 */
 	if (dev->transport->transport_type != TRANSPORT_PLUGIN_PHBA_PDEV) {
 		strncpy(&dev->t10_wwn.vendor[0], "LIO-ORG", 8);
 		strncpy(&dev->t10_wwn.model[0],
 			dev->transport->inquiry_prod, 16);
 		strncpy(&dev->t10_wwn.revision[0],
 			dev->transport->inquiry_rev, 4);
 	}
 	scsi_dump_inquiry(dev);
 	spin_lock(&hba->device_lock);
 	hba->dev_count++;
 	spin_unlock(&hba->device_lock);
 	mutex_lock(&g_device_mutex);
 	list_add_tail(&dev->g_dev_node, &g_device_list);
 	mutex_unlock(&g_device_mutex);
 	return 0;
 out_free_alua:
 	core_alua_free_lu_gp_mem(dev);
 out:
 	se_release_vpd_for_dev(dev);
 	return ret;
 }
 void target_free_device(struct se_device *dev)
 {
 	struct se_hba *hba = dev->se_hba;
 	WARN_ON(!list_empty(&dev->dev_sep_list));
 	if (dev->dev_flags & DF_CONFIGURED) {
 		destroy_workqueue(dev->tmr_wq);
 		mutex_lock(&g_device_mutex);
 		list_del(&dev->g_dev_node);
 		mutex_unlock(&g_device_mutex);
 		spin_lock(&hba->device_lock);
 		hba->dev_count--;
 		spin_unlock(&hba->device_lock);
 	}
 	core_alua_free_lu_gp_mem(dev);
 	core_alua_set_lba_map(dev, NULL, 0, 0);
 	core_scsi3_free_all_registrations(dev);
 	se_release_vpd_for_dev(dev);
 	if (dev->transport->free_prot)
 		dev->transport->free_prot(dev);
 	dev->transport->free_device(dev);
 }
 int core_dev_setup_virtual_lun0(void)
 {
 	struct se_hba *hba;
 	struct se_device *dev;
 	char buf[] = "rd_pages=8,rd_nullio=1";
 	int ret;
 	hba = core_alloc_hba("rd_mcp", 0, HBA_FLAGS_INTERNAL_USE);
 	if (IS_ERR(hba))
 		return PTR_ERR(hba);
 	dev = target_alloc_device(hba, "virt_lun0");
 	if (!dev) {
 		ret = -ENOMEM;
 		goto out_free_hba;
 	}
 	hba->transport->set_configfs_dev_params(dev, buf, sizeof(buf));
 	ret = target_configure_device(dev);
 	if (ret)
 		goto out_free_se_dev;
 	lun0_hba = hba;
 	g_lun0_dev = dev;
 	return 0;
 out_free_se_dev:
 	target_free_device(dev);
 out_free_hba:
 	core_delete_hba(hba);
 	return ret;
 }
 void core_dev_release_virtual_lun0(void)
 {
 	struct se_hba *hba = lun0_hba;
 	if (!hba)
 		return;
 	if (g_lun0_dev)
 		target_free_device(g_lun0_dev);
 	core_delete_hba(hba);
 }

drivers/target/target_core_file.c

Diff comments View file @ 82bc9d0

1	/*******************************************************************************	1	/*******************************************************************************
2	* Filename: target_core_file.c	2	* Filename: target_core_file.c
3	*	3	*
4	* This file contains the Storage Engine <-> FILEIO transport specific functions	4	* This file contains the Storage Engine <-> FILEIO transport specific functions
5	*	5	*
6	* (c) Copyright 2005-2013 Datera, Inc.	6	* (c) Copyright 2005-2013 Datera, Inc.
7	*	7	*
8	* Nicholas A. Bellinger <nab@kernel.org>	8	* Nicholas A. Bellinger <nab@kernel.org>
9	*	9	*
10	* This program is free software; you can redistribute it and/or modify	10	* This program is free software; you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by	11	* it under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; either version 2 of the License, or	12	* the Free Software Foundation; either version 2 of the License, or
13	* (at your option) any later version.	13	* (at your option) any later version.
14	*	14	*
15	* This program is distributed in the hope that it will be useful,	15	* This program is distributed in the hope that it will be useful,
16	* but WITHOUT ANY WARRANTY; without even the implied warranty of	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18	* GNU General Public License for more details.	18	* GNU General Public License for more details.
19	*	19	*
20	* You should have received a copy of the GNU General Public License	20	* You should have received a copy of the GNU General Public License
21	* along with this program; if not, write to the Free Software	21	* along with this program; if not, write to the Free Software
22	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.	22	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23	*	23	*
24	******************************************************************************/	24	******************************************************************************/
25		25
26	#include <linux/string.h>	26	#include <linux/string.h>
27	#include <linux/parser.h>	27	#include <linux/parser.h>
28	#include <linux/timer.h>	28	#include <linux/timer.h>
29	#include <linux/blkdev.h>	29	#include <linux/blkdev.h>
30	#include <linux/slab.h>	30	#include <linux/slab.h>
31	#include <linux/spinlock.h>	31	#include <linux/spinlock.h>
32	#include <linux/module.h>	32	#include <linux/module.h>
33	#include <linux/falloc.h>	33	#include <linux/falloc.h>
34	#include <scsi/scsi.h>	34	#include <scsi/scsi.h>
35	#include <scsi/scsi_host.h>	35	#include <scsi/scsi_host.h>
36	#include <asm/unaligned.h>	36	#include <asm/unaligned.h>
37		37
38	#include <target/target_core_base.h>	38	#include <target/target_core_base.h>
39	#include <target/target_core_backend.h>	39	#include <target/target_core_backend.h>
40		40
41	#include "target_core_file.h"	41	#include "target_core_file.h"
42		42
43	static inline struct fd_dev FD_DEV(struct se_device dev)	43	static inline struct fd_dev FD_DEV(struct se_device dev)
44	{	44	{
45	return container_of(dev, struct fd_dev, dev);	45	return container_of(dev, struct fd_dev, dev);
46	}	46	}
47		47
48	/* fd_attach_hba(): (Part of se_subsystem_api_t template)	48	/* fd_attach_hba(): (Part of se_subsystem_api_t template)
49	*	49	*
50	*	50	*
51	*/	51	*/
52	static int fd_attach_hba(struct se_hba *hba, u32 host_id)	52	static int fd_attach_hba(struct se_hba *hba, u32 host_id)
53	{	53	{
54	struct fd_host *fd_host;	54	struct fd_host *fd_host;
55		55
56	fd_host = kzalloc(sizeof(struct fd_host), GFP_KERNEL);	56	fd_host = kzalloc(sizeof(struct fd_host), GFP_KERNEL);
57	if (!fd_host) {	57	if (!fd_host) {
58	pr_err("Unable to allocate memory for struct fd_host\n");	58	pr_err("Unable to allocate memory for struct fd_host\n");
59	return -ENOMEM;	59	return -ENOMEM;
60	}	60	}
61		61
62	fd_host->fd_host_id = host_id;	62	fd_host->fd_host_id = host_id;
63		63
64	hba->hba_ptr = fd_host;	64	hba->hba_ptr = fd_host;
65		65
66	pr_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic"	66	pr_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic"
67	" Target Core Stack %s\n", hba->hba_id, FD_VERSION,	67	" Target Core Stack %s\n", hba->hba_id, FD_VERSION,
68	TARGET_CORE_MOD_VERSION);	68	TARGET_CORE_MOD_VERSION);
69	pr_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic\n",	69	pr_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic\n",
70	hba->hba_id, fd_host->fd_host_id);	70	hba->hba_id, fd_host->fd_host_id);
71		71
72	return 0;	72	return 0;
73	}	73	}
74		74
75	static void fd_detach_hba(struct se_hba *hba)	75	static void fd_detach_hba(struct se_hba *hba)
76	{	76	{
77	struct fd_host *fd_host = hba->hba_ptr;	77	struct fd_host *fd_host = hba->hba_ptr;
78		78
79	pr_debug("CORE_HBA[%d] - Detached FILEIO HBA: %u from Generic"	79	pr_debug("CORE_HBA[%d] - Detached FILEIO HBA: %u from Generic"
80	" Target Core\n", hba->hba_id, fd_host->fd_host_id);	80	" Target Core\n", hba->hba_id, fd_host->fd_host_id);
81		81
82	kfree(fd_host);	82	kfree(fd_host);
83	hba->hba_ptr = NULL;	83	hba->hba_ptr = NULL;
84	}	84	}
85		85
86	static struct se_device fd_alloc_device(struct se_hba hba, const char *name)	86	static struct se_device fd_alloc_device(struct se_hba hba, const char *name)
87	{	87	{
88	struct fd_dev *fd_dev;	88	struct fd_dev *fd_dev;
89	struct fd_host *fd_host = hba->hba_ptr;	89	struct fd_host *fd_host = hba->hba_ptr;
90		90
91	fd_dev = kzalloc(sizeof(struct fd_dev), GFP_KERNEL);	91	fd_dev = kzalloc(sizeof(struct fd_dev), GFP_KERNEL);
92	if (!fd_dev) {	92	if (!fd_dev) {
93	pr_err("Unable to allocate memory for struct fd_dev\n");	93	pr_err("Unable to allocate memory for struct fd_dev\n");
94	return NULL;	94	return NULL;
95	}	95	}
96		96
97	fd_dev->fd_host = fd_host;	97	fd_dev->fd_host = fd_host;
98		98
99	pr_debug("FILEIO: Allocated fd_dev for %p\n", name);	99	pr_debug("FILEIO: Allocated fd_dev for %p\n", name);
100		100
101	return &fd_dev->dev;	101	return &fd_dev->dev;
102	}	102	}
103		103
104	static int fd_configure_device(struct se_device *dev)	104	static int fd_configure_device(struct se_device *dev)
105	{	105	{
106	struct fd_dev *fd_dev = FD_DEV(dev);	106	struct fd_dev *fd_dev = FD_DEV(dev);
107	struct fd_host *fd_host = dev->se_hba->hba_ptr;	107	struct fd_host *fd_host = dev->se_hba->hba_ptr;
108	struct file *file;	108	struct file *file;
109	struct inode *inode = NULL;	109	struct inode *inode = NULL;
110	int flags, ret = -EINVAL;	110	int flags, ret = -EINVAL;
111		111
112	if (!(fd_dev->fbd_flags & FBDF_HAS_PATH)) {	112	if (!(fd_dev->fbd_flags & FBDF_HAS_PATH)) {
113	pr_err("Missing fd_dev_name=\n");	113	pr_err("Missing fd_dev_name=\n");
114	return -EINVAL;	114	return -EINVAL;
115	}	115	}
116		116
117	/*	117	/*
118	* Use O_DSYNC by default instead of O_SYNC to forgo syncing	118	* Use O_DSYNC by default instead of O_SYNC to forgo syncing
119	* of pure timestamp updates.	119	* of pure timestamp updates.
120	*/	120	*/
121	flags = O_RDWR \| O_CREAT \| O_LARGEFILE \| O_DSYNC;	121	flags = O_RDWR \| O_CREAT \| O_LARGEFILE \| O_DSYNC;
122		122
123	/*	123	/*
124	* Optionally allow fd_buffered_io=1 to be enabled for people	124	* Optionally allow fd_buffered_io=1 to be enabled for people
125	* who want use the fs buffer cache as an WriteCache mechanism.	125	* who want use the fs buffer cache as an WriteCache mechanism.
126	*	126	*
127	* This means that in event of a hard failure, there is a risk	127	* This means that in event of a hard failure, there is a risk
128	* of silent data-loss if the SCSI client has not performed a	128	* of silent data-loss if the SCSI client has not performed a
129	* forced unit access (FUA) write, or issued SYNCHRONIZE_CACHE	129	* forced unit access (FUA) write, or issued SYNCHRONIZE_CACHE
130	* to write-out the entire device cache.	130	* to write-out the entire device cache.
131	*/	131	*/
132	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {	132	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {
133	pr_debug("FILEIO: Disabling O_DSYNC, using buffered FILEIO\n");	133	pr_debug("FILEIO: Disabling O_DSYNC, using buffered FILEIO\n");
134	flags &= ~O_DSYNC;	134	flags &= ~O_DSYNC;
135	}	135	}
136		136
137	file = filp_open(fd_dev->fd_dev_name, flags, 0600);	137	file = filp_open(fd_dev->fd_dev_name, flags, 0600);
138	if (IS_ERR(file)) {	138	if (IS_ERR(file)) {
139	pr_err("filp_open(%s) failed\n", fd_dev->fd_dev_name);	139	pr_err("filp_open(%s) failed\n", fd_dev->fd_dev_name);
140	ret = PTR_ERR(file);	140	ret = PTR_ERR(file);
141	goto fail;	141	goto fail;
142	}	142	}
143	fd_dev->fd_file = file;	143	fd_dev->fd_file = file;
144	/*	144	/*
145	* If using a block backend with this struct file, we extract	145	* If using a block backend with this struct file, we extract
146	* fd_dev->fd_[block,dev]_size from struct block_device.	146	* fd_dev->fd_[block,dev]_size from struct block_device.
147	*	147	*
148	* Otherwise, we use the passed fd_size= from configfs	148	* Otherwise, we use the passed fd_size= from configfs
149	*/	149	*/
150	inode = file->f_mapping->host;	150	inode = file->f_mapping->host;
151	if (S_ISBLK(inode->i_mode)) {	151	if (S_ISBLK(inode->i_mode)) {
152	struct request_queue *q = bdev_get_queue(inode->i_bdev);	152	struct request_queue *q = bdev_get_queue(inode->i_bdev);
153	unsigned long long dev_size;	153	unsigned long long dev_size;
154		154
155	fd_dev->fd_block_size = bdev_logical_block_size(inode->i_bdev);	155	fd_dev->fd_block_size = bdev_logical_block_size(inode->i_bdev);
156	/*	156	/*
157	* Determine the number of bytes from i_size_read() minus	157	* Determine the number of bytes from i_size_read() minus
158	* one (1) logical sector from underlying struct block_device	158	* one (1) logical sector from underlying struct block_device
159	*/	159	*/
160	dev_size = (i_size_read(file->f_mapping->host) -	160	dev_size = (i_size_read(file->f_mapping->host) -
161	fd_dev->fd_block_size);	161	fd_dev->fd_block_size);
162		162
163	pr_debug("FILEIO: Using size: %llu bytes from struct"	163	pr_debug("FILEIO: Using size: %llu bytes from struct"
164	" block_device blocks: %llu logical_block_size: %d\n",	164	" block_device blocks: %llu logical_block_size: %d\n",
165	dev_size, div_u64(dev_size, fd_dev->fd_block_size),	165	dev_size, div_u64(dev_size, fd_dev->fd_block_size),
166	fd_dev->fd_block_size);	166	fd_dev->fd_block_size);
167	/*	167	/*
168	* Check if the underlying struct block_device request_queue supports	168	* Check if the underlying struct block_device request_queue supports
169	* the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM	169	* the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM
170	* in ATA and we need to set TPE=1	170	* in ATA and we need to set TPE=1
171	*/	171	*/
172	if (blk_queue_discard(q)) {	172	if (blk_queue_discard(q)) {
173	dev->dev_attrib.max_unmap_lba_count =	173	dev->dev_attrib.max_unmap_lba_count =
174	q->limits.max_discard_sectors;	174	q->limits.max_discard_sectors;
175	/*	175	/*
176	* Currently hardcoded to 1 in Linux/SCSI code..	176	* Currently hardcoded to 1 in Linux/SCSI code..
177	*/	177	*/
178	dev->dev_attrib.max_unmap_block_desc_count = 1;	178	dev->dev_attrib.max_unmap_block_desc_count = 1;
179	dev->dev_attrib.unmap_granularity =	179	dev->dev_attrib.unmap_granularity =
180	q->limits.discard_granularity >> 9;	180	q->limits.discard_granularity >> 9;
181	dev->dev_attrib.unmap_granularity_alignment =	181	dev->dev_attrib.unmap_granularity_alignment =
182	q->limits.discard_alignment;	182	q->limits.discard_alignment;
183	pr_debug("IFILE: BLOCK Discard support available,"	183	pr_debug("IFILE: BLOCK Discard support available,"
184	" disabled by default\n");	184	" disabled by default\n");
185	}	185	}
186	/*	186	/*
187	* Enable write same emulation for IBLOCK and use 0xFFFF as	187	* Enable write same emulation for IBLOCK and use 0xFFFF as
188	* the smaller WRITE_SAME(10) only has a two-byte block count.	188	* the smaller WRITE_SAME(10) only has a two-byte block count.
189	*/	189	*/
190	dev->dev_attrib.max_write_same_len = 0xFFFF;	190	dev->dev_attrib.max_write_same_len = 0xFFFF;
191		191
192	if (blk_queue_nonrot(q))	192	if (blk_queue_nonrot(q))
193	dev->dev_attrib.is_nonrot = 1;	193	dev->dev_attrib.is_nonrot = 1;
194	} else {	194	} else {
195	if (!(fd_dev->fbd_flags & FBDF_HAS_SIZE)) {	195	if (!(fd_dev->fbd_flags & FBDF_HAS_SIZE)) {
196	pr_err("FILEIO: Missing fd_dev_size="	196	pr_err("FILEIO: Missing fd_dev_size="
197	" parameter, and no backing struct"	197	" parameter, and no backing struct"
198	" block_device\n");	198	" block_device\n");
199	goto fail;	199	goto fail;
200	}	200	}
201		201
202	fd_dev->fd_block_size = FD_BLOCKSIZE;	202	fd_dev->fd_block_size = FD_BLOCKSIZE;
203	/*	203	/*
204	* Limit UNMAP emulation to 8k Number of LBAs (NoLB)	204	* Limit UNMAP emulation to 8k Number of LBAs (NoLB)
205	*/	205	*/
206	dev->dev_attrib.max_unmap_lba_count = 0x2000;	206	dev->dev_attrib.max_unmap_lba_count = 0x2000;
207	/*	207	/*
208	* Currently hardcoded to 1 in Linux/SCSI code..	208	* Currently hardcoded to 1 in Linux/SCSI code..
209	*/	209	*/
210	dev->dev_attrib.max_unmap_block_desc_count = 1;	210	dev->dev_attrib.max_unmap_block_desc_count = 1;
211	dev->dev_attrib.unmap_granularity = 1;	211	dev->dev_attrib.unmap_granularity = 1;
212	dev->dev_attrib.unmap_granularity_alignment = 0;	212	dev->dev_attrib.unmap_granularity_alignment = 0;
213		213
214	/*	214	/*
215	* Limit WRITE_SAME w/ UNMAP=0 emulation to 8k Number of LBAs (NoLB)	215	* Limit WRITE_SAME w/ UNMAP=0 emulation to 8k Number of LBAs (NoLB)
216	* based upon struct iovec limit for vfs_writev()	216	* based upon struct iovec limit for vfs_writev()
217	*/	217	*/
218	dev->dev_attrib.max_write_same_len = 0x1000;	218	dev->dev_attrib.max_write_same_len = 0x1000;
219	}	219	}
220		220
221	dev->dev_attrib.hw_block_size = fd_dev->fd_block_size;	221	dev->dev_attrib.hw_block_size = fd_dev->fd_block_size;
222	dev->dev_attrib.max_bytes_per_io = FD_MAX_BYTES;	222	dev->dev_attrib.max_bytes_per_io = FD_MAX_BYTES;
223	dev->dev_attrib.hw_max_sectors = FD_MAX_BYTES / fd_dev->fd_block_size;	223	dev->dev_attrib.hw_max_sectors = FD_MAX_BYTES / fd_dev->fd_block_size;
224	dev->dev_attrib.hw_queue_depth = FD_MAX_DEVICE_QUEUE_DEPTH;	224	dev->dev_attrib.hw_queue_depth = FD_MAX_DEVICE_QUEUE_DEPTH;
225		225
226	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {	226	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {
227	pr_debug("FILEIO: Forcing setting of emulate_write_cache=1"	227	pr_debug("FILEIO: Forcing setting of emulate_write_cache=1"
228	" with FDBD_HAS_BUFFERED_IO_WCE\n");	228	" with FDBD_HAS_BUFFERED_IO_WCE\n");
229	dev->dev_attrib.emulate_write_cache = 1;	229	dev->dev_attrib.emulate_write_cache = 1;
230	}	230	}
231		231
232	fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++;	232	fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++;
233	fd_dev->fd_queue_depth = dev->queue_depth;	233	fd_dev->fd_queue_depth = dev->queue_depth;
234		234
235	pr_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s,"	235	pr_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s,"
236	" %llu total bytes\n", fd_host->fd_host_id, fd_dev->fd_dev_id,	236	" %llu total bytes\n", fd_host->fd_host_id, fd_dev->fd_dev_id,
237	fd_dev->fd_dev_name, fd_dev->fd_dev_size);	237	fd_dev->fd_dev_name, fd_dev->fd_dev_size);
238		238
239	return 0;	239	return 0;
240	fail:	240	fail:
241	if (fd_dev->fd_file) {	241	if (fd_dev->fd_file) {
242	filp_close(fd_dev->fd_file, NULL);	242	filp_close(fd_dev->fd_file, NULL);
243	fd_dev->fd_file = NULL;	243	fd_dev->fd_file = NULL;
244	}	244	}
245	return ret;	245	return ret;
246	}	246	}
247		247
248	static void fd_free_device(struct se_device *dev)	248	static void fd_free_device(struct se_device *dev)
249	{	249	{
250	struct fd_dev *fd_dev = FD_DEV(dev);	250	struct fd_dev *fd_dev = FD_DEV(dev);
251		251
252	if (fd_dev->fd_file) {	252	if (fd_dev->fd_file) {
253	filp_close(fd_dev->fd_file, NULL);	253	filp_close(fd_dev->fd_file, NULL);
254	fd_dev->fd_file = NULL;	254	fd_dev->fd_file = NULL;
255	}	255	}
256		256
257	kfree(fd_dev);	257	kfree(fd_dev);
258	}	258	}
259		259
260	static int fd_do_prot_rw(struct se_cmd cmd, struct fd_prot fd_prot,	260	static int fd_do_prot_rw(struct se_cmd cmd, struct fd_prot fd_prot,
261	int is_write)	261	int is_write)
262	{	262	{
263	struct se_device *se_dev = cmd->se_dev;	263	struct se_device *se_dev = cmd->se_dev;
264	struct fd_dev *dev = FD_DEV(se_dev);	264	struct fd_dev *dev = FD_DEV(se_dev);
265	struct file *prot_fd = dev->fd_prot_file;	265	struct file *prot_fd = dev->fd_prot_file;
266	struct scatterlist *sg;	266	struct scatterlist *sg;
267	loff_t pos = (cmd->t_task_lba * se_dev->prot_length);	267	loff_t pos = (cmd->t_task_lba * se_dev->prot_length);
268	unsigned char *buf;	268	unsigned char *buf;
269	u32 prot_size, len, size;	269	u32 prot_size, len, size;
270	int rc, ret = 1, i;	270	int rc, ret = 1, i;
271		271
272	prot_size = (cmd->data_length / se_dev->dev_attrib.block_size) *	272	prot_size = (cmd->data_length / se_dev->dev_attrib.block_size) *
273	se_dev->prot_length;	273	se_dev->prot_length;
274		274
275	if (!is_write) {	275	if (!is_write) {
276	fd_prot->prot_buf = vzalloc(prot_size);	276	fd_prot->prot_buf = vzalloc(prot_size);
277	if (!fd_prot->prot_buf) {	277	if (!fd_prot->prot_buf) {
278	pr_err("Unable to allocate fd_prot->prot_buf\n");	278	pr_err("Unable to allocate fd_prot->prot_buf\n");
279	return -ENOMEM;	279	return -ENOMEM;
280	}	280	}
281	buf = fd_prot->prot_buf;	281	buf = fd_prot->prot_buf;
282		282
283	fd_prot->prot_sg_nents = cmd->t_prot_nents;	283	fd_prot->prot_sg_nents = cmd->t_prot_nents;
284	fd_prot->prot_sg = kzalloc(sizeof(struct scatterlist) *	284	fd_prot->prot_sg = kzalloc(sizeof(struct scatterlist) *
285	fd_prot->prot_sg_nents, GFP_KERNEL);	285	fd_prot->prot_sg_nents, GFP_KERNEL);
286	if (!fd_prot->prot_sg) {	286	if (!fd_prot->prot_sg) {
287	pr_err("Unable to allocate fd_prot->prot_sg\n");	287	pr_err("Unable to allocate fd_prot->prot_sg\n");
288	vfree(fd_prot->prot_buf);	288	vfree(fd_prot->prot_buf);
289	return -ENOMEM;	289	return -ENOMEM;
290	}	290	}
291	size = prot_size;	291	size = prot_size;
292		292
293	for_each_sg(fd_prot->prot_sg, sg, fd_prot->prot_sg_nents, i) {	293	for_each_sg(fd_prot->prot_sg, sg, fd_prot->prot_sg_nents, i) {
294		294
295	len = min_t(u32, PAGE_SIZE, size);	295	len = min_t(u32, PAGE_SIZE, size);
296	sg_set_buf(sg, buf, len);	296	sg_set_buf(sg, buf, len);
297	size -= len;	297	size -= len;
298	buf += len;	298	buf += len;
299	}	299	}
300	}	300	}
301		301
302	if (is_write) {	302	if (is_write) {
303	rc = kernel_write(prot_fd, fd_prot->prot_buf, prot_size, pos);	303	rc = kernel_write(prot_fd, fd_prot->prot_buf, prot_size, pos);
304	if (rc < 0 \|\| prot_size != rc) {	304	if (rc < 0 \|\| prot_size != rc) {
305	pr_err("kernel_write() for fd_do_prot_rw failed:"	305	pr_err("kernel_write() for fd_do_prot_rw failed:"
306	" %d\n", rc);	306	" %d\n", rc);
307	ret = -EINVAL;	307	ret = -EINVAL;
308	}	308	}
309	} else {	309	} else {
310	rc = kernel_read(prot_fd, pos, fd_prot->prot_buf, prot_size);	310	rc = kernel_read(prot_fd, pos, fd_prot->prot_buf, prot_size);
311	if (rc < 0) {	311	if (rc < 0) {
312	pr_err("kernel_read() for fd_do_prot_rw failed:"	312	pr_err("kernel_read() for fd_do_prot_rw failed:"
313	" %d\n", rc);	313	" %d\n", rc);
314	ret = -EINVAL;	314	ret = -EINVAL;
315	}	315	}
316	}	316	}
317		317
318	if (is_write \|\| ret < 0) {	318	if (is_write \|\| ret < 0) {
319	kfree(fd_prot->prot_sg);	319	kfree(fd_prot->prot_sg);
320	vfree(fd_prot->prot_buf);	320	vfree(fd_prot->prot_buf);
321	}	321	}
322		322
323	return ret;	323	return ret;
324	}	324	}
325		325
326	static int fd_do_rw(struct se_cmd cmd, struct scatterlist sgl,	326	static int fd_do_rw(struct se_cmd cmd, struct scatterlist sgl,
327	u32 sgl_nents, int is_write)	327	u32 sgl_nents, int is_write)
328	{	328	{
329	struct se_device *se_dev = cmd->se_dev;	329	struct se_device *se_dev = cmd->se_dev;
330	struct fd_dev *dev = FD_DEV(se_dev);	330	struct fd_dev *dev = FD_DEV(se_dev);
331	struct file *fd = dev->fd_file;	331	struct file *fd = dev->fd_file;
332	struct scatterlist *sg;	332	struct scatterlist *sg;
333	struct iovec *iov;	333	struct iovec *iov;
334	mm_segment_t old_fs;	334	mm_segment_t old_fs;
335	loff_t pos = (cmd->t_task_lba * se_dev->dev_attrib.block_size);	335	loff_t pos = (cmd->t_task_lba * se_dev->dev_attrib.block_size);
336	int ret = 0, i;	336	int ret = 0, i;
337		337
338	iov = kzalloc(sizeof(struct iovec) * sgl_nents, GFP_KERNEL);	338	iov = kzalloc(sizeof(struct iovec) * sgl_nents, GFP_KERNEL);
339	if (!iov) {	339	if (!iov) {
340	pr_err("Unable to allocate fd_do_readv iov[]\n");	340	pr_err("Unable to allocate fd_do_readv iov[]\n");
341	return -ENOMEM;	341	return -ENOMEM;
342	}	342	}
343		343
344	for_each_sg(sgl, sg, sgl_nents, i) {	344	for_each_sg(sgl, sg, sgl_nents, i) {
345	iov[i].iov_len = sg->length;	345	iov[i].iov_len = sg->length;
346	iov[i].iov_base = kmap(sg_page(sg)) + sg->offset;	346	iov[i].iov_base = kmap(sg_page(sg)) + sg->offset;
347	}	347	}
348		348
349	old_fs = get_fs();	349	old_fs = get_fs();
350	set_fs(get_ds());	350	set_fs(get_ds());
351		351
352	if (is_write)	352	if (is_write)
353	ret = vfs_writev(fd, &iov[0], sgl_nents, &pos);	353	ret = vfs_writev(fd, &iov[0], sgl_nents, &pos);
354	else	354	else
355	ret = vfs_readv(fd, &iov[0], sgl_nents, &pos);	355	ret = vfs_readv(fd, &iov[0], sgl_nents, &pos);
356		356
357	set_fs(old_fs);	357	set_fs(old_fs);
358		358
359	for_each_sg(sgl, sg, sgl_nents, i)	359	for_each_sg(sgl, sg, sgl_nents, i)
360	kunmap(sg_page(sg));	360	kunmap(sg_page(sg));
361		361
362	kfree(iov);	362	kfree(iov);
363		363
364	if (is_write) {	364	if (is_write) {
365	if (ret < 0 \|\| ret != cmd->data_length) {	365	if (ret < 0 \|\| ret != cmd->data_length) {
366	pr_err("%s() write returned %d\n", __func__, ret);	366	pr_err("%s() write returned %d\n", __func__, ret);
367	return (ret < 0 ? ret : -EINVAL);	367	return (ret < 0 ? ret : -EINVAL);
368	}	368	}
369	} else {	369	} else {
370	/*	370	/*
371	* Return zeros and GOOD status even if the READ did not return	371	* Return zeros and GOOD status even if the READ did not return
372	* the expected virt_size for struct file w/o a backing struct	372	* the expected virt_size for struct file w/o a backing struct
373	* block_device.	373	* block_device.
374	*/	374	*/
375	if (S_ISBLK(file_inode(fd)->i_mode)) {	375	if (S_ISBLK(file_inode(fd)->i_mode)) {
376	if (ret < 0 \|\| ret != cmd->data_length) {	376	if (ret < 0 \|\| ret != cmd->data_length) {
377	pr_err("%s() returned %d, expecting %u for "	377	pr_err("%s() returned %d, expecting %u for "
378	"S_ISBLK\n", __func__, ret,	378	"S_ISBLK\n", __func__, ret,
379	cmd->data_length);	379	cmd->data_length);
380	return (ret < 0 ? ret : -EINVAL);	380	return (ret < 0 ? ret : -EINVAL);
381	}	381	}
382	} else {	382	} else {
383	if (ret < 0) {	383	if (ret < 0) {
384	pr_err("%s() returned %d for non S_ISBLK\n",	384	pr_err("%s() returned %d for non S_ISBLK\n",
385	__func__, ret);	385	__func__, ret);
386	return ret;	386	return ret;
387	}	387	}
388	}	388	}
389	}	389	}
390	return 1;	390	return 1;
391	}	391	}
392		392
393	static sense_reason_t	393	static sense_reason_t
394	fd_execute_sync_cache(struct se_cmd *cmd)	394	fd_execute_sync_cache(struct se_cmd *cmd)
395	{	395	{
396	struct se_device *dev = cmd->se_dev;	396	struct se_device *dev = cmd->se_dev;
397	struct fd_dev *fd_dev = FD_DEV(dev);	397	struct fd_dev *fd_dev = FD_DEV(dev);
398	int immed = (cmd->t_task_cdb[1] & 0x2);	398	int immed = (cmd->t_task_cdb[1] & 0x2);
399	loff_t start, end;	399	loff_t start, end;
400	int ret;	400	int ret;
401		401
402	/*	402	/*
403	* If the Immediate bit is set, queue up the GOOD response	403	* If the Immediate bit is set, queue up the GOOD response
404	* for this SYNCHRONIZE_CACHE op	404	* for this SYNCHRONIZE_CACHE op
405	*/	405	*/
406	if (immed)	406	if (immed)
407	target_complete_cmd(cmd, SAM_STAT_GOOD);	407	target_complete_cmd(cmd, SAM_STAT_GOOD);
408		408
409	/*	409	/*
410	* Determine if we will be flushing the entire device.	410	* Determine if we will be flushing the entire device.
411	*/	411	*/
412	if (cmd->t_task_lba == 0 && cmd->data_length == 0) {	412	if (cmd->t_task_lba == 0 && cmd->data_length == 0) {
413	start = 0;	413	start = 0;
414	end = LLONG_MAX;	414	end = LLONG_MAX;
415	} else {	415	} else {
416	start = cmd->t_task_lba * dev->dev_attrib.block_size;	416	start = cmd->t_task_lba * dev->dev_attrib.block_size;
417	if (cmd->data_length)	417	if (cmd->data_length)
418	end = start + cmd->data_length - 1;	418	end = start + cmd->data_length - 1;
419	else	419	else
420	end = LLONG_MAX;	420	end = LLONG_MAX;
421	}	421	}
422		422
423	ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);	423	ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);
424	if (ret != 0)	424	if (ret != 0)
425	pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret);	425	pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret);
426		426
427	if (immed)	427	if (immed)
428	return 0;	428	return 0;
429		429
430	if (ret)	430	if (ret)
431	target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);	431	target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
432	else	432	else
433	target_complete_cmd(cmd, SAM_STAT_GOOD);	433	target_complete_cmd(cmd, SAM_STAT_GOOD);
434		434
435	return 0;	435	return 0;
436	}	436	}
437		437
438	static unsigned char *	438	static unsigned char *
439	fd_setup_write_same_buf(struct se_cmd cmd, struct scatterlist sg,	439	fd_setup_write_same_buf(struct se_cmd cmd, struct scatterlist sg,
440	unsigned int len)	440	unsigned int len)
441	{	441	{
442	struct se_device *se_dev = cmd->se_dev;	442	struct se_device *se_dev = cmd->se_dev;
443	unsigned int block_size = se_dev->dev_attrib.block_size;	443	unsigned int block_size = se_dev->dev_attrib.block_size;
444	unsigned int i = 0, end;	444	unsigned int i = 0, end;
445	unsigned char buf, p, *kmap_buf;	445	unsigned char buf, p, *kmap_buf;
446		446
447	buf = kzalloc(min_t(unsigned int, len, PAGE_SIZE), GFP_KERNEL);	447	buf = kzalloc(min_t(unsigned int, len, PAGE_SIZE), GFP_KERNEL);
448	if (!buf) {	448	if (!buf) {
449	pr_err("Unable to allocate fd_execute_write_same buf\n");	449	pr_err("Unable to allocate fd_execute_write_same buf\n");
450	return NULL;	450	return NULL;
451	}	451	}
452		452
453	kmap_buf = kmap(sg_page(sg)) + sg->offset;	453	kmap_buf = kmap(sg_page(sg)) + sg->offset;
454	if (!kmap_buf) {	454	if (!kmap_buf) {
455	pr_err("kmap() failed in fd_setup_write_same\n");	455	pr_err("kmap() failed in fd_setup_write_same\n");
456	kfree(buf);	456	kfree(buf);
457	return NULL;	457	return NULL;
458	}	458	}
459	/*	459	/*
460	* Fill local *buf to contain multiple WRITE_SAME blocks up to	460	* Fill local *buf to contain multiple WRITE_SAME blocks up to
461	* min(len, PAGE_SIZE)	461	* min(len, PAGE_SIZE)
462	*/	462	*/
463	p = buf;	463	p = buf;
464	end = min_t(unsigned int, len, PAGE_SIZE);	464	end = min_t(unsigned int, len, PAGE_SIZE);
465		465
466	while (i < end) {	466	while (i < end) {
467	memcpy(p, kmap_buf, block_size);	467	memcpy(p, kmap_buf, block_size);
468		468
469	i += block_size;	469	i += block_size;
470	p += block_size;	470	p += block_size;
471	}	471	}
472	kunmap(sg_page(sg));	472	kunmap(sg_page(sg));
473		473
474	return buf;	474	return buf;
475	}	475	}
476		476
477	static sense_reason_t	477	static sense_reason_t
478	fd_execute_write_same(struct se_cmd *cmd)	478	fd_execute_write_same(struct se_cmd *cmd)
479	{	479	{
480	struct se_device *se_dev = cmd->se_dev;	480	struct se_device *se_dev = cmd->se_dev;
481	struct fd_dev *fd_dev = FD_DEV(se_dev);	481	struct fd_dev *fd_dev = FD_DEV(se_dev);
482	struct file *f = fd_dev->fd_file;	482	struct file *f = fd_dev->fd_file;
483	struct scatterlist *sg;	483	struct scatterlist *sg;
484	struct iovec *iov;	484	struct iovec *iov;
485	mm_segment_t old_fs;	485	mm_segment_t old_fs;
486	sector_t nolb = sbc_get_write_same_sectors(cmd);	486	sector_t nolb = sbc_get_write_same_sectors(cmd);
487	loff_t pos = cmd->t_task_lba * se_dev->dev_attrib.block_size;	487	loff_t pos = cmd->t_task_lba * se_dev->dev_attrib.block_size;
488	unsigned int len, len_tmp, iov_num;	488	unsigned int len, len_tmp, iov_num;
489	int i, rc;	489	int i, rc;
490	unsigned char *buf;	490	unsigned char *buf;
491		491
492	if (!nolb) {	492	if (!nolb) {
493	target_complete_cmd(cmd, SAM_STAT_GOOD);	493	target_complete_cmd(cmd, SAM_STAT_GOOD);
494	return 0;	494	return 0;
495	}	495	}
496	sg = &cmd->t_data_sg[0];	496	sg = &cmd->t_data_sg[0];
497		497
498	if (cmd->t_data_nents > 1 \|\|	498	if (cmd->t_data_nents > 1 \|\|
499	sg->length != cmd->se_dev->dev_attrib.block_size) {	499	sg->length != cmd->se_dev->dev_attrib.block_size) {
500	pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"	500	pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"
501	" block_size: %u\n", cmd->t_data_nents, sg->length,	501	" block_size: %u\n", cmd->t_data_nents, sg->length,
502	cmd->se_dev->dev_attrib.block_size);	502	cmd->se_dev->dev_attrib.block_size);
503	return TCM_INVALID_CDB_FIELD;	503	return TCM_INVALID_CDB_FIELD;
504	}	504	}
505		505
506	len = len_tmp = nolb * se_dev->dev_attrib.block_size;	506	len = len_tmp = nolb * se_dev->dev_attrib.block_size;
507	iov_num = DIV_ROUND_UP(len, PAGE_SIZE);	507	iov_num = DIV_ROUND_UP(len, PAGE_SIZE);
508		508
509	buf = fd_setup_write_same_buf(cmd, sg, len);	509	buf = fd_setup_write_same_buf(cmd, sg, len);
510	if (!buf)	510	if (!buf)
511	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	511	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
512		512
513	iov = vzalloc(sizeof(struct iovec) * iov_num);	513	iov = vzalloc(sizeof(struct iovec) * iov_num);
514	if (!iov) {	514	if (!iov) {
515	pr_err("Unable to allocate fd_execute_write_same iovecs\n");	515	pr_err("Unable to allocate fd_execute_write_same iovecs\n");
516	kfree(buf);	516	kfree(buf);
517	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	517	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
518	}	518	}
519	/*	519	/*
520	* Map the single fabric received scatterlist block now populated	520	* Map the single fabric received scatterlist block now populated
521	* in *buf into each iovec for I/O submission.	521	* in *buf into each iovec for I/O submission.
522	*/	522	*/
523	for (i = 0; i < iov_num; i++) {	523	for (i = 0; i < iov_num; i++) {
524	iov[i].iov_base = buf;	524	iov[i].iov_base = buf;
525	iov[i].iov_len = min_t(unsigned int, len_tmp, PAGE_SIZE);	525	iov[i].iov_len = min_t(unsigned int, len_tmp, PAGE_SIZE);
526	len_tmp -= iov[i].iov_len;	526	len_tmp -= iov[i].iov_len;
527	}	527	}
528		528
529	old_fs = get_fs();	529	old_fs = get_fs();
530	set_fs(get_ds());	530	set_fs(get_ds());
531	rc = vfs_writev(f, &iov[0], iov_num, &pos);	531	rc = vfs_writev(f, &iov[0], iov_num, &pos);
532	set_fs(old_fs);	532	set_fs(old_fs);
533		533
534	vfree(iov);	534	vfree(iov);
535	kfree(buf);	535	kfree(buf);
536		536
537	if (rc < 0 \|\| rc != len) {	537	if (rc < 0 \|\| rc != len) {
538	pr_err("vfs_writev() returned %d for write same\n", rc);	538	pr_err("vfs_writev() returned %d for write same\n", rc);
539	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	539	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
540	}	540	}
541		541
542	target_complete_cmd(cmd, SAM_STAT_GOOD);	542	target_complete_cmd(cmd, SAM_STAT_GOOD);
543	return 0;	543	return 0;
544	}	544	}
545		545
546	static sense_reason_t	546	static sense_reason_t
547	fd_do_unmap(struct se_cmd cmd, void priv, sector_t lba, sector_t nolb)	547	fd_do_unmap(struct se_cmd cmd, void priv, sector_t lba, sector_t nolb)
548	{	548	{
549	struct file *file = priv;	549	struct file *file = priv;
550	struct inode *inode = file->f_mapping->host;	550	struct inode *inode = file->f_mapping->host;
551	int ret;	551	int ret;
552		552
553	if (S_ISBLK(inode->i_mode)) {	553	if (S_ISBLK(inode->i_mode)) {
554	/* The backend is block device, use discard */	554	/* The backend is block device, use discard */
555	struct block_device *bdev = inode->i_bdev;	555	struct block_device *bdev = inode->i_bdev;
556		556
557	ret = blkdev_issue_discard(bdev, lba,	557	ret = blkdev_issue_discard(bdev, lba,
558	nolb, GFP_KERNEL, 0);	558	nolb, GFP_KERNEL, 0);
559	if (ret < 0) {	559	if (ret < 0) {
560	pr_warn("FILEIO: blkdev_issue_discard() failed: %d\n",	560	pr_warn("FILEIO: blkdev_issue_discard() failed: %d\n",
561	ret);	561	ret);
562	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	562	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
563	}	563	}
564	} else {	564	} else {
565	/* The backend is normal file, use fallocate */	565	/* The backend is normal file, use fallocate */
566	struct se_device *se_dev = cmd->se_dev;	566	struct se_device *se_dev = cmd->se_dev;
567	loff_t pos = lba * se_dev->dev_attrib.block_size;	567	loff_t pos = lba * se_dev->dev_attrib.block_size;
568	unsigned int len = nolb * se_dev->dev_attrib.block_size;	568	unsigned int len = nolb * se_dev->dev_attrib.block_size;
569	int mode = FALLOC_FL_PUNCH_HOLE \| FALLOC_FL_KEEP_SIZE;	569	int mode = FALLOC_FL_PUNCH_HOLE \| FALLOC_FL_KEEP_SIZE;
570		570
571	if (!file->f_op->fallocate)	571	if (!file->f_op->fallocate)
572	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	572	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
573		573
574	ret = file->f_op->fallocate(file, mode, pos, len);	574	ret = file->f_op->fallocate(file, mode, pos, len);
575	if (ret < 0) {	575	if (ret < 0) {
576	pr_warn("FILEIO: fallocate() failed: %d\n", ret);	576	pr_warn("FILEIO: fallocate() failed: %d\n", ret);
577	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	577	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
578	}	578	}
579	}	579	}
580		580
581	return 0;	581	return 0;
582	}	582	}
583		583
584	static sense_reason_t	584	static sense_reason_t
585	fd_execute_write_same_unmap(struct se_cmd *cmd)	585	fd_execute_write_same_unmap(struct se_cmd *cmd)
586	{	586	{
587	struct se_device *se_dev = cmd->se_dev;	587	struct se_device *se_dev = cmd->se_dev;
588	struct fd_dev *fd_dev = FD_DEV(se_dev);	588	struct fd_dev *fd_dev = FD_DEV(se_dev);
589	struct file *file = fd_dev->fd_file;	589	struct file *file = fd_dev->fd_file;
590	sector_t lba = cmd->t_task_lba;	590	sector_t lba = cmd->t_task_lba;
591	sector_t nolb = sbc_get_write_same_sectors(cmd);	591	sector_t nolb = sbc_get_write_same_sectors(cmd);
592	int ret;	592	int ret;
593		593
594	if (!nolb) {	594	if (!nolb) {
595	target_complete_cmd(cmd, SAM_STAT_GOOD);	595	target_complete_cmd(cmd, SAM_STAT_GOOD);
596	return 0;	596	return 0;
597	}	597	}
598		598
599	ret = fd_do_unmap(cmd, file, lba, nolb);	599	ret = fd_do_unmap(cmd, file, lba, nolb);
600	if (ret)	600	if (ret)
601	return ret;	601	return ret;
602		602
603	target_complete_cmd(cmd, GOOD);	603	target_complete_cmd(cmd, GOOD);
604	return 0;	604	return 0;
605	}	605	}
606		606
607	static sense_reason_t	607	static sense_reason_t
608	fd_execute_unmap(struct se_cmd *cmd)	608	fd_execute_unmap(struct se_cmd *cmd)
609	{	609	{
610	struct file *file = FD_DEV(cmd->se_dev)->fd_file;	610	struct file *file = FD_DEV(cmd->se_dev)->fd_file;
611		611
612	return sbc_execute_unmap(cmd, fd_do_unmap, file);	612	return sbc_execute_unmap(cmd, fd_do_unmap, file);
613	}	613	}
614		614
615	static sense_reason_t	615	static sense_reason_t
616	fd_execute_rw(struct se_cmd cmd, struct scatterlist sgl, u32 sgl_nents,	616	fd_execute_rw(struct se_cmd cmd, struct scatterlist sgl, u32 sgl_nents,
617	enum dma_data_direction data_direction)	617	enum dma_data_direction data_direction)
618	{	618	{
619	struct se_device *dev = cmd->se_dev;	619	struct se_device *dev = cmd->se_dev;
620	struct fd_prot fd_prot;	620	struct fd_prot fd_prot;
621	sense_reason_t rc;	621	sense_reason_t rc;
622	int ret = 0;	622	int ret = 0;
623		623	/*
		624	* We are currently limited by the number of iovecs (2048) per
		625	* single vfs_[writev,readv] call.
		626	*/
		627	if (cmd->data_length > FD_MAX_BYTES) {
		628	pr_err("FILEIO: Not able to process I/O of %u bytes due to"
		629	"FD_MAX_BYTES: %u iovec count limitiation\n",
		630	cmd->data_length, FD_MAX_BYTES);
		631	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
		632	}
624	/*	633	/*
625	* Call vectorized fileio functions to map struct scatterlist	634	* Call vectorized fileio functions to map struct scatterlist
626	* physical memory addresses to struct iovec virtual memory.	635	* physical memory addresses to struct iovec virtual memory.
627	*/	636	*/
628	if (data_direction == DMA_FROM_DEVICE) {	637	if (data_direction == DMA_FROM_DEVICE) {
629	memset(&fd_prot, 0, sizeof(struct fd_prot));	638	memset(&fd_prot, 0, sizeof(struct fd_prot));
630		639
631	if (cmd->prot_type) {	640	if (cmd->prot_type) {
632	ret = fd_do_prot_rw(cmd, &fd_prot, false);	641	ret = fd_do_prot_rw(cmd, &fd_prot, false);
633	if (ret < 0)	642	if (ret < 0)
634	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	643	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
635	}	644	}
636		645
637	ret = fd_do_rw(cmd, sgl, sgl_nents, 0);	646	ret = fd_do_rw(cmd, sgl, sgl_nents, 0);
638		647
639	if (ret > 0 && cmd->prot_type) {	648	if (ret > 0 && cmd->prot_type) {
640	u32 sectors = cmd->data_length / dev->dev_attrib.block_size;	649	u32 sectors = cmd->data_length / dev->dev_attrib.block_size;
641		650
642	rc = sbc_dif_verify_read(cmd, cmd->t_task_lba, sectors,	651	rc = sbc_dif_verify_read(cmd, cmd->t_task_lba, sectors,
643	0, fd_prot.prot_sg, 0);	652	0, fd_prot.prot_sg, 0);
644	if (rc) {	653	if (rc) {
645	kfree(fd_prot.prot_sg);	654	kfree(fd_prot.prot_sg);
646	vfree(fd_prot.prot_buf);	655	vfree(fd_prot.prot_buf);
647	return rc;	656	return rc;
648	}	657	}
649	kfree(fd_prot.prot_sg);	658	kfree(fd_prot.prot_sg);
650	vfree(fd_prot.prot_buf);	659	vfree(fd_prot.prot_buf);
651	}	660	}
652	} else {	661	} else {
653	memset(&fd_prot, 0, sizeof(struct fd_prot));	662	memset(&fd_prot, 0, sizeof(struct fd_prot));
654		663
655	if (cmd->prot_type) {	664	if (cmd->prot_type) {
656	u32 sectors = cmd->data_length / dev->dev_attrib.block_size;	665	u32 sectors = cmd->data_length / dev->dev_attrib.block_size;
657		666
658	ret = fd_do_prot_rw(cmd, &fd_prot, false);	667	ret = fd_do_prot_rw(cmd, &fd_prot, false);
659	if (ret < 0)	668	if (ret < 0)
660	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	669	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
661		670
662	rc = sbc_dif_verify_write(cmd, cmd->t_task_lba, sectors,	671	rc = sbc_dif_verify_write(cmd, cmd->t_task_lba, sectors,
663	0, fd_prot.prot_sg, 0);	672	0, fd_prot.prot_sg, 0);
664	if (rc) {	673	if (rc) {
665	kfree(fd_prot.prot_sg);	674	kfree(fd_prot.prot_sg);
666	vfree(fd_prot.prot_buf);	675	vfree(fd_prot.prot_buf);
667	return rc;	676	return rc;
668	}	677	}
669	}	678	}
670		679
671	ret = fd_do_rw(cmd, sgl, sgl_nents, 1);	680	ret = fd_do_rw(cmd, sgl, sgl_nents, 1);
672	/*	681	/*
673	* Perform implicit vfs_fsync_range() for fd_do_writev() ops	682	* Perform implicit vfs_fsync_range() for fd_do_writev() ops
674	* for SCSI WRITEs with Forced Unit Access (FUA) set.	683	* for SCSI WRITEs with Forced Unit Access (FUA) set.
675	* Allow this to happen independent of WCE=0 setting.	684	* Allow this to happen independent of WCE=0 setting.
676	*/	685	*/
677	if (ret > 0 &&	686	if (ret > 0 &&
678	dev->dev_attrib.emulate_fua_write > 0 &&	687	dev->dev_attrib.emulate_fua_write > 0 &&
679	(cmd->se_cmd_flags & SCF_FUA)) {	688	(cmd->se_cmd_flags & SCF_FUA)) {
680	struct fd_dev *fd_dev = FD_DEV(dev);	689	struct fd_dev *fd_dev = FD_DEV(dev);
681	loff_t start = cmd->t_task_lba *	690	loff_t start = cmd->t_task_lba *
682	dev->dev_attrib.block_size;	691	dev->dev_attrib.block_size;
683	loff_t end;	692	loff_t end;
684		693
685	if (cmd->data_length)	694	if (cmd->data_length)
686	end = start + cmd->data_length - 1;	695	end = start + cmd->data_length - 1;
687	else	696	else
688	end = LLONG_MAX;	697	end = LLONG_MAX;
689		698
690	vfs_fsync_range(fd_dev->fd_file, start, end, 1);	699	vfs_fsync_range(fd_dev->fd_file, start, end, 1);
691	}	700	}
692		701
693	if (ret > 0 && cmd->prot_type) {	702	if (ret > 0 && cmd->prot_type) {
694	ret = fd_do_prot_rw(cmd, &fd_prot, true);	703	ret = fd_do_prot_rw(cmd, &fd_prot, true);
695	if (ret < 0)	704	if (ret < 0)
696	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	705	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
697	}	706	}
698	}	707	}
699		708
700	if (ret < 0) {	709	if (ret < 0) {
701	kfree(fd_prot.prot_sg);	710	kfree(fd_prot.prot_sg);
702	vfree(fd_prot.prot_buf);	711	vfree(fd_prot.prot_buf);
703	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	712	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
704	}	713	}
705		714
706	if (ret)	715	if (ret)
707	target_complete_cmd(cmd, SAM_STAT_GOOD);	716	target_complete_cmd(cmd, SAM_STAT_GOOD);
708	return 0;	717	return 0;
709	}	718	}
710		719
711	enum {	720	enum {
712	Opt_fd_dev_name, Opt_fd_dev_size, Opt_fd_buffered_io, Opt_err	721	Opt_fd_dev_name, Opt_fd_dev_size, Opt_fd_buffered_io, Opt_err
713	};	722	};
714		723
715	static match_table_t tokens = {	724	static match_table_t tokens = {
716	{Opt_fd_dev_name, "fd_dev_name=%s"},	725	{Opt_fd_dev_name, "fd_dev_name=%s"},
717	{Opt_fd_dev_size, "fd_dev_size=%s"},	726	{Opt_fd_dev_size, "fd_dev_size=%s"},
718	{Opt_fd_buffered_io, "fd_buffered_io=%d"},	727	{Opt_fd_buffered_io, "fd_buffered_io=%d"},
719	{Opt_err, NULL}	728	{Opt_err, NULL}
720	};	729	};
721		730
722	static ssize_t fd_set_configfs_dev_params(struct se_device *dev,	731	static ssize_t fd_set_configfs_dev_params(struct se_device *dev,
723	const char *page, ssize_t count)	732	const char *page, ssize_t count)
724	{	733	{
725	struct fd_dev *fd_dev = FD_DEV(dev);	734	struct fd_dev *fd_dev = FD_DEV(dev);
726	char orig, ptr, arg_p, opts;	735	char orig, ptr, arg_p, opts;
727	substring_t args[MAX_OPT_ARGS];	736	substring_t args[MAX_OPT_ARGS];
728	int ret = 0, arg, token;	737	int ret = 0, arg, token;
729		738
730	opts = kstrdup(page, GFP_KERNEL);	739	opts = kstrdup(page, GFP_KERNEL);
731	if (!opts)	740	if (!opts)
732	return -ENOMEM;	741	return -ENOMEM;
733		742
734	orig = opts;	743	orig = opts;
735		744
736	while ((ptr = strsep(&opts, ",\n")) != NULL) {	745	while ((ptr = strsep(&opts, ",\n")) != NULL) {
737	if (!*ptr)	746	if (!*ptr)
738	continue;	747	continue;
739		748
740	token = match_token(ptr, tokens, args);	749	token = match_token(ptr, tokens, args);
741	switch (token) {	750	switch (token) {
742	case Opt_fd_dev_name:	751	case Opt_fd_dev_name:
743	if (match_strlcpy(fd_dev->fd_dev_name, &args[0],	752	if (match_strlcpy(fd_dev->fd_dev_name, &args[0],
744	FD_MAX_DEV_NAME) == 0) {	753	FD_MAX_DEV_NAME) == 0) {
745	ret = -EINVAL;	754	ret = -EINVAL;
746	break;	755	break;
747	}	756	}
748	pr_debug("FILEIO: Referencing Path: %s\n",	757	pr_debug("FILEIO: Referencing Path: %s\n",
749	fd_dev->fd_dev_name);	758	fd_dev->fd_dev_name);
750	fd_dev->fbd_flags \|= FBDF_HAS_PATH;	759	fd_dev->fbd_flags \|= FBDF_HAS_PATH;
751	break;	760	break;
752	case Opt_fd_dev_size:	761	case Opt_fd_dev_size:
753	arg_p = match_strdup(&args[0]);	762	arg_p = match_strdup(&args[0]);
754	if (!arg_p) {	763	if (!arg_p) {
755	ret = -ENOMEM;	764	ret = -ENOMEM;
756	break;	765	break;
757	}	766	}
758	ret = kstrtoull(arg_p, 0, &fd_dev->fd_dev_size);	767	ret = kstrtoull(arg_p, 0, &fd_dev->fd_dev_size);
759	kfree(arg_p);	768	kfree(arg_p);
760	if (ret < 0) {	769	if (ret < 0) {
761	pr_err("kstrtoull() failed for"	770	pr_err("kstrtoull() failed for"
762	" fd_dev_size=\n");	771	" fd_dev_size=\n");
763	goto out;	772	goto out;
764	}	773	}
765	pr_debug("FILEIO: Referencing Size: %llu"	774	pr_debug("FILEIO: Referencing Size: %llu"
766	" bytes\n", fd_dev->fd_dev_size);	775	" bytes\n", fd_dev->fd_dev_size);
767	fd_dev->fbd_flags \|= FBDF_HAS_SIZE;	776	fd_dev->fbd_flags \|= FBDF_HAS_SIZE;
768	break;	777	break;
769	case Opt_fd_buffered_io:	778	case Opt_fd_buffered_io:
770	ret = match_int(args, &arg);	779	ret = match_int(args, &arg);
771	if (ret)	780	if (ret)
772	goto out;	781	goto out;
773	if (arg != 1) {	782	if (arg != 1) {
774	pr_err("bogus fd_buffered_io=%d value\n", arg);	783	pr_err("bogus fd_buffered_io=%d value\n", arg);
775	ret = -EINVAL;	784	ret = -EINVAL;
776	goto out;	785	goto out;
777	}	786	}
778		787
779	pr_debug("FILEIO: Using buffered I/O"	788	pr_debug("FILEIO: Using buffered I/O"
780	" operations for struct fd_dev\n");	789	" operations for struct fd_dev\n");
781		790
782	fd_dev->fbd_flags \|= FDBD_HAS_BUFFERED_IO_WCE;	791	fd_dev->fbd_flags \|= FDBD_HAS_BUFFERED_IO_WCE;
783	break;	792	break;
784	default:	793	default:
785	break;	794	break;
786	}	795	}
787	}	796	}
788		797
789	out:	798	out:
790	kfree(orig);	799	kfree(orig);
791	return (!ret) ? count : ret;	800	return (!ret) ? count : ret;
792	}	801	}
793		802
794	static ssize_t fd_show_configfs_dev_params(struct se_device dev, char b)	803	static ssize_t fd_show_configfs_dev_params(struct se_device dev, char b)
795	{	804	{
796	struct fd_dev *fd_dev = FD_DEV(dev);	805	struct fd_dev *fd_dev = FD_DEV(dev);
797	ssize_t bl = 0;	806	ssize_t bl = 0;
798		807
799	bl = sprintf(b + bl, "TCM FILEIO ID: %u", fd_dev->fd_dev_id);	808	bl = sprintf(b + bl, "TCM FILEIO ID: %u", fd_dev->fd_dev_id);
800	bl += sprintf(b + bl, " File: %s Size: %llu Mode: %s\n",	809	bl += sprintf(b + bl, " File: %s Size: %llu Mode: %s\n",
801	fd_dev->fd_dev_name, fd_dev->fd_dev_size,	810	fd_dev->fd_dev_name, fd_dev->fd_dev_size,
802	(fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) ?	811	(fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) ?
803	"Buffered-WCE" : "O_DSYNC");	812	"Buffered-WCE" : "O_DSYNC");
804	return bl;	813	return bl;
805	}	814	}
806		815
807	static sector_t fd_get_blocks(struct se_device *dev)	816	static sector_t fd_get_blocks(struct se_device *dev)
808	{	817	{
809	struct fd_dev *fd_dev = FD_DEV(dev);	818	struct fd_dev *fd_dev = FD_DEV(dev);
810	struct file *f = fd_dev->fd_file;	819	struct file *f = fd_dev->fd_file;
811	struct inode *i = f->f_mapping->host;	820	struct inode *i = f->f_mapping->host;
812	unsigned long long dev_size;	821	unsigned long long dev_size;
813	/*	822	/*
814	* When using a file that references an underlying struct block_device,	823	* When using a file that references an underlying struct block_device,
815	* ensure dev_size is always based on the current inode size in order	824	* ensure dev_size is always based on the current inode size in order
816	* to handle underlying block_device resize operations.	825	* to handle underlying block_device resize operations.
817	*/	826	*/
818	if (S_ISBLK(i->i_mode))	827	if (S_ISBLK(i->i_mode))
819	dev_size = i_size_read(i);	828	dev_size = i_size_read(i);
820	else	829	else
821	dev_size = fd_dev->fd_dev_size;	830	dev_size = fd_dev->fd_dev_size;
822		831
823	return div_u64(dev_size - dev->dev_attrib.block_size,	832	return div_u64(dev_size - dev->dev_attrib.block_size,
824	dev->dev_attrib.block_size);	833	dev->dev_attrib.block_size);
825	}	834	}
826		835
827	static int fd_init_prot(struct se_device *dev)	836	static int fd_init_prot(struct se_device *dev)
828	{	837	{
829	struct fd_dev *fd_dev = FD_DEV(dev);	838	struct fd_dev *fd_dev = FD_DEV(dev);
830	struct file prot_file, file = fd_dev->fd_file;	839	struct file prot_file, file = fd_dev->fd_file;
831	struct inode *inode;	840	struct inode *inode;
832	int ret, flags = O_RDWR \| O_CREAT \| O_LARGEFILE \| O_DSYNC;	841	int ret, flags = O_RDWR \| O_CREAT \| O_LARGEFILE \| O_DSYNC;
833	char buf[FD_MAX_DEV_PROT_NAME];	842	char buf[FD_MAX_DEV_PROT_NAME];
834		843
835	if (!file) {	844	if (!file) {
836	pr_err("Unable to locate fd_dev->fd_file\n");	845	pr_err("Unable to locate fd_dev->fd_file\n");
837	return -ENODEV;	846	return -ENODEV;
838	}	847	}
839		848
840	inode = file->f_mapping->host;	849	inode = file->f_mapping->host;
841	if (S_ISBLK(inode->i_mode)) {	850	if (S_ISBLK(inode->i_mode)) {
842	pr_err("FILEIO Protection emulation only supported on"	851	pr_err("FILEIO Protection emulation only supported on"
843	" !S_ISBLK\n");	852	" !S_ISBLK\n");
844	return -ENOSYS;	853	return -ENOSYS;
845	}	854	}
846		855
847	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE)	856	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE)
848	flags &= ~O_DSYNC;	857	flags &= ~O_DSYNC;
849		858
850	snprintf(buf, FD_MAX_DEV_PROT_NAME, "%s.protection",	859	snprintf(buf, FD_MAX_DEV_PROT_NAME, "%s.protection",
851	fd_dev->fd_dev_name);	860	fd_dev->fd_dev_name);
852		861
853	prot_file = filp_open(buf, flags, 0600);	862	prot_file = filp_open(buf, flags, 0600);
854	if (IS_ERR(prot_file)) {	863	if (IS_ERR(prot_file)) {
855	pr_err("filp_open(%s) failed\n", buf);	864	pr_err("filp_open(%s) failed\n", buf);
856	ret = PTR_ERR(prot_file);	865	ret = PTR_ERR(prot_file);
857	return ret;	866	return ret;
858	}	867	}
859	fd_dev->fd_prot_file = prot_file;	868	fd_dev->fd_prot_file = prot_file;
860		869
861	return 0;	870	return 0;
862	}	871	}
863		872
864	static int fd_format_prot(struct se_device *dev)	873	static int fd_format_prot(struct se_device *dev)
865	{	874	{
866	struct fd_dev *fd_dev = FD_DEV(dev);	875	struct fd_dev *fd_dev = FD_DEV(dev);
867	struct file *prot_fd = fd_dev->fd_prot_file;	876	struct file *prot_fd = fd_dev->fd_prot_file;
868	sector_t prot_length, prot;	877	sector_t prot_length, prot;
869	unsigned char *buf;	878	unsigned char *buf;
870	loff_t pos = 0;	879	loff_t pos = 0;
871	int unit_size = FDBD_FORMAT_UNIT_SIZE * dev->dev_attrib.block_size;	880	int unit_size = FDBD_FORMAT_UNIT_SIZE * dev->dev_attrib.block_size;
872	int rc, ret = 0, size, len;	881	int rc, ret = 0, size, len;
873		882
874	if (!dev->dev_attrib.pi_prot_type) {	883	if (!dev->dev_attrib.pi_prot_type) {
875	pr_err("Unable to format_prot while pi_prot_type == 0\n");	884	pr_err("Unable to format_prot while pi_prot_type == 0\n");
876	return -ENODEV;	885	return -ENODEV;
877	}	886	}
878	if (!prot_fd) {	887	if (!prot_fd) {
879	pr_err("Unable to locate fd_dev->fd_prot_file\n");	888	pr_err("Unable to locate fd_dev->fd_prot_file\n");
880	return -ENODEV;	889	return -ENODEV;
881	}	890	}
882		891
883	buf = vzalloc(unit_size);	892	buf = vzalloc(unit_size);
884	if (!buf) {	893	if (!buf) {
885	pr_err("Unable to allocate FILEIO prot buf\n");	894	pr_err("Unable to allocate FILEIO prot buf\n");
886	return -ENOMEM;	895	return -ENOMEM;
887	}	896	}
888	prot_length = (dev->transport->get_blocks(dev) + 1) * dev->prot_length;	897	prot_length = (dev->transport->get_blocks(dev) + 1) * dev->prot_length;
889	size = prot_length;	898	size = prot_length;
890		899
891	pr_debug("Using FILEIO prot_length: %llu\n",	900	pr_debug("Using FILEIO prot_length: %llu\n",
892	(unsigned long long)prot_length);	901	(unsigned long long)prot_length);
893		902
894	memset(buf, 0xff, unit_size);	903	memset(buf, 0xff, unit_size);
895	for (prot = 0; prot < prot_length; prot += unit_size) {	904	for (prot = 0; prot < prot_length; prot += unit_size) {
896	len = min(unit_size, size);	905	len = min(unit_size, size);
897	rc = kernel_write(prot_fd, buf, len, pos);	906	rc = kernel_write(prot_fd, buf, len, pos);
898	if (rc != len) {	907	if (rc != len) {
899	pr_err("vfs_write to prot file failed: %d\n", rc);	908	pr_err("vfs_write to prot file failed: %d\n", rc);
900	ret = -ENODEV;	909	ret = -ENODEV;
901	goto out;	910	goto out;
902	}	911	}
903	pos += len;	912	pos += len;
904	size -= len;	913	size -= len;
905	}	914	}
906		915
907	out:	916	out:
908	vfree(buf);	917	vfree(buf);
909	return ret;	918	return ret;
910	}	919	}
911		920
912	static void fd_free_prot(struct se_device *dev)	921	static void fd_free_prot(struct se_device *dev)
913	{	922	{
914	struct fd_dev *fd_dev = FD_DEV(dev);	923	struct fd_dev *fd_dev = FD_DEV(dev);
915		924
916	if (!fd_dev->fd_prot_file)	925	if (!fd_dev->fd_prot_file)
917	return;	926	return;
918		927
919	filp_close(fd_dev->fd_prot_file, NULL);	928	filp_close(fd_dev->fd_prot_file, NULL);
920	fd_dev->fd_prot_file = NULL;	929	fd_dev->fd_prot_file = NULL;
921	}	930	}
922		931
923	static struct sbc_ops fd_sbc_ops = {	932	static struct sbc_ops fd_sbc_ops = {
924	.execute_rw = fd_execute_rw,	933	.execute_rw = fd_execute_rw,
925	.execute_sync_cache = fd_execute_sync_cache,	934	.execute_sync_cache = fd_execute_sync_cache,
926	.execute_write_same = fd_execute_write_same,	935	.execute_write_same = fd_execute_write_same,
927	.execute_write_same_unmap = fd_execute_write_same_unmap,	936	.execute_write_same_unmap = fd_execute_write_same_unmap,
928	.execute_unmap = fd_execute_unmap,	937	.execute_unmap = fd_execute_unmap,
929	};	938	};
930		939
931	static sense_reason_t	940	static sense_reason_t
932	fd_parse_cdb(struct se_cmd *cmd)	941	fd_parse_cdb(struct se_cmd *cmd)
933	{	942	{
934	return sbc_parse_cdb(cmd, &fd_sbc_ops);	943	return sbc_parse_cdb(cmd, &fd_sbc_ops);
935	}	944	}
936		945
937	static struct se_subsystem_api fileio_template = {	946	static struct se_subsystem_api fileio_template = {
938	.name = "fileio",	947	.name = "fileio",
939	.inquiry_prod = "FILEIO",	948	.inquiry_prod = "FILEIO",
940	.inquiry_rev = FD_VERSION,	949	.inquiry_rev = FD_VERSION,
941	.owner = THIS_MODULE,	950	.owner = THIS_MODULE,
942	.transport_type = TRANSPORT_PLUGIN_VHBA_PDEV,	951	.transport_type = TRANSPORT_PLUGIN_VHBA_PDEV,
943	.attach_hba = fd_attach_hba,	952	.attach_hba = fd_attach_hba,
944	.detach_hba = fd_detach_hba,	953	.detach_hba = fd_detach_hba,
945	.alloc_device = fd_alloc_device,	954	.alloc_device = fd_alloc_device,
946	.configure_device = fd_configure_device,	955	.configure_device = fd_configure_device,
947	.free_device = fd_free_device,	956	.free_device = fd_free_device,
948	.parse_cdb = fd_parse_cdb,	957	.parse_cdb = fd_parse_cdb,
949	.set_configfs_dev_params = fd_set_configfs_dev_params,	958	.set_configfs_dev_params = fd_set_configfs_dev_params,
950	.show_configfs_dev_params = fd_show_configfs_dev_params,	959	.show_configfs_dev_params = fd_show_configfs_dev_params,
951	.get_device_type = sbc_get_device_type,	960	.get_device_type = sbc_get_device_type,
952	.get_blocks = fd_get_blocks,	961	.get_blocks = fd_get_blocks,
953	.init_prot = fd_init_prot,	962	.init_prot = fd_init_prot,
954	.format_prot = fd_format_prot,	963	.format_prot = fd_format_prot,
955	.free_prot = fd_free_prot,	964	.free_prot = fd_free_prot,
956	};	965	};
957		966
958	static int __init fileio_module_init(void)	967	static int __init fileio_module_init(void)
959	{	968	{
960	return transport_subsystem_register(&fileio_template);	969	return transport_subsystem_register(&fileio_template);
961	}	970	}
962		971
963	static void __exit fileio_module_exit(void)	972	static void __exit fileio_module_exit(void)
964	{	973	{
965	transport_subsystem_release(&fileio_template);	974	transport_subsystem_release(&fileio_template);
966	}	975	}
967		976
968	MODULE_DESCRIPTION("TCM FILEIO subsystem plugin");	977	MODULE_DESCRIPTION("TCM FILEIO subsystem plugin");
969	MODULE_AUTHOR("nab@Linux-iSCSI.org");	978	MODULE_AUTHOR("nab@Linux-iSCSI.org");
970	MODULE_LICENSE("GPL");	979	MODULE_LICENSE("GPL");
971		980
972	module_init(fileio_module_init);	981	module_init(fileio_module_init);
973	module_exit(fileio_module_exit);	982	module_exit(fileio_module_exit);
974		983

drivers/target/target_core_iblock.c

Diff comments View file @ 82bc9d0

1	/*******************************************************************************	1	/*******************************************************************************
2	* Filename: target_core_iblock.c	2	* Filename: target_core_iblock.c
3	*	3	*
4	* This file contains the Storage Engine <-> Linux BlockIO transport	4	* This file contains the Storage Engine <-> Linux BlockIO transport
5	* specific functions.	5	* specific functions.
6	*	6	*
7	* (c) Copyright 2003-2013 Datera, Inc.	7	* (c) Copyright 2003-2013 Datera, Inc.
8	*	8	*
9	* Nicholas A. Bellinger <nab@kernel.org>	9	* Nicholas A. Bellinger <nab@kernel.org>
10	*	10	*
11	* This program is free software; you can redistribute it and/or modify	11	* This program is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by	12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 2 of the License, or	13	* the Free Software Foundation; either version 2 of the License, or
14	* (at your option) any later version.	14	* (at your option) any later version.
15	*	15	*
16	* This program is distributed in the hope that it will be useful,	16	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.	19	* GNU General Public License for more details.
20	*	20	*
21	* You should have received a copy of the GNU General Public License	21	* You should have received a copy of the GNU General Public License
22	* along with this program; if not, write to the Free Software	22	* along with this program; if not, write to the Free Software
23	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.	23	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24	*	24	*
25	******************************************************************************/	25	******************************************************************************/
26		26
27	#include <linux/string.h>	27	#include <linux/string.h>
28	#include <linux/parser.h>	28	#include <linux/parser.h>
29	#include <linux/timer.h>	29	#include <linux/timer.h>
30	#include <linux/fs.h>	30	#include <linux/fs.h>
31	#include <linux/blkdev.h>	31	#include <linux/blkdev.h>
32	#include <linux/slab.h>	32	#include <linux/slab.h>
33	#include <linux/spinlock.h>	33	#include <linux/spinlock.h>
34	#include <linux/bio.h>	34	#include <linux/bio.h>
35	#include <linux/genhd.h>	35	#include <linux/genhd.h>
36	#include <linux/file.h>	36	#include <linux/file.h>
37	#include <linux/module.h>	37	#include <linux/module.h>
38	#include <scsi/scsi.h>	38	#include <scsi/scsi.h>
39	#include <scsi/scsi_host.h>	39	#include <scsi/scsi_host.h>
40	#include <asm/unaligned.h>	40	#include <asm/unaligned.h>
41		41
42	#include <target/target_core_base.h>	42	#include <target/target_core_base.h>
43	#include <target/target_core_backend.h>	43	#include <target/target_core_backend.h>
44		44
45	#include "target_core_iblock.h"	45	#include "target_core_iblock.h"
46		46
47	#define IBLOCK_MAX_BIO_PER_TASK 32 /* max # of bios to submit at a time */	47	#define IBLOCK_MAX_BIO_PER_TASK 32 /* max # of bios to submit at a time */
48	#define IBLOCK_BIO_POOL_SIZE 128	48	#define IBLOCK_BIO_POOL_SIZE 128
49		49
50	static inline struct iblock_dev IBLOCK_DEV(struct se_device dev)	50	static inline struct iblock_dev IBLOCK_DEV(struct se_device dev)
51	{	51	{
52	return container_of(dev, struct iblock_dev, dev);	52	return container_of(dev, struct iblock_dev, dev);
53	}	53	}
54		54
55		55
56	static struct se_subsystem_api iblock_template;	56	static struct se_subsystem_api iblock_template;
57		57
58	/* iblock_attach_hba(): (Part of se_subsystem_api_t template)	58	/* iblock_attach_hba(): (Part of se_subsystem_api_t template)
59	*	59	*
60	*	60	*
61	*/	61	*/
62	static int iblock_attach_hba(struct se_hba *hba, u32 host_id)	62	static int iblock_attach_hba(struct se_hba *hba, u32 host_id)
63	{	63	{
64	pr_debug("CORE_HBA[%d] - TCM iBlock HBA Driver %s on"	64	pr_debug("CORE_HBA[%d] - TCM iBlock HBA Driver %s on"
65	" Generic Target Core Stack %s\n", hba->hba_id,	65	" Generic Target Core Stack %s\n", hba->hba_id,
66	IBLOCK_VERSION, TARGET_CORE_MOD_VERSION);	66	IBLOCK_VERSION, TARGET_CORE_MOD_VERSION);
67	return 0;	67	return 0;
68	}	68	}
69		69
70	static void iblock_detach_hba(struct se_hba *hba)	70	static void iblock_detach_hba(struct se_hba *hba)
71	{	71	{
72	}	72	}
73		73
74	static struct se_device iblock_alloc_device(struct se_hba hba, const char *name)	74	static struct se_device iblock_alloc_device(struct se_hba hba, const char *name)
75	{	75	{
76	struct iblock_dev *ib_dev = NULL;	76	struct iblock_dev *ib_dev = NULL;
77		77
78	ib_dev = kzalloc(sizeof(struct iblock_dev), GFP_KERNEL);	78	ib_dev = kzalloc(sizeof(struct iblock_dev), GFP_KERNEL);
79	if (!ib_dev) {	79	if (!ib_dev) {
80	pr_err("Unable to allocate struct iblock_dev\n");	80	pr_err("Unable to allocate struct iblock_dev\n");
81	return NULL;	81	return NULL;
82	}	82	}
83		83
84	pr_debug( "IBLOCK: Allocated ib_dev for %s\n", name);	84	pr_debug( "IBLOCK: Allocated ib_dev for %s\n", name);
85		85
86	return &ib_dev->dev;	86	return &ib_dev->dev;
87	}	87	}
88		88
89	static int iblock_configure_device(struct se_device *dev)	89	static int iblock_configure_device(struct se_device *dev)
90	{	90	{
91	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);	91	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
92	struct request_queue *q;	92	struct request_queue *q;
93	struct block_device *bd = NULL;	93	struct block_device *bd = NULL;
94	struct blk_integrity *bi;	94	struct blk_integrity *bi;
95	fmode_t mode;	95	fmode_t mode;
96	int ret = -ENOMEM;	96	int ret = -ENOMEM;
97		97
98	if (!(ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH)) {	98	if (!(ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH)) {
99	pr_err("Missing udev_path= parameters for IBLOCK\n");	99	pr_err("Missing udev_path= parameters for IBLOCK\n");
100	return -EINVAL;	100	return -EINVAL;
101	}	101	}
102		102
103	ib_dev->ibd_bio_set = bioset_create(IBLOCK_BIO_POOL_SIZE, 0);	103	ib_dev->ibd_bio_set = bioset_create(IBLOCK_BIO_POOL_SIZE, 0);
104	if (!ib_dev->ibd_bio_set) {	104	if (!ib_dev->ibd_bio_set) {
105	pr_err("IBLOCK: Unable to create bioset\n");	105	pr_err("IBLOCK: Unable to create bioset\n");
106	goto out;	106	goto out;
107	}	107	}
108		108
109	pr_debug( "IBLOCK: Claiming struct block_device: %s\n",	109	pr_debug( "IBLOCK: Claiming struct block_device: %s\n",
110	ib_dev->ibd_udev_path);	110	ib_dev->ibd_udev_path);
111		111
112	mode = FMODE_READ\|FMODE_EXCL;	112	mode = FMODE_READ\|FMODE_EXCL;
113	if (!ib_dev->ibd_readonly)	113	if (!ib_dev->ibd_readonly)
114	mode \|= FMODE_WRITE;	114	mode \|= FMODE_WRITE;
115		115
116	bd = blkdev_get_by_path(ib_dev->ibd_udev_path, mode, ib_dev);	116	bd = blkdev_get_by_path(ib_dev->ibd_udev_path, mode, ib_dev);
117	if (IS_ERR(bd)) {	117	if (IS_ERR(bd)) {
118	ret = PTR_ERR(bd);	118	ret = PTR_ERR(bd);
119	goto out_free_bioset;	119	goto out_free_bioset;
120	}	120	}
121	ib_dev->ibd_bd = bd;	121	ib_dev->ibd_bd = bd;
122		122
123	q = bdev_get_queue(bd);	123	q = bdev_get_queue(bd);
124		124
125	dev->dev_attrib.hw_block_size = bdev_logical_block_size(bd);	125	dev->dev_attrib.hw_block_size = bdev_logical_block_size(bd);
126	dev->dev_attrib.hw_max_sectors = UINT_MAX;	126	dev->dev_attrib.hw_max_sectors = queue_max_hw_sectors(q);
127	dev->dev_attrib.hw_queue_depth = q->nr_requests;	127	dev->dev_attrib.hw_queue_depth = q->nr_requests;
128		128
129	/*	129	/*
130	* Check if the underlying struct block_device request_queue supports	130	* Check if the underlying struct block_device request_queue supports
131	* the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM	131	* the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM
132	* in ATA and we need to set TPE=1	132	* in ATA and we need to set TPE=1
133	*/	133	*/
134	if (blk_queue_discard(q)) {	134	if (blk_queue_discard(q)) {
135	dev->dev_attrib.max_unmap_lba_count =	135	dev->dev_attrib.max_unmap_lba_count =
136	q->limits.max_discard_sectors;	136	q->limits.max_discard_sectors;
137		137
138	/*	138	/*
139	* Currently hardcoded to 1 in Linux/SCSI code..	139	* Currently hardcoded to 1 in Linux/SCSI code..
140	*/	140	*/
141	dev->dev_attrib.max_unmap_block_desc_count = 1;	141	dev->dev_attrib.max_unmap_block_desc_count = 1;
142	dev->dev_attrib.unmap_granularity =	142	dev->dev_attrib.unmap_granularity =
143	q->limits.discard_granularity >> 9;	143	q->limits.discard_granularity >> 9;
144	dev->dev_attrib.unmap_granularity_alignment =	144	dev->dev_attrib.unmap_granularity_alignment =
145	q->limits.discard_alignment;	145	q->limits.discard_alignment;
146		146
147	pr_debug("IBLOCK: BLOCK Discard support available,"	147	pr_debug("IBLOCK: BLOCK Discard support available,"
148	" disabled by default\n");	148	" disabled by default\n");
149	}	149	}
150	/*	150	/*
151	* Enable write same emulation for IBLOCK and use 0xFFFF as	151	* Enable write same emulation for IBLOCK and use 0xFFFF as
152	* the smaller WRITE_SAME(10) only has a two-byte block count.	152	* the smaller WRITE_SAME(10) only has a two-byte block count.
153	*/	153	*/
154	dev->dev_attrib.max_write_same_len = 0xFFFF;	154	dev->dev_attrib.max_write_same_len = 0xFFFF;
155		155
156	if (blk_queue_nonrot(q))	156	if (blk_queue_nonrot(q))
157	dev->dev_attrib.is_nonrot = 1;	157	dev->dev_attrib.is_nonrot = 1;
158		158
159	bi = bdev_get_integrity(bd);	159	bi = bdev_get_integrity(bd);
160	if (bi) {	160	if (bi) {
161	struct bio_set *bs = ib_dev->ibd_bio_set;	161	struct bio_set *bs = ib_dev->ibd_bio_set;
162		162
163	if (!strcmp(bi->name, "T10-DIF-TYPE3-IP") \|\|	163	if (!strcmp(bi->name, "T10-DIF-TYPE3-IP") \|\|
164	!strcmp(bi->name, "T10-DIF-TYPE1-IP")) {	164	!strcmp(bi->name, "T10-DIF-TYPE1-IP")) {
165	pr_err("IBLOCK export of blk_integrity: %s not"	165	pr_err("IBLOCK export of blk_integrity: %s not"
166	" supported\n", bi->name);	166	" supported\n", bi->name);
167	ret = -ENOSYS;	167	ret = -ENOSYS;
168	goto out_blkdev_put;	168	goto out_blkdev_put;
169	}	169	}
170		170
171	if (!strcmp(bi->name, "T10-DIF-TYPE3-CRC")) {	171	if (!strcmp(bi->name, "T10-DIF-TYPE3-CRC")) {
172	dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE3_PROT;	172	dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE3_PROT;
173	} else if (!strcmp(bi->name, "T10-DIF-TYPE1-CRC")) {	173	} else if (!strcmp(bi->name, "T10-DIF-TYPE1-CRC")) {
174	dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE1_PROT;	174	dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE1_PROT;
175	}	175	}
176		176
177	if (dev->dev_attrib.pi_prot_type) {	177	if (dev->dev_attrib.pi_prot_type) {
178	if (bioset_integrity_create(bs, IBLOCK_BIO_POOL_SIZE) < 0) {	178	if (bioset_integrity_create(bs, IBLOCK_BIO_POOL_SIZE) < 0) {
179	pr_err("Unable to allocate bioset for PI\n");	179	pr_err("Unable to allocate bioset for PI\n");
180	ret = -ENOMEM;	180	ret = -ENOMEM;
181	goto out_blkdev_put;	181	goto out_blkdev_put;
182	}	182	}
183	pr_debug("IBLOCK setup BIP bs->bio_integrity_pool: %p\n",	183	pr_debug("IBLOCK setup BIP bs->bio_integrity_pool: %p\n",
184	bs->bio_integrity_pool);	184	bs->bio_integrity_pool);
185	}	185	}
186	dev->dev_attrib.hw_pi_prot_type = dev->dev_attrib.pi_prot_type;	186	dev->dev_attrib.hw_pi_prot_type = dev->dev_attrib.pi_prot_type;
187	}	187	}
188		188
189	return 0;	189	return 0;
190		190
191	out_blkdev_put:	191	out_blkdev_put:
192	blkdev_put(ib_dev->ibd_bd, FMODE_WRITE\|FMODE_READ\|FMODE_EXCL);	192	blkdev_put(ib_dev->ibd_bd, FMODE_WRITE\|FMODE_READ\|FMODE_EXCL);
193	out_free_bioset:	193	out_free_bioset:
194	bioset_free(ib_dev->ibd_bio_set);	194	bioset_free(ib_dev->ibd_bio_set);
195	ib_dev->ibd_bio_set = NULL;	195	ib_dev->ibd_bio_set = NULL;
196	out:	196	out:
197	return ret;	197	return ret;
198	}	198	}
199		199
200	static void iblock_free_device(struct se_device *dev)	200	static void iblock_free_device(struct se_device *dev)
201	{	201	{
202	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);	202	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
203		203
204	if (ib_dev->ibd_bd != NULL)	204	if (ib_dev->ibd_bd != NULL)
205	blkdev_put(ib_dev->ibd_bd, FMODE_WRITE\|FMODE_READ\|FMODE_EXCL);	205	blkdev_put(ib_dev->ibd_bd, FMODE_WRITE\|FMODE_READ\|FMODE_EXCL);
206	if (ib_dev->ibd_bio_set != NULL)	206	if (ib_dev->ibd_bio_set != NULL)
207	bioset_free(ib_dev->ibd_bio_set);	207	bioset_free(ib_dev->ibd_bio_set);
208		208
209	kfree(ib_dev);	209	kfree(ib_dev);
210	}	210	}
211		211
212	static unsigned long long iblock_emulate_read_cap_with_block_size(	212	static unsigned long long iblock_emulate_read_cap_with_block_size(
213	struct se_device *dev,	213	struct se_device *dev,
214	struct block_device *bd,	214	struct block_device *bd,
215	struct request_queue *q)	215	struct request_queue *q)
216	{	216	{
217	unsigned long long blocks_long = (div_u64(i_size_read(bd->bd_inode),	217	unsigned long long blocks_long = (div_u64(i_size_read(bd->bd_inode),
218	bdev_logical_block_size(bd)) - 1);	218	bdev_logical_block_size(bd)) - 1);
219	u32 block_size = bdev_logical_block_size(bd);	219	u32 block_size = bdev_logical_block_size(bd);
220		220
221	if (block_size == dev->dev_attrib.block_size)	221	if (block_size == dev->dev_attrib.block_size)
222	return blocks_long;	222	return blocks_long;
223		223
224	switch (block_size) {	224	switch (block_size) {
225	case 4096:	225	case 4096:
226	switch (dev->dev_attrib.block_size) {	226	switch (dev->dev_attrib.block_size) {
227	case 2048:	227	case 2048:
228	blocks_long <<= 1;	228	blocks_long <<= 1;
229	break;	229	break;
230	case 1024:	230	case 1024:
231	blocks_long <<= 2;	231	blocks_long <<= 2;
232	break;	232	break;
233	case 512:	233	case 512:
234	blocks_long <<= 3;	234	blocks_long <<= 3;
235	default:	235	default:
236	break;	236	break;
237	}	237	}
238	break;	238	break;
239	case 2048:	239	case 2048:
240	switch (dev->dev_attrib.block_size) {	240	switch (dev->dev_attrib.block_size) {
241	case 4096:	241	case 4096:
242	blocks_long >>= 1;	242	blocks_long >>= 1;
243	break;	243	break;
244	case 1024:	244	case 1024:
245	blocks_long <<= 1;	245	blocks_long <<= 1;
246	break;	246	break;
247	case 512:	247	case 512:
248	blocks_long <<= 2;	248	blocks_long <<= 2;
249	break;	249	break;
250	default:	250	default:
251	break;	251	break;
252	}	252	}
253	break;	253	break;
254	case 1024:	254	case 1024:
255	switch (dev->dev_attrib.block_size) {	255	switch (dev->dev_attrib.block_size) {
256	case 4096:	256	case 4096:
257	blocks_long >>= 2;	257	blocks_long >>= 2;
258	break;	258	break;
259	case 2048:	259	case 2048:
260	blocks_long >>= 1;	260	blocks_long >>= 1;
261	break;	261	break;
262	case 512:	262	case 512:
263	blocks_long <<= 1;	263	blocks_long <<= 1;
264	break;	264	break;
265	default:	265	default:
266	break;	266	break;
267	}	267	}
268	break;	268	break;
269	case 512:	269	case 512:
270	switch (dev->dev_attrib.block_size) {	270	switch (dev->dev_attrib.block_size) {
271	case 4096:	271	case 4096:
272	blocks_long >>= 3;	272	blocks_long >>= 3;
273	break;	273	break;
274	case 2048:	274	case 2048:
275	blocks_long >>= 2;	275	blocks_long >>= 2;
276	break;	276	break;
277	case 1024:	277	case 1024:
278	blocks_long >>= 1;	278	blocks_long >>= 1;
279	break;	279	break;
280	default:	280	default:
281	break;	281	break;
282	}	282	}
283	break;	283	break;
284	default:	284	default:
285	break;	285	break;
286	}	286	}
287		287
288	return blocks_long;	288	return blocks_long;
289	}	289	}
290		290
291	static void iblock_complete_cmd(struct se_cmd *cmd)	291	static void iblock_complete_cmd(struct se_cmd *cmd)
292	{	292	{
293	struct iblock_req *ibr = cmd->priv;	293	struct iblock_req *ibr = cmd->priv;
294	u8 status;	294	u8 status;
295		295
296	if (!atomic_dec_and_test(&ibr->pending))	296	if (!atomic_dec_and_test(&ibr->pending))
297	return;	297	return;
298		298
299	if (atomic_read(&ibr->ib_bio_err_cnt))	299	if (atomic_read(&ibr->ib_bio_err_cnt))
300	status = SAM_STAT_CHECK_CONDITION;	300	status = SAM_STAT_CHECK_CONDITION;
301	else	301	else
302	status = SAM_STAT_GOOD;	302	status = SAM_STAT_GOOD;
303		303
304	target_complete_cmd(cmd, status);	304	target_complete_cmd(cmd, status);
305	kfree(ibr);	305	kfree(ibr);
306	}	306	}
307		307
308	static void iblock_bio_done(struct bio *bio, int err)	308	static void iblock_bio_done(struct bio *bio, int err)
309	{	309	{
310	struct se_cmd *cmd = bio->bi_private;	310	struct se_cmd *cmd = bio->bi_private;
311	struct iblock_req *ibr = cmd->priv;	311	struct iblock_req *ibr = cmd->priv;
312		312
313	/*	313	/*
314	* Set -EIO if !BIO_UPTODATE and the passed is still err=0	314	* Set -EIO if !BIO_UPTODATE and the passed is still err=0
315	*/	315	*/
316	if (!test_bit(BIO_UPTODATE, &bio->bi_flags) && !err)	316	if (!test_bit(BIO_UPTODATE, &bio->bi_flags) && !err)
317	err = -EIO;	317	err = -EIO;
318		318
319	if (err != 0) {	319	if (err != 0) {
320	pr_err("test_bit(BIO_UPTODATE) failed for bio: %p,"	320	pr_err("test_bit(BIO_UPTODATE) failed for bio: %p,"
321	" err: %d\n", bio, err);	321	" err: %d\n", bio, err);
322	/*	322	/*
323	* Bump the ib_bio_err_cnt and release bio.	323	* Bump the ib_bio_err_cnt and release bio.
324	*/	324	*/
325	atomic_inc(&ibr->ib_bio_err_cnt);	325	atomic_inc(&ibr->ib_bio_err_cnt);
326	smp_mb__after_atomic();	326	smp_mb__after_atomic();
327	}	327	}
328		328
329	bio_put(bio);	329	bio_put(bio);
330		330
331	iblock_complete_cmd(cmd);	331	iblock_complete_cmd(cmd);
332	}	332	}
333		333
334	static struct bio *	334	static struct bio *
335	iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num)	335	iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num)
336	{	336	{
337	struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);	337	struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);
338	struct bio *bio;	338	struct bio *bio;
339		339
340	/*	340	/*
341	* Only allocate as many vector entries as the bio code allows us to,	341	* Only allocate as many vector entries as the bio code allows us to,
342	* we'll loop later on until we have handled the whole request.	342	* we'll loop later on until we have handled the whole request.
343	*/	343	*/
344	if (sg_num > BIO_MAX_PAGES)	344	if (sg_num > BIO_MAX_PAGES)
345	sg_num = BIO_MAX_PAGES;	345	sg_num = BIO_MAX_PAGES;
346		346
347	bio = bio_alloc_bioset(GFP_NOIO, sg_num, ib_dev->ibd_bio_set);	347	bio = bio_alloc_bioset(GFP_NOIO, sg_num, ib_dev->ibd_bio_set);
348	if (!bio) {	348	if (!bio) {
349	pr_err("Unable to allocate memory for bio\n");	349	pr_err("Unable to allocate memory for bio\n");
350	return NULL;	350	return NULL;
351	}	351	}
352		352
353	bio->bi_bdev = ib_dev->ibd_bd;	353	bio->bi_bdev = ib_dev->ibd_bd;
354	bio->bi_private = cmd;	354	bio->bi_private = cmd;
355	bio->bi_end_io = &iblock_bio_done;	355	bio->bi_end_io = &iblock_bio_done;
356	bio->bi_iter.bi_sector = lba;	356	bio->bi_iter.bi_sector = lba;
357		357
358	return bio;	358	return bio;
359	}	359	}
360		360
361	static void iblock_submit_bios(struct bio_list *list, int rw)	361	static void iblock_submit_bios(struct bio_list *list, int rw)
362	{	362	{
363	struct blk_plug plug;	363	struct blk_plug plug;
364	struct bio *bio;	364	struct bio *bio;
365		365
366	blk_start_plug(&plug);	366	blk_start_plug(&plug);
367	while ((bio = bio_list_pop(list)))	367	while ((bio = bio_list_pop(list)))
368	submit_bio(rw, bio);	368	submit_bio(rw, bio);
369	blk_finish_plug(&plug);	369	blk_finish_plug(&plug);
370	}	370	}
371		371
372	static void iblock_end_io_flush(struct bio *bio, int err)	372	static void iblock_end_io_flush(struct bio *bio, int err)
373	{	373	{
374	struct se_cmd *cmd = bio->bi_private;	374	struct se_cmd *cmd = bio->bi_private;
375		375
376	if (err)	376	if (err)
377	pr_err("IBLOCK: cache flush failed: %d\n", err);	377	pr_err("IBLOCK: cache flush failed: %d\n", err);
378		378
379	if (cmd) {	379	if (cmd) {
380	if (err)	380	if (err)
381	target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);	381	target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
382	else	382	else
383	target_complete_cmd(cmd, SAM_STAT_GOOD);	383	target_complete_cmd(cmd, SAM_STAT_GOOD);
384	}	384	}
385		385
386	bio_put(bio);	386	bio_put(bio);
387	}	387	}
388		388
389	/*	389	/*
390	* Implement SYCHRONIZE CACHE. Note that we can't handle lba ranges and must	390	* Implement SYCHRONIZE CACHE. Note that we can't handle lba ranges and must
391	* always flush the whole cache.	391	* always flush the whole cache.
392	*/	392	*/
393	static sense_reason_t	393	static sense_reason_t
394	iblock_execute_sync_cache(struct se_cmd *cmd)	394	iblock_execute_sync_cache(struct se_cmd *cmd)
395	{	395	{
396	struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);	396	struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);
397	int immed = (cmd->t_task_cdb[1] & 0x2);	397	int immed = (cmd->t_task_cdb[1] & 0x2);
398	struct bio *bio;	398	struct bio *bio;
399		399
400	/*	400	/*
401	* If the Immediate bit is set, queue up the GOOD response	401	* If the Immediate bit is set, queue up the GOOD response
402	* for this SYNCHRONIZE_CACHE op.	402	* for this SYNCHRONIZE_CACHE op.
403	*/	403	*/
404	if (immed)	404	if (immed)
405	target_complete_cmd(cmd, SAM_STAT_GOOD);	405	target_complete_cmd(cmd, SAM_STAT_GOOD);
406		406
407	bio = bio_alloc(GFP_KERNEL, 0);	407	bio = bio_alloc(GFP_KERNEL, 0);
408	bio->bi_end_io = iblock_end_io_flush;	408	bio->bi_end_io = iblock_end_io_flush;
409	bio->bi_bdev = ib_dev->ibd_bd;	409	bio->bi_bdev = ib_dev->ibd_bd;
410	if (!immed)	410	if (!immed)
411	bio->bi_private = cmd;	411	bio->bi_private = cmd;
412	submit_bio(WRITE_FLUSH, bio);	412	submit_bio(WRITE_FLUSH, bio);
413	return 0;	413	return 0;
414	}	414	}
415		415
416	static sense_reason_t	416	static sense_reason_t
417	iblock_do_unmap(struct se_cmd cmd, void priv,	417	iblock_do_unmap(struct se_cmd cmd, void priv,
418	sector_t lba, sector_t nolb)	418	sector_t lba, sector_t nolb)
419	{	419	{
420	struct block_device *bdev = priv;	420	struct block_device *bdev = priv;
421	int ret;	421	int ret;
422		422
423	ret = blkdev_issue_discard(bdev, lba, nolb, GFP_KERNEL, 0);	423	ret = blkdev_issue_discard(bdev, lba, nolb, GFP_KERNEL, 0);
424	if (ret < 0) {	424	if (ret < 0) {
425	pr_err("blkdev_issue_discard() failed: %d\n", ret);	425	pr_err("blkdev_issue_discard() failed: %d\n", ret);
426	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	426	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
427	}	427	}
428		428
429	return 0;	429	return 0;
430	}	430	}
431		431
432	static sense_reason_t	432	static sense_reason_t
433	iblock_execute_unmap(struct se_cmd *cmd)	433	iblock_execute_unmap(struct se_cmd *cmd)
434	{	434	{
435	struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd;	435	struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd;
436		436
437	return sbc_execute_unmap(cmd, iblock_do_unmap, bdev);	437	return sbc_execute_unmap(cmd, iblock_do_unmap, bdev);
438	}	438	}
439		439
440	static sense_reason_t	440	static sense_reason_t
441	iblock_execute_write_same_unmap(struct se_cmd *cmd)	441	iblock_execute_write_same_unmap(struct se_cmd *cmd)
442	{	442	{
443	struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd;	443	struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd;
444	sector_t lba = cmd->t_task_lba;	444	sector_t lba = cmd->t_task_lba;
445	sector_t nolb = sbc_get_write_same_sectors(cmd);	445	sector_t nolb = sbc_get_write_same_sectors(cmd);
446	int ret;	446	int ret;
447		447
448	ret = iblock_do_unmap(cmd, bdev, lba, nolb);	448	ret = iblock_do_unmap(cmd, bdev, lba, nolb);
449	if (ret)	449	if (ret)
450	return ret;	450	return ret;
451		451
452	target_complete_cmd(cmd, GOOD);	452	target_complete_cmd(cmd, GOOD);
453	return 0;	453	return 0;
454	}	454	}
455		455
456	static sense_reason_t	456	static sense_reason_t
457	iblock_execute_write_same(struct se_cmd *cmd)	457	iblock_execute_write_same(struct se_cmd *cmd)
458	{	458	{
459	struct iblock_req *ibr;	459	struct iblock_req *ibr;
460	struct scatterlist *sg;	460	struct scatterlist *sg;
461	struct bio *bio;	461	struct bio *bio;
462	struct bio_list list;	462	struct bio_list list;
463	sector_t block_lba = cmd->t_task_lba;	463	sector_t block_lba = cmd->t_task_lba;
464	sector_t sectors = sbc_get_write_same_sectors(cmd);	464	sector_t sectors = sbc_get_write_same_sectors(cmd);
465		465
466	sg = &cmd->t_data_sg[0];	466	sg = &cmd->t_data_sg[0];
467		467
468	if (cmd->t_data_nents > 1 \|\|	468	if (cmd->t_data_nents > 1 \|\|
469	sg->length != cmd->se_dev->dev_attrib.block_size) {	469	sg->length != cmd->se_dev->dev_attrib.block_size) {
470	pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"	470	pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"
471	" block_size: %u\n", cmd->t_data_nents, sg->length,	471	" block_size: %u\n", cmd->t_data_nents, sg->length,
472	cmd->se_dev->dev_attrib.block_size);	472	cmd->se_dev->dev_attrib.block_size);
473	return TCM_INVALID_CDB_FIELD;	473	return TCM_INVALID_CDB_FIELD;
474	}	474	}
475		475
476	ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL);	476	ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL);
477	if (!ibr)	477	if (!ibr)
478	goto fail;	478	goto fail;
479	cmd->priv = ibr;	479	cmd->priv = ibr;
480		480
481	bio = iblock_get_bio(cmd, block_lba, 1);	481	bio = iblock_get_bio(cmd, block_lba, 1);
482	if (!bio)	482	if (!bio)
483	goto fail_free_ibr;	483	goto fail_free_ibr;
484		484
485	bio_list_init(&list);	485	bio_list_init(&list);
486	bio_list_add(&list, bio);	486	bio_list_add(&list, bio);
487		487
488	atomic_set(&ibr->pending, 1);	488	atomic_set(&ibr->pending, 1);
489		489
490	while (sectors) {	490	while (sectors) {
491	while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)	491	while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)
492	!= sg->length) {	492	!= sg->length) {
493		493
494	bio = iblock_get_bio(cmd, block_lba, 1);	494	bio = iblock_get_bio(cmd, block_lba, 1);
495	if (!bio)	495	if (!bio)
496	goto fail_put_bios;	496	goto fail_put_bios;
497		497
498	atomic_inc(&ibr->pending);	498	atomic_inc(&ibr->pending);
499	bio_list_add(&list, bio);	499	bio_list_add(&list, bio);
500	}	500	}
501		501
502	/* Always in 512 byte units for Linux/Block */	502	/* Always in 512 byte units for Linux/Block */
503	block_lba += sg->length >> IBLOCK_LBA_SHIFT;	503	block_lba += sg->length >> IBLOCK_LBA_SHIFT;
504	sectors -= 1;	504	sectors -= 1;
505	}	505	}
506		506
507	iblock_submit_bios(&list, WRITE);	507	iblock_submit_bios(&list, WRITE);
508	return 0;	508	return 0;
509		509
510	fail_put_bios:	510	fail_put_bios:
511	while ((bio = bio_list_pop(&list)))	511	while ((bio = bio_list_pop(&list)))
512	bio_put(bio);	512	bio_put(bio);
513	fail_free_ibr:	513	fail_free_ibr:
514	kfree(ibr);	514	kfree(ibr);
515	fail:	515	fail:
516	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	516	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
517	}	517	}
518		518
519	enum {	519	enum {
520	Opt_udev_path, Opt_readonly, Opt_force, Opt_err	520	Opt_udev_path, Opt_readonly, Opt_force, Opt_err
521	};	521	};
522		522
523	static match_table_t tokens = {	523	static match_table_t tokens = {
524	{Opt_udev_path, "udev_path=%s"},	524	{Opt_udev_path, "udev_path=%s"},
525	{Opt_readonly, "readonly=%d"},	525	{Opt_readonly, "readonly=%d"},
526	{Opt_force, "force=%d"},	526	{Opt_force, "force=%d"},
527	{Opt_err, NULL}	527	{Opt_err, NULL}
528	};	528	};
529		529
530	static ssize_t iblock_set_configfs_dev_params(struct se_device *dev,	530	static ssize_t iblock_set_configfs_dev_params(struct se_device *dev,
531	const char *page, ssize_t count)	531	const char *page, ssize_t count)
532	{	532	{
533	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);	533	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
534	char orig, ptr, arg_p, opts;	534	char orig, ptr, arg_p, opts;
535	substring_t args[MAX_OPT_ARGS];	535	substring_t args[MAX_OPT_ARGS];
536	int ret = 0, token;	536	int ret = 0, token;
537	unsigned long tmp_readonly;	537	unsigned long tmp_readonly;
538		538
539	opts = kstrdup(page, GFP_KERNEL);	539	opts = kstrdup(page, GFP_KERNEL);
540	if (!opts)	540	if (!opts)
541	return -ENOMEM;	541	return -ENOMEM;
542		542
543	orig = opts;	543	orig = opts;
544		544
545	while ((ptr = strsep(&opts, ",\n")) != NULL) {	545	while ((ptr = strsep(&opts, ",\n")) != NULL) {
546	if (!*ptr)	546	if (!*ptr)
547	continue;	547	continue;
548		548
549	token = match_token(ptr, tokens, args);	549	token = match_token(ptr, tokens, args);
550	switch (token) {	550	switch (token) {
551	case Opt_udev_path:	551	case Opt_udev_path:
552	if (ib_dev->ibd_bd) {	552	if (ib_dev->ibd_bd) {
553	pr_err("Unable to set udev_path= while"	553	pr_err("Unable to set udev_path= while"
554	" ib_dev->ibd_bd exists\n");	554	" ib_dev->ibd_bd exists\n");
555	ret = -EEXIST;	555	ret = -EEXIST;
556	goto out;	556	goto out;
557	}	557	}
558	if (match_strlcpy(ib_dev->ibd_udev_path, &args[0],	558	if (match_strlcpy(ib_dev->ibd_udev_path, &args[0],
559	SE_UDEV_PATH_LEN) == 0) {	559	SE_UDEV_PATH_LEN) == 0) {
560	ret = -EINVAL;	560	ret = -EINVAL;
561	break;	561	break;
562	}	562	}
563	pr_debug("IBLOCK: Referencing UDEV path: %s\n",	563	pr_debug("IBLOCK: Referencing UDEV path: %s\n",
564	ib_dev->ibd_udev_path);	564	ib_dev->ibd_udev_path);
565	ib_dev->ibd_flags \|= IBDF_HAS_UDEV_PATH;	565	ib_dev->ibd_flags \|= IBDF_HAS_UDEV_PATH;
566	break;	566	break;
567	case Opt_readonly:	567	case Opt_readonly:
568	arg_p = match_strdup(&args[0]);	568	arg_p = match_strdup(&args[0]);
569	if (!arg_p) {	569	if (!arg_p) {
570	ret = -ENOMEM;	570	ret = -ENOMEM;
571	break;	571	break;
572	}	572	}
573	ret = kstrtoul(arg_p, 0, &tmp_readonly);	573	ret = kstrtoul(arg_p, 0, &tmp_readonly);
574	kfree(arg_p);	574	kfree(arg_p);
575	if (ret < 0) {	575	if (ret < 0) {
576	pr_err("kstrtoul() failed for"	576	pr_err("kstrtoul() failed for"
577	" readonly=\n");	577	" readonly=\n");
578	goto out;	578	goto out;
579	}	579	}
580	ib_dev->ibd_readonly = tmp_readonly;	580	ib_dev->ibd_readonly = tmp_readonly;
581	pr_debug("IBLOCK: readonly: %d\n", ib_dev->ibd_readonly);	581	pr_debug("IBLOCK: readonly: %d\n", ib_dev->ibd_readonly);
582	break;	582	break;
583	case Opt_force:	583	case Opt_force:
584	break;	584	break;
585	default:	585	default:
586	break;	586	break;
587	}	587	}
588	}	588	}
589		589
590	out:	590	out:
591	kfree(orig);	591	kfree(orig);
592	return (!ret) ? count : ret;	592	return (!ret) ? count : ret;
593	}	593	}
594		594
595	static ssize_t iblock_show_configfs_dev_params(struct se_device dev, char b)	595	static ssize_t iblock_show_configfs_dev_params(struct se_device dev, char b)
596	{	596	{
597	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);	597	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
598	struct block_device *bd = ib_dev->ibd_bd;	598	struct block_device *bd = ib_dev->ibd_bd;
599	char buf[BDEVNAME_SIZE];	599	char buf[BDEVNAME_SIZE];
600	ssize_t bl = 0;	600	ssize_t bl = 0;
601		601
602	if (bd)	602	if (bd)
603	bl += sprintf(b + bl, "iBlock device: %s",	603	bl += sprintf(b + bl, "iBlock device: %s",
604	bdevname(bd, buf));	604	bdevname(bd, buf));
605	if (ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH)	605	if (ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH)
606	bl += sprintf(b + bl, " UDEV PATH: %s",	606	bl += sprintf(b + bl, " UDEV PATH: %s",
607	ib_dev->ibd_udev_path);	607	ib_dev->ibd_udev_path);
608	bl += sprintf(b + bl, " readonly: %d\n", ib_dev->ibd_readonly);	608	bl += sprintf(b + bl, " readonly: %d\n", ib_dev->ibd_readonly);
609		609
610	bl += sprintf(b + bl, " ");	610	bl += sprintf(b + bl, " ");
611	if (bd) {	611	if (bd) {
612	bl += sprintf(b + bl, "Major: %d Minor: %d %s\n",	612	bl += sprintf(b + bl, "Major: %d Minor: %d %s\n",
613	MAJOR(bd->bd_dev), MINOR(bd->bd_dev), (!bd->bd_contains) ?	613	MAJOR(bd->bd_dev), MINOR(bd->bd_dev), (!bd->bd_contains) ?
614	"" : (bd->bd_holder == ib_dev) ?	614	"" : (bd->bd_holder == ib_dev) ?
615	"CLAIMED: IBLOCK" : "CLAIMED: OS");	615	"CLAIMED: IBLOCK" : "CLAIMED: OS");
616	} else {	616	} else {
617	bl += sprintf(b + bl, "Major: 0 Minor: 0\n");	617	bl += sprintf(b + bl, "Major: 0 Minor: 0\n");
618	}	618	}
619		619
620	return bl;	620	return bl;
621	}	621	}
622		622
623	static int	623	static int
624	iblock_alloc_bip(struct se_cmd cmd, struct bio bio)	624	iblock_alloc_bip(struct se_cmd cmd, struct bio bio)
625	{	625	{
626	struct se_device *dev = cmd->se_dev;	626	struct se_device *dev = cmd->se_dev;
627	struct blk_integrity *bi;	627	struct blk_integrity *bi;
628	struct bio_integrity_payload *bip;	628	struct bio_integrity_payload *bip;
629	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);	629	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
630	struct scatterlist *sg;	630	struct scatterlist *sg;
631	int i, rc;	631	int i, rc;
632		632
633	bi = bdev_get_integrity(ib_dev->ibd_bd);	633	bi = bdev_get_integrity(ib_dev->ibd_bd);
634	if (!bi) {	634	if (!bi) {
635	pr_err("Unable to locate bio_integrity\n");	635	pr_err("Unable to locate bio_integrity\n");
636	return -ENODEV;	636	return -ENODEV;
637	}	637	}
638		638
639	bip = bio_integrity_alloc(bio, GFP_NOIO, cmd->t_prot_nents);	639	bip = bio_integrity_alloc(bio, GFP_NOIO, cmd->t_prot_nents);
640	if (!bip) {	640	if (!bip) {
641	pr_err("Unable to allocate bio_integrity_payload\n");	641	pr_err("Unable to allocate bio_integrity_payload\n");
642	return -ENOMEM;	642	return -ENOMEM;
643	}	643	}
644		644
645	bip->bip_iter.bi_size = (cmd->data_length / dev->dev_attrib.block_size) *	645	bip->bip_iter.bi_size = (cmd->data_length / dev->dev_attrib.block_size) *
646	dev->prot_length;	646	dev->prot_length;
647	bip->bip_iter.bi_sector = bio->bi_iter.bi_sector;	647	bip->bip_iter.bi_sector = bio->bi_iter.bi_sector;
648		648
649	pr_debug("IBLOCK BIP Size: %u Sector: %llu\n", bip->bip_iter.bi_size,	649	pr_debug("IBLOCK BIP Size: %u Sector: %llu\n", bip->bip_iter.bi_size,
650	(unsigned long long)bip->bip_iter.bi_sector);	650	(unsigned long long)bip->bip_iter.bi_sector);
651		651
652	for_each_sg(cmd->t_prot_sg, sg, cmd->t_prot_nents, i) {	652	for_each_sg(cmd->t_prot_sg, sg, cmd->t_prot_nents, i) {
653		653
654	rc = bio_integrity_add_page(bio, sg_page(sg), sg->length,	654	rc = bio_integrity_add_page(bio, sg_page(sg), sg->length,
655	sg->offset);	655	sg->offset);
656	if (rc != sg->length) {	656	if (rc != sg->length) {
657	pr_err("bio_integrity_add_page() failed; %d\n", rc);	657	pr_err("bio_integrity_add_page() failed; %d\n", rc);
658	return -ENOMEM;	658	return -ENOMEM;
659	}	659	}
660		660
661	pr_debug("Added bio integrity page: %p length: %d offset; %d\n",	661	pr_debug("Added bio integrity page: %p length: %d offset; %d\n",
662	sg_page(sg), sg->length, sg->offset);	662	sg_page(sg), sg->length, sg->offset);
663	}	663	}
664		664
665	return 0;	665	return 0;
666	}	666	}
667		667
668	static sense_reason_t	668	static sense_reason_t
669	iblock_execute_rw(struct se_cmd cmd, struct scatterlist sgl, u32 sgl_nents,	669	iblock_execute_rw(struct se_cmd cmd, struct scatterlist sgl, u32 sgl_nents,
670	enum dma_data_direction data_direction)	670	enum dma_data_direction data_direction)
671	{	671	{
672	struct se_device *dev = cmd->se_dev;	672	struct se_device *dev = cmd->se_dev;
673	struct iblock_req *ibr;	673	struct iblock_req *ibr;
674	struct bio bio, bio_start;	674	struct bio bio, bio_start;
675	struct bio_list list;	675	struct bio_list list;
676	struct scatterlist *sg;	676	struct scatterlist *sg;
677	u32 sg_num = sgl_nents;	677	u32 sg_num = sgl_nents;
678	sector_t block_lba;	678	sector_t block_lba;
679	unsigned bio_cnt;	679	unsigned bio_cnt;
680	int rw = 0;	680	int rw = 0;
681	int i;	681	int i;
682		682
683	if (data_direction == DMA_TO_DEVICE) {	683	if (data_direction == DMA_TO_DEVICE) {
684	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);	684	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
685	struct request_queue *q = bdev_get_queue(ib_dev->ibd_bd);	685	struct request_queue *q = bdev_get_queue(ib_dev->ibd_bd);
686	/*	686	/*
687	* Force writethrough using WRITE_FUA if a volatile write cache	687	* Force writethrough using WRITE_FUA if a volatile write cache
688	* is not enabled, or if initiator set the Force Unit Access bit.	688	* is not enabled, or if initiator set the Force Unit Access bit.
689	*/	689	*/
690	if (q->flush_flags & REQ_FUA) {	690	if (q->flush_flags & REQ_FUA) {
691	if (cmd->se_cmd_flags & SCF_FUA)	691	if (cmd->se_cmd_flags & SCF_FUA)
692	rw = WRITE_FUA;	692	rw = WRITE_FUA;
693	else if (!(q->flush_flags & REQ_FLUSH))	693	else if (!(q->flush_flags & REQ_FLUSH))
694	rw = WRITE_FUA;	694	rw = WRITE_FUA;
695	else	695	else
696	rw = WRITE;	696	rw = WRITE;
697	} else {	697	} else {
698	rw = WRITE;	698	rw = WRITE;
699	}	699	}
700	} else {	700	} else {
701	rw = READ;	701	rw = READ;
702	}	702	}
703		703
704	/*	704	/*
705	* Convert the blocksize advertised to the initiator to the 512 byte	705	* Convert the blocksize advertised to the initiator to the 512 byte
706	* units unconditionally used by the Linux block layer.	706	* units unconditionally used by the Linux block layer.
707	*/	707	*/
708	if (dev->dev_attrib.block_size == 4096)	708	if (dev->dev_attrib.block_size == 4096)
709	block_lba = (cmd->t_task_lba << 3);	709	block_lba = (cmd->t_task_lba << 3);
710	else if (dev->dev_attrib.block_size == 2048)	710	else if (dev->dev_attrib.block_size == 2048)
711	block_lba = (cmd->t_task_lba << 2);	711	block_lba = (cmd->t_task_lba << 2);
712	else if (dev->dev_attrib.block_size == 1024)	712	else if (dev->dev_attrib.block_size == 1024)
713	block_lba = (cmd->t_task_lba << 1);	713	block_lba = (cmd->t_task_lba << 1);
714	else if (dev->dev_attrib.block_size == 512)	714	else if (dev->dev_attrib.block_size == 512)
715	block_lba = cmd->t_task_lba;	715	block_lba = cmd->t_task_lba;
716	else {	716	else {
717	pr_err("Unsupported SCSI -> BLOCK LBA conversion:"	717	pr_err("Unsupported SCSI -> BLOCK LBA conversion:"
718	" %u\n", dev->dev_attrib.block_size);	718	" %u\n", dev->dev_attrib.block_size);
719	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	719	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
720	}	720	}
721		721
722	ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL);	722	ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL);
723	if (!ibr)	723	if (!ibr)
724	goto fail;	724	goto fail;
725	cmd->priv = ibr;	725	cmd->priv = ibr;
726		726
727	if (!sgl_nents) {	727	if (!sgl_nents) {
728	atomic_set(&ibr->pending, 1);	728	atomic_set(&ibr->pending, 1);
729	iblock_complete_cmd(cmd);	729	iblock_complete_cmd(cmd);
730	return 0;	730	return 0;
731	}	731	}
732		732
733	bio = iblock_get_bio(cmd, block_lba, sgl_nents);	733	bio = iblock_get_bio(cmd, block_lba, sgl_nents);
734	if (!bio)	734	if (!bio)
735	goto fail_free_ibr;	735	goto fail_free_ibr;
736		736
737	bio_start = bio;	737	bio_start = bio;
738	bio_list_init(&list);	738	bio_list_init(&list);
739	bio_list_add(&list, bio);	739	bio_list_add(&list, bio);
740		740
741	atomic_set(&ibr->pending, 2);	741	atomic_set(&ibr->pending, 2);
742	bio_cnt = 1;	742	bio_cnt = 1;
743		743
744	for_each_sg(sgl, sg, sgl_nents, i) {	744	for_each_sg(sgl, sg, sgl_nents, i) {
745	/*	745	/*
746	* XXX: if the length the device accepts is shorter than the	746	* XXX: if the length the device accepts is shorter than the
747	* length of the S/G list entry this will cause and	747	* length of the S/G list entry this will cause and
748	* endless loop. Better hope no driver uses huge pages.	748	* endless loop. Better hope no driver uses huge pages.
749	*/	749	*/
750	while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)	750	while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)
751	!= sg->length) {	751	!= sg->length) {
752	if (bio_cnt >= IBLOCK_MAX_BIO_PER_TASK) {	752	if (bio_cnt >= IBLOCK_MAX_BIO_PER_TASK) {
753	iblock_submit_bios(&list, rw);	753	iblock_submit_bios(&list, rw);
754	bio_cnt = 0;	754	bio_cnt = 0;
755	}	755	}
756		756
757	bio = iblock_get_bio(cmd, block_lba, sg_num);	757	bio = iblock_get_bio(cmd, block_lba, sg_num);
758	if (!bio)	758	if (!bio)
759	goto fail_put_bios;	759	goto fail_put_bios;
760		760
761	atomic_inc(&ibr->pending);	761	atomic_inc(&ibr->pending);
762	bio_list_add(&list, bio);	762	bio_list_add(&list, bio);
763	bio_cnt++;	763	bio_cnt++;
764	}	764	}
765		765
766	/* Always in 512 byte units for Linux/Block */	766	/* Always in 512 byte units for Linux/Block */
767	block_lba += sg->length >> IBLOCK_LBA_SHIFT;	767	block_lba += sg->length >> IBLOCK_LBA_SHIFT;
768	sg_num--;	768	sg_num--;
769	}	769	}
770		770
771	if (cmd->prot_type) {	771	if (cmd->prot_type) {
772	int rc = iblock_alloc_bip(cmd, bio_start);	772	int rc = iblock_alloc_bip(cmd, bio_start);
773	if (rc)	773	if (rc)
774	goto fail_put_bios;	774	goto fail_put_bios;
775	}	775	}
776		776
777	iblock_submit_bios(&list, rw);	777	iblock_submit_bios(&list, rw);
778	iblock_complete_cmd(cmd);	778	iblock_complete_cmd(cmd);
779	return 0;	779	return 0;
780		780
781	fail_put_bios:	781	fail_put_bios:
782	while ((bio = bio_list_pop(&list)))	782	while ((bio = bio_list_pop(&list)))
783	bio_put(bio);	783	bio_put(bio);
784	fail_free_ibr:	784	fail_free_ibr:
785	kfree(ibr);	785	kfree(ibr);
786	fail:	786	fail:
787	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;	787	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
788	}	788	}
789		789
790	static sector_t iblock_get_blocks(struct se_device *dev)	790	static sector_t iblock_get_blocks(struct se_device *dev)
791	{	791	{
792	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);	792	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
793	struct block_device *bd = ib_dev->ibd_bd;	793	struct block_device *bd = ib_dev->ibd_bd;
794	struct request_queue *q = bdev_get_queue(bd);	794	struct request_queue *q = bdev_get_queue(bd);
795		795
796	return iblock_emulate_read_cap_with_block_size(dev, bd, q);	796	return iblock_emulate_read_cap_with_block_size(dev, bd, q);
797	}	797	}
798		798
799	static sector_t iblock_get_alignment_offset_lbas(struct se_device *dev)	799	static sector_t iblock_get_alignment_offset_lbas(struct se_device *dev)
800	{	800	{
801	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);	801	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
802	struct block_device *bd = ib_dev->ibd_bd;	802	struct block_device *bd = ib_dev->ibd_bd;
803	int ret;	803	int ret;
804		804
805	ret = bdev_alignment_offset(bd);	805	ret = bdev_alignment_offset(bd);
806	if (ret == -1)	806	if (ret == -1)
807	return 0;	807	return 0;
808		808
809	/* convert offset-bytes to offset-lbas */	809	/* convert offset-bytes to offset-lbas */
810	return ret / bdev_logical_block_size(bd);	810	return ret / bdev_logical_block_size(bd);
811	}	811	}
812		812
813	static unsigned int iblock_get_lbppbe(struct se_device *dev)	813	static unsigned int iblock_get_lbppbe(struct se_device *dev)
814	{	814	{
815	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);	815	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
816	struct block_device *bd = ib_dev->ibd_bd;	816	struct block_device *bd = ib_dev->ibd_bd;
817	int logs_per_phys = bdev_physical_block_size(bd) / bdev_logical_block_size(bd);	817	int logs_per_phys = bdev_physical_block_size(bd) / bdev_logical_block_size(bd);
818		818
819	return ilog2(logs_per_phys);	819	return ilog2(logs_per_phys);
820	}	820	}
821		821
822	static unsigned int iblock_get_io_min(struct se_device *dev)	822	static unsigned int iblock_get_io_min(struct se_device *dev)
823	{	823	{
824	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);	824	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
825	struct block_device *bd = ib_dev->ibd_bd;	825	struct block_device *bd = ib_dev->ibd_bd;
826		826
827	return bdev_io_min(bd);	827	return bdev_io_min(bd);
828	}	828	}
829		829
830	static unsigned int iblock_get_io_opt(struct se_device *dev)	830	static unsigned int iblock_get_io_opt(struct se_device *dev)
831	{	831	{
832	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);	832	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
833	struct block_device *bd = ib_dev->ibd_bd;	833	struct block_device *bd = ib_dev->ibd_bd;
834		834
835	return bdev_io_opt(bd);	835	return bdev_io_opt(bd);
836	}	836	}
837		837
838	static struct sbc_ops iblock_sbc_ops = {	838	static struct sbc_ops iblock_sbc_ops = {
839	.execute_rw = iblock_execute_rw,	839	.execute_rw = iblock_execute_rw,
840	.execute_sync_cache = iblock_execute_sync_cache,	840	.execute_sync_cache = iblock_execute_sync_cache,
841	.execute_write_same = iblock_execute_write_same,	841	.execute_write_same = iblock_execute_write_same,
842	.execute_write_same_unmap = iblock_execute_write_same_unmap,	842	.execute_write_same_unmap = iblock_execute_write_same_unmap,
843	.execute_unmap = iblock_execute_unmap,	843	.execute_unmap = iblock_execute_unmap,
844	};	844	};
845		845
846	static sense_reason_t	846	static sense_reason_t
847	iblock_parse_cdb(struct se_cmd *cmd)	847	iblock_parse_cdb(struct se_cmd *cmd)
848	{	848	{
849	return sbc_parse_cdb(cmd, &iblock_sbc_ops);	849	return sbc_parse_cdb(cmd, &iblock_sbc_ops);
850	}	850	}
851		851
852	static bool iblock_get_write_cache(struct se_device *dev)	852	static bool iblock_get_write_cache(struct se_device *dev)
853	{	853	{
854	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);	854	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
855	struct block_device *bd = ib_dev->ibd_bd;	855	struct block_device *bd = ib_dev->ibd_bd;
856	struct request_queue *q = bdev_get_queue(bd);	856	struct request_queue *q = bdev_get_queue(bd);
857		857
858	return q->flush_flags & REQ_FLUSH;	858	return q->flush_flags & REQ_FLUSH;
859	}	859	}
860		860
861	static struct se_subsystem_api iblock_template = {	861	static struct se_subsystem_api iblock_template = {
862	.name = "iblock",	862	.name = "iblock",
863	.inquiry_prod = "IBLOCK",	863	.inquiry_prod = "IBLOCK",
864	.inquiry_rev = IBLOCK_VERSION,	864	.inquiry_rev = IBLOCK_VERSION,
865	.owner = THIS_MODULE,	865	.owner = THIS_MODULE,
866	.transport_type = TRANSPORT_PLUGIN_VHBA_PDEV,	866	.transport_type = TRANSPORT_PLUGIN_VHBA_PDEV,
867	.attach_hba = iblock_attach_hba,	867	.attach_hba = iblock_attach_hba,
868	.detach_hba = iblock_detach_hba,	868	.detach_hba = iblock_detach_hba,
869	.alloc_device = iblock_alloc_device,	869	.alloc_device = iblock_alloc_device,
870	.configure_device = iblock_configure_device,	870	.configure_device = iblock_configure_device,
871	.free_device = iblock_free_device,	871	.free_device = iblock_free_device,
872	.parse_cdb = iblock_parse_cdb,	872	.parse_cdb = iblock_parse_cdb,
873	.set_configfs_dev_params = iblock_set_configfs_dev_params,	873	.set_configfs_dev_params = iblock_set_configfs_dev_params,
874	.show_configfs_dev_params = iblock_show_configfs_dev_params,	874	.show_configfs_dev_params = iblock_show_configfs_dev_params,
875	.get_device_type = sbc_get_device_type,	875	.get_device_type = sbc_get_device_type,
876	.get_blocks = iblock_get_blocks,	876	.get_blocks = iblock_get_blocks,
877	.get_alignment_offset_lbas = iblock_get_alignment_offset_lbas,	877	.get_alignment_offset_lbas = iblock_get_alignment_offset_lbas,
878	.get_lbppbe = iblock_get_lbppbe,	878	.get_lbppbe = iblock_get_lbppbe,
879	.get_io_min = iblock_get_io_min,	879	.get_io_min = iblock_get_io_min,
880	.get_io_opt = iblock_get_io_opt,	880	.get_io_opt = iblock_get_io_opt,
881	.get_write_cache = iblock_get_write_cache,	881	.get_write_cache = iblock_get_write_cache,
882	};	882	};
883		883
884	static int __init iblock_module_init(void)	884	static int __init iblock_module_init(void)
885	{	885	{
886	return transport_subsystem_register(&iblock_template);	886	return transport_subsystem_register(&iblock_template);
887	}	887	}
888		888
889	static void __exit iblock_module_exit(void)	889	static void __exit iblock_module_exit(void)
890	{	890	{
891	transport_subsystem_release(&iblock_template);	891	transport_subsystem_release(&iblock_template);
892	}	892	}
893		893
894	MODULE_DESCRIPTION("TCM IBLOCK subsystem plugin");	894	MODULE_DESCRIPTION("TCM IBLOCK subsystem plugin");
895	MODULE_AUTHOR("nab@Linux-iSCSI.org");	895	MODULE_AUTHOR("nab@Linux-iSCSI.org");
896	MODULE_LICENSE("GPL");	896	MODULE_LICENSE("GPL");
897		897
898	module_init(iblock_module_init);	898	module_init(iblock_module_init);
899	module_exit(iblock_module_exit);	899	module_exit(iblock_module_exit);
900		900

drivers/target/target_core_sbc.c

Diff comments View file @ 82bc9d0

 /*
  * SCSI Block Commands (SBC) parsing and emulation.
  *
  * (c) Copyright 2002-2013 Datera, Inc.
  *
  * Nicholas A. Bellinger <nab@kernel.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/ratelimit.h>
 #include <linux/crc-t10dif.h>
 #include <asm/unaligned.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_tcq.h>
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
 #include "target_core_internal.h"
 #include "target_core_ua.h"
 #include "target_core_alua.h"
 static sense_reason_t
 sbc_emulate_readcapacity(struct se_cmd *cmd)
 {
 	struct se_device *dev = cmd->se_dev;
 	unsigned char *cdb = cmd->t_task_cdb;
 	unsigned long long blocks_long = dev->transport->get_blocks(dev);
 	unsigned char *rbuf;
 	unsigned char buf[8];
 	u32 blocks;
 	/*
 	 * SBC-2 says:
 	 *   If the PMI bit is set to zero and the LOGICAL BLOCK
 	 *   ADDRESS field is not set to zero, the device server shall
 	 *   terminate the command with CHECK CONDITION status with
 	 *   the sense key set to ILLEGAL REQUEST and the additional
 	 *   sense code set to INVALID FIELD IN CDB.
 	 *
 	 * In SBC-3, these fields are obsolete, but some SCSI
 	 * compliance tests actually check this, so we might as well
 	 * follow SBC-2.
 	 */
 	if (!(cdb[8] & 1) && !!(cdb[2] | cdb[3] | cdb[4] | cdb[5]))
 		return TCM_INVALID_CDB_FIELD;
 	if (blocks_long >= 0x00000000ffffffff)
 		blocks = 0xffffffff;
 	else
 		blocks = (u32)blocks_long;
 	buf[0] = (blocks >> 24) & 0xff;
 	buf[1] = (blocks >> 16) & 0xff;
 	buf[2] = (blocks >> 8) & 0xff;
 	buf[3] = blocks & 0xff;
 	buf[4] = (dev->dev_attrib.block_size >> 24) & 0xff;
 	buf[5] = (dev->dev_attrib.block_size >> 16) & 0xff;
 	buf[6] = (dev->dev_attrib.block_size >> 8) & 0xff;
 	buf[7] = dev->dev_attrib.block_size & 0xff;
 	rbuf = transport_kmap_data_sg(cmd);
 	if (rbuf) {
 		memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
 		transport_kunmap_data_sg(cmd);
 	}
 	target_complete_cmd_with_length(cmd, GOOD, 8);
 	return 0;
 }
 static sense_reason_t
 sbc_emulate_readcapacity_16(struct se_cmd *cmd)
 {
 	struct se_device *dev = cmd->se_dev;
 	struct se_session *sess = cmd->se_sess;
 	unsigned char *rbuf;
 	unsigned char buf[32];
 	unsigned long long blocks = dev->transport->get_blocks(dev);
 	memset(buf, 0, sizeof(buf));
 	buf[0] = (blocks >> 56) & 0xff;
 	buf[1] = (blocks >> 48) & 0xff;
 	buf[2] = (blocks >> 40) & 0xff;
 	buf[3] = (blocks >> 32) & 0xff;
 	buf[4] = (blocks >> 24) & 0xff;
 	buf[5] = (blocks >> 16) & 0xff;
 	buf[6] = (blocks >> 8) & 0xff;
 	buf[7] = blocks & 0xff;
 	buf[8] = (dev->dev_attrib.block_size >> 24) & 0xff;
 	buf[9] = (dev->dev_attrib.block_size >> 16) & 0xff;
 	buf[10] = (dev->dev_attrib.block_size >> 8) & 0xff;
 	buf[11] = dev->dev_attrib.block_size & 0xff;
 	/*
 	 * Set P_TYPE and PROT_EN bits for DIF support
 	 */
 	if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
 		if (dev->dev_attrib.pi_prot_type)
 			buf[12] = (dev->dev_attrib.pi_prot_type - 1) << 1 | 0x1;
 	}
 	if (dev->transport->get_lbppbe)
 		buf[13] = dev->transport->get_lbppbe(dev) & 0x0f;
 	if (dev->transport->get_alignment_offset_lbas) {
 		u16 lalba = dev->transport->get_alignment_offset_lbas(dev);
 		buf[14] = (lalba >> 8) & 0x3f;
 		buf[15] = lalba & 0xff;
 	}
 	/*
 	 * Set Thin Provisioning Enable bit following sbc3r22 in section
 	 * READ CAPACITY (16) byte 14 if emulate_tpu or emulate_tpws is enabled.
 	 */
 	if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws)
 		buf[14] |= 0x80;
 	rbuf = transport_kmap_data_sg(cmd);
 	if (rbuf) {
 		memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
 		transport_kunmap_data_sg(cmd);
 	}
 	target_complete_cmd_with_length(cmd, GOOD, 32);
 	return 0;
 }
 sector_t sbc_get_write_same_sectors(struct se_cmd *cmd)
 {
 	u32 num_blocks;
 	if (cmd->t_task_cdb[0] == WRITE_SAME)
 		num_blocks = get_unaligned_be16(&cmd->t_task_cdb[7]);
 	else if (cmd->t_task_cdb[0] == WRITE_SAME_16)
 		num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]);
 	else /* WRITE_SAME_32 via VARIABLE_LENGTH_CMD */
 		num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]);
 	/*
 	 * Use the explicit range when non zero is supplied, otherwise calculate
 	 * the remaining range based on ->get_blocks() - starting LBA.
 	 */
 	if (num_blocks)
 		return num_blocks;
 	return cmd->se_dev->transport->get_blocks(cmd->se_dev) -
 		cmd->t_task_lba + 1;
 }
 EXPORT_SYMBOL(sbc_get_write_same_sectors);
 static sense_reason_t
 sbc_emulate_noop(struct se_cmd *cmd)
 {
 	target_complete_cmd(cmd, GOOD);
 	return 0;
 }
 static inline u32 sbc_get_size(struct se_cmd *cmd, u32 sectors)
 {
 	return cmd->se_dev->dev_attrib.block_size * sectors;
 }
 static inline u32 transport_get_sectors_6(unsigned char *cdb)
 {
 	/*
 	 * Use 8-bit sector value.  SBC-3 says:
 	 *
 	 *   A TRANSFER LENGTH field set to zero specifies that 256
 	 *   logical blocks shall be written.  Any other value
 	 *   specifies the number of logical blocks that shall be
 	 *   written.
 	 */
 	return cdb[4] ? : 256;
 }
 static inline u32 transport_get_sectors_10(unsigned char *cdb)
 {
 	return (u32)(cdb[7] << 8) + cdb[8];
 }
 static inline u32 transport_get_sectors_12(unsigned char *cdb)
 {
 	return (u32)(cdb[6] << 24) + (cdb[7] << 16) + (cdb[8] << 8) + cdb[9];
 }
 static inline u32 transport_get_sectors_16(unsigned char *cdb)
 {
 	return (u32)(cdb[10] << 24) + (cdb[11] << 16) +
 		    (cdb[12] << 8) + cdb[13];
 }
 /*
  * Used for VARIABLE_LENGTH_CDB WRITE_32 and READ_32 variants
  */
 static inline u32 transport_get_sectors_32(unsigned char *cdb)
 {
 	return (u32)(cdb[28] << 24) + (cdb[29] << 16) +
 		    (cdb[30] << 8) + cdb[31];
 }
 static inline u32 transport_lba_21(unsigned char *cdb)
 {
 	return ((cdb[1] & 0x1f) << 16) | (cdb[2] << 8) | cdb[3];
 }
 static inline u32 transport_lba_32(unsigned char *cdb)
 {
 	return (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
 }
 static inline unsigned long long transport_lba_64(unsigned char *cdb)
 {
 	unsigned int __v1, __v2;
 	__v1 = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5];
 	__v2 = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
 	return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
 }
 /*
  * For VARIABLE_LENGTH_CDB w/ 32 byte extended CDBs
  */
 static inline unsigned long long transport_lba_64_ext(unsigned char *cdb)
 {
 	unsigned int __v1, __v2;
 	__v1 = (cdb[12] << 24) | (cdb[13] << 16) | (cdb[14] << 8) | cdb[15];
 	__v2 = (cdb[16] << 24) | (cdb[17] << 16) | (cdb[18] << 8) | cdb[19];
 	return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
 }
 static sense_reason_t
 sbc_setup_write_same(struct se_cmd *cmd, unsigned char *flags, struct sbc_ops *ops)
 {
 	unsigned int sectors = sbc_get_write_same_sectors(cmd);
 	if ((flags[0] & 0x04) || (flags[0] & 0x02)) {
 		pr_err("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) {
 		pr_warn("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;
 	}
 	/* We always have ANC_SUP == 0 so setting ANCHOR is always an error */
 	if (flags[0] & 0x10) {
 		pr_warn("WRITE SAME with ANCHOR not supported\n");
 		return TCM_INVALID_CDB_FIELD;
 	}
 	/*
 	 * Special case for WRITE_SAME w/ UNMAP=1 that ends up getting
 	 * translated into block discard requests within backend code.
 	 */
 	if (flags[0] & 0x08) {
 		if (!ops->execute_write_same_unmap)
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		cmd->execute_cmd = ops->execute_write_same_unmap;
 		return 0;
 	}
 	if (!ops->execute_write_same)
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	cmd->execute_cmd = ops->execute_write_same;
 	return 0;
 }
 static sense_reason_t xdreadwrite_callback(struct se_cmd *cmd)
 {
 	unsigned char *buf, *addr;
 	struct scatterlist *sg;
 	unsigned int offset;
 	sense_reason_t ret = TCM_NO_SENSE;
 	int i, count;
 	/*
 	 * From sbc3r22.pdf section 5.48 XDWRITEREAD (10) command
 	 *
 	 * 1) read the specified logical block(s);
 	 * 2) transfer logical blocks from the data-out buffer;
 	 * 3) XOR the logical blocks transferred from the data-out buffer with
 	 *    the logical blocks read, storing the resulting XOR data in a buffer;
 	 * 4) if the DISABLE WRITE bit is set to zero, then write the logical
 	 *    blocks transferred from the data-out buffer; and
 	 * 5) transfer the resulting XOR data to the data-in buffer.
 	 */
 	buf = kmalloc(cmd->data_length, GFP_KERNEL);
 	if (!buf) {
 		pr_err("Unable to allocate xor_callback buf\n");
 		return TCM_OUT_OF_RESOURCES;
 	}
 	/*
 	 * Copy the scatterlist WRITE buffer located at cmd->t_data_sg
 	 * into the locally allocated *buf
 	 */
 	sg_copy_to_buffer(cmd->t_data_sg,
 			  cmd->t_data_nents,
 			  buf,
 			  cmd->data_length);
 	/*
 	 * Now perform the XOR against the BIDI read memory located at
 	 * cmd->t_mem_bidi_list
 	 */
 	offset = 0;
 	for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, count) {
 		addr = kmap_atomic(sg_page(sg));
 		if (!addr) {
 			ret = TCM_OUT_OF_RESOURCES;
 			goto out;
 		}
 		for (i = 0; i < sg->length; i++)
 			*(addr + sg->offset + i) ^= *(buf + offset + i);
 		offset += sg->length;
 		kunmap_atomic(addr);
 	}
 out:
 	kfree(buf);
 	return ret;
 }
 static sense_reason_t
 sbc_execute_rw(struct se_cmd *cmd)
 {
 	return cmd->execute_rw(cmd, cmd->t_data_sg, cmd->t_data_nents,
 			       cmd->data_direction);
 }
 static sense_reason_t compare_and_write_post(struct se_cmd *cmd)
 {
 	struct se_device *dev = cmd->se_dev;
 	/*
 	 * Only set SCF_COMPARE_AND_WRITE_POST to force a response fall-through
 	 * within target_complete_ok_work() if the command was successfully
 	 * sent to the backend driver.
 	 */
 	spin_lock_irq(&cmd->t_state_lock);
 	if ((cmd->transport_state & CMD_T_SENT) && !cmd->scsi_status)
 		cmd->se_cmd_flags |= SCF_COMPARE_AND_WRITE_POST;
 	spin_unlock_irq(&cmd->t_state_lock);
 	/*
 	 * Unlock ->caw_sem originally obtained during sbc_compare_and_write()
 	 * before the original READ I/O submission.
 	 */
 	up(&dev->caw_sem);
 	return TCM_NO_SENSE;
 }
 static sense_reason_t compare_and_write_callback(struct se_cmd *cmd)
 {
 	struct se_device *dev = cmd->se_dev;
 	struct scatterlist *write_sg = NULL, *sg;
 	unsigned char *buf = NULL, *addr;
 	struct sg_mapping_iter m;
 	unsigned int offset = 0, len;
 	unsigned int nlbas = cmd->t_task_nolb;
 	unsigned int block_size = dev->dev_attrib.block_size;
 	unsigned int compare_len = (nlbas * block_size);
 	sense_reason_t ret = TCM_NO_SENSE;
 	int rc, i;
 	/*
 	 * Handle early failure in transport_generic_request_failure(),
 	 * which will not have taken ->caw_mutex yet..
 	 */
 	if (!cmd->t_data_sg || !cmd->t_bidi_data_sg)
 		return TCM_NO_SENSE;
 	/*
 	 * Immediately exit + release dev->caw_sem if command has already
 	 * been failed with a non-zero SCSI status.
 	 */
 	if (cmd->scsi_status) {
 		pr_err("compare_and_write_callback: non zero scsi_status:"
 			" 0x%02x\n", cmd->scsi_status);
 		goto out;
 	}
 	buf = kzalloc(cmd->data_length, GFP_KERNEL);
 	if (!buf) {
 		pr_err("Unable to allocate compare_and_write buf\n");
 		ret = TCM_OUT_OF_RESOURCES;
 		goto out;
 	}
 	write_sg = kmalloc(sizeof(struct scatterlist) * cmd->t_data_nents,
 			   GFP_KERNEL);
 	if (!write_sg) {
 		pr_err("Unable to allocate compare_and_write sg\n");
 		ret = TCM_OUT_OF_RESOURCES;
 		goto out;
 	}
 	sg_init_table(write_sg, cmd->t_data_nents);
 	/*
 	 * Setup verify and write data payloads from total NumberLBAs.
 	 */
 	rc = sg_copy_to_buffer(cmd->t_data_sg, cmd->t_data_nents, buf,
 			       cmd->data_length);
 	if (!rc) {
 		pr_err("sg_copy_to_buffer() failed for compare_and_write\n");
 		ret = TCM_OUT_OF_RESOURCES;
 		goto out;
 	}
 	/*
 	 * Compare against SCSI READ payload against verify payload
 	 */
 	for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, i) {
 		addr = (unsigned char *)kmap_atomic(sg_page(sg));
 		if (!addr) {
 			ret = TCM_OUT_OF_RESOURCES;
 			goto out;
 		}
 		len = min(sg->length, compare_len);
 		if (memcmp(addr, buf + offset, len)) {
 			pr_warn("Detected MISCOMPARE for addr: %p buf: %p\n",
 				addr, buf + offset);
 			kunmap_atomic(addr);
 			goto miscompare;
 		}
 		kunmap_atomic(addr);
 		offset += len;
 		compare_len -= len;
 		if (!compare_len)
 			break;
 	}
 	i = 0;
 	len = cmd->t_task_nolb * block_size;
 	sg_miter_start(&m, cmd->t_data_sg, cmd->t_data_nents, SG_MITER_TO_SG);
 	/*
 	 * Currently assumes NoLB=1 and SGLs are PAGE_SIZE..
 	 */
 	while (len) {
 		sg_miter_next(&m);
 		if (block_size < PAGE_SIZE) {
 			sg_set_page(&write_sg[i], m.page, block_size,
 				    block_size);
 		} else {
 			sg_miter_next(&m);
 			sg_set_page(&write_sg[i], m.page, block_size,
 				    0);
 		}
 		len -= block_size;
 		i++;
 	}
 	sg_miter_stop(&m);
 	/*
 	 * Save the original SGL + nents values before updating to new
 	 * assignments, to be released in transport_free_pages() ->
 	 * transport_reset_sgl_orig()
 	 */
 	cmd->t_data_sg_orig = cmd->t_data_sg;
 	cmd->t_data_sg = write_sg;
 	cmd->t_data_nents_orig = cmd->t_data_nents;
 	cmd->t_data_nents = 1;
 	cmd->sam_task_attr = MSG_HEAD_TAG;
 	cmd->transport_complete_callback = compare_and_write_post;
 	/*
 	 * Now reset ->execute_cmd() to the normal sbc_execute_rw() handler
 	 * for submitting the adjusted SGL to write instance user-data.
 	 */
 	cmd->execute_cmd = sbc_execute_rw;
 	spin_lock_irq(&cmd->t_state_lock);
 	cmd->t_state = TRANSPORT_PROCESSING;
 	cmd->transport_state |= CMD_T_ACTIVE|CMD_T_BUSY|CMD_T_SENT;
 	spin_unlock_irq(&cmd->t_state_lock);
 	__target_execute_cmd(cmd);
 	kfree(buf);
 	return ret;
 miscompare:
 	pr_warn("Target/%s: Send MISCOMPARE check condition and sense\n",
 		dev->transport->name);
 	ret = TCM_MISCOMPARE_VERIFY;
 out:
 	/*
 	 * In the MISCOMPARE or failure case, unlock ->caw_sem obtained in
 	 * sbc_compare_and_write() before the original READ I/O submission.
 	 */
 	up(&dev->caw_sem);
 	kfree(write_sg);
 	kfree(buf);
 	return ret;
 }
 static sense_reason_t
 sbc_compare_and_write(struct se_cmd *cmd)
 {
 	struct se_device *dev = cmd->se_dev;
 	sense_reason_t ret;
 	int rc;
 	/*
 	 * Submit the READ first for COMPARE_AND_WRITE to perform the
 	 * comparision using SGLs at cmd->t_bidi_data_sg..
 	 */
 	rc = down_interruptible(&dev->caw_sem);
 	if ((rc != 0) || signal_pending(current)) {
 		cmd->transport_complete_callback = NULL;
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 	/*
 	 * Reset cmd->data_length to individual block_size in order to not
 	 * confuse backend drivers that depend on this value matching the
 	 * size of the I/O being submitted.
 	 */
 	cmd->data_length = cmd->t_task_nolb * dev->dev_attrib.block_size;
 	ret = cmd->execute_rw(cmd, cmd->t_bidi_data_sg, cmd->t_bidi_data_nents,
 			      DMA_FROM_DEVICE);
 	if (ret) {
 		cmd->transport_complete_callback = NULL;
 		up(&dev->caw_sem);
 		return ret;
 	}
 	/*
 	 * Unlock of dev->caw_sem to occur in compare_and_write_callback()
 	 * upon MISCOMPARE, or in compare_and_write_done() upon completion
 	 * of WRITE instance user-data.
 	 */
 	return TCM_NO_SENSE;
 }
 static int
 sbc_set_prot_op_checks(u8 protect, enum target_prot_type prot_type,
 		       bool is_write, struct se_cmd *cmd)
 {
 	if (is_write) {
 		cmd->prot_op = protect ? TARGET_PROT_DOUT_PASS :
 					 TARGET_PROT_DOUT_INSERT;
 		switch (protect) {
 		case 0x0:
 		case 0x3:
 			cmd->prot_checks = 0;
 			break;
 		case 0x1:
 		case 0x5:
 			cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
 			if (prot_type == TARGET_DIF_TYPE1_PROT)
 				cmd->prot_checks |= TARGET_DIF_CHECK_REFTAG;
 			break;
 		case 0x2:
 			if (prot_type == TARGET_DIF_TYPE1_PROT)
 				cmd->prot_checks = TARGET_DIF_CHECK_REFTAG;
 			break;
 		case 0x4:
 			cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
 			break;
 		default:
 			pr_err("Unsupported protect field %d\n", protect);
 			return -EINVAL;
 		}
 	} else {
 		cmd->prot_op = protect ? TARGET_PROT_DIN_PASS :
 					 TARGET_PROT_DIN_STRIP;
 		switch (protect) {
 		case 0x0:
 		case 0x1:
 		case 0x5:
 			cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
 			if (prot_type == TARGET_DIF_TYPE1_PROT)
 				cmd->prot_checks |= TARGET_DIF_CHECK_REFTAG;
 			break;
 		case 0x2:
 			if (prot_type == TARGET_DIF_TYPE1_PROT)
 				cmd->prot_checks = TARGET_DIF_CHECK_REFTAG;
 			break;
 		case 0x3:
 			cmd->prot_checks = 0;
 			break;
 		case 0x4:
 			cmd->prot_checks = TARGET_DIF_CHECK_GUARD;
 			break;
 		default:
 			pr_err("Unsupported protect field %d\n", protect);
 			return -EINVAL;
 		}
 	}
 	return 0;
 }
 static bool
 sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb,
 	       u32 sectors, bool is_write)
 {
 	u8 protect = cdb[1] >> 5;
 	if ((!cmd->t_prot_sg || !cmd->t_prot_nents) && cmd->prot_pto)
 		return true;
 	switch (dev->dev_attrib.pi_prot_type) {
 	case TARGET_DIF_TYPE3_PROT:
 		cmd->reftag_seed = 0xffffffff;
 		break;
 	case TARGET_DIF_TYPE2_PROT:
 		if (protect)
 			return false;
 		cmd->reftag_seed = cmd->t_task_lba;
 		break;
 	case TARGET_DIF_TYPE1_PROT:
 		cmd->reftag_seed = cmd->t_task_lba;
 		break;
 	case TARGET_DIF_TYPE0_PROT:
 	default:
 		return true;
 	}
 	if (sbc_set_prot_op_checks(protect, dev->dev_attrib.pi_prot_type,
 				   is_write, cmd))
 		return false;
 	cmd->prot_type = dev->dev_attrib.pi_prot_type;
 	cmd->prot_length = dev->prot_length * sectors;
 	/**
 	 * In case protection information exists over the wire
 	 * we modify command data length to describe pure data.
 	 * The actual transfer length is data length + protection
 	 * length
 	 **/
 	if (protect)
 		cmd->data_length = sectors * dev->dev_attrib.block_size;
 	pr_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);
 	return true;
 }
 sense_reason_t
 sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
 {
 	struct se_device *dev = cmd->se_dev;
 	unsigned char *cdb = cmd->t_task_cdb;
 	unsigned int size;
 	u32 sectors = 0;
 	sense_reason_t ret;
 	switch (cdb[0]) {
 	case READ_6:
 		sectors = transport_get_sectors_6(cdb);
 		cmd->t_task_lba = transport_lba_21(cdb);
 		cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
 		cmd->execute_rw = ops->execute_rw;
 		cmd->execute_cmd = sbc_execute_rw;
 		break;
 	case READ_10:
 		sectors = transport_get_sectors_10(cdb);
 		cmd->t_task_lba = transport_lba_32(cdb);
 		if (!sbc_check_prot(dev, cmd, cdb, sectors, false))
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
 		cmd->execute_rw = ops->execute_rw;
 		cmd->execute_cmd = sbc_execute_rw;
 		break;
 	case READ_12:
 		sectors = transport_get_sectors_12(cdb);
 		cmd->t_task_lba = transport_lba_32(cdb);
 		if (!sbc_check_prot(dev, cmd, cdb, sectors, false))
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
 		cmd->execute_rw = ops->execute_rw;
 		cmd->execute_cmd = sbc_execute_rw;
 		break;
 	case READ_16:
 		sectors = transport_get_sectors_16(cdb);
 		cmd->t_task_lba = transport_lba_64(cdb);
 		if (!sbc_check_prot(dev, cmd, cdb, sectors, false))
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
 		cmd->execute_rw = ops->execute_rw;
 		cmd->execute_cmd = sbc_execute_rw;
 		break;
 	case WRITE_6:
 		sectors = transport_get_sectors_6(cdb);
 		cmd->t_task_lba = transport_lba_21(cdb);
 		cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
 		cmd->execute_rw = ops->execute_rw;
 		cmd->execute_cmd = sbc_execute_rw;
 		break;
 	case WRITE_10:
 	case WRITE_VERIFY:
 		sectors = transport_get_sectors_10(cdb);
 		cmd->t_task_lba = transport_lba_32(cdb);
 		if (!sbc_check_prot(dev, cmd, cdb, sectors, true))
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		if (cdb[1] & 0x8)
 			cmd->se_cmd_flags |= SCF_FUA;
 		cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
 		cmd->execute_rw = ops->execute_rw;
 		cmd->execute_cmd = sbc_execute_rw;
 		break;
 	case WRITE_12:
 		sectors = transport_get_sectors_12(cdb);
 		cmd->t_task_lba = transport_lba_32(cdb);
 		if (!sbc_check_prot(dev, cmd, cdb, sectors, true))
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		if (cdb[1] & 0x8)
 			cmd->se_cmd_flags |= SCF_FUA;
 		cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
 		cmd->execute_rw = ops->execute_rw;
 		cmd->execute_cmd = sbc_execute_rw;
 		break;
 	case WRITE_16:
 		sectors = transport_get_sectors_16(cdb);
 		cmd->t_task_lba = transport_lba_64(cdb);
 		if (!sbc_check_prot(dev, cmd, cdb, sectors, true))
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		if (cdb[1] & 0x8)
 			cmd->se_cmd_flags |= SCF_FUA;
 		cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
 		cmd->execute_rw = ops->execute_rw;
 		cmd->execute_cmd = sbc_execute_rw;
 		break;
 	case XDWRITEREAD_10:
 		if (cmd->data_direction != DMA_TO_DEVICE ||
 		    !(cmd->se_cmd_flags & SCF_BIDI))
 			return TCM_INVALID_CDB_FIELD;
 		sectors = transport_get_sectors_10(cdb);
 		cmd->t_task_lba = transport_lba_32(cdb);
 		cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
 		/*
 		 * Setup BIDI XOR callback to be run after I/O completion.
 		 */
 		cmd->execute_rw = ops->execute_rw;
 		cmd->execute_cmd = sbc_execute_rw;
 		cmd->transport_complete_callback = &xdreadwrite_callback;
 		if (cdb[1] & 0x8)
 			cmd->se_cmd_flags |= SCF_FUA;
 		break;
 	case VARIABLE_LENGTH_CMD:
 	{
 		u16 service_action = get_unaligned_be16(&cdb[8]);
 		switch (service_action) {
 		case XDWRITEREAD_32:
 			sectors = transport_get_sectors_32(cdb);
 			/*
 			 * Use WRITE_32 and READ_32 opcodes for the emulated
 			 * XDWRITE_READ_32 logic.
 			 */
 			cmd->t_task_lba = transport_lba_64_ext(cdb);
 			cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
 			/*
 			 * Setup BIDI XOR callback to be run during after I/O
 			 * completion.
 			 */
 			cmd->execute_rw = ops->execute_rw;
 			cmd->execute_cmd = sbc_execute_rw;
 			cmd->transport_complete_callback = &xdreadwrite_callback;
 			if (cdb[1] & 0x8)
 				cmd->se_cmd_flags |= SCF_FUA;
 			break;
 		case WRITE_SAME_32:
 			sectors = transport_get_sectors_32(cdb);
 			if (!sectors) {
 				pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not"
 				       " supported\n");
 				return TCM_INVALID_CDB_FIELD;
 			}
 			size = sbc_get_size(cmd, 1);
 			cmd->t_task_lba = get_unaligned_be64(&cdb[12]);
 			ret = sbc_setup_write_same(cmd, &cdb[10], ops);
 			if (ret)
 				return ret;
 			break;
 		default:
 			pr_err("VARIABLE_LENGTH_CMD service action"
 				" 0x%04x not supported\n", service_action);
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		}
 		break;
 	}
 	case COMPARE_AND_WRITE:
 		sectors = cdb[13];
 		/*
 		 * Currently enforce COMPARE_AND_WRITE for a single sector
 		 */
 		if (sectors > 1) {
 			pr_err("COMPARE_AND_WRITE contains NoLB: %u greater"
 			       " than 1\n", sectors);
 			return TCM_INVALID_CDB_FIELD;
 		}
 		/*
 		 * Double size because we have two buffers, note that
 		 * zero is not an error..
 		 */
 		size = 2 * sbc_get_size(cmd, sectors);
 		cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
 		cmd->t_task_nolb = sectors;
 		cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB | SCF_COMPARE_AND_WRITE;
 		cmd->execute_rw = ops->execute_rw;
 		cmd->execute_cmd = sbc_compare_and_write;
 		cmd->transport_complete_callback = compare_and_write_callback;
 		break;
 	case READ_CAPACITY:
 		size = READ_CAP_LEN;
 		cmd->execute_cmd = sbc_emulate_readcapacity;
 		break;
 	case SERVICE_ACTION_IN:
 		switch (cmd->t_task_cdb[1] & 0x1f) {
 		case SAI_READ_CAPACITY_16:
 			cmd->execute_cmd = sbc_emulate_readcapacity_16;
 			break;
 		case SAI_REPORT_REFERRALS:
 			cmd->execute_cmd = target_emulate_report_referrals;
 			break;
 		default:
 			pr_err("Unsupported SA: 0x%02x\n",
 				cmd->t_task_cdb[1] & 0x1f);
 			return TCM_INVALID_CDB_FIELD;
 		}
 		size = (cdb[10] << 24) | (cdb[11] << 16) |
 		       (cdb[12] << 8) | cdb[13];
 		break;
 	case SYNCHRONIZE_CACHE:
 	case SYNCHRONIZE_CACHE_16:
 		if (cdb[0] == SYNCHRONIZE_CACHE) {
 			sectors = transport_get_sectors_10(cdb);
 			cmd->t_task_lba = transport_lba_32(cdb);
 		} else {
 			sectors = transport_get_sectors_16(cdb);
 			cmd->t_task_lba = transport_lba_64(cdb);
 		}
 		if (ops->execute_sync_cache) {
 			cmd->execute_cmd = ops->execute_sync_cache;
 			goto check_lba;
 		}
 		size = 0;
 		cmd->execute_cmd = sbc_emulate_noop;
 		break;
 	case UNMAP:
 		if (!ops->execute_unmap)
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		size = get_unaligned_be16(&cdb[7]);
 		cmd->execute_cmd = ops->execute_unmap;
 		break;
 	case WRITE_SAME_16:
 		sectors = transport_get_sectors_16(cdb);
 		if (!sectors) {
 			pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
 			return TCM_INVALID_CDB_FIELD;
 		}
 		size = sbc_get_size(cmd, 1);
 		cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
 		ret = sbc_setup_write_same(cmd, &cdb[1], ops);
 		if (ret)
 			return ret;
 		break;
 	case WRITE_SAME:
 		sectors = transport_get_sectors_10(cdb);
 		if (!sectors) {
 			pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
 			return TCM_INVALID_CDB_FIELD;
 		}
 		size = sbc_get_size(cmd, 1);
 		cmd->t_task_lba = get_unaligned_be32(&cdb[2]);
 		/*
 		 * Follow sbcr26 with WRITE_SAME (10) and check for the existence
 		 * of byte 1 bit 3 UNMAP instead of original reserved field
 		 */
 		ret = sbc_setup_write_same(cmd, &cdb[1], ops);
 		if (ret)
 			return ret;
 		break;
 	case VERIFY:
 		size = 0;
 		sectors = transport_get_sectors_10(cdb);
 		cmd->t_task_lba = transport_lba_32(cdb);
 		cmd->execute_cmd = sbc_emulate_noop;
 		goto check_lba;
 	case REZERO_UNIT:
 	case SEEK_6:
 	case SEEK_10:
 		/*
 		 * There are still clients out there which use these old SCSI-2
 		 * commands. This mainly happens when running VMs with legacy
 		 * guest systems, connected via SCSI command pass-through to
 		 * iSCSI targets. Make them happy and return status GOOD.
 		 */
 		size = 0;
 		cmd->execute_cmd = sbc_emulate_noop;
 		break;
 	default:
 		ret = spc_parse_cdb(cmd, &size);
 		if (ret)
 			return ret;
 	}
 	/* reject any command that we don't have a handler for */
 	if (!cmd->execute_cmd)
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) {
 		unsigned long long end_lba;
-		if (sectors > dev->dev_attrib.fabric_max_sectors) {
-			printk_ratelimited(KERN_ERR "SCSI OP %02xh with too"
-				" big sectors %u exceeds fabric_max_sectors:"
-				" %u\n", cdb[0], sectors,
-				dev->dev_attrib.fabric_max_sectors);
-			return TCM_INVALID_CDB_FIELD;
-		}
-		if (sectors > dev->dev_attrib.hw_max_sectors) {
-			printk_ratelimited(KERN_ERR "SCSI OP %02xh with too"
-				" big sectors %u exceeds backend hw_max_sectors:"
-				" %u\n", cdb[0], sectors,
-				dev->dev_attrib.hw_max_sectors);
-			return TCM_INVALID_CDB_FIELD;
-		}
 check_lba:
 		end_lba = dev->transport->get_blocks(dev) + 1;
 		if (cmd->t_task_lba + sectors > end_lba) {
 			pr_err("cmd exceeds last lba %llu "
 				"(lba %llu, sectors %u)\n",
 				end_lba, cmd->t_task_lba, sectors);
 			return TCM_ADDRESS_OUT_OF_RANGE;
 		}
 		if (!(cmd->se_cmd_flags & SCF_COMPARE_AND_WRITE))
 			size = sbc_get_size(cmd, sectors);
 	}
 	return target_cmd_size_check(cmd, size);
 }
 EXPORT_SYMBOL(sbc_parse_cdb);
 u32 sbc_get_device_type(struct se_device *dev)
 {
 	return TYPE_DISK;
 }
 EXPORT_SYMBOL(sbc_get_device_type);
 sense_reason_t
 sbc_execute_unmap(struct se_cmd *cmd,
 	sense_reason_t (*do_unmap_fn)(struct se_cmd *, void *,
 				      sector_t, sector_t),
 	void *priv)
 {
 	struct se_device *dev = cmd->se_dev;
 	unsigned char *buf, *ptr = NULL;
 	sector_t lba;
 	int size;
 	u32 range;
 	sense_reason_t ret = 0;
 	int dl, bd_dl;
 	/* 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_PARAMETER_LIST_LENGTH_ERROR;
 	}
 	buf = transport_kmap_data_sg(cmd);
 	if (!buf)
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	dl = get_unaligned_be16(&buf[0]);
 	bd_dl = get_unaligned_be16(&buf[2]);
 	size = cmd->data_length - 8;
 	if (bd_dl > size)
 		pr_warn("UNMAP parameter list length %u too small, ignoring bd_dl %u\n",
 			cmd->data_length, bd_dl);
 	else
 		size = bd_dl;
 	if (size / 16 > dev->dev_attrib.max_unmap_block_desc_count) {
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto err;
 	}
 	/* First UNMAP block descriptor starts at 8 byte offset */
 	ptr = &buf[8];
 	pr_debug("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]);
 		pr_debug("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;
 			goto err;
 		}
 		if (lba + range > dev->transport->get_blocks(dev) + 1) {
 			ret = TCM_ADDRESS_OUT_OF_RANGE;
 			goto err;
 		}
 		ret = do_unmap_fn(cmd, priv, lba, range);
 		if (ret)
 			goto err;
 		ptr += 16;
 		size -= 16;
 	}
 err:
 	transport_kunmap_data_sg(cmd);
 	if (!ret)
 		target_complete_cmd(cmd, GOOD);
 	return ret;
 }
 EXPORT_SYMBOL(sbc_execute_unmap);
 void
 sbc_dif_generate(struct se_cmd *cmd)
 {
 	struct se_device *dev = cmd->se_dev;
 	struct se_dif_v1_tuple *sdt;
 	struct scatterlist *dsg, *psg = cmd->t_prot_sg;
 	sector_t sector = cmd->t_task_lba;
 	void *daddr, *paddr;
 	int i, j, offset = 0;
 	for_each_sg(cmd->t_data_sg, dsg, cmd->t_data_nents, i) {
 		daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
 		paddr = kmap_atomic(sg_page(psg)) + psg->offset;
 		for (j = 0; j < dsg->length; j += dev->dev_attrib.block_size) {
 			if (offset >= psg->length) {
 				kunmap_atomic(paddr);
 				psg = sg_next(psg);
 				paddr = kmap_atomic(sg_page(psg)) + psg->offset;
 				offset = 0;
 			}
 			sdt = paddr + offset;
 			sdt->guard_tag = cpu_to_be16(crc_t10dif(daddr + j,
 						dev->dev_attrib.block_size));
 			if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE1_PROT)
 				sdt->ref_tag = cpu_to_be32(sector & 0xffffffff);
 			sdt->app_tag = 0;
 			pr_debug("DIF WRITE INSERT 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));
 			sector++;
 			offset += sizeof(struct se_dif_v1_tuple);
 		}
 		kunmap_atomic(paddr);
 		kunmap_atomic(daddr);
 	}
 }
 static sense_reason_t
 sbc_dif_v1_verify(struct se_device *dev, struct se_dif_v1_tuple *sdt,
 		  const void *p, sector_t sector, unsigned int ei_lba)
 {
 	int block_size = dev->dev_attrib.block_size;
 	__be16 csum;
 	csum = cpu_to_be16(crc_t10dif(p, block_size));
 	if (sdt->guard_tag != csum) {
 		pr_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));
 		return TCM_LOGICAL_BLOCK_GUARD_CHECK_FAILED;
 	}
 	if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE1_PROT &&
 	    be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
 		pr_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));
 		return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED;
 	}
 	if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE2_PROT &&
 	    be32_to_cpu(sdt->ref_tag) != ei_lba) {
 		pr_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);
 		return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED;
 	}
 	return 0;
 }
 static void
 sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read,
 		  struct scatterlist *sg, int sg_off)
 {
 	struct se_device *dev = cmd->se_dev;
 	struct scatterlist *psg;
 	void *paddr, *addr;
 	unsigned int i, len, left;
 	unsigned int offset = sg_off;
 	left = sectors * dev->prot_length;
 	for_each_sg(cmd->t_prot_sg, psg, cmd->t_prot_nents, i) {
 		unsigned int psg_len, copied = 0;
 		paddr = kmap_atomic(sg_page(psg)) + psg->offset;
 		psg_len = min(left, psg->length);
 		while (psg_len) {
 			len = min(psg_len, sg->length - offset);
 			addr = kmap_atomic(sg_page(sg)) + sg->offset + offset;
 			if (read)
 				memcpy(paddr + copied, addr, len);
 			else
 				memcpy(addr, paddr + copied, len);
 			left -= len;
 			offset += len;
 			copied += len;
 			psg_len -= len;
 			if (offset >= sg->length) {
 				sg = sg_next(sg);
 				offset = 0;
 			}
 			kunmap_atomic(addr);
 		}
 		kunmap_atomic(paddr);
 	}
 }
 sense_reason_t
 sbc_dif_verify_write(struct se_cmd *cmd, sector_t start, unsigned int sectors,
 		     unsigned int ei_lba, struct scatterlist *sg, int sg_off)
 {
 	struct se_device *dev = cmd->se_dev;
 	struct se_dif_v1_tuple *sdt;
 	struct scatterlist *dsg, *psg = cmd->t_prot_sg;
 	sector_t sector = start;
 	void *daddr, *paddr;
 	int i, j, offset = 0;
 	sense_reason_t rc;
 	for_each_sg(cmd->t_data_sg, dsg, cmd->t_data_nents, i) {
 		daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
 		paddr = kmap_atomic(sg_page(psg)) + psg->offset;
 		for (j = 0; j < dsg->length; j += dev->dev_attrib.block_size) {
 			if (offset >= psg->length) {
 				kunmap_atomic(paddr);
 				psg = sg_next(psg);
 				paddr = kmap_atomic(sg_page(psg)) + psg->offset;
 				offset = 0;
 			}
 			sdt = paddr + offset;
 			pr_debug("DIF WRITE sector: %llu guard_tag: 0x%04x"
 				 " app_tag: 0x%04x ref_tag: %u\n",
 				 (unsigned long long)sector, sdt->guard_tag,
 				 sdt->app_tag, be32_to_cpu(sdt->ref_tag));
 			rc = sbc_dif_v1_verify(dev, sdt, daddr + j, sector,
 					       ei_lba);
 			if (rc) {
 				kunmap_atomic(paddr);
 				kunmap_atomic(daddr);
 				cmd->bad_sector = sector;
 				return rc;
 			}
 			sector++;
 			ei_lba++;
 			offset += sizeof(struct se_dif_v1_tuple);
 		}
 		kunmap_atomic(paddr);
 		kunmap_atomic(daddr);
 	}
 	sbc_dif_copy_prot(cmd, sectors, false, sg, sg_off);
 	return 0;
 }
 EXPORT_SYMBOL(sbc_dif_verify_write);
 static sense_reason_t
 __sbc_dif_verify_read(struct se_cmd *cmd, sector_t start, unsigned int sectors,
 		      unsigned int ei_lba, struct scatterlist *sg, int sg_off)
 {
 	struct se_device *dev = cmd->se_dev;
 	struct se_dif_v1_tuple *sdt;
 	struct scatterlist *dsg, *psg = sg;
 	sector_t sector = start;
 	void *daddr, *paddr;
 	int i, j, offset = sg_off;
 	sense_reason_t rc;
 	for_each_sg(cmd->t_data_sg, dsg, cmd->t_data_nents, i) {
 		daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;
 		paddr = kmap_atomic(sg_page(psg)) + sg->offset;
 		for (j = 0; j < dsg->length; j += dev->dev_attrib.block_size) {
 			if (offset >= psg->length) {
 				kunmap_atomic(paddr);
 				psg = sg_next(psg);
 				paddr = kmap_atomic(sg_page(psg)) + psg->offset;
 				offset = 0;
 			}
 			sdt = paddr + offset;
 			pr_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));
 			if (sdt->app_tag == cpu_to_be16(0xffff)) {
 				sector++;
 				offset += sizeof(struct se_dif_v1_tuple);
 				continue;
 			}
 			rc = sbc_dif_v1_verify(dev, sdt, daddr + j, sector,
 					       ei_lba);
 			if (rc) {
 				kunmap_atomic(paddr);
 				kunmap_atomic(daddr);
 				cmd->bad_sector = sector;
 				return rc;
 			}
 			sector++;
 			ei_lba++;
 			offset += sizeof(struct se_dif_v1_tuple);
 		}
 		kunmap_atomic(paddr);
 		kunmap_atomic(daddr);
 	}
 	return 0;
 }
 sense_reason_t
 sbc_dif_read_strip(struct se_cmd *cmd)
 {
 	struct se_device *dev = cmd->se_dev;
 	u32 sectors = cmd->prot_length / dev->prot_length;
 	return __sbc_dif_verify_read(cmd, cmd->t_task_lba, sectors, 0,
 				     cmd->t_prot_sg, 0);
 }
 sense_reason_t
 sbc_dif_verify_read(struct se_cmd *cmd, sector_t start, unsigned int sectors,
 		    unsigned int ei_lba, struct scatterlist *sg, int sg_off)
 {
 	sense_reason_t rc;
 	rc = __sbc_dif_verify_read(cmd, start, sectors, ei_lba, sg, sg_off);
 	if (rc)
 		return rc;
 	sbc_dif_copy_prot(cmd, sectors, true, sg, sg_off);
 	return 0;
 }
 EXPORT_SYMBOL(sbc_dif_verify_read);

drivers/target/target_core_spc.c

Diff comments View file @ 82bc9d0

 /*
  * SCSI Primary Commands (SPC) parsing and emulation.
  *
  * (c) Copyright 2002-2013 Datera, Inc.
  *
  * Nicholas A. Bellinger <nab@kernel.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <asm/unaligned.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_tcq.h>
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
 #include "target_core_internal.h"
 #include "target_core_alua.h"
 #include "target_core_pr.h"
 #include "target_core_ua.h"
 #include "target_core_xcopy.h"
 static void spc_fill_alua_data(struct se_port *port, unsigned char *buf)
 {
 	struct t10_alua_tg_pt_gp *tg_pt_gp;
 	struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
 	/*
 	 * Set SCCS for MAINTENANCE_IN + REPORT_TARGET_PORT_GROUPS.
 	 */
 	buf[5]	= 0x80;
 	/*
 	 * Set TPGS field for explicit and/or implicit ALUA access type
 	 * and opteration.
 	 *
 	 * See spc4r17 section 6.4.2 Table 135
 	 */
 	if (!port)
 		return;
 	tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
 	if (!tg_pt_gp_mem)
 		return;
 	spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 	tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
 	if (tg_pt_gp)
 		buf[5] |= tg_pt_gp->tg_pt_gp_alua_access_type;
 	spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 }
 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;
 	struct se_session *sess = cmd->se_sess;
 	/* Set RMB (removable media) for tape devices */
 	if (dev->transport->get_device_type(dev) == TYPE_TAPE)
 		buf[1] = 0x80;
 	buf[2] = 0x05; /* SPC-3 */
 	/*
 	 * NORMACA and HISUP = 0, RESPONSE DATA FORMAT = 2
 	 *
 	 * SPC4 says:
 	 *   A RESPONSE DATA FORMAT field set to 2h indicates that the
 	 *   standard INQUIRY data is in the format defined in this
 	 *   standard. Response data format values less than 2h are
 	 *   obsolete. Response data format values greater than 2h are
 	 *   reserved.
 	 */
 	buf[3] = 2;
 	/*
 	 * Enable SCCS and TPGS fields for Emulated ALUA
 	 */
 	spc_fill_alua_data(lun->lun_sep, buf);
 	/*
 	 * Set Third-Party Copy (3PC) bit to indicate support for EXTENDED_COPY
 	 */
 	if (dev->dev_attrib.emulate_3pc)
 		buf[5] |= 0x8;
 	/*
 	 * Set Protection (PROTECT) bit when DIF has been enabled on the
 	 * device, and the transport supports VERIFY + PASS.
 	 */
 	if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
 		if (dev->dev_attrib.pi_prot_type)
 			buf[5] |= 0x1;
 	}
 	buf[7] = 0x2; /* CmdQue=1 */
 	memcpy(&buf[8], "LIO-ORG ", 8);
 	memset(&buf[16], 0x20, 16);
 	memcpy(&buf[16], dev->t10_wwn.model,
 	       min_t(size_t, strlen(dev->t10_wwn.model), 16));
 	memcpy(&buf[32], dev->t10_wwn.revision,
 	       min_t(size_t, strlen(dev->t10_wwn.revision), 4));
 	buf[4] = 31; /* Set additional length to 31 */
 	return 0;
 }
 EXPORT_SYMBOL(spc_emulate_inquiry_std);
 /* unit serial number */
 static sense_reason_t
 spc_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf)
 {
 	struct se_device *dev = cmd->se_dev;
 	u16 len;
 	if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
 		len = sprintf(&buf[4], "%s", dev->t10_wwn.unit_serial);
 		len++; /* Extra Byte for NULL Terminator */
 		buf[3] = len;
 	}
 	return 0;
 }
 void spc_parse_naa_6h_vendor_specific(struct se_device *dev,
 				      unsigned char *buf)
 {
 	unsigned char *p = &dev->t10_wwn.unit_serial[0];
 	int cnt;
 	bool next = true;
 	/*
 	 * Generate up to 36 bits of VENDOR SPECIFIC IDENTIFIER starting on
 	 * byte 3 bit 3-0 for NAA IEEE Registered Extended DESIGNATOR field
 	 * format, followed by 64 bits of VENDOR SPECIFIC IDENTIFIER EXTENSION
 	 * to complete the payload.  These are based from VPD=0x80 PRODUCT SERIAL
 	 * NUMBER set via vpd_unit_serial in target_core_configfs.c to ensure
 	 * per device uniqeness.
 	 */
 	for (cnt = 0; *p && cnt < 13; p++) {
 		int val = hex_to_bin(*p);
 		if (val < 0)
 			continue;
 		if (next) {
 			next = false;
 			buf[cnt++] |= val;
 		} else {
 			next = true;
 			buf[cnt] = val << 4;
 		}
 	}
 }
 /*
  * Device identification VPD, for a complete list of
  * DESIGNATOR TYPEs see spc4r17 Table 459.
  */
 sense_reason_t
 spc_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)
 {
 	struct se_device *dev = cmd->se_dev;
 	struct se_lun *lun = cmd->se_lun;
 	struct se_port *port = NULL;
 	struct se_portal_group *tpg = NULL;
 	struct t10_alua_lu_gp_member *lu_gp_mem;
 	struct t10_alua_tg_pt_gp *tg_pt_gp;
 	struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
 	unsigned char *prod = &dev->t10_wwn.model[0];
 	u32 prod_len;
 	u32 unit_serial_len, off = 0;
 	u16 len = 0, id_len;
 	off = 4;
 	/*
 	 * NAA IEEE Registered Extended Assigned designator format, see
 	 * spc4r17 section 7.7.3.6.5
 	 *
 	 * We depend upon a target_core_mod/ConfigFS provided
 	 * /sys/kernel/config/target/core/$HBA/$DEV/wwn/vpd_unit_serial
 	 * value in order to return the NAA id.
 	 */
 	if (!(dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL))
 		goto check_t10_vend_desc;
 	/* CODE SET == Binary */
 	buf[off++] = 0x1;
 	/* Set ASSOCIATION == addressed logical unit: 0)b */
 	buf[off] = 0x00;
 	/* Identifier/Designator type == NAA identifier */
 	buf[off++] |= 0x3;
 	off++;
 	/* Identifier/Designator length */
 	buf[off++] = 0x10;
 	/*
 	 * Start NAA IEEE Registered Extended Identifier/Designator
 	 */
 	buf[off++] = (0x6 << 4);
 	/*
 	 * Use OpenFabrics IEEE Company ID: 00 14 05
 	 */
 	buf[off++] = 0x01;
 	buf[off++] = 0x40;
 	buf[off] = (0x5 << 4);
 	/*
 	 * Return ConfigFS Unit Serial Number information for
 	 * VENDOR_SPECIFIC_IDENTIFIER and
 	 * VENDOR_SPECIFIC_IDENTIFIER_EXTENTION
 	 */
 	spc_parse_naa_6h_vendor_specific(dev, &buf[off]);
 	len = 20;
 	off = (len + 4);
 check_t10_vend_desc:
 	/*
 	 * T10 Vendor Identifier Page, see spc4r17 section 7.7.3.4
 	 */
 	id_len = 8; /* For Vendor field */
 	prod_len = 4; /* For VPD Header */
 	prod_len += 8; /* For Vendor field */
 	prod_len += strlen(prod);
 	prod_len++; /* For : */
 	if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
 		unit_serial_len = strlen(&dev->t10_wwn.unit_serial[0]);
 		unit_serial_len++; /* For NULL Terminator */
 		id_len += sprintf(&buf[off+12], "%s:%s", prod,
 				&dev->t10_wwn.unit_serial[0]);
 	}
 	buf[off] = 0x2; /* ASCII */
 	buf[off+1] = 0x1; /* T10 Vendor ID */
 	buf[off+2] = 0x0;
 	memcpy(&buf[off+4], "LIO-ORG", 8);
 	/* Extra Byte for NULL Terminator */
 	id_len++;
 	/* Identifier Length */
 	buf[off+3] = id_len;
 	/* Header size for Designation descriptor */
 	len += (id_len + 4);
 	off += (id_len + 4);
 	/*
 	 * struct se_port is only set for INQUIRY VPD=1 through $FABRIC_MOD
 	 */
 	port = lun->lun_sep;
 	if (port) {
 		struct t10_alua_lu_gp *lu_gp;
 		u32 padding, scsi_name_len, scsi_target_len;
 		u16 lu_gp_id = 0;
 		u16 tg_pt_gp_id = 0;
 		u16 tpgt;
 		tpg = port->sep_tpg;
 		/*
 		 * Relative target port identifer, see spc4r17
 		 * section 7.7.3.7
 		 *
 		 * Get the PROTOCOL IDENTIFIER as defined by spc4r17
 		 * section 7.5.1 Table 362
 		 */
 		buf[off] =
 			(tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4);
 		buf[off++] |= 0x1; /* CODE SET == Binary */
 		buf[off] = 0x80; /* Set PIV=1 */
 		/* Set ASSOCIATION == target port: 01b */
 		buf[off] |= 0x10;
 		/* DESIGNATOR TYPE == Relative target port identifer */
 		buf[off++] |= 0x4;
 		off++; /* Skip over Reserved */
 		buf[off++] = 4; /* DESIGNATOR LENGTH */
 		/* Skip over Obsolete field in RTPI payload
 		 * in Table 472 */
 		off += 2;
 		buf[off++] = ((port->sep_rtpi >> 8) & 0xff);
 		buf[off++] = (port->sep_rtpi & 0xff);
 		len += 8; /* Header size + Designation descriptor */
 		/*
 		 * Target port group identifier, see spc4r17
 		 * section 7.7.3.8
 		 *
 		 * Get the PROTOCOL IDENTIFIER as defined by spc4r17
 		 * section 7.5.1 Table 362
 		 */
 		tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
 		if (!tg_pt_gp_mem)
 			goto check_lu_gp;
 		spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 		tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
 		if (!tg_pt_gp) {
 			spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 			goto check_lu_gp;
 		}
 		tg_pt_gp_id = tg_pt_gp->tg_pt_gp_id;
 		spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 		buf[off] =
 			(tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4);
 		buf[off++] |= 0x1; /* CODE SET == Binary */
 		buf[off] = 0x80; /* Set PIV=1 */
 		/* Set ASSOCIATION == target port: 01b */
 		buf[off] |= 0x10;
 		/* DESIGNATOR TYPE == Target port group identifier */
 		buf[off++] |= 0x5;
 		off++; /* Skip over Reserved */
 		buf[off++] = 4; /* DESIGNATOR LENGTH */
 		off += 2; /* Skip over Reserved Field */
 		buf[off++] = ((tg_pt_gp_id >> 8) & 0xff);
 		buf[off++] = (tg_pt_gp_id & 0xff);
 		len += 8; /* Header size + Designation descriptor */
 		/*
 		 * Logical Unit Group identifier, see spc4r17
 		 * section 7.7.3.8
 		 */
 check_lu_gp:
 		lu_gp_mem = dev->dev_alua_lu_gp_mem;
 		if (!lu_gp_mem)
 			goto check_scsi_name;
 		spin_lock(&lu_gp_mem->lu_gp_mem_lock);
 		lu_gp = lu_gp_mem->lu_gp;
 		if (!lu_gp) {
 			spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
 			goto check_scsi_name;
 		}
 		lu_gp_id = lu_gp->lu_gp_id;
 		spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
 		buf[off++] |= 0x1; /* CODE SET == Binary */
 		/* DESIGNATOR TYPE == Logical Unit Group identifier */
 		buf[off++] |= 0x6;
 		off++; /* Skip over Reserved */
 		buf[off++] = 4; /* DESIGNATOR LENGTH */
 		off += 2; /* Skip over Reserved Field */
 		buf[off++] = ((lu_gp_id >> 8) & 0xff);
 		buf[off++] = (lu_gp_id & 0xff);
 		len += 8; /* Header size + Designation descriptor */
 		/*
 		 * SCSI name string designator, see spc4r17
 		 * section 7.7.3.11
 		 *
 		 * Get the PROTOCOL IDENTIFIER as defined by spc4r17
 		 * section 7.5.1 Table 362
 		 */
 check_scsi_name:
 		buf[off] =
 			(tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4);
 		buf[off++] |= 0x3; /* CODE SET == UTF-8 */
 		buf[off] = 0x80; /* Set PIV=1 */
 		/* Set ASSOCIATION == target port: 01b */
 		buf[off] |= 0x10;
 		/* DESIGNATOR TYPE == SCSI name string */
 		buf[off++] |= 0x8;
 		off += 2; /* Skip over Reserved and length */
 		/*
 		 * SCSI name string identifer containing, $FABRIC_MOD
 		 * dependent information.  For LIO-Target and iSCSI
 		 * Target Port, this means "<iSCSI name>,t,0x<TPGT> in
 		 * UTF-8 encoding.
 		 */
 		tpgt = tpg->se_tpg_tfo->tpg_get_tag(tpg);
 		scsi_name_len = sprintf(&buf[off], "%s,t,0x%04x",
 					tpg->se_tpg_tfo->tpg_get_wwn(tpg), tpgt);
 		scsi_name_len += 1 /* Include  NULL terminator */;
 		/*
 		 * The null-terminated, null-padded (see 4.4.2) SCSI
 		 * NAME STRING field contains a UTF-8 format string.
 		 * The number of bytes in the SCSI NAME STRING field
 		 * (i.e., the value in the DESIGNATOR LENGTH field)
 		 * shall be no larger than 256 and shall be a multiple
 		 * of four.
 		 */
 		padding = ((-scsi_name_len) & 3);
 		if (padding)
 			scsi_name_len += padding;
 		if (scsi_name_len > 256)
 			scsi_name_len = 256;
 		buf[off-1] = scsi_name_len;
 		off += scsi_name_len;
 		/* Header size + Designation descriptor */
 		len += (scsi_name_len + 4);
 		/*
 		 * Target device designator
 		 */
 		buf[off] =
 			(tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4);
 		buf[off++] |= 0x3; /* CODE SET == UTF-8 */
 		buf[off] = 0x80; /* Set PIV=1 */
 		/* Set ASSOCIATION == target device: 10b */
 		buf[off] |= 0x20;
 		/* DESIGNATOR TYPE == SCSI name string */
 		buf[off++] |= 0x8;
 		off += 2; /* Skip over Reserved and length */
 		/*
 		 * SCSI name string identifer containing, $FABRIC_MOD
 		 * dependent information.  For LIO-Target and iSCSI
 		 * Target Port, this means "<iSCSI name>" in
 		 * UTF-8 encoding.
 		 */
 		scsi_target_len = sprintf(&buf[off], "%s",
 					  tpg->se_tpg_tfo->tpg_get_wwn(tpg));
 		scsi_target_len += 1 /* Include  NULL terminator */;
 		/*
 		 * The null-terminated, null-padded (see 4.4.2) SCSI
 		 * NAME STRING field contains a UTF-8 format string.
 		 * The number of bytes in the SCSI NAME STRING field
 		 * (i.e., the value in the DESIGNATOR LENGTH field)
 		 * shall be no larger than 256 and shall be a multiple
 		 * of four.
 		 */
 		padding = ((-scsi_target_len) & 3);
 		if (padding)
 			scsi_target_len += padding;
 		if (scsi_target_len > 256)
 			scsi_target_len = 256;
 		buf[off-1] = scsi_target_len;
 		off += scsi_target_len;
 		/* Header size + Designation descriptor */
 		len += (scsi_target_len + 4);
 	}
 	buf[2] = ((len >> 8) & 0xff);
 	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;
 	struct se_session *sess = cmd->se_sess;
 	buf[3] = 0x3c;
 	/*
 	 * Set GRD_CHK + REF_CHK for TYPE1 protection, or GRD_CHK
 	 * only for TYPE3 protection.
 	 */
 	if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
 		if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE1_PROT)
 			buf[4] = 0x5;
 		else if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE3_PROT)
 			buf[4] = 0x4;
 	}
 	/* Set HEADSUP, ORDSUP, SIMPSUP */
 	buf[5] = 0x07;
 	/* If WriteCache emulation is enabled, set V_SUP */
 	if (spc_check_dev_wce(dev))
 		buf[6] = 0x01;
 	/* If an LBA map is present set R_SUP */
 	spin_lock(&cmd->se_dev->t10_alua.lba_map_lock);
 	if (!list_empty(&dev->t10_alua.lba_map_list))
 		buf[8] = 0x10;
 	spin_unlock(&cmd->se_dev->t10_alua.lba_map_lock);
 	return 0;
 }
 /* Block Limits VPD page */
 static sense_reason_t
 spc_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)
 {
 	struct se_device *dev = cmd->se_dev;
-	u32 max_sectors;
 	int have_tp = 0;
 	int opt, min;
 	/*
 	 * Following spc3r22 section 6.5.3 Block Limits VPD page, when
 	 * emulate_tpu=1 or emulate_tpws=1 we will be expect a
 	 * different page length for Thin Provisioning.
 	 */
 	if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws)
 		have_tp = 1;
 	buf[0] = dev->transport->get_device_type(dev);
 	buf[3] = have_tp ? 0x3c : 0x10;
 	/* Set WSNZ to 1 */
 	buf[4] = 0x01;
 	/*
 	 * Set MAXIMUM COMPARE AND WRITE LENGTH
 	 */
 	if (dev->dev_attrib.emulate_caw)
 		buf[5] = 0x01;
 	/*
 	 * Set OPTIMAL TRANSFER LENGTH GRANULARITY
 	 */
 	if (dev->transport->get_io_min && (min = dev->transport->get_io_min(dev)))
 		put_unaligned_be16(min / dev->dev_attrib.block_size, &buf[6]);
 	else
 		put_unaligned_be16(1, &buf[6]);
 	/*
 	 * Set MAXIMUM TRANSFER LENGTH
 	 */
-	max_sectors = min(dev->dev_attrib.fabric_max_sectors,
+	put_unaligned_be32(dev->dev_attrib.hw_max_sectors, &buf[8]);
-			  dev->dev_attrib.hw_max_sectors);
-	put_unaligned_be32(max_sectors, &buf[8]);
 	/*
 	 * Set OPTIMAL TRANSFER LENGTH
 	 */
 	if (dev->transport->get_io_opt && (opt = dev->transport->get_io_opt(dev)))
 		put_unaligned_be32(opt / dev->dev_attrib.block_size, &buf[12]);
 	else
 		put_unaligned_be32(dev->dev_attrib.optimal_sectors, &buf[12]);
 	/*
 	 * Exit now if we don't support TP.
 	 */
 	if (!have_tp)
 		goto max_write_same;
 	/*
 	 * Set MAXIMUM UNMAP LBA COUNT
 	 */
 	put_unaligned_be32(dev->dev_attrib.max_unmap_lba_count, &buf[20]);
 	/*
 	 * Set MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT
 	 */
 	put_unaligned_be32(dev->dev_attrib.max_unmap_block_desc_count,
 			   &buf[24]);
 	/*
 	 * Set OPTIMAL UNMAP GRANULARITY
 	 */
 	put_unaligned_be32(dev->dev_attrib.unmap_granularity, &buf[28]);
 	/*
 	 * UNMAP GRANULARITY ALIGNMENT
 	 */
 	put_unaligned_be32(dev->dev_attrib.unmap_granularity_alignment,
 			   &buf[32]);
 	if (dev->dev_attrib.unmap_granularity_alignment != 0)
 		buf[32] |= 0x80; /* Set the UGAVALID bit */
 	/*
 	 * MAXIMUM WRITE SAME LENGTH
 	 */
 max_write_same:
 	put_unaligned_be64(dev->dev_attrib.max_write_same_len, &buf[36]);
 	return 0;
 }
 /* Block Device Characteristics VPD page */
 static sense_reason_t
 spc_emulate_evpd_b1(struct se_cmd *cmd, unsigned char *buf)
 {
 	struct se_device *dev = cmd->se_dev;
 	buf[0] = dev->transport->get_device_type(dev);
 	buf[3] = 0x3c;
 	buf[5] = dev->dev_attrib.is_nonrot ? 1 : 0;
 	return 0;
 }
 /* Thin Provisioning VPD */
 static sense_reason_t
 spc_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf)
 {
 	struct se_device *dev = cmd->se_dev;
 	/*
 	 * From spc3r22 section 6.5.4 Thin Provisioning VPD page:
 	 *
 	 * The PAGE LENGTH field is defined in SPC-4. If the DP bit is set to
 	 * zero, then the page length shall be set to 0004h.  If the DP bit
 	 * is set to one, then the page length shall be set to the value
 	 * defined in table 162.
 	 */
 	buf[0] = dev->transport->get_device_type(dev);
 	/*
 	 * Set Hardcoded length mentioned above for DP=0
 	 */
 	put_unaligned_be16(0x0004, &buf[2]);
 	/*
 	 * The THRESHOLD EXPONENT field indicates the threshold set size in
 	 * LBAs as a power of 2 (i.e., the threshold set size is equal to
 	 * 2(threshold exponent)).
 	 *
 	 * Note that this is currently set to 0x00 as mkp says it will be
 	 * changing again.  We can enable this once it has settled in T10
 	 * and is actually used by Linux/SCSI ML code.
 	 */
 	buf[4] = 0x00;
 	/*
 	 * A TPU bit set to one indicates that the device server supports
 	 * the UNMAP command (see 5.25). A TPU bit set to zero indicates
 	 * that the device server does not support the UNMAP command.
 	 */
 	if (dev->dev_attrib.emulate_tpu != 0)
 		buf[5] = 0x80;
 	/*
 	 * A TPWS bit set to one indicates that the device server supports
 	 * the use of the WRITE SAME (16) command (see 5.42) to unmap LBAs.
 	 * A TPWS bit set to zero indicates that the device server does not
 	 * support the use of the WRITE SAME (16) command to unmap LBAs.
 	 */
 	if (dev->dev_attrib.emulate_tpws != 0)
 		buf[5] |= 0x40;
 	return 0;
 }
 /* Referrals VPD page */
 static sense_reason_t
 spc_emulate_evpd_b3(struct se_cmd *cmd, unsigned char *buf)
 {
 	struct se_device *dev = cmd->se_dev;
 	buf[0] = dev->transport->get_device_type(dev);
 	buf[3] = 0x0c;
 	put_unaligned_be32(dev->t10_alua.lba_map_segment_size, &buf[8]);
 	put_unaligned_be32(dev->t10_alua.lba_map_segment_multiplier, &buf[12]);
 	return 0;
 }
 static sense_reason_t
 spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf);
 static struct {
 	uint8_t		page;
 	sense_reason_t	(*emulate)(struct se_cmd *, unsigned char *);
 } evpd_handlers[] = {
 	{ .page = 0x00, .emulate = spc_emulate_evpd_00 },
 	{ .page = 0x80, .emulate = spc_emulate_evpd_80 },
 	{ .page = 0x83, .emulate = spc_emulate_evpd_83 },
 	{ .page = 0x86, .emulate = spc_emulate_evpd_86 },
 	{ .page = 0xb0, .emulate = spc_emulate_evpd_b0 },
 	{ .page = 0xb1, .emulate = spc_emulate_evpd_b1 },
 	{ .page = 0xb2, .emulate = spc_emulate_evpd_b2 },
 	{ .page = 0xb3, .emulate = spc_emulate_evpd_b3 },
 };
 /* supported vital product data pages */
 static sense_reason_t
 spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf)
 {
 	int p;
 	/*
 	 * Only report the INQUIRY EVPD=1 pages after a valid NAA
 	 * Registered Extended LUN WWN has been set via ConfigFS
 	 * during device creation/restart.
 	 */
 	if (cmd->se_dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
 		buf[3] = ARRAY_SIZE(evpd_handlers);
 		for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p)
 			buf[p + 4] = evpd_handlers[p].page;
 	}
 	return 0;
 }
 static sense_reason_t
 spc_emulate_inquiry(struct se_cmd *cmd)
 {
 	struct se_device *dev = cmd->se_dev;
 	struct se_portal_group *tpg = cmd->se_lun->lun_sep->sep_tpg;
 	unsigned char *rbuf;
 	unsigned char *cdb = cmd->t_task_cdb;
 	unsigned char *buf;
 	sense_reason_t ret;
 	int p;
 	int len = 0;
 	buf = kzalloc(SE_INQUIRY_BUF, GFP_KERNEL);
 	if (!buf) {
 		pr_err("Unable to allocate response buffer for INQUIRY\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 	if (dev == tpg->tpg_virt_lun0.lun_se_dev)
 		buf[0] = 0x3f; /* Not connected */
 	else
 		buf[0] = dev->transport->get_device_type(dev);
 	if (!(cdb[1] & 0x1)) {
 		if (cdb[2]) {
 			pr_err("INQUIRY with EVPD==0 but PAGE CODE=%02x\n",
 			       cdb[2]);
 			ret = TCM_INVALID_CDB_FIELD;
 			goto out;
 		}
 		ret = spc_emulate_inquiry_std(cmd, buf);
 		len = buf[4] + 5;
 		goto out;
 	}
 	for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p) {
 		if (cdb[2] == evpd_handlers[p].page) {
 			buf[1] = cdb[2];
 			ret = evpd_handlers[p].emulate(cmd, buf);
 			len = get_unaligned_be16(&buf[2]) + 4;
 			goto out;
 		}
 	}
 	pr_err("Unknown VPD Code: 0x%02x\n", cdb[2]);
 	ret = TCM_INVALID_CDB_FIELD;
 out:
 	rbuf = transport_kmap_data_sg(cmd);
 	if (rbuf) {
 		memcpy(rbuf, buf, min_t(u32, SE_INQUIRY_BUF, cmd->data_length));
 		transport_kunmap_data_sg(cmd);
 	}
 	kfree(buf);
 	if (!ret)
 		target_complete_cmd_with_length(cmd, GOOD, len);
 	return ret;
 }
 static int spc_modesense_rwrecovery(struct se_cmd *cmd, u8 pc, u8 *p)
 {
 	p[0] = 0x01;
 	p[1] = 0x0a;
 	/* No changeable values for now */
 	if (pc == 1)
 		goto out;
 out:
 	return 12;
 }
 static int spc_modesense_control(struct se_cmd *cmd, u8 pc, u8 *p)
 {
 	struct se_device *dev = cmd->se_dev;
 	struct se_session *sess = cmd->se_sess;
 	p[0] = 0x0a;
 	p[1] = 0x0a;
 	/* No changeable values for now */
 	if (pc == 1)
 		goto out;
 	p[2] = 2;
 	/*
 	 * From spc4r23, 7.4.7 Control mode page
 	 *
 	 * The QUEUE ALGORITHM MODIFIER field (see table 368) specifies
 	 * restrictions on the algorithm used for reordering commands
 	 * having the SIMPLE task attribute (see SAM-4).
 	 *
 	 *                    Table 368 -- QUEUE ALGORITHM MODIFIER field
 	 *                         Code      Description
 	 *                          0h       Restricted reordering
 	 *                          1h       Unrestricted reordering allowed
 	 *                          2h to 7h    Reserved
 	 *                          8h to Fh    Vendor specific
 	 *
 	 * A value of zero in the QUEUE ALGORITHM MODIFIER field specifies that
 	 * the device server shall order the processing sequence of commands
 	 * having the SIMPLE task attribute such that data integrity is maintained
 	 * for that I_T nexus (i.e., if the transmission of new SCSI transport protocol
 	 * requests is halted at any time, the final value of all data observable
 	 * on the medium shall be the same as if all the commands had been processed
 	 * with the ORDERED task attribute).
 	 *
 	 * A value of one in the QUEUE ALGORITHM MODIFIER field specifies that the
 	 * device server may reorder the processing sequence of commands having the
 	 * SIMPLE task attribute in any manner. Any data integrity exposures related to
 	 * command sequence order shall be explicitly handled by the application client
 	 * through the selection of appropriate ommands and task attributes.
 	 */
 	p[3] = (dev->dev_attrib.emulate_rest_reord == 1) ? 0x00 : 0x10;
 	/*
 	 * From spc4r17, section 7.4.6 Control mode Page
 	 *
 	 * Unit Attention interlocks control (UN_INTLCK_CTRL) to code 00b
 	 *
 	 * 00b: The logical unit shall clear any unit attention condition
 	 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
 	 * status and shall not establish a unit attention condition when a com-
 	 * mand is completed with BUSY, TASK SET FULL, or RESERVATION CONFLICT
 	 * status.
 	 *
 	 * 10b: The logical unit shall not clear any unit attention condition
 	 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
 	 * status and shall not establish a unit attention condition when
 	 * a command is completed with BUSY, TASK SET FULL, or RESERVATION
 	 * CONFLICT status.
 	 *
 	 * 11b a The logical unit shall not clear any unit attention condition
 	 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
 	 * status and shall establish a unit attention condition for the
 	 * initiator port associated with the I_T nexus on which the BUSY,
 	 * TASK SET FULL, or RESERVATION CONFLICT status is being returned.
 	 * Depending on the status, the additional sense code shall be set to
 	 * PREVIOUS BUSY STATUS, PREVIOUS TASK SET FULL STATUS, or PREVIOUS
 	 * RESERVATION CONFLICT STATUS. Until it is cleared by a REQUEST SENSE
 	 * command, a unit attention condition shall be established only once
 	 * for a BUSY, TASK SET FULL, or RESERVATION CONFLICT status regardless
 	 * to the number of commands completed with one of those status codes.
 	 */
 	p[4] = (dev->dev_attrib.emulate_ua_intlck_ctrl == 2) ? 0x30 :
 	       (dev->dev_attrib.emulate_ua_intlck_ctrl == 1) ? 0x20 : 0x00;
 	/*
 	 * From spc4r17, section 7.4.6 Control mode Page
 	 *
 	 * Task Aborted Status (TAS) bit set to zero.
 	 *
 	 * A task aborted status (TAS) bit set to zero specifies that aborted
 	 * tasks shall be terminated by the device server without any response
 	 * to the application client. A TAS bit set to one specifies that tasks
 	 * aborted by the actions of an I_T nexus other than the I_T nexus on
 	 * which the command was received shall be completed with TASK ABORTED
 	 * status (see SAM-4).
 	 */
 	p[5] = (dev->dev_attrib.emulate_tas) ? 0x40 : 0x00;
 	/*
 	 * From spc4r30, section 7.5.7 Control mode page
 	 *
 	 * Application Tag Owner (ATO) bit set to one.
 	 *
 	 * If the ATO bit is set to one the device server shall not modify the
 	 * LOGICAL BLOCK APPLICATION TAG field and, depending on the protection
 	 * type, shall not modify the contents of the LOGICAL BLOCK REFERENCE
 	 * TAG field.
 	 */
 	if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
 		if (dev->dev_attrib.pi_prot_type)
 			p[5] |= 0x80;
 	}
 	p[8] = 0xff;
 	p[9] = 0xff;
 	p[11] = 30;
 out:
 	return 12;
 }
 static int spc_modesense_caching(struct se_cmd *cmd, u8 pc, u8 *p)
 {
 	struct se_device *dev = cmd->se_dev;
 	p[0] = 0x08;
 	p[1] = 0x12;
 	/* No changeable values for now */
 	if (pc == 1)
 		goto out;
 	if (spc_check_dev_wce(dev))
 		p[2] = 0x04; /* Write Cache Enable */
 	p[12] = 0x20; /* Disabled Read Ahead */
 out:
 	return 20;
 }
 static int spc_modesense_informational_exceptions(struct se_cmd *cmd, u8 pc, unsigned char *p)
 {
 	p[0] = 0x1c;
 	p[1] = 0x0a;
 	/* No changeable values for now */
 	if (pc == 1)
 		goto out;
 out:
 	return 12;
 }
 static struct {
 	uint8_t		page;
 	uint8_t		subpage;
 	int		(*emulate)(struct se_cmd *, u8, unsigned char *);
 } modesense_handlers[] = {
 	{ .page = 0x01, .subpage = 0x00, .emulate = spc_modesense_rwrecovery },
 	{ .page = 0x08, .subpage = 0x00, .emulate = spc_modesense_caching },
 	{ .page = 0x0a, .subpage = 0x00, .emulate = spc_modesense_control },
 	{ .page = 0x1c, .subpage = 0x00, .emulate = spc_modesense_informational_exceptions },
 };
 static void spc_modesense_write_protect(unsigned char *buf, int type)
 {
 	/*
 	 * I believe that the WP bit (bit 7) in the mode header is the same for
 	 * all device types..
 	 */
 	switch (type) {
 	case TYPE_DISK:
 	case TYPE_TAPE:
 	default:
 		buf[0] |= 0x80; /* WP bit */
 		break;
 	}
 }
 static void spc_modesense_dpofua(unsigned char *buf, int type)
 {
 	switch (type) {
 	case TYPE_DISK:
 		buf[0] |= 0x10; /* DPOFUA bit */
 		break;
 	default:
 		break;
 	}
 }
 static int spc_modesense_blockdesc(unsigned char *buf, u64 blocks, u32 block_size)
 {
 	*buf++ = 8;
 	put_unaligned_be32(min(blocks, 0xffffffffull), buf);
 	buf += 4;
 	put_unaligned_be32(block_size, buf);
 	return 9;
 }
 static int spc_modesense_long_blockdesc(unsigned char *buf, u64 blocks, u32 block_size)
 {
 	if (blocks <= 0xffffffff)
 		return spc_modesense_blockdesc(buf + 3, blocks, block_size) + 3;
 	*buf++ = 1;		/* LONGLBA */
 	buf += 2;
 	*buf++ = 16;
 	put_unaligned_be64(blocks, buf);
 	buf += 12;
 	put_unaligned_be32(block_size, buf);
 	return 17;
 }
 static sense_reason_t spc_emulate_modesense(struct se_cmd *cmd)
 {
 	struct se_device *dev = cmd->se_dev;
 	char *cdb = cmd->t_task_cdb;
 	unsigned char buf[SE_MODE_PAGE_BUF], *rbuf;
 	int type = dev->transport->get_device_type(dev);
 	int ten = (cmd->t_task_cdb[0] == MODE_SENSE_10);
 	bool dbd = !!(cdb[1] & 0x08);
 	bool llba = ten ? !!(cdb[1] & 0x10) : false;
 	u8 pc = cdb[2] >> 6;
 	u8 page = cdb[2] & 0x3f;
 	u8 subpage = cdb[3];
 	int length = 0;
 	int ret;
 	int i;
 	memset(buf, 0, SE_MODE_PAGE_BUF);
 	/*
 	 * Skip over MODE DATA LENGTH + MEDIUM TYPE fields to byte 3 for
 	 * MODE_SENSE_10 and byte 2 for MODE_SENSE (6).
 	 */
 	length = ten ? 3 : 2;
 	/* DEVICE-SPECIFIC PARAMETER */
 	if ((cmd->se_lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) ||
 	    (cmd->se_deve &&
 	     (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)))
 		spc_modesense_write_protect(&buf[length], type);
 	if ((spc_check_dev_wce(dev)) &&
 	    (dev->dev_attrib.emulate_fua_write > 0))
 		spc_modesense_dpofua(&buf[length], type);
 	++length;
 	/* BLOCK DESCRIPTOR */
 	/*
 	 * For now we only include a block descriptor for disk (SBC)
 	 * devices; other command sets use a slightly different format.
 	 */
 	if (!dbd && type == TYPE_DISK) {
 		u64 blocks = dev->transport->get_blocks(dev);
 		u32 block_size = dev->dev_attrib.block_size;
 		if (ten) {
 			if (llba) {
 				length += spc_modesense_long_blockdesc(&buf[length],
 								       blocks, block_size);
 			} else {
 				length += 3;
 				length += spc_modesense_blockdesc(&buf[length],
 								  blocks, block_size);
 			}
 		} else {
 			length += spc_modesense_blockdesc(&buf[length], blocks,
 							  block_size);
 		}
 	} else {
 		if (ten)
 			length += 4;
 		else
 			length += 1;
 	}
 	if (page == 0x3f) {
 		if (subpage != 0x00 && subpage != 0xff) {
 			pr_warn("MODE_SENSE: Invalid subpage code: 0x%02x\n", subpage);
 			return TCM_INVALID_CDB_FIELD;
 		}
 		for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i) {
 			/*
 			 * Tricky way to say all subpage 00h for
 			 * subpage==0, all subpages for subpage==0xff
 			 * (and we just checked above that those are
 			 * the only two possibilities).
 			 */
 			if ((modesense_handlers[i].subpage & ~subpage) == 0) {
 				ret = modesense_handlers[i].emulate(cmd, pc, &buf[length]);
 				if (!ten && length + ret >= 255)
 					break;
 				length += ret;
 			}
 		}
 		goto set_length;
 	}
 	for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i)
 		if (modesense_handlers[i].page == page &&
 		    modesense_handlers[i].subpage == subpage) {
 			length += modesense_handlers[i].emulate(cmd, pc, &buf[length]);
 			goto set_length;
 		}
 	/*
 	 * We don't intend to implement:
 	 *  - obsolete page 03h "format parameters" (checked by Solaris)
 	 */
 	if (page != 0x03)
 		pr_err("MODE SENSE: unimplemented page/subpage: 0x%02x/0x%02x\n",
 		       page, subpage);
 	return TCM_UNKNOWN_MODE_PAGE;
 set_length:
 	if (ten)
 		put_unaligned_be16(length - 2, buf);
 	else
 		buf[0] = length - 1;
 	rbuf = transport_kmap_data_sg(cmd);
 	if (rbuf) {
 		memcpy(rbuf, buf, min_t(u32, SE_MODE_PAGE_BUF, cmd->data_length));
 		transport_kunmap_data_sg(cmd);
 	}
 	target_complete_cmd_with_length(cmd, GOOD, length);
 	return 0;
 }
 static sense_reason_t spc_emulate_modeselect(struct se_cmd *cmd)
 {
 	char *cdb = cmd->t_task_cdb;
 	bool ten = cdb[0] == MODE_SELECT_10;
 	int off = ten ? 8 : 4;
 	bool pf = !!(cdb[1] & 0x10);
 	u8 page, subpage;
 	unsigned char *buf;
 	unsigned char tbuf[SE_MODE_PAGE_BUF];
 	int length;
 	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;
 	if (!pf) {
 		ret = TCM_INVALID_CDB_FIELD;
 		goto out;
 	}
 	page = buf[off] & 0x3f;
 	subpage = buf[off] & 0x40 ? buf[off + 1] : 0;
 	for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i)
 		if (modesense_handlers[i].page == page &&
 		    modesense_handlers[i].subpage == subpage) {
 			memset(tbuf, 0, SE_MODE_PAGE_BUF);
 			length = modesense_handlers[i].emulate(cmd, 0, tbuf);
 			goto check_contents;
 		}
 	ret = TCM_UNKNOWN_MODE_PAGE;
 	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;
 out:
 	transport_kunmap_data_sg(cmd);
 	if (!ret)
 		target_complete_cmd(cmd, GOOD);
 	return ret;
 }
 static sense_reason_t spc_emulate_request_sense(struct se_cmd *cmd)
 {
 	unsigned char *cdb = cmd->t_task_cdb;
 	unsigned char *rbuf;
 	u8 ua_asc = 0, ua_ascq = 0;
 	unsigned char buf[SE_SENSE_BUF];
 	memset(buf, 0, SE_SENSE_BUF);
 	if (cdb[1] & 0x01) {
 		pr_err("REQUEST_SENSE description emulation not"
 			" supported\n");
 		return TCM_INVALID_CDB_FIELD;
 	}
 	rbuf = transport_kmap_data_sg(cmd);
 	if (!rbuf)
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	if (!core_scsi3_ua_clear_for_request_sense(cmd, &ua_asc, &ua_ascq)) {
 		/*
 		 * CURRENT ERROR, UNIT ATTENTION
 		 */
 		buf[0] = 0x70;
 		buf[SPC_SENSE_KEY_OFFSET] = UNIT_ATTENTION;
 		/*
 		 * The Additional Sense Code (ASC) from the UNIT ATTENTION
 		 */
 		buf[SPC_ASC_KEY_OFFSET] = ua_asc;
 		buf[SPC_ASCQ_KEY_OFFSET] = ua_ascq;
 		buf[7] = 0x0A;
 	} else {
 		/*
 		 * CURRENT ERROR, NO SENSE
 		 */
 		buf[0] = 0x70;
 		buf[SPC_SENSE_KEY_OFFSET] = NO_SENSE;
 		/*
 		 * NO ADDITIONAL SENSE INFORMATION
 		 */
 		buf[SPC_ASC_KEY_OFFSET] = 0x00;
 		buf[7] = 0x0A;
 	}
 	memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
 	transport_kunmap_data_sg(cmd);
 	target_complete_cmd(cmd, GOOD);
 	return 0;
 }
 sense_reason_t spc_emulate_report_luns(struct se_cmd *cmd)
 {
 	struct se_dev_entry *deve;
 	struct se_session *sess = cmd->se_sess;
 	unsigned char *buf;
 	u32 lun_count = 0, offset = 8, i;
 	if (cmd->data_length < 16) {
 		pr_warn("REPORT LUNS allocation length %u too small\n",
 			cmd->data_length);
 		return TCM_INVALID_CDB_FIELD;
 	}
 	buf = transport_kmap_data_sg(cmd);
 	if (!buf)
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	/*
 	 * If no struct se_session pointer is present, this struct se_cmd is
 	 * coming via a target_core_mod PASSTHROUGH op, and not through
 	 * a $FABRIC_MOD.  In that case, report LUN=0 only.
 	 */
 	if (!sess) {
 		int_to_scsilun(0, (struct scsi_lun *)&buf[offset]);
 		lun_count = 1;
 		goto done;
 	}
 	spin_lock_irq(&sess->se_node_acl->device_list_lock);
 	for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
 		deve = sess->se_node_acl->device_list[i];
 		if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
 			continue;
 		/*
 		 * We determine the correct LUN LIST LENGTH even once we
 		 * have reached the initial allocation length.
 		 * See SPC2-R20 7.19.
 		 */
 		lun_count++;
 		if ((offset + 8) > cmd->data_length)
 			continue;
 		int_to_scsilun(deve->mapped_lun, (struct scsi_lun *)&buf[offset]);
 		offset += 8;
 	}
 	spin_unlock_irq(&sess->se_node_acl->device_list_lock);
 	/*
 	 * See SPC3 r07, page 159.
 	 */
 done:
 	lun_count *= 8;
 	buf[0] = ((lun_count >> 24) & 0xff);
 	buf[1] = ((lun_count >> 16) & 0xff);
 	buf[2] = ((lun_count >> 8) & 0xff);
 	buf[3] = (lun_count & 0xff);
 	transport_kunmap_data_sg(cmd);
 	target_complete_cmd_with_length(cmd, GOOD, 8 + lun_count * 8);
 	return 0;
 }
 EXPORT_SYMBOL(spc_emulate_report_luns);
 static sense_reason_t
 spc_emulate_testunitready(struct se_cmd *cmd)
 {
 	target_complete_cmd(cmd, GOOD);
 	return 0;
 }
 sense_reason_t
 spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
 {
 	struct se_device *dev = cmd->se_dev;
 	unsigned char *cdb = cmd->t_task_cdb;
 	switch (cdb[0]) {
 	case MODE_SELECT:
 		*size = cdb[4];
 		cmd->execute_cmd = spc_emulate_modeselect;
 		break;
 	case MODE_SELECT_10:
 		*size = (cdb[7] << 8) + cdb[8];
 		cmd->execute_cmd = spc_emulate_modeselect;
 		break;
 	case MODE_SENSE:
 		*size = cdb[4];
 		cmd->execute_cmd = spc_emulate_modesense;
 		break;
 	case MODE_SENSE_10:
 		*size = (cdb[7] << 8) + cdb[8];
 		cmd->execute_cmd = spc_emulate_modesense;
 		break;
 	case LOG_SELECT:
 	case LOG_SENSE:
 		*size = (cdb[7] << 8) + cdb[8];
 		break;
 	case PERSISTENT_RESERVE_IN:
 		*size = (cdb[7] << 8) + cdb[8];
 		cmd->execute_cmd = target_scsi3_emulate_pr_in;
 		break;
 	case PERSISTENT_RESERVE_OUT:
 		*size = (cdb[7] << 8) + cdb[8];
 		cmd->execute_cmd = target_scsi3_emulate_pr_out;
 		break;
 	case RELEASE:
 	case RELEASE_10:
 		if (cdb[0] == RELEASE_10)
 			*size = (cdb[7] << 8) | cdb[8];
 		else
 			*size = cmd->data_length;
 		cmd->execute_cmd = target_scsi2_reservation_release;
 		break;
 	case RESERVE:
 	case RESERVE_10:
 		/*
 		 * The SPC-2 RESERVE does not contain a size in the SCSI CDB.
 		 * Assume the passthrough or $FABRIC_MOD will tell us about it.
 		 */
 		if (cdb[0] == RESERVE_10)
 			*size = (cdb[7] << 8) | cdb[8];
 		else
 			*size = cmd->data_length;
 		cmd->execute_cmd = target_scsi2_reservation_reserve;
 		break;
 	case REQUEST_SENSE:
 		*size = cdb[4];
 		cmd->execute_cmd = spc_emulate_request_sense;
 		break;
 	case INQUIRY:
 		*size = (cdb[3] << 8) + cdb[4];
 		/*
 		 * Do implicit HEAD_OF_QUEUE processing for INQUIRY.
 		 * See spc4r17 section 5.3
 		 */
 		cmd->sam_task_attr = MSG_HEAD_TAG;
 		cmd->execute_cmd = spc_emulate_inquiry;
 		break;
 	case SECURITY_PROTOCOL_IN:
 	case SECURITY_PROTOCOL_OUT:
 		*size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
 		break;
 	case EXTENDED_COPY:
 		*size = get_unaligned_be32(&cdb[10]);
 		cmd->execute_cmd = target_do_xcopy;
 		break;
 	case RECEIVE_COPY_RESULTS:
 		*size = get_unaligned_be32(&cdb[10]);
 		cmd->execute_cmd = target_do_receive_copy_results;
 		break;
 	case READ_ATTRIBUTE:
 	case WRITE_ATTRIBUTE:
 		*size = (cdb[10] << 24) | (cdb[11] << 16) |
 		       (cdb[12] << 8) | cdb[13];
 		break;
 	case RECEIVE_DIAGNOSTIC:
 	case SEND_DIAGNOSTIC:
 		*size = (cdb[3] << 8) | cdb[4];
 		break;
 	case WRITE_BUFFER:
 		*size = (cdb[6] << 16) + (cdb[7] << 8) + cdb[8];
 		break;
 	case REPORT_LUNS:
 		cmd->execute_cmd = spc_emulate_report_luns;
 		*size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
 		/*
 		 * Do implicit HEAD_OF_QUEUE processing for REPORT_LUNS
 		 * See spc4r17 section 5.3
 		 */
 		cmd->sam_task_attr = MSG_HEAD_TAG;
 		break;
 	case TEST_UNIT_READY:
 		cmd->execute_cmd = spc_emulate_testunitready;
 		*size = 0;
 		break;
 	case MAINTENANCE_IN:
 		if (dev->transport->get_device_type(dev) != TYPE_ROM) {
 			/*
 			 * MAINTENANCE_IN from SCC-2
 			 * Check for emulated MI_REPORT_TARGET_PGS
 			 */
 			if ((cdb[1] & 0x1f) == MI_REPORT_TARGET_PGS) {
 				cmd->execute_cmd =
 					target_emulate_report_target_port_groups;
 			}
 			*size = get_unaligned_be32(&cdb[6]);
 		} else {
 			/*
 			 * GPCMD_SEND_KEY from multi media commands
 			 */
 			*size = get_unaligned_be16(&cdb[8]);
 		}
 		break;
 	case MAINTENANCE_OUT:
 		if (dev->transport->get_device_type(dev) != TYPE_ROM) {
 			/*
 			 * MAINTENANCE_OUT from SCC-2
 			 * Check for emulated MO_SET_TARGET_PGS.
 			 */
 			if (cdb[1] == MO_SET_TARGET_PGS) {
 				cmd->execute_cmd =
 					target_emulate_set_target_port_groups;
 			}
 			*size = get_unaligned_be32(&cdb[6]);
 		} else {
 			/*
 			 * GPCMD_SEND_KEY from multi media commands
 			 */
 			*size = get_unaligned_be16(&cdb[8]);
 		}
 		break;
 	default:
 		pr_warn("TARGET_CORE[%s]: Unsupported SCSI Opcode"
 			" 0x%02x, sending CHECK_CONDITION.\n",
 			cmd->se_tfo->get_fabric_name(), cdb[0]);
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 	return 0;
 }
 EXPORT_SYMBOL(spc_parse_cdb);