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  * Copyright (c) 2003, 2004, 2005 PyX Technologies, Inc.
   8  * Copyright (c) 2005, 2006, 2007 SBE, Inc.
   9  * Copyright (c) 2007-2010 Rising Tide Systems
  10  * Copyright (c) 2008-2010 Linux-iSCSI.org
  11  *
  12  * Nicholas A. Bellinger <nab@kernel.org>
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27  *
  28  ******************************************************************************/
  29
  30 #include <linux/string.h>
  31 #include <linux/parser.h>
  32 #include <linux/timer.h>
  33 #include <linux/fs.h>
  34 #include <linux/blkdev.h>
  35 #include <linux/slab.h>
  36 #include <linux/spinlock.h>
  37 #include <linux/bio.h>
  38 #include <linux/genhd.h>
  39 #include <linux/file.h>
  40 #include <linux/module.h>
  41 #include <scsi/scsi.h>
  42 #include <scsi/scsi_host.h>
  43
  44 #include <target/target_core_base.h>
  45 #include <target/target_core_backend.h>
  46
  47 #include "target_core_iblock.h"
  48
  49 #define IBLOCK_MAX_BIO_PER_TASK  32     /* max # of bios to submit at a time */
  50 #define IBLOCK_BIO_POOL_SIZE    128
  51
  52 static struct se_subsystem_api iblock_template;
  53
  54 static void iblock_bio_done(struct bio *, int);
  55
  56 /*      iblock_attach_hba(): (Part of se_subsystem_api_t template)
  57  *
  58  *
  59  */
  60 static int iblock_attach_hba(struct se_hba *hba, u32 host_id)
  61 {
  62         pr_debug("CORE_HBA[%d] - TCM iBlock HBA Driver %s on"
  63                 " Generic Target Core Stack %s\n", hba->hba_id,
  64                 IBLOCK_VERSION, TARGET_CORE_MOD_VERSION);
  65         return 0;
  66 }
  67
  68 static void iblock_detach_hba(struct se_hba *hba)
  69 {
  70 }
  71
  72 static void *iblock_allocate_virtdevice(struct se_hba *hba, const char *name)
  73 {
  74         struct iblock_dev *ib_dev = NULL;
  75
  76         ib_dev = kzalloc(sizeof(struct iblock_dev), GFP_KERNEL);
  77         if (!ib_dev) {
  78                 pr_err("Unable to allocate struct iblock_dev\n");
  79                 return NULL;
  80         }
  81
  82         pr_debug( "IBLOCK: Allocated ib_dev for %s\n", name);
  83
  84         return ib_dev;
  85 }
  86
  87 static struct se_device *iblock_create_virtdevice(
  88         struct se_hba *hba,
  89         struct se_subsystem_dev *se_dev,
  90         void *p)
  91 {
  92         struct iblock_dev *ib_dev = p;
  93         struct se_device *dev;
  94         struct se_dev_limits dev_limits;
  95         struct block_device *bd = NULL;
  96         struct request_queue *q;
  97         struct queue_limits *limits;
  98         u32 dev_flags = 0;
  99         int ret = -EINVAL;
 100
 101         if (!ib_dev) {
 102                 pr_err("Unable to locate struct iblock_dev parameter\n");
 103                 return ERR_PTR(ret);
 104         }
 105         memset(&dev_limits, 0, sizeof(struct se_dev_limits));
 106
 107         ib_dev->ibd_bio_set = bioset_create(IBLOCK_BIO_POOL_SIZE, 0);
 108         if (!ib_dev->ibd_bio_set) {
 109                 pr_err("IBLOCK: Unable to create bioset()\n");
 110                 return ERR_PTR(-ENOMEM);
 111         }
 112         pr_debug("IBLOCK: Created bio_set()\n");
 113         /*
 114          * iblock_check_configfs_dev_params() ensures that ib_dev->ibd_udev_path
 115          * must already have been set in order for echo 1 > $HBA/$DEV/enable to run.
 116          */
 117         pr_debug( "IBLOCK: Claiming struct block_device: %s\n",
 118                         ib_dev->ibd_udev_path);
 119
 120         bd = blkdev_get_by_path(ib_dev->ibd_udev_path,
 121                                 FMODE_WRITE|FMODE_READ|FMODE_EXCL, ib_dev);
 122         if (IS_ERR(bd)) {
 123                 ret = PTR_ERR(bd);
 124                 goto failed;
 125         }
 126         /*
 127          * Setup the local scope queue_limits from struct request_queue->limits
 128          * to pass into transport_add_device_to_core_hba() as struct se_dev_limits.
 129          */
 130         q = bdev_get_queue(bd);
 131         limits = &dev_limits.limits;
 132         limits->logical_block_size = bdev_logical_block_size(bd);
 133         limits->max_hw_sectors = UINT_MAX;
 134         limits->max_sectors = UINT_MAX;
 135         dev_limits.hw_queue_depth = q->nr_requests;
 136         dev_limits.queue_depth = q->nr_requests;
 137
 138         ib_dev->ibd_bd = bd;
 139
 140         dev = transport_add_device_to_core_hba(hba,
 141                         &iblock_template, se_dev, dev_flags, ib_dev,
 142                         &dev_limits, "IBLOCK", IBLOCK_VERSION);
 143         if (!dev)
 144                 goto failed;
 145
 146         /*
 147          * Check if the underlying struct block_device request_queue supports
 148          * the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM
 149          * in ATA and we need to set TPE=1
 150          */
 151         if (blk_queue_discard(q)) {
 152                 dev->se_sub_dev->se_dev_attrib.max_unmap_lba_count =
 153                                 q->limits.max_discard_sectors;
 154                 /*
 155                  * Currently hardcoded to 1 in Linux/SCSI code..
 156                  */
 157                 dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count = 1;
 158                 dev->se_sub_dev->se_dev_attrib.unmap_granularity =
 159                                 q->limits.discard_granularity >> 9;
 160                 dev->se_sub_dev->se_dev_attrib.unmap_granularity_alignment =
 161                                 q->limits.discard_alignment;
 162
 163                 pr_debug("IBLOCK: BLOCK Discard support available,"
 164                                 " disabled by default\n");
 165         }
 166
 167         if (blk_queue_nonrot(q))
 168                 dev->se_sub_dev->se_dev_attrib.is_nonrot = 1;
 169
 170         return dev;
 171
 172 failed:
 173         if (ib_dev->ibd_bio_set) {
 174                 bioset_free(ib_dev->ibd_bio_set);
 175                 ib_dev->ibd_bio_set = NULL;
 176         }
 177         ib_dev->ibd_bd = NULL;
 178         return ERR_PTR(ret);
 179 }
 180
 181 static void iblock_free_device(void *p)
 182 {
 183         struct iblock_dev *ib_dev = p;
 184
 185         if (ib_dev->ibd_bd != NULL)
 186                 blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL);
 187         if (ib_dev->ibd_bio_set != NULL)
 188                 bioset_free(ib_dev->ibd_bio_set);
 189         kfree(ib_dev);
 190 }
 191
 192 static unsigned long long iblock_emulate_read_cap_with_block_size(
 193         struct se_device *dev,
 194         struct block_device *bd,
 195         struct request_queue *q)
 196 {
 197         unsigned long long blocks_long = (div_u64(i_size_read(bd->bd_inode),
 198                                         bdev_logical_block_size(bd)) - 1);
 199         u32 block_size = bdev_logical_block_size(bd);
 200
 201         if (block_size == dev->se_sub_dev->se_dev_attrib.block_size)
 202                 return blocks_long;
 203
 204         switch (block_size) {
 205         case 4096:
 206                 switch (dev->se_sub_dev->se_dev_attrib.block_size) {
 207                 case 2048:
 208                         blocks_long <<= 1;
 209                         break;
 210                 case 1024:
 211                         blocks_long <<= 2;
 212                         break;
 213                 case 512:
 214                         blocks_long <<= 3;
 215                 default:
 216                         break;
 217                 }
 218                 break;
 219         case 2048:
 220                 switch (dev->se_sub_dev->se_dev_attrib.block_size) {
 221                 case 4096:
 222                         blocks_long >>= 1;
 223                         break;
 224                 case 1024:
 225                         blocks_long <<= 1;
 226                         break;
 227                 case 512:
 228                         blocks_long <<= 2;
 229                         break;
 230                 default:
 231                         break;
 232                 }
 233                 break;
 234         case 1024:
 235                 switch (dev->se_sub_dev->se_dev_attrib.block_size) {
 236                 case 4096:
 237                         blocks_long >>= 2;
 238                         break;
 239                 case 2048:
 240                         blocks_long >>= 1;
 241                         break;
 242                 case 512:
 243                         blocks_long <<= 1;
 244                         break;
 245                 default:
 246                         break;
 247                 }
 248                 break;
 249         case 512:
 250                 switch (dev->se_sub_dev->se_dev_attrib.block_size) {
 251                 case 4096:
 252                         blocks_long >>= 3;
 253                         break;
 254                 case 2048:
 255                         blocks_long >>= 2;
 256                         break;
 257                 case 1024:
 258                         blocks_long >>= 1;
 259                         break;
 260                 default:
 261                         break;
 262                 }
 263                 break;
 264         default:
 265                 break;
 266         }
 267
 268         return blocks_long;
 269 }
 270
 271 static void iblock_end_io_flush(struct bio *bio, int err)
 272 {
 273         struct se_cmd *cmd = bio->bi_private;
 274
 275         if (err)
 276                 pr_err("IBLOCK: cache flush failed: %d\n", err);
 277
 278         if (cmd) {
 279                 if (err) {
 280                         cmd->scsi_sense_reason =
 281                                 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 282                         target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
 283                 } else {
 284                         target_complete_cmd(cmd, SAM_STAT_GOOD);
 285                 }
 286         }
 287
 288         bio_put(bio);
 289 }
 290
 291 /*
 292  * Implement SYCHRONIZE CACHE.  Note that we can't handle lba ranges and must
 293  * always flush the whole cache.
 294  */
 295 static void iblock_emulate_sync_cache(struct se_cmd *cmd)
 296 {
 297         struct iblock_dev *ib_dev = cmd->se_dev->dev_ptr;
 298         int immed = (cmd->t_task_cdb[1] & 0x2);
 299         struct bio *bio;
 300
 301         /*
 302          * If the Immediate bit is set, queue up the GOOD response
 303          * for this SYNCHRONIZE_CACHE op.
 304          */
 305         if (immed)
 306                 target_complete_cmd(cmd, SAM_STAT_GOOD);
 307
 308         bio = bio_alloc(GFP_KERNEL, 0);
 309         bio->bi_end_io = iblock_end_io_flush;
 310         bio->bi_bdev = ib_dev->ibd_bd;
 311         if (!immed)
 312                 bio->bi_private = cmd;
 313         submit_bio(WRITE_FLUSH, bio);
 314 }
 315
 316 static int iblock_do_discard(struct se_device *dev, sector_t lba, u32 range)
 317 {
 318         struct iblock_dev *ibd = dev->dev_ptr;
 319         struct block_device *bd = ibd->ibd_bd;
 320         int barrier = 0;
 321
 322         return blkdev_issue_discard(bd, lba, range, GFP_KERNEL, barrier);
 323 }
 324
 325 enum {
 326         Opt_udev_path, Opt_force, Opt_err
 327 };
 328
 329 static match_table_t tokens = {
 330         {Opt_udev_path, "udev_path=%s"},
 331         {Opt_force, "force=%d"},
 332         {Opt_err, NULL}
 333 };
 334
 335 static ssize_t iblock_set_configfs_dev_params(struct se_hba *hba,
 336                                                struct se_subsystem_dev *se_dev,
 337                                                const char *page, ssize_t count)
 338 {
 339         struct iblock_dev *ib_dev = se_dev->se_dev_su_ptr;
 340         char *orig, *ptr, *arg_p, *opts;
 341         substring_t args[MAX_OPT_ARGS];
 342         int ret = 0, token;
 343
 344         opts = kstrdup(page, GFP_KERNEL);
 345         if (!opts)
 346                 return -ENOMEM;
 347
 348         orig = opts;
 349
 350         while ((ptr = strsep(&opts, ",\n")) != NULL) {
 351                 if (!*ptr)
 352                         continue;
 353
 354                 token = match_token(ptr, tokens, args);
 355                 switch (token) {
 356                 case Opt_udev_path:
 357                         if (ib_dev->ibd_bd) {
 358                                 pr_err("Unable to set udev_path= while"
 359                                         " ib_dev->ibd_bd exists\n");
 360                                 ret = -EEXIST;
 361                                 goto out;
 362                         }
 363                         arg_p = match_strdup(&args[0]);
 364                         if (!arg_p) {
 365                                 ret = -ENOMEM;
 366                                 break;
 367                         }
 368                         snprintf(ib_dev->ibd_udev_path, SE_UDEV_PATH_LEN,
 369                                         "%s", arg_p);
 370                         kfree(arg_p);
 371                         pr_debug("IBLOCK: Referencing UDEV path: %s\n",
 372                                         ib_dev->ibd_udev_path);
 373                         ib_dev->ibd_flags |= IBDF_HAS_UDEV_PATH;
 374                         break;
 375                 case Opt_force:
 376                         break;
 377                 default:
 378                         break;
 379                 }
 380         }
 381
 382 out:
 383         kfree(orig);
 384         return (!ret) ? count : ret;
 385 }
 386
 387 static ssize_t iblock_check_configfs_dev_params(
 388         struct se_hba *hba,
 389         struct se_subsystem_dev *se_dev)
 390 {
 391         struct iblock_dev *ibd = se_dev->se_dev_su_ptr;
 392
 393         if (!(ibd->ibd_flags & IBDF_HAS_UDEV_PATH)) {
 394                 pr_err("Missing udev_path= parameters for IBLOCK\n");
 395                 return -EINVAL;
 396         }
 397
 398         return 0;
 399 }
 400
 401 static ssize_t iblock_show_configfs_dev_params(
 402         struct se_hba *hba,
 403         struct se_subsystem_dev *se_dev,
 404         char *b)
 405 {
 406         struct iblock_dev *ibd = se_dev->se_dev_su_ptr;
 407         struct block_device *bd = ibd->ibd_bd;
 408         char buf[BDEVNAME_SIZE];
 409         ssize_t bl = 0;
 410
 411         if (bd)
 412                 bl += sprintf(b + bl, "iBlock device: %s",
 413                                 bdevname(bd, buf));
 414         if (ibd->ibd_flags & IBDF_HAS_UDEV_PATH) {
 415                 bl += sprintf(b + bl, "  UDEV PATH: %s\n",
 416                                 ibd->ibd_udev_path);
 417         } else
 418                 bl += sprintf(b + bl, "\n");
 419
 420         bl += sprintf(b + bl, "        ");
 421         if (bd) {
 422                 bl += sprintf(b + bl, "Major: %d Minor: %d  %s\n",
 423                         MAJOR(bd->bd_dev), MINOR(bd->bd_dev), (!bd->bd_contains) ?
 424                         "" : (bd->bd_holder == ibd) ?
 425                         "CLAIMED: IBLOCK" : "CLAIMED: OS");
 426         } else {
 427                 bl += sprintf(b + bl, "Major: 0 Minor: 0\n");
 428         }
 429
 430         return bl;
 431 }
 432
 433 static void iblock_complete_cmd(struct se_cmd *cmd)
 434 {
 435         struct iblock_req *ibr = cmd->priv;
 436         u8 status;
 437
 438         if (!atomic_dec_and_test(&ibr->pending))
 439                 return;
 440
 441         if (atomic_read(&ibr->ib_bio_err_cnt))
 442                 status = SAM_STAT_CHECK_CONDITION;
 443         else
 444                 status = SAM_STAT_GOOD;
 445
 446         target_complete_cmd(cmd, status);
 447         kfree(ibr);
 448 }
 449
 450 static void iblock_bio_destructor(struct bio *bio)
 451 {
 452         struct se_cmd *cmd = bio->bi_private;
 453         struct iblock_dev *ib_dev = cmd->se_dev->dev_ptr;
 454
 455         bio_free(bio, ib_dev->ibd_bio_set);
 456 }
 457
 458 static struct bio *
 459 iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num)
 460 {
 461         struct iblock_dev *ib_dev = cmd->se_dev->dev_ptr;
 462         struct bio *bio;
 463
 464         /*
 465          * Only allocate as many vector entries as the bio code allows us to,
 466          * we'll loop later on until we have handled the whole request.
 467          */
 468         if (sg_num > BIO_MAX_PAGES)
 469                 sg_num = BIO_MAX_PAGES;
 470
 471         bio = bio_alloc_bioset(GFP_NOIO, sg_num, ib_dev->ibd_bio_set);
 472         if (!bio) {
 473                 pr_err("Unable to allocate memory for bio\n");
 474                 return NULL;
 475         }
 476
 477         bio->bi_bdev = ib_dev->ibd_bd;
 478         bio->bi_private = cmd;
 479         bio->bi_destructor = iblock_bio_destructor;
 480         bio->bi_end_io = &iblock_bio_done;
 481         bio->bi_sector = lba;
 482         return bio;
 483 }
 484
 485 static void iblock_submit_bios(struct bio_list *list, int rw)
 486 {
 487         struct blk_plug plug;
 488         struct bio *bio;
 489
 490         blk_start_plug(&plug);
 491         while ((bio = bio_list_pop(list)))
 492                 submit_bio(rw, bio);
 493         blk_finish_plug(&plug);
 494 }
 495
 496 static int iblock_execute_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
 497                 u32 sgl_nents, enum dma_data_direction data_direction)
 498 {
 499         struct se_device *dev = cmd->se_dev;
 500         struct iblock_req *ibr;
 501         struct bio *bio;
 502         struct bio_list list;
 503         struct scatterlist *sg;
 504         u32 sg_num = sgl_nents;
 505         sector_t block_lba;
 506         unsigned bio_cnt;
 507         int rw;
 508         int i;
 509
 510         if (data_direction == DMA_TO_DEVICE) {
 511                 /*
 512                  * Force data to disk if we pretend to not have a volatile
 513                  * write cache, or the initiator set the Force Unit Access bit.
 514                  */
 515                 if (dev->se_sub_dev->se_dev_attrib.emulate_write_cache == 0 ||
 516                     (dev->se_sub_dev->se_dev_attrib.emulate_fua_write > 0 &&
 517                      (cmd->se_cmd_flags & SCF_FUA)))
 518                         rw = WRITE_FUA;
 519                 else
 520                         rw = WRITE;
 521         } else {
 522                 rw = READ;
 523         }
 524
 525         /*
 526          * Convert the blocksize advertised to the initiator to the 512 byte
 527          * units unconditionally used by the Linux block layer.
 528          */
 529         if (dev->se_sub_dev->se_dev_attrib.block_size == 4096)
 530                 block_lba = (cmd->t_task_lba << 3);
 531         else if (dev->se_sub_dev->se_dev_attrib.block_size == 2048)
 532                 block_lba = (cmd->t_task_lba << 2);
 533         else if (dev->se_sub_dev->se_dev_attrib.block_size == 1024)
 534                 block_lba = (cmd->t_task_lba << 1);
 535         else if (dev->se_sub_dev->se_dev_attrib.block_size == 512)
 536                 block_lba = cmd->t_task_lba;
 537         else {
 538                 pr_err("Unsupported SCSI -> BLOCK LBA conversion:"
 539                                 " %u\n", dev->se_sub_dev->se_dev_attrib.block_size);
 540                 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 541                 return -ENOSYS;
 542         }
 543
 544         ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL);
 545         if (!ibr)
 546                 goto fail;
 547         cmd->priv = ibr;
 548
 549         bio = iblock_get_bio(cmd, block_lba, sgl_nents);
 550         if (!bio)
 551                 goto fail_free_ibr;
 552
 553         bio_list_init(&list);
 554         bio_list_add(&list, bio);
 555
 556         atomic_set(&ibr->pending, 2);
 557         bio_cnt = 1;
 558
 559         for_each_sg(sgl, sg, sgl_nents, i) {
 560                 /*
 561                  * XXX: if the length the device accepts is shorter than the
 562                  *      length of the S/G list entry this will cause and
 563                  *      endless loop.  Better hope no driver uses huge pages.
 564                  */
 565                 while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)
 566                                 != sg->length) {
 567                         if (bio_cnt >= IBLOCK_MAX_BIO_PER_TASK) {
 568                                 iblock_submit_bios(&list, rw);
 569                                 bio_cnt = 0;
 570                         }
 571
 572                         bio = iblock_get_bio(cmd, block_lba, sg_num);
 573                         if (!bio)
 574                                 goto fail_put_bios;
 575
 576                         atomic_inc(&ibr->pending);
 577                         bio_list_add(&list, bio);
 578                         bio_cnt++;
 579                 }
 580
 581                 /* Always in 512 byte units for Linux/Block */
 582                 block_lba += sg->length >> IBLOCK_LBA_SHIFT;
 583                 sg_num--;
 584         }
 585
 586         iblock_submit_bios(&list, rw);
 587         iblock_complete_cmd(cmd);
 588         return 0;
 589
 590 fail_put_bios:
 591         while ((bio = bio_list_pop(&list)))
 592                 bio_put(bio);
 593 fail_free_ibr:
 594         kfree(ibr);
 595         cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 596 fail:
 597         return -ENOMEM;
 598 }
 599
 600 static u32 iblock_get_device_rev(struct se_device *dev)
 601 {
 602         return SCSI_SPC_2; /* Returns SPC-3 in Initiator Data */
 603 }
 604
 605 static u32 iblock_get_device_type(struct se_device *dev)
 606 {
 607         return TYPE_DISK;
 608 }
 609
 610 static sector_t iblock_get_blocks(struct se_device *dev)
 611 {
 612         struct iblock_dev *ibd = dev->dev_ptr;
 613         struct block_device *bd = ibd->ibd_bd;
 614         struct request_queue *q = bdev_get_queue(bd);
 615
 616         return iblock_emulate_read_cap_with_block_size(dev, bd, q);
 617 }
 618
 619 static void iblock_bio_done(struct bio *bio, int err)
 620 {
 621         struct se_cmd *cmd = bio->bi_private;
 622         struct iblock_req *ibr = cmd->priv;
 623
 624         /*
 625          * Set -EIO if !BIO_UPTODATE and the passed is still err=0
 626          */
 627         if (!test_bit(BIO_UPTODATE, &bio->bi_flags) && !err)
 628                 err = -EIO;
 629
 630         if (err != 0) {
 631                 pr_err("test_bit(BIO_UPTODATE) failed for bio: %p,"
 632                         " err: %d\n", bio, err);
 633                 /*
 634                  * Bump the ib_bio_err_cnt and release bio.
 635                  */
 636                 atomic_inc(&ibr->ib_bio_err_cnt);
 637                 smp_mb__after_atomic_inc();
 638         }
 639
 640         bio_put(bio);
 641
 642         iblock_complete_cmd(cmd);
 643 }
 644
 645 static struct se_subsystem_api iblock_template = {
 646         .name                   = "iblock",
 647         .owner                  = THIS_MODULE,
 648         .transport_type         = TRANSPORT_PLUGIN_VHBA_PDEV,
 649         .write_cache_emulated   = 1,
 650         .fua_write_emulated     = 1,
 651         .attach_hba             = iblock_attach_hba,
 652         .detach_hba             = iblock_detach_hba,
 653         .allocate_virtdevice    = iblock_allocate_virtdevice,
 654         .create_virtdevice      = iblock_create_virtdevice,
 655         .free_device            = iblock_free_device,
 656         .execute_cmd            = iblock_execute_cmd,
 657         .do_discard             = iblock_do_discard,
 658         .do_sync_cache          = iblock_emulate_sync_cache,
 659         .check_configfs_dev_params = iblock_check_configfs_dev_params,
 660         .set_configfs_dev_params = iblock_set_configfs_dev_params,
 661         .show_configfs_dev_params = iblock_show_configfs_dev_params,
 662         .get_device_rev         = iblock_get_device_rev,
 663         .get_device_type        = iblock_get_device_type,
 664         .get_blocks             = iblock_get_blocks,
 665 };
 666
 667 static int __init iblock_module_init(void)
 668 {
 669         return transport_subsystem_register(&iblock_template);
 670 }
 671
 672 static void iblock_module_exit(void)
 673 {
 674         transport_subsystem_release(&iblock_template);
 675 }
 676
 677 MODULE_DESCRIPTION("TCM IBLOCK subsystem plugin");
 678 MODULE_AUTHOR("nab@Linux-iSCSI.org");
 679 MODULE_LICENSE("GPL");
 680
 681 module_init(iblock_module_init);
 682 module_exit(iblock_module_exit);