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 len = 20 - hlen; 516 517 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 518 /* 519 * MAXIMUM UNMAP LBA COUNT: indicates the 520 * maximum number of LBAs that may be 521 * unmapped by an UNMAP command. 522 */ 523 /* For now, choose 4MB as the maximum. */ 524 to_be32(&data[20], 4194304); 525 526 /* 527 * MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT: 528 * indicates the maximum number of UNMAP 529 * block descriptors that shall be contained 530 * in the parameter data transferred to the 531 * device server for an UNMAP command. 532 * The bdev layer automatically splits unmap 533 * requests, so pick an arbitrary high number here. 534 */ 535 to_be32(&data[24], DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT); 536 537 /* 538 * The UGAVALID bit is left as 0 which means neither the 539 * OPTIMAL UNMAP GRANULARITY nor the UNMAP GRANULARITY 540 * ALIGNMENT fields are valid. 541 */ 542 543 /* 544 * MAXIMUM WRITE SAME LENGTH: indicates the 545 * maximum number of contiguous logical blocks 546 * that the device server allows to be unmapped 547 * or written in a single WRITE SAME command. 548 */ 549 to_be64(&data[36], blocks); 550 551 /* Reserved */ 552 /* not specified */ 553 len = 64 - hlen; 554 } 555 556 to_be16(vpage->alloc_len, len); 557 break; 558 } 559 560 case SPDK_SPC_VPD_BLOCK_DEV_CHARS: { 561 /* PAGE LENGTH */ 562 hlen = 4; 563 len = 64 - hlen; 564 565 to_be16(&data[4], DEFAULT_DISK_ROTATION_RATE); 566 567 /* Reserved */ 568 data[6] = 0; 569 /* NOMINAL FORM FACTOR(3-0) */ 570 data[7] = DEFAULT_DISK_FORM_FACTOR << 4; 571 /* Reserved */ 572 memset(&data[8], 0, 64 - 8); 573 574 to_be16(vpage->alloc_len, len); 575 break; 576 } 577 578 case SPDK_SPC_VPD_BLOCK_THIN_PROVISION: { 579 if (!spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 580 goto inq_error; 581 } 582 583 hlen = 4; 584 len = 7; 585 586 /* 587 * PAGE LENGTH : if the DP bit is set to one, then the 588 * page length shall be set 0004h. 589 */ 590 to_be16(&data[2], 0x0004); 591 592 /* 593 * THRESHOLD EXPONENT : it indicates the threshold set 594 * size in LBAs as a power of 2( i.e., the threshold 595 * set size = 2 ^ (threshold exponent). 596 */ 597 data[4] = 0; 598 599 /* 600 * Set the LBPU bit to indicate the support for UNMAP 601 * command. 602 */ 603 data[5] |= SPDK_SCSI_UNMAP_LBPU; 604 605 /* 606 * Set the provisioning type to thin provision. 607 */ 608 data[6] = SPDK_SCSI_UNMAP_THIN_PROVISIONING; 609 610 to_be16(vpage->alloc_len, len); 611 break; 612 } 613 614 default: 615 if (pc >= 0xc0 && pc <= 0xff) { 616 SPDK_DEBUGLOG(scsi, "Vendor specific INQUIRY VPD page 0x%x\n", pc); 617 } else { 618 SPDK_NOTICELOG("unsupported INQUIRY VPD page 0x%x\n", pc); 619 } 620 goto inq_error; 621 } 622 } else { 623 struct spdk_scsi_cdb_inquiry_data *inqdata = 624 (struct spdk_scsi_cdb_inquiry_data *)data; 625 626 /* Standard INQUIRY data */ 627 /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */ 628 inqdata->peripheral_device_type = pd; 629 inqdata->peripheral_qualifier = SPDK_SPC_PERIPHERAL_QUALIFIER_CONNECTED; 630 631 /* RMB(7) */ 632 inqdata->rmb = 0; 633 634 /* VERSION */ 635 /* See SPC3/SBC2/MMC4/SAM2 for more details */ 636 inqdata->version = SPDK_SPC_VERSION_SPC3; 637 638 /* NORMACA(5) HISUP(4) RESPONSE DATA FORMAT(3-0) */ 639 /* format 2 */ /* hierarchical support */ 640 inqdata->response = 2 | 1 << 4; 641 642 hlen = 5; 643 644 /* SCCS(7) ACC(6) TPGS(5-4) 3PC(3) PROTECT(0) */ 645 /* Not support TPGS */ 646 inqdata->flags = 0; 647 648 /* MULTIP */ 649 inqdata->flags2 = 0x10; 650 651 /* WBUS16(5) SYNC(4) LINKED(3) CMDQUE(1) VS(0) */ 652 /* CMDQUE */ 653 inqdata->flags3 = 0x2; 654 655 /* T10 VENDOR IDENTIFICATION */ 656 spdk_strcpy_pad(inqdata->t10_vendor_id, DEFAULT_DISK_VENDOR, 8, ' '); 657 658 /* PRODUCT IDENTIFICATION */ 659 spdk_strcpy_pad(inqdata->product_id, spdk_bdev_get_product_name(bdev), 16, ' '); 660 661 /* PRODUCT REVISION LEVEL */ 662 spdk_strcpy_pad(inqdata->product_rev, DEFAULT_DISK_REVISION, 4, ' '); 663 664 /* 665 * Standard inquiry data ends here. Only populate remaining fields if alloc_len 666 * indicates enough space to hold it. 667 */ 668 len = INQUIRY_OFFSET(product_rev) - 5; 669 670 if (alloc_len >= INQUIRY_OFFSET(vendor)) { 671 /* Vendor specific */ 672 memset(inqdata->vendor, 0x20, 20); 673 len += sizeof(inqdata->vendor); 674 } 675 676 if (alloc_len >= INQUIRY_OFFSET(ius)) { 677 /* CLOCKING(3-2) QAS(1) IUS(0) */ 678 inqdata->ius = 0; 679 len += sizeof(inqdata->ius); 680 } 681 682 if (alloc_len >= INQUIRY_OFFSET(reserved)) { 683 /* Reserved */ 684 inqdata->reserved = 0; 685 len += sizeof(inqdata->reserved); 686 } 687 688 /* VERSION DESCRIPTOR 1-8 */ 689 if (alloc_len >= INQUIRY_OFFSET(reserved) + 2) { 690 to_be16(&inqdata->desc[0], 0x0960); 691 len += 2; 692 } 693 694 if (alloc_len >= INQUIRY_OFFSET(reserved) + 4) { 695 to_be16(&inqdata->desc[2], 0x0300); /* SPC-3 (no version claimed) */ 696 len += 2; 697 } 698 699 if (alloc_len >= INQUIRY_OFFSET(reserved) + 6) { 700 to_be16(&inqdata->desc[4], 0x320); /* SBC-2 (no version claimed) */ 701 len += 2; 702 } 703 704 if (alloc_len >= INQUIRY_OFFSET(reserved) + 8) { 705 to_be16(&inqdata->desc[6], 0x0040); /* SAM-2 (no version claimed) */ 706 len += 2; 707 } 708 709 /* 710 * We only fill out 4 descriptors, but if the allocation length goes past 711 * that, zero the remaining bytes. This fixes some SCSI compliance tests 712 * which expect a full 96 bytes to be returned, including the unpopulated 713 * version descriptors 5-8 (4 * 2 = 8 bytes) plus the 22 bytes of reserved 714 * space (bytes 74-95) - for a total of 30 bytes. 715 */ 716 if (alloc_len > INQUIRY_OFFSET(reserved) + 8) { 717 i = alloc_len - (INQUIRY_OFFSET(reserved) + 8); 718 if (i > 30) { 719 i = 30; 720 } 721 memset(&inqdata->desc[8], 0, i); 722 len += i; 723 } 724 725 /* ADDITIONAL LENGTH */ 726 inqdata->add_len = len; 727 } 728 729 return hlen + len; 730 731 inq_error: 732 task->data_transferred = 0; 733 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 734 SPDK_SCSI_SENSE_NO_SENSE, 735 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 736 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 737 return -1; 738 } 739 740 static void 741 mode_sense_page_init(uint8_t *buf, int len, int page, int subpage) 742 { 743 if (!buf) { 744 return; 745 } 746 747 memset(buf, 0, len); 748 if (subpage != 0) { 749 buf[0] = page | 0x40; /* PAGE + SPF=1 */ 750 buf[1] = subpage; 751 to_be16(&buf[2], len - 4); 752 } else { 753 buf[0] = page; 754 buf[1] = len - 2; 755 } 756 } 757 758 static int 759 bdev_scsi_mode_sense_page(struct spdk_bdev *bdev, 760 uint8_t *cdb, int pc, int page, int subpage, 761 uint8_t *data, struct spdk_scsi_task *task) 762 { 763 uint8_t *cp = data; 764 int len = 0; 765 int plen; 766 int i; 767 768 if (pc == 0x00) { 769 /* Current values */ 770 } else if (pc == 0x01) { 771 /* Changeable values */ 772 /* As we currently do not support changeable values, 773 all parameters are reported as zero. */ 774 } else if (pc == 0x02) { 775 /* Default values */ 776 } else { 777 /* Saved values not supported */ 778 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 779 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 780 SPDK_SCSI_ASC_SAVING_PARAMETERS_NOT_SUPPORTED, 781 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 782 return -1; 783 } 784 785 switch (page) { 786 case 0x00: 787 /* Vendor specific */ 788 break; 789 case 0x01: 790 /* Read-Write Error Recovery */ 791 SPDK_DEBUGLOG(scsi, 792 "MODE_SENSE Read-Write Error Recovery\n"); 793 if (subpage != 0x00) { 794 break; 795 } 796 plen = 0x0a + 2; 797 mode_sense_page_init(cp, plen, page, subpage); 798 len += plen; 799 break; 800 case 0x02: 801 /* Disconnect-Reconnect */ 802 SPDK_DEBUGLOG(scsi, 803 "MODE_SENSE Disconnect-Reconnect\n"); 804 if (subpage != 0x00) { 805 break; 806 } 807 plen = 0x0e + 2; 808 mode_sense_page_init(cp, plen, page, subpage); 809 len += plen; 810 break; 811 case 0x03: 812 /* Obsolete (Format Device) */ 813 break; 814 case 0x04: 815 /* Obsolete (Rigid Disk Geometry) */ 816 break; 817 case 0x05: 818 /* Obsolete (Rigid Disk Geometry) */ 819 break; 820 case 0x06: 821 /* Reserved */ 822 break; 823 case 0x07: 824 /* Verify Error Recovery */ 825 SPDK_DEBUGLOG(scsi, 826 "MODE_SENSE Verify Error Recovery\n"); 827 828 if (subpage != 0x00) { 829 break; 830 } 831 832 plen = 0x0a + 2; 833 mode_sense_page_init(cp, plen, page, subpage); 834 len += plen; 835 break; 836 case 0x08: { 837 /* Caching */ 838 SPDK_DEBUGLOG(scsi, "MODE_SENSE Caching\n"); 839 if (subpage != 0x00) { 840 break; 841 } 842 843 plen = 0x12 + 2; 844 mode_sense_page_init(cp, plen, page, subpage); 845 846 if (cp && spdk_bdev_has_write_cache(bdev) && pc != 0x01) { 847 cp[2] |= 0x4; /* WCE */ 848 } 849 850 /* Read Cache Disable (RCD) = 1 */ 851 if (cp && pc != 0x01) { 852 cp[2] |= 0x1; 853 } 854 855 len += plen; 856 break; 857 } 858 case 0x09: 859 /* Obsolete */ 860 break; 861 case 0x0a: 862 switch (subpage) { 863 case 0x00: 864 /* Control */ 865 SPDK_DEBUGLOG(scsi, 866 "MODE_SENSE Control\n"); 867 plen = 0x0a + 2; 868 mode_sense_page_init(cp, plen, page, subpage); 869 len += plen; 870 break; 871 case 0x01: 872 /* Control Extension */ 873 SPDK_DEBUGLOG(scsi, 874 "MODE_SENSE Control Extension\n"); 875 plen = 0x1c + 4; 876 mode_sense_page_init(cp, plen, page, subpage); 877 len += plen; 878 break; 879 case 0xff: 880 /* All subpages */ 881 len += bdev_scsi_mode_sense_page(bdev, 882 cdb, pc, page, 883 0x00, 884 cp ? &cp[len] : NULL, task); 885 len += bdev_scsi_mode_sense_page(bdev, 886 cdb, pc, page, 887 0x01, 888 cp ? &cp[len] : NULL, task); 889 break; 890 default: 891 /* 0x02-0x3e: Reserved */ 892 break; 893 } 894 break; 895 case 0x0b: 896 /* Obsolete (Medium Types Supported) */ 897 break; 898 case 0x0c: 899 /* Obsolete (Notch And Partition) */ 900 break; 901 case 0x0d: 902 /* Obsolete */ 903 break; 904 case 0x0e: 905 case 0x0f: 906 /* Reserved */ 907 break; 908 case 0x10: 909 /* XOR Control */ 910 SPDK_DEBUGLOG(scsi, "MODE_SENSE XOR Control\n"); 911 if (subpage != 0x00) { 912 break; 913 } 914 plen = 0x16 + 2; 915 mode_sense_page_init(cp, plen, page, subpage); 916 len += plen; 917 break; 918 case 0x11: 919 case 0x12: 920 case 0x13: 921 /* Reserved */ 922 break; 923 case 0x14: 924 /* Enclosure Services Management */ 925 break; 926 case 0x15: 927 case 0x16: 928 case 0x17: 929 /* Reserved */ 930 break; 931 case 0x18: 932 /* Protocol-Specific LUN */ 933 break; 934 case 0x19: 935 /* Protocol-Specific Port */ 936 break; 937 case 0x1a: 938 /* Power Condition */ 939 SPDK_DEBUGLOG(scsi, 940 "MODE_SENSE Power Condition\n"); 941 if (subpage != 0x00) { 942 break; 943 } 944 plen = 0x0a + 2; 945 mode_sense_page_init(cp, plen, page, subpage); 946 len += plen; 947 break; 948 case 0x1b: 949 /* Reserved */ 950 break; 951 case 0x1c: 952 /* Informational Exceptions Control */ 953 SPDK_DEBUGLOG(scsi, 954 "MODE_SENSE Informational Exceptions Control\n"); 955 if (subpage != 0x00) { 956 break; 957 } 958 959 plen = 0x0a + 2; 960 mode_sense_page_init(cp, plen, page, subpage); 961 len += plen; 962 break; 963 case 0x1d: 964 case 0x1e: 965 case 0x1f: 966 /* Reserved */ 967 break; 968 case 0x20: 969 case 0x21: 970 case 0x22: 971 case 0x23: 972 case 0x24: 973 case 0x25: 974 case 0x26: 975 case 0x27: 976 case 0x28: 977 case 0x29: 978 case 0x2a: 979 case 0x2b: 980 case 0x2c: 981 case 0x2d: 982 case 0x2e: 983 case 0x2f: 984 case 0x30: 985 case 0x31: 986 case 0x32: 987 case 0x33: 988 case 0x34: 989 case 0x35: 990 case 0x36: 991 case 0x37: 992 case 0x38: 993 case 0x39: 994 case 0x3a: 995 case 0x3b: 996 case 0x3c: 997 case 0x3d: 998 case 0x3e: 999 /* Vendor-specific */ 1000 break; 1001 case 0x3f: 1002 switch (subpage) { 1003 case 0x00: 1004 /* All mode pages */ 1005 for (i = 0x00; i < 0x3e; i ++) { 1006 len += bdev_scsi_mode_sense_page( 1007 bdev, cdb, pc, i, 0x00, 1008 cp ? &cp[len] : NULL, task); 1009 } 1010 break; 1011 case 0xff: 1012 /* All mode pages and subpages */ 1013 for (i = 0x00; i < 0x3e; i ++) { 1014 len += bdev_scsi_mode_sense_page( 1015 bdev, cdb, pc, i, 0x00, 1016 cp ? &cp[len] : NULL, task); 1017 } 1018 for (i = 0x00; i < 0x3e; i ++) { 1019 len += bdev_scsi_mode_sense_page( 1020 bdev, cdb, pc, i, 0xff, 1021 cp ? &cp[len] : NULL, task); 1022 } 1023 break; 1024 default: 1025 /* 0x01-0x3e: Reserved */ 1026 break; 1027 } 1028 } 1029 1030 return len; 1031 } 1032 1033 static int 1034 bdev_scsi_mode_sense(struct spdk_bdev *bdev, int md, 1035 uint8_t *cdb, int dbd, int llbaa, int pc, 1036 int page, int subpage, uint8_t *data, struct spdk_scsi_task *task) 1037 { 1038 uint64_t num_blocks = spdk_bdev_get_num_blocks(bdev); 1039 uint32_t block_size = spdk_bdev_get_data_block_size(bdev); 1040 uint8_t *hdr, *bdesc, *pages; 1041 int hlen; 1042 int blen; 1043 int plen, total; 1044 1045 assert(md == 6 || md == 10); 1046 1047 if (md == 6) { 1048 hlen = 4; 1049 blen = 8; /* For MODE SENSE 6 only short LBA */ 1050 } else { 1051 hlen = 8; 1052 blen = llbaa ? 16 : 8; 1053 } 1054 1055 if (dbd) { 1056 blen = 0; 1057 } 1058 1059 pages = data ? &data[hlen + blen] : NULL; 1060 plen = bdev_scsi_mode_sense_page(bdev, cdb, pc, page, 1061 subpage, 1062 pages, task); 1063 if (plen < 0) { 1064 return -1; 1065 } 1066 1067 total = hlen + blen + plen; 1068 if (data == NULL) { 1069 return total; 1070 } 1071 1072 hdr = &data[0]; 1073 if (hlen == 4) { 1074 hdr[0] = total - 1; /* Mode Data Length */ 1075 hdr[1] = 0; /* Medium Type */ 1076 hdr[2] = 0; /* Device-Specific Parameter */ 1077 hdr[3] = blen; /* Block Descriptor Length */ 1078 } else { 1079 to_be16(&hdr[0], total - 2); /* Mode Data Length */ 1080 hdr[2] = 0; /* Medium Type */ 1081 hdr[3] = 0; /* Device-Specific Parameter */ 1082 hdr[4] = llbaa ? 0x1 : 0; /* Long/short LBA */ 1083 hdr[5] = 0; /* Reserved */ 1084 to_be16(&hdr[6], blen); /* Block Descriptor Length */ 1085 } 1086 1087 bdesc = &data[hlen]; 1088 if (blen == 16) { 1089 /* Number of Blocks */ 1090 to_be64(&bdesc[0], num_blocks); 1091 /* Reserved */ 1092 memset(&bdesc[8], 0, 4); 1093 /* Block Length */ 1094 to_be32(&bdesc[12], block_size); 1095 } else if (blen == 8) { 1096 /* Number of Blocks */ 1097 if (num_blocks > 0xffffffffULL) { 1098 memset(&bdesc[0], 0xff, 4); 1099 } else { 1100 to_be32(&bdesc[0], num_blocks); 1101 } 1102 1103 /* Block Length */ 1104 to_be32(&bdesc[4], block_size); 1105 } 1106 1107 return total; 1108 } 1109 1110 static void 1111 bdev_scsi_task_complete_cmd(struct spdk_bdev_io *bdev_io, bool success, 1112 void *cb_arg) 1113 { 1114 struct spdk_scsi_task *task = cb_arg; 1115 int sc, sk, asc, ascq; 1116 1117 spdk_bdev_io_get_scsi_status(bdev_io, &sc, &sk, &asc, &ascq); 1118 1119 spdk_bdev_free_io(bdev_io); 1120 1121 spdk_scsi_task_set_status(task, sc, sk, asc, ascq); 1122 scsi_lun_complete_task(task->lun, task); 1123 } 1124 1125 static void 1126 bdev_scsi_read_task_complete_cmd(struct spdk_bdev_io *bdev_io, bool success, 1127 void *cb_arg) 1128 { 1129 struct spdk_scsi_task *task = cb_arg; 1130 int sc, sk, asc, ascq; 1131 1132 task->bdev_io = bdev_io; 1133 1134 spdk_bdev_io_get_scsi_status(bdev_io, &sc, &sk, &asc, &ascq); 1135 1136 spdk_scsi_task_set_status(task, sc, sk, asc, ascq); 1137 scsi_lun_complete_task(task->lun, task); 1138 } 1139 1140 static void 1141 bdev_scsi_task_complete_reset(struct spdk_bdev_io *bdev_io, bool success, 1142 void *cb_arg) 1143 { 1144 struct spdk_scsi_task *task = cb_arg; 1145 1146 spdk_bdev_free_io(bdev_io); 1147 1148 if (success) { 1149 task->response = SPDK_SCSI_TASK_MGMT_RESP_SUCCESS; 1150 } 1151 1152 scsi_lun_complete_reset_task(task->lun, task); 1153 } 1154 1155 static void 1156 bdev_scsi_queue_io(struct spdk_scsi_task *task, spdk_bdev_io_wait_cb cb_fn, void *cb_arg) 1157 { 1158 struct spdk_scsi_lun *lun = task->lun; 1159 struct spdk_bdev *bdev = lun->bdev; 1160 struct spdk_io_channel *ch = lun->io_channel; 1161 int rc; 1162 1163 task->bdev_io_wait.bdev = bdev; 1164 task->bdev_io_wait.cb_fn = cb_fn; 1165 task->bdev_io_wait.cb_arg = cb_arg; 1166 1167 rc = spdk_bdev_queue_io_wait(bdev, ch, &task->bdev_io_wait); 1168 if (rc != 0) { 1169 assert(false); 1170 } 1171 } 1172 1173 static int 1174 bdev_scsi_sync(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1175 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, 1176 uint64_t lba, uint32_t num_blocks) 1177 { 1178 uint64_t bdev_num_blocks; 1179 int rc; 1180 1181 if (num_blocks == 0) { 1182 return SPDK_SCSI_TASK_COMPLETE; 1183 } 1184 1185 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev); 1186 1187 if (lba >= bdev_num_blocks || num_blocks > bdev_num_blocks || 1188 lba > (bdev_num_blocks - num_blocks)) { 1189 SPDK_ERRLOG("end of media\n"); 1190 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1191 SPDK_SCSI_SENSE_NO_SENSE, 1192 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1193 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1194 return SPDK_SCSI_TASK_COMPLETE; 1195 } 1196 1197 rc = spdk_bdev_flush_blocks(bdev_desc, bdev_ch, lba, num_blocks, 1198 bdev_scsi_task_complete_cmd, task); 1199 1200 if (rc) { 1201 if (rc == -ENOMEM) { 1202 bdev_scsi_queue_io(task, bdev_scsi_process_block_resubmit, task); 1203 return SPDK_SCSI_TASK_PENDING; 1204 } 1205 SPDK_ERRLOG("spdk_bdev_flush_blocks() failed\n"); 1206 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1207 SPDK_SCSI_SENSE_NO_SENSE, 1208 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1209 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1210 return SPDK_SCSI_TASK_COMPLETE; 1211 } 1212 task->data_transferred = 0; 1213 return SPDK_SCSI_TASK_PENDING; 1214 } 1215 1216 static uint64_t 1217 _bytes_to_blocks(uint32_t block_size, uint64_t offset_bytes, uint64_t *offset_blocks, 1218 uint64_t num_bytes, uint64_t *num_blocks) 1219 { 1220 uint8_t shift_cnt; 1221 1222 /* Avoid expensive div operations if possible. These spdk_u32 functions are very cheap. */ 1223 if (spdk_likely(spdk_u32_is_pow2(block_size))) { 1224 shift_cnt = spdk_u32log2(block_size); 1225 *offset_blocks = offset_bytes >> shift_cnt; 1226 *num_blocks = num_bytes >> shift_cnt; 1227 return (offset_bytes - (*offset_blocks << shift_cnt)) | 1228 (num_bytes - (*num_blocks << shift_cnt)); 1229 } else { 1230 *offset_blocks = offset_bytes / block_size; 1231 *num_blocks = num_bytes / block_size; 1232 return (offset_bytes % block_size) | (num_bytes % block_size); 1233 } 1234 } 1235 1236 static int 1237 bdev_scsi_readwrite(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1238 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, 1239 uint64_t lba, uint32_t xfer_len, bool is_read) 1240 { 1241 uint64_t bdev_num_blocks, offset_blocks, num_blocks; 1242 uint32_t max_xfer_len, block_size; 1243 int sk = SPDK_SCSI_SENSE_NO_SENSE, asc = SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE; 1244 int rc; 1245 1246 task->data_transferred = 0; 1247 1248 if (spdk_unlikely(task->dxfer_dir != SPDK_SCSI_DIR_NONE && 1249 task->dxfer_dir != (is_read ? SPDK_SCSI_DIR_FROM_DEV : SPDK_SCSI_DIR_TO_DEV))) { 1250 SPDK_ERRLOG("Incorrect data direction\n"); 1251 goto check_condition; 1252 } 1253 1254 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev); 1255 if (spdk_unlikely(bdev_num_blocks <= lba || bdev_num_blocks - lba < xfer_len)) { 1256 SPDK_DEBUGLOG(scsi, "end of media\n"); 1257 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST; 1258 asc = SPDK_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE; 1259 goto check_condition; 1260 } 1261 1262 if (spdk_unlikely(xfer_len == 0)) { 1263 task->status = SPDK_SCSI_STATUS_GOOD; 1264 return SPDK_SCSI_TASK_COMPLETE; 1265 } 1266 1267 block_size = spdk_bdev_get_data_block_size(bdev); 1268 1269 /* Transfer Length is limited to the Block Limits VPD page Maximum Transfer Length */ 1270 max_xfer_len = SPDK_WORK_BLOCK_SIZE / block_size; 1271 if (spdk_unlikely(xfer_len > max_xfer_len)) { 1272 SPDK_ERRLOG("xfer_len %" PRIu32 " > maximum transfer length %" PRIu32 "\n", 1273 xfer_len, max_xfer_len); 1274 sk = SPDK_SCSI_SENSE_ILLEGAL_REQUEST; 1275 asc = SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB; 1276 goto check_condition; 1277 } 1278 1279 if (!is_read) { 1280 /* Additional check for Transfer Length */ 1281 if (xfer_len * block_size > task->transfer_len) { 1282 SPDK_ERRLOG("xfer_len %" PRIu32 " * block_size %" PRIu32 " > transfer_len %u\n", 1283 xfer_len, block_size, task->transfer_len); 1284 goto check_condition; 1285 } 1286 } 1287 1288 if (_bytes_to_blocks(block_size, task->offset, &offset_blocks, task->length, &num_blocks) != 0) { 1289 SPDK_ERRLOG("task's offset %" PRIu64 " or length %" PRIu32 " is not block multiple\n", 1290 task->offset, task->length); 1291 goto check_condition; 1292 } 1293 1294 offset_blocks += lba; 1295 1296 SPDK_DEBUGLOG(scsi, 1297 "%s: lba=%"PRIu64", len=%"PRIu64"\n", 1298 is_read ? "Read" : "Write", offset_blocks, num_blocks); 1299 1300 if (is_read) { 1301 rc = spdk_bdev_readv_blocks(bdev_desc, bdev_ch, task->iovs, task->iovcnt, 1302 offset_blocks, num_blocks, 1303 bdev_scsi_read_task_complete_cmd, task); 1304 } else { 1305 rc = spdk_bdev_writev_blocks(bdev_desc, bdev_ch, task->iovs, task->iovcnt, 1306 offset_blocks, num_blocks, 1307 bdev_scsi_task_complete_cmd, task); 1308 } 1309 1310 if (rc) { 1311 if (rc == -ENOMEM) { 1312 bdev_scsi_queue_io(task, bdev_scsi_process_block_resubmit, task); 1313 return SPDK_SCSI_TASK_PENDING; 1314 } 1315 SPDK_ERRLOG("spdk_bdev_%s_blocks() failed\n", is_read ? "readv" : "writev"); 1316 goto check_condition; 1317 } 1318 1319 task->data_transferred = task->length; 1320 return SPDK_SCSI_TASK_PENDING; 1321 1322 check_condition: 1323 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, sk, asc, 1324 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1325 return SPDK_SCSI_TASK_COMPLETE; 1326 } 1327 1328 struct spdk_bdev_scsi_unmap_ctx { 1329 struct spdk_scsi_task *task; 1330 struct spdk_scsi_unmap_bdesc desc[DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT]; 1331 uint16_t remaining_count; 1332 uint16_t current_count; 1333 uint16_t outstanding_count; 1334 }; 1335 1336 static int _bdev_scsi_unmap(struct spdk_bdev_scsi_unmap_ctx *ctx); 1337 1338 static void 1339 bdev_scsi_task_complete_unmap_cmd(struct spdk_bdev_io *bdev_io, bool success, 1340 void *cb_arg) 1341 { 1342 struct spdk_bdev_scsi_unmap_ctx *ctx = cb_arg; 1343 struct spdk_scsi_task *task = ctx->task; 1344 1345 spdk_bdev_free_io(bdev_io); 1346 1347 if (!success) { 1348 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1349 SPDK_SCSI_SENSE_NO_SENSE, 1350 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1351 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1352 /* If any child I/O failed, stop further splitting process. */ 1353 ctx->current_count += ctx->remaining_count; 1354 ctx->remaining_count = 0; 1355 } 1356 1357 ctx->outstanding_count--; 1358 if (ctx->outstanding_count != 0) { 1359 /* Any child I/O is still outstanding. */ 1360 return; 1361 } 1362 1363 if (ctx->remaining_count == 0) { 1364 /* SCSI task finishes when all descriptors are consumed. */ 1365 scsi_lun_complete_task(task->lun, task); 1366 free(ctx); 1367 return; 1368 } 1369 1370 /* Continue with splitting process. */ 1371 _bdev_scsi_unmap(ctx); 1372 } 1373 1374 static int 1375 __copy_desc(struct spdk_bdev_scsi_unmap_ctx *ctx, uint8_t *data, size_t data_len) 1376 { 1377 uint16_t desc_data_len; 1378 uint16_t desc_count; 1379 1380 if (!data) { 1381 return -EINVAL; 1382 } 1383 1384 if (data_len < 8) { 1385 /* We can't even get the reported length, so fail. */ 1386 return -EINVAL; 1387 } 1388 1389 desc_data_len = from_be16(&data[2]); 1390 desc_count = desc_data_len / 16; 1391 1392 if (desc_data_len > (data_len - 8)) { 1393 SPDK_ERRLOG("Error - desc_data_len (%u) > data_len (%zu) - 8\n", 1394 desc_data_len, data_len); 1395 return -EINVAL; 1396 } 1397 1398 if (desc_count > DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT) { 1399 SPDK_ERRLOG("desc_count (%u) greater than max allowed (%u)\n", 1400 desc_count, DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT); 1401 return -EINVAL; 1402 } 1403 1404 memcpy(ctx->desc, &data[8], desc_data_len); 1405 return desc_count; 1406 } 1407 1408 static void 1409 bdev_scsi_unmap_resubmit(void *arg) 1410 { 1411 struct spdk_bdev_scsi_unmap_ctx *ctx = arg; 1412 1413 _bdev_scsi_unmap(ctx); 1414 } 1415 1416 static int 1417 _bdev_scsi_unmap(struct spdk_bdev_scsi_unmap_ctx *ctx) 1418 { 1419 struct spdk_scsi_task *task = ctx->task; 1420 struct spdk_scsi_lun *lun = task->lun; 1421 int rc; 1422 1423 while (ctx->remaining_count != 0) { 1424 struct spdk_scsi_unmap_bdesc *desc; 1425 uint64_t offset_blocks; 1426 uint64_t num_blocks; 1427 1428 desc = &ctx->desc[ctx->current_count]; 1429 1430 offset_blocks = from_be64(&desc->lba); 1431 num_blocks = from_be32(&desc->block_count); 1432 1433 if (num_blocks == 0) { 1434 rc = 0; 1435 } else { 1436 ctx->outstanding_count++; 1437 rc = spdk_bdev_unmap_blocks(lun->bdev_desc, 1438 lun->io_channel, 1439 offset_blocks, 1440 num_blocks, 1441 bdev_scsi_task_complete_unmap_cmd, 1442 ctx); 1443 } 1444 1445 if (rc == 0) { 1446 ctx->current_count++; 1447 ctx->remaining_count--; 1448 } else { 1449 ctx->outstanding_count--; 1450 if (rc == -ENOMEM) { 1451 if (ctx->outstanding_count == 0) { 1452 /* 1453 * If there are outstanding child I/Os, the last 1454 * completion will call this function again to try 1455 * the next split. Hence, queue the parent task only 1456 * if there is no outstanding child I/O. 1457 */ 1458 bdev_scsi_queue_io(task, bdev_scsi_unmap_resubmit, ctx); 1459 } 1460 return SPDK_SCSI_TASK_PENDING; 1461 } else { 1462 SPDK_ERRLOG("SCSI Unmapping failed\n"); 1463 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1464 SPDK_SCSI_SENSE_NO_SENSE, 1465 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1466 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1467 /* If any child I/O failed, stop further splitting process. */ 1468 ctx->current_count += ctx->remaining_count; 1469 ctx->remaining_count = 0; 1470 /* We can't complete here - we may have to wait for previously 1471 * submitted child I/Os to complete */ 1472 break; 1473 } 1474 } 1475 } 1476 1477 if (ctx->outstanding_count == 0) { 1478 free(ctx); 1479 return SPDK_SCSI_TASK_COMPLETE; 1480 } 1481 1482 return SPDK_SCSI_TASK_PENDING; 1483 } 1484 1485 static int 1486 bdev_scsi_unmap(struct spdk_bdev *bdev, struct spdk_scsi_task *task) 1487 { 1488 struct spdk_bdev_scsi_unmap_ctx *ctx; 1489 uint8_t *data; 1490 int desc_count = -1; 1491 int data_len; 1492 1493 assert(task->status == SPDK_SCSI_STATUS_GOOD); 1494 1495 ctx = calloc(1, sizeof(*ctx)); 1496 if (!ctx) { 1497 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1498 SPDK_SCSI_SENSE_NO_SENSE, 1499 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1500 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1501 return SPDK_SCSI_TASK_COMPLETE; 1502 } 1503 1504 ctx->task = task; 1505 ctx->current_count = 0; 1506 ctx->outstanding_count = 0; 1507 1508 if (task->iovcnt == 1) { 1509 data = (uint8_t *)task->iovs[0].iov_base; 1510 data_len = task->iovs[0].iov_len; 1511 desc_count = __copy_desc(ctx, data, data_len); 1512 } else { 1513 data = spdk_scsi_task_gather_data(task, &data_len); 1514 if (data) { 1515 desc_count = __copy_desc(ctx, data, data_len); 1516 free(data); 1517 } 1518 } 1519 1520 if (desc_count < 0) { 1521 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1522 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1523 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1524 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1525 free(ctx); 1526 return SPDK_SCSI_TASK_COMPLETE; 1527 } 1528 1529 ctx->remaining_count = desc_count; 1530 1531 return _bdev_scsi_unmap(ctx); 1532 } 1533 1534 static int 1535 bdev_scsi_process_block(struct spdk_scsi_task *task) 1536 { 1537 struct spdk_scsi_lun *lun = task->lun; 1538 struct spdk_bdev *bdev = lun->bdev; 1539 uint64_t lba; 1540 uint32_t xfer_len; 1541 uint32_t len = 0; 1542 uint8_t *cdb = task->cdb; 1543 1544 /* XXX: We need to support FUA bit for writes! */ 1545 switch (cdb[0]) { 1546 case SPDK_SBC_READ_6: 1547 case SPDK_SBC_WRITE_6: 1548 lba = (uint64_t)cdb[1] << 16; 1549 lba |= (uint64_t)cdb[2] << 8; 1550 lba |= (uint64_t)cdb[3]; 1551 xfer_len = cdb[4]; 1552 if (xfer_len == 0) { 1553 xfer_len = 256; 1554 } 1555 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1556 task, lba, xfer_len, 1557 cdb[0] == SPDK_SBC_READ_6); 1558 1559 case SPDK_SBC_READ_10: 1560 case SPDK_SBC_WRITE_10: 1561 lba = from_be32(&cdb[2]); 1562 xfer_len = from_be16(&cdb[7]); 1563 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1564 task, lba, xfer_len, 1565 cdb[0] == SPDK_SBC_READ_10); 1566 1567 case SPDK_SBC_READ_12: 1568 case SPDK_SBC_WRITE_12: 1569 lba = from_be32(&cdb[2]); 1570 xfer_len = from_be32(&cdb[6]); 1571 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1572 task, lba, xfer_len, 1573 cdb[0] == SPDK_SBC_READ_12); 1574 case SPDK_SBC_READ_16: 1575 case SPDK_SBC_WRITE_16: 1576 lba = from_be64(&cdb[2]); 1577 xfer_len = from_be32(&cdb[10]); 1578 return bdev_scsi_readwrite(bdev, lun->bdev_desc, lun->io_channel, 1579 task, lba, xfer_len, 1580 cdb[0] == SPDK_SBC_READ_16); 1581 1582 case SPDK_SBC_READ_CAPACITY_10: { 1583 uint64_t num_blocks = spdk_bdev_get_num_blocks(bdev); 1584 uint8_t buffer[8]; 1585 1586 if (num_blocks - 1 > 0xffffffffULL) { 1587 memset(buffer, 0xff, 4); 1588 } else { 1589 to_be32(buffer, num_blocks - 1); 1590 } 1591 to_be32(&buffer[4], spdk_bdev_get_data_block_size(bdev)); 1592 1593 len = spdk_min(task->length, sizeof(buffer)); 1594 if (spdk_scsi_task_scatter_data(task, buffer, len) < 0) { 1595 break; 1596 } 1597 1598 task->data_transferred = len; 1599 task->status = SPDK_SCSI_STATUS_GOOD; 1600 break; 1601 } 1602 1603 case SPDK_SPC_SERVICE_ACTION_IN_16: 1604 switch (cdb[1] & 0x1f) { /* SERVICE ACTION */ 1605 case SPDK_SBC_SAI_READ_CAPACITY_16: { 1606 uint8_t buffer[32] = {0}; 1607 uint32_t lbppb, lbppbe; 1608 1609 to_be64(&buffer[0], spdk_bdev_get_num_blocks(bdev) - 1); 1610 to_be32(&buffer[8], spdk_bdev_get_data_block_size(bdev)); 1611 lbppb = spdk_bdev_get_physical_block_size(bdev) / spdk_bdev_get_data_block_size(bdev); 1612 lbppbe = spdk_u32log2(lbppb); 1613 if (lbppbe > 0xf) { 1614 SPDK_ERRLOG("lbppbe(0x%x) > 0xf\n", lbppbe); 1615 } else { 1616 buffer[13] = lbppbe; 1617 } 1618 /* 1619 * Set the TPE bit to 1 to indicate thin provisioning. 1620 * The position of TPE bit is the 7th bit in 14th byte 1621 * in READ CAPACITY (16) parameter data. 1622 */ 1623 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 1624 buffer[14] |= 1 << 7; 1625 } 1626 1627 len = spdk_min(from_be32(&cdb[10]), sizeof(buffer)); 1628 if (spdk_scsi_task_scatter_data(task, buffer, len) < 0) { 1629 break; 1630 } 1631 1632 task->data_transferred = len; 1633 task->status = SPDK_SCSI_STATUS_GOOD; 1634 break; 1635 } 1636 1637 default: 1638 return SPDK_SCSI_TASK_UNKNOWN; 1639 } 1640 break; 1641 1642 case SPDK_SBC_SYNCHRONIZE_CACHE_10: 1643 case SPDK_SBC_SYNCHRONIZE_CACHE_16: 1644 if (cdb[0] == SPDK_SBC_SYNCHRONIZE_CACHE_10) { 1645 lba = from_be32(&cdb[2]); 1646 len = from_be16(&cdb[7]); 1647 } else { 1648 lba = from_be64(&cdb[2]); 1649 len = from_be32(&cdb[10]); 1650 } 1651 1652 if (len == 0) { 1653 len = spdk_bdev_get_num_blocks(bdev) - lba; 1654 } 1655 1656 return bdev_scsi_sync(bdev, lun->bdev_desc, lun->io_channel, task, lba, len); 1657 break; 1658 1659 case SPDK_SBC_UNMAP: 1660 return bdev_scsi_unmap(bdev, task); 1661 1662 default: 1663 return SPDK_SCSI_TASK_UNKNOWN; 1664 } 1665 1666 return SPDK_SCSI_TASK_COMPLETE; 1667 } 1668 1669 static void 1670 bdev_scsi_process_block_resubmit(void *arg) 1671 { 1672 struct spdk_scsi_task *task = arg; 1673 1674 bdev_scsi_process_block(task); 1675 } 1676 1677 static int 1678 bdev_scsi_check_len(struct spdk_scsi_task *task, int len, int min_len) 1679 { 1680 if (len >= min_len) { 1681 return 0; 1682 } 1683 1684 /* INVALID FIELD IN CDB */ 1685 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1686 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1687 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1688 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1689 return -1; 1690 } 1691 1692 static int 1693 bdev_scsi_process_primary(struct spdk_scsi_task *task) 1694 { 1695 struct spdk_scsi_lun *lun = task->lun; 1696 struct spdk_bdev *bdev = lun->bdev; 1697 int alloc_len = -1; 1698 int data_len = -1; 1699 uint8_t *cdb = task->cdb; 1700 uint8_t *data = NULL; 1701 int rc = 0; 1702 int pllen, md = 0; 1703 int llba; 1704 int dbd, pc, page, subpage; 1705 int cmd_parsed = 0; 1706 1707 switch (cdb[0]) { 1708 case SPDK_SPC_INQUIRY: 1709 alloc_len = from_be16(&cdb[3]); 1710 data_len = spdk_max(4096, alloc_len); 1711 data = calloc(1, data_len); 1712 assert(data != NULL); 1713 rc = bdev_scsi_inquiry(bdev, task, cdb, data, data_len); 1714 data_len = spdk_min(rc, data_len); 1715 if (rc < 0) { 1716 break; 1717 } 1718 1719 SPDK_LOGDUMP(scsi, "INQUIRY", data, data_len); 1720 break; 1721 1722 case SPDK_SPC_REPORT_LUNS: { 1723 int sel; 1724 1725 sel = cdb[2]; 1726 SPDK_DEBUGLOG(scsi, "sel=%x\n", sel); 1727 1728 alloc_len = from_be32(&cdb[6]); 1729 rc = bdev_scsi_check_len(task, alloc_len, 16); 1730 if (rc < 0) { 1731 break; 1732 } 1733 1734 data_len = spdk_max(4096, alloc_len); 1735 data = calloc(1, data_len); 1736 assert(data != NULL); 1737 rc = bdev_scsi_report_luns(task->lun, sel, data, data_len); 1738 data_len = rc; 1739 if (rc < 0) { 1740 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1741 SPDK_SCSI_SENSE_NO_SENSE, 1742 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1743 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1744 break; 1745 } 1746 1747 SPDK_LOGDUMP(scsi, "REPORT LUNS", data, data_len); 1748 break; 1749 } 1750 1751 case SPDK_SPC_MODE_SELECT_6: 1752 case SPDK_SPC_MODE_SELECT_10: 1753 if (cdb[0] == SPDK_SPC_MODE_SELECT_6) { 1754 /* MODE_SELECT(6) must have at least a 4 byte header. */ 1755 md = 4; 1756 pllen = cdb[4]; 1757 } else { 1758 /* MODE_SELECT(10) must have at least an 8 byte header. */ 1759 md = 8; 1760 pllen = from_be16(&cdb[7]); 1761 } 1762 1763 if (pllen == 0) { 1764 break; 1765 } 1766 1767 rc = bdev_scsi_check_len(task, pllen, md); 1768 if (rc < 0) { 1769 break; 1770 } 1771 1772 data = spdk_scsi_task_gather_data(task, &rc); 1773 if (rc < 0) { 1774 break; 1775 } 1776 data_len = rc; 1777 1778 rc = bdev_scsi_check_len(task, data_len, spdk_max(pllen, md)); 1779 if (rc < 0) { 1780 break; 1781 } 1782 1783 rc = pllen; 1784 data_len = 0; 1785 break; 1786 1787 case SPDK_SPC_MODE_SENSE_6: 1788 alloc_len = cdb[4]; 1789 md = 6; 1790 /* FALLTHROUGH */ 1791 case SPDK_SPC_MODE_SENSE_10: 1792 llba = 0; 1793 1794 if (md == 0) { 1795 alloc_len = from_be16(&cdb[7]); 1796 llba = !!(cdb[1] & 0x10); 1797 md = 10; 1798 } 1799 1800 dbd = !!(cdb[1] & 0x8); 1801 pc = (cdb[2] & 0xc0) >> 6; 1802 page = cdb[2] & 0x3f; 1803 subpage = cdb[3]; 1804 1805 /* First call with no buffer to discover needed buffer size */ 1806 rc = bdev_scsi_mode_sense(bdev, md, 1807 cdb, dbd, llba, pc, 1808 page, subpage, 1809 NULL, task); 1810 if (rc < 0) { 1811 break; 1812 } 1813 1814 data_len = rc; 1815 data = calloc(1, data_len); 1816 assert(data != NULL); 1817 1818 /* First call with no buffer to discover needed buffer size */ 1819 rc = bdev_scsi_mode_sense(bdev, md, 1820 cdb, dbd, llba, pc, 1821 page, subpage, 1822 data, task); 1823 if (rc < 0) { 1824 /* INVALID FIELD IN CDB */ 1825 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1826 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1827 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1828 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1829 break; 1830 } 1831 break; 1832 1833 case SPDK_SPC_REQUEST_SENSE: { 1834 int desc; 1835 int sk, asc, ascq; 1836 1837 desc = cdb[1] & 0x1; 1838 if (desc != 0) { 1839 /* INVALID FIELD IN CDB */ 1840 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1841 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1842 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1843 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1844 break; 1845 } 1846 1847 alloc_len = cdb[4]; 1848 1849 /* NO ADDITIONAL SENSE INFORMATION */ 1850 sk = SPDK_SCSI_SENSE_NO_SENSE; 1851 asc = 0x00; 1852 ascq = 0x00; 1853 1854 spdk_scsi_task_build_sense_data(task, sk, asc, ascq); 1855 1856 data_len = task->sense_data_len; 1857 data = calloc(1, data_len); 1858 assert(data != NULL); 1859 memcpy(data, task->sense_data, data_len); 1860 break; 1861 } 1862 1863 case SPDK_SPC_LOG_SELECT: 1864 SPDK_DEBUGLOG(scsi, "LOG_SELECT\n"); 1865 cmd_parsed = 1; 1866 /* FALLTHROUGH */ 1867 case SPDK_SPC_LOG_SENSE: 1868 if (!cmd_parsed) { 1869 SPDK_DEBUGLOG(scsi, "LOG_SENSE\n"); 1870 } 1871 1872 /* INVALID COMMAND OPERATION CODE */ 1873 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1874 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1875 SPDK_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 1876 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1877 rc = -1; 1878 break; 1879 1880 case SPDK_SPC_TEST_UNIT_READY: 1881 SPDK_DEBUGLOG(scsi, "TEST_UNIT_READY\n"); 1882 cmd_parsed = 1; 1883 /* FALLTHROUGH */ 1884 case SPDK_SBC_START_STOP_UNIT: 1885 if (!cmd_parsed) { 1886 SPDK_DEBUGLOG(scsi, "START_STOP_UNIT\n"); 1887 } 1888 1889 rc = 0; 1890 break; 1891 1892 case SPDK_SPC_PERSISTENT_RESERVE_OUT: 1893 pllen = from_be32(&cdb[5]); 1894 rc = bdev_scsi_check_len(task, pllen, 24); 1895 if (rc < 0) { 1896 break; 1897 } 1898 1899 data = spdk_scsi_task_gather_data(task, &rc); 1900 if (rc < 0) { 1901 break; 1902 } 1903 data_len = rc; 1904 if (data_len < 24) { 1905 rc = -1; 1906 break; 1907 } 1908 1909 rc = scsi_pr_out(task, cdb, data, data_len); 1910 if (rc < 0) { 1911 break; 1912 } 1913 rc = pllen; 1914 data_len = 0; 1915 break; 1916 1917 case SPDK_SPC_PERSISTENT_RESERVE_IN: 1918 alloc_len = from_be16(&cdb[7]); 1919 data_len = alloc_len; 1920 data = calloc(1, data_len); 1921 assert(data != NULL); 1922 rc = scsi_pr_in(task, cdb, data, data_len); 1923 break; 1924 1925 case SPDK_SPC2_RESERVE_6: 1926 case SPDK_SPC2_RESERVE_10: 1927 rc = scsi2_reserve(task, cdb); 1928 if (rc == 0) { 1929 if (cdb[0] == SPDK_SPC2_RESERVE_10) { 1930 rc = from_be16(&cdb[7]); 1931 } 1932 data_len = 0; 1933 } 1934 break; 1935 1936 case SPDK_SPC2_RELEASE_6: 1937 case SPDK_SPC2_RELEASE_10: 1938 rc = scsi2_release(task); 1939 break; 1940 1941 default: 1942 return SPDK_SCSI_TASK_UNKNOWN; 1943 } 1944 1945 if (rc >= 0 && data_len > 0) { 1946 assert(alloc_len >= 0); 1947 spdk_scsi_task_scatter_data(task, data, spdk_min(alloc_len, data_len)); 1948 rc = spdk_min(data_len, alloc_len); 1949 } 1950 1951 if (rc >= 0) { 1952 task->data_transferred = rc; 1953 task->status = SPDK_SCSI_STATUS_GOOD; 1954 } 1955 1956 if (data) { 1957 free(data); 1958 } 1959 1960 return SPDK_SCSI_TASK_COMPLETE; 1961 } 1962 1963 int 1964 bdev_scsi_execute(struct spdk_scsi_task *task) 1965 { 1966 int rc; 1967 1968 if ((rc = bdev_scsi_process_block(task)) == SPDK_SCSI_TASK_UNKNOWN) { 1969 if ((rc = bdev_scsi_process_primary(task)) == SPDK_SCSI_TASK_UNKNOWN) { 1970 SPDK_DEBUGLOG(scsi, "unsupported SCSI OP=0x%x\n", task->cdb[0]); 1971 /* INVALID COMMAND OPERATION CODE */ 1972 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1973 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1974 SPDK_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 1975 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1976 return SPDK_SCSI_TASK_COMPLETE; 1977 } 1978 } 1979 1980 return rc; 1981 } 1982 1983 static void 1984 bdev_scsi_reset_resubmit(void *arg) 1985 { 1986 struct spdk_scsi_task *task = arg; 1987 1988 bdev_scsi_reset(task); 1989 } 1990 1991 void 1992 bdev_scsi_reset(struct spdk_scsi_task *task) 1993 { 1994 struct spdk_scsi_lun *lun = task->lun; 1995 int rc; 1996 1997 rc = spdk_bdev_reset(lun->bdev_desc, lun->io_channel, bdev_scsi_task_complete_reset, 1998 task); 1999 if (rc == -ENOMEM) { 2000 bdev_scsi_queue_io(task, bdev_scsi_reset_resubmit, task); 2001 } 2002 } 2003 2004 bool 2005 bdev_scsi_get_dif_ctx(struct spdk_bdev *bdev, struct spdk_scsi_task *task, 2006 struct spdk_dif_ctx *dif_ctx) 2007 { 2008 uint32_t ref_tag = 0, dif_check_flags = 0, data_offset; 2009 uint8_t *cdb; 2010 int rc; 2011 struct spdk_dif_ctx_init_ext_opts dif_opts; 2012 2013 if (spdk_likely(spdk_bdev_get_md_size(bdev) == 0)) { 2014 return false; 2015 } 2016 2017 cdb = task->cdb; 2018 data_offset = task->offset; 2019 2020 /* We use lower 32 bits of LBA as Reference. Tag */ 2021 switch (cdb[0]) { 2022 case SPDK_SBC_READ_6: 2023 case SPDK_SBC_WRITE_6: 2024 ref_tag = (uint32_t)cdb[1] << 16; 2025 ref_tag |= (uint32_t)cdb[2] << 8; 2026 ref_tag |= (uint32_t)cdb[3]; 2027 break; 2028 case SPDK_SBC_READ_10: 2029 case SPDK_SBC_WRITE_10: 2030 case SPDK_SBC_READ_12: 2031 case SPDK_SBC_WRITE_12: 2032 ref_tag = from_be32(&cdb[2]); 2033 break; 2034 case SPDK_SBC_READ_16: 2035 case SPDK_SBC_WRITE_16: 2036 ref_tag = (uint32_t)from_be64(&cdb[2]); 2037 break; 2038 default: 2039 return false; 2040 } 2041 2042 if (spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_REFTAG)) { 2043 dif_check_flags |= SPDK_DIF_FLAGS_REFTAG_CHECK; 2044 } 2045 2046 if (spdk_bdev_is_dif_check_enabled(bdev, SPDK_DIF_CHECK_TYPE_GUARD)) { 2047 dif_check_flags |= SPDK_DIF_FLAGS_GUARD_CHECK; 2048 } 2049 2050 dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format); 2051 dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16; 2052 rc = spdk_dif_ctx_init(dif_ctx, 2053 spdk_bdev_get_block_size(bdev), 2054 spdk_bdev_get_md_size(bdev), 2055 spdk_bdev_is_md_interleaved(bdev), 2056 spdk_bdev_is_dif_head_of_md(bdev), 2057 spdk_bdev_get_dif_type(bdev), 2058 dif_check_flags, 2059 ref_tag, 0, 0, data_offset, 0, &dif_opts); 2060 2061 return (rc == 0) ? true : false; 2062 } 2063