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-2012 RisingTide Systems LLC.
   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.h>
  39 #include <scsi/scsi_host.h>
  40 #include <asm/unaligned.h>
  41
  42 #include <target/target_core_base.h>
  43 #include <target/target_core_backend.h>
  44
  45 #include "target_core_iblock.h"
  46
  47 #define IBLOCK_MAX_BIO_PER_TASK  32     /* max # of bios to submit at a time */
  48 #define IBLOCK_BIO_POOL_SIZE    128
  49
  50 static inline struct iblock_dev *IBLOCK_DEV(struct se_device *dev)
  51 {
  52         return container_of(dev, struct iblock_dev, dev);
  53 }
  54
  55
  56 static struct se_subsystem_api iblock_template;
  57
  58 /*      iblock_attach_hba(): (Part of se_subsystem_api_t template)
  59  *
  60  *
  61  */
  62 static int iblock_attach_hba(struct se_hba *hba, u32 host_id)
  63 {
  64         pr_debug("CORE_HBA[%d] - TCM iBlock HBA Driver %s on"
  65                 " Generic Target Core Stack %s\n", hba->hba_id,
  66                 IBLOCK_VERSION, TARGET_CORE_MOD_VERSION);
  67         return 0;
  68 }
  69
  70 static void iblock_detach_hba(struct se_hba *hba)
  71 {
  72 }
  73
  74 static struct se_device *iblock_alloc_device(struct se_hba *hba, const char *name)
  75 {
  76         struct iblock_dev *ib_dev = NULL;
  77
  78         ib_dev = kzalloc(sizeof(struct iblock_dev), GFP_KERNEL);
  79         if (!ib_dev) {
  80                 pr_err("Unable to allocate struct iblock_dev\n");
  81                 return NULL;
  82         }
  83
  84         pr_debug( "IBLOCK: Allocated ib_dev for %s\n", name);
  85
  86         return &ib_dev->dev;
  87 }
  88
  89 static int iblock_configure_device(struct se_device *dev)
  90 {
  91         struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
  92         struct request_queue *q;
  93         struct block_device *bd = NULL;
  94         fmode_t mode;
  95         int ret = -ENOMEM;
  96
  97         if (!(ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH)) {
  98                 pr_err("Missing udev_path= parameters for IBLOCK\n");
  99                 return -EINVAL;
 100         }
 101
 102         ib_dev->ibd_bio_set = bioset_create(IBLOCK_BIO_POOL_SIZE, 0);
 103         if (!ib_dev->ibd_bio_set) {
 104                 pr_err("IBLOCK: Unable to create bioset\n");
 105                 goto out;
 106         }
 107
 108         pr_debug( "IBLOCK: Claiming struct block_device: %s\n",
 109                         ib_dev->ibd_udev_path);
 110
 111         mode = FMODE_READ|FMODE_EXCL;
 112         if (!ib_dev->ibd_readonly)
 113                 mode |= FMODE_WRITE;
 114
 115         bd = blkdev_get_by_path(ib_dev->ibd_udev_path, mode, ib_dev);
 116         if (IS_ERR(bd)) {
 117                 ret = PTR_ERR(bd);
 118                 goto out_free_bioset;
 119         }
 120         ib_dev->ibd_bd = bd;
 121
 122         q = bdev_get_queue(bd);
 123
 124         dev->dev_attrib.hw_block_size = bdev_logical_block_size(bd);
 125         dev->dev_attrib.hw_max_sectors = UINT_MAX;
 126         dev->dev_attrib.hw_queue_depth = q->nr_requests;
 127
 128         /*
 129          * Check if the underlying struct block_device request_queue supports
 130          * the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM
 131          * in ATA and we need to set TPE=1
 132          */
 133         if (blk_queue_discard(q)) {
 134                 dev->dev_attrib.max_unmap_lba_count =
 135                                 q->limits.max_discard_sectors;
 136
 137                 /*
 138                  * Currently hardcoded to 1 in Linux/SCSI code..
 139                  */
 140                 dev->dev_attrib.max_unmap_block_desc_count = 1;
 141                 dev->dev_attrib.unmap_granularity =
 142                                 q->limits.discard_granularity >> 9;
 143                 dev->dev_attrib.unmap_granularity_alignment =
 144                                 q->limits.discard_alignment;
 145
 146                 pr_debug("IBLOCK: BLOCK Discard support available,"
 147                                 " disabled by default\n");
 148         }
 149         /*
 150          * Enable write same emulation for IBLOCK and use 0xFFFF as
 151          * the smaller WRITE_SAME(10) only has a two-byte block count.
 152          */
 153         dev->dev_attrib.max_write_same_len = 0xFFFF;
 154
 155         if (blk_queue_nonrot(q))
 156                 dev->dev_attrib.is_nonrot = 1;
 157         return 0;
 158
 159 out_free_bioset:
 160         bioset_free(ib_dev->ibd_bio_set);
 161         ib_dev->ibd_bio_set = NULL;
 162 out:
 163         return ret;
 164 }
 165
 166 static void iblock_free_device(struct se_device *dev)
 167 {
 168         struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
 169
 170         if (ib_dev->ibd_bd != NULL)
 171                 blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL);
 172         if (ib_dev->ibd_bio_set != NULL)
 173                 bioset_free(ib_dev->ibd_bio_set);
 174         kfree(ib_dev);
 175 }
 176
 177 static unsigned long long iblock_emulate_read_cap_with_block_size(
 178         struct se_device *dev,
 179         struct block_device *bd,
 180         struct request_queue *q)
 181 {
 182         unsigned long long blocks_long = (div_u64(i_size_read(bd->bd_inode),
 183                                         bdev_logical_block_size(bd)) - 1);
 184         u32 block_size = bdev_logical_block_size(bd);
 185
 186         if (block_size == dev->dev_attrib.block_size)
 187                 return blocks_long;
 188
 189         switch (block_size) {
 190         case 4096:
 191                 switch (dev->dev_attrib.block_size) {
 192                 case 2048:
 193                         blocks_long <<= 1;
 194                         break;
 195                 case 1024:
 196                         blocks_long <<= 2;
 197                         break;
 198                 case 512:
 199                         blocks_long <<= 3;
 200                 default:
 201                         break;
 202                 }
 203                 break;
 204         case 2048:
 205                 switch (dev->dev_attrib.block_size) {
 206                 case 4096:
 207                         blocks_long >>= 1;
 208                         break;
 209                 case 1024:
 210                         blocks_long <<= 1;
 211                         break;
 212                 case 512:
 213                         blocks_long <<= 2;
 214                         break;
 215                 default:
 216                         break;
 217                 }
 218                 break;
 219         case 1024:
 220                 switch (dev->dev_attrib.block_size) {
 221                 case 4096:
 222                         blocks_long >>= 2;
 223                         break;
 224                 case 2048:
 225                         blocks_long >>= 1;
 226                         break;
 227                 case 512:
 228                         blocks_long <<= 1;
 229                         break;
 230                 default:
 231                         break;
 232                 }
 233                 break;
 234         case 512:
 235                 switch (dev->dev_attrib.block_size) {
 236                 case 4096:
 237                         blocks_long >>= 3;
 238                         break;
 239                 case 2048:
 240                         blocks_long >>= 2;
 241                         break;
 242                 case 1024:
 243                         blocks_long >>= 1;
 244                         break;
 245                 default:
 246                         break;
 247                 }
 248                 break;
 249         default:
 250                 break;
 251         }
 252
 253         return blocks_long;
 254 }
 255
 256 static void iblock_complete_cmd(struct se_cmd *cmd)
 257 {
 258         struct iblock_req *ibr = cmd->priv;
 259         u8 status;
 260
 261         if (!atomic_dec_and_test(&ibr->pending))
 262                 return;
 263
 264         if (atomic_read(&ibr->ib_bio_err_cnt))
 265                 status = SAM_STAT_CHECK_CONDITION;
 266         else
 267                 status = SAM_STAT_GOOD;
 268
 269         target_complete_cmd(cmd, status);
 270         kfree(ibr);
 271 }
 272
 273 static void iblock_bio_done(struct bio *bio, int err)
 274 {
 275         struct se_cmd *cmd = bio->bi_private;
 276         struct iblock_req *ibr = cmd->priv;
 277
 278         /*
 279          * Set -EIO if !BIO_UPTODATE and the passed is still err=0
 280          */
 281         if (!test_bit(BIO_UPTODATE, &bio->bi_flags) && !err)
 282                 err = -EIO;
 283
 284         if (err != 0) {
 285                 pr_err("test_bit(BIO_UPTODATE) failed for bio: %p,"
 286                         " err: %d\n", bio, err);
 287                 /*
 288                  * Bump the ib_bio_err_cnt and release bio.
 289                  */
 290                 atomic_inc(&ibr->ib_bio_err_cnt);
 291                 smp_mb__after_atomic_inc();
 292         }
 293
 294         bio_put(bio);
 295
 296         iblock_complete_cmd(cmd);
 297 }
 298
 299 static struct bio *
 300 iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num)
 301 {
 302         struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);
 303         struct bio *bio;
 304
 305         /*
 306          * Only allocate as many vector entries as the bio code allows us to,
 307          * we'll loop later on until we have handled the whole request.
 308          */
 309         if (sg_num > BIO_MAX_PAGES)
 310                 sg_num = BIO_MAX_PAGES;
 311
 312         bio = bio_alloc_bioset(GFP_NOIO, sg_num, ib_dev->ibd_bio_set);
 313         if (!bio) {
 314                 pr_err("Unable to allocate memory for bio\n");
 315                 return NULL;
 316         }
 317
 318         bio->bi_bdev = ib_dev->ibd_bd;
 319         bio->bi_private = cmd;
 320         bio->bi_end_io = &iblock_bio_done;
 321         bio->bi_sector = lba;
 322
 323         return bio;
 324 }
 325
 326 static void iblock_submit_bios(struct bio_list *list, int rw)
 327 {
 328         struct blk_plug plug;
 329         struct bio *bio;
 330
 331         blk_start_plug(&plug);
 332         while ((bio = bio_list_pop(list)))
 333                 submit_bio(rw, bio);
 334         blk_finish_plug(&plug);
 335 }
 336
 337 static void iblock_end_io_flush(struct bio *bio, int err)
 338 {
 339         struct se_cmd *cmd = bio->bi_private;
 340
 341         if (err)
 342                 pr_err("IBLOCK: cache flush failed: %d\n", err);
 343
 344         if (cmd) {
 345                 if (err)
 346                         target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
 347                 else
 348                         target_complete_cmd(cmd, SAM_STAT_GOOD);
 349         }
 350
 351         bio_put(bio);
 352 }
 353
 354 /*
 355  * Implement SYCHRONIZE CACHE.  Note that we can't handle lba ranges and must
 356  * always flush the whole cache.
 357  */
 358 static sense_reason_t
 359 iblock_execute_sync_cache(struct se_cmd *cmd)
 360 {
 361         struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);
 362         int immed = (cmd->t_task_cdb[1] & 0x2);
 363         struct bio *bio;
 364
 365         /*
 366          * If the Immediate bit is set, queue up the GOOD response
 367          * for this SYNCHRONIZE_CACHE op.
 368          */
 369         if (immed)
 370                 target_complete_cmd(cmd, SAM_STAT_GOOD);
 371
 372         bio = bio_alloc(GFP_KERNEL, 0);
 373         bio->bi_end_io = iblock_end_io_flush;
 374         bio->bi_bdev = ib_dev->ibd_bd;
 375         if (!immed)
 376                 bio->bi_private = cmd;
 377         submit_bio(WRITE_FLUSH, bio);
 378         return 0;
 379 }
 380
 381 static sense_reason_t
 382 iblock_execute_unmap(struct se_cmd *cmd)
 383 {
 384         struct se_device *dev = cmd->se_dev;
 385         struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
 386         unsigned char *buf, *ptr = NULL;
 387         sector_t lba;
 388         int size;
 389         u32 range;
 390         sense_reason_t ret = 0;
 391         int dl, bd_dl, err;
 392
 393         if (cmd->data_length < 8) {
 394                 pr_warn("UNMAP parameter list length %u too small\n",
 395                         cmd->data_length);
 396                 return TCM_INVALID_PARAMETER_LIST;
 397         }
 398
 399         buf = transport_kmap_data_sg(cmd);
 400         if (!buf)
 401                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 402
 403         dl = get_unaligned_be16(&buf[0]);
 404         bd_dl = get_unaligned_be16(&buf[2]);
 405
 406         size = cmd->data_length - 8;
 407         if (bd_dl > size)
 408                 pr_warn("UNMAP parameter list length %u too small, ignoring bd_dl %u\n",
 409                         cmd->data_length, bd_dl);
 410         else
 411                 size = bd_dl;
 412
 413         if (size / 16 > dev->dev_attrib.max_unmap_block_desc_count) {
 414                 ret = TCM_INVALID_PARAMETER_LIST;
 415                 goto err;
 416         }
 417
 418         /* First UNMAP block descriptor starts at 8 byte offset */
 419         ptr = &buf[8];
 420         pr_debug("UNMAP: Sub: %s Using dl: %u bd_dl: %u size: %u"
 421                 " ptr: %p\n", dev->transport->name, dl, bd_dl, size, ptr);
 422
 423         while (size >= 16) {
 424                 lba = get_unaligned_be64(&ptr[0]);
 425                 range = get_unaligned_be32(&ptr[8]);
 426                 pr_debug("UNMAP: Using lba: %llu and range: %u\n",
 427                                  (unsigned long long)lba, range);
 428
 429                 if (range > dev->dev_attrib.max_unmap_lba_count) {
 430                         ret = TCM_INVALID_PARAMETER_LIST;
 431                         goto err;
 432                 }
 433
 434                 if (lba + range > dev->transport->get_blocks(dev) + 1) {
 435                         ret = TCM_ADDRESS_OUT_OF_RANGE;
 436                         goto err;
 437                 }
 438
 439                 err = blkdev_issue_discard(ib_dev->ibd_bd, lba, range,
 440                                            GFP_KERNEL, 0);
 441                 if (err < 0) {
 442                         pr_err("blkdev_issue_discard() failed: %d\n",
 443                                         err);
 444                         ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 445                         goto err;
 446                 }
 447
 448                 ptr += 16;
 449                 size -= 16;
 450         }
 451
 452 err:
 453         transport_kunmap_data_sg(cmd);
 454         if (!ret)
 455                 target_complete_cmd(cmd, GOOD);
 456         return ret;
 457 }
 458
 459 static sense_reason_t
 460 iblock_execute_write_same_unmap(struct se_cmd *cmd)
 461 {
 462         struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev);
 463         int rc;
 464
 465         rc = blkdev_issue_discard(ib_dev->ibd_bd, cmd->t_task_lba,
 466                         spc_get_write_same_sectors(cmd), GFP_KERNEL, 0);
 467         if (rc < 0) {
 468                 pr_warn("blkdev_issue_discard() failed: %d\n", rc);
 469                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 470         }
 471
 472         target_complete_cmd(cmd, GOOD);
 473         return 0;
 474 }
 475
 476 static sense_reason_t
 477 iblock_execute_write_same(struct se_cmd *cmd)
 478 {
 479         struct iblock_req *ibr;
 480         struct scatterlist *sg;
 481         struct bio *bio;
 482         struct bio_list list;
 483         sector_t block_lba = cmd->t_task_lba;
 484         sector_t sectors = spc_get_write_same_sectors(cmd);
 485
 486         sg = &cmd->t_data_sg[0];
 487
 488         if (cmd->t_data_nents > 1 ||
 489             sg->length != cmd->se_dev->dev_attrib.block_size) {
 490                 pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"
 491                         " block_size: %u\n", cmd->t_data_nents, sg->length,
 492                         cmd->se_dev->dev_attrib.block_size);
 493                 return TCM_INVALID_CDB_FIELD;
 494         }
 495
 496         ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL);
 497         if (!ibr)
 498                 goto fail;
 499         cmd->priv = ibr;
 500
 501         bio = iblock_get_bio(cmd, block_lba, 1);
 502         if (!bio)
 503                 goto fail_free_ibr;
 504
 505         bio_list_init(&list);
 506         bio_list_add(&list, bio);
 507
 508         atomic_set(&ibr->pending, 1);
 509
 510         while (sectors) {
 511                 while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)
 512                                 != sg->length) {
 513
 514                         bio = iblock_get_bio(cmd, block_lba, 1);
 515                         if (!bio)
 516                                 goto fail_put_bios;
 517
 518                         atomic_inc(&ibr->pending);
 519                         bio_list_add(&list, bio);
 520                 }
 521
 522                 /* Always in 512 byte units for Linux/Block */
 523                 block_lba += sg->length >> IBLOCK_LBA_SHIFT;
 524                 sectors -= 1;
 525         }
 526
 527         iblock_submit_bios(&list, WRITE);
 528         return 0;
 529
 530 fail_put_bios:
 531         while ((bio = bio_list_pop(&list)))
 532                 bio_put(bio);
 533 fail_free_ibr:
 534         kfree(ibr);
 535 fail:
 536         return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 537 }
 538
 539 enum {
 540         Opt_udev_path, Opt_readonly, Opt_force, Opt_err
 541 };
 542
 543 static match_table_t tokens = {
 544         {Opt_udev_path, "udev_path=%s"},
 545         {Opt_readonly, "readonly=%d"},
 546         {Opt_force, "force=%d"},
 547         {Opt_err, NULL}
 548 };
 549
 550 static ssize_t iblock_set_configfs_dev_params(struct se_device *dev,
 551                 const char *page, ssize_t count)
 552 {
 553         struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
 554         char *orig, *ptr, *arg_p, *opts;
 555         substring_t args[MAX_OPT_ARGS];
 556         int ret = 0, token;
 557         unsigned long tmp_readonly;
 558
 559         opts = kstrdup(page, GFP_KERNEL);
 560         if (!opts)
 561                 return -ENOMEM;
 562
 563         orig = opts;
 564
 565         while ((ptr = strsep(&opts, ",\n")) != NULL) {
 566                 if (!*ptr)
 567                         continue;
 568
 569                 token = match_token(ptr, tokens, args);
 570                 switch (token) {
 571                 case Opt_udev_path:
 572                         if (ib_dev->ibd_bd) {
 573                                 pr_err("Unable to set udev_path= while"
 574                                         " ib_dev->ibd_bd exists\n");
 575                                 ret = -EEXIST;
 576                                 goto out;
 577                         }
 578                         if (match_strlcpy(ib_dev->ibd_udev_path, &args[0],
 579                                 SE_UDEV_PATH_LEN) == 0) {
 580                                 ret = -EINVAL;
 581                                 break;
 582                         }
 583                         pr_debug("IBLOCK: Referencing UDEV path: %s\n",
 584                                         ib_dev->ibd_udev_path);
 585                         ib_dev->ibd_flags |= IBDF_HAS_UDEV_PATH;
 586                         break;
 587                 case Opt_readonly:
 588                         arg_p = match_strdup(&args[0]);
 589                         if (!arg_p) {
 590                                 ret = -ENOMEM;
 591                                 break;
 592                         }
 593                         ret = strict_strtoul(arg_p, 0, &tmp_readonly);
 594                         kfree(arg_p);
 595                         if (ret < 0) {
 596                                 pr_err("strict_strtoul() failed for"
 597                                                 " readonly=\n");
 598                                 goto out;
 599                         }
 600                         ib_dev->ibd_readonly = tmp_readonly;
 601                         pr_debug("IBLOCK: readonly: %d\n", ib_dev->ibd_readonly);
 602                         break;
 603                 case Opt_force:
 604                         break;
 605                 default:
 606                         break;
 607                 }
 608         }
 609
 610 out:
 611         kfree(orig);
 612         return (!ret) ? count : ret;
 613 }
 614
 615 static ssize_t iblock_show_configfs_dev_params(struct se_device *dev, char *b)
 616 {
 617         struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
 618         struct block_device *bd = ib_dev->ibd_bd;
 619         char buf[BDEVNAME_SIZE];
 620         ssize_t bl = 0;
 621
 622         if (bd)
 623                 bl += sprintf(b + bl, "iBlock device: %s",
 624                                 bdevname(bd, buf));
 625         if (ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH)
 626                 bl += sprintf(b + bl, "  UDEV PATH: %s",
 627                                 ib_dev->ibd_udev_path);
 628         bl += sprintf(b + bl, "  readonly: %d\n", ib_dev->ibd_readonly);
 629
 630         bl += sprintf(b + bl, "        ");
 631         if (bd) {
 632                 bl += sprintf(b + bl, "Major: %d Minor: %d  %s\n",
 633                         MAJOR(bd->bd_dev), MINOR(bd->bd_dev), (!bd->bd_contains) ?
 634                         "" : (bd->bd_holder == ib_dev) ?
 635                         "CLAIMED: IBLOCK" : "CLAIMED: OS");
 636         } else {
 637                 bl += sprintf(b + bl, "Major: 0 Minor: 0\n");
 638         }
 639
 640         return bl;
 641 }
 642
 643 static sense_reason_t
 644 iblock_execute_rw(struct se_cmd *cmd)
 645 {
 646         struct scatterlist *sgl = cmd->t_data_sg;
 647         u32 sgl_nents = cmd->t_data_nents;
 648         enum dma_data_direction data_direction = cmd->data_direction;
 649         struct se_device *dev = cmd->se_dev;
 650         struct iblock_req *ibr;
 651         struct bio *bio;
 652         struct bio_list list;
 653         struct scatterlist *sg;
 654         u32 sg_num = sgl_nents;
 655         sector_t block_lba;
 656         unsigned bio_cnt;
 657         int rw;
 658         int i;
 659
 660         if (data_direction == DMA_TO_DEVICE) {
 661                 /*
 662                  * Force data to disk if we pretend to not have a volatile
 663                  * write cache, or the initiator set the Force Unit Access bit.
 664                  */
 665                 if (dev->dev_attrib.emulate_write_cache == 0 ||
 666                     (dev->dev_attrib.emulate_fua_write > 0 &&
 667                      (cmd->se_cmd_flags & SCF_FUA)))
 668                         rw = WRITE_FUA;
 669                 else
 670                         rw = WRITE;
 671         } else {
 672                 rw = READ;
 673         }
 674
 675         /*
 676          * Convert the blocksize advertised to the initiator to the 512 byte
 677          * units unconditionally used by the Linux block layer.
 678          */
 679         if (dev->dev_attrib.block_size == 4096)
 680                 block_lba = (cmd->t_task_lba << 3);
 681         else if (dev->dev_attrib.block_size == 2048)
 682                 block_lba = (cmd->t_task_lba << 2);
 683         else if (dev->dev_attrib.block_size == 1024)
 684                 block_lba = (cmd->t_task_lba << 1);
 685         else if (dev->dev_attrib.block_size == 512)
 686                 block_lba = cmd->t_task_lba;
 687         else {
 688                 pr_err("Unsupported SCSI -> BLOCK LBA conversion:"
 689                                 " %u\n", dev->dev_attrib.block_size);
 690                 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 691         }
 692
 693         ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL);
 694         if (!ibr)
 695                 goto fail;
 696         cmd->priv = ibr;
 697
 698         if (!sgl_nents) {
 699                 atomic_set(&ibr->pending, 1);
 700                 iblock_complete_cmd(cmd);
 701                 return 0;
 702         }
 703
 704         bio = iblock_get_bio(cmd, block_lba, sgl_nents);
 705         if (!bio)
 706                 goto fail_free_ibr;
 707
 708         bio_list_init(&list);
 709         bio_list_add(&list, bio);
 710
 711         atomic_set(&ibr->pending, 2);
 712         bio_cnt = 1;
 713
 714         for_each_sg(sgl, sg, sgl_nents, i) {
 715                 /*
 716                  * XXX: if the length the device accepts is shorter than the
 717                  *      length of the S/G list entry this will cause and
 718                  *      endless loop.  Better hope no driver uses huge pages.
 719                  */
 720                 while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)
 721                                 != sg->length) {
 722                         if (bio_cnt >= IBLOCK_MAX_BIO_PER_TASK) {
 723                                 iblock_submit_bios(&list, rw);
 724                                 bio_cnt = 0;
 725                         }
 726
 727                         bio = iblock_get_bio(cmd, block_lba, sg_num);
 728                         if (!bio)
 729                                 goto fail_put_bios;
 730
 731                         atomic_inc(&ibr->pending);
 732                         bio_list_add(&list, bio);
 733                         bio_cnt++;
 734                 }
 735
 736                 /* Always in 512 byte units for Linux/Block */
 737                 block_lba += sg->length >> IBLOCK_LBA_SHIFT;
 738                 sg_num--;
 739         }
 740
 741         iblock_submit_bios(&list, rw);
 742         iblock_complete_cmd(cmd);
 743         return 0;
 744
 745 fail_put_bios:
 746         while ((bio = bio_list_pop(&list)))
 747                 bio_put(bio);
 748 fail_free_ibr:
 749         kfree(ibr);
 750 fail:
 751         return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 752 }
 753
 754 static sector_t iblock_get_blocks(struct se_device *dev)
 755 {
 756         struct iblock_dev *ib_dev = IBLOCK_DEV(dev);
 757         struct block_device *bd = ib_dev->ibd_bd;
 758         struct request_queue *q = bdev_get_queue(bd);
 759
 760         return iblock_emulate_read_cap_with_block_size(dev, bd, q);
 761 }
 762
 763 static struct sbc_ops iblock_sbc_ops = {
 764         .execute_rw             = iblock_execute_rw,
 765         .execute_sync_cache     = iblock_execute_sync_cache,
 766         .execute_write_same     = iblock_execute_write_same,
 767         .execute_write_same_unmap = iblock_execute_write_same_unmap,
 768         .execute_unmap          = iblock_execute_unmap,
 769 };
 770
 771 static sense_reason_t
 772 iblock_parse_cdb(struct se_cmd *cmd)
 773 {
 774         return sbc_parse_cdb(cmd, &iblock_sbc_ops);
 775 }
 776
 777 static struct se_subsystem_api iblock_template = {
 778         .name                   = "iblock",
 779         .inquiry_prod           = "IBLOCK",
 780         .inquiry_rev            = IBLOCK_VERSION,
 781         .owner                  = THIS_MODULE,
 782         .transport_type         = TRANSPORT_PLUGIN_VHBA_PDEV,
 783         .attach_hba             = iblock_attach_hba,
 784         .detach_hba             = iblock_detach_hba,
 785         .alloc_device           = iblock_alloc_device,
 786         .configure_device       = iblock_configure_device,
 787         .free_device            = iblock_free_device,
 788         .parse_cdb              = iblock_parse_cdb,
 789         .set_configfs_dev_params = iblock_set_configfs_dev_params,
 790         .show_configfs_dev_params = iblock_show_configfs_dev_params,
 791         .get_device_type        = sbc_get_device_type,
 792         .get_blocks             = iblock_get_blocks,
 793 };
 794
 795 static int __init iblock_module_init(void)
 796 {
 797         return transport_subsystem_register(&iblock_template);
 798 }
 799
 800 static void iblock_module_exit(void)
 801 {
 802         transport_subsystem_release(&iblock_template);
 803 }
 804
 805 MODULE_DESCRIPTION("TCM IBLOCK subsystem plugin");
 806 MODULE_AUTHOR("nab@Linux-iSCSI.org");
 807 MODULE_LICENSE("GPL");
 808
 809 module_init(iblock_module_init);
 810 module_exit(iblock_module_exit);