2 * linux/kernel/scsi_debug.c
3 * vvvvvvvvvvvvvvvvvvvvvvv Original vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
4 * Copyright (C) 1992 Eric Youngdale
5 * Simulate a host adapter with 2 disks attached. Do a lot of checking
6 * to make sure that we are not getting blocks mixed up, and PANIC if
7 * anything out of the ordinary is seen.
8 * ^^^^^^^^^^^^^^^^^^^^^^^ Original ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
10 * This version is more generic, simulating a variable number of disk
11 * (or disk like devices) sharing a common amount of RAM
14 * For documentation see http://www.torque.net/sg/sdebug.html
16 * D. Gilbert (dpg) work for Magneto-Optical device test [20010421]
17 * dpg: work for devfs large number of disks [20010809]
18 * forked for lk 2.5 series [20011216, 20020101]
19 * use vmalloc() more inquiry+mode_sense [20020302]
20 * add timers for delayed responses [20020721]
21 * Patrick Mansfield <patmans@us.ibm.com> max_luns+scsi_level [20021031]
22 * Mike Anderson <andmike@us.ibm.com> sysfs work [20021118]
23 * dpg: change style of boot options to "scsi_debug.num_devs=2" and
24 * module options to "modprobe scsi_debug num_devs=2" [20021221]
27 #include <linux/config.h>
28 #include <linux/module.h>
30 #include <linux/kernel.h>
31 #include <linux/sched.h>
32 #include <linux/errno.h>
33 #include <linux/timer.h>
34 #include <linux/types.h>
35 #include <linux/string.h>
36 #include <linux/genhd.h>
38 #include <linux/init.h>
39 #include <linux/proc_fs.h>
40 #include <linux/smp_lock.h>
41 #include <linux/vmalloc.h>
42 #include <linux/moduleparam.h>
44 #include <linux/blk.h>
47 #include <scsi/scsicam.h>
49 #include <linux/stat.h>
51 #ifndef LINUX_VERSION_CODE
52 #include <linux/version.h>
55 #include "scsi_debug.h"
57 static const char * scsi_debug_version_str
= "Version: 1.67 (20021221)";
59 #ifndef SCSI_CMD_READ_16
60 #define SCSI_CMD_READ_16 0x88
62 #ifndef SCSI_CMD_WRITE_16
63 #define SCSI_CMD_WRITE_16 0x8a
66 #define SDEBUG_TAGGED_QUEUING 0 /* 0 | MSG_SIMPLE_TAG | MSG_ORDERED_TAG */
68 /* Default values for driver parameters */
69 #define DEF_NUM_DEVS 1
70 #define DEF_DEV_SIZE_MB 8
71 #define DEF_EVERY_NTH 100
73 #define DEF_MAX_LUNS 2
74 #define DEF_SCSI_LEVEL 3
75 #define DEF_NUM_HOST 1
78 #define MAX_NUM_HOSTS 128
80 /* bit mask values for scsi_debug_opts */
81 #define SCSI_DEBUG_OPT_NOISE 1
82 #define SCSI_DEBUG_OPT_MEDIUM_ERR 2
83 #define SCSI_DEBUG_OPT_EVERY_NTH 4
85 #define OPT_MEDIUM_ERR_ADDR 0x1234
87 static int scsi_debug_dev_size_mb
= DEF_DEV_SIZE_MB
;
88 static int scsi_debug_num_devs
= DEF_NUM_DEVS
;
89 static int scsi_debug_opts
= DEF_OPTS
;
90 static int scsi_debug_every_nth
= DEF_EVERY_NTH
;
91 static int scsi_debug_cmnd_count
= 0;
92 static int scsi_debug_delay
= DEF_DELAY
;
93 static int scsi_debug_max_luns
= DEF_MAX_LUNS
;
94 static int scsi_debug_scsi_level
= DEF_SCSI_LEVEL
;
95 static int scsi_debug_add_host
= DEF_NUM_HOST
;
97 #define DEV_READONLY(TGT) (0)
98 #define DEV_REMOVEABLE(TGT) (0)
99 #define PERIPH_DEVICE_TYPE(TGT) (TYPE_DISK);
101 static unsigned long sdebug_store_size
; /* in bytes */
102 static sector_t sdebug_capacity
; /* in sectors */
104 /* old BIOS stuff, kernel may get rid of them but some mode sense pages
105 may still need them */
106 static int sdebug_heads
; /* heads per disk */
107 static int sdebug_cylinders_per
; /* cylinders per surface */
108 static int sdebug_sectors_per
; /* sectors per cylinder */
110 /* default sector size is 512 bytes, 2**9 bytes */
111 #define POW2_SECT_SIZE 9
112 #define SECT_SIZE (1 << POW2_SECT_SIZE)
113 #define SECT_SIZE_PER(TGT) SECT_SIZE
115 struct sdebug_host_info
{
116 struct Scsi_Host
*shost
;
120 struct sdebug_host_info
* scsi_debug_hosts
;
122 #define SDEBUG_SENSE_LEN 32
124 struct sdebug_dev_info
{
125 unsigned char sense_buff
[SDEBUG_SENSE_LEN
]; /* weak nexus */
126 unsigned int channel
;
129 struct Scsi_Host
*host
;
133 static struct sdebug_dev_info
* devInfop
;
135 typedef void (* done_funct_t
) (struct scsi_cmnd
*);
137 struct sdebug_queued_cmd
{
139 struct timer_list cmnd_timer
;
140 done_funct_t done_funct
;
141 struct scsi_cmnd
* a_cmnd
;
144 static struct sdebug_queued_cmd queued_arr
[SCSI_DEBUG_CANQUEUE
];
146 static unsigned char * fake_storep
; /* ramdisk storage */
148 static unsigned char spare_buff
[SDEBUG_SENSE_LEN
];
150 static int num_aborts
= 0;
151 static int num_dev_resets
= 0;
152 static int num_bus_resets
= 0;
153 static int num_host_resets
= 0;
155 static spinlock_t queued_arr_lock
= SPIN_LOCK_UNLOCKED
;
156 static rwlock_t atomic_rw
= RW_LOCK_UNLOCKED
;
158 static char sdebug_proc_name
[] = "scsi_debug";
159 static struct device_driver sdebug_driverfs_driver
= {
160 .name
= sdebug_proc_name
,
161 .devclass
= &shost_devclass
,
164 /* function declarations */
165 static int resp_inquiry(unsigned char * cmd
, int target
, unsigned char * buff
,
166 int bufflen
, struct sdebug_dev_info
* devip
);
167 static int resp_mode_sense(unsigned char * cmd
, int target
,
168 unsigned char * buff
, int bufflen
,
169 struct sdebug_dev_info
* devip
);
170 static int resp_read(struct scsi_cmnd
* SCpnt
, int upper_blk
, int block
,
171 int num
, struct sdebug_dev_info
* devip
);
172 static int resp_write(struct scsi_cmnd
* SCpnt
, int upper_blk
, int block
,
173 int num
, struct sdebug_dev_info
* devip
);
174 static int resp_report_luns(unsigned char * cmd
, unsigned char * buff
,
175 int bufflen
, struct sdebug_dev_info
* devip
);
176 static void timer_intr_handler(unsigned long);
177 static struct sdebug_dev_info
* devInfoReg(struct scsi_cmnd
*scmd
);
178 static void mk_sense_buffer(struct sdebug_dev_info
* devip
, int key
,
179 int asc
, int asq
, int inbandLen
);
180 static int check_reset(struct scsi_cmnd
* SCpnt
,
181 struct sdebug_dev_info
* devip
);
182 static int schedule_resp(struct scsi_cmnd
* cmnd
,
183 struct sdebug_dev_info
* devip
,
184 done_funct_t done
, int scsi_result
, int delta_jiff
);
185 static void init_all_queued(void);
186 static void stop_all_queued(void);
187 static int stop_queued_cmnd(struct scsi_cmnd
* cmnd
);
188 static int inquiry_evpd_83(unsigned char * arr
, int dev_id_num
,
189 const char * dev_id_str
, int dev_id_str_len
);
190 static void do_create_driverfs_files(void);
191 static void do_remove_driverfs_files(void);
192 static void sdebug_add_shost(int num
);
193 static void sdebug_remove_shost(int num
);
195 static int sdebug_add_adapter(int num
);
196 static void sdebug_remove_adapter(int num
);
197 static struct device pseudo_primary
;
198 static struct bus_type pseudo_lld_bus
;
199 int scsi_debug_register_driver(struct device_driver
*);
200 int scsi_debug_unregister_driver(struct device_driver
*);
202 static unsigned char * scatg2virt(const struct scatterlist
* sclp
)
207 return (unsigned char *)page_address(sclp
->page
) +
214 int scsi_debug_queuecommand(struct scsi_cmnd
* SCpnt
, done_funct_t done
)
216 unsigned char *cmd
= (unsigned char *) SCpnt
->cmnd
;
217 int block
, upper_blk
, num
;
220 int target
= SCpnt
->target
;
221 int bufflen
= SCpnt
->request_bufflen
;
223 struct sdebug_dev_info
* devip
= NULL
;
224 unsigned char * sbuff
;
227 return 0; /* assume mid level reprocessing command */
229 if (SCpnt
->use_sg
) { /* just use first element */
230 struct scatterlist
*sgpnt
= (struct scatterlist
*)
231 SCpnt
->request_buffer
;
233 buff
= scatg2virt(&sgpnt
[0]);
234 bufflen
= sgpnt
[0].length
;
235 /* READ and WRITE process scatterlist themselves */
238 buff
= (unsigned char *) SCpnt
->request_buffer
;
240 buff
= spare_buff
; /* assume cmd moves no data */
241 bufflen
= SDEBUG_SENSE_LEN
;
244 if(target
== sdebug_driver_template
.this_id
) {
246 "scsi_debug: initiator's id used as target!\n");
247 return schedule_resp(SCpnt
, NULL
, done
, 0, 0);
250 if (SCpnt
->lun
>= scsi_debug_max_luns
)
251 return schedule_resp(SCpnt
, NULL
, done
,
252 DID_NO_CONNECT
<< 16, 0);
253 devip
= devInfoReg(SCpnt
);
255 return schedule_resp(SCpnt
, NULL
, done
,
256 DID_NO_CONNECT
<< 16, 0);
258 if ((SCSI_DEBUG_OPT_EVERY_NTH
& scsi_debug_opts
) &&
259 (scsi_debug_every_nth
> 0) &&
260 (++scsi_debug_cmnd_count
>= scsi_debug_every_nth
)) {
261 scsi_debug_cmnd_count
=0;
262 return 0; /* ignore command causing timeout */
266 case INQUIRY
: /* mandatory */
267 errsts
= resp_inquiry(cmd
, target
, buff
, bufflen
, devip
);
269 case REQUEST_SENSE
: /* mandatory */
270 /* Since this driver indicates autosense by placing the
271 * sense buffer in the scsi_cmnd structure in the response
272 * (when CHECK_CONDITION is set), the mid level shouldn't
273 * need to call REQUEST_SENSE */
275 sbuff
= devip
->sense_buff
;
276 memcpy(buff
, sbuff
, (bufflen
< SDEBUG_SENSE_LEN
) ?
277 bufflen
: SDEBUG_SENSE_LEN
);
278 mk_sense_buffer(devip
, 0, 0x0, 0, 7);
280 memset(buff
, 0, bufflen
);
285 errsts
= check_reset(SCpnt
, devip
);
287 case ALLOW_MEDIUM_REMOVAL
:
288 if ((errsts
= check_reset(SCpnt
, devip
)))
290 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
291 printk("\tMedium removal %s\n",
292 cmd
[4] ? "inhibited" : "enabled");
294 case SEND_DIAGNOSTIC
: /* mandatory */
295 memset(buff
, 0, bufflen
);
297 case TEST_UNIT_READY
: /* mandatory */
298 memset(buff
, 0, bufflen
);
301 errsts
= check_reset(SCpnt
, devip
);
302 memset(buff
, 0, bufflen
);
305 errsts
= check_reset(SCpnt
, devip
);
306 memset(buff
, 0, bufflen
);
309 errsts
= check_reset(SCpnt
, devip
);
310 memset(buff
, 0, bufflen
);
313 errsts
= check_reset(SCpnt
, devip
);
314 memset(buff
, 0, bufflen
);
317 errsts
= check_reset(SCpnt
, devip
);
318 memset(buff
, 0, bufflen
);
320 capac
= (unsigned long)sdebug_capacity
- 1;
321 buff
[0] = (capac
>> 24);
322 buff
[1] = (capac
>> 16) & 0xff;
323 buff
[2] = (capac
>> 8) & 0xff;
324 buff
[3] = capac
& 0xff;
325 buff
[6] = (SECT_SIZE_PER(target
) >> 8) & 0xff;
326 buff
[7] = SECT_SIZE_PER(target
) & 0xff;
329 case SCSI_CMD_READ_16
: /* SBC-2 */
333 if ((errsts
= check_reset(SCpnt
, devip
)))
336 if ((*cmd
) == SCSI_CMD_READ_16
) {
337 upper_blk
= cmd
[5] + (cmd
[4] << 8) +
338 (cmd
[3] << 16) + (cmd
[2] << 24);
339 block
= cmd
[9] + (cmd
[8] << 8) +
340 (cmd
[7] << 16) + (cmd
[6] << 24);
341 num
= cmd
[13] + (cmd
[12] << 8) +
342 (cmd
[11] << 16) + (cmd
[10] << 24);
343 } else if ((*cmd
) == READ_12
) {
344 block
= cmd
[5] + (cmd
[4] << 8) +
345 (cmd
[3] << 16) + (cmd
[2] << 24);
346 num
= cmd
[9] + (cmd
[8] << 8) +
347 (cmd
[7] << 16) + (cmd
[6] << 24);
348 } else if ((*cmd
) == READ_10
) {
349 block
= cmd
[5] + (cmd
[4] << 8) +
350 (cmd
[3] << 16) + (cmd
[2] << 24);
351 num
= cmd
[8] + (cmd
[7] << 8);
353 block
= cmd
[3] + (cmd
[2] << 8) +
354 ((cmd
[1] & 0x1f) << 16);
357 errsts
= resp_read(SCpnt
, upper_blk
, block
, num
, devip
);
360 errsts
= resp_report_luns(cmd
, buff
, bufflen
, devip
);
362 case SCSI_CMD_WRITE_16
: /* SBC-2 */
366 if ((errsts
= check_reset(SCpnt
, devip
)))
369 if ((*cmd
) == SCSI_CMD_WRITE_16
) {
370 upper_blk
= cmd
[5] + (cmd
[4] << 8) +
371 (cmd
[3] << 16) + (cmd
[2] << 24);
372 block
= cmd
[9] + (cmd
[8] << 8) +
373 (cmd
[7] << 16) + (cmd
[6] << 24);
374 num
= cmd
[13] + (cmd
[12] << 8) +
375 (cmd
[11] << 16) + (cmd
[10] << 24);
376 } else if ((*cmd
) == WRITE_12
) {
377 block
= cmd
[5] + (cmd
[4] << 8) +
378 (cmd
[3] << 16) + (cmd
[2] << 24);
379 num
= cmd
[9] + (cmd
[8] << 8) +
380 (cmd
[7] << 16) + (cmd
[6] << 24);
381 } else if ((*cmd
) == WRITE_10
) {
382 block
= cmd
[5] + (cmd
[4] << 8) +
383 (cmd
[3] << 16) + (cmd
[2] << 24);
384 num
= cmd
[8] + (cmd
[7] << 8);
386 block
= cmd
[3] + (cmd
[2] << 8) +
387 ((cmd
[1] & 0x1f) << 16);
390 errsts
= resp_write(SCpnt
, upper_blk
, block
, num
, devip
);
394 errsts
= resp_mode_sense(cmd
, target
, buff
, bufflen
, devip
);
396 case SYNCHRONIZE_CACHE
:
397 memset(buff
, 0, bufflen
);
400 if ((errsts
= check_reset(SCpnt
, devip
)))
402 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, 0x20, 0, 14);
403 errsts
= (DRIVER_SENSE
<< 24) | (CHECK_CONDITION
<< 1);
406 return schedule_resp(SCpnt
, devip
, done
, errsts
, scsi_debug_delay
);
409 static int scsi_debug_ioctl(struct scsi_device
*dev
, int cmd
, void *arg
)
411 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
) {
412 printk(KERN_INFO
"scsi_debug: ioctl: cmd=0x%x\n", cmd
);
415 /* return -ENOTTY; // correct return but upsets fdisk */
418 static int check_reset(struct scsi_cmnd
* SCpnt
, struct sdebug_dev_info
* devip
)
422 mk_sense_buffer(devip
, UNIT_ATTENTION
, 0x29, 0, 14);
423 return (DRIVER_SENSE
<< 24) | (CHECK_CONDITION
<< 1);
428 #define SDEBUG_LONG_INQ_SZ 58
429 #define SDEBUG_MAX_INQ_ARR_SZ 128
431 static const char * vendor_id
= "Linux ";
432 static const char * product_id
= "scsi_debug ";
433 static const char * product_rev
= "0004";
435 static int inquiry_evpd_83(unsigned char * arr
, int dev_id_num
,
436 const char * dev_id_str
, int dev_id_str_len
)
440 /* Two identification descriptors: */
441 /* T10 vendor identifier field format (faked) */
442 arr
[0] = 0x2; /* ASCII */
445 memcpy(&arr
[4], vendor_id
, 8);
446 memcpy(&arr
[12], product_id
, 16);
447 memcpy(&arr
[28], dev_id_str
, dev_id_str_len
);
448 num
= 8 + 16 + dev_id_str_len
;
451 /* NAA IEEE registered identifier (faked) */
452 arr
[num
] = 0x1; /* binary */
456 arr
[num
+ 4] = 0x51; /* ieee company id=0x123456 (faked) */
460 arr
[num
+ 8] = (dev_id_num
>> 24);
461 arr
[num
+ 9] = (dev_id_num
>> 16) & 0xff;
462 arr
[num
+ 10] = (dev_id_num
>> 8) & 0xff;
463 arr
[num
+ 11] = dev_id_num
& 0xff;
467 static int resp_inquiry(unsigned char * cmd
, int target
, unsigned char * buff
,
468 int bufflen
, struct sdebug_dev_info
* devip
)
470 unsigned char pq_pdt
;
471 unsigned char arr
[SDEBUG_MAX_INQ_ARR_SZ
];
472 int min_len
= bufflen
> SDEBUG_MAX_INQ_ARR_SZ
?
473 SDEBUG_MAX_INQ_ARR_SZ
: bufflen
;
475 if (bufflen
< cmd
[4])
476 printk(KERN_INFO
"scsi_debug: inquiry: bufflen=%d "
477 "< alloc_length=%d\n", bufflen
, (int)cmd
[4]);
478 memset(buff
, 0, bufflen
);
479 memset(arr
, 0, SDEBUG_MAX_INQ_ARR_SZ
);
480 pq_pdt
= PERIPH_DEVICE_TYPE(target
);
482 if (0x2 & cmd
[1]) { /* CMDDT bit set */
483 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, 0x24, 0, 14);
484 return (DRIVER_SENSE
<< 24) | (CHECK_CONDITION
<< 1);
485 } else if (0x1 & cmd
[1]) { /* EVPD bit set */
489 dev_id_num
= ((devip
->host
->host_no
+ 1) * 2000) +
490 (devip
->target
* 1000) + devip
->lun
;
491 len
= snprintf(dev_id_str
, 6, "%d", dev_id_num
);
492 len
= (len
> 6) ? 6 : len
;
493 if (0 == cmd
[2]) { /* supported vital product data pages */
495 arr
[4] = 0x0; /* this page */
496 arr
[5] = 0x80; /* unit serial number */
497 arr
[6] = 0x83; /* device identification */
498 } else if (0x80 == cmd
[2]) { /* unit serial number */
501 memcpy(&arr
[4], dev_id_str
, len
);
502 } else if (0x83 == cmd
[2]) { /* device identification */
504 arr
[3] = inquiry_evpd_83(&arr
[4], dev_id_num
,
507 /* Illegal request, invalid field in cdb */
508 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, 0x24, 0, 14);
509 return (DRIVER_SENSE
<< 24) | (CHECK_CONDITION
<< 1);
511 memcpy(buff
, arr
, min_len
);
514 /* drops through here for a standard inquiry */
515 arr
[1] = DEV_REMOVEABLE(target
) ? 0x80 : 0; /* Removable disk */
516 arr
[2] = scsi_debug_scsi_level
;
517 arr
[4] = SDEBUG_LONG_INQ_SZ
- 5;
518 arr
[7] = 0x3a; /* claim: WBUS16, SYNC, LINKED + CMDQUE */
519 memcpy(&arr
[8], vendor_id
, 8);
520 memcpy(&arr
[16], product_id
, 16);
521 memcpy(&arr
[32], product_rev
, 4);
522 memcpy(buff
, arr
, min_len
);
526 /* <<Following mode page info copied from ST318451LW>> */
528 static int resp_err_recov_pg(unsigned char * p
, int pcontrol
, int target
)
529 { /* Read-Write Error Recovery page for mode_sense */
530 unsigned char err_recov_pg
[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
533 memcpy(p
, err_recov_pg
, sizeof(err_recov_pg
));
535 memset(p
+ 2, 0, sizeof(err_recov_pg
) - 2);
536 return sizeof(err_recov_pg
);
539 static int resp_disconnect_pg(unsigned char * p
, int pcontrol
, int target
)
540 { /* Disconnect-Reconnect page for mode_sense */
541 unsigned char disconnect_pg
[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
542 0, 0, 0, 0, 0, 0, 0, 0};
544 memcpy(p
, disconnect_pg
, sizeof(disconnect_pg
));
546 memset(p
+ 2, 0, sizeof(disconnect_pg
) - 2);
547 return sizeof(disconnect_pg
);
550 static int resp_format_pg(unsigned char * p
, int pcontrol
, int target
)
551 { /* Format device page for mode_sense */
552 unsigned char format_pg
[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
553 0, 0, 0, 0, 0, 0, 0, 0,
554 0, 0, 0, 0, 0x40, 0, 0, 0};
556 memcpy(p
, format_pg
, sizeof(format_pg
));
557 p
[10] = (sdebug_sectors_per
>> 8) & 0xff;
558 p
[11] = sdebug_sectors_per
& 0xff;
559 p
[12] = (SECT_SIZE
>> 8) & 0xff;
560 p
[13] = SECT_SIZE
& 0xff;
561 if (DEV_REMOVEABLE(target
))
562 p
[20] |= 0x20; /* should agree with INQUIRY */
564 memset(p
+ 2, 0, sizeof(format_pg
) - 2);
565 return sizeof(format_pg
);
568 static int resp_caching_pg(unsigned char * p
, int pcontrol
, int target
)
569 { /* Caching page for mode_sense */
570 unsigned char caching_pg
[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
571 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
573 memcpy(p
, caching_pg
, sizeof(caching_pg
));
575 memset(p
+ 2, 0, sizeof(caching_pg
) - 2);
576 return sizeof(caching_pg
);
579 static int resp_ctrl_m_pg(unsigned char * p
, int pcontrol
, int target
)
580 { /* Control mode page for mode_sense */
581 unsigned char ctrl_m_pg
[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
584 memcpy(p
, ctrl_m_pg
, sizeof(ctrl_m_pg
));
586 memset(p
+ 2, 0, sizeof(ctrl_m_pg
) - 2);
587 return sizeof(ctrl_m_pg
);
591 #define SDEBUG_MAX_MSENSE_SZ 256
593 static int resp_mode_sense(unsigned char * cmd
, int target
,
594 unsigned char * buff
, int bufflen
,
595 struct sdebug_dev_info
* devip
)
599 unsigned char dev_spec
;
600 int alloc_len
, msense_6
, offset
, len
;
602 unsigned char arr
[SDEBUG_MAX_MSENSE_SZ
];
603 int min_len
= bufflen
> SDEBUG_MAX_MSENSE_SZ
?
604 SDEBUG_MAX_MSENSE_SZ
: bufflen
;
606 SCSI_LOG_LLQUEUE(3, printk("Mode sense ...(%p %d)\n", buff
, bufflen
));
608 pcontrol
= (cmd
[2] & 0xc0) >> 6;
609 pcode
= cmd
[2] & 0x3f;
610 msense_6
= (MODE_SENSE
== cmd
[0]);
611 alloc_len
= msense_6
? cmd
[4] : ((cmd
[7] << 8) | cmd
[6]);
612 /* printk(KERN_INFO "msense: dbd=%d pcontrol=%d pcode=%d "
613 "msense_6=%d alloc_len=%d\n", dbd, pcontrol, pcode, "
614 "msense_6, alloc_len); */
615 if (bufflen
< alloc_len
)
616 printk(KERN_INFO
"scsi_debug: mode_sense: bufflen=%d "
617 "< alloc_length=%d\n", bufflen
, alloc_len
);
618 memset(buff
, 0, bufflen
);
619 memset(arr
, 0, SDEBUG_MAX_MSENSE_SZ
);
620 if (0x3 == pcontrol
) { /* Saving values not supported */
621 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, 0x39, 0, 14);
622 return (DRIVER_SENSE
<< 24) | (CHECK_CONDITION
<< 1);
624 dev_spec
= DEV_READONLY(target
) ? 0x80 : 0x0;
635 case 0x1: /* Read-Write error recovery page, direct access */
636 len
= resp_err_recov_pg(ap
, pcontrol
, target
);
639 case 0x2: /* Disconnect-Reconnect page, all devices */
640 len
= resp_disconnect_pg(ap
, pcontrol
, target
);
643 case 0x3: /* Format device page, direct access */
644 len
= resp_format_pg(ap
, pcontrol
, target
);
647 case 0x8: /* Caching page, direct access */
648 len
= resp_caching_pg(ap
, pcontrol
, target
);
651 case 0xa: /* Control Mode page, all devices */
652 len
= resp_ctrl_m_pg(ap
, pcontrol
, target
);
655 case 0x3f: /* Read all Mode pages */
656 len
= resp_err_recov_pg(ap
, pcontrol
, target
);
657 len
+= resp_disconnect_pg(ap
+ len
, pcontrol
, target
);
658 len
+= resp_format_pg(ap
+ len
, pcontrol
, target
);
659 len
+= resp_caching_pg(ap
+ len
, pcontrol
, target
);
660 len
+= resp_ctrl_m_pg(ap
+ len
, pcontrol
, target
);
664 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, 0x24, 0, 14);
665 return (DRIVER_SENSE
<< 24) | (CHECK_CONDITION
<< 1);
671 arr
[0] = (offset
>> 8) & 0xff;
672 arr
[1] = offset
& 0xff;
674 memcpy(buff
, arr
, min_len
);
678 static int resp_read(struct scsi_cmnd
* SCpnt
, int upper_blk
, int block
,
679 int num
, struct sdebug_dev_info
* devip
)
681 unsigned char *buff
= (unsigned char *) SCpnt
->request_buffer
;
683 struct scatterlist
*sgpnt
= NULL
;
684 int bufflen
= SCpnt
->request_bufflen
;
685 unsigned long iflags
;
687 if (upper_blk
|| (block
+ num
> sdebug_capacity
)) {
688 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, 0x21, 0, 14);
689 return (DRIVER_SENSE
<< 24) | (CHECK_CONDITION
<< 1);
691 if ((SCSI_DEBUG_OPT_MEDIUM_ERR
& scsi_debug_opts
) &&
692 (block
>= OPT_MEDIUM_ERR_ADDR
) &&
693 (block
< (OPT_MEDIUM_ERR_ADDR
+ num
))) {
694 mk_sense_buffer(devip
, MEDIUM_ERROR
, 0x11, 0, 14);
695 /* claim unrecoverable read error */
696 return (DRIVER_SENSE
<< 24) | (CHECK_CONDITION
<< 1);
698 read_lock_irqsave(&atomic_rw
, iflags
);
701 /* printk(KERN_INFO "scsi_debug_read: block=%d, tot_bufflen=%d\n",
705 sgpnt
= (struct scatterlist
*) buff
;
706 buff
= scatg2virt(&sgpnt
[sgcount
]);
707 bufflen
= sgpnt
[sgcount
].length
;
710 memcpy(buff
, fake_storep
+ (block
* SECT_SIZE
), bufflen
);
713 block
+= bufflen
>> POW2_SECT_SIZE
;
716 buff
= scatg2virt(&sgpnt
[sgcount
]);
717 bufflen
= sgpnt
[sgcount
].length
;
719 } else if (nbytes
> 0)
720 printk(KERN_WARNING
"scsi_debug:resp_read: unexpected "
721 "nbytes=%d\n", nbytes
);
723 read_unlock_irqrestore(&atomic_rw
, iflags
);
727 static int resp_write(struct scsi_cmnd
* SCpnt
, int upper_blk
, int block
,
728 int num
, struct sdebug_dev_info
* devip
)
730 unsigned char *buff
= (unsigned char *) SCpnt
->request_buffer
;
732 struct scatterlist
*sgpnt
= NULL
;
733 int bufflen
= SCpnt
->request_bufflen
;
734 unsigned long iflags
;
736 if (upper_blk
|| (block
+ num
> sdebug_capacity
)) {
737 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, 0x21, 0, 14);
738 return (DRIVER_SENSE
<< 24) | (CHECK_CONDITION
<< 1);
741 write_lock_irqsave(&atomic_rw
, iflags
);
746 sgpnt
= (struct scatterlist
*) buff
;
747 buff
= scatg2virt(&sgpnt
[sgcount
]);
748 bufflen
= sgpnt
[sgcount
].length
;
751 memcpy(fake_storep
+ (block
* SECT_SIZE
), buff
, bufflen
);
755 block
+= bufflen
>> POW2_SECT_SIZE
;
758 buff
= scatg2virt(&sgpnt
[sgcount
]);
759 bufflen
= sgpnt
[sgcount
].length
;
761 } else if (nbytes
> 0)
762 printk(KERN_WARNING
"scsi_debug:resp_write: "
763 "unexpected nbytes=%d\n", nbytes
);
765 write_unlock_irqrestore(&atomic_rw
, iflags
);
769 static int resp_report_luns(unsigned char * cmd
, unsigned char * buff
,
770 int bufflen
, struct sdebug_dev_info
* devip
)
772 unsigned int alloc_len
, lun_cnt
, i
;
773 int select_report
= (int)cmd
[2];
776 alloc_len
= cmd
[9] + (cmd
[8] << 8) + (cmd
[7] << 16) + (cmd
[6] << 24);
777 if ((alloc_len
< 16) || (select_report
> 2)) {
778 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, 0x24, 0, 14);
779 return (DRIVER_SENSE
<< 24) | (CHECK_CONDITION
<< 1);
782 lun_cnt
= min((int)(bufflen
/ sizeof(ScsiLun
)),
783 (int)scsi_debug_max_luns
);
784 memset(buff
, 0, bufflen
);
785 buff
[3] = 8 * lun_cnt
;
786 one_lun
= (ScsiLun
*) &buff
[0];
787 for (i
= 0; i
< lun_cnt
; i
++)
788 one_lun
[i
].scsi_lun
[1] = i
;
793 /* When timer goes off this function is called. */
794 static void timer_intr_handler(unsigned long indx
)
796 struct sdebug_queued_cmd
* sqcp
;
799 if (indx
>= SCSI_DEBUG_CANQUEUE
) {
800 printk(KERN_ERR
"scsi_debug:timer_intr_handler: indx too "
804 spin_lock_irqsave(&queued_arr_lock
, iflags
);
805 sqcp
= &queued_arr
[(int)indx
];
806 if (! sqcp
->in_use
) {
807 printk(KERN_ERR
"scsi_debug:timer_intr_handler: Unexpected "
809 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
813 if (sqcp
->done_funct
)
814 sqcp
->done_funct(sqcp
->a_cmnd
); /* callback to mid level */
815 sqcp
->done_funct
= NULL
;
816 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
819 static int scsi_debug_slave_configure(struct scsi_device
* sdp
)
822 struct sdebug_dev_info
* devip
;
824 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
825 printk(KERN_INFO
"scsi_debug: slave_configure <%u %u %u %u>\n",
826 sdp
->host
->host_no
, sdp
->channel
, sdp
->id
, sdp
->lun
);
827 if (sdp
->host
->max_cmd_len
!= SCSI_DEBUG_MAX_CMD_LEN
)
828 sdp
->host
->max_cmd_len
= SCSI_DEBUG_MAX_CMD_LEN
;
829 for (k
= 0; k
< scsi_debug_num_devs
; ++k
) {
830 devip
= &devInfop
[k
];
831 if ((devip
->channel
== sdp
->channel
) &&
832 (devip
->target
== sdp
->id
) &&
833 (devip
->lun
== sdp
->lun
) &&
834 (devip
->host
== sdp
->host
)) {
835 sdp
->hostdata
= devip
;
839 if (sdp
->host
->cmd_per_lun
)
840 scsi_adjust_queue_depth(sdp
, SDEBUG_TAGGED_QUEUING
,
841 sdp
->host
->cmd_per_lun
);
845 static void scsi_debug_slave_destroy(struct scsi_device
* sdp
)
847 struct sdebug_dev_info
* devip
=
848 (struct sdebug_dev_info
*)sdp
->hostdata
;
850 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
851 printk(KERN_INFO
"scsi_debug: slave_destroy <%u %u %u %u>\n",
852 sdp
->host
->host_no
, sdp
->channel
, sdp
->id
, sdp
->lun
);
854 /* make this slot avaliable for re-use */
855 memset(devip
, 0, sizeof(struct sdebug_dev_info
));
856 sdp
->hostdata
= NULL
;
860 static struct sdebug_dev_info
* devInfoReg(struct scsi_cmnd
*scmd
)
863 struct scsi_device
* sdp
= scmd
->device
;
864 struct sdebug_dev_info
* devip
=
865 (struct sdebug_dev_info
*)sdp
->hostdata
;
869 for (k
= 0; k
< scsi_debug_num_devs
; ++k
) {
870 devip
= &devInfop
[k
];
871 if ((devip
->channel
== scmd
->channel
) &&
872 (devip
->target
== scmd
->target
) &&
873 (devip
->lun
== scmd
->lun
) &&
874 (devip
->host
== scmd
->host
))
877 for (k
= 0; k
< scsi_debug_num_devs
; ++k
) {
878 devip
= &devInfop
[k
];
880 devip
->channel
= scmd
->channel
;
881 devip
->target
= scmd
->target
;
882 devip
->lun
= scmd
->lun
;
883 devip
->host
= scmd
->host
;
886 memset(devip
->sense_buff
, 0, SDEBUG_SENSE_LEN
);
887 devip
->sense_buff
[0] = 0x70;
894 static void mk_sense_buffer(struct sdebug_dev_info
* devip
, int key
,
895 int asc
, int asq
, int inbandLen
)
897 unsigned char * sbuff
;
899 sbuff
= devip
->sense_buff
;
900 memset(sbuff
, 0, SDEBUG_SENSE_LEN
);
901 if (inbandLen
> SDEBUG_SENSE_LEN
)
902 inbandLen
= SDEBUG_SENSE_LEN
;
905 sbuff
[7] = (inbandLen
> 7) ? (inbandLen
- 8) : 0;
910 static int scsi_debug_abort(struct scsi_cmnd
* SCpnt
)
912 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
913 printk(KERN_INFO
"scsi_debug: abort\n");
915 stop_queued_cmnd(SCpnt
);
919 static int scsi_debug_biosparam(struct scsi_device
*sdev
,
920 struct block_device
* bdev
, sector_t capacity
, int *info
)
925 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
926 printk(KERN_INFO
"scsi_debug: biosparam\n");
927 buf
= scsi_bios_ptable(bdev
);
929 res
= scsi_partsize(buf
, capacity
,
930 &info
[2], &info
[0], &info
[1]);
935 info
[0] = sdebug_heads
;
936 info
[1] = sdebug_sectors_per
;
937 info
[2] = sdebug_cylinders_per
;
941 static int scsi_debug_device_reset(struct scsi_cmnd
* SCpnt
)
943 struct sdebug_dev_info
* devip
;
945 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
946 printk(KERN_INFO
"scsi_debug: device_reset\n");
949 devip
= devInfoReg(SCpnt
);
956 static int scsi_debug_bus_reset(struct scsi_cmnd
* SCpnt
)
958 struct scsi_device
* sdp
;
959 struct Scsi_Host
* hp
;
962 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
963 printk(KERN_INFO
"scsi_debug: bus_reset\n");
965 if (SCpnt
&& ((sdp
= SCpnt
->device
)) && ((hp
= SCpnt
->host
))) {
966 for (k
= 0; k
< scsi_debug_num_devs
; ++k
) {
967 if (hp
== devInfop
[k
].host
)
968 devInfop
[k
].reset
= 1;
974 static int scsi_debug_host_reset(struct scsi_cmnd
* SCpnt
)
978 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
979 printk(KERN_INFO
"scsi_debug: host_reset\n");
981 for (k
= 0; k
< scsi_debug_num_devs
; ++k
)
982 devInfop
[k
].reset
= 1;
988 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
989 static int stop_queued_cmnd(struct scsi_cmnd
* cmnd
)
991 unsigned long iflags
;
993 struct sdebug_queued_cmd
* sqcp
;
995 spin_lock_irqsave(&queued_arr_lock
, iflags
);
996 for (k
= 0; k
< SCSI_DEBUG_CANQUEUE
; ++k
) {
997 sqcp
= &queued_arr
[k
];
998 if (sqcp
->in_use
&& (cmnd
== sqcp
->a_cmnd
)) {
999 del_timer_sync(&sqcp
->cmnd_timer
);
1001 sqcp
->a_cmnd
= NULL
;
1005 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
1006 return (k
< SCSI_DEBUG_CANQUEUE
) ? 1 : 0;
1009 /* Deletes (stops) timers of all queued commands */
1010 static void stop_all_queued(void)
1012 unsigned long iflags
;
1014 struct sdebug_queued_cmd
* sqcp
;
1016 spin_lock_irqsave(&queued_arr_lock
, iflags
);
1017 for (k
= 0; k
< SCSI_DEBUG_CANQUEUE
; ++k
) {
1018 sqcp
= &queued_arr
[k
];
1019 if (sqcp
->in_use
&& sqcp
->a_cmnd
) {
1020 del_timer_sync(&sqcp
->cmnd_timer
);
1022 sqcp
->a_cmnd
= NULL
;
1025 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
1028 /* Initializes timers in queued array */
1029 static void init_all_queued(void)
1031 unsigned long iflags
;
1033 struct sdebug_queued_cmd
* sqcp
;
1035 spin_lock_irqsave(&queued_arr_lock
, iflags
);
1036 for (k
= 0; k
< SCSI_DEBUG_CANQUEUE
; ++k
) {
1037 sqcp
= &queued_arr
[k
];
1038 init_timer(&sqcp
->cmnd_timer
);
1040 sqcp
->a_cmnd
= NULL
;
1042 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
1045 static int schedule_resp(struct scsi_cmnd
* cmnd
,
1046 struct sdebug_dev_info
* devip
,
1047 done_funct_t done
, int scsi_result
, int delta_jiff
)
1051 if ((SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
) && cmnd
) {
1052 printk(KERN_INFO
"scsi_debug: cmd ");
1053 for (k
= 0, num
= cmnd
->cmd_len
; k
< num
; ++k
)
1054 printk("%02x ", (int)cmnd
->cmnd
[k
]);
1057 struct scsi_device
* sdp
= cmnd
->device
;
1059 printk(KERN_INFO
"scsi_debug: ... <%u %u %u %u> "
1060 "non-zero result=0x%x\n", sdp
->host
->host_no
,
1061 sdp
->channel
, sdp
->id
, sdp
->lun
, scsi_result
);
1064 if (cmnd
&& devip
) {
1065 /* simulate autosense by this driver */
1066 if (CHECK_CONDITION
== status_byte(scsi_result
))
1067 memcpy(cmnd
->sense_buffer
, devip
->sense_buff
,
1068 (SCSI_SENSE_BUFFERSIZE
> SDEBUG_SENSE_LEN
) ?
1069 SDEBUG_SENSE_LEN
: SCSI_SENSE_BUFFERSIZE
);
1071 if (delta_jiff
<= 0) {
1073 cmnd
->result
= scsi_result
;
1078 unsigned long iflags
;
1080 struct sdebug_queued_cmd
* sqcp
= NULL
;
1082 spin_lock_irqsave(&queued_arr_lock
, iflags
);
1083 for (k
= 0; k
< SCSI_DEBUG_CANQUEUE
; ++k
) {
1084 sqcp
= &queued_arr
[k
];
1088 if (k
>= SCSI_DEBUG_CANQUEUE
) {
1089 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
1090 printk(KERN_WARNING
"scsi_debug: can_queue exceeded\n");
1091 return 1; /* report busy to mid level */
1094 sqcp
->a_cmnd
= cmnd
;
1095 sqcp
->scsi_result
= scsi_result
;
1096 sqcp
->done_funct
= done
;
1097 sqcp
->cmnd_timer
.function
= timer_intr_handler
;
1098 sqcp
->cmnd_timer
.data
= k
;
1099 sqcp
->cmnd_timer
.expires
= jiffies
+ delta_jiff
;
1100 add_timer(&sqcp
->cmnd_timer
);
1101 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
1106 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
1107 * of sysfs parameters (which module_param doesn't yet support).
1108 * Sysfs parameters defined explicitly below.
1110 module_param_named(num_devs
, scsi_debug_num_devs
, int, 0);
1111 module_param_named(max_luns
, scsi_debug_max_luns
, int, 0);
1112 module_param_named(scsi_level
, scsi_debug_scsi_level
, int, 0);
1113 module_param_named(dev_size_mb
, scsi_debug_dev_size_mb
, int, 0);
1114 module_param_named(opts
, scsi_debug_opts
, int, 0); /* perm=0644 */
1115 module_param_named(every_nth
, scsi_debug_every_nth
, int, 0);
1116 module_param_named(delay
, scsi_debug_delay
, int, 0); /* perm=0644 */
1117 module_param_named(add_host
, scsi_debug_add_host
, int, 0); /* perm=0644 */
1119 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
1120 MODULE_DESCRIPTION("SCSI debug adapter driver");
1121 MODULE_LICENSE("GPL");
1123 MODULE_PARM_DESC(num_devs
, "number of SCSI devices to simulate");
1124 MODULE_PARM_DESC(max_luns
, "number of SCSI LUNs per target to simulate");
1125 MODULE_PARM_DESC(scsi_level
, "SCSI level to simulate");
1126 MODULE_PARM_DESC(dev_size_mb
, "size in MB of ram shared by devs");
1127 MODULE_PARM_DESC(opts
, "1->noise, 2->medium_error, 4->...");
1128 MODULE_PARM_DESC(every_nth
, "timeout every nth command(def=100)");
1129 MODULE_PARM_DESC(delay
, "# of jiffies to delay response(def=1)");
1130 MODULE_PARM_DESC(add_host
, "0..127 hosts allowed(def=1)");
1133 static char sdebug_info
[256];
1135 static const char * scsi_debug_info(struct Scsi_Host
* shp
)
1137 sprintf(sdebug_info
, "scsi_debug, %s, num_devs=%d, "
1138 "dev_size_mb=%d, opts=0x%x", scsi_debug_version_str
,
1139 scsi_debug_num_devs
, scsi_debug_dev_size_mb
,
1144 /* scsi_debug_proc_info
1145 * Used if the driver currently has no own support for /proc/scsi
1147 static int scsi_debug_proc_info(char *buffer
, char **start
, off_t offset
,
1148 int length
, int inode
, int inout
)
1150 int len
, pos
, begin
;
1153 orig_length
= length
;
1157 int minLen
= length
> 15 ? 15 : length
;
1159 if (!capable(CAP_SYS_ADMIN
) || !capable(CAP_SYS_RAWIO
))
1161 memcpy(arr
, buffer
, minLen
);
1163 if (1 != sscanf(arr
, "%d", &pos
))
1165 scsi_debug_opts
= pos
;
1166 if (SCSI_DEBUG_OPT_EVERY_NTH
& scsi_debug_opts
)
1167 scsi_debug_cmnd_count
= 0;
1171 pos
= len
= sprintf(buffer
, "scsi_debug adapter driver, %s\n"
1172 "num_devs=%d, shared (ram) size=%d MB, opts=0x%x, "
1173 "every_nth=%d(curr:%d)\n"
1174 "delay=%d, max_luns=%d, scsi_level=%d\n"
1175 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
1176 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
1178 scsi_debug_version_str
, scsi_debug_num_devs
,
1179 scsi_debug_dev_size_mb
, scsi_debug_opts
, scsi_debug_every_nth
,
1180 scsi_debug_cmnd_count
, scsi_debug_delay
,
1181 scsi_debug_max_luns
, scsi_debug_scsi_level
,
1182 SECT_SIZE
, sdebug_cylinders_per
, sdebug_heads
, sdebug_sectors_per
,
1183 num_aborts
, num_dev_resets
, num_bus_resets
, num_host_resets
);
1188 *start
= buffer
+ (offset
- begin
); /* Start of wanted data */
1189 len
-= (offset
- begin
);
1195 static ssize_t
sdebug_delay_read(struct device_driver
* ddp
, char * buf
)
1197 return sprintf(buf
, "%d\n", scsi_debug_delay
);
1200 static ssize_t
sdebug_delay_write(struct device_driver
* ddp
,
1201 const char * buf
, size_t count
)
1206 if (1 == sscanf(buf
, "%10s", work
)) {
1207 if ((1 == sscanf(work
, "%d", &delay
)) && (delay
>= 0)) {
1208 scsi_debug_delay
= delay
;
1214 DRIVER_ATTR(delay
, S_IRUGO
| S_IWUSR
, sdebug_delay_read
,
1217 static ssize_t
sdebug_opts_read(struct device_driver
* ddp
, char * buf
)
1219 return sprintf(buf
, "0x%x\n", scsi_debug_opts
);
1222 static ssize_t
sdebug_opts_write(struct device_driver
* ddp
,
1223 const char * buf
, size_t count
)
1228 if (1 == sscanf(buf
, "%10s", work
)) {
1229 if (0 == strnicmp(work
,"0x", 2)) {
1230 if (1 == sscanf(&work
[2], "%x", &opts
))
1233 if (1 == sscanf(work
, "%d", &opts
))
1239 scsi_debug_opts
= opts
;
1242 DRIVER_ATTR(opts
, S_IRUGO
| S_IWUSR
, sdebug_opts_read
,
1245 static ssize_t
sdebug_num_devs_read(struct device_driver
* ddp
, char * buf
)
1247 return sprintf(buf
, "%d\n", scsi_debug_num_devs
);
1249 DRIVER_ATTR(num_devs
, S_IRUGO
, sdebug_num_devs_read
, NULL
)
1251 static ssize_t
sdebug_dev_size_mb_read(struct device_driver
* ddp
, char * buf
)
1253 return sprintf(buf
, "%d\n", scsi_debug_dev_size_mb
);
1255 DRIVER_ATTR(dev_size_mb
, S_IRUGO
, sdebug_dev_size_mb_read
, NULL
)
1257 static ssize_t
sdebug_every_nth_read(struct device_driver
* ddp
, char * buf
)
1259 return sprintf(buf
, "%d\n", scsi_debug_every_nth
);
1261 DRIVER_ATTR(every_nth
, S_IRUGO
, sdebug_every_nth_read
, NULL
)
1263 static ssize_t
sdebug_max_luns_read(struct device_driver
* ddp
, char * buf
)
1265 return sprintf(buf
, "%d\n", scsi_debug_max_luns
);
1267 DRIVER_ATTR(max_luns
, S_IRUGO
, sdebug_max_luns_read
, NULL
)
1269 static ssize_t
sdebug_scsi_level_read(struct device_driver
* ddp
, char * buf
)
1271 return sprintf(buf
, "%d\n", scsi_debug_scsi_level
);
1273 DRIVER_ATTR(scsi_level
, S_IRUGO
, sdebug_scsi_level_read
, NULL
)
1275 static ssize_t
sdebug_add_host_read(struct device_driver
* ddp
, char * buf
)
1277 return sprintf(buf
, "%d\n", scsi_debug_add_host
);
1280 static ssize_t
sdebug_add_host_write(struct device_driver
* ddp
,
1281 const char * buf
, size_t count
)
1286 if (1 != sscanf(buf
, "%10s", work
))
1288 { /* temporary hack around sscanf() problem with -ve nums */
1293 if (1 != sscanf(work
+ neg
, "%d", &delta_hosts
))
1296 delta_hosts
= -delta_hosts
;
1298 if (delta_hosts
> 0) {
1300 for (k
= 0; k
< MAX_NUM_HOSTS
; ++k
) {
1301 if (NULL
== scsi_debug_hosts
[k
].shost
) {
1302 sdebug_add_shost(k
);
1306 if (k
== MAX_NUM_HOSTS
)
1308 ++scsi_debug_add_host
;
1309 } while (--delta_hosts
);
1310 } else if (delta_hosts
< 0) {
1312 for (k
= MAX_NUM_HOSTS
- 1; k
>= 0; --k
) {
1313 if (scsi_debug_hosts
[k
].shost
) {
1314 sdebug_remove_shost(k
);
1320 --scsi_debug_add_host
;
1321 } while (++delta_hosts
);
1325 DRIVER_ATTR(add_host
, S_IRUGO
| S_IWUSR
, sdebug_add_host_read
,
1326 sdebug_add_host_write
)
1328 static void do_create_driverfs_files()
1330 driver_create_file(&sdebug_driverfs_driver
, &driver_attr_delay
);
1331 driver_create_file(&sdebug_driverfs_driver
, &driver_attr_opts
);
1332 driver_create_file(&sdebug_driverfs_driver
, &driver_attr_num_devs
);
1333 driver_create_file(&sdebug_driverfs_driver
, &driver_attr_dev_size_mb
);
1334 driver_create_file(&sdebug_driverfs_driver
, &driver_attr_every_nth
);
1335 driver_create_file(&sdebug_driverfs_driver
, &driver_attr_max_luns
);
1336 driver_create_file(&sdebug_driverfs_driver
, &driver_attr_scsi_level
);
1337 driver_create_file(&sdebug_driverfs_driver
, &driver_attr_add_host
);
1340 static void do_remove_driverfs_files()
1342 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_add_host
);
1343 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_scsi_level
);
1344 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_max_luns
);
1345 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_every_nth
);
1346 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_dev_size_mb
);
1347 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_num_devs
);
1348 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_opts
);
1349 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_delay
);
1352 static void sdebug_add_shost(int num
)
1354 struct Scsi_Host
* hpnt
;
1357 if (sdebug_add_adapter(num
)){
1358 printk(KERN_ERR
"sdebug_add_shost: sdebug_add_adapter failed\n");
1361 hpnt
= scsi_register(&sdebug_driver_template
, 0);
1363 sdebug_remove_adapter(num
);
1364 printk(KERN_ERR
"sdebug_add_shost: scsi_register failed\n");
1367 err
= scsi_add_host(hpnt
, scsi_debug_hosts
[num
].dev
);
1369 printk(KERN_ERR
"sdebug_add_shost: scsi_add_host failed\n");
1370 scsi_unregister(hpnt
);
1371 sdebug_remove_adapter(num
);
1374 hpnt
->max_lun
= scsi_debug_max_luns
;
1376 scsi_debug_hosts
[num
].shost
= hpnt
;
1379 static void sdebug_remove_shost(int num
)
1381 scsi_remove_host(scsi_debug_hosts
[num
].shost
);
1382 scsi_unregister(scsi_debug_hosts
[num
].shost
);
1383 sdebug_remove_adapter(num
);
1384 scsi_debug_hosts
[num
].shost
= NULL
;
1387 static int __init
scsi_debug_init(void)
1392 sdebug_store_size
= (unsigned long)scsi_debug_dev_size_mb
* 1048576;
1393 sdebug_capacity
= sdebug_store_size
/ SECT_SIZE
;
1395 /* play around with geometry, don't waste too much on track 0 */
1397 sdebug_sectors_per
= 32;
1398 if (scsi_debug_dev_size_mb
>= 16)
1400 else if (scsi_debug_dev_size_mb
>= 256)
1402 sdebug_cylinders_per
= (unsigned long)sdebug_capacity
/
1403 (sdebug_sectors_per
* sdebug_heads
);
1404 if (sdebug_cylinders_per
>= 1024) {
1405 /* other LLDs do this; implies >= 1GB ram disk ... */
1407 sdebug_sectors_per
= 63;
1408 sdebug_cylinders_per
= (unsigned long)sdebug_capacity
/
1409 (sdebug_sectors_per
* sdebug_heads
);
1412 if (scsi_debug_num_devs
> 0) {
1413 sz
= sizeof(struct sdebug_dev_info
) * scsi_debug_num_devs
;
1414 devInfop
= vmalloc(sz
);
1415 if (NULL
== devInfop
) {
1416 printk(KERN_ERR
"scsi_debug_init: out of memory\n");
1419 memset(devInfop
, 0, sz
);
1422 sz
= sizeof(struct sdebug_host_info
) * MAX_NUM_HOSTS
;
1423 scsi_debug_hosts
= vmalloc(sz
);
1424 if (NULL
== scsi_debug_hosts
) {
1425 printk(KERN_ERR
"scsi_debug_init: out of memory 1\n");
1428 memset(scsi_debug_hosts
, 0, sz
);
1430 sz
= sdebug_store_size
;
1431 fake_storep
= vmalloc(sz
);
1432 if (NULL
== fake_storep
) {
1433 printk(KERN_ERR
"scsi_debug_init: out of memory, 1\n");
1438 memset(fake_storep
, 0, sz
);
1442 device_register(&pseudo_primary
);
1443 bus_register(&pseudo_lld_bus
);
1444 scsi_debug_register_driver(&sdebug_driverfs_driver
);
1445 do_create_driverfs_files();
1447 sdebug_driver_template
.proc_name
= (char *)sdebug_proc_name
;
1449 for (k
= 0; (k
< scsi_debug_add_host
) && (k
< MAX_NUM_HOSTS
); k
++) {
1450 sdebug_add_shost(k
);
1451 if (NULL
== scsi_debug_hosts
[k
].shost
) {
1452 printk(KERN_ERR
"scsi_debug_init: "
1453 "sdebug_add_shost failed k=%d\n", k
);
1457 scsi_debug_add_host
= k
; // number of hosts actually present
1459 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
) {
1460 printk(KERN_INFO
"scsi_debug: ... built %d host(s)\n",
1461 scsi_debug_add_host
);
1466 static void __exit
scsi_debug_exit(void)
1470 for (k
= MAX_NUM_HOSTS
- 1; k
>= 0; --k
) {
1471 if (scsi_debug_hosts
[k
].shost
) {
1472 sdebug_remove_shost(k
);
1476 do_remove_driverfs_files();
1477 scsi_debug_unregister_driver(&sdebug_driverfs_driver
);
1478 bus_unregister(&pseudo_lld_bus
);
1479 device_unregister(&pseudo_primary
);
1486 device_initcall(scsi_debug_init
);
1487 module_exit(scsi_debug_exit
);
1489 static struct device pseudo_primary
= {
1490 .name
= "Host/Pseudo Bridge",
1491 .bus_id
= "pseudo_0",
1494 static int pseudo_lld_bus_match(struct device
*dev
,
1495 struct device_driver
*dev_driver
)
1500 static struct bus_type pseudo_lld_bus
= {
1502 .match
= pseudo_lld_bus_match
,
1505 int scsi_debug_register_driver(struct device_driver
*dev_driver
)
1507 dev_driver
->bus
= &pseudo_lld_bus
;
1508 driver_register(dev_driver
);
1513 int scsi_debug_unregister_driver(struct device_driver
*dev_driver
)
1515 driver_unregister(dev_driver
);
1519 static int sdebug_add_adapter(int num
)
1521 struct device
* dev
;
1523 dev
= kmalloc(sizeof(*dev
),GFP_KERNEL
);
1525 printk(KERN_ERR
"%s: out of memory\n", __FUNCTION__
);
1529 memset(dev
, 0, sizeof(*dev
));
1530 dev
->bus
= &pseudo_lld_bus
;
1531 dev
->parent
= &pseudo_primary
;
1532 sprintf(dev
->name
, "scsi debug adapter");
1533 sprintf(dev
->bus_id
, "adapter%d", num
);
1535 device_register(dev
);
1537 scsi_debug_hosts
[num
].dev
= dev
;
1542 static void sdebug_remove_adapter(int num
)
1544 device_unregister(scsi_debug_hosts
[num
].dev
);