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