1 /* 2 * SCSI Block Commands (SBC) parsing and emulation. 3 * 4 * (c) Copyright 2002-2013 Datera, Inc. 5 * 6 * Nicholas A. Bellinger <nab@kernel.org> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 21 */ 22 23 #include <linux/kernel.h> 24 #include <linux/module.h> 25 #include <linux/ratelimit.h> 26 #include <linux/crc-t10dif.h> 27 #include <linux/t10-pi.h> 28 #include <asm/unaligned.h> 29 #include <scsi/scsi_proto.h> 30 #include <scsi/scsi_tcq.h> 31 32 #include <target/target_core_base.h> 33 #include <target/target_core_backend.h> 34 #include <target/target_core_fabric.h> 35 36 #include "target_core_internal.h" 37 #include "target_core_ua.h" 38 #include "target_core_alua.h" 39 40 static sense_reason_t 41 sbc_check_prot(struct se_device *, struct se_cmd *, unsigned char *, u32, bool); 42 static sense_reason_t sbc_execute_unmap(struct se_cmd *cmd); 43 44 static sense_reason_t 45 sbc_emulate_readcapacity(struct se_cmd *cmd) 46 { 47 struct se_device *dev = cmd->se_dev; 48 unsigned char *cdb = cmd->t_task_cdb; 49 unsigned long long blocks_long = dev->transport->get_blocks(dev); 50 unsigned char *rbuf; 51 unsigned char buf[8]; 52 u32 blocks; 53 54 /* 55 * SBC-2 says: 56 * If the PMI bit is set to zero and the LOGICAL BLOCK 57 * ADDRESS field is not set to zero, the device server shall 58 * terminate the command with CHECK CONDITION status with 59 * the sense key set to ILLEGAL REQUEST and the additional 60 * sense code set to INVALID FIELD IN CDB. 61 * 62 * In SBC-3, these fields are obsolete, but some SCSI 63 * compliance tests actually check this, so we might as well 64 * follow SBC-2. 65 */ 66 if (!(cdb[8] & 1) && !!(cdb[2] | cdb[3] | cdb[4] | cdb[5])) 67 return TCM_INVALID_CDB_FIELD; 68 69 if (blocks_long >= 0x00000000ffffffff) 70 blocks = 0xffffffff; 71 else 72 blocks = (u32)blocks_long; 73 74 buf[0] = (blocks >> 24) & 0xff; 75 buf[1] = (blocks >> 16) & 0xff; 76 buf[2] = (blocks >> 8) & 0xff; 77 buf[3] = blocks & 0xff; 78 buf[4] = (dev->dev_attrib.block_size >> 24) & 0xff; 79 buf[5] = (dev->dev_attrib.block_size >> 16) & 0xff; 80 buf[6] = (dev->dev_attrib.block_size >> 8) & 0xff; 81 buf[7] = dev->dev_attrib.block_size & 0xff; 82 83 rbuf = transport_kmap_data_sg(cmd); 84 if (rbuf) { 85 memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length)); 86 transport_kunmap_data_sg(cmd); 87 } 88 89 target_complete_cmd_with_length(cmd, GOOD, 8); 90 return 0; 91 } 92 93 static sense_reason_t 94 sbc_emulate_readcapacity_16(struct se_cmd *cmd) 95 { 96 struct se_device *dev = cmd->se_dev; 97 struct se_session *sess = cmd->se_sess; 98 int pi_prot_type = dev->dev_attrib.pi_prot_type; 99 100 unsigned char *rbuf; 101 unsigned char buf[32]; 102 unsigned long long blocks = dev->transport->get_blocks(dev); 103 104 memset(buf, 0, sizeof(buf)); 105 buf[0] = (blocks >> 56) & 0xff; 106 buf[1] = (blocks >> 48) & 0xff; 107 buf[2] = (blocks >> 40) & 0xff; 108 buf[3] = (blocks >> 32) & 0xff; 109 buf[4] = (blocks >> 24) & 0xff; 110 buf[5] = (blocks >> 16) & 0xff; 111 buf[6] = (blocks >> 8) & 0xff; 112 buf[7] = blocks & 0xff; 113 buf[8] = (dev->dev_attrib.block_size >> 24) & 0xff; 114 buf[9] = (dev->dev_attrib.block_size >> 16) & 0xff; 115 buf[10] = (dev->dev_attrib.block_size >> 8) & 0xff; 116 buf[11] = dev->dev_attrib.block_size & 0xff; 117 /* 118 * Set P_TYPE and PROT_EN bits for DIF support 119 */ 120 if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) { 121 /* 122 * Only override a device's pi_prot_type if no T10-PI is 123 * available, and sess_prot_type has been explicitly enabled. 124 */ 125 if (!pi_prot_type) 126 pi_prot_type = sess->sess_prot_type; 127 128 if (pi_prot_type) 129 buf[12] = (pi_prot_type - 1) << 1 | 0x1; 130 } 131 132 if (dev->transport->get_lbppbe) 133 buf[13] = dev->transport->get_lbppbe(dev) & 0x0f; 134 135 if (dev->transport->get_alignment_offset_lbas) { 136 u16 lalba = dev->transport->get_alignment_offset_lbas(dev); 137 buf[14] = (lalba >> 8) & 0x3f; 138 buf[15] = lalba & 0xff; 139 } 140 141 /* 142 * Set Thin Provisioning Enable bit following sbc3r22 in section 143 * READ CAPACITY (16) byte 14 if emulate_tpu or emulate_tpws is enabled. 144 */ 145 if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws) { 146 buf[14] |= 0x80; 147 148 /* 149 * LBPRZ signifies that zeroes will be read back from an LBA after 150 * an UNMAP or WRITE SAME w/ unmap bit (sbc3r36 5.16.2) 151 */ 152 if (dev->dev_attrib.unmap_zeroes_data) 153 buf[14] |= 0x40; 154 } 155 156 rbuf = transport_kmap_data_sg(cmd); 157 if (rbuf) { 158 memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length)); 159 transport_kunmap_data_sg(cmd); 160 } 161 162 target_complete_cmd_with_length(cmd, GOOD, 32); 163 return 0; 164 } 165 166 static sense_reason_t 167 sbc_emulate_startstop(struct se_cmd *cmd) 168 { 169 unsigned char *cdb = cmd->t_task_cdb; 170 171 /* 172 * See sbc3r36 section 5.25 173 * Immediate bit should be set since there is nothing to complete 174 * POWER CONDITION MODIFIER 0h 175 */ 176 if (!(cdb[1] & 1) || cdb[2] || cdb[3]) 177 return TCM_INVALID_CDB_FIELD; 178 179 /* 180 * See sbc3r36 section 5.25 181 * POWER CONDITION 0h START_VALID - process START and LOEJ 182 */ 183 if (cdb[4] >> 4 & 0xf) 184 return TCM_INVALID_CDB_FIELD; 185 186 /* 187 * See sbc3r36 section 5.25 188 * LOEJ 0h - nothing to load or unload 189 * START 1h - we are ready 190 */ 191 if (!(cdb[4] & 1) || (cdb[4] & 2) || (cdb[4] & 4)) 192 return TCM_INVALID_CDB_FIELD; 193 194 target_complete_cmd(cmd, SAM_STAT_GOOD); 195 return 0; 196 } 197 198 sector_t sbc_get_write_same_sectors(struct se_cmd *cmd) 199 { 200 u32 num_blocks; 201 202 if (cmd->t_task_cdb[0] == WRITE_SAME) 203 num_blocks = get_unaligned_be16(&cmd->t_task_cdb[7]); 204 else if (cmd->t_task_cdb[0] == WRITE_SAME_16) 205 num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]); 206 else /* WRITE_SAME_32 via VARIABLE_LENGTH_CMD */ 207 num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]); 208 209 /* 210 * Use the explicit range when non zero is supplied, otherwise calculate 211 * the remaining range based on ->get_blocks() - starting LBA. 212 */ 213 if (num_blocks) 214 return num_blocks; 215 216 return cmd->se_dev->transport->get_blocks(cmd->se_dev) - 217 cmd->t_task_lba + 1; 218 } 219 EXPORT_SYMBOL(sbc_get_write_same_sectors); 220 221 static sense_reason_t 222 sbc_execute_write_same_unmap(struct se_cmd *cmd) 223 { 224 struct sbc_ops *ops = cmd->protocol_data; 225 sector_t nolb = sbc_get_write_same_sectors(cmd); 226 sense_reason_t ret; 227 228 if (nolb) { 229 ret = ops->execute_unmap(cmd, cmd->t_task_lba, nolb); 230 if (ret) 231 return ret; 232 } 233 234 target_complete_cmd(cmd, GOOD); 235 return 0; 236 } 237 238 static sense_reason_t 239 sbc_emulate_noop(struct se_cmd *cmd) 240 { 241 target_complete_cmd(cmd, GOOD); 242 return 0; 243 } 244 245 static inline u32 sbc_get_size(struct se_cmd *cmd, u32 sectors) 246 { 247 return cmd->se_dev->dev_attrib.block_size * sectors; 248 } 249 250 static inline u32 transport_get_sectors_6(unsigned char *cdb) 251 { 252 /* 253 * Use 8-bit sector value. SBC-3 says: 254 * 255 * A TRANSFER LENGTH field set to zero specifies that 256 256 * logical blocks shall be written. Any other value 257 * specifies the number of logical blocks that shall be 258 * written. 259 */ 260 return cdb[4] ? : 256; 261 } 262 263 static inline u32 transport_get_sectors_10(unsigned char *cdb) 264 { 265 return (u32)(cdb[7] << 8) + cdb[8]; 266 } 267 268 static inline u32 transport_get_sectors_12(unsigned char *cdb) 269 { 270 return (u32)(cdb[6] << 24) + (cdb[7] << 16) + (cdb[8] << 8) + cdb[9]; 271 } 272 273 static inline u32 transport_get_sectors_16(unsigned char *cdb) 274 { 275 return (u32)(cdb[10] << 24) + (cdb[11] << 16) + 276 (cdb[12] << 8) + cdb[13]; 277 } 278 279 /* 280 * Used for VARIABLE_LENGTH_CDB WRITE_32 and READ_32 variants 281 */ 282 static inline u32 transport_get_sectors_32(unsigned char *cdb) 283 { 284 return (u32)(cdb[28] << 24) + (cdb[29] << 16) + 285 (cdb[30] << 8) + cdb[31]; 286 287 } 288 289 static inline u32 transport_lba_21(unsigned char *cdb) 290 { 291 return ((cdb[1] & 0x1f) << 16) | (cdb[2] << 8) | cdb[3]; 292 } 293 294 static inline u32 transport_lba_32(unsigned char *cdb) 295 { 296 return (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; 297 } 298 299 static inline unsigned long long transport_lba_64(unsigned char *cdb) 300 { 301 unsigned int __v1, __v2; 302 303 __v1 = (cdb[2] << 24) | (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; 304 __v2 = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9]; 305 306 return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32; 307 } 308 309 /* 310 * For VARIABLE_LENGTH_CDB w/ 32 byte extended CDBs 311 */ 312 static inline unsigned long long transport_lba_64_ext(unsigned char *cdb) 313 { 314 unsigned int __v1, __v2; 315 316 __v1 = (cdb[12] << 24) | (cdb[13] << 16) | (cdb[14] << 8) | cdb[15]; 317 __v2 = (cdb[16] << 24) | (cdb[17] << 16) | (cdb[18] << 8) | cdb[19]; 318 319 return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32; 320 } 321 322 static sense_reason_t 323 sbc_setup_write_same(struct se_cmd *cmd, unsigned char *flags, struct sbc_ops *ops) 324 { 325 struct se_device *dev = cmd->se_dev; 326 sector_t end_lba = dev->transport->get_blocks(dev) + 1; 327 unsigned int sectors = sbc_get_write_same_sectors(cmd); 328 sense_reason_t ret; 329 330 if ((flags[0] & 0x04) || (flags[0] & 0x02)) { 331 pr_err("WRITE_SAME PBDATA and LBDATA" 332 " bits not supported for Block Discard" 333 " Emulation\n"); 334 return TCM_UNSUPPORTED_SCSI_OPCODE; 335 } 336 if (sectors > cmd->se_dev->dev_attrib.max_write_same_len) { 337 pr_warn("WRITE_SAME sectors: %u exceeds max_write_same_len: %u\n", 338 sectors, cmd->se_dev->dev_attrib.max_write_same_len); 339 return TCM_INVALID_CDB_FIELD; 340 } 341 /* 342 * Sanity check for LBA wrap and request past end of device. 343 */ 344 if (((cmd->t_task_lba + sectors) < cmd->t_task_lba) || 345 ((cmd->t_task_lba + sectors) > end_lba)) { 346 pr_err("WRITE_SAME exceeds last lba %llu (lba %llu, sectors %u)\n", 347 (unsigned long long)end_lba, cmd->t_task_lba, sectors); 348 return TCM_ADDRESS_OUT_OF_RANGE; 349 } 350 351 /* We always have ANC_SUP == 0 so setting ANCHOR is always an error */ 352 if (flags[0] & 0x10) { 353 pr_warn("WRITE SAME with ANCHOR not supported\n"); 354 return TCM_INVALID_CDB_FIELD; 355 } 356 /* 357 * Special case for WRITE_SAME w/ UNMAP=1 that ends up getting 358 * translated into block discard requests within backend code. 359 */ 360 if (flags[0] & 0x08) { 361 if (!ops->execute_unmap) 362 return TCM_UNSUPPORTED_SCSI_OPCODE; 363 364 if (!dev->dev_attrib.emulate_tpws) { 365 pr_err("Got WRITE_SAME w/ UNMAP=1, but backend device" 366 " has emulate_tpws disabled\n"); 367 return TCM_UNSUPPORTED_SCSI_OPCODE; 368 } 369 cmd->execute_cmd = sbc_execute_write_same_unmap; 370 return 0; 371 } 372 if (!ops->execute_write_same) 373 return TCM_UNSUPPORTED_SCSI_OPCODE; 374 375 ret = sbc_check_prot(dev, cmd, &cmd->t_task_cdb[0], sectors, true); 376 if (ret) 377 return ret; 378 379 cmd->execute_cmd = ops->execute_write_same; 380 return 0; 381 } 382 383 static sense_reason_t xdreadwrite_callback(struct se_cmd *cmd, bool success, 384 int *post_ret) 385 { 386 unsigned char *buf, *addr; 387 struct scatterlist *sg; 388 unsigned int offset; 389 sense_reason_t ret = TCM_NO_SENSE; 390 int i, count; 391 /* 392 * From sbc3r22.pdf section 5.48 XDWRITEREAD (10) command 393 * 394 * 1) read the specified logical block(s); 395 * 2) transfer logical blocks from the data-out buffer; 396 * 3) XOR the logical blocks transferred from the data-out buffer with 397 * the logical blocks read, storing the resulting XOR data in a buffer; 398 * 4) if the DISABLE WRITE bit is set to zero, then write the logical 399 * blocks transferred from the data-out buffer; and 400 * 5) transfer the resulting XOR data to the data-in buffer. 401 */ 402 buf = kmalloc(cmd->data_length, GFP_KERNEL); 403 if (!buf) { 404 pr_err("Unable to allocate xor_callback buf\n"); 405 return TCM_OUT_OF_RESOURCES; 406 } 407 /* 408 * Copy the scatterlist WRITE buffer located at cmd->t_data_sg 409 * into the locally allocated *buf 410 */ 411 sg_copy_to_buffer(cmd->t_data_sg, 412 cmd->t_data_nents, 413 buf, 414 cmd->data_length); 415 416 /* 417 * Now perform the XOR against the BIDI read memory located at 418 * cmd->t_mem_bidi_list 419 */ 420 421 offset = 0; 422 for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, count) { 423 addr = kmap_atomic(sg_page(sg)); 424 if (!addr) { 425 ret = TCM_OUT_OF_RESOURCES; 426 goto out; 427 } 428 429 for (i = 0; i < sg->length; i++) 430 *(addr + sg->offset + i) ^= *(buf + offset + i); 431 432 offset += sg->length; 433 kunmap_atomic(addr); 434 } 435 436 out: 437 kfree(buf); 438 return ret; 439 } 440 441 static sense_reason_t 442 sbc_execute_rw(struct se_cmd *cmd) 443 { 444 struct sbc_ops *ops = cmd->protocol_data; 445 446 return ops->execute_rw(cmd, cmd->t_data_sg, cmd->t_data_nents, 447 cmd->data_direction); 448 } 449 450 static sense_reason_t compare_and_write_post(struct se_cmd *cmd, bool success, 451 int *post_ret) 452 { 453 struct se_device *dev = cmd->se_dev; 454 sense_reason_t ret = TCM_NO_SENSE; 455 456 /* 457 * Only set SCF_COMPARE_AND_WRITE_POST to force a response fall-through 458 * within target_complete_ok_work() if the command was successfully 459 * sent to the backend driver. 460 */ 461 spin_lock_irq(&cmd->t_state_lock); 462 if (cmd->transport_state & CMD_T_SENT) { 463 cmd->se_cmd_flags |= SCF_COMPARE_AND_WRITE_POST; 464 *post_ret = 1; 465 466 if (cmd->scsi_status == SAM_STAT_CHECK_CONDITION) 467 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 468 } 469 spin_unlock_irq(&cmd->t_state_lock); 470 471 /* 472 * Unlock ->caw_sem originally obtained during sbc_compare_and_write() 473 * before the original READ I/O submission. 474 */ 475 up(&dev->caw_sem); 476 477 return ret; 478 } 479 480 static sense_reason_t compare_and_write_callback(struct se_cmd *cmd, bool success, 481 int *post_ret) 482 { 483 struct se_device *dev = cmd->se_dev; 484 struct scatterlist *write_sg = NULL, *sg; 485 unsigned char *buf = NULL, *addr; 486 struct sg_mapping_iter m; 487 unsigned int offset = 0, len; 488 unsigned int nlbas = cmd->t_task_nolb; 489 unsigned int block_size = dev->dev_attrib.block_size; 490 unsigned int compare_len = (nlbas * block_size); 491 sense_reason_t ret = TCM_NO_SENSE; 492 int rc, i; 493 494 /* 495 * Handle early failure in transport_generic_request_failure(), 496 * which will not have taken ->caw_sem yet.. 497 */ 498 if (!success && (!cmd->t_data_sg || !cmd->t_bidi_data_sg)) 499 return TCM_NO_SENSE; 500 /* 501 * Handle special case for zero-length COMPARE_AND_WRITE 502 */ 503 if (!cmd->data_length) 504 goto out; 505 /* 506 * Immediately exit + release dev->caw_sem if command has already 507 * been failed with a non-zero SCSI status. 508 */ 509 if (cmd->scsi_status) { 510 pr_err("compare_and_write_callback: non zero scsi_status:" 511 " 0x%02x\n", cmd->scsi_status); 512 goto out; 513 } 514 515 buf = kzalloc(cmd->data_length, GFP_KERNEL); 516 if (!buf) { 517 pr_err("Unable to allocate compare_and_write buf\n"); 518 ret = TCM_OUT_OF_RESOURCES; 519 goto out; 520 } 521 522 write_sg = kmalloc_array(cmd->t_data_nents, sizeof(*write_sg), 523 GFP_KERNEL); 524 if (!write_sg) { 525 pr_err("Unable to allocate compare_and_write sg\n"); 526 ret = TCM_OUT_OF_RESOURCES; 527 goto out; 528 } 529 sg_init_table(write_sg, cmd->t_data_nents); 530 /* 531 * Setup verify and write data payloads from total NumberLBAs. 532 */ 533 rc = sg_copy_to_buffer(cmd->t_data_sg, cmd->t_data_nents, buf, 534 cmd->data_length); 535 if (!rc) { 536 pr_err("sg_copy_to_buffer() failed for compare_and_write\n"); 537 ret = TCM_OUT_OF_RESOURCES; 538 goto out; 539 } 540 /* 541 * Compare against SCSI READ payload against verify payload 542 */ 543 for_each_sg(cmd->t_bidi_data_sg, sg, cmd->t_bidi_data_nents, i) { 544 addr = (unsigned char *)kmap_atomic(sg_page(sg)); 545 if (!addr) { 546 ret = TCM_OUT_OF_RESOURCES; 547 goto out; 548 } 549 550 len = min(sg->length, compare_len); 551 552 if (memcmp(addr, buf + offset, len)) { 553 pr_warn("Detected MISCOMPARE for addr: %p buf: %p\n", 554 addr, buf + offset); 555 kunmap_atomic(addr); 556 goto miscompare; 557 } 558 kunmap_atomic(addr); 559 560 offset += len; 561 compare_len -= len; 562 if (!compare_len) 563 break; 564 } 565 566 i = 0; 567 len = cmd->t_task_nolb * block_size; 568 sg_miter_start(&m, cmd->t_data_sg, cmd->t_data_nents, SG_MITER_TO_SG); 569 /* 570 * Currently assumes NoLB=1 and SGLs are PAGE_SIZE.. 571 */ 572 while (len) { 573 sg_miter_next(&m); 574 575 if (block_size < PAGE_SIZE) { 576 sg_set_page(&write_sg[i], m.page, block_size, 577 m.piter.sg->offset + block_size); 578 } else { 579 sg_miter_next(&m); 580 sg_set_page(&write_sg[i], m.page, block_size, 581 m.piter.sg->offset); 582 } 583 len -= block_size; 584 i++; 585 } 586 sg_miter_stop(&m); 587 /* 588 * Save the original SGL + nents values before updating to new 589 * assignments, to be released in transport_free_pages() -> 590 * transport_reset_sgl_orig() 591 */ 592 cmd->t_data_sg_orig = cmd->t_data_sg; 593 cmd->t_data_sg = write_sg; 594 cmd->t_data_nents_orig = cmd->t_data_nents; 595 cmd->t_data_nents = 1; 596 597 cmd->sam_task_attr = TCM_HEAD_TAG; 598 cmd->transport_complete_callback = compare_and_write_post; 599 /* 600 * Now reset ->execute_cmd() to the normal sbc_execute_rw() handler 601 * for submitting the adjusted SGL to write instance user-data. 602 */ 603 cmd->execute_cmd = sbc_execute_rw; 604 605 spin_lock_irq(&cmd->t_state_lock); 606 cmd->t_state = TRANSPORT_PROCESSING; 607 cmd->transport_state |= CMD_T_ACTIVE | CMD_T_SENT; 608 spin_unlock_irq(&cmd->t_state_lock); 609 610 __target_execute_cmd(cmd, false); 611 612 kfree(buf); 613 return ret; 614 615 miscompare: 616 pr_warn("Target/%s: Send MISCOMPARE check condition and sense\n", 617 dev->transport->name); 618 ret = TCM_MISCOMPARE_VERIFY; 619 out: 620 /* 621 * In the MISCOMPARE or failure case, unlock ->caw_sem obtained in 622 * sbc_compare_and_write() before the original READ I/O submission. 623 */ 624 up(&dev->caw_sem); 625 kfree(write_sg); 626 kfree(buf); 627 return ret; 628 } 629 630 static sense_reason_t 631 sbc_compare_and_write(struct se_cmd *cmd) 632 { 633 struct sbc_ops *ops = cmd->protocol_data; 634 struct se_device *dev = cmd->se_dev; 635 sense_reason_t ret; 636 int rc; 637 /* 638 * Submit the READ first for COMPARE_AND_WRITE to perform the 639 * comparision using SGLs at cmd->t_bidi_data_sg.. 640 */ 641 rc = down_interruptible(&dev->caw_sem); 642 if (rc != 0) { 643 cmd->transport_complete_callback = NULL; 644 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 645 } 646 /* 647 * Reset cmd->data_length to individual block_size in order to not 648 * confuse backend drivers that depend on this value matching the 649 * size of the I/O being submitted. 650 */ 651 cmd->data_length = cmd->t_task_nolb * dev->dev_attrib.block_size; 652 653 ret = ops->execute_rw(cmd, cmd->t_bidi_data_sg, cmd->t_bidi_data_nents, 654 DMA_FROM_DEVICE); 655 if (ret) { 656 cmd->transport_complete_callback = NULL; 657 up(&dev->caw_sem); 658 return ret; 659 } 660 /* 661 * Unlock of dev->caw_sem to occur in compare_and_write_callback() 662 * upon MISCOMPARE, or in compare_and_write_done() upon completion 663 * of WRITE instance user-data. 664 */ 665 return TCM_NO_SENSE; 666 } 667 668 static int 669 sbc_set_prot_op_checks(u8 protect, bool fabric_prot, enum target_prot_type prot_type, 670 bool is_write, struct se_cmd *cmd) 671 { 672 if (is_write) { 673 cmd->prot_op = fabric_prot ? TARGET_PROT_DOUT_STRIP : 674 protect ? TARGET_PROT_DOUT_PASS : 675 TARGET_PROT_DOUT_INSERT; 676 switch (protect) { 677 case 0x0: 678 case 0x3: 679 cmd->prot_checks = 0; 680 break; 681 case 0x1: 682 case 0x5: 683 cmd->prot_checks = TARGET_DIF_CHECK_GUARD; 684 if (prot_type == TARGET_DIF_TYPE1_PROT) 685 cmd->prot_checks |= TARGET_DIF_CHECK_REFTAG; 686 break; 687 case 0x2: 688 if (prot_type == TARGET_DIF_TYPE1_PROT) 689 cmd->prot_checks = TARGET_DIF_CHECK_REFTAG; 690 break; 691 case 0x4: 692 cmd->prot_checks = TARGET_DIF_CHECK_GUARD; 693 break; 694 default: 695 pr_err("Unsupported protect field %d\n", protect); 696 return -EINVAL; 697 } 698 } else { 699 cmd->prot_op = fabric_prot ? TARGET_PROT_DIN_INSERT : 700 protect ? TARGET_PROT_DIN_PASS : 701 TARGET_PROT_DIN_STRIP; 702 switch (protect) { 703 case 0x0: 704 case 0x1: 705 case 0x5: 706 cmd->prot_checks = TARGET_DIF_CHECK_GUARD; 707 if (prot_type == TARGET_DIF_TYPE1_PROT) 708 cmd->prot_checks |= TARGET_DIF_CHECK_REFTAG; 709 break; 710 case 0x2: 711 if (prot_type == TARGET_DIF_TYPE1_PROT) 712 cmd->prot_checks = TARGET_DIF_CHECK_REFTAG; 713 break; 714 case 0x3: 715 cmd->prot_checks = 0; 716 break; 717 case 0x4: 718 cmd->prot_checks = TARGET_DIF_CHECK_GUARD; 719 break; 720 default: 721 pr_err("Unsupported protect field %d\n", protect); 722 return -EINVAL; 723 } 724 } 725 726 return 0; 727 } 728 729 static sense_reason_t 730 sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb, 731 u32 sectors, bool is_write) 732 { 733 u8 protect = cdb[1] >> 5; 734 int sp_ops = cmd->se_sess->sup_prot_ops; 735 int pi_prot_type = dev->dev_attrib.pi_prot_type; 736 bool fabric_prot = false; 737 738 if (!cmd->t_prot_sg || !cmd->t_prot_nents) { 739 if (unlikely(protect && 740 !dev->dev_attrib.pi_prot_type && !cmd->se_sess->sess_prot_type)) { 741 pr_err("CDB contains protect bit, but device + fabric does" 742 " not advertise PROTECT=1 feature bit\n"); 743 return TCM_INVALID_CDB_FIELD; 744 } 745 if (cmd->prot_pto) 746 return TCM_NO_SENSE; 747 } 748 749 switch (dev->dev_attrib.pi_prot_type) { 750 case TARGET_DIF_TYPE3_PROT: 751 cmd->reftag_seed = 0xffffffff; 752 break; 753 case TARGET_DIF_TYPE2_PROT: 754 if (protect) 755 return TCM_INVALID_CDB_FIELD; 756 757 cmd->reftag_seed = cmd->t_task_lba; 758 break; 759 case TARGET_DIF_TYPE1_PROT: 760 cmd->reftag_seed = cmd->t_task_lba; 761 break; 762 case TARGET_DIF_TYPE0_PROT: 763 /* 764 * See if the fabric supports T10-PI, and the session has been 765 * configured to allow export PROTECT=1 feature bit with backend 766 * devices that don't support T10-PI. 767 */ 768 fabric_prot = is_write ? 769 !!(sp_ops & (TARGET_PROT_DOUT_PASS | TARGET_PROT_DOUT_STRIP)) : 770 !!(sp_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DIN_INSERT)); 771 772 if (fabric_prot && cmd->se_sess->sess_prot_type) { 773 pi_prot_type = cmd->se_sess->sess_prot_type; 774 break; 775 } 776 if (!protect) 777 return TCM_NO_SENSE; 778 /* Fallthrough */ 779 default: 780 pr_err("Unable to determine pi_prot_type for CDB: 0x%02x " 781 "PROTECT: 0x%02x\n", cdb[0], protect); 782 return TCM_INVALID_CDB_FIELD; 783 } 784 785 if (sbc_set_prot_op_checks(protect, fabric_prot, pi_prot_type, is_write, cmd)) 786 return TCM_INVALID_CDB_FIELD; 787 788 cmd->prot_type = pi_prot_type; 789 cmd->prot_length = dev->prot_length * sectors; 790 791 /** 792 * In case protection information exists over the wire 793 * we modify command data length to describe pure data. 794 * The actual transfer length is data length + protection 795 * length 796 **/ 797 if (protect) 798 cmd->data_length = sectors * dev->dev_attrib.block_size; 799 800 pr_debug("%s: prot_type=%d, data_length=%d, prot_length=%d " 801 "prot_op=%d prot_checks=%d\n", 802 __func__, cmd->prot_type, cmd->data_length, cmd->prot_length, 803 cmd->prot_op, cmd->prot_checks); 804 805 return TCM_NO_SENSE; 806 } 807 808 static int 809 sbc_check_dpofua(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb) 810 { 811 if (cdb[1] & 0x10) { 812 /* see explanation in spc_emulate_modesense */ 813 if (!target_check_fua(dev)) { 814 pr_err("Got CDB: 0x%02x with DPO bit set, but device" 815 " does not advertise support for DPO\n", cdb[0]); 816 return -EINVAL; 817 } 818 } 819 if (cdb[1] & 0x8) { 820 if (!target_check_fua(dev)) { 821 pr_err("Got CDB: 0x%02x with FUA bit set, but device" 822 " does not advertise support for FUA write\n", 823 cdb[0]); 824 return -EINVAL; 825 } 826 cmd->se_cmd_flags |= SCF_FUA; 827 } 828 return 0; 829 } 830 831 /** 832 * sbc_parse_verify - parse VERIFY, VERIFY_16 and WRITE VERIFY commands 833 * @cmd: (in) structure that describes the SCSI command to be parsed. 834 * @sectors: (out) Number of logical blocks on the storage medium that will be 835 * affected by the SCSI command. 836 * @bufflen: (out) Expected length of the SCSI Data-Out buffer. 837 */ 838 static sense_reason_t sbc_parse_verify(struct se_cmd *cmd, int *sectors, 839 u32 *bufflen) 840 { 841 struct se_device *dev = cmd->se_dev; 842 u8 *cdb = cmd->t_task_cdb; 843 u8 bytchk = (cdb[1] >> 1) & 3; 844 sense_reason_t ret; 845 846 switch (cdb[0]) { 847 case VERIFY: 848 case WRITE_VERIFY: 849 *sectors = transport_get_sectors_10(cdb); 850 cmd->t_task_lba = transport_lba_32(cdb); 851 break; 852 case VERIFY_16: 853 case WRITE_VERIFY_16: 854 *sectors = transport_get_sectors_16(cdb); 855 cmd->t_task_lba = transport_lba_64(cdb); 856 break; 857 default: 858 WARN_ON_ONCE(true); 859 return TCM_UNSUPPORTED_SCSI_OPCODE; 860 } 861 862 if (sbc_check_dpofua(dev, cmd, cdb)) 863 return TCM_INVALID_CDB_FIELD; 864 865 ret = sbc_check_prot(dev, cmd, cdb, *sectors, true); 866 if (ret) 867 return ret; 868 869 switch (bytchk) { 870 case 0: 871 *bufflen = 0; 872 break; 873 case 1: 874 *bufflen = sbc_get_size(cmd, *sectors); 875 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 876 break; 877 default: 878 pr_err("Unsupported BYTCHK value %d for SCSI opcode %#x\n", 879 bytchk, cdb[0]); 880 return TCM_INVALID_CDB_FIELD; 881 } 882 return TCM_NO_SENSE; 883 } 884 885 sense_reason_t 886 sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops) 887 { 888 struct se_device *dev = cmd->se_dev; 889 unsigned char *cdb = cmd->t_task_cdb; 890 unsigned int size; 891 u32 sectors = 0; 892 sense_reason_t ret; 893 894 cmd->protocol_data = ops; 895 896 switch (cdb[0]) { 897 case READ_6: 898 sectors = transport_get_sectors_6(cdb); 899 cmd->t_task_lba = transport_lba_21(cdb); 900 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 901 cmd->execute_cmd = sbc_execute_rw; 902 break; 903 case READ_10: 904 sectors = transport_get_sectors_10(cdb); 905 cmd->t_task_lba = transport_lba_32(cdb); 906 907 if (sbc_check_dpofua(dev, cmd, cdb)) 908 return TCM_INVALID_CDB_FIELD; 909 910 ret = sbc_check_prot(dev, cmd, cdb, sectors, false); 911 if (ret) 912 return ret; 913 914 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 915 cmd->execute_cmd = sbc_execute_rw; 916 break; 917 case READ_12: 918 sectors = transport_get_sectors_12(cdb); 919 cmd->t_task_lba = transport_lba_32(cdb); 920 921 if (sbc_check_dpofua(dev, cmd, cdb)) 922 return TCM_INVALID_CDB_FIELD; 923 924 ret = sbc_check_prot(dev, cmd, cdb, sectors, false); 925 if (ret) 926 return ret; 927 928 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 929 cmd->execute_cmd = sbc_execute_rw; 930 break; 931 case READ_16: 932 sectors = transport_get_sectors_16(cdb); 933 cmd->t_task_lba = transport_lba_64(cdb); 934 935 if (sbc_check_dpofua(dev, cmd, cdb)) 936 return TCM_INVALID_CDB_FIELD; 937 938 ret = sbc_check_prot(dev, cmd, cdb, sectors, false); 939 if (ret) 940 return ret; 941 942 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 943 cmd->execute_cmd = sbc_execute_rw; 944 break; 945 case WRITE_6: 946 sectors = transport_get_sectors_6(cdb); 947 cmd->t_task_lba = transport_lba_21(cdb); 948 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 949 cmd->execute_cmd = sbc_execute_rw; 950 break; 951 case WRITE_10: 952 sectors = transport_get_sectors_10(cdb); 953 cmd->t_task_lba = transport_lba_32(cdb); 954 955 if (sbc_check_dpofua(dev, cmd, cdb)) 956 return TCM_INVALID_CDB_FIELD; 957 958 ret = sbc_check_prot(dev, cmd, cdb, sectors, true); 959 if (ret) 960 return ret; 961 962 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 963 cmd->execute_cmd = sbc_execute_rw; 964 break; 965 case WRITE_VERIFY: 966 case WRITE_VERIFY_16: 967 ret = sbc_parse_verify(cmd, §ors, &size); 968 if (ret) 969 return ret; 970 cmd->execute_cmd = sbc_execute_rw; 971 goto check_lba; 972 case WRITE_12: 973 sectors = transport_get_sectors_12(cdb); 974 cmd->t_task_lba = transport_lba_32(cdb); 975 976 if (sbc_check_dpofua(dev, cmd, cdb)) 977 return TCM_INVALID_CDB_FIELD; 978 979 ret = sbc_check_prot(dev, cmd, cdb, sectors, true); 980 if (ret) 981 return ret; 982 983 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 984 cmd->execute_cmd = sbc_execute_rw; 985 break; 986 case WRITE_16: 987 sectors = transport_get_sectors_16(cdb); 988 cmd->t_task_lba = transport_lba_64(cdb); 989 990 if (sbc_check_dpofua(dev, cmd, cdb)) 991 return TCM_INVALID_CDB_FIELD; 992 993 ret = sbc_check_prot(dev, cmd, cdb, sectors, true); 994 if (ret) 995 return ret; 996 997 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 998 cmd->execute_cmd = sbc_execute_rw; 999 break; 1000 case XDWRITEREAD_10: 1001 if (cmd->data_direction != DMA_TO_DEVICE || 1002 !(cmd->se_cmd_flags & SCF_BIDI)) 1003 return TCM_INVALID_CDB_FIELD; 1004 sectors = transport_get_sectors_10(cdb); 1005 1006 if (sbc_check_dpofua(dev, cmd, cdb)) 1007 return TCM_INVALID_CDB_FIELD; 1008 1009 cmd->t_task_lba = transport_lba_32(cdb); 1010 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 1011 1012 /* 1013 * Setup BIDI XOR callback to be run after I/O completion. 1014 */ 1015 cmd->execute_cmd = sbc_execute_rw; 1016 cmd->transport_complete_callback = &xdreadwrite_callback; 1017 break; 1018 case VARIABLE_LENGTH_CMD: 1019 { 1020 u16 service_action = get_unaligned_be16(&cdb[8]); 1021 switch (service_action) { 1022 case XDWRITEREAD_32: 1023 sectors = transport_get_sectors_32(cdb); 1024 1025 if (sbc_check_dpofua(dev, cmd, cdb)) 1026 return TCM_INVALID_CDB_FIELD; 1027 /* 1028 * Use WRITE_32 and READ_32 opcodes for the emulated 1029 * XDWRITE_READ_32 logic. 1030 */ 1031 cmd->t_task_lba = transport_lba_64_ext(cdb); 1032 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; 1033 1034 /* 1035 * Setup BIDI XOR callback to be run during after I/O 1036 * completion. 1037 */ 1038 cmd->execute_cmd = sbc_execute_rw; 1039 cmd->transport_complete_callback = &xdreadwrite_callback; 1040 break; 1041 case WRITE_SAME_32: 1042 sectors = transport_get_sectors_32(cdb); 1043 if (!sectors) { 1044 pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not" 1045 " supported\n"); 1046 return TCM_INVALID_CDB_FIELD; 1047 } 1048 1049 size = sbc_get_size(cmd, 1); 1050 cmd->t_task_lba = get_unaligned_be64(&cdb[12]); 1051 1052 ret = sbc_setup_write_same(cmd, &cdb[10], ops); 1053 if (ret) 1054 return ret; 1055 break; 1056 default: 1057 pr_err("VARIABLE_LENGTH_CMD service action" 1058 " 0x%04x not supported\n", service_action); 1059 return TCM_UNSUPPORTED_SCSI_OPCODE; 1060 } 1061 break; 1062 } 1063 case COMPARE_AND_WRITE: 1064 sectors = cdb[13]; 1065 /* 1066 * Currently enforce COMPARE_AND_WRITE for a single sector 1067 */ 1068 if (sectors > 1) { 1069 pr_err("COMPARE_AND_WRITE contains NoLB: %u greater" 1070 " than 1\n", sectors); 1071 return TCM_INVALID_CDB_FIELD; 1072 } 1073 if (sbc_check_dpofua(dev, cmd, cdb)) 1074 return TCM_INVALID_CDB_FIELD; 1075 1076 /* 1077 * Double size because we have two buffers, note that 1078 * zero is not an error.. 1079 */ 1080 size = 2 * sbc_get_size(cmd, sectors); 1081 cmd->t_task_lba = get_unaligned_be64(&cdb[2]); 1082 cmd->t_task_nolb = sectors; 1083 cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB | SCF_COMPARE_AND_WRITE; 1084 cmd->execute_cmd = sbc_compare_and_write; 1085 cmd->transport_complete_callback = compare_and_write_callback; 1086 break; 1087 case READ_CAPACITY: 1088 size = READ_CAP_LEN; 1089 cmd->execute_cmd = sbc_emulate_readcapacity; 1090 break; 1091 case SERVICE_ACTION_IN_16: 1092 switch (cmd->t_task_cdb[1] & 0x1f) { 1093 case SAI_READ_CAPACITY_16: 1094 cmd->execute_cmd = sbc_emulate_readcapacity_16; 1095 break; 1096 case SAI_REPORT_REFERRALS: 1097 cmd->execute_cmd = target_emulate_report_referrals; 1098 break; 1099 default: 1100 pr_err("Unsupported SA: 0x%02x\n", 1101 cmd->t_task_cdb[1] & 0x1f); 1102 return TCM_INVALID_CDB_FIELD; 1103 } 1104 size = (cdb[10] << 24) | (cdb[11] << 16) | 1105 (cdb[12] << 8) | cdb[13]; 1106 break; 1107 case SYNCHRONIZE_CACHE: 1108 case SYNCHRONIZE_CACHE_16: 1109 if (cdb[0] == SYNCHRONIZE_CACHE) { 1110 sectors = transport_get_sectors_10(cdb); 1111 cmd->t_task_lba = transport_lba_32(cdb); 1112 } else { 1113 sectors = transport_get_sectors_16(cdb); 1114 cmd->t_task_lba = transport_lba_64(cdb); 1115 } 1116 if (ops->execute_sync_cache) { 1117 cmd->execute_cmd = ops->execute_sync_cache; 1118 goto check_lba; 1119 } 1120 size = 0; 1121 cmd->execute_cmd = sbc_emulate_noop; 1122 break; 1123 case UNMAP: 1124 if (!ops->execute_unmap) 1125 return TCM_UNSUPPORTED_SCSI_OPCODE; 1126 1127 if (!dev->dev_attrib.emulate_tpu) { 1128 pr_err("Got UNMAP, but backend device has" 1129 " emulate_tpu disabled\n"); 1130 return TCM_UNSUPPORTED_SCSI_OPCODE; 1131 } 1132 size = get_unaligned_be16(&cdb[7]); 1133 cmd->execute_cmd = sbc_execute_unmap; 1134 break; 1135 case WRITE_SAME_16: 1136 sectors = transport_get_sectors_16(cdb); 1137 if (!sectors) { 1138 pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n"); 1139 return TCM_INVALID_CDB_FIELD; 1140 } 1141 1142 size = sbc_get_size(cmd, 1); 1143 cmd->t_task_lba = get_unaligned_be64(&cdb[2]); 1144 1145 ret = sbc_setup_write_same(cmd, &cdb[1], ops); 1146 if (ret) 1147 return ret; 1148 break; 1149 case WRITE_SAME: 1150 sectors = transport_get_sectors_10(cdb); 1151 if (!sectors) { 1152 pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n"); 1153 return TCM_INVALID_CDB_FIELD; 1154 } 1155 1156 size = sbc_get_size(cmd, 1); 1157 cmd->t_task_lba = get_unaligned_be32(&cdb[2]); 1158 1159 /* 1160 * Follow sbcr26 with WRITE_SAME (10) and check for the existence 1161 * of byte 1 bit 3 UNMAP instead of original reserved field 1162 */ 1163 ret = sbc_setup_write_same(cmd, &cdb[1], ops); 1164 if (ret) 1165 return ret; 1166 break; 1167 case VERIFY: 1168 case VERIFY_16: 1169 ret = sbc_parse_verify(cmd, §ors, &size); 1170 if (ret) 1171 return ret; 1172 cmd->execute_cmd = sbc_emulate_noop; 1173 goto check_lba; 1174 case REZERO_UNIT: 1175 case SEEK_6: 1176 case SEEK_10: 1177 /* 1178 * There are still clients out there which use these old SCSI-2 1179 * commands. This mainly happens when running VMs with legacy 1180 * guest systems, connected via SCSI command pass-through to 1181 * iSCSI targets. Make them happy and return status GOOD. 1182 */ 1183 size = 0; 1184 cmd->execute_cmd = sbc_emulate_noop; 1185 break; 1186 case START_STOP: 1187 size = 0; 1188 cmd->execute_cmd = sbc_emulate_startstop; 1189 break; 1190 default: 1191 ret = spc_parse_cdb(cmd, &size); 1192 if (ret) 1193 return ret; 1194 } 1195 1196 /* reject any command that we don't have a handler for */ 1197 if (!cmd->execute_cmd) 1198 return TCM_UNSUPPORTED_SCSI_OPCODE; 1199 1200 if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) { 1201 unsigned long long end_lba; 1202 check_lba: 1203 end_lba = dev->transport->get_blocks(dev) + 1; 1204 if (((cmd->t_task_lba + sectors) < cmd->t_task_lba) || 1205 ((cmd->t_task_lba + sectors) > end_lba)) { 1206 pr_err("cmd exceeds last lba %llu " 1207 "(lba %llu, sectors %u)\n", 1208 end_lba, cmd->t_task_lba, sectors); 1209 return TCM_ADDRESS_OUT_OF_RANGE; 1210 } 1211 1212 if (!(cmd->se_cmd_flags & SCF_COMPARE_AND_WRITE)) 1213 size = sbc_get_size(cmd, sectors); 1214 } 1215 1216 return target_cmd_size_check(cmd, size); 1217 } 1218 EXPORT_SYMBOL(sbc_parse_cdb); 1219 1220 u32 sbc_get_device_type(struct se_device *dev) 1221 { 1222 return TYPE_DISK; 1223 } 1224 EXPORT_SYMBOL(sbc_get_device_type); 1225 1226 static sense_reason_t 1227 sbc_execute_unmap(struct se_cmd *cmd) 1228 { 1229 struct sbc_ops *ops = cmd->protocol_data; 1230 struct se_device *dev = cmd->se_dev; 1231 unsigned char *buf, *ptr = NULL; 1232 sector_t lba; 1233 int size; 1234 u32 range; 1235 sense_reason_t ret = 0; 1236 int dl, bd_dl; 1237 1238 /* We never set ANC_SUP */ 1239 if (cmd->t_task_cdb[1]) 1240 return TCM_INVALID_CDB_FIELD; 1241 1242 if (cmd->data_length == 0) { 1243 target_complete_cmd(cmd, SAM_STAT_GOOD); 1244 return 0; 1245 } 1246 1247 if (cmd->data_length < 8) { 1248 pr_warn("UNMAP parameter list length %u too small\n", 1249 cmd->data_length); 1250 return TCM_PARAMETER_LIST_LENGTH_ERROR; 1251 } 1252 1253 buf = transport_kmap_data_sg(cmd); 1254 if (!buf) 1255 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1256 1257 dl = get_unaligned_be16(&buf[0]); 1258 bd_dl = get_unaligned_be16(&buf[2]); 1259 1260 size = cmd->data_length - 8; 1261 if (bd_dl > size) 1262 pr_warn("UNMAP parameter list length %u too small, ignoring bd_dl %u\n", 1263 cmd->data_length, bd_dl); 1264 else 1265 size = bd_dl; 1266 1267 if (size / 16 > dev->dev_attrib.max_unmap_block_desc_count) { 1268 ret = TCM_INVALID_PARAMETER_LIST; 1269 goto err; 1270 } 1271 1272 /* First UNMAP block descriptor starts at 8 byte offset */ 1273 ptr = &buf[8]; 1274 pr_debug("UNMAP: Sub: %s Using dl: %u bd_dl: %u size: %u" 1275 " ptr: %p\n", dev->transport->name, dl, bd_dl, size, ptr); 1276 1277 while (size >= 16) { 1278 lba = get_unaligned_be64(&ptr[0]); 1279 range = get_unaligned_be32(&ptr[8]); 1280 pr_debug("UNMAP: Using lba: %llu and range: %u\n", 1281 (unsigned long long)lba, range); 1282 1283 if (range > dev->dev_attrib.max_unmap_lba_count) { 1284 ret = TCM_INVALID_PARAMETER_LIST; 1285 goto err; 1286 } 1287 1288 if (lba + range > dev->transport->get_blocks(dev) + 1) { 1289 ret = TCM_ADDRESS_OUT_OF_RANGE; 1290 goto err; 1291 } 1292 1293 ret = ops->execute_unmap(cmd, lba, range); 1294 if (ret) 1295 goto err; 1296 1297 ptr += 16; 1298 size -= 16; 1299 } 1300 1301 err: 1302 transport_kunmap_data_sg(cmd); 1303 if (!ret) 1304 target_complete_cmd(cmd, GOOD); 1305 return ret; 1306 } 1307 1308 void 1309 sbc_dif_generate(struct se_cmd *cmd) 1310 { 1311 struct se_device *dev = cmd->se_dev; 1312 struct t10_pi_tuple *sdt; 1313 struct scatterlist *dsg = cmd->t_data_sg, *psg; 1314 sector_t sector = cmd->t_task_lba; 1315 void *daddr, *paddr; 1316 int i, j, offset = 0; 1317 unsigned int block_size = dev->dev_attrib.block_size; 1318 1319 for_each_sg(cmd->t_prot_sg, psg, cmd->t_prot_nents, i) { 1320 paddr = kmap_atomic(sg_page(psg)) + psg->offset; 1321 daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; 1322 1323 for (j = 0; j < psg->length; 1324 j += sizeof(*sdt)) { 1325 __u16 crc; 1326 unsigned int avail; 1327 1328 if (offset >= dsg->length) { 1329 offset -= dsg->length; 1330 kunmap_atomic(daddr - dsg->offset); 1331 dsg = sg_next(dsg); 1332 if (!dsg) { 1333 kunmap_atomic(paddr - psg->offset); 1334 return; 1335 } 1336 daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; 1337 } 1338 1339 sdt = paddr + j; 1340 avail = min(block_size, dsg->length - offset); 1341 crc = crc_t10dif(daddr + offset, avail); 1342 if (avail < block_size) { 1343 kunmap_atomic(daddr - dsg->offset); 1344 dsg = sg_next(dsg); 1345 if (!dsg) { 1346 kunmap_atomic(paddr - psg->offset); 1347 return; 1348 } 1349 daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; 1350 offset = block_size - avail; 1351 crc = crc_t10dif_update(crc, daddr, offset); 1352 } else { 1353 offset += block_size; 1354 } 1355 1356 sdt->guard_tag = cpu_to_be16(crc); 1357 if (cmd->prot_type == TARGET_DIF_TYPE1_PROT) 1358 sdt->ref_tag = cpu_to_be32(sector & 0xffffffff); 1359 sdt->app_tag = 0; 1360 1361 pr_debug("DIF %s INSERT sector: %llu guard_tag: 0x%04x" 1362 " app_tag: 0x%04x ref_tag: %u\n", 1363 (cmd->data_direction == DMA_TO_DEVICE) ? 1364 "WRITE" : "READ", (unsigned long long)sector, 1365 sdt->guard_tag, sdt->app_tag, 1366 be32_to_cpu(sdt->ref_tag)); 1367 1368 sector++; 1369 } 1370 1371 kunmap_atomic(daddr - dsg->offset); 1372 kunmap_atomic(paddr - psg->offset); 1373 } 1374 } 1375 1376 static sense_reason_t 1377 sbc_dif_v1_verify(struct se_cmd *cmd, struct t10_pi_tuple *sdt, 1378 __u16 crc, sector_t sector, unsigned int ei_lba) 1379 { 1380 __be16 csum; 1381 1382 if (!(cmd->prot_checks & TARGET_DIF_CHECK_GUARD)) 1383 goto check_ref; 1384 1385 csum = cpu_to_be16(crc); 1386 1387 if (sdt->guard_tag != csum) { 1388 pr_err("DIFv1 checksum failed on sector %llu guard tag 0x%04x" 1389 " csum 0x%04x\n", (unsigned long long)sector, 1390 be16_to_cpu(sdt->guard_tag), be16_to_cpu(csum)); 1391 return TCM_LOGICAL_BLOCK_GUARD_CHECK_FAILED; 1392 } 1393 1394 check_ref: 1395 if (!(cmd->prot_checks & TARGET_DIF_CHECK_REFTAG)) 1396 return 0; 1397 1398 if (cmd->prot_type == TARGET_DIF_TYPE1_PROT && 1399 be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) { 1400 pr_err("DIFv1 Type 1 reference failed on sector: %llu tag: 0x%08x" 1401 " sector MSB: 0x%08x\n", (unsigned long long)sector, 1402 be32_to_cpu(sdt->ref_tag), (u32)(sector & 0xffffffff)); 1403 return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED; 1404 } 1405 1406 if (cmd->prot_type == TARGET_DIF_TYPE2_PROT && 1407 be32_to_cpu(sdt->ref_tag) != ei_lba) { 1408 pr_err("DIFv1 Type 2 reference failed on sector: %llu tag: 0x%08x" 1409 " ei_lba: 0x%08x\n", (unsigned long long)sector, 1410 be32_to_cpu(sdt->ref_tag), ei_lba); 1411 return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED; 1412 } 1413 1414 return 0; 1415 } 1416 1417 void sbc_dif_copy_prot(struct se_cmd *cmd, unsigned int sectors, bool read, 1418 struct scatterlist *sg, int sg_off) 1419 { 1420 struct se_device *dev = cmd->se_dev; 1421 struct scatterlist *psg; 1422 void *paddr, *addr; 1423 unsigned int i, len, left; 1424 unsigned int offset = sg_off; 1425 1426 if (!sg) 1427 return; 1428 1429 left = sectors * dev->prot_length; 1430 1431 for_each_sg(cmd->t_prot_sg, psg, cmd->t_prot_nents, i) { 1432 unsigned int psg_len, copied = 0; 1433 1434 paddr = kmap_atomic(sg_page(psg)) + psg->offset; 1435 psg_len = min(left, psg->length); 1436 while (psg_len) { 1437 len = min(psg_len, sg->length - offset); 1438 addr = kmap_atomic(sg_page(sg)) + sg->offset + offset; 1439 1440 if (read) 1441 memcpy(paddr + copied, addr, len); 1442 else 1443 memcpy(addr, paddr + copied, len); 1444 1445 left -= len; 1446 offset += len; 1447 copied += len; 1448 psg_len -= len; 1449 1450 kunmap_atomic(addr - sg->offset - offset); 1451 1452 if (offset >= sg->length) { 1453 sg = sg_next(sg); 1454 offset = 0; 1455 } 1456 } 1457 kunmap_atomic(paddr - psg->offset); 1458 } 1459 } 1460 EXPORT_SYMBOL(sbc_dif_copy_prot); 1461 1462 sense_reason_t 1463 sbc_dif_verify(struct se_cmd *cmd, sector_t start, unsigned int sectors, 1464 unsigned int ei_lba, struct scatterlist *psg, int psg_off) 1465 { 1466 struct se_device *dev = cmd->se_dev; 1467 struct t10_pi_tuple *sdt; 1468 struct scatterlist *dsg = cmd->t_data_sg; 1469 sector_t sector = start; 1470 void *daddr, *paddr; 1471 int i; 1472 sense_reason_t rc; 1473 int dsg_off = 0; 1474 unsigned int block_size = dev->dev_attrib.block_size; 1475 1476 for (; psg && sector < start + sectors; psg = sg_next(psg)) { 1477 paddr = kmap_atomic(sg_page(psg)) + psg->offset; 1478 daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; 1479 1480 for (i = psg_off; i < psg->length && 1481 sector < start + sectors; 1482 i += sizeof(*sdt)) { 1483 __u16 crc; 1484 unsigned int avail; 1485 1486 if (dsg_off >= dsg->length) { 1487 dsg_off -= dsg->length; 1488 kunmap_atomic(daddr - dsg->offset); 1489 dsg = sg_next(dsg); 1490 if (!dsg) { 1491 kunmap_atomic(paddr - psg->offset); 1492 return 0; 1493 } 1494 daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; 1495 } 1496 1497 sdt = paddr + i; 1498 1499 pr_debug("DIF READ sector: %llu guard_tag: 0x%04x" 1500 " app_tag: 0x%04x ref_tag: %u\n", 1501 (unsigned long long)sector, sdt->guard_tag, 1502 sdt->app_tag, be32_to_cpu(sdt->ref_tag)); 1503 1504 if (sdt->app_tag == cpu_to_be16(0xffff)) { 1505 dsg_off += block_size; 1506 goto next; 1507 } 1508 1509 avail = min(block_size, dsg->length - dsg_off); 1510 crc = crc_t10dif(daddr + dsg_off, avail); 1511 if (avail < block_size) { 1512 kunmap_atomic(daddr - dsg->offset); 1513 dsg = sg_next(dsg); 1514 if (!dsg) { 1515 kunmap_atomic(paddr - psg->offset); 1516 return 0; 1517 } 1518 daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; 1519 dsg_off = block_size - avail; 1520 crc = crc_t10dif_update(crc, daddr, dsg_off); 1521 } else { 1522 dsg_off += block_size; 1523 } 1524 1525 rc = sbc_dif_v1_verify(cmd, sdt, crc, sector, ei_lba); 1526 if (rc) { 1527 kunmap_atomic(daddr - dsg->offset); 1528 kunmap_atomic(paddr - psg->offset); 1529 cmd->bad_sector = sector; 1530 return rc; 1531 } 1532 next: 1533 sector++; 1534 ei_lba++; 1535 } 1536 1537 psg_off = 0; 1538 kunmap_atomic(daddr - dsg->offset); 1539 kunmap_atomic(paddr - psg->offset); 1540 } 1541 1542 return 0; 1543 } 1544 EXPORT_SYMBOL(sbc_dif_verify); 1545