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>
50 #include <linux/stat.h>
52 #include "scsi_logging.h"
54 #define SCSI_DEBUG_VERSION "1.81"
55 static const char * scsi_debug_version_date = "20070104";
57 /* Additional Sense Code (ASC) */
58 #define NO_ADDITIONAL_SENSE 0x0
59 #define LOGICAL_UNIT_NOT_READY 0x4
60 #define UNRECOVERED_READ_ERR 0x11
61 #define PARAMETER_LIST_LENGTH_ERR 0x1a
62 #define INVALID_OPCODE 0x20
63 #define ADDR_OUT_OF_RANGE 0x21
64 #define INVALID_FIELD_IN_CDB 0x24
65 #define INVALID_FIELD_IN_PARAM_LIST 0x26
66 #define POWERON_RESET 0x29
67 #define SAVING_PARAMS_UNSUP 0x39
68 #define TRANSPORT_PROBLEM 0x4b
69 #define THRESHOLD_EXCEEDED 0x5d
70 #define LOW_POWER_COND_ON 0x5e
72 /* Additional Sense Code Qualifier (ASCQ) */
73 #define ACK_NAK_TO 0x3
75 #define SDEBUG_TAGGED_QUEUING 0 /* 0 | MSG_SIMPLE_TAG | MSG_ORDERED_TAG */
77 /* Default values for driver parameters */
78 #define DEF_NUM_HOST 1
79 #define DEF_NUM_TGTS 1
80 #define DEF_MAX_LUNS 1
81 /* With these defaults, this driver will make 1 host with 1 target
82 * (id 0) containing 1 logical unit (lun 0). That is 1 device.
85 #define DEF_DEV_SIZE_MB 8
86 #define DEF_EVERY_NTH 0
87 #define DEF_NUM_PARTS 0
89 #define DEF_SCSI_LEVEL 5 /* INQUIRY, byte2 [5->SPC-3] */
92 #define DEF_NO_LUN_0 0
93 #define DEF_VIRTUAL_GB 0
95 #define DEF_VPD_USE_HOSTNO 1
97 /* bit mask values for scsi_debug_opts */
98 #define SCSI_DEBUG_OPT_NOISE 1
99 #define SCSI_DEBUG_OPT_MEDIUM_ERR 2
100 #define SCSI_DEBUG_OPT_TIMEOUT 4
101 #define SCSI_DEBUG_OPT_RECOVERED_ERR 8
102 #define SCSI_DEBUG_OPT_TRANSPORT_ERR 16
103 /* When "every_nth" > 0 then modulo "every_nth" commands:
104 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
105 * - a RECOVERED_ERROR is simulated on successful read and write
106 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
107 * - a TRANSPORT_ERROR is simulated on successful read and write
108 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
110 * When "every_nth" < 0 then after "- every_nth" commands:
111 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
112 * - a RECOVERED_ERROR is simulated on successful read and write
113 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
114 * - a TRANSPORT_ERROR is simulated on successful read and write
115 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
116 * This will continue until some other action occurs (e.g. the user
117 * writing a new value (other than -1 or 1) to every_nth via sysfs).
120 /* when 1==SCSI_DEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
121 * sector on read commands: */
122 #define OPT_MEDIUM_ERR_ADDR 0x1234 /* that's sector 4660 in decimal */
124 /* If REPORT LUNS has luns >= 256 it can choose "flat space" (value 1)
125 * or "peripheral device" addressing (value 0) */
126 #define SAM2_LUN_ADDRESS_METHOD 0
127 #define SAM2_WLUN_REPORT_LUNS 0xc101
129 static int scsi_debug_add_host = DEF_NUM_HOST;
130 static int scsi_debug_delay = DEF_DELAY;
131 static int scsi_debug_dev_size_mb = DEF_DEV_SIZE_MB;
132 static int scsi_debug_every_nth = DEF_EVERY_NTH;
133 static int scsi_debug_max_luns = DEF_MAX_LUNS;
134 static int scsi_debug_num_parts = DEF_NUM_PARTS;
135 static int scsi_debug_num_tgts = DEF_NUM_TGTS; /* targets per host */
136 static int scsi_debug_opts = DEF_OPTS;
137 static int scsi_debug_scsi_level = DEF_SCSI_LEVEL;
138 static int scsi_debug_ptype = DEF_PTYPE; /* SCSI peripheral type (0==disk) */
139 static int scsi_debug_dsense = DEF_D_SENSE;
140 static int scsi_debug_no_lun_0 = DEF_NO_LUN_0;
141 static int scsi_debug_virtual_gb = DEF_VIRTUAL_GB;
142 static int scsi_debug_fake_rw = DEF_FAKE_RW;
143 static int scsi_debug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
145 static int scsi_debug_cmnd_count = 0;
147 #define DEV_READONLY(TGT) (0)
148 #define DEV_REMOVEABLE(TGT) (0)
150 static unsigned int sdebug_store_size; /* in bytes */
151 static unsigned int sdebug_store_sectors;
152 static sector_t sdebug_capacity; /* in sectors */
154 /* old BIOS stuff, kernel may get rid of them but some mode sense pages
155 may still need them */
156 static int sdebug_heads; /* heads per disk */
157 static int sdebug_cylinders_per; /* cylinders per surface */
158 static int sdebug_sectors_per; /* sectors per cylinder */
160 /* default sector size is 512 bytes, 2**9 bytes */
161 #define POW2_SECT_SIZE 9
162 #define SECT_SIZE (1 << POW2_SECT_SIZE)
163 #define SECT_SIZE_PER(TGT) SECT_SIZE
165 #define SDEBUG_MAX_PARTS 4
167 #define SDEBUG_SENSE_LEN 32
169 #define SCSI_DEBUG_CANQUEUE 255
170 #define SCSI_DEBUG_MAX_CMD_LEN 16
172 struct sdebug_dev_info {
173 struct list_head dev_list;
174 unsigned char sense_buff[SDEBUG_SENSE_LEN]; /* weak nexus */
175 unsigned int channel;
178 struct sdebug_host_info *sdbg_host;
185 struct sdebug_host_info {
186 struct list_head host_list;
187 struct Scsi_Host *shost;
189 struct list_head dev_info_list;
192 #define to_sdebug_host(d) \
193 container_of(d, struct sdebug_host_info, dev)
195 static LIST_HEAD(sdebug_host_list);
196 static DEFINE_SPINLOCK(sdebug_host_list_lock);
198 typedef void (* done_funct_t) (struct scsi_cmnd *);
200 struct sdebug_queued_cmd {
202 struct timer_list cmnd_timer;
203 done_funct_t done_funct;
204 struct scsi_cmnd * a_cmnd;
207 static struct sdebug_queued_cmd queued_arr[SCSI_DEBUG_CANQUEUE];
209 static unsigned char * fake_storep; /* ramdisk storage */
211 static int num_aborts = 0;
212 static int num_dev_resets = 0;
213 static int num_bus_resets = 0;
214 static int num_host_resets = 0;
216 static DEFINE_SPINLOCK(queued_arr_lock);
217 static DEFINE_RWLOCK(atomic_rw);
219 static char sdebug_proc_name[] = "scsi_debug";
221 static int sdebug_driver_probe(struct device *);
222 static int sdebug_driver_remove(struct device *);
223 static struct bus_type pseudo_lld_bus;
225 static struct device_driver sdebug_driverfs_driver = {
226 .name = sdebug_proc_name,
227 .bus = &pseudo_lld_bus,
230 static const int check_condition_result =
231 (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
233 static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
235 static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
238 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev);
239 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
241 static void stop_all_queued(void);
242 static int stop_queued_cmnd(struct scsi_cmnd * cmnd);
244 static int sdebug_add_adapter(void);
245 static void sdebug_remove_adapter(void);
246 static void sdebug_max_tgts_luns(void);
248 static struct device pseudo_primary;
249 static struct bus_type pseudo_lld_bus;
251 static void get_data_transfer_info(unsigned char *cmd,
252 unsigned long long *lba, unsigned int *num)
259 for (*lba = 0, i = 0; i < 8; ++i) {
264 *num = cmd[13] + (cmd[12] << 8) +
265 (cmd[11] << 16) + (cmd[10] << 24);
269 *lba = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24);
270 *num = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
275 *lba = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24);
276 *num = cmd[8] + (cmd[7] << 8);
280 *lba = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
281 *num = (0 == cmd[4]) ? 256 : cmd[4];
288 static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
290 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
291 printk(KERN_INFO "scsi_debug: ioctl: cmd=0x%x\n", cmd);
294 /* return -ENOTTY; // correct return but upsets fdisk */
297 static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
298 struct sdebug_dev_info * devip)
301 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
302 printk(KERN_INFO "scsi_debug: Reporting Unit "
303 "attention: power on reset\n");
305 mk_sense_buffer(devip, UNIT_ATTENTION, POWERON_RESET, 0);
306 return check_condition_result;
308 if ((0 == reset_only) && devip->stopped) {
309 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
310 printk(KERN_INFO "scsi_debug: Reporting Not "
311 "ready: initializing command required\n");
312 mk_sense_buffer(devip, NOT_READY, LOGICAL_UNIT_NOT_READY,
314 return check_condition_result;
319 /* Returns 0 if ok else (DID_ERROR << 16). Sets scp->resid . */
320 static int fill_from_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
324 struct scsi_data_buffer *sdb = scsi_in(scp);
328 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE))
329 return (DID_ERROR << 16);
331 act_len = sg_copy_from_buffer(sdb->table.sgl, sdb->table.nents,
334 sdb->resid -= act_len;
336 sdb->resid = scsi_bufflen(scp) - act_len;
341 /* Returns number of bytes fetched into 'arr' or -1 if error. */
342 static int fetch_to_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
345 if (!scsi_bufflen(scp))
347 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_TO_DEVICE))
350 return scsi_sg_copy_to_buffer(scp, arr, arr_len);
354 static const char * inq_vendor_id = "Linux ";
355 static const char * inq_product_id = "scsi_debug ";
356 static const char * inq_product_rev = "0004";
358 static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
359 int target_dev_id, int dev_id_num,
360 const char * dev_id_str,
366 port_a = target_dev_id + 1;
367 /* T10 vendor identifier field format (faked) */
368 arr[0] = 0x2; /* ASCII */
371 memcpy(&arr[4], inq_vendor_id, 8);
372 memcpy(&arr[12], inq_product_id, 16);
373 memcpy(&arr[28], dev_id_str, dev_id_str_len);
374 num = 8 + 16 + dev_id_str_len;
377 if (dev_id_num >= 0) {
378 /* NAA-5, Logical unit identifier (binary) */
379 arr[num++] = 0x1; /* binary (not necessarily sas) */
380 arr[num++] = 0x3; /* PIV=0, lu, naa */
383 arr[num++] = 0x53; /* naa-5 ieee company id=0x333333 (fake) */
387 arr[num++] = (dev_id_num >> 24);
388 arr[num++] = (dev_id_num >> 16) & 0xff;
389 arr[num++] = (dev_id_num >> 8) & 0xff;
390 arr[num++] = dev_id_num & 0xff;
391 /* Target relative port number */
392 arr[num++] = 0x61; /* proto=sas, binary */
393 arr[num++] = 0x94; /* PIV=1, target port, rel port */
394 arr[num++] = 0x0; /* reserved */
395 arr[num++] = 0x4; /* length */
396 arr[num++] = 0x0; /* reserved */
397 arr[num++] = 0x0; /* reserved */
399 arr[num++] = 0x1; /* relative port A */
401 /* NAA-5, Target port identifier */
402 arr[num++] = 0x61; /* proto=sas, binary */
403 arr[num++] = 0x93; /* piv=1, target port, naa */
406 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
410 arr[num++] = (port_a >> 24);
411 arr[num++] = (port_a >> 16) & 0xff;
412 arr[num++] = (port_a >> 8) & 0xff;
413 arr[num++] = port_a & 0xff;
414 /* NAA-5, Target port group identifier */
415 arr[num++] = 0x61; /* proto=sas, binary */
416 arr[num++] = 0x95; /* piv=1, target port group id */
421 arr[num++] = (port_group_id >> 8) & 0xff;
422 arr[num++] = port_group_id & 0xff;
423 /* NAA-5, Target device identifier */
424 arr[num++] = 0x61; /* proto=sas, binary */
425 arr[num++] = 0xa3; /* piv=1, target device, naa */
428 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
432 arr[num++] = (target_dev_id >> 24);
433 arr[num++] = (target_dev_id >> 16) & 0xff;
434 arr[num++] = (target_dev_id >> 8) & 0xff;
435 arr[num++] = target_dev_id & 0xff;
436 /* SCSI name string: Target device identifier */
437 arr[num++] = 0x63; /* proto=sas, UTF-8 */
438 arr[num++] = 0xa8; /* piv=1, target device, SCSI name string */
441 memcpy(arr + num, "naa.52222220", 12);
443 snprintf(b, sizeof(b), "%08X", target_dev_id);
444 memcpy(arr + num, b, 8);
446 memset(arr + num, 0, 4);
452 static unsigned char vpd84_data[] = {
453 /* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
454 0x22,0x22,0x22,0x0,0xbb,0x1,
455 0x22,0x22,0x22,0x0,0xbb,0x2,
458 static int inquiry_evpd_84(unsigned char * arr)
460 memcpy(arr, vpd84_data, sizeof(vpd84_data));
461 return sizeof(vpd84_data);
464 static int inquiry_evpd_85(unsigned char * arr)
467 const char * na1 = "https://www.kernel.org/config";
468 const char * na2 = "http://www.kernel.org/log";
471 arr[num++] = 0x1; /* lu, storage config */
472 arr[num++] = 0x0; /* reserved */
477 plen = ((plen / 4) + 1) * 4;
478 arr[num++] = plen; /* length, null termianted, padded */
479 memcpy(arr + num, na1, olen);
480 memset(arr + num + olen, 0, plen - olen);
483 arr[num++] = 0x4; /* lu, logging */
484 arr[num++] = 0x0; /* reserved */
489 plen = ((plen / 4) + 1) * 4;
490 arr[num++] = plen; /* length, null terminated, padded */
491 memcpy(arr + num, na2, olen);
492 memset(arr + num + olen, 0, plen - olen);
498 /* SCSI ports VPD page */
499 static int inquiry_evpd_88(unsigned char * arr, int target_dev_id)
504 port_a = target_dev_id + 1;
506 arr[num++] = 0x0; /* reserved */
507 arr[num++] = 0x0; /* reserved */
509 arr[num++] = 0x1; /* relative port 1 (primary) */
510 memset(arr + num, 0, 6);
513 arr[num++] = 12; /* length tp descriptor */
514 /* naa-5 target port identifier (A) */
515 arr[num++] = 0x61; /* proto=sas, binary */
516 arr[num++] = 0x93; /* PIV=1, target port, NAA */
517 arr[num++] = 0x0; /* reserved */
518 arr[num++] = 0x8; /* length */
519 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
523 arr[num++] = (port_a >> 24);
524 arr[num++] = (port_a >> 16) & 0xff;
525 arr[num++] = (port_a >> 8) & 0xff;
526 arr[num++] = port_a & 0xff;
528 arr[num++] = 0x0; /* reserved */
529 arr[num++] = 0x0; /* reserved */
531 arr[num++] = 0x2; /* relative port 2 (secondary) */
532 memset(arr + num, 0, 6);
535 arr[num++] = 12; /* length tp descriptor */
536 /* naa-5 target port identifier (B) */
537 arr[num++] = 0x61; /* proto=sas, binary */
538 arr[num++] = 0x93; /* PIV=1, target port, NAA */
539 arr[num++] = 0x0; /* reserved */
540 arr[num++] = 0x8; /* length */
541 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
545 arr[num++] = (port_b >> 24);
546 arr[num++] = (port_b >> 16) & 0xff;
547 arr[num++] = (port_b >> 8) & 0xff;
548 arr[num++] = port_b & 0xff;
554 static unsigned char vpd89_data[] = {
555 /* from 4th byte */ 0,0,0,0,
556 'l','i','n','u','x',' ',' ',' ',
557 'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
559 0x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
561 0x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
562 0,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
563 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
564 0x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
566 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
568 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
570 0,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
571 0x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
572 0x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
573 0,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
574 0x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
575 0x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
576 0,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
577 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
578 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
579 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
580 0x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
581 0,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
582 0xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
583 0,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
584 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
585 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
586 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
587 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
588 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
589 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
590 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
591 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
592 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
593 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
594 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
595 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
598 static int inquiry_evpd_89(unsigned char * arr)
600 memcpy(arr, vpd89_data, sizeof(vpd89_data));
601 return sizeof(vpd89_data);
605 static unsigned char vpdb0_data[] = {
606 /* from 4th byte */ 0,0,0,4,
611 static int inquiry_evpd_b0(unsigned char * arr)
613 memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
614 if (sdebug_store_sectors > 0x400) {
615 arr[4] = (sdebug_store_sectors >> 24) & 0xff;
616 arr[5] = (sdebug_store_sectors >> 16) & 0xff;
617 arr[6] = (sdebug_store_sectors >> 8) & 0xff;
618 arr[7] = sdebug_store_sectors & 0xff;
620 return sizeof(vpdb0_data);
624 #define SDEBUG_LONG_INQ_SZ 96
625 #define SDEBUG_MAX_INQ_ARR_SZ 584
627 static int resp_inquiry(struct scsi_cmnd * scp, int target,
628 struct sdebug_dev_info * devip)
630 unsigned char pq_pdt;
632 unsigned char *cmd = (unsigned char *)scp->cmnd;
633 int alloc_len, n, ret;
635 alloc_len = (cmd[3] << 8) + cmd[4];
636 arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
638 return DID_REQUEUE << 16;
640 pq_pdt = 0x1e; /* present, wlun */
641 else if (scsi_debug_no_lun_0 && (0 == devip->lun))
642 pq_pdt = 0x7f; /* not present, no device type */
644 pq_pdt = (scsi_debug_ptype & 0x1f);
646 if (0x2 & cmd[1]) { /* CMDDT bit set */
647 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
650 return check_condition_result;
651 } else if (0x1 & cmd[1]) { /* EVPD bit set */
652 int lu_id_num, port_group_id, target_dev_id, len;
654 int host_no = devip->sdbg_host->shost->host_no;
656 port_group_id = (((host_no + 1) & 0x7f) << 8) +
657 (devip->channel & 0x7f);
658 if (0 == scsi_debug_vpd_use_hostno)
660 lu_id_num = devip->wlun ? -1 : (((host_no + 1) * 2000) +
661 (devip->target * 1000) + devip->lun);
662 target_dev_id = ((host_no + 1) * 2000) +
663 (devip->target * 1000) - 3;
664 len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
665 if (0 == cmd[2]) { /* supported vital product data pages */
666 arr[1] = cmd[2]; /*sanity */
668 arr[n++] = 0x0; /* this page */
669 arr[n++] = 0x80; /* unit serial number */
670 arr[n++] = 0x83; /* device identification */
671 arr[n++] = 0x84; /* software interface ident. */
672 arr[n++] = 0x85; /* management network addresses */
673 arr[n++] = 0x86; /* extended inquiry */
674 arr[n++] = 0x87; /* mode page policy */
675 arr[n++] = 0x88; /* SCSI ports */
676 arr[n++] = 0x89; /* ATA information */
677 arr[n++] = 0xb0; /* Block limits (SBC) */
678 arr[3] = n - 4; /* number of supported VPD pages */
679 } else if (0x80 == cmd[2]) { /* unit serial number */
680 arr[1] = cmd[2]; /*sanity */
682 memcpy(&arr[4], lu_id_str, len);
683 } else if (0x83 == cmd[2]) { /* device identification */
684 arr[1] = cmd[2]; /*sanity */
685 arr[3] = inquiry_evpd_83(&arr[4], port_group_id,
686 target_dev_id, lu_id_num,
688 } else if (0x84 == cmd[2]) { /* Software interface ident. */
689 arr[1] = cmd[2]; /*sanity */
690 arr[3] = inquiry_evpd_84(&arr[4]);
691 } else if (0x85 == cmd[2]) { /* Management network addresses */
692 arr[1] = cmd[2]; /*sanity */
693 arr[3] = inquiry_evpd_85(&arr[4]);
694 } else if (0x86 == cmd[2]) { /* extended inquiry */
695 arr[1] = cmd[2]; /*sanity */
696 arr[3] = 0x3c; /* number of following entries */
697 arr[4] = 0x0; /* no protection stuff */
698 arr[5] = 0x7; /* head of q, ordered + simple q's */
699 } else if (0x87 == cmd[2]) { /* mode page policy */
700 arr[1] = cmd[2]; /*sanity */
701 arr[3] = 0x8; /* number of following entries */
702 arr[4] = 0x2; /* disconnect-reconnect mp */
703 arr[6] = 0x80; /* mlus, shared */
704 arr[8] = 0x18; /* protocol specific lu */
705 arr[10] = 0x82; /* mlus, per initiator port */
706 } else if (0x88 == cmd[2]) { /* SCSI Ports */
707 arr[1] = cmd[2]; /*sanity */
708 arr[3] = inquiry_evpd_88(&arr[4], target_dev_id);
709 } else if (0x89 == cmd[2]) { /* ATA information */
710 arr[1] = cmd[2]; /*sanity */
711 n = inquiry_evpd_89(&arr[4]);
714 } else if (0xb0 == cmd[2]) { /* Block limits (SBC) */
715 arr[1] = cmd[2]; /*sanity */
716 arr[3] = inquiry_evpd_b0(&arr[4]);
718 /* Illegal request, invalid field in cdb */
719 mk_sense_buffer(devip, ILLEGAL_REQUEST,
720 INVALID_FIELD_IN_CDB, 0);
722 return check_condition_result;
724 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
725 ret = fill_from_dev_buffer(scp, arr,
726 min(len, SDEBUG_MAX_INQ_ARR_SZ));
730 /* drops through here for a standard inquiry */
731 arr[1] = DEV_REMOVEABLE(target) ? 0x80 : 0; /* Removable disk */
732 arr[2] = scsi_debug_scsi_level;
733 arr[3] = 2; /* response_data_format==2 */
734 arr[4] = SDEBUG_LONG_INQ_SZ - 5;
735 if (0 == scsi_debug_vpd_use_hostno)
736 arr[5] = 0x10; /* claim: implicit TGPS */
737 arr[6] = 0x10; /* claim: MultiP */
738 /* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
739 arr[7] = 0xa; /* claim: LINKED + CMDQUE */
740 memcpy(&arr[8], inq_vendor_id, 8);
741 memcpy(&arr[16], inq_product_id, 16);
742 memcpy(&arr[32], inq_product_rev, 4);
743 /* version descriptors (2 bytes each) follow */
744 arr[58] = 0x0; arr[59] = 0x77; /* SAM-3 ANSI */
745 arr[60] = 0x3; arr[61] = 0x14; /* SPC-3 ANSI */
747 if (scsi_debug_ptype == 0) {
748 arr[n++] = 0x3; arr[n++] = 0x3d; /* SBC-2 ANSI */
749 } else if (scsi_debug_ptype == 1) {
750 arr[n++] = 0x3; arr[n++] = 0x60; /* SSC-2 no version */
752 arr[n++] = 0xc; arr[n++] = 0xf; /* SAS-1.1 rev 10 */
753 ret = fill_from_dev_buffer(scp, arr,
754 min(alloc_len, SDEBUG_LONG_INQ_SZ));
759 static int resp_requests(struct scsi_cmnd * scp,
760 struct sdebug_dev_info * devip)
762 unsigned char * sbuff;
763 unsigned char *cmd = (unsigned char *)scp->cmnd;
764 unsigned char arr[SDEBUG_SENSE_LEN];
768 memset(arr, 0, sizeof(arr));
769 if (devip->reset == 1)
770 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
771 want_dsense = !!(cmd[1] & 1) || scsi_debug_dsense;
772 sbuff = devip->sense_buff;
773 if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
776 arr[1] = 0x0; /* NO_SENSE in sense_key */
777 arr[2] = THRESHOLD_EXCEEDED;
778 arr[3] = 0xff; /* TEST set and MRIE==6 */
781 arr[2] = 0x0; /* NO_SENSE in sense_key */
782 arr[7] = 0xa; /* 18 byte sense buffer */
783 arr[12] = THRESHOLD_EXCEEDED;
784 arr[13] = 0xff; /* TEST set and MRIE==6 */
787 memcpy(arr, sbuff, SDEBUG_SENSE_LEN);
788 if ((cmd[1] & 1) && (! scsi_debug_dsense)) {
789 /* DESC bit set and sense_buff in fixed format */
790 memset(arr, 0, sizeof(arr));
792 arr[1] = sbuff[2]; /* sense key */
793 arr[2] = sbuff[12]; /* asc */
794 arr[3] = sbuff[13]; /* ascq */
798 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
799 return fill_from_dev_buffer(scp, arr, len);
802 static int resp_start_stop(struct scsi_cmnd * scp,
803 struct sdebug_dev_info * devip)
805 unsigned char *cmd = (unsigned char *)scp->cmnd;
806 int power_cond, errsts, start;
808 if ((errsts = check_readiness(scp, 1, devip)))
810 power_cond = (cmd[4] & 0xf0) >> 4;
812 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
814 return check_condition_result;
817 if (start == devip->stopped)
818 devip->stopped = !start;
822 #define SDEBUG_READCAP_ARR_SZ 8
823 static int resp_readcap(struct scsi_cmnd * scp,
824 struct sdebug_dev_info * devip)
826 unsigned char arr[SDEBUG_READCAP_ARR_SZ];
830 if ((errsts = check_readiness(scp, 1, devip)))
832 /* following just in case virtual_gb changed */
833 if (scsi_debug_virtual_gb > 0) {
834 sdebug_capacity = 2048 * 1024;
835 sdebug_capacity *= scsi_debug_virtual_gb;
837 sdebug_capacity = sdebug_store_sectors;
838 memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
839 if (sdebug_capacity < 0xffffffff) {
840 capac = (unsigned int)sdebug_capacity - 1;
841 arr[0] = (capac >> 24);
842 arr[1] = (capac >> 16) & 0xff;
843 arr[2] = (capac >> 8) & 0xff;
844 arr[3] = capac & 0xff;
851 arr[6] = (SECT_SIZE_PER(target) >> 8) & 0xff;
852 arr[7] = SECT_SIZE_PER(target) & 0xff;
853 return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
856 #define SDEBUG_READCAP16_ARR_SZ 32
857 static int resp_readcap16(struct scsi_cmnd * scp,
858 struct sdebug_dev_info * devip)
860 unsigned char *cmd = (unsigned char *)scp->cmnd;
861 unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
862 unsigned long long capac;
863 int errsts, k, alloc_len;
865 if ((errsts = check_readiness(scp, 1, devip)))
867 alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8)
869 /* following just in case virtual_gb changed */
870 if (scsi_debug_virtual_gb > 0) {
871 sdebug_capacity = 2048 * 1024;
872 sdebug_capacity *= scsi_debug_virtual_gb;
874 sdebug_capacity = sdebug_store_sectors;
875 memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
876 capac = sdebug_capacity - 1;
877 for (k = 0; k < 8; ++k, capac >>= 8)
878 arr[7 - k] = capac & 0xff;
879 arr[8] = (SECT_SIZE_PER(target) >> 24) & 0xff;
880 arr[9] = (SECT_SIZE_PER(target) >> 16) & 0xff;
881 arr[10] = (SECT_SIZE_PER(target) >> 8) & 0xff;
882 arr[11] = SECT_SIZE_PER(target) & 0xff;
883 return fill_from_dev_buffer(scp, arr,
884 min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
887 #define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
889 static int resp_report_tgtpgs(struct scsi_cmnd * scp,
890 struct sdebug_dev_info * devip)
892 unsigned char *cmd = (unsigned char *)scp->cmnd;
894 int host_no = devip->sdbg_host->shost->host_no;
895 int n, ret, alen, rlen;
896 int port_group_a, port_group_b, port_a, port_b;
898 alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8)
901 arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
903 return DID_REQUEUE << 16;
905 * EVPD page 0x88 states we have two ports, one
906 * real and a fake port with no device connected.
907 * So we create two port groups with one port each
908 * and set the group with port B to unavailable.
910 port_a = 0x1; /* relative port A */
911 port_b = 0x2; /* relative port B */
912 port_group_a = (((host_no + 1) & 0x7f) << 8) +
913 (devip->channel & 0x7f);
914 port_group_b = (((host_no + 1) & 0x7f) << 8) +
915 (devip->channel & 0x7f) + 0x80;
918 * The asymmetric access state is cycled according to the host_id.
921 if (0 == scsi_debug_vpd_use_hostno) {
922 arr[n++] = host_no % 3; /* Asymm access state */
923 arr[n++] = 0x0F; /* claim: all states are supported */
925 arr[n++] = 0x0; /* Active/Optimized path */
926 arr[n++] = 0x01; /* claim: only support active/optimized paths */
928 arr[n++] = (port_group_a >> 8) & 0xff;
929 arr[n++] = port_group_a & 0xff;
930 arr[n++] = 0; /* Reserved */
931 arr[n++] = 0; /* Status code */
932 arr[n++] = 0; /* Vendor unique */
933 arr[n++] = 0x1; /* One port per group */
934 arr[n++] = 0; /* Reserved */
935 arr[n++] = 0; /* Reserved */
936 arr[n++] = (port_a >> 8) & 0xff;
937 arr[n++] = port_a & 0xff;
938 arr[n++] = 3; /* Port unavailable */
939 arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
940 arr[n++] = (port_group_b >> 8) & 0xff;
941 arr[n++] = port_group_b & 0xff;
942 arr[n++] = 0; /* Reserved */
943 arr[n++] = 0; /* Status code */
944 arr[n++] = 0; /* Vendor unique */
945 arr[n++] = 0x1; /* One port per group */
946 arr[n++] = 0; /* Reserved */
947 arr[n++] = 0; /* Reserved */
948 arr[n++] = (port_b >> 8) & 0xff;
949 arr[n++] = port_b & 0xff;
952 arr[0] = (rlen >> 24) & 0xff;
953 arr[1] = (rlen >> 16) & 0xff;
954 arr[2] = (rlen >> 8) & 0xff;
955 arr[3] = rlen & 0xff;
958 * Return the smallest value of either
959 * - The allocated length
960 * - The constructed command length
961 * - The maximum array size
964 ret = fill_from_dev_buffer(scp, arr,
965 min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
970 /* <<Following mode page info copied from ST318451LW>> */
972 static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
973 { /* Read-Write Error Recovery page for mode_sense */
974 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
977 memcpy(p, err_recov_pg, sizeof(err_recov_pg));
979 memset(p + 2, 0, sizeof(err_recov_pg) - 2);
980 return sizeof(err_recov_pg);
983 static int resp_disconnect_pg(unsigned char * p, int pcontrol, int target)
984 { /* Disconnect-Reconnect page for mode_sense */
985 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
986 0, 0, 0, 0, 0, 0, 0, 0};
988 memcpy(p, disconnect_pg, sizeof(disconnect_pg));
990 memset(p + 2, 0, sizeof(disconnect_pg) - 2);
991 return sizeof(disconnect_pg);
994 static int resp_format_pg(unsigned char * p, int pcontrol, int target)
995 { /* Format device page for mode_sense */
996 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
997 0, 0, 0, 0, 0, 0, 0, 0,
998 0, 0, 0, 0, 0x40, 0, 0, 0};
1000 memcpy(p, format_pg, sizeof(format_pg));
1001 p[10] = (sdebug_sectors_per >> 8) & 0xff;
1002 p[11] = sdebug_sectors_per & 0xff;
1003 p[12] = (SECT_SIZE >> 8) & 0xff;
1004 p[13] = SECT_SIZE & 0xff;
1005 if (DEV_REMOVEABLE(target))
1006 p[20] |= 0x20; /* should agree with INQUIRY */
1008 memset(p + 2, 0, sizeof(format_pg) - 2);
1009 return sizeof(format_pg);
1012 static int resp_caching_pg(unsigned char * p, int pcontrol, int target)
1013 { /* Caching page for mode_sense */
1014 unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1015 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
1017 memcpy(p, caching_pg, sizeof(caching_pg));
1019 memset(p + 2, 0, sizeof(caching_pg) - 2);
1020 return sizeof(caching_pg);
1023 static int resp_ctrl_m_pg(unsigned char * p, int pcontrol, int target)
1024 { /* Control mode page for mode_sense */
1025 unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
1027 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1030 if (scsi_debug_dsense)
1031 ctrl_m_pg[2] |= 0x4;
1033 ctrl_m_pg[2] &= ~0x4;
1034 memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
1036 memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
1037 else if (2 == pcontrol)
1038 memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
1039 return sizeof(ctrl_m_pg);
1043 static int resp_iec_m_pg(unsigned char * p, int pcontrol, int target)
1044 { /* Informational Exceptions control mode page for mode_sense */
1045 unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
1047 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1050 memcpy(p, iec_m_pg, sizeof(iec_m_pg));
1052 memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
1053 else if (2 == pcontrol)
1054 memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
1055 return sizeof(iec_m_pg);
1058 static int resp_sas_sf_m_pg(unsigned char * p, int pcontrol, int target)
1059 { /* SAS SSP mode page - short format for mode_sense */
1060 unsigned char sas_sf_m_pg[] = {0x19, 0x6,
1061 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
1063 memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
1065 memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
1066 return sizeof(sas_sf_m_pg);
1070 static int resp_sas_pcd_m_spg(unsigned char * p, int pcontrol, int target,
1072 { /* SAS phy control and discover mode page for mode_sense */
1073 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
1074 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
1075 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1076 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1077 0x2, 0, 0, 0, 0, 0, 0, 0,
1078 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1079 0, 0, 0, 0, 0, 0, 0, 0,
1080 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
1081 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1082 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1083 0x3, 0, 0, 0, 0, 0, 0, 0,
1084 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1085 0, 0, 0, 0, 0, 0, 0, 0,
1089 port_a = target_dev_id + 1;
1090 port_b = port_a + 1;
1091 memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
1092 p[20] = (port_a >> 24);
1093 p[21] = (port_a >> 16) & 0xff;
1094 p[22] = (port_a >> 8) & 0xff;
1095 p[23] = port_a & 0xff;
1096 p[48 + 20] = (port_b >> 24);
1097 p[48 + 21] = (port_b >> 16) & 0xff;
1098 p[48 + 22] = (port_b >> 8) & 0xff;
1099 p[48 + 23] = port_b & 0xff;
1101 memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
1102 return sizeof(sas_pcd_m_pg);
1105 static int resp_sas_sha_m_spg(unsigned char * p, int pcontrol)
1106 { /* SAS SSP shared protocol specific port mode subpage */
1107 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
1108 0, 0, 0, 0, 0, 0, 0, 0,
1111 memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
1113 memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
1114 return sizeof(sas_sha_m_pg);
1117 #define SDEBUG_MAX_MSENSE_SZ 256
1119 static int resp_mode_sense(struct scsi_cmnd * scp, int target,
1120 struct sdebug_dev_info * devip)
1122 unsigned char dbd, llbaa;
1123 int pcontrol, pcode, subpcode, bd_len;
1124 unsigned char dev_spec;
1125 int k, alloc_len, msense_6, offset, len, errsts, target_dev_id;
1127 unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
1128 unsigned char *cmd = (unsigned char *)scp->cmnd;
1130 if ((errsts = check_readiness(scp, 1, devip)))
1132 dbd = !!(cmd[1] & 0x8);
1133 pcontrol = (cmd[2] & 0xc0) >> 6;
1134 pcode = cmd[2] & 0x3f;
1136 msense_6 = (MODE_SENSE == cmd[0]);
1137 llbaa = msense_6 ? 0 : !!(cmd[1] & 0x10);
1138 if ((0 == scsi_debug_ptype) && (0 == dbd))
1139 bd_len = llbaa ? 16 : 8;
1142 alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]);
1143 memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
1144 if (0x3 == pcontrol) { /* Saving values not supported */
1145 mk_sense_buffer(devip, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP,
1147 return check_condition_result;
1149 target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
1150 (devip->target * 1000) - 3;
1151 /* set DPOFUA bit for disks */
1152 if (0 == scsi_debug_ptype)
1153 dev_spec = (DEV_READONLY(target) ? 0x80 : 0x0) | 0x10;
1163 arr[4] = 0x1; /* set LONGLBA bit */
1164 arr[7] = bd_len; /* assume 255 or less */
1168 if ((bd_len > 0) && (0 == sdebug_capacity)) {
1169 if (scsi_debug_virtual_gb > 0) {
1170 sdebug_capacity = 2048 * 1024;
1171 sdebug_capacity *= scsi_debug_virtual_gb;
1173 sdebug_capacity = sdebug_store_sectors;
1176 if (sdebug_capacity > 0xfffffffe) {
1182 ap[0] = (sdebug_capacity >> 24) & 0xff;
1183 ap[1] = (sdebug_capacity >> 16) & 0xff;
1184 ap[2] = (sdebug_capacity >> 8) & 0xff;
1185 ap[3] = sdebug_capacity & 0xff;
1187 ap[6] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1188 ap[7] = SECT_SIZE_PER(target) & 0xff;
1191 } else if (16 == bd_len) {
1192 unsigned long long capac = sdebug_capacity;
1194 for (k = 0; k < 8; ++k, capac >>= 8)
1195 ap[7 - k] = capac & 0xff;
1196 ap[12] = (SECT_SIZE_PER(target) >> 24) & 0xff;
1197 ap[13] = (SECT_SIZE_PER(target) >> 16) & 0xff;
1198 ap[14] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1199 ap[15] = SECT_SIZE_PER(target) & 0xff;
1204 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
1205 /* TODO: Control Extension page */
1206 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1208 return check_condition_result;
1211 case 0x1: /* Read-Write error recovery page, direct access */
1212 len = resp_err_recov_pg(ap, pcontrol, target);
1215 case 0x2: /* Disconnect-Reconnect page, all devices */
1216 len = resp_disconnect_pg(ap, pcontrol, target);
1219 case 0x3: /* Format device page, direct access */
1220 len = resp_format_pg(ap, pcontrol, target);
1223 case 0x8: /* Caching page, direct access */
1224 len = resp_caching_pg(ap, pcontrol, target);
1227 case 0xa: /* Control Mode page, all devices */
1228 len = resp_ctrl_m_pg(ap, pcontrol, target);
1231 case 0x19: /* if spc==1 then sas phy, control+discover */
1232 if ((subpcode > 0x2) && (subpcode < 0xff)) {
1233 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1234 INVALID_FIELD_IN_CDB, 0);
1235 return check_condition_result;
1238 if ((0x0 == subpcode) || (0xff == subpcode))
1239 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1240 if ((0x1 == subpcode) || (0xff == subpcode))
1241 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
1243 if ((0x2 == subpcode) || (0xff == subpcode))
1244 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1247 case 0x1c: /* Informational Exceptions Mode page, all devices */
1248 len = resp_iec_m_pg(ap, pcontrol, target);
1251 case 0x3f: /* Read all Mode pages */
1252 if ((0 == subpcode) || (0xff == subpcode)) {
1253 len = resp_err_recov_pg(ap, pcontrol, target);
1254 len += resp_disconnect_pg(ap + len, pcontrol, target);
1255 len += resp_format_pg(ap + len, pcontrol, target);
1256 len += resp_caching_pg(ap + len, pcontrol, target);
1257 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
1258 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1259 if (0xff == subpcode) {
1260 len += resp_sas_pcd_m_spg(ap + len, pcontrol,
1261 target, target_dev_id);
1262 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1264 len += resp_iec_m_pg(ap + len, pcontrol, target);
1266 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1267 INVALID_FIELD_IN_CDB, 0);
1268 return check_condition_result;
1273 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1275 return check_condition_result;
1278 arr[0] = offset - 1;
1280 arr[0] = ((offset - 2) >> 8) & 0xff;
1281 arr[1] = (offset - 2) & 0xff;
1283 return fill_from_dev_buffer(scp, arr, min(alloc_len, offset));
1286 #define SDEBUG_MAX_MSELECT_SZ 512
1288 static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
1289 struct sdebug_dev_info * devip)
1291 int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
1292 int param_len, res, errsts, mpage;
1293 unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
1294 unsigned char *cmd = (unsigned char *)scp->cmnd;
1296 if ((errsts = check_readiness(scp, 1, devip)))
1298 memset(arr, 0, sizeof(arr));
1301 param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]);
1302 if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
1303 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1304 INVALID_FIELD_IN_CDB, 0);
1305 return check_condition_result;
1307 res = fetch_to_dev_buffer(scp, arr, param_len);
1309 return (DID_ERROR << 16);
1310 else if ((res < param_len) &&
1311 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1312 printk(KERN_INFO "scsi_debug: mode_select: cdb indicated=%d, "
1313 " IO sent=%d bytes\n", param_len, res);
1314 md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2);
1315 bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]);
1317 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1318 INVALID_FIELD_IN_PARAM_LIST, 0);
1319 return check_condition_result;
1321 off = bd_len + (mselect6 ? 4 : 8);
1322 mpage = arr[off] & 0x3f;
1323 ps = !!(arr[off] & 0x80);
1325 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1326 INVALID_FIELD_IN_PARAM_LIST, 0);
1327 return check_condition_result;
1329 spf = !!(arr[off] & 0x40);
1330 pg_len = spf ? ((arr[off + 2] << 8) + arr[off + 3] + 4) :
1332 if ((pg_len + off) > param_len) {
1333 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1334 PARAMETER_LIST_LENGTH_ERR, 0);
1335 return check_condition_result;
1338 case 0xa: /* Control Mode page */
1339 if (ctrl_m_pg[1] == arr[off + 1]) {
1340 memcpy(ctrl_m_pg + 2, arr + off + 2,
1341 sizeof(ctrl_m_pg) - 2);
1342 scsi_debug_dsense = !!(ctrl_m_pg[2] & 0x4);
1346 case 0x1c: /* Informational Exceptions Mode page */
1347 if (iec_m_pg[1] == arr[off + 1]) {
1348 memcpy(iec_m_pg + 2, arr + off + 2,
1349 sizeof(iec_m_pg) - 2);
1356 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1357 INVALID_FIELD_IN_PARAM_LIST, 0);
1358 return check_condition_result;
1361 static int resp_temp_l_pg(unsigned char * arr)
1363 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
1364 0x0, 0x1, 0x3, 0x2, 0x0, 65,
1367 memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
1368 return sizeof(temp_l_pg);
1371 static int resp_ie_l_pg(unsigned char * arr)
1373 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
1376 memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
1377 if (iec_m_pg[2] & 0x4) { /* TEST bit set */
1378 arr[4] = THRESHOLD_EXCEEDED;
1381 return sizeof(ie_l_pg);
1384 #define SDEBUG_MAX_LSENSE_SZ 512
1386 static int resp_log_sense(struct scsi_cmnd * scp,
1387 struct sdebug_dev_info * devip)
1389 int ppc, sp, pcontrol, pcode, subpcode, alloc_len, errsts, len, n;
1390 unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
1391 unsigned char *cmd = (unsigned char *)scp->cmnd;
1393 if ((errsts = check_readiness(scp, 1, devip)))
1395 memset(arr, 0, sizeof(arr));
1399 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1400 INVALID_FIELD_IN_CDB, 0);
1401 return check_condition_result;
1403 pcontrol = (cmd[2] & 0xc0) >> 6;
1404 pcode = cmd[2] & 0x3f;
1405 subpcode = cmd[3] & 0xff;
1406 alloc_len = (cmd[7] << 8) + cmd[8];
1408 if (0 == subpcode) {
1410 case 0x0: /* Supported log pages log page */
1412 arr[n++] = 0x0; /* this page */
1413 arr[n++] = 0xd; /* Temperature */
1414 arr[n++] = 0x2f; /* Informational exceptions */
1417 case 0xd: /* Temperature log page */
1418 arr[3] = resp_temp_l_pg(arr + 4);
1420 case 0x2f: /* Informational exceptions log page */
1421 arr[3] = resp_ie_l_pg(arr + 4);
1424 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1425 INVALID_FIELD_IN_CDB, 0);
1426 return check_condition_result;
1428 } else if (0xff == subpcode) {
1432 case 0x0: /* Supported log pages and subpages log page */
1435 arr[n++] = 0x0; /* 0,0 page */
1437 arr[n++] = 0xff; /* this page */
1439 arr[n++] = 0x0; /* Temperature */
1441 arr[n++] = 0x0; /* Informational exceptions */
1444 case 0xd: /* Temperature subpages */
1447 arr[n++] = 0x0; /* Temperature */
1450 case 0x2f: /* Informational exceptions subpages */
1453 arr[n++] = 0x0; /* Informational exceptions */
1457 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1458 INVALID_FIELD_IN_CDB, 0);
1459 return check_condition_result;
1462 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1463 INVALID_FIELD_IN_CDB, 0);
1464 return check_condition_result;
1466 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
1467 return fill_from_dev_buffer(scp, arr,
1468 min(len, SDEBUG_MAX_INQ_ARR_SZ));
1471 static int resp_read(struct scsi_cmnd * SCpnt, unsigned long long lba,
1472 unsigned int num, struct sdebug_dev_info * devip)
1474 unsigned long iflags;
1475 unsigned int block, from_bottom;
1476 unsigned long long u;
1479 if (lba + num > sdebug_capacity) {
1480 mk_sense_buffer(devip, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE,
1482 return check_condition_result;
1484 /* transfer length excessive (tie in to block limits VPD page) */
1485 if (num > sdebug_store_sectors) {
1486 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1488 return check_condition_result;
1490 if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) &&
1491 (lba <= OPT_MEDIUM_ERR_ADDR) &&
1492 ((lba + num) > OPT_MEDIUM_ERR_ADDR)) {
1493 /* claim unrecoverable read error */
1494 mk_sense_buffer(devip, MEDIUM_ERROR, UNRECOVERED_READ_ERR,
1496 /* set info field and valid bit for fixed descriptor */
1497 if (0x70 == (devip->sense_buff[0] & 0x7f)) {
1498 devip->sense_buff[0] |= 0x80; /* Valid bit */
1499 ret = OPT_MEDIUM_ERR_ADDR;
1500 devip->sense_buff[3] = (ret >> 24) & 0xff;
1501 devip->sense_buff[4] = (ret >> 16) & 0xff;
1502 devip->sense_buff[5] = (ret >> 8) & 0xff;
1503 devip->sense_buff[6] = ret & 0xff;
1505 return check_condition_result;
1507 read_lock_irqsave(&atomic_rw, iflags);
1508 if ((lba + num) <= sdebug_store_sectors)
1509 ret = fill_from_dev_buffer(SCpnt,
1510 fake_storep + (lba * SECT_SIZE),
1513 /* modulo when one arg is 64 bits needs do_div() */
1515 block = do_div(u, sdebug_store_sectors);
1517 if ((block + num) > sdebug_store_sectors)
1518 from_bottom = (block + num) - sdebug_store_sectors;
1519 ret = fill_from_dev_buffer(SCpnt,
1520 fake_storep + (block * SECT_SIZE),
1521 (num - from_bottom) * SECT_SIZE);
1522 if ((0 == ret) && (from_bottom > 0))
1523 ret = fill_from_dev_buffer(SCpnt, fake_storep,
1524 from_bottom * SECT_SIZE);
1526 read_unlock_irqrestore(&atomic_rw, iflags);
1530 static int resp_write(struct scsi_cmnd * SCpnt, unsigned long long lba,
1531 unsigned int num, struct sdebug_dev_info * devip)
1533 unsigned long iflags;
1534 unsigned int block, to_bottom;
1535 unsigned long long u;
1538 if (lba + num > sdebug_capacity) {
1539 mk_sense_buffer(devip, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE,
1541 return check_condition_result;
1543 /* transfer length excessive (tie in to block limits VPD page) */
1544 if (num > sdebug_store_sectors) {
1545 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1547 return check_condition_result;
1550 write_lock_irqsave(&atomic_rw, iflags);
1551 if ((lba + num) <= sdebug_store_sectors)
1552 res = fetch_to_dev_buffer(SCpnt,
1553 fake_storep + (lba * SECT_SIZE),
1556 /* modulo when one arg is 64 bits needs do_div() */
1558 block = do_div(u, sdebug_store_sectors);
1560 if ((block + num) > sdebug_store_sectors)
1561 to_bottom = (block + num) - sdebug_store_sectors;
1562 res = fetch_to_dev_buffer(SCpnt,
1563 fake_storep + (block * SECT_SIZE),
1564 (num - to_bottom) * SECT_SIZE);
1565 if ((0 == res) && (to_bottom > 0))
1566 res = fetch_to_dev_buffer(SCpnt, fake_storep,
1567 to_bottom * SECT_SIZE);
1569 write_unlock_irqrestore(&atomic_rw, iflags);
1571 return (DID_ERROR << 16);
1572 else if ((res < (num * SECT_SIZE)) &&
1573 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1574 printk(KERN_INFO "scsi_debug: write: cdb indicated=%u, "
1575 " IO sent=%d bytes\n", num * SECT_SIZE, res);
1579 #define SDEBUG_RLUN_ARR_SZ 256
1581 static int resp_report_luns(struct scsi_cmnd * scp,
1582 struct sdebug_dev_info * devip)
1584 unsigned int alloc_len;
1585 int lun_cnt, i, upper, num, n, wlun, lun;
1586 unsigned char *cmd = (unsigned char *)scp->cmnd;
1587 int select_report = (int)cmd[2];
1588 struct scsi_lun *one_lun;
1589 unsigned char arr[SDEBUG_RLUN_ARR_SZ];
1590 unsigned char * max_addr;
1592 alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
1593 if ((alloc_len < 4) || (select_report > 2)) {
1594 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1596 return check_condition_result;
1598 /* can produce response with up to 16k luns (lun 0 to lun 16383) */
1599 memset(arr, 0, SDEBUG_RLUN_ARR_SZ);
1600 lun_cnt = scsi_debug_max_luns;
1601 if (1 == select_report)
1603 else if (scsi_debug_no_lun_0 && (lun_cnt > 0))
1605 wlun = (select_report > 0) ? 1 : 0;
1606 num = lun_cnt + wlun;
1607 arr[2] = ((sizeof(struct scsi_lun) * num) >> 8) & 0xff;
1608 arr[3] = (sizeof(struct scsi_lun) * num) & 0xff;
1609 n = min((int)((SDEBUG_RLUN_ARR_SZ - 8) /
1610 sizeof(struct scsi_lun)), num);
1615 one_lun = (struct scsi_lun *) &arr[8];
1616 max_addr = arr + SDEBUG_RLUN_ARR_SZ;
1617 for (i = 0, lun = (scsi_debug_no_lun_0 ? 1 : 0);
1618 ((i < lun_cnt) && ((unsigned char *)(one_lun + i) < max_addr));
1620 upper = (lun >> 8) & 0x3f;
1622 one_lun[i].scsi_lun[0] =
1623 (upper | (SAM2_LUN_ADDRESS_METHOD << 6));
1624 one_lun[i].scsi_lun[1] = lun & 0xff;
1627 one_lun[i].scsi_lun[0] = (SAM2_WLUN_REPORT_LUNS >> 8) & 0xff;
1628 one_lun[i].scsi_lun[1] = SAM2_WLUN_REPORT_LUNS & 0xff;
1631 alloc_len = (unsigned char *)(one_lun + i) - arr;
1632 return fill_from_dev_buffer(scp, arr,
1633 min((int)alloc_len, SDEBUG_RLUN_ARR_SZ));
1636 static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
1637 unsigned int num, struct sdebug_dev_info *devip)
1640 unsigned char *kaddr, *buf;
1641 unsigned int offset;
1642 struct scatterlist *sg;
1643 struct scsi_data_buffer *sdb = scsi_in(scp);
1645 /* better not to use temporary buffer. */
1646 buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
1650 scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
1653 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, i) {
1654 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
1658 for (j = 0; j < sg->length; j++)
1659 *(kaddr + sg->offset + j) ^= *(buf + offset + j);
1661 offset += sg->length;
1662 kunmap_atomic(kaddr, KM_USER0);
1671 /* When timer goes off this function is called. */
1672 static void timer_intr_handler(unsigned long indx)
1674 struct sdebug_queued_cmd * sqcp;
1675 unsigned long iflags;
1677 if (indx >= SCSI_DEBUG_CANQUEUE) {
1678 printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too "
1682 spin_lock_irqsave(&queued_arr_lock, iflags);
1683 sqcp = &queued_arr[(int)indx];
1684 if (! sqcp->in_use) {
1685 printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected "
1687 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1691 if (sqcp->done_funct) {
1692 sqcp->a_cmnd->result = sqcp->scsi_result;
1693 sqcp->done_funct(sqcp->a_cmnd); /* callback to mid level */
1695 sqcp->done_funct = NULL;
1696 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1699 static int scsi_debug_slave_alloc(struct scsi_device * sdp)
1701 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1702 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
1703 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
1704 set_bit(QUEUE_FLAG_BIDI, &sdp->request_queue->queue_flags);
1708 static int scsi_debug_slave_configure(struct scsi_device * sdp)
1710 struct sdebug_dev_info * devip;
1712 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1713 printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n",
1714 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
1715 if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN)
1716 sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN;
1717 devip = devInfoReg(sdp);
1719 return 1; /* no resources, will be marked offline */
1720 sdp->hostdata = devip;
1721 if (sdp->host->cmd_per_lun)
1722 scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING,
1723 sdp->host->cmd_per_lun);
1724 blk_queue_max_segment_size(sdp->request_queue, 256 * 1024);
1728 static void scsi_debug_slave_destroy(struct scsi_device * sdp)
1730 struct sdebug_dev_info * devip =
1731 (struct sdebug_dev_info *)sdp->hostdata;
1733 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1734 printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n",
1735 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
1737 /* make this slot avaliable for re-use */
1739 sdp->hostdata = NULL;
1743 struct sdebug_dev_info *sdebug_device_create(struct sdebug_host_info *sdbg_host,
1746 struct sdebug_dev_info *devip;
1748 devip = kzalloc(sizeof(*devip), flags);
1750 devip->sdbg_host = sdbg_host;
1751 list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
1756 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
1758 struct sdebug_host_info * sdbg_host;
1759 struct sdebug_dev_info * open_devip = NULL;
1760 struct sdebug_dev_info * devip =
1761 (struct sdebug_dev_info *)sdev->hostdata;
1765 sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
1767 printk(KERN_ERR "Host info NULL\n");
1770 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
1771 if ((devip->used) && (devip->channel == sdev->channel) &&
1772 (devip->target == sdev->id) &&
1773 (devip->lun == sdev->lun))
1776 if ((!devip->used) && (!open_devip))
1780 if (!open_devip) { /* try and make a new one */
1781 open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC);
1783 printk(KERN_ERR "%s: out of memory at line %d\n",
1784 __FUNCTION__, __LINE__);
1789 open_devip->channel = sdev->channel;
1790 open_devip->target = sdev->id;
1791 open_devip->lun = sdev->lun;
1792 open_devip->sdbg_host = sdbg_host;
1793 open_devip->reset = 1;
1794 open_devip->used = 1;
1795 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
1796 if (scsi_debug_dsense)
1797 open_devip->sense_buff[0] = 0x72;
1799 open_devip->sense_buff[0] = 0x70;
1800 open_devip->sense_buff[7] = 0xa;
1802 if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
1803 open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
1808 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
1811 unsigned char * sbuff;
1813 sbuff = devip->sense_buff;
1814 memset(sbuff, 0, SDEBUG_SENSE_LEN);
1815 if (scsi_debug_dsense) {
1816 sbuff[0] = 0x72; /* descriptor, current */
1821 sbuff[0] = 0x70; /* fixed, current */
1823 sbuff[7] = 0xa; /* implies 18 byte sense buffer */
1827 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1828 printk(KERN_INFO "scsi_debug: [sense_key,asc,ascq]: "
1829 "[0x%x,0x%x,0x%x]\n", key, asc, asq);
1832 static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
1834 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1835 printk(KERN_INFO "scsi_debug: abort\n");
1837 stop_queued_cmnd(SCpnt);
1841 static int scsi_debug_biosparam(struct scsi_device *sdev,
1842 struct block_device * bdev, sector_t capacity, int *info)
1847 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1848 printk(KERN_INFO "scsi_debug: biosparam\n");
1849 buf = scsi_bios_ptable(bdev);
1851 res = scsi_partsize(buf, capacity,
1852 &info[2], &info[0], &info[1]);
1857 info[0] = sdebug_heads;
1858 info[1] = sdebug_sectors_per;
1859 info[2] = sdebug_cylinders_per;
1863 static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
1865 struct sdebug_dev_info * devip;
1867 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1868 printk(KERN_INFO "scsi_debug: device_reset\n");
1871 devip = devInfoReg(SCpnt->device);
1878 static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
1880 struct sdebug_host_info *sdbg_host;
1881 struct sdebug_dev_info * dev_info;
1882 struct scsi_device * sdp;
1883 struct Scsi_Host * hp;
1885 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1886 printk(KERN_INFO "scsi_debug: bus_reset\n");
1888 if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
1889 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
1891 list_for_each_entry(dev_info,
1892 &sdbg_host->dev_info_list,
1894 dev_info->reset = 1;
1900 static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
1902 struct sdebug_host_info * sdbg_host;
1903 struct sdebug_dev_info * dev_info;
1905 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1906 printk(KERN_INFO "scsi_debug: host_reset\n");
1908 spin_lock(&sdebug_host_list_lock);
1909 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
1910 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
1912 dev_info->reset = 1;
1914 spin_unlock(&sdebug_host_list_lock);
1919 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
1920 static int stop_queued_cmnd(struct scsi_cmnd * cmnd)
1922 unsigned long iflags;
1924 struct sdebug_queued_cmd * sqcp;
1926 spin_lock_irqsave(&queued_arr_lock, iflags);
1927 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
1928 sqcp = &queued_arr[k];
1929 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
1930 del_timer_sync(&sqcp->cmnd_timer);
1932 sqcp->a_cmnd = NULL;
1936 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1937 return (k < SCSI_DEBUG_CANQUEUE) ? 1 : 0;
1940 /* Deletes (stops) timers of all queued commands */
1941 static void stop_all_queued(void)
1943 unsigned long iflags;
1945 struct sdebug_queued_cmd * sqcp;
1947 spin_lock_irqsave(&queued_arr_lock, iflags);
1948 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
1949 sqcp = &queued_arr[k];
1950 if (sqcp->in_use && sqcp->a_cmnd) {
1951 del_timer_sync(&sqcp->cmnd_timer);
1953 sqcp->a_cmnd = NULL;
1956 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1959 /* Initializes timers in queued array */
1960 static void __init init_all_queued(void)
1962 unsigned long iflags;
1964 struct sdebug_queued_cmd * sqcp;
1966 spin_lock_irqsave(&queued_arr_lock, iflags);
1967 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
1968 sqcp = &queued_arr[k];
1969 init_timer(&sqcp->cmnd_timer);
1971 sqcp->a_cmnd = NULL;
1973 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1976 static void __init sdebug_build_parts(unsigned char * ramp)
1978 struct partition * pp;
1979 int starts[SDEBUG_MAX_PARTS + 2];
1980 int sectors_per_part, num_sectors, k;
1981 int heads_by_sects, start_sec, end_sec;
1983 /* assume partition table already zeroed */
1984 if ((scsi_debug_num_parts < 1) || (sdebug_store_size < 1048576))
1986 if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
1987 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
1988 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
1989 "partitions to %d\n", SDEBUG_MAX_PARTS);
1991 num_sectors = (int)sdebug_store_sectors;
1992 sectors_per_part = (num_sectors - sdebug_sectors_per)
1993 / scsi_debug_num_parts;
1994 heads_by_sects = sdebug_heads * sdebug_sectors_per;
1995 starts[0] = sdebug_sectors_per;
1996 for (k = 1; k < scsi_debug_num_parts; ++k)
1997 starts[k] = ((k * sectors_per_part) / heads_by_sects)
1999 starts[scsi_debug_num_parts] = num_sectors;
2000 starts[scsi_debug_num_parts + 1] = 0;
2002 ramp[510] = 0x55; /* magic partition markings */
2004 pp = (struct partition *)(ramp + 0x1be);
2005 for (k = 0; starts[k + 1]; ++k, ++pp) {
2006 start_sec = starts[k];
2007 end_sec = starts[k + 1] - 1;
2010 pp->cyl = start_sec / heads_by_sects;
2011 pp->head = (start_sec - (pp->cyl * heads_by_sects))
2012 / sdebug_sectors_per;
2013 pp->sector = (start_sec % sdebug_sectors_per) + 1;
2015 pp->end_cyl = end_sec / heads_by_sects;
2016 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
2017 / sdebug_sectors_per;
2018 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2020 pp->start_sect = start_sec;
2021 pp->nr_sects = end_sec - start_sec + 1;
2022 pp->sys_ind = 0x83; /* plain Linux partition */
2026 static int schedule_resp(struct scsi_cmnd * cmnd,
2027 struct sdebug_dev_info * devip,
2028 done_funct_t done, int scsi_result, int delta_jiff)
2030 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
2032 struct scsi_device * sdp = cmnd->device;
2034 printk(KERN_INFO "scsi_debug: <%u %u %u %u> "
2035 "non-zero result=0x%x\n", sdp->host->host_no,
2036 sdp->channel, sdp->id, sdp->lun, scsi_result);
2039 if (cmnd && devip) {
2040 /* simulate autosense by this driver */
2041 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
2042 memcpy(cmnd->sense_buffer, devip->sense_buff,
2043 (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
2044 SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
2046 if (delta_jiff <= 0) {
2048 cmnd->result = scsi_result;
2053 unsigned long iflags;
2055 struct sdebug_queued_cmd * sqcp = NULL;
2057 spin_lock_irqsave(&queued_arr_lock, iflags);
2058 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2059 sqcp = &queued_arr[k];
2063 if (k >= SCSI_DEBUG_CANQUEUE) {
2064 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2065 printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
2066 return 1; /* report busy to mid level */
2069 sqcp->a_cmnd = cmnd;
2070 sqcp->scsi_result = scsi_result;
2071 sqcp->done_funct = done;
2072 sqcp->cmnd_timer.function = timer_intr_handler;
2073 sqcp->cmnd_timer.data = k;
2074 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
2075 add_timer(&sqcp->cmnd_timer);
2076 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2083 /* Note: The following macros create attribute files in the
2084 /sys/module/scsi_debug/parameters directory. Unfortunately this
2085 driver is unaware of a change and cannot trigger auxiliary actions
2086 as it can when the corresponding attribute in the
2087 /sys/bus/pseudo/drivers/scsi_debug directory is changed.
2089 module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
2090 module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
2091 module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
2092 module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
2093 module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
2094 module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
2095 module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
2096 module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
2097 module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
2098 module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
2099 module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
2100 module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
2101 module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
2102 module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
2103 module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
2106 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2107 MODULE_DESCRIPTION("SCSI debug adapter driver");
2108 MODULE_LICENSE("GPL");
2109 MODULE_VERSION(SCSI_DEBUG_VERSION);
2111 MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
2112 MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
2113 MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
2114 MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
2115 MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
2116 MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
2117 MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
2118 MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
2119 MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
2120 MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
2121 MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
2122 MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
2123 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
2124 MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
2125 MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2128 static char sdebug_info[256];
2130 static const char * scsi_debug_info(struct Scsi_Host * shp)
2132 sprintf(sdebug_info, "scsi_debug, version %s [%s], "
2133 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
2134 scsi_debug_version_date, scsi_debug_dev_size_mb,
2139 /* scsi_debug_proc_info
2140 * Used if the driver currently has no own support for /proc/scsi
2142 static int scsi_debug_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
2143 int length, int inout)
2145 int len, pos, begin;
2148 orig_length = length;
2152 int minLen = length > 15 ? 15 : length;
2154 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2156 memcpy(arr, buffer, minLen);
2158 if (1 != sscanf(arr, "%d", &pos))
2160 scsi_debug_opts = pos;
2161 if (scsi_debug_every_nth != 0)
2162 scsi_debug_cmnd_count = 0;
2166 pos = len = sprintf(buffer, "scsi_debug adapter driver, version "
2168 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2169 "every_nth=%d(curr:%d)\n"
2170 "delay=%d, max_luns=%d, scsi_level=%d\n"
2171 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2172 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2174 SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
2175 scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2176 scsi_debug_cmnd_count, scsi_debug_delay,
2177 scsi_debug_max_luns, scsi_debug_scsi_level,
2178 SECT_SIZE, sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
2179 num_aborts, num_dev_resets, num_bus_resets, num_host_resets);
2184 *start = buffer + (offset - begin); /* Start of wanted data */
2185 len -= (offset - begin);
2191 static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf)
2193 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
2196 static ssize_t sdebug_delay_store(struct device_driver * ddp,
2197 const char * buf, size_t count)
2202 if (1 == sscanf(buf, "%10s", work)) {
2203 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
2204 scsi_debug_delay = delay;
2210 DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show,
2211 sdebug_delay_store);
2213 static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf)
2215 return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
2218 static ssize_t sdebug_opts_store(struct device_driver * ddp,
2219 const char * buf, size_t count)
2224 if (1 == sscanf(buf, "%10s", work)) {
2225 if (0 == strnicmp(work,"0x", 2)) {
2226 if (1 == sscanf(&work[2], "%x", &opts))
2229 if (1 == sscanf(work, "%d", &opts))
2235 scsi_debug_opts = opts;
2236 scsi_debug_cmnd_count = 0;
2239 DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show,
2242 static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf)
2244 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
2246 static ssize_t sdebug_ptype_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_ptype = n;
2257 DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store);
2259 static ssize_t sdebug_dsense_show(struct device_driver * ddp, char * buf)
2261 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
2263 static ssize_t sdebug_dsense_store(struct device_driver * ddp,
2264 const char * buf, size_t count)
2268 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2269 scsi_debug_dsense = n;
2274 DRIVER_ATTR(dsense, S_IRUGO | S_IWUSR, sdebug_dsense_show,
2275 sdebug_dsense_store);
2277 static ssize_t sdebug_fake_rw_show(struct device_driver * ddp, char * buf)
2279 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
2281 static ssize_t sdebug_fake_rw_store(struct device_driver * ddp,
2282 const char * buf, size_t count)
2286 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2287 scsi_debug_fake_rw = n;
2292 DRIVER_ATTR(fake_rw, S_IRUGO | S_IWUSR, sdebug_fake_rw_show,
2293 sdebug_fake_rw_store);
2295 static ssize_t sdebug_no_lun_0_show(struct device_driver * ddp, char * buf)
2297 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
2299 static ssize_t sdebug_no_lun_0_store(struct device_driver * ddp,
2300 const char * buf, size_t count)
2304 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2305 scsi_debug_no_lun_0 = n;
2310 DRIVER_ATTR(no_lun_0, S_IRUGO | S_IWUSR, sdebug_no_lun_0_show,
2311 sdebug_no_lun_0_store);
2313 static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf)
2315 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
2317 static ssize_t sdebug_num_tgts_store(struct device_driver * ddp,
2318 const char * buf, size_t count)
2322 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2323 scsi_debug_num_tgts = n;
2324 sdebug_max_tgts_luns();
2329 DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show,
2330 sdebug_num_tgts_store);
2332 static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf)
2334 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
2336 DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL);
2338 static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf)
2340 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
2342 DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL);
2344 static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf)
2346 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
2348 static ssize_t sdebug_every_nth_store(struct device_driver * ddp,
2349 const char * buf, size_t count)
2353 if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
2354 scsi_debug_every_nth = nth;
2355 scsi_debug_cmnd_count = 0;
2360 DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show,
2361 sdebug_every_nth_store);
2363 static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf)
2365 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
2367 static ssize_t sdebug_max_luns_store(struct device_driver * ddp,
2368 const char * buf, size_t count)
2372 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2373 scsi_debug_max_luns = n;
2374 sdebug_max_tgts_luns();
2379 DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show,
2380 sdebug_max_luns_store);
2382 static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf)
2384 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
2386 DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL);
2388 static ssize_t sdebug_virtual_gb_show(struct device_driver * ddp, char * buf)
2390 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
2392 static ssize_t sdebug_virtual_gb_store(struct device_driver * ddp,
2393 const char * buf, size_t count)
2397 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2398 scsi_debug_virtual_gb = n;
2399 if (scsi_debug_virtual_gb > 0) {
2400 sdebug_capacity = 2048 * 1024;
2401 sdebug_capacity *= scsi_debug_virtual_gb;
2403 sdebug_capacity = sdebug_store_sectors;
2408 DRIVER_ATTR(virtual_gb, S_IRUGO | S_IWUSR, sdebug_virtual_gb_show,
2409 sdebug_virtual_gb_store);
2411 static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf)
2413 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
2416 static ssize_t sdebug_add_host_store(struct device_driver * ddp,
2417 const char * buf, size_t count)
2421 if (sscanf(buf, "%d", &delta_hosts) != 1)
2423 if (delta_hosts > 0) {
2425 sdebug_add_adapter();
2426 } while (--delta_hosts);
2427 } else if (delta_hosts < 0) {
2429 sdebug_remove_adapter();
2430 } while (++delta_hosts);
2434 DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show,
2435 sdebug_add_host_store);
2437 static ssize_t sdebug_vpd_use_hostno_show(struct device_driver * ddp,
2440 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
2442 static ssize_t sdebug_vpd_use_hostno_store(struct device_driver * ddp,
2443 const char * buf, size_t count)
2447 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2448 scsi_debug_vpd_use_hostno = n;
2453 DRIVER_ATTR(vpd_use_hostno, S_IRUGO | S_IWUSR, sdebug_vpd_use_hostno_show,
2454 sdebug_vpd_use_hostno_store);
2456 /* Note: The following function creates attribute files in the
2457 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
2458 files (over those found in the /sys/module/scsi_debug/parameters
2459 directory) is that auxiliary actions can be triggered when an attribute
2460 is changed. For example see: sdebug_add_host_store() above.
2462 static int do_create_driverfs_files(void)
2466 ret = driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2467 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay);
2468 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2469 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2470 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2471 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2472 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2473 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2474 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2475 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2476 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2477 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts);
2478 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2479 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2480 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2484 static void do_remove_driverfs_files(void)
2486 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2487 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2488 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2489 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts);
2490 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2491 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2492 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2493 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2494 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2495 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2496 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2497 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2498 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2499 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay);
2500 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2503 static int __init scsi_debug_init(void)
2510 if (scsi_debug_dev_size_mb < 1)
2511 scsi_debug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */
2512 sdebug_store_size = (unsigned int)scsi_debug_dev_size_mb * 1048576;
2513 sdebug_store_sectors = sdebug_store_size / SECT_SIZE;
2514 if (scsi_debug_virtual_gb > 0) {
2515 sdebug_capacity = 2048 * 1024;
2516 sdebug_capacity *= scsi_debug_virtual_gb;
2518 sdebug_capacity = sdebug_store_sectors;
2520 /* play around with geometry, don't waste too much on track 0 */
2522 sdebug_sectors_per = 32;
2523 if (scsi_debug_dev_size_mb >= 16)
2525 else if (scsi_debug_dev_size_mb >= 256)
2527 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2528 (sdebug_sectors_per * sdebug_heads);
2529 if (sdebug_cylinders_per >= 1024) {
2530 /* other LLDs do this; implies >= 1GB ram disk ... */
2532 sdebug_sectors_per = 63;
2533 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2534 (sdebug_sectors_per * sdebug_heads);
2537 sz = sdebug_store_size;
2538 fake_storep = vmalloc(sz);
2539 if (NULL == fake_storep) {
2540 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
2543 memset(fake_storep, 0, sz);
2544 if (scsi_debug_num_parts > 0)
2545 sdebug_build_parts(fake_storep);
2547 ret = device_register(&pseudo_primary);
2549 printk(KERN_WARNING "scsi_debug: device_register error: %d\n",
2553 ret = bus_register(&pseudo_lld_bus);
2555 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
2559 ret = driver_register(&sdebug_driverfs_driver);
2561 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
2565 ret = do_create_driverfs_files();
2567 printk(KERN_WARNING "scsi_debug: driver_create_file error: %d\n",
2574 host_to_add = scsi_debug_add_host;
2575 scsi_debug_add_host = 0;
2577 for (k = 0; k < host_to_add; k++) {
2578 if (sdebug_add_adapter()) {
2579 printk(KERN_ERR "scsi_debug_init: "
2580 "sdebug_add_adapter failed k=%d\n", k);
2585 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
2586 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
2587 scsi_debug_add_host);
2592 do_remove_driverfs_files();
2593 driver_unregister(&sdebug_driverfs_driver);
2595 bus_unregister(&pseudo_lld_bus);
2597 device_unregister(&pseudo_primary);
2604 static void __exit scsi_debug_exit(void)
2606 int k = scsi_debug_add_host;
2610 sdebug_remove_adapter();
2611 do_remove_driverfs_files();
2612 driver_unregister(&sdebug_driverfs_driver);
2613 bus_unregister(&pseudo_lld_bus);
2614 device_unregister(&pseudo_primary);
2619 device_initcall(scsi_debug_init);
2620 module_exit(scsi_debug_exit);
2622 static void pseudo_0_release(struct device * dev)
2624 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2625 printk(KERN_INFO "scsi_debug: pseudo_0_release() called\n");
2628 static struct device pseudo_primary = {
2629 .bus_id = "pseudo_0",
2630 .release = pseudo_0_release,
2633 static int pseudo_lld_bus_match(struct device *dev,
2634 struct device_driver *dev_driver)
2639 static struct bus_type pseudo_lld_bus = {
2641 .match = pseudo_lld_bus_match,
2642 .probe = sdebug_driver_probe,
2643 .remove = sdebug_driver_remove,
2646 static void sdebug_release_adapter(struct device * dev)
2648 struct sdebug_host_info *sdbg_host;
2650 sdbg_host = to_sdebug_host(dev);
2654 static int sdebug_add_adapter(void)
2656 int k, devs_per_host;
2658 struct sdebug_host_info *sdbg_host;
2659 struct sdebug_dev_info *sdbg_devinfo, *tmp;
2661 sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
2662 if (NULL == sdbg_host) {
2663 printk(KERN_ERR "%s: out of memory at line %d\n",
2664 __FUNCTION__, __LINE__);
2668 INIT_LIST_HEAD(&sdbg_host->dev_info_list);
2670 devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
2671 for (k = 0; k < devs_per_host; k++) {
2672 sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL);
2673 if (!sdbg_devinfo) {
2674 printk(KERN_ERR "%s: out of memory at line %d\n",
2675 __FUNCTION__, __LINE__);
2681 spin_lock(&sdebug_host_list_lock);
2682 list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
2683 spin_unlock(&sdebug_host_list_lock);
2685 sdbg_host->dev.bus = &pseudo_lld_bus;
2686 sdbg_host->dev.parent = &pseudo_primary;
2687 sdbg_host->dev.release = &sdebug_release_adapter;
2688 sprintf(sdbg_host->dev.bus_id, "adapter%d", scsi_debug_add_host);
2690 error = device_register(&sdbg_host->dev);
2695 ++scsi_debug_add_host;
2699 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
2701 list_del(&sdbg_devinfo->dev_list);
2702 kfree(sdbg_devinfo);
2709 static void sdebug_remove_adapter(void)
2711 struct sdebug_host_info * sdbg_host = NULL;
2713 spin_lock(&sdebug_host_list_lock);
2714 if (!list_empty(&sdebug_host_list)) {
2715 sdbg_host = list_entry(sdebug_host_list.prev,
2716 struct sdebug_host_info, host_list);
2717 list_del(&sdbg_host->host_list);
2719 spin_unlock(&sdebug_host_list_lock);
2724 device_unregister(&sdbg_host->dev);
2725 --scsi_debug_add_host;
2729 int scsi_debug_queuecommand(struct scsi_cmnd *SCpnt, done_funct_t done)
2731 unsigned char *cmd = (unsigned char *) SCpnt->cmnd;
2734 unsigned long long lba;
2736 int target = SCpnt->device->id;
2737 struct sdebug_dev_info *devip = NULL;
2738 int inj_recovered = 0;
2739 int inj_transport = 0;
2740 int delay_override = 0;
2742 scsi_set_resid(SCpnt, 0);
2743 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) {
2744 printk(KERN_INFO "scsi_debug: cmd ");
2745 for (k = 0, len = SCpnt->cmd_len; k < len; ++k)
2746 printk("%02x ", (int)cmd[k]);
2750 if (target == SCpnt->device->host->hostt->this_id) {
2751 printk(KERN_INFO "scsi_debug: initiator's id used as "
2753 return schedule_resp(SCpnt, NULL, done,
2754 DID_NO_CONNECT << 16, 0);
2757 if ((SCpnt->device->lun >= scsi_debug_max_luns) &&
2758 (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS))
2759 return schedule_resp(SCpnt, NULL, done,
2760 DID_NO_CONNECT << 16, 0);
2761 devip = devInfoReg(SCpnt->device);
2763 return schedule_resp(SCpnt, NULL, done,
2764 DID_NO_CONNECT << 16, 0);
2766 if ((scsi_debug_every_nth != 0) &&
2767 (++scsi_debug_cmnd_count >= abs(scsi_debug_every_nth))) {
2768 scsi_debug_cmnd_count = 0;
2769 if (scsi_debug_every_nth < -1)
2770 scsi_debug_every_nth = -1;
2771 if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
2772 return 0; /* ignore command causing timeout */
2773 else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
2774 inj_recovered = 1; /* to reads and writes below */
2775 else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts)
2776 inj_transport = 1; /* to reads and writes below */
2783 case TEST_UNIT_READY:
2785 break; /* only allowable wlun commands */
2787 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2788 printk(KERN_INFO "scsi_debug: Opcode: 0x%x "
2789 "not supported for wlun\n", *cmd);
2790 mk_sense_buffer(devip, ILLEGAL_REQUEST,
2792 errsts = check_condition_result;
2793 return schedule_resp(SCpnt, devip, done, errsts,
2799 case INQUIRY: /* mandatory, ignore unit attention */
2801 errsts = resp_inquiry(SCpnt, target, devip);
2803 case REQUEST_SENSE: /* mandatory, ignore unit attention */
2805 errsts = resp_requests(SCpnt, devip);
2807 case REZERO_UNIT: /* actually this is REWIND for SSC */
2809 errsts = resp_start_stop(SCpnt, devip);
2811 case ALLOW_MEDIUM_REMOVAL:
2812 errsts = check_readiness(SCpnt, 1, devip);
2815 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2816 printk(KERN_INFO "scsi_debug: Medium removal %s\n",
2817 cmd[4] ? "inhibited" : "enabled");
2819 case SEND_DIAGNOSTIC: /* mandatory */
2820 errsts = check_readiness(SCpnt, 1, devip);
2822 case TEST_UNIT_READY: /* mandatory */
2824 errsts = check_readiness(SCpnt, 0, devip);
2827 errsts = check_readiness(SCpnt, 1, devip);
2830 errsts = check_readiness(SCpnt, 1, devip);
2833 errsts = check_readiness(SCpnt, 1, devip);
2836 errsts = check_readiness(SCpnt, 1, devip);
2839 errsts = resp_readcap(SCpnt, devip);
2841 case SERVICE_ACTION_IN:
2842 if (SAI_READ_CAPACITY_16 != cmd[1]) {
2843 mk_sense_buffer(devip, ILLEGAL_REQUEST,
2845 errsts = check_condition_result;
2848 errsts = resp_readcap16(SCpnt, devip);
2850 case MAINTENANCE_IN:
2851 if (MI_REPORT_TARGET_PGS != cmd[1]) {
2852 mk_sense_buffer(devip, ILLEGAL_REQUEST,
2854 errsts = check_condition_result;
2857 errsts = resp_report_tgtpgs(SCpnt, devip);
2863 errsts = check_readiness(SCpnt, 0, devip);
2866 if (scsi_debug_fake_rw)
2868 get_data_transfer_info(cmd, &lba, &num);
2869 errsts = resp_read(SCpnt, lba, num, devip);
2870 if (inj_recovered && (0 == errsts)) {
2871 mk_sense_buffer(devip, RECOVERED_ERROR,
2872 THRESHOLD_EXCEEDED, 0);
2873 errsts = check_condition_result;
2874 } else if (inj_transport && (0 == errsts)) {
2875 mk_sense_buffer(devip, ABORTED_COMMAND,
2876 TRANSPORT_PROBLEM, ACK_NAK_TO);
2877 errsts = check_condition_result;
2880 case REPORT_LUNS: /* mandatory, ignore unit attention */
2882 errsts = resp_report_luns(SCpnt, devip);
2884 case VERIFY: /* 10 byte SBC-2 command */
2885 errsts = check_readiness(SCpnt, 0, devip);
2891 errsts = check_readiness(SCpnt, 0, devip);
2894 if (scsi_debug_fake_rw)
2896 get_data_transfer_info(cmd, &lba, &num);
2897 errsts = resp_write(SCpnt, lba, num, devip);
2898 if (inj_recovered && (0 == errsts)) {
2899 mk_sense_buffer(devip, RECOVERED_ERROR,
2900 THRESHOLD_EXCEEDED, 0);
2901 errsts = check_condition_result;
2906 errsts = resp_mode_sense(SCpnt, target, devip);
2909 errsts = resp_mode_select(SCpnt, 1, devip);
2911 case MODE_SELECT_10:
2912 errsts = resp_mode_select(SCpnt, 0, devip);
2915 errsts = resp_log_sense(SCpnt, devip);
2917 case SYNCHRONIZE_CACHE:
2919 errsts = check_readiness(SCpnt, 0, devip);
2922 errsts = check_readiness(SCpnt, 1, devip);
2924 case XDWRITEREAD_10:
2925 if (!scsi_bidi_cmnd(SCpnt)) {
2926 mk_sense_buffer(devip, ILLEGAL_REQUEST,
2927 INVALID_FIELD_IN_CDB, 0);
2928 errsts = check_condition_result;
2932 errsts = check_readiness(SCpnt, 0, devip);
2935 if (scsi_debug_fake_rw)
2937 get_data_transfer_info(cmd, &lba, &num);
2938 errsts = resp_read(SCpnt, lba, num, devip);
2941 errsts = resp_write(SCpnt, lba, num, devip);
2944 errsts = resp_xdwriteread(SCpnt, lba, num, devip);
2947 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2948 printk(KERN_INFO "scsi_debug: Opcode: 0x%x not "
2949 "supported\n", *cmd);
2950 errsts = check_readiness(SCpnt, 1, devip);
2952 break; /* Unit attention takes precedence */
2953 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
2954 errsts = check_condition_result;
2957 return schedule_resp(SCpnt, devip, done, errsts,
2958 (delay_override ? 0 : scsi_debug_delay));
2961 static struct scsi_host_template sdebug_driver_template = {
2962 .proc_info = scsi_debug_proc_info,
2963 .proc_name = sdebug_proc_name,
2964 .name = "SCSI DEBUG",
2965 .info = scsi_debug_info,
2966 .slave_alloc = scsi_debug_slave_alloc,
2967 .slave_configure = scsi_debug_slave_configure,
2968 .slave_destroy = scsi_debug_slave_destroy,
2969 .ioctl = scsi_debug_ioctl,
2970 .queuecommand = scsi_debug_queuecommand,
2971 .eh_abort_handler = scsi_debug_abort,
2972 .eh_bus_reset_handler = scsi_debug_bus_reset,
2973 .eh_device_reset_handler = scsi_debug_device_reset,
2974 .eh_host_reset_handler = scsi_debug_host_reset,
2975 .bios_param = scsi_debug_biosparam,
2976 .can_queue = SCSI_DEBUG_CANQUEUE,
2978 .sg_tablesize = 256,
2980 .max_sectors = 0xffff,
2981 .use_clustering = DISABLE_CLUSTERING,
2982 .module = THIS_MODULE,
2985 static int sdebug_driver_probe(struct device * dev)
2988 struct sdebug_host_info *sdbg_host;
2989 struct Scsi_Host *hpnt;
2991 sdbg_host = to_sdebug_host(dev);
2993 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
2995 printk(KERN_ERR "%s: scsi_register failed\n", __FUNCTION__);
3000 sdbg_host->shost = hpnt;
3001 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
3002 if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
3003 hpnt->max_id = scsi_debug_num_tgts + 1;
3005 hpnt->max_id = scsi_debug_num_tgts;
3006 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* = scsi_debug_max_luns; */
3008 error = scsi_add_host(hpnt, &sdbg_host->dev);
3010 printk(KERN_ERR "%s: scsi_add_host failed\n", __FUNCTION__);
3012 scsi_host_put(hpnt);
3014 scsi_scan_host(hpnt);
3020 static int sdebug_driver_remove(struct device * dev)
3022 struct sdebug_host_info *sdbg_host;
3023 struct sdebug_dev_info *sdbg_devinfo, *tmp;
3025 sdbg_host = to_sdebug_host(dev);
3028 printk(KERN_ERR "%s: Unable to locate host info\n",
3033 scsi_remove_host(sdbg_host->shost);
3035 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
3037 list_del(&sdbg_devinfo->dev_list);
3038 kfree(sdbg_devinfo);
3041 scsi_host_put(sdbg_host->shost);
3045 static void sdebug_max_tgts_luns(void)
3047 struct sdebug_host_info * sdbg_host;
3048 struct Scsi_Host *hpnt;
3050 spin_lock(&sdebug_host_list_lock);
3051 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
3052 hpnt = sdbg_host->shost;
3053 if ((hpnt->this_id >= 0) &&
3054 (scsi_debug_num_tgts > hpnt->this_id))
3055 hpnt->max_id = scsi_debug_num_tgts + 1;
3057 hpnt->max_id = scsi_debug_num_tgts;
3058 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* scsi_debug_max_luns; */
3060 spin_unlock(&sdebug_host_list_lock);