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