Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a1d8b49a authored by Andy Grover's avatar Andy Grover Committed by Nicholas Bellinger
Browse files

target: Updates from AGrover and HCH (round 3) 



This patch contains a squashed version of third round series cleanups,
improvements ,and simplfications from Andy and Christoph ahead of the
heavy lifting between round 3 -> 4 for the target core SGL conversion.

This include cleanups to the main target I/O path and other miscellaneous
updates.

target: Replace custom sg<->buf functions with lib funcs
target: Simplify sector limiting code
target: get_cdb should never return NULL
target: Simplify transport_memcpy_se_mem_read_contig
target: Use assignment rather than increment for t_task_cdbs
target: Don't pass dma_size to generic_get_mem
target: Pass sg with type scatterlist in transport_map_sg_to_mem
target: Move task_sg_num next to task_sg in struct se_task
target: inline struct se_transport_task into struct se_cmd
target: Change name & semantics of transport_get_sectors()
target: Remove unused members of se_cmd
target: Rename se_cmd.t_task_cdbs to t_task_list_num
target: Fix some spelling
target: Remove unused var from transport_generic_do_tmr
target: map_sg_to_mem: return sg_count in return value
target/pscsi: Use min_t for sector limits
target/pscsi: Unused param for pscsi_get_bio()
target: Rename get_cdb_count to allocate_tasks
target: Make transport_generic_new_cmd() available for iscsi-target
target: Remove fabric callback to allocate iovecs
target: Fix transport_generic_new_cmd WRITE comment

(hch: Use __GFP_ZERO usage for alloc_pages() usage)

Signed-off-by: default avatarAndy Grover <agrover@redhat.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarNicholas Bellinger <nab@linux-iscsi.org>
parent dd3a5ad8

drivers/target/loopback/tcm_loop.c

+2 −9
Original line number Diff line number Diff line
@@ -118,7 +118,7 @@ static struct se_cmd *tcm_loop_allocate_core_cmd( 
	 * Signal BIDI usage with T_TASK(cmd)->t_tasks_bidi

	 */

	if (scsi_bidi_cmnd(sc))

		se_cmd->t_task.t_tasks_bidi = 1;

		se_cmd->t_tasks_bidi = 1;

	/*

	 * Locate the struct se_lun pointer and attach it to struct se_cmd

	 */
@@ -169,7 +169,7 @@ static int tcm_loop_new_cmd_map(struct se_cmd *se_cmd) 
	 * For BIDI commands, pass in the extra READ buffer

	 * to transport_generic_map_mem_to_cmd() below..

	 */

	if (se_cmd->t_task.t_tasks_bidi) {

	if (se_cmd->t_tasks_bidi) {

		struct scsi_data_buffer *sdb = scsi_in(sc);



		sgl_bidi = sdb->table.sgl;
@@ -1423,13 +1423,6 @@ static int tcm_loop_register_configfs(void) 
	fabric->tf_ops.tpg_release_fabric_acl =

					&tcm_loop_tpg_release_fabric_acl;

	fabric->tf_ops.tpg_get_inst_index = &tcm_loop_get_inst_index;

	/*

	 * Since tcm_loop is mapping physical memory from Linux/SCSI

	 * struct scatterlist arrays for each struct scsi_cmnd I/O,

	 * we do not need TCM to allocate a iovec array for

	 * virtual memory address mappings

	 */

	fabric->tf_ops.alloc_cmd_iovecs = NULL;

	/*

	 * Used for setting up remaining TCM resources in process context

	 */

drivers/target/target_core_alua.c

+2 −2
Original line number Diff line number Diff line
@@ -65,7 +65,7 @@ int core_emulate_report_target_port_groups(struct se_cmd *cmd) 
	struct se_port *port;

	struct t10_alua_tg_pt_gp *tg_pt_gp;

	struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;

	unsigned char *buf = (unsigned char *)cmd->t_task.t_task_buf;

	unsigned char *buf = (unsigned char *)cmd->t_task_buf;

	u32 rd_len = 0, off = 4; /* Skip over RESERVED area to first

				    Target port group descriptor */
@@ -157,7 +157,7 @@ int core_emulate_set_target_port_groups(struct se_cmd *cmd) 
	struct se_node_acl *nacl = cmd->se_sess->se_node_acl;

	struct t10_alua_tg_pt_gp *tg_pt_gp = NULL, *l_tg_pt_gp;

	struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem, *l_tg_pt_gp_mem;

	unsigned char *buf = (unsigned char *)cmd->t_task.t_task_buf;

	unsigned char *buf = (unsigned char *)cmd->t_task_buf;

	unsigned char *ptr = &buf[4]; /* Skip over RESERVED area in header */

	u32 len = 4; /* Skip over RESERVED area in header */

	int alua_access_state, primary = 0, rc;

drivers/target/target_core_cdb.c

+20 −19
Original line number Diff line number Diff line
@@ -66,7 +66,7 @@ target_emulate_inquiry_std(struct se_cmd *cmd) 
{

	struct se_lun *lun = cmd->se_lun;

	struct se_device *dev = cmd->se_dev;

	unsigned char *buf = cmd->t_task.t_task_buf;

	unsigned char *buf = cmd->t_task_buf;



	/*

	 * Make sure we at least have 6 bytes of INQUIRY response
@@ -621,8 +621,8 @@ static int 
target_emulate_inquiry(struct se_cmd *cmd)

{

	struct se_device *dev = cmd->se_dev;

	unsigned char *buf = cmd->t_task.t_task_buf;

	unsigned char *cdb = cmd->t_task.t_task_cdb;

	unsigned char *buf = cmd->t_task_buf;

	unsigned char *cdb = cmd->t_task_cdb;



	if (!(cdb[1] & 0x1))

		return target_emulate_inquiry_std(cmd);
@@ -666,7 +666,7 @@ static int 
target_emulate_readcapacity(struct se_cmd *cmd)

{

	struct se_device *dev = cmd->se_dev;

	unsigned char *buf = cmd->t_task.t_task_buf;

	unsigned char *buf = cmd->t_task_buf;

	unsigned long long blocks_long = dev->transport->get_blocks(dev);

	u32 blocks;
@@ -696,7 +696,7 @@ static int 
target_emulate_readcapacity_16(struct se_cmd *cmd)

{

	struct se_device *dev = cmd->se_dev;

	unsigned char *buf = cmd->t_task.t_task_buf;

	unsigned char *buf = cmd->t_task_buf;

	unsigned long long blocks = dev->transport->get_blocks(dev);



	buf[0] = (blocks >> 56) & 0xff;
@@ -831,8 +831,8 @@ static int 
target_emulate_modesense(struct se_cmd *cmd, int ten)

{

	struct se_device *dev = cmd->se_dev;

	char *cdb = cmd->t_task.t_task_cdb;

	unsigned char *rbuf = cmd->t_task.t_task_buf;

	char *cdb = cmd->t_task_cdb;

	unsigned char *rbuf = cmd->t_task_buf;

	int type = dev->transport->get_device_type(dev);

	int offset = (ten) ? 8 : 4;

	int length = 0;
@@ -903,8 +903,8 @@ target_emulate_modesense(struct se_cmd *cmd, int ten) 
static int

target_emulate_request_sense(struct se_cmd *cmd)

{

	unsigned char *cdb = cmd->t_task.t_task_cdb;

	unsigned char *buf = cmd->t_task.t_task_buf;

	unsigned char *cdb = cmd->t_task_cdb;

	unsigned char *buf = cmd->t_task_buf;

	u8 ua_asc = 0, ua_ascq = 0;



	if (cdb[1] & 0x01) {
@@ -965,8 +965,8 @@ target_emulate_unmap(struct se_task *task) 
{

	struct se_cmd *cmd = task->task_se_cmd;

	struct se_device *dev = cmd->se_dev;

	unsigned char *buf = cmd->t_task.t_task_buf, *ptr = NULL;

	unsigned char *cdb = &cmd->t_task.t_task_cdb[0];

	unsigned char *buf = cmd->t_task_buf, *ptr = NULL;

	unsigned char *cdb = &cmd->t_task_cdb[0];

	sector_t lba;

	unsigned int size = cmd->data_length, range;

	int ret, offset;
@@ -1012,7 +1012,8 @@ target_emulate_write_same(struct se_task *task, int write_same32) 
{

	struct se_cmd *cmd = task->task_se_cmd;

	struct se_device *dev = cmd->se_dev;

	sector_t range, lba = cmd->t_task.t_task_lba;

	sector_t range;

	sector_t lba = cmd->t_task_lba;

	unsigned int num_blocks;

	int ret;

	/*
@@ -1021,9 +1022,9 @@ target_emulate_write_same(struct se_task *task, int write_same32) 
	 * range based on ->get_blocks() - starting LBA.

	 */

	if (write_same32)

		num_blocks = get_unaligned_be32(&cmd->t_task.t_task_cdb[28]);

		num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]);

	else

		num_blocks = get_unaligned_be32(&cmd->t_task.t_task_cdb[10]);

		num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]);



	if (num_blocks != 0)

		range = num_blocks;
@@ -1052,7 +1053,7 @@ transport_emulate_control_cdb(struct se_task *task) 
	unsigned short service_action;

	int ret = 0;



	switch (cmd->t_task.t_task_cdb[0]) {

	switch (cmd->t_task_cdb[0]) {

	case INQUIRY:

		ret = target_emulate_inquiry(cmd);

		break;
@@ -1066,13 +1067,13 @@ transport_emulate_control_cdb(struct se_task *task) 
		ret = target_emulate_modesense(cmd, 1);

		break;

	case SERVICE_ACTION_IN:

		switch (cmd->t_task.t_task_cdb[1] & 0x1f) {

		switch (cmd->t_task_cdb[1] & 0x1f) {

		case SAI_READ_CAPACITY_16:

			ret = target_emulate_readcapacity_16(cmd);

			break;

		default:

			printk(KERN_ERR "Unsupported SA: 0x%02x\n",

				cmd->t_task.t_task_cdb[1] & 0x1f);

				cmd->t_task_cdb[1] & 0x1f);

			return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;

		}

		break;
@@ -1097,7 +1098,7 @@ transport_emulate_control_cdb(struct se_task *task) 
		break;

	case VARIABLE_LENGTH_CMD:

		service_action =

			get_unaligned_be16(&cmd->t_task.t_task_cdb[8]);

			get_unaligned_be16(&cmd->t_task_cdb[8]);

		switch (service_action) {

		case WRITE_SAME_32:

			if (!dev->transport->do_discard) {
@@ -1136,7 +1137,7 @@ transport_emulate_control_cdb(struct se_task *task) 
		break;

	default:

		printk(KERN_ERR "Unsupported SCSI Opcode: 0x%02x for %s\n",

			cmd->t_task.t_task_cdb[0], dev->transport->name);

			cmd->t_task_cdb[0], dev->transport->name);

		return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;

	}

drivers/target/target_core_device.c

+3 −3
Original line number Diff line number Diff line
@@ -168,7 +168,7 @@ int transport_lookup_cmd_lun(struct se_cmd *se_cmd, u32 unpacked_lun) 
	 */

	spin_lock_irqsave(&se_lun->lun_cmd_lock, flags);

	list_add_tail(&se_cmd->se_lun_node, &se_lun->lun_cmd_list);

	atomic_set(&se_cmd->t_task.transport_lun_active, 1);

	atomic_set(&se_cmd->transport_lun_active, 1);

	spin_unlock_irqrestore(&se_lun->lun_cmd_lock, flags);



	return 0;
@@ -656,10 +656,10 @@ int transport_core_report_lun_response(struct se_cmd *se_cmd) 
	struct se_lun *se_lun;

	struct se_session *se_sess = se_cmd->se_sess;

	struct se_task *se_task;

	unsigned char *buf = se_cmd->t_task.t_task_buf;

	unsigned char *buf = se_cmd->t_task_buf;

	u32 cdb_offset = 0, lun_count = 0, offset = 8, i;



	list_for_each_entry(se_task, &se_cmd->t_task.t_task_list, t_list)

	list_for_each_entry(se_task, &se_cmd->t_task_list, t_list)

		break;



	if (!(se_task)) {

drivers/target/target_core_file.c

+4 −4
Original line number Diff line number Diff line
@@ -377,7 +377,7 @@ static void fd_emulate_sync_cache(struct se_task *task) 
	struct se_cmd *cmd = task->task_se_cmd;

	struct se_device *dev = cmd->se_dev;

	struct fd_dev *fd_dev = dev->dev_ptr;

	int immed = (cmd->t_task.t_task_cdb[1] & 0x2);

	int immed = (cmd->t_task_cdb[1] & 0x2);

	loff_t start, end;

	int ret;
@@ -391,11 +391,11 @@ static void fd_emulate_sync_cache(struct se_task *task) 
	/*

	 * Determine if we will be flushing the entire device.

	 */

	if (cmd->t_task.t_task_lba == 0 && cmd->data_length == 0) {

	if (cmd->t_task_lba == 0 && cmd->data_length == 0) {

		start = 0;

		end = LLONG_MAX;

	} else {

		start = cmd->t_task.t_task_lba * dev->se_sub_dev->se_dev_attrib.block_size;

		start = cmd->t_task_lba * dev->se_sub_dev->se_dev_attrib.block_size;

		if (cmd->data_length)

			end = start + cmd->data_length;

		else
@@ -475,7 +475,7 @@ static int fd_do_task(struct se_task *task) 
		if (ret > 0 &&

		    dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0 &&

		    dev->se_sub_dev->se_dev_attrib.emulate_fua_write > 0 &&

		    cmd->t_task.t_tasks_fua) {

		    cmd->t_tasks_fua) {

			/*

			 * We might need to be a bit smarter here

			 * and return some sense data to let the initiator