Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit ee60bddba5a5f23e39598195d944aa0eb2d455e5

Authored by Nicholas Bellinger
1 parent d4e4ab86bc
Exists in smarc-imx_3.14.28_1.0.0_ga and in 1 other branch imx_3.14.28_1.0.0_ga

target: Fix trailing ASCII space usage in INQUIRY vendor+model 

This patch fixes spc_emulate_inquiry_std() to add trailing ASCII
spaces for INQUIRY vendor + model fields following SPC-4 text:

  "ASCII data fields described as being left-aligned shall have any
   unused bytes at the end of the field (i.e., highest offset) and
   the unused bytes shall be filled with ASCII space characters (20h)."

This addresses a problem with Falconstor NSS multipathing.

Reported-by: Tomas Molota <tomas.molota@lightstorm.sk>
Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>

Showing 1 changed file with 6 additions and 3 deletions Inline Diff

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