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