1d6e0175cSChristoph Hellwig /* 2d6e0175cSChristoph Hellwig * SCSI Block Commands (SBC) parsing and emulation. 3d6e0175cSChristoph Hellwig * 44c76251eSNicholas Bellinger * (c) Copyright 2002-2013 Datera, Inc. 5d6e0175cSChristoph Hellwig * 6d6e0175cSChristoph Hellwig * Nicholas A. Bellinger <nab@kernel.org> 7d6e0175cSChristoph Hellwig * 8d6e0175cSChristoph Hellwig * This program is free software; you can redistribute it and/or modify 9d6e0175cSChristoph Hellwig * it under the terms of the GNU General Public License as published by 10d6e0175cSChristoph Hellwig * the Free Software Foundation; either version 2 of the License, or 11d6e0175cSChristoph Hellwig * (at your option) any later version. 12d6e0175cSChristoph Hellwig * 13d6e0175cSChristoph Hellwig * This program is distributed in the hope that it will be useful, 14d6e0175cSChristoph Hellwig * but WITHOUT ANY WARRANTY; without even the implied warranty of 15d6e0175cSChristoph Hellwig * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16d6e0175cSChristoph Hellwig * GNU General Public License for more details. 17d6e0175cSChristoph Hellwig * 18d6e0175cSChristoph Hellwig * You should have received a copy of the GNU General Public License 19d6e0175cSChristoph Hellwig * along with this program; if not, write to the Free Software 20d6e0175cSChristoph Hellwig * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 21d6e0175cSChristoph Hellwig */ 22d6e0175cSChristoph Hellwig 23d6e0175cSChristoph Hellwig #include <linux/kernel.h> 24d6e0175cSChristoph Hellwig #include <linux/module.h> 25d6e0175cSChristoph Hellwig #include <linux/ratelimit.h> 2641861fa8SNicholas Bellinger #include <linux/crc-t10dif.h> 27d6e0175cSChristoph Hellwig #include <asm/unaligned.h> 28d6e0175cSChristoph Hellwig #include <scsi/scsi.h> 2968ff9b9bSNicholas Bellinger #include <scsi/scsi_tcq.h> 30d6e0175cSChristoph Hellwig 31d6e0175cSChristoph Hellwig #include <target/target_core_base.h> 32d6e0175cSChristoph Hellwig #include <target/target_core_backend.h> 33d6e0175cSChristoph Hellwig #include <target/target_core_fabric.h> 34d6e0175cSChristoph Hellwig 35d6e0175cSChristoph Hellwig #include "target_core_internal.h" 36d6e0175cSChristoph Hellwig #include "target_core_ua.h" 37c66094bfSHannes Reinecke #include "target_core_alua.h" 38d6e0175cSChristoph Hellwig 39de103c93SChristoph Hellwig static sense_reason_t 40de103c93SChristoph Hellwig sbc_emulate_readcapacity(struct se_cmd *cmd) 411fd032eeSChristoph Hellwig { 421fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev; 438dc8632aSRoland Dreier unsigned char *cdb = cmd->t_task_cdb; 441fd032eeSChristoph Hellwig unsigned long long blocks_long = dev->transport->get_blocks(dev); 45a50da144SPaolo Bonzini unsigned char *rbuf; 46a50da144SPaolo Bonzini unsigned char buf[8]; 471fd032eeSChristoph Hellwig u32 blocks; 481fd032eeSChristoph Hellwig 498dc8632aSRoland Dreier /* 508dc8632aSRoland Dreier * SBC-2 says: 518dc8632aSRoland Dreier * If the PMI bit is set to zero and the LOGICAL BLOCK 528dc8632aSRoland Dreier * ADDRESS field is not set to zero, the device server shall 538dc8632aSRoland Dreier * terminate the command with CHECK CONDITION status with 548dc8632aSRoland Dreier * the sense key set to ILLEGAL REQUEST and the additional 558dc8632aSRoland Dreier * sense code set to INVALID FIELD IN CDB. 568dc8632aSRoland Dreier * 578dc8632aSRoland Dreier * In SBC-3, these fields are obsolete, but some SCSI 588dc8632aSRoland Dreier * compliance tests actually check this, so we might as well 598dc8632aSRoland Dreier * follow SBC-2. 608dc8632aSRoland Dreier */ 618dc8632aSRoland Dreier if (!(cdb[8] & 1) && !!(cdb[2] | cdb[3] | cdb[4] | cdb[5])) 628dc8632aSRoland Dreier return TCM_INVALID_CDB_FIELD; 638dc8632aSRoland Dreier 641fd032eeSChristoph Hellwig if (blocks_long >= 0x00000000ffffffff) 651fd032eeSChristoph Hellwig blocks = 0xffffffff; 661fd032eeSChristoph Hellwig else 671fd032eeSChristoph Hellwig blocks = (u32)blocks_long; 681fd032eeSChristoph Hellwig 691fd032eeSChristoph Hellwig buf[0] = (blocks >> 24) & 0xff; 701fd032eeSChristoph Hellwig buf[1] = (blocks >> 16) & 0xff; 711fd032eeSChristoph Hellwig buf[2] = (blocks >> 8) & 0xff; 721fd032eeSChristoph Hellwig buf[3] = blocks & 0xff; 730fd97ccfSChristoph Hellwig buf[4] = (dev->dev_attrib.block_size >> 24) & 0xff; 740fd97ccfSChristoph Hellwig buf[5] = (dev->dev_attrib.block_size >> 16) & 0xff; 750fd97ccfSChristoph Hellwig buf[6] = (dev->dev_attrib.block_size >> 8) & 0xff; 760fd97ccfSChristoph Hellwig buf[7] = dev->dev_attrib.block_size & 0xff; 771fd032eeSChristoph Hellwig 78a50da144SPaolo Bonzini rbuf = transport_kmap_data_sg(cmd); 798b4b0dcbSNicholas Bellinger if (rbuf) { 80a50da144SPaolo Bonzini memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length)); 811fd032eeSChristoph Hellwig transport_kunmap_data_sg(cmd); 828b4b0dcbSNicholas Bellinger } 831fd032eeSChristoph Hellwig 841fd032eeSChristoph Hellwig target_complete_cmd(cmd, GOOD); 851fd032eeSChristoph Hellwig return 0; 861fd032eeSChristoph Hellwig } 871fd032eeSChristoph Hellwig 88de103c93SChristoph Hellwig static sense_reason_t 89de103c93SChristoph Hellwig sbc_emulate_readcapacity_16(struct se_cmd *cmd) 901fd032eeSChristoph Hellwig { 911fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev; 92a50da144SPaolo Bonzini unsigned char *rbuf; 93a50da144SPaolo Bonzini unsigned char buf[32]; 941fd032eeSChristoph Hellwig unsigned long long blocks = dev->transport->get_blocks(dev); 951fd032eeSChristoph Hellwig 96a50da144SPaolo Bonzini memset(buf, 0, sizeof(buf)); 971fd032eeSChristoph Hellwig buf[0] = (blocks >> 56) & 0xff; 981fd032eeSChristoph Hellwig buf[1] = (blocks >> 48) & 0xff; 991fd032eeSChristoph Hellwig buf[2] = (blocks >> 40) & 0xff; 1001fd032eeSChristoph Hellwig buf[3] = (blocks >> 32) & 0xff; 1011fd032eeSChristoph Hellwig buf[4] = (blocks >> 24) & 0xff; 1021fd032eeSChristoph Hellwig buf[5] = (blocks >> 16) & 0xff; 1031fd032eeSChristoph Hellwig buf[6] = (blocks >> 8) & 0xff; 1041fd032eeSChristoph Hellwig buf[7] = blocks & 0xff; 1050fd97ccfSChristoph Hellwig buf[8] = (dev->dev_attrib.block_size >> 24) & 0xff; 1060fd97ccfSChristoph Hellwig buf[9] = (dev->dev_attrib.block_size >> 16) & 0xff; 1070fd97ccfSChristoph Hellwig buf[10] = (dev->dev_attrib.block_size >> 8) & 0xff; 1080fd97ccfSChristoph Hellwig buf[11] = dev->dev_attrib.block_size & 0xff; 1097f7caf6aSAndy Grover 1107f7caf6aSAndy Grover if (dev->transport->get_lbppbe) 1117f7caf6aSAndy Grover buf[13] = dev->transport->get_lbppbe(dev) & 0x0f; 1127f7caf6aSAndy Grover 1137f7caf6aSAndy Grover if (dev->transport->get_alignment_offset_lbas) { 1147f7caf6aSAndy Grover u16 lalba = dev->transport->get_alignment_offset_lbas(dev); 1157f7caf6aSAndy Grover buf[14] = (lalba >> 8) & 0x3f; 1167f7caf6aSAndy Grover buf[15] = lalba & 0xff; 1177f7caf6aSAndy Grover } 1187f7caf6aSAndy Grover 1191fd032eeSChristoph Hellwig /* 1201fd032eeSChristoph Hellwig * Set Thin Provisioning Enable bit following sbc3r22 in section 1211fd032eeSChristoph Hellwig * READ CAPACITY (16) byte 14 if emulate_tpu or emulate_tpws is enabled. 1221fd032eeSChristoph Hellwig */ 1230fd97ccfSChristoph Hellwig if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws) 1247f7caf6aSAndy Grover buf[14] |= 0x80; 1251fd032eeSChristoph Hellwig 126a50da144SPaolo Bonzini rbuf = transport_kmap_data_sg(cmd); 1278b4b0dcbSNicholas Bellinger if (rbuf) { 128a50da144SPaolo Bonzini memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length)); 1291fd032eeSChristoph Hellwig transport_kunmap_data_sg(cmd); 1308b4b0dcbSNicholas Bellinger } 1311fd032eeSChristoph Hellwig 1321fd032eeSChristoph Hellwig target_complete_cmd(cmd, GOOD); 1331fd032eeSChristoph Hellwig return 0; 1341fd032eeSChristoph Hellwig } 1351fd032eeSChristoph Hellwig 136972b29c8SRoland Dreier sector_t sbc_get_write_same_sectors(struct se_cmd *cmd) 1371fd032eeSChristoph Hellwig { 1381fd032eeSChristoph Hellwig u32 num_blocks; 1391fd032eeSChristoph Hellwig 1401fd032eeSChristoph Hellwig if (cmd->t_task_cdb[0] == WRITE_SAME) 1411fd032eeSChristoph Hellwig num_blocks = get_unaligned_be16(&cmd->t_task_cdb[7]); 1421fd032eeSChristoph Hellwig else if (cmd->t_task_cdb[0] == WRITE_SAME_16) 1431fd032eeSChristoph Hellwig num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]); 1441fd032eeSChristoph Hellwig else /* WRITE_SAME_32 via VARIABLE_LENGTH_CMD */ 1451fd032eeSChristoph Hellwig num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]); 1461fd032eeSChristoph Hellwig 1471fd032eeSChristoph Hellwig /* 1481fd032eeSChristoph Hellwig * Use the explicit range when non zero is supplied, otherwise calculate 1491fd032eeSChristoph Hellwig * the remaining range based on ->get_blocks() - starting LBA. 1501fd032eeSChristoph Hellwig */ 1516f974e8cSChristoph Hellwig if (num_blocks) 1526f974e8cSChristoph Hellwig return num_blocks; 1531fd032eeSChristoph Hellwig 1546f974e8cSChristoph Hellwig return cmd->se_dev->transport->get_blocks(cmd->se_dev) - 1556f974e8cSChristoph Hellwig cmd->t_task_lba + 1; 1561fd032eeSChristoph Hellwig } 157972b29c8SRoland Dreier EXPORT_SYMBOL(sbc_get_write_same_sectors); 1581fd032eeSChristoph Hellwig 159de103c93SChristoph Hellwig static sense_reason_t 1601920ed61SNicholas Bellinger sbc_emulate_noop(struct se_cmd *cmd) 1611a1ff38cSBernhard Kohl { 1621a1ff38cSBernhard Kohl target_complete_cmd(cmd, GOOD); 1631a1ff38cSBernhard Kohl return 0; 1641a1ff38cSBernhard Kohl } 1651a1ff38cSBernhard Kohl 166d6e0175cSChristoph Hellwig static inline u32 sbc_get_size(struct se_cmd *cmd, u32 sectors) 167d6e0175cSChristoph Hellwig { 1680fd97ccfSChristoph Hellwig return cmd->se_dev->dev_attrib.block_size * sectors; 169d6e0175cSChristoph Hellwig } 170d6e0175cSChristoph Hellwig 171d6e0175cSChristoph Hellwig static int sbc_check_valid_sectors(struct se_cmd *cmd) 172d6e0175cSChristoph Hellwig { 173d6e0175cSChristoph Hellwig struct se_device *dev = cmd->se_dev; 174d6e0175cSChristoph Hellwig unsigned long long end_lba; 175d6e0175cSChristoph Hellwig u32 sectors; 176d6e0175cSChristoph Hellwig 1770fd97ccfSChristoph Hellwig sectors = cmd->data_length / dev->dev_attrib.block_size; 178d6e0175cSChristoph Hellwig end_lba = dev->transport->get_blocks(dev) + 1; 179d6e0175cSChristoph Hellwig 180d6e0175cSChristoph Hellwig if (cmd->t_task_lba + sectors > end_lba) { 181d6e0175cSChristoph Hellwig pr_err("target: lba %llu, sectors %u exceeds end lba %llu\n", 182d6e0175cSChristoph Hellwig cmd->t_task_lba, sectors, end_lba); 183d6e0175cSChristoph Hellwig return -EINVAL; 184d6e0175cSChristoph Hellwig } 185d6e0175cSChristoph Hellwig 186d6e0175cSChristoph Hellwig return 0; 187d6e0175cSChristoph Hellwig } 188d6e0175cSChristoph Hellwig 189d6e0175cSChristoph Hellwig static inline u32 transport_get_sectors_6(unsigned char *cdb) 190d6e0175cSChristoph Hellwig { 191d6e0175cSChristoph Hellwig /* 192d6e0175cSChristoph Hellwig * Use 8-bit sector value. SBC-3 says: 193d6e0175cSChristoph Hellwig * 194d6e0175cSChristoph Hellwig * A TRANSFER LENGTH field set to zero specifies that 256 195d6e0175cSChristoph Hellwig * logical blocks shall be written. Any other value 196d6e0175cSChristoph Hellwig * specifies the number of logical blocks that shall be 197d6e0175cSChristoph Hellwig * written. 198d6e0175cSChristoph Hellwig */ 199d6e0175cSChristoph Hellwig return cdb[4] ? : 256; 200d6e0175cSChristoph Hellwig } 201d6e0175cSChristoph Hellwig 202d6e0175cSChristoph Hellwig static inline u32 transport_get_sectors_10(unsigned char *cdb) 203d6e0175cSChristoph Hellwig { 204d6e0175cSChristoph Hellwig return (u32)(cdb[7] << 8) + cdb[8]; 205d6e0175cSChristoph Hellwig } 206d6e0175cSChristoph Hellwig 207d6e0175cSChristoph Hellwig static inline u32 transport_get_sectors_12(unsigned char *cdb) 208d6e0175cSChristoph Hellwig { 209d6e0175cSChristoph Hellwig return (u32)(cdb[6] << 24) + (cdb[7] << 16) + (cdb[8] << 8) + cdb[9]; 210d6e0175cSChristoph Hellwig } 211d6e0175cSChristoph Hellwig 212d6e0175cSChristoph Hellwig static inline u32 transport_get_sectors_16(unsigned char *cdb) 213d6e0175cSChristoph Hellwig { 214d6e0175cSChristoph Hellwig return (u32)(cdb[10] << 24) + (cdb[11] << 16) + 215d6e0175cSChristoph Hellwig (cdb[12] << 8) + cdb[13]; 216d6e0175cSChristoph Hellwig } 217d6e0175cSChristoph Hellwig 218d6e0175cSChristoph Hellwig /* 219d6e0175cSChristoph Hellwig * Used for VARIABLE_LENGTH_CDB WRITE_32 and READ_32 variants 220d6e0175cSChristoph Hellwig */ 221d6e0175cSChristoph Hellwig static inline u32 transport_get_sectors_32(unsigned char *cdb) 222d6e0175cSChristoph Hellwig { 223d6e0175cSChristoph Hellwig return (u32)(cdb[28] << 24) + (cdb[29] << 16) + 224d6e0175cSChristoph Hellwig (cdb[30] << 8) + cdb[31]; 225d6e0175cSChristoph Hellwig 226d6e0175cSChristoph Hellwig } 227d6e0175cSChristoph Hellwig 228d6e0175cSChristoph Hellwig static inline u32 transport_lba_21(unsigned char *cdb) 229d6e0175cSChristoph Hellwig { 230d6e0175cSChristoph Hellwig return ((cdb[1] & 0x1f) << 16) | (cdb[2] << 8) | cdb[3]; 231d6e0175cSChristoph Hellwig } 232d6e0175cSChristoph Hellwig 233d6e0175cSChristoph Hellwig static inline u32 transport_lba_32(unsigned char *cdb) 234d6e0175cSChristoph Hellwig { 235d6e0175cSChristoph Hellwig return (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; 236d6e0175cSChristoph Hellwig } 237d6e0175cSChristoph Hellwig 238d6e0175cSChristoph Hellwig static inline unsigned long long transport_lba_64(unsigned char *cdb) 239d6e0175cSChristoph Hellwig { 240d6e0175cSChristoph Hellwig unsigned int __v1, __v2; 241d6e0175cSChristoph Hellwig 242d6e0175cSChristoph Hellwig __v1 = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; 243d6e0175cSChristoph Hellwig __v2 = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9]; 244d6e0175cSChristoph Hellwig 245d6e0175cSChristoph Hellwig return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32; 246d6e0175cSChristoph Hellwig } 247d6e0175cSChristoph Hellwig 248d6e0175cSChristoph Hellwig /* 249d6e0175cSChristoph Hellwig * For VARIABLE_LENGTH_CDB w/ 32 byte extended CDBs 250d6e0175cSChristoph Hellwig */ 251d6e0175cSChristoph Hellwig static inline unsigned long long transport_lba_64_ext(unsigned char *cdb) 252d6e0175cSChristoph Hellwig { 253d6e0175cSChristoph Hellwig unsigned int __v1, __v2; 254d6e0175cSChristoph Hellwig 255d6e0175cSChristoph Hellwig __v1 = (cdb[12] << 24) | (cdb[13] << 16) | (cdb[14] << 8) | cdb[15]; 256d6e0175cSChristoph Hellwig __v2 = (cdb[16] << 24) | (cdb[17] << 16) | (cdb[18] << 8) | cdb[19]; 257d6e0175cSChristoph Hellwig 258d6e0175cSChristoph Hellwig return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32; 259d6e0175cSChristoph Hellwig } 260d6e0175cSChristoph Hellwig 261cd063befSNicholas Bellinger static sense_reason_t 262cd063befSNicholas Bellinger sbc_setup_write_same(struct se_cmd *cmd, unsigned char *flags, struct sbc_ops *ops) 263d6e0175cSChristoph Hellwig { 264972b29c8SRoland Dreier unsigned int sectors = sbc_get_write_same_sectors(cmd); 265773cbaf7SNicholas Bellinger 266d6e0175cSChristoph Hellwig if ((flags[0] & 0x04) || (flags[0] & 0x02)) { 267d6e0175cSChristoph Hellwig pr_err("WRITE_SAME PBDATA and LBDATA" 268d6e0175cSChristoph Hellwig " bits not supported for Block Discard" 269d6e0175cSChristoph Hellwig " Emulation\n"); 270cd063befSNicholas Bellinger return TCM_UNSUPPORTED_SCSI_OPCODE; 271d6e0175cSChristoph Hellwig } 272773cbaf7SNicholas Bellinger if (sectors > cmd->se_dev->dev_attrib.max_write_same_len) { 273773cbaf7SNicholas Bellinger pr_warn("WRITE_SAME sectors: %u exceeds max_write_same_len: %u\n", 274773cbaf7SNicholas Bellinger sectors, cmd->se_dev->dev_attrib.max_write_same_len); 275773cbaf7SNicholas Bellinger return TCM_INVALID_CDB_FIELD; 276773cbaf7SNicholas Bellinger } 2775cb770bfSRoland Dreier /* We always have ANC_SUP == 0 so setting ANCHOR is always an error */ 2785cb770bfSRoland Dreier if (flags[0] & 0x10) { 2795cb770bfSRoland Dreier pr_warn("WRITE SAME with ANCHOR not supported\n"); 2805cb770bfSRoland Dreier return TCM_INVALID_CDB_FIELD; 2815cb770bfSRoland Dreier } 282d6e0175cSChristoph Hellwig /* 283cd063befSNicholas Bellinger * Special case for WRITE_SAME w/ UNMAP=1 that ends up getting 284cd063befSNicholas Bellinger * translated into block discard requests within backend code. 285d6e0175cSChristoph Hellwig */ 286cd063befSNicholas Bellinger if (flags[0] & 0x08) { 287cd063befSNicholas Bellinger if (!ops->execute_write_same_unmap) 288cd063befSNicholas Bellinger return TCM_UNSUPPORTED_SCSI_OPCODE; 289d6e0175cSChristoph Hellwig 290cd063befSNicholas Bellinger cmd->execute_cmd = ops->execute_write_same_unmap; 291cd063befSNicholas Bellinger return 0; 292cd063befSNicholas Bellinger } 293cd063befSNicholas Bellinger if (!ops->execute_write_same) 294cd063befSNicholas Bellinger return TCM_UNSUPPORTED_SCSI_OPCODE; 295cd063befSNicholas Bellinger 296cd063befSNicholas Bellinger cmd->execute_cmd = ops->execute_write_same; 297d6e0175cSChristoph Hellwig return 0; 298d6e0175cSChristoph Hellwig } 299d6e0175cSChristoph Hellwig 300a6b0133cSNicholas Bellinger static sense_reason_t xdreadwrite_callback(struct se_cmd *cmd) 301d6e0175cSChristoph Hellwig { 302d6e0175cSChristoph Hellwig unsigned char *buf, *addr; 303d6e0175cSChristoph Hellwig struct scatterlist *sg; 304d6e0175cSChristoph Hellwig unsigned int offset; 305a6b0133cSNicholas Bellinger sense_reason_t ret = TCM_NO_SENSE; 306a6b0133cSNicholas Bellinger int i, count; 307d6e0175cSChristoph Hellwig /* 308d6e0175cSChristoph Hellwig * From sbc3r22.pdf section 5.48 XDWRITEREAD (10) command 309d6e0175cSChristoph Hellwig * 310d6e0175cSChristoph Hellwig * 1) read the specified logical block(s); 311d6e0175cSChristoph Hellwig * 2) transfer logical blocks from the data-out buffer; 312d6e0175cSChristoph Hellwig * 3) XOR the logical blocks transferred from the data-out buffer with 313d6e0175cSChristoph Hellwig * the logical blocks read, storing the resulting XOR data in a buffer; 314d6e0175cSChristoph Hellwig * 4) if the DISABLE WRITE bit is set to zero, then write the logical 315d6e0175cSChristoph Hellwig * blocks transferred from the data-out buffer; and 316d6e0175cSChristoph Hellwig * 5) transfer the resulting XOR data to the data-in buffer. 317d6e0175cSChristoph Hellwig */ 318d6e0175cSChristoph Hellwig buf = kmalloc(cmd->data_length, GFP_KERNEL); 319d6e0175cSChristoph Hellwig if (!buf) { 320d6e0175cSChristoph Hellwig pr_err("Unable to allocate xor_callback buf\n"); 321a6b0133cSNicholas Bellinger return TCM_OUT_OF_RESOURCES; 322d6e0175cSChristoph Hellwig } 323d6e0175cSChristoph Hellwig /* 324d6e0175cSChristoph Hellwig * Copy the scatterlist WRITE buffer located at cmd->t_data_sg 325d6e0175cSChristoph Hellwig * into the locally allocated *buf 326d6e0175cSChristoph Hellwig */ 327d6e0175cSChristoph Hellwig sg_copy_to_buffer(cmd->t_data_sg, 328d6e0175cSChristoph Hellwig cmd->t_data_nents, 329d6e0175cSChristoph Hellwig buf, 330d6e0175cSChristoph Hellwig cmd->data_length); 331d6e0175cSChristoph Hellwig 332d6e0175cSChristoph Hellwig /* 333d6e0175cSChristoph Hellwig * Now perform the XOR against the BIDI read memory located at 334d6e0175cSChristoph Hellwig * cmd->t_mem_bidi_list 335d6e0175cSChristoph Hellwig */ 336d6e0175cSChristoph Hellwig 337d6e0175cSChristoph Hellwig offset = 0; 338d6e0175cSChristoph Hellwig for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, count) { 339d6e0175cSChristoph Hellwig addr = kmap_atomic(sg_page(sg)); 340a6b0133cSNicholas Bellinger if (!addr) { 341a6b0133cSNicholas Bellinger ret = TCM_OUT_OF_RESOURCES; 342d6e0175cSChristoph Hellwig goto out; 343a6b0133cSNicholas Bellinger } 344d6e0175cSChristoph Hellwig 345d6e0175cSChristoph Hellwig for (i = 0; i < sg->length; i++) 346d6e0175cSChristoph Hellwig *(addr + sg->offset + i) ^= *(buf + offset + i); 347d6e0175cSChristoph Hellwig 348d6e0175cSChristoph Hellwig offset += sg->length; 349d6e0175cSChristoph Hellwig kunmap_atomic(addr); 350d6e0175cSChristoph Hellwig } 351d6e0175cSChristoph Hellwig 352d6e0175cSChristoph Hellwig out: 353d6e0175cSChristoph Hellwig kfree(buf); 354a6b0133cSNicholas Bellinger return ret; 355d6e0175cSChristoph Hellwig } 356d6e0175cSChristoph Hellwig 357a82a9538SNicholas Bellinger static sense_reason_t 358a82a9538SNicholas Bellinger sbc_execute_rw(struct se_cmd *cmd) 359a82a9538SNicholas Bellinger { 360a82a9538SNicholas Bellinger return cmd->execute_rw(cmd, cmd->t_data_sg, cmd->t_data_nents, 361a82a9538SNicholas Bellinger cmd->data_direction); 362a82a9538SNicholas Bellinger } 363a82a9538SNicholas Bellinger 36468ff9b9bSNicholas Bellinger static sense_reason_t compare_and_write_post(struct se_cmd *cmd) 36568ff9b9bSNicholas Bellinger { 36668ff9b9bSNicholas Bellinger struct se_device *dev = cmd->se_dev; 36768ff9b9bSNicholas Bellinger 368d8855c15SNicholas Bellinger /* 369d8855c15SNicholas Bellinger * Only set SCF_COMPARE_AND_WRITE_POST to force a response fall-through 370d8855c15SNicholas Bellinger * within target_complete_ok_work() if the command was successfully 371d8855c15SNicholas Bellinger * sent to the backend driver. 372d8855c15SNicholas Bellinger */ 373d8855c15SNicholas Bellinger spin_lock_irq(&cmd->t_state_lock); 374d8855c15SNicholas Bellinger if ((cmd->transport_state & CMD_T_SENT) && !cmd->scsi_status) 37568ff9b9bSNicholas Bellinger cmd->se_cmd_flags |= SCF_COMPARE_AND_WRITE_POST; 376d8855c15SNicholas Bellinger spin_unlock_irq(&cmd->t_state_lock); 377d8855c15SNicholas Bellinger 37868ff9b9bSNicholas Bellinger /* 37968ff9b9bSNicholas Bellinger * Unlock ->caw_sem originally obtained during sbc_compare_and_write() 38068ff9b9bSNicholas Bellinger * before the original READ I/O submission. 38168ff9b9bSNicholas Bellinger */ 38268ff9b9bSNicholas Bellinger up(&dev->caw_sem); 38368ff9b9bSNicholas Bellinger 38468ff9b9bSNicholas Bellinger return TCM_NO_SENSE; 38568ff9b9bSNicholas Bellinger } 38668ff9b9bSNicholas Bellinger 38768ff9b9bSNicholas Bellinger static sense_reason_t compare_and_write_callback(struct se_cmd *cmd) 38868ff9b9bSNicholas Bellinger { 38968ff9b9bSNicholas Bellinger struct se_device *dev = cmd->se_dev; 39068ff9b9bSNicholas Bellinger struct scatterlist *write_sg = NULL, *sg; 391db60df88SNicholas Bellinger unsigned char *buf = NULL, *addr; 39268ff9b9bSNicholas Bellinger struct sg_mapping_iter m; 39368ff9b9bSNicholas Bellinger unsigned int offset = 0, len; 39468ff9b9bSNicholas Bellinger unsigned int nlbas = cmd->t_task_nolb; 39568ff9b9bSNicholas Bellinger unsigned int block_size = dev->dev_attrib.block_size; 39668ff9b9bSNicholas Bellinger unsigned int compare_len = (nlbas * block_size); 39768ff9b9bSNicholas Bellinger sense_reason_t ret = TCM_NO_SENSE; 39868ff9b9bSNicholas Bellinger int rc, i; 39968ff9b9bSNicholas Bellinger 400cf6d1f09SNicholas Bellinger /* 401cf6d1f09SNicholas Bellinger * Handle early failure in transport_generic_request_failure(), 402cf6d1f09SNicholas Bellinger * which will not have taken ->caw_mutex yet.. 403cf6d1f09SNicholas Bellinger */ 404cf6d1f09SNicholas Bellinger if (!cmd->t_data_sg || !cmd->t_bidi_data_sg) 405cf6d1f09SNicholas Bellinger return TCM_NO_SENSE; 406db60df88SNicholas Bellinger /* 407db60df88SNicholas Bellinger * Immediately exit + release dev->caw_sem if command has already 408db60df88SNicholas Bellinger * been failed with a non-zero SCSI status. 409db60df88SNicholas Bellinger */ 410db60df88SNicholas Bellinger if (cmd->scsi_status) { 411db60df88SNicholas Bellinger pr_err("compare_and_write_callback: non zero scsi_status:" 412db60df88SNicholas Bellinger " 0x%02x\n", cmd->scsi_status); 413db60df88SNicholas Bellinger goto out; 414db60df88SNicholas Bellinger } 415cf6d1f09SNicholas Bellinger 41668ff9b9bSNicholas Bellinger buf = kzalloc(cmd->data_length, GFP_KERNEL); 41768ff9b9bSNicholas Bellinger if (!buf) { 41868ff9b9bSNicholas Bellinger pr_err("Unable to allocate compare_and_write buf\n"); 419a2890087SNicholas Bellinger ret = TCM_OUT_OF_RESOURCES; 420a2890087SNicholas Bellinger goto out; 42168ff9b9bSNicholas Bellinger } 42268ff9b9bSNicholas Bellinger 42368ff9b9bSNicholas Bellinger write_sg = kzalloc(sizeof(struct scatterlist) * cmd->t_data_nents, 42468ff9b9bSNicholas Bellinger GFP_KERNEL); 42568ff9b9bSNicholas Bellinger if (!write_sg) { 42668ff9b9bSNicholas Bellinger pr_err("Unable to allocate compare_and_write sg\n"); 42768ff9b9bSNicholas Bellinger ret = TCM_OUT_OF_RESOURCES; 42868ff9b9bSNicholas Bellinger goto out; 42968ff9b9bSNicholas Bellinger } 43068ff9b9bSNicholas Bellinger /* 43168ff9b9bSNicholas Bellinger * Setup verify and write data payloads from total NumberLBAs. 43268ff9b9bSNicholas Bellinger */ 43368ff9b9bSNicholas Bellinger rc = sg_copy_to_buffer(cmd->t_data_sg, cmd->t_data_nents, buf, 43468ff9b9bSNicholas Bellinger cmd->data_length); 43568ff9b9bSNicholas Bellinger if (!rc) { 43668ff9b9bSNicholas Bellinger pr_err("sg_copy_to_buffer() failed for compare_and_write\n"); 43768ff9b9bSNicholas Bellinger ret = TCM_OUT_OF_RESOURCES; 43868ff9b9bSNicholas Bellinger goto out; 43968ff9b9bSNicholas Bellinger } 44068ff9b9bSNicholas Bellinger /* 44168ff9b9bSNicholas Bellinger * Compare against SCSI READ payload against verify payload 44268ff9b9bSNicholas Bellinger */ 44368ff9b9bSNicholas Bellinger for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, i) { 44468ff9b9bSNicholas Bellinger addr = (unsigned char *)kmap_atomic(sg_page(sg)); 44568ff9b9bSNicholas Bellinger if (!addr) { 44668ff9b9bSNicholas Bellinger ret = TCM_OUT_OF_RESOURCES; 44768ff9b9bSNicholas Bellinger goto out; 44868ff9b9bSNicholas Bellinger } 44968ff9b9bSNicholas Bellinger 45068ff9b9bSNicholas Bellinger len = min(sg->length, compare_len); 45168ff9b9bSNicholas Bellinger 45268ff9b9bSNicholas Bellinger if (memcmp(addr, buf + offset, len)) { 45368ff9b9bSNicholas Bellinger pr_warn("Detected MISCOMPARE for addr: %p buf: %p\n", 45468ff9b9bSNicholas Bellinger addr, buf + offset); 45568ff9b9bSNicholas Bellinger kunmap_atomic(addr); 45668ff9b9bSNicholas Bellinger goto miscompare; 45768ff9b9bSNicholas Bellinger } 45868ff9b9bSNicholas Bellinger kunmap_atomic(addr); 45968ff9b9bSNicholas Bellinger 46068ff9b9bSNicholas Bellinger offset += len; 46168ff9b9bSNicholas Bellinger compare_len -= len; 46268ff9b9bSNicholas Bellinger if (!compare_len) 46368ff9b9bSNicholas Bellinger break; 46468ff9b9bSNicholas Bellinger } 46568ff9b9bSNicholas Bellinger 46668ff9b9bSNicholas Bellinger i = 0; 46768ff9b9bSNicholas Bellinger len = cmd->t_task_nolb * block_size; 46868ff9b9bSNicholas Bellinger sg_miter_start(&m, cmd->t_data_sg, cmd->t_data_nents, SG_MITER_TO_SG); 46968ff9b9bSNicholas Bellinger /* 47068ff9b9bSNicholas Bellinger * Currently assumes NoLB=1 and SGLs are PAGE_SIZE.. 47168ff9b9bSNicholas Bellinger */ 47268ff9b9bSNicholas Bellinger while (len) { 47368ff9b9bSNicholas Bellinger sg_miter_next(&m); 47468ff9b9bSNicholas Bellinger 47568ff9b9bSNicholas Bellinger if (block_size < PAGE_SIZE) { 47668ff9b9bSNicholas Bellinger sg_set_page(&write_sg[i], m.page, block_size, 47768ff9b9bSNicholas Bellinger block_size); 47868ff9b9bSNicholas Bellinger } else { 47968ff9b9bSNicholas Bellinger sg_miter_next(&m); 48068ff9b9bSNicholas Bellinger sg_set_page(&write_sg[i], m.page, block_size, 48168ff9b9bSNicholas Bellinger 0); 48268ff9b9bSNicholas Bellinger } 48368ff9b9bSNicholas Bellinger len -= block_size; 48468ff9b9bSNicholas Bellinger i++; 48568ff9b9bSNicholas Bellinger } 48668ff9b9bSNicholas Bellinger sg_miter_stop(&m); 48768ff9b9bSNicholas Bellinger /* 48868ff9b9bSNicholas Bellinger * Save the original SGL + nents values before updating to new 48968ff9b9bSNicholas Bellinger * assignments, to be released in transport_free_pages() -> 49068ff9b9bSNicholas Bellinger * transport_reset_sgl_orig() 49168ff9b9bSNicholas Bellinger */ 49268ff9b9bSNicholas Bellinger cmd->t_data_sg_orig = cmd->t_data_sg; 49368ff9b9bSNicholas Bellinger cmd->t_data_sg = write_sg; 49468ff9b9bSNicholas Bellinger cmd->t_data_nents_orig = cmd->t_data_nents; 49568ff9b9bSNicholas Bellinger cmd->t_data_nents = 1; 49668ff9b9bSNicholas Bellinger 49768ff9b9bSNicholas Bellinger cmd->sam_task_attr = MSG_HEAD_TAG; 49868ff9b9bSNicholas Bellinger cmd->transport_complete_callback = compare_and_write_post; 49968ff9b9bSNicholas Bellinger /* 50068ff9b9bSNicholas Bellinger * Now reset ->execute_cmd() to the normal sbc_execute_rw() handler 50168ff9b9bSNicholas Bellinger * for submitting the adjusted SGL to write instance user-data. 50268ff9b9bSNicholas Bellinger */ 50368ff9b9bSNicholas Bellinger cmd->execute_cmd = sbc_execute_rw; 50468ff9b9bSNicholas Bellinger 50568ff9b9bSNicholas Bellinger spin_lock_irq(&cmd->t_state_lock); 50668ff9b9bSNicholas Bellinger cmd->t_state = TRANSPORT_PROCESSING; 50768ff9b9bSNicholas Bellinger cmd->transport_state |= CMD_T_ACTIVE|CMD_T_BUSY|CMD_T_SENT; 50868ff9b9bSNicholas Bellinger spin_unlock_irq(&cmd->t_state_lock); 50968ff9b9bSNicholas Bellinger 51068ff9b9bSNicholas Bellinger __target_execute_cmd(cmd); 51168ff9b9bSNicholas Bellinger 51268ff9b9bSNicholas Bellinger kfree(buf); 51368ff9b9bSNicholas Bellinger return ret; 51468ff9b9bSNicholas Bellinger 51568ff9b9bSNicholas Bellinger miscompare: 51668ff9b9bSNicholas Bellinger pr_warn("Target/%s: Send MISCOMPARE check condition and sense\n", 51768ff9b9bSNicholas Bellinger dev->transport->name); 51868ff9b9bSNicholas Bellinger ret = TCM_MISCOMPARE_VERIFY; 51968ff9b9bSNicholas Bellinger out: 52068ff9b9bSNicholas Bellinger /* 52168ff9b9bSNicholas Bellinger * In the MISCOMPARE or failure case, unlock ->caw_sem obtained in 52268ff9b9bSNicholas Bellinger * sbc_compare_and_write() before the original READ I/O submission. 52368ff9b9bSNicholas Bellinger */ 52468ff9b9bSNicholas Bellinger up(&dev->caw_sem); 52568ff9b9bSNicholas Bellinger kfree(write_sg); 52668ff9b9bSNicholas Bellinger kfree(buf); 52768ff9b9bSNicholas Bellinger return ret; 52868ff9b9bSNicholas Bellinger } 52968ff9b9bSNicholas Bellinger 53068ff9b9bSNicholas Bellinger static sense_reason_t 53168ff9b9bSNicholas Bellinger sbc_compare_and_write(struct se_cmd *cmd) 53268ff9b9bSNicholas Bellinger { 53368ff9b9bSNicholas Bellinger struct se_device *dev = cmd->se_dev; 53468ff9b9bSNicholas Bellinger sense_reason_t ret; 53568ff9b9bSNicholas Bellinger int rc; 53668ff9b9bSNicholas Bellinger /* 53768ff9b9bSNicholas Bellinger * Submit the READ first for COMPARE_AND_WRITE to perform the 53868ff9b9bSNicholas Bellinger * comparision using SGLs at cmd->t_bidi_data_sg.. 53968ff9b9bSNicholas Bellinger */ 54068ff9b9bSNicholas Bellinger rc = down_interruptible(&dev->caw_sem); 54168ff9b9bSNicholas Bellinger if ((rc != 0) || signal_pending(current)) { 54268ff9b9bSNicholas Bellinger cmd->transport_complete_callback = NULL; 54368ff9b9bSNicholas Bellinger return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 54468ff9b9bSNicholas Bellinger } 545b7191253SNicholas Bellinger /* 546b7191253SNicholas Bellinger * Reset cmd->data_length to individual block_size in order to not 547b7191253SNicholas Bellinger * confuse backend drivers that depend on this value matching the 548b7191253SNicholas Bellinger * size of the I/O being submitted. 549b7191253SNicholas Bellinger */ 550b7191253SNicholas Bellinger cmd->data_length = cmd->t_task_nolb * dev->dev_attrib.block_size; 55168ff9b9bSNicholas Bellinger 55268ff9b9bSNicholas Bellinger ret = cmd->execute_rw(cmd, cmd->t_bidi_data_sg, cmd->t_bidi_data_nents, 55368ff9b9bSNicholas Bellinger DMA_FROM_DEVICE); 55468ff9b9bSNicholas Bellinger if (ret) { 55568ff9b9bSNicholas Bellinger cmd->transport_complete_callback = NULL; 55668ff9b9bSNicholas Bellinger up(&dev->caw_sem); 55768ff9b9bSNicholas Bellinger return ret; 55868ff9b9bSNicholas Bellinger } 55968ff9b9bSNicholas Bellinger /* 56068ff9b9bSNicholas Bellinger * Unlock of dev->caw_sem to occur in compare_and_write_callback() 56168ff9b9bSNicholas Bellinger * upon MISCOMPARE, or in compare_and_write_done() upon completion 56268ff9b9bSNicholas Bellinger * of WRITE instance user-data. 56368ff9b9bSNicholas Bellinger */ 56468ff9b9bSNicholas Bellinger return TCM_NO_SENSE; 56568ff9b9bSNicholas Bellinger } 56668ff9b9bSNicholas Bellinger 567499bf77bSNicholas Bellinger static bool 568499bf77bSNicholas Bellinger sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb, 569499bf77bSNicholas Bellinger u32 sectors) 570499bf77bSNicholas Bellinger { 571499bf77bSNicholas Bellinger if (!cmd->t_prot_sg || !cmd->t_prot_nents) 572499bf77bSNicholas Bellinger return true; 573499bf77bSNicholas Bellinger 574499bf77bSNicholas Bellinger switch (dev->dev_attrib.pi_prot_type) { 575499bf77bSNicholas Bellinger case TARGET_DIF_TYPE3_PROT: 576499bf77bSNicholas Bellinger if (!(cdb[1] & 0xe0)) 577499bf77bSNicholas Bellinger return true; 578499bf77bSNicholas Bellinger 579499bf77bSNicholas Bellinger cmd->reftag_seed = 0xffffffff; 580499bf77bSNicholas Bellinger break; 581499bf77bSNicholas Bellinger case TARGET_DIF_TYPE2_PROT: 582499bf77bSNicholas Bellinger if (cdb[1] & 0xe0) 583499bf77bSNicholas Bellinger return false; 584499bf77bSNicholas Bellinger 585499bf77bSNicholas Bellinger cmd->reftag_seed = cmd->t_task_lba; 586499bf77bSNicholas Bellinger break; 587499bf77bSNicholas Bellinger case TARGET_DIF_TYPE1_PROT: 588499bf77bSNicholas Bellinger if (!(cdb[1] & 0xe0)) 589499bf77bSNicholas Bellinger return true; 590499bf77bSNicholas Bellinger 591499bf77bSNicholas Bellinger cmd->reftag_seed = cmd->t_task_lba; 592499bf77bSNicholas Bellinger break; 593499bf77bSNicholas Bellinger case TARGET_DIF_TYPE0_PROT: 594499bf77bSNicholas Bellinger default: 595499bf77bSNicholas Bellinger return true; 596499bf77bSNicholas Bellinger } 597499bf77bSNicholas Bellinger 598499bf77bSNicholas Bellinger cmd->prot_type = dev->dev_attrib.pi_prot_type; 599499bf77bSNicholas Bellinger cmd->prot_length = dev->prot_length * sectors; 600499bf77bSNicholas Bellinger cmd->prot_handover = PROT_SEPERATED; 601499bf77bSNicholas Bellinger 602499bf77bSNicholas Bellinger return true; 603499bf77bSNicholas Bellinger } 604499bf77bSNicholas Bellinger 605de103c93SChristoph Hellwig sense_reason_t 606de103c93SChristoph Hellwig sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops) 607d6e0175cSChristoph Hellwig { 608d6e0175cSChristoph Hellwig struct se_device *dev = cmd->se_dev; 609d6e0175cSChristoph Hellwig unsigned char *cdb = cmd->t_task_cdb; 6101fd032eeSChristoph Hellwig unsigned int size; 611d6e0175cSChristoph Hellwig u32 sectors = 0; 612de103c93SChristoph Hellwig sense_reason_t ret; 613d6e0175cSChristoph Hellwig 614d6e0175cSChristoph Hellwig switch (cdb[0]) { 615d6e0175cSChristoph Hellwig case READ_6: 616d6e0175cSChristoph Hellwig sectors = transport_get_sectors_6(cdb); 617d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_21(cdb); 618d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 619a82a9538SNicholas Bellinger cmd->execute_rw = ops->execute_rw; 620a82a9538SNicholas Bellinger cmd->execute_cmd = sbc_execute_rw; 621d6e0175cSChristoph Hellwig break; 622d6e0175cSChristoph Hellwig case READ_10: 623d6e0175cSChristoph Hellwig sectors = transport_get_sectors_10(cdb); 624d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_32(cdb); 625499bf77bSNicholas Bellinger 626499bf77bSNicholas Bellinger if (!sbc_check_prot(dev, cmd, cdb, sectors)) 627499bf77bSNicholas Bellinger return TCM_UNSUPPORTED_SCSI_OPCODE; 628499bf77bSNicholas Bellinger 629d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 630a82a9538SNicholas Bellinger cmd->execute_rw = ops->execute_rw; 631a82a9538SNicholas Bellinger cmd->execute_cmd = sbc_execute_rw; 632d6e0175cSChristoph Hellwig break; 633d6e0175cSChristoph Hellwig case READ_12: 634d6e0175cSChristoph Hellwig sectors = transport_get_sectors_12(cdb); 635d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_32(cdb); 636499bf77bSNicholas Bellinger 637499bf77bSNicholas Bellinger if (!sbc_check_prot(dev, cmd, cdb, sectors)) 638499bf77bSNicholas Bellinger return TCM_UNSUPPORTED_SCSI_OPCODE; 639499bf77bSNicholas Bellinger 640d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 641a82a9538SNicholas Bellinger cmd->execute_rw = ops->execute_rw; 642a82a9538SNicholas Bellinger cmd->execute_cmd = sbc_execute_rw; 643d6e0175cSChristoph Hellwig break; 644d6e0175cSChristoph Hellwig case READ_16: 645d6e0175cSChristoph Hellwig sectors = transport_get_sectors_16(cdb); 646d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_64(cdb); 647499bf77bSNicholas Bellinger 648499bf77bSNicholas Bellinger if (!sbc_check_prot(dev, cmd, cdb, sectors)) 649499bf77bSNicholas Bellinger return TCM_UNSUPPORTED_SCSI_OPCODE; 650499bf77bSNicholas Bellinger 651d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 652a82a9538SNicholas Bellinger cmd->execute_rw = ops->execute_rw; 653a82a9538SNicholas Bellinger cmd->execute_cmd = sbc_execute_rw; 654d6e0175cSChristoph Hellwig break; 655d6e0175cSChristoph Hellwig case WRITE_6: 656d6e0175cSChristoph Hellwig sectors = transport_get_sectors_6(cdb); 657d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_21(cdb); 658d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 659a82a9538SNicholas Bellinger cmd->execute_rw = ops->execute_rw; 660a82a9538SNicholas Bellinger cmd->execute_cmd = sbc_execute_rw; 661d6e0175cSChristoph Hellwig break; 662d6e0175cSChristoph Hellwig case WRITE_10: 663d6e0175cSChristoph Hellwig case WRITE_VERIFY: 664d6e0175cSChristoph Hellwig sectors = transport_get_sectors_10(cdb); 665d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_32(cdb); 666499bf77bSNicholas Bellinger 667499bf77bSNicholas Bellinger if (!sbc_check_prot(dev, cmd, cdb, sectors)) 668499bf77bSNicholas Bellinger return TCM_UNSUPPORTED_SCSI_OPCODE; 669499bf77bSNicholas Bellinger 670d6e0175cSChristoph Hellwig if (cdb[1] & 0x8) 671d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_FUA; 672d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 673a82a9538SNicholas Bellinger cmd->execute_rw = ops->execute_rw; 674a82a9538SNicholas Bellinger cmd->execute_cmd = sbc_execute_rw; 675d6e0175cSChristoph Hellwig break; 676d6e0175cSChristoph Hellwig case WRITE_12: 677d6e0175cSChristoph Hellwig sectors = transport_get_sectors_12(cdb); 678d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_32(cdb); 679499bf77bSNicholas Bellinger 680499bf77bSNicholas Bellinger if (!sbc_check_prot(dev, cmd, cdb, sectors)) 681499bf77bSNicholas Bellinger return TCM_UNSUPPORTED_SCSI_OPCODE; 682499bf77bSNicholas Bellinger 683d6e0175cSChristoph Hellwig if (cdb[1] & 0x8) 684d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_FUA; 685d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 686a82a9538SNicholas Bellinger cmd->execute_rw = ops->execute_rw; 687a82a9538SNicholas Bellinger cmd->execute_cmd = sbc_execute_rw; 688d6e0175cSChristoph Hellwig break; 689d6e0175cSChristoph Hellwig case WRITE_16: 690d6e0175cSChristoph Hellwig sectors = transport_get_sectors_16(cdb); 691d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_64(cdb); 692499bf77bSNicholas Bellinger 693499bf77bSNicholas Bellinger if (!sbc_check_prot(dev, cmd, cdb, sectors)) 694499bf77bSNicholas Bellinger return TCM_UNSUPPORTED_SCSI_OPCODE; 695499bf77bSNicholas Bellinger 696d6e0175cSChristoph Hellwig if (cdb[1] & 0x8) 697d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_FUA; 698d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 699a82a9538SNicholas Bellinger cmd->execute_rw = ops->execute_rw; 700a82a9538SNicholas Bellinger cmd->execute_cmd = sbc_execute_rw; 701d6e0175cSChristoph Hellwig break; 702d6e0175cSChristoph Hellwig case XDWRITEREAD_10: 703de103c93SChristoph Hellwig if (cmd->data_direction != DMA_TO_DEVICE || 704d6e0175cSChristoph Hellwig !(cmd->se_cmd_flags & SCF_BIDI)) 705de103c93SChristoph Hellwig return TCM_INVALID_CDB_FIELD; 706d6e0175cSChristoph Hellwig sectors = transport_get_sectors_10(cdb); 707d6e0175cSChristoph Hellwig 708d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_32(cdb); 709d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 710d6e0175cSChristoph Hellwig 711d6e0175cSChristoph Hellwig /* 712d6e0175cSChristoph Hellwig * Setup BIDI XOR callback to be run after I/O completion. 713d6e0175cSChristoph Hellwig */ 714a82a9538SNicholas Bellinger cmd->execute_rw = ops->execute_rw; 715a82a9538SNicholas Bellinger cmd->execute_cmd = sbc_execute_rw; 716d6e0175cSChristoph Hellwig cmd->transport_complete_callback = &xdreadwrite_callback; 717d6e0175cSChristoph Hellwig if (cdb[1] & 0x8) 718d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_FUA; 719d6e0175cSChristoph Hellwig break; 720d6e0175cSChristoph Hellwig case VARIABLE_LENGTH_CMD: 721d6e0175cSChristoph Hellwig { 722d6e0175cSChristoph Hellwig u16 service_action = get_unaligned_be16(&cdb[8]); 723d6e0175cSChristoph Hellwig switch (service_action) { 724d6e0175cSChristoph Hellwig case XDWRITEREAD_32: 725d6e0175cSChristoph Hellwig sectors = transport_get_sectors_32(cdb); 726d6e0175cSChristoph Hellwig 727d6e0175cSChristoph Hellwig /* 728d6e0175cSChristoph Hellwig * Use WRITE_32 and READ_32 opcodes for the emulated 729d6e0175cSChristoph Hellwig * XDWRITE_READ_32 logic. 730d6e0175cSChristoph Hellwig */ 731d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_64_ext(cdb); 732d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 733d6e0175cSChristoph Hellwig 734d6e0175cSChristoph Hellwig /* 735d6e0175cSChristoph Hellwig * Setup BIDI XOR callback to be run during after I/O 736d6e0175cSChristoph Hellwig * completion. 737d6e0175cSChristoph Hellwig */ 738a82a9538SNicholas Bellinger cmd->execute_rw = ops->execute_rw; 739a82a9538SNicholas Bellinger cmd->execute_cmd = sbc_execute_rw; 740d6e0175cSChristoph Hellwig cmd->transport_complete_callback = &xdreadwrite_callback; 741d6e0175cSChristoph Hellwig if (cdb[1] & 0x8) 742d6e0175cSChristoph Hellwig cmd->se_cmd_flags |= SCF_FUA; 743d6e0175cSChristoph Hellwig break; 744d6e0175cSChristoph Hellwig case WRITE_SAME_32: 745d6e0175cSChristoph Hellwig sectors = transport_get_sectors_32(cdb); 746d6e0175cSChristoph Hellwig if (!sectors) { 747d6e0175cSChristoph Hellwig pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not" 748d6e0175cSChristoph Hellwig " supported\n"); 749de103c93SChristoph Hellwig return TCM_INVALID_CDB_FIELD; 750d6e0175cSChristoph Hellwig } 751d6e0175cSChristoph Hellwig 7521fd032eeSChristoph Hellwig size = sbc_get_size(cmd, 1); 753d6e0175cSChristoph Hellwig cmd->t_task_lba = get_unaligned_be64(&cdb[12]); 754d6e0175cSChristoph Hellwig 755cd063befSNicholas Bellinger ret = sbc_setup_write_same(cmd, &cdb[10], ops); 7566b64e1feSDan Carpenter if (ret) 757cd063befSNicholas Bellinger return ret; 758d6e0175cSChristoph Hellwig break; 759d6e0175cSChristoph Hellwig default: 760d6e0175cSChristoph Hellwig pr_err("VARIABLE_LENGTH_CMD service action" 761d6e0175cSChristoph Hellwig " 0x%04x not supported\n", service_action); 762de103c93SChristoph Hellwig return TCM_UNSUPPORTED_SCSI_OPCODE; 763d6e0175cSChristoph Hellwig } 764d6e0175cSChristoph Hellwig break; 765d6e0175cSChristoph Hellwig } 76668ff9b9bSNicholas Bellinger case COMPARE_AND_WRITE: 76768ff9b9bSNicholas Bellinger sectors = cdb[13]; 76868ff9b9bSNicholas Bellinger /* 76968ff9b9bSNicholas Bellinger * Currently enforce COMPARE_AND_WRITE for a single sector 77068ff9b9bSNicholas Bellinger */ 77168ff9b9bSNicholas Bellinger if (sectors > 1) { 77268ff9b9bSNicholas Bellinger pr_err("COMPARE_AND_WRITE contains NoLB: %u greater" 77368ff9b9bSNicholas Bellinger " than 1\n", sectors); 77468ff9b9bSNicholas Bellinger return TCM_INVALID_CDB_FIELD; 77568ff9b9bSNicholas Bellinger } 77668ff9b9bSNicholas Bellinger /* 77768ff9b9bSNicholas Bellinger * Double size because we have two buffers, note that 77868ff9b9bSNicholas Bellinger * zero is not an error.. 77968ff9b9bSNicholas Bellinger */ 78068ff9b9bSNicholas Bellinger size = 2 * sbc_get_size(cmd, sectors); 78168ff9b9bSNicholas Bellinger cmd->t_task_lba = get_unaligned_be64(&cdb[2]); 78268ff9b9bSNicholas Bellinger cmd->t_task_nolb = sectors; 78368ff9b9bSNicholas Bellinger cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB | SCF_COMPARE_AND_WRITE; 78468ff9b9bSNicholas Bellinger cmd->execute_rw = ops->execute_rw; 78568ff9b9bSNicholas Bellinger cmd->execute_cmd = sbc_compare_and_write; 78668ff9b9bSNicholas Bellinger cmd->transport_complete_callback = compare_and_write_callback; 78768ff9b9bSNicholas Bellinger break; 788d6e0175cSChristoph Hellwig case READ_CAPACITY: 7891fd032eeSChristoph Hellwig size = READ_CAP_LEN; 7901fd032eeSChristoph Hellwig cmd->execute_cmd = sbc_emulate_readcapacity; 791d6e0175cSChristoph Hellwig break; 792d6e0175cSChristoph Hellwig case SERVICE_ACTION_IN: 793d6e0175cSChristoph Hellwig switch (cmd->t_task_cdb[1] & 0x1f) { 794d6e0175cSChristoph Hellwig case SAI_READ_CAPACITY_16: 7951fd032eeSChristoph Hellwig cmd->execute_cmd = sbc_emulate_readcapacity_16; 796d6e0175cSChristoph Hellwig break; 797c66094bfSHannes Reinecke case SAI_REPORT_REFERRALS: 798c66094bfSHannes Reinecke cmd->execute_cmd = target_emulate_report_referrals; 799c66094bfSHannes Reinecke break; 800d6e0175cSChristoph Hellwig default: 801d6e0175cSChristoph Hellwig pr_err("Unsupported SA: 0x%02x\n", 802d6e0175cSChristoph Hellwig cmd->t_task_cdb[1] & 0x1f); 803de103c93SChristoph Hellwig return TCM_INVALID_CDB_FIELD; 804d6e0175cSChristoph Hellwig } 8051fd032eeSChristoph Hellwig size = (cdb[10] << 24) | (cdb[11] << 16) | 806d6e0175cSChristoph Hellwig (cdb[12] << 8) | cdb[13]; 807d6e0175cSChristoph Hellwig break; 808d6e0175cSChristoph Hellwig case SYNCHRONIZE_CACHE: 809d6e0175cSChristoph Hellwig case SYNCHRONIZE_CACHE_16: 810882e3f8eSHannes Reinecke if (!ops->execute_sync_cache) { 811882e3f8eSHannes Reinecke size = 0; 812882e3f8eSHannes Reinecke cmd->execute_cmd = sbc_emulate_noop; 813882e3f8eSHannes Reinecke break; 814882e3f8eSHannes Reinecke } 815ad67f0d9SChristoph Hellwig 816d6e0175cSChristoph Hellwig /* 817d6e0175cSChristoph Hellwig * Extract LBA and range to be flushed for emulated SYNCHRONIZE_CACHE 818d6e0175cSChristoph Hellwig */ 819d6e0175cSChristoph Hellwig if (cdb[0] == SYNCHRONIZE_CACHE) { 820d6e0175cSChristoph Hellwig sectors = transport_get_sectors_10(cdb); 821d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_32(cdb); 822d6e0175cSChristoph Hellwig } else { 823d6e0175cSChristoph Hellwig sectors = transport_get_sectors_16(cdb); 824d6e0175cSChristoph Hellwig cmd->t_task_lba = transport_lba_64(cdb); 825d6e0175cSChristoph Hellwig } 826d6e0175cSChristoph Hellwig 8271fd032eeSChristoph Hellwig size = sbc_get_size(cmd, sectors); 828d6e0175cSChristoph Hellwig 829d6e0175cSChristoph Hellwig /* 830d6e0175cSChristoph Hellwig * Check to ensure that LBA + Range does not exceed past end of 831d6e0175cSChristoph Hellwig * device for IBLOCK and FILEIO ->do_sync_cache() backend calls 832d6e0175cSChristoph Hellwig */ 833d6e0175cSChristoph Hellwig if (cmd->t_task_lba || sectors) { 834d6e0175cSChristoph Hellwig if (sbc_check_valid_sectors(cmd) < 0) 83533633676SRoland Dreier return TCM_ADDRESS_OUT_OF_RANGE; 836d6e0175cSChristoph Hellwig } 837ad67f0d9SChristoph Hellwig cmd->execute_cmd = ops->execute_sync_cache; 838d6e0175cSChristoph Hellwig break; 839d6e0175cSChristoph Hellwig case UNMAP: 84014150a6bSChristoph Hellwig if (!ops->execute_unmap) 841de103c93SChristoph Hellwig return TCM_UNSUPPORTED_SCSI_OPCODE; 84214150a6bSChristoph Hellwig 8431fd032eeSChristoph Hellwig size = get_unaligned_be16(&cdb[7]); 84414150a6bSChristoph Hellwig cmd->execute_cmd = ops->execute_unmap; 845d6e0175cSChristoph Hellwig break; 846d6e0175cSChristoph Hellwig case WRITE_SAME_16: 847d6e0175cSChristoph Hellwig sectors = transport_get_sectors_16(cdb); 848d6e0175cSChristoph Hellwig if (!sectors) { 849d6e0175cSChristoph Hellwig pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n"); 850de103c93SChristoph Hellwig return TCM_INVALID_CDB_FIELD; 851d6e0175cSChristoph Hellwig } 852d6e0175cSChristoph Hellwig 8531fd032eeSChristoph Hellwig size = sbc_get_size(cmd, 1); 854d6e0175cSChristoph Hellwig cmd->t_task_lba = get_unaligned_be64(&cdb[2]); 855d6e0175cSChristoph Hellwig 856cd063befSNicholas Bellinger ret = sbc_setup_write_same(cmd, &cdb[1], ops); 8576b64e1feSDan Carpenter if (ret) 858cd063befSNicholas Bellinger return ret; 859d6e0175cSChristoph Hellwig break; 860d6e0175cSChristoph Hellwig case WRITE_SAME: 861d6e0175cSChristoph Hellwig sectors = transport_get_sectors_10(cdb); 862d6e0175cSChristoph Hellwig if (!sectors) { 863d6e0175cSChristoph Hellwig pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n"); 864de103c93SChristoph Hellwig return TCM_INVALID_CDB_FIELD; 865d6e0175cSChristoph Hellwig } 866d6e0175cSChristoph Hellwig 8671fd032eeSChristoph Hellwig size = sbc_get_size(cmd, 1); 868d6e0175cSChristoph Hellwig cmd->t_task_lba = get_unaligned_be32(&cdb[2]); 869d6e0175cSChristoph Hellwig 870d6e0175cSChristoph Hellwig /* 871d6e0175cSChristoph Hellwig * Follow sbcr26 with WRITE_SAME (10) and check for the existence 872d6e0175cSChristoph Hellwig * of byte 1 bit 3 UNMAP instead of original reserved field 873d6e0175cSChristoph Hellwig */ 874cd063befSNicholas Bellinger ret = sbc_setup_write_same(cmd, &cdb[1], ops); 8756b64e1feSDan Carpenter if (ret) 876cd063befSNicholas Bellinger return ret; 877d6e0175cSChristoph Hellwig break; 878d6e0175cSChristoph Hellwig case VERIFY: 8791fd032eeSChristoph Hellwig size = 0; 8801920ed61SNicholas Bellinger cmd->execute_cmd = sbc_emulate_noop; 881d6e0175cSChristoph Hellwig break; 8821a1ff38cSBernhard Kohl case REZERO_UNIT: 8831a1ff38cSBernhard Kohl case SEEK_6: 8841a1ff38cSBernhard Kohl case SEEK_10: 8851a1ff38cSBernhard Kohl /* 8861a1ff38cSBernhard Kohl * There are still clients out there which use these old SCSI-2 8871a1ff38cSBernhard Kohl * commands. This mainly happens when running VMs with legacy 8881a1ff38cSBernhard Kohl * guest systems, connected via SCSI command pass-through to 8891a1ff38cSBernhard Kohl * iSCSI targets. Make them happy and return status GOOD. 8901a1ff38cSBernhard Kohl */ 8911a1ff38cSBernhard Kohl size = 0; 8921a1ff38cSBernhard Kohl cmd->execute_cmd = sbc_emulate_noop; 8931a1ff38cSBernhard Kohl break; 894d6e0175cSChristoph Hellwig default: 8951fd032eeSChristoph Hellwig ret = spc_parse_cdb(cmd, &size); 896d6e0175cSChristoph Hellwig if (ret) 897d6e0175cSChristoph Hellwig return ret; 898d6e0175cSChristoph Hellwig } 899d6e0175cSChristoph Hellwig 900d6e0175cSChristoph Hellwig /* reject any command that we don't have a handler for */ 901d6e0175cSChristoph Hellwig if (!(cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) && !cmd->execute_cmd) 902de103c93SChristoph Hellwig return TCM_UNSUPPORTED_SCSI_OPCODE; 903d6e0175cSChristoph Hellwig 904d6e0175cSChristoph Hellwig if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) { 9051fd032eeSChristoph Hellwig unsigned long long end_lba; 9061fd032eeSChristoph Hellwig 9070fd97ccfSChristoph Hellwig if (sectors > dev->dev_attrib.fabric_max_sectors) { 908d6e0175cSChristoph Hellwig printk_ratelimited(KERN_ERR "SCSI OP %02xh with too" 909d6e0175cSChristoph Hellwig " big sectors %u exceeds fabric_max_sectors:" 910d6e0175cSChristoph Hellwig " %u\n", cdb[0], sectors, 9110fd97ccfSChristoph Hellwig dev->dev_attrib.fabric_max_sectors); 912de103c93SChristoph Hellwig return TCM_INVALID_CDB_FIELD; 913d6e0175cSChristoph Hellwig } 9140fd97ccfSChristoph Hellwig if (sectors > dev->dev_attrib.hw_max_sectors) { 915d6e0175cSChristoph Hellwig printk_ratelimited(KERN_ERR "SCSI OP %02xh with too" 916d6e0175cSChristoph Hellwig " big sectors %u exceeds backend hw_max_sectors:" 917d6e0175cSChristoph Hellwig " %u\n", cdb[0], sectors, 9180fd97ccfSChristoph Hellwig dev->dev_attrib.hw_max_sectors); 919de103c93SChristoph Hellwig return TCM_INVALID_CDB_FIELD; 920d6e0175cSChristoph Hellwig } 921d6e0175cSChristoph Hellwig 9221fd032eeSChristoph Hellwig end_lba = dev->transport->get_blocks(dev) + 1; 9231fd032eeSChristoph Hellwig if (cmd->t_task_lba + sectors > end_lba) { 9241fd032eeSChristoph Hellwig pr_err("cmd exceeds last lba %llu " 9251fd032eeSChristoph Hellwig "(lba %llu, sectors %u)\n", 9261fd032eeSChristoph Hellwig end_lba, cmd->t_task_lba, sectors); 92709ceadc7SRoland Dreier return TCM_ADDRESS_OUT_OF_RANGE; 928d6e0175cSChristoph Hellwig } 929d6e0175cSChristoph Hellwig 93068ff9b9bSNicholas Bellinger if (!(cmd->se_cmd_flags & SCF_COMPARE_AND_WRITE)) 9311fd032eeSChristoph Hellwig size = sbc_get_size(cmd, sectors); 9321fd032eeSChristoph Hellwig } 9331fd032eeSChristoph Hellwig 934de103c93SChristoph Hellwig return target_cmd_size_check(cmd, size); 935d6e0175cSChristoph Hellwig } 936d6e0175cSChristoph Hellwig EXPORT_SYMBOL(sbc_parse_cdb); 9376f23ac8aSChristoph Hellwig 9386f23ac8aSChristoph Hellwig u32 sbc_get_device_type(struct se_device *dev) 9396f23ac8aSChristoph Hellwig { 9406f23ac8aSChristoph Hellwig return TYPE_DISK; 9416f23ac8aSChristoph Hellwig } 9426f23ac8aSChristoph Hellwig EXPORT_SYMBOL(sbc_get_device_type); 94386d71829SAsias He 94486d71829SAsias He sense_reason_t 94586d71829SAsias He sbc_execute_unmap(struct se_cmd *cmd, 94686d71829SAsias He sense_reason_t (*do_unmap_fn)(struct se_cmd *, void *, 94786d71829SAsias He sector_t, sector_t), 94886d71829SAsias He void *priv) 94986d71829SAsias He { 95086d71829SAsias He struct se_device *dev = cmd->se_dev; 95186d71829SAsias He unsigned char *buf, *ptr = NULL; 95286d71829SAsias He sector_t lba; 95386d71829SAsias He int size; 95486d71829SAsias He u32 range; 95586d71829SAsias He sense_reason_t ret = 0; 95686d71829SAsias He int dl, bd_dl; 95786d71829SAsias He 95886d71829SAsias He /* We never set ANC_SUP */ 95986d71829SAsias He if (cmd->t_task_cdb[1]) 96086d71829SAsias He return TCM_INVALID_CDB_FIELD; 96186d71829SAsias He 96286d71829SAsias He if (cmd->data_length == 0) { 96386d71829SAsias He target_complete_cmd(cmd, SAM_STAT_GOOD); 96486d71829SAsias He return 0; 96586d71829SAsias He } 96686d71829SAsias He 96786d71829SAsias He if (cmd->data_length < 8) { 96886d71829SAsias He pr_warn("UNMAP parameter list length %u too small\n", 96986d71829SAsias He cmd->data_length); 97086d71829SAsias He return TCM_PARAMETER_LIST_LENGTH_ERROR; 97186d71829SAsias He } 97286d71829SAsias He 97386d71829SAsias He buf = transport_kmap_data_sg(cmd); 97486d71829SAsias He if (!buf) 97586d71829SAsias He return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 97686d71829SAsias He 97786d71829SAsias He dl = get_unaligned_be16(&buf[0]); 97886d71829SAsias He bd_dl = get_unaligned_be16(&buf[2]); 97986d71829SAsias He 98086d71829SAsias He size = cmd->data_length - 8; 98186d71829SAsias He if (bd_dl > size) 98286d71829SAsias He pr_warn("UNMAP parameter list length %u too small, ignoring bd_dl %u\n", 98386d71829SAsias He cmd->data_length, bd_dl); 98486d71829SAsias He else 98586d71829SAsias He size = bd_dl; 98686d71829SAsias He 98786d71829SAsias He if (size / 16 > dev->dev_attrib.max_unmap_block_desc_count) { 98886d71829SAsias He ret = TCM_INVALID_PARAMETER_LIST; 98986d71829SAsias He goto err; 99086d71829SAsias He } 99186d71829SAsias He 99286d71829SAsias He /* First UNMAP block descriptor starts at 8 byte offset */ 99386d71829SAsias He ptr = &buf[8]; 99486d71829SAsias He pr_debug("UNMAP: Sub: %s Using dl: %u bd_dl: %u size: %u" 99586d71829SAsias He " ptr: %p\n", dev->transport->name, dl, bd_dl, size, ptr); 99686d71829SAsias He 99786d71829SAsias He while (size >= 16) { 99886d71829SAsias He lba = get_unaligned_be64(&ptr[0]); 99986d71829SAsias He range = get_unaligned_be32(&ptr[8]); 100086d71829SAsias He pr_debug("UNMAP: Using lba: %llu and range: %u\n", 100186d71829SAsias He (unsigned long long)lba, range); 100286d71829SAsias He 100386d71829SAsias He if (range > dev->dev_attrib.max_unmap_lba_count) { 100486d71829SAsias He ret = TCM_INVALID_PARAMETER_LIST; 100586d71829SAsias He goto err; 100686d71829SAsias He } 100786d71829SAsias He 100886d71829SAsias He if (lba + range > dev->transport->get_blocks(dev) + 1) { 100986d71829SAsias He ret = TCM_ADDRESS_OUT_OF_RANGE; 101086d71829SAsias He goto err; 101186d71829SAsias He } 101286d71829SAsias He 101386d71829SAsias He ret = do_unmap_fn(cmd, priv, lba, range); 101486d71829SAsias He if (ret) 101586d71829SAsias He goto err; 101686d71829SAsias He 101786d71829SAsias He ptr += 16; 101886d71829SAsias He size -= 16; 101986d71829SAsias He } 102086d71829SAsias He 102186d71829SAsias He err: 102286d71829SAsias He transport_kunmap_data_sg(cmd); 102386d71829SAsias He if (!ret) 102486d71829SAsias He target_complete_cmd(cmd, GOOD); 102586d71829SAsias He return ret; 102686d71829SAsias He } 102786d71829SAsias He EXPORT_SYMBOL(sbc_execute_unmap); 102841861fa8SNicholas Bellinger 102941861fa8SNicholas Bellinger static sense_reason_t 103041861fa8SNicholas Bellinger sbc_dif_v1_verify(struct se_device *dev, struct se_dif_v1_tuple *sdt, 103141861fa8SNicholas Bellinger const void *p, sector_t sector, unsigned int ei_lba) 103241861fa8SNicholas Bellinger { 103341861fa8SNicholas Bellinger int block_size = dev->dev_attrib.block_size; 103441861fa8SNicholas Bellinger __be16 csum; 103541861fa8SNicholas Bellinger 103641861fa8SNicholas Bellinger csum = cpu_to_be16(crc_t10dif(p, block_size)); 103741861fa8SNicholas Bellinger 103841861fa8SNicholas Bellinger if (sdt->guard_tag != csum) { 103941861fa8SNicholas Bellinger pr_err("DIFv1 checksum failed on sector %llu guard tag 0x%04x" 104041861fa8SNicholas Bellinger " csum 0x%04x\n", (unsigned long long)sector, 104141861fa8SNicholas Bellinger be16_to_cpu(sdt->guard_tag), be16_to_cpu(csum)); 104241861fa8SNicholas Bellinger return TCM_LOGICAL_BLOCK_GUARD_CHECK_FAILED; 104341861fa8SNicholas Bellinger } 104441861fa8SNicholas Bellinger 104541861fa8SNicholas Bellinger if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE1_PROT && 104641861fa8SNicholas Bellinger be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) { 104741861fa8SNicholas Bellinger pr_err("DIFv1 Type 1 reference failed on sector: %llu tag: 0x%08x" 104841861fa8SNicholas Bellinger " sector MSB: 0x%08x\n", (unsigned long long)sector, 104941861fa8SNicholas Bellinger be32_to_cpu(sdt->ref_tag), (u32)(sector & 0xffffffff)); 105041861fa8SNicholas Bellinger return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED; 105141861fa8SNicholas Bellinger } 105241861fa8SNicholas Bellinger 105341861fa8SNicholas Bellinger if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE2_PROT && 105441861fa8SNicholas Bellinger be32_to_cpu(sdt->ref_tag) != ei_lba) { 105541861fa8SNicholas Bellinger pr_err("DIFv1 Type 2 reference failed on sector: %llu tag: 0x%08x" 105641861fa8SNicholas Bellinger " ei_lba: 0x%08x\n", (unsigned long long)sector, 105741861fa8SNicholas Bellinger be32_to_cpu(sdt->ref_tag), ei_lba); 105841861fa8SNicholas Bellinger return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED; 105941861fa8SNicholas Bellinger } 106041861fa8SNicholas Bellinger 106141861fa8SNicholas Bellinger return 0; 106241861fa8SNicholas Bellinger } 106341861fa8SNicholas Bellinger 106441861fa8SNicholas Bellinger static void 106541861fa8SNicholas Bellinger sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read, 106641861fa8SNicholas Bellinger struct scatterlist *sg, int sg_off) 106741861fa8SNicholas Bellinger { 106841861fa8SNicholas Bellinger struct se_device *dev = cmd->se_dev; 106941861fa8SNicholas Bellinger struct scatterlist *psg; 107041861fa8SNicholas Bellinger void *paddr, *addr; 107141861fa8SNicholas Bellinger unsigned int i, len, left; 107241861fa8SNicholas Bellinger 107341861fa8SNicholas Bellinger left = sectors * dev->prot_length; 107441861fa8SNicholas Bellinger 107541861fa8SNicholas Bellinger for_each_sg(cmd->t_prot_sg, psg, cmd->t_prot_nents, i) { 107641861fa8SNicholas Bellinger 107741861fa8SNicholas Bellinger len = min(psg->length, left); 107841861fa8SNicholas Bellinger paddr = kmap_atomic(sg_page(psg)) + psg->offset; 107941861fa8SNicholas Bellinger addr = kmap_atomic(sg_page(sg)) + sg_off; 108041861fa8SNicholas Bellinger 108141861fa8SNicholas Bellinger if (read) 108241861fa8SNicholas Bellinger memcpy(paddr, addr, len); 108341861fa8SNicholas Bellinger else 108441861fa8SNicholas Bellinger memcpy(addr, paddr, len); 108541861fa8SNicholas Bellinger 108641861fa8SNicholas Bellinger left -= len; 108741861fa8SNicholas Bellinger kunmap_atomic(paddr); 108841861fa8SNicholas Bellinger kunmap_atomic(addr); 108941861fa8SNicholas Bellinger } 109041861fa8SNicholas Bellinger } 109141861fa8SNicholas Bellinger 109241861fa8SNicholas Bellinger sense_reason_t 109341861fa8SNicholas Bellinger sbc_dif_verify_write(struct se_cmd *cmd, sector_t start, unsigned int sectors, 109441861fa8SNicholas Bellinger unsigned int ei_lba, struct scatterlist *sg, int sg_off) 109541861fa8SNicholas Bellinger { 109641861fa8SNicholas Bellinger struct se_device *dev = cmd->se_dev; 109741861fa8SNicholas Bellinger struct se_dif_v1_tuple *sdt; 109841861fa8SNicholas Bellinger struct scatterlist *dsg, *psg = cmd->t_prot_sg; 109941861fa8SNicholas Bellinger sector_t sector = start; 110041861fa8SNicholas Bellinger void *daddr, *paddr; 110141861fa8SNicholas Bellinger int i, j, offset = 0; 110241861fa8SNicholas Bellinger sense_reason_t rc; 110341861fa8SNicholas Bellinger 110441861fa8SNicholas Bellinger for_each_sg(cmd->t_data_sg, dsg, cmd->t_data_nents, i) { 110541861fa8SNicholas Bellinger daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; 110641861fa8SNicholas Bellinger paddr = kmap_atomic(sg_page(psg)) + psg->offset; 110741861fa8SNicholas Bellinger 110841861fa8SNicholas Bellinger for (j = 0; j < dsg->length; j += dev->dev_attrib.block_size) { 110941861fa8SNicholas Bellinger 111041861fa8SNicholas Bellinger if (offset >= psg->length) { 111141861fa8SNicholas Bellinger kunmap_atomic(paddr); 111241861fa8SNicholas Bellinger psg = sg_next(psg); 111341861fa8SNicholas Bellinger paddr = kmap_atomic(sg_page(psg)) + psg->offset; 111441861fa8SNicholas Bellinger offset = 0; 111541861fa8SNicholas Bellinger } 111641861fa8SNicholas Bellinger 111741861fa8SNicholas Bellinger sdt = paddr + offset; 111841861fa8SNicholas Bellinger 111941861fa8SNicholas Bellinger pr_debug("DIF WRITE sector: %llu guard_tag: 0x%04x" 112041861fa8SNicholas Bellinger " app_tag: 0x%04x ref_tag: %u\n", 112141861fa8SNicholas Bellinger (unsigned long long)sector, sdt->guard_tag, 112241861fa8SNicholas Bellinger sdt->app_tag, be32_to_cpu(sdt->ref_tag)); 112341861fa8SNicholas Bellinger 112441861fa8SNicholas Bellinger rc = sbc_dif_v1_verify(dev, sdt, daddr + j, sector, 112541861fa8SNicholas Bellinger ei_lba); 112641861fa8SNicholas Bellinger if (rc) { 112741861fa8SNicholas Bellinger kunmap_atomic(paddr); 112841861fa8SNicholas Bellinger kunmap_atomic(daddr); 112941861fa8SNicholas Bellinger return rc; 113041861fa8SNicholas Bellinger } 113141861fa8SNicholas Bellinger 113241861fa8SNicholas Bellinger sector++; 113341861fa8SNicholas Bellinger ei_lba++; 113441861fa8SNicholas Bellinger offset += sizeof(struct se_dif_v1_tuple); 113541861fa8SNicholas Bellinger } 113641861fa8SNicholas Bellinger 113741861fa8SNicholas Bellinger kunmap_atomic(paddr); 113841861fa8SNicholas Bellinger kunmap_atomic(daddr); 113941861fa8SNicholas Bellinger } 114041861fa8SNicholas Bellinger sbc_dif_copy_prot(cmd, sectors, false, sg, sg_off); 114141861fa8SNicholas Bellinger 114241861fa8SNicholas Bellinger return 0; 114341861fa8SNicholas Bellinger } 114441861fa8SNicholas Bellinger EXPORT_SYMBOL(sbc_dif_verify_write); 114541861fa8SNicholas Bellinger 114641861fa8SNicholas Bellinger sense_reason_t 114741861fa8SNicholas Bellinger sbc_dif_verify_read(struct se_cmd *cmd, sector_t start, unsigned int sectors, 114841861fa8SNicholas Bellinger unsigned int ei_lba, struct scatterlist *sg, int sg_off) 114941861fa8SNicholas Bellinger { 115041861fa8SNicholas Bellinger struct se_device *dev = cmd->se_dev; 115141861fa8SNicholas Bellinger struct se_dif_v1_tuple *sdt; 115241861fa8SNicholas Bellinger struct scatterlist *dsg; 115341861fa8SNicholas Bellinger sector_t sector = start; 115441861fa8SNicholas Bellinger void *daddr, *paddr; 115541861fa8SNicholas Bellinger int i, j, offset = sg_off; 115641861fa8SNicholas Bellinger sense_reason_t rc; 115741861fa8SNicholas Bellinger 115841861fa8SNicholas Bellinger for_each_sg(cmd->t_data_sg, dsg, cmd->t_data_nents, i) { 115941861fa8SNicholas Bellinger daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; 116041861fa8SNicholas Bellinger paddr = kmap_atomic(sg_page(sg)) + sg->offset; 116141861fa8SNicholas Bellinger 116241861fa8SNicholas Bellinger for (j = 0; j < dsg->length; j += dev->dev_attrib.block_size) { 116341861fa8SNicholas Bellinger 116441861fa8SNicholas Bellinger if (offset >= sg->length) { 116541861fa8SNicholas Bellinger kunmap_atomic(paddr); 116641861fa8SNicholas Bellinger sg = sg_next(sg); 116741861fa8SNicholas Bellinger paddr = kmap_atomic(sg_page(sg)) + sg->offset; 116841861fa8SNicholas Bellinger offset = 0; 116941861fa8SNicholas Bellinger } 117041861fa8SNicholas Bellinger 117141861fa8SNicholas Bellinger sdt = paddr + offset; 117241861fa8SNicholas Bellinger 117341861fa8SNicholas Bellinger pr_debug("DIF READ sector: %llu guard_tag: 0x%04x" 117441861fa8SNicholas Bellinger " app_tag: 0x%04x ref_tag: %u\n", 117541861fa8SNicholas Bellinger (unsigned long long)sector, sdt->guard_tag, 117641861fa8SNicholas Bellinger sdt->app_tag, be32_to_cpu(sdt->ref_tag)); 117741861fa8SNicholas Bellinger 117841861fa8SNicholas Bellinger if (sdt->app_tag == cpu_to_be16(0xffff)) { 117941861fa8SNicholas Bellinger sector++; 118041861fa8SNicholas Bellinger offset += sizeof(struct se_dif_v1_tuple); 118141861fa8SNicholas Bellinger continue; 118241861fa8SNicholas Bellinger } 118341861fa8SNicholas Bellinger 118441861fa8SNicholas Bellinger rc = sbc_dif_v1_verify(dev, sdt, daddr + j, sector, 118541861fa8SNicholas Bellinger ei_lba); 118641861fa8SNicholas Bellinger if (rc) { 118741861fa8SNicholas Bellinger kunmap_atomic(paddr); 118841861fa8SNicholas Bellinger kunmap_atomic(daddr); 118941861fa8SNicholas Bellinger return rc; 119041861fa8SNicholas Bellinger } 119141861fa8SNicholas Bellinger 119241861fa8SNicholas Bellinger sector++; 119341861fa8SNicholas Bellinger ei_lba++; 119441861fa8SNicholas Bellinger offset += sizeof(struct se_dif_v1_tuple); 119541861fa8SNicholas Bellinger } 119641861fa8SNicholas Bellinger 119741861fa8SNicholas Bellinger kunmap_atomic(paddr); 119841861fa8SNicholas Bellinger kunmap_atomic(daddr); 119941861fa8SNicholas Bellinger } 120041861fa8SNicholas Bellinger sbc_dif_copy_prot(cmd, sectors, true, sg, sg_off); 120141861fa8SNicholas Bellinger 120241861fa8SNicholas Bellinger return 0; 120341861fa8SNicholas Bellinger } 120441861fa8SNicholas Bellinger EXPORT_SYMBOL(sbc_dif_verify_read); 1205