1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (C) 2008-2012 Daisuke Aoyama <aoyama@peach.ne.jp>. 5 * Copyright (c) Intel Corporation. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * * Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * * Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the 17 * distribution. 18 * * Neither the name of Intel Corporation nor the names of its 19 * contributors may be used to endorse or promote products derived 20 * from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 #include "scsi_internal.h" 36 37 /* 38 * TODO: move bdev SCSI error code translation tests to bdev unit test 39 * and remove this include. 40 */ 41 #include "spdk/bdev_module.h" 42 43 #include "spdk/env.h" 44 #include "spdk/bdev.h" 45 #include "spdk/endian.h" 46 #include "spdk/likely.h" 47 #include "spdk/string.h" 48 #include "spdk/util.h" 49 50 #define SPDK_WORK_BLOCK_SIZE (4ULL * 1024ULL * 1024ULL) 51 #define SPDK_WORK_ATS_BLOCK_SIZE (1ULL * 1024ULL * 1024ULL) 52 #define MAX_SERIAL_STRING 32 53 54 #define DEFAULT_DISK_VENDOR "INTEL" 55 #define DEFAULT_DISK_REVISION "0001" 56 #define DEFAULT_DISK_ROTATION_RATE 1 /* Non-rotating medium */ 57 #define DEFAULT_DISK_FORM_FACTOR 0x02 /* 3.5 inch */ 58 #define DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT 256 59 60 #define INQUIRY_OFFSET(field) offsetof(struct spdk_scsi_cdb_inquiry_data, field) + \ 61 sizeof(((struct spdk_scsi_cdb_inquiry_data *)0x0)->field) 62 63 static void spdk_bdev_scsi_process_block_resubmit(void *arg); 64 65 static int 66 spdk_hex2bin(char ch) 67 { 68 if ((ch >= '0') && (ch <= '9')) { 69 return ch - '0'; 70 } 71 ch = tolower(ch); 72 if ((ch >= 'a') && (ch <= 'f')) { 73 return ch - 'a' + 10; 74 } 75 return (int)ch; 76 } 77 78 static void 79 spdk_bdev_scsi_set_naa_ieee_extended(const char *name, uint8_t *buf) 80 { 81 int i, value, count = 0; 82 uint64_t local_value; 83 84 for (i = 0; (i < 16) && (name[i] != '\0'); i++) { 85 value = spdk_hex2bin(name[i]); 86 if (i % 2) { 87 buf[count++] |= value << 4; 88 } else { 89 buf[count] = value; 90 } 91 } 92 93 local_value = *(uint64_t *)buf; 94 /* 95 * see spc3r23 7.6.3.6.2, 96 * NAA IEEE Extended identifer format 97 */ 98 local_value &= 0x0fff000000ffffffull; 99 /* NAA 02, and 00 03 47 for IEEE Intel */ 100 local_value |= 0x2000000347000000ull; 101 102 to_be64((void *)buf, local_value); 103 } 104 105 static int 106 spdk_bdev_scsi_report_luns(struct spdk_scsi_lun *lun, 107 int sel, uint8_t *data, int alloc_len) 108 { 109 struct spdk_scsi_dev *dev; 110 uint64_t fmt_lun, lun_id, method; 111 int hlen, len = 0; 112 int i; 113 114 if (alloc_len < 8) { 115 return -1; 116 } 117 118 if (sel == 0x00) { 119 /* logical unit with addressing method */ 120 } else if (sel == 0x01) { 121 /* well known logical unit */ 122 } else if (sel == 0x02) { 123 /* logical unit */ 124 } else { 125 return -1; 126 } 127 128 /* LUN LIST LENGTH */ 129 memset(data, 0, 4); 130 131 /* Reserved */ 132 memset(&data[4], 0, 4); 133 hlen = 8; 134 135 dev = lun->dev; 136 137 for (i = 0; i < SPDK_SCSI_DEV_MAX_LUN; i++) { 138 if (dev->lun[i] == NULL) { 139 continue; 140 } 141 142 if (alloc_len - (hlen + len) < 8) { 143 return -1; 144 } 145 146 lun_id = (uint64_t)i; 147 148 if (SPDK_SCSI_DEV_MAX_LUN <= 0x0100) { 149 /* below 256 */ 150 method = 0x00U; 151 fmt_lun = (method & 0x03U) << 62; 152 fmt_lun |= (lun_id & 0x00ffU) << 48; 153 } else if (SPDK_SCSI_DEV_MAX_LUN <= 0x4000) { 154 /* below 16384 */ 155 method = 0x01U; 156 fmt_lun = (method & 0x03U) << 62; 157 fmt_lun |= (lun_id & 0x3fffU) << 48; 158 } else { 159 /* XXX */ 160 fmt_lun = 0; 161 } 162 163 /* LUN */ 164 to_be64(&data[hlen + len], fmt_lun); 165 len += 8; 166 } 167 168 /* LUN LIST LENGTH */ 169 to_be32(data, len); 170 171 return hlen + len; 172 } 173 174 static int 175 spdk_bdev_scsi_pad_scsi_name(char *dst, const char *name) 176 { 177 size_t len; 178 179 len = strlen(name); 180 memcpy(dst, name, len); 181 do { 182 dst[len++] = '\0'; 183 } while (len & 3); 184 185 return len; 186 } 187 188 static int 189 spdk_bdev_scsi_inquiry(struct spdk_bdev *bdev, struct spdk_scsi_task *task, 190 uint8_t *cdb, uint8_t *data, uint16_t alloc_len) 191 { 192 struct spdk_scsi_lun *lun; 193 struct spdk_scsi_dev *dev; 194 struct spdk_scsi_port *port; 195 uint32_t blocks, optimal_blocks; 196 int hlen = 0, plen, plen2; 197 uint16_t len = 0; 198 int pc; 199 int pd; 200 int evpd; 201 int i; 202 struct spdk_scsi_cdb_inquiry *inq = (struct spdk_scsi_cdb_inquiry *)cdb; 203 204 /* standard inquiry command at lease with 36 Bytes */ 205 if (alloc_len < 0x24) { 206 goto inq_error; 207 } 208 209 lun = task->lun; 210 dev = lun->dev; 211 port = task->target_port; 212 213 pd = SPDK_SPC_PERIPHERAL_DEVICE_TYPE_DISK; 214 pc = inq->page_code; 215 evpd = inq->evpd & 0x1; 216 217 if (!evpd && pc) { 218 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 219 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 220 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 221 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 222 return -1; 223 } 224 225 if (evpd) { 226 struct spdk_scsi_vpd_page *vpage = (struct spdk_scsi_vpd_page *)data; 227 228 /* PERIPHERAL QUALIFIER(7-5) PERIPHERAL DEVICE TYPE(4-0) */ 229 vpage->peripheral_device_type = pd; 230 vpage->peripheral_qualifier = SPDK_SPC_PERIPHERAL_QUALIFIER_CONNECTED; 231 /* PAGE CODE */ 232 vpage->page_code = pc; 233 234 /* Vital product data */ 235 switch (pc) { 236 case SPDK_SPC_VPD_SUPPORTED_VPD_PAGES: 237 hlen = 4; 238 239 vpage->params[0] = SPDK_SPC_VPD_SUPPORTED_VPD_PAGES; 240 vpage->params[1] = SPDK_SPC_VPD_UNIT_SERIAL_NUMBER; 241 vpage->params[2] = SPDK_SPC_VPD_DEVICE_IDENTIFICATION; 242 vpage->params[3] = SPDK_SPC_VPD_MANAGEMENT_NETWORK_ADDRESSES; 243 vpage->params[4] = SPDK_SPC_VPD_EXTENDED_INQUIRY_DATA; 244 vpage->params[5] = SPDK_SPC_VPD_MODE_PAGE_POLICY; 245 vpage->params[6] = SPDK_SPC_VPD_SCSI_PORTS; 246 vpage->params[7] = SPDK_SPC_VPD_BLOCK_LIMITS; 247 vpage->params[8] = SPDK_SPC_VPD_BLOCK_DEV_CHARS; 248 len = 9; 249 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 250 vpage->params[9] = SPDK_SPC_VPD_BLOCK_THIN_PROVISION; 251 len++; 252 } 253 254 /* PAGE LENGTH */ 255 to_be16(vpage->alloc_len, len); 256 break; 257 258 case SPDK_SPC_VPD_UNIT_SERIAL_NUMBER: { 259 const char *name = spdk_bdev_get_name(bdev); 260 261 hlen = 4; 262 263 /* PRODUCT SERIAL NUMBER */ 264 len = strlen(name) + 1; 265 if (len > MAX_SERIAL_STRING) { 266 len = MAX_SERIAL_STRING; 267 } 268 269 memcpy(vpage->params, name, len - 1); 270 vpage->params[len - 1] = 0; 271 272 /* PAGE LENGTH */ 273 to_be16(vpage->alloc_len, len); 274 break; 275 } 276 277 case SPDK_SPC_VPD_DEVICE_IDENTIFICATION: { 278 const char *name = spdk_bdev_get_name(bdev); 279 const char *product_name = spdk_bdev_get_product_name(bdev); 280 uint8_t protocol_id = dev->protocol_id; 281 uint8_t *buf = vpage->params; 282 struct spdk_scsi_desig_desc *desig; 283 284 hlen = 4; 285 286 /* Check total length by calculated how much space all entries take */ 287 len = sizeof(struct spdk_scsi_desig_desc) + 8; 288 len += sizeof(struct spdk_scsi_desig_desc) + 8 + 16 + MAX_SERIAL_STRING; 289 len += sizeof(struct spdk_scsi_desig_desc) + SPDK_SCSI_DEV_MAX_NAME + 1; 290 len += sizeof(struct spdk_scsi_desig_desc) + SPDK_SCSI_PORT_MAX_NAME_LENGTH; 291 len += sizeof(struct spdk_scsi_desig_desc) + 4; 292 len += sizeof(struct spdk_scsi_desig_desc) + 4; 293 len += sizeof(struct spdk_scsi_desig_desc) + 4; 294 if (sizeof(struct spdk_scsi_vpd_page) + len > alloc_len) { 295 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 296 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 297 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 298 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 299 return -1; 300 } 301 302 /* Now fill out the designator array */ 303 304 /* NAA designator */ 305 desig = (struct spdk_scsi_desig_desc *)buf; 306 desig->code_set = SPDK_SPC_VPD_CODE_SET_BINARY; 307 desig->protocol_id = protocol_id; 308 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_NAA; 309 desig->association = SPDK_SPC_VPD_ASSOCIATION_LOGICAL_UNIT; 310 desig->reserved0 = 0; 311 desig->piv = 1; 312 desig->reserved1 = 0; 313 desig->len = 8; 314 spdk_bdev_scsi_set_naa_ieee_extended(name, desig->desig); 315 len = sizeof(struct spdk_scsi_desig_desc) + 8; 316 317 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len; 318 319 /* T10 Vendor ID designator */ 320 desig = (struct spdk_scsi_desig_desc *)buf; 321 desig->code_set = SPDK_SPC_VPD_CODE_SET_ASCII; 322 desig->protocol_id = protocol_id; 323 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_T10_VENDOR_ID; 324 desig->association = SPDK_SPC_VPD_ASSOCIATION_LOGICAL_UNIT; 325 desig->reserved0 = 0; 326 desig->piv = 1; 327 desig->reserved1 = 0; 328 desig->len = 8 + 16 + MAX_SERIAL_STRING; 329 spdk_strcpy_pad(desig->desig, DEFAULT_DISK_VENDOR, 8, ' '); 330 spdk_strcpy_pad(&desig->desig[8], product_name, 16, ' '); 331 spdk_strcpy_pad(&desig->desig[24], name, MAX_SERIAL_STRING, ' '); 332 len += sizeof(struct spdk_scsi_desig_desc) + 8 + 16 + MAX_SERIAL_STRING; 333 334 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len; 335 336 /* SCSI Device Name designator */ 337 desig = (struct spdk_scsi_desig_desc *)buf; 338 desig->code_set = SPDK_SPC_VPD_CODE_SET_UTF8; 339 desig->protocol_id = protocol_id; 340 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME; 341 desig->association = SPDK_SPC_VPD_ASSOCIATION_TARGET_DEVICE; 342 desig->reserved0 = 0; 343 desig->piv = 1; 344 desig->reserved1 = 0; 345 desig->len = spdk_bdev_scsi_pad_scsi_name(desig->desig, dev->name); 346 len += sizeof(struct spdk_scsi_desig_desc) + desig->len; 347 348 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len; 349 350 /* SCSI Port Name designator */ 351 desig = (struct spdk_scsi_desig_desc *)buf; 352 desig->code_set = SPDK_SPC_VPD_CODE_SET_UTF8; 353 desig->protocol_id = protocol_id; 354 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME; 355 desig->association = SPDK_SPC_VPD_ASSOCIATION_TARGET_PORT; 356 desig->reserved0 = 0; 357 desig->piv = 1; 358 desig->reserved1 = 0; 359 desig->len = snprintf(desig->desig, SPDK_SCSI_PORT_MAX_NAME_LENGTH, "%s", port->name); 360 len += sizeof(struct spdk_scsi_desig_desc) + desig->len; 361 362 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len; 363 364 /* Relative Target Port designator */ 365 desig = (struct spdk_scsi_desig_desc *)buf; 366 desig->code_set = SPDK_SPC_VPD_CODE_SET_BINARY; 367 desig->protocol_id = protocol_id; 368 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_RELATIVE_TARGET_PORT; 369 desig->association = SPDK_SPC_VPD_ASSOCIATION_TARGET_PORT; 370 desig->reserved0 = 0; 371 desig->piv = 1; 372 desig->reserved1 = 0; 373 desig->len = 4; 374 memset(desig->desig, 0, 2); /* Reserved */ 375 to_be16(&desig->desig[2], port->index); 376 len += sizeof(struct spdk_scsi_desig_desc) + desig->len; 377 378 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len; 379 380 /* Target port group designator */ 381 desig = (struct spdk_scsi_desig_desc *)buf; 382 desig->code_set = SPDK_SPC_VPD_CODE_SET_BINARY; 383 desig->protocol_id = protocol_id; 384 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_TARGET_PORT_GROUP; 385 desig->association = SPDK_SPC_VPD_ASSOCIATION_TARGET_PORT; 386 desig->reserved0 = 0; 387 desig->piv = 1; 388 desig->reserved1 = 0; 389 desig->len = 4; 390 memset(desig->desig, 0, 4); 391 len += sizeof(struct spdk_scsi_desig_desc) + desig->len; 392 393 buf += sizeof(struct spdk_scsi_desig_desc) + desig->len; 394 395 /* Logical unit group designator */ 396 desig = (struct spdk_scsi_desig_desc *)buf; 397 desig->code_set = SPDK_SPC_VPD_CODE_SET_BINARY; 398 desig->protocol_id = protocol_id; 399 desig->type = SPDK_SPC_VPD_IDENTIFIER_TYPE_LOGICAL_UNIT_GROUP; 400 desig->association = SPDK_SPC_VPD_ASSOCIATION_LOGICAL_UNIT; 401 desig->reserved0 = 0; 402 desig->piv = 1; 403 desig->reserved1 = 0; 404 desig->len = 4; 405 memset(desig->desig, 0, 2); /* Reserved */ 406 to_be16(&desig->desig[2], dev->id); 407 len += sizeof(struct spdk_scsi_desig_desc) + desig->len; 408 409 to_be16(vpage->alloc_len, len); 410 411 break; 412 } 413 414 case SPDK_SPC_VPD_EXTENDED_INQUIRY_DATA: { 415 struct spdk_scsi_vpd_ext_inquiry *vext = (struct spdk_scsi_vpd_ext_inquiry *)vpage; 416 417 memset(vext, 0, sizeof(*vext)); 418 hlen = 4; 419 420 /* RTO(3) GRD_CHK(2) APP_CHK(1) REF_CHK(0) */ 421 422 /* GROUP_SUP(4) PRIOR_SUP(3) HEADSUP(2) ORDSUP(1) SIMPSUP(0) */ 423 vext->sup = SPDK_SCSI_VEXT_HEADSUP | SPDK_SCSI_VEXT_SIMPSUP; 424 425 /* NV_SUP(1) V_SUP(0) */ 426 427 /* Reserved[7-63] */ 428 429 len = 64 - hlen; 430 431 /* PAGE LENGTH */ 432 to_be16(vpage->alloc_len, len); 433 break; 434 } 435 436 case SPDK_SPC_VPD_MANAGEMENT_NETWORK_ADDRESSES: 437 /* PAGE LENGTH */ 438 hlen = 4; 439 440 to_be16(vpage->alloc_len, len); 441 break; 442 443 case SPDK_SPC_VPD_MODE_PAGE_POLICY: { 444 struct spdk_scsi_mpage_policy_desc *pdesc = 445 (struct spdk_scsi_mpage_policy_desc *)vpage->params; 446 447 hlen = 4; 448 449 /* Mode page policy descriptor 1 */ 450 451 /* POLICY PAGE CODE(5-0) */ 452 /* all page code */ 453 pdesc->page_code = 0x3f; 454 455 /* POLICY SUBPAGE CODE */ 456 /* all sub page */ 457 pdesc->sub_page_code = 0xff; 458 459 /* MLUS(7) MODE PAGE POLICY(1-0) */ 460 /* MLUS own copy */ 461 /* Shared MODE PAGE policy */ 462 pdesc->policy = 0; 463 /* Reserved */ 464 pdesc->reserved = 0; 465 466 len += 4; 467 468 to_be16(vpage->alloc_len, len); 469 break; 470 } 471 472 case SPDK_SPC_VPD_SCSI_PORTS: { 473 /* PAGE LENGTH */ 474 hlen = 4; 475 476 /* Identification descriptor list */ 477 for (i = 0; i < SPDK_SCSI_DEV_MAX_PORTS; i++) { 478 struct spdk_scsi_port_desc *sdesc; 479 struct spdk_scsi_tgt_port_desc *pdesc; 480 481 if (!dev->port[i].is_used) { 482 continue; 483 } 484 485 /* Identification descriptor N */ 486 sdesc = (struct spdk_scsi_port_desc *)&vpage->params[len]; 487 488 /* Reserved */ 489 sdesc->reserved = 0; 490 491 /* RELATIVE PORT IDENTIFIER */ 492 to_be16(&sdesc->rel_port_id, dev->port[i].index); 493 494 /* Reserved */ 495 sdesc->reserved2 = 0; 496 497 /* INITIATOR PORT TRANSPORTID LENGTH */ 498 sdesc->init_port_len = 0; 499 500 /* Reserved */ 501 sdesc->init_port_id = 0; 502 503 /* TARGET PORT DESCRIPTORS LENGTH */ 504 sdesc->tgt_desc_len = 0; 505 506 len += 12; 507 508 plen2 = 0; 509 /* Target port descriptor 1 */ 510 pdesc = (struct spdk_scsi_tgt_port_desc *)sdesc->tgt_desc; 511 512 /* PROTOCOL IDENTIFIER(7-4) CODE SET(3-0) */ 513 pdesc->code_set = 514 SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI << 4 | 515 SPDK_SPC_VPD_CODE_SET_UTF8; 516 517 /* PIV(7) ASSOCIATION(5-4) IDENTIFIER TYPE(3-0) */ 518 pdesc->desig_type = SPDK_SPC_VPD_DESIG_PIV | 519 SPDK_SPC_VPD_ASSOCIATION_TARGET_PORT << 4 | 520 SPDK_SPC_VPD_IDENTIFIER_TYPE_SCSI_NAME; 521 522 /* Reserved */ 523 pdesc->reserved = 0; 524 525 /* IDENTIFIER */ 526 plen = snprintf((char *)pdesc->designator, 527 SPDK_SCSI_PORT_MAX_NAME_LENGTH, "%s", 528 dev->port[i].name); 529 pdesc->len = plen; 530 531 plen2 += 4 + plen; 532 533 /* TARGET PORT DESCRIPTORS LENGTH */ 534 to_be16(&sdesc->tgt_desc_len, plen2); 535 536 len += plen2; 537 } 538 539 to_be16(vpage->alloc_len, len); 540 break; 541 } 542 543 case SPDK_SPC_VPD_BLOCK_LIMITS: { 544 uint32_t block_size = spdk_bdev_get_block_size(bdev); 545 546 /* PAGE LENGTH */ 547 memset(&data[4], 0, 60); 548 549 hlen = 4; 550 551 /* WSNZ(0) */ 552 /* support zero length in WRITE SAME */ 553 554 /* MAXIMUM COMPARE AND WRITE LENGTH */ 555 blocks = SPDK_WORK_ATS_BLOCK_SIZE / block_size; 556 557 if (blocks > 0xff) { 558 blocks = 0xff; 559 } 560 561 data[5] = (uint8_t)blocks; 562 563 /* force align to 4KB */ 564 if (block_size < 4096) { 565 optimal_blocks = 4096 / block_size; 566 } else { 567 optimal_blocks = 1; 568 } 569 570 /* OPTIMAL TRANSFER LENGTH GRANULARITY */ 571 to_be16(&data[6], optimal_blocks); 572 573 blocks = SPDK_WORK_BLOCK_SIZE / block_size; 574 575 /* MAXIMUM TRANSFER LENGTH */ 576 to_be32(&data[8], blocks); 577 /* OPTIMAL TRANSFER LENGTH */ 578 to_be32(&data[12], blocks); 579 580 /* MAXIMUM PREFETCH XDREAD XDWRITE TRANSFER LENGTH */ 581 582 len = 20 - hlen; 583 584 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 585 /* 586 * MAXIMUM UNMAP LBA COUNT: indicates the 587 * maximum number of LBAs that may be 588 * unmapped by an UNMAP command. 589 */ 590 /* For now, choose 4MB as the maximum. */ 591 to_be32(&data[20], 4194304); 592 593 /* 594 * MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT: 595 * indicates the maximum number of UNMAP 596 * block descriptors that shall be contained 597 * in the parameter data transferred to the 598 * device server for an UNMAP command. 599 * The bdev layer automatically splits unmap 600 * requests, so pick an arbitrary high number here. 601 */ 602 to_be32(&data[24], DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT); 603 604 /* 605 * The UGAVALID bit is left as 0 which means neither the 606 * OPTIMAL UNMAP GRANULARITY nor the UNMAP GRANULARITY 607 * ALIGNMENT fields are valid. 608 */ 609 610 /* 611 * MAXIMUM WRITE SAME LENGTH: indicates the 612 * maximum number of contiguous logical blocks 613 * that the device server allows to be unmapped 614 * or written in a single WRITE SAME command. 615 */ 616 to_be64(&data[36], 512); 617 618 /* Reserved */ 619 /* not specified */ 620 len = 64 - hlen; 621 } 622 623 to_be16(vpage->alloc_len, len); 624 break; 625 } 626 627 case SPDK_SPC_VPD_BLOCK_DEV_CHARS: { 628 /* PAGE LENGTH */ 629 hlen = 4; 630 len = 64 - hlen; 631 632 to_be16(&data[4], DEFAULT_DISK_ROTATION_RATE); 633 634 /* Reserved */ 635 data[6] = 0; 636 /* NOMINAL FORM FACTOR(3-0) */ 637 data[7] = DEFAULT_DISK_FORM_FACTOR << 4; 638 /* Reserved */ 639 memset(&data[8], 0, 64 - 8); 640 641 to_be16(vpage->alloc_len, len); 642 break; 643 } 644 645 case SPDK_SPC_VPD_BLOCK_THIN_PROVISION: { 646 if (!spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 647 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_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 uint64_t 1319 _bytes_to_blocks(uint32_t block_size, uint64_t offset_bytes, uint64_t *offset_blocks, 1320 uint64_t num_bytes, uint64_t *num_blocks) 1321 { 1322 uint8_t shift_cnt; 1323 1324 /* Avoid expensive div operations if possible. These spdk_u32 functions are very cheap. */ 1325 if (spdk_likely(spdk_u32_is_pow2(block_size))) { 1326 shift_cnt = spdk_u32log2(block_size); 1327 *offset_blocks = offset_bytes >> shift_cnt; 1328 *num_blocks = num_bytes >> shift_cnt; 1329 return (offset_bytes - (*offset_blocks << shift_cnt)) | 1330 (num_bytes - (*num_blocks << shift_cnt)); 1331 } else { 1332 *offset_blocks = offset_bytes / block_size; 1333 *num_blocks = num_bytes / block_size; 1334 return (offset_bytes % block_size) | (num_bytes % block_size); 1335 } 1336 } 1337 1338 static int 1339 spdk_bdev_scsi_read(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1340 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, 1341 uint64_t lba) 1342 { 1343 uint64_t offset_blocks, num_blocks; 1344 int rc; 1345 1346 if (_bytes_to_blocks(spdk_bdev_get_block_size(bdev), task->offset, &offset_blocks, 1347 task->length, &num_blocks) != 0) { 1348 SPDK_ERRLOG("task's offset %" PRIu64 " or length %" PRIu32 " is not block multiple\n", 1349 task->offset, task->length); 1350 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1351 SPDK_SCSI_SENSE_NO_SENSE, 1352 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1353 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1354 return SPDK_SCSI_TASK_COMPLETE; 1355 } 1356 1357 offset_blocks += lba; 1358 1359 SPDK_DEBUGLOG(SPDK_LOG_SCSI, 1360 "Read: lba=%"PRIu64", len=%"PRIu64"\n", 1361 offset_blocks, num_blocks); 1362 1363 rc = spdk_bdev_readv_blocks(bdev_desc, bdev_ch, task->iovs, task->iovcnt, 1364 offset_blocks, num_blocks, 1365 spdk_bdev_scsi_task_complete_cmd, task); 1366 1367 if (rc) { 1368 if (rc == -ENOMEM) { 1369 spdk_bdev_scsi_queue_io(task, spdk_bdev_scsi_process_block_resubmit, task); 1370 return SPDK_SCSI_TASK_PENDING; 1371 } 1372 SPDK_ERRLOG("spdk_bdev_readv_blocks() failed\n"); 1373 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1374 SPDK_SCSI_SENSE_NO_SENSE, 1375 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1376 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1377 return SPDK_SCSI_TASK_COMPLETE; 1378 } 1379 1380 task->data_transferred = task->length; 1381 return SPDK_SCSI_TASK_PENDING; 1382 } 1383 1384 static int 1385 spdk_bdev_scsi_write(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1386 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, 1387 uint64_t lba) 1388 { 1389 uint64_t blen; 1390 uint64_t offset; 1391 int rc; 1392 1393 blen = spdk_bdev_get_block_size(bdev); 1394 offset = lba * blen; 1395 1396 SPDK_DEBUGLOG(SPDK_LOG_SCSI, 1397 "Write: lba=%"PRIu64", len=%lu\n", 1398 lba, task->length / blen); 1399 1400 offset += task->offset; 1401 rc = spdk_bdev_writev(bdev_desc, bdev_ch, task->iovs, 1402 task->iovcnt, offset, task->length, 1403 spdk_bdev_scsi_task_complete_cmd, 1404 task); 1405 1406 if (rc) { 1407 if (rc == -ENOMEM) { 1408 spdk_bdev_scsi_queue_io(task, spdk_bdev_scsi_process_block_resubmit, task); 1409 return SPDK_SCSI_TASK_PENDING; 1410 } 1411 SPDK_ERRLOG("spdk_bdev_writev failed\n"); 1412 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1413 SPDK_SCSI_SENSE_NO_SENSE, 1414 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1415 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1416 return SPDK_SCSI_TASK_COMPLETE; 1417 } 1418 1419 task->data_transferred = task->length; 1420 return SPDK_SCSI_TASK_PENDING; 1421 } 1422 1423 static int 1424 spdk_bdev_scsi_sync(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1425 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, 1426 uint64_t lba, uint32_t num_blocks) 1427 { 1428 uint64_t bdev_num_blocks; 1429 int rc; 1430 1431 if (num_blocks == 0) { 1432 return SPDK_SCSI_TASK_COMPLETE; 1433 } 1434 1435 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev); 1436 1437 if (lba >= bdev_num_blocks || num_blocks > bdev_num_blocks || 1438 lba > (bdev_num_blocks - num_blocks)) { 1439 SPDK_ERRLOG("end of media\n"); 1440 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1441 SPDK_SCSI_SENSE_NO_SENSE, 1442 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1443 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1444 return SPDK_SCSI_TASK_COMPLETE; 1445 } 1446 1447 rc = spdk_bdev_flush_blocks(bdev_desc, bdev_ch, lba, num_blocks, 1448 spdk_bdev_scsi_task_complete_cmd, task); 1449 1450 if (rc) { 1451 if (rc == -ENOMEM) { 1452 spdk_bdev_scsi_queue_io(task, spdk_bdev_scsi_process_block_resubmit, task); 1453 return SPDK_SCSI_TASK_PENDING; 1454 } 1455 SPDK_ERRLOG("spdk_bdev_flush_blocks() failed\n"); 1456 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1457 SPDK_SCSI_SENSE_NO_SENSE, 1458 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1459 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1460 return SPDK_SCSI_TASK_COMPLETE; 1461 } 1462 task->data_transferred = 0; 1463 return SPDK_SCSI_TASK_PENDING; 1464 } 1465 1466 static int 1467 spdk_bdev_scsi_readwrite(struct spdk_scsi_task *task, 1468 uint64_t lba, uint32_t xfer_len, bool is_read) 1469 { 1470 struct spdk_scsi_lun *lun = task->lun; 1471 struct spdk_bdev *bdev = lun->bdev; 1472 struct spdk_bdev_desc *bdev_desc = lun->bdev_desc; 1473 struct spdk_io_channel *bdev_ch = lun->io_channel; 1474 uint64_t bdev_num_blocks; 1475 uint32_t max_xfer_len, block_size; 1476 1477 task->data_transferred = 0; 1478 1479 if (spdk_unlikely(task->dxfer_dir != SPDK_SCSI_DIR_NONE && 1480 task->dxfer_dir != (is_read ? SPDK_SCSI_DIR_FROM_DEV : SPDK_SCSI_DIR_TO_DEV))) { 1481 SPDK_ERRLOG("Incorrect data direction\n"); 1482 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1483 SPDK_SCSI_SENSE_NO_SENSE, 1484 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1485 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1486 return SPDK_SCSI_TASK_COMPLETE; 1487 } 1488 1489 bdev_num_blocks = spdk_bdev_get_num_blocks(bdev); 1490 if (spdk_unlikely(bdev_num_blocks <= lba || bdev_num_blocks - lba < xfer_len)) { 1491 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "end of media\n"); 1492 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1493 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1494 SPDK_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 1495 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1496 return SPDK_SCSI_TASK_COMPLETE; 1497 } 1498 1499 if (spdk_unlikely(xfer_len == 0)) { 1500 task->status = SPDK_SCSI_STATUS_GOOD; 1501 return SPDK_SCSI_TASK_COMPLETE; 1502 } 1503 1504 block_size = spdk_bdev_get_block_size(bdev); 1505 1506 /* Transfer Length is limited to the Block Limits VPD page Maximum Transfer Length */ 1507 max_xfer_len = SPDK_WORK_BLOCK_SIZE / block_size; 1508 if (spdk_unlikely(xfer_len > max_xfer_len)) { 1509 SPDK_ERRLOG("xfer_len %" PRIu32 " > maximum transfer length %" PRIu32 "\n", 1510 xfer_len, max_xfer_len); 1511 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1512 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1513 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1514 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1515 return SPDK_SCSI_TASK_COMPLETE; 1516 } 1517 1518 if (is_read) { 1519 return spdk_bdev_scsi_read(bdev, bdev_desc, bdev_ch, task, lba); 1520 } else { 1521 /* Additional check for Transfer Length */ 1522 if (xfer_len * block_size > task->transfer_len) { 1523 SPDK_ERRLOG("xfer_len %" PRIu32 " * block_size %" PRIu32 " > transfer_len %u\n", 1524 xfer_len, block_size, task->transfer_len); 1525 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1526 SPDK_SCSI_SENSE_NO_SENSE, 1527 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1528 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1529 return SPDK_SCSI_TASK_COMPLETE; 1530 } 1531 1532 return spdk_bdev_scsi_write(bdev, bdev_desc, bdev_ch, task, lba); 1533 } 1534 } 1535 1536 struct spdk_bdev_scsi_unmap_ctx { 1537 struct spdk_scsi_task *task; 1538 struct spdk_scsi_unmap_bdesc desc[DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT]; 1539 uint32_t count; 1540 }; 1541 1542 static int spdk_bdev_scsi_unmap(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1543 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, struct spdk_bdev_scsi_unmap_ctx *ctx); 1544 1545 static void 1546 spdk_bdev_scsi_task_complete_unmap_cmd(struct spdk_bdev_io *bdev_io, bool success, 1547 void *cb_arg) 1548 { 1549 struct spdk_bdev_scsi_unmap_ctx *ctx = cb_arg; 1550 struct spdk_scsi_task *task = ctx->task; 1551 int sc, sk, asc, ascq; 1552 1553 ctx->count--; 1554 1555 task->bdev_io = bdev_io; 1556 1557 if (task->status == SPDK_SCSI_STATUS_GOOD) { 1558 spdk_bdev_io_get_scsi_status(bdev_io, &sc, &sk, &asc, &ascq); 1559 spdk_scsi_task_set_status(task, sc, sk, asc, ascq); 1560 } 1561 1562 if (ctx->count == 0) { 1563 spdk_scsi_lun_complete_task(task->lun, task); 1564 free(ctx); 1565 } 1566 } 1567 1568 static int 1569 __copy_desc(struct spdk_bdev_scsi_unmap_ctx *ctx, uint8_t *data, size_t data_len) 1570 { 1571 uint16_t desc_data_len; 1572 uint16_t desc_count; 1573 1574 if (!data) { 1575 return -EINVAL; 1576 } 1577 1578 if (data_len < 8) { 1579 /* We can't even get the reported length, so fail. */ 1580 return -EINVAL; 1581 } 1582 1583 desc_data_len = from_be16(&data[2]); 1584 desc_count = desc_data_len / 16; 1585 1586 if (desc_data_len > (data_len - 8)) { 1587 SPDK_ERRLOG("Error - desc_data_len (%u) > data_len (%lu) - 8\n", 1588 desc_data_len, data_len); 1589 return -EINVAL; 1590 } 1591 1592 if (desc_count > DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT) { 1593 SPDK_ERRLOG("desc_count (%u) greater than max allowed (%u)\n", 1594 desc_count, DEFAULT_MAX_UNMAP_BLOCK_DESCRIPTOR_COUNT); 1595 return -EINVAL; 1596 } 1597 1598 memcpy(ctx->desc, &data[8], desc_data_len); 1599 return desc_count; 1600 } 1601 1602 static void 1603 spdk_bdev_scsi_unmap_resubmit(void *arg) 1604 { 1605 struct spdk_bdev_scsi_unmap_ctx *ctx = arg; 1606 struct spdk_scsi_task *task = ctx->task; 1607 struct spdk_scsi_lun *lun = task->lun; 1608 1609 spdk_bdev_scsi_unmap(lun->bdev, lun->bdev_desc, lun->io_channel, task, ctx); 1610 } 1611 1612 static int 1613 spdk_bdev_scsi_unmap(struct spdk_bdev *bdev, struct spdk_bdev_desc *bdev_desc, 1614 struct spdk_io_channel *bdev_ch, struct spdk_scsi_task *task, struct spdk_bdev_scsi_unmap_ctx *ctx) 1615 { 1616 uint8_t *data; 1617 int i, desc_count = -1; 1618 int data_len; 1619 int rc; 1620 1621 assert(task->status == SPDK_SCSI_STATUS_GOOD); 1622 1623 if (ctx == NULL) { 1624 ctx = calloc(1, sizeof(*ctx)); 1625 if (!ctx) { 1626 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1627 SPDK_SCSI_SENSE_NO_SENSE, 1628 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1629 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1630 return SPDK_SCSI_TASK_COMPLETE; 1631 } 1632 1633 ctx->task = task; 1634 ctx->count = 0; 1635 } 1636 1637 1638 if (task->iovcnt == 1) { 1639 data = (uint8_t *)task->iovs[0].iov_base; 1640 data_len = task->iovs[0].iov_len; 1641 desc_count = __copy_desc(ctx, data, data_len); 1642 } else { 1643 data = spdk_scsi_task_gather_data(task, &data_len); 1644 if (data) { 1645 desc_count = __copy_desc(ctx, data, data_len); 1646 spdk_dma_free(data); 1647 } 1648 } 1649 1650 if (desc_count < 0) { 1651 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1652 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1653 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1654 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1655 free(ctx); 1656 return SPDK_SCSI_TASK_COMPLETE; 1657 } 1658 1659 for (i = ctx->count; i < desc_count; i++) { 1660 struct spdk_scsi_unmap_bdesc *desc; 1661 uint64_t offset_blocks; 1662 uint64_t num_blocks; 1663 1664 desc = &ctx->desc[i]; 1665 1666 offset_blocks = from_be64(&desc->lba); 1667 num_blocks = from_be32(&desc->block_count); 1668 1669 if (num_blocks == 0) { 1670 continue; 1671 } 1672 1673 ctx->count++; 1674 rc = spdk_bdev_unmap_blocks(bdev_desc, bdev_ch, offset_blocks, num_blocks, 1675 spdk_bdev_scsi_task_complete_unmap_cmd, ctx); 1676 1677 if (rc) { 1678 if (rc == -ENOMEM) { 1679 spdk_bdev_scsi_queue_io(task, spdk_bdev_scsi_unmap_resubmit, ctx); 1680 /* Unmap was not yet submitted to bdev */ 1681 ctx->count--; 1682 return SPDK_SCSI_TASK_PENDING; 1683 } 1684 SPDK_ERRLOG("SCSI Unmapping failed\n"); 1685 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1686 SPDK_SCSI_SENSE_NO_SENSE, 1687 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1688 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1689 ctx->count--; 1690 /* We can't complete here - we may have to wait for previously 1691 * submitted unmaps to complete */ 1692 break; 1693 } 1694 } 1695 1696 if (ctx->count == 0) { 1697 free(ctx); 1698 return SPDK_SCSI_TASK_COMPLETE; 1699 } 1700 1701 return SPDK_SCSI_TASK_PENDING; 1702 } 1703 1704 static int 1705 spdk_bdev_scsi_process_block(struct spdk_scsi_task *task) 1706 { 1707 struct spdk_scsi_lun *lun = task->lun; 1708 struct spdk_bdev *bdev = lun->bdev; 1709 uint64_t lba; 1710 uint32_t xfer_len; 1711 uint32_t len = 0; 1712 uint8_t *cdb = task->cdb; 1713 1714 /* XXX: We need to support FUA bit for writes! */ 1715 switch (cdb[0]) { 1716 case SPDK_SBC_READ_6: 1717 case SPDK_SBC_WRITE_6: 1718 lba = (uint64_t)cdb[1] << 16; 1719 lba |= (uint64_t)cdb[2] << 8; 1720 lba |= (uint64_t)cdb[3]; 1721 xfer_len = cdb[4]; 1722 if (xfer_len == 0) { 1723 xfer_len = 256; 1724 } 1725 return spdk_bdev_scsi_readwrite(task, lba, xfer_len, 1726 cdb[0] == SPDK_SBC_READ_6); 1727 1728 case SPDK_SBC_READ_10: 1729 case SPDK_SBC_WRITE_10: 1730 lba = from_be32(&cdb[2]); 1731 xfer_len = from_be16(&cdb[7]); 1732 return spdk_bdev_scsi_readwrite(task, lba, xfer_len, 1733 cdb[0] == SPDK_SBC_READ_10); 1734 1735 case SPDK_SBC_READ_12: 1736 case SPDK_SBC_WRITE_12: 1737 lba = from_be32(&cdb[2]); 1738 xfer_len = from_be32(&cdb[6]); 1739 return spdk_bdev_scsi_readwrite(task, lba, xfer_len, 1740 cdb[0] == SPDK_SBC_READ_12); 1741 case SPDK_SBC_READ_16: 1742 case SPDK_SBC_WRITE_16: 1743 lba = from_be64(&cdb[2]); 1744 xfer_len = from_be32(&cdb[10]); 1745 return spdk_bdev_scsi_readwrite(task, lba, xfer_len, 1746 cdb[0] == SPDK_SBC_READ_16); 1747 1748 case SPDK_SBC_READ_CAPACITY_10: { 1749 uint64_t num_blocks = spdk_bdev_get_num_blocks(bdev); 1750 uint8_t buffer[8]; 1751 1752 if (num_blocks - 1 > 0xffffffffULL) { 1753 memset(buffer, 0xff, 4); 1754 } else { 1755 to_be32(buffer, num_blocks - 1); 1756 } 1757 to_be32(&buffer[4], spdk_bdev_get_block_size(bdev)); 1758 1759 len = spdk_min(task->length, sizeof(buffer)); 1760 if (spdk_scsi_task_scatter_data(task, buffer, len) < 0) { 1761 break; 1762 } 1763 1764 task->data_transferred = len; 1765 task->status = SPDK_SCSI_STATUS_GOOD; 1766 break; 1767 } 1768 1769 case SPDK_SPC_SERVICE_ACTION_IN_16: 1770 switch (cdb[1] & 0x1f) { /* SERVICE ACTION */ 1771 case SPDK_SBC_SAI_READ_CAPACITY_16: { 1772 uint8_t buffer[32] = {0}; 1773 1774 to_be64(&buffer[0], spdk_bdev_get_num_blocks(bdev) - 1); 1775 to_be32(&buffer[8], spdk_bdev_get_block_size(bdev)); 1776 /* 1777 * Set the TPE bit to 1 to indicate thin provisioning. 1778 * The position of TPE bit is the 7th bit in 14th byte 1779 * in READ CAPACITY (16) parameter data. 1780 */ 1781 if (spdk_bdev_io_type_supported(bdev, SPDK_BDEV_IO_TYPE_UNMAP)) { 1782 buffer[14] |= 1 << 7; 1783 } 1784 1785 len = spdk_min(from_be32(&cdb[10]), sizeof(buffer)); 1786 if (spdk_scsi_task_scatter_data(task, buffer, len) < 0) { 1787 break; 1788 } 1789 1790 task->data_transferred = len; 1791 task->status = SPDK_SCSI_STATUS_GOOD; 1792 break; 1793 } 1794 1795 default: 1796 return SPDK_SCSI_TASK_UNKNOWN; 1797 } 1798 break; 1799 1800 case SPDK_SBC_SYNCHRONIZE_CACHE_10: 1801 case SPDK_SBC_SYNCHRONIZE_CACHE_16: 1802 if (cdb[0] == SPDK_SBC_SYNCHRONIZE_CACHE_10) { 1803 lba = from_be32(&cdb[2]); 1804 len = from_be16(&cdb[7]); 1805 } else { 1806 lba = from_be64(&cdb[2]); 1807 len = from_be32(&cdb[10]); 1808 } 1809 1810 if (len == 0) { 1811 len = spdk_bdev_get_num_blocks(bdev) - lba; 1812 } 1813 1814 return spdk_bdev_scsi_sync(bdev, lun->bdev_desc, lun->io_channel, task, lba, len); 1815 break; 1816 1817 case SPDK_SBC_UNMAP: 1818 return spdk_bdev_scsi_unmap(bdev, lun->bdev_desc, lun->io_channel, task, NULL); 1819 1820 default: 1821 return SPDK_SCSI_TASK_UNKNOWN; 1822 } 1823 1824 return SPDK_SCSI_TASK_COMPLETE; 1825 } 1826 1827 static void 1828 spdk_bdev_scsi_process_block_resubmit(void *arg) 1829 { 1830 struct spdk_scsi_task *task = arg; 1831 1832 spdk_bdev_scsi_process_block(task); 1833 } 1834 1835 static int 1836 spdk_bdev_scsi_check_len(struct spdk_scsi_task *task, int len, int min_len) 1837 { 1838 if (len >= min_len) { 1839 return 0; 1840 } 1841 1842 /* INVALID FIELD IN CDB */ 1843 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1844 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 1845 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 1846 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1847 return -1; 1848 } 1849 1850 static int 1851 spdk_bdev_scsi_process_primary(struct spdk_scsi_task *task) 1852 { 1853 struct spdk_scsi_lun *lun = task->lun; 1854 struct spdk_bdev *bdev = lun->bdev; 1855 int alloc_len = -1; 1856 int data_len = -1; 1857 uint8_t *cdb = task->cdb; 1858 uint8_t *data = NULL; 1859 int rc = 0; 1860 int pllen, md = 0; 1861 int pf, sp; 1862 int bdlen = 0, llba; 1863 int dbd, pc, page, subpage; 1864 int cmd_parsed = 0; 1865 1866 1867 switch (cdb[0]) { 1868 case SPDK_SPC_INQUIRY: 1869 alloc_len = from_be16(&cdb[3]); 1870 data_len = spdk_max(4096, alloc_len); 1871 data = spdk_dma_zmalloc(data_len, 0, NULL); 1872 assert(data != NULL); 1873 rc = spdk_bdev_scsi_inquiry(bdev, task, cdb, data, data_len); 1874 data_len = spdk_min(rc, data_len); 1875 if (rc < 0) { 1876 break; 1877 } 1878 1879 SPDK_LOGDUMP(SPDK_LOG_SCSI, "INQUIRY", data, data_len); 1880 break; 1881 1882 case SPDK_SPC_REPORT_LUNS: { 1883 int sel; 1884 1885 sel = cdb[2]; 1886 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "sel=%x\n", sel); 1887 1888 alloc_len = from_be32(&cdb[6]); 1889 rc = spdk_bdev_scsi_check_len(task, alloc_len, 16); 1890 if (rc < 0) { 1891 break; 1892 } 1893 1894 data_len = spdk_max(4096, alloc_len); 1895 data = spdk_dma_zmalloc(data_len, 0, NULL); 1896 assert(data != NULL); 1897 rc = spdk_bdev_scsi_report_luns(task->lun, sel, data, data_len); 1898 data_len = rc; 1899 if (rc < 0) { 1900 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1901 SPDK_SCSI_SENSE_NO_SENSE, 1902 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1903 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1904 break; 1905 } 1906 1907 SPDK_LOGDUMP(SPDK_LOG_SCSI, "REPORT LUNS", data, data_len); 1908 break; 1909 } 1910 1911 case SPDK_SPC_MODE_SELECT_6: 1912 case SPDK_SPC_MODE_SELECT_10: 1913 if (cdb[0] == SPDK_SPC_MODE_SELECT_6) { 1914 /* MODE_SELECT(6) must have at least a 4 byte header. */ 1915 md = 4; 1916 pllen = cdb[4]; 1917 } else { 1918 /* MODE_SELECT(10) must have at least an 8 byte header. */ 1919 md = 8; 1920 pllen = from_be16(&cdb[7]); 1921 } 1922 1923 if (pllen == 0) { 1924 break; 1925 } 1926 1927 rc = spdk_bdev_scsi_check_len(task, pllen, md); 1928 if (rc < 0) { 1929 break; 1930 } 1931 1932 data = spdk_scsi_task_gather_data(task, &rc); 1933 if (rc < 0) { 1934 break; 1935 } 1936 1937 data_len = rc; 1938 if (cdb[0] == SPDK_SPC_MODE_SELECT_6) { 1939 rc = spdk_bdev_scsi_check_len(task, data_len, 4); 1940 if (rc >= 0) { 1941 bdlen = data[3]; 1942 } 1943 1944 } else { 1945 rc = spdk_bdev_scsi_check_len(task, data_len, 8); 1946 if (rc >= 0) { 1947 bdlen = from_be16(&data[6]); 1948 } 1949 } 1950 1951 if (rc < 0) { 1952 break; 1953 } 1954 pf = !!(cdb[1] & 0x10); 1955 sp = !!(cdb[1] & 0x1); 1956 1957 /* page data */ 1958 rc = spdk_bdev_scsi_mode_select_page( 1959 bdev, cdb, 1960 pf, sp, 1961 &data[md + bdlen], 1962 pllen - (md + bdlen)); 1963 if (rc < 0) { 1964 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 1965 SPDK_SCSI_SENSE_NO_SENSE, 1966 SPDK_SCSI_ASC_NO_ADDITIONAL_SENSE, 1967 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 1968 break; 1969 } 1970 1971 rc = pllen; 1972 data_len = 0; 1973 break; 1974 1975 case SPDK_SPC_MODE_SENSE_6: 1976 alloc_len = cdb[4]; 1977 md = 6; 1978 /* FALLTHROUGH */ 1979 case SPDK_SPC_MODE_SENSE_10: 1980 llba = 0; 1981 1982 if (md == 0) { 1983 alloc_len = from_be16(&cdb[7]); 1984 llba = !!(cdb[1] & 0x10); 1985 md = 10; 1986 } 1987 1988 dbd = !!(cdb[1] & 0x8); 1989 pc = (cdb[2] & 0xc0) >> 6; 1990 page = cdb[2] & 0x3f; 1991 subpage = cdb[3]; 1992 1993 /* First call with no buffer to discover needed buffer size */ 1994 rc = spdk_bdev_scsi_mode_sense(bdev, md, 1995 cdb, dbd, llba, pc, 1996 page, subpage, 1997 NULL, task); 1998 if (rc < 0) { 1999 break; 2000 } 2001 2002 data_len = rc; 2003 data = spdk_dma_zmalloc(data_len, 0, NULL); 2004 assert(data != NULL); 2005 2006 /* First call with no buffer to discover needed buffer size */ 2007 rc = spdk_bdev_scsi_mode_sense(bdev, md, 2008 cdb, dbd, llba, pc, 2009 page, subpage, 2010 data, task); 2011 if (rc < 0) { 2012 /* INVALID FIELD IN CDB */ 2013 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 2014 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 2015 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 2016 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 2017 break; 2018 } 2019 break; 2020 2021 case SPDK_SPC_REQUEST_SENSE: { 2022 int desc; 2023 int sk, asc, ascq; 2024 2025 desc = cdb[1] & 0x1; 2026 if (desc != 0) { 2027 /* INVALID FIELD IN CDB */ 2028 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 2029 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 2030 SPDK_SCSI_ASC_INVALID_FIELD_IN_CDB, 2031 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 2032 break; 2033 } 2034 2035 alloc_len = cdb[4]; 2036 2037 /* NO ADDITIONAL SENSE INFORMATION */ 2038 sk = SPDK_SCSI_SENSE_NO_SENSE; 2039 asc = 0x00; 2040 ascq = 0x00; 2041 2042 spdk_scsi_task_build_sense_data(task, sk, asc, ascq); 2043 2044 data_len = task->sense_data_len; 2045 data = spdk_dma_zmalloc(data_len, 0, NULL); 2046 assert(data != NULL); 2047 memcpy(data, task->sense_data, data_len); 2048 break; 2049 } 2050 2051 case SPDK_SPC_LOG_SELECT: 2052 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "LOG_SELECT\n"); 2053 cmd_parsed = 1; 2054 /* FALLTHROUGH */ 2055 case SPDK_SPC_LOG_SENSE: 2056 if (!cmd_parsed) { 2057 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "LOG_SENSE\n"); 2058 } 2059 2060 /* INVALID COMMAND OPERATION CODE */ 2061 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 2062 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 2063 SPDK_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 2064 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 2065 rc = -1; 2066 break; 2067 2068 case SPDK_SPC_TEST_UNIT_READY: 2069 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "TEST_UNIT_READY\n"); 2070 cmd_parsed = 1; 2071 /* FALLTHROUGH */ 2072 case SPDK_SBC_START_STOP_UNIT: 2073 if (!cmd_parsed) { 2074 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "START_STOP_UNIT\n"); 2075 } 2076 2077 rc = 0; 2078 break; 2079 2080 default: 2081 return SPDK_SCSI_TASK_UNKNOWN; 2082 } 2083 2084 if (rc >= 0 && data_len > 0) { 2085 assert(alloc_len >= 0); 2086 spdk_scsi_task_scatter_data(task, data, spdk_min(alloc_len, data_len)); 2087 rc = spdk_min(data_len, alloc_len); 2088 } 2089 2090 if (rc >= 0) { 2091 task->data_transferred = rc; 2092 task->status = SPDK_SCSI_STATUS_GOOD; 2093 } 2094 2095 if (data) { 2096 spdk_dma_free(data); 2097 } 2098 2099 return SPDK_SCSI_TASK_COMPLETE; 2100 } 2101 2102 int 2103 spdk_bdev_scsi_execute(struct spdk_scsi_task *task) 2104 { 2105 int rc; 2106 2107 if ((rc = spdk_bdev_scsi_process_block(task)) == SPDK_SCSI_TASK_UNKNOWN) { 2108 if ((rc = spdk_bdev_scsi_process_primary(task)) == SPDK_SCSI_TASK_UNKNOWN) { 2109 SPDK_DEBUGLOG(SPDK_LOG_SCSI, "unsupported SCSI OP=0x%x\n", task->cdb[0]); 2110 /* INVALID COMMAND OPERATION CODE */ 2111 spdk_scsi_task_set_status(task, SPDK_SCSI_STATUS_CHECK_CONDITION, 2112 SPDK_SCSI_SENSE_ILLEGAL_REQUEST, 2113 SPDK_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE, 2114 SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); 2115 return SPDK_SCSI_TASK_COMPLETE; 2116 } 2117 } 2118 2119 return rc; 2120 } 2121 2122 static void 2123 spdk_bdev_scsi_reset_resubmit(void *arg) 2124 { 2125 struct spdk_scsi_task *task = arg; 2126 2127 spdk_bdev_scsi_reset(task); 2128 } 2129 2130 void 2131 spdk_bdev_scsi_reset(struct spdk_scsi_task *task) 2132 { 2133 struct spdk_scsi_lun *lun = task->lun; 2134 int rc; 2135 2136 rc = spdk_bdev_reset(lun->bdev_desc, lun->io_channel, spdk_bdev_scsi_task_complete_reset, 2137 task); 2138 if (rc == -ENOMEM) { 2139 spdk_bdev_scsi_queue_io(task, spdk_bdev_scsi_reset_resubmit, task); 2140 } 2141 } 2142