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 97011067b0SNeilBrown ib_dev->ibd_bio_set = bioset_create(IBLOCK_BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS); 986708bb27SAndy Grover if (!ib_dev->ibd_bio_set) { 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) { 144ecebbf6cSNicholas Bellinger 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", 167ecebbf6cSNicholas Bellinger 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: 177c66ac9dbSNicholas Bellinger bioset_free(ib_dev->ibd_bio_set); 178c66ac9dbSNicholas Bellinger ib_dev->ibd_bio_set = NULL; 1790fd97ccfSChristoph Hellwig out: 1800fd97ccfSChristoph Hellwig return ret; 181c66ac9dbSNicholas Bellinger } 182c66ac9dbSNicholas Bellinger 1834cc987eaSNicholas Bellinger static void iblock_dev_call_rcu(struct rcu_head *p) 1844cc987eaSNicholas Bellinger { 1854cc987eaSNicholas Bellinger struct se_device *dev = container_of(p, struct se_device, rcu_head); 1864cc987eaSNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 1874cc987eaSNicholas Bellinger 1884cc987eaSNicholas Bellinger kfree(ib_dev); 1894cc987eaSNicholas Bellinger } 1904cc987eaSNicholas Bellinger 1910fd97ccfSChristoph Hellwig static void iblock_free_device(struct se_device *dev) 192c66ac9dbSNicholas Bellinger { 19392634706SMike Christie call_rcu(&dev->rcu_head, iblock_dev_call_rcu); 19492634706SMike Christie } 19592634706SMike Christie 19692634706SMike Christie static void iblock_destroy_device(struct se_device *dev) 19792634706SMike Christie { 1980fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 199c66ac9dbSNicholas Bellinger 200bc665524SNicholas Bellinger if (ib_dev->ibd_bd != NULL) 201c66ac9dbSNicholas Bellinger blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL); 202d84287bcSNicholas Bellinger if (ib_dev->ibd_bio_set != NULL) 203c66ac9dbSNicholas Bellinger bioset_free(ib_dev->ibd_bio_set); 204c66ac9dbSNicholas Bellinger } 205c66ac9dbSNicholas Bellinger 206c66ac9dbSNicholas Bellinger static unsigned long long iblock_emulate_read_cap_with_block_size( 207c66ac9dbSNicholas Bellinger struct se_device *dev, 208c66ac9dbSNicholas Bellinger struct block_device *bd, 209c66ac9dbSNicholas Bellinger struct request_queue *q) 210c66ac9dbSNicholas Bellinger { 211c66ac9dbSNicholas Bellinger unsigned long long blocks_long = (div_u64(i_size_read(bd->bd_inode), 212c66ac9dbSNicholas Bellinger bdev_logical_block_size(bd)) - 1); 213c66ac9dbSNicholas Bellinger u32 block_size = bdev_logical_block_size(bd); 214c66ac9dbSNicholas Bellinger 2150fd97ccfSChristoph Hellwig if (block_size == dev->dev_attrib.block_size) 216c66ac9dbSNicholas Bellinger return blocks_long; 217c66ac9dbSNicholas Bellinger 218c66ac9dbSNicholas Bellinger switch (block_size) { 219c66ac9dbSNicholas Bellinger case 4096: 2200fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 221c66ac9dbSNicholas Bellinger case 2048: 222c66ac9dbSNicholas Bellinger blocks_long <<= 1; 223c66ac9dbSNicholas Bellinger break; 224c66ac9dbSNicholas Bellinger case 1024: 225c66ac9dbSNicholas Bellinger blocks_long <<= 2; 226c66ac9dbSNicholas Bellinger break; 227c66ac9dbSNicholas Bellinger case 512: 228c66ac9dbSNicholas Bellinger blocks_long <<= 3; 229c66ac9dbSNicholas Bellinger default: 230c66ac9dbSNicholas Bellinger break; 231c66ac9dbSNicholas Bellinger } 232c66ac9dbSNicholas Bellinger break; 233c66ac9dbSNicholas Bellinger case 2048: 2340fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 235c66ac9dbSNicholas Bellinger case 4096: 236c66ac9dbSNicholas Bellinger blocks_long >>= 1; 237c66ac9dbSNicholas Bellinger break; 238c66ac9dbSNicholas Bellinger case 1024: 239c66ac9dbSNicholas Bellinger blocks_long <<= 1; 240c66ac9dbSNicholas Bellinger break; 241c66ac9dbSNicholas Bellinger case 512: 242c66ac9dbSNicholas Bellinger blocks_long <<= 2; 243c66ac9dbSNicholas Bellinger break; 244c66ac9dbSNicholas Bellinger default: 245c66ac9dbSNicholas Bellinger break; 246c66ac9dbSNicholas Bellinger } 247c66ac9dbSNicholas Bellinger break; 248c66ac9dbSNicholas Bellinger case 1024: 2490fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 250c66ac9dbSNicholas Bellinger case 4096: 251c66ac9dbSNicholas Bellinger blocks_long >>= 2; 252c66ac9dbSNicholas Bellinger break; 253c66ac9dbSNicholas Bellinger case 2048: 254c66ac9dbSNicholas Bellinger blocks_long >>= 1; 255c66ac9dbSNicholas Bellinger break; 256c66ac9dbSNicholas Bellinger case 512: 257c66ac9dbSNicholas Bellinger blocks_long <<= 1; 258c66ac9dbSNicholas Bellinger break; 259c66ac9dbSNicholas Bellinger default: 260c66ac9dbSNicholas Bellinger break; 261c66ac9dbSNicholas Bellinger } 262c66ac9dbSNicholas Bellinger break; 263c66ac9dbSNicholas Bellinger case 512: 2640fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 265c66ac9dbSNicholas Bellinger case 4096: 266c66ac9dbSNicholas Bellinger blocks_long >>= 3; 267c66ac9dbSNicholas Bellinger break; 268c66ac9dbSNicholas Bellinger case 2048: 269c66ac9dbSNicholas Bellinger blocks_long >>= 2; 270c66ac9dbSNicholas Bellinger break; 271c66ac9dbSNicholas Bellinger case 1024: 272c66ac9dbSNicholas Bellinger blocks_long >>= 1; 273c66ac9dbSNicholas Bellinger break; 274c66ac9dbSNicholas Bellinger default: 275c66ac9dbSNicholas Bellinger break; 276c66ac9dbSNicholas Bellinger } 277c66ac9dbSNicholas Bellinger break; 278c66ac9dbSNicholas Bellinger default: 279c66ac9dbSNicholas Bellinger break; 280c66ac9dbSNicholas Bellinger } 281c66ac9dbSNicholas Bellinger 282c66ac9dbSNicholas Bellinger return blocks_long; 283c66ac9dbSNicholas Bellinger } 284c66ac9dbSNicholas Bellinger 2853a41d85fSNicholas Bellinger static void iblock_complete_cmd(struct se_cmd *cmd) 2863a41d85fSNicholas Bellinger { 2873a41d85fSNicholas Bellinger struct iblock_req *ibr = cmd->priv; 2883a41d85fSNicholas Bellinger u8 status; 2893a41d85fSNicholas Bellinger 2905981c245SElena Reshetova if (!refcount_dec_and_test(&ibr->pending)) 2913a41d85fSNicholas Bellinger return; 2923a41d85fSNicholas Bellinger 2933a41d85fSNicholas Bellinger if (atomic_read(&ibr->ib_bio_err_cnt)) 2943a41d85fSNicholas Bellinger status = SAM_STAT_CHECK_CONDITION; 2953a41d85fSNicholas Bellinger else 2963a41d85fSNicholas Bellinger status = SAM_STAT_GOOD; 2973a41d85fSNicholas Bellinger 2983a41d85fSNicholas Bellinger target_complete_cmd(cmd, status); 2993a41d85fSNicholas Bellinger kfree(ibr); 3003a41d85fSNicholas Bellinger } 3013a41d85fSNicholas Bellinger 3024246a0b6SChristoph Hellwig static void iblock_bio_done(struct bio *bio) 3033a41d85fSNicholas Bellinger { 3043a41d85fSNicholas Bellinger struct se_cmd *cmd = bio->bi_private; 3053a41d85fSNicholas Bellinger struct iblock_req *ibr = cmd->priv; 3063a41d85fSNicholas Bellinger 3074e4cbee9SChristoph Hellwig if (bio->bi_status) { 3084e4cbee9SChristoph Hellwig pr_err("bio error: %p, err: %d\n", bio, bio->bi_status); 3093a41d85fSNicholas Bellinger /* 3103a41d85fSNicholas Bellinger * Bump the ib_bio_err_cnt and release bio. 3113a41d85fSNicholas Bellinger */ 3123a41d85fSNicholas Bellinger atomic_inc(&ibr->ib_bio_err_cnt); 3134e857c58SPeter Zijlstra smp_mb__after_atomic(); 3143a41d85fSNicholas Bellinger } 3153a41d85fSNicholas Bellinger 3163a41d85fSNicholas Bellinger bio_put(bio); 3173a41d85fSNicholas Bellinger 3183a41d85fSNicholas Bellinger iblock_complete_cmd(cmd); 3193a41d85fSNicholas Bellinger } 3203a41d85fSNicholas Bellinger 3213a41d85fSNicholas Bellinger static struct bio * 322e742fc32SMike Christie iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num, int op, 323e742fc32SMike Christie int op_flags) 3243a41d85fSNicholas Bellinger { 3253a41d85fSNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev); 3263a41d85fSNicholas Bellinger struct bio *bio; 3273a41d85fSNicholas Bellinger 3283a41d85fSNicholas Bellinger /* 3293a41d85fSNicholas Bellinger * Only allocate as many vector entries as the bio code allows us to, 3303a41d85fSNicholas Bellinger * we'll loop later on until we have handled the whole request. 3313a41d85fSNicholas Bellinger */ 3323a41d85fSNicholas Bellinger if (sg_num > BIO_MAX_PAGES) 3333a41d85fSNicholas Bellinger sg_num = BIO_MAX_PAGES; 3343a41d85fSNicholas Bellinger 3353a41d85fSNicholas Bellinger bio = bio_alloc_bioset(GFP_NOIO, sg_num, ib_dev->ibd_bio_set); 3363a41d85fSNicholas Bellinger if (!bio) { 3373a41d85fSNicholas Bellinger pr_err("Unable to allocate memory for bio\n"); 3383a41d85fSNicholas Bellinger return NULL; 3393a41d85fSNicholas Bellinger } 3403a41d85fSNicholas Bellinger 34174d46992SChristoph Hellwig bio_set_dev(bio, ib_dev->ibd_bd); 3423a41d85fSNicholas Bellinger bio->bi_private = cmd; 3433a41d85fSNicholas Bellinger bio->bi_end_io = &iblock_bio_done; 3444f024f37SKent Overstreet bio->bi_iter.bi_sector = lba; 345e742fc32SMike Christie bio_set_op_attrs(bio, op, op_flags); 3463a41d85fSNicholas Bellinger 3473a41d85fSNicholas Bellinger return bio; 3483a41d85fSNicholas Bellinger } 3493a41d85fSNicholas Bellinger 3504e49ea4aSMike Christie static void iblock_submit_bios(struct bio_list *list) 3513a41d85fSNicholas Bellinger { 3523a41d85fSNicholas Bellinger struct blk_plug plug; 3533a41d85fSNicholas Bellinger struct bio *bio; 3543a41d85fSNicholas Bellinger 3553a41d85fSNicholas Bellinger blk_start_plug(&plug); 3563a41d85fSNicholas Bellinger while ((bio = bio_list_pop(list))) 3574e49ea4aSMike Christie submit_bio(bio); 3583a41d85fSNicholas Bellinger blk_finish_plug(&plug); 3593a41d85fSNicholas Bellinger } 3603a41d85fSNicholas Bellinger 3614246a0b6SChristoph Hellwig static void iblock_end_io_flush(struct bio *bio) 362df5fa691SChristoph Hellwig { 363df5fa691SChristoph Hellwig struct se_cmd *cmd = bio->bi_private; 364df5fa691SChristoph Hellwig 3654e4cbee9SChristoph Hellwig if (bio->bi_status) 3664e4cbee9SChristoph Hellwig pr_err("IBLOCK: cache flush failed: %d\n", bio->bi_status); 367df5fa691SChristoph Hellwig 3685787cacdSChristoph Hellwig if (cmd) { 3694e4cbee9SChristoph Hellwig if (bio->bi_status) 3705787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION); 371de103c93SChristoph Hellwig else 3725787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_GOOD); 3735787cacdSChristoph Hellwig } 3745787cacdSChristoph Hellwig 375df5fa691SChristoph Hellwig bio_put(bio); 376df5fa691SChristoph Hellwig } 377df5fa691SChristoph Hellwig 378c66ac9dbSNicholas Bellinger /* 379df5fa691SChristoph Hellwig * Implement SYCHRONIZE CACHE. Note that we can't handle lba ranges and must 380df5fa691SChristoph Hellwig * always flush the whole cache. 381c66ac9dbSNicholas Bellinger */ 382de103c93SChristoph Hellwig static sense_reason_t 383de103c93SChristoph Hellwig iblock_execute_sync_cache(struct se_cmd *cmd) 384c66ac9dbSNicholas Bellinger { 3850fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev); 386a1d8b49aSAndy Grover int immed = (cmd->t_task_cdb[1] & 0x2); 387df5fa691SChristoph Hellwig struct bio *bio; 388c66ac9dbSNicholas Bellinger 389c66ac9dbSNicholas Bellinger /* 390c66ac9dbSNicholas Bellinger * If the Immediate bit is set, queue up the GOOD response 391df5fa691SChristoph Hellwig * for this SYNCHRONIZE_CACHE op. 392c66ac9dbSNicholas Bellinger */ 393c66ac9dbSNicholas Bellinger if (immed) 3945787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_GOOD); 395c66ac9dbSNicholas Bellinger 396df5fa691SChristoph Hellwig bio = bio_alloc(GFP_KERNEL, 0); 397df5fa691SChristoph Hellwig bio->bi_end_io = iblock_end_io_flush; 39874d46992SChristoph Hellwig bio_set_dev(bio, ib_dev->ibd_bd); 39970fd7614SChristoph Hellwig bio->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH; 400c66ac9dbSNicholas Bellinger if (!immed) 401df5fa691SChristoph Hellwig bio->bi_private = cmd; 4024e49ea4aSMike Christie submit_bio(bio); 403ad67f0d9SChristoph Hellwig return 0; 404c66ac9dbSNicholas Bellinger } 405c66ac9dbSNicholas Bellinger 406de103c93SChristoph Hellwig static sense_reason_t 40762e46942SChristoph Hellwig iblock_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb) 408dbc21c5aSAsias He { 40962e46942SChristoph Hellwig struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd; 4108a9ebe71SMike Christie struct se_device *dev = cmd->se_dev; 411dbc21c5aSAsias He int ret; 412dbc21c5aSAsias He 4138a9ebe71SMike Christie ret = blkdev_issue_discard(bdev, 4148a9ebe71SMike Christie target_to_linux_sector(dev, lba), 4158a9ebe71SMike Christie target_to_linux_sector(dev, nolb), 4168a9ebe71SMike Christie GFP_KERNEL, 0); 417dbc21c5aSAsias He if (ret < 0) { 418dbc21c5aSAsias He pr_err("blkdev_issue_discard() failed: %d\n", ret); 419dbc21c5aSAsias He return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 420dbc21c5aSAsias He } 421dbc21c5aSAsias He 422dbc21c5aSAsias He return 0; 423dbc21c5aSAsias He } 424dbc21c5aSAsias He 425dbc21c5aSAsias He static sense_reason_t 4262237498fSNicholas Bellinger iblock_execute_zero_out(struct block_device *bdev, struct se_cmd *cmd) 42707b63196SMike Christie { 42807b63196SMike Christie struct se_device *dev = cmd->se_dev; 42907b63196SMike Christie struct scatterlist *sg = &cmd->t_data_sg[0]; 430f5957dadSBryant G Ly unsigned char *buf, *not_zero; 431f5957dadSBryant G Ly int ret; 43207b63196SMike Christie 4332237498fSNicholas Bellinger buf = kmap(sg_page(sg)) + sg->offset; 4342237498fSNicholas Bellinger if (!buf) 4352237498fSNicholas Bellinger return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 4362237498fSNicholas Bellinger /* 4372237498fSNicholas Bellinger * Fall back to block_execute_write_same() slow-path if 4382237498fSNicholas Bellinger * incoming WRITE_SAME payload does not contain zeros. 4392237498fSNicholas Bellinger */ 440f5957dadSBryant G Ly not_zero = memchr_inv(buf, 0x00, cmd->data_length); 4412237498fSNicholas Bellinger kunmap(sg_page(sg)); 44207b63196SMike Christie 443f5957dadSBryant G Ly if (not_zero) 4442237498fSNicholas Bellinger return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 4452237498fSNicholas Bellinger 4462237498fSNicholas Bellinger ret = blkdev_issue_zeroout(bdev, 44707b63196SMike Christie target_to_linux_sector(dev, cmd->t_task_lba), 44807b63196SMike Christie target_to_linux_sector(dev, 44907b63196SMike Christie sbc_get_write_same_sectors(cmd)), 4502237498fSNicholas Bellinger GFP_KERNEL, false); 45107b63196SMike Christie if (ret) 45207b63196SMike Christie return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 45307b63196SMike Christie 45407b63196SMike Christie target_complete_cmd(cmd, GOOD); 45507b63196SMike Christie return 0; 45607b63196SMike Christie } 45707b63196SMike Christie 45807b63196SMike Christie static sense_reason_t 459f6970ad3SNicholas Bellinger iblock_execute_write_same(struct se_cmd *cmd) 460f6970ad3SNicholas Bellinger { 46107b63196SMike Christie struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd; 462f6970ad3SNicholas Bellinger struct iblock_req *ibr; 463f6970ad3SNicholas Bellinger struct scatterlist *sg; 464f6970ad3SNicholas Bellinger struct bio *bio; 465f6970ad3SNicholas Bellinger struct bio_list list; 4668a9ebe71SMike Christie struct se_device *dev = cmd->se_dev; 4678a9ebe71SMike Christie sector_t block_lba = target_to_linux_sector(dev, cmd->t_task_lba); 4688a9ebe71SMike Christie sector_t sectors = target_to_linux_sector(dev, 4698a9ebe71SMike Christie sbc_get_write_same_sectors(cmd)); 470f6970ad3SNicholas Bellinger 471afd73f1bSNicholas Bellinger if (cmd->prot_op) { 472afd73f1bSNicholas Bellinger pr_err("WRITE_SAME: Protection information with IBLOCK" 473afd73f1bSNicholas Bellinger " backends not supported\n"); 474afd73f1bSNicholas Bellinger return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 475afd73f1bSNicholas Bellinger } 476f6970ad3SNicholas Bellinger sg = &cmd->t_data_sg[0]; 477f6970ad3SNicholas Bellinger 478f6970ad3SNicholas Bellinger if (cmd->t_data_nents > 1 || 479f6970ad3SNicholas Bellinger sg->length != cmd->se_dev->dev_attrib.block_size) { 480f6970ad3SNicholas Bellinger pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u" 481f6970ad3SNicholas Bellinger " block_size: %u\n", cmd->t_data_nents, sg->length, 482f6970ad3SNicholas Bellinger cmd->se_dev->dev_attrib.block_size); 483f6970ad3SNicholas Bellinger return TCM_INVALID_CDB_FIELD; 484f6970ad3SNicholas Bellinger } 485f6970ad3SNicholas Bellinger 4862237498fSNicholas Bellinger if (bdev_write_zeroes_sectors(bdev)) { 4872237498fSNicholas Bellinger if (!iblock_execute_zero_out(bdev, cmd)) 4882237498fSNicholas Bellinger return 0; 4892237498fSNicholas Bellinger } 49007b63196SMike Christie 491f6970ad3SNicholas Bellinger ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL); 492f6970ad3SNicholas Bellinger if (!ibr) 493f6970ad3SNicholas Bellinger goto fail; 494f6970ad3SNicholas Bellinger cmd->priv = ibr; 495f6970ad3SNicholas Bellinger 496e742fc32SMike Christie bio = iblock_get_bio(cmd, block_lba, 1, REQ_OP_WRITE, 0); 497f6970ad3SNicholas Bellinger if (!bio) 498f6970ad3SNicholas Bellinger goto fail_free_ibr; 499f6970ad3SNicholas Bellinger 500f6970ad3SNicholas Bellinger bio_list_init(&list); 501f6970ad3SNicholas Bellinger bio_list_add(&list, bio); 502f6970ad3SNicholas Bellinger 5035981c245SElena Reshetova refcount_set(&ibr->pending, 1); 504f6970ad3SNicholas Bellinger 505f6970ad3SNicholas Bellinger while (sectors) { 506f6970ad3SNicholas Bellinger while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset) 507f6970ad3SNicholas Bellinger != sg->length) { 508f6970ad3SNicholas Bellinger 509e742fc32SMike Christie bio = iblock_get_bio(cmd, block_lba, 1, REQ_OP_WRITE, 510e742fc32SMike Christie 0); 511f6970ad3SNicholas Bellinger if (!bio) 512f6970ad3SNicholas Bellinger goto fail_put_bios; 513f6970ad3SNicholas Bellinger 5145981c245SElena Reshetova refcount_inc(&ibr->pending); 515f6970ad3SNicholas Bellinger bio_list_add(&list, bio); 516f6970ad3SNicholas Bellinger } 517f6970ad3SNicholas Bellinger 518f6970ad3SNicholas Bellinger /* Always in 512 byte units for Linux/Block */ 519f6970ad3SNicholas Bellinger block_lba += sg->length >> IBLOCK_LBA_SHIFT; 520f6970ad3SNicholas Bellinger sectors -= 1; 521f6970ad3SNicholas Bellinger } 522f6970ad3SNicholas Bellinger 5234e49ea4aSMike Christie iblock_submit_bios(&list); 524f6970ad3SNicholas Bellinger return 0; 525f6970ad3SNicholas Bellinger 526f6970ad3SNicholas Bellinger fail_put_bios: 527f6970ad3SNicholas Bellinger while ((bio = bio_list_pop(&list))) 528f6970ad3SNicholas Bellinger bio_put(bio); 529f6970ad3SNicholas Bellinger fail_free_ibr: 530f6970ad3SNicholas Bellinger kfree(ibr); 531f6970ad3SNicholas Bellinger fail: 532f6970ad3SNicholas Bellinger return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 533f6970ad3SNicholas Bellinger } 534f6970ad3SNicholas Bellinger 535c66ac9dbSNicholas Bellinger enum { 53644bfd018SAndy Grover Opt_udev_path, Opt_readonly, Opt_force, Opt_err 537c66ac9dbSNicholas Bellinger }; 538c66ac9dbSNicholas Bellinger 539c66ac9dbSNicholas Bellinger static match_table_t tokens = { 540c66ac9dbSNicholas Bellinger {Opt_udev_path, "udev_path=%s"}, 54144bfd018SAndy Grover {Opt_readonly, "readonly=%d"}, 542c66ac9dbSNicholas Bellinger {Opt_force, "force=%d"}, 543c66ac9dbSNicholas Bellinger {Opt_err, NULL} 544c66ac9dbSNicholas Bellinger }; 545c66ac9dbSNicholas Bellinger 5460fd97ccfSChristoph Hellwig static ssize_t iblock_set_configfs_dev_params(struct se_device *dev, 547c66ac9dbSNicholas Bellinger const char *page, ssize_t count) 548c66ac9dbSNicholas Bellinger { 5490fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 5506d180253SJesper Juhl char *orig, *ptr, *arg_p, *opts; 551c66ac9dbSNicholas Bellinger substring_t args[MAX_OPT_ARGS]; 55221bca31cSRoland Dreier int ret = 0, token; 55344bfd018SAndy Grover unsigned long tmp_readonly; 554c66ac9dbSNicholas Bellinger 555c66ac9dbSNicholas Bellinger opts = kstrdup(page, GFP_KERNEL); 556c66ac9dbSNicholas Bellinger if (!opts) 557c66ac9dbSNicholas Bellinger return -ENOMEM; 558c66ac9dbSNicholas Bellinger 559c66ac9dbSNicholas Bellinger orig = opts; 560c66ac9dbSNicholas Bellinger 56190c161b6SSebastian Andrzej Siewior while ((ptr = strsep(&opts, ",\n")) != NULL) { 562c66ac9dbSNicholas Bellinger if (!*ptr) 563c66ac9dbSNicholas Bellinger continue; 564c66ac9dbSNicholas Bellinger 565c66ac9dbSNicholas Bellinger token = match_token(ptr, tokens, args); 566c66ac9dbSNicholas Bellinger switch (token) { 567c66ac9dbSNicholas Bellinger case Opt_udev_path: 568c66ac9dbSNicholas Bellinger if (ib_dev->ibd_bd) { 5696708bb27SAndy Grover pr_err("Unable to set udev_path= while" 570c66ac9dbSNicholas Bellinger " ib_dev->ibd_bd exists\n"); 571c66ac9dbSNicholas Bellinger ret = -EEXIST; 572c66ac9dbSNicholas Bellinger goto out; 573c66ac9dbSNicholas Bellinger } 574852b6ed1SNicholas Bellinger if (match_strlcpy(ib_dev->ibd_udev_path, &args[0], 575852b6ed1SNicholas Bellinger SE_UDEV_PATH_LEN) == 0) { 576852b6ed1SNicholas Bellinger ret = -EINVAL; 5776d180253SJesper Juhl break; 5786d180253SJesper Juhl } 5796708bb27SAndy Grover pr_debug("IBLOCK: Referencing UDEV path: %s\n", 580c66ac9dbSNicholas Bellinger ib_dev->ibd_udev_path); 581c66ac9dbSNicholas Bellinger ib_dev->ibd_flags |= IBDF_HAS_UDEV_PATH; 582c66ac9dbSNicholas Bellinger break; 58344bfd018SAndy Grover case Opt_readonly: 58444bfd018SAndy Grover arg_p = match_strdup(&args[0]); 58544bfd018SAndy Grover if (!arg_p) { 58644bfd018SAndy Grover ret = -ENOMEM; 58744bfd018SAndy Grover break; 58844bfd018SAndy Grover } 58957103d7fSJingoo Han ret = kstrtoul(arg_p, 0, &tmp_readonly); 59044bfd018SAndy Grover kfree(arg_p); 59144bfd018SAndy Grover if (ret < 0) { 59257103d7fSJingoo Han pr_err("kstrtoul() failed for" 59344bfd018SAndy Grover " readonly=\n"); 59444bfd018SAndy Grover goto out; 59544bfd018SAndy Grover } 59644bfd018SAndy Grover ib_dev->ibd_readonly = tmp_readonly; 59744bfd018SAndy Grover pr_debug("IBLOCK: readonly: %d\n", ib_dev->ibd_readonly); 59844bfd018SAndy Grover break; 599c66ac9dbSNicholas Bellinger case Opt_force: 600c66ac9dbSNicholas Bellinger break; 601c66ac9dbSNicholas Bellinger default: 602c66ac9dbSNicholas Bellinger break; 603c66ac9dbSNicholas Bellinger } 604c66ac9dbSNicholas Bellinger } 605c66ac9dbSNicholas Bellinger 606c66ac9dbSNicholas Bellinger out: 607c66ac9dbSNicholas Bellinger kfree(orig); 608c66ac9dbSNicholas Bellinger return (!ret) ? count : ret; 609c66ac9dbSNicholas Bellinger } 610c66ac9dbSNicholas Bellinger 6110fd97ccfSChristoph Hellwig static ssize_t iblock_show_configfs_dev_params(struct se_device *dev, char *b) 612c66ac9dbSNicholas Bellinger { 6130fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 6140fd97ccfSChristoph Hellwig struct block_device *bd = ib_dev->ibd_bd; 615c66ac9dbSNicholas Bellinger char buf[BDEVNAME_SIZE]; 616c66ac9dbSNicholas Bellinger ssize_t bl = 0; 617c66ac9dbSNicholas Bellinger 618c66ac9dbSNicholas Bellinger if (bd) 619c66ac9dbSNicholas Bellinger bl += sprintf(b + bl, "iBlock device: %s", 620c66ac9dbSNicholas Bellinger bdevname(bd, buf)); 6210fd97ccfSChristoph Hellwig if (ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH) 62244bfd018SAndy Grover bl += sprintf(b + bl, " UDEV PATH: %s", 6230fd97ccfSChristoph Hellwig ib_dev->ibd_udev_path); 6240fd97ccfSChristoph Hellwig bl += sprintf(b + bl, " readonly: %d\n", ib_dev->ibd_readonly); 625c66ac9dbSNicholas Bellinger 626c66ac9dbSNicholas Bellinger bl += sprintf(b + bl, " "); 627c66ac9dbSNicholas Bellinger if (bd) { 628c66ac9dbSNicholas Bellinger bl += sprintf(b + bl, "Major: %d Minor: %d %s\n", 62921bca31cSRoland Dreier MAJOR(bd->bd_dev), MINOR(bd->bd_dev), (!bd->bd_contains) ? 6300fd97ccfSChristoph Hellwig "" : (bd->bd_holder == ib_dev) ? 631c66ac9dbSNicholas Bellinger "CLAIMED: IBLOCK" : "CLAIMED: OS"); 632c66ac9dbSNicholas Bellinger } else { 63321bca31cSRoland Dreier bl += sprintf(b + bl, "Major: 0 Minor: 0\n"); 634c66ac9dbSNicholas Bellinger } 635c66ac9dbSNicholas Bellinger 636c66ac9dbSNicholas Bellinger return bl; 637c66ac9dbSNicholas Bellinger } 638c66ac9dbSNicholas Bellinger 639ecebbf6cSNicholas Bellinger static int 640ecebbf6cSNicholas Bellinger iblock_alloc_bip(struct se_cmd *cmd, struct bio *bio) 641ecebbf6cSNicholas Bellinger { 642ecebbf6cSNicholas Bellinger struct se_device *dev = cmd->se_dev; 643ecebbf6cSNicholas Bellinger struct blk_integrity *bi; 644ecebbf6cSNicholas Bellinger struct bio_integrity_payload *bip; 645ecebbf6cSNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 646ecebbf6cSNicholas Bellinger struct scatterlist *sg; 647ecebbf6cSNicholas Bellinger int i, rc; 648ecebbf6cSNicholas Bellinger 649ecebbf6cSNicholas Bellinger bi = bdev_get_integrity(ib_dev->ibd_bd); 650ecebbf6cSNicholas Bellinger if (!bi) { 651ecebbf6cSNicholas Bellinger pr_err("Unable to locate bio_integrity\n"); 652ecebbf6cSNicholas Bellinger return -ENODEV; 653ecebbf6cSNicholas Bellinger } 654ecebbf6cSNicholas Bellinger 655ecebbf6cSNicholas Bellinger bip = bio_integrity_alloc(bio, GFP_NOIO, cmd->t_prot_nents); 65606c1e390SKeith Busch if (IS_ERR(bip)) { 657ecebbf6cSNicholas Bellinger pr_err("Unable to allocate bio_integrity_payload\n"); 65806c1e390SKeith Busch return PTR_ERR(bip); 659ecebbf6cSNicholas Bellinger } 660ecebbf6cSNicholas Bellinger 6614e13c5d0SLinus Torvalds bip->bip_iter.bi_size = (cmd->data_length / dev->dev_attrib.block_size) * 662ecebbf6cSNicholas Bellinger dev->prot_length; 6634e13c5d0SLinus Torvalds bip->bip_iter.bi_sector = bio->bi_iter.bi_sector; 664ecebbf6cSNicholas Bellinger 6654e13c5d0SLinus Torvalds pr_debug("IBLOCK BIP Size: %u Sector: %llu\n", bip->bip_iter.bi_size, 6664e13c5d0SLinus Torvalds (unsigned long long)bip->bip_iter.bi_sector); 667ecebbf6cSNicholas Bellinger 668ecebbf6cSNicholas Bellinger for_each_sg(cmd->t_prot_sg, sg, cmd->t_prot_nents, i) { 669ecebbf6cSNicholas Bellinger 670ecebbf6cSNicholas Bellinger rc = bio_integrity_add_page(bio, sg_page(sg), sg->length, 671ecebbf6cSNicholas Bellinger sg->offset); 672ecebbf6cSNicholas Bellinger if (rc != sg->length) { 673ecebbf6cSNicholas Bellinger pr_err("bio_integrity_add_page() failed; %d\n", rc); 674ecebbf6cSNicholas Bellinger return -ENOMEM; 675ecebbf6cSNicholas Bellinger } 676ecebbf6cSNicholas Bellinger 677ecebbf6cSNicholas Bellinger pr_debug("Added bio integrity page: %p length: %d offset; %d\n", 678ecebbf6cSNicholas Bellinger sg_page(sg), sg->length, sg->offset); 679ecebbf6cSNicholas Bellinger } 680ecebbf6cSNicholas Bellinger 681ecebbf6cSNicholas Bellinger return 0; 682ecebbf6cSNicholas Bellinger } 683ecebbf6cSNicholas Bellinger 684de103c93SChristoph Hellwig static sense_reason_t 685a82a9538SNicholas Bellinger iblock_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents, 686a82a9538SNicholas Bellinger enum dma_data_direction data_direction) 687c66ac9dbSNicholas Bellinger { 6885951146dSAndy Grover struct se_device *dev = cmd->se_dev; 6898a9ebe71SMike Christie sector_t block_lba = target_to_linux_sector(dev, cmd->t_task_lba); 6905787cacdSChristoph Hellwig struct iblock_req *ibr; 691ecebbf6cSNicholas Bellinger struct bio *bio, *bio_start; 692dbbf3e94SChristoph Hellwig struct bio_list list; 693c66ac9dbSNicholas Bellinger struct scatterlist *sg; 6945787cacdSChristoph Hellwig u32 sg_num = sgl_nents; 695d5b4a21bSChristoph Hellwig unsigned bio_cnt; 696e742fc32SMike Christie int i, op, op_flags = 0; 697dbbf3e94SChristoph Hellwig 6985787cacdSChristoph Hellwig if (data_direction == DMA_TO_DEVICE) { 699d0c8b259SNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 700d0c8b259SNicholas Bellinger struct request_queue *q = bdev_get_queue(ib_dev->ibd_bd); 701dbbf3e94SChristoph Hellwig /* 70270fd7614SChristoph Hellwig * Force writethrough using REQ_FUA if a volatile write cache 703d0c8b259SNicholas Bellinger * is not enabled, or if initiator set the Force Unit Access bit. 704dbbf3e94SChristoph Hellwig */ 705e742fc32SMike Christie op = REQ_OP_WRITE; 706c888a8f9SJens Axboe if (test_bit(QUEUE_FLAG_FUA, &q->queue_flags)) { 707d0c8b259SNicholas Bellinger if (cmd->se_cmd_flags & SCF_FUA) 70870fd7614SChristoph Hellwig op_flags = REQ_FUA; 709c888a8f9SJens Axboe else if (!test_bit(QUEUE_FLAG_WC, &q->queue_flags)) 71070fd7614SChristoph Hellwig op_flags = REQ_FUA; 711d0c8b259SNicholas Bellinger } 712dbbf3e94SChristoph Hellwig } else { 713e742fc32SMike Christie op = REQ_OP_READ; 714dbbf3e94SChristoph Hellwig } 715dbbf3e94SChristoph Hellwig 7165787cacdSChristoph Hellwig ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL); 7175787cacdSChristoph Hellwig if (!ibr) 7185787cacdSChristoph Hellwig goto fail; 7195787cacdSChristoph Hellwig cmd->priv = ibr; 7205787cacdSChristoph Hellwig 721e0de4457SPaolo Bonzini if (!sgl_nents) { 7225981c245SElena Reshetova refcount_set(&ibr->pending, 1); 723e0de4457SPaolo Bonzini iblock_complete_cmd(cmd); 724e0de4457SPaolo Bonzini return 0; 725e0de4457SPaolo Bonzini } 726e0de4457SPaolo Bonzini 727e742fc32SMike Christie bio = iblock_get_bio(cmd, block_lba, sgl_nents, op, op_flags); 7285787cacdSChristoph Hellwig if (!bio) 7295787cacdSChristoph Hellwig goto fail_free_ibr; 730c66ac9dbSNicholas Bellinger 731ecebbf6cSNicholas Bellinger bio_start = bio; 732dbbf3e94SChristoph Hellwig bio_list_init(&list); 733dbbf3e94SChristoph Hellwig bio_list_add(&list, bio); 7345787cacdSChristoph Hellwig 7355981c245SElena Reshetova refcount_set(&ibr->pending, 2); 736d5b4a21bSChristoph Hellwig bio_cnt = 1; 737dbbf3e94SChristoph Hellwig 7385787cacdSChristoph Hellwig for_each_sg(sgl, sg, sgl_nents, i) { 739dbbf3e94SChristoph Hellwig /* 740dbbf3e94SChristoph Hellwig * XXX: if the length the device accepts is shorter than the 741dbbf3e94SChristoph Hellwig * length of the S/G list entry this will cause and 742dbbf3e94SChristoph Hellwig * endless loop. Better hope no driver uses huge pages. 743dbbf3e94SChristoph Hellwig */ 744dbbf3e94SChristoph Hellwig while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset) 745dbbf3e94SChristoph Hellwig != sg->length) { 746d5b4a21bSChristoph Hellwig if (bio_cnt >= IBLOCK_MAX_BIO_PER_TASK) { 7474e49ea4aSMike Christie iblock_submit_bios(&list); 748d5b4a21bSChristoph Hellwig bio_cnt = 0; 749d5b4a21bSChristoph Hellwig } 750d5b4a21bSChristoph Hellwig 751e742fc32SMike Christie bio = iblock_get_bio(cmd, block_lba, sg_num, op, 752e742fc32SMike Christie op_flags); 7536708bb27SAndy Grover if (!bio) 7545787cacdSChristoph Hellwig goto fail_put_bios; 7555787cacdSChristoph Hellwig 7565981c245SElena Reshetova refcount_inc(&ibr->pending); 757dbbf3e94SChristoph Hellwig bio_list_add(&list, bio); 758d5b4a21bSChristoph Hellwig bio_cnt++; 759c66ac9dbSNicholas Bellinger } 760dbbf3e94SChristoph Hellwig 761c66ac9dbSNicholas Bellinger /* Always in 512 byte units for Linux/Block */ 762c66ac9dbSNicholas Bellinger block_lba += sg->length >> IBLOCK_LBA_SHIFT; 763c66ac9dbSNicholas Bellinger sg_num--; 764c66ac9dbSNicholas Bellinger } 765c66ac9dbSNicholas Bellinger 7666f16ec43SNicholas Bellinger if (cmd->prot_type && dev->dev_attrib.pi_prot_type) { 767ecebbf6cSNicholas Bellinger int rc = iblock_alloc_bip(cmd, bio_start); 768ecebbf6cSNicholas Bellinger if (rc) 769ecebbf6cSNicholas Bellinger goto fail_put_bios; 770ecebbf6cSNicholas Bellinger } 771ecebbf6cSNicholas Bellinger 7724e49ea4aSMike Christie iblock_submit_bios(&list); 7735787cacdSChristoph Hellwig iblock_complete_cmd(cmd); 77403e98c9eSNicholas Bellinger return 0; 775dbbf3e94SChristoph Hellwig 7765787cacdSChristoph Hellwig fail_put_bios: 777dbbf3e94SChristoph Hellwig while ((bio = bio_list_pop(&list))) 778c66ac9dbSNicholas Bellinger bio_put(bio); 7795787cacdSChristoph Hellwig fail_free_ibr: 7805787cacdSChristoph Hellwig kfree(ibr); 7815787cacdSChristoph Hellwig fail: 782de103c93SChristoph Hellwig return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 783c66ac9dbSNicholas Bellinger } 784c66ac9dbSNicholas Bellinger 785c66ac9dbSNicholas Bellinger static sector_t iblock_get_blocks(struct se_device *dev) 786c66ac9dbSNicholas Bellinger { 7870fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 7880fd97ccfSChristoph Hellwig struct block_device *bd = ib_dev->ibd_bd; 789c66ac9dbSNicholas Bellinger struct request_queue *q = bdev_get_queue(bd); 790c66ac9dbSNicholas Bellinger 791c66ac9dbSNicholas Bellinger return iblock_emulate_read_cap_with_block_size(dev, bd, q); 792c66ac9dbSNicholas Bellinger } 793c66ac9dbSNicholas Bellinger 7947f7caf6aSAndy Grover static sector_t iblock_get_alignment_offset_lbas(struct se_device *dev) 7957f7caf6aSAndy Grover { 7967f7caf6aSAndy Grover struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 7977f7caf6aSAndy Grover struct block_device *bd = ib_dev->ibd_bd; 7987f7caf6aSAndy Grover int ret; 7997f7caf6aSAndy Grover 8007f7caf6aSAndy Grover ret = bdev_alignment_offset(bd); 8017f7caf6aSAndy Grover if (ret == -1) 8027f7caf6aSAndy Grover return 0; 8037f7caf6aSAndy Grover 8047f7caf6aSAndy Grover /* convert offset-bytes to offset-lbas */ 8057f7caf6aSAndy Grover return ret / bdev_logical_block_size(bd); 8067f7caf6aSAndy Grover } 8077f7caf6aSAndy Grover 8087f7caf6aSAndy Grover static unsigned int iblock_get_lbppbe(struct se_device *dev) 8097f7caf6aSAndy Grover { 8107f7caf6aSAndy Grover struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 8117f7caf6aSAndy Grover struct block_device *bd = ib_dev->ibd_bd; 8127f7caf6aSAndy Grover int logs_per_phys = bdev_physical_block_size(bd) / bdev_logical_block_size(bd); 8137f7caf6aSAndy Grover 8147f7caf6aSAndy Grover return ilog2(logs_per_phys); 8157f7caf6aSAndy Grover } 8167f7caf6aSAndy Grover 8177f7caf6aSAndy Grover static unsigned int iblock_get_io_min(struct se_device *dev) 8187f7caf6aSAndy Grover { 8197f7caf6aSAndy Grover struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 8207f7caf6aSAndy Grover struct block_device *bd = ib_dev->ibd_bd; 8217f7caf6aSAndy Grover 8227f7caf6aSAndy Grover return bdev_io_min(bd); 8237f7caf6aSAndy Grover } 8247f7caf6aSAndy Grover 8257f7caf6aSAndy Grover static unsigned int iblock_get_io_opt(struct se_device *dev) 8267f7caf6aSAndy Grover { 8277f7caf6aSAndy Grover struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 8287f7caf6aSAndy Grover struct block_device *bd = ib_dev->ibd_bd; 8297f7caf6aSAndy Grover 8307f7caf6aSAndy Grover return bdev_io_opt(bd); 8317f7caf6aSAndy Grover } 8327f7caf6aSAndy Grover 8339e999a6cSChristoph Hellwig static struct sbc_ops iblock_sbc_ops = { 8340c2ad7d1SChristoph Hellwig .execute_rw = iblock_execute_rw, 835ad67f0d9SChristoph Hellwig .execute_sync_cache = iblock_execute_sync_cache, 8366f974e8cSChristoph Hellwig .execute_write_same = iblock_execute_write_same, 83714150a6bSChristoph Hellwig .execute_unmap = iblock_execute_unmap, 8380c2ad7d1SChristoph Hellwig }; 8390c2ad7d1SChristoph Hellwig 840de103c93SChristoph Hellwig static sense_reason_t 841de103c93SChristoph Hellwig iblock_parse_cdb(struct se_cmd *cmd) 8420c2ad7d1SChristoph Hellwig { 8439e999a6cSChristoph Hellwig return sbc_parse_cdb(cmd, &iblock_sbc_ops); 8440c2ad7d1SChristoph Hellwig } 8450c2ad7d1SChristoph Hellwig 846452e2010SRashika Kheria static bool iblock_get_write_cache(struct se_device *dev) 847d0c8b259SNicholas Bellinger { 848d0c8b259SNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 849d0c8b259SNicholas Bellinger struct block_device *bd = ib_dev->ibd_bd; 850d0c8b259SNicholas Bellinger struct request_queue *q = bdev_get_queue(bd); 851d0c8b259SNicholas Bellinger 852c888a8f9SJens Axboe return test_bit(QUEUE_FLAG_WC, &q->queue_flags); 853d0c8b259SNicholas Bellinger } 854d0c8b259SNicholas Bellinger 8550a06d430SChristoph Hellwig static const struct target_backend_ops iblock_ops = { 856c66ac9dbSNicholas Bellinger .name = "iblock", 8570fd97ccfSChristoph Hellwig .inquiry_prod = "IBLOCK", 8580fd97ccfSChristoph Hellwig .inquiry_rev = IBLOCK_VERSION, 859c66ac9dbSNicholas Bellinger .owner = THIS_MODULE, 860c66ac9dbSNicholas Bellinger .attach_hba = iblock_attach_hba, 861c66ac9dbSNicholas Bellinger .detach_hba = iblock_detach_hba, 8620fd97ccfSChristoph Hellwig .alloc_device = iblock_alloc_device, 8630fd97ccfSChristoph Hellwig .configure_device = iblock_configure_device, 86492634706SMike Christie .destroy_device = iblock_destroy_device, 865c66ac9dbSNicholas Bellinger .free_device = iblock_free_device, 8660c2ad7d1SChristoph Hellwig .parse_cdb = iblock_parse_cdb, 867c66ac9dbSNicholas Bellinger .set_configfs_dev_params = iblock_set_configfs_dev_params, 868c66ac9dbSNicholas Bellinger .show_configfs_dev_params = iblock_show_configfs_dev_params, 8696f23ac8aSChristoph Hellwig .get_device_type = sbc_get_device_type, 870c66ac9dbSNicholas Bellinger .get_blocks = iblock_get_blocks, 8717f7caf6aSAndy Grover .get_alignment_offset_lbas = iblock_get_alignment_offset_lbas, 8727f7caf6aSAndy Grover .get_lbppbe = iblock_get_lbppbe, 8737f7caf6aSAndy Grover .get_io_min = iblock_get_io_min, 8747f7caf6aSAndy Grover .get_io_opt = iblock_get_io_opt, 875d0c8b259SNicholas Bellinger .get_write_cache = iblock_get_write_cache, 8765873c4d1SChristoph Hellwig .tb_dev_attrib_attrs = sbc_attrib_attrs, 877c66ac9dbSNicholas Bellinger }; 878c66ac9dbSNicholas Bellinger 879c66ac9dbSNicholas Bellinger static int __init iblock_module_init(void) 880c66ac9dbSNicholas Bellinger { 8810a06d430SChristoph Hellwig return transport_backend_register(&iblock_ops); 882c66ac9dbSNicholas Bellinger } 883c66ac9dbSNicholas Bellinger 88463b91d5aSAsias He static void __exit iblock_module_exit(void) 885c66ac9dbSNicholas Bellinger { 8860a06d430SChristoph Hellwig target_backend_unregister(&iblock_ops); 887c66ac9dbSNicholas Bellinger } 888c66ac9dbSNicholas Bellinger 889c66ac9dbSNicholas Bellinger MODULE_DESCRIPTION("TCM IBLOCK subsystem plugin"); 890c66ac9dbSNicholas Bellinger MODULE_AUTHOR("nab@Linux-iSCSI.org"); 891c66ac9dbSNicholas Bellinger MODULE_LICENSE("GPL"); 892c66ac9dbSNicholas Bellinger 893c66ac9dbSNicholas Bellinger module_init(iblock_module_init); 894c66ac9dbSNicholas Bellinger module_exit(iblock_module_exit); 895