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