1 /*******************************************************************************
2  * Filename:  target_core_iblock.c
3  *
4  * This file contains the Storage Engine  <-> Linux BlockIO transport
5  * specific functions.
6  *
7  * (c) Copyright 2003-2013 Datera, Inc.
8  *
9  * Nicholas A. Bellinger <nab@kernel.org>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24  *
25  ******************************************************************************/
26 
27 #include <linux/string.h>
28 #include <linux/parser.h>
29 #include <linux/timer.h>
30 #include <linux/fs.h>
31 #include <linux/blkdev.h>
32 #include <linux/slab.h>
33 #include <linux/spinlock.h>
34 #include <linux/bio.h>
35 #include <linux/genhd.h>
36 #include <linux/file.h>
37 #include <linux/module.h>
38 #include <scsi/scsi_proto.h>
39 #include <asm/unaligned.h>
40 
41 #include <target/target_core_base.h>
42 #include <target/target_core_backend.h>
43 
44 #include "target_core_iblock.h"
45 
46 #define IBLOCK_MAX_BIO_PER_TASK	 32	/* max # of bios to submit at a time */
47 #define IBLOCK_BIO_POOL_SIZE	128
48 
49 static inline struct iblock_dev *IBLOCK_DEV(struct se_device *dev)
50 {
51 	return container_of(dev, struct iblock_dev, dev);
52 }
53 
54 
55 static int iblock_attach_hba(struct se_hba *hba, u32 host_id)
56 {
57 	pr_debug("CORE_HBA[%d] - TCM iBlock HBA Driver %s on"
58 		" Generic Target Core Stack %s\n", hba->hba_id,
59 		IBLOCK_VERSION, TARGET_CORE_VERSION);
60 	return 0;
61 }
62 
63 static void iblock_detach_hba(struct se_hba *hba)
64 {
65 }
66 
67 static struct se_device *iblock_alloc_device(struct se_hba *hba, const char *name)
68 {
69 	struct iblock_dev *ib_dev = NULL;
70 
71 	ib_dev = kzalloc(sizeof(struct iblock_dev), GFP_KERNEL);
72 	if (!ib_dev) {
73 		pr_err("Unable to allocate struct iblock_dev\n");
74 		return NULL;
75 	}
76 
77 	pr_debug( "IBLOCK: Allocated ib_dev for %s\n", name);
78 
79 	return &ib_dev->dev;
80 }
81 
82 static int iblock_configure_device(struct se_device *dev)
83 {
84 	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
85 	struct request_queue *q;
86 	struct block_device *bd = NULL;
87 	struct blk_integrity *bi;
88 	fmode_t mode;
89 	unsigned int max_write_zeroes_sectors;
90 	int ret = -ENOMEM;
91 
92 	if (!(ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH)) {
93 		pr_err("Missing udev_path= parameters for IBLOCK\n");
94 		return -EINVAL;
95 	}
96 
97 	ret = bioset_init(&ib_dev->ibd_bio_set, IBLOCK_BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
98 	if (ret) {
99 		pr_err("IBLOCK: Unable to create bioset\n");
100 		goto out;
101 	}
102 
103 	pr_debug( "IBLOCK: Claiming struct block_device: %s\n",
104 			ib_dev->ibd_udev_path);
105 
106 	mode = FMODE_READ|FMODE_EXCL;
107 	if (!ib_dev->ibd_readonly)
108 		mode |= FMODE_WRITE;
109 	else
110 		dev->dev_flags |= DF_READ_ONLY;
111 
112 	bd = blkdev_get_by_path(ib_dev->ibd_udev_path, mode, ib_dev);
113 	if (IS_ERR(bd)) {
114 		ret = PTR_ERR(bd);
115 		goto out_free_bioset;
116 	}
117 	ib_dev->ibd_bd = bd;
118 
119 	q = bdev_get_queue(bd);
120 
121 	dev->dev_attrib.hw_block_size = bdev_logical_block_size(bd);
122 	dev->dev_attrib.hw_max_sectors = queue_max_hw_sectors(q);
123 	dev->dev_attrib.hw_queue_depth = q->nr_requests;
124 
125 	if (target_configure_unmap_from_queue(&dev->dev_attrib, q))
126 		pr_debug("IBLOCK: BLOCK Discard support available,"
127 			 " disabled by default\n");
128 
129 	/*
130 	 * Enable write same emulation for IBLOCK and use 0xFFFF as
131 	 * the smaller WRITE_SAME(10) only has a two-byte block count.
132 	 */
133 	max_write_zeroes_sectors = bdev_write_zeroes_sectors(bd);
134 	if (max_write_zeroes_sectors)
135 		dev->dev_attrib.max_write_same_len = max_write_zeroes_sectors;
136 	else
137 		dev->dev_attrib.max_write_same_len = 0xFFFF;
138 
139 	if (blk_queue_nonrot(q))
140 		dev->dev_attrib.is_nonrot = 1;
141 
142 	bi = bdev_get_integrity(bd);
143 	if (bi) {
144 		struct bio_set *bs = &ib_dev->ibd_bio_set;
145 
146 		if (!strcmp(bi->profile->name, "T10-DIF-TYPE3-IP") ||
147 		    !strcmp(bi->profile->name, "T10-DIF-TYPE1-IP")) {
148 			pr_err("IBLOCK export of blk_integrity: %s not"
149 			       " supported\n", bi->profile->name);
150 			ret = -ENOSYS;
151 			goto out_blkdev_put;
152 		}
153 
154 		if (!strcmp(bi->profile->name, "T10-DIF-TYPE3-CRC")) {
155 			dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE3_PROT;
156 		} else if (!strcmp(bi->profile->name, "T10-DIF-TYPE1-CRC")) {
157 			dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE1_PROT;
158 		}
159 
160 		if (dev->dev_attrib.pi_prot_type) {
161 			if (bioset_integrity_create(bs, IBLOCK_BIO_POOL_SIZE) < 0) {
162 				pr_err("Unable to allocate bioset for PI\n");
163 				ret = -ENOMEM;
164 				goto out_blkdev_put;
165 			}
166 			pr_debug("IBLOCK setup BIP bs->bio_integrity_pool: %p\n",
167 				 &bs->bio_integrity_pool);
168 		}
169 		dev->dev_attrib.hw_pi_prot_type = dev->dev_attrib.pi_prot_type;
170 	}
171 
172 	return 0;
173 
174 out_blkdev_put:
175 	blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL);
176 out_free_bioset:
177 	bioset_exit(&ib_dev->ibd_bio_set);
178 out:
179 	return ret;
180 }
181 
182 static void iblock_dev_call_rcu(struct rcu_head *p)
183 {
184 	struct se_device *dev = container_of(p, struct se_device, rcu_head);
185 	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
186 
187 	kfree(ib_dev);
188 }
189 
190 static void iblock_free_device(struct se_device *dev)
191 {
192 	call_rcu(&dev->rcu_head, iblock_dev_call_rcu);
193 }
194 
195 static void iblock_destroy_device(struct se_device *dev)
196 {
197 	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
198 
199 	if (ib_dev->ibd_bd != NULL)
200 		blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL);
201 	bioset_exit(&ib_dev->ibd_bio_set);
202 }
203 
204 static unsigned long long iblock_emulate_read_cap_with_block_size(
205 	struct se_device *dev,
206 	struct block_device *bd,
207 	struct request_queue *q)
208 {
209 	unsigned long long blocks_long = (div_u64(i_size_read(bd->bd_inode),
210 					bdev_logical_block_size(bd)) - 1);
211 	u32 block_size = bdev_logical_block_size(bd);
212 
213 	if (block_size == dev->dev_attrib.block_size)
214 		return blocks_long;
215 
216 	switch (block_size) {
217 	case 4096:
218 		switch (dev->dev_attrib.block_size) {
219 		case 2048:
220 			blocks_long <<= 1;
221 			break;
222 		case 1024:
223 			blocks_long <<= 2;
224 			break;
225 		case 512:
226 			blocks_long <<= 3;
227 		default:
228 			break;
229 		}
230 		break;
231 	case 2048:
232 		switch (dev->dev_attrib.block_size) {
233 		case 4096:
234 			blocks_long >>= 1;
235 			break;
236 		case 1024:
237 			blocks_long <<= 1;
238 			break;
239 		case 512:
240 			blocks_long <<= 2;
241 			break;
242 		default:
243 			break;
244 		}
245 		break;
246 	case 1024:
247 		switch (dev->dev_attrib.block_size) {
248 		case 4096:
249 			blocks_long >>= 2;
250 			break;
251 		case 2048:
252 			blocks_long >>= 1;
253 			break;
254 		case 512:
255 			blocks_long <<= 1;
256 			break;
257 		default:
258 			break;
259 		}
260 		break;
261 	case 512:
262 		switch (dev->dev_attrib.block_size) {
263 		case 4096:
264 			blocks_long >>= 3;
265 			break;
266 		case 2048:
267 			blocks_long >>= 2;
268 			break;
269 		case 1024:
270 			blocks_long >>= 1;
271 			break;
272 		default:
273 			break;
274 		}
275 		break;
276 	default:
277 		break;
278 	}
279 
280 	return blocks_long;
281 }
282 
283 static void iblock_complete_cmd(struct se_cmd *cmd)
284 {
285 	struct iblock_req *ibr = cmd->priv;
286 	u8 status;
287 
288 	if (!refcount_dec_and_test(&ibr->pending))
289 		return;
290 
291 	if (atomic_read(&ibr->ib_bio_err_cnt))
292 		status = SAM_STAT_CHECK_CONDITION;
293 	else
294 		status = SAM_STAT_GOOD;
295 
296 	target_complete_cmd(cmd, status);
297 	kfree(ibr);
298 }
299 
300 static void iblock_bio_done(struct bio *bio)
301 {
302 	struct se_cmd *cmd = bio->bi_private;
303 	struct iblock_req *ibr = cmd->priv;
304 
305 	if (bio->bi_status) {
306 		pr_err("bio error: %p,  err: %d\n", bio, bio->bi_status);
307 		/*
308 		 * Bump the ib_bio_err_cnt and release bio.
309 		 */
310 		atomic_inc(&ibr->ib_bio_err_cnt);
311 		smp_mb__after_atomic();
312 	}
313 
314 	bio_put(bio);
315 
316 	iblock_complete_cmd(cmd);
317 }
318 
319 static struct bio *
320 iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num, int op,
321 	       int op_flags)
322 {
323 	struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);
324 	struct bio *bio;
325 
326 	/*
327 	 * Only allocate as many vector entries as the bio code allows us to,
328 	 * we'll loop later on until we have handled the whole request.
329 	 */
330 	if (sg_num > BIO_MAX_PAGES)
331 		sg_num = BIO_MAX_PAGES;
332 
333 	bio = bio_alloc_bioset(GFP_NOIO, sg_num, &ib_dev->ibd_bio_set);
334 	if (!bio) {
335 		pr_err("Unable to allocate memory for bio\n");
336 		return NULL;
337 	}
338 
339 	bio_set_dev(bio, ib_dev->ibd_bd);
340 	bio->bi_private = cmd;
341 	bio->bi_end_io = &iblock_bio_done;
342 	bio->bi_iter.bi_sector = lba;
343 	bio_set_op_attrs(bio, op, op_flags);
344 
345 	return bio;
346 }
347 
348 static void iblock_submit_bios(struct bio_list *list)
349 {
350 	struct blk_plug plug;
351 	struct bio *bio;
352 
353 	blk_start_plug(&plug);
354 	while ((bio = bio_list_pop(list)))
355 		submit_bio(bio);
356 	blk_finish_plug(&plug);
357 }
358 
359 static void iblock_end_io_flush(struct bio *bio)
360 {
361 	struct se_cmd *cmd = bio->bi_private;
362 
363 	if (bio->bi_status)
364 		pr_err("IBLOCK: cache flush failed: %d\n", bio->bi_status);
365 
366 	if (cmd) {
367 		if (bio->bi_status)
368 			target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
369 		else
370 			target_complete_cmd(cmd, SAM_STAT_GOOD);
371 	}
372 
373 	bio_put(bio);
374 }
375 
376 /*
377  * Implement SYCHRONIZE CACHE.  Note that we can't handle lba ranges and must
378  * always flush the whole cache.
379  */
380 static sense_reason_t
381 iblock_execute_sync_cache(struct se_cmd *cmd)
382 {
383 	struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);
384 	int immed = (cmd->t_task_cdb[1] & 0x2);
385 	struct bio *bio;
386 
387 	/*
388 	 * If the Immediate bit is set, queue up the GOOD response
389 	 * for this SYNCHRONIZE_CACHE op.
390 	 */
391 	if (immed)
392 		target_complete_cmd(cmd, SAM_STAT_GOOD);
393 
394 	bio = bio_alloc(GFP_KERNEL, 0);
395 	bio->bi_end_io = iblock_end_io_flush;
396 	bio_set_dev(bio, ib_dev->ibd_bd);
397 	bio->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH;
398 	if (!immed)
399 		bio->bi_private = cmd;
400 	submit_bio(bio);
401 	return 0;
402 }
403 
404 static sense_reason_t
405 iblock_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb)
406 {
407 	struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd;
408 	struct se_device *dev = cmd->se_dev;
409 	int ret;
410 
411 	ret = blkdev_issue_discard(bdev,
412 				   target_to_linux_sector(dev, lba),
413 				   target_to_linux_sector(dev,  nolb),
414 				   GFP_KERNEL, 0);
415 	if (ret < 0) {
416 		pr_err("blkdev_issue_discard() failed: %d\n", ret);
417 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
418 	}
419 
420 	return 0;
421 }
422 
423 static sense_reason_t
424 iblock_execute_zero_out(struct block_device *bdev, struct se_cmd *cmd)
425 {
426 	struct se_device *dev = cmd->se_dev;
427 	struct scatterlist *sg = &cmd->t_data_sg[0];
428 	unsigned char *buf, *not_zero;
429 	int ret;
430 
431 	buf = kmap(sg_page(sg)) + sg->offset;
432 	if (!buf)
433 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
434 	/*
435 	 * Fall back to block_execute_write_same() slow-path if
436 	 * incoming WRITE_SAME payload does not contain zeros.
437 	 */
438 	not_zero = memchr_inv(buf, 0x00, cmd->data_length);
439 	kunmap(sg_page(sg));
440 
441 	if (not_zero)
442 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
443 
444 	ret = blkdev_issue_zeroout(bdev,
445 				target_to_linux_sector(dev, cmd->t_task_lba),
446 				target_to_linux_sector(dev,
447 					sbc_get_write_same_sectors(cmd)),
448 				GFP_KERNEL, false);
449 	if (ret)
450 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
451 
452 	target_complete_cmd(cmd, GOOD);
453 	return 0;
454 }
455 
456 static sense_reason_t
457 iblock_execute_write_same(struct se_cmd *cmd)
458 {
459 	struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd;
460 	struct iblock_req *ibr;
461 	struct scatterlist *sg;
462 	struct bio *bio;
463 	struct bio_list list;
464 	struct se_device *dev = cmd->se_dev;
465 	sector_t block_lba = target_to_linux_sector(dev, cmd->t_task_lba);
466 	sector_t sectors = target_to_linux_sector(dev,
467 					sbc_get_write_same_sectors(cmd));
468 
469 	if (cmd->prot_op) {
470 		pr_err("WRITE_SAME: Protection information with IBLOCK"
471 		       " backends not supported\n");
472 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
473 	}
474 	sg = &cmd->t_data_sg[0];
475 
476 	if (cmd->t_data_nents > 1 ||
477 	    sg->length != cmd->se_dev->dev_attrib.block_size) {
478 		pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"
479 			" block_size: %u\n", cmd->t_data_nents, sg->length,
480 			cmd->se_dev->dev_attrib.block_size);
481 		return TCM_INVALID_CDB_FIELD;
482 	}
483 
484 	if (bdev_write_zeroes_sectors(bdev)) {
485 		if (!iblock_execute_zero_out(bdev, cmd))
486 			return 0;
487 	}
488 
489 	ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL);
490 	if (!ibr)
491 		goto fail;
492 	cmd->priv = ibr;
493 
494 	bio = iblock_get_bio(cmd, block_lba, 1, REQ_OP_WRITE, 0);
495 	if (!bio)
496 		goto fail_free_ibr;
497 
498 	bio_list_init(&list);
499 	bio_list_add(&list, bio);
500 
501 	refcount_set(&ibr->pending, 1);
502 
503 	while (sectors) {
504 		while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)
505 				!= sg->length) {
506 
507 			bio = iblock_get_bio(cmd, block_lba, 1, REQ_OP_WRITE,
508 					     0);
509 			if (!bio)
510 				goto fail_put_bios;
511 
512 			refcount_inc(&ibr->pending);
513 			bio_list_add(&list, bio);
514 		}
515 
516 		/* Always in 512 byte units for Linux/Block */
517 		block_lba += sg->length >> IBLOCK_LBA_SHIFT;
518 		sectors -= 1;
519 	}
520 
521 	iblock_submit_bios(&list);
522 	return 0;
523 
524 fail_put_bios:
525 	while ((bio = bio_list_pop(&list)))
526 		bio_put(bio);
527 fail_free_ibr:
528 	kfree(ibr);
529 fail:
530 	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
531 }
532 
533 enum {
534 	Opt_udev_path, Opt_readonly, Opt_force, Opt_err
535 };
536 
537 static match_table_t tokens = {
538 	{Opt_udev_path, "udev_path=%s"},
539 	{Opt_readonly, "readonly=%d"},
540 	{Opt_force, "force=%d"},
541 	{Opt_err, NULL}
542 };
543 
544 static ssize_t iblock_set_configfs_dev_params(struct se_device *dev,
545 		const char *page, ssize_t count)
546 {
547 	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
548 	char *orig, *ptr, *arg_p, *opts;
549 	substring_t args[MAX_OPT_ARGS];
550 	int ret = 0, token;
551 	unsigned long tmp_readonly;
552 
553 	opts = kstrdup(page, GFP_KERNEL);
554 	if (!opts)
555 		return -ENOMEM;
556 
557 	orig = opts;
558 
559 	while ((ptr = strsep(&opts, ",\n")) != NULL) {
560 		if (!*ptr)
561 			continue;
562 
563 		token = match_token(ptr, tokens, args);
564 		switch (token) {
565 		case Opt_udev_path:
566 			if (ib_dev->ibd_bd) {
567 				pr_err("Unable to set udev_path= while"
568 					" ib_dev->ibd_bd exists\n");
569 				ret = -EEXIST;
570 				goto out;
571 			}
572 			if (match_strlcpy(ib_dev->ibd_udev_path, &args[0],
573 				SE_UDEV_PATH_LEN) == 0) {
574 				ret = -EINVAL;
575 				break;
576 			}
577 			pr_debug("IBLOCK: Referencing UDEV path: %s\n",
578 					ib_dev->ibd_udev_path);
579 			ib_dev->ibd_flags |= IBDF_HAS_UDEV_PATH;
580 			break;
581 		case Opt_readonly:
582 			arg_p = match_strdup(&args[0]);
583 			if (!arg_p) {
584 				ret = -ENOMEM;
585 				break;
586 			}
587 			ret = kstrtoul(arg_p, 0, &tmp_readonly);
588 			kfree(arg_p);
589 			if (ret < 0) {
590 				pr_err("kstrtoul() failed for"
591 						" readonly=\n");
592 				goto out;
593 			}
594 			ib_dev->ibd_readonly = tmp_readonly;
595 			pr_debug("IBLOCK: readonly: %d\n", ib_dev->ibd_readonly);
596 			break;
597 		case Opt_force:
598 			break;
599 		default:
600 			break;
601 		}
602 	}
603 
604 out:
605 	kfree(orig);
606 	return (!ret) ? count : ret;
607 }
608 
609 static ssize_t iblock_show_configfs_dev_params(struct se_device *dev, char *b)
610 {
611 	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
612 	struct block_device *bd = ib_dev->ibd_bd;
613 	char buf[BDEVNAME_SIZE];
614 	ssize_t bl = 0;
615 
616 	if (bd)
617 		bl += sprintf(b + bl, "iBlock device: %s",
618 				bdevname(bd, buf));
619 	if (ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH)
620 		bl += sprintf(b + bl, "  UDEV PATH: %s",
621 				ib_dev->ibd_udev_path);
622 	bl += sprintf(b + bl, "  readonly: %d\n", ib_dev->ibd_readonly);
623 
624 	bl += sprintf(b + bl, "        ");
625 	if (bd) {
626 		bl += sprintf(b + bl, "Major: %d Minor: %d  %s\n",
627 			MAJOR(bd->bd_dev), MINOR(bd->bd_dev), (!bd->bd_contains) ?
628 			"" : (bd->bd_holder == ib_dev) ?
629 			"CLAIMED: IBLOCK" : "CLAIMED: OS");
630 	} else {
631 		bl += sprintf(b + bl, "Major: 0 Minor: 0\n");
632 	}
633 
634 	return bl;
635 }
636 
637 static int
638 iblock_alloc_bip(struct se_cmd *cmd, struct bio *bio)
639 {
640 	struct se_device *dev = cmd->se_dev;
641 	struct blk_integrity *bi;
642 	struct bio_integrity_payload *bip;
643 	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
644 	struct scatterlist *sg;
645 	int i, rc;
646 
647 	bi = bdev_get_integrity(ib_dev->ibd_bd);
648 	if (!bi) {
649 		pr_err("Unable to locate bio_integrity\n");
650 		return -ENODEV;
651 	}
652 
653 	bip = bio_integrity_alloc(bio, GFP_NOIO, cmd->t_prot_nents);
654 	if (IS_ERR(bip)) {
655 		pr_err("Unable to allocate bio_integrity_payload\n");
656 		return PTR_ERR(bip);
657 	}
658 
659 	bip->bip_iter.bi_size = (cmd->data_length / dev->dev_attrib.block_size) *
660 			 dev->prot_length;
661 	bip->bip_iter.bi_sector = bio->bi_iter.bi_sector;
662 
663 	pr_debug("IBLOCK BIP Size: %u Sector: %llu\n", bip->bip_iter.bi_size,
664 		 (unsigned long long)bip->bip_iter.bi_sector);
665 
666 	for_each_sg(cmd->t_prot_sg, sg, cmd->t_prot_nents, i) {
667 
668 		rc = bio_integrity_add_page(bio, sg_page(sg), sg->length,
669 					    sg->offset);
670 		if (rc != sg->length) {
671 			pr_err("bio_integrity_add_page() failed; %d\n", rc);
672 			return -ENOMEM;
673 		}
674 
675 		pr_debug("Added bio integrity page: %p length: %d offset; %d\n",
676 			 sg_page(sg), sg->length, sg->offset);
677 	}
678 
679 	return 0;
680 }
681 
682 static sense_reason_t
683 iblock_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
684 		  enum dma_data_direction data_direction)
685 {
686 	struct se_device *dev = cmd->se_dev;
687 	sector_t block_lba = target_to_linux_sector(dev, cmd->t_task_lba);
688 	struct iblock_req *ibr;
689 	struct bio *bio, *bio_start;
690 	struct bio_list list;
691 	struct scatterlist *sg;
692 	u32 sg_num = sgl_nents;
693 	unsigned bio_cnt;
694 	int i, op, op_flags = 0;
695 
696 	if (data_direction == DMA_TO_DEVICE) {
697 		struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
698 		struct request_queue *q = bdev_get_queue(ib_dev->ibd_bd);
699 		/*
700 		 * Force writethrough using REQ_FUA if a volatile write cache
701 		 * is not enabled, or if initiator set the Force Unit Access bit.
702 		 */
703 		op = REQ_OP_WRITE;
704 		if (test_bit(QUEUE_FLAG_FUA, &q->queue_flags)) {
705 			if (cmd->se_cmd_flags & SCF_FUA)
706 				op_flags = REQ_FUA;
707 			else if (!test_bit(QUEUE_FLAG_WC, &q->queue_flags))
708 				op_flags = REQ_FUA;
709 		}
710 	} else {
711 		op = REQ_OP_READ;
712 	}
713 
714 	ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL);
715 	if (!ibr)
716 		goto fail;
717 	cmd->priv = ibr;
718 
719 	if (!sgl_nents) {
720 		refcount_set(&ibr->pending, 1);
721 		iblock_complete_cmd(cmd);
722 		return 0;
723 	}
724 
725 	bio = iblock_get_bio(cmd, block_lba, sgl_nents, op, op_flags);
726 	if (!bio)
727 		goto fail_free_ibr;
728 
729 	bio_start = bio;
730 	bio_list_init(&list);
731 	bio_list_add(&list, bio);
732 
733 	refcount_set(&ibr->pending, 2);
734 	bio_cnt = 1;
735 
736 	for_each_sg(sgl, sg, sgl_nents, i) {
737 		/*
738 		 * XXX: if the length the device accepts is shorter than the
739 		 *	length of the S/G list entry this will cause and
740 		 *	endless loop.  Better hope no driver uses huge pages.
741 		 */
742 		while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)
743 				!= sg->length) {
744 			if (bio_cnt >= IBLOCK_MAX_BIO_PER_TASK) {
745 				iblock_submit_bios(&list);
746 				bio_cnt = 0;
747 			}
748 
749 			bio = iblock_get_bio(cmd, block_lba, sg_num, op,
750 					     op_flags);
751 			if (!bio)
752 				goto fail_put_bios;
753 
754 			refcount_inc(&ibr->pending);
755 			bio_list_add(&list, bio);
756 			bio_cnt++;
757 		}
758 
759 		/* Always in 512 byte units for Linux/Block */
760 		block_lba += sg->length >> IBLOCK_LBA_SHIFT;
761 		sg_num--;
762 	}
763 
764 	if (cmd->prot_type && dev->dev_attrib.pi_prot_type) {
765 		int rc = iblock_alloc_bip(cmd, bio_start);
766 		if (rc)
767 			goto fail_put_bios;
768 	}
769 
770 	iblock_submit_bios(&list);
771 	iblock_complete_cmd(cmd);
772 	return 0;
773 
774 fail_put_bios:
775 	while ((bio = bio_list_pop(&list)))
776 		bio_put(bio);
777 fail_free_ibr:
778 	kfree(ibr);
779 fail:
780 	return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
781 }
782 
783 static sector_t iblock_get_blocks(struct se_device *dev)
784 {
785 	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
786 	struct block_device *bd = ib_dev->ibd_bd;
787 	struct request_queue *q = bdev_get_queue(bd);
788 
789 	return iblock_emulate_read_cap_with_block_size(dev, bd, q);
790 }
791 
792 static sector_t iblock_get_alignment_offset_lbas(struct se_device *dev)
793 {
794 	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
795 	struct block_device *bd = ib_dev->ibd_bd;
796 	int ret;
797 
798 	ret = bdev_alignment_offset(bd);
799 	if (ret == -1)
800 		return 0;
801 
802 	/* convert offset-bytes to offset-lbas */
803 	return ret / bdev_logical_block_size(bd);
804 }
805 
806 static unsigned int iblock_get_lbppbe(struct se_device *dev)
807 {
808 	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
809 	struct block_device *bd = ib_dev->ibd_bd;
810 	int logs_per_phys = bdev_physical_block_size(bd) / bdev_logical_block_size(bd);
811 
812 	return ilog2(logs_per_phys);
813 }
814 
815 static unsigned int iblock_get_io_min(struct se_device *dev)
816 {
817 	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
818 	struct block_device *bd = ib_dev->ibd_bd;
819 
820 	return bdev_io_min(bd);
821 }
822 
823 static unsigned int iblock_get_io_opt(struct se_device *dev)
824 {
825 	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
826 	struct block_device *bd = ib_dev->ibd_bd;
827 
828 	return bdev_io_opt(bd);
829 }
830 
831 static struct sbc_ops iblock_sbc_ops = {
832 	.execute_rw		= iblock_execute_rw,
833 	.execute_sync_cache	= iblock_execute_sync_cache,
834 	.execute_write_same	= iblock_execute_write_same,
835 	.execute_unmap		= iblock_execute_unmap,
836 };
837 
838 static sense_reason_t
839 iblock_parse_cdb(struct se_cmd *cmd)
840 {
841 	return sbc_parse_cdb(cmd, &iblock_sbc_ops);
842 }
843 
844 static bool iblock_get_write_cache(struct se_device *dev)
845 {
846 	struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
847 	struct block_device *bd = ib_dev->ibd_bd;
848 	struct request_queue *q = bdev_get_queue(bd);
849 
850 	return test_bit(QUEUE_FLAG_WC, &q->queue_flags);
851 }
852 
853 static const struct target_backend_ops iblock_ops = {
854 	.name			= "iblock",
855 	.inquiry_prod		= "IBLOCK",
856 	.inquiry_rev		= IBLOCK_VERSION,
857 	.owner			= THIS_MODULE,
858 	.attach_hba		= iblock_attach_hba,
859 	.detach_hba		= iblock_detach_hba,
860 	.alloc_device		= iblock_alloc_device,
861 	.configure_device	= iblock_configure_device,
862 	.destroy_device		= iblock_destroy_device,
863 	.free_device		= iblock_free_device,
864 	.parse_cdb		= iblock_parse_cdb,
865 	.set_configfs_dev_params = iblock_set_configfs_dev_params,
866 	.show_configfs_dev_params = iblock_show_configfs_dev_params,
867 	.get_device_type	= sbc_get_device_type,
868 	.get_blocks		= iblock_get_blocks,
869 	.get_alignment_offset_lbas = iblock_get_alignment_offset_lbas,
870 	.get_lbppbe		= iblock_get_lbppbe,
871 	.get_io_min		= iblock_get_io_min,
872 	.get_io_opt		= iblock_get_io_opt,
873 	.get_write_cache	= iblock_get_write_cache,
874 	.tb_dev_attrib_attrs	= sbc_attrib_attrs,
875 };
876 
877 static int __init iblock_module_init(void)
878 {
879 	return transport_backend_register(&iblock_ops);
880 }
881 
882 static void __exit iblock_module_exit(void)
883 {
884 	target_backend_unregister(&iblock_ops);
885 }
886 
887 MODULE_DESCRIPTION("TCM IBLOCK subsystem plugin");
888 MODULE_AUTHOR("nab@Linux-iSCSI.org");
889 MODULE_LICENSE("GPL");
890 
891 module_init(iblock_module_init);
892 module_exit(iblock_module_exit);
893