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://sg.danny.cz/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/slab.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/vmalloc.h>
41 #include <linux/moduleparam.h>
42 #include <linux/scatterlist.h>
43 #include <linux/blkdev.h>
44 #include <linux/crc-t10dif.h>
46 #include <net/checksum.h>
48 #include <asm/unaligned.h>
50 #include <scsi/scsi.h>
51 #include <scsi/scsi_cmnd.h>
52 #include <scsi/scsi_device.h>
53 #include <scsi/scsi_host.h>
54 #include <scsi/scsicam.h>
55 #include <scsi/scsi_eh.h>
56 #include <scsi/scsi_dbg.h>
59 #include "scsi_logging.h"
61 #define SCSI_DEBUG_VERSION "1.82"
62 static const char * scsi_debug_version_date
= "20100324";
64 /* Additional Sense Code (ASC) */
65 #define NO_ADDITIONAL_SENSE 0x0
66 #define LOGICAL_UNIT_NOT_READY 0x4
67 #define UNRECOVERED_READ_ERR 0x11
68 #define PARAMETER_LIST_LENGTH_ERR 0x1a
69 #define INVALID_OPCODE 0x20
70 #define ADDR_OUT_OF_RANGE 0x21
71 #define INVALID_COMMAND_OPCODE 0x20
72 #define INVALID_FIELD_IN_CDB 0x24
73 #define INVALID_FIELD_IN_PARAM_LIST 0x26
74 #define POWERON_RESET 0x29
75 #define SAVING_PARAMS_UNSUP 0x39
76 #define TRANSPORT_PROBLEM 0x4b
77 #define THRESHOLD_EXCEEDED 0x5d
78 #define LOW_POWER_COND_ON 0x5e
80 /* Additional Sense Code Qualifier (ASCQ) */
81 #define ACK_NAK_TO 0x3
83 #define SDEBUG_TAGGED_QUEUING 0 /* 0 | MSG_SIMPLE_TAG | MSG_ORDERED_TAG */
85 /* Default values for driver parameters */
86 #define DEF_NUM_HOST 1
87 #define DEF_NUM_TGTS 1
88 #define DEF_MAX_LUNS 1
89 /* With these defaults, this driver will make 1 host with 1 target
90 * (id 0) containing 1 logical unit (lun 0). That is 1 device.
94 #define DEF_DEV_SIZE_MB 8
98 #define DEF_EVERY_NTH 0
103 #define DEF_LBPWS10 0
104 #define DEF_LOWEST_ALIGNED 0
105 #define DEF_NO_LUN_0 0
106 #define DEF_NUM_PARTS 0
108 #define DEF_OPT_BLKS 64
109 #define DEF_PHYSBLK_EXP 0
111 #define DEF_SCSI_LEVEL 5 /* INQUIRY, byte2 [5->SPC-3] */
112 #define DEF_SECTOR_SIZE 512
113 #define DEF_UNMAP_ALIGNMENT 0
114 #define DEF_UNMAP_GRANULARITY 1
115 #define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF
116 #define DEF_UNMAP_MAX_DESC 256
117 #define DEF_VIRTUAL_GB 0
118 #define DEF_VPD_USE_HOSTNO 1
119 #define DEF_WRITESAME_LENGTH 0xFFFF
121 /* bit mask values for scsi_debug_opts */
122 #define SCSI_DEBUG_OPT_NOISE 1
123 #define SCSI_DEBUG_OPT_MEDIUM_ERR 2
124 #define SCSI_DEBUG_OPT_TIMEOUT 4
125 #define SCSI_DEBUG_OPT_RECOVERED_ERR 8
126 #define SCSI_DEBUG_OPT_TRANSPORT_ERR 16
127 #define SCSI_DEBUG_OPT_DIF_ERR 32
128 #define SCSI_DEBUG_OPT_DIX_ERR 64
129 #define SCSI_DEBUG_OPT_MAC_TIMEOUT 128
130 /* When "every_nth" > 0 then modulo "every_nth" commands:
131 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
132 * - a RECOVERED_ERROR is simulated on successful read and write
133 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
134 * - a TRANSPORT_ERROR is simulated on successful read and write
135 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
137 * When "every_nth" < 0 then after "- every_nth" commands:
138 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
139 * - a RECOVERED_ERROR is simulated on successful read and write
140 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
141 * - a TRANSPORT_ERROR is simulated on successful read and write
142 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
143 * This will continue until some other action occurs (e.g. the user
144 * writing a new value (other than -1 or 1) to every_nth via sysfs).
147 /* when 1==SCSI_DEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
148 * sector on read commands: */
149 #define OPT_MEDIUM_ERR_ADDR 0x1234 /* that's sector 4660 in decimal */
150 #define OPT_MEDIUM_ERR_NUM 10 /* number of consecutive medium errs */
152 /* If REPORT LUNS has luns >= 256 it can choose "flat space" (value 1)
153 * or "peripheral device" addressing (value 0) */
154 #define SAM2_LUN_ADDRESS_METHOD 0
155 #define SAM2_WLUN_REPORT_LUNS 0xc101
157 /* Can queue up to this number of commands. Typically commands that
158 * that have a non-zero delay are queued. */
159 #define SCSI_DEBUG_CANQUEUE 255
161 static int scsi_debug_add_host
= DEF_NUM_HOST
;
162 static int scsi_debug_ato
= DEF_ATO
;
163 static int scsi_debug_delay
= DEF_DELAY
;
164 static int scsi_debug_dev_size_mb
= DEF_DEV_SIZE_MB
;
165 static int scsi_debug_dif
= DEF_DIF
;
166 static int scsi_debug_dix
= DEF_DIX
;
167 static int scsi_debug_dsense
= DEF_D_SENSE
;
168 static int scsi_debug_every_nth
= DEF_EVERY_NTH
;
169 static int scsi_debug_fake_rw
= DEF_FAKE_RW
;
170 static int scsi_debug_guard
= DEF_GUARD
;
171 static int scsi_debug_lowest_aligned
= DEF_LOWEST_ALIGNED
;
172 static int scsi_debug_max_luns
= DEF_MAX_LUNS
;
173 static int scsi_debug_max_queue
= SCSI_DEBUG_CANQUEUE
;
174 static int scsi_debug_no_lun_0
= DEF_NO_LUN_0
;
175 static int scsi_debug_no_uld
= 0;
176 static int scsi_debug_num_parts
= DEF_NUM_PARTS
;
177 static int scsi_debug_num_tgts
= DEF_NUM_TGTS
; /* targets per host */
178 static int scsi_debug_opt_blks
= DEF_OPT_BLKS
;
179 static int scsi_debug_opts
= DEF_OPTS
;
180 static int scsi_debug_physblk_exp
= DEF_PHYSBLK_EXP
;
181 static int scsi_debug_ptype
= DEF_PTYPE
; /* SCSI peripheral type (0==disk) */
182 static int scsi_debug_scsi_level
= DEF_SCSI_LEVEL
;
183 static int scsi_debug_sector_size
= DEF_SECTOR_SIZE
;
184 static int scsi_debug_virtual_gb
= DEF_VIRTUAL_GB
;
185 static int scsi_debug_vpd_use_hostno
= DEF_VPD_USE_HOSTNO
;
186 static unsigned int scsi_debug_lbpu
= DEF_LBPU
;
187 static unsigned int scsi_debug_lbpws
= DEF_LBPWS
;
188 static unsigned int scsi_debug_lbpws10
= DEF_LBPWS10
;
189 static unsigned int scsi_debug_unmap_alignment
= DEF_UNMAP_ALIGNMENT
;
190 static unsigned int scsi_debug_unmap_granularity
= DEF_UNMAP_GRANULARITY
;
191 static unsigned int scsi_debug_unmap_max_blocks
= DEF_UNMAP_MAX_BLOCKS
;
192 static unsigned int scsi_debug_unmap_max_desc
= DEF_UNMAP_MAX_DESC
;
193 static unsigned int scsi_debug_write_same_length
= DEF_WRITESAME_LENGTH
;
195 static int scsi_debug_cmnd_count
= 0;
197 #define DEV_READONLY(TGT) (0)
198 #define DEV_REMOVEABLE(TGT) (0)
200 static unsigned int sdebug_store_sectors
;
201 static sector_t sdebug_capacity
; /* in sectors */
203 /* old BIOS stuff, kernel may get rid of them but some mode sense pages
204 may still need them */
205 static int sdebug_heads
; /* heads per disk */
206 static int sdebug_cylinders_per
; /* cylinders per surface */
207 static int sdebug_sectors_per
; /* sectors per cylinder */
209 #define SDEBUG_MAX_PARTS 4
211 #define SDEBUG_SENSE_LEN 32
213 #define SCSI_DEBUG_MAX_CMD_LEN 32
215 static unsigned int scsi_debug_lbp(void)
217 return scsi_debug_lbpu
| scsi_debug_lbpws
| scsi_debug_lbpws10
;
220 struct sdebug_dev_info
{
221 struct list_head dev_list
;
222 unsigned char sense_buff
[SDEBUG_SENSE_LEN
]; /* weak nexus */
223 unsigned int channel
;
226 struct sdebug_host_info
*sdbg_host
;
233 struct sdebug_host_info
{
234 struct list_head host_list
;
235 struct Scsi_Host
*shost
;
237 struct list_head dev_info_list
;
240 #define to_sdebug_host(d) \
241 container_of(d, struct sdebug_host_info, dev)
243 static LIST_HEAD(sdebug_host_list
);
244 static DEFINE_SPINLOCK(sdebug_host_list_lock
);
246 typedef void (* done_funct_t
) (struct scsi_cmnd
*);
248 struct sdebug_queued_cmd
{
250 struct timer_list cmnd_timer
;
251 done_funct_t done_funct
;
252 struct scsi_cmnd
* a_cmnd
;
255 static struct sdebug_queued_cmd queued_arr
[SCSI_DEBUG_CANQUEUE
];
257 static unsigned char * fake_storep
; /* ramdisk storage */
258 static unsigned char *dif_storep
; /* protection info */
259 static void *map_storep
; /* provisioning map */
261 static unsigned long map_size
;
262 static int num_aborts
= 0;
263 static int num_dev_resets
= 0;
264 static int num_bus_resets
= 0;
265 static int num_host_resets
= 0;
266 static int dix_writes
;
267 static int dix_reads
;
268 static int dif_errors
;
270 static DEFINE_SPINLOCK(queued_arr_lock
);
271 static DEFINE_RWLOCK(atomic_rw
);
273 static char sdebug_proc_name
[] = "scsi_debug";
275 static struct bus_type pseudo_lld_bus
;
277 static inline sector_t
dif_offset(sector_t sector
)
282 static struct device_driver sdebug_driverfs_driver
= {
283 .name
= sdebug_proc_name
,
284 .bus
= &pseudo_lld_bus
,
287 static const int check_condition_result
=
288 (DRIVER_SENSE
<< 24) | SAM_STAT_CHECK_CONDITION
;
290 static const int illegal_condition_result
=
291 (DRIVER_SENSE
<< 24) | (DID_ABORT
<< 16) | SAM_STAT_CHECK_CONDITION
;
293 static unsigned char ctrl_m_pg
[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
295 static unsigned char iec_m_pg
[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
298 static int sdebug_add_adapter(void);
299 static void sdebug_remove_adapter(void);
301 static void sdebug_max_tgts_luns(void)
303 struct sdebug_host_info
*sdbg_host
;
304 struct Scsi_Host
*hpnt
;
306 spin_lock(&sdebug_host_list_lock
);
307 list_for_each_entry(sdbg_host
, &sdebug_host_list
, host_list
) {
308 hpnt
= sdbg_host
->shost
;
309 if ((hpnt
->this_id
>= 0) &&
310 (scsi_debug_num_tgts
> hpnt
->this_id
))
311 hpnt
->max_id
= scsi_debug_num_tgts
+ 1;
313 hpnt
->max_id
= scsi_debug_num_tgts
;
314 /* scsi_debug_max_luns; */
315 hpnt
->max_lun
= SAM2_WLUN_REPORT_LUNS
;
317 spin_unlock(&sdebug_host_list_lock
);
320 static void mk_sense_buffer(struct sdebug_dev_info
*devip
, int key
,
323 unsigned char *sbuff
;
325 sbuff
= devip
->sense_buff
;
326 memset(sbuff
, 0, SDEBUG_SENSE_LEN
);
328 scsi_build_sense_buffer(scsi_debug_dsense
, sbuff
, key
, asc
, asq
);
330 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
331 printk(KERN_INFO
"scsi_debug: [sense_key,asc,ascq]: "
332 "[0x%x,0x%x,0x%x]\n", key
, asc
, asq
);
335 static void get_data_transfer_info(unsigned char *cmd
,
336 unsigned long long *lba
, unsigned int *num
,
342 case VARIABLE_LENGTH_CMD
:
343 *lba
= (u64
)cmd
[19] | (u64
)cmd
[18] << 8 |
344 (u64
)cmd
[17] << 16 | (u64
)cmd
[16] << 24 |
345 (u64
)cmd
[15] << 32 | (u64
)cmd
[14] << 40 |
346 (u64
)cmd
[13] << 48 | (u64
)cmd
[12] << 56;
348 *ei_lba
= (u32
)cmd
[23] | (u32
)cmd
[22] << 8 |
349 (u32
)cmd
[21] << 16 | (u32
)cmd
[20] << 24;
351 *num
= (u32
)cmd
[31] | (u32
)cmd
[30] << 8 | (u32
)cmd
[29] << 16 |
358 *lba
= (u64
)cmd
[9] | (u64
)cmd
[8] << 8 |
359 (u64
)cmd
[7] << 16 | (u64
)cmd
[6] << 24 |
360 (u64
)cmd
[5] << 32 | (u64
)cmd
[4] << 40 |
361 (u64
)cmd
[3] << 48 | (u64
)cmd
[2] << 56;
363 *num
= (u32
)cmd
[13] | (u32
)cmd
[12] << 8 | (u32
)cmd
[11] << 16 |
368 *lba
= (u32
)cmd
[5] | (u32
)cmd
[4] << 8 | (u32
)cmd
[3] << 16 |
371 *num
= (u32
)cmd
[9] | (u32
)cmd
[8] << 8 | (u32
)cmd
[7] << 16 |
378 *lba
= (u32
)cmd
[5] | (u32
)cmd
[4] << 8 | (u32
)cmd
[3] << 16 |
381 *num
= (u32
)cmd
[8] | (u32
)cmd
[7] << 8;
385 *lba
= (u32
)cmd
[3] | (u32
)cmd
[2] << 8 |
386 (u32
)(cmd
[1] & 0x1f) << 16;
387 *num
= (0 == cmd
[4]) ? 256 : cmd
[4];
394 static int scsi_debug_ioctl(struct scsi_device
*dev
, int cmd
, void __user
*arg
)
396 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
) {
397 printk(KERN_INFO
"scsi_debug: ioctl: cmd=0x%x\n", cmd
);
400 /* return -ENOTTY; // correct return but upsets fdisk */
403 static int check_readiness(struct scsi_cmnd
* SCpnt
, int reset_only
,
404 struct sdebug_dev_info
* devip
)
407 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
408 printk(KERN_INFO
"scsi_debug: Reporting Unit "
409 "attention: power on reset\n");
411 mk_sense_buffer(devip
, UNIT_ATTENTION
, POWERON_RESET
, 0);
412 return check_condition_result
;
414 if ((0 == reset_only
) && devip
->stopped
) {
415 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
416 printk(KERN_INFO
"scsi_debug: Reporting Not "
417 "ready: initializing command required\n");
418 mk_sense_buffer(devip
, NOT_READY
, LOGICAL_UNIT_NOT_READY
,
420 return check_condition_result
;
425 /* Returns 0 if ok else (DID_ERROR << 16). Sets scp->resid . */
426 static int fill_from_dev_buffer(struct scsi_cmnd
*scp
, unsigned char *arr
,
430 struct scsi_data_buffer
*sdb
= scsi_in(scp
);
434 if (!(scsi_bidi_cmnd(scp
) || scp
->sc_data_direction
== DMA_FROM_DEVICE
))
435 return (DID_ERROR
<< 16);
437 act_len
= sg_copy_from_buffer(sdb
->table
.sgl
, sdb
->table
.nents
,
440 sdb
->resid
-= act_len
;
442 sdb
->resid
= scsi_bufflen(scp
) - act_len
;
447 /* Returns number of bytes fetched into 'arr' or -1 if error. */
448 static int fetch_to_dev_buffer(struct scsi_cmnd
*scp
, unsigned char *arr
,
451 if (!scsi_bufflen(scp
))
453 if (!(scsi_bidi_cmnd(scp
) || scp
->sc_data_direction
== DMA_TO_DEVICE
))
456 return scsi_sg_copy_to_buffer(scp
, arr
, arr_len
);
460 static const char * inq_vendor_id
= "Linux ";
461 static const char * inq_product_id
= "scsi_debug ";
462 static const char * inq_product_rev
= "0004";
464 static int inquiry_evpd_83(unsigned char * arr
, int port_group_id
,
465 int target_dev_id
, int dev_id_num
,
466 const char * dev_id_str
,
472 port_a
= target_dev_id
+ 1;
473 /* T10 vendor identifier field format (faked) */
474 arr
[0] = 0x2; /* ASCII */
477 memcpy(&arr
[4], inq_vendor_id
, 8);
478 memcpy(&arr
[12], inq_product_id
, 16);
479 memcpy(&arr
[28], dev_id_str
, dev_id_str_len
);
480 num
= 8 + 16 + dev_id_str_len
;
483 if (dev_id_num
>= 0) {
484 /* NAA-5, Logical unit identifier (binary) */
485 arr
[num
++] = 0x1; /* binary (not necessarily sas) */
486 arr
[num
++] = 0x3; /* PIV=0, lu, naa */
489 arr
[num
++] = 0x53; /* naa-5 ieee company id=0x333333 (fake) */
493 arr
[num
++] = (dev_id_num
>> 24);
494 arr
[num
++] = (dev_id_num
>> 16) & 0xff;
495 arr
[num
++] = (dev_id_num
>> 8) & 0xff;
496 arr
[num
++] = dev_id_num
& 0xff;
497 /* Target relative port number */
498 arr
[num
++] = 0x61; /* proto=sas, binary */
499 arr
[num
++] = 0x94; /* PIV=1, target port, rel port */
500 arr
[num
++] = 0x0; /* reserved */
501 arr
[num
++] = 0x4; /* length */
502 arr
[num
++] = 0x0; /* reserved */
503 arr
[num
++] = 0x0; /* reserved */
505 arr
[num
++] = 0x1; /* relative port A */
507 /* NAA-5, Target port identifier */
508 arr
[num
++] = 0x61; /* proto=sas, binary */
509 arr
[num
++] = 0x93; /* piv=1, target port, naa */
512 arr
[num
++] = 0x52; /* naa-5, company id=0x222222 (fake) */
516 arr
[num
++] = (port_a
>> 24);
517 arr
[num
++] = (port_a
>> 16) & 0xff;
518 arr
[num
++] = (port_a
>> 8) & 0xff;
519 arr
[num
++] = port_a
& 0xff;
520 /* NAA-5, Target port group identifier */
521 arr
[num
++] = 0x61; /* proto=sas, binary */
522 arr
[num
++] = 0x95; /* piv=1, target port group id */
527 arr
[num
++] = (port_group_id
>> 8) & 0xff;
528 arr
[num
++] = port_group_id
& 0xff;
529 /* NAA-5, Target device identifier */
530 arr
[num
++] = 0x61; /* proto=sas, binary */
531 arr
[num
++] = 0xa3; /* piv=1, target device, naa */
534 arr
[num
++] = 0x52; /* naa-5, company id=0x222222 (fake) */
538 arr
[num
++] = (target_dev_id
>> 24);
539 arr
[num
++] = (target_dev_id
>> 16) & 0xff;
540 arr
[num
++] = (target_dev_id
>> 8) & 0xff;
541 arr
[num
++] = target_dev_id
& 0xff;
542 /* SCSI name string: Target device identifier */
543 arr
[num
++] = 0x63; /* proto=sas, UTF-8 */
544 arr
[num
++] = 0xa8; /* piv=1, target device, SCSI name string */
547 memcpy(arr
+ num
, "naa.52222220", 12);
549 snprintf(b
, sizeof(b
), "%08X", target_dev_id
);
550 memcpy(arr
+ num
, b
, 8);
552 memset(arr
+ num
, 0, 4);
558 static unsigned char vpd84_data
[] = {
559 /* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
560 0x22,0x22,0x22,0x0,0xbb,0x1,
561 0x22,0x22,0x22,0x0,0xbb,0x2,
564 static int inquiry_evpd_84(unsigned char * arr
)
566 memcpy(arr
, vpd84_data
, sizeof(vpd84_data
));
567 return sizeof(vpd84_data
);
570 static int inquiry_evpd_85(unsigned char * arr
)
573 const char * na1
= "https://www.kernel.org/config";
574 const char * na2
= "http://www.kernel.org/log";
577 arr
[num
++] = 0x1; /* lu, storage config */
578 arr
[num
++] = 0x0; /* reserved */
583 plen
= ((plen
/ 4) + 1) * 4;
584 arr
[num
++] = plen
; /* length, null termianted, padded */
585 memcpy(arr
+ num
, na1
, olen
);
586 memset(arr
+ num
+ olen
, 0, plen
- olen
);
589 arr
[num
++] = 0x4; /* lu, logging */
590 arr
[num
++] = 0x0; /* reserved */
595 plen
= ((plen
/ 4) + 1) * 4;
596 arr
[num
++] = plen
; /* length, null terminated, padded */
597 memcpy(arr
+ num
, na2
, olen
);
598 memset(arr
+ num
+ olen
, 0, plen
- olen
);
604 /* SCSI ports VPD page */
605 static int inquiry_evpd_88(unsigned char * arr
, int target_dev_id
)
610 port_a
= target_dev_id
+ 1;
612 arr
[num
++] = 0x0; /* reserved */
613 arr
[num
++] = 0x0; /* reserved */
615 arr
[num
++] = 0x1; /* relative port 1 (primary) */
616 memset(arr
+ num
, 0, 6);
619 arr
[num
++] = 12; /* length tp descriptor */
620 /* naa-5 target port identifier (A) */
621 arr
[num
++] = 0x61; /* proto=sas, binary */
622 arr
[num
++] = 0x93; /* PIV=1, target port, NAA */
623 arr
[num
++] = 0x0; /* reserved */
624 arr
[num
++] = 0x8; /* length */
625 arr
[num
++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
629 arr
[num
++] = (port_a
>> 24);
630 arr
[num
++] = (port_a
>> 16) & 0xff;
631 arr
[num
++] = (port_a
>> 8) & 0xff;
632 arr
[num
++] = port_a
& 0xff;
634 arr
[num
++] = 0x0; /* reserved */
635 arr
[num
++] = 0x0; /* reserved */
637 arr
[num
++] = 0x2; /* relative port 2 (secondary) */
638 memset(arr
+ num
, 0, 6);
641 arr
[num
++] = 12; /* length tp descriptor */
642 /* naa-5 target port identifier (B) */
643 arr
[num
++] = 0x61; /* proto=sas, binary */
644 arr
[num
++] = 0x93; /* PIV=1, target port, NAA */
645 arr
[num
++] = 0x0; /* reserved */
646 arr
[num
++] = 0x8; /* length */
647 arr
[num
++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
651 arr
[num
++] = (port_b
>> 24);
652 arr
[num
++] = (port_b
>> 16) & 0xff;
653 arr
[num
++] = (port_b
>> 8) & 0xff;
654 arr
[num
++] = port_b
& 0xff;
660 static unsigned char vpd89_data
[] = {
661 /* from 4th byte */ 0,0,0,0,
662 'l','i','n','u','x',' ',' ',' ',
663 'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
665 0x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
667 0x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
668 0,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
669 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
670 0x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
672 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
674 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
676 0,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
677 0x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
678 0x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
679 0,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
680 0x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
681 0x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
682 0,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
683 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
684 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
685 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
686 0x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
687 0,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
688 0xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
689 0,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
690 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
691 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
692 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
693 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
694 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
695 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
696 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
697 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
698 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
699 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
700 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
701 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
704 static int inquiry_evpd_89(unsigned char * arr
)
706 memcpy(arr
, vpd89_data
, sizeof(vpd89_data
));
707 return sizeof(vpd89_data
);
711 /* Block limits VPD page (SBC-3) */
712 static unsigned char vpdb0_data
[] = {
713 /* from 4th byte */ 0,0,0,4, 0,0,0x4,0, 0,0,0,64,
714 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
715 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
716 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
719 static int inquiry_evpd_b0(unsigned char * arr
)
723 memcpy(arr
, vpdb0_data
, sizeof(vpdb0_data
));
725 /* Optimal transfer length granularity */
726 gran
= 1 << scsi_debug_physblk_exp
;
727 arr
[2] = (gran
>> 8) & 0xff;
728 arr
[3] = gran
& 0xff;
730 /* Maximum Transfer Length */
731 if (sdebug_store_sectors
> 0x400) {
732 arr
[4] = (sdebug_store_sectors
>> 24) & 0xff;
733 arr
[5] = (sdebug_store_sectors
>> 16) & 0xff;
734 arr
[6] = (sdebug_store_sectors
>> 8) & 0xff;
735 arr
[7] = sdebug_store_sectors
& 0xff;
738 /* Optimal Transfer Length */
739 put_unaligned_be32(scsi_debug_opt_blks
, &arr
[8]);
741 if (scsi_debug_lbpu
) {
742 /* Maximum Unmap LBA Count */
743 put_unaligned_be32(scsi_debug_unmap_max_blocks
, &arr
[16]);
745 /* Maximum Unmap Block Descriptor Count */
746 put_unaligned_be32(scsi_debug_unmap_max_desc
, &arr
[20]);
749 /* Unmap Granularity Alignment */
750 if (scsi_debug_unmap_alignment
) {
751 put_unaligned_be32(scsi_debug_unmap_alignment
, &arr
[28]);
752 arr
[28] |= 0x80; /* UGAVALID */
755 /* Optimal Unmap Granularity */
756 put_unaligned_be32(scsi_debug_unmap_granularity
, &arr
[24]);
758 /* Maximum WRITE SAME Length */
759 put_unaligned_be64(scsi_debug_write_same_length
, &arr
[32]);
761 return 0x3c; /* Mandatory page length for Logical Block Provisioning */
763 return sizeof(vpdb0_data
);
766 /* Block device characteristics VPD page (SBC-3) */
767 static int inquiry_evpd_b1(unsigned char *arr
)
769 memset(arr
, 0, 0x3c);
771 arr
[1] = 1; /* non rotating medium (e.g. solid state) */
773 arr
[3] = 5; /* less than 1.8" */
778 /* Thin provisioning VPD page (SBC-3) */
779 static int inquiry_evpd_b2(unsigned char *arr
)
782 arr
[0] = 0; /* threshold exponent */
787 if (scsi_debug_lbpws
)
790 if (scsi_debug_lbpws10
)
796 #define SDEBUG_LONG_INQ_SZ 96
797 #define SDEBUG_MAX_INQ_ARR_SZ 584
799 static int resp_inquiry(struct scsi_cmnd
* scp
, int target
,
800 struct sdebug_dev_info
* devip
)
802 unsigned char pq_pdt
;
804 unsigned char *cmd
= (unsigned char *)scp
->cmnd
;
805 int alloc_len
, n
, ret
;
807 alloc_len
= (cmd
[3] << 8) + cmd
[4];
808 arr
= kzalloc(SDEBUG_MAX_INQ_ARR_SZ
, GFP_ATOMIC
);
810 return DID_REQUEUE
<< 16;
812 pq_pdt
= 0x1e; /* present, wlun */
813 else if (scsi_debug_no_lun_0
&& (0 == devip
->lun
))
814 pq_pdt
= 0x7f; /* not present, no device type */
816 pq_pdt
= (scsi_debug_ptype
& 0x1f);
818 if (0x2 & cmd
[1]) { /* CMDDT bit set */
819 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, INVALID_FIELD_IN_CDB
,
822 return check_condition_result
;
823 } else if (0x1 & cmd
[1]) { /* EVPD bit set */
824 int lu_id_num
, port_group_id
, target_dev_id
, len
;
826 int host_no
= devip
->sdbg_host
->shost
->host_no
;
828 port_group_id
= (((host_no
+ 1) & 0x7f) << 8) +
829 (devip
->channel
& 0x7f);
830 if (0 == scsi_debug_vpd_use_hostno
)
832 lu_id_num
= devip
->wlun
? -1 : (((host_no
+ 1) * 2000) +
833 (devip
->target
* 1000) + devip
->lun
);
834 target_dev_id
= ((host_no
+ 1) * 2000) +
835 (devip
->target
* 1000) - 3;
836 len
= scnprintf(lu_id_str
, 6, "%d", lu_id_num
);
837 if (0 == cmd
[2]) { /* supported vital product data pages */
838 arr
[1] = cmd
[2]; /*sanity */
840 arr
[n
++] = 0x0; /* this page */
841 arr
[n
++] = 0x80; /* unit serial number */
842 arr
[n
++] = 0x83; /* device identification */
843 arr
[n
++] = 0x84; /* software interface ident. */
844 arr
[n
++] = 0x85; /* management network addresses */
845 arr
[n
++] = 0x86; /* extended inquiry */
846 arr
[n
++] = 0x87; /* mode page policy */
847 arr
[n
++] = 0x88; /* SCSI ports */
848 arr
[n
++] = 0x89; /* ATA information */
849 arr
[n
++] = 0xb0; /* Block limits (SBC) */
850 arr
[n
++] = 0xb1; /* Block characteristics (SBC) */
851 if (scsi_debug_lbp()) /* Logical Block Prov. (SBC) */
853 arr
[3] = n
- 4; /* number of supported VPD pages */
854 } else if (0x80 == cmd
[2]) { /* unit serial number */
855 arr
[1] = cmd
[2]; /*sanity */
857 memcpy(&arr
[4], lu_id_str
, len
);
858 } else if (0x83 == cmd
[2]) { /* device identification */
859 arr
[1] = cmd
[2]; /*sanity */
860 arr
[3] = inquiry_evpd_83(&arr
[4], port_group_id
,
861 target_dev_id
, lu_id_num
,
863 } else if (0x84 == cmd
[2]) { /* Software interface ident. */
864 arr
[1] = cmd
[2]; /*sanity */
865 arr
[3] = inquiry_evpd_84(&arr
[4]);
866 } else if (0x85 == cmd
[2]) { /* Management network addresses */
867 arr
[1] = cmd
[2]; /*sanity */
868 arr
[3] = inquiry_evpd_85(&arr
[4]);
869 } else if (0x86 == cmd
[2]) { /* extended inquiry */
870 arr
[1] = cmd
[2]; /*sanity */
871 arr
[3] = 0x3c; /* number of following entries */
872 if (scsi_debug_dif
== SD_DIF_TYPE3_PROTECTION
)
873 arr
[4] = 0x4; /* SPT: GRD_CHK:1 */
874 else if (scsi_debug_dif
)
875 arr
[4] = 0x5; /* SPT: GRD_CHK:1, REF_CHK:1 */
877 arr
[4] = 0x0; /* no protection stuff */
878 arr
[5] = 0x7; /* head of q, ordered + simple q's */
879 } else if (0x87 == cmd
[2]) { /* mode page policy */
880 arr
[1] = cmd
[2]; /*sanity */
881 arr
[3] = 0x8; /* number of following entries */
882 arr
[4] = 0x2; /* disconnect-reconnect mp */
883 arr
[6] = 0x80; /* mlus, shared */
884 arr
[8] = 0x18; /* protocol specific lu */
885 arr
[10] = 0x82; /* mlus, per initiator port */
886 } else if (0x88 == cmd
[2]) { /* SCSI Ports */
887 arr
[1] = cmd
[2]; /*sanity */
888 arr
[3] = inquiry_evpd_88(&arr
[4], target_dev_id
);
889 } else if (0x89 == cmd
[2]) { /* ATA information */
890 arr
[1] = cmd
[2]; /*sanity */
891 n
= inquiry_evpd_89(&arr
[4]);
894 } else if (0xb0 == cmd
[2]) { /* Block limits (SBC) */
895 arr
[1] = cmd
[2]; /*sanity */
896 arr
[3] = inquiry_evpd_b0(&arr
[4]);
897 } else if (0xb1 == cmd
[2]) { /* Block characteristics (SBC) */
898 arr
[1] = cmd
[2]; /*sanity */
899 arr
[3] = inquiry_evpd_b1(&arr
[4]);
900 } else if (0xb2 == cmd
[2]) { /* Logical Block Prov. (SBC) */
901 arr
[1] = cmd
[2]; /*sanity */
902 arr
[3] = inquiry_evpd_b2(&arr
[4]);
904 /* Illegal request, invalid field in cdb */
905 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
906 INVALID_FIELD_IN_CDB
, 0);
908 return check_condition_result
;
910 len
= min(((arr
[2] << 8) + arr
[3]) + 4, alloc_len
);
911 ret
= fill_from_dev_buffer(scp
, arr
,
912 min(len
, SDEBUG_MAX_INQ_ARR_SZ
));
916 /* drops through here for a standard inquiry */
917 arr
[1] = DEV_REMOVEABLE(target
) ? 0x80 : 0; /* Removable disk */
918 arr
[2] = scsi_debug_scsi_level
;
919 arr
[3] = 2; /* response_data_format==2 */
920 arr
[4] = SDEBUG_LONG_INQ_SZ
- 5;
921 arr
[5] = scsi_debug_dif
? 1 : 0; /* PROTECT bit */
922 if (0 == scsi_debug_vpd_use_hostno
)
923 arr
[5] = 0x10; /* claim: implicit TGPS */
924 arr
[6] = 0x10; /* claim: MultiP */
925 /* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
926 arr
[7] = 0xa; /* claim: LINKED + CMDQUE */
927 memcpy(&arr
[8], inq_vendor_id
, 8);
928 memcpy(&arr
[16], inq_product_id
, 16);
929 memcpy(&arr
[32], inq_product_rev
, 4);
930 /* version descriptors (2 bytes each) follow */
931 arr
[58] = 0x0; arr
[59] = 0x77; /* SAM-3 ANSI */
932 arr
[60] = 0x3; arr
[61] = 0x14; /* SPC-3 ANSI */
934 if (scsi_debug_ptype
== 0) {
935 arr
[n
++] = 0x3; arr
[n
++] = 0x3d; /* SBC-2 ANSI */
936 } else if (scsi_debug_ptype
== 1) {
937 arr
[n
++] = 0x3; arr
[n
++] = 0x60; /* SSC-2 no version */
939 arr
[n
++] = 0xc; arr
[n
++] = 0xf; /* SAS-1.1 rev 10 */
940 ret
= fill_from_dev_buffer(scp
, arr
,
941 min(alloc_len
, SDEBUG_LONG_INQ_SZ
));
946 static int resp_requests(struct scsi_cmnd
* scp
,
947 struct sdebug_dev_info
* devip
)
949 unsigned char * sbuff
;
950 unsigned char *cmd
= (unsigned char *)scp
->cmnd
;
951 unsigned char arr
[SDEBUG_SENSE_LEN
];
955 memset(arr
, 0, sizeof(arr
));
956 if (devip
->reset
== 1)
957 mk_sense_buffer(devip
, 0, NO_ADDITIONAL_SENSE
, 0);
958 want_dsense
= !!(cmd
[1] & 1) || scsi_debug_dsense
;
959 sbuff
= devip
->sense_buff
;
960 if ((iec_m_pg
[2] & 0x4) && (6 == (iec_m_pg
[3] & 0xf))) {
963 arr
[1] = 0x0; /* NO_SENSE in sense_key */
964 arr
[2] = THRESHOLD_EXCEEDED
;
965 arr
[3] = 0xff; /* TEST set and MRIE==6 */
968 arr
[2] = 0x0; /* NO_SENSE in sense_key */
969 arr
[7] = 0xa; /* 18 byte sense buffer */
970 arr
[12] = THRESHOLD_EXCEEDED
;
971 arr
[13] = 0xff; /* TEST set and MRIE==6 */
974 memcpy(arr
, sbuff
, SDEBUG_SENSE_LEN
);
975 if ((cmd
[1] & 1) && (! scsi_debug_dsense
)) {
976 /* DESC bit set and sense_buff in fixed format */
977 memset(arr
, 0, sizeof(arr
));
979 arr
[1] = sbuff
[2]; /* sense key */
980 arr
[2] = sbuff
[12]; /* asc */
981 arr
[3] = sbuff
[13]; /* ascq */
985 mk_sense_buffer(devip
, 0, NO_ADDITIONAL_SENSE
, 0);
986 return fill_from_dev_buffer(scp
, arr
, len
);
989 static int resp_start_stop(struct scsi_cmnd
* scp
,
990 struct sdebug_dev_info
* devip
)
992 unsigned char *cmd
= (unsigned char *)scp
->cmnd
;
993 int power_cond
, errsts
, start
;
995 if ((errsts
= check_readiness(scp
, 1, devip
)))
997 power_cond
= (cmd
[4] & 0xf0) >> 4;
999 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, INVALID_FIELD_IN_CDB
,
1001 return check_condition_result
;
1004 if (start
== devip
->stopped
)
1005 devip
->stopped
= !start
;
1009 static sector_t
get_sdebug_capacity(void)
1011 if (scsi_debug_virtual_gb
> 0)
1012 return (sector_t
)scsi_debug_virtual_gb
*
1013 (1073741824 / scsi_debug_sector_size
);
1015 return sdebug_store_sectors
;
1018 #define SDEBUG_READCAP_ARR_SZ 8
1019 static int resp_readcap(struct scsi_cmnd
* scp
,
1020 struct sdebug_dev_info
* devip
)
1022 unsigned char arr
[SDEBUG_READCAP_ARR_SZ
];
1026 if ((errsts
= check_readiness(scp
, 1, devip
)))
1028 /* following just in case virtual_gb changed */
1029 sdebug_capacity
= get_sdebug_capacity();
1030 memset(arr
, 0, SDEBUG_READCAP_ARR_SZ
);
1031 if (sdebug_capacity
< 0xffffffff) {
1032 capac
= (unsigned int)sdebug_capacity
- 1;
1033 arr
[0] = (capac
>> 24);
1034 arr
[1] = (capac
>> 16) & 0xff;
1035 arr
[2] = (capac
>> 8) & 0xff;
1036 arr
[3] = capac
& 0xff;
1043 arr
[6] = (scsi_debug_sector_size
>> 8) & 0xff;
1044 arr
[7] = scsi_debug_sector_size
& 0xff;
1045 return fill_from_dev_buffer(scp
, arr
, SDEBUG_READCAP_ARR_SZ
);
1048 #define SDEBUG_READCAP16_ARR_SZ 32
1049 static int resp_readcap16(struct scsi_cmnd
* scp
,
1050 struct sdebug_dev_info
* devip
)
1052 unsigned char *cmd
= (unsigned char *)scp
->cmnd
;
1053 unsigned char arr
[SDEBUG_READCAP16_ARR_SZ
];
1054 unsigned long long capac
;
1055 int errsts
, k
, alloc_len
;
1057 if ((errsts
= check_readiness(scp
, 1, devip
)))
1059 alloc_len
= ((cmd
[10] << 24) + (cmd
[11] << 16) + (cmd
[12] << 8)
1061 /* following just in case virtual_gb changed */
1062 sdebug_capacity
= get_sdebug_capacity();
1063 memset(arr
, 0, SDEBUG_READCAP16_ARR_SZ
);
1064 capac
= sdebug_capacity
- 1;
1065 for (k
= 0; k
< 8; ++k
, capac
>>= 8)
1066 arr
[7 - k
] = capac
& 0xff;
1067 arr
[8] = (scsi_debug_sector_size
>> 24) & 0xff;
1068 arr
[9] = (scsi_debug_sector_size
>> 16) & 0xff;
1069 arr
[10] = (scsi_debug_sector_size
>> 8) & 0xff;
1070 arr
[11] = scsi_debug_sector_size
& 0xff;
1071 arr
[13] = scsi_debug_physblk_exp
& 0xf;
1072 arr
[14] = (scsi_debug_lowest_aligned
>> 8) & 0x3f;
1074 if (scsi_debug_lbp())
1075 arr
[14] |= 0x80; /* LBPME */
1077 arr
[15] = scsi_debug_lowest_aligned
& 0xff;
1079 if (scsi_debug_dif
) {
1080 arr
[12] = (scsi_debug_dif
- 1) << 1; /* P_TYPE */
1081 arr
[12] |= 1; /* PROT_EN */
1084 return fill_from_dev_buffer(scp
, arr
,
1085 min(alloc_len
, SDEBUG_READCAP16_ARR_SZ
));
1088 #define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
1090 static int resp_report_tgtpgs(struct scsi_cmnd
* scp
,
1091 struct sdebug_dev_info
* devip
)
1093 unsigned char *cmd
= (unsigned char *)scp
->cmnd
;
1094 unsigned char * arr
;
1095 int host_no
= devip
->sdbg_host
->shost
->host_no
;
1096 int n
, ret
, alen
, rlen
;
1097 int port_group_a
, port_group_b
, port_a
, port_b
;
1099 alen
= ((cmd
[6] << 24) + (cmd
[7] << 16) + (cmd
[8] << 8)
1102 arr
= kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ
, GFP_ATOMIC
);
1104 return DID_REQUEUE
<< 16;
1106 * EVPD page 0x88 states we have two ports, one
1107 * real and a fake port with no device connected.
1108 * So we create two port groups with one port each
1109 * and set the group with port B to unavailable.
1111 port_a
= 0x1; /* relative port A */
1112 port_b
= 0x2; /* relative port B */
1113 port_group_a
= (((host_no
+ 1) & 0x7f) << 8) +
1114 (devip
->channel
& 0x7f);
1115 port_group_b
= (((host_no
+ 1) & 0x7f) << 8) +
1116 (devip
->channel
& 0x7f) + 0x80;
1119 * The asymmetric access state is cycled according to the host_id.
1122 if (0 == scsi_debug_vpd_use_hostno
) {
1123 arr
[n
++] = host_no
% 3; /* Asymm access state */
1124 arr
[n
++] = 0x0F; /* claim: all states are supported */
1126 arr
[n
++] = 0x0; /* Active/Optimized path */
1127 arr
[n
++] = 0x01; /* claim: only support active/optimized paths */
1129 arr
[n
++] = (port_group_a
>> 8) & 0xff;
1130 arr
[n
++] = port_group_a
& 0xff;
1131 arr
[n
++] = 0; /* Reserved */
1132 arr
[n
++] = 0; /* Status code */
1133 arr
[n
++] = 0; /* Vendor unique */
1134 arr
[n
++] = 0x1; /* One port per group */
1135 arr
[n
++] = 0; /* Reserved */
1136 arr
[n
++] = 0; /* Reserved */
1137 arr
[n
++] = (port_a
>> 8) & 0xff;
1138 arr
[n
++] = port_a
& 0xff;
1139 arr
[n
++] = 3; /* Port unavailable */
1140 arr
[n
++] = 0x08; /* claim: only unavailalbe paths are supported */
1141 arr
[n
++] = (port_group_b
>> 8) & 0xff;
1142 arr
[n
++] = port_group_b
& 0xff;
1143 arr
[n
++] = 0; /* Reserved */
1144 arr
[n
++] = 0; /* Status code */
1145 arr
[n
++] = 0; /* Vendor unique */
1146 arr
[n
++] = 0x1; /* One port per group */
1147 arr
[n
++] = 0; /* Reserved */
1148 arr
[n
++] = 0; /* Reserved */
1149 arr
[n
++] = (port_b
>> 8) & 0xff;
1150 arr
[n
++] = port_b
& 0xff;
1153 arr
[0] = (rlen
>> 24) & 0xff;
1154 arr
[1] = (rlen
>> 16) & 0xff;
1155 arr
[2] = (rlen
>> 8) & 0xff;
1156 arr
[3] = rlen
& 0xff;
1159 * Return the smallest value of either
1160 * - The allocated length
1161 * - The constructed command length
1162 * - The maximum array size
1165 ret
= fill_from_dev_buffer(scp
, arr
,
1166 min(rlen
, SDEBUG_MAX_TGTPGS_ARR_SZ
));
1171 /* <<Following mode page info copied from ST318451LW>> */
1173 static int resp_err_recov_pg(unsigned char * p
, int pcontrol
, int target
)
1174 { /* Read-Write Error Recovery page for mode_sense */
1175 unsigned char err_recov_pg
[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
1178 memcpy(p
, err_recov_pg
, sizeof(err_recov_pg
));
1180 memset(p
+ 2, 0, sizeof(err_recov_pg
) - 2);
1181 return sizeof(err_recov_pg
);
1184 static int resp_disconnect_pg(unsigned char * p
, int pcontrol
, int target
)
1185 { /* Disconnect-Reconnect page for mode_sense */
1186 unsigned char disconnect_pg
[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
1187 0, 0, 0, 0, 0, 0, 0, 0};
1189 memcpy(p
, disconnect_pg
, sizeof(disconnect_pg
));
1191 memset(p
+ 2, 0, sizeof(disconnect_pg
) - 2);
1192 return sizeof(disconnect_pg
);
1195 static int resp_format_pg(unsigned char * p
, int pcontrol
, int target
)
1196 { /* Format device page for mode_sense */
1197 unsigned char format_pg
[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
1198 0, 0, 0, 0, 0, 0, 0, 0,
1199 0, 0, 0, 0, 0x40, 0, 0, 0};
1201 memcpy(p
, format_pg
, sizeof(format_pg
));
1202 p
[10] = (sdebug_sectors_per
>> 8) & 0xff;
1203 p
[11] = sdebug_sectors_per
& 0xff;
1204 p
[12] = (scsi_debug_sector_size
>> 8) & 0xff;
1205 p
[13] = scsi_debug_sector_size
& 0xff;
1206 if (DEV_REMOVEABLE(target
))
1207 p
[20] |= 0x20; /* should agree with INQUIRY */
1209 memset(p
+ 2, 0, sizeof(format_pg
) - 2);
1210 return sizeof(format_pg
);
1213 static int resp_caching_pg(unsigned char * p
, int pcontrol
, int target
)
1214 { /* Caching page for mode_sense */
1215 unsigned char caching_pg
[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1216 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
1218 memcpy(p
, caching_pg
, sizeof(caching_pg
));
1220 memset(p
+ 2, 0, sizeof(caching_pg
) - 2);
1221 return sizeof(caching_pg
);
1224 static int resp_ctrl_m_pg(unsigned char * p
, int pcontrol
, int target
)
1225 { /* Control mode page for mode_sense */
1226 unsigned char ch_ctrl_m_pg
[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
1228 unsigned char d_ctrl_m_pg
[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1231 if (scsi_debug_dsense
)
1232 ctrl_m_pg
[2] |= 0x4;
1234 ctrl_m_pg
[2] &= ~0x4;
1237 ctrl_m_pg
[5] |= 0x80; /* ATO=1 */
1239 memcpy(p
, ctrl_m_pg
, sizeof(ctrl_m_pg
));
1241 memcpy(p
+ 2, ch_ctrl_m_pg
, sizeof(ch_ctrl_m_pg
));
1242 else if (2 == pcontrol
)
1243 memcpy(p
, d_ctrl_m_pg
, sizeof(d_ctrl_m_pg
));
1244 return sizeof(ctrl_m_pg
);
1248 static int resp_iec_m_pg(unsigned char * p
, int pcontrol
, int target
)
1249 { /* Informational Exceptions control mode page for mode_sense */
1250 unsigned char ch_iec_m_pg
[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
1252 unsigned char d_iec_m_pg
[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1255 memcpy(p
, iec_m_pg
, sizeof(iec_m_pg
));
1257 memcpy(p
+ 2, ch_iec_m_pg
, sizeof(ch_iec_m_pg
));
1258 else if (2 == pcontrol
)
1259 memcpy(p
, d_iec_m_pg
, sizeof(d_iec_m_pg
));
1260 return sizeof(iec_m_pg
);
1263 static int resp_sas_sf_m_pg(unsigned char * p
, int pcontrol
, int target
)
1264 { /* SAS SSP mode page - short format for mode_sense */
1265 unsigned char sas_sf_m_pg
[] = {0x19, 0x6,
1266 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
1268 memcpy(p
, sas_sf_m_pg
, sizeof(sas_sf_m_pg
));
1270 memset(p
+ 2, 0, sizeof(sas_sf_m_pg
) - 2);
1271 return sizeof(sas_sf_m_pg
);
1275 static int resp_sas_pcd_m_spg(unsigned char * p
, int pcontrol
, int target
,
1277 { /* SAS phy control and discover mode page for mode_sense */
1278 unsigned char sas_pcd_m_pg
[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
1279 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
1280 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1281 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1282 0x2, 0, 0, 0, 0, 0, 0, 0,
1283 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1284 0, 0, 0, 0, 0, 0, 0, 0,
1285 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
1286 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1287 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1288 0x3, 0, 0, 0, 0, 0, 0, 0,
1289 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1290 0, 0, 0, 0, 0, 0, 0, 0,
1294 port_a
= target_dev_id
+ 1;
1295 port_b
= port_a
+ 1;
1296 memcpy(p
, sas_pcd_m_pg
, sizeof(sas_pcd_m_pg
));
1297 p
[20] = (port_a
>> 24);
1298 p
[21] = (port_a
>> 16) & 0xff;
1299 p
[22] = (port_a
>> 8) & 0xff;
1300 p
[23] = port_a
& 0xff;
1301 p
[48 + 20] = (port_b
>> 24);
1302 p
[48 + 21] = (port_b
>> 16) & 0xff;
1303 p
[48 + 22] = (port_b
>> 8) & 0xff;
1304 p
[48 + 23] = port_b
& 0xff;
1306 memset(p
+ 4, 0, sizeof(sas_pcd_m_pg
) - 4);
1307 return sizeof(sas_pcd_m_pg
);
1310 static int resp_sas_sha_m_spg(unsigned char * p
, int pcontrol
)
1311 { /* SAS SSP shared protocol specific port mode subpage */
1312 unsigned char sas_sha_m_pg
[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
1313 0, 0, 0, 0, 0, 0, 0, 0,
1316 memcpy(p
, sas_sha_m_pg
, sizeof(sas_sha_m_pg
));
1318 memset(p
+ 4, 0, sizeof(sas_sha_m_pg
) - 4);
1319 return sizeof(sas_sha_m_pg
);
1322 #define SDEBUG_MAX_MSENSE_SZ 256
1324 static int resp_mode_sense(struct scsi_cmnd
* scp
, int target
,
1325 struct sdebug_dev_info
* devip
)
1327 unsigned char dbd
, llbaa
;
1328 int pcontrol
, pcode
, subpcode
, bd_len
;
1329 unsigned char dev_spec
;
1330 int k
, alloc_len
, msense_6
, offset
, len
, errsts
, target_dev_id
;
1332 unsigned char arr
[SDEBUG_MAX_MSENSE_SZ
];
1333 unsigned char *cmd
= (unsigned char *)scp
->cmnd
;
1335 if ((errsts
= check_readiness(scp
, 1, devip
)))
1337 dbd
= !!(cmd
[1] & 0x8);
1338 pcontrol
= (cmd
[2] & 0xc0) >> 6;
1339 pcode
= cmd
[2] & 0x3f;
1341 msense_6
= (MODE_SENSE
== cmd
[0]);
1342 llbaa
= msense_6
? 0 : !!(cmd
[1] & 0x10);
1343 if ((0 == scsi_debug_ptype
) && (0 == dbd
))
1344 bd_len
= llbaa
? 16 : 8;
1347 alloc_len
= msense_6
? cmd
[4] : ((cmd
[7] << 8) | cmd
[8]);
1348 memset(arr
, 0, SDEBUG_MAX_MSENSE_SZ
);
1349 if (0x3 == pcontrol
) { /* Saving values not supported */
1350 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, SAVING_PARAMS_UNSUP
,
1352 return check_condition_result
;
1354 target_dev_id
= ((devip
->sdbg_host
->shost
->host_no
+ 1) * 2000) +
1355 (devip
->target
* 1000) - 3;
1356 /* set DPOFUA bit for disks */
1357 if (0 == scsi_debug_ptype
)
1358 dev_spec
= (DEV_READONLY(target
) ? 0x80 : 0x0) | 0x10;
1368 arr
[4] = 0x1; /* set LONGLBA bit */
1369 arr
[7] = bd_len
; /* assume 255 or less */
1373 if ((bd_len
> 0) && (!sdebug_capacity
))
1374 sdebug_capacity
= get_sdebug_capacity();
1377 if (sdebug_capacity
> 0xfffffffe) {
1383 ap
[0] = (sdebug_capacity
>> 24) & 0xff;
1384 ap
[1] = (sdebug_capacity
>> 16) & 0xff;
1385 ap
[2] = (sdebug_capacity
>> 8) & 0xff;
1386 ap
[3] = sdebug_capacity
& 0xff;
1388 ap
[6] = (scsi_debug_sector_size
>> 8) & 0xff;
1389 ap
[7] = scsi_debug_sector_size
& 0xff;
1392 } else if (16 == bd_len
) {
1393 unsigned long long capac
= sdebug_capacity
;
1395 for (k
= 0; k
< 8; ++k
, capac
>>= 8)
1396 ap
[7 - k
] = capac
& 0xff;
1397 ap
[12] = (scsi_debug_sector_size
>> 24) & 0xff;
1398 ap
[13] = (scsi_debug_sector_size
>> 16) & 0xff;
1399 ap
[14] = (scsi_debug_sector_size
>> 8) & 0xff;
1400 ap
[15] = scsi_debug_sector_size
& 0xff;
1405 if ((subpcode
> 0x0) && (subpcode
< 0xff) && (0x19 != pcode
)) {
1406 /* TODO: Control Extension page */
1407 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, INVALID_FIELD_IN_CDB
,
1409 return check_condition_result
;
1412 case 0x1: /* Read-Write error recovery page, direct access */
1413 len
= resp_err_recov_pg(ap
, pcontrol
, target
);
1416 case 0x2: /* Disconnect-Reconnect page, all devices */
1417 len
= resp_disconnect_pg(ap
, pcontrol
, target
);
1420 case 0x3: /* Format device page, direct access */
1421 len
= resp_format_pg(ap
, pcontrol
, target
);
1424 case 0x8: /* Caching page, direct access */
1425 len
= resp_caching_pg(ap
, pcontrol
, target
);
1428 case 0xa: /* Control Mode page, all devices */
1429 len
= resp_ctrl_m_pg(ap
, pcontrol
, target
);
1432 case 0x19: /* if spc==1 then sas phy, control+discover */
1433 if ((subpcode
> 0x2) && (subpcode
< 0xff)) {
1434 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
1435 INVALID_FIELD_IN_CDB
, 0);
1436 return check_condition_result
;
1439 if ((0x0 == subpcode
) || (0xff == subpcode
))
1440 len
+= resp_sas_sf_m_pg(ap
+ len
, pcontrol
, target
);
1441 if ((0x1 == subpcode
) || (0xff == subpcode
))
1442 len
+= resp_sas_pcd_m_spg(ap
+ len
, pcontrol
, target
,
1444 if ((0x2 == subpcode
) || (0xff == subpcode
))
1445 len
+= resp_sas_sha_m_spg(ap
+ len
, pcontrol
);
1448 case 0x1c: /* Informational Exceptions Mode page, all devices */
1449 len
= resp_iec_m_pg(ap
, pcontrol
, target
);
1452 case 0x3f: /* Read all Mode pages */
1453 if ((0 == subpcode
) || (0xff == subpcode
)) {
1454 len
= resp_err_recov_pg(ap
, pcontrol
, target
);
1455 len
+= resp_disconnect_pg(ap
+ len
, pcontrol
, target
);
1456 len
+= resp_format_pg(ap
+ len
, pcontrol
, target
);
1457 len
+= resp_caching_pg(ap
+ len
, pcontrol
, target
);
1458 len
+= resp_ctrl_m_pg(ap
+ len
, pcontrol
, target
);
1459 len
+= resp_sas_sf_m_pg(ap
+ len
, pcontrol
, target
);
1460 if (0xff == subpcode
) {
1461 len
+= resp_sas_pcd_m_spg(ap
+ len
, pcontrol
,
1462 target
, target_dev_id
);
1463 len
+= resp_sas_sha_m_spg(ap
+ len
, pcontrol
);
1465 len
+= resp_iec_m_pg(ap
+ len
, pcontrol
, target
);
1467 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
1468 INVALID_FIELD_IN_CDB
, 0);
1469 return check_condition_result
;
1474 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, INVALID_FIELD_IN_CDB
,
1476 return check_condition_result
;
1479 arr
[0] = offset
- 1;
1481 arr
[0] = ((offset
- 2) >> 8) & 0xff;
1482 arr
[1] = (offset
- 2) & 0xff;
1484 return fill_from_dev_buffer(scp
, arr
, min(alloc_len
, offset
));
1487 #define SDEBUG_MAX_MSELECT_SZ 512
1489 static int resp_mode_select(struct scsi_cmnd
* scp
, int mselect6
,
1490 struct sdebug_dev_info
* devip
)
1492 int pf
, sp
, ps
, md_len
, bd_len
, off
, spf
, pg_len
;
1493 int param_len
, res
, errsts
, mpage
;
1494 unsigned char arr
[SDEBUG_MAX_MSELECT_SZ
];
1495 unsigned char *cmd
= (unsigned char *)scp
->cmnd
;
1497 if ((errsts
= check_readiness(scp
, 1, devip
)))
1499 memset(arr
, 0, sizeof(arr
));
1502 param_len
= mselect6
? cmd
[4] : ((cmd
[7] << 8) + cmd
[8]);
1503 if ((0 == pf
) || sp
|| (param_len
> SDEBUG_MAX_MSELECT_SZ
)) {
1504 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
1505 INVALID_FIELD_IN_CDB
, 0);
1506 return check_condition_result
;
1508 res
= fetch_to_dev_buffer(scp
, arr
, param_len
);
1510 return (DID_ERROR
<< 16);
1511 else if ((res
< param_len
) &&
1512 (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
))
1513 printk(KERN_INFO
"scsi_debug: mode_select: cdb indicated=%d, "
1514 " IO sent=%d bytes\n", param_len
, res
);
1515 md_len
= mselect6
? (arr
[0] + 1) : ((arr
[0] << 8) + arr
[1] + 2);
1516 bd_len
= mselect6
? arr
[3] : ((arr
[6] << 8) + arr
[7]);
1518 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
1519 INVALID_FIELD_IN_PARAM_LIST
, 0);
1520 return check_condition_result
;
1522 off
= bd_len
+ (mselect6
? 4 : 8);
1523 mpage
= arr
[off
] & 0x3f;
1524 ps
= !!(arr
[off
] & 0x80);
1526 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
1527 INVALID_FIELD_IN_PARAM_LIST
, 0);
1528 return check_condition_result
;
1530 spf
= !!(arr
[off
] & 0x40);
1531 pg_len
= spf
? ((arr
[off
+ 2] << 8) + arr
[off
+ 3] + 4) :
1533 if ((pg_len
+ off
) > param_len
) {
1534 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
1535 PARAMETER_LIST_LENGTH_ERR
, 0);
1536 return check_condition_result
;
1539 case 0xa: /* Control Mode page */
1540 if (ctrl_m_pg
[1] == arr
[off
+ 1]) {
1541 memcpy(ctrl_m_pg
+ 2, arr
+ off
+ 2,
1542 sizeof(ctrl_m_pg
) - 2);
1543 scsi_debug_dsense
= !!(ctrl_m_pg
[2] & 0x4);
1547 case 0x1c: /* Informational Exceptions Mode page */
1548 if (iec_m_pg
[1] == arr
[off
+ 1]) {
1549 memcpy(iec_m_pg
+ 2, arr
+ off
+ 2,
1550 sizeof(iec_m_pg
) - 2);
1557 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
1558 INVALID_FIELD_IN_PARAM_LIST
, 0);
1559 return check_condition_result
;
1562 static int resp_temp_l_pg(unsigned char * arr
)
1564 unsigned char temp_l_pg
[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
1565 0x0, 0x1, 0x3, 0x2, 0x0, 65,
1568 memcpy(arr
, temp_l_pg
, sizeof(temp_l_pg
));
1569 return sizeof(temp_l_pg
);
1572 static int resp_ie_l_pg(unsigned char * arr
)
1574 unsigned char ie_l_pg
[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
1577 memcpy(arr
, ie_l_pg
, sizeof(ie_l_pg
));
1578 if (iec_m_pg
[2] & 0x4) { /* TEST bit set */
1579 arr
[4] = THRESHOLD_EXCEEDED
;
1582 return sizeof(ie_l_pg
);
1585 #define SDEBUG_MAX_LSENSE_SZ 512
1587 static int resp_log_sense(struct scsi_cmnd
* scp
,
1588 struct sdebug_dev_info
* devip
)
1590 int ppc
, sp
, pcontrol
, pcode
, subpcode
, alloc_len
, errsts
, len
, n
;
1591 unsigned char arr
[SDEBUG_MAX_LSENSE_SZ
];
1592 unsigned char *cmd
= (unsigned char *)scp
->cmnd
;
1594 if ((errsts
= check_readiness(scp
, 1, devip
)))
1596 memset(arr
, 0, sizeof(arr
));
1600 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
1601 INVALID_FIELD_IN_CDB
, 0);
1602 return check_condition_result
;
1604 pcontrol
= (cmd
[2] & 0xc0) >> 6;
1605 pcode
= cmd
[2] & 0x3f;
1606 subpcode
= cmd
[3] & 0xff;
1607 alloc_len
= (cmd
[7] << 8) + cmd
[8];
1609 if (0 == subpcode
) {
1611 case 0x0: /* Supported log pages log page */
1613 arr
[n
++] = 0x0; /* this page */
1614 arr
[n
++] = 0xd; /* Temperature */
1615 arr
[n
++] = 0x2f; /* Informational exceptions */
1618 case 0xd: /* Temperature log page */
1619 arr
[3] = resp_temp_l_pg(arr
+ 4);
1621 case 0x2f: /* Informational exceptions log page */
1622 arr
[3] = resp_ie_l_pg(arr
+ 4);
1625 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
1626 INVALID_FIELD_IN_CDB
, 0);
1627 return check_condition_result
;
1629 } else if (0xff == subpcode
) {
1633 case 0x0: /* Supported log pages and subpages log page */
1636 arr
[n
++] = 0x0; /* 0,0 page */
1638 arr
[n
++] = 0xff; /* this page */
1640 arr
[n
++] = 0x0; /* Temperature */
1642 arr
[n
++] = 0x0; /* Informational exceptions */
1645 case 0xd: /* Temperature subpages */
1648 arr
[n
++] = 0x0; /* Temperature */
1651 case 0x2f: /* Informational exceptions subpages */
1654 arr
[n
++] = 0x0; /* Informational exceptions */
1658 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
1659 INVALID_FIELD_IN_CDB
, 0);
1660 return check_condition_result
;
1663 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
1664 INVALID_FIELD_IN_CDB
, 0);
1665 return check_condition_result
;
1667 len
= min(((arr
[2] << 8) + arr
[3]) + 4, alloc_len
);
1668 return fill_from_dev_buffer(scp
, arr
,
1669 min(len
, SDEBUG_MAX_INQ_ARR_SZ
));
1672 static int check_device_access_params(struct sdebug_dev_info
*devi
,
1673 unsigned long long lba
, unsigned int num
)
1675 if (lba
+ num
> sdebug_capacity
) {
1676 mk_sense_buffer(devi
, ILLEGAL_REQUEST
, ADDR_OUT_OF_RANGE
, 0);
1677 return check_condition_result
;
1679 /* transfer length excessive (tie in to block limits VPD page) */
1680 if (num
> sdebug_store_sectors
) {
1681 mk_sense_buffer(devi
, ILLEGAL_REQUEST
, INVALID_FIELD_IN_CDB
, 0);
1682 return check_condition_result
;
1687 static int do_device_access(struct scsi_cmnd
*scmd
,
1688 struct sdebug_dev_info
*devi
,
1689 unsigned long long lba
, unsigned int num
, int write
)
1692 unsigned long long block
, rest
= 0;
1693 int (*func
)(struct scsi_cmnd
*, unsigned char *, int);
1695 func
= write
? fetch_to_dev_buffer
: fill_from_dev_buffer
;
1697 block
= do_div(lba
, sdebug_store_sectors
);
1698 if (block
+ num
> sdebug_store_sectors
)
1699 rest
= block
+ num
- sdebug_store_sectors
;
1701 ret
= func(scmd
, fake_storep
+ (block
* scsi_debug_sector_size
),
1702 (num
- rest
) * scsi_debug_sector_size
);
1704 ret
= func(scmd
, fake_storep
, rest
* scsi_debug_sector_size
);
1709 static int prot_verify_read(struct scsi_cmnd
*SCpnt
, sector_t start_sec
,
1710 unsigned int sectors
, u32 ei_lba
)
1712 unsigned int i
, resid
;
1713 struct scatterlist
*psgl
;
1714 struct sd_dif_tuple
*sdt
;
1716 sector_t tmp_sec
= start_sec
;
1719 start_sec
= do_div(tmp_sec
, sdebug_store_sectors
);
1721 sdt
= (struct sd_dif_tuple
*)(dif_storep
+ dif_offset(start_sec
));
1723 for (i
= 0 ; i
< sectors
; i
++) {
1726 if (sdt
[i
].app_tag
== 0xffff)
1729 sector
= start_sec
+ i
;
1731 switch (scsi_debug_guard
) {
1733 csum
= ip_compute_csum(fake_storep
+
1734 sector
* scsi_debug_sector_size
,
1735 scsi_debug_sector_size
);
1738 csum
= crc_t10dif(fake_storep
+
1739 sector
* scsi_debug_sector_size
,
1740 scsi_debug_sector_size
);
1741 csum
= cpu_to_be16(csum
);
1747 if (sdt
[i
].guard_tag
!= csum
) {
1748 printk(KERN_ERR
"%s: GUARD check failed on sector %lu" \
1749 " rcvd 0x%04x, data 0x%04x\n", __func__
,
1750 (unsigned long)sector
,
1751 be16_to_cpu(sdt
[i
].guard_tag
),
1757 if (scsi_debug_dif
== SD_DIF_TYPE1_PROTECTION
&&
1758 be32_to_cpu(sdt
[i
].ref_tag
) != (sector
& 0xffffffff)) {
1759 printk(KERN_ERR
"%s: REF check failed on sector %lu\n",
1760 __func__
, (unsigned long)sector
);
1765 if (scsi_debug_dif
== SD_DIF_TYPE2_PROTECTION
&&
1766 be32_to_cpu(sdt
[i
].ref_tag
) != ei_lba
) {
1767 printk(KERN_ERR
"%s: REF check failed on sector %lu\n",
1768 __func__
, (unsigned long)sector
);
1776 resid
= sectors
* 8; /* Bytes of protection data to copy into sgl */
1779 scsi_for_each_prot_sg(SCpnt
, psgl
, scsi_prot_sg_count(SCpnt
), i
) {
1780 int len
= min(psgl
->length
, resid
);
1782 paddr
= kmap_atomic(sg_page(psgl
)) + psgl
->offset
;
1783 memcpy(paddr
, dif_storep
+ dif_offset(sector
), len
);
1786 if (sector
>= sdebug_store_sectors
) {
1789 sector
= do_div(tmp_sec
, sdebug_store_sectors
);
1792 kunmap_atomic(paddr
);
1800 static int resp_read(struct scsi_cmnd
*SCpnt
, unsigned long long lba
,
1801 unsigned int num
, struct sdebug_dev_info
*devip
,
1804 unsigned long iflags
;
1807 ret
= check_device_access_params(devip
, lba
, num
);
1811 if ((SCSI_DEBUG_OPT_MEDIUM_ERR
& scsi_debug_opts
) &&
1812 (lba
<= (OPT_MEDIUM_ERR_ADDR
+ OPT_MEDIUM_ERR_NUM
- 1)) &&
1813 ((lba
+ num
) > OPT_MEDIUM_ERR_ADDR
)) {
1814 /* claim unrecoverable read error */
1815 mk_sense_buffer(devip
, MEDIUM_ERROR
, UNRECOVERED_READ_ERR
, 0);
1816 /* set info field and valid bit for fixed descriptor */
1817 if (0x70 == (devip
->sense_buff
[0] & 0x7f)) {
1818 devip
->sense_buff
[0] |= 0x80; /* Valid bit */
1819 ret
= (lba
< OPT_MEDIUM_ERR_ADDR
)
1820 ? OPT_MEDIUM_ERR_ADDR
: (int)lba
;
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 scsi_set_resid(SCpnt
, scsi_bufflen(SCpnt
));
1827 return check_condition_result
;
1831 if (scsi_debug_dix
&& scsi_prot_sg_count(SCpnt
)) {
1832 int prot_ret
= prot_verify_read(SCpnt
, lba
, num
, ei_lba
);
1835 mk_sense_buffer(devip
, ABORTED_COMMAND
, 0x10, prot_ret
);
1836 return illegal_condition_result
;
1840 read_lock_irqsave(&atomic_rw
, iflags
);
1841 ret
= do_device_access(SCpnt
, devip
, lba
, num
, 0);
1842 read_unlock_irqrestore(&atomic_rw
, iflags
);
1846 void dump_sector(unsigned char *buf
, int len
)
1850 printk(KERN_ERR
">>> Sector Dump <<<\n");
1852 for (i
= 0 ; i
< len
; i
+= 16) {
1853 printk(KERN_ERR
"%04d: ", i
);
1855 for (j
= 0 ; j
< 16 ; j
++) {
1856 unsigned char c
= buf
[i
+j
];
1857 if (c
>= 0x20 && c
< 0x7e)
1858 printk(" %c ", buf
[i
+j
]);
1860 printk("%02x ", buf
[i
+j
]);
1867 static int prot_verify_write(struct scsi_cmnd
*SCpnt
, sector_t start_sec
,
1868 unsigned int sectors
, u32 ei_lba
)
1871 struct sd_dif_tuple
*sdt
;
1872 struct scatterlist
*dsgl
= scsi_sglist(SCpnt
);
1873 struct scatterlist
*psgl
= scsi_prot_sglist(SCpnt
);
1874 void *daddr
, *paddr
;
1875 sector_t tmp_sec
= start_sec
;
1878 unsigned short csum
;
1880 sector
= do_div(tmp_sec
, sdebug_store_sectors
);
1882 BUG_ON(scsi_sg_count(SCpnt
) == 0);
1883 BUG_ON(scsi_prot_sg_count(SCpnt
) == 0);
1885 paddr
= kmap_atomic(sg_page(psgl
)) + psgl
->offset
;
1888 /* For each data page */
1889 scsi_for_each_sg(SCpnt
, dsgl
, scsi_sg_count(SCpnt
), i
) {
1890 daddr
= kmap_atomic(sg_page(dsgl
)) + dsgl
->offset
;
1892 /* For each sector-sized chunk in data page */
1893 for (j
= 0 ; j
< dsgl
->length
; j
+= scsi_debug_sector_size
) {
1895 /* If we're at the end of the current
1896 * protection page advance to the next one
1898 if (ppage_offset
>= psgl
->length
) {
1899 kunmap_atomic(paddr
);
1900 psgl
= sg_next(psgl
);
1901 BUG_ON(psgl
== NULL
);
1902 paddr
= kmap_atomic(sg_page(psgl
))
1907 sdt
= paddr
+ ppage_offset
;
1909 switch (scsi_debug_guard
) {
1911 csum
= ip_compute_csum(daddr
,
1912 scsi_debug_sector_size
);
1915 csum
= cpu_to_be16(crc_t10dif(daddr
,
1916 scsi_debug_sector_size
));
1924 if (sdt
->guard_tag
!= csum
) {
1926 "%s: GUARD check failed on sector %lu " \
1927 "rcvd 0x%04x, calculated 0x%04x\n",
1928 __func__
, (unsigned long)sector
,
1929 be16_to_cpu(sdt
->guard_tag
),
1932 dump_sector(daddr
, scsi_debug_sector_size
);
1936 if (scsi_debug_dif
== SD_DIF_TYPE1_PROTECTION
&&
1937 be32_to_cpu(sdt
->ref_tag
)
1938 != (start_sec
& 0xffffffff)) {
1940 "%s: REF check failed on sector %lu\n",
1941 __func__
, (unsigned long)sector
);
1943 dump_sector(daddr
, scsi_debug_sector_size
);
1947 if (scsi_debug_dif
== SD_DIF_TYPE2_PROTECTION
&&
1948 be32_to_cpu(sdt
->ref_tag
) != ei_lba
) {
1950 "%s: REF check failed on sector %lu\n",
1951 __func__
, (unsigned long)sector
);
1953 dump_sector(daddr
, scsi_debug_sector_size
);
1957 /* Would be great to copy this in bigger
1958 * chunks. However, for the sake of
1959 * correctness we need to verify each sector
1960 * before writing it to "stable" storage
1962 memcpy(dif_storep
+ dif_offset(sector
), sdt
, 8);
1966 if (sector
== sdebug_store_sectors
)
1967 sector
= 0; /* Force wrap */
1971 daddr
+= scsi_debug_sector_size
;
1972 ppage_offset
+= sizeof(struct sd_dif_tuple
);
1975 kunmap_atomic(daddr
);
1978 kunmap_atomic(paddr
);
1986 kunmap_atomic(daddr
);
1987 kunmap_atomic(paddr
);
1991 static unsigned int map_state(sector_t lba
, unsigned int *num
)
1993 unsigned int granularity
, alignment
, mapped
;
1994 sector_t block
, next
, end
;
1996 granularity
= scsi_debug_unmap_granularity
;
1997 alignment
= granularity
- scsi_debug_unmap_alignment
;
1998 block
= lba
+ alignment
;
1999 do_div(block
, granularity
);
2001 mapped
= test_bit(block
, map_storep
);
2004 next
= find_next_zero_bit(map_storep
, map_size
, block
);
2006 next
= find_next_bit(map_storep
, map_size
, block
);
2008 end
= next
* granularity
- scsi_debug_unmap_alignment
;
2014 static void map_region(sector_t lba
, unsigned int len
)
2016 unsigned int granularity
, alignment
;
2017 sector_t end
= lba
+ len
;
2019 granularity
= scsi_debug_unmap_granularity
;
2020 alignment
= granularity
- scsi_debug_unmap_alignment
;
2023 sector_t block
, rem
;
2025 block
= lba
+ alignment
;
2026 rem
= do_div(block
, granularity
);
2028 if (block
< map_size
)
2029 set_bit(block
, map_storep
);
2031 lba
+= granularity
- rem
;
2035 static void unmap_region(sector_t lba
, unsigned int len
)
2037 unsigned int granularity
, alignment
;
2038 sector_t end
= lba
+ len
;
2040 granularity
= scsi_debug_unmap_granularity
;
2041 alignment
= granularity
- scsi_debug_unmap_alignment
;
2044 sector_t block
, rem
;
2046 block
= lba
+ alignment
;
2047 rem
= do_div(block
, granularity
);
2049 if (rem
== 0 && lba
+ granularity
<= end
&&
2051 clear_bit(block
, map_storep
);
2053 lba
+= granularity
- rem
;
2057 static int resp_write(struct scsi_cmnd
*SCpnt
, unsigned long long lba
,
2058 unsigned int num
, struct sdebug_dev_info
*devip
,
2061 unsigned long iflags
;
2064 ret
= check_device_access_params(devip
, lba
, num
);
2069 if (scsi_debug_dix
&& scsi_prot_sg_count(SCpnt
)) {
2070 int prot_ret
= prot_verify_write(SCpnt
, lba
, num
, ei_lba
);
2073 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, 0x10, prot_ret
);
2074 return illegal_condition_result
;
2078 write_lock_irqsave(&atomic_rw
, iflags
);
2079 ret
= do_device_access(SCpnt
, devip
, lba
, num
, 1);
2080 if (scsi_debug_unmap_granularity
)
2081 map_region(lba
, num
);
2082 write_unlock_irqrestore(&atomic_rw
, iflags
);
2084 return (DID_ERROR
<< 16);
2085 else if ((ret
< (num
* scsi_debug_sector_size
)) &&
2086 (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
))
2087 printk(KERN_INFO
"scsi_debug: write: cdb indicated=%u, "
2088 " IO sent=%d bytes\n", num
* scsi_debug_sector_size
, ret
);
2093 static int resp_write_same(struct scsi_cmnd
*scmd
, unsigned long long lba
,
2094 unsigned int num
, struct sdebug_dev_info
*devip
,
2095 u32 ei_lba
, unsigned int unmap
)
2097 unsigned long iflags
;
2098 unsigned long long i
;
2101 ret
= check_device_access_params(devip
, lba
, num
);
2105 if (num
> scsi_debug_write_same_length
) {
2106 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, INVALID_FIELD_IN_CDB
,
2108 return check_condition_result
;
2111 write_lock_irqsave(&atomic_rw
, iflags
);
2113 if (unmap
&& scsi_debug_unmap_granularity
) {
2114 unmap_region(lba
, num
);
2118 /* Else fetch one logical block */
2119 ret
= fetch_to_dev_buffer(scmd
,
2120 fake_storep
+ (lba
* scsi_debug_sector_size
),
2121 scsi_debug_sector_size
);
2124 write_unlock_irqrestore(&atomic_rw
, iflags
);
2125 return (DID_ERROR
<< 16);
2126 } else if ((ret
< (num
* scsi_debug_sector_size
)) &&
2127 (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
))
2128 printk(KERN_INFO
"scsi_debug: write same: cdb indicated=%u, "
2129 " IO sent=%d bytes\n", num
* scsi_debug_sector_size
, ret
);
2131 /* Copy first sector to remaining blocks */
2132 for (i
= 1 ; i
< num
; i
++)
2133 memcpy(fake_storep
+ ((lba
+ i
) * scsi_debug_sector_size
),
2134 fake_storep
+ (lba
* scsi_debug_sector_size
),
2135 scsi_debug_sector_size
);
2137 if (scsi_debug_unmap_granularity
)
2138 map_region(lba
, num
);
2140 write_unlock_irqrestore(&atomic_rw
, iflags
);
2145 struct unmap_block_desc
{
2151 static int resp_unmap(struct scsi_cmnd
* scmd
, struct sdebug_dev_info
* devip
)
2154 struct unmap_block_desc
*desc
;
2155 unsigned int i
, payload_len
, descriptors
;
2158 ret
= check_readiness(scmd
, 1, devip
);
2162 payload_len
= get_unaligned_be16(&scmd
->cmnd
[7]);
2163 BUG_ON(scsi_bufflen(scmd
) != payload_len
);
2165 descriptors
= (payload_len
- 8) / 16;
2167 buf
= kmalloc(scsi_bufflen(scmd
), GFP_ATOMIC
);
2169 return check_condition_result
;
2171 scsi_sg_copy_to_buffer(scmd
, buf
, scsi_bufflen(scmd
));
2173 BUG_ON(get_unaligned_be16(&buf
[0]) != payload_len
- 2);
2174 BUG_ON(get_unaligned_be16(&buf
[2]) != descriptors
* 16);
2176 desc
= (void *)&buf
[8];
2178 for (i
= 0 ; i
< descriptors
; i
++) {
2179 unsigned long long lba
= get_unaligned_be64(&desc
[i
].lba
);
2180 unsigned int num
= get_unaligned_be32(&desc
[i
].blocks
);
2182 ret
= check_device_access_params(devip
, lba
, num
);
2186 unmap_region(lba
, num
);
2197 #define SDEBUG_GET_LBA_STATUS_LEN 32
2199 static int resp_get_lba_status(struct scsi_cmnd
* scmd
,
2200 struct sdebug_dev_info
* devip
)
2202 unsigned long long lba
;
2203 unsigned int alloc_len
, mapped
, num
;
2204 unsigned char arr
[SDEBUG_GET_LBA_STATUS_LEN
];
2207 ret
= check_readiness(scmd
, 1, devip
);
2211 lba
= get_unaligned_be64(&scmd
->cmnd
[2]);
2212 alloc_len
= get_unaligned_be32(&scmd
->cmnd
[10]);
2217 ret
= check_device_access_params(devip
, lba
, 1);
2221 mapped
= map_state(lba
, &num
);
2223 memset(arr
, 0, SDEBUG_GET_LBA_STATUS_LEN
);
2224 put_unaligned_be32(20, &arr
[0]); /* Parameter Data Length */
2225 put_unaligned_be64(lba
, &arr
[8]); /* LBA */
2226 put_unaligned_be32(num
, &arr
[16]); /* Number of blocks */
2227 arr
[20] = !mapped
; /* mapped = 0, unmapped = 1 */
2229 return fill_from_dev_buffer(scmd
, arr
, SDEBUG_GET_LBA_STATUS_LEN
);
2232 #define SDEBUG_RLUN_ARR_SZ 256
2234 static int resp_report_luns(struct scsi_cmnd
* scp
,
2235 struct sdebug_dev_info
* devip
)
2237 unsigned int alloc_len
;
2238 int lun_cnt
, i
, upper
, num
, n
, wlun
, lun
;
2239 unsigned char *cmd
= (unsigned char *)scp
->cmnd
;
2240 int select_report
= (int)cmd
[2];
2241 struct scsi_lun
*one_lun
;
2242 unsigned char arr
[SDEBUG_RLUN_ARR_SZ
];
2243 unsigned char * max_addr
;
2245 alloc_len
= cmd
[9] + (cmd
[8] << 8) + (cmd
[7] << 16) + (cmd
[6] << 24);
2246 if ((alloc_len
< 4) || (select_report
> 2)) {
2247 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, INVALID_FIELD_IN_CDB
,
2249 return check_condition_result
;
2251 /* can produce response with up to 16k luns (lun 0 to lun 16383) */
2252 memset(arr
, 0, SDEBUG_RLUN_ARR_SZ
);
2253 lun_cnt
= scsi_debug_max_luns
;
2254 if (1 == select_report
)
2256 else if (scsi_debug_no_lun_0
&& (lun_cnt
> 0))
2258 wlun
= (select_report
> 0) ? 1 : 0;
2259 num
= lun_cnt
+ wlun
;
2260 arr
[2] = ((sizeof(struct scsi_lun
) * num
) >> 8) & 0xff;
2261 arr
[3] = (sizeof(struct scsi_lun
) * num
) & 0xff;
2262 n
= min((int)((SDEBUG_RLUN_ARR_SZ
- 8) /
2263 sizeof(struct scsi_lun
)), num
);
2268 one_lun
= (struct scsi_lun
*) &arr
[8];
2269 max_addr
= arr
+ SDEBUG_RLUN_ARR_SZ
;
2270 for (i
= 0, lun
= (scsi_debug_no_lun_0
? 1 : 0);
2271 ((i
< lun_cnt
) && ((unsigned char *)(one_lun
+ i
) < max_addr
));
2273 upper
= (lun
>> 8) & 0x3f;
2275 one_lun
[i
].scsi_lun
[0] =
2276 (upper
| (SAM2_LUN_ADDRESS_METHOD
<< 6));
2277 one_lun
[i
].scsi_lun
[1] = lun
& 0xff;
2280 one_lun
[i
].scsi_lun
[0] = (SAM2_WLUN_REPORT_LUNS
>> 8) & 0xff;
2281 one_lun
[i
].scsi_lun
[1] = SAM2_WLUN_REPORT_LUNS
& 0xff;
2284 alloc_len
= (unsigned char *)(one_lun
+ i
) - arr
;
2285 return fill_from_dev_buffer(scp
, arr
,
2286 min((int)alloc_len
, SDEBUG_RLUN_ARR_SZ
));
2289 static int resp_xdwriteread(struct scsi_cmnd
*scp
, unsigned long long lba
,
2290 unsigned int num
, struct sdebug_dev_info
*devip
)
2293 unsigned char *kaddr
, *buf
;
2294 unsigned int offset
;
2295 struct scatterlist
*sg
;
2296 struct scsi_data_buffer
*sdb
= scsi_in(scp
);
2298 /* better not to use temporary buffer. */
2299 buf
= kmalloc(scsi_bufflen(scp
), GFP_ATOMIC
);
2303 scsi_sg_copy_to_buffer(scp
, buf
, scsi_bufflen(scp
));
2306 for_each_sg(sdb
->table
.sgl
, sg
, sdb
->table
.nents
, i
) {
2307 kaddr
= (unsigned char *)kmap_atomic(sg_page(sg
));
2311 for (j
= 0; j
< sg
->length
; j
++)
2312 *(kaddr
+ sg
->offset
+ j
) ^= *(buf
+ offset
+ j
);
2314 offset
+= sg
->length
;
2315 kunmap_atomic(kaddr
);
2324 /* When timer goes off this function is called. */
2325 static void timer_intr_handler(unsigned long indx
)
2327 struct sdebug_queued_cmd
* sqcp
;
2328 unsigned long iflags
;
2330 if (indx
>= scsi_debug_max_queue
) {
2331 printk(KERN_ERR
"scsi_debug:timer_intr_handler: indx too "
2335 spin_lock_irqsave(&queued_arr_lock
, iflags
);
2336 sqcp
= &queued_arr
[(int)indx
];
2337 if (! sqcp
->in_use
) {
2338 printk(KERN_ERR
"scsi_debug:timer_intr_handler: Unexpected "
2340 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
2344 if (sqcp
->done_funct
) {
2345 sqcp
->a_cmnd
->result
= sqcp
->scsi_result
;
2346 sqcp
->done_funct(sqcp
->a_cmnd
); /* callback to mid level */
2348 sqcp
->done_funct
= NULL
;
2349 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
2353 static struct sdebug_dev_info
*
2354 sdebug_device_create(struct sdebug_host_info
*sdbg_host
, gfp_t flags
)
2356 struct sdebug_dev_info
*devip
;
2358 devip
= kzalloc(sizeof(*devip
), flags
);
2360 devip
->sdbg_host
= sdbg_host
;
2361 list_add_tail(&devip
->dev_list
, &sdbg_host
->dev_info_list
);
2366 static struct sdebug_dev_info
* devInfoReg(struct scsi_device
* sdev
)
2368 struct sdebug_host_info
* sdbg_host
;
2369 struct sdebug_dev_info
* open_devip
= NULL
;
2370 struct sdebug_dev_info
* devip
=
2371 (struct sdebug_dev_info
*)sdev
->hostdata
;
2375 sdbg_host
= *(struct sdebug_host_info
**)shost_priv(sdev
->host
);
2377 printk(KERN_ERR
"Host info NULL\n");
2380 list_for_each_entry(devip
, &sdbg_host
->dev_info_list
, dev_list
) {
2381 if ((devip
->used
) && (devip
->channel
== sdev
->channel
) &&
2382 (devip
->target
== sdev
->id
) &&
2383 (devip
->lun
== sdev
->lun
))
2386 if ((!devip
->used
) && (!open_devip
))
2390 if (!open_devip
) { /* try and make a new one */
2391 open_devip
= sdebug_device_create(sdbg_host
, GFP_ATOMIC
);
2393 printk(KERN_ERR
"%s: out of memory at line %d\n",
2394 __func__
, __LINE__
);
2399 open_devip
->channel
= sdev
->channel
;
2400 open_devip
->target
= sdev
->id
;
2401 open_devip
->lun
= sdev
->lun
;
2402 open_devip
->sdbg_host
= sdbg_host
;
2403 open_devip
->reset
= 1;
2404 open_devip
->used
= 1;
2405 memset(open_devip
->sense_buff
, 0, SDEBUG_SENSE_LEN
);
2406 if (scsi_debug_dsense
)
2407 open_devip
->sense_buff
[0] = 0x72;
2409 open_devip
->sense_buff
[0] = 0x70;
2410 open_devip
->sense_buff
[7] = 0xa;
2412 if (sdev
->lun
== SAM2_WLUN_REPORT_LUNS
)
2413 open_devip
->wlun
= SAM2_WLUN_REPORT_LUNS
& 0xff;
2418 static int scsi_debug_slave_alloc(struct scsi_device
*sdp
)
2420 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
2421 printk(KERN_INFO
"scsi_debug: slave_alloc <%u %u %u %u>\n",
2422 sdp
->host
->host_no
, sdp
->channel
, sdp
->id
, sdp
->lun
);
2423 queue_flag_set_unlocked(QUEUE_FLAG_BIDI
, sdp
->request_queue
);
2427 static int scsi_debug_slave_configure(struct scsi_device
*sdp
)
2429 struct sdebug_dev_info
*devip
;
2431 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
2432 printk(KERN_INFO
"scsi_debug: slave_configure <%u %u %u %u>\n",
2433 sdp
->host
->host_no
, sdp
->channel
, sdp
->id
, sdp
->lun
);
2434 if (sdp
->host
->max_cmd_len
!= SCSI_DEBUG_MAX_CMD_LEN
)
2435 sdp
->host
->max_cmd_len
= SCSI_DEBUG_MAX_CMD_LEN
;
2436 devip
= devInfoReg(sdp
);
2438 return 1; /* no resources, will be marked offline */
2439 sdp
->hostdata
= devip
;
2440 if (sdp
->host
->cmd_per_lun
)
2441 scsi_adjust_queue_depth(sdp
, SDEBUG_TAGGED_QUEUING
,
2442 sdp
->host
->cmd_per_lun
);
2443 blk_queue_max_segment_size(sdp
->request_queue
, 256 * 1024);
2444 if (scsi_debug_no_uld
)
2445 sdp
->no_uld_attach
= 1;
2449 static void scsi_debug_slave_destroy(struct scsi_device
*sdp
)
2451 struct sdebug_dev_info
*devip
=
2452 (struct sdebug_dev_info
*)sdp
->hostdata
;
2454 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
2455 printk(KERN_INFO
"scsi_debug: slave_destroy <%u %u %u %u>\n",
2456 sdp
->host
->host_no
, sdp
->channel
, sdp
->id
, sdp
->lun
);
2458 /* make this slot available for re-use */
2460 sdp
->hostdata
= NULL
;
2464 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
2465 static int stop_queued_cmnd(struct scsi_cmnd
*cmnd
)
2467 unsigned long iflags
;
2469 struct sdebug_queued_cmd
*sqcp
;
2471 spin_lock_irqsave(&queued_arr_lock
, iflags
);
2472 for (k
= 0; k
< scsi_debug_max_queue
; ++k
) {
2473 sqcp
= &queued_arr
[k
];
2474 if (sqcp
->in_use
&& (cmnd
== sqcp
->a_cmnd
)) {
2475 del_timer_sync(&sqcp
->cmnd_timer
);
2477 sqcp
->a_cmnd
= NULL
;
2481 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
2482 return (k
< scsi_debug_max_queue
) ? 1 : 0;
2485 /* Deletes (stops) timers of all queued commands */
2486 static void stop_all_queued(void)
2488 unsigned long iflags
;
2490 struct sdebug_queued_cmd
*sqcp
;
2492 spin_lock_irqsave(&queued_arr_lock
, iflags
);
2493 for (k
= 0; k
< scsi_debug_max_queue
; ++k
) {
2494 sqcp
= &queued_arr
[k
];
2495 if (sqcp
->in_use
&& sqcp
->a_cmnd
) {
2496 del_timer_sync(&sqcp
->cmnd_timer
);
2498 sqcp
->a_cmnd
= NULL
;
2501 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
2504 static int scsi_debug_abort(struct scsi_cmnd
* SCpnt
)
2506 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
2507 printk(KERN_INFO
"scsi_debug: abort\n");
2509 stop_queued_cmnd(SCpnt
);
2513 static int scsi_debug_biosparam(struct scsi_device
*sdev
,
2514 struct block_device
* bdev
, sector_t capacity
, int *info
)
2519 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
2520 printk(KERN_INFO
"scsi_debug: biosparam\n");
2521 buf
= scsi_bios_ptable(bdev
);
2523 res
= scsi_partsize(buf
, capacity
,
2524 &info
[2], &info
[0], &info
[1]);
2529 info
[0] = sdebug_heads
;
2530 info
[1] = sdebug_sectors_per
;
2531 info
[2] = sdebug_cylinders_per
;
2535 static int scsi_debug_device_reset(struct scsi_cmnd
* SCpnt
)
2537 struct sdebug_dev_info
* devip
;
2539 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
2540 printk(KERN_INFO
"scsi_debug: device_reset\n");
2543 devip
= devInfoReg(SCpnt
->device
);
2550 static int scsi_debug_bus_reset(struct scsi_cmnd
* SCpnt
)
2552 struct sdebug_host_info
*sdbg_host
;
2553 struct sdebug_dev_info
* dev_info
;
2554 struct scsi_device
* sdp
;
2555 struct Scsi_Host
* hp
;
2557 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
2558 printk(KERN_INFO
"scsi_debug: bus_reset\n");
2560 if (SCpnt
&& ((sdp
= SCpnt
->device
)) && ((hp
= sdp
->host
))) {
2561 sdbg_host
= *(struct sdebug_host_info
**)shost_priv(hp
);
2563 list_for_each_entry(dev_info
,
2564 &sdbg_host
->dev_info_list
,
2566 dev_info
->reset
= 1;
2572 static int scsi_debug_host_reset(struct scsi_cmnd
* SCpnt
)
2574 struct sdebug_host_info
* sdbg_host
;
2575 struct sdebug_dev_info
* dev_info
;
2577 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
2578 printk(KERN_INFO
"scsi_debug: host_reset\n");
2580 spin_lock(&sdebug_host_list_lock
);
2581 list_for_each_entry(sdbg_host
, &sdebug_host_list
, host_list
) {
2582 list_for_each_entry(dev_info
, &sdbg_host
->dev_info_list
,
2584 dev_info
->reset
= 1;
2586 spin_unlock(&sdebug_host_list_lock
);
2591 /* Initializes timers in queued array */
2592 static void __init
init_all_queued(void)
2594 unsigned long iflags
;
2596 struct sdebug_queued_cmd
* sqcp
;
2598 spin_lock_irqsave(&queued_arr_lock
, iflags
);
2599 for (k
= 0; k
< scsi_debug_max_queue
; ++k
) {
2600 sqcp
= &queued_arr
[k
];
2601 init_timer(&sqcp
->cmnd_timer
);
2603 sqcp
->a_cmnd
= NULL
;
2605 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
2608 static void __init
sdebug_build_parts(unsigned char *ramp
,
2609 unsigned long store_size
)
2611 struct partition
* pp
;
2612 int starts
[SDEBUG_MAX_PARTS
+ 2];
2613 int sectors_per_part
, num_sectors
, k
;
2614 int heads_by_sects
, start_sec
, end_sec
;
2616 /* assume partition table already zeroed */
2617 if ((scsi_debug_num_parts
< 1) || (store_size
< 1048576))
2619 if (scsi_debug_num_parts
> SDEBUG_MAX_PARTS
) {
2620 scsi_debug_num_parts
= SDEBUG_MAX_PARTS
;
2621 printk(KERN_WARNING
"scsi_debug:build_parts: reducing "
2622 "partitions to %d\n", SDEBUG_MAX_PARTS
);
2624 num_sectors
= (int)sdebug_store_sectors
;
2625 sectors_per_part
= (num_sectors
- sdebug_sectors_per
)
2626 / scsi_debug_num_parts
;
2627 heads_by_sects
= sdebug_heads
* sdebug_sectors_per
;
2628 starts
[0] = sdebug_sectors_per
;
2629 for (k
= 1; k
< scsi_debug_num_parts
; ++k
)
2630 starts
[k
] = ((k
* sectors_per_part
) / heads_by_sects
)
2632 starts
[scsi_debug_num_parts
] = num_sectors
;
2633 starts
[scsi_debug_num_parts
+ 1] = 0;
2635 ramp
[510] = 0x55; /* magic partition markings */
2637 pp
= (struct partition
*)(ramp
+ 0x1be);
2638 for (k
= 0; starts
[k
+ 1]; ++k
, ++pp
) {
2639 start_sec
= starts
[k
];
2640 end_sec
= starts
[k
+ 1] - 1;
2643 pp
->cyl
= start_sec
/ heads_by_sects
;
2644 pp
->head
= (start_sec
- (pp
->cyl
* heads_by_sects
))
2645 / sdebug_sectors_per
;
2646 pp
->sector
= (start_sec
% sdebug_sectors_per
) + 1;
2648 pp
->end_cyl
= end_sec
/ heads_by_sects
;
2649 pp
->end_head
= (end_sec
- (pp
->end_cyl
* heads_by_sects
))
2650 / sdebug_sectors_per
;
2651 pp
->end_sector
= (end_sec
% sdebug_sectors_per
) + 1;
2653 pp
->start_sect
= start_sec
;
2654 pp
->nr_sects
= end_sec
- start_sec
+ 1;
2655 pp
->sys_ind
= 0x83; /* plain Linux partition */
2659 static int schedule_resp(struct scsi_cmnd
* cmnd
,
2660 struct sdebug_dev_info
* devip
,
2661 done_funct_t done
, int scsi_result
, int delta_jiff
)
2663 if ((SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
) && cmnd
) {
2665 struct scsi_device
* sdp
= cmnd
->device
;
2667 printk(KERN_INFO
"scsi_debug: <%u %u %u %u> "
2668 "non-zero result=0x%x\n", sdp
->host
->host_no
,
2669 sdp
->channel
, sdp
->id
, sdp
->lun
, scsi_result
);
2672 if (cmnd
&& devip
) {
2673 /* simulate autosense by this driver */
2674 if (SAM_STAT_CHECK_CONDITION
== (scsi_result
& 0xff))
2675 memcpy(cmnd
->sense_buffer
, devip
->sense_buff
,
2676 (SCSI_SENSE_BUFFERSIZE
> SDEBUG_SENSE_LEN
) ?
2677 SDEBUG_SENSE_LEN
: SCSI_SENSE_BUFFERSIZE
);
2679 if (delta_jiff
<= 0) {
2681 cmnd
->result
= scsi_result
;
2686 unsigned long iflags
;
2688 struct sdebug_queued_cmd
* sqcp
= NULL
;
2690 spin_lock_irqsave(&queued_arr_lock
, iflags
);
2691 for (k
= 0; k
< scsi_debug_max_queue
; ++k
) {
2692 sqcp
= &queued_arr
[k
];
2696 if (k
>= scsi_debug_max_queue
) {
2697 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
2698 printk(KERN_WARNING
"scsi_debug: can_queue exceeded\n");
2699 return 1; /* report busy to mid level */
2702 sqcp
->a_cmnd
= cmnd
;
2703 sqcp
->scsi_result
= scsi_result
;
2704 sqcp
->done_funct
= done
;
2705 sqcp
->cmnd_timer
.function
= timer_intr_handler
;
2706 sqcp
->cmnd_timer
.data
= k
;
2707 sqcp
->cmnd_timer
.expires
= jiffies
+ delta_jiff
;
2708 add_timer(&sqcp
->cmnd_timer
);
2709 spin_unlock_irqrestore(&queued_arr_lock
, iflags
);
2715 /* Note: The following macros create attribute files in the
2716 /sys/module/scsi_debug/parameters directory. Unfortunately this
2717 driver is unaware of a change and cannot trigger auxiliary actions
2718 as it can when the corresponding attribute in the
2719 /sys/bus/pseudo/drivers/scsi_debug directory is changed.
2721 module_param_named(add_host
, scsi_debug_add_host
, int, S_IRUGO
| S_IWUSR
);
2722 module_param_named(ato
, scsi_debug_ato
, int, S_IRUGO
);
2723 module_param_named(delay
, scsi_debug_delay
, int, S_IRUGO
| S_IWUSR
);
2724 module_param_named(dev_size_mb
, scsi_debug_dev_size_mb
, int, S_IRUGO
);
2725 module_param_named(dif
, scsi_debug_dif
, int, S_IRUGO
);
2726 module_param_named(dix
, scsi_debug_dix
, int, S_IRUGO
);
2727 module_param_named(dsense
, scsi_debug_dsense
, int, S_IRUGO
| S_IWUSR
);
2728 module_param_named(every_nth
, scsi_debug_every_nth
, int, S_IRUGO
| S_IWUSR
);
2729 module_param_named(fake_rw
, scsi_debug_fake_rw
, int, S_IRUGO
| S_IWUSR
);
2730 module_param_named(guard
, scsi_debug_guard
, int, S_IRUGO
);
2731 module_param_named(lbpu
, scsi_debug_lbpu
, int, S_IRUGO
);
2732 module_param_named(lbpws
, scsi_debug_lbpws
, int, S_IRUGO
);
2733 module_param_named(lbpws10
, scsi_debug_lbpws10
, int, S_IRUGO
);
2734 module_param_named(lowest_aligned
, scsi_debug_lowest_aligned
, int, S_IRUGO
);
2735 module_param_named(max_luns
, scsi_debug_max_luns
, int, S_IRUGO
| S_IWUSR
);
2736 module_param_named(max_queue
, scsi_debug_max_queue
, int, S_IRUGO
| S_IWUSR
);
2737 module_param_named(no_lun_0
, scsi_debug_no_lun_0
, int, S_IRUGO
| S_IWUSR
);
2738 module_param_named(no_uld
, scsi_debug_no_uld
, int, S_IRUGO
);
2739 module_param_named(num_parts
, scsi_debug_num_parts
, int, S_IRUGO
);
2740 module_param_named(num_tgts
, scsi_debug_num_tgts
, int, S_IRUGO
| S_IWUSR
);
2741 module_param_named(opt_blks
, scsi_debug_opt_blks
, int, S_IRUGO
);
2742 module_param_named(opts
, scsi_debug_opts
, int, S_IRUGO
| S_IWUSR
);
2743 module_param_named(physblk_exp
, scsi_debug_physblk_exp
, int, S_IRUGO
);
2744 module_param_named(ptype
, scsi_debug_ptype
, int, S_IRUGO
| S_IWUSR
);
2745 module_param_named(scsi_level
, scsi_debug_scsi_level
, int, S_IRUGO
);
2746 module_param_named(sector_size
, scsi_debug_sector_size
, int, S_IRUGO
);
2747 module_param_named(unmap_alignment
, scsi_debug_unmap_alignment
, int, S_IRUGO
);
2748 module_param_named(unmap_granularity
, scsi_debug_unmap_granularity
, int, S_IRUGO
);
2749 module_param_named(unmap_max_blocks
, scsi_debug_unmap_max_blocks
, int, S_IRUGO
);
2750 module_param_named(unmap_max_desc
, scsi_debug_unmap_max_desc
, int, S_IRUGO
);
2751 module_param_named(virtual_gb
, scsi_debug_virtual_gb
, int, S_IRUGO
| S_IWUSR
);
2752 module_param_named(vpd_use_hostno
, scsi_debug_vpd_use_hostno
, int,
2754 module_param_named(write_same_length
, scsi_debug_write_same_length
, int,
2757 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2758 MODULE_DESCRIPTION("SCSI debug adapter driver");
2759 MODULE_LICENSE("GPL");
2760 MODULE_VERSION(SCSI_DEBUG_VERSION
);
2762 MODULE_PARM_DESC(add_host
, "0..127 hosts allowed(def=1)");
2763 MODULE_PARM_DESC(ato
, "application tag ownership: 0=disk 1=host (def=1)");
2764 MODULE_PARM_DESC(delay
, "# of jiffies to delay response(def=1)");
2765 MODULE_PARM_DESC(dev_size_mb
, "size in MB of ram shared by devs(def=8)");
2766 MODULE_PARM_DESC(dif
, "data integrity field type: 0-3 (def=0)");
2767 MODULE_PARM_DESC(dix
, "data integrity extensions mask (def=0)");
2768 MODULE_PARM_DESC(dsense
, "use descriptor sense format(def=0 -> fixed)");
2769 MODULE_PARM_DESC(every_nth
, "timeout every nth command(def=0)");
2770 MODULE_PARM_DESC(fake_rw
, "fake reads/writes instead of copying (def=0)");
2771 MODULE_PARM_DESC(guard
, "protection checksum: 0=crc, 1=ip (def=0)");
2772 MODULE_PARM_DESC(lbpu
, "enable LBP, support UNMAP command (def=0)");
2773 MODULE_PARM_DESC(lbpws
, "enable LBP, support WRITE SAME(16) with UNMAP bit (def=0)");
2774 MODULE_PARM_DESC(lbpws10
, "enable LBP, support WRITE SAME(10) with UNMAP bit (def=0)");
2775 MODULE_PARM_DESC(lowest_aligned
, "lowest aligned lba (def=0)");
2776 MODULE_PARM_DESC(max_luns
, "number of LUNs per target to simulate(def=1)");
2777 MODULE_PARM_DESC(max_queue
, "max number of queued commands (1 to 255(def))");
2778 MODULE_PARM_DESC(no_lun_0
, "no LU number 0 (def=0 -> have lun 0)");
2779 MODULE_PARM_DESC(no_uld
, "stop ULD (e.g. sd driver) attaching (def=0))");
2780 MODULE_PARM_DESC(num_parts
, "number of partitions(def=0)");
2781 MODULE_PARM_DESC(num_tgts
, "number of targets per host to simulate(def=1)");
2782 MODULE_PARM_DESC(opt_blks
, "optimal transfer length in block (def=64)");
2783 MODULE_PARM_DESC(opts
, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
2784 MODULE_PARM_DESC(physblk_exp
, "physical block exponent (def=0)");
2785 MODULE_PARM_DESC(ptype
, "SCSI peripheral type(def=0[disk])");
2786 MODULE_PARM_DESC(scsi_level
, "SCSI level to simulate(def=5[SPC-3])");
2787 MODULE_PARM_DESC(sector_size
, "logical block size in bytes (def=512)");
2788 MODULE_PARM_DESC(unmap_alignment
, "lowest aligned thin provisioning lba (def=0)");
2789 MODULE_PARM_DESC(unmap_granularity
, "thin provisioning granularity in blocks (def=1)");
2790 MODULE_PARM_DESC(unmap_max_blocks
, "max # of blocks can be unmapped in one cmd (def=0xffffffff)");
2791 MODULE_PARM_DESC(unmap_max_desc
, "max # of ranges that can be unmapped in one cmd (def=256)");
2792 MODULE_PARM_DESC(virtual_gb
, "virtual gigabyte size (def=0 -> use dev_size_mb)");
2793 MODULE_PARM_DESC(vpd_use_hostno
, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2794 MODULE_PARM_DESC(write_same_length
, "Maximum blocks per WRITE SAME cmd (def=0xffff)");
2796 static char sdebug_info
[256];
2798 static const char * scsi_debug_info(struct Scsi_Host
* shp
)
2800 sprintf(sdebug_info
, "scsi_debug, version %s [%s], "
2801 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION
,
2802 scsi_debug_version_date
, scsi_debug_dev_size_mb
,
2807 /* scsi_debug_proc_info
2808 * Used if the driver currently has no own support for /proc/scsi
2810 static int scsi_debug_proc_info(struct Scsi_Host
*host
, char *buffer
, char **start
, off_t offset
,
2811 int length
, int inout
)
2813 int len
, pos
, begin
;
2816 orig_length
= length
;
2820 int minLen
= length
> 15 ? 15 : length
;
2822 if (!capable(CAP_SYS_ADMIN
) || !capable(CAP_SYS_RAWIO
))
2824 memcpy(arr
, buffer
, minLen
);
2826 if (1 != sscanf(arr
, "%d", &pos
))
2828 scsi_debug_opts
= pos
;
2829 if (scsi_debug_every_nth
!= 0)
2830 scsi_debug_cmnd_count
= 0;
2834 pos
= len
= sprintf(buffer
, "scsi_debug adapter driver, version "
2836 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2837 "every_nth=%d(curr:%d)\n"
2838 "delay=%d, max_luns=%d, scsi_level=%d\n"
2839 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2840 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2841 "host_resets=%d\ndix_reads=%d dix_writes=%d dif_errors=%d\n",
2842 SCSI_DEBUG_VERSION
, scsi_debug_version_date
, scsi_debug_num_tgts
,
2843 scsi_debug_dev_size_mb
, scsi_debug_opts
, scsi_debug_every_nth
,
2844 scsi_debug_cmnd_count
, scsi_debug_delay
,
2845 scsi_debug_max_luns
, scsi_debug_scsi_level
,
2846 scsi_debug_sector_size
, sdebug_cylinders_per
, sdebug_heads
,
2847 sdebug_sectors_per
, num_aborts
, num_dev_resets
, num_bus_resets
,
2848 num_host_resets
, dix_reads
, dix_writes
, dif_errors
);
2853 *start
= buffer
+ (offset
- begin
); /* Start of wanted data */
2854 len
-= (offset
- begin
);
2860 static ssize_t
sdebug_delay_show(struct device_driver
* ddp
, char * buf
)
2862 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_delay
);
2865 static ssize_t
sdebug_delay_store(struct device_driver
* ddp
,
2866 const char * buf
, size_t count
)
2871 if (1 == sscanf(buf
, "%10s", work
)) {
2872 if ((1 == sscanf(work
, "%d", &delay
)) && (delay
>= 0)) {
2873 scsi_debug_delay
= delay
;
2879 DRIVER_ATTR(delay
, S_IRUGO
| S_IWUSR
, sdebug_delay_show
,
2880 sdebug_delay_store
);
2882 static ssize_t
sdebug_opts_show(struct device_driver
* ddp
, char * buf
)
2884 return scnprintf(buf
, PAGE_SIZE
, "0x%x\n", scsi_debug_opts
);
2887 static ssize_t
sdebug_opts_store(struct device_driver
* ddp
,
2888 const char * buf
, size_t count
)
2893 if (1 == sscanf(buf
, "%10s", work
)) {
2894 if (0 == strnicmp(work
,"0x", 2)) {
2895 if (1 == sscanf(&work
[2], "%x", &opts
))
2898 if (1 == sscanf(work
, "%d", &opts
))
2904 scsi_debug_opts
= opts
;
2905 scsi_debug_cmnd_count
= 0;
2908 DRIVER_ATTR(opts
, S_IRUGO
| S_IWUSR
, sdebug_opts_show
,
2911 static ssize_t
sdebug_ptype_show(struct device_driver
* ddp
, char * buf
)
2913 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_ptype
);
2915 static ssize_t
sdebug_ptype_store(struct device_driver
* ddp
,
2916 const char * buf
, size_t count
)
2920 if ((count
> 0) && (1 == sscanf(buf
, "%d", &n
)) && (n
>= 0)) {
2921 scsi_debug_ptype
= n
;
2926 DRIVER_ATTR(ptype
, S_IRUGO
| S_IWUSR
, sdebug_ptype_show
, sdebug_ptype_store
);
2928 static ssize_t
sdebug_dsense_show(struct device_driver
* ddp
, char * buf
)
2930 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_dsense
);
2932 static ssize_t
sdebug_dsense_store(struct device_driver
* ddp
,
2933 const char * buf
, size_t count
)
2937 if ((count
> 0) && (1 == sscanf(buf
, "%d", &n
)) && (n
>= 0)) {
2938 scsi_debug_dsense
= n
;
2943 DRIVER_ATTR(dsense
, S_IRUGO
| S_IWUSR
, sdebug_dsense_show
,
2944 sdebug_dsense_store
);
2946 static ssize_t
sdebug_fake_rw_show(struct device_driver
* ddp
, char * buf
)
2948 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_fake_rw
);
2950 static ssize_t
sdebug_fake_rw_store(struct device_driver
* ddp
,
2951 const char * buf
, size_t count
)
2955 if ((count
> 0) && (1 == sscanf(buf
, "%d", &n
)) && (n
>= 0)) {
2956 scsi_debug_fake_rw
= n
;
2961 DRIVER_ATTR(fake_rw
, S_IRUGO
| S_IWUSR
, sdebug_fake_rw_show
,
2962 sdebug_fake_rw_store
);
2964 static ssize_t
sdebug_no_lun_0_show(struct device_driver
* ddp
, char * buf
)
2966 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_no_lun_0
);
2968 static ssize_t
sdebug_no_lun_0_store(struct device_driver
* ddp
,
2969 const char * buf
, size_t count
)
2973 if ((count
> 0) && (1 == sscanf(buf
, "%d", &n
)) && (n
>= 0)) {
2974 scsi_debug_no_lun_0
= n
;
2979 DRIVER_ATTR(no_lun_0
, S_IRUGO
| S_IWUSR
, sdebug_no_lun_0_show
,
2980 sdebug_no_lun_0_store
);
2982 static ssize_t
sdebug_num_tgts_show(struct device_driver
* ddp
, char * buf
)
2984 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_num_tgts
);
2986 static ssize_t
sdebug_num_tgts_store(struct device_driver
* ddp
,
2987 const char * buf
, size_t count
)
2991 if ((count
> 0) && (1 == sscanf(buf
, "%d", &n
)) && (n
>= 0)) {
2992 scsi_debug_num_tgts
= n
;
2993 sdebug_max_tgts_luns();
2998 DRIVER_ATTR(num_tgts
, S_IRUGO
| S_IWUSR
, sdebug_num_tgts_show
,
2999 sdebug_num_tgts_store
);
3001 static ssize_t
sdebug_dev_size_mb_show(struct device_driver
* ddp
, char * buf
)
3003 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_dev_size_mb
);
3005 DRIVER_ATTR(dev_size_mb
, S_IRUGO
, sdebug_dev_size_mb_show
, NULL
);
3007 static ssize_t
sdebug_num_parts_show(struct device_driver
* ddp
, char * buf
)
3009 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_num_parts
);
3011 DRIVER_ATTR(num_parts
, S_IRUGO
, sdebug_num_parts_show
, NULL
);
3013 static ssize_t
sdebug_every_nth_show(struct device_driver
* ddp
, char * buf
)
3015 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_every_nth
);
3017 static ssize_t
sdebug_every_nth_store(struct device_driver
* ddp
,
3018 const char * buf
, size_t count
)
3022 if ((count
> 0) && (1 == sscanf(buf
, "%d", &nth
))) {
3023 scsi_debug_every_nth
= nth
;
3024 scsi_debug_cmnd_count
= 0;
3029 DRIVER_ATTR(every_nth
, S_IRUGO
| S_IWUSR
, sdebug_every_nth_show
,
3030 sdebug_every_nth_store
);
3032 static ssize_t
sdebug_max_luns_show(struct device_driver
* ddp
, char * buf
)
3034 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_max_luns
);
3036 static ssize_t
sdebug_max_luns_store(struct device_driver
* ddp
,
3037 const char * buf
, size_t count
)
3041 if ((count
> 0) && (1 == sscanf(buf
, "%d", &n
)) && (n
>= 0)) {
3042 scsi_debug_max_luns
= n
;
3043 sdebug_max_tgts_luns();
3048 DRIVER_ATTR(max_luns
, S_IRUGO
| S_IWUSR
, sdebug_max_luns_show
,
3049 sdebug_max_luns_store
);
3051 static ssize_t
sdebug_max_queue_show(struct device_driver
* ddp
, char * buf
)
3053 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_max_queue
);
3055 static ssize_t
sdebug_max_queue_store(struct device_driver
* ddp
,
3056 const char * buf
, size_t count
)
3060 if ((count
> 0) && (1 == sscanf(buf
, "%d", &n
)) && (n
> 0) &&
3061 (n
<= SCSI_DEBUG_CANQUEUE
)) {
3062 scsi_debug_max_queue
= n
;
3067 DRIVER_ATTR(max_queue
, S_IRUGO
| S_IWUSR
, sdebug_max_queue_show
,
3068 sdebug_max_queue_store
);
3070 static ssize_t
sdebug_no_uld_show(struct device_driver
* ddp
, char * buf
)
3072 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_no_uld
);
3074 DRIVER_ATTR(no_uld
, S_IRUGO
, sdebug_no_uld_show
, NULL
);
3076 static ssize_t
sdebug_scsi_level_show(struct device_driver
* ddp
, char * buf
)
3078 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_scsi_level
);
3080 DRIVER_ATTR(scsi_level
, S_IRUGO
, sdebug_scsi_level_show
, NULL
);
3082 static ssize_t
sdebug_virtual_gb_show(struct device_driver
* ddp
, char * buf
)
3084 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_virtual_gb
);
3086 static ssize_t
sdebug_virtual_gb_store(struct device_driver
* ddp
,
3087 const char * buf
, size_t count
)
3091 if ((count
> 0) && (1 == sscanf(buf
, "%d", &n
)) && (n
>= 0)) {
3092 scsi_debug_virtual_gb
= n
;
3094 sdebug_capacity
= get_sdebug_capacity();
3100 DRIVER_ATTR(virtual_gb
, S_IRUGO
| S_IWUSR
, sdebug_virtual_gb_show
,
3101 sdebug_virtual_gb_store
);
3103 static ssize_t
sdebug_add_host_show(struct device_driver
* ddp
, char * buf
)
3105 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_add_host
);
3108 static ssize_t
sdebug_add_host_store(struct device_driver
* ddp
,
3109 const char * buf
, size_t count
)
3113 if (sscanf(buf
, "%d", &delta_hosts
) != 1)
3115 if (delta_hosts
> 0) {
3117 sdebug_add_adapter();
3118 } while (--delta_hosts
);
3119 } else if (delta_hosts
< 0) {
3121 sdebug_remove_adapter();
3122 } while (++delta_hosts
);
3126 DRIVER_ATTR(add_host
, S_IRUGO
| S_IWUSR
, sdebug_add_host_show
,
3127 sdebug_add_host_store
);
3129 static ssize_t
sdebug_vpd_use_hostno_show(struct device_driver
* ddp
,
3132 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_vpd_use_hostno
);
3134 static ssize_t
sdebug_vpd_use_hostno_store(struct device_driver
* ddp
,
3135 const char * buf
, size_t count
)
3139 if ((count
> 0) && (1 == sscanf(buf
, "%d", &n
)) && (n
>= 0)) {
3140 scsi_debug_vpd_use_hostno
= n
;
3145 DRIVER_ATTR(vpd_use_hostno
, S_IRUGO
| S_IWUSR
, sdebug_vpd_use_hostno_show
,
3146 sdebug_vpd_use_hostno_store
);
3148 static ssize_t
sdebug_sector_size_show(struct device_driver
* ddp
, char * buf
)
3150 return scnprintf(buf
, PAGE_SIZE
, "%u\n", scsi_debug_sector_size
);
3152 DRIVER_ATTR(sector_size
, S_IRUGO
, sdebug_sector_size_show
, NULL
);
3154 static ssize_t
sdebug_dix_show(struct device_driver
*ddp
, char *buf
)
3156 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_dix
);
3158 DRIVER_ATTR(dix
, S_IRUGO
, sdebug_dix_show
, NULL
);
3160 static ssize_t
sdebug_dif_show(struct device_driver
*ddp
, char *buf
)
3162 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_dif
);
3164 DRIVER_ATTR(dif
, S_IRUGO
, sdebug_dif_show
, NULL
);
3166 static ssize_t
sdebug_guard_show(struct device_driver
*ddp
, char *buf
)
3168 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_guard
);
3170 DRIVER_ATTR(guard
, S_IRUGO
, sdebug_guard_show
, NULL
);
3172 static ssize_t
sdebug_ato_show(struct device_driver
*ddp
, char *buf
)
3174 return scnprintf(buf
, PAGE_SIZE
, "%d\n", scsi_debug_ato
);
3176 DRIVER_ATTR(ato
, S_IRUGO
, sdebug_ato_show
, NULL
);
3178 static ssize_t
sdebug_map_show(struct device_driver
*ddp
, char *buf
)
3182 if (!scsi_debug_lbp())
3183 return scnprintf(buf
, PAGE_SIZE
, "0-%u\n",
3184 sdebug_store_sectors
);
3186 count
= bitmap_scnlistprintf(buf
, PAGE_SIZE
, map_storep
, map_size
);
3188 buf
[count
++] = '\n';
3193 DRIVER_ATTR(map
, S_IRUGO
, sdebug_map_show
, NULL
);
3196 /* Note: The following function creates attribute files in the
3197 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
3198 files (over those found in the /sys/module/scsi_debug/parameters
3199 directory) is that auxiliary actions can be triggered when an attribute
3200 is changed. For example see: sdebug_add_host_store() above.
3202 static int do_create_driverfs_files(void)
3206 ret
= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_add_host
);
3207 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_delay
);
3208 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_dev_size_mb
);
3209 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_dsense
);
3210 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_every_nth
);
3211 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_fake_rw
);
3212 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_max_luns
);
3213 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_max_queue
);
3214 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_no_lun_0
);
3215 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_no_uld
);
3216 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_num_parts
);
3217 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_num_tgts
);
3218 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_ptype
);
3219 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_opts
);
3220 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_scsi_level
);
3221 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_virtual_gb
);
3222 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_vpd_use_hostno
);
3223 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_sector_size
);
3224 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_dix
);
3225 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_dif
);
3226 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_guard
);
3227 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_ato
);
3228 ret
|= driver_create_file(&sdebug_driverfs_driver
, &driver_attr_map
);
3232 static void do_remove_driverfs_files(void)
3234 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_map
);
3235 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_ato
);
3236 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_guard
);
3237 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_dif
);
3238 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_dix
);
3239 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_sector_size
);
3240 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_vpd_use_hostno
);
3241 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_virtual_gb
);
3242 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_scsi_level
);
3243 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_opts
);
3244 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_ptype
);
3245 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_num_tgts
);
3246 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_num_parts
);
3247 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_no_uld
);
3248 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_no_lun_0
);
3249 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_max_queue
);
3250 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_max_luns
);
3251 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_fake_rw
);
3252 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_every_nth
);
3253 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_dsense
);
3254 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_dev_size_mb
);
3255 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_delay
);
3256 driver_remove_file(&sdebug_driverfs_driver
, &driver_attr_add_host
);
3259 struct device
*pseudo_primary
;
3261 static int __init
scsi_debug_init(void)
3268 switch (scsi_debug_sector_size
) {
3275 printk(KERN_ERR
"scsi_debug_init: invalid sector_size %d\n",
3276 scsi_debug_sector_size
);
3280 switch (scsi_debug_dif
) {
3282 case SD_DIF_TYPE0_PROTECTION
:
3283 case SD_DIF_TYPE1_PROTECTION
:
3284 case SD_DIF_TYPE2_PROTECTION
:
3285 case SD_DIF_TYPE3_PROTECTION
:
3289 printk(KERN_ERR
"scsi_debug_init: dif must be 0, 1, 2 or 3\n");
3293 if (scsi_debug_guard
> 1) {
3294 printk(KERN_ERR
"scsi_debug_init: guard must be 0 or 1\n");
3298 if (scsi_debug_ato
> 1) {
3299 printk(KERN_ERR
"scsi_debug_init: ato must be 0 or 1\n");
3303 if (scsi_debug_physblk_exp
> 15) {
3304 printk(KERN_ERR
"scsi_debug_init: invalid physblk_exp %u\n",
3305 scsi_debug_physblk_exp
);
3309 if (scsi_debug_lowest_aligned
> 0x3fff) {
3310 printk(KERN_ERR
"scsi_debug_init: lowest_aligned too big: %u\n",
3311 scsi_debug_lowest_aligned
);
3315 if (scsi_debug_dev_size_mb
< 1)
3316 scsi_debug_dev_size_mb
= 1; /* force minimum 1 MB ramdisk */
3317 sz
= (unsigned long)scsi_debug_dev_size_mb
* 1048576;
3318 sdebug_store_sectors
= sz
/ scsi_debug_sector_size
;
3319 sdebug_capacity
= get_sdebug_capacity();
3321 /* play around with geometry, don't waste too much on track 0 */
3323 sdebug_sectors_per
= 32;
3324 if (scsi_debug_dev_size_mb
>= 16)
3326 else if (scsi_debug_dev_size_mb
>= 256)
3328 sdebug_cylinders_per
= (unsigned long)sdebug_capacity
/
3329 (sdebug_sectors_per
* sdebug_heads
);
3330 if (sdebug_cylinders_per
>= 1024) {
3331 /* other LLDs do this; implies >= 1GB ram disk ... */
3333 sdebug_sectors_per
= 63;
3334 sdebug_cylinders_per
= (unsigned long)sdebug_capacity
/
3335 (sdebug_sectors_per
* sdebug_heads
);
3338 fake_storep
= vmalloc(sz
);
3339 if (NULL
== fake_storep
) {
3340 printk(KERN_ERR
"scsi_debug_init: out of memory, 1\n");
3343 memset(fake_storep
, 0, sz
);
3344 if (scsi_debug_num_parts
> 0)
3345 sdebug_build_parts(fake_storep
, sz
);
3347 if (scsi_debug_dif
) {
3350 dif_size
= sdebug_store_sectors
* sizeof(struct sd_dif_tuple
);
3351 dif_storep
= vmalloc(dif_size
);
3353 printk(KERN_ERR
"scsi_debug_init: dif_storep %u bytes @ %p\n",
3354 dif_size
, dif_storep
);
3356 if (dif_storep
== NULL
) {
3357 printk(KERN_ERR
"scsi_debug_init: out of mem. (DIX)\n");
3362 memset(dif_storep
, 0xff, dif_size
);
3365 /* Logical Block Provisioning */
3366 if (scsi_debug_lbp()) {
3367 unsigned int map_bytes
;
3369 scsi_debug_unmap_max_blocks
=
3370 clamp(scsi_debug_unmap_max_blocks
, 0U, 0xffffffffU
);
3372 scsi_debug_unmap_max_desc
=
3373 clamp(scsi_debug_unmap_max_desc
, 0U, 256U);
3375 scsi_debug_unmap_granularity
=
3376 clamp(scsi_debug_unmap_granularity
, 1U, 0xffffffffU
);
3378 if (scsi_debug_unmap_alignment
&&
3379 scsi_debug_unmap_granularity
< scsi_debug_unmap_alignment
) {
3381 "%s: ERR: unmap_granularity < unmap_alignment\n",
3386 map_size
= (sdebug_store_sectors
/ scsi_debug_unmap_granularity
);
3387 map_bytes
= map_size
>> 3;
3388 map_storep
= vmalloc(map_bytes
);
3390 printk(KERN_INFO
"scsi_debug_init: %lu provisioning blocks\n",
3393 if (map_storep
== NULL
) {
3394 printk(KERN_ERR
"scsi_debug_init: out of mem. (MAP)\n");
3399 memset(map_storep
, 0x0, map_bytes
);
3401 /* Map first 1KB for partition table */
3402 if (scsi_debug_num_parts
)
3406 pseudo_primary
= root_device_register("pseudo_0");
3407 if (IS_ERR(pseudo_primary
)) {
3408 printk(KERN_WARNING
"scsi_debug: root_device_register() error\n");
3409 ret
= PTR_ERR(pseudo_primary
);
3412 ret
= bus_register(&pseudo_lld_bus
);
3414 printk(KERN_WARNING
"scsi_debug: bus_register error: %d\n",
3418 ret
= driver_register(&sdebug_driverfs_driver
);
3420 printk(KERN_WARNING
"scsi_debug: driver_register error: %d\n",
3424 ret
= do_create_driverfs_files();
3426 printk(KERN_WARNING
"scsi_debug: driver_create_file error: %d\n",
3433 host_to_add
= scsi_debug_add_host
;
3434 scsi_debug_add_host
= 0;
3436 for (k
= 0; k
< host_to_add
; k
++) {
3437 if (sdebug_add_adapter()) {
3438 printk(KERN_ERR
"scsi_debug_init: "
3439 "sdebug_add_adapter failed k=%d\n", k
);
3444 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
) {
3445 printk(KERN_INFO
"scsi_debug_init: built %d host(s)\n",
3446 scsi_debug_add_host
);
3451 do_remove_driverfs_files();
3452 driver_unregister(&sdebug_driverfs_driver
);
3454 bus_unregister(&pseudo_lld_bus
);
3456 root_device_unregister(pseudo_primary
);
3467 static void __exit
scsi_debug_exit(void)
3469 int k
= scsi_debug_add_host
;
3473 sdebug_remove_adapter();
3474 do_remove_driverfs_files();
3475 driver_unregister(&sdebug_driverfs_driver
);
3476 bus_unregister(&pseudo_lld_bus
);
3477 root_device_unregister(pseudo_primary
);
3485 device_initcall(scsi_debug_init
);
3486 module_exit(scsi_debug_exit
);
3488 static void sdebug_release_adapter(struct device
* dev
)
3490 struct sdebug_host_info
*sdbg_host
;
3492 sdbg_host
= to_sdebug_host(dev
);
3496 static int sdebug_add_adapter(void)
3498 int k
, devs_per_host
;
3500 struct sdebug_host_info
*sdbg_host
;
3501 struct sdebug_dev_info
*sdbg_devinfo
, *tmp
;
3503 sdbg_host
= kzalloc(sizeof(*sdbg_host
),GFP_KERNEL
);
3504 if (NULL
== sdbg_host
) {
3505 printk(KERN_ERR
"%s: out of memory at line %d\n",
3506 __func__
, __LINE__
);
3510 INIT_LIST_HEAD(&sdbg_host
->dev_info_list
);
3512 devs_per_host
= scsi_debug_num_tgts
* scsi_debug_max_luns
;
3513 for (k
= 0; k
< devs_per_host
; k
++) {
3514 sdbg_devinfo
= sdebug_device_create(sdbg_host
, GFP_KERNEL
);
3515 if (!sdbg_devinfo
) {
3516 printk(KERN_ERR
"%s: out of memory at line %d\n",
3517 __func__
, __LINE__
);
3523 spin_lock(&sdebug_host_list_lock
);
3524 list_add_tail(&sdbg_host
->host_list
, &sdebug_host_list
);
3525 spin_unlock(&sdebug_host_list_lock
);
3527 sdbg_host
->dev
.bus
= &pseudo_lld_bus
;
3528 sdbg_host
->dev
.parent
= pseudo_primary
;
3529 sdbg_host
->dev
.release
= &sdebug_release_adapter
;
3530 dev_set_name(&sdbg_host
->dev
, "adapter%d", scsi_debug_add_host
);
3532 error
= device_register(&sdbg_host
->dev
);
3537 ++scsi_debug_add_host
;
3541 list_for_each_entry_safe(sdbg_devinfo
, tmp
, &sdbg_host
->dev_info_list
,
3543 list_del(&sdbg_devinfo
->dev_list
);
3544 kfree(sdbg_devinfo
);
3551 static void sdebug_remove_adapter(void)
3553 struct sdebug_host_info
* sdbg_host
= NULL
;
3555 spin_lock(&sdebug_host_list_lock
);
3556 if (!list_empty(&sdebug_host_list
)) {
3557 sdbg_host
= list_entry(sdebug_host_list
.prev
,
3558 struct sdebug_host_info
, host_list
);
3559 list_del(&sdbg_host
->host_list
);
3561 spin_unlock(&sdebug_host_list_lock
);
3566 device_unregister(&sdbg_host
->dev
);
3567 --scsi_debug_add_host
;
3571 int scsi_debug_queuecommand_lck(struct scsi_cmnd
*SCpnt
, done_funct_t done
)
3573 unsigned char *cmd
= (unsigned char *) SCpnt
->cmnd
;
3576 unsigned long long lba
;
3579 int target
= SCpnt
->device
->id
;
3580 struct sdebug_dev_info
*devip
= NULL
;
3581 int inj_recovered
= 0;
3582 int inj_transport
= 0;
3585 int delay_override
= 0;
3588 scsi_set_resid(SCpnt
, 0);
3589 if ((SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
) && cmd
) {
3590 printk(KERN_INFO
"scsi_debug: cmd ");
3591 for (k
= 0, len
= SCpnt
->cmd_len
; k
< len
; ++k
)
3592 printk("%02x ", (int)cmd
[k
]);
3596 if (target
== SCpnt
->device
->host
->hostt
->this_id
) {
3597 printk(KERN_INFO
"scsi_debug: initiator's id used as "
3599 return schedule_resp(SCpnt
, NULL
, done
,
3600 DID_NO_CONNECT
<< 16, 0);
3603 if ((SCpnt
->device
->lun
>= scsi_debug_max_luns
) &&
3604 (SCpnt
->device
->lun
!= SAM2_WLUN_REPORT_LUNS
))
3605 return schedule_resp(SCpnt
, NULL
, done
,
3606 DID_NO_CONNECT
<< 16, 0);
3607 devip
= devInfoReg(SCpnt
->device
);
3609 return schedule_resp(SCpnt
, NULL
, done
,
3610 DID_NO_CONNECT
<< 16, 0);
3612 if ((scsi_debug_every_nth
!= 0) &&
3613 (++scsi_debug_cmnd_count
>= abs(scsi_debug_every_nth
))) {
3614 scsi_debug_cmnd_count
= 0;
3615 if (scsi_debug_every_nth
< -1)
3616 scsi_debug_every_nth
= -1;
3617 if (SCSI_DEBUG_OPT_TIMEOUT
& scsi_debug_opts
)
3618 return 0; /* ignore command causing timeout */
3619 else if (SCSI_DEBUG_OPT_MAC_TIMEOUT
& scsi_debug_opts
&&
3620 scsi_medium_access_command(SCpnt
))
3621 return 0; /* time out reads and writes */
3622 else if (SCSI_DEBUG_OPT_RECOVERED_ERR
& scsi_debug_opts
)
3623 inj_recovered
= 1; /* to reads and writes below */
3624 else if (SCSI_DEBUG_OPT_TRANSPORT_ERR
& scsi_debug_opts
)
3625 inj_transport
= 1; /* to reads and writes below */
3626 else if (SCSI_DEBUG_OPT_DIF_ERR
& scsi_debug_opts
)
3627 inj_dif
= 1; /* to reads and writes below */
3628 else if (SCSI_DEBUG_OPT_DIX_ERR
& scsi_debug_opts
)
3629 inj_dix
= 1; /* to reads and writes below */
3636 case TEST_UNIT_READY
:
3638 break; /* only allowable wlun commands */
3640 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
3641 printk(KERN_INFO
"scsi_debug: Opcode: 0x%x "
3642 "not supported for wlun\n", *cmd
);
3643 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
3645 errsts
= check_condition_result
;
3646 return schedule_resp(SCpnt
, devip
, done
, errsts
,
3652 case INQUIRY
: /* mandatory, ignore unit attention */
3654 errsts
= resp_inquiry(SCpnt
, target
, devip
);
3656 case REQUEST_SENSE
: /* mandatory, ignore unit attention */
3658 errsts
= resp_requests(SCpnt
, devip
);
3660 case REZERO_UNIT
: /* actually this is REWIND for SSC */
3662 errsts
= resp_start_stop(SCpnt
, devip
);
3664 case ALLOW_MEDIUM_REMOVAL
:
3665 errsts
= check_readiness(SCpnt
, 1, devip
);
3668 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
3669 printk(KERN_INFO
"scsi_debug: Medium removal %s\n",
3670 cmd
[4] ? "inhibited" : "enabled");
3672 case SEND_DIAGNOSTIC
: /* mandatory */
3673 errsts
= check_readiness(SCpnt
, 1, devip
);
3675 case TEST_UNIT_READY
: /* mandatory */
3677 errsts
= check_readiness(SCpnt
, 0, devip
);
3680 errsts
= check_readiness(SCpnt
, 1, devip
);
3683 errsts
= check_readiness(SCpnt
, 1, devip
);
3686 errsts
= check_readiness(SCpnt
, 1, devip
);
3689 errsts
= check_readiness(SCpnt
, 1, devip
);
3692 errsts
= resp_readcap(SCpnt
, devip
);
3694 case SERVICE_ACTION_IN
:
3695 if (cmd
[1] == SAI_READ_CAPACITY_16
)
3696 errsts
= resp_readcap16(SCpnt
, devip
);
3697 else if (cmd
[1] == SAI_GET_LBA_STATUS
) {
3699 if (scsi_debug_lbp() == 0) {
3700 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
3701 INVALID_COMMAND_OPCODE
, 0);
3702 errsts
= check_condition_result
;
3704 errsts
= resp_get_lba_status(SCpnt
, devip
);
3706 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
3708 errsts
= check_condition_result
;
3711 case MAINTENANCE_IN
:
3712 if (MI_REPORT_TARGET_PGS
!= cmd
[1]) {
3713 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
3715 errsts
= check_condition_result
;
3718 errsts
= resp_report_tgtpgs(SCpnt
, devip
);
3723 /* READ{10,12,16} and DIF Type 2 are natural enemies */
3724 if (scsi_debug_dif
== SD_DIF_TYPE2_PROTECTION
&&
3726 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
3727 INVALID_COMMAND_OPCODE
, 0);
3728 errsts
= check_condition_result
;
3732 if ((scsi_debug_dif
== SD_DIF_TYPE1_PROTECTION
||
3733 scsi_debug_dif
== SD_DIF_TYPE3_PROTECTION
) &&
3734 (cmd
[1] & 0xe0) == 0)
3735 printk(KERN_ERR
"Unprotected RD/WR to DIF device\n");
3740 errsts
= check_readiness(SCpnt
, 0, devip
);
3743 if (scsi_debug_fake_rw
)
3745 get_data_transfer_info(cmd
, &lba
, &num
, &ei_lba
);
3746 errsts
= resp_read(SCpnt
, lba
, num
, devip
, ei_lba
);
3747 if (inj_recovered
&& (0 == errsts
)) {
3748 mk_sense_buffer(devip
, RECOVERED_ERROR
,
3749 THRESHOLD_EXCEEDED
, 0);
3750 errsts
= check_condition_result
;
3751 } else if (inj_transport
&& (0 == errsts
)) {
3752 mk_sense_buffer(devip
, ABORTED_COMMAND
,
3753 TRANSPORT_PROBLEM
, ACK_NAK_TO
);
3754 errsts
= check_condition_result
;
3755 } else if (inj_dif
&& (0 == errsts
)) {
3756 mk_sense_buffer(devip
, ABORTED_COMMAND
, 0x10, 1);
3757 errsts
= illegal_condition_result
;
3758 } else if (inj_dix
&& (0 == errsts
)) {
3759 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, 0x10, 1);
3760 errsts
= illegal_condition_result
;
3763 case REPORT_LUNS
: /* mandatory, ignore unit attention */
3765 errsts
= resp_report_luns(SCpnt
, devip
);
3767 case VERIFY
: /* 10 byte SBC-2 command */
3768 errsts
= check_readiness(SCpnt
, 0, devip
);
3773 /* WRITE{10,12,16} and DIF Type 2 are natural enemies */
3774 if (scsi_debug_dif
== SD_DIF_TYPE2_PROTECTION
&&
3776 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
3777 INVALID_COMMAND_OPCODE
, 0);
3778 errsts
= check_condition_result
;
3782 if ((scsi_debug_dif
== SD_DIF_TYPE1_PROTECTION
||
3783 scsi_debug_dif
== SD_DIF_TYPE3_PROTECTION
) &&
3784 (cmd
[1] & 0xe0) == 0)
3785 printk(KERN_ERR
"Unprotected RD/WR to DIF device\n");
3790 errsts
= check_readiness(SCpnt
, 0, devip
);
3793 if (scsi_debug_fake_rw
)
3795 get_data_transfer_info(cmd
, &lba
, &num
, &ei_lba
);
3796 errsts
= resp_write(SCpnt
, lba
, num
, devip
, ei_lba
);
3797 if (inj_recovered
&& (0 == errsts
)) {
3798 mk_sense_buffer(devip
, RECOVERED_ERROR
,
3799 THRESHOLD_EXCEEDED
, 0);
3800 errsts
= check_condition_result
;
3801 } else if (inj_dif
&& (0 == errsts
)) {
3802 mk_sense_buffer(devip
, ABORTED_COMMAND
, 0x10, 1);
3803 errsts
= illegal_condition_result
;
3804 } else if (inj_dix
&& (0 == errsts
)) {
3805 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, 0x10, 1);
3806 errsts
= illegal_condition_result
;
3812 if ((*cmd
== WRITE_SAME_16
&& scsi_debug_lbpws
== 0) ||
3813 (*cmd
== WRITE_SAME
&& scsi_debug_lbpws10
== 0)) {
3814 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
3815 INVALID_FIELD_IN_CDB
, 0);
3816 errsts
= check_condition_result
;
3822 errsts
= check_readiness(SCpnt
, 0, devip
);
3825 get_data_transfer_info(cmd
, &lba
, &num
, &ei_lba
);
3826 errsts
= resp_write_same(SCpnt
, lba
, num
, devip
, ei_lba
, unmap
);
3829 errsts
= check_readiness(SCpnt
, 0, devip
);
3833 if (scsi_debug_unmap_max_desc
== 0 || scsi_debug_lbpu
== 0) {
3834 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
3835 INVALID_COMMAND_OPCODE
, 0);
3836 errsts
= check_condition_result
;
3838 errsts
= resp_unmap(SCpnt
, devip
);
3842 errsts
= resp_mode_sense(SCpnt
, target
, devip
);
3845 errsts
= resp_mode_select(SCpnt
, 1, devip
);
3847 case MODE_SELECT_10
:
3848 errsts
= resp_mode_select(SCpnt
, 0, devip
);
3851 errsts
= resp_log_sense(SCpnt
, devip
);
3853 case SYNCHRONIZE_CACHE
:
3855 errsts
= check_readiness(SCpnt
, 0, devip
);
3858 errsts
= check_readiness(SCpnt
, 1, devip
);
3860 case XDWRITEREAD_10
:
3861 if (!scsi_bidi_cmnd(SCpnt
)) {
3862 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
3863 INVALID_FIELD_IN_CDB
, 0);
3864 errsts
= check_condition_result
;
3868 errsts
= check_readiness(SCpnt
, 0, devip
);
3871 if (scsi_debug_fake_rw
)
3873 get_data_transfer_info(cmd
, &lba
, &num
, &ei_lba
);
3874 errsts
= resp_read(SCpnt
, lba
, num
, devip
, ei_lba
);
3877 errsts
= resp_write(SCpnt
, lba
, num
, devip
, ei_lba
);
3880 errsts
= resp_xdwriteread(SCpnt
, lba
, num
, devip
);
3882 case VARIABLE_LENGTH_CMD
:
3883 if (scsi_debug_dif
== SD_DIF_TYPE2_PROTECTION
) {
3885 if ((cmd
[10] & 0xe0) == 0)
3887 "Unprotected RD/WR to DIF device\n");
3889 if (cmd
[9] == READ_32
) {
3890 BUG_ON(SCpnt
->cmd_len
< 32);
3894 if (cmd
[9] == WRITE_32
) {
3895 BUG_ON(SCpnt
->cmd_len
< 32);
3900 mk_sense_buffer(devip
, ILLEGAL_REQUEST
,
3901 INVALID_FIELD_IN_CDB
, 0);
3902 errsts
= check_condition_result
;
3906 if (SCSI_DEBUG_OPT_NOISE
& scsi_debug_opts
)
3907 printk(KERN_INFO
"scsi_debug: Opcode: 0x%x not "
3908 "supported\n", *cmd
);
3909 errsts
= check_readiness(SCpnt
, 1, devip
);
3911 break; /* Unit attention takes precedence */
3912 mk_sense_buffer(devip
, ILLEGAL_REQUEST
, INVALID_OPCODE
, 0);
3913 errsts
= check_condition_result
;
3916 return schedule_resp(SCpnt
, devip
, done
, errsts
,
3917 (delay_override
? 0 : scsi_debug_delay
));
3920 static DEF_SCSI_QCMD(scsi_debug_queuecommand
)
3922 static struct scsi_host_template sdebug_driver_template
= {
3923 .proc_info
= scsi_debug_proc_info
,
3924 .proc_name
= sdebug_proc_name
,
3925 .name
= "SCSI DEBUG",
3926 .info
= scsi_debug_info
,
3927 .slave_alloc
= scsi_debug_slave_alloc
,
3928 .slave_configure
= scsi_debug_slave_configure
,
3929 .slave_destroy
= scsi_debug_slave_destroy
,
3930 .ioctl
= scsi_debug_ioctl
,
3931 .queuecommand
= scsi_debug_queuecommand
,
3932 .eh_abort_handler
= scsi_debug_abort
,
3933 .eh_bus_reset_handler
= scsi_debug_bus_reset
,
3934 .eh_device_reset_handler
= scsi_debug_device_reset
,
3935 .eh_host_reset_handler
= scsi_debug_host_reset
,
3936 .bios_param
= scsi_debug_biosparam
,
3937 .can_queue
= SCSI_DEBUG_CANQUEUE
,
3939 .sg_tablesize
= 256,
3941 .max_sectors
= 0xffff,
3942 .use_clustering
= DISABLE_CLUSTERING
,
3943 .module
= THIS_MODULE
,
3946 static int sdebug_driver_probe(struct device
* dev
)
3949 struct sdebug_host_info
*sdbg_host
;
3950 struct Scsi_Host
*hpnt
;
3953 sdbg_host
= to_sdebug_host(dev
);
3955 sdebug_driver_template
.can_queue
= scsi_debug_max_queue
;
3956 hpnt
= scsi_host_alloc(&sdebug_driver_template
, sizeof(sdbg_host
));
3958 printk(KERN_ERR
"%s: scsi_register failed\n", __func__
);
3963 sdbg_host
->shost
= hpnt
;
3964 *((struct sdebug_host_info
**)hpnt
->hostdata
) = sdbg_host
;
3965 if ((hpnt
->this_id
>= 0) && (scsi_debug_num_tgts
> hpnt
->this_id
))
3966 hpnt
->max_id
= scsi_debug_num_tgts
+ 1;
3968 hpnt
->max_id
= scsi_debug_num_tgts
;
3969 hpnt
->max_lun
= SAM2_WLUN_REPORT_LUNS
; /* = scsi_debug_max_luns; */
3973 switch (scsi_debug_dif
) {
3975 case SD_DIF_TYPE1_PROTECTION
:
3976 host_prot
= SHOST_DIF_TYPE1_PROTECTION
;
3978 host_prot
|= SHOST_DIX_TYPE1_PROTECTION
;
3981 case SD_DIF_TYPE2_PROTECTION
:
3982 host_prot
= SHOST_DIF_TYPE2_PROTECTION
;
3984 host_prot
|= SHOST_DIX_TYPE2_PROTECTION
;
3987 case SD_DIF_TYPE3_PROTECTION
:
3988 host_prot
= SHOST_DIF_TYPE3_PROTECTION
;
3990 host_prot
|= SHOST_DIX_TYPE3_PROTECTION
;
3995 host_prot
|= SHOST_DIX_TYPE0_PROTECTION
;
3999 scsi_host_set_prot(hpnt
, host_prot
);
4001 printk(KERN_INFO
"scsi_debug: host protection%s%s%s%s%s%s%s\n",
4002 (host_prot
& SHOST_DIF_TYPE1_PROTECTION
) ? " DIF1" : "",
4003 (host_prot
& SHOST_DIF_TYPE2_PROTECTION
) ? " DIF2" : "",
4004 (host_prot
& SHOST_DIF_TYPE3_PROTECTION
) ? " DIF3" : "",
4005 (host_prot
& SHOST_DIX_TYPE0_PROTECTION
) ? " DIX0" : "",
4006 (host_prot
& SHOST_DIX_TYPE1_PROTECTION
) ? " DIX1" : "",
4007 (host_prot
& SHOST_DIX_TYPE2_PROTECTION
) ? " DIX2" : "",
4008 (host_prot
& SHOST_DIX_TYPE3_PROTECTION
) ? " DIX3" : "");
4010 if (scsi_debug_guard
== 1)
4011 scsi_host_set_guard(hpnt
, SHOST_DIX_GUARD_IP
);
4013 scsi_host_set_guard(hpnt
, SHOST_DIX_GUARD_CRC
);
4015 error
= scsi_add_host(hpnt
, &sdbg_host
->dev
);
4017 printk(KERN_ERR
"%s: scsi_add_host failed\n", __func__
);
4019 scsi_host_put(hpnt
);
4021 scsi_scan_host(hpnt
);
4027 static int sdebug_driver_remove(struct device
* dev
)
4029 struct sdebug_host_info
*sdbg_host
;
4030 struct sdebug_dev_info
*sdbg_devinfo
, *tmp
;
4032 sdbg_host
= to_sdebug_host(dev
);
4035 printk(KERN_ERR
"%s: Unable to locate host info\n",
4040 scsi_remove_host(sdbg_host
->shost
);
4042 list_for_each_entry_safe(sdbg_devinfo
, tmp
, &sdbg_host
->dev_info_list
,
4044 list_del(&sdbg_devinfo
->dev_list
);
4045 kfree(sdbg_devinfo
);
4048 scsi_host_put(sdbg_host
->shost
);
4052 static int pseudo_lld_bus_match(struct device
*dev
,
4053 struct device_driver
*dev_driver
)
4058 static struct bus_type pseudo_lld_bus
= {
4060 .match
= pseudo_lld_bus_match
,
4061 .probe
= sdebug_driver_probe
,
4062 .remove
= sdebug_driver_remove
,