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