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;
348 return 0; /* assume mid level reprocessing command */
350 scsi_set_resid(SCpnt, 0);
351 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) {
352 printk(KERN_INFO "scsi_debug: cmd ");
353 for (k = 0, len = SCpnt->cmd_len; k < len; ++k)
354 printk("%02x ", (int)cmd[k]);
358 if (target == SCpnt->device->host->hostt->this_id) {
359 printk(KERN_INFO "scsi_debug: initiator's id used as "
361 return schedule_resp(SCpnt, NULL, done,
362 DID_NO_CONNECT << 16, 0);
365 if ((SCpnt->device->lun >= scsi_debug_max_luns) &&
366 (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS))
367 return schedule_resp(SCpnt, NULL, done,
368 DID_NO_CONNECT << 16, 0);
369 devip = devInfoReg(SCpnt->device);
371 return schedule_resp(SCpnt, NULL, done,
372 DID_NO_CONNECT << 16, 0);
374 if ((scsi_debug_every_nth != 0) &&
375 (++scsi_debug_cmnd_count >= abs(scsi_debug_every_nth))) {
376 scsi_debug_cmnd_count = 0;
377 if (scsi_debug_every_nth < -1)
378 scsi_debug_every_nth = -1;
379 if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
380 return 0; /* ignore command causing timeout */
381 else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
382 inj_recovered = 1; /* to reads and writes below */
383 else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts)
384 inj_transport = 1; /* to reads and writes below */
391 case TEST_UNIT_READY:
393 break; /* only allowable wlun commands */
395 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
396 printk(KERN_INFO "scsi_debug: Opcode: 0x%x "
397 "not supported for wlun\n", *cmd);
398 mk_sense_buffer(devip, ILLEGAL_REQUEST,
400 errsts = check_condition_result;
401 return schedule_resp(SCpnt, devip, done, errsts,
407 case INQUIRY: /* mandatory, ignore unit attention */
409 errsts = resp_inquiry(SCpnt, target, devip);
411 case REQUEST_SENSE: /* mandatory, ignore unit attention */
413 errsts = resp_requests(SCpnt, devip);
415 case REZERO_UNIT: /* actually this is REWIND for SSC */
417 errsts = resp_start_stop(SCpnt, devip);
419 case ALLOW_MEDIUM_REMOVAL:
420 if ((errsts = check_readiness(SCpnt, 1, devip)))
422 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
423 printk(KERN_INFO "scsi_debug: Medium removal %s\n",
424 cmd[4] ? "inhibited" : "enabled");
426 case SEND_DIAGNOSTIC: /* mandatory */
427 errsts = check_readiness(SCpnt, 1, devip);
429 case TEST_UNIT_READY: /* mandatory */
431 errsts = check_readiness(SCpnt, 0, devip);
434 errsts = check_readiness(SCpnt, 1, devip);
437 errsts = check_readiness(SCpnt, 1, devip);
440 errsts = check_readiness(SCpnt, 1, devip);
443 errsts = check_readiness(SCpnt, 1, devip);
446 errsts = resp_readcap(SCpnt, devip);
448 case SERVICE_ACTION_IN:
449 if (SAI_READ_CAPACITY_16 != cmd[1]) {
450 mk_sense_buffer(devip, ILLEGAL_REQUEST,
452 errsts = check_condition_result;
455 errsts = resp_readcap16(SCpnt, devip);
458 if (MI_REPORT_TARGET_PGS != cmd[1]) {
459 mk_sense_buffer(devip, ILLEGAL_REQUEST,
461 errsts = check_condition_result;
464 errsts = resp_report_tgtpgs(SCpnt, devip);
470 if ((errsts = check_readiness(SCpnt, 0, devip)))
472 if (scsi_debug_fake_rw)
474 get_data_transfer_info(cmd, &lba, &num);
475 errsts = resp_read(SCpnt, lba, num, devip);
476 if (inj_recovered && (0 == errsts)) {
477 mk_sense_buffer(devip, RECOVERED_ERROR,
478 THRESHOLD_EXCEEDED, 0);
479 errsts = check_condition_result;
480 } else if (inj_transport && (0 == errsts)) {
481 mk_sense_buffer(devip, ABORTED_COMMAND,
482 TRANSPORT_PROBLEM, ACK_NAK_TO);
483 errsts = check_condition_result;
486 case REPORT_LUNS: /* mandatory, ignore unit attention */
488 errsts = resp_report_luns(SCpnt, devip);
490 case VERIFY: /* 10 byte SBC-2 command */
491 errsts = check_readiness(SCpnt, 0, devip);
497 if ((errsts = check_readiness(SCpnt, 0, devip)))
499 if (scsi_debug_fake_rw)
501 get_data_transfer_info(cmd, &lba, &num);
502 errsts = resp_write(SCpnt, lba, num, devip);
503 if (inj_recovered && (0 == errsts)) {
504 mk_sense_buffer(devip, RECOVERED_ERROR,
505 THRESHOLD_EXCEEDED, 0);
506 errsts = check_condition_result;
511 errsts = resp_mode_sense(SCpnt, target, devip);
514 errsts = resp_mode_select(SCpnt, 1, devip);
517 errsts = resp_mode_select(SCpnt, 0, devip);
520 errsts = resp_log_sense(SCpnt, devip);
522 case SYNCHRONIZE_CACHE:
524 errsts = check_readiness(SCpnt, 0, devip);
527 errsts = check_readiness(SCpnt, 1, devip);
530 if (!scsi_bidi_cmnd(SCpnt)) {
531 mk_sense_buffer(devip, ILLEGAL_REQUEST,
532 INVALID_FIELD_IN_CDB, 0);
533 errsts = check_condition_result;
537 errsts = check_readiness(SCpnt, 0, devip);
540 if (scsi_debug_fake_rw)
542 get_data_transfer_info(cmd, &lba, &num);
543 errsts = resp_read(SCpnt, lba, num, devip);
546 errsts = resp_write(SCpnt, lba, num, devip);
549 errsts = resp_xdwriteread(SCpnt, lba, num, devip);
552 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
553 printk(KERN_INFO "scsi_debug: Opcode: 0x%x not "
554 "supported\n", *cmd);
555 if ((errsts = check_readiness(SCpnt, 1, devip)))
556 break; /* Unit attention takes precedence */
557 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
558 errsts = check_condition_result;
561 return schedule_resp(SCpnt, devip, done, errsts,
562 (delay_override ? 0 : scsi_debug_delay));
565 static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
567 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
568 printk(KERN_INFO "scsi_debug: ioctl: cmd=0x%x\n", cmd);
571 /* return -ENOTTY; // correct return but upsets fdisk */
574 static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
575 struct sdebug_dev_info * devip)
578 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
579 printk(KERN_INFO "scsi_debug: Reporting Unit "
580 "attention: power on reset\n");
582 mk_sense_buffer(devip, UNIT_ATTENTION, POWERON_RESET, 0);
583 return check_condition_result;
585 if ((0 == reset_only) && devip->stopped) {
586 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
587 printk(KERN_INFO "scsi_debug: Reporting Not "
588 "ready: initializing command required\n");
589 mk_sense_buffer(devip, NOT_READY, LOGICAL_UNIT_NOT_READY,
591 return check_condition_result;
596 /* Returns 0 if ok else (DID_ERROR << 16). Sets scp->resid . */
597 static int fill_from_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
600 int k, req_len, act_len, len, active;
603 struct scatterlist *sg;
604 struct scsi_data_buffer *sdb = scsi_in(scp);
609 return (DID_ERROR << 16);
610 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE))
611 return (DID_ERROR << 16);
613 req_len = act_len = 0;
614 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, k) {
616 kaddr = (unsigned char *)
617 kmap_atomic(sg_page(sg), KM_USER0);
619 return (DID_ERROR << 16);
620 kaddr_off = (unsigned char *)kaddr + sg->offset;
622 if ((req_len + len) > arr_len) {
624 len = arr_len - req_len;
626 memcpy(kaddr_off, arr + req_len, len);
627 kunmap_atomic(kaddr, KM_USER0);
630 req_len += sg->length;
633 sdb->resid -= act_len;
635 sdb->resid = req_len - act_len;
639 /* Returns number of bytes fetched into 'arr' or -1 if error. */
640 static int fetch_to_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
643 int k, req_len, len, fin;
646 struct scatterlist * sg;
648 if (0 == scsi_bufflen(scp))
650 if (NULL == scsi_sglist(scp))
652 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_TO_DEVICE))
655 scsi_for_each_sg(scp, sg, scsi_sg_count(scp), k) {
656 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
659 kaddr_off = (unsigned char *)kaddr + sg->offset;
661 if ((req_len + len) > max_arr_len) {
662 len = max_arr_len - req_len;
665 memcpy(arr + req_len, kaddr_off, len);
666 kunmap_atomic(kaddr, KM_USER0);
668 return req_len + len;
669 req_len += sg->length;
675 static const char * inq_vendor_id = "Linux ";
676 static const char * inq_product_id = "scsi_debug ";
677 static const char * inq_product_rev = "0004";
679 static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
680 int target_dev_id, int dev_id_num,
681 const char * dev_id_str,
687 port_a = target_dev_id + 1;
688 /* T10 vendor identifier field format (faked) */
689 arr[0] = 0x2; /* ASCII */
692 memcpy(&arr[4], inq_vendor_id, 8);
693 memcpy(&arr[12], inq_product_id, 16);
694 memcpy(&arr[28], dev_id_str, dev_id_str_len);
695 num = 8 + 16 + dev_id_str_len;
698 if (dev_id_num >= 0) {
699 /* NAA-5, Logical unit identifier (binary) */
700 arr[num++] = 0x1; /* binary (not necessarily sas) */
701 arr[num++] = 0x3; /* PIV=0, lu, naa */
704 arr[num++] = 0x53; /* naa-5 ieee company id=0x333333 (fake) */
708 arr[num++] = (dev_id_num >> 24);
709 arr[num++] = (dev_id_num >> 16) & 0xff;
710 arr[num++] = (dev_id_num >> 8) & 0xff;
711 arr[num++] = dev_id_num & 0xff;
712 /* Target relative port number */
713 arr[num++] = 0x61; /* proto=sas, binary */
714 arr[num++] = 0x94; /* PIV=1, target port, rel port */
715 arr[num++] = 0x0; /* reserved */
716 arr[num++] = 0x4; /* length */
717 arr[num++] = 0x0; /* reserved */
718 arr[num++] = 0x0; /* reserved */
720 arr[num++] = 0x1; /* relative port A */
722 /* NAA-5, Target port identifier */
723 arr[num++] = 0x61; /* proto=sas, binary */
724 arr[num++] = 0x93; /* piv=1, target port, naa */
727 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
731 arr[num++] = (port_a >> 24);
732 arr[num++] = (port_a >> 16) & 0xff;
733 arr[num++] = (port_a >> 8) & 0xff;
734 arr[num++] = port_a & 0xff;
735 /* NAA-5, Target port group identifier */
736 arr[num++] = 0x61; /* proto=sas, binary */
737 arr[num++] = 0x95; /* piv=1, target port group id */
742 arr[num++] = (port_group_id >> 8) & 0xff;
743 arr[num++] = port_group_id & 0xff;
744 /* NAA-5, Target device identifier */
745 arr[num++] = 0x61; /* proto=sas, binary */
746 arr[num++] = 0xa3; /* piv=1, target device, naa */
749 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
753 arr[num++] = (target_dev_id >> 24);
754 arr[num++] = (target_dev_id >> 16) & 0xff;
755 arr[num++] = (target_dev_id >> 8) & 0xff;
756 arr[num++] = target_dev_id & 0xff;
757 /* SCSI name string: Target device identifier */
758 arr[num++] = 0x63; /* proto=sas, UTF-8 */
759 arr[num++] = 0xa8; /* piv=1, target device, SCSI name string */
762 memcpy(arr + num, "naa.52222220", 12);
764 snprintf(b, sizeof(b), "%08X", target_dev_id);
765 memcpy(arr + num, b, 8);
767 memset(arr + num, 0, 4);
773 static unsigned char vpd84_data[] = {
774 /* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
775 0x22,0x22,0x22,0x0,0xbb,0x1,
776 0x22,0x22,0x22,0x0,0xbb,0x2,
779 static int inquiry_evpd_84(unsigned char * arr)
781 memcpy(arr, vpd84_data, sizeof(vpd84_data));
782 return sizeof(vpd84_data);
785 static int inquiry_evpd_85(unsigned char * arr)
788 const char * na1 = "https://www.kernel.org/config";
789 const char * na2 = "http://www.kernel.org/log";
792 arr[num++] = 0x1; /* lu, storage config */
793 arr[num++] = 0x0; /* reserved */
798 plen = ((plen / 4) + 1) * 4;
799 arr[num++] = plen; /* length, null termianted, padded */
800 memcpy(arr + num, na1, olen);
801 memset(arr + num + olen, 0, plen - olen);
804 arr[num++] = 0x4; /* lu, logging */
805 arr[num++] = 0x0; /* reserved */
810 plen = ((plen / 4) + 1) * 4;
811 arr[num++] = plen; /* length, null terminated, padded */
812 memcpy(arr + num, na2, olen);
813 memset(arr + num + olen, 0, plen - olen);
819 /* SCSI ports VPD page */
820 static int inquiry_evpd_88(unsigned char * arr, int target_dev_id)
825 port_a = target_dev_id + 1;
827 arr[num++] = 0x0; /* reserved */
828 arr[num++] = 0x0; /* reserved */
830 arr[num++] = 0x1; /* relative port 1 (primary) */
831 memset(arr + num, 0, 6);
834 arr[num++] = 12; /* length tp descriptor */
835 /* naa-5 target port identifier (A) */
836 arr[num++] = 0x61; /* proto=sas, binary */
837 arr[num++] = 0x93; /* PIV=1, target port, NAA */
838 arr[num++] = 0x0; /* reserved */
839 arr[num++] = 0x8; /* length */
840 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
844 arr[num++] = (port_a >> 24);
845 arr[num++] = (port_a >> 16) & 0xff;
846 arr[num++] = (port_a >> 8) & 0xff;
847 arr[num++] = port_a & 0xff;
849 arr[num++] = 0x0; /* reserved */
850 arr[num++] = 0x0; /* reserved */
852 arr[num++] = 0x2; /* relative port 2 (secondary) */
853 memset(arr + num, 0, 6);
856 arr[num++] = 12; /* length tp descriptor */
857 /* naa-5 target port identifier (B) */
858 arr[num++] = 0x61; /* proto=sas, binary */
859 arr[num++] = 0x93; /* PIV=1, target port, NAA */
860 arr[num++] = 0x0; /* reserved */
861 arr[num++] = 0x8; /* length */
862 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
866 arr[num++] = (port_b >> 24);
867 arr[num++] = (port_b >> 16) & 0xff;
868 arr[num++] = (port_b >> 8) & 0xff;
869 arr[num++] = port_b & 0xff;
875 static unsigned char vpd89_data[] = {
876 /* from 4th byte */ 0,0,0,0,
877 'l','i','n','u','x',' ',' ',' ',
878 'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
880 0x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
882 0x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
883 0,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
884 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
885 0x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
887 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
889 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
891 0,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
892 0x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
893 0x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
894 0,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
895 0x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
896 0x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
897 0,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
898 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
899 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
900 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
901 0x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
902 0,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
903 0xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
904 0,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
905 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
906 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
907 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
908 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
909 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
910 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
911 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
912 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
913 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
914 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
915 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
916 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
919 static int inquiry_evpd_89(unsigned char * arr)
921 memcpy(arr, vpd89_data, sizeof(vpd89_data));
922 return sizeof(vpd89_data);
926 static unsigned char vpdb0_data[] = {
927 /* from 4th byte */ 0,0,0,4,
932 static int inquiry_evpd_b0(unsigned char * arr)
934 memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
935 if (sdebug_store_sectors > 0x400) {
936 arr[4] = (sdebug_store_sectors >> 24) & 0xff;
937 arr[5] = (sdebug_store_sectors >> 16) & 0xff;
938 arr[6] = (sdebug_store_sectors >> 8) & 0xff;
939 arr[7] = sdebug_store_sectors & 0xff;
941 return sizeof(vpdb0_data);
945 #define SDEBUG_LONG_INQ_SZ 96
946 #define SDEBUG_MAX_INQ_ARR_SZ 584
948 static int resp_inquiry(struct scsi_cmnd * scp, int target,
949 struct sdebug_dev_info * devip)
951 unsigned char pq_pdt;
953 unsigned char *cmd = (unsigned char *)scp->cmnd;
954 int alloc_len, n, ret;
956 alloc_len = (cmd[3] << 8) + cmd[4];
957 arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
959 return DID_REQUEUE << 16;
961 pq_pdt = 0x1e; /* present, wlun */
962 else if (scsi_debug_no_lun_0 && (0 == devip->lun))
963 pq_pdt = 0x7f; /* not present, no device type */
965 pq_pdt = (scsi_debug_ptype & 0x1f);
967 if (0x2 & cmd[1]) { /* CMDDT bit set */
968 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
971 return check_condition_result;
972 } else if (0x1 & cmd[1]) { /* EVPD bit set */
973 int lu_id_num, port_group_id, target_dev_id, len;
975 int host_no = devip->sdbg_host->shost->host_no;
977 port_group_id = (((host_no + 1) & 0x7f) << 8) +
978 (devip->channel & 0x7f);
979 if (0 == scsi_debug_vpd_use_hostno)
981 lu_id_num = devip->wlun ? -1 : (((host_no + 1) * 2000) +
982 (devip->target * 1000) + devip->lun);
983 target_dev_id = ((host_no + 1) * 2000) +
984 (devip->target * 1000) - 3;
985 len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
986 if (0 == cmd[2]) { /* supported vital product data pages */
987 arr[1] = cmd[2]; /*sanity */
989 arr[n++] = 0x0; /* this page */
990 arr[n++] = 0x80; /* unit serial number */
991 arr[n++] = 0x83; /* device identification */
992 arr[n++] = 0x84; /* software interface ident. */
993 arr[n++] = 0x85; /* management network addresses */
994 arr[n++] = 0x86; /* extended inquiry */
995 arr[n++] = 0x87; /* mode page policy */
996 arr[n++] = 0x88; /* SCSI ports */
997 arr[n++] = 0x89; /* ATA information */
998 arr[n++] = 0xb0; /* Block limits (SBC) */
999 arr[3] = n - 4; /* number of supported VPD pages */
1000 } else if (0x80 == cmd[2]) { /* unit serial number */
1001 arr[1] = cmd[2]; /*sanity */
1003 memcpy(&arr[4], lu_id_str, len);
1004 } else if (0x83 == cmd[2]) { /* device identification */
1005 arr[1] = cmd[2]; /*sanity */
1006 arr[3] = inquiry_evpd_83(&arr[4], port_group_id,
1007 target_dev_id, lu_id_num,
1009 } else if (0x84 == cmd[2]) { /* Software interface ident. */
1010 arr[1] = cmd[2]; /*sanity */
1011 arr[3] = inquiry_evpd_84(&arr[4]);
1012 } else if (0x85 == cmd[2]) { /* Management network addresses */
1013 arr[1] = cmd[2]; /*sanity */
1014 arr[3] = inquiry_evpd_85(&arr[4]);
1015 } else if (0x86 == cmd[2]) { /* extended inquiry */
1016 arr[1] = cmd[2]; /*sanity */
1017 arr[3] = 0x3c; /* number of following entries */
1018 arr[4] = 0x0; /* no protection stuff */
1019 arr[5] = 0x7; /* head of q, ordered + simple q's */
1020 } else if (0x87 == cmd[2]) { /* mode page policy */
1021 arr[1] = cmd[2]; /*sanity */
1022 arr[3] = 0x8; /* number of following entries */
1023 arr[4] = 0x2; /* disconnect-reconnect mp */
1024 arr[6] = 0x80; /* mlus, shared */
1025 arr[8] = 0x18; /* protocol specific lu */
1026 arr[10] = 0x82; /* mlus, per initiator port */
1027 } else if (0x88 == cmd[2]) { /* SCSI Ports */
1028 arr[1] = cmd[2]; /*sanity */
1029 arr[3] = inquiry_evpd_88(&arr[4], target_dev_id);
1030 } else if (0x89 == cmd[2]) { /* ATA information */
1031 arr[1] = cmd[2]; /*sanity */
1032 n = inquiry_evpd_89(&arr[4]);
1034 arr[3] = (n & 0xff);
1035 } else if (0xb0 == cmd[2]) { /* Block limits (SBC) */
1036 arr[1] = cmd[2]; /*sanity */
1037 arr[3] = inquiry_evpd_b0(&arr[4]);
1039 /* Illegal request, invalid field in cdb */
1040 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1041 INVALID_FIELD_IN_CDB, 0);
1043 return check_condition_result;
1045 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
1046 ret = fill_from_dev_buffer(scp, arr,
1047 min(len, SDEBUG_MAX_INQ_ARR_SZ));
1051 /* drops through here for a standard inquiry */
1052 arr[1] = DEV_REMOVEABLE(target) ? 0x80 : 0; /* Removable disk */
1053 arr[2] = scsi_debug_scsi_level;
1054 arr[3] = 2; /* response_data_format==2 */
1055 arr[4] = SDEBUG_LONG_INQ_SZ - 5;
1056 if (0 == scsi_debug_vpd_use_hostno)
1057 arr[5] = 0x10; /* claim: implicit TGPS */
1058 arr[6] = 0x10; /* claim: MultiP */
1059 /* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
1060 arr[7] = 0xa; /* claim: LINKED + CMDQUE */
1061 memcpy(&arr[8], inq_vendor_id, 8);
1062 memcpy(&arr[16], inq_product_id, 16);
1063 memcpy(&arr[32], inq_product_rev, 4);
1064 /* version descriptors (2 bytes each) follow */
1065 arr[58] = 0x0; arr[59] = 0x77; /* SAM-3 ANSI */
1066 arr[60] = 0x3; arr[61] = 0x14; /* SPC-3 ANSI */
1068 if (scsi_debug_ptype == 0) {
1069 arr[n++] = 0x3; arr[n++] = 0x3d; /* SBC-2 ANSI */
1070 } else if (scsi_debug_ptype == 1) {
1071 arr[n++] = 0x3; arr[n++] = 0x60; /* SSC-2 no version */
1073 arr[n++] = 0xc; arr[n++] = 0xf; /* SAS-1.1 rev 10 */
1074 ret = fill_from_dev_buffer(scp, arr,
1075 min(alloc_len, SDEBUG_LONG_INQ_SZ));
1080 static int resp_requests(struct scsi_cmnd * scp,
1081 struct sdebug_dev_info * devip)
1083 unsigned char * sbuff;
1084 unsigned char *cmd = (unsigned char *)scp->cmnd;
1085 unsigned char arr[SDEBUG_SENSE_LEN];
1089 memset(arr, 0, sizeof(arr));
1090 if (devip->reset == 1)
1091 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
1092 want_dsense = !!(cmd[1] & 1) || scsi_debug_dsense;
1093 sbuff = devip->sense_buff;
1094 if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
1097 arr[1] = 0x0; /* NO_SENSE in sense_key */
1098 arr[2] = THRESHOLD_EXCEEDED;
1099 arr[3] = 0xff; /* TEST set and MRIE==6 */
1102 arr[2] = 0x0; /* NO_SENSE in sense_key */
1103 arr[7] = 0xa; /* 18 byte sense buffer */
1104 arr[12] = THRESHOLD_EXCEEDED;
1105 arr[13] = 0xff; /* TEST set and MRIE==6 */
1108 memcpy(arr, sbuff, SDEBUG_SENSE_LEN);
1109 if ((cmd[1] & 1) && (! scsi_debug_dsense)) {
1110 /* DESC bit set and sense_buff in fixed format */
1111 memset(arr, 0, sizeof(arr));
1113 arr[1] = sbuff[2]; /* sense key */
1114 arr[2] = sbuff[12]; /* asc */
1115 arr[3] = sbuff[13]; /* ascq */
1119 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
1120 return fill_from_dev_buffer(scp, arr, len);
1123 static int resp_start_stop(struct scsi_cmnd * scp,
1124 struct sdebug_dev_info * devip)
1126 unsigned char *cmd = (unsigned char *)scp->cmnd;
1127 int power_cond, errsts, start;
1129 if ((errsts = check_readiness(scp, 1, devip)))
1131 power_cond = (cmd[4] & 0xf0) >> 4;
1133 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1135 return check_condition_result;
1138 if (start == devip->stopped)
1139 devip->stopped = !start;
1143 #define SDEBUG_READCAP_ARR_SZ 8
1144 static int resp_readcap(struct scsi_cmnd * scp,
1145 struct sdebug_dev_info * devip)
1147 unsigned char arr[SDEBUG_READCAP_ARR_SZ];
1151 if ((errsts = check_readiness(scp, 1, devip)))
1153 /* following just in case virtual_gb changed */
1154 if (scsi_debug_virtual_gb > 0) {
1155 sdebug_capacity = 2048 * 1024;
1156 sdebug_capacity *= scsi_debug_virtual_gb;
1158 sdebug_capacity = sdebug_store_sectors;
1159 memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
1160 if (sdebug_capacity < 0xffffffff) {
1161 capac = (unsigned int)sdebug_capacity - 1;
1162 arr[0] = (capac >> 24);
1163 arr[1] = (capac >> 16) & 0xff;
1164 arr[2] = (capac >> 8) & 0xff;
1165 arr[3] = capac & 0xff;
1172 arr[6] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1173 arr[7] = SECT_SIZE_PER(target) & 0xff;
1174 return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
1177 #define SDEBUG_READCAP16_ARR_SZ 32
1178 static int resp_readcap16(struct scsi_cmnd * scp,
1179 struct sdebug_dev_info * devip)
1181 unsigned char *cmd = (unsigned char *)scp->cmnd;
1182 unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
1183 unsigned long long capac;
1184 int errsts, k, alloc_len;
1186 if ((errsts = check_readiness(scp, 1, devip)))
1188 alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8)
1190 /* following just in case virtual_gb changed */
1191 if (scsi_debug_virtual_gb > 0) {
1192 sdebug_capacity = 2048 * 1024;
1193 sdebug_capacity *= scsi_debug_virtual_gb;
1195 sdebug_capacity = sdebug_store_sectors;
1196 memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
1197 capac = sdebug_capacity - 1;
1198 for (k = 0; k < 8; ++k, capac >>= 8)
1199 arr[7 - k] = capac & 0xff;
1200 arr[8] = (SECT_SIZE_PER(target) >> 24) & 0xff;
1201 arr[9] = (SECT_SIZE_PER(target) >> 16) & 0xff;
1202 arr[10] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1203 arr[11] = SECT_SIZE_PER(target) & 0xff;
1204 return fill_from_dev_buffer(scp, arr,
1205 min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
1208 #define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
1210 static int resp_report_tgtpgs(struct scsi_cmnd * scp,
1211 struct sdebug_dev_info * devip)
1213 unsigned char *cmd = (unsigned char *)scp->cmnd;
1214 unsigned char * arr;
1215 int host_no = devip->sdbg_host->shost->host_no;
1216 int n, ret, alen, rlen;
1217 int port_group_a, port_group_b, port_a, port_b;
1219 alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8)
1222 arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
1224 return DID_REQUEUE << 16;
1226 * EVPD page 0x88 states we have two ports, one
1227 * real and a fake port with no device connected.
1228 * So we create two port groups with one port each
1229 * and set the group with port B to unavailable.
1231 port_a = 0x1; /* relative port A */
1232 port_b = 0x2; /* relative port B */
1233 port_group_a = (((host_no + 1) & 0x7f) << 8) +
1234 (devip->channel & 0x7f);
1235 port_group_b = (((host_no + 1) & 0x7f) << 8) +
1236 (devip->channel & 0x7f) + 0x80;
1239 * The asymmetric access state is cycled according to the host_id.
1242 if (0 == scsi_debug_vpd_use_hostno) {
1243 arr[n++] = host_no % 3; /* Asymm access state */
1244 arr[n++] = 0x0F; /* claim: all states are supported */
1246 arr[n++] = 0x0; /* Active/Optimized path */
1247 arr[n++] = 0x01; /* claim: only support active/optimized paths */
1249 arr[n++] = (port_group_a >> 8) & 0xff;
1250 arr[n++] = port_group_a & 0xff;
1251 arr[n++] = 0; /* Reserved */
1252 arr[n++] = 0; /* Status code */
1253 arr[n++] = 0; /* Vendor unique */
1254 arr[n++] = 0x1; /* One port per group */
1255 arr[n++] = 0; /* Reserved */
1256 arr[n++] = 0; /* Reserved */
1257 arr[n++] = (port_a >> 8) & 0xff;
1258 arr[n++] = port_a & 0xff;
1259 arr[n++] = 3; /* Port unavailable */
1260 arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
1261 arr[n++] = (port_group_b >> 8) & 0xff;
1262 arr[n++] = port_group_b & 0xff;
1263 arr[n++] = 0; /* Reserved */
1264 arr[n++] = 0; /* Status code */
1265 arr[n++] = 0; /* Vendor unique */
1266 arr[n++] = 0x1; /* One port per group */
1267 arr[n++] = 0; /* Reserved */
1268 arr[n++] = 0; /* Reserved */
1269 arr[n++] = (port_b >> 8) & 0xff;
1270 arr[n++] = port_b & 0xff;
1273 arr[0] = (rlen >> 24) & 0xff;
1274 arr[1] = (rlen >> 16) & 0xff;
1275 arr[2] = (rlen >> 8) & 0xff;
1276 arr[3] = rlen & 0xff;
1279 * Return the smallest value of either
1280 * - The allocated length
1281 * - The constructed command length
1282 * - The maximum array size
1285 ret = fill_from_dev_buffer(scp, arr,
1286 min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
1291 /* <<Following mode page info copied from ST318451LW>> */
1293 static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
1294 { /* Read-Write Error Recovery page for mode_sense */
1295 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
1298 memcpy(p, err_recov_pg, sizeof(err_recov_pg));
1300 memset(p + 2, 0, sizeof(err_recov_pg) - 2);
1301 return sizeof(err_recov_pg);
1304 static int resp_disconnect_pg(unsigned char * p, int pcontrol, int target)
1305 { /* Disconnect-Reconnect page for mode_sense */
1306 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
1307 0, 0, 0, 0, 0, 0, 0, 0};
1309 memcpy(p, disconnect_pg, sizeof(disconnect_pg));
1311 memset(p + 2, 0, sizeof(disconnect_pg) - 2);
1312 return sizeof(disconnect_pg);
1315 static int resp_format_pg(unsigned char * p, int pcontrol, int target)
1316 { /* Format device page for mode_sense */
1317 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
1318 0, 0, 0, 0, 0, 0, 0, 0,
1319 0, 0, 0, 0, 0x40, 0, 0, 0};
1321 memcpy(p, format_pg, sizeof(format_pg));
1322 p[10] = (sdebug_sectors_per >> 8) & 0xff;
1323 p[11] = sdebug_sectors_per & 0xff;
1324 p[12] = (SECT_SIZE >> 8) & 0xff;
1325 p[13] = SECT_SIZE & 0xff;
1326 if (DEV_REMOVEABLE(target))
1327 p[20] |= 0x20; /* should agree with INQUIRY */
1329 memset(p + 2, 0, sizeof(format_pg) - 2);
1330 return sizeof(format_pg);
1333 static int resp_caching_pg(unsigned char * p, int pcontrol, int target)
1334 { /* Caching page for mode_sense */
1335 unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1336 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
1338 memcpy(p, caching_pg, sizeof(caching_pg));
1340 memset(p + 2, 0, sizeof(caching_pg) - 2);
1341 return sizeof(caching_pg);
1344 static int resp_ctrl_m_pg(unsigned char * p, int pcontrol, int target)
1345 { /* Control mode page for mode_sense */
1346 unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
1348 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1351 if (scsi_debug_dsense)
1352 ctrl_m_pg[2] |= 0x4;
1354 ctrl_m_pg[2] &= ~0x4;
1355 memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
1357 memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
1358 else if (2 == pcontrol)
1359 memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
1360 return sizeof(ctrl_m_pg);
1364 static int resp_iec_m_pg(unsigned char * p, int pcontrol, int target)
1365 { /* Informational Exceptions control mode page for mode_sense */
1366 unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
1368 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1371 memcpy(p, iec_m_pg, sizeof(iec_m_pg));
1373 memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
1374 else if (2 == pcontrol)
1375 memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
1376 return sizeof(iec_m_pg);
1379 static int resp_sas_sf_m_pg(unsigned char * p, int pcontrol, int target)
1380 { /* SAS SSP mode page - short format for mode_sense */
1381 unsigned char sas_sf_m_pg[] = {0x19, 0x6,
1382 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
1384 memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
1386 memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
1387 return sizeof(sas_sf_m_pg);
1391 static int resp_sas_pcd_m_spg(unsigned char * p, int pcontrol, int target,
1393 { /* SAS phy control and discover mode page for mode_sense */
1394 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
1395 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
1396 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1397 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1398 0x2, 0, 0, 0, 0, 0, 0, 0,
1399 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1400 0, 0, 0, 0, 0, 0, 0, 0,
1401 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
1402 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1403 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1404 0x3, 0, 0, 0, 0, 0, 0, 0,
1405 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1406 0, 0, 0, 0, 0, 0, 0, 0,
1410 port_a = target_dev_id + 1;
1411 port_b = port_a + 1;
1412 memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
1413 p[20] = (port_a >> 24);
1414 p[21] = (port_a >> 16) & 0xff;
1415 p[22] = (port_a >> 8) & 0xff;
1416 p[23] = port_a & 0xff;
1417 p[48 + 20] = (port_b >> 24);
1418 p[48 + 21] = (port_b >> 16) & 0xff;
1419 p[48 + 22] = (port_b >> 8) & 0xff;
1420 p[48 + 23] = port_b & 0xff;
1422 memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
1423 return sizeof(sas_pcd_m_pg);
1426 static int resp_sas_sha_m_spg(unsigned char * p, int pcontrol)
1427 { /* SAS SSP shared protocol specific port mode subpage */
1428 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
1429 0, 0, 0, 0, 0, 0, 0, 0,
1432 memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
1434 memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
1435 return sizeof(sas_sha_m_pg);
1438 #define SDEBUG_MAX_MSENSE_SZ 256
1440 static int resp_mode_sense(struct scsi_cmnd * scp, int target,
1441 struct sdebug_dev_info * devip)
1443 unsigned char dbd, llbaa;
1444 int pcontrol, pcode, subpcode, bd_len;
1445 unsigned char dev_spec;
1446 int k, alloc_len, msense_6, offset, len, errsts, target_dev_id;
1448 unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
1449 unsigned char *cmd = (unsigned char *)scp->cmnd;
1451 if ((errsts = check_readiness(scp, 1, devip)))
1453 dbd = !!(cmd[1] & 0x8);
1454 pcontrol = (cmd[2] & 0xc0) >> 6;
1455 pcode = cmd[2] & 0x3f;
1457 msense_6 = (MODE_SENSE == cmd[0]);
1458 llbaa = msense_6 ? 0 : !!(cmd[1] & 0x10);
1459 if ((0 == scsi_debug_ptype) && (0 == dbd))
1460 bd_len = llbaa ? 16 : 8;
1463 alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]);
1464 memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
1465 if (0x3 == pcontrol) { /* Saving values not supported */
1466 mk_sense_buffer(devip, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP,
1468 return check_condition_result;
1470 target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
1471 (devip->target * 1000) - 3;
1472 /* set DPOFUA bit for disks */
1473 if (0 == scsi_debug_ptype)
1474 dev_spec = (DEV_READONLY(target) ? 0x80 : 0x0) | 0x10;
1484 arr[4] = 0x1; /* set LONGLBA bit */
1485 arr[7] = bd_len; /* assume 255 or less */
1489 if ((bd_len > 0) && (0 == sdebug_capacity)) {
1490 if (scsi_debug_virtual_gb > 0) {
1491 sdebug_capacity = 2048 * 1024;
1492 sdebug_capacity *= scsi_debug_virtual_gb;
1494 sdebug_capacity = sdebug_store_sectors;
1497 if (sdebug_capacity > 0xfffffffe) {
1503 ap[0] = (sdebug_capacity >> 24) & 0xff;
1504 ap[1] = (sdebug_capacity >> 16) & 0xff;
1505 ap[2] = (sdebug_capacity >> 8) & 0xff;
1506 ap[3] = sdebug_capacity & 0xff;
1508 ap[6] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1509 ap[7] = SECT_SIZE_PER(target) & 0xff;
1512 } else if (16 == bd_len) {
1513 unsigned long long capac = sdebug_capacity;
1515 for (k = 0; k < 8; ++k, capac >>= 8)
1516 ap[7 - k] = capac & 0xff;
1517 ap[12] = (SECT_SIZE_PER(target) >> 24) & 0xff;
1518 ap[13] = (SECT_SIZE_PER(target) >> 16) & 0xff;
1519 ap[14] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1520 ap[15] = SECT_SIZE_PER(target) & 0xff;
1525 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
1526 /* TODO: Control Extension page */
1527 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1529 return check_condition_result;
1532 case 0x1: /* Read-Write error recovery page, direct access */
1533 len = resp_err_recov_pg(ap, pcontrol, target);
1536 case 0x2: /* Disconnect-Reconnect page, all devices */
1537 len = resp_disconnect_pg(ap, pcontrol, target);
1540 case 0x3: /* Format device page, direct access */
1541 len = resp_format_pg(ap, pcontrol, target);
1544 case 0x8: /* Caching page, direct access */
1545 len = resp_caching_pg(ap, pcontrol, target);
1548 case 0xa: /* Control Mode page, all devices */
1549 len = resp_ctrl_m_pg(ap, pcontrol, target);
1552 case 0x19: /* if spc==1 then sas phy, control+discover */
1553 if ((subpcode > 0x2) && (subpcode < 0xff)) {
1554 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1555 INVALID_FIELD_IN_CDB, 0);
1556 return check_condition_result;
1559 if ((0x0 == subpcode) || (0xff == subpcode))
1560 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1561 if ((0x1 == subpcode) || (0xff == subpcode))
1562 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
1564 if ((0x2 == subpcode) || (0xff == subpcode))
1565 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1568 case 0x1c: /* Informational Exceptions Mode page, all devices */
1569 len = resp_iec_m_pg(ap, pcontrol, target);
1572 case 0x3f: /* Read all Mode pages */
1573 if ((0 == subpcode) || (0xff == subpcode)) {
1574 len = resp_err_recov_pg(ap, pcontrol, target);
1575 len += resp_disconnect_pg(ap + len, pcontrol, target);
1576 len += resp_format_pg(ap + len, pcontrol, target);
1577 len += resp_caching_pg(ap + len, pcontrol, target);
1578 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
1579 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1580 if (0xff == subpcode) {
1581 len += resp_sas_pcd_m_spg(ap + len, pcontrol,
1582 target, target_dev_id);
1583 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1585 len += resp_iec_m_pg(ap + len, pcontrol, target);
1587 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1588 INVALID_FIELD_IN_CDB, 0);
1589 return check_condition_result;
1594 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1596 return check_condition_result;
1599 arr[0] = offset - 1;
1601 arr[0] = ((offset - 2) >> 8) & 0xff;
1602 arr[1] = (offset - 2) & 0xff;
1604 return fill_from_dev_buffer(scp, arr, min(alloc_len, offset));
1607 #define SDEBUG_MAX_MSELECT_SZ 512
1609 static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
1610 struct sdebug_dev_info * devip)
1612 int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
1613 int param_len, res, errsts, mpage;
1614 unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
1615 unsigned char *cmd = (unsigned char *)scp->cmnd;
1617 if ((errsts = check_readiness(scp, 1, devip)))
1619 memset(arr, 0, sizeof(arr));
1622 param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]);
1623 if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
1624 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1625 INVALID_FIELD_IN_CDB, 0);
1626 return check_condition_result;
1628 res = fetch_to_dev_buffer(scp, arr, param_len);
1630 return (DID_ERROR << 16);
1631 else if ((res < param_len) &&
1632 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1633 printk(KERN_INFO "scsi_debug: mode_select: cdb indicated=%d, "
1634 " IO sent=%d bytes\n", param_len, res);
1635 md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2);
1636 bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]);
1638 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1639 INVALID_FIELD_IN_PARAM_LIST, 0);
1640 return check_condition_result;
1642 off = bd_len + (mselect6 ? 4 : 8);
1643 mpage = arr[off] & 0x3f;
1644 ps = !!(arr[off] & 0x80);
1646 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1647 INVALID_FIELD_IN_PARAM_LIST, 0);
1648 return check_condition_result;
1650 spf = !!(arr[off] & 0x40);
1651 pg_len = spf ? ((arr[off + 2] << 8) + arr[off + 3] + 4) :
1653 if ((pg_len + off) > param_len) {
1654 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1655 PARAMETER_LIST_LENGTH_ERR, 0);
1656 return check_condition_result;
1659 case 0xa: /* Control Mode page */
1660 if (ctrl_m_pg[1] == arr[off + 1]) {
1661 memcpy(ctrl_m_pg + 2, arr + off + 2,
1662 sizeof(ctrl_m_pg) - 2);
1663 scsi_debug_dsense = !!(ctrl_m_pg[2] & 0x4);
1667 case 0x1c: /* Informational Exceptions Mode page */
1668 if (iec_m_pg[1] == arr[off + 1]) {
1669 memcpy(iec_m_pg + 2, arr + off + 2,
1670 sizeof(iec_m_pg) - 2);
1677 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1678 INVALID_FIELD_IN_PARAM_LIST, 0);
1679 return check_condition_result;
1682 static int resp_temp_l_pg(unsigned char * arr)
1684 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
1685 0x0, 0x1, 0x3, 0x2, 0x0, 65,
1688 memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
1689 return sizeof(temp_l_pg);
1692 static int resp_ie_l_pg(unsigned char * arr)
1694 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
1697 memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
1698 if (iec_m_pg[2] & 0x4) { /* TEST bit set */
1699 arr[4] = THRESHOLD_EXCEEDED;
1702 return sizeof(ie_l_pg);
1705 #define SDEBUG_MAX_LSENSE_SZ 512
1707 static int resp_log_sense(struct scsi_cmnd * scp,
1708 struct sdebug_dev_info * devip)
1710 int ppc, sp, pcontrol, pcode, subpcode, alloc_len, errsts, len, n;
1711 unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
1712 unsigned char *cmd = (unsigned char *)scp->cmnd;
1714 if ((errsts = check_readiness(scp, 1, devip)))
1716 memset(arr, 0, sizeof(arr));
1720 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1721 INVALID_FIELD_IN_CDB, 0);
1722 return check_condition_result;
1724 pcontrol = (cmd[2] & 0xc0) >> 6;
1725 pcode = cmd[2] & 0x3f;
1726 subpcode = cmd[3] & 0xff;
1727 alloc_len = (cmd[7] << 8) + cmd[8];
1729 if (0 == subpcode) {
1731 case 0x0: /* Supported log pages log page */
1733 arr[n++] = 0x0; /* this page */
1734 arr[n++] = 0xd; /* Temperature */
1735 arr[n++] = 0x2f; /* Informational exceptions */
1738 case 0xd: /* Temperature log page */
1739 arr[3] = resp_temp_l_pg(arr + 4);
1741 case 0x2f: /* Informational exceptions log page */
1742 arr[3] = resp_ie_l_pg(arr + 4);
1745 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1746 INVALID_FIELD_IN_CDB, 0);
1747 return check_condition_result;
1749 } else if (0xff == subpcode) {
1753 case 0x0: /* Supported log pages and subpages log page */
1756 arr[n++] = 0x0; /* 0,0 page */
1758 arr[n++] = 0xff; /* this page */
1760 arr[n++] = 0x0; /* Temperature */
1762 arr[n++] = 0x0; /* Informational exceptions */
1765 case 0xd: /* Temperature subpages */
1768 arr[n++] = 0x0; /* Temperature */
1771 case 0x2f: /* Informational exceptions subpages */
1774 arr[n++] = 0x0; /* Informational exceptions */
1778 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1779 INVALID_FIELD_IN_CDB, 0);
1780 return check_condition_result;
1783 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1784 INVALID_FIELD_IN_CDB, 0);
1785 return check_condition_result;
1787 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
1788 return fill_from_dev_buffer(scp, arr,
1789 min(len, SDEBUG_MAX_INQ_ARR_SZ));
1792 static int resp_read(struct scsi_cmnd * SCpnt, unsigned long long lba,
1793 unsigned int num, struct sdebug_dev_info * devip)
1795 unsigned long iflags;
1796 unsigned int block, from_bottom;
1797 unsigned long long u;
1800 if (lba + num > sdebug_capacity) {
1801 mk_sense_buffer(devip, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE,
1803 return check_condition_result;
1805 /* transfer length excessive (tie in to block limits VPD page) */
1806 if (num > sdebug_store_sectors) {
1807 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1809 return check_condition_result;
1811 if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) &&
1812 (lba <= OPT_MEDIUM_ERR_ADDR) &&
1813 ((lba + num) > OPT_MEDIUM_ERR_ADDR)) {
1814 /* claim unrecoverable read error */
1815 mk_sense_buffer(devip, MEDIUM_ERROR, UNRECOVERED_READ_ERR,
1817 /* set info field and valid bit for fixed descriptor */
1818 if (0x70 == (devip->sense_buff[0] & 0x7f)) {
1819 devip->sense_buff[0] |= 0x80; /* Valid bit */
1820 ret = OPT_MEDIUM_ERR_ADDR;
1821 devip->sense_buff[3] = (ret >> 24) & 0xff;
1822 devip->sense_buff[4] = (ret >> 16) & 0xff;
1823 devip->sense_buff[5] = (ret >> 8) & 0xff;
1824 devip->sense_buff[6] = ret & 0xff;
1826 return check_condition_result;
1828 read_lock_irqsave(&atomic_rw, iflags);
1829 if ((lba + num) <= sdebug_store_sectors)
1830 ret = fill_from_dev_buffer(SCpnt,
1831 fake_storep + (lba * SECT_SIZE),
1834 /* modulo when one arg is 64 bits needs do_div() */
1836 block = do_div(u, sdebug_store_sectors);
1838 if ((block + num) > sdebug_store_sectors)
1839 from_bottom = (block + num) - sdebug_store_sectors;
1840 ret = fill_from_dev_buffer(SCpnt,
1841 fake_storep + (block * SECT_SIZE),
1842 (num - from_bottom) * SECT_SIZE);
1843 if ((0 == ret) && (from_bottom > 0))
1844 ret = fill_from_dev_buffer(SCpnt, fake_storep,
1845 from_bottom * SECT_SIZE);
1847 read_unlock_irqrestore(&atomic_rw, iflags);
1851 static int resp_write(struct scsi_cmnd * SCpnt, unsigned long long lba,
1852 unsigned int num, struct sdebug_dev_info * devip)
1854 unsigned long iflags;
1855 unsigned int block, to_bottom;
1856 unsigned long long u;
1859 if (lba + num > sdebug_capacity) {
1860 mk_sense_buffer(devip, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE,
1862 return check_condition_result;
1864 /* transfer length excessive (tie in to block limits VPD page) */
1865 if (num > sdebug_store_sectors) {
1866 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1868 return check_condition_result;
1871 write_lock_irqsave(&atomic_rw, iflags);
1872 if ((lba + num) <= sdebug_store_sectors)
1873 res = fetch_to_dev_buffer(SCpnt,
1874 fake_storep + (lba * SECT_SIZE),
1877 /* modulo when one arg is 64 bits needs do_div() */
1879 block = do_div(u, sdebug_store_sectors);
1881 if ((block + num) > sdebug_store_sectors)
1882 to_bottom = (block + num) - sdebug_store_sectors;
1883 res = fetch_to_dev_buffer(SCpnt,
1884 fake_storep + (block * SECT_SIZE),
1885 (num - to_bottom) * SECT_SIZE);
1886 if ((0 == res) && (to_bottom > 0))
1887 res = fetch_to_dev_buffer(SCpnt, fake_storep,
1888 to_bottom * SECT_SIZE);
1890 write_unlock_irqrestore(&atomic_rw, iflags);
1892 return (DID_ERROR << 16);
1893 else if ((res < (num * SECT_SIZE)) &&
1894 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1895 printk(KERN_INFO "scsi_debug: write: cdb indicated=%u, "
1896 " IO sent=%d bytes\n", num * SECT_SIZE, res);
1900 #define SDEBUG_RLUN_ARR_SZ 256
1902 static int resp_report_luns(struct scsi_cmnd * scp,
1903 struct sdebug_dev_info * devip)
1905 unsigned int alloc_len;
1906 int lun_cnt, i, upper, num, n, wlun, lun;
1907 unsigned char *cmd = (unsigned char *)scp->cmnd;
1908 int select_report = (int)cmd[2];
1909 struct scsi_lun *one_lun;
1910 unsigned char arr[SDEBUG_RLUN_ARR_SZ];
1911 unsigned char * max_addr;
1913 alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
1914 if ((alloc_len < 4) || (select_report > 2)) {
1915 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1917 return check_condition_result;
1919 /* can produce response with up to 16k luns (lun 0 to lun 16383) */
1920 memset(arr, 0, SDEBUG_RLUN_ARR_SZ);
1921 lun_cnt = scsi_debug_max_luns;
1922 if (1 == select_report)
1924 else if (scsi_debug_no_lun_0 && (lun_cnt > 0))
1926 wlun = (select_report > 0) ? 1 : 0;
1927 num = lun_cnt + wlun;
1928 arr[2] = ((sizeof(struct scsi_lun) * num) >> 8) & 0xff;
1929 arr[3] = (sizeof(struct scsi_lun) * num) & 0xff;
1930 n = min((int)((SDEBUG_RLUN_ARR_SZ - 8) /
1931 sizeof(struct scsi_lun)), num);
1936 one_lun = (struct scsi_lun *) &arr[8];
1937 max_addr = arr + SDEBUG_RLUN_ARR_SZ;
1938 for (i = 0, lun = (scsi_debug_no_lun_0 ? 1 : 0);
1939 ((i < lun_cnt) && ((unsigned char *)(one_lun + i) < max_addr));
1941 upper = (lun >> 8) & 0x3f;
1943 one_lun[i].scsi_lun[0] =
1944 (upper | (SAM2_LUN_ADDRESS_METHOD << 6));
1945 one_lun[i].scsi_lun[1] = lun & 0xff;
1948 one_lun[i].scsi_lun[0] = (SAM2_WLUN_REPORT_LUNS >> 8) & 0xff;
1949 one_lun[i].scsi_lun[1] = SAM2_WLUN_REPORT_LUNS & 0xff;
1952 alloc_len = (unsigned char *)(one_lun + i) - arr;
1953 return fill_from_dev_buffer(scp, arr,
1954 min((int)alloc_len, SDEBUG_RLUN_ARR_SZ));
1957 static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
1958 unsigned int num, struct sdebug_dev_info *devip)
1961 unsigned char *kaddr, *buf;
1962 unsigned int offset;
1963 struct scatterlist *sg;
1964 struct scsi_data_buffer *sdb = scsi_in(scp);
1966 /* better not to use temporary buffer. */
1967 buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
1972 scsi_for_each_sg(scp, sg, scsi_sg_count(scp), i) {
1973 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
1977 memcpy(buf + offset, kaddr + sg->offset, sg->length);
1978 offset += sg->length;
1979 kunmap_atomic(kaddr, KM_USER0);
1983 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, i) {
1984 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
1988 for (j = 0; j < sg->length; j++)
1989 *(kaddr + sg->offset + j) ^= *(buf + offset + j);
1991 offset += sg->length;
1992 kunmap_atomic(kaddr, KM_USER0);
2001 /* When timer goes off this function is called. */
2002 static void timer_intr_handler(unsigned long indx)
2004 struct sdebug_queued_cmd * sqcp;
2005 unsigned long iflags;
2007 if (indx >= SCSI_DEBUG_CANQUEUE) {
2008 printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too "
2012 spin_lock_irqsave(&queued_arr_lock, iflags);
2013 sqcp = &queued_arr[(int)indx];
2014 if (! sqcp->in_use) {
2015 printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected "
2017 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2021 if (sqcp->done_funct) {
2022 sqcp->a_cmnd->result = sqcp->scsi_result;
2023 sqcp->done_funct(sqcp->a_cmnd); /* callback to mid level */
2025 sqcp->done_funct = NULL;
2026 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2029 static int scsi_debug_slave_alloc(struct scsi_device * sdp)
2031 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2032 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
2033 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2034 set_bit(QUEUE_FLAG_BIDI, &sdp->request_queue->queue_flags);
2038 static int scsi_debug_slave_configure(struct scsi_device * sdp)
2040 struct sdebug_dev_info * devip;
2042 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2043 printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n",
2044 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2045 if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN)
2046 sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN;
2047 devip = devInfoReg(sdp);
2049 return 1; /* no resources, will be marked offline */
2050 sdp->hostdata = devip;
2051 if (sdp->host->cmd_per_lun)
2052 scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING,
2053 sdp->host->cmd_per_lun);
2054 blk_queue_max_segment_size(sdp->request_queue, 256 * 1024);
2058 static void scsi_debug_slave_destroy(struct scsi_device * sdp)
2060 struct sdebug_dev_info * devip =
2061 (struct sdebug_dev_info *)sdp->hostdata;
2063 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2064 printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n",
2065 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2067 /* make this slot avaliable for re-use */
2069 sdp->hostdata = NULL;
2073 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
2075 struct sdebug_host_info * sdbg_host;
2076 struct sdebug_dev_info * open_devip = NULL;
2077 struct sdebug_dev_info * devip =
2078 (struct sdebug_dev_info *)sdev->hostdata;
2082 sdbg_host = *(struct sdebug_host_info **) sdev->host->hostdata;
2084 printk(KERN_ERR "Host info NULL\n");
2087 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
2088 if ((devip->used) && (devip->channel == sdev->channel) &&
2089 (devip->target == sdev->id) &&
2090 (devip->lun == sdev->lun))
2093 if ((!devip->used) && (!open_devip))
2097 if (NULL == open_devip) { /* try and make a new one */
2098 open_devip = kzalloc(sizeof(*open_devip),GFP_ATOMIC);
2099 if (NULL == open_devip) {
2100 printk(KERN_ERR "%s: out of memory at line %d\n",
2101 __FUNCTION__, __LINE__);
2104 open_devip->sdbg_host = sdbg_host;
2105 list_add_tail(&open_devip->dev_list,
2106 &sdbg_host->dev_info_list);
2109 open_devip->channel = sdev->channel;
2110 open_devip->target = sdev->id;
2111 open_devip->lun = sdev->lun;
2112 open_devip->sdbg_host = sdbg_host;
2113 open_devip->reset = 1;
2114 open_devip->used = 1;
2115 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
2116 if (scsi_debug_dsense)
2117 open_devip->sense_buff[0] = 0x72;
2119 open_devip->sense_buff[0] = 0x70;
2120 open_devip->sense_buff[7] = 0xa;
2122 if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
2123 open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
2129 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
2132 unsigned char * sbuff;
2134 sbuff = devip->sense_buff;
2135 memset(sbuff, 0, SDEBUG_SENSE_LEN);
2136 if (scsi_debug_dsense) {
2137 sbuff[0] = 0x72; /* descriptor, current */
2142 sbuff[0] = 0x70; /* fixed, current */
2144 sbuff[7] = 0xa; /* implies 18 byte sense buffer */
2148 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2149 printk(KERN_INFO "scsi_debug: [sense_key,asc,ascq]: "
2150 "[0x%x,0x%x,0x%x]\n", key, asc, asq);
2153 static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
2155 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2156 printk(KERN_INFO "scsi_debug: abort\n");
2158 stop_queued_cmnd(SCpnt);
2162 static int scsi_debug_biosparam(struct scsi_device *sdev,
2163 struct block_device * bdev, sector_t capacity, int *info)
2168 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2169 printk(KERN_INFO "scsi_debug: biosparam\n");
2170 buf = scsi_bios_ptable(bdev);
2172 res = scsi_partsize(buf, capacity,
2173 &info[2], &info[0], &info[1]);
2178 info[0] = sdebug_heads;
2179 info[1] = sdebug_sectors_per;
2180 info[2] = sdebug_cylinders_per;
2184 static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
2186 struct sdebug_dev_info * devip;
2188 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2189 printk(KERN_INFO "scsi_debug: device_reset\n");
2192 devip = devInfoReg(SCpnt->device);
2199 static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
2201 struct sdebug_host_info *sdbg_host;
2202 struct sdebug_dev_info * dev_info;
2203 struct scsi_device * sdp;
2204 struct Scsi_Host * hp;
2206 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2207 printk(KERN_INFO "scsi_debug: bus_reset\n");
2209 if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
2210 sdbg_host = *(struct sdebug_host_info **) hp->hostdata;
2212 list_for_each_entry(dev_info,
2213 &sdbg_host->dev_info_list,
2215 dev_info->reset = 1;
2221 static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
2223 struct sdebug_host_info * sdbg_host;
2224 struct sdebug_dev_info * dev_info;
2226 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2227 printk(KERN_INFO "scsi_debug: host_reset\n");
2229 spin_lock(&sdebug_host_list_lock);
2230 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
2231 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
2233 dev_info->reset = 1;
2235 spin_unlock(&sdebug_host_list_lock);
2240 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
2241 static int stop_queued_cmnd(struct scsi_cmnd * cmnd)
2243 unsigned long iflags;
2245 struct sdebug_queued_cmd * sqcp;
2247 spin_lock_irqsave(&queued_arr_lock, iflags);
2248 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2249 sqcp = &queued_arr[k];
2250 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
2251 del_timer_sync(&sqcp->cmnd_timer);
2253 sqcp->a_cmnd = NULL;
2257 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2258 return (k < SCSI_DEBUG_CANQUEUE) ? 1 : 0;
2261 /* Deletes (stops) timers of all queued commands */
2262 static void stop_all_queued(void)
2264 unsigned long iflags;
2266 struct sdebug_queued_cmd * sqcp;
2268 spin_lock_irqsave(&queued_arr_lock, iflags);
2269 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2270 sqcp = &queued_arr[k];
2271 if (sqcp->in_use && sqcp->a_cmnd) {
2272 del_timer_sync(&sqcp->cmnd_timer);
2274 sqcp->a_cmnd = NULL;
2277 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2280 /* Initializes timers in queued array */
2281 static void __init init_all_queued(void)
2283 unsigned long iflags;
2285 struct sdebug_queued_cmd * sqcp;
2287 spin_lock_irqsave(&queued_arr_lock, iflags);
2288 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2289 sqcp = &queued_arr[k];
2290 init_timer(&sqcp->cmnd_timer);
2292 sqcp->a_cmnd = NULL;
2294 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2297 static void __init sdebug_build_parts(unsigned char * ramp)
2299 struct partition * pp;
2300 int starts[SDEBUG_MAX_PARTS + 2];
2301 int sectors_per_part, num_sectors, k;
2302 int heads_by_sects, start_sec, end_sec;
2304 /* assume partition table already zeroed */
2305 if ((scsi_debug_num_parts < 1) || (sdebug_store_size < 1048576))
2307 if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
2308 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
2309 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
2310 "partitions to %d\n", SDEBUG_MAX_PARTS);
2312 num_sectors = (int)sdebug_store_sectors;
2313 sectors_per_part = (num_sectors - sdebug_sectors_per)
2314 / scsi_debug_num_parts;
2315 heads_by_sects = sdebug_heads * sdebug_sectors_per;
2316 starts[0] = sdebug_sectors_per;
2317 for (k = 1; k < scsi_debug_num_parts; ++k)
2318 starts[k] = ((k * sectors_per_part) / heads_by_sects)
2320 starts[scsi_debug_num_parts] = num_sectors;
2321 starts[scsi_debug_num_parts + 1] = 0;
2323 ramp[510] = 0x55; /* magic partition markings */
2325 pp = (struct partition *)(ramp + 0x1be);
2326 for (k = 0; starts[k + 1]; ++k, ++pp) {
2327 start_sec = starts[k];
2328 end_sec = starts[k + 1] - 1;
2331 pp->cyl = start_sec / heads_by_sects;
2332 pp->head = (start_sec - (pp->cyl * heads_by_sects))
2333 / sdebug_sectors_per;
2334 pp->sector = (start_sec % sdebug_sectors_per) + 1;
2336 pp->end_cyl = end_sec / heads_by_sects;
2337 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
2338 / sdebug_sectors_per;
2339 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2341 pp->start_sect = start_sec;
2342 pp->nr_sects = end_sec - start_sec + 1;
2343 pp->sys_ind = 0x83; /* plain Linux partition */
2347 static int schedule_resp(struct scsi_cmnd * cmnd,
2348 struct sdebug_dev_info * devip,
2349 done_funct_t done, int scsi_result, int delta_jiff)
2351 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
2353 struct scsi_device * sdp = cmnd->device;
2355 printk(KERN_INFO "scsi_debug: <%u %u %u %u> "
2356 "non-zero result=0x%x\n", sdp->host->host_no,
2357 sdp->channel, sdp->id, sdp->lun, scsi_result);
2360 if (cmnd && devip) {
2361 /* simulate autosense by this driver */
2362 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
2363 memcpy(cmnd->sense_buffer, devip->sense_buff,
2364 (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
2365 SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
2367 if (delta_jiff <= 0) {
2369 cmnd->result = scsi_result;
2374 unsigned long iflags;
2376 struct sdebug_queued_cmd * sqcp = NULL;
2378 spin_lock_irqsave(&queued_arr_lock, iflags);
2379 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2380 sqcp = &queued_arr[k];
2384 if (k >= SCSI_DEBUG_CANQUEUE) {
2385 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2386 printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
2387 return 1; /* report busy to mid level */
2390 sqcp->a_cmnd = cmnd;
2391 sqcp->scsi_result = scsi_result;
2392 sqcp->done_funct = done;
2393 sqcp->cmnd_timer.function = timer_intr_handler;
2394 sqcp->cmnd_timer.data = k;
2395 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
2396 add_timer(&sqcp->cmnd_timer);
2397 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2404 /* Note: The following macros create attribute files in the
2405 /sys/module/scsi_debug/parameters directory. Unfortunately this
2406 driver is unaware of a change and cannot trigger auxiliary actions
2407 as it can when the corresponding attribute in the
2408 /sys/bus/pseudo/drivers/scsi_debug directory is changed.
2410 module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
2411 module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
2412 module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
2413 module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
2414 module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
2415 module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
2416 module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
2417 module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
2418 module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
2419 module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
2420 module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
2421 module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
2422 module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
2423 module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
2424 module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
2427 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2428 MODULE_DESCRIPTION("SCSI debug adapter driver");
2429 MODULE_LICENSE("GPL");
2430 MODULE_VERSION(SCSI_DEBUG_VERSION);
2432 MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
2433 MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
2434 MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
2435 MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
2436 MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
2437 MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
2438 MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
2439 MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
2440 MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
2441 MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
2442 MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
2443 MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
2444 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
2445 MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
2446 MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2449 static char sdebug_info[256];
2451 static const char * scsi_debug_info(struct Scsi_Host * shp)
2453 sprintf(sdebug_info, "scsi_debug, version %s [%s], "
2454 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
2455 scsi_debug_version_date, scsi_debug_dev_size_mb,
2460 /* scsi_debug_proc_info
2461 * Used if the driver currently has no own support for /proc/scsi
2463 static int scsi_debug_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
2464 int length, int inout)
2466 int len, pos, begin;
2469 orig_length = length;
2473 int minLen = length > 15 ? 15 : length;
2475 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2477 memcpy(arr, buffer, minLen);
2479 if (1 != sscanf(arr, "%d", &pos))
2481 scsi_debug_opts = pos;
2482 if (scsi_debug_every_nth != 0)
2483 scsi_debug_cmnd_count = 0;
2487 pos = len = sprintf(buffer, "scsi_debug adapter driver, version "
2489 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2490 "every_nth=%d(curr:%d)\n"
2491 "delay=%d, max_luns=%d, scsi_level=%d\n"
2492 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2493 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2495 SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
2496 scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2497 scsi_debug_cmnd_count, scsi_debug_delay,
2498 scsi_debug_max_luns, scsi_debug_scsi_level,
2499 SECT_SIZE, sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
2500 num_aborts, num_dev_resets, num_bus_resets, num_host_resets);
2505 *start = buffer + (offset - begin); /* Start of wanted data */
2506 len -= (offset - begin);
2512 static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf)
2514 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
2517 static ssize_t sdebug_delay_store(struct device_driver * ddp,
2518 const char * buf, size_t count)
2523 if (1 == sscanf(buf, "%10s", work)) {
2524 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
2525 scsi_debug_delay = delay;
2531 DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show,
2532 sdebug_delay_store);
2534 static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf)
2536 return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
2539 static ssize_t sdebug_opts_store(struct device_driver * ddp,
2540 const char * buf, size_t count)
2545 if (1 == sscanf(buf, "%10s", work)) {
2546 if (0 == strnicmp(work,"0x", 2)) {
2547 if (1 == sscanf(&work[2], "%x", &opts))
2550 if (1 == sscanf(work, "%d", &opts))
2556 scsi_debug_opts = opts;
2557 scsi_debug_cmnd_count = 0;
2560 DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show,
2563 static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf)
2565 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
2567 static ssize_t sdebug_ptype_store(struct device_driver * ddp,
2568 const char * buf, size_t count)
2572 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2573 scsi_debug_ptype = n;
2578 DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store);
2580 static ssize_t sdebug_dsense_show(struct device_driver * ddp, char * buf)
2582 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
2584 static ssize_t sdebug_dsense_store(struct device_driver * ddp,
2585 const char * buf, size_t count)
2589 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2590 scsi_debug_dsense = n;
2595 DRIVER_ATTR(dsense, S_IRUGO | S_IWUSR, sdebug_dsense_show,
2596 sdebug_dsense_store);
2598 static ssize_t sdebug_fake_rw_show(struct device_driver * ddp, char * buf)
2600 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
2602 static ssize_t sdebug_fake_rw_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_fake_rw = n;
2613 DRIVER_ATTR(fake_rw, S_IRUGO | S_IWUSR, sdebug_fake_rw_show,
2614 sdebug_fake_rw_store);
2616 static ssize_t sdebug_no_lun_0_show(struct device_driver * ddp, char * buf)
2618 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
2620 static ssize_t sdebug_no_lun_0_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_no_lun_0 = n;
2631 DRIVER_ATTR(no_lun_0, S_IRUGO | S_IWUSR, sdebug_no_lun_0_show,
2632 sdebug_no_lun_0_store);
2634 static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf)
2636 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
2638 static ssize_t sdebug_num_tgts_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_num_tgts = n;
2645 sdebug_max_tgts_luns();
2650 DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show,
2651 sdebug_num_tgts_store);
2653 static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf)
2655 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
2657 DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL);
2659 static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf)
2661 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
2663 DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL);
2665 static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf)
2667 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
2669 static ssize_t sdebug_every_nth_store(struct device_driver * ddp,
2670 const char * buf, size_t count)
2674 if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
2675 scsi_debug_every_nth = nth;
2676 scsi_debug_cmnd_count = 0;
2681 DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show,
2682 sdebug_every_nth_store);
2684 static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf)
2686 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
2688 static ssize_t sdebug_max_luns_store(struct device_driver * ddp,
2689 const char * buf, size_t count)
2693 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2694 scsi_debug_max_luns = n;
2695 sdebug_max_tgts_luns();
2700 DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show,
2701 sdebug_max_luns_store);
2703 static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf)
2705 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
2707 DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL);
2709 static ssize_t sdebug_virtual_gb_show(struct device_driver * ddp, char * buf)
2711 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
2713 static ssize_t sdebug_virtual_gb_store(struct device_driver * ddp,
2714 const char * buf, size_t count)
2718 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2719 scsi_debug_virtual_gb = n;
2720 if (scsi_debug_virtual_gb > 0) {
2721 sdebug_capacity = 2048 * 1024;
2722 sdebug_capacity *= scsi_debug_virtual_gb;
2724 sdebug_capacity = sdebug_store_sectors;
2729 DRIVER_ATTR(virtual_gb, S_IRUGO | S_IWUSR, sdebug_virtual_gb_show,
2730 sdebug_virtual_gb_store);
2732 static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf)
2734 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
2737 static ssize_t sdebug_add_host_store(struct device_driver * ddp,
2738 const char * buf, size_t count)
2743 if (1 != sscanf(buf, "%10s", work))
2745 { /* temporary hack around sscanf() problem with -ve nums */
2750 if (1 != sscanf(work + neg, "%d", &delta_hosts))
2753 delta_hosts = -delta_hosts;
2755 if (delta_hosts > 0) {
2757 sdebug_add_adapter();
2758 } while (--delta_hosts);
2759 } else if (delta_hosts < 0) {
2761 sdebug_remove_adapter();
2762 } while (++delta_hosts);
2766 DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show,
2767 sdebug_add_host_store);
2769 static ssize_t sdebug_vpd_use_hostno_show(struct device_driver * ddp,
2772 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
2774 static ssize_t sdebug_vpd_use_hostno_store(struct device_driver * ddp,
2775 const char * buf, size_t count)
2779 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2780 scsi_debug_vpd_use_hostno = n;
2785 DRIVER_ATTR(vpd_use_hostno, S_IRUGO | S_IWUSR, sdebug_vpd_use_hostno_show,
2786 sdebug_vpd_use_hostno_store);
2788 /* Note: The following function creates attribute files in the
2789 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
2790 files (over those found in the /sys/module/scsi_debug/parameters
2791 directory) is that auxiliary actions can be triggered when an attribute
2792 is changed. For example see: sdebug_add_host_store() above.
2794 static int do_create_driverfs_files(void)
2798 ret = driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2799 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay);
2800 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2801 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2802 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2803 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2804 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2805 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2806 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2807 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2808 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2809 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts);
2810 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2811 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2812 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2816 static void do_remove_driverfs_files(void)
2818 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2819 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2820 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2821 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts);
2822 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2823 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2824 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2825 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2826 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2827 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2828 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2829 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2830 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2831 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay);
2832 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2835 static int __init scsi_debug_init(void)
2842 if (scsi_debug_dev_size_mb < 1)
2843 scsi_debug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */
2844 sdebug_store_size = (unsigned int)scsi_debug_dev_size_mb * 1048576;
2845 sdebug_store_sectors = sdebug_store_size / SECT_SIZE;
2846 if (scsi_debug_virtual_gb > 0) {
2847 sdebug_capacity = 2048 * 1024;
2848 sdebug_capacity *= scsi_debug_virtual_gb;
2850 sdebug_capacity = sdebug_store_sectors;
2852 /* play around with geometry, don't waste too much on track 0 */
2854 sdebug_sectors_per = 32;
2855 if (scsi_debug_dev_size_mb >= 16)
2857 else if (scsi_debug_dev_size_mb >= 256)
2859 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2860 (sdebug_sectors_per * sdebug_heads);
2861 if (sdebug_cylinders_per >= 1024) {
2862 /* other LLDs do this; implies >= 1GB ram disk ... */
2864 sdebug_sectors_per = 63;
2865 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2866 (sdebug_sectors_per * sdebug_heads);
2869 sz = sdebug_store_size;
2870 fake_storep = vmalloc(sz);
2871 if (NULL == fake_storep) {
2872 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
2875 memset(fake_storep, 0, sz);
2876 if (scsi_debug_num_parts > 0)
2877 sdebug_build_parts(fake_storep);
2879 ret = device_register(&pseudo_primary);
2881 printk(KERN_WARNING "scsi_debug: device_register error: %d\n",
2885 ret = bus_register(&pseudo_lld_bus);
2887 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
2891 ret = driver_register(&sdebug_driverfs_driver);
2893 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
2897 ret = do_create_driverfs_files();
2899 printk(KERN_WARNING "scsi_debug: driver_create_file error: %d\n",
2906 host_to_add = scsi_debug_add_host;
2907 scsi_debug_add_host = 0;
2909 for (k = 0; k < host_to_add; k++) {
2910 if (sdebug_add_adapter()) {
2911 printk(KERN_ERR "scsi_debug_init: "
2912 "sdebug_add_adapter failed k=%d\n", k);
2917 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
2918 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
2919 scsi_debug_add_host);
2924 do_remove_driverfs_files();
2925 driver_unregister(&sdebug_driverfs_driver);
2927 bus_unregister(&pseudo_lld_bus);
2929 device_unregister(&pseudo_primary);
2936 static void __exit scsi_debug_exit(void)
2938 int k = scsi_debug_add_host;
2942 sdebug_remove_adapter();
2943 do_remove_driverfs_files();
2944 driver_unregister(&sdebug_driverfs_driver);
2945 bus_unregister(&pseudo_lld_bus);
2946 device_unregister(&pseudo_primary);
2951 device_initcall(scsi_debug_init);
2952 module_exit(scsi_debug_exit);
2954 static void pseudo_0_release(struct device * dev)
2956 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2957 printk(KERN_INFO "scsi_debug: pseudo_0_release() called\n");
2960 static struct device pseudo_primary = {
2961 .bus_id = "pseudo_0",
2962 .release = pseudo_0_release,
2965 static int pseudo_lld_bus_match(struct device *dev,
2966 struct device_driver *dev_driver)
2971 static struct bus_type pseudo_lld_bus = {
2973 .match = pseudo_lld_bus_match,
2974 .probe = sdebug_driver_probe,
2975 .remove = sdebug_driver_remove,
2978 static void sdebug_release_adapter(struct device * dev)
2980 struct sdebug_host_info *sdbg_host;
2982 sdbg_host = to_sdebug_host(dev);
2986 static int sdebug_add_adapter(void)
2988 int k, devs_per_host;
2990 struct sdebug_host_info *sdbg_host;
2991 struct sdebug_dev_info *sdbg_devinfo;
2992 struct list_head *lh, *lh_sf;
2994 sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
2995 if (NULL == sdbg_host) {
2996 printk(KERN_ERR "%s: out of memory at line %d\n",
2997 __FUNCTION__, __LINE__);
3001 INIT_LIST_HEAD(&sdbg_host->dev_info_list);
3003 devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
3004 for (k = 0; k < devs_per_host; k++) {
3005 sdbg_devinfo = kzalloc(sizeof(*sdbg_devinfo),GFP_KERNEL);
3006 if (NULL == sdbg_devinfo) {
3007 printk(KERN_ERR "%s: out of memory at line %d\n",
3008 __FUNCTION__, __LINE__);
3012 sdbg_devinfo->sdbg_host = sdbg_host;
3013 list_add_tail(&sdbg_devinfo->dev_list,
3014 &sdbg_host->dev_info_list);
3017 spin_lock(&sdebug_host_list_lock);
3018 list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
3019 spin_unlock(&sdebug_host_list_lock);
3021 sdbg_host->dev.bus = &pseudo_lld_bus;
3022 sdbg_host->dev.parent = &pseudo_primary;
3023 sdbg_host->dev.release = &sdebug_release_adapter;
3024 sprintf(sdbg_host->dev.bus_id, "adapter%d", scsi_debug_add_host);
3026 error = device_register(&sdbg_host->dev);
3031 ++scsi_debug_add_host;
3035 list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
3036 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
3038 list_del(&sdbg_devinfo->dev_list);
3039 kfree(sdbg_devinfo);
3046 static void sdebug_remove_adapter(void)
3048 struct sdebug_host_info * sdbg_host = NULL;
3050 spin_lock(&sdebug_host_list_lock);
3051 if (!list_empty(&sdebug_host_list)) {
3052 sdbg_host = list_entry(sdebug_host_list.prev,
3053 struct sdebug_host_info, host_list);
3054 list_del(&sdbg_host->host_list);
3056 spin_unlock(&sdebug_host_list_lock);
3061 device_unregister(&sdbg_host->dev);
3062 --scsi_debug_add_host;
3065 static struct scsi_host_template sdebug_driver_template = {
3066 .proc_info = scsi_debug_proc_info,
3067 .proc_name = sdebug_proc_name,
3068 .name = "SCSI DEBUG",
3069 .info = scsi_debug_info,
3070 .slave_alloc = scsi_debug_slave_alloc,
3071 .slave_configure = scsi_debug_slave_configure,
3072 .slave_destroy = scsi_debug_slave_destroy,
3073 .ioctl = scsi_debug_ioctl,
3074 .queuecommand = scsi_debug_queuecommand,
3075 .eh_abort_handler = scsi_debug_abort,
3076 .eh_bus_reset_handler = scsi_debug_bus_reset,
3077 .eh_device_reset_handler = scsi_debug_device_reset,
3078 .eh_host_reset_handler = scsi_debug_host_reset,
3079 .bios_param = scsi_debug_biosparam,
3080 .can_queue = SCSI_DEBUG_CANQUEUE,
3082 .sg_tablesize = 256,
3084 .max_sectors = 0xffff,
3085 .use_clustering = DISABLE_CLUSTERING,
3086 .module = THIS_MODULE,
3089 static int sdebug_driver_probe(struct device * dev)
3092 struct sdebug_host_info *sdbg_host;
3093 struct Scsi_Host *hpnt;
3095 sdbg_host = to_sdebug_host(dev);
3097 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
3099 printk(KERN_ERR "%s: scsi_register failed\n", __FUNCTION__);
3104 sdbg_host->shost = hpnt;
3105 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
3106 if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
3107 hpnt->max_id = scsi_debug_num_tgts + 1;
3109 hpnt->max_id = scsi_debug_num_tgts;
3110 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* = scsi_debug_max_luns; */
3112 error = scsi_add_host(hpnt, &sdbg_host->dev);
3114 printk(KERN_ERR "%s: scsi_add_host failed\n", __FUNCTION__);
3116 scsi_host_put(hpnt);
3118 scsi_scan_host(hpnt);
3124 static int sdebug_driver_remove(struct device * dev)
3126 struct list_head *lh, *lh_sf;
3127 struct sdebug_host_info *sdbg_host;
3128 struct sdebug_dev_info *sdbg_devinfo;
3130 sdbg_host = to_sdebug_host(dev);
3133 printk(KERN_ERR "%s: Unable to locate host info\n",
3138 scsi_remove_host(sdbg_host->shost);
3140 list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
3141 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
3143 list_del(&sdbg_devinfo->dev_list);
3144 kfree(sdbg_devinfo);
3147 scsi_host_put(sdbg_host->shost);
3151 static void sdebug_max_tgts_luns(void)
3153 struct sdebug_host_info * sdbg_host;
3154 struct Scsi_Host *hpnt;
3156 spin_lock(&sdebug_host_list_lock);
3157 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
3158 hpnt = sdbg_host->shost;
3159 if ((hpnt->this_id >= 0) &&
3160 (scsi_debug_num_tgts > hpnt->this_id))
3161 hpnt->max_id = scsi_debug_num_tgts + 1;
3163 hpnt->max_id = scsi_debug_num_tgts;
3164 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* scsi_debug_max_luns; */
3166 spin_unlock(&sdebug_host_list_lock);