target_core_file.c 19.2 KB
Newer Older
1 2 3 4 5
/*******************************************************************************
 * Filename:  target_core_file.c
 *
 * This file contains the Storage Engine <-> FILEIO transport specific functions
 *
6
 * (c) Copyright 2005-2013 Datera, Inc.
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 *
 * 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>
32
#include <linux/module.h>
33
#include <linux/falloc.h>
34 35
#include <scsi/scsi.h>
#include <scsi/scsi_host.h>
36
#include <asm/unaligned.h>
37 38

#include <target/target_core_base.h>
39
#include <target/target_core_backend.h>
40 41 42

#include "target_core_file.h"

43 44 45 46
static inline struct fd_dev *FD_DEV(struct se_device *dev)
{
	return container_of(dev, struct fd_dev, dev);
}
47 48 49 50 51 52 53 54 55 56

/*	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);
57 58
	if (!fd_host) {
		pr_err("Unable to allocate memory for struct fd_host\n");
59
		return -ENOMEM;
60 61 62 63
	}

	fd_host->fd_host_id = host_id;

64
	hba->hba_ptr = fd_host;
65

66
	pr_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic"
67 68
		" Target Core Stack %s\n", hba->hba_id, FD_VERSION,
		TARGET_CORE_MOD_VERSION);
69
	pr_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic"
70 71
		" MaxSectors: %u\n",
		hba->hba_id, fd_host->fd_host_id, FD_MAX_SECTORS);
72 73 74 75 76 77 78 79

	return 0;
}

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

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

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

87
static struct se_device *fd_alloc_device(struct se_hba *hba, const char *name)
88 89
{
	struct fd_dev *fd_dev;
J
Jörn Engel 已提交
90
	struct fd_host *fd_host = hba->hba_ptr;
91 92

	fd_dev = kzalloc(sizeof(struct fd_dev), GFP_KERNEL);
93 94
	if (!fd_dev) {
		pr_err("Unable to allocate memory for struct fd_dev\n");
95 96 97 98 99
		return NULL;
	}

	fd_dev->fd_host = fd_host;

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

102
	return &fd_dev->dev;
103 104
}

105
static int fd_configure_device(struct se_device *dev)
106
{
107 108
	struct fd_dev *fd_dev = FD_DEV(dev);
	struct fd_host *fd_host = dev->se_hba->hba_ptr;
109 110
	struct file *file;
	struct inode *inode = NULL;
111
	int flags, ret = -EINVAL;
112

113 114 115 116
	if (!(fd_dev->fbd_flags & FBDF_HAS_PATH)) {
		pr_err("Missing fd_dev_name=\n");
		return -EINVAL;
	}
117 118

	/*
119 120
	 * Use O_DSYNC by default instead of O_SYNC to forgo syncing
	 * of pure timestamp updates.
121
	 */
122
	flags = O_RDWR | O_CREAT | O_LARGEFILE | O_DSYNC;
123

124 125 126 127 128 129 130 131 132 133 134 135 136
	/*
	 * Optionally allow fd_buffered_io=1 to be enabled for people
	 * who want use the fs buffer cache as an WriteCache mechanism.
	 *
	 * This means that in event of a hard failure, there is a risk
	 * of silent data-loss if the SCSI client has *not* performed a
	 * forced unit access (FUA) write, or issued SYNCHRONIZE_CACHE
	 * to write-out the entire device cache.
	 */
	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {
		pr_debug("FILEIO: Disabling O_DSYNC, using buffered FILEIO\n");
		flags &= ~O_DSYNC;
	}
137

A
Al Viro 已提交
138
	file = filp_open(fd_dev->fd_dev_name, flags, 0600);
139
	if (IS_ERR(file)) {
A
Al Viro 已提交
140
		pr_err("filp_open(%s) failed\n", fd_dev->fd_dev_name);
141 142 143
		ret = PTR_ERR(file);
		goto fail;
	}
144 145 146 147 148 149 150 151 152
	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)) {
153
		struct request_queue *q = bdev_get_queue(inode->i_bdev);
154
		unsigned long long dev_size;
155

156
		fd_dev->fd_block_size = bdev_logical_block_size(inode->i_bdev);
157 158 159 160
		/*
		 * Determine the number of bytes from i_size_read() minus
		 * one (1) logical sector from underlying struct block_device
		 */
161
		dev_size = (i_size_read(file->f_mapping->host) -
162 163
				       fd_dev->fd_block_size);

164
		pr_debug("FILEIO: Using size: %llu bytes from struct"
165
			" block_device blocks: %llu logical_block_size: %d\n",
166
			dev_size, div_u64(dev_size, fd_dev->fd_block_size),
167
			fd_dev->fd_block_size);
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
		/*
		 * Check if the underlying struct block_device request_queue supports
		 * the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM
		 * in ATA and we need to set TPE=1
		 */
		if (blk_queue_discard(q)) {
			dev->dev_attrib.max_unmap_lba_count =
				q->limits.max_discard_sectors;
			/*
			 * Currently hardcoded to 1 in Linux/SCSI code..
			 */
			dev->dev_attrib.max_unmap_block_desc_count = 1;
			dev->dev_attrib.unmap_granularity =
				q->limits.discard_granularity >> 9;
			dev->dev_attrib.unmap_granularity_alignment =
				q->limits.discard_alignment;
			pr_debug("IFILE: BLOCK Discard support available,"
					" disabled by default\n");
		}
		/*
		 * Enable write same emulation for IBLOCK and use 0xFFFF as
		 * the smaller WRITE_SAME(10) only has a two-byte block count.
		 */
		dev->dev_attrib.max_write_same_len = 0xFFFF;
A
Asias He 已提交
192 193 194

		if (blk_queue_nonrot(q))
			dev->dev_attrib.is_nonrot = 1;
195 196
	} else {
		if (!(fd_dev->fbd_flags & FBDF_HAS_SIZE)) {
197
			pr_err("FILEIO: Missing fd_dev_size="
198 199 200 201 202
				" parameter, and no backing struct"
				" block_device\n");
			goto fail;
		}

203
		fd_dev->fd_block_size = FD_BLOCKSIZE;
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
		/*
		 * Limit UNMAP emulation to 8k Number of LBAs (NoLB)
		 */
		dev->dev_attrib.max_unmap_lba_count = 0x2000;
		/*
		 * Currently hardcoded to 1 in Linux/SCSI code..
		 */
		dev->dev_attrib.max_unmap_block_desc_count = 1;
		dev->dev_attrib.unmap_granularity = 1;
		dev->dev_attrib.unmap_granularity_alignment = 0;

		/*
		 * Limit WRITE_SAME w/ UNMAP=0 emulation to 8k Number of LBAs (NoLB)
		 * based upon struct iovec limit for vfs_writev()
		 */
		dev->dev_attrib.max_write_same_len = 0x1000;
220 221
	}

222
	dev->dev_attrib.hw_block_size = fd_dev->fd_block_size;
223
	dev->dev_attrib.hw_max_sectors = FD_MAX_SECTORS;
224
	dev->dev_attrib.hw_queue_depth = FD_MAX_DEVICE_QUEUE_DEPTH;
225

226 227 228
	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {
		pr_debug("FILEIO: Forcing setting of emulate_write_cache=1"
			" with FDBD_HAS_BUFFERED_IO_WCE\n");
229
		dev->dev_attrib.emulate_write_cache = 1;
230 231
	}

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

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

239
	return 0;
240 241 242 243 244
fail:
	if (fd_dev->fd_file) {
		filp_close(fd_dev->fd_file, NULL);
		fd_dev->fd_file = NULL;
	}
245
	return ret;
246 247
}

248
static void fd_free_device(struct se_device *dev)
249
{
250
	struct fd_dev *fd_dev = FD_DEV(dev);
251 252 253 254 255 256 257 258 259

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

	kfree(fd_dev);
}

260 261
static int fd_do_rw(struct se_cmd *cmd, struct scatterlist *sgl,
		u32 sgl_nents, int is_write)
262
{
263
	struct se_device *se_dev = cmd->se_dev;
264
	struct fd_dev *dev = FD_DEV(se_dev);
265
	struct file *fd = dev->fd_file;
266
	struct scatterlist *sg;
267 268
	struct iovec *iov;
	mm_segment_t old_fs;
269
	loff_t pos = (cmd->t_task_lba * se_dev->dev_attrib.block_size);
270 271
	int ret = 0, i;

272
	iov = kzalloc(sizeof(struct iovec) * sgl_nents, GFP_KERNEL);
273 274
	if (!iov) {
		pr_err("Unable to allocate fd_do_readv iov[]\n");
275
		return -ENOMEM;
276 277
	}

278
	for_each_sg(sgl, sg, sgl_nents, i) {
279
		iov[i].iov_len = sg->length;
280
		iov[i].iov_base = kmap(sg_page(sg)) + sg->offset;
281 282 283 284
	}

	old_fs = get_fs();
	set_fs(get_ds());
285 286 287 288 289 290

	if (is_write)
		ret = vfs_writev(fd, &iov[0], sgl_nents, &pos);
	else
		ret = vfs_readv(fd, &iov[0], sgl_nents, &pos);

291 292
	set_fs(old_fs);

293 294
	for_each_sg(sgl, sg, sgl_nents, i)
		kunmap(sg_page(sg));
295

296
	kfree(iov);
297 298

	if (is_write) {
299
		if (ret < 0 || ret != cmd->data_length) {
300
			pr_err("%s() write returned %d\n", __func__, ret);
301
			return (ret < 0 ? ret : -EINVAL);
302 303
		}
	} else {
304 305 306 307 308
		/*
		 * 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.
		 */
A
Al Viro 已提交
309
		if (S_ISBLK(file_inode(fd)->i_mode)) {
310 311 312 313 314 315 316 317 318 319 320 321
			if (ret < 0 || ret != cmd->data_length) {
				pr_err("%s() returned %d, expecting %u for "
						"S_ISBLK\n", __func__, ret,
						cmd->data_length);
				return (ret < 0 ? ret : -EINVAL);
			}
		} else {
			if (ret < 0) {
				pr_err("%s() returned %d for non S_ISBLK\n",
						__func__, ret);
				return ret;
			}
322 323 324 325 326
		}
	}
	return 1;
}

327 328
static sense_reason_t
fd_execute_sync_cache(struct se_cmd *cmd)
329 330
{
	struct se_device *dev = cmd->se_dev;
331
	struct fd_dev *fd_dev = FD_DEV(dev);
332
	int immed = (cmd->t_task_cdb[1] & 0x2);
333 334 335 336 337 338 339 340
	loff_t start, end;
	int ret;

	/*
	 * If the Immediate bit is set, queue up the GOOD response
	 * for this SYNCHRONIZE_CACHE op
	 */
	if (immed)
341
		target_complete_cmd(cmd, SAM_STAT_GOOD);
342 343 344 345

	/*
	 * Determine if we will be flushing the entire device.
	 */
346
	if (cmd->t_task_lba == 0 && cmd->data_length == 0) {
347 348 349
		start = 0;
		end = LLONG_MAX;
	} else {
350
		start = cmd->t_task_lba * dev->dev_attrib.block_size;
351 352 353 354 355 356 357 358
		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)
359
		pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret);
360

361
	if (immed)
362
		return 0;
363

364
	if (ret)
365
		target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
366
	else
367
		target_complete_cmd(cmd, SAM_STAT_GOOD);
368 369

	return 0;
370 371
}

372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
static unsigned char *
fd_setup_write_same_buf(struct se_cmd *cmd, struct scatterlist *sg,
		    unsigned int len)
{
	struct se_device *se_dev = cmd->se_dev;
	unsigned int block_size = se_dev->dev_attrib.block_size;
	unsigned int i = 0, end;
	unsigned char *buf, *p, *kmap_buf;

	buf = kzalloc(min_t(unsigned int, len, PAGE_SIZE), GFP_KERNEL);
	if (!buf) {
		pr_err("Unable to allocate fd_execute_write_same buf\n");
		return NULL;
	}

	kmap_buf = kmap(sg_page(sg)) + sg->offset;
	if (!kmap_buf) {
		pr_err("kmap() failed in fd_setup_write_same\n");
		kfree(buf);
		return NULL;
	}
	/*
	 * Fill local *buf to contain multiple WRITE_SAME blocks up to
	 * min(len, PAGE_SIZE)
	 */
	p = buf;
	end = min_t(unsigned int, len, PAGE_SIZE);

	while (i < end) {
		memcpy(p, kmap_buf, block_size);

		i += block_size;
		p += block_size;
	}
	kunmap(sg_page(sg));

	return buf;
}

static sense_reason_t
fd_execute_write_same(struct se_cmd *cmd)
{
	struct se_device *se_dev = cmd->se_dev;
	struct fd_dev *fd_dev = FD_DEV(se_dev);
	struct file *f = fd_dev->fd_file;
	struct scatterlist *sg;
	struct iovec *iov;
	mm_segment_t old_fs;
420
	sector_t nolb = sbc_get_write_same_sectors(cmd);
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
	loff_t pos = cmd->t_task_lba * se_dev->dev_attrib.block_size;
	unsigned int len, len_tmp, iov_num;
	int i, rc;
	unsigned char *buf;

	if (!nolb) {
		target_complete_cmd(cmd, SAM_STAT_GOOD);
		return 0;
	}
	sg = &cmd->t_data_sg[0];

	if (cmd->t_data_nents > 1 ||
	    sg->length != cmd->se_dev->dev_attrib.block_size) {
		pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"
			" block_size: %u\n", cmd->t_data_nents, sg->length,
			cmd->se_dev->dev_attrib.block_size);
		return TCM_INVALID_CDB_FIELD;
	}

	len = len_tmp = nolb * se_dev->dev_attrib.block_size;
	iov_num = DIV_ROUND_UP(len, PAGE_SIZE);

	buf = fd_setup_write_same_buf(cmd, sg, len);
	if (!buf)
		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;

	iov = vzalloc(sizeof(struct iovec) * iov_num);
	if (!iov) {
		pr_err("Unable to allocate fd_execute_write_same iovecs\n");
		kfree(buf);
		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
	}
	/*
	 * Map the single fabric received scatterlist block now populated
	 * in *buf into each iovec for I/O submission.
	 */
	for (i = 0; i < iov_num; i++) {
		iov[i].iov_base = buf;
		iov[i].iov_len = min_t(unsigned int, len_tmp, PAGE_SIZE);
		len_tmp -= iov[i].iov_len;
	}

	old_fs = get_fs();
	set_fs(get_ds());
	rc = vfs_writev(f, &iov[0], iov_num, &pos);
	set_fs(old_fs);

	vfree(iov);
	kfree(buf);

	if (rc < 0 || rc != len) {
		pr_err("vfs_writev() returned %d for write same\n", rc);
		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
	}

	target_complete_cmd(cmd, SAM_STAT_GOOD);
	return 0;
}

480
static sense_reason_t
481
fd_do_unmap(struct se_cmd *cmd, void *priv, sector_t lba, sector_t nolb)
482
{
483
	struct file *file = priv;
484 485 486 487 488 489 490
	struct inode *inode = file->f_mapping->host;
	int ret;

	if (S_ISBLK(inode->i_mode)) {
		/* The backend is block device, use discard */
		struct block_device *bdev = inode->i_bdev;

A
Asias He 已提交
491
		ret = blkdev_issue_discard(bdev, lba,
492 493 494 495 496 497 498 499
				nolb, GFP_KERNEL, 0);
		if (ret < 0) {
			pr_warn("FILEIO: blkdev_issue_discard() failed: %d\n",
				ret);
			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
		}
	} else {
		/* The backend is normal file, use fallocate */
A
Asias He 已提交
500 501
		struct se_device *se_dev = cmd->se_dev;
		loff_t pos = lba * se_dev->dev_attrib.block_size;
502 503 504 505 506 507 508 509 510 511 512 513 514
		unsigned int len = nolb * se_dev->dev_attrib.block_size;
		int mode = FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE;

		if (!file->f_op->fallocate)
			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;

		ret = file->f_op->fallocate(file, mode, pos, len);
		if (ret < 0) {
			pr_warn("FILEIO: fallocate() failed: %d\n", ret);
			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
		}
	}

A
Asias He 已提交
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
	return 0;
}

static sense_reason_t
fd_execute_write_same_unmap(struct se_cmd *cmd)
{
	struct se_device *se_dev = cmd->se_dev;
	struct fd_dev *fd_dev = FD_DEV(se_dev);
	struct file *file = fd_dev->fd_file;
	sector_t lba = cmd->t_task_lba;
	sector_t nolb = sbc_get_write_same_sectors(cmd);
	int ret;

	if (!nolb) {
		target_complete_cmd(cmd, SAM_STAT_GOOD);
		return 0;
	}

	ret = fd_do_unmap(cmd, file, lba, nolb);
	if (ret)
		return ret;

537 538 539 540
	target_complete_cmd(cmd, GOOD);
	return 0;
}

541 542 543
static sense_reason_t
fd_execute_unmap(struct se_cmd *cmd)
{
544
	struct file *file = FD_DEV(cmd->se_dev)->fd_file;
545

546
	return sbc_execute_unmap(cmd, fd_do_unmap, file);
547 548
}

549
static sense_reason_t
550 551
fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
	      enum dma_data_direction data_direction)
552 553 554 555 556 557 558 559
{
	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.
	 */
560
	if (data_direction == DMA_FROM_DEVICE) {
561
		ret = fd_do_rw(cmd, sgl, sgl_nents, 0);
562
	} else {
563
		ret = fd_do_rw(cmd, sgl, sgl_nents, 1);
564
		/*
565
		 * Perform implicit vfs_fsync_range() for fd_do_writev() ops
566 567 568
		 * for SCSI WRITEs with Forced Unit Access (FUA) set.
		 * Allow this to happen independent of WCE=0 setting.
		 */
569
		if (ret > 0 &&
570
		    dev->dev_attrib.emulate_fua_write > 0 &&
571
		    (cmd->se_cmd_flags & SCF_FUA)) {
572
			struct fd_dev *fd_dev = FD_DEV(dev);
573
			loff_t start = cmd->t_task_lba *
574
				dev->dev_attrib.block_size;
575
			loff_t end = start + cmd->data_length;
576

577 578
			vfs_fsync_range(fd_dev->fd_file, start, end, 1);
		}
579 580
	}

581 582 583
	if (ret < 0)
		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;

584 585
	if (ret)
		target_complete_cmd(cmd, SAM_STAT_GOOD);
586
	return 0;
587 588 589 590 591 592 593 594 595
}

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"},
596
	{Opt_fd_buffered_io, "fd_buffered_io=%d"},
597 598 599
	{Opt_err, NULL}
};

600 601
static ssize_t fd_set_configfs_dev_params(struct se_device *dev,
		const char *page, ssize_t count)
602
{
603
	struct fd_dev *fd_dev = FD_DEV(dev);
604 605
	char *orig, *ptr, *arg_p, *opts;
	substring_t args[MAX_OPT_ARGS];
606
	int ret = 0, arg, token;
607 608 609 610 611 612 613

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

	orig = opts;

614
	while ((ptr = strsep(&opts, ",\n")) != NULL) {
615 616 617 618 619 620
		if (!*ptr)
			continue;

		token = match_token(ptr, tokens, args);
		switch (token) {
		case Opt_fd_dev_name:
A
Al Viro 已提交
621 622 623
			if (match_strlcpy(fd_dev->fd_dev_name, &args[0],
				FD_MAX_DEV_NAME) == 0) {
				ret = -EINVAL;
624 625
				break;
			}
626
			pr_debug("FILEIO: Referencing Path: %s\n",
627 628 629 630 631
					fd_dev->fd_dev_name);
			fd_dev->fbd_flags |= FBDF_HAS_PATH;
			break;
		case Opt_fd_dev_size:
			arg_p = match_strdup(&args[0]);
632 633 634 635
			if (!arg_p) {
				ret = -ENOMEM;
				break;
			}
636
			ret = kstrtoull(arg_p, 0, &fd_dev->fd_dev_size);
637
			kfree(arg_p);
638
			if (ret < 0) {
639
				pr_err("kstrtoull() failed for"
640 641 642
						" fd_dev_size=\n");
				goto out;
			}
643
			pr_debug("FILEIO: Referencing Size: %llu"
644 645 646
					" bytes\n", fd_dev->fd_dev_size);
			fd_dev->fbd_flags |= FBDF_HAS_SIZE;
			break;
647 648 649 650 651 652 653 654 655 656 657 658 659
		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_HAS_BUFFERED_IO_WCE;
			break;
660 661 662 663 664 665 666 667 668 669
		default:
			break;
		}
	}

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

670
static ssize_t fd_show_configfs_dev_params(struct se_device *dev, char *b)
671
{
672
	struct fd_dev *fd_dev = FD_DEV(dev);
673 674 675
	ssize_t bl = 0;

	bl = sprintf(b + bl, "TCM FILEIO ID: %u", fd_dev->fd_dev_id);
676 677 678 679
	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_HAS_BUFFERED_IO_WCE) ?
		"Buffered-WCE" : "O_DSYNC");
680 681 682 683 684
	return bl;
}

static sector_t fd_get_blocks(struct se_device *dev)
{
685
	struct fd_dev *fd_dev = FD_DEV(dev);
686 687 688 689 690 691 692 693 694
	struct file *f = fd_dev->fd_file;
	struct inode *i = f->f_mapping->host;
	unsigned long long dev_size;
	/*
	 * When using a file that references an underlying struct block_device,
	 * ensure dev_size is always based on the current inode size in order
	 * to handle underlying block_device resize operations.
	 */
	if (S_ISBLK(i->i_mode))
695
		dev_size = i_size_read(i);
696 697
	else
		dev_size = fd_dev->fd_dev_size;
698

699 700
	return div_u64(dev_size - dev->dev_attrib.block_size,
		       dev->dev_attrib.block_size);
701 702
}

C
Christoph Hellwig 已提交
703
static struct sbc_ops fd_sbc_ops = {
704
	.execute_rw		= fd_execute_rw,
705
	.execute_sync_cache	= fd_execute_sync_cache,
706
	.execute_write_same	= fd_execute_write_same,
707
	.execute_write_same_unmap = fd_execute_write_same_unmap,
708
	.execute_unmap		= fd_execute_unmap,
709 710
};

711 712
static sense_reason_t
fd_parse_cdb(struct se_cmd *cmd)
713
{
C
Christoph Hellwig 已提交
714
	return sbc_parse_cdb(cmd, &fd_sbc_ops);
715 716
}

717 718
static struct se_subsystem_api fileio_template = {
	.name			= "fileio",
719 720
	.inquiry_prod		= "FILEIO",
	.inquiry_rev		= FD_VERSION,
721 722 723 724
	.owner			= THIS_MODULE,
	.transport_type		= TRANSPORT_PLUGIN_VHBA_PDEV,
	.attach_hba		= fd_attach_hba,
	.detach_hba		= fd_detach_hba,
725 726
	.alloc_device		= fd_alloc_device,
	.configure_device	= fd_configure_device,
727
	.free_device		= fd_free_device,
728
	.parse_cdb		= fd_parse_cdb,
729 730
	.set_configfs_dev_params = fd_set_configfs_dev_params,
	.show_configfs_dev_params = fd_show_configfs_dev_params,
731
	.get_device_type	= sbc_get_device_type,
732 733 734 735 736 737 738 739
	.get_blocks		= fd_get_blocks,
};

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

740
static void __exit fileio_module_exit(void)
741 742 743 744 745 746 747 748 749 750
{
	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);