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