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