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