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) 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 { 1303 rc = spdk_bdev_writev_blocks(bdev_desc, bdev_ch, task->iovs, task->iovcnt, 1304 offset_blocks, num_blocks, 1305 bdev_scsi_task_complete_cmd, task); 1306 } 1307 1308 if (rc) { 1309 if (rc == -ENOMEM) { 1310 bdev_scsi_queue_io(task, bdev_scsi_process_block_resubmit, task); 1311 return SPDK_SCSI_TASK_PENDING; 1312 } 1313 SPDK_ERRLOG("spdk_bdev_%s_blocks() failed\n", is_read ? "readv" : "writev"); 1314 goto check_condition; 1315 } 1316 1317 task->data_transferred = task->length; 1318 return SPDK_SCSI_TASK_PENDING; 1319 1320 check_condition: 1321 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, sk, asc, 1322 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1323 return SPDK_SCSI_TASK_COMPLETE; 1324 } 1325 1326 struct spdk_bdev_scsi_split_ctx { 1327 struct spdk_scsi_task *task; 1328 union { 1329 struct spdk_scsi_unmap_bdesc desc[DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT]; 1330 uint64_t start_offset_blocks; /* used by writesame */ 1331 }; 1332 uint16_t remaining_count; 1333 uint16_t current_count; 1334 uint16_t outstanding_count; 1335 int (*fn)(struct spdk_bdev_scsi_split_ctx *ctx); 1336 char name[16]; 1337 }; 1338 1339 static int bdev_scsi_split(struct spdk_bdev_scsi_split_ctx *ctx); 1340 1341 static void 1342 bdev_scsi_split_resubmit(void *arg) 1343 { 1344 struct spdk_bdev_scsi_split_ctx *ctx = arg; 1345 1346 bdev_scsi_split(ctx); 1347 } 1348 1349 static int 1350 bdev_scsi_split(struct spdk_bdev_scsi_split_ctx *ctx) 1351 { 1352 struct spdk_scsi_task *task = ctx->task; 1353 int rc; 1354 1355 while (ctx->remaining_count != 0) { 1356 rc = ctx->fn(ctx); 1357 if (rc == 0) { 1358 ctx->current_count++; 1359 ctx->remaining_count--; 1360 } else { 1361 ctx->outstanding_count--; 1362 if (rc == -ENOMEM) { 1363 if (ctx->outstanding_count == 0) { 1364 /* 1365 * If there are outstanding child I/Os, the last 1366 * completion will call this function again to try 1367 * the next split. Hence, queue the parent task only 1368 * if there is no outstanding child I/O. 1369 */ 1370 bdev_scsi_queue_io(task, bdev_scsi_split_resubmit, ctx); 1371 } 1372 return SPDK_SCSI_TASK_PENDING; 1373 } else { 1374 SPDK_ERRLOG("SCSI %s failed\n", ctx->name); 1375 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1376 SPDK_SCSI_SENSE_NO_SENSE, 1377 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1378 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1379 /* If any child I/O failed, stop further splitting process. */ 1380 ctx->current_count += ctx->remaining_count; 1381 ctx->remaining_count = 0; 1382 /* We can't complete here - we may have to wait for previously 1383 * submitted child I/Os to complete */ 1384 break; 1385 } 1386 } 1387 } 1388 1389 if (ctx->outstanding_count == 0) { 1390 free(ctx); 1391 return SPDK_SCSI_TASK_COMPLETE; 1392 } 1393 1394 return SPDK_SCSI_TASK_PENDING; 1395 } 1396 1397 static void 1398 bdev_scsi_task_complete_split_cmd(struct spdk_bdev_io *bdev_io, bool success, 1399 void *cb_arg) 1400 { 1401 struct spdk_bdev_scsi_split_ctx *ctx = cb_arg; 1402 struct spdk_scsi_task *task = ctx->task; 1403 1404 spdk_bdev_free_io(bdev_io); 1405 1406 if (!success) { 1407 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1408 SPDK_SCSI_SENSE_NO_SENSE, 1409 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1410 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1411 /* If any child I/O failed, stop further splitting process. */ 1412 ctx->current_count += ctx->remaining_count; 1413 ctx->remaining_count = 0; 1414 } 1415 1416 ctx->outstanding_count--; 1417 if (ctx->outstanding_count != 0) { 1418 /* Any child I/O is still outstanding. */ 1419 return; 1420 } 1421 1422 if (ctx->remaining_count == 0) { 1423 /* SCSI task finishes when all descriptors are consumed. */ 1424 scsi_lun_complete_task(task->lun, task); 1425 free(ctx); 1426 return; 1427 } 1428 1429 /* Continue with splitting process. */ 1430 bdev_scsi_split(ctx); 1431 } 1432 1433 static int 1434 __copy_desc(struct spdk_bdev_scsi_split_ctx *ctx, uint8_t *data, size_t data_len) 1435 { 1436 uint16_t desc_data_len; 1437 uint16_t desc_count; 1438 1439 if (!data) { 1440 return -EINVAL; 1441 } 1442 1443 if (data_len < 8) { 1444 /* We can't even get the reported length, so fail. */ 1445 return -EINVAL; 1446 } 1447 1448 desc_data_len = from_be16(&data[2]); 1449 desc_count = desc_data_len / 16; 1450 1451 if (desc_data_len > (data_len - 8)) { 1452 SPDK_ERRLOG("Error - desc_data_len (%u) > data_len (%zu) - 8\n", 1453 desc_data_len, data_len); 1454 return -EINVAL; 1455 } 1456 1457 if (desc_count > DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT) { 1458 SPDK_ERRLOG("desc_count (%u) greater than max allowed (%u)\n", 1459 desc_count, DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT); 1460 return -EINVAL; 1461 } 1462 1463 memcpy(ctx->desc, &data[8], desc_data_len); 1464 return desc_count; 1465 } 1466 1467 static int 1468 _bdev_scsi_unmap(struct spdk_bdev_scsi_split_ctx *ctx) 1469 { 1470 struct spdk_scsi_task *task = ctx->task; 1471 struct spdk_scsi_lun *lun = task->lun; 1472 struct spdk_scsi_unmap_bdesc *desc; 1473 uint64_t offset_blocks; 1474 uint64_t num_blocks; 1475 1476 desc = &ctx->desc[ctx->current_count]; 1477 1478 offset_blocks = from_be64(&desc->lba); 1479 num_blocks = from_be32(&desc->block_count); 1480 1481 if (num_blocks == 0) { 1482 return 0; 1483 } 1484 1485 ctx->outstanding_count++; 1486 return spdk_bdev_unmap_blocks(lun->bdev_desc, 1487 lun->io_channel, 1488 offset_blocks, 1489 num_blocks, 1490 bdev_scsi_task_complete_split_cmd, 1491 ctx); 1492 } 1493 1494 static int 1495 bdev_scsi_unmap(struct spdk_bdev *bdev, struct spdk_scsi_task *task) 1496 { 1497 struct spdk_bdev_scsi_split_ctx *ctx; 1498 uint8_t *data; 1499 int desc_count = -1; 1500 int data_len; 1501 1502 assert(task->status == SPDK_SCSI_STATUS_GOOD); 1503 1504 ctx = calloc(1, sizeof(*ctx)); 1505 if (!ctx) { 1506 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1507 SPDK_SCSI_SENSE_NO_SENSE, 1508 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1509 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1510 return SPDK_SCSI_TASK_COMPLETE; 1511 } 1512 1513 ctx->task = task; 1514 ctx->current_count = 0; 1515 ctx->outstanding_count = 0; 1516 ctx->fn = _bdev_scsi_unmap; 1517 snprintf(ctx->name, sizeof(ctx->name), "UNMAP"); 1518 1519 if (task->iovcnt == 1) { 1520 data = (uint8_t *)task->iovs[0].iov_base; 1521 data_len = task->iovs[0].iov_len; 1522 desc_count = __copy_desc(ctx, data, data_len); 1523 } else { 1524 data = spdk_scsi_task_gather_data(task, &data_len); 1525 if (data) { 1526 desc_count = __copy_desc(ctx, data, data_len); 1527 free(data); 1528 } 1529 } 1530 1531 if (desc_count < 0) { 1532 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1533 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1534 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1535 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1536 free(ctx); 1537 return SPDK_SCSI_TASK_COMPLETE; 1538 } 1539 1540 ctx->remaining_count = desc_count; 1541 1542 return bdev_scsi_split(ctx); 1543 } 1544 1545 static int 1546 _bdev_scsi_write_same(struct spdk_bdev_scsi_split_ctx *ctx) 1547 { 1548 struct spdk_scsi_task *task = ctx->task; 1549 struct spdk_scsi_lun *lun = task->lun; 1550 uint64_t offset_blocks; 1551 1552 ctx->outstanding_count++; 1553 offset_blocks = ctx->start_offset_blocks + ctx->current_count; 1554 return spdk_bdev_writev_blocks(lun->bdev_desc, lun->io_channel, task->iovs, task->iovcnt, 1555 offset_blocks, 1, bdev_scsi_task_complete_split_cmd, ctx); 1556 } 1557 1558 static int 1559 bdev_scsi_write_same(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1560 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, 1561 uint64_t lba, uint32_t xfer_len, uint8_t flags) 1562 { 1563 struct spdk_bdev_scsi_split_ctx *ctx; 1564 uint64_t bdev_num_blocks, offset_blocks, num_blocks; 1565 uint32_t max_xfer_len, block_size; 1566 int sk = SPDK_SCSI_SENSE_NO_SENSE, asc = SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE; 1567 1568 task->data_transferred = 0; 1569 1570 if (spdk_unlikely(task->dxfer_dir != SPDK_SCSI_DIR_TO_DEV)) { 1571 SPDK_ERRLOG("Incorrect data direction\n"); 1572 goto check_condition; 1573 } 1574 1575 block_size = spdk_bdev_get_data_block_size(bdev); 1576 if (spdk_unlikely(task->transfer_len != block_size)) { 1577 SPDK_ERRLOG("Incorrect data length(%d), a single logical block(%d) is required\n", 1578 task->transfer_len, block_size); 1579 goto check_condition; 1580 } 1581 1582 if (spdk_unlikely(xfer_len == 0)) { 1583 task->status = SPDK_SCSI_STATUS_GOOD; 1584 return SPDK_SCSI_TASK_COMPLETE; 1585 } 1586 1587 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev); 1588 if (spdk_unlikely(bdev_num_blocks <= lba || bdev_num_blocks - lba < xfer_len)) { 1589 SPDK_DEBUGLOG(scsi, "end of media\n"); 1590 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST; 1591 asc = SPDK_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE; 1592 goto check_condition; 1593 } 1594 1595 /* see MAXIMUM WRITE SAME LENGTH of SPDK_SPC_VPD_BLOCK_LIMITS */ 1596 max_xfer_len = SPDK_WORK_BLOCK_SIZE / block_size; 1597 if (spdk_unlikely(xfer_len > max_xfer_len)) { 1598 SPDK_ERRLOG("xfer_len %"PRIu32 " > maximum transfer length %" PRIu32 "\n", 1599 xfer_len, max_xfer_len); 1600 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST; 1601 asc = SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB; 1602 goto check_condition; 1603 } 1604 1605 if (_bytes_to_blocks(block_size, task->offset, &offset_blocks, task->length * xfer_len, 1606 &num_blocks) != 0) { 1607 SPDK_ERRLOG("task's offset %" PRIu64 " or length %" PRIu32 " is not block multiple\n", 1608 task->offset, task->length); 1609 goto check_condition; 1610 } 1611 1612 offset_blocks += lba; 1613 SPDK_DEBUGLOG(scsi, "Writesame: lba=%"PRIu64", len=%"PRIu64"\n", 1614 offset_blocks, num_blocks); 1615 1616 ctx = calloc(1, sizeof(*ctx)); 1617 if (!ctx) { 1618 SPDK_ERRLOG("No enough memory on SCSI WRITE SAME\n"); 1619 goto check_condition; 1620 } 1621 1622 ctx->task = task; 1623 ctx->start_offset_blocks = offset_blocks; 1624 ctx->current_count = 0; 1625 ctx->outstanding_count = 0; 1626 ctx->remaining_count = xfer_len; 1627 ctx->fn = _bdev_scsi_write_same; 1628 snprintf(ctx->name, sizeof(ctx->name), "WRITE SAME"); 1629 1630 task->data_transferred = task->length; 1631 1632 return bdev_scsi_split(ctx); 1633 1634 check_condition: 1635 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1636 sk, asc, SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1637 return SPDK_SCSI_TASK_COMPLETE; 1638 } 1639 1640 static int 1641 bdev_scsi_process_block(struct spdk_scsi_task *task) 1642 { 1643 struct spdk_scsi_lun *lun = task->lun; 1644 struct spdk_bdev *bdev = lun->bdev; 1645 uint64_t lba; 1646 uint32_t xfer_len; 1647 uint32_t len = 0; 1648 uint8_t *cdb = task->cdb; 1649 1650 /* XXX: We need to support FUA bit for writes! */ 1651 switch (cdb[0]) { 1652 case SPDK_SBC_READ_6: 1653 case SPDK_SBC_WRITE_6: 1654 lba = (uint64_t)cdb[1] << 16; 1655 lba |= (uint64_t)cdb[2] << 8; 1656 lba |= (uint64_t)cdb[3]; 1657 xfer_len = cdb[4]; 1658 if (xfer_len == 0) { 1659 xfer_len = 256; 1660 } 1661 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1662 task, lba, xfer_len, 1663 cdb[0] == SPDK_SBC_READ_6); 1664 1665 case SPDK_SBC_READ_10: 1666 case SPDK_SBC_WRITE_10: 1667 lba = from_be32(&cdb[2]); 1668 xfer_len = from_be16(&cdb[7]); 1669 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1670 task, lba, xfer_len, 1671 cdb[0] == SPDK_SBC_READ_10); 1672 1673 case SPDK_SBC_READ_12: 1674 case SPDK_SBC_WRITE_12: 1675 lba = from_be32(&cdb[2]); 1676 xfer_len = from_be32(&cdb[6]); 1677 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1678 task, lba, xfer_len, 1679 cdb[0] == SPDK_SBC_READ_12); 1680 case SPDK_SBC_READ_16: 1681 case SPDK_SBC_WRITE_16: 1682 lba = from_be64(&cdb[2]); 1683 xfer_len = from_be32(&cdb[10]); 1684 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1685 task, lba, xfer_len, 1686 cdb[0] == SPDK_SBC_READ_16); 1687 1688 case SPDK_SBC_READ_CAPACITY_10: { 1689 uint64_t num_blocks = spdk_bdev_get_num_blocks(bdev); 1690 uint8_t buffer[8]; 1691 1692 if (num_blocks - 1 > 0xffffffffULL) { 1693 memset(buffer, 0xff, 4); 1694 } else { 1695 to_be32(buffer, num_blocks - 1); 1696 } 1697 to_be32(&buffer[4], spdk_bdev_get_data_block_size(bdev)); 1698 1699 len = spdk_min(task->length, sizeof(buffer)); 1700 if (spdk_scsi_task_scatter_data(task, buffer, len) < 0) { 1701 break; 1702 } 1703 1704 task->data_transferred = len; 1705 task->status = SPDK_SCSI_STATUS_GOOD; 1706 break; 1707 } 1708 1709 case SPDK_SPC_SERVICE_ACTION_IN_16: 1710 switch (cdb[1] & 0x1f) { /* SERVICE ACTION */ 1711 case SPDK_SBC_SAI_READ_CAPACITY_16: { 1712 uint8_t buffer[32] = {0}; 1713 uint32_t lbppb, lbppbe; 1714 1715 to_be64(&buffer[0], spdk_bdev_get_num_blocks(bdev) - 1); 1716 to_be32(&buffer[8], spdk_bdev_get_data_block_size(bdev)); 1717 lbppb = spdk_bdev_get_physical_block_size(bdev) / spdk_bdev_get_data_block_size(bdev); 1718 lbppbe = spdk_u32log2(lbppb); 1719 if (lbppbe > 0xf) { 1720 SPDK_ERRLOG("lbppbe(0x%x) > 0xf\n", lbppbe); 1721 } else { 1722 buffer[13] = lbppbe; 1723 } 1724 /* 1725 * Set the TPE bit to 1 to indicate thin provisioning. 1726 * The position of TPE bit is the 7th bit in 14th byte 1727 * in READ CAPACITY (16) parameter data. 1728 */ 1729 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 1730 buffer[14] |= 1 << 7; 1731 } 1732 1733 len = spdk_min(from_be32(&cdb[10]), sizeof(buffer)); 1734 if (spdk_scsi_task_scatter_data(task, buffer, len) < 0) { 1735 break; 1736 } 1737 1738 task->data_transferred = len; 1739 task->status = SPDK_SCSI_STATUS_GOOD; 1740 break; 1741 } 1742 1743 default: 1744 return SPDK_SCSI_TASK_UNKNOWN; 1745 } 1746 break; 1747 1748 case SPDK_SBC_SYNCHRONIZE_CACHE_10: 1749 case SPDK_SBC_SYNCHRONIZE_CACHE_16: 1750 if (cdb[0] == SPDK_SBC_SYNCHRONIZE_CACHE_10) { 1751 lba = from_be32(&cdb[2]); 1752 len = from_be16(&cdb[7]); 1753 } else { 1754 lba = from_be64(&cdb[2]); 1755 len = from_be32(&cdb[10]); 1756 } 1757 1758 if (len == 0) { 1759 len = spdk_bdev_get_num_blocks(bdev) - lba; 1760 } 1761 1762 return bdev_scsi_sync(bdev, lun->bdev_desc, lun->io_channel, task, lba, len); 1763 break; 1764 1765 case SPDK_SBC_UNMAP: 1766 return bdev_scsi_unmap(bdev, task); 1767 1768 case SPDK_SBC_WRITE_SAME_10: 1769 lba = from_be32(&cdb[2]); 1770 xfer_len = from_be16(&cdb[7]); 1771 return bdev_scsi_write_same(bdev, lun->bdev_desc, lun->io_channel, 1772 task, lba, xfer_len, cdb[1]); 1773 1774 case SPDK_SBC_WRITE_SAME_16: 1775 lba = from_be64(&cdb[2]); 1776 xfer_len = from_be32(&cdb[10]); 1777 return bdev_scsi_write_same(bdev, lun->bdev_desc, lun->io_channel, 1778 task, lba, xfer_len, cdb[1]); 1779 1780 1781 default: 1782 return SPDK_SCSI_TASK_UNKNOWN; 1783 } 1784 1785 return SPDK_SCSI_TASK_COMPLETE; 1786 } 1787 1788 static void 1789 bdev_scsi_process_block_resubmit(void *arg) 1790 { 1791 struct spdk_scsi_task *task = arg; 1792 1793 bdev_scsi_process_block(task); 1794 } 1795 1796 static int 1797 bdev_scsi_check_len(struct spdk_scsi_task *task, int len, int min_len) 1798 { 1799 if (len >= min_len) { 1800 return 0; 1801 } 1802 1803 /* INVALID FIELD IN CDB */ 1804 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1805 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1806 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1807 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1808 return -1; 1809 } 1810 1811 static int 1812 bdev_scsi_process_primary(struct spdk_scsi_task *task) 1813 { 1814 struct spdk_scsi_lun *lun = task->lun; 1815 struct spdk_bdev *bdev = lun->bdev; 1816 int alloc_len = -1; 1817 int data_len = -1; 1818 uint8_t *cdb = task->cdb; 1819 uint8_t *data = NULL; 1820 int rc = 0; 1821 int pllen, md = 0; 1822 int llba; 1823 int dbd, pc, page, subpage; 1824 int cmd_parsed = 0; 1825 1826 switch (cdb[0]) { 1827 case SPDK_SPC_INQUIRY: 1828 alloc_len = from_be16(&cdb[3]); 1829 data_len = spdk_max(4096, alloc_len); 1830 data = calloc(1, data_len); 1831 assert(data != NULL); 1832 rc = bdev_scsi_inquiry(bdev, task, cdb, data, data_len); 1833 data_len = spdk_min(rc, data_len); 1834 if (rc < 0) { 1835 break; 1836 } 1837 1838 SPDK_LOGDUMP(scsi, "INQUIRY", data, data_len); 1839 break; 1840 1841 case SPDK_SPC_REPORT_LUNS: { 1842 int sel; 1843 1844 sel = cdb[2]; 1845 SPDK_DEBUGLOG(scsi, "sel=%x\n", sel); 1846 1847 alloc_len = from_be32(&cdb[6]); 1848 rc = bdev_scsi_check_len(task, alloc_len, 16); 1849 if (rc < 0) { 1850 break; 1851 } 1852 1853 data_len = spdk_max(4096, alloc_len); 1854 data = calloc(1, data_len); 1855 assert(data != NULL); 1856 rc = bdev_scsi_report_luns(task->lun, sel, data, data_len); 1857 data_len = rc; 1858 if (rc < 0) { 1859 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1860 SPDK_SCSI_SENSE_NO_SENSE, 1861 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1862 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1863 break; 1864 } 1865 1866 SPDK_LOGDUMP(scsi, "REPORT LUNS", data, data_len); 1867 break; 1868 } 1869 1870 case SPDK_SPC_MODE_SELECT_6: 1871 case SPDK_SPC_MODE_SELECT_10: 1872 if (cdb[0] == SPDK_SPC_MODE_SELECT_6) { 1873 /* MODE_SELECT(6) must have at least a 4 byte header. */ 1874 md = 4; 1875 pllen = cdb[4]; 1876 } else { 1877 /* MODE_SELECT(10) must have at least an 8 byte header. */ 1878 md = 8; 1879 pllen = from_be16(&cdb[7]); 1880 } 1881 1882 if (pllen == 0) { 1883 break; 1884 } 1885 1886 rc = bdev_scsi_check_len(task, pllen, md); 1887 if (rc < 0) { 1888 break; 1889 } 1890 1891 data = spdk_scsi_task_gather_data(task, &rc); 1892 if (rc < 0) { 1893 break; 1894 } 1895 data_len = rc; 1896 1897 rc = bdev_scsi_check_len(task, data_len, spdk_max(pllen, md)); 1898 if (rc < 0) { 1899 break; 1900 } 1901 1902 rc = pllen; 1903 data_len = 0; 1904 break; 1905 1906 case SPDK_SPC_MODE_SENSE_6: 1907 alloc_len = cdb[4]; 1908 md = 6; 1909 /* FALLTHROUGH */ 1910 case SPDK_SPC_MODE_SENSE_10: 1911 llba = 0; 1912 1913 if (md == 0) { 1914 alloc_len = from_be16(&cdb[7]); 1915 llba = !!(cdb[1] & 0x10); 1916 md = 10; 1917 } 1918 1919 dbd = !!(cdb[1] & 0x8); 1920 pc = (cdb[2] & 0xc0) >> 6; 1921 page = cdb[2] & 0x3f; 1922 subpage = cdb[3]; 1923 1924 /* First call with no buffer to discover needed buffer size */ 1925 rc = bdev_scsi_mode_sense(bdev, md, 1926 cdb, dbd, llba, pc, 1927 page, subpage, 1928 NULL, task); 1929 if (rc < 0) { 1930 break; 1931 } 1932 1933 data_len = rc; 1934 data = calloc(1, data_len); 1935 assert(data != NULL); 1936 1937 /* First call with no buffer to discover needed buffer size */ 1938 rc = bdev_scsi_mode_sense(bdev, md, 1939 cdb, dbd, llba, pc, 1940 page, subpage, 1941 data, task); 1942 if (rc < 0) { 1943 /* INVALID FIELD IN CDB */ 1944 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1945 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1946 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1947 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1948 break; 1949 } 1950 break; 1951 1952 case SPDK_SPC_REQUEST_SENSE: { 1953 int desc; 1954 int sk, asc, ascq; 1955 1956 desc = cdb[1] & 0x1; 1957 if (desc != 0) { 1958 /* INVALID FIELD IN CDB */ 1959 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1960 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1961 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1962 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1963 break; 1964 } 1965 1966 alloc_len = cdb[4]; 1967 1968 /* NO ADDITIONAL SENSE INFORMATION */ 1969 sk = SPDK_SCSI_SENSE_NO_SENSE; 1970 asc = 0x00; 1971 ascq = 0x00; 1972 1973 spdk_scsi_task_build_sense_data(task, sk, asc, ascq); 1974 1975 data_len = task->sense_data_len; 1976 data = calloc(1, data_len); 1977 assert(data != NULL); 1978 memcpy(data, task->sense_data, data_len); 1979 break; 1980 } 1981 1982 case SPDK_SPC_LOG_SELECT: 1983 SPDK_DEBUGLOG(scsi, "LOG_SELECT\n"); 1984 cmd_parsed = 1; 1985 /* FALLTHROUGH */ 1986 case SPDK_SPC_LOG_SENSE: 1987 if (!cmd_parsed) { 1988 SPDK_DEBUGLOG(scsi, "LOG_SENSE\n"); 1989 } 1990 1991 /* INVALID COMMAND OPERATION CODE */ 1992 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1993 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1994 SPDK_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 1995 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1996 rc = -1; 1997 break; 1998 1999 case SPDK_SPC_TEST_UNIT_READY: 2000 SPDK_DEBUGLOG(scsi, "TEST_UNIT_READY\n"); 2001 cmd_parsed = 1; 2002 /* FALLTHROUGH */ 2003 case SPDK_SBC_START_STOP_UNIT: 2004 if (!cmd_parsed) { 2005 SPDK_DEBUGLOG(scsi, "START_STOP_UNIT\n"); 2006 } 2007 2008 rc = 0; 2009 break; 2010 2011 case SPDK_SPC_PERSISTENT_RESERVE_OUT: 2012 pllen = from_be32(&cdb[5]); 2013 rc = bdev_scsi_check_len(task, pllen, 24); 2014 if (rc < 0) { 2015 break; 2016 } 2017 2018 data = spdk_scsi_task_gather_data(task, &rc); 2019 if (rc < 0) { 2020 break; 2021 } 2022 data_len = rc; 2023 if (data_len < 24) { 2024 rc = -1; 2025 break; 2026 } 2027 2028 rc = scsi_pr_out(task, cdb, data, data_len); 2029 if (rc < 0) { 2030 break; 2031 } 2032 rc = pllen; 2033 data_len = 0; 2034 break; 2035 2036 case SPDK_SPC_PERSISTENT_RESERVE_IN: 2037 alloc_len = from_be16(&cdb[7]); 2038 data_len = alloc_len; 2039 data = calloc(1, data_len); 2040 assert(data != NULL); 2041 rc = scsi_pr_in(task, cdb, data, data_len); 2042 break; 2043 2044 case SPDK_SPC2_RESERVE_6: 2045 case SPDK_SPC2_RESERVE_10: 2046 rc = scsi2_reserve(task, cdb); 2047 if (rc == 0) { 2048 if (cdb[0] == SPDK_SPC2_RESERVE_10) { 2049 rc = from_be16(&cdb[7]); 2050 } 2051 data_len = 0; 2052 } 2053 break; 2054 2055 case SPDK_SPC2_RELEASE_6: 2056 case SPDK_SPC2_RELEASE_10: 2057 rc = scsi2_release(task); 2058 break; 2059 2060 default: 2061 return SPDK_SCSI_TASK_UNKNOWN; 2062 } 2063 2064 if (rc >= 0 && data_len > 0) { 2065 assert(alloc_len >= 0); 2066 spdk_scsi_task_scatter_data(task, data, spdk_min(alloc_len, data_len)); 2067 rc = spdk_min(data_len, alloc_len); 2068 } 2069 2070 if (rc >= 0) { 2071 task->data_transferred = rc; 2072 task->status = SPDK_SCSI_STATUS_GOOD; 2073 } 2074 2075 if (data) { 2076 free(data); 2077 } 2078 2079 return SPDK_SCSI_TASK_COMPLETE; 2080 } 2081 2082 int 2083 bdev_scsi_execute(struct spdk_scsi_task *task) 2084 { 2085 int rc; 2086 2087 if ((rc = bdev_scsi_process_block(task)) == SPDK_SCSI_TASK_UNKNOWN) { 2088 if ((rc = bdev_scsi_process_primary(task)) == SPDK_SCSI_TASK_UNKNOWN) { 2089 SPDK_DEBUGLOG(scsi, "unsupported SCSI OP=0x%x\n", task->cdb[0]); 2090 /* INVALID COMMAND OPERATION CODE */ 2091 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 2092 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 2093 SPDK_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 2094 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 2095 return SPDK_SCSI_TASK_COMPLETE; 2096 } 2097 } 2098 2099 return rc; 2100 } 2101 2102 static void 2103 bdev_scsi_reset_resubmit(void *arg) 2104 { 2105 struct spdk_scsi_task *task = arg; 2106 2107 bdev_scsi_reset(task); 2108 } 2109 2110 void 2111 bdev_scsi_reset(struct spdk_scsi_task *task) 2112 { 2113 struct spdk_scsi_lun *lun = task->lun; 2114 int rc; 2115 2116 rc = spdk_bdev_reset(lun->bdev_desc, lun->io_channel, bdev_scsi_task_complete_reset, 2117 task); 2118 if (rc == -ENOMEM) { 2119 bdev_scsi_queue_io(task, bdev_scsi_reset_resubmit, task); 2120 } 2121 } 2122 2123 bool 2124 bdev_scsi_get_dif_ctx(struct spdk_bdev *bdev, struct spdk_scsi_task *task, 2125 struct spdk_dif_ctx *dif_ctx) 2126 { 2127 uint32_t ref_tag = 0, dif_check_flags = 0, data_offset; 2128 uint8_t *cdb; 2129 int rc; 2130 struct spdk_dif_ctx_init_ext_opts dif_opts; 2131 2132 if (spdk_likely(spdk_bdev_get_md_size(bdev) == 0)) { 2133 return false; 2134 } 2135 2136 cdb = task->cdb; 2137 data_offset = task->offset; 2138 2139 /* We use lower 32 bits of LBA as Reference. Tag */ 2140 switch (cdb[0]) { 2141 case SPDK_SBC_READ_6: 2142 case SPDK_SBC_WRITE_6: 2143 ref_tag = (uint32_t)cdb[1] << 16; 2144 ref_tag |= (uint32_t)cdb[2] << 8; 2145 ref_tag |= (uint32_t)cdb[3]; 2146 break; 2147 case SPDK_SBC_READ_10: 2148 case SPDK_SBC_WRITE_10: 2149 case SPDK_SBC_READ_12: 2150 case SPDK_SBC_WRITE_12: 2151 ref_tag = from_be32(&cdb[2]); 2152 break; 2153 case SPDK_SBC_READ_16: 2154 case SPDK_SBC_WRITE_16: 2155 ref_tag = (uint32_t)from_be64(&cdb[2]); 2156 break; 2157 default: 2158 return false; 2159 } 2160 2161 if (spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_REFTAG)) { 2162 dif_check_flags |= SPDK_DIF_FLAGS_REFTAG_CHECK; 2163 } 2164 2165 if (spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_GUARD)) { 2166 dif_check_flags |= SPDK_DIF_FLAGS_GUARD_CHECK; 2167 } 2168 2169 dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format); 2170 dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16; 2171 rc = spdk_dif_ctx_init(dif_ctx, 2172 spdk_bdev_get_block_size(bdev), 2173 spdk_bdev_get_md_size(bdev), 2174 spdk_bdev_is_md_interleaved(bdev), 2175 spdk_bdev_is_dif_head_of_md(bdev), 2176 spdk_bdev_get_dif_type(bdev), 2177 dif_check_flags, 2178 ref_tag, 0, 0, data_offset, 0, &dif_opts); 2179 2180 return (rc == 0) ? true : false; 2181 } 2182