target_core_cdb.c revision a1d8b49abd60ba5d09e7c968731abcb0f8f1cbf6
1/* 2 * CDB emulation for non-READ/WRITE commands. 3 * 4 * Copyright (c) 2002, 2003, 2004, 2005 PyX Technologies, Inc. 5 * Copyright (c) 2005, 2006, 2007 SBE, Inc. 6 * Copyright (c) 2007-2010 Rising Tide Systems 7 * Copyright (c) 2008-2010 Linux-iSCSI.org 8 * 9 * Nicholas A. Bellinger <nab@kernel.org> 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or 14 * (at your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 24 */ 25 26#include <asm/unaligned.h> 27#include <scsi/scsi.h> 28 29#include <target/target_core_base.h> 30#include <target/target_core_transport.h> 31#include <target/target_core_fabric_ops.h> 32#include "target_core_ua.h" 33 34static void 35target_fill_alua_data(struct se_port *port, unsigned char *buf) 36{ 37 struct t10_alua_tg_pt_gp *tg_pt_gp; 38 struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem; 39 40 /* 41 * Set SCCS for MAINTENANCE_IN + REPORT_TARGET_PORT_GROUPS. 42 */ 43 buf[5] = 0x80; 44 45 /* 46 * Set TPGS field for explict and/or implict ALUA access type 47 * and opteration. 48 * 49 * See spc4r17 section 6.4.2 Table 135 50 */ 51 if (!port) 52 return; 53 tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem; 54 if (!tg_pt_gp_mem) 55 return; 56 57 spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock); 58 tg_pt_gp = tg_pt_gp_mem->tg_pt_gp; 59 if (tg_pt_gp) 60 buf[5] |= tg_pt_gp->tg_pt_gp_alua_access_type; 61 spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock); 62} 63 64static int 65target_emulate_inquiry_std(struct se_cmd *cmd) 66{ 67 struct se_lun *lun = cmd->se_lun; 68 struct se_device *dev = cmd->se_dev; 69 unsigned char *buf = cmd->t_task_buf; 70 71 /* 72 * Make sure we at least have 6 bytes of INQUIRY response 73 * payload going back for EVPD=0 74 */ 75 if (cmd->data_length < 6) { 76 printk(KERN_ERR "SCSI Inquiry payload length: %u" 77 " too small for EVPD=0\n", cmd->data_length); 78 return -EINVAL; 79 } 80 81 buf[0] = dev->transport->get_device_type(dev); 82 if (buf[0] == TYPE_TAPE) 83 buf[1] = 0x80; 84 buf[2] = dev->transport->get_device_rev(dev); 85 86 /* 87 * Enable SCCS and TPGS fields for Emulated ALUA 88 */ 89 if (dev->se_sub_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) 90 target_fill_alua_data(lun->lun_sep, buf); 91 92 if (cmd->data_length < 8) { 93 buf[4] = 1; /* Set additional length to 1 */ 94 return 0; 95 } 96 97 buf[7] = 0x32; /* Sync=1 and CmdQue=1 */ 98 99 /* 100 * Do not include vendor, product, reversion info in INQUIRY 101 * response payload for cdbs with a small allocation length. 102 */ 103 if (cmd->data_length < 36) { 104 buf[4] = 3; /* Set additional length to 3 */ 105 return 0; 106 } 107 108 snprintf((unsigned char *)&buf[8], 8, "LIO-ORG"); 109 snprintf((unsigned char *)&buf[16], 16, "%s", 110 &dev->se_sub_dev->t10_wwn.model[0]); 111 snprintf((unsigned char *)&buf[32], 4, "%s", 112 &dev->se_sub_dev->t10_wwn.revision[0]); 113 buf[4] = 31; /* Set additional length to 31 */ 114 return 0; 115} 116 117/* supported vital product data pages */ 118static int 119target_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf) 120{ 121 buf[1] = 0x00; 122 if (cmd->data_length < 8) 123 return 0; 124 125 buf[4] = 0x0; 126 /* 127 * Only report the INQUIRY EVPD=1 pages after a valid NAA 128 * Registered Extended LUN WWN has been set via ConfigFS 129 * during device creation/restart. 130 */ 131 if (cmd->se_dev->se_sub_dev->su_dev_flags & 132 SDF_EMULATED_VPD_UNIT_SERIAL) { 133 buf[3] = 3; 134 buf[5] = 0x80; 135 buf[6] = 0x83; 136 buf[7] = 0x86; 137 } 138 139 return 0; 140} 141 142/* unit serial number */ 143static int 144target_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf) 145{ 146 struct se_device *dev = cmd->se_dev; 147 u16 len = 0; 148 149 buf[1] = 0x80; 150 if (dev->se_sub_dev->su_dev_flags & 151 SDF_EMULATED_VPD_UNIT_SERIAL) { 152 u32 unit_serial_len; 153 154 unit_serial_len = 155 strlen(&dev->se_sub_dev->t10_wwn.unit_serial[0]); 156 unit_serial_len++; /* For NULL Terminator */ 157 158 if (((len + 4) + unit_serial_len) > cmd->data_length) { 159 len += unit_serial_len; 160 buf[2] = ((len >> 8) & 0xff); 161 buf[3] = (len & 0xff); 162 return 0; 163 } 164 len += sprintf((unsigned char *)&buf[4], "%s", 165 &dev->se_sub_dev->t10_wwn.unit_serial[0]); 166 len++; /* Extra Byte for NULL Terminator */ 167 buf[3] = len; 168 } 169 return 0; 170} 171 172/* 173 * Device identification VPD, for a complete list of 174 * DESIGNATOR TYPEs see spc4r17 Table 459. 175 */ 176static int 177target_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf) 178{ 179 struct se_device *dev = cmd->se_dev; 180 struct se_lun *lun = cmd->se_lun; 181 struct se_port *port = NULL; 182 struct se_portal_group *tpg = NULL; 183 struct t10_alua_lu_gp_member *lu_gp_mem; 184 struct t10_alua_tg_pt_gp *tg_pt_gp; 185 struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem; 186 unsigned char binary, binary_new; 187 unsigned char *prod = &dev->se_sub_dev->t10_wwn.model[0]; 188 u32 prod_len; 189 u32 unit_serial_len, off = 0; 190 int i; 191 u16 len = 0, id_len; 192 193 buf[1] = 0x83; 194 off = 4; 195 196 /* 197 * NAA IEEE Registered Extended Assigned designator format, see 198 * spc4r17 section 7.7.3.6.5 199 * 200 * We depend upon a target_core_mod/ConfigFS provided 201 * /sys/kernel/config/target/core/$HBA/$DEV/wwn/vpd_unit_serial 202 * value in order to return the NAA id. 203 */ 204 if (!(dev->se_sub_dev->su_dev_flags & SDF_EMULATED_VPD_UNIT_SERIAL)) 205 goto check_t10_vend_desc; 206 207 if (off + 20 > cmd->data_length) 208 goto check_t10_vend_desc; 209 210 /* CODE SET == Binary */ 211 buf[off++] = 0x1; 212 213 /* Set ASSOICATION == addressed logical unit: 0)b */ 214 buf[off] = 0x00; 215 216 /* Identifier/Designator type == NAA identifier */ 217 buf[off++] = 0x3; 218 off++; 219 220 /* Identifier/Designator length */ 221 buf[off++] = 0x10; 222 223 /* 224 * Start NAA IEEE Registered Extended Identifier/Designator 225 */ 226 buf[off++] = (0x6 << 4); 227 228 /* 229 * Use OpenFabrics IEEE Company ID: 00 14 05 230 */ 231 buf[off++] = 0x01; 232 buf[off++] = 0x40; 233 buf[off] = (0x5 << 4); 234 235 /* 236 * Return ConfigFS Unit Serial Number information for 237 * VENDOR_SPECIFIC_IDENTIFIER and 238 * VENDOR_SPECIFIC_IDENTIFIER_EXTENTION 239 */ 240 binary = transport_asciihex_to_binaryhex( 241 &dev->se_sub_dev->t10_wwn.unit_serial[0]); 242 buf[off++] |= (binary & 0xf0) >> 4; 243 for (i = 0; i < 24; i += 2) { 244 binary_new = transport_asciihex_to_binaryhex( 245 &dev->se_sub_dev->t10_wwn.unit_serial[i+2]); 246 buf[off] = (binary & 0x0f) << 4; 247 buf[off++] |= (binary_new & 0xf0) >> 4; 248 binary = binary_new; 249 } 250 len = 20; 251 off = (len + 4); 252 253check_t10_vend_desc: 254 /* 255 * T10 Vendor Identifier Page, see spc4r17 section 7.7.3.4 256 */ 257 id_len = 8; /* For Vendor field */ 258 prod_len = 4; /* For VPD Header */ 259 prod_len += 8; /* For Vendor field */ 260 prod_len += strlen(prod); 261 prod_len++; /* For : */ 262 263 if (dev->se_sub_dev->su_dev_flags & 264 SDF_EMULATED_VPD_UNIT_SERIAL) { 265 unit_serial_len = 266 strlen(&dev->se_sub_dev->t10_wwn.unit_serial[0]); 267 unit_serial_len++; /* For NULL Terminator */ 268 269 if ((len + (id_len + 4) + 270 (prod_len + unit_serial_len)) > 271 cmd->data_length) { 272 len += (prod_len + unit_serial_len); 273 goto check_port; 274 } 275 id_len += sprintf((unsigned char *)&buf[off+12], 276 "%s:%s", prod, 277 &dev->se_sub_dev->t10_wwn.unit_serial[0]); 278 } 279 buf[off] = 0x2; /* ASCII */ 280 buf[off+1] = 0x1; /* T10 Vendor ID */ 281 buf[off+2] = 0x0; 282 memcpy((unsigned char *)&buf[off+4], "LIO-ORG", 8); 283 /* Extra Byte for NULL Terminator */ 284 id_len++; 285 /* Identifier Length */ 286 buf[off+3] = id_len; 287 /* Header size for Designation descriptor */ 288 len += (id_len + 4); 289 off += (id_len + 4); 290 /* 291 * struct se_port is only set for INQUIRY VPD=1 through $FABRIC_MOD 292 */ 293check_port: 294 port = lun->lun_sep; 295 if (port) { 296 struct t10_alua_lu_gp *lu_gp; 297 u32 padding, scsi_name_len; 298 u16 lu_gp_id = 0; 299 u16 tg_pt_gp_id = 0; 300 u16 tpgt; 301 302 tpg = port->sep_tpg; 303 /* 304 * Relative target port identifer, see spc4r17 305 * section 7.7.3.7 306 * 307 * Get the PROTOCOL IDENTIFIER as defined by spc4r17 308 * section 7.5.1 Table 362 309 */ 310 if (((len + 4) + 8) > cmd->data_length) { 311 len += 8; 312 goto check_tpgi; 313 } 314 buf[off] = 315 (tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4); 316 buf[off++] |= 0x1; /* CODE SET == Binary */ 317 buf[off] = 0x80; /* Set PIV=1 */ 318 /* Set ASSOICATION == target port: 01b */ 319 buf[off] |= 0x10; 320 /* DESIGNATOR TYPE == Relative target port identifer */ 321 buf[off++] |= 0x4; 322 off++; /* Skip over Reserved */ 323 buf[off++] = 4; /* DESIGNATOR LENGTH */ 324 /* Skip over Obsolete field in RTPI payload 325 * in Table 472 */ 326 off += 2; 327 buf[off++] = ((port->sep_rtpi >> 8) & 0xff); 328 buf[off++] = (port->sep_rtpi & 0xff); 329 len += 8; /* Header size + Designation descriptor */ 330 /* 331 * Target port group identifier, see spc4r17 332 * section 7.7.3.8 333 * 334 * Get the PROTOCOL IDENTIFIER as defined by spc4r17 335 * section 7.5.1 Table 362 336 */ 337check_tpgi: 338 if (dev->se_sub_dev->t10_alua.alua_type != 339 SPC3_ALUA_EMULATED) 340 goto check_scsi_name; 341 342 if (((len + 4) + 8) > cmd->data_length) { 343 len += 8; 344 goto check_lu_gp; 345 } 346 tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem; 347 if (!tg_pt_gp_mem) 348 goto check_lu_gp; 349 350 spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock); 351 tg_pt_gp = tg_pt_gp_mem->tg_pt_gp; 352 if (!(tg_pt_gp)) { 353 spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock); 354 goto check_lu_gp; 355 } 356 tg_pt_gp_id = tg_pt_gp->tg_pt_gp_id; 357 spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock); 358 359 buf[off] = 360 (tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4); 361 buf[off++] |= 0x1; /* CODE SET == Binary */ 362 buf[off] = 0x80; /* Set PIV=1 */ 363 /* Set ASSOICATION == target port: 01b */ 364 buf[off] |= 0x10; 365 /* DESIGNATOR TYPE == Target port group identifier */ 366 buf[off++] |= 0x5; 367 off++; /* Skip over Reserved */ 368 buf[off++] = 4; /* DESIGNATOR LENGTH */ 369 off += 2; /* Skip over Reserved Field */ 370 buf[off++] = ((tg_pt_gp_id >> 8) & 0xff); 371 buf[off++] = (tg_pt_gp_id & 0xff); 372 len += 8; /* Header size + Designation descriptor */ 373 /* 374 * Logical Unit Group identifier, see spc4r17 375 * section 7.7.3.8 376 */ 377check_lu_gp: 378 if (((len + 4) + 8) > cmd->data_length) { 379 len += 8; 380 goto check_scsi_name; 381 } 382 lu_gp_mem = dev->dev_alua_lu_gp_mem; 383 if (!(lu_gp_mem)) 384 goto check_scsi_name; 385 386 spin_lock(&lu_gp_mem->lu_gp_mem_lock); 387 lu_gp = lu_gp_mem->lu_gp; 388 if (!(lu_gp)) { 389 spin_unlock(&lu_gp_mem->lu_gp_mem_lock); 390 goto check_scsi_name; 391 } 392 lu_gp_id = lu_gp->lu_gp_id; 393 spin_unlock(&lu_gp_mem->lu_gp_mem_lock); 394 395 buf[off++] |= 0x1; /* CODE SET == Binary */ 396 /* DESIGNATOR TYPE == Logical Unit Group identifier */ 397 buf[off++] |= 0x6; 398 off++; /* Skip over Reserved */ 399 buf[off++] = 4; /* DESIGNATOR LENGTH */ 400 off += 2; /* Skip over Reserved Field */ 401 buf[off++] = ((lu_gp_id >> 8) & 0xff); 402 buf[off++] = (lu_gp_id & 0xff); 403 len += 8; /* Header size + Designation descriptor */ 404 /* 405 * SCSI name string designator, see spc4r17 406 * section 7.7.3.11 407 * 408 * Get the PROTOCOL IDENTIFIER as defined by spc4r17 409 * section 7.5.1 Table 362 410 */ 411check_scsi_name: 412 scsi_name_len = strlen(tpg->se_tpg_tfo->tpg_get_wwn(tpg)); 413 /* UTF-8 ",t,0x<16-bit TPGT>" + NULL Terminator */ 414 scsi_name_len += 10; 415 /* Check for 4-byte padding */ 416 padding = ((-scsi_name_len) & 3); 417 if (padding != 0) 418 scsi_name_len += padding; 419 /* Header size + Designation descriptor */ 420 scsi_name_len += 4; 421 422 if (((len + 4) + scsi_name_len) > cmd->data_length) { 423 len += scsi_name_len; 424 goto set_len; 425 } 426 buf[off] = 427 (tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4); 428 buf[off++] |= 0x3; /* CODE SET == UTF-8 */ 429 buf[off] = 0x80; /* Set PIV=1 */ 430 /* Set ASSOICATION == target port: 01b */ 431 buf[off] |= 0x10; 432 /* DESIGNATOR TYPE == SCSI name string */ 433 buf[off++] |= 0x8; 434 off += 2; /* Skip over Reserved and length */ 435 /* 436 * SCSI name string identifer containing, $FABRIC_MOD 437 * dependent information. For LIO-Target and iSCSI 438 * Target Port, this means "<iSCSI name>,t,0x<TPGT> in 439 * UTF-8 encoding. 440 */ 441 tpgt = tpg->se_tpg_tfo->tpg_get_tag(tpg); 442 scsi_name_len = sprintf(&buf[off], "%s,t,0x%04x", 443 tpg->se_tpg_tfo->tpg_get_wwn(tpg), tpgt); 444 scsi_name_len += 1 /* Include NULL terminator */; 445 /* 446 * The null-terminated, null-padded (see 4.4.2) SCSI 447 * NAME STRING field contains a UTF-8 format string. 448 * The number of bytes in the SCSI NAME STRING field 449 * (i.e., the value in the DESIGNATOR LENGTH field) 450 * shall be no larger than 256 and shall be a multiple 451 * of four. 452 */ 453 if (padding) 454 scsi_name_len += padding; 455 456 buf[off-1] = scsi_name_len; 457 off += scsi_name_len; 458 /* Header size + Designation descriptor */ 459 len += (scsi_name_len + 4); 460 } 461set_len: 462 buf[2] = ((len >> 8) & 0xff); 463 buf[3] = (len & 0xff); /* Page Length for VPD 0x83 */ 464 return 0; 465} 466 467/* Extended INQUIRY Data VPD Page */ 468static int 469target_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf) 470{ 471 if (cmd->data_length < 60) 472 return 0; 473 474 buf[1] = 0x86; 475 buf[2] = 0x3c; 476 /* Set HEADSUP, ORDSUP, SIMPSUP */ 477 buf[5] = 0x07; 478 479 /* If WriteCache emulation is enabled, set V_SUP */ 480 if (cmd->se_dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0) 481 buf[6] = 0x01; 482 return 0; 483} 484 485/* Block Limits VPD page */ 486static int 487target_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf) 488{ 489 struct se_device *dev = cmd->se_dev; 490 int have_tp = 0; 491 492 /* 493 * Following sbc3r22 section 6.5.3 Block Limits VPD page, when 494 * emulate_tpu=1 or emulate_tpws=1 we will be expect a 495 * different page length for Thin Provisioning. 496 */ 497 if (dev->se_sub_dev->se_dev_attrib.emulate_tpu || dev->se_sub_dev->se_dev_attrib.emulate_tpws) 498 have_tp = 1; 499 500 if (cmd->data_length < (0x10 + 4)) { 501 printk(KERN_INFO "Received data_length: %u" 502 " too small for EVPD 0xb0\n", 503 cmd->data_length); 504 return -EINVAL; 505 } 506 507 if (have_tp && cmd->data_length < (0x3c + 4)) { 508 printk(KERN_INFO "Received data_length: %u" 509 " too small for TPE=1 EVPD 0xb0\n", 510 cmd->data_length); 511 have_tp = 0; 512 } 513 514 buf[0] = dev->transport->get_device_type(dev); 515 buf[1] = 0xb0; 516 buf[3] = have_tp ? 0x3c : 0x10; 517 518 /* 519 * Set OPTIMAL TRANSFER LENGTH GRANULARITY 520 */ 521 put_unaligned_be16(1, &buf[6]); 522 523 /* 524 * Set MAXIMUM TRANSFER LENGTH 525 */ 526 put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.max_sectors, &buf[8]); 527 528 /* 529 * Set OPTIMAL TRANSFER LENGTH 530 */ 531 put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.optimal_sectors, &buf[12]); 532 533 /* 534 * Exit now if we don't support TP or the initiator sent a too 535 * short buffer. 536 */ 537 if (!have_tp || cmd->data_length < (0x3c + 4)) 538 return 0; 539 540 /* 541 * Set MAXIMUM UNMAP LBA COUNT 542 */ 543 put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.max_unmap_lba_count, &buf[20]); 544 545 /* 546 * Set MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT 547 */ 548 put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count, 549 &buf[24]); 550 551 /* 552 * Set OPTIMAL UNMAP GRANULARITY 553 */ 554 put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.unmap_granularity, &buf[28]); 555 556 /* 557 * UNMAP GRANULARITY ALIGNMENT 558 */ 559 put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.unmap_granularity_alignment, 560 &buf[32]); 561 if (dev->se_sub_dev->se_dev_attrib.unmap_granularity_alignment != 0) 562 buf[32] |= 0x80; /* Set the UGAVALID bit */ 563 564 return 0; 565} 566 567/* Thin Provisioning VPD */ 568static int 569target_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf) 570{ 571 struct se_device *dev = cmd->se_dev; 572 573 /* 574 * From sbc3r22 section 6.5.4 Thin Provisioning VPD page: 575 * 576 * The PAGE LENGTH field is defined in SPC-4. If the DP bit is set to 577 * zero, then the page length shall be set to 0004h. If the DP bit 578 * is set to one, then the page length shall be set to the value 579 * defined in table 162. 580 */ 581 buf[0] = dev->transport->get_device_type(dev); 582 buf[1] = 0xb2; 583 584 /* 585 * Set Hardcoded length mentioned above for DP=0 586 */ 587 put_unaligned_be16(0x0004, &buf[2]); 588 589 /* 590 * The THRESHOLD EXPONENT field indicates the threshold set size in 591 * LBAs as a power of 2 (i.e., the threshold set size is equal to 592 * 2(threshold exponent)). 593 * 594 * Note that this is currently set to 0x00 as mkp says it will be 595 * changing again. We can enable this once it has settled in T10 596 * and is actually used by Linux/SCSI ML code. 597 */ 598 buf[4] = 0x00; 599 600 /* 601 * A TPU bit set to one indicates that the device server supports 602 * the UNMAP command (see 5.25). A TPU bit set to zero indicates 603 * that the device server does not support the UNMAP command. 604 */ 605 if (dev->se_sub_dev->se_dev_attrib.emulate_tpu != 0) 606 buf[5] = 0x80; 607 608 /* 609 * A TPWS bit set to one indicates that the device server supports 610 * the use of the WRITE SAME (16) command (see 5.42) to unmap LBAs. 611 * A TPWS bit set to zero indicates that the device server does not 612 * support the use of the WRITE SAME (16) command to unmap LBAs. 613 */ 614 if (dev->se_sub_dev->se_dev_attrib.emulate_tpws != 0) 615 buf[5] |= 0x40; 616 617 return 0; 618} 619 620static int 621target_emulate_inquiry(struct se_cmd *cmd) 622{ 623 struct se_device *dev = cmd->se_dev; 624 unsigned char *buf = cmd->t_task_buf; 625 unsigned char *cdb = cmd->t_task_cdb; 626 627 if (!(cdb[1] & 0x1)) 628 return target_emulate_inquiry_std(cmd); 629 630 /* 631 * Make sure we at least have 4 bytes of INQUIRY response 632 * payload for 0x00 going back for EVPD=1. Note that 0x80 633 * and 0x83 will check for enough payload data length and 634 * jump to set_len: label when there is not enough inquiry EVPD 635 * payload length left for the next outgoing EVPD metadata 636 */ 637 if (cmd->data_length < 4) { 638 printk(KERN_ERR "SCSI Inquiry payload length: %u" 639 " too small for EVPD=1\n", cmd->data_length); 640 return -EINVAL; 641 } 642 buf[0] = dev->transport->get_device_type(dev); 643 644 switch (cdb[2]) { 645 case 0x00: 646 return target_emulate_evpd_00(cmd, buf); 647 case 0x80: 648 return target_emulate_evpd_80(cmd, buf); 649 case 0x83: 650 return target_emulate_evpd_83(cmd, buf); 651 case 0x86: 652 return target_emulate_evpd_86(cmd, buf); 653 case 0xb0: 654 return target_emulate_evpd_b0(cmd, buf); 655 case 0xb2: 656 return target_emulate_evpd_b2(cmd, buf); 657 default: 658 printk(KERN_ERR "Unknown VPD Code: 0x%02x\n", cdb[2]); 659 return -EINVAL; 660 } 661 662 return 0; 663} 664 665static int 666target_emulate_readcapacity(struct se_cmd *cmd) 667{ 668 struct se_device *dev = cmd->se_dev; 669 unsigned char *buf = cmd->t_task_buf; 670 unsigned long long blocks_long = dev->transport->get_blocks(dev); 671 u32 blocks; 672 673 if (blocks_long >= 0x00000000ffffffff) 674 blocks = 0xffffffff; 675 else 676 blocks = (u32)blocks_long; 677 678 buf[0] = (blocks >> 24) & 0xff; 679 buf[1] = (blocks >> 16) & 0xff; 680 buf[2] = (blocks >> 8) & 0xff; 681 buf[3] = blocks & 0xff; 682 buf[4] = (dev->se_sub_dev->se_dev_attrib.block_size >> 24) & 0xff; 683 buf[5] = (dev->se_sub_dev->se_dev_attrib.block_size >> 16) & 0xff; 684 buf[6] = (dev->se_sub_dev->se_dev_attrib.block_size >> 8) & 0xff; 685 buf[7] = dev->se_sub_dev->se_dev_attrib.block_size & 0xff; 686 /* 687 * Set max 32-bit blocks to signal SERVICE ACTION READ_CAPACITY_16 688 */ 689 if (dev->se_sub_dev->se_dev_attrib.emulate_tpu || dev->se_sub_dev->se_dev_attrib.emulate_tpws) 690 put_unaligned_be32(0xFFFFFFFF, &buf[0]); 691 692 return 0; 693} 694 695static int 696target_emulate_readcapacity_16(struct se_cmd *cmd) 697{ 698 struct se_device *dev = cmd->se_dev; 699 unsigned char *buf = cmd->t_task_buf; 700 unsigned long long blocks = dev->transport->get_blocks(dev); 701 702 buf[0] = (blocks >> 56) & 0xff; 703 buf[1] = (blocks >> 48) & 0xff; 704 buf[2] = (blocks >> 40) & 0xff; 705 buf[3] = (blocks >> 32) & 0xff; 706 buf[4] = (blocks >> 24) & 0xff; 707 buf[5] = (blocks >> 16) & 0xff; 708 buf[6] = (blocks >> 8) & 0xff; 709 buf[7] = blocks & 0xff; 710 buf[8] = (dev->se_sub_dev->se_dev_attrib.block_size >> 24) & 0xff; 711 buf[9] = (dev->se_sub_dev->se_dev_attrib.block_size >> 16) & 0xff; 712 buf[10] = (dev->se_sub_dev->se_dev_attrib.block_size >> 8) & 0xff; 713 buf[11] = dev->se_sub_dev->se_dev_attrib.block_size & 0xff; 714 /* 715 * Set Thin Provisioning Enable bit following sbc3r22 in section 716 * READ CAPACITY (16) byte 14 if emulate_tpu or emulate_tpws is enabled. 717 */ 718 if (dev->se_sub_dev->se_dev_attrib.emulate_tpu || dev->se_sub_dev->se_dev_attrib.emulate_tpws) 719 buf[14] = 0x80; 720 721 return 0; 722} 723 724static int 725target_modesense_rwrecovery(unsigned char *p) 726{ 727 p[0] = 0x01; 728 p[1] = 0x0a; 729 730 return 12; 731} 732 733static int 734target_modesense_control(struct se_device *dev, unsigned char *p) 735{ 736 p[0] = 0x0a; 737 p[1] = 0x0a; 738 p[2] = 2; 739 /* 740 * From spc4r17, section 7.4.6 Control mode Page 741 * 742 * Unit Attention interlocks control (UN_INTLCK_CTRL) to code 00b 743 * 744 * 00b: The logical unit shall clear any unit attention condition 745 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION 746 * status and shall not establish a unit attention condition when a com- 747 * mand is completed with BUSY, TASK SET FULL, or RESERVATION CONFLICT 748 * status. 749 * 750 * 10b: The logical unit shall not clear any unit attention condition 751 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION 752 * status and shall not establish a unit attention condition when 753 * a command is completed with BUSY, TASK SET FULL, or RESERVATION 754 * CONFLICT status. 755 * 756 * 11b a The logical unit shall not clear any unit attention condition 757 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION 758 * status and shall establish a unit attention condition for the 759 * initiator port associated with the I_T nexus on which the BUSY, 760 * TASK SET FULL, or RESERVATION CONFLICT status is being returned. 761 * Depending on the status, the additional sense code shall be set to 762 * PREVIOUS BUSY STATUS, PREVIOUS TASK SET FULL STATUS, or PREVIOUS 763 * RESERVATION CONFLICT STATUS. Until it is cleared by a REQUEST SENSE 764 * command, a unit attention condition shall be established only once 765 * for a BUSY, TASK SET FULL, or RESERVATION CONFLICT status regardless 766 * to the number of commands completed with one of those status codes. 767 */ 768 p[4] = (dev->se_sub_dev->se_dev_attrib.emulate_ua_intlck_ctrl == 2) ? 0x30 : 769 (dev->se_sub_dev->se_dev_attrib.emulate_ua_intlck_ctrl == 1) ? 0x20 : 0x00; 770 /* 771 * From spc4r17, section 7.4.6 Control mode Page 772 * 773 * Task Aborted Status (TAS) bit set to zero. 774 * 775 * A task aborted status (TAS) bit set to zero specifies that aborted 776 * tasks shall be terminated by the device server without any response 777 * to the application client. A TAS bit set to one specifies that tasks 778 * aborted by the actions of an I_T nexus other than the I_T nexus on 779 * which the command was received shall be completed with TASK ABORTED 780 * status (see SAM-4). 781 */ 782 p[5] = (dev->se_sub_dev->se_dev_attrib.emulate_tas) ? 0x40 : 0x00; 783 p[8] = 0xff; 784 p[9] = 0xff; 785 p[11] = 30; 786 787 return 12; 788} 789 790static int 791target_modesense_caching(struct se_device *dev, unsigned char *p) 792{ 793 p[0] = 0x08; 794 p[1] = 0x12; 795 if (dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0) 796 p[2] = 0x04; /* Write Cache Enable */ 797 p[12] = 0x20; /* Disabled Read Ahead */ 798 799 return 20; 800} 801 802static void 803target_modesense_write_protect(unsigned char *buf, int type) 804{ 805 /* 806 * I believe that the WP bit (bit 7) in the mode header is the same for 807 * all device types.. 808 */ 809 switch (type) { 810 case TYPE_DISK: 811 case TYPE_TAPE: 812 default: 813 buf[0] |= 0x80; /* WP bit */ 814 break; 815 } 816} 817 818static void 819target_modesense_dpofua(unsigned char *buf, int type) 820{ 821 switch (type) { 822 case TYPE_DISK: 823 buf[0] |= 0x10; /* DPOFUA bit */ 824 break; 825 default: 826 break; 827 } 828} 829 830static int 831target_emulate_modesense(struct se_cmd *cmd, int ten) 832{ 833 struct se_device *dev = cmd->se_dev; 834 char *cdb = cmd->t_task_cdb; 835 unsigned char *rbuf = cmd->t_task_buf; 836 int type = dev->transport->get_device_type(dev); 837 int offset = (ten) ? 8 : 4; 838 int length = 0; 839 unsigned char buf[SE_MODE_PAGE_BUF]; 840 841 memset(buf, 0, SE_MODE_PAGE_BUF); 842 843 switch (cdb[2] & 0x3f) { 844 case 0x01: 845 length = target_modesense_rwrecovery(&buf[offset]); 846 break; 847 case 0x08: 848 length = target_modesense_caching(dev, &buf[offset]); 849 break; 850 case 0x0a: 851 length = target_modesense_control(dev, &buf[offset]); 852 break; 853 case 0x3f: 854 length = target_modesense_rwrecovery(&buf[offset]); 855 length += target_modesense_caching(dev, &buf[offset+length]); 856 length += target_modesense_control(dev, &buf[offset+length]); 857 break; 858 default: 859 printk(KERN_ERR "Got Unknown Mode Page: 0x%02x\n", 860 cdb[2] & 0x3f); 861 return PYX_TRANSPORT_UNKNOWN_MODE_PAGE; 862 } 863 offset += length; 864 865 if (ten) { 866 offset -= 2; 867 buf[0] = (offset >> 8) & 0xff; 868 buf[1] = offset & 0xff; 869 870 if ((cmd->se_lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) || 871 (cmd->se_deve && 872 (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY))) 873 target_modesense_write_protect(&buf[3], type); 874 875 if ((dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0) && 876 (dev->se_sub_dev->se_dev_attrib.emulate_fua_write > 0)) 877 target_modesense_dpofua(&buf[3], type); 878 879 if ((offset + 2) > cmd->data_length) 880 offset = cmd->data_length; 881 882 } else { 883 offset -= 1; 884 buf[0] = offset & 0xff; 885 886 if ((cmd->se_lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) || 887 (cmd->se_deve && 888 (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY))) 889 target_modesense_write_protect(&buf[2], type); 890 891 if ((dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0) && 892 (dev->se_sub_dev->se_dev_attrib.emulate_fua_write > 0)) 893 target_modesense_dpofua(&buf[2], type); 894 895 if ((offset + 1) > cmd->data_length) 896 offset = cmd->data_length; 897 } 898 memcpy(rbuf, buf, offset); 899 900 return 0; 901} 902 903static int 904target_emulate_request_sense(struct se_cmd *cmd) 905{ 906 unsigned char *cdb = cmd->t_task_cdb; 907 unsigned char *buf = cmd->t_task_buf; 908 u8 ua_asc = 0, ua_ascq = 0; 909 910 if (cdb[1] & 0x01) { 911 printk(KERN_ERR "REQUEST_SENSE description emulation not" 912 " supported\n"); 913 return PYX_TRANSPORT_INVALID_CDB_FIELD; 914 } 915 if (!(core_scsi3_ua_clear_for_request_sense(cmd, &ua_asc, &ua_ascq))) { 916 /* 917 * CURRENT ERROR, UNIT ATTENTION 918 */ 919 buf[0] = 0x70; 920 buf[SPC_SENSE_KEY_OFFSET] = UNIT_ATTENTION; 921 /* 922 * Make sure request data length is enough for additional 923 * sense data. 924 */ 925 if (cmd->data_length <= 18) { 926 buf[7] = 0x00; 927 return 0; 928 } 929 /* 930 * The Additional Sense Code (ASC) from the UNIT ATTENTION 931 */ 932 buf[SPC_ASC_KEY_OFFSET] = ua_asc; 933 buf[SPC_ASCQ_KEY_OFFSET] = ua_ascq; 934 buf[7] = 0x0A; 935 } else { 936 /* 937 * CURRENT ERROR, NO SENSE 938 */ 939 buf[0] = 0x70; 940 buf[SPC_SENSE_KEY_OFFSET] = NO_SENSE; 941 /* 942 * Make sure request data length is enough for additional 943 * sense data. 944 */ 945 if (cmd->data_length <= 18) { 946 buf[7] = 0x00; 947 return 0; 948 } 949 /* 950 * NO ADDITIONAL SENSE INFORMATION 951 */ 952 buf[SPC_ASC_KEY_OFFSET] = 0x00; 953 buf[7] = 0x0A; 954 } 955 956 return 0; 957} 958 959/* 960 * Used for TCM/IBLOCK and TCM/FILEIO for block/blk-lib.c level discard support. 961 * Note this is not used for TCM/pSCSI passthrough 962 */ 963static int 964target_emulate_unmap(struct se_task *task) 965{ 966 struct se_cmd *cmd = task->task_se_cmd; 967 struct se_device *dev = cmd->se_dev; 968 unsigned char *buf = cmd->t_task_buf, *ptr = NULL; 969 unsigned char *cdb = &cmd->t_task_cdb[0]; 970 sector_t lba; 971 unsigned int size = cmd->data_length, range; 972 int ret, offset; 973 unsigned short dl, bd_dl; 974 975 /* First UNMAP block descriptor starts at 8 byte offset */ 976 offset = 8; 977 size -= 8; 978 dl = get_unaligned_be16(&cdb[0]); 979 bd_dl = get_unaligned_be16(&cdb[2]); 980 ptr = &buf[offset]; 981 printk(KERN_INFO "UNMAP: Sub: %s Using dl: %hu bd_dl: %hu size: %hu" 982 " ptr: %p\n", dev->transport->name, dl, bd_dl, size, ptr); 983 984 while (size) { 985 lba = get_unaligned_be64(&ptr[0]); 986 range = get_unaligned_be32(&ptr[8]); 987 printk(KERN_INFO "UNMAP: Using lba: %llu and range: %u\n", 988 (unsigned long long)lba, range); 989 990 ret = dev->transport->do_discard(dev, lba, range); 991 if (ret < 0) { 992 printk(KERN_ERR "blkdev_issue_discard() failed: %d\n", 993 ret); 994 return ret; 995 } 996 997 ptr += 16; 998 size -= 16; 999 } 1000 1001 task->task_scsi_status = GOOD; 1002 transport_complete_task(task, 1); 1003 return 0; 1004} 1005 1006/* 1007 * Used for TCM/IBLOCK and TCM/FILEIO for block/blk-lib.c level discard support. 1008 * Note this is not used for TCM/pSCSI passthrough 1009 */ 1010static int 1011target_emulate_write_same(struct se_task *task, int write_same32) 1012{ 1013 struct se_cmd *cmd = task->task_se_cmd; 1014 struct se_device *dev = cmd->se_dev; 1015 sector_t range; 1016 sector_t lba = cmd->t_task_lba; 1017 unsigned int num_blocks; 1018 int ret; 1019 /* 1020 * Extract num_blocks from the WRITE_SAME_* CDB. Then use the explict 1021 * range when non zero is supplied, otherwise calculate the remaining 1022 * range based on ->get_blocks() - starting LBA. 1023 */ 1024 if (write_same32) 1025 num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]); 1026 else 1027 num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]); 1028 1029 if (num_blocks != 0) 1030 range = num_blocks; 1031 else 1032 range = (dev->transport->get_blocks(dev) - lba); 1033 1034 printk(KERN_INFO "WRITE_SAME UNMAP: LBA: %llu Range: %llu\n", 1035 (unsigned long long)lba, (unsigned long long)range); 1036 1037 ret = dev->transport->do_discard(dev, lba, range); 1038 if (ret < 0) { 1039 printk(KERN_INFO "blkdev_issue_discard() failed for WRITE_SAME\n"); 1040 return ret; 1041 } 1042 1043 task->task_scsi_status = GOOD; 1044 transport_complete_task(task, 1); 1045 return 0; 1046} 1047 1048int 1049transport_emulate_control_cdb(struct se_task *task) 1050{ 1051 struct se_cmd *cmd = task->task_se_cmd; 1052 struct se_device *dev = cmd->se_dev; 1053 unsigned short service_action; 1054 int ret = 0; 1055 1056 switch (cmd->t_task_cdb[0]) { 1057 case INQUIRY: 1058 ret = target_emulate_inquiry(cmd); 1059 break; 1060 case READ_CAPACITY: 1061 ret = target_emulate_readcapacity(cmd); 1062 break; 1063 case MODE_SENSE: 1064 ret = target_emulate_modesense(cmd, 0); 1065 break; 1066 case MODE_SENSE_10: 1067 ret = target_emulate_modesense(cmd, 1); 1068 break; 1069 case SERVICE_ACTION_IN: 1070 switch (cmd->t_task_cdb[1] & 0x1f) { 1071 case SAI_READ_CAPACITY_16: 1072 ret = target_emulate_readcapacity_16(cmd); 1073 break; 1074 default: 1075 printk(KERN_ERR "Unsupported SA: 0x%02x\n", 1076 cmd->t_task_cdb[1] & 0x1f); 1077 return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1078 } 1079 break; 1080 case REQUEST_SENSE: 1081 ret = target_emulate_request_sense(cmd); 1082 break; 1083 case UNMAP: 1084 if (!dev->transport->do_discard) { 1085 printk(KERN_ERR "UNMAP emulation not supported for: %s\n", 1086 dev->transport->name); 1087 return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1088 } 1089 ret = target_emulate_unmap(task); 1090 break; 1091 case WRITE_SAME_16: 1092 if (!dev->transport->do_discard) { 1093 printk(KERN_ERR "WRITE_SAME_16 emulation not supported" 1094 " for: %s\n", dev->transport->name); 1095 return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1096 } 1097 ret = target_emulate_write_same(task, 0); 1098 break; 1099 case VARIABLE_LENGTH_CMD: 1100 service_action = 1101 get_unaligned_be16(&cmd->t_task_cdb[8]); 1102 switch (service_action) { 1103 case WRITE_SAME_32: 1104 if (!dev->transport->do_discard) { 1105 printk(KERN_ERR "WRITE_SAME_32 SA emulation not" 1106 " supported for: %s\n", 1107 dev->transport->name); 1108 return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1109 } 1110 ret = target_emulate_write_same(task, 1); 1111 break; 1112 default: 1113 printk(KERN_ERR "Unsupported VARIABLE_LENGTH_CMD SA:" 1114 " 0x%02x\n", service_action); 1115 break; 1116 } 1117 break; 1118 case SYNCHRONIZE_CACHE: 1119 case 0x91: /* SYNCHRONIZE_CACHE_16: */ 1120 if (!dev->transport->do_sync_cache) { 1121 printk(KERN_ERR 1122 "SYNCHRONIZE_CACHE emulation not supported" 1123 " for: %s\n", dev->transport->name); 1124 return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1125 } 1126 dev->transport->do_sync_cache(task); 1127 break; 1128 case ALLOW_MEDIUM_REMOVAL: 1129 case ERASE: 1130 case REZERO_UNIT: 1131 case SEEK_10: 1132 case SPACE: 1133 case START_STOP: 1134 case TEST_UNIT_READY: 1135 case VERIFY: 1136 case WRITE_FILEMARKS: 1137 break; 1138 default: 1139 printk(KERN_ERR "Unsupported SCSI Opcode: 0x%02x for %s\n", 1140 cmd->t_task_cdb[0], dev->transport->name); 1141 return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1142 } 1143 1144 if (ret < 0) 1145 return ret; 1146 task->task_scsi_status = GOOD; 1147 transport_complete_task(task, 1); 1148 1149 return PYX_TRANSPORT_SENT_TO_TRANSPORT; 1150} 1151