2 * vvvvvvvvvvvvvvvvvvvvvvv Original vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
3 * Copyright (C) 1992 Eric Youngdale
4 * Simulate a host adapter with 2 disks attached. Do a lot of checking
5 * to make sure that we are not getting blocks mixed up, and PANIC if
6 * anything out of the ordinary is seen.
7 * ^^^^^^^^^^^^^^^^^^^^^^^ Original ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
9 * This version is more generic, simulating a variable number of disk
10 * (or disk like devices) sharing a common amount of RAM. To be more
11 * realistic, the simulated devices have the transport attributes of
15 * For documentation see http://www.torque.net/sg/sdebug26.html
17 * D. Gilbert (dpg) work for Magneto-Optical device test [20010421]
18 * dpg: work for devfs large number of disks [20010809]
19 * forked for lk 2.5 series [20011216, 20020101]
20 * use vmalloc() more inquiry+mode_sense [20020302]
21 * add timers for delayed responses [20020721]
22 * Patrick Mansfield <patmans@us.ibm.com> max_luns+scsi_level [20021031]
23 * Mike Anderson <andmike@us.ibm.com> sysfs work [20021118]
24 * dpg: change style of boot options to "scsi_debug.num_tgts=2" and
25 * module options to "modprobe scsi_debug num_tgts=2" [20021221]
28 #include <linux/module.h>
30 #include <linux/kernel.h>
31 #include <linux/errno.h>
32 #include <linux/timer.h>
33 #include <linux/types.h>
34 #include <linux/string.h>
35 #include <linux/genhd.h>
37 #include <linux/init.h>
38 #include <linux/proc_fs.h>
39 #include <linux/vmalloc.h>
40 #include <linux/moduleparam.h>
41 #include <linux/scatterlist.h>
42 #include <linux/blkdev.h>
44 #include <scsi/scsi.h>
45 #include <scsi/scsi_cmnd.h>
46 #include <scsi/scsi_device.h>
47 #include <scsi/scsi_host.h>
48 #include <scsi/scsicam.h>
49 #include <scsi/scsi_eh.h>
51 #include <linux/stat.h>
53 #include "scsi_logging.h"
55 #define SCSI_DEBUG_VERSION "1.81"
56 static const char * scsi_debug_version_date = "20070104";
58 /* Additional Sense Code (ASC) */
59 #define NO_ADDITIONAL_SENSE 0x0
60 #define LOGICAL_UNIT_NOT_READY 0x4
61 #define UNRECOVERED_READ_ERR 0x11
62 #define PARAMETER_LIST_LENGTH_ERR 0x1a
63 #define INVALID_OPCODE 0x20
64 #define ADDR_OUT_OF_RANGE 0x21
65 #define INVALID_FIELD_IN_CDB 0x24
66 #define INVALID_FIELD_IN_PARAM_LIST 0x26
67 #define POWERON_RESET 0x29
68 #define SAVING_PARAMS_UNSUP 0x39
69 #define TRANSPORT_PROBLEM 0x4b
70 #define THRESHOLD_EXCEEDED 0x5d
71 #define LOW_POWER_COND_ON 0x5e
73 /* Additional Sense Code Qualifier (ASCQ) */
74 #define ACK_NAK_TO 0x3
76 #define SDEBUG_TAGGED_QUEUING 0 /* 0 | MSG_SIMPLE_TAG | MSG_ORDERED_TAG */
78 /* Default values for driver parameters */
79 #define DEF_NUM_HOST 1
80 #define DEF_NUM_TGTS 1
81 #define DEF_MAX_LUNS 1
82 /* With these defaults, this driver will make 1 host with 1 target
83 * (id 0) containing 1 logical unit (lun 0). That is 1 device.
86 #define DEF_DEV_SIZE_MB 8
87 #define DEF_EVERY_NTH 0
88 #define DEF_NUM_PARTS 0
90 #define DEF_SCSI_LEVEL 5 /* INQUIRY, byte2 [5->SPC-3] */
93 #define DEF_NO_LUN_0 0
94 #define DEF_VIRTUAL_GB 0
96 #define DEF_VPD_USE_HOSTNO 1
97 #define DEF_SECTOR_SIZE 512
99 /* bit mask values for scsi_debug_opts */
100 #define SCSI_DEBUG_OPT_NOISE 1
101 #define SCSI_DEBUG_OPT_MEDIUM_ERR 2
102 #define SCSI_DEBUG_OPT_TIMEOUT 4
103 #define SCSI_DEBUG_OPT_RECOVERED_ERR 8
104 #define SCSI_DEBUG_OPT_TRANSPORT_ERR 16
105 /* When "every_nth" > 0 then modulo "every_nth" commands:
106 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
107 * - a RECOVERED_ERROR is simulated on successful read and write
108 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
109 * - a TRANSPORT_ERROR is simulated on successful read and write
110 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
112 * When "every_nth" < 0 then after "- every_nth" commands:
113 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
114 * - a RECOVERED_ERROR is simulated on successful read and write
115 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
116 * - a TRANSPORT_ERROR is simulated on successful read and write
117 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
118 * This will continue until some other action occurs (e.g. the user
119 * writing a new value (other than -1 or 1) to every_nth via sysfs).
122 /* when 1==SCSI_DEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
123 * sector on read commands: */
124 #define OPT_MEDIUM_ERR_ADDR 0x1234 /* that's sector 4660 in decimal */
126 /* If REPORT LUNS has luns >= 256 it can choose "flat space" (value 1)
127 * or "peripheral device" addressing (value 0) */
128 #define SAM2_LUN_ADDRESS_METHOD 0
129 #define SAM2_WLUN_REPORT_LUNS 0xc101
131 static int scsi_debug_add_host = DEF_NUM_HOST;
132 static int scsi_debug_delay = DEF_DELAY;
133 static int scsi_debug_dev_size_mb = DEF_DEV_SIZE_MB;
134 static int scsi_debug_every_nth = DEF_EVERY_NTH;
135 static int scsi_debug_max_luns = DEF_MAX_LUNS;
136 static int scsi_debug_num_parts = DEF_NUM_PARTS;
137 static int scsi_debug_num_tgts = DEF_NUM_TGTS; /* targets per host */
138 static int scsi_debug_opts = DEF_OPTS;
139 static int scsi_debug_scsi_level = DEF_SCSI_LEVEL;
140 static int scsi_debug_ptype = DEF_PTYPE; /* SCSI peripheral type (0==disk) */
141 static int scsi_debug_dsense = DEF_D_SENSE;
142 static int scsi_debug_no_lun_0 = DEF_NO_LUN_0;
143 static int scsi_debug_virtual_gb = DEF_VIRTUAL_GB;
144 static int scsi_debug_fake_rw = DEF_FAKE_RW;
145 static int scsi_debug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
146 static int scsi_debug_sector_size = DEF_SECTOR_SIZE;
148 static int scsi_debug_cmnd_count = 0;
150 #define DEV_READONLY(TGT) (0)
151 #define DEV_REMOVEABLE(TGT) (0)
153 static unsigned int sdebug_store_sectors;
154 static sector_t sdebug_capacity; /* in sectors */
156 /* old BIOS stuff, kernel may get rid of them but some mode sense pages
157 may still need them */
158 static int sdebug_heads; /* heads per disk */
159 static int sdebug_cylinders_per; /* cylinders per surface */
160 static int sdebug_sectors_per; /* sectors per cylinder */
162 #define SDEBUG_MAX_PARTS 4
164 #define SDEBUG_SENSE_LEN 32
166 #define SCSI_DEBUG_CANQUEUE 255
167 #define SCSI_DEBUG_MAX_CMD_LEN 16
169 struct sdebug_dev_info {
170 struct list_head dev_list;
171 unsigned char sense_buff[SDEBUG_SENSE_LEN]; /* weak nexus */
172 unsigned int channel;
175 struct sdebug_host_info *sdbg_host;
182 struct sdebug_host_info {
183 struct list_head host_list;
184 struct Scsi_Host *shost;
186 struct list_head dev_info_list;
189 #define to_sdebug_host(d) \
190 container_of(d, struct sdebug_host_info, dev)
192 static LIST_HEAD(sdebug_host_list);
193 static DEFINE_SPINLOCK(sdebug_host_list_lock);
195 typedef void (* done_funct_t) (struct scsi_cmnd *);
197 struct sdebug_queued_cmd {
199 struct timer_list cmnd_timer;
200 done_funct_t done_funct;
201 struct scsi_cmnd * a_cmnd;
204 static struct sdebug_queued_cmd queued_arr[SCSI_DEBUG_CANQUEUE];
206 static unsigned char * fake_storep; /* ramdisk storage */
208 static int num_aborts = 0;
209 static int num_dev_resets = 0;
210 static int num_bus_resets = 0;
211 static int num_host_resets = 0;
213 static DEFINE_SPINLOCK(queued_arr_lock);
214 static DEFINE_RWLOCK(atomic_rw);
216 static char sdebug_proc_name[] = "scsi_debug";
218 static struct bus_type pseudo_lld_bus;
220 static struct device_driver sdebug_driverfs_driver = {
221 .name = sdebug_proc_name,
222 .bus = &pseudo_lld_bus,
225 static const int check_condition_result =
226 (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
228 static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
230 static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
233 static int sdebug_add_adapter(void);
234 static void sdebug_remove_adapter(void);
236 static void sdebug_max_tgts_luns(void)
238 struct sdebug_host_info *sdbg_host;
239 struct Scsi_Host *hpnt;
241 spin_lock(&sdebug_host_list_lock);
242 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
243 hpnt = sdbg_host->shost;
244 if ((hpnt->this_id >= 0) &&
245 (scsi_debug_num_tgts > hpnt->this_id))
246 hpnt->max_id = scsi_debug_num_tgts + 1;
248 hpnt->max_id = scsi_debug_num_tgts;
249 /* scsi_debug_max_luns; */
250 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS;
252 spin_unlock(&sdebug_host_list_lock);
255 static void mk_sense_buffer(struct sdebug_dev_info *devip, int key,
258 unsigned char *sbuff;
260 sbuff = devip->sense_buff;
261 memset(sbuff, 0, SDEBUG_SENSE_LEN);
263 scsi_build_sense_buffer(scsi_debug_dsense, sbuff, key, asc, asq);
265 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
266 printk(KERN_INFO "scsi_debug: [sense_key,asc,ascq]: "
267 "[0x%x,0x%x,0x%x]\n", key, asc, asq);
270 static void get_data_transfer_info(unsigned char *cmd,
271 unsigned long long *lba, unsigned int *num)
276 *lba = (u64)cmd[9] | (u64)cmd[8] << 8 |
277 (u64)cmd[7] << 16 | (u64)cmd[6] << 24 |
278 (u64)cmd[5] << 32 | (u64)cmd[4] << 40 |
279 (u64)cmd[3] << 48 | (u64)cmd[2] << 56;
281 *num = (u32)cmd[13] | (u32)cmd[12] << 8 | (u32)cmd[11] << 16 |
286 *lba = (u32)cmd[5] | (u32)cmd[4] << 8 | (u32)cmd[3] << 16 |
289 *num = (u32)cmd[9] | (u32)cmd[8] << 8 | (u32)cmd[7] << 16 |
295 *lba = (u32)cmd[5] | (u32)cmd[4] << 8 | (u32)cmd[3] << 16 |
298 *num = (u32)cmd[8] | (u32)cmd[7] << 8;
302 *lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
303 (u32)(cmd[1] & 0x1f) << 16;
304 *num = (0 == cmd[4]) ? 256 : cmd[4];
311 static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
313 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
314 printk(KERN_INFO "scsi_debug: ioctl: cmd=0x%x\n", cmd);
317 /* return -ENOTTY; // correct return but upsets fdisk */
320 static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
321 struct sdebug_dev_info * devip)
324 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
325 printk(KERN_INFO "scsi_debug: Reporting Unit "
326 "attention: power on reset\n");
328 mk_sense_buffer(devip, UNIT_ATTENTION, POWERON_RESET, 0);
329 return check_condition_result;
331 if ((0 == reset_only) && devip->stopped) {
332 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
333 printk(KERN_INFO "scsi_debug: Reporting Not "
334 "ready: initializing command required\n");
335 mk_sense_buffer(devip, NOT_READY, LOGICAL_UNIT_NOT_READY,
337 return check_condition_result;
342 /* Returns 0 if ok else (DID_ERROR << 16). Sets scp->resid . */
343 static int fill_from_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
347 struct scsi_data_buffer *sdb = scsi_in(scp);
351 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE))
352 return (DID_ERROR << 16);
354 act_len = sg_copy_from_buffer(sdb->table.sgl, sdb->table.nents,
357 sdb->resid -= act_len;
359 sdb->resid = scsi_bufflen(scp) - act_len;
364 /* Returns number of bytes fetched into 'arr' or -1 if error. */
365 static int fetch_to_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
368 if (!scsi_bufflen(scp))
370 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_TO_DEVICE))
373 return scsi_sg_copy_to_buffer(scp, arr, arr_len);
377 static const char * inq_vendor_id = "Linux ";
378 static const char * inq_product_id = "scsi_debug ";
379 static const char * inq_product_rev = "0004";
381 static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
382 int target_dev_id, int dev_id_num,
383 const char * dev_id_str,
389 port_a = target_dev_id + 1;
390 /* T10 vendor identifier field format (faked) */
391 arr[0] = 0x2; /* ASCII */
394 memcpy(&arr[4], inq_vendor_id, 8);
395 memcpy(&arr[12], inq_product_id, 16);
396 memcpy(&arr[28], dev_id_str, dev_id_str_len);
397 num = 8 + 16 + dev_id_str_len;
400 if (dev_id_num >= 0) {
401 /* NAA-5, Logical unit identifier (binary) */
402 arr[num++] = 0x1; /* binary (not necessarily sas) */
403 arr[num++] = 0x3; /* PIV=0, lu, naa */
406 arr[num++] = 0x53; /* naa-5 ieee company id=0x333333 (fake) */
410 arr[num++] = (dev_id_num >> 24);
411 arr[num++] = (dev_id_num >> 16) & 0xff;
412 arr[num++] = (dev_id_num >> 8) & 0xff;
413 arr[num++] = dev_id_num & 0xff;
414 /* Target relative port number */
415 arr[num++] = 0x61; /* proto=sas, binary */
416 arr[num++] = 0x94; /* PIV=1, target port, rel port */
417 arr[num++] = 0x0; /* reserved */
418 arr[num++] = 0x4; /* length */
419 arr[num++] = 0x0; /* reserved */
420 arr[num++] = 0x0; /* reserved */
422 arr[num++] = 0x1; /* relative port A */
424 /* NAA-5, Target port identifier */
425 arr[num++] = 0x61; /* proto=sas, binary */
426 arr[num++] = 0x93; /* piv=1, target port, naa */
429 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
433 arr[num++] = (port_a >> 24);
434 arr[num++] = (port_a >> 16) & 0xff;
435 arr[num++] = (port_a >> 8) & 0xff;
436 arr[num++] = port_a & 0xff;
437 /* NAA-5, Target port group identifier */
438 arr[num++] = 0x61; /* proto=sas, binary */
439 arr[num++] = 0x95; /* piv=1, target port group id */
444 arr[num++] = (port_group_id >> 8) & 0xff;
445 arr[num++] = port_group_id & 0xff;
446 /* NAA-5, Target device identifier */
447 arr[num++] = 0x61; /* proto=sas, binary */
448 arr[num++] = 0xa3; /* piv=1, target device, naa */
451 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
455 arr[num++] = (target_dev_id >> 24);
456 arr[num++] = (target_dev_id >> 16) & 0xff;
457 arr[num++] = (target_dev_id >> 8) & 0xff;
458 arr[num++] = target_dev_id & 0xff;
459 /* SCSI name string: Target device identifier */
460 arr[num++] = 0x63; /* proto=sas, UTF-8 */
461 arr[num++] = 0xa8; /* piv=1, target device, SCSI name string */
464 memcpy(arr + num, "naa.52222220", 12);
466 snprintf(b, sizeof(b), "%08X", target_dev_id);
467 memcpy(arr + num, b, 8);
469 memset(arr + num, 0, 4);
475 static unsigned char vpd84_data[] = {
476 /* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
477 0x22,0x22,0x22,0x0,0xbb,0x1,
478 0x22,0x22,0x22,0x0,0xbb,0x2,
481 static int inquiry_evpd_84(unsigned char * arr)
483 memcpy(arr, vpd84_data, sizeof(vpd84_data));
484 return sizeof(vpd84_data);
487 static int inquiry_evpd_85(unsigned char * arr)
490 const char * na1 = "https://www.kernel.org/config";
491 const char * na2 = "http://www.kernel.org/log";
494 arr[num++] = 0x1; /* lu, storage config */
495 arr[num++] = 0x0; /* reserved */
500 plen = ((plen / 4) + 1) * 4;
501 arr[num++] = plen; /* length, null termianted, padded */
502 memcpy(arr + num, na1, olen);
503 memset(arr + num + olen, 0, plen - olen);
506 arr[num++] = 0x4; /* lu, logging */
507 arr[num++] = 0x0; /* reserved */
512 plen = ((plen / 4) + 1) * 4;
513 arr[num++] = plen; /* length, null terminated, padded */
514 memcpy(arr + num, na2, olen);
515 memset(arr + num + olen, 0, plen - olen);
521 /* SCSI ports VPD page */
522 static int inquiry_evpd_88(unsigned char * arr, int target_dev_id)
527 port_a = target_dev_id + 1;
529 arr[num++] = 0x0; /* reserved */
530 arr[num++] = 0x0; /* reserved */
532 arr[num++] = 0x1; /* relative port 1 (primary) */
533 memset(arr + num, 0, 6);
536 arr[num++] = 12; /* length tp descriptor */
537 /* naa-5 target port identifier (A) */
538 arr[num++] = 0x61; /* proto=sas, binary */
539 arr[num++] = 0x93; /* PIV=1, target port, NAA */
540 arr[num++] = 0x0; /* reserved */
541 arr[num++] = 0x8; /* length */
542 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
546 arr[num++] = (port_a >> 24);
547 arr[num++] = (port_a >> 16) & 0xff;
548 arr[num++] = (port_a >> 8) & 0xff;
549 arr[num++] = port_a & 0xff;
551 arr[num++] = 0x0; /* reserved */
552 arr[num++] = 0x0; /* reserved */
554 arr[num++] = 0x2; /* relative port 2 (secondary) */
555 memset(arr + num, 0, 6);
558 arr[num++] = 12; /* length tp descriptor */
559 /* naa-5 target port identifier (B) */
560 arr[num++] = 0x61; /* proto=sas, binary */
561 arr[num++] = 0x93; /* PIV=1, target port, NAA */
562 arr[num++] = 0x0; /* reserved */
563 arr[num++] = 0x8; /* length */
564 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
568 arr[num++] = (port_b >> 24);
569 arr[num++] = (port_b >> 16) & 0xff;
570 arr[num++] = (port_b >> 8) & 0xff;
571 arr[num++] = port_b & 0xff;
577 static unsigned char vpd89_data[] = {
578 /* from 4th byte */ 0,0,0,0,
579 'l','i','n','u','x',' ',' ',' ',
580 'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
582 0x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
584 0x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
585 0,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
586 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
587 0x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
589 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
591 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
593 0,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
594 0x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
595 0x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
596 0,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
597 0x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
598 0x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
599 0,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
600 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
601 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
602 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
603 0x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
604 0,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
605 0xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
606 0,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
607 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
608 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
609 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
611 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
612 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
613 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
614 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
615 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
616 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
617 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
618 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
621 static int inquiry_evpd_89(unsigned char * arr)
623 memcpy(arr, vpd89_data, sizeof(vpd89_data));
624 return sizeof(vpd89_data);
628 static unsigned char vpdb0_data[] = {
629 /* from 4th byte */ 0,0,0,4,
634 static int inquiry_evpd_b0(unsigned char * arr)
636 memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
637 if (sdebug_store_sectors > 0x400) {
638 arr[4] = (sdebug_store_sectors >> 24) & 0xff;
639 arr[5] = (sdebug_store_sectors >> 16) & 0xff;
640 arr[6] = (sdebug_store_sectors >> 8) & 0xff;
641 arr[7] = sdebug_store_sectors & 0xff;
643 return sizeof(vpdb0_data);
647 #define SDEBUG_LONG_INQ_SZ 96
648 #define SDEBUG_MAX_INQ_ARR_SZ 584
650 static int resp_inquiry(struct scsi_cmnd * scp, int target,
651 struct sdebug_dev_info * devip)
653 unsigned char pq_pdt;
655 unsigned char *cmd = (unsigned char *)scp->cmnd;
656 int alloc_len, n, ret;
658 alloc_len = (cmd[3] << 8) + cmd[4];
659 arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
661 return DID_REQUEUE << 16;
663 pq_pdt = 0x1e; /* present, wlun */
664 else if (scsi_debug_no_lun_0 && (0 == devip->lun))
665 pq_pdt = 0x7f; /* not present, no device type */
667 pq_pdt = (scsi_debug_ptype & 0x1f);
669 if (0x2 & cmd[1]) { /* CMDDT bit set */
670 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
673 return check_condition_result;
674 } else if (0x1 & cmd[1]) { /* EVPD bit set */
675 int lu_id_num, port_group_id, target_dev_id, len;
677 int host_no = devip->sdbg_host->shost->host_no;
679 port_group_id = (((host_no + 1) & 0x7f) << 8) +
680 (devip->channel & 0x7f);
681 if (0 == scsi_debug_vpd_use_hostno)
683 lu_id_num = devip->wlun ? -1 : (((host_no + 1) * 2000) +
684 (devip->target * 1000) + devip->lun);
685 target_dev_id = ((host_no + 1) * 2000) +
686 (devip->target * 1000) - 3;
687 len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
688 if (0 == cmd[2]) { /* supported vital product data pages */
689 arr[1] = cmd[2]; /*sanity */
691 arr[n++] = 0x0; /* this page */
692 arr[n++] = 0x80; /* unit serial number */
693 arr[n++] = 0x83; /* device identification */
694 arr[n++] = 0x84; /* software interface ident. */
695 arr[n++] = 0x85; /* management network addresses */
696 arr[n++] = 0x86; /* extended inquiry */
697 arr[n++] = 0x87; /* mode page policy */
698 arr[n++] = 0x88; /* SCSI ports */
699 arr[n++] = 0x89; /* ATA information */
700 arr[n++] = 0xb0; /* Block limits (SBC) */
701 arr[3] = n - 4; /* number of supported VPD pages */
702 } else if (0x80 == cmd[2]) { /* unit serial number */
703 arr[1] = cmd[2]; /*sanity */
705 memcpy(&arr[4], lu_id_str, len);
706 } else if (0x83 == cmd[2]) { /* device identification */
707 arr[1] = cmd[2]; /*sanity */
708 arr[3] = inquiry_evpd_83(&arr[4], port_group_id,
709 target_dev_id, lu_id_num,
711 } else if (0x84 == cmd[2]) { /* Software interface ident. */
712 arr[1] = cmd[2]; /*sanity */
713 arr[3] = inquiry_evpd_84(&arr[4]);
714 } else if (0x85 == cmd[2]) { /* Management network addresses */
715 arr[1] = cmd[2]; /*sanity */
716 arr[3] = inquiry_evpd_85(&arr[4]);
717 } else if (0x86 == cmd[2]) { /* extended inquiry */
718 arr[1] = cmd[2]; /*sanity */
719 arr[3] = 0x3c; /* number of following entries */
720 arr[4] = 0x0; /* no protection stuff */
721 arr[5] = 0x7; /* head of q, ordered + simple q's */
722 } else if (0x87 == cmd[2]) { /* mode page policy */
723 arr[1] = cmd[2]; /*sanity */
724 arr[3] = 0x8; /* number of following entries */
725 arr[4] = 0x2; /* disconnect-reconnect mp */
726 arr[6] = 0x80; /* mlus, shared */
727 arr[8] = 0x18; /* protocol specific lu */
728 arr[10] = 0x82; /* mlus, per initiator port */
729 } else if (0x88 == cmd[2]) { /* SCSI Ports */
730 arr[1] = cmd[2]; /*sanity */
731 arr[3] = inquiry_evpd_88(&arr[4], target_dev_id);
732 } else if (0x89 == cmd[2]) { /* ATA information */
733 arr[1] = cmd[2]; /*sanity */
734 n = inquiry_evpd_89(&arr[4]);
737 } else if (0xb0 == cmd[2]) { /* Block limits (SBC) */
738 arr[1] = cmd[2]; /*sanity */
739 arr[3] = inquiry_evpd_b0(&arr[4]);
741 /* Illegal request, invalid field in cdb */
742 mk_sense_buffer(devip, ILLEGAL_REQUEST,
743 INVALID_FIELD_IN_CDB, 0);
745 return check_condition_result;
747 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
748 ret = fill_from_dev_buffer(scp, arr,
749 min(len, SDEBUG_MAX_INQ_ARR_SZ));
753 /* drops through here for a standard inquiry */
754 arr[1] = DEV_REMOVEABLE(target) ? 0x80 : 0; /* Removable disk */
755 arr[2] = scsi_debug_scsi_level;
756 arr[3] = 2; /* response_data_format==2 */
757 arr[4] = SDEBUG_LONG_INQ_SZ - 5;
758 if (0 == scsi_debug_vpd_use_hostno)
759 arr[5] = 0x10; /* claim: implicit TGPS */
760 arr[6] = 0x10; /* claim: MultiP */
761 /* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
762 arr[7] = 0xa; /* claim: LINKED + CMDQUE */
763 memcpy(&arr[8], inq_vendor_id, 8);
764 memcpy(&arr[16], inq_product_id, 16);
765 memcpy(&arr[32], inq_product_rev, 4);
766 /* version descriptors (2 bytes each) follow */
767 arr[58] = 0x0; arr[59] = 0x77; /* SAM-3 ANSI */
768 arr[60] = 0x3; arr[61] = 0x14; /* SPC-3 ANSI */
770 if (scsi_debug_ptype == 0) {
771 arr[n++] = 0x3; arr[n++] = 0x3d; /* SBC-2 ANSI */
772 } else if (scsi_debug_ptype == 1) {
773 arr[n++] = 0x3; arr[n++] = 0x60; /* SSC-2 no version */
775 arr[n++] = 0xc; arr[n++] = 0xf; /* SAS-1.1 rev 10 */
776 ret = fill_from_dev_buffer(scp, arr,
777 min(alloc_len, SDEBUG_LONG_INQ_SZ));
782 static int resp_requests(struct scsi_cmnd * scp,
783 struct sdebug_dev_info * devip)
785 unsigned char * sbuff;
786 unsigned char *cmd = (unsigned char *)scp->cmnd;
787 unsigned char arr[SDEBUG_SENSE_LEN];
791 memset(arr, 0, sizeof(arr));
792 if (devip->reset == 1)
793 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
794 want_dsense = !!(cmd[1] & 1) || scsi_debug_dsense;
795 sbuff = devip->sense_buff;
796 if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
799 arr[1] = 0x0; /* NO_SENSE in sense_key */
800 arr[2] = THRESHOLD_EXCEEDED;
801 arr[3] = 0xff; /* TEST set and MRIE==6 */
804 arr[2] = 0x0; /* NO_SENSE in sense_key */
805 arr[7] = 0xa; /* 18 byte sense buffer */
806 arr[12] = THRESHOLD_EXCEEDED;
807 arr[13] = 0xff; /* TEST set and MRIE==6 */
810 memcpy(arr, sbuff, SDEBUG_SENSE_LEN);
811 if ((cmd[1] & 1) && (! scsi_debug_dsense)) {
812 /* DESC bit set and sense_buff in fixed format */
813 memset(arr, 0, sizeof(arr));
815 arr[1] = sbuff[2]; /* sense key */
816 arr[2] = sbuff[12]; /* asc */
817 arr[3] = sbuff[13]; /* ascq */
821 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
822 return fill_from_dev_buffer(scp, arr, len);
825 static int resp_start_stop(struct scsi_cmnd * scp,
826 struct sdebug_dev_info * devip)
828 unsigned char *cmd = (unsigned char *)scp->cmnd;
829 int power_cond, errsts, start;
831 if ((errsts = check_readiness(scp, 1, devip)))
833 power_cond = (cmd[4] & 0xf0) >> 4;
835 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
837 return check_condition_result;
840 if (start == devip->stopped)
841 devip->stopped = !start;
845 static sector_t get_sdebug_capacity(void)
847 if (scsi_debug_virtual_gb > 0)
848 return 2048 * 1024 * scsi_debug_virtual_gb;
850 return sdebug_store_sectors;
853 #define SDEBUG_READCAP_ARR_SZ 8
854 static int resp_readcap(struct scsi_cmnd * scp,
855 struct sdebug_dev_info * devip)
857 unsigned char arr[SDEBUG_READCAP_ARR_SZ];
861 if ((errsts = check_readiness(scp, 1, devip)))
863 /* following just in case virtual_gb changed */
864 sdebug_capacity = get_sdebug_capacity();
865 memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
866 if (sdebug_capacity < 0xffffffff) {
867 capac = (unsigned int)sdebug_capacity - 1;
868 arr[0] = (capac >> 24);
869 arr[1] = (capac >> 16) & 0xff;
870 arr[2] = (capac >> 8) & 0xff;
871 arr[3] = capac & 0xff;
878 arr[6] = (scsi_debug_sector_size >> 8) & 0xff;
879 arr[7] = scsi_debug_sector_size & 0xff;
880 return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
883 #define SDEBUG_READCAP16_ARR_SZ 32
884 static int resp_readcap16(struct scsi_cmnd * scp,
885 struct sdebug_dev_info * devip)
887 unsigned char *cmd = (unsigned char *)scp->cmnd;
888 unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
889 unsigned long long capac;
890 int errsts, k, alloc_len;
892 if ((errsts = check_readiness(scp, 1, devip)))
894 alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8)
896 /* following just in case virtual_gb changed */
897 sdebug_capacity = get_sdebug_capacity();
898 memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
899 capac = sdebug_capacity - 1;
900 for (k = 0; k < 8; ++k, capac >>= 8)
901 arr[7 - k] = capac & 0xff;
902 arr[8] = (scsi_debug_sector_size >> 24) & 0xff;
903 arr[9] = (scsi_debug_sector_size >> 16) & 0xff;
904 arr[10] = (scsi_debug_sector_size >> 8) & 0xff;
905 arr[11] = scsi_debug_sector_size & 0xff;
906 return fill_from_dev_buffer(scp, arr,
907 min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
910 #define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
912 static int resp_report_tgtpgs(struct scsi_cmnd * scp,
913 struct sdebug_dev_info * devip)
915 unsigned char *cmd = (unsigned char *)scp->cmnd;
917 int host_no = devip->sdbg_host->shost->host_no;
918 int n, ret, alen, rlen;
919 int port_group_a, port_group_b, port_a, port_b;
921 alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8)
924 arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
926 return DID_REQUEUE << 16;
928 * EVPD page 0x88 states we have two ports, one
929 * real and a fake port with no device connected.
930 * So we create two port groups with one port each
931 * and set the group with port B to unavailable.
933 port_a = 0x1; /* relative port A */
934 port_b = 0x2; /* relative port B */
935 port_group_a = (((host_no + 1) & 0x7f) << 8) +
936 (devip->channel & 0x7f);
937 port_group_b = (((host_no + 1) & 0x7f) << 8) +
938 (devip->channel & 0x7f) + 0x80;
941 * The asymmetric access state is cycled according to the host_id.
944 if (0 == scsi_debug_vpd_use_hostno) {
945 arr[n++] = host_no % 3; /* Asymm access state */
946 arr[n++] = 0x0F; /* claim: all states are supported */
948 arr[n++] = 0x0; /* Active/Optimized path */
949 arr[n++] = 0x01; /* claim: only support active/optimized paths */
951 arr[n++] = (port_group_a >> 8) & 0xff;
952 arr[n++] = port_group_a & 0xff;
953 arr[n++] = 0; /* Reserved */
954 arr[n++] = 0; /* Status code */
955 arr[n++] = 0; /* Vendor unique */
956 arr[n++] = 0x1; /* One port per group */
957 arr[n++] = 0; /* Reserved */
958 arr[n++] = 0; /* Reserved */
959 arr[n++] = (port_a >> 8) & 0xff;
960 arr[n++] = port_a & 0xff;
961 arr[n++] = 3; /* Port unavailable */
962 arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
963 arr[n++] = (port_group_b >> 8) & 0xff;
964 arr[n++] = port_group_b & 0xff;
965 arr[n++] = 0; /* Reserved */
966 arr[n++] = 0; /* Status code */
967 arr[n++] = 0; /* Vendor unique */
968 arr[n++] = 0x1; /* One port per group */
969 arr[n++] = 0; /* Reserved */
970 arr[n++] = 0; /* Reserved */
971 arr[n++] = (port_b >> 8) & 0xff;
972 arr[n++] = port_b & 0xff;
975 arr[0] = (rlen >> 24) & 0xff;
976 arr[1] = (rlen >> 16) & 0xff;
977 arr[2] = (rlen >> 8) & 0xff;
978 arr[3] = rlen & 0xff;
981 * Return the smallest value of either
982 * - The allocated length
983 * - The constructed command length
984 * - The maximum array size
987 ret = fill_from_dev_buffer(scp, arr,
988 min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
993 /* <<Following mode page info copied from ST318451LW>> */
995 static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
996 { /* Read-Write Error Recovery page for mode_sense */
997 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
1000 memcpy(p, err_recov_pg, sizeof(err_recov_pg));
1002 memset(p + 2, 0, sizeof(err_recov_pg) - 2);
1003 return sizeof(err_recov_pg);
1006 static int resp_disconnect_pg(unsigned char * p, int pcontrol, int target)
1007 { /* Disconnect-Reconnect page for mode_sense */
1008 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
1009 0, 0, 0, 0, 0, 0, 0, 0};
1011 memcpy(p, disconnect_pg, sizeof(disconnect_pg));
1013 memset(p + 2, 0, sizeof(disconnect_pg) - 2);
1014 return sizeof(disconnect_pg);
1017 static int resp_format_pg(unsigned char * p, int pcontrol, int target)
1018 { /* Format device page for mode_sense */
1019 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
1020 0, 0, 0, 0, 0, 0, 0, 0,
1021 0, 0, 0, 0, 0x40, 0, 0, 0};
1023 memcpy(p, format_pg, sizeof(format_pg));
1024 p[10] = (sdebug_sectors_per >> 8) & 0xff;
1025 p[11] = sdebug_sectors_per & 0xff;
1026 p[12] = (scsi_debug_sector_size >> 8) & 0xff;
1027 p[13] = scsi_debug_sector_size & 0xff;
1028 if (DEV_REMOVEABLE(target))
1029 p[20] |= 0x20; /* should agree with INQUIRY */
1031 memset(p + 2, 0, sizeof(format_pg) - 2);
1032 return sizeof(format_pg);
1035 static int resp_caching_pg(unsigned char * p, int pcontrol, int target)
1036 { /* Caching page for mode_sense */
1037 unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1038 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
1040 memcpy(p, caching_pg, sizeof(caching_pg));
1042 memset(p + 2, 0, sizeof(caching_pg) - 2);
1043 return sizeof(caching_pg);
1046 static int resp_ctrl_m_pg(unsigned char * p, int pcontrol, int target)
1047 { /* Control mode page for mode_sense */
1048 unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
1050 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1053 if (scsi_debug_dsense)
1054 ctrl_m_pg[2] |= 0x4;
1056 ctrl_m_pg[2] &= ~0x4;
1057 memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
1059 memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
1060 else if (2 == pcontrol)
1061 memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
1062 return sizeof(ctrl_m_pg);
1066 static int resp_iec_m_pg(unsigned char * p, int pcontrol, int target)
1067 { /* Informational Exceptions control mode page for mode_sense */
1068 unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
1070 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1073 memcpy(p, iec_m_pg, sizeof(iec_m_pg));
1075 memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
1076 else if (2 == pcontrol)
1077 memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
1078 return sizeof(iec_m_pg);
1081 static int resp_sas_sf_m_pg(unsigned char * p, int pcontrol, int target)
1082 { /* SAS SSP mode page - short format for mode_sense */
1083 unsigned char sas_sf_m_pg[] = {0x19, 0x6,
1084 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
1086 memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
1088 memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
1089 return sizeof(sas_sf_m_pg);
1093 static int resp_sas_pcd_m_spg(unsigned char * p, int pcontrol, int target,
1095 { /* SAS phy control and discover mode page for mode_sense */
1096 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
1097 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
1098 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1099 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1100 0x2, 0, 0, 0, 0, 0, 0, 0,
1101 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1102 0, 0, 0, 0, 0, 0, 0, 0,
1103 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
1104 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1105 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1106 0x3, 0, 0, 0, 0, 0, 0, 0,
1107 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1108 0, 0, 0, 0, 0, 0, 0, 0,
1112 port_a = target_dev_id + 1;
1113 port_b = port_a + 1;
1114 memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
1115 p[20] = (port_a >> 24);
1116 p[21] = (port_a >> 16) & 0xff;
1117 p[22] = (port_a >> 8) & 0xff;
1118 p[23] = port_a & 0xff;
1119 p[48 + 20] = (port_b >> 24);
1120 p[48 + 21] = (port_b >> 16) & 0xff;
1121 p[48 + 22] = (port_b >> 8) & 0xff;
1122 p[48 + 23] = port_b & 0xff;
1124 memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
1125 return sizeof(sas_pcd_m_pg);
1128 static int resp_sas_sha_m_spg(unsigned char * p, int pcontrol)
1129 { /* SAS SSP shared protocol specific port mode subpage */
1130 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
1131 0, 0, 0, 0, 0, 0, 0, 0,
1134 memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
1136 memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
1137 return sizeof(sas_sha_m_pg);
1140 #define SDEBUG_MAX_MSENSE_SZ 256
1142 static int resp_mode_sense(struct scsi_cmnd * scp, int target,
1143 struct sdebug_dev_info * devip)
1145 unsigned char dbd, llbaa;
1146 int pcontrol, pcode, subpcode, bd_len;
1147 unsigned char dev_spec;
1148 int k, alloc_len, msense_6, offset, len, errsts, target_dev_id;
1150 unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
1151 unsigned char *cmd = (unsigned char *)scp->cmnd;
1153 if ((errsts = check_readiness(scp, 1, devip)))
1155 dbd = !!(cmd[1] & 0x8);
1156 pcontrol = (cmd[2] & 0xc0) >> 6;
1157 pcode = cmd[2] & 0x3f;
1159 msense_6 = (MODE_SENSE == cmd[0]);
1160 llbaa = msense_6 ? 0 : !!(cmd[1] & 0x10);
1161 if ((0 == scsi_debug_ptype) && (0 == dbd))
1162 bd_len = llbaa ? 16 : 8;
1165 alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]);
1166 memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
1167 if (0x3 == pcontrol) { /* Saving values not supported */
1168 mk_sense_buffer(devip, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP,
1170 return check_condition_result;
1172 target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
1173 (devip->target * 1000) - 3;
1174 /* set DPOFUA bit for disks */
1175 if (0 == scsi_debug_ptype)
1176 dev_spec = (DEV_READONLY(target) ? 0x80 : 0x0) | 0x10;
1186 arr[4] = 0x1; /* set LONGLBA bit */
1187 arr[7] = bd_len; /* assume 255 or less */
1191 if ((bd_len > 0) && (!sdebug_capacity))
1192 sdebug_capacity = get_sdebug_capacity();
1195 if (sdebug_capacity > 0xfffffffe) {
1201 ap[0] = (sdebug_capacity >> 24) & 0xff;
1202 ap[1] = (sdebug_capacity >> 16) & 0xff;
1203 ap[2] = (sdebug_capacity >> 8) & 0xff;
1204 ap[3] = sdebug_capacity & 0xff;
1206 ap[6] = (scsi_debug_sector_size >> 8) & 0xff;
1207 ap[7] = scsi_debug_sector_size & 0xff;
1210 } else if (16 == bd_len) {
1211 unsigned long long capac = sdebug_capacity;
1213 for (k = 0; k < 8; ++k, capac >>= 8)
1214 ap[7 - k] = capac & 0xff;
1215 ap[12] = (scsi_debug_sector_size >> 24) & 0xff;
1216 ap[13] = (scsi_debug_sector_size >> 16) & 0xff;
1217 ap[14] = (scsi_debug_sector_size >> 8) & 0xff;
1218 ap[15] = scsi_debug_sector_size & 0xff;
1223 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
1224 /* TODO: Control Extension page */
1225 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1227 return check_condition_result;
1230 case 0x1: /* Read-Write error recovery page, direct access */
1231 len = resp_err_recov_pg(ap, pcontrol, target);
1234 case 0x2: /* Disconnect-Reconnect page, all devices */
1235 len = resp_disconnect_pg(ap, pcontrol, target);
1238 case 0x3: /* Format device page, direct access */
1239 len = resp_format_pg(ap, pcontrol, target);
1242 case 0x8: /* Caching page, direct access */
1243 len = resp_caching_pg(ap, pcontrol, target);
1246 case 0xa: /* Control Mode page, all devices */
1247 len = resp_ctrl_m_pg(ap, pcontrol, target);
1250 case 0x19: /* if spc==1 then sas phy, control+discover */
1251 if ((subpcode > 0x2) && (subpcode < 0xff)) {
1252 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1253 INVALID_FIELD_IN_CDB, 0);
1254 return check_condition_result;
1257 if ((0x0 == subpcode) || (0xff == subpcode))
1258 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1259 if ((0x1 == subpcode) || (0xff == subpcode))
1260 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
1262 if ((0x2 == subpcode) || (0xff == subpcode))
1263 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1266 case 0x1c: /* Informational Exceptions Mode page, all devices */
1267 len = resp_iec_m_pg(ap, pcontrol, target);
1270 case 0x3f: /* Read all Mode pages */
1271 if ((0 == subpcode) || (0xff == subpcode)) {
1272 len = resp_err_recov_pg(ap, pcontrol, target);
1273 len += resp_disconnect_pg(ap + len, pcontrol, target);
1274 len += resp_format_pg(ap + len, pcontrol, target);
1275 len += resp_caching_pg(ap + len, pcontrol, target);
1276 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
1277 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1278 if (0xff == subpcode) {
1279 len += resp_sas_pcd_m_spg(ap + len, pcontrol,
1280 target, target_dev_id);
1281 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1283 len += resp_iec_m_pg(ap + len, pcontrol, target);
1285 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1286 INVALID_FIELD_IN_CDB, 0);
1287 return check_condition_result;
1292 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1294 return check_condition_result;
1297 arr[0] = offset - 1;
1299 arr[0] = ((offset - 2) >> 8) & 0xff;
1300 arr[1] = (offset - 2) & 0xff;
1302 return fill_from_dev_buffer(scp, arr, min(alloc_len, offset));
1305 #define SDEBUG_MAX_MSELECT_SZ 512
1307 static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
1308 struct sdebug_dev_info * devip)
1310 int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
1311 int param_len, res, errsts, mpage;
1312 unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
1313 unsigned char *cmd = (unsigned char *)scp->cmnd;
1315 if ((errsts = check_readiness(scp, 1, devip)))
1317 memset(arr, 0, sizeof(arr));
1320 param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]);
1321 if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
1322 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1323 INVALID_FIELD_IN_CDB, 0);
1324 return check_condition_result;
1326 res = fetch_to_dev_buffer(scp, arr, param_len);
1328 return (DID_ERROR << 16);
1329 else if ((res < param_len) &&
1330 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1331 printk(KERN_INFO "scsi_debug: mode_select: cdb indicated=%d, "
1332 " IO sent=%d bytes\n", param_len, res);
1333 md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2);
1334 bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]);
1336 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1337 INVALID_FIELD_IN_PARAM_LIST, 0);
1338 return check_condition_result;
1340 off = bd_len + (mselect6 ? 4 : 8);
1341 mpage = arr[off] & 0x3f;
1342 ps = !!(arr[off] & 0x80);
1344 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1345 INVALID_FIELD_IN_PARAM_LIST, 0);
1346 return check_condition_result;
1348 spf = !!(arr[off] & 0x40);
1349 pg_len = spf ? ((arr[off + 2] << 8) + arr[off + 3] + 4) :
1351 if ((pg_len + off) > param_len) {
1352 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1353 PARAMETER_LIST_LENGTH_ERR, 0);
1354 return check_condition_result;
1357 case 0xa: /* Control Mode page */
1358 if (ctrl_m_pg[1] == arr[off + 1]) {
1359 memcpy(ctrl_m_pg + 2, arr + off + 2,
1360 sizeof(ctrl_m_pg) - 2);
1361 scsi_debug_dsense = !!(ctrl_m_pg[2] & 0x4);
1365 case 0x1c: /* Informational Exceptions Mode page */
1366 if (iec_m_pg[1] == arr[off + 1]) {
1367 memcpy(iec_m_pg + 2, arr + off + 2,
1368 sizeof(iec_m_pg) - 2);
1375 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1376 INVALID_FIELD_IN_PARAM_LIST, 0);
1377 return check_condition_result;
1380 static int resp_temp_l_pg(unsigned char * arr)
1382 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
1383 0x0, 0x1, 0x3, 0x2, 0x0, 65,
1386 memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
1387 return sizeof(temp_l_pg);
1390 static int resp_ie_l_pg(unsigned char * arr)
1392 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
1395 memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
1396 if (iec_m_pg[2] & 0x4) { /* TEST bit set */
1397 arr[4] = THRESHOLD_EXCEEDED;
1400 return sizeof(ie_l_pg);
1403 #define SDEBUG_MAX_LSENSE_SZ 512
1405 static int resp_log_sense(struct scsi_cmnd * scp,
1406 struct sdebug_dev_info * devip)
1408 int ppc, sp, pcontrol, pcode, subpcode, alloc_len, errsts, len, n;
1409 unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
1410 unsigned char *cmd = (unsigned char *)scp->cmnd;
1412 if ((errsts = check_readiness(scp, 1, devip)))
1414 memset(arr, 0, sizeof(arr));
1418 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1419 INVALID_FIELD_IN_CDB, 0);
1420 return check_condition_result;
1422 pcontrol = (cmd[2] & 0xc0) >> 6;
1423 pcode = cmd[2] & 0x3f;
1424 subpcode = cmd[3] & 0xff;
1425 alloc_len = (cmd[7] << 8) + cmd[8];
1427 if (0 == subpcode) {
1429 case 0x0: /* Supported log pages log page */
1431 arr[n++] = 0x0; /* this page */
1432 arr[n++] = 0xd; /* Temperature */
1433 arr[n++] = 0x2f; /* Informational exceptions */
1436 case 0xd: /* Temperature log page */
1437 arr[3] = resp_temp_l_pg(arr + 4);
1439 case 0x2f: /* Informational exceptions log page */
1440 arr[3] = resp_ie_l_pg(arr + 4);
1443 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1444 INVALID_FIELD_IN_CDB, 0);
1445 return check_condition_result;
1447 } else if (0xff == subpcode) {
1451 case 0x0: /* Supported log pages and subpages log page */
1454 arr[n++] = 0x0; /* 0,0 page */
1456 arr[n++] = 0xff; /* this page */
1458 arr[n++] = 0x0; /* Temperature */
1460 arr[n++] = 0x0; /* Informational exceptions */
1463 case 0xd: /* Temperature subpages */
1466 arr[n++] = 0x0; /* Temperature */
1469 case 0x2f: /* Informational exceptions subpages */
1472 arr[n++] = 0x0; /* Informational exceptions */
1476 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1477 INVALID_FIELD_IN_CDB, 0);
1478 return check_condition_result;
1481 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1482 INVALID_FIELD_IN_CDB, 0);
1483 return check_condition_result;
1485 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
1486 return fill_from_dev_buffer(scp, arr,
1487 min(len, SDEBUG_MAX_INQ_ARR_SZ));
1490 static int check_device_access_params(struct sdebug_dev_info *devi,
1491 unsigned long long lba, unsigned int num)
1493 if (lba + num > sdebug_capacity) {
1494 mk_sense_buffer(devi, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE, 0);
1495 return check_condition_result;
1497 /* transfer length excessive (tie in to block limits VPD page) */
1498 if (num > sdebug_store_sectors) {
1499 mk_sense_buffer(devi, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
1500 return check_condition_result;
1505 static int do_device_access(struct scsi_cmnd *scmd,
1506 struct sdebug_dev_info *devi,
1507 unsigned long long lba, unsigned int num, int write)
1510 unsigned int block, rest = 0;
1511 int (*func)(struct scsi_cmnd *, unsigned char *, int);
1513 func = write ? fetch_to_dev_buffer : fill_from_dev_buffer;
1515 block = do_div(lba, sdebug_store_sectors);
1516 if (block + num > sdebug_store_sectors)
1517 rest = block + num - sdebug_store_sectors;
1519 ret = func(scmd, fake_storep + (block * scsi_debug_sector_size),
1520 (num - rest) * scsi_debug_sector_size);
1522 ret = func(scmd, fake_storep, rest * scsi_debug_sector_size);
1527 static int resp_read(struct scsi_cmnd *SCpnt, unsigned long long lba,
1528 unsigned int num, struct sdebug_dev_info *devip)
1530 unsigned long iflags;
1533 ret = check_device_access_params(devip, lba, num);
1537 if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) &&
1538 (lba <= OPT_MEDIUM_ERR_ADDR) &&
1539 ((lba + num) > OPT_MEDIUM_ERR_ADDR)) {
1540 /* claim unrecoverable read error */
1541 mk_sense_buffer(devip, MEDIUM_ERROR, UNRECOVERED_READ_ERR,
1543 /* set info field and valid bit for fixed descriptor */
1544 if (0x70 == (devip->sense_buff[0] & 0x7f)) {
1545 devip->sense_buff[0] |= 0x80; /* Valid bit */
1546 ret = OPT_MEDIUM_ERR_ADDR;
1547 devip->sense_buff[3] = (ret >> 24) & 0xff;
1548 devip->sense_buff[4] = (ret >> 16) & 0xff;
1549 devip->sense_buff[5] = (ret >> 8) & 0xff;
1550 devip->sense_buff[6] = ret & 0xff;
1552 return check_condition_result;
1554 read_lock_irqsave(&atomic_rw, iflags);
1555 ret = do_device_access(SCpnt, devip, lba, num, 0);
1556 read_unlock_irqrestore(&atomic_rw, iflags);
1560 static int resp_write(struct scsi_cmnd *SCpnt, unsigned long long lba,
1561 unsigned int num, struct sdebug_dev_info *devip)
1563 unsigned long iflags;
1566 ret = check_device_access_params(devip, lba, num);
1570 write_lock_irqsave(&atomic_rw, iflags);
1571 ret = do_device_access(SCpnt, devip, lba, num, 1);
1572 write_unlock_irqrestore(&atomic_rw, iflags);
1574 return (DID_ERROR << 16);
1575 else if ((ret < (num * scsi_debug_sector_size)) &&
1576 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1577 printk(KERN_INFO "scsi_debug: write: cdb indicated=%u, "
1578 " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret);
1582 #define SDEBUG_RLUN_ARR_SZ 256
1584 static int resp_report_luns(struct scsi_cmnd * scp,
1585 struct sdebug_dev_info * devip)
1587 unsigned int alloc_len;
1588 int lun_cnt, i, upper, num, n, wlun, lun;
1589 unsigned char *cmd = (unsigned char *)scp->cmnd;
1590 int select_report = (int)cmd[2];
1591 struct scsi_lun *one_lun;
1592 unsigned char arr[SDEBUG_RLUN_ARR_SZ];
1593 unsigned char * max_addr;
1595 alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
1596 if ((alloc_len < 4) || (select_report > 2)) {
1597 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1599 return check_condition_result;
1601 /* can produce response with up to 16k luns (lun 0 to lun 16383) */
1602 memset(arr, 0, SDEBUG_RLUN_ARR_SZ);
1603 lun_cnt = scsi_debug_max_luns;
1604 if (1 == select_report)
1606 else if (scsi_debug_no_lun_0 && (lun_cnt > 0))
1608 wlun = (select_report > 0) ? 1 : 0;
1609 num = lun_cnt + wlun;
1610 arr[2] = ((sizeof(struct scsi_lun) * num) >> 8) & 0xff;
1611 arr[3] = (sizeof(struct scsi_lun) * num) & 0xff;
1612 n = min((int)((SDEBUG_RLUN_ARR_SZ - 8) /
1613 sizeof(struct scsi_lun)), num);
1618 one_lun = (struct scsi_lun *) &arr[8];
1619 max_addr = arr + SDEBUG_RLUN_ARR_SZ;
1620 for (i = 0, lun = (scsi_debug_no_lun_0 ? 1 : 0);
1621 ((i < lun_cnt) && ((unsigned char *)(one_lun + i) < max_addr));
1623 upper = (lun >> 8) & 0x3f;
1625 one_lun[i].scsi_lun[0] =
1626 (upper | (SAM2_LUN_ADDRESS_METHOD << 6));
1627 one_lun[i].scsi_lun[1] = lun & 0xff;
1630 one_lun[i].scsi_lun[0] = (SAM2_WLUN_REPORT_LUNS >> 8) & 0xff;
1631 one_lun[i].scsi_lun[1] = SAM2_WLUN_REPORT_LUNS & 0xff;
1634 alloc_len = (unsigned char *)(one_lun + i) - arr;
1635 return fill_from_dev_buffer(scp, arr,
1636 min((int)alloc_len, SDEBUG_RLUN_ARR_SZ));
1639 static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
1640 unsigned int num, struct sdebug_dev_info *devip)
1643 unsigned char *kaddr, *buf;
1644 unsigned int offset;
1645 struct scatterlist *sg;
1646 struct scsi_data_buffer *sdb = scsi_in(scp);
1648 /* better not to use temporary buffer. */
1649 buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
1653 scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
1656 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, i) {
1657 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
1661 for (j = 0; j < sg->length; j++)
1662 *(kaddr + sg->offset + j) ^= *(buf + offset + j);
1664 offset += sg->length;
1665 kunmap_atomic(kaddr, KM_USER0);
1674 /* When timer goes off this function is called. */
1675 static void timer_intr_handler(unsigned long indx)
1677 struct sdebug_queued_cmd * sqcp;
1678 unsigned long iflags;
1680 if (indx >= SCSI_DEBUG_CANQUEUE) {
1681 printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too "
1685 spin_lock_irqsave(&queued_arr_lock, iflags);
1686 sqcp = &queued_arr[(int)indx];
1687 if (! sqcp->in_use) {
1688 printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected "
1690 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1694 if (sqcp->done_funct) {
1695 sqcp->a_cmnd->result = sqcp->scsi_result;
1696 sqcp->done_funct(sqcp->a_cmnd); /* callback to mid level */
1698 sqcp->done_funct = NULL;
1699 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1703 static struct sdebug_dev_info *
1704 sdebug_device_create(struct sdebug_host_info *sdbg_host, gfp_t flags)
1706 struct sdebug_dev_info *devip;
1708 devip = kzalloc(sizeof(*devip), flags);
1710 devip->sdbg_host = sdbg_host;
1711 list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
1716 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
1718 struct sdebug_host_info * sdbg_host;
1719 struct sdebug_dev_info * open_devip = NULL;
1720 struct sdebug_dev_info * devip =
1721 (struct sdebug_dev_info *)sdev->hostdata;
1725 sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
1727 printk(KERN_ERR "Host info NULL\n");
1730 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
1731 if ((devip->used) && (devip->channel == sdev->channel) &&
1732 (devip->target == sdev->id) &&
1733 (devip->lun == sdev->lun))
1736 if ((!devip->used) && (!open_devip))
1740 if (!open_devip) { /* try and make a new one */
1741 open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC);
1743 printk(KERN_ERR "%s: out of memory at line %d\n",
1744 __FUNCTION__, __LINE__);
1749 open_devip->channel = sdev->channel;
1750 open_devip->target = sdev->id;
1751 open_devip->lun = sdev->lun;
1752 open_devip->sdbg_host = sdbg_host;
1753 open_devip->reset = 1;
1754 open_devip->used = 1;
1755 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
1756 if (scsi_debug_dsense)
1757 open_devip->sense_buff[0] = 0x72;
1759 open_devip->sense_buff[0] = 0x70;
1760 open_devip->sense_buff[7] = 0xa;
1762 if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
1763 open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
1768 static int scsi_debug_slave_alloc(struct scsi_device *sdp)
1770 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1771 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
1772 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
1773 queue_flag_set_unlocked(QUEUE_FLAG_BIDI, sdp->request_queue);
1777 static int scsi_debug_slave_configure(struct scsi_device *sdp)
1779 struct sdebug_dev_info *devip;
1781 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1782 printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n",
1783 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
1784 if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN)
1785 sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN;
1786 devip = devInfoReg(sdp);
1788 return 1; /* no resources, will be marked offline */
1789 sdp->hostdata = devip;
1790 if (sdp->host->cmd_per_lun)
1791 scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING,
1792 sdp->host->cmd_per_lun);
1793 blk_queue_max_segment_size(sdp->request_queue, 256 * 1024);
1797 static void scsi_debug_slave_destroy(struct scsi_device *sdp)
1799 struct sdebug_dev_info *devip =
1800 (struct sdebug_dev_info *)sdp->hostdata;
1802 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1803 printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n",
1804 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
1806 /* make this slot avaliable for re-use */
1808 sdp->hostdata = NULL;
1812 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
1813 static int stop_queued_cmnd(struct scsi_cmnd *cmnd)
1815 unsigned long iflags;
1817 struct sdebug_queued_cmd *sqcp;
1819 spin_lock_irqsave(&queued_arr_lock, iflags);
1820 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
1821 sqcp = &queued_arr[k];
1822 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
1823 del_timer_sync(&sqcp->cmnd_timer);
1825 sqcp->a_cmnd = NULL;
1829 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1830 return (k < SCSI_DEBUG_CANQUEUE) ? 1 : 0;
1833 /* Deletes (stops) timers of all queued commands */
1834 static void stop_all_queued(void)
1836 unsigned long iflags;
1838 struct sdebug_queued_cmd *sqcp;
1840 spin_lock_irqsave(&queued_arr_lock, iflags);
1841 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
1842 sqcp = &queued_arr[k];
1843 if (sqcp->in_use && sqcp->a_cmnd) {
1844 del_timer_sync(&sqcp->cmnd_timer);
1846 sqcp->a_cmnd = NULL;
1849 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1852 static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
1854 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1855 printk(KERN_INFO "scsi_debug: abort\n");
1857 stop_queued_cmnd(SCpnt);
1861 static int scsi_debug_biosparam(struct scsi_device *sdev,
1862 struct block_device * bdev, sector_t capacity, int *info)
1867 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1868 printk(KERN_INFO "scsi_debug: biosparam\n");
1869 buf = scsi_bios_ptable(bdev);
1871 res = scsi_partsize(buf, capacity,
1872 &info[2], &info[0], &info[1]);
1877 info[0] = sdebug_heads;
1878 info[1] = sdebug_sectors_per;
1879 info[2] = sdebug_cylinders_per;
1883 static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
1885 struct sdebug_dev_info * devip;
1887 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1888 printk(KERN_INFO "scsi_debug: device_reset\n");
1891 devip = devInfoReg(SCpnt->device);
1898 static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
1900 struct sdebug_host_info *sdbg_host;
1901 struct sdebug_dev_info * dev_info;
1902 struct scsi_device * sdp;
1903 struct Scsi_Host * hp;
1905 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1906 printk(KERN_INFO "scsi_debug: bus_reset\n");
1908 if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
1909 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
1911 list_for_each_entry(dev_info,
1912 &sdbg_host->dev_info_list,
1914 dev_info->reset = 1;
1920 static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
1922 struct sdebug_host_info * sdbg_host;
1923 struct sdebug_dev_info * dev_info;
1925 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1926 printk(KERN_INFO "scsi_debug: host_reset\n");
1928 spin_lock(&sdebug_host_list_lock);
1929 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
1930 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
1932 dev_info->reset = 1;
1934 spin_unlock(&sdebug_host_list_lock);
1939 /* Initializes timers in queued array */
1940 static void __init init_all_queued(void)
1942 unsigned long iflags;
1944 struct sdebug_queued_cmd * sqcp;
1946 spin_lock_irqsave(&queued_arr_lock, iflags);
1947 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
1948 sqcp = &queued_arr[k];
1949 init_timer(&sqcp->cmnd_timer);
1951 sqcp->a_cmnd = NULL;
1953 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1956 static void __init sdebug_build_parts(unsigned char *ramp,
1957 unsigned long store_size)
1959 struct partition * pp;
1960 int starts[SDEBUG_MAX_PARTS + 2];
1961 int sectors_per_part, num_sectors, k;
1962 int heads_by_sects, start_sec, end_sec;
1964 /* assume partition table already zeroed */
1965 if ((scsi_debug_num_parts < 1) || (store_size < 1048576))
1967 if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
1968 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
1969 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
1970 "partitions to %d\n", SDEBUG_MAX_PARTS);
1972 num_sectors = (int)sdebug_store_sectors;
1973 sectors_per_part = (num_sectors - sdebug_sectors_per)
1974 / scsi_debug_num_parts;
1975 heads_by_sects = sdebug_heads * sdebug_sectors_per;
1976 starts[0] = sdebug_sectors_per;
1977 for (k = 1; k < scsi_debug_num_parts; ++k)
1978 starts[k] = ((k * sectors_per_part) / heads_by_sects)
1980 starts[scsi_debug_num_parts] = num_sectors;
1981 starts[scsi_debug_num_parts + 1] = 0;
1983 ramp[510] = 0x55; /* magic partition markings */
1985 pp = (struct partition *)(ramp + 0x1be);
1986 for (k = 0; starts[k + 1]; ++k, ++pp) {
1987 start_sec = starts[k];
1988 end_sec = starts[k + 1] - 1;
1991 pp->cyl = start_sec / heads_by_sects;
1992 pp->head = (start_sec - (pp->cyl * heads_by_sects))
1993 / sdebug_sectors_per;
1994 pp->sector = (start_sec % sdebug_sectors_per) + 1;
1996 pp->end_cyl = end_sec / heads_by_sects;
1997 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
1998 / sdebug_sectors_per;
1999 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2001 pp->start_sect = start_sec;
2002 pp->nr_sects = end_sec - start_sec + 1;
2003 pp->sys_ind = 0x83; /* plain Linux partition */
2007 static int schedule_resp(struct scsi_cmnd * cmnd,
2008 struct sdebug_dev_info * devip,
2009 done_funct_t done, int scsi_result, int delta_jiff)
2011 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
2013 struct scsi_device * sdp = cmnd->device;
2015 printk(KERN_INFO "scsi_debug: <%u %u %u %u> "
2016 "non-zero result=0x%x\n", sdp->host->host_no,
2017 sdp->channel, sdp->id, sdp->lun, scsi_result);
2020 if (cmnd && devip) {
2021 /* simulate autosense by this driver */
2022 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
2023 memcpy(cmnd->sense_buffer, devip->sense_buff,
2024 (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
2025 SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
2027 if (delta_jiff <= 0) {
2029 cmnd->result = scsi_result;
2034 unsigned long iflags;
2036 struct sdebug_queued_cmd * sqcp = NULL;
2038 spin_lock_irqsave(&queued_arr_lock, iflags);
2039 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2040 sqcp = &queued_arr[k];
2044 if (k >= SCSI_DEBUG_CANQUEUE) {
2045 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2046 printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
2047 return 1; /* report busy to mid level */
2050 sqcp->a_cmnd = cmnd;
2051 sqcp->scsi_result = scsi_result;
2052 sqcp->done_funct = done;
2053 sqcp->cmnd_timer.function = timer_intr_handler;
2054 sqcp->cmnd_timer.data = k;
2055 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
2056 add_timer(&sqcp->cmnd_timer);
2057 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2063 /* Note: The following macros create attribute files in the
2064 /sys/module/scsi_debug/parameters directory. Unfortunately this
2065 driver is unaware of a change and cannot trigger auxiliary actions
2066 as it can when the corresponding attribute in the
2067 /sys/bus/pseudo/drivers/scsi_debug directory is changed.
2069 module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
2070 module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
2071 module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
2072 module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
2073 module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
2074 module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
2075 module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
2076 module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
2077 module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
2078 module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
2079 module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
2080 module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
2081 module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
2082 module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
2083 module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
2085 module_param_named(sector_size, scsi_debug_sector_size, int, S_IRUGO);
2087 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2088 MODULE_DESCRIPTION("SCSI debug adapter driver");
2089 MODULE_LICENSE("GPL");
2090 MODULE_VERSION(SCSI_DEBUG_VERSION);
2092 MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
2093 MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
2094 MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
2095 MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
2096 MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
2097 MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
2098 MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
2099 MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
2100 MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
2101 MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
2102 MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
2103 MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
2104 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
2105 MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
2106 MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2107 MODULE_PARM_DESC(sector_size, "hardware sector size in bytes (def=512)");
2110 static char sdebug_info[256];
2112 static const char * scsi_debug_info(struct Scsi_Host * shp)
2114 sprintf(sdebug_info, "scsi_debug, version %s [%s], "
2115 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
2116 scsi_debug_version_date, scsi_debug_dev_size_mb,
2121 /* scsi_debug_proc_info
2122 * Used if the driver currently has no own support for /proc/scsi
2124 static int scsi_debug_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
2125 int length, int inout)
2127 int len, pos, begin;
2130 orig_length = length;
2134 int minLen = length > 15 ? 15 : length;
2136 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2138 memcpy(arr, buffer, minLen);
2140 if (1 != sscanf(arr, "%d", &pos))
2142 scsi_debug_opts = pos;
2143 if (scsi_debug_every_nth != 0)
2144 scsi_debug_cmnd_count = 0;
2148 pos = len = sprintf(buffer, "scsi_debug adapter driver, version "
2150 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2151 "every_nth=%d(curr:%d)\n"
2152 "delay=%d, max_luns=%d, scsi_level=%d\n"
2153 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2154 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2156 SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
2157 scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2158 scsi_debug_cmnd_count, scsi_debug_delay,
2159 scsi_debug_max_luns, scsi_debug_scsi_level,
2160 scsi_debug_sector_size, sdebug_cylinders_per, sdebug_heads,
2161 sdebug_sectors_per, num_aborts, num_dev_resets, num_bus_resets,
2167 *start = buffer + (offset - begin); /* Start of wanted data */
2168 len -= (offset - begin);
2174 static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf)
2176 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
2179 static ssize_t sdebug_delay_store(struct device_driver * ddp,
2180 const char * buf, size_t count)
2185 if (1 == sscanf(buf, "%10s", work)) {
2186 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
2187 scsi_debug_delay = delay;
2193 DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show,
2194 sdebug_delay_store);
2196 static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf)
2198 return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
2201 static ssize_t sdebug_opts_store(struct device_driver * ddp,
2202 const char * buf, size_t count)
2207 if (1 == sscanf(buf, "%10s", work)) {
2208 if (0 == strnicmp(work,"0x", 2)) {
2209 if (1 == sscanf(&work[2], "%x", &opts))
2212 if (1 == sscanf(work, "%d", &opts))
2218 scsi_debug_opts = opts;
2219 scsi_debug_cmnd_count = 0;
2222 DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show,
2225 static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf)
2227 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
2229 static ssize_t sdebug_ptype_store(struct device_driver * ddp,
2230 const char * buf, size_t count)
2234 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2235 scsi_debug_ptype = n;
2240 DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store);
2242 static ssize_t sdebug_dsense_show(struct device_driver * ddp, char * buf)
2244 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
2246 static ssize_t sdebug_dsense_store(struct device_driver * ddp,
2247 const char * buf, size_t count)
2251 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2252 scsi_debug_dsense = n;
2257 DRIVER_ATTR(dsense, S_IRUGO | S_IWUSR, sdebug_dsense_show,
2258 sdebug_dsense_store);
2260 static ssize_t sdebug_fake_rw_show(struct device_driver * ddp, char * buf)
2262 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
2264 static ssize_t sdebug_fake_rw_store(struct device_driver * ddp,
2265 const char * buf, size_t count)
2269 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2270 scsi_debug_fake_rw = n;
2275 DRIVER_ATTR(fake_rw, S_IRUGO | S_IWUSR, sdebug_fake_rw_show,
2276 sdebug_fake_rw_store);
2278 static ssize_t sdebug_no_lun_0_show(struct device_driver * ddp, char * buf)
2280 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
2282 static ssize_t sdebug_no_lun_0_store(struct device_driver * ddp,
2283 const char * buf, size_t count)
2287 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2288 scsi_debug_no_lun_0 = n;
2293 DRIVER_ATTR(no_lun_0, S_IRUGO | S_IWUSR, sdebug_no_lun_0_show,
2294 sdebug_no_lun_0_store);
2296 static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf)
2298 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
2300 static ssize_t sdebug_num_tgts_store(struct device_driver * ddp,
2301 const char * buf, size_t count)
2305 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2306 scsi_debug_num_tgts = n;
2307 sdebug_max_tgts_luns();
2312 DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show,
2313 sdebug_num_tgts_store);
2315 static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf)
2317 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
2319 DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL);
2321 static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf)
2323 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
2325 DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL);
2327 static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf)
2329 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
2331 static ssize_t sdebug_every_nth_store(struct device_driver * ddp,
2332 const char * buf, size_t count)
2336 if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
2337 scsi_debug_every_nth = nth;
2338 scsi_debug_cmnd_count = 0;
2343 DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show,
2344 sdebug_every_nth_store);
2346 static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf)
2348 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
2350 static ssize_t sdebug_max_luns_store(struct device_driver * ddp,
2351 const char * buf, size_t count)
2355 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2356 scsi_debug_max_luns = n;
2357 sdebug_max_tgts_luns();
2362 DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show,
2363 sdebug_max_luns_store);
2365 static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf)
2367 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
2369 DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL);
2371 static ssize_t sdebug_virtual_gb_show(struct device_driver * ddp, char * buf)
2373 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
2375 static ssize_t sdebug_virtual_gb_store(struct device_driver * ddp,
2376 const char * buf, size_t count)
2380 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2381 scsi_debug_virtual_gb = n;
2383 sdebug_capacity = get_sdebug_capacity();
2389 DRIVER_ATTR(virtual_gb, S_IRUGO | S_IWUSR, sdebug_virtual_gb_show,
2390 sdebug_virtual_gb_store);
2392 static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf)
2394 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
2397 static ssize_t sdebug_add_host_store(struct device_driver * ddp,
2398 const char * buf, size_t count)
2402 if (sscanf(buf, "%d", &delta_hosts) != 1)
2404 if (delta_hosts > 0) {
2406 sdebug_add_adapter();
2407 } while (--delta_hosts);
2408 } else if (delta_hosts < 0) {
2410 sdebug_remove_adapter();
2411 } while (++delta_hosts);
2415 DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show,
2416 sdebug_add_host_store);
2418 static ssize_t sdebug_vpd_use_hostno_show(struct device_driver * ddp,
2421 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
2423 static ssize_t sdebug_vpd_use_hostno_store(struct device_driver * ddp,
2424 const char * buf, size_t count)
2428 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2429 scsi_debug_vpd_use_hostno = n;
2434 DRIVER_ATTR(vpd_use_hostno, S_IRUGO | S_IWUSR, sdebug_vpd_use_hostno_show,
2435 sdebug_vpd_use_hostno_store);
2437 static ssize_t sdebug_sector_size_show(struct device_driver * ddp, char * buf)
2439 return scnprintf(buf, PAGE_SIZE, "%u\n", scsi_debug_sector_size);
2441 DRIVER_ATTR(sector_size, S_IRUGO, sdebug_sector_size_show, NULL);
2443 /* Note: The following function creates attribute files in the
2444 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
2445 files (over those found in the /sys/module/scsi_debug/parameters
2446 directory) is that auxiliary actions can be triggered when an attribute
2447 is changed. For example see: sdebug_add_host_store() above.
2449 static int do_create_driverfs_files(void)
2453 ret = driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2454 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay);
2455 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2456 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2457 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2458 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2459 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2460 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2461 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2462 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2463 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2464 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts);
2465 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2466 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2467 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2468 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_sector_size);
2472 static void do_remove_driverfs_files(void)
2474 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_sector_size);
2475 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2476 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2477 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2478 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts);
2479 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2480 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2481 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2482 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2483 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2484 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2485 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2486 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2487 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2488 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay);
2489 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2492 static void pseudo_0_release(struct device *dev)
2494 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2495 printk(KERN_INFO "scsi_debug: pseudo_0_release() called\n");
2498 static struct device pseudo_primary = {
2499 .bus_id = "pseudo_0",
2500 .release = pseudo_0_release,
2503 static int __init scsi_debug_init(void)
2510 switch (scsi_debug_sector_size) {
2517 printk(KERN_ERR "scsi_debug_init: invalid sector_size %u\n",
2518 scsi_debug_sector_size);
2522 if (scsi_debug_dev_size_mb < 1)
2523 scsi_debug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */
2524 sz = (unsigned long)scsi_debug_dev_size_mb * 1048576;
2525 sdebug_store_sectors = sz / scsi_debug_sector_size;
2526 sdebug_capacity = get_sdebug_capacity();
2528 /* play around with geometry, don't waste too much on track 0 */
2530 sdebug_sectors_per = 32;
2531 if (scsi_debug_dev_size_mb >= 16)
2533 else if (scsi_debug_dev_size_mb >= 256)
2535 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2536 (sdebug_sectors_per * sdebug_heads);
2537 if (sdebug_cylinders_per >= 1024) {
2538 /* other LLDs do this; implies >= 1GB ram disk ... */
2540 sdebug_sectors_per = 63;
2541 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2542 (sdebug_sectors_per * sdebug_heads);
2545 fake_storep = vmalloc(sz);
2546 if (NULL == fake_storep) {
2547 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
2550 memset(fake_storep, 0, sz);
2551 if (scsi_debug_num_parts > 0)
2552 sdebug_build_parts(fake_storep, sz);
2554 ret = device_register(&pseudo_primary);
2556 printk(KERN_WARNING "scsi_debug: device_register error: %d\n",
2560 ret = bus_register(&pseudo_lld_bus);
2562 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
2566 ret = driver_register(&sdebug_driverfs_driver);
2568 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
2572 ret = do_create_driverfs_files();
2574 printk(KERN_WARNING "scsi_debug: driver_create_file error: %d\n",
2581 host_to_add = scsi_debug_add_host;
2582 scsi_debug_add_host = 0;
2584 for (k = 0; k < host_to_add; k++) {
2585 if (sdebug_add_adapter()) {
2586 printk(KERN_ERR "scsi_debug_init: "
2587 "sdebug_add_adapter failed k=%d\n", k);
2592 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
2593 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
2594 scsi_debug_add_host);
2599 do_remove_driverfs_files();
2600 driver_unregister(&sdebug_driverfs_driver);
2602 bus_unregister(&pseudo_lld_bus);
2604 device_unregister(&pseudo_primary);
2611 static void __exit scsi_debug_exit(void)
2613 int k = scsi_debug_add_host;
2617 sdebug_remove_adapter();
2618 do_remove_driverfs_files();
2619 driver_unregister(&sdebug_driverfs_driver);
2620 bus_unregister(&pseudo_lld_bus);
2621 device_unregister(&pseudo_primary);
2626 device_initcall(scsi_debug_init);
2627 module_exit(scsi_debug_exit);
2629 static void sdebug_release_adapter(struct device * dev)
2631 struct sdebug_host_info *sdbg_host;
2633 sdbg_host = to_sdebug_host(dev);
2637 static int sdebug_add_adapter(void)
2639 int k, devs_per_host;
2641 struct sdebug_host_info *sdbg_host;
2642 struct sdebug_dev_info *sdbg_devinfo, *tmp;
2644 sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
2645 if (NULL == sdbg_host) {
2646 printk(KERN_ERR "%s: out of memory at line %d\n",
2647 __FUNCTION__, __LINE__);
2651 INIT_LIST_HEAD(&sdbg_host->dev_info_list);
2653 devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
2654 for (k = 0; k < devs_per_host; k++) {
2655 sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL);
2656 if (!sdbg_devinfo) {
2657 printk(KERN_ERR "%s: out of memory at line %d\n",
2658 __FUNCTION__, __LINE__);
2664 spin_lock(&sdebug_host_list_lock);
2665 list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
2666 spin_unlock(&sdebug_host_list_lock);
2668 sdbg_host->dev.bus = &pseudo_lld_bus;
2669 sdbg_host->dev.parent = &pseudo_primary;
2670 sdbg_host->dev.release = &sdebug_release_adapter;
2671 sprintf(sdbg_host->dev.bus_id, "adapter%d", scsi_debug_add_host);
2673 error = device_register(&sdbg_host->dev);
2678 ++scsi_debug_add_host;
2682 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
2684 list_del(&sdbg_devinfo->dev_list);
2685 kfree(sdbg_devinfo);
2692 static void sdebug_remove_adapter(void)
2694 struct sdebug_host_info * sdbg_host = NULL;
2696 spin_lock(&sdebug_host_list_lock);
2697 if (!list_empty(&sdebug_host_list)) {
2698 sdbg_host = list_entry(sdebug_host_list.prev,
2699 struct sdebug_host_info, host_list);
2700 list_del(&sdbg_host->host_list);
2702 spin_unlock(&sdebug_host_list_lock);
2707 device_unregister(&sdbg_host->dev);
2708 --scsi_debug_add_host;
2712 int scsi_debug_queuecommand(struct scsi_cmnd *SCpnt, done_funct_t done)
2714 unsigned char *cmd = (unsigned char *) SCpnt->cmnd;
2717 unsigned long long lba;
2719 int target = SCpnt->device->id;
2720 struct sdebug_dev_info *devip = NULL;
2721 int inj_recovered = 0;
2722 int inj_transport = 0;
2723 int delay_override = 0;
2725 scsi_set_resid(SCpnt, 0);
2726 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) {
2727 printk(KERN_INFO "scsi_debug: cmd ");
2728 for (k = 0, len = SCpnt->cmd_len; k < len; ++k)
2729 printk("%02x ", (int)cmd[k]);
2733 if (target == SCpnt->device->host->hostt->this_id) {
2734 printk(KERN_INFO "scsi_debug: initiator's id used as "
2736 return schedule_resp(SCpnt, NULL, done,
2737 DID_NO_CONNECT << 16, 0);
2740 if ((SCpnt->device->lun >= scsi_debug_max_luns) &&
2741 (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS))
2742 return schedule_resp(SCpnt, NULL, done,
2743 DID_NO_CONNECT << 16, 0);
2744 devip = devInfoReg(SCpnt->device);
2746 return schedule_resp(SCpnt, NULL, done,
2747 DID_NO_CONNECT << 16, 0);
2749 if ((scsi_debug_every_nth != 0) &&
2750 (++scsi_debug_cmnd_count >= abs(scsi_debug_every_nth))) {
2751 scsi_debug_cmnd_count = 0;
2752 if (scsi_debug_every_nth < -1)
2753 scsi_debug_every_nth = -1;
2754 if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
2755 return 0; /* ignore command causing timeout */
2756 else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
2757 inj_recovered = 1; /* to reads and writes below */
2758 else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts)
2759 inj_transport = 1; /* to reads and writes below */
2766 case TEST_UNIT_READY:
2768 break; /* only allowable wlun commands */
2770 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2771 printk(KERN_INFO "scsi_debug: Opcode: 0x%x "
2772 "not supported for wlun\n", *cmd);
2773 mk_sense_buffer(devip, ILLEGAL_REQUEST,
2775 errsts = check_condition_result;
2776 return schedule_resp(SCpnt, devip, done, errsts,
2782 case INQUIRY: /* mandatory, ignore unit attention */
2784 errsts = resp_inquiry(SCpnt, target, devip);
2786 case REQUEST_SENSE: /* mandatory, ignore unit attention */
2788 errsts = resp_requests(SCpnt, devip);
2790 case REZERO_UNIT: /* actually this is REWIND for SSC */
2792 errsts = resp_start_stop(SCpnt, devip);
2794 case ALLOW_MEDIUM_REMOVAL:
2795 errsts = check_readiness(SCpnt, 1, devip);
2798 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2799 printk(KERN_INFO "scsi_debug: Medium removal %s\n",
2800 cmd[4] ? "inhibited" : "enabled");
2802 case SEND_DIAGNOSTIC: /* mandatory */
2803 errsts = check_readiness(SCpnt, 1, devip);
2805 case TEST_UNIT_READY: /* mandatory */
2807 errsts = check_readiness(SCpnt, 0, devip);
2810 errsts = check_readiness(SCpnt, 1, devip);
2813 errsts = check_readiness(SCpnt, 1, devip);
2816 errsts = check_readiness(SCpnt, 1, devip);
2819 errsts = check_readiness(SCpnt, 1, devip);
2822 errsts = resp_readcap(SCpnt, devip);
2824 case SERVICE_ACTION_IN:
2825 if (SAI_READ_CAPACITY_16 != cmd[1]) {
2826 mk_sense_buffer(devip, ILLEGAL_REQUEST,
2828 errsts = check_condition_result;
2831 errsts = resp_readcap16(SCpnt, devip);
2833 case MAINTENANCE_IN:
2834 if (MI_REPORT_TARGET_PGS != cmd[1]) {
2835 mk_sense_buffer(devip, ILLEGAL_REQUEST,
2837 errsts = check_condition_result;
2840 errsts = resp_report_tgtpgs(SCpnt, devip);
2846 errsts = check_readiness(SCpnt, 0, devip);
2849 if (scsi_debug_fake_rw)
2851 get_data_transfer_info(cmd, &lba, &num);
2852 errsts = resp_read(SCpnt, lba, num, devip);
2853 if (inj_recovered && (0 == errsts)) {
2854 mk_sense_buffer(devip, RECOVERED_ERROR,
2855 THRESHOLD_EXCEEDED, 0);
2856 errsts = check_condition_result;
2857 } else if (inj_transport && (0 == errsts)) {
2858 mk_sense_buffer(devip, ABORTED_COMMAND,
2859 TRANSPORT_PROBLEM, ACK_NAK_TO);
2860 errsts = check_condition_result;
2863 case REPORT_LUNS: /* mandatory, ignore unit attention */
2865 errsts = resp_report_luns(SCpnt, devip);
2867 case VERIFY: /* 10 byte SBC-2 command */
2868 errsts = check_readiness(SCpnt, 0, devip);
2874 errsts = check_readiness(SCpnt, 0, devip);
2877 if (scsi_debug_fake_rw)
2879 get_data_transfer_info(cmd, &lba, &num);
2880 errsts = resp_write(SCpnt, lba, num, devip);
2881 if (inj_recovered && (0 == errsts)) {
2882 mk_sense_buffer(devip, RECOVERED_ERROR,
2883 THRESHOLD_EXCEEDED, 0);
2884 errsts = check_condition_result;
2889 errsts = resp_mode_sense(SCpnt, target, devip);
2892 errsts = resp_mode_select(SCpnt, 1, devip);
2894 case MODE_SELECT_10:
2895 errsts = resp_mode_select(SCpnt, 0, devip);
2898 errsts = resp_log_sense(SCpnt, devip);
2900 case SYNCHRONIZE_CACHE:
2902 errsts = check_readiness(SCpnt, 0, devip);
2905 errsts = check_readiness(SCpnt, 1, devip);
2907 case XDWRITEREAD_10:
2908 if (!scsi_bidi_cmnd(SCpnt)) {
2909 mk_sense_buffer(devip, ILLEGAL_REQUEST,
2910 INVALID_FIELD_IN_CDB, 0);
2911 errsts = check_condition_result;
2915 errsts = check_readiness(SCpnt, 0, devip);
2918 if (scsi_debug_fake_rw)
2920 get_data_transfer_info(cmd, &lba, &num);
2921 errsts = resp_read(SCpnt, lba, num, devip);
2924 errsts = resp_write(SCpnt, lba, num, devip);
2927 errsts = resp_xdwriteread(SCpnt, lba, num, devip);
2930 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2931 printk(KERN_INFO "scsi_debug: Opcode: 0x%x not "
2932 "supported\n", *cmd);
2933 errsts = check_readiness(SCpnt, 1, devip);
2935 break; /* Unit attention takes precedence */
2936 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
2937 errsts = check_condition_result;
2940 return schedule_resp(SCpnt, devip, done, errsts,
2941 (delay_override ? 0 : scsi_debug_delay));
2944 static struct scsi_host_template sdebug_driver_template = {
2945 .proc_info = scsi_debug_proc_info,
2946 .proc_name = sdebug_proc_name,
2947 .name = "SCSI DEBUG",
2948 .info = scsi_debug_info,
2949 .slave_alloc = scsi_debug_slave_alloc,
2950 .slave_configure = scsi_debug_slave_configure,
2951 .slave_destroy = scsi_debug_slave_destroy,
2952 .ioctl = scsi_debug_ioctl,
2953 .queuecommand = scsi_debug_queuecommand,
2954 .eh_abort_handler = scsi_debug_abort,
2955 .eh_bus_reset_handler = scsi_debug_bus_reset,
2956 .eh_device_reset_handler = scsi_debug_device_reset,
2957 .eh_host_reset_handler = scsi_debug_host_reset,
2958 .bios_param = scsi_debug_biosparam,
2959 .can_queue = SCSI_DEBUG_CANQUEUE,
2961 .sg_tablesize = 256,
2963 .max_sectors = 0xffff,
2964 .use_clustering = DISABLE_CLUSTERING,
2965 .module = THIS_MODULE,
2968 static int sdebug_driver_probe(struct device * dev)
2971 struct sdebug_host_info *sdbg_host;
2972 struct Scsi_Host *hpnt;
2974 sdbg_host = to_sdebug_host(dev);
2976 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
2978 printk(KERN_ERR "%s: scsi_register failed\n", __FUNCTION__);
2983 sdbg_host->shost = hpnt;
2984 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
2985 if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
2986 hpnt->max_id = scsi_debug_num_tgts + 1;
2988 hpnt->max_id = scsi_debug_num_tgts;
2989 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* = scsi_debug_max_luns; */
2991 error = scsi_add_host(hpnt, &sdbg_host->dev);
2993 printk(KERN_ERR "%s: scsi_add_host failed\n", __FUNCTION__);
2995 scsi_host_put(hpnt);
2997 scsi_scan_host(hpnt);
3003 static int sdebug_driver_remove(struct device * dev)
3005 struct sdebug_host_info *sdbg_host;
3006 struct sdebug_dev_info *sdbg_devinfo, *tmp;
3008 sdbg_host = to_sdebug_host(dev);
3011 printk(KERN_ERR "%s: Unable to locate host info\n",
3016 scsi_remove_host(sdbg_host->shost);
3018 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
3020 list_del(&sdbg_devinfo->dev_list);
3021 kfree(sdbg_devinfo);
3024 scsi_host_put(sdbg_host->shost);
3028 static int pseudo_lld_bus_match(struct device *dev,
3029 struct device_driver *dev_driver)
3034 static struct bus_type pseudo_lld_bus = {
3036 .match = pseudo_lld_bus_match,
3037 .probe = sdebug_driver_probe,
3038 .remove = sdebug_driver_remove,