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