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