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 /* function declarations */
239 static int resp_inquiry(struct scsi_cmnd * SCpnt, int target,
240 struct sdebug_dev_info * devip);
241 static int resp_requests(struct scsi_cmnd * SCpnt,
242 struct sdebug_dev_info * devip);
243 static int resp_start_stop(struct scsi_cmnd * scp,
244 struct sdebug_dev_info * devip);
245 static int resp_report_tgtpgs(struct scsi_cmnd * scp,
246 struct sdebug_dev_info * devip);
247 static int resp_readcap(struct scsi_cmnd * SCpnt,
248 struct sdebug_dev_info * devip);
249 static int resp_readcap16(struct scsi_cmnd * SCpnt,
250 struct sdebug_dev_info * devip);
251 static int resp_mode_sense(struct scsi_cmnd * scp, int target,
252 struct sdebug_dev_info * devip);
253 static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
254 struct sdebug_dev_info * devip);
255 static int resp_log_sense(struct scsi_cmnd * scp,
256 struct sdebug_dev_info * devip);
257 static int resp_read(struct scsi_cmnd * SCpnt, unsigned long long lba,
258 unsigned int num, struct sdebug_dev_info * devip);
259 static int resp_write(struct scsi_cmnd * SCpnt, unsigned long long lba,
260 unsigned int num, struct sdebug_dev_info * devip);
261 static int resp_report_luns(struct scsi_cmnd * SCpnt,
262 struct sdebug_dev_info * devip);
263 static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
264 unsigned int num, struct sdebug_dev_info *devip);
265 static int fill_from_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
267 static int fetch_to_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
269 static void timer_intr_handler(unsigned long);
270 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev);
271 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
273 static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
274 struct sdebug_dev_info * devip);
275 static int schedule_resp(struct scsi_cmnd * cmnd,
276 struct sdebug_dev_info * devip,
277 done_funct_t done, int scsi_result, int delta_jiff);
278 static void __init sdebug_build_parts(unsigned char * ramp);
279 static void __init init_all_queued(void);
280 static void stop_all_queued(void);
281 static int stop_queued_cmnd(struct scsi_cmnd * cmnd);
282 static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
283 int target_dev_id, int dev_id_num,
284 const char * dev_id_str, int dev_id_str_len);
285 static int inquiry_evpd_88(unsigned char * arr, int target_dev_id);
286 static int do_create_driverfs_files(void);
287 static void do_remove_driverfs_files(void);
289 static int sdebug_add_adapter(void);
290 static void sdebug_remove_adapter(void);
291 static void sdebug_max_tgts_luns(void);
293 static struct device pseudo_primary;
294 static struct bus_type pseudo_lld_bus;
296 static void get_data_transfer_info(unsigned char *cmd,
297 unsigned long long *lba, unsigned int *num)
304 for (*lba = 0, i = 0; i < 8; ++i) {
309 *num = cmd[13] + (cmd[12] << 8) +
310 (cmd[11] << 16) + (cmd[10] << 24);
314 *lba = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24);
315 *num = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
320 *lba = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24);
321 *num = cmd[8] + (cmd[7] << 8);
325 *lba = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
326 *num = (0 == cmd[4]) ? 256 : cmd[4];
334 int scsi_debug_queuecommand(struct scsi_cmnd * SCpnt, done_funct_t done)
336 unsigned char *cmd = (unsigned char *) SCpnt->cmnd;
339 unsigned long long lba;
341 int target = SCpnt->device->id;
342 struct sdebug_dev_info * devip = NULL;
343 int inj_recovered = 0;
344 int inj_transport = 0;
345 int delay_override = 0;
347 scsi_set_resid(SCpnt, 0);
348 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) {
349 printk(KERN_INFO "scsi_debug: cmd ");
350 for (k = 0, len = SCpnt->cmd_len; k < len; ++k)
351 printk("%02x ", (int)cmd[k]);
355 if (target == SCpnt->device->host->hostt->this_id) {
356 printk(KERN_INFO "scsi_debug: initiator's id used as "
358 return schedule_resp(SCpnt, NULL, done,
359 DID_NO_CONNECT << 16, 0);
362 if ((SCpnt->device->lun >= scsi_debug_max_luns) &&
363 (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS))
364 return schedule_resp(SCpnt, NULL, done,
365 DID_NO_CONNECT << 16, 0);
366 devip = devInfoReg(SCpnt->device);
368 return schedule_resp(SCpnt, NULL, done,
369 DID_NO_CONNECT << 16, 0);
371 if ((scsi_debug_every_nth != 0) &&
372 (++scsi_debug_cmnd_count >= abs(scsi_debug_every_nth))) {
373 scsi_debug_cmnd_count = 0;
374 if (scsi_debug_every_nth < -1)
375 scsi_debug_every_nth = -1;
376 if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
377 return 0; /* ignore command causing timeout */
378 else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
379 inj_recovered = 1; /* to reads and writes below */
380 else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts)
381 inj_transport = 1; /* to reads and writes below */
388 case TEST_UNIT_READY:
390 break; /* only allowable wlun commands */
392 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
393 printk(KERN_INFO "scsi_debug: Opcode: 0x%x "
394 "not supported for wlun\n", *cmd);
395 mk_sense_buffer(devip, ILLEGAL_REQUEST,
397 errsts = check_condition_result;
398 return schedule_resp(SCpnt, devip, done, errsts,
404 case INQUIRY: /* mandatory, ignore unit attention */
406 errsts = resp_inquiry(SCpnt, target, devip);
408 case REQUEST_SENSE: /* mandatory, ignore unit attention */
410 errsts = resp_requests(SCpnt, devip);
412 case REZERO_UNIT: /* actually this is REWIND for SSC */
414 errsts = resp_start_stop(SCpnt, devip);
416 case ALLOW_MEDIUM_REMOVAL:
417 if ((errsts = check_readiness(SCpnt, 1, devip)))
419 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
420 printk(KERN_INFO "scsi_debug: Medium removal %s\n",
421 cmd[4] ? "inhibited" : "enabled");
423 case SEND_DIAGNOSTIC: /* mandatory */
424 errsts = check_readiness(SCpnt, 1, devip);
426 case TEST_UNIT_READY: /* mandatory */
428 errsts = check_readiness(SCpnt, 0, devip);
431 errsts = check_readiness(SCpnt, 1, devip);
434 errsts = check_readiness(SCpnt, 1, devip);
437 errsts = check_readiness(SCpnt, 1, devip);
440 errsts = check_readiness(SCpnt, 1, devip);
443 errsts = resp_readcap(SCpnt, devip);
445 case SERVICE_ACTION_IN:
446 if (SAI_READ_CAPACITY_16 != cmd[1]) {
447 mk_sense_buffer(devip, ILLEGAL_REQUEST,
449 errsts = check_condition_result;
452 errsts = resp_readcap16(SCpnt, devip);
455 if (MI_REPORT_TARGET_PGS != cmd[1]) {
456 mk_sense_buffer(devip, ILLEGAL_REQUEST,
458 errsts = check_condition_result;
461 errsts = resp_report_tgtpgs(SCpnt, devip);
467 if ((errsts = check_readiness(SCpnt, 0, devip)))
469 if (scsi_debug_fake_rw)
471 get_data_transfer_info(cmd, &lba, &num);
472 errsts = resp_read(SCpnt, lba, num, devip);
473 if (inj_recovered && (0 == errsts)) {
474 mk_sense_buffer(devip, RECOVERED_ERROR,
475 THRESHOLD_EXCEEDED, 0);
476 errsts = check_condition_result;
477 } else if (inj_transport && (0 == errsts)) {
478 mk_sense_buffer(devip, ABORTED_COMMAND,
479 TRANSPORT_PROBLEM, ACK_NAK_TO);
480 errsts = check_condition_result;
483 case REPORT_LUNS: /* mandatory, ignore unit attention */
485 errsts = resp_report_luns(SCpnt, devip);
487 case VERIFY: /* 10 byte SBC-2 command */
488 errsts = check_readiness(SCpnt, 0, devip);
494 if ((errsts = check_readiness(SCpnt, 0, devip)))
496 if (scsi_debug_fake_rw)
498 get_data_transfer_info(cmd, &lba, &num);
499 errsts = resp_write(SCpnt, lba, num, devip);
500 if (inj_recovered && (0 == errsts)) {
501 mk_sense_buffer(devip, RECOVERED_ERROR,
502 THRESHOLD_EXCEEDED, 0);
503 errsts = check_condition_result;
508 errsts = resp_mode_sense(SCpnt, target, devip);
511 errsts = resp_mode_select(SCpnt, 1, devip);
514 errsts = resp_mode_select(SCpnt, 0, devip);
517 errsts = resp_log_sense(SCpnt, devip);
519 case SYNCHRONIZE_CACHE:
521 errsts = check_readiness(SCpnt, 0, devip);
524 errsts = check_readiness(SCpnt, 1, devip);
527 if (!scsi_bidi_cmnd(SCpnt)) {
528 mk_sense_buffer(devip, ILLEGAL_REQUEST,
529 INVALID_FIELD_IN_CDB, 0);
530 errsts = check_condition_result;
534 errsts = check_readiness(SCpnt, 0, devip);
537 if (scsi_debug_fake_rw)
539 get_data_transfer_info(cmd, &lba, &num);
540 errsts = resp_read(SCpnt, lba, num, devip);
543 errsts = resp_write(SCpnt, lba, num, devip);
546 errsts = resp_xdwriteread(SCpnt, lba, num, devip);
549 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
550 printk(KERN_INFO "scsi_debug: Opcode: 0x%x not "
551 "supported\n", *cmd);
552 if ((errsts = check_readiness(SCpnt, 1, devip)))
553 break; /* Unit attention takes precedence */
554 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
555 errsts = check_condition_result;
558 return schedule_resp(SCpnt, devip, done, errsts,
559 (delay_override ? 0 : scsi_debug_delay));
562 static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
564 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
565 printk(KERN_INFO "scsi_debug: ioctl: cmd=0x%x\n", cmd);
568 /* return -ENOTTY; // correct return but upsets fdisk */
571 static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
572 struct sdebug_dev_info * devip)
575 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
576 printk(KERN_INFO "scsi_debug: Reporting Unit "
577 "attention: power on reset\n");
579 mk_sense_buffer(devip, UNIT_ATTENTION, POWERON_RESET, 0);
580 return check_condition_result;
582 if ((0 == reset_only) && devip->stopped) {
583 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
584 printk(KERN_INFO "scsi_debug: Reporting Not "
585 "ready: initializing command required\n");
586 mk_sense_buffer(devip, NOT_READY, LOGICAL_UNIT_NOT_READY,
588 return check_condition_result;
593 /* Returns 0 if ok else (DID_ERROR << 16). Sets scp->resid . */
594 static int fill_from_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
598 struct scsi_data_buffer *sdb = scsi_in(scp);
602 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE))
603 return (DID_ERROR << 16);
605 act_len = sg_copy_from_buffer(sdb->table.sgl, sdb->table.nents,
608 sdb->resid -= act_len;
610 sdb->resid = scsi_bufflen(scp) - act_len;
615 /* Returns number of bytes fetched into 'arr' or -1 if error. */
616 static int fetch_to_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
619 if (!scsi_bufflen(scp))
621 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_TO_DEVICE))
624 return scsi_sg_copy_to_buffer(scp, arr, arr_len);
628 static const char * inq_vendor_id = "Linux ";
629 static const char * inq_product_id = "scsi_debug ";
630 static const char * inq_product_rev = "0004";
632 static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
633 int target_dev_id, int dev_id_num,
634 const char * dev_id_str,
640 port_a = target_dev_id + 1;
641 /* T10 vendor identifier field format (faked) */
642 arr[0] = 0x2; /* ASCII */
645 memcpy(&arr[4], inq_vendor_id, 8);
646 memcpy(&arr[12], inq_product_id, 16);
647 memcpy(&arr[28], dev_id_str, dev_id_str_len);
648 num = 8 + 16 + dev_id_str_len;
651 if (dev_id_num >= 0) {
652 /* NAA-5, Logical unit identifier (binary) */
653 arr[num++] = 0x1; /* binary (not necessarily sas) */
654 arr[num++] = 0x3; /* PIV=0, lu, naa */
657 arr[num++] = 0x53; /* naa-5 ieee company id=0x333333 (fake) */
661 arr[num++] = (dev_id_num >> 24);
662 arr[num++] = (dev_id_num >> 16) & 0xff;
663 arr[num++] = (dev_id_num >> 8) & 0xff;
664 arr[num++] = dev_id_num & 0xff;
665 /* Target relative port number */
666 arr[num++] = 0x61; /* proto=sas, binary */
667 arr[num++] = 0x94; /* PIV=1, target port, rel port */
668 arr[num++] = 0x0; /* reserved */
669 arr[num++] = 0x4; /* length */
670 arr[num++] = 0x0; /* reserved */
671 arr[num++] = 0x0; /* reserved */
673 arr[num++] = 0x1; /* relative port A */
675 /* NAA-5, Target port identifier */
676 arr[num++] = 0x61; /* proto=sas, binary */
677 arr[num++] = 0x93; /* piv=1, target port, naa */
680 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
684 arr[num++] = (port_a >> 24);
685 arr[num++] = (port_a >> 16) & 0xff;
686 arr[num++] = (port_a >> 8) & 0xff;
687 arr[num++] = port_a & 0xff;
688 /* NAA-5, Target port group identifier */
689 arr[num++] = 0x61; /* proto=sas, binary */
690 arr[num++] = 0x95; /* piv=1, target port group id */
695 arr[num++] = (port_group_id >> 8) & 0xff;
696 arr[num++] = port_group_id & 0xff;
697 /* NAA-5, Target device identifier */
698 arr[num++] = 0x61; /* proto=sas, binary */
699 arr[num++] = 0xa3; /* piv=1, target device, naa */
702 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
706 arr[num++] = (target_dev_id >> 24);
707 arr[num++] = (target_dev_id >> 16) & 0xff;
708 arr[num++] = (target_dev_id >> 8) & 0xff;
709 arr[num++] = target_dev_id & 0xff;
710 /* SCSI name string: Target device identifier */
711 arr[num++] = 0x63; /* proto=sas, UTF-8 */
712 arr[num++] = 0xa8; /* piv=1, target device, SCSI name string */
715 memcpy(arr + num, "naa.52222220", 12);
717 snprintf(b, sizeof(b), "%08X", target_dev_id);
718 memcpy(arr + num, b, 8);
720 memset(arr + num, 0, 4);
726 static unsigned char vpd84_data[] = {
727 /* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
728 0x22,0x22,0x22,0x0,0xbb,0x1,
729 0x22,0x22,0x22,0x0,0xbb,0x2,
732 static int inquiry_evpd_84(unsigned char * arr)
734 memcpy(arr, vpd84_data, sizeof(vpd84_data));
735 return sizeof(vpd84_data);
738 static int inquiry_evpd_85(unsigned char * arr)
741 const char * na1 = "https://www.kernel.org/config";
742 const char * na2 = "http://www.kernel.org/log";
745 arr[num++] = 0x1; /* lu, storage config */
746 arr[num++] = 0x0; /* reserved */
751 plen = ((plen / 4) + 1) * 4;
752 arr[num++] = plen; /* length, null termianted, padded */
753 memcpy(arr + num, na1, olen);
754 memset(arr + num + olen, 0, plen - olen);
757 arr[num++] = 0x4; /* lu, logging */
758 arr[num++] = 0x0; /* reserved */
763 plen = ((plen / 4) + 1) * 4;
764 arr[num++] = plen; /* length, null terminated, padded */
765 memcpy(arr + num, na2, olen);
766 memset(arr + num + olen, 0, plen - olen);
772 /* SCSI ports VPD page */
773 static int inquiry_evpd_88(unsigned char * arr, int target_dev_id)
778 port_a = target_dev_id + 1;
780 arr[num++] = 0x0; /* reserved */
781 arr[num++] = 0x0; /* reserved */
783 arr[num++] = 0x1; /* relative port 1 (primary) */
784 memset(arr + num, 0, 6);
787 arr[num++] = 12; /* length tp descriptor */
788 /* naa-5 target port identifier (A) */
789 arr[num++] = 0x61; /* proto=sas, binary */
790 arr[num++] = 0x93; /* PIV=1, target port, NAA */
791 arr[num++] = 0x0; /* reserved */
792 arr[num++] = 0x8; /* length */
793 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
797 arr[num++] = (port_a >> 24);
798 arr[num++] = (port_a >> 16) & 0xff;
799 arr[num++] = (port_a >> 8) & 0xff;
800 arr[num++] = port_a & 0xff;
802 arr[num++] = 0x0; /* reserved */
803 arr[num++] = 0x0; /* reserved */
805 arr[num++] = 0x2; /* relative port 2 (secondary) */
806 memset(arr + num, 0, 6);
809 arr[num++] = 12; /* length tp descriptor */
810 /* naa-5 target port identifier (B) */
811 arr[num++] = 0x61; /* proto=sas, binary */
812 arr[num++] = 0x93; /* PIV=1, target port, NAA */
813 arr[num++] = 0x0; /* reserved */
814 arr[num++] = 0x8; /* length */
815 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
819 arr[num++] = (port_b >> 24);
820 arr[num++] = (port_b >> 16) & 0xff;
821 arr[num++] = (port_b >> 8) & 0xff;
822 arr[num++] = port_b & 0xff;
828 static unsigned char vpd89_data[] = {
829 /* from 4th byte */ 0,0,0,0,
830 'l','i','n','u','x',' ',' ',' ',
831 'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
833 0x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
835 0x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
836 0,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
837 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
838 0x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
840 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
842 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
844 0,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
845 0x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
846 0x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
847 0,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
848 0x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
849 0x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
850 0,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
851 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
852 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
853 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
854 0x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
855 0,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
856 0xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
857 0,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
858 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
859 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
860 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
861 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
862 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
863 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
864 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
865 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
866 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
867 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
868 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
869 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
872 static int inquiry_evpd_89(unsigned char * arr)
874 memcpy(arr, vpd89_data, sizeof(vpd89_data));
875 return sizeof(vpd89_data);
879 static unsigned char vpdb0_data[] = {
880 /* from 4th byte */ 0,0,0,4,
885 static int inquiry_evpd_b0(unsigned char * arr)
887 memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
888 if (sdebug_store_sectors > 0x400) {
889 arr[4] = (sdebug_store_sectors >> 24) & 0xff;
890 arr[5] = (sdebug_store_sectors >> 16) & 0xff;
891 arr[6] = (sdebug_store_sectors >> 8) & 0xff;
892 arr[7] = sdebug_store_sectors & 0xff;
894 return sizeof(vpdb0_data);
898 #define SDEBUG_LONG_INQ_SZ 96
899 #define SDEBUG_MAX_INQ_ARR_SZ 584
901 static int resp_inquiry(struct scsi_cmnd * scp, int target,
902 struct sdebug_dev_info * devip)
904 unsigned char pq_pdt;
906 unsigned char *cmd = (unsigned char *)scp->cmnd;
907 int alloc_len, n, ret;
909 alloc_len = (cmd[3] << 8) + cmd[4];
910 arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
912 return DID_REQUEUE << 16;
914 pq_pdt = 0x1e; /* present, wlun */
915 else if (scsi_debug_no_lun_0 && (0 == devip->lun))
916 pq_pdt = 0x7f; /* not present, no device type */
918 pq_pdt = (scsi_debug_ptype & 0x1f);
920 if (0x2 & cmd[1]) { /* CMDDT bit set */
921 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
924 return check_condition_result;
925 } else if (0x1 & cmd[1]) { /* EVPD bit set */
926 int lu_id_num, port_group_id, target_dev_id, len;
928 int host_no = devip->sdbg_host->shost->host_no;
930 port_group_id = (((host_no + 1) & 0x7f) << 8) +
931 (devip->channel & 0x7f);
932 if (0 == scsi_debug_vpd_use_hostno)
934 lu_id_num = devip->wlun ? -1 : (((host_no + 1) * 2000) +
935 (devip->target * 1000) + devip->lun);
936 target_dev_id = ((host_no + 1) * 2000) +
937 (devip->target * 1000) - 3;
938 len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
939 if (0 == cmd[2]) { /* supported vital product data pages */
940 arr[1] = cmd[2]; /*sanity */
942 arr[n++] = 0x0; /* this page */
943 arr[n++] = 0x80; /* unit serial number */
944 arr[n++] = 0x83; /* device identification */
945 arr[n++] = 0x84; /* software interface ident. */
946 arr[n++] = 0x85; /* management network addresses */
947 arr[n++] = 0x86; /* extended inquiry */
948 arr[n++] = 0x87; /* mode page policy */
949 arr[n++] = 0x88; /* SCSI ports */
950 arr[n++] = 0x89; /* ATA information */
951 arr[n++] = 0xb0; /* Block limits (SBC) */
952 arr[3] = n - 4; /* number of supported VPD pages */
953 } else if (0x80 == cmd[2]) { /* unit serial number */
954 arr[1] = cmd[2]; /*sanity */
956 memcpy(&arr[4], lu_id_str, len);
957 } else if (0x83 == cmd[2]) { /* device identification */
958 arr[1] = cmd[2]; /*sanity */
959 arr[3] = inquiry_evpd_83(&arr[4], port_group_id,
960 target_dev_id, lu_id_num,
962 } else if (0x84 == cmd[2]) { /* Software interface ident. */
963 arr[1] = cmd[2]; /*sanity */
964 arr[3] = inquiry_evpd_84(&arr[4]);
965 } else if (0x85 == cmd[2]) { /* Management network addresses */
966 arr[1] = cmd[2]; /*sanity */
967 arr[3] = inquiry_evpd_85(&arr[4]);
968 } else if (0x86 == cmd[2]) { /* extended inquiry */
969 arr[1] = cmd[2]; /*sanity */
970 arr[3] = 0x3c; /* number of following entries */
971 arr[4] = 0x0; /* no protection stuff */
972 arr[5] = 0x7; /* head of q, ordered + simple q's */
973 } else if (0x87 == cmd[2]) { /* mode page policy */
974 arr[1] = cmd[2]; /*sanity */
975 arr[3] = 0x8; /* number of following entries */
976 arr[4] = 0x2; /* disconnect-reconnect mp */
977 arr[6] = 0x80; /* mlus, shared */
978 arr[8] = 0x18; /* protocol specific lu */
979 arr[10] = 0x82; /* mlus, per initiator port */
980 } else if (0x88 == cmd[2]) { /* SCSI Ports */
981 arr[1] = cmd[2]; /*sanity */
982 arr[3] = inquiry_evpd_88(&arr[4], target_dev_id);
983 } else if (0x89 == cmd[2]) { /* ATA information */
984 arr[1] = cmd[2]; /*sanity */
985 n = inquiry_evpd_89(&arr[4]);
988 } else if (0xb0 == cmd[2]) { /* Block limits (SBC) */
989 arr[1] = cmd[2]; /*sanity */
990 arr[3] = inquiry_evpd_b0(&arr[4]);
992 /* Illegal request, invalid field in cdb */
993 mk_sense_buffer(devip, ILLEGAL_REQUEST,
994 INVALID_FIELD_IN_CDB, 0);
996 return check_condition_result;
998 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
999 ret = fill_from_dev_buffer(scp, arr,
1000 min(len, SDEBUG_MAX_INQ_ARR_SZ));
1004 /* drops through here for a standard inquiry */
1005 arr[1] = DEV_REMOVEABLE(target) ? 0x80 : 0; /* Removable disk */
1006 arr[2] = scsi_debug_scsi_level;
1007 arr[3] = 2; /* response_data_format==2 */
1008 arr[4] = SDEBUG_LONG_INQ_SZ - 5;
1009 if (0 == scsi_debug_vpd_use_hostno)
1010 arr[5] = 0x10; /* claim: implicit TGPS */
1011 arr[6] = 0x10; /* claim: MultiP */
1012 /* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
1013 arr[7] = 0xa; /* claim: LINKED + CMDQUE */
1014 memcpy(&arr[8], inq_vendor_id, 8);
1015 memcpy(&arr[16], inq_product_id, 16);
1016 memcpy(&arr[32], inq_product_rev, 4);
1017 /* version descriptors (2 bytes each) follow */
1018 arr[58] = 0x0; arr[59] = 0x77; /* SAM-3 ANSI */
1019 arr[60] = 0x3; arr[61] = 0x14; /* SPC-3 ANSI */
1021 if (scsi_debug_ptype == 0) {
1022 arr[n++] = 0x3; arr[n++] = 0x3d; /* SBC-2 ANSI */
1023 } else if (scsi_debug_ptype == 1) {
1024 arr[n++] = 0x3; arr[n++] = 0x60; /* SSC-2 no version */
1026 arr[n++] = 0xc; arr[n++] = 0xf; /* SAS-1.1 rev 10 */
1027 ret = fill_from_dev_buffer(scp, arr,
1028 min(alloc_len, SDEBUG_LONG_INQ_SZ));
1033 static int resp_requests(struct scsi_cmnd * scp,
1034 struct sdebug_dev_info * devip)
1036 unsigned char * sbuff;
1037 unsigned char *cmd = (unsigned char *)scp->cmnd;
1038 unsigned char arr[SDEBUG_SENSE_LEN];
1042 memset(arr, 0, sizeof(arr));
1043 if (devip->reset == 1)
1044 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
1045 want_dsense = !!(cmd[1] & 1) || scsi_debug_dsense;
1046 sbuff = devip->sense_buff;
1047 if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
1050 arr[1] = 0x0; /* NO_SENSE in sense_key */
1051 arr[2] = THRESHOLD_EXCEEDED;
1052 arr[3] = 0xff; /* TEST set and MRIE==6 */
1055 arr[2] = 0x0; /* NO_SENSE in sense_key */
1056 arr[7] = 0xa; /* 18 byte sense buffer */
1057 arr[12] = THRESHOLD_EXCEEDED;
1058 arr[13] = 0xff; /* TEST set and MRIE==6 */
1061 memcpy(arr, sbuff, SDEBUG_SENSE_LEN);
1062 if ((cmd[1] & 1) && (! scsi_debug_dsense)) {
1063 /* DESC bit set and sense_buff in fixed format */
1064 memset(arr, 0, sizeof(arr));
1066 arr[1] = sbuff[2]; /* sense key */
1067 arr[2] = sbuff[12]; /* asc */
1068 arr[3] = sbuff[13]; /* ascq */
1072 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
1073 return fill_from_dev_buffer(scp, arr, len);
1076 static int resp_start_stop(struct scsi_cmnd * scp,
1077 struct sdebug_dev_info * devip)
1079 unsigned char *cmd = (unsigned char *)scp->cmnd;
1080 int power_cond, errsts, start;
1082 if ((errsts = check_readiness(scp, 1, devip)))
1084 power_cond = (cmd[4] & 0xf0) >> 4;
1086 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1088 return check_condition_result;
1091 if (start == devip->stopped)
1092 devip->stopped = !start;
1096 #define SDEBUG_READCAP_ARR_SZ 8
1097 static int resp_readcap(struct scsi_cmnd * scp,
1098 struct sdebug_dev_info * devip)
1100 unsigned char arr[SDEBUG_READCAP_ARR_SZ];
1104 if ((errsts = check_readiness(scp, 1, devip)))
1106 /* following just in case virtual_gb changed */
1107 if (scsi_debug_virtual_gb > 0) {
1108 sdebug_capacity = 2048 * 1024;
1109 sdebug_capacity *= scsi_debug_virtual_gb;
1111 sdebug_capacity = sdebug_store_sectors;
1112 memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
1113 if (sdebug_capacity < 0xffffffff) {
1114 capac = (unsigned int)sdebug_capacity - 1;
1115 arr[0] = (capac >> 24);
1116 arr[1] = (capac >> 16) & 0xff;
1117 arr[2] = (capac >> 8) & 0xff;
1118 arr[3] = capac & 0xff;
1125 arr[6] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1126 arr[7] = SECT_SIZE_PER(target) & 0xff;
1127 return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
1130 #define SDEBUG_READCAP16_ARR_SZ 32
1131 static int resp_readcap16(struct scsi_cmnd * scp,
1132 struct sdebug_dev_info * devip)
1134 unsigned char *cmd = (unsigned char *)scp->cmnd;
1135 unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
1136 unsigned long long capac;
1137 int errsts, k, alloc_len;
1139 if ((errsts = check_readiness(scp, 1, devip)))
1141 alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8)
1143 /* following just in case virtual_gb changed */
1144 if (scsi_debug_virtual_gb > 0) {
1145 sdebug_capacity = 2048 * 1024;
1146 sdebug_capacity *= scsi_debug_virtual_gb;
1148 sdebug_capacity = sdebug_store_sectors;
1149 memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
1150 capac = sdebug_capacity - 1;
1151 for (k = 0; k < 8; ++k, capac >>= 8)
1152 arr[7 - k] = capac & 0xff;
1153 arr[8] = (SECT_SIZE_PER(target) >> 24) & 0xff;
1154 arr[9] = (SECT_SIZE_PER(target) >> 16) & 0xff;
1155 arr[10] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1156 arr[11] = SECT_SIZE_PER(target) & 0xff;
1157 return fill_from_dev_buffer(scp, arr,
1158 min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
1161 #define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
1163 static int resp_report_tgtpgs(struct scsi_cmnd * scp,
1164 struct sdebug_dev_info * devip)
1166 unsigned char *cmd = (unsigned char *)scp->cmnd;
1167 unsigned char * arr;
1168 int host_no = devip->sdbg_host->shost->host_no;
1169 int n, ret, alen, rlen;
1170 int port_group_a, port_group_b, port_a, port_b;
1172 alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8)
1175 arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
1177 return DID_REQUEUE << 16;
1179 * EVPD page 0x88 states we have two ports, one
1180 * real and a fake port with no device connected.
1181 * So we create two port groups with one port each
1182 * and set the group with port B to unavailable.
1184 port_a = 0x1; /* relative port A */
1185 port_b = 0x2; /* relative port B */
1186 port_group_a = (((host_no + 1) & 0x7f) << 8) +
1187 (devip->channel & 0x7f);
1188 port_group_b = (((host_no + 1) & 0x7f) << 8) +
1189 (devip->channel & 0x7f) + 0x80;
1192 * The asymmetric access state is cycled according to the host_id.
1195 if (0 == scsi_debug_vpd_use_hostno) {
1196 arr[n++] = host_no % 3; /* Asymm access state */
1197 arr[n++] = 0x0F; /* claim: all states are supported */
1199 arr[n++] = 0x0; /* Active/Optimized path */
1200 arr[n++] = 0x01; /* claim: only support active/optimized paths */
1202 arr[n++] = (port_group_a >> 8) & 0xff;
1203 arr[n++] = port_group_a & 0xff;
1204 arr[n++] = 0; /* Reserved */
1205 arr[n++] = 0; /* Status code */
1206 arr[n++] = 0; /* Vendor unique */
1207 arr[n++] = 0x1; /* One port per group */
1208 arr[n++] = 0; /* Reserved */
1209 arr[n++] = 0; /* Reserved */
1210 arr[n++] = (port_a >> 8) & 0xff;
1211 arr[n++] = port_a & 0xff;
1212 arr[n++] = 3; /* Port unavailable */
1213 arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
1214 arr[n++] = (port_group_b >> 8) & 0xff;
1215 arr[n++] = port_group_b & 0xff;
1216 arr[n++] = 0; /* Reserved */
1217 arr[n++] = 0; /* Status code */
1218 arr[n++] = 0; /* Vendor unique */
1219 arr[n++] = 0x1; /* One port per group */
1220 arr[n++] = 0; /* Reserved */
1221 arr[n++] = 0; /* Reserved */
1222 arr[n++] = (port_b >> 8) & 0xff;
1223 arr[n++] = port_b & 0xff;
1226 arr[0] = (rlen >> 24) & 0xff;
1227 arr[1] = (rlen >> 16) & 0xff;
1228 arr[2] = (rlen >> 8) & 0xff;
1229 arr[3] = rlen & 0xff;
1232 * Return the smallest value of either
1233 * - The allocated length
1234 * - The constructed command length
1235 * - The maximum array size
1238 ret = fill_from_dev_buffer(scp, arr,
1239 min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
1244 /* <<Following mode page info copied from ST318451LW>> */
1246 static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
1247 { /* Read-Write Error Recovery page for mode_sense */
1248 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
1251 memcpy(p, err_recov_pg, sizeof(err_recov_pg));
1253 memset(p + 2, 0, sizeof(err_recov_pg) - 2);
1254 return sizeof(err_recov_pg);
1257 static int resp_disconnect_pg(unsigned char * p, int pcontrol, int target)
1258 { /* Disconnect-Reconnect page for mode_sense */
1259 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
1260 0, 0, 0, 0, 0, 0, 0, 0};
1262 memcpy(p, disconnect_pg, sizeof(disconnect_pg));
1264 memset(p + 2, 0, sizeof(disconnect_pg) - 2);
1265 return sizeof(disconnect_pg);
1268 static int resp_format_pg(unsigned char * p, int pcontrol, int target)
1269 { /* Format device page for mode_sense */
1270 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
1271 0, 0, 0, 0, 0, 0, 0, 0,
1272 0, 0, 0, 0, 0x40, 0, 0, 0};
1274 memcpy(p, format_pg, sizeof(format_pg));
1275 p[10] = (sdebug_sectors_per >> 8) & 0xff;
1276 p[11] = sdebug_sectors_per & 0xff;
1277 p[12] = (SECT_SIZE >> 8) & 0xff;
1278 p[13] = SECT_SIZE & 0xff;
1279 if (DEV_REMOVEABLE(target))
1280 p[20] |= 0x20; /* should agree with INQUIRY */
1282 memset(p + 2, 0, sizeof(format_pg) - 2);
1283 return sizeof(format_pg);
1286 static int resp_caching_pg(unsigned char * p, int pcontrol, int target)
1287 { /* Caching page for mode_sense */
1288 unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1289 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
1291 memcpy(p, caching_pg, sizeof(caching_pg));
1293 memset(p + 2, 0, sizeof(caching_pg) - 2);
1294 return sizeof(caching_pg);
1297 static int resp_ctrl_m_pg(unsigned char * p, int pcontrol, int target)
1298 { /* Control mode page for mode_sense */
1299 unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
1301 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1304 if (scsi_debug_dsense)
1305 ctrl_m_pg[2] |= 0x4;
1307 ctrl_m_pg[2] &= ~0x4;
1308 memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
1310 memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
1311 else if (2 == pcontrol)
1312 memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
1313 return sizeof(ctrl_m_pg);
1317 static int resp_iec_m_pg(unsigned char * p, int pcontrol, int target)
1318 { /* Informational Exceptions control mode page for mode_sense */
1319 unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
1321 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1324 memcpy(p, iec_m_pg, sizeof(iec_m_pg));
1326 memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
1327 else if (2 == pcontrol)
1328 memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
1329 return sizeof(iec_m_pg);
1332 static int resp_sas_sf_m_pg(unsigned char * p, int pcontrol, int target)
1333 { /* SAS SSP mode page - short format for mode_sense */
1334 unsigned char sas_sf_m_pg[] = {0x19, 0x6,
1335 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
1337 memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
1339 memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
1340 return sizeof(sas_sf_m_pg);
1344 static int resp_sas_pcd_m_spg(unsigned char * p, int pcontrol, int target,
1346 { /* SAS phy control and discover mode page for mode_sense */
1347 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
1348 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
1349 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1350 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1351 0x2, 0, 0, 0, 0, 0, 0, 0,
1352 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1353 0, 0, 0, 0, 0, 0, 0, 0,
1354 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
1355 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1356 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1357 0x3, 0, 0, 0, 0, 0, 0, 0,
1358 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1359 0, 0, 0, 0, 0, 0, 0, 0,
1363 port_a = target_dev_id + 1;
1364 port_b = port_a + 1;
1365 memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
1366 p[20] = (port_a >> 24);
1367 p[21] = (port_a >> 16) & 0xff;
1368 p[22] = (port_a >> 8) & 0xff;
1369 p[23] = port_a & 0xff;
1370 p[48 + 20] = (port_b >> 24);
1371 p[48 + 21] = (port_b >> 16) & 0xff;
1372 p[48 + 22] = (port_b >> 8) & 0xff;
1373 p[48 + 23] = port_b & 0xff;
1375 memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
1376 return sizeof(sas_pcd_m_pg);
1379 static int resp_sas_sha_m_spg(unsigned char * p, int pcontrol)
1380 { /* SAS SSP shared protocol specific port mode subpage */
1381 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
1382 0, 0, 0, 0, 0, 0, 0, 0,
1385 memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
1387 memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
1388 return sizeof(sas_sha_m_pg);
1391 #define SDEBUG_MAX_MSENSE_SZ 256
1393 static int resp_mode_sense(struct scsi_cmnd * scp, int target,
1394 struct sdebug_dev_info * devip)
1396 unsigned char dbd, llbaa;
1397 int pcontrol, pcode, subpcode, bd_len;
1398 unsigned char dev_spec;
1399 int k, alloc_len, msense_6, offset, len, errsts, target_dev_id;
1401 unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
1402 unsigned char *cmd = (unsigned char *)scp->cmnd;
1404 if ((errsts = check_readiness(scp, 1, devip)))
1406 dbd = !!(cmd[1] & 0x8);
1407 pcontrol = (cmd[2] & 0xc0) >> 6;
1408 pcode = cmd[2] & 0x3f;
1410 msense_6 = (MODE_SENSE == cmd[0]);
1411 llbaa = msense_6 ? 0 : !!(cmd[1] & 0x10);
1412 if ((0 == scsi_debug_ptype) && (0 == dbd))
1413 bd_len = llbaa ? 16 : 8;
1416 alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]);
1417 memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
1418 if (0x3 == pcontrol) { /* Saving values not supported */
1419 mk_sense_buffer(devip, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP,
1421 return check_condition_result;
1423 target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
1424 (devip->target * 1000) - 3;
1425 /* set DPOFUA bit for disks */
1426 if (0 == scsi_debug_ptype)
1427 dev_spec = (DEV_READONLY(target) ? 0x80 : 0x0) | 0x10;
1437 arr[4] = 0x1; /* set LONGLBA bit */
1438 arr[7] = bd_len; /* assume 255 or less */
1442 if ((bd_len > 0) && (0 == sdebug_capacity)) {
1443 if (scsi_debug_virtual_gb > 0) {
1444 sdebug_capacity = 2048 * 1024;
1445 sdebug_capacity *= scsi_debug_virtual_gb;
1447 sdebug_capacity = sdebug_store_sectors;
1450 if (sdebug_capacity > 0xfffffffe) {
1456 ap[0] = (sdebug_capacity >> 24) & 0xff;
1457 ap[1] = (sdebug_capacity >> 16) & 0xff;
1458 ap[2] = (sdebug_capacity >> 8) & 0xff;
1459 ap[3] = sdebug_capacity & 0xff;
1461 ap[6] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1462 ap[7] = SECT_SIZE_PER(target) & 0xff;
1465 } else if (16 == bd_len) {
1466 unsigned long long capac = sdebug_capacity;
1468 for (k = 0; k < 8; ++k, capac >>= 8)
1469 ap[7 - k] = capac & 0xff;
1470 ap[12] = (SECT_SIZE_PER(target) >> 24) & 0xff;
1471 ap[13] = (SECT_SIZE_PER(target) >> 16) & 0xff;
1472 ap[14] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1473 ap[15] = SECT_SIZE_PER(target) & 0xff;
1478 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
1479 /* TODO: Control Extension page */
1480 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1482 return check_condition_result;
1485 case 0x1: /* Read-Write error recovery page, direct access */
1486 len = resp_err_recov_pg(ap, pcontrol, target);
1489 case 0x2: /* Disconnect-Reconnect page, all devices */
1490 len = resp_disconnect_pg(ap, pcontrol, target);
1493 case 0x3: /* Format device page, direct access */
1494 len = resp_format_pg(ap, pcontrol, target);
1497 case 0x8: /* Caching page, direct access */
1498 len = resp_caching_pg(ap, pcontrol, target);
1501 case 0xa: /* Control Mode page, all devices */
1502 len = resp_ctrl_m_pg(ap, pcontrol, target);
1505 case 0x19: /* if spc==1 then sas phy, control+discover */
1506 if ((subpcode > 0x2) && (subpcode < 0xff)) {
1507 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1508 INVALID_FIELD_IN_CDB, 0);
1509 return check_condition_result;
1512 if ((0x0 == subpcode) || (0xff == subpcode))
1513 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1514 if ((0x1 == subpcode) || (0xff == subpcode))
1515 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
1517 if ((0x2 == subpcode) || (0xff == subpcode))
1518 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1521 case 0x1c: /* Informational Exceptions Mode page, all devices */
1522 len = resp_iec_m_pg(ap, pcontrol, target);
1525 case 0x3f: /* Read all Mode pages */
1526 if ((0 == subpcode) || (0xff == subpcode)) {
1527 len = resp_err_recov_pg(ap, pcontrol, target);
1528 len += resp_disconnect_pg(ap + len, pcontrol, target);
1529 len += resp_format_pg(ap + len, pcontrol, target);
1530 len += resp_caching_pg(ap + len, pcontrol, target);
1531 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
1532 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1533 if (0xff == subpcode) {
1534 len += resp_sas_pcd_m_spg(ap + len, pcontrol,
1535 target, target_dev_id);
1536 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1538 len += resp_iec_m_pg(ap + len, pcontrol, target);
1540 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1541 INVALID_FIELD_IN_CDB, 0);
1542 return check_condition_result;
1547 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1549 return check_condition_result;
1552 arr[0] = offset - 1;
1554 arr[0] = ((offset - 2) >> 8) & 0xff;
1555 arr[1] = (offset - 2) & 0xff;
1557 return fill_from_dev_buffer(scp, arr, min(alloc_len, offset));
1560 #define SDEBUG_MAX_MSELECT_SZ 512
1562 static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
1563 struct sdebug_dev_info * devip)
1565 int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
1566 int param_len, res, errsts, mpage;
1567 unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
1568 unsigned char *cmd = (unsigned char *)scp->cmnd;
1570 if ((errsts = check_readiness(scp, 1, devip)))
1572 memset(arr, 0, sizeof(arr));
1575 param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]);
1576 if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
1577 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1578 INVALID_FIELD_IN_CDB, 0);
1579 return check_condition_result;
1581 res = fetch_to_dev_buffer(scp, arr, param_len);
1583 return (DID_ERROR << 16);
1584 else if ((res < param_len) &&
1585 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1586 printk(KERN_INFO "scsi_debug: mode_select: cdb indicated=%d, "
1587 " IO sent=%d bytes\n", param_len, res);
1588 md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2);
1589 bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]);
1591 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1592 INVALID_FIELD_IN_PARAM_LIST, 0);
1593 return check_condition_result;
1595 off = bd_len + (mselect6 ? 4 : 8);
1596 mpage = arr[off] & 0x3f;
1597 ps = !!(arr[off] & 0x80);
1599 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1600 INVALID_FIELD_IN_PARAM_LIST, 0);
1601 return check_condition_result;
1603 spf = !!(arr[off] & 0x40);
1604 pg_len = spf ? ((arr[off + 2] << 8) + arr[off + 3] + 4) :
1606 if ((pg_len + off) > param_len) {
1607 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1608 PARAMETER_LIST_LENGTH_ERR, 0);
1609 return check_condition_result;
1612 case 0xa: /* Control Mode page */
1613 if (ctrl_m_pg[1] == arr[off + 1]) {
1614 memcpy(ctrl_m_pg + 2, arr + off + 2,
1615 sizeof(ctrl_m_pg) - 2);
1616 scsi_debug_dsense = !!(ctrl_m_pg[2] & 0x4);
1620 case 0x1c: /* Informational Exceptions Mode page */
1621 if (iec_m_pg[1] == arr[off + 1]) {
1622 memcpy(iec_m_pg + 2, arr + off + 2,
1623 sizeof(iec_m_pg) - 2);
1630 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1631 INVALID_FIELD_IN_PARAM_LIST, 0);
1632 return check_condition_result;
1635 static int resp_temp_l_pg(unsigned char * arr)
1637 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
1638 0x0, 0x1, 0x3, 0x2, 0x0, 65,
1641 memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
1642 return sizeof(temp_l_pg);
1645 static int resp_ie_l_pg(unsigned char * arr)
1647 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
1650 memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
1651 if (iec_m_pg[2] & 0x4) { /* TEST bit set */
1652 arr[4] = THRESHOLD_EXCEEDED;
1655 return sizeof(ie_l_pg);
1658 #define SDEBUG_MAX_LSENSE_SZ 512
1660 static int resp_log_sense(struct scsi_cmnd * scp,
1661 struct sdebug_dev_info * devip)
1663 int ppc, sp, pcontrol, pcode, subpcode, alloc_len, errsts, len, n;
1664 unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
1665 unsigned char *cmd = (unsigned char *)scp->cmnd;
1667 if ((errsts = check_readiness(scp, 1, devip)))
1669 memset(arr, 0, sizeof(arr));
1673 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1674 INVALID_FIELD_IN_CDB, 0);
1675 return check_condition_result;
1677 pcontrol = (cmd[2] & 0xc0) >> 6;
1678 pcode = cmd[2] & 0x3f;
1679 subpcode = cmd[3] & 0xff;
1680 alloc_len = (cmd[7] << 8) + cmd[8];
1682 if (0 == subpcode) {
1684 case 0x0: /* Supported log pages log page */
1686 arr[n++] = 0x0; /* this page */
1687 arr[n++] = 0xd; /* Temperature */
1688 arr[n++] = 0x2f; /* Informational exceptions */
1691 case 0xd: /* Temperature log page */
1692 arr[3] = resp_temp_l_pg(arr + 4);
1694 case 0x2f: /* Informational exceptions log page */
1695 arr[3] = resp_ie_l_pg(arr + 4);
1698 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1699 INVALID_FIELD_IN_CDB, 0);
1700 return check_condition_result;
1702 } else if (0xff == subpcode) {
1706 case 0x0: /* Supported log pages and subpages log page */
1709 arr[n++] = 0x0; /* 0,0 page */
1711 arr[n++] = 0xff; /* this page */
1713 arr[n++] = 0x0; /* Temperature */
1715 arr[n++] = 0x0; /* Informational exceptions */
1718 case 0xd: /* Temperature subpages */
1721 arr[n++] = 0x0; /* Temperature */
1724 case 0x2f: /* Informational exceptions subpages */
1727 arr[n++] = 0x0; /* Informational exceptions */
1731 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1732 INVALID_FIELD_IN_CDB, 0);
1733 return check_condition_result;
1736 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1737 INVALID_FIELD_IN_CDB, 0);
1738 return check_condition_result;
1740 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
1741 return fill_from_dev_buffer(scp, arr,
1742 min(len, SDEBUG_MAX_INQ_ARR_SZ));
1745 static int resp_read(struct scsi_cmnd * SCpnt, unsigned long long lba,
1746 unsigned int num, struct sdebug_dev_info * devip)
1748 unsigned long iflags;
1749 unsigned int block, from_bottom;
1750 unsigned long long u;
1753 if (lba + num > sdebug_capacity) {
1754 mk_sense_buffer(devip, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE,
1756 return check_condition_result;
1758 /* transfer length excessive (tie in to block limits VPD page) */
1759 if (num > sdebug_store_sectors) {
1760 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1762 return check_condition_result;
1764 if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) &&
1765 (lba <= OPT_MEDIUM_ERR_ADDR) &&
1766 ((lba + num) > OPT_MEDIUM_ERR_ADDR)) {
1767 /* claim unrecoverable read error */
1768 mk_sense_buffer(devip, MEDIUM_ERROR, UNRECOVERED_READ_ERR,
1770 /* set info field and valid bit for fixed descriptor */
1771 if (0x70 == (devip->sense_buff[0] & 0x7f)) {
1772 devip->sense_buff[0] |= 0x80; /* Valid bit */
1773 ret = OPT_MEDIUM_ERR_ADDR;
1774 devip->sense_buff[3] = (ret >> 24) & 0xff;
1775 devip->sense_buff[4] = (ret >> 16) & 0xff;
1776 devip->sense_buff[5] = (ret >> 8) & 0xff;
1777 devip->sense_buff[6] = ret & 0xff;
1779 return check_condition_result;
1781 read_lock_irqsave(&atomic_rw, iflags);
1782 if ((lba + num) <= sdebug_store_sectors)
1783 ret = fill_from_dev_buffer(SCpnt,
1784 fake_storep + (lba * SECT_SIZE),
1787 /* modulo when one arg is 64 bits needs do_div() */
1789 block = do_div(u, sdebug_store_sectors);
1791 if ((block + num) > sdebug_store_sectors)
1792 from_bottom = (block + num) - sdebug_store_sectors;
1793 ret = fill_from_dev_buffer(SCpnt,
1794 fake_storep + (block * SECT_SIZE),
1795 (num - from_bottom) * SECT_SIZE);
1796 if ((0 == ret) && (from_bottom > 0))
1797 ret = fill_from_dev_buffer(SCpnt, fake_storep,
1798 from_bottom * SECT_SIZE);
1800 read_unlock_irqrestore(&atomic_rw, iflags);
1804 static int resp_write(struct scsi_cmnd * SCpnt, unsigned long long lba,
1805 unsigned int num, struct sdebug_dev_info * devip)
1807 unsigned long iflags;
1808 unsigned int block, to_bottom;
1809 unsigned long long u;
1812 if (lba + num > sdebug_capacity) {
1813 mk_sense_buffer(devip, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE,
1815 return check_condition_result;
1817 /* transfer length excessive (tie in to block limits VPD page) */
1818 if (num > sdebug_store_sectors) {
1819 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1821 return check_condition_result;
1824 write_lock_irqsave(&atomic_rw, iflags);
1825 if ((lba + num) <= sdebug_store_sectors)
1826 res = fetch_to_dev_buffer(SCpnt,
1827 fake_storep + (lba * SECT_SIZE),
1830 /* modulo when one arg is 64 bits needs do_div() */
1832 block = do_div(u, sdebug_store_sectors);
1834 if ((block + num) > sdebug_store_sectors)
1835 to_bottom = (block + num) - sdebug_store_sectors;
1836 res = fetch_to_dev_buffer(SCpnt,
1837 fake_storep + (block * SECT_SIZE),
1838 (num - to_bottom) * SECT_SIZE);
1839 if ((0 == res) && (to_bottom > 0))
1840 res = fetch_to_dev_buffer(SCpnt, fake_storep,
1841 to_bottom * SECT_SIZE);
1843 write_unlock_irqrestore(&atomic_rw, iflags);
1845 return (DID_ERROR << 16);
1846 else if ((res < (num * SECT_SIZE)) &&
1847 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1848 printk(KERN_INFO "scsi_debug: write: cdb indicated=%u, "
1849 " IO sent=%d bytes\n", num * SECT_SIZE, res);
1853 #define SDEBUG_RLUN_ARR_SZ 256
1855 static int resp_report_luns(struct scsi_cmnd * scp,
1856 struct sdebug_dev_info * devip)
1858 unsigned int alloc_len;
1859 int lun_cnt, i, upper, num, n, wlun, lun;
1860 unsigned char *cmd = (unsigned char *)scp->cmnd;
1861 int select_report = (int)cmd[2];
1862 struct scsi_lun *one_lun;
1863 unsigned char arr[SDEBUG_RLUN_ARR_SZ];
1864 unsigned char * max_addr;
1866 alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
1867 if ((alloc_len < 4) || (select_report > 2)) {
1868 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1870 return check_condition_result;
1872 /* can produce response with up to 16k luns (lun 0 to lun 16383) */
1873 memset(arr, 0, SDEBUG_RLUN_ARR_SZ);
1874 lun_cnt = scsi_debug_max_luns;
1875 if (1 == select_report)
1877 else if (scsi_debug_no_lun_0 && (lun_cnt > 0))
1879 wlun = (select_report > 0) ? 1 : 0;
1880 num = lun_cnt + wlun;
1881 arr[2] = ((sizeof(struct scsi_lun) * num) >> 8) & 0xff;
1882 arr[3] = (sizeof(struct scsi_lun) * num) & 0xff;
1883 n = min((int)((SDEBUG_RLUN_ARR_SZ - 8) /
1884 sizeof(struct scsi_lun)), num);
1889 one_lun = (struct scsi_lun *) &arr[8];
1890 max_addr = arr + SDEBUG_RLUN_ARR_SZ;
1891 for (i = 0, lun = (scsi_debug_no_lun_0 ? 1 : 0);
1892 ((i < lun_cnt) && ((unsigned char *)(one_lun + i) < max_addr));
1894 upper = (lun >> 8) & 0x3f;
1896 one_lun[i].scsi_lun[0] =
1897 (upper | (SAM2_LUN_ADDRESS_METHOD << 6));
1898 one_lun[i].scsi_lun[1] = lun & 0xff;
1901 one_lun[i].scsi_lun[0] = (SAM2_WLUN_REPORT_LUNS >> 8) & 0xff;
1902 one_lun[i].scsi_lun[1] = SAM2_WLUN_REPORT_LUNS & 0xff;
1905 alloc_len = (unsigned char *)(one_lun + i) - arr;
1906 return fill_from_dev_buffer(scp, arr,
1907 min((int)alloc_len, SDEBUG_RLUN_ARR_SZ));
1910 static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
1911 unsigned int num, struct sdebug_dev_info *devip)
1914 unsigned char *kaddr, *buf;
1915 unsigned int offset;
1916 struct scatterlist *sg;
1917 struct scsi_data_buffer *sdb = scsi_in(scp);
1919 /* better not to use temporary buffer. */
1920 buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
1924 scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
1927 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, i) {
1928 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
1932 for (j = 0; j < sg->length; j++)
1933 *(kaddr + sg->offset + j) ^= *(buf + offset + j);
1935 offset += sg->length;
1936 kunmap_atomic(kaddr, KM_USER0);
1945 /* When timer goes off this function is called. */
1946 static void timer_intr_handler(unsigned long indx)
1948 struct sdebug_queued_cmd * sqcp;
1949 unsigned long iflags;
1951 if (indx >= SCSI_DEBUG_CANQUEUE) {
1952 printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too "
1956 spin_lock_irqsave(&queued_arr_lock, iflags);
1957 sqcp = &queued_arr[(int)indx];
1958 if (! sqcp->in_use) {
1959 printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected "
1961 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1965 if (sqcp->done_funct) {
1966 sqcp->a_cmnd->result = sqcp->scsi_result;
1967 sqcp->done_funct(sqcp->a_cmnd); /* callback to mid level */
1969 sqcp->done_funct = NULL;
1970 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1973 static int scsi_debug_slave_alloc(struct scsi_device * sdp)
1975 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1976 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
1977 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
1978 set_bit(QUEUE_FLAG_BIDI, &sdp->request_queue->queue_flags);
1982 static int scsi_debug_slave_configure(struct scsi_device * sdp)
1984 struct sdebug_dev_info * devip;
1986 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1987 printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n",
1988 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
1989 if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN)
1990 sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN;
1991 devip = devInfoReg(sdp);
1993 return 1; /* no resources, will be marked offline */
1994 sdp->hostdata = devip;
1995 if (sdp->host->cmd_per_lun)
1996 scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING,
1997 sdp->host->cmd_per_lun);
1998 blk_queue_max_segment_size(sdp->request_queue, 256 * 1024);
2002 static void scsi_debug_slave_destroy(struct scsi_device * sdp)
2004 struct sdebug_dev_info * devip =
2005 (struct sdebug_dev_info *)sdp->hostdata;
2007 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2008 printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n",
2009 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2011 /* make this slot avaliable for re-use */
2013 sdp->hostdata = NULL;
2017 struct sdebug_dev_info *sdebug_device_create(struct sdebug_host_info *sdbg_host,
2020 struct sdebug_dev_info *devip;
2022 devip = kzalloc(sizeof(*devip), flags);
2024 devip->sdbg_host = sdbg_host;
2025 list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
2030 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
2032 struct sdebug_host_info * sdbg_host;
2033 struct sdebug_dev_info * open_devip = NULL;
2034 struct sdebug_dev_info * devip =
2035 (struct sdebug_dev_info *)sdev->hostdata;
2039 sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
2041 printk(KERN_ERR "Host info NULL\n");
2044 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
2045 if ((devip->used) && (devip->channel == sdev->channel) &&
2046 (devip->target == sdev->id) &&
2047 (devip->lun == sdev->lun))
2050 if ((!devip->used) && (!open_devip))
2054 if (!open_devip) { /* try and make a new one */
2055 open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC);
2057 printk(KERN_ERR "%s: out of memory at line %d\n",
2058 __FUNCTION__, __LINE__);
2063 open_devip->channel = sdev->channel;
2064 open_devip->target = sdev->id;
2065 open_devip->lun = sdev->lun;
2066 open_devip->sdbg_host = sdbg_host;
2067 open_devip->reset = 1;
2068 open_devip->used = 1;
2069 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
2070 if (scsi_debug_dsense)
2071 open_devip->sense_buff[0] = 0x72;
2073 open_devip->sense_buff[0] = 0x70;
2074 open_devip->sense_buff[7] = 0xa;
2076 if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
2077 open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
2083 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
2086 unsigned char * sbuff;
2088 sbuff = devip->sense_buff;
2089 memset(sbuff, 0, SDEBUG_SENSE_LEN);
2090 if (scsi_debug_dsense) {
2091 sbuff[0] = 0x72; /* descriptor, current */
2096 sbuff[0] = 0x70; /* fixed, current */
2098 sbuff[7] = 0xa; /* implies 18 byte sense buffer */
2102 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2103 printk(KERN_INFO "scsi_debug: [sense_key,asc,ascq]: "
2104 "[0x%x,0x%x,0x%x]\n", key, asc, asq);
2107 static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
2109 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2110 printk(KERN_INFO "scsi_debug: abort\n");
2112 stop_queued_cmnd(SCpnt);
2116 static int scsi_debug_biosparam(struct scsi_device *sdev,
2117 struct block_device * bdev, sector_t capacity, int *info)
2122 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2123 printk(KERN_INFO "scsi_debug: biosparam\n");
2124 buf = scsi_bios_ptable(bdev);
2126 res = scsi_partsize(buf, capacity,
2127 &info[2], &info[0], &info[1]);
2132 info[0] = sdebug_heads;
2133 info[1] = sdebug_sectors_per;
2134 info[2] = sdebug_cylinders_per;
2138 static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
2140 struct sdebug_dev_info * devip;
2142 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2143 printk(KERN_INFO "scsi_debug: device_reset\n");
2146 devip = devInfoReg(SCpnt->device);
2153 static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
2155 struct sdebug_host_info *sdbg_host;
2156 struct sdebug_dev_info * dev_info;
2157 struct scsi_device * sdp;
2158 struct Scsi_Host * hp;
2160 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2161 printk(KERN_INFO "scsi_debug: bus_reset\n");
2163 if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
2164 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
2166 list_for_each_entry(dev_info,
2167 &sdbg_host->dev_info_list,
2169 dev_info->reset = 1;
2175 static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
2177 struct sdebug_host_info * sdbg_host;
2178 struct sdebug_dev_info * dev_info;
2180 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2181 printk(KERN_INFO "scsi_debug: host_reset\n");
2183 spin_lock(&sdebug_host_list_lock);
2184 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
2185 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
2187 dev_info->reset = 1;
2189 spin_unlock(&sdebug_host_list_lock);
2194 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
2195 static int stop_queued_cmnd(struct scsi_cmnd * cmnd)
2197 unsigned long iflags;
2199 struct sdebug_queued_cmd * sqcp;
2201 spin_lock_irqsave(&queued_arr_lock, iflags);
2202 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2203 sqcp = &queued_arr[k];
2204 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
2205 del_timer_sync(&sqcp->cmnd_timer);
2207 sqcp->a_cmnd = NULL;
2211 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2212 return (k < SCSI_DEBUG_CANQUEUE) ? 1 : 0;
2215 /* Deletes (stops) timers of all queued commands */
2216 static void stop_all_queued(void)
2218 unsigned long iflags;
2220 struct sdebug_queued_cmd * sqcp;
2222 spin_lock_irqsave(&queued_arr_lock, iflags);
2223 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2224 sqcp = &queued_arr[k];
2225 if (sqcp->in_use && sqcp->a_cmnd) {
2226 del_timer_sync(&sqcp->cmnd_timer);
2228 sqcp->a_cmnd = NULL;
2231 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2234 /* Initializes timers in queued array */
2235 static void __init init_all_queued(void)
2237 unsigned long iflags;
2239 struct sdebug_queued_cmd * sqcp;
2241 spin_lock_irqsave(&queued_arr_lock, iflags);
2242 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2243 sqcp = &queued_arr[k];
2244 init_timer(&sqcp->cmnd_timer);
2246 sqcp->a_cmnd = NULL;
2248 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2251 static void __init sdebug_build_parts(unsigned char * ramp)
2253 struct partition * pp;
2254 int starts[SDEBUG_MAX_PARTS + 2];
2255 int sectors_per_part, num_sectors, k;
2256 int heads_by_sects, start_sec, end_sec;
2258 /* assume partition table already zeroed */
2259 if ((scsi_debug_num_parts < 1) || (sdebug_store_size < 1048576))
2261 if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
2262 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
2263 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
2264 "partitions to %d\n", SDEBUG_MAX_PARTS);
2266 num_sectors = (int)sdebug_store_sectors;
2267 sectors_per_part = (num_sectors - sdebug_sectors_per)
2268 / scsi_debug_num_parts;
2269 heads_by_sects = sdebug_heads * sdebug_sectors_per;
2270 starts[0] = sdebug_sectors_per;
2271 for (k = 1; k < scsi_debug_num_parts; ++k)
2272 starts[k] = ((k * sectors_per_part) / heads_by_sects)
2274 starts[scsi_debug_num_parts] = num_sectors;
2275 starts[scsi_debug_num_parts + 1] = 0;
2277 ramp[510] = 0x55; /* magic partition markings */
2279 pp = (struct partition *)(ramp + 0x1be);
2280 for (k = 0; starts[k + 1]; ++k, ++pp) {
2281 start_sec = starts[k];
2282 end_sec = starts[k + 1] - 1;
2285 pp->cyl = start_sec / heads_by_sects;
2286 pp->head = (start_sec - (pp->cyl * heads_by_sects))
2287 / sdebug_sectors_per;
2288 pp->sector = (start_sec % sdebug_sectors_per) + 1;
2290 pp->end_cyl = end_sec / heads_by_sects;
2291 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
2292 / sdebug_sectors_per;
2293 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2295 pp->start_sect = start_sec;
2296 pp->nr_sects = end_sec - start_sec + 1;
2297 pp->sys_ind = 0x83; /* plain Linux partition */
2301 static int schedule_resp(struct scsi_cmnd * cmnd,
2302 struct sdebug_dev_info * devip,
2303 done_funct_t done, int scsi_result, int delta_jiff)
2305 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
2307 struct scsi_device * sdp = cmnd->device;
2309 printk(KERN_INFO "scsi_debug: <%u %u %u %u> "
2310 "non-zero result=0x%x\n", sdp->host->host_no,
2311 sdp->channel, sdp->id, sdp->lun, scsi_result);
2314 if (cmnd && devip) {
2315 /* simulate autosense by this driver */
2316 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
2317 memcpy(cmnd->sense_buffer, devip->sense_buff,
2318 (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
2319 SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
2321 if (delta_jiff <= 0) {
2323 cmnd->result = scsi_result;
2328 unsigned long iflags;
2330 struct sdebug_queued_cmd * sqcp = NULL;
2332 spin_lock_irqsave(&queued_arr_lock, iflags);
2333 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2334 sqcp = &queued_arr[k];
2338 if (k >= SCSI_DEBUG_CANQUEUE) {
2339 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2340 printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
2341 return 1; /* report busy to mid level */
2344 sqcp->a_cmnd = cmnd;
2345 sqcp->scsi_result = scsi_result;
2346 sqcp->done_funct = done;
2347 sqcp->cmnd_timer.function = timer_intr_handler;
2348 sqcp->cmnd_timer.data = k;
2349 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
2350 add_timer(&sqcp->cmnd_timer);
2351 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2358 /* Note: The following macros create attribute files in the
2359 /sys/module/scsi_debug/parameters directory. Unfortunately this
2360 driver is unaware of a change and cannot trigger auxiliary actions
2361 as it can when the corresponding attribute in the
2362 /sys/bus/pseudo/drivers/scsi_debug directory is changed.
2364 module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
2365 module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
2366 module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
2367 module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
2368 module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
2369 module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
2370 module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
2371 module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
2372 module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
2373 module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
2374 module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
2375 module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
2376 module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
2377 module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
2378 module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
2381 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2382 MODULE_DESCRIPTION("SCSI debug adapter driver");
2383 MODULE_LICENSE("GPL");
2384 MODULE_VERSION(SCSI_DEBUG_VERSION);
2386 MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
2387 MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
2388 MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
2389 MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
2390 MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
2391 MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
2392 MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
2393 MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
2394 MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
2395 MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
2396 MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
2397 MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
2398 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
2399 MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
2400 MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2403 static char sdebug_info[256];
2405 static const char * scsi_debug_info(struct Scsi_Host * shp)
2407 sprintf(sdebug_info, "scsi_debug, version %s [%s], "
2408 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
2409 scsi_debug_version_date, scsi_debug_dev_size_mb,
2414 /* scsi_debug_proc_info
2415 * Used if the driver currently has no own support for /proc/scsi
2417 static int scsi_debug_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
2418 int length, int inout)
2420 int len, pos, begin;
2423 orig_length = length;
2427 int minLen = length > 15 ? 15 : length;
2429 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2431 memcpy(arr, buffer, minLen);
2433 if (1 != sscanf(arr, "%d", &pos))
2435 scsi_debug_opts = pos;
2436 if (scsi_debug_every_nth != 0)
2437 scsi_debug_cmnd_count = 0;
2441 pos = len = sprintf(buffer, "scsi_debug adapter driver, version "
2443 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2444 "every_nth=%d(curr:%d)\n"
2445 "delay=%d, max_luns=%d, scsi_level=%d\n"
2446 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2447 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2449 SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
2450 scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2451 scsi_debug_cmnd_count, scsi_debug_delay,
2452 scsi_debug_max_luns, scsi_debug_scsi_level,
2453 SECT_SIZE, sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
2454 num_aborts, num_dev_resets, num_bus_resets, num_host_resets);
2459 *start = buffer + (offset - begin); /* Start of wanted data */
2460 len -= (offset - begin);
2466 static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf)
2468 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
2471 static ssize_t sdebug_delay_store(struct device_driver * ddp,
2472 const char * buf, size_t count)
2477 if (1 == sscanf(buf, "%10s", work)) {
2478 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
2479 scsi_debug_delay = delay;
2485 DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show,
2486 sdebug_delay_store);
2488 static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf)
2490 return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
2493 static ssize_t sdebug_opts_store(struct device_driver * ddp,
2494 const char * buf, size_t count)
2499 if (1 == sscanf(buf, "%10s", work)) {
2500 if (0 == strnicmp(work,"0x", 2)) {
2501 if (1 == sscanf(&work[2], "%x", &opts))
2504 if (1 == sscanf(work, "%d", &opts))
2510 scsi_debug_opts = opts;
2511 scsi_debug_cmnd_count = 0;
2514 DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show,
2517 static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf)
2519 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
2521 static ssize_t sdebug_ptype_store(struct device_driver * ddp,
2522 const char * buf, size_t count)
2526 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2527 scsi_debug_ptype = n;
2532 DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store);
2534 static ssize_t sdebug_dsense_show(struct device_driver * ddp, char * buf)
2536 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
2538 static ssize_t sdebug_dsense_store(struct device_driver * ddp,
2539 const char * buf, size_t count)
2543 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2544 scsi_debug_dsense = n;
2549 DRIVER_ATTR(dsense, S_IRUGO | S_IWUSR, sdebug_dsense_show,
2550 sdebug_dsense_store);
2552 static ssize_t sdebug_fake_rw_show(struct device_driver * ddp, char * buf)
2554 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
2556 static ssize_t sdebug_fake_rw_store(struct device_driver * ddp,
2557 const char * buf, size_t count)
2561 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2562 scsi_debug_fake_rw = n;
2567 DRIVER_ATTR(fake_rw, S_IRUGO | S_IWUSR, sdebug_fake_rw_show,
2568 sdebug_fake_rw_store);
2570 static ssize_t sdebug_no_lun_0_show(struct device_driver * ddp, char * buf)
2572 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
2574 static ssize_t sdebug_no_lun_0_store(struct device_driver * ddp,
2575 const char * buf, size_t count)
2579 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2580 scsi_debug_no_lun_0 = n;
2585 DRIVER_ATTR(no_lun_0, S_IRUGO | S_IWUSR, sdebug_no_lun_0_show,
2586 sdebug_no_lun_0_store);
2588 static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf)
2590 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
2592 static ssize_t sdebug_num_tgts_store(struct device_driver * ddp,
2593 const char * buf, size_t count)
2597 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2598 scsi_debug_num_tgts = n;
2599 sdebug_max_tgts_luns();
2604 DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show,
2605 sdebug_num_tgts_store);
2607 static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf)
2609 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
2611 DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL);
2613 static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf)
2615 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
2617 DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL);
2619 static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf)
2621 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
2623 static ssize_t sdebug_every_nth_store(struct device_driver * ddp,
2624 const char * buf, size_t count)
2628 if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
2629 scsi_debug_every_nth = nth;
2630 scsi_debug_cmnd_count = 0;
2635 DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show,
2636 sdebug_every_nth_store);
2638 static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf)
2640 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
2642 static ssize_t sdebug_max_luns_store(struct device_driver * ddp,
2643 const char * buf, size_t count)
2647 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2648 scsi_debug_max_luns = n;
2649 sdebug_max_tgts_luns();
2654 DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show,
2655 sdebug_max_luns_store);
2657 static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf)
2659 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
2661 DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL);
2663 static ssize_t sdebug_virtual_gb_show(struct device_driver * ddp, char * buf)
2665 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
2667 static ssize_t sdebug_virtual_gb_store(struct device_driver * ddp,
2668 const char * buf, size_t count)
2672 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2673 scsi_debug_virtual_gb = n;
2674 if (scsi_debug_virtual_gb > 0) {
2675 sdebug_capacity = 2048 * 1024;
2676 sdebug_capacity *= scsi_debug_virtual_gb;
2678 sdebug_capacity = sdebug_store_sectors;
2683 DRIVER_ATTR(virtual_gb, S_IRUGO | S_IWUSR, sdebug_virtual_gb_show,
2684 sdebug_virtual_gb_store);
2686 static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf)
2688 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
2691 static ssize_t sdebug_add_host_store(struct device_driver * ddp,
2692 const char * buf, size_t count)
2696 if (sscanf(buf, "%d", &delta_hosts) != 1)
2698 if (delta_hosts > 0) {
2700 sdebug_add_adapter();
2701 } while (--delta_hosts);
2702 } else if (delta_hosts < 0) {
2704 sdebug_remove_adapter();
2705 } while (++delta_hosts);
2709 DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show,
2710 sdebug_add_host_store);
2712 static ssize_t sdebug_vpd_use_hostno_show(struct device_driver * ddp,
2715 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
2717 static ssize_t sdebug_vpd_use_hostno_store(struct device_driver * ddp,
2718 const char * buf, size_t count)
2722 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2723 scsi_debug_vpd_use_hostno = n;
2728 DRIVER_ATTR(vpd_use_hostno, S_IRUGO | S_IWUSR, sdebug_vpd_use_hostno_show,
2729 sdebug_vpd_use_hostno_store);
2731 /* Note: The following function creates attribute files in the
2732 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
2733 files (over those found in the /sys/module/scsi_debug/parameters
2734 directory) is that auxiliary actions can be triggered when an attribute
2735 is changed. For example see: sdebug_add_host_store() above.
2737 static int do_create_driverfs_files(void)
2741 ret = driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2742 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay);
2743 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2744 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2745 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2746 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2747 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2748 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2749 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2750 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2751 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2752 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts);
2753 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2754 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2755 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2759 static void do_remove_driverfs_files(void)
2761 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2762 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2763 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2764 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts);
2765 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2766 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2767 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2768 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2769 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2770 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2771 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2772 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2773 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2774 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay);
2775 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2778 static int __init scsi_debug_init(void)
2785 if (scsi_debug_dev_size_mb < 1)
2786 scsi_debug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */
2787 sdebug_store_size = (unsigned int)scsi_debug_dev_size_mb * 1048576;
2788 sdebug_store_sectors = sdebug_store_size / SECT_SIZE;
2789 if (scsi_debug_virtual_gb > 0) {
2790 sdebug_capacity = 2048 * 1024;
2791 sdebug_capacity *= scsi_debug_virtual_gb;
2793 sdebug_capacity = sdebug_store_sectors;
2795 /* play around with geometry, don't waste too much on track 0 */
2797 sdebug_sectors_per = 32;
2798 if (scsi_debug_dev_size_mb >= 16)
2800 else if (scsi_debug_dev_size_mb >= 256)
2802 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2803 (sdebug_sectors_per * sdebug_heads);
2804 if (sdebug_cylinders_per >= 1024) {
2805 /* other LLDs do this; implies >= 1GB ram disk ... */
2807 sdebug_sectors_per = 63;
2808 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2809 (sdebug_sectors_per * sdebug_heads);
2812 sz = sdebug_store_size;
2813 fake_storep = vmalloc(sz);
2814 if (NULL == fake_storep) {
2815 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
2818 memset(fake_storep, 0, sz);
2819 if (scsi_debug_num_parts > 0)
2820 sdebug_build_parts(fake_storep);
2822 ret = device_register(&pseudo_primary);
2824 printk(KERN_WARNING "scsi_debug: device_register error: %d\n",
2828 ret = bus_register(&pseudo_lld_bus);
2830 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
2834 ret = driver_register(&sdebug_driverfs_driver);
2836 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
2840 ret = do_create_driverfs_files();
2842 printk(KERN_WARNING "scsi_debug: driver_create_file error: %d\n",
2849 host_to_add = scsi_debug_add_host;
2850 scsi_debug_add_host = 0;
2852 for (k = 0; k < host_to_add; k++) {
2853 if (sdebug_add_adapter()) {
2854 printk(KERN_ERR "scsi_debug_init: "
2855 "sdebug_add_adapter failed k=%d\n", k);
2860 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
2861 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
2862 scsi_debug_add_host);
2867 do_remove_driverfs_files();
2868 driver_unregister(&sdebug_driverfs_driver);
2870 bus_unregister(&pseudo_lld_bus);
2872 device_unregister(&pseudo_primary);
2879 static void __exit scsi_debug_exit(void)
2881 int k = scsi_debug_add_host;
2885 sdebug_remove_adapter();
2886 do_remove_driverfs_files();
2887 driver_unregister(&sdebug_driverfs_driver);
2888 bus_unregister(&pseudo_lld_bus);
2889 device_unregister(&pseudo_primary);
2894 device_initcall(scsi_debug_init);
2895 module_exit(scsi_debug_exit);
2897 static void pseudo_0_release(struct device * dev)
2899 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2900 printk(KERN_INFO "scsi_debug: pseudo_0_release() called\n");
2903 static struct device pseudo_primary = {
2904 .bus_id = "pseudo_0",
2905 .release = pseudo_0_release,
2908 static int pseudo_lld_bus_match(struct device *dev,
2909 struct device_driver *dev_driver)
2914 static struct bus_type pseudo_lld_bus = {
2916 .match = pseudo_lld_bus_match,
2917 .probe = sdebug_driver_probe,
2918 .remove = sdebug_driver_remove,
2921 static void sdebug_release_adapter(struct device * dev)
2923 struct sdebug_host_info *sdbg_host;
2925 sdbg_host = to_sdebug_host(dev);
2929 static int sdebug_add_adapter(void)
2931 int k, devs_per_host;
2933 struct sdebug_host_info *sdbg_host;
2934 struct sdebug_dev_info *sdbg_devinfo;
2935 struct list_head *lh, *lh_sf;
2937 sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
2938 if (NULL == sdbg_host) {
2939 printk(KERN_ERR "%s: out of memory at line %d\n",
2940 __FUNCTION__, __LINE__);
2944 INIT_LIST_HEAD(&sdbg_host->dev_info_list);
2946 devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
2947 for (k = 0; k < devs_per_host; k++) {
2948 sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL);
2949 if (!sdbg_devinfo) {
2950 printk(KERN_ERR "%s: out of memory at line %d\n",
2951 __FUNCTION__, __LINE__);
2957 spin_lock(&sdebug_host_list_lock);
2958 list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
2959 spin_unlock(&sdebug_host_list_lock);
2961 sdbg_host->dev.bus = &pseudo_lld_bus;
2962 sdbg_host->dev.parent = &pseudo_primary;
2963 sdbg_host->dev.release = &sdebug_release_adapter;
2964 sprintf(sdbg_host->dev.bus_id, "adapter%d", scsi_debug_add_host);
2966 error = device_register(&sdbg_host->dev);
2971 ++scsi_debug_add_host;
2975 list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
2976 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
2978 list_del(&sdbg_devinfo->dev_list);
2979 kfree(sdbg_devinfo);
2986 static void sdebug_remove_adapter(void)
2988 struct sdebug_host_info * sdbg_host = NULL;
2990 spin_lock(&sdebug_host_list_lock);
2991 if (!list_empty(&sdebug_host_list)) {
2992 sdbg_host = list_entry(sdebug_host_list.prev,
2993 struct sdebug_host_info, host_list);
2994 list_del(&sdbg_host->host_list);
2996 spin_unlock(&sdebug_host_list_lock);
3001 device_unregister(&sdbg_host->dev);
3002 --scsi_debug_add_host;
3005 static struct scsi_host_template sdebug_driver_template = {
3006 .proc_info = scsi_debug_proc_info,
3007 .proc_name = sdebug_proc_name,
3008 .name = "SCSI DEBUG",
3009 .info = scsi_debug_info,
3010 .slave_alloc = scsi_debug_slave_alloc,
3011 .slave_configure = scsi_debug_slave_configure,
3012 .slave_destroy = scsi_debug_slave_destroy,
3013 .ioctl = scsi_debug_ioctl,
3014 .queuecommand = scsi_debug_queuecommand,
3015 .eh_abort_handler = scsi_debug_abort,
3016 .eh_bus_reset_handler = scsi_debug_bus_reset,
3017 .eh_device_reset_handler = scsi_debug_device_reset,
3018 .eh_host_reset_handler = scsi_debug_host_reset,
3019 .bios_param = scsi_debug_biosparam,
3020 .can_queue = SCSI_DEBUG_CANQUEUE,
3022 .sg_tablesize = 256,
3024 .max_sectors = 0xffff,
3025 .use_clustering = DISABLE_CLUSTERING,
3026 .module = THIS_MODULE,
3029 static int sdebug_driver_probe(struct device * dev)
3032 struct sdebug_host_info *sdbg_host;
3033 struct Scsi_Host *hpnt;
3035 sdbg_host = to_sdebug_host(dev);
3037 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
3039 printk(KERN_ERR "%s: scsi_register failed\n", __FUNCTION__);
3044 sdbg_host->shost = hpnt;
3045 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
3046 if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
3047 hpnt->max_id = scsi_debug_num_tgts + 1;
3049 hpnt->max_id = scsi_debug_num_tgts;
3050 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* = scsi_debug_max_luns; */
3052 error = scsi_add_host(hpnt, &sdbg_host->dev);
3054 printk(KERN_ERR "%s: scsi_add_host failed\n", __FUNCTION__);
3056 scsi_host_put(hpnt);
3058 scsi_scan_host(hpnt);
3064 static int sdebug_driver_remove(struct device * dev)
3066 struct list_head *lh, *lh_sf;
3067 struct sdebug_host_info *sdbg_host;
3068 struct sdebug_dev_info *sdbg_devinfo;
3070 sdbg_host = to_sdebug_host(dev);
3073 printk(KERN_ERR "%s: Unable to locate host info\n",
3078 scsi_remove_host(sdbg_host->shost);
3080 list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
3081 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
3083 list_del(&sdbg_devinfo->dev_list);
3084 kfree(sdbg_devinfo);
3087 scsi_host_put(sdbg_host->shost);
3091 static void sdebug_max_tgts_luns(void)
3093 struct sdebug_host_info * sdbg_host;
3094 struct Scsi_Host *hpnt;
3096 spin_lock(&sdebug_host_list_lock);
3097 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
3098 hpnt = sdbg_host->shost;
3099 if ((hpnt->this_id >= 0) &&
3100 (scsi_debug_num_tgts > hpnt->this_id))
3101 hpnt->max_id = scsi_debug_num_tgts + 1;
3103 hpnt->max_id = scsi_debug_num_tgts;
3104 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* scsi_debug_max_luns; */
3106 spin_unlock(&sdebug_host_list_lock);