1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*******************************************************************************
3  * Filename:  target_core_file.c
4  *
5  * This file contains the Storage Engine <-> FILEIO transport specific functions
6  *
7  * (c) Copyright 2005-2013 Datera, Inc.
8  *
9  * Nicholas A. Bellinger <nab@kernel.org>
10  *
11  ******************************************************************************/
12 
13 #include <linux/string.h>
14 #include <linux/parser.h>
15 #include <linux/timer.h>
16 #include <linux/blkdev.h>
17 #include <linux/slab.h>
18 #include <linux/spinlock.h>
19 #include <linux/module.h>
20 #include <linux/vmalloc.h>
21 #include <linux/falloc.h>
22 #include <linux/uio.h>
23 #include <scsi/scsi_proto.h>
24 #include <asm/unaligned.h>
25 
26 #include <target/target_core_base.h>
27 #include <target/target_core_backend.h>
28 
29 #include "target_core_file.h"
30 
31 static inline struct fd_dev *FD_DEV(struct se_device *dev)
32 {
33 	return container_of(dev, struct fd_dev, dev);
34 }
35 
36 static int fd_attach_hba(struct se_hba *hba, u32 host_id)
37 {
38 	struct fd_host *fd_host;
39 
40 	fd_host = kzalloc(sizeof(struct fd_host), GFP_KERNEL);
41 	if (!fd_host) {
42 		pr_err("Unable to allocate memory for struct fd_host\n");
43 		return -ENOMEM;
44 	}
45 
46 	fd_host->fd_host_id = host_id;
47 
48 	hba->hba_ptr = fd_host;
49 
50 	pr_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic"
51 		" Target Core Stack %s\n", hba->hba_id, FD_VERSION,
52 		TARGET_CORE_VERSION);
53 	pr_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic\n",
54 		hba->hba_id, fd_host->fd_host_id);
55 
56 	return 0;
57 }
58 
59 static void fd_detach_hba(struct se_hba *hba)
60 {
61 	struct fd_host *fd_host = hba->hba_ptr;
62 
63 	pr_debug("CORE_HBA[%d] - Detached FILEIO HBA: %u from Generic"
64 		" Target Core\n", hba->hba_id, fd_host->fd_host_id);
65 
66 	kfree(fd_host);
67 	hba->hba_ptr = NULL;
68 }
69 
70 static struct se_device *fd_alloc_device(struct se_hba *hba, const char *name)
71 {
72 	struct fd_dev *fd_dev;
73 	struct fd_host *fd_host = hba->hba_ptr;
74 
75 	fd_dev = kzalloc(sizeof(struct fd_dev), GFP_KERNEL);
76 	if (!fd_dev) {
77 		pr_err("Unable to allocate memory for struct fd_dev\n");
78 		return NULL;
79 	}
80 
81 	fd_dev->fd_host = fd_host;
82 
83 	pr_debug("FILEIO: Allocated fd_dev for %p\n", name);
84 
85 	return &fd_dev->dev;
86 }
87 
88 static int fd_configure_device(struct se_device *dev)
89 {
90 	struct fd_dev *fd_dev = FD_DEV(dev);
91 	struct fd_host *fd_host = dev->se_hba->hba_ptr;
92 	struct file *file;
93 	struct inode *inode = NULL;
94 	int flags, ret = -EINVAL;
95 
96 	if (!(fd_dev->fbd_flags & FBDF_HAS_PATH)) {
97 		pr_err("Missing fd_dev_name=\n");
98 		return -EINVAL;
99 	}
100 
101 	/*
102 	 * Use O_DSYNC by default instead of O_SYNC to forgo syncing
103 	 * of pure timestamp updates.
104 	 */
105 	flags = O_RDWR | O_CREAT | O_LARGEFILE | O_DSYNC;
106 
107 	/*
108 	 * Optionally allow fd_buffered_io=1 to be enabled for people
109 	 * who want use the fs buffer cache as an WriteCache mechanism.
110 	 *
111 	 * This means that in event of a hard failure, there is a risk
112 	 * of silent data-loss if the SCSI client has *not* performed a
113 	 * forced unit access (FUA) write, or issued SYNCHRONIZE_CACHE
114 	 * to write-out the entire device cache.
115 	 */
116 	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {
117 		pr_debug("FILEIO: Disabling O_DSYNC, using buffered FILEIO\n");
118 		flags &= ~O_DSYNC;
119 	}
120 
121 	file = filp_open(fd_dev->fd_dev_name, flags, 0600);
122 	if (IS_ERR(file)) {
123 		pr_err("filp_open(%s) failed\n", fd_dev->fd_dev_name);
124 		ret = PTR_ERR(file);
125 		goto fail;
126 	}
127 	fd_dev->fd_file = file;
128 	/*
129 	 * If using a block backend with this struct file, we extract
130 	 * fd_dev->fd_[block,dev]_size from struct block_device.
131 	 *
132 	 * Otherwise, we use the passed fd_size= from configfs
133 	 */
134 	inode = file->f_mapping->host;
135 	if (S_ISBLK(inode->i_mode)) {
136 		struct request_queue *q = bdev_get_queue(I_BDEV(inode));
137 		unsigned long long dev_size;
138 
139 		fd_dev->fd_block_size = bdev_logical_block_size(I_BDEV(inode));
140 		/*
141 		 * Determine the number of bytes from i_size_read() minus
142 		 * one (1) logical sector from underlying struct block_device
143 		 */
144 		dev_size = (i_size_read(file->f_mapping->host) -
145 				       fd_dev->fd_block_size);
146 
147 		pr_debug("FILEIO: Using size: %llu bytes from struct"
148 			" block_device blocks: %llu logical_block_size: %d\n",
149 			dev_size, div_u64(dev_size, fd_dev->fd_block_size),
150 			fd_dev->fd_block_size);
151 
152 		if (target_configure_unmap_from_queue(&dev->dev_attrib, q))
153 			pr_debug("IFILE: BLOCK Discard support available,"
154 				 " disabled by default\n");
155 		/*
156 		 * Enable write same emulation for IBLOCK and use 0xFFFF as
157 		 * the smaller WRITE_SAME(10) only has a two-byte block count.
158 		 */
159 		dev->dev_attrib.max_write_same_len = 0xFFFF;
160 
161 		if (blk_queue_nonrot(q))
162 			dev->dev_attrib.is_nonrot = 1;
163 	} else {
164 		if (!(fd_dev->fbd_flags & FBDF_HAS_SIZE)) {
165 			pr_err("FILEIO: Missing fd_dev_size="
166 				" parameter, and no backing struct"
167 				" block_device\n");
168 			goto fail;
169 		}
170 
171 		fd_dev->fd_block_size = FD_BLOCKSIZE;
172 		/*
173 		 * Limit UNMAP emulation to 8k Number of LBAs (NoLB)
174 		 */
175 		dev->dev_attrib.max_unmap_lba_count = 0x2000;
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 = 1;
181 		dev->dev_attrib.unmap_granularity_alignment = 0;
182 
183 		/*
184 		 * Limit WRITE_SAME w/ UNMAP=0 emulation to 8k Number of LBAs (NoLB)
185 		 * based upon struct iovec limit for vfs_writev()
186 		 */
187 		dev->dev_attrib.max_write_same_len = 0x1000;
188 	}
189 
190 	dev->dev_attrib.hw_block_size = fd_dev->fd_block_size;
191 	dev->dev_attrib.max_bytes_per_io = FD_MAX_BYTES;
192 	dev->dev_attrib.hw_max_sectors = FD_MAX_BYTES / fd_dev->fd_block_size;
193 	dev->dev_attrib.hw_queue_depth = FD_MAX_DEVICE_QUEUE_DEPTH;
194 
195 	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {
196 		pr_debug("FILEIO: Forcing setting of emulate_write_cache=1"
197 			" with FDBD_HAS_BUFFERED_IO_WCE\n");
198 		dev->dev_attrib.emulate_write_cache = 1;
199 	}
200 
201 	fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++;
202 	fd_dev->fd_queue_depth = dev->queue_depth;
203 
204 	pr_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s,"
205 		" %llu total bytes\n", fd_host->fd_host_id, fd_dev->fd_dev_id,
206 			fd_dev->fd_dev_name, fd_dev->fd_dev_size);
207 
208 	return 0;
209 fail:
210 	if (fd_dev->fd_file) {
211 		filp_close(fd_dev->fd_file, NULL);
212 		fd_dev->fd_file = NULL;
213 	}
214 	return ret;
215 }
216 
217 static void fd_dev_call_rcu(struct rcu_head *p)
218 {
219 	struct se_device *dev = container_of(p, struct se_device, rcu_head);
220 	struct fd_dev *fd_dev = FD_DEV(dev);
221 
222 	kfree(fd_dev);
223 }
224 
225 static void fd_free_device(struct se_device *dev)
226 {
227 	call_rcu(&dev->rcu_head, fd_dev_call_rcu);
228 }
229 
230 static void fd_destroy_device(struct se_device *dev)
231 {
232 	struct fd_dev *fd_dev = FD_DEV(dev);
233 
234 	if (fd_dev->fd_file) {
235 		filp_close(fd_dev->fd_file, NULL);
236 		fd_dev->fd_file = NULL;
237 	}
238 }
239 
240 struct target_core_file_cmd {
241 	unsigned long	len;
242 	struct se_cmd	*cmd;
243 	struct kiocb	iocb;
244 	struct bio_vec	bvecs[];
245 };
246 
247 static void cmd_rw_aio_complete(struct kiocb *iocb, long ret, long ret2)
248 {
249 	struct target_core_file_cmd *cmd;
250 
251 	cmd = container_of(iocb, struct target_core_file_cmd, iocb);
252 
253 	if (ret != cmd->len)
254 		target_complete_cmd(cmd->cmd, SAM_STAT_CHECK_CONDITION);
255 	else
256 		target_complete_cmd(cmd->cmd, SAM_STAT_GOOD);
257 
258 	kfree(cmd);
259 }
260 
261 static sense_reason_t
262 fd_execute_rw_aio(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
263 	      enum dma_data_direction data_direction)
264 {
265 	int is_write = !(data_direction == DMA_FROM_DEVICE);
266 	struct se_device *dev = cmd->se_dev;
267 	struct fd_dev *fd_dev = FD_DEV(dev);
268 	struct file *file = fd_dev->fd_file;
269 	struct target_core_file_cmd *aio_cmd;
270 	struct iov_iter iter;
271 	struct scatterlist *sg;
272 	ssize_t len = 0;
273 	int ret = 0, i;
274 
275 	aio_cmd = kmalloc(struct_size(aio_cmd, bvecs, sgl_nents), GFP_KERNEL);
276 	if (!aio_cmd)
277 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
278 
279 	for_each_sg(sgl, sg, sgl_nents, i) {
280 		aio_cmd->bvecs[i].bv_page = sg_page(sg);
281 		aio_cmd->bvecs[i].bv_len = sg->length;
282 		aio_cmd->bvecs[i].bv_offset = sg->offset;
283 
284 		len += sg->length;
285 	}
286 
287 	iov_iter_bvec(&iter, is_write, aio_cmd->bvecs, sgl_nents, len);
288 
289 	aio_cmd->cmd = cmd;
290 	aio_cmd->len = len;
291 	aio_cmd->iocb.ki_pos = cmd->t_task_lba * dev->dev_attrib.block_size;
292 	aio_cmd->iocb.ki_filp = file;
293 	aio_cmd->iocb.ki_complete = cmd_rw_aio_complete;
294 	aio_cmd->iocb.ki_flags = IOCB_DIRECT;
295 
296 	if (is_write && (cmd->se_cmd_flags & SCF_FUA))
297 		aio_cmd->iocb.ki_flags |= IOCB_DSYNC;
298 
299 	if (is_write)
300 		ret = call_write_iter(file, &aio_cmd->iocb, &iter);
301 	else
302 		ret = call_read_iter(file, &aio_cmd->iocb, &iter);
303 
304 	if (ret != -EIOCBQUEUED)
305 		cmd_rw_aio_complete(&aio_cmd->iocb, ret, 0);
306 
307 	return 0;
308 }
309 
310 static int fd_do_rw(struct se_cmd *cmd, struct file *fd,
311 		    u32 block_size, struct scatterlist *sgl,
312 		    u32 sgl_nents, u32 data_length, int is_write)
313 {
314 	struct scatterlist *sg;
315 	struct iov_iter iter;
316 	struct bio_vec *bvec;
317 	ssize_t len = 0;
318 	loff_t pos = (cmd->t_task_lba * block_size);
319 	int ret = 0, i;
320 
321 	bvec = kcalloc(sgl_nents, sizeof(struct bio_vec), GFP_KERNEL);
322 	if (!bvec) {
323 		pr_err("Unable to allocate fd_do_readv iov[]\n");
324 		return -ENOMEM;
325 	}
326 
327 	for_each_sg(sgl, sg, sgl_nents, i) {
328 		bvec[i].bv_page = sg_page(sg);
329 		bvec[i].bv_len = sg->length;
330 		bvec[i].bv_offset = sg->offset;
331 
332 		len += sg->length;
333 	}
334 
335 	iov_iter_bvec(&iter, READ, bvec, sgl_nents, len);
336 	if (is_write)
337 		ret = vfs_iter_write(fd, &iter, &pos, 0);
338 	else
339 		ret = vfs_iter_read(fd, &iter, &pos, 0);
340 
341 	if (is_write) {
342 		if (ret < 0 || ret != data_length) {
343 			pr_err("%s() write returned %d\n", __func__, ret);
344 			if (ret >= 0)
345 				ret = -EINVAL;
346 		}
347 	} else {
348 		/*
349 		 * Return zeros and GOOD status even if the READ did not return
350 		 * the expected virt_size for struct file w/o a backing struct
351 		 * block_device.
352 		 */
353 		if (S_ISBLK(file_inode(fd)->i_mode)) {
354 			if (ret < 0 || ret != data_length) {
355 				pr_err("%s() returned %d, expecting %u for "
356 						"S_ISBLK\n", __func__, ret,
357 						data_length);
358 				if (ret >= 0)
359 					ret = -EINVAL;
360 			}
361 		} else {
362 			if (ret < 0) {
363 				pr_err("%s() returned %d for non S_ISBLK\n",
364 						__func__, ret);
365 			} else if (ret != data_length) {
366 				/*
367 				 * Short read case:
368 				 * Probably some one truncate file under us.
369 				 * We must explicitly zero sg-pages to prevent
370 				 * expose uninizialized pages to userspace.
371 				 */
372 				if (ret < data_length)
373 					ret += iov_iter_zero(data_length - ret, &iter);
374 				else
375 					ret = -EINVAL;
376 			}
377 		}
378 	}
379 	kfree(bvec);
380 	return ret;
381 }
382 
383 static sense_reason_t
384 fd_execute_sync_cache(struct se_cmd *cmd)
385 {
386 	struct se_device *dev = cmd->se_dev;
387 	struct fd_dev *fd_dev = FD_DEV(dev);
388 	int immed = (cmd->t_task_cdb[1] & 0x2);
389 	loff_t start, end;
390 	int ret;
391 
392 	/*
393 	 * If the Immediate bit is set, queue up the GOOD response
394 	 * for this SYNCHRONIZE_CACHE op
395 	 */
396 	if (immed)
397 		target_complete_cmd(cmd, SAM_STAT_GOOD);
398 
399 	/*
400 	 * Determine if we will be flushing the entire device.
401 	 */
402 	if (cmd->t_task_lba == 0 && cmd->data_length == 0) {
403 		start = 0;
404 		end = LLONG_MAX;
405 	} else {
406 		start = cmd->t_task_lba * dev->dev_attrib.block_size;
407 		if (cmd->data_length)
408 			end = start + cmd->data_length - 1;
409 		else
410 			end = LLONG_MAX;
411 	}
412 
413 	ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);
414 	if (ret != 0)
415 		pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret);
416 
417 	if (immed)
418 		return 0;
419 
420 	if (ret)
421 		target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
422 	else
423 		target_complete_cmd(cmd, SAM_STAT_GOOD);
424 
425 	return 0;
426 }
427 
428 static sense_reason_t
429 fd_execute_write_same(struct se_cmd *cmd)
430 {
431 	struct se_device *se_dev = cmd->se_dev;
432 	struct fd_dev *fd_dev = FD_DEV(se_dev);
433 	loff_t pos = cmd->t_task_lba * se_dev->dev_attrib.block_size;
434 	sector_t nolb = sbc_get_write_same_sectors(cmd);
435 	struct iov_iter iter;
436 	struct bio_vec *bvec;
437 	unsigned int len = 0, i;
438 	ssize_t ret;
439 
440 	if (!nolb) {
441 		target_complete_cmd(cmd, SAM_STAT_GOOD);
442 		return 0;
443 	}
444 	if (cmd->prot_op) {
445 		pr_err("WRITE_SAME: Protection information with FILEIO"
446 		       " backends not supported\n");
447 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
448 	}
449 
450 	if (cmd->t_data_nents > 1 ||
451 	    cmd->t_data_sg[0].length != cmd->se_dev->dev_attrib.block_size) {
452 		pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"
453 			" block_size: %u\n",
454 			cmd->t_data_nents,
455 			cmd->t_data_sg[0].length,
456 			cmd->se_dev->dev_attrib.block_size);
457 		return TCM_INVALID_CDB_FIELD;
458 	}
459 
460 	bvec = kcalloc(nolb, sizeof(struct bio_vec), GFP_KERNEL);
461 	if (!bvec)
462 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
463 
464 	for (i = 0; i < nolb; i++) {
465 		bvec[i].bv_page = sg_page(&cmd->t_data_sg[0]);
466 		bvec[i].bv_len = cmd->t_data_sg[0].length;
467 		bvec[i].bv_offset = cmd->t_data_sg[0].offset;
468 
469 		len += se_dev->dev_attrib.block_size;
470 	}
471 
472 	iov_iter_bvec(&iter, READ, bvec, nolb, len);
473 	ret = vfs_iter_write(fd_dev->fd_file, &iter, &pos, 0);
474 
475 	kfree(bvec);
476 	if (ret < 0 || ret != len) {
477 		pr_err("vfs_iter_write() returned %zd for write same\n", ret);
478 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
479 	}
480 
481 	target_complete_cmd(cmd, SAM_STAT_GOOD);
482 	return 0;
483 }
484 
485 static int
486 fd_do_prot_fill(struct se_device *se_dev, sector_t lba, sector_t nolb,
487 		void *buf, size_t bufsize)
488 {
489 	struct fd_dev *fd_dev = FD_DEV(se_dev);
490 	struct file *prot_fd = fd_dev->fd_prot_file;
491 	sector_t prot_length, prot;
492 	loff_t pos = lba * se_dev->prot_length;
493 
494 	if (!prot_fd) {
495 		pr_err("Unable to locate fd_dev->fd_prot_file\n");
496 		return -ENODEV;
497 	}
498 
499 	prot_length = nolb * se_dev->prot_length;
500 
501 	for (prot = 0; prot < prot_length;) {
502 		sector_t len = min_t(sector_t, bufsize, prot_length - prot);
503 		ssize_t ret = kernel_write(prot_fd, buf, len, &pos);
504 
505 		if (ret != len) {
506 			pr_err("vfs_write to prot file failed: %zd\n", ret);
507 			return ret < 0 ? ret : -ENODEV;
508 		}
509 		prot += ret;
510 	}
511 
512 	return 0;
513 }
514 
515 static int
516 fd_do_prot_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)
517 {
518 	void *buf;
519 	int rc;
520 
521 	buf = (void *)__get_free_page(GFP_KERNEL);
522 	if (!buf) {
523 		pr_err("Unable to allocate FILEIO prot buf\n");
524 		return -ENOMEM;
525 	}
526 	memset(buf, 0xff, PAGE_SIZE);
527 
528 	rc = fd_do_prot_fill(cmd->se_dev, lba, nolb, buf, PAGE_SIZE);
529 
530 	free_page((unsigned long)buf);
531 
532 	return rc;
533 }
534 
535 static sense_reason_t
536 fd_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)
537 {
538 	struct file *file = FD_DEV(cmd->se_dev)->fd_file;
539 	struct inode *inode = file->f_mapping->host;
540 	int ret;
541 
542 	if (!nolb) {
543 		return 0;
544 	}
545 
546 	if (cmd->se_dev->dev_attrib.pi_prot_type) {
547 		ret = fd_do_prot_unmap(cmd, lba, nolb);
548 		if (ret)
549 			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
550 	}
551 
552 	if (S_ISBLK(inode->i_mode)) {
553 		/* The backend is block device, use discard */
554 		struct block_device *bdev = I_BDEV(inode);
555 		struct se_device *dev = cmd->se_dev;
556 
557 		ret = blkdev_issue_discard(bdev,
558 					   target_to_linux_sector(dev, lba),
559 					   target_to_linux_sector(dev,  nolb),
560 					   GFP_KERNEL, 0);
561 		if (ret < 0) {
562 			pr_warn("FILEIO: blkdev_issue_discard() failed: %d\n",
563 				ret);
564 			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
565 		}
566 	} else {
567 		/* The backend is normal file, use fallocate */
568 		struct se_device *se_dev = cmd->se_dev;
569 		loff_t pos = lba * se_dev->dev_attrib.block_size;
570 		unsigned int len = nolb * se_dev->dev_attrib.block_size;
571 		int mode = FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE;
572 
573 		if (!file->f_op->fallocate)
574 			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
575 
576 		ret = file->f_op->fallocate(file, mode, pos, len);
577 		if (ret < 0) {
578 			pr_warn("FILEIO: fallocate() failed: %d\n", ret);
579 			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
580 		}
581 	}
582 
583 	return 0;
584 }
585 
586 static sense_reason_t
587 fd_execute_rw_buffered(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
588 	      enum dma_data_direction data_direction)
589 {
590 	struct se_device *dev = cmd->se_dev;
591 	struct fd_dev *fd_dev = FD_DEV(dev);
592 	struct file *file = fd_dev->fd_file;
593 	struct file *pfile = fd_dev->fd_prot_file;
594 	sense_reason_t rc;
595 	int ret = 0;
596 	/*
597 	 * Call vectorized fileio functions to map struct scatterlist
598 	 * physical memory addresses to struct iovec virtual memory.
599 	 */
600 	if (data_direction == DMA_FROM_DEVICE) {
601 		if (cmd->prot_type && dev->dev_attrib.pi_prot_type) {
602 			ret = fd_do_rw(cmd, pfile, dev->prot_length,
603 				       cmd->t_prot_sg, cmd->t_prot_nents,
604 				       cmd->prot_length, 0);
605 			if (ret < 0)
606 				return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
607 		}
608 
609 		ret = fd_do_rw(cmd, file, dev->dev_attrib.block_size,
610 			       sgl, sgl_nents, cmd->data_length, 0);
611 
612 		if (ret > 0 && cmd->prot_type && dev->dev_attrib.pi_prot_type &&
613 		    dev->dev_attrib.pi_prot_verify) {
614 			u32 sectors = cmd->data_length >>
615 					ilog2(dev->dev_attrib.block_size);
616 
617 			rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors,
618 					    0, cmd->t_prot_sg, 0);
619 			if (rc)
620 				return rc;
621 		}
622 	} else {
623 		if (cmd->prot_type && dev->dev_attrib.pi_prot_type &&
624 		    dev->dev_attrib.pi_prot_verify) {
625 			u32 sectors = cmd->data_length >>
626 					ilog2(dev->dev_attrib.block_size);
627 
628 			rc = sbc_dif_verify(cmd, cmd->t_task_lba, sectors,
629 					    0, cmd->t_prot_sg, 0);
630 			if (rc)
631 				return rc;
632 		}
633 
634 		ret = fd_do_rw(cmd, file, dev->dev_attrib.block_size,
635 			       sgl, sgl_nents, cmd->data_length, 1);
636 		/*
637 		 * Perform implicit vfs_fsync_range() for fd_do_writev() ops
638 		 * for SCSI WRITEs with Forced Unit Access (FUA) set.
639 		 * Allow this to happen independent of WCE=0 setting.
640 		 */
641 		if (ret > 0 && (cmd->se_cmd_flags & SCF_FUA)) {
642 			loff_t start = cmd->t_task_lba *
643 				dev->dev_attrib.block_size;
644 			loff_t end;
645 
646 			if (cmd->data_length)
647 				end = start + cmd->data_length - 1;
648 			else
649 				end = LLONG_MAX;
650 
651 			vfs_fsync_range(fd_dev->fd_file, start, end, 1);
652 		}
653 
654 		if (ret > 0 && cmd->prot_type && dev->dev_attrib.pi_prot_type) {
655 			ret = fd_do_rw(cmd, pfile, dev->prot_length,
656 				       cmd->t_prot_sg, cmd->t_prot_nents,
657 				       cmd->prot_length, 1);
658 			if (ret < 0)
659 				return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
660 		}
661 	}
662 
663 	if (ret < 0)
664 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
665 
666 	target_complete_cmd(cmd, SAM_STAT_GOOD);
667 	return 0;
668 }
669 
670 static sense_reason_t
671 fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
672 	      enum dma_data_direction data_direction)
673 {
674 	struct se_device *dev = cmd->se_dev;
675 	struct fd_dev *fd_dev = FD_DEV(dev);
676 
677 	/*
678 	 * We are currently limited by the number of iovecs (2048) per
679 	 * single vfs_[writev,readv] call.
680 	 */
681 	if (cmd->data_length > FD_MAX_BYTES) {
682 		pr_err("FILEIO: Not able to process I/O of %u bytes due to"
683 		       "FD_MAX_BYTES: %u iovec count limitation\n",
684 			cmd->data_length, FD_MAX_BYTES);
685 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
686 	}
687 
688 	if (fd_dev->fbd_flags & FDBD_HAS_ASYNC_IO)
689 		return fd_execute_rw_aio(cmd, sgl, sgl_nents, data_direction);
690 	return fd_execute_rw_buffered(cmd, sgl, sgl_nents, data_direction);
691 }
692 
693 enum {
694 	Opt_fd_dev_name, Opt_fd_dev_size, Opt_fd_buffered_io,
695 	Opt_fd_async_io, Opt_err
696 };
697 
698 static match_table_t tokens = {
699 	{Opt_fd_dev_name, "fd_dev_name=%s"},
700 	{Opt_fd_dev_size, "fd_dev_size=%s"},
701 	{Opt_fd_buffered_io, "fd_buffered_io=%d"},
702 	{Opt_fd_async_io, "fd_async_io=%d"},
703 	{Opt_err, NULL}
704 };
705 
706 static ssize_t fd_set_configfs_dev_params(struct se_device *dev,
707 		const char *page, ssize_t count)
708 {
709 	struct fd_dev *fd_dev = FD_DEV(dev);
710 	char *orig, *ptr, *arg_p, *opts;
711 	substring_t args[MAX_OPT_ARGS];
712 	int ret = 0, arg, token;
713 
714 	opts = kstrdup(page, GFP_KERNEL);
715 	if (!opts)
716 		return -ENOMEM;
717 
718 	orig = opts;
719 
720 	while ((ptr = strsep(&opts, ",\n")) != NULL) {
721 		if (!*ptr)
722 			continue;
723 
724 		token = match_token(ptr, tokens, args);
725 		switch (token) {
726 		case Opt_fd_dev_name:
727 			if (match_strlcpy(fd_dev->fd_dev_name, &args[0],
728 				FD_MAX_DEV_NAME) == 0) {
729 				ret = -EINVAL;
730 				break;
731 			}
732 			pr_debug("FILEIO: Referencing Path: %s\n",
733 					fd_dev->fd_dev_name);
734 			fd_dev->fbd_flags |= FBDF_HAS_PATH;
735 			break;
736 		case Opt_fd_dev_size:
737 			arg_p = match_strdup(&args[0]);
738 			if (!arg_p) {
739 				ret = -ENOMEM;
740 				break;
741 			}
742 			ret = kstrtoull(arg_p, 0, &fd_dev->fd_dev_size);
743 			kfree(arg_p);
744 			if (ret < 0) {
745 				pr_err("kstrtoull() failed for"
746 						" fd_dev_size=\n");
747 				goto out;
748 			}
749 			pr_debug("FILEIO: Referencing Size: %llu"
750 					" bytes\n", fd_dev->fd_dev_size);
751 			fd_dev->fbd_flags |= FBDF_HAS_SIZE;
752 			break;
753 		case Opt_fd_buffered_io:
754 			ret = match_int(args, &arg);
755 			if (ret)
756 				goto out;
757 			if (arg != 1) {
758 				pr_err("bogus fd_buffered_io=%d value\n", arg);
759 				ret = -EINVAL;
760 				goto out;
761 			}
762 
763 			pr_debug("FILEIO: Using buffered I/O"
764 				" operations for struct fd_dev\n");
765 
766 			fd_dev->fbd_flags |= FDBD_HAS_BUFFERED_IO_WCE;
767 			break;
768 		case Opt_fd_async_io:
769 			ret = match_int(args, &arg);
770 			if (ret)
771 				goto out;
772 			if (arg != 1) {
773 				pr_err("bogus fd_async_io=%d value\n", arg);
774 				ret = -EINVAL;
775 				goto out;
776 			}
777 
778 			pr_debug("FILEIO: Using async I/O"
779 				" operations for struct fd_dev\n");
780 
781 			fd_dev->fbd_flags |= FDBD_HAS_ASYNC_IO;
782 			break;
783 		default:
784 			break;
785 		}
786 	}
787 
788 out:
789 	kfree(orig);
790 	return (!ret) ? count : ret;
791 }
792 
793 static ssize_t fd_show_configfs_dev_params(struct se_device *dev, char *b)
794 {
795 	struct fd_dev *fd_dev = FD_DEV(dev);
796 	ssize_t bl = 0;
797 
798 	bl = sprintf(b + bl, "TCM FILEIO ID: %u", fd_dev->fd_dev_id);
799 	bl += sprintf(b + bl, "        File: %s  Size: %llu  Mode: %s Async: %d\n",
800 		fd_dev->fd_dev_name, fd_dev->fd_dev_size,
801 		(fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) ?
802 		"Buffered-WCE" : "O_DSYNC",
803 		!!(fd_dev->fbd_flags & FDBD_HAS_ASYNC_IO));
804 	return bl;
805 }
806 
807 static sector_t fd_get_blocks(struct se_device *dev)
808 {
809 	struct fd_dev *fd_dev = FD_DEV(dev);
810 	struct file *f = fd_dev->fd_file;
811 	struct inode *i = f->f_mapping->host;
812 	unsigned long long dev_size;
813 	/*
814 	 * When using a file that references an underlying struct block_device,
815 	 * ensure dev_size is always based on the current inode size in order
816 	 * to handle underlying block_device resize operations.
817 	 */
818 	if (S_ISBLK(i->i_mode))
819 		dev_size = i_size_read(i);
820 	else
821 		dev_size = fd_dev->fd_dev_size;
822 
823 	return div_u64(dev_size - dev->dev_attrib.block_size,
824 		       dev->dev_attrib.block_size);
825 }
826 
827 static int fd_init_prot(struct se_device *dev)
828 {
829 	struct fd_dev *fd_dev = FD_DEV(dev);
830 	struct file *prot_file, *file = fd_dev->fd_file;
831 	struct inode *inode;
832 	int ret, flags = O_RDWR | O_CREAT | O_LARGEFILE | O_DSYNC;
833 	char buf[FD_MAX_DEV_PROT_NAME];
834 
835 	if (!file) {
836 		pr_err("Unable to locate fd_dev->fd_file\n");
837 		return -ENODEV;
838 	}
839 
840 	inode = file->f_mapping->host;
841 	if (S_ISBLK(inode->i_mode)) {
842 		pr_err("FILEIO Protection emulation only supported on"
843 		       " !S_ISBLK\n");
844 		return -ENOSYS;
845 	}
846 
847 	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE)
848 		flags &= ~O_DSYNC;
849 
850 	snprintf(buf, FD_MAX_DEV_PROT_NAME, "%s.protection",
851 		 fd_dev->fd_dev_name);
852 
853 	prot_file = filp_open(buf, flags, 0600);
854 	if (IS_ERR(prot_file)) {
855 		pr_err("filp_open(%s) failed\n", buf);
856 		ret = PTR_ERR(prot_file);
857 		return ret;
858 	}
859 	fd_dev->fd_prot_file = prot_file;
860 
861 	return 0;
862 }
863 
864 static int fd_format_prot(struct se_device *dev)
865 {
866 	unsigned char *buf;
867 	int unit_size = FDBD_FORMAT_UNIT_SIZE * dev->dev_attrib.block_size;
868 	int ret;
869 
870 	if (!dev->dev_attrib.pi_prot_type) {
871 		pr_err("Unable to format_prot while pi_prot_type == 0\n");
872 		return -ENODEV;
873 	}
874 
875 	buf = vzalloc(unit_size);
876 	if (!buf) {
877 		pr_err("Unable to allocate FILEIO prot buf\n");
878 		return -ENOMEM;
879 	}
880 
881 	pr_debug("Using FILEIO prot_length: %llu\n",
882 		 (unsigned long long)(dev->transport->get_blocks(dev) + 1) *
883 					dev->prot_length);
884 
885 	memset(buf, 0xff, unit_size);
886 	ret = fd_do_prot_fill(dev, 0, dev->transport->get_blocks(dev) + 1,
887 			      buf, unit_size);
888 	vfree(buf);
889 	return ret;
890 }
891 
892 static void fd_free_prot(struct se_device *dev)
893 {
894 	struct fd_dev *fd_dev = FD_DEV(dev);
895 
896 	if (!fd_dev->fd_prot_file)
897 		return;
898 
899 	filp_close(fd_dev->fd_prot_file, NULL);
900 	fd_dev->fd_prot_file = NULL;
901 }
902 
903 static struct sbc_ops fd_sbc_ops = {
904 	.execute_rw		= fd_execute_rw,
905 	.execute_sync_cache	= fd_execute_sync_cache,
906 	.execute_write_same	= fd_execute_write_same,
907 	.execute_unmap		= fd_execute_unmap,
908 };
909 
910 static sense_reason_t
911 fd_parse_cdb(struct se_cmd *cmd)
912 {
913 	return sbc_parse_cdb(cmd, &fd_sbc_ops);
914 }
915 
916 static const struct target_backend_ops fileio_ops = {
917 	.name			= "fileio",
918 	.inquiry_prod		= "FILEIO",
919 	.inquiry_rev		= FD_VERSION,
920 	.owner			= THIS_MODULE,
921 	.attach_hba		= fd_attach_hba,
922 	.detach_hba		= fd_detach_hba,
923 	.alloc_device		= fd_alloc_device,
924 	.configure_device	= fd_configure_device,
925 	.destroy_device		= fd_destroy_device,
926 	.free_device		= fd_free_device,
927 	.parse_cdb		= fd_parse_cdb,
928 	.set_configfs_dev_params = fd_set_configfs_dev_params,
929 	.show_configfs_dev_params = fd_show_configfs_dev_params,
930 	.get_device_type	= sbc_get_device_type,
931 	.get_blocks		= fd_get_blocks,
932 	.init_prot		= fd_init_prot,
933 	.format_prot		= fd_format_prot,
934 	.free_prot		= fd_free_prot,
935 	.tb_dev_attrib_attrs	= sbc_attrib_attrs,
936 };
937 
938 static int __init fileio_module_init(void)
939 {
940 	return transport_backend_register(&fileio_ops);
941 }
942 
943 static void __exit fileio_module_exit(void)
944 {
945 	target_backend_unregister(&fileio_ops);
946 }
947 
948 MODULE_DESCRIPTION("TCM FILEIO subsystem plugin");
949 MODULE_AUTHOR("nab@Linux-iSCSI.org");
950 MODULE_LICENSE("GPL");
951 
952 module_init(fileio_module_init);
953 module_exit(fileio_module_exit);
954