Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * SCSI Primary Commands (SPC) parsing and emulation.
0004  *
0005  * (c) Copyright 2002-2013 Datera, Inc.
0006  *
0007  * Nicholas A. Bellinger <nab@kernel.org>
0008  */
0009 
0010 #include <linux/kernel.h>
0011 #include <linux/module.h>
0012 #include <asm/unaligned.h>
0013 
0014 #include <scsi/scsi_proto.h>
0015 #include <scsi/scsi_common.h>
0016 #include <scsi/scsi_tcq.h>
0017 
0018 #include <target/target_core_base.h>
0019 #include <target/target_core_backend.h>
0020 #include <target/target_core_fabric.h>
0021 
0022 #include "target_core_internal.h"
0023 #include "target_core_alua.h"
0024 #include "target_core_pr.h"
0025 #include "target_core_ua.h"
0026 #include "target_core_xcopy.h"
0027 
0028 static void spc_fill_alua_data(struct se_lun *lun, unsigned char *buf)
0029 {
0030     struct t10_alua_tg_pt_gp *tg_pt_gp;
0031 
0032     /*
0033      * Set SCCS for MAINTENANCE_IN + REPORT_TARGET_PORT_GROUPS.
0034      */
0035     buf[5]  = 0x80;
0036 
0037     /*
0038      * Set TPGS field for explicit and/or implicit ALUA access type
0039      * and opteration.
0040      *
0041      * See spc4r17 section 6.4.2 Table 135
0042      */
0043     rcu_read_lock();
0044     tg_pt_gp = rcu_dereference(lun->lun_tg_pt_gp);
0045     if (tg_pt_gp)
0046         buf[5] |= tg_pt_gp->tg_pt_gp_alua_access_type;
0047     rcu_read_unlock();
0048 }
0049 
0050 static u16
0051 spc_find_scsi_transport_vd(int proto_id)
0052 {
0053     switch (proto_id) {
0054     case SCSI_PROTOCOL_FCP:
0055         return SCSI_VERSION_DESCRIPTOR_FCP4;
0056     case SCSI_PROTOCOL_ISCSI:
0057         return SCSI_VERSION_DESCRIPTOR_ISCSI;
0058     case SCSI_PROTOCOL_SAS:
0059         return SCSI_VERSION_DESCRIPTOR_SAS3;
0060     case SCSI_PROTOCOL_SBP:
0061         return SCSI_VERSION_DESCRIPTOR_SBP3;
0062     case SCSI_PROTOCOL_SRP:
0063         return SCSI_VERSION_DESCRIPTOR_SRP;
0064     default:
0065         pr_warn("Cannot find VERSION DESCRIPTOR value for unknown SCSI"
0066             " transport PROTOCOL IDENTIFIER %#x\n", proto_id);
0067         return 0;
0068     }
0069 }
0070 
0071 sense_reason_t
0072 spc_emulate_inquiry_std(struct se_cmd *cmd, unsigned char *buf)
0073 {
0074     struct se_lun *lun = cmd->se_lun;
0075     struct se_portal_group *tpg = lun->lun_tpg;
0076     struct se_device *dev = cmd->se_dev;
0077     struct se_session *sess = cmd->se_sess;
0078 
0079     /* Set RMB (removable media) for tape devices */
0080     if (dev->transport->get_device_type(dev) == TYPE_TAPE)
0081         buf[1] = 0x80;
0082 
0083     buf[2] = 0x06; /* SPC-4 */
0084 
0085     /*
0086      * NORMACA and HISUP = 0, RESPONSE DATA FORMAT = 2
0087      *
0088      * SPC4 says:
0089      *   A RESPONSE DATA FORMAT field set to 2h indicates that the
0090      *   standard INQUIRY data is in the format defined in this
0091      *   standard. Response data format values less than 2h are
0092      *   obsolete. Response data format values greater than 2h are
0093      *   reserved.
0094      */
0095     buf[3] = 2;
0096 
0097     /*
0098      * Enable SCCS and TPGS fields for Emulated ALUA
0099      */
0100     spc_fill_alua_data(lun, buf);
0101 
0102     /*
0103      * Set Third-Party Copy (3PC) bit to indicate support for EXTENDED_COPY
0104      */
0105     if (dev->dev_attrib.emulate_3pc)
0106         buf[5] |= 0x8;
0107     /*
0108      * Set Protection (PROTECT) bit when DIF has been enabled on the
0109      * device, and the fabric supports VERIFY + PASS.  Also report
0110      * PROTECT=1 if sess_prot_type has been configured to allow T10-PI
0111      * to unprotected devices.
0112      */
0113     if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
0114         if (dev->dev_attrib.pi_prot_type || cmd->se_sess->sess_prot_type)
0115             buf[5] |= 0x1;
0116     }
0117 
0118     buf[7] = 0x2; /* CmdQue=1 */
0119 
0120     /*
0121      * ASCII data fields described as being left-aligned shall have any
0122      * unused bytes at the end of the field (i.e., highest offset) and the
0123      * unused bytes shall be filled with ASCII space characters (20h).
0124      */
0125     memset(&buf[8], 0x20,
0126            INQUIRY_VENDOR_LEN + INQUIRY_MODEL_LEN + INQUIRY_REVISION_LEN);
0127     memcpy(&buf[8], dev->t10_wwn.vendor,
0128            strnlen(dev->t10_wwn.vendor, INQUIRY_VENDOR_LEN));
0129     memcpy(&buf[16], dev->t10_wwn.model,
0130            strnlen(dev->t10_wwn.model, INQUIRY_MODEL_LEN));
0131     memcpy(&buf[32], dev->t10_wwn.revision,
0132            strnlen(dev->t10_wwn.revision, INQUIRY_REVISION_LEN));
0133 
0134     /*
0135      * Set the VERSION DESCRIPTOR fields
0136      */
0137     put_unaligned_be16(SCSI_VERSION_DESCRIPTOR_SAM5, &buf[58]);
0138     put_unaligned_be16(spc_find_scsi_transport_vd(tpg->proto_id), &buf[60]);
0139     put_unaligned_be16(SCSI_VERSION_DESCRIPTOR_SPC4, &buf[62]);
0140     if (cmd->se_dev->transport->get_device_type(dev) == TYPE_DISK)
0141         put_unaligned_be16(SCSI_VERSION_DESCRIPTOR_SBC3, &buf[64]);
0142 
0143     buf[4] = 91; /* Set additional length to 91 */
0144 
0145     return 0;
0146 }
0147 EXPORT_SYMBOL(spc_emulate_inquiry_std);
0148 
0149 /* unit serial number */
0150 static sense_reason_t
0151 spc_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf)
0152 {
0153     struct se_device *dev = cmd->se_dev;
0154     u16 len;
0155 
0156     if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
0157         len = sprintf(&buf[4], "%s", dev->t10_wwn.unit_serial);
0158         len++; /* Extra Byte for NULL Terminator */
0159         buf[3] = len;
0160     }
0161     return 0;
0162 }
0163 
0164 /*
0165  * Generate NAA IEEE Registered Extended designator
0166  */
0167 void spc_gen_naa_6h_vendor_specific(struct se_device *dev,
0168                     unsigned char *buf)
0169 {
0170     unsigned char *p = &dev->t10_wwn.unit_serial[0];
0171     u32 company_id = dev->t10_wwn.company_id;
0172     int cnt, off = 0;
0173     bool next = true;
0174 
0175     /*
0176      * Start NAA IEEE Registered Extended Identifier/Designator
0177      */
0178     buf[off] = 0x6 << 4;
0179 
0180     /* IEEE COMPANY_ID */
0181     buf[off++] |= (company_id >> 20) & 0xf;
0182     buf[off++] = (company_id >> 12) & 0xff;
0183     buf[off++] = (company_id >> 4) & 0xff;
0184     buf[off] = (company_id & 0xf) << 4;
0185 
0186     /*
0187      * Generate up to 36 bits of VENDOR SPECIFIC IDENTIFIER starting on
0188      * byte 3 bit 3-0 for NAA IEEE Registered Extended DESIGNATOR field
0189      * format, followed by 64 bits of VENDOR SPECIFIC IDENTIFIER EXTENSION
0190      * to complete the payload.  These are based from VPD=0x80 PRODUCT SERIAL
0191      * NUMBER set via vpd_unit_serial in target_core_configfs.c to ensure
0192      * per device uniqeness.
0193      */
0194     for (cnt = off + 13; *p && off < cnt; p++) {
0195         int val = hex_to_bin(*p);
0196 
0197         if (val < 0)
0198             continue;
0199 
0200         if (next) {
0201             next = false;
0202             buf[off++] |= val;
0203         } else {
0204             next = true;
0205             buf[off] = val << 4;
0206         }
0207     }
0208 }
0209 
0210 /*
0211  * Device identification VPD, for a complete list of
0212  * DESIGNATOR TYPEs see spc4r17 Table 459.
0213  */
0214 sense_reason_t
0215 spc_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)
0216 {
0217     struct se_device *dev = cmd->se_dev;
0218     struct se_lun *lun = cmd->se_lun;
0219     struct se_portal_group *tpg = NULL;
0220     struct t10_alua_lu_gp_member *lu_gp_mem;
0221     struct t10_alua_tg_pt_gp *tg_pt_gp;
0222     unsigned char *prod = &dev->t10_wwn.model[0];
0223     u32 prod_len;
0224     u32 unit_serial_len, off = 0;
0225     u16 len = 0, id_len;
0226 
0227     off = 4;
0228 
0229     /*
0230      * NAA IEEE Registered Extended Assigned designator format, see
0231      * spc4r17 section 7.7.3.6.5
0232      *
0233      * We depend upon a target_core_mod/ConfigFS provided
0234      * /sys/kernel/config/target/core/$HBA/$DEV/wwn/vpd_unit_serial
0235      * value in order to return the NAA id.
0236      */
0237     if (!(dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL))
0238         goto check_t10_vend_desc;
0239 
0240     /* CODE SET == Binary */
0241     buf[off++] = 0x1;
0242 
0243     /* Set ASSOCIATION == addressed logical unit: 0)b */
0244     buf[off] = 0x00;
0245 
0246     /* Identifier/Designator type == NAA identifier */
0247     buf[off++] |= 0x3;
0248     off++;
0249 
0250     /* Identifier/Designator length */
0251     buf[off++] = 0x10;
0252 
0253     /* NAA IEEE Registered Extended designator */
0254     spc_gen_naa_6h_vendor_specific(dev, &buf[off]);
0255 
0256     len = 20;
0257     off = (len + 4);
0258 
0259 check_t10_vend_desc:
0260     /*
0261      * T10 Vendor Identifier Page, see spc4r17 section 7.7.3.4
0262      */
0263     id_len = 8; /* For Vendor field */
0264     prod_len = 4; /* For VPD Header */
0265     prod_len += 8; /* For Vendor field */
0266     prod_len += strlen(prod);
0267     prod_len++; /* For : */
0268 
0269     if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
0270         unit_serial_len = strlen(&dev->t10_wwn.unit_serial[0]);
0271         unit_serial_len++; /* For NULL Terminator */
0272 
0273         id_len += sprintf(&buf[off+12], "%s:%s", prod,
0274                 &dev->t10_wwn.unit_serial[0]);
0275     }
0276     buf[off] = 0x2; /* ASCII */
0277     buf[off+1] = 0x1; /* T10 Vendor ID */
0278     buf[off+2] = 0x0;
0279     /* left align Vendor ID and pad with spaces */
0280     memset(&buf[off+4], 0x20, INQUIRY_VENDOR_LEN);
0281     memcpy(&buf[off+4], dev->t10_wwn.vendor,
0282            strnlen(dev->t10_wwn.vendor, INQUIRY_VENDOR_LEN));
0283     /* Extra Byte for NULL Terminator */
0284     id_len++;
0285     /* Identifier Length */
0286     buf[off+3] = id_len;
0287     /* Header size for Designation descriptor */
0288     len += (id_len + 4);
0289     off += (id_len + 4);
0290 
0291     if (1) {
0292         struct t10_alua_lu_gp *lu_gp;
0293         u32 padding, scsi_name_len, scsi_target_len;
0294         u16 lu_gp_id = 0;
0295         u16 tg_pt_gp_id = 0;
0296         u16 tpgt;
0297 
0298         tpg = lun->lun_tpg;
0299         /*
0300          * Relative target port identifer, see spc4r17
0301          * section 7.7.3.7
0302          *
0303          * Get the PROTOCOL IDENTIFIER as defined by spc4r17
0304          * section 7.5.1 Table 362
0305          */
0306         buf[off] = tpg->proto_id << 4;
0307         buf[off++] |= 0x1; /* CODE SET == Binary */
0308         buf[off] = 0x80; /* Set PIV=1 */
0309         /* Set ASSOCIATION == target port: 01b */
0310         buf[off] |= 0x10;
0311         /* DESIGNATOR TYPE == Relative target port identifer */
0312         buf[off++] |= 0x4;
0313         off++; /* Skip over Reserved */
0314         buf[off++] = 4; /* DESIGNATOR LENGTH */
0315         /* Skip over Obsolete field in RTPI payload
0316          * in Table 472 */
0317         off += 2;
0318         put_unaligned_be16(lun->lun_rtpi, &buf[off]);
0319         off += 2;
0320         len += 8; /* Header size + Designation descriptor */
0321         /*
0322          * Target port group identifier, see spc4r17
0323          * section 7.7.3.8
0324          *
0325          * Get the PROTOCOL IDENTIFIER as defined by spc4r17
0326          * section 7.5.1 Table 362
0327          */
0328         rcu_read_lock();
0329         tg_pt_gp = rcu_dereference(lun->lun_tg_pt_gp);
0330         if (!tg_pt_gp) {
0331             rcu_read_unlock();
0332             goto check_lu_gp;
0333         }
0334         tg_pt_gp_id = tg_pt_gp->tg_pt_gp_id;
0335         rcu_read_unlock();
0336 
0337         buf[off] = tpg->proto_id << 4;
0338         buf[off++] |= 0x1; /* CODE SET == Binary */
0339         buf[off] = 0x80; /* Set PIV=1 */
0340         /* Set ASSOCIATION == target port: 01b */
0341         buf[off] |= 0x10;
0342         /* DESIGNATOR TYPE == Target port group identifier */
0343         buf[off++] |= 0x5;
0344         off++; /* Skip over Reserved */
0345         buf[off++] = 4; /* DESIGNATOR LENGTH */
0346         off += 2; /* Skip over Reserved Field */
0347         put_unaligned_be16(tg_pt_gp_id, &buf[off]);
0348         off += 2;
0349         len += 8; /* Header size + Designation descriptor */
0350         /*
0351          * Logical Unit Group identifier, see spc4r17
0352          * section 7.7.3.8
0353          */
0354 check_lu_gp:
0355         lu_gp_mem = dev->dev_alua_lu_gp_mem;
0356         if (!lu_gp_mem)
0357             goto check_scsi_name;
0358 
0359         spin_lock(&lu_gp_mem->lu_gp_mem_lock);
0360         lu_gp = lu_gp_mem->lu_gp;
0361         if (!lu_gp) {
0362             spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
0363             goto check_scsi_name;
0364         }
0365         lu_gp_id = lu_gp->lu_gp_id;
0366         spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
0367 
0368         buf[off++] |= 0x1; /* CODE SET == Binary */
0369         /* DESIGNATOR TYPE == Logical Unit Group identifier */
0370         buf[off++] |= 0x6;
0371         off++; /* Skip over Reserved */
0372         buf[off++] = 4; /* DESIGNATOR LENGTH */
0373         off += 2; /* Skip over Reserved Field */
0374         put_unaligned_be16(lu_gp_id, &buf[off]);
0375         off += 2;
0376         len += 8; /* Header size + Designation descriptor */
0377         /*
0378          * SCSI name string designator, see spc4r17
0379          * section 7.7.3.11
0380          *
0381          * Get the PROTOCOL IDENTIFIER as defined by spc4r17
0382          * section 7.5.1 Table 362
0383          */
0384 check_scsi_name:
0385         buf[off] = tpg->proto_id << 4;
0386         buf[off++] |= 0x3; /* CODE SET == UTF-8 */
0387         buf[off] = 0x80; /* Set PIV=1 */
0388         /* Set ASSOCIATION == target port: 01b */
0389         buf[off] |= 0x10;
0390         /* DESIGNATOR TYPE == SCSI name string */
0391         buf[off++] |= 0x8;
0392         off += 2; /* Skip over Reserved and length */
0393         /*
0394          * SCSI name string identifer containing, $FABRIC_MOD
0395          * dependent information.  For LIO-Target and iSCSI
0396          * Target Port, this means "<iSCSI name>,t,0x<TPGT> in
0397          * UTF-8 encoding.
0398          */
0399         tpgt = tpg->se_tpg_tfo->tpg_get_tag(tpg);
0400         scsi_name_len = sprintf(&buf[off], "%s,t,0x%04x",
0401                     tpg->se_tpg_tfo->tpg_get_wwn(tpg), tpgt);
0402         scsi_name_len += 1 /* Include  NULL terminator */;
0403         /*
0404          * The null-terminated, null-padded (see 4.4.2) SCSI
0405          * NAME STRING field contains a UTF-8 format string.
0406          * The number of bytes in the SCSI NAME STRING field
0407          * (i.e., the value in the DESIGNATOR LENGTH field)
0408          * shall be no larger than 256 and shall be a multiple
0409          * of four.
0410          */
0411         padding = ((-scsi_name_len) & 3);
0412         if (padding)
0413             scsi_name_len += padding;
0414         if (scsi_name_len > 256)
0415             scsi_name_len = 256;
0416 
0417         buf[off-1] = scsi_name_len;
0418         off += scsi_name_len;
0419         /* Header size + Designation descriptor */
0420         len += (scsi_name_len + 4);
0421 
0422         /*
0423          * Target device designator
0424          */
0425         buf[off] = tpg->proto_id << 4;
0426         buf[off++] |= 0x3; /* CODE SET == UTF-8 */
0427         buf[off] = 0x80; /* Set PIV=1 */
0428         /* Set ASSOCIATION == target device: 10b */
0429         buf[off] |= 0x20;
0430         /* DESIGNATOR TYPE == SCSI name string */
0431         buf[off++] |= 0x8;
0432         off += 2; /* Skip over Reserved and length */
0433         /*
0434          * SCSI name string identifer containing, $FABRIC_MOD
0435          * dependent information.  For LIO-Target and iSCSI
0436          * Target Port, this means "<iSCSI name>" in
0437          * UTF-8 encoding.
0438          */
0439         scsi_target_len = sprintf(&buf[off], "%s",
0440                       tpg->se_tpg_tfo->tpg_get_wwn(tpg));
0441         scsi_target_len += 1 /* Include  NULL terminator */;
0442         /*
0443          * The null-terminated, null-padded (see 4.4.2) SCSI
0444          * NAME STRING field contains a UTF-8 format string.
0445          * The number of bytes in the SCSI NAME STRING field
0446          * (i.e., the value in the DESIGNATOR LENGTH field)
0447          * shall be no larger than 256 and shall be a multiple
0448          * of four.
0449          */
0450         padding = ((-scsi_target_len) & 3);
0451         if (padding)
0452             scsi_target_len += padding;
0453         if (scsi_target_len > 256)
0454             scsi_target_len = 256;
0455 
0456         buf[off-1] = scsi_target_len;
0457         off += scsi_target_len;
0458 
0459         /* Header size + Designation descriptor */
0460         len += (scsi_target_len + 4);
0461     }
0462     put_unaligned_be16(len, &buf[2]); /* Page Length for VPD 0x83 */
0463     return 0;
0464 }
0465 EXPORT_SYMBOL(spc_emulate_evpd_83);
0466 
0467 /* Extended INQUIRY Data VPD Page */
0468 static sense_reason_t
0469 spc_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf)
0470 {
0471     struct se_device *dev = cmd->se_dev;
0472     struct se_session *sess = cmd->se_sess;
0473 
0474     buf[3] = 0x3c;
0475     /*
0476      * Set GRD_CHK + REF_CHK for TYPE1 protection, or GRD_CHK
0477      * only for TYPE3 protection.
0478      */
0479     if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
0480         if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE1_PROT ||
0481             cmd->se_sess->sess_prot_type == TARGET_DIF_TYPE1_PROT)
0482             buf[4] = 0x5;
0483         else if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE3_PROT ||
0484              cmd->se_sess->sess_prot_type == TARGET_DIF_TYPE3_PROT)
0485             buf[4] = 0x4;
0486     }
0487 
0488     /* logical unit supports type 1 and type 3 protection */
0489     if ((dev->transport->get_device_type(dev) == TYPE_DISK) &&
0490         (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) &&
0491         (dev->dev_attrib.pi_prot_type || cmd->se_sess->sess_prot_type)) {
0492         buf[4] |= (0x3 << 3);
0493     }
0494 
0495     /* Set HEADSUP, ORDSUP, SIMPSUP */
0496     buf[5] = 0x07;
0497 
0498     /* If WriteCache emulation is enabled, set V_SUP */
0499     if (target_check_wce(dev))
0500         buf[6] = 0x01;
0501     /* If an LBA map is present set R_SUP */
0502     spin_lock(&cmd->se_dev->t10_alua.lba_map_lock);
0503     if (!list_empty(&dev->t10_alua.lba_map_list))
0504         buf[8] = 0x10;
0505     spin_unlock(&cmd->se_dev->t10_alua.lba_map_lock);
0506     return 0;
0507 }
0508 
0509 /* Block Limits VPD page */
0510 static sense_reason_t
0511 spc_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)
0512 {
0513     struct se_device *dev = cmd->se_dev;
0514     u32 mtl = 0;
0515     int have_tp = 0, opt, min;
0516 
0517     /*
0518      * Following spc3r22 section 6.5.3 Block Limits VPD page, when
0519      * emulate_tpu=1 or emulate_tpws=1 we will be expect a
0520      * different page length for Thin Provisioning.
0521      */
0522     if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws)
0523         have_tp = 1;
0524 
0525     buf[0] = dev->transport->get_device_type(dev);
0526     buf[3] = have_tp ? 0x3c : 0x10;
0527 
0528     /* Set WSNZ to 1 */
0529     buf[4] = 0x01;
0530     /*
0531      * Set MAXIMUM COMPARE AND WRITE LENGTH
0532      */
0533     if (dev->dev_attrib.emulate_caw)
0534         buf[5] = 0x01;
0535 
0536     /*
0537      * Set OPTIMAL TRANSFER LENGTH GRANULARITY
0538      */
0539     if (dev->transport->get_io_min && (min = dev->transport->get_io_min(dev)))
0540         put_unaligned_be16(min / dev->dev_attrib.block_size, &buf[6]);
0541     else
0542         put_unaligned_be16(1, &buf[6]);
0543 
0544     /*
0545      * Set MAXIMUM TRANSFER LENGTH
0546      *
0547      * XXX: Currently assumes single PAGE_SIZE per scatterlist for fabrics
0548      * enforcing maximum HW scatter-gather-list entry limit
0549      */
0550     if (cmd->se_tfo->max_data_sg_nents) {
0551         mtl = (cmd->se_tfo->max_data_sg_nents * PAGE_SIZE) /
0552                dev->dev_attrib.block_size;
0553     }
0554     put_unaligned_be32(min_not_zero(mtl, dev->dev_attrib.hw_max_sectors), &buf[8]);
0555 
0556     /*
0557      * Set OPTIMAL TRANSFER LENGTH
0558      */
0559     if (dev->transport->get_io_opt && (opt = dev->transport->get_io_opt(dev)))
0560         put_unaligned_be32(opt / dev->dev_attrib.block_size, &buf[12]);
0561     else
0562         put_unaligned_be32(dev->dev_attrib.optimal_sectors, &buf[12]);
0563 
0564     /*
0565      * Exit now if we don't support TP.
0566      */
0567     if (!have_tp)
0568         goto max_write_same;
0569 
0570     /*
0571      * Set MAXIMUM UNMAP LBA COUNT
0572      */
0573     put_unaligned_be32(dev->dev_attrib.max_unmap_lba_count, &buf[20]);
0574 
0575     /*
0576      * Set MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT
0577      */
0578     put_unaligned_be32(dev->dev_attrib.max_unmap_block_desc_count,
0579                &buf[24]);
0580 
0581     /*
0582      * Set OPTIMAL UNMAP GRANULARITY
0583      */
0584     put_unaligned_be32(dev->dev_attrib.unmap_granularity, &buf[28]);
0585 
0586     /*
0587      * UNMAP GRANULARITY ALIGNMENT
0588      */
0589     put_unaligned_be32(dev->dev_attrib.unmap_granularity_alignment,
0590                &buf[32]);
0591     if (dev->dev_attrib.unmap_granularity_alignment != 0)
0592         buf[32] |= 0x80; /* Set the UGAVALID bit */
0593 
0594     /*
0595      * MAXIMUM WRITE SAME LENGTH
0596      */
0597 max_write_same:
0598     put_unaligned_be64(dev->dev_attrib.max_write_same_len, &buf[36]);
0599 
0600     return 0;
0601 }
0602 
0603 /* Block Device Characteristics VPD page */
0604 static sense_reason_t
0605 spc_emulate_evpd_b1(struct se_cmd *cmd, unsigned char *buf)
0606 {
0607     struct se_device *dev = cmd->se_dev;
0608 
0609     buf[0] = dev->transport->get_device_type(dev);
0610     buf[3] = 0x3c;
0611     buf[5] = dev->dev_attrib.is_nonrot ? 1 : 0;
0612 
0613     return 0;
0614 }
0615 
0616 /* Thin Provisioning VPD */
0617 static sense_reason_t
0618 spc_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf)
0619 {
0620     struct se_device *dev = cmd->se_dev;
0621 
0622     /*
0623      * From spc3r22 section 6.5.4 Thin Provisioning VPD page:
0624      *
0625      * The PAGE LENGTH field is defined in SPC-4. If the DP bit is set to
0626      * zero, then the page length shall be set to 0004h.  If the DP bit
0627      * is set to one, then the page length shall be set to the value
0628      * defined in table 162.
0629      */
0630     buf[0] = dev->transport->get_device_type(dev);
0631 
0632     /*
0633      * Set Hardcoded length mentioned above for DP=0
0634      */
0635     put_unaligned_be16(0x0004, &buf[2]);
0636 
0637     /*
0638      * The THRESHOLD EXPONENT field indicates the threshold set size in
0639      * LBAs as a power of 2 (i.e., the threshold set size is equal to
0640      * 2(threshold exponent)).
0641      *
0642      * Note that this is currently set to 0x00 as mkp says it will be
0643      * changing again.  We can enable this once it has settled in T10
0644      * and is actually used by Linux/SCSI ML code.
0645      */
0646     buf[4] = 0x00;
0647 
0648     /*
0649      * A TPU bit set to one indicates that the device server supports
0650      * the UNMAP command (see 5.25). A TPU bit set to zero indicates
0651      * that the device server does not support the UNMAP command.
0652      */
0653     if (dev->dev_attrib.emulate_tpu != 0)
0654         buf[5] = 0x80;
0655 
0656     /*
0657      * A TPWS bit set to one indicates that the device server supports
0658      * the use of the WRITE SAME (16) command (see 5.42) to unmap LBAs.
0659      * A TPWS bit set to zero indicates that the device server does not
0660      * support the use of the WRITE SAME (16) command to unmap LBAs.
0661      */
0662     if (dev->dev_attrib.emulate_tpws != 0)
0663         buf[5] |= 0x40 | 0x20;
0664 
0665     /*
0666      * The unmap_zeroes_data set means that the underlying device supports
0667      * REQ_OP_DISCARD and has the discard_zeroes_data bit set. This
0668      * satisfies the SBC requirements for LBPRZ, meaning that a subsequent
0669      * read will return zeroes after an UNMAP or WRITE SAME (16) to an LBA
0670      * See sbc4r36 6.6.4.
0671      */
0672     if (((dev->dev_attrib.emulate_tpu != 0) ||
0673          (dev->dev_attrib.emulate_tpws != 0)) &&
0674          (dev->dev_attrib.unmap_zeroes_data != 0))
0675         buf[5] |= 0x04;
0676 
0677     return 0;
0678 }
0679 
0680 /* Referrals VPD page */
0681 static sense_reason_t
0682 spc_emulate_evpd_b3(struct se_cmd *cmd, unsigned char *buf)
0683 {
0684     struct se_device *dev = cmd->se_dev;
0685 
0686     buf[0] = dev->transport->get_device_type(dev);
0687     buf[3] = 0x0c;
0688     put_unaligned_be32(dev->t10_alua.lba_map_segment_size, &buf[8]);
0689     put_unaligned_be32(dev->t10_alua.lba_map_segment_multiplier, &buf[12]);
0690 
0691     return 0;
0692 }
0693 
0694 static sense_reason_t
0695 spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf);
0696 
0697 static struct {
0698     uint8_t     page;
0699     sense_reason_t  (*emulate)(struct se_cmd *, unsigned char *);
0700 } evpd_handlers[] = {
0701     { .page = 0x00, .emulate = spc_emulate_evpd_00 },
0702     { .page = 0x80, .emulate = spc_emulate_evpd_80 },
0703     { .page = 0x83, .emulate = spc_emulate_evpd_83 },
0704     { .page = 0x86, .emulate = spc_emulate_evpd_86 },
0705     { .page = 0xb0, .emulate = spc_emulate_evpd_b0 },
0706     { .page = 0xb1, .emulate = spc_emulate_evpd_b1 },
0707     { .page = 0xb2, .emulate = spc_emulate_evpd_b2 },
0708     { .page = 0xb3, .emulate = spc_emulate_evpd_b3 },
0709 };
0710 
0711 /* supported vital product data pages */
0712 static sense_reason_t
0713 spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf)
0714 {
0715     int p;
0716 
0717     /*
0718      * Only report the INQUIRY EVPD=1 pages after a valid NAA
0719      * Registered Extended LUN WWN has been set via ConfigFS
0720      * during device creation/restart.
0721      */
0722     if (cmd->se_dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
0723         buf[3] = ARRAY_SIZE(evpd_handlers);
0724         for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p)
0725             buf[p + 4] = evpd_handlers[p].page;
0726     }
0727 
0728     return 0;
0729 }
0730 
0731 static sense_reason_t
0732 spc_emulate_inquiry(struct se_cmd *cmd)
0733 {
0734     struct se_device *dev = cmd->se_dev;
0735     unsigned char *rbuf;
0736     unsigned char *cdb = cmd->t_task_cdb;
0737     unsigned char *buf;
0738     sense_reason_t ret;
0739     int p;
0740     int len = 0;
0741 
0742     buf = kzalloc(SE_INQUIRY_BUF, GFP_KERNEL);
0743     if (!buf) {
0744         pr_err("Unable to allocate response buffer for INQUIRY\n");
0745         return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
0746     }
0747 
0748     buf[0] = dev->transport->get_device_type(dev);
0749 
0750     if (!(cdb[1] & 0x1)) {
0751         if (cdb[2]) {
0752             pr_err("INQUIRY with EVPD==0 but PAGE CODE=%02x\n",
0753                    cdb[2]);
0754             ret = TCM_INVALID_CDB_FIELD;
0755             goto out;
0756         }
0757 
0758         ret = spc_emulate_inquiry_std(cmd, buf);
0759         len = buf[4] + 5;
0760         goto out;
0761     }
0762 
0763     for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p) {
0764         if (cdb[2] == evpd_handlers[p].page) {
0765             buf[1] = cdb[2];
0766             ret = evpd_handlers[p].emulate(cmd, buf);
0767             len = get_unaligned_be16(&buf[2]) + 4;
0768             goto out;
0769         }
0770     }
0771 
0772     pr_debug("Unknown VPD Code: 0x%02x\n", cdb[2]);
0773     ret = TCM_INVALID_CDB_FIELD;
0774 
0775 out:
0776     rbuf = transport_kmap_data_sg(cmd);
0777     if (rbuf) {
0778         memcpy(rbuf, buf, min_t(u32, SE_INQUIRY_BUF, cmd->data_length));
0779         transport_kunmap_data_sg(cmd);
0780     }
0781     kfree(buf);
0782 
0783     if (!ret)
0784         target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, len);
0785     return ret;
0786 }
0787 
0788 static int spc_modesense_rwrecovery(struct se_cmd *cmd, u8 pc, u8 *p)
0789 {
0790     p[0] = 0x01;
0791     p[1] = 0x0a;
0792 
0793     /* No changeable values for now */
0794     if (pc == 1)
0795         goto out;
0796 
0797 out:
0798     return 12;
0799 }
0800 
0801 static int spc_modesense_control(struct se_cmd *cmd, u8 pc, u8 *p)
0802 {
0803     struct se_device *dev = cmd->se_dev;
0804     struct se_session *sess = cmd->se_sess;
0805 
0806     p[0] = 0x0a;
0807     p[1] = 0x0a;
0808 
0809     /* No changeable values for now */
0810     if (pc == 1)
0811         goto out;
0812 
0813     /* GLTSD: No implicit save of log parameters */
0814     p[2] = (1 << 1);
0815     if (target_sense_desc_format(dev))
0816         /* D_SENSE: Descriptor format sense data for 64bit sectors */
0817         p[2] |= (1 << 2);
0818 
0819     /*
0820      * From spc4r23, 7.4.7 Control mode page
0821      *
0822      * The QUEUE ALGORITHM MODIFIER field (see table 368) specifies
0823      * restrictions on the algorithm used for reordering commands
0824      * having the SIMPLE task attribute (see SAM-4).
0825      *
0826      *                    Table 368 -- QUEUE ALGORITHM MODIFIER field
0827      *                         Code      Description
0828      *                          0h       Restricted reordering
0829      *                          1h       Unrestricted reordering allowed
0830      *                          2h to 7h    Reserved
0831      *                          8h to Fh    Vendor specific
0832      *
0833      * A value of zero in the QUEUE ALGORITHM MODIFIER field specifies that
0834      * the device server shall order the processing sequence of commands
0835      * having the SIMPLE task attribute such that data integrity is maintained
0836      * for that I_T nexus (i.e., if the transmission of new SCSI transport protocol
0837      * requests is halted at any time, the final value of all data observable
0838      * on the medium shall be the same as if all the commands had been processed
0839      * with the ORDERED task attribute).
0840      *
0841      * A value of one in the QUEUE ALGORITHM MODIFIER field specifies that the
0842      * device server may reorder the processing sequence of commands having the
0843      * SIMPLE task attribute in any manner. Any data integrity exposures related to
0844      * command sequence order shall be explicitly handled by the application client
0845      * through the selection of appropriate ommands and task attributes.
0846      */
0847     p[3] = (dev->dev_attrib.emulate_rest_reord == 1) ? 0x00 : 0x10;
0848     /*
0849      * From spc4r17, section 7.4.6 Control mode Page
0850      *
0851      * Unit Attention interlocks control (UN_INTLCK_CTRL) to code 00b
0852      *
0853      * 00b: The logical unit shall clear any unit attention condition
0854      * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
0855      * status and shall not establish a unit attention condition when a com-
0856      * mand is completed with BUSY, TASK SET FULL, or RESERVATION CONFLICT
0857      * status.
0858      *
0859      * 10b: The logical unit shall not clear any unit attention condition
0860      * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
0861      * status and shall not establish a unit attention condition when
0862      * a command is completed with BUSY, TASK SET FULL, or RESERVATION
0863      * CONFLICT status.
0864      *
0865      * 11b a The logical unit shall not clear any unit attention condition
0866      * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
0867      * status and shall establish a unit attention condition for the
0868      * initiator port associated with the I_T nexus on which the BUSY,
0869      * TASK SET FULL, or RESERVATION CONFLICT status is being returned.
0870      * Depending on the status, the additional sense code shall be set to
0871      * PREVIOUS BUSY STATUS, PREVIOUS TASK SET FULL STATUS, or PREVIOUS
0872      * RESERVATION CONFLICT STATUS. Until it is cleared by a REQUEST SENSE
0873      * command, a unit attention condition shall be established only once
0874      * for a BUSY, TASK SET FULL, or RESERVATION CONFLICT status regardless
0875      * to the number of commands completed with one of those status codes.
0876      */
0877     switch (dev->dev_attrib.emulate_ua_intlck_ctrl) {
0878     case TARGET_UA_INTLCK_CTRL_ESTABLISH_UA:
0879         p[4] = 0x30;
0880         break;
0881     case TARGET_UA_INTLCK_CTRL_NO_CLEAR:
0882         p[4] = 0x20;
0883         break;
0884     default:    /* TARGET_UA_INTLCK_CTRL_CLEAR */
0885         p[4] = 0x00;
0886         break;
0887     }
0888     /*
0889      * From spc4r17, section 7.4.6 Control mode Page
0890      *
0891      * Task Aborted Status (TAS) bit set to zero.
0892      *
0893      * A task aborted status (TAS) bit set to zero specifies that aborted
0894      * tasks shall be terminated by the device server without any response
0895      * to the application client. A TAS bit set to one specifies that tasks
0896      * aborted by the actions of an I_T nexus other than the I_T nexus on
0897      * which the command was received shall be completed with TASK ABORTED
0898      * status (see SAM-4).
0899      */
0900     p[5] = (dev->dev_attrib.emulate_tas) ? 0x40 : 0x00;
0901     /*
0902      * From spc4r30, section 7.5.7 Control mode page
0903      *
0904      * Application Tag Owner (ATO) bit set to one.
0905      *
0906      * If the ATO bit is set to one the device server shall not modify the
0907      * LOGICAL BLOCK APPLICATION TAG field and, depending on the protection
0908      * type, shall not modify the contents of the LOGICAL BLOCK REFERENCE
0909      * TAG field.
0910      */
0911     if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
0912         if (dev->dev_attrib.pi_prot_type || sess->sess_prot_type)
0913             p[5] |= 0x80;
0914     }
0915 
0916     p[8] = 0xff;
0917     p[9] = 0xff;
0918     p[11] = 30;
0919 
0920 out:
0921     return 12;
0922 }
0923 
0924 static int spc_modesense_caching(struct se_cmd *cmd, u8 pc, u8 *p)
0925 {
0926     struct se_device *dev = cmd->se_dev;
0927 
0928     p[0] = 0x08;
0929     p[1] = 0x12;
0930 
0931     /* No changeable values for now */
0932     if (pc == 1)
0933         goto out;
0934 
0935     if (target_check_wce(dev))
0936         p[2] = 0x04; /* Write Cache Enable */
0937     p[12] = 0x20; /* Disabled Read Ahead */
0938 
0939 out:
0940     return 20;
0941 }
0942 
0943 static int spc_modesense_informational_exceptions(struct se_cmd *cmd, u8 pc, unsigned char *p)
0944 {
0945     p[0] = 0x1c;
0946     p[1] = 0x0a;
0947 
0948     /* No changeable values for now */
0949     if (pc == 1)
0950         goto out;
0951 
0952 out:
0953     return 12;
0954 }
0955 
0956 static struct {
0957     uint8_t     page;
0958     uint8_t     subpage;
0959     int     (*emulate)(struct se_cmd *, u8, unsigned char *);
0960 } modesense_handlers[] = {
0961     { .page = 0x01, .subpage = 0x00, .emulate = spc_modesense_rwrecovery },
0962     { .page = 0x08, .subpage = 0x00, .emulate = spc_modesense_caching },
0963     { .page = 0x0a, .subpage = 0x00, .emulate = spc_modesense_control },
0964     { .page = 0x1c, .subpage = 0x00, .emulate = spc_modesense_informational_exceptions },
0965 };
0966 
0967 static void spc_modesense_write_protect(unsigned char *buf, int type)
0968 {
0969     /*
0970      * I believe that the WP bit (bit 7) in the mode header is the same for
0971      * all device types..
0972      */
0973     switch (type) {
0974     case TYPE_DISK:
0975     case TYPE_TAPE:
0976     default:
0977         buf[0] |= 0x80; /* WP bit */
0978         break;
0979     }
0980 }
0981 
0982 static void spc_modesense_dpofua(unsigned char *buf, int type)
0983 {
0984     switch (type) {
0985     case TYPE_DISK:
0986         buf[0] |= 0x10; /* DPOFUA bit */
0987         break;
0988     default:
0989         break;
0990     }
0991 }
0992 
0993 static int spc_modesense_blockdesc(unsigned char *buf, u64 blocks, u32 block_size)
0994 {
0995     *buf++ = 8;
0996     put_unaligned_be32(min(blocks, 0xffffffffull), buf);
0997     buf += 4;
0998     put_unaligned_be32(block_size, buf);
0999     return 9;
1000 }
1001 
1002 static int spc_modesense_long_blockdesc(unsigned char *buf, u64 blocks, u32 block_size)
1003 {
1004     if (blocks <= 0xffffffff)
1005         return spc_modesense_blockdesc(buf + 3, blocks, block_size) + 3;
1006 
1007     *buf++ = 1;     /* LONGLBA */
1008     buf += 2;
1009     *buf++ = 16;
1010     put_unaligned_be64(blocks, buf);
1011     buf += 12;
1012     put_unaligned_be32(block_size, buf);
1013 
1014     return 17;
1015 }
1016 
1017 static sense_reason_t spc_emulate_modesense(struct se_cmd *cmd)
1018 {
1019     struct se_device *dev = cmd->se_dev;
1020     char *cdb = cmd->t_task_cdb;
1021     unsigned char buf[SE_MODE_PAGE_BUF], *rbuf;
1022     int type = dev->transport->get_device_type(dev);
1023     int ten = (cmd->t_task_cdb[0] == MODE_SENSE_10);
1024     bool dbd = !!(cdb[1] & 0x08);
1025     bool llba = ten ? !!(cdb[1] & 0x10) : false;
1026     u8 pc = cdb[2] >> 6;
1027     u8 page = cdb[2] & 0x3f;
1028     u8 subpage = cdb[3];
1029     int length = 0;
1030     int ret;
1031     int i;
1032 
1033     memset(buf, 0, SE_MODE_PAGE_BUF);
1034 
1035     /*
1036      * Skip over MODE DATA LENGTH + MEDIUM TYPE fields to byte 3 for
1037      * MODE_SENSE_10 and byte 2 for MODE_SENSE (6).
1038      */
1039     length = ten ? 3 : 2;
1040 
1041     /* DEVICE-SPECIFIC PARAMETER */
1042     if (cmd->se_lun->lun_access_ro || target_lun_is_rdonly(cmd))
1043         spc_modesense_write_protect(&buf[length], type);
1044 
1045     /*
1046      * SBC only allows us to enable FUA and DPO together.  Fortunately
1047      * DPO is explicitly specified as a hint, so a noop is a perfectly
1048      * valid implementation.
1049      */
1050     if (target_check_fua(dev))
1051         spc_modesense_dpofua(&buf[length], type);
1052 
1053     ++length;
1054 
1055     /* BLOCK DESCRIPTOR */
1056 
1057     /*
1058      * For now we only include a block descriptor for disk (SBC)
1059      * devices; other command sets use a slightly different format.
1060      */
1061     if (!dbd && type == TYPE_DISK) {
1062         u64 blocks = dev->transport->get_blocks(dev);
1063         u32 block_size = dev->dev_attrib.block_size;
1064 
1065         if (ten) {
1066             if (llba) {
1067                 length += spc_modesense_long_blockdesc(&buf[length],
1068                                        blocks, block_size);
1069             } else {
1070                 length += 3;
1071                 length += spc_modesense_blockdesc(&buf[length],
1072                                   blocks, block_size);
1073             }
1074         } else {
1075             length += spc_modesense_blockdesc(&buf[length], blocks,
1076                               block_size);
1077         }
1078     } else {
1079         if (ten)
1080             length += 4;
1081         else
1082             length += 1;
1083     }
1084 
1085     if (page == 0x3f) {
1086         if (subpage != 0x00 && subpage != 0xff) {
1087             pr_warn("MODE_SENSE: Invalid subpage code: 0x%02x\n", subpage);
1088             return TCM_INVALID_CDB_FIELD;
1089         }
1090 
1091         for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i) {
1092             /*
1093              * Tricky way to say all subpage 00h for
1094              * subpage==0, all subpages for subpage==0xff
1095              * (and we just checked above that those are
1096              * the only two possibilities).
1097              */
1098             if ((modesense_handlers[i].subpage & ~subpage) == 0) {
1099                 ret = modesense_handlers[i].emulate(cmd, pc, &buf[length]);
1100                 if (!ten && length + ret >= 255)
1101                     break;
1102                 length += ret;
1103             }
1104         }
1105 
1106         goto set_length;
1107     }
1108 
1109     for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i)
1110         if (modesense_handlers[i].page == page &&
1111             modesense_handlers[i].subpage == subpage) {
1112             length += modesense_handlers[i].emulate(cmd, pc, &buf[length]);
1113             goto set_length;
1114         }
1115 
1116     /*
1117      * We don't intend to implement:
1118      *  - obsolete page 03h "format parameters" (checked by Solaris)
1119      */
1120     if (page != 0x03)
1121         pr_err("MODE SENSE: unimplemented page/subpage: 0x%02x/0x%02x\n",
1122                page, subpage);
1123 
1124     return TCM_UNKNOWN_MODE_PAGE;
1125 
1126 set_length:
1127     if (ten)
1128         put_unaligned_be16(length - 2, buf);
1129     else
1130         buf[0] = length - 1;
1131 
1132     rbuf = transport_kmap_data_sg(cmd);
1133     if (rbuf) {
1134         memcpy(rbuf, buf, min_t(u32, SE_MODE_PAGE_BUF, cmd->data_length));
1135         transport_kunmap_data_sg(cmd);
1136     }
1137 
1138     target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, length);
1139     return 0;
1140 }
1141 
1142 static sense_reason_t spc_emulate_modeselect(struct se_cmd *cmd)
1143 {
1144     char *cdb = cmd->t_task_cdb;
1145     bool ten = cdb[0] == MODE_SELECT_10;
1146     int off = ten ? 8 : 4;
1147     bool pf = !!(cdb[1] & 0x10);
1148     u8 page, subpage;
1149     unsigned char *buf;
1150     unsigned char tbuf[SE_MODE_PAGE_BUF];
1151     int length;
1152     sense_reason_t ret = 0;
1153     int i;
1154 
1155     if (!cmd->data_length) {
1156         target_complete_cmd(cmd, SAM_STAT_GOOD);
1157         return 0;
1158     }
1159 
1160     if (cmd->data_length < off + 2)
1161         return TCM_PARAMETER_LIST_LENGTH_ERROR;
1162 
1163     buf = transport_kmap_data_sg(cmd);
1164     if (!buf)
1165         return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1166 
1167     if (!pf) {
1168         ret = TCM_INVALID_CDB_FIELD;
1169         goto out;
1170     }
1171 
1172     page = buf[off] & 0x3f;
1173     subpage = buf[off] & 0x40 ? buf[off + 1] : 0;
1174 
1175     for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i)
1176         if (modesense_handlers[i].page == page &&
1177             modesense_handlers[i].subpage == subpage) {
1178             memset(tbuf, 0, SE_MODE_PAGE_BUF);
1179             length = modesense_handlers[i].emulate(cmd, 0, tbuf);
1180             goto check_contents;
1181         }
1182 
1183     ret = TCM_UNKNOWN_MODE_PAGE;
1184     goto out;
1185 
1186 check_contents:
1187     if (cmd->data_length < off + length) {
1188         ret = TCM_PARAMETER_LIST_LENGTH_ERROR;
1189         goto out;
1190     }
1191 
1192     if (memcmp(buf + off, tbuf, length))
1193         ret = TCM_INVALID_PARAMETER_LIST;
1194 
1195 out:
1196     transport_kunmap_data_sg(cmd);
1197 
1198     if (!ret)
1199         target_complete_cmd(cmd, SAM_STAT_GOOD);
1200     return ret;
1201 }
1202 
1203 static sense_reason_t spc_emulate_request_sense(struct se_cmd *cmd)
1204 {
1205     unsigned char *cdb = cmd->t_task_cdb;
1206     unsigned char *rbuf;
1207     u8 ua_asc = 0, ua_ascq = 0;
1208     unsigned char buf[SE_SENSE_BUF];
1209     bool desc_format = target_sense_desc_format(cmd->se_dev);
1210 
1211     memset(buf, 0, SE_SENSE_BUF);
1212 
1213     if (cdb[1] & 0x01) {
1214         pr_err("REQUEST_SENSE description emulation not"
1215             " supported\n");
1216         return TCM_INVALID_CDB_FIELD;
1217     }
1218 
1219     rbuf = transport_kmap_data_sg(cmd);
1220     if (!rbuf)
1221         return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1222 
1223     if (!core_scsi3_ua_clear_for_request_sense(cmd, &ua_asc, &ua_ascq))
1224         scsi_build_sense_buffer(desc_format, buf, UNIT_ATTENTION,
1225                     ua_asc, ua_ascq);
1226     else
1227         scsi_build_sense_buffer(desc_format, buf, NO_SENSE, 0x0, 0x0);
1228 
1229     memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
1230     transport_kunmap_data_sg(cmd);
1231 
1232     target_complete_cmd(cmd, SAM_STAT_GOOD);
1233     return 0;
1234 }
1235 
1236 sense_reason_t spc_emulate_report_luns(struct se_cmd *cmd)
1237 {
1238     struct se_dev_entry *deve;
1239     struct se_session *sess = cmd->se_sess;
1240     struct se_node_acl *nacl;
1241     struct scsi_lun slun;
1242     unsigned char *buf;
1243     u32 lun_count = 0, offset = 8;
1244     __be32 len;
1245 
1246     buf = transport_kmap_data_sg(cmd);
1247     if (cmd->data_length && !buf)
1248         return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1249 
1250     /*
1251      * If no struct se_session pointer is present, this struct se_cmd is
1252      * coming via a target_core_mod PASSTHROUGH op, and not through
1253      * a $FABRIC_MOD.  In that case, report LUN=0 only.
1254      */
1255     if (!sess)
1256         goto done;
1257 
1258     nacl = sess->se_node_acl;
1259 
1260     rcu_read_lock();
1261     hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) {
1262         /*
1263          * We determine the correct LUN LIST LENGTH even once we
1264          * have reached the initial allocation length.
1265          * See SPC2-R20 7.19.
1266          */
1267         lun_count++;
1268         if (offset >= cmd->data_length)
1269             continue;
1270 
1271         int_to_scsilun(deve->mapped_lun, &slun);
1272         memcpy(buf + offset, &slun,
1273                min(8u, cmd->data_length - offset));
1274         offset += 8;
1275     }
1276     rcu_read_unlock();
1277 
1278     /*
1279      * See SPC3 r07, page 159.
1280      */
1281 done:
1282     /*
1283      * If no LUNs are accessible, report virtual LUN 0.
1284      */
1285     if (lun_count == 0) {
1286         int_to_scsilun(0, &slun);
1287         if (cmd->data_length > 8)
1288             memcpy(buf + offset, &slun,
1289                    min(8u, cmd->data_length - offset));
1290         lun_count = 1;
1291     }
1292 
1293     if (buf) {
1294         len = cpu_to_be32(lun_count * 8);
1295         memcpy(buf, &len, min_t(int, sizeof len, cmd->data_length));
1296         transport_kunmap_data_sg(cmd);
1297     }
1298 
1299     target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, 8 + lun_count * 8);
1300     return 0;
1301 }
1302 EXPORT_SYMBOL(spc_emulate_report_luns);
1303 
1304 static sense_reason_t
1305 spc_emulate_testunitready(struct se_cmd *cmd)
1306 {
1307     target_complete_cmd(cmd, SAM_STAT_GOOD);
1308     return 0;
1309 }
1310 
1311 sense_reason_t
1312 spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
1313 {
1314     struct se_device *dev = cmd->se_dev;
1315     unsigned char *cdb = cmd->t_task_cdb;
1316 
1317     if (!dev->dev_attrib.emulate_pr &&
1318         ((cdb[0] == PERSISTENT_RESERVE_IN) ||
1319          (cdb[0] == PERSISTENT_RESERVE_OUT) ||
1320          (cdb[0] == RELEASE || cdb[0] == RELEASE_10) ||
1321          (cdb[0] == RESERVE || cdb[0] == RESERVE_10))) {
1322         return TCM_UNSUPPORTED_SCSI_OPCODE;
1323     }
1324 
1325     switch (cdb[0]) {
1326     case MODE_SELECT:
1327         *size = cdb[4];
1328         cmd->execute_cmd = spc_emulate_modeselect;
1329         break;
1330     case MODE_SELECT_10:
1331         *size = get_unaligned_be16(&cdb[7]);
1332         cmd->execute_cmd = spc_emulate_modeselect;
1333         break;
1334     case MODE_SENSE:
1335         *size = cdb[4];
1336         cmd->execute_cmd = spc_emulate_modesense;
1337         break;
1338     case MODE_SENSE_10:
1339         *size = get_unaligned_be16(&cdb[7]);
1340         cmd->execute_cmd = spc_emulate_modesense;
1341         break;
1342     case LOG_SELECT:
1343     case LOG_SENSE:
1344         *size = get_unaligned_be16(&cdb[7]);
1345         break;
1346     case PERSISTENT_RESERVE_IN:
1347         *size = get_unaligned_be16(&cdb[7]);
1348         cmd->execute_cmd = target_scsi3_emulate_pr_in;
1349         break;
1350     case PERSISTENT_RESERVE_OUT:
1351         *size = get_unaligned_be32(&cdb[5]);
1352         cmd->execute_cmd = target_scsi3_emulate_pr_out;
1353         break;
1354     case RELEASE:
1355     case RELEASE_10:
1356         if (cdb[0] == RELEASE_10)
1357             *size = get_unaligned_be16(&cdb[7]);
1358         else
1359             *size = cmd->data_length;
1360 
1361         cmd->execute_cmd = target_scsi2_reservation_release;
1362         break;
1363     case RESERVE:
1364     case RESERVE_10:
1365         /*
1366          * The SPC-2 RESERVE does not contain a size in the SCSI CDB.
1367          * Assume the passthrough or $FABRIC_MOD will tell us about it.
1368          */
1369         if (cdb[0] == RESERVE_10)
1370             *size = get_unaligned_be16(&cdb[7]);
1371         else
1372             *size = cmd->data_length;
1373 
1374         cmd->execute_cmd = target_scsi2_reservation_reserve;
1375         break;
1376     case REQUEST_SENSE:
1377         *size = cdb[4];
1378         cmd->execute_cmd = spc_emulate_request_sense;
1379         break;
1380     case INQUIRY:
1381         *size = get_unaligned_be16(&cdb[3]);
1382 
1383         /*
1384          * Do implicit HEAD_OF_QUEUE processing for INQUIRY.
1385          * See spc4r17 section 5.3
1386          */
1387         cmd->sam_task_attr = TCM_HEAD_TAG;
1388         cmd->execute_cmd = spc_emulate_inquiry;
1389         break;
1390     case SECURITY_PROTOCOL_IN:
1391     case SECURITY_PROTOCOL_OUT:
1392         *size = get_unaligned_be32(&cdb[6]);
1393         break;
1394     case EXTENDED_COPY:
1395         *size = get_unaligned_be32(&cdb[10]);
1396         cmd->execute_cmd = target_do_xcopy;
1397         break;
1398     case RECEIVE_COPY_RESULTS:
1399         *size = get_unaligned_be32(&cdb[10]);
1400         cmd->execute_cmd = target_do_receive_copy_results;
1401         break;
1402     case READ_ATTRIBUTE:
1403     case WRITE_ATTRIBUTE:
1404         *size = get_unaligned_be32(&cdb[10]);
1405         break;
1406     case RECEIVE_DIAGNOSTIC:
1407     case SEND_DIAGNOSTIC:
1408         *size = get_unaligned_be16(&cdb[3]);
1409         break;
1410     case WRITE_BUFFER:
1411         *size = get_unaligned_be24(&cdb[6]);
1412         break;
1413     case REPORT_LUNS:
1414         cmd->execute_cmd = spc_emulate_report_luns;
1415         *size = get_unaligned_be32(&cdb[6]);
1416         /*
1417          * Do implicit HEAD_OF_QUEUE processing for REPORT_LUNS
1418          * See spc4r17 section 5.3
1419          */
1420         cmd->sam_task_attr = TCM_HEAD_TAG;
1421         break;
1422     case TEST_UNIT_READY:
1423         cmd->execute_cmd = spc_emulate_testunitready;
1424         *size = 0;
1425         break;
1426     case MAINTENANCE_IN:
1427         if (dev->transport->get_device_type(dev) != TYPE_ROM) {
1428             /*
1429              * MAINTENANCE_IN from SCC-2
1430              * Check for emulated MI_REPORT_TARGET_PGS
1431              */
1432             if ((cdb[1] & 0x1f) == MI_REPORT_TARGET_PGS) {
1433                 cmd->execute_cmd =
1434                     target_emulate_report_target_port_groups;
1435             }
1436             *size = get_unaligned_be32(&cdb[6]);
1437         } else {
1438             /*
1439              * GPCMD_SEND_KEY from multi media commands
1440              */
1441             *size = get_unaligned_be16(&cdb[8]);
1442         }
1443         break;
1444     case MAINTENANCE_OUT:
1445         if (dev->transport->get_device_type(dev) != TYPE_ROM) {
1446             /*
1447              * MAINTENANCE_OUT from SCC-2
1448              * Check for emulated MO_SET_TARGET_PGS.
1449              */
1450             if (cdb[1] == MO_SET_TARGET_PGS) {
1451                 cmd->execute_cmd =
1452                     target_emulate_set_target_port_groups;
1453             }
1454             *size = get_unaligned_be32(&cdb[6]);
1455         } else {
1456             /*
1457              * GPCMD_SEND_KEY from multi media commands
1458              */
1459             *size = get_unaligned_be16(&cdb[8]);
1460         }
1461         break;
1462     default:
1463         return TCM_UNSUPPORTED_SCSI_OPCODE;
1464     }
1465 
1466     return 0;
1467 }
1468 EXPORT_SYMBOL(spc_parse_cdb);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!