GNU Linux-libre 4.19.263-gnu1
[releases.git] / drivers / target / target_core_iblock.c
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, BLKDEV_ZERO_NOUNMAP);
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 >> SECTOR_SHIFT;
518                 sectors -= sg->length >> SECTOR_SHIFT;
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 >> SECTOR_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);