11a59d1b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
288455ec4SChristoph Hellwig /*
388455ec4SChristoph Hellwig * SCSI Primary Commands (SPC) parsing and emulation.
488455ec4SChristoph Hellwig *
54c76251eSNicholas Bellinger * (c) Copyright 2002-2013 Datera, Inc.
688455ec4SChristoph Hellwig *
788455ec4SChristoph Hellwig * Nicholas A. Bellinger <nab@kernel.org>
888455ec4SChristoph Hellwig */
988455ec4SChristoph Hellwig
1088455ec4SChristoph Hellwig #include <linux/kernel.h>
1188455ec4SChristoph Hellwig #include <linux/module.h>
1288455ec4SChristoph Hellwig #include <asm/unaligned.h>
1388455ec4SChristoph Hellwig
14ba929992SBart Van Assche #include <scsi/scsi_proto.h>
15ba929992SBart Van Assche #include <scsi/scsi_common.h>
1688455ec4SChristoph Hellwig #include <scsi/scsi_tcq.h>
1788455ec4SChristoph Hellwig
1888455ec4SChristoph Hellwig #include <target/target_core_base.h>
1988455ec4SChristoph Hellwig #include <target/target_core_backend.h>
2088455ec4SChristoph Hellwig #include <target/target_core_fabric.h>
2188455ec4SChristoph Hellwig
2288455ec4SChristoph Hellwig #include "target_core_internal.h"
23eba2ca45SNicholas Bellinger #include "target_core_alua.h"
2488455ec4SChristoph Hellwig #include "target_core_pr.h"
2588455ec4SChristoph Hellwig #include "target_core_ua.h"
2604b1b795SNicholas Bellinger #include "target_core_xcopy.h"
2788455ec4SChristoph Hellwig
spc_fill_alua_data(struct se_lun * lun,unsigned char * buf)28adf653f9SChristoph Hellwig static void spc_fill_alua_data(struct se_lun *lun, unsigned char *buf)
291fd032eeSChristoph Hellwig {
301fd032eeSChristoph Hellwig struct t10_alua_tg_pt_gp *tg_pt_gp;
311fd032eeSChristoph Hellwig
321fd032eeSChristoph Hellwig /*
331fd032eeSChristoph Hellwig * Set SCCS for MAINTENANCE_IN + REPORT_TARGET_PORT_GROUPS.
341fd032eeSChristoph Hellwig */
351fd032eeSChristoph Hellwig buf[5] = 0x80;
361fd032eeSChristoph Hellwig
371fd032eeSChristoph Hellwig /*
38125d0119SHannes Reinecke * Set TPGS field for explicit and/or implicit ALUA access type
391fd032eeSChristoph Hellwig * and opteration.
401fd032eeSChristoph Hellwig *
411fd032eeSChristoph Hellwig * See spc4r17 section 6.4.2 Table 135
421fd032eeSChristoph Hellwig */
43e2a49a95SMike Christie rcu_read_lock();
44e2a49a95SMike Christie tg_pt_gp = rcu_dereference(lun->lun_tg_pt_gp);
451fd032eeSChristoph Hellwig if (tg_pt_gp)
461fd032eeSChristoph Hellwig buf[5] |= tg_pt_gp->tg_pt_gp_alua_access_type;
47e2a49a95SMike Christie rcu_read_unlock();
481fd032eeSChristoph Hellwig }
491fd032eeSChristoph Hellwig
50b790a56dSKonstantin Shelekhin static u16
spc_find_scsi_transport_vd(int proto_id)51b790a56dSKonstantin Shelekhin spc_find_scsi_transport_vd(int proto_id)
52b790a56dSKonstantin Shelekhin {
53b790a56dSKonstantin Shelekhin switch (proto_id) {
54b790a56dSKonstantin Shelekhin case SCSI_PROTOCOL_FCP:
55b790a56dSKonstantin Shelekhin return SCSI_VERSION_DESCRIPTOR_FCP4;
56b790a56dSKonstantin Shelekhin case SCSI_PROTOCOL_ISCSI:
57b790a56dSKonstantin Shelekhin return SCSI_VERSION_DESCRIPTOR_ISCSI;
58b790a56dSKonstantin Shelekhin case SCSI_PROTOCOL_SAS:
59b790a56dSKonstantin Shelekhin return SCSI_VERSION_DESCRIPTOR_SAS3;
60b790a56dSKonstantin Shelekhin case SCSI_PROTOCOL_SBP:
61b790a56dSKonstantin Shelekhin return SCSI_VERSION_DESCRIPTOR_SBP3;
62b790a56dSKonstantin Shelekhin case SCSI_PROTOCOL_SRP:
63b790a56dSKonstantin Shelekhin return SCSI_VERSION_DESCRIPTOR_SRP;
64b790a56dSKonstantin Shelekhin default:
65b790a56dSKonstantin Shelekhin pr_warn("Cannot find VERSION DESCRIPTOR value for unknown SCSI"
66b790a56dSKonstantin Shelekhin " transport PROTOCOL IDENTIFIER %#x\n", proto_id);
67b790a56dSKonstantin Shelekhin return 0;
68b790a56dSKonstantin Shelekhin }
69b790a56dSKonstantin Shelekhin }
70b790a56dSKonstantin Shelekhin
710dfa1c5dSHannes Reinecke sense_reason_t
spc_emulate_inquiry_std(struct se_cmd * cmd,unsigned char * buf)720dfa1c5dSHannes Reinecke spc_emulate_inquiry_std(struct se_cmd *cmd, unsigned char *buf)
731fd032eeSChristoph Hellwig {
741fd032eeSChristoph Hellwig struct se_lun *lun = cmd->se_lun;
75b790a56dSKonstantin Shelekhin struct se_portal_group *tpg = lun->lun_tpg;
761fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev;
77d2c5304cSNicholas Bellinger struct se_session *sess = cmd->se_sess;
781fd032eeSChristoph Hellwig
791fd032eeSChristoph Hellwig /* Set RMB (removable media) for tape devices */
801fd032eeSChristoph Hellwig if (dev->transport->get_device_type(dev) == TYPE_TAPE)
811fd032eeSChristoph Hellwig buf[1] = 0x80;
821fd032eeSChristoph Hellwig
8364ae33efSKonstantin Shelekhin buf[2] = 0x06; /* SPC-4 */
841fd032eeSChristoph Hellwig
851fd032eeSChristoph Hellwig /*
861fd032eeSChristoph Hellwig * NORMACA and HISUP = 0, RESPONSE DATA FORMAT = 2
871fd032eeSChristoph Hellwig *
881fd032eeSChristoph Hellwig * SPC4 says:
891fd032eeSChristoph Hellwig * A RESPONSE DATA FORMAT field set to 2h indicates that the
901fd032eeSChristoph Hellwig * standard INQUIRY data is in the format defined in this
911fd032eeSChristoph Hellwig * standard. Response data format values less than 2h are
921fd032eeSChristoph Hellwig * obsolete. Response data format values greater than 2h are
931fd032eeSChristoph Hellwig * reserved.
941fd032eeSChristoph Hellwig */
951fd032eeSChristoph Hellwig buf[3] = 2;
961fd032eeSChristoph Hellwig
971fd032eeSChristoph Hellwig /*
981fd032eeSChristoph Hellwig * Enable SCCS and TPGS fields for Emulated ALUA
991fd032eeSChristoph Hellwig */
100adf653f9SChristoph Hellwig spc_fill_alua_data(lun, buf);
1011fd032eeSChristoph Hellwig
102d397a445SNicholas Bellinger /*
103d397a445SNicholas Bellinger * Set Third-Party Copy (3PC) bit to indicate support for EXTENDED_COPY
104d397a445SNicholas Bellinger */
105d397a445SNicholas Bellinger if (dev->dev_attrib.emulate_3pc)
106d397a445SNicholas Bellinger buf[5] |= 0x8;
107bdbad2bdSNicholas Bellinger /*
108d2c5304cSNicholas Bellinger * Set Protection (PROTECT) bit when DIF has been enabled on the
1099ef5466eSNicholas Bellinger * device, and the fabric supports VERIFY + PASS. Also report
1109ef5466eSNicholas Bellinger * PROTECT=1 if sess_prot_type has been configured to allow T10-PI
1119ef5466eSNicholas Bellinger * to unprotected devices.
112bdbad2bdSNicholas Bellinger */
113d2c5304cSNicholas Bellinger if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
1149ef5466eSNicholas Bellinger if (dev->dev_attrib.pi_prot_type || cmd->se_sess->sess_prot_type)
115bdbad2bdSNicholas Bellinger buf[5] |= 0x1;
116d2c5304cSNicholas Bellinger }
117d397a445SNicholas Bellinger
1185bdd4a8eSDmitry Bogdanov /*
1195bdd4a8eSDmitry Bogdanov * Set MULTIP bit to indicate presence of multiple SCSI target ports
1205bdd4a8eSDmitry Bogdanov */
1215bdd4a8eSDmitry Bogdanov if (dev->export_count > 1)
1225bdd4a8eSDmitry Bogdanov buf[6] |= 0x10;
1235bdd4a8eSDmitry Bogdanov
1241fd032eeSChristoph Hellwig buf[7] = 0x2; /* CmdQue=1 */
1251fd032eeSChristoph Hellwig
1260de26357SDavid Disseldorp /*
1270de26357SDavid Disseldorp * ASCII data fields described as being left-aligned shall have any
1280de26357SDavid Disseldorp * unused bytes at the end of the field (i.e., highest offset) and the
1290de26357SDavid Disseldorp * unused bytes shall be filled with ASCII space characters (20h).
1300de26357SDavid Disseldorp */
131b2da4abfSDavid Disseldorp memset(&buf[8], 0x20,
132b2da4abfSDavid Disseldorp INQUIRY_VENDOR_LEN + INQUIRY_MODEL_LEN + INQUIRY_REVISION_LEN);
1332d882847SDavid Disseldorp memcpy(&buf[8], dev->t10_wwn.vendor,
1342d882847SDavid Disseldorp strnlen(dev->t10_wwn.vendor, INQUIRY_VENDOR_LEN));
135ee60bddbSNicholas Bellinger memcpy(&buf[16], dev->t10_wwn.model,
136b2da4abfSDavid Disseldorp strnlen(dev->t10_wwn.model, INQUIRY_MODEL_LEN));
137ee60bddbSNicholas Bellinger memcpy(&buf[32], dev->t10_wwn.revision,
138b2da4abfSDavid Disseldorp strnlen(dev->t10_wwn.revision, INQUIRY_REVISION_LEN));
139b790a56dSKonstantin Shelekhin
140b790a56dSKonstantin Shelekhin /*
141b790a56dSKonstantin Shelekhin * Set the VERSION DESCRIPTOR fields
142b790a56dSKonstantin Shelekhin */
143b790a56dSKonstantin Shelekhin put_unaligned_be16(SCSI_VERSION_DESCRIPTOR_SAM5, &buf[58]);
144b790a56dSKonstantin Shelekhin put_unaligned_be16(spc_find_scsi_transport_vd(tpg->proto_id), &buf[60]);
145b790a56dSKonstantin Shelekhin put_unaligned_be16(SCSI_VERSION_DESCRIPTOR_SPC4, &buf[62]);
146b790a56dSKonstantin Shelekhin if (cmd->se_dev->transport->get_device_type(dev) == TYPE_DISK)
147b790a56dSKonstantin Shelekhin put_unaligned_be16(SCSI_VERSION_DESCRIPTOR_SBC3, &buf[64]);
148b790a56dSKonstantin Shelekhin
149b790a56dSKonstantin Shelekhin buf[4] = 91; /* Set additional length to 91 */
1501fd032eeSChristoph Hellwig
1511fd032eeSChristoph Hellwig return 0;
1521fd032eeSChristoph Hellwig }
1530dfa1c5dSHannes Reinecke EXPORT_SYMBOL(spc_emulate_inquiry_std);
1541fd032eeSChristoph Hellwig
1551fd032eeSChristoph Hellwig /* unit serial number */
156de103c93SChristoph Hellwig static sense_reason_t
spc_emulate_evpd_80(struct se_cmd * cmd,unsigned char * buf)157de103c93SChristoph Hellwig spc_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf)
1581fd032eeSChristoph Hellwig {
1591fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev;
1609aff64e1SChristophe Vu-Brugier u16 len;
1611fd032eeSChristoph Hellwig
1620fd97ccfSChristoph Hellwig if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
1639aff64e1SChristophe Vu-Brugier len = sprintf(&buf[4], "%s", dev->t10_wwn.unit_serial);
1641fd032eeSChristoph Hellwig len++; /* Extra Byte for NULL Terminator */
1651fd032eeSChristoph Hellwig buf[3] = len;
1661fd032eeSChristoph Hellwig }
1671fd032eeSChristoph Hellwig return 0;
1681fd032eeSChristoph Hellwig }
1691fd032eeSChristoph Hellwig
17017f947b8SSergey Samoylenko /*
17117f947b8SSergey Samoylenko * Generate NAA IEEE Registered Extended designator
17217f947b8SSergey Samoylenko */
spc_gen_naa_6h_vendor_specific(struct se_device * dev,unsigned char * buf)17317f947b8SSergey Samoylenko void spc_gen_naa_6h_vendor_specific(struct se_device *dev,
1741fd032eeSChristoph Hellwig unsigned char *buf)
1751fd032eeSChristoph Hellwig {
1760fd97ccfSChristoph Hellwig unsigned char *p = &dev->t10_wwn.unit_serial[0];
1772469f1e0SSergey Samoylenko u32 company_id = dev->t10_wwn.company_id;
17817f947b8SSergey Samoylenko int cnt, off = 0;
1791fd032eeSChristoph Hellwig bool next = true;
1801fd032eeSChristoph Hellwig
1811fd032eeSChristoph Hellwig /*
18217f947b8SSergey Samoylenko * Start NAA IEEE Registered Extended Identifier/Designator
18317f947b8SSergey Samoylenko */
1842469f1e0SSergey Samoylenko buf[off] = 0x6 << 4;
18517f947b8SSergey Samoylenko
1862469f1e0SSergey Samoylenko /* IEEE COMPANY_ID */
1872469f1e0SSergey Samoylenko buf[off++] |= (company_id >> 20) & 0xf;
1882469f1e0SSergey Samoylenko buf[off++] = (company_id >> 12) & 0xff;
1892469f1e0SSergey Samoylenko buf[off++] = (company_id >> 4) & 0xff;
1902469f1e0SSergey Samoylenko buf[off] = (company_id & 0xf) << 4;
19117f947b8SSergey Samoylenko
19217f947b8SSergey Samoylenko /*
1931fd032eeSChristoph Hellwig * Generate up to 36 bits of VENDOR SPECIFIC IDENTIFIER starting on
1941fd032eeSChristoph Hellwig * byte 3 bit 3-0 for NAA IEEE Registered Extended DESIGNATOR field
1951fd032eeSChristoph Hellwig * format, followed by 64 bits of VENDOR SPECIFIC IDENTIFIER EXTENSION
1961fd032eeSChristoph Hellwig * to complete the payload. These are based from VPD=0x80 PRODUCT SERIAL
1971fd032eeSChristoph Hellwig * NUMBER set via vpd_unit_serial in target_core_configfs.c to ensure
1981fd032eeSChristoph Hellwig * per device uniqeness.
1991fd032eeSChristoph Hellwig */
20017f947b8SSergey Samoylenko for (cnt = off + 13; *p && off < cnt; p++) {
2011fd032eeSChristoph Hellwig int val = hex_to_bin(*p);
2021fd032eeSChristoph Hellwig
2031fd032eeSChristoph Hellwig if (val < 0)
2041fd032eeSChristoph Hellwig continue;
2051fd032eeSChristoph Hellwig
2061fd032eeSChristoph Hellwig if (next) {
2071fd032eeSChristoph Hellwig next = false;
20817f947b8SSergey Samoylenko buf[off++] |= val;
2091fd032eeSChristoph Hellwig } else {
2101fd032eeSChristoph Hellwig next = true;
21117f947b8SSergey Samoylenko buf[off] = val << 4;
2121fd032eeSChristoph Hellwig }
2131fd032eeSChristoph Hellwig }
2141fd032eeSChristoph Hellwig }
2151fd032eeSChristoph Hellwig
2161fd032eeSChristoph Hellwig /*
2171fd032eeSChristoph Hellwig * Device identification VPD, for a complete list of
2181fd032eeSChristoph Hellwig * DESIGNATOR TYPEs see spc4r17 Table 459.
2191fd032eeSChristoph Hellwig */
2200dfa1c5dSHannes Reinecke sense_reason_t
spc_emulate_evpd_83(struct se_cmd * cmd,unsigned char * buf)221de103c93SChristoph Hellwig spc_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)
2221fd032eeSChristoph Hellwig {
2231fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev;
2241fd032eeSChristoph Hellwig struct se_lun *lun = cmd->se_lun;
2251fd032eeSChristoph Hellwig struct se_portal_group *tpg = NULL;
2261fd032eeSChristoph Hellwig struct t10_alua_lu_gp_member *lu_gp_mem;
2271fd032eeSChristoph Hellwig struct t10_alua_tg_pt_gp *tg_pt_gp;
2280fd97ccfSChristoph Hellwig unsigned char *prod = &dev->t10_wwn.model[0];
2291fd032eeSChristoph Hellwig u32 off = 0;
230bc811318SColin Ian King u16 len = 0, id_len;
2311fd032eeSChristoph Hellwig
2321fd032eeSChristoph Hellwig off = 4;
2331fd032eeSChristoph Hellwig
2341fd032eeSChristoph Hellwig /*
2351fd032eeSChristoph Hellwig * NAA IEEE Registered Extended Assigned designator format, see
2361fd032eeSChristoph Hellwig * spc4r17 section 7.7.3.6.5
2371fd032eeSChristoph Hellwig *
2381fd032eeSChristoph Hellwig * We depend upon a target_core_mod/ConfigFS provided
2391fd032eeSChristoph Hellwig * /sys/kernel/config/target/core/$HBA/$DEV/wwn/vpd_unit_serial
2401fd032eeSChristoph Hellwig * value in order to return the NAA id.
2411fd032eeSChristoph Hellwig */
2421fd032eeSChristoph Hellwig if (!(dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL))
2430fd97ccfSChristoph Hellwig goto check_t10_vend_desc;
2441fd032eeSChristoph Hellwig
2451fd032eeSChristoph Hellwig /* CODE SET == Binary */
2461fd032eeSChristoph Hellwig buf[off++] = 0x1;
2471fd032eeSChristoph Hellwig
2481fd032eeSChristoph Hellwig /* Set ASSOCIATION == addressed logical unit: 0)b */
2491fd032eeSChristoph Hellwig buf[off] = 0x00;
2501fd032eeSChristoph Hellwig
2511fd032eeSChristoph Hellwig /* Identifier/Designator type == NAA identifier */
2521fd032eeSChristoph Hellwig buf[off++] |= 0x3;
2531fd032eeSChristoph Hellwig off++;
2541fd032eeSChristoph Hellwig
2551fd032eeSChristoph Hellwig /* Identifier/Designator length */
2561fd032eeSChristoph Hellwig buf[off++] = 0x10;
2571fd032eeSChristoph Hellwig
2581fd032eeSChristoph Hellwig /* NAA IEEE Registered Extended designator */
25917f947b8SSergey Samoylenko spc_gen_naa_6h_vendor_specific(dev, &buf[off]);
26017f947b8SSergey Samoylenko
2611fd032eeSChristoph Hellwig len = 20;
2621fd032eeSChristoph Hellwig off = (len + 4);
2631fd032eeSChristoph Hellwig
2641fd032eeSChristoph Hellwig check_t10_vend_desc:
2651fd032eeSChristoph Hellwig /*
2661fd032eeSChristoph Hellwig * T10 Vendor Identifier Page, see spc4r17 section 7.7.3.4
2671fd032eeSChristoph Hellwig */
2681fd032eeSChristoph Hellwig id_len = 8; /* For Vendor field */
2691fd032eeSChristoph Hellwig
2701fd032eeSChristoph Hellwig if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL)
2711fd032eeSChristoph Hellwig id_len += sprintf(&buf[off+12], "%s:%s", prod,
2721fd032eeSChristoph Hellwig &dev->t10_wwn.unit_serial[0]);
2731fd032eeSChristoph Hellwig buf[off] = 0x2; /* ASCII */
2741fd032eeSChristoph Hellwig buf[off+1] = 0x1; /* T10 Vendor ID */
275bc811318SColin Ian King buf[off+2] = 0x0;
2761fd032eeSChristoph Hellwig /* left align Vendor ID and pad with spaces */
2770fd97ccfSChristoph Hellwig memset(&buf[off+4], 0x20, INQUIRY_VENDOR_LEN);
2781fd032eeSChristoph Hellwig memcpy(&buf[off+4], dev->t10_wwn.vendor,
2791fd032eeSChristoph Hellwig strnlen(dev->t10_wwn.vendor, INQUIRY_VENDOR_LEN));
2801fd032eeSChristoph Hellwig /* Extra Byte for NULL Terminator */
2810de26357SDavid Disseldorp id_len++;
2822d882847SDavid Disseldorp /* Identifier Length */
2832d882847SDavid Disseldorp buf[off+3] = id_len;
2842d882847SDavid Disseldorp /* Header size for Designation descriptor */
2851fd032eeSChristoph Hellwig len += (id_len + 4);
2861fd032eeSChristoph Hellwig off += (id_len + 4);
2871fd032eeSChristoph Hellwig
2881fd032eeSChristoph Hellwig if (1) {
2891fd032eeSChristoph Hellwig struct t10_alua_lu_gp *lu_gp;
2901fd032eeSChristoph Hellwig u32 padding, scsi_name_len, scsi_target_len;
2911fd032eeSChristoph Hellwig u16 lu_gp_id = 0;
292adf653f9SChristoph Hellwig u16 tg_pt_gp_id = 0;
293adf653f9SChristoph Hellwig u16 tpgt;
2941fd032eeSChristoph Hellwig
295fbfe858fSHannes Reinecke tpg = lun->lun_tpg;
2961fd032eeSChristoph Hellwig /*
2971fd032eeSChristoph Hellwig * Relative target port identifer, see spc4r17
2981fd032eeSChristoph Hellwig * section 7.7.3.7
2991fd032eeSChristoph Hellwig *
300adf653f9SChristoph Hellwig * Get the PROTOCOL IDENTIFIER as defined by spc4r17
3011fd032eeSChristoph Hellwig * section 7.5.1 Table 362
3021fd032eeSChristoph Hellwig */
3031fd032eeSChristoph Hellwig buf[off] = tpg->proto_id << 4;
3041fd032eeSChristoph Hellwig buf[off++] |= 0x1; /* CODE SET == Binary */
3051fd032eeSChristoph Hellwig buf[off] = 0x80; /* Set PIV=1 */
3061fd032eeSChristoph Hellwig /* Set ASSOCIATION == target port: 01b */
3071fd032eeSChristoph Hellwig buf[off] |= 0x10;
3082aeeafaeSChristoph Hellwig /* DESIGNATOR TYPE == Relative target port identifer */
3091fd032eeSChristoph Hellwig buf[off++] |= 0x4;
3101fd032eeSChristoph Hellwig off++; /* Skip over Reserved */
3111fd032eeSChristoph Hellwig buf[off++] = 4; /* DESIGNATOR LENGTH */
3121fd032eeSChristoph Hellwig /* Skip over Obsolete field in RTPI payload
3131fd032eeSChristoph Hellwig * in Table 472 */
3141fd032eeSChristoph Hellwig off += 2;
3151fd032eeSChristoph Hellwig put_unaligned_be16(lun->lun_tpg->tpg_rtpi, &buf[off]);
3161fd032eeSChristoph Hellwig off += 2;
3171fd032eeSChristoph Hellwig len += 8; /* Header size + Designation descriptor */
3181fd032eeSChristoph Hellwig /*
3191fd032eeSChristoph Hellwig * Target port group identifier, see spc4r17
320a85d667eSBart Van Assche * section 7.7.3.8
321a85d667eSBart Van Assche *
3221fd032eeSChristoph Hellwig * Get the PROTOCOL IDENTIFIER as defined by spc4r17
3231fd032eeSChristoph Hellwig * section 7.5.1 Table 362
3241fd032eeSChristoph Hellwig */
3251fd032eeSChristoph Hellwig rcu_read_lock();
3261fd032eeSChristoph Hellwig tg_pt_gp = rcu_dereference(lun->lun_tg_pt_gp);
3271fd032eeSChristoph Hellwig if (!tg_pt_gp) {
3281fd032eeSChristoph Hellwig rcu_read_unlock();
3291fd032eeSChristoph Hellwig goto check_lu_gp;
330e2a49a95SMike Christie }
331e2a49a95SMike Christie tg_pt_gp_id = tg_pt_gp->tg_pt_gp_id;
3321fd032eeSChristoph Hellwig rcu_read_unlock();
333e2a49a95SMike Christie
3341fd032eeSChristoph Hellwig buf[off] = tpg->proto_id << 4;
3351fd032eeSChristoph Hellwig buf[off++] |= 0x1; /* CODE SET == Binary */
3361fd032eeSChristoph Hellwig buf[off] = 0x80; /* Set PIV=1 */
337e2a49a95SMike Christie /* Set ASSOCIATION == target port: 01b */
3381fd032eeSChristoph Hellwig buf[off] |= 0x10;
3392aeeafaeSChristoph Hellwig /* DESIGNATOR TYPE == Target port group identifier */
3401fd032eeSChristoph Hellwig buf[off++] |= 0x5;
3411fd032eeSChristoph Hellwig off++; /* Skip over Reserved */
3421fd032eeSChristoph Hellwig buf[off++] = 4; /* DESIGNATOR LENGTH */
3431fd032eeSChristoph Hellwig off += 2; /* Skip over Reserved Field */
3441fd032eeSChristoph Hellwig put_unaligned_be16(tg_pt_gp_id, &buf[off]);
3451fd032eeSChristoph Hellwig off += 2;
3461fd032eeSChristoph Hellwig len += 8; /* Header size + Designation descriptor */
3471fd032eeSChristoph Hellwig /*
3481fd032eeSChristoph Hellwig * Logical Unit Group identifier, see spc4r17
349a85d667eSBart Van Assche * section 7.7.3.8
350a85d667eSBart Van Assche */
3511fd032eeSChristoph Hellwig check_lu_gp:
3521fd032eeSChristoph Hellwig lu_gp_mem = dev->dev_alua_lu_gp_mem;
3531fd032eeSChristoph Hellwig if (!lu_gp_mem)
3541fd032eeSChristoph Hellwig goto check_scsi_name;
3551fd032eeSChristoph Hellwig
3561fd032eeSChristoph Hellwig spin_lock(&lu_gp_mem->lu_gp_mem_lock);
3571fd032eeSChristoph Hellwig lu_gp = lu_gp_mem->lu_gp;
3581fd032eeSChristoph Hellwig if (!lu_gp) {
3591fd032eeSChristoph Hellwig spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
3601fd032eeSChristoph Hellwig goto check_scsi_name;
3611fd032eeSChristoph Hellwig }
3621fd032eeSChristoph Hellwig lu_gp_id = lu_gp->lu_gp_id;
3631fd032eeSChristoph Hellwig spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
3641fd032eeSChristoph Hellwig
3651fd032eeSChristoph Hellwig buf[off++] |= 0x1; /* CODE SET == Binary */
3661fd032eeSChristoph Hellwig /* DESIGNATOR TYPE == Logical Unit Group identifier */
3671fd032eeSChristoph Hellwig buf[off++] |= 0x6;
3681fd032eeSChristoph Hellwig off++; /* Skip over Reserved */
3691fd032eeSChristoph Hellwig buf[off++] = 4; /* DESIGNATOR LENGTH */
3701fd032eeSChristoph Hellwig off += 2; /* Skip over Reserved Field */
3711fd032eeSChristoph Hellwig put_unaligned_be16(lu_gp_id, &buf[off]);
3721fd032eeSChristoph Hellwig off += 2;
3731fd032eeSChristoph Hellwig len += 8; /* Header size + Designation descriptor */
3741fd032eeSChristoph Hellwig /*
3751fd032eeSChristoph Hellwig * SCSI name string designator, see spc4r17
376a85d667eSBart Van Assche * section 7.7.3.11
377a85d667eSBart Van Assche *
3781fd032eeSChristoph Hellwig * Get the PROTOCOL IDENTIFIER as defined by spc4r17
3791fd032eeSChristoph Hellwig * section 7.5.1 Table 362
3801fd032eeSChristoph Hellwig */
3811fd032eeSChristoph Hellwig check_scsi_name:
3821fd032eeSChristoph Hellwig buf[off] = tpg->proto_id << 4;
3831fd032eeSChristoph Hellwig buf[off++] |= 0x3; /* CODE SET == UTF-8 */
3841fd032eeSChristoph Hellwig buf[off] = 0x80; /* Set PIV=1 */
3851fd032eeSChristoph Hellwig /* Set ASSOCIATION == target port: 01b */
3861fd032eeSChristoph Hellwig buf[off] |= 0x10;
3872aeeafaeSChristoph Hellwig /* DESIGNATOR TYPE == SCSI name string */
3881fd032eeSChristoph Hellwig buf[off++] |= 0x8;
3891fd032eeSChristoph Hellwig off += 2; /* Skip over Reserved and length */
3901fd032eeSChristoph Hellwig /*
3911fd032eeSChristoph Hellwig * SCSI name string identifer containing, $FABRIC_MOD
3921fd032eeSChristoph Hellwig * dependent information. For LIO-Target and iSCSI
3931fd032eeSChristoph Hellwig * Target Port, this means "<iSCSI name>,t,0x<TPGT> in
3941fd032eeSChristoph Hellwig * UTF-8 encoding.
3951fd032eeSChristoph Hellwig */
3961fd032eeSChristoph Hellwig tpgt = tpg->se_tpg_tfo->tpg_get_tag(tpg);
3971fd032eeSChristoph Hellwig scsi_name_len = sprintf(&buf[off], "%s,t,0x%04x",
3981fd032eeSChristoph Hellwig tpg->se_tpg_tfo->tpg_get_wwn(tpg), tpgt);
3991fd032eeSChristoph Hellwig scsi_name_len += 1 /* Include NULL terminator */;
4001fd032eeSChristoph Hellwig /*
4011fd032eeSChristoph Hellwig * The null-terminated, null-padded (see 4.4.2) SCSI
4021fd032eeSChristoph Hellwig * NAME STRING field contains a UTF-8 format string.
4031fd032eeSChristoph Hellwig * The number of bytes in the SCSI NAME STRING field
4041fd032eeSChristoph Hellwig * (i.e., the value in the DESIGNATOR LENGTH field)
4051fd032eeSChristoph Hellwig * shall be no larger than 256 and shall be a multiple
4061fd032eeSChristoph Hellwig * of four.
4071fd032eeSChristoph Hellwig */
4081fd032eeSChristoph Hellwig padding = ((-scsi_name_len) & 3);
4091fd032eeSChristoph Hellwig if (padding)
4101fd032eeSChristoph Hellwig scsi_name_len += padding;
4111fd032eeSChristoph Hellwig if (scsi_name_len > 256)
4121fd032eeSChristoph Hellwig scsi_name_len = 256;
41303ba84caSHannes Reinecke
4141fd032eeSChristoph Hellwig buf[off-1] = scsi_name_len;
4151fd032eeSChristoph Hellwig off += scsi_name_len;
41603ba84caSHannes Reinecke /* Header size + Designation descriptor */
41703ba84caSHannes Reinecke len += (scsi_name_len + 4);
4181fd032eeSChristoph Hellwig
4191fd032eeSChristoph Hellwig /*
4201fd032eeSChristoph Hellwig * Target device designator
4211fd032eeSChristoph Hellwig */
4221fd032eeSChristoph Hellwig buf[off] = tpg->proto_id << 4;
423fbfe858fSHannes Reinecke buf[off++] |= 0x3; /* CODE SET == UTF-8 */
424fbfe858fSHannes Reinecke buf[off] = 0x80; /* Set PIV=1 */
425fbfe858fSHannes Reinecke /* Set ASSOCIATION == target device: 10b */
426fbfe858fSHannes Reinecke buf[off] |= 0x20;
4272aeeafaeSChristoph Hellwig /* DESIGNATOR TYPE == SCSI name string */
428fbfe858fSHannes Reinecke buf[off++] |= 0x8;
429fbfe858fSHannes Reinecke off += 2; /* Skip over Reserved and length */
430fbfe858fSHannes Reinecke /*
431fbfe858fSHannes Reinecke * SCSI name string identifer containing, $FABRIC_MOD
432fbfe858fSHannes Reinecke * dependent information. For LIO-Target and iSCSI
433fbfe858fSHannes Reinecke * Target Port, this means "<iSCSI name>" in
434fbfe858fSHannes Reinecke * UTF-8 encoding.
435fbfe858fSHannes Reinecke */
436fbfe858fSHannes Reinecke scsi_target_len = sprintf(&buf[off], "%s",
437fbfe858fSHannes Reinecke tpg->se_tpg_tfo->tpg_get_wwn(tpg));
438fbfe858fSHannes Reinecke scsi_target_len += 1 /* Include NULL terminator */;
439fbfe858fSHannes Reinecke /*
440fbfe858fSHannes Reinecke * The null-terminated, null-padded (see 4.4.2) SCSI
441fbfe858fSHannes Reinecke * NAME STRING field contains a UTF-8 format string.
442fbfe858fSHannes Reinecke * The number of bytes in the SCSI NAME STRING field
443fbfe858fSHannes Reinecke * (i.e., the value in the DESIGNATOR LENGTH field)
444fbfe858fSHannes Reinecke * shall be no larger than 256 and shall be a multiple
445fbfe858fSHannes Reinecke * of four.
446fbfe858fSHannes Reinecke */
447fbfe858fSHannes Reinecke padding = ((-scsi_target_len) & 3);
448fbfe858fSHannes Reinecke if (padding)
449fbfe858fSHannes Reinecke scsi_target_len += padding;
450fbfe858fSHannes Reinecke if (scsi_target_len > 256)
451fbfe858fSHannes Reinecke scsi_target_len = 256;
452fbfe858fSHannes Reinecke
453fbfe858fSHannes Reinecke buf[off-1] = scsi_target_len;
454fbfe858fSHannes Reinecke off += scsi_target_len;
4556a16d7beSRoland Dreier
4566a16d7beSRoland Dreier /* Header size + Designation descriptor */
457fbfe858fSHannes Reinecke len += (scsi_target_len + 4);
458fbfe858fSHannes Reinecke }
459fbfe858fSHannes Reinecke put_unaligned_be16(len, &buf[2]); /* Page Length for VPD 0x83 */
460fbfe858fSHannes Reinecke return 0;
461fbfe858fSHannes Reinecke }
462fbfe858fSHannes Reinecke EXPORT_SYMBOL(spc_emulate_evpd_83);
4631fd032eeSChristoph Hellwig
464a85d667eSBart Van Assche /* Extended INQUIRY Data VPD Page */
4651fd032eeSChristoph Hellwig static sense_reason_t
spc_emulate_evpd_86(struct se_cmd * cmd,unsigned char * buf)4661fd032eeSChristoph Hellwig spc_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf)
4670dfa1c5dSHannes Reinecke {
4681fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev;
4691fd032eeSChristoph Hellwig struct se_session *sess = cmd->se_sess;
470de103c93SChristoph Hellwig
471de103c93SChristoph Hellwig buf[3] = 0x3c;
4721fd032eeSChristoph Hellwig /*
473d0c8b259SNicholas Bellinger * Set GRD_CHK + REF_CHK for TYPE1 protection, or GRD_CHK
474d2c5304cSNicholas Bellinger * only for TYPE3 protection.
475d0c8b259SNicholas Bellinger */
4761fd032eeSChristoph Hellwig if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
47743bb95c7SNicholas Bellinger if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE1_PROT ||
47843bb95c7SNicholas Bellinger cmd->se_sess->sess_prot_type == TARGET_DIF_TYPE1_PROT)
47943bb95c7SNicholas Bellinger buf[4] = 0x5;
48043bb95c7SNicholas Bellinger else if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE3_PROT ||
481d2c5304cSNicholas Bellinger cmd->se_sess->sess_prot_type == TARGET_DIF_TYPE3_PROT)
4829ef5466eSNicholas Bellinger buf[4] = 0x4;
4839ef5466eSNicholas Bellinger }
48443bb95c7SNicholas Bellinger
4859ef5466eSNicholas Bellinger /* logical unit supports type 1 and type 3 protection */
4869ef5466eSNicholas Bellinger if ((dev->transport->get_device_type(dev) == TYPE_DISK) &&
48743bb95c7SNicholas Bellinger (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) &&
488d2c5304cSNicholas Bellinger (dev->dev_attrib.pi_prot_type || cmd->se_sess->sess_prot_type)) {
48943bb95c7SNicholas Bellinger buf[4] |= (0x3 << 3);
49027e6772bSSagi Grimberg }
4913aa3c67bSNicholas Bellinger
4923aa3c67bSNicholas Bellinger /* Set HEADSUP, ORDSUP, SIMPSUP */
4933aa3c67bSNicholas Bellinger buf[5] = 0x07;
49427e6772bSSagi Grimberg
4953aa3c67bSNicholas Bellinger /* If WriteCache emulation is enabled, set V_SUP */
49627e6772bSSagi Grimberg if (target_check_wce(dev))
4971fd032eeSChristoph Hellwig buf[6] = 0x01;
4981fd032eeSChristoph Hellwig /* If an LBA map is present set R_SUP */
4991fd032eeSChristoph Hellwig spin_lock(&cmd->se_dev->t10_alua.lba_map_lock);
5001fd032eeSChristoph Hellwig if (!list_empty(&dev->t10_alua.lba_map_list))
501814e5b45SChristoph Hellwig buf[8] = 0x10;
5021fd032eeSChristoph Hellwig spin_unlock(&cmd->se_dev->t10_alua.lba_map_lock);
503c66094bfSHannes Reinecke return 0;
504c66094bfSHannes Reinecke }
505c66094bfSHannes Reinecke
506c66094bfSHannes Reinecke /* Block Limits VPD page */
507c66094bfSHannes Reinecke static sense_reason_t
spc_emulate_evpd_b0(struct se_cmd * cmd,unsigned char * buf)5081fd032eeSChristoph Hellwig spc_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)
5091fd032eeSChristoph Hellwig {
5101fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev;
5111fd032eeSChristoph Hellwig u32 mtl = 0;
512de103c93SChristoph Hellwig int have_tp = 0, opt, min;
513de103c93SChristoph Hellwig u32 io_max_blocks;
5141fd032eeSChristoph Hellwig
5151fd032eeSChristoph Hellwig /*
5168f9b5654SNicholas Bellinger * Following spc3r22 section 6.5.3 Block Limits VPD page, when
5178f9b5654SNicholas Bellinger * emulate_tpu=1 or emulate_tpws=1 we will be expect a
5187870d248SAnastasia Kovaleva * different page length for Thin Provisioning.
5191fd032eeSChristoph Hellwig */
5201fd032eeSChristoph Hellwig if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws)
5211fd032eeSChristoph Hellwig have_tp = 1;
5221fd032eeSChristoph Hellwig
5231fd032eeSChristoph Hellwig buf[0] = dev->transport->get_device_type(dev);
5241fd032eeSChristoph Hellwig buf[3] = have_tp ? 0x3c : 0x10;
5250fd97ccfSChristoph Hellwig
5261fd032eeSChristoph Hellwig /* Set WSNZ to 1 */
5271fd032eeSChristoph Hellwig buf[4] = 0x01;
5281fd032eeSChristoph Hellwig /*
5291fd032eeSChristoph Hellwig * Set MAXIMUM COMPARE AND WRITE LENGTH
5301fd032eeSChristoph Hellwig */
5311fd032eeSChristoph Hellwig if (dev->dev_attrib.emulate_caw)
5321fd032eeSChristoph Hellwig buf[5] = 0x01;
5330123a9ecSNicholas Bellinger
5340123a9ecSNicholas Bellinger /*
5350123a9ecSNicholas Bellinger * Set OPTIMAL TRANSFER LENGTH GRANULARITY
5360123a9ecSNicholas Bellinger */
5370123a9ecSNicholas Bellinger if (dev->transport->get_io_min && (min = dev->transport->get_io_min(dev)))
5381fd032eeSChristoph Hellwig put_unaligned_be16(min / dev->dev_attrib.block_size, &buf[6]);
5391fd032eeSChristoph Hellwig else
5401fd032eeSChristoph Hellwig put_unaligned_be16(1, &buf[6]);
5411fd032eeSChristoph Hellwig
5427f7caf6aSAndy Grover /*
5437f7caf6aSAndy Grover * Set MAXIMUM TRANSFER LENGTH
5447f7caf6aSAndy Grover *
5451fd032eeSChristoph Hellwig * XXX: Currently assumes single PAGE_SIZE per scatterlist for fabrics
5461fd032eeSChristoph Hellwig * enforcing maximum HW scatter-gather-list entry limit
5471fd032eeSChristoph Hellwig */
5481fd032eeSChristoph Hellwig if (cmd->se_tfo->max_data_sg_nents) {
5498f9b5654SNicholas Bellinger mtl = (cmd->se_tfo->max_data_sg_nents * PAGE_SIZE) /
5508f9b5654SNicholas Bellinger dev->dev_attrib.block_size;
5518f9b5654SNicholas Bellinger }
5521fd032eeSChristoph Hellwig io_max_blocks = mult_frac(dev->dev_attrib.hw_max_sectors,
5538f9b5654SNicholas Bellinger dev->dev_attrib.hw_block_size,
5548f9b5654SNicholas Bellinger dev->dev_attrib.block_size);
5558f9b5654SNicholas Bellinger put_unaligned_be32(min_not_zero(mtl, io_max_blocks), &buf[8]);
5568f9b5654SNicholas Bellinger
5577870d248SAnastasia Kovaleva /*
5587870d248SAnastasia Kovaleva * Set OPTIMAL TRANSFER LENGTH
5597870d248SAnastasia Kovaleva */
5607870d248SAnastasia Kovaleva if (dev->transport->get_io_opt && (opt = dev->transport->get_io_opt(dev)))
5611fd032eeSChristoph Hellwig put_unaligned_be32(opt / dev->dev_attrib.block_size, &buf[12]);
5621fd032eeSChristoph Hellwig else
5631fd032eeSChristoph Hellwig put_unaligned_be32(dev->dev_attrib.optimal_sectors, &buf[12]);
5641fd032eeSChristoph Hellwig
5657f7caf6aSAndy Grover /*
5667f7caf6aSAndy Grover * Exit now if we don't support TP.
5677f7caf6aSAndy Grover */
5680fd97ccfSChristoph Hellwig if (!have_tp)
5691fd032eeSChristoph Hellwig goto max_write_same;
5701fd032eeSChristoph Hellwig
5711fd032eeSChristoph Hellwig /*
5721fd032eeSChristoph Hellwig * Set MAXIMUM UNMAP LBA COUNT
5731fd032eeSChristoph Hellwig */
574773cbaf7SNicholas Bellinger put_unaligned_be32(dev->dev_attrib.max_unmap_lba_count, &buf[20]);
5751fd032eeSChristoph Hellwig
5761fd032eeSChristoph Hellwig /*
5771fd032eeSChristoph Hellwig * Set MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT
5781fd032eeSChristoph Hellwig */
5790fd97ccfSChristoph Hellwig put_unaligned_be32(dev->dev_attrib.max_unmap_block_desc_count,
5801fd032eeSChristoph Hellwig &buf[24]);
5811fd032eeSChristoph Hellwig
5821fd032eeSChristoph Hellwig /*
5831fd032eeSChristoph Hellwig * Set OPTIMAL UNMAP GRANULARITY
5840fd97ccfSChristoph Hellwig */
5851fd032eeSChristoph Hellwig put_unaligned_be32(dev->dev_attrib.unmap_granularity, &buf[28]);
5861fd032eeSChristoph Hellwig
5871fd032eeSChristoph Hellwig /*
5881fd032eeSChristoph Hellwig * UNMAP GRANULARITY ALIGNMENT
5891fd032eeSChristoph Hellwig */
5900fd97ccfSChristoph Hellwig put_unaligned_be32(dev->dev_attrib.unmap_granularity_alignment,
5911fd032eeSChristoph Hellwig &buf[32]);
5921fd032eeSChristoph Hellwig if (dev->dev_attrib.unmap_granularity_alignment != 0)
5931fd032eeSChristoph Hellwig buf[32] |= 0x80; /* Set the UGAVALID bit */
5941fd032eeSChristoph Hellwig
5950fd97ccfSChristoph Hellwig /*
5961fd032eeSChristoph Hellwig * MAXIMUM WRITE SAME LENGTH
5970fd97ccfSChristoph Hellwig */
5981fd032eeSChristoph Hellwig max_write_same:
5991fd032eeSChristoph Hellwig put_unaligned_be64(dev->dev_attrib.max_write_same_len, &buf[36]);
600773cbaf7SNicholas Bellinger
601773cbaf7SNicholas Bellinger return 0;
602773cbaf7SNicholas Bellinger }
603773cbaf7SNicholas Bellinger
604773cbaf7SNicholas Bellinger /* Block Device Characteristics VPD page */
605773cbaf7SNicholas Bellinger static sense_reason_t
spc_emulate_evpd_b1(struct se_cmd * cmd,unsigned char * buf)6061fd032eeSChristoph Hellwig spc_emulate_evpd_b1(struct se_cmd *cmd, unsigned char *buf)
6071fd032eeSChristoph Hellwig {
6081fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev;
6091fd032eeSChristoph Hellwig
610de103c93SChristoph Hellwig buf[0] = dev->transport->get_device_type(dev);
611de103c93SChristoph Hellwig buf[3] = 0x3c;
6121fd032eeSChristoph Hellwig buf[5] = dev->dev_attrib.is_nonrot ? 1 : 0;
6131fd032eeSChristoph Hellwig
6141fd032eeSChristoph Hellwig return 0;
6151fd032eeSChristoph Hellwig }
6161fd032eeSChristoph Hellwig
6170fd97ccfSChristoph Hellwig /* Thin Provisioning VPD */
6181fd032eeSChristoph Hellwig static sense_reason_t
spc_emulate_evpd_b2(struct se_cmd * cmd,unsigned char * buf)6191fd032eeSChristoph Hellwig spc_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf)
6201fd032eeSChristoph Hellwig {
6211fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev;
6221fd032eeSChristoph Hellwig
623de103c93SChristoph Hellwig /*
624de103c93SChristoph Hellwig * From spc3r22 section 6.5.4 Thin Provisioning VPD page:
6251fd032eeSChristoph Hellwig *
6261fd032eeSChristoph Hellwig * The PAGE LENGTH field is defined in SPC-4. If the DP bit is set to
6271fd032eeSChristoph Hellwig * zero, then the page length shall be set to 0004h. If the DP bit
6281fd032eeSChristoph Hellwig * is set to one, then the page length shall be set to the value
6291fd032eeSChristoph Hellwig * defined in table 162.
6301fd032eeSChristoph Hellwig */
6311fd032eeSChristoph Hellwig buf[0] = dev->transport->get_device_type(dev);
6321fd032eeSChristoph Hellwig
6331fd032eeSChristoph Hellwig /*
6341fd032eeSChristoph Hellwig * Set Hardcoded length mentioned above for DP=0
6351fd032eeSChristoph Hellwig */
6361fd032eeSChristoph Hellwig put_unaligned_be16(0x0004, &buf[2]);
6371fd032eeSChristoph Hellwig
6381fd032eeSChristoph Hellwig /*
6391fd032eeSChristoph Hellwig * The THRESHOLD EXPONENT field indicates the threshold set size in
6401fd032eeSChristoph Hellwig * LBAs as a power of 2 (i.e., the threshold set size is equal to
6411fd032eeSChristoph Hellwig * 2(threshold exponent)).
6421fd032eeSChristoph Hellwig *
6431fd032eeSChristoph Hellwig * Note that this is currently set to 0x00 as mkp says it will be
6441fd032eeSChristoph Hellwig * changing again. We can enable this once it has settled in T10
6451fd032eeSChristoph Hellwig * and is actually used by Linux/SCSI ML code.
6461fd032eeSChristoph Hellwig */
6471fd032eeSChristoph Hellwig buf[4] = 0x00;
6481fd032eeSChristoph Hellwig
6491fd032eeSChristoph Hellwig /*
6501fd032eeSChristoph Hellwig * A TPU bit set to one indicates that the device server supports
6511fd032eeSChristoph Hellwig * the UNMAP command (see 5.25). A TPU bit set to zero indicates
6521fd032eeSChristoph Hellwig * that the device server does not support the UNMAP command.
6531fd032eeSChristoph Hellwig */
6541fd032eeSChristoph Hellwig if (dev->dev_attrib.emulate_tpu != 0)
6551fd032eeSChristoph Hellwig buf[5] = 0x80;
6561fd032eeSChristoph Hellwig
6571fd032eeSChristoph Hellwig /*
6581fd032eeSChristoph Hellwig * A TPWS bit set to one indicates that the device server supports
6590fd97ccfSChristoph Hellwig * the use of the WRITE SAME (16) command (see 5.42) to unmap LBAs.
6601fd032eeSChristoph Hellwig * A TPWS bit set to zero indicates that the device server does not
6611fd032eeSChristoph Hellwig * support the use of the WRITE SAME (16) command to unmap LBAs.
6621fd032eeSChristoph Hellwig */
6631fd032eeSChristoph Hellwig if (dev->dev_attrib.emulate_tpws != 0)
6641fd032eeSChristoph Hellwig buf[5] |= 0x40 | 0x20;
6651fd032eeSChristoph Hellwig
6661fd032eeSChristoph Hellwig /*
6671fd032eeSChristoph Hellwig * The unmap_zeroes_data set means that the underlying device supports
6680fd97ccfSChristoph Hellwig * REQ_OP_DISCARD and has the discard_zeroes_data bit set. This
669aa04dae4SNicholas Bellinger * satisfies the SBC requirements for LBPRZ, meaning that a subsequent
6701fd032eeSChristoph Hellwig * read will return zeroes after an UNMAP or WRITE SAME (16) to an LBA
671e6f41633SJamie Pocas * See sbc4r36 6.6.4.
672e6f41633SJamie Pocas */
6739305455aSBart Van Assche if (((dev->dev_attrib.emulate_tpu != 0) ||
6749305455aSBart Van Assche (dev->dev_attrib.emulate_tpws != 0)) &&
6759305455aSBart Van Assche (dev->dev_attrib.unmap_zeroes_data != 0))
676e6f41633SJamie Pocas buf[5] |= 0x04;
677e6f41633SJamie Pocas
678e6f41633SJamie Pocas return 0;
679e6f41633SJamie Pocas }
680e6f41633SJamie Pocas
681e6f41633SJamie Pocas /* Referrals VPD page */
682e6f41633SJamie Pocas static sense_reason_t
spc_emulate_evpd_b3(struct se_cmd * cmd,unsigned char * buf)6831fd032eeSChristoph Hellwig spc_emulate_evpd_b3(struct se_cmd *cmd, unsigned char *buf)
6841fd032eeSChristoph Hellwig {
6851fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev;
686c66094bfSHannes Reinecke
687c66094bfSHannes Reinecke buf[0] = dev->transport->get_device_type(dev);
688c66094bfSHannes Reinecke buf[3] = 0x0c;
689c66094bfSHannes Reinecke put_unaligned_be32(dev->t10_alua.lba_map_segment_size, &buf[8]);
690c66094bfSHannes Reinecke put_unaligned_be32(dev->t10_alua.lba_map_segment_multiplier, &buf[12]);
691c66094bfSHannes Reinecke
692c66094bfSHannes Reinecke return 0;
693c66094bfSHannes Reinecke }
694c66094bfSHannes Reinecke
695096b4995SSebastian Herbszt static sense_reason_t
696c66094bfSHannes Reinecke spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf);
697c66094bfSHannes Reinecke
698c66094bfSHannes Reinecke static struct {
699c66094bfSHannes Reinecke uint8_t page;
700de103c93SChristoph Hellwig sense_reason_t (*emulate)(struct se_cmd *, unsigned char *);
701de103c93SChristoph Hellwig } evpd_handlers[] = {
7021fd032eeSChristoph Hellwig { .page = 0x00, .emulate = spc_emulate_evpd_00 },
7031fd032eeSChristoph Hellwig { .page = 0x80, .emulate = spc_emulate_evpd_80 },
7041fd032eeSChristoph Hellwig { .page = 0x83, .emulate = spc_emulate_evpd_83 },
705de103c93SChristoph Hellwig { .page = 0x86, .emulate = spc_emulate_evpd_86 },
7061fd032eeSChristoph Hellwig { .page = 0xb0, .emulate = spc_emulate_evpd_b0 },
7071fd032eeSChristoph Hellwig { .page = 0xb1, .emulate = spc_emulate_evpd_b1 },
7081fd032eeSChristoph Hellwig { .page = 0xb2, .emulate = spc_emulate_evpd_b2 },
7091fd032eeSChristoph Hellwig { .page = 0xb3, .emulate = spc_emulate_evpd_b3 },
7101fd032eeSChristoph Hellwig };
7111fd032eeSChristoph Hellwig
7121fd032eeSChristoph Hellwig /* supported vital product data pages */
7131fd032eeSChristoph Hellwig static sense_reason_t
spc_emulate_evpd_00(struct se_cmd * cmd,unsigned char * buf)714c66094bfSHannes Reinecke spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf)
7151fd032eeSChristoph Hellwig {
7161fd032eeSChristoph Hellwig int p;
7171fd032eeSChristoph Hellwig
718de103c93SChristoph Hellwig /*
719de103c93SChristoph Hellwig * Only report the INQUIRY EVPD=1 pages after a valid NAA
7201fd032eeSChristoph Hellwig * Registered Extended LUN WWN has been set via ConfigFS
7211fd032eeSChristoph Hellwig * during device creation/restart.
7221fd032eeSChristoph Hellwig */
7231fd032eeSChristoph Hellwig if (cmd->se_dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
7241fd032eeSChristoph Hellwig buf[3] = ARRAY_SIZE(evpd_handlers);
7251fd032eeSChristoph Hellwig for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p)
7261fd032eeSChristoph Hellwig buf[p + 4] = evpd_handlers[p].page;
7271fd032eeSChristoph Hellwig }
7280fd97ccfSChristoph Hellwig
7291fd032eeSChristoph Hellwig return 0;
7301fd032eeSChristoph Hellwig }
7311fd032eeSChristoph Hellwig
7321fd032eeSChristoph Hellwig static sense_reason_t
spc_emulate_inquiry(struct se_cmd * cmd)7331fd032eeSChristoph Hellwig spc_emulate_inquiry(struct se_cmd *cmd)
7341fd032eeSChristoph Hellwig {
7351fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev;
7361fd032eeSChristoph Hellwig unsigned char *rbuf;
737de103c93SChristoph Hellwig unsigned char *cdb = cmd->t_task_cdb;
738de103c93SChristoph Hellwig unsigned char *buf;
7391fd032eeSChristoph Hellwig sense_reason_t ret;
7401fd032eeSChristoph Hellwig int p;
741ffe7b0e9SPaolo Bonzini int len = 0;
7421fd032eeSChristoph Hellwig
743f82f320eSNicholas Bellinger buf = kzalloc(SE_INQUIRY_BUF, GFP_KERNEL);
744de103c93SChristoph Hellwig if (!buf) {
745de103c93SChristoph Hellwig pr_err("Unable to allocate response buffer for INQUIRY\n");
7462426bd45SRoland Dreier return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
7471fd032eeSChristoph Hellwig }
748f82f320eSNicholas Bellinger
749f82f320eSNicholas Bellinger buf[0] = dev->transport->get_device_type(dev);
750f82f320eSNicholas Bellinger
751f82f320eSNicholas Bellinger if (!(cdb[1] & 0x1)) {
752f82f320eSNicholas Bellinger if (cdb[2]) {
753dea5f099SNicholas Bellinger pr_err("INQUIRY with EVPD==0 but PAGE CODE=%02x\n",
7541fd032eeSChristoph Hellwig cdb[2]);
7551fd032eeSChristoph Hellwig ret = TCM_INVALID_CDB_FIELD;
7561fd032eeSChristoph Hellwig goto out;
7571fd032eeSChristoph Hellwig }
7581fd032eeSChristoph Hellwig
7591fd032eeSChristoph Hellwig ret = spc_emulate_inquiry_std(cmd, buf);
760de103c93SChristoph Hellwig len = buf[4] + 5;
7611fd032eeSChristoph Hellwig goto out;
7621fd032eeSChristoph Hellwig }
7631fd032eeSChristoph Hellwig
7641fd032eeSChristoph Hellwig for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p) {
7652426bd45SRoland Dreier if (cdb[2] == evpd_handlers[p].page) {
7661fd032eeSChristoph Hellwig buf[1] = cdb[2];
7671fd032eeSChristoph Hellwig ret = evpd_handlers[p].emulate(cmd, buf);
7681fd032eeSChristoph Hellwig len = get_unaligned_be16(&buf[2]) + 4;
7691fd032eeSChristoph Hellwig goto out;
7701fd032eeSChristoph Hellwig }
7711fd032eeSChristoph Hellwig }
7721fd032eeSChristoph Hellwig
7732426bd45SRoland Dreier pr_debug("Unknown VPD Code: 0x%02x\n", cdb[2]);
7741fd032eeSChristoph Hellwig ret = TCM_INVALID_CDB_FIELD;
7751fd032eeSChristoph Hellwig
7761fd032eeSChristoph Hellwig out:
7771fd032eeSChristoph Hellwig rbuf = transport_kmap_data_sg(cmd);
77895af09faSKonstantin Shelekhin if (rbuf) {
779de103c93SChristoph Hellwig memcpy(rbuf, buf, min_t(u32, SE_INQUIRY_BUF, cmd->data_length));
7801fd032eeSChristoph Hellwig transport_kunmap_data_sg(cmd);
7811fd032eeSChristoph Hellwig }
782ffe7b0e9SPaolo Bonzini kfree(buf);
78349df9fc9SNicholas Bellinger
784f82f320eSNicholas Bellinger if (!ret)
7851fd032eeSChristoph Hellwig target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, len);
78649df9fc9SNicholas Bellinger return ret;
787f82f320eSNicholas Bellinger }
7881fd032eeSChristoph Hellwig
spc_modesense_rwrecovery(struct se_cmd * cmd,u8 pc,u8 * p)7891fd032eeSChristoph Hellwig static int spc_modesense_rwrecovery(struct se_cmd *cmd, u8 pc, u8 *p)
79014b40c1eSHannes Reinecke {
7911fd032eeSChristoph Hellwig p[0] = 0x01;
7921fd032eeSChristoph Hellwig p[1] = 0x0a;
7931fd032eeSChristoph Hellwig
794d45aca42SNicholas Bellinger /* No changeable values for now */
7951fd032eeSChristoph Hellwig if (pc == 1)
7961fd032eeSChristoph Hellwig goto out;
7971fd032eeSChristoph Hellwig
7981fd032eeSChristoph Hellwig out:
799d4b2b867SRoland Dreier return 12;
800d4b2b867SRoland Dreier }
801d4b2b867SRoland Dreier
spc_modesense_control(struct se_cmd * cmd,u8 pc,u8 * p)802d4b2b867SRoland Dreier static int spc_modesense_control(struct se_cmd *cmd, u8 pc, u8 *p)
803d4b2b867SRoland Dreier {
8041fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev;
8051fd032eeSChristoph Hellwig struct se_session *sess = cmd->se_sess;
8061fd032eeSChristoph Hellwig
807d45aca42SNicholas Bellinger p[0] = 0x0a;
8081fd032eeSChristoph Hellwig p[1] = 0x0a;
809d45aca42SNicholas Bellinger
810d45aca42SNicholas Bellinger /* No changeable values for now */
811d45aca42SNicholas Bellinger if (pc == 1)
8121fd032eeSChristoph Hellwig goto out;
8131fd032eeSChristoph Hellwig
814d4b2b867SRoland Dreier /* GLTSD: No implicit save of log parameters */
815d4b2b867SRoland Dreier p[2] = (1 << 1);
816d4b2b867SRoland Dreier if (target_sense_desc_format(dev))
817d4b2b867SRoland Dreier /* D_SENSE: Descriptor format sense data for 64bit sectors */
818d4b2b867SRoland Dreier p[2] |= (1 << 2);
8194e4937e8SSagi Grimberg
8204e4937e8SSagi Grimberg /*
8214e4937e8SSagi Grimberg * From spc4r23, 7.4.7 Control mode page
8224e4937e8SSagi Grimberg *
8234e4937e8SSagi Grimberg * The QUEUE ALGORITHM MODIFIER field (see table 368) specifies
8244e4937e8SSagi Grimberg * restrictions on the algorithm used for reordering commands
8251fd032eeSChristoph Hellwig * having the SIMPLE task attribute (see SAM-4).
8261fd032eeSChristoph Hellwig *
8271fd032eeSChristoph Hellwig * Table 368 -- QUEUE ALGORITHM MODIFIER field
8281fd032eeSChristoph Hellwig * Code Description
8291fd032eeSChristoph Hellwig * 0h Restricted reordering
8301fd032eeSChristoph Hellwig * 1h Unrestricted reordering allowed
8311fd032eeSChristoph Hellwig * 2h to 7h Reserved
8321fd032eeSChristoph Hellwig * 8h to Fh Vendor specific
8331fd032eeSChristoph Hellwig *
8341fd032eeSChristoph Hellwig * A value of zero in the QUEUE ALGORITHM MODIFIER field specifies that
8351fd032eeSChristoph Hellwig * the device server shall order the processing sequence of commands
8361fd032eeSChristoph Hellwig * having the SIMPLE task attribute such that data integrity is maintained
8371fd032eeSChristoph Hellwig * for that I_T nexus (i.e., if the transmission of new SCSI transport protocol
8381fd032eeSChristoph Hellwig * requests is halted at any time, the final value of all data observable
8391fd032eeSChristoph Hellwig * on the medium shall be the same as if all the commands had been processed
8401fd032eeSChristoph Hellwig * with the ORDERED task attribute).
8411fd032eeSChristoph Hellwig *
8421fd032eeSChristoph Hellwig * A value of one in the QUEUE ALGORITHM MODIFIER field specifies that the
8431fd032eeSChristoph Hellwig * device server may reorder the processing sequence of commands having the
8441fd032eeSChristoph Hellwig * SIMPLE task attribute in any manner. Any data integrity exposures related to
8451fd032eeSChristoph Hellwig * command sequence order shall be explicitly handled by the application client
8461fd032eeSChristoph Hellwig * through the selection of appropriate ommands and task attributes.
8471fd032eeSChristoph Hellwig */
8481fd032eeSChristoph Hellwig p[3] = (dev->dev_attrib.emulate_rest_reord == 1) ? 0x00 : 0x10;
8491fd032eeSChristoph Hellwig /*
8501fd032eeSChristoph Hellwig * From spc4r17, section 7.4.6 Control mode Page
8511fd032eeSChristoph Hellwig *
8521fd032eeSChristoph Hellwig * Unit Attention interlocks control (UN_INTLCK_CTRL) to code 00b
8530fd97ccfSChristoph Hellwig *
8541fd032eeSChristoph Hellwig * 00b: The logical unit shall clear any unit attention condition
8551fd032eeSChristoph Hellwig * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
8561fd032eeSChristoph Hellwig * status and shall not establish a unit attention condition when a com-
8571fd032eeSChristoph Hellwig * mand is completed with BUSY, TASK SET FULL, or RESERVATION CONFLICT
8581fd032eeSChristoph Hellwig * status.
8591fd032eeSChristoph Hellwig *
8601fd032eeSChristoph Hellwig * 10b: The logical unit shall not clear any unit attention condition
8611fd032eeSChristoph Hellwig * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
8621fd032eeSChristoph Hellwig * status and shall not establish a unit attention condition when
8631fd032eeSChristoph Hellwig * a command is completed with BUSY, TASK SET FULL, or RESERVATION
8641fd032eeSChristoph Hellwig * CONFLICT status.
8651fd032eeSChristoph Hellwig *
8661fd032eeSChristoph Hellwig * 11b a The logical unit shall not clear any unit attention condition
8671fd032eeSChristoph Hellwig * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
8681fd032eeSChristoph Hellwig * status and shall establish a unit attention condition for the
8691fd032eeSChristoph Hellwig * initiator port associated with the I_T nexus on which the BUSY,
8701fd032eeSChristoph Hellwig * TASK SET FULL, or RESERVATION CONFLICT status is being returned.
8711fd032eeSChristoph Hellwig * Depending on the status, the additional sense code shall be set to
8721fd032eeSChristoph Hellwig * PREVIOUS BUSY STATUS, PREVIOUS TASK SET FULL STATUS, or PREVIOUS
8731fd032eeSChristoph Hellwig * RESERVATION CONFLICT STATUS. Until it is cleared by a REQUEST SENSE
8741fd032eeSChristoph Hellwig * command, a unit attention condition shall be established only once
8751fd032eeSChristoph Hellwig * for a BUSY, TASK SET FULL, or RESERVATION CONFLICT status regardless
8761fd032eeSChristoph Hellwig * to the number of commands completed with one of those status codes.
8771fd032eeSChristoph Hellwig */
8781fd032eeSChristoph Hellwig switch (dev->dev_attrib.emulate_ua_intlck_ctrl) {
8791fd032eeSChristoph Hellwig case TARGET_UA_INTLCK_CTRL_ESTABLISH_UA:
8801fd032eeSChristoph Hellwig p[4] = 0x30;
8811fd032eeSChristoph Hellwig break;
8821fd032eeSChristoph Hellwig case TARGET_UA_INTLCK_CTRL_NO_CLEAR:
8831bf630fdSDavid Disseldorp p[4] = 0x20;
8841bf630fdSDavid Disseldorp break;
8851bf630fdSDavid Disseldorp default: /* TARGET_UA_INTLCK_CTRL_CLEAR */
8861bf630fdSDavid Disseldorp p[4] = 0x00;
8871bf630fdSDavid Disseldorp break;
8881bf630fdSDavid Disseldorp }
8891bf630fdSDavid Disseldorp /*
8901bf630fdSDavid Disseldorp * From spc4r17, section 7.4.6 Control mode Page
8911bf630fdSDavid Disseldorp *
8921bf630fdSDavid Disseldorp * Task Aborted Status (TAS) bit set to zero.
8931bf630fdSDavid Disseldorp *
8941fd032eeSChristoph Hellwig * A task aborted status (TAS) bit set to zero specifies that aborted
8951fd032eeSChristoph Hellwig * tasks shall be terminated by the device server without any response
8961fd032eeSChristoph Hellwig * to the application client. A TAS bit set to one specifies that tasks
8971fd032eeSChristoph Hellwig * aborted by the actions of an I_T nexus other than the I_T nexus on
8981fd032eeSChristoph Hellwig * which the command was received shall be completed with TASK ABORTED
8991fd032eeSChristoph Hellwig * status (see SAM-4).
9001fd032eeSChristoph Hellwig */
9011fd032eeSChristoph Hellwig p[5] = (dev->dev_attrib.emulate_tas) ? 0x40 : 0x00;
9021fd032eeSChristoph Hellwig /*
9031fd032eeSChristoph Hellwig * From spc4r30, section 7.5.7 Control mode page
9041fd032eeSChristoph Hellwig *
9051fd032eeSChristoph Hellwig * Application Tag Owner (ATO) bit set to one.
9060fd97ccfSChristoph Hellwig *
9070c30f421SNicholas Bellinger * If the ATO bit is set to one the device server shall not modify the
9080c30f421SNicholas Bellinger * LOGICAL BLOCK APPLICATION TAG field and, depending on the protection
9090c30f421SNicholas Bellinger * type, shall not modify the contents of the LOGICAL BLOCK REFERENCE
9100c30f421SNicholas Bellinger * TAG field.
9110c30f421SNicholas Bellinger */
9120c30f421SNicholas Bellinger if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
9130c30f421SNicholas Bellinger if (dev->dev_attrib.pi_prot_type || sess->sess_prot_type)
9140c30f421SNicholas Bellinger p[5] |= 0x80;
9150c30f421SNicholas Bellinger }
9160c30f421SNicholas Bellinger
917d45aca42SNicholas Bellinger p[8] = 0xff;
9189ef5466eSNicholas Bellinger p[9] = 0xff;
9190c30f421SNicholas Bellinger p[11] = 30;
920d45aca42SNicholas Bellinger
9210c30f421SNicholas Bellinger out:
9221fd032eeSChristoph Hellwig return 12;
9231fd032eeSChristoph Hellwig }
9241fd032eeSChristoph Hellwig
spc_modesense_caching(struct se_cmd * cmd,u8 pc,u8 * p)9251fd032eeSChristoph Hellwig static int spc_modesense_caching(struct se_cmd *cmd, u8 pc, u8 *p)
926d4b2b867SRoland Dreier {
9271fd032eeSChristoph Hellwig struct se_device *dev = cmd->se_dev;
9281fd032eeSChristoph Hellwig
9291fd032eeSChristoph Hellwig p[0] = 0x08;
930d45aca42SNicholas Bellinger p[1] = 0x12;
9311fd032eeSChristoph Hellwig
932d45aca42SNicholas Bellinger /* No changeable values for now */
933d45aca42SNicholas Bellinger if (pc == 1)
9341fd032eeSChristoph Hellwig goto out;
9351fd032eeSChristoph Hellwig
936d4b2b867SRoland Dreier if (target_check_wce(dev))
937d4b2b867SRoland Dreier p[2] = 0x04; /* Write Cache Enable */
938d4b2b867SRoland Dreier p[12] = 0x20; /* Disabled Read Ahead */
939d4b2b867SRoland Dreier
940d4b2b867SRoland Dreier out:
941814e5b45SChristoph Hellwig return 20;
9421fd032eeSChristoph Hellwig }
9431fd032eeSChristoph Hellwig
spc_modesense_informational_exceptions(struct se_cmd * cmd,u8 pc,unsigned char * p)9441fd032eeSChristoph Hellwig static int spc_modesense_informational_exceptions(struct se_cmd *cmd, u8 pc, unsigned char *p)
945d4b2b867SRoland Dreier {
9461fd032eeSChristoph Hellwig p[0] = 0x1c;
9471fd032eeSChristoph Hellwig p[1] = 0x0a;
9481fd032eeSChristoph Hellwig
949d45aca42SNicholas Bellinger /* No changeable values for now */
9500f6d64ceSRoland Dreier if (pc == 1)
9510f6d64ceSRoland Dreier goto out;
9520f6d64ceSRoland Dreier
9530f6d64ceSRoland Dreier out:
9540f6d64ceSRoland Dreier return 12;
9550f6d64ceSRoland Dreier }
9560f6d64ceSRoland Dreier
9570f6d64ceSRoland Dreier static struct {
9580f6d64ceSRoland Dreier uint8_t page;
9590f6d64ceSRoland Dreier uint8_t subpage;
9600f6d64ceSRoland Dreier int (*emulate)(struct se_cmd *, u8, unsigned char *);
9610f6d64ceSRoland Dreier } modesense_handlers[] = {
962d4b2b867SRoland Dreier { .page = 0x01, .subpage = 0x00, .emulate = spc_modesense_rwrecovery },
963d4b2b867SRoland Dreier { .page = 0x08, .subpage = 0x00, .emulate = spc_modesense_caching },
964d4b2b867SRoland Dreier { .page = 0x0a, .subpage = 0x00, .emulate = spc_modesense_control },
965d45aca42SNicholas Bellinger { .page = 0x1c, .subpage = 0x00, .emulate = spc_modesense_informational_exceptions },
966d4b2b867SRoland Dreier };
967d4b2b867SRoland Dreier
spc_modesense_write_protect(unsigned char * buf,int type)968d4b2b867SRoland Dreier static void spc_modesense_write_protect(unsigned char *buf, int type)
969d4b2b867SRoland Dreier {
9700f6d64ceSRoland Dreier /*
971d4b2b867SRoland Dreier * I believe that the WP bit (bit 7) in the mode header is the same for
972d4b2b867SRoland Dreier * all device types..
9731fd032eeSChristoph Hellwig */
9741fd032eeSChristoph Hellwig switch (type) {
9751fd032eeSChristoph Hellwig case TYPE_DISK:
9761fd032eeSChristoph Hellwig case TYPE_TAPE:
9771fd032eeSChristoph Hellwig default:
9781fd032eeSChristoph Hellwig buf[0] |= 0x80; /* WP bit */
9791fd032eeSChristoph Hellwig break;
9801fd032eeSChristoph Hellwig }
9811fd032eeSChristoph Hellwig }
9821fd032eeSChristoph Hellwig
spc_modesense_dpofua(unsigned char * buf,int type)9831fd032eeSChristoph Hellwig static void spc_modesense_dpofua(unsigned char *buf, int type)
9841fd032eeSChristoph Hellwig {
9851fd032eeSChristoph Hellwig switch (type) {
9861fd032eeSChristoph Hellwig case TYPE_DISK:
9871fd032eeSChristoph Hellwig buf[0] |= 0x10; /* DPOFUA bit */
9881fd032eeSChristoph Hellwig break;
9891fd032eeSChristoph Hellwig default:
9901fd032eeSChristoph Hellwig break;
9911fd032eeSChristoph Hellwig }
9921fd032eeSChristoph Hellwig }
9931fd032eeSChristoph Hellwig
spc_modesense_blockdesc(unsigned char * buf,u64 blocks,u32 block_size)9941fd032eeSChristoph Hellwig static int spc_modesense_blockdesc(unsigned char *buf, u64 blocks, u32 block_size)
9951fd032eeSChristoph Hellwig {
9961fd032eeSChristoph Hellwig *buf++ = 8;
9971fd032eeSChristoph Hellwig put_unaligned_be32(min(blocks, 0xffffffffull), buf);
9981fd032eeSChristoph Hellwig buf += 4;
999d4b2b867SRoland Dreier put_unaligned_be32(block_size, buf);
1000d4b2b867SRoland Dreier return 9;
1001d4b2b867SRoland Dreier }
1002d4b2b867SRoland Dreier
spc_modesense_long_blockdesc(unsigned char * buf,u64 blocks,u32 block_size)1003d4b2b867SRoland Dreier static int spc_modesense_long_blockdesc(unsigned char *buf, u64 blocks, u32 block_size)
1004d4b2b867SRoland Dreier {
1005d4b2b867SRoland Dreier if (blocks <= 0xffffffff)
1006d4b2b867SRoland Dreier return spc_modesense_blockdesc(buf + 3, blocks, block_size) + 3;
1007d4b2b867SRoland Dreier
1008d4b2b867SRoland Dreier *buf++ = 1; /* LONGLBA */
1009d4b2b867SRoland Dreier buf += 2;
1010d4b2b867SRoland Dreier *buf++ = 16;
1011d4b2b867SRoland Dreier put_unaligned_be64(blocks, buf);
1012d4b2b867SRoland Dreier buf += 12;
1013d4b2b867SRoland Dreier put_unaligned_be32(block_size, buf);
1014d4b2b867SRoland Dreier
1015d4b2b867SRoland Dreier return 17;
1016d4b2b867SRoland Dreier }
1017d4b2b867SRoland Dreier
spc_emulate_modesense(struct se_cmd * cmd)1018d4b2b867SRoland Dreier static sense_reason_t spc_emulate_modesense(struct se_cmd *cmd)
1019d4b2b867SRoland Dreier {
1020d4b2b867SRoland Dreier struct se_device *dev = cmd->se_dev;
1021d4b2b867SRoland Dreier char *cdb = cmd->t_task_cdb;
1022d4b2b867SRoland Dreier unsigned char buf[SE_MODE_PAGE_BUF], *rbuf;
1023de103c93SChristoph Hellwig int type = dev->transport->get_device_type(dev);
10241fd032eeSChristoph Hellwig int ten = (cmd->t_task_cdb[0] == MODE_SENSE_10);
10251fd032eeSChristoph Hellwig bool dbd = !!(cdb[1] & 0x08);
10261fd032eeSChristoph Hellwig bool llba = ten ? !!(cdb[1] & 0x10) : false;
1027cab9609bSNicholas Bellinger u8 pc = cdb[2] >> 6;
10281fd032eeSChristoph Hellwig u8 page = cdb[2] & 0x3f;
10291fd032eeSChristoph Hellwig u8 subpage = cdb[3];
1030d4b2b867SRoland Dreier int length = 0;
1031d4b2b867SRoland Dreier int ret;
1032d4b2b867SRoland Dreier int i;
1033d4b2b867SRoland Dreier
1034d4b2b867SRoland Dreier memset(buf, 0, SE_MODE_PAGE_BUF);
10351fd032eeSChristoph Hellwig
1036d4b2b867SRoland Dreier /*
1037d4b2b867SRoland Dreier * Skip over MODE DATA LENGTH + MEDIUM TYPE fields to byte 3 for
10381fd032eeSChristoph Hellwig * MODE_SENSE_10 and byte 2 for MODE_SENSE (6).
1039cab9609bSNicholas Bellinger */
1040cab9609bSNicholas Bellinger length = ten ? 3 : 2;
1041fecae40aSNicholas Bellinger
1042fecae40aSNicholas Bellinger /* DEVICE-SPECIFIC PARAMETER */
1043fecae40aSNicholas Bellinger if (cmd->se_lun->lun_access_ro || target_lun_is_rdonly(cmd))
1044fecae40aSNicholas Bellinger spc_modesense_write_protect(&buf[length], type);
1045fecae40aSNicholas Bellinger
1046d4b2b867SRoland Dreier /*
1047d4b2b867SRoland Dreier * SBC only allows us to enable FUA and DPO together. Fortunately
104803a68b44SAndy Grover * DPO is explicitly specified as a hint, so a noop is a perfectly
1049d4b2b867SRoland Dreier * valid implementation.
1050d4b2b867SRoland Dreier */
1051814e5b45SChristoph Hellwig if (target_check_fua(dev))
1052814e5b45SChristoph Hellwig spc_modesense_dpofua(&buf[length], type);
1053814e5b45SChristoph Hellwig
1054814e5b45SChristoph Hellwig ++length;
1055814e5b45SChristoph Hellwig
1056814e5b45SChristoph Hellwig /* BLOCK DESCRIPTOR */
1057d4b2b867SRoland Dreier
1058d4b2b867SRoland Dreier /*
1059d4b2b867SRoland Dreier * For now we only include a block descriptor for disk (SBC)
1060d4b2b867SRoland Dreier * devices; other command sets use a slightly different format.
1061d4b2b867SRoland Dreier */
1062d4b2b867SRoland Dreier if (!dbd && type == TYPE_DISK) {
1063d4b2b867SRoland Dreier u64 blocks = dev->transport->get_blocks(dev);
1064d4b2b867SRoland Dreier u32 block_size = dev->dev_attrib.block_size;
1065d4b2b867SRoland Dreier
1066d4b2b867SRoland Dreier if (ten) {
1067d4b2b867SRoland Dreier if (llba) {
1068d4b2b867SRoland Dreier length += spc_modesense_long_blockdesc(&buf[length],
1069d4b2b867SRoland Dreier blocks, block_size);
10701fd032eeSChristoph Hellwig } else {
10711fd032eeSChristoph Hellwig length += 3;
1072d4b2b867SRoland Dreier length += spc_modesense_blockdesc(&buf[length],
1073d4b2b867SRoland Dreier blocks, block_size);
1074d4b2b867SRoland Dreier }
10751fd032eeSChristoph Hellwig } else {
1076d4b2b867SRoland Dreier length += spc_modesense_blockdesc(&buf[length], blocks,
1077d4b2b867SRoland Dreier block_size);
1078d4b2b867SRoland Dreier }
1079d4b2b867SRoland Dreier } else {
1080d4b2b867SRoland Dreier if (ten)
1081d4b2b867SRoland Dreier length += 4;
1082d4b2b867SRoland Dreier else
1083d4b2b867SRoland Dreier length += 1;
1084d4b2b867SRoland Dreier }
1085d4b2b867SRoland Dreier
1086d4b2b867SRoland Dreier if (page == 0x3f) {
1087d4b2b867SRoland Dreier if (subpage != 0x00 && subpage != 0xff) {
1088d4b2b867SRoland Dreier pr_warn("MODE_SENSE: Invalid subpage code: 0x%02x\n", subpage);
10891fd032eeSChristoph Hellwig return TCM_INVALID_CDB_FIELD;
10901fd032eeSChristoph Hellwig }
1091d4b2b867SRoland Dreier
1092d4b2b867SRoland Dreier for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i) {
1093de103c93SChristoph Hellwig /*
1094de103c93SChristoph Hellwig * Tricky way to say all subpage 00h for
1095d4b2b867SRoland Dreier * subpage==0, all subpages for subpage==0xff
1096d4b2b867SRoland Dreier * (and we just checked above that those are
1097d4b2b867SRoland Dreier * the only two possibilities).
1098d4b2b867SRoland Dreier */
1099d4b2b867SRoland Dreier if ((modesense_handlers[i].subpage & ~subpage) == 0) {
1100d4b2b867SRoland Dreier ret = modesense_handlers[i].emulate(cmd, pc, &buf[length]);
1101d4b2b867SRoland Dreier if (!ten && length + ret >= 255)
1102d4b2b867SRoland Dreier break;
1103d4b2b867SRoland Dreier length += ret;
1104d4b2b867SRoland Dreier }
1105d45aca42SNicholas Bellinger }
1106d4b2b867SRoland Dreier
1107d4b2b867SRoland Dreier goto set_length;
1108d4b2b867SRoland Dreier }
1109d4b2b867SRoland Dreier
1110d4b2b867SRoland Dreier for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i)
1111d4b2b867SRoland Dreier if (modesense_handlers[i].page == page &&
1112d4b2b867SRoland Dreier modesense_handlers[i].subpage == subpage) {
1113d4b2b867SRoland Dreier length += modesense_handlers[i].emulate(cmd, pc, &buf[length]);
1114d4b2b867SRoland Dreier goto set_length;
1115d4b2b867SRoland Dreier }
1116d4b2b867SRoland Dreier
1117d4b2b867SRoland Dreier /*
1118d45aca42SNicholas Bellinger * We don't intend to implement:
1119d4b2b867SRoland Dreier * - obsolete page 03h "format parameters" (checked by Solaris)
1120d4b2b867SRoland Dreier */
1121d4b2b867SRoland Dreier if (page != 0x03)
1122d4b2b867SRoland Dreier pr_err("MODE SENSE: unimplemented page/subpage: 0x%02x/0x%02x\n",
1123d4b2b867SRoland Dreier page, subpage);
1124d4b2b867SRoland Dreier
1125d4b2b867SRoland Dreier return TCM_UNKNOWN_MODE_PAGE;
1126d4b2b867SRoland Dreier
1127d4b2b867SRoland Dreier set_length:
1128d4b2b867SRoland Dreier if (ten)
1129d4b2b867SRoland Dreier put_unaligned_be16(length - 2, buf);
1130de103c93SChristoph Hellwig else
1131d4b2b867SRoland Dreier buf[0] = length - 1;
1132d4b2b867SRoland Dreier
1133d4b2b867SRoland Dreier rbuf = transport_kmap_data_sg(cmd);
1134d4b2b867SRoland Dreier if (rbuf) {
1135d4b2b867SRoland Dreier memcpy(rbuf, buf, min_t(u32, SE_MODE_PAGE_BUF, cmd->data_length));
1136d4b2b867SRoland Dreier transport_kunmap_data_sg(cmd);
1137d4b2b867SRoland Dreier }
1138cab9609bSNicholas Bellinger
1139cab9609bSNicholas Bellinger target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, length);
1140cab9609bSNicholas Bellinger return 0;
1141cab9609bSNicholas Bellinger }
1142d4b2b867SRoland Dreier
spc_emulate_modeselect(struct se_cmd * cmd)1143d4b2b867SRoland Dreier static sense_reason_t spc_emulate_modeselect(struct se_cmd *cmd)
114414b40c1eSHannes Reinecke {
11451fd032eeSChristoph Hellwig char *cdb = cmd->t_task_cdb;
11461fd032eeSChristoph Hellwig bool ten = cdb[0] == MODE_SELECT_10;
11471fd032eeSChristoph Hellwig int off = ten ? 8 : 4;
1148de103c93SChristoph Hellwig bool pf = !!(cdb[1] & 0x10);
11493a3c5e4aSRoland Dreier u8 page, subpage;
11503a3c5e4aSRoland Dreier unsigned char *buf;
11513a3c5e4aSRoland Dreier unsigned char tbuf[SE_MODE_PAGE_BUF];
11523a3c5e4aSRoland Dreier int length;
11533a3c5e4aSRoland Dreier sense_reason_t ret = 0;
11543a3c5e4aSRoland Dreier int i;
11553a3c5e4aSRoland Dreier
11563a3c5e4aSRoland Dreier if (!cmd->data_length) {
11573a3c5e4aSRoland Dreier target_complete_cmd(cmd, SAM_STAT_GOOD);
11583abff1e5SChristoph Hellwig return 0;
11593a3c5e4aSRoland Dreier }
11603a3c5e4aSRoland Dreier
116171f41fe1SRoland Dreier if (cmd->data_length < off + 2)
116214b40c1eSHannes Reinecke return TCM_PARAMETER_LIST_LENGTH_ERROR;
116371f41fe1SRoland Dreier
116471f41fe1SRoland Dreier buf = transport_kmap_data_sg(cmd);
116571f41fe1SRoland Dreier if (!buf)
116671f41fe1SRoland Dreier return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
116771f41fe1SRoland Dreier
116871f41fe1SRoland Dreier if (!pf) {
11693a3c5e4aSRoland Dreier ret = TCM_INVALID_CDB_FIELD;
1170de103c93SChristoph Hellwig goto out;
1171de103c93SChristoph Hellwig }
11723a3c5e4aSRoland Dreier
11733a3c5e4aSRoland Dreier page = buf[off] & 0x3f;
1174de103c93SChristoph Hellwig subpage = buf[off] & 0x40 ? buf[off + 1] : 0;
11753a3c5e4aSRoland Dreier
11763a3c5e4aSRoland Dreier for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i)
11773a3c5e4aSRoland Dreier if (modesense_handlers[i].page == page &&
11783a3c5e4aSRoland Dreier modesense_handlers[i].subpage == subpage) {
11793a3c5e4aSRoland Dreier memset(tbuf, 0, SE_MODE_PAGE_BUF);
11803a3c5e4aSRoland Dreier length = modesense_handlers[i].emulate(cmd, 0, tbuf);
11813a3c5e4aSRoland Dreier goto check_contents;
11823a3c5e4aSRoland Dreier }
11833a3c5e4aSRoland Dreier
11843a3c5e4aSRoland Dreier ret = TCM_UNKNOWN_MODE_PAGE;
1185d45aca42SNicholas Bellinger goto out;
11863a3c5e4aSRoland Dreier
11873a3c5e4aSRoland Dreier check_contents:
11883a3c5e4aSRoland Dreier if (cmd->data_length < off + length) {
1189de103c93SChristoph Hellwig ret = TCM_PARAMETER_LIST_LENGTH_ERROR;
11903a3c5e4aSRoland Dreier goto out;
11913a3c5e4aSRoland Dreier }
11923a3c5e4aSRoland Dreier
119371f41fe1SRoland Dreier if (memcmp(buf + off, tbuf, length))
119471f41fe1SRoland Dreier ret = TCM_INVALID_PARAMETER_LIST;
119571f41fe1SRoland Dreier
119671f41fe1SRoland Dreier out:
119771f41fe1SRoland Dreier transport_kunmap_data_sg(cmd);
1198de103c93SChristoph Hellwig
1199de103c93SChristoph Hellwig if (!ret)
12003a3c5e4aSRoland Dreier target_complete_cmd(cmd, SAM_STAT_GOOD);
12013a3c5e4aSRoland Dreier return ret;
12023a3c5e4aSRoland Dreier }
12033a3c5e4aSRoland Dreier
spc_emulate_request_sense(struct se_cmd * cmd)12043a3c5e4aSRoland Dreier static sense_reason_t spc_emulate_request_sense(struct se_cmd *cmd)
120514b40c1eSHannes Reinecke {
12063a3c5e4aSRoland Dreier unsigned char *cdb = cmd->t_task_cdb;
12073a3c5e4aSRoland Dreier unsigned char *rbuf;
12083a3c5e4aSRoland Dreier u8 ua_asc = 0, ua_ascq = 0;
1209de103c93SChristoph Hellwig unsigned char buf[SE_SENSE_BUF];
12101fd032eeSChristoph Hellwig bool desc_format = target_sense_desc_format(cmd->se_dev);
12111fd032eeSChristoph Hellwig
121232a8811fSPaolo Bonzini memset(buf, 0, SE_SENSE_BUF);
12131fd032eeSChristoph Hellwig
121432a8811fSPaolo Bonzini if (cdb[1] & 0x01) {
12154e4937e8SSagi Grimberg pr_err("REQUEST_SENSE description emulation not"
121632a8811fSPaolo Bonzini " supported\n");
121732a8811fSPaolo Bonzini return TCM_INVALID_CDB_FIELD;
12181fd032eeSChristoph Hellwig }
12191fd032eeSChristoph Hellwig
12201fd032eeSChristoph Hellwig rbuf = transport_kmap_data_sg(cmd);
12211fd032eeSChristoph Hellwig if (!rbuf)
1222de103c93SChristoph Hellwig return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
12231fd032eeSChristoph Hellwig
12241fd032eeSChristoph Hellwig if (!core_scsi3_ua_clear_for_request_sense(cmd, &ua_asc, &ua_ascq))
122532a8811fSPaolo Bonzini scsi_build_sense_buffer(desc_format, buf, UNIT_ATTENTION,
1226de103c93SChristoph Hellwig ua_asc, ua_ascq);
1227de103c93SChristoph Hellwig else
1228de103c93SChristoph Hellwig scsi_build_sense_buffer(desc_format, buf, NO_SENSE, 0x0, 0x0);
12299ec1e1ceSSagi Grimberg
12304e4937e8SSagi Grimberg memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
12319ec1e1ceSSagi Grimberg transport_kunmap_data_sg(cmd);
12329ec1e1ceSSagi Grimberg
12334e4937e8SSagi Grimberg target_complete_cmd(cmd, SAM_STAT_GOOD);
12341fd032eeSChristoph Hellwig return 0;
123532a8811fSPaolo Bonzini }
12361fd032eeSChristoph Hellwig
spc_emulate_report_luns(struct se_cmd * cmd)123732a8811fSPaolo Bonzini sense_reason_t spc_emulate_report_luns(struct se_cmd *cmd)
123814b40c1eSHannes Reinecke {
12391fd032eeSChristoph Hellwig struct se_dev_entry *deve;
12401fd032eeSChristoph Hellwig struct se_session *sess = cmd->se_sess;
12411fd032eeSChristoph Hellwig struct se_node_acl *nacl;
1242de103c93SChristoph Hellwig struct scsi_lun slun;
1243d1b1f805SChristoph Hellwig unsigned char *buf;
1244d1b1f805SChristoph Hellwig u32 lun_count = 0, offset = 8;
1245d1b1f805SChristoph Hellwig __be32 len;
124629a05deeSNicholas Bellinger
12470f69a387SRoland Dreier buf = transport_kmap_data_sg(cmd);
1248d1b1f805SChristoph Hellwig if (cmd->data_length && !buf)
124929a05deeSNicholas Bellinger return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
12500f69a387SRoland Dreier
1251d1b1f805SChristoph Hellwig /*
1252d1b1f805SChristoph Hellwig * If no struct se_session pointer is present, this struct se_cmd is
12530f69a387SRoland Dreier * coming via a target_core_mod PASSTHROUGH op, and not through
1254de103c93SChristoph Hellwig * a $FABRIC_MOD. In that case, report LUN=0 only.
1255d1b1f805SChristoph Hellwig */
1256d1b1f805SChristoph Hellwig if (!sess)
1257d1b1f805SChristoph Hellwig goto done;
1258d1b1f805SChristoph Hellwig
1259d1b1f805SChristoph Hellwig nacl = sess->se_node_acl;
1260d1b1f805SChristoph Hellwig
12619c395170SRoland Dreier rcu_read_lock();
1262d1b1f805SChristoph Hellwig hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) {
12639c395170SRoland Dreier /*
126429a05deeSNicholas Bellinger * We determine the correct LUN LIST LENGTH even once we
1265d1b1f805SChristoph Hellwig * have reached the initial allocation length.
126629a05deeSNicholas Bellinger * See SPC2-R20 7.19.
126729a05deeSNicholas Bellinger */
1268d1b1f805SChristoph Hellwig lun_count++;
1269d1b1f805SChristoph Hellwig if (offset >= cmd->data_length)
1270d1b1f805SChristoph Hellwig continue;
1271d1b1f805SChristoph Hellwig
1272d1b1f805SChristoph Hellwig int_to_scsilun(deve->mapped_lun, &slun);
1273d1b1f805SChristoph Hellwig memcpy(buf + offset, &slun,
12740f69a387SRoland Dreier min(8u, cmd->data_length - offset));
1275d1b1f805SChristoph Hellwig offset += 8;
1276d1b1f805SChristoph Hellwig }
12770f69a387SRoland Dreier rcu_read_unlock();
12780f69a387SRoland Dreier
12790f69a387SRoland Dreier /*
1280d1b1f805SChristoph Hellwig * See SPC3 r07, page 159.
1281d1b1f805SChristoph Hellwig */
128229a05deeSNicholas Bellinger done:
1283d1b1f805SChristoph Hellwig /*
1284d1b1f805SChristoph Hellwig * If no LUNs are accessible, report virtual LUN 0.
1285d1b1f805SChristoph Hellwig */
1286d1b1f805SChristoph Hellwig if (lun_count == 0) {
1287d1b1f805SChristoph Hellwig int_to_scsilun(0, &slun);
12889c395170SRoland Dreier if (cmd->data_length > 8)
12899c395170SRoland Dreier memcpy(buf + offset, &slun,
12909c395170SRoland Dreier min(8u, cmd->data_length - offset));
12919c395170SRoland Dreier lun_count = 1;
12920f69a387SRoland Dreier }
12930f69a387SRoland Dreier
12940f69a387SRoland Dreier if (buf) {
12950f69a387SRoland Dreier len = cpu_to_be32(lun_count * 8);
12969c395170SRoland Dreier memcpy(buf, &len, min_t(int, sizeof len, cmd->data_length));
12979c395170SRoland Dreier transport_kunmap_data_sg(cmd);
12989c395170SRoland Dreier }
12990f69a387SRoland Dreier
13000f69a387SRoland Dreier target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, 8 + lun_count * 8);
13010f69a387SRoland Dreier return 0;
1302d1b1f805SChristoph Hellwig }
13030f69a387SRoland Dreier EXPORT_SYMBOL(spc_emulate_report_luns);
1304d1b1f805SChristoph Hellwig
130514b40c1eSHannes Reinecke static sense_reason_t
spc_emulate_testunitready(struct se_cmd * cmd)1306d1b1f805SChristoph Hellwig spc_emulate_testunitready(struct se_cmd *cmd)
1307d1b1f805SChristoph Hellwig {
13088de530a5SChristoph Hellwig target_complete_cmd(cmd, SAM_STAT_GOOD);
1309d1b1f805SChristoph Hellwig return 0;
1310de103c93SChristoph Hellwig }
1311de103c93SChristoph Hellwig
set_dpofua_usage_bits(u8 * usage_bits,struct se_device * dev)13121fd032eeSChristoph Hellwig static void set_dpofua_usage_bits(u8 *usage_bits, struct se_device *dev)
131314b40c1eSHannes Reinecke {
13141fd032eeSChristoph Hellwig if (!target_check_fua(dev))
13151fd032eeSChristoph Hellwig usage_bits[1] &= ~0x18;
13161fd032eeSChristoph Hellwig else
1317415d82b4SDmitry Bogdanov usage_bits[1] |= 0x18;
1318415d82b4SDmitry Bogdanov }
1319415d82b4SDmitry Bogdanov
set_dpofua_usage_bits32(u8 * usage_bits,struct se_device * dev)1320415d82b4SDmitry Bogdanov static void set_dpofua_usage_bits32(u8 *usage_bits, struct se_device *dev)
1321415d82b4SDmitry Bogdanov {
1322415d82b4SDmitry Bogdanov if (!target_check_fua(dev))
1323415d82b4SDmitry Bogdanov usage_bits[10] &= ~0x18;
1324415d82b4SDmitry Bogdanov else
1325415d82b4SDmitry Bogdanov usage_bits[10] |= 0x18;
1326415d82b4SDmitry Bogdanov }
1327415d82b4SDmitry Bogdanov
1328415d82b4SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_read6 = {
1329415d82b4SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1330415d82b4SDmitry Bogdanov .opcode = READ_6,
1331415d82b4SDmitry Bogdanov .cdb_size = 6,
1332415d82b4SDmitry Bogdanov .usage_bits = {READ_6, 0x1f, 0xff, 0xff,
13330016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
13340016e820SDmitry Bogdanov };
13350016e820SDmitry Bogdanov
13360016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_read10 = {
13370016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
13380016e820SDmitry Bogdanov .opcode = READ_10,
13390016e820SDmitry Bogdanov .cdb_size = 10,
13400016e820SDmitry Bogdanov .usage_bits = {READ_10, 0xf8, 0xff, 0xff,
13410016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, 0xff,
13420016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
13430016e820SDmitry Bogdanov .update_usage_bits = set_dpofua_usage_bits,
13440016e820SDmitry Bogdanov };
13450016e820SDmitry Bogdanov
13460016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_read12 = {
13470016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1348415d82b4SDmitry Bogdanov .opcode = READ_12,
13490016e820SDmitry Bogdanov .cdb_size = 12,
13500016e820SDmitry Bogdanov .usage_bits = {READ_12, 0xf8, 0xff, 0xff,
13510016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
13520016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
13530016e820SDmitry Bogdanov .update_usage_bits = set_dpofua_usage_bits,
13540016e820SDmitry Bogdanov };
13550016e820SDmitry Bogdanov
13560016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_read16 = {
13570016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1358415d82b4SDmitry Bogdanov .opcode = READ_16,
13590016e820SDmitry Bogdanov .cdb_size = 16,
13600016e820SDmitry Bogdanov .usage_bits = {READ_16, 0xf8, 0xff, 0xff,
13610016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
13620016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
13630016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
13640016e820SDmitry Bogdanov .update_usage_bits = set_dpofua_usage_bits,
13650016e820SDmitry Bogdanov };
13660016e820SDmitry Bogdanov
13670016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_write6 = {
13680016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1369415d82b4SDmitry Bogdanov .opcode = WRITE_6,
13700016e820SDmitry Bogdanov .cdb_size = 6,
13710016e820SDmitry Bogdanov .usage_bits = {WRITE_6, 0x1f, 0xff, 0xff,
13720016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
13730016e820SDmitry Bogdanov };
13740016e820SDmitry Bogdanov
13750016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_write10 = {
13760016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
13770016e820SDmitry Bogdanov .opcode = WRITE_10,
13780016e820SDmitry Bogdanov .cdb_size = 10,
13790016e820SDmitry Bogdanov .usage_bits = {WRITE_10, 0xf8, 0xff, 0xff,
13800016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, 0xff,
13810016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
13820016e820SDmitry Bogdanov .update_usage_bits = set_dpofua_usage_bits,
13830016e820SDmitry Bogdanov };
13840016e820SDmitry Bogdanov
13850016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_write_verify10 = {
13860016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1387415d82b4SDmitry Bogdanov .opcode = WRITE_VERIFY,
13880016e820SDmitry Bogdanov .cdb_size = 10,
13890016e820SDmitry Bogdanov .usage_bits = {WRITE_VERIFY, 0xf0, 0xff, 0xff,
13900016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, 0xff,
13910016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
13920016e820SDmitry Bogdanov .update_usage_bits = set_dpofua_usage_bits,
13930016e820SDmitry Bogdanov };
13940016e820SDmitry Bogdanov
13950016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_write12 = {
13960016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1397415d82b4SDmitry Bogdanov .opcode = WRITE_12,
13980016e820SDmitry Bogdanov .cdb_size = 12,
13990016e820SDmitry Bogdanov .usage_bits = {WRITE_12, 0xf8, 0xff, 0xff,
14000016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
14010016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
14020016e820SDmitry Bogdanov .update_usage_bits = set_dpofua_usage_bits,
14030016e820SDmitry Bogdanov };
14040016e820SDmitry Bogdanov
14050016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_write16 = {
14060016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1407415d82b4SDmitry Bogdanov .opcode = WRITE_16,
14080016e820SDmitry Bogdanov .cdb_size = 16,
14090016e820SDmitry Bogdanov .usage_bits = {WRITE_16, 0xf8, 0xff, 0xff,
14100016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
14110016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
14120016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
14130016e820SDmitry Bogdanov .update_usage_bits = set_dpofua_usage_bits,
14140016e820SDmitry Bogdanov };
14150016e820SDmitry Bogdanov
14160016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_write_verify16 = {
14170016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1418415d82b4SDmitry Bogdanov .opcode = WRITE_VERIFY_16,
14190016e820SDmitry Bogdanov .cdb_size = 16,
14200016e820SDmitry Bogdanov .usage_bits = {WRITE_VERIFY_16, 0xf0, 0xff, 0xff,
14210016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
14220016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
14230016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
14240016e820SDmitry Bogdanov .update_usage_bits = set_dpofua_usage_bits,
14250016e820SDmitry Bogdanov };
14260016e820SDmitry Bogdanov
tcm_is_ws_enabled(struct target_opcode_descriptor * descr,struct se_cmd * cmd)14270016e820SDmitry Bogdanov static bool tcm_is_ws_enabled(struct target_opcode_descriptor *descr,
14280016e820SDmitry Bogdanov struct se_cmd *cmd)
1429415d82b4SDmitry Bogdanov {
14300016e820SDmitry Bogdanov struct exec_cmd_ops *ops = cmd->protocol_data;
14310016e820SDmitry Bogdanov struct se_device *dev = cmd->se_dev;
1432d9b3275bSMike Christie
1433d9b3275bSMike Christie return (dev->dev_attrib.emulate_tpws && !!ops->execute_unmap) ||
1434553b08d9SDmitry Bogdanov !!ops->execute_write_same;
14350217da08SMike Christie }
1436553b08d9SDmitry Bogdanov
1437553b08d9SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_write_same32 = {
1438553b08d9SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1439553b08d9SDmitry Bogdanov .serv_action_valid = 1,
1440553b08d9SDmitry Bogdanov .opcode = VARIABLE_LENGTH_CMD,
1441553b08d9SDmitry Bogdanov .service_action = WRITE_SAME_32,
14420016e820SDmitry Bogdanov .cdb_size = 32,
14430016e820SDmitry Bogdanov .usage_bits = {VARIABLE_LENGTH_CMD, SCSI_CONTROL_MASK, 0x00, 0x00,
14440016e820SDmitry Bogdanov 0x00, 0x00, SCSI_GROUP_NUMBER_MASK, 0x18,
14450016e820SDmitry Bogdanov 0x00, WRITE_SAME_32, 0xe8, 0x00,
14460016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
14470016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
14480016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0x00,
14490016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0x00,
14500016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff},
14510016e820SDmitry Bogdanov .enabled = tcm_is_ws_enabled,
14520016e820SDmitry Bogdanov .update_usage_bits = set_dpofua_usage_bits32,
14530016e820SDmitry Bogdanov };
14540016e820SDmitry Bogdanov
tcm_is_caw_enabled(struct target_opcode_descriptor * descr,struct se_cmd * cmd)14550016e820SDmitry Bogdanov static bool tcm_is_caw_enabled(struct target_opcode_descriptor *descr,
1456553b08d9SDmitry Bogdanov struct se_cmd *cmd)
1457415d82b4SDmitry Bogdanov {
14580016e820SDmitry Bogdanov struct se_device *dev = cmd->se_dev;
14590016e820SDmitry Bogdanov
1460d9b3275bSMike Christie return dev->dev_attrib.emulate_caw;
1461d9b3275bSMike Christie }
1462553b08d9SDmitry Bogdanov
1463553b08d9SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_compare_write = {
1464553b08d9SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1465553b08d9SDmitry Bogdanov .opcode = COMPARE_AND_WRITE,
1466553b08d9SDmitry Bogdanov .cdb_size = 16,
1467553b08d9SDmitry Bogdanov .usage_bits = {COMPARE_AND_WRITE, 0x18, 0xff, 0xff,
14680016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
14690016e820SDmitry Bogdanov 0xff, 0xff, 0x00, 0x00,
14700016e820SDmitry Bogdanov 0x00, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
14710016e820SDmitry Bogdanov .enabled = tcm_is_caw_enabled,
14720016e820SDmitry Bogdanov .update_usage_bits = set_dpofua_usage_bits,
14730016e820SDmitry Bogdanov };
14740016e820SDmitry Bogdanov
14750016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_read_capacity = {
1476553b08d9SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1477415d82b4SDmitry Bogdanov .opcode = READ_CAPACITY,
14780016e820SDmitry Bogdanov .cdb_size = 10,
14790016e820SDmitry Bogdanov .usage_bits = {READ_CAPACITY, 0x00, 0xff, 0xff,
14800016e820SDmitry Bogdanov 0xff, 0xff, 0x00, 0x00,
14810016e820SDmitry Bogdanov 0x01, SCSI_CONTROL_MASK},
14820016e820SDmitry Bogdanov };
14830016e820SDmitry Bogdanov
14840016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_read_capacity16 = {
14850016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
14860016e820SDmitry Bogdanov .serv_action_valid = 1,
14870016e820SDmitry Bogdanov .opcode = SERVICE_ACTION_IN_16,
14880016e820SDmitry Bogdanov .service_action = SAI_READ_CAPACITY_16,
14890016e820SDmitry Bogdanov .cdb_size = 16,
14900016e820SDmitry Bogdanov .usage_bits = {SERVICE_ACTION_IN_16, SAI_READ_CAPACITY_16, 0x00, 0x00,
14910016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0x00,
14920016e820SDmitry Bogdanov 0x00, 0x00, 0xff, 0xff,
14930016e820SDmitry Bogdanov 0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
14940016e820SDmitry Bogdanov };
14950016e820SDmitry Bogdanov
tcm_is_rep_ref_enabled(struct target_opcode_descriptor * descr,struct se_cmd * cmd)14960016e820SDmitry Bogdanov static bool tcm_is_rep_ref_enabled(struct target_opcode_descriptor *descr,
14970016e820SDmitry Bogdanov struct se_cmd *cmd)
14980016e820SDmitry Bogdanov {
14990016e820SDmitry Bogdanov struct se_device *dev = cmd->se_dev;
15000016e820SDmitry Bogdanov
1501d9b3275bSMike Christie spin_lock(&dev->t10_alua.lba_map_lock);
1502d9b3275bSMike Christie if (list_empty(&dev->t10_alua.lba_map_list)) {
1503553b08d9SDmitry Bogdanov spin_unlock(&dev->t10_alua.lba_map_lock);
1504553b08d9SDmitry Bogdanov return false;
1505553b08d9SDmitry Bogdanov }
1506553b08d9SDmitry Bogdanov spin_unlock(&dev->t10_alua.lba_map_lock);
1507553b08d9SDmitry Bogdanov return true;
1508553b08d9SDmitry Bogdanov }
1509553b08d9SDmitry Bogdanov
1510553b08d9SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_read_report_refferals = {
1511553b08d9SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1512553b08d9SDmitry Bogdanov .serv_action_valid = 1,
1513553b08d9SDmitry Bogdanov .opcode = SERVICE_ACTION_IN_16,
1514553b08d9SDmitry Bogdanov .service_action = SAI_REPORT_REFERRALS,
15150016e820SDmitry Bogdanov .cdb_size = 16,
15160016e820SDmitry Bogdanov .usage_bits = {SERVICE_ACTION_IN_16, SAI_REPORT_REFERRALS, 0x00, 0x00,
15170016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0x00,
15180016e820SDmitry Bogdanov 0x00, 0x00, 0xff, 0xff,
15190016e820SDmitry Bogdanov 0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
15200016e820SDmitry Bogdanov .enabled = tcm_is_rep_ref_enabled,
15210016e820SDmitry Bogdanov };
15220016e820SDmitry Bogdanov
15230016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_sync_cache = {
15240016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1525553b08d9SDmitry Bogdanov .opcode = SYNCHRONIZE_CACHE,
15260016e820SDmitry Bogdanov .cdb_size = 10,
15270016e820SDmitry Bogdanov .usage_bits = {SYNCHRONIZE_CACHE, 0x02, 0xff, 0xff,
15280016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, 0xff,
15290016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
15300016e820SDmitry Bogdanov };
15310016e820SDmitry Bogdanov
15320016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_sync_cache16 = {
15330016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
15340016e820SDmitry Bogdanov .opcode = SYNCHRONIZE_CACHE_16,
15350016e820SDmitry Bogdanov .cdb_size = 16,
15360016e820SDmitry Bogdanov .usage_bits = {SYNCHRONIZE_CACHE_16, 0x02, 0xff, 0xff,
15370016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
15380016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
15390016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
15400016e820SDmitry Bogdanov };
15410016e820SDmitry Bogdanov
tcm_is_unmap_enabled(struct target_opcode_descriptor * descr,struct se_cmd * cmd)15420016e820SDmitry Bogdanov static bool tcm_is_unmap_enabled(struct target_opcode_descriptor *descr,
15430016e820SDmitry Bogdanov struct se_cmd *cmd)
15440016e820SDmitry Bogdanov {
15450016e820SDmitry Bogdanov struct exec_cmd_ops *ops = cmd->protocol_data;
15460016e820SDmitry Bogdanov struct se_device *dev = cmd->se_dev;
1547d9b3275bSMike Christie
1548d9b3275bSMike Christie return ops->execute_unmap && dev->dev_attrib.emulate_tpu;
1549553b08d9SDmitry Bogdanov }
15500217da08SMike Christie
1551553b08d9SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_unmap = {
1552553b08d9SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1553553b08d9SDmitry Bogdanov .opcode = UNMAP,
1554553b08d9SDmitry Bogdanov .cdb_size = 10,
1555553b08d9SDmitry Bogdanov .usage_bits = {UNMAP, 0x00, 0x00, 0x00,
15560016e820SDmitry Bogdanov 0x00, 0x00, SCSI_GROUP_NUMBER_MASK, 0xff,
15570016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
15580016e820SDmitry Bogdanov .enabled = tcm_is_unmap_enabled,
15590016e820SDmitry Bogdanov };
15600016e820SDmitry Bogdanov
15610016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_write_same = {
15620016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1563553b08d9SDmitry Bogdanov .opcode = WRITE_SAME,
15640016e820SDmitry Bogdanov .cdb_size = 10,
15650016e820SDmitry Bogdanov .usage_bits = {WRITE_SAME, 0xe8, 0xff, 0xff,
15660016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, 0xff,
15670016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
15680016e820SDmitry Bogdanov .enabled = tcm_is_ws_enabled,
15690016e820SDmitry Bogdanov };
15700016e820SDmitry Bogdanov
15710016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_write_same16 = {
15720016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1573553b08d9SDmitry Bogdanov .opcode = WRITE_SAME_16,
15740016e820SDmitry Bogdanov .cdb_size = 16,
15750016e820SDmitry Bogdanov .usage_bits = {WRITE_SAME_16, 0xe8, 0xff, 0xff,
15760016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
15770016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
15780016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
15790016e820SDmitry Bogdanov .enabled = tcm_is_ws_enabled,
15800016e820SDmitry Bogdanov };
15810016e820SDmitry Bogdanov
15820016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_verify = {
15830016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1584553b08d9SDmitry Bogdanov .opcode = VERIFY,
15850016e820SDmitry Bogdanov .cdb_size = 10,
15860016e820SDmitry Bogdanov .usage_bits = {VERIFY, 0x00, 0xff, 0xff,
15870016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, 0xff,
15880016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
15890016e820SDmitry Bogdanov };
15900016e820SDmitry Bogdanov
15910016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_verify16 = {
15920016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
15930016e820SDmitry Bogdanov .opcode = VERIFY_16,
15940016e820SDmitry Bogdanov .cdb_size = 16,
15950016e820SDmitry Bogdanov .usage_bits = {VERIFY_16, 0x00, 0xff, 0xff,
15960016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
15970016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
15980016e820SDmitry Bogdanov 0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
15990016e820SDmitry Bogdanov };
16000016e820SDmitry Bogdanov
16010016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_start_stop = {
16020016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
16030016e820SDmitry Bogdanov .opcode = START_STOP,
16040016e820SDmitry Bogdanov .cdb_size = 6,
16050016e820SDmitry Bogdanov .usage_bits = {START_STOP, 0x01, 0x00, 0x00,
16060016e820SDmitry Bogdanov 0x01, SCSI_CONTROL_MASK},
16070016e820SDmitry Bogdanov };
16080016e820SDmitry Bogdanov
16090016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_mode_select = {
16100016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
16110016e820SDmitry Bogdanov .opcode = MODE_SELECT,
16120016e820SDmitry Bogdanov .cdb_size = 6,
16130016e820SDmitry Bogdanov .usage_bits = {MODE_SELECT, 0x10, 0x00, 0x00,
16140016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
16150016e820SDmitry Bogdanov };
16160016e820SDmitry Bogdanov
16170016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_mode_select10 = {
16180016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
16190016e820SDmitry Bogdanov .opcode = MODE_SELECT_10,
16200016e820SDmitry Bogdanov .cdb_size = 10,
16210016e820SDmitry Bogdanov .usage_bits = {MODE_SELECT_10, 0x10, 0x00, 0x00,
16220016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0xff,
16230016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
16240016e820SDmitry Bogdanov };
16250016e820SDmitry Bogdanov
16260016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_mode_sense = {
16270016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
16280016e820SDmitry Bogdanov .opcode = MODE_SENSE,
16290016e820SDmitry Bogdanov .cdb_size = 6,
16300016e820SDmitry Bogdanov .usage_bits = {MODE_SENSE, 0x08, 0xff, 0xff,
16310016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
16320016e820SDmitry Bogdanov };
16330016e820SDmitry Bogdanov
16340016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_mode_sense10 = {
16350016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
16360016e820SDmitry Bogdanov .opcode = MODE_SENSE_10,
16370016e820SDmitry Bogdanov .cdb_size = 10,
16380016e820SDmitry Bogdanov .usage_bits = {MODE_SENSE_10, 0x18, 0xff, 0xff,
16390016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0xff,
16400016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
16410016e820SDmitry Bogdanov };
16420016e820SDmitry Bogdanov
16430016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_pri_read_keys = {
16440016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
16450016e820SDmitry Bogdanov .serv_action_valid = 1,
16460016e820SDmitry Bogdanov .opcode = PERSISTENT_RESERVE_IN,
16470016e820SDmitry Bogdanov .service_action = PRI_READ_KEYS,
16480016e820SDmitry Bogdanov .cdb_size = 10,
16490016e820SDmitry Bogdanov .usage_bits = {PERSISTENT_RESERVE_IN, PRI_READ_KEYS, 0x00, 0x00,
16500016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0xff,
16510016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
16520016e820SDmitry Bogdanov };
16530016e820SDmitry Bogdanov
16540016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_pri_read_resrv = {
16550016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
16560016e820SDmitry Bogdanov .serv_action_valid = 1,
16570016e820SDmitry Bogdanov .opcode = PERSISTENT_RESERVE_IN,
16580016e820SDmitry Bogdanov .service_action = PRI_READ_RESERVATION,
16590016e820SDmitry Bogdanov .cdb_size = 10,
16600016e820SDmitry Bogdanov .usage_bits = {PERSISTENT_RESERVE_IN, PRI_READ_RESERVATION, 0x00, 0x00,
16610016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0xff,
16620016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
16630016e820SDmitry Bogdanov };
16640016e820SDmitry Bogdanov
tcm_is_pr_enabled(struct target_opcode_descriptor * descr,struct se_cmd * cmd)16650016e820SDmitry Bogdanov static bool tcm_is_pr_enabled(struct target_opcode_descriptor *descr,
16660016e820SDmitry Bogdanov struct se_cmd *cmd)
16670016e820SDmitry Bogdanov {
16680016e820SDmitry Bogdanov struct se_device *dev = cmd->se_dev;
16690016e820SDmitry Bogdanov
1670d9b3275bSMike Christie if (!dev->dev_attrib.emulate_pr)
1671d9b3275bSMike Christie return false;
1672553b08d9SDmitry Bogdanov
1673553b08d9SDmitry Bogdanov if (!(dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR))
1674553b08d9SDmitry Bogdanov return true;
1675*8455799dSMike Christie
1676*8455799dSMike Christie switch (descr->opcode) {
1677*8455799dSMike Christie case RESERVE:
1678*8455799dSMike Christie case RESERVE_10:
1679*8455799dSMike Christie case RELEASE:
1680*8455799dSMike Christie case RELEASE_10:
1681*8455799dSMike Christie /*
1682*8455799dSMike Christie * The pr_ops which are used by the backend modules don't
1683*8455799dSMike Christie * support these commands.
1684*8455799dSMike Christie */
1685*8455799dSMike Christie return false;
1686*8455799dSMike Christie case PERSISTENT_RESERVE_OUT:
1687*8455799dSMike Christie switch (descr->service_action) {
1688*8455799dSMike Christie case PRO_REGISTER_AND_MOVE:
1689*8455799dSMike Christie case PRO_REPLACE_LOST_RESERVATION:
1690*8455799dSMike Christie /*
1691*8455799dSMike Christie * The backend modules don't have access to ports and
1692*8455799dSMike Christie * I_T nexuses so they can't handle these type of
1693*8455799dSMike Christie * requests.
1694*8455799dSMike Christie */
1695*8455799dSMike Christie return false;
1696*8455799dSMike Christie }
1697*8455799dSMike Christie break;
1698*8455799dSMike Christie case PERSISTENT_RESERVE_IN:
1699*8455799dSMike Christie if (descr->service_action == PRI_READ_FULL_STATUS)
1700*8455799dSMike Christie return false;
1701*8455799dSMike Christie break;
1702*8455799dSMike Christie }
1703*8455799dSMike Christie
1704*8455799dSMike Christie return true;
1705*8455799dSMike Christie }
1706*8455799dSMike Christie
1707*8455799dSMike Christie static struct target_opcode_descriptor tcm_opcode_pri_read_caps = {
1708*8455799dSMike Christie .support = SCSI_SUPPORT_FULL,
1709*8455799dSMike Christie .serv_action_valid = 1,
1710553b08d9SDmitry Bogdanov .opcode = PERSISTENT_RESERVE_IN,
1711553b08d9SDmitry Bogdanov .service_action = PRI_REPORT_CAPABILITIES,
17120016e820SDmitry Bogdanov .cdb_size = 10,
17130016e820SDmitry Bogdanov .usage_bits = {PERSISTENT_RESERVE_IN, PRI_REPORT_CAPABILITIES, 0x00, 0x00,
17140016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0xff,
17150016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
17160016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
17170016e820SDmitry Bogdanov };
17180016e820SDmitry Bogdanov
17190016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_pri_read_full_status = {
17200016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1721553b08d9SDmitry Bogdanov .serv_action_valid = 1,
17220016e820SDmitry Bogdanov .opcode = PERSISTENT_RESERVE_IN,
17230016e820SDmitry Bogdanov .service_action = PRI_READ_FULL_STATUS,
17240016e820SDmitry Bogdanov .cdb_size = 10,
17250016e820SDmitry Bogdanov .usage_bits = {PERSISTENT_RESERVE_IN, PRI_READ_FULL_STATUS, 0x00, 0x00,
17260016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0xff,
17270016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
17280016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
17290016e820SDmitry Bogdanov };
17300016e820SDmitry Bogdanov
17310016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_pro_register = {
17320016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1733553b08d9SDmitry Bogdanov .serv_action_valid = 1,
17340016e820SDmitry Bogdanov .opcode = PERSISTENT_RESERVE_OUT,
17350016e820SDmitry Bogdanov .service_action = PRO_REGISTER,
17360016e820SDmitry Bogdanov .cdb_size = 10,
17370016e820SDmitry Bogdanov .usage_bits = {PERSISTENT_RESERVE_OUT, PRO_REGISTER, 0xff, 0x00,
17380016e820SDmitry Bogdanov 0x00, 0xff, 0xff, 0xff,
17390016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
17400016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
17410016e820SDmitry Bogdanov };
17420016e820SDmitry Bogdanov
17430016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_pro_reserve = {
17440016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1745553b08d9SDmitry Bogdanov .serv_action_valid = 1,
17460016e820SDmitry Bogdanov .opcode = PERSISTENT_RESERVE_OUT,
17470016e820SDmitry Bogdanov .service_action = PRO_RESERVE,
17480016e820SDmitry Bogdanov .cdb_size = 10,
17490016e820SDmitry Bogdanov .usage_bits = {PERSISTENT_RESERVE_OUT, PRO_RESERVE, 0xff, 0x00,
17500016e820SDmitry Bogdanov 0x00, 0xff, 0xff, 0xff,
17510016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
17520016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
17530016e820SDmitry Bogdanov };
17540016e820SDmitry Bogdanov
17550016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_pro_release = {
17560016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1757553b08d9SDmitry Bogdanov .serv_action_valid = 1,
17580016e820SDmitry Bogdanov .opcode = PERSISTENT_RESERVE_OUT,
17590016e820SDmitry Bogdanov .service_action = PRO_RELEASE,
17600016e820SDmitry Bogdanov .cdb_size = 10,
17610016e820SDmitry Bogdanov .usage_bits = {PERSISTENT_RESERVE_OUT, PRO_RELEASE, 0xff, 0x00,
17620016e820SDmitry Bogdanov 0x00, 0xff, 0xff, 0xff,
17630016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
17640016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
17650016e820SDmitry Bogdanov };
17660016e820SDmitry Bogdanov
17670016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_pro_clear = {
17680016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1769553b08d9SDmitry Bogdanov .serv_action_valid = 1,
17700016e820SDmitry Bogdanov .opcode = PERSISTENT_RESERVE_OUT,
17710016e820SDmitry Bogdanov .service_action = PRO_CLEAR,
17720016e820SDmitry Bogdanov .cdb_size = 10,
17730016e820SDmitry Bogdanov .usage_bits = {PERSISTENT_RESERVE_OUT, PRO_CLEAR, 0xff, 0x00,
17740016e820SDmitry Bogdanov 0x00, 0xff, 0xff, 0xff,
17750016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
17760016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
17770016e820SDmitry Bogdanov };
17780016e820SDmitry Bogdanov
17790016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_pro_preempt = {
17800016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1781553b08d9SDmitry Bogdanov .serv_action_valid = 1,
17820016e820SDmitry Bogdanov .opcode = PERSISTENT_RESERVE_OUT,
17830016e820SDmitry Bogdanov .service_action = PRO_PREEMPT,
17840016e820SDmitry Bogdanov .cdb_size = 10,
17850016e820SDmitry Bogdanov .usage_bits = {PERSISTENT_RESERVE_OUT, PRO_PREEMPT, 0xff, 0x00,
17860016e820SDmitry Bogdanov 0x00, 0xff, 0xff, 0xff,
17870016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
17880016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
17890016e820SDmitry Bogdanov };
17900016e820SDmitry Bogdanov
17910016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_pro_preempt_abort = {
17920016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1793553b08d9SDmitry Bogdanov .serv_action_valid = 1,
17940016e820SDmitry Bogdanov .opcode = PERSISTENT_RESERVE_OUT,
17950016e820SDmitry Bogdanov .service_action = PRO_PREEMPT_AND_ABORT,
17960016e820SDmitry Bogdanov .cdb_size = 10,
17970016e820SDmitry Bogdanov .usage_bits = {PERSISTENT_RESERVE_OUT, PRO_PREEMPT_AND_ABORT, 0xff, 0x00,
17980016e820SDmitry Bogdanov 0x00, 0xff, 0xff, 0xff,
17990016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
18000016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
18010016e820SDmitry Bogdanov };
18020016e820SDmitry Bogdanov
18030016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_pro_reg_ign_exist = {
18040016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1805553b08d9SDmitry Bogdanov .serv_action_valid = 1,
18060016e820SDmitry Bogdanov .opcode = PERSISTENT_RESERVE_OUT,
18070016e820SDmitry Bogdanov .service_action = PRO_REGISTER_AND_IGNORE_EXISTING_KEY,
18080016e820SDmitry Bogdanov .cdb_size = 10,
18090016e820SDmitry Bogdanov .usage_bits = {
18100016e820SDmitry Bogdanov PERSISTENT_RESERVE_OUT, PRO_REGISTER_AND_IGNORE_EXISTING_KEY,
18110016e820SDmitry Bogdanov 0xff, 0x00,
18120016e820SDmitry Bogdanov 0x00, 0xff, 0xff, 0xff,
18130016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
18140016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
18150016e820SDmitry Bogdanov };
18160016e820SDmitry Bogdanov
18170016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_pro_register_move = {
18180016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1819553b08d9SDmitry Bogdanov .serv_action_valid = 1,
18200016e820SDmitry Bogdanov .opcode = PERSISTENT_RESERVE_OUT,
18210016e820SDmitry Bogdanov .service_action = PRO_REGISTER_AND_MOVE,
18220016e820SDmitry Bogdanov .cdb_size = 10,
18230016e820SDmitry Bogdanov .usage_bits = {PERSISTENT_RESERVE_OUT, PRO_REGISTER_AND_MOVE, 0xff, 0x00,
18240016e820SDmitry Bogdanov 0x00, 0xff, 0xff, 0xff,
18250016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
18260016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
18270016e820SDmitry Bogdanov };
18280016e820SDmitry Bogdanov
18290016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_release = {
18300016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1831553b08d9SDmitry Bogdanov .opcode = RELEASE,
18320016e820SDmitry Bogdanov .cdb_size = 6,
18330016e820SDmitry Bogdanov .usage_bits = {RELEASE, 0x00, 0x00, 0x00,
18340016e820SDmitry Bogdanov 0x00, SCSI_CONTROL_MASK},
18350016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
18360016e820SDmitry Bogdanov };
18370016e820SDmitry Bogdanov
18380016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_release10 = {
18390016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1840*8455799dSMike Christie .opcode = RELEASE_10,
18410016e820SDmitry Bogdanov .cdb_size = 10,
18420016e820SDmitry Bogdanov .usage_bits = {RELEASE_10, 0x00, 0x00, 0x00,
18430016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0xff,
18440016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
18450016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
18460016e820SDmitry Bogdanov };
18470016e820SDmitry Bogdanov
18480016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_reserve = {
18490016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1850*8455799dSMike Christie .opcode = RESERVE,
18510016e820SDmitry Bogdanov .cdb_size = 6,
18520016e820SDmitry Bogdanov .usage_bits = {RESERVE, 0x00, 0x00, 0x00,
18530016e820SDmitry Bogdanov 0x00, SCSI_CONTROL_MASK},
18540016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
18550016e820SDmitry Bogdanov };
18560016e820SDmitry Bogdanov
18570016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_reserve10 = {
18580016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1859*8455799dSMike Christie .opcode = RESERVE_10,
18600016e820SDmitry Bogdanov .cdb_size = 10,
18610016e820SDmitry Bogdanov .usage_bits = {RESERVE_10, 0x00, 0x00, 0x00,
18620016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0xff,
18630016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
18640016e820SDmitry Bogdanov .enabled = tcm_is_pr_enabled,
18650016e820SDmitry Bogdanov };
18660016e820SDmitry Bogdanov
18670016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_request_sense = {
18680016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1869*8455799dSMike Christie .opcode = REQUEST_SENSE,
18700016e820SDmitry Bogdanov .cdb_size = 6,
18710016e820SDmitry Bogdanov .usage_bits = {REQUEST_SENSE, 0x00, 0x00, 0x00,
18720016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
18730016e820SDmitry Bogdanov };
18740016e820SDmitry Bogdanov
18750016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_inquiry = {
18760016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
18770016e820SDmitry Bogdanov .opcode = INQUIRY,
18780016e820SDmitry Bogdanov .cdb_size = 6,
18790016e820SDmitry Bogdanov .usage_bits = {INQUIRY, 0x01, 0xff, 0xff,
18800016e820SDmitry Bogdanov 0xff, SCSI_CONTROL_MASK},
18810016e820SDmitry Bogdanov };
18820016e820SDmitry Bogdanov
tcm_is_3pc_enabled(struct target_opcode_descriptor * descr,struct se_cmd * cmd)18830016e820SDmitry Bogdanov static bool tcm_is_3pc_enabled(struct target_opcode_descriptor *descr,
18840016e820SDmitry Bogdanov struct se_cmd *cmd)
18850016e820SDmitry Bogdanov {
18860016e820SDmitry Bogdanov struct se_device *dev = cmd->se_dev;
18870016e820SDmitry Bogdanov
1888d9b3275bSMike Christie return dev->dev_attrib.emulate_3pc;
1889d9b3275bSMike Christie }
1890553b08d9SDmitry Bogdanov
1891553b08d9SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_extended_copy_lid1 = {
1892553b08d9SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1893553b08d9SDmitry Bogdanov .serv_action_valid = 1,
1894553b08d9SDmitry Bogdanov .opcode = EXTENDED_COPY,
1895553b08d9SDmitry Bogdanov .cdb_size = 16,
18960016e820SDmitry Bogdanov .usage_bits = {EXTENDED_COPY, 0x00, 0x00, 0x00,
18970016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0x00,
18980016e820SDmitry Bogdanov 0x00, 0x00, 0xff, 0xff,
18990016e820SDmitry Bogdanov 0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
19000016e820SDmitry Bogdanov .enabled = tcm_is_3pc_enabled,
19010016e820SDmitry Bogdanov };
19020016e820SDmitry Bogdanov
19030016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_rcv_copy_res_op_params = {
19040016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1905553b08d9SDmitry Bogdanov .serv_action_valid = 1,
19060016e820SDmitry Bogdanov .opcode = RECEIVE_COPY_RESULTS,
19070016e820SDmitry Bogdanov .service_action = RCR_SA_OPERATING_PARAMETERS,
19080016e820SDmitry Bogdanov .cdb_size = 16,
19090016e820SDmitry Bogdanov .usage_bits = {RECEIVE_COPY_RESULTS, RCR_SA_OPERATING_PARAMETERS,
19100016e820SDmitry Bogdanov 0x00, 0x00,
19110016e820SDmitry Bogdanov 0x00, 0x00, 0x00, 0x00,
19120016e820SDmitry Bogdanov 0x00, 0x00, 0xff, 0xff,
19130016e820SDmitry Bogdanov 0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
19140016e820SDmitry Bogdanov .enabled = tcm_is_3pc_enabled,
19150016e820SDmitry Bogdanov };
19160016e820SDmitry Bogdanov
19170016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_report_luns = {
19180016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1919553b08d9SDmitry Bogdanov .opcode = REPORT_LUNS,
19200016e820SDmitry Bogdanov .cdb_size = 12,
19210016e820SDmitry Bogdanov .usage_bits = {REPORT_LUNS, 0x00, 0xff, 0x00,
19220016e820SDmitry Bogdanov 0x00, 0x00, 0xff, 0xff,
19230016e820SDmitry Bogdanov 0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
19240016e820SDmitry Bogdanov };
19250016e820SDmitry Bogdanov
19260016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_test_unit_ready = {
19270016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
19280016e820SDmitry Bogdanov .opcode = TEST_UNIT_READY,
19290016e820SDmitry Bogdanov .cdb_size = 6,
19300016e820SDmitry Bogdanov .usage_bits = {TEST_UNIT_READY, 0x00, 0x00, 0x00,
19310016e820SDmitry Bogdanov 0x00, SCSI_CONTROL_MASK},
19320016e820SDmitry Bogdanov };
19330016e820SDmitry Bogdanov
19340016e820SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_report_target_pgs = {
19350016e820SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
19360016e820SDmitry Bogdanov .serv_action_valid = 1,
19370016e820SDmitry Bogdanov .opcode = MAINTENANCE_IN,
19380016e820SDmitry Bogdanov .service_action = MI_REPORT_TARGET_PGS,
19390016e820SDmitry Bogdanov .cdb_size = 12,
19400016e820SDmitry Bogdanov .usage_bits = {MAINTENANCE_IN, 0xE0 | MI_REPORT_TARGET_PGS, 0x00, 0x00,
19410016e820SDmitry Bogdanov 0x00, 0x00, 0xff, 0xff,
19420016e820SDmitry Bogdanov 0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
19430016e820SDmitry Bogdanov };
19440016e820SDmitry Bogdanov
spc_rsoc_enabled(struct target_opcode_descriptor * descr,struct se_cmd * cmd)19450016e820SDmitry Bogdanov static bool spc_rsoc_enabled(struct target_opcode_descriptor *descr,
19460016e820SDmitry Bogdanov struct se_cmd *cmd)
19470016e820SDmitry Bogdanov {
19480016e820SDmitry Bogdanov struct se_device *dev = cmd->se_dev;
19490016e820SDmitry Bogdanov
1950d9b3275bSMike Christie return dev->dev_attrib.emulate_rsoc;
1951d9b3275bSMike Christie }
1952bd217b8cSDmitry Bogdanov
1953bd217b8cSDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_report_supp_opcodes = {
1954bd217b8cSDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1955bd217b8cSDmitry Bogdanov .serv_action_valid = 1,
1956bd217b8cSDmitry Bogdanov .opcode = MAINTENANCE_IN,
1957bd217b8cSDmitry Bogdanov .service_action = MI_REPORT_SUPPORTED_OPERATION_CODES,
19580016e820SDmitry Bogdanov .cdb_size = 12,
19590016e820SDmitry Bogdanov .usage_bits = {MAINTENANCE_IN, MI_REPORT_SUPPORTED_OPERATION_CODES,
19600016e820SDmitry Bogdanov 0x87, 0xff,
19610016e820SDmitry Bogdanov 0xff, 0xff, 0xff, 0xff,
19620016e820SDmitry Bogdanov 0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
19630016e820SDmitry Bogdanov .enabled = spc_rsoc_enabled,
19640016e820SDmitry Bogdanov };
19650016e820SDmitry Bogdanov
tcm_is_set_tpg_enabled(struct target_opcode_descriptor * descr,struct se_cmd * cmd)19660016e820SDmitry Bogdanov static bool tcm_is_set_tpg_enabled(struct target_opcode_descriptor *descr,
19670016e820SDmitry Bogdanov struct se_cmd *cmd)
1968bd217b8cSDmitry Bogdanov {
19690016e820SDmitry Bogdanov struct t10_alua_tg_pt_gp *l_tg_pt_gp;
19700016e820SDmitry Bogdanov struct se_lun *l_lun = cmd->se_lun;
1971d9b3275bSMike Christie
1972d9b3275bSMike Christie rcu_read_lock();
1973553b08d9SDmitry Bogdanov l_tg_pt_gp = rcu_dereference(l_lun->lun_tg_pt_gp);
1974553b08d9SDmitry Bogdanov if (!l_tg_pt_gp) {
1975553b08d9SDmitry Bogdanov rcu_read_unlock();
1976553b08d9SDmitry Bogdanov return false;
1977553b08d9SDmitry Bogdanov }
1978553b08d9SDmitry Bogdanov if (!(l_tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA)) {
1979553b08d9SDmitry Bogdanov rcu_read_unlock();
1980553b08d9SDmitry Bogdanov return false;
1981553b08d9SDmitry Bogdanov }
1982553b08d9SDmitry Bogdanov rcu_read_unlock();
1983553b08d9SDmitry Bogdanov
1984553b08d9SDmitry Bogdanov return true;
1985553b08d9SDmitry Bogdanov }
1986553b08d9SDmitry Bogdanov
1987553b08d9SDmitry Bogdanov static struct target_opcode_descriptor tcm_opcode_set_tpg = {
1988553b08d9SDmitry Bogdanov .support = SCSI_SUPPORT_FULL,
1989553b08d9SDmitry Bogdanov .serv_action_valid = 1,
1990553b08d9SDmitry Bogdanov .opcode = MAINTENANCE_OUT,
1991553b08d9SDmitry Bogdanov .service_action = MO_SET_TARGET_PGS,
19920016e820SDmitry Bogdanov .cdb_size = 12,
19930016e820SDmitry Bogdanov .usage_bits = {MAINTENANCE_OUT, MO_SET_TARGET_PGS, 0x00, 0x00,
19940016e820SDmitry Bogdanov 0x00, 0x00, 0xff, 0xff,
19950016e820SDmitry Bogdanov 0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
19960016e820SDmitry Bogdanov .enabled = tcm_is_set_tpg_enabled,
19970016e820SDmitry Bogdanov };
19980016e820SDmitry Bogdanov
19990016e820SDmitry Bogdanov static struct target_opcode_descriptor *tcm_supported_opcodes[] = {
20000016e820SDmitry Bogdanov &tcm_opcode_read6,
2001553b08d9SDmitry Bogdanov &tcm_opcode_read10,
20020016e820SDmitry Bogdanov &tcm_opcode_read12,
2003b9b8782fSDmitry Bogdanov &tcm_opcode_read16,
2004b9b8782fSDmitry Bogdanov &tcm_opcode_write6,
20050016e820SDmitry Bogdanov &tcm_opcode_write10,
20060016e820SDmitry Bogdanov &tcm_opcode_write_verify10,
20070016e820SDmitry Bogdanov &tcm_opcode_write12,
20080016e820SDmitry Bogdanov &tcm_opcode_write16,
20090016e820SDmitry Bogdanov &tcm_opcode_write_verify16,
20100016e820SDmitry Bogdanov &tcm_opcode_write_same32,
20110016e820SDmitry Bogdanov &tcm_opcode_compare_write,
20120016e820SDmitry Bogdanov &tcm_opcode_read_capacity,
20130016e820SDmitry Bogdanov &tcm_opcode_read_capacity16,
20140016e820SDmitry Bogdanov &tcm_opcode_read_report_refferals,
20150016e820SDmitry Bogdanov &tcm_opcode_sync_cache,
20160016e820SDmitry Bogdanov &tcm_opcode_sync_cache16,
20170016e820SDmitry Bogdanov &tcm_opcode_unmap,
20180016e820SDmitry Bogdanov &tcm_opcode_write_same,
20190016e820SDmitry Bogdanov &tcm_opcode_write_same16,
20200016e820SDmitry Bogdanov &tcm_opcode_verify,
20210016e820SDmitry Bogdanov &tcm_opcode_verify16,
20220016e820SDmitry Bogdanov &tcm_opcode_start_stop,
20230016e820SDmitry Bogdanov &tcm_opcode_mode_select,
20240016e820SDmitry Bogdanov &tcm_opcode_mode_select10,
20250016e820SDmitry Bogdanov &tcm_opcode_mode_sense,
20260016e820SDmitry Bogdanov &tcm_opcode_mode_sense10,
20270016e820SDmitry Bogdanov &tcm_opcode_pri_read_keys,
20280016e820SDmitry Bogdanov &tcm_opcode_pri_read_resrv,
20290016e820SDmitry Bogdanov &tcm_opcode_pri_read_caps,
20300016e820SDmitry Bogdanov &tcm_opcode_pri_read_full_status,
20310016e820SDmitry Bogdanov &tcm_opcode_pro_register,
20320016e820SDmitry Bogdanov &tcm_opcode_pro_reserve,
20330016e820SDmitry Bogdanov &tcm_opcode_pro_release,
20340016e820SDmitry Bogdanov &tcm_opcode_pro_clear,
20350016e820SDmitry Bogdanov &tcm_opcode_pro_preempt,
20360016e820SDmitry Bogdanov &tcm_opcode_pro_preempt_abort,
20370016e820SDmitry Bogdanov &tcm_opcode_pro_reg_ign_exist,
20380016e820SDmitry Bogdanov &tcm_opcode_pro_register_move,
20390016e820SDmitry Bogdanov &tcm_opcode_release,
20400016e820SDmitry Bogdanov &tcm_opcode_release10,
20410016e820SDmitry Bogdanov &tcm_opcode_reserve,
20420016e820SDmitry Bogdanov &tcm_opcode_reserve10,
20430016e820SDmitry Bogdanov &tcm_opcode_request_sense,
20440016e820SDmitry Bogdanov &tcm_opcode_inquiry,
20450016e820SDmitry Bogdanov &tcm_opcode_extended_copy_lid1,
20460016e820SDmitry Bogdanov &tcm_opcode_rcv_copy_res_op_params,
20470016e820SDmitry Bogdanov &tcm_opcode_report_luns,
20480016e820SDmitry Bogdanov &tcm_opcode_test_unit_ready,
20490016e820SDmitry Bogdanov &tcm_opcode_report_target_pgs,
20500016e820SDmitry Bogdanov &tcm_opcode_report_supp_opcodes,
20510016e820SDmitry Bogdanov &tcm_opcode_set_tpg,
20520016e820SDmitry Bogdanov };
20530016e820SDmitry Bogdanov
20540016e820SDmitry Bogdanov static int
spc_rsoc_encode_command_timeouts_descriptor(unsigned char * buf,u8 ctdp,struct target_opcode_descriptor * descr)20550016e820SDmitry Bogdanov spc_rsoc_encode_command_timeouts_descriptor(unsigned char *buf, u8 ctdp,
20560016e820SDmitry Bogdanov struct target_opcode_descriptor *descr)
2057b9b8782fSDmitry Bogdanov {
2058b9b8782fSDmitry Bogdanov if (!ctdp)
2059b9b8782fSDmitry Bogdanov return 0;
2060b9b8782fSDmitry Bogdanov
2061b9b8782fSDmitry Bogdanov put_unaligned_be16(0xa, buf);
2062b9b8782fSDmitry Bogdanov buf[3] = descr->specific_timeout;
2063b9b8782fSDmitry Bogdanov put_unaligned_be32(descr->nominal_timeout, &buf[4]);
2064b9b8782fSDmitry Bogdanov put_unaligned_be32(descr->recommended_timeout, &buf[8]);
2065b9b8782fSDmitry Bogdanov
2066b9b8782fSDmitry Bogdanov return 12;
2067b9b8782fSDmitry Bogdanov }
2068b9b8782fSDmitry Bogdanov
2069b9b8782fSDmitry Bogdanov static int
spc_rsoc_encode_command_descriptor(unsigned char * buf,u8 ctdp,struct target_opcode_descriptor * descr)2070b9b8782fSDmitry Bogdanov spc_rsoc_encode_command_descriptor(unsigned char *buf, u8 ctdp,
2071b9b8782fSDmitry Bogdanov struct target_opcode_descriptor *descr)
2072b9b8782fSDmitry Bogdanov {
2073b9b8782fSDmitry Bogdanov int td_size = 0;
2074b9b8782fSDmitry Bogdanov
2075b9b8782fSDmitry Bogdanov buf[0] = descr->opcode;
2076b9b8782fSDmitry Bogdanov
2077b9b8782fSDmitry Bogdanov put_unaligned_be16(descr->service_action, &buf[2]);
2078b9b8782fSDmitry Bogdanov
2079b9b8782fSDmitry Bogdanov buf[5] = (ctdp << 1) | descr->serv_action_valid;
2080b9b8782fSDmitry Bogdanov put_unaligned_be16(descr->cdb_size, &buf[6]);
2081b9b8782fSDmitry Bogdanov
2082b9b8782fSDmitry Bogdanov td_size = spc_rsoc_encode_command_timeouts_descriptor(&buf[8], ctdp,
2083b9b8782fSDmitry Bogdanov descr);
2084b9b8782fSDmitry Bogdanov
2085b9b8782fSDmitry Bogdanov return 8 + td_size;
2086b9b8782fSDmitry Bogdanov }
2087b9b8782fSDmitry Bogdanov
2088b9b8782fSDmitry Bogdanov static int
spc_rsoc_encode_one_command_descriptor(unsigned char * buf,u8 ctdp,struct target_opcode_descriptor * descr,struct se_device * dev)2089b9b8782fSDmitry Bogdanov spc_rsoc_encode_one_command_descriptor(unsigned char *buf, u8 ctdp,
2090b9b8782fSDmitry Bogdanov struct target_opcode_descriptor *descr,
2091b9b8782fSDmitry Bogdanov struct se_device *dev)
2092b9b8782fSDmitry Bogdanov {
2093b9b8782fSDmitry Bogdanov int td_size = 0;
2094b9b8782fSDmitry Bogdanov
2095415d82b4SDmitry Bogdanov if (!descr) {
2096415d82b4SDmitry Bogdanov buf[1] = (ctdp << 7) | SCSI_SUPPORT_NOT_SUPPORTED;
2097b9b8782fSDmitry Bogdanov return 2;
2098b9b8782fSDmitry Bogdanov }
2099b9b8782fSDmitry Bogdanov
2100b9b8782fSDmitry Bogdanov buf[1] = (ctdp << 7) | SCSI_SUPPORT_FULL;
2101b9b8782fSDmitry Bogdanov put_unaligned_be16(descr->cdb_size, &buf[2]);
2102b9b8782fSDmitry Bogdanov memcpy(&buf[4], descr->usage_bits, descr->cdb_size);
2103b9b8782fSDmitry Bogdanov if (descr->update_usage_bits)
2104b9b8782fSDmitry Bogdanov descr->update_usage_bits(&buf[4], dev);
2105b9b8782fSDmitry Bogdanov
2106b9b8782fSDmitry Bogdanov td_size = spc_rsoc_encode_command_timeouts_descriptor(
2107b9b8782fSDmitry Bogdanov &buf[4 + descr->cdb_size], ctdp, descr);
2108415d82b4SDmitry Bogdanov
2109415d82b4SDmitry Bogdanov return 4 + descr->cdb_size + td_size;
2110b9b8782fSDmitry Bogdanov }
2111b9b8782fSDmitry Bogdanov
2112b9b8782fSDmitry Bogdanov static sense_reason_t
spc_rsoc_get_descr(struct se_cmd * cmd,struct target_opcode_descriptor ** opcode)2113b9b8782fSDmitry Bogdanov spc_rsoc_get_descr(struct se_cmd *cmd, struct target_opcode_descriptor **opcode)
2114b9b8782fSDmitry Bogdanov {
2115b9b8782fSDmitry Bogdanov struct target_opcode_descriptor *descr;
2116b9b8782fSDmitry Bogdanov struct se_session *sess = cmd->se_sess;
2117b9b8782fSDmitry Bogdanov unsigned char *cdb = cmd->t_task_cdb;
2118b9b8782fSDmitry Bogdanov u8 opts = cdb[2] & 0x3;
2119b9b8782fSDmitry Bogdanov u8 requested_opcode;
2120b9b8782fSDmitry Bogdanov u16 requested_sa;
2121b9b8782fSDmitry Bogdanov int i;
2122b9b8782fSDmitry Bogdanov
2123b9b8782fSDmitry Bogdanov requested_opcode = cdb[3];
2124b9b8782fSDmitry Bogdanov requested_sa = ((u16)cdb[4]) << 8 | cdb[5];
2125b9b8782fSDmitry Bogdanov *opcode = NULL;
2126b9b8782fSDmitry Bogdanov
2127b9b8782fSDmitry Bogdanov if (opts > 3) {
2128b9b8782fSDmitry Bogdanov pr_debug("TARGET_CORE[%s]: Invalid REPORT SUPPORTED OPERATION CODES"
2129b9b8782fSDmitry Bogdanov " with unsupported REPORTING OPTIONS %#x for 0x%08llx from %s\n",
2130b9b8782fSDmitry Bogdanov cmd->se_tfo->fabric_name, opts,
2131b9b8782fSDmitry Bogdanov cmd->se_lun->unpacked_lun,
2132b9b8782fSDmitry Bogdanov sess->se_node_acl->initiatorname);
2133b9b8782fSDmitry Bogdanov return TCM_INVALID_CDB_FIELD;
2134b9b8782fSDmitry Bogdanov }
2135b9b8782fSDmitry Bogdanov
2136b9b8782fSDmitry Bogdanov for (i = 0; i < ARRAY_SIZE(tcm_supported_opcodes); i++) {
2137b9b8782fSDmitry Bogdanov descr = tcm_supported_opcodes[i];
2138b9b8782fSDmitry Bogdanov if (descr->opcode != requested_opcode)
2139b9b8782fSDmitry Bogdanov continue;
2140b9b8782fSDmitry Bogdanov
2141b9b8782fSDmitry Bogdanov switch (opts) {
2142b9b8782fSDmitry Bogdanov case 0x1:
2143b9b8782fSDmitry Bogdanov /*
2144b9b8782fSDmitry Bogdanov * If the REQUESTED OPERATION CODE field specifies an
2145b9b8782fSDmitry Bogdanov * operation code for which the device server implements
2146b9b8782fSDmitry Bogdanov * service actions, then the device server shall
2147b9b8782fSDmitry Bogdanov * terminate the command with CHECK CONDITION status,
2148b9b8782fSDmitry Bogdanov * with the sense key set to ILLEGAL REQUEST, and the
2149b9b8782fSDmitry Bogdanov * additional sense code set to INVALID FIELD IN CDB
2150b9b8782fSDmitry Bogdanov */
2151b9b8782fSDmitry Bogdanov if (descr->serv_action_valid)
2152b9b8782fSDmitry Bogdanov return TCM_INVALID_CDB_FIELD;
2153b9b8782fSDmitry Bogdanov
2154b9b8782fSDmitry Bogdanov if (!descr->enabled || descr->enabled(descr, cmd))
2155b9b8782fSDmitry Bogdanov *opcode = descr;
2156b9b8782fSDmitry Bogdanov break;
2157b9b8782fSDmitry Bogdanov case 0x2:
2158553b08d9SDmitry Bogdanov /*
2159d9b3275bSMike Christie * If the REQUESTED OPERATION CODE field specifies an
2160b9b8782fSDmitry Bogdanov * operation code for which the device server does not
2161b9b8782fSDmitry Bogdanov * implement service actions, then the device server
2162b9b8782fSDmitry Bogdanov * shall terminate the command with CHECK CONDITION
2163b9b8782fSDmitry Bogdanov * status, with the sense key set to ILLEGAL REQUEST,
2164b9b8782fSDmitry Bogdanov * and the additional sense code set to INVALID FIELD IN CDB.
2165b9b8782fSDmitry Bogdanov */
2166b9b8782fSDmitry Bogdanov if (descr->serv_action_valid &&
2167b9b8782fSDmitry Bogdanov descr->service_action == requested_sa) {
2168b9b8782fSDmitry Bogdanov if (!descr->enabled || descr->enabled(descr,
2169b9b8782fSDmitry Bogdanov cmd))
2170b9b8782fSDmitry Bogdanov *opcode = descr;
2171b9b8782fSDmitry Bogdanov } else if (!descr->serv_action_valid)
2172553b08d9SDmitry Bogdanov return TCM_INVALID_CDB_FIELD;
2173d9b3275bSMike Christie break;
2174d9b3275bSMike Christie case 0x3:
2175b9b8782fSDmitry Bogdanov /*
2176553b08d9SDmitry Bogdanov * The command support data for the operation code and
2177b9b8782fSDmitry Bogdanov * service action a specified in the REQUESTED OPERATION
2178b9b8782fSDmitry Bogdanov * CODE field and REQUESTED SERVICE ACTION field shall
2179b9b8782fSDmitry Bogdanov * be returned in the one_command parameter data format.
2180b9b8782fSDmitry Bogdanov */
2181b9b8782fSDmitry Bogdanov if (descr->service_action == requested_sa)
2182b9b8782fSDmitry Bogdanov if (!descr->enabled || descr->enabled(descr,
2183b9b8782fSDmitry Bogdanov cmd))
2184b9b8782fSDmitry Bogdanov *opcode = descr;
2185b9b8782fSDmitry Bogdanov break;
2186b9b8782fSDmitry Bogdanov }
2187d9b3275bSMike Christie }
2188d9b3275bSMike Christie
2189b9b8782fSDmitry Bogdanov return 0;
2190b9b8782fSDmitry Bogdanov }
2191b9b8782fSDmitry Bogdanov
2192b9b8782fSDmitry Bogdanov static sense_reason_t
spc_emulate_report_supp_op_codes(struct se_cmd * cmd)2193553b08d9SDmitry Bogdanov spc_emulate_report_supp_op_codes(struct se_cmd *cmd)
2194b9b8782fSDmitry Bogdanov {
2195b9b8782fSDmitry Bogdanov int descr_num = ARRAY_SIZE(tcm_supported_opcodes);
2196b9b8782fSDmitry Bogdanov struct target_opcode_descriptor *descr = NULL;
2197b9b8782fSDmitry Bogdanov unsigned char *cdb = cmd->t_task_cdb;
2198b9b8782fSDmitry Bogdanov u8 rctd = (cdb[2] >> 7) & 0x1;
2199b9b8782fSDmitry Bogdanov unsigned char *buf = NULL;
2200b9b8782fSDmitry Bogdanov int response_length = 0;
2201b9b8782fSDmitry Bogdanov u8 opts = cdb[2] & 0x3;
2202b9b8782fSDmitry Bogdanov unsigned char *rbuf;
2203b9b8782fSDmitry Bogdanov sense_reason_t ret = 0;
2204b9b8782fSDmitry Bogdanov int i;
2205b9b8782fSDmitry Bogdanov
2206b9b8782fSDmitry Bogdanov if (!cmd->se_dev->dev_attrib.emulate_rsoc)
2207b9b8782fSDmitry Bogdanov return TCM_UNSUPPORTED_SCSI_OPCODE;
2208b9b8782fSDmitry Bogdanov
2209b9b8782fSDmitry Bogdanov rbuf = transport_kmap_data_sg(cmd);
2210b9b8782fSDmitry Bogdanov if (cmd->data_length && !rbuf) {
2211bd217b8cSDmitry Bogdanov ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
2212bd217b8cSDmitry Bogdanov goto out;
2213bd217b8cSDmitry Bogdanov }
2214b9b8782fSDmitry Bogdanov
2215b9b8782fSDmitry Bogdanov if (opts == 0)
2216b9b8782fSDmitry Bogdanov response_length = 4 + (8 + rctd * 12) * descr_num;
2217b9b8782fSDmitry Bogdanov else {
2218b9b8782fSDmitry Bogdanov ret = spc_rsoc_get_descr(cmd, &descr);
2219b9b8782fSDmitry Bogdanov if (ret)
2220b9b8782fSDmitry Bogdanov goto out;
2221b9b8782fSDmitry Bogdanov
2222b9b8782fSDmitry Bogdanov if (descr)
2223b9b8782fSDmitry Bogdanov response_length = 4 + descr->cdb_size + rctd * 12;
2224b9b8782fSDmitry Bogdanov else
2225b9b8782fSDmitry Bogdanov response_length = 2;
2226b9b8782fSDmitry Bogdanov }
2227b9b8782fSDmitry Bogdanov
2228b9b8782fSDmitry Bogdanov buf = kzalloc(response_length, GFP_KERNEL);
2229b9b8782fSDmitry Bogdanov if (!buf) {
2230b9b8782fSDmitry Bogdanov ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
2231b9b8782fSDmitry Bogdanov goto out;
2232b9b8782fSDmitry Bogdanov }
2233b9b8782fSDmitry Bogdanov response_length = 0;
2234b9b8782fSDmitry Bogdanov
2235b9b8782fSDmitry Bogdanov if (opts == 0) {
2236b9b8782fSDmitry Bogdanov response_length += 4;
2237b9b8782fSDmitry Bogdanov
2238b9b8782fSDmitry Bogdanov for (i = 0; i < ARRAY_SIZE(tcm_supported_opcodes); i++) {
2239b9b8782fSDmitry Bogdanov descr = tcm_supported_opcodes[i];
2240b9b8782fSDmitry Bogdanov if (descr->enabled && !descr->enabled(descr, cmd))
2241b9b8782fSDmitry Bogdanov continue;
2242b9b8782fSDmitry Bogdanov
2243b9b8782fSDmitry Bogdanov response_length += spc_rsoc_encode_command_descriptor(
2244b9b8782fSDmitry Bogdanov &buf[response_length], rctd, descr);
2245d9b3275bSMike Christie }
2246553b08d9SDmitry Bogdanov put_unaligned_be32(response_length - 3, buf);
2247553b08d9SDmitry Bogdanov } else {
2248b9b8782fSDmitry Bogdanov response_length = spc_rsoc_encode_one_command_descriptor(
2249b9b8782fSDmitry Bogdanov &buf[response_length], rctd, descr,
2250b9b8782fSDmitry Bogdanov cmd->se_dev);
2251b9b8782fSDmitry Bogdanov }
2252b9b8782fSDmitry Bogdanov
2253b9b8782fSDmitry Bogdanov memcpy(rbuf, buf, min_t(u32, response_length, cmd->data_length));
2254415d82b4SDmitry Bogdanov out:
2255415d82b4SDmitry Bogdanov kfree(buf);
2256b9b8782fSDmitry Bogdanov transport_kunmap_data_sg(cmd);
2257b9b8782fSDmitry Bogdanov
2258b9b8782fSDmitry Bogdanov if (!ret)
2259b9b8782fSDmitry Bogdanov target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, response_length);
2260b9b8782fSDmitry Bogdanov return ret;
2261b9b8782fSDmitry Bogdanov }
2262b9b8782fSDmitry Bogdanov
2263b9b8782fSDmitry Bogdanov sense_reason_t
spc_parse_cdb(struct se_cmd * cmd,unsigned int * size)2264b9b8782fSDmitry Bogdanov spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
2265b9b8782fSDmitry Bogdanov {
2266b9b8782fSDmitry Bogdanov struct se_device *dev = cmd->se_dev;
2267b9b8782fSDmitry Bogdanov unsigned char *cdb = cmd->t_task_cdb;
2268de103c93SChristoph Hellwig
2269de103c93SChristoph Hellwig switch (cdb[0]) {
227088455ec4SChristoph Hellwig case RESERVE:
2271eba2ca45SNicholas Bellinger case RESERVE_10:
227288455ec4SChristoph Hellwig case RELEASE:
227388455ec4SChristoph Hellwig case RELEASE_10:
2274*8455799dSMike Christie if (!dev->dev_attrib.emulate_pr)
2275*8455799dSMike Christie return TCM_UNSUPPORTED_SCSI_OPCODE;
2276*8455799dSMike Christie
2277*8455799dSMike Christie if (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR)
2278*8455799dSMike Christie return TCM_UNSUPPORTED_SCSI_OPCODE;
2279*8455799dSMike Christie break;
2280b49d6f78SDavid Disseldorp case PERSISTENT_RESERVE_IN:
2281*8455799dSMike Christie case PERSISTENT_RESERVE_OUT:
2282*8455799dSMike Christie if (!dev->dev_attrib.emulate_pr)
2283*8455799dSMike Christie return TCM_UNSUPPORTED_SCSI_OPCODE;
2284*8455799dSMike Christie break;
2285*8455799dSMike Christie }
2286*8455799dSMike Christie
2287*8455799dSMike Christie switch (cdb[0]) {
2288*8455799dSMike Christie case MODE_SELECT:
2289*8455799dSMike Christie *size = cdb[4];
2290b49d6f78SDavid Disseldorp cmd->execute_cmd = spc_emulate_modeselect;
2291b49d6f78SDavid Disseldorp break;
229288455ec4SChristoph Hellwig case MODE_SELECT_10:
229388455ec4SChristoph Hellwig *size = get_unaligned_be16(&cdb[7]);
229488455ec4SChristoph Hellwig cmd->execute_cmd = spc_emulate_modeselect;
22953a3c5e4aSRoland Dreier break;
229688455ec4SChristoph Hellwig case MODE_SENSE:
229788455ec4SChristoph Hellwig *size = cdb[4];
2298a85d667eSBart Van Assche cmd->execute_cmd = spc_emulate_modesense;
22993a3c5e4aSRoland Dreier break;
230088455ec4SChristoph Hellwig case MODE_SENSE_10:
230188455ec4SChristoph Hellwig *size = get_unaligned_be16(&cdb[7]);
230288455ec4SChristoph Hellwig cmd->execute_cmd = spc_emulate_modesense;
23031fd032eeSChristoph Hellwig break;
230488455ec4SChristoph Hellwig case LOG_SELECT:
230588455ec4SChristoph Hellwig case LOG_SENSE:
2306a85d667eSBart Van Assche *size = get_unaligned_be16(&cdb[7]);
23071fd032eeSChristoph Hellwig break;
230888455ec4SChristoph Hellwig case PERSISTENT_RESERVE_IN:
230988455ec4SChristoph Hellwig *size = get_unaligned_be16(&cdb[7]);
231088455ec4SChristoph Hellwig cmd->execute_cmd = target_scsi3_emulate_pr_in;
2311a85d667eSBart Van Assche break;
231288455ec4SChristoph Hellwig case PERSISTENT_RESERVE_OUT:
231388455ec4SChristoph Hellwig *size = get_unaligned_be32(&cdb[5]);
2314a85d667eSBart Van Assche cmd->execute_cmd = target_scsi3_emulate_pr_out;
2315d977f437SChristoph Hellwig break;
231688455ec4SChristoph Hellwig case RELEASE:
231788455ec4SChristoph Hellwig case RELEASE_10:
2318388fe699STang Wenji if (cdb[0] == RELEASE_10)
2319d977f437SChristoph Hellwig *size = get_unaligned_be16(&cdb[7]);
232088455ec4SChristoph Hellwig else
232188455ec4SChristoph Hellwig *size = cmd->data_length;
232288455ec4SChristoph Hellwig
232388455ec4SChristoph Hellwig cmd->execute_cmd = target_scsi2_reservation_release;
2324a85d667eSBart Van Assche break;
232588455ec4SChristoph Hellwig case RESERVE:
232688455ec4SChristoph Hellwig case RESERVE_10:
232788455ec4SChristoph Hellwig /*
232888455ec4SChristoph Hellwig * The SPC-2 RESERVE does not contain a size in the SCSI CDB.
232988455ec4SChristoph Hellwig * Assume the passthrough or $FABRIC_MOD will tell us about it.
233088455ec4SChristoph Hellwig */
233188455ec4SChristoph Hellwig if (cdb[0] == RESERVE_10)
233288455ec4SChristoph Hellwig *size = get_unaligned_be16(&cdb[7]);
233388455ec4SChristoph Hellwig else
233488455ec4SChristoph Hellwig *size = cmd->data_length;
233588455ec4SChristoph Hellwig
233688455ec4SChristoph Hellwig cmd->execute_cmd = target_scsi2_reservation_reserve;
2337a85d667eSBart Van Assche break;
233888455ec4SChristoph Hellwig case REQUEST_SENSE:
233988455ec4SChristoph Hellwig *size = cdb[4];
234088455ec4SChristoph Hellwig cmd->execute_cmd = spc_emulate_request_sense;
234188455ec4SChristoph Hellwig break;
234288455ec4SChristoph Hellwig case INQUIRY:
234388455ec4SChristoph Hellwig *size = get_unaligned_be16(&cdb[3]);
234488455ec4SChristoph Hellwig
23451fd032eeSChristoph Hellwig /*
234688455ec4SChristoph Hellwig * Do implicit HEAD_OF_QUEUE processing for INQUIRY.
234788455ec4SChristoph Hellwig * See spc4r17 section 5.3
2348a85d667eSBart Van Assche */
234988455ec4SChristoph Hellwig cmd->sam_task_attr = TCM_HEAD_TAG;
235088455ec4SChristoph Hellwig cmd->execute_cmd = spc_emulate_inquiry;
2351125d0119SHannes Reinecke break;
235288455ec4SChristoph Hellwig case SECURITY_PROTOCOL_IN:
235388455ec4SChristoph Hellwig case SECURITY_PROTOCOL_OUT:
235468d81f40SChristoph Hellwig *size = get_unaligned_be32(&cdb[6]);
23551fd032eeSChristoph Hellwig break;
235688455ec4SChristoph Hellwig case EXTENDED_COPY:
235788455ec4SChristoph Hellwig *size = get_unaligned_be32(&cdb[10]);
235888455ec4SChristoph Hellwig cmd->execute_cmd = target_do_xcopy;
2359a85d667eSBart Van Assche break;
236088455ec4SChristoph Hellwig case RECEIVE_COPY_RESULTS:
236188455ec4SChristoph Hellwig *size = get_unaligned_be32(&cdb[10]);
236204b1b795SNicholas Bellinger cmd->execute_cmd = target_do_receive_copy_results;
236304b1b795SNicholas Bellinger break;
236404b1b795SNicholas Bellinger case READ_ATTRIBUTE:
236588455ec4SChristoph Hellwig case WRITE_ATTRIBUTE:
236604b1b795SNicholas Bellinger *size = get_unaligned_be32(&cdb[10]);
236704b1b795SNicholas Bellinger break;
236804b1b795SNicholas Bellinger case RECEIVE_DIAGNOSTIC:
236904b1b795SNicholas Bellinger case SEND_DIAGNOSTIC:
237088455ec4SChristoph Hellwig *size = get_unaligned_be16(&cdb[3]);
2371a85d667eSBart Van Assche break;
237288455ec4SChristoph Hellwig case WRITE_BUFFER:
237388455ec4SChristoph Hellwig *size = get_unaligned_be24(&cdb[6]);
237488455ec4SChristoph Hellwig break;
2375a85d667eSBart Van Assche case REPORT_LUNS:
237688455ec4SChristoph Hellwig cmd->execute_cmd = spc_emulate_report_luns;
237788455ec4SChristoph Hellwig *size = get_unaligned_be32(&cdb[6]);
2378a85d667eSBart Van Assche /*
237988455ec4SChristoph Hellwig * Do implicit HEAD_OF_QUEUE processing for REPORT_LUNS
238088455ec4SChristoph Hellwig * See spc4r17 section 5.3
2381d1b1f805SChristoph Hellwig */
2382a85d667eSBart Van Assche cmd->sam_task_attr = TCM_HEAD_TAG;
238388455ec4SChristoph Hellwig break;
2384125d0119SHannes Reinecke case TEST_UNIT_READY:
238588455ec4SChristoph Hellwig cmd->execute_cmd = spc_emulate_testunitready;
238688455ec4SChristoph Hellwig *size = 0;
238768d81f40SChristoph Hellwig break;
238888455ec4SChristoph Hellwig case MAINTENANCE_IN:
238988455ec4SChristoph Hellwig if (dev->transport->get_device_type(dev) != TYPE_ROM) {
23901fd032eeSChristoph Hellwig /*
2391d6e0175cSChristoph Hellwig * MAINTENANCE_IN from SCC-2
239288455ec4SChristoph Hellwig * Check for emulated MI_REPORT_TARGET_PGS
2393eba2ca45SNicholas Bellinger */
2394eba2ca45SNicholas Bellinger if ((cdb[1] & 0x1f) == MI_REPORT_TARGET_PGS) {
2395eba2ca45SNicholas Bellinger cmd->execute_cmd =
2396eba2ca45SNicholas Bellinger target_emulate_report_target_port_groups;
2397eba2ca45SNicholas Bellinger }
2398eba2ca45SNicholas Bellinger if ((cdb[1] & 0x1f) ==
2399c87fbd56SChristoph Hellwig MI_REPORT_SUPPORTED_OPERATION_CODES)
2400eba2ca45SNicholas Bellinger cmd->execute_cmd =
2401eba2ca45SNicholas Bellinger spc_emulate_report_supp_op_codes;
2402eba2ca45SNicholas Bellinger *size = get_unaligned_be32(&cdb[6]);
2403b9b8782fSDmitry Bogdanov } else {
2404b9b8782fSDmitry Bogdanov /*
2405b9b8782fSDmitry Bogdanov * GPCMD_SEND_KEY from multi media commands
2406b9b8782fSDmitry Bogdanov */
2407eba2ca45SNicholas Bellinger *size = get_unaligned_be16(&cdb[8]);
2408eba2ca45SNicholas Bellinger }
2409eba2ca45SNicholas Bellinger break;
2410eba2ca45SNicholas Bellinger case MAINTENANCE_OUT:
2411eba2ca45SNicholas Bellinger if (dev->transport->get_device_type(dev) != TYPE_ROM) {
2412eba2ca45SNicholas Bellinger /*
2413eba2ca45SNicholas Bellinger * MAINTENANCE_OUT from SCC-2
2414eba2ca45SNicholas Bellinger * Check for emulated MO_SET_TARGET_PGS.
2415eba2ca45SNicholas Bellinger */
2416eba2ca45SNicholas Bellinger if (cdb[1] == MO_SET_TARGET_PGS) {
2417eba2ca45SNicholas Bellinger cmd->execute_cmd =
2418eba2ca45SNicholas Bellinger target_emulate_set_target_port_groups;
2419eba2ca45SNicholas Bellinger }
2420eba2ca45SNicholas Bellinger *size = get_unaligned_be32(&cdb[6]);
2421c87fbd56SChristoph Hellwig } else {
2422eba2ca45SNicholas Bellinger /*
2423eba2ca45SNicholas Bellinger * GPCMD_SEND_KEY from multi media commands
2424eba2ca45SNicholas Bellinger */
2425eba2ca45SNicholas Bellinger *size = get_unaligned_be16(&cdb[8]);
2426eba2ca45SNicholas Bellinger }
2427eba2ca45SNicholas Bellinger break;
2428eba2ca45SNicholas Bellinger default:
2429eba2ca45SNicholas Bellinger return TCM_UNSUPPORTED_SCSI_OPCODE;
2430eba2ca45SNicholas Bellinger }
2431eba2ca45SNicholas Bellinger
2432eba2ca45SNicholas Bellinger return 0;
243388455ec4SChristoph Hellwig }
2434de103c93SChristoph Hellwig EXPORT_SYMBOL(spc_parse_cdb);
243588455ec4SChristoph Hellwig