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