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> 445645cba0SNicholas Bellinger #include <target/target_core_backend_configfs.h> 45c66ac9dbSNicholas Bellinger 46c66ac9dbSNicholas Bellinger #include "target_core_iblock.h" 47c66ac9dbSNicholas Bellinger 48d5b4a21bSChristoph Hellwig #define IBLOCK_MAX_BIO_PER_TASK 32 /* max # of bios to submit at a time */ 49d5b4a21bSChristoph Hellwig #define IBLOCK_BIO_POOL_SIZE 128 50d5b4a21bSChristoph Hellwig 510fd97ccfSChristoph Hellwig static inline struct iblock_dev *IBLOCK_DEV(struct se_device *dev) 520fd97ccfSChristoph Hellwig { 530fd97ccfSChristoph Hellwig return container_of(dev, struct iblock_dev, dev); 540fd97ccfSChristoph Hellwig } 550fd97ccfSChristoph Hellwig 560fd97ccfSChristoph Hellwig 57c66ac9dbSNicholas Bellinger static int iblock_attach_hba(struct se_hba *hba, u32 host_id) 58c66ac9dbSNicholas Bellinger { 596708bb27SAndy Grover pr_debug("CORE_HBA[%d] - TCM iBlock HBA Driver %s on" 60c66ac9dbSNicholas Bellinger " Generic Target Core Stack %s\n", hba->hba_id, 61c66ac9dbSNicholas Bellinger IBLOCK_VERSION, TARGET_CORE_MOD_VERSION); 62c66ac9dbSNicholas Bellinger return 0; 63c66ac9dbSNicholas Bellinger } 64c66ac9dbSNicholas Bellinger 65c66ac9dbSNicholas Bellinger static void iblock_detach_hba(struct se_hba *hba) 66c66ac9dbSNicholas Bellinger { 67c66ac9dbSNicholas Bellinger } 68c66ac9dbSNicholas Bellinger 690fd97ccfSChristoph Hellwig static struct se_device *iblock_alloc_device(struct se_hba *hba, const char *name) 70c66ac9dbSNicholas Bellinger { 71c66ac9dbSNicholas Bellinger struct iblock_dev *ib_dev = NULL; 72c66ac9dbSNicholas Bellinger 73c66ac9dbSNicholas Bellinger ib_dev = kzalloc(sizeof(struct iblock_dev), GFP_KERNEL); 746708bb27SAndy Grover if (!ib_dev) { 756708bb27SAndy Grover pr_err("Unable to allocate struct iblock_dev\n"); 76c66ac9dbSNicholas Bellinger return NULL; 77c66ac9dbSNicholas Bellinger } 78c66ac9dbSNicholas Bellinger 796708bb27SAndy Grover pr_debug( "IBLOCK: Allocated ib_dev for %s\n", name); 80c66ac9dbSNicholas Bellinger 810fd97ccfSChristoph Hellwig return &ib_dev->dev; 82c66ac9dbSNicholas Bellinger } 83c66ac9dbSNicholas Bellinger 840fd97ccfSChristoph Hellwig static int iblock_configure_device(struct se_device *dev) 85c66ac9dbSNicholas Bellinger { 860fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 87c66ac9dbSNicholas Bellinger struct request_queue *q; 880fd97ccfSChristoph Hellwig struct block_device *bd = NULL; 89ecebbf6cSNicholas Bellinger struct blk_integrity *bi; 9044bfd018SAndy Grover fmode_t mode; 910fd97ccfSChristoph Hellwig int ret = -ENOMEM; 92c66ac9dbSNicholas Bellinger 930fd97ccfSChristoph Hellwig if (!(ib_dev->ibd_flags & IBDF_HAS_UDEV_PATH)) { 940fd97ccfSChristoph Hellwig pr_err("Missing udev_path= parameters for IBLOCK\n"); 950fd97ccfSChristoph Hellwig return -EINVAL; 96c66ac9dbSNicholas Bellinger } 97d5b4a21bSChristoph Hellwig 98d5b4a21bSChristoph Hellwig ib_dev->ibd_bio_set = bioset_create(IBLOCK_BIO_POOL_SIZE, 0); 996708bb27SAndy Grover if (!ib_dev->ibd_bio_set) { 1000fd97ccfSChristoph Hellwig pr_err("IBLOCK: Unable to create bioset\n"); 1010fd97ccfSChristoph Hellwig goto out; 102c66ac9dbSNicholas Bellinger } 1030fd97ccfSChristoph Hellwig 1046708bb27SAndy Grover pr_debug( "IBLOCK: Claiming struct block_device: %s\n", 105c66ac9dbSNicholas Bellinger ib_dev->ibd_udev_path); 106c66ac9dbSNicholas Bellinger 10744bfd018SAndy Grover mode = FMODE_READ|FMODE_EXCL; 10844bfd018SAndy Grover if (!ib_dev->ibd_readonly) 10944bfd018SAndy Grover mode |= FMODE_WRITE; 11044bfd018SAndy Grover 11144bfd018SAndy Grover bd = blkdev_get_by_path(ib_dev->ibd_udev_path, mode, ib_dev); 112613640e4SNicholas Bellinger if (IS_ERR(bd)) { 113613640e4SNicholas Bellinger ret = PTR_ERR(bd); 1140fd97ccfSChristoph Hellwig goto out_free_bioset; 115613640e4SNicholas Bellinger } 116c66ac9dbSNicholas Bellinger ib_dev->ibd_bd = bd; 117c66ac9dbSNicholas Bellinger 1180fd97ccfSChristoph Hellwig q = bdev_get_queue(bd); 1190fd97ccfSChristoph Hellwig 1200fd97ccfSChristoph Hellwig dev->dev_attrib.hw_block_size = bdev_logical_block_size(bd); 121046ba642SNicholas Bellinger dev->dev_attrib.hw_max_sectors = queue_max_hw_sectors(q); 1220fd97ccfSChristoph Hellwig dev->dev_attrib.hw_queue_depth = q->nr_requests; 123c66ac9dbSNicholas Bellinger 124c66ac9dbSNicholas Bellinger /* 125c66ac9dbSNicholas Bellinger * Check if the underlying struct block_device request_queue supports 126c66ac9dbSNicholas Bellinger * the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM 127c66ac9dbSNicholas Bellinger * in ATA and we need to set TPE=1 128c66ac9dbSNicholas Bellinger */ 129613640e4SNicholas Bellinger if (blk_queue_discard(q)) { 1300fd97ccfSChristoph Hellwig dev->dev_attrib.max_unmap_lba_count = 131c66ac9dbSNicholas Bellinger q->limits.max_discard_sectors; 1320fd97ccfSChristoph Hellwig 133c66ac9dbSNicholas Bellinger /* 134c66ac9dbSNicholas Bellinger * Currently hardcoded to 1 in Linux/SCSI code.. 135c66ac9dbSNicholas Bellinger */ 1360fd97ccfSChristoph Hellwig dev->dev_attrib.max_unmap_block_desc_count = 1; 1370fd97ccfSChristoph Hellwig dev->dev_attrib.unmap_granularity = 1387347b5ffSMarco Sanvido q->limits.discard_granularity >> 9; 1390fd97ccfSChristoph Hellwig dev->dev_attrib.unmap_granularity_alignment = 140c66ac9dbSNicholas Bellinger q->limits.discard_alignment; 141c66ac9dbSNicholas Bellinger 1426708bb27SAndy Grover pr_debug("IBLOCK: BLOCK Discard support available," 143c66ac9dbSNicholas Bellinger " disabled by default\n"); 144c66ac9dbSNicholas Bellinger } 145f6970ad3SNicholas Bellinger /* 146f6970ad3SNicholas Bellinger * Enable write same emulation for IBLOCK and use 0xFFFF as 147f6970ad3SNicholas Bellinger * the smaller WRITE_SAME(10) only has a two-byte block count. 148f6970ad3SNicholas Bellinger */ 149f6970ad3SNicholas Bellinger dev->dev_attrib.max_write_same_len = 0xFFFF; 150c66ac9dbSNicholas Bellinger 151e22a7f07SRoland Dreier if (blk_queue_nonrot(q)) 1520fd97ccfSChristoph Hellwig dev->dev_attrib.is_nonrot = 1; 153d0c8b259SNicholas Bellinger 154ecebbf6cSNicholas Bellinger bi = bdev_get_integrity(bd); 155ecebbf6cSNicholas Bellinger if (bi) { 156ecebbf6cSNicholas Bellinger struct bio_set *bs = ib_dev->ibd_bio_set; 157ecebbf6cSNicholas Bellinger 158ecebbf6cSNicholas Bellinger if (!strcmp(bi->name, "T10-DIF-TYPE3-IP") || 159ecebbf6cSNicholas Bellinger !strcmp(bi->name, "T10-DIF-TYPE1-IP")) { 160ecebbf6cSNicholas Bellinger pr_err("IBLOCK export of blk_integrity: %s not" 161ecebbf6cSNicholas Bellinger " supported\n", bi->name); 162ecebbf6cSNicholas Bellinger ret = -ENOSYS; 163ecebbf6cSNicholas Bellinger goto out_blkdev_put; 164ecebbf6cSNicholas Bellinger } 165ecebbf6cSNicholas Bellinger 166ecebbf6cSNicholas Bellinger if (!strcmp(bi->name, "T10-DIF-TYPE3-CRC")) { 167ecebbf6cSNicholas Bellinger dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE3_PROT; 168ecebbf6cSNicholas Bellinger } else if (!strcmp(bi->name, "T10-DIF-TYPE1-CRC")) { 169ecebbf6cSNicholas Bellinger dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE1_PROT; 170ecebbf6cSNicholas Bellinger } 171ecebbf6cSNicholas Bellinger 172ecebbf6cSNicholas Bellinger if (dev->dev_attrib.pi_prot_type) { 173ecebbf6cSNicholas Bellinger if (bioset_integrity_create(bs, IBLOCK_BIO_POOL_SIZE) < 0) { 174ecebbf6cSNicholas Bellinger pr_err("Unable to allocate bioset for PI\n"); 175ecebbf6cSNicholas Bellinger ret = -ENOMEM; 176ecebbf6cSNicholas Bellinger goto out_blkdev_put; 177ecebbf6cSNicholas Bellinger } 178ecebbf6cSNicholas Bellinger pr_debug("IBLOCK setup BIP bs->bio_integrity_pool: %p\n", 179ecebbf6cSNicholas Bellinger bs->bio_integrity_pool); 180ecebbf6cSNicholas Bellinger } 181ecebbf6cSNicholas Bellinger dev->dev_attrib.hw_pi_prot_type = dev->dev_attrib.pi_prot_type; 182ecebbf6cSNicholas Bellinger } 183ecebbf6cSNicholas Bellinger 1840fd97ccfSChristoph Hellwig return 0; 185e22a7f07SRoland Dreier 186ecebbf6cSNicholas Bellinger out_blkdev_put: 187ecebbf6cSNicholas Bellinger blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL); 1880fd97ccfSChristoph Hellwig out_free_bioset: 189c66ac9dbSNicholas Bellinger bioset_free(ib_dev->ibd_bio_set); 190c66ac9dbSNicholas Bellinger ib_dev->ibd_bio_set = NULL; 1910fd97ccfSChristoph Hellwig out: 1920fd97ccfSChristoph Hellwig return ret; 193c66ac9dbSNicholas Bellinger } 194c66ac9dbSNicholas Bellinger 1950fd97ccfSChristoph Hellwig static void iblock_free_device(struct se_device *dev) 196c66ac9dbSNicholas Bellinger { 1970fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(dev); 198c66ac9dbSNicholas Bellinger 199bc665524SNicholas Bellinger if (ib_dev->ibd_bd != NULL) 200c66ac9dbSNicholas Bellinger blkdev_put(ib_dev->ibd_bd, FMODE_WRITE|FMODE_READ|FMODE_EXCL); 201d84287bcSNicholas Bellinger if (ib_dev->ibd_bio_set != NULL) 202c66ac9dbSNicholas Bellinger bioset_free(ib_dev->ibd_bio_set); 203d84287bcSNicholas Bellinger 204c66ac9dbSNicholas Bellinger kfree(ib_dev); 205c66ac9dbSNicholas Bellinger } 206c66ac9dbSNicholas Bellinger 207c66ac9dbSNicholas Bellinger static unsigned long long iblock_emulate_read_cap_with_block_size( 208c66ac9dbSNicholas Bellinger struct se_device *dev, 209c66ac9dbSNicholas Bellinger struct block_device *bd, 210c66ac9dbSNicholas Bellinger struct request_queue *q) 211c66ac9dbSNicholas Bellinger { 212c66ac9dbSNicholas Bellinger unsigned long long blocks_long = (div_u64(i_size_read(bd->bd_inode), 213c66ac9dbSNicholas Bellinger bdev_logical_block_size(bd)) - 1); 214c66ac9dbSNicholas Bellinger u32 block_size = bdev_logical_block_size(bd); 215c66ac9dbSNicholas Bellinger 2160fd97ccfSChristoph Hellwig if (block_size == dev->dev_attrib.block_size) 217c66ac9dbSNicholas Bellinger return blocks_long; 218c66ac9dbSNicholas Bellinger 219c66ac9dbSNicholas Bellinger switch (block_size) { 220c66ac9dbSNicholas Bellinger case 4096: 2210fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 222c66ac9dbSNicholas Bellinger case 2048: 223c66ac9dbSNicholas Bellinger blocks_long <<= 1; 224c66ac9dbSNicholas Bellinger break; 225c66ac9dbSNicholas Bellinger case 1024: 226c66ac9dbSNicholas Bellinger blocks_long <<= 2; 227c66ac9dbSNicholas Bellinger break; 228c66ac9dbSNicholas Bellinger case 512: 229c66ac9dbSNicholas Bellinger blocks_long <<= 3; 230c66ac9dbSNicholas Bellinger default: 231c66ac9dbSNicholas Bellinger break; 232c66ac9dbSNicholas Bellinger } 233c66ac9dbSNicholas Bellinger break; 234c66ac9dbSNicholas Bellinger case 2048: 2350fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 236c66ac9dbSNicholas Bellinger case 4096: 237c66ac9dbSNicholas Bellinger blocks_long >>= 1; 238c66ac9dbSNicholas Bellinger break; 239c66ac9dbSNicholas Bellinger case 1024: 240c66ac9dbSNicholas Bellinger blocks_long <<= 1; 241c66ac9dbSNicholas Bellinger break; 242c66ac9dbSNicholas Bellinger case 512: 243c66ac9dbSNicholas Bellinger blocks_long <<= 2; 244c66ac9dbSNicholas Bellinger break; 245c66ac9dbSNicholas Bellinger default: 246c66ac9dbSNicholas Bellinger break; 247c66ac9dbSNicholas Bellinger } 248c66ac9dbSNicholas Bellinger break; 249c66ac9dbSNicholas Bellinger case 1024: 2500fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 251c66ac9dbSNicholas Bellinger case 4096: 252c66ac9dbSNicholas Bellinger blocks_long >>= 2; 253c66ac9dbSNicholas Bellinger break; 254c66ac9dbSNicholas Bellinger case 2048: 255c66ac9dbSNicholas Bellinger blocks_long >>= 1; 256c66ac9dbSNicholas Bellinger break; 257c66ac9dbSNicholas Bellinger case 512: 258c66ac9dbSNicholas Bellinger blocks_long <<= 1; 259c66ac9dbSNicholas Bellinger break; 260c66ac9dbSNicholas Bellinger default: 261c66ac9dbSNicholas Bellinger break; 262c66ac9dbSNicholas Bellinger } 263c66ac9dbSNicholas Bellinger break; 264c66ac9dbSNicholas Bellinger case 512: 2650fd97ccfSChristoph Hellwig switch (dev->dev_attrib.block_size) { 266c66ac9dbSNicholas Bellinger case 4096: 267c66ac9dbSNicholas Bellinger blocks_long >>= 3; 268c66ac9dbSNicholas Bellinger break; 269c66ac9dbSNicholas Bellinger case 2048: 270c66ac9dbSNicholas Bellinger blocks_long >>= 2; 271c66ac9dbSNicholas Bellinger break; 272c66ac9dbSNicholas Bellinger case 1024: 273c66ac9dbSNicholas Bellinger blocks_long >>= 1; 274c66ac9dbSNicholas Bellinger break; 275c66ac9dbSNicholas Bellinger default: 276c66ac9dbSNicholas Bellinger break; 277c66ac9dbSNicholas Bellinger } 278c66ac9dbSNicholas Bellinger break; 279c66ac9dbSNicholas Bellinger default: 280c66ac9dbSNicholas Bellinger break; 281c66ac9dbSNicholas Bellinger } 282c66ac9dbSNicholas Bellinger 283c66ac9dbSNicholas Bellinger return blocks_long; 284c66ac9dbSNicholas Bellinger } 285c66ac9dbSNicholas Bellinger 2863a41d85fSNicholas Bellinger static void iblock_complete_cmd(struct se_cmd *cmd) 2873a41d85fSNicholas Bellinger { 2883a41d85fSNicholas Bellinger struct iblock_req *ibr = cmd->priv; 2893a41d85fSNicholas Bellinger u8 status; 2903a41d85fSNicholas Bellinger 2913a41d85fSNicholas Bellinger if (!atomic_dec_and_test(&ibr->pending)) 2923a41d85fSNicholas Bellinger return; 2933a41d85fSNicholas Bellinger 2943a41d85fSNicholas Bellinger if (atomic_read(&ibr->ib_bio_err_cnt)) 2953a41d85fSNicholas Bellinger status = SAM_STAT_CHECK_CONDITION; 2963a41d85fSNicholas Bellinger else 2973a41d85fSNicholas Bellinger status = SAM_STAT_GOOD; 2983a41d85fSNicholas Bellinger 2993a41d85fSNicholas Bellinger target_complete_cmd(cmd, status); 3003a41d85fSNicholas Bellinger kfree(ibr); 3013a41d85fSNicholas Bellinger } 3023a41d85fSNicholas Bellinger 3033a41d85fSNicholas Bellinger static void iblock_bio_done(struct bio *bio, int err) 3043a41d85fSNicholas Bellinger { 3053a41d85fSNicholas Bellinger struct se_cmd *cmd = bio->bi_private; 3063a41d85fSNicholas Bellinger struct iblock_req *ibr = cmd->priv; 3073a41d85fSNicholas Bellinger 3083a41d85fSNicholas Bellinger /* 3093a41d85fSNicholas Bellinger * Set -EIO if !BIO_UPTODATE and the passed is still err=0 3103a41d85fSNicholas Bellinger */ 3113a41d85fSNicholas Bellinger if (!test_bit(BIO_UPTODATE, &bio->bi_flags) && !err) 3123a41d85fSNicholas Bellinger err = -EIO; 3133a41d85fSNicholas Bellinger 3143a41d85fSNicholas Bellinger if (err != 0) { 3153a41d85fSNicholas Bellinger pr_err("test_bit(BIO_UPTODATE) failed for bio: %p," 3163a41d85fSNicholas Bellinger " err: %d\n", bio, err); 3173a41d85fSNicholas Bellinger /* 3183a41d85fSNicholas Bellinger * Bump the ib_bio_err_cnt and release bio. 3193a41d85fSNicholas Bellinger */ 3203a41d85fSNicholas Bellinger atomic_inc(&ibr->ib_bio_err_cnt); 3214e857c58SPeter Zijlstra smp_mb__after_atomic(); 3223a41d85fSNicholas Bellinger } 3233a41d85fSNicholas Bellinger 3243a41d85fSNicholas Bellinger bio_put(bio); 3253a41d85fSNicholas Bellinger 3263a41d85fSNicholas Bellinger iblock_complete_cmd(cmd); 3273a41d85fSNicholas Bellinger } 3283a41d85fSNicholas Bellinger 3293a41d85fSNicholas Bellinger static struct bio * 3303a41d85fSNicholas Bellinger iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num) 3313a41d85fSNicholas Bellinger { 3323a41d85fSNicholas Bellinger struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev); 3333a41d85fSNicholas Bellinger struct bio *bio; 3343a41d85fSNicholas Bellinger 3353a41d85fSNicholas Bellinger /* 3363a41d85fSNicholas Bellinger * Only allocate as many vector entries as the bio code allows us to, 3373a41d85fSNicholas Bellinger * we'll loop later on until we have handled the whole request. 3383a41d85fSNicholas Bellinger */ 3393a41d85fSNicholas Bellinger if (sg_num > BIO_MAX_PAGES) 3403a41d85fSNicholas Bellinger sg_num = BIO_MAX_PAGES; 3413a41d85fSNicholas Bellinger 3423a41d85fSNicholas Bellinger bio = bio_alloc_bioset(GFP_NOIO, sg_num, ib_dev->ibd_bio_set); 3433a41d85fSNicholas Bellinger if (!bio) { 3443a41d85fSNicholas Bellinger pr_err("Unable to allocate memory for bio\n"); 3453a41d85fSNicholas Bellinger return NULL; 3463a41d85fSNicholas Bellinger } 3473a41d85fSNicholas Bellinger 3483a41d85fSNicholas Bellinger bio->bi_bdev = ib_dev->ibd_bd; 3493a41d85fSNicholas Bellinger bio->bi_private = cmd; 3503a41d85fSNicholas Bellinger bio->bi_end_io = &iblock_bio_done; 3514f024f37SKent Overstreet bio->bi_iter.bi_sector = lba; 3523a41d85fSNicholas Bellinger 3533a41d85fSNicholas Bellinger return bio; 3543a41d85fSNicholas Bellinger } 3553a41d85fSNicholas Bellinger 3563a41d85fSNicholas Bellinger static void iblock_submit_bios(struct bio_list *list, int rw) 3573a41d85fSNicholas Bellinger { 3583a41d85fSNicholas Bellinger struct blk_plug plug; 3593a41d85fSNicholas Bellinger struct bio *bio; 3603a41d85fSNicholas Bellinger 3613a41d85fSNicholas Bellinger blk_start_plug(&plug); 3623a41d85fSNicholas Bellinger while ((bio = bio_list_pop(list))) 3633a41d85fSNicholas Bellinger submit_bio(rw, bio); 3643a41d85fSNicholas Bellinger blk_finish_plug(&plug); 3653a41d85fSNicholas Bellinger } 3663a41d85fSNicholas Bellinger 367df5fa691SChristoph Hellwig static void iblock_end_io_flush(struct bio *bio, int err) 368df5fa691SChristoph Hellwig { 369df5fa691SChristoph Hellwig struct se_cmd *cmd = bio->bi_private; 370df5fa691SChristoph Hellwig 371df5fa691SChristoph Hellwig if (err) 372df5fa691SChristoph Hellwig pr_err("IBLOCK: cache flush failed: %d\n", err); 373df5fa691SChristoph Hellwig 3745787cacdSChristoph Hellwig if (cmd) { 375de103c93SChristoph Hellwig if (err) 3765787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION); 377de103c93SChristoph Hellwig else 3785787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_GOOD); 3795787cacdSChristoph Hellwig } 3805787cacdSChristoph Hellwig 381df5fa691SChristoph Hellwig bio_put(bio); 382df5fa691SChristoph Hellwig } 383df5fa691SChristoph Hellwig 384c66ac9dbSNicholas Bellinger /* 385df5fa691SChristoph Hellwig * Implement SYCHRONIZE CACHE. Note that we can't handle lba ranges and must 386df5fa691SChristoph Hellwig * always flush the whole cache. 387c66ac9dbSNicholas Bellinger */ 388de103c93SChristoph Hellwig static sense_reason_t 389de103c93SChristoph Hellwig iblock_execute_sync_cache(struct se_cmd *cmd) 390c66ac9dbSNicholas Bellinger { 3910fd97ccfSChristoph Hellwig struct iblock_dev *ib_dev = IBLOCK_DEV(cmd->se_dev); 392a1d8b49aSAndy Grover int immed = (cmd->t_task_cdb[1] & 0x2); 393df5fa691SChristoph Hellwig struct bio *bio; 394c66ac9dbSNicholas Bellinger 395c66ac9dbSNicholas Bellinger /* 396c66ac9dbSNicholas Bellinger * If the Immediate bit is set, queue up the GOOD response 397df5fa691SChristoph Hellwig * for this SYNCHRONIZE_CACHE op. 398c66ac9dbSNicholas Bellinger */ 399c66ac9dbSNicholas Bellinger if (immed) 4005787cacdSChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_GOOD); 401c66ac9dbSNicholas Bellinger 402df5fa691SChristoph Hellwig bio = bio_alloc(GFP_KERNEL, 0); 403df5fa691SChristoph Hellwig bio->bi_end_io = iblock_end_io_flush; 404df5fa691SChristoph Hellwig bio->bi_bdev = ib_dev->ibd_bd; 405c66ac9dbSNicholas Bellinger if (!immed) 406df5fa691SChristoph Hellwig bio->bi_private = cmd; 407df5fa691SChristoph Hellwig submit_bio(WRITE_FLUSH, bio); 408ad67f0d9SChristoph Hellwig return 0; 409c66ac9dbSNicholas Bellinger } 410c66ac9dbSNicholas Bellinger 411de103c93SChristoph Hellwig static sense_reason_t 41286d71829SAsias He iblock_do_unmap(struct se_cmd *cmd, void *priv, 413dbc21c5aSAsias He sector_t lba, sector_t nolb) 414dbc21c5aSAsias He { 41586d71829SAsias He struct block_device *bdev = priv; 416dbc21c5aSAsias He int ret; 417dbc21c5aSAsias He 418dbc21c5aSAsias He ret = blkdev_issue_discard(bdev, lba, nolb, GFP_KERNEL, 0); 419dbc21c5aSAsias He if (ret < 0) { 420dbc21c5aSAsias He pr_err("blkdev_issue_discard() failed: %d\n", ret); 421dbc21c5aSAsias He return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 422dbc21c5aSAsias He } 423dbc21c5aSAsias He 424dbc21c5aSAsias He return 0; 425dbc21c5aSAsias He } 426dbc21c5aSAsias He 427dbc21c5aSAsias He static sense_reason_t 428de103c93SChristoph Hellwig iblock_execute_unmap(struct se_cmd *cmd) 429c66ac9dbSNicholas Bellinger { 43086d71829SAsias He struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd; 43114150a6bSChristoph Hellwig 43286d71829SAsias He return sbc_execute_unmap(cmd, iblock_do_unmap, bdev); 433c66ac9dbSNicholas Bellinger } 434c66ac9dbSNicholas Bellinger 435de103c93SChristoph Hellwig static sense_reason_t 436f6970ad3SNicholas Bellinger iblock_execute_write_same_unmap(struct se_cmd *cmd) 4376f974e8cSChristoph Hellwig { 438dbc21c5aSAsias He struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd; 439dbc21c5aSAsias He sector_t lba = cmd->t_task_lba; 440dbc21c5aSAsias He sector_t nolb = sbc_get_write_same_sectors(cmd); 4413abff1e5SChristoph Hellwig sense_reason_t ret; 4426f974e8cSChristoph Hellwig 443dbc21c5aSAsias He ret = iblock_do_unmap(cmd, bdev, lba, nolb); 444dbc21c5aSAsias He if (ret) 445dbc21c5aSAsias He return ret; 4466f974e8cSChristoph Hellwig 4476f974e8cSChristoph Hellwig target_complete_cmd(cmd, GOOD); 4486f974e8cSChristoph Hellwig return 0; 4496f974e8cSChristoph Hellwig } 4506f974e8cSChristoph Hellwig 451f6970ad3SNicholas Bellinger static sense_reason_t 452f6970ad3SNicholas Bellinger iblock_execute_write_same(struct se_cmd *cmd) 453f6970ad3SNicholas Bellinger { 454f6970ad3SNicholas Bellinger struct iblock_req *ibr; 455f6970ad3SNicholas Bellinger struct scatterlist *sg; 456f6970ad3SNicholas Bellinger struct bio *bio; 457f6970ad3SNicholas Bellinger struct bio_list list; 458f6970ad3SNicholas Bellinger sector_t block_lba = cmd->t_task_lba; 459972b29c8SRoland Dreier sector_t sectors = sbc_get_write_same_sectors(cmd); 460f6970ad3SNicholas Bellinger 461afd73f1bSNicholas Bellinger if (cmd->prot_op) { 462afd73f1bSNicholas Bellinger pr_err("WRITE_SAME: Protection information with IBLOCK" 463afd73f1bSNicholas Bellinger " backends not supported\n"); 464afd73f1bSNicholas Bellinger return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 465afd73f1bSNicholas 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 7716f16ec43SNicholas Bellinger if (cmd->prot_type && dev->dev_attrib.pi_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 8615645cba0SNicholas Bellinger DEF_TB_DEFAULT_ATTRIBS(iblock); 8625645cba0SNicholas Bellinger 8635645cba0SNicholas Bellinger static struct configfs_attribute *iblock_backend_dev_attrs[] = { 8645645cba0SNicholas Bellinger &iblock_dev_attrib_emulate_model_alias.attr, 8655645cba0SNicholas Bellinger &iblock_dev_attrib_emulate_dpo.attr, 8665645cba0SNicholas Bellinger &iblock_dev_attrib_emulate_fua_write.attr, 8675645cba0SNicholas Bellinger &iblock_dev_attrib_emulate_fua_read.attr, 8685645cba0SNicholas Bellinger &iblock_dev_attrib_emulate_write_cache.attr, 8695645cba0SNicholas Bellinger &iblock_dev_attrib_emulate_ua_intlck_ctrl.attr, 8705645cba0SNicholas Bellinger &iblock_dev_attrib_emulate_tas.attr, 8715645cba0SNicholas Bellinger &iblock_dev_attrib_emulate_tpu.attr, 8725645cba0SNicholas Bellinger &iblock_dev_attrib_emulate_tpws.attr, 8735645cba0SNicholas Bellinger &iblock_dev_attrib_emulate_caw.attr, 8745645cba0SNicholas Bellinger &iblock_dev_attrib_emulate_3pc.attr, 8755645cba0SNicholas Bellinger &iblock_dev_attrib_pi_prot_type.attr, 8765645cba0SNicholas Bellinger &iblock_dev_attrib_hw_pi_prot_type.attr, 8775645cba0SNicholas Bellinger &iblock_dev_attrib_pi_prot_format.attr, 8785645cba0SNicholas Bellinger &iblock_dev_attrib_enforce_pr_isids.attr, 8795645cba0SNicholas Bellinger &iblock_dev_attrib_is_nonrot.attr, 8805645cba0SNicholas Bellinger &iblock_dev_attrib_emulate_rest_reord.attr, 8815645cba0SNicholas Bellinger &iblock_dev_attrib_force_pr_aptpl.attr, 8825645cba0SNicholas Bellinger &iblock_dev_attrib_hw_block_size.attr, 8835645cba0SNicholas Bellinger &iblock_dev_attrib_block_size.attr, 8845645cba0SNicholas Bellinger &iblock_dev_attrib_hw_max_sectors.attr, 8855645cba0SNicholas Bellinger &iblock_dev_attrib_optimal_sectors.attr, 8865645cba0SNicholas Bellinger &iblock_dev_attrib_hw_queue_depth.attr, 8875645cba0SNicholas Bellinger &iblock_dev_attrib_queue_depth.attr, 8885645cba0SNicholas Bellinger &iblock_dev_attrib_max_unmap_lba_count.attr, 8895645cba0SNicholas Bellinger &iblock_dev_attrib_max_unmap_block_desc_count.attr, 8905645cba0SNicholas Bellinger &iblock_dev_attrib_unmap_granularity.attr, 8915645cba0SNicholas Bellinger &iblock_dev_attrib_unmap_granularity_alignment.attr, 8925645cba0SNicholas Bellinger &iblock_dev_attrib_max_write_same_len.attr, 8935645cba0SNicholas Bellinger NULL, 8945645cba0SNicholas Bellinger }; 895d30cd123SNicholas Bellinger 8960a06d430SChristoph Hellwig static const struct target_backend_ops iblock_ops = { 897c66ac9dbSNicholas Bellinger .name = "iblock", 8980fd97ccfSChristoph Hellwig .inquiry_prod = "IBLOCK", 8990fd97ccfSChristoph Hellwig .inquiry_rev = IBLOCK_VERSION, 900c66ac9dbSNicholas Bellinger .owner = THIS_MODULE, 901c66ac9dbSNicholas Bellinger .attach_hba = iblock_attach_hba, 902c66ac9dbSNicholas Bellinger .detach_hba = iblock_detach_hba, 9030fd97ccfSChristoph Hellwig .alloc_device = iblock_alloc_device, 9040fd97ccfSChristoph Hellwig .configure_device = iblock_configure_device, 905c66ac9dbSNicholas Bellinger .free_device = iblock_free_device, 9060c2ad7d1SChristoph Hellwig .parse_cdb = iblock_parse_cdb, 907c66ac9dbSNicholas Bellinger .set_configfs_dev_params = iblock_set_configfs_dev_params, 908c66ac9dbSNicholas Bellinger .show_configfs_dev_params = iblock_show_configfs_dev_params, 9096f23ac8aSChristoph Hellwig .get_device_type = sbc_get_device_type, 910c66ac9dbSNicholas Bellinger .get_blocks = iblock_get_blocks, 9117f7caf6aSAndy Grover .get_alignment_offset_lbas = iblock_get_alignment_offset_lbas, 9127f7caf6aSAndy Grover .get_lbppbe = iblock_get_lbppbe, 9137f7caf6aSAndy Grover .get_io_min = iblock_get_io_min, 9147f7caf6aSAndy Grover .get_io_opt = iblock_get_io_opt, 915d0c8b259SNicholas Bellinger .get_write_cache = iblock_get_write_cache, 9160a06d430SChristoph Hellwig .tb_dev_attrib_attrs = iblock_backend_dev_attrs, 917c66ac9dbSNicholas Bellinger }; 918c66ac9dbSNicholas Bellinger 919c66ac9dbSNicholas Bellinger static int __init iblock_module_init(void) 920c66ac9dbSNicholas Bellinger { 9210a06d430SChristoph Hellwig return transport_backend_register(&iblock_ops); 922c66ac9dbSNicholas Bellinger } 923c66ac9dbSNicholas Bellinger 92463b91d5aSAsias He static void __exit iblock_module_exit(void) 925c66ac9dbSNicholas Bellinger { 9260a06d430SChristoph Hellwig target_backend_unregister(&iblock_ops); 927c66ac9dbSNicholas Bellinger } 928c66ac9dbSNicholas Bellinger 929c66ac9dbSNicholas Bellinger MODULE_DESCRIPTION("TCM IBLOCK subsystem plugin"); 930c66ac9dbSNicholas Bellinger MODULE_AUTHOR("nab@Linux-iSCSI.org"); 931c66ac9dbSNicholas Bellinger MODULE_LICENSE("GPL"); 932c66ac9dbSNicholas Bellinger 933c66ac9dbSNicholas Bellinger module_init(iblock_module_init); 934c66ac9dbSNicholas Bellinger module_exit(iblock_module_exit); 935