1d6e0175cSChristoph Hellwig /* 2d6e0175cSChristoph Hellwig * SCSI Block Commands (SBC) parsing and emulation. 3d6e0175cSChristoph Hellwig * 4d6e0175cSChristoph Hellwig * Copyright (c) 2002, 2003, 2004, 2005 PyX Technologies, Inc. 5d6e0175cSChristoph Hellwig * Copyright (c) 2005, 2006, 2007 SBE, Inc. 6d6e0175cSChristoph Hellwig * Copyright (c) 2007-2010 Rising Tide Systems 7d6e0175cSChristoph Hellwig * Copyright (c) 2008-2010 Linux-iSCSI.org 8d6e0175cSChristoph Hellwig * 9d6e0175cSChristoph Hellwig * Nicholas A. Bellinger <nab@kernel.org> 10d6e0175cSChristoph Hellwig * 11d6e0175cSChristoph Hellwig * This program is free software; you can redistribute it and/or modify 12d6e0175cSChristoph Hellwig * it under the terms of the GNU General Public License as published by 13d6e0175cSChristoph Hellwig * the Free Software Foundation; either version 2 of the License, or 14d6e0175cSChristoph Hellwig * (at your option) any later version. 15d6e0175cSChristoph Hellwig * 16d6e0175cSChristoph Hellwig * This program is distributed in the hope that it will be useful, 17d6e0175cSChristoph Hellwig * but WITHOUT ANY WARRANTY; without even the implied warranty of 18d6e0175cSChristoph Hellwig * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19d6e0175cSChristoph Hellwig * GNU General Public License for more details. 20d6e0175cSChristoph Hellwig * 21d6e0175cSChristoph Hellwig * You should have received a copy of the GNU General Public License 22d6e0175cSChristoph Hellwig * along with this program; if not, write to the Free Software 23d6e0175cSChristoph Hellwig * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 24d6e0175cSChristoph Hellwig */ 25d6e0175cSChristoph Hellwig 26d6e0175cSChristoph Hellwig #include <linux/kernel.h> 27d6e0175cSChristoph Hellwig #include <linux/module.h> 28d6e0175cSChristoph Hellwig #include <linux/ratelimit.h> 29d6e0175cSChristoph Hellwig #include <asm/unaligned.h> 30d6e0175cSChristoph Hellwig #include <scsi/scsi.h> 31d6e0175cSChristoph Hellwig 32d6e0175cSChristoph Hellwig #include <target/target_core_base.h> 33d6e0175cSChristoph Hellwig #include <target/target_core_backend.h> 34d6e0175cSChristoph Hellwig #include <target/target_core_fabric.h> 35d6e0175cSChristoph Hellwig 36d6e0175cSChristoph Hellwig #include "target_core_internal.h" 37d6e0175cSChristoph Hellwig #include "target_core_ua.h" 38d6e0175cSChristoph Hellwig 39d6e0175cSChristoph Hellwig 401fd032eeSChristoph Hellwig static int sbc_emulate_readcapacity(struct se_cmd *cmd) 411fd032eeSChristoph Hellwig { 421fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev; 431fd032eeSChristoph Hellwig unsigned long long blocks_long = dev->transport->get_blocks(dev); 44a50da144SPaolo Bonzini unsigned char *rbuf; 45a50da144SPaolo Bonzini unsigned char buf[8]; 461fd032eeSChristoph Hellwig u32 blocks; 471fd032eeSChristoph Hellwig 481fd032eeSChristoph Hellwig if (blocks_long >= 0x00000000ffffffff) 491fd032eeSChristoph Hellwig blocks = 0xffffffff; 501fd032eeSChristoph Hellwig else 511fd032eeSChristoph Hellwig blocks = (u32)blocks_long; 521fd032eeSChristoph Hellwig 531fd032eeSChristoph Hellwig buf[0] = (blocks >> 24) & 0xff; 541fd032eeSChristoph Hellwig buf[1] = (blocks >> 16) & 0xff; 551fd032eeSChristoph Hellwig buf[2] = (blocks >> 8) & 0xff; 561fd032eeSChristoph Hellwig buf[3] = blocks & 0xff; 570fd97ccfSChristoph Hellwig buf[4] = (dev->dev_attrib.block_size >> 24) & 0xff; 580fd97ccfSChristoph Hellwig buf[5] = (dev->dev_attrib.block_size >> 16) & 0xff; 590fd97ccfSChristoph Hellwig buf[6] = (dev->dev_attrib.block_size >> 8) & 0xff; 600fd97ccfSChristoph Hellwig buf[7] = dev->dev_attrib.block_size & 0xff; 611fd032eeSChristoph Hellwig 62a50da144SPaolo Bonzini rbuf = transport_kmap_data_sg(cmd); 63a50da144SPaolo Bonzini if (rbuf) { 64a50da144SPaolo Bonzini memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length)); 651fd032eeSChristoph Hellwig transport_kunmap_data_sg(cmd); 66a50da144SPaolo Bonzini } 671fd032eeSChristoph Hellwig 681fd032eeSChristoph Hellwig target_complete_cmd(cmd, GOOD); 691fd032eeSChristoph Hellwig return 0; 701fd032eeSChristoph Hellwig } 711fd032eeSChristoph Hellwig 721fd032eeSChristoph Hellwig static int sbc_emulate_readcapacity_16(struct se_cmd *cmd) 731fd032eeSChristoph Hellwig { 741fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev; 75a50da144SPaolo Bonzini unsigned char *rbuf; 76a50da144SPaolo Bonzini unsigned char buf[32]; 771fd032eeSChristoph Hellwig unsigned long long blocks = dev->transport->get_blocks(dev); 781fd032eeSChristoph Hellwig 79a50da144SPaolo Bonzini memset(buf, 0, sizeof(buf)); 801fd032eeSChristoph Hellwig buf[0] = (blocks >> 56) & 0xff; 811fd032eeSChristoph Hellwig buf[1] = (blocks >> 48) & 0xff; 821fd032eeSChristoph Hellwig buf[2] = (blocks >> 40) & 0xff; 831fd032eeSChristoph Hellwig buf[3] = (blocks >> 32) & 0xff; 841fd032eeSChristoph Hellwig buf[4] = (blocks >> 24) & 0xff; 851fd032eeSChristoph Hellwig buf[5] = (blocks >> 16) & 0xff; 861fd032eeSChristoph Hellwig buf[6] = (blocks >> 8) & 0xff; 871fd032eeSChristoph Hellwig buf[7] = blocks & 0xff; 880fd97ccfSChristoph Hellwig buf[8] = (dev->dev_attrib.block_size >> 24) & 0xff; 890fd97ccfSChristoph Hellwig buf[9] = (dev->dev_attrib.block_size >> 16) & 0xff; 900fd97ccfSChristoph Hellwig buf[10] = (dev->dev_attrib.block_size >> 8) & 0xff; 910fd97ccfSChristoph Hellwig buf[11] = dev->dev_attrib.block_size & 0xff; 921fd032eeSChristoph Hellwig /* 931fd032eeSChristoph Hellwig * Set Thin Provisioning Enable bit following sbc3r22 in section 941fd032eeSChristoph Hellwig * READ CAPACITY (16) byte 14 if emulate_tpu or emulate_tpws is enabled. 951fd032eeSChristoph Hellwig */ 960fd97ccfSChristoph Hellwig if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws) 971fd032eeSChristoph Hellwig buf[14] = 0x80; 981fd032eeSChristoph Hellwig 99a50da144SPaolo Bonzini rbuf = transport_kmap_data_sg(cmd); 100a50da144SPaolo Bonzini if (rbuf) { 101a50da144SPaolo Bonzini memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length)); 1021fd032eeSChristoph Hellwig transport_kunmap_data_sg(cmd); 103a50da144SPaolo Bonzini } 1041fd032eeSChristoph Hellwig 1051fd032eeSChristoph Hellwig target_complete_cmd(cmd, GOOD); 1061fd032eeSChristoph Hellwig return 0; 1071fd032eeSChristoph Hellwig } 1081fd032eeSChristoph Hellwig 1096f974e8cSChristoph Hellwig int spc_get_write_same_sectors(struct se_cmd *cmd) 1101fd032eeSChristoph Hellwig { 1111fd032eeSChristoph Hellwig u32 num_blocks; 1121fd032eeSChristoph Hellwig 1131fd032eeSChristoph Hellwig if (cmd->t_task_cdb[0] == WRITE_SAME) 1141fd032eeSChristoph Hellwig num_blocks = get_unaligned_be16(&cmd->t_task_cdb[7]); 1151fd032eeSChristoph Hellwig else if (cmd->t_task_cdb[0] == WRITE_SAME_16) 1161fd032eeSChristoph Hellwig num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]); 1171fd032eeSChristoph Hellwig else /* WRITE_SAME_32 via VARIABLE_LENGTH_CMD */ 1181fd032eeSChristoph Hellwig num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]); 1191fd032eeSChristoph Hellwig 1201fd032eeSChristoph Hellwig /* 1211fd032eeSChristoph Hellwig * Use the explicit range when non zero is supplied, otherwise calculate 1221fd032eeSChristoph Hellwig * the remaining range based on ->get_blocks() - starting LBA. 1231fd032eeSChristoph Hellwig */ 1246f974e8cSChristoph Hellwig if (num_blocks) 1256f974e8cSChristoph Hellwig return num_blocks; 1261fd032eeSChristoph Hellwig 1276f974e8cSChristoph Hellwig return cmd->se_dev->transport->get_blocks(cmd->se_dev) - 1286f974e8cSChristoph Hellwig cmd->t_task_lba + 1; 1291fd032eeSChristoph Hellwig } 1306f974e8cSChristoph Hellwig EXPORT_SYMBOL(spc_get_write_same_sectors); 1311fd032eeSChristoph Hellwig 1321fd032eeSChristoph Hellwig static int sbc_emulate_verify(struct se_cmd *cmd) 1331fd032eeSChristoph Hellwig { 1341fd032eeSChristoph Hellwig target_complete_cmd(cmd, GOOD); 1351fd032eeSChristoph Hellwig return 0; 1361fd032eeSChristoph Hellwig } 1371fd032eeSChristoph Hellwig 1381a1ff38cSBernhard Kohl static int sbc_emulate_noop(struct se_cmd *cmd) 1391a1ff38cSBernhard Kohl { 1401a1ff38cSBernhard Kohl target_complete_cmd(cmd, GOOD); 1411a1ff38cSBernhard Kohl return 0; 1421a1ff38cSBernhard Kohl } 1431a1ff38cSBernhard Kohl 144d6e0175cSChristoph Hellwig static inline u32 sbc_get_size(struct se_cmd *cmd, u32 sectors) 145d6e0175cSChristoph Hellwig { 1460fd97ccfSChristoph Hellwig return cmd->se_dev->dev_attrib.block_size * sectors; 147d6e0175cSChristoph Hellwig } 148d6e0175cSChristoph Hellwig 149d6e0175cSChristoph Hellwig static int sbc_check_valid_sectors(struct se_cmd *cmd) 150d6e0175cSChristoph Hellwig { 151d6e0175cSChristoph Hellwig struct se_device *dev = cmd->se_dev; 152d6e0175cSChristoph Hellwig unsigned long long end_lba; 153d6e0175cSChristoph Hellwig u32 sectors; 154d6e0175cSChristoph Hellwig 1550fd97ccfSChristoph Hellwig sectors = cmd->data_length / dev->dev_attrib.block_size; 156d6e0175cSChristoph Hellwig end_lba = dev->transport->get_blocks(dev) + 1; 157d6e0175cSChristoph Hellwig 158d6e0175cSChristoph Hellwig if (cmd->t_task_lba + sectors > end_lba) { 159d6e0175cSChristoph Hellwig pr_err("target: lba %llu, sectors %u exceeds end lba %llu\n", 160d6e0175cSChristoph Hellwig cmd->t_task_lba, sectors, end_lba); 161d6e0175cSChristoph Hellwig return -EINVAL; 162d6e0175cSChristoph Hellwig } 163d6e0175cSChristoph Hellwig 164d6e0175cSChristoph Hellwig return 0; 165d6e0175cSChristoph Hellwig } 166d6e0175cSChristoph Hellwig 167d6e0175cSChristoph Hellwig static inline u32 transport_get_sectors_6(unsigned char *cdb) 168d6e0175cSChristoph Hellwig { 169d6e0175cSChristoph Hellwig /* 170d6e0175cSChristoph Hellwig * Use 8-bit sector value. SBC-3 says: 171d6e0175cSChristoph Hellwig * 172d6e0175cSChristoph Hellwig * A TRANSFER LENGTH field set to zero specifies that 256 173d6e0175cSChristoph Hellwig * logical blocks shall be written. Any other value 174d6e0175cSChristoph Hellwig * specifies the number of logical blocks that shall be 175d6e0175cSChristoph Hellwig * written. 176d6e0175cSChristoph Hellwig */ 177d6e0175cSChristoph Hellwig return cdb[4] ? : 256; 178d6e0175cSChristoph Hellwig } 179d6e0175cSChristoph Hellwig 180d6e0175cSChristoph Hellwig static inline u32 transport_get_sectors_10(unsigned char *cdb) 181d6e0175cSChristoph Hellwig { 182d6e0175cSChristoph Hellwig return (u32)(cdb[7] << 8) + cdb[8]; 183d6e0175cSChristoph Hellwig } 184d6e0175cSChristoph Hellwig 185d6e0175cSChristoph Hellwig static inline u32 transport_get_sectors_12(unsigned char *cdb) 186d6e0175cSChristoph Hellwig { 187d6e0175cSChristoph Hellwig return (u32)(cdb[6] << 24) + (cdb[7] << 16) + (cdb[8] << 8) + cdb[9]; 188d6e0175cSChristoph Hellwig } 189d6e0175cSChristoph Hellwig 190d6e0175cSChristoph Hellwig static inline u32 transport_get_sectors_16(unsigned char *cdb) 191d6e0175cSChristoph Hellwig { 192d6e0175cSChristoph Hellwig return (u32)(cdb[10] << 24) + (cdb[11] << 16) + 193d6e0175cSChristoph Hellwig (cdb[12] << 8) + cdb[13]; 194d6e0175cSChristoph Hellwig } 195d6e0175cSChristoph Hellwig 196d6e0175cSChristoph Hellwig /* 197d6e0175cSChristoph Hellwig * Used for VARIABLE_LENGTH_CDB WRITE_32 and READ_32 variants 198d6e0175cSChristoph Hellwig */ 199d6e0175cSChristoph Hellwig static inline u32 transport_get_sectors_32(unsigned char *cdb) 200d6e0175cSChristoph Hellwig { 201d6e0175cSChristoph Hellwig return (u32)(cdb[28] << 24) + (cdb[29] << 16) + 202d6e0175cSChristoph Hellwig (cdb[30] << 8) + cdb[31]; 203d6e0175cSChristoph Hellwig 204d6e0175cSChristoph Hellwig } 205d6e0175cSChristoph Hellwig 206d6e0175cSChristoph Hellwig static inline u32 transport_lba_21(unsigned char *cdb) 207d6e0175cSChristoph Hellwig { 208d6e0175cSChristoph Hellwig return ((cdb[1] & 0x1f) << 16) | (cdb[2] << 8) | cdb[3]; 209d6e0175cSChristoph Hellwig } 210d6e0175cSChristoph Hellwig 211d6e0175cSChristoph Hellwig static inline u32 transport_lba_32(unsigned char *cdb) 212d6e0175cSChristoph Hellwig { 213d6e0175cSChristoph Hellwig return (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; 214d6e0175cSChristoph Hellwig } 215d6e0175cSChristoph Hellwig 216d6e0175cSChristoph Hellwig static inline unsigned long long transport_lba_64(unsigned char *cdb) 217d6e0175cSChristoph Hellwig { 218d6e0175cSChristoph Hellwig unsigned int __v1, __v2; 219d6e0175cSChristoph Hellwig 220d6e0175cSChristoph Hellwig __v1 = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; 221d6e0175cSChristoph Hellwig __v2 = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9]; 222d6e0175cSChristoph Hellwig 223d6e0175cSChristoph Hellwig return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32; 224d6e0175cSChristoph Hellwig } 225d6e0175cSChristoph Hellwig 226d6e0175cSChristoph Hellwig /* 227d6e0175cSChristoph Hellwig * For VARIABLE_LENGTH_CDB w/ 32 byte extended CDBs 228d6e0175cSChristoph Hellwig */ 229d6e0175cSChristoph Hellwig static inline unsigned long long transport_lba_64_ext(unsigned char *cdb) 230d6e0175cSChristoph Hellwig { 231d6e0175cSChristoph Hellwig unsigned int __v1, __v2; 232d6e0175cSChristoph Hellwig 233d6e0175cSChristoph Hellwig __v1 = (cdb[12] << 24) | (cdb[13] << 16) | (cdb[14] << 8) | cdb[15]; 234d6e0175cSChristoph Hellwig __v2 = (cdb[16] << 24) | (cdb[17] << 16) | (cdb[18] << 8) | cdb[19]; 235d6e0175cSChristoph Hellwig 236d6e0175cSChristoph Hellwig return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32; 237d6e0175cSChristoph Hellwig } 238d6e0175cSChristoph Hellwig 239d6e0175cSChristoph Hellwig static int sbc_write_same_supported(struct se_device *dev, 240d6e0175cSChristoph Hellwig unsigned char *flags) 241d6e0175cSChristoph Hellwig { 242d6e0175cSChristoph Hellwig if ((flags[0] & 0x04) || (flags[0] & 0x02)) { 243d6e0175cSChristoph Hellwig pr_err("WRITE_SAME PBDATA and LBDATA" 244d6e0175cSChristoph Hellwig " bits not supported for Block Discard" 245d6e0175cSChristoph Hellwig " Emulation\n"); 246d6e0175cSChristoph Hellwig return -ENOSYS; 247d6e0175cSChristoph Hellwig } 248d6e0175cSChristoph Hellwig 249d6e0175cSChristoph Hellwig /* 250d6e0175cSChristoph Hellwig * Currently for the emulated case we only accept 251d6e0175cSChristoph Hellwig * tpws with the UNMAP=1 bit set. 252d6e0175cSChristoph Hellwig */ 253d6e0175cSChristoph Hellwig if (!(flags[0] & 0x08)) { 254d6e0175cSChristoph Hellwig pr_err("WRITE_SAME w/o UNMAP bit not" 255d6e0175cSChristoph Hellwig " supported for Block Discard Emulation\n"); 256d6e0175cSChristoph Hellwig return -ENOSYS; 257d6e0175cSChristoph Hellwig } 258d6e0175cSChristoph Hellwig 259d6e0175cSChristoph Hellwig return 0; 260d6e0175cSChristoph Hellwig } 261d6e0175cSChristoph Hellwig 262d6e0175cSChristoph Hellwig static void xdreadwrite_callback(struct se_cmd *cmd) 263d6e0175cSChristoph Hellwig { 264d6e0175cSChristoph Hellwig unsigned char *buf, *addr; 265d6e0175cSChristoph Hellwig struct scatterlist *sg; 266d6e0175cSChristoph Hellwig unsigned int offset; 267d6e0175cSChristoph Hellwig int i; 268d6e0175cSChristoph Hellwig int count; 269d6e0175cSChristoph Hellwig /* 270d6e0175cSChristoph Hellwig * From sbc3r22.pdf section 5.48 XDWRITEREAD (10) command 271d6e0175cSChristoph Hellwig * 272d6e0175cSChristoph Hellwig * 1) read the specified logical block(s); 273d6e0175cSChristoph Hellwig * 2) transfer logical blocks from the data-out buffer; 274d6e0175cSChristoph Hellwig * 3) XOR the logical blocks transferred from the data-out buffer with 275d6e0175cSChristoph Hellwig * the logical blocks read, storing the resulting XOR data in a buffer; 276d6e0175cSChristoph Hellwig * 4) if the DISABLE WRITE bit is set to zero, then write the logical 277d6e0175cSChristoph Hellwig * blocks transferred from the data-out buffer; and 278d6e0175cSChristoph Hellwig * 5) transfer the resulting XOR data to the data-in buffer. 279d6e0175cSChristoph Hellwig */ 280d6e0175cSChristoph Hellwig buf = kmalloc(cmd->data_length, GFP_KERNEL); 281d6e0175cSChristoph Hellwig if (!buf) { 282d6e0175cSChristoph Hellwig pr_err("Unable to allocate xor_callback buf\n"); 283d6e0175cSChristoph Hellwig return; 284d6e0175cSChristoph Hellwig } 285d6e0175cSChristoph Hellwig /* 286d6e0175cSChristoph Hellwig * Copy the scatterlist WRITE buffer located at cmd->t_data_sg 287d6e0175cSChristoph Hellwig * into the locally allocated *buf 288d6e0175cSChristoph Hellwig */ 289d6e0175cSChristoph Hellwig sg_copy_to_buffer(cmd->t_data_sg, 290d6e0175cSChristoph Hellwig cmd->t_data_nents, 291d6e0175cSChristoph Hellwig buf, 292d6e0175cSChristoph Hellwig cmd->data_length); 293d6e0175cSChristoph Hellwig 294d6e0175cSChristoph Hellwig /* 295d6e0175cSChristoph Hellwig * Now perform the XOR against the BIDI read memory located at 296d6e0175cSChristoph Hellwig * cmd->t_mem_bidi_list 297d6e0175cSChristoph Hellwig */ 298d6e0175cSChristoph Hellwig 299d6e0175cSChristoph Hellwig offset = 0; 300d6e0175cSChristoph Hellwig for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, count) { 301d6e0175cSChristoph Hellwig addr = kmap_atomic(sg_page(sg)); 302d6e0175cSChristoph Hellwig if (!addr) 303d6e0175cSChristoph Hellwig goto out; 304d6e0175cSChristoph Hellwig 305d6e0175cSChristoph Hellwig for (i = 0; i < sg->length; i++) 306d6e0175cSChristoph Hellwig *(addr + sg->offset + i) ^= *(buf + offset + i); 307d6e0175cSChristoph Hellwig 308d6e0175cSChristoph Hellwig offset += sg->length; 309d6e0175cSChristoph Hellwig kunmap_atomic(addr); 310d6e0175cSChristoph Hellwig } 311d6e0175cSChristoph Hellwig 312d6e0175cSChristoph Hellwig out: 313d6e0175cSChristoph Hellwig kfree(buf); 314d6e0175cSChristoph Hellwig } 315d6e0175cSChristoph Hellwig 3160c2ad7d1SChristoph Hellwig int sbc_parse_cdb(struct se_cmd *cmd, struct spc_ops *ops) 317d6e0175cSChristoph Hellwig { 318d6e0175cSChristoph Hellwig struct se_device *dev = cmd->se_dev; 319d6e0175cSChristoph Hellwig unsigned char *cdb = cmd->t_task_cdb; 3201fd032eeSChristoph Hellwig unsigned int size; 321d6e0175cSChristoph Hellwig u32 sectors = 0; 322d6e0175cSChristoph Hellwig int ret; 323d6e0175cSChristoph Hellwig 324d6e0175cSChristoph Hellwig switch (cdb[0]) { 325d6e0175cSChristoph Hellwig case READ_6: 326d6e0175cSChristoph Hellwig sectors = transport_get_sectors_6(cdb); 327d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_21(cdb); 328d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 3290c2ad7d1SChristoph Hellwig cmd->execute_cmd = ops->execute_rw; 330d6e0175cSChristoph Hellwig break; 331d6e0175cSChristoph Hellwig case READ_10: 332d6e0175cSChristoph Hellwig sectors = transport_get_sectors_10(cdb); 333d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_32(cdb); 334d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 3350c2ad7d1SChristoph Hellwig cmd->execute_cmd = ops->execute_rw; 336d6e0175cSChristoph Hellwig break; 337d6e0175cSChristoph Hellwig case READ_12: 338d6e0175cSChristoph Hellwig sectors = transport_get_sectors_12(cdb); 339d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_32(cdb); 340d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 3410c2ad7d1SChristoph Hellwig cmd->execute_cmd = ops->execute_rw; 342d6e0175cSChristoph Hellwig break; 343d6e0175cSChristoph Hellwig case READ_16: 344d6e0175cSChristoph Hellwig sectors = transport_get_sectors_16(cdb); 345d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_64(cdb); 346d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 3470c2ad7d1SChristoph Hellwig cmd->execute_cmd = ops->execute_rw; 348d6e0175cSChristoph Hellwig break; 349d6e0175cSChristoph Hellwig case WRITE_6: 350d6e0175cSChristoph Hellwig sectors = transport_get_sectors_6(cdb); 351d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_21(cdb); 352d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 3530c2ad7d1SChristoph Hellwig cmd->execute_cmd = ops->execute_rw; 354d6e0175cSChristoph Hellwig break; 355d6e0175cSChristoph Hellwig case WRITE_10: 356d6e0175cSChristoph Hellwig case WRITE_VERIFY: 357d6e0175cSChristoph Hellwig sectors = transport_get_sectors_10(cdb); 358d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_32(cdb); 359d6e0175cSChristoph Hellwig if (cdb[1] & 0x8) 360d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_FUA; 361d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 3620c2ad7d1SChristoph Hellwig cmd->execute_cmd = ops->execute_rw; 363d6e0175cSChristoph Hellwig break; 364d6e0175cSChristoph Hellwig case WRITE_12: 365d6e0175cSChristoph Hellwig sectors = transport_get_sectors_12(cdb); 366d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_32(cdb); 367d6e0175cSChristoph Hellwig if (cdb[1] & 0x8) 368d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_FUA; 369d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 3700c2ad7d1SChristoph Hellwig cmd->execute_cmd = ops->execute_rw; 371d6e0175cSChristoph Hellwig break; 372d6e0175cSChristoph Hellwig case WRITE_16: 373d6e0175cSChristoph Hellwig sectors = transport_get_sectors_16(cdb); 374d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_64(cdb); 375d6e0175cSChristoph Hellwig if (cdb[1] & 0x8) 376d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_FUA; 377d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 3780c2ad7d1SChristoph Hellwig cmd->execute_cmd = ops->execute_rw; 379d6e0175cSChristoph Hellwig break; 380d6e0175cSChristoph Hellwig case XDWRITEREAD_10: 381d6e0175cSChristoph Hellwig if ((cmd->data_direction != DMA_TO_DEVICE) || 382d6e0175cSChristoph Hellwig !(cmd->se_cmd_flags & SCF_BIDI)) 383d6e0175cSChristoph Hellwig goto out_invalid_cdb_field; 384d6e0175cSChristoph Hellwig sectors = transport_get_sectors_10(cdb); 385d6e0175cSChristoph Hellwig 386d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_32(cdb); 387d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 388d6e0175cSChristoph Hellwig 389d6e0175cSChristoph Hellwig /* 390d6e0175cSChristoph Hellwig * Setup BIDI XOR callback to be run after I/O completion. 391d6e0175cSChristoph Hellwig */ 3920c2ad7d1SChristoph Hellwig cmd->execute_cmd = ops->execute_rw; 393d6e0175cSChristoph Hellwig cmd->transport_complete_callback = &xdreadwrite_callback; 394d6e0175cSChristoph Hellwig if (cdb[1] & 0x8) 395d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_FUA; 396d6e0175cSChristoph Hellwig break; 397d6e0175cSChristoph Hellwig case VARIABLE_LENGTH_CMD: 398d6e0175cSChristoph Hellwig { 399d6e0175cSChristoph Hellwig u16 service_action = get_unaligned_be16(&cdb[8]); 400d6e0175cSChristoph Hellwig switch (service_action) { 401d6e0175cSChristoph Hellwig case XDWRITEREAD_32: 402d6e0175cSChristoph Hellwig sectors = transport_get_sectors_32(cdb); 403d6e0175cSChristoph Hellwig 404d6e0175cSChristoph Hellwig /* 405d6e0175cSChristoph Hellwig * Use WRITE_32 and READ_32 opcodes for the emulated 406d6e0175cSChristoph Hellwig * XDWRITE_READ_32 logic. 407d6e0175cSChristoph Hellwig */ 408d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_64_ext(cdb); 409d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 410d6e0175cSChristoph Hellwig 411d6e0175cSChristoph Hellwig /* 412d6e0175cSChristoph Hellwig * Setup BIDI XOR callback to be run during after I/O 413d6e0175cSChristoph Hellwig * completion. 414d6e0175cSChristoph Hellwig */ 4150c2ad7d1SChristoph Hellwig cmd->execute_cmd = ops->execute_rw; 416d6e0175cSChristoph Hellwig cmd->transport_complete_callback = &xdreadwrite_callback; 417d6e0175cSChristoph Hellwig if (cdb[1] & 0x8) 418d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_FUA; 419d6e0175cSChristoph Hellwig break; 420d6e0175cSChristoph Hellwig case WRITE_SAME_32: 4216f974e8cSChristoph Hellwig if (!ops->execute_write_same) 4226f974e8cSChristoph Hellwig goto out_unsupported_cdb; 4236f974e8cSChristoph Hellwig 424d6e0175cSChristoph Hellwig sectors = transport_get_sectors_32(cdb); 425d6e0175cSChristoph Hellwig if (!sectors) { 426d6e0175cSChristoph Hellwig pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not" 427d6e0175cSChristoph Hellwig " supported\n"); 428d6e0175cSChristoph Hellwig goto out_invalid_cdb_field; 429d6e0175cSChristoph Hellwig } 430d6e0175cSChristoph Hellwig 4311fd032eeSChristoph Hellwig size = sbc_get_size(cmd, 1); 432d6e0175cSChristoph Hellwig cmd->t_task_lba = get_unaligned_be64(&cdb[12]); 433d6e0175cSChristoph Hellwig 434d6e0175cSChristoph Hellwig if (sbc_write_same_supported(dev, &cdb[10]) < 0) 435d6e0175cSChristoph Hellwig goto out_unsupported_cdb; 4366f974e8cSChristoph Hellwig cmd->execute_cmd = ops->execute_write_same; 437d6e0175cSChristoph Hellwig break; 438d6e0175cSChristoph Hellwig default: 439d6e0175cSChristoph Hellwig pr_err("VARIABLE_LENGTH_CMD service action" 440d6e0175cSChristoph Hellwig " 0x%04x not supported\n", service_action); 441d6e0175cSChristoph Hellwig goto out_unsupported_cdb; 442d6e0175cSChristoph Hellwig } 443d6e0175cSChristoph Hellwig break; 444d6e0175cSChristoph Hellwig } 445d6e0175cSChristoph Hellwig case READ_CAPACITY: 4461fd032eeSChristoph Hellwig size = READ_CAP_LEN; 4471fd032eeSChristoph Hellwig cmd->execute_cmd = sbc_emulate_readcapacity; 448d6e0175cSChristoph Hellwig break; 449d6e0175cSChristoph Hellwig case SERVICE_ACTION_IN: 450d6e0175cSChristoph Hellwig switch (cmd->t_task_cdb[1] & 0x1f) { 451d6e0175cSChristoph Hellwig case SAI_READ_CAPACITY_16: 4521fd032eeSChristoph Hellwig cmd->execute_cmd = sbc_emulate_readcapacity_16; 453d6e0175cSChristoph Hellwig break; 454d6e0175cSChristoph Hellwig default: 455d6e0175cSChristoph Hellwig pr_err("Unsupported SA: 0x%02x\n", 456d6e0175cSChristoph Hellwig cmd->t_task_cdb[1] & 0x1f); 457d6e0175cSChristoph Hellwig goto out_invalid_cdb_field; 458d6e0175cSChristoph Hellwig } 4591fd032eeSChristoph Hellwig size = (cdb[10] << 24) | (cdb[11] << 16) | 460d6e0175cSChristoph Hellwig (cdb[12] << 8) | cdb[13]; 461d6e0175cSChristoph Hellwig break; 462d6e0175cSChristoph Hellwig case SYNCHRONIZE_CACHE: 463d6e0175cSChristoph Hellwig case SYNCHRONIZE_CACHE_16: 464ad67f0d9SChristoph Hellwig if (!ops->execute_sync_cache) 465ad67f0d9SChristoph Hellwig goto out_unsupported_cdb; 466ad67f0d9SChristoph Hellwig 467d6e0175cSChristoph Hellwig /* 468d6e0175cSChristoph Hellwig * Extract LBA and range to be flushed for emulated SYNCHRONIZE_CACHE 469d6e0175cSChristoph Hellwig */ 470d6e0175cSChristoph Hellwig if (cdb[0] == SYNCHRONIZE_CACHE) { 471d6e0175cSChristoph Hellwig sectors = transport_get_sectors_10(cdb); 472d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_32(cdb); 473d6e0175cSChristoph Hellwig } else { 474d6e0175cSChristoph Hellwig sectors = transport_get_sectors_16(cdb); 475d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_64(cdb); 476d6e0175cSChristoph Hellwig } 477d6e0175cSChristoph Hellwig 4781fd032eeSChristoph Hellwig size = sbc_get_size(cmd, sectors); 479d6e0175cSChristoph Hellwig 480d6e0175cSChristoph Hellwig /* 481d6e0175cSChristoph Hellwig * Check to ensure that LBA + Range does not exceed past end of 482d6e0175cSChristoph Hellwig * device for IBLOCK and FILEIO ->do_sync_cache() backend calls 483d6e0175cSChristoph Hellwig */ 484d6e0175cSChristoph Hellwig if (cmd->t_task_lba || sectors) { 485d6e0175cSChristoph Hellwig if (sbc_check_valid_sectors(cmd) < 0) 486d6e0175cSChristoph Hellwig goto out_invalid_cdb_field; 487d6e0175cSChristoph Hellwig } 488ad67f0d9SChristoph Hellwig cmd->execute_cmd = ops->execute_sync_cache; 489d6e0175cSChristoph Hellwig break; 490d6e0175cSChristoph Hellwig case UNMAP: 49114150a6bSChristoph Hellwig if (!ops->execute_unmap) 49214150a6bSChristoph Hellwig goto out_unsupported_cdb; 49314150a6bSChristoph Hellwig 4941fd032eeSChristoph Hellwig size = get_unaligned_be16(&cdb[7]); 49514150a6bSChristoph Hellwig cmd->execute_cmd = ops->execute_unmap; 496d6e0175cSChristoph Hellwig break; 497d6e0175cSChristoph Hellwig case WRITE_SAME_16: 4986f974e8cSChristoph Hellwig if (!ops->execute_write_same) 4996f974e8cSChristoph Hellwig goto out_unsupported_cdb; 5006f974e8cSChristoph Hellwig 501d6e0175cSChristoph Hellwig sectors = transport_get_sectors_16(cdb); 502d6e0175cSChristoph Hellwig if (!sectors) { 503d6e0175cSChristoph Hellwig pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n"); 504d6e0175cSChristoph Hellwig goto out_invalid_cdb_field; 505d6e0175cSChristoph Hellwig } 506d6e0175cSChristoph Hellwig 5071fd032eeSChristoph Hellwig size = sbc_get_size(cmd, 1); 508d6e0175cSChristoph Hellwig cmd->t_task_lba = get_unaligned_be64(&cdb[2]); 509d6e0175cSChristoph Hellwig 510d6e0175cSChristoph Hellwig if (sbc_write_same_supported(dev, &cdb[1]) < 0) 511d6e0175cSChristoph Hellwig goto out_unsupported_cdb; 5126f974e8cSChristoph Hellwig cmd->execute_cmd = ops->execute_write_same; 513d6e0175cSChristoph Hellwig break; 514d6e0175cSChristoph Hellwig case WRITE_SAME: 5156f974e8cSChristoph Hellwig if (!ops->execute_write_same) 5166f974e8cSChristoph Hellwig goto out_unsupported_cdb; 5176f974e8cSChristoph Hellwig 518d6e0175cSChristoph Hellwig sectors = transport_get_sectors_10(cdb); 519d6e0175cSChristoph Hellwig if (!sectors) { 520d6e0175cSChristoph Hellwig pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n"); 521d6e0175cSChristoph Hellwig goto out_invalid_cdb_field; 522d6e0175cSChristoph Hellwig } 523d6e0175cSChristoph Hellwig 5241fd032eeSChristoph Hellwig size = sbc_get_size(cmd, 1); 525d6e0175cSChristoph Hellwig cmd->t_task_lba = get_unaligned_be32(&cdb[2]); 526d6e0175cSChristoph Hellwig 527d6e0175cSChristoph Hellwig /* 528d6e0175cSChristoph Hellwig * Follow sbcr26 with WRITE_SAME (10) and check for the existence 529d6e0175cSChristoph Hellwig * of byte 1 bit 3 UNMAP instead of original reserved field 530d6e0175cSChristoph Hellwig */ 531d6e0175cSChristoph Hellwig if (sbc_write_same_supported(dev, &cdb[1]) < 0) 532d6e0175cSChristoph Hellwig goto out_unsupported_cdb; 5336f974e8cSChristoph Hellwig cmd->execute_cmd = ops->execute_write_same; 534d6e0175cSChristoph Hellwig break; 535d6e0175cSChristoph Hellwig case VERIFY: 5361fd032eeSChristoph Hellwig size = 0; 5371fd032eeSChristoph Hellwig cmd->execute_cmd = sbc_emulate_verify; 538d6e0175cSChristoph Hellwig break; 5391a1ff38cSBernhard Kohl case REZERO_UNIT: 5401a1ff38cSBernhard Kohl case SEEK_6: 5411a1ff38cSBernhard Kohl case SEEK_10: 5421a1ff38cSBernhard Kohl /* 5431a1ff38cSBernhard Kohl * There are still clients out there which use these old SCSI-2 5441a1ff38cSBernhard Kohl * commands. This mainly happens when running VMs with legacy 5451a1ff38cSBernhard Kohl * guest systems, connected via SCSI command pass-through to 5461a1ff38cSBernhard Kohl * iSCSI targets. Make them happy and return status GOOD. 5471a1ff38cSBernhard Kohl */ 5481a1ff38cSBernhard Kohl size = 0; 5491a1ff38cSBernhard Kohl cmd->execute_cmd = sbc_emulate_noop; 5501a1ff38cSBernhard Kohl break; 551d6e0175cSChristoph Hellwig default: 5521fd032eeSChristoph Hellwig ret = spc_parse_cdb(cmd, &size); 553d6e0175cSChristoph Hellwig if (ret) 554d6e0175cSChristoph Hellwig return ret; 555d6e0175cSChristoph Hellwig } 556d6e0175cSChristoph Hellwig 557d6e0175cSChristoph Hellwig /* reject any command that we don't have a handler for */ 558d6e0175cSChristoph Hellwig if (!(cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) && !cmd->execute_cmd) 559d6e0175cSChristoph Hellwig goto out_unsupported_cdb; 560d6e0175cSChristoph Hellwig 561d6e0175cSChristoph Hellwig if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) { 5621fd032eeSChristoph Hellwig unsigned long long end_lba; 5631fd032eeSChristoph Hellwig 5640fd97ccfSChristoph Hellwig if (sectors > dev->dev_attrib.fabric_max_sectors) { 565d6e0175cSChristoph Hellwig printk_ratelimited(KERN_ERR "SCSI OP %02xh with too" 566d6e0175cSChristoph Hellwig " big sectors %u exceeds fabric_max_sectors:" 567d6e0175cSChristoph Hellwig " %u\n", cdb[0], sectors, 5680fd97ccfSChristoph Hellwig dev->dev_attrib.fabric_max_sectors); 569d6e0175cSChristoph Hellwig goto out_invalid_cdb_field; 570d6e0175cSChristoph Hellwig } 5710fd97ccfSChristoph Hellwig if (sectors > dev->dev_attrib.hw_max_sectors) { 572d6e0175cSChristoph Hellwig printk_ratelimited(KERN_ERR "SCSI OP %02xh with too" 573d6e0175cSChristoph Hellwig " big sectors %u exceeds backend hw_max_sectors:" 574d6e0175cSChristoph Hellwig " %u\n", cdb[0], sectors, 5750fd97ccfSChristoph Hellwig dev->dev_attrib.hw_max_sectors); 576d6e0175cSChristoph Hellwig goto out_invalid_cdb_field; 577d6e0175cSChristoph Hellwig } 578d6e0175cSChristoph Hellwig 5791fd032eeSChristoph Hellwig end_lba = dev->transport->get_blocks(dev) + 1; 5801fd032eeSChristoph Hellwig if (cmd->t_task_lba + sectors > end_lba) { 5811fd032eeSChristoph Hellwig pr_err("cmd exceeds last lba %llu " 5821fd032eeSChristoph Hellwig "(lba %llu, sectors %u)\n", 5831fd032eeSChristoph Hellwig end_lba, cmd->t_task_lba, sectors); 5841fd032eeSChristoph Hellwig goto out_invalid_cdb_field; 585d6e0175cSChristoph Hellwig } 586d6e0175cSChristoph Hellwig 5871fd032eeSChristoph Hellwig size = sbc_get_size(cmd, sectors); 5881fd032eeSChristoph Hellwig } 5891fd032eeSChristoph Hellwig 5901fd032eeSChristoph Hellwig ret = target_cmd_size_check(cmd, size); 5911fd032eeSChristoph Hellwig if (ret < 0) 5921fd032eeSChristoph Hellwig return ret; 5931fd032eeSChristoph Hellwig 594d6e0175cSChristoph Hellwig return 0; 595d6e0175cSChristoph Hellwig 596d6e0175cSChristoph Hellwig out_unsupported_cdb: 597d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 598d6e0175cSChristoph Hellwig cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE; 599d6e0175cSChristoph Hellwig return -EINVAL; 600d6e0175cSChristoph Hellwig out_invalid_cdb_field: 601d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 602d6e0175cSChristoph Hellwig cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD; 603d6e0175cSChristoph Hellwig return -EINVAL; 604d6e0175cSChristoph Hellwig } 605d6e0175cSChristoph Hellwig EXPORT_SYMBOL(sbc_parse_cdb); 606