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