1 /* 2 * SCSI Primary Commands (SPC) parsing and emulation. 3 * 4 * (c) Copyright 2002-2012 RisingTide Systems LLC. 5 * 6 * Nicholas A. Bellinger <nab@kernel.org> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 21 */ 22 23 #include <linux/kernel.h> 24 #include <linux/module.h> 25 #include <asm/unaligned.h> 26 27 #include <scsi/scsi.h> 28 #include <scsi/scsi_tcq.h> 29 30 #include <target/target_core_base.h> 31 #include <target/target_core_backend.h> 32 #include <target/target_core_fabric.h> 33 34 #include "target_core_internal.h" 35 #include "target_core_alua.h" 36 #include "target_core_pr.h" 37 #include "target_core_ua.h" 38 39 40 static void spc_fill_alua_data(struct se_port *port, unsigned char *buf) 41 { 42 struct t10_alua_tg_pt_gp *tg_pt_gp; 43 struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem; 44 45 /* 46 * Set SCCS for MAINTENANCE_IN + REPORT_TARGET_PORT_GROUPS. 47 */ 48 buf[5] = 0x80; 49 50 /* 51 * Set TPGS field for explict and/or implict ALUA access type 52 * and opteration. 53 * 54 * See spc4r17 section 6.4.2 Table 135 55 */ 56 if (!port) 57 return; 58 tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem; 59 if (!tg_pt_gp_mem) 60 return; 61 62 spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock); 63 tg_pt_gp = tg_pt_gp_mem->tg_pt_gp; 64 if (tg_pt_gp) 65 buf[5] |= tg_pt_gp->tg_pt_gp_alua_access_type; 66 spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock); 67 } 68 69 static sense_reason_t 70 spc_emulate_inquiry_std(struct se_cmd *cmd, char *buf) 71 { 72 struct se_lun *lun = cmd->se_lun; 73 struct se_device *dev = cmd->se_dev; 74 75 /* Set RMB (removable media) for tape devices */ 76 if (dev->transport->get_device_type(dev) == TYPE_TAPE) 77 buf[1] = 0x80; 78 79 buf[2] = 0x05; /* SPC-3 */ 80 81 /* 82 * NORMACA and HISUP = 0, RESPONSE DATA FORMAT = 2 83 * 84 * SPC4 says: 85 * A RESPONSE DATA FORMAT field set to 2h indicates that the 86 * standard INQUIRY data is in the format defined in this 87 * standard. Response data format values less than 2h are 88 * obsolete. Response data format values greater than 2h are 89 * reserved. 90 */ 91 buf[3] = 2; 92 93 /* 94 * Enable SCCS and TPGS fields for Emulated ALUA 95 */ 96 spc_fill_alua_data(lun->lun_sep, buf); 97 98 buf[7] = 0x2; /* CmdQue=1 */ 99 100 snprintf(&buf[8], 8, "LIO-ORG"); 101 snprintf(&buf[16], 16, "%s", dev->t10_wwn.model); 102 snprintf(&buf[32], 4, "%s", dev->t10_wwn.revision); 103 buf[4] = 31; /* Set additional length to 31 */ 104 105 return 0; 106 } 107 108 /* unit serial number */ 109 static sense_reason_t 110 spc_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf) 111 { 112 struct se_device *dev = cmd->se_dev; 113 u16 len = 0; 114 115 if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) { 116 u32 unit_serial_len; 117 118 unit_serial_len = strlen(dev->t10_wwn.unit_serial); 119 unit_serial_len++; /* For NULL Terminator */ 120 121 len += sprintf(&buf[4], "%s", dev->t10_wwn.unit_serial); 122 len++; /* Extra Byte for NULL Terminator */ 123 buf[3] = len; 124 } 125 return 0; 126 } 127 128 static void spc_parse_naa_6h_vendor_specific(struct se_device *dev, 129 unsigned char *buf) 130 { 131 unsigned char *p = &dev->t10_wwn.unit_serial[0]; 132 int cnt; 133 bool next = true; 134 135 /* 136 * Generate up to 36 bits of VENDOR SPECIFIC IDENTIFIER starting on 137 * byte 3 bit 3-0 for NAA IEEE Registered Extended DESIGNATOR field 138 * format, followed by 64 bits of VENDOR SPECIFIC IDENTIFIER EXTENSION 139 * to complete the payload. These are based from VPD=0x80 PRODUCT SERIAL 140 * NUMBER set via vpd_unit_serial in target_core_configfs.c to ensure 141 * per device uniqeness. 142 */ 143 for (cnt = 0; *p && cnt < 13; p++) { 144 int val = hex_to_bin(*p); 145 146 if (val < 0) 147 continue; 148 149 if (next) { 150 next = false; 151 buf[cnt++] |= val; 152 } else { 153 next = true; 154 buf[cnt] = val << 4; 155 } 156 } 157 } 158 159 /* 160 * Device identification VPD, for a complete list of 161 * DESIGNATOR TYPEs see spc4r17 Table 459. 162 */ 163 static sense_reason_t 164 spc_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf) 165 { 166 struct se_device *dev = cmd->se_dev; 167 struct se_lun *lun = cmd->se_lun; 168 struct se_port *port = NULL; 169 struct se_portal_group *tpg = NULL; 170 struct t10_alua_lu_gp_member *lu_gp_mem; 171 struct t10_alua_tg_pt_gp *tg_pt_gp; 172 struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem; 173 unsigned char *prod = &dev->t10_wwn.model[0]; 174 u32 prod_len; 175 u32 unit_serial_len, off = 0; 176 u16 len = 0, id_len; 177 178 off = 4; 179 180 /* 181 * NAA IEEE Registered Extended Assigned designator format, see 182 * spc4r17 section 7.7.3.6.5 183 * 184 * We depend upon a target_core_mod/ConfigFS provided 185 * /sys/kernel/config/target/core/$HBA/$DEV/wwn/vpd_unit_serial 186 * value in order to return the NAA id. 187 */ 188 if (!(dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL)) 189 goto check_t10_vend_desc; 190 191 /* CODE SET == Binary */ 192 buf[off++] = 0x1; 193 194 /* Set ASSOCIATION == addressed logical unit: 0)b */ 195 buf[off] = 0x00; 196 197 /* Identifier/Designator type == NAA identifier */ 198 buf[off++] |= 0x3; 199 off++; 200 201 /* Identifier/Designator length */ 202 buf[off++] = 0x10; 203 204 /* 205 * Start NAA IEEE Registered Extended Identifier/Designator 206 */ 207 buf[off++] = (0x6 << 4); 208 209 /* 210 * Use OpenFabrics IEEE Company ID: 00 14 05 211 */ 212 buf[off++] = 0x01; 213 buf[off++] = 0x40; 214 buf[off] = (0x5 << 4); 215 216 /* 217 * Return ConfigFS Unit Serial Number information for 218 * VENDOR_SPECIFIC_IDENTIFIER and 219 * VENDOR_SPECIFIC_IDENTIFIER_EXTENTION 220 */ 221 spc_parse_naa_6h_vendor_specific(dev, &buf[off]); 222 223 len = 20; 224 off = (len + 4); 225 226 check_t10_vend_desc: 227 /* 228 * T10 Vendor Identifier Page, see spc4r17 section 7.7.3.4 229 */ 230 id_len = 8; /* For Vendor field */ 231 prod_len = 4; /* For VPD Header */ 232 prod_len += 8; /* For Vendor field */ 233 prod_len += strlen(prod); 234 prod_len++; /* For : */ 235 236 if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) { 237 unit_serial_len = strlen(&dev->t10_wwn.unit_serial[0]); 238 unit_serial_len++; /* For NULL Terminator */ 239 240 id_len += sprintf(&buf[off+12], "%s:%s", prod, 241 &dev->t10_wwn.unit_serial[0]); 242 } 243 buf[off] = 0x2; /* ASCII */ 244 buf[off+1] = 0x1; /* T10 Vendor ID */ 245 buf[off+2] = 0x0; 246 memcpy(&buf[off+4], "LIO-ORG", 8); 247 /* Extra Byte for NULL Terminator */ 248 id_len++; 249 /* Identifier Length */ 250 buf[off+3] = id_len; 251 /* Header size for Designation descriptor */ 252 len += (id_len + 4); 253 off += (id_len + 4); 254 /* 255 * struct se_port is only set for INQUIRY VPD=1 through $FABRIC_MOD 256 */ 257 port = lun->lun_sep; 258 if (port) { 259 struct t10_alua_lu_gp *lu_gp; 260 u32 padding, scsi_name_len; 261 u16 lu_gp_id = 0; 262 u16 tg_pt_gp_id = 0; 263 u16 tpgt; 264 265 tpg = port->sep_tpg; 266 /* 267 * Relative target port identifer, see spc4r17 268 * section 7.7.3.7 269 * 270 * Get the PROTOCOL IDENTIFIER as defined by spc4r17 271 * section 7.5.1 Table 362 272 */ 273 buf[off] = 274 (tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4); 275 buf[off++] |= 0x1; /* CODE SET == Binary */ 276 buf[off] = 0x80; /* Set PIV=1 */ 277 /* Set ASSOCIATION == target port: 01b */ 278 buf[off] |= 0x10; 279 /* DESIGNATOR TYPE == Relative target port identifer */ 280 buf[off++] |= 0x4; 281 off++; /* Skip over Reserved */ 282 buf[off++] = 4; /* DESIGNATOR LENGTH */ 283 /* Skip over Obsolete field in RTPI payload 284 * in Table 472 */ 285 off += 2; 286 buf[off++] = ((port->sep_rtpi >> 8) & 0xff); 287 buf[off++] = (port->sep_rtpi & 0xff); 288 len += 8; /* Header size + Designation descriptor */ 289 /* 290 * Target port group identifier, see spc4r17 291 * section 7.7.3.8 292 * 293 * Get the PROTOCOL IDENTIFIER as defined by spc4r17 294 * section 7.5.1 Table 362 295 */ 296 tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem; 297 if (!tg_pt_gp_mem) 298 goto check_lu_gp; 299 300 spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock); 301 tg_pt_gp = tg_pt_gp_mem->tg_pt_gp; 302 if (!tg_pt_gp) { 303 spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock); 304 goto check_lu_gp; 305 } 306 tg_pt_gp_id = tg_pt_gp->tg_pt_gp_id; 307 spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock); 308 309 buf[off] = 310 (tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4); 311 buf[off++] |= 0x1; /* CODE SET == Binary */ 312 buf[off] = 0x80; /* Set PIV=1 */ 313 /* Set ASSOCIATION == target port: 01b */ 314 buf[off] |= 0x10; 315 /* DESIGNATOR TYPE == Target port group identifier */ 316 buf[off++] |= 0x5; 317 off++; /* Skip over Reserved */ 318 buf[off++] = 4; /* DESIGNATOR LENGTH */ 319 off += 2; /* Skip over Reserved Field */ 320 buf[off++] = ((tg_pt_gp_id >> 8) & 0xff); 321 buf[off++] = (tg_pt_gp_id & 0xff); 322 len += 8; /* Header size + Designation descriptor */ 323 /* 324 * Logical Unit Group identifier, see spc4r17 325 * section 7.7.3.8 326 */ 327 check_lu_gp: 328 lu_gp_mem = dev->dev_alua_lu_gp_mem; 329 if (!lu_gp_mem) 330 goto check_scsi_name; 331 332 spin_lock(&lu_gp_mem->lu_gp_mem_lock); 333 lu_gp = lu_gp_mem->lu_gp; 334 if (!lu_gp) { 335 spin_unlock(&lu_gp_mem->lu_gp_mem_lock); 336 goto check_scsi_name; 337 } 338 lu_gp_id = lu_gp->lu_gp_id; 339 spin_unlock(&lu_gp_mem->lu_gp_mem_lock); 340 341 buf[off++] |= 0x1; /* CODE SET == Binary */ 342 /* DESIGNATOR TYPE == Logical Unit Group identifier */ 343 buf[off++] |= 0x6; 344 off++; /* Skip over Reserved */ 345 buf[off++] = 4; /* DESIGNATOR LENGTH */ 346 off += 2; /* Skip over Reserved Field */ 347 buf[off++] = ((lu_gp_id >> 8) & 0xff); 348 buf[off++] = (lu_gp_id & 0xff); 349 len += 8; /* Header size + Designation descriptor */ 350 /* 351 * SCSI name string designator, see spc4r17 352 * section 7.7.3.11 353 * 354 * Get the PROTOCOL IDENTIFIER as defined by spc4r17 355 * section 7.5.1 Table 362 356 */ 357 check_scsi_name: 358 scsi_name_len = strlen(tpg->se_tpg_tfo->tpg_get_wwn(tpg)); 359 /* UTF-8 ",t,0x<16-bit TPGT>" + NULL Terminator */ 360 scsi_name_len += 10; 361 /* Check for 4-byte padding */ 362 padding = ((-scsi_name_len) & 3); 363 if (padding != 0) 364 scsi_name_len += padding; 365 /* Header size + Designation descriptor */ 366 scsi_name_len += 4; 367 368 buf[off] = 369 (tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4); 370 buf[off++] |= 0x3; /* CODE SET == UTF-8 */ 371 buf[off] = 0x80; /* Set PIV=1 */ 372 /* Set ASSOCIATION == target port: 01b */ 373 buf[off] |= 0x10; 374 /* DESIGNATOR TYPE == SCSI name string */ 375 buf[off++] |= 0x8; 376 off += 2; /* Skip over Reserved and length */ 377 /* 378 * SCSI name string identifer containing, $FABRIC_MOD 379 * dependent information. For LIO-Target and iSCSI 380 * Target Port, this means "<iSCSI name>,t,0x<TPGT> in 381 * UTF-8 encoding. 382 */ 383 tpgt = tpg->se_tpg_tfo->tpg_get_tag(tpg); 384 scsi_name_len = sprintf(&buf[off], "%s,t,0x%04x", 385 tpg->se_tpg_tfo->tpg_get_wwn(tpg), tpgt); 386 scsi_name_len += 1 /* Include NULL terminator */; 387 /* 388 * The null-terminated, null-padded (see 4.4.2) SCSI 389 * NAME STRING field contains a UTF-8 format string. 390 * The number of bytes in the SCSI NAME STRING field 391 * (i.e., the value in the DESIGNATOR LENGTH field) 392 * shall be no larger than 256 and shall be a multiple 393 * of four. 394 */ 395 if (padding) 396 scsi_name_len += padding; 397 398 buf[off-1] = scsi_name_len; 399 off += scsi_name_len; 400 /* Header size + Designation descriptor */ 401 len += (scsi_name_len + 4); 402 } 403 buf[2] = ((len >> 8) & 0xff); 404 buf[3] = (len & 0xff); /* Page Length for VPD 0x83 */ 405 return 0; 406 } 407 408 /* Extended INQUIRY Data VPD Page */ 409 static sense_reason_t 410 spc_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf) 411 { 412 buf[3] = 0x3c; 413 /* Set HEADSUP, ORDSUP, SIMPSUP */ 414 buf[5] = 0x07; 415 416 /* If WriteCache emulation is enabled, set V_SUP */ 417 if (cmd->se_dev->dev_attrib.emulate_write_cache > 0) 418 buf[6] = 0x01; 419 return 0; 420 } 421 422 /* Block Limits VPD page */ 423 static sense_reason_t 424 spc_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf) 425 { 426 struct se_device *dev = cmd->se_dev; 427 u32 max_sectors; 428 int have_tp = 0; 429 430 /* 431 * Following spc3r22 section 6.5.3 Block Limits VPD page, when 432 * emulate_tpu=1 or emulate_tpws=1 we will be expect a 433 * different page length for Thin Provisioning. 434 */ 435 if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws) 436 have_tp = 1; 437 438 buf[0] = dev->transport->get_device_type(dev); 439 buf[3] = have_tp ? 0x3c : 0x10; 440 441 /* Set WSNZ to 1 */ 442 buf[4] = 0x01; 443 444 /* 445 * Set OPTIMAL TRANSFER LENGTH GRANULARITY 446 */ 447 put_unaligned_be16(1, &buf[6]); 448 449 /* 450 * Set MAXIMUM TRANSFER LENGTH 451 */ 452 max_sectors = min(dev->dev_attrib.fabric_max_sectors, 453 dev->dev_attrib.hw_max_sectors); 454 put_unaligned_be32(max_sectors, &buf[8]); 455 456 /* 457 * Set OPTIMAL TRANSFER LENGTH 458 */ 459 put_unaligned_be32(dev->dev_attrib.optimal_sectors, &buf[12]); 460 461 /* 462 * Exit now if we don't support TP. 463 */ 464 if (!have_tp) 465 goto max_write_same; 466 467 /* 468 * Set MAXIMUM UNMAP LBA COUNT 469 */ 470 put_unaligned_be32(dev->dev_attrib.max_unmap_lba_count, &buf[20]); 471 472 /* 473 * Set MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT 474 */ 475 put_unaligned_be32(dev->dev_attrib.max_unmap_block_desc_count, 476 &buf[24]); 477 478 /* 479 * Set OPTIMAL UNMAP GRANULARITY 480 */ 481 put_unaligned_be32(dev->dev_attrib.unmap_granularity, &buf[28]); 482 483 /* 484 * UNMAP GRANULARITY ALIGNMENT 485 */ 486 put_unaligned_be32(dev->dev_attrib.unmap_granularity_alignment, 487 &buf[32]); 488 if (dev->dev_attrib.unmap_granularity_alignment != 0) 489 buf[32] |= 0x80; /* Set the UGAVALID bit */ 490 491 /* 492 * MAXIMUM WRITE SAME LENGTH 493 */ 494 max_write_same: 495 put_unaligned_be64(dev->dev_attrib.max_write_same_len, &buf[36]); 496 497 return 0; 498 } 499 500 /* Block Device Characteristics VPD page */ 501 static sense_reason_t 502 spc_emulate_evpd_b1(struct se_cmd *cmd, unsigned char *buf) 503 { 504 struct se_device *dev = cmd->se_dev; 505 506 buf[0] = dev->transport->get_device_type(dev); 507 buf[3] = 0x3c; 508 buf[5] = dev->dev_attrib.is_nonrot ? 1 : 0; 509 510 return 0; 511 } 512 513 /* Thin Provisioning VPD */ 514 static sense_reason_t 515 spc_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf) 516 { 517 struct se_device *dev = cmd->se_dev; 518 519 /* 520 * From spc3r22 section 6.5.4 Thin Provisioning VPD page: 521 * 522 * The PAGE LENGTH field is defined in SPC-4. If the DP bit is set to 523 * zero, then the page length shall be set to 0004h. If the DP bit 524 * is set to one, then the page length shall be set to the value 525 * defined in table 162. 526 */ 527 buf[0] = dev->transport->get_device_type(dev); 528 529 /* 530 * Set Hardcoded length mentioned above for DP=0 531 */ 532 put_unaligned_be16(0x0004, &buf[2]); 533 534 /* 535 * The THRESHOLD EXPONENT field indicates the threshold set size in 536 * LBAs as a power of 2 (i.e., the threshold set size is equal to 537 * 2(threshold exponent)). 538 * 539 * Note that this is currently set to 0x00 as mkp says it will be 540 * changing again. We can enable this once it has settled in T10 541 * and is actually used by Linux/SCSI ML code. 542 */ 543 buf[4] = 0x00; 544 545 /* 546 * A TPU bit set to one indicates that the device server supports 547 * the UNMAP command (see 5.25). A TPU bit set to zero indicates 548 * that the device server does not support the UNMAP command. 549 */ 550 if (dev->dev_attrib.emulate_tpu != 0) 551 buf[5] = 0x80; 552 553 /* 554 * A TPWS bit set to one indicates that the device server supports 555 * the use of the WRITE SAME (16) command (see 5.42) to unmap LBAs. 556 * A TPWS bit set to zero indicates that the device server does not 557 * support the use of the WRITE SAME (16) command to unmap LBAs. 558 */ 559 if (dev->dev_attrib.emulate_tpws != 0) 560 buf[5] |= 0x40; 561 562 return 0; 563 } 564 565 static sense_reason_t 566 spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf); 567 568 static struct { 569 uint8_t page; 570 sense_reason_t (*emulate)(struct se_cmd *, unsigned char *); 571 } evpd_handlers[] = { 572 { .page = 0x00, .emulate = spc_emulate_evpd_00 }, 573 { .page = 0x80, .emulate = spc_emulate_evpd_80 }, 574 { .page = 0x83, .emulate = spc_emulate_evpd_83 }, 575 { .page = 0x86, .emulate = spc_emulate_evpd_86 }, 576 { .page = 0xb0, .emulate = spc_emulate_evpd_b0 }, 577 { .page = 0xb1, .emulate = spc_emulate_evpd_b1 }, 578 { .page = 0xb2, .emulate = spc_emulate_evpd_b2 }, 579 }; 580 581 /* supported vital product data pages */ 582 static sense_reason_t 583 spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf) 584 { 585 int p; 586 587 /* 588 * Only report the INQUIRY EVPD=1 pages after a valid NAA 589 * Registered Extended LUN WWN has been set via ConfigFS 590 * during device creation/restart. 591 */ 592 if (cmd->se_dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) { 593 buf[3] = ARRAY_SIZE(evpd_handlers); 594 for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p) 595 buf[p + 4] = evpd_handlers[p].page; 596 } 597 598 return 0; 599 } 600 601 static sense_reason_t 602 spc_emulate_inquiry(struct se_cmd *cmd) 603 { 604 struct se_device *dev = cmd->se_dev; 605 struct se_portal_group *tpg = cmd->se_lun->lun_sep->sep_tpg; 606 unsigned char *rbuf; 607 unsigned char *cdb = cmd->t_task_cdb; 608 unsigned char buf[SE_INQUIRY_BUF]; 609 sense_reason_t ret; 610 int p; 611 612 memset(buf, 0, SE_INQUIRY_BUF); 613 614 if (dev == tpg->tpg_virt_lun0.lun_se_dev) 615 buf[0] = 0x3f; /* Not connected */ 616 else 617 buf[0] = dev->transport->get_device_type(dev); 618 619 if (!(cdb[1] & 0x1)) { 620 if (cdb[2]) { 621 pr_err("INQUIRY with EVPD==0 but PAGE CODE=%02x\n", 622 cdb[2]); 623 ret = TCM_INVALID_CDB_FIELD; 624 goto out; 625 } 626 627 ret = spc_emulate_inquiry_std(cmd, buf); 628 goto out; 629 } 630 631 for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p) { 632 if (cdb[2] == evpd_handlers[p].page) { 633 buf[1] = cdb[2]; 634 ret = evpd_handlers[p].emulate(cmd, buf); 635 goto out; 636 } 637 } 638 639 pr_err("Unknown VPD Code: 0x%02x\n", cdb[2]); 640 ret = TCM_INVALID_CDB_FIELD; 641 642 out: 643 rbuf = transport_kmap_data_sg(cmd); 644 if (rbuf) { 645 memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length)); 646 transport_kunmap_data_sg(cmd); 647 } 648 649 if (!ret) 650 target_complete_cmd(cmd, GOOD); 651 return ret; 652 } 653 654 static int spc_modesense_rwrecovery(struct se_device *dev, u8 pc, u8 *p) 655 { 656 p[0] = 0x01; 657 p[1] = 0x0a; 658 659 /* No changeable values for now */ 660 if (pc == 1) 661 goto out; 662 663 out: 664 return 12; 665 } 666 667 static int spc_modesense_control(struct se_device *dev, u8 pc, u8 *p) 668 { 669 p[0] = 0x0a; 670 p[1] = 0x0a; 671 672 /* No changeable values for now */ 673 if (pc == 1) 674 goto out; 675 676 p[2] = 2; 677 /* 678 * From spc4r23, 7.4.7 Control mode page 679 * 680 * The QUEUE ALGORITHM MODIFIER field (see table 368) specifies 681 * restrictions on the algorithm used for reordering commands 682 * having the SIMPLE task attribute (see SAM-4). 683 * 684 * Table 368 -- QUEUE ALGORITHM MODIFIER field 685 * Code Description 686 * 0h Restricted reordering 687 * 1h Unrestricted reordering allowed 688 * 2h to 7h Reserved 689 * 8h to Fh Vendor specific 690 * 691 * A value of zero in the QUEUE ALGORITHM MODIFIER field specifies that 692 * the device server shall order the processing sequence of commands 693 * having the SIMPLE task attribute such that data integrity is maintained 694 * for that I_T nexus (i.e., if the transmission of new SCSI transport protocol 695 * requests is halted at any time, the final value of all data observable 696 * on the medium shall be the same as if all the commands had been processed 697 * with the ORDERED task attribute). 698 * 699 * A value of one in the QUEUE ALGORITHM MODIFIER field specifies that the 700 * device server may reorder the processing sequence of commands having the 701 * SIMPLE task attribute in any manner. Any data integrity exposures related to 702 * command sequence order shall be explicitly handled by the application client 703 * through the selection of appropriate ommands and task attributes. 704 */ 705 p[3] = (dev->dev_attrib.emulate_rest_reord == 1) ? 0x00 : 0x10; 706 /* 707 * From spc4r17, section 7.4.6 Control mode Page 708 * 709 * Unit Attention interlocks control (UN_INTLCK_CTRL) to code 00b 710 * 711 * 00b: The logical unit shall clear any unit attention condition 712 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION 713 * status and shall not establish a unit attention condition when a com- 714 * mand is completed with BUSY, TASK SET FULL, or RESERVATION CONFLICT 715 * status. 716 * 717 * 10b: The logical unit shall not clear any unit attention condition 718 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION 719 * status and shall not establish a unit attention condition when 720 * a command is completed with BUSY, TASK SET FULL, or RESERVATION 721 * CONFLICT status. 722 * 723 * 11b a The logical unit shall not clear any unit attention condition 724 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION 725 * status and shall establish a unit attention condition for the 726 * initiator port associated with the I_T nexus on which the BUSY, 727 * TASK SET FULL, or RESERVATION CONFLICT status is being returned. 728 * Depending on the status, the additional sense code shall be set to 729 * PREVIOUS BUSY STATUS, PREVIOUS TASK SET FULL STATUS, or PREVIOUS 730 * RESERVATION CONFLICT STATUS. Until it is cleared by a REQUEST SENSE 731 * command, a unit attention condition shall be established only once 732 * for a BUSY, TASK SET FULL, or RESERVATION CONFLICT status regardless 733 * to the number of commands completed with one of those status codes. 734 */ 735 p[4] = (dev->dev_attrib.emulate_ua_intlck_ctrl == 2) ? 0x30 : 736 (dev->dev_attrib.emulate_ua_intlck_ctrl == 1) ? 0x20 : 0x00; 737 /* 738 * From spc4r17, section 7.4.6 Control mode Page 739 * 740 * Task Aborted Status (TAS) bit set to zero. 741 * 742 * A task aborted status (TAS) bit set to zero specifies that aborted 743 * tasks shall be terminated by the device server without any response 744 * to the application client. A TAS bit set to one specifies that tasks 745 * aborted by the actions of an I_T nexus other than the I_T nexus on 746 * which the command was received shall be completed with TASK ABORTED 747 * status (see SAM-4). 748 */ 749 p[5] = (dev->dev_attrib.emulate_tas) ? 0x40 : 0x00; 750 p[8] = 0xff; 751 p[9] = 0xff; 752 p[11] = 30; 753 754 out: 755 return 12; 756 } 757 758 static int spc_modesense_caching(struct se_device *dev, u8 pc, u8 *p) 759 { 760 p[0] = 0x08; 761 p[1] = 0x12; 762 763 /* No changeable values for now */ 764 if (pc == 1) 765 goto out; 766 767 if (dev->dev_attrib.emulate_write_cache > 0) 768 p[2] = 0x04; /* Write Cache Enable */ 769 p[12] = 0x20; /* Disabled Read Ahead */ 770 771 out: 772 return 20; 773 } 774 775 static int spc_modesense_informational_exceptions(struct se_device *dev, u8 pc, unsigned char *p) 776 { 777 p[0] = 0x1c; 778 p[1] = 0x0a; 779 780 /* No changeable values for now */ 781 if (pc == 1) 782 goto out; 783 784 out: 785 return 12; 786 } 787 788 static struct { 789 uint8_t page; 790 uint8_t subpage; 791 int (*emulate)(struct se_device *, u8, unsigned char *); 792 } modesense_handlers[] = { 793 { .page = 0x01, .subpage = 0x00, .emulate = spc_modesense_rwrecovery }, 794 { .page = 0x08, .subpage = 0x00, .emulate = spc_modesense_caching }, 795 { .page = 0x0a, .subpage = 0x00, .emulate = spc_modesense_control }, 796 { .page = 0x1c, .subpage = 0x00, .emulate = spc_modesense_informational_exceptions }, 797 }; 798 799 static void spc_modesense_write_protect(unsigned char *buf, int type) 800 { 801 /* 802 * I believe that the WP bit (bit 7) in the mode header is the same for 803 * all device types.. 804 */ 805 switch (type) { 806 case TYPE_DISK: 807 case TYPE_TAPE: 808 default: 809 buf[0] |= 0x80; /* WP bit */ 810 break; 811 } 812 } 813 814 static void spc_modesense_dpofua(unsigned char *buf, int type) 815 { 816 switch (type) { 817 case TYPE_DISK: 818 buf[0] |= 0x10; /* DPOFUA bit */ 819 break; 820 default: 821 break; 822 } 823 } 824 825 static int spc_modesense_blockdesc(unsigned char *buf, u64 blocks, u32 block_size) 826 { 827 *buf++ = 8; 828 put_unaligned_be32(min(blocks, 0xffffffffull), buf); 829 buf += 4; 830 put_unaligned_be32(block_size, buf); 831 return 9; 832 } 833 834 static int spc_modesense_long_blockdesc(unsigned char *buf, u64 blocks, u32 block_size) 835 { 836 if (blocks <= 0xffffffff) 837 return spc_modesense_blockdesc(buf + 3, blocks, block_size) + 3; 838 839 *buf++ = 1; /* LONGLBA */ 840 buf += 2; 841 *buf++ = 16; 842 put_unaligned_be64(blocks, buf); 843 buf += 12; 844 put_unaligned_be32(block_size, buf); 845 846 return 17; 847 } 848 849 static sense_reason_t spc_emulate_modesense(struct se_cmd *cmd) 850 { 851 struct se_device *dev = cmd->se_dev; 852 char *cdb = cmd->t_task_cdb; 853 unsigned char buf[SE_MODE_PAGE_BUF], *rbuf; 854 int type = dev->transport->get_device_type(dev); 855 int ten = (cmd->t_task_cdb[0] == MODE_SENSE_10); 856 bool dbd = !!(cdb[1] & 0x08); 857 bool llba = ten ? !!(cdb[1] & 0x10) : false; 858 u8 pc = cdb[2] >> 6; 859 u8 page = cdb[2] & 0x3f; 860 u8 subpage = cdb[3]; 861 int length = 0; 862 int ret; 863 int i; 864 865 memset(buf, 0, SE_MODE_PAGE_BUF); 866 867 /* 868 * Skip over MODE DATA LENGTH + MEDIUM TYPE fields to byte 3 for 869 * MODE_SENSE_10 and byte 2 for MODE_SENSE (6). 870 */ 871 length = ten ? 3 : 2; 872 873 /* DEVICE-SPECIFIC PARAMETER */ 874 if ((cmd->se_lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) || 875 (cmd->se_deve && 876 (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY))) 877 spc_modesense_write_protect(&buf[length], type); 878 879 if ((dev->dev_attrib.emulate_write_cache > 0) && 880 (dev->dev_attrib.emulate_fua_write > 0)) 881 spc_modesense_dpofua(&buf[length], type); 882 883 ++length; 884 885 /* BLOCK DESCRIPTOR */ 886 887 /* 888 * For now we only include a block descriptor for disk (SBC) 889 * devices; other command sets use a slightly different format. 890 */ 891 if (!dbd && type == TYPE_DISK) { 892 u64 blocks = dev->transport->get_blocks(dev); 893 u32 block_size = dev->dev_attrib.block_size; 894 895 if (ten) { 896 if (llba) { 897 length += spc_modesense_long_blockdesc(&buf[length], 898 blocks, block_size); 899 } else { 900 length += 3; 901 length += spc_modesense_blockdesc(&buf[length], 902 blocks, block_size); 903 } 904 } else { 905 length += spc_modesense_blockdesc(&buf[length], blocks, 906 block_size); 907 } 908 } else { 909 if (ten) 910 length += 4; 911 else 912 length += 1; 913 } 914 915 if (page == 0x3f) { 916 if (subpage != 0x00 && subpage != 0xff) { 917 pr_warn("MODE_SENSE: Invalid subpage code: 0x%02x\n", subpage); 918 return TCM_INVALID_CDB_FIELD; 919 } 920 921 for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i) { 922 /* 923 * Tricky way to say all subpage 00h for 924 * subpage==0, all subpages for subpage==0xff 925 * (and we just checked above that those are 926 * the only two possibilities). 927 */ 928 if ((modesense_handlers[i].subpage & ~subpage) == 0) { 929 ret = modesense_handlers[i].emulate(dev, pc, &buf[length]); 930 if (!ten && length + ret >= 255) 931 break; 932 length += ret; 933 } 934 } 935 936 goto set_length; 937 } 938 939 for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i) 940 if (modesense_handlers[i].page == page && 941 modesense_handlers[i].subpage == subpage) { 942 length += modesense_handlers[i].emulate(dev, pc, &buf[length]); 943 goto set_length; 944 } 945 946 /* 947 * We don't intend to implement: 948 * - obsolete page 03h "format parameters" (checked by Solaris) 949 */ 950 if (page != 0x03) 951 pr_err("MODE SENSE: unimplemented page/subpage: 0x%02x/0x%02x\n", 952 page, subpage); 953 954 return TCM_UNKNOWN_MODE_PAGE; 955 956 set_length: 957 if (ten) 958 put_unaligned_be16(length - 2, buf); 959 else 960 buf[0] = length - 1; 961 962 rbuf = transport_kmap_data_sg(cmd); 963 if (rbuf) { 964 memcpy(rbuf, buf, min_t(u32, SE_MODE_PAGE_BUF, cmd->data_length)); 965 transport_kunmap_data_sg(cmd); 966 } 967 968 target_complete_cmd(cmd, GOOD); 969 return 0; 970 } 971 972 static sense_reason_t spc_emulate_modeselect(struct se_cmd *cmd) 973 { 974 struct se_device *dev = cmd->se_dev; 975 char *cdb = cmd->t_task_cdb; 976 bool ten = cdb[0] == MODE_SELECT_10; 977 int off = ten ? 8 : 4; 978 bool pf = !!(cdb[1] & 0x10); 979 u8 page, subpage; 980 unsigned char *buf; 981 unsigned char tbuf[SE_MODE_PAGE_BUF]; 982 int length; 983 int ret = 0; 984 int i; 985 986 buf = transport_kmap_data_sg(cmd); 987 if (!buf) 988 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 989 990 if (!pf) { 991 ret = TCM_INVALID_CDB_FIELD; 992 goto out; 993 } 994 995 page = buf[off] & 0x3f; 996 subpage = buf[off] & 0x40 ? buf[off + 1] : 0; 997 998 for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i) 999 if (modesense_handlers[i].page == page && 1000 modesense_handlers[i].subpage == subpage) { 1001 memset(tbuf, 0, SE_MODE_PAGE_BUF); 1002 length = modesense_handlers[i].emulate(dev, 0, tbuf); 1003 goto check_contents; 1004 } 1005 1006 ret = TCM_UNKNOWN_MODE_PAGE; 1007 goto out; 1008 1009 check_contents: 1010 if (memcmp(buf + off, tbuf, length)) 1011 ret = TCM_INVALID_PARAMETER_LIST; 1012 1013 out: 1014 transport_kunmap_data_sg(cmd); 1015 1016 if (!ret) 1017 target_complete_cmd(cmd, GOOD); 1018 return ret; 1019 } 1020 1021 static sense_reason_t spc_emulate_request_sense(struct se_cmd *cmd) 1022 { 1023 unsigned char *cdb = cmd->t_task_cdb; 1024 unsigned char *rbuf; 1025 u8 ua_asc = 0, ua_ascq = 0; 1026 unsigned char buf[SE_SENSE_BUF]; 1027 1028 memset(buf, 0, SE_SENSE_BUF); 1029 1030 if (cdb[1] & 0x01) { 1031 pr_err("REQUEST_SENSE description emulation not" 1032 " supported\n"); 1033 return TCM_INVALID_CDB_FIELD; 1034 } 1035 1036 rbuf = transport_kmap_data_sg(cmd); 1037 if (!rbuf) 1038 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1039 1040 if (!core_scsi3_ua_clear_for_request_sense(cmd, &ua_asc, &ua_ascq)) { 1041 /* 1042 * CURRENT ERROR, UNIT ATTENTION 1043 */ 1044 buf[0] = 0x70; 1045 buf[SPC_SENSE_KEY_OFFSET] = UNIT_ATTENTION; 1046 1047 /* 1048 * The Additional Sense Code (ASC) from the UNIT ATTENTION 1049 */ 1050 buf[SPC_ASC_KEY_OFFSET] = ua_asc; 1051 buf[SPC_ASCQ_KEY_OFFSET] = ua_ascq; 1052 buf[7] = 0x0A; 1053 } else { 1054 /* 1055 * CURRENT ERROR, NO SENSE 1056 */ 1057 buf[0] = 0x70; 1058 buf[SPC_SENSE_KEY_OFFSET] = NO_SENSE; 1059 1060 /* 1061 * NO ADDITIONAL SENSE INFORMATION 1062 */ 1063 buf[SPC_ASC_KEY_OFFSET] = 0x00; 1064 buf[7] = 0x0A; 1065 } 1066 1067 memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length)); 1068 transport_kunmap_data_sg(cmd); 1069 1070 target_complete_cmd(cmd, GOOD); 1071 return 0; 1072 } 1073 1074 sense_reason_t spc_emulate_report_luns(struct se_cmd *cmd) 1075 { 1076 struct se_dev_entry *deve; 1077 struct se_session *sess = cmd->se_sess; 1078 unsigned char *buf; 1079 u32 lun_count = 0, offset = 8, i; 1080 1081 if (cmd->data_length < 16) { 1082 pr_warn("REPORT LUNS allocation length %u too small\n", 1083 cmd->data_length); 1084 return TCM_INVALID_CDB_FIELD; 1085 } 1086 1087 buf = transport_kmap_data_sg(cmd); 1088 if (!buf) 1089 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1090 1091 /* 1092 * If no struct se_session pointer is present, this struct se_cmd is 1093 * coming via a target_core_mod PASSTHROUGH op, and not through 1094 * a $FABRIC_MOD. In that case, report LUN=0 only. 1095 */ 1096 if (!sess) { 1097 int_to_scsilun(0, (struct scsi_lun *)&buf[offset]); 1098 lun_count = 1; 1099 goto done; 1100 } 1101 1102 spin_lock_irq(&sess->se_node_acl->device_list_lock); 1103 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) { 1104 deve = sess->se_node_acl->device_list[i]; 1105 if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS)) 1106 continue; 1107 /* 1108 * We determine the correct LUN LIST LENGTH even once we 1109 * have reached the initial allocation length. 1110 * See SPC2-R20 7.19. 1111 */ 1112 lun_count++; 1113 if ((offset + 8) > cmd->data_length) 1114 continue; 1115 1116 int_to_scsilun(deve->mapped_lun, (struct scsi_lun *)&buf[offset]); 1117 offset += 8; 1118 } 1119 spin_unlock_irq(&sess->se_node_acl->device_list_lock); 1120 1121 /* 1122 * See SPC3 r07, page 159. 1123 */ 1124 done: 1125 lun_count *= 8; 1126 buf[0] = ((lun_count >> 24) & 0xff); 1127 buf[1] = ((lun_count >> 16) & 0xff); 1128 buf[2] = ((lun_count >> 8) & 0xff); 1129 buf[3] = (lun_count & 0xff); 1130 transport_kunmap_data_sg(cmd); 1131 1132 target_complete_cmd(cmd, GOOD); 1133 return 0; 1134 } 1135 EXPORT_SYMBOL(spc_emulate_report_luns); 1136 1137 static sense_reason_t 1138 spc_emulate_testunitready(struct se_cmd *cmd) 1139 { 1140 target_complete_cmd(cmd, GOOD); 1141 return 0; 1142 } 1143 1144 sense_reason_t 1145 spc_parse_cdb(struct se_cmd *cmd, unsigned int *size) 1146 { 1147 struct se_device *dev = cmd->se_dev; 1148 unsigned char *cdb = cmd->t_task_cdb; 1149 1150 switch (cdb[0]) { 1151 case MODE_SELECT: 1152 *size = cdb[4]; 1153 cmd->execute_cmd = spc_emulate_modeselect; 1154 break; 1155 case MODE_SELECT_10: 1156 *size = (cdb[7] << 8) + cdb[8]; 1157 cmd->execute_cmd = spc_emulate_modeselect; 1158 break; 1159 case MODE_SENSE: 1160 *size = cdb[4]; 1161 cmd->execute_cmd = spc_emulate_modesense; 1162 break; 1163 case MODE_SENSE_10: 1164 *size = (cdb[7] << 8) + cdb[8]; 1165 cmd->execute_cmd = spc_emulate_modesense; 1166 break; 1167 case LOG_SELECT: 1168 case LOG_SENSE: 1169 *size = (cdb[7] << 8) + cdb[8]; 1170 break; 1171 case PERSISTENT_RESERVE_IN: 1172 *size = (cdb[7] << 8) + cdb[8]; 1173 cmd->execute_cmd = target_scsi3_emulate_pr_in; 1174 break; 1175 case PERSISTENT_RESERVE_OUT: 1176 *size = (cdb[7] << 8) + cdb[8]; 1177 cmd->execute_cmd = target_scsi3_emulate_pr_out; 1178 break; 1179 case RELEASE: 1180 case RELEASE_10: 1181 if (cdb[0] == RELEASE_10) 1182 *size = (cdb[7] << 8) | cdb[8]; 1183 else 1184 *size = cmd->data_length; 1185 1186 cmd->execute_cmd = target_scsi2_reservation_release; 1187 break; 1188 case RESERVE: 1189 case RESERVE_10: 1190 /* 1191 * The SPC-2 RESERVE does not contain a size in the SCSI CDB. 1192 * Assume the passthrough or $FABRIC_MOD will tell us about it. 1193 */ 1194 if (cdb[0] == RESERVE_10) 1195 *size = (cdb[7] << 8) | cdb[8]; 1196 else 1197 *size = cmd->data_length; 1198 1199 cmd->execute_cmd = target_scsi2_reservation_reserve; 1200 break; 1201 case REQUEST_SENSE: 1202 *size = cdb[4]; 1203 cmd->execute_cmd = spc_emulate_request_sense; 1204 break; 1205 case INQUIRY: 1206 *size = (cdb[3] << 8) + cdb[4]; 1207 1208 /* 1209 * Do implict HEAD_OF_QUEUE processing for INQUIRY. 1210 * See spc4r17 section 5.3 1211 */ 1212 cmd->sam_task_attr = MSG_HEAD_TAG; 1213 cmd->execute_cmd = spc_emulate_inquiry; 1214 break; 1215 case SECURITY_PROTOCOL_IN: 1216 case SECURITY_PROTOCOL_OUT: 1217 *size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9]; 1218 break; 1219 case EXTENDED_COPY: 1220 case READ_ATTRIBUTE: 1221 case RECEIVE_COPY_RESULTS: 1222 case WRITE_ATTRIBUTE: 1223 *size = (cdb[10] << 24) | (cdb[11] << 16) | 1224 (cdb[12] << 8) | cdb[13]; 1225 break; 1226 case RECEIVE_DIAGNOSTIC: 1227 case SEND_DIAGNOSTIC: 1228 *size = (cdb[3] << 8) | cdb[4]; 1229 break; 1230 case WRITE_BUFFER: 1231 *size = (cdb[6] << 16) + (cdb[7] << 8) + cdb[8]; 1232 break; 1233 case REPORT_LUNS: 1234 cmd->execute_cmd = spc_emulate_report_luns; 1235 *size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9]; 1236 /* 1237 * Do implict HEAD_OF_QUEUE processing for REPORT_LUNS 1238 * See spc4r17 section 5.3 1239 */ 1240 cmd->sam_task_attr = MSG_HEAD_TAG; 1241 break; 1242 case TEST_UNIT_READY: 1243 cmd->execute_cmd = spc_emulate_testunitready; 1244 *size = 0; 1245 break; 1246 case MAINTENANCE_IN: 1247 if (dev->transport->get_device_type(dev) != TYPE_ROM) { 1248 /* 1249 * MAINTENANCE_IN from SCC-2 1250 * Check for emulated MI_REPORT_TARGET_PGS 1251 */ 1252 if ((cdb[1] & 0x1f) == MI_REPORT_TARGET_PGS) { 1253 cmd->execute_cmd = 1254 target_emulate_report_target_port_groups; 1255 } 1256 *size = get_unaligned_be32(&cdb[6]); 1257 } else { 1258 /* 1259 * GPCMD_SEND_KEY from multi media commands 1260 */ 1261 *size = get_unaligned_be16(&cdb[8]); 1262 } 1263 break; 1264 case MAINTENANCE_OUT: 1265 if (dev->transport->get_device_type(dev) != TYPE_ROM) { 1266 /* 1267 * MAINTENANCE_OUT from SCC-2 1268 * Check for emulated MO_SET_TARGET_PGS. 1269 */ 1270 if (cdb[1] == MO_SET_TARGET_PGS) { 1271 cmd->execute_cmd = 1272 target_emulate_set_target_port_groups; 1273 } 1274 *size = get_unaligned_be32(&cdb[6]); 1275 } else { 1276 /* 1277 * GPCMD_SEND_KEY from multi media commands 1278 */ 1279 *size = get_unaligned_be16(&cdb[8]); 1280 } 1281 break; 1282 default: 1283 pr_warn("TARGET_CORE[%s]: Unsupported SCSI Opcode" 1284 " 0x%02x, sending CHECK_CONDITION.\n", 1285 cmd->se_tfo->get_fabric_name(), cdb[0]); 1286 return TCM_UNSUPPORTED_SCSI_OPCODE; 1287 } 1288 1289 return 0; 1290 } 1291 EXPORT_SYMBOL(spc_parse_cdb); 1292