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