1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * SCSI Primary Commands (SPC) parsing and emulation.
4  *
5  * (c) Copyright 2002-2013 Datera, Inc.
6  *
7  * Nicholas A. Bellinger <nab@kernel.org>
8  */
9 
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <asm/unaligned.h>
13 
14 #include <scsi/scsi_proto.h>
15 #include <scsi/scsi_common.h>
16 #include <scsi/scsi_tcq.h>
17 
18 #include <target/target_core_base.h>
19 #include <target/target_core_backend.h>
20 #include <target/target_core_fabric.h>
21 
22 #include "target_core_internal.h"
23 #include "target_core_alua.h"
24 #include "target_core_pr.h"
25 #include "target_core_ua.h"
26 #include "target_core_xcopy.h"
27 
28 static void spc_fill_alua_data(struct se_lun *lun, unsigned char *buf)
29 {
30 	struct t10_alua_tg_pt_gp *tg_pt_gp;
31 
32 	/*
33 	 * Set SCCS for MAINTENANCE_IN + REPORT_TARGET_PORT_GROUPS.
34 	 */
35 	buf[5]	= 0x80;
36 
37 	/*
38 	 * Set TPGS field for explicit and/or implicit ALUA access type
39 	 * and opteration.
40 	 *
41 	 * See spc4r17 section 6.4.2 Table 135
42 	 */
43 	rcu_read_lock();
44 	tg_pt_gp = rcu_dereference(lun->lun_tg_pt_gp);
45 	if (tg_pt_gp)
46 		buf[5] |= tg_pt_gp->tg_pt_gp_alua_access_type;
47 	rcu_read_unlock();
48 }
49 
50 static u16
51 spc_find_scsi_transport_vd(int proto_id)
52 {
53 	switch (proto_id) {
54 	case SCSI_PROTOCOL_FCP:
55 		return SCSI_VERSION_DESCRIPTOR_FCP4;
56 	case SCSI_PROTOCOL_ISCSI:
57 		return SCSI_VERSION_DESCRIPTOR_ISCSI;
58 	case SCSI_PROTOCOL_SAS:
59 		return SCSI_VERSION_DESCRIPTOR_SAS3;
60 	case SCSI_PROTOCOL_SBP:
61 		return SCSI_VERSION_DESCRIPTOR_SBP3;
62 	case SCSI_PROTOCOL_SRP:
63 		return SCSI_VERSION_DESCRIPTOR_SRP;
64 	default:
65 		pr_warn("Cannot find VERSION DESCRIPTOR value for unknown SCSI"
66 			" transport PROTOCOL IDENTIFIER %#x\n", proto_id);
67 		return 0;
68 	}
69 }
70 
71 sense_reason_t
72 spc_emulate_inquiry_std(struct se_cmd *cmd, unsigned char *buf)
73 {
74 	struct se_lun *lun = cmd->se_lun;
75 	struct se_portal_group *tpg = lun->lun_tpg;
76 	struct se_device *dev = cmd->se_dev;
77 	struct se_session *sess = cmd->se_sess;
78 
79 	/* Set RMB (removable media) for tape devices */
80 	if (dev->transport->get_device_type(dev) == TYPE_TAPE)
81 		buf[1] = 0x80;
82 
83 	buf[2] = 0x06; /* SPC-4 */
84 
85 	/*
86 	 * NORMACA and HISUP = 0, RESPONSE DATA FORMAT = 2
87 	 *
88 	 * SPC4 says:
89 	 *   A RESPONSE DATA FORMAT field set to 2h indicates that the
90 	 *   standard INQUIRY data is in the format defined in this
91 	 *   standard. Response data format values less than 2h are
92 	 *   obsolete. Response data format values greater than 2h are
93 	 *   reserved.
94 	 */
95 	buf[3] = 2;
96 
97 	/*
98 	 * Enable SCCS and TPGS fields for Emulated ALUA
99 	 */
100 	spc_fill_alua_data(lun, buf);
101 
102 	/*
103 	 * Set Third-Party Copy (3PC) bit to indicate support for EXTENDED_COPY
104 	 */
105 	if (dev->dev_attrib.emulate_3pc)
106 		buf[5] |= 0x8;
107 	/*
108 	 * Set Protection (PROTECT) bit when DIF has been enabled on the
109 	 * device, and the fabric supports VERIFY + PASS.  Also report
110 	 * PROTECT=1 if sess_prot_type has been configured to allow T10-PI
111 	 * to unprotected devices.
112 	 */
113 	if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
114 		if (dev->dev_attrib.pi_prot_type || cmd->se_sess->sess_prot_type)
115 			buf[5] |= 0x1;
116 	}
117 
118 	/*
119 	 * Set MULTIP bit to indicate presence of multiple SCSI target ports
120 	 */
121 	if (dev->export_count > 1)
122 		buf[6] |= 0x10;
123 
124 	buf[7] = 0x2; /* CmdQue=1 */
125 
126 	/*
127 	 * ASCII data fields described as being left-aligned shall have any
128 	 * unused bytes at the end of the field (i.e., highest offset) and the
129 	 * unused bytes shall be filled with ASCII space characters (20h).
130 	 */
131 	memset(&buf[8], 0x20,
132 	       INQUIRY_VENDOR_LEN + INQUIRY_MODEL_LEN + INQUIRY_REVISION_LEN);
133 	memcpy(&buf[8], dev->t10_wwn.vendor,
134 	       strnlen(dev->t10_wwn.vendor, INQUIRY_VENDOR_LEN));
135 	memcpy(&buf[16], dev->t10_wwn.model,
136 	       strnlen(dev->t10_wwn.model, INQUIRY_MODEL_LEN));
137 	memcpy(&buf[32], dev->t10_wwn.revision,
138 	       strnlen(dev->t10_wwn.revision, INQUIRY_REVISION_LEN));
139 
140 	/*
141 	 * Set the VERSION DESCRIPTOR fields
142 	 */
143 	put_unaligned_be16(SCSI_VERSION_DESCRIPTOR_SAM5, &buf[58]);
144 	put_unaligned_be16(spc_find_scsi_transport_vd(tpg->proto_id), &buf[60]);
145 	put_unaligned_be16(SCSI_VERSION_DESCRIPTOR_SPC4, &buf[62]);
146 	if (cmd->se_dev->transport->get_device_type(dev) == TYPE_DISK)
147 		put_unaligned_be16(SCSI_VERSION_DESCRIPTOR_SBC3, &buf[64]);
148 
149 	buf[4] = 91; /* Set additional length to 91 */
150 
151 	return 0;
152 }
153 EXPORT_SYMBOL(spc_emulate_inquiry_std);
154 
155 /* unit serial number */
156 static sense_reason_t
157 spc_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf)
158 {
159 	struct se_device *dev = cmd->se_dev;
160 	u16 len;
161 
162 	if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
163 		len = sprintf(&buf[4], "%s", dev->t10_wwn.unit_serial);
164 		len++; /* Extra Byte for NULL Terminator */
165 		buf[3] = len;
166 	}
167 	return 0;
168 }
169 
170 /*
171  * Generate NAA IEEE Registered Extended designator
172  */
173 void spc_gen_naa_6h_vendor_specific(struct se_device *dev,
174 				    unsigned char *buf)
175 {
176 	unsigned char *p = &dev->t10_wwn.unit_serial[0];
177 	u32 company_id = dev->t10_wwn.company_id;
178 	int cnt, off = 0;
179 	bool next = true;
180 
181 	/*
182 	 * Start NAA IEEE Registered Extended Identifier/Designator
183 	 */
184 	buf[off] = 0x6 << 4;
185 
186 	/* IEEE COMPANY_ID */
187 	buf[off++] |= (company_id >> 20) & 0xf;
188 	buf[off++] = (company_id >> 12) & 0xff;
189 	buf[off++] = (company_id >> 4) & 0xff;
190 	buf[off] = (company_id & 0xf) << 4;
191 
192 	/*
193 	 * Generate up to 36 bits of VENDOR SPECIFIC IDENTIFIER starting on
194 	 * byte 3 bit 3-0 for NAA IEEE Registered Extended DESIGNATOR field
195 	 * format, followed by 64 bits of VENDOR SPECIFIC IDENTIFIER EXTENSION
196 	 * to complete the payload.  These are based from VPD=0x80 PRODUCT SERIAL
197 	 * NUMBER set via vpd_unit_serial in target_core_configfs.c to ensure
198 	 * per device uniqeness.
199 	 */
200 	for (cnt = off + 13; *p && off < cnt; p++) {
201 		int val = hex_to_bin(*p);
202 
203 		if (val < 0)
204 			continue;
205 
206 		if (next) {
207 			next = false;
208 			buf[off++] |= val;
209 		} else {
210 			next = true;
211 			buf[off] = val << 4;
212 		}
213 	}
214 }
215 
216 /*
217  * Device identification VPD, for a complete list of
218  * DESIGNATOR TYPEs see spc4r17 Table 459.
219  */
220 sense_reason_t
221 spc_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)
222 {
223 	struct se_device *dev = cmd->se_dev;
224 	struct se_lun *lun = cmd->se_lun;
225 	struct se_portal_group *tpg = NULL;
226 	struct t10_alua_lu_gp_member *lu_gp_mem;
227 	struct t10_alua_tg_pt_gp *tg_pt_gp;
228 	unsigned char *prod = &dev->t10_wwn.model[0];
229 	u32 prod_len;
230 	u32 off = 0;
231 	u16 len = 0, id_len;
232 
233 	off = 4;
234 
235 	/*
236 	 * NAA IEEE Registered Extended Assigned designator format, see
237 	 * spc4r17 section 7.7.3.6.5
238 	 *
239 	 * We depend upon a target_core_mod/ConfigFS provided
240 	 * /sys/kernel/config/target/core/$HBA/$DEV/wwn/vpd_unit_serial
241 	 * value in order to return the NAA id.
242 	 */
243 	if (!(dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL))
244 		goto check_t10_vend_desc;
245 
246 	/* CODE SET == Binary */
247 	buf[off++] = 0x1;
248 
249 	/* Set ASSOCIATION == addressed logical unit: 0)b */
250 	buf[off] = 0x00;
251 
252 	/* Identifier/Designator type == NAA identifier */
253 	buf[off++] |= 0x3;
254 	off++;
255 
256 	/* Identifier/Designator length */
257 	buf[off++] = 0x10;
258 
259 	/* NAA IEEE Registered Extended designator */
260 	spc_gen_naa_6h_vendor_specific(dev, &buf[off]);
261 
262 	len = 20;
263 	off = (len + 4);
264 
265 check_t10_vend_desc:
266 	/*
267 	 * T10 Vendor Identifier Page, see spc4r17 section 7.7.3.4
268 	 */
269 	id_len = 8; /* For Vendor field */
270 	prod_len = 4; /* For VPD Header */
271 	prod_len += 8; /* For Vendor field */
272 	prod_len += strlen(prod);
273 	prod_len++; /* For : */
274 
275 	if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL)
276 		id_len += sprintf(&buf[off+12], "%s:%s", prod,
277 				&dev->t10_wwn.unit_serial[0]);
278 	buf[off] = 0x2; /* ASCII */
279 	buf[off+1] = 0x1; /* T10 Vendor ID */
280 	buf[off+2] = 0x0;
281 	/* left align Vendor ID and pad with spaces */
282 	memset(&buf[off+4], 0x20, INQUIRY_VENDOR_LEN);
283 	memcpy(&buf[off+4], dev->t10_wwn.vendor,
284 	       strnlen(dev->t10_wwn.vendor, INQUIRY_VENDOR_LEN));
285 	/* Extra Byte for NULL Terminator */
286 	id_len++;
287 	/* Identifier Length */
288 	buf[off+3] = id_len;
289 	/* Header size for Designation descriptor */
290 	len += (id_len + 4);
291 	off += (id_len + 4);
292 
293 	if (1) {
294 		struct t10_alua_lu_gp *lu_gp;
295 		u32 padding, scsi_name_len, scsi_target_len;
296 		u16 lu_gp_id = 0;
297 		u16 tg_pt_gp_id = 0;
298 		u16 tpgt;
299 
300 		tpg = lun->lun_tpg;
301 		/*
302 		 * Relative target port identifer, see spc4r17
303 		 * section 7.7.3.7
304 		 *
305 		 * Get the PROTOCOL IDENTIFIER as defined by spc4r17
306 		 * section 7.5.1 Table 362
307 		 */
308 		buf[off] = tpg->proto_id << 4;
309 		buf[off++] |= 0x1; /* CODE SET == Binary */
310 		buf[off] = 0x80; /* Set PIV=1 */
311 		/* Set ASSOCIATION == target port: 01b */
312 		buf[off] |= 0x10;
313 		/* DESIGNATOR TYPE == Relative target port identifer */
314 		buf[off++] |= 0x4;
315 		off++; /* Skip over Reserved */
316 		buf[off++] = 4; /* DESIGNATOR LENGTH */
317 		/* Skip over Obsolete field in RTPI payload
318 		 * in Table 472 */
319 		off += 2;
320 		put_unaligned_be16(lun->lun_rtpi, &buf[off]);
321 		off += 2;
322 		len += 8; /* Header size + Designation descriptor */
323 		/*
324 		 * Target port group identifier, see spc4r17
325 		 * section 7.7.3.8
326 		 *
327 		 * Get the PROTOCOL IDENTIFIER as defined by spc4r17
328 		 * section 7.5.1 Table 362
329 		 */
330 		rcu_read_lock();
331 		tg_pt_gp = rcu_dereference(lun->lun_tg_pt_gp);
332 		if (!tg_pt_gp) {
333 			rcu_read_unlock();
334 			goto check_lu_gp;
335 		}
336 		tg_pt_gp_id = tg_pt_gp->tg_pt_gp_id;
337 		rcu_read_unlock();
338 
339 		buf[off] = tpg->proto_id << 4;
340 		buf[off++] |= 0x1; /* CODE SET == Binary */
341 		buf[off] = 0x80; /* Set PIV=1 */
342 		/* Set ASSOCIATION == target port: 01b */
343 		buf[off] |= 0x10;
344 		/* DESIGNATOR TYPE == Target port group identifier */
345 		buf[off++] |= 0x5;
346 		off++; /* Skip over Reserved */
347 		buf[off++] = 4; /* DESIGNATOR LENGTH */
348 		off += 2; /* Skip over Reserved Field */
349 		put_unaligned_be16(tg_pt_gp_id, &buf[off]);
350 		off += 2;
351 		len += 8; /* Header size + Designation descriptor */
352 		/*
353 		 * Logical Unit Group identifier, see spc4r17
354 		 * section 7.7.3.8
355 		 */
356 check_lu_gp:
357 		lu_gp_mem = dev->dev_alua_lu_gp_mem;
358 		if (!lu_gp_mem)
359 			goto check_scsi_name;
360 
361 		spin_lock(&lu_gp_mem->lu_gp_mem_lock);
362 		lu_gp = lu_gp_mem->lu_gp;
363 		if (!lu_gp) {
364 			spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
365 			goto check_scsi_name;
366 		}
367 		lu_gp_id = lu_gp->lu_gp_id;
368 		spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
369 
370 		buf[off++] |= 0x1; /* CODE SET == Binary */
371 		/* DESIGNATOR TYPE == Logical Unit Group identifier */
372 		buf[off++] |= 0x6;
373 		off++; /* Skip over Reserved */
374 		buf[off++] = 4; /* DESIGNATOR LENGTH */
375 		off += 2; /* Skip over Reserved Field */
376 		put_unaligned_be16(lu_gp_id, &buf[off]);
377 		off += 2;
378 		len += 8; /* Header size + Designation descriptor */
379 		/*
380 		 * SCSI name string designator, see spc4r17
381 		 * section 7.7.3.11
382 		 *
383 		 * Get the PROTOCOL IDENTIFIER as defined by spc4r17
384 		 * section 7.5.1 Table 362
385 		 */
386 check_scsi_name:
387 		buf[off] = tpg->proto_id << 4;
388 		buf[off++] |= 0x3; /* CODE SET == UTF-8 */
389 		buf[off] = 0x80; /* Set PIV=1 */
390 		/* Set ASSOCIATION == target port: 01b */
391 		buf[off] |= 0x10;
392 		/* DESIGNATOR TYPE == SCSI name string */
393 		buf[off++] |= 0x8;
394 		off += 2; /* Skip over Reserved and length */
395 		/*
396 		 * SCSI name string identifer containing, $FABRIC_MOD
397 		 * dependent information.  For LIO-Target and iSCSI
398 		 * Target Port, this means "<iSCSI name>,t,0x<TPGT> in
399 		 * UTF-8 encoding.
400 		 */
401 		tpgt = tpg->se_tpg_tfo->tpg_get_tag(tpg);
402 		scsi_name_len = sprintf(&buf[off], "%s,t,0x%04x",
403 					tpg->se_tpg_tfo->tpg_get_wwn(tpg), tpgt);
404 		scsi_name_len += 1 /* Include  NULL terminator */;
405 		/*
406 		 * The null-terminated, null-padded (see 4.4.2) SCSI
407 		 * NAME STRING field contains a UTF-8 format string.
408 		 * The number of bytes in the SCSI NAME STRING field
409 		 * (i.e., the value in the DESIGNATOR LENGTH field)
410 		 * shall be no larger than 256 and shall be a multiple
411 		 * of four.
412 		 */
413 		padding = ((-scsi_name_len) & 3);
414 		if (padding)
415 			scsi_name_len += padding;
416 		if (scsi_name_len > 256)
417 			scsi_name_len = 256;
418 
419 		buf[off-1] = scsi_name_len;
420 		off += scsi_name_len;
421 		/* Header size + Designation descriptor */
422 		len += (scsi_name_len + 4);
423 
424 		/*
425 		 * Target device designator
426 		 */
427 		buf[off] = tpg->proto_id << 4;
428 		buf[off++] |= 0x3; /* CODE SET == UTF-8 */
429 		buf[off] = 0x80; /* Set PIV=1 */
430 		/* Set ASSOCIATION == target device: 10b */
431 		buf[off] |= 0x20;
432 		/* DESIGNATOR TYPE == SCSI name string */
433 		buf[off++] |= 0x8;
434 		off += 2; /* Skip over Reserved and length */
435 		/*
436 		 * SCSI name string identifer containing, $FABRIC_MOD
437 		 * dependent information.  For LIO-Target and iSCSI
438 		 * Target Port, this means "<iSCSI name>" in
439 		 * UTF-8 encoding.
440 		 */
441 		scsi_target_len = sprintf(&buf[off], "%s",
442 					  tpg->se_tpg_tfo->tpg_get_wwn(tpg));
443 		scsi_target_len += 1 /* Include  NULL terminator */;
444 		/*
445 		 * The null-terminated, null-padded (see 4.4.2) SCSI
446 		 * NAME STRING field contains a UTF-8 format string.
447 		 * The number of bytes in the SCSI NAME STRING field
448 		 * (i.e., the value in the DESIGNATOR LENGTH field)
449 		 * shall be no larger than 256 and shall be a multiple
450 		 * of four.
451 		 */
452 		padding = ((-scsi_target_len) & 3);
453 		if (padding)
454 			scsi_target_len += padding;
455 		if (scsi_target_len > 256)
456 			scsi_target_len = 256;
457 
458 		buf[off-1] = scsi_target_len;
459 		off += scsi_target_len;
460 
461 		/* Header size + Designation descriptor */
462 		len += (scsi_target_len + 4);
463 	}
464 	put_unaligned_be16(len, &buf[2]); /* Page Length for VPD 0x83 */
465 	return 0;
466 }
467 EXPORT_SYMBOL(spc_emulate_evpd_83);
468 
469 /* Extended INQUIRY Data VPD Page */
470 static sense_reason_t
471 spc_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf)
472 {
473 	struct se_device *dev = cmd->se_dev;
474 	struct se_session *sess = cmd->se_sess;
475 
476 	buf[3] = 0x3c;
477 	/*
478 	 * Set GRD_CHK + REF_CHK for TYPE1 protection, or GRD_CHK
479 	 * only for TYPE3 protection.
480 	 */
481 	if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
482 		if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE1_PROT ||
483 		    cmd->se_sess->sess_prot_type == TARGET_DIF_TYPE1_PROT)
484 			buf[4] = 0x5;
485 		else if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE3_PROT ||
486 			 cmd->se_sess->sess_prot_type == TARGET_DIF_TYPE3_PROT)
487 			buf[4] = 0x4;
488 	}
489 
490 	/* logical unit supports type 1 and type 3 protection */
491 	if ((dev->transport->get_device_type(dev) == TYPE_DISK) &&
492 	    (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) &&
493 	    (dev->dev_attrib.pi_prot_type || cmd->se_sess->sess_prot_type)) {
494 		buf[4] |= (0x3 << 3);
495 	}
496 
497 	/* Set HEADSUP, ORDSUP, SIMPSUP */
498 	buf[5] = 0x07;
499 
500 	/* If WriteCache emulation is enabled, set V_SUP */
501 	if (target_check_wce(dev))
502 		buf[6] = 0x01;
503 	/* If an LBA map is present set R_SUP */
504 	spin_lock(&cmd->se_dev->t10_alua.lba_map_lock);
505 	if (!list_empty(&dev->t10_alua.lba_map_list))
506 		buf[8] = 0x10;
507 	spin_unlock(&cmd->se_dev->t10_alua.lba_map_lock);
508 	return 0;
509 }
510 
511 /* Block Limits VPD page */
512 static sense_reason_t
513 spc_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)
514 {
515 	struct se_device *dev = cmd->se_dev;
516 	u32 mtl = 0;
517 	int have_tp = 0, opt, min;
518 	u32 io_max_blocks;
519 
520 	/*
521 	 * Following spc3r22 section 6.5.3 Block Limits VPD page, when
522 	 * emulate_tpu=1 or emulate_tpws=1 we will be expect a
523 	 * different page length for Thin Provisioning.
524 	 */
525 	if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws)
526 		have_tp = 1;
527 
528 	buf[0] = dev->transport->get_device_type(dev);
529 	buf[3] = have_tp ? 0x3c : 0x10;
530 
531 	/* Set WSNZ to 1 */
532 	buf[4] = 0x01;
533 	/*
534 	 * Set MAXIMUM COMPARE AND WRITE LENGTH
535 	 */
536 	if (dev->dev_attrib.emulate_caw)
537 		buf[5] = 0x01;
538 
539 	/*
540 	 * Set OPTIMAL TRANSFER LENGTH GRANULARITY
541 	 */
542 	if (dev->transport->get_io_min && (min = dev->transport->get_io_min(dev)))
543 		put_unaligned_be16(min / dev->dev_attrib.block_size, &buf[6]);
544 	else
545 		put_unaligned_be16(1, &buf[6]);
546 
547 	/*
548 	 * Set MAXIMUM TRANSFER LENGTH
549 	 *
550 	 * XXX: Currently assumes single PAGE_SIZE per scatterlist for fabrics
551 	 * enforcing maximum HW scatter-gather-list entry limit
552 	 */
553 	if (cmd->se_tfo->max_data_sg_nents) {
554 		mtl = (cmd->se_tfo->max_data_sg_nents * PAGE_SIZE) /
555 		       dev->dev_attrib.block_size;
556 	}
557 	io_max_blocks = mult_frac(dev->dev_attrib.hw_max_sectors,
558 			dev->dev_attrib.hw_block_size,
559 			dev->dev_attrib.block_size);
560 	put_unaligned_be32(min_not_zero(mtl, io_max_blocks), &buf[8]);
561 
562 	/*
563 	 * Set OPTIMAL TRANSFER LENGTH
564 	 */
565 	if (dev->transport->get_io_opt && (opt = dev->transport->get_io_opt(dev)))
566 		put_unaligned_be32(opt / dev->dev_attrib.block_size, &buf[12]);
567 	else
568 		put_unaligned_be32(dev->dev_attrib.optimal_sectors, &buf[12]);
569 
570 	/*
571 	 * Exit now if we don't support TP.
572 	 */
573 	if (!have_tp)
574 		goto max_write_same;
575 
576 	/*
577 	 * Set MAXIMUM UNMAP LBA COUNT
578 	 */
579 	put_unaligned_be32(dev->dev_attrib.max_unmap_lba_count, &buf[20]);
580 
581 	/*
582 	 * Set MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT
583 	 */
584 	put_unaligned_be32(dev->dev_attrib.max_unmap_block_desc_count,
585 			   &buf[24]);
586 
587 	/*
588 	 * Set OPTIMAL UNMAP GRANULARITY
589 	 */
590 	put_unaligned_be32(dev->dev_attrib.unmap_granularity, &buf[28]);
591 
592 	/*
593 	 * UNMAP GRANULARITY ALIGNMENT
594 	 */
595 	put_unaligned_be32(dev->dev_attrib.unmap_granularity_alignment,
596 			   &buf[32]);
597 	if (dev->dev_attrib.unmap_granularity_alignment != 0)
598 		buf[32] |= 0x80; /* Set the UGAVALID bit */
599 
600 	/*
601 	 * MAXIMUM WRITE SAME LENGTH
602 	 */
603 max_write_same:
604 	put_unaligned_be64(dev->dev_attrib.max_write_same_len, &buf[36]);
605 
606 	return 0;
607 }
608 
609 /* Block Device Characteristics VPD page */
610 static sense_reason_t
611 spc_emulate_evpd_b1(struct se_cmd *cmd, unsigned char *buf)
612 {
613 	struct se_device *dev = cmd->se_dev;
614 
615 	buf[0] = dev->transport->get_device_type(dev);
616 	buf[3] = 0x3c;
617 	buf[5] = dev->dev_attrib.is_nonrot ? 1 : 0;
618 
619 	return 0;
620 }
621 
622 /* Thin Provisioning VPD */
623 static sense_reason_t
624 spc_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf)
625 {
626 	struct se_device *dev = cmd->se_dev;
627 
628 	/*
629 	 * From spc3r22 section 6.5.4 Thin Provisioning VPD page:
630 	 *
631 	 * The PAGE LENGTH field is defined in SPC-4. If the DP bit is set to
632 	 * zero, then the page length shall be set to 0004h.  If the DP bit
633 	 * is set to one, then the page length shall be set to the value
634 	 * defined in table 162.
635 	 */
636 	buf[0] = dev->transport->get_device_type(dev);
637 
638 	/*
639 	 * Set Hardcoded length mentioned above for DP=0
640 	 */
641 	put_unaligned_be16(0x0004, &buf[2]);
642 
643 	/*
644 	 * The THRESHOLD EXPONENT field indicates the threshold set size in
645 	 * LBAs as a power of 2 (i.e., the threshold set size is equal to
646 	 * 2(threshold exponent)).
647 	 *
648 	 * Note that this is currently set to 0x00 as mkp says it will be
649 	 * changing again.  We can enable this once it has settled in T10
650 	 * and is actually used by Linux/SCSI ML code.
651 	 */
652 	buf[4] = 0x00;
653 
654 	/*
655 	 * A TPU bit set to one indicates that the device server supports
656 	 * the UNMAP command (see 5.25). A TPU bit set to zero indicates
657 	 * that the device server does not support the UNMAP command.
658 	 */
659 	if (dev->dev_attrib.emulate_tpu != 0)
660 		buf[5] = 0x80;
661 
662 	/*
663 	 * A TPWS bit set to one indicates that the device server supports
664 	 * the use of the WRITE SAME (16) command (see 5.42) to unmap LBAs.
665 	 * A TPWS bit set to zero indicates that the device server does not
666 	 * support the use of the WRITE SAME (16) command to unmap LBAs.
667 	 */
668 	if (dev->dev_attrib.emulate_tpws != 0)
669 		buf[5] |= 0x40 | 0x20;
670 
671 	/*
672 	 * The unmap_zeroes_data set means that the underlying device supports
673 	 * REQ_OP_DISCARD and has the discard_zeroes_data bit set. This
674 	 * satisfies the SBC requirements for LBPRZ, meaning that a subsequent
675 	 * read will return zeroes after an UNMAP or WRITE SAME (16) to an LBA
676 	 * See sbc4r36 6.6.4.
677 	 */
678 	if (((dev->dev_attrib.emulate_tpu != 0) ||
679 	     (dev->dev_attrib.emulate_tpws != 0)) &&
680 	     (dev->dev_attrib.unmap_zeroes_data != 0))
681 		buf[5] |= 0x04;
682 
683 	return 0;
684 }
685 
686 /* Referrals VPD page */
687 static sense_reason_t
688 spc_emulate_evpd_b3(struct se_cmd *cmd, unsigned char *buf)
689 {
690 	struct se_device *dev = cmd->se_dev;
691 
692 	buf[0] = dev->transport->get_device_type(dev);
693 	buf[3] = 0x0c;
694 	put_unaligned_be32(dev->t10_alua.lba_map_segment_size, &buf[8]);
695 	put_unaligned_be32(dev->t10_alua.lba_map_segment_multiplier, &buf[12]);
696 
697 	return 0;
698 }
699 
700 static sense_reason_t
701 spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf);
702 
703 static struct {
704 	uint8_t		page;
705 	sense_reason_t	(*emulate)(struct se_cmd *, unsigned char *);
706 } evpd_handlers[] = {
707 	{ .page = 0x00, .emulate = spc_emulate_evpd_00 },
708 	{ .page = 0x80, .emulate = spc_emulate_evpd_80 },
709 	{ .page = 0x83, .emulate = spc_emulate_evpd_83 },
710 	{ .page = 0x86, .emulate = spc_emulate_evpd_86 },
711 	{ .page = 0xb0, .emulate = spc_emulate_evpd_b0 },
712 	{ .page = 0xb1, .emulate = spc_emulate_evpd_b1 },
713 	{ .page = 0xb2, .emulate = spc_emulate_evpd_b2 },
714 	{ .page = 0xb3, .emulate = spc_emulate_evpd_b3 },
715 };
716 
717 /* supported vital product data pages */
718 static sense_reason_t
719 spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf)
720 {
721 	int p;
722 
723 	/*
724 	 * Only report the INQUIRY EVPD=1 pages after a valid NAA
725 	 * Registered Extended LUN WWN has been set via ConfigFS
726 	 * during device creation/restart.
727 	 */
728 	if (cmd->se_dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
729 		buf[3] = ARRAY_SIZE(evpd_handlers);
730 		for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p)
731 			buf[p + 4] = evpd_handlers[p].page;
732 	}
733 
734 	return 0;
735 }
736 
737 static sense_reason_t
738 spc_emulate_inquiry(struct se_cmd *cmd)
739 {
740 	struct se_device *dev = cmd->se_dev;
741 	unsigned char *rbuf;
742 	unsigned char *cdb = cmd->t_task_cdb;
743 	unsigned char *buf;
744 	sense_reason_t ret;
745 	int p;
746 	int len = 0;
747 
748 	buf = kzalloc(SE_INQUIRY_BUF, GFP_KERNEL);
749 	if (!buf) {
750 		pr_err("Unable to allocate response buffer for INQUIRY\n");
751 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
752 	}
753 
754 	buf[0] = dev->transport->get_device_type(dev);
755 
756 	if (!(cdb[1] & 0x1)) {
757 		if (cdb[2]) {
758 			pr_err("INQUIRY with EVPD==0 but PAGE CODE=%02x\n",
759 			       cdb[2]);
760 			ret = TCM_INVALID_CDB_FIELD;
761 			goto out;
762 		}
763 
764 		ret = spc_emulate_inquiry_std(cmd, buf);
765 		len = buf[4] + 5;
766 		goto out;
767 	}
768 
769 	for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p) {
770 		if (cdb[2] == evpd_handlers[p].page) {
771 			buf[1] = cdb[2];
772 			ret = evpd_handlers[p].emulate(cmd, buf);
773 			len = get_unaligned_be16(&buf[2]) + 4;
774 			goto out;
775 		}
776 	}
777 
778 	pr_debug("Unknown VPD Code: 0x%02x\n", cdb[2]);
779 	ret = TCM_INVALID_CDB_FIELD;
780 
781 out:
782 	rbuf = transport_kmap_data_sg(cmd);
783 	if (rbuf) {
784 		memcpy(rbuf, buf, min_t(u32, SE_INQUIRY_BUF, cmd->data_length));
785 		transport_kunmap_data_sg(cmd);
786 	}
787 	kfree(buf);
788 
789 	if (!ret)
790 		target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, len);
791 	return ret;
792 }
793 
794 static int spc_modesense_rwrecovery(struct se_cmd *cmd, u8 pc, u8 *p)
795 {
796 	p[0] = 0x01;
797 	p[1] = 0x0a;
798 
799 	/* No changeable values for now */
800 	if (pc == 1)
801 		goto out;
802 
803 out:
804 	return 12;
805 }
806 
807 static int spc_modesense_control(struct se_cmd *cmd, u8 pc, u8 *p)
808 {
809 	struct se_device *dev = cmd->se_dev;
810 	struct se_session *sess = cmd->se_sess;
811 
812 	p[0] = 0x0a;
813 	p[1] = 0x0a;
814 
815 	/* No changeable values for now */
816 	if (pc == 1)
817 		goto out;
818 
819 	/* GLTSD: No implicit save of log parameters */
820 	p[2] = (1 << 1);
821 	if (target_sense_desc_format(dev))
822 		/* D_SENSE: Descriptor format sense data for 64bit sectors */
823 		p[2] |= (1 << 2);
824 
825 	/*
826 	 * From spc4r23, 7.4.7 Control mode page
827 	 *
828 	 * The QUEUE ALGORITHM MODIFIER field (see table 368) specifies
829 	 * restrictions on the algorithm used for reordering commands
830 	 * having the SIMPLE task attribute (see SAM-4).
831 	 *
832 	 *                    Table 368 -- QUEUE ALGORITHM MODIFIER field
833 	 *                         Code      Description
834 	 *                          0h       Restricted reordering
835 	 *                          1h       Unrestricted reordering allowed
836 	 *                          2h to 7h    Reserved
837 	 *                          8h to Fh    Vendor specific
838 	 *
839 	 * A value of zero in the QUEUE ALGORITHM MODIFIER field specifies that
840 	 * the device server shall order the processing sequence of commands
841 	 * having the SIMPLE task attribute such that data integrity is maintained
842 	 * for that I_T nexus (i.e., if the transmission of new SCSI transport protocol
843 	 * requests is halted at any time, the final value of all data observable
844 	 * on the medium shall be the same as if all the commands had been processed
845 	 * with the ORDERED task attribute).
846 	 *
847 	 * A value of one in the QUEUE ALGORITHM MODIFIER field specifies that the
848 	 * device server may reorder the processing sequence of commands having the
849 	 * SIMPLE task attribute in any manner. Any data integrity exposures related to
850 	 * command sequence order shall be explicitly handled by the application client
851 	 * through the selection of appropriate ommands and task attributes.
852 	 */
853 	p[3] = (dev->dev_attrib.emulate_rest_reord == 1) ? 0x00 : 0x10;
854 	/*
855 	 * From spc4r17, section 7.4.6 Control mode Page
856 	 *
857 	 * Unit Attention interlocks control (UN_INTLCK_CTRL) to code 00b
858 	 *
859 	 * 00b: The logical unit shall clear any unit attention condition
860 	 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
861 	 * status and shall not establish a unit attention condition when a com-
862 	 * mand is completed with BUSY, TASK SET FULL, or RESERVATION CONFLICT
863 	 * status.
864 	 *
865 	 * 10b: The logical unit shall not clear any unit attention condition
866 	 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
867 	 * status and shall not establish a unit attention condition when
868 	 * a command is completed with BUSY, TASK SET FULL, or RESERVATION
869 	 * CONFLICT status.
870 	 *
871 	 * 11b a The logical unit shall not clear any unit attention condition
872 	 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
873 	 * status and shall establish a unit attention condition for the
874 	 * initiator port associated with the I_T nexus on which the BUSY,
875 	 * TASK SET FULL, or RESERVATION CONFLICT status is being returned.
876 	 * Depending on the status, the additional sense code shall be set to
877 	 * PREVIOUS BUSY STATUS, PREVIOUS TASK SET FULL STATUS, or PREVIOUS
878 	 * RESERVATION CONFLICT STATUS. Until it is cleared by a REQUEST SENSE
879 	 * command, a unit attention condition shall be established only once
880 	 * for a BUSY, TASK SET FULL, or RESERVATION CONFLICT status regardless
881 	 * to the number of commands completed with one of those status codes.
882 	 */
883 	switch (dev->dev_attrib.emulate_ua_intlck_ctrl) {
884 	case TARGET_UA_INTLCK_CTRL_ESTABLISH_UA:
885 		p[4] = 0x30;
886 		break;
887 	case TARGET_UA_INTLCK_CTRL_NO_CLEAR:
888 		p[4] = 0x20;
889 		break;
890 	default:	/* TARGET_UA_INTLCK_CTRL_CLEAR */
891 		p[4] = 0x00;
892 		break;
893 	}
894 	/*
895 	 * From spc4r17, section 7.4.6 Control mode Page
896 	 *
897 	 * Task Aborted Status (TAS) bit set to zero.
898 	 *
899 	 * A task aborted status (TAS) bit set to zero specifies that aborted
900 	 * tasks shall be terminated by the device server without any response
901 	 * to the application client. A TAS bit set to one specifies that tasks
902 	 * aborted by the actions of an I_T nexus other than the I_T nexus on
903 	 * which the command was received shall be completed with TASK ABORTED
904 	 * status (see SAM-4).
905 	 */
906 	p[5] = (dev->dev_attrib.emulate_tas) ? 0x40 : 0x00;
907 	/*
908 	 * From spc4r30, section 7.5.7 Control mode page
909 	 *
910 	 * Application Tag Owner (ATO) bit set to one.
911 	 *
912 	 * If the ATO bit is set to one the device server shall not modify the
913 	 * LOGICAL BLOCK APPLICATION TAG field and, depending on the protection
914 	 * type, shall not modify the contents of the LOGICAL BLOCK REFERENCE
915 	 * TAG field.
916 	 */
917 	if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
918 		if (dev->dev_attrib.pi_prot_type || sess->sess_prot_type)
919 			p[5] |= 0x80;
920 	}
921 
922 	p[8] = 0xff;
923 	p[9] = 0xff;
924 	p[11] = 30;
925 
926 out:
927 	return 12;
928 }
929 
930 static int spc_modesense_caching(struct se_cmd *cmd, u8 pc, u8 *p)
931 {
932 	struct se_device *dev = cmd->se_dev;
933 
934 	p[0] = 0x08;
935 	p[1] = 0x12;
936 
937 	/* No changeable values for now */
938 	if (pc == 1)
939 		goto out;
940 
941 	if (target_check_wce(dev))
942 		p[2] = 0x04; /* Write Cache Enable */
943 	p[12] = 0x20; /* Disabled Read Ahead */
944 
945 out:
946 	return 20;
947 }
948 
949 static int spc_modesense_informational_exceptions(struct se_cmd *cmd, u8 pc, unsigned char *p)
950 {
951 	p[0] = 0x1c;
952 	p[1] = 0x0a;
953 
954 	/* No changeable values for now */
955 	if (pc == 1)
956 		goto out;
957 
958 out:
959 	return 12;
960 }
961 
962 static struct {
963 	uint8_t		page;
964 	uint8_t		subpage;
965 	int		(*emulate)(struct se_cmd *, u8, unsigned char *);
966 } modesense_handlers[] = {
967 	{ .page = 0x01, .subpage = 0x00, .emulate = spc_modesense_rwrecovery },
968 	{ .page = 0x08, .subpage = 0x00, .emulate = spc_modesense_caching },
969 	{ .page = 0x0a, .subpage = 0x00, .emulate = spc_modesense_control },
970 	{ .page = 0x1c, .subpage = 0x00, .emulate = spc_modesense_informational_exceptions },
971 };
972 
973 static void spc_modesense_write_protect(unsigned char *buf, int type)
974 {
975 	/*
976 	 * I believe that the WP bit (bit 7) in the mode header is the same for
977 	 * all device types..
978 	 */
979 	switch (type) {
980 	case TYPE_DISK:
981 	case TYPE_TAPE:
982 	default:
983 		buf[0] |= 0x80; /* WP bit */
984 		break;
985 	}
986 }
987 
988 static void spc_modesense_dpofua(unsigned char *buf, int type)
989 {
990 	switch (type) {
991 	case TYPE_DISK:
992 		buf[0] |= 0x10; /* DPOFUA bit */
993 		break;
994 	default:
995 		break;
996 	}
997 }
998 
999 static int spc_modesense_blockdesc(unsigned char *buf, u64 blocks, u32 block_size)
1000 {
1001 	*buf++ = 8;
1002 	put_unaligned_be32(min(blocks, 0xffffffffull), buf);
1003 	buf += 4;
1004 	put_unaligned_be32(block_size, buf);
1005 	return 9;
1006 }
1007 
1008 static int spc_modesense_long_blockdesc(unsigned char *buf, u64 blocks, u32 block_size)
1009 {
1010 	if (blocks <= 0xffffffff)
1011 		return spc_modesense_blockdesc(buf + 3, blocks, block_size) + 3;
1012 
1013 	*buf++ = 1;		/* LONGLBA */
1014 	buf += 2;
1015 	*buf++ = 16;
1016 	put_unaligned_be64(blocks, buf);
1017 	buf += 12;
1018 	put_unaligned_be32(block_size, buf);
1019 
1020 	return 17;
1021 }
1022 
1023 static sense_reason_t spc_emulate_modesense(struct se_cmd *cmd)
1024 {
1025 	struct se_device *dev = cmd->se_dev;
1026 	char *cdb = cmd->t_task_cdb;
1027 	unsigned char buf[SE_MODE_PAGE_BUF], *rbuf;
1028 	int type = dev->transport->get_device_type(dev);
1029 	int ten = (cmd->t_task_cdb[0] == MODE_SENSE_10);
1030 	bool dbd = !!(cdb[1] & 0x08);
1031 	bool llba = ten ? !!(cdb[1] & 0x10) : false;
1032 	u8 pc = cdb[2] >> 6;
1033 	u8 page = cdb[2] & 0x3f;
1034 	u8 subpage = cdb[3];
1035 	int length = 0;
1036 	int ret;
1037 	int i;
1038 
1039 	memset(buf, 0, SE_MODE_PAGE_BUF);
1040 
1041 	/*
1042 	 * Skip over MODE DATA LENGTH + MEDIUM TYPE fields to byte 3 for
1043 	 * MODE_SENSE_10 and byte 2 for MODE_SENSE (6).
1044 	 */
1045 	length = ten ? 3 : 2;
1046 
1047 	/* DEVICE-SPECIFIC PARAMETER */
1048 	if (cmd->se_lun->lun_access_ro || target_lun_is_rdonly(cmd))
1049 		spc_modesense_write_protect(&buf[length], type);
1050 
1051 	/*
1052 	 * SBC only allows us to enable FUA and DPO together.  Fortunately
1053 	 * DPO is explicitly specified as a hint, so a noop is a perfectly
1054 	 * valid implementation.
1055 	 */
1056 	if (target_check_fua(dev))
1057 		spc_modesense_dpofua(&buf[length], type);
1058 
1059 	++length;
1060 
1061 	/* BLOCK DESCRIPTOR */
1062 
1063 	/*
1064 	 * For now we only include a block descriptor for disk (SBC)
1065 	 * devices; other command sets use a slightly different format.
1066 	 */
1067 	if (!dbd && type == TYPE_DISK) {
1068 		u64 blocks = dev->transport->get_blocks(dev);
1069 		u32 block_size = dev->dev_attrib.block_size;
1070 
1071 		if (ten) {
1072 			if (llba) {
1073 				length += spc_modesense_long_blockdesc(&buf[length],
1074 								       blocks, block_size);
1075 			} else {
1076 				length += 3;
1077 				length += spc_modesense_blockdesc(&buf[length],
1078 								  blocks, block_size);
1079 			}
1080 		} else {
1081 			length += spc_modesense_blockdesc(&buf[length], blocks,
1082 							  block_size);
1083 		}
1084 	} else {
1085 		if (ten)
1086 			length += 4;
1087 		else
1088 			length += 1;
1089 	}
1090 
1091 	if (page == 0x3f) {
1092 		if (subpage != 0x00 && subpage != 0xff) {
1093 			pr_warn("MODE_SENSE: Invalid subpage code: 0x%02x\n", subpage);
1094 			return TCM_INVALID_CDB_FIELD;
1095 		}
1096 
1097 		for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i) {
1098 			/*
1099 			 * Tricky way to say all subpage 00h for
1100 			 * subpage==0, all subpages for subpage==0xff
1101 			 * (and we just checked above that those are
1102 			 * the only two possibilities).
1103 			 */
1104 			if ((modesense_handlers[i].subpage & ~subpage) == 0) {
1105 				ret = modesense_handlers[i].emulate(cmd, pc, &buf[length]);
1106 				if (!ten && length + ret >= 255)
1107 					break;
1108 				length += ret;
1109 			}
1110 		}
1111 
1112 		goto set_length;
1113 	}
1114 
1115 	for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i)
1116 		if (modesense_handlers[i].page == page &&
1117 		    modesense_handlers[i].subpage == subpage) {
1118 			length += modesense_handlers[i].emulate(cmd, pc, &buf[length]);
1119 			goto set_length;
1120 		}
1121 
1122 	/*
1123 	 * We don't intend to implement:
1124 	 *  - obsolete page 03h "format parameters" (checked by Solaris)
1125 	 */
1126 	if (page != 0x03)
1127 		pr_err("MODE SENSE: unimplemented page/subpage: 0x%02x/0x%02x\n",
1128 		       page, subpage);
1129 
1130 	return TCM_UNKNOWN_MODE_PAGE;
1131 
1132 set_length:
1133 	if (ten)
1134 		put_unaligned_be16(length - 2, buf);
1135 	else
1136 		buf[0] = length - 1;
1137 
1138 	rbuf = transport_kmap_data_sg(cmd);
1139 	if (rbuf) {
1140 		memcpy(rbuf, buf, min_t(u32, SE_MODE_PAGE_BUF, cmd->data_length));
1141 		transport_kunmap_data_sg(cmd);
1142 	}
1143 
1144 	target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, length);
1145 	return 0;
1146 }
1147 
1148 static sense_reason_t spc_emulate_modeselect(struct se_cmd *cmd)
1149 {
1150 	char *cdb = cmd->t_task_cdb;
1151 	bool ten = cdb[0] == MODE_SELECT_10;
1152 	int off = ten ? 8 : 4;
1153 	bool pf = !!(cdb[1] & 0x10);
1154 	u8 page, subpage;
1155 	unsigned char *buf;
1156 	unsigned char tbuf[SE_MODE_PAGE_BUF];
1157 	int length;
1158 	sense_reason_t ret = 0;
1159 	int i;
1160 
1161 	if (!cmd->data_length) {
1162 		target_complete_cmd(cmd, SAM_STAT_GOOD);
1163 		return 0;
1164 	}
1165 
1166 	if (cmd->data_length < off + 2)
1167 		return TCM_PARAMETER_LIST_LENGTH_ERROR;
1168 
1169 	buf = transport_kmap_data_sg(cmd);
1170 	if (!buf)
1171 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1172 
1173 	if (!pf) {
1174 		ret = TCM_INVALID_CDB_FIELD;
1175 		goto out;
1176 	}
1177 
1178 	page = buf[off] & 0x3f;
1179 	subpage = buf[off] & 0x40 ? buf[off + 1] : 0;
1180 
1181 	for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i)
1182 		if (modesense_handlers[i].page == page &&
1183 		    modesense_handlers[i].subpage == subpage) {
1184 			memset(tbuf, 0, SE_MODE_PAGE_BUF);
1185 			length = modesense_handlers[i].emulate(cmd, 0, tbuf);
1186 			goto check_contents;
1187 		}
1188 
1189 	ret = TCM_UNKNOWN_MODE_PAGE;
1190 	goto out;
1191 
1192 check_contents:
1193 	if (cmd->data_length < off + length) {
1194 		ret = TCM_PARAMETER_LIST_LENGTH_ERROR;
1195 		goto out;
1196 	}
1197 
1198 	if (memcmp(buf + off, tbuf, length))
1199 		ret = TCM_INVALID_PARAMETER_LIST;
1200 
1201 out:
1202 	transport_kunmap_data_sg(cmd);
1203 
1204 	if (!ret)
1205 		target_complete_cmd(cmd, SAM_STAT_GOOD);
1206 	return ret;
1207 }
1208 
1209 static sense_reason_t spc_emulate_request_sense(struct se_cmd *cmd)
1210 {
1211 	unsigned char *cdb = cmd->t_task_cdb;
1212 	unsigned char *rbuf;
1213 	u8 ua_asc = 0, ua_ascq = 0;
1214 	unsigned char buf[SE_SENSE_BUF];
1215 	bool desc_format = target_sense_desc_format(cmd->se_dev);
1216 
1217 	memset(buf, 0, SE_SENSE_BUF);
1218 
1219 	if (cdb[1] & 0x01) {
1220 		pr_err("REQUEST_SENSE description emulation not"
1221 			" supported\n");
1222 		return TCM_INVALID_CDB_FIELD;
1223 	}
1224 
1225 	rbuf = transport_kmap_data_sg(cmd);
1226 	if (!rbuf)
1227 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1228 
1229 	if (!core_scsi3_ua_clear_for_request_sense(cmd, &ua_asc, &ua_ascq))
1230 		scsi_build_sense_buffer(desc_format, buf, UNIT_ATTENTION,
1231 					ua_asc, ua_ascq);
1232 	else
1233 		scsi_build_sense_buffer(desc_format, buf, NO_SENSE, 0x0, 0x0);
1234 
1235 	memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
1236 	transport_kunmap_data_sg(cmd);
1237 
1238 	target_complete_cmd(cmd, SAM_STAT_GOOD);
1239 	return 0;
1240 }
1241 
1242 sense_reason_t spc_emulate_report_luns(struct se_cmd *cmd)
1243 {
1244 	struct se_dev_entry *deve;
1245 	struct se_session *sess = cmd->se_sess;
1246 	struct se_node_acl *nacl;
1247 	struct scsi_lun slun;
1248 	unsigned char *buf;
1249 	u32 lun_count = 0, offset = 8;
1250 	__be32 len;
1251 
1252 	buf = transport_kmap_data_sg(cmd);
1253 	if (cmd->data_length && !buf)
1254 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1255 
1256 	/*
1257 	 * If no struct se_session pointer is present, this struct se_cmd is
1258 	 * coming via a target_core_mod PASSTHROUGH op, and not through
1259 	 * a $FABRIC_MOD.  In that case, report LUN=0 only.
1260 	 */
1261 	if (!sess)
1262 		goto done;
1263 
1264 	nacl = sess->se_node_acl;
1265 
1266 	rcu_read_lock();
1267 	hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) {
1268 		/*
1269 		 * We determine the correct LUN LIST LENGTH even once we
1270 		 * have reached the initial allocation length.
1271 		 * See SPC2-R20 7.19.
1272 		 */
1273 		lun_count++;
1274 		if (offset >= cmd->data_length)
1275 			continue;
1276 
1277 		int_to_scsilun(deve->mapped_lun, &slun);
1278 		memcpy(buf + offset, &slun,
1279 		       min(8u, cmd->data_length - offset));
1280 		offset += 8;
1281 	}
1282 	rcu_read_unlock();
1283 
1284 	/*
1285 	 * See SPC3 r07, page 159.
1286 	 */
1287 done:
1288 	/*
1289 	 * If no LUNs are accessible, report virtual LUN 0.
1290 	 */
1291 	if (lun_count == 0) {
1292 		int_to_scsilun(0, &slun);
1293 		if (cmd->data_length > 8)
1294 			memcpy(buf + offset, &slun,
1295 			       min(8u, cmd->data_length - offset));
1296 		lun_count = 1;
1297 	}
1298 
1299 	if (buf) {
1300 		len = cpu_to_be32(lun_count * 8);
1301 		memcpy(buf, &len, min_t(int, sizeof len, cmd->data_length));
1302 		transport_kunmap_data_sg(cmd);
1303 	}
1304 
1305 	target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, 8 + lun_count * 8);
1306 	return 0;
1307 }
1308 EXPORT_SYMBOL(spc_emulate_report_luns);
1309 
1310 static sense_reason_t
1311 spc_emulate_testunitready(struct se_cmd *cmd)
1312 {
1313 	target_complete_cmd(cmd, SAM_STAT_GOOD);
1314 	return 0;
1315 }
1316 
1317 static void set_dpofua_usage_bits(u8 *usage_bits, struct se_device *dev)
1318 {
1319 	if (!target_check_fua(dev))
1320 		usage_bits[1] &= ~0x18;
1321 	else
1322 		usage_bits[1] |= 0x18;
1323 }
1324 
1325 static void set_dpofua_usage_bits32(u8 *usage_bits, struct se_device *dev)
1326 {
1327 	if (!target_check_fua(dev))
1328 		usage_bits[10] &= ~0x18;
1329 	else
1330 		usage_bits[10] |= 0x18;
1331 }
1332 
1333 static struct target_opcode_descriptor tcm_opcode_read6 = {
1334 	.support = SCSI_SUPPORT_FULL,
1335 	.opcode = READ_6,
1336 	.cdb_size = 6,
1337 	.usage_bits = {READ_6, 0x1f, 0xff, 0xff,
1338 		       0xff, SCSI_CONTROL_MASK},
1339 };
1340 
1341 static struct target_opcode_descriptor tcm_opcode_read10 = {
1342 	.support = SCSI_SUPPORT_FULL,
1343 	.opcode = READ_10,
1344 	.cdb_size = 10,
1345 	.usage_bits = {READ_10, 0xf8, 0xff, 0xff,
1346 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, 0xff,
1347 		       0xff, SCSI_CONTROL_MASK},
1348 	.update_usage_bits = set_dpofua_usage_bits,
1349 };
1350 
1351 static struct target_opcode_descriptor tcm_opcode_read12 = {
1352 	.support = SCSI_SUPPORT_FULL,
1353 	.opcode = READ_12,
1354 	.cdb_size = 12,
1355 	.usage_bits = {READ_12, 0xf8, 0xff, 0xff,
1356 		       0xff, 0xff, 0xff, 0xff,
1357 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
1358 	.update_usage_bits = set_dpofua_usage_bits,
1359 };
1360 
1361 static struct target_opcode_descriptor tcm_opcode_read16 = {
1362 	.support = SCSI_SUPPORT_FULL,
1363 	.opcode = READ_16,
1364 	.cdb_size = 16,
1365 	.usage_bits = {READ_16, 0xf8, 0xff, 0xff,
1366 		       0xff, 0xff, 0xff, 0xff,
1367 		       0xff, 0xff, 0xff, 0xff,
1368 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
1369 	.update_usage_bits = set_dpofua_usage_bits,
1370 };
1371 
1372 static struct target_opcode_descriptor tcm_opcode_write6 = {
1373 	.support = SCSI_SUPPORT_FULL,
1374 	.opcode = WRITE_6,
1375 	.cdb_size = 6,
1376 	.usage_bits = {WRITE_6, 0x1f, 0xff, 0xff,
1377 		       0xff, SCSI_CONTROL_MASK},
1378 };
1379 
1380 static struct target_opcode_descriptor tcm_opcode_write10 = {
1381 	.support = SCSI_SUPPORT_FULL,
1382 	.opcode = WRITE_10,
1383 	.cdb_size = 10,
1384 	.usage_bits = {WRITE_10, 0xf8, 0xff, 0xff,
1385 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, 0xff,
1386 		       0xff, SCSI_CONTROL_MASK},
1387 	.update_usage_bits = set_dpofua_usage_bits,
1388 };
1389 
1390 static struct target_opcode_descriptor tcm_opcode_write_verify10 = {
1391 	.support = SCSI_SUPPORT_FULL,
1392 	.opcode = WRITE_VERIFY,
1393 	.cdb_size = 10,
1394 	.usage_bits = {WRITE_VERIFY, 0xf0, 0xff, 0xff,
1395 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, 0xff,
1396 		       0xff, SCSI_CONTROL_MASK},
1397 	.update_usage_bits = set_dpofua_usage_bits,
1398 };
1399 
1400 static struct target_opcode_descriptor tcm_opcode_write12 = {
1401 	.support = SCSI_SUPPORT_FULL,
1402 	.opcode = WRITE_12,
1403 	.cdb_size = 12,
1404 	.usage_bits = {WRITE_12, 0xf8, 0xff, 0xff,
1405 		       0xff, 0xff, 0xff, 0xff,
1406 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
1407 	.update_usage_bits = set_dpofua_usage_bits,
1408 };
1409 
1410 static struct target_opcode_descriptor tcm_opcode_write16 = {
1411 	.support = SCSI_SUPPORT_FULL,
1412 	.opcode = WRITE_16,
1413 	.cdb_size = 16,
1414 	.usage_bits = {WRITE_16, 0xf8, 0xff, 0xff,
1415 		       0xff, 0xff, 0xff, 0xff,
1416 		       0xff, 0xff, 0xff, 0xff,
1417 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
1418 	.update_usage_bits = set_dpofua_usage_bits,
1419 };
1420 
1421 static struct target_opcode_descriptor tcm_opcode_write_verify16 = {
1422 	.support = SCSI_SUPPORT_FULL,
1423 	.opcode = WRITE_VERIFY_16,
1424 	.cdb_size = 16,
1425 	.usage_bits = {WRITE_VERIFY_16, 0xf0, 0xff, 0xff,
1426 		       0xff, 0xff, 0xff, 0xff,
1427 		       0xff, 0xff, 0xff, 0xff,
1428 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
1429 	.update_usage_bits = set_dpofua_usage_bits,
1430 };
1431 
1432 static bool tcm_is_ws_enabled(struct se_cmd *cmd)
1433 {
1434 	struct sbc_ops *ops = cmd->protocol_data;
1435 	struct se_device *dev = cmd->se_dev;
1436 
1437 	return (dev->dev_attrib.emulate_tpws && !!ops->execute_unmap) ||
1438 	       !!ops->execute_write_same;
1439 }
1440 
1441 static struct target_opcode_descriptor tcm_opcode_write_same32 = {
1442 	.support = SCSI_SUPPORT_FULL,
1443 	.serv_action_valid = 1,
1444 	.opcode = VARIABLE_LENGTH_CMD,
1445 	.service_action = WRITE_SAME_32,
1446 	.cdb_size = 32,
1447 	.usage_bits = {VARIABLE_LENGTH_CMD, SCSI_CONTROL_MASK, 0x00, 0x00,
1448 		       0x00, 0x00, SCSI_GROUP_NUMBER_MASK, 0x18,
1449 		       0x00, WRITE_SAME_32, 0xe8, 0x00,
1450 		       0xff, 0xff, 0xff, 0xff,
1451 		       0xff, 0xff, 0xff, 0xff,
1452 		       0x00, 0x00, 0x00, 0x00,
1453 		       0x00, 0x00, 0x00, 0x00,
1454 		       0xff, 0xff, 0xff, 0xff},
1455 	.enabled = tcm_is_ws_enabled,
1456 	.update_usage_bits = set_dpofua_usage_bits32,
1457 };
1458 
1459 static bool tcm_is_caw_enabled(struct se_cmd *cmd)
1460 {
1461 	struct se_device *dev = cmd->se_dev;
1462 
1463 	return dev->dev_attrib.emulate_caw;
1464 }
1465 
1466 static struct target_opcode_descriptor tcm_opcode_compare_write = {
1467 	.support = SCSI_SUPPORT_FULL,
1468 	.opcode = COMPARE_AND_WRITE,
1469 	.cdb_size = 16,
1470 	.usage_bits = {COMPARE_AND_WRITE, 0x18, 0xff, 0xff,
1471 		       0xff, 0xff, 0xff, 0xff,
1472 		       0xff, 0xff, 0x00, 0x00,
1473 		       0x00, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
1474 	.enabled = tcm_is_caw_enabled,
1475 	.update_usage_bits = set_dpofua_usage_bits,
1476 };
1477 
1478 static struct target_opcode_descriptor tcm_opcode_read_capacity = {
1479 	.support = SCSI_SUPPORT_FULL,
1480 	.opcode = READ_CAPACITY,
1481 	.cdb_size = 10,
1482 	.usage_bits = {READ_CAPACITY, 0x00, 0xff, 0xff,
1483 		       0xff, 0xff, 0x00, 0x00,
1484 		       0x01, SCSI_CONTROL_MASK},
1485 };
1486 
1487 static struct target_opcode_descriptor tcm_opcode_read_capacity16 = {
1488 	.support = SCSI_SUPPORT_FULL,
1489 	.serv_action_valid = 1,
1490 	.opcode = SERVICE_ACTION_IN_16,
1491 	.service_action = SAI_READ_CAPACITY_16,
1492 	.cdb_size = 16,
1493 	.usage_bits = {SERVICE_ACTION_IN_16, SAI_READ_CAPACITY_16, 0x00, 0x00,
1494 		       0x00, 0x00, 0x00, 0x00,
1495 		       0x00, 0x00, 0xff, 0xff,
1496 		       0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
1497 };
1498 
1499 static bool tcm_is_rep_ref_enabled(struct se_cmd *cmd)
1500 {
1501 	struct se_device *dev = cmd->se_dev;
1502 
1503 	spin_lock(&dev->t10_alua.lba_map_lock);
1504 	if (list_empty(&dev->t10_alua.lba_map_list)) {
1505 		spin_unlock(&dev->t10_alua.lba_map_lock);
1506 		return false;
1507 	}
1508 	spin_unlock(&dev->t10_alua.lba_map_lock);
1509 	return true;
1510 
1511 }
1512 
1513 static struct target_opcode_descriptor tcm_opcode_read_report_refferals = {
1514 	.support = SCSI_SUPPORT_FULL,
1515 	.serv_action_valid = 1,
1516 	.opcode = SERVICE_ACTION_IN_16,
1517 	.service_action = SAI_REPORT_REFERRALS,
1518 	.cdb_size = 16,
1519 	.usage_bits = {SERVICE_ACTION_IN_16, SAI_REPORT_REFERRALS, 0x00, 0x00,
1520 		       0x00, 0x00, 0x00, 0x00,
1521 		       0x00, 0x00, 0xff, 0xff,
1522 		       0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
1523 	.enabled = tcm_is_rep_ref_enabled,
1524 };
1525 
1526 static struct target_opcode_descriptor tcm_opcode_sync_cache = {
1527 	.support = SCSI_SUPPORT_FULL,
1528 	.opcode = SYNCHRONIZE_CACHE,
1529 	.cdb_size = 10,
1530 	.usage_bits = {SYNCHRONIZE_CACHE, 0x02, 0xff, 0xff,
1531 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, 0xff,
1532 		       0xff, SCSI_CONTROL_MASK},
1533 };
1534 
1535 static struct target_opcode_descriptor tcm_opcode_sync_cache16 = {
1536 	.support = SCSI_SUPPORT_FULL,
1537 	.opcode = SYNCHRONIZE_CACHE_16,
1538 	.cdb_size = 16,
1539 	.usage_bits = {SYNCHRONIZE_CACHE_16, 0x02, 0xff, 0xff,
1540 		       0xff, 0xff, 0xff, 0xff,
1541 		       0xff, 0xff, 0xff, 0xff,
1542 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
1543 };
1544 
1545 static bool tcm_is_unmap_enabled(struct se_cmd *cmd)
1546 {
1547 	struct sbc_ops *ops = cmd->protocol_data;
1548 	struct se_device *dev = cmd->se_dev;
1549 
1550 	return ops->execute_unmap && dev->dev_attrib.emulate_tpu;
1551 }
1552 
1553 static struct target_opcode_descriptor tcm_opcode_unmap = {
1554 	.support = SCSI_SUPPORT_FULL,
1555 	.opcode = UNMAP,
1556 	.cdb_size = 10,
1557 	.usage_bits = {UNMAP, 0x00, 0x00, 0x00,
1558 		       0x00, 0x00, SCSI_GROUP_NUMBER_MASK, 0xff,
1559 		       0xff, SCSI_CONTROL_MASK},
1560 	.enabled = tcm_is_unmap_enabled,
1561 };
1562 
1563 static struct target_opcode_descriptor tcm_opcode_write_same = {
1564 	.support = SCSI_SUPPORT_FULL,
1565 	.opcode = WRITE_SAME,
1566 	.cdb_size = 10,
1567 	.usage_bits = {WRITE_SAME, 0xe8, 0xff, 0xff,
1568 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, 0xff,
1569 		       0xff, SCSI_CONTROL_MASK},
1570 	.enabled = tcm_is_ws_enabled,
1571 };
1572 
1573 static struct target_opcode_descriptor tcm_opcode_write_same16 = {
1574 	.support = SCSI_SUPPORT_FULL,
1575 	.opcode = WRITE_SAME_16,
1576 	.cdb_size = 16,
1577 	.usage_bits = {WRITE_SAME_16, 0xe8, 0xff, 0xff,
1578 		       0xff, 0xff, 0xff, 0xff,
1579 		       0xff, 0xff, 0xff, 0xff,
1580 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
1581 	.enabled = tcm_is_ws_enabled,
1582 };
1583 
1584 static struct target_opcode_descriptor tcm_opcode_verify = {
1585 	.support = SCSI_SUPPORT_FULL,
1586 	.opcode = VERIFY,
1587 	.cdb_size = 10,
1588 	.usage_bits = {VERIFY, 0x00, 0xff, 0xff,
1589 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, 0xff,
1590 		       0xff, SCSI_CONTROL_MASK},
1591 };
1592 
1593 static struct target_opcode_descriptor tcm_opcode_verify16 = {
1594 	.support = SCSI_SUPPORT_FULL,
1595 	.opcode = VERIFY_16,
1596 	.cdb_size = 16,
1597 	.usage_bits = {VERIFY_16, 0x00, 0xff, 0xff,
1598 		       0xff, 0xff, 0xff, 0xff,
1599 		       0xff, 0xff, 0xff, 0xff,
1600 		       0xff, 0xff, SCSI_GROUP_NUMBER_MASK, SCSI_CONTROL_MASK},
1601 };
1602 
1603 static struct target_opcode_descriptor tcm_opcode_start_stop = {
1604 	.support = SCSI_SUPPORT_FULL,
1605 	.opcode = START_STOP,
1606 	.cdb_size = 6,
1607 	.usage_bits = {START_STOP, 0x01, 0x00, 0x00,
1608 		       0x01, SCSI_CONTROL_MASK},
1609 };
1610 
1611 static struct target_opcode_descriptor tcm_opcode_mode_select = {
1612 	.support = SCSI_SUPPORT_FULL,
1613 	.opcode = MODE_SELECT,
1614 	.cdb_size = 6,
1615 	.usage_bits = {MODE_SELECT, 0x10, 0x00, 0x00,
1616 		       0xff, SCSI_CONTROL_MASK},
1617 };
1618 
1619 static struct target_opcode_descriptor tcm_opcode_mode_select10 = {
1620 	.support = SCSI_SUPPORT_FULL,
1621 	.opcode = MODE_SELECT_10,
1622 	.cdb_size = 10,
1623 	.usage_bits = {MODE_SELECT_10, 0x10, 0x00, 0x00,
1624 		       0x00, 0x00, 0x00, 0xff,
1625 		       0xff, SCSI_CONTROL_MASK},
1626 };
1627 
1628 static struct target_opcode_descriptor tcm_opcode_mode_sense = {
1629 	.support = SCSI_SUPPORT_FULL,
1630 	.opcode = MODE_SENSE,
1631 	.cdb_size = 6,
1632 	.usage_bits = {MODE_SENSE, 0x08, 0xff, 0xff,
1633 		       0xff, SCSI_CONTROL_MASK},
1634 };
1635 
1636 static struct target_opcode_descriptor tcm_opcode_mode_sense10 = {
1637 	.support = SCSI_SUPPORT_FULL,
1638 	.opcode = MODE_SENSE_10,
1639 	.cdb_size = 10,
1640 	.usage_bits = {MODE_SENSE_10, 0x18, 0xff, 0xff,
1641 		       0x00, 0x00, 0x00, 0xff,
1642 		       0xff, SCSI_CONTROL_MASK},
1643 };
1644 
1645 static struct target_opcode_descriptor tcm_opcode_pri_read_keys = {
1646 	.support = SCSI_SUPPORT_FULL,
1647 	.serv_action_valid = 1,
1648 	.opcode = PERSISTENT_RESERVE_IN,
1649 	.service_action = PRI_READ_KEYS,
1650 	.cdb_size = 10,
1651 	.usage_bits = {PERSISTENT_RESERVE_IN, PRI_READ_KEYS, 0x00, 0x00,
1652 		       0x00, 0x00, 0x00, 0xff,
1653 		       0xff, SCSI_CONTROL_MASK},
1654 };
1655 
1656 static struct target_opcode_descriptor tcm_opcode_pri_read_resrv = {
1657 	.support = SCSI_SUPPORT_FULL,
1658 	.serv_action_valid = 1,
1659 	.opcode = PERSISTENT_RESERVE_IN,
1660 	.service_action = PRI_READ_RESERVATION,
1661 	.cdb_size = 10,
1662 	.usage_bits = {PERSISTENT_RESERVE_IN, PRI_READ_RESERVATION, 0x00, 0x00,
1663 		       0x00, 0x00, 0x00, 0xff,
1664 		       0xff, SCSI_CONTROL_MASK},
1665 };
1666 
1667 static bool tcm_is_pr_enabled(struct se_cmd *cmd)
1668 {
1669 	struct se_device *dev = cmd->se_dev;
1670 
1671 	return dev->dev_attrib.emulate_pr;
1672 }
1673 
1674 static struct target_opcode_descriptor tcm_opcode_pri_read_caps = {
1675 	.support = SCSI_SUPPORT_FULL,
1676 	.serv_action_valid = 1,
1677 	.opcode = PERSISTENT_RESERVE_IN,
1678 	.service_action = PRI_REPORT_CAPABILITIES,
1679 	.cdb_size = 10,
1680 	.usage_bits = {PERSISTENT_RESERVE_IN, PRI_REPORT_CAPABILITIES, 0x00, 0x00,
1681 		       0x00, 0x00, 0x00, 0xff,
1682 		       0xff, SCSI_CONTROL_MASK},
1683 	.enabled = tcm_is_pr_enabled,
1684 };
1685 
1686 static struct target_opcode_descriptor tcm_opcode_pri_read_full_status = {
1687 	.support = SCSI_SUPPORT_FULL,
1688 	.serv_action_valid = 1,
1689 	.opcode = PERSISTENT_RESERVE_IN,
1690 	.service_action = PRI_READ_FULL_STATUS,
1691 	.cdb_size = 10,
1692 	.usage_bits = {PERSISTENT_RESERVE_IN, PRI_READ_FULL_STATUS, 0x00, 0x00,
1693 		       0x00, 0x00, 0x00, 0xff,
1694 		       0xff, SCSI_CONTROL_MASK},
1695 	.enabled = tcm_is_pr_enabled,
1696 };
1697 
1698 static struct target_opcode_descriptor tcm_opcode_pro_register = {
1699 	.support = SCSI_SUPPORT_FULL,
1700 	.serv_action_valid = 1,
1701 	.opcode = PERSISTENT_RESERVE_OUT,
1702 	.service_action = PRO_REGISTER,
1703 	.cdb_size = 10,
1704 	.usage_bits = {PERSISTENT_RESERVE_OUT, PRO_REGISTER, 0xff, 0x00,
1705 		       0x00, 0xff, 0xff, 0xff,
1706 		       0xff, SCSI_CONTROL_MASK},
1707 	.enabled = tcm_is_pr_enabled,
1708 };
1709 
1710 static struct target_opcode_descriptor tcm_opcode_pro_reserve = {
1711 	.support = SCSI_SUPPORT_FULL,
1712 	.serv_action_valid = 1,
1713 	.opcode = PERSISTENT_RESERVE_OUT,
1714 	.service_action = PRO_RESERVE,
1715 	.cdb_size = 10,
1716 	.usage_bits = {PERSISTENT_RESERVE_OUT, PRO_RESERVE, 0xff, 0x00,
1717 		       0x00, 0xff, 0xff, 0xff,
1718 		       0xff, SCSI_CONTROL_MASK},
1719 	.enabled = tcm_is_pr_enabled,
1720 };
1721 
1722 static struct target_opcode_descriptor tcm_opcode_pro_release = {
1723 	.support = SCSI_SUPPORT_FULL,
1724 	.serv_action_valid = 1,
1725 	.opcode = PERSISTENT_RESERVE_OUT,
1726 	.service_action = PRO_RELEASE,
1727 	.cdb_size = 10,
1728 	.usage_bits = {PERSISTENT_RESERVE_OUT, PRO_RELEASE, 0xff, 0x00,
1729 		       0x00, 0xff, 0xff, 0xff,
1730 		       0xff, SCSI_CONTROL_MASK},
1731 	.enabled = tcm_is_pr_enabled,
1732 };
1733 
1734 static struct target_opcode_descriptor tcm_opcode_pro_clear = {
1735 	.support = SCSI_SUPPORT_FULL,
1736 	.serv_action_valid = 1,
1737 	.opcode = PERSISTENT_RESERVE_OUT,
1738 	.service_action = PRO_CLEAR,
1739 	.cdb_size = 10,
1740 	.usage_bits = {PERSISTENT_RESERVE_OUT, PRO_CLEAR, 0xff, 0x00,
1741 		       0x00, 0xff, 0xff, 0xff,
1742 		       0xff, SCSI_CONTROL_MASK},
1743 	.enabled = tcm_is_pr_enabled,
1744 };
1745 
1746 static struct target_opcode_descriptor tcm_opcode_pro_preempt = {
1747 	.support = SCSI_SUPPORT_FULL,
1748 	.serv_action_valid = 1,
1749 	.opcode = PERSISTENT_RESERVE_OUT,
1750 	.service_action = PRO_PREEMPT,
1751 	.cdb_size = 10,
1752 	.usage_bits = {PERSISTENT_RESERVE_OUT, PRO_PREEMPT, 0xff, 0x00,
1753 		       0x00, 0xff, 0xff, 0xff,
1754 		       0xff, SCSI_CONTROL_MASK},
1755 	.enabled = tcm_is_pr_enabled,
1756 };
1757 
1758 static struct target_opcode_descriptor tcm_opcode_pro_preempt_abort = {
1759 	.support = SCSI_SUPPORT_FULL,
1760 	.serv_action_valid = 1,
1761 	.opcode = PERSISTENT_RESERVE_OUT,
1762 	.service_action = PRO_PREEMPT_AND_ABORT,
1763 	.cdb_size = 10,
1764 	.usage_bits = {PERSISTENT_RESERVE_OUT, PRO_PREEMPT_AND_ABORT, 0xff, 0x00,
1765 		       0x00, 0xff, 0xff, 0xff,
1766 		       0xff, SCSI_CONTROL_MASK},
1767 	.enabled = tcm_is_pr_enabled,
1768 };
1769 
1770 static struct target_opcode_descriptor tcm_opcode_pro_reg_ign_exist = {
1771 	.support = SCSI_SUPPORT_FULL,
1772 	.serv_action_valid = 1,
1773 	.opcode = PERSISTENT_RESERVE_OUT,
1774 	.service_action = PRO_REGISTER_AND_IGNORE_EXISTING_KEY,
1775 	.cdb_size = 10,
1776 	.usage_bits = {
1777 		PERSISTENT_RESERVE_OUT, PRO_REGISTER_AND_IGNORE_EXISTING_KEY,
1778 		0xff, 0x00,
1779 		0x00, 0xff, 0xff, 0xff,
1780 		0xff, SCSI_CONTROL_MASK},
1781 	.enabled = tcm_is_pr_enabled,
1782 };
1783 
1784 static struct target_opcode_descriptor tcm_opcode_pro_register_move = {
1785 	.support = SCSI_SUPPORT_FULL,
1786 	.serv_action_valid = 1,
1787 	.opcode = PERSISTENT_RESERVE_OUT,
1788 	.service_action = PRO_REGISTER_AND_MOVE,
1789 	.cdb_size = 10,
1790 	.usage_bits = {PERSISTENT_RESERVE_OUT, PRO_REGISTER_AND_MOVE, 0xff, 0x00,
1791 		       0x00, 0xff, 0xff, 0xff,
1792 		       0xff, SCSI_CONTROL_MASK},
1793 	.enabled = tcm_is_pr_enabled,
1794 };
1795 
1796 static bool tcm_is_scsi2_reservations_enabled(struct se_cmd *cmd)
1797 {
1798 	struct se_device *dev = cmd->se_dev;
1799 
1800 	return dev->dev_attrib.emulate_pr;
1801 }
1802 
1803 static struct target_opcode_descriptor tcm_opcode_release = {
1804 	.support = SCSI_SUPPORT_FULL,
1805 	.opcode = RELEASE,
1806 	.cdb_size = 6,
1807 	.usage_bits = {RELEASE, 0x00, 0x00, 0x00,
1808 		       0x00, SCSI_CONTROL_MASK},
1809 	.enabled = tcm_is_scsi2_reservations_enabled,
1810 };
1811 
1812 static struct target_opcode_descriptor tcm_opcode_release10 = {
1813 	.support = SCSI_SUPPORT_FULL,
1814 	.opcode = RELEASE_10,
1815 	.cdb_size = 10,
1816 	.usage_bits = {RELEASE_10, 0x00, 0x00, 0x00,
1817 		       0x00, 0x00, 0x00, 0xff,
1818 		       0xff, SCSI_CONTROL_MASK},
1819 	.enabled = tcm_is_scsi2_reservations_enabled,
1820 };
1821 
1822 static struct target_opcode_descriptor tcm_opcode_reserve = {
1823 	.support = SCSI_SUPPORT_FULL,
1824 	.opcode = RESERVE,
1825 	.cdb_size = 6,
1826 	.usage_bits = {RESERVE, 0x00, 0x00, 0x00,
1827 		       0x00, SCSI_CONTROL_MASK},
1828 	.enabled = tcm_is_scsi2_reservations_enabled,
1829 };
1830 
1831 static struct target_opcode_descriptor tcm_opcode_reserve10 = {
1832 	.support = SCSI_SUPPORT_FULL,
1833 	.opcode = RESERVE_10,
1834 	.cdb_size = 10,
1835 	.usage_bits = {RESERVE_10, 0x00, 0x00, 0x00,
1836 		       0x00, 0x00, 0x00, 0xff,
1837 		       0xff, SCSI_CONTROL_MASK},
1838 	.enabled = tcm_is_scsi2_reservations_enabled,
1839 };
1840 
1841 static struct target_opcode_descriptor tcm_opcode_request_sense = {
1842 	.support = SCSI_SUPPORT_FULL,
1843 	.opcode = REQUEST_SENSE,
1844 	.cdb_size = 6,
1845 	.usage_bits = {REQUEST_SENSE, 0x00, 0x00, 0x00,
1846 		       0xff, SCSI_CONTROL_MASK},
1847 };
1848 
1849 static struct target_opcode_descriptor tcm_opcode_inquiry = {
1850 	.support = SCSI_SUPPORT_FULL,
1851 	.opcode = INQUIRY,
1852 	.cdb_size = 6,
1853 	.usage_bits = {INQUIRY, 0x01, 0xff, 0xff,
1854 		       0xff, SCSI_CONTROL_MASK},
1855 };
1856 
1857 static bool tcm_is_3pc_enabled(struct se_cmd *cmd)
1858 {
1859 	struct se_device *dev = cmd->se_dev;
1860 
1861 	return dev->dev_attrib.emulate_3pc;
1862 }
1863 
1864 static struct target_opcode_descriptor tcm_opcode_extended_copy_lid1 = {
1865 	.support = SCSI_SUPPORT_FULL,
1866 	.serv_action_valid = 1,
1867 	.opcode = EXTENDED_COPY,
1868 	.cdb_size = 16,
1869 	.usage_bits = {EXTENDED_COPY, 0x00, 0x00, 0x00,
1870 		       0x00, 0x00, 0x00, 0x00,
1871 		       0x00, 0x00, 0xff, 0xff,
1872 		       0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
1873 	.enabled = tcm_is_3pc_enabled,
1874 };
1875 
1876 static struct target_opcode_descriptor tcm_opcode_rcv_copy_res_op_params = {
1877 	.support = SCSI_SUPPORT_FULL,
1878 	.serv_action_valid = 1,
1879 	.opcode = RECEIVE_COPY_RESULTS,
1880 	.service_action = RCR_SA_OPERATING_PARAMETERS,
1881 	.cdb_size = 16,
1882 	.usage_bits = {RECEIVE_COPY_RESULTS, RCR_SA_OPERATING_PARAMETERS,
1883 		       0x00, 0x00,
1884 		       0x00, 0x00, 0x00, 0x00,
1885 		       0x00, 0x00, 0xff, 0xff,
1886 		       0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
1887 	.enabled = tcm_is_3pc_enabled,
1888 };
1889 
1890 static struct target_opcode_descriptor tcm_opcode_report_luns = {
1891 	.support = SCSI_SUPPORT_FULL,
1892 	.opcode = REPORT_LUNS,
1893 	.cdb_size = 12,
1894 	.usage_bits = {REPORT_LUNS, 0x00, 0xff, 0x00,
1895 		       0x00, 0x00, 0xff, 0xff,
1896 		       0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
1897 };
1898 
1899 static struct target_opcode_descriptor tcm_opcode_test_unit_ready = {
1900 	.support = SCSI_SUPPORT_FULL,
1901 	.opcode = TEST_UNIT_READY,
1902 	.cdb_size = 6,
1903 	.usage_bits = {TEST_UNIT_READY, 0x00, 0x00, 0x00,
1904 		       0x00, SCSI_CONTROL_MASK},
1905 };
1906 
1907 static struct target_opcode_descriptor tcm_opcode_report_target_pgs = {
1908 	.support = SCSI_SUPPORT_FULL,
1909 	.serv_action_valid = 1,
1910 	.opcode = MAINTENANCE_IN,
1911 	.service_action = MI_REPORT_TARGET_PGS,
1912 	.cdb_size = 12,
1913 	.usage_bits = {MAINTENANCE_IN, 0xE0 | MI_REPORT_TARGET_PGS, 0x00, 0x00,
1914 		       0x00, 0x00, 0xff, 0xff,
1915 		       0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
1916 };
1917 
1918 
1919 static bool spc_rsoc_enabled(struct se_cmd *cmd)
1920 {
1921 	struct se_device *dev = cmd->se_dev;
1922 
1923 	return dev->dev_attrib.emulate_rsoc;
1924 }
1925 
1926 static struct target_opcode_descriptor tcm_opcode_report_supp_opcodes = {
1927 	.support = SCSI_SUPPORT_FULL,
1928 	.serv_action_valid = 1,
1929 	.opcode = MAINTENANCE_IN,
1930 	.service_action = MI_REPORT_SUPPORTED_OPERATION_CODES,
1931 	.cdb_size = 12,
1932 	.usage_bits = {MAINTENANCE_IN, MI_REPORT_SUPPORTED_OPERATION_CODES,
1933 		       0x87, 0xff,
1934 		       0xff, 0xff, 0xff, 0xff,
1935 		       0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
1936 	.enabled = spc_rsoc_enabled,
1937 };
1938 
1939 static bool tcm_is_set_tpg_enabled(struct se_cmd *cmd)
1940 {
1941 	struct t10_alua_tg_pt_gp *l_tg_pt_gp;
1942 	struct se_lun *l_lun = cmd->se_lun;
1943 
1944 	rcu_read_lock();
1945 	l_tg_pt_gp = rcu_dereference(l_lun->lun_tg_pt_gp);
1946 	if (!l_tg_pt_gp) {
1947 		rcu_read_unlock();
1948 		return false;
1949 	}
1950 	if (!(l_tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA)) {
1951 		rcu_read_unlock();
1952 		return false;
1953 	}
1954 	rcu_read_unlock();
1955 
1956 	return true;
1957 }
1958 
1959 static struct target_opcode_descriptor tcm_opcode_set_tpg = {
1960 	.support = SCSI_SUPPORT_FULL,
1961 	.serv_action_valid = 1,
1962 	.opcode = MAINTENANCE_OUT,
1963 	.service_action = MO_SET_TARGET_PGS,
1964 	.cdb_size = 12,
1965 	.usage_bits = {MAINTENANCE_OUT, MO_SET_TARGET_PGS, 0x00, 0x00,
1966 		       0x00, 0x00, 0xff, 0xff,
1967 		       0xff, 0xff, 0x00, SCSI_CONTROL_MASK},
1968 	.enabled = tcm_is_set_tpg_enabled,
1969 };
1970 
1971 static struct target_opcode_descriptor *tcm_supported_opcodes[] = {
1972 	&tcm_opcode_read6,
1973 	&tcm_opcode_read10,
1974 	&tcm_opcode_read12,
1975 	&tcm_opcode_read16,
1976 	&tcm_opcode_write6,
1977 	&tcm_opcode_write10,
1978 	&tcm_opcode_write_verify10,
1979 	&tcm_opcode_write12,
1980 	&tcm_opcode_write16,
1981 	&tcm_opcode_write_verify16,
1982 	&tcm_opcode_write_same32,
1983 	&tcm_opcode_compare_write,
1984 	&tcm_opcode_read_capacity,
1985 	&tcm_opcode_read_capacity16,
1986 	&tcm_opcode_read_report_refferals,
1987 	&tcm_opcode_sync_cache,
1988 	&tcm_opcode_sync_cache16,
1989 	&tcm_opcode_unmap,
1990 	&tcm_opcode_write_same,
1991 	&tcm_opcode_write_same16,
1992 	&tcm_opcode_verify,
1993 	&tcm_opcode_verify16,
1994 	&tcm_opcode_start_stop,
1995 	&tcm_opcode_mode_select,
1996 	&tcm_opcode_mode_select10,
1997 	&tcm_opcode_mode_sense,
1998 	&tcm_opcode_mode_sense10,
1999 	&tcm_opcode_pri_read_keys,
2000 	&tcm_opcode_pri_read_resrv,
2001 	&tcm_opcode_pri_read_caps,
2002 	&tcm_opcode_pri_read_full_status,
2003 	&tcm_opcode_pro_register,
2004 	&tcm_opcode_pro_reserve,
2005 	&tcm_opcode_pro_release,
2006 	&tcm_opcode_pro_clear,
2007 	&tcm_opcode_pro_preempt,
2008 	&tcm_opcode_pro_preempt_abort,
2009 	&tcm_opcode_pro_reg_ign_exist,
2010 	&tcm_opcode_pro_register_move,
2011 	&tcm_opcode_release,
2012 	&tcm_opcode_release10,
2013 	&tcm_opcode_reserve,
2014 	&tcm_opcode_reserve10,
2015 	&tcm_opcode_request_sense,
2016 	&tcm_opcode_inquiry,
2017 	&tcm_opcode_extended_copy_lid1,
2018 	&tcm_opcode_rcv_copy_res_op_params,
2019 	&tcm_opcode_report_luns,
2020 	&tcm_opcode_test_unit_ready,
2021 	&tcm_opcode_report_target_pgs,
2022 	&tcm_opcode_report_supp_opcodes,
2023 	&tcm_opcode_set_tpg,
2024 };
2025 
2026 static int
2027 spc_rsoc_encode_command_timeouts_descriptor(unsigned char *buf, u8 ctdp,
2028 				struct target_opcode_descriptor *descr)
2029 {
2030 	if (!ctdp)
2031 		return 0;
2032 
2033 	put_unaligned_be16(0xa, buf);
2034 	buf[3] = descr->specific_timeout;
2035 	put_unaligned_be32(descr->nominal_timeout, &buf[4]);
2036 	put_unaligned_be32(descr->recommended_timeout, &buf[8]);
2037 
2038 	return 12;
2039 }
2040 
2041 static int
2042 spc_rsoc_encode_command_descriptor(unsigned char *buf, u8 ctdp,
2043 				   struct target_opcode_descriptor *descr)
2044 {
2045 	int td_size = 0;
2046 
2047 	buf[0] = descr->opcode;
2048 
2049 	put_unaligned_be16(descr->service_action, &buf[2]);
2050 
2051 	buf[5] = (ctdp << 1) | descr->serv_action_valid;
2052 	put_unaligned_be16(descr->cdb_size, &buf[6]);
2053 
2054 	td_size = spc_rsoc_encode_command_timeouts_descriptor(&buf[8], ctdp,
2055 							      descr);
2056 
2057 	return 8 + td_size;
2058 }
2059 
2060 static int
2061 spc_rsoc_encode_one_command_descriptor(unsigned char *buf, u8 ctdp,
2062 				       struct target_opcode_descriptor *descr,
2063 				       struct se_device *dev)
2064 {
2065 	int td_size = 0;
2066 
2067 	if (!descr) {
2068 		buf[1] = (ctdp << 7) | SCSI_SUPPORT_NOT_SUPPORTED;
2069 		return 2;
2070 	}
2071 
2072 	buf[1] = (ctdp << 7) | SCSI_SUPPORT_FULL;
2073 	put_unaligned_be16(descr->cdb_size, &buf[2]);
2074 	memcpy(&buf[4], descr->usage_bits, descr->cdb_size);
2075 	if (descr->update_usage_bits)
2076 		descr->update_usage_bits(&buf[4], dev);
2077 
2078 	td_size = spc_rsoc_encode_command_timeouts_descriptor(
2079 			&buf[4 + descr->cdb_size], ctdp, descr);
2080 
2081 	return 4 + descr->cdb_size + td_size;
2082 }
2083 
2084 static sense_reason_t
2085 spc_rsoc_get_descr(struct se_cmd *cmd, struct target_opcode_descriptor **opcode)
2086 {
2087 	struct target_opcode_descriptor *descr;
2088 	struct se_session *sess = cmd->se_sess;
2089 	unsigned char *cdb = cmd->t_task_cdb;
2090 	u8 opts = cdb[2] & 0x3;
2091 	u8 requested_opcode;
2092 	u16 requested_sa;
2093 	int i;
2094 
2095 	requested_opcode = cdb[3];
2096 	requested_sa = ((u16)cdb[4]) << 8 | cdb[5];
2097 	*opcode = NULL;
2098 
2099 	if (opts > 3) {
2100 		pr_debug("TARGET_CORE[%s]: Invalid REPORT SUPPORTED OPERATION CODES"
2101 			" with unsupported REPORTING OPTIONS %#x for 0x%08llx from %s\n",
2102 			cmd->se_tfo->fabric_name, opts,
2103 			cmd->se_lun->unpacked_lun,
2104 			sess->se_node_acl->initiatorname);
2105 		return TCM_INVALID_CDB_FIELD;
2106 	}
2107 
2108 	for (i = 0; i < ARRAY_SIZE(tcm_supported_opcodes); i++) {
2109 		descr = tcm_supported_opcodes[i];
2110 		if (descr->opcode != requested_opcode)
2111 			continue;
2112 
2113 		switch (opts) {
2114 		case 0x1:
2115 			/*
2116 			 * If the REQUESTED OPERATION CODE field specifies an
2117 			 * operation code for which the device server implements
2118 			 * service actions, then the device server shall
2119 			 * terminate the command with CHECK CONDITION status,
2120 			 * with the sense key set to ILLEGAL REQUEST, and the
2121 			 * additional sense code set to INVALID FIELD IN CDB
2122 			 */
2123 			if (descr->serv_action_valid)
2124 				return TCM_INVALID_CDB_FIELD;
2125 
2126 			if (!descr->enabled || descr->enabled(cmd))
2127 				*opcode = descr;
2128 			break;
2129 		case 0x2:
2130 			/*
2131 			 * If the REQUESTED OPERATION CODE field specifies an
2132 			 * operation code for which the device server does not
2133 			 * implement service actions, then the device server
2134 			 * shall terminate the command with CHECK CONDITION
2135 			 * status, with the sense key set to ILLEGAL REQUEST,
2136 			 * and the additional sense code set to INVALID FIELD IN CDB.
2137 			 */
2138 			if (descr->serv_action_valid &&
2139 			    descr->service_action == requested_sa) {
2140 				if (!descr->enabled || descr->enabled(cmd))
2141 					*opcode = descr;
2142 			} else if (!descr->serv_action_valid)
2143 				return TCM_INVALID_CDB_FIELD;
2144 			break;
2145 		case 0x3:
2146 			/*
2147 			 * The command support data for the operation code and
2148 			 * service action a specified in the REQUESTED OPERATION
2149 			 * CODE field and REQUESTED SERVICE ACTION field shall
2150 			 * be returned in the one_command parameter data format.
2151 			 */
2152 			if (descr->service_action == requested_sa)
2153 				if (!descr->enabled || descr->enabled(cmd))
2154 					*opcode = descr;
2155 			break;
2156 		}
2157 	}
2158 
2159 	return 0;
2160 }
2161 
2162 static sense_reason_t
2163 spc_emulate_report_supp_op_codes(struct se_cmd *cmd)
2164 {
2165 	int descr_num = ARRAY_SIZE(tcm_supported_opcodes);
2166 	struct target_opcode_descriptor *descr = NULL;
2167 	unsigned char *cdb = cmd->t_task_cdb;
2168 	u8 rctd = (cdb[2] >> 7) & 0x1;
2169 	unsigned char *buf = NULL;
2170 	int response_length = 0;
2171 	u8 opts = cdb[2] & 0x3;
2172 	unsigned char *rbuf;
2173 	sense_reason_t ret = 0;
2174 	int i;
2175 
2176 	if (!cmd->se_dev->dev_attrib.emulate_rsoc)
2177 		return TCM_UNSUPPORTED_SCSI_OPCODE;
2178 
2179 	rbuf = transport_kmap_data_sg(cmd);
2180 	if (cmd->data_length && !rbuf) {
2181 		ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
2182 		goto out;
2183 	}
2184 
2185 	if (opts == 0)
2186 		response_length = 4 + (8 + rctd * 12) * descr_num;
2187 	else {
2188 		ret = spc_rsoc_get_descr(cmd, &descr);
2189 		if (ret)
2190 			goto out;
2191 
2192 		if (descr)
2193 			response_length = 4 + descr->cdb_size + rctd * 12;
2194 		else
2195 			response_length = 2;
2196 	}
2197 
2198 	buf = kzalloc(response_length, GFP_KERNEL);
2199 	if (!buf) {
2200 		ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
2201 		goto out;
2202 	}
2203 	response_length = 0;
2204 
2205 	if (opts == 0) {
2206 		response_length += 4;
2207 
2208 		for (i = 0; i < ARRAY_SIZE(tcm_supported_opcodes); i++) {
2209 			descr = tcm_supported_opcodes[i];
2210 			if (descr->enabled && !descr->enabled(cmd))
2211 				continue;
2212 
2213 			response_length += spc_rsoc_encode_command_descriptor(
2214 					&buf[response_length], rctd, descr);
2215 		}
2216 		put_unaligned_be32(response_length - 3, buf);
2217 	} else {
2218 		response_length = spc_rsoc_encode_one_command_descriptor(
2219 				&buf[response_length], rctd, descr,
2220 				cmd->se_dev);
2221 	}
2222 
2223 	memcpy(rbuf, buf, min_t(u32, response_length, cmd->data_length));
2224 out:
2225 	kfree(buf);
2226 	transport_kunmap_data_sg(cmd);
2227 
2228 	if (!ret)
2229 		target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, response_length);
2230 	return ret;
2231 }
2232 
2233 sense_reason_t
2234 spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
2235 {
2236 	struct se_device *dev = cmd->se_dev;
2237 	unsigned char *cdb = cmd->t_task_cdb;
2238 
2239 	if (!dev->dev_attrib.emulate_pr &&
2240 	    ((cdb[0] == PERSISTENT_RESERVE_IN) ||
2241 	     (cdb[0] == PERSISTENT_RESERVE_OUT) ||
2242 	     (cdb[0] == RELEASE || cdb[0] == RELEASE_10) ||
2243 	     (cdb[0] == RESERVE || cdb[0] == RESERVE_10))) {
2244 		return TCM_UNSUPPORTED_SCSI_OPCODE;
2245 	}
2246 
2247 	switch (cdb[0]) {
2248 	case MODE_SELECT:
2249 		*size = cdb[4];
2250 		cmd->execute_cmd = spc_emulate_modeselect;
2251 		break;
2252 	case MODE_SELECT_10:
2253 		*size = get_unaligned_be16(&cdb[7]);
2254 		cmd->execute_cmd = spc_emulate_modeselect;
2255 		break;
2256 	case MODE_SENSE:
2257 		*size = cdb[4];
2258 		cmd->execute_cmd = spc_emulate_modesense;
2259 		break;
2260 	case MODE_SENSE_10:
2261 		*size = get_unaligned_be16(&cdb[7]);
2262 		cmd->execute_cmd = spc_emulate_modesense;
2263 		break;
2264 	case LOG_SELECT:
2265 	case LOG_SENSE:
2266 		*size = get_unaligned_be16(&cdb[7]);
2267 		break;
2268 	case PERSISTENT_RESERVE_IN:
2269 		*size = get_unaligned_be16(&cdb[7]);
2270 		cmd->execute_cmd = target_scsi3_emulate_pr_in;
2271 		break;
2272 	case PERSISTENT_RESERVE_OUT:
2273 		*size = get_unaligned_be32(&cdb[5]);
2274 		cmd->execute_cmd = target_scsi3_emulate_pr_out;
2275 		break;
2276 	case RELEASE:
2277 	case RELEASE_10:
2278 		if (cdb[0] == RELEASE_10)
2279 			*size = get_unaligned_be16(&cdb[7]);
2280 		else
2281 			*size = cmd->data_length;
2282 
2283 		cmd->execute_cmd = target_scsi2_reservation_release;
2284 		break;
2285 	case RESERVE:
2286 	case RESERVE_10:
2287 		/*
2288 		 * The SPC-2 RESERVE does not contain a size in the SCSI CDB.
2289 		 * Assume the passthrough or $FABRIC_MOD will tell us about it.
2290 		 */
2291 		if (cdb[0] == RESERVE_10)
2292 			*size = get_unaligned_be16(&cdb[7]);
2293 		else
2294 			*size = cmd->data_length;
2295 
2296 		cmd->execute_cmd = target_scsi2_reservation_reserve;
2297 		break;
2298 	case REQUEST_SENSE:
2299 		*size = cdb[4];
2300 		cmd->execute_cmd = spc_emulate_request_sense;
2301 		break;
2302 	case INQUIRY:
2303 		*size = get_unaligned_be16(&cdb[3]);
2304 
2305 		/*
2306 		 * Do implicit HEAD_OF_QUEUE processing for INQUIRY.
2307 		 * See spc4r17 section 5.3
2308 		 */
2309 		cmd->sam_task_attr = TCM_HEAD_TAG;
2310 		cmd->execute_cmd = spc_emulate_inquiry;
2311 		break;
2312 	case SECURITY_PROTOCOL_IN:
2313 	case SECURITY_PROTOCOL_OUT:
2314 		*size = get_unaligned_be32(&cdb[6]);
2315 		break;
2316 	case EXTENDED_COPY:
2317 		*size = get_unaligned_be32(&cdb[10]);
2318 		cmd->execute_cmd = target_do_xcopy;
2319 		break;
2320 	case RECEIVE_COPY_RESULTS:
2321 		*size = get_unaligned_be32(&cdb[10]);
2322 		cmd->execute_cmd = target_do_receive_copy_results;
2323 		break;
2324 	case READ_ATTRIBUTE:
2325 	case WRITE_ATTRIBUTE:
2326 		*size = get_unaligned_be32(&cdb[10]);
2327 		break;
2328 	case RECEIVE_DIAGNOSTIC:
2329 	case SEND_DIAGNOSTIC:
2330 		*size = get_unaligned_be16(&cdb[3]);
2331 		break;
2332 	case WRITE_BUFFER:
2333 		*size = get_unaligned_be24(&cdb[6]);
2334 		break;
2335 	case REPORT_LUNS:
2336 		cmd->execute_cmd = spc_emulate_report_luns;
2337 		*size = get_unaligned_be32(&cdb[6]);
2338 		/*
2339 		 * Do implicit HEAD_OF_QUEUE processing for REPORT_LUNS
2340 		 * See spc4r17 section 5.3
2341 		 */
2342 		cmd->sam_task_attr = TCM_HEAD_TAG;
2343 		break;
2344 	case TEST_UNIT_READY:
2345 		cmd->execute_cmd = spc_emulate_testunitready;
2346 		*size = 0;
2347 		break;
2348 	case MAINTENANCE_IN:
2349 		if (dev->transport->get_device_type(dev) != TYPE_ROM) {
2350 			/*
2351 			 * MAINTENANCE_IN from SCC-2
2352 			 * Check for emulated MI_REPORT_TARGET_PGS
2353 			 */
2354 			if ((cdb[1] & 0x1f) == MI_REPORT_TARGET_PGS) {
2355 				cmd->execute_cmd =
2356 					target_emulate_report_target_port_groups;
2357 			}
2358 			if ((cdb[1] & 0x1f) ==
2359 			    MI_REPORT_SUPPORTED_OPERATION_CODES)
2360 				cmd->execute_cmd =
2361 					spc_emulate_report_supp_op_codes;
2362 			*size = get_unaligned_be32(&cdb[6]);
2363 		} else {
2364 			/*
2365 			 * GPCMD_SEND_KEY from multi media commands
2366 			 */
2367 			*size = get_unaligned_be16(&cdb[8]);
2368 		}
2369 		break;
2370 	case MAINTENANCE_OUT:
2371 		if (dev->transport->get_device_type(dev) != TYPE_ROM) {
2372 			/*
2373 			 * MAINTENANCE_OUT from SCC-2
2374 			 * Check for emulated MO_SET_TARGET_PGS.
2375 			 */
2376 			if (cdb[1] == MO_SET_TARGET_PGS) {
2377 				cmd->execute_cmd =
2378 					target_emulate_set_target_port_groups;
2379 			}
2380 			*size = get_unaligned_be32(&cdb[6]);
2381 		} else {
2382 			/*
2383 			 * GPCMD_SEND_KEY from multi media commands
2384 			 */
2385 			*size = get_unaligned_be16(&cdb[8]);
2386 		}
2387 		break;
2388 	default:
2389 		return TCM_UNSUPPORTED_SCSI_OPCODE;
2390 	}
2391 
2392 	return 0;
2393 }
2394 EXPORT_SYMBOL(spc_parse_cdb);
2395