1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include <linux/module.h>
29
30#include <linux/kernel.h>
31#include <linux/errno.h>
32#include <linux/timer.h>
33#include <linux/slab.h>
34#include <linux/types.h>
35#include <linux/string.h>
36#include <linux/genhd.h>
37#include <linux/fs.h>
38#include <linux/init.h>
39#include <linux/proc_fs.h>
40#include <linux/vmalloc.h>
41#include <linux/moduleparam.h>
42#include <linux/scatterlist.h>
43#include <linux/blkdev.h>
44#include <linux/crc-t10dif.h>
45
46#include <net/checksum.h>
47
48#include <asm/unaligned.h>
49
50#include <scsi/scsi.h>
51#include <scsi/scsi_cmnd.h>
52#include <scsi/scsi_device.h>
53#include <scsi/scsi_host.h>
54#include <scsi/scsicam.h>
55#include <scsi/scsi_eh.h>
56#include <scsi/scsi_dbg.h>
57
58#include "sd.h"
59#include "scsi_logging.h"
60
61#define SCSI_DEBUG_VERSION "1.82"
62static const char * scsi_debug_version_date = "20100324";
63
64
65#define NO_ADDITIONAL_SENSE 0x0
66#define LOGICAL_UNIT_NOT_READY 0x4
67#define UNRECOVERED_READ_ERR 0x11
68#define PARAMETER_LIST_LENGTH_ERR 0x1a
69#define INVALID_OPCODE 0x20
70#define ADDR_OUT_OF_RANGE 0x21
71#define INVALID_COMMAND_OPCODE 0x20
72#define INVALID_FIELD_IN_CDB 0x24
73#define INVALID_FIELD_IN_PARAM_LIST 0x26
74#define POWERON_RESET 0x29
75#define SAVING_PARAMS_UNSUP 0x39
76#define TRANSPORT_PROBLEM 0x4b
77#define THRESHOLD_EXCEEDED 0x5d
78#define LOW_POWER_COND_ON 0x5e
79
80
81#define ACK_NAK_TO 0x3
82
83#define SDEBUG_TAGGED_QUEUING 0
84
85
86#define DEF_NUM_HOST 1
87#define DEF_NUM_TGTS 1
88#define DEF_MAX_LUNS 1
89
90
91
92#define DEF_ATO 1
93#define DEF_DELAY 1
94#define DEF_DEV_SIZE_MB 8
95#define DEF_DIF 0
96#define DEF_DIX 0
97#define DEF_D_SENSE 0
98#define DEF_EVERY_NTH 0
99#define DEF_FAKE_RW 0
100#define DEF_GUARD 0
101#define DEF_LBPU 0
102#define DEF_LBPWS 0
103#define DEF_LBPWS10 0
104#define DEF_LBPRZ 1
105#define DEF_LOWEST_ALIGNED 0
106#define DEF_NO_LUN_0 0
107#define DEF_NUM_PARTS 0
108#define DEF_OPTS 0
109#define DEF_OPT_BLKS 64
110#define DEF_PHYSBLK_EXP 0
111#define DEF_PTYPE 0
112#define DEF_REMOVABLE false
113#define DEF_SCSI_LEVEL 5
114#define DEF_SECTOR_SIZE 512
115#define DEF_UNMAP_ALIGNMENT 0
116#define DEF_UNMAP_GRANULARITY 1
117#define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF
118#define DEF_UNMAP_MAX_DESC 256
119#define DEF_VIRTUAL_GB 0
120#define DEF_VPD_USE_HOSTNO 1
121#define DEF_WRITESAME_LENGTH 0xFFFF
122
123
124#define SCSI_DEBUG_OPT_NOISE 1
125#define SCSI_DEBUG_OPT_MEDIUM_ERR 2
126#define SCSI_DEBUG_OPT_TIMEOUT 4
127#define SCSI_DEBUG_OPT_RECOVERED_ERR 8
128#define SCSI_DEBUG_OPT_TRANSPORT_ERR 16
129#define SCSI_DEBUG_OPT_DIF_ERR 32
130#define SCSI_DEBUG_OPT_DIX_ERR 64
131#define SCSI_DEBUG_OPT_MAC_TIMEOUT 128
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151#define OPT_MEDIUM_ERR_ADDR 0x1234
152#define OPT_MEDIUM_ERR_NUM 10
153
154
155
156#define SAM2_LUN_ADDRESS_METHOD 0
157#define SAM2_WLUN_REPORT_LUNS 0xc101
158
159
160
161#define SCSI_DEBUG_CANQUEUE 255
162
163static int scsi_debug_add_host = DEF_NUM_HOST;
164static int scsi_debug_ato = DEF_ATO;
165static int scsi_debug_delay = DEF_DELAY;
166static int scsi_debug_dev_size_mb = DEF_DEV_SIZE_MB;
167static int scsi_debug_dif = DEF_DIF;
168static int scsi_debug_dix = DEF_DIX;
169static int scsi_debug_dsense = DEF_D_SENSE;
170static int scsi_debug_every_nth = DEF_EVERY_NTH;
171static int scsi_debug_fake_rw = DEF_FAKE_RW;
172static int scsi_debug_guard = DEF_GUARD;
173static int scsi_debug_lowest_aligned = DEF_LOWEST_ALIGNED;
174static int scsi_debug_max_luns = DEF_MAX_LUNS;
175static int scsi_debug_max_queue = SCSI_DEBUG_CANQUEUE;
176static int scsi_debug_no_lun_0 = DEF_NO_LUN_0;
177static int scsi_debug_no_uld = 0;
178static int scsi_debug_num_parts = DEF_NUM_PARTS;
179static int scsi_debug_num_tgts = DEF_NUM_TGTS;
180static int scsi_debug_opt_blks = DEF_OPT_BLKS;
181static int scsi_debug_opts = DEF_OPTS;
182static int scsi_debug_physblk_exp = DEF_PHYSBLK_EXP;
183static int scsi_debug_ptype = DEF_PTYPE;
184static int scsi_debug_scsi_level = DEF_SCSI_LEVEL;
185static int scsi_debug_sector_size = DEF_SECTOR_SIZE;
186static int scsi_debug_virtual_gb = DEF_VIRTUAL_GB;
187static int scsi_debug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
188static unsigned int scsi_debug_lbpu = DEF_LBPU;
189static unsigned int scsi_debug_lbpws = DEF_LBPWS;
190static unsigned int scsi_debug_lbpws10 = DEF_LBPWS10;
191static unsigned int scsi_debug_lbprz = DEF_LBPRZ;
192static unsigned int scsi_debug_unmap_alignment = DEF_UNMAP_ALIGNMENT;
193static unsigned int scsi_debug_unmap_granularity = DEF_UNMAP_GRANULARITY;
194static unsigned int scsi_debug_unmap_max_blocks = DEF_UNMAP_MAX_BLOCKS;
195static unsigned int scsi_debug_unmap_max_desc = DEF_UNMAP_MAX_DESC;
196static unsigned int scsi_debug_write_same_length = DEF_WRITESAME_LENGTH;
197static bool scsi_debug_removable = DEF_REMOVABLE;
198
199static int scsi_debug_cmnd_count = 0;
200
201#define DEV_READONLY(TGT) (0)
202
203static unsigned int sdebug_store_sectors;
204static sector_t sdebug_capacity;
205
206
207
208static int sdebug_heads;
209static int sdebug_cylinders_per;
210static int sdebug_sectors_per;
211
212#define SDEBUG_MAX_PARTS 4
213
214#define SDEBUG_SENSE_LEN 32
215
216#define SCSI_DEBUG_MAX_CMD_LEN 32
217
218static unsigned int scsi_debug_lbp(void)
219{
220 return scsi_debug_lbpu | scsi_debug_lbpws | scsi_debug_lbpws10;
221}
222
223struct sdebug_dev_info {
224 struct list_head dev_list;
225 unsigned char sense_buff[SDEBUG_SENSE_LEN];
226 unsigned int channel;
227 unsigned int target;
228 unsigned int lun;
229 struct sdebug_host_info *sdbg_host;
230 unsigned int wlun;
231 char reset;
232 char stopped;
233 char used;
234};
235
236struct sdebug_host_info {
237 struct list_head host_list;
238 struct Scsi_Host *shost;
239 struct device dev;
240 struct list_head dev_info_list;
241};
242
243#define to_sdebug_host(d) \
244 container_of(d, struct sdebug_host_info, dev)
245
246static LIST_HEAD(sdebug_host_list);
247static DEFINE_SPINLOCK(sdebug_host_list_lock);
248
249typedef void (* done_funct_t) (struct scsi_cmnd *);
250
251struct sdebug_queued_cmd {
252 int in_use;
253 struct timer_list cmnd_timer;
254 done_funct_t done_funct;
255 struct scsi_cmnd * a_cmnd;
256 int scsi_result;
257};
258static struct sdebug_queued_cmd queued_arr[SCSI_DEBUG_CANQUEUE];
259
260static unsigned char * fake_storep;
261static struct sd_dif_tuple *dif_storep;
262static void *map_storep;
263
264static unsigned long map_size;
265static int num_aborts = 0;
266static int num_dev_resets = 0;
267static int num_bus_resets = 0;
268static int num_host_resets = 0;
269static int dix_writes;
270static int dix_reads;
271static int dif_errors;
272
273static DEFINE_SPINLOCK(queued_arr_lock);
274static DEFINE_RWLOCK(atomic_rw);
275
276static char sdebug_proc_name[] = "scsi_debug";
277
278static struct bus_type pseudo_lld_bus;
279
280static struct device_driver sdebug_driverfs_driver = {
281 .name = sdebug_proc_name,
282 .bus = &pseudo_lld_bus,
283};
284
285static const int check_condition_result =
286 (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
287
288static const int illegal_condition_result =
289 (DRIVER_SENSE << 24) | (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION;
290
291static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
292 0, 0, 0x2, 0x4b};
293static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
294 0, 0, 0x0, 0x0};
295
296static int sdebug_add_adapter(void);
297static void sdebug_remove_adapter(void);
298
299static void sdebug_max_tgts_luns(void)
300{
301 struct sdebug_host_info *sdbg_host;
302 struct Scsi_Host *hpnt;
303
304 spin_lock(&sdebug_host_list_lock);
305 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
306 hpnt = sdbg_host->shost;
307 if ((hpnt->this_id >= 0) &&
308 (scsi_debug_num_tgts > hpnt->this_id))
309 hpnt->max_id = scsi_debug_num_tgts + 1;
310 else
311 hpnt->max_id = scsi_debug_num_tgts;
312
313 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS;
314 }
315 spin_unlock(&sdebug_host_list_lock);
316}
317
318static void mk_sense_buffer(struct sdebug_dev_info *devip, int key,
319 int asc, int asq)
320{
321 unsigned char *sbuff;
322
323 sbuff = devip->sense_buff;
324 memset(sbuff, 0, SDEBUG_SENSE_LEN);
325
326 scsi_build_sense_buffer(scsi_debug_dsense, sbuff, key, asc, asq);
327
328 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
329 printk(KERN_INFO "scsi_debug: [sense_key,asc,ascq]: "
330 "[0x%x,0x%x,0x%x]\n", key, asc, asq);
331}
332
333static void get_data_transfer_info(unsigned char *cmd,
334 unsigned long long *lba, unsigned int *num,
335 u32 *ei_lba)
336{
337 *ei_lba = 0;
338
339 switch (*cmd) {
340 case VARIABLE_LENGTH_CMD:
341 *lba = (u64)cmd[19] | (u64)cmd[18] << 8 |
342 (u64)cmd[17] << 16 | (u64)cmd[16] << 24 |
343 (u64)cmd[15] << 32 | (u64)cmd[14] << 40 |
344 (u64)cmd[13] << 48 | (u64)cmd[12] << 56;
345
346 *ei_lba = (u32)cmd[23] | (u32)cmd[22] << 8 |
347 (u32)cmd[21] << 16 | (u32)cmd[20] << 24;
348
349 *num = (u32)cmd[31] | (u32)cmd[30] << 8 | (u32)cmd[29] << 16 |
350 (u32)cmd[28] << 24;
351 break;
352
353 case WRITE_SAME_16:
354 case WRITE_16:
355 case READ_16:
356 *lba = (u64)cmd[9] | (u64)cmd[8] << 8 |
357 (u64)cmd[7] << 16 | (u64)cmd[6] << 24 |
358 (u64)cmd[5] << 32 | (u64)cmd[4] << 40 |
359 (u64)cmd[3] << 48 | (u64)cmd[2] << 56;
360
361 *num = (u32)cmd[13] | (u32)cmd[12] << 8 | (u32)cmd[11] << 16 |
362 (u32)cmd[10] << 24;
363 break;
364 case WRITE_12:
365 case READ_12:
366 *lba = (u32)cmd[5] | (u32)cmd[4] << 8 | (u32)cmd[3] << 16 |
367 (u32)cmd[2] << 24;
368
369 *num = (u32)cmd[9] | (u32)cmd[8] << 8 | (u32)cmd[7] << 16 |
370 (u32)cmd[6] << 24;
371 break;
372 case WRITE_SAME:
373 case WRITE_10:
374 case READ_10:
375 case XDWRITEREAD_10:
376 *lba = (u32)cmd[5] | (u32)cmd[4] << 8 | (u32)cmd[3] << 16 |
377 (u32)cmd[2] << 24;
378
379 *num = (u32)cmd[8] | (u32)cmd[7] << 8;
380 break;
381 case WRITE_6:
382 case READ_6:
383 *lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
384 (u32)(cmd[1] & 0x1f) << 16;
385 *num = (0 == cmd[4]) ? 256 : cmd[4];
386 break;
387 default:
388 break;
389 }
390}
391
392static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
393{
394 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
395 printk(KERN_INFO "scsi_debug: ioctl: cmd=0x%x\n", cmd);
396 }
397 return -EINVAL;
398
399}
400
401static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
402 struct sdebug_dev_info * devip)
403{
404 if (devip->reset) {
405 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
406 printk(KERN_INFO "scsi_debug: Reporting Unit "
407 "attention: power on reset\n");
408 devip->reset = 0;
409 mk_sense_buffer(devip, UNIT_ATTENTION, POWERON_RESET, 0);
410 return check_condition_result;
411 }
412 if ((0 == reset_only) && devip->stopped) {
413 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
414 printk(KERN_INFO "scsi_debug: Reporting Not "
415 "ready: initializing command required\n");
416 mk_sense_buffer(devip, NOT_READY, LOGICAL_UNIT_NOT_READY,
417 0x2);
418 return check_condition_result;
419 }
420 return 0;
421}
422
423
424static int fill_from_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
425 int arr_len)
426{
427 int act_len;
428 struct scsi_data_buffer *sdb = scsi_in(scp);
429
430 if (!sdb->length)
431 return 0;
432 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE))
433 return (DID_ERROR << 16);
434
435 act_len = sg_copy_from_buffer(sdb->table.sgl, sdb->table.nents,
436 arr, arr_len);
437 sdb->resid = scsi_bufflen(scp) - act_len;
438
439 return 0;
440}
441
442
443static int fetch_to_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
444 int arr_len)
445{
446 if (!scsi_bufflen(scp))
447 return 0;
448 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_TO_DEVICE))
449 return -1;
450
451 return scsi_sg_copy_to_buffer(scp, arr, arr_len);
452}
453
454
455static const char * inq_vendor_id = "Linux ";
456static const char * inq_product_id = "scsi_debug ";
457static const char * inq_product_rev = "0004";
458
459static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
460 int target_dev_id, int dev_id_num,
461 const char * dev_id_str,
462 int dev_id_str_len)
463{
464 int num, port_a;
465 char b[32];
466
467 port_a = target_dev_id + 1;
468
469 arr[0] = 0x2;
470 arr[1] = 0x1;
471 arr[2] = 0x0;
472 memcpy(&arr[4], inq_vendor_id, 8);
473 memcpy(&arr[12], inq_product_id, 16);
474 memcpy(&arr[28], dev_id_str, dev_id_str_len);
475 num = 8 + 16 + dev_id_str_len;
476 arr[3] = num;
477 num += 4;
478 if (dev_id_num >= 0) {
479
480 arr[num++] = 0x1;
481 arr[num++] = 0x3;
482 arr[num++] = 0x0;
483 arr[num++] = 0x8;
484 arr[num++] = 0x53;
485 arr[num++] = 0x33;
486 arr[num++] = 0x33;
487 arr[num++] = 0x30;
488 arr[num++] = (dev_id_num >> 24);
489 arr[num++] = (dev_id_num >> 16) & 0xff;
490 arr[num++] = (dev_id_num >> 8) & 0xff;
491 arr[num++] = dev_id_num & 0xff;
492
493 arr[num++] = 0x61;
494 arr[num++] = 0x94;
495 arr[num++] = 0x0;
496 arr[num++] = 0x4;
497 arr[num++] = 0x0;
498 arr[num++] = 0x0;
499 arr[num++] = 0x0;
500 arr[num++] = 0x1;
501 }
502
503 arr[num++] = 0x61;
504 arr[num++] = 0x93;
505 arr[num++] = 0x0;
506 arr[num++] = 0x8;
507 arr[num++] = 0x52;
508 arr[num++] = 0x22;
509 arr[num++] = 0x22;
510 arr[num++] = 0x20;
511 arr[num++] = (port_a >> 24);
512 arr[num++] = (port_a >> 16) & 0xff;
513 arr[num++] = (port_a >> 8) & 0xff;
514 arr[num++] = port_a & 0xff;
515
516 arr[num++] = 0x61;
517 arr[num++] = 0x95;
518 arr[num++] = 0x0;
519 arr[num++] = 0x4;
520 arr[num++] = 0;
521 arr[num++] = 0;
522 arr[num++] = (port_group_id >> 8) & 0xff;
523 arr[num++] = port_group_id & 0xff;
524
525 arr[num++] = 0x61;
526 arr[num++] = 0xa3;
527 arr[num++] = 0x0;
528 arr[num++] = 0x8;
529 arr[num++] = 0x52;
530 arr[num++] = 0x22;
531 arr[num++] = 0x22;
532 arr[num++] = 0x20;
533 arr[num++] = (target_dev_id >> 24);
534 arr[num++] = (target_dev_id >> 16) & 0xff;
535 arr[num++] = (target_dev_id >> 8) & 0xff;
536 arr[num++] = target_dev_id & 0xff;
537
538 arr[num++] = 0x63;
539 arr[num++] = 0xa8;
540 arr[num++] = 0x0;
541 arr[num++] = 24;
542 memcpy(arr + num, "naa.52222220", 12);
543 num += 12;
544 snprintf(b, sizeof(b), "%08X", target_dev_id);
545 memcpy(arr + num, b, 8);
546 num += 8;
547 memset(arr + num, 0, 4);
548 num += 4;
549 return num;
550}
551
552
553static unsigned char vpd84_data[] = {
554 0x22,0x22,0x22,0x0,0xbb,0x0,
555 0x22,0x22,0x22,0x0,0xbb,0x1,
556 0x22,0x22,0x22,0x0,0xbb,0x2,
557};
558
559static int inquiry_evpd_84(unsigned char * arr)
560{
561 memcpy(arr, vpd84_data, sizeof(vpd84_data));
562 return sizeof(vpd84_data);
563}
564
565static int inquiry_evpd_85(unsigned char * arr)
566{
567 int num = 0;
568 const char * na1 = "https://www.kernel.org/config";
569 const char * na2 = "http://www.kernel.org/log";
570 int plen, olen;
571
572 arr[num++] = 0x1;
573 arr[num++] = 0x0;
574 arr[num++] = 0x0;
575 olen = strlen(na1);
576 plen = olen + 1;
577 if (plen % 4)
578 plen = ((plen / 4) + 1) * 4;
579 arr[num++] = plen;
580 memcpy(arr + num, na1, olen);
581 memset(arr + num + olen, 0, plen - olen);
582 num += plen;
583
584 arr[num++] = 0x4;
585 arr[num++] = 0x0;
586 arr[num++] = 0x0;
587 olen = strlen(na2);
588 plen = olen + 1;
589 if (plen % 4)
590 plen = ((plen / 4) + 1) * 4;
591 arr[num++] = plen;
592 memcpy(arr + num, na2, olen);
593 memset(arr + num + olen, 0, plen - olen);
594 num += plen;
595
596 return num;
597}
598
599
600static int inquiry_evpd_88(unsigned char * arr, int target_dev_id)
601{
602 int num = 0;
603 int port_a, port_b;
604
605 port_a = target_dev_id + 1;
606 port_b = port_a + 1;
607 arr[num++] = 0x0;
608 arr[num++] = 0x0;
609 arr[num++] = 0x0;
610 arr[num++] = 0x1;
611 memset(arr + num, 0, 6);
612 num += 6;
613 arr[num++] = 0x0;
614 arr[num++] = 12;
615
616 arr[num++] = 0x61;
617 arr[num++] = 0x93;
618 arr[num++] = 0x0;
619 arr[num++] = 0x8;
620 arr[num++] = 0x52;
621 arr[num++] = 0x22;
622 arr[num++] = 0x22;
623 arr[num++] = 0x20;
624 arr[num++] = (port_a >> 24);
625 arr[num++] = (port_a >> 16) & 0xff;
626 arr[num++] = (port_a >> 8) & 0xff;
627 arr[num++] = port_a & 0xff;
628
629 arr[num++] = 0x0;
630 arr[num++] = 0x0;
631 arr[num++] = 0x0;
632 arr[num++] = 0x2;
633 memset(arr + num, 0, 6);
634 num += 6;
635 arr[num++] = 0x0;
636 arr[num++] = 12;
637
638 arr[num++] = 0x61;
639 arr[num++] = 0x93;
640 arr[num++] = 0x0;
641 arr[num++] = 0x8;
642 arr[num++] = 0x52;
643 arr[num++] = 0x22;
644 arr[num++] = 0x22;
645 arr[num++] = 0x20;
646 arr[num++] = (port_b >> 24);
647 arr[num++] = (port_b >> 16) & 0xff;
648 arr[num++] = (port_b >> 8) & 0xff;
649 arr[num++] = port_b & 0xff;
650
651 return num;
652}
653
654
655static unsigned char vpd89_data[] = {
656 0,0,0,0,
657'l','i','n','u','x',' ',' ',' ',
658'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
659'1','2','3','4',
6600x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
6610xec,0,0,0,
6620x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
6630,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
6640x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
6650x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
6660x53,0x41,
6670x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
6680x20,0x20,
6690x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
6700x10,0x80,
6710,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
6720x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
6730x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
6740,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
6750x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
6760x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
6770,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
6780,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6790,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6800,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6810x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
6820,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
6830xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
6840,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
6850,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6860,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6870,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6880,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6890,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6900,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6910,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6920,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6930,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6940,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6950,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6960,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
697};
698
699static int inquiry_evpd_89(unsigned char * arr)
700{
701 memcpy(arr, vpd89_data, sizeof(vpd89_data));
702 return sizeof(vpd89_data);
703}
704
705
706
707static unsigned char vpdb0_data[] = {
708 0,0,0,4, 0,0,0x4,0, 0,0,0,64,
709 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
710 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
711 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
712};
713
714static int inquiry_evpd_b0(unsigned char * arr)
715{
716 unsigned int gran;
717
718 memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
719
720
721 gran = 1 << scsi_debug_physblk_exp;
722 arr[2] = (gran >> 8) & 0xff;
723 arr[3] = gran & 0xff;
724
725
726 if (sdebug_store_sectors > 0x400) {
727 arr[4] = (sdebug_store_sectors >> 24) & 0xff;
728 arr[5] = (sdebug_store_sectors >> 16) & 0xff;
729 arr[6] = (sdebug_store_sectors >> 8) & 0xff;
730 arr[7] = sdebug_store_sectors & 0xff;
731 }
732
733
734 put_unaligned_be32(scsi_debug_opt_blks, &arr[8]);
735
736 if (scsi_debug_lbpu) {
737
738 put_unaligned_be32(scsi_debug_unmap_max_blocks, &arr[16]);
739
740
741 put_unaligned_be32(scsi_debug_unmap_max_desc, &arr[20]);
742 }
743
744
745 if (scsi_debug_unmap_alignment) {
746 put_unaligned_be32(scsi_debug_unmap_alignment, &arr[28]);
747 arr[28] |= 0x80;
748 }
749
750
751 put_unaligned_be32(scsi_debug_unmap_granularity, &arr[24]);
752
753
754 put_unaligned_be64(scsi_debug_write_same_length, &arr[32]);
755
756 return 0x3c;
757
758 return sizeof(vpdb0_data);
759}
760
761
762static int inquiry_evpd_b1(unsigned char *arr)
763{
764 memset(arr, 0, 0x3c);
765 arr[0] = 0;
766 arr[1] = 1;
767 arr[2] = 0;
768 arr[3] = 5;
769
770 return 0x3c;
771}
772
773
774static int inquiry_evpd_b2(unsigned char *arr)
775{
776 memset(arr, 0, 0x4);
777 arr[0] = 0;
778
779 if (scsi_debug_lbpu)
780 arr[1] = 1 << 7;
781
782 if (scsi_debug_lbpws)
783 arr[1] |= 1 << 6;
784
785 if (scsi_debug_lbpws10)
786 arr[1] |= 1 << 5;
787
788 if (scsi_debug_lbprz)
789 arr[1] |= 1 << 2;
790
791 return 0x4;
792}
793
794#define SDEBUG_LONG_INQ_SZ 96
795#define SDEBUG_MAX_INQ_ARR_SZ 584
796
797static int resp_inquiry(struct scsi_cmnd * scp, int target,
798 struct sdebug_dev_info * devip)
799{
800 unsigned char pq_pdt;
801 unsigned char * arr;
802 unsigned char *cmd = (unsigned char *)scp->cmnd;
803 int alloc_len, n, ret;
804
805 alloc_len = (cmd[3] << 8) + cmd[4];
806 arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
807 if (! arr)
808 return DID_REQUEUE << 16;
809 if (devip->wlun)
810 pq_pdt = 0x1e;
811 else if (scsi_debug_no_lun_0 && (0 == devip->lun))
812 pq_pdt = 0x7f;
813 else
814 pq_pdt = (scsi_debug_ptype & 0x1f);
815 arr[0] = pq_pdt;
816 if (0x2 & cmd[1]) {
817 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
818 0);
819 kfree(arr);
820 return check_condition_result;
821 } else if (0x1 & cmd[1]) {
822 int lu_id_num, port_group_id, target_dev_id, len;
823 char lu_id_str[6];
824 int host_no = devip->sdbg_host->shost->host_no;
825
826 port_group_id = (((host_no + 1) & 0x7f) << 8) +
827 (devip->channel & 0x7f);
828 if (0 == scsi_debug_vpd_use_hostno)
829 host_no = 0;
830 lu_id_num = devip->wlun ? -1 : (((host_no + 1) * 2000) +
831 (devip->target * 1000) + devip->lun);
832 target_dev_id = ((host_no + 1) * 2000) +
833 (devip->target * 1000) - 3;
834 len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
835 if (0 == cmd[2]) {
836 arr[1] = cmd[2];
837 n = 4;
838 arr[n++] = 0x0;
839 arr[n++] = 0x80;
840 arr[n++] = 0x83;
841 arr[n++] = 0x84;
842 arr[n++] = 0x85;
843 arr[n++] = 0x86;
844 arr[n++] = 0x87;
845 arr[n++] = 0x88;
846 arr[n++] = 0x89;
847 arr[n++] = 0xb0;
848 arr[n++] = 0xb1;
849 if (scsi_debug_lbp())
850 arr[n++] = 0xb2;
851 arr[3] = n - 4;
852 } else if (0x80 == cmd[2]) {
853 arr[1] = cmd[2];
854 arr[3] = len;
855 memcpy(&arr[4], lu_id_str, len);
856 } else if (0x83 == cmd[2]) {
857 arr[1] = cmd[2];
858 arr[3] = inquiry_evpd_83(&arr[4], port_group_id,
859 target_dev_id, lu_id_num,
860 lu_id_str, len);
861 } else if (0x84 == cmd[2]) {
862 arr[1] = cmd[2];
863 arr[3] = inquiry_evpd_84(&arr[4]);
864 } else if (0x85 == cmd[2]) {
865 arr[1] = cmd[2];
866 arr[3] = inquiry_evpd_85(&arr[4]);
867 } else if (0x86 == cmd[2]) {
868 arr[1] = cmd[2];
869 arr[3] = 0x3c;
870 if (scsi_debug_dif == SD_DIF_TYPE3_PROTECTION)
871 arr[4] = 0x4;
872 else if (scsi_debug_dif)
873 arr[4] = 0x5;
874 else
875 arr[4] = 0x0;
876 arr[5] = 0x7;
877 } else if (0x87 == cmd[2]) {
878 arr[1] = cmd[2];
879 arr[3] = 0x8;
880 arr[4] = 0x2;
881 arr[6] = 0x80;
882 arr[8] = 0x18;
883 arr[10] = 0x82;
884 } else if (0x88 == cmd[2]) {
885 arr[1] = cmd[2];
886 arr[3] = inquiry_evpd_88(&arr[4], target_dev_id);
887 } else if (0x89 == cmd[2]) {
888 arr[1] = cmd[2];
889 n = inquiry_evpd_89(&arr[4]);
890 arr[2] = (n >> 8);
891 arr[3] = (n & 0xff);
892 } else if (0xb0 == cmd[2]) {
893 arr[1] = cmd[2];
894 arr[3] = inquiry_evpd_b0(&arr[4]);
895 } else if (0xb1 == cmd[2]) {
896 arr[1] = cmd[2];
897 arr[3] = inquiry_evpd_b1(&arr[4]);
898 } else if (0xb2 == cmd[2]) {
899 arr[1] = cmd[2];
900 arr[3] = inquiry_evpd_b2(&arr[4]);
901 } else {
902
903 mk_sense_buffer(devip, ILLEGAL_REQUEST,
904 INVALID_FIELD_IN_CDB, 0);
905 kfree(arr);
906 return check_condition_result;
907 }
908 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
909 ret = fill_from_dev_buffer(scp, arr,
910 min(len, SDEBUG_MAX_INQ_ARR_SZ));
911 kfree(arr);
912 return ret;
913 }
914
915 arr[1] = scsi_debug_removable ? 0x80 : 0;
916 arr[2] = scsi_debug_scsi_level;
917 arr[3] = 2;
918 arr[4] = SDEBUG_LONG_INQ_SZ - 5;
919 arr[5] = scsi_debug_dif ? 1 : 0;
920 if (0 == scsi_debug_vpd_use_hostno)
921 arr[5] = 0x10;
922 arr[6] = 0x10;
923
924 arr[7] = 0xa;
925 memcpy(&arr[8], inq_vendor_id, 8);
926 memcpy(&arr[16], inq_product_id, 16);
927 memcpy(&arr[32], inq_product_rev, 4);
928
929 arr[58] = 0x0; arr[59] = 0x77;
930 arr[60] = 0x3; arr[61] = 0x14;
931 n = 62;
932 if (scsi_debug_ptype == 0) {
933 arr[n++] = 0x3; arr[n++] = 0x3d;
934 } else if (scsi_debug_ptype == 1) {
935 arr[n++] = 0x3; arr[n++] = 0x60;
936 }
937 arr[n++] = 0xc; arr[n++] = 0xf;
938 ret = fill_from_dev_buffer(scp, arr,
939 min(alloc_len, SDEBUG_LONG_INQ_SZ));
940 kfree(arr);
941 return ret;
942}
943
944static int resp_requests(struct scsi_cmnd * scp,
945 struct sdebug_dev_info * devip)
946{
947 unsigned char * sbuff;
948 unsigned char *cmd = (unsigned char *)scp->cmnd;
949 unsigned char arr[SDEBUG_SENSE_LEN];
950 int want_dsense;
951 int len = 18;
952
953 memset(arr, 0, sizeof(arr));
954 if (devip->reset == 1)
955 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
956 want_dsense = !!(cmd[1] & 1) || scsi_debug_dsense;
957 sbuff = devip->sense_buff;
958 if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
959 if (want_dsense) {
960 arr[0] = 0x72;
961 arr[1] = 0x0;
962 arr[2] = THRESHOLD_EXCEEDED;
963 arr[3] = 0xff;
964 } else {
965 arr[0] = 0x70;
966 arr[2] = 0x0;
967 arr[7] = 0xa;
968 arr[12] = THRESHOLD_EXCEEDED;
969 arr[13] = 0xff;
970 }
971 } else {
972 memcpy(arr, sbuff, SDEBUG_SENSE_LEN);
973 if ((cmd[1] & 1) && (! scsi_debug_dsense)) {
974
975 memset(arr, 0, sizeof(arr));
976 arr[0] = 0x72;
977 arr[1] = sbuff[2];
978 arr[2] = sbuff[12];
979 arr[3] = sbuff[13];
980 len = 8;
981 }
982 }
983 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
984 return fill_from_dev_buffer(scp, arr, len);
985}
986
987static int resp_start_stop(struct scsi_cmnd * scp,
988 struct sdebug_dev_info * devip)
989{
990 unsigned char *cmd = (unsigned char *)scp->cmnd;
991 int power_cond, errsts, start;
992
993 if ((errsts = check_readiness(scp, 1, devip)))
994 return errsts;
995 power_cond = (cmd[4] & 0xf0) >> 4;
996 if (power_cond) {
997 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
998 0);
999 return check_condition_result;
1000 }
1001 start = cmd[4] & 1;
1002 if (start == devip->stopped)
1003 devip->stopped = !start;
1004 return 0;
1005}
1006
1007static sector_t get_sdebug_capacity(void)
1008{
1009 if (scsi_debug_virtual_gb > 0)
1010 return (sector_t)scsi_debug_virtual_gb *
1011 (1073741824 / scsi_debug_sector_size);
1012 else
1013 return sdebug_store_sectors;
1014}
1015
1016#define SDEBUG_READCAP_ARR_SZ 8
1017static int resp_readcap(struct scsi_cmnd * scp,
1018 struct sdebug_dev_info * devip)
1019{
1020 unsigned char arr[SDEBUG_READCAP_ARR_SZ];
1021 unsigned int capac;
1022 int errsts;
1023
1024 if ((errsts = check_readiness(scp, 1, devip)))
1025 return errsts;
1026
1027 sdebug_capacity = get_sdebug_capacity();
1028 memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
1029 if (sdebug_capacity < 0xffffffff) {
1030 capac = (unsigned int)sdebug_capacity - 1;
1031 arr[0] = (capac >> 24);
1032 arr[1] = (capac >> 16) & 0xff;
1033 arr[2] = (capac >> 8) & 0xff;
1034 arr[3] = capac & 0xff;
1035 } else {
1036 arr[0] = 0xff;
1037 arr[1] = 0xff;
1038 arr[2] = 0xff;
1039 arr[3] = 0xff;
1040 }
1041 arr[6] = (scsi_debug_sector_size >> 8) & 0xff;
1042 arr[7] = scsi_debug_sector_size & 0xff;
1043 return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
1044}
1045
1046#define SDEBUG_READCAP16_ARR_SZ 32
1047static int resp_readcap16(struct scsi_cmnd * scp,
1048 struct sdebug_dev_info * devip)
1049{
1050 unsigned char *cmd = (unsigned char *)scp->cmnd;
1051 unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
1052 unsigned long long capac;
1053 int errsts, k, alloc_len;
1054
1055 if ((errsts = check_readiness(scp, 1, devip)))
1056 return errsts;
1057 alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8)
1058 + cmd[13]);
1059
1060 sdebug_capacity = get_sdebug_capacity();
1061 memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
1062 capac = sdebug_capacity - 1;
1063 for (k = 0; k < 8; ++k, capac >>= 8)
1064 arr[7 - k] = capac & 0xff;
1065 arr[8] = (scsi_debug_sector_size >> 24) & 0xff;
1066 arr[9] = (scsi_debug_sector_size >> 16) & 0xff;
1067 arr[10] = (scsi_debug_sector_size >> 8) & 0xff;
1068 arr[11] = scsi_debug_sector_size & 0xff;
1069 arr[13] = scsi_debug_physblk_exp & 0xf;
1070 arr[14] = (scsi_debug_lowest_aligned >> 8) & 0x3f;
1071
1072 if (scsi_debug_lbp()) {
1073 arr[14] |= 0x80;
1074 if (scsi_debug_lbprz)
1075 arr[14] |= 0x40;
1076 }
1077
1078 arr[15] = scsi_debug_lowest_aligned & 0xff;
1079
1080 if (scsi_debug_dif) {
1081 arr[12] = (scsi_debug_dif - 1) << 1;
1082 arr[12] |= 1;
1083 }
1084
1085 return fill_from_dev_buffer(scp, arr,
1086 min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
1087}
1088
1089#define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
1090
1091static int resp_report_tgtpgs(struct scsi_cmnd * scp,
1092 struct sdebug_dev_info * devip)
1093{
1094 unsigned char *cmd = (unsigned char *)scp->cmnd;
1095 unsigned char * arr;
1096 int host_no = devip->sdbg_host->shost->host_no;
1097 int n, ret, alen, rlen;
1098 int port_group_a, port_group_b, port_a, port_b;
1099
1100 alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8)
1101 + cmd[9]);
1102
1103 arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
1104 if (! arr)
1105 return DID_REQUEUE << 16;
1106
1107
1108
1109
1110
1111
1112 port_a = 0x1;
1113 port_b = 0x2;
1114 port_group_a = (((host_no + 1) & 0x7f) << 8) +
1115 (devip->channel & 0x7f);
1116 port_group_b = (((host_no + 1) & 0x7f) << 8) +
1117 (devip->channel & 0x7f) + 0x80;
1118
1119
1120
1121
1122 n = 4;
1123 if (0 == scsi_debug_vpd_use_hostno) {
1124 arr[n++] = host_no % 3;
1125 arr[n++] = 0x0F;
1126 } else {
1127 arr[n++] = 0x0;
1128 arr[n++] = 0x01;
1129 }
1130 arr[n++] = (port_group_a >> 8) & 0xff;
1131 arr[n++] = port_group_a & 0xff;
1132 arr[n++] = 0;
1133 arr[n++] = 0;
1134 arr[n++] = 0;
1135 arr[n++] = 0x1;
1136 arr[n++] = 0;
1137 arr[n++] = 0;
1138 arr[n++] = (port_a >> 8) & 0xff;
1139 arr[n++] = port_a & 0xff;
1140 arr[n++] = 3;
1141 arr[n++] = 0x08;
1142 arr[n++] = (port_group_b >> 8) & 0xff;
1143 arr[n++] = port_group_b & 0xff;
1144 arr[n++] = 0;
1145 arr[n++] = 0;
1146 arr[n++] = 0;
1147 arr[n++] = 0x1;
1148 arr[n++] = 0;
1149 arr[n++] = 0;
1150 arr[n++] = (port_b >> 8) & 0xff;
1151 arr[n++] = port_b & 0xff;
1152
1153 rlen = n - 4;
1154 arr[0] = (rlen >> 24) & 0xff;
1155 arr[1] = (rlen >> 16) & 0xff;
1156 arr[2] = (rlen >> 8) & 0xff;
1157 arr[3] = rlen & 0xff;
1158
1159
1160
1161
1162
1163
1164
1165 rlen = min(alen,n);
1166 ret = fill_from_dev_buffer(scp, arr,
1167 min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
1168 kfree(arr);
1169 return ret;
1170}
1171
1172
1173
1174static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
1175{
1176 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
1177 5, 0, 0xff, 0xff};
1178
1179 memcpy(p, err_recov_pg, sizeof(err_recov_pg));
1180 if (1 == pcontrol)
1181 memset(p + 2, 0, sizeof(err_recov_pg) - 2);
1182 return sizeof(err_recov_pg);
1183}
1184
1185static int resp_disconnect_pg(unsigned char * p, int pcontrol, int target)
1186{
1187 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
1188 0, 0, 0, 0, 0, 0, 0, 0};
1189
1190 memcpy(p, disconnect_pg, sizeof(disconnect_pg));
1191 if (1 == pcontrol)
1192 memset(p + 2, 0, sizeof(disconnect_pg) - 2);
1193 return sizeof(disconnect_pg);
1194}
1195
1196static int resp_format_pg(unsigned char * p, int pcontrol, int target)
1197{
1198 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
1199 0, 0, 0, 0, 0, 0, 0, 0,
1200 0, 0, 0, 0, 0x40, 0, 0, 0};
1201
1202 memcpy(p, format_pg, sizeof(format_pg));
1203 p[10] = (sdebug_sectors_per >> 8) & 0xff;
1204 p[11] = sdebug_sectors_per & 0xff;
1205 p[12] = (scsi_debug_sector_size >> 8) & 0xff;
1206 p[13] = scsi_debug_sector_size & 0xff;
1207 if (scsi_debug_removable)
1208 p[20] |= 0x20;
1209 if (1 == pcontrol)
1210 memset(p + 2, 0, sizeof(format_pg) - 2);
1211 return sizeof(format_pg);
1212}
1213
1214static int resp_caching_pg(unsigned char * p, int pcontrol, int target)
1215{
1216 unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1217 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
1218
1219 memcpy(p, caching_pg, sizeof(caching_pg));
1220 if (1 == pcontrol)
1221 memset(p + 2, 0, sizeof(caching_pg) - 2);
1222 return sizeof(caching_pg);
1223}
1224
1225static int resp_ctrl_m_pg(unsigned char * p, int pcontrol, int target)
1226{
1227 unsigned char ch_ctrl_m_pg[] = { 0x6, 0, 0, 0, 0, 0,
1228 0, 0, 0, 0};
1229 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1230 0, 0, 0x2, 0x4b};
1231
1232 if (scsi_debug_dsense)
1233 ctrl_m_pg[2] |= 0x4;
1234 else
1235 ctrl_m_pg[2] &= ~0x4;
1236
1237 if (scsi_debug_ato)
1238 ctrl_m_pg[5] |= 0x80;
1239
1240 memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
1241 if (1 == pcontrol)
1242 memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
1243 else if (2 == pcontrol)
1244 memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
1245 return sizeof(ctrl_m_pg);
1246}
1247
1248
1249static int resp_iec_m_pg(unsigned char * p, int pcontrol, int target)
1250{
1251 unsigned char ch_iec_m_pg[] = { 0x4, 0xf, 0, 0, 0, 0,
1252 0, 0, 0x0, 0x0};
1253 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1254 0, 0, 0x0, 0x0};
1255
1256 memcpy(p, iec_m_pg, sizeof(iec_m_pg));
1257 if (1 == pcontrol)
1258 memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
1259 else if (2 == pcontrol)
1260 memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
1261 return sizeof(iec_m_pg);
1262}
1263
1264static int resp_sas_sf_m_pg(unsigned char * p, int pcontrol, int target)
1265{
1266 unsigned char sas_sf_m_pg[] = {0x19, 0x6,
1267 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
1268
1269 memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
1270 if (1 == pcontrol)
1271 memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
1272 return sizeof(sas_sf_m_pg);
1273}
1274
1275
1276static int resp_sas_pcd_m_spg(unsigned char * p, int pcontrol, int target,
1277 int target_dev_id)
1278{
1279 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
1280 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
1281 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1282 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1283 0x2, 0, 0, 0, 0, 0, 0, 0,
1284 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1285 0, 0, 0, 0, 0, 0, 0, 0,
1286 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
1287 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1288 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1289 0x3, 0, 0, 0, 0, 0, 0, 0,
1290 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1291 0, 0, 0, 0, 0, 0, 0, 0,
1292 };
1293 int port_a, port_b;
1294
1295 port_a = target_dev_id + 1;
1296 port_b = port_a + 1;
1297 memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
1298 p[20] = (port_a >> 24);
1299 p[21] = (port_a >> 16) & 0xff;
1300 p[22] = (port_a >> 8) & 0xff;
1301 p[23] = port_a & 0xff;
1302 p[48 + 20] = (port_b >> 24);
1303 p[48 + 21] = (port_b >> 16) & 0xff;
1304 p[48 + 22] = (port_b >> 8) & 0xff;
1305 p[48 + 23] = port_b & 0xff;
1306 if (1 == pcontrol)
1307 memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
1308 return sizeof(sas_pcd_m_pg);
1309}
1310
1311static int resp_sas_sha_m_spg(unsigned char * p, int pcontrol)
1312{
1313 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
1314 0, 0, 0, 0, 0, 0, 0, 0,
1315 };
1316
1317 memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
1318 if (1 == pcontrol)
1319 memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
1320 return sizeof(sas_sha_m_pg);
1321}
1322
1323#define SDEBUG_MAX_MSENSE_SZ 256
1324
1325static int resp_mode_sense(struct scsi_cmnd * scp, int target,
1326 struct sdebug_dev_info * devip)
1327{
1328 unsigned char dbd, llbaa;
1329 int pcontrol, pcode, subpcode, bd_len;
1330 unsigned char dev_spec;
1331 int k, alloc_len, msense_6, offset, len, errsts, target_dev_id;
1332 unsigned char * ap;
1333 unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
1334 unsigned char *cmd = (unsigned char *)scp->cmnd;
1335
1336 if ((errsts = check_readiness(scp, 1, devip)))
1337 return errsts;
1338 dbd = !!(cmd[1] & 0x8);
1339 pcontrol = (cmd[2] & 0xc0) >> 6;
1340 pcode = cmd[2] & 0x3f;
1341 subpcode = cmd[3];
1342 msense_6 = (MODE_SENSE == cmd[0]);
1343 llbaa = msense_6 ? 0 : !!(cmd[1] & 0x10);
1344 if ((0 == scsi_debug_ptype) && (0 == dbd))
1345 bd_len = llbaa ? 16 : 8;
1346 else
1347 bd_len = 0;
1348 alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]);
1349 memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
1350 if (0x3 == pcontrol) {
1351 mk_sense_buffer(devip, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP,
1352 0);
1353 return check_condition_result;
1354 }
1355 target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
1356 (devip->target * 1000) - 3;
1357
1358 if (0 == scsi_debug_ptype)
1359 dev_spec = (DEV_READONLY(target) ? 0x80 : 0x0) | 0x10;
1360 else
1361 dev_spec = 0x0;
1362 if (msense_6) {
1363 arr[2] = dev_spec;
1364 arr[3] = bd_len;
1365 offset = 4;
1366 } else {
1367 arr[3] = dev_spec;
1368 if (16 == bd_len)
1369 arr[4] = 0x1;
1370 arr[7] = bd_len;
1371 offset = 8;
1372 }
1373 ap = arr + offset;
1374 if ((bd_len > 0) && (!sdebug_capacity))
1375 sdebug_capacity = get_sdebug_capacity();
1376
1377 if (8 == bd_len) {
1378 if (sdebug_capacity > 0xfffffffe) {
1379 ap[0] = 0xff;
1380 ap[1] = 0xff;
1381 ap[2] = 0xff;
1382 ap[3] = 0xff;
1383 } else {
1384 ap[0] = (sdebug_capacity >> 24) & 0xff;
1385 ap[1] = (sdebug_capacity >> 16) & 0xff;
1386 ap[2] = (sdebug_capacity >> 8) & 0xff;
1387 ap[3] = sdebug_capacity & 0xff;
1388 }
1389 ap[6] = (scsi_debug_sector_size >> 8) & 0xff;
1390 ap[7] = scsi_debug_sector_size & 0xff;
1391 offset += bd_len;
1392 ap = arr + offset;
1393 } else if (16 == bd_len) {
1394 unsigned long long capac = sdebug_capacity;
1395
1396 for (k = 0; k < 8; ++k, capac >>= 8)
1397 ap[7 - k] = capac & 0xff;
1398 ap[12] = (scsi_debug_sector_size >> 24) & 0xff;
1399 ap[13] = (scsi_debug_sector_size >> 16) & 0xff;
1400 ap[14] = (scsi_debug_sector_size >> 8) & 0xff;
1401 ap[15] = scsi_debug_sector_size & 0xff;
1402 offset += bd_len;
1403 ap = arr + offset;
1404 }
1405
1406 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
1407
1408 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1409 0);
1410 return check_condition_result;
1411 }
1412 switch (pcode) {
1413 case 0x1:
1414 len = resp_err_recov_pg(ap, pcontrol, target);
1415 offset += len;
1416 break;
1417 case 0x2:
1418 len = resp_disconnect_pg(ap, pcontrol, target);
1419 offset += len;
1420 break;
1421 case 0x3:
1422 len = resp_format_pg(ap, pcontrol, target);
1423 offset += len;
1424 break;
1425 case 0x8:
1426 len = resp_caching_pg(ap, pcontrol, target);
1427 offset += len;
1428 break;
1429 case 0xa:
1430 len = resp_ctrl_m_pg(ap, pcontrol, target);
1431 offset += len;
1432 break;
1433 case 0x19:
1434 if ((subpcode > 0x2) && (subpcode < 0xff)) {
1435 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1436 INVALID_FIELD_IN_CDB, 0);
1437 return check_condition_result;
1438 }
1439 len = 0;
1440 if ((0x0 == subpcode) || (0xff == subpcode))
1441 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1442 if ((0x1 == subpcode) || (0xff == subpcode))
1443 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
1444 target_dev_id);
1445 if ((0x2 == subpcode) || (0xff == subpcode))
1446 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1447 offset += len;
1448 break;
1449 case 0x1c:
1450 len = resp_iec_m_pg(ap, pcontrol, target);
1451 offset += len;
1452 break;
1453 case 0x3f:
1454 if ((0 == subpcode) || (0xff == subpcode)) {
1455 len = resp_err_recov_pg(ap, pcontrol, target);
1456 len += resp_disconnect_pg(ap + len, pcontrol, target);
1457 len += resp_format_pg(ap + len, pcontrol, target);
1458 len += resp_caching_pg(ap + len, pcontrol, target);
1459 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
1460 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1461 if (0xff == subpcode) {
1462 len += resp_sas_pcd_m_spg(ap + len, pcontrol,
1463 target, target_dev_id);
1464 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1465 }
1466 len += resp_iec_m_pg(ap + len, pcontrol, target);
1467 } else {
1468 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1469 INVALID_FIELD_IN_CDB, 0);
1470 return check_condition_result;
1471 }
1472 offset += len;
1473 break;
1474 default:
1475 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1476 0);
1477 return check_condition_result;
1478 }
1479 if (msense_6)
1480 arr[0] = offset - 1;
1481 else {
1482 arr[0] = ((offset - 2) >> 8) & 0xff;
1483 arr[1] = (offset - 2) & 0xff;
1484 }
1485 return fill_from_dev_buffer(scp, arr, min(alloc_len, offset));
1486}
1487
1488#define SDEBUG_MAX_MSELECT_SZ 512
1489
1490static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
1491 struct sdebug_dev_info * devip)
1492{
1493 int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
1494 int param_len, res, errsts, mpage;
1495 unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
1496 unsigned char *cmd = (unsigned char *)scp->cmnd;
1497
1498 if ((errsts = check_readiness(scp, 1, devip)))
1499 return errsts;
1500 memset(arr, 0, sizeof(arr));
1501 pf = cmd[1] & 0x10;
1502 sp = cmd[1] & 0x1;
1503 param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]);
1504 if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
1505 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1506 INVALID_FIELD_IN_CDB, 0);
1507 return check_condition_result;
1508 }
1509 res = fetch_to_dev_buffer(scp, arr, param_len);
1510 if (-1 == res)
1511 return (DID_ERROR << 16);
1512 else if ((res < param_len) &&
1513 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1514 printk(KERN_INFO "scsi_debug: mode_select: cdb indicated=%d, "
1515 " IO sent=%d bytes\n", param_len, res);
1516 md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2);
1517 bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]);
1518 if (md_len > 2) {
1519 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1520 INVALID_FIELD_IN_PARAM_LIST, 0);
1521 return check_condition_result;
1522 }
1523 off = bd_len + (mselect6 ? 4 : 8);
1524 mpage = arr[off] & 0x3f;
1525 ps = !!(arr[off] & 0x80);
1526 if (ps) {
1527 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1528 INVALID_FIELD_IN_PARAM_LIST, 0);
1529 return check_condition_result;
1530 }
1531 spf = !!(arr[off] & 0x40);
1532 pg_len = spf ? ((arr[off + 2] << 8) + arr[off + 3] + 4) :
1533 (arr[off + 1] + 2);
1534 if ((pg_len + off) > param_len) {
1535 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1536 PARAMETER_LIST_LENGTH_ERR, 0);
1537 return check_condition_result;
1538 }
1539 switch (mpage) {
1540 case 0xa:
1541 if (ctrl_m_pg[1] == arr[off + 1]) {
1542 memcpy(ctrl_m_pg + 2, arr + off + 2,
1543 sizeof(ctrl_m_pg) - 2);
1544 scsi_debug_dsense = !!(ctrl_m_pg[2] & 0x4);
1545 return 0;
1546 }
1547 break;
1548 case 0x1c:
1549 if (iec_m_pg[1] == arr[off + 1]) {
1550 memcpy(iec_m_pg + 2, arr + off + 2,
1551 sizeof(iec_m_pg) - 2);
1552 return 0;
1553 }
1554 break;
1555 default:
1556 break;
1557 }
1558 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1559 INVALID_FIELD_IN_PARAM_LIST, 0);
1560 return check_condition_result;
1561}
1562
1563static int resp_temp_l_pg(unsigned char * arr)
1564{
1565 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
1566 0x0, 0x1, 0x3, 0x2, 0x0, 65,
1567 };
1568
1569 memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
1570 return sizeof(temp_l_pg);
1571}
1572
1573static int resp_ie_l_pg(unsigned char * arr)
1574{
1575 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
1576 };
1577
1578 memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
1579 if (iec_m_pg[2] & 0x4) {
1580 arr[4] = THRESHOLD_EXCEEDED;
1581 arr[5] = 0xff;
1582 }
1583 return sizeof(ie_l_pg);
1584}
1585
1586#define SDEBUG_MAX_LSENSE_SZ 512
1587
1588static int resp_log_sense(struct scsi_cmnd * scp,
1589 struct sdebug_dev_info * devip)
1590{
1591 int ppc, sp, pcontrol, pcode, subpcode, alloc_len, errsts, len, n;
1592 unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
1593 unsigned char *cmd = (unsigned char *)scp->cmnd;
1594
1595 if ((errsts = check_readiness(scp, 1, devip)))
1596 return errsts;
1597 memset(arr, 0, sizeof(arr));
1598 ppc = cmd[1] & 0x2;
1599 sp = cmd[1] & 0x1;
1600 if (ppc || sp) {
1601 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1602 INVALID_FIELD_IN_CDB, 0);
1603 return check_condition_result;
1604 }
1605 pcontrol = (cmd[2] & 0xc0) >> 6;
1606 pcode = cmd[2] & 0x3f;
1607 subpcode = cmd[3] & 0xff;
1608 alloc_len = (cmd[7] << 8) + cmd[8];
1609 arr[0] = pcode;
1610 if (0 == subpcode) {
1611 switch (pcode) {
1612 case 0x0:
1613 n = 4;
1614 arr[n++] = 0x0;
1615 arr[n++] = 0xd;
1616 arr[n++] = 0x2f;
1617 arr[3] = n - 4;
1618 break;
1619 case 0xd:
1620 arr[3] = resp_temp_l_pg(arr + 4);
1621 break;
1622 case 0x2f:
1623 arr[3] = resp_ie_l_pg(arr + 4);
1624 break;
1625 default:
1626 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1627 INVALID_FIELD_IN_CDB, 0);
1628 return check_condition_result;
1629 }
1630 } else if (0xff == subpcode) {
1631 arr[0] |= 0x40;
1632 arr[1] = subpcode;
1633 switch (pcode) {
1634 case 0x0:
1635 n = 4;
1636 arr[n++] = 0x0;
1637 arr[n++] = 0x0;
1638 arr[n++] = 0x0;
1639 arr[n++] = 0xff;
1640 arr[n++] = 0xd;
1641 arr[n++] = 0x0;
1642 arr[n++] = 0x2f;
1643 arr[n++] = 0x0;
1644 arr[3] = n - 4;
1645 break;
1646 case 0xd:
1647 n = 4;
1648 arr[n++] = 0xd;
1649 arr[n++] = 0x0;
1650 arr[3] = n - 4;
1651 break;
1652 case 0x2f:
1653 n = 4;
1654 arr[n++] = 0x2f;
1655 arr[n++] = 0x0;
1656 arr[3] = n - 4;
1657 break;
1658 default:
1659 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1660 INVALID_FIELD_IN_CDB, 0);
1661 return check_condition_result;
1662 }
1663 } else {
1664 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1665 INVALID_FIELD_IN_CDB, 0);
1666 return check_condition_result;
1667 }
1668 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
1669 return fill_from_dev_buffer(scp, arr,
1670 min(len, SDEBUG_MAX_INQ_ARR_SZ));
1671}
1672
1673static int check_device_access_params(struct sdebug_dev_info *devi,
1674 unsigned long long lba, unsigned int num)
1675{
1676 if (lba + num > sdebug_capacity) {
1677 mk_sense_buffer(devi, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE, 0);
1678 return check_condition_result;
1679 }
1680
1681 if (num > sdebug_store_sectors) {
1682 mk_sense_buffer(devi, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
1683 return check_condition_result;
1684 }
1685 return 0;
1686}
1687
1688
1689static int do_device_access(struct scsi_cmnd *scmd,
1690 struct sdebug_dev_info *devi,
1691 unsigned long long lba, unsigned int num, int write)
1692{
1693 int ret;
1694 unsigned long long block, rest = 0;
1695 struct scsi_data_buffer *sdb;
1696 enum dma_data_direction dir;
1697 size_t (*func)(struct scatterlist *, unsigned int, void *, size_t,
1698 off_t);
1699
1700 if (write) {
1701 sdb = scsi_out(scmd);
1702 dir = DMA_TO_DEVICE;
1703 func = sg_pcopy_to_buffer;
1704 } else {
1705 sdb = scsi_in(scmd);
1706 dir = DMA_FROM_DEVICE;
1707 func = sg_pcopy_from_buffer;
1708 }
1709
1710 if (!sdb->length)
1711 return 0;
1712 if (!(scsi_bidi_cmnd(scmd) || scmd->sc_data_direction == dir))
1713 return -1;
1714
1715 block = do_div(lba, sdebug_store_sectors);
1716 if (block + num > sdebug_store_sectors)
1717 rest = block + num - sdebug_store_sectors;
1718
1719 ret = func(sdb->table.sgl, sdb->table.nents,
1720 fake_storep + (block * scsi_debug_sector_size),
1721 (num - rest) * scsi_debug_sector_size, 0);
1722 if (ret != (num - rest) * scsi_debug_sector_size)
1723 return ret;
1724
1725 if (rest) {
1726 ret += func(sdb->table.sgl, sdb->table.nents,
1727 fake_storep, rest * scsi_debug_sector_size,
1728 (num - rest) * scsi_debug_sector_size);
1729 }
1730
1731 return ret;
1732}
1733
1734static u16 dif_compute_csum(const void *buf, int len)
1735{
1736 u16 csum;
1737
1738 switch (scsi_debug_guard) {
1739 case 1:
1740 csum = ip_compute_csum(buf, len);
1741 break;
1742 case 0:
1743 csum = cpu_to_be16(crc_t10dif(buf, len));
1744 break;
1745 }
1746 return csum;
1747}
1748
1749static int dif_verify(struct sd_dif_tuple *sdt, const void *data,
1750 sector_t sector, u32 ei_lba)
1751{
1752 u16 csum = dif_compute_csum(data, scsi_debug_sector_size);
1753
1754 if (sdt->guard_tag != csum) {
1755 pr_err("%s: GUARD check failed on sector %lu rcvd 0x%04x, data 0x%04x\n",
1756 __func__,
1757 (unsigned long)sector,
1758 be16_to_cpu(sdt->guard_tag),
1759 be16_to_cpu(csum));
1760 return 0x01;
1761 }
1762 if (scsi_debug_dif == SD_DIF_TYPE1_PROTECTION &&
1763 be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
1764 pr_err("%s: REF check failed on sector %lu\n",
1765 __func__, (unsigned long)sector);
1766 return 0x03;
1767 }
1768 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
1769 be32_to_cpu(sdt->ref_tag) != ei_lba) {
1770 pr_err("%s: REF check failed on sector %lu\n",
1771 __func__, (unsigned long)sector);
1772 dif_errors++;
1773 return 0x03;
1774 }
1775 return 0;
1776}
1777
1778static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec,
1779 unsigned int sectors, u32 ei_lba)
1780{
1781 unsigned int i, resid;
1782 struct scatterlist *psgl;
1783 struct sd_dif_tuple *sdt;
1784 sector_t sector;
1785 sector_t tmp_sec = start_sec;
1786 void *paddr;
1787
1788 start_sec = do_div(tmp_sec, sdebug_store_sectors);
1789
1790 sdt = dif_storep + start_sec;
1791
1792 for (i = 0 ; i < sectors ; i++) {
1793 int ret;
1794
1795 if (sdt[i].app_tag == 0xffff)
1796 continue;
1797
1798 sector = start_sec + i;
1799
1800 ret = dif_verify(&sdt[i],
1801 fake_storep + sector * scsi_debug_sector_size,
1802 sector, ei_lba);
1803 if (ret) {
1804 dif_errors++;
1805 return ret;
1806 }
1807
1808 ei_lba++;
1809 }
1810
1811
1812 resid = sectors * sizeof(*dif_storep);
1813 sector = start_sec;
1814
1815 scsi_for_each_prot_sg(SCpnt, psgl, scsi_prot_sg_count(SCpnt), i) {
1816 int len = min(psgl->length, resid);
1817
1818 paddr = kmap_atomic(sg_page(psgl)) + psgl->offset;
1819 memcpy(paddr, dif_storep + sector, len);
1820
1821 sector += len / sizeof(*dif_storep);
1822 if (sector >= sdebug_store_sectors) {
1823
1824 tmp_sec = sector;
1825 sector = do_div(tmp_sec, sdebug_store_sectors);
1826 }
1827 resid -= len;
1828 kunmap_atomic(paddr);
1829 }
1830
1831 dix_reads++;
1832
1833 return 0;
1834}
1835
1836static int resp_read(struct scsi_cmnd *SCpnt, unsigned long long lba,
1837 unsigned int num, struct sdebug_dev_info *devip,
1838 u32 ei_lba)
1839{
1840 unsigned long iflags;
1841 int ret;
1842
1843 ret = check_device_access_params(devip, lba, num);
1844 if (ret)
1845 return ret;
1846
1847 if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) &&
1848 (lba <= (OPT_MEDIUM_ERR_ADDR + OPT_MEDIUM_ERR_NUM - 1)) &&
1849 ((lba + num) > OPT_MEDIUM_ERR_ADDR)) {
1850
1851 mk_sense_buffer(devip, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 0);
1852
1853 if (0x70 == (devip->sense_buff[0] & 0x7f)) {
1854 devip->sense_buff[0] |= 0x80;
1855 ret = (lba < OPT_MEDIUM_ERR_ADDR)
1856 ? OPT_MEDIUM_ERR_ADDR : (int)lba;
1857 devip->sense_buff[3] = (ret >> 24) & 0xff;
1858 devip->sense_buff[4] = (ret >> 16) & 0xff;
1859 devip->sense_buff[5] = (ret >> 8) & 0xff;
1860 devip->sense_buff[6] = ret & 0xff;
1861 }
1862 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
1863 return check_condition_result;
1864 }
1865
1866
1867 if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) {
1868 int prot_ret = prot_verify_read(SCpnt, lba, num, ei_lba);
1869
1870 if (prot_ret) {
1871 mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, prot_ret);
1872 return illegal_condition_result;
1873 }
1874 }
1875
1876 read_lock_irqsave(&atomic_rw, iflags);
1877 ret = do_device_access(SCpnt, devip, lba, num, 0);
1878 read_unlock_irqrestore(&atomic_rw, iflags);
1879 if (ret == -1)
1880 return DID_ERROR << 16;
1881
1882 scsi_in(SCpnt)->resid = scsi_bufflen(SCpnt) - ret;
1883
1884 return 0;
1885}
1886
1887void dump_sector(unsigned char *buf, int len)
1888{
1889 int i, j;
1890
1891 printk(KERN_ERR ">>> Sector Dump <<<\n");
1892
1893 for (i = 0 ; i < len ; i += 16) {
1894 printk(KERN_ERR "%04d: ", i);
1895
1896 for (j = 0 ; j < 16 ; j++) {
1897 unsigned char c = buf[i+j];
1898 if (c >= 0x20 && c < 0x7e)
1899 printk(" %c ", buf[i+j]);
1900 else
1901 printk("%02x ", buf[i+j]);
1902 }
1903
1904 printk("\n");
1905 }
1906}
1907
1908static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
1909 unsigned int sectors, u32 ei_lba)
1910{
1911 int i, j, ret;
1912 struct sd_dif_tuple *sdt;
1913 struct scatterlist *dsgl = scsi_sglist(SCpnt);
1914 struct scatterlist *psgl = scsi_prot_sglist(SCpnt);
1915 void *daddr, *paddr;
1916 sector_t tmp_sec = start_sec;
1917 sector_t sector;
1918 int ppage_offset;
1919
1920 sector = do_div(tmp_sec, sdebug_store_sectors);
1921
1922 BUG_ON(scsi_sg_count(SCpnt) == 0);
1923 BUG_ON(scsi_prot_sg_count(SCpnt) == 0);
1924
1925 ppage_offset = 0;
1926
1927
1928 scsi_for_each_sg(SCpnt, dsgl, scsi_sg_count(SCpnt), i) {
1929 daddr = kmap_atomic(sg_page(dsgl)) + dsgl->offset;
1930 paddr = kmap_atomic(sg_page(psgl)) + psgl->offset;
1931
1932
1933 for (j = 0; j < dsgl->length; j += scsi_debug_sector_size) {
1934
1935
1936
1937
1938 if (ppage_offset >= psgl->length) {
1939 kunmap_atomic(paddr);
1940 psgl = sg_next(psgl);
1941 BUG_ON(psgl == NULL);
1942 paddr = kmap_atomic(sg_page(psgl))
1943 + psgl->offset;
1944 ppage_offset = 0;
1945 }
1946
1947 sdt = paddr + ppage_offset;
1948
1949 ret = dif_verify(sdt, daddr + j, start_sec, ei_lba);
1950 if (ret) {
1951 dump_sector(daddr + j, scsi_debug_sector_size);
1952 goto out;
1953 }
1954
1955
1956
1957
1958
1959
1960 memcpy(dif_storep + sector, sdt, sizeof(*sdt));
1961
1962 sector++;
1963
1964 if (sector == sdebug_store_sectors)
1965 sector = 0;
1966
1967 start_sec++;
1968 ei_lba++;
1969 ppage_offset += sizeof(struct sd_dif_tuple);
1970 }
1971
1972 kunmap_atomic(paddr);
1973 kunmap_atomic(daddr);
1974 }
1975
1976 dix_writes++;
1977
1978 return 0;
1979
1980out:
1981 dif_errors++;
1982 kunmap_atomic(paddr);
1983 kunmap_atomic(daddr);
1984 return ret;
1985}
1986
1987static unsigned long lba_to_map_index(sector_t lba)
1988{
1989 if (scsi_debug_unmap_alignment) {
1990 lba += scsi_debug_unmap_granularity -
1991 scsi_debug_unmap_alignment;
1992 }
1993 do_div(lba, scsi_debug_unmap_granularity);
1994
1995 return lba;
1996}
1997
1998static sector_t map_index_to_lba(unsigned long index)
1999{
2000 sector_t lba = index * scsi_debug_unmap_granularity;
2001
2002 if (scsi_debug_unmap_alignment) {
2003 lba -= scsi_debug_unmap_granularity -
2004 scsi_debug_unmap_alignment;
2005 }
2006
2007 return lba;
2008}
2009
2010static unsigned int map_state(sector_t lba, unsigned int *num)
2011{
2012 sector_t end;
2013 unsigned int mapped;
2014 unsigned long index;
2015 unsigned long next;
2016
2017 index = lba_to_map_index(lba);
2018 mapped = test_bit(index, map_storep);
2019
2020 if (mapped)
2021 next = find_next_zero_bit(map_storep, map_size, index);
2022 else
2023 next = find_next_bit(map_storep, map_size, index);
2024
2025 end = min_t(sector_t, sdebug_store_sectors, map_index_to_lba(next));
2026 *num = end - lba;
2027
2028 return mapped;
2029}
2030
2031static void map_region(sector_t lba, unsigned int len)
2032{
2033 sector_t end = lba + len;
2034
2035 while (lba < end) {
2036 unsigned long index = lba_to_map_index(lba);
2037
2038 if (index < map_size)
2039 set_bit(index, map_storep);
2040
2041 lba = map_index_to_lba(index + 1);
2042 }
2043}
2044
2045static void unmap_region(sector_t lba, unsigned int len)
2046{
2047 sector_t end = lba + len;
2048
2049 while (lba < end) {
2050 unsigned long index = lba_to_map_index(lba);
2051
2052 if (lba == map_index_to_lba(index) &&
2053 lba + scsi_debug_unmap_granularity <= end &&
2054 index < map_size) {
2055 clear_bit(index, map_storep);
2056 if (scsi_debug_lbprz) {
2057 memset(fake_storep +
2058 lba * scsi_debug_sector_size, 0,
2059 scsi_debug_sector_size *
2060 scsi_debug_unmap_granularity);
2061 }
2062 if (dif_storep) {
2063 memset(dif_storep + lba, 0xff,
2064 sizeof(*dif_storep) *
2065 scsi_debug_unmap_granularity);
2066 }
2067 }
2068 lba = map_index_to_lba(index + 1);
2069 }
2070}
2071
2072static int resp_write(struct scsi_cmnd *SCpnt, unsigned long long lba,
2073 unsigned int num, struct sdebug_dev_info *devip,
2074 u32 ei_lba)
2075{
2076 unsigned long iflags;
2077 int ret;
2078
2079 ret = check_device_access_params(devip, lba, num);
2080 if (ret)
2081 return ret;
2082
2083
2084 if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) {
2085 int prot_ret = prot_verify_write(SCpnt, lba, num, ei_lba);
2086
2087 if (prot_ret) {
2088 mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, prot_ret);
2089 return illegal_condition_result;
2090 }
2091 }
2092
2093 write_lock_irqsave(&atomic_rw, iflags);
2094 ret = do_device_access(SCpnt, devip, lba, num, 1);
2095 if (scsi_debug_lbp())
2096 map_region(lba, num);
2097 write_unlock_irqrestore(&atomic_rw, iflags);
2098 if (-1 == ret)
2099 return (DID_ERROR << 16);
2100 else if ((ret < (num * scsi_debug_sector_size)) &&
2101 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
2102 printk(KERN_INFO "scsi_debug: write: cdb indicated=%u, "
2103 " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret);
2104
2105 return 0;
2106}
2107
2108static int resp_write_same(struct scsi_cmnd *scmd, unsigned long long lba,
2109 unsigned int num, struct sdebug_dev_info *devip,
2110 u32 ei_lba, unsigned int unmap)
2111{
2112 unsigned long iflags;
2113 unsigned long long i;
2114 int ret;
2115
2116 ret = check_device_access_params(devip, lba, num);
2117 if (ret)
2118 return ret;
2119
2120 if (num > scsi_debug_write_same_length) {
2121 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
2122 0);
2123 return check_condition_result;
2124 }
2125
2126 write_lock_irqsave(&atomic_rw, iflags);
2127
2128 if (unmap && scsi_debug_lbp()) {
2129 unmap_region(lba, num);
2130 goto out;
2131 }
2132
2133
2134 ret = fetch_to_dev_buffer(scmd,
2135 fake_storep + (lba * scsi_debug_sector_size),
2136 scsi_debug_sector_size);
2137
2138 if (-1 == ret) {
2139 write_unlock_irqrestore(&atomic_rw, iflags);
2140 return (DID_ERROR << 16);
2141 } else if ((ret < (num * scsi_debug_sector_size)) &&
2142 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
2143 printk(KERN_INFO "scsi_debug: write same: cdb indicated=%u, "
2144 " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret);
2145
2146
2147 for (i = 1 ; i < num ; i++)
2148 memcpy(fake_storep + ((lba + i) * scsi_debug_sector_size),
2149 fake_storep + (lba * scsi_debug_sector_size),
2150 scsi_debug_sector_size);
2151
2152 if (scsi_debug_lbp())
2153 map_region(lba, num);
2154out:
2155 write_unlock_irqrestore(&atomic_rw, iflags);
2156
2157 return 0;
2158}
2159
2160struct unmap_block_desc {
2161 __be64 lba;
2162 __be32 blocks;
2163 __be32 __reserved;
2164};
2165
2166static int resp_unmap(struct scsi_cmnd * scmd, struct sdebug_dev_info * devip)
2167{
2168 unsigned char *buf;
2169 struct unmap_block_desc *desc;
2170 unsigned int i, payload_len, descriptors;
2171 int ret;
2172
2173 ret = check_readiness(scmd, 1, devip);
2174 if (ret)
2175 return ret;
2176
2177 payload_len = get_unaligned_be16(&scmd->cmnd[7]);
2178 BUG_ON(scsi_bufflen(scmd) != payload_len);
2179
2180 descriptors = (payload_len - 8) / 16;
2181
2182 buf = kmalloc(scsi_bufflen(scmd), GFP_ATOMIC);
2183 if (!buf)
2184 return check_condition_result;
2185
2186 scsi_sg_copy_to_buffer(scmd, buf, scsi_bufflen(scmd));
2187
2188 BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2);
2189 BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16);
2190
2191 desc = (void *)&buf[8];
2192
2193 for (i = 0 ; i < descriptors ; i++) {
2194 unsigned long long lba = get_unaligned_be64(&desc[i].lba);
2195 unsigned int num = get_unaligned_be32(&desc[i].blocks);
2196
2197 ret = check_device_access_params(devip, lba, num);
2198 if (ret)
2199 goto out;
2200
2201 unmap_region(lba, num);
2202 }
2203
2204 ret = 0;
2205
2206out:
2207 kfree(buf);
2208
2209 return ret;
2210}
2211
2212#define SDEBUG_GET_LBA_STATUS_LEN 32
2213
2214static int resp_get_lba_status(struct scsi_cmnd * scmd,
2215 struct sdebug_dev_info * devip)
2216{
2217 unsigned long long lba;
2218 unsigned int alloc_len, mapped, num;
2219 unsigned char arr[SDEBUG_GET_LBA_STATUS_LEN];
2220 int ret;
2221
2222 ret = check_readiness(scmd, 1, devip);
2223 if (ret)
2224 return ret;
2225
2226 lba = get_unaligned_be64(&scmd->cmnd[2]);
2227 alloc_len = get_unaligned_be32(&scmd->cmnd[10]);
2228
2229 if (alloc_len < 24)
2230 return 0;
2231
2232 ret = check_device_access_params(devip, lba, 1);
2233 if (ret)
2234 return ret;
2235
2236 mapped = map_state(lba, &num);
2237
2238 memset(arr, 0, SDEBUG_GET_LBA_STATUS_LEN);
2239 put_unaligned_be32(20, &arr[0]);
2240 put_unaligned_be64(lba, &arr[8]);
2241 put_unaligned_be32(num, &arr[16]);
2242 arr[20] = !mapped;
2243
2244 return fill_from_dev_buffer(scmd, arr, SDEBUG_GET_LBA_STATUS_LEN);
2245}
2246
2247#define SDEBUG_RLUN_ARR_SZ 256
2248
2249static int resp_report_luns(struct scsi_cmnd * scp,
2250 struct sdebug_dev_info * devip)
2251{
2252 unsigned int alloc_len;
2253 int lun_cnt, i, upper, num, n, wlun, lun;
2254 unsigned char *cmd = (unsigned char *)scp->cmnd;
2255 int select_report = (int)cmd[2];
2256 struct scsi_lun *one_lun;
2257 unsigned char arr[SDEBUG_RLUN_ARR_SZ];
2258 unsigned char * max_addr;
2259
2260 alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
2261 if ((alloc_len < 4) || (select_report > 2)) {
2262 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
2263 0);
2264 return check_condition_result;
2265 }
2266
2267 memset(arr, 0, SDEBUG_RLUN_ARR_SZ);
2268 lun_cnt = scsi_debug_max_luns;
2269 if (1 == select_report)
2270 lun_cnt = 0;
2271 else if (scsi_debug_no_lun_0 && (lun_cnt > 0))
2272 --lun_cnt;
2273 wlun = (select_report > 0) ? 1 : 0;
2274 num = lun_cnt + wlun;
2275 arr[2] = ((sizeof(struct scsi_lun) * num) >> 8) & 0xff;
2276 arr[3] = (sizeof(struct scsi_lun) * num) & 0xff;
2277 n = min((int)((SDEBUG_RLUN_ARR_SZ - 8) /
2278 sizeof(struct scsi_lun)), num);
2279 if (n < num) {
2280 wlun = 0;
2281 lun_cnt = n;
2282 }
2283 one_lun = (struct scsi_lun *) &arr[8];
2284 max_addr = arr + SDEBUG_RLUN_ARR_SZ;
2285 for (i = 0, lun = (scsi_debug_no_lun_0 ? 1 : 0);
2286 ((i < lun_cnt) && ((unsigned char *)(one_lun + i) < max_addr));
2287 i++, lun++) {
2288 upper = (lun >> 8) & 0x3f;
2289 if (upper)
2290 one_lun[i].scsi_lun[0] =
2291 (upper | (SAM2_LUN_ADDRESS_METHOD << 6));
2292 one_lun[i].scsi_lun[1] = lun & 0xff;
2293 }
2294 if (wlun) {
2295 one_lun[i].scsi_lun[0] = (SAM2_WLUN_REPORT_LUNS >> 8) & 0xff;
2296 one_lun[i].scsi_lun[1] = SAM2_WLUN_REPORT_LUNS & 0xff;
2297 i++;
2298 }
2299 alloc_len = (unsigned char *)(one_lun + i) - arr;
2300 return fill_from_dev_buffer(scp, arr,
2301 min((int)alloc_len, SDEBUG_RLUN_ARR_SZ));
2302}
2303
2304static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
2305 unsigned int num, struct sdebug_dev_info *devip)
2306{
2307 int i, j, ret = -1;
2308 unsigned char *kaddr, *buf;
2309 unsigned int offset;
2310 struct scatterlist *sg;
2311 struct scsi_data_buffer *sdb = scsi_in(scp);
2312
2313
2314 buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
2315 if (!buf)
2316 return ret;
2317
2318 scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
2319
2320 offset = 0;
2321 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, i) {
2322 kaddr = (unsigned char *)kmap_atomic(sg_page(sg));
2323 if (!kaddr)
2324 goto out;
2325
2326 for (j = 0; j < sg->length; j++)
2327 *(kaddr + sg->offset + j) ^= *(buf + offset + j);
2328
2329 offset += sg->length;
2330 kunmap_atomic(kaddr);
2331 }
2332 ret = 0;
2333out:
2334 kfree(buf);
2335
2336 return ret;
2337}
2338
2339
2340static void timer_intr_handler(unsigned long indx)
2341{
2342 struct sdebug_queued_cmd * sqcp;
2343 unsigned long iflags;
2344
2345 if (indx >= scsi_debug_max_queue) {
2346 printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too "
2347 "large\n");
2348 return;
2349 }
2350 spin_lock_irqsave(&queued_arr_lock, iflags);
2351 sqcp = &queued_arr[(int)indx];
2352 if (! sqcp->in_use) {
2353 printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected "
2354 "interrupt\n");
2355 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2356 return;
2357 }
2358 sqcp->in_use = 0;
2359 if (sqcp->done_funct) {
2360 sqcp->a_cmnd->result = sqcp->scsi_result;
2361 sqcp->done_funct(sqcp->a_cmnd);
2362 }
2363 sqcp->done_funct = NULL;
2364 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2365}
2366
2367
2368static struct sdebug_dev_info *
2369sdebug_device_create(struct sdebug_host_info *sdbg_host, gfp_t flags)
2370{
2371 struct sdebug_dev_info *devip;
2372
2373 devip = kzalloc(sizeof(*devip), flags);
2374 if (devip) {
2375 devip->sdbg_host = sdbg_host;
2376 list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
2377 }
2378 return devip;
2379}
2380
2381static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
2382{
2383 struct sdebug_host_info * sdbg_host;
2384 struct sdebug_dev_info * open_devip = NULL;
2385 struct sdebug_dev_info * devip =
2386 (struct sdebug_dev_info *)sdev->hostdata;
2387
2388 if (devip)
2389 return devip;
2390 sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
2391 if (!sdbg_host) {
2392 printk(KERN_ERR "Host info NULL\n");
2393 return NULL;
2394 }
2395 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
2396 if ((devip->used) && (devip->channel == sdev->channel) &&
2397 (devip->target == sdev->id) &&
2398 (devip->lun == sdev->lun))
2399 return devip;
2400 else {
2401 if ((!devip->used) && (!open_devip))
2402 open_devip = devip;
2403 }
2404 }
2405 if (!open_devip) {
2406 open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC);
2407 if (!open_devip) {
2408 printk(KERN_ERR "%s: out of memory at line %d\n",
2409 __func__, __LINE__);
2410 return NULL;
2411 }
2412 }
2413
2414 open_devip->channel = sdev->channel;
2415 open_devip->target = sdev->id;
2416 open_devip->lun = sdev->lun;
2417 open_devip->sdbg_host = sdbg_host;
2418 open_devip->reset = 1;
2419 open_devip->used = 1;
2420 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
2421 if (scsi_debug_dsense)
2422 open_devip->sense_buff[0] = 0x72;
2423 else {
2424 open_devip->sense_buff[0] = 0x70;
2425 open_devip->sense_buff[7] = 0xa;
2426 }
2427 if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
2428 open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
2429
2430 return open_devip;
2431}
2432
2433static int scsi_debug_slave_alloc(struct scsi_device *sdp)
2434{
2435 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2436 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
2437 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2438 queue_flag_set_unlocked(QUEUE_FLAG_BIDI, sdp->request_queue);
2439 return 0;
2440}
2441
2442static int scsi_debug_slave_configure(struct scsi_device *sdp)
2443{
2444 struct sdebug_dev_info *devip;
2445
2446 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2447 printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n",
2448 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2449 if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN)
2450 sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN;
2451 devip = devInfoReg(sdp);
2452 if (NULL == devip)
2453 return 1;
2454 sdp->hostdata = devip;
2455 if (sdp->host->cmd_per_lun)
2456 scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING,
2457 sdp->host->cmd_per_lun);
2458 blk_queue_max_segment_size(sdp->request_queue, 256 * 1024);
2459 if (scsi_debug_no_uld)
2460 sdp->no_uld_attach = 1;
2461 return 0;
2462}
2463
2464static void scsi_debug_slave_destroy(struct scsi_device *sdp)
2465{
2466 struct sdebug_dev_info *devip =
2467 (struct sdebug_dev_info *)sdp->hostdata;
2468
2469 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2470 printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n",
2471 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2472 if (devip) {
2473
2474 devip->used = 0;
2475 sdp->hostdata = NULL;
2476 }
2477}
2478
2479
2480static int stop_queued_cmnd(struct scsi_cmnd *cmnd)
2481{
2482 unsigned long iflags;
2483 int k;
2484 struct sdebug_queued_cmd *sqcp;
2485
2486 spin_lock_irqsave(&queued_arr_lock, iflags);
2487 for (k = 0; k < scsi_debug_max_queue; ++k) {
2488 sqcp = &queued_arr[k];
2489 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
2490 del_timer_sync(&sqcp->cmnd_timer);
2491 sqcp->in_use = 0;
2492 sqcp->a_cmnd = NULL;
2493 break;
2494 }
2495 }
2496 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2497 return (k < scsi_debug_max_queue) ? 1 : 0;
2498}
2499
2500
2501static void stop_all_queued(void)
2502{
2503 unsigned long iflags;
2504 int k;
2505 struct sdebug_queued_cmd *sqcp;
2506
2507 spin_lock_irqsave(&queued_arr_lock, iflags);
2508 for (k = 0; k < scsi_debug_max_queue; ++k) {
2509 sqcp = &queued_arr[k];
2510 if (sqcp->in_use && sqcp->a_cmnd) {
2511 del_timer_sync(&sqcp->cmnd_timer);
2512 sqcp->in_use = 0;
2513 sqcp->a_cmnd = NULL;
2514 }
2515 }
2516 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2517}
2518
2519static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
2520{
2521 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2522 printk(KERN_INFO "scsi_debug: abort\n");
2523 ++num_aborts;
2524 stop_queued_cmnd(SCpnt);
2525 return SUCCESS;
2526}
2527
2528static int scsi_debug_biosparam(struct scsi_device *sdev,
2529 struct block_device * bdev, sector_t capacity, int *info)
2530{
2531 int res;
2532 unsigned char *buf;
2533
2534 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2535 printk(KERN_INFO "scsi_debug: biosparam\n");
2536 buf = scsi_bios_ptable(bdev);
2537 if (buf) {
2538 res = scsi_partsize(buf, capacity,
2539 &info[2], &info[0], &info[1]);
2540 kfree(buf);
2541 if (! res)
2542 return res;
2543 }
2544 info[0] = sdebug_heads;
2545 info[1] = sdebug_sectors_per;
2546 info[2] = sdebug_cylinders_per;
2547 return 0;
2548}
2549
2550static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
2551{
2552 struct sdebug_dev_info * devip;
2553
2554 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2555 printk(KERN_INFO "scsi_debug: device_reset\n");
2556 ++num_dev_resets;
2557 if (SCpnt) {
2558 devip = devInfoReg(SCpnt->device);
2559 if (devip)
2560 devip->reset = 1;
2561 }
2562 return SUCCESS;
2563}
2564
2565static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
2566{
2567 struct sdebug_host_info *sdbg_host;
2568 struct sdebug_dev_info * dev_info;
2569 struct scsi_device * sdp;
2570 struct Scsi_Host * hp;
2571
2572 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2573 printk(KERN_INFO "scsi_debug: bus_reset\n");
2574 ++num_bus_resets;
2575 if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
2576 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
2577 if (sdbg_host) {
2578 list_for_each_entry(dev_info,
2579 &sdbg_host->dev_info_list,
2580 dev_list)
2581 dev_info->reset = 1;
2582 }
2583 }
2584 return SUCCESS;
2585}
2586
2587static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
2588{
2589 struct sdebug_host_info * sdbg_host;
2590 struct sdebug_dev_info * dev_info;
2591
2592 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2593 printk(KERN_INFO "scsi_debug: host_reset\n");
2594 ++num_host_resets;
2595 spin_lock(&sdebug_host_list_lock);
2596 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
2597 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
2598 dev_list)
2599 dev_info->reset = 1;
2600 }
2601 spin_unlock(&sdebug_host_list_lock);
2602 stop_all_queued();
2603 return SUCCESS;
2604}
2605
2606
2607static void __init init_all_queued(void)
2608{
2609 unsigned long iflags;
2610 int k;
2611 struct sdebug_queued_cmd * sqcp;
2612
2613 spin_lock_irqsave(&queued_arr_lock, iflags);
2614 for (k = 0; k < scsi_debug_max_queue; ++k) {
2615 sqcp = &queued_arr[k];
2616 init_timer(&sqcp->cmnd_timer);
2617 sqcp->in_use = 0;
2618 sqcp->a_cmnd = NULL;
2619 }
2620 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2621}
2622
2623static void __init sdebug_build_parts(unsigned char *ramp,
2624 unsigned long store_size)
2625{
2626 struct partition * pp;
2627 int starts[SDEBUG_MAX_PARTS + 2];
2628 int sectors_per_part, num_sectors, k;
2629 int heads_by_sects, start_sec, end_sec;
2630
2631
2632 if ((scsi_debug_num_parts < 1) || (store_size < 1048576))
2633 return;
2634 if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
2635 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
2636 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
2637 "partitions to %d\n", SDEBUG_MAX_PARTS);
2638 }
2639 num_sectors = (int)sdebug_store_sectors;
2640 sectors_per_part = (num_sectors - sdebug_sectors_per)
2641 / scsi_debug_num_parts;
2642 heads_by_sects = sdebug_heads * sdebug_sectors_per;
2643 starts[0] = sdebug_sectors_per;
2644 for (k = 1; k < scsi_debug_num_parts; ++k)
2645 starts[k] = ((k * sectors_per_part) / heads_by_sects)
2646 * heads_by_sects;
2647 starts[scsi_debug_num_parts] = num_sectors;
2648 starts[scsi_debug_num_parts + 1] = 0;
2649
2650 ramp[510] = 0x55;
2651 ramp[511] = 0xAA;
2652 pp = (struct partition *)(ramp + 0x1be);
2653 for (k = 0; starts[k + 1]; ++k, ++pp) {
2654 start_sec = starts[k];
2655 end_sec = starts[k + 1] - 1;
2656 pp->boot_ind = 0;
2657
2658 pp->cyl = start_sec / heads_by_sects;
2659 pp->head = (start_sec - (pp->cyl * heads_by_sects))
2660 / sdebug_sectors_per;
2661 pp->sector = (start_sec % sdebug_sectors_per) + 1;
2662
2663 pp->end_cyl = end_sec / heads_by_sects;
2664 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
2665 / sdebug_sectors_per;
2666 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2667
2668 pp->start_sect = cpu_to_le32(start_sec);
2669 pp->nr_sects = cpu_to_le32(end_sec - start_sec + 1);
2670 pp->sys_ind = 0x83;
2671 }
2672}
2673
2674static int schedule_resp(struct scsi_cmnd * cmnd,
2675 struct sdebug_dev_info * devip,
2676 done_funct_t done, int scsi_result, int delta_jiff)
2677{
2678 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
2679 if (scsi_result) {
2680 struct scsi_device * sdp = cmnd->device;
2681
2682 printk(KERN_INFO "scsi_debug: <%u %u %u %u> "
2683 "non-zero result=0x%x\n", sdp->host->host_no,
2684 sdp->channel, sdp->id, sdp->lun, scsi_result);
2685 }
2686 }
2687 if (cmnd && devip) {
2688
2689 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
2690 memcpy(cmnd->sense_buffer, devip->sense_buff,
2691 (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
2692 SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
2693 }
2694 if (delta_jiff <= 0) {
2695 if (cmnd)
2696 cmnd->result = scsi_result;
2697 if (done)
2698 done(cmnd);
2699 return 0;
2700 } else {
2701 unsigned long iflags;
2702 int k;
2703 struct sdebug_queued_cmd * sqcp = NULL;
2704
2705 spin_lock_irqsave(&queued_arr_lock, iflags);
2706 for (k = 0; k < scsi_debug_max_queue; ++k) {
2707 sqcp = &queued_arr[k];
2708 if (! sqcp->in_use)
2709 break;
2710 }
2711 if (k >= scsi_debug_max_queue) {
2712 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2713 printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
2714 return 1;
2715 }
2716 sqcp->in_use = 1;
2717 sqcp->a_cmnd = cmnd;
2718 sqcp->scsi_result = scsi_result;
2719 sqcp->done_funct = done;
2720 sqcp->cmnd_timer.function = timer_intr_handler;
2721 sqcp->cmnd_timer.data = k;
2722 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
2723 add_timer(&sqcp->cmnd_timer);
2724 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2725 if (cmnd)
2726 cmnd->result = 0;
2727 return 0;
2728 }
2729}
2730
2731
2732
2733
2734
2735
2736module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
2737module_param_named(ato, scsi_debug_ato, int, S_IRUGO);
2738module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
2739module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
2740module_param_named(dif, scsi_debug_dif, int, S_IRUGO);
2741module_param_named(dix, scsi_debug_dix, int, S_IRUGO);
2742module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
2743module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
2744module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
2745module_param_named(guard, scsi_debug_guard, int, S_IRUGO);
2746module_param_named(lbpu, scsi_debug_lbpu, int, S_IRUGO);
2747module_param_named(lbpws, scsi_debug_lbpws, int, S_IRUGO);
2748module_param_named(lbpws10, scsi_debug_lbpws10, int, S_IRUGO);
2749module_param_named(lbprz, scsi_debug_lbprz, int, S_IRUGO);
2750module_param_named(lowest_aligned, scsi_debug_lowest_aligned, int, S_IRUGO);
2751module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
2752module_param_named(max_queue, scsi_debug_max_queue, int, S_IRUGO | S_IWUSR);
2753module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
2754module_param_named(no_uld, scsi_debug_no_uld, int, S_IRUGO);
2755module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
2756module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
2757module_param_named(opt_blks, scsi_debug_opt_blks, int, S_IRUGO);
2758module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
2759module_param_named(physblk_exp, scsi_debug_physblk_exp, int, S_IRUGO);
2760module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
2761module_param_named(removable, scsi_debug_removable, bool, S_IRUGO | S_IWUSR);
2762module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
2763module_param_named(sector_size, scsi_debug_sector_size, int, S_IRUGO);
2764module_param_named(unmap_alignment, scsi_debug_unmap_alignment, int, S_IRUGO);
2765module_param_named(unmap_granularity, scsi_debug_unmap_granularity, int, S_IRUGO);
2766module_param_named(unmap_max_blocks, scsi_debug_unmap_max_blocks, int, S_IRUGO);
2767module_param_named(unmap_max_desc, scsi_debug_unmap_max_desc, int, S_IRUGO);
2768module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
2769module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
2770 S_IRUGO | S_IWUSR);
2771module_param_named(write_same_length, scsi_debug_write_same_length, int,
2772 S_IRUGO | S_IWUSR);
2773
2774MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2775MODULE_DESCRIPTION("SCSI debug adapter driver");
2776MODULE_LICENSE("GPL");
2777MODULE_VERSION(SCSI_DEBUG_VERSION);
2778
2779MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
2780MODULE_PARM_DESC(ato, "application tag ownership: 0=disk 1=host (def=1)");
2781MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
2782MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
2783MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)");
2784MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)");
2785MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
2786MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
2787MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
2788MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");
2789MODULE_PARM_DESC(lbpu, "enable LBP, support UNMAP command (def=0)");
2790MODULE_PARM_DESC(lbpws, "enable LBP, support WRITE SAME(16) with UNMAP bit (def=0)");
2791MODULE_PARM_DESC(lbpws10, "enable LBP, support WRITE SAME(10) with UNMAP bit (def=0)");
2792MODULE_PARM_DESC(lbprz, "unmapped blocks return 0 on read (def=1)");
2793MODULE_PARM_DESC(lowest_aligned, "lowest aligned lba (def=0)");
2794MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
2795MODULE_PARM_DESC(max_queue, "max number of queued commands (1 to 255(def))");
2796MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
2797MODULE_PARM_DESC(no_uld, "stop ULD (e.g. sd driver) attaching (def=0))");
2798MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
2799MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
2800MODULE_PARM_DESC(opt_blks, "optimal transfer length in block (def=64)");
2801MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
2802MODULE_PARM_DESC(physblk_exp, "physical block exponent (def=0)");
2803MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
2804MODULE_PARM_DESC(removable, "claim to have removable media (def=0)");
2805MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
2806MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)");
2807MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)");
2808MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=1)");
2809MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0xffffffff)");
2810MODULE_PARM_DESC(unmap_max_desc, "max # of ranges that can be unmapped in one cmd (def=256)");
2811MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
2812MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2813MODULE_PARM_DESC(write_same_length, "Maximum blocks per WRITE SAME cmd (def=0xffff)");
2814
2815static char sdebug_info[256];
2816
2817static const char * scsi_debug_info(struct Scsi_Host * shp)
2818{
2819 sprintf(sdebug_info, "scsi_debug, version %s [%s], "
2820 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
2821 scsi_debug_version_date, scsi_debug_dev_size_mb,
2822 scsi_debug_opts);
2823 return sdebug_info;
2824}
2825
2826
2827
2828
2829static int scsi_debug_write_info(struct Scsi_Host *host, char *buffer, int length)
2830{
2831 char arr[16];
2832 int opts;
2833 int minLen = length > 15 ? 15 : length;
2834
2835 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2836 return -EACCES;
2837 memcpy(arr, buffer, minLen);
2838 arr[minLen] = '\0';
2839 if (1 != sscanf(arr, "%d", &opts))
2840 return -EINVAL;
2841 scsi_debug_opts = opts;
2842 if (scsi_debug_every_nth != 0)
2843 scsi_debug_cmnd_count = 0;
2844 return length;
2845}
2846
2847static int scsi_debug_show_info(struct seq_file *m, struct Scsi_Host *host)
2848{
2849 seq_printf(m, "scsi_debug adapter driver, version "
2850 "%s [%s]\n"
2851 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2852 "every_nth=%d(curr:%d)\n"
2853 "delay=%d, max_luns=%d, scsi_level=%d\n"
2854 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2855 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2856 "host_resets=%d\ndix_reads=%d dix_writes=%d dif_errors=%d\n",
2857 SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
2858 scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2859 scsi_debug_cmnd_count, scsi_debug_delay,
2860 scsi_debug_max_luns, scsi_debug_scsi_level,
2861 scsi_debug_sector_size, sdebug_cylinders_per, sdebug_heads,
2862 sdebug_sectors_per, num_aborts, num_dev_resets, num_bus_resets,
2863 num_host_resets, dix_reads, dix_writes, dif_errors);
2864 return 0;
2865}
2866
2867static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf)
2868{
2869 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
2870}
2871
2872static ssize_t sdebug_delay_store(struct device_driver * ddp,
2873 const char * buf, size_t count)
2874{
2875 int delay;
2876 char work[20];
2877
2878 if (1 == sscanf(buf, "%10s", work)) {
2879 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
2880 scsi_debug_delay = delay;
2881 return count;
2882 }
2883 }
2884 return -EINVAL;
2885}
2886DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show,
2887 sdebug_delay_store);
2888
2889static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf)
2890{
2891 return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
2892}
2893
2894static ssize_t sdebug_opts_store(struct device_driver * ddp,
2895 const char * buf, size_t count)
2896{
2897 int opts;
2898 char work[20];
2899
2900 if (1 == sscanf(buf, "%10s", work)) {
2901 if (0 == strnicmp(work,"0x", 2)) {
2902 if (1 == sscanf(&work[2], "%x", &opts))
2903 goto opts_done;
2904 } else {
2905 if (1 == sscanf(work, "%d", &opts))
2906 goto opts_done;
2907 }
2908 }
2909 return -EINVAL;
2910opts_done:
2911 scsi_debug_opts = opts;
2912 scsi_debug_cmnd_count = 0;
2913 return count;
2914}
2915DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show,
2916 sdebug_opts_store);
2917
2918static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf)
2919{
2920 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
2921}
2922static ssize_t sdebug_ptype_store(struct device_driver * ddp,
2923 const char * buf, size_t count)
2924{
2925 int n;
2926
2927 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2928 scsi_debug_ptype = n;
2929 return count;
2930 }
2931 return -EINVAL;
2932}
2933DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store);
2934
2935static ssize_t sdebug_dsense_show(struct device_driver * ddp, char * buf)
2936{
2937 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
2938}
2939static ssize_t sdebug_dsense_store(struct device_driver * ddp,
2940 const char * buf, size_t count)
2941{
2942 int n;
2943
2944 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2945 scsi_debug_dsense = n;
2946 return count;
2947 }
2948 return -EINVAL;
2949}
2950DRIVER_ATTR(dsense, S_IRUGO | S_IWUSR, sdebug_dsense_show,
2951 sdebug_dsense_store);
2952
2953static ssize_t sdebug_fake_rw_show(struct device_driver * ddp, char * buf)
2954{
2955 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
2956}
2957static ssize_t sdebug_fake_rw_store(struct device_driver * ddp,
2958 const char * buf, size_t count)
2959{
2960 int n;
2961
2962 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2963 scsi_debug_fake_rw = n;
2964 return count;
2965 }
2966 return -EINVAL;
2967}
2968DRIVER_ATTR(fake_rw, S_IRUGO | S_IWUSR, sdebug_fake_rw_show,
2969 sdebug_fake_rw_store);
2970
2971static ssize_t sdebug_no_lun_0_show(struct device_driver * ddp, char * buf)
2972{
2973 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
2974}
2975static ssize_t sdebug_no_lun_0_store(struct device_driver * ddp,
2976 const char * buf, size_t count)
2977{
2978 int n;
2979
2980 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2981 scsi_debug_no_lun_0 = n;
2982 return count;
2983 }
2984 return -EINVAL;
2985}
2986DRIVER_ATTR(no_lun_0, S_IRUGO | S_IWUSR, sdebug_no_lun_0_show,
2987 sdebug_no_lun_0_store);
2988
2989static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf)
2990{
2991 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
2992}
2993static ssize_t sdebug_num_tgts_store(struct device_driver * ddp,
2994 const char * buf, size_t count)
2995{
2996 int n;
2997
2998 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2999 scsi_debug_num_tgts = n;
3000 sdebug_max_tgts_luns();
3001 return count;
3002 }
3003 return -EINVAL;
3004}
3005DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show,
3006 sdebug_num_tgts_store);
3007
3008static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf)
3009{
3010 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
3011}
3012DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL);
3013
3014static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf)
3015{
3016 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
3017}
3018DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL);
3019
3020static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf)
3021{
3022 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
3023}
3024static ssize_t sdebug_every_nth_store(struct device_driver * ddp,
3025 const char * buf, size_t count)
3026{
3027 int nth;
3028
3029 if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
3030 scsi_debug_every_nth = nth;
3031 scsi_debug_cmnd_count = 0;
3032 return count;
3033 }
3034 return -EINVAL;
3035}
3036DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show,
3037 sdebug_every_nth_store);
3038
3039static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf)
3040{
3041 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
3042}
3043static ssize_t sdebug_max_luns_store(struct device_driver * ddp,
3044 const char * buf, size_t count)
3045{
3046 int n;
3047
3048 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
3049 scsi_debug_max_luns = n;
3050 sdebug_max_tgts_luns();
3051 return count;
3052 }
3053 return -EINVAL;
3054}
3055DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show,
3056 sdebug_max_luns_store);
3057
3058static ssize_t sdebug_max_queue_show(struct device_driver * ddp, char * buf)
3059{
3060 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_queue);
3061}
3062static ssize_t sdebug_max_queue_store(struct device_driver * ddp,
3063 const char * buf, size_t count)
3064{
3065 int n;
3066
3067 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n > 0) &&
3068 (n <= SCSI_DEBUG_CANQUEUE)) {
3069 scsi_debug_max_queue = n;
3070 return count;
3071 }
3072 return -EINVAL;
3073}
3074DRIVER_ATTR(max_queue, S_IRUGO | S_IWUSR, sdebug_max_queue_show,
3075 sdebug_max_queue_store);
3076
3077static ssize_t sdebug_no_uld_show(struct device_driver * ddp, char * buf)
3078{
3079 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_uld);
3080}
3081DRIVER_ATTR(no_uld, S_IRUGO, sdebug_no_uld_show, NULL);
3082
3083static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf)
3084{
3085 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
3086}
3087DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL);
3088
3089static ssize_t sdebug_virtual_gb_show(struct device_driver * ddp, char * buf)
3090{
3091 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
3092}
3093static ssize_t sdebug_virtual_gb_store(struct device_driver * ddp,
3094 const char * buf, size_t count)
3095{
3096 int n;
3097
3098 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
3099 scsi_debug_virtual_gb = n;
3100
3101 sdebug_capacity = get_sdebug_capacity();
3102
3103 return count;
3104 }
3105 return -EINVAL;
3106}
3107DRIVER_ATTR(virtual_gb, S_IRUGO | S_IWUSR, sdebug_virtual_gb_show,
3108 sdebug_virtual_gb_store);
3109
3110static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf)
3111{
3112 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
3113}
3114
3115static ssize_t sdebug_add_host_store(struct device_driver * ddp,
3116 const char * buf, size_t count)
3117{
3118 int delta_hosts;
3119
3120 if (sscanf(buf, "%d", &delta_hosts) != 1)
3121 return -EINVAL;
3122 if (delta_hosts > 0) {
3123 do {
3124 sdebug_add_adapter();
3125 } while (--delta_hosts);
3126 } else if (delta_hosts < 0) {
3127 do {
3128 sdebug_remove_adapter();
3129 } while (++delta_hosts);
3130 }
3131 return count;
3132}
3133DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show,
3134 sdebug_add_host_store);
3135
3136static ssize_t sdebug_vpd_use_hostno_show(struct device_driver * ddp,
3137 char * buf)
3138{
3139 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
3140}
3141static ssize_t sdebug_vpd_use_hostno_store(struct device_driver * ddp,
3142 const char * buf, size_t count)
3143{
3144 int n;
3145
3146 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
3147 scsi_debug_vpd_use_hostno = n;
3148 return count;
3149 }
3150 return -EINVAL;
3151}
3152DRIVER_ATTR(vpd_use_hostno, S_IRUGO | S_IWUSR, sdebug_vpd_use_hostno_show,
3153 sdebug_vpd_use_hostno_store);
3154
3155static ssize_t sdebug_sector_size_show(struct device_driver * ddp, char * buf)
3156{
3157 return scnprintf(buf, PAGE_SIZE, "%u\n", scsi_debug_sector_size);
3158}
3159DRIVER_ATTR(sector_size, S_IRUGO, sdebug_sector_size_show, NULL);
3160
3161static ssize_t sdebug_dix_show(struct device_driver *ddp, char *buf)
3162{
3163 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dix);
3164}
3165DRIVER_ATTR(dix, S_IRUGO, sdebug_dix_show, NULL);
3166
3167static ssize_t sdebug_dif_show(struct device_driver *ddp, char *buf)
3168{
3169 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dif);
3170}
3171DRIVER_ATTR(dif, S_IRUGO, sdebug_dif_show, NULL);
3172
3173static ssize_t sdebug_guard_show(struct device_driver *ddp, char *buf)
3174{
3175 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_guard);
3176}
3177DRIVER_ATTR(guard, S_IRUGO, sdebug_guard_show, NULL);
3178
3179static ssize_t sdebug_ato_show(struct device_driver *ddp, char *buf)
3180{
3181 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ato);
3182}
3183DRIVER_ATTR(ato, S_IRUGO, sdebug_ato_show, NULL);
3184
3185static ssize_t sdebug_map_show(struct device_driver *ddp, char *buf)
3186{
3187 ssize_t count;
3188
3189 if (!scsi_debug_lbp())
3190 return scnprintf(buf, PAGE_SIZE, "0-%u\n",
3191 sdebug_store_sectors);
3192
3193 count = bitmap_scnlistprintf(buf, PAGE_SIZE, map_storep, map_size);
3194
3195 buf[count++] = '\n';
3196 buf[count++] = 0;
3197
3198 return count;
3199}
3200DRIVER_ATTR(map, S_IRUGO, sdebug_map_show, NULL);
3201
3202static ssize_t sdebug_removable_show(struct device_driver *ddp,
3203 char *buf)
3204{
3205 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_removable ? 1 : 0);
3206}
3207static ssize_t sdebug_removable_store(struct device_driver *ddp,
3208 const char *buf, size_t count)
3209{
3210 int n;
3211
3212 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
3213 scsi_debug_removable = (n > 0);
3214 return count;
3215 }
3216 return -EINVAL;
3217}
3218DRIVER_ATTR(removable, S_IRUGO | S_IWUSR, sdebug_removable_show,
3219 sdebug_removable_store);
3220
3221
3222
3223
3224
3225
3226
3227
3228static int do_create_driverfs_files(void)
3229{
3230 int ret;
3231
3232 ret = driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host);
3233 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay);
3234 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
3235 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dsense);
3236 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
3237 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
3238 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
3239 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_queue);
3240 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
3241 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_uld);
3242 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
3243 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
3244 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype);
3245 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts);
3246 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_removable);
3247 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
3248 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
3249 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
3250 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_sector_size);
3251 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dix);
3252 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dif);
3253 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_guard);
3254 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ato);
3255 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_map);
3256 return ret;
3257}
3258
3259static void do_remove_driverfs_files(void)
3260{
3261 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_map);
3262 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ato);
3263 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_guard);
3264 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dif);
3265 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dix);
3266 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_sector_size);
3267 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
3268 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
3269 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
3270 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts);
3271 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype);
3272 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_removable);
3273 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
3274 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
3275 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_uld);
3276 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
3277 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_queue);
3278 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
3279 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
3280 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
3281 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dsense);
3282 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
3283 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay);
3284 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host);
3285}
3286
3287struct device *pseudo_primary;
3288
3289static int __init scsi_debug_init(void)
3290{
3291 unsigned long sz;
3292 int host_to_add;
3293 int k;
3294 int ret;
3295
3296 switch (scsi_debug_sector_size) {
3297 case 512:
3298 case 1024:
3299 case 2048:
3300 case 4096:
3301 break;
3302 default:
3303 printk(KERN_ERR "scsi_debug_init: invalid sector_size %d\n",
3304 scsi_debug_sector_size);
3305 return -EINVAL;
3306 }
3307
3308 switch (scsi_debug_dif) {
3309
3310 case SD_DIF_TYPE0_PROTECTION:
3311 case SD_DIF_TYPE1_PROTECTION:
3312 case SD_DIF_TYPE2_PROTECTION:
3313 case SD_DIF_TYPE3_PROTECTION:
3314 break;
3315
3316 default:
3317 printk(KERN_ERR "scsi_debug_init: dif must be 0, 1, 2 or 3\n");
3318 return -EINVAL;
3319 }
3320
3321 if (scsi_debug_guard > 1) {
3322 printk(KERN_ERR "scsi_debug_init: guard must be 0 or 1\n");
3323 return -EINVAL;
3324 }
3325
3326 if (scsi_debug_ato > 1) {
3327 printk(KERN_ERR "scsi_debug_init: ato must be 0 or 1\n");
3328 return -EINVAL;
3329 }
3330
3331 if (scsi_debug_physblk_exp > 15) {
3332 printk(KERN_ERR "scsi_debug_init: invalid physblk_exp %u\n",
3333 scsi_debug_physblk_exp);
3334 return -EINVAL;
3335 }
3336
3337 if (scsi_debug_lowest_aligned > 0x3fff) {
3338 printk(KERN_ERR "scsi_debug_init: lowest_aligned too big: %u\n",
3339 scsi_debug_lowest_aligned);
3340 return -EINVAL;
3341 }
3342
3343 if (scsi_debug_dev_size_mb < 1)
3344 scsi_debug_dev_size_mb = 1;
3345 sz = (unsigned long)scsi_debug_dev_size_mb * 1048576;
3346 sdebug_store_sectors = sz / scsi_debug_sector_size;
3347 sdebug_capacity = get_sdebug_capacity();
3348
3349
3350 sdebug_heads = 8;
3351 sdebug_sectors_per = 32;
3352 if (scsi_debug_dev_size_mb >= 16)
3353 sdebug_heads = 32;
3354 else if (scsi_debug_dev_size_mb >= 256)
3355 sdebug_heads = 64;
3356 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
3357 (sdebug_sectors_per * sdebug_heads);
3358 if (sdebug_cylinders_per >= 1024) {
3359
3360 sdebug_heads = 255;
3361 sdebug_sectors_per = 63;
3362 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
3363 (sdebug_sectors_per * sdebug_heads);
3364 }
3365
3366 fake_storep = vmalloc(sz);
3367 if (NULL == fake_storep) {
3368 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
3369 return -ENOMEM;
3370 }
3371 memset(fake_storep, 0, sz);
3372 if (scsi_debug_num_parts > 0)
3373 sdebug_build_parts(fake_storep, sz);
3374
3375 if (scsi_debug_dix) {
3376 int dif_size;
3377
3378 dif_size = sdebug_store_sectors * sizeof(struct sd_dif_tuple);
3379 dif_storep = vmalloc(dif_size);
3380
3381 printk(KERN_ERR "scsi_debug_init: dif_storep %u bytes @ %p\n",
3382 dif_size, dif_storep);
3383
3384 if (dif_storep == NULL) {
3385 printk(KERN_ERR "scsi_debug_init: out of mem. (DIX)\n");
3386 ret = -ENOMEM;
3387 goto free_vm;
3388 }
3389
3390 memset(dif_storep, 0xff, dif_size);
3391 }
3392
3393
3394 if (scsi_debug_lbp()) {
3395 scsi_debug_unmap_max_blocks =
3396 clamp(scsi_debug_unmap_max_blocks, 0U, 0xffffffffU);
3397
3398 scsi_debug_unmap_max_desc =
3399 clamp(scsi_debug_unmap_max_desc, 0U, 256U);
3400
3401 scsi_debug_unmap_granularity =
3402 clamp(scsi_debug_unmap_granularity, 1U, 0xffffffffU);
3403
3404 if (scsi_debug_unmap_alignment &&
3405 scsi_debug_unmap_granularity <=
3406 scsi_debug_unmap_alignment) {
3407 printk(KERN_ERR
3408 "%s: ERR: unmap_granularity <= unmap_alignment\n",
3409 __func__);
3410 return -EINVAL;
3411 }
3412
3413 map_size = lba_to_map_index(sdebug_store_sectors - 1) + 1;
3414 map_storep = vmalloc(BITS_TO_LONGS(map_size) * sizeof(long));
3415
3416 printk(KERN_INFO "scsi_debug_init: %lu provisioning blocks\n",
3417 map_size);
3418
3419 if (map_storep == NULL) {
3420 printk(KERN_ERR "scsi_debug_init: out of mem. (MAP)\n");
3421 ret = -ENOMEM;
3422 goto free_vm;
3423 }
3424
3425 bitmap_zero(map_storep, map_size);
3426
3427
3428 if (scsi_debug_num_parts)
3429 map_region(0, 2);
3430 }
3431
3432 pseudo_primary = root_device_register("pseudo_0");
3433 if (IS_ERR(pseudo_primary)) {
3434 printk(KERN_WARNING "scsi_debug: root_device_register() error\n");
3435 ret = PTR_ERR(pseudo_primary);
3436 goto free_vm;
3437 }
3438 ret = bus_register(&pseudo_lld_bus);
3439 if (ret < 0) {
3440 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
3441 ret);
3442 goto dev_unreg;
3443 }
3444 ret = driver_register(&sdebug_driverfs_driver);
3445 if (ret < 0) {
3446 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
3447 ret);
3448 goto bus_unreg;
3449 }
3450 ret = do_create_driverfs_files();
3451 if (ret < 0) {
3452 printk(KERN_WARNING "scsi_debug: driver_create_file error: %d\n",
3453 ret);
3454 goto del_files;
3455 }
3456
3457 init_all_queued();
3458
3459 host_to_add = scsi_debug_add_host;
3460 scsi_debug_add_host = 0;
3461
3462 for (k = 0; k < host_to_add; k++) {
3463 if (sdebug_add_adapter()) {
3464 printk(KERN_ERR "scsi_debug_init: "
3465 "sdebug_add_adapter failed k=%d\n", k);
3466 break;
3467 }
3468 }
3469
3470 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
3471 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
3472 scsi_debug_add_host);
3473 }
3474 return 0;
3475
3476del_files:
3477 do_remove_driverfs_files();
3478 driver_unregister(&sdebug_driverfs_driver);
3479bus_unreg:
3480 bus_unregister(&pseudo_lld_bus);
3481dev_unreg:
3482 root_device_unregister(pseudo_primary);
3483free_vm:
3484 if (map_storep)
3485 vfree(map_storep);
3486 if (dif_storep)
3487 vfree(dif_storep);
3488 vfree(fake_storep);
3489
3490 return ret;
3491}
3492
3493static void __exit scsi_debug_exit(void)
3494{
3495 int k = scsi_debug_add_host;
3496
3497 stop_all_queued();
3498 for (; k; k--)
3499 sdebug_remove_adapter();
3500 do_remove_driverfs_files();
3501 driver_unregister(&sdebug_driverfs_driver);
3502 bus_unregister(&pseudo_lld_bus);
3503 root_device_unregister(pseudo_primary);
3504
3505 if (dif_storep)
3506 vfree(dif_storep);
3507
3508 vfree(fake_storep);
3509}
3510
3511device_initcall(scsi_debug_init);
3512module_exit(scsi_debug_exit);
3513
3514static void sdebug_release_adapter(struct device * dev)
3515{
3516 struct sdebug_host_info *sdbg_host;
3517
3518 sdbg_host = to_sdebug_host(dev);
3519 kfree(sdbg_host);
3520}
3521
3522static int sdebug_add_adapter(void)
3523{
3524 int k, devs_per_host;
3525 int error = 0;
3526 struct sdebug_host_info *sdbg_host;
3527 struct sdebug_dev_info *sdbg_devinfo, *tmp;
3528
3529 sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
3530 if (NULL == sdbg_host) {
3531 printk(KERN_ERR "%s: out of memory at line %d\n",
3532 __func__, __LINE__);
3533 return -ENOMEM;
3534 }
3535
3536 INIT_LIST_HEAD(&sdbg_host->dev_info_list);
3537
3538 devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
3539 for (k = 0; k < devs_per_host; k++) {
3540 sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL);
3541 if (!sdbg_devinfo) {
3542 printk(KERN_ERR "%s: out of memory at line %d\n",
3543 __func__, __LINE__);
3544 error = -ENOMEM;
3545 goto clean;
3546 }
3547 }
3548
3549 spin_lock(&sdebug_host_list_lock);
3550 list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
3551 spin_unlock(&sdebug_host_list_lock);
3552
3553 sdbg_host->dev.bus = &pseudo_lld_bus;
3554 sdbg_host->dev.parent = pseudo_primary;
3555 sdbg_host->dev.release = &sdebug_release_adapter;
3556 dev_set_name(&sdbg_host->dev, "adapter%d", scsi_debug_add_host);
3557
3558 error = device_register(&sdbg_host->dev);
3559
3560 if (error)
3561 goto clean;
3562
3563 ++scsi_debug_add_host;
3564 return error;
3565
3566clean:
3567 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
3568 dev_list) {
3569 list_del(&sdbg_devinfo->dev_list);
3570 kfree(sdbg_devinfo);
3571 }
3572
3573 kfree(sdbg_host);
3574 return error;
3575}
3576
3577static void sdebug_remove_adapter(void)
3578{
3579 struct sdebug_host_info * sdbg_host = NULL;
3580
3581 spin_lock(&sdebug_host_list_lock);
3582 if (!list_empty(&sdebug_host_list)) {
3583 sdbg_host = list_entry(sdebug_host_list.prev,
3584 struct sdebug_host_info, host_list);
3585 list_del(&sdbg_host->host_list);
3586 }
3587 spin_unlock(&sdebug_host_list_lock);
3588
3589 if (!sdbg_host)
3590 return;
3591
3592 device_unregister(&sdbg_host->dev);
3593 --scsi_debug_add_host;
3594}
3595
3596static
3597int scsi_debug_queuecommand_lck(struct scsi_cmnd *SCpnt, done_funct_t done)
3598{
3599 unsigned char *cmd = (unsigned char *) SCpnt->cmnd;
3600 int len, k;
3601 unsigned int num;
3602 unsigned long long lba;
3603 u32 ei_lba;
3604 int errsts = 0;
3605 int target = SCpnt->device->id;
3606 struct sdebug_dev_info *devip = NULL;
3607 int inj_recovered = 0;
3608 int inj_transport = 0;
3609 int inj_dif = 0;
3610 int inj_dix = 0;
3611 int delay_override = 0;
3612 int unmap = 0;
3613
3614 scsi_set_resid(SCpnt, 0);
3615 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) {
3616 printk(KERN_INFO "scsi_debug: cmd ");
3617 for (k = 0, len = SCpnt->cmd_len; k < len; ++k)
3618 printk("%02x ", (int)cmd[k]);
3619 printk("\n");
3620 }
3621
3622 if (target == SCpnt->device->host->hostt->this_id) {
3623 printk(KERN_INFO "scsi_debug: initiator's id used as "
3624 "target!\n");
3625 return schedule_resp(SCpnt, NULL, done,
3626 DID_NO_CONNECT << 16, 0);
3627 }
3628
3629 if ((SCpnt->device->lun >= scsi_debug_max_luns) &&
3630 (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS))
3631 return schedule_resp(SCpnt, NULL, done,
3632 DID_NO_CONNECT << 16, 0);
3633 devip = devInfoReg(SCpnt->device);
3634 if (NULL == devip)
3635 return schedule_resp(SCpnt, NULL, done,
3636 DID_NO_CONNECT << 16, 0);
3637
3638 if ((scsi_debug_every_nth != 0) &&
3639 (++scsi_debug_cmnd_count >= abs(scsi_debug_every_nth))) {
3640 scsi_debug_cmnd_count = 0;
3641 if (scsi_debug_every_nth < -1)
3642 scsi_debug_every_nth = -1;
3643 if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
3644 return 0;
3645 else if (SCSI_DEBUG_OPT_MAC_TIMEOUT & scsi_debug_opts &&
3646 scsi_medium_access_command(SCpnt))
3647 return 0;
3648 else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
3649 inj_recovered = 1;
3650 else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts)
3651 inj_transport = 1;
3652 else if (SCSI_DEBUG_OPT_DIF_ERR & scsi_debug_opts)
3653 inj_dif = 1;
3654 else if (SCSI_DEBUG_OPT_DIX_ERR & scsi_debug_opts)
3655 inj_dix = 1;
3656 }
3657
3658 if (devip->wlun) {
3659 switch (*cmd) {
3660 case INQUIRY:
3661 case REQUEST_SENSE:
3662 case TEST_UNIT_READY:
3663 case REPORT_LUNS:
3664 break;
3665 default:
3666 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
3667 printk(KERN_INFO "scsi_debug: Opcode: 0x%x "
3668 "not supported for wlun\n", *cmd);
3669 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3670 INVALID_OPCODE, 0);
3671 errsts = check_condition_result;
3672 return schedule_resp(SCpnt, devip, done, errsts,
3673 0);
3674 }
3675 }
3676
3677 switch (*cmd) {
3678 case INQUIRY:
3679 delay_override = 1;
3680 errsts = resp_inquiry(SCpnt, target, devip);
3681 break;
3682 case REQUEST_SENSE:
3683 delay_override = 1;
3684 errsts = resp_requests(SCpnt, devip);
3685 break;
3686 case REZERO_UNIT:
3687 case START_STOP:
3688 errsts = resp_start_stop(SCpnt, devip);
3689 break;
3690 case ALLOW_MEDIUM_REMOVAL:
3691 errsts = check_readiness(SCpnt, 1, devip);
3692 if (errsts)
3693 break;
3694 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
3695 printk(KERN_INFO "scsi_debug: Medium removal %s\n",
3696 cmd[4] ? "inhibited" : "enabled");
3697 break;
3698 case SEND_DIAGNOSTIC:
3699 errsts = check_readiness(SCpnt, 1, devip);
3700 break;
3701 case TEST_UNIT_READY:
3702 delay_override = 1;
3703 errsts = check_readiness(SCpnt, 0, devip);
3704 break;
3705 case RESERVE:
3706 errsts = check_readiness(SCpnt, 1, devip);
3707 break;
3708 case RESERVE_10:
3709 errsts = check_readiness(SCpnt, 1, devip);
3710 break;
3711 case RELEASE:
3712 errsts = check_readiness(SCpnt, 1, devip);
3713 break;
3714 case RELEASE_10:
3715 errsts = check_readiness(SCpnt, 1, devip);
3716 break;
3717 case READ_CAPACITY:
3718 errsts = resp_readcap(SCpnt, devip);
3719 break;
3720 case SERVICE_ACTION_IN:
3721 if (cmd[1] == SAI_READ_CAPACITY_16)
3722 errsts = resp_readcap16(SCpnt, devip);
3723 else if (cmd[1] == SAI_GET_LBA_STATUS) {
3724
3725 if (scsi_debug_lbp() == 0) {
3726 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3727 INVALID_COMMAND_OPCODE, 0);
3728 errsts = check_condition_result;
3729 } else
3730 errsts = resp_get_lba_status(SCpnt, devip);
3731 } else {
3732 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3733 INVALID_OPCODE, 0);
3734 errsts = check_condition_result;
3735 }
3736 break;
3737 case MAINTENANCE_IN:
3738 if (MI_REPORT_TARGET_PGS != cmd[1]) {
3739 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3740 INVALID_OPCODE, 0);
3741 errsts = check_condition_result;
3742 break;
3743 }
3744 errsts = resp_report_tgtpgs(SCpnt, devip);
3745 break;
3746 case READ_16:
3747 case READ_12:
3748 case READ_10:
3749
3750 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
3751 cmd[1] & 0xe0) {
3752 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3753 INVALID_COMMAND_OPCODE, 0);
3754 errsts = check_condition_result;
3755 break;
3756 }
3757
3758 if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
3759 scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
3760 (cmd[1] & 0xe0) == 0)
3761 printk(KERN_ERR "Unprotected RD/WR to DIF device\n");
3762
3763
3764 case READ_6:
3765read:
3766 errsts = check_readiness(SCpnt, 0, devip);
3767 if (errsts)
3768 break;
3769 if (scsi_debug_fake_rw)
3770 break;
3771 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3772 errsts = resp_read(SCpnt, lba, num, devip, ei_lba);
3773 if (inj_recovered && (0 == errsts)) {
3774 mk_sense_buffer(devip, RECOVERED_ERROR,
3775 THRESHOLD_EXCEEDED, 0);
3776 errsts = check_condition_result;
3777 } else if (inj_transport && (0 == errsts)) {
3778 mk_sense_buffer(devip, ABORTED_COMMAND,
3779 TRANSPORT_PROBLEM, ACK_NAK_TO);
3780 errsts = check_condition_result;
3781 } else if (inj_dif && (0 == errsts)) {
3782 mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, 1);
3783 errsts = illegal_condition_result;
3784 } else if (inj_dix && (0 == errsts)) {
3785 mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, 1);
3786 errsts = illegal_condition_result;
3787 }
3788 break;
3789 case REPORT_LUNS:
3790 delay_override = 1;
3791 errsts = resp_report_luns(SCpnt, devip);
3792 break;
3793 case VERIFY:
3794 errsts = check_readiness(SCpnt, 0, devip);
3795 break;
3796 case WRITE_16:
3797 case WRITE_12:
3798 case WRITE_10:
3799
3800 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
3801 cmd[1] & 0xe0) {
3802 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3803 INVALID_COMMAND_OPCODE, 0);
3804 errsts = check_condition_result;
3805 break;
3806 }
3807
3808 if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
3809 scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
3810 (cmd[1] & 0xe0) == 0)
3811 printk(KERN_ERR "Unprotected RD/WR to DIF device\n");
3812
3813
3814 case WRITE_6:
3815write:
3816 errsts = check_readiness(SCpnt, 0, devip);
3817 if (errsts)
3818 break;
3819 if (scsi_debug_fake_rw)
3820 break;
3821 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3822 errsts = resp_write(SCpnt, lba, num, devip, ei_lba);
3823 if (inj_recovered && (0 == errsts)) {
3824 mk_sense_buffer(devip, RECOVERED_ERROR,
3825 THRESHOLD_EXCEEDED, 0);
3826 errsts = check_condition_result;
3827 } else if (inj_dif && (0 == errsts)) {
3828 mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, 1);
3829 errsts = illegal_condition_result;
3830 } else if (inj_dix && (0 == errsts)) {
3831 mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, 1);
3832 errsts = illegal_condition_result;
3833 }
3834 break;
3835 case WRITE_SAME_16:
3836 case WRITE_SAME:
3837 if (cmd[1] & 0x8) {
3838 if ((*cmd == WRITE_SAME_16 && scsi_debug_lbpws == 0) ||
3839 (*cmd == WRITE_SAME && scsi_debug_lbpws10 == 0)) {
3840 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3841 INVALID_FIELD_IN_CDB, 0);
3842 errsts = check_condition_result;
3843 } else
3844 unmap = 1;
3845 }
3846 if (errsts)
3847 break;
3848 errsts = check_readiness(SCpnt, 0, devip);
3849 if (errsts)
3850 break;
3851 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3852 errsts = resp_write_same(SCpnt, lba, num, devip, ei_lba, unmap);
3853 break;
3854 case UNMAP:
3855 errsts = check_readiness(SCpnt, 0, devip);
3856 if (errsts)
3857 break;
3858
3859 if (scsi_debug_unmap_max_desc == 0 || scsi_debug_lbpu == 0) {
3860 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3861 INVALID_COMMAND_OPCODE, 0);
3862 errsts = check_condition_result;
3863 } else
3864 errsts = resp_unmap(SCpnt, devip);
3865 break;
3866 case MODE_SENSE:
3867 case MODE_SENSE_10:
3868 errsts = resp_mode_sense(SCpnt, target, devip);
3869 break;
3870 case MODE_SELECT:
3871 errsts = resp_mode_select(SCpnt, 1, devip);
3872 break;
3873 case MODE_SELECT_10:
3874 errsts = resp_mode_select(SCpnt, 0, devip);
3875 break;
3876 case LOG_SENSE:
3877 errsts = resp_log_sense(SCpnt, devip);
3878 break;
3879 case SYNCHRONIZE_CACHE:
3880 delay_override = 1;
3881 errsts = check_readiness(SCpnt, 0, devip);
3882 break;
3883 case WRITE_BUFFER:
3884 errsts = check_readiness(SCpnt, 1, devip);
3885 break;
3886 case XDWRITEREAD_10:
3887 if (!scsi_bidi_cmnd(SCpnt)) {
3888 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3889 INVALID_FIELD_IN_CDB, 0);
3890 errsts = check_condition_result;
3891 break;
3892 }
3893
3894 errsts = check_readiness(SCpnt, 0, devip);
3895 if (errsts)
3896 break;
3897 if (scsi_debug_fake_rw)
3898 break;
3899 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3900 errsts = resp_read(SCpnt, lba, num, devip, ei_lba);
3901 if (errsts)
3902 break;
3903 errsts = resp_write(SCpnt, lba, num, devip, ei_lba);
3904 if (errsts)
3905 break;
3906 errsts = resp_xdwriteread(SCpnt, lba, num, devip);
3907 break;
3908 case VARIABLE_LENGTH_CMD:
3909 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION) {
3910
3911 if ((cmd[10] & 0xe0) == 0)
3912 printk(KERN_ERR
3913 "Unprotected RD/WR to DIF device\n");
3914
3915 if (cmd[9] == READ_32) {
3916 BUG_ON(SCpnt->cmd_len < 32);
3917 goto read;
3918 }
3919
3920 if (cmd[9] == WRITE_32) {
3921 BUG_ON(SCpnt->cmd_len < 32);
3922 goto write;
3923 }
3924 }
3925
3926 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3927 INVALID_FIELD_IN_CDB, 0);
3928 errsts = check_condition_result;
3929 break;
3930
3931 default:
3932 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
3933 printk(KERN_INFO "scsi_debug: Opcode: 0x%x not "
3934 "supported\n", *cmd);
3935 errsts = check_readiness(SCpnt, 1, devip);
3936 if (errsts)
3937 break;
3938 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
3939 errsts = check_condition_result;
3940 break;
3941 }
3942 return schedule_resp(SCpnt, devip, done, errsts,
3943 (delay_override ? 0 : scsi_debug_delay));
3944}
3945
3946static DEF_SCSI_QCMD(scsi_debug_queuecommand)
3947
3948static struct scsi_host_template sdebug_driver_template = {
3949 .show_info = scsi_debug_show_info,
3950 .write_info = scsi_debug_write_info,
3951 .proc_name = sdebug_proc_name,
3952 .name = "SCSI DEBUG",
3953 .info = scsi_debug_info,
3954 .slave_alloc = scsi_debug_slave_alloc,
3955 .slave_configure = scsi_debug_slave_configure,
3956 .slave_destroy = scsi_debug_slave_destroy,
3957 .ioctl = scsi_debug_ioctl,
3958 .queuecommand = scsi_debug_queuecommand,
3959 .eh_abort_handler = scsi_debug_abort,
3960 .eh_bus_reset_handler = scsi_debug_bus_reset,
3961 .eh_device_reset_handler = scsi_debug_device_reset,
3962 .eh_host_reset_handler = scsi_debug_host_reset,
3963 .bios_param = scsi_debug_biosparam,
3964 .can_queue = SCSI_DEBUG_CANQUEUE,
3965 .this_id = 7,
3966 .sg_tablesize = 256,
3967 .cmd_per_lun = 16,
3968 .max_sectors = 0xffff,
3969 .use_clustering = DISABLE_CLUSTERING,
3970 .module = THIS_MODULE,
3971};
3972
3973static int sdebug_driver_probe(struct device * dev)
3974{
3975 int error = 0;
3976 struct sdebug_host_info *sdbg_host;
3977 struct Scsi_Host *hpnt;
3978 int host_prot;
3979
3980 sdbg_host = to_sdebug_host(dev);
3981
3982 sdebug_driver_template.can_queue = scsi_debug_max_queue;
3983 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
3984 if (NULL == hpnt) {
3985 printk(KERN_ERR "%s: scsi_register failed\n", __func__);
3986 error = -ENODEV;
3987 return error;
3988 }
3989
3990 sdbg_host->shost = hpnt;
3991 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
3992 if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
3993 hpnt->max_id = scsi_debug_num_tgts + 1;
3994 else
3995 hpnt->max_id = scsi_debug_num_tgts;
3996 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS;
3997
3998 host_prot = 0;
3999
4000 switch (scsi_debug_dif) {
4001
4002 case SD_DIF_TYPE1_PROTECTION:
4003 host_prot = SHOST_DIF_TYPE1_PROTECTION;
4004 if (scsi_debug_dix)
4005 host_prot |= SHOST_DIX_TYPE1_PROTECTION;
4006 break;
4007
4008 case SD_DIF_TYPE2_PROTECTION:
4009 host_prot = SHOST_DIF_TYPE2_PROTECTION;
4010 if (scsi_debug_dix)
4011 host_prot |= SHOST_DIX_TYPE2_PROTECTION;
4012 break;
4013
4014 case SD_DIF_TYPE3_PROTECTION:
4015 host_prot = SHOST_DIF_TYPE3_PROTECTION;
4016 if (scsi_debug_dix)
4017 host_prot |= SHOST_DIX_TYPE3_PROTECTION;
4018 break;
4019
4020 default:
4021 if (scsi_debug_dix)
4022 host_prot |= SHOST_DIX_TYPE0_PROTECTION;
4023 break;
4024 }
4025
4026 scsi_host_set_prot(hpnt, host_prot);
4027
4028 printk(KERN_INFO "scsi_debug: host protection%s%s%s%s%s%s%s\n",
4029 (host_prot & SHOST_DIF_TYPE1_PROTECTION) ? " DIF1" : "",
4030 (host_prot & SHOST_DIF_TYPE2_PROTECTION) ? " DIF2" : "",
4031 (host_prot & SHOST_DIF_TYPE3_PROTECTION) ? " DIF3" : "",
4032 (host_prot & SHOST_DIX_TYPE0_PROTECTION) ? " DIX0" : "",
4033 (host_prot & SHOST_DIX_TYPE1_PROTECTION) ? " DIX1" : "",
4034 (host_prot & SHOST_DIX_TYPE2_PROTECTION) ? " DIX2" : "",
4035 (host_prot & SHOST_DIX_TYPE3_PROTECTION) ? " DIX3" : "");
4036
4037 if (scsi_debug_guard == 1)
4038 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_IP);
4039 else
4040 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_CRC);
4041
4042 error = scsi_add_host(hpnt, &sdbg_host->dev);
4043 if (error) {
4044 printk(KERN_ERR "%s: scsi_add_host failed\n", __func__);
4045 error = -ENODEV;
4046 scsi_host_put(hpnt);
4047 } else
4048 scsi_scan_host(hpnt);
4049
4050
4051 return error;
4052}
4053
4054static int sdebug_driver_remove(struct device * dev)
4055{
4056 struct sdebug_host_info *sdbg_host;
4057 struct sdebug_dev_info *sdbg_devinfo, *tmp;
4058
4059 sdbg_host = to_sdebug_host(dev);
4060
4061 if (!sdbg_host) {
4062 printk(KERN_ERR "%s: Unable to locate host info\n",
4063 __func__);
4064 return -ENODEV;
4065 }
4066
4067 scsi_remove_host(sdbg_host->shost);
4068
4069 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
4070 dev_list) {
4071 list_del(&sdbg_devinfo->dev_list);
4072 kfree(sdbg_devinfo);
4073 }
4074
4075 scsi_host_put(sdbg_host->shost);
4076 return 0;
4077}
4078
4079static int pseudo_lld_bus_match(struct device *dev,
4080 struct device_driver *dev_driver)
4081{
4082 return 1;
4083}
4084
4085static struct bus_type pseudo_lld_bus = {
4086 .name = "pseudo",
4087 .match = pseudo_lld_bus_match,
4088 .probe = sdebug_driver_probe,
4089 .remove = sdebug_driver_remove,
4090};
4091