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>
43 #include <linux/blkdev.h>
45 #include <scsi/scsi_host.h>
46 #include <scsi/scsicam.h>
48 #include <linux/stat.h>
50 #include "scsi_logging.h"
51 #include "scsi_debug.h"
53 #define SCSI_DEBUG_VERSION "1.81"
54 static const char * scsi_debug_version_date = "20070104";
56 /* Additional Sense Code (ASC) */
57 #define NO_ADDITIONAL_SENSE 0x0
58 #define LOGICAL_UNIT_NOT_READY 0x4
59 #define UNRECOVERED_READ_ERR 0x11
60 #define PARAMETER_LIST_LENGTH_ERR 0x1a
61 #define INVALID_OPCODE 0x20
62 #define ADDR_OUT_OF_RANGE 0x21
63 #define INVALID_FIELD_IN_CDB 0x24
64 #define INVALID_FIELD_IN_PARAM_LIST 0x26
65 #define POWERON_RESET 0x29
66 #define SAVING_PARAMS_UNSUP 0x39
67 #define TRANSPORT_PROBLEM 0x4b
68 #define THRESHOLD_EXCEEDED 0x5d
69 #define LOW_POWER_COND_ON 0x5e
71 /* Additional Sense Code Qualifier (ASCQ) */
72 #define ACK_NAK_TO 0x3
74 #define SDEBUG_TAGGED_QUEUING 0 /* 0 | MSG_SIMPLE_TAG | MSG_ORDERED_TAG */
76 /* Default values for driver parameters */
77 #define DEF_NUM_HOST 1
78 #define DEF_NUM_TGTS 1
79 #define DEF_MAX_LUNS 1
80 /* With these defaults, this driver will make 1 host with 1 target
81 * (id 0) containing 1 logical unit (lun 0). That is 1 device.
84 #define DEF_DEV_SIZE_MB 8
85 #define DEF_EVERY_NTH 0
86 #define DEF_NUM_PARTS 0
88 #define DEF_SCSI_LEVEL 5 /* INQUIRY, byte2 [5->SPC-3] */
91 #define DEF_NO_LUN_0 0
92 #define DEF_VIRTUAL_GB 0
94 #define DEF_VPD_USE_HOSTNO 1
96 /* bit mask values for scsi_debug_opts */
97 #define SCSI_DEBUG_OPT_NOISE 1
98 #define SCSI_DEBUG_OPT_MEDIUM_ERR 2
99 #define SCSI_DEBUG_OPT_TIMEOUT 4
100 #define SCSI_DEBUG_OPT_RECOVERED_ERR 8
101 #define SCSI_DEBUG_OPT_TRANSPORT_ERR 16
102 /* When "every_nth" > 0 then modulo "every_nth" commands:
103 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
104 * - a RECOVERED_ERROR is simulated on successful read and write
105 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
106 * - a TRANSPORT_ERROR is simulated on successful read and write
107 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
109 * When "every_nth" < 0 then after "- every_nth" commands:
110 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
111 * - a RECOVERED_ERROR is simulated on successful read and write
112 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
113 * - a TRANSPORT_ERROR is simulated on successful read and write
114 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
115 * This will continue until some other action occurs (e.g. the user
116 * writing a new value (other than -1 or 1) to every_nth via sysfs).
119 /* when 1==SCSI_DEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
120 * sector on read commands: */
121 #define OPT_MEDIUM_ERR_ADDR 0x1234 /* that's sector 4660 in decimal */
123 /* If REPORT LUNS has luns >= 256 it can choose "flat space" (value 1)
124 * or "peripheral device" addressing (value 0) */
125 #define SAM2_LUN_ADDRESS_METHOD 0
126 #define SAM2_WLUN_REPORT_LUNS 0xc101
128 static int scsi_debug_add_host = DEF_NUM_HOST;
129 static int scsi_debug_delay = DEF_DELAY;
130 static int scsi_debug_dev_size_mb = DEF_DEV_SIZE_MB;
131 static int scsi_debug_every_nth = DEF_EVERY_NTH;
132 static int scsi_debug_max_luns = DEF_MAX_LUNS;
133 static int scsi_debug_num_parts = DEF_NUM_PARTS;
134 static int scsi_debug_num_tgts = DEF_NUM_TGTS; /* targets per host */
135 static int scsi_debug_opts = DEF_OPTS;
136 static int scsi_debug_scsi_level = DEF_SCSI_LEVEL;
137 static int scsi_debug_ptype = DEF_PTYPE; /* SCSI peripheral type (0==disk) */
138 static int scsi_debug_dsense = DEF_D_SENSE;
139 static int scsi_debug_no_lun_0 = DEF_NO_LUN_0;
140 static int scsi_debug_virtual_gb = DEF_VIRTUAL_GB;
141 static int scsi_debug_fake_rw = DEF_FAKE_RW;
142 static int scsi_debug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
144 static int scsi_debug_cmnd_count = 0;
146 #define DEV_READONLY(TGT) (0)
147 #define DEV_REMOVEABLE(TGT) (0)
149 static unsigned int sdebug_store_size; /* in bytes */
150 static unsigned int sdebug_store_sectors;
151 static sector_t sdebug_capacity; /* in sectors */
153 /* old BIOS stuff, kernel may get rid of them but some mode sense pages
154 may still need them */
155 static int sdebug_heads; /* heads per disk */
156 static int sdebug_cylinders_per; /* cylinders per surface */
157 static int sdebug_sectors_per; /* sectors per cylinder */
159 /* default sector size is 512 bytes, 2**9 bytes */
160 #define POW2_SECT_SIZE 9
161 #define SECT_SIZE (1 << POW2_SECT_SIZE)
162 #define SECT_SIZE_PER(TGT) SECT_SIZE
164 #define SDEBUG_MAX_PARTS 4
166 #define SDEBUG_SENSE_LEN 32
168 struct sdebug_dev_info {
169 struct list_head dev_list;
170 unsigned char sense_buff[SDEBUG_SENSE_LEN]; /* weak nexus */
171 unsigned int channel;
174 struct sdebug_host_info *sdbg_host;
181 struct sdebug_host_info {
182 struct list_head host_list;
183 struct Scsi_Host *shost;
185 struct list_head dev_info_list;
188 #define to_sdebug_host(d) \
189 container_of(d, struct sdebug_host_info, dev)
191 static LIST_HEAD(sdebug_host_list);
192 static DEFINE_SPINLOCK(sdebug_host_list_lock);
194 typedef void (* done_funct_t) (struct scsi_cmnd *);
196 struct sdebug_queued_cmd {
198 struct timer_list cmnd_timer;
199 done_funct_t done_funct;
200 struct scsi_cmnd * a_cmnd;
203 static struct sdebug_queued_cmd queued_arr[SCSI_DEBUG_CANQUEUE];
205 static struct scsi_host_template sdebug_driver_template = {
206 .proc_info = scsi_debug_proc_info,
207 .name = "SCSI DEBUG",
208 .info = scsi_debug_info,
209 .slave_alloc = scsi_debug_slave_alloc,
210 .slave_configure = scsi_debug_slave_configure,
211 .slave_destroy = scsi_debug_slave_destroy,
212 .ioctl = scsi_debug_ioctl,
213 .queuecommand = scsi_debug_queuecommand,
214 .eh_abort_handler = scsi_debug_abort,
215 .eh_bus_reset_handler = scsi_debug_bus_reset,
216 .eh_device_reset_handler = scsi_debug_device_reset,
217 .eh_host_reset_handler = scsi_debug_host_reset,
218 .bios_param = scsi_debug_biosparam,
219 .can_queue = SCSI_DEBUG_CANQUEUE,
223 .max_sectors = 0xffff,
224 .use_clustering = DISABLE_CLUSTERING,
225 .module = THIS_MODULE,
228 static unsigned char * fake_storep; /* ramdisk storage */
230 static int num_aborts = 0;
231 static int num_dev_resets = 0;
232 static int num_bus_resets = 0;
233 static int num_host_resets = 0;
235 static DEFINE_SPINLOCK(queued_arr_lock);
236 static DEFINE_RWLOCK(atomic_rw);
238 static char sdebug_proc_name[] = "scsi_debug";
240 static int sdebug_driver_probe(struct device *);
241 static int sdebug_driver_remove(struct device *);
242 static struct bus_type pseudo_lld_bus;
244 static struct device_driver sdebug_driverfs_driver = {
245 .name = sdebug_proc_name,
246 .bus = &pseudo_lld_bus,
249 static const int check_condition_result =
250 (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
252 static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
254 static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
257 /* function declarations */
258 static int resp_inquiry(struct scsi_cmnd * SCpnt, int target,
259 struct sdebug_dev_info * devip);
260 static int resp_requests(struct scsi_cmnd * SCpnt,
261 struct sdebug_dev_info * devip);
262 static int resp_start_stop(struct scsi_cmnd * scp,
263 struct sdebug_dev_info * devip);
264 static int resp_report_tgtpgs(struct scsi_cmnd * scp,
265 struct sdebug_dev_info * devip);
266 static int resp_readcap(struct scsi_cmnd * SCpnt,
267 struct sdebug_dev_info * devip);
268 static int resp_readcap16(struct scsi_cmnd * SCpnt,
269 struct sdebug_dev_info * devip);
270 static int resp_mode_sense(struct scsi_cmnd * scp, int target,
271 struct sdebug_dev_info * devip);
272 static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
273 struct sdebug_dev_info * devip);
274 static int resp_log_sense(struct scsi_cmnd * scp,
275 struct sdebug_dev_info * devip);
276 static int resp_read(struct scsi_cmnd * SCpnt, unsigned long long lba,
277 unsigned int num, struct sdebug_dev_info * devip);
278 static int resp_write(struct scsi_cmnd * SCpnt, unsigned long long lba,
279 unsigned int num, struct sdebug_dev_info * devip);
280 static int resp_report_luns(struct scsi_cmnd * SCpnt,
281 struct sdebug_dev_info * devip);
282 static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
283 unsigned int num, struct sdebug_dev_info *devip);
284 static int fill_from_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
286 static int fetch_to_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
288 static void timer_intr_handler(unsigned long);
289 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev);
290 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
292 static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
293 struct sdebug_dev_info * devip);
294 static int schedule_resp(struct scsi_cmnd * cmnd,
295 struct sdebug_dev_info * devip,
296 done_funct_t done, int scsi_result, int delta_jiff);
297 static void __init sdebug_build_parts(unsigned char * ramp);
298 static void __init init_all_queued(void);
299 static void stop_all_queued(void);
300 static int stop_queued_cmnd(struct scsi_cmnd * cmnd);
301 static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
302 int target_dev_id, int dev_id_num,
303 const char * dev_id_str, int dev_id_str_len);
304 static int inquiry_evpd_88(unsigned char * arr, int target_dev_id);
305 static int do_create_driverfs_files(void);
306 static void do_remove_driverfs_files(void);
308 static int sdebug_add_adapter(void);
309 static void sdebug_remove_adapter(void);
310 static void sdebug_max_tgts_luns(void);
312 static struct device pseudo_primary;
313 static struct bus_type pseudo_lld_bus;
315 static void get_data_transfer_info(unsigned char *cmd,
316 unsigned long long *lba, unsigned int *num)
323 for (*lba = 0, i = 0; i < 8; ++i) {
328 *num = cmd[13] + (cmd[12] << 8) +
329 (cmd[11] << 16) + (cmd[10] << 24);
333 *lba = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24);
334 *num = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
339 *lba = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24);
340 *num = cmd[8] + (cmd[7] << 8);
344 *lba = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
345 *num = (0 == cmd[4]) ? 256 : cmd[4];
353 int scsi_debug_queuecommand(struct scsi_cmnd * SCpnt, done_funct_t done)
355 unsigned char *cmd = (unsigned char *) SCpnt->cmnd;
358 unsigned long long lba;
360 int target = SCpnt->device->id;
361 struct sdebug_dev_info * devip = NULL;
362 int inj_recovered = 0;
363 int inj_transport = 0;
364 int delay_override = 0;
367 return 0; /* assume mid level reprocessing command */
369 scsi_set_resid(SCpnt, 0);
370 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) {
371 printk(KERN_INFO "scsi_debug: cmd ");
372 for (k = 0, len = SCpnt->cmd_len; k < len; ++k)
373 printk("%02x ", (int)cmd[k]);
376 if(target == sdebug_driver_template.this_id) {
377 printk(KERN_INFO "scsi_debug: initiator's id used as "
379 return schedule_resp(SCpnt, NULL, done,
380 DID_NO_CONNECT << 16, 0);
383 if ((SCpnt->device->lun >= scsi_debug_max_luns) &&
384 (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS))
385 return schedule_resp(SCpnt, NULL, done,
386 DID_NO_CONNECT << 16, 0);
387 devip = devInfoReg(SCpnt->device);
389 return schedule_resp(SCpnt, NULL, done,
390 DID_NO_CONNECT << 16, 0);
392 if ((scsi_debug_every_nth != 0) &&
393 (++scsi_debug_cmnd_count >= abs(scsi_debug_every_nth))) {
394 scsi_debug_cmnd_count = 0;
395 if (scsi_debug_every_nth < -1)
396 scsi_debug_every_nth = -1;
397 if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
398 return 0; /* ignore command causing timeout */
399 else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
400 inj_recovered = 1; /* to reads and writes below */
401 else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts)
402 inj_transport = 1; /* to reads and writes below */
409 case TEST_UNIT_READY:
411 break; /* only allowable wlun commands */
413 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
414 printk(KERN_INFO "scsi_debug: Opcode: 0x%x "
415 "not supported for wlun\n", *cmd);
416 mk_sense_buffer(devip, ILLEGAL_REQUEST,
418 errsts = check_condition_result;
419 return schedule_resp(SCpnt, devip, done, errsts,
425 case INQUIRY: /* mandatory, ignore unit attention */
427 errsts = resp_inquiry(SCpnt, target, devip);
429 case REQUEST_SENSE: /* mandatory, ignore unit attention */
431 errsts = resp_requests(SCpnt, devip);
433 case REZERO_UNIT: /* actually this is REWIND for SSC */
435 errsts = resp_start_stop(SCpnt, devip);
437 case ALLOW_MEDIUM_REMOVAL:
438 if ((errsts = check_readiness(SCpnt, 1, devip)))
440 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
441 printk(KERN_INFO "scsi_debug: Medium removal %s\n",
442 cmd[4] ? "inhibited" : "enabled");
444 case SEND_DIAGNOSTIC: /* mandatory */
445 errsts = check_readiness(SCpnt, 1, devip);
447 case TEST_UNIT_READY: /* mandatory */
449 errsts = check_readiness(SCpnt, 0, devip);
452 errsts = check_readiness(SCpnt, 1, devip);
455 errsts = check_readiness(SCpnt, 1, devip);
458 errsts = check_readiness(SCpnt, 1, devip);
461 errsts = check_readiness(SCpnt, 1, devip);
464 errsts = resp_readcap(SCpnt, devip);
466 case SERVICE_ACTION_IN:
467 if (SAI_READ_CAPACITY_16 != cmd[1]) {
468 mk_sense_buffer(devip, ILLEGAL_REQUEST,
470 errsts = check_condition_result;
473 errsts = resp_readcap16(SCpnt, devip);
476 if (MI_REPORT_TARGET_PGS != cmd[1]) {
477 mk_sense_buffer(devip, ILLEGAL_REQUEST,
479 errsts = check_condition_result;
482 errsts = resp_report_tgtpgs(SCpnt, devip);
488 if ((errsts = check_readiness(SCpnt, 0, devip)))
490 if (scsi_debug_fake_rw)
492 get_data_transfer_info(cmd, &lba, &num);
493 errsts = resp_read(SCpnt, lba, num, devip);
494 if (inj_recovered && (0 == errsts)) {
495 mk_sense_buffer(devip, RECOVERED_ERROR,
496 THRESHOLD_EXCEEDED, 0);
497 errsts = check_condition_result;
498 } else if (inj_transport && (0 == errsts)) {
499 mk_sense_buffer(devip, ABORTED_COMMAND,
500 TRANSPORT_PROBLEM, ACK_NAK_TO);
501 errsts = check_condition_result;
504 case REPORT_LUNS: /* mandatory, ignore unit attention */
506 errsts = resp_report_luns(SCpnt, devip);
508 case VERIFY: /* 10 byte SBC-2 command */
509 errsts = check_readiness(SCpnt, 0, devip);
515 if ((errsts = check_readiness(SCpnt, 0, devip)))
517 if (scsi_debug_fake_rw)
519 get_data_transfer_info(cmd, &lba, &num);
520 errsts = resp_write(SCpnt, lba, num, devip);
521 if (inj_recovered && (0 == errsts)) {
522 mk_sense_buffer(devip, RECOVERED_ERROR,
523 THRESHOLD_EXCEEDED, 0);
524 errsts = check_condition_result;
529 errsts = resp_mode_sense(SCpnt, target, devip);
532 errsts = resp_mode_select(SCpnt, 1, devip);
535 errsts = resp_mode_select(SCpnt, 0, devip);
538 errsts = resp_log_sense(SCpnt, devip);
540 case SYNCHRONIZE_CACHE:
542 errsts = check_readiness(SCpnt, 0, devip);
545 errsts = check_readiness(SCpnt, 1, devip);
548 if (!scsi_bidi_cmnd(SCpnt)) {
549 mk_sense_buffer(devip, ILLEGAL_REQUEST,
550 INVALID_FIELD_IN_CDB, 0);
551 errsts = check_condition_result;
555 errsts = check_readiness(SCpnt, 0, devip);
558 if (scsi_debug_fake_rw)
560 get_data_transfer_info(cmd, &lba, &num);
561 errsts = resp_read(SCpnt, lba, num, devip);
564 errsts = resp_write(SCpnt, lba, num, devip);
567 errsts = resp_xdwriteread(SCpnt, lba, num, devip);
570 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
571 printk(KERN_INFO "scsi_debug: Opcode: 0x%x not "
572 "supported\n", *cmd);
573 if ((errsts = check_readiness(SCpnt, 1, devip)))
574 break; /* Unit attention takes precedence */
575 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
576 errsts = check_condition_result;
579 return schedule_resp(SCpnt, devip, done, errsts,
580 (delay_override ? 0 : scsi_debug_delay));
583 static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
585 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
586 printk(KERN_INFO "scsi_debug: ioctl: cmd=0x%x\n", cmd);
589 /* return -ENOTTY; // correct return but upsets fdisk */
592 static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
593 struct sdebug_dev_info * devip)
596 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
597 printk(KERN_INFO "scsi_debug: Reporting Unit "
598 "attention: power on reset\n");
600 mk_sense_buffer(devip, UNIT_ATTENTION, POWERON_RESET, 0);
601 return check_condition_result;
603 if ((0 == reset_only) && devip->stopped) {
604 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
605 printk(KERN_INFO "scsi_debug: Reporting Not "
606 "ready: initializing command required\n");
607 mk_sense_buffer(devip, NOT_READY, LOGICAL_UNIT_NOT_READY,
609 return check_condition_result;
614 /* Returns 0 if ok else (DID_ERROR << 16). Sets scp->resid . */
615 static int fill_from_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
618 int k, req_len, act_len, len, active;
621 struct scatterlist *sg;
622 struct scsi_data_buffer *sdb = scsi_in(scp);
627 return (DID_ERROR << 16);
628 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE))
629 return (DID_ERROR << 16);
631 req_len = act_len = 0;
632 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, k) {
634 kaddr = (unsigned char *)
635 kmap_atomic(sg_page(sg), KM_USER0);
637 return (DID_ERROR << 16);
638 kaddr_off = (unsigned char *)kaddr + sg->offset;
640 if ((req_len + len) > arr_len) {
642 len = arr_len - req_len;
644 memcpy(kaddr_off, arr + req_len, len);
645 kunmap_atomic(kaddr, KM_USER0);
648 req_len += sg->length;
651 sdb->resid -= act_len;
653 sdb->resid = req_len - act_len;
657 /* Returns number of bytes fetched into 'arr' or -1 if error. */
658 static int fetch_to_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
661 int k, req_len, len, fin;
664 struct scatterlist * sg;
666 if (0 == scsi_bufflen(scp))
668 if (NULL == scsi_sglist(scp))
670 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_TO_DEVICE))
673 scsi_for_each_sg(scp, sg, scsi_sg_count(scp), k) {
674 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
677 kaddr_off = (unsigned char *)kaddr + sg->offset;
679 if ((req_len + len) > max_arr_len) {
680 len = max_arr_len - req_len;
683 memcpy(arr + req_len, kaddr_off, len);
684 kunmap_atomic(kaddr, KM_USER0);
686 return req_len + len;
687 req_len += sg->length;
693 static const char * inq_vendor_id = "Linux ";
694 static const char * inq_product_id = "scsi_debug ";
695 static const char * inq_product_rev = "0004";
697 static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
698 int target_dev_id, int dev_id_num,
699 const char * dev_id_str,
705 port_a = target_dev_id + 1;
706 /* T10 vendor identifier field format (faked) */
707 arr[0] = 0x2; /* ASCII */
710 memcpy(&arr[4], inq_vendor_id, 8);
711 memcpy(&arr[12], inq_product_id, 16);
712 memcpy(&arr[28], dev_id_str, dev_id_str_len);
713 num = 8 + 16 + dev_id_str_len;
716 if (dev_id_num >= 0) {
717 /* NAA-5, Logical unit identifier (binary) */
718 arr[num++] = 0x1; /* binary (not necessarily sas) */
719 arr[num++] = 0x3; /* PIV=0, lu, naa */
722 arr[num++] = 0x53; /* naa-5 ieee company id=0x333333 (fake) */
726 arr[num++] = (dev_id_num >> 24);
727 arr[num++] = (dev_id_num >> 16) & 0xff;
728 arr[num++] = (dev_id_num >> 8) & 0xff;
729 arr[num++] = dev_id_num & 0xff;
730 /* Target relative port number */
731 arr[num++] = 0x61; /* proto=sas, binary */
732 arr[num++] = 0x94; /* PIV=1, target port, rel port */
733 arr[num++] = 0x0; /* reserved */
734 arr[num++] = 0x4; /* length */
735 arr[num++] = 0x0; /* reserved */
736 arr[num++] = 0x0; /* reserved */
738 arr[num++] = 0x1; /* relative port A */
740 /* NAA-5, Target port identifier */
741 arr[num++] = 0x61; /* proto=sas, binary */
742 arr[num++] = 0x93; /* piv=1, target port, naa */
745 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
749 arr[num++] = (port_a >> 24);
750 arr[num++] = (port_a >> 16) & 0xff;
751 arr[num++] = (port_a >> 8) & 0xff;
752 arr[num++] = port_a & 0xff;
753 /* NAA-5, Target port group identifier */
754 arr[num++] = 0x61; /* proto=sas, binary */
755 arr[num++] = 0x95; /* piv=1, target port group id */
760 arr[num++] = (port_group_id >> 8) & 0xff;
761 arr[num++] = port_group_id & 0xff;
762 /* NAA-5, Target device identifier */
763 arr[num++] = 0x61; /* proto=sas, binary */
764 arr[num++] = 0xa3; /* piv=1, target device, naa */
767 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
771 arr[num++] = (target_dev_id >> 24);
772 arr[num++] = (target_dev_id >> 16) & 0xff;
773 arr[num++] = (target_dev_id >> 8) & 0xff;
774 arr[num++] = target_dev_id & 0xff;
775 /* SCSI name string: Target device identifier */
776 arr[num++] = 0x63; /* proto=sas, UTF-8 */
777 arr[num++] = 0xa8; /* piv=1, target device, SCSI name string */
780 memcpy(arr + num, "naa.52222220", 12);
782 snprintf(b, sizeof(b), "%08X", target_dev_id);
783 memcpy(arr + num, b, 8);
785 memset(arr + num, 0, 4);
791 static unsigned char vpd84_data[] = {
792 /* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
793 0x22,0x22,0x22,0x0,0xbb,0x1,
794 0x22,0x22,0x22,0x0,0xbb,0x2,
797 static int inquiry_evpd_84(unsigned char * arr)
799 memcpy(arr, vpd84_data, sizeof(vpd84_data));
800 return sizeof(vpd84_data);
803 static int inquiry_evpd_85(unsigned char * arr)
806 const char * na1 = "https://www.kernel.org/config";
807 const char * na2 = "http://www.kernel.org/log";
810 arr[num++] = 0x1; /* lu, storage config */
811 arr[num++] = 0x0; /* reserved */
816 plen = ((plen / 4) + 1) * 4;
817 arr[num++] = plen; /* length, null termianted, padded */
818 memcpy(arr + num, na1, olen);
819 memset(arr + num + olen, 0, plen - olen);
822 arr[num++] = 0x4; /* lu, logging */
823 arr[num++] = 0x0; /* reserved */
828 plen = ((plen / 4) + 1) * 4;
829 arr[num++] = plen; /* length, null terminated, padded */
830 memcpy(arr + num, na2, olen);
831 memset(arr + num + olen, 0, plen - olen);
837 /* SCSI ports VPD page */
838 static int inquiry_evpd_88(unsigned char * arr, int target_dev_id)
843 port_a = target_dev_id + 1;
845 arr[num++] = 0x0; /* reserved */
846 arr[num++] = 0x0; /* reserved */
848 arr[num++] = 0x1; /* relative port 1 (primary) */
849 memset(arr + num, 0, 6);
852 arr[num++] = 12; /* length tp descriptor */
853 /* naa-5 target port identifier (A) */
854 arr[num++] = 0x61; /* proto=sas, binary */
855 arr[num++] = 0x93; /* PIV=1, target port, NAA */
856 arr[num++] = 0x0; /* reserved */
857 arr[num++] = 0x8; /* length */
858 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
862 arr[num++] = (port_a >> 24);
863 arr[num++] = (port_a >> 16) & 0xff;
864 arr[num++] = (port_a >> 8) & 0xff;
865 arr[num++] = port_a & 0xff;
867 arr[num++] = 0x0; /* reserved */
868 arr[num++] = 0x0; /* reserved */
870 arr[num++] = 0x2; /* relative port 2 (secondary) */
871 memset(arr + num, 0, 6);
874 arr[num++] = 12; /* length tp descriptor */
875 /* naa-5 target port identifier (B) */
876 arr[num++] = 0x61; /* proto=sas, binary */
877 arr[num++] = 0x93; /* PIV=1, target port, NAA */
878 arr[num++] = 0x0; /* reserved */
879 arr[num++] = 0x8; /* length */
880 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
884 arr[num++] = (port_b >> 24);
885 arr[num++] = (port_b >> 16) & 0xff;
886 arr[num++] = (port_b >> 8) & 0xff;
887 arr[num++] = port_b & 0xff;
893 static unsigned char vpd89_data[] = {
894 /* from 4th byte */ 0,0,0,0,
895 'l','i','n','u','x',' ',' ',' ',
896 'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
898 0x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
900 0x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
901 0,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
902 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
903 0x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
905 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
907 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
909 0,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
910 0x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
911 0x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
912 0,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
913 0x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
914 0x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
915 0,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
916 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
917 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
918 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
919 0x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
920 0,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
921 0xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
922 0,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
923 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
924 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
925 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
926 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
927 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
928 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
929 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
930 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
931 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
932 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
933 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
934 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
937 static int inquiry_evpd_89(unsigned char * arr)
939 memcpy(arr, vpd89_data, sizeof(vpd89_data));
940 return sizeof(vpd89_data);
944 static unsigned char vpdb0_data[] = {
945 /* from 4th byte */ 0,0,0,4,
950 static int inquiry_evpd_b0(unsigned char * arr)
952 memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
953 if (sdebug_store_sectors > 0x400) {
954 arr[4] = (sdebug_store_sectors >> 24) & 0xff;
955 arr[5] = (sdebug_store_sectors >> 16) & 0xff;
956 arr[6] = (sdebug_store_sectors >> 8) & 0xff;
957 arr[7] = sdebug_store_sectors & 0xff;
959 return sizeof(vpdb0_data);
963 #define SDEBUG_LONG_INQ_SZ 96
964 #define SDEBUG_MAX_INQ_ARR_SZ 584
966 static int resp_inquiry(struct scsi_cmnd * scp, int target,
967 struct sdebug_dev_info * devip)
969 unsigned char pq_pdt;
971 unsigned char *cmd = (unsigned char *)scp->cmnd;
972 int alloc_len, n, ret;
974 alloc_len = (cmd[3] << 8) + cmd[4];
975 arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
977 return DID_REQUEUE << 16;
979 pq_pdt = 0x1e; /* present, wlun */
980 else if (scsi_debug_no_lun_0 && (0 == devip->lun))
981 pq_pdt = 0x7f; /* not present, no device type */
983 pq_pdt = (scsi_debug_ptype & 0x1f);
985 if (0x2 & cmd[1]) { /* CMDDT bit set */
986 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
989 return check_condition_result;
990 } else if (0x1 & cmd[1]) { /* EVPD bit set */
991 int lu_id_num, port_group_id, target_dev_id, len;
993 int host_no = devip->sdbg_host->shost->host_no;
995 port_group_id = (((host_no + 1) & 0x7f) << 8) +
996 (devip->channel & 0x7f);
997 if (0 == scsi_debug_vpd_use_hostno)
999 lu_id_num = devip->wlun ? -1 : (((host_no + 1) * 2000) +
1000 (devip->target * 1000) + devip->lun);
1001 target_dev_id = ((host_no + 1) * 2000) +
1002 (devip->target * 1000) - 3;
1003 len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
1004 if (0 == cmd[2]) { /* supported vital product data pages */
1005 arr[1] = cmd[2]; /*sanity */
1007 arr[n++] = 0x0; /* this page */
1008 arr[n++] = 0x80; /* unit serial number */
1009 arr[n++] = 0x83; /* device identification */
1010 arr[n++] = 0x84; /* software interface ident. */
1011 arr[n++] = 0x85; /* management network addresses */
1012 arr[n++] = 0x86; /* extended inquiry */
1013 arr[n++] = 0x87; /* mode page policy */
1014 arr[n++] = 0x88; /* SCSI ports */
1015 arr[n++] = 0x89; /* ATA information */
1016 arr[n++] = 0xb0; /* Block limits (SBC) */
1017 arr[3] = n - 4; /* number of supported VPD pages */
1018 } else if (0x80 == cmd[2]) { /* unit serial number */
1019 arr[1] = cmd[2]; /*sanity */
1021 memcpy(&arr[4], lu_id_str, len);
1022 } else if (0x83 == cmd[2]) { /* device identification */
1023 arr[1] = cmd[2]; /*sanity */
1024 arr[3] = inquiry_evpd_83(&arr[4], port_group_id,
1025 target_dev_id, lu_id_num,
1027 } else if (0x84 == cmd[2]) { /* Software interface ident. */
1028 arr[1] = cmd[2]; /*sanity */
1029 arr[3] = inquiry_evpd_84(&arr[4]);
1030 } else if (0x85 == cmd[2]) { /* Management network addresses */
1031 arr[1] = cmd[2]; /*sanity */
1032 arr[3] = inquiry_evpd_85(&arr[4]);
1033 } else if (0x86 == cmd[2]) { /* extended inquiry */
1034 arr[1] = cmd[2]; /*sanity */
1035 arr[3] = 0x3c; /* number of following entries */
1036 arr[4] = 0x0; /* no protection stuff */
1037 arr[5] = 0x7; /* head of q, ordered + simple q's */
1038 } else if (0x87 == cmd[2]) { /* mode page policy */
1039 arr[1] = cmd[2]; /*sanity */
1040 arr[3] = 0x8; /* number of following entries */
1041 arr[4] = 0x2; /* disconnect-reconnect mp */
1042 arr[6] = 0x80; /* mlus, shared */
1043 arr[8] = 0x18; /* protocol specific lu */
1044 arr[10] = 0x82; /* mlus, per initiator port */
1045 } else if (0x88 == cmd[2]) { /* SCSI Ports */
1046 arr[1] = cmd[2]; /*sanity */
1047 arr[3] = inquiry_evpd_88(&arr[4], target_dev_id);
1048 } else if (0x89 == cmd[2]) { /* ATA information */
1049 arr[1] = cmd[2]; /*sanity */
1050 n = inquiry_evpd_89(&arr[4]);
1052 arr[3] = (n & 0xff);
1053 } else if (0xb0 == cmd[2]) { /* Block limits (SBC) */
1054 arr[1] = cmd[2]; /*sanity */
1055 arr[3] = inquiry_evpd_b0(&arr[4]);
1057 /* Illegal request, invalid field in cdb */
1058 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1059 INVALID_FIELD_IN_CDB, 0);
1061 return check_condition_result;
1063 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
1064 ret = fill_from_dev_buffer(scp, arr,
1065 min(len, SDEBUG_MAX_INQ_ARR_SZ));
1069 /* drops through here for a standard inquiry */
1070 arr[1] = DEV_REMOVEABLE(target) ? 0x80 : 0; /* Removable disk */
1071 arr[2] = scsi_debug_scsi_level;
1072 arr[3] = 2; /* response_data_format==2 */
1073 arr[4] = SDEBUG_LONG_INQ_SZ - 5;
1074 if (0 == scsi_debug_vpd_use_hostno)
1075 arr[5] = 0x10; /* claim: implicit TGPS */
1076 arr[6] = 0x10; /* claim: MultiP */
1077 /* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
1078 arr[7] = 0xa; /* claim: LINKED + CMDQUE */
1079 memcpy(&arr[8], inq_vendor_id, 8);
1080 memcpy(&arr[16], inq_product_id, 16);
1081 memcpy(&arr[32], inq_product_rev, 4);
1082 /* version descriptors (2 bytes each) follow */
1083 arr[58] = 0x0; arr[59] = 0x77; /* SAM-3 ANSI */
1084 arr[60] = 0x3; arr[61] = 0x14; /* SPC-3 ANSI */
1086 if (scsi_debug_ptype == 0) {
1087 arr[n++] = 0x3; arr[n++] = 0x3d; /* SBC-2 ANSI */
1088 } else if (scsi_debug_ptype == 1) {
1089 arr[n++] = 0x3; arr[n++] = 0x60; /* SSC-2 no version */
1091 arr[n++] = 0xc; arr[n++] = 0xf; /* SAS-1.1 rev 10 */
1092 ret = fill_from_dev_buffer(scp, arr,
1093 min(alloc_len, SDEBUG_LONG_INQ_SZ));
1098 static int resp_requests(struct scsi_cmnd * scp,
1099 struct sdebug_dev_info * devip)
1101 unsigned char * sbuff;
1102 unsigned char *cmd = (unsigned char *)scp->cmnd;
1103 unsigned char arr[SDEBUG_SENSE_LEN];
1107 memset(arr, 0, sizeof(arr));
1108 if (devip->reset == 1)
1109 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
1110 want_dsense = !!(cmd[1] & 1) || scsi_debug_dsense;
1111 sbuff = devip->sense_buff;
1112 if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
1115 arr[1] = 0x0; /* NO_SENSE in sense_key */
1116 arr[2] = THRESHOLD_EXCEEDED;
1117 arr[3] = 0xff; /* TEST set and MRIE==6 */
1120 arr[2] = 0x0; /* NO_SENSE in sense_key */
1121 arr[7] = 0xa; /* 18 byte sense buffer */
1122 arr[12] = THRESHOLD_EXCEEDED;
1123 arr[13] = 0xff; /* TEST set and MRIE==6 */
1126 memcpy(arr, sbuff, SDEBUG_SENSE_LEN);
1127 if ((cmd[1] & 1) && (! scsi_debug_dsense)) {
1128 /* DESC bit set and sense_buff in fixed format */
1129 memset(arr, 0, sizeof(arr));
1131 arr[1] = sbuff[2]; /* sense key */
1132 arr[2] = sbuff[12]; /* asc */
1133 arr[3] = sbuff[13]; /* ascq */
1137 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
1138 return fill_from_dev_buffer(scp, arr, len);
1141 static int resp_start_stop(struct scsi_cmnd * scp,
1142 struct sdebug_dev_info * devip)
1144 unsigned char *cmd = (unsigned char *)scp->cmnd;
1145 int power_cond, errsts, start;
1147 if ((errsts = check_readiness(scp, 1, devip)))
1149 power_cond = (cmd[4] & 0xf0) >> 4;
1151 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1153 return check_condition_result;
1156 if (start == devip->stopped)
1157 devip->stopped = !start;
1161 #define SDEBUG_READCAP_ARR_SZ 8
1162 static int resp_readcap(struct scsi_cmnd * scp,
1163 struct sdebug_dev_info * devip)
1165 unsigned char arr[SDEBUG_READCAP_ARR_SZ];
1169 if ((errsts = check_readiness(scp, 1, devip)))
1171 /* following just in case virtual_gb changed */
1172 if (scsi_debug_virtual_gb > 0) {
1173 sdebug_capacity = 2048 * 1024;
1174 sdebug_capacity *= scsi_debug_virtual_gb;
1176 sdebug_capacity = sdebug_store_sectors;
1177 memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
1178 if (sdebug_capacity < 0xffffffff) {
1179 capac = (unsigned int)sdebug_capacity - 1;
1180 arr[0] = (capac >> 24);
1181 arr[1] = (capac >> 16) & 0xff;
1182 arr[2] = (capac >> 8) & 0xff;
1183 arr[3] = capac & 0xff;
1190 arr[6] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1191 arr[7] = SECT_SIZE_PER(target) & 0xff;
1192 return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
1195 #define SDEBUG_READCAP16_ARR_SZ 32
1196 static int resp_readcap16(struct scsi_cmnd * scp,
1197 struct sdebug_dev_info * devip)
1199 unsigned char *cmd = (unsigned char *)scp->cmnd;
1200 unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
1201 unsigned long long capac;
1202 int errsts, k, alloc_len;
1204 if ((errsts = check_readiness(scp, 1, devip)))
1206 alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8)
1208 /* following just in case virtual_gb changed */
1209 if (scsi_debug_virtual_gb > 0) {
1210 sdebug_capacity = 2048 * 1024;
1211 sdebug_capacity *= scsi_debug_virtual_gb;
1213 sdebug_capacity = sdebug_store_sectors;
1214 memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
1215 capac = sdebug_capacity - 1;
1216 for (k = 0; k < 8; ++k, capac >>= 8)
1217 arr[7 - k] = capac & 0xff;
1218 arr[8] = (SECT_SIZE_PER(target) >> 24) & 0xff;
1219 arr[9] = (SECT_SIZE_PER(target) >> 16) & 0xff;
1220 arr[10] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1221 arr[11] = SECT_SIZE_PER(target) & 0xff;
1222 return fill_from_dev_buffer(scp, arr,
1223 min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
1226 #define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
1228 static int resp_report_tgtpgs(struct scsi_cmnd * scp,
1229 struct sdebug_dev_info * devip)
1231 unsigned char *cmd = (unsigned char *)scp->cmnd;
1232 unsigned char * arr;
1233 int host_no = devip->sdbg_host->shost->host_no;
1234 int n, ret, alen, rlen;
1235 int port_group_a, port_group_b, port_a, port_b;
1237 alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8)
1240 arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
1242 return DID_REQUEUE << 16;
1244 * EVPD page 0x88 states we have two ports, one
1245 * real and a fake port with no device connected.
1246 * So we create two port groups with one port each
1247 * and set the group with port B to unavailable.
1249 port_a = 0x1; /* relative port A */
1250 port_b = 0x2; /* relative port B */
1251 port_group_a = (((host_no + 1) & 0x7f) << 8) +
1252 (devip->channel & 0x7f);
1253 port_group_b = (((host_no + 1) & 0x7f) << 8) +
1254 (devip->channel & 0x7f) + 0x80;
1257 * The asymmetric access state is cycled according to the host_id.
1260 if (0 == scsi_debug_vpd_use_hostno) {
1261 arr[n++] = host_no % 3; /* Asymm access state */
1262 arr[n++] = 0x0F; /* claim: all states are supported */
1264 arr[n++] = 0x0; /* Active/Optimized path */
1265 arr[n++] = 0x01; /* claim: only support active/optimized paths */
1267 arr[n++] = (port_group_a >> 8) & 0xff;
1268 arr[n++] = port_group_a & 0xff;
1269 arr[n++] = 0; /* Reserved */
1270 arr[n++] = 0; /* Status code */
1271 arr[n++] = 0; /* Vendor unique */
1272 arr[n++] = 0x1; /* One port per group */
1273 arr[n++] = 0; /* Reserved */
1274 arr[n++] = 0; /* Reserved */
1275 arr[n++] = (port_a >> 8) & 0xff;
1276 arr[n++] = port_a & 0xff;
1277 arr[n++] = 3; /* Port unavailable */
1278 arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
1279 arr[n++] = (port_group_b >> 8) & 0xff;
1280 arr[n++] = port_group_b & 0xff;
1281 arr[n++] = 0; /* Reserved */
1282 arr[n++] = 0; /* Status code */
1283 arr[n++] = 0; /* Vendor unique */
1284 arr[n++] = 0x1; /* One port per group */
1285 arr[n++] = 0; /* Reserved */
1286 arr[n++] = 0; /* Reserved */
1287 arr[n++] = (port_b >> 8) & 0xff;
1288 arr[n++] = port_b & 0xff;
1291 arr[0] = (rlen >> 24) & 0xff;
1292 arr[1] = (rlen >> 16) & 0xff;
1293 arr[2] = (rlen >> 8) & 0xff;
1294 arr[3] = rlen & 0xff;
1297 * Return the smallest value of either
1298 * - The allocated length
1299 * - The constructed command length
1300 * - The maximum array size
1303 ret = fill_from_dev_buffer(scp, arr,
1304 min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
1309 /* <<Following mode page info copied from ST318451LW>> */
1311 static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
1312 { /* Read-Write Error Recovery page for mode_sense */
1313 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
1316 memcpy(p, err_recov_pg, sizeof(err_recov_pg));
1318 memset(p + 2, 0, sizeof(err_recov_pg) - 2);
1319 return sizeof(err_recov_pg);
1322 static int resp_disconnect_pg(unsigned char * p, int pcontrol, int target)
1323 { /* Disconnect-Reconnect page for mode_sense */
1324 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
1325 0, 0, 0, 0, 0, 0, 0, 0};
1327 memcpy(p, disconnect_pg, sizeof(disconnect_pg));
1329 memset(p + 2, 0, sizeof(disconnect_pg) - 2);
1330 return sizeof(disconnect_pg);
1333 static int resp_format_pg(unsigned char * p, int pcontrol, int target)
1334 { /* Format device page for mode_sense */
1335 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
1336 0, 0, 0, 0, 0, 0, 0, 0,
1337 0, 0, 0, 0, 0x40, 0, 0, 0};
1339 memcpy(p, format_pg, sizeof(format_pg));
1340 p[10] = (sdebug_sectors_per >> 8) & 0xff;
1341 p[11] = sdebug_sectors_per & 0xff;
1342 p[12] = (SECT_SIZE >> 8) & 0xff;
1343 p[13] = SECT_SIZE & 0xff;
1344 if (DEV_REMOVEABLE(target))
1345 p[20] |= 0x20; /* should agree with INQUIRY */
1347 memset(p + 2, 0, sizeof(format_pg) - 2);
1348 return sizeof(format_pg);
1351 static int resp_caching_pg(unsigned char * p, int pcontrol, int target)
1352 { /* Caching page for mode_sense */
1353 unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1354 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
1356 memcpy(p, caching_pg, sizeof(caching_pg));
1358 memset(p + 2, 0, sizeof(caching_pg) - 2);
1359 return sizeof(caching_pg);
1362 static int resp_ctrl_m_pg(unsigned char * p, int pcontrol, int target)
1363 { /* Control mode page for mode_sense */
1364 unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
1366 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1369 if (scsi_debug_dsense)
1370 ctrl_m_pg[2] |= 0x4;
1372 ctrl_m_pg[2] &= ~0x4;
1373 memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
1375 memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
1376 else if (2 == pcontrol)
1377 memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
1378 return sizeof(ctrl_m_pg);
1382 static int resp_iec_m_pg(unsigned char * p, int pcontrol, int target)
1383 { /* Informational Exceptions control mode page for mode_sense */
1384 unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
1386 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1389 memcpy(p, iec_m_pg, sizeof(iec_m_pg));
1391 memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
1392 else if (2 == pcontrol)
1393 memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
1394 return sizeof(iec_m_pg);
1397 static int resp_sas_sf_m_pg(unsigned char * p, int pcontrol, int target)
1398 { /* SAS SSP mode page - short format for mode_sense */
1399 unsigned char sas_sf_m_pg[] = {0x19, 0x6,
1400 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
1402 memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
1404 memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
1405 return sizeof(sas_sf_m_pg);
1409 static int resp_sas_pcd_m_spg(unsigned char * p, int pcontrol, int target,
1411 { /* SAS phy control and discover mode page for mode_sense */
1412 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
1413 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
1414 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1415 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1416 0x2, 0, 0, 0, 0, 0, 0, 0,
1417 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1418 0, 0, 0, 0, 0, 0, 0, 0,
1419 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
1420 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1421 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1422 0x3, 0, 0, 0, 0, 0, 0, 0,
1423 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1424 0, 0, 0, 0, 0, 0, 0, 0,
1428 port_a = target_dev_id + 1;
1429 port_b = port_a + 1;
1430 memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
1431 p[20] = (port_a >> 24);
1432 p[21] = (port_a >> 16) & 0xff;
1433 p[22] = (port_a >> 8) & 0xff;
1434 p[23] = port_a & 0xff;
1435 p[48 + 20] = (port_b >> 24);
1436 p[48 + 21] = (port_b >> 16) & 0xff;
1437 p[48 + 22] = (port_b >> 8) & 0xff;
1438 p[48 + 23] = port_b & 0xff;
1440 memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
1441 return sizeof(sas_pcd_m_pg);
1444 static int resp_sas_sha_m_spg(unsigned char * p, int pcontrol)
1445 { /* SAS SSP shared protocol specific port mode subpage */
1446 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
1447 0, 0, 0, 0, 0, 0, 0, 0,
1450 memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
1452 memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
1453 return sizeof(sas_sha_m_pg);
1456 #define SDEBUG_MAX_MSENSE_SZ 256
1458 static int resp_mode_sense(struct scsi_cmnd * scp, int target,
1459 struct sdebug_dev_info * devip)
1461 unsigned char dbd, llbaa;
1462 int pcontrol, pcode, subpcode, bd_len;
1463 unsigned char dev_spec;
1464 int k, alloc_len, msense_6, offset, len, errsts, target_dev_id;
1466 unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
1467 unsigned char *cmd = (unsigned char *)scp->cmnd;
1469 if ((errsts = check_readiness(scp, 1, devip)))
1471 dbd = !!(cmd[1] & 0x8);
1472 pcontrol = (cmd[2] & 0xc0) >> 6;
1473 pcode = cmd[2] & 0x3f;
1475 msense_6 = (MODE_SENSE == cmd[0]);
1476 llbaa = msense_6 ? 0 : !!(cmd[1] & 0x10);
1477 if ((0 == scsi_debug_ptype) && (0 == dbd))
1478 bd_len = llbaa ? 16 : 8;
1481 alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]);
1482 memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
1483 if (0x3 == pcontrol) { /* Saving values not supported */
1484 mk_sense_buffer(devip, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP,
1486 return check_condition_result;
1488 target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
1489 (devip->target * 1000) - 3;
1490 /* set DPOFUA bit for disks */
1491 if (0 == scsi_debug_ptype)
1492 dev_spec = (DEV_READONLY(target) ? 0x80 : 0x0) | 0x10;
1502 arr[4] = 0x1; /* set LONGLBA bit */
1503 arr[7] = bd_len; /* assume 255 or less */
1507 if ((bd_len > 0) && (0 == sdebug_capacity)) {
1508 if (scsi_debug_virtual_gb > 0) {
1509 sdebug_capacity = 2048 * 1024;
1510 sdebug_capacity *= scsi_debug_virtual_gb;
1512 sdebug_capacity = sdebug_store_sectors;
1515 if (sdebug_capacity > 0xfffffffe) {
1521 ap[0] = (sdebug_capacity >> 24) & 0xff;
1522 ap[1] = (sdebug_capacity >> 16) & 0xff;
1523 ap[2] = (sdebug_capacity >> 8) & 0xff;
1524 ap[3] = sdebug_capacity & 0xff;
1526 ap[6] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1527 ap[7] = SECT_SIZE_PER(target) & 0xff;
1530 } else if (16 == bd_len) {
1531 unsigned long long capac = sdebug_capacity;
1533 for (k = 0; k < 8; ++k, capac >>= 8)
1534 ap[7 - k] = capac & 0xff;
1535 ap[12] = (SECT_SIZE_PER(target) >> 24) & 0xff;
1536 ap[13] = (SECT_SIZE_PER(target) >> 16) & 0xff;
1537 ap[14] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1538 ap[15] = SECT_SIZE_PER(target) & 0xff;
1543 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
1544 /* TODO: Control Extension page */
1545 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1547 return check_condition_result;
1550 case 0x1: /* Read-Write error recovery page, direct access */
1551 len = resp_err_recov_pg(ap, pcontrol, target);
1554 case 0x2: /* Disconnect-Reconnect page, all devices */
1555 len = resp_disconnect_pg(ap, pcontrol, target);
1558 case 0x3: /* Format device page, direct access */
1559 len = resp_format_pg(ap, pcontrol, target);
1562 case 0x8: /* Caching page, direct access */
1563 len = resp_caching_pg(ap, pcontrol, target);
1566 case 0xa: /* Control Mode page, all devices */
1567 len = resp_ctrl_m_pg(ap, pcontrol, target);
1570 case 0x19: /* if spc==1 then sas phy, control+discover */
1571 if ((subpcode > 0x2) && (subpcode < 0xff)) {
1572 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1573 INVALID_FIELD_IN_CDB, 0);
1574 return check_condition_result;
1577 if ((0x0 == subpcode) || (0xff == subpcode))
1578 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1579 if ((0x1 == subpcode) || (0xff == subpcode))
1580 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
1582 if ((0x2 == subpcode) || (0xff == subpcode))
1583 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1586 case 0x1c: /* Informational Exceptions Mode page, all devices */
1587 len = resp_iec_m_pg(ap, pcontrol, target);
1590 case 0x3f: /* Read all Mode pages */
1591 if ((0 == subpcode) || (0xff == subpcode)) {
1592 len = resp_err_recov_pg(ap, pcontrol, target);
1593 len += resp_disconnect_pg(ap + len, pcontrol, target);
1594 len += resp_format_pg(ap + len, pcontrol, target);
1595 len += resp_caching_pg(ap + len, pcontrol, target);
1596 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
1597 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1598 if (0xff == subpcode) {
1599 len += resp_sas_pcd_m_spg(ap + len, pcontrol,
1600 target, target_dev_id);
1601 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1603 len += resp_iec_m_pg(ap + len, pcontrol, target);
1605 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1606 INVALID_FIELD_IN_CDB, 0);
1607 return check_condition_result;
1612 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1614 return check_condition_result;
1617 arr[0] = offset - 1;
1619 arr[0] = ((offset - 2) >> 8) & 0xff;
1620 arr[1] = (offset - 2) & 0xff;
1622 return fill_from_dev_buffer(scp, arr, min(alloc_len, offset));
1625 #define SDEBUG_MAX_MSELECT_SZ 512
1627 static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
1628 struct sdebug_dev_info * devip)
1630 int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
1631 int param_len, res, errsts, mpage;
1632 unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
1633 unsigned char *cmd = (unsigned char *)scp->cmnd;
1635 if ((errsts = check_readiness(scp, 1, devip)))
1637 memset(arr, 0, sizeof(arr));
1640 param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]);
1641 if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
1642 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1643 INVALID_FIELD_IN_CDB, 0);
1644 return check_condition_result;
1646 res = fetch_to_dev_buffer(scp, arr, param_len);
1648 return (DID_ERROR << 16);
1649 else if ((res < param_len) &&
1650 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1651 printk(KERN_INFO "scsi_debug: mode_select: cdb indicated=%d, "
1652 " IO sent=%d bytes\n", param_len, res);
1653 md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2);
1654 bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]);
1656 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1657 INVALID_FIELD_IN_PARAM_LIST, 0);
1658 return check_condition_result;
1660 off = bd_len + (mselect6 ? 4 : 8);
1661 mpage = arr[off] & 0x3f;
1662 ps = !!(arr[off] & 0x80);
1664 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1665 INVALID_FIELD_IN_PARAM_LIST, 0);
1666 return check_condition_result;
1668 spf = !!(arr[off] & 0x40);
1669 pg_len = spf ? ((arr[off + 2] << 8) + arr[off + 3] + 4) :
1671 if ((pg_len + off) > param_len) {
1672 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1673 PARAMETER_LIST_LENGTH_ERR, 0);
1674 return check_condition_result;
1677 case 0xa: /* Control Mode page */
1678 if (ctrl_m_pg[1] == arr[off + 1]) {
1679 memcpy(ctrl_m_pg + 2, arr + off + 2,
1680 sizeof(ctrl_m_pg) - 2);
1681 scsi_debug_dsense = !!(ctrl_m_pg[2] & 0x4);
1685 case 0x1c: /* Informational Exceptions Mode page */
1686 if (iec_m_pg[1] == arr[off + 1]) {
1687 memcpy(iec_m_pg + 2, arr + off + 2,
1688 sizeof(iec_m_pg) - 2);
1695 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1696 INVALID_FIELD_IN_PARAM_LIST, 0);
1697 return check_condition_result;
1700 static int resp_temp_l_pg(unsigned char * arr)
1702 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
1703 0x0, 0x1, 0x3, 0x2, 0x0, 65,
1706 memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
1707 return sizeof(temp_l_pg);
1710 static int resp_ie_l_pg(unsigned char * arr)
1712 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
1715 memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
1716 if (iec_m_pg[2] & 0x4) { /* TEST bit set */
1717 arr[4] = THRESHOLD_EXCEEDED;
1720 return sizeof(ie_l_pg);
1723 #define SDEBUG_MAX_LSENSE_SZ 512
1725 static int resp_log_sense(struct scsi_cmnd * scp,
1726 struct sdebug_dev_info * devip)
1728 int ppc, sp, pcontrol, pcode, subpcode, alloc_len, errsts, len, n;
1729 unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
1730 unsigned char *cmd = (unsigned char *)scp->cmnd;
1732 if ((errsts = check_readiness(scp, 1, devip)))
1734 memset(arr, 0, sizeof(arr));
1738 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1739 INVALID_FIELD_IN_CDB, 0);
1740 return check_condition_result;
1742 pcontrol = (cmd[2] & 0xc0) >> 6;
1743 pcode = cmd[2] & 0x3f;
1744 subpcode = cmd[3] & 0xff;
1745 alloc_len = (cmd[7] << 8) + cmd[8];
1747 if (0 == subpcode) {
1749 case 0x0: /* Supported log pages log page */
1751 arr[n++] = 0x0; /* this page */
1752 arr[n++] = 0xd; /* Temperature */
1753 arr[n++] = 0x2f; /* Informational exceptions */
1756 case 0xd: /* Temperature log page */
1757 arr[3] = resp_temp_l_pg(arr + 4);
1759 case 0x2f: /* Informational exceptions log page */
1760 arr[3] = resp_ie_l_pg(arr + 4);
1763 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1764 INVALID_FIELD_IN_CDB, 0);
1765 return check_condition_result;
1767 } else if (0xff == subpcode) {
1771 case 0x0: /* Supported log pages and subpages log page */
1774 arr[n++] = 0x0; /* 0,0 page */
1776 arr[n++] = 0xff; /* this page */
1778 arr[n++] = 0x0; /* Temperature */
1780 arr[n++] = 0x0; /* Informational exceptions */
1783 case 0xd: /* Temperature subpages */
1786 arr[n++] = 0x0; /* Temperature */
1789 case 0x2f: /* Informational exceptions subpages */
1792 arr[n++] = 0x0; /* Informational exceptions */
1796 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1797 INVALID_FIELD_IN_CDB, 0);
1798 return check_condition_result;
1801 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1802 INVALID_FIELD_IN_CDB, 0);
1803 return check_condition_result;
1805 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
1806 return fill_from_dev_buffer(scp, arr,
1807 min(len, SDEBUG_MAX_INQ_ARR_SZ));
1810 static int resp_read(struct scsi_cmnd * SCpnt, unsigned long long lba,
1811 unsigned int num, struct sdebug_dev_info * devip)
1813 unsigned long iflags;
1814 unsigned int block, from_bottom;
1815 unsigned long long u;
1818 if (lba + num > sdebug_capacity) {
1819 mk_sense_buffer(devip, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE,
1821 return check_condition_result;
1823 /* transfer length excessive (tie in to block limits VPD page) */
1824 if (num > sdebug_store_sectors) {
1825 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1827 return check_condition_result;
1829 if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) &&
1830 (lba <= OPT_MEDIUM_ERR_ADDR) &&
1831 ((lba + num) > OPT_MEDIUM_ERR_ADDR)) {
1832 /* claim unrecoverable read error */
1833 mk_sense_buffer(devip, MEDIUM_ERROR, UNRECOVERED_READ_ERR,
1835 /* set info field and valid bit for fixed descriptor */
1836 if (0x70 == (devip->sense_buff[0] & 0x7f)) {
1837 devip->sense_buff[0] |= 0x80; /* Valid bit */
1838 ret = OPT_MEDIUM_ERR_ADDR;
1839 devip->sense_buff[3] = (ret >> 24) & 0xff;
1840 devip->sense_buff[4] = (ret >> 16) & 0xff;
1841 devip->sense_buff[5] = (ret >> 8) & 0xff;
1842 devip->sense_buff[6] = ret & 0xff;
1844 return check_condition_result;
1846 read_lock_irqsave(&atomic_rw, iflags);
1847 if ((lba + num) <= sdebug_store_sectors)
1848 ret = fill_from_dev_buffer(SCpnt,
1849 fake_storep + (lba * SECT_SIZE),
1852 /* modulo when one arg is 64 bits needs do_div() */
1854 block = do_div(u, sdebug_store_sectors);
1856 if ((block + num) > sdebug_store_sectors)
1857 from_bottom = (block + num) - sdebug_store_sectors;
1858 ret = fill_from_dev_buffer(SCpnt,
1859 fake_storep + (block * SECT_SIZE),
1860 (num - from_bottom) * SECT_SIZE);
1861 if ((0 == ret) && (from_bottom > 0))
1862 ret = fill_from_dev_buffer(SCpnt, fake_storep,
1863 from_bottom * SECT_SIZE);
1865 read_unlock_irqrestore(&atomic_rw, iflags);
1869 static int resp_write(struct scsi_cmnd * SCpnt, unsigned long long lba,
1870 unsigned int num, struct sdebug_dev_info * devip)
1872 unsigned long iflags;
1873 unsigned int block, to_bottom;
1874 unsigned long long u;
1877 if (lba + num > sdebug_capacity) {
1878 mk_sense_buffer(devip, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE,
1880 return check_condition_result;
1882 /* transfer length excessive (tie in to block limits VPD page) */
1883 if (num > sdebug_store_sectors) {
1884 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1886 return check_condition_result;
1889 write_lock_irqsave(&atomic_rw, iflags);
1890 if ((lba + num) <= sdebug_store_sectors)
1891 res = fetch_to_dev_buffer(SCpnt,
1892 fake_storep + (lba * SECT_SIZE),
1895 /* modulo when one arg is 64 bits needs do_div() */
1897 block = do_div(u, sdebug_store_sectors);
1899 if ((block + num) > sdebug_store_sectors)
1900 to_bottom = (block + num) - sdebug_store_sectors;
1901 res = fetch_to_dev_buffer(SCpnt,
1902 fake_storep + (block * SECT_SIZE),
1903 (num - to_bottom) * SECT_SIZE);
1904 if ((0 == res) && (to_bottom > 0))
1905 res = fetch_to_dev_buffer(SCpnt, fake_storep,
1906 to_bottom * SECT_SIZE);
1908 write_unlock_irqrestore(&atomic_rw, iflags);
1910 return (DID_ERROR << 16);
1911 else if ((res < (num * SECT_SIZE)) &&
1912 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1913 printk(KERN_INFO "scsi_debug: write: cdb indicated=%u, "
1914 " IO sent=%d bytes\n", num * SECT_SIZE, res);
1918 #define SDEBUG_RLUN_ARR_SZ 256
1920 static int resp_report_luns(struct scsi_cmnd * scp,
1921 struct sdebug_dev_info * devip)
1923 unsigned int alloc_len;
1924 int lun_cnt, i, upper, num, n, wlun, lun;
1925 unsigned char *cmd = (unsigned char *)scp->cmnd;
1926 int select_report = (int)cmd[2];
1927 struct scsi_lun *one_lun;
1928 unsigned char arr[SDEBUG_RLUN_ARR_SZ];
1929 unsigned char * max_addr;
1931 alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
1932 if ((alloc_len < 4) || (select_report > 2)) {
1933 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1935 return check_condition_result;
1937 /* can produce response with up to 16k luns (lun 0 to lun 16383) */
1938 memset(arr, 0, SDEBUG_RLUN_ARR_SZ);
1939 lun_cnt = scsi_debug_max_luns;
1940 if (1 == select_report)
1942 else if (scsi_debug_no_lun_0 && (lun_cnt > 0))
1944 wlun = (select_report > 0) ? 1 : 0;
1945 num = lun_cnt + wlun;
1946 arr[2] = ((sizeof(struct scsi_lun) * num) >> 8) & 0xff;
1947 arr[3] = (sizeof(struct scsi_lun) * num) & 0xff;
1948 n = min((int)((SDEBUG_RLUN_ARR_SZ - 8) /
1949 sizeof(struct scsi_lun)), num);
1954 one_lun = (struct scsi_lun *) &arr[8];
1955 max_addr = arr + SDEBUG_RLUN_ARR_SZ;
1956 for (i = 0, lun = (scsi_debug_no_lun_0 ? 1 : 0);
1957 ((i < lun_cnt) && ((unsigned char *)(one_lun + i) < max_addr));
1959 upper = (lun >> 8) & 0x3f;
1961 one_lun[i].scsi_lun[0] =
1962 (upper | (SAM2_LUN_ADDRESS_METHOD << 6));
1963 one_lun[i].scsi_lun[1] = lun & 0xff;
1966 one_lun[i].scsi_lun[0] = (SAM2_WLUN_REPORT_LUNS >> 8) & 0xff;
1967 one_lun[i].scsi_lun[1] = SAM2_WLUN_REPORT_LUNS & 0xff;
1970 alloc_len = (unsigned char *)(one_lun + i) - arr;
1971 return fill_from_dev_buffer(scp, arr,
1972 min((int)alloc_len, SDEBUG_RLUN_ARR_SZ));
1975 static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
1976 unsigned int num, struct sdebug_dev_info *devip)
1979 unsigned char *kaddr, *buf;
1980 unsigned int offset;
1981 struct scatterlist *sg;
1982 struct scsi_data_buffer *sdb = scsi_in(scp);
1984 /* better not to use temporary buffer. */
1985 buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
1990 scsi_for_each_sg(scp, sg, scsi_sg_count(scp), i) {
1991 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
1995 memcpy(buf + offset, kaddr + sg->offset, sg->length);
1996 offset += sg->length;
1997 kunmap_atomic(kaddr, KM_USER0);
2001 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, i) {
2002 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
2006 for (j = 0; j < sg->length; j++)
2007 *(kaddr + sg->offset + j) ^= *(buf + offset + j);
2009 offset += sg->length;
2010 kunmap_atomic(kaddr, KM_USER0);
2019 /* When timer goes off this function is called. */
2020 static void timer_intr_handler(unsigned long indx)
2022 struct sdebug_queued_cmd * sqcp;
2023 unsigned long iflags;
2025 if (indx >= SCSI_DEBUG_CANQUEUE) {
2026 printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too "
2030 spin_lock_irqsave(&queued_arr_lock, iflags);
2031 sqcp = &queued_arr[(int)indx];
2032 if (! sqcp->in_use) {
2033 printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected "
2035 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2039 if (sqcp->done_funct) {
2040 sqcp->a_cmnd->result = sqcp->scsi_result;
2041 sqcp->done_funct(sqcp->a_cmnd); /* callback to mid level */
2043 sqcp->done_funct = NULL;
2044 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2047 static int scsi_debug_slave_alloc(struct scsi_device * sdp)
2049 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2050 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
2051 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2052 set_bit(QUEUE_FLAG_BIDI, &sdp->request_queue->queue_flags);
2056 static int scsi_debug_slave_configure(struct scsi_device * sdp)
2058 struct sdebug_dev_info * devip;
2060 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2061 printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n",
2062 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2063 if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN)
2064 sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN;
2065 devip = devInfoReg(sdp);
2067 return 1; /* no resources, will be marked offline */
2068 sdp->hostdata = devip;
2069 if (sdp->host->cmd_per_lun)
2070 scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING,
2071 sdp->host->cmd_per_lun);
2072 blk_queue_max_segment_size(sdp->request_queue, 256 * 1024);
2076 static void scsi_debug_slave_destroy(struct scsi_device * sdp)
2078 struct sdebug_dev_info * devip =
2079 (struct sdebug_dev_info *)sdp->hostdata;
2081 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2082 printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n",
2083 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2085 /* make this slot avaliable for re-use */
2087 sdp->hostdata = NULL;
2091 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
2093 struct sdebug_host_info * sdbg_host;
2094 struct sdebug_dev_info * open_devip = NULL;
2095 struct sdebug_dev_info * devip =
2096 (struct sdebug_dev_info *)sdev->hostdata;
2100 sdbg_host = *(struct sdebug_host_info **) sdev->host->hostdata;
2102 printk(KERN_ERR "Host info NULL\n");
2105 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
2106 if ((devip->used) && (devip->channel == sdev->channel) &&
2107 (devip->target == sdev->id) &&
2108 (devip->lun == sdev->lun))
2111 if ((!devip->used) && (!open_devip))
2115 if (NULL == open_devip) { /* try and make a new one */
2116 open_devip = kzalloc(sizeof(*open_devip),GFP_ATOMIC);
2117 if (NULL == open_devip) {
2118 printk(KERN_ERR "%s: out of memory at line %d\n",
2119 __FUNCTION__, __LINE__);
2122 open_devip->sdbg_host = sdbg_host;
2123 list_add_tail(&open_devip->dev_list,
2124 &sdbg_host->dev_info_list);
2127 open_devip->channel = sdev->channel;
2128 open_devip->target = sdev->id;
2129 open_devip->lun = sdev->lun;
2130 open_devip->sdbg_host = sdbg_host;
2131 open_devip->reset = 1;
2132 open_devip->used = 1;
2133 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
2134 if (scsi_debug_dsense)
2135 open_devip->sense_buff[0] = 0x72;
2137 open_devip->sense_buff[0] = 0x70;
2138 open_devip->sense_buff[7] = 0xa;
2140 if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
2141 open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
2147 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
2150 unsigned char * sbuff;
2152 sbuff = devip->sense_buff;
2153 memset(sbuff, 0, SDEBUG_SENSE_LEN);
2154 if (scsi_debug_dsense) {
2155 sbuff[0] = 0x72; /* descriptor, current */
2160 sbuff[0] = 0x70; /* fixed, current */
2162 sbuff[7] = 0xa; /* implies 18 byte sense buffer */
2166 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2167 printk(KERN_INFO "scsi_debug: [sense_key,asc,ascq]: "
2168 "[0x%x,0x%x,0x%x]\n", key, asc, asq);
2171 static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
2173 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2174 printk(KERN_INFO "scsi_debug: abort\n");
2176 stop_queued_cmnd(SCpnt);
2180 static int scsi_debug_biosparam(struct scsi_device *sdev,
2181 struct block_device * bdev, sector_t capacity, int *info)
2186 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2187 printk(KERN_INFO "scsi_debug: biosparam\n");
2188 buf = scsi_bios_ptable(bdev);
2190 res = scsi_partsize(buf, capacity,
2191 &info[2], &info[0], &info[1]);
2196 info[0] = sdebug_heads;
2197 info[1] = sdebug_sectors_per;
2198 info[2] = sdebug_cylinders_per;
2202 static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
2204 struct sdebug_dev_info * devip;
2206 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2207 printk(KERN_INFO "scsi_debug: device_reset\n");
2210 devip = devInfoReg(SCpnt->device);
2217 static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
2219 struct sdebug_host_info *sdbg_host;
2220 struct sdebug_dev_info * dev_info;
2221 struct scsi_device * sdp;
2222 struct Scsi_Host * hp;
2224 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2225 printk(KERN_INFO "scsi_debug: bus_reset\n");
2227 if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
2228 sdbg_host = *(struct sdebug_host_info **) hp->hostdata;
2230 list_for_each_entry(dev_info,
2231 &sdbg_host->dev_info_list,
2233 dev_info->reset = 1;
2239 static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
2241 struct sdebug_host_info * sdbg_host;
2242 struct sdebug_dev_info * dev_info;
2244 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2245 printk(KERN_INFO "scsi_debug: host_reset\n");
2247 spin_lock(&sdebug_host_list_lock);
2248 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
2249 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
2251 dev_info->reset = 1;
2253 spin_unlock(&sdebug_host_list_lock);
2258 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
2259 static int stop_queued_cmnd(struct scsi_cmnd * cmnd)
2261 unsigned long iflags;
2263 struct sdebug_queued_cmd * sqcp;
2265 spin_lock_irqsave(&queued_arr_lock, iflags);
2266 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2267 sqcp = &queued_arr[k];
2268 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
2269 del_timer_sync(&sqcp->cmnd_timer);
2271 sqcp->a_cmnd = NULL;
2275 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2276 return (k < SCSI_DEBUG_CANQUEUE) ? 1 : 0;
2279 /* Deletes (stops) timers of all queued commands */
2280 static void stop_all_queued(void)
2282 unsigned long iflags;
2284 struct sdebug_queued_cmd * sqcp;
2286 spin_lock_irqsave(&queued_arr_lock, iflags);
2287 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2288 sqcp = &queued_arr[k];
2289 if (sqcp->in_use && sqcp->a_cmnd) {
2290 del_timer_sync(&sqcp->cmnd_timer);
2292 sqcp->a_cmnd = NULL;
2295 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2298 /* Initializes timers in queued array */
2299 static void __init init_all_queued(void)
2301 unsigned long iflags;
2303 struct sdebug_queued_cmd * sqcp;
2305 spin_lock_irqsave(&queued_arr_lock, iflags);
2306 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2307 sqcp = &queued_arr[k];
2308 init_timer(&sqcp->cmnd_timer);
2310 sqcp->a_cmnd = NULL;
2312 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2315 static void __init sdebug_build_parts(unsigned char * ramp)
2317 struct partition * pp;
2318 int starts[SDEBUG_MAX_PARTS + 2];
2319 int sectors_per_part, num_sectors, k;
2320 int heads_by_sects, start_sec, end_sec;
2322 /* assume partition table already zeroed */
2323 if ((scsi_debug_num_parts < 1) || (sdebug_store_size < 1048576))
2325 if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
2326 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
2327 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
2328 "partitions to %d\n", SDEBUG_MAX_PARTS);
2330 num_sectors = (int)sdebug_store_sectors;
2331 sectors_per_part = (num_sectors - sdebug_sectors_per)
2332 / scsi_debug_num_parts;
2333 heads_by_sects = sdebug_heads * sdebug_sectors_per;
2334 starts[0] = sdebug_sectors_per;
2335 for (k = 1; k < scsi_debug_num_parts; ++k)
2336 starts[k] = ((k * sectors_per_part) / heads_by_sects)
2338 starts[scsi_debug_num_parts] = num_sectors;
2339 starts[scsi_debug_num_parts + 1] = 0;
2341 ramp[510] = 0x55; /* magic partition markings */
2343 pp = (struct partition *)(ramp + 0x1be);
2344 for (k = 0; starts[k + 1]; ++k, ++pp) {
2345 start_sec = starts[k];
2346 end_sec = starts[k + 1] - 1;
2349 pp->cyl = start_sec / heads_by_sects;
2350 pp->head = (start_sec - (pp->cyl * heads_by_sects))
2351 / sdebug_sectors_per;
2352 pp->sector = (start_sec % sdebug_sectors_per) + 1;
2354 pp->end_cyl = end_sec / heads_by_sects;
2355 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
2356 / sdebug_sectors_per;
2357 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2359 pp->start_sect = start_sec;
2360 pp->nr_sects = end_sec - start_sec + 1;
2361 pp->sys_ind = 0x83; /* plain Linux partition */
2365 static int schedule_resp(struct scsi_cmnd * cmnd,
2366 struct sdebug_dev_info * devip,
2367 done_funct_t done, int scsi_result, int delta_jiff)
2369 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
2371 struct scsi_device * sdp = cmnd->device;
2373 printk(KERN_INFO "scsi_debug: <%u %u %u %u> "
2374 "non-zero result=0x%x\n", sdp->host->host_no,
2375 sdp->channel, sdp->id, sdp->lun, scsi_result);
2378 if (cmnd && devip) {
2379 /* simulate autosense by this driver */
2380 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
2381 memcpy(cmnd->sense_buffer, devip->sense_buff,
2382 (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
2383 SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
2385 if (delta_jiff <= 0) {
2387 cmnd->result = scsi_result;
2392 unsigned long iflags;
2394 struct sdebug_queued_cmd * sqcp = NULL;
2396 spin_lock_irqsave(&queued_arr_lock, iflags);
2397 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2398 sqcp = &queued_arr[k];
2402 if (k >= SCSI_DEBUG_CANQUEUE) {
2403 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2404 printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
2405 return 1; /* report busy to mid level */
2408 sqcp->a_cmnd = cmnd;
2409 sqcp->scsi_result = scsi_result;
2410 sqcp->done_funct = done;
2411 sqcp->cmnd_timer.function = timer_intr_handler;
2412 sqcp->cmnd_timer.data = k;
2413 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
2414 add_timer(&sqcp->cmnd_timer);
2415 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2422 /* Note: The following macros create attribute files in the
2423 /sys/module/scsi_debug/parameters directory. Unfortunately this
2424 driver is unaware of a change and cannot trigger auxiliary actions
2425 as it can when the corresponding attribute in the
2426 /sys/bus/pseudo/drivers/scsi_debug directory is changed.
2428 module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
2429 module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
2430 module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
2431 module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
2432 module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
2433 module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
2434 module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
2435 module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
2436 module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
2437 module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
2438 module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
2439 module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
2440 module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
2441 module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
2442 module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
2445 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2446 MODULE_DESCRIPTION("SCSI debug adapter driver");
2447 MODULE_LICENSE("GPL");
2448 MODULE_VERSION(SCSI_DEBUG_VERSION);
2450 MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
2451 MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
2452 MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
2453 MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
2454 MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
2455 MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
2456 MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
2457 MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
2458 MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
2459 MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
2460 MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
2461 MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
2462 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
2463 MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
2464 MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2467 static char sdebug_info[256];
2469 static const char * scsi_debug_info(struct Scsi_Host * shp)
2471 sprintf(sdebug_info, "scsi_debug, version %s [%s], "
2472 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
2473 scsi_debug_version_date, scsi_debug_dev_size_mb,
2478 /* scsi_debug_proc_info
2479 * Used if the driver currently has no own support for /proc/scsi
2481 static int scsi_debug_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
2482 int length, int inout)
2484 int len, pos, begin;
2487 orig_length = length;
2491 int minLen = length > 15 ? 15 : length;
2493 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2495 memcpy(arr, buffer, minLen);
2497 if (1 != sscanf(arr, "%d", &pos))
2499 scsi_debug_opts = pos;
2500 if (scsi_debug_every_nth != 0)
2501 scsi_debug_cmnd_count = 0;
2505 pos = len = sprintf(buffer, "scsi_debug adapter driver, version "
2507 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2508 "every_nth=%d(curr:%d)\n"
2509 "delay=%d, max_luns=%d, scsi_level=%d\n"
2510 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2511 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2513 SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
2514 scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2515 scsi_debug_cmnd_count, scsi_debug_delay,
2516 scsi_debug_max_luns, scsi_debug_scsi_level,
2517 SECT_SIZE, sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
2518 num_aborts, num_dev_resets, num_bus_resets, num_host_resets);
2523 *start = buffer + (offset - begin); /* Start of wanted data */
2524 len -= (offset - begin);
2530 static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf)
2532 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
2535 static ssize_t sdebug_delay_store(struct device_driver * ddp,
2536 const char * buf, size_t count)
2541 if (1 == sscanf(buf, "%10s", work)) {
2542 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
2543 scsi_debug_delay = delay;
2549 DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show,
2550 sdebug_delay_store);
2552 static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf)
2554 return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
2557 static ssize_t sdebug_opts_store(struct device_driver * ddp,
2558 const char * buf, size_t count)
2563 if (1 == sscanf(buf, "%10s", work)) {
2564 if (0 == strnicmp(work,"0x", 2)) {
2565 if (1 == sscanf(&work[2], "%x", &opts))
2568 if (1 == sscanf(work, "%d", &opts))
2574 scsi_debug_opts = opts;
2575 scsi_debug_cmnd_count = 0;
2578 DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show,
2581 static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf)
2583 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
2585 static ssize_t sdebug_ptype_store(struct device_driver * ddp,
2586 const char * buf, size_t count)
2590 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2591 scsi_debug_ptype = n;
2596 DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store);
2598 static ssize_t sdebug_dsense_show(struct device_driver * ddp, char * buf)
2600 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
2602 static ssize_t sdebug_dsense_store(struct device_driver * ddp,
2603 const char * buf, size_t count)
2607 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2608 scsi_debug_dsense = n;
2613 DRIVER_ATTR(dsense, S_IRUGO | S_IWUSR, sdebug_dsense_show,
2614 sdebug_dsense_store);
2616 static ssize_t sdebug_fake_rw_show(struct device_driver * ddp, char * buf)
2618 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
2620 static ssize_t sdebug_fake_rw_store(struct device_driver * ddp,
2621 const char * buf, size_t count)
2625 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2626 scsi_debug_fake_rw = n;
2631 DRIVER_ATTR(fake_rw, S_IRUGO | S_IWUSR, sdebug_fake_rw_show,
2632 sdebug_fake_rw_store);
2634 static ssize_t sdebug_no_lun_0_show(struct device_driver * ddp, char * buf)
2636 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
2638 static ssize_t sdebug_no_lun_0_store(struct device_driver * ddp,
2639 const char * buf, size_t count)
2643 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2644 scsi_debug_no_lun_0 = n;
2649 DRIVER_ATTR(no_lun_0, S_IRUGO | S_IWUSR, sdebug_no_lun_0_show,
2650 sdebug_no_lun_0_store);
2652 static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf)
2654 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
2656 static ssize_t sdebug_num_tgts_store(struct device_driver * ddp,
2657 const char * buf, size_t count)
2661 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2662 scsi_debug_num_tgts = n;
2663 sdebug_max_tgts_luns();
2668 DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show,
2669 sdebug_num_tgts_store);
2671 static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf)
2673 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
2675 DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL);
2677 static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf)
2679 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
2681 DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL);
2683 static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf)
2685 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
2687 static ssize_t sdebug_every_nth_store(struct device_driver * ddp,
2688 const char * buf, size_t count)
2692 if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
2693 scsi_debug_every_nth = nth;
2694 scsi_debug_cmnd_count = 0;
2699 DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show,
2700 sdebug_every_nth_store);
2702 static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf)
2704 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
2706 static ssize_t sdebug_max_luns_store(struct device_driver * ddp,
2707 const char * buf, size_t count)
2711 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2712 scsi_debug_max_luns = n;
2713 sdebug_max_tgts_luns();
2718 DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show,
2719 sdebug_max_luns_store);
2721 static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf)
2723 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
2725 DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL);
2727 static ssize_t sdebug_virtual_gb_show(struct device_driver * ddp, char * buf)
2729 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
2731 static ssize_t sdebug_virtual_gb_store(struct device_driver * ddp,
2732 const char * buf, size_t count)
2736 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2737 scsi_debug_virtual_gb = n;
2738 if (scsi_debug_virtual_gb > 0) {
2739 sdebug_capacity = 2048 * 1024;
2740 sdebug_capacity *= scsi_debug_virtual_gb;
2742 sdebug_capacity = sdebug_store_sectors;
2747 DRIVER_ATTR(virtual_gb, S_IRUGO | S_IWUSR, sdebug_virtual_gb_show,
2748 sdebug_virtual_gb_store);
2750 static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf)
2752 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
2755 static ssize_t sdebug_add_host_store(struct device_driver * ddp,
2756 const char * buf, size_t count)
2761 if (1 != sscanf(buf, "%10s", work))
2763 { /* temporary hack around sscanf() problem with -ve nums */
2768 if (1 != sscanf(work + neg, "%d", &delta_hosts))
2771 delta_hosts = -delta_hosts;
2773 if (delta_hosts > 0) {
2775 sdebug_add_adapter();
2776 } while (--delta_hosts);
2777 } else if (delta_hosts < 0) {
2779 sdebug_remove_adapter();
2780 } while (++delta_hosts);
2784 DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show,
2785 sdebug_add_host_store);
2787 static ssize_t sdebug_vpd_use_hostno_show(struct device_driver * ddp,
2790 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
2792 static ssize_t sdebug_vpd_use_hostno_store(struct device_driver * ddp,
2793 const char * buf, size_t count)
2797 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2798 scsi_debug_vpd_use_hostno = n;
2803 DRIVER_ATTR(vpd_use_hostno, S_IRUGO | S_IWUSR, sdebug_vpd_use_hostno_show,
2804 sdebug_vpd_use_hostno_store);
2806 /* Note: The following function creates attribute files in the
2807 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
2808 files (over those found in the /sys/module/scsi_debug/parameters
2809 directory) is that auxiliary actions can be triggered when an attribute
2810 is changed. For example see: sdebug_add_host_store() above.
2812 static int do_create_driverfs_files(void)
2816 ret = driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2817 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay);
2818 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2819 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2820 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2821 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2822 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2823 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2824 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2825 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2826 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2827 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts);
2828 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2829 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2830 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2834 static void do_remove_driverfs_files(void)
2836 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2837 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2838 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2839 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts);
2840 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2841 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2842 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2843 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2844 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2845 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2846 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2847 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2848 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2849 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay);
2850 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2853 static int __init scsi_debug_init(void)
2860 if (scsi_debug_dev_size_mb < 1)
2861 scsi_debug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */
2862 sdebug_store_size = (unsigned int)scsi_debug_dev_size_mb * 1048576;
2863 sdebug_store_sectors = sdebug_store_size / SECT_SIZE;
2864 if (scsi_debug_virtual_gb > 0) {
2865 sdebug_capacity = 2048 * 1024;
2866 sdebug_capacity *= scsi_debug_virtual_gb;
2868 sdebug_capacity = sdebug_store_sectors;
2870 /* play around with geometry, don't waste too much on track 0 */
2872 sdebug_sectors_per = 32;
2873 if (scsi_debug_dev_size_mb >= 16)
2875 else if (scsi_debug_dev_size_mb >= 256)
2877 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2878 (sdebug_sectors_per * sdebug_heads);
2879 if (sdebug_cylinders_per >= 1024) {
2880 /* other LLDs do this; implies >= 1GB ram disk ... */
2882 sdebug_sectors_per = 63;
2883 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2884 (sdebug_sectors_per * sdebug_heads);
2887 sz = sdebug_store_size;
2888 fake_storep = vmalloc(sz);
2889 if (NULL == fake_storep) {
2890 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
2893 memset(fake_storep, 0, sz);
2894 if (scsi_debug_num_parts > 0)
2895 sdebug_build_parts(fake_storep);
2897 ret = device_register(&pseudo_primary);
2899 printk(KERN_WARNING "scsi_debug: device_register error: %d\n",
2903 ret = bus_register(&pseudo_lld_bus);
2905 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
2909 ret = driver_register(&sdebug_driverfs_driver);
2911 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
2915 ret = do_create_driverfs_files();
2917 printk(KERN_WARNING "scsi_debug: driver_create_file error: %d\n",
2924 sdebug_driver_template.proc_name = sdebug_proc_name;
2926 host_to_add = scsi_debug_add_host;
2927 scsi_debug_add_host = 0;
2929 for (k = 0; k < host_to_add; k++) {
2930 if (sdebug_add_adapter()) {
2931 printk(KERN_ERR "scsi_debug_init: "
2932 "sdebug_add_adapter failed k=%d\n", k);
2937 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
2938 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
2939 scsi_debug_add_host);
2944 do_remove_driverfs_files();
2945 driver_unregister(&sdebug_driverfs_driver);
2947 bus_unregister(&pseudo_lld_bus);
2949 device_unregister(&pseudo_primary);
2956 static void __exit scsi_debug_exit(void)
2958 int k = scsi_debug_add_host;
2962 sdebug_remove_adapter();
2963 do_remove_driverfs_files();
2964 driver_unregister(&sdebug_driverfs_driver);
2965 bus_unregister(&pseudo_lld_bus);
2966 device_unregister(&pseudo_primary);
2971 device_initcall(scsi_debug_init);
2972 module_exit(scsi_debug_exit);
2974 static void pseudo_0_release(struct device * dev)
2976 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2977 printk(KERN_INFO "scsi_debug: pseudo_0_release() called\n");
2980 static struct device pseudo_primary = {
2981 .bus_id = "pseudo_0",
2982 .release = pseudo_0_release,
2985 static int pseudo_lld_bus_match(struct device *dev,
2986 struct device_driver *dev_driver)
2991 static struct bus_type pseudo_lld_bus = {
2993 .match = pseudo_lld_bus_match,
2994 .probe = sdebug_driver_probe,
2995 .remove = sdebug_driver_remove,
2998 static void sdebug_release_adapter(struct device * dev)
3000 struct sdebug_host_info *sdbg_host;
3002 sdbg_host = to_sdebug_host(dev);
3006 static int sdebug_add_adapter(void)
3008 int k, devs_per_host;
3010 struct sdebug_host_info *sdbg_host;
3011 struct sdebug_dev_info *sdbg_devinfo;
3012 struct list_head *lh, *lh_sf;
3014 sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
3015 if (NULL == sdbg_host) {
3016 printk(KERN_ERR "%s: out of memory at line %d\n",
3017 __FUNCTION__, __LINE__);
3021 INIT_LIST_HEAD(&sdbg_host->dev_info_list);
3023 devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
3024 for (k = 0; k < devs_per_host; k++) {
3025 sdbg_devinfo = kzalloc(sizeof(*sdbg_devinfo),GFP_KERNEL);
3026 if (NULL == sdbg_devinfo) {
3027 printk(KERN_ERR "%s: out of memory at line %d\n",
3028 __FUNCTION__, __LINE__);
3032 sdbg_devinfo->sdbg_host = sdbg_host;
3033 list_add_tail(&sdbg_devinfo->dev_list,
3034 &sdbg_host->dev_info_list);
3037 spin_lock(&sdebug_host_list_lock);
3038 list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
3039 spin_unlock(&sdebug_host_list_lock);
3041 sdbg_host->dev.bus = &pseudo_lld_bus;
3042 sdbg_host->dev.parent = &pseudo_primary;
3043 sdbg_host->dev.release = &sdebug_release_adapter;
3044 sprintf(sdbg_host->dev.bus_id, "adapter%d", scsi_debug_add_host);
3046 error = device_register(&sdbg_host->dev);
3051 ++scsi_debug_add_host;
3055 list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
3056 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
3058 list_del(&sdbg_devinfo->dev_list);
3059 kfree(sdbg_devinfo);
3066 static void sdebug_remove_adapter(void)
3068 struct sdebug_host_info * sdbg_host = NULL;
3070 spin_lock(&sdebug_host_list_lock);
3071 if (!list_empty(&sdebug_host_list)) {
3072 sdbg_host = list_entry(sdebug_host_list.prev,
3073 struct sdebug_host_info, host_list);
3074 list_del(&sdbg_host->host_list);
3076 spin_unlock(&sdebug_host_list_lock);
3081 device_unregister(&sdbg_host->dev);
3082 --scsi_debug_add_host;
3085 static int sdebug_driver_probe(struct device * dev)
3088 struct sdebug_host_info *sdbg_host;
3089 struct Scsi_Host *hpnt;
3091 sdbg_host = to_sdebug_host(dev);
3093 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
3095 printk(KERN_ERR "%s: scsi_register failed\n", __FUNCTION__);
3100 sdbg_host->shost = hpnt;
3101 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
3102 if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
3103 hpnt->max_id = scsi_debug_num_tgts + 1;
3105 hpnt->max_id = scsi_debug_num_tgts;
3106 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* = scsi_debug_max_luns; */
3108 error = scsi_add_host(hpnt, &sdbg_host->dev);
3110 printk(KERN_ERR "%s: scsi_add_host failed\n", __FUNCTION__);
3112 scsi_host_put(hpnt);
3114 scsi_scan_host(hpnt);
3120 static int sdebug_driver_remove(struct device * dev)
3122 struct list_head *lh, *lh_sf;
3123 struct sdebug_host_info *sdbg_host;
3124 struct sdebug_dev_info *sdbg_devinfo;
3126 sdbg_host = to_sdebug_host(dev);
3129 printk(KERN_ERR "%s: Unable to locate host info\n",
3134 scsi_remove_host(sdbg_host->shost);
3136 list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
3137 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
3139 list_del(&sdbg_devinfo->dev_list);
3140 kfree(sdbg_devinfo);
3143 scsi_host_put(sdbg_host->shost);
3147 static void sdebug_max_tgts_luns(void)
3149 struct sdebug_host_info * sdbg_host;
3150 struct Scsi_Host *hpnt;
3152 spin_lock(&sdebug_host_list_lock);
3153 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
3154 hpnt = sdbg_host->shost;
3155 if ((hpnt->this_id >= 0) &&
3156 (scsi_debug_num_tgts > hpnt->this_id))
3157 hpnt->max_id = scsi_debug_num_tgts + 1;
3159 hpnt->max_id = scsi_debug_num_tgts;
3160 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* scsi_debug_max_luns; */
3162 spin_unlock(&sdebug_host_list_lock);