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