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