1c66ac9dbSNicholas Bellinger /******************************************************************************* 2c66ac9dbSNicholas Bellinger * Filename: target_core_iblock.c 3c66ac9dbSNicholas Bellinger * 4c66ac9dbSNicholas Bellinger * This file contains the Storage Engine <-> Linux BlockIO transport 5c66ac9dbSNicholas Bellinger * specific functions. 6c66ac9dbSNicholas Bellinger * 74c76251eSNicholas Bellinger * (c) Copyright 2003-2013 Datera, Inc. 8c66ac9dbSNicholas Bellinger * 9c66ac9dbSNicholas Bellinger * Nicholas A. Bellinger <nab@kernel.org> 10c66ac9dbSNicholas Bellinger * 11c66ac9dbSNicholas Bellinger * This program is free software; you can redistribute it and/or modify 12c66ac9dbSNicholas Bellinger * it under the terms of the GNU General Public License as published by 13c66ac9dbSNicholas Bellinger * the Free Software Foundation; either version 2 of the License, or 14c66ac9dbSNicholas Bellinger * (at your option) any later version. 15c66ac9dbSNicholas Bellinger * 16c66ac9dbSNicholas Bellinger * This program is distributed in the hope that it will be useful, 17c66ac9dbSNicholas Bellinger * but WITHOUT ANY WARRANTY; without even the implied warranty of 18c66ac9dbSNicholas Bellinger * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19c66ac9dbSNicholas Bellinger * GNU General Public License for more details. 20c66ac9dbSNicholas Bellinger * 21c66ac9dbSNicholas Bellinger * You should have received a copy of the GNU General Public License 22c66ac9dbSNicholas Bellinger * along with this program; if not, write to the Free Software 23c66ac9dbSNicholas Bellinger * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 24c66ac9dbSNicholas Bellinger * 25c66ac9dbSNicholas Bellinger ******************************************************************************/ 26c66ac9dbSNicholas Bellinger 27c66ac9dbSNicholas Bellinger #include <linux/string.h> 28c66ac9dbSNicholas Bellinger #include <linux/parser.h> 29c66ac9dbSNicholas Bellinger #include <linux/timer.h> 30c66ac9dbSNicholas Bellinger #include <linux/fs.h> 31c66ac9dbSNicholas Bellinger #include <linux/blkdev.h> 32c66ac9dbSNicholas Bellinger #include <linux/slab.h> 33c66ac9dbSNicholas Bellinger #include <linux/spinlock.h> 34c66ac9dbSNicholas Bellinger #include <linux/bio.h> 35c66ac9dbSNicholas Bellinger #include <linux/genhd.h> 36c66ac9dbSNicholas Bellinger #include <linux/file.h> 37827509e3SPaul Gortmaker #include <linux/module.h> 38ba929992SBart Van Assche #include <scsi/scsi_proto.h> 3914150a6bSChristoph Hellwig #include <asm/unaligned.h> 40c66ac9dbSNicholas Bellinger 41c66ac9dbSNicholas Bellinger #include <target/target_core_base.h> 42c4795fb2SChristoph Hellwig #include <target/target_core_backend.h> 43c66ac9dbSNicholas Bellinger 44c66ac9dbSNicholas Bellinger #include "target_core_iblock.h" 45c66ac9dbSNicholas Bellinger 46d5b4a21bSChristoph Hellwig #define IBLOCK_MAX_BIO_PER_TASK 32 /* max # of bios to submit at a time */ 47d5b4a21bSChristoph Hellwig #define IBLOCK_BIO_POOL_SIZE 128 48d5b4a21bSChristoph Hellwig 490fd97ccfSChristoph Hellwig static inline struct iblock_dev *IBLOCK_DEV(struct se_device *dev) 500fd97ccfSChristoph Hellwig { 510fd97ccfSChristoph Hellwig return container_of(dev, struct iblock_dev, dev); 520fd97ccfSChristoph Hellwig } 530fd97ccfSChristoph Hellwig 540fd97ccfSChristoph Hellwig 55c66ac9dbSNicholas Bellinger static int iblock_attach_hba(struct se_hba *hba, u32 host_id) 56c66ac9dbSNicholas Bellinger { 576708bb27SAndy Grover pr_debug("CORE_HBA[%d] - TCM iBlock HBA Driver %s on" 58c66ac9dbSNicholas Bellinger " Generic Target Core Stack %s\n", hba->hba_id, 59ce8dd25dSChristoph Hellwig IBLOCK_VERSION, TARGET_CORE_VERSION); 60c66ac9dbSNicholas Bellinger return 0; 61c66ac9dbSNicholas Bellinger } 62c66ac9dbSNicholas Bellinger 63c66ac9dbSNicholas Bellinger static void iblock_detach_hba(struct se_hba *hba) 64c66ac9dbSNicholas Bellinger { 65c66ac9dbSNicholas Bellinger } 66c66ac9dbSNicholas Bellinger 670fd97ccfSChristoph Hellwig static struct se_device *iblock_alloc_device(struct se_hba *hba, const char *name) 68c66ac9dbSNicholas Bellinger { 69c66ac9dbSNicholas Bellinger struct iblock_dev *ib_dev = NULL; 70c66ac9dbSNicholas Bellinger 71c66ac9dbSNicholas Bellinger ib_dev = kzalloc(sizeof(struct iblock_dev), GFP_KERNEL); 726708bb27SAndy Grover if (!ib_dev) { 736708bb27SAndy Grover pr_err("Unable to allocate struct iblock_dev\n"); 74c66ac9dbSNicholas Bellinger return NULL; 75c66ac9dbSNicholas Bellinger } 76c66ac9dbSNicholas Bellinger 776708bb27SAndy Grover pr_debug( "IBLOCK: Allocated ib_dev for %s\n", name); 78c66ac9dbSNicholas Bellinger 790fd97ccfSChristoph Hellwig return &ib_dev->dev; 80c66ac9dbSNicholas Bellinger } 81c66ac9dbSNicholas Bellinger 820fd97ccfSChristoph Hellwig static int iblock_configure_device(struct se_device *dev) 83c66ac9dbSNicholas Bellinger { 840fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 85c66ac9dbSNicholas Bellinger struct request_queue *q; 860fd97ccfSChristoph Hellwig struct block_device *bd = NULL; 87ecebbf6cSNicholas Bellinger struct blk_integrity *bi; 8844bfd018SAndy Grover fmode_t mode; 892237498fSNicholas Bellinger unsigned int max_write_zeroes_sectors; 900fd97ccfSChristoph Hellwig int ret = -ENOMEM; 91c66ac9dbSNicholas Bellinger 920fd97ccfSChristoph Hellwig if (!(ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH)) { 930fd97ccfSChristoph Hellwig pr_err("Missing udev_path= parameters for IBLOCK\n"); 940fd97ccfSChristoph Hellwig return -EINVAL; 95c66ac9dbSNicholas Bellinger } 96d5b4a21bSChristoph Hellwig 97a47a28b7SKent Overstreet ret = bioset_init(&ib_dev->ibd_bio_set, IBLOCK_BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS); 98a47a28b7SKent Overstreet if (ret) { 990fd97ccfSChristoph Hellwig pr_err("IBLOCK: Unable to create bioset\n"); 1000fd97ccfSChristoph Hellwig goto out; 101c66ac9dbSNicholas Bellinger } 1020fd97ccfSChristoph Hellwig 1036708bb27SAndy Grover pr_debug( "IBLOCK: Claiming struct block_device: %s\n", 104c66ac9dbSNicholas Bellinger ib_dev->ibd_udev_path); 105c66ac9dbSNicholas Bellinger 10644bfd018SAndy Grover mode = FMODE_READ|FMODE_EXCL; 10744bfd018SAndy Grover if (!ib_dev->ibd_readonly) 10844bfd018SAndy Grover mode |= FMODE_WRITE; 109eeeb9522SNicholas Bellinger else 110eeeb9522SNicholas Bellinger dev->dev_flags |= DF_READ_ONLY; 11144bfd018SAndy Grover 11244bfd018SAndy Grover bd = blkdev_get_by_path(ib_dev->ibd_udev_path, mode, ib_dev); 113613640e4SNicholas Bellinger if (IS_ERR(bd)) { 114613640e4SNicholas Bellinger ret = PTR_ERR(bd); 1150fd97ccfSChristoph Hellwig goto out_free_bioset; 116613640e4SNicholas Bellinger } 117c66ac9dbSNicholas Bellinger ib_dev->ibd_bd = bd; 118c66ac9dbSNicholas Bellinger 1190fd97ccfSChristoph Hellwig q = bdev_get_queue(bd); 1200fd97ccfSChristoph Hellwig 1210fd97ccfSChristoph Hellwig dev->dev_attrib.hw_block_size = bdev_logical_block_size(bd); 122046ba642SNicholas Bellinger dev->dev_attrib.hw_max_sectors = queue_max_hw_sectors(q); 1230fd97ccfSChristoph Hellwig dev->dev_attrib.hw_queue_depth = q->nr_requests; 124c66ac9dbSNicholas Bellinger 125ea263c7fSMike Christie if (target_configure_unmap_from_queue(&dev->dev_attrib, q)) 1266708bb27SAndy Grover pr_debug("IBLOCK: BLOCK Discard support available," 127c66ac9dbSNicholas Bellinger " disabled by default\n"); 1288a9ebe71SMike Christie 129f6970ad3SNicholas Bellinger /* 130f6970ad3SNicholas Bellinger * Enable write same emulation for IBLOCK and use 0xFFFF as 131f6970ad3SNicholas Bellinger * the smaller WRITE_SAME(10) only has a two-byte block count. 132f6970ad3SNicholas Bellinger */ 1332237498fSNicholas Bellinger max_write_zeroes_sectors = bdev_write_zeroes_sectors(bd); 1342237498fSNicholas Bellinger if (max_write_zeroes_sectors) 1352237498fSNicholas Bellinger dev->dev_attrib.max_write_same_len = max_write_zeroes_sectors; 1362237498fSNicholas Bellinger else 137f6970ad3SNicholas Bellinger dev->dev_attrib.max_write_same_len = 0xFFFF; 138c66ac9dbSNicholas Bellinger 139e22a7f07SRoland Dreier if (blk_queue_nonrot(q)) 1400fd97ccfSChristoph Hellwig dev->dev_attrib.is_nonrot = 1; 141d0c8b259SNicholas Bellinger 142ecebbf6cSNicholas Bellinger bi = bdev_get_integrity(bd); 143ecebbf6cSNicholas Bellinger if (bi) { 144a47a28b7SKent Overstreet struct bio_set *bs = &ib_dev->ibd_bio_set; 145ecebbf6cSNicholas Bellinger 1460f8087ecSMartin K. Petersen if (!strcmp(bi->profile->name, "T10-DIF-TYPE3-IP") || 1470f8087ecSMartin K. Petersen !strcmp(bi->profile->name, "T10-DIF-TYPE1-IP")) { 148ecebbf6cSNicholas Bellinger pr_err("IBLOCK export of blk_integrity: %s not" 1490f8087ecSMartin K. Petersen " supported\n", bi->profile->name); 150ecebbf6cSNicholas Bellinger ret = -ENOSYS; 151ecebbf6cSNicholas Bellinger goto out_blkdev_put; 152ecebbf6cSNicholas Bellinger } 153ecebbf6cSNicholas Bellinger 1540f8087ecSMartin K. Petersen if (!strcmp(bi->profile->name, "T10-DIF-TYPE3-CRC")) { 155ecebbf6cSNicholas Bellinger dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE3_PROT; 1560f8087ecSMartin K. Petersen } else if (!strcmp(bi->profile->name, "T10-DIF-TYPE1-CRC")) { 157ecebbf6cSNicholas Bellinger dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE1_PROT; 158ecebbf6cSNicholas Bellinger } 159ecebbf6cSNicholas Bellinger 160ecebbf6cSNicholas Bellinger if (dev->dev_attrib.pi_prot_type) { 161ecebbf6cSNicholas Bellinger if (bioset_integrity_create(bs, IBLOCK_BIO_POOL_SIZE) < 0) { 162ecebbf6cSNicholas Bellinger pr_err("Unable to allocate bioset for PI\n"); 163ecebbf6cSNicholas Bellinger ret = -ENOMEM; 164ecebbf6cSNicholas Bellinger goto out_blkdev_put; 165ecebbf6cSNicholas Bellinger } 166ecebbf6cSNicholas Bellinger pr_debug("IBLOCK setup BIP bs->bio_integrity_pool: %p\n", 167f4f8154aSKent Overstreet &bs->bio_integrity_pool); 168ecebbf6cSNicholas Bellinger } 169ecebbf6cSNicholas Bellinger dev->dev_attrib.hw_pi_prot_type = dev->dev_attrib.pi_prot_type; 170ecebbf6cSNicholas Bellinger } 171ecebbf6cSNicholas Bellinger 1720fd97ccfSChristoph Hellwig return 0; 173e22a7f07SRoland Dreier 174ecebbf6cSNicholas Bellinger out_blkdev_put: 175ecebbf6cSNicholas Bellinger blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL); 1760fd97ccfSChristoph Hellwig out_free_bioset: 177a47a28b7SKent Overstreet bioset_exit(&ib_dev->ibd_bio_set); 1780fd97ccfSChristoph Hellwig out: 1790fd97ccfSChristoph Hellwig return ret; 180c66ac9dbSNicholas Bellinger } 181c66ac9dbSNicholas Bellinger 1824cc987eaSNicholas Bellinger static void iblock_dev_call_rcu(struct rcu_head *p) 1834cc987eaSNicholas Bellinger { 1844cc987eaSNicholas Bellinger struct se_device *dev = container_of(p, struct se_device, rcu_head); 1854cc987eaSNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 1864cc987eaSNicholas Bellinger 1874cc987eaSNicholas Bellinger kfree(ib_dev); 1884cc987eaSNicholas Bellinger } 1894cc987eaSNicholas Bellinger 1900fd97ccfSChristoph Hellwig static void iblock_free_device(struct se_device *dev) 191c66ac9dbSNicholas Bellinger { 19292634706SMike Christie call_rcu(&dev->rcu_head, iblock_dev_call_rcu); 19392634706SMike Christie } 19492634706SMike Christie 19592634706SMike Christie static void iblock_destroy_device(struct se_device *dev) 19692634706SMike Christie { 1970fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 198c66ac9dbSNicholas Bellinger 199bc665524SNicholas Bellinger if (ib_dev->ibd_bd != NULL) 200c66ac9dbSNicholas Bellinger blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL); 201a47a28b7SKent Overstreet bioset_exit(&ib_dev->ibd_bio_set); 202c66ac9dbSNicholas Bellinger } 203c66ac9dbSNicholas Bellinger 204c66ac9dbSNicholas Bellinger static unsigned long long iblock_emulate_read_cap_with_block_size( 205c66ac9dbSNicholas Bellinger struct se_device *dev, 206c66ac9dbSNicholas Bellinger struct block_device *bd, 207c66ac9dbSNicholas Bellinger struct request_queue *q) 208c66ac9dbSNicholas Bellinger { 209c66ac9dbSNicholas Bellinger unsigned long long blocks_long = (div_u64(i_size_read(bd->bd_inode), 210c66ac9dbSNicholas Bellinger bdev_logical_block_size(bd)) - 1); 211c66ac9dbSNicholas Bellinger u32 block_size = bdev_logical_block_size(bd); 212c66ac9dbSNicholas Bellinger 2130fd97ccfSChristoph Hellwig if (block_size == dev->dev_attrib.block_size) 214c66ac9dbSNicholas Bellinger return blocks_long; 215c66ac9dbSNicholas Bellinger 216c66ac9dbSNicholas Bellinger switch (block_size) { 217c66ac9dbSNicholas Bellinger case 4096: 2180fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 219c66ac9dbSNicholas Bellinger case 2048: 220c66ac9dbSNicholas Bellinger blocks_long <<= 1; 221c66ac9dbSNicholas Bellinger break; 222c66ac9dbSNicholas Bellinger case 1024: 223c66ac9dbSNicholas Bellinger blocks_long <<= 2; 224c66ac9dbSNicholas Bellinger break; 225c66ac9dbSNicholas Bellinger case 512: 226c66ac9dbSNicholas Bellinger blocks_long <<= 3; 227c66ac9dbSNicholas Bellinger default: 228c66ac9dbSNicholas Bellinger break; 229c66ac9dbSNicholas Bellinger } 230c66ac9dbSNicholas Bellinger break; 231c66ac9dbSNicholas Bellinger case 2048: 2320fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 233c66ac9dbSNicholas Bellinger case 4096: 234c66ac9dbSNicholas Bellinger blocks_long >>= 1; 235c66ac9dbSNicholas Bellinger break; 236c66ac9dbSNicholas Bellinger case 1024: 237c66ac9dbSNicholas Bellinger blocks_long <<= 1; 238c66ac9dbSNicholas Bellinger break; 239c66ac9dbSNicholas Bellinger case 512: 240c66ac9dbSNicholas Bellinger blocks_long <<= 2; 241c66ac9dbSNicholas Bellinger break; 242c66ac9dbSNicholas Bellinger default: 243c66ac9dbSNicholas Bellinger break; 244c66ac9dbSNicholas Bellinger } 245c66ac9dbSNicholas Bellinger break; 246c66ac9dbSNicholas Bellinger case 1024: 2470fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 248c66ac9dbSNicholas Bellinger case 4096: 249c66ac9dbSNicholas Bellinger blocks_long >>= 2; 250c66ac9dbSNicholas Bellinger break; 251c66ac9dbSNicholas Bellinger case 2048: 252c66ac9dbSNicholas Bellinger blocks_long >>= 1; 253c66ac9dbSNicholas Bellinger break; 254c66ac9dbSNicholas Bellinger case 512: 255c66ac9dbSNicholas Bellinger blocks_long <<= 1; 256c66ac9dbSNicholas Bellinger break; 257c66ac9dbSNicholas Bellinger default: 258c66ac9dbSNicholas Bellinger break; 259c66ac9dbSNicholas Bellinger } 260c66ac9dbSNicholas Bellinger break; 261c66ac9dbSNicholas Bellinger case 512: 2620fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 263c66ac9dbSNicholas Bellinger case 4096: 264c66ac9dbSNicholas Bellinger blocks_long >>= 3; 265c66ac9dbSNicholas Bellinger break; 266c66ac9dbSNicholas Bellinger case 2048: 267c66ac9dbSNicholas Bellinger blocks_long >>= 2; 268c66ac9dbSNicholas Bellinger break; 269c66ac9dbSNicholas Bellinger case 1024: 270c66ac9dbSNicholas Bellinger blocks_long >>= 1; 271c66ac9dbSNicholas Bellinger break; 272c66ac9dbSNicholas Bellinger default: 273c66ac9dbSNicholas Bellinger break; 274c66ac9dbSNicholas Bellinger } 275c66ac9dbSNicholas Bellinger break; 276c66ac9dbSNicholas Bellinger default: 277c66ac9dbSNicholas Bellinger break; 278c66ac9dbSNicholas Bellinger } 279c66ac9dbSNicholas Bellinger 280c66ac9dbSNicholas Bellinger return blocks_long; 281c66ac9dbSNicholas Bellinger } 282c66ac9dbSNicholas Bellinger 2833a41d85fSNicholas Bellinger static void iblock_complete_cmd(struct se_cmd *cmd) 2843a41d85fSNicholas Bellinger { 2853a41d85fSNicholas Bellinger struct iblock_req *ibr = cmd->priv; 2863a41d85fSNicholas Bellinger u8 status; 2873a41d85fSNicholas Bellinger 2885981c245SElena Reshetova if (!refcount_dec_and_test(&ibr->pending)) 2893a41d85fSNicholas Bellinger return; 2903a41d85fSNicholas Bellinger 2913a41d85fSNicholas Bellinger if (atomic_read(&ibr->ib_bio_err_cnt)) 2923a41d85fSNicholas Bellinger status = SAM_STAT_CHECK_CONDITION; 2933a41d85fSNicholas Bellinger else 2943a41d85fSNicholas Bellinger status = SAM_STAT_GOOD; 2953a41d85fSNicholas Bellinger 2963a41d85fSNicholas Bellinger target_complete_cmd(cmd, status); 2973a41d85fSNicholas Bellinger kfree(ibr); 2983a41d85fSNicholas Bellinger } 2993a41d85fSNicholas Bellinger 3004246a0b6SChristoph Hellwig static void iblock_bio_done(struct bio *bio) 3013a41d85fSNicholas Bellinger { 3023a41d85fSNicholas Bellinger struct se_cmd *cmd = bio->bi_private; 3033a41d85fSNicholas Bellinger struct iblock_req *ibr = cmd->priv; 3043a41d85fSNicholas Bellinger 3054e4cbee9SChristoph Hellwig if (bio->bi_status) { 3064e4cbee9SChristoph Hellwig pr_err("bio error: %p, err: %d\n", bio, bio->bi_status); 3073a41d85fSNicholas Bellinger /* 3083a41d85fSNicholas Bellinger * Bump the ib_bio_err_cnt and release bio. 3093a41d85fSNicholas Bellinger */ 3103a41d85fSNicholas Bellinger atomic_inc(&ibr->ib_bio_err_cnt); 3114e857c58SPeter Zijlstra smp_mb__after_atomic(); 3123a41d85fSNicholas Bellinger } 3133a41d85fSNicholas Bellinger 3143a41d85fSNicholas Bellinger bio_put(bio); 3153a41d85fSNicholas Bellinger 3163a41d85fSNicholas Bellinger iblock_complete_cmd(cmd); 3173a41d85fSNicholas Bellinger } 3183a41d85fSNicholas Bellinger 3193a41d85fSNicholas Bellinger static struct bio * 320e742fc32SMike Christie iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num, int op, 321e742fc32SMike Christie int op_flags) 3223a41d85fSNicholas Bellinger { 3233a41d85fSNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev); 3243a41d85fSNicholas Bellinger struct bio *bio; 3253a41d85fSNicholas Bellinger 3263a41d85fSNicholas Bellinger /* 3273a41d85fSNicholas Bellinger * Only allocate as many vector entries as the bio code allows us to, 3283a41d85fSNicholas Bellinger * we'll loop later on until we have handled the whole request. 3293a41d85fSNicholas Bellinger */ 3303a41d85fSNicholas Bellinger if (sg_num > BIO_MAX_PAGES) 3313a41d85fSNicholas Bellinger sg_num = BIO_MAX_PAGES; 3323a41d85fSNicholas Bellinger 333a47a28b7SKent Overstreet bio = bio_alloc_bioset(GFP_NOIO, sg_num, &ib_dev->ibd_bio_set); 3343a41d85fSNicholas Bellinger if (!bio) { 3353a41d85fSNicholas Bellinger pr_err("Unable to allocate memory for bio\n"); 3363a41d85fSNicholas Bellinger return NULL; 3373a41d85fSNicholas Bellinger } 3383a41d85fSNicholas Bellinger 33974d46992SChristoph Hellwig bio_set_dev(bio, ib_dev->ibd_bd); 3403a41d85fSNicholas Bellinger bio->bi_private = cmd; 3413a41d85fSNicholas Bellinger bio->bi_end_io = &iblock_bio_done; 3424f024f37SKent Overstreet bio->bi_iter.bi_sector = lba; 343e742fc32SMike Christie bio_set_op_attrs(bio, op, op_flags); 3443a41d85fSNicholas Bellinger 3453a41d85fSNicholas Bellinger return bio; 3463a41d85fSNicholas Bellinger } 3473a41d85fSNicholas Bellinger 3484e49ea4aSMike Christie static void iblock_submit_bios(struct bio_list *list) 3493a41d85fSNicholas Bellinger { 3503a41d85fSNicholas Bellinger struct blk_plug plug; 3513a41d85fSNicholas Bellinger struct bio *bio; 3523a41d85fSNicholas Bellinger 3533a41d85fSNicholas Bellinger blk_start_plug(&plug); 3543a41d85fSNicholas Bellinger while ((bio = bio_list_pop(list))) 3554e49ea4aSMike Christie submit_bio(bio); 3563a41d85fSNicholas Bellinger blk_finish_plug(&plug); 3573a41d85fSNicholas Bellinger } 3583a41d85fSNicholas Bellinger 3594246a0b6SChristoph Hellwig static void iblock_end_io_flush(struct bio *bio) 360df5fa691SChristoph Hellwig { 361df5fa691SChristoph Hellwig struct se_cmd *cmd = bio->bi_private; 362df5fa691SChristoph Hellwig 3634e4cbee9SChristoph Hellwig if (bio->bi_status) 3644e4cbee9SChristoph Hellwig pr_err("IBLOCK: cache flush failed: %d\n", bio->bi_status); 365df5fa691SChristoph Hellwig 3665787cacdSChristoph Hellwig if (cmd) { 3674e4cbee9SChristoph Hellwig if (bio->bi_status) 3685787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION); 369de103c93SChristoph Hellwig else 3705787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_GOOD); 3715787cacdSChristoph Hellwig } 3725787cacdSChristoph Hellwig 373df5fa691SChristoph Hellwig bio_put(bio); 374df5fa691SChristoph Hellwig } 375df5fa691SChristoph Hellwig 376c66ac9dbSNicholas Bellinger /* 377df5fa691SChristoph Hellwig * Implement SYCHRONIZE CACHE. Note that we can't handle lba ranges and must 378df5fa691SChristoph Hellwig * always flush the whole cache. 379c66ac9dbSNicholas Bellinger */ 380de103c93SChristoph Hellwig static sense_reason_t 381de103c93SChristoph Hellwig iblock_execute_sync_cache(struct se_cmd *cmd) 382c66ac9dbSNicholas Bellinger { 3830fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev); 384a1d8b49aSAndy Grover int immed = (cmd->t_task_cdb[1] & 0x2); 385df5fa691SChristoph Hellwig struct bio *bio; 386c66ac9dbSNicholas Bellinger 387c66ac9dbSNicholas Bellinger /* 388c66ac9dbSNicholas Bellinger * If the Immediate bit is set, queue up the GOOD response 389df5fa691SChristoph Hellwig * for this SYNCHRONIZE_CACHE op. 390c66ac9dbSNicholas Bellinger */ 391c66ac9dbSNicholas Bellinger if (immed) 3925787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_GOOD); 393c66ac9dbSNicholas Bellinger 394df5fa691SChristoph Hellwig bio = bio_alloc(GFP_KERNEL, 0); 395df5fa691SChristoph Hellwig bio->bi_end_io = iblock_end_io_flush; 39674d46992SChristoph Hellwig bio_set_dev(bio, ib_dev->ibd_bd); 39770fd7614SChristoph Hellwig bio->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH; 398c66ac9dbSNicholas Bellinger if (!immed) 399df5fa691SChristoph Hellwig bio->bi_private = cmd; 4004e49ea4aSMike Christie submit_bio(bio); 401ad67f0d9SChristoph Hellwig return 0; 402c66ac9dbSNicholas Bellinger } 403c66ac9dbSNicholas Bellinger 404de103c93SChristoph Hellwig static sense_reason_t 40562e46942SChristoph Hellwig iblock_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb) 406dbc21c5aSAsias He { 40762e46942SChristoph Hellwig struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd; 4088a9ebe71SMike Christie struct se_device *dev = cmd->se_dev; 409dbc21c5aSAsias He int ret; 410dbc21c5aSAsias He 4118a9ebe71SMike Christie ret = blkdev_issue_discard(bdev, 4128a9ebe71SMike Christie target_to_linux_sector(dev, lba), 4138a9ebe71SMike Christie target_to_linux_sector(dev, nolb), 4148a9ebe71SMike Christie GFP_KERNEL, 0); 415dbc21c5aSAsias He if (ret < 0) { 416dbc21c5aSAsias He pr_err("blkdev_issue_discard() failed: %d\n", ret); 417dbc21c5aSAsias He return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 418dbc21c5aSAsias He } 419dbc21c5aSAsias He 420dbc21c5aSAsias He return 0; 421dbc21c5aSAsias He } 422dbc21c5aSAsias He 423dbc21c5aSAsias He static sense_reason_t 4242237498fSNicholas Bellinger iblock_execute_zero_out(struct block_device *bdev, struct se_cmd *cmd) 42507b63196SMike Christie { 42607b63196SMike Christie struct se_device *dev = cmd->se_dev; 42707b63196SMike Christie struct scatterlist *sg = &cmd->t_data_sg[0]; 428f5957dadSBryant G Ly unsigned char *buf, *not_zero; 429f5957dadSBryant G Ly int ret; 43007b63196SMike Christie 4312237498fSNicholas Bellinger buf = kmap(sg_page(sg)) + sg->offset; 4322237498fSNicholas Bellinger if (!buf) 4332237498fSNicholas Bellinger return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 4342237498fSNicholas Bellinger /* 4352237498fSNicholas Bellinger * Fall back to block_execute_write_same() slow-path if 4362237498fSNicholas Bellinger * incoming WRITE_SAME payload does not contain zeros. 4372237498fSNicholas Bellinger */ 438f5957dadSBryant G Ly not_zero = memchr_inv(buf, 0x00, cmd->data_length); 4392237498fSNicholas Bellinger kunmap(sg_page(sg)); 44007b63196SMike Christie 441f5957dadSBryant G Ly if (not_zero) 4422237498fSNicholas Bellinger return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 4432237498fSNicholas Bellinger 4442237498fSNicholas Bellinger ret = blkdev_issue_zeroout(bdev, 44507b63196SMike Christie target_to_linux_sector(dev, cmd->t_task_lba), 44607b63196SMike Christie target_to_linux_sector(dev, 44707b63196SMike Christie sbc_get_write_same_sectors(cmd)), 4482237498fSNicholas Bellinger GFP_KERNEL, false); 44907b63196SMike Christie if (ret) 45007b63196SMike Christie return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 45107b63196SMike Christie 45207b63196SMike Christie target_complete_cmd(cmd, GOOD); 45307b63196SMike Christie return 0; 45407b63196SMike Christie } 45507b63196SMike Christie 45607b63196SMike Christie static sense_reason_t 457f6970ad3SNicholas Bellinger iblock_execute_write_same(struct se_cmd *cmd) 458f6970ad3SNicholas Bellinger { 45907b63196SMike Christie struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd; 460f6970ad3SNicholas Bellinger struct iblock_req *ibr; 461f6970ad3SNicholas Bellinger struct scatterlist *sg; 462f6970ad3SNicholas Bellinger struct bio *bio; 463f6970ad3SNicholas Bellinger struct bio_list list; 4648a9ebe71SMike Christie struct se_device *dev = cmd->se_dev; 4658a9ebe71SMike Christie sector_t block_lba = target_to_linux_sector(dev, cmd->t_task_lba); 4668a9ebe71SMike Christie sector_t sectors = target_to_linux_sector(dev, 4678a9ebe71SMike Christie sbc_get_write_same_sectors(cmd)); 468f6970ad3SNicholas Bellinger 469afd73f1bSNicholas Bellinger if (cmd->prot_op) { 470afd73f1bSNicholas Bellinger pr_err("WRITE_SAME: Protection information with IBLOCK" 471afd73f1bSNicholas Bellinger " backends not supported\n"); 472afd73f1bSNicholas Bellinger return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 473afd73f1bSNicholas Bellinger } 474f6970ad3SNicholas Bellinger sg = &cmd->t_data_sg[0]; 475f6970ad3SNicholas Bellinger 476f6970ad3SNicholas Bellinger if (cmd->t_data_nents > 1 || 477f6970ad3SNicholas Bellinger sg->length != cmd->se_dev->dev_attrib.block_size) { 478f6970ad3SNicholas Bellinger pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u" 479f6970ad3SNicholas Bellinger " block_size: %u\n", cmd->t_data_nents, sg->length, 480f6970ad3SNicholas Bellinger cmd->se_dev->dev_attrib.block_size); 481f6970ad3SNicholas Bellinger return TCM_INVALID_CDB_FIELD; 482f6970ad3SNicholas Bellinger } 483f6970ad3SNicholas Bellinger 4842237498fSNicholas Bellinger if (bdev_write_zeroes_sectors(bdev)) { 4852237498fSNicholas Bellinger if (!iblock_execute_zero_out(bdev, cmd)) 4862237498fSNicholas Bellinger return 0; 4872237498fSNicholas Bellinger } 48807b63196SMike Christie 489f6970ad3SNicholas Bellinger ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL); 490f6970ad3SNicholas Bellinger if (!ibr) 491f6970ad3SNicholas Bellinger goto fail; 492f6970ad3SNicholas Bellinger cmd->priv = ibr; 493f6970ad3SNicholas Bellinger 494e742fc32SMike Christie bio = iblock_get_bio(cmd, block_lba, 1, REQ_OP_WRITE, 0); 495f6970ad3SNicholas Bellinger if (!bio) 496f6970ad3SNicholas Bellinger goto fail_free_ibr; 497f6970ad3SNicholas Bellinger 498f6970ad3SNicholas Bellinger bio_list_init(&list); 499f6970ad3SNicholas Bellinger bio_list_add(&list, bio); 500f6970ad3SNicholas Bellinger 5015981c245SElena Reshetova refcount_set(&ibr->pending, 1); 502f6970ad3SNicholas Bellinger 503f6970ad3SNicholas Bellinger while (sectors) { 504f6970ad3SNicholas Bellinger while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset) 505f6970ad3SNicholas Bellinger != sg->length) { 506f6970ad3SNicholas Bellinger 507e742fc32SMike Christie bio = iblock_get_bio(cmd, block_lba, 1, REQ_OP_WRITE, 508e742fc32SMike Christie 0); 509f6970ad3SNicholas Bellinger if (!bio) 510f6970ad3SNicholas Bellinger goto fail_put_bios; 511f6970ad3SNicholas Bellinger 5125981c245SElena Reshetova refcount_inc(&ibr->pending); 513f6970ad3SNicholas Bellinger bio_list_add(&list, bio); 514f6970ad3SNicholas Bellinger } 515f6970ad3SNicholas Bellinger 516f6970ad3SNicholas Bellinger /* Always in 512 byte units for Linux/Block */ 517f6970ad3SNicholas Bellinger block_lba += sg->length >> IBLOCK_LBA_SHIFT; 518f6970ad3SNicholas Bellinger sectors -= 1; 519f6970ad3SNicholas Bellinger } 520f6970ad3SNicholas Bellinger 5214e49ea4aSMike Christie iblock_submit_bios(&list); 522f6970ad3SNicholas Bellinger return 0; 523f6970ad3SNicholas Bellinger 524f6970ad3SNicholas Bellinger fail_put_bios: 525f6970ad3SNicholas Bellinger while ((bio = bio_list_pop(&list))) 526f6970ad3SNicholas Bellinger bio_put(bio); 527f6970ad3SNicholas Bellinger fail_free_ibr: 528f6970ad3SNicholas Bellinger kfree(ibr); 529f6970ad3SNicholas Bellinger fail: 530f6970ad3SNicholas Bellinger return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 531f6970ad3SNicholas Bellinger } 532f6970ad3SNicholas Bellinger 533c66ac9dbSNicholas Bellinger enum { 53444bfd018SAndy Grover Opt_udev_path, Opt_readonly, Opt_force, Opt_err 535c66ac9dbSNicholas Bellinger }; 536c66ac9dbSNicholas Bellinger 537c66ac9dbSNicholas Bellinger static match_table_t tokens = { 538c66ac9dbSNicholas Bellinger {Opt_udev_path, "udev_path=%s"}, 53944bfd018SAndy Grover {Opt_readonly, "readonly=%d"}, 540c66ac9dbSNicholas Bellinger {Opt_force, "force=%d"}, 541c66ac9dbSNicholas Bellinger {Opt_err, NULL} 542c66ac9dbSNicholas Bellinger }; 543c66ac9dbSNicholas Bellinger 5440fd97ccfSChristoph Hellwig static ssize_t iblock_set_configfs_dev_params(struct se_device *dev, 545c66ac9dbSNicholas Bellinger const char *page, ssize_t count) 546c66ac9dbSNicholas Bellinger { 5470fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 5486d180253SJesper Juhl char *orig, *ptr, *arg_p, *opts; 549c66ac9dbSNicholas Bellinger substring_t args[MAX_OPT_ARGS]; 55021bca31cSRoland Dreier int ret = 0, token; 55144bfd018SAndy Grover unsigned long tmp_readonly; 552c66ac9dbSNicholas Bellinger 553c66ac9dbSNicholas Bellinger opts = kstrdup(page, GFP_KERNEL); 554c66ac9dbSNicholas Bellinger if (!opts) 555c66ac9dbSNicholas Bellinger return -ENOMEM; 556c66ac9dbSNicholas Bellinger 557c66ac9dbSNicholas Bellinger orig = opts; 558c66ac9dbSNicholas Bellinger 55990c161b6SSebastian Andrzej Siewior while ((ptr = strsep(&opts, ",\n")) != NULL) { 560c66ac9dbSNicholas Bellinger if (!*ptr) 561c66ac9dbSNicholas Bellinger continue; 562c66ac9dbSNicholas Bellinger 563c66ac9dbSNicholas Bellinger token = match_token(ptr, tokens, args); 564c66ac9dbSNicholas Bellinger switch (token) { 565c66ac9dbSNicholas Bellinger case Opt_udev_path: 566c66ac9dbSNicholas Bellinger if (ib_dev->ibd_bd) { 5676708bb27SAndy Grover pr_err("Unable to set udev_path= while" 568c66ac9dbSNicholas Bellinger " ib_dev->ibd_bd exists\n"); 569c66ac9dbSNicholas Bellinger ret = -EEXIST; 570c66ac9dbSNicholas Bellinger goto out; 571c66ac9dbSNicholas Bellinger } 572852b6ed1SNicholas Bellinger if (match_strlcpy(ib_dev->ibd_udev_path, &args[0], 573852b6ed1SNicholas Bellinger SE_UDEV_PATH_LEN) == 0) { 574852b6ed1SNicholas Bellinger ret = -EINVAL; 5756d180253SJesper Juhl break; 5766d180253SJesper Juhl } 5776708bb27SAndy Grover pr_debug("IBLOCK: Referencing UDEV path: %s\n", 578c66ac9dbSNicholas Bellinger ib_dev->ibd_udev_path); 579c66ac9dbSNicholas Bellinger ib_dev->ibd_flags |= IBDF_HAS_UDEV_PATH; 580c66ac9dbSNicholas Bellinger break; 58144bfd018SAndy Grover case Opt_readonly: 58244bfd018SAndy Grover arg_p = match_strdup(&args[0]); 58344bfd018SAndy Grover if (!arg_p) { 58444bfd018SAndy Grover ret = -ENOMEM; 58544bfd018SAndy Grover break; 58644bfd018SAndy Grover } 58757103d7fSJingoo Han ret = kstrtoul(arg_p, 0, &tmp_readonly); 58844bfd018SAndy Grover kfree(arg_p); 58944bfd018SAndy Grover if (ret < 0) { 59057103d7fSJingoo Han pr_err("kstrtoul() failed for" 59144bfd018SAndy Grover " readonly=\n"); 59244bfd018SAndy Grover goto out; 59344bfd018SAndy Grover } 59444bfd018SAndy Grover ib_dev->ibd_readonly = tmp_readonly; 59544bfd018SAndy Grover pr_debug("IBLOCK: readonly: %d\n", ib_dev->ibd_readonly); 59644bfd018SAndy Grover break; 597c66ac9dbSNicholas Bellinger case Opt_force: 598c66ac9dbSNicholas Bellinger break; 599c66ac9dbSNicholas Bellinger default: 600c66ac9dbSNicholas Bellinger break; 601c66ac9dbSNicholas Bellinger } 602c66ac9dbSNicholas Bellinger } 603c66ac9dbSNicholas Bellinger 604c66ac9dbSNicholas Bellinger out: 605c66ac9dbSNicholas Bellinger kfree(orig); 606c66ac9dbSNicholas Bellinger return (!ret) ? count : ret; 607c66ac9dbSNicholas Bellinger } 608c66ac9dbSNicholas Bellinger 6090fd97ccfSChristoph Hellwig static ssize_t iblock_show_configfs_dev_params(struct se_device *dev, char *b) 610c66ac9dbSNicholas Bellinger { 6110fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 6120fd97ccfSChristoph Hellwig struct block_device *bd = ib_dev->ibd_bd; 613c66ac9dbSNicholas Bellinger char buf[BDEVNAME_SIZE]; 614c66ac9dbSNicholas Bellinger ssize_t bl = 0; 615c66ac9dbSNicholas Bellinger 616c66ac9dbSNicholas Bellinger if (bd) 617c66ac9dbSNicholas Bellinger bl += sprintf(b + bl, "iBlock device: %s", 618c66ac9dbSNicholas Bellinger bdevname(bd, buf)); 6190fd97ccfSChristoph Hellwig if (ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH) 62044bfd018SAndy Grover bl += sprintf(b + bl, " UDEV PATH: %s", 6210fd97ccfSChristoph Hellwig ib_dev->ibd_udev_path); 6220fd97ccfSChristoph Hellwig bl += sprintf(b + bl, " readonly: %d\n", ib_dev->ibd_readonly); 623c66ac9dbSNicholas Bellinger 624c66ac9dbSNicholas Bellinger bl += sprintf(b + bl, " "); 625c66ac9dbSNicholas Bellinger if (bd) { 626c66ac9dbSNicholas Bellinger bl += sprintf(b + bl, "Major: %d Minor: %d %s\n", 62721bca31cSRoland Dreier MAJOR(bd->bd_dev), MINOR(bd->bd_dev), (!bd->bd_contains) ? 6280fd97ccfSChristoph Hellwig "" : (bd->bd_holder == ib_dev) ? 629c66ac9dbSNicholas Bellinger "CLAIMED: IBLOCK" : "CLAIMED: OS"); 630c66ac9dbSNicholas Bellinger } else { 63121bca31cSRoland Dreier bl += sprintf(b + bl, "Major: 0 Minor: 0\n"); 632c66ac9dbSNicholas Bellinger } 633c66ac9dbSNicholas Bellinger 634c66ac9dbSNicholas Bellinger return bl; 635c66ac9dbSNicholas Bellinger } 636c66ac9dbSNicholas Bellinger 637ecebbf6cSNicholas Bellinger static int 638ecebbf6cSNicholas Bellinger iblock_alloc_bip(struct se_cmd *cmd, struct bio *bio) 639ecebbf6cSNicholas Bellinger { 640ecebbf6cSNicholas Bellinger struct se_device *dev = cmd->se_dev; 641ecebbf6cSNicholas Bellinger struct blk_integrity *bi; 642ecebbf6cSNicholas Bellinger struct bio_integrity_payload *bip; 643ecebbf6cSNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 644ecebbf6cSNicholas Bellinger struct scatterlist *sg; 645ecebbf6cSNicholas Bellinger int i, rc; 646ecebbf6cSNicholas Bellinger 647ecebbf6cSNicholas Bellinger bi = bdev_get_integrity(ib_dev->ibd_bd); 648ecebbf6cSNicholas Bellinger if (!bi) { 649ecebbf6cSNicholas Bellinger pr_err("Unable to locate bio_integrity\n"); 650ecebbf6cSNicholas Bellinger return -ENODEV; 651ecebbf6cSNicholas Bellinger } 652ecebbf6cSNicholas Bellinger 653ecebbf6cSNicholas Bellinger bip = bio_integrity_alloc(bio, GFP_NOIO, cmd->t_prot_nents); 65406c1e390SKeith Busch if (IS_ERR(bip)) { 655ecebbf6cSNicholas Bellinger pr_err("Unable to allocate bio_integrity_payload\n"); 65606c1e390SKeith Busch return PTR_ERR(bip); 657ecebbf6cSNicholas Bellinger } 658ecebbf6cSNicholas Bellinger 6594e13c5d0SLinus Torvalds bip->bip_iter.bi_size = (cmd->data_length / dev->dev_attrib.block_size) * 660ecebbf6cSNicholas Bellinger dev->prot_length; 6614e13c5d0SLinus Torvalds bip->bip_iter.bi_sector = bio->bi_iter.bi_sector; 662ecebbf6cSNicholas Bellinger 6634e13c5d0SLinus Torvalds pr_debug("IBLOCK BIP Size: %u Sector: %llu\n", bip->bip_iter.bi_size, 6644e13c5d0SLinus Torvalds (unsigned long long)bip->bip_iter.bi_sector); 665ecebbf6cSNicholas Bellinger 666ecebbf6cSNicholas Bellinger for_each_sg(cmd->t_prot_sg, sg, cmd->t_prot_nents, i) { 667ecebbf6cSNicholas Bellinger 668ecebbf6cSNicholas Bellinger rc = bio_integrity_add_page(bio, sg_page(sg), sg->length, 669ecebbf6cSNicholas Bellinger sg->offset); 670ecebbf6cSNicholas Bellinger if (rc != sg->length) { 671ecebbf6cSNicholas Bellinger pr_err("bio_integrity_add_page() failed; %d\n", rc); 672ecebbf6cSNicholas Bellinger return -ENOMEM; 673ecebbf6cSNicholas Bellinger } 674ecebbf6cSNicholas Bellinger 675ecebbf6cSNicholas Bellinger pr_debug("Added bio integrity page: %p length: %d offset; %d\n", 676ecebbf6cSNicholas Bellinger sg_page(sg), sg->length, sg->offset); 677ecebbf6cSNicholas Bellinger } 678ecebbf6cSNicholas Bellinger 679ecebbf6cSNicholas Bellinger return 0; 680ecebbf6cSNicholas Bellinger } 681ecebbf6cSNicholas Bellinger 682de103c93SChristoph Hellwig static sense_reason_t 683a82a9538SNicholas Bellinger iblock_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents, 684a82a9538SNicholas Bellinger enum dma_data_direction data_direction) 685c66ac9dbSNicholas Bellinger { 6865951146dSAndy Grover struct se_device *dev = cmd->se_dev; 6878a9ebe71SMike Christie sector_t block_lba = target_to_linux_sector(dev, cmd->t_task_lba); 6885787cacdSChristoph Hellwig struct iblock_req *ibr; 689ecebbf6cSNicholas Bellinger struct bio *bio, *bio_start; 690dbbf3e94SChristoph Hellwig struct bio_list list; 691c66ac9dbSNicholas Bellinger struct scatterlist *sg; 6925787cacdSChristoph Hellwig u32 sg_num = sgl_nents; 693d5b4a21bSChristoph Hellwig unsigned bio_cnt; 694e742fc32SMike Christie int i, op, op_flags = 0; 695dbbf3e94SChristoph Hellwig 6965787cacdSChristoph Hellwig if (data_direction == DMA_TO_DEVICE) { 697d0c8b259SNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 698d0c8b259SNicholas Bellinger struct request_queue *q = bdev_get_queue(ib_dev->ibd_bd); 699dbbf3e94SChristoph Hellwig /* 70070fd7614SChristoph Hellwig * Force writethrough using REQ_FUA if a volatile write cache 701d0c8b259SNicholas Bellinger * is not enabled, or if initiator set the Force Unit Access bit. 702dbbf3e94SChristoph Hellwig */ 703e742fc32SMike Christie op = REQ_OP_WRITE; 704c888a8f9SJens Axboe if (test_bit(QUEUE_FLAG_FUA, &q->queue_flags)) { 705d0c8b259SNicholas Bellinger if (cmd->se_cmd_flags & SCF_FUA) 70670fd7614SChristoph Hellwig op_flags = REQ_FUA; 707c888a8f9SJens Axboe else if (!test_bit(QUEUE_FLAG_WC, &q->queue_flags)) 70870fd7614SChristoph Hellwig op_flags = REQ_FUA; 709d0c8b259SNicholas Bellinger } 710dbbf3e94SChristoph Hellwig } else { 711e742fc32SMike Christie op = REQ_OP_READ; 712dbbf3e94SChristoph Hellwig } 713dbbf3e94SChristoph Hellwig 7145787cacdSChristoph Hellwig ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL); 7155787cacdSChristoph Hellwig if (!ibr) 7165787cacdSChristoph Hellwig goto fail; 7175787cacdSChristoph Hellwig cmd->priv = ibr; 7185787cacdSChristoph Hellwig 719e0de4457SPaolo Bonzini if (!sgl_nents) { 7205981c245SElena Reshetova refcount_set(&ibr->pending, 1); 721e0de4457SPaolo Bonzini iblock_complete_cmd(cmd); 722e0de4457SPaolo Bonzini return 0; 723e0de4457SPaolo Bonzini } 724e0de4457SPaolo Bonzini 725e742fc32SMike Christie bio = iblock_get_bio(cmd, block_lba, sgl_nents, op, op_flags); 7265787cacdSChristoph Hellwig if (!bio) 7275787cacdSChristoph Hellwig goto fail_free_ibr; 728c66ac9dbSNicholas Bellinger 729ecebbf6cSNicholas Bellinger bio_start = bio; 730dbbf3e94SChristoph Hellwig bio_list_init(&list); 731dbbf3e94SChristoph Hellwig bio_list_add(&list, bio); 7325787cacdSChristoph Hellwig 7335981c245SElena Reshetova refcount_set(&ibr->pending, 2); 734d5b4a21bSChristoph Hellwig bio_cnt = 1; 735dbbf3e94SChristoph Hellwig 7365787cacdSChristoph Hellwig for_each_sg(sgl, sg, sgl_nents, i) { 737dbbf3e94SChristoph Hellwig /* 738dbbf3e94SChristoph Hellwig * XXX: if the length the device accepts is shorter than the 739dbbf3e94SChristoph Hellwig * length of the S/G list entry this will cause and 740dbbf3e94SChristoph Hellwig * endless loop. Better hope no driver uses huge pages. 741dbbf3e94SChristoph Hellwig */ 742dbbf3e94SChristoph Hellwig while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset) 743dbbf3e94SChristoph Hellwig != sg->length) { 744d5b4a21bSChristoph Hellwig if (bio_cnt >= IBLOCK_MAX_BIO_PER_TASK) { 7454e49ea4aSMike Christie iblock_submit_bios(&list); 746d5b4a21bSChristoph Hellwig bio_cnt = 0; 747d5b4a21bSChristoph Hellwig } 748d5b4a21bSChristoph Hellwig 749e742fc32SMike Christie bio = iblock_get_bio(cmd, block_lba, sg_num, op, 750e742fc32SMike Christie op_flags); 7516708bb27SAndy Grover if (!bio) 7525787cacdSChristoph Hellwig goto fail_put_bios; 7535787cacdSChristoph Hellwig 7545981c245SElena Reshetova refcount_inc(&ibr->pending); 755dbbf3e94SChristoph Hellwig bio_list_add(&list, bio); 756d5b4a21bSChristoph Hellwig bio_cnt++; 757c66ac9dbSNicholas Bellinger } 758dbbf3e94SChristoph Hellwig 759c66ac9dbSNicholas Bellinger /* Always in 512 byte units for Linux/Block */ 760c66ac9dbSNicholas Bellinger block_lba += sg->length >> IBLOCK_LBA_SHIFT; 761c66ac9dbSNicholas Bellinger sg_num--; 762c66ac9dbSNicholas Bellinger } 763c66ac9dbSNicholas Bellinger 7646f16ec43SNicholas Bellinger if (cmd->prot_type && dev->dev_attrib.pi_prot_type) { 765ecebbf6cSNicholas Bellinger int rc = iblock_alloc_bip(cmd, bio_start); 766ecebbf6cSNicholas Bellinger if (rc) 767ecebbf6cSNicholas Bellinger goto fail_put_bios; 768ecebbf6cSNicholas Bellinger } 769ecebbf6cSNicholas Bellinger 7704e49ea4aSMike Christie iblock_submit_bios(&list); 7715787cacdSChristoph Hellwig iblock_complete_cmd(cmd); 77203e98c9eSNicholas Bellinger return 0; 773dbbf3e94SChristoph Hellwig 7745787cacdSChristoph Hellwig fail_put_bios: 775dbbf3e94SChristoph Hellwig while ((bio = bio_list_pop(&list))) 776c66ac9dbSNicholas Bellinger bio_put(bio); 7775787cacdSChristoph Hellwig fail_free_ibr: 7785787cacdSChristoph Hellwig kfree(ibr); 7795787cacdSChristoph Hellwig fail: 780de103c93SChristoph Hellwig return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 781c66ac9dbSNicholas Bellinger } 782c66ac9dbSNicholas Bellinger 783c66ac9dbSNicholas Bellinger static sector_t iblock_get_blocks(struct se_device *dev) 784c66ac9dbSNicholas Bellinger { 7850fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 7860fd97ccfSChristoph Hellwig struct block_device *bd = ib_dev->ibd_bd; 787c66ac9dbSNicholas Bellinger struct request_queue *q = bdev_get_queue(bd); 788c66ac9dbSNicholas Bellinger 789c66ac9dbSNicholas Bellinger return iblock_emulate_read_cap_with_block_size(dev, bd, q); 790c66ac9dbSNicholas Bellinger } 791c66ac9dbSNicholas Bellinger 7927f7caf6aSAndy Grover static sector_t iblock_get_alignment_offset_lbas(struct se_device *dev) 7937f7caf6aSAndy Grover { 7947f7caf6aSAndy Grover struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 7957f7caf6aSAndy Grover struct block_device *bd = ib_dev->ibd_bd; 7967f7caf6aSAndy Grover int ret; 7977f7caf6aSAndy Grover 7987f7caf6aSAndy Grover ret = bdev_alignment_offset(bd); 7997f7caf6aSAndy Grover if (ret == -1) 8007f7caf6aSAndy Grover return 0; 8017f7caf6aSAndy Grover 8027f7caf6aSAndy Grover /* convert offset-bytes to offset-lbas */ 8037f7caf6aSAndy Grover return ret / bdev_logical_block_size(bd); 8047f7caf6aSAndy Grover } 8057f7caf6aSAndy Grover 8067f7caf6aSAndy Grover static unsigned int iblock_get_lbppbe(struct se_device *dev) 8077f7caf6aSAndy Grover { 8087f7caf6aSAndy Grover struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 8097f7caf6aSAndy Grover struct block_device *bd = ib_dev->ibd_bd; 8107f7caf6aSAndy Grover int logs_per_phys = bdev_physical_block_size(bd) / bdev_logical_block_size(bd); 8117f7caf6aSAndy Grover 8127f7caf6aSAndy Grover return ilog2(logs_per_phys); 8137f7caf6aSAndy Grover } 8147f7caf6aSAndy Grover 8157f7caf6aSAndy Grover static unsigned int iblock_get_io_min(struct se_device *dev) 8167f7caf6aSAndy Grover { 8177f7caf6aSAndy Grover struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 8187f7caf6aSAndy Grover struct block_device *bd = ib_dev->ibd_bd; 8197f7caf6aSAndy Grover 8207f7caf6aSAndy Grover return bdev_io_min(bd); 8217f7caf6aSAndy Grover } 8227f7caf6aSAndy Grover 8237f7caf6aSAndy Grover static unsigned int iblock_get_io_opt(struct se_device *dev) 8247f7caf6aSAndy Grover { 8257f7caf6aSAndy Grover struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 8267f7caf6aSAndy Grover struct block_device *bd = ib_dev->ibd_bd; 8277f7caf6aSAndy Grover 8287f7caf6aSAndy Grover return bdev_io_opt(bd); 8297f7caf6aSAndy Grover } 8307f7caf6aSAndy Grover 8319e999a6cSChristoph Hellwig static struct sbc_ops iblock_sbc_ops = { 8320c2ad7d1SChristoph Hellwig .execute_rw = iblock_execute_rw, 833ad67f0d9SChristoph Hellwig .execute_sync_cache = iblock_execute_sync_cache, 8346f974e8cSChristoph Hellwig .execute_write_same = iblock_execute_write_same, 83514150a6bSChristoph Hellwig .execute_unmap = iblock_execute_unmap, 8360c2ad7d1SChristoph Hellwig }; 8370c2ad7d1SChristoph Hellwig 838de103c93SChristoph Hellwig static sense_reason_t 839de103c93SChristoph Hellwig iblock_parse_cdb(struct se_cmd *cmd) 8400c2ad7d1SChristoph Hellwig { 8419e999a6cSChristoph Hellwig return sbc_parse_cdb(cmd, &iblock_sbc_ops); 8420c2ad7d1SChristoph Hellwig } 8430c2ad7d1SChristoph Hellwig 844452e2010SRashika Kheria static bool iblock_get_write_cache(struct se_device *dev) 845d0c8b259SNicholas Bellinger { 846d0c8b259SNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 847d0c8b259SNicholas Bellinger struct block_device *bd = ib_dev->ibd_bd; 848d0c8b259SNicholas Bellinger struct request_queue *q = bdev_get_queue(bd); 849d0c8b259SNicholas Bellinger 850c888a8f9SJens Axboe return test_bit(QUEUE_FLAG_WC, &q->queue_flags); 851d0c8b259SNicholas Bellinger } 852d0c8b259SNicholas Bellinger 8530a06d430SChristoph Hellwig static const struct target_backend_ops iblock_ops = { 854c66ac9dbSNicholas Bellinger .name = "iblock", 8550fd97ccfSChristoph Hellwig .inquiry_prod = "IBLOCK", 8560fd97ccfSChristoph Hellwig .inquiry_rev = IBLOCK_VERSION, 857c66ac9dbSNicholas Bellinger .owner = THIS_MODULE, 858c66ac9dbSNicholas Bellinger .attach_hba = iblock_attach_hba, 859c66ac9dbSNicholas Bellinger .detach_hba = iblock_detach_hba, 8600fd97ccfSChristoph Hellwig .alloc_device = iblock_alloc_device, 8610fd97ccfSChristoph Hellwig .configure_device = iblock_configure_device, 86292634706SMike Christie .destroy_device = iblock_destroy_device, 863c66ac9dbSNicholas Bellinger .free_device = iblock_free_device, 8640c2ad7d1SChristoph Hellwig .parse_cdb = iblock_parse_cdb, 865c66ac9dbSNicholas Bellinger .set_configfs_dev_params = iblock_set_configfs_dev_params, 866c66ac9dbSNicholas Bellinger .show_configfs_dev_params = iblock_show_configfs_dev_params, 8676f23ac8aSChristoph Hellwig .get_device_type = sbc_get_device_type, 868c66ac9dbSNicholas Bellinger .get_blocks = iblock_get_blocks, 8697f7caf6aSAndy Grover .get_alignment_offset_lbas = iblock_get_alignment_offset_lbas, 8707f7caf6aSAndy Grover .get_lbppbe = iblock_get_lbppbe, 8717f7caf6aSAndy Grover .get_io_min = iblock_get_io_min, 8727f7caf6aSAndy Grover .get_io_opt = iblock_get_io_opt, 873d0c8b259SNicholas Bellinger .get_write_cache = iblock_get_write_cache, 8745873c4d1SChristoph Hellwig .tb_dev_attrib_attrs = sbc_attrib_attrs, 875c66ac9dbSNicholas Bellinger }; 876c66ac9dbSNicholas Bellinger 877c66ac9dbSNicholas Bellinger static int __init iblock_module_init(void) 878c66ac9dbSNicholas Bellinger { 8790a06d430SChristoph Hellwig return transport_backend_register(&iblock_ops); 880c66ac9dbSNicholas Bellinger } 881c66ac9dbSNicholas Bellinger 88263b91d5aSAsias He static void __exit iblock_module_exit(void) 883c66ac9dbSNicholas Bellinger { 8840a06d430SChristoph Hellwig target_backend_unregister(&iblock_ops); 885c66ac9dbSNicholas Bellinger } 886c66ac9dbSNicholas Bellinger 887c66ac9dbSNicholas Bellinger MODULE_DESCRIPTION("TCM IBLOCK subsystem plugin"); 888c66ac9dbSNicholas Bellinger MODULE_AUTHOR("nab@Linux-iSCSI.org"); 889c66ac9dbSNicholas Bellinger MODULE_LICENSE("GPL"); 890c66ac9dbSNicholas Bellinger 891c66ac9dbSNicholas Bellinger module_init(iblock_module_init); 892c66ac9dbSNicholas Bellinger module_exit(iblock_module_exit); 893