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