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