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