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 #include <target/target_core_backend_configfs.h>
41 
42 #include "target_core_file.h"
43 
44 static inline struct fd_dev *FD_DEV(struct se_device *dev)
45 {
46 	return container_of(dev, struct fd_dev, dev);
47 }
48 
49 /*	fd_attach_hba(): (Part of se_subsystem_api_t template)
50  *
51  *
52  */
53 static int fd_attach_hba(struct se_hba *hba, u32 host_id)
54 {
55 	struct fd_host *fd_host;
56 
57 	fd_host = kzalloc(sizeof(struct fd_host), GFP_KERNEL);
58 	if (!fd_host) {
59 		pr_err("Unable to allocate memory for struct fd_host\n");
60 		return -ENOMEM;
61 	}
62 
63 	fd_host->fd_host_id = host_id;
64 
65 	hba->hba_ptr = fd_host;
66 
67 	pr_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic"
68 		" Target Core Stack %s\n", hba->hba_id, FD_VERSION,
69 		TARGET_CORE_MOD_VERSION);
70 	pr_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic\n",
71 		hba->hba_id, fd_host->fd_host_id);
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.max_bytes_per_io = FD_MAX_BYTES;
224 	dev->dev_attrib.hw_max_sectors = FD_MAX_BYTES / fd_dev->fd_block_size;
225 	dev->dev_attrib.hw_queue_depth = FD_MAX_DEVICE_QUEUE_DEPTH;
226 
227 	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {
228 		pr_debug("FILEIO: Forcing setting of emulate_write_cache=1"
229 			" with FDBD_HAS_BUFFERED_IO_WCE\n");
230 		dev->dev_attrib.emulate_write_cache = 1;
231 	}
232 
233 	fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++;
234 	fd_dev->fd_queue_depth = dev->queue_depth;
235 
236 	pr_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s,"
237 		" %llu total bytes\n", fd_host->fd_host_id, fd_dev->fd_dev_id,
238 			fd_dev->fd_dev_name, fd_dev->fd_dev_size);
239 
240 	return 0;
241 fail:
242 	if (fd_dev->fd_file) {
243 		filp_close(fd_dev->fd_file, NULL);
244 		fd_dev->fd_file = NULL;
245 	}
246 	return ret;
247 }
248 
249 static void fd_free_device(struct se_device *dev)
250 {
251 	struct fd_dev *fd_dev = FD_DEV(dev);
252 
253 	if (fd_dev->fd_file) {
254 		filp_close(fd_dev->fd_file, NULL);
255 		fd_dev->fd_file = NULL;
256 	}
257 
258 	kfree(fd_dev);
259 }
260 
261 static int fd_do_prot_rw(struct se_cmd *cmd, struct fd_prot *fd_prot,
262 			 int is_write)
263 {
264 	struct se_device *se_dev = cmd->se_dev;
265 	struct fd_dev *dev = FD_DEV(se_dev);
266 	struct file *prot_fd = dev->fd_prot_file;
267 	struct scatterlist *sg;
268 	loff_t pos = (cmd->t_task_lba * se_dev->prot_length);
269 	unsigned char *buf;
270 	u32 prot_size, len, size;
271 	int rc, ret = 1, i;
272 
273 	prot_size = (cmd->data_length / se_dev->dev_attrib.block_size) *
274 		     se_dev->prot_length;
275 
276 	if (!is_write) {
277 		fd_prot->prot_buf = vzalloc(prot_size);
278 		if (!fd_prot->prot_buf) {
279 			pr_err("Unable to allocate fd_prot->prot_buf\n");
280 			return -ENOMEM;
281 		}
282 		buf = fd_prot->prot_buf;
283 
284 		fd_prot->prot_sg_nents = cmd->t_prot_nents;
285 		fd_prot->prot_sg = kzalloc(sizeof(struct scatterlist) *
286 					   fd_prot->prot_sg_nents, GFP_KERNEL);
287 		if (!fd_prot->prot_sg) {
288 			pr_err("Unable to allocate fd_prot->prot_sg\n");
289 			vfree(fd_prot->prot_buf);
290 			return -ENOMEM;
291 		}
292 		size = prot_size;
293 
294 		for_each_sg(fd_prot->prot_sg, sg, fd_prot->prot_sg_nents, i) {
295 
296 			len = min_t(u32, PAGE_SIZE, size);
297 			sg_set_buf(sg, buf, len);
298 			size -= len;
299 			buf += len;
300 		}
301 	}
302 
303 	if (is_write) {
304 		rc = kernel_write(prot_fd, fd_prot->prot_buf, prot_size, pos);
305 		if (rc < 0 || prot_size != rc) {
306 			pr_err("kernel_write() for fd_do_prot_rw failed:"
307 			       " %d\n", rc);
308 			ret = -EINVAL;
309 		}
310 	} else {
311 		rc = kernel_read(prot_fd, pos, fd_prot->prot_buf, prot_size);
312 		if (rc < 0) {
313 			pr_err("kernel_read() for fd_do_prot_rw failed:"
314 			       " %d\n", rc);
315 			ret = -EINVAL;
316 		}
317 	}
318 
319 	if (is_write || ret < 0) {
320 		kfree(fd_prot->prot_sg);
321 		vfree(fd_prot->prot_buf);
322 	}
323 
324 	return ret;
325 }
326 
327 static int fd_do_rw(struct se_cmd *cmd, struct scatterlist *sgl,
328 		u32 sgl_nents, int is_write)
329 {
330 	struct se_device *se_dev = cmd->se_dev;
331 	struct fd_dev *dev = FD_DEV(se_dev);
332 	struct file *fd = dev->fd_file;
333 	struct scatterlist *sg;
334 	struct iovec *iov;
335 	mm_segment_t old_fs;
336 	loff_t pos = (cmd->t_task_lba * se_dev->dev_attrib.block_size);
337 	int ret = 0, i;
338 
339 	iov = kzalloc(sizeof(struct iovec) * sgl_nents, GFP_KERNEL);
340 	if (!iov) {
341 		pr_err("Unable to allocate fd_do_readv iov[]\n");
342 		return -ENOMEM;
343 	}
344 
345 	for_each_sg(sgl, sg, sgl_nents, i) {
346 		iov[i].iov_len = sg->length;
347 		iov[i].iov_base = kmap(sg_page(sg)) + sg->offset;
348 	}
349 
350 	old_fs = get_fs();
351 	set_fs(get_ds());
352 
353 	if (is_write)
354 		ret = vfs_writev(fd, &iov[0], sgl_nents, &pos);
355 	else
356 		ret = vfs_readv(fd, &iov[0], sgl_nents, &pos);
357 
358 	set_fs(old_fs);
359 
360 	for_each_sg(sgl, sg, sgl_nents, i)
361 		kunmap(sg_page(sg));
362 
363 	kfree(iov);
364 
365 	if (is_write) {
366 		if (ret < 0 || ret != cmd->data_length) {
367 			pr_err("%s() write returned %d\n", __func__, ret);
368 			return (ret < 0 ? ret : -EINVAL);
369 		}
370 	} else {
371 		/*
372 		 * Return zeros and GOOD status even if the READ did not return
373 		 * the expected virt_size for struct file w/o a backing struct
374 		 * block_device.
375 		 */
376 		if (S_ISBLK(file_inode(fd)->i_mode)) {
377 			if (ret < 0 || ret != cmd->data_length) {
378 				pr_err("%s() returned %d, expecting %u for "
379 						"S_ISBLK\n", __func__, ret,
380 						cmd->data_length);
381 				return (ret < 0 ? ret : -EINVAL);
382 			}
383 		} else {
384 			if (ret < 0) {
385 				pr_err("%s() returned %d for non S_ISBLK\n",
386 						__func__, ret);
387 				return ret;
388 			}
389 		}
390 	}
391 	return 1;
392 }
393 
394 static sense_reason_t
395 fd_execute_sync_cache(struct se_cmd *cmd)
396 {
397 	struct se_device *dev = cmd->se_dev;
398 	struct fd_dev *fd_dev = FD_DEV(dev);
399 	int immed = (cmd->t_task_cdb[1] & 0x2);
400 	loff_t start, end;
401 	int ret;
402 
403 	/*
404 	 * If the Immediate bit is set, queue up the GOOD response
405 	 * for this SYNCHRONIZE_CACHE op
406 	 */
407 	if (immed)
408 		target_complete_cmd(cmd, SAM_STAT_GOOD);
409 
410 	/*
411 	 * Determine if we will be flushing the entire device.
412 	 */
413 	if (cmd->t_task_lba == 0 && cmd->data_length == 0) {
414 		start = 0;
415 		end = LLONG_MAX;
416 	} else {
417 		start = cmd->t_task_lba * dev->dev_attrib.block_size;
418 		if (cmd->data_length)
419 			end = start + cmd->data_length - 1;
420 		else
421 			end = LLONG_MAX;
422 	}
423 
424 	ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);
425 	if (ret != 0)
426 		pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret);
427 
428 	if (immed)
429 		return 0;
430 
431 	if (ret)
432 		target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
433 	else
434 		target_complete_cmd(cmd, SAM_STAT_GOOD);
435 
436 	return 0;
437 }
438 
439 static unsigned char *
440 fd_setup_write_same_buf(struct se_cmd *cmd, struct scatterlist *sg,
441 		    unsigned int len)
442 {
443 	struct se_device *se_dev = cmd->se_dev;
444 	unsigned int block_size = se_dev->dev_attrib.block_size;
445 	unsigned int i = 0, end;
446 	unsigned char *buf, *p, *kmap_buf;
447 
448 	buf = kzalloc(min_t(unsigned int, len, PAGE_SIZE), GFP_KERNEL);
449 	if (!buf) {
450 		pr_err("Unable to allocate fd_execute_write_same buf\n");
451 		return NULL;
452 	}
453 
454 	kmap_buf = kmap(sg_page(sg)) + sg->offset;
455 	if (!kmap_buf) {
456 		pr_err("kmap() failed in fd_setup_write_same\n");
457 		kfree(buf);
458 		return NULL;
459 	}
460 	/*
461 	 * Fill local *buf to contain multiple WRITE_SAME blocks up to
462 	 * min(len, PAGE_SIZE)
463 	 */
464 	p = buf;
465 	end = min_t(unsigned int, len, PAGE_SIZE);
466 
467 	while (i < end) {
468 		memcpy(p, kmap_buf, block_size);
469 
470 		i += block_size;
471 		p += block_size;
472 	}
473 	kunmap(sg_page(sg));
474 
475 	return buf;
476 }
477 
478 static sense_reason_t
479 fd_execute_write_same(struct se_cmd *cmd)
480 {
481 	struct se_device *se_dev = cmd->se_dev;
482 	struct fd_dev *fd_dev = FD_DEV(se_dev);
483 	struct file *f = fd_dev->fd_file;
484 	struct scatterlist *sg;
485 	struct iovec *iov;
486 	mm_segment_t old_fs;
487 	sector_t nolb = sbc_get_write_same_sectors(cmd);
488 	loff_t pos = cmd->t_task_lba * se_dev->dev_attrib.block_size;
489 	unsigned int len, len_tmp, iov_num;
490 	int i, rc;
491 	unsigned char *buf;
492 
493 	if (!nolb) {
494 		target_complete_cmd(cmd, SAM_STAT_GOOD);
495 		return 0;
496 	}
497 	sg = &cmd->t_data_sg[0];
498 
499 	if (cmd->t_data_nents > 1 ||
500 	    sg->length != cmd->se_dev->dev_attrib.block_size) {
501 		pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"
502 			" block_size: %u\n", cmd->t_data_nents, sg->length,
503 			cmd->se_dev->dev_attrib.block_size);
504 		return TCM_INVALID_CDB_FIELD;
505 	}
506 
507 	len = len_tmp = nolb * se_dev->dev_attrib.block_size;
508 	iov_num = DIV_ROUND_UP(len, PAGE_SIZE);
509 
510 	buf = fd_setup_write_same_buf(cmd, sg, len);
511 	if (!buf)
512 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
513 
514 	iov = vzalloc(sizeof(struct iovec) * iov_num);
515 	if (!iov) {
516 		pr_err("Unable to allocate fd_execute_write_same iovecs\n");
517 		kfree(buf);
518 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
519 	}
520 	/*
521 	 * Map the single fabric received scatterlist block now populated
522 	 * in *buf into each iovec for I/O submission.
523 	 */
524 	for (i = 0; i < iov_num; i++) {
525 		iov[i].iov_base = buf;
526 		iov[i].iov_len = min_t(unsigned int, len_tmp, PAGE_SIZE);
527 		len_tmp -= iov[i].iov_len;
528 	}
529 
530 	old_fs = get_fs();
531 	set_fs(get_ds());
532 	rc = vfs_writev(f, &iov[0], iov_num, &pos);
533 	set_fs(old_fs);
534 
535 	vfree(iov);
536 	kfree(buf);
537 
538 	if (rc < 0 || rc != len) {
539 		pr_err("vfs_writev() returned %d for write same\n", rc);
540 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
541 	}
542 
543 	target_complete_cmd(cmd, SAM_STAT_GOOD);
544 	return 0;
545 }
546 
547 static sense_reason_t
548 fd_do_unmap(struct se_cmd *cmd, void *priv, sector_t lba, sector_t nolb)
549 {
550 	struct file *file = priv;
551 	struct inode *inode = file->f_mapping->host;
552 	int ret;
553 
554 	if (S_ISBLK(inode->i_mode)) {
555 		/* The backend is block device, use discard */
556 		struct block_device *bdev = inode->i_bdev;
557 
558 		ret = blkdev_issue_discard(bdev, lba,
559 				nolb, GFP_KERNEL, 0);
560 		if (ret < 0) {
561 			pr_warn("FILEIO: blkdev_issue_discard() failed: %d\n",
562 				ret);
563 			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
564 		}
565 	} else {
566 		/* The backend is normal file, use fallocate */
567 		struct se_device *se_dev = cmd->se_dev;
568 		loff_t pos = lba * se_dev->dev_attrib.block_size;
569 		unsigned int len = nolb * se_dev->dev_attrib.block_size;
570 		int mode = FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE;
571 
572 		if (!file->f_op->fallocate)
573 			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
574 
575 		ret = file->f_op->fallocate(file, mode, pos, len);
576 		if (ret < 0) {
577 			pr_warn("FILEIO: fallocate() failed: %d\n", ret);
578 			return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
579 		}
580 	}
581 
582 	return 0;
583 }
584 
585 static sense_reason_t
586 fd_execute_write_same_unmap(struct se_cmd *cmd)
587 {
588 	struct se_device *se_dev = cmd->se_dev;
589 	struct fd_dev *fd_dev = FD_DEV(se_dev);
590 	struct file *file = fd_dev->fd_file;
591 	sector_t lba = cmd->t_task_lba;
592 	sector_t nolb = sbc_get_write_same_sectors(cmd);
593 	int ret;
594 
595 	if (!nolb) {
596 		target_complete_cmd(cmd, SAM_STAT_GOOD);
597 		return 0;
598 	}
599 
600 	ret = fd_do_unmap(cmd, file, lba, nolb);
601 	if (ret)
602 		return ret;
603 
604 	target_complete_cmd(cmd, GOOD);
605 	return 0;
606 }
607 
608 static sense_reason_t
609 fd_execute_unmap(struct se_cmd *cmd)
610 {
611 	struct file *file = FD_DEV(cmd->se_dev)->fd_file;
612 
613 	return sbc_execute_unmap(cmd, fd_do_unmap, file);
614 }
615 
616 static sense_reason_t
617 fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
618 	      enum dma_data_direction data_direction)
619 {
620 	struct se_device *dev = cmd->se_dev;
621 	struct fd_prot fd_prot;
622 	sense_reason_t rc;
623 	int ret = 0;
624 	/*
625 	 * We are currently limited by the number of iovecs (2048) per
626 	 * single vfs_[writev,readv] call.
627 	 */
628 	if (cmd->data_length > FD_MAX_BYTES) {
629 		pr_err("FILEIO: Not able to process I/O of %u bytes due to"
630 		       "FD_MAX_BYTES: %u iovec count limitiation\n",
631 			cmd->data_length, FD_MAX_BYTES);
632 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
633 	}
634 	/*
635 	 * Call vectorized fileio functions to map struct scatterlist
636 	 * physical memory addresses to struct iovec virtual memory.
637 	 */
638 	if (data_direction == DMA_FROM_DEVICE) {
639 		memset(&fd_prot, 0, sizeof(struct fd_prot));
640 
641 		if (cmd->prot_type) {
642 			ret = fd_do_prot_rw(cmd, &fd_prot, false);
643 			if (ret < 0)
644 				return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
645 		}
646 
647 		ret = fd_do_rw(cmd, sgl, sgl_nents, 0);
648 
649 		if (ret > 0 && cmd->prot_type) {
650 			u32 sectors = cmd->data_length / dev->dev_attrib.block_size;
651 
652 			rc = sbc_dif_verify_read(cmd, cmd->t_task_lba, sectors,
653 						 0, fd_prot.prot_sg, 0);
654 			if (rc) {
655 				kfree(fd_prot.prot_sg);
656 				vfree(fd_prot.prot_buf);
657 				return rc;
658 			}
659 			kfree(fd_prot.prot_sg);
660 			vfree(fd_prot.prot_buf);
661 		}
662 	} else {
663 		memset(&fd_prot, 0, sizeof(struct fd_prot));
664 
665 		if (cmd->prot_type) {
666 			u32 sectors = cmd->data_length / dev->dev_attrib.block_size;
667 
668 			ret = fd_do_prot_rw(cmd, &fd_prot, false);
669 			if (ret < 0)
670 				return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
671 
672 			rc = sbc_dif_verify_write(cmd, cmd->t_task_lba, sectors,
673 						  0, fd_prot.prot_sg, 0);
674 			if (rc) {
675 				kfree(fd_prot.prot_sg);
676 				vfree(fd_prot.prot_buf);
677 				return rc;
678 			}
679 		}
680 
681 		ret = fd_do_rw(cmd, sgl, sgl_nents, 1);
682 		/*
683 		 * Perform implicit vfs_fsync_range() for fd_do_writev() ops
684 		 * for SCSI WRITEs with Forced Unit Access (FUA) set.
685 		 * Allow this to happen independent of WCE=0 setting.
686 		 */
687 		if (ret > 0 &&
688 		    dev->dev_attrib.emulate_fua_write > 0 &&
689 		    (cmd->se_cmd_flags & SCF_FUA)) {
690 			struct fd_dev *fd_dev = FD_DEV(dev);
691 			loff_t start = cmd->t_task_lba *
692 				dev->dev_attrib.block_size;
693 			loff_t end;
694 
695 			if (cmd->data_length)
696 				end = start + cmd->data_length - 1;
697 			else
698 				end = LLONG_MAX;
699 
700 			vfs_fsync_range(fd_dev->fd_file, start, end, 1);
701 		}
702 
703 		if (ret > 0 && cmd->prot_type) {
704 			ret = fd_do_prot_rw(cmd, &fd_prot, true);
705 			if (ret < 0)
706 				return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
707 		}
708 	}
709 
710 	if (ret < 0) {
711 		kfree(fd_prot.prot_sg);
712 		vfree(fd_prot.prot_buf);
713 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
714 	}
715 
716 	if (ret)
717 		target_complete_cmd(cmd, SAM_STAT_GOOD);
718 	return 0;
719 }
720 
721 enum {
722 	Opt_fd_dev_name, Opt_fd_dev_size, Opt_fd_buffered_io, Opt_err
723 };
724 
725 static match_table_t tokens = {
726 	{Opt_fd_dev_name, "fd_dev_name=%s"},
727 	{Opt_fd_dev_size, "fd_dev_size=%s"},
728 	{Opt_fd_buffered_io, "fd_buffered_io=%d"},
729 	{Opt_err, NULL}
730 };
731 
732 static ssize_t fd_set_configfs_dev_params(struct se_device *dev,
733 		const char *page, ssize_t count)
734 {
735 	struct fd_dev *fd_dev = FD_DEV(dev);
736 	char *orig, *ptr, *arg_p, *opts;
737 	substring_t args[MAX_OPT_ARGS];
738 	int ret = 0, arg, token;
739 
740 	opts = kstrdup(page, GFP_KERNEL);
741 	if (!opts)
742 		return -ENOMEM;
743 
744 	orig = opts;
745 
746 	while ((ptr = strsep(&opts, ",\n")) != NULL) {
747 		if (!*ptr)
748 			continue;
749 
750 		token = match_token(ptr, tokens, args);
751 		switch (token) {
752 		case Opt_fd_dev_name:
753 			if (match_strlcpy(fd_dev->fd_dev_name, &args[0],
754 				FD_MAX_DEV_NAME) == 0) {
755 				ret = -EINVAL;
756 				break;
757 			}
758 			pr_debug("FILEIO: Referencing Path: %s\n",
759 					fd_dev->fd_dev_name);
760 			fd_dev->fbd_flags |= FBDF_HAS_PATH;
761 			break;
762 		case Opt_fd_dev_size:
763 			arg_p = match_strdup(&args[0]);
764 			if (!arg_p) {
765 				ret = -ENOMEM;
766 				break;
767 			}
768 			ret = kstrtoull(arg_p, 0, &fd_dev->fd_dev_size);
769 			kfree(arg_p);
770 			if (ret < 0) {
771 				pr_err("kstrtoull() failed for"
772 						" fd_dev_size=\n");
773 				goto out;
774 			}
775 			pr_debug("FILEIO: Referencing Size: %llu"
776 					" bytes\n", fd_dev->fd_dev_size);
777 			fd_dev->fbd_flags |= FBDF_HAS_SIZE;
778 			break;
779 		case Opt_fd_buffered_io:
780 			ret = match_int(args, &arg);
781 			if (ret)
782 				goto out;
783 			if (arg != 1) {
784 				pr_err("bogus fd_buffered_io=%d value\n", arg);
785 				ret = -EINVAL;
786 				goto out;
787 			}
788 
789 			pr_debug("FILEIO: Using buffered I/O"
790 				" operations for struct fd_dev\n");
791 
792 			fd_dev->fbd_flags |= FDBD_HAS_BUFFERED_IO_WCE;
793 			break;
794 		default:
795 			break;
796 		}
797 	}
798 
799 out:
800 	kfree(orig);
801 	return (!ret) ? count : ret;
802 }
803 
804 static ssize_t fd_show_configfs_dev_params(struct se_device *dev, char *b)
805 {
806 	struct fd_dev *fd_dev = FD_DEV(dev);
807 	ssize_t bl = 0;
808 
809 	bl = sprintf(b + bl, "TCM FILEIO ID: %u", fd_dev->fd_dev_id);
810 	bl += sprintf(b + bl, "        File: %s  Size: %llu  Mode: %s\n",
811 		fd_dev->fd_dev_name, fd_dev->fd_dev_size,
812 		(fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) ?
813 		"Buffered-WCE" : "O_DSYNC");
814 	return bl;
815 }
816 
817 static sector_t fd_get_blocks(struct se_device *dev)
818 {
819 	struct fd_dev *fd_dev = FD_DEV(dev);
820 	struct file *f = fd_dev->fd_file;
821 	struct inode *i = f->f_mapping->host;
822 	unsigned long long dev_size;
823 	/*
824 	 * When using a file that references an underlying struct block_device,
825 	 * ensure dev_size is always based on the current inode size in order
826 	 * to handle underlying block_device resize operations.
827 	 */
828 	if (S_ISBLK(i->i_mode))
829 		dev_size = i_size_read(i);
830 	else
831 		dev_size = fd_dev->fd_dev_size;
832 
833 	return div_u64(dev_size - dev->dev_attrib.block_size,
834 		       dev->dev_attrib.block_size);
835 }
836 
837 static int fd_init_prot(struct se_device *dev)
838 {
839 	struct fd_dev *fd_dev = FD_DEV(dev);
840 	struct file *prot_file, *file = fd_dev->fd_file;
841 	struct inode *inode;
842 	int ret, flags = O_RDWR | O_CREAT | O_LARGEFILE | O_DSYNC;
843 	char buf[FD_MAX_DEV_PROT_NAME];
844 
845 	if (!file) {
846 		pr_err("Unable to locate fd_dev->fd_file\n");
847 		return -ENODEV;
848 	}
849 
850 	inode = file->f_mapping->host;
851 	if (S_ISBLK(inode->i_mode)) {
852 		pr_err("FILEIO Protection emulation only supported on"
853 		       " !S_ISBLK\n");
854 		return -ENOSYS;
855 	}
856 
857 	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE)
858 		flags &= ~O_DSYNC;
859 
860 	snprintf(buf, FD_MAX_DEV_PROT_NAME, "%s.protection",
861 		 fd_dev->fd_dev_name);
862 
863 	prot_file = filp_open(buf, flags, 0600);
864 	if (IS_ERR(prot_file)) {
865 		pr_err("filp_open(%s) failed\n", buf);
866 		ret = PTR_ERR(prot_file);
867 		return ret;
868 	}
869 	fd_dev->fd_prot_file = prot_file;
870 
871 	return 0;
872 }
873 
874 static int fd_format_prot(struct se_device *dev)
875 {
876 	struct fd_dev *fd_dev = FD_DEV(dev);
877 	struct file *prot_fd = fd_dev->fd_prot_file;
878 	sector_t prot_length, prot;
879 	unsigned char *buf;
880 	loff_t pos = 0;
881 	int unit_size = FDBD_FORMAT_UNIT_SIZE * dev->dev_attrib.block_size;
882 	int rc, ret = 0, size, len;
883 
884 	if (!dev->dev_attrib.pi_prot_type) {
885 		pr_err("Unable to format_prot while pi_prot_type == 0\n");
886 		return -ENODEV;
887 	}
888 	if (!prot_fd) {
889 		pr_err("Unable to locate fd_dev->fd_prot_file\n");
890 		return -ENODEV;
891 	}
892 
893 	buf = vzalloc(unit_size);
894 	if (!buf) {
895 		pr_err("Unable to allocate FILEIO prot buf\n");
896 		return -ENOMEM;
897 	}
898 	prot_length = (dev->transport->get_blocks(dev) + 1) * dev->prot_length;
899 	size = prot_length;
900 
901 	pr_debug("Using FILEIO prot_length: %llu\n",
902 		 (unsigned long long)prot_length);
903 
904 	memset(buf, 0xff, unit_size);
905 	for (prot = 0; prot < prot_length; prot += unit_size) {
906 		len = min(unit_size, size);
907 		rc = kernel_write(prot_fd, buf, len, pos);
908 		if (rc != len) {
909 			pr_err("vfs_write to prot file failed: %d\n", rc);
910 			ret = -ENODEV;
911 			goto out;
912 		}
913 		pos += len;
914 		size -= len;
915 	}
916 
917 out:
918 	vfree(buf);
919 	return ret;
920 }
921 
922 static void fd_free_prot(struct se_device *dev)
923 {
924 	struct fd_dev *fd_dev = FD_DEV(dev);
925 
926 	if (!fd_dev->fd_prot_file)
927 		return;
928 
929 	filp_close(fd_dev->fd_prot_file, NULL);
930 	fd_dev->fd_prot_file = NULL;
931 }
932 
933 static struct sbc_ops fd_sbc_ops = {
934 	.execute_rw		= fd_execute_rw,
935 	.execute_sync_cache	= fd_execute_sync_cache,
936 	.execute_write_same	= fd_execute_write_same,
937 	.execute_write_same_unmap = fd_execute_write_same_unmap,
938 	.execute_unmap		= fd_execute_unmap,
939 };
940 
941 static sense_reason_t
942 fd_parse_cdb(struct se_cmd *cmd)
943 {
944 	return sbc_parse_cdb(cmd, &fd_sbc_ops);
945 }
946 
947 DEF_TB_DEFAULT_ATTRIBS(fileio);
948 
949 static struct configfs_attribute *fileio_backend_dev_attrs[] = {
950 	&fileio_dev_attrib_emulate_model_alias.attr,
951 	&fileio_dev_attrib_emulate_dpo.attr,
952 	&fileio_dev_attrib_emulate_fua_write.attr,
953 	&fileio_dev_attrib_emulate_fua_read.attr,
954 	&fileio_dev_attrib_emulate_write_cache.attr,
955 	&fileio_dev_attrib_emulate_ua_intlck_ctrl.attr,
956 	&fileio_dev_attrib_emulate_tas.attr,
957 	&fileio_dev_attrib_emulate_tpu.attr,
958 	&fileio_dev_attrib_emulate_tpws.attr,
959 	&fileio_dev_attrib_emulate_caw.attr,
960 	&fileio_dev_attrib_emulate_3pc.attr,
961 	&fileio_dev_attrib_pi_prot_type.attr,
962 	&fileio_dev_attrib_hw_pi_prot_type.attr,
963 	&fileio_dev_attrib_pi_prot_format.attr,
964 	&fileio_dev_attrib_enforce_pr_isids.attr,
965 	&fileio_dev_attrib_is_nonrot.attr,
966 	&fileio_dev_attrib_emulate_rest_reord.attr,
967 	&fileio_dev_attrib_force_pr_aptpl.attr,
968 	&fileio_dev_attrib_hw_block_size.attr,
969 	&fileio_dev_attrib_block_size.attr,
970 	&fileio_dev_attrib_hw_max_sectors.attr,
971 	&fileio_dev_attrib_optimal_sectors.attr,
972 	&fileio_dev_attrib_hw_queue_depth.attr,
973 	&fileio_dev_attrib_queue_depth.attr,
974 	&fileio_dev_attrib_max_unmap_lba_count.attr,
975 	&fileio_dev_attrib_max_unmap_block_desc_count.attr,
976 	&fileio_dev_attrib_unmap_granularity.attr,
977 	&fileio_dev_attrib_unmap_granularity_alignment.attr,
978 	&fileio_dev_attrib_max_write_same_len.attr,
979 	NULL,
980 };
981 
982 static struct se_subsystem_api fileio_template = {
983 	.name			= "fileio",
984 	.inquiry_prod		= "FILEIO",
985 	.inquiry_rev		= FD_VERSION,
986 	.owner			= THIS_MODULE,
987 	.transport_type		= TRANSPORT_PLUGIN_VHBA_PDEV,
988 	.attach_hba		= fd_attach_hba,
989 	.detach_hba		= fd_detach_hba,
990 	.alloc_device		= fd_alloc_device,
991 	.configure_device	= fd_configure_device,
992 	.free_device		= fd_free_device,
993 	.parse_cdb		= fd_parse_cdb,
994 	.set_configfs_dev_params = fd_set_configfs_dev_params,
995 	.show_configfs_dev_params = fd_show_configfs_dev_params,
996 	.get_device_type	= sbc_get_device_type,
997 	.get_blocks		= fd_get_blocks,
998 	.init_prot		= fd_init_prot,
999 	.format_prot		= fd_format_prot,
1000 	.free_prot		= fd_free_prot,
1001 };
1002 
1003 static int __init fileio_module_init(void)
1004 {
1005 	struct target_backend_cits *tbc = &fileio_template.tb_cits;
1006 
1007 	target_core_setup_sub_cits(&fileio_template);
1008 	tbc->tb_dev_attrib_cit.ct_attrs = fileio_backend_dev_attrs;
1009 
1010 	return transport_subsystem_register(&fileio_template);
1011 }
1012 
1013 static void __exit fileio_module_exit(void)
1014 {
1015 	transport_subsystem_release(&fileio_template);
1016 }
1017 
1018 MODULE_DESCRIPTION("TCM FILEIO subsystem plugin");
1019 MODULE_AUTHOR("nab@Linux-iSCSI.org");
1020 MODULE_LICENSE("GPL");
1021 
1022 module_init(fileio_module_init);
1023 module_exit(fileio_module_exit);
1024