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 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
2019 struct sdebug_host_info * sdbg_host;
2020 struct sdebug_dev_info * open_devip = NULL;
2021 struct sdebug_dev_info * devip =
2022 (struct sdebug_dev_info *)sdev->hostdata;
2026 sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
2028 printk(KERN_ERR "Host info NULL\n");
2031 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
2032 if ((devip->used) && (devip->channel == sdev->channel) &&
2033 (devip->target == sdev->id) &&
2034 (devip->lun == sdev->lun))
2037 if ((!devip->used) && (!open_devip))
2041 if (NULL == open_devip) { /* try and make a new one */
2042 open_devip = kzalloc(sizeof(*open_devip),GFP_ATOMIC);
2043 if (NULL == open_devip) {
2044 printk(KERN_ERR "%s: out of memory at line %d\n",
2045 __FUNCTION__, __LINE__);
2048 open_devip->sdbg_host = sdbg_host;
2049 list_add_tail(&open_devip->dev_list,
2050 &sdbg_host->dev_info_list);
2053 open_devip->channel = sdev->channel;
2054 open_devip->target = sdev->id;
2055 open_devip->lun = sdev->lun;
2056 open_devip->sdbg_host = sdbg_host;
2057 open_devip->reset = 1;
2058 open_devip->used = 1;
2059 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
2060 if (scsi_debug_dsense)
2061 open_devip->sense_buff[0] = 0x72;
2063 open_devip->sense_buff[0] = 0x70;
2064 open_devip->sense_buff[7] = 0xa;
2066 if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
2067 open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
2073 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
2076 unsigned char * sbuff;
2078 sbuff = devip->sense_buff;
2079 memset(sbuff, 0, SDEBUG_SENSE_LEN);
2080 if (scsi_debug_dsense) {
2081 sbuff[0] = 0x72; /* descriptor, current */
2086 sbuff[0] = 0x70; /* fixed, current */
2088 sbuff[7] = 0xa; /* implies 18 byte sense buffer */
2092 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2093 printk(KERN_INFO "scsi_debug: [sense_key,asc,ascq]: "
2094 "[0x%x,0x%x,0x%x]\n", key, asc, asq);
2097 static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
2099 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2100 printk(KERN_INFO "scsi_debug: abort\n");
2102 stop_queued_cmnd(SCpnt);
2106 static int scsi_debug_biosparam(struct scsi_device *sdev,
2107 struct block_device * bdev, sector_t capacity, int *info)
2112 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2113 printk(KERN_INFO "scsi_debug: biosparam\n");
2114 buf = scsi_bios_ptable(bdev);
2116 res = scsi_partsize(buf, capacity,
2117 &info[2], &info[0], &info[1]);
2122 info[0] = sdebug_heads;
2123 info[1] = sdebug_sectors_per;
2124 info[2] = sdebug_cylinders_per;
2128 static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
2130 struct sdebug_dev_info * devip;
2132 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2133 printk(KERN_INFO "scsi_debug: device_reset\n");
2136 devip = devInfoReg(SCpnt->device);
2143 static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
2145 struct sdebug_host_info *sdbg_host;
2146 struct sdebug_dev_info * dev_info;
2147 struct scsi_device * sdp;
2148 struct Scsi_Host * hp;
2150 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2151 printk(KERN_INFO "scsi_debug: bus_reset\n");
2153 if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
2154 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
2156 list_for_each_entry(dev_info,
2157 &sdbg_host->dev_info_list,
2159 dev_info->reset = 1;
2165 static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
2167 struct sdebug_host_info * sdbg_host;
2168 struct sdebug_dev_info * dev_info;
2170 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2171 printk(KERN_INFO "scsi_debug: host_reset\n");
2173 spin_lock(&sdebug_host_list_lock);
2174 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
2175 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
2177 dev_info->reset = 1;
2179 spin_unlock(&sdebug_host_list_lock);
2184 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
2185 static int stop_queued_cmnd(struct scsi_cmnd * cmnd)
2187 unsigned long iflags;
2189 struct sdebug_queued_cmd * sqcp;
2191 spin_lock_irqsave(&queued_arr_lock, iflags);
2192 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2193 sqcp = &queued_arr[k];
2194 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
2195 del_timer_sync(&sqcp->cmnd_timer);
2197 sqcp->a_cmnd = NULL;
2201 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2202 return (k < SCSI_DEBUG_CANQUEUE) ? 1 : 0;
2205 /* Deletes (stops) timers of all queued commands */
2206 static void stop_all_queued(void)
2208 unsigned long iflags;
2210 struct sdebug_queued_cmd * sqcp;
2212 spin_lock_irqsave(&queued_arr_lock, iflags);
2213 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2214 sqcp = &queued_arr[k];
2215 if (sqcp->in_use && sqcp->a_cmnd) {
2216 del_timer_sync(&sqcp->cmnd_timer);
2218 sqcp->a_cmnd = NULL;
2221 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2224 /* Initializes timers in queued array */
2225 static void __init init_all_queued(void)
2227 unsigned long iflags;
2229 struct sdebug_queued_cmd * sqcp;
2231 spin_lock_irqsave(&queued_arr_lock, iflags);
2232 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2233 sqcp = &queued_arr[k];
2234 init_timer(&sqcp->cmnd_timer);
2236 sqcp->a_cmnd = NULL;
2238 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2241 static void __init sdebug_build_parts(unsigned char * ramp)
2243 struct partition * pp;
2244 int starts[SDEBUG_MAX_PARTS + 2];
2245 int sectors_per_part, num_sectors, k;
2246 int heads_by_sects, start_sec, end_sec;
2248 /* assume partition table already zeroed */
2249 if ((scsi_debug_num_parts < 1) || (sdebug_store_size < 1048576))
2251 if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
2252 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
2253 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
2254 "partitions to %d\n", SDEBUG_MAX_PARTS);
2256 num_sectors = (int)sdebug_store_sectors;
2257 sectors_per_part = (num_sectors - sdebug_sectors_per)
2258 / scsi_debug_num_parts;
2259 heads_by_sects = sdebug_heads * sdebug_sectors_per;
2260 starts[0] = sdebug_sectors_per;
2261 for (k = 1; k < scsi_debug_num_parts; ++k)
2262 starts[k] = ((k * sectors_per_part) / heads_by_sects)
2264 starts[scsi_debug_num_parts] = num_sectors;
2265 starts[scsi_debug_num_parts + 1] = 0;
2267 ramp[510] = 0x55; /* magic partition markings */
2269 pp = (struct partition *)(ramp + 0x1be);
2270 for (k = 0; starts[k + 1]; ++k, ++pp) {
2271 start_sec = starts[k];
2272 end_sec = starts[k + 1] - 1;
2275 pp->cyl = start_sec / heads_by_sects;
2276 pp->head = (start_sec - (pp->cyl * heads_by_sects))
2277 / sdebug_sectors_per;
2278 pp->sector = (start_sec % sdebug_sectors_per) + 1;
2280 pp->end_cyl = end_sec / heads_by_sects;
2281 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
2282 / sdebug_sectors_per;
2283 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2285 pp->start_sect = start_sec;
2286 pp->nr_sects = end_sec - start_sec + 1;
2287 pp->sys_ind = 0x83; /* plain Linux partition */
2291 static int schedule_resp(struct scsi_cmnd * cmnd,
2292 struct sdebug_dev_info * devip,
2293 done_funct_t done, int scsi_result, int delta_jiff)
2295 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
2297 struct scsi_device * sdp = cmnd->device;
2299 printk(KERN_INFO "scsi_debug: <%u %u %u %u> "
2300 "non-zero result=0x%x\n", sdp->host->host_no,
2301 sdp->channel, sdp->id, sdp->lun, scsi_result);
2304 if (cmnd && devip) {
2305 /* simulate autosense by this driver */
2306 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
2307 memcpy(cmnd->sense_buffer, devip->sense_buff,
2308 (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
2309 SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
2311 if (delta_jiff <= 0) {
2313 cmnd->result = scsi_result;
2318 unsigned long iflags;
2320 struct sdebug_queued_cmd * sqcp = NULL;
2322 spin_lock_irqsave(&queued_arr_lock, iflags);
2323 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2324 sqcp = &queued_arr[k];
2328 if (k >= SCSI_DEBUG_CANQUEUE) {
2329 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2330 printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
2331 return 1; /* report busy to mid level */
2334 sqcp->a_cmnd = cmnd;
2335 sqcp->scsi_result = scsi_result;
2336 sqcp->done_funct = done;
2337 sqcp->cmnd_timer.function = timer_intr_handler;
2338 sqcp->cmnd_timer.data = k;
2339 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
2340 add_timer(&sqcp->cmnd_timer);
2341 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2348 /* Note: The following macros create attribute files in the
2349 /sys/module/scsi_debug/parameters directory. Unfortunately this
2350 driver is unaware of a change and cannot trigger auxiliary actions
2351 as it can when the corresponding attribute in the
2352 /sys/bus/pseudo/drivers/scsi_debug directory is changed.
2354 module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
2355 module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
2356 module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
2357 module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
2358 module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
2359 module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
2360 module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
2361 module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
2362 module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
2363 module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
2364 module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
2365 module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
2366 module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
2367 module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
2368 module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
2371 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2372 MODULE_DESCRIPTION("SCSI debug adapter driver");
2373 MODULE_LICENSE("GPL");
2374 MODULE_VERSION(SCSI_DEBUG_VERSION);
2376 MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
2377 MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
2378 MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
2379 MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
2380 MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
2381 MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
2382 MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
2383 MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
2384 MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
2385 MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
2386 MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
2387 MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
2388 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
2389 MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
2390 MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2393 static char sdebug_info[256];
2395 static const char * scsi_debug_info(struct Scsi_Host * shp)
2397 sprintf(sdebug_info, "scsi_debug, version %s [%s], "
2398 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
2399 scsi_debug_version_date, scsi_debug_dev_size_mb,
2404 /* scsi_debug_proc_info
2405 * Used if the driver currently has no own support for /proc/scsi
2407 static int scsi_debug_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
2408 int length, int inout)
2410 int len, pos, begin;
2413 orig_length = length;
2417 int minLen = length > 15 ? 15 : length;
2419 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2421 memcpy(arr, buffer, minLen);
2423 if (1 != sscanf(arr, "%d", &pos))
2425 scsi_debug_opts = pos;
2426 if (scsi_debug_every_nth != 0)
2427 scsi_debug_cmnd_count = 0;
2431 pos = len = sprintf(buffer, "scsi_debug adapter driver, version "
2433 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2434 "every_nth=%d(curr:%d)\n"
2435 "delay=%d, max_luns=%d, scsi_level=%d\n"
2436 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2437 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2439 SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
2440 scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2441 scsi_debug_cmnd_count, scsi_debug_delay,
2442 scsi_debug_max_luns, scsi_debug_scsi_level,
2443 SECT_SIZE, sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
2444 num_aborts, num_dev_resets, num_bus_resets, num_host_resets);
2449 *start = buffer + (offset - begin); /* Start of wanted data */
2450 len -= (offset - begin);
2456 static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf)
2458 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
2461 static ssize_t sdebug_delay_store(struct device_driver * ddp,
2462 const char * buf, size_t count)
2467 if (1 == sscanf(buf, "%10s", work)) {
2468 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
2469 scsi_debug_delay = delay;
2475 DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show,
2476 sdebug_delay_store);
2478 static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf)
2480 return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
2483 static ssize_t sdebug_opts_store(struct device_driver * ddp,
2484 const char * buf, size_t count)
2489 if (1 == sscanf(buf, "%10s", work)) {
2490 if (0 == strnicmp(work,"0x", 2)) {
2491 if (1 == sscanf(&work[2], "%x", &opts))
2494 if (1 == sscanf(work, "%d", &opts))
2500 scsi_debug_opts = opts;
2501 scsi_debug_cmnd_count = 0;
2504 DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show,
2507 static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf)
2509 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
2511 static ssize_t sdebug_ptype_store(struct device_driver * ddp,
2512 const char * buf, size_t count)
2516 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2517 scsi_debug_ptype = n;
2522 DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store);
2524 static ssize_t sdebug_dsense_show(struct device_driver * ddp, char * buf)
2526 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
2528 static ssize_t sdebug_dsense_store(struct device_driver * ddp,
2529 const char * buf, size_t count)
2533 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2534 scsi_debug_dsense = n;
2539 DRIVER_ATTR(dsense, S_IRUGO | S_IWUSR, sdebug_dsense_show,
2540 sdebug_dsense_store);
2542 static ssize_t sdebug_fake_rw_show(struct device_driver * ddp, char * buf)
2544 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
2546 static ssize_t sdebug_fake_rw_store(struct device_driver * ddp,
2547 const char * buf, size_t count)
2551 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2552 scsi_debug_fake_rw = n;
2557 DRIVER_ATTR(fake_rw, S_IRUGO | S_IWUSR, sdebug_fake_rw_show,
2558 sdebug_fake_rw_store);
2560 static ssize_t sdebug_no_lun_0_show(struct device_driver * ddp, char * buf)
2562 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
2564 static ssize_t sdebug_no_lun_0_store(struct device_driver * ddp,
2565 const char * buf, size_t count)
2569 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2570 scsi_debug_no_lun_0 = n;
2575 DRIVER_ATTR(no_lun_0, S_IRUGO | S_IWUSR, sdebug_no_lun_0_show,
2576 sdebug_no_lun_0_store);
2578 static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf)
2580 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
2582 static ssize_t sdebug_num_tgts_store(struct device_driver * ddp,
2583 const char * buf, size_t count)
2587 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2588 scsi_debug_num_tgts = n;
2589 sdebug_max_tgts_luns();
2594 DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show,
2595 sdebug_num_tgts_store);
2597 static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf)
2599 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
2601 DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL);
2603 static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf)
2605 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
2607 DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL);
2609 static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf)
2611 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
2613 static ssize_t sdebug_every_nth_store(struct device_driver * ddp,
2614 const char * buf, size_t count)
2618 if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
2619 scsi_debug_every_nth = nth;
2620 scsi_debug_cmnd_count = 0;
2625 DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show,
2626 sdebug_every_nth_store);
2628 static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf)
2630 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
2632 static ssize_t sdebug_max_luns_store(struct device_driver * ddp,
2633 const char * buf, size_t count)
2637 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2638 scsi_debug_max_luns = n;
2639 sdebug_max_tgts_luns();
2644 DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show,
2645 sdebug_max_luns_store);
2647 static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf)
2649 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
2651 DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL);
2653 static ssize_t sdebug_virtual_gb_show(struct device_driver * ddp, char * buf)
2655 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
2657 static ssize_t sdebug_virtual_gb_store(struct device_driver * ddp,
2658 const char * buf, size_t count)
2662 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2663 scsi_debug_virtual_gb = n;
2664 if (scsi_debug_virtual_gb > 0) {
2665 sdebug_capacity = 2048 * 1024;
2666 sdebug_capacity *= scsi_debug_virtual_gb;
2668 sdebug_capacity = sdebug_store_sectors;
2673 DRIVER_ATTR(virtual_gb, S_IRUGO | S_IWUSR, sdebug_virtual_gb_show,
2674 sdebug_virtual_gb_store);
2676 static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf)
2678 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
2681 static ssize_t sdebug_add_host_store(struct device_driver * ddp,
2682 const char * buf, size_t count)
2687 if (1 != sscanf(buf, "%10s", work))
2689 { /* temporary hack around sscanf() problem with -ve nums */
2694 if (1 != sscanf(work + neg, "%d", &delta_hosts))
2697 delta_hosts = -delta_hosts;
2699 if (delta_hosts > 0) {
2701 sdebug_add_adapter();
2702 } while (--delta_hosts);
2703 } else if (delta_hosts < 0) {
2705 sdebug_remove_adapter();
2706 } while (++delta_hosts);
2710 DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show,
2711 sdebug_add_host_store);
2713 static ssize_t sdebug_vpd_use_hostno_show(struct device_driver * ddp,
2716 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
2718 static ssize_t sdebug_vpd_use_hostno_store(struct device_driver * ddp,
2719 const char * buf, size_t count)
2723 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2724 scsi_debug_vpd_use_hostno = n;
2729 DRIVER_ATTR(vpd_use_hostno, S_IRUGO | S_IWUSR, sdebug_vpd_use_hostno_show,
2730 sdebug_vpd_use_hostno_store);
2732 /* Note: The following function creates attribute files in the
2733 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
2734 files (over those found in the /sys/module/scsi_debug/parameters
2735 directory) is that auxiliary actions can be triggered when an attribute
2736 is changed. For example see: sdebug_add_host_store() above.
2738 static int do_create_driverfs_files(void)
2742 ret = driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2743 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay);
2744 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2745 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2746 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2747 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2748 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2749 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2750 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2751 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2752 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2753 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts);
2754 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2755 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2756 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2760 static void do_remove_driverfs_files(void)
2762 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2763 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2764 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2765 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts);
2766 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2767 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2768 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2769 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2770 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2771 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2772 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2773 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2774 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2775 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay);
2776 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2779 static int __init scsi_debug_init(void)
2786 if (scsi_debug_dev_size_mb < 1)
2787 scsi_debug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */
2788 sdebug_store_size = (unsigned int)scsi_debug_dev_size_mb * 1048576;
2789 sdebug_store_sectors = sdebug_store_size / SECT_SIZE;
2790 if (scsi_debug_virtual_gb > 0) {
2791 sdebug_capacity = 2048 * 1024;
2792 sdebug_capacity *= scsi_debug_virtual_gb;
2794 sdebug_capacity = sdebug_store_sectors;
2796 /* play around with geometry, don't waste too much on track 0 */
2798 sdebug_sectors_per = 32;
2799 if (scsi_debug_dev_size_mb >= 16)
2801 else if (scsi_debug_dev_size_mb >= 256)
2803 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2804 (sdebug_sectors_per * sdebug_heads);
2805 if (sdebug_cylinders_per >= 1024) {
2806 /* other LLDs do this; implies >= 1GB ram disk ... */
2808 sdebug_sectors_per = 63;
2809 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2810 (sdebug_sectors_per * sdebug_heads);
2813 sz = sdebug_store_size;
2814 fake_storep = vmalloc(sz);
2815 if (NULL == fake_storep) {
2816 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
2819 memset(fake_storep, 0, sz);
2820 if (scsi_debug_num_parts > 0)
2821 sdebug_build_parts(fake_storep);
2823 ret = device_register(&pseudo_primary);
2825 printk(KERN_WARNING "scsi_debug: device_register error: %d\n",
2829 ret = bus_register(&pseudo_lld_bus);
2831 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
2835 ret = driver_register(&sdebug_driverfs_driver);
2837 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
2841 ret = do_create_driverfs_files();
2843 printk(KERN_WARNING "scsi_debug: driver_create_file error: %d\n",
2850 host_to_add = scsi_debug_add_host;
2851 scsi_debug_add_host = 0;
2853 for (k = 0; k < host_to_add; k++) {
2854 if (sdebug_add_adapter()) {
2855 printk(KERN_ERR "scsi_debug_init: "
2856 "sdebug_add_adapter failed k=%d\n", k);
2861 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
2862 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
2863 scsi_debug_add_host);
2868 do_remove_driverfs_files();
2869 driver_unregister(&sdebug_driverfs_driver);
2871 bus_unregister(&pseudo_lld_bus);
2873 device_unregister(&pseudo_primary);
2880 static void __exit scsi_debug_exit(void)
2882 int k = scsi_debug_add_host;
2886 sdebug_remove_adapter();
2887 do_remove_driverfs_files();
2888 driver_unregister(&sdebug_driverfs_driver);
2889 bus_unregister(&pseudo_lld_bus);
2890 device_unregister(&pseudo_primary);
2895 device_initcall(scsi_debug_init);
2896 module_exit(scsi_debug_exit);
2898 static void pseudo_0_release(struct device * dev)
2900 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2901 printk(KERN_INFO "scsi_debug: pseudo_0_release() called\n");
2904 static struct device pseudo_primary = {
2905 .bus_id = "pseudo_0",
2906 .release = pseudo_0_release,
2909 static int pseudo_lld_bus_match(struct device *dev,
2910 struct device_driver *dev_driver)
2915 static struct bus_type pseudo_lld_bus = {
2917 .match = pseudo_lld_bus_match,
2918 .probe = sdebug_driver_probe,
2919 .remove = sdebug_driver_remove,
2922 static void sdebug_release_adapter(struct device * dev)
2924 struct sdebug_host_info *sdbg_host;
2926 sdbg_host = to_sdebug_host(dev);
2930 static int sdebug_add_adapter(void)
2932 int k, devs_per_host;
2934 struct sdebug_host_info *sdbg_host;
2935 struct sdebug_dev_info *sdbg_devinfo;
2936 struct list_head *lh, *lh_sf;
2938 sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
2939 if (NULL == sdbg_host) {
2940 printk(KERN_ERR "%s: out of memory at line %d\n",
2941 __FUNCTION__, __LINE__);
2945 INIT_LIST_HEAD(&sdbg_host->dev_info_list);
2947 devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
2948 for (k = 0; k < devs_per_host; k++) {
2949 sdbg_devinfo = kzalloc(sizeof(*sdbg_devinfo),GFP_KERNEL);
2950 if (NULL == sdbg_devinfo) {
2951 printk(KERN_ERR "%s: out of memory at line %d\n",
2952 __FUNCTION__, __LINE__);
2956 sdbg_devinfo->sdbg_host = sdbg_host;
2957 list_add_tail(&sdbg_devinfo->dev_list,
2958 &sdbg_host->dev_info_list);
2961 spin_lock(&sdebug_host_list_lock);
2962 list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
2963 spin_unlock(&sdebug_host_list_lock);
2965 sdbg_host->dev.bus = &pseudo_lld_bus;
2966 sdbg_host->dev.parent = &pseudo_primary;
2967 sdbg_host->dev.release = &sdebug_release_adapter;
2968 sprintf(sdbg_host->dev.bus_id, "adapter%d", scsi_debug_add_host);
2970 error = device_register(&sdbg_host->dev);
2975 ++scsi_debug_add_host;
2979 list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
2980 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
2982 list_del(&sdbg_devinfo->dev_list);
2983 kfree(sdbg_devinfo);
2990 static void sdebug_remove_adapter(void)
2992 struct sdebug_host_info * sdbg_host = NULL;
2994 spin_lock(&sdebug_host_list_lock);
2995 if (!list_empty(&sdebug_host_list)) {
2996 sdbg_host = list_entry(sdebug_host_list.prev,
2997 struct sdebug_host_info, host_list);
2998 list_del(&sdbg_host->host_list);
3000 spin_unlock(&sdebug_host_list_lock);
3005 device_unregister(&sdbg_host->dev);
3006 --scsi_debug_add_host;
3009 static struct scsi_host_template sdebug_driver_template = {
3010 .proc_info = scsi_debug_proc_info,
3011 .proc_name = sdebug_proc_name,
3012 .name = "SCSI DEBUG",
3013 .info = scsi_debug_info,
3014 .slave_alloc = scsi_debug_slave_alloc,
3015 .slave_configure = scsi_debug_slave_configure,
3016 .slave_destroy = scsi_debug_slave_destroy,
3017 .ioctl = scsi_debug_ioctl,
3018 .queuecommand = scsi_debug_queuecommand,
3019 .eh_abort_handler = scsi_debug_abort,
3020 .eh_bus_reset_handler = scsi_debug_bus_reset,
3021 .eh_device_reset_handler = scsi_debug_device_reset,
3022 .eh_host_reset_handler = scsi_debug_host_reset,
3023 .bios_param = scsi_debug_biosparam,
3024 .can_queue = SCSI_DEBUG_CANQUEUE,
3026 .sg_tablesize = 256,
3028 .max_sectors = 0xffff,
3029 .use_clustering = DISABLE_CLUSTERING,
3030 .module = THIS_MODULE,
3033 static int sdebug_driver_probe(struct device * dev)
3036 struct sdebug_host_info *sdbg_host;
3037 struct Scsi_Host *hpnt;
3039 sdbg_host = to_sdebug_host(dev);
3041 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
3043 printk(KERN_ERR "%s: scsi_register failed\n", __FUNCTION__);
3048 sdbg_host->shost = hpnt;
3049 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
3050 if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
3051 hpnt->max_id = scsi_debug_num_tgts + 1;
3053 hpnt->max_id = scsi_debug_num_tgts;
3054 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* = scsi_debug_max_luns; */
3056 error = scsi_add_host(hpnt, &sdbg_host->dev);
3058 printk(KERN_ERR "%s: scsi_add_host failed\n", __FUNCTION__);
3060 scsi_host_put(hpnt);
3062 scsi_scan_host(hpnt);
3068 static int sdebug_driver_remove(struct device * dev)
3070 struct list_head *lh, *lh_sf;
3071 struct sdebug_host_info *sdbg_host;
3072 struct sdebug_dev_info *sdbg_devinfo;
3074 sdbg_host = to_sdebug_host(dev);
3077 printk(KERN_ERR "%s: Unable to locate host info\n",
3082 scsi_remove_host(sdbg_host->shost);
3084 list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
3085 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
3087 list_del(&sdbg_devinfo->dev_list);
3088 kfree(sdbg_devinfo);
3091 scsi_host_put(sdbg_host->shost);
3095 static void sdebug_max_tgts_luns(void)
3097 struct sdebug_host_info * sdbg_host;
3098 struct Scsi_Host *hpnt;
3100 spin_lock(&sdebug_host_list_lock);
3101 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
3102 hpnt = sdbg_host->shost;
3103 if ((hpnt->this_id >= 0) &&
3104 (scsi_debug_num_tgts > hpnt->this_id))
3105 hpnt->max_id = scsi_debug_num_tgts + 1;
3107 hpnt->max_id = scsi_debug_num_tgts;
3108 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* scsi_debug_max_luns; */
3110 spin_unlock(&sdebug_host_list_lock);