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