On Tue, 2010-11-16 at 12:38 -0500, Christoph Hellwig wrote:
> Instead of having separate methods for mapping read/write CDBs
> add a data_direction member to struct se_task abd unify the code
> in the backends. Also remove all kinds of unused copies of the
> task state in the backend-specific task structures.
>
> Signed-off-by: Christoph Hellwig <hch@xxxxxx>
Hi Christoph,
I think this cleanup looks good. Committed as e79b6805
--nab
>
> Index: lio-core/drivers/target/target_core_file.c
> ===================================================================
> --- lio-core.orig/drivers/target/target_core_file.c 2010-11-16 10:33:03.117004333 +0100
> +++ lio-core/drivers/target/target_core_file.c 2010-11-16 12:26:05.116254863 +0100
> @@ -304,41 +304,30 @@ fd_alloc_task(struct se_cmd *cmd)
> return &fd_req->fd_task;
> }
>
> -static inline int fd_iovec_alloc(struct fd_request *req)
> -{
> - req->fd_iovs = kzalloc(sizeof(struct iovec) * req->fd_sg_count,
> - GFP_KERNEL);
> - if (!(req->fd_iovs)) {
> - printk(KERN_ERR "Unable to allocate req->fd_iovs\n");
> - return -1;
> - }
> -
> - return 0;
> -}
> -
> -static int fd_do_readv(struct fd_request *req, struct se_task *task)
> +static int fd_do_readv(struct se_task *task)
> {
> + struct fd_request *req = FILE_REQ(task);
> struct file *fd = req->fd_dev->fd_file;
> struct scatterlist *sg = task->task_sg;
> struct iovec *iov;
> mm_segment_t old_fs;
> - loff_t pos = (req->fd_lba * DEV_ATTRIB(task->se_dev)->block_size);
> + loff_t pos = (task->task_lba * DEV_ATTRIB(task->se_dev)->block_size);
> int ret = 0, i;
>
> - iov = kzalloc(sizeof(struct iovec) * req->fd_sg_count, GFP_KERNEL);
> + iov = kzalloc(sizeof(struct iovec) * task->task_sg_num, GFP_KERNEL);
> if (!(iov)) {
> printk(KERN_ERR "Unable to allocate fd_do_readv iov[]\n");
> return -1;
> }
>
> - for (i = 0; i < req->fd_sg_count; i++) {
> + for (i = 0; i < task->task_sg_num; i++) {
> iov[i].iov_len = sg[i].length;
> iov[i].iov_base = sg_virt(&sg[i]);
> }
>
> old_fs = get_fs();
> set_fs(get_ds());
> - ret = vfs_readv(fd, &iov[0], req->fd_sg_count, &pos);
> + ret = vfs_readv(fd, &iov[0], task->task_sg_num, &pos);
> set_fs(old_fs);
>
> kfree(iov);
> @@ -348,10 +337,10 @@ static int fd_do_readv(struct fd_request
> * block_device.
> */
> if (S_ISBLK(fd->f_dentry->d_inode->i_mode)) {
> - if (ret < 0 || ret != req->fd_size) {
> + if (ret < 0 || ret != task->task_size) {
> printk(KERN_ERR "vfs_readv() returned %d,"
> " expecting %d for S_ISBLK\n", ret,
> - (int)req->fd_size);
> + (int)task->task_size);
> return -1;
> }
> } else {
> @@ -365,98 +354,35 @@ static int fd_do_readv(struct fd_request
> return 1;
> }
>
> -#if 0
> -
> -static void fd_sendfile_free_DMA(struct se_cmd *cmd)
> -{
> - printk(KERN_INFO "Release reference to pages now..\n");
> -}
> -
> -static static int fd_sendactor(
> - read_descriptor_t *desc,
> - struct page *page,
> - unsigned long offset,
> - unsigned long size)
> +static int fd_do_writev(struct se_task *task)
> {
> - unsigned long count = desc->count;
> - struct se_task *task = desc->arg.data;
> struct fd_request *req = FILE_REQ(task);
> - struct scatterlist *sg = task->task_sg;
> -
> - printk(KERN_INFO "page: %p offset: %lu size: %lu\n", page,
> - offset, size);
> -
> - __free_page(sg[req->fd_cur_offset].page);
> -
> - printk(KERN_INFO "page_address(page): %p\n", page_address(page));
> - sg[req->fd_cur_offset].page = page;
> - sg[req->fd_cur_offset].offset = offset;
> - sg[req->fd_cur_offset].length = size;
> -
> - printk(KERN_INFO "sg[%d:%p].page %p length: %d\n", req->fd_cur_offset,
> - &sg[req->fd_cur_offset], sg[req->fd_cur_offset].page,
> - sg[req->fd_cur_offset].length);
> -
> - req->fd_cur_size += size;
> - printk(KERN_INFO "fd_cur_size: %u\n", req->fd_cur_size);
> -
> - req->fd_cur_offset++;
> -
> - desc->count--;
> - desc->written += size;
> - return size;
> -}
> -
> -static int fd_do_sendfile(struct fd_request *req, struct se_task *task)
> -{
> - int ret = 0;
> - struct file *fd = req->fd_dev->fd_file;
> -
> - if (fd_seek(fd, req->fd_lba, DEV_ATTRIB(task->se_dev)->block_size) < 0)
> - return -1;
> -
> - TASK_CMD(task)->transport_free_DMA = &fd_sendfile_free_DMA;
> -
> - ret = fd->f_op->sendfile(fd, &fd->f_pos, req->fd_sg_count,
> - fd_sendactor, (void *)task);
> -
> - if (ret < 0) {
> - printk(KERN_ERR "fd->f_op->sendfile() returned %d\n", ret);
> - return -1;
> - }
> -
> - return 1;
> -}
> -#endif
> -
> -static int fd_do_writev(struct fd_request *req, struct se_task *task)
> -{
> struct file *fd = req->fd_dev->fd_file;
> struct scatterlist *sg = task->task_sg;
> struct iovec *iov;
> mm_segment_t old_fs;
> - loff_t pos = (req->fd_lba * DEV_ATTRIB(task->se_dev)->block_size);
> + loff_t pos = (task->task_lba * DEV_ATTRIB(task->se_dev)->block_size);
> int ret, i = 0;
>
> - iov = kzalloc(sizeof(struct iovec) * req->fd_sg_count, GFP_KERNEL);
> + iov = kzalloc(sizeof(struct iovec) * task->task_sg_num, GFP_KERNEL);
> if (!(iov)) {
> printk(KERN_ERR "Unable to allocate fd_do_writev iov[]\n");
> return -1;
> }
>
> - for (i = 0; i < req->fd_sg_count; i++) {
> + for (i = 0; i < task->task_sg_num; i++) {
> iov[i].iov_len = sg[i].length;
> iov[i].iov_base = sg_virt(&sg[i]);
> }
>
> old_fs = get_fs();
> set_fs(get_ds());
> - ret = vfs_writev(fd, &iov[0], req->fd_sg_count, &pos);
> + ret = vfs_writev(fd, &iov[0], task->task_sg_num, &pos);
> set_fs(old_fs);
>
> kfree(iov);
>
> - if (ret < 0 || ret != req->fd_size) {
> + if (ret < 0 || ret != task->task_size) {
> printk(KERN_ERR "vfs_writev() returned %d\n", ret);
> return -1;
> }
> @@ -553,31 +479,21 @@ static int fd_do_task(struct se_task *ta
> {
> struct se_cmd *cmd = task->task_se_cmd;
> struct se_device *dev = cmd->se_dev;
> - struct fd_request *req = FILE_REQ(task);
> int ret = 0;
>
> - req->fd_lba = task->task_lba;
> - req->fd_size = task->task_size;
> /*
> * Call vectorized fileio functions to map struct scatterlist
> * physical memory addresses to struct iovec virtual memory.
> */
> - if (req->fd_data_direction == FD_DATA_READ)
> - ret = fd_do_readv(req, task);
> - else
> - ret = fd_do_writev(req, task);
> -
> - if (ret < 0)
> - return ret;
> + if (task->task_data_direction == DMA_FROM_DEVICE) {
> + ret = fd_do_readv(task);
> + } else {
> + ret = fd_do_writev(task);
>
> - if (ret) {
> - /*
> - * Check for Forced Unit Access WRITE emulation
> - */
> - if ((DEV_ATTRIB(dev)->emulate_write_cache > 0) &&
> - (DEV_ATTRIB(dev)->emulate_fua_write > 0) &&
> - (req->fd_data_direction == FD_DATA_WRITE) &&
> - (T_TASK(cmd)->t_tasks_fua)) {
> + if (ret > 0 &&
> + DEV_ATTRIB(dev)->emulate_write_cache > 0 &&
> + DEV_ATTRIB(dev)->emulate_fua_write > 0 &&
> + T_TASK(cmd)->t_tasks_fua) {
> /*
> * We might need to be a bit smarter here
> * and return some sense data to let the initiator
> @@ -586,10 +502,14 @@ static int fd_do_task(struct se_task *ta
> fd_emulate_write_fua(cmd, task);
> }
>
> + }
> +
> + if (ret < 0)
> + return ret;
> + if (ret) {
> task->task_scsi_status = GOOD;
> transport_complete_task(task, 1);
> }
> -
> return PYX_TRANSPORT_SENT_TO_TRANSPORT;
> }
>
> @@ -601,7 +521,6 @@ static void fd_free_task(struct se_task
> {
> struct fd_request *req = FILE_REQ(task);
>
> - kfree(req->fd_iovs);
> kfree(req);
> }
>
> @@ -722,105 +641,6 @@ static ssize_t fd_show_configfs_dev_para
> return bl;
> }
>
> -/* fd_map_task_non_SG():
> - *
> - *
> - */
> -static void fd_map_task_non_SG(struct se_task *task)
> -{
> - struct se_cmd *cmd = TASK_CMD(task);
> - struct fd_request *req = FILE_REQ(task);
> -
> - req->fd_bufflen = task->task_size;
> - req->fd_buf = (void *) T_TASK(cmd)->t_task_buf;
> - req->fd_sg_count = 0;
> -}
> -
> -/* fd_map_task_SG():
> - *
> - *
> - */
> -static void fd_map_task_SG(struct se_task *task)
> -{
> - struct fd_request *req = FILE_REQ(task);
> -
> - req->fd_bufflen = task->task_size;
> - req->fd_buf = NULL;
> - req->fd_sg_count = task->task_sg_num;
> -}
> -
> -/* fd_CDB_none():
> - *
> - *
> - */
> -static int fd_CDB_none(struct se_task *task, u32 size)
> -{
> - struct fd_request *req = FILE_REQ(task);
> -
> - req->fd_data_direction = FD_DATA_NONE;
> - req->fd_bufflen = 0;
> - req->fd_sg_count = 0;
> - req->fd_buf = NULL;
> -
> - return 0;
> -}
> -
> -/* fd_CDB_read_non_SG():
> - *
> - *
> - */
> -static int fd_CDB_read_non_SG(struct se_task *task, u32 size)
> -{
> - struct fd_request *req = FILE_REQ(task);
> -
> - req->fd_data_direction = FD_DATA_READ;
> - fd_map_task_non_SG(task);
> -
> - return 0;
> -}
> -
> -/* fd_CDB_read_SG):
> - *
> - *
> - */
> -static int fd_CDB_read_SG(struct se_task *task, u32 size)
> -{
> - struct fd_request *req = FILE_REQ(task);
> -
> - req->fd_data_direction = FD_DATA_READ;
> - fd_map_task_SG(task);
> -
> - return req->fd_sg_count;
> -}
> -
> -/* fd_CDB_write_non_SG():
> - *
> - *
> - */
> -static int fd_CDB_write_non_SG(struct se_task *task, u32 size)
> -{
> - struct fd_request *req = FILE_REQ(task);
> -
> - req->fd_data_direction = FD_DATA_WRITE;
> - fd_map_task_non_SG(task);
> -
> - return 0;
> -}
> -
> -/* fd_CDB_write_SG():
> - *
> - *
> - */
> -static int fd_CDB_write_SG(struct se_task *task, u32 size)
> -{
> - struct fd_request *req = FILE_REQ(task);
> -
> - req->fd_data_direction = FD_DATA_WRITE;
> - fd_map_task_SG(task);
> -
> - return req->fd_sg_count;
> -}
> -
> /* fd_check_lba():
> *
> *
> @@ -830,17 +650,6 @@ static int fd_check_lba(unsigned long lo
> return 0;
> }
>
> -/* fd_check_for_SG(): (Part of se_subsystem_api_t template)
> - *
> - *
> - */
> -static int fd_check_for_SG(struct se_task *task)
> -{
> - struct fd_request *req = FILE_REQ(task);
> -
> - return req->fd_sg_count;
> -}
> -
> /* fd_get_cdb(): (Part of se_subsystem_api_t template)
> *
> *
> @@ -895,11 +704,6 @@ static struct se_subsystem_api fileio_te
> .transport_type = TRANSPORT_PLUGIN_VHBA_PDEV,
> .attach_hba = fd_attach_hba,
> .detach_hba = fd_detach_hba,
> - .cdb_none = fd_CDB_none,
> - .cdb_read_non_SG = fd_CDB_read_non_SG,
> - .cdb_read_SG = fd_CDB_read_SG,
> - .cdb_write_non_SG = fd_CDB_write_non_SG,
> - .cdb_write_SG = fd_CDB_write_SG,
> .allocate_virtdevice = fd_allocate_virtdevice,
> .create_virtdevice = fd_create_virtdevice,
> .free_device = fd_free_device,
> @@ -918,7 +722,6 @@ static struct se_subsystem_api fileio_te
> .get_plugin_info = fd_get_plugin_info,
> .get_hba_info = fd_get_hba_info,
> .check_lba = fd_check_lba,
> - .check_for_SG = fd_check_for_SG,
> .get_cdb = fd_get_cdb,
> .get_device_rev = fd_get_device_rev,
> .get_device_type = fd_get_device_type,
> Index: lio-core/drivers/target/target_core_file.h
> ===================================================================
> --- lio-core.orig/drivers/target/target_core_file.h 2010-11-16 10:33:03.125004403 +0100
> +++ lio-core/drivers/target/target_core_file.h 2010-11-16 10:34:05.928032340 +0100
> @@ -11,10 +11,6 @@
> #define FD_BLOCKSIZE 512
> #define FD_MAX_SECTORS 1024
>
> -#define FD_DATA_READ 1
> -#define FD_DATA_WRITE 2
> -#define FD_DATA_NONE 3
> -
> extern struct se_global *se_global;
>
> #define RRF_EMULATE_CDB 0x01
> @@ -24,26 +20,6 @@ struct fd_request {
> struct se_task fd_task;
> /* SCSI CDB from iSCSI Command PDU */
> unsigned char fd_scsi_cdb[TCM_MAX_COMMAND_SIZE];
> - /* Data Direction */
> - u8 fd_data_direction;
> - /* Total length of request */
> - u32 fd_bufflen;
> - /* RD request flags */
> - u32 fd_req_flags;
> - /* Offset from start of page */
> - u32 fd_offset;
> - u32 fd_cur_size;
> - u32 fd_cur_offset;
> - /* Scatterlist count */
> - u32 fd_sg_count;
> - /* Logical Block Address */
> - unsigned long long fd_lba;
> - u64 fd_size;
> - struct kiocb fd_iocb;
> - struct iovec *fd_iovs;
> - /* Data buffer containing scatterlists(s) or contingous
> - memory segments */
> - void *fd_buf;
> /* FILEIO device */
> struct fd_dev *fd_dev;
> } ____cacheline_aligned;
> @@ -65,8 +41,6 @@ struct fd_dev {
> struct file *fd_file;
> /* FILEIO HBA device is connected to */
> struct fd_host *fd_host;
> - int (*fd_do_read)(struct fd_request *, struct se_task *);
> - int (*fd_do_write)(struct fd_request *, struct se_task *);
> } ____cacheline_aligned;
>
> struct fd_host {
> Index: lio-core/drivers/target/target_core_iblock.c
> ===================================================================
> --- lio-core.orig/drivers/target/target_core_iblock.c 2010-11-16 10:33:03.134004613 +0100
> +++ lio-core/drivers/target/target_core_iblock.c 2010-11-16 12:26:33.202041352 +0100
> @@ -412,7 +412,7 @@ static int iblock_do_task(struct se_task
> struct bio *bio = req->ib_bio, *nbio = NULL;
> int rw;
>
> - if (TASK_CMD(task)->data_direction == DMA_TO_DEVICE) {
> + if (task->task_data_direction == DMA_TO_DEVICE) {
> /*
> * Force data to disk if we pretend to not have a volatile
> * write cache, or the initiator set the Force Unit Access bit.
> @@ -710,7 +710,7 @@ again:
> " %u\n", task, bio->bi_vcnt);
> }
>
> - return task->task_sg_num;
> + return 0;
> fail:
> while (hbio) {
> bio = hbio;
> @@ -721,41 +721,11 @@ fail:
> return ret;
> }
>
> -static int iblock_CDB_none(struct se_task *task, u32 size)
> -{
> - return 0;
> -}
> -
> -static int iblock_CDB_read_non_SG(struct se_task *task, u32 size)
> -{
> - return 0;
> -}
> -
> -static int iblock_CDB_read_SG(struct se_task *task, u32 size)
> -{
> - return iblock_map_task_SG(task);
> -}
> -
> -static int iblock_CDB_write_non_SG(struct se_task *task, u32 size)
> -{
> - return 0;
> -}
> -
> -static int iblock_CDB_write_SG(struct se_task *task, u32 size)
> -{
> - return iblock_map_task_SG(task);
> -}
> -
> static int iblock_check_lba(unsigned long long lba, struct se_device *dev)
> {
> return 0;
> }
>
> -static int iblock_check_for_SG(struct se_task *task)
> -{
> - return task->task_sg_num;
> -}
> -
> static unsigned char *iblock_get_cdb(struct se_task *task)
> {
> return IBLOCK_REQ(task)->ib_scsi_cdb;
> @@ -838,11 +808,7 @@ static struct se_subsystem_api iblock_te
> .owner = THIS_MODULE,
> .type = IBLOCK,
> .transport_type = TRANSPORT_PLUGIN_VHBA_PDEV,
> - .cdb_none = iblock_CDB_none,
> - .cdb_read_non_SG = iblock_CDB_read_non_SG,
> - .cdb_read_SG = iblock_CDB_read_SG,
> - .cdb_write_non_SG = iblock_CDB_write_non_SG,
> - .cdb_write_SG = iblock_CDB_write_SG,
> + .map_task_SG = iblock_map_task_SG,
> .attach_hba = iblock_attach_hba,
> .detach_hba = iblock_detach_hba,
> .allocate_virtdevice = iblock_allocate_virtdevice,
> @@ -864,7 +830,6 @@ static struct se_subsystem_api iblock_te
> .get_plugin_info = iblock_get_plugin_info,
> .get_hba_info = iblock_get_hba_info,
> .check_lba = iblock_check_lba,
> - .check_for_SG = iblock_check_for_SG,
> .get_cdb = iblock_get_cdb,
> .get_device_rev = iblock_get_device_rev,
> .get_device_type = iblock_get_device_type,
> Index: lio-core/drivers/target/target_core_iblock.h
> ===================================================================
> --- lio-core.orig/drivers/target/target_core_iblock.h 2010-11-16 10:33:03.142010829 +0100
> +++ lio-core/drivers/target/target_core_iblock.h 2010-11-16 10:34:05.936022143 +0100
> @@ -16,8 +16,6 @@ struct iblock_req {
> unsigned char ib_scsi_cdb[TCM_MAX_COMMAND_SIZE];
> atomic_t ib_bio_cnt;
> atomic_t ib_bio_err_cnt;
> - u32 ib_sg_count;
> - void *ib_buf;
> struct bio *ib_bio;
> struct iblock_dev *ib_dev;
> } ____cacheline_aligned;
> Index: lio-core/drivers/target/target_core_rd.c
> ===================================================================
> --- lio-core.orig/drivers/target/target_core_rd.c 2010-11-16 10:34:05.085260863 +0100
> +++ lio-core/drivers/target/target_core_rd.c 2010-11-16 12:27:09.238272596 +0100
> @@ -394,6 +394,7 @@ static struct rd_dev_sg_table *rd_get_sg
> */
> static int rd_MEMCPY_read(struct rd_request *req)
> {
> + struct se_task *task = &req->rd_task;
> struct rd_dev *dev = req->rd_dev;
> struct rd_dev_sg_table *table;
> struct scatterlist *sg_d, *sg_s;
> @@ -407,11 +408,11 @@ static int rd_MEMCPY_read(struct rd_requ
> return -1;
>
> table_sg_end = (table->page_end_offset - req->rd_page);
> - sg_d = req->rd_buf;
> + sg_d = task->task_sg;
> sg_s = &table->sg_table[req->rd_page - table->page_start_offset];
> #ifdef DEBUG_RAMDISK_MCP
> printk(KERN_INFO "RD[%u]: Read LBA: %llu, Size: %u Page: %u, Offset:"
> - " %u\n", dev->rd_dev_id, req->rd_lba, req->rd_size,
> + " %u\n", dev->rd_dev_id, task->task_lba, req->rd_size,
> req->rd_page, req->rd_offset);
> #endif
> src_offset = rd_offset;
> @@ -516,6 +517,7 @@ static int rd_MEMCPY_read(struct rd_requ
> */
> static int rd_MEMCPY_write(struct rd_request *req)
> {
> + struct se_task *task = &req->rd_task;
> struct rd_dev *dev = req->rd_dev;
> struct rd_dev_sg_table *table;
> struct scatterlist *sg_d, *sg_s;
> @@ -530,10 +532,10 @@ static int rd_MEMCPY_write(struct rd_req
>
> table_sg_end = (table->page_end_offset - req->rd_page);
> sg_d = &table->sg_table[req->rd_page - table->page_start_offset];
> - sg_s = req->rd_buf;
> + sg_s = task->task_sg;
> #ifdef DEBUG_RAMDISK_MCP
> printk(KERN_INFO "RD[%d] Write LBA: %llu, Size: %u, Page: %u,"
> - " Offset: %u\n", dev->rd_dev_id, req->rd_lba, req->rd_size,
> + " Offset: %u\n", dev->rd_dev_id, task->task_lba, req->rd_size,
> req->rd_page, req->rd_offset);
> #endif
> dst_offset = rd_offset;
> @@ -640,16 +642,17 @@ static int rd_MEMCPY_do_task(struct se_t
> {
> struct se_device *dev = task->se_dev;
> struct rd_request *req = RD_REQ(task);
> + unsigned long long lba;
> int ret;
>
> - req->rd_lba = task->task_lba;
> - req->rd_page = (req->rd_lba * DEV_ATTRIB(dev)->block_size) / PAGE_SIZE;
> - req->rd_offset = (do_div(req->rd_lba,
> + req->rd_page = (task->task_lba * DEV_ATTRIB(dev)->block_size) / PAGE_SIZE;
> + lba = task->task_lba;
> + req->rd_offset = (do_div(lba,
> (PAGE_SIZE / DEV_ATTRIB(dev)->block_size))) *
> DEV_ATTRIB(dev)->block_size;
> req->rd_size = task->task_size;
>
> - if (req->rd_data_direction == RD_DATA_READ)
> + if (task->task_data_direction == DMA_FROM_DEVICE)
> ret = rd_MEMCPY_read(req);
> else
> ret = rd_MEMCPY_write(req);
> @@ -689,8 +692,9 @@ static int rd_DIRECT_with_offset(
> sg_s = &table->sg_table[req->rd_page - table->page_start_offset];
> #ifdef DEBUG_RAMDISK_DR
> printk(KERN_INFO "%s DIRECT LBA: %llu, Size: %u Page: %u, Offset: %u\n",
> - (req->rd_data_direction != RD_DATA_READ) ? "Write" : "Read",
> - req->rd_lba, req->rd_size, req->rd_page, req->rd_offset);
> + (task->task_data_direction == DMA_TO_DEVICE) ?
> + "Write" : "Read",
> + task->task_lba, req->rd_size, req->rd_page, req->rd_offset);
> #endif
> while (req->rd_size) {
> se_mem = kmem_cache_zalloc(se_mem_cache, GFP_KERNEL);
> @@ -790,8 +794,9 @@ static int rd_DIRECT_without_offset(
> sg_s = &table->sg_table[req->rd_page - table->page_start_offset];
> #ifdef DEBUG_RAMDISK_DR
> printk(KERN_INFO "%s DIRECT LBA: %llu, Size: %u, Page: %u\n",
> - (req->rd_data_direction != RD_DATA_READ) ? "Write" : "Read",
> - req->rd_lba, req->rd_size, req->rd_page);
> + (task->task_data_direction == DMA_TO_DEVICE) ?
> + "Write" : "Read",
> + task->task_lba, req->rd_size, req->rd_page);
> #endif
> while (req->rd_size) {
> se_mem = kmem_cache_zalloc(se_mem_cache, GFP_KERNEL);
> @@ -863,13 +868,13 @@ static int rd_DIRECT_do_se_mem_map(
> struct se_cmd *cmd = task->task_se_cmd;
> struct rd_request *req = RD_REQ(task);
> u32 task_offset = *task_offset_in;
> + unsigned long long lba;
> int ret;
>
> - req->rd_lba = task->task_lba;
> - req->rd_req_flags = RRF_GOT_LBA;
> - req->rd_page = ((req->rd_lba * DEV_ATTRIB(task->se_dev)->block_size) /
> + req->rd_page = ((task->task_lba * DEV_ATTRIB(task->se_dev)->block_size) /
> PAGE_SIZE);
> - req->rd_offset = (do_div(req->rd_lba,
> + lba = task->task_lba;
> + req->rd_offset = (do_div(lba,
> (PAGE_SIZE / DEV_ATTRIB(task->se_dev)->block_size))) *
> DEV_ATTRIB(task->se_dev)->block_size;
> req->rd_size = task->task_size;
> @@ -1032,105 +1037,6 @@ static ssize_t rd_show_configfs_dev_para
> return bl;
> }
>
> -/* rd_map_task_non_SG():
> - *
> - *
> - */
> -static void rd_map_task_non_SG(struct se_task *task)
> -{
> - struct se_cmd *cmd = TASK_CMD(task);
> - struct rd_request *req = RD_REQ(task);
> -
> - req->rd_bufflen = task->task_size;
> - req->rd_buf = (void *) T_TASK(cmd)->t_task_buf;
> - req->rd_sg_count = 0;
> -}
> -
> -/* rd_map_task_SG():
> - *
> - *
> - */
> -static void rd_map_task_SG(struct se_task *task)
> -{
> - struct rd_request *req = RD_REQ(task);
> -
> - req->rd_bufflen = task->task_size;
> - req->rd_buf = task->task_sg;
> - req->rd_sg_count = task->task_sg_num;
> -}
> -
> -/* rd_CDB_none():
> - *
> - *
> - */
> -static int rd_CDB_none(struct se_task *task, u32 size)
> -{
> - struct rd_request *req = RD_REQ(task);
> -
> - req->rd_data_direction = RD_DATA_NONE;
> - req->rd_bufflen = 0;
> - req->rd_sg_count = 0;
> - req->rd_buf = NULL;
> -
> - return 0;
> -}
> -
> -/* rd_CDB_read_non_SG():
> - *
> - *
> - */
> -static int rd_CDB_read_non_SG(struct se_task *task, u32 size)
> -{
> - struct rd_request *req = RD_REQ(task);
> -
> - req->rd_data_direction = RD_DATA_READ;
> - rd_map_task_non_SG(task);
> -
> - return 0;
> -}
> -
> -/* rd_CDB_read_SG):
> - *
> - *
> - */
> -static int rd_CDB_read_SG(struct se_task *task, u32 size)
> -{
> - struct rd_request *req = RD_REQ(task);
> -
> - req->rd_data_direction = RD_DATA_READ;
> - rd_map_task_SG(task);
> -
> - return req->rd_sg_count;
> -}
> -
> -/* rd_CDB_write_non_SG():
> - *
> - *
> - */
> -static int rd_CDB_write_non_SG(struct se_task *task, u32 size)
> -{
> - struct rd_request *req = RD_REQ(task);
> -
> - req->rd_data_direction = RD_DATA_WRITE;
> - rd_map_task_non_SG(task);
> -
> - return 0;
> -}
> -
> -/* d_CDB_write_SG():
> - *
> - *
> - */
> -static int rd_CDB_write_SG(struct se_task *task, u32 size)
> -{
> - struct rd_request *req = RD_REQ(task);
> -
> - req->rd_data_direction = RD_DATA_WRITE;
> - rd_map_task_SG(task);
> -
> - return req->rd_sg_count;
> -}
> -
> /* rd_DIRECT_check_lba():
> *
> *
> @@ -1150,17 +1056,6 @@ static int rd_MEMCPY_check_lba(unsigned
> return 0;
> }
>
> -/* rd_check_for_SG(): (Part of se_subsystem_api_t template)
> - *
> - *
> - */
> -static int rd_check_for_SG(struct se_task *task)
> -{
> - struct rd_request *req = RD_REQ(task);
> -
> - return req->rd_sg_count;
> -}
> -
> /* rd_get_cdb(): (Part of se_subsystem_api_t template)
> *
> *
> @@ -1204,11 +1099,6 @@ static struct se_subsystem_api rd_dr_tem
> .name = "rd_dr",
> .type = RAMDISK_DR,
> .transport_type = TRANSPORT_PLUGIN_VHBA_VDEV,
> - .cdb_none = rd_CDB_none,
> - .cdb_read_non_SG = rd_CDB_read_non_SG,
> - .cdb_read_SG = rd_CDB_read_SG,
> - .cdb_write_non_SG = rd_CDB_write_non_SG,
> - .cdb_write_SG = rd_CDB_write_SG,
> .attach_hba = rd_attach_hba,
> .detach_hba = rd_detach_hba,
> .allocate_virtdevice = rd_DIRECT_allocate_virtdevice,
> @@ -1224,7 +1114,6 @@ static struct se_subsystem_api rd_dr_tem
> .get_plugin_info = rd_dr_get_plugin_info,
> .get_hba_info = rd_get_hba_info,
> .check_lba = rd_DIRECT_check_lba,
> - .check_for_SG = rd_check_for_SG,
> .get_cdb = rd_get_cdb,
> .get_device_rev = rd_get_device_rev,
> .get_device_type = rd_get_device_type,
> @@ -1237,11 +1126,6 @@ static struct se_subsystem_api rd_mcp_te
> .name = "rd_mcp",
> .type = RAMDISK_MCP,
> .transport_type = TRANSPORT_PLUGIN_VHBA_VDEV,
> - .cdb_none = rd_CDB_none,
> - .cdb_read_non_SG = rd_CDB_read_non_SG,
> - .cdb_read_SG = rd_CDB_read_SG,
> - .cdb_write_non_SG = rd_CDB_write_non_SG,
> - .cdb_write_SG = rd_CDB_write_SG,
> .attach_hba = rd_attach_hba,
> .detach_hba = rd_detach_hba,
> .allocate_virtdevice = rd_MEMCPY_allocate_virtdevice,
> @@ -1257,7 +1141,6 @@ static struct se_subsystem_api rd_mcp_te
> .get_plugin_info = rd_mcp_get_plugin_info,
> .get_hba_info = rd_get_hba_info,
> .check_lba = rd_MEMCPY_check_lba,
> - .check_for_SG = rd_check_for_SG,
> .get_cdb = rd_get_cdb,
> .get_device_rev = rd_get_device_rev,
> .get_device_type = rd_get_device_type,
> Index: lio-core/drivers/target/target_core_rd.h
> ===================================================================
> --- lio-core.orig/drivers/target/target_core_rd.h 2010-11-16 10:33:03.158012295 +0100
> +++ lio-core/drivers/target/target_core_rd.h 2010-11-16 10:34:05.947005241 +0100
> @@ -14,10 +14,6 @@
> #define RD_BLOCKSIZE 512
> #define RD_MAX_SECTORS 1024
>
> -#define RD_DATA_READ 1
> -#define RD_DATA_WRITE 2
> -#define RD_DATA_NONE 3
> -
> extern struct se_global *se_global;
>
> extern struct kmem_cache *se_mem_cache;
> @@ -34,12 +30,6 @@ struct rd_request {
>
> /* SCSI CDB from iSCSI Command PDU */
> unsigned char rd_scsi_cdb[TCM_MAX_COMMAND_SIZE];
> - /* Data Direction */
> - u8 rd_data_direction;
> - /* Total length of request */
> - u32 rd_bufflen;
> - /* RD request flags */
> - u32 rd_req_flags;
> /* Offset from start of page */
> u32 rd_offset;
> /* Starting page in Ramdisk for request */
> @@ -47,13 +37,7 @@ struct rd_request {
> /* Total number of pages needed for request */
> u32 rd_page_count;
> /* Scatterlist count */
> - u32 rd_sg_count;
> u32 rd_size;
> - /* Logical Block Address */
> - unsigned long long rd_lba;
> - /* Data buffer containing scatterlists(s) or
> - * contiguous memory segments */
> - void *rd_buf;
> /* Ramdisk device */
> struct rd_dev *rd_dev;
> } ____cacheline_aligned;
> Index: lio-core/drivers/target/target_core_stgt.c
> ===================================================================
> --- lio-core.orig/drivers/target/target_core_stgt.c 2010-11-16 10:33:03.167012645 +0100
> +++ lio-core/drivers/target/target_core_stgt.c 2010-11-16 12:27:23.619005311 +0100
> @@ -383,7 +383,8 @@ static int stgt_do_task(struct se_task *
> struct scsi_cmnd *sc;
> int tag = MSG_SIMPLE_TAG;
>
> - sc = scsi_host_get_command(sh, st->stgt_direction, GFP_KERNEL);
> + sc = scsi_host_get_command(sh, task->task_data_direction,
> + GFP_KERNEL);
> if (!sc) {
> printk(KERN_ERR "Unable to allocate memory for struct"
> " scsi_cmnd\n");
> @@ -532,88 +533,6 @@ static ssize_t stgt_show_configfs_dev_pa
> return bl;
> }
>
> -/* stgt_map_task_SG():
> - *
> - *
> - */
> -static int stgt_map_task_SG(struct se_task *task)
> -{
> - return 0;
> -}
> -
> -/* stgt_map_task_non_SG():
> - *
> - *
> - */
> -static int stgt_map_task_non_SG(struct se_task *task)
> -{
> - return 0;
> -}
> -
> -static int stgt_CDB_none(struct se_task *task, u32 size)
> -{
> - struct stgt_plugin_task *pt = STGT_TASK(task);
> -
> - pt->stgt_direction = DMA_NONE;
> - return 0;
> -}
> -
> -/* stgt_CDB_read_non_SG():
> - *
> - *
> - */
> -static int stgt_CDB_read_non_SG(struct se_task *task, u32 size)
> -{
> - struct stgt_plugin_task *pt = STGT_TASK(task);
> -
> - pt->stgt_direction = DMA_FROM_DEVICE;
> - return stgt_map_task_non_SG(task);
> -}
> -
> -/* stgt_CDB_read_SG():
> - *
> - *
> - */
> -static int stgt_CDB_read_SG(struct se_task *task, u32 size)
> -{
> - struct stgt_plugin_task *pt = STGT_TASK(task);
> -
> - pt->stgt_direction = DMA_FROM_DEVICE;
> -
> - if (stgt_map_task_SG(task) < 0)
> - return PYX_TRANSPORT_LU_COMM_FAILURE;
> -
> - return task->task_sg_num;
> -}
> -
> -/* stgt_CDB_write_non_SG():
> - *
> - *
> - */
> -static int stgt_CDB_write_non_SG(struct se_task *task, u32 size)
> -{
> - struct stgt_plugin_task *pt = STGT_TASK(task);
> -
> - pt->stgt_direction = DMA_TO_DEVICE;
> - return stgt_map_task_non_SG(task);
> -}
> -
> -/* stgt_CDB_write_SG():
> - *
> - *
> - */
> -static int stgt_CDB_write_SG(struct se_task *task, u32 size)
> -{
> - struct stgt_plugin_task *pt = STGT_TASK(task);
> -
> - pt->stgt_direction = DMA_TO_DEVICE;
> -
> - if (stgt_map_task_SG(task) < 0)
> - return PYX_TRANSPORT_LU_COMM_FAILURE;
> -
> - return task->task_sg_num;
> -}
> -
> /* stgt_check_lba():
> *
> *
> @@ -623,15 +542,6 @@ static int stgt_check_lba(unsigned long
> return 0;
> }
>
> -/* stgt_check_for_SG():
> - *
> - *
> - */
> -static int stgt_check_for_SG(struct se_task *task)
> -{
> - return task->task_sg_num;
> -}
> -
> /* stgt_get_cdb():
> *
> *
> @@ -758,11 +668,6 @@ static struct se_subsystem_api stgt_temp
> .owner = THIS_MODULE,
> .type = STGT,
> .transport_type = TRANSPORT_PLUGIN_VHBA_PDEV,
> - .cdb_none = stgt_CDB_none,
> - .cdb_read_non_SG = stgt_CDB_read_non_SG,
> - .cdb_read_SG = stgt_CDB_read_SG,
> - .cdb_write_non_SG = stgt_CDB_write_non_SG,
> - .cdb_write_SG = stgt_CDB_write_SG,
> .attach_hba = stgt_attach_hba,
> .detach_hba = stgt_detach_hba,
> .allocate_virtdevice = stgt_allocate_virtdevice,
> @@ -780,7 +685,6 @@ static struct se_subsystem_api stgt_temp
> .get_plugin_info = stgt_get_plugin_info,
> .get_hba_info = stgt_get_hba_info,
> .check_lba = stgt_check_lba,
> - .check_for_SG = stgt_check_for_SG,
> .get_cdb = stgt_get_cdb,
> .get_sense_buffer = stgt_get_sense_buffer,
> .get_device_rev = stgt_get_device_rev,
> Index: lio-core/drivers/target/target_core_pscsi.c
> ===================================================================
> --- lio-core.orig/drivers/target/target_core_pscsi.c 2010-11-16 10:33:03.175004194 +0100
> +++ lio-core/drivers/target/target_core_pscsi.c 2010-11-16 12:28:04.905004752 +0100
> @@ -741,7 +741,8 @@ static int pscsi_blk_get_request(struct
> struct pscsi_dev_virt *pdv = task->se_dev->dev_ptr;
>
> pt->pscsi_req = blk_get_request(pdv->pdv_sd->request_queue,
> - (pt->pscsi_direction == DMA_TO_DEVICE), GFP_KERNEL);
> + (task->task_data_direction == DMA_TO_DEVICE),
> + GFP_KERNEL);
> if (!(pt->pscsi_req) || IS_ERR(pt->pscsi_req)) {
> printk(KERN_ERR "PSCSI: blk_get_request() failed: %ld\n",
> IS_ERR(pt->pscsi_req));
> @@ -1015,7 +1016,7 @@ static int __pscsi_map_task_SG(
> int nr_pages = (task->task_size + task_sg[0].offset +
> PAGE_SIZE - 1) >> PAGE_SHIFT;
> int nr_vecs = 0, rc, ret = PYX_TRANSPORT_OUT_OF_MEMORY_RESOURCES;
> - int rw = (TASK_CMD(task)->data_direction == DMA_TO_DEVICE);
> + int rw = (task->task_data_direction == DMA_TO_DEVICE);
>
> if (!task->task_size)
> return 0;
> @@ -1152,22 +1153,24 @@ fail:
> static int pscsi_map_task_SG(struct se_task *task)
> {
> int ret;
> +
> /*
> * Setup the main struct request for the task->task_sg[] payload
> */
>
> ret = __pscsi_map_task_SG(task, task->task_sg, task->task_sg_num, 0);
> - if (ret < 0)
> - return ret;
> + if (ret >= 0 && task->task_sg_bidi) {
> + /*
> + * If present, set up the extra BIDI-COMMAND SCSI READ
> + * struct request and payload.
> + */
> + ret = __pscsi_map_task_SG(task, task->task_sg_bidi,
> + task->task_sg_num, 1);
> + }
>
> - if (!(task->task_sg_bidi))
> - return ret;
> - /*
> - * If present, set up the extra BIDI-COMMAND SCSI READ
> - * struct request and payload.
> - */
> - return __pscsi_map_task_SG(task, task->task_sg_bidi,
> - task->task_sg_num, 1);
> + if (ret < 0)
> + return PYX_TRANSPORT_LU_COMM_FAILURE;
> + return 0;
> }
>
> /* pscsi_map_task_non_SG():
> @@ -1181,6 +1184,9 @@ static int pscsi_map_task_non_SG(struct
> struct pscsi_dev_virt *pdv = task->se_dev->dev_ptr;
> int ret = 0;
>
> + if (pscsi_blk_get_request(task) < 0)
> + return PYX_TRANSPORT_LU_COMM_FAILURE;
> +
> if (!task->task_size)
> return 0;
>
> @@ -1194,85 +1200,11 @@ static int pscsi_map_task_non_SG(struct
> return 0;
> }
>
> -static int pscsi_CDB_none(struct se_task *task, u32 size)
> +static int pscsi_CDB_none(struct se_task *task)
> {
> - struct pscsi_plugin_task *pt = PSCSI_TASK(task);
> -
> - pt->pscsi_direction = DMA_NONE;
> -
> return pscsi_blk_get_request(task);
> }
>
> -/* pscsi_CDB_read_non_SG():
> - *
> - *
> - */
> -static int pscsi_CDB_read_non_SG(struct se_task *task, u32 size)
> -{
> - struct pscsi_plugin_task *pt = PSCSI_TASK(task);
> -
> - pt->pscsi_direction = DMA_FROM_DEVICE;
> -
> - if (pscsi_blk_get_request(task) < 0)
> - return PYX_TRANSPORT_LU_COMM_FAILURE;
> -
> - return pscsi_map_task_non_SG(task);
> -}
> -
> -/* pscsi_CDB_read_SG():
> - *
> - *
> - */
> -static int pscsi_CDB_read_SG(struct se_task *task, u32 size)
> -{
> - struct pscsi_plugin_task *pt = PSCSI_TASK(task);
> -
> - pt->pscsi_direction = DMA_FROM_DEVICE;
> - /*
> - * pscsi_map_task_SG() calls block/blk-core.c:blk_make_request()
> - * for >= v2.6.31 pSCSI
> - */
> - if (pscsi_map_task_SG(task) < 0)
> - return PYX_TRANSPORT_LU_COMM_FAILURE;
> -
> - return task->task_sg_num;
> -}
> -
> -/* pscsi_CDB_write_non_SG():
> - *
> - *
> - */
> -static int pscsi_CDB_write_non_SG(struct se_task *task, u32 size)
> -{
> - struct pscsi_plugin_task *pt = PSCSI_TASK(task);
> -
> - pt->pscsi_direction = DMA_TO_DEVICE;
> -
> - if (pscsi_blk_get_request(task) < 0)
> - return PYX_TRANSPORT_LU_COMM_FAILURE;
> -
> - return pscsi_map_task_non_SG(task);
> -}
> -
> -/* pscsi_CDB_write_SG():
> - *
> - *
> - */
> -static int pscsi_CDB_write_SG(struct se_task *task, u32 size)
> -{
> - struct pscsi_plugin_task *pt = PSCSI_TASK(task);
> -
> - pt->pscsi_direction = DMA_TO_DEVICE;
> - /*
> - * pscsi_map_task_SG() calls block/blk-core.c:blk_make_request()
> - * for >= v2.6.31 pSCSI
> - */
> - if (pscsi_map_task_SG(task) < 0)
> - return PYX_TRANSPORT_LU_COMM_FAILURE;
> -
> - return task->task_sg_num;
> -}
> -
> /* pscsi_check_lba():
> *
> *
> @@ -1282,15 +1214,6 @@ static int pscsi_check_lba(unsigned long
> return 0;
> }
>
> -/* pscsi_check_for_SG():
> - *
> - *
> - */
> -static int pscsi_check_for_SG(struct se_task *task)
> -{
> - return task->task_sg_num;
> -}
> -
> /* pscsi_get_cdb():
> *
> *
> @@ -1406,10 +1329,8 @@ static struct se_subsystem_api pscsi_tem
> .type = PSCSI,
> .transport_type = TRANSPORT_PLUGIN_PHBA_PDEV,
> .cdb_none = pscsi_CDB_none,
> - .cdb_read_non_SG = pscsi_CDB_read_non_SG,
> - .cdb_read_SG = pscsi_CDB_read_SG,
> - .cdb_write_non_SG = pscsi_CDB_write_non_SG,
> - .cdb_write_SG = pscsi_CDB_write_SG,
> + .map_task_non_SG = pscsi_map_task_non_SG,
> + .map_task_SG = pscsi_map_task_SG,
> .attach_hba = pscsi_attach_hba,
> .detach_hba = pscsi_detach_hba,
> .pmode_enable_hba = pscsi_pmode_enable_hba,
> @@ -1426,7 +1347,6 @@ static struct se_subsystem_api pscsi_tem
> .get_plugin_info = pscsi_get_plugin_info,
> .get_hba_info = pscsi_get_hba_info,
> .check_lba = pscsi_check_lba,
> - .check_for_SG = pscsi_check_for_SG,
> .get_cdb = pscsi_get_cdb,
> .get_sense_buffer = pscsi_get_sense_buffer,
> .get_device_rev = pscsi_get_device_rev,
> Index: lio-core/drivers/target/target_core_stgt.h
> ===================================================================
> --- lio-core.orig/drivers/target/target_core_stgt.h 2010-11-16 10:33:03.184012435 +0100
> +++ lio-core/drivers/target/target_core_stgt.h 2010-11-16 10:34:05.966264356 +0100
> @@ -23,7 +23,6 @@ struct stgt_plugin_task {
> struct se_task stgt_task;
> unsigned char stgt_cdb[TCM_MAX_COMMAND_SIZE];
> unsigned char stgt_sense[SCSI_SENSE_BUFFERSIZE];
> - int stgt_direction;
> int stgt_result;
> u32 stgt_resid;
> struct scsi_cmnd *stgt_cmd;
> Index: lio-core/include/target/target_core_transport.h
> ===================================================================
> --- lio-core.orig/include/target/target_core_transport.h 2010-11-16 10:34:05.083275321 +0100
> +++ lio-core/include/target/target_core_transport.h 2010-11-16 10:34:05.973004473 +0100
> @@ -303,23 +303,15 @@ struct se_subsystem_api {
> /*
> * For SCF_SCSI_NON_DATA_CDB
> */
> - int (*cdb_none)(struct se_task *, u32);
> + int (*cdb_none)(struct se_task *);
> /*
> - * For READ SCF_SCSI_CONTROL_NONSG_IO_CDB
> + * For SCF_SCSI_CONTROL_NONSG_IO_CDB
> */
> - int (*cdb_read_non_SG)(struct se_task *, u32);
> + int (*map_task_non_SG)(struct se_task *);
> /*
> - * For READ SCF_SCSI_DATA_SG_IO_CDB and SCF_SCSI_CONTROL_SG_IO_CDB
> + * For SCF_SCSI_DATA_SG_IO_CDB and SCF_SCSI_CONTROL_SG_IO_CDB
> */
> - int (*cdb_read_SG)(struct se_task *, u32);
> - /*
> - * For WRITE SCF_SCSI_CONTROL_NONSG_IO_CDB
> - */
> - int (*cdb_write_non_SG)(struct se_task *, u32);
> - /*
> - * For WRITE SCF_SCSI_DATA_SG_IO_CDB and SCF_SCSI_CONTROL_SG_IO_CDB
> - */
> - int (*cdb_write_SG)(struct se_task *, u32);
> + int (*map_task_SG)(struct se_task *);
> /*
> * attach_hba():
> */
> @@ -438,10 +430,6 @@ struct se_subsystem_api {
> */
> int (*check_lba)(unsigned long long lba, struct se_device *);
> /*
> - * check_for_SG():
> - */
> - int (*check_for_SG)(struct se_task *);
> - /*
> * get_cdb():
> */
> unsigned char *(*get_cdb)(struct se_task *);
> Index: lio-core/drivers/target/target_core_transport.c
> ===================================================================
> --- lio-core.orig/drivers/target/target_core_transport.c 2010-11-16 10:34:05.081254089 +0100
> +++ lio-core/drivers/target/target_core_transport.c 2010-11-16 12:30:12.831254579 +0100
> @@ -2257,6 +2257,7 @@ static struct se_task *transport_generic
> task->task_no = T_TASK(cmd)->t_tasks_no++;
> task->task_se_cmd = cmd;
> task->se_dev = dev;
> + task->task_data_direction = data_direction;
>
> DEBUG_SO("se_obj_ptr: %p\n", se_obj_ptr);
>
> @@ -2269,28 +2270,6 @@ static struct se_task *transport_generic
> return task;
> }
>
> -static inline map_func_t transport_dev_get_map_SG(
> - struct se_device *dev,
> - int rw)
> -{
> - return (rw == DMA_TO_DEVICE) ? dev->transport->cdb_write_SG :
> - dev->transport->cdb_read_SG;
> -}
> -
> -static inline map_func_t transport_dev_get_map_non_SG(
> - struct se_device *dev,
> - int rw)
> -{
> - return (rw == DMA_TO_DEVICE) ? dev->transport->cdb_write_non_SG :
> - dev->transport->cdb_read_non_SG;
> -}
> -
> -static inline map_func_t transport_dev_get_map_none(
> - struct se_device *dev)
> -{
> - return dev->transport->cdb_none;
> -}
> -
> static int transport_process_data_sg_transform(
> struct se_cmd *cmd,
> struct se_transform_info *ti)
> @@ -2333,8 +2312,7 @@ static int transport_process_control_sg_
> if (!(task))
> return -1;
>
> - task->transport_map_task = transport_dev_get_map_SG(ti->se_obj_ptr,
> - cmd->data_direction);
> + task->transport_map_task = ti->se_obj_ptr->transport->map_task_SG;
>
> cdb = TRANSPORT(dev)->get_cdb(task);
> if (cdb)
> @@ -2375,8 +2353,7 @@ static int transport_process_control_non
> if (!(task))
> return -1;
>
> - task->transport_map_task = transport_dev_get_map_non_SG(ti->se_obj_ptr,
> - cmd->data_direction);
> + task->transport_map_task = ti->se_obj_ptr->transport->map_task_non_SG;
>
> cdb = TRANSPORT(dev)->get_cdb(task);
> if (cdb)
> @@ -2411,7 +2388,7 @@ static int transport_process_non_data_tr
> if (!(task))
> return -1;
>
> - task->transport_map_task = transport_dev_get_map_none(ti->se_obj_ptr);
> + task->transport_map_task = ti->se_obj_ptr->transport->cdb_none;
>
> cdb = TRANSPORT(dev)->get_cdb(task);
> if (cdb)
> @@ -5994,8 +5971,8 @@ u32 transport_generic_get_cdb_count(
> sectors -= task->task_sectors;
> task->task_size = (task->task_sectors *
> DEV_ATTRIB(dev)->block_size);
> - task->transport_map_task = transport_dev_get_map_SG(dev,
> - data_direction);
> +
> + task->transport_map_task = dev->transport->map_task_SG;
>
> cdb = TRANSPORT(dev)->get_cdb(task);
> if ((cdb)) {
> @@ -6139,9 +6116,11 @@ int transport_generic_new_cmd(struct se_
> if (atomic_read(&task->task_sent))
> continue;
>
> - ret = task->transport_map_task(task, task->task_size);
> - if (ret < 0)
> - goto failure;
> + if (task->transport_map_task) {
> + ret = task->transport_map_task(task);
> + if (ret < 0)
> + goto failure;
> + }
> }
>
> /*
> Index: lio-core/include/target/target_core_base.h
> ===================================================================
> --- lio-core.orig/include/target/target_core_base.h 2010-11-16 10:34:05.089004054 +0100
> +++ lio-core/include/target/target_core_base.h 2010-11-16 12:23:24.621013003 +0100
> @@ -488,6 +488,7 @@ struct se_task {
> u32 task_size;
> u32 task_sg_num;
> u32 task_sg_offset;
> + enum dma_data_direction task_data_direction;
> struct se_cmd *task_se_cmd;
> struct se_device *se_dev;
> struct completion task_stop_comp;
> @@ -498,7 +499,7 @@ struct se_task {
> atomic_t task_stop;
> atomic_t task_state_active;
> struct timer_list task_timer;
> - int (*transport_map_task)(struct se_task *, u32);
> + int (*transport_map_task)(struct se_task *);
> struct se_device *se_obj_ptr;
> struct list_head t_list;
> struct list_head t_execute_list;
--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
