1 /*******************************************************************************
2  * Filename:  target_core_file.c
3  *
4  * This file contains the Storage Engine <-> FILEIO transport specific functions
5  *
6  * (c) Copyright 2005-2013 Datera, Inc.
7  *
8  * Nicholas A. Bellinger <nab@kernel.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23  *
24  ******************************************************************************/
25 
26 #include <linux/string.h>
27 #include <linux/parser.h>
28 #include <linux/timer.h>
29 #include <linux/blkdev.h>
30 #include <linux/slab.h>
31 #include <linux/spinlock.h>
32 #include <linux/module.h>
33 #include <linux/falloc.h>
34 #include <scsi/scsi.h>
35 #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 #include "target_core_file.h"
42 
43 static inline struct fd_dev *FD_DEV(struct se_device *dev)
44 {
45 	return container_of(dev, struct fd_dev, dev);
46 }
47 
48 /*	fd_attach_hba(): (Part of se_subsystem_api_t template)
49  *
50  *
51  */
52 static int fd_attach_hba(struct se_hba *hba, u32 host_id)
53 {
54 	struct fd_host *fd_host;
55 
56 	fd_host = kzalloc(sizeof(struct fd_host), GFP_KERNEL);
57 	if (!fd_host) {
58 		pr_err("Unable to allocate memory for struct fd_host\n");
59 		return -ENOMEM;
60 	}
61 
62 	fd_host->fd_host_id = host_id;
63 
64 	hba->hba_ptr = fd_host;
65 
66 	pr_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic"
67 		" Target Core Stack %s\n", hba->hba_id, FD_VERSION,
68 		TARGET_CORE_MOD_VERSION);
69 	pr_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic"
70 		" MaxSectors: %u\n",
71 		hba->hba_id, fd_host->fd_host_id, FD_MAX_SECTORS);
72 
73 	return 0;
74 }
75 
76 static void fd_detach_hba(struct se_hba *hba)
77 {
78 	struct fd_host *fd_host = hba->hba_ptr;
79 
80 	pr_debug("CORE_HBA[%d] - Detached FILEIO HBA: %u from Generic"
81 		" Target Core\n", hba->hba_id, fd_host->fd_host_id);
82 
83 	kfree(fd_host);
84 	hba->hba_ptr = NULL;
85 }
86 
87 static struct se_device *fd_alloc_device(struct se_hba *hba, const char *name)
88 {
89 	struct fd_dev *fd_dev;
90 	struct fd_host *fd_host = hba->hba_ptr;
91 
92 	fd_dev = kzalloc(sizeof(struct fd_dev), GFP_KERNEL);
93 	if (!fd_dev) {
94 		pr_err("Unable to allocate memory for struct fd_dev\n");
95 		return NULL;
96 	}
97 
98 	fd_dev->fd_host = fd_host;
99 
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 	struct fd_dev *fd_dev = FD_DEV(dev);
108 	struct fd_host *fd_host = dev->se_hba->hba_ptr;
109 	struct file *file;
110 	struct inode *inode = NULL;
111 	int flags, ret = -EINVAL;
112 
113 	if (!(fd_dev->fbd_flags & FBDF_HAS_PATH)) {
114 		pr_err("Missing fd_dev_name=\n");
115 		return -EINVAL;
116 	}
117 
118 	/*
119 	 * Use O_DSYNC by default instead of O_SYNC to forgo syncing
120 	 * of pure timestamp updates.
121 	 */
122 	flags = O_RDWR | O_CREAT | O_LARGEFILE | O_DSYNC;
123 
124 	/*
125 	 * Optionally allow fd_buffered_io=1 to be enabled for people
126 	 * who want use the fs buffer cache as an WriteCache mechanism.
127 	 *
128 	 * This means that in event of a hard failure, there is a risk
129 	 * of silent data-loss if the SCSI client has *not* performed a
130 	 * forced unit access (FUA) write, or issued SYNCHRONIZE_CACHE
131 	 * to write-out the entire device cache.
132 	 */
133 	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {
134 		pr_debug("FILEIO: Disabling O_DSYNC, using buffered FILEIO\n");
135 		flags &= ~O_DSYNC;
136 	}
137 
138 	file = filp_open(fd_dev->fd_dev_name, flags, 0600);
139 	if (IS_ERR(file)) {
140 		pr_err("filp_open(%s) failed\n", fd_dev->fd_dev_name);
141 		ret = PTR_ERR(file);
142 		goto fail;
143 	}
144 	fd_dev->fd_file = file;
145 	/*
146 	 * If using a block backend with this struct file, we extract
147 	 * fd_dev->fd_[block,dev]_size from struct block_device.
148 	 *
149 	 * Otherwise, we use the passed fd_size= from configfs
150 	 */
151 	inode = file->f_mapping->host;
152 	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 		 * Determine the number of bytes from i_size_read() minus
159 		 * one (1) logical sector from underlying struct block_device
160 		 */
161 		dev_size = (i_size_read(file->f_mapping->host) -
162 				       fd_dev->fd_block_size);
163 
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 		 * Check if the underlying struct block_device request_queue supports
170 		 * the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM
171 		 * in ATA and we need to set TPE=1
172 		 */
173 		if (blk_queue_discard(q)) {
174 			dev->dev_attrib.max_unmap_lba_count =
175 				q->limits.max_discard_sectors;
176 			/*
177 			 * Currently hardcoded to 1 in Linux/SCSI code..
178 			 */
179 			dev->dev_attrib.max_unmap_block_desc_count = 1;
180 			dev->dev_attrib.unmap_granularity =
181 				q->limits.discard_granularity >> 9;
182 			dev->dev_attrib.unmap_granularity_alignment =
183 				q->limits.discard_alignment;
184 			pr_debug("IFILE: BLOCK Discard support available,"
185 					" disabled by default\n");
186 		}
187 		/*
188 		 * Enable write same emulation for IBLOCK and use 0xFFFF as
189 		 * the smaller WRITE_SAME(10) only has a two-byte block count.
190 		 */
191 		dev->dev_attrib.max_write_same_len = 0xFFFF;
192 
193 		if (blk_queue_nonrot(q))
194 			dev->dev_attrib.is_nonrot = 1;
195 	} else {
196 		if (!(fd_dev->fbd_flags & FBDF_HAS_SIZE)) {
197 			pr_err("FILEIO: Missing fd_dev_size="
198 				" parameter, and no backing struct"
199 				" block_device\n");
200 			goto fail;
201 		}
202 
203 		fd_dev->fd_block_size = FD_BLOCKSIZE;
204 		/*
205 		 * Limit UNMAP emulation to 8k Number of LBAs (NoLB)
206 		 */
207 		dev->dev_attrib.max_unmap_lba_count = 0x2000;
208 		/*
209 		 * Currently hardcoded to 1 in Linux/SCSI code..
210 		 */
211 		dev->dev_attrib.max_unmap_block_desc_count = 1;
212 		dev->dev_attrib.unmap_granularity = 1;
213 		dev->dev_attrib.unmap_granularity_alignment = 0;
214 
215 		/*
216 		 * Limit WRITE_SAME w/ UNMAP=0 emulation to 8k Number of LBAs (NoLB)
217 		 * based upon struct iovec limit for vfs_writev()
218 		 */
219 		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 	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {
227 		pr_debug("FILEIO: Forcing setting of emulate_write_cache=1"
228 			" with FDBD_HAS_BUFFERED_IO_WCE\n");
229 		dev->dev_attrib.emulate_write_cache = 1;
230 	}
231 
232 	fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++;
233 	fd_dev->fd_queue_depth = dev->queue_depth;
234 
235 	pr_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s,"
236 		" %llu total bytes\n", fd_host->fd_host_id, fd_dev->fd_dev_id,
237 			fd_dev->fd_dev_name, fd_dev->fd_dev_size);
238 
239 	return 0;
240 fail:
241 	if (fd_dev->fd_file) {
242 		filp_close(fd_dev->fd_file, NULL);
243 		fd_dev->fd_file = NULL;
244 	}
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 	if (fd_dev->fd_file) {
253 		filp_close(fd_dev->fd_file, NULL);
254 		fd_dev->fd_file = NULL;
255 	}
256 
257 	kfree(fd_dev);
258 }
259 
260 static int fd_do_rw(struct se_cmd *cmd, struct scatterlist *sgl,
261 		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 	struct iovec *iov;
268 	mm_segment_t old_fs;
269 	loff_t pos = (cmd->t_task_lba * se_dev->dev_attrib.block_size);
270 	int ret = 0, i;
271 
272 	iov = kzalloc(sizeof(struct iovec) * sgl_nents, GFP_KERNEL);
273 	if (!iov) {
274 		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 	old_fs = get_fs();
284 	set_fs(get_ds());
285 
286 	if (is_write)
287 		ret = vfs_writev(fd, &iov[0], sgl_nents, &pos);
288 	else
289 		ret = vfs_readv(fd, &iov[0], sgl_nents, &pos);
290 
291 	set_fs(old_fs);
292 
293 	for_each_sg(sgl, sg, sgl_nents, i)
294 		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 		 * Return zeros and GOOD status even if the READ did not return
306 		 * the expected virt_size for struct file w/o a backing struct
307 		 * block_device.
308 		 */
309 		if (S_ISBLK(file_inode(fd)->i_mode)) {
310 			if (ret < 0 || ret != cmd->data_length) {
311 				pr_err("%s() returned %d, expecting %u for "
312 						"S_ISBLK\n", __func__, ret,
313 						cmd->data_length);
314 				return (ret < 0 ? ret : -EINVAL);
315 			}
316 		} else {
317 			if (ret < 0) {
318 				pr_err("%s() returned %d for non S_ISBLK\n",
319 						__func__, ret);
320 				return ret;
321 			}
322 		}
323 	}
324 	return 1;
325 }
326 
327 static sense_reason_t
328 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 	loff_t start, end;
334 	int ret;
335 
336 	/*
337 	 * If the Immediate bit is set, queue up the GOOD response
338 	 * for this SYNCHRONIZE_CACHE op
339 	 */
340 	if (immed)
341 		target_complete_cmd(cmd, SAM_STAT_GOOD);
342 
343 	/*
344 	 * Determine if we will be flushing the entire device.
345 	 */
346 	if (cmd->t_task_lba == 0 && cmd->data_length == 0) {
347 		start = 0;
348 		end = LLONG_MAX;
349 	} else {
350 		start = cmd->t_task_lba * dev->dev_attrib.block_size;
351 		if (cmd->data_length)
352 			end = start + cmd->data_length;
353 		else
354 			end = LLONG_MAX;
355 	}
356 
357 	ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);
358 	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 static unsigned char *
373 fd_setup_write_same_buf(struct se_cmd *cmd, struct scatterlist *sg,
374 		    unsigned int len)
375 {
376 	struct se_device *se_dev = cmd->se_dev;
377 	unsigned int block_size = se_dev->dev_attrib.block_size;
378 	unsigned int i = 0, end;
379 	unsigned char *buf, *p, *kmap_buf;
380 
381 	buf = kzalloc(min_t(unsigned int, len, PAGE_SIZE), GFP_KERNEL);
382 	if (!buf) {
383 		pr_err("Unable to allocate fd_execute_write_same buf\n");
384 		return NULL;
385 	}
386 
387 	kmap_buf = kmap(sg_page(sg)) + sg->offset;
388 	if (!kmap_buf) {
389 		pr_err("kmap() failed in fd_setup_write_same\n");
390 		kfree(buf);
391 		return NULL;
392 	}
393 	/*
394 	 * Fill local *buf to contain multiple WRITE_SAME blocks up to
395 	 * min(len, PAGE_SIZE)
396 	 */
397 	p = buf;
398 	end = min_t(unsigned int, len, PAGE_SIZE);
399 
400 	while (i < end) {
401 		memcpy(p, kmap_buf, block_size);
402 
403 		i += block_size;
404 		p += block_size;
405 	}
406 	kunmap(sg_page(sg));
407 
408 	return buf;
409 }
410 
411 static sense_reason_t
412 fd_execute_write_same(struct se_cmd *cmd)
413 {
414 	struct se_device *se_dev = cmd->se_dev;
415 	struct fd_dev *fd_dev = FD_DEV(se_dev);
416 	struct file *f = fd_dev->fd_file;
417 	struct scatterlist *sg;
418 	struct iovec *iov;
419 	mm_segment_t old_fs;
420 	sector_t nolb = sbc_get_write_same_sectors(cmd);
421 	loff_t pos = cmd->t_task_lba * se_dev->dev_attrib.block_size;
422 	unsigned int len, len_tmp, iov_num;
423 	int i, rc;
424 	unsigned char *buf;
425 
426 	if (!nolb) {
427 		target_complete_cmd(cmd, SAM_STAT_GOOD);
428 		return 0;
429 	}
430 	sg = &cmd->t_data_sg[0];
431 
432 	if (cmd->t_data_nents > 1 ||
433 	    sg->length != cmd->se_dev->dev_attrib.block_size) {
434 		pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"
435 			" block_size: %u\n", cmd->t_data_nents, sg->length,
436 			cmd->se_dev->dev_attrib.block_size);
437 		return TCM_INVALID_CDB_FIELD;
438 	}
439 
440 	len = len_tmp = nolb * se_dev->dev_attrib.block_size;
441 	iov_num = DIV_ROUND_UP(len, PAGE_SIZE);
442 
443 	buf = fd_setup_write_same_buf(cmd, sg, len);
444 	if (!buf)
445 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
446 
447 	iov = vzalloc(sizeof(struct iovec) * iov_num);
448 	if (!iov) {
449 		pr_err("Unable to allocate fd_execute_write_same iovecs\n");
450 		kfree(buf);
451 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
452 	}
453 	/*
454 	 * Map the single fabric received scatterlist block now populated
455 	 * in *buf into each iovec for I/O submission.
456 	 */
457 	for (i = 0; i < iov_num; i++) {
458 		iov[i].iov_base = buf;
459 		iov[i].iov_len = min_t(unsigned int, len_tmp, PAGE_SIZE);
460 		len_tmp -= iov[i].iov_len;
461 	}
462 
463 	old_fs = get_fs();
464 	set_fs(get_ds());
465 	rc = vfs_writev(f, &iov[0], iov_num, &pos);
466 	set_fs(old_fs);
467 
468 	vfree(iov);
469 	kfree(buf);
470 
471 	if (rc < 0 || rc != len) {
472 		pr_err("vfs_writev() returned %d for write same\n", rc);
473 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
474 	}
475 
476 	target_complete_cmd(cmd, SAM_STAT_GOOD);
477 	return 0;
478 }
479 
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 	struct inode *inode = file->f_mapping->host;
485 	int ret;
486 
487 	if (S_ISBLK(inode->i_mode)) {
488 		/* The backend is block device, use discard */
489 		struct block_device *bdev = inode->i_bdev;
490 
491 		ret = blkdev_issue_discard(bdev, lba,
492 				nolb, GFP_KERNEL, 0);
493 		if (ret < 0) {
494 			pr_warn("FILEIO: blkdev_issue_discard() failed: %d\n",
495 				ret);
496 			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
497 		}
498 	} else {
499 		/* The backend is normal file, use fallocate */
500 		struct se_device *se_dev = cmd->se_dev;
501 		loff_t pos = lba * se_dev->dev_attrib.block_size;
502 		unsigned int len = nolb * se_dev->dev_attrib.block_size;
503 		int mode = FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE;
504 
505 		if (!file->f_op->fallocate)
506 			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
507 
508 		ret = file->f_op->fallocate(file, mode, pos, len);
509 		if (ret < 0) {
510 			pr_warn("FILEIO: fallocate() failed: %d\n", ret);
511 			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
512 		}
513 	}
514 
515 	return 0;
516 }
517 
518 static sense_reason_t
519 fd_execute_write_same_unmap(struct se_cmd *cmd)
520 {
521 	struct se_device *se_dev = cmd->se_dev;
522 	struct fd_dev *fd_dev = FD_DEV(se_dev);
523 	struct file *file = fd_dev->fd_file;
524 	sector_t lba = cmd->t_task_lba;
525 	sector_t nolb = sbc_get_write_same_sectors(cmd);
526 	int ret;
527 
528 	if (!nolb) {
529 		target_complete_cmd(cmd, SAM_STAT_GOOD);
530 		return 0;
531 	}
532 
533 	ret = fd_do_unmap(cmd, file, lba, nolb);
534 	if (ret)
535 		return ret;
536 
537 	target_complete_cmd(cmd, GOOD);
538 	return 0;
539 }
540 
541 static sense_reason_t
542 fd_execute_unmap(struct se_cmd *cmd)
543 {
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 fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
551 	      enum dma_data_direction data_direction)
552 {
553 	struct se_device *dev = cmd->se_dev;
554 	int ret = 0;
555 
556 	/*
557 	 * Call vectorized fileio functions to map struct scatterlist
558 	 * physical memory addresses to struct iovec virtual memory.
559 	 */
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 implict vfs_fsync_range() for fd_do_writev() ops
566 		 * for SCSI WRITEs with Forced Unit Access (FUA) set.
567 		 * Allow this to happen independent of WCE=0 setting.
568 		 */
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 			vfs_fsync_range(fd_dev->fd_file, start, end, 1);
578 		}
579 	}
580 
581 	if (ret < 0)
582 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
583 
584 	if (ret)
585 		target_complete_cmd(cmd, SAM_STAT_GOOD);
586 	return 0;
587 }
588 
589 enum {
590 	Opt_fd_dev_name, Opt_fd_dev_size, Opt_fd_buffered_io, Opt_err
591 };
592 
593 static match_table_t tokens = {
594 	{Opt_fd_dev_name, "fd_dev_name=%s"},
595 	{Opt_fd_dev_size, "fd_dev_size=%s"},
596 	{Opt_fd_buffered_io, "fd_buffered_io=%d"},
597 	{Opt_err, NULL}
598 };
599 
600 static ssize_t fd_set_configfs_dev_params(struct se_device *dev,
601 		const char *page, ssize_t count)
602 {
603 	struct fd_dev *fd_dev = FD_DEV(dev);
604 	char *orig, *ptr, *arg_p, *opts;
605 	substring_t args[MAX_OPT_ARGS];
606 	int ret = 0, arg, token;
607 
608 	opts = kstrdup(page, GFP_KERNEL);
609 	if (!opts)
610 		return -ENOMEM;
611 
612 	orig = opts;
613 
614 	while ((ptr = strsep(&opts, ",\n")) != NULL) {
615 		if (!*ptr)
616 			continue;
617 
618 		token = match_token(ptr, tokens, args);
619 		switch (token) {
620 		case Opt_fd_dev_name:
621 			if (match_strlcpy(fd_dev->fd_dev_name, &args[0],
622 				FD_MAX_DEV_NAME) == 0) {
623 				ret = -EINVAL;
624 				break;
625 			}
626 			pr_debug("FILEIO: Referencing Path: %s\n",
627 					fd_dev->fd_dev_name);
628 			fd_dev->fbd_flags |= FBDF_HAS_PATH;
629 			break;
630 		case Opt_fd_dev_size:
631 			arg_p = match_strdup(&args[0]);
632 			if (!arg_p) {
633 				ret = -ENOMEM;
634 				break;
635 			}
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 						" fd_dev_size=\n");
641 				goto out;
642 			}
643 			pr_debug("FILEIO: Referencing Size: %llu"
644 					" bytes\n", fd_dev->fd_dev_size);
645 			fd_dev->fbd_flags |= FBDF_HAS_SIZE;
646 			break;
647 		case Opt_fd_buffered_io:
648 			match_int(args, &arg);
649 			if (arg != 1) {
650 				pr_err("bogus fd_buffered_io=%d value\n", arg);
651 				ret = -EINVAL;
652 				goto out;
653 			}
654 
655 			pr_debug("FILEIO: Using buffered I/O"
656 				" operations for struct fd_dev\n");
657 
658 			fd_dev->fbd_flags |= FDBD_HAS_BUFFERED_IO_WCE;
659 			break;
660 		default:
661 			break;
662 		}
663 	}
664 
665 out:
666 	kfree(orig);
667 	return (!ret) ? count : ret;
668 }
669 
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 	ssize_t bl = 0;
674 
675 	bl = sprintf(b + bl, "TCM FILEIO ID: %u", fd_dev->fd_dev_id);
676 	bl += sprintf(b + bl, "        File: %s  Size: %llu  Mode: %s\n",
677 		fd_dev->fd_dev_name, fd_dev->fd_dev_size,
678 		(fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) ?
679 		"Buffered-WCE" : "O_DSYNC");
680 	return bl;
681 }
682 
683 static sector_t fd_get_blocks(struct se_device *dev)
684 {
685 	struct fd_dev *fd_dev = FD_DEV(dev);
686 	struct file *f = fd_dev->fd_file;
687 	struct inode *i = f->f_mapping->host;
688 	unsigned long long dev_size;
689 	/*
690 	 * When using a file that references an underlying struct block_device,
691 	 * ensure dev_size is always based on the current inode size in order
692 	 * to handle underlying block_device resize operations.
693 	 */
694 	if (S_ISBLK(i->i_mode))
695 		dev_size = i_size_read(i);
696 	else
697 		dev_size = fd_dev->fd_dev_size;
698 
699 	return div_u64(dev_size - dev->dev_attrib.block_size,
700 		       dev->dev_attrib.block_size);
701 }
702 
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 static sense_reason_t
712 fd_parse_cdb(struct se_cmd *cmd)
713 {
714 	return sbc_parse_cdb(cmd, &fd_sbc_ops);
715 }
716 
717 static struct se_subsystem_api fileio_template = {
718 	.name			= "fileio",
719 	.inquiry_prod		= "FILEIO",
720 	.inquiry_rev		= FD_VERSION,
721 	.owner			= THIS_MODULE,
722 	.transport_type		= TRANSPORT_PLUGIN_VHBA_PDEV,
723 	.attach_hba		= fd_attach_hba,
724 	.detach_hba		= fd_detach_hba,
725 	.alloc_device		= fd_alloc_device,
726 	.configure_device	= fd_configure_device,
727 	.free_device		= fd_free_device,
728 	.parse_cdb		= fd_parse_cdb,
729 	.set_configfs_dev_params = fd_set_configfs_dev_params,
730 	.show_configfs_dev_params = fd_show_configfs_dev_params,
731 	.get_device_type	= sbc_get_device_type,
732 	.get_blocks		= fd_get_blocks,
733 };
734 
735 static int __init fileio_module_init(void)
736 {
737 	return transport_subsystem_register(&fileio_template);
738 }
739 
740 static void __exit fileio_module_exit(void)
741 {
742 	transport_subsystem_release(&fileio_template);
743 }
744 
745 MODULE_DESCRIPTION("TCM FILEIO subsystem plugin");
746 MODULE_AUTHOR("nab@Linux-iSCSI.org");
747 MODULE_LICENSE("GPL");
748 
749 module_init(fileio_module_init);
750 module_exit(fileio_module_exit);
751