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