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 #if 0 1238 wce = data[2] & 0x4; /* WCE */ 1239 1240 fd = bdev->fd; 1241 1242 rc = fcntl(fd, F_GETFL, 0); 1243 if (rc != -1) { 1244 if (wce) { 1245 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "MODE_SELECT Writeback cache enable\n"); 1246 rc = fcntl(fd, F_SETFL, (rc & ~O_FSYNC)); 1247 bdev->write_cache = 1; 1248 } else { 1249 rc = fcntl(fd, F_SETFL, (rc | O_FSYNC)); 1250 bdev->write_cache = 0; 1251 } 1252 } 1253 #endif 1254 1255 break; 1256 } 1257 default: 1258 /* not supported */ 1259 break; 1260 } 1261 1262 len -= plen; 1263 if (len != 0) { 1264 rc = spdk_bdev_scsi_mode_select_page(bdev, cdb, pf, sp, &data[plen], len); 1265 if (rc < 0) { 1266 return rc; 1267 } 1268 } 1269 return 0; 1270 } 1271 1272 static void 1273 spdk_bdev_scsi_task_complete_cmd(struct spdk_bdev_io *bdev_io, bool success, 1274 void *cb_arg) 1275 { 1276 struct spdk_scsi_task *task = cb_arg; 1277 int sc, sk, asc, ascq; 1278 1279 task->bdev_io = bdev_io; 1280 1281 spdk_bdev_io_get_scsi_status(bdev_io, &sc, &sk, &asc, &ascq); 1282 spdk_scsi_task_set_status(task, sc, sk, asc, ascq); 1283 spdk_scsi_lun_complete_task(task->lun, task); 1284 } 1285 1286 static void 1287 spdk_bdev_scsi_task_complete_mgmt(struct spdk_bdev_io *bdev_io, bool success, 1288 void *cb_arg) 1289 { 1290 struct spdk_scsi_task *task = cb_arg; 1291 1292 task->bdev_io = bdev_io; 1293 1294 if (success) { 1295 task->response = SPDK_SCSI_TASK_MGMT_RESP_SUCCESS; 1296 } 1297 1298 spdk_scsi_lun_complete_mgmt_task(task->lun, task); 1299 } 1300 1301 static void 1302 spdk_bdev_scsi_queue_io(struct spdk_scsi_task *task, spdk_bdev_io_wait_cb cb_fn, void *cb_arg) 1303 { 1304 struct spdk_scsi_lun *lun = task->lun; 1305 struct spdk_bdev *bdev = lun->bdev; 1306 struct spdk_io_channel *ch = lun->io_channel; 1307 int rc; 1308 1309 task->bdev_io_wait.bdev = bdev; 1310 task->bdev_io_wait.cb_fn = cb_fn; 1311 task->bdev_io_wait.cb_arg = cb_arg; 1312 1313 rc = spdk_bdev_queue_io_wait(bdev, ch, &task->bdev_io_wait); 1314 if (rc != 0) { 1315 assert(false); 1316 } 1317 } 1318 1319 static int 1320 spdk_bdev_scsi_read(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1321 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, 1322 uint64_t lba, uint32_t len) 1323 { 1324 uint64_t blen; 1325 uint64_t offset; 1326 uint64_t nbytes; 1327 int rc; 1328 1329 blen = spdk_bdev_get_block_size(bdev); 1330 1331 lba += (task->offset / blen); 1332 offset = lba * blen; 1333 nbytes = task->length; 1334 1335 SPDK_DEBUGLOG(SPDK_LOG_SCSI, 1336 "Read: lba=%"PRIu64", len=%"PRIu64"\n", 1337 lba, (uint64_t)task->length / blen); 1338 1339 rc = spdk_bdev_readv(bdev_desc, bdev_ch, task->iovs, 1340 task->iovcnt, offset, nbytes, 1341 spdk_bdev_scsi_task_complete_cmd, task); 1342 1343 if (rc) { 1344 if (rc == -ENOMEM) { 1345 spdk_bdev_scsi_queue_io(task, spdk_bdev_scsi_process_block_resubmit, task); 1346 return SPDK_SCSI_TASK_PENDING; 1347 } 1348 SPDK_ERRLOG("spdk_bdev_readv() failed\n"); 1349 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1350 SPDK_SCSI_SENSE_NO_SENSE, 1351 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1352 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1353 return SPDK_SCSI_TASK_COMPLETE; 1354 } 1355 1356 task->data_transferred = nbytes; 1357 return SPDK_SCSI_TASK_PENDING; 1358 } 1359 1360 static int 1361 spdk_bdev_scsi_write(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1362 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, 1363 uint64_t lba, uint32_t len) 1364 { 1365 uint64_t blen; 1366 uint64_t offset; 1367 uint64_t nbytes; 1368 int rc; 1369 1370 blen = spdk_bdev_get_block_size(bdev); 1371 offset = lba * blen; 1372 nbytes = ((uint64_t)len) * blen; 1373 1374 SPDK_DEBUGLOG(SPDK_LOG_SCSI, 1375 "Write: lba=%"PRIu64", len=%u\n", 1376 lba, len); 1377 1378 if (nbytes > task->transfer_len) { 1379 SPDK_ERRLOG("nbytes(%zu) > transfer_len(%u)\n", 1380 (size_t)nbytes, task->transfer_len); 1381 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1382 SPDK_SCSI_SENSE_NO_SENSE, 1383 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1384 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1385 return SPDK_SCSI_TASK_COMPLETE; 1386 } 1387 1388 offset += task->offset; 1389 rc = spdk_bdev_writev(bdev_desc, bdev_ch, task->iovs, 1390 task->iovcnt, offset, task->length, 1391 spdk_bdev_scsi_task_complete_cmd, 1392 task); 1393 1394 if (rc) { 1395 if (rc == -ENOMEM) { 1396 spdk_bdev_scsi_queue_io(task, spdk_bdev_scsi_process_block_resubmit, task); 1397 return SPDK_SCSI_TASK_PENDING; 1398 } 1399 SPDK_ERRLOG("spdk_bdev_writev failed\n"); 1400 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1401 SPDK_SCSI_SENSE_NO_SENSE, 1402 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1403 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1404 return SPDK_SCSI_TASK_COMPLETE; 1405 } 1406 1407 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "Wrote %"PRIu64"/%"PRIu64" bytes\n", 1408 (uint64_t)task->length, nbytes); 1409 1410 task->data_transferred = task->length; 1411 return SPDK_SCSI_TASK_PENDING; 1412 } 1413 1414 static int 1415 spdk_bdev_scsi_sync(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1416 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, 1417 uint64_t lba, uint32_t num_blocks) 1418 { 1419 uint64_t bdev_num_blocks; 1420 int rc; 1421 1422 if (num_blocks == 0) { 1423 return SPDK_SCSI_TASK_COMPLETE; 1424 } 1425 1426 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev); 1427 1428 if (lba >= bdev_num_blocks || num_blocks > bdev_num_blocks || 1429 lba > (bdev_num_blocks - num_blocks)) { 1430 SPDK_ERRLOG("end of media\n"); 1431 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1432 SPDK_SCSI_SENSE_NO_SENSE, 1433 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1434 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1435 return SPDK_SCSI_TASK_COMPLETE; 1436 } 1437 1438 rc = spdk_bdev_flush_blocks(bdev_desc, bdev_ch, lba, num_blocks, 1439 spdk_bdev_scsi_task_complete_cmd, task); 1440 1441 if (rc) { 1442 if (rc == -ENOMEM) { 1443 spdk_bdev_scsi_queue_io(task, spdk_bdev_scsi_process_block_resubmit, task); 1444 return SPDK_SCSI_TASK_PENDING; 1445 } 1446 SPDK_ERRLOG("spdk_bdev_flush_blocks() failed\n"); 1447 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1448 SPDK_SCSI_SENSE_NO_SENSE, 1449 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1450 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1451 return SPDK_SCSI_TASK_COMPLETE; 1452 } 1453 task->data_transferred = 0; 1454 return SPDK_SCSI_TASK_PENDING; 1455 } 1456 1457 static int 1458 spdk_bdev_scsi_readwrite(struct spdk_scsi_task *task, 1459 uint64_t lba, uint32_t xfer_len, bool is_read) 1460 { 1461 struct spdk_scsi_lun *lun = task->lun; 1462 struct spdk_bdev *bdev = lun->bdev; 1463 struct spdk_bdev_desc *bdev_desc = lun->bdev_desc; 1464 struct spdk_io_channel *bdev_ch = lun->io_channel; 1465 uint64_t bdev_num_blocks; 1466 uint32_t max_xfer_len; 1467 1468 task->data_transferred = 0; 1469 1470 if (spdk_unlikely(task->dxfer_dir != SPDK_SCSI_DIR_NONE && 1471 task->dxfer_dir != (is_read ? SPDK_SCSI_DIR_FROM_DEV : SPDK_SCSI_DIR_TO_DEV))) { 1472 SPDK_ERRLOG("Incorrect data direction\n"); 1473 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1474 SPDK_SCSI_SENSE_NO_SENSE, 1475 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1476 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1477 return SPDK_SCSI_TASK_COMPLETE; 1478 } 1479 1480 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev); 1481 if (spdk_unlikely(bdev_num_blocks <= lba || bdev_num_blocks - lba < xfer_len)) { 1482 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "end of media\n"); 1483 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1484 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1485 SPDK_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 1486 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1487 return SPDK_SCSI_TASK_COMPLETE; 1488 } 1489 1490 if (spdk_unlikely(xfer_len == 0)) { 1491 task->status = SPDK_SCSI_STATUS_GOOD; 1492 return SPDK_SCSI_TASK_COMPLETE; 1493 } 1494 1495 /* Transfer Length is limited to the Block Limits VPD page Maximum Transfer Length */ 1496 max_xfer_len = SPDK_WORK_BLOCK_SIZE / spdk_bdev_get_block_size(bdev); 1497 if (spdk_unlikely(xfer_len > max_xfer_len)) { 1498 SPDK_ERRLOG("xfer_len %" PRIu32 " > maximum transfer length %" PRIu32 "\n", 1499 xfer_len, max_xfer_len); 1500 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1501 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1502 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1503 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1504 return SPDK_SCSI_TASK_COMPLETE; 1505 } 1506 1507 if (is_read) { 1508 return spdk_bdev_scsi_read(bdev, bdev_desc, bdev_ch, task, lba, xfer_len); 1509 } else { 1510 return spdk_bdev_scsi_write(bdev, bdev_desc, bdev_ch, task, lba, xfer_len); 1511 } 1512 } 1513 1514 struct spdk_bdev_scsi_unmap_ctx { 1515 struct spdk_scsi_task *task; 1516 struct spdk_scsi_unmap_bdesc desc[DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT]; 1517 uint32_t count; 1518 }; 1519 1520 static int spdk_bdev_scsi_unmap(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1521 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, struct spdk_bdev_scsi_unmap_ctx *ctx); 1522 1523 static void 1524 spdk_bdev_scsi_task_complete_unmap_cmd(struct spdk_bdev_io *bdev_io, bool success, 1525 void *cb_arg) 1526 { 1527 struct spdk_bdev_scsi_unmap_ctx *ctx = cb_arg; 1528 struct spdk_scsi_task *task = ctx->task; 1529 int sc, sk, asc, ascq; 1530 1531 ctx->count--; 1532 1533 task->bdev_io = bdev_io; 1534 1535 if (task->status == SPDK_SCSI_STATUS_GOOD) { 1536 spdk_bdev_io_get_scsi_status(bdev_io, &sc, &sk, &asc, &ascq); 1537 spdk_scsi_task_set_status(task, sc, sk, asc, ascq); 1538 } 1539 1540 if (ctx->count == 0) { 1541 spdk_scsi_lun_complete_task(task->lun, task); 1542 free(ctx); 1543 } 1544 } 1545 1546 static int 1547 __copy_desc(struct spdk_bdev_scsi_unmap_ctx *ctx, uint8_t *data, size_t data_len) 1548 { 1549 uint16_t desc_data_len; 1550 uint16_t desc_count; 1551 1552 if (!data) { 1553 return -EINVAL; 1554 } 1555 1556 if (data_len < 8) { 1557 /* We can't even get the reported length, so fail. */ 1558 return -EINVAL; 1559 } 1560 1561 desc_data_len = from_be16(&data[2]); 1562 desc_count = desc_data_len / 16; 1563 1564 if (desc_data_len > (data_len - 8)) { 1565 SPDK_ERRLOG("Error - desc_data_len (%u) > data_len (%lu) - 8\n", 1566 desc_data_len, data_len); 1567 return -EINVAL; 1568 } 1569 1570 if (desc_count > DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT) { 1571 SPDK_ERRLOG("desc_count (%u) greater than max allowed (%u)\n", 1572 desc_count, DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT); 1573 return -EINVAL; 1574 } 1575 1576 memcpy(ctx->desc, &data[8], desc_data_len); 1577 return desc_count; 1578 } 1579 1580 static void 1581 spdk_bdev_scsi_unmap_resubmit(void *arg) 1582 { 1583 struct spdk_bdev_scsi_unmap_ctx *ctx = arg; 1584 struct spdk_scsi_task *task = ctx->task; 1585 struct spdk_scsi_lun *lun = task->lun; 1586 1587 spdk_bdev_scsi_unmap(lun->bdev, lun->bdev_desc, lun->io_channel, task, ctx); 1588 } 1589 1590 static int 1591 spdk_bdev_scsi_unmap(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1592 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, struct spdk_bdev_scsi_unmap_ctx *ctx) 1593 { 1594 uint8_t *data; 1595 int i, desc_count = -1; 1596 int data_len; 1597 int rc; 1598 1599 assert(task->status == SPDK_SCSI_STATUS_GOOD); 1600 1601 if (ctx == NULL) { 1602 ctx = calloc(1, sizeof(*ctx)); 1603 if (!ctx) { 1604 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1605 SPDK_SCSI_SENSE_NO_SENSE, 1606 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1607 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1608 return SPDK_SCSI_TASK_COMPLETE; 1609 } 1610 1611 ctx->task = task; 1612 ctx->count = 0; 1613 } 1614 1615 1616 if (task->iovcnt == 1) { 1617 data = (uint8_t *)task->iovs[0].iov_base; 1618 data_len = task->iovs[0].iov_len; 1619 desc_count = __copy_desc(ctx, data, data_len); 1620 } else { 1621 data = spdk_scsi_task_gather_data(task, &data_len); 1622 if (data) { 1623 desc_count = __copy_desc(ctx, data, data_len); 1624 spdk_dma_free(data); 1625 } 1626 } 1627 1628 if (desc_count < 0) { 1629 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1630 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1631 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1632 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1633 free(ctx); 1634 return SPDK_SCSI_TASK_COMPLETE; 1635 } 1636 1637 for (i = ctx->count; i < desc_count; i++) { 1638 struct spdk_scsi_unmap_bdesc *desc; 1639 uint64_t offset_blocks; 1640 uint64_t num_blocks; 1641 1642 desc = &ctx->desc[i]; 1643 1644 offset_blocks = from_be64(&desc->lba); 1645 num_blocks = from_be32(&desc->block_count); 1646 1647 if (num_blocks == 0) { 1648 continue; 1649 } 1650 1651 ctx->count++; 1652 rc = spdk_bdev_unmap_blocks(bdev_desc, bdev_ch, offset_blocks, num_blocks, 1653 spdk_bdev_scsi_task_complete_unmap_cmd, ctx); 1654 1655 if (rc) { 1656 if (rc == -ENOMEM) { 1657 spdk_bdev_scsi_queue_io(task, spdk_bdev_scsi_unmap_resubmit, ctx); 1658 /* Unmap was not yet submitted to bdev */ 1659 ctx->count--; 1660 return SPDK_SCSI_TASK_PENDING; 1661 } 1662 SPDK_ERRLOG("SCSI Unmapping failed\n"); 1663 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1664 SPDK_SCSI_SENSE_NO_SENSE, 1665 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1666 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1667 ctx->count--; 1668 /* We can't complete here - we may have to wait for previously 1669 * submitted unmaps to complete */ 1670 break; 1671 } 1672 } 1673 1674 if (ctx->count == 0) { 1675 free(ctx); 1676 return SPDK_SCSI_TASK_COMPLETE; 1677 } 1678 1679 return SPDK_SCSI_TASK_PENDING; 1680 } 1681 1682 static int 1683 spdk_bdev_scsi_process_block(struct spdk_scsi_task *task) 1684 { 1685 struct spdk_scsi_lun *lun = task->lun; 1686 struct spdk_bdev *bdev = lun->bdev; 1687 uint64_t lba; 1688 uint32_t xfer_len; 1689 uint32_t len = 0; 1690 uint8_t *cdb = task->cdb; 1691 1692 /* XXX: We need to support FUA bit for writes! */ 1693 switch (cdb[0]) { 1694 case SPDK_SBC_READ_6: 1695 case SPDK_SBC_WRITE_6: 1696 lba = (uint64_t)cdb[1] << 16; 1697 lba |= (uint64_t)cdb[2] << 8; 1698 lba |= (uint64_t)cdb[3]; 1699 xfer_len = cdb[4]; 1700 if (xfer_len == 0) { 1701 xfer_len = 256; 1702 } 1703 return spdk_bdev_scsi_readwrite(task, lba, xfer_len, 1704 cdb[0] == SPDK_SBC_READ_6); 1705 1706 case SPDK_SBC_READ_10: 1707 case SPDK_SBC_WRITE_10: 1708 lba = from_be32(&cdb[2]); 1709 xfer_len = from_be16(&cdb[7]); 1710 return spdk_bdev_scsi_readwrite(task, lba, xfer_len, 1711 cdb[0] == SPDK_SBC_READ_10); 1712 1713 case SPDK_SBC_READ_12: 1714 case SPDK_SBC_WRITE_12: 1715 lba = from_be32(&cdb[2]); 1716 xfer_len = from_be32(&cdb[6]); 1717 return spdk_bdev_scsi_readwrite(task, lba, xfer_len, 1718 cdb[0] == SPDK_SBC_READ_12); 1719 case SPDK_SBC_READ_16: 1720 case SPDK_SBC_WRITE_16: 1721 lba = from_be64(&cdb[2]); 1722 xfer_len = from_be32(&cdb[10]); 1723 return spdk_bdev_scsi_readwrite(task, lba, xfer_len, 1724 cdb[0] == SPDK_SBC_READ_16); 1725 1726 case SPDK_SBC_READ_CAPACITY_10: { 1727 uint64_t num_blocks = spdk_bdev_get_num_blocks(bdev); 1728 uint8_t buffer[8]; 1729 1730 if (num_blocks - 1 > 0xffffffffULL) { 1731 memset(buffer, 0xff, 4); 1732 } else { 1733 to_be32(buffer, num_blocks - 1); 1734 } 1735 to_be32(&buffer[4], spdk_bdev_get_block_size(bdev)); 1736 1737 len = spdk_min(task->length, sizeof(buffer)); 1738 if (spdk_scsi_task_scatter_data(task, buffer, len) < 0) { 1739 break; 1740 } 1741 1742 task->data_transferred = len; 1743 task->status = SPDK_SCSI_STATUS_GOOD; 1744 break; 1745 } 1746 1747 case SPDK_SPC_SERVICE_ACTION_IN_16: 1748 switch (cdb[1] & 0x1f) { /* SERVICE ACTION */ 1749 case SPDK_SBC_SAI_READ_CAPACITY_16: { 1750 uint8_t buffer[32] = {0}; 1751 1752 to_be64(&buffer[0], spdk_bdev_get_num_blocks(bdev) - 1); 1753 to_be32(&buffer[8], spdk_bdev_get_block_size(bdev)); 1754 /* 1755 * Set the TPE bit to 1 to indicate thin provisioning. 1756 * The position of TPE bit is the 7th bit in 14th byte 1757 * in READ CAPACITY (16) parameter data. 1758 */ 1759 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 1760 buffer[14] |= 1 << 7; 1761 } 1762 1763 len = spdk_min(from_be32(&cdb[10]), sizeof(buffer)); 1764 if (spdk_scsi_task_scatter_data(task, buffer, len) < 0) { 1765 break; 1766 } 1767 1768 task->data_transferred = len; 1769 task->status = SPDK_SCSI_STATUS_GOOD; 1770 break; 1771 } 1772 1773 default: 1774 return SPDK_SCSI_TASK_UNKNOWN; 1775 } 1776 break; 1777 1778 case SPDK_SBC_SYNCHRONIZE_CACHE_10: 1779 case SPDK_SBC_SYNCHRONIZE_CACHE_16: 1780 if (cdb[0] == SPDK_SBC_SYNCHRONIZE_CACHE_10) { 1781 lba = from_be32(&cdb[2]); 1782 len = from_be16(&cdb[7]); 1783 } else { 1784 lba = from_be64(&cdb[2]); 1785 len = from_be32(&cdb[10]); 1786 } 1787 1788 if (len == 0) { 1789 len = spdk_bdev_get_num_blocks(bdev) - lba; 1790 } 1791 1792 return spdk_bdev_scsi_sync(bdev, lun->bdev_desc, lun->io_channel, task, lba, len); 1793 break; 1794 1795 case SPDK_SBC_UNMAP: 1796 return spdk_bdev_scsi_unmap(bdev, lun->bdev_desc, lun->io_channel, task, NULL); 1797 1798 default: 1799 return SPDK_SCSI_TASK_UNKNOWN; 1800 } 1801 1802 return SPDK_SCSI_TASK_COMPLETE; 1803 } 1804 1805 static void 1806 spdk_bdev_scsi_process_block_resubmit(void *arg) 1807 { 1808 struct spdk_scsi_task *task = arg; 1809 1810 spdk_bdev_scsi_process_block(task); 1811 } 1812 1813 static int 1814 spdk_bdev_scsi_check_len(struct spdk_scsi_task *task, int len, int min_len) 1815 { 1816 if (len >= min_len) { 1817 return 0; 1818 } 1819 1820 /* INVALID FIELD IN CDB */ 1821 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1822 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1823 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1824 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1825 return -1; 1826 } 1827 1828 static int 1829 spdk_bdev_scsi_process_primary(struct spdk_scsi_task *task) 1830 { 1831 struct spdk_scsi_lun *lun = task->lun; 1832 struct spdk_bdev *bdev = lun->bdev; 1833 int alloc_len = -1; 1834 int data_len = -1; 1835 uint8_t *cdb = task->cdb; 1836 uint8_t *data = NULL; 1837 int rc = 0; 1838 int pllen, md = 0; 1839 int pf, sp; 1840 int bdlen = 0, llba; 1841 int dbd, pc, page, subpage; 1842 int cmd_parsed = 0; 1843 1844 1845 switch (cdb[0]) { 1846 case SPDK_SPC_INQUIRY: 1847 alloc_len = from_be16(&cdb[3]); 1848 data_len = spdk_max(4096, alloc_len); 1849 data = spdk_dma_zmalloc(data_len, 0, NULL); 1850 assert(data != NULL); 1851 rc = spdk_bdev_scsi_inquiry(bdev, task, cdb, data, data_len); 1852 data_len = spdk_min(rc, data_len); 1853 if (rc < 0) { 1854 break; 1855 } 1856 1857 SPDK_LOGDUMP(SPDK_LOG_SCSI, "INQUIRY", data, data_len); 1858 break; 1859 1860 case SPDK_SPC_REPORT_LUNS: { 1861 int sel; 1862 1863 sel = cdb[2]; 1864 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "sel=%x\n", sel); 1865 1866 alloc_len = from_be32(&cdb[6]); 1867 rc = spdk_bdev_scsi_check_len(task, alloc_len, 16); 1868 if (rc < 0) { 1869 break; 1870 } 1871 1872 data_len = spdk_max(4096, alloc_len); 1873 data = spdk_dma_zmalloc(data_len, 0, NULL); 1874 assert(data != NULL); 1875 rc = spdk_bdev_scsi_report_luns(task->lun, sel, data, data_len); 1876 data_len = rc; 1877 if (rc < 0) { 1878 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1879 SPDK_SCSI_SENSE_NO_SENSE, 1880 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1881 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1882 break; 1883 } 1884 1885 SPDK_LOGDUMP(SPDK_LOG_SCSI, "REPORT LUNS", data, data_len); 1886 break; 1887 } 1888 1889 case SPDK_SPC_MODE_SELECT_6: 1890 case SPDK_SPC_MODE_SELECT_10: 1891 if (cdb[0] == SPDK_SPC_MODE_SELECT_6) { 1892 /* MODE_SELECT(6) must have at least a 4 byte header. */ 1893 md = 4; 1894 pllen = cdb[4]; 1895 } else { 1896 /* MODE_SELECT(10) must have at least an 8 byte header. */ 1897 md = 8; 1898 pllen = from_be16(&cdb[7]); 1899 } 1900 1901 if (pllen == 0) { 1902 break; 1903 } 1904 1905 rc = spdk_bdev_scsi_check_len(task, pllen, md); 1906 if (rc < 0) { 1907 break; 1908 } 1909 1910 data = spdk_scsi_task_gather_data(task, &rc); 1911 if (rc < 0) { 1912 break; 1913 } 1914 1915 data_len = rc; 1916 if (cdb[0] == SPDK_SPC_MODE_SELECT_6) { 1917 rc = spdk_bdev_scsi_check_len(task, data_len, 4); 1918 if (rc >= 0) { 1919 bdlen = data[3]; 1920 } 1921 1922 } else { 1923 rc = spdk_bdev_scsi_check_len(task, data_len, 8); 1924 if (rc >= 0) { 1925 bdlen = from_be16(&data[6]); 1926 } 1927 } 1928 1929 if (rc < 0) { 1930 break; 1931 } 1932 pf = !!(cdb[1] & 0x10); 1933 sp = !!(cdb[1] & 0x1); 1934 1935 /* page data */ 1936 rc = spdk_bdev_scsi_mode_select_page( 1937 bdev, cdb, 1938 pf, sp, 1939 &data[md + bdlen], 1940 pllen - (md + bdlen)); 1941 if (rc < 0) { 1942 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1943 SPDK_SCSI_SENSE_NO_SENSE, 1944 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1945 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1946 break; 1947 } 1948 1949 rc = pllen; 1950 data_len = 0; 1951 break; 1952 1953 case SPDK_SPC_MODE_SENSE_6: 1954 alloc_len = cdb[4]; 1955 md = 6; 1956 /* FALLTHROUGH */ 1957 case SPDK_SPC_MODE_SENSE_10: 1958 llba = 0; 1959 1960 if (md == 0) { 1961 alloc_len = from_be16(&cdb[7]); 1962 llba = !!(cdb[1] & 0x10); 1963 md = 10; 1964 } 1965 1966 dbd = !!(cdb[1] & 0x8); 1967 pc = (cdb[2] & 0xc0) >> 6; 1968 page = cdb[2] & 0x3f; 1969 subpage = cdb[3]; 1970 1971 /* First call with no buffer to discover needed buffer size */ 1972 rc = spdk_bdev_scsi_mode_sense(bdev, md, 1973 cdb, dbd, llba, pc, 1974 page, subpage, 1975 NULL, task); 1976 if (rc < 0) { 1977 break; 1978 } 1979 1980 data_len = rc; 1981 data = spdk_dma_zmalloc(data_len, 0, NULL); 1982 assert(data != NULL); 1983 1984 /* First call with no buffer to discover needed buffer size */ 1985 rc = spdk_bdev_scsi_mode_sense(bdev, md, 1986 cdb, dbd, llba, pc, 1987 page, subpage, 1988 data, task); 1989 if (rc < 0) { 1990 /* INVALID FIELD IN CDB */ 1991 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1992 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1993 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1994 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1995 break; 1996 } 1997 break; 1998 1999 case SPDK_SPC_REQUEST_SENSE: { 2000 int desc; 2001 int sk, asc, ascq; 2002 2003 desc = cdb[1] & 0x1; 2004 if (desc != 0) { 2005 /* INVALID FIELD IN CDB */ 2006 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 2007 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 2008 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 2009 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 2010 break; 2011 } 2012 2013 alloc_len = cdb[4]; 2014 2015 /* NO ADDITIONAL SENSE INFORMATION */ 2016 sk = SPDK_SCSI_SENSE_NO_SENSE; 2017 asc = 0x00; 2018 ascq = 0x00; 2019 2020 spdk_scsi_task_build_sense_data(task, sk, asc, ascq); 2021 2022 data_len = task->sense_data_len; 2023 data = spdk_dma_zmalloc(data_len, 0, NULL); 2024 assert(data != NULL); 2025 memcpy(data, task->sense_data, data_len); 2026 break; 2027 } 2028 2029 case SPDK_SPC_LOG_SELECT: 2030 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "LOG_SELECT\n"); 2031 cmd_parsed = 1; 2032 /* FALLTHROUGH */ 2033 case SPDK_SPC_LOG_SENSE: 2034 if (!cmd_parsed) { 2035 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "LOG_SENSE\n"); 2036 } 2037 2038 /* INVALID COMMAND OPERATION CODE */ 2039 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 2040 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 2041 SPDK_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 2042 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 2043 rc = -1; 2044 break; 2045 2046 case SPDK_SPC_TEST_UNIT_READY: 2047 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "TEST_UNIT_READY\n"); 2048 cmd_parsed = 1; 2049 /* FALLTHROUGH */ 2050 case SPDK_SBC_START_STOP_UNIT: 2051 if (!cmd_parsed) { 2052 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "START_STOP_UNIT\n"); 2053 } 2054 2055 rc = 0; 2056 break; 2057 2058 default: 2059 return SPDK_SCSI_TASK_UNKNOWN; 2060 } 2061 2062 if (rc >= 0 && data_len > 0) { 2063 assert(alloc_len >= 0); 2064 spdk_scsi_task_scatter_data(task, data, spdk_min(alloc_len, data_len)); 2065 rc = spdk_min(data_len, alloc_len); 2066 } 2067 2068 if (rc >= 0) { 2069 task->data_transferred = rc; 2070 task->status = SPDK_SCSI_STATUS_GOOD; 2071 } 2072 2073 if (data) { 2074 spdk_dma_free(data); 2075 } 2076 2077 return SPDK_SCSI_TASK_COMPLETE; 2078 } 2079 2080 int 2081 spdk_bdev_scsi_execute(struct spdk_scsi_task *task) 2082 { 2083 int rc; 2084 2085 if ((rc = spdk_bdev_scsi_process_block(task)) == SPDK_SCSI_TASK_UNKNOWN) { 2086 if ((rc = spdk_bdev_scsi_process_primary(task)) == SPDK_SCSI_TASK_UNKNOWN) { 2087 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "unsupported SCSI OP=0x%x\n", task->cdb[0]); 2088 /* INVALID COMMAND OPERATION CODE */ 2089 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 2090 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 2091 SPDK_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 2092 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 2093 return SPDK_SCSI_TASK_COMPLETE; 2094 } 2095 } 2096 2097 return rc; 2098 } 2099 2100 static void 2101 spdk_bdev_scsi_reset_resubmit(void *arg) 2102 { 2103 struct spdk_scsi_task *task = arg; 2104 2105 spdk_bdev_scsi_reset(task); 2106 } 2107 2108 void 2109 spdk_bdev_scsi_reset(struct spdk_scsi_task *task) 2110 { 2111 struct spdk_scsi_lun *lun = task->lun; 2112 int rc; 2113 2114 rc = spdk_bdev_reset(lun->bdev_desc, lun->io_channel, spdk_bdev_scsi_task_complete_mgmt, task); 2115 if (rc == -ENOMEM) { 2116 spdk_bdev_scsi_queue_io(task, spdk_bdev_scsi_reset_resubmit, task); 2117 } 2118 } 2119