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