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