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