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