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> 38c66ac9dbSNicholas Bellinger #include <scsi/scsi.h> 39c66ac9dbSNicholas Bellinger #include <scsi/scsi_host.h> 4014150a6bSChristoph Hellwig #include <asm/unaligned.h> 41c66ac9dbSNicholas Bellinger 42c66ac9dbSNicholas Bellinger #include <target/target_core_base.h> 43c4795fb2SChristoph Hellwig #include <target/target_core_backend.h> 44c66ac9dbSNicholas Bellinger 45c66ac9dbSNicholas Bellinger #include "target_core_iblock.h" 46c66ac9dbSNicholas Bellinger 47d5b4a21bSChristoph Hellwig #define IBLOCK_MAX_BIO_PER_TASK 32 /* max # of bios to submit at a time */ 48d5b4a21bSChristoph Hellwig #define IBLOCK_BIO_POOL_SIZE 128 49d5b4a21bSChristoph Hellwig 500fd97ccfSChristoph Hellwig static inline struct iblock_dev *IBLOCK_DEV(struct se_device *dev) 510fd97ccfSChristoph Hellwig { 520fd97ccfSChristoph Hellwig return container_of(dev, struct iblock_dev, dev); 530fd97ccfSChristoph Hellwig } 540fd97ccfSChristoph Hellwig 550fd97ccfSChristoph Hellwig 56c66ac9dbSNicholas Bellinger static struct se_subsystem_api iblock_template; 57c66ac9dbSNicholas Bellinger 58c66ac9dbSNicholas Bellinger /* iblock_attach_hba(): (Part of se_subsystem_api_t template) 59c66ac9dbSNicholas Bellinger * 60c66ac9dbSNicholas Bellinger * 61c66ac9dbSNicholas Bellinger */ 62c66ac9dbSNicholas Bellinger static int iblock_attach_hba(struct se_hba *hba, u32 host_id) 63c66ac9dbSNicholas Bellinger { 646708bb27SAndy Grover pr_debug("CORE_HBA[%d] - TCM iBlock HBA Driver %s on" 65c66ac9dbSNicholas Bellinger " Generic Target Core Stack %s\n", hba->hba_id, 66c66ac9dbSNicholas Bellinger IBLOCK_VERSION, TARGET_CORE_MOD_VERSION); 67c66ac9dbSNicholas Bellinger return 0; 68c66ac9dbSNicholas Bellinger } 69c66ac9dbSNicholas Bellinger 70c66ac9dbSNicholas Bellinger static void iblock_detach_hba(struct se_hba *hba) 71c66ac9dbSNicholas Bellinger { 72c66ac9dbSNicholas Bellinger } 73c66ac9dbSNicholas Bellinger 740fd97ccfSChristoph Hellwig static struct se_device *iblock_alloc_device(struct se_hba *hba, const char *name) 75c66ac9dbSNicholas Bellinger { 76c66ac9dbSNicholas Bellinger struct iblock_dev *ib_dev = NULL; 77c66ac9dbSNicholas Bellinger 78c66ac9dbSNicholas Bellinger ib_dev = kzalloc(sizeof(struct iblock_dev), GFP_KERNEL); 796708bb27SAndy Grover if (!ib_dev) { 806708bb27SAndy Grover pr_err("Unable to allocate struct iblock_dev\n"); 81c66ac9dbSNicholas Bellinger return NULL; 82c66ac9dbSNicholas Bellinger } 83c66ac9dbSNicholas Bellinger 846708bb27SAndy Grover pr_debug( "IBLOCK: Allocated ib_dev for %s\n", name); 85c66ac9dbSNicholas Bellinger 860fd97ccfSChristoph Hellwig return &ib_dev->dev; 87c66ac9dbSNicholas Bellinger } 88c66ac9dbSNicholas Bellinger 890fd97ccfSChristoph Hellwig static int iblock_configure_device(struct se_device *dev) 90c66ac9dbSNicholas Bellinger { 910fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 92c66ac9dbSNicholas Bellinger struct request_queue *q; 930fd97ccfSChristoph Hellwig struct block_device *bd = NULL; 94ecebbf6cSNicholas Bellinger struct blk_integrity *bi; 9544bfd018SAndy Grover fmode_t mode; 960fd97ccfSChristoph Hellwig int ret = -ENOMEM; 97c66ac9dbSNicholas Bellinger 980fd97ccfSChristoph Hellwig if (!(ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH)) { 990fd97ccfSChristoph Hellwig pr_err("Missing udev_path= parameters for IBLOCK\n"); 1000fd97ccfSChristoph Hellwig return -EINVAL; 101c66ac9dbSNicholas Bellinger } 102d5b4a21bSChristoph Hellwig 103d5b4a21bSChristoph Hellwig ib_dev->ibd_bio_set = bioset_create(IBLOCK_BIO_POOL_SIZE, 0); 1046708bb27SAndy Grover if (!ib_dev->ibd_bio_set) { 1050fd97ccfSChristoph Hellwig pr_err("IBLOCK: Unable to create bioset\n"); 1060fd97ccfSChristoph Hellwig goto out; 107c66ac9dbSNicholas Bellinger } 1080fd97ccfSChristoph Hellwig 1096708bb27SAndy Grover pr_debug( "IBLOCK: Claiming struct block_device: %s\n", 110c66ac9dbSNicholas Bellinger ib_dev->ibd_udev_path); 111c66ac9dbSNicholas Bellinger 11244bfd018SAndy Grover mode = FMODE_READ|FMODE_EXCL; 11344bfd018SAndy Grover if (!ib_dev->ibd_readonly) 11444bfd018SAndy Grover mode |= FMODE_WRITE; 11544bfd018SAndy Grover 11644bfd018SAndy Grover bd = blkdev_get_by_path(ib_dev->ibd_udev_path, mode, ib_dev); 117613640e4SNicholas Bellinger if (IS_ERR(bd)) { 118613640e4SNicholas Bellinger ret = PTR_ERR(bd); 1190fd97ccfSChristoph Hellwig goto out_free_bioset; 120613640e4SNicholas Bellinger } 121c66ac9dbSNicholas Bellinger ib_dev->ibd_bd = bd; 122c66ac9dbSNicholas Bellinger 1230fd97ccfSChristoph Hellwig q = bdev_get_queue(bd); 1240fd97ccfSChristoph Hellwig 1250fd97ccfSChristoph Hellwig dev->dev_attrib.hw_block_size = bdev_logical_block_size(bd); 1260fd97ccfSChristoph Hellwig dev->dev_attrib.hw_max_sectors = UINT_MAX; 1270fd97ccfSChristoph Hellwig dev->dev_attrib.hw_queue_depth = q->nr_requests; 128c66ac9dbSNicholas Bellinger 129c66ac9dbSNicholas Bellinger /* 130c66ac9dbSNicholas Bellinger * Check if the underlying struct block_device request_queue supports 131c66ac9dbSNicholas Bellinger * the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM 132c66ac9dbSNicholas Bellinger * in ATA and we need to set TPE=1 133c66ac9dbSNicholas Bellinger */ 134613640e4SNicholas Bellinger if (blk_queue_discard(q)) { 1350fd97ccfSChristoph Hellwig dev->dev_attrib.max_unmap_lba_count = 136c66ac9dbSNicholas Bellinger q->limits.max_discard_sectors; 1370fd97ccfSChristoph Hellwig 138c66ac9dbSNicholas Bellinger /* 139c66ac9dbSNicholas Bellinger * Currently hardcoded to 1 in Linux/SCSI code.. 140c66ac9dbSNicholas Bellinger */ 1410fd97ccfSChristoph Hellwig dev->dev_attrib.max_unmap_block_desc_count = 1; 1420fd97ccfSChristoph Hellwig dev->dev_attrib.unmap_granularity = 1437347b5ffSMarco Sanvido q->limits.discard_granularity >> 9; 1440fd97ccfSChristoph Hellwig dev->dev_attrib.unmap_granularity_alignment = 145c66ac9dbSNicholas Bellinger q->limits.discard_alignment; 146c66ac9dbSNicholas Bellinger 1476708bb27SAndy Grover pr_debug("IBLOCK: BLOCK Discard support available," 148c66ac9dbSNicholas Bellinger " disabled by default\n"); 149c66ac9dbSNicholas Bellinger } 150f6970ad3SNicholas Bellinger /* 151f6970ad3SNicholas Bellinger * Enable write same emulation for IBLOCK and use 0xFFFF as 152f6970ad3SNicholas Bellinger * the smaller WRITE_SAME(10) only has a two-byte block count. 153f6970ad3SNicholas Bellinger */ 154f6970ad3SNicholas Bellinger dev->dev_attrib.max_write_same_len = 0xFFFF; 155c66ac9dbSNicholas Bellinger 156e22a7f07SRoland Dreier if (blk_queue_nonrot(q)) 1570fd97ccfSChristoph Hellwig dev->dev_attrib.is_nonrot = 1; 158d0c8b259SNicholas Bellinger 159ecebbf6cSNicholas Bellinger bi = bdev_get_integrity(bd); 160ecebbf6cSNicholas Bellinger if (bi) { 161ecebbf6cSNicholas Bellinger struct bio_set *bs = ib_dev->ibd_bio_set; 162ecebbf6cSNicholas Bellinger 163ecebbf6cSNicholas Bellinger if (!strcmp(bi->name, "T10-DIF-TYPE3-IP") || 164ecebbf6cSNicholas Bellinger !strcmp(bi->name, "T10-DIF-TYPE1-IP")) { 165ecebbf6cSNicholas Bellinger pr_err("IBLOCK export of blk_integrity: %s not" 166ecebbf6cSNicholas Bellinger " supported\n", bi->name); 167ecebbf6cSNicholas Bellinger ret = -ENOSYS; 168ecebbf6cSNicholas Bellinger goto out_blkdev_put; 169ecebbf6cSNicholas Bellinger } 170ecebbf6cSNicholas Bellinger 171ecebbf6cSNicholas Bellinger if (!strcmp(bi->name, "T10-DIF-TYPE3-CRC")) { 172ecebbf6cSNicholas Bellinger dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE3_PROT; 173ecebbf6cSNicholas Bellinger } else if (!strcmp(bi->name, "T10-DIF-TYPE1-CRC")) { 174ecebbf6cSNicholas Bellinger dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE1_PROT; 175ecebbf6cSNicholas Bellinger } 176ecebbf6cSNicholas Bellinger 177ecebbf6cSNicholas Bellinger if (dev->dev_attrib.pi_prot_type) { 178ecebbf6cSNicholas Bellinger if (bioset_integrity_create(bs, IBLOCK_BIO_POOL_SIZE) < 0) { 179ecebbf6cSNicholas Bellinger pr_err("Unable to allocate bioset for PI\n"); 180ecebbf6cSNicholas Bellinger ret = -ENOMEM; 181ecebbf6cSNicholas Bellinger goto out_blkdev_put; 182ecebbf6cSNicholas Bellinger } 183ecebbf6cSNicholas Bellinger pr_debug("IBLOCK setup BIP bs->bio_integrity_pool: %p\n", 184ecebbf6cSNicholas Bellinger bs->bio_integrity_pool); 185ecebbf6cSNicholas Bellinger } 186ecebbf6cSNicholas Bellinger dev->dev_attrib.hw_pi_prot_type = dev->dev_attrib.pi_prot_type; 187ecebbf6cSNicholas Bellinger } 188ecebbf6cSNicholas Bellinger 1890fd97ccfSChristoph Hellwig return 0; 190e22a7f07SRoland Dreier 191ecebbf6cSNicholas Bellinger out_blkdev_put: 192ecebbf6cSNicholas Bellinger blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL); 1930fd97ccfSChristoph Hellwig out_free_bioset: 194c66ac9dbSNicholas Bellinger bioset_free(ib_dev->ibd_bio_set); 195c66ac9dbSNicholas Bellinger ib_dev->ibd_bio_set = NULL; 1960fd97ccfSChristoph Hellwig out: 1970fd97ccfSChristoph Hellwig return ret; 198c66ac9dbSNicholas Bellinger } 199c66ac9dbSNicholas Bellinger 2000fd97ccfSChristoph Hellwig static void iblock_free_device(struct se_device *dev) 201c66ac9dbSNicholas Bellinger { 2020fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 203c66ac9dbSNicholas Bellinger 204bc665524SNicholas Bellinger if (ib_dev->ibd_bd != NULL) 205c66ac9dbSNicholas Bellinger blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL); 206d84287bcSNicholas Bellinger if (ib_dev->ibd_bio_set != NULL) 207c66ac9dbSNicholas Bellinger bioset_free(ib_dev->ibd_bio_set); 208d84287bcSNicholas Bellinger 209c66ac9dbSNicholas Bellinger kfree(ib_dev); 210c66ac9dbSNicholas Bellinger } 211c66ac9dbSNicholas Bellinger 212c66ac9dbSNicholas Bellinger static unsigned long long iblock_emulate_read_cap_with_block_size( 213c66ac9dbSNicholas Bellinger struct se_device *dev, 214c66ac9dbSNicholas Bellinger struct block_device *bd, 215c66ac9dbSNicholas Bellinger struct request_queue *q) 216c66ac9dbSNicholas Bellinger { 217c66ac9dbSNicholas Bellinger unsigned long long blocks_long = (div_u64(i_size_read(bd->bd_inode), 218c66ac9dbSNicholas Bellinger bdev_logical_block_size(bd)) - 1); 219c66ac9dbSNicholas Bellinger u32 block_size = bdev_logical_block_size(bd); 220c66ac9dbSNicholas Bellinger 2210fd97ccfSChristoph Hellwig if (block_size == dev->dev_attrib.block_size) 222c66ac9dbSNicholas Bellinger return blocks_long; 223c66ac9dbSNicholas Bellinger 224c66ac9dbSNicholas Bellinger switch (block_size) { 225c66ac9dbSNicholas Bellinger case 4096: 2260fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 227c66ac9dbSNicholas Bellinger case 2048: 228c66ac9dbSNicholas Bellinger blocks_long <<= 1; 229c66ac9dbSNicholas Bellinger break; 230c66ac9dbSNicholas Bellinger case 1024: 231c66ac9dbSNicholas Bellinger blocks_long <<= 2; 232c66ac9dbSNicholas Bellinger break; 233c66ac9dbSNicholas Bellinger case 512: 234c66ac9dbSNicholas Bellinger blocks_long <<= 3; 235c66ac9dbSNicholas Bellinger default: 236c66ac9dbSNicholas Bellinger break; 237c66ac9dbSNicholas Bellinger } 238c66ac9dbSNicholas Bellinger break; 239c66ac9dbSNicholas Bellinger case 2048: 2400fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 241c66ac9dbSNicholas Bellinger case 4096: 242c66ac9dbSNicholas Bellinger blocks_long >>= 1; 243c66ac9dbSNicholas Bellinger break; 244c66ac9dbSNicholas Bellinger case 1024: 245c66ac9dbSNicholas Bellinger blocks_long <<= 1; 246c66ac9dbSNicholas Bellinger break; 247c66ac9dbSNicholas Bellinger case 512: 248c66ac9dbSNicholas Bellinger blocks_long <<= 2; 249c66ac9dbSNicholas Bellinger break; 250c66ac9dbSNicholas Bellinger default: 251c66ac9dbSNicholas Bellinger break; 252c66ac9dbSNicholas Bellinger } 253c66ac9dbSNicholas Bellinger break; 254c66ac9dbSNicholas Bellinger case 1024: 2550fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 256c66ac9dbSNicholas Bellinger case 4096: 257c66ac9dbSNicholas Bellinger blocks_long >>= 2; 258c66ac9dbSNicholas Bellinger break; 259c66ac9dbSNicholas Bellinger case 2048: 260c66ac9dbSNicholas Bellinger blocks_long >>= 1; 261c66ac9dbSNicholas Bellinger break; 262c66ac9dbSNicholas Bellinger case 512: 263c66ac9dbSNicholas Bellinger blocks_long <<= 1; 264c66ac9dbSNicholas Bellinger break; 265c66ac9dbSNicholas Bellinger default: 266c66ac9dbSNicholas Bellinger break; 267c66ac9dbSNicholas Bellinger } 268c66ac9dbSNicholas Bellinger break; 269c66ac9dbSNicholas Bellinger case 512: 2700fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 271c66ac9dbSNicholas Bellinger case 4096: 272c66ac9dbSNicholas Bellinger blocks_long >>= 3; 273c66ac9dbSNicholas Bellinger break; 274c66ac9dbSNicholas Bellinger case 2048: 275c66ac9dbSNicholas Bellinger blocks_long >>= 2; 276c66ac9dbSNicholas Bellinger break; 277c66ac9dbSNicholas Bellinger case 1024: 278c66ac9dbSNicholas Bellinger blocks_long >>= 1; 279c66ac9dbSNicholas Bellinger break; 280c66ac9dbSNicholas Bellinger default: 281c66ac9dbSNicholas Bellinger break; 282c66ac9dbSNicholas Bellinger } 283c66ac9dbSNicholas Bellinger break; 284c66ac9dbSNicholas Bellinger default: 285c66ac9dbSNicholas Bellinger break; 286c66ac9dbSNicholas Bellinger } 287c66ac9dbSNicholas Bellinger 288c66ac9dbSNicholas Bellinger return blocks_long; 289c66ac9dbSNicholas Bellinger } 290c66ac9dbSNicholas Bellinger 2913a41d85fSNicholas Bellinger static void iblock_complete_cmd(struct se_cmd *cmd) 2923a41d85fSNicholas Bellinger { 2933a41d85fSNicholas Bellinger struct iblock_req *ibr = cmd->priv; 2943a41d85fSNicholas Bellinger u8 status; 2953a41d85fSNicholas Bellinger 2963a41d85fSNicholas Bellinger if (!atomic_dec_and_test(&ibr->pending)) 2973a41d85fSNicholas Bellinger return; 2983a41d85fSNicholas Bellinger 2993a41d85fSNicholas Bellinger if (atomic_read(&ibr->ib_bio_err_cnt)) 3003a41d85fSNicholas Bellinger status = SAM_STAT_CHECK_CONDITION; 3013a41d85fSNicholas Bellinger else 3023a41d85fSNicholas Bellinger status = SAM_STAT_GOOD; 3033a41d85fSNicholas Bellinger 3043a41d85fSNicholas Bellinger target_complete_cmd(cmd, status); 3053a41d85fSNicholas Bellinger kfree(ibr); 3063a41d85fSNicholas Bellinger } 3073a41d85fSNicholas Bellinger 3083a41d85fSNicholas Bellinger static void iblock_bio_done(struct bio *bio, int err) 3093a41d85fSNicholas Bellinger { 3103a41d85fSNicholas Bellinger struct se_cmd *cmd = bio->bi_private; 3113a41d85fSNicholas Bellinger struct iblock_req *ibr = cmd->priv; 3123a41d85fSNicholas Bellinger 3133a41d85fSNicholas Bellinger /* 3143a41d85fSNicholas Bellinger * Set -EIO if !BIO_UPTODATE and the passed is still err=0 3153a41d85fSNicholas Bellinger */ 3163a41d85fSNicholas Bellinger if (!test_bit(BIO_UPTODATE, &bio->bi_flags) && !err) 3173a41d85fSNicholas Bellinger err = -EIO; 3183a41d85fSNicholas Bellinger 3193a41d85fSNicholas Bellinger if (err != 0) { 3203a41d85fSNicholas Bellinger pr_err("test_bit(BIO_UPTODATE) failed for bio: %p," 3213a41d85fSNicholas Bellinger " err: %d\n", bio, err); 3223a41d85fSNicholas Bellinger /* 3233a41d85fSNicholas Bellinger * Bump the ib_bio_err_cnt and release bio. 3243a41d85fSNicholas Bellinger */ 3253a41d85fSNicholas Bellinger atomic_inc(&ibr->ib_bio_err_cnt); 3264e857c58SPeter Zijlstra smp_mb__after_atomic(); 3273a41d85fSNicholas Bellinger } 3283a41d85fSNicholas Bellinger 3293a41d85fSNicholas Bellinger bio_put(bio); 3303a41d85fSNicholas Bellinger 3313a41d85fSNicholas Bellinger iblock_complete_cmd(cmd); 3323a41d85fSNicholas Bellinger } 3333a41d85fSNicholas Bellinger 3343a41d85fSNicholas Bellinger static struct bio * 3353a41d85fSNicholas Bellinger iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num) 3363a41d85fSNicholas Bellinger { 3373a41d85fSNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev); 3383a41d85fSNicholas Bellinger struct bio *bio; 3393a41d85fSNicholas Bellinger 3403a41d85fSNicholas Bellinger /* 3413a41d85fSNicholas Bellinger * Only allocate as many vector entries as the bio code allows us to, 3423a41d85fSNicholas Bellinger * we'll loop later on until we have handled the whole request. 3433a41d85fSNicholas Bellinger */ 3443a41d85fSNicholas Bellinger if (sg_num > BIO_MAX_PAGES) 3453a41d85fSNicholas Bellinger sg_num = BIO_MAX_PAGES; 3463a41d85fSNicholas Bellinger 3473a41d85fSNicholas Bellinger bio = bio_alloc_bioset(GFP_NOIO, sg_num, ib_dev->ibd_bio_set); 3483a41d85fSNicholas Bellinger if (!bio) { 3493a41d85fSNicholas Bellinger pr_err("Unable to allocate memory for bio\n"); 3503a41d85fSNicholas Bellinger return NULL; 3513a41d85fSNicholas Bellinger } 3523a41d85fSNicholas Bellinger 3533a41d85fSNicholas Bellinger bio->bi_bdev = ib_dev->ibd_bd; 3543a41d85fSNicholas Bellinger bio->bi_private = cmd; 3553a41d85fSNicholas Bellinger bio->bi_end_io = &iblock_bio_done; 3564f024f37SKent Overstreet bio->bi_iter.bi_sector = lba; 3573a41d85fSNicholas Bellinger 3583a41d85fSNicholas Bellinger return bio; 3593a41d85fSNicholas Bellinger } 3603a41d85fSNicholas Bellinger 3613a41d85fSNicholas Bellinger static void iblock_submit_bios(struct bio_list *list, int rw) 3623a41d85fSNicholas Bellinger { 3633a41d85fSNicholas Bellinger struct blk_plug plug; 3643a41d85fSNicholas Bellinger struct bio *bio; 3653a41d85fSNicholas Bellinger 3663a41d85fSNicholas Bellinger blk_start_plug(&plug); 3673a41d85fSNicholas Bellinger while ((bio = bio_list_pop(list))) 3683a41d85fSNicholas Bellinger submit_bio(rw, bio); 3693a41d85fSNicholas Bellinger blk_finish_plug(&plug); 3703a41d85fSNicholas Bellinger } 3713a41d85fSNicholas Bellinger 372df5fa691SChristoph Hellwig static void iblock_end_io_flush(struct bio *bio, int err) 373df5fa691SChristoph Hellwig { 374df5fa691SChristoph Hellwig struct se_cmd *cmd = bio->bi_private; 375df5fa691SChristoph Hellwig 376df5fa691SChristoph Hellwig if (err) 377df5fa691SChristoph Hellwig pr_err("IBLOCK: cache flush failed: %d\n", err); 378df5fa691SChristoph Hellwig 3795787cacdSChristoph Hellwig if (cmd) { 380de103c93SChristoph Hellwig if (err) 3815787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION); 382de103c93SChristoph Hellwig else 3835787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_GOOD); 3845787cacdSChristoph Hellwig } 3855787cacdSChristoph Hellwig 386df5fa691SChristoph Hellwig bio_put(bio); 387df5fa691SChristoph Hellwig } 388df5fa691SChristoph Hellwig 389c66ac9dbSNicholas Bellinger /* 390df5fa691SChristoph Hellwig * Implement SYCHRONIZE CACHE. Note that we can't handle lba ranges and must 391df5fa691SChristoph Hellwig * always flush the whole cache. 392c66ac9dbSNicholas Bellinger */ 393de103c93SChristoph Hellwig static sense_reason_t 394de103c93SChristoph Hellwig iblock_execute_sync_cache(struct se_cmd *cmd) 395c66ac9dbSNicholas Bellinger { 3960fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev); 397a1d8b49aSAndy Grover int immed = (cmd->t_task_cdb[1] & 0x2); 398df5fa691SChristoph Hellwig struct bio *bio; 399c66ac9dbSNicholas Bellinger 400c66ac9dbSNicholas Bellinger /* 401c66ac9dbSNicholas Bellinger * If the Immediate bit is set, queue up the GOOD response 402df5fa691SChristoph Hellwig * for this SYNCHRONIZE_CACHE op. 403c66ac9dbSNicholas Bellinger */ 404c66ac9dbSNicholas Bellinger if (immed) 4055787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_GOOD); 406c66ac9dbSNicholas Bellinger 407df5fa691SChristoph Hellwig bio = bio_alloc(GFP_KERNEL, 0); 408df5fa691SChristoph Hellwig bio->bi_end_io = iblock_end_io_flush; 409df5fa691SChristoph Hellwig bio->bi_bdev = ib_dev->ibd_bd; 410c66ac9dbSNicholas Bellinger if (!immed) 411df5fa691SChristoph Hellwig bio->bi_private = cmd; 412df5fa691SChristoph Hellwig submit_bio(WRITE_FLUSH, bio); 413ad67f0d9SChristoph Hellwig return 0; 414c66ac9dbSNicholas Bellinger } 415c66ac9dbSNicholas Bellinger 416de103c93SChristoph Hellwig static sense_reason_t 41786d71829SAsias He iblock_do_unmap(struct se_cmd *cmd, void *priv, 418dbc21c5aSAsias He sector_t lba, sector_t nolb) 419dbc21c5aSAsias He { 42086d71829SAsias He struct block_device *bdev = priv; 421dbc21c5aSAsias He int ret; 422dbc21c5aSAsias He 423dbc21c5aSAsias He ret = blkdev_issue_discard(bdev, lba, nolb, GFP_KERNEL, 0); 424dbc21c5aSAsias He if (ret < 0) { 425dbc21c5aSAsias He pr_err("blkdev_issue_discard() failed: %d\n", ret); 426dbc21c5aSAsias He return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 427dbc21c5aSAsias He } 428dbc21c5aSAsias He 429dbc21c5aSAsias He return 0; 430dbc21c5aSAsias He } 431dbc21c5aSAsias He 432dbc21c5aSAsias He static sense_reason_t 433de103c93SChristoph Hellwig iblock_execute_unmap(struct se_cmd *cmd) 434c66ac9dbSNicholas Bellinger { 43586d71829SAsias He struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd; 43614150a6bSChristoph Hellwig 43786d71829SAsias He return sbc_execute_unmap(cmd, iblock_do_unmap, bdev); 438c66ac9dbSNicholas Bellinger } 439c66ac9dbSNicholas Bellinger 440de103c93SChristoph Hellwig static sense_reason_t 441f6970ad3SNicholas Bellinger iblock_execute_write_same_unmap(struct se_cmd *cmd) 4426f974e8cSChristoph Hellwig { 443dbc21c5aSAsias He struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd; 444dbc21c5aSAsias He sector_t lba = cmd->t_task_lba; 445dbc21c5aSAsias He sector_t nolb = sbc_get_write_same_sectors(cmd); 446dbc21c5aSAsias He int ret; 4476f974e8cSChristoph Hellwig 448dbc21c5aSAsias He ret = iblock_do_unmap(cmd, bdev, lba, nolb); 449dbc21c5aSAsias He if (ret) 450dbc21c5aSAsias He return ret; 4516f974e8cSChristoph Hellwig 4526f974e8cSChristoph Hellwig target_complete_cmd(cmd, GOOD); 4536f974e8cSChristoph Hellwig return 0; 4546f974e8cSChristoph Hellwig } 4556f974e8cSChristoph Hellwig 456f6970ad3SNicholas Bellinger static sense_reason_t 457f6970ad3SNicholas Bellinger iblock_execute_write_same(struct se_cmd *cmd) 458f6970ad3SNicholas Bellinger { 459f6970ad3SNicholas Bellinger struct iblock_req *ibr; 460f6970ad3SNicholas Bellinger struct scatterlist *sg; 461f6970ad3SNicholas Bellinger struct bio *bio; 462f6970ad3SNicholas Bellinger struct bio_list list; 463f6970ad3SNicholas Bellinger sector_t block_lba = cmd->t_task_lba; 464972b29c8SRoland Dreier sector_t sectors = sbc_get_write_same_sectors(cmd); 465f6970ad3SNicholas Bellinger 466f6970ad3SNicholas Bellinger sg = &cmd->t_data_sg[0]; 467f6970ad3SNicholas Bellinger 468f6970ad3SNicholas Bellinger if (cmd->t_data_nents > 1 || 469f6970ad3SNicholas Bellinger sg->length != cmd->se_dev->dev_attrib.block_size) { 470f6970ad3SNicholas Bellinger pr_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u" 471f6970ad3SNicholas Bellinger " block_size: %u\n", cmd->t_data_nents, sg->length, 472f6970ad3SNicholas Bellinger cmd->se_dev->dev_attrib.block_size); 473f6970ad3SNicholas Bellinger return TCM_INVALID_CDB_FIELD; 474f6970ad3SNicholas Bellinger } 475f6970ad3SNicholas Bellinger 476f6970ad3SNicholas Bellinger ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL); 477f6970ad3SNicholas Bellinger if (!ibr) 478f6970ad3SNicholas Bellinger goto fail; 479f6970ad3SNicholas Bellinger cmd->priv = ibr; 480f6970ad3SNicholas Bellinger 481f6970ad3SNicholas Bellinger bio = iblock_get_bio(cmd, block_lba, 1); 482f6970ad3SNicholas Bellinger if (!bio) 483f6970ad3SNicholas Bellinger goto fail_free_ibr; 484f6970ad3SNicholas Bellinger 485f6970ad3SNicholas Bellinger bio_list_init(&list); 486f6970ad3SNicholas Bellinger bio_list_add(&list, bio); 487f6970ad3SNicholas Bellinger 488f6970ad3SNicholas Bellinger atomic_set(&ibr->pending, 1); 489f6970ad3SNicholas Bellinger 490f6970ad3SNicholas Bellinger while (sectors) { 491f6970ad3SNicholas Bellinger while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset) 492f6970ad3SNicholas Bellinger != sg->length) { 493f6970ad3SNicholas Bellinger 494f6970ad3SNicholas Bellinger bio = iblock_get_bio(cmd, block_lba, 1); 495f6970ad3SNicholas Bellinger if (!bio) 496f6970ad3SNicholas Bellinger goto fail_put_bios; 497f6970ad3SNicholas Bellinger 498f6970ad3SNicholas Bellinger atomic_inc(&ibr->pending); 499f6970ad3SNicholas Bellinger bio_list_add(&list, bio); 500f6970ad3SNicholas Bellinger } 501f6970ad3SNicholas Bellinger 502f6970ad3SNicholas Bellinger /* Always in 512 byte units for Linux/Block */ 503f6970ad3SNicholas Bellinger block_lba += sg->length >> IBLOCK_LBA_SHIFT; 504f6970ad3SNicholas Bellinger sectors -= 1; 505f6970ad3SNicholas Bellinger } 506f6970ad3SNicholas Bellinger 507f6970ad3SNicholas Bellinger iblock_submit_bios(&list, WRITE); 508f6970ad3SNicholas Bellinger return 0; 509f6970ad3SNicholas Bellinger 510f6970ad3SNicholas Bellinger fail_put_bios: 511f6970ad3SNicholas Bellinger while ((bio = bio_list_pop(&list))) 512f6970ad3SNicholas Bellinger bio_put(bio); 513f6970ad3SNicholas Bellinger fail_free_ibr: 514f6970ad3SNicholas Bellinger kfree(ibr); 515f6970ad3SNicholas Bellinger fail: 516f6970ad3SNicholas Bellinger return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 517f6970ad3SNicholas Bellinger } 518f6970ad3SNicholas Bellinger 519c66ac9dbSNicholas Bellinger enum { 52044bfd018SAndy Grover Opt_udev_path, Opt_readonly, Opt_force, Opt_err 521c66ac9dbSNicholas Bellinger }; 522c66ac9dbSNicholas Bellinger 523c66ac9dbSNicholas Bellinger static match_table_t tokens = { 524c66ac9dbSNicholas Bellinger {Opt_udev_path, "udev_path=%s"}, 52544bfd018SAndy Grover {Opt_readonly, "readonly=%d"}, 526c66ac9dbSNicholas Bellinger {Opt_force, "force=%d"}, 527c66ac9dbSNicholas Bellinger {Opt_err, NULL} 528c66ac9dbSNicholas Bellinger }; 529c66ac9dbSNicholas Bellinger 5300fd97ccfSChristoph Hellwig static ssize_t iblock_set_configfs_dev_params(struct se_device *dev, 531c66ac9dbSNicholas Bellinger const char *page, ssize_t count) 532c66ac9dbSNicholas Bellinger { 5330fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 5346d180253SJesper Juhl char *orig, *ptr, *arg_p, *opts; 535c66ac9dbSNicholas Bellinger substring_t args[MAX_OPT_ARGS]; 53621bca31cSRoland Dreier int ret = 0, token; 53744bfd018SAndy Grover unsigned long tmp_readonly; 538c66ac9dbSNicholas Bellinger 539c66ac9dbSNicholas Bellinger opts = kstrdup(page, GFP_KERNEL); 540c66ac9dbSNicholas Bellinger if (!opts) 541c66ac9dbSNicholas Bellinger return -ENOMEM; 542c66ac9dbSNicholas Bellinger 543c66ac9dbSNicholas Bellinger orig = opts; 544c66ac9dbSNicholas Bellinger 54590c161b6SSebastian Andrzej Siewior while ((ptr = strsep(&opts, ",\n")) != NULL) { 546c66ac9dbSNicholas Bellinger if (!*ptr) 547c66ac9dbSNicholas Bellinger continue; 548c66ac9dbSNicholas Bellinger 549c66ac9dbSNicholas Bellinger token = match_token(ptr, tokens, args); 550c66ac9dbSNicholas Bellinger switch (token) { 551c66ac9dbSNicholas Bellinger case Opt_udev_path: 552c66ac9dbSNicholas Bellinger if (ib_dev->ibd_bd) { 5536708bb27SAndy Grover pr_err("Unable to set udev_path= while" 554c66ac9dbSNicholas Bellinger " ib_dev->ibd_bd exists\n"); 555c66ac9dbSNicholas Bellinger ret = -EEXIST; 556c66ac9dbSNicholas Bellinger goto out; 557c66ac9dbSNicholas Bellinger } 558852b6ed1SNicholas Bellinger if (match_strlcpy(ib_dev->ibd_udev_path, &args[0], 559852b6ed1SNicholas Bellinger SE_UDEV_PATH_LEN) == 0) { 560852b6ed1SNicholas Bellinger ret = -EINVAL; 5616d180253SJesper Juhl break; 5626d180253SJesper Juhl } 5636708bb27SAndy Grover pr_debug("IBLOCK: Referencing UDEV path: %s\n", 564c66ac9dbSNicholas Bellinger ib_dev->ibd_udev_path); 565c66ac9dbSNicholas Bellinger ib_dev->ibd_flags |= IBDF_HAS_UDEV_PATH; 566c66ac9dbSNicholas Bellinger break; 56744bfd018SAndy Grover case Opt_readonly: 56844bfd018SAndy Grover arg_p = match_strdup(&args[0]); 56944bfd018SAndy Grover if (!arg_p) { 57044bfd018SAndy Grover ret = -ENOMEM; 57144bfd018SAndy Grover break; 57244bfd018SAndy Grover } 57357103d7fSJingoo Han ret = kstrtoul(arg_p, 0, &tmp_readonly); 57444bfd018SAndy Grover kfree(arg_p); 57544bfd018SAndy Grover if (ret < 0) { 57657103d7fSJingoo Han pr_err("kstrtoul() failed for" 57744bfd018SAndy Grover " readonly=\n"); 57844bfd018SAndy Grover goto out; 57944bfd018SAndy Grover } 58044bfd018SAndy Grover ib_dev->ibd_readonly = tmp_readonly; 58144bfd018SAndy Grover pr_debug("IBLOCK: readonly: %d\n", ib_dev->ibd_readonly); 58244bfd018SAndy Grover break; 583c66ac9dbSNicholas Bellinger case Opt_force: 584c66ac9dbSNicholas Bellinger break; 585c66ac9dbSNicholas Bellinger default: 586c66ac9dbSNicholas Bellinger break; 587c66ac9dbSNicholas Bellinger } 588c66ac9dbSNicholas Bellinger } 589c66ac9dbSNicholas Bellinger 590c66ac9dbSNicholas Bellinger out: 591c66ac9dbSNicholas Bellinger kfree(orig); 592c66ac9dbSNicholas Bellinger return (!ret) ? count : ret; 593c66ac9dbSNicholas Bellinger } 594c66ac9dbSNicholas Bellinger 5950fd97ccfSChristoph Hellwig static ssize_t iblock_show_configfs_dev_params(struct se_device *dev, char *b) 596c66ac9dbSNicholas Bellinger { 5970fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 5980fd97ccfSChristoph Hellwig struct block_device *bd = ib_dev->ibd_bd; 599c66ac9dbSNicholas Bellinger char buf[BDEVNAME_SIZE]; 600c66ac9dbSNicholas Bellinger ssize_t bl = 0; 601c66ac9dbSNicholas Bellinger 602c66ac9dbSNicholas Bellinger if (bd) 603c66ac9dbSNicholas Bellinger bl += sprintf(b + bl, "iBlock device: %s", 604c66ac9dbSNicholas Bellinger bdevname(bd, buf)); 6050fd97ccfSChristoph Hellwig if (ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH) 60644bfd018SAndy Grover bl += sprintf(b + bl, " UDEV PATH: %s", 6070fd97ccfSChristoph Hellwig ib_dev->ibd_udev_path); 6080fd97ccfSChristoph Hellwig bl += sprintf(b + bl, " readonly: %d\n", ib_dev->ibd_readonly); 609c66ac9dbSNicholas Bellinger 610c66ac9dbSNicholas Bellinger bl += sprintf(b + bl, " "); 611c66ac9dbSNicholas Bellinger if (bd) { 612c66ac9dbSNicholas Bellinger bl += sprintf(b + bl, "Major: %d Minor: %d %s\n", 61321bca31cSRoland Dreier MAJOR(bd->bd_dev), MINOR(bd->bd_dev), (!bd->bd_contains) ? 6140fd97ccfSChristoph Hellwig "" : (bd->bd_holder == ib_dev) ? 615c66ac9dbSNicholas Bellinger "CLAIMED: IBLOCK" : "CLAIMED: OS"); 616c66ac9dbSNicholas Bellinger } else { 61721bca31cSRoland Dreier bl += sprintf(b + bl, "Major: 0 Minor: 0\n"); 618c66ac9dbSNicholas Bellinger } 619c66ac9dbSNicholas Bellinger 620c66ac9dbSNicholas Bellinger return bl; 621c66ac9dbSNicholas Bellinger } 622c66ac9dbSNicholas Bellinger 623ecebbf6cSNicholas Bellinger static int 624ecebbf6cSNicholas Bellinger iblock_alloc_bip(struct se_cmd *cmd, struct bio *bio) 625ecebbf6cSNicholas Bellinger { 626ecebbf6cSNicholas Bellinger struct se_device *dev = cmd->se_dev; 627ecebbf6cSNicholas Bellinger struct blk_integrity *bi; 628ecebbf6cSNicholas Bellinger struct bio_integrity_payload *bip; 629ecebbf6cSNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 630ecebbf6cSNicholas Bellinger struct scatterlist *sg; 631ecebbf6cSNicholas Bellinger int i, rc; 632ecebbf6cSNicholas Bellinger 633ecebbf6cSNicholas Bellinger bi = bdev_get_integrity(ib_dev->ibd_bd); 634ecebbf6cSNicholas Bellinger if (!bi) { 635ecebbf6cSNicholas Bellinger pr_err("Unable to locate bio_integrity\n"); 636ecebbf6cSNicholas Bellinger return -ENODEV; 637ecebbf6cSNicholas Bellinger } 638ecebbf6cSNicholas Bellinger 639ecebbf6cSNicholas Bellinger bip = bio_integrity_alloc(bio, GFP_NOIO, cmd->t_prot_nents); 640ecebbf6cSNicholas Bellinger if (!bip) { 641ecebbf6cSNicholas Bellinger pr_err("Unable to allocate bio_integrity_payload\n"); 642ecebbf6cSNicholas Bellinger return -ENOMEM; 643ecebbf6cSNicholas Bellinger } 644ecebbf6cSNicholas Bellinger 6454e13c5d0SLinus Torvalds bip->bip_iter.bi_size = (cmd->data_length / dev->dev_attrib.block_size) * 646ecebbf6cSNicholas Bellinger dev->prot_length; 6474e13c5d0SLinus Torvalds bip->bip_iter.bi_sector = bio->bi_iter.bi_sector; 648ecebbf6cSNicholas Bellinger 6494e13c5d0SLinus Torvalds pr_debug("IBLOCK BIP Size: %u Sector: %llu\n", bip->bip_iter.bi_size, 6504e13c5d0SLinus Torvalds (unsigned long long)bip->bip_iter.bi_sector); 651ecebbf6cSNicholas Bellinger 652ecebbf6cSNicholas Bellinger for_each_sg(cmd->t_prot_sg, sg, cmd->t_prot_nents, i) { 653ecebbf6cSNicholas Bellinger 654ecebbf6cSNicholas Bellinger rc = bio_integrity_add_page(bio, sg_page(sg), sg->length, 655ecebbf6cSNicholas Bellinger sg->offset); 656ecebbf6cSNicholas Bellinger if (rc != sg->length) { 657ecebbf6cSNicholas Bellinger pr_err("bio_integrity_add_page() failed; %d\n", rc); 658ecebbf6cSNicholas Bellinger return -ENOMEM; 659ecebbf6cSNicholas Bellinger } 660ecebbf6cSNicholas Bellinger 661ecebbf6cSNicholas Bellinger pr_debug("Added bio integrity page: %p length: %d offset; %d\n", 662ecebbf6cSNicholas Bellinger sg_page(sg), sg->length, sg->offset); 663ecebbf6cSNicholas Bellinger } 664ecebbf6cSNicholas Bellinger 665ecebbf6cSNicholas Bellinger return 0; 666ecebbf6cSNicholas Bellinger } 667ecebbf6cSNicholas Bellinger 668de103c93SChristoph Hellwig static sense_reason_t 669a82a9538SNicholas Bellinger iblock_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents, 670a82a9538SNicholas Bellinger enum dma_data_direction data_direction) 671c66ac9dbSNicholas Bellinger { 6725951146dSAndy Grover struct se_device *dev = cmd->se_dev; 6735787cacdSChristoph Hellwig struct iblock_req *ibr; 674ecebbf6cSNicholas Bellinger struct bio *bio, *bio_start; 675dbbf3e94SChristoph Hellwig struct bio_list list; 676c66ac9dbSNicholas Bellinger struct scatterlist *sg; 6775787cacdSChristoph Hellwig u32 sg_num = sgl_nents; 678c66ac9dbSNicholas Bellinger sector_t block_lba; 679d5b4a21bSChristoph Hellwig unsigned bio_cnt; 680d0c8b259SNicholas Bellinger int rw = 0; 6815787cacdSChristoph Hellwig int i; 682dbbf3e94SChristoph Hellwig 6835787cacdSChristoph Hellwig if (data_direction == DMA_TO_DEVICE) { 684d0c8b259SNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 685d0c8b259SNicholas Bellinger struct request_queue *q = bdev_get_queue(ib_dev->ibd_bd); 686dbbf3e94SChristoph Hellwig /* 687d0c8b259SNicholas Bellinger * Force writethrough using WRITE_FUA if a volatile write cache 688d0c8b259SNicholas Bellinger * is not enabled, or if initiator set the Force Unit Access bit. 689dbbf3e94SChristoph Hellwig */ 690d0c8b259SNicholas Bellinger if (q->flush_flags & REQ_FUA) { 691d0c8b259SNicholas Bellinger if (cmd->se_cmd_flags & SCF_FUA) 692dbbf3e94SChristoph Hellwig rw = WRITE_FUA; 693d0c8b259SNicholas Bellinger else if (!(q->flush_flags & REQ_FLUSH)) 694d0c8b259SNicholas Bellinger rw = WRITE_FUA; 695d2bdbee0SNicholas Bellinger else 696d2bdbee0SNicholas Bellinger rw = WRITE; 697d0c8b259SNicholas Bellinger } else { 698dbbf3e94SChristoph Hellwig rw = WRITE; 699d0c8b259SNicholas Bellinger } 700dbbf3e94SChristoph Hellwig } else { 701dbbf3e94SChristoph Hellwig rw = READ; 702dbbf3e94SChristoph Hellwig } 703dbbf3e94SChristoph Hellwig 704c66ac9dbSNicholas Bellinger /* 7055787cacdSChristoph Hellwig * Convert the blocksize advertised to the initiator to the 512 byte 7065787cacdSChristoph Hellwig * units unconditionally used by the Linux block layer. 707c66ac9dbSNicholas Bellinger */ 7080fd97ccfSChristoph Hellwig if (dev->dev_attrib.block_size == 4096) 70972a0e5e2SChristoph Hellwig block_lba = (cmd->t_task_lba << 3); 7100fd97ccfSChristoph Hellwig else if (dev->dev_attrib.block_size == 2048) 71172a0e5e2SChristoph Hellwig block_lba = (cmd->t_task_lba << 2); 7120fd97ccfSChristoph Hellwig else if (dev->dev_attrib.block_size == 1024) 71372a0e5e2SChristoph Hellwig block_lba = (cmd->t_task_lba << 1); 7140fd97ccfSChristoph Hellwig else if (dev->dev_attrib.block_size == 512) 71572a0e5e2SChristoph Hellwig block_lba = cmd->t_task_lba; 716c66ac9dbSNicholas Bellinger else { 7176708bb27SAndy Grover pr_err("Unsupported SCSI -> BLOCK LBA conversion:" 7180fd97ccfSChristoph Hellwig " %u\n", dev->dev_attrib.block_size); 719de103c93SChristoph Hellwig return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 720c66ac9dbSNicholas Bellinger } 721c66ac9dbSNicholas Bellinger 7225787cacdSChristoph Hellwig ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL); 7235787cacdSChristoph Hellwig if (!ibr) 7245787cacdSChristoph Hellwig goto fail; 7255787cacdSChristoph Hellwig cmd->priv = ibr; 7265787cacdSChristoph Hellwig 727e0de4457SPaolo Bonzini if (!sgl_nents) { 728e0de4457SPaolo Bonzini atomic_set(&ibr->pending, 1); 729e0de4457SPaolo Bonzini iblock_complete_cmd(cmd); 730e0de4457SPaolo Bonzini return 0; 731e0de4457SPaolo Bonzini } 732e0de4457SPaolo Bonzini 7335787cacdSChristoph Hellwig bio = iblock_get_bio(cmd, block_lba, sgl_nents); 7345787cacdSChristoph Hellwig if (!bio) 7355787cacdSChristoph Hellwig goto fail_free_ibr; 736c66ac9dbSNicholas Bellinger 737ecebbf6cSNicholas Bellinger bio_start = bio; 738dbbf3e94SChristoph Hellwig bio_list_init(&list); 739dbbf3e94SChristoph Hellwig bio_list_add(&list, bio); 7405787cacdSChristoph Hellwig 7415787cacdSChristoph Hellwig atomic_set(&ibr->pending, 2); 742d5b4a21bSChristoph Hellwig bio_cnt = 1; 743dbbf3e94SChristoph Hellwig 7445787cacdSChristoph Hellwig for_each_sg(sgl, sg, sgl_nents, i) { 745dbbf3e94SChristoph Hellwig /* 746dbbf3e94SChristoph Hellwig * XXX: if the length the device accepts is shorter than the 747dbbf3e94SChristoph Hellwig * length of the S/G list entry this will cause and 748dbbf3e94SChristoph Hellwig * endless loop. Better hope no driver uses huge pages. 749dbbf3e94SChristoph Hellwig */ 750dbbf3e94SChristoph Hellwig while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset) 751dbbf3e94SChristoph Hellwig != sg->length) { 752d5b4a21bSChristoph Hellwig if (bio_cnt >= IBLOCK_MAX_BIO_PER_TASK) { 753d5b4a21bSChristoph Hellwig iblock_submit_bios(&list, rw); 754d5b4a21bSChristoph Hellwig bio_cnt = 0; 755d5b4a21bSChristoph Hellwig } 756d5b4a21bSChristoph Hellwig 7575787cacdSChristoph Hellwig bio = iblock_get_bio(cmd, block_lba, sg_num); 7586708bb27SAndy Grover if (!bio) 7595787cacdSChristoph Hellwig goto fail_put_bios; 7605787cacdSChristoph Hellwig 7615787cacdSChristoph Hellwig atomic_inc(&ibr->pending); 762dbbf3e94SChristoph Hellwig bio_list_add(&list, bio); 763d5b4a21bSChristoph Hellwig bio_cnt++; 764c66ac9dbSNicholas Bellinger } 765dbbf3e94SChristoph Hellwig 766c66ac9dbSNicholas Bellinger /* Always in 512 byte units for Linux/Block */ 767c66ac9dbSNicholas Bellinger block_lba += sg->length >> IBLOCK_LBA_SHIFT; 768c66ac9dbSNicholas Bellinger sg_num--; 769c66ac9dbSNicholas Bellinger } 770c66ac9dbSNicholas Bellinger 771ecebbf6cSNicholas Bellinger if (cmd->prot_type) { 772ecebbf6cSNicholas Bellinger int rc = iblock_alloc_bip(cmd, bio_start); 773ecebbf6cSNicholas Bellinger if (rc) 774ecebbf6cSNicholas Bellinger goto fail_put_bios; 775ecebbf6cSNicholas Bellinger } 776ecebbf6cSNicholas Bellinger 777d5b4a21bSChristoph Hellwig iblock_submit_bios(&list, rw); 7785787cacdSChristoph Hellwig iblock_complete_cmd(cmd); 77903e98c9eSNicholas Bellinger return 0; 780dbbf3e94SChristoph Hellwig 7815787cacdSChristoph Hellwig fail_put_bios: 782dbbf3e94SChristoph Hellwig while ((bio = bio_list_pop(&list))) 783c66ac9dbSNicholas Bellinger bio_put(bio); 7845787cacdSChristoph Hellwig fail_free_ibr: 7855787cacdSChristoph Hellwig kfree(ibr); 7865787cacdSChristoph Hellwig fail: 787de103c93SChristoph Hellwig return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 788c66ac9dbSNicholas Bellinger } 789c66ac9dbSNicholas Bellinger 790c66ac9dbSNicholas Bellinger static sector_t iblock_get_blocks(struct se_device *dev) 791c66ac9dbSNicholas Bellinger { 7920fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 7930fd97ccfSChristoph Hellwig struct block_device *bd = ib_dev->ibd_bd; 794c66ac9dbSNicholas Bellinger struct request_queue *q = bdev_get_queue(bd); 795c66ac9dbSNicholas Bellinger 796c66ac9dbSNicholas Bellinger return iblock_emulate_read_cap_with_block_size(dev, bd, q); 797c66ac9dbSNicholas Bellinger } 798c66ac9dbSNicholas Bellinger 7997f7caf6aSAndy Grover static sector_t iblock_get_alignment_offset_lbas(struct se_device *dev) 8007f7caf6aSAndy Grover { 8017f7caf6aSAndy Grover struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 8027f7caf6aSAndy Grover struct block_device *bd = ib_dev->ibd_bd; 8037f7caf6aSAndy Grover int ret; 8047f7caf6aSAndy Grover 8057f7caf6aSAndy Grover ret = bdev_alignment_offset(bd); 8067f7caf6aSAndy Grover if (ret == -1) 8077f7caf6aSAndy Grover return 0; 8087f7caf6aSAndy Grover 8097f7caf6aSAndy Grover /* convert offset-bytes to offset-lbas */ 8107f7caf6aSAndy Grover return ret / bdev_logical_block_size(bd); 8117f7caf6aSAndy Grover } 8127f7caf6aSAndy Grover 8137f7caf6aSAndy Grover static unsigned int iblock_get_lbppbe(struct se_device *dev) 8147f7caf6aSAndy Grover { 8157f7caf6aSAndy Grover struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 8167f7caf6aSAndy Grover struct block_device *bd = ib_dev->ibd_bd; 8177f7caf6aSAndy Grover int logs_per_phys = bdev_physical_block_size(bd) / bdev_logical_block_size(bd); 8187f7caf6aSAndy Grover 8197f7caf6aSAndy Grover return ilog2(logs_per_phys); 8207f7caf6aSAndy Grover } 8217f7caf6aSAndy Grover 8227f7caf6aSAndy Grover static unsigned int iblock_get_io_min(struct se_device *dev) 8237f7caf6aSAndy Grover { 8247f7caf6aSAndy Grover struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 8257f7caf6aSAndy Grover struct block_device *bd = ib_dev->ibd_bd; 8267f7caf6aSAndy Grover 8277f7caf6aSAndy Grover return bdev_io_min(bd); 8287f7caf6aSAndy Grover } 8297f7caf6aSAndy Grover 8307f7caf6aSAndy Grover static unsigned int iblock_get_io_opt(struct se_device *dev) 8317f7caf6aSAndy Grover { 8327f7caf6aSAndy Grover struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 8337f7caf6aSAndy Grover struct block_device *bd = ib_dev->ibd_bd; 8347f7caf6aSAndy Grover 8357f7caf6aSAndy Grover return bdev_io_opt(bd); 8367f7caf6aSAndy Grover } 8377f7caf6aSAndy Grover 8389e999a6cSChristoph Hellwig static struct sbc_ops iblock_sbc_ops = { 8390c2ad7d1SChristoph Hellwig .execute_rw = iblock_execute_rw, 840ad67f0d9SChristoph Hellwig .execute_sync_cache = iblock_execute_sync_cache, 8416f974e8cSChristoph Hellwig .execute_write_same = iblock_execute_write_same, 842f6970ad3SNicholas Bellinger .execute_write_same_unmap = iblock_execute_write_same_unmap, 84314150a6bSChristoph Hellwig .execute_unmap = iblock_execute_unmap, 8440c2ad7d1SChristoph Hellwig }; 8450c2ad7d1SChristoph Hellwig 846de103c93SChristoph Hellwig static sense_reason_t 847de103c93SChristoph Hellwig iblock_parse_cdb(struct se_cmd *cmd) 8480c2ad7d1SChristoph Hellwig { 8499e999a6cSChristoph Hellwig return sbc_parse_cdb(cmd, &iblock_sbc_ops); 8500c2ad7d1SChristoph Hellwig } 8510c2ad7d1SChristoph Hellwig 852452e2010SRashika Kheria static bool iblock_get_write_cache(struct se_device *dev) 853d0c8b259SNicholas Bellinger { 854d0c8b259SNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 855d0c8b259SNicholas Bellinger struct block_device *bd = ib_dev->ibd_bd; 856d0c8b259SNicholas Bellinger struct request_queue *q = bdev_get_queue(bd); 857d0c8b259SNicholas Bellinger 858d0c8b259SNicholas Bellinger return q->flush_flags & REQ_FLUSH; 859d0c8b259SNicholas Bellinger } 860d0c8b259SNicholas Bellinger 861c66ac9dbSNicholas Bellinger static struct se_subsystem_api iblock_template = { 862c66ac9dbSNicholas Bellinger .name = "iblock", 8630fd97ccfSChristoph Hellwig .inquiry_prod = "IBLOCK", 8640fd97ccfSChristoph Hellwig .inquiry_rev = IBLOCK_VERSION, 865c66ac9dbSNicholas Bellinger .owner = THIS_MODULE, 866c66ac9dbSNicholas Bellinger .transport_type = TRANSPORT_PLUGIN_VHBA_PDEV, 867c66ac9dbSNicholas Bellinger .attach_hba = iblock_attach_hba, 868c66ac9dbSNicholas Bellinger .detach_hba = iblock_detach_hba, 8690fd97ccfSChristoph Hellwig .alloc_device = iblock_alloc_device, 8700fd97ccfSChristoph Hellwig .configure_device = iblock_configure_device, 871c66ac9dbSNicholas Bellinger .free_device = iblock_free_device, 8720c2ad7d1SChristoph Hellwig .parse_cdb = iblock_parse_cdb, 873c66ac9dbSNicholas Bellinger .set_configfs_dev_params = iblock_set_configfs_dev_params, 874c66ac9dbSNicholas Bellinger .show_configfs_dev_params = iblock_show_configfs_dev_params, 8756f23ac8aSChristoph Hellwig .get_device_type = sbc_get_device_type, 876c66ac9dbSNicholas Bellinger .get_blocks = iblock_get_blocks, 8777f7caf6aSAndy Grover .get_alignment_offset_lbas = iblock_get_alignment_offset_lbas, 8787f7caf6aSAndy Grover .get_lbppbe = iblock_get_lbppbe, 8797f7caf6aSAndy Grover .get_io_min = iblock_get_io_min, 8807f7caf6aSAndy Grover .get_io_opt = iblock_get_io_opt, 881d0c8b259SNicholas Bellinger .get_write_cache = iblock_get_write_cache, 882c66ac9dbSNicholas Bellinger }; 883c66ac9dbSNicholas Bellinger 884c66ac9dbSNicholas Bellinger static int __init iblock_module_init(void) 885c66ac9dbSNicholas Bellinger { 886c66ac9dbSNicholas Bellinger return transport_subsystem_register(&iblock_template); 887c66ac9dbSNicholas Bellinger } 888c66ac9dbSNicholas Bellinger 88963b91d5aSAsias He static void __exit iblock_module_exit(void) 890c66ac9dbSNicholas Bellinger { 891c66ac9dbSNicholas Bellinger transport_subsystem_release(&iblock_template); 892c66ac9dbSNicholas Bellinger } 893c66ac9dbSNicholas Bellinger 894c66ac9dbSNicholas Bellinger MODULE_DESCRIPTION("TCM IBLOCK subsystem plugin"); 895c66ac9dbSNicholas Bellinger MODULE_AUTHOR("nab@Linux-iSCSI.org"); 896c66ac9dbSNicholas Bellinger MODULE_LICENSE("GPL"); 897c66ac9dbSNicholas Bellinger 898c66ac9dbSNicholas Bellinger module_init(iblock_module_init); 899c66ac9dbSNicholas Bellinger module_exit(iblock_module_exit); 900