target_core_cdb.c revision 05d1c7c0d0db4cc25548d9aadebb416888a82327
1/*
2 * CDB emulation for non-READ/WRITE commands.
3 *
4 * Copyright (c) 2002, 2003, 2004, 2005 PyX Technologies, Inc.
5 * Copyright (c) 2005, 2006, 2007 SBE, Inc.
6 * Copyright (c) 2007-2010 Rising Tide Systems
7 * Copyright (c) 2008-2010 Linux-iSCSI.org
8 *
9 * Nicholas A. Bellinger <nab@kernel.org>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 */
25
26#include <asm/unaligned.h>
27#include <scsi/scsi.h>
28
29#include <target/target_core_base.h>
30#include <target/target_core_transport.h>
31#include <target/target_core_fabric_ops.h>
32#include "target_core_ua.h"
33
34static void
35target_fill_alua_data(struct se_port *port, unsigned char *buf)
36{
37	struct t10_alua_tg_pt_gp *tg_pt_gp;
38	struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
39
40	/*
41	 * Set SCCS for MAINTENANCE_IN + REPORT_TARGET_PORT_GROUPS.
42	 */
43	buf[5]	= 0x80;
44
45	/*
46	 * Set TPGS field for explict and/or implict ALUA access type
47	 * and opteration.
48	 *
49	 * See spc4r17 section 6.4.2 Table 135
50	 */
51	if (!port)
52		return;
53	tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
54	if (!tg_pt_gp_mem)
55		return;
56
57	spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
58	tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
59	if (tg_pt_gp)
60		buf[5] |= tg_pt_gp->tg_pt_gp_alua_access_type;
61	spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
62}
63
64static int
65target_emulate_inquiry_std(struct se_cmd *cmd)
66{
67	struct se_lun *lun = cmd->se_lun;
68	struct se_device *dev = cmd->se_dev;
69	unsigned char *buf;
70
71	/*
72	 * Make sure we at least have 6 bytes of INQUIRY response
73	 * payload going back for EVPD=0
74	 */
75	if (cmd->data_length < 6) {
76		printk(KERN_ERR "SCSI Inquiry payload length: %u"
77			" too small for EVPD=0\n", cmd->data_length);
78		return -EINVAL;
79	}
80
81	buf = transport_kmap_first_data_page(cmd);
82
83	buf[0] = dev->transport->get_device_type(dev);
84	if (buf[0] == TYPE_TAPE)
85		buf[1] = 0x80;
86	buf[2] = dev->transport->get_device_rev(dev);
87
88	/*
89	 * Enable SCCS and TPGS fields for Emulated ALUA
90	 */
91	if (dev->se_sub_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED)
92		target_fill_alua_data(lun->lun_sep, buf);
93
94	if (cmd->data_length < 8) {
95		buf[4] = 1; /* Set additional length to 1 */
96		goto out;
97	}
98
99	buf[7] = 0x32; /* Sync=1 and CmdQue=1 */
100
101	/*
102	 * Do not include vendor, product, reversion info in INQUIRY
103	 * response payload for cdbs with a small allocation length.
104	 */
105	if (cmd->data_length < 36) {
106		buf[4] = 3; /* Set additional length to 3 */
107		goto out;
108	}
109
110	snprintf((unsigned char *)&buf[8], 8, "LIO-ORG");
111	snprintf((unsigned char *)&buf[16], 16, "%s",
112		 &dev->se_sub_dev->t10_wwn.model[0]);
113	snprintf((unsigned char *)&buf[32], 4, "%s",
114		 &dev->se_sub_dev->t10_wwn.revision[0]);
115	buf[4] = 31; /* Set additional length to 31 */
116
117out:
118	transport_kunmap_first_data_page(cmd);
119	return 0;
120}
121
122/* unit serial number */
123static int
124target_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf)
125{
126	struct se_device *dev = cmd->se_dev;
127	u16 len = 0;
128
129	if (dev->se_sub_dev->su_dev_flags &
130			SDF_EMULATED_VPD_UNIT_SERIAL) {
131		u32 unit_serial_len;
132
133		unit_serial_len =
134			strlen(&dev->se_sub_dev->t10_wwn.unit_serial[0]);
135		unit_serial_len++; /* For NULL Terminator */
136
137		if (((len + 4) + unit_serial_len) > cmd->data_length) {
138			len += unit_serial_len;
139			buf[2] = ((len >> 8) & 0xff);
140			buf[3] = (len & 0xff);
141			return 0;
142		}
143		len += sprintf((unsigned char *)&buf[4], "%s",
144			&dev->se_sub_dev->t10_wwn.unit_serial[0]);
145		len++; /* Extra Byte for NULL Terminator */
146		buf[3] = len;
147	}
148	return 0;
149}
150
151/*
152 * Device identification VPD, for a complete list of
153 * DESIGNATOR TYPEs see spc4r17 Table 459.
154 */
155static int
156target_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)
157{
158	struct se_device *dev = cmd->se_dev;
159	struct se_lun *lun = cmd->se_lun;
160	struct se_port *port = NULL;
161	struct se_portal_group *tpg = NULL;
162	struct t10_alua_lu_gp_member *lu_gp_mem;
163	struct t10_alua_tg_pt_gp *tg_pt_gp;
164	struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
165	unsigned char binary, binary_new;
166	unsigned char *prod = &dev->se_sub_dev->t10_wwn.model[0];
167	u32 prod_len;
168	u32 unit_serial_len, off = 0;
169	int i;
170	u16 len = 0, id_len;
171
172	off = 4;
173
174	/*
175	 * NAA IEEE Registered Extended Assigned designator format, see
176	 * spc4r17 section 7.7.3.6.5
177	 *
178	 * We depend upon a target_core_mod/ConfigFS provided
179	 * /sys/kernel/config/target/core/$HBA/$DEV/wwn/vpd_unit_serial
180	 * value in order to return the NAA id.
181	 */
182	if (!(dev->se_sub_dev->su_dev_flags & SDF_EMULATED_VPD_UNIT_SERIAL))
183		goto check_t10_vend_desc;
184
185	if (off + 20 > cmd->data_length)
186		goto check_t10_vend_desc;
187
188	/* CODE SET == Binary */
189	buf[off++] = 0x1;
190
191	/* Set ASSOICATION == addressed logical unit: 0)b */
192	buf[off] = 0x00;
193
194	/* Identifier/Designator type == NAA identifier */
195	buf[off++] = 0x3;
196	off++;
197
198	/* Identifier/Designator length */
199	buf[off++] = 0x10;
200
201	/*
202	 * Start NAA IEEE Registered Extended Identifier/Designator
203	 */
204	buf[off++] = (0x6 << 4);
205
206	/*
207	 * Use OpenFabrics IEEE Company ID: 00 14 05
208	 */
209	buf[off++] = 0x01;
210	buf[off++] = 0x40;
211	buf[off] = (0x5 << 4);
212
213	/*
214	 * Return ConfigFS Unit Serial Number information for
215	 * VENDOR_SPECIFIC_IDENTIFIER and
216	 * VENDOR_SPECIFIC_IDENTIFIER_EXTENTION
217	 */
218	binary = transport_asciihex_to_binaryhex(
219				&dev->se_sub_dev->t10_wwn.unit_serial[0]);
220	buf[off++] |= (binary & 0xf0) >> 4;
221	for (i = 0; i < 24; i += 2) {
222		binary_new = transport_asciihex_to_binaryhex(
223			&dev->se_sub_dev->t10_wwn.unit_serial[i+2]);
224		buf[off] = (binary & 0x0f) << 4;
225		buf[off++] |= (binary_new & 0xf0) >> 4;
226		binary = binary_new;
227	}
228	len = 20;
229	off = (len + 4);
230
231check_t10_vend_desc:
232	/*
233	 * T10 Vendor Identifier Page, see spc4r17 section 7.7.3.4
234	 */
235	id_len = 8; /* For Vendor field */
236	prod_len = 4; /* For VPD Header */
237	prod_len += 8; /* For Vendor field */
238	prod_len += strlen(prod);
239	prod_len++; /* For : */
240
241	if (dev->se_sub_dev->su_dev_flags &
242			SDF_EMULATED_VPD_UNIT_SERIAL) {
243		unit_serial_len =
244			strlen(&dev->se_sub_dev->t10_wwn.unit_serial[0]);
245		unit_serial_len++; /* For NULL Terminator */
246
247		if ((len + (id_len + 4) +
248		    (prod_len + unit_serial_len)) >
249				cmd->data_length) {
250			len += (prod_len + unit_serial_len);
251			goto check_port;
252		}
253		id_len += sprintf((unsigned char *)&buf[off+12],
254				"%s:%s", prod,
255				&dev->se_sub_dev->t10_wwn.unit_serial[0]);
256	}
257	buf[off] = 0x2; /* ASCII */
258	buf[off+1] = 0x1; /* T10 Vendor ID */
259	buf[off+2] = 0x0;
260	memcpy((unsigned char *)&buf[off+4], "LIO-ORG", 8);
261	/* Extra Byte for NULL Terminator */
262	id_len++;
263	/* Identifier Length */
264	buf[off+3] = id_len;
265	/* Header size for Designation descriptor */
266	len += (id_len + 4);
267	off += (id_len + 4);
268	/*
269	 * struct se_port is only set for INQUIRY VPD=1 through $FABRIC_MOD
270	 */
271check_port:
272	port = lun->lun_sep;
273	if (port) {
274		struct t10_alua_lu_gp *lu_gp;
275		u32 padding, scsi_name_len;
276		u16 lu_gp_id = 0;
277		u16 tg_pt_gp_id = 0;
278		u16 tpgt;
279
280		tpg = port->sep_tpg;
281		/*
282		 * Relative target port identifer, see spc4r17
283		 * section 7.7.3.7
284		 *
285		 * Get the PROTOCOL IDENTIFIER as defined by spc4r17
286		 * section 7.5.1 Table 362
287		 */
288		if (((len + 4) + 8) > cmd->data_length) {
289			len += 8;
290			goto check_tpgi;
291		}
292		buf[off] =
293			(tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4);
294		buf[off++] |= 0x1; /* CODE SET == Binary */
295		buf[off] = 0x80; /* Set PIV=1 */
296		/* Set ASSOICATION == target port: 01b */
297		buf[off] |= 0x10;
298		/* DESIGNATOR TYPE == Relative target port identifer */
299		buf[off++] |= 0x4;
300		off++; /* Skip over Reserved */
301		buf[off++] = 4; /* DESIGNATOR LENGTH */
302		/* Skip over Obsolete field in RTPI payload
303		 * in Table 472 */
304		off += 2;
305		buf[off++] = ((port->sep_rtpi >> 8) & 0xff);
306		buf[off++] = (port->sep_rtpi & 0xff);
307		len += 8; /* Header size + Designation descriptor */
308		/*
309		 * Target port group identifier, see spc4r17
310		 * section 7.7.3.8
311		 *
312		 * Get the PROTOCOL IDENTIFIER as defined by spc4r17
313		 * section 7.5.1 Table 362
314		 */
315check_tpgi:
316		if (dev->se_sub_dev->t10_alua.alua_type !=
317				SPC3_ALUA_EMULATED)
318			goto check_scsi_name;
319
320		if (((len + 4) + 8) > cmd->data_length) {
321			len += 8;
322			goto check_lu_gp;
323		}
324		tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
325		if (!tg_pt_gp_mem)
326			goto check_lu_gp;
327
328		spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
329		tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
330		if (!(tg_pt_gp)) {
331			spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
332			goto check_lu_gp;
333		}
334		tg_pt_gp_id = tg_pt_gp->tg_pt_gp_id;
335		spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
336
337		buf[off] =
338			(tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4);
339		buf[off++] |= 0x1; /* CODE SET == Binary */
340		buf[off] = 0x80; /* Set PIV=1 */
341		/* Set ASSOICATION == target port: 01b */
342		buf[off] |= 0x10;
343		/* DESIGNATOR TYPE == Target port group identifier */
344		buf[off++] |= 0x5;
345		off++; /* Skip over Reserved */
346		buf[off++] = 4; /* DESIGNATOR LENGTH */
347		off += 2; /* Skip over Reserved Field */
348		buf[off++] = ((tg_pt_gp_id >> 8) & 0xff);
349		buf[off++] = (tg_pt_gp_id & 0xff);
350		len += 8; /* Header size + Designation descriptor */
351		/*
352		 * Logical Unit Group identifier, see spc4r17
353		 * section 7.7.3.8
354		 */
355check_lu_gp:
356		if (((len + 4) + 8) > cmd->data_length) {
357			len += 8;
358			goto check_scsi_name;
359		}
360		lu_gp_mem = dev->dev_alua_lu_gp_mem;
361		if (!(lu_gp_mem))
362			goto check_scsi_name;
363
364		spin_lock(&lu_gp_mem->lu_gp_mem_lock);
365		lu_gp = lu_gp_mem->lu_gp;
366		if (!(lu_gp)) {
367			spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
368			goto check_scsi_name;
369		}
370		lu_gp_id = lu_gp->lu_gp_id;
371		spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
372
373		buf[off++] |= 0x1; /* CODE SET == Binary */
374		/* DESIGNATOR TYPE == Logical Unit Group identifier */
375		buf[off++] |= 0x6;
376		off++; /* Skip over Reserved */
377		buf[off++] = 4; /* DESIGNATOR LENGTH */
378		off += 2; /* Skip over Reserved Field */
379		buf[off++] = ((lu_gp_id >> 8) & 0xff);
380		buf[off++] = (lu_gp_id & 0xff);
381		len += 8; /* Header size + Designation descriptor */
382		/*
383		 * SCSI name string designator, see spc4r17
384		 * section 7.7.3.11
385		 *
386		 * Get the PROTOCOL IDENTIFIER as defined by spc4r17
387		 * section 7.5.1 Table 362
388		 */
389check_scsi_name:
390		scsi_name_len = strlen(tpg->se_tpg_tfo->tpg_get_wwn(tpg));
391		/* UTF-8 ",t,0x<16-bit TPGT>" + NULL Terminator */
392		scsi_name_len += 10;
393		/* Check for 4-byte padding */
394		padding = ((-scsi_name_len) & 3);
395		if (padding != 0)
396			scsi_name_len += padding;
397		/* Header size + Designation descriptor */
398		scsi_name_len += 4;
399
400		if (((len + 4) + scsi_name_len) > cmd->data_length) {
401			len += scsi_name_len;
402			goto set_len;
403		}
404		buf[off] =
405			(tpg->se_tpg_tfo->get_fabric_proto_ident(tpg) << 4);
406		buf[off++] |= 0x3; /* CODE SET == UTF-8 */
407		buf[off] = 0x80; /* Set PIV=1 */
408		/* Set ASSOICATION == target port: 01b */
409		buf[off] |= 0x10;
410		/* DESIGNATOR TYPE == SCSI name string */
411		buf[off++] |= 0x8;
412		off += 2; /* Skip over Reserved and length */
413		/*
414		 * SCSI name string identifer containing, $FABRIC_MOD
415		 * dependent information.  For LIO-Target and iSCSI
416		 * Target Port, this means "<iSCSI name>,t,0x<TPGT> in
417		 * UTF-8 encoding.
418		 */
419		tpgt = tpg->se_tpg_tfo->tpg_get_tag(tpg);
420		scsi_name_len = sprintf(&buf[off], "%s,t,0x%04x",
421					tpg->se_tpg_tfo->tpg_get_wwn(tpg), tpgt);
422		scsi_name_len += 1 /* Include  NULL terminator */;
423		/*
424		 * The null-terminated, null-padded (see 4.4.2) SCSI
425		 * NAME STRING field contains a UTF-8 format string.
426		 * The number of bytes in the SCSI NAME STRING field
427		 * (i.e., the value in the DESIGNATOR LENGTH field)
428		 * shall be no larger than 256 and shall be a multiple
429		 * of four.
430		 */
431		if (padding)
432			scsi_name_len += padding;
433
434		buf[off-1] = scsi_name_len;
435		off += scsi_name_len;
436		/* Header size + Designation descriptor */
437		len += (scsi_name_len + 4);
438	}
439set_len:
440	buf[2] = ((len >> 8) & 0xff);
441	buf[3] = (len & 0xff); /* Page Length for VPD 0x83 */
442	return 0;
443}
444
445/* Extended INQUIRY Data VPD Page */
446static int
447target_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf)
448{
449	if (cmd->data_length < 60)
450		return 0;
451
452	buf[2] = 0x3c;
453	/* Set HEADSUP, ORDSUP, SIMPSUP */
454	buf[5] = 0x07;
455
456	/* If WriteCache emulation is enabled, set V_SUP */
457	if (cmd->se_dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0)
458		buf[6] = 0x01;
459	return 0;
460}
461
462/* Block Limits VPD page */
463static int
464target_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)
465{
466	struct se_device *dev = cmd->se_dev;
467	int have_tp = 0;
468
469	/*
470	 * Following sbc3r22 section 6.5.3 Block Limits VPD page, when
471	 * emulate_tpu=1 or emulate_tpws=1 we will be expect a
472	 * different page length for Thin Provisioning.
473	 */
474	if (dev->se_sub_dev->se_dev_attrib.emulate_tpu || dev->se_sub_dev->se_dev_attrib.emulate_tpws)
475		have_tp = 1;
476
477	if (cmd->data_length < (0x10 + 4)) {
478		printk(KERN_INFO "Received data_length: %u"
479			" too small for EVPD 0xb0\n",
480			cmd->data_length);
481		return -EINVAL;
482	}
483
484	if (have_tp && cmd->data_length < (0x3c + 4)) {
485		printk(KERN_INFO "Received data_length: %u"
486			" too small for TPE=1 EVPD 0xb0\n",
487			cmd->data_length);
488		have_tp = 0;
489	}
490
491	buf[0] = dev->transport->get_device_type(dev);
492	buf[3] = have_tp ? 0x3c : 0x10;
493
494	/*
495	 * Set OPTIMAL TRANSFER LENGTH GRANULARITY
496	 */
497	put_unaligned_be16(1, &buf[6]);
498
499	/*
500	 * Set MAXIMUM TRANSFER LENGTH
501	 */
502	put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.max_sectors, &buf[8]);
503
504	/*
505	 * Set OPTIMAL TRANSFER LENGTH
506	 */
507	put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.optimal_sectors, &buf[12]);
508
509	/*
510	 * Exit now if we don't support TP or the initiator sent a too
511	 * short buffer.
512	 */
513	if (!have_tp || cmd->data_length < (0x3c + 4))
514		return 0;
515
516	/*
517	 * Set MAXIMUM UNMAP LBA COUNT
518	 */
519	put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.max_unmap_lba_count, &buf[20]);
520
521	/*
522	 * Set MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT
523	 */
524	put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count,
525			   &buf[24]);
526
527	/*
528	 * Set OPTIMAL UNMAP GRANULARITY
529	 */
530	put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.unmap_granularity, &buf[28]);
531
532	/*
533	 * UNMAP GRANULARITY ALIGNMENT
534	 */
535	put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.unmap_granularity_alignment,
536			   &buf[32]);
537	if (dev->se_sub_dev->se_dev_attrib.unmap_granularity_alignment != 0)
538		buf[32] |= 0x80; /* Set the UGAVALID bit */
539
540	return 0;
541}
542
543/* Block Device Characteristics VPD page */
544static int
545target_emulate_evpd_b1(struct se_cmd *cmd, unsigned char *buf)
546{
547	struct se_device *dev = cmd->se_dev;
548
549	buf[0] = dev->transport->get_device_type(dev);
550	buf[3] = 0x3c;
551
552	if (cmd->data_length >= 5 &&
553	    dev->se_sub_dev->se_dev_attrib.is_nonrot)
554		buf[5] = 1;
555
556	return 0;
557}
558
559/* Thin Provisioning VPD */
560static int
561target_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf)
562{
563	struct se_device *dev = cmd->se_dev;
564
565	/*
566	 * From sbc3r22 section 6.5.4 Thin Provisioning VPD page:
567	 *
568	 * The PAGE LENGTH field is defined in SPC-4. If the DP bit is set to
569	 * zero, then the page length shall be set to 0004h.  If the DP bit
570	 * is set to one, then the page length shall be set to the value
571	 * defined in table 162.
572	 */
573	buf[0] = dev->transport->get_device_type(dev);
574
575	/*
576	 * Set Hardcoded length mentioned above for DP=0
577	 */
578	put_unaligned_be16(0x0004, &buf[2]);
579
580	/*
581	 * The THRESHOLD EXPONENT field indicates the threshold set size in
582	 * LBAs as a power of 2 (i.e., the threshold set size is equal to
583	 * 2(threshold exponent)).
584	 *
585	 * Note that this is currently set to 0x00 as mkp says it will be
586	 * changing again.  We can enable this once it has settled in T10
587	 * and is actually used by Linux/SCSI ML code.
588	 */
589	buf[4] = 0x00;
590
591	/*
592	 * A TPU bit set to one indicates that the device server supports
593	 * the UNMAP command (see 5.25). A TPU bit set to zero indicates
594	 * that the device server does not support the UNMAP command.
595	 */
596	if (dev->se_sub_dev->se_dev_attrib.emulate_tpu != 0)
597		buf[5] = 0x80;
598
599	/*
600	 * A TPWS bit set to one indicates that the device server supports
601	 * the use of the WRITE SAME (16) command (see 5.42) to unmap LBAs.
602	 * A TPWS bit set to zero indicates that the device server does not
603	 * support the use of the WRITE SAME (16) command to unmap LBAs.
604	 */
605	if (dev->se_sub_dev->se_dev_attrib.emulate_tpws != 0)
606		buf[5] |= 0x40;
607
608	return 0;
609}
610
611static int
612target_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf);
613
614static struct {
615	uint8_t		page;
616	int		(*emulate)(struct se_cmd *, unsigned char *);
617} evpd_handlers[] = {
618	{ .page = 0x00, .emulate = target_emulate_evpd_00 },
619	{ .page = 0x80, .emulate = target_emulate_evpd_80 },
620	{ .page = 0x83, .emulate = target_emulate_evpd_83 },
621	{ .page = 0x86, .emulate = target_emulate_evpd_86 },
622	{ .page = 0xb0, .emulate = target_emulate_evpd_b0 },
623	{ .page = 0xb1, .emulate = target_emulate_evpd_b1 },
624	{ .page = 0xb2, .emulate = target_emulate_evpd_b2 },
625};
626
627/* supported vital product data pages */
628static int
629target_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf)
630{
631	int p;
632
633	if (cmd->data_length < 8)
634		return 0;
635	/*
636	 * Only report the INQUIRY EVPD=1 pages after a valid NAA
637	 * Registered Extended LUN WWN has been set via ConfigFS
638	 * during device creation/restart.
639	 */
640	if (cmd->se_dev->se_sub_dev->su_dev_flags &
641			SDF_EMULATED_VPD_UNIT_SERIAL) {
642		buf[3] = ARRAY_SIZE(evpd_handlers);
643		for (p = 0; p < min_t(int, ARRAY_SIZE(evpd_handlers),
644				      cmd->data_length - 4); ++p)
645			buf[p + 4] = evpd_handlers[p].page;
646	}
647
648	return 0;
649}
650
651static int
652target_emulate_inquiry(struct se_cmd *cmd)
653{
654	struct se_device *dev = cmd->se_dev;
655	unsigned char *buf;
656	unsigned char *cdb = cmd->t_task_cdb;
657	int p, ret;
658
659	if (!(cdb[1] & 0x1))
660		return target_emulate_inquiry_std(cmd);
661
662	/*
663	 * Make sure we at least have 4 bytes of INQUIRY response
664	 * payload for 0x00 going back for EVPD=1.  Note that 0x80
665	 * and 0x83 will check for enough payload data length and
666	 * jump to set_len: label when there is not enough inquiry EVPD
667	 * payload length left for the next outgoing EVPD metadata
668	 */
669	if (cmd->data_length < 4) {
670		printk(KERN_ERR "SCSI Inquiry payload length: %u"
671			" too small for EVPD=1\n", cmd->data_length);
672		return -EINVAL;
673	}
674
675	buf = transport_kmap_first_data_page(cmd);
676
677	buf[0] = dev->transport->get_device_type(dev);
678
679	for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p)
680		if (cdb[2] == evpd_handlers[p].page) {
681			buf[1] = cdb[2];
682			ret = evpd_handlers[p].emulate(cmd, buf);
683			transport_kunmap_first_data_page(cmd);
684			return ret;
685		}
686
687	transport_kunmap_first_data_page(cmd);
688	printk(KERN_ERR "Unknown VPD Code: 0x%02x\n", cdb[2]);
689	return -EINVAL;
690}
691
692static int
693target_emulate_readcapacity(struct se_cmd *cmd)
694{
695	struct se_device *dev = cmd->se_dev;
696	unsigned char *buf;
697	unsigned long long blocks_long = dev->transport->get_blocks(dev);
698	u32 blocks;
699
700	if (blocks_long >= 0x00000000ffffffff)
701		blocks = 0xffffffff;
702	else
703		blocks = (u32)blocks_long;
704
705	buf = transport_kmap_first_data_page(cmd);
706
707	buf[0] = (blocks >> 24) & 0xff;
708	buf[1] = (blocks >> 16) & 0xff;
709	buf[2] = (blocks >> 8) & 0xff;
710	buf[3] = blocks & 0xff;
711	buf[4] = (dev->se_sub_dev->se_dev_attrib.block_size >> 24) & 0xff;
712	buf[5] = (dev->se_sub_dev->se_dev_attrib.block_size >> 16) & 0xff;
713	buf[6] = (dev->se_sub_dev->se_dev_attrib.block_size >> 8) & 0xff;
714	buf[7] = dev->se_sub_dev->se_dev_attrib.block_size & 0xff;
715	/*
716	 * Set max 32-bit blocks to signal SERVICE ACTION READ_CAPACITY_16
717	*/
718	if (dev->se_sub_dev->se_dev_attrib.emulate_tpu || dev->se_sub_dev->se_dev_attrib.emulate_tpws)
719		put_unaligned_be32(0xFFFFFFFF, &buf[0]);
720
721	transport_kunmap_first_data_page(cmd);
722
723	return 0;
724}
725
726static int
727target_emulate_readcapacity_16(struct se_cmd *cmd)
728{
729	struct se_device *dev = cmd->se_dev;
730	unsigned char *buf;
731	unsigned long long blocks = dev->transport->get_blocks(dev);
732
733	buf = transport_kmap_first_data_page(cmd);
734
735	buf[0] = (blocks >> 56) & 0xff;
736	buf[1] = (blocks >> 48) & 0xff;
737	buf[2] = (blocks >> 40) & 0xff;
738	buf[3] = (blocks >> 32) & 0xff;
739	buf[4] = (blocks >> 24) & 0xff;
740	buf[5] = (blocks >> 16) & 0xff;
741	buf[6] = (blocks >> 8) & 0xff;
742	buf[7] = blocks & 0xff;
743	buf[8] = (dev->se_sub_dev->se_dev_attrib.block_size >> 24) & 0xff;
744	buf[9] = (dev->se_sub_dev->se_dev_attrib.block_size >> 16) & 0xff;
745	buf[10] = (dev->se_sub_dev->se_dev_attrib.block_size >> 8) & 0xff;
746	buf[11] = dev->se_sub_dev->se_dev_attrib.block_size & 0xff;
747	/*
748	 * Set Thin Provisioning Enable bit following sbc3r22 in section
749	 * READ CAPACITY (16) byte 14 if emulate_tpu or emulate_tpws is enabled.
750	 */
751	if (dev->se_sub_dev->se_dev_attrib.emulate_tpu || dev->se_sub_dev->se_dev_attrib.emulate_tpws)
752		buf[14] = 0x80;
753
754	transport_kunmap_first_data_page(cmd);
755
756	return 0;
757}
758
759static int
760target_modesense_rwrecovery(unsigned char *p)
761{
762	p[0] = 0x01;
763	p[1] = 0x0a;
764
765	return 12;
766}
767
768static int
769target_modesense_control(struct se_device *dev, unsigned char *p)
770{
771	p[0] = 0x0a;
772	p[1] = 0x0a;
773	p[2] = 2;
774	/*
775	 * From spc4r17, section 7.4.6 Control mode Page
776	 *
777	 * Unit Attention interlocks control (UN_INTLCK_CTRL) to code 00b
778	 *
779	 * 00b: The logical unit shall clear any unit attention condition
780	 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
781	 * status and shall not establish a unit attention condition when a com-
782	 * mand is completed with BUSY, TASK SET FULL, or RESERVATION CONFLICT
783	 * status.
784	 *
785	 * 10b: The logical unit shall not clear any unit attention condition
786	 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
787	 * status and shall not establish a unit attention condition when
788	 * a command is completed with BUSY, TASK SET FULL, or RESERVATION
789	 * CONFLICT status.
790	 *
791	 * 11b a The logical unit shall not clear any unit attention condition
792	 * reported in the same I_T_L_Q nexus transaction as a CHECK CONDITION
793	 * status and shall establish a unit attention condition for the
794	 * initiator port associated with the I_T nexus on which the BUSY,
795	 * TASK SET FULL, or RESERVATION CONFLICT status is being returned.
796	 * Depending on the status, the additional sense code shall be set to
797	 * PREVIOUS BUSY STATUS, PREVIOUS TASK SET FULL STATUS, or PREVIOUS
798	 * RESERVATION CONFLICT STATUS. Until it is cleared by a REQUEST SENSE
799	 * command, a unit attention condition shall be established only once
800	 * for a BUSY, TASK SET FULL, or RESERVATION CONFLICT status regardless
801	 * to the number of commands completed with one of those status codes.
802	 */
803	p[4] = (dev->se_sub_dev->se_dev_attrib.emulate_ua_intlck_ctrl == 2) ? 0x30 :
804	       (dev->se_sub_dev->se_dev_attrib.emulate_ua_intlck_ctrl == 1) ? 0x20 : 0x00;
805	/*
806	 * From spc4r17, section 7.4.6 Control mode Page
807	 *
808	 * Task Aborted Status (TAS) bit set to zero.
809	 *
810	 * A task aborted status (TAS) bit set to zero specifies that aborted
811	 * tasks shall be terminated by the device server without any response
812	 * to the application client. A TAS bit set to one specifies that tasks
813	 * aborted by the actions of an I_T nexus other than the I_T nexus on
814	 * which the command was received shall be completed with TASK ABORTED
815	 * status (see SAM-4).
816	 */
817	p[5] = (dev->se_sub_dev->se_dev_attrib.emulate_tas) ? 0x40 : 0x00;
818	p[8] = 0xff;
819	p[9] = 0xff;
820	p[11] = 30;
821
822	return 12;
823}
824
825static int
826target_modesense_caching(struct se_device *dev, unsigned char *p)
827{
828	p[0] = 0x08;
829	p[1] = 0x12;
830	if (dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0)
831		p[2] = 0x04; /* Write Cache Enable */
832	p[12] = 0x20; /* Disabled Read Ahead */
833
834	return 20;
835}
836
837static void
838target_modesense_write_protect(unsigned char *buf, int type)
839{
840	/*
841	 * I believe that the WP bit (bit 7) in the mode header is the same for
842	 * all device types..
843	 */
844	switch (type) {
845	case TYPE_DISK:
846	case TYPE_TAPE:
847	default:
848		buf[0] |= 0x80; /* WP bit */
849		break;
850	}
851}
852
853static void
854target_modesense_dpofua(unsigned char *buf, int type)
855{
856	switch (type) {
857	case TYPE_DISK:
858		buf[0] |= 0x10; /* DPOFUA bit */
859		break;
860	default:
861		break;
862	}
863}
864
865static int
866target_emulate_modesense(struct se_cmd *cmd, int ten)
867{
868	struct se_device *dev = cmd->se_dev;
869	char *cdb = cmd->t_task_cdb;
870	unsigned char *rbuf;
871	int type = dev->transport->get_device_type(dev);
872	int offset = (ten) ? 8 : 4;
873	int length = 0;
874	unsigned char buf[SE_MODE_PAGE_BUF];
875
876	memset(buf, 0, SE_MODE_PAGE_BUF);
877
878	switch (cdb[2] & 0x3f) {
879	case 0x01:
880		length = target_modesense_rwrecovery(&buf[offset]);
881		break;
882	case 0x08:
883		length = target_modesense_caching(dev, &buf[offset]);
884		break;
885	case 0x0a:
886		length = target_modesense_control(dev, &buf[offset]);
887		break;
888	case 0x3f:
889		length = target_modesense_rwrecovery(&buf[offset]);
890		length += target_modesense_caching(dev, &buf[offset+length]);
891		length += target_modesense_control(dev, &buf[offset+length]);
892		break;
893	default:
894		printk(KERN_ERR "Got Unknown Mode Page: 0x%02x\n",
895				cdb[2] & 0x3f);
896		return PYX_TRANSPORT_UNKNOWN_MODE_PAGE;
897	}
898	offset += length;
899
900	if (ten) {
901		offset -= 2;
902		buf[0] = (offset >> 8) & 0xff;
903		buf[1] = offset & 0xff;
904
905		if ((cmd->se_lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) ||
906		    (cmd->se_deve &&
907		    (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)))
908			target_modesense_write_protect(&buf[3], type);
909
910		if ((dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0) &&
911		    (dev->se_sub_dev->se_dev_attrib.emulate_fua_write > 0))
912			target_modesense_dpofua(&buf[3], type);
913
914		if ((offset + 2) > cmd->data_length)
915			offset = cmd->data_length;
916
917	} else {
918		offset -= 1;
919		buf[0] = offset & 0xff;
920
921		if ((cmd->se_lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) ||
922		    (cmd->se_deve &&
923		    (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)))
924			target_modesense_write_protect(&buf[2], type);
925
926		if ((dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0) &&
927		    (dev->se_sub_dev->se_dev_attrib.emulate_fua_write > 0))
928			target_modesense_dpofua(&buf[2], type);
929
930		if ((offset + 1) > cmd->data_length)
931			offset = cmd->data_length;
932	}
933
934	rbuf = transport_kmap_first_data_page(cmd);
935	memcpy(rbuf, buf, offset);
936	transport_kunmap_first_data_page(cmd);
937
938	return 0;
939}
940
941static int
942target_emulate_request_sense(struct se_cmd *cmd)
943{
944	unsigned char *cdb = cmd->t_task_cdb;
945	unsigned char *buf;
946	u8 ua_asc = 0, ua_ascq = 0;
947	int err = 0;
948
949	if (cdb[1] & 0x01) {
950		printk(KERN_ERR "REQUEST_SENSE description emulation not"
951			" supported\n");
952		return PYX_TRANSPORT_INVALID_CDB_FIELD;
953	}
954
955	buf = transport_kmap_first_data_page(cmd);
956
957	if (!(core_scsi3_ua_clear_for_request_sense(cmd, &ua_asc, &ua_ascq))) {
958		/*
959		 * CURRENT ERROR, UNIT ATTENTION
960		 */
961		buf[0] = 0x70;
962		buf[SPC_SENSE_KEY_OFFSET] = UNIT_ATTENTION;
963		/*
964		 * Make sure request data length is enough for additional
965		 * sense data.
966		 */
967		if (cmd->data_length <= 18) {
968			buf[7] = 0x00;
969			err = -EINVAL;
970			goto end;
971		}
972		/*
973		 * The Additional Sense Code (ASC) from the UNIT ATTENTION
974		 */
975		buf[SPC_ASC_KEY_OFFSET] = ua_asc;
976		buf[SPC_ASCQ_KEY_OFFSET] = ua_ascq;
977		buf[7] = 0x0A;
978	} else {
979		/*
980		 * CURRENT ERROR, NO SENSE
981		 */
982		buf[0] = 0x70;
983		buf[SPC_SENSE_KEY_OFFSET] = NO_SENSE;
984		/*
985		 * Make sure request data length is enough for additional
986		 * sense data.
987		 */
988		if (cmd->data_length <= 18) {
989			buf[7] = 0x00;
990			err = -EINVAL;
991			goto end;
992		}
993		/*
994		 * NO ADDITIONAL SENSE INFORMATION
995		 */
996		buf[SPC_ASC_KEY_OFFSET] = 0x00;
997		buf[7] = 0x0A;
998	}
999
1000end:
1001	transport_kunmap_first_data_page(cmd);
1002
1003	return 0;
1004}
1005
1006/*
1007 * Used for TCM/IBLOCK and TCM/FILEIO for block/blk-lib.c level discard support.
1008 * Note this is not used for TCM/pSCSI passthrough
1009 */
1010static int
1011target_emulate_unmap(struct se_task *task)
1012{
1013	struct se_cmd *cmd = task->task_se_cmd;
1014	struct se_device *dev = cmd->se_dev;
1015	unsigned char *buf, *ptr = NULL;
1016	unsigned char *cdb = &cmd->t_task_cdb[0];
1017	sector_t lba;
1018	unsigned int size = cmd->data_length, range;
1019	int ret = 0, offset;
1020	unsigned short dl, bd_dl;
1021
1022	/* First UNMAP block descriptor starts at 8 byte offset */
1023	offset = 8;
1024	size -= 8;
1025	dl = get_unaligned_be16(&cdb[0]);
1026	bd_dl = get_unaligned_be16(&cdb[2]);
1027
1028	buf = transport_kmap_first_data_page(cmd);
1029
1030	ptr = &buf[offset];
1031	printk(KERN_INFO "UNMAP: Sub: %s Using dl: %hu bd_dl: %hu size: %hu"
1032		" ptr: %p\n", dev->transport->name, dl, bd_dl, size, ptr);
1033
1034	while (size) {
1035		lba = get_unaligned_be64(&ptr[0]);
1036		range = get_unaligned_be32(&ptr[8]);
1037		printk(KERN_INFO "UNMAP: Using lba: %llu and range: %u\n",
1038				 (unsigned long long)lba, range);
1039
1040		ret = dev->transport->do_discard(dev, lba, range);
1041		if (ret < 0) {
1042			printk(KERN_ERR "blkdev_issue_discard() failed: %d\n",
1043					ret);
1044			goto err;
1045		}
1046
1047		ptr += 16;
1048		size -= 16;
1049	}
1050
1051	task->task_scsi_status = GOOD;
1052	transport_complete_task(task, 1);
1053err:
1054	transport_kunmap_first_data_page(cmd);
1055
1056	return ret;
1057}
1058
1059/*
1060 * Used for TCM/IBLOCK and TCM/FILEIO for block/blk-lib.c level discard support.
1061 * Note this is not used for TCM/pSCSI passthrough
1062 */
1063static int
1064target_emulate_write_same(struct se_task *task, int write_same32)
1065{
1066	struct se_cmd *cmd = task->task_se_cmd;
1067	struct se_device *dev = cmd->se_dev;
1068	sector_t range;
1069	sector_t lba = cmd->t_task_lba;
1070	unsigned int num_blocks;
1071	int ret;
1072	/*
1073	 * Extract num_blocks from the WRITE_SAME_* CDB.  Then use the explict
1074	 * range when non zero is supplied, otherwise calculate the remaining
1075	 * range based on ->get_blocks() - starting LBA.
1076	 */
1077	if (write_same32)
1078		num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]);
1079	else
1080		num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]);
1081
1082	if (num_blocks != 0)
1083		range = num_blocks;
1084	else
1085		range = (dev->transport->get_blocks(dev) - lba);
1086
1087	printk(KERN_INFO "WRITE_SAME UNMAP: LBA: %llu Range: %llu\n",
1088		 (unsigned long long)lba, (unsigned long long)range);
1089
1090	ret = dev->transport->do_discard(dev, lba, range);
1091	if (ret < 0) {
1092		printk(KERN_INFO "blkdev_issue_discard() failed for WRITE_SAME\n");
1093		return ret;
1094	}
1095
1096	task->task_scsi_status = GOOD;
1097	transport_complete_task(task, 1);
1098	return 0;
1099}
1100
1101int
1102transport_emulate_control_cdb(struct se_task *task)
1103{
1104	struct se_cmd *cmd = task->task_se_cmd;
1105	struct se_device *dev = cmd->se_dev;
1106	unsigned short service_action;
1107	int ret = 0;
1108
1109	switch (cmd->t_task_cdb[0]) {
1110	case INQUIRY:
1111		ret = target_emulate_inquiry(cmd);
1112		break;
1113	case READ_CAPACITY:
1114		ret = target_emulate_readcapacity(cmd);
1115		break;
1116	case MODE_SENSE:
1117		ret = target_emulate_modesense(cmd, 0);
1118		break;
1119	case MODE_SENSE_10:
1120		ret = target_emulate_modesense(cmd, 1);
1121		break;
1122	case SERVICE_ACTION_IN:
1123		switch (cmd->t_task_cdb[1] & 0x1f) {
1124		case SAI_READ_CAPACITY_16:
1125			ret = target_emulate_readcapacity_16(cmd);
1126			break;
1127		default:
1128			printk(KERN_ERR "Unsupported SA: 0x%02x\n",
1129				cmd->t_task_cdb[1] & 0x1f);
1130			return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
1131		}
1132		break;
1133	case REQUEST_SENSE:
1134		ret = target_emulate_request_sense(cmd);
1135		break;
1136	case UNMAP:
1137		if (!dev->transport->do_discard) {
1138			printk(KERN_ERR "UNMAP emulation not supported for: %s\n",
1139					dev->transport->name);
1140			return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
1141		}
1142		ret = target_emulate_unmap(task);
1143		break;
1144	case WRITE_SAME_16:
1145		if (!dev->transport->do_discard) {
1146			printk(KERN_ERR "WRITE_SAME_16 emulation not supported"
1147					" for: %s\n", dev->transport->name);
1148			return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
1149		}
1150		ret = target_emulate_write_same(task, 0);
1151		break;
1152	case VARIABLE_LENGTH_CMD:
1153		service_action =
1154			get_unaligned_be16(&cmd->t_task_cdb[8]);
1155		switch (service_action) {
1156		case WRITE_SAME_32:
1157			if (!dev->transport->do_discard) {
1158				printk(KERN_ERR "WRITE_SAME_32 SA emulation not"
1159					" supported for: %s\n",
1160					dev->transport->name);
1161				return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
1162			}
1163			ret = target_emulate_write_same(task, 1);
1164			break;
1165		default:
1166			printk(KERN_ERR "Unsupported VARIABLE_LENGTH_CMD SA:"
1167					" 0x%02x\n", service_action);
1168			break;
1169		}
1170		break;
1171	case SYNCHRONIZE_CACHE:
1172	case 0x91: /* SYNCHRONIZE_CACHE_16: */
1173		if (!dev->transport->do_sync_cache) {
1174			printk(KERN_ERR
1175				"SYNCHRONIZE_CACHE emulation not supported"
1176				" for: %s\n", dev->transport->name);
1177			return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
1178		}
1179		dev->transport->do_sync_cache(task);
1180		break;
1181	case ALLOW_MEDIUM_REMOVAL:
1182	case ERASE:
1183	case REZERO_UNIT:
1184	case SEEK_10:
1185	case SPACE:
1186	case START_STOP:
1187	case TEST_UNIT_READY:
1188	case VERIFY:
1189	case WRITE_FILEMARKS:
1190		break;
1191	default:
1192		printk(KERN_ERR "Unsupported SCSI Opcode: 0x%02x for %s\n",
1193			cmd->t_task_cdb[0], dev->transport->name);
1194		return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
1195	}
1196
1197	if (ret < 0)
1198		return ret;
1199	task->task_scsi_status = GOOD;
1200	transport_complete_task(task, 1);
1201
1202	return PYX_TRANSPORT_SENT_TO_TRANSPORT;
1203}
1204