[deliverable/linux.git] / drivers / target / target_core_file.c

/*******************************************************************************
 * Filename:  target_core_file.c
 *
 * This file contains the Storage Engine <-> FILEIO transport specific functions
 *
 * Copyright (c) 2005 PyX Technologies, Inc.
 * Copyright (c) 2005-2006 SBE, Inc.  All Rights Reserved.
 * Copyright (c) 2007-2010 Rising Tide Systems
 * Copyright (c) 2008-2010 Linux-iSCSI.org
 *
 * 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/string.h>
#include <linux/parser.h>
#include <linux/timer.h>
#include <linux/blkdev.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/module.h>
#include <scsi/scsi.h>
#include <scsi/scsi_host.h>

#include <target/target_core_base.h>
#include <target/target_core_device.h>
#include <target/target_core_transport.h>

#include "target_core_file.h"

static struct se_subsystem_api fileio_template;

/*	fd_attach_hba(): (Part of se_subsystem_api_t template)
 *
 *
 */
static int fd_attach_hba(struct se_hba *hba, u32 host_id)
{
	struct fd_host *fd_host;

	fd_host = kzalloc(sizeof(struct fd_host), GFP_KERNEL);
	if (!fd_host) {
		pr_err("Unable to allocate memory for struct fd_host\n");
		return -ENOMEM;
	}

	fd_host->fd_host_id = host_id;

	hba->hba_ptr = fd_host;

	pr_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic"
		" Target Core Stack %s\n", hba->hba_id, FD_VERSION,
		TARGET_CORE_MOD_VERSION);
	pr_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic"
		" MaxSectors: %u\n",
		hba->hba_id, fd_host->fd_host_id, FD_MAX_SECTORS);

	return 0;
}

static void fd_detach_hba(struct se_hba *hba)
{
	struct fd_host *fd_host = hba->hba_ptr;

	pr_debug("CORE_HBA[%d] - Detached FILEIO HBA: %u from Generic"
		" Target Core\n", hba->hba_id, fd_host->fd_host_id);

	kfree(fd_host);
	hba->hba_ptr = NULL;
}

static void *fd_allocate_virtdevice(struct se_hba *hba, const char *name)
{
	struct fd_dev *fd_dev;
	struct fd_host *fd_host = (struct fd_host *) hba->hba_ptr;

	fd_dev = kzalloc(sizeof(struct fd_dev), GFP_KERNEL);
	if (!fd_dev) {
		pr_err("Unable to allocate memory for struct fd_dev\n");
		return NULL;
	}

	fd_dev->fd_host = fd_host;

	pr_debug("FILEIO: Allocated fd_dev for %p\n", name);

	return fd_dev;
}

/*	fd_create_virtdevice(): (Part of se_subsystem_api_t template)
 *
 *
 */
static struct se_device *fd_create_virtdevice(
	struct se_hba *hba,
	struct se_subsystem_dev *se_dev,
	void *p)
{
	char *dev_p = NULL;
	struct se_device *dev;
	struct se_dev_limits dev_limits;
	struct queue_limits *limits;
	struct fd_dev *fd_dev = (struct fd_dev *) p;
	struct fd_host *fd_host = (struct fd_host *) hba->hba_ptr;
	mm_segment_t old_fs;
	struct file *file;
	struct inode *inode = NULL;
	int dev_flags = 0, flags, ret = -EINVAL;

	memset(&dev_limits, 0, sizeof(struct se_dev_limits));

	old_fs = get_fs();
	set_fs(get_ds());
	dev_p = getname(fd_dev->fd_dev_name);
	set_fs(old_fs);

	if (IS_ERR(dev_p)) {
		pr_err("getname(%s) failed: %lu\n",
			fd_dev->fd_dev_name, IS_ERR(dev_p));
		ret = PTR_ERR(dev_p);
		goto fail;
	}
#if 0
	if (di->no_create_file)
		flags = O_RDWR | O_LARGEFILE;
	else
		flags = O_RDWR | O_CREAT | O_LARGEFILE;
#else
	flags = O_RDWR | O_CREAT | O_LARGEFILE;
#endif
/*	flags |= O_DIRECT; */
	/*
	 * If fd_buffered_io=1 has not been set explicitly (the default),
	 * use O_SYNC to force FILEIO writes to disk.
	 */
	if (!(fd_dev->fbd_flags & FDBD_USE_BUFFERED_IO))
		flags |= O_SYNC;

	file = filp_open(dev_p, flags, 0600);
	if (IS_ERR(file)) {
		pr_err("filp_open(%s) failed\n", dev_p);
		ret = PTR_ERR(file);
		goto fail;
	}
	if (!file || !file->f_dentry) {
		pr_err("filp_open(%s) failed\n", dev_p);
		goto fail;
	}
	fd_dev->fd_file = file;
	/*
	 * If using a block backend with this struct file, we extract
	 * fd_dev->fd_[block,dev]_size from struct block_device.
	 *
	 * Otherwise, we use the passed fd_size= from configfs
	 */
	inode = file->f_mapping->host;
	if (S_ISBLK(inode->i_mode)) {
		struct request_queue *q;
		/*
		 * Setup the local scope queue_limits from struct request_queue->limits
		 * to pass into transport_add_device_to_core_hba() as struct se_dev_limits.
		 */
		q = bdev_get_queue(inode->i_bdev);
		limits = &dev_limits.limits;
		limits->logical_block_size = bdev_logical_block_size(inode->i_bdev);
		limits->max_hw_sectors = queue_max_hw_sectors(q);
		limits->max_sectors = queue_max_sectors(q);
		/*
		 * Determine the number of bytes from i_size_read() minus
		 * one (1) logical sector from underlying struct block_device
		 */
		fd_dev->fd_block_size = bdev_logical_block_size(inode->i_bdev);
		fd_dev->fd_dev_size = (i_size_read(file->f_mapping->host) -
				       fd_dev->fd_block_size);

		pr_debug("FILEIO: Using size: %llu bytes from struct"
			" block_device blocks: %llu logical_block_size: %d\n",
			fd_dev->fd_dev_size,
			div_u64(fd_dev->fd_dev_size, fd_dev->fd_block_size),
			fd_dev->fd_block_size);
	} else {
		if (!(fd_dev->fbd_flags & FBDF_HAS_SIZE)) {
			pr_err("FILEIO: Missing fd_dev_size="
				" parameter, and no backing struct"
				" block_device\n");
			goto fail;
		}

		limits = &dev_limits.limits;
		limits->logical_block_size = FD_BLOCKSIZE;
		limits->max_hw_sectors = FD_MAX_SECTORS;
		limits->max_sectors = FD_MAX_SECTORS;
		fd_dev->fd_block_size = FD_BLOCKSIZE;
	}

	dev_limits.hw_queue_depth = FD_MAX_DEVICE_QUEUE_DEPTH;
	dev_limits.queue_depth = FD_DEVICE_QUEUE_DEPTH;

	dev = transport_add_device_to_core_hba(hba, &fileio_template,
				se_dev, dev_flags, fd_dev,
				&dev_limits, "FILEIO", FD_VERSION);
	if (!dev)
		goto fail;

	fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++;
	fd_dev->fd_queue_depth = dev->queue_depth;

	pr_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s,"
		" %llu total bytes\n", fd_host->fd_host_id, fd_dev->fd_dev_id,
			fd_dev->fd_dev_name, fd_dev->fd_dev_size);

	putname(dev_p);
	return dev;
fail:
	if (fd_dev->fd_file) {
		filp_close(fd_dev->fd_file, NULL);
		fd_dev->fd_file = NULL;
	}
	putname(dev_p);
	return ERR_PTR(ret);
}

/*	fd_free_device(): (Part of se_subsystem_api_t template)
 *
 *
 */
static void fd_free_device(void *p)
{
	struct fd_dev *fd_dev = (struct fd_dev *) p;

	if (fd_dev->fd_file) {
		filp_close(fd_dev->fd_file, NULL);
		fd_dev->fd_file = NULL;
	}

	kfree(fd_dev);
}

static inline struct fd_request *FILE_REQ(struct se_task *task)
{
	return container_of(task, struct fd_request, fd_task);
}


static struct se_task *
fd_alloc_task(unsigned char *cdb)
{
	struct fd_request *fd_req;

	fd_req = kzalloc(sizeof(struct fd_request), GFP_KERNEL);
	if (!fd_req) {
		pr_err("Unable to allocate struct fd_request\n");
		return NULL;
	}

	return &fd_req->fd_task;
}

static int fd_do_readv(struct se_task *task)
{
	struct fd_request *req = FILE_REQ(task);
	struct se_device *se_dev = req->fd_task.task_se_cmd->se_dev;
	struct fd_dev *dev = se_dev->dev_ptr;
	struct file *fd = dev->fd_file;
	struct scatterlist *sg = task->task_sg;
	struct iovec *iov;
	mm_segment_t old_fs;
	loff_t pos = (task->task_lba *
		      se_dev->se_sub_dev->se_dev_attrib.block_size);
	int ret = 0, i;

	iov = kzalloc(sizeof(struct iovec) * task->task_sg_nents, GFP_KERNEL);
	if (!iov) {
		pr_err("Unable to allocate fd_do_readv iov[]\n");
		return -ENOMEM;
	}

	for_each_sg(task->task_sg, sg, task->task_sg_nents, i) {
		iov[i].iov_len = sg->length;
		iov[i].iov_base = sg_virt(sg);
	}

	old_fs = get_fs();
	set_fs(get_ds());
	ret = vfs_readv(fd, &iov[0], task->task_sg_nents, &pos);
	set_fs(old_fs);

	kfree(iov);
	/*
	 * Return zeros and GOOD status even if the READ did not return
	 * the expected virt_size for struct file w/o a backing struct
	 * block_device.
	 */
	if (S_ISBLK(fd->f_dentry->d_inode->i_mode)) {
		if (ret < 0 || ret != task->task_size) {
			pr_err("vfs_readv() returned %d,"
				" expecting %d for S_ISBLK\n", ret,
				(int)task->task_size);
			return (ret < 0 ? ret : -EINVAL);
		}
	} else {
		if (ret < 0) {
			pr_err("vfs_readv() returned %d for non"
				" S_ISBLK\n", ret);
			return ret;
		}
	}

	return 1;
}

static int fd_do_writev(struct se_task *task)
{
	struct fd_request *req = FILE_REQ(task);
	struct se_device *se_dev = req->fd_task.task_se_cmd->se_dev;
	struct fd_dev *dev = se_dev->dev_ptr;
	struct file *fd = dev->fd_file;
	struct scatterlist *sg = task->task_sg;
	struct iovec *iov;
	mm_segment_t old_fs;
	loff_t pos = (task->task_lba *
		      se_dev->se_sub_dev->se_dev_attrib.block_size);
	int ret, i = 0;

	iov = kzalloc(sizeof(struct iovec) * task->task_sg_nents, GFP_KERNEL);
	if (!iov) {
		pr_err("Unable to allocate fd_do_writev iov[]\n");
		return -ENOMEM;
	}

	for_each_sg(task->task_sg, sg, task->task_sg_nents, i) {
		iov[i].iov_len = sg->length;
		iov[i].iov_base = sg_virt(sg);
	}

	old_fs = get_fs();
	set_fs(get_ds());
	ret = vfs_writev(fd, &iov[0], task->task_sg_nents, &pos);
	set_fs(old_fs);

	kfree(iov);

	if (ret < 0 || ret != task->task_size) {
		pr_err("vfs_writev() returned %d\n", ret);
		return (ret < 0 ? ret : -EINVAL);
	}

	return 1;
}

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_cdb[1] & 0x2);
	loff_t start, end;
	int ret;

	/*
	 * If the Immediate bit is set, queue up the GOOD response
	 * for this SYNCHRONIZE_CACHE op
	 */
	if (immed)
		transport_complete_sync_cache(cmd, 1);

	/*
	 * Determine if we will be flushing the entire device.
	 */
	if (cmd->t_task_lba == 0 && cmd->data_length == 0) {
		start = 0;
		end = LLONG_MAX;
	} else {
		start = cmd->t_task_lba * dev->se_sub_dev->se_dev_attrib.block_size;
		if (cmd->data_length)
			end = start + cmd->data_length;
		else
			end = LLONG_MAX;
	}

	ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);
	if (ret != 0)
		pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret);

	if (!immed)
		transport_complete_sync_cache(cmd, ret == 0);
}

/*
 * WRITE Force Unit Access (FUA) emulation on a per struct se_task
 * LBA range basis..
 */
static void fd_emulate_write_fua(struct se_cmd *cmd, struct se_task *task)
{
	struct se_device *dev = cmd->se_dev;
	struct fd_dev *fd_dev = dev->dev_ptr;
	loff_t start = task->task_lba * dev->se_sub_dev->se_dev_attrib.block_size;
	loff_t end = start + task->task_size;
	int ret;

	pr_debug("FILEIO: FUA WRITE LBA: %llu, bytes: %u\n",
			task->task_lba, task->task_size);

	ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);
	if (ret != 0)
		pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret);
}

static int fd_do_task(struct se_task *task)
{
	struct se_cmd *cmd = task->task_se_cmd;
	struct se_device *dev = cmd->se_dev;
	int ret = 0;

	/*
	 * Call vectorized fileio functions to map struct scatterlist
	 * physical memory addresses to struct iovec virtual memory.
	 */
	if (task->task_data_direction == DMA_FROM_DEVICE) {
		ret = fd_do_readv(task);
	} else {
		ret = fd_do_writev(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->se_cmd_flags & SCF_FUA)) {
			/*
			 * We might need to be a bit smarter here
			 * and return some sense data to let the initiator
			 * know the FUA WRITE cache sync failed..?
			 */
			fd_emulate_write_fua(cmd, task);
		}

	}

	if (ret < 0) {
		cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
		return ret;
	}
	if (ret) {
		task->task_scsi_status = GOOD;
		transport_complete_task(task, 1);
	}
	return 0;
}

/*	fd_free_task(): (Part of se_subsystem_api_t template)
 *
 *
 */
static void fd_free_task(struct se_task *task)
{
	struct fd_request *req = FILE_REQ(task);

	kfree(req);
}

enum {
	Opt_fd_dev_name, Opt_fd_dev_size, Opt_fd_buffered_io, Opt_err
};

static match_table_t tokens = {
	{Opt_fd_dev_name, "fd_dev_name=%s"},
	{Opt_fd_dev_size, "fd_dev_size=%s"},
	{Opt_fd_buffered_io, "fd_buffered_io=%d"},
	{Opt_err, NULL}
};

static ssize_t fd_set_configfs_dev_params(
	struct se_hba *hba,
	struct se_subsystem_dev *se_dev,
	const char *page, ssize_t count)
{
	struct fd_dev *fd_dev = se_dev->se_dev_su_ptr;
	char *orig, *ptr, *arg_p, *opts;
	substring_t args[MAX_OPT_ARGS];
	int ret = 0, arg, token;

	opts = kstrdup(page, GFP_KERNEL);
	if (!opts)
		return -ENOMEM;

	orig = opts;

	while ((ptr = strsep(&opts, ",")) != NULL) {
		if (!*ptr)
			continue;

		token = match_token(ptr, tokens, args);
		switch (token) {
		case Opt_fd_dev_name:
			arg_p = match_strdup(&args[0]);
			if (!arg_p) {
				ret = -ENOMEM;
				break;
			}
			snprintf(fd_dev->fd_dev_name, FD_MAX_DEV_NAME,
					"%s", arg_p);
			kfree(arg_p);
			pr_debug("FILEIO: Referencing Path: %s\n",
					fd_dev->fd_dev_name);
			fd_dev->fbd_flags |= FBDF_HAS_PATH;
			break;
		case Opt_fd_dev_size:
			arg_p = match_strdup(&args[0]);
			if (!arg_p) {
				ret = -ENOMEM;
				break;
			}
			ret = strict_strtoull(arg_p, 0, &fd_dev->fd_dev_size);
			kfree(arg_p);
			if (ret < 0) {
				pr_err("strict_strtoull() failed for"
						" fd_dev_size=\n");
				goto out;
			}
			pr_debug("FILEIO: Referencing Size: %llu"
					" bytes\n", fd_dev->fd_dev_size);
			fd_dev->fbd_flags |= FBDF_HAS_SIZE;
			break;
		case Opt_fd_buffered_io:
			match_int(args, &arg);
			if (arg != 1) {
				pr_err("bogus fd_buffered_io=%d value\n", arg);
				ret = -EINVAL;
				goto out;
			}

			pr_debug("FILEIO: Using buffered I/O"
				" operations for struct fd_dev\n");

			fd_dev->fbd_flags |= FDBD_USE_BUFFERED_IO;
			break;
		default:
			break;
		}
	}

out:
	kfree(orig);
	return (!ret) ? count : ret;
}

static ssize_t fd_check_configfs_dev_params(struct se_hba *hba, struct se_subsystem_dev *se_dev)
{
	struct fd_dev *fd_dev = (struct fd_dev *) se_dev->se_dev_su_ptr;

	if (!(fd_dev->fbd_flags & FBDF_HAS_PATH)) {
		pr_err("Missing fd_dev_name=\n");
		return -EINVAL;
	}

	return 0;
}

static ssize_t fd_show_configfs_dev_params(
	struct se_hba *hba,
	struct se_subsystem_dev *se_dev,
	char *b)
{
	struct fd_dev *fd_dev = se_dev->se_dev_su_ptr;
	ssize_t bl = 0;

	bl = sprintf(b + bl, "TCM FILEIO ID: %u", fd_dev->fd_dev_id);
	bl += sprintf(b + bl, "        File: %s  Size: %llu  Mode: %s\n",
		fd_dev->fd_dev_name, fd_dev->fd_dev_size,
		(fd_dev->fbd_flags & FDBD_USE_BUFFERED_IO) ?
		"Buffered" : "Synchronous");
	return bl;
}

/*	fd_get_device_rev(): (Part of se_subsystem_api_t template)
 *
 *
 */
static u32 fd_get_device_rev(struct se_device *dev)
{
	return SCSI_SPC_2; /* Returns SPC-3 in Initiator Data */
}

/*	fd_get_device_type(): (Part of se_subsystem_api_t template)
 *
 *
 */
static u32 fd_get_device_type(struct se_device *dev)
{
	return TYPE_DISK;
}

static sector_t fd_get_blocks(struct se_device *dev)
{
	struct fd_dev *fd_dev = dev->dev_ptr;
	unsigned long long blocks_long = div_u64(fd_dev->fd_dev_size,
			dev->se_sub_dev->se_dev_attrib.block_size);

	return blocks_long;
}

static struct se_subsystem_api fileio_template = {
	.name			= "fileio",
	.owner			= THIS_MODULE,
	.transport_type		= TRANSPORT_PLUGIN_VHBA_PDEV,
	.write_cache_emulated	= 1,
	.fua_write_emulated	= 1,
	.attach_hba		= fd_attach_hba,
	.detach_hba		= fd_detach_hba,
	.allocate_virtdevice	= fd_allocate_virtdevice,
	.create_virtdevice	= fd_create_virtdevice,
	.free_device		= fd_free_device,
	.alloc_task		= fd_alloc_task,
	.do_task		= fd_do_task,
	.do_sync_cache		= fd_emulate_sync_cache,
	.free_task		= fd_free_task,
	.check_configfs_dev_params = fd_check_configfs_dev_params,
	.set_configfs_dev_params = fd_set_configfs_dev_params,
	.show_configfs_dev_params = fd_show_configfs_dev_params,
	.get_device_rev		= fd_get_device_rev,
	.get_device_type	= fd_get_device_type,
	.get_blocks		= fd_get_blocks,
};

static int __init fileio_module_init(void)
{
	return transport_subsystem_register(&fileio_template);
}

static void fileio_module_exit(void)
{
	transport_subsystem_release(&fileio_template);
}

MODULE_DESCRIPTION("TCM FILEIO subsystem plugin");
MODULE_AUTHOR("nab@Linux-iSCSI.org");
MODULE_LICENSE("GPL");

module_init(fileio_module_init);
module_exit(fileio_module_exit);
Commit	Line	Data
c66ac9db NB	1	/*******************************************************************************
	2	* Filename: target_core_file.c
	3	*
	4	* This file contains the Storage Engine <-> FILEIO transport specific functions
	5	*
	6	* Copyright (c) 2005 PyX Technologies, Inc.
	7	* Copyright (c) 2005-2006 SBE, Inc. All Rights Reserved.
	8	* Copyright (c) 2007-2010 Rising Tide Systems
	9	* Copyright (c) 2008-2010 Linux-iSCSI.org
	10	*
	11	* Nicholas A. Bellinger <nab@kernel.org>
	12	*
	13	* This program is free software; you can redistribute it and/or modify
	14	* it under the terms of the GNU General Public License as published by
	15	* the Free Software Foundation; either version 2 of the License, or
	16	* (at your option) any later version.
	17	*
	18	* This program is distributed in the hope that it will be useful,
	19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	21	* GNU General Public License for more details.
	22	*
	23	* You should have received a copy of the GNU General Public License
	24	* along with this program; if not, write to the Free Software
	25	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	26	*
	27	******************************************************************************/
	28
c66ac9db NB	29	#include <linux/string.h>
	30	#include <linux/parser.h>
	31	#include <linux/timer.h>
	32	#include <linux/blkdev.h>
	33	#include <linux/slab.h>
	34	#include <linux/spinlock.h>
827509e3	35	#include <linux/module.h>
c66ac9db NB	36	#include <scsi/scsi.h>
	37	#include <scsi/scsi_host.h>
	38
	39	#include <target/target_core_base.h>
	40	#include <target/target_core_device.h>
	41	#include <target/target_core_transport.h>
	42
	43	#include "target_core_file.h"
	44
c66ac9db NB	45	static struct se_subsystem_api fileio_template;
	46
	47	/* fd_attach_hba(): (Part of se_subsystem_api_t template)
	48	*
	49	*
	50	*/
	51	static int fd_attach_hba(struct se_hba *hba, u32 host_id)
	52	{
	53	struct fd_host *fd_host;
	54
	55	fd_host = kzalloc(sizeof(struct fd_host), GFP_KERNEL);
6708bb27 AG	56	if (!fd_host) {
6708bb27 AG	57	pr_err("Unable to allocate memory for struct fd_host\n");
e3d6f909	58	return -ENOMEM;
c66ac9db NB	59	}
	60
	61	fd_host->fd_host_id = host_id;
	62
e3d6f909	63	hba->hba_ptr = fd_host;
c66ac9db	64
6708bb27	65	pr_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic"
c66ac9db NB	66	" Target Core Stack %s\n", hba->hba_id, FD_VERSION,
c66ac9db NB	67	TARGET_CORE_MOD_VERSION);
6708bb27	68	pr_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic"
e3d6f909 AG	69	" MaxSectors: %u\n",
e3d6f909 AG	70	hba->hba_id, fd_host->fd_host_id, FD_MAX_SECTORS);
c66ac9db NB	71
	72	return 0;
	73	}
	74
	75	static void fd_detach_hba(struct se_hba *hba)
	76	{
	77	struct fd_host *fd_host = hba->hba_ptr;
	78
6708bb27	79	pr_debug("CORE_HBA[%d] - Detached FILEIO HBA: %u from Generic"
c66ac9db NB	80	" Target Core\n", hba->hba_id, fd_host->fd_host_id);
	81
	82	kfree(fd_host);
	83	hba->hba_ptr = NULL;
	84	}
	85
	86	static void fd_allocate_virtdevice(struct se_hba hba, const char *name)
	87	{
	88	struct fd_dev *fd_dev;
	89	struct fd_host fd_host = (struct fd_host ) hba->hba_ptr;
	90
	91	fd_dev = kzalloc(sizeof(struct fd_dev), GFP_KERNEL);
6708bb27 AG	92	if (!fd_dev) {
6708bb27 AG	93	pr_err("Unable to allocate memory for struct fd_dev\n");
c66ac9db NB	94	return NULL;
	95	}
	96
	97	fd_dev->fd_host = fd_host;
	98
6708bb27	99	pr_debug("FILEIO: Allocated fd_dev for %p\n", name);
c66ac9db NB	100
	101	return fd_dev;
	102	}
	103
	104	/* fd_create_virtdevice(): (Part of se_subsystem_api_t template)
	105	*
	106	*
	107	*/
	108	static struct se_device *fd_create_virtdevice(
	109	struct se_hba *hba,
	110	struct se_subsystem_dev *se_dev,
	111	void *p)
	112	{
	113	char *dev_p = NULL;
	114	struct se_device *dev;
	115	struct se_dev_limits dev_limits;
	116	struct queue_limits *limits;
	117	struct fd_dev fd_dev = (struct fd_dev ) p;
	118	struct fd_host fd_host = (struct fd_host ) hba->hba_ptr;
	119	mm_segment_t old_fs;
	120	struct file *file;
	121	struct inode *inode = NULL;
613640e4	122	int dev_flags = 0, flags, ret = -EINVAL;
c66ac9db NB	123
	124	memset(&dev_limits, 0, sizeof(struct se_dev_limits));
	125
	126	old_fs = get_fs();
	127	set_fs(get_ds());
	128	dev_p = getname(fd_dev->fd_dev_name);
	129	set_fs(old_fs);
	130
	131	if (IS_ERR(dev_p)) {
6708bb27	132	pr_err("getname(%s) failed: %lu\n",
c66ac9db	133	fd_dev->fd_dev_name, IS_ERR(dev_p));
613640e4	134	ret = PTR_ERR(dev_p);
c66ac9db NB	135	goto fail;
	136	}
	137	#if 0
	138	if (di->no_create_file)
	139	flags = O_RDWR \| O_LARGEFILE;
	140	else
	141	flags = O_RDWR \| O_CREAT \| O_LARGEFILE;
	142	#else
	143	flags = O_RDWR \| O_CREAT \| O_LARGEFILE;
	144	#endif
	145	/* flags \|= O_DIRECT; */
	146	/*
25985edc	147	* If fd_buffered_io=1 has not been set explicitly (the default),
c66ac9db NB	148	* use O_SYNC to force FILEIO writes to disk.
	149	*/
	150	if (!(fd_dev->fbd_flags & FDBD_USE_BUFFERED_IO))
	151	flags \|= O_SYNC;
	152
	153	file = filp_open(dev_p, flags, 0600);
613640e4	154	if (IS_ERR(file)) {
6708bb27	155	pr_err("filp_open(%s) failed\n", dev_p);
613640e4 NB	156	ret = PTR_ERR(file);
	157	goto fail;
	158	}
	159	if (!file \|\| !file->f_dentry) {
6708bb27	160	pr_err("filp_open(%s) failed\n", dev_p);
c66ac9db NB	161	goto fail;
	162	}
	163	fd_dev->fd_file = file;
	164	/*
	165	* If using a block backend with this struct file, we extract
	166	* fd_dev->fd_[block,dev]_size from struct block_device.
	167	*
	168	* Otherwise, we use the passed fd_size= from configfs
	169	*/
	170	inode = file->f_mapping->host;
	171	if (S_ISBLK(inode->i_mode)) {
	172	struct request_queue *q;
	173	/*
	174	* Setup the local scope queue_limits from struct request_queue->limits
	175	* to pass into transport_add_device_to_core_hba() as struct se_dev_limits.
	176	*/
	177	q = bdev_get_queue(inode->i_bdev);
	178	limits = &dev_limits.limits;
	179	limits->logical_block_size = bdev_logical_block_size(inode->i_bdev);
	180	limits->max_hw_sectors = queue_max_hw_sectors(q);
	181	limits->max_sectors = queue_max_sectors(q);
	182	/*
	183	* Determine the number of bytes from i_size_read() minus
	184	* one (1) logical sector from underlying struct block_device
	185	*/
	186	fd_dev->fd_block_size = bdev_logical_block_size(inode->i_bdev);
	187	fd_dev->fd_dev_size = (i_size_read(file->f_mapping->host) -
	188	fd_dev->fd_block_size);
	189
6708bb27	190	pr_debug("FILEIO: Using size: %llu bytes from struct"
c66ac9db NB	191	" block_device blocks: %llu logical_block_size: %d\n",
	192	fd_dev->fd_dev_size,
	193	div_u64(fd_dev->fd_dev_size, fd_dev->fd_block_size),
	194	fd_dev->fd_block_size);
	195	} else {
	196	if (!(fd_dev->fbd_flags & FBDF_HAS_SIZE)) {
6708bb27	197	pr_err("FILEIO: Missing fd_dev_size="
c66ac9db NB	198	" parameter, and no backing struct"
	199	" block_device\n");
	200	goto fail;
	201	}
	202
	203	limits = &dev_limits.limits;
	204	limits->logical_block_size = FD_BLOCKSIZE;
	205	limits->max_hw_sectors = FD_MAX_SECTORS;
	206	limits->max_sectors = FD_MAX_SECTORS;
	207	fd_dev->fd_block_size = FD_BLOCKSIZE;
	208	}
	209
	210	dev_limits.hw_queue_depth = FD_MAX_DEVICE_QUEUE_DEPTH;
	211	dev_limits.queue_depth = FD_DEVICE_QUEUE_DEPTH;
	212
	213	dev = transport_add_device_to_core_hba(hba, &fileio_template,
5951146d	214	se_dev, dev_flags, fd_dev,
c66ac9db	215	&dev_limits, "FILEIO", FD_VERSION);
6708bb27	216	if (!dev)
c66ac9db NB	217	goto fail;
	218
	219	fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++;
	220	fd_dev->fd_queue_depth = dev->queue_depth;
	221
6708bb27	222	pr_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s,"
c66ac9db NB	223	" %llu total bytes\n", fd_host->fd_host_id, fd_dev->fd_dev_id,
	224	fd_dev->fd_dev_name, fd_dev->fd_dev_size);
	225
	226	putname(dev_p);
	227	return dev;
	228	fail:
	229	if (fd_dev->fd_file) {
	230	filp_close(fd_dev->fd_file, NULL);
	231	fd_dev->fd_file = NULL;
	232	}
	233	putname(dev_p);
613640e4	234	return ERR_PTR(ret);
c66ac9db NB	235	}
	236
	237	/* fd_free_device(): (Part of se_subsystem_api_t template)
	238	*
	239	*
	240	*/
	241	static void fd_free_device(void *p)
	242	{
	243	struct fd_dev fd_dev = (struct fd_dev ) p;
	244
	245	if (fd_dev->fd_file) {
	246	filp_close(fd_dev->fd_file, NULL);
	247	fd_dev->fd_file = NULL;
	248	}
	249
	250	kfree(fd_dev);
	251	}
	252
	253	static inline struct fd_request FILE_REQ(struct se_task task)
	254	{
	255	return container_of(task, struct fd_request, fd_task);
	256	}
	257
	258
	259	static struct se_task *
6708bb27	260	fd_alloc_task(unsigned char *cdb)
c66ac9db NB	261	{
	262	struct fd_request *fd_req;
	263
	264	fd_req = kzalloc(sizeof(struct fd_request), GFP_KERNEL);
6708bb27 AG	265	if (!fd_req) {
6708bb27 AG	266	pr_err("Unable to allocate struct fd_request\n");
c66ac9db NB	267	return NULL;
	268	}
	269
c66ac9db NB	270	return &fd_req->fd_task;
	271	}
	272
	273	static int fd_do_readv(struct se_task *task)
	274	{
	275	struct fd_request *req = FILE_REQ(task);
42bf829e CH	276	struct se_device *se_dev = req->fd_task.task_se_cmd->se_dev;
42bf829e CH	277	struct fd_dev *dev = se_dev->dev_ptr;
6708bb27	278	struct file *fd = dev->fd_file;
c66ac9db NB	279	struct scatterlist *sg = task->task_sg;
	280	struct iovec *iov;
	281	mm_segment_t old_fs;
e3d6f909	282	loff_t pos = (task->task_lba *
42bf829e	283	se_dev->se_sub_dev->se_dev_attrib.block_size);
c66ac9db NB	284	int ret = 0, i;
c66ac9db NB	285
6708bb27 AG	286	iov = kzalloc(sizeof(struct iovec) * task->task_sg_nents, GFP_KERNEL);
	287	if (!iov) {
	288	pr_err("Unable to allocate fd_do_readv iov[]\n");
e3d6f909	289	return -ENOMEM;
c66ac9db NB	290	}
c66ac9db NB	291
9649fa1b SAS	292	for_each_sg(task->task_sg, sg, task->task_sg_nents, i) {
	293	iov[i].iov_len = sg->length;
	294	iov[i].iov_base = sg_virt(sg);
c66ac9db NB	295	}
	296
	297	old_fs = get_fs();
	298	set_fs(get_ds());
6708bb27	299	ret = vfs_readv(fd, &iov[0], task->task_sg_nents, &pos);
c66ac9db NB	300	set_fs(old_fs);
	301
	302	kfree(iov);
	303	/*
	304	* Return zeros and GOOD status even if the READ did not return
	305	* the expected virt_size for struct file w/o a backing struct
	306	* block_device.
	307	*/
	308	if (S_ISBLK(fd->f_dentry->d_inode->i_mode)) {
	309	if (ret < 0 \|\| ret != task->task_size) {
6708bb27	310	pr_err("vfs_readv() returned %d,"
c66ac9db NB	311	" expecting %d for S_ISBLK\n", ret,
c66ac9db NB	312	(int)task->task_size);
e3d6f909	313	return (ret < 0 ? ret : -EINVAL);
c66ac9db NB	314	}
	315	} else {
	316	if (ret < 0) {
6708bb27	317	pr_err("vfs_readv() returned %d for non"
c66ac9db	318	" S_ISBLK\n", ret);
e3d6f909	319	return ret;
c66ac9db NB	320	}
	321	}
	322
	323	return 1;
	324	}
	325
	326	static int fd_do_writev(struct se_task *task)
	327	{
	328	struct fd_request *req = FILE_REQ(task);
42bf829e CH	329	struct se_device *se_dev = req->fd_task.task_se_cmd->se_dev;
42bf829e CH	330	struct fd_dev *dev = se_dev->dev_ptr;
6708bb27	331	struct file *fd = dev->fd_file;
c66ac9db NB	332	struct scatterlist *sg = task->task_sg;
	333	struct iovec *iov;
	334	mm_segment_t old_fs;
e3d6f909	335	loff_t pos = (task->task_lba *
42bf829e	336	se_dev->se_sub_dev->se_dev_attrib.block_size);
c66ac9db NB	337	int ret, i = 0;
c66ac9db NB	338
6708bb27 AG	339	iov = kzalloc(sizeof(struct iovec) * task->task_sg_nents, GFP_KERNEL);
	340	if (!iov) {
	341	pr_err("Unable to allocate fd_do_writev iov[]\n");
e3d6f909	342	return -ENOMEM;
c66ac9db NB	343	}
c66ac9db NB	344
9649fa1b SAS	345	for_each_sg(task->task_sg, sg, task->task_sg_nents, i) {
	346	iov[i].iov_len = sg->length;
	347	iov[i].iov_base = sg_virt(sg);
c66ac9db NB	348	}
	349
	350	old_fs = get_fs();
	351	set_fs(get_ds());
6708bb27	352	ret = vfs_writev(fd, &iov[0], task->task_sg_nents, &pos);
c66ac9db NB	353	set_fs(old_fs);
	354
	355	kfree(iov);
	356
	357	if (ret < 0 \|\| ret != task->task_size) {
6708bb27	358	pr_err("vfs_writev() returned %d\n", ret);
e3d6f909	359	return (ret < 0 ? ret : -EINVAL);
c66ac9db NB	360	}
	361
	362	return 1;
	363	}
	364
	365	static void fd_emulate_sync_cache(struct se_task *task)
	366	{
e3d6f909	367	struct se_cmd *cmd = task->task_se_cmd;
c66ac9db NB	368	struct se_device *dev = cmd->se_dev;
c66ac9db NB	369	struct fd_dev *fd_dev = dev->dev_ptr;
a1d8b49a	370	int immed = (cmd->t_task_cdb[1] & 0x2);
c66ac9db NB	371	loff_t start, end;
	372	int ret;
	373
	374	/*
	375	* If the Immediate bit is set, queue up the GOOD response
	376	* for this SYNCHRONIZE_CACHE op
	377	*/
	378	if (immed)
	379	transport_complete_sync_cache(cmd, 1);
	380
	381	/*
	382	* Determine if we will be flushing the entire device.
	383	*/
a1d8b49a	384	if (cmd->t_task_lba == 0 && cmd->data_length == 0) {
c66ac9db NB	385	start = 0;
	386	end = LLONG_MAX;
	387	} else {
a1d8b49a	388	start = cmd->t_task_lba * dev->se_sub_dev->se_dev_attrib.block_size;
c66ac9db NB	389	if (cmd->data_length)
	390	end = start + cmd->data_length;
	391	else
	392	end = LLONG_MAX;
	393	}
	394
	395	ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);
	396	if (ret != 0)
6708bb27	397	pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret);
c66ac9db NB	398
	399	if (!immed)
	400	transport_complete_sync_cache(cmd, ret == 0);
	401	}
	402
c66ac9db NB	403	/*
	404	* WRITE Force Unit Access (FUA) emulation on a per struct se_task
	405	* LBA range basis..
	406	*/
	407	static void fd_emulate_write_fua(struct se_cmd cmd, struct se_task task)
	408	{
	409	struct se_device *dev = cmd->se_dev;
	410	struct fd_dev *fd_dev = dev->dev_ptr;
e3d6f909	411	loff_t start = task->task_lba * dev->se_sub_dev->se_dev_attrib.block_size;
c66ac9db NB	412	loff_t end = start + task->task_size;
	413	int ret;
	414
6708bb27	415	pr_debug("FILEIO: FUA WRITE LBA: %llu, bytes: %u\n",
c66ac9db NB	416	task->task_lba, task->task_size);
	417
	418	ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);
	419	if (ret != 0)
6708bb27	420	pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret);
c66ac9db NB	421	}
	422
	423	static int fd_do_task(struct se_task *task)
	424	{
	425	struct se_cmd *cmd = task->task_se_cmd;
	426	struct se_device *dev = cmd->se_dev;
	427	int ret = 0;
	428
	429	/*
	430	* Call vectorized fileio functions to map struct scatterlist
	431	* physical memory addresses to struct iovec virtual memory.
	432	*/
	433	if (task->task_data_direction == DMA_FROM_DEVICE) {
	434	ret = fd_do_readv(task);
	435	} else {
	436	ret = fd_do_writev(task);
	437
	438	if (ret > 0 &&
e3d6f909 AG	439	dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0 &&
e3d6f909 AG	440	dev->se_sub_dev->se_dev_attrib.emulate_fua_write > 0 &&
2d3a4b51	441	(cmd->se_cmd_flags & SCF_FUA)) {
c66ac9db NB	442	/*
	443	* We might need to be a bit smarter here
	444	* and return some sense data to let the initiator
	445	* know the FUA WRITE cache sync failed..?
	446	*/
	447	fd_emulate_write_fua(cmd, task);
	448	}
	449
	450	}
	451
03e98c9e NB	452	if (ret < 0) {
03e98c9e NB	453	cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db	454	return ret;
03e98c9e	455	}
c66ac9db NB	456	if (ret) {
	457	task->task_scsi_status = GOOD;
	458	transport_complete_task(task, 1);
	459	}
03e98c9e	460	return 0;
c66ac9db NB	461	}
	462
	463	/* fd_free_task(): (Part of se_subsystem_api_t template)
	464	*
	465	*
	466	*/
	467	static void fd_free_task(struct se_task *task)
	468	{
	469	struct fd_request *req = FILE_REQ(task);
	470
	471	kfree(req);
	472	}
	473
	474	enum {
	475	Opt_fd_dev_name, Opt_fd_dev_size, Opt_fd_buffered_io, Opt_err
	476	};
	477
	478	static match_table_t tokens = {
	479	{Opt_fd_dev_name, "fd_dev_name=%s"},
	480	{Opt_fd_dev_size, "fd_dev_size=%s"},
58c3e647	481	{Opt_fd_buffered_io, "fd_buffered_io=%d"},
c66ac9db NB	482	{Opt_err, NULL}
	483	};
	484
	485	static ssize_t fd_set_configfs_dev_params(
	486	struct se_hba *hba,
	487	struct se_subsystem_dev *se_dev,
	488	const char *page, ssize_t count)
	489	{
	490	struct fd_dev *fd_dev = se_dev->se_dev_su_ptr;
	491	char orig, ptr, arg_p, opts;
	492	substring_t args[MAX_OPT_ARGS];
	493	int ret = 0, arg, token;
	494
	495	opts = kstrdup(page, GFP_KERNEL);
	496	if (!opts)
	497	return -ENOMEM;
	498
	499	orig = opts;
	500
	501	while ((ptr = strsep(&opts, ",")) != NULL) {
	502	if (!*ptr)
	503	continue;
	504
	505	token = match_token(ptr, tokens, args);
	506	switch (token) {
	507	case Opt_fd_dev_name:
6d180253 JJ	508	arg_p = match_strdup(&args[0]);
	509	if (!arg_p) {
	510	ret = -ENOMEM;
	511	break;
	512	}
c66ac9db	513	snprintf(fd_dev->fd_dev_name, FD_MAX_DEV_NAME,
6d180253 JJ	514	"%s", arg_p);
6d180253 JJ	515	kfree(arg_p);
6708bb27	516	pr_debug("FILEIO: Referencing Path: %s\n",
c66ac9db NB	517	fd_dev->fd_dev_name);
	518	fd_dev->fbd_flags \|= FBDF_HAS_PATH;
	519	break;
	520	case Opt_fd_dev_size:
	521	arg_p = match_strdup(&args[0]);
6d180253 JJ	522	if (!arg_p) {
	523	ret = -ENOMEM;
	524	break;
	525	}
c66ac9db	526	ret = strict_strtoull(arg_p, 0, &fd_dev->fd_dev_size);
6d180253	527	kfree(arg_p);
c66ac9db	528	if (ret < 0) {
6708bb27	529	pr_err("strict_strtoull() failed for"
c66ac9db NB	530	" fd_dev_size=\n");
	531	goto out;
	532	}
6708bb27	533	pr_debug("FILEIO: Referencing Size: %llu"
c66ac9db NB	534	" bytes\n", fd_dev->fd_dev_size);
	535	fd_dev->fbd_flags \|= FBDF_HAS_SIZE;
	536	break;
	537	case Opt_fd_buffered_io:
	538	match_int(args, &arg);
	539	if (arg != 1) {
6708bb27	540	pr_err("bogus fd_buffered_io=%d value\n", arg);
c66ac9db NB	541	ret = -EINVAL;
	542	goto out;
	543	}
	544
6708bb27	545	pr_debug("FILEIO: Using buffered I/O"
c66ac9db NB	546	" operations for struct fd_dev\n");
	547
	548	fd_dev->fbd_flags \|= FDBD_USE_BUFFERED_IO;
	549	break;
	550	default:
	551	break;
	552	}
	553	}
	554
	555	out:
	556	kfree(orig);
	557	return (!ret) ? count : ret;
	558	}
	559
	560	static ssize_t fd_check_configfs_dev_params(struct se_hba hba, struct se_subsystem_dev se_dev)
	561	{
	562	struct fd_dev fd_dev = (struct fd_dev ) se_dev->se_dev_su_ptr;
	563
	564	if (!(fd_dev->fbd_flags & FBDF_HAS_PATH)) {
6708bb27	565	pr_err("Missing fd_dev_name=\n");
e3d6f909	566	return -EINVAL;
c66ac9db NB	567	}
	568
	569	return 0;
	570	}
	571
	572	static ssize_t fd_show_configfs_dev_params(
	573	struct se_hba *hba,
	574	struct se_subsystem_dev *se_dev,
	575	char *b)
	576	{
	577	struct fd_dev *fd_dev = se_dev->se_dev_su_ptr;
	578	ssize_t bl = 0;
	579
	580	bl = sprintf(b + bl, "TCM FILEIO ID: %u", fd_dev->fd_dev_id);
	581	bl += sprintf(b + bl, " File: %s Size: %llu Mode: %s\n",
	582	fd_dev->fd_dev_name, fd_dev->fd_dev_size,
	583	(fd_dev->fbd_flags & FDBD_USE_BUFFERED_IO) ?
	584	"Buffered" : "Synchronous");
	585	return bl;
	586	}
	587
c66ac9db NB	588	/* fd_get_device_rev(): (Part of se_subsystem_api_t template)
	589	*
	590	*
	591	*/
	592	static u32 fd_get_device_rev(struct se_device *dev)
	593	{
	594	return SCSI_SPC_2; /* Returns SPC-3 in Initiator Data */
	595	}
	596
	597	/* fd_get_device_type(): (Part of se_subsystem_api_t template)
	598	*
	599	*
	600	*/
	601	static u32 fd_get_device_type(struct se_device *dev)
	602	{
	603	return TYPE_DISK;
	604	}
	605
	606	static sector_t fd_get_blocks(struct se_device *dev)
	607	{
	608	struct fd_dev *fd_dev = dev->dev_ptr;
	609	unsigned long long blocks_long = div_u64(fd_dev->fd_dev_size,
e3d6f909	610	dev->se_sub_dev->se_dev_attrib.block_size);
c66ac9db NB	611
	612	return blocks_long;
	613	}
	614
	615	static struct se_subsystem_api fileio_template = {
	616	.name = "fileio",
	617	.owner = THIS_MODULE,
	618	.transport_type = TRANSPORT_PLUGIN_VHBA_PDEV,
f55918fa CH	619	.write_cache_emulated = 1,
f55918fa CH	620	.fua_write_emulated = 1,
c66ac9db NB	621	.attach_hba = fd_attach_hba,
	622	.detach_hba = fd_detach_hba,
	623	.allocate_virtdevice = fd_allocate_virtdevice,
	624	.create_virtdevice = fd_create_virtdevice,
	625	.free_device = fd_free_device,
c66ac9db NB	626	.alloc_task = fd_alloc_task,
	627	.do_task = fd_do_task,
	628	.do_sync_cache = fd_emulate_sync_cache,
	629	.free_task = fd_free_task,
	630	.check_configfs_dev_params = fd_check_configfs_dev_params,
	631	.set_configfs_dev_params = fd_set_configfs_dev_params,
	632	.show_configfs_dev_params = fd_show_configfs_dev_params,
c66ac9db NB	633	.get_device_rev = fd_get_device_rev,
	634	.get_device_type = fd_get_device_type,
	635	.get_blocks = fd_get_blocks,
	636	};
	637
	638	static int __init fileio_module_init(void)
	639	{
	640	return transport_subsystem_register(&fileio_template);
	641	}
	642
	643	static void fileio_module_exit(void)
	644	{
	645	transport_subsystem_release(&fileio_template);
	646	}
	647
	648	MODULE_DESCRIPTION("TCM FILEIO subsystem plugin");
	649	MODULE_AUTHOR("nab@Linux-iSCSI.org");
	650	MODULE_LICENSE("GPL");
	651
	652	module_init(fileio_module_init);
	653	module_exit(fileio_module_exit);