Pileus Git - ~andy/linux/blob - drivers/target/target_core_cdb.c

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