1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2008-2012 Daisuke Aoyama <aoyama@peach.ne.jp>. 3 * Copyright (C) 2016 Intel Corporation. 4 * All rights reserved. 5 */ 6 7 #include "scsi_internal.h" 8 9 #include "spdk/env.h" 10 #include "spdk/bdev.h" 11 #include "spdk/endian.h" 12 #include "spdk/likely.h" 13 #include "spdk/string.h" 14 #include "spdk/util.h" 15 16 #define SPDK_WORK_BLOCK_SIZE (4ULL * 1024ULL * 1024ULL) 17 #define SPDK_WORK_ATS_BLOCK_SIZE (1ULL * 1024ULL * 1024ULL) 18 #define MAX_SERIAL_STRING 32 19 20 #define DEFAULT_DISK_VENDOR "INTEL" 21 #define DEFAULT_DISK_REVISION "0001" 22 #define DEFAULT_DISK_ROTATION_RATE 1 /* Non-rotating medium */ 23 #define DEFAULT_DISK_FORM_FACTOR 0x02 /* 3.5 inch */ 24 #define DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT 256 25 26 #define INQUIRY_OFFSET(field) offsetof(struct spdk_scsi_cdb_inquiry_data, field) + \ 27 SPDK_SIZEOF_MEMBER(struct spdk_scsi_cdb_inquiry_data, field) 28 29 static void bdev_scsi_process_block_resubmit(void *arg); 30 31 static void 32 bdev_scsi_set_naa_ieee_extended(const char *name, uint8_t *buf) 33 { 34 int i; 35 uint64_t local_value = 0, id_a, seed = 131; 36 37 for (i = 0; name[i] != '\0'; i++) { 38 local_value = (local_value * seed) + name[i]; 39 } 40 41 /* 42 * see spc3r23 7.6.3.6.2, 43 * NAA IEEE Extended identifier format 44 */ 45 id_a = local_value & 0x0000000fff000000ull; 46 id_a = id_a << 24; 47 48 local_value &= 0x0000000000ffffffull; 49 /* NAA 02, and 00 03 47 for IEEE Intel */ 50 local_value |= 0x2000000347000000ull; 51 local_value |= id_a; 52 53 to_be64((void *)buf, local_value); 54 } 55 56 static int 57 bdev_scsi_report_luns(struct spdk_scsi_lun *lun, 58 int sel, uint8_t *data, int alloc_len) 59 { 60 struct spdk_scsi_dev *dev; 61 struct spdk_scsi_lun *tmp_lun; 62 uint64_t fmt_lun; 63 int hlen, len = 0; 64 65 if (alloc_len < 8) { 66 return -1; 67 } 68 69 if (sel == 0x00) { 70 /* logical unit with addressing method */ 71 } else if (sel == 0x01) { 72 /* well known logical unit */ 73 } else if (sel == 0x02) { 74 /* logical unit */ 75 } else { 76 return -1; 77 } 78 79 /* LUN LIST LENGTH */ 80 memset(data, 0, 4); 81 82 /* Reserved */ 83 memset(&data[4], 0, 4); 84 hlen = 8; 85 86 dev = lun->dev; 87 88 for (tmp_lun = spdk_scsi_dev_get_first_lun(dev); tmp_lun != NULL; 89 tmp_lun = spdk_scsi_dev_get_next_lun(tmp_lun)) { 90 if (alloc_len - (hlen + len) < 8) { 91 return -1; 92 } 93 94 fmt_lun = spdk_scsi_lun_id_int_to_fmt(tmp_lun->id); 95 96 /* LUN */ 97 to_be64(&data[hlen + len], fmt_lun); 98 len += 8; 99 } 100 101 /* LUN LIST LENGTH */ 102 to_be32(data, len); 103 104 return hlen + len; 105 } 106 107 static int 108 bdev_scsi_pad_scsi_name(char *dst, const char *name) 109 { 110 size_t len; 111 112 len = strlen(name); 113 memcpy(dst, name, len); 114 do { 115 dst[len++] = '\0'; 116 } while (len & 3); 117 118 return len; 119 } 120 121 static int 122 bdev_scsi_inquiry(struct spdk_bdev *bdev, struct spdk_scsi_task *task, 123 uint8_t *cdb, uint8_t *data, uint16_t alloc_len) 124 { 125 struct spdk_scsi_lun *lun; 126 struct spdk_scsi_dev *dev; 127 struct spdk_scsi_port *port; 128 uint32_t blocks, optimal_blocks; 129 int hlen = 0, plen, plen2; 130 uint16_t len = 0; 131 int pc; 132 int pd; 133 int evpd; 134 int i; 135 struct spdk_scsi_cdb_inquiry *inq = (struct spdk_scsi_cdb_inquiry *)cdb; 136 137 /* standard inquiry command at lease with 36 Bytes */ 138 if (alloc_len < 0x24) { 139 goto inq_error; 140 } 141 142 lun = task->lun; 143 dev = lun->dev; 144 port = task->target_port; 145 146 pd = SPDK_SPC_PERIPHERAL_DEVICE_TYPE_DISK; 147 pc = inq->page_code; 148 evpd = inq->evpd & 0x1; 149 150 if (!evpd && pc) { 151 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 152 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 153 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 154 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 155 return -1; 156 } 157 158 if (evpd) { 159 struct spdk_scsi_vpd_page *vpage = (struct spdk_scsi_vpd_page *)data; 160 161 /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */ 162 vpage->peripheral_device_type = pd; 163 vpage->peripheral_qualifier = SPDK_SPC_PERIPHERAL_QUALIFIER_CONNECTED; 164 /* PAGE CODE */ 165 vpage->page_code = pc; 166 167 /* Vital product data */ 168 switch (pc) { 169 case SPDK_SPC_VPD_SUPPORTED_VPD_PAGES: 170 hlen = 4; 171 172 vpage->params[0] = SPDK_SPC_VPD_SUPPORTED_VPD_PAGES; 173 vpage->params[1] = SPDK_SPC_VPD_UNIT_SERIAL_NUMBER; 174 vpage->params[2] = SPDK_SPC_VPD_DEVICE_IDENTIFICATION; 175 vpage->params[3] = SPDK_SPC_VPD_MANAGEMENT_NETWORK_ADDRESSES; 176 vpage->params[4] = SPDK_SPC_VPD_EXTENDED_INQUIRY_DATA; 177 vpage->params[5] = SPDK_SPC_VPD_MODE_PAGE_POLICY; 178 vpage->params[6] = SPDK_SPC_VPD_SCSI_PORTS; 179 vpage->params[7] = SPDK_SPC_VPD_BLOCK_LIMITS; 180 vpage->params[8] = SPDK_SPC_VPD_BLOCK_DEV_CHARS; 181 len = 9; 182 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 183 vpage->params[9] = SPDK_SPC_VPD_BLOCK_THIN_PROVISION; 184 len++; 185 } 186 187 /* PAGE LENGTH */ 188 to_be16(vpage->alloc_len, len); 189 break; 190 191 case SPDK_SPC_VPD_UNIT_SERIAL_NUMBER: { 192 const char *name = spdk_bdev_get_name(bdev); 193 194 hlen = 4; 195 196 /* PRODUCT SERIAL NUMBER */ 197 len = strlen(name) + 1; 198 if (len > MAX_SERIAL_STRING) { 199 len = MAX_SERIAL_STRING; 200 } 201 202 memcpy(vpage->params, name, len - 1); 203 vpage->params[len - 1] = 0; 204 205 /* PAGE LENGTH */ 206 to_be16(vpage->alloc_len, len); 207 break; 208 } 209 210 case SPDK_SPC_VPD_DEVICE_IDENTIFICATION: { 211 const char *name = spdk_bdev_get_name(bdev); 212 const char *product_name = spdk_bdev_get_product_name(bdev); 213 uint8_t protocol_id = dev->protocol_id; 214 uint8_t *buf = vpage->params; 215 struct spdk_scsi_desig_desc *desig; 216 217 hlen = 4; 218 219 /* Check total length by calculated how much space all entries take */ 220 len = sizeof(struct spdk_scsi_desig_desc) + 8; 221 len += sizeof(struct spdk_scsi_desig_desc) + 8 + 16 + MAX_SERIAL_STRING; 222 len += sizeof(struct spdk_scsi_desig_desc) + SPDK_SCSI_DEV_MAX_NAME + 1; 223 len += sizeof(struct spdk_scsi_desig_desc) + SPDK_SCSI_PORT_MAX_NAME_LENGTH; 224 len += sizeof(struct spdk_scsi_desig_desc) + 4; 225 len += sizeof(struct spdk_scsi_desig_desc) + 4; 226 len += sizeof(struct spdk_scsi_desig_desc) + 4; 227 if (sizeof(struct spdk_scsi_vpd_page) + len > alloc_len) { 228 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 229 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 230 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 231 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 232 return -1; 233 } 234 235 /* Now fill out the designator array */ 236 237 /* NAA designator */ 238 desig = (struct spdk_scsi_desig_desc *)buf; 239 desig->code_set = SPDK_SPC_VPD_CODE_SET_BINARY; 240 desig->protocol_id = protocol_id; 241 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_NAA; 242 desig->association = SPDK_SPC_VPD_ASSOCIATION_LOGICAL_UNIT; 243 desig->reserved0 = 0; 244 desig->piv = 1; 245 desig->reserved1 = 0; 246 desig->len = 8; 247 bdev_scsi_set_naa_ieee_extended(name, desig->desig); 248 len = sizeof(struct spdk_scsi_desig_desc) + 8; 249 250 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len; 251 252 /* T10 Vendor ID designator */ 253 desig = (struct spdk_scsi_desig_desc *)buf; 254 desig->code_set = SPDK_SPC_VPD_CODE_SET_ASCII; 255 desig->protocol_id = protocol_id; 256 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_T10_VENDOR_ID; 257 desig->association = SPDK_SPC_VPD_ASSOCIATION_LOGICAL_UNIT; 258 desig->reserved0 = 0; 259 desig->piv = 1; 260 desig->reserved1 = 0; 261 desig->len = 8 + 16 + MAX_SERIAL_STRING; 262 spdk_strcpy_pad(desig->desig, DEFAULT_DISK_VENDOR, 8, ' '); 263 spdk_strcpy_pad(&desig->desig[8], product_name, 16, ' '); 264 spdk_strcpy_pad(&desig->desig[24], name, MAX_SERIAL_STRING, ' '); 265 len += sizeof(struct spdk_scsi_desig_desc) + 8 + 16 + MAX_SERIAL_STRING; 266 267 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len; 268 269 /* SCSI Device Name designator */ 270 desig = (struct spdk_scsi_desig_desc *)buf; 271 desig->code_set = SPDK_SPC_VPD_CODE_SET_UTF8; 272 desig->protocol_id = protocol_id; 273 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME; 274 desig->association = SPDK_SPC_VPD_ASSOCIATION_TARGET_DEVICE; 275 desig->reserved0 = 0; 276 desig->piv = 1; 277 desig->reserved1 = 0; 278 desig->len = bdev_scsi_pad_scsi_name(desig->desig, dev->name); 279 len += sizeof(struct spdk_scsi_desig_desc) + desig->len; 280 281 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len; 282 283 /* SCSI Port Name designator */ 284 desig = (struct spdk_scsi_desig_desc *)buf; 285 desig->code_set = SPDK_SPC_VPD_CODE_SET_UTF8; 286 desig->protocol_id = protocol_id; 287 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME; 288 desig->association = SPDK_SPC_VPD_ASSOCIATION_TARGET_PORT; 289 desig->reserved0 = 0; 290 desig->piv = 1; 291 desig->reserved1 = 0; 292 desig->len = snprintf(desig->desig, SPDK_SCSI_PORT_MAX_NAME_LENGTH, "%s", port->name); 293 len += sizeof(struct spdk_scsi_desig_desc) + desig->len; 294 295 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len; 296 297 /* Relative Target Port designator */ 298 desig = (struct spdk_scsi_desig_desc *)buf; 299 desig->code_set = SPDK_SPC_VPD_CODE_SET_BINARY; 300 desig->protocol_id = protocol_id; 301 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_RELATIVE_TARGET_PORT; 302 desig->association = SPDK_SPC_VPD_ASSOCIATION_TARGET_PORT; 303 desig->reserved0 = 0; 304 desig->piv = 1; 305 desig->reserved1 = 0; 306 desig->len = 4; 307 memset(desig->desig, 0, 2); /* Reserved */ 308 to_be16(&desig->desig[2], port->index); 309 len += sizeof(struct spdk_scsi_desig_desc) + desig->len; 310 311 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len; 312 313 /* Target port group designator */ 314 desig = (struct spdk_scsi_desig_desc *)buf; 315 desig->code_set = SPDK_SPC_VPD_CODE_SET_BINARY; 316 desig->protocol_id = protocol_id; 317 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_TARGET_PORT_GROUP; 318 desig->association = SPDK_SPC_VPD_ASSOCIATION_TARGET_PORT; 319 desig->reserved0 = 0; 320 desig->piv = 1; 321 desig->reserved1 = 0; 322 desig->len = 4; 323 memset(desig->desig, 0, 4); 324 len += sizeof(struct spdk_scsi_desig_desc) + desig->len; 325 326 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len; 327 328 /* Logical unit group designator */ 329 desig = (struct spdk_scsi_desig_desc *)buf; 330 desig->code_set = SPDK_SPC_VPD_CODE_SET_BINARY; 331 desig->protocol_id = protocol_id; 332 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_LOGICAL_UNIT_GROUP; 333 desig->association = SPDK_SPC_VPD_ASSOCIATION_LOGICAL_UNIT; 334 desig->reserved0 = 0; 335 desig->piv = 1; 336 desig->reserved1 = 0; 337 desig->len = 4; 338 memset(desig->desig, 0, 2); /* Reserved */ 339 to_be16(&desig->desig[2], dev->id); 340 len += sizeof(struct spdk_scsi_desig_desc) + desig->len; 341 342 to_be16(vpage->alloc_len, len); 343 344 break; 345 } 346 347 case SPDK_SPC_VPD_EXTENDED_INQUIRY_DATA: { 348 struct spdk_scsi_vpd_ext_inquiry *vext = (struct spdk_scsi_vpd_ext_inquiry *)vpage; 349 350 hlen = 4; 351 memset((uint8_t *)vext + hlen, 0, sizeof(*vext) - hlen); 352 353 /* RTO(3) GRD_CHK(2) APP_CHK(1) REF_CHK(0) */ 354 355 /* GROUP_SUP(4) PRIOR_SUP(3) HEADSUP(2) ORDSUP(1) SIMPSUP(0) */ 356 vext->sup = SPDK_SCSI_VEXT_HEADSUP | SPDK_SCSI_VEXT_SIMPSUP; 357 358 /* NV_SUP(1) V_SUP(0) */ 359 360 /* Reserved[7-63] */ 361 362 len = 64 - hlen; 363 364 /* PAGE LENGTH */ 365 to_be16(vpage->alloc_len, len); 366 break; 367 } 368 369 case SPDK_SPC_VPD_MANAGEMENT_NETWORK_ADDRESSES: 370 /* PAGE LENGTH */ 371 hlen = 4; 372 373 to_be16(vpage->alloc_len, len); 374 break; 375 376 case SPDK_SPC_VPD_MODE_PAGE_POLICY: { 377 struct spdk_scsi_mpage_policy_desc *pdesc = 378 (struct spdk_scsi_mpage_policy_desc *)vpage->params; 379 380 hlen = 4; 381 382 /* Mode page policy descriptor 1 */ 383 384 /* POLICY PAGE CODE(5-0) */ 385 /* all page code */ 386 pdesc->page_code = 0x3f; 387 388 /* POLICY SUBPAGE CODE */ 389 /* all sub page */ 390 pdesc->sub_page_code = 0xff; 391 392 /* MLUS(7) MODE PAGE POLICY(1-0) */ 393 /* MLUS own copy */ 394 /* Shared MODE PAGE policy */ 395 pdesc->policy = 0; 396 /* Reserved */ 397 pdesc->reserved = 0; 398 399 len += 4; 400 401 to_be16(vpage->alloc_len, len); 402 break; 403 } 404 405 case SPDK_SPC_VPD_SCSI_PORTS: { 406 /* PAGE LENGTH */ 407 hlen = 4; 408 409 /* Identification descriptor list */ 410 for (i = 0; i < SPDK_SCSI_DEV_MAX_PORTS; i++) { 411 struct spdk_scsi_port_desc *sdesc; 412 struct spdk_scsi_tgt_port_desc *pdesc; 413 414 if (!dev->port[i].is_used) { 415 continue; 416 } 417 418 /* Identification descriptor N */ 419 sdesc = (struct spdk_scsi_port_desc *)&vpage->params[len]; 420 421 /* Reserved */ 422 sdesc->reserved = 0; 423 424 /* RELATIVE PORT IDENTIFIER */ 425 to_be16(&sdesc->rel_port_id, dev->port[i].index); 426 427 /* Reserved */ 428 sdesc->reserved2 = 0; 429 430 /* INITIATOR PORT TRANSPORTID LENGTH */ 431 sdesc->init_port_len = 0; 432 433 /* Reserved */ 434 sdesc->init_port_id = 0; 435 436 /* TARGET PORT DESCRIPTORS LENGTH */ 437 sdesc->tgt_desc_len = 0; 438 439 len += 12; 440 441 plen2 = 0; 442 /* Target port descriptor 1 */ 443 pdesc = (struct spdk_scsi_tgt_port_desc *)sdesc->tgt_desc; 444 445 /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */ 446 pdesc->code_set = 447 SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI << 4 | 448 SPDK_SPC_VPD_CODE_SET_UTF8; 449 450 /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */ 451 pdesc->desig_type = SPDK_SPC_VPD_DESIG_PIV | 452 SPDK_SPC_VPD_ASSOCIATION_TARGET_PORT << 4 | 453 SPDK_SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME; 454 455 /* Reserved */ 456 pdesc->reserved = 0; 457 458 /* IDENTIFIER */ 459 plen = snprintf((char *)pdesc->designator, 460 SPDK_SCSI_PORT_MAX_NAME_LENGTH, "%s", 461 dev->port[i].name); 462 pdesc->len = plen; 463 464 plen2 += 4 + plen; 465 466 /* TARGET PORT DESCRIPTORS LENGTH */ 467 to_be16(&sdesc->tgt_desc_len, plen2); 468 469 len += plen2; 470 } 471 472 to_be16(vpage->alloc_len, len); 473 break; 474 } 475 476 case SPDK_SPC_VPD_BLOCK_LIMITS: { 477 uint32_t block_size = spdk_bdev_get_data_block_size(bdev); 478 479 /* PAGE LENGTH */ 480 memset(&data[4], 0, 60); 481 482 hlen = 4; 483 484 /* WSNZ(0) */ 485 /* support zero length in WRITE SAME */ 486 487 /* MAXIMUM COMPARE AND WRITE LENGTH */ 488 blocks = SPDK_WORK_ATS_BLOCK_SIZE / block_size; 489 490 if (blocks > 0xff) { 491 blocks = 0xff; 492 } 493 494 data[5] = (uint8_t)blocks; 495 496 /* force align to 4KB */ 497 if (block_size < 4096) { 498 optimal_blocks = 4096 / block_size; 499 } else { 500 optimal_blocks = 1; 501 } 502 503 /* OPTIMAL TRANSFER LENGTH GRANULARITY */ 504 to_be16(&data[6], optimal_blocks); 505 506 blocks = SPDK_WORK_BLOCK_SIZE / block_size; 507 508 /* MAXIMUM TRANSFER LENGTH */ 509 to_be32(&data[8], blocks); 510 /* OPTIMAL TRANSFER LENGTH */ 511 to_be32(&data[12], blocks); 512 513 /* MAXIMUM PREFETCH XDREAD XDWRITE TRANSFER LENGTH */ 514 515 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 516 /* 517 * MAXIMUM UNMAP LBA COUNT: indicates the 518 * maximum number of LBAs that may be 519 * unmapped by an UNMAP command. 520 */ 521 /* For now, choose 4MB as the maximum. */ 522 to_be32(&data[20], 4194304); 523 524 /* 525 * MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT: 526 * indicates the maximum number of UNMAP 527 * block descriptors that shall be contained 528 * in the parameter data transferred to the 529 * device server for an UNMAP command. 530 * The bdev layer automatically splits unmap 531 * requests, so pick an arbitrary high number here. 532 */ 533 to_be32(&data[24], DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT); 534 535 /* 536 * The UGAVALID bit is left as 0 which means neither the 537 * OPTIMAL UNMAP GRANULARITY nor the UNMAP GRANULARITY 538 * ALIGNMENT fields are valid. 539 */ 540 } 541 542 /* 543 * MAXIMUM WRITE SAME LENGTH: indicates the 544 * maximum number of contiguous logical blocks 545 * that the device server allows to be unmapped 546 * or written in a single WRITE SAME command. 547 */ 548 to_be64(&data[36], blocks); 549 550 /* Reserved */ 551 /* not specified */ 552 len = 64 - hlen; 553 554 to_be16(vpage->alloc_len, len); 555 break; 556 } 557 558 case SPDK_SPC_VPD_BLOCK_DEV_CHARS: { 559 /* PAGE LENGTH */ 560 hlen = 4; 561 len = 64 - hlen; 562 563 to_be16(&data[4], DEFAULT_DISK_ROTATION_RATE); 564 565 /* Reserved */ 566 data[6] = 0; 567 /* NOMINAL FORM FACTOR(3-0) */ 568 data[7] = DEFAULT_DISK_FORM_FACTOR << 4; 569 /* Reserved */ 570 memset(&data[8], 0, 64 - 8); 571 572 to_be16(vpage->alloc_len, len); 573 break; 574 } 575 576 case SPDK_SPC_VPD_BLOCK_THIN_PROVISION: { 577 if (!spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 578 goto inq_error; 579 } 580 581 hlen = 4; 582 len = 7; 583 584 /* 585 * PAGE LENGTH : if the DP bit is set to one, then the 586 * page length shall be set 0004h. 587 */ 588 to_be16(&data[2], 0x0004); 589 590 /* 591 * THRESHOLD EXPONENT : it indicates the threshold set 592 * size in LBAs as a power of 2( i.e., the threshold 593 * set size = 2 ^ (threshold exponent). 594 */ 595 data[4] = 0; 596 597 /* 598 * Set the LBPU bit to indicate the support for UNMAP 599 * command. 600 */ 601 data[5] |= SPDK_SCSI_UNMAP_LBPU; 602 603 /* 604 * Set the provisioning type to thin provision. 605 */ 606 data[6] = SPDK_SCSI_UNMAP_THIN_PROVISIONING; 607 608 to_be16(vpage->alloc_len, len); 609 break; 610 } 611 612 default: 613 if (pc >= 0xc0 && pc <= 0xff) { 614 SPDK_DEBUGLOG(scsi, "Vendor specific INQUIRY VPD page 0x%x\n", pc); 615 } else { 616 SPDK_NOTICELOG("unsupported INQUIRY VPD page 0x%x\n", pc); 617 } 618 goto inq_error; 619 } 620 } else { 621 struct spdk_scsi_cdb_inquiry_data *inqdata = 622 (struct spdk_scsi_cdb_inquiry_data *)data; 623 624 /* Standard INQUIRY data */ 625 /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */ 626 inqdata->peripheral_device_type = pd; 627 inqdata->peripheral_qualifier = SPDK_SPC_PERIPHERAL_QUALIFIER_CONNECTED; 628 629 /* RMB(7) */ 630 inqdata->rmb = 0; 631 632 /* VERSION */ 633 /* See SPC3/SBC2/MMC4/SAM2 for more details */ 634 inqdata->version = SPDK_SPC_VERSION_SPC3; 635 636 /* NORMACA(5) HISUP(4) RESPONSE DATA FORMAT(3-0) */ 637 /* format 2 */ /* hierarchical support */ 638 inqdata->response = 2 | 1 << 4; 639 640 hlen = 5; 641 642 /* SCCS(7) ACC(6) TPGS(5-4) 3PC(3) PROTECT(0) */ 643 /* Not support TPGS */ 644 inqdata->flags = 0; 645 646 /* MULTIP */ 647 inqdata->flags2 = 0x10; 648 649 /* WBUS16(5) SYNC(4) LINKED(3) CMDQUE(1) VS(0) */ 650 /* CMDQUE */ 651 inqdata->flags3 = 0x2; 652 653 /* T10 VENDOR IDENTIFICATION */ 654 spdk_strcpy_pad(inqdata->t10_vendor_id, DEFAULT_DISK_VENDOR, 8, ' '); 655 656 /* PRODUCT IDENTIFICATION */ 657 spdk_strcpy_pad(inqdata->product_id, spdk_bdev_get_product_name(bdev), 16, ' '); 658 659 /* PRODUCT REVISION LEVEL */ 660 spdk_strcpy_pad(inqdata->product_rev, DEFAULT_DISK_REVISION, 4, ' '); 661 662 /* 663 * Standard inquiry data ends here. Only populate remaining fields if alloc_len 664 * indicates enough space to hold it. 665 */ 666 len = INQUIRY_OFFSET(product_rev) - 5; 667 668 if (alloc_len >= INQUIRY_OFFSET(vendor)) { 669 /* Vendor specific */ 670 memset(inqdata->vendor, 0x20, 20); 671 len += sizeof(inqdata->vendor); 672 } 673 674 if (alloc_len >= INQUIRY_OFFSET(ius)) { 675 /* CLOCKING(3-2) QAS(1) IUS(0) */ 676 inqdata->ius = 0; 677 len += sizeof(inqdata->ius); 678 } 679 680 if (alloc_len >= INQUIRY_OFFSET(reserved)) { 681 /* Reserved */ 682 inqdata->reserved = 0; 683 len += sizeof(inqdata->reserved); 684 } 685 686 /* VERSION DESCRIPTOR 1-8 */ 687 if (alloc_len >= INQUIRY_OFFSET(reserved) + 2) { 688 to_be16(&inqdata->desc[0], 0x0960); 689 len += 2; 690 } 691 692 if (alloc_len >= INQUIRY_OFFSET(reserved) + 4) { 693 to_be16(&inqdata->desc[2], 0x0300); /* SPC-3 (no version claimed) */ 694 len += 2; 695 } 696 697 if (alloc_len >= INQUIRY_OFFSET(reserved) + 6) { 698 to_be16(&inqdata->desc[4], 0x320); /* SBC-2 (no version claimed) */ 699 len += 2; 700 } 701 702 if (alloc_len >= INQUIRY_OFFSET(reserved) + 8) { 703 to_be16(&inqdata->desc[6], 0x0040); /* SAM-2 (no version claimed) */ 704 len += 2; 705 } 706 707 /* 708 * We only fill out 4 descriptors, but if the allocation length goes past 709 * that, zero the remaining bytes. This fixes some SCSI compliance tests 710 * which expect a full 96 bytes to be returned, including the unpopulated 711 * version descriptors 5-8 (4 * 2 = 8 bytes) plus the 22 bytes of reserved 712 * space (bytes 74-95) - for a total of 30 bytes. 713 */ 714 if (alloc_len > INQUIRY_OFFSET(reserved) + 8) { 715 i = alloc_len - (INQUIRY_OFFSET(reserved) + 8); 716 if (i > 30) { 717 i = 30; 718 } 719 memset(&inqdata->desc[8], 0, i); 720 len += i; 721 } 722 723 /* ADDITIONAL LENGTH */ 724 inqdata->add_len = len; 725 } 726 727 return hlen + len; 728 729 inq_error: 730 task->data_transferred = 0; 731 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 732 SPDK_SCSI_SENSE_NO_SENSE, 733 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 734 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 735 return -1; 736 } 737 738 static void 739 mode_sense_page_init(uint8_t *buf, int len, int page, int subpage) 740 { 741 if (!buf) { 742 return; 743 } 744 745 memset(buf, 0, len); 746 if (subpage != 0) { 747 buf[0] = page | 0x40; /* PAGE + SPF=1 */ 748 buf[1] = subpage; 749 to_be16(&buf[2], len - 4); 750 } else { 751 buf[0] = page; 752 buf[1] = len - 2; 753 } 754 } 755 756 static int 757 bdev_scsi_mode_sense_page(struct spdk_bdev *bdev, 758 uint8_t *cdb, int pc, int page, int subpage, 759 uint8_t *data, struct spdk_scsi_task *task) 760 { 761 uint8_t *cp = data; 762 int len = 0; 763 int plen; 764 int i; 765 766 if (pc == 0x00) { 767 /* Current values */ 768 } else if (pc == 0x01) { 769 /* Changeable values */ 770 /* As we currently do not support changeable values, 771 all parameters are reported as zero. */ 772 } else if (pc == 0x02) { 773 /* Default values */ 774 } else { 775 /* Saved values not supported */ 776 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 777 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 778 SPDK_SCSI_ASC_SAVING_PARAMETERS_NOT_SUPPORTED, 779 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 780 return -1; 781 } 782 783 switch (page) { 784 case 0x00: 785 /* Vendor specific */ 786 break; 787 case 0x01: 788 /* Read-Write Error Recovery */ 789 SPDK_DEBUGLOG(scsi, 790 "MODE_SENSE Read-Write Error Recovery\n"); 791 if (subpage != 0x00) { 792 break; 793 } 794 plen = 0x0a + 2; 795 mode_sense_page_init(cp, plen, page, subpage); 796 len += plen; 797 break; 798 case 0x02: 799 /* Disconnect-Reconnect */ 800 SPDK_DEBUGLOG(scsi, 801 "MODE_SENSE Disconnect-Reconnect\n"); 802 if (subpage != 0x00) { 803 break; 804 } 805 plen = 0x0e + 2; 806 mode_sense_page_init(cp, plen, page, subpage); 807 len += plen; 808 break; 809 case 0x03: 810 /* Obsolete (Format Device) */ 811 break; 812 case 0x04: 813 /* Obsolete (Rigid Disk Geometry) */ 814 break; 815 case 0x05: 816 /* Obsolete (Rigid Disk Geometry) */ 817 break; 818 case 0x06: 819 /* Reserved */ 820 break; 821 case 0x07: 822 /* Verify Error Recovery */ 823 SPDK_DEBUGLOG(scsi, 824 "MODE_SENSE Verify Error Recovery\n"); 825 826 if (subpage != 0x00) { 827 break; 828 } 829 830 plen = 0x0a + 2; 831 mode_sense_page_init(cp, plen, page, subpage); 832 len += plen; 833 break; 834 case 0x08: { 835 /* Caching */ 836 SPDK_DEBUGLOG(scsi, "MODE_SENSE Caching\n"); 837 if (subpage != 0x00) { 838 break; 839 } 840 841 plen = 0x12 + 2; 842 mode_sense_page_init(cp, plen, page, subpage); 843 844 if (cp && spdk_bdev_has_write_cache(bdev) && pc != 0x01) { 845 cp[2] |= 0x4; /* WCE */ 846 } 847 848 /* Read Cache Disable (RCD) = 1 */ 849 if (cp && pc != 0x01) { 850 cp[2] |= 0x1; 851 } 852 853 len += plen; 854 break; 855 } 856 case 0x09: 857 /* Obsolete */ 858 break; 859 case 0x0a: 860 switch (subpage) { 861 case 0x00: 862 /* Control */ 863 SPDK_DEBUGLOG(scsi, 864 "MODE_SENSE Control\n"); 865 plen = 0x0a + 2; 866 mode_sense_page_init(cp, plen, page, subpage); 867 len += plen; 868 break; 869 case 0x01: 870 /* Control Extension */ 871 SPDK_DEBUGLOG(scsi, 872 "MODE_SENSE Control Extension\n"); 873 plen = 0x1c + 4; 874 mode_sense_page_init(cp, plen, page, subpage); 875 len += plen; 876 break; 877 case 0xff: 878 /* All subpages */ 879 len += bdev_scsi_mode_sense_page(bdev, 880 cdb, pc, page, 881 0x00, 882 cp ? &cp[len] : NULL, task); 883 len += bdev_scsi_mode_sense_page(bdev, 884 cdb, pc, page, 885 0x01, 886 cp ? &cp[len] : NULL, task); 887 break; 888 default: 889 /* 0x02-0x3e: Reserved */ 890 break; 891 } 892 break; 893 case 0x0b: 894 /* Obsolete (Medium Types Supported) */ 895 break; 896 case 0x0c: 897 /* Obsolete (Notch And Partition) */ 898 break; 899 case 0x0d: 900 /* Obsolete */ 901 break; 902 case 0x0e: 903 case 0x0f: 904 /* Reserved */ 905 break; 906 case 0x10: 907 /* XOR Control */ 908 SPDK_DEBUGLOG(scsi, "MODE_SENSE XOR Control\n"); 909 if (subpage != 0x00) { 910 break; 911 } 912 plen = 0x16 + 2; 913 mode_sense_page_init(cp, plen, page, subpage); 914 len += plen; 915 break; 916 case 0x11: 917 case 0x12: 918 case 0x13: 919 /* Reserved */ 920 break; 921 case 0x14: 922 /* Enclosure Services Management */ 923 break; 924 case 0x15: 925 case 0x16: 926 case 0x17: 927 /* Reserved */ 928 break; 929 case 0x18: 930 /* Protocol-Specific LUN */ 931 break; 932 case 0x19: 933 /* Protocol-Specific Port */ 934 break; 935 case 0x1a: 936 /* Power Condition */ 937 SPDK_DEBUGLOG(scsi, 938 "MODE_SENSE Power Condition\n"); 939 if (subpage != 0x00) { 940 break; 941 } 942 plen = 0x0a + 2; 943 mode_sense_page_init(cp, plen, page, subpage); 944 len += plen; 945 break; 946 case 0x1b: 947 /* Reserved */ 948 break; 949 case 0x1c: 950 /* Informational Exceptions Control */ 951 SPDK_DEBUGLOG(scsi, 952 "MODE_SENSE Informational Exceptions Control\n"); 953 if (subpage != 0x00) { 954 break; 955 } 956 957 plen = 0x0a + 2; 958 mode_sense_page_init(cp, plen, page, subpage); 959 len += plen; 960 break; 961 case 0x1d: 962 case 0x1e: 963 case 0x1f: 964 /* Reserved */ 965 break; 966 case 0x20: 967 case 0x21: 968 case 0x22: 969 case 0x23: 970 case 0x24: 971 case 0x25: 972 case 0x26: 973 case 0x27: 974 case 0x28: 975 case 0x29: 976 case 0x2a: 977 case 0x2b: 978 case 0x2c: 979 case 0x2d: 980 case 0x2e: 981 case 0x2f: 982 case 0x30: 983 case 0x31: 984 case 0x32: 985 case 0x33: 986 case 0x34: 987 case 0x35: 988 case 0x36: 989 case 0x37: 990 case 0x38: 991 case 0x39: 992 case 0x3a: 993 case 0x3b: 994 case 0x3c: 995 case 0x3d: 996 case 0x3e: 997 /* Vendor-specific */ 998 break; 999 case 0x3f: 1000 switch (subpage) { 1001 case 0x00: 1002 /* All mode pages */ 1003 for (i = 0x00; i < 0x3e; i ++) { 1004 len += bdev_scsi_mode_sense_page( 1005 bdev, cdb, pc, i, 0x00, 1006 cp ? &cp[len] : NULL, task); 1007 } 1008 break; 1009 case 0xff: 1010 /* All mode pages and subpages */ 1011 for (i = 0x00; i < 0x3e; i ++) { 1012 len += bdev_scsi_mode_sense_page( 1013 bdev, cdb, pc, i, 0x00, 1014 cp ? &cp[len] : NULL, task); 1015 } 1016 for (i = 0x00; i < 0x3e; i ++) { 1017 len += bdev_scsi_mode_sense_page( 1018 bdev, cdb, pc, i, 0xff, 1019 cp ? &cp[len] : NULL, task); 1020 } 1021 break; 1022 default: 1023 /* 0x01-0x3e: Reserved */ 1024 break; 1025 } 1026 } 1027 1028 return len; 1029 } 1030 1031 static int 1032 bdev_scsi_mode_sense(struct spdk_bdev *bdev, int md, 1033 uint8_t *cdb, int dbd, int llbaa, int pc, 1034 int page, int subpage, uint8_t *data, struct spdk_scsi_task *task) 1035 { 1036 uint64_t num_blocks = spdk_bdev_get_num_blocks(bdev); 1037 uint32_t block_size = spdk_bdev_get_data_block_size(bdev); 1038 uint8_t *hdr, *bdesc, *pages; 1039 int hlen; 1040 int blen; 1041 int plen, total; 1042 1043 assert(md == 6 || md == 10); 1044 1045 if (md == 6) { 1046 hlen = 4; 1047 blen = 8; /* For MODE SENSE 6 only short LBA */ 1048 } else { 1049 hlen = 8; 1050 blen = llbaa ? 16 : 8; 1051 } 1052 1053 if (dbd) { 1054 blen = 0; 1055 } 1056 1057 pages = data ? &data[hlen + blen] : NULL; 1058 plen = bdev_scsi_mode_sense_page(bdev, cdb, pc, page, 1059 subpage, 1060 pages, task); 1061 if (plen < 0) { 1062 return -1; 1063 } 1064 1065 total = hlen + blen + plen; 1066 if (data == NULL) { 1067 return total; 1068 } 1069 1070 hdr = &data[0]; 1071 if (hlen == 4) { 1072 hdr[0] = total - 1; /* Mode Data Length */ 1073 hdr[1] = 0; /* Medium Type */ 1074 hdr[2] = 0; /* Device-Specific Parameter */ 1075 hdr[3] = blen; /* Block Descriptor Length */ 1076 } else { 1077 to_be16(&hdr[0], total - 2); /* Mode Data Length */ 1078 hdr[2] = 0; /* Medium Type */ 1079 hdr[3] = 0; /* Device-Specific Parameter */ 1080 hdr[4] = llbaa ? 0x1 : 0; /* Long/short LBA */ 1081 hdr[5] = 0; /* Reserved */ 1082 to_be16(&hdr[6], blen); /* Block Descriptor Length */ 1083 } 1084 1085 bdesc = &data[hlen]; 1086 if (blen == 16) { 1087 /* Number of Blocks */ 1088 to_be64(&bdesc[0], num_blocks); 1089 /* Reserved */ 1090 memset(&bdesc[8], 0, 4); 1091 /* Block Length */ 1092 to_be32(&bdesc[12], block_size); 1093 } else if (blen == 8) { 1094 /* Number of Blocks */ 1095 if (num_blocks > 0xffffffffULL) { 1096 memset(&bdesc[0], 0xff, 4); 1097 } else { 1098 to_be32(&bdesc[0], num_blocks); 1099 } 1100 1101 /* Block Length */ 1102 to_be32(&bdesc[4], block_size); 1103 } 1104 1105 return total; 1106 } 1107 1108 static void 1109 bdev_scsi_task_complete_cmd(struct spdk_bdev_io *bdev_io, bool success, 1110 void *cb_arg) 1111 { 1112 struct spdk_scsi_task *task = cb_arg; 1113 int sc, sk, asc, ascq; 1114 1115 spdk_bdev_io_get_scsi_status(bdev_io, &sc, &sk, &asc, &ascq); 1116 1117 spdk_bdev_free_io(bdev_io); 1118 1119 spdk_scsi_task_set_status(task, sc, sk, asc, ascq); 1120 scsi_lun_complete_task(task->lun, task); 1121 } 1122 1123 static void 1124 bdev_scsi_read_task_complete_cmd(struct spdk_bdev_io *bdev_io, bool success, 1125 void *cb_arg) 1126 { 1127 struct spdk_scsi_task *task = cb_arg; 1128 int sc, sk, asc, ascq; 1129 1130 task->bdev_io = bdev_io; 1131 1132 spdk_bdev_io_get_scsi_status(bdev_io, &sc, &sk, &asc, &ascq); 1133 1134 spdk_scsi_task_set_status(task, sc, sk, asc, ascq); 1135 scsi_lun_complete_task(task->lun, task); 1136 } 1137 1138 static void 1139 bdev_scsi_task_complete_reset(struct spdk_bdev_io *bdev_io, bool success, 1140 void *cb_arg) 1141 { 1142 struct spdk_scsi_task *task = cb_arg; 1143 1144 spdk_bdev_free_io(bdev_io); 1145 1146 if (success) { 1147 task->response = SPDK_SCSI_TASK_MGMT_RESP_SUCCESS; 1148 } 1149 1150 scsi_lun_complete_reset_task(task->lun, task); 1151 } 1152 1153 static void 1154 bdev_scsi_queue_io(struct spdk_scsi_task *task, spdk_bdev_io_wait_cb cb_fn, void *cb_arg) 1155 { 1156 struct spdk_scsi_lun *lun = task->lun; 1157 struct spdk_bdev *bdev = lun->bdev; 1158 struct spdk_io_channel *ch = lun->io_channel; 1159 int rc; 1160 1161 task->bdev_io_wait.bdev = bdev; 1162 task->bdev_io_wait.cb_fn = cb_fn; 1163 task->bdev_io_wait.cb_arg = cb_arg; 1164 1165 rc = spdk_bdev_queue_io_wait(bdev, ch, &task->bdev_io_wait); 1166 if (rc != 0) { 1167 assert(false); 1168 } 1169 } 1170 1171 static int 1172 bdev_scsi_sync(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1173 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, 1174 uint64_t lba, uint32_t num_blocks) 1175 { 1176 uint64_t bdev_num_blocks; 1177 int rc; 1178 1179 if (num_blocks == 0) { 1180 return SPDK_SCSI_TASK_COMPLETE; 1181 } 1182 1183 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev); 1184 1185 if (lba >= bdev_num_blocks || num_blocks > bdev_num_blocks || 1186 lba > (bdev_num_blocks - num_blocks)) { 1187 SPDK_ERRLOG("end of media\n"); 1188 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1189 SPDK_SCSI_SENSE_NO_SENSE, 1190 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1191 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1192 return SPDK_SCSI_TASK_COMPLETE; 1193 } 1194 1195 rc = spdk_bdev_flush_blocks(bdev_desc, bdev_ch, lba, num_blocks, 1196 bdev_scsi_task_complete_cmd, task); 1197 1198 if (rc) { 1199 if (rc == -ENOMEM) { 1200 bdev_scsi_queue_io(task, bdev_scsi_process_block_resubmit, task); 1201 return SPDK_SCSI_TASK_PENDING; 1202 } 1203 SPDK_ERRLOG("spdk_bdev_flush_blocks() failed\n"); 1204 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1205 SPDK_SCSI_SENSE_NO_SENSE, 1206 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1207 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1208 return SPDK_SCSI_TASK_COMPLETE; 1209 } 1210 task->data_transferred = 0; 1211 return SPDK_SCSI_TASK_PENDING; 1212 } 1213 1214 static uint64_t 1215 _bytes_to_blocks(uint32_t block_size, uint64_t offset_bytes, uint64_t *offset_blocks, 1216 uint64_t num_bytes, uint64_t *num_blocks) 1217 { 1218 uint8_t shift_cnt; 1219 1220 /* Avoid expensive div operations if possible. These spdk_u32 functions are very cheap. */ 1221 if (spdk_likely(spdk_u32_is_pow2(block_size))) { 1222 shift_cnt = spdk_u32log2(block_size); 1223 *offset_blocks = offset_bytes >> shift_cnt; 1224 *num_blocks = num_bytes >> shift_cnt; 1225 return (offset_bytes - (*offset_blocks << shift_cnt)) | 1226 (num_bytes - (*num_blocks << shift_cnt)); 1227 } else { 1228 *offset_blocks = offset_bytes / block_size; 1229 *num_blocks = num_bytes / block_size; 1230 return (offset_bytes % block_size) | (num_bytes % block_size); 1231 } 1232 } 1233 1234 static int 1235 bdev_scsi_readwrite(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1236 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, 1237 uint64_t lba, uint32_t xfer_len, bool is_read, bool is_compare) 1238 { 1239 uint64_t bdev_num_blocks, offset_blocks, num_blocks; 1240 uint32_t max_xfer_len, block_size; 1241 int sk = SPDK_SCSI_SENSE_NO_SENSE, asc = SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE; 1242 int rc; 1243 1244 task->data_transferred = 0; 1245 1246 if (spdk_unlikely(task->dxfer_dir != SPDK_SCSI_DIR_NONE && 1247 task->dxfer_dir != (is_read ? SPDK_SCSI_DIR_FROM_DEV : SPDK_SCSI_DIR_TO_DEV))) { 1248 SPDK_ERRLOG("Incorrect data direction\n"); 1249 goto check_condition; 1250 } 1251 1252 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev); 1253 if (spdk_unlikely(bdev_num_blocks <= lba || bdev_num_blocks - lba < xfer_len)) { 1254 SPDK_DEBUGLOG(scsi, "end of media\n"); 1255 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST; 1256 asc = SPDK_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE; 1257 goto check_condition; 1258 } 1259 1260 if (spdk_unlikely(xfer_len == 0)) { 1261 task->status = SPDK_SCSI_STATUS_GOOD; 1262 return SPDK_SCSI_TASK_COMPLETE; 1263 } 1264 1265 block_size = spdk_bdev_get_data_block_size(bdev); 1266 1267 /* Transfer Length is limited to the Block Limits VPD page Maximum Transfer Length */ 1268 max_xfer_len = SPDK_WORK_BLOCK_SIZE / block_size; 1269 if (spdk_unlikely(xfer_len > max_xfer_len)) { 1270 SPDK_ERRLOG("xfer_len %" PRIu32 " > maximum transfer length %" PRIu32 "\n", 1271 xfer_len, max_xfer_len); 1272 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST; 1273 asc = SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB; 1274 goto check_condition; 1275 } 1276 1277 if (!is_read) { 1278 /* Additional check for Transfer Length */ 1279 if (xfer_len * block_size > task->transfer_len) { 1280 SPDK_ERRLOG("xfer_len %" PRIu32 " * block_size %" PRIu32 " > transfer_len %u\n", 1281 xfer_len, block_size, task->transfer_len); 1282 goto check_condition; 1283 } 1284 } 1285 1286 if (_bytes_to_blocks(block_size, task->offset, &offset_blocks, task->length, &num_blocks) != 0) { 1287 SPDK_ERRLOG("task's offset %" PRIu64 " or length %" PRIu32 " is not block multiple\n", 1288 task->offset, task->length); 1289 goto check_condition; 1290 } 1291 1292 offset_blocks += lba; 1293 1294 SPDK_DEBUGLOG(scsi, 1295 "%s: lba=%"PRIu64", len=%"PRIu64"\n", 1296 is_read ? "Read" : "Write", offset_blocks, num_blocks); 1297 1298 if (is_read) { 1299 rc = spdk_bdev_readv_blocks(bdev_desc, bdev_ch, task->iovs, task->iovcnt, 1300 offset_blocks, num_blocks, 1301 bdev_scsi_read_task_complete_cmd, task); 1302 } else if (is_compare) { 1303 struct iovec *iov; 1304 size_t len; 1305 1306 if (task->iovcnt != 1 || task->iovs[0].iov_len != (block_size * 2)) { 1307 if (task->iovcnt != 1) { 1308 SPDK_ERRLOG("task's iovcnt %" PRIu32 " is not 1.\n", task->iovcnt); 1309 } else { 1310 SPDK_ERRLOG("task's iov len %" PRIu64 " is not 2 * BLOCK_SIZE.\n", 1311 task->iovs[0].iov_len); 1312 } 1313 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST; 1314 asc = SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB; 1315 goto check_condition; 1316 } 1317 1318 iov = &task->iovs[0]; 1319 len = iov->iov_len >> 1; 1320 task->caw_iov.iov_len = len; 1321 task->caw_iov.iov_base = (uint8_t *)(iov->iov_base) + len; 1322 iov->iov_len = len; 1323 1324 rc = spdk_bdev_comparev_and_writev_blocks(bdev_desc, bdev_ch, iov, 1, 1325 &task->caw_iov, 1, offset_blocks, 1, bdev_scsi_task_complete_cmd, task); 1326 } else { 1327 rc = spdk_bdev_writev_blocks(bdev_desc, bdev_ch, task->iovs, task->iovcnt, 1328 offset_blocks, num_blocks, 1329 bdev_scsi_task_complete_cmd, task); 1330 } 1331 1332 if (rc) { 1333 if (rc == -ENOMEM) { 1334 bdev_scsi_queue_io(task, bdev_scsi_process_block_resubmit, task); 1335 return SPDK_SCSI_TASK_PENDING; 1336 } 1337 SPDK_ERRLOG("spdk_bdev_%s_blocks() failed: %d\n", 1338 is_read ? "readv" : (is_compare ? "comparev_and_writev" : "writev"), rc); 1339 goto check_condition; 1340 } 1341 1342 task->data_transferred = task->length; 1343 return SPDK_SCSI_TASK_PENDING; 1344 1345 check_condition: 1346 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, sk, asc, 1347 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1348 return SPDK_SCSI_TASK_COMPLETE; 1349 } 1350 1351 struct spdk_bdev_scsi_split_ctx { 1352 struct spdk_scsi_task *task; 1353 union { 1354 struct spdk_scsi_unmap_bdesc desc[DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT]; 1355 uint64_t start_offset_blocks; /* used by writesame */ 1356 }; 1357 uint16_t remaining_count; 1358 uint16_t current_count; 1359 uint16_t outstanding_count; 1360 /* Return 0 on successly submitting child IO, 1 on skipping child IO, negative number on failure */ 1361 int (*fn)(struct spdk_bdev_scsi_split_ctx *ctx); 1362 }; 1363 1364 static int bdev_scsi_split(struct spdk_bdev_scsi_split_ctx *ctx); 1365 1366 static void 1367 bdev_scsi_split_resubmit(void *arg) 1368 { 1369 struct spdk_bdev_scsi_split_ctx *ctx = arg; 1370 1371 bdev_scsi_split(ctx); 1372 } 1373 1374 static int 1375 bdev_scsi_split(struct spdk_bdev_scsi_split_ctx *ctx) 1376 { 1377 struct spdk_scsi_task *task = ctx->task; 1378 uint8_t opcode = task->cdb[0]; 1379 int rc; 1380 1381 while (ctx->remaining_count != 0) { 1382 rc = ctx->fn(ctx); 1383 if (rc >= 0) { 1384 ctx->current_count++; 1385 ctx->remaining_count--; 1386 /* 0 on success, 1 on skipping child IO. !rc is good enough */ 1387 ctx->outstanding_count += !rc; 1388 continue; 1389 } else if (rc == -ENOMEM) { 1390 break; 1391 } 1392 1393 SPDK_ERRLOG("SCSI %s failed\n", spdk_scsi_sbc_opcode_string(opcode, 0)); 1394 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1395 SPDK_SCSI_SENSE_NO_SENSE, 1396 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1397 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1398 /* If any child I/O failed, stop further splitting process. */ 1399 ctx->current_count += ctx->remaining_count; 1400 ctx->remaining_count = 0; 1401 break; 1402 } 1403 1404 if (ctx->outstanding_count != 0) { 1405 /* We can't complete here - we may have to wait for previously 1406 * submitted child I/Os to complete */ 1407 return SPDK_SCSI_TASK_PENDING; 1408 } 1409 1410 if (rc == -ENOMEM) { 1411 /* none outstanding child IO submitted, no callback would be involked. 1412 this is the last chance to resubmit on -ENOMEM */ 1413 bdev_scsi_queue_io(task, bdev_scsi_split_resubmit, ctx); 1414 return SPDK_SCSI_TASK_PENDING; 1415 } 1416 1417 free(ctx); 1418 return SPDK_SCSI_TASK_COMPLETE; 1419 } 1420 1421 static void 1422 bdev_scsi_task_complete_split_cmd(struct spdk_bdev_io *bdev_io, bool success, 1423 void *cb_arg) 1424 { 1425 struct spdk_bdev_scsi_split_ctx *ctx = cb_arg; 1426 struct spdk_scsi_task *task = ctx->task; 1427 1428 spdk_bdev_free_io(bdev_io); 1429 1430 if (!success) { 1431 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1432 SPDK_SCSI_SENSE_NO_SENSE, 1433 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1434 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1435 /* If any child I/O failed, stop further splitting process. */ 1436 ctx->current_count += ctx->remaining_count; 1437 ctx->remaining_count = 0; 1438 } 1439 1440 ctx->outstanding_count--; 1441 if (ctx->outstanding_count != 0) { 1442 /* Any child I/O is still outstanding. */ 1443 return; 1444 } 1445 1446 if (ctx->remaining_count == 0) { 1447 /* SCSI task finishes when all descriptors are consumed. */ 1448 scsi_lun_complete_task(task->lun, task); 1449 free(ctx); 1450 return; 1451 } 1452 1453 /* Continue with splitting process. */ 1454 bdev_scsi_split(ctx); 1455 } 1456 1457 static int 1458 __copy_desc(struct spdk_bdev_scsi_split_ctx *ctx, uint8_t *data, size_t data_len) 1459 { 1460 uint16_t desc_data_len; 1461 uint16_t desc_count; 1462 1463 if (!data) { 1464 return -EINVAL; 1465 } 1466 1467 if (data_len < 8) { 1468 /* We can't even get the reported length, so fail. */ 1469 return -EINVAL; 1470 } 1471 1472 desc_data_len = from_be16(&data[2]); 1473 desc_count = desc_data_len / 16; 1474 1475 if (desc_data_len > (data_len - 8)) { 1476 SPDK_ERRLOG("Error - desc_data_len (%u) > data_len (%zu) - 8\n", 1477 desc_data_len, data_len); 1478 return -EINVAL; 1479 } 1480 1481 if (desc_count > DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT) { 1482 SPDK_ERRLOG("desc_count (%u) greater than max allowed (%u)\n", 1483 desc_count, DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT); 1484 return -EINVAL; 1485 } 1486 1487 memcpy(ctx->desc, &data[8], desc_data_len); 1488 return desc_count; 1489 } 1490 1491 static int 1492 _bdev_scsi_unmap(struct spdk_bdev_scsi_split_ctx *ctx) 1493 { 1494 struct spdk_scsi_task *task = ctx->task; 1495 struct spdk_scsi_lun *lun = task->lun; 1496 struct spdk_scsi_unmap_bdesc *desc; 1497 uint64_t offset_blocks; 1498 uint64_t num_blocks; 1499 1500 desc = &ctx->desc[ctx->current_count]; 1501 1502 offset_blocks = from_be64(&desc->lba); 1503 num_blocks = from_be32(&desc->block_count); 1504 1505 if (num_blocks == 0) { 1506 return 1; 1507 } 1508 1509 return spdk_bdev_unmap_blocks(lun->bdev_desc, 1510 lun->io_channel, 1511 offset_blocks, 1512 num_blocks, 1513 bdev_scsi_task_complete_split_cmd, 1514 ctx); 1515 } 1516 1517 static int 1518 bdev_scsi_unmap(struct spdk_bdev *bdev, struct spdk_scsi_task *task) 1519 { 1520 struct spdk_bdev_scsi_split_ctx *ctx; 1521 uint8_t *data; 1522 int desc_count = -1; 1523 int data_len; 1524 1525 assert(task->status == SPDK_SCSI_STATUS_GOOD); 1526 1527 ctx = calloc(1, sizeof(*ctx)); 1528 if (!ctx) { 1529 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1530 SPDK_SCSI_SENSE_NO_SENSE, 1531 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1532 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1533 return SPDK_SCSI_TASK_COMPLETE; 1534 } 1535 1536 ctx->task = task; 1537 ctx->current_count = 0; 1538 ctx->outstanding_count = 0; 1539 ctx->fn = _bdev_scsi_unmap; 1540 1541 if (task->iovcnt == 1) { 1542 data = (uint8_t *)task->iovs[0].iov_base; 1543 data_len = task->iovs[0].iov_len; 1544 desc_count = __copy_desc(ctx, data, data_len); 1545 } else { 1546 data = spdk_scsi_task_gather_data(task, &data_len); 1547 if (data) { 1548 desc_count = __copy_desc(ctx, data, data_len); 1549 free(data); 1550 } 1551 } 1552 1553 if (desc_count > 0) { 1554 ctx->remaining_count = desc_count; 1555 return bdev_scsi_split(ctx); 1556 } 1557 1558 if (desc_count < 0) { 1559 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1560 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1561 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1562 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1563 } 1564 1565 free(ctx); 1566 return SPDK_SCSI_TASK_COMPLETE; 1567 } 1568 1569 static int 1570 _bdev_scsi_write_same(struct spdk_bdev_scsi_split_ctx *ctx) 1571 { 1572 struct spdk_scsi_task *task = ctx->task; 1573 struct spdk_scsi_lun *lun = task->lun; 1574 uint64_t offset_blocks; 1575 1576 offset_blocks = ctx->start_offset_blocks + ctx->current_count; 1577 return spdk_bdev_writev_blocks(lun->bdev_desc, lun->io_channel, task->iovs, task->iovcnt, 1578 offset_blocks, 1, bdev_scsi_task_complete_split_cmd, ctx); 1579 } 1580 1581 static int 1582 bdev_scsi_write_same(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1583 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, 1584 uint64_t lba, uint32_t xfer_len, uint8_t flags) 1585 { 1586 struct spdk_bdev_scsi_split_ctx *ctx; 1587 uint64_t bdev_num_blocks, offset_blocks, num_blocks; 1588 uint32_t max_xfer_len, block_size; 1589 int sk = SPDK_SCSI_SENSE_NO_SENSE, asc = SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE; 1590 1591 task->data_transferred = 0; 1592 1593 if (spdk_unlikely(task->dxfer_dir != SPDK_SCSI_DIR_TO_DEV)) { 1594 SPDK_ERRLOG("Incorrect data direction\n"); 1595 goto check_condition; 1596 } 1597 1598 block_size = spdk_bdev_get_data_block_size(bdev); 1599 if (spdk_unlikely(task->transfer_len != block_size)) { 1600 SPDK_ERRLOG("Incorrect data length(%d), a single logical block(%d) is required\n", 1601 task->transfer_len, block_size); 1602 goto check_condition; 1603 } 1604 1605 if (spdk_unlikely(xfer_len == 0)) { 1606 task->status = SPDK_SCSI_STATUS_GOOD; 1607 return SPDK_SCSI_TASK_COMPLETE; 1608 } 1609 1610 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev); 1611 if (spdk_unlikely(bdev_num_blocks <= lba || bdev_num_blocks - lba < xfer_len)) { 1612 SPDK_DEBUGLOG(scsi, "end of media\n"); 1613 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST; 1614 asc = SPDK_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE; 1615 goto check_condition; 1616 } 1617 1618 /* see MAXIMUM WRITE SAME LENGTH of SPDK_SPC_VPD_BLOCK_LIMITS */ 1619 max_xfer_len = SPDK_WORK_BLOCK_SIZE / block_size; 1620 if (spdk_unlikely(xfer_len > max_xfer_len)) { 1621 SPDK_ERRLOG("xfer_len %"PRIu32 " > maximum transfer length %" PRIu32 "\n", 1622 xfer_len, max_xfer_len); 1623 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST; 1624 asc = SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB; 1625 goto check_condition; 1626 } 1627 1628 if (_bytes_to_blocks(block_size, task->offset, &offset_blocks, task->length * xfer_len, 1629 &num_blocks) != 0) { 1630 SPDK_ERRLOG("task's offset %" PRIu64 " or length %" PRIu32 " is not block multiple\n", 1631 task->offset, task->length); 1632 goto check_condition; 1633 } 1634 1635 offset_blocks += lba; 1636 SPDK_DEBUGLOG(scsi, "Writesame: lba=%"PRIu64", len=%"PRIu64"\n", 1637 offset_blocks, num_blocks); 1638 1639 ctx = calloc(1, sizeof(*ctx)); 1640 if (!ctx) { 1641 SPDK_ERRLOG("No enough memory on SCSI WRITE SAME\n"); 1642 goto check_condition; 1643 } 1644 1645 ctx->task = task; 1646 ctx->start_offset_blocks = offset_blocks; 1647 ctx->current_count = 0; 1648 ctx->outstanding_count = 0; 1649 ctx->remaining_count = xfer_len; 1650 ctx->fn = _bdev_scsi_write_same; 1651 1652 task->data_transferred = task->length; 1653 1654 return bdev_scsi_split(ctx); 1655 1656 check_condition: 1657 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1658 sk, asc, SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1659 return SPDK_SCSI_TASK_COMPLETE; 1660 } 1661 1662 static int 1663 bdev_scsi_process_block(struct spdk_scsi_task *task) 1664 { 1665 struct spdk_scsi_lun *lun = task->lun; 1666 struct spdk_bdev *bdev = lun->bdev; 1667 uint64_t lba; 1668 uint32_t xfer_len; 1669 uint32_t len = 0; 1670 uint8_t *cdb = task->cdb; 1671 1672 /* XXX: We need to support FUA bit for writes! */ 1673 switch (cdb[0]) { 1674 case SPDK_SBC_READ_6: 1675 case SPDK_SBC_WRITE_6: 1676 lba = (uint64_t)cdb[1] << 16; 1677 lba |= (uint64_t)cdb[2] << 8; 1678 lba |= (uint64_t)cdb[3]; 1679 xfer_len = cdb[4]; 1680 if (xfer_len == 0) { 1681 xfer_len = 256; 1682 } 1683 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1684 task, lba, xfer_len, 1685 cdb[0] == SPDK_SBC_READ_6, false); 1686 1687 case SPDK_SBC_READ_10: 1688 case SPDK_SBC_WRITE_10: 1689 lba = from_be32(&cdb[2]); 1690 xfer_len = from_be16(&cdb[7]); 1691 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1692 task, lba, xfer_len, 1693 cdb[0] == SPDK_SBC_READ_10, false); 1694 1695 case SPDK_SBC_READ_12: 1696 case SPDK_SBC_WRITE_12: 1697 lba = from_be32(&cdb[2]); 1698 xfer_len = from_be32(&cdb[6]); 1699 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1700 task, lba, xfer_len, 1701 cdb[0] == SPDK_SBC_READ_12, false); 1702 case SPDK_SBC_READ_16: 1703 case SPDK_SBC_WRITE_16: 1704 lba = from_be64(&cdb[2]); 1705 xfer_len = from_be32(&cdb[10]); 1706 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1707 task, lba, xfer_len, 1708 cdb[0] == SPDK_SBC_READ_16, false); 1709 1710 case SPDK_SBC_COMPARE_AND_WRITE: { 1711 uint32_t num_blocks = cdb[13]; 1712 uint8_t wrprotect = (cdb[1] >> 5) & 0x07; 1713 bool dpo = cdb[1] & 0x10; 1714 bool fua = cdb[1] & 0x08; 1715 1716 lba = from_be64(&cdb[2]); 1717 1718 if (dpo || fua || wrprotect) { 1719 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1720 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1721 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1722 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1723 SPDK_ERRLOG("Invalid Task\n"); 1724 return SPDK_SCSI_TASK_COMPLETE; 1725 } 1726 1727 if (num_blocks != 1) { 1728 SPDK_ERRLOG("Invalid CAW block count, request block count is %u, limit is : 1\n", 1729 num_blocks); 1730 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1731 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1732 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1733 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1734 return SPDK_SCSI_TASK_COMPLETE; 1735 } 1736 1737 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1738 task, lba, num_blocks, false, true); 1739 } 1740 1741 case SPDK_SBC_READ_CAPACITY_10: { 1742 uint64_t num_blocks = spdk_bdev_get_num_blocks(bdev); 1743 uint8_t buffer[8]; 1744 1745 if (num_blocks - 1 > 0xffffffffULL) { 1746 memset(buffer, 0xff, 4); 1747 } else { 1748 to_be32(buffer, num_blocks - 1); 1749 } 1750 to_be32(&buffer[4], spdk_bdev_get_data_block_size(bdev)); 1751 1752 len = spdk_min(task->length, sizeof(buffer)); 1753 if (spdk_scsi_task_scatter_data(task, buffer, len) < 0) { 1754 break; 1755 } 1756 1757 task->data_transferred = len; 1758 task->status = SPDK_SCSI_STATUS_GOOD; 1759 break; 1760 } 1761 1762 case SPDK_SPC_SERVICE_ACTION_IN_16: 1763 switch (cdb[1] & 0x1f) { /* SERVICE ACTION */ 1764 case SPDK_SBC_SAI_READ_CAPACITY_16: { 1765 uint8_t buffer[32] = {0}; 1766 uint32_t lbppb, lbppbe; 1767 1768 to_be64(&buffer[0], spdk_bdev_get_num_blocks(bdev) - 1); 1769 to_be32(&buffer[8], spdk_bdev_get_data_block_size(bdev)); 1770 lbppb = spdk_bdev_get_physical_block_size(bdev) / spdk_bdev_get_data_block_size(bdev); 1771 lbppbe = spdk_u32log2(lbppb); 1772 if (lbppbe > 0xf) { 1773 SPDK_ERRLOG("lbppbe(0x%x) > 0xf\n", lbppbe); 1774 } else { 1775 buffer[13] = lbppbe; 1776 } 1777 /* 1778 * Set the TPE bit to 1 to indicate thin provisioning. 1779 * The position of TPE bit is the 7th bit in 14th byte 1780 * in READ CAPACITY (16) parameter data. 1781 */ 1782 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 1783 buffer[14] |= 1 << 7; 1784 } 1785 1786 len = spdk_min(from_be32(&cdb[10]), sizeof(buffer)); 1787 if (spdk_scsi_task_scatter_data(task, buffer, len) < 0) { 1788 break; 1789 } 1790 1791 task->data_transferred = len; 1792 task->status = SPDK_SCSI_STATUS_GOOD; 1793 break; 1794 } 1795 1796 default: 1797 return SPDK_SCSI_TASK_UNKNOWN; 1798 } 1799 break; 1800 1801 case SPDK_SBC_SYNCHRONIZE_CACHE_10: 1802 case SPDK_SBC_SYNCHRONIZE_CACHE_16: 1803 if (cdb[0] == SPDK_SBC_SYNCHRONIZE_CACHE_10) { 1804 lba = from_be32(&cdb[2]); 1805 len = from_be16(&cdb[7]); 1806 } else { 1807 lba = from_be64(&cdb[2]); 1808 len = from_be32(&cdb[10]); 1809 } 1810 1811 if (len == 0) { 1812 len = spdk_bdev_get_num_blocks(bdev) - lba; 1813 } 1814 1815 return bdev_scsi_sync(bdev, lun->bdev_desc, lun->io_channel, task, lba, len); 1816 break; 1817 1818 case SPDK_SBC_UNMAP: 1819 return bdev_scsi_unmap(bdev, task); 1820 1821 case SPDK_SBC_WRITE_SAME_10: 1822 lba = from_be32(&cdb[2]); 1823 xfer_len = from_be16(&cdb[7]); 1824 return bdev_scsi_write_same(bdev, lun->bdev_desc, lun->io_channel, 1825 task, lba, xfer_len, cdb[1]); 1826 1827 case SPDK_SBC_WRITE_SAME_16: 1828 lba = from_be64(&cdb[2]); 1829 xfer_len = from_be32(&cdb[10]); 1830 return bdev_scsi_write_same(bdev, lun->bdev_desc, lun->io_channel, 1831 task, lba, xfer_len, cdb[1]); 1832 1833 1834 default: 1835 return SPDK_SCSI_TASK_UNKNOWN; 1836 } 1837 1838 return SPDK_SCSI_TASK_COMPLETE; 1839 } 1840 1841 static void 1842 bdev_scsi_process_block_resubmit(void *arg) 1843 { 1844 struct spdk_scsi_task *task = arg; 1845 1846 bdev_scsi_process_block(task); 1847 } 1848 1849 static int 1850 bdev_scsi_check_len(struct spdk_scsi_task *task, int len, int min_len) 1851 { 1852 if (len >= min_len) { 1853 return 0; 1854 } 1855 1856 /* INVALID FIELD IN CDB */ 1857 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1858 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1859 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1860 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1861 return -1; 1862 } 1863 1864 static int 1865 bdev_scsi_process_primary(struct spdk_scsi_task *task) 1866 { 1867 struct spdk_scsi_lun *lun = task->lun; 1868 struct spdk_bdev *bdev = lun->bdev; 1869 int alloc_len = -1; 1870 int data_len = -1; 1871 uint8_t *cdb = task->cdb; 1872 uint8_t *data = NULL; 1873 int rc = 0; 1874 int pllen, md = 0; 1875 int llba; 1876 int dbd, pc, page, subpage; 1877 int cmd_parsed = 0; 1878 1879 switch (cdb[0]) { 1880 case SPDK_SPC_INQUIRY: 1881 alloc_len = from_be16(&cdb[3]); 1882 data_len = spdk_max(4096, alloc_len); 1883 data = calloc(1, data_len); 1884 assert(data != NULL); 1885 rc = bdev_scsi_inquiry(bdev, task, cdb, data, data_len); 1886 data_len = spdk_min(rc, data_len); 1887 if (rc < 0) { 1888 break; 1889 } 1890 1891 SPDK_LOGDUMP(scsi, "INQUIRY", data, data_len); 1892 break; 1893 1894 case SPDK_SPC_REPORT_LUNS: { 1895 int sel; 1896 1897 sel = cdb[2]; 1898 SPDK_DEBUGLOG(scsi, "sel=%x\n", sel); 1899 1900 alloc_len = from_be32(&cdb[6]); 1901 rc = bdev_scsi_check_len(task, alloc_len, 16); 1902 if (rc < 0) { 1903 break; 1904 } 1905 1906 data_len = spdk_max(4096, alloc_len); 1907 data = calloc(1, data_len); 1908 assert(data != NULL); 1909 rc = bdev_scsi_report_luns(task->lun, sel, data, data_len); 1910 data_len = rc; 1911 if (rc < 0) { 1912 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1913 SPDK_SCSI_SENSE_NO_SENSE, 1914 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1915 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1916 break; 1917 } 1918 1919 SPDK_LOGDUMP(scsi, "REPORT LUNS", data, data_len); 1920 break; 1921 } 1922 1923 case SPDK_SPC_MODE_SELECT_6: 1924 case SPDK_SPC_MODE_SELECT_10: 1925 if (cdb[0] == SPDK_SPC_MODE_SELECT_6) { 1926 /* MODE_SELECT(6) must have at least a 4 byte header. */ 1927 md = 4; 1928 pllen = cdb[4]; 1929 } else { 1930 /* MODE_SELECT(10) must have at least an 8 byte header. */ 1931 md = 8; 1932 pllen = from_be16(&cdb[7]); 1933 } 1934 1935 if (pllen == 0) { 1936 break; 1937 } 1938 1939 rc = bdev_scsi_check_len(task, pllen, md); 1940 if (rc < 0) { 1941 break; 1942 } 1943 1944 data = spdk_scsi_task_gather_data(task, &rc); 1945 if (rc < 0) { 1946 break; 1947 } 1948 data_len = rc; 1949 1950 rc = bdev_scsi_check_len(task, data_len, spdk_max(pllen, md)); 1951 if (rc < 0) { 1952 break; 1953 } 1954 1955 rc = pllen; 1956 data_len = 0; 1957 break; 1958 1959 case SPDK_SPC_MODE_SENSE_6: 1960 alloc_len = cdb[4]; 1961 md = 6; 1962 /* FALLTHROUGH */ 1963 case SPDK_SPC_MODE_SENSE_10: 1964 llba = 0; 1965 1966 if (md == 0) { 1967 alloc_len = from_be16(&cdb[7]); 1968 llba = !!(cdb[1] & 0x10); 1969 md = 10; 1970 } 1971 1972 dbd = !!(cdb[1] & 0x8); 1973 pc = (cdb[2] & 0xc0) >> 6; 1974 page = cdb[2] & 0x3f; 1975 subpage = cdb[3]; 1976 1977 /* First call with no buffer to discover needed buffer size */ 1978 rc = bdev_scsi_mode_sense(bdev, md, 1979 cdb, dbd, llba, pc, 1980 page, subpage, 1981 NULL, task); 1982 if (rc < 0) { 1983 break; 1984 } 1985 1986 data_len = rc; 1987 data = calloc(1, data_len); 1988 assert(data != NULL); 1989 1990 /* First call with no buffer to discover needed buffer size */ 1991 rc = bdev_scsi_mode_sense(bdev, md, 1992 cdb, dbd, llba, pc, 1993 page, subpage, 1994 data, task); 1995 if (rc < 0) { 1996 /* INVALID FIELD IN CDB */ 1997 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1998 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1999 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 2000 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 2001 break; 2002 } 2003 break; 2004 2005 case SPDK_SPC_REQUEST_SENSE: { 2006 int desc; 2007 int sk, asc, ascq; 2008 2009 desc = cdb[1] & 0x1; 2010 if (desc != 0) { 2011 /* INVALID FIELD IN CDB */ 2012 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 2013 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 2014 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 2015 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 2016 break; 2017 } 2018 2019 alloc_len = cdb[4]; 2020 2021 /* NO ADDITIONAL SENSE INFORMATION */ 2022 sk = SPDK_SCSI_SENSE_NO_SENSE; 2023 asc = 0x00; 2024 ascq = 0x00; 2025 2026 spdk_scsi_task_build_sense_data(task, sk, asc, ascq); 2027 2028 data_len = task->sense_data_len; 2029 data = calloc(1, data_len); 2030 assert(data != NULL); 2031 memcpy(data, task->sense_data, data_len); 2032 break; 2033 } 2034 2035 case SPDK_SPC_LOG_SELECT: 2036 SPDK_DEBUGLOG(scsi, "LOG_SELECT\n"); 2037 cmd_parsed = 1; 2038 /* FALLTHROUGH */ 2039 case SPDK_SPC_LOG_SENSE: 2040 if (!cmd_parsed) { 2041 SPDK_DEBUGLOG(scsi, "LOG_SENSE\n"); 2042 } 2043 2044 /* INVALID COMMAND OPERATION CODE */ 2045 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 2046 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 2047 SPDK_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 2048 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 2049 rc = -1; 2050 break; 2051 2052 case SPDK_SPC_TEST_UNIT_READY: 2053 SPDK_DEBUGLOG(scsi, "TEST_UNIT_READY\n"); 2054 cmd_parsed = 1; 2055 /* FALLTHROUGH */ 2056 case SPDK_SBC_START_STOP_UNIT: 2057 if (!cmd_parsed) { 2058 SPDK_DEBUGLOG(scsi, "START_STOP_UNIT\n"); 2059 } 2060 2061 rc = 0; 2062 break; 2063 2064 case SPDK_SPC_PERSISTENT_RESERVE_OUT: 2065 pllen = from_be32(&cdb[5]); 2066 rc = bdev_scsi_check_len(task, pllen, 24); 2067 if (rc < 0) { 2068 break; 2069 } 2070 2071 data = spdk_scsi_task_gather_data(task, &rc); 2072 if (rc < 0) { 2073 break; 2074 } 2075 data_len = rc; 2076 if (data_len < 24) { 2077 rc = -1; 2078 break; 2079 } 2080 2081 rc = scsi_pr_out(task, cdb, data, data_len); 2082 if (rc < 0) { 2083 break; 2084 } 2085 rc = pllen; 2086 data_len = 0; 2087 break; 2088 2089 case SPDK_SPC_PERSISTENT_RESERVE_IN: 2090 alloc_len = from_be16(&cdb[7]); 2091 data_len = alloc_len; 2092 data = calloc(1, data_len); 2093 assert(data != NULL); 2094 rc = scsi_pr_in(task, cdb, data, data_len); 2095 break; 2096 2097 case SPDK_SPC2_RESERVE_6: 2098 case SPDK_SPC2_RESERVE_10: 2099 rc = scsi2_reserve(task, cdb); 2100 if (rc == 0) { 2101 if (cdb[0] == SPDK_SPC2_RESERVE_10) { 2102 rc = from_be16(&cdb[7]); 2103 } 2104 data_len = 0; 2105 } 2106 break; 2107 2108 case SPDK_SPC2_RELEASE_6: 2109 case SPDK_SPC2_RELEASE_10: 2110 rc = scsi2_release(task); 2111 break; 2112 2113 default: 2114 return SPDK_SCSI_TASK_UNKNOWN; 2115 } 2116 2117 if (rc >= 0 && data_len > 0) { 2118 assert(alloc_len >= 0); 2119 spdk_scsi_task_scatter_data(task, data, spdk_min(alloc_len, data_len)); 2120 rc = spdk_min(data_len, alloc_len); 2121 } 2122 2123 if (rc >= 0) { 2124 task->data_transferred = rc; 2125 task->status = SPDK_SCSI_STATUS_GOOD; 2126 } 2127 2128 if (data) { 2129 free(data); 2130 } 2131 2132 return SPDK_SCSI_TASK_COMPLETE; 2133 } 2134 2135 int 2136 bdev_scsi_execute(struct spdk_scsi_task *task) 2137 { 2138 int rc; 2139 2140 if ((rc = bdev_scsi_process_block(task)) == SPDK_SCSI_TASK_UNKNOWN) { 2141 if ((rc = bdev_scsi_process_primary(task)) == SPDK_SCSI_TASK_UNKNOWN) { 2142 SPDK_DEBUGLOG(scsi, "unsupported SCSI OP=0x%x\n", task->cdb[0]); 2143 /* INVALID COMMAND OPERATION CODE */ 2144 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 2145 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 2146 SPDK_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 2147 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 2148 return SPDK_SCSI_TASK_COMPLETE; 2149 } 2150 } 2151 2152 return rc; 2153 } 2154 2155 static void 2156 bdev_scsi_reset_resubmit(void *arg) 2157 { 2158 struct spdk_scsi_task *task = arg; 2159 2160 bdev_scsi_reset(task); 2161 } 2162 2163 void 2164 bdev_scsi_reset(struct spdk_scsi_task *task) 2165 { 2166 struct spdk_scsi_lun *lun = task->lun; 2167 int rc; 2168 2169 rc = spdk_bdev_reset(lun->bdev_desc, lun->io_channel, bdev_scsi_task_complete_reset, 2170 task); 2171 if (rc == -ENOMEM) { 2172 bdev_scsi_queue_io(task, bdev_scsi_reset_resubmit, task); 2173 } 2174 } 2175 2176 bool 2177 bdev_scsi_get_dif_ctx(struct spdk_bdev *bdev, struct spdk_scsi_task *task, 2178 struct spdk_dif_ctx *dif_ctx) 2179 { 2180 uint32_t ref_tag = 0, dif_check_flags = 0, data_offset; 2181 uint8_t *cdb; 2182 int rc; 2183 struct spdk_dif_ctx_init_ext_opts dif_opts; 2184 2185 if (spdk_likely(spdk_bdev_get_md_size(bdev) == 0)) { 2186 return false; 2187 } 2188 2189 cdb = task->cdb; 2190 data_offset = task->offset; 2191 2192 /* We use lower 32 bits of LBA as Reference. Tag */ 2193 switch (cdb[0]) { 2194 case SPDK_SBC_READ_6: 2195 case SPDK_SBC_WRITE_6: 2196 ref_tag = (uint32_t)cdb[1] << 16; 2197 ref_tag |= (uint32_t)cdb[2] << 8; 2198 ref_tag |= (uint32_t)cdb[3]; 2199 break; 2200 case SPDK_SBC_READ_10: 2201 case SPDK_SBC_WRITE_10: 2202 case SPDK_SBC_READ_12: 2203 case SPDK_SBC_WRITE_12: 2204 ref_tag = from_be32(&cdb[2]); 2205 break; 2206 case SPDK_SBC_READ_16: 2207 case SPDK_SBC_WRITE_16: 2208 ref_tag = (uint32_t)from_be64(&cdb[2]); 2209 break; 2210 default: 2211 return false; 2212 } 2213 2214 if (spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_REFTAG)) { 2215 dif_check_flags |= SPDK_DIF_FLAGS_REFTAG_CHECK; 2216 } 2217 2218 if (spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_GUARD)) { 2219 dif_check_flags |= SPDK_DIF_FLAGS_GUARD_CHECK; 2220 } 2221 2222 dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format); 2223 dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16; 2224 rc = spdk_dif_ctx_init(dif_ctx, 2225 spdk_bdev_get_block_size(bdev), 2226 spdk_bdev_get_md_size(bdev), 2227 spdk_bdev_is_md_interleaved(bdev), 2228 spdk_bdev_is_dif_head_of_md(bdev), 2229 spdk_bdev_get_dif_type(bdev), 2230 dif_check_flags, 2231 ref_tag, 0, 0, data_offset, 0, &dif_opts); 2232 2233 return (rc == 0) ? true : false; 2234 } 2235