1
2
3
4
5
6
7
8
9
10#include <linux/kernel.h>
11#include <linux/module.h>
12#include <asm/unaligned.h>
13
14#include <scsi/scsi_proto.h>
15#include <scsi/scsi_common.h>
16#include <scsi/scsi_tcq.h>
17
18#include <target/target_core_base.h>
19#include <target/target_core_backend.h>
20#include <target/target_core_fabric.h>
21
22#include "target_core_internal.h"
23#include "target_core_alua.h"
24#include "target_core_pr.h"
25#include "target_core_ua.h"
26#include "target_core_xcopy.h"
27
28static void spc_fill_alua_data(struct se_lun *lun, unsigned char *buf)
29{
30 struct t10_alua_tg_pt_gp *tg_pt_gp;
31
32
33
34
35 buf[5] = 0x80;
36
37
38
39
40
41
42
43 rcu_read_lock();
44 tg_pt_gp = rcu_dereference(lun->lun_tg_pt_gp);
45 if (tg_pt_gp)
46 buf[5] |= tg_pt_gp->tg_pt_gp_alua_access_type;
47 rcu_read_unlock();
48}
49
50static u16
51spc_find_scsi_transport_vd(int proto_id)
52{
53 switch (proto_id) {
54 case SCSI_PROTOCOL_FCP:
55 return SCSI_VERSION_DESCRIPTOR_FCP4;
56 case SCSI_PROTOCOL_ISCSI:
57 return SCSI_VERSION_DESCRIPTOR_ISCSI;
58 case SCSI_PROTOCOL_SAS:
59 return SCSI_VERSION_DESCRIPTOR_SAS3;
60 case SCSI_PROTOCOL_SBP:
61 return SCSI_VERSION_DESCRIPTOR_SBP3;
62 case SCSI_PROTOCOL_SRP:
63 return SCSI_VERSION_DESCRIPTOR_SRP;
64 default:
65 pr_warn("Cannot find VERSION DESCRIPTOR value for unknown SCSI"
66 " transport PROTOCOL IDENTIFIER %#x\n", proto_id);
67 return 0;
68 }
69}
70
71sense_reason_t
72spc_emulate_inquiry_std(struct se_cmd *cmd, unsigned char *buf)
73{
74 struct se_lun *lun = cmd->se_lun;
75 struct se_portal_group *tpg = lun->lun_tpg;
76 struct se_device *dev = cmd->se_dev;
77 struct se_session *sess = cmd->se_sess;
78
79
80 if (dev->transport->get_device_type(dev) == TYPE_TAPE)
81 buf[1] = 0x80;
82
83 buf[2] = 0x06;
84
85
86
87
88
89
90
91
92
93
94
95 buf[3] = 2;
96
97
98
99
100 spc_fill_alua_data(lun, buf);
101
102
103
104
105 if (dev->dev_attrib.emulate_3pc)
106 buf[5] |= 0x8;
107
108
109
110
111
112
113 if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
114 if (dev->dev_attrib.pi_prot_type || cmd->se_sess->sess_prot_type)
115 buf[5] |= 0x1;
116 }
117
118 buf[7] = 0x2;
119
120
121
122
123
124
125 memset(&buf[8], 0x20,
126 INQUIRY_VENDOR_LEN + INQUIRY_MODEL_LEN + INQUIRY_REVISION_LEN);
127 memcpy(&buf[8], dev->t10_wwn.vendor,
128 strnlen(dev->t10_wwn.vendor, INQUIRY_VENDOR_LEN));
129 memcpy(&buf[16], dev->t10_wwn.model,
130 strnlen(dev->t10_wwn.model, INQUIRY_MODEL_LEN));
131 memcpy(&buf[32], dev->t10_wwn.revision,
132 strnlen(dev->t10_wwn.revision, INQUIRY_REVISION_LEN));
133
134
135
136
137 put_unaligned_be16(SCSI_VERSION_DESCRIPTOR_SAM5, &buf[58]);
138 put_unaligned_be16(spc_find_scsi_transport_vd(tpg->proto_id), &buf[60]);
139 put_unaligned_be16(SCSI_VERSION_DESCRIPTOR_SPC4, &buf[62]);
140 if (cmd->se_dev->transport->get_device_type(dev) == TYPE_DISK)
141 put_unaligned_be16(SCSI_VERSION_DESCRIPTOR_SBC3, &buf[64]);
142
143 buf[4] = 91;
144
145 return 0;
146}
147EXPORT_SYMBOL(spc_emulate_inquiry_std);
148
149
150static sense_reason_t
151spc_emulate_evpd_80(struct se_cmd *cmd, unsigned char *buf)
152{
153 struct se_device *dev = cmd->se_dev;
154 u16 len;
155
156 if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
157 len = sprintf(&buf[4], "%s", dev->t10_wwn.unit_serial);
158 len++;
159 buf[3] = len;
160 }
161 return 0;
162}
163
164
165
166
167void spc_gen_naa_6h_vendor_specific(struct se_device *dev,
168 unsigned char *buf)
169{
170 unsigned char *p = &dev->t10_wwn.unit_serial[0];
171 u32 company_id = dev->t10_wwn.company_id;
172 int cnt, off = 0;
173 bool next = true;
174
175
176
177
178 buf[off] = 0x6 << 4;
179
180
181 buf[off++] |= (company_id >> 20) & 0xf;
182 buf[off++] = (company_id >> 12) & 0xff;
183 buf[off++] = (company_id >> 4) & 0xff;
184 buf[off] = (company_id & 0xf) << 4;
185
186
187
188
189
190
191
192
193
194 for (cnt = off + 13; *p && off < cnt; p++) {
195 int val = hex_to_bin(*p);
196
197 if (val < 0)
198 continue;
199
200 if (next) {
201 next = false;
202 buf[off++] |= val;
203 } else {
204 next = true;
205 buf[off] = val << 4;
206 }
207 }
208}
209
210
211
212
213
214sense_reason_t
215spc_emulate_evpd_83(struct se_cmd *cmd, unsigned char *buf)
216{
217 struct se_device *dev = cmd->se_dev;
218 struct se_lun *lun = cmd->se_lun;
219 struct se_portal_group *tpg = NULL;
220 struct t10_alua_lu_gp_member *lu_gp_mem;
221 struct t10_alua_tg_pt_gp *tg_pt_gp;
222 unsigned char *prod = &dev->t10_wwn.model[0];
223 u32 prod_len;
224 u32 unit_serial_len, off = 0;
225 u16 len = 0, id_len;
226
227 off = 4;
228
229
230
231
232
233
234
235
236
237 if (!(dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL))
238 goto check_t10_vend_desc;
239
240
241 buf[off++] = 0x1;
242
243
244 buf[off] = 0x00;
245
246
247 buf[off++] |= 0x3;
248 off++;
249
250
251 buf[off++] = 0x10;
252
253
254 spc_gen_naa_6h_vendor_specific(dev, &buf[off]);
255
256 len = 20;
257 off = (len + 4);
258
259check_t10_vend_desc:
260
261
262
263 id_len = 8;
264 prod_len = 4;
265 prod_len += 8;
266 prod_len += strlen(prod);
267 prod_len++;
268
269 if (dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
270 unit_serial_len = strlen(&dev->t10_wwn.unit_serial[0]);
271 unit_serial_len++;
272
273 id_len += sprintf(&buf[off+12], "%s:%s", prod,
274 &dev->t10_wwn.unit_serial[0]);
275 }
276 buf[off] = 0x2;
277 buf[off+1] = 0x1;
278 buf[off+2] = 0x0;
279
280 memset(&buf[off+4], 0x20, INQUIRY_VENDOR_LEN);
281 memcpy(&buf[off+4], dev->t10_wwn.vendor,
282 strnlen(dev->t10_wwn.vendor, INQUIRY_VENDOR_LEN));
283
284 id_len++;
285
286 buf[off+3] = id_len;
287
288 len += (id_len + 4);
289 off += (id_len + 4);
290
291 if (1) {
292 struct t10_alua_lu_gp *lu_gp;
293 u32 padding, scsi_name_len, scsi_target_len;
294 u16 lu_gp_id = 0;
295 u16 tg_pt_gp_id = 0;
296 u16 tpgt;
297
298 tpg = lun->lun_tpg;
299
300
301
302
303
304
305
306 buf[off] = tpg->proto_id << 4;
307 buf[off++] |= 0x1;
308 buf[off] = 0x80;
309
310 buf[off] |= 0x10;
311
312 buf[off++] |= 0x4;
313 off++;
314 buf[off++] = 4;
315
316
317 off += 2;
318 put_unaligned_be16(lun->lun_rtpi, &buf[off]);
319 off += 2;
320 len += 8;
321
322
323
324
325
326
327
328 rcu_read_lock();
329 tg_pt_gp = rcu_dereference(lun->lun_tg_pt_gp);
330 if (!tg_pt_gp) {
331 rcu_read_unlock();
332 goto check_lu_gp;
333 }
334 tg_pt_gp_id = tg_pt_gp->tg_pt_gp_id;
335 rcu_read_unlock();
336
337 buf[off] = tpg->proto_id << 4;
338 buf[off++] |= 0x1;
339 buf[off] = 0x80;
340
341 buf[off] |= 0x10;
342
343 buf[off++] |= 0x5;
344 off++;
345 buf[off++] = 4;
346 off += 2;
347 put_unaligned_be16(tg_pt_gp_id, &buf[off]);
348 off += 2;
349 len += 8;
350
351
352
353
354check_lu_gp:
355 lu_gp_mem = dev->dev_alua_lu_gp_mem;
356 if (!lu_gp_mem)
357 goto check_scsi_name;
358
359 spin_lock(&lu_gp_mem->lu_gp_mem_lock);
360 lu_gp = lu_gp_mem->lu_gp;
361 if (!lu_gp) {
362 spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
363 goto check_scsi_name;
364 }
365 lu_gp_id = lu_gp->lu_gp_id;
366 spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
367
368 buf[off++] |= 0x1;
369
370 buf[off++] |= 0x6;
371 off++;
372 buf[off++] = 4;
373 off += 2;
374 put_unaligned_be16(lu_gp_id, &buf[off]);
375 off += 2;
376 len += 8;
377
378
379
380
381
382
383
384check_scsi_name:
385 buf[off] = tpg->proto_id << 4;
386 buf[off++] |= 0x3;
387 buf[off] = 0x80;
388
389 buf[off] |= 0x10;
390
391 buf[off++] |= 0x8;
392 off += 2;
393
394
395
396
397
398
399 tpgt = tpg->se_tpg_tfo->tpg_get_tag(tpg);
400 scsi_name_len = sprintf(&buf[off], "%s,t,0x%04x",
401 tpg->se_tpg_tfo->tpg_get_wwn(tpg), tpgt);
402 scsi_name_len += 1 ;
403
404
405
406
407
408
409
410
411 padding = ((-scsi_name_len) & 3);
412 if (padding)
413 scsi_name_len += padding;
414 if (scsi_name_len > 256)
415 scsi_name_len = 256;
416
417 buf[off-1] = scsi_name_len;
418 off += scsi_name_len;
419
420 len += (scsi_name_len + 4);
421
422
423
424
425 buf[off] = tpg->proto_id << 4;
426 buf[off++] |= 0x3;
427 buf[off] = 0x80;
428
429 buf[off] |= 0x20;
430
431 buf[off++] |= 0x8;
432 off += 2;
433
434
435
436
437
438
439 scsi_target_len = sprintf(&buf[off], "%s",
440 tpg->se_tpg_tfo->tpg_get_wwn(tpg));
441 scsi_target_len += 1 ;
442
443
444
445
446
447
448
449
450 padding = ((-scsi_target_len) & 3);
451 if (padding)
452 scsi_target_len += padding;
453 if (scsi_target_len > 256)
454 scsi_target_len = 256;
455
456 buf[off-1] = scsi_target_len;
457 off += scsi_target_len;
458
459
460 len += (scsi_target_len + 4);
461 }
462 put_unaligned_be16(len, &buf[2]);
463 return 0;
464}
465EXPORT_SYMBOL(spc_emulate_evpd_83);
466
467
468static sense_reason_t
469spc_emulate_evpd_86(struct se_cmd *cmd, unsigned char *buf)
470{
471 struct se_device *dev = cmd->se_dev;
472 struct se_session *sess = cmd->se_sess;
473
474 buf[3] = 0x3c;
475
476
477
478
479 if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
480 if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE1_PROT ||
481 cmd->se_sess->sess_prot_type == TARGET_DIF_TYPE1_PROT)
482 buf[4] = 0x5;
483 else if (dev->dev_attrib.pi_prot_type == TARGET_DIF_TYPE3_PROT ||
484 cmd->se_sess->sess_prot_type == TARGET_DIF_TYPE3_PROT)
485 buf[4] = 0x4;
486 }
487
488
489 if ((dev->transport->get_device_type(dev) == TYPE_DISK) &&
490 (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) &&
491 (dev->dev_attrib.pi_prot_type || cmd->se_sess->sess_prot_type)) {
492 buf[4] |= (0x3 << 3);
493 }
494
495
496 buf[5] = 0x07;
497
498
499 if (target_check_wce(dev))
500 buf[6] = 0x01;
501
502 spin_lock(&cmd->se_dev->t10_alua.lba_map_lock);
503 if (!list_empty(&dev->t10_alua.lba_map_list))
504 buf[8] = 0x10;
505 spin_unlock(&cmd->se_dev->t10_alua.lba_map_lock);
506 return 0;
507}
508
509
510static sense_reason_t
511spc_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)
512{
513 struct se_device *dev = cmd->se_dev;
514 u32 mtl = 0;
515 int have_tp = 0, opt, min;
516
517
518
519
520
521
522 if (dev->dev_attrib.emulate_tpu || dev->dev_attrib.emulate_tpws)
523 have_tp = 1;
524
525 buf[0] = dev->transport->get_device_type(dev);
526 buf[3] = have_tp ? 0x3c : 0x10;
527
528
529 buf[4] = 0x01;
530
531
532
533 if (dev->dev_attrib.emulate_caw)
534 buf[5] = 0x01;
535
536
537
538
539 if (dev->transport->get_io_min && (min = dev->transport->get_io_min(dev)))
540 put_unaligned_be16(min / dev->dev_attrib.block_size, &buf[6]);
541 else
542 put_unaligned_be16(1, &buf[6]);
543
544
545
546
547
548
549
550 if (cmd->se_tfo->max_data_sg_nents) {
551 mtl = (cmd->se_tfo->max_data_sg_nents * PAGE_SIZE) /
552 dev->dev_attrib.block_size;
553 }
554 put_unaligned_be32(min_not_zero(mtl, dev->dev_attrib.hw_max_sectors), &buf[8]);
555
556
557
558
559 if (dev->transport->get_io_opt && (opt = dev->transport->get_io_opt(dev)))
560 put_unaligned_be32(opt / dev->dev_attrib.block_size, &buf[12]);
561 else
562 put_unaligned_be32(dev->dev_attrib.optimal_sectors, &buf[12]);
563
564
565
566
567 if (!have_tp)
568 goto max_write_same;
569
570
571
572
573 put_unaligned_be32(dev->dev_attrib.max_unmap_lba_count, &buf[20]);
574
575
576
577
578 put_unaligned_be32(dev->dev_attrib.max_unmap_block_desc_count,
579 &buf[24]);
580
581
582
583
584 put_unaligned_be32(dev->dev_attrib.unmap_granularity, &buf[28]);
585
586
587
588
589 put_unaligned_be32(dev->dev_attrib.unmap_granularity_alignment,
590 &buf[32]);
591 if (dev->dev_attrib.unmap_granularity_alignment != 0)
592 buf[32] |= 0x80;
593
594
595
596
597max_write_same:
598 put_unaligned_be64(dev->dev_attrib.max_write_same_len, &buf[36]);
599
600 return 0;
601}
602
603
604static sense_reason_t
605spc_emulate_evpd_b1(struct se_cmd *cmd, unsigned char *buf)
606{
607 struct se_device *dev = cmd->se_dev;
608
609 buf[0] = dev->transport->get_device_type(dev);
610 buf[3] = 0x3c;
611 buf[5] = dev->dev_attrib.is_nonrot ? 1 : 0;
612
613 return 0;
614}
615
616
617static sense_reason_t
618spc_emulate_evpd_b2(struct se_cmd *cmd, unsigned char *buf)
619{
620 struct se_device *dev = cmd->se_dev;
621
622
623
624
625
626
627
628
629
630 buf[0] = dev->transport->get_device_type(dev);
631
632
633
634
635 put_unaligned_be16(0x0004, &buf[2]);
636
637
638
639
640
641
642
643
644
645
646 buf[4] = 0x00;
647
648
649
650
651
652
653 if (dev->dev_attrib.emulate_tpu != 0)
654 buf[5] = 0x80;
655
656
657
658
659
660
661
662 if (dev->dev_attrib.emulate_tpws != 0)
663 buf[5] |= 0x40 | 0x20;
664
665
666
667
668
669
670
671
672 if (((dev->dev_attrib.emulate_tpu != 0) ||
673 (dev->dev_attrib.emulate_tpws != 0)) &&
674 (dev->dev_attrib.unmap_zeroes_data != 0))
675 buf[5] |= 0x04;
676
677 return 0;
678}
679
680
681static sense_reason_t
682spc_emulate_evpd_b3(struct se_cmd *cmd, unsigned char *buf)
683{
684 struct se_device *dev = cmd->se_dev;
685
686 buf[0] = dev->transport->get_device_type(dev);
687 buf[3] = 0x0c;
688 put_unaligned_be32(dev->t10_alua.lba_map_segment_size, &buf[8]);
689 put_unaligned_be32(dev->t10_alua.lba_map_segment_multiplier, &buf[12]);
690
691 return 0;
692}
693
694static sense_reason_t
695spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf);
696
697static struct {
698 uint8_t page;
699 sense_reason_t (*emulate)(struct se_cmd *, unsigned char *);
700} evpd_handlers[] = {
701 { .page = 0x00, .emulate = spc_emulate_evpd_00 },
702 { .page = 0x80, .emulate = spc_emulate_evpd_80 },
703 { .page = 0x83, .emulate = spc_emulate_evpd_83 },
704 { .page = 0x86, .emulate = spc_emulate_evpd_86 },
705 { .page = 0xb0, .emulate = spc_emulate_evpd_b0 },
706 { .page = 0xb1, .emulate = spc_emulate_evpd_b1 },
707 { .page = 0xb2, .emulate = spc_emulate_evpd_b2 },
708 { .page = 0xb3, .emulate = spc_emulate_evpd_b3 },
709};
710
711
712static sense_reason_t
713spc_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf)
714{
715 int p;
716
717
718
719
720
721
722 if (cmd->se_dev->dev_flags & DF_EMULATED_VPD_UNIT_SERIAL) {
723 buf[3] = ARRAY_SIZE(evpd_handlers);
724 for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p)
725 buf[p + 4] = evpd_handlers[p].page;
726 }
727
728 return 0;
729}
730
731static sense_reason_t
732spc_emulate_inquiry(struct se_cmd *cmd)
733{
734 struct se_device *dev = cmd->se_dev;
735 unsigned char *rbuf;
736 unsigned char *cdb = cmd->t_task_cdb;
737 unsigned char *buf;
738 sense_reason_t ret;
739 int p;
740 int len = 0;
741
742 buf = kzalloc(SE_INQUIRY_BUF, GFP_KERNEL);
743 if (!buf) {
744 pr_err("Unable to allocate response buffer for INQUIRY\n");
745 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
746 }
747
748 buf[0] = dev->transport->get_device_type(dev);
749
750 if (!(cdb[1] & 0x1)) {
751 if (cdb[2]) {
752 pr_err("INQUIRY with EVPD==0 but PAGE CODE=%02x\n",
753 cdb[2]);
754 ret = TCM_INVALID_CDB_FIELD;
755 goto out;
756 }
757
758 ret = spc_emulate_inquiry_std(cmd, buf);
759 len = buf[4] + 5;
760 goto out;
761 }
762
763 for (p = 0; p < ARRAY_SIZE(evpd_handlers); ++p) {
764 if (cdb[2] == evpd_handlers[p].page) {
765 buf[1] = cdb[2];
766 ret = evpd_handlers[p].emulate(cmd, buf);
767 len = get_unaligned_be16(&buf[2]) + 4;
768 goto out;
769 }
770 }
771
772 pr_err("Unknown VPD Code: 0x%02x\n", cdb[2]);
773 ret = TCM_INVALID_CDB_FIELD;
774
775out:
776 rbuf = transport_kmap_data_sg(cmd);
777 if (rbuf) {
778 memcpy(rbuf, buf, min_t(u32, SE_INQUIRY_BUF, cmd->data_length));
779 transport_kunmap_data_sg(cmd);
780 }
781 kfree(buf);
782
783 if (!ret)
784 target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, len);
785 return ret;
786}
787
788static int spc_modesense_rwrecovery(struct se_cmd *cmd, u8 pc, u8 *p)
789{
790 p[0] = 0x01;
791 p[1] = 0x0a;
792
793
794 if (pc == 1)
795 goto out;
796
797out:
798 return 12;
799}
800
801static int spc_modesense_control(struct se_cmd *cmd, u8 pc, u8 *p)
802{
803 struct se_device *dev = cmd->se_dev;
804 struct se_session *sess = cmd->se_sess;
805
806 p[0] = 0x0a;
807 p[1] = 0x0a;
808
809
810 if (pc == 1)
811 goto out;
812
813
814 p[2] = (1 << 1);
815 if (target_sense_desc_format(dev))
816
817 p[2] |= (1 << 2);
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847 p[3] = (dev->dev_attrib.emulate_rest_reord == 1) ? 0x00 : 0x10;
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877 switch (dev->dev_attrib.emulate_ua_intlck_ctrl) {
878 case TARGET_UA_INTLCK_CTRL_ESTABLISH_UA:
879 p[4] = 0x30;
880 break;
881 case TARGET_UA_INTLCK_CTRL_NO_CLEAR:
882 p[4] = 0x20;
883 break;
884 default:
885 p[4] = 0x00;
886 break;
887 }
888
889
890
891
892
893
894
895
896
897
898
899
900 p[5] = (dev->dev_attrib.emulate_tas) ? 0x40 : 0x00;
901
902
903
904
905
906
907
908
909
910
911 if (sess->sup_prot_ops & (TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS)) {
912 if (dev->dev_attrib.pi_prot_type || sess->sess_prot_type)
913 p[5] |= 0x80;
914 }
915
916 p[8] = 0xff;
917 p[9] = 0xff;
918 p[11] = 30;
919
920out:
921 return 12;
922}
923
924static int spc_modesense_caching(struct se_cmd *cmd, u8 pc, u8 *p)
925{
926 struct se_device *dev = cmd->se_dev;
927
928 p[0] = 0x08;
929 p[1] = 0x12;
930
931
932 if (pc == 1)
933 goto out;
934
935 if (target_check_wce(dev))
936 p[2] = 0x04;
937 p[12] = 0x20;
938
939out:
940 return 20;
941}
942
943static int spc_modesense_informational_exceptions(struct se_cmd *cmd, u8 pc, unsigned char *p)
944{
945 p[0] = 0x1c;
946 p[1] = 0x0a;
947
948
949 if (pc == 1)
950 goto out;
951
952out:
953 return 12;
954}
955
956static struct {
957 uint8_t page;
958 uint8_t subpage;
959 int (*emulate)(struct se_cmd *, u8, unsigned char *);
960} modesense_handlers[] = {
961 { .page = 0x01, .subpage = 0x00, .emulate = spc_modesense_rwrecovery },
962 { .page = 0x08, .subpage = 0x00, .emulate = spc_modesense_caching },
963 { .page = 0x0a, .subpage = 0x00, .emulate = spc_modesense_control },
964 { .page = 0x1c, .subpage = 0x00, .emulate = spc_modesense_informational_exceptions },
965};
966
967static void spc_modesense_write_protect(unsigned char *buf, int type)
968{
969
970
971
972
973 switch (type) {
974 case TYPE_DISK:
975 case TYPE_TAPE:
976 default:
977 buf[0] |= 0x80;
978 break;
979 }
980}
981
982static void spc_modesense_dpofua(unsigned char *buf, int type)
983{
984 switch (type) {
985 case TYPE_DISK:
986 buf[0] |= 0x10;
987 break;
988 default:
989 break;
990 }
991}
992
993static int spc_modesense_blockdesc(unsigned char *buf, u64 blocks, u32 block_size)
994{
995 *buf++ = 8;
996 put_unaligned_be32(min(blocks, 0xffffffffull), buf);
997 buf += 4;
998 put_unaligned_be32(block_size, buf);
999 return 9;
1000}
1001
1002static int spc_modesense_long_blockdesc(unsigned char *buf, u64 blocks, u32 block_size)
1003{
1004 if (blocks <= 0xffffffff)
1005 return spc_modesense_blockdesc(buf + 3, blocks, block_size) + 3;
1006
1007 *buf++ = 1;
1008 buf += 2;
1009 *buf++ = 16;
1010 put_unaligned_be64(blocks, buf);
1011 buf += 12;
1012 put_unaligned_be32(block_size, buf);
1013
1014 return 17;
1015}
1016
1017static sense_reason_t spc_emulate_modesense(struct se_cmd *cmd)
1018{
1019 struct se_device *dev = cmd->se_dev;
1020 char *cdb = cmd->t_task_cdb;
1021 unsigned char buf[SE_MODE_PAGE_BUF], *rbuf;
1022 int type = dev->transport->get_device_type(dev);
1023 int ten = (cmd->t_task_cdb[0] == MODE_SENSE_10);
1024 bool dbd = !!(cdb[1] & 0x08);
1025 bool llba = ten ? !!(cdb[1] & 0x10) : false;
1026 u8 pc = cdb[2] >> 6;
1027 u8 page = cdb[2] & 0x3f;
1028 u8 subpage = cdb[3];
1029 int length = 0;
1030 int ret;
1031 int i;
1032
1033 memset(buf, 0, SE_MODE_PAGE_BUF);
1034
1035
1036
1037
1038
1039 length = ten ? 3 : 2;
1040
1041
1042 if (cmd->se_lun->lun_access_ro || target_lun_is_rdonly(cmd))
1043 spc_modesense_write_protect(&buf[length], type);
1044
1045
1046
1047
1048
1049
1050 if (target_check_fua(dev))
1051 spc_modesense_dpofua(&buf[length], type);
1052
1053 ++length;
1054
1055
1056
1057
1058
1059
1060
1061 if (!dbd && type == TYPE_DISK) {
1062 u64 blocks = dev->transport->get_blocks(dev);
1063 u32 block_size = dev->dev_attrib.block_size;
1064
1065 if (ten) {
1066 if (llba) {
1067 length += spc_modesense_long_blockdesc(&buf[length],
1068 blocks, block_size);
1069 } else {
1070 length += 3;
1071 length += spc_modesense_blockdesc(&buf[length],
1072 blocks, block_size);
1073 }
1074 } else {
1075 length += spc_modesense_blockdesc(&buf[length], blocks,
1076 block_size);
1077 }
1078 } else {
1079 if (ten)
1080 length += 4;
1081 else
1082 length += 1;
1083 }
1084
1085 if (page == 0x3f) {
1086 if (subpage != 0x00 && subpage != 0xff) {
1087 pr_warn("MODE_SENSE: Invalid subpage code: 0x%02x\n", subpage);
1088 return TCM_INVALID_CDB_FIELD;
1089 }
1090
1091 for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i) {
1092
1093
1094
1095
1096
1097
1098 if ((modesense_handlers[i].subpage & ~subpage) == 0) {
1099 ret = modesense_handlers[i].emulate(cmd, pc, &buf[length]);
1100 if (!ten && length + ret >= 255)
1101 break;
1102 length += ret;
1103 }
1104 }
1105
1106 goto set_length;
1107 }
1108
1109 for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i)
1110 if (modesense_handlers[i].page == page &&
1111 modesense_handlers[i].subpage == subpage) {
1112 length += modesense_handlers[i].emulate(cmd, pc, &buf[length]);
1113 goto set_length;
1114 }
1115
1116
1117
1118
1119
1120 if (page != 0x03)
1121 pr_err("MODE SENSE: unimplemented page/subpage: 0x%02x/0x%02x\n",
1122 page, subpage);
1123
1124 return TCM_UNKNOWN_MODE_PAGE;
1125
1126set_length:
1127 if (ten)
1128 put_unaligned_be16(length - 2, buf);
1129 else
1130 buf[0] = length - 1;
1131
1132 rbuf = transport_kmap_data_sg(cmd);
1133 if (rbuf) {
1134 memcpy(rbuf, buf, min_t(u32, SE_MODE_PAGE_BUF, cmd->data_length));
1135 transport_kunmap_data_sg(cmd);
1136 }
1137
1138 target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, length);
1139 return 0;
1140}
1141
1142static sense_reason_t spc_emulate_modeselect(struct se_cmd *cmd)
1143{
1144 char *cdb = cmd->t_task_cdb;
1145 bool ten = cdb[0] == MODE_SELECT_10;
1146 int off = ten ? 8 : 4;
1147 bool pf = !!(cdb[1] & 0x10);
1148 u8 page, subpage;
1149 unsigned char *buf;
1150 unsigned char tbuf[SE_MODE_PAGE_BUF];
1151 int length;
1152 sense_reason_t ret = 0;
1153 int i;
1154
1155 if (!cmd->data_length) {
1156 target_complete_cmd(cmd, SAM_STAT_GOOD);
1157 return 0;
1158 }
1159
1160 if (cmd->data_length < off + 2)
1161 return TCM_PARAMETER_LIST_LENGTH_ERROR;
1162
1163 buf = transport_kmap_data_sg(cmd);
1164 if (!buf)
1165 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1166
1167 if (!pf) {
1168 ret = TCM_INVALID_CDB_FIELD;
1169 goto out;
1170 }
1171
1172 page = buf[off] & 0x3f;
1173 subpage = buf[off] & 0x40 ? buf[off + 1] : 0;
1174
1175 for (i = 0; i < ARRAY_SIZE(modesense_handlers); ++i)
1176 if (modesense_handlers[i].page == page &&
1177 modesense_handlers[i].subpage == subpage) {
1178 memset(tbuf, 0, SE_MODE_PAGE_BUF);
1179 length = modesense_handlers[i].emulate(cmd, 0, tbuf);
1180 goto check_contents;
1181 }
1182
1183 ret = TCM_UNKNOWN_MODE_PAGE;
1184 goto out;
1185
1186check_contents:
1187 if (cmd->data_length < off + length) {
1188 ret = TCM_PARAMETER_LIST_LENGTH_ERROR;
1189 goto out;
1190 }
1191
1192 if (memcmp(buf + off, tbuf, length))
1193 ret = TCM_INVALID_PARAMETER_LIST;
1194
1195out:
1196 transport_kunmap_data_sg(cmd);
1197
1198 if (!ret)
1199 target_complete_cmd(cmd, SAM_STAT_GOOD);
1200 return ret;
1201}
1202
1203static sense_reason_t spc_emulate_request_sense(struct se_cmd *cmd)
1204{
1205 unsigned char *cdb = cmd->t_task_cdb;
1206 unsigned char *rbuf;
1207 u8 ua_asc = 0, ua_ascq = 0;
1208 unsigned char buf[SE_SENSE_BUF];
1209 bool desc_format = target_sense_desc_format(cmd->se_dev);
1210
1211 memset(buf, 0, SE_SENSE_BUF);
1212
1213 if (cdb[1] & 0x01) {
1214 pr_err("REQUEST_SENSE description emulation not"
1215 " supported\n");
1216 return TCM_INVALID_CDB_FIELD;
1217 }
1218
1219 rbuf = transport_kmap_data_sg(cmd);
1220 if (!rbuf)
1221 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1222
1223 if (!core_scsi3_ua_clear_for_request_sense(cmd, &ua_asc, &ua_ascq))
1224 scsi_build_sense_buffer(desc_format, buf, UNIT_ATTENTION,
1225 ua_asc, ua_ascq);
1226 else
1227 scsi_build_sense_buffer(desc_format, buf, NO_SENSE, 0x0, 0x0);
1228
1229 memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
1230 transport_kunmap_data_sg(cmd);
1231
1232 target_complete_cmd(cmd, SAM_STAT_GOOD);
1233 return 0;
1234}
1235
1236sense_reason_t spc_emulate_report_luns(struct se_cmd *cmd)
1237{
1238 struct se_dev_entry *deve;
1239 struct se_session *sess = cmd->se_sess;
1240 struct se_node_acl *nacl;
1241 struct scsi_lun slun;
1242 unsigned char *buf;
1243 u32 lun_count = 0, offset = 8;
1244 __be32 len;
1245
1246 buf = transport_kmap_data_sg(cmd);
1247 if (cmd->data_length && !buf)
1248 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1249
1250
1251
1252
1253
1254
1255 if (!sess)
1256 goto done;
1257
1258 nacl = sess->se_node_acl;
1259
1260 rcu_read_lock();
1261 hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) {
1262
1263
1264
1265
1266
1267 lun_count++;
1268 if (offset >= cmd->data_length)
1269 continue;
1270
1271 int_to_scsilun(deve->mapped_lun, &slun);
1272 memcpy(buf + offset, &slun,
1273 min(8u, cmd->data_length - offset));
1274 offset += 8;
1275 }
1276 rcu_read_unlock();
1277
1278
1279
1280
1281done:
1282
1283
1284
1285 if (lun_count == 0) {
1286 int_to_scsilun(0, &slun);
1287 if (cmd->data_length > 8)
1288 memcpy(buf + offset, &slun,
1289 min(8u, cmd->data_length - offset));
1290 lun_count = 1;
1291 }
1292
1293 if (buf) {
1294 len = cpu_to_be32(lun_count * 8);
1295 memcpy(buf, &len, min_t(int, sizeof len, cmd->data_length));
1296 transport_kunmap_data_sg(cmd);
1297 }
1298
1299 target_complete_cmd_with_length(cmd, SAM_STAT_GOOD, 8 + lun_count * 8);
1300 return 0;
1301}
1302EXPORT_SYMBOL(spc_emulate_report_luns);
1303
1304static sense_reason_t
1305spc_emulate_testunitready(struct se_cmd *cmd)
1306{
1307 target_complete_cmd(cmd, SAM_STAT_GOOD);
1308 return 0;
1309}
1310
1311sense_reason_t
1312spc_parse_cdb(struct se_cmd *cmd, unsigned int *size)
1313{
1314 struct se_device *dev = cmd->se_dev;
1315 unsigned char *cdb = cmd->t_task_cdb;
1316
1317 if (!dev->dev_attrib.emulate_pr &&
1318 ((cdb[0] == PERSISTENT_RESERVE_IN) ||
1319 (cdb[0] == PERSISTENT_RESERVE_OUT) ||
1320 (cdb[0] == RELEASE || cdb[0] == RELEASE_10) ||
1321 (cdb[0] == RESERVE || cdb[0] == RESERVE_10))) {
1322 return TCM_UNSUPPORTED_SCSI_OPCODE;
1323 }
1324
1325 switch (cdb[0]) {
1326 case MODE_SELECT:
1327 *size = cdb[4];
1328 cmd->execute_cmd = spc_emulate_modeselect;
1329 break;
1330 case MODE_SELECT_10:
1331 *size = get_unaligned_be16(&cdb[7]);
1332 cmd->execute_cmd = spc_emulate_modeselect;
1333 break;
1334 case MODE_SENSE:
1335 *size = cdb[4];
1336 cmd->execute_cmd = spc_emulate_modesense;
1337 break;
1338 case MODE_SENSE_10:
1339 *size = get_unaligned_be16(&cdb[7]);
1340 cmd->execute_cmd = spc_emulate_modesense;
1341 break;
1342 case LOG_SELECT:
1343 case LOG_SENSE:
1344 *size = get_unaligned_be16(&cdb[7]);
1345 break;
1346 case PERSISTENT_RESERVE_IN:
1347 *size = get_unaligned_be16(&cdb[7]);
1348 cmd->execute_cmd = target_scsi3_emulate_pr_in;
1349 break;
1350 case PERSISTENT_RESERVE_OUT:
1351 *size = get_unaligned_be32(&cdb[5]);
1352 cmd->execute_cmd = target_scsi3_emulate_pr_out;
1353 break;
1354 case RELEASE:
1355 case RELEASE_10:
1356 if (cdb[0] == RELEASE_10)
1357 *size = get_unaligned_be16(&cdb[7]);
1358 else
1359 *size = cmd->data_length;
1360
1361 cmd->execute_cmd = target_scsi2_reservation_release;
1362 break;
1363 case RESERVE:
1364 case RESERVE_10:
1365
1366
1367
1368
1369 if (cdb[0] == RESERVE_10)
1370 *size = get_unaligned_be16(&cdb[7]);
1371 else
1372 *size = cmd->data_length;
1373
1374 cmd->execute_cmd = target_scsi2_reservation_reserve;
1375 break;
1376 case REQUEST_SENSE:
1377 *size = cdb[4];
1378 cmd->execute_cmd = spc_emulate_request_sense;
1379 break;
1380 case INQUIRY:
1381 *size = get_unaligned_be16(&cdb[3]);
1382
1383
1384
1385
1386
1387 cmd->sam_task_attr = TCM_HEAD_TAG;
1388 cmd->execute_cmd = spc_emulate_inquiry;
1389 break;
1390 case SECURITY_PROTOCOL_IN:
1391 case SECURITY_PROTOCOL_OUT:
1392 *size = get_unaligned_be32(&cdb[6]);
1393 break;
1394 case EXTENDED_COPY:
1395 *size = get_unaligned_be32(&cdb[10]);
1396 cmd->execute_cmd = target_do_xcopy;
1397 break;
1398 case RECEIVE_COPY_RESULTS:
1399 *size = get_unaligned_be32(&cdb[10]);
1400 cmd->execute_cmd = target_do_receive_copy_results;
1401 break;
1402 case READ_ATTRIBUTE:
1403 case WRITE_ATTRIBUTE:
1404 *size = get_unaligned_be32(&cdb[10]);
1405 break;
1406 case RECEIVE_DIAGNOSTIC:
1407 case SEND_DIAGNOSTIC:
1408 *size = get_unaligned_be16(&cdb[3]);
1409 break;
1410 case WRITE_BUFFER:
1411 *size = get_unaligned_be24(&cdb[6]);
1412 break;
1413 case REPORT_LUNS:
1414 cmd->execute_cmd = spc_emulate_report_luns;
1415 *size = get_unaligned_be32(&cdb[6]);
1416
1417
1418
1419
1420 cmd->sam_task_attr = TCM_HEAD_TAG;
1421 break;
1422 case TEST_UNIT_READY:
1423 cmd->execute_cmd = spc_emulate_testunitready;
1424 *size = 0;
1425 break;
1426 case MAINTENANCE_IN:
1427 if (dev->transport->get_device_type(dev) != TYPE_ROM) {
1428
1429
1430
1431
1432 if ((cdb[1] & 0x1f) == MI_REPORT_TARGET_PGS) {
1433 cmd->execute_cmd =
1434 target_emulate_report_target_port_groups;
1435 }
1436 *size = get_unaligned_be32(&cdb[6]);
1437 } else {
1438
1439
1440
1441 *size = get_unaligned_be16(&cdb[8]);
1442 }
1443 break;
1444 case MAINTENANCE_OUT:
1445 if (dev->transport->get_device_type(dev) != TYPE_ROM) {
1446
1447
1448
1449
1450 if (cdb[1] == MO_SET_TARGET_PGS) {
1451 cmd->execute_cmd =
1452 target_emulate_set_target_port_groups;
1453 }
1454 *size = get_unaligned_be32(&cdb[6]);
1455 } else {
1456
1457
1458
1459 *size = get_unaligned_be16(&cdb[8]);
1460 }
1461 break;
1462 default:
1463 return TCM_UNSUPPORTED_SCSI_OPCODE;
1464 }
1465
1466 return 0;
1467}
1468EXPORT_SYMBOL(spc_parse_cdb);
1469