]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - drivers/scsi/scsi_debug.c
projects / mirror_ubuntu-jammy-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] scsi_debug: fix resp_xdwriteread() return value when running out of memory
[mirror_ubuntu-jammy-kernel.git] / drivers / scsi / scsi_debug.c
CommitLineData
1da177e4 1/*
1da177e4
LT		 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 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 *
9 * This version is more generic, simulating a variable number of disk
23183910
DG		 10 * (or disk like devices) sharing a common amount of RAM. To be more
11 * realistic, the simulated devices have the transport attributes of
12 * SAS disks.
1da177e4
LT		 13 *
14 *
78d4e5a0 15 * For documentation see http://sg.danny.cz/sg/sdebug26.html
1da177e4
LT		 16 *
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]
26 */
27
1da177e4
LT		 28#include <linux/module.h>
29
30#include <linux/kernel.h>
1da177e4
LT		 31#include <linux/errno.h>
32#include <linux/timer.h>
5a0e3ad6 33#include <linux/slab.h>
1da177e4
LT		 34#include <linux/types.h>
35#include <linux/string.h>
36#include <linux/genhd.h>
37#include <linux/fs.h>
38#include <linux/init.h>
39#include <linux/proc_fs.h>
1da177e4
LT		 40#include <linux/vmalloc.h>
41#include <linux/moduleparam.h>
852e034d 42#include <linux/scatterlist.h>
1da177e4 43#include <linux/blkdev.h>
c6a44287
MP		 44#include <linux/crc-t10dif.h>
45
46#include <net/checksum.h>
9ff26eef 47
44d92694
MP		 48#include <asm/unaligned.h>
49
9ff26eef
FT		 50#include <scsi/scsi.h>
51#include <scsi/scsi_cmnd.h>
52#include <scsi/scsi_device.h>
1da177e4
LT		 53#include <scsi/scsi_host.h>
54#include <scsi/scsicam.h>
a34c4e98 55#include <scsi/scsi_eh.h>
395cef03 56#include <scsi/scsi_dbg.h>
1da177e4 57
c6a44287 58#include "sd.h"
1da177e4 59#include "scsi_logging.h"
1da177e4 60
78d4e5a0
DG		 61#define SCSI_DEBUG_VERSION "1.82"
62static const char * scsi_debug_version_date = "20100324";
1da177e4 63
6f3cbf55 64/* Additional Sense Code (ASC) */
c65b1445
DG		 65#define NO_ADDITIONAL_SENSE 0x0
66#define LOGICAL_UNIT_NOT_READY 0x4
c5af0db9 67#define LOGICAL_UNIT_COMMUNICATION_FAILURE 0x8
1da177e4 68#define UNRECOVERED_READ_ERR 0x11
c65b1445 69#define PARAMETER_LIST_LENGTH_ERR 0x1a
1da177e4
LT		 70#define INVALID_OPCODE 0x20
71#define ADDR_OUT_OF_RANGE 0x21
395cef03 72#define INVALID_COMMAND_OPCODE 0x20
1da177e4 73#define INVALID_FIELD_IN_CDB 0x24
c65b1445 74#define INVALID_FIELD_IN_PARAM_LIST 0x26
1da177e4
LT		 75#define POWERON_RESET 0x29
76#define SAVING_PARAMS_UNSUP 0x39
6f3cbf55 77#define TRANSPORT_PROBLEM 0x4b
c65b1445
DG		 78#define THRESHOLD_EXCEEDED 0x5d
79#define LOW_POWER_COND_ON 0x5e
1da177e4 80
6f3cbf55
DG		 81/* Additional Sense Code Qualifier (ASCQ) */
82#define ACK_NAK_TO 0x3
83
1da177e4
LT		 84#define SDEBUG_TAGGED_QUEUING 0 /* 0 | MSG_SIMPLE_TAG | MSG_ORDERED_TAG */
85
86/* Default values for driver parameters */
87#define DEF_NUM_HOST 1
88#define DEF_NUM_TGTS 1
89#define DEF_MAX_LUNS 1
90/* With these defaults, this driver will make 1 host with 1 target
91 * (id 0) containing 1 logical unit (lun 0). That is 1 device.
92 */
5b94e232 93#define DEF_ATO 1
1da177e4
LT		 94#define DEF_DELAY 1
95#define DEF_DEV_SIZE_MB 8
5b94e232
MP		 96#define DEF_DIF 0
97#define DEF_DIX 0
1da177e4 98#define DEF_D_SENSE 0
5b94e232 99#define DEF_EVERY_NTH 0
23183910 100#define DEF_FAKE_RW 0
c6a44287 101#define DEF_GUARD 0
5b94e232
MP		 102#define DEF_LBPU 0
103#define DEF_LBPWS 0
104#define DEF_LBPWS10 0
be1dd78d 105#define DEF_LBPRZ 1
ea61fca5 106#define DEF_LOWEST_ALIGNED 0
5b94e232
MP		 107#define DEF_NO_LUN_0 0
108#define DEF_NUM_PARTS 0
109#define DEF_OPTS 0
e308b3d1 110#define DEF_OPT_BLKS 64
5b94e232
MP		 111#define DEF_PHYSBLK_EXP 0
112#define DEF_PTYPE 0
d986788b 113#define DEF_REMOVABLE false
5b94e232
MP		 114#define DEF_SCSI_LEVEL 5 /* INQUIRY, byte2 [5->SPC-3] */
115#define DEF_SECTOR_SIZE 512
116#define DEF_UNMAP_ALIGNMENT 0
117#define DEF_UNMAP_GRANULARITY 1
6014759c
MP		 118#define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF
119#define DEF_UNMAP_MAX_DESC 256
5b94e232
MP		 120#define DEF_VIRTUAL_GB 0
121#define DEF_VPD_USE_HOSTNO 1
122#define DEF_WRITESAME_LENGTH 0xFFFF
1da177e4
LT		 123
124/* bit mask values for scsi_debug_opts */
125#define SCSI_DEBUG_OPT_NOISE 1
126#define SCSI_DEBUG_OPT_MEDIUM_ERR 2
127#define SCSI_DEBUG_OPT_TIMEOUT 4
128#define SCSI_DEBUG_OPT_RECOVERED_ERR 8
6f3cbf55 129#define SCSI_DEBUG_OPT_TRANSPORT_ERR 16
c6a44287
MP		 130#define SCSI_DEBUG_OPT_DIF_ERR 32
131#define SCSI_DEBUG_OPT_DIX_ERR 64
18a4d0a2 132#define SCSI_DEBUG_OPT_MAC_TIMEOUT 128
1da177e4
LT		 133/* When "every_nth" > 0 then modulo "every_nth" commands:
134 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
135 * - a RECOVERED_ERROR is simulated on successful read and write
136 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
6f3cbf55
DG		 137 * - a TRANSPORT_ERROR is simulated on successful read and write
138 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
1da177e4
LT		 139 *
140 * When "every_nth" < 0 then after "- every_nth" commands:
141 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
142 * - a RECOVERED_ERROR is simulated on successful read and write
143 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
6f3cbf55
DG		 144 * - a TRANSPORT_ERROR is simulated on successful read and write
145 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
1da177e4
LT		 146 * This will continue until some other action occurs (e.g. the user
147 * writing a new value (other than -1 or 1) to every_nth via sysfs).
148 */
149
150/* when 1==SCSI_DEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
151 * sector on read commands: */
152#define OPT_MEDIUM_ERR_ADDR 0x1234 /* that's sector 4660 in decimal */
32f7ef73 153#define OPT_MEDIUM_ERR_NUM 10 /* number of consecutive medium errs */
1da177e4
LT		 154
155/* If REPORT LUNS has luns >= 256 it can choose "flat space" (value 1)
156 * or "peripheral device" addressing (value 0) */
157#define SAM2_LUN_ADDRESS_METHOD 0
c65b1445 158#define SAM2_WLUN_REPORT_LUNS 0xc101
1da177e4 159
78d4e5a0
DG		 160/* Can queue up to this number of commands. Typically commands that
161 * that have a non-zero delay are queued. */
162#define SCSI_DEBUG_CANQUEUE 255
163
1da177e4 164static int scsi_debug_add_host = DEF_NUM_HOST;
5b94e232 165static int scsi_debug_ato = DEF_ATO;
1da177e4
LT		 166static int scsi_debug_delay = DEF_DELAY;
167static int scsi_debug_dev_size_mb = DEF_DEV_SIZE_MB;
5b94e232
MP		 168static int scsi_debug_dif = DEF_DIF;
169static int scsi_debug_dix = DEF_DIX;
170static int scsi_debug_dsense = DEF_D_SENSE;
1da177e4 171static int scsi_debug_every_nth = DEF_EVERY_NTH;
5b94e232 172static int scsi_debug_fake_rw = DEF_FAKE_RW;
68aee7ba 173static unsigned int scsi_debug_guard = DEF_GUARD;
5b94e232 174static int scsi_debug_lowest_aligned = DEF_LOWEST_ALIGNED;
1da177e4 175static int scsi_debug_max_luns = DEF_MAX_LUNS;
78d4e5a0 176static int scsi_debug_max_queue = SCSI_DEBUG_CANQUEUE;
5b94e232 177static int scsi_debug_no_lun_0 = DEF_NO_LUN_0;
78d4e5a0 178static int scsi_debug_no_uld = 0;
5b94e232 179static int scsi_debug_num_parts = DEF_NUM_PARTS;
1da177e4 180static int scsi_debug_num_tgts = DEF_NUM_TGTS; /* targets per host */
5b94e232 181static int scsi_debug_opt_blks = DEF_OPT_BLKS;
1da177e4 182static int scsi_debug_opts = DEF_OPTS;
5b94e232 183static int scsi_debug_physblk_exp = DEF_PHYSBLK_EXP;
1da177e4 184static int scsi_debug_ptype = DEF_PTYPE; /* SCSI peripheral type (0==disk) */
5b94e232
MP		 185static int scsi_debug_scsi_level = DEF_SCSI_LEVEL;
186static int scsi_debug_sector_size = DEF_SECTOR_SIZE;
c65b1445 187static int scsi_debug_virtual_gb = DEF_VIRTUAL_GB;
23183910 188static int scsi_debug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
5b94e232
MP		 189static unsigned int scsi_debug_lbpu = DEF_LBPU;
190static unsigned int scsi_debug_lbpws = DEF_LBPWS;
191static unsigned int scsi_debug_lbpws10 = DEF_LBPWS10;
be1dd78d 192static unsigned int scsi_debug_lbprz = DEF_LBPRZ;
6014759c 193static unsigned int scsi_debug_unmap_alignment = DEF_UNMAP_ALIGNMENT;
5b94e232
MP		 194static unsigned int scsi_debug_unmap_granularity = DEF_UNMAP_GRANULARITY;
195static unsigned int scsi_debug_unmap_max_blocks = DEF_UNMAP_MAX_BLOCKS;
196static unsigned int scsi_debug_unmap_max_desc = DEF_UNMAP_MAX_DESC;
197static unsigned int scsi_debug_write_same_length = DEF_WRITESAME_LENGTH;
d986788b 198static bool scsi_debug_removable = DEF_REMOVABLE;
1da177e4
LT		 199
200static int scsi_debug_cmnd_count = 0;
201
202#define DEV_READONLY(TGT) (0)
1da177e4 203
c65b1445 204static unsigned int sdebug_store_sectors;
1da177e4
LT		 205static sector_t sdebug_capacity; /* in sectors */
206
207/* old BIOS stuff, kernel may get rid of them but some mode sense pages
208 may still need them */
209static int sdebug_heads; /* heads per disk */
210static int sdebug_cylinders_per; /* cylinders per surface */
211static int sdebug_sectors_per; /* sectors per cylinder */
212
1da177e4
LT		 213#define SDEBUG_MAX_PARTS 4
214
215#define SDEBUG_SENSE_LEN 32
216
395cef03 217#define SCSI_DEBUG_MAX_CMD_LEN 32
9e603ca0 218
5b94e232
MP		 219static unsigned int scsi_debug_lbp(void)
220{
221 return scsi_debug_lbpu | scsi_debug_lbpws | scsi_debug_lbpws10;
222}
223
1da177e4
LT		 224struct sdebug_dev_info {
225 struct list_head dev_list;
226 unsigned char sense_buff[SDEBUG_SENSE_LEN]; /* weak nexus */
227 unsigned int channel;
228 unsigned int target;
229 unsigned int lun;
230 struct sdebug_host_info *sdbg_host;
c65b1445 231 unsigned int wlun;
1da177e4 232 char reset;
c65b1445 233 char stopped;
1da177e4
LT		 234 char used;
235};
236
237struct sdebug_host_info {
238 struct list_head host_list;
239 struct Scsi_Host *shost;
240 struct device dev;
241 struct list_head dev_info_list;
242};
243
244#define to_sdebug_host(d) \
245 container_of(d, struct sdebug_host_info, dev)
246
247static LIST_HEAD(sdebug_host_list);
248static DEFINE_SPINLOCK(sdebug_host_list_lock);
249
250typedef void (* done_funct_t) (struct scsi_cmnd *);
251
252struct sdebug_queued_cmd {
253 int in_use;
254 struct timer_list cmnd_timer;
255 done_funct_t done_funct;
256 struct scsi_cmnd * a_cmnd;
257 int scsi_result;
258};
259static struct sdebug_queued_cmd queued_arr[SCSI_DEBUG_CANQUEUE];
260
1da177e4 261static unsigned char * fake_storep; /* ramdisk storage */
e18d8bea 262static struct sd_dif_tuple *dif_storep; /* protection info */
44d92694 263static void *map_storep; /* provisioning map */
1da177e4 264
44d92694 265static unsigned long map_size;
1da177e4
LT		 266static int num_aborts = 0;
267static int num_dev_resets = 0;
268static int num_bus_resets = 0;
269static int num_host_resets = 0;
c6a44287
MP		 270static int dix_writes;
271static int dix_reads;
272static int dif_errors;
1da177e4
LT		 273
274static DEFINE_SPINLOCK(queued_arr_lock);
275static DEFINE_RWLOCK(atomic_rw);
276
277static char sdebug_proc_name[] = "scsi_debug";
278
1da177e4
LT		 279static struct bus_type pseudo_lld_bus;
280
281static struct device_driver sdebug_driverfs_driver = {
282 .name = sdebug_proc_name,
283 .bus = &pseudo_lld_bus,
1da177e4
LT		 284};
285
286static const int check_condition_result =
287 (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
288
c6a44287
MP		 289static const int illegal_condition_result =
290 (DRIVER_SENSE << 24) | (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION;
291
c65b1445
DG		 292static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
293 0, 0, 0x2, 0x4b};
294static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
295 0, 0, 0x0, 0x0};
296
14faa944
AM		 297static void *fake_store(unsigned long long lba)
298{
299 lba = do_div(lba, sdebug_store_sectors);
300
301 return fake_storep + lba * scsi_debug_sector_size;
302}
303
304static struct sd_dif_tuple *dif_store(sector_t sector)
305{
306 sector = do_div(sector, sdebug_store_sectors);
307
308 return dif_storep + sector;
309}
310
1da177e4
LT		 311static int sdebug_add_adapter(void);
312static void sdebug_remove_adapter(void);
1da177e4 313
8dea0d02
FT		 314static void sdebug_max_tgts_luns(void)
315{
316 struct sdebug_host_info *sdbg_host;
317 struct Scsi_Host *hpnt;
318
319 spin_lock(&sdebug_host_list_lock);
320 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
321 hpnt = sdbg_host->shost;
322 if ((hpnt->this_id >= 0) &&
323 (scsi_debug_num_tgts > hpnt->this_id))
324 hpnt->max_id = scsi_debug_num_tgts + 1;
325 else
326 hpnt->max_id = scsi_debug_num_tgts;
327 /* scsi_debug_max_luns; */
328 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS;
329 }
330 spin_unlock(&sdebug_host_list_lock);
331}
332
333static void mk_sense_buffer(struct sdebug_dev_info *devip, int key,
334 int asc, int asq)
335{
336 unsigned char *sbuff;
337
338 sbuff = devip->sense_buff;
339 memset(sbuff, 0, SDEBUG_SENSE_LEN);
340
341 scsi_build_sense_buffer(scsi_debug_dsense, sbuff, key, asc, asq);
342
343 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
344 printk(KERN_INFO "scsi_debug: [sense_key,asc,ascq]: "
345 "[0x%x,0x%x,0x%x]\n", key, asc, asq);
346}
1da177e4 347
3de9f944 348static void get_data_transfer_info(unsigned char *cmd,
395cef03
MP		 349 unsigned long long *lba, unsigned int *num,
350 u32 *ei_lba)
3de9f944 351{
395cef03
MP		 352 *ei_lba = 0;
353
3de9f944 354 switch (*cmd) {
395cef03
MP		 355 case VARIABLE_LENGTH_CMD:
356 *lba = (u64)cmd[19] | (u64)cmd[18] << 8 |
357 (u64)cmd[17] << 16 | (u64)cmd[16] << 24 |
358 (u64)cmd[15] << 32 | (u64)cmd[14] << 40 |
359 (u64)cmd[13] << 48 | (u64)cmd[12] << 56;
360
361 *ei_lba = (u32)cmd[23] | (u32)cmd[22] << 8 |
362 (u32)cmd[21] << 16 | (u32)cmd[20] << 24;
363
364 *num = (u32)cmd[31] | (u32)cmd[30] << 8 | (u32)cmd[29] << 16 |
365 (u32)cmd[28] << 24;
366 break;
367
44d92694 368 case WRITE_SAME_16:
3de9f944
FT		 369 case WRITE_16:
370 case READ_16:
d5cdc989
FT		 371 *lba = (u64)cmd[9] | (u64)cmd[8] << 8 |
372 (u64)cmd[7] << 16 | (u64)cmd[6] << 24 |
373 (u64)cmd[5] << 32 | (u64)cmd[4] << 40 |
374 (u64)cmd[3] << 48 | (u64)cmd[2] << 56;
375
376 *num = (u32)cmd[13] | (u32)cmd[12] << 8 | (u32)cmd[11] << 16 |
377 (u32)cmd[10] << 24;
3de9f944
FT		 378 break;
379 case WRITE_12:
380 case READ_12:
d5cdc989
FT		 381 *lba = (u32)cmd[5] | (u32)cmd[4] << 8 | (u32)cmd[3] << 16 |
382 (u32)cmd[2] << 24;
383
384 *num = (u32)cmd[9] | (u32)cmd[8] << 8 | (u32)cmd[7] << 16 |
385 (u32)cmd[6] << 24;
3de9f944 386 break;
44d92694 387 case WRITE_SAME:
3de9f944
FT		 388 case WRITE_10:
389 case READ_10:
c639d14e 390 case XDWRITEREAD_10:
d5cdc989
FT		 391 *lba = (u32)cmd[5] | (u32)cmd[4] << 8 | (u32)cmd[3] << 16 |
392 (u32)cmd[2] << 24;
393
394 *num = (u32)cmd[8] | (u32)cmd[7] << 8;
3de9f944
FT		 395 break;
396 case WRITE_6:
397 case READ_6:
d5cdc989
FT		 398 *lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
399 (u32)(cmd[1] & 0x1f) << 16;
3de9f944
FT		 400 *num = (0 == cmd[4]) ? 256 : cmd[4];
401 break;
402 default:
403 break;
404 }
405}
1da177e4 406
1da177e4
LT		 407static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
408{
409 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
410 printk(KERN_INFO "scsi_debug: ioctl: cmd=0x%x\n", cmd);
411 }
412 return -EINVAL;
413 /* return -ENOTTY; // correct return but upsets fdisk */
414}
415
c65b1445
DG		 416static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
417 struct sdebug_dev_info * devip)
1da177e4
LT		 418{
419 if (devip->reset) {
420 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
421 printk(KERN_INFO "scsi_debug: Reporting Unit "
422 "attention: power on reset\n");
423 devip->reset = 0;
424 mk_sense_buffer(devip, UNIT_ATTENTION, POWERON_RESET, 0);
425 return check_condition_result;
426 }
c65b1445
DG		 427 if ((0 == reset_only) && devip->stopped) {
428 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
429 printk(KERN_INFO "scsi_debug: Reporting Not "
430 "ready: initializing command required\n");
431 mk_sense_buffer(devip, NOT_READY, LOGICAL_UNIT_NOT_READY,
432 0x2);
433 return check_condition_result;
434 }
1da177e4
LT		 435 return 0;
436}
437
438/* Returns 0 if ok else (DID_ERROR << 16). Sets scp->resid . */
21a61829 439static int fill_from_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
1da177e4
LT		 440 int arr_len)
441{
21a61829 442 int act_len;
072d0bb3 443 struct scsi_data_buffer *sdb = scsi_in(scp);
1da177e4 444
072d0bb3 445 if (!sdb->length)
1da177e4 446 return 0;
072d0bb3 447 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE))
1da177e4 448 return (DID_ERROR << 16);
21a61829
FT		 449
450 act_len = sg_copy_from_buffer(sdb->table.sgl, sdb->table.nents,
451 arr, arr_len);
a4517511 452 sdb->resid = scsi_bufflen(scp) - act_len;
21a61829 453
1da177e4
LT		 454 return 0;
455}
456
457/* Returns number of bytes fetched into 'arr' or -1 if error. */
21a61829
FT		 458static int fetch_to_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
459 int arr_len)
1da177e4 460{
21a61829 461 if (!scsi_bufflen(scp))
1da177e4 462 return 0;
072d0bb3 463 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_TO_DEVICE))
1da177e4 464 return -1;
21a61829
FT		 465
466 return scsi_sg_copy_to_buffer(scp, arr, arr_len);
1da177e4
LT		 467}
468
469
470static const char * inq_vendor_id = "Linux ";
471static const char * inq_product_id = "scsi_debug ";
472static const char * inq_product_rev = "0004";
473
5a09e398
HR		 474static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
475 int target_dev_id, int dev_id_num,
476 const char * dev_id_str,
c65b1445 477 int dev_id_str_len)
1da177e4 478{
c65b1445
DG		 479 int num, port_a;
480 char b[32];
1da177e4 481
c65b1445 482 port_a = target_dev_id + 1;
1da177e4
LT		 483 /* T10 vendor identifier field format (faked) */
484 arr[0] = 0x2; /* ASCII */
485 arr[1] = 0x1;
486 arr[2] = 0x0;
487 memcpy(&arr[4], inq_vendor_id, 8);
488 memcpy(&arr[12], inq_product_id, 16);
489 memcpy(&arr[28], dev_id_str, dev_id_str_len);
490 num = 8 + 16 + dev_id_str_len;
491 arr[3] = num;
492 num += 4;
c65b1445
DG		 493 if (dev_id_num >= 0) {
494 /* NAA-5, Logical unit identifier (binary) */
495 arr[num++] = 0x1; /* binary (not necessarily sas) */
496 arr[num++] = 0x3; /* PIV=0, lu, naa */
497 arr[num++] = 0x0;
498 arr[num++] = 0x8;
499 arr[num++] = 0x53; /* naa-5 ieee company id=0x333333 (fake) */
500 arr[num++] = 0x33;
501 arr[num++] = 0x33;
502 arr[num++] = 0x30;
503 arr[num++] = (dev_id_num >> 24);
504 arr[num++] = (dev_id_num >> 16) & 0xff;
505 arr[num++] = (dev_id_num >> 8) & 0xff;
506 arr[num++] = dev_id_num & 0xff;
507 /* Target relative port number */
508 arr[num++] = 0x61; /* proto=sas, binary */
509 arr[num++] = 0x94; /* PIV=1, target port, rel port */
510 arr[num++] = 0x0; /* reserved */
511 arr[num++] = 0x4; /* length */
512 arr[num++] = 0x0; /* reserved */
513 arr[num++] = 0x0; /* reserved */
514 arr[num++] = 0x0;
515 arr[num++] = 0x1; /* relative port A */
516 }
517 /* NAA-5, Target port identifier */
518 arr[num++] = 0x61; /* proto=sas, binary */
519 arr[num++] = 0x93; /* piv=1, target port, naa */
520 arr[num++] = 0x0;
521 arr[num++] = 0x8;
522 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
523 arr[num++] = 0x22;
524 arr[num++] = 0x22;
525 arr[num++] = 0x20;
526 arr[num++] = (port_a >> 24);
527 arr[num++] = (port_a >> 16) & 0xff;
528 arr[num++] = (port_a >> 8) & 0xff;
529 arr[num++] = port_a & 0xff;
5a09e398
HR		 530 /* NAA-5, Target port group identifier */
531 arr[num++] = 0x61; /* proto=sas, binary */
532 arr[num++] = 0x95; /* piv=1, target port group id */
533 arr[num++] = 0x0;
534 arr[num++] = 0x4;
535 arr[num++] = 0;
536 arr[num++] = 0;
537 arr[num++] = (port_group_id >> 8) & 0xff;
538 arr[num++] = port_group_id & 0xff;
c65b1445
DG		 539 /* NAA-5, Target device identifier */
540 arr[num++] = 0x61; /* proto=sas, binary */
541 arr[num++] = 0xa3; /* piv=1, target device, naa */
542 arr[num++] = 0x0;
543 arr[num++] = 0x8;
544 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
545 arr[num++] = 0x22;
546 arr[num++] = 0x22;
547 arr[num++] = 0x20;
548 arr[num++] = (target_dev_id >> 24);
549 arr[num++] = (target_dev_id >> 16) & 0xff;
550 arr[num++] = (target_dev_id >> 8) & 0xff;
551 arr[num++] = target_dev_id & 0xff;
552 /* SCSI name string: Target device identifier */
553 arr[num++] = 0x63; /* proto=sas, UTF-8 */
554 arr[num++] = 0xa8; /* piv=1, target device, SCSI name string */
555 arr[num++] = 0x0;
556 arr[num++] = 24;
557 memcpy(arr + num, "naa.52222220", 12);
558 num += 12;
559 snprintf(b, sizeof(b), "%08X", target_dev_id);
560 memcpy(arr + num, b, 8);
561 num += 8;
562 memset(arr + num, 0, 4);
563 num += 4;
564 return num;
565}
566
567
568static unsigned char vpd84_data[] = {
569/* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
570 0x22,0x22,0x22,0x0,0xbb,0x1,
571 0x22,0x22,0x22,0x0,0xbb,0x2,
572};
573
574static int inquiry_evpd_84(unsigned char * arr)
575{
576 memcpy(arr, vpd84_data, sizeof(vpd84_data));
577 return sizeof(vpd84_data);
578}
579
580static int inquiry_evpd_85(unsigned char * arr)
581{
582 int num = 0;
583 const char * na1 = "https://www.kernel.org/config";
584 const char * na2 = "http://www.kernel.org/log";
585 int plen, olen;
586
587 arr[num++] = 0x1; /* lu, storage config */
588 arr[num++] = 0x0; /* reserved */
589 arr[num++] = 0x0;
590 olen = strlen(na1);
591 plen = olen + 1;
592 if (plen % 4)
593 plen = ((plen / 4) + 1) * 4;
594 arr[num++] = plen; /* length, null termianted, padded */
595 memcpy(arr + num, na1, olen);
596 memset(arr + num + olen, 0, plen - olen);
597 num += plen;
598
599 arr[num++] = 0x4; /* lu, logging */
600 arr[num++] = 0x0; /* reserved */
601 arr[num++] = 0x0;
602 olen = strlen(na2);
603 plen = olen + 1;
604 if (plen % 4)
605 plen = ((plen / 4) + 1) * 4;
606 arr[num++] = plen; /* length, null terminated, padded */
607 memcpy(arr + num, na2, olen);
608 memset(arr + num + olen, 0, plen - olen);
609 num += plen;
610
611 return num;
612}
613
614/* SCSI ports VPD page */
615static int inquiry_evpd_88(unsigned char * arr, int target_dev_id)
616{
617 int num = 0;
618 int port_a, port_b;
619
620 port_a = target_dev_id + 1;
621 port_b = port_a + 1;
622 arr[num++] = 0x0; /* reserved */
623 arr[num++] = 0x0; /* reserved */
624 arr[num++] = 0x0;
625 arr[num++] = 0x1; /* relative port 1 (primary) */
626 memset(arr + num, 0, 6);
627 num += 6;
628 arr[num++] = 0x0;
629 arr[num++] = 12; /* length tp descriptor */
630 /* naa-5 target port identifier (A) */
631 arr[num++] = 0x61; /* proto=sas, binary */
632 arr[num++] = 0x93; /* PIV=1, target port, NAA */
633 arr[num++] = 0x0; /* reserved */
634 arr[num++] = 0x8; /* length */
635 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
636 arr[num++] = 0x22;
637 arr[num++] = 0x22;
638 arr[num++] = 0x20;
639 arr[num++] = (port_a >> 24);
640 arr[num++] = (port_a >> 16) & 0xff;
641 arr[num++] = (port_a >> 8) & 0xff;
642 arr[num++] = port_a & 0xff;
643
644 arr[num++] = 0x0; /* reserved */
645 arr[num++] = 0x0; /* reserved */
646 arr[num++] = 0x0;
647 arr[num++] = 0x2; /* relative port 2 (secondary) */
648 memset(arr + num, 0, 6);
649 num += 6;
650 arr[num++] = 0x0;
651 arr[num++] = 12; /* length tp descriptor */
652 /* naa-5 target port identifier (B) */
653 arr[num++] = 0x61; /* proto=sas, binary */
654 arr[num++] = 0x93; /* PIV=1, target port, NAA */
655 arr[num++] = 0x0; /* reserved */
656 arr[num++] = 0x8; /* length */
657 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
658 arr[num++] = 0x22;
659 arr[num++] = 0x22;
660 arr[num++] = 0x20;
661 arr[num++] = (port_b >> 24);
662 arr[num++] = (port_b >> 16) & 0xff;
663 arr[num++] = (port_b >> 8) & 0xff;
664 arr[num++] = port_b & 0xff;
665
666 return num;
667}
668
669
670static unsigned char vpd89_data[] = {
671/* from 4th byte */ 0,0,0,0,
672'l','i','n','u','x',' ',' ',' ',
673'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
674'1','2','3','4',
6750x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
6760xec,0,0,0,
6770x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
6780,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
6790x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
6800x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
6810x53,0x41,
6820x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
6830x20,0x20,
6840x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
6850x10,0x80,
6860,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
6870x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
6880x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
6890,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
6900x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
6910x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
6920,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
6930,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6940,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6950,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
6960x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
6970,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
6980xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
6990,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
7000,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
7010,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
7020,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
7030,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
7040,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
7050,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
7060,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
7070,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
7080,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
7090,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
7100,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
7110,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
712};
713
714static int inquiry_evpd_89(unsigned char * arr)
715{
716 memcpy(arr, vpd89_data, sizeof(vpd89_data));
717 return sizeof(vpd89_data);
718}
719
720
1e49f785 721/* Block limits VPD page (SBC-3) */
c65b1445 722static unsigned char vpdb0_data[] = {
1e49f785
DG		 723 /* from 4th byte */ 0,0,0,4, 0,0,0x4,0, 0,0,0,64,
724 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
725 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
726 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
c65b1445
DG		 727};
728
729static int inquiry_evpd_b0(unsigned char * arr)
730{
ea61fca5
MP		 731 unsigned int gran;
732
c65b1445 733 memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
e308b3d1
MP		 734
735 /* Optimal transfer length granularity */
ea61fca5
MP		 736 gran = 1 << scsi_debug_physblk_exp;
737 arr[2] = (gran >> 8) & 0xff;
738 arr[3] = gran & 0xff;
e308b3d1
MP		 739
740 /* Maximum Transfer Length */
c65b1445
DG		 741 if (sdebug_store_sectors > 0x400) {
742 arr[4] = (sdebug_store_sectors >> 24) & 0xff;
743 arr[5] = (sdebug_store_sectors >> 16) & 0xff;
744 arr[6] = (sdebug_store_sectors >> 8) & 0xff;
745 arr[7] = sdebug_store_sectors & 0xff;
746 }
44d92694 747
e308b3d1
MP		 748 /* Optimal Transfer Length */
749 put_unaligned_be32(scsi_debug_opt_blks, &arr[8]);
750
5b94e232 751 if (scsi_debug_lbpu) {
e308b3d1 752 /* Maximum Unmap LBA Count */
6014759c 753 put_unaligned_be32(scsi_debug_unmap_max_blocks, &arr[16]);
e308b3d1
MP		 754
755 /* Maximum Unmap Block Descriptor Count */
44d92694
MP		 756 put_unaligned_be32(scsi_debug_unmap_max_desc, &arr[20]);
757 }
758
e308b3d1 759 /* Unmap Granularity Alignment */
44d92694
MP		 760 if (scsi_debug_unmap_alignment) {
761 put_unaligned_be32(scsi_debug_unmap_alignment, &arr[28]);
762 arr[28] |= 0x80; /* UGAVALID */
763 }
764
e308b3d1 765 /* Optimal Unmap Granularity */
6014759c
MP		 766 put_unaligned_be32(scsi_debug_unmap_granularity, &arr[24]);
767
5b94e232
MP		 768 /* Maximum WRITE SAME Length */
769 put_unaligned_be64(scsi_debug_write_same_length, &arr[32]);
770
771 return 0x3c; /* Mandatory page length for Logical Block Provisioning */
44d92694 772
c65b1445 773 return sizeof(vpdb0_data);
1da177e4
LT		 774}
775
1e49f785 776/* Block device characteristics VPD page (SBC-3) */
eac6e8e4
MW		 777static int inquiry_evpd_b1(unsigned char *arr)
778{
779 memset(arr, 0, 0x3c);
780 arr[0] = 0;
1e49f785
DG		 781 arr[1] = 1; /* non rotating medium (e.g. solid state) */
782 arr[2] = 0;
783 arr[3] = 5; /* less than 1.8" */
eac6e8e4
MW		 784
785 return 0x3c;
786}
1da177e4 787
be1dd78d 788/* Logical block provisioning VPD page (SBC-3) */
6014759c
MP		 789static int inquiry_evpd_b2(unsigned char *arr)
790{
3f0bc3b3 791 memset(arr, 0, 0x4);
6014759c
MP		 792 arr[0] = 0; /* threshold exponent */
793
5b94e232 794 if (scsi_debug_lbpu)
6014759c
MP		 795 arr[1] = 1 << 7;
796
5b94e232 797 if (scsi_debug_lbpws)
6014759c
MP		 798 arr[1] |= 1 << 6;
799
5b94e232
MP		 800 if (scsi_debug_lbpws10)
801 arr[1] |= 1 << 5;
802
be1dd78d
ES		 803 if (scsi_debug_lbprz)
804 arr[1] |= 1 << 2;
805
3f0bc3b3 806 return 0x4;
6014759c
MP		 807}
808
1da177e4 809#define SDEBUG_LONG_INQ_SZ 96
c65b1445 810#define SDEBUG_MAX_INQ_ARR_SZ 584
1da177e4
LT		 811
812static int resp_inquiry(struct scsi_cmnd * scp, int target,
813 struct sdebug_dev_info * devip)
814{
815 unsigned char pq_pdt;
5a09e398 816 unsigned char * arr;
1da177e4 817 unsigned char *cmd = (unsigned char *)scp->cmnd;
5a09e398 818 int alloc_len, n, ret;
1da177e4
LT		 819
820 alloc_len = (cmd[3] << 8) + cmd[4];
6f3cbf55
DG		 821 arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
822 if (! arr)
823 return DID_REQUEUE << 16;
c65b1445
DG		 824 if (devip->wlun)
825 pq_pdt = 0x1e; /* present, wlun */
826 else if (scsi_debug_no_lun_0 && (0 == devip->lun))
827 pq_pdt = 0x7f; /* not present, no device type */
828 else
829 pq_pdt = (scsi_debug_ptype & 0x1f);
1da177e4
LT		 830 arr[0] = pq_pdt;
831 if (0x2 & cmd[1]) { /* CMDDT bit set */
832 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
833 0);
5a09e398 834 kfree(arr);
1da177e4
LT		 835 return check_condition_result;
836 } else if (0x1 & cmd[1]) { /* EVPD bit set */
5a09e398 837 int lu_id_num, port_group_id, target_dev_id, len;
c65b1445
DG		 838 char lu_id_str[6];
839 int host_no = devip->sdbg_host->shost->host_no;
1da177e4 840
5a09e398
HR		 841 port_group_id = (((host_no + 1) & 0x7f) << 8) +
842 (devip->channel & 0x7f);
23183910
DG		 843 if (0 == scsi_debug_vpd_use_hostno)
844 host_no = 0;
c65b1445
DG		 845 lu_id_num = devip->wlun ? -1 : (((host_no + 1) * 2000) +
846 (devip->target * 1000) + devip->lun);
847 target_dev_id = ((host_no + 1) * 2000) +
848 (devip->target * 1000) - 3;
849 len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
1da177e4 850 if (0 == cmd[2]) { /* supported vital product data pages */
c65b1445
DG		 851 arr[1] = cmd[2]; /*sanity */
852 n = 4;
853 arr[n++] = 0x0; /* this page */
854 arr[n++] = 0x80; /* unit serial number */
855 arr[n++] = 0x83; /* device identification */
856 arr[n++] = 0x84; /* software interface ident. */
857 arr[n++] = 0x85; /* management network addresses */
858 arr[n++] = 0x86; /* extended inquiry */
859 arr[n++] = 0x87; /* mode page policy */
860 arr[n++] = 0x88; /* SCSI ports */
861 arr[n++] = 0x89; /* ATA information */
862 arr[n++] = 0xb0; /* Block limits (SBC) */
eac6e8e4 863 arr[n++] = 0xb1; /* Block characteristics (SBC) */
5b94e232
MP		 864 if (scsi_debug_lbp()) /* Logical Block Prov. (SBC) */
865 arr[n++] = 0xb2;
c65b1445 866 arr[3] = n - 4; /* number of supported VPD pages */
1da177e4 867 } else if (0x80 == cmd[2]) { /* unit serial number */
c65b1445 868 arr[1] = cmd[2]; /*sanity */
1da177e4 869 arr[3] = len;
c65b1445 870 memcpy(&arr[4], lu_id_str, len);
1da177e4 871 } else if (0x83 == cmd[2]) { /* device identification */
c65b1445 872 arr[1] = cmd[2]; /*sanity */
5a09e398
HR		 873 arr[3] = inquiry_evpd_83(&arr[4], port_group_id,
874 target_dev_id, lu_id_num,
875 lu_id_str, len);
c65b1445
DG		 876 } else if (0x84 == cmd[2]) { /* Software interface ident. */
877 arr[1] = cmd[2]; /*sanity */
878 arr[3] = inquiry_evpd_84(&arr[4]);
879 } else if (0x85 == cmd[2]) { /* Management network addresses */
880 arr[1] = cmd[2]; /*sanity */
881 arr[3] = inquiry_evpd_85(&arr[4]);
882 } else if (0x86 == cmd[2]) { /* extended inquiry */
883 arr[1] = cmd[2]; /*sanity */
884 arr[3] = 0x3c; /* number of following entries */
c6a44287
MP		 885 if (scsi_debug_dif == SD_DIF_TYPE3_PROTECTION)
886 arr[4] = 0x4; /* SPT: GRD_CHK:1 */
887 else if (scsi_debug_dif)
888 arr[4] = 0x5; /* SPT: GRD_CHK:1, REF_CHK:1 */
889 else
890 arr[4] = 0x0; /* no protection stuff */
c65b1445
DG		 891 arr[5] = 0x7; /* head of q, ordered + simple q's */
892 } else if (0x87 == cmd[2]) { /* mode page policy */
893 arr[1] = cmd[2]; /*sanity */
894 arr[3] = 0x8; /* number of following entries */
895 arr[4] = 0x2; /* disconnect-reconnect mp */
896 arr[6] = 0x80; /* mlus, shared */
897 arr[8] = 0x18; /* protocol specific lu */
898 arr[10] = 0x82; /* mlus, per initiator port */
899 } else if (0x88 == cmd[2]) { /* SCSI Ports */
900 arr[1] = cmd[2]; /*sanity */
901 arr[3] = inquiry_evpd_88(&arr[4], target_dev_id);
902 } else if (0x89 == cmd[2]) { /* ATA information */
903 arr[1] = cmd[2]; /*sanity */
904 n = inquiry_evpd_89(&arr[4]);
905 arr[2] = (n >> 8);
906 arr[3] = (n & 0xff);
907 } else if (0xb0 == cmd[2]) { /* Block limits (SBC) */
908 arr[1] = cmd[2]; /*sanity */
909 arr[3] = inquiry_evpd_b0(&arr[4]);
eac6e8e4
MW		 910 } else if (0xb1 == cmd[2]) { /* Block characteristics (SBC) */
911 arr[1] = cmd[2]; /*sanity */
912 arr[3] = inquiry_evpd_b1(&arr[4]);
5b94e232 913 } else if (0xb2 == cmd[2]) { /* Logical Block Prov. (SBC) */
6014759c
MP		 914 arr[1] = cmd[2]; /*sanity */
915 arr[3] = inquiry_evpd_b2(&arr[4]);
1da177e4
LT		 916 } else {
917 /* Illegal request, invalid field in cdb */
918 mk_sense_buffer(devip, ILLEGAL_REQUEST,
919 INVALID_FIELD_IN_CDB, 0);
5a09e398 920 kfree(arr);
1da177e4
LT		 921 return check_condition_result;
922 }
c65b1445 923 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
5a09e398 924 ret = fill_from_dev_buffer(scp, arr,
c65b1445 925 min(len, SDEBUG_MAX_INQ_ARR_SZ));
5a09e398
HR		 926 kfree(arr);
927 return ret;
1da177e4
LT		 928 }
929 /* drops through here for a standard inquiry */
d986788b 930 arr[1] = scsi_debug_removable ? 0x80 : 0; /* Removable disk */
1da177e4
LT		 931 arr[2] = scsi_debug_scsi_level;
932 arr[3] = 2; /* response_data_format==2 */
933 arr[4] = SDEBUG_LONG_INQ_SZ - 5;
c6a44287 934 arr[5] = scsi_debug_dif ? 1 : 0; /* PROTECT bit */
5a09e398
HR		 935 if (0 == scsi_debug_vpd_use_hostno)
936 arr[5] = 0x10; /* claim: implicit TGPS */
c65b1445 937 arr[6] = 0x10; /* claim: MultiP */
1da177e4 938 /* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
c65b1445 939 arr[7] = 0xa; /* claim: LINKED + CMDQUE */
1da177e4
LT		 940 memcpy(&arr[8], inq_vendor_id, 8);
941 memcpy(&arr[16], inq_product_id, 16);
942 memcpy(&arr[32], inq_product_rev, 4);
943 /* version descriptors (2 bytes each) follow */
c65b1445
DG		 944 arr[58] = 0x0; arr[59] = 0x77; /* SAM-3 ANSI */
945 arr[60] = 0x3; arr[61] = 0x14; /* SPC-3 ANSI */
946 n = 62;
1da177e4 947 if (scsi_debug_ptype == 0) {
c65b1445 948 arr[n++] = 0x3; arr[n++] = 0x3d; /* SBC-2 ANSI */
1da177e4 949 } else if (scsi_debug_ptype == 1) {
c65b1445 950 arr[n++] = 0x3; arr[n++] = 0x60; /* SSC-2 no version */
1da177e4 951 }
c65b1445 952 arr[n++] = 0xc; arr[n++] = 0xf; /* SAS-1.1 rev 10 */
5a09e398 953 ret = fill_from_dev_buffer(scp, arr,
1da177e4 954 min(alloc_len, SDEBUG_LONG_INQ_SZ));
5a09e398
HR		 955 kfree(arr);
956 return ret;
1da177e4
LT		 957}
958
959static int resp_requests(struct scsi_cmnd * scp,
960 struct sdebug_dev_info * devip)
961{
962 unsigned char * sbuff;
963 unsigned char *cmd = (unsigned char *)scp->cmnd;
964 unsigned char arr[SDEBUG_SENSE_LEN];
c65b1445 965 int want_dsense;
1da177e4
LT		 966 int len = 18;
967
c65b1445 968 memset(arr, 0, sizeof(arr));
1da177e4 969 if (devip->reset == 1)
c65b1445
DG		 970 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
971 want_dsense = !!(cmd[1] & 1) || scsi_debug_dsense;
1da177e4 972 sbuff = devip->sense_buff;
c65b1445
DG		 973 if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
974 if (want_dsense) {
975 arr[0] = 0x72;
976 arr[1] = 0x0; /* NO_SENSE in sense_key */
977 arr[2] = THRESHOLD_EXCEEDED;
978 arr[3] = 0xff; /* TEST set and MRIE==6 */
979 } else {
980 arr[0] = 0x70;
981 arr[2] = 0x0; /* NO_SENSE in sense_key */
982 arr[7] = 0xa; /* 18 byte sense buffer */
983 arr[12] = THRESHOLD_EXCEEDED;
984 arr[13] = 0xff; /* TEST set and MRIE==6 */
985 }
c65b1445 986 } else {
1da177e4 987 memcpy(arr, sbuff, SDEBUG_SENSE_LEN);
c65b1445
DG		 988 if ((cmd[1] & 1) && (! scsi_debug_dsense)) {
989 /* DESC bit set and sense_buff in fixed format */
990 memset(arr, 0, sizeof(arr));
991 arr[0] = 0x72;
992 arr[1] = sbuff[2]; /* sense key */
993 arr[2] = sbuff[12]; /* asc */
994 arr[3] = sbuff[13]; /* ascq */
995 len = 8;
996 }
997 }
998 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
1da177e4
LT		 999 return fill_from_dev_buffer(scp, arr, len);
1000}
1001
c65b1445
DG		 1002static int resp_start_stop(struct scsi_cmnd * scp,
1003 struct sdebug_dev_info * devip)
1004{
1005 unsigned char *cmd = (unsigned char *)scp->cmnd;
1006 int power_cond, errsts, start;
1007
1008 if ((errsts = check_readiness(scp, 1, devip)))
1009 return errsts;
1010 power_cond = (cmd[4] & 0xf0) >> 4;
1011 if (power_cond) {
1012 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1013 0);
1014 return check_condition_result;
1015 }
1016 start = cmd[4] & 1;
1017 if (start == devip->stopped)
1018 devip->stopped = !start;
1019 return 0;
1020}
1021
28898873
FT		 1022static sector_t get_sdebug_capacity(void)
1023{
1024 if (scsi_debug_virtual_gb > 0)
5447ed6c
DG		 1025 return (sector_t)scsi_debug_virtual_gb *
1026 (1073741824 / scsi_debug_sector_size);
28898873
FT		 1027 else
1028 return sdebug_store_sectors;
1029}
1030
1da177e4
LT		 1031#define SDEBUG_READCAP_ARR_SZ 8
1032static int resp_readcap(struct scsi_cmnd * scp,
1033 struct sdebug_dev_info * devip)
1034{
1035 unsigned char arr[SDEBUG_READCAP_ARR_SZ];
c65b1445 1036 unsigned int capac;
1da177e4
LT		 1037 int errsts;
1038
c65b1445 1039 if ((errsts = check_readiness(scp, 1, devip)))
1da177e4 1040 return errsts;
c65b1445 1041 /* following just in case virtual_gb changed */
28898873 1042 sdebug_capacity = get_sdebug_capacity();
1da177e4 1043 memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
c65b1445
DG		 1044 if (sdebug_capacity < 0xffffffff) {
1045 capac = (unsigned int)sdebug_capacity - 1;
1046 arr[0] = (capac >> 24);
1047 arr[1] = (capac >> 16) & 0xff;
1048 arr[2] = (capac >> 8) & 0xff;
1049 arr[3] = capac & 0xff;
1050 } else {
1051 arr[0] = 0xff;
1052 arr[1] = 0xff;
1053 arr[2] = 0xff;
1054 arr[3] = 0xff;
1055 }
597136ab
MP		 1056 arr[6] = (scsi_debug_sector_size >> 8) & 0xff;
1057 arr[7] = scsi_debug_sector_size & 0xff;
1da177e4
LT		 1058 return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
1059}
1060
c65b1445
DG		 1061#define SDEBUG_READCAP16_ARR_SZ 32
1062static int resp_readcap16(struct scsi_cmnd * scp,
1063 struct sdebug_dev_info * devip)
1064{
1065 unsigned char *cmd = (unsigned char *)scp->cmnd;
1066 unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
1067 unsigned long long capac;
1068 int errsts, k, alloc_len;
1069
1070 if ((errsts = check_readiness(scp, 1, devip)))
1071 return errsts;
1072 alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8)
1073 + cmd[13]);
1074 /* following just in case virtual_gb changed */
28898873 1075 sdebug_capacity = get_sdebug_capacity();
c65b1445
DG		 1076 memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
1077 capac = sdebug_capacity - 1;
1078 for (k = 0; k < 8; ++k, capac >>= 8)
1079 arr[7 - k] = capac & 0xff;
597136ab
MP		 1080 arr[8] = (scsi_debug_sector_size >> 24) & 0xff;
1081 arr[9] = (scsi_debug_sector_size >> 16) & 0xff;
1082 arr[10] = (scsi_debug_sector_size >> 8) & 0xff;
1083 arr[11] = scsi_debug_sector_size & 0xff;
ea61fca5
MP		 1084 arr[13] = scsi_debug_physblk_exp & 0xf;
1085 arr[14] = (scsi_debug_lowest_aligned >> 8) & 0x3f;
44d92694 1086
be1dd78d 1087 if (scsi_debug_lbp()) {
5b94e232 1088 arr[14] |= 0x80; /* LBPME */
be1dd78d
ES		 1089 if (scsi_debug_lbprz)
1090 arr[14] |= 0x40; /* LBPRZ */
1091 }
44d92694 1092
ea61fca5 1093 arr[15] = scsi_debug_lowest_aligned & 0xff;
c6a44287
MP		 1094
1095 if (scsi_debug_dif) {
1096 arr[12] = (scsi_debug_dif - 1) << 1; /* P_TYPE */
1097 arr[12] |= 1; /* PROT_EN */
1098 }
1099
c65b1445
DG		 1100 return fill_from_dev_buffer(scp, arr,
1101 min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
1102}
1103
5a09e398
HR		 1104#define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
1105
1106static int resp_report_tgtpgs(struct scsi_cmnd * scp,
1107 struct sdebug_dev_info * devip)
1108{
1109 unsigned char *cmd = (unsigned char *)scp->cmnd;
1110 unsigned char * arr;
1111 int host_no = devip->sdbg_host->shost->host_no;
1112 int n, ret, alen, rlen;
1113 int port_group_a, port_group_b, port_a, port_b;
1114
1115 alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8)
1116 + cmd[9]);
1117
6f3cbf55
DG		 1118 arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
1119 if (! arr)
1120 return DID_REQUEUE << 16;
5a09e398
HR		 1121 /*
1122 * EVPD page 0x88 states we have two ports, one
1123 * real and a fake port with no device connected.
1124 * So we create two port groups with one port each
1125 * and set the group with port B to unavailable.
1126 */
1127 port_a = 0x1; /* relative port A */
1128 port_b = 0x2; /* relative port B */
1129 port_group_a = (((host_no + 1) & 0x7f) << 8) +
1130 (devip->channel & 0x7f);
1131 port_group_b = (((host_no + 1) & 0x7f) << 8) +
1132 (devip->channel & 0x7f) + 0x80;
1133
1134 /*
1135 * The asymmetric access state is cycled according to the host_id.
1136 */
1137 n = 4;
1138 if (0 == scsi_debug_vpd_use_hostno) {
1139 arr[n++] = host_no % 3; /* Asymm access state */
1140 arr[n++] = 0x0F; /* claim: all states are supported */
1141 } else {
1142 arr[n++] = 0x0; /* Active/Optimized path */
1143 arr[n++] = 0x01; /* claim: only support active/optimized paths */
1144 }
1145 arr[n++] = (port_group_a >> 8) & 0xff;
1146 arr[n++] = port_group_a & 0xff;
1147 arr[n++] = 0; /* Reserved */
1148 arr[n++] = 0; /* Status code */
1149 arr[n++] = 0; /* Vendor unique */
1150 arr[n++] = 0x1; /* One port per group */
1151 arr[n++] = 0; /* Reserved */
1152 arr[n++] = 0; /* Reserved */
1153 arr[n++] = (port_a >> 8) & 0xff;
1154 arr[n++] = port_a & 0xff;
1155 arr[n++] = 3; /* Port unavailable */
1156 arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
1157 arr[n++] = (port_group_b >> 8) & 0xff;
1158 arr[n++] = port_group_b & 0xff;
1159 arr[n++] = 0; /* Reserved */
1160 arr[n++] = 0; /* Status code */
1161 arr[n++] = 0; /* Vendor unique */
1162 arr[n++] = 0x1; /* One port per group */
1163 arr[n++] = 0; /* Reserved */
1164 arr[n++] = 0; /* Reserved */
1165 arr[n++] = (port_b >> 8) & 0xff;
1166 arr[n++] = port_b & 0xff;
1167
1168 rlen = n - 4;
1169 arr[0] = (rlen >> 24) & 0xff;
1170 arr[1] = (rlen >> 16) & 0xff;
1171 arr[2] = (rlen >> 8) & 0xff;
1172 arr[3] = rlen & 0xff;
1173
1174 /*
1175 * Return the smallest value of either
1176 * - The allocated length
1177 * - The constructed command length
1178 * - The maximum array size
1179 */
1180 rlen = min(alen,n);
1181 ret = fill_from_dev_buffer(scp, arr,
1182 min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
1183 kfree(arr);
1184 return ret;
1185}
1186
1da177e4
LT		 1187/* <<Following mode page info copied from ST318451LW>> */
1188
1189static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
1190{ /* Read-Write Error Recovery page for mode_sense */
1191 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
1192 5, 0, 0xff, 0xff};
1193
1194 memcpy(p, err_recov_pg, sizeof(err_recov_pg));
1195 if (1 == pcontrol)
1196 memset(p + 2, 0, sizeof(err_recov_pg) - 2);
1197 return sizeof(err_recov_pg);
1198}
1199
1200static int resp_disconnect_pg(unsigned char * p, int pcontrol, int target)
1201{ /* Disconnect-Reconnect page for mode_sense */
1202 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
1203 0, 0, 0, 0, 0, 0, 0, 0};
1204
1205 memcpy(p, disconnect_pg, sizeof(disconnect_pg));
1206 if (1 == pcontrol)
1207 memset(p + 2, 0, sizeof(disconnect_pg) - 2);
1208 return sizeof(disconnect_pg);
1209}
1210
1211static int resp_format_pg(unsigned char * p, int pcontrol, int target)
1212{ /* Format device page for mode_sense */
597136ab
MP		 1213 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
1214 0, 0, 0, 0, 0, 0, 0, 0,
1215 0, 0, 0, 0, 0x40, 0, 0, 0};
1216
1217 memcpy(p, format_pg, sizeof(format_pg));
1218 p[10] = (sdebug_sectors_per >> 8) & 0xff;
1219 p[11] = sdebug_sectors_per & 0xff;
1220 p[12] = (scsi_debug_sector_size >> 8) & 0xff;
1221 p[13] = scsi_debug_sector_size & 0xff;
d986788b 1222 if (scsi_debug_removable)
597136ab
MP		 1223 p[20] |= 0x20; /* should agree with INQUIRY */
1224 if (1 == pcontrol)
1225 memset(p + 2, 0, sizeof(format_pg) - 2);
1226 return sizeof(format_pg);
1da177e4
LT		 1227}
1228
1229static int resp_caching_pg(unsigned char * p, int pcontrol, int target)
1230{ /* Caching page for mode_sense */
1231 unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1232 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
1233
1234 memcpy(p, caching_pg, sizeof(caching_pg));
1235 if (1 == pcontrol)
1236 memset(p + 2, 0, sizeof(caching_pg) - 2);
1237 return sizeof(caching_pg);
1238}
1239
1240static int resp_ctrl_m_pg(unsigned char * p, int pcontrol, int target)
1241{ /* Control mode page for mode_sense */
c65b1445
DG		 1242 unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
1243 0, 0, 0, 0};
1244 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1da177e4
LT		 1245 0, 0, 0x2, 0x4b};
1246
1247 if (scsi_debug_dsense)
1248 ctrl_m_pg[2] |= 0x4;
c65b1445
DG		 1249 else
1250 ctrl_m_pg[2] &= ~0x4;
c6a44287
MP		 1251
1252 if (scsi_debug_ato)
1253 ctrl_m_pg[5] |= 0x80; /* ATO=1 */
1254
1da177e4
LT		 1255 memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
1256 if (1 == pcontrol)
c65b1445
DG		 1257 memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
1258 else if (2 == pcontrol)
1259 memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
1da177e4
LT		 1260 return sizeof(ctrl_m_pg);
1261}
1262
c65b1445 1263
1da177e4
LT		 1264static int resp_iec_m_pg(unsigned char * p, int pcontrol, int target)
1265{ /* Informational Exceptions control mode page for mode_sense */
c65b1445
DG		 1266 unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
1267 0, 0, 0x0, 0x0};
1268 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1269 0, 0, 0x0, 0x0};
1270
1da177e4
LT		 1271 memcpy(p, iec_m_pg, sizeof(iec_m_pg));
1272 if (1 == pcontrol)
c65b1445
DG		 1273 memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
1274 else if (2 == pcontrol)
1275 memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
1da177e4
LT		 1276 return sizeof(iec_m_pg);
1277}
1278
c65b1445
DG		 1279static int resp_sas_sf_m_pg(unsigned char * p, int pcontrol, int target)
1280{ /* SAS SSP mode page - short format for mode_sense */
1281 unsigned char sas_sf_m_pg[] = {0x19, 0x6,
1282 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
1283
1284 memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
1285 if (1 == pcontrol)
1286 memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
1287 return sizeof(sas_sf_m_pg);
1288}
1289
1290
1291static int resp_sas_pcd_m_spg(unsigned char * p, int pcontrol, int target,
1292 int target_dev_id)
1293{ /* SAS phy control and discover mode page for mode_sense */
1294 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
1295 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
1296 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1297 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1298 0x2, 0, 0, 0, 0, 0, 0, 0,
1299 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1300 0, 0, 0, 0, 0, 0, 0, 0,
1301 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
1302 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1303 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1304 0x3, 0, 0, 0, 0, 0, 0, 0,
1305 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1306 0, 0, 0, 0, 0, 0, 0, 0,
1307 };
1308 int port_a, port_b;
1309
1310 port_a = target_dev_id + 1;
1311 port_b = port_a + 1;
1312 memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
1313 p[20] = (port_a >> 24);
1314 p[21] = (port_a >> 16) & 0xff;
1315 p[22] = (port_a >> 8) & 0xff;
1316 p[23] = port_a & 0xff;
1317 p[48 + 20] = (port_b >> 24);
1318 p[48 + 21] = (port_b >> 16) & 0xff;
1319 p[48 + 22] = (port_b >> 8) & 0xff;
1320 p[48 + 23] = port_b & 0xff;
1321 if (1 == pcontrol)
1322 memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
1323 return sizeof(sas_pcd_m_pg);
1324}
1325
1326static int resp_sas_sha_m_spg(unsigned char * p, int pcontrol)
1327{ /* SAS SSP shared protocol specific port mode subpage */
1328 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
1329 0, 0, 0, 0, 0, 0, 0, 0,
1330 };
1331
1332 memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
1333 if (1 == pcontrol)
1334 memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
1335 return sizeof(sas_sha_m_pg);
1336}
1337
1da177e4
LT		 1338#define SDEBUG_MAX_MSENSE_SZ 256
1339
1340static int resp_mode_sense(struct scsi_cmnd * scp, int target,
1341 struct sdebug_dev_info * devip)
1342{
23183910
DG		 1343 unsigned char dbd, llbaa;
1344 int pcontrol, pcode, subpcode, bd_len;
1da177e4 1345 unsigned char dev_spec;
23183910 1346 int k, alloc_len, msense_6, offset, len, errsts, target_dev_id;
1da177e4
LT		 1347 unsigned char * ap;
1348 unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
1349 unsigned char *cmd = (unsigned char *)scp->cmnd;
1350
c65b1445 1351 if ((errsts = check_readiness(scp, 1, devip)))
1da177e4 1352 return errsts;
23183910 1353 dbd = !!(cmd[1] & 0x8);
1da177e4
LT		 1354 pcontrol = (cmd[2] & 0xc0) >> 6;
1355 pcode = cmd[2] & 0x3f;
1356 subpcode = cmd[3];
1357 msense_6 = (MODE_SENSE == cmd[0]);
23183910
DG		 1358 llbaa = msense_6 ? 0 : !!(cmd[1] & 0x10);
1359 if ((0 == scsi_debug_ptype) && (0 == dbd))
1360 bd_len = llbaa ? 16 : 8;
1361 else
1362 bd_len = 0;
1da177e4
LT		 1363 alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]);
1364 memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
1365 if (0x3 == pcontrol) { /* Saving values not supported */
1366 mk_sense_buffer(devip, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP,
1367 0);
1368 return check_condition_result;
1369 }
c65b1445
DG		 1370 target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
1371 (devip->target * 1000) - 3;
23183910
DG		 1372 /* set DPOFUA bit for disks */
1373 if (0 == scsi_debug_ptype)
1374 dev_spec = (DEV_READONLY(target) ? 0x80 : 0x0) | 0x10;
1375 else
1376 dev_spec = 0x0;
1da177e4
LT		 1377 if (msense_6) {
1378 arr[2] = dev_spec;
23183910 1379 arr[3] = bd_len;
1da177e4
LT		 1380 offset = 4;
1381 } else {
1382 arr[3] = dev_spec;
23183910
DG		 1383 if (16 == bd_len)
1384 arr[4] = 0x1; /* set LONGLBA bit */
1385 arr[7] = bd_len; /* assume 255 or less */
1da177e4
LT		 1386 offset = 8;
1387 }
1388 ap = arr + offset;
28898873
FT		 1389 if ((bd_len > 0) && (!sdebug_capacity))
1390 sdebug_capacity = get_sdebug_capacity();
1391
23183910
DG		 1392 if (8 == bd_len) {
1393 if (sdebug_capacity > 0xfffffffe) {
1394 ap[0] = 0xff;
1395 ap[1] = 0xff;
1396 ap[2] = 0xff;
1397 ap[3] = 0xff;
1398 } else {
1399 ap[0] = (sdebug_capacity >> 24) & 0xff;
1400 ap[1] = (sdebug_capacity >> 16) & 0xff;
1401 ap[2] = (sdebug_capacity >> 8) & 0xff;
1402 ap[3] = sdebug_capacity & 0xff;
1403 }
597136ab
MP		 1404 ap[6] = (scsi_debug_sector_size >> 8) & 0xff;
1405 ap[7] = scsi_debug_sector_size & 0xff;
23183910
DG		 1406 offset += bd_len;
1407 ap = arr + offset;
1408 } else if (16 == bd_len) {
1409 unsigned long long capac = sdebug_capacity;
1410
1411 for (k = 0; k < 8; ++k, capac >>= 8)
1412 ap[7 - k] = capac & 0xff;
597136ab
MP		 1413 ap[12] = (scsi_debug_sector_size >> 24) & 0xff;
1414 ap[13] = (scsi_debug_sector_size >> 16) & 0xff;
1415 ap[14] = (scsi_debug_sector_size >> 8) & 0xff;
1416 ap[15] = scsi_debug_sector_size & 0xff;
23183910
DG		 1417 offset += bd_len;
1418 ap = arr + offset;
1419 }
1da177e4 1420
c65b1445
DG		 1421 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
1422 /* TODO: Control Extension page */
1da177e4
LT		 1423 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1424 0);
1425 return check_condition_result;
1426 }
1427 switch (pcode) {
1428 case 0x1: /* Read-Write error recovery page, direct access */
1429 len = resp_err_recov_pg(ap, pcontrol, target);
1430 offset += len;
1431 break;
1432 case 0x2: /* Disconnect-Reconnect page, all devices */
1433 len = resp_disconnect_pg(ap, pcontrol, target);
1434 offset += len;
1435 break;
1436 case 0x3: /* Format device page, direct access */
1437 len = resp_format_pg(ap, pcontrol, target);
1438 offset += len;
1439 break;
1440 case 0x8: /* Caching page, direct access */
1441 len = resp_caching_pg(ap, pcontrol, target);
1442 offset += len;
1443 break;
1444 case 0xa: /* Control Mode page, all devices */
1445 len = resp_ctrl_m_pg(ap, pcontrol, target);
1446 offset += len;
1447 break;
c65b1445
DG		 1448 case 0x19: /* if spc==1 then sas phy, control+discover */
1449 if ((subpcode > 0x2) && (subpcode < 0xff)) {
1450 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1451 INVALID_FIELD_IN_CDB, 0);
1452 return check_condition_result;
1453 }
1454 len = 0;
1455 if ((0x0 == subpcode) || (0xff == subpcode))
1456 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1457 if ((0x1 == subpcode) || (0xff == subpcode))
1458 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
1459 target_dev_id);
1460 if ((0x2 == subpcode) || (0xff == subpcode))
1461 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1462 offset += len;
1463 break;
1da177e4
LT		 1464 case 0x1c: /* Informational Exceptions Mode page, all devices */
1465 len = resp_iec_m_pg(ap, pcontrol, target);
1466 offset += len;
1467 break;
1468 case 0x3f: /* Read all Mode pages */
c65b1445
DG		 1469 if ((0 == subpcode) || (0xff == subpcode)) {
1470 len = resp_err_recov_pg(ap, pcontrol, target);
1471 len += resp_disconnect_pg(ap + len, pcontrol, target);
1472 len += resp_format_pg(ap + len, pcontrol, target);
1473 len += resp_caching_pg(ap + len, pcontrol, target);
1474 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
1475 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1476 if (0xff == subpcode) {
1477 len += resp_sas_pcd_m_spg(ap + len, pcontrol,
1478 target, target_dev_id);
1479 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1480 }
1481 len += resp_iec_m_pg(ap + len, pcontrol, target);
1482 } else {
1483 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1484 INVALID_FIELD_IN_CDB, 0);
1485 return check_condition_result;
1486 }
1da177e4
LT		 1487 offset += len;
1488 break;
1489 default:
1490 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1491 0);
1492 return check_condition_result;
1493 }
1494 if (msense_6)
1495 arr[0] = offset - 1;
1496 else {
1497 arr[0] = ((offset - 2) >> 8) & 0xff;
1498 arr[1] = (offset - 2) & 0xff;
1499 }
1500 return fill_from_dev_buffer(scp, arr, min(alloc_len, offset));
1501}
1502
c65b1445
DG		 1503#define SDEBUG_MAX_MSELECT_SZ 512
1504
1505static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
1506 struct sdebug_dev_info * devip)
1507{
1508 int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
1509 int param_len, res, errsts, mpage;
1510 unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
1511 unsigned char *cmd = (unsigned char *)scp->cmnd;
1512
1513 if ((errsts = check_readiness(scp, 1, devip)))
1514 return errsts;
1515 memset(arr, 0, sizeof(arr));
1516 pf = cmd[1] & 0x10;
1517 sp = cmd[1] & 0x1;
1518 param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]);
1519 if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
1520 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1521 INVALID_FIELD_IN_CDB, 0);
1522 return check_condition_result;
1523 }
1524 res = fetch_to_dev_buffer(scp, arr, param_len);
1525 if (-1 == res)
1526 return (DID_ERROR << 16);
1527 else if ((res < param_len) &&
1528 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1529 printk(KERN_INFO "scsi_debug: mode_select: cdb indicated=%d, "
1530 " IO sent=%d bytes\n", param_len, res);
1531 md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2);
1532 bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]);
23183910 1533 if (md_len > 2) {
c65b1445
DG		 1534 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1535 INVALID_FIELD_IN_PARAM_LIST, 0);
1536 return check_condition_result;
1537 }
1538 off = bd_len + (mselect6 ? 4 : 8);
1539 mpage = arr[off] & 0x3f;
1540 ps = !!(arr[off] & 0x80);
1541 if (ps) {
1542 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1543 INVALID_FIELD_IN_PARAM_LIST, 0);
1544 return check_condition_result;
1545 }
1546 spf = !!(arr[off] & 0x40);
1547 pg_len = spf ? ((arr[off + 2] << 8) + arr[off + 3] + 4) :
1548 (arr[off + 1] + 2);
1549 if ((pg_len + off) > param_len) {
1550 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1551 PARAMETER_LIST_LENGTH_ERR, 0);
1552 return check_condition_result;
1553 }
1554 switch (mpage) {
1555 case 0xa: /* Control Mode page */
1556 if (ctrl_m_pg[1] == arr[off + 1]) {
1557 memcpy(ctrl_m_pg + 2, arr + off + 2,
1558 sizeof(ctrl_m_pg) - 2);
1559 scsi_debug_dsense = !!(ctrl_m_pg[2] & 0x4);
1560 return 0;
1561 }
1562 break;
1563 case 0x1c: /* Informational Exceptions Mode page */
1564 if (iec_m_pg[1] == arr[off + 1]) {
1565 memcpy(iec_m_pg + 2, arr + off + 2,
1566 sizeof(iec_m_pg) - 2);
1567 return 0;
1568 }
1569 break;
1570 default:
1571 break;
1572 }
1573 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1574 INVALID_FIELD_IN_PARAM_LIST, 0);
1575 return check_condition_result;
1576}
1577
1578static int resp_temp_l_pg(unsigned char * arr)
1579{
1580 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
1581 0x0, 0x1, 0x3, 0x2, 0x0, 65,
1582 };
1583
1584 memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
1585 return sizeof(temp_l_pg);
1586}
1587
1588static int resp_ie_l_pg(unsigned char * arr)
1589{
1590 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
1591 };
1592
1593 memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
1594 if (iec_m_pg[2] & 0x4) { /* TEST bit set */
1595 arr[4] = THRESHOLD_EXCEEDED;
1596 arr[5] = 0xff;
1597 }
1598 return sizeof(ie_l_pg);
1599}
1600
1601#define SDEBUG_MAX_LSENSE_SZ 512
1602
1603static int resp_log_sense(struct scsi_cmnd * scp,
1604 struct sdebug_dev_info * devip)
1605{
23183910 1606 int ppc, sp, pcontrol, pcode, subpcode, alloc_len, errsts, len, n;
c65b1445
DG		 1607 unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
1608 unsigned char *cmd = (unsigned char *)scp->cmnd;
1609
1610 if ((errsts = check_readiness(scp, 1, devip)))
1611 return errsts;
1612 memset(arr, 0, sizeof(arr));
1613 ppc = cmd[1] & 0x2;
1614 sp = cmd[1] & 0x1;
1615 if (ppc || sp) {
1616 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1617 INVALID_FIELD_IN_CDB, 0);
1618 return check_condition_result;
1619 }
1620 pcontrol = (cmd[2] & 0xc0) >> 6;
1621 pcode = cmd[2] & 0x3f;
23183910 1622 subpcode = cmd[3] & 0xff;
c65b1445
DG		 1623 alloc_len = (cmd[7] << 8) + cmd[8];
1624 arr[0] = pcode;
23183910
DG		 1625 if (0 == subpcode) {
1626 switch (pcode) {
1627 case 0x0: /* Supported log pages log page */
1628 n = 4;
1629 arr[n++] = 0x0; /* this page */
1630 arr[n++] = 0xd; /* Temperature */
1631 arr[n++] = 0x2f; /* Informational exceptions */
1632 arr[3] = n - 4;
1633 break;
1634 case 0xd: /* Temperature log page */
1635 arr[3] = resp_temp_l_pg(arr + 4);
1636 break;
1637 case 0x2f: /* Informational exceptions log page */
1638 arr[3] = resp_ie_l_pg(arr + 4);
1639 break;
1640 default:
1641 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1642 INVALID_FIELD_IN_CDB, 0);
1643 return check_condition_result;
1644 }
1645 } else if (0xff == subpcode) {
1646 arr[0] |= 0x40;
1647 arr[1] = subpcode;
1648 switch (pcode) {
1649 case 0x0: /* Supported log pages and subpages log page */
1650 n = 4;
1651 arr[n++] = 0x0;
1652 arr[n++] = 0x0; /* 0,0 page */
1653 arr[n++] = 0x0;
1654 arr[n++] = 0xff; /* this page */
1655 arr[n++] = 0xd;
1656 arr[n++] = 0x0; /* Temperature */
1657 arr[n++] = 0x2f;
1658 arr[n++] = 0x0; /* Informational exceptions */
1659 arr[3] = n - 4;
1660 break;
1661 case 0xd: /* Temperature subpages */
1662 n = 4;
1663 arr[n++] = 0xd;
1664 arr[n++] = 0x0; /* Temperature */
1665 arr[3] = n - 4;
1666 break;
1667 case 0x2f: /* Informational exceptions subpages */
1668 n = 4;
1669 arr[n++] = 0x2f;
1670 arr[n++] = 0x0; /* Informational exceptions */
1671 arr[3] = n - 4;
1672 break;
1673 default:
1674 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1675 INVALID_FIELD_IN_CDB, 0);
1676 return check_condition_result;
1677 }
1678 } else {
c65b1445
DG		 1679 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1680 INVALID_FIELD_IN_CDB, 0);
1681 return check_condition_result;
1682 }
1683 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
1684 return fill_from_dev_buffer(scp, arr,
1685 min(len, SDEBUG_MAX_INQ_ARR_SZ));
1686}
1687
19789100
FT		 1688static int check_device_access_params(struct sdebug_dev_info *devi,
1689 unsigned long long lba, unsigned int num)
1da177e4 1690{
c65b1445 1691 if (lba + num > sdebug_capacity) {
19789100 1692 mk_sense_buffer(devi, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE, 0);
1da177e4
LT		 1693 return check_condition_result;
1694 }
c65b1445
DG		 1695 /* transfer length excessive (tie in to block limits VPD page) */
1696 if (num > sdebug_store_sectors) {
19789100 1697 mk_sense_buffer(devi, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
c65b1445
DG		 1698 return check_condition_result;
1699 }
19789100
FT		 1700 return 0;
1701}
1702
a4517511 1703/* Returns number of bytes copied or -1 if error. */
19789100
FT		 1704static int do_device_access(struct scsi_cmnd *scmd,
1705 struct sdebug_dev_info *devi,
1706 unsigned long long lba, unsigned int num, int write)
1707{
1708 int ret;
a361cc00 1709 unsigned long long block, rest = 0;
a4517511
AM		 1710 struct scsi_data_buffer *sdb;
1711 enum dma_data_direction dir;
1712 size_t (*func)(struct scatterlist *, unsigned int, void *, size_t,
1713 off_t);
1714
1715 if (write) {
1716 sdb = scsi_out(scmd);
1717 dir = DMA_TO_DEVICE;
1718 func = sg_pcopy_to_buffer;
1719 } else {
1720 sdb = scsi_in(scmd);
1721 dir = DMA_FROM_DEVICE;
1722 func = sg_pcopy_from_buffer;
1723 }
19789100 1724
a4517511
AM		 1725 if (!sdb->length)
1726 return 0;
1727 if (!(scsi_bidi_cmnd(scmd) || scmd->sc_data_direction == dir))
1728 return -1;
19789100
FT		 1729
1730 block = do_div(lba, sdebug_store_sectors);
1731 if (block + num > sdebug_store_sectors)
1732 rest = block + num - sdebug_store_sectors;
1733
a4517511
AM		 1734 ret = func(sdb->table.sgl, sdb->table.nents,
1735 fake_storep + (block * scsi_debug_sector_size),
1736 (num - rest) * scsi_debug_sector_size, 0);
1737 if (ret != (num - rest) * scsi_debug_sector_size)
1738 return ret;
1739
1740 if (rest) {
1741 ret += func(sdb->table.sgl, sdb->table.nents,
1742 fake_storep, rest * scsi_debug_sector_size,
1743 (num - rest) * scsi_debug_sector_size);
1744 }
19789100
FT		 1745
1746 return ret;
1747}
1748
51d648af 1749static __be16 dif_compute_csum(const void *buf, int len)
beb40ea4 1750{
51d648af 1751 __be16 csum;
beb40ea4 1752
51d648af
AM		 1753 if (scsi_debug_guard)
1754 csum = (__force __be16)ip_compute_csum(buf, len);
1755 else
beb40ea4 1756 csum = cpu_to_be16(crc_t10dif(buf, len));
51d648af 1757
beb40ea4
AM		 1758 return csum;
1759}
1760
1761static int dif_verify(struct sd_dif_tuple *sdt, const void *data,
1762 sector_t sector, u32 ei_lba)
1763{
51d648af 1764 __be16 csum = dif_compute_csum(data, scsi_debug_sector_size);
beb40ea4
AM		 1765
1766 if (sdt->guard_tag != csum) {
1767 pr_err("%s: GUARD check failed on sector %lu rcvd 0x%04x, data 0x%04x\n",
1768 __func__,
1769 (unsigned long)sector,
1770 be16_to_cpu(sdt->guard_tag),
1771 be16_to_cpu(csum));
1772 return 0x01;
1773 }
1774 if (scsi_debug_dif == SD_DIF_TYPE1_PROTECTION &&
1775 be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
1776 pr_err("%s: REF check failed on sector %lu\n",
1777 __func__, (unsigned long)sector);
1778 return 0x03;
1779 }
1780 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
1781 be32_to_cpu(sdt->ref_tag) != ei_lba) {
1782 pr_err("%s: REF check failed on sector %lu\n",
1783 __func__, (unsigned long)sector);
beb40ea4
AM		 1784 return 0x03;
1785 }
1786 return 0;
1787}
1788
bb8c063c 1789static void dif_copy_prot(struct scsi_cmnd *SCpnt, sector_t sector,
65f72f2a 1790 unsigned int sectors, bool read)
c6a44287
MP		 1791{
1792 unsigned int i, resid;
1793 struct scatterlist *psgl;
c6a44287 1794 void *paddr;
14faa944 1795 const void *dif_store_end = dif_storep + sdebug_store_sectors;
c6a44287 1796
e18d8bea
AM		 1797 /* Bytes of protection data to copy into sgl */
1798 resid = sectors * sizeof(*dif_storep);
c6a44287
MP		 1799
1800 scsi_for_each_prot_sg(SCpnt, psgl, scsi_prot_sg_count(SCpnt), i) {
1801 int len = min(psgl->length, resid);
14faa944
AM		 1802 void *start = dif_store(sector);
1803 int rest = 0;
1804
1805 if (dif_store_end < start + len)
1806 rest = start + len - dif_store_end;
c6a44287 1807
77dfce07 1808 paddr = kmap_atomic(sg_page(psgl)) + psgl->offset;
14faa944 1809
65f72f2a
AM		 1810 if (read)
1811 memcpy(paddr, start, len - rest);
1812 else
1813 memcpy(start, paddr, len - rest);
1814
1815 if (rest) {
1816 if (read)
1817 memcpy(paddr + len - rest, dif_storep, rest);
1818 else
1819 memcpy(dif_storep, paddr + len - rest, rest);
1820 }
c6a44287 1821
e18d8bea 1822 sector += len / sizeof(*dif_storep);
c6a44287 1823 resid -= len;
77dfce07 1824 kunmap_atomic(paddr);
c6a44287 1825 }
bb8c063c
AM		 1826}
1827
1828static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec,
1829 unsigned int sectors, u32 ei_lba)
1830{
1831 unsigned int i;
1832 struct sd_dif_tuple *sdt;
1833 sector_t sector;
1834
c45eabec 1835 for (i = 0; i < sectors; i++, ei_lba++) {
bb8c063c
AM		 1836 int ret;
1837
1838 sector = start_sec + i;
1839 sdt = dif_store(sector);
1840
51d648af 1841 if (sdt->app_tag == cpu_to_be16(0xffff))
bb8c063c
AM		 1842 continue;
1843
1844 ret = dif_verify(sdt, fake_store(sector), sector, ei_lba);
1845 if (ret) {
1846 dif_errors++;
1847 return ret;
1848 }
bb8c063c 1849 }
c6a44287 1850
65f72f2a 1851 dif_copy_prot(SCpnt, start_sec, sectors, true);
c6a44287
MP		 1852 dix_reads++;
1853
1854 return 0;
1855}
1856
19789100 1857static int resp_read(struct scsi_cmnd *SCpnt, unsigned long long lba,
395cef03
MP		 1858 unsigned int num, struct sdebug_dev_info *devip,
1859 u32 ei_lba)
19789100
FT		 1860{
1861 unsigned long iflags;
1862 int ret;
1863
1864 ret = check_device_access_params(devip, lba, num);
1865 if (ret)
1866 return ret;
1867
1da177e4 1868 if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) &&
32f7ef73 1869 (lba <= (OPT_MEDIUM_ERR_ADDR + OPT_MEDIUM_ERR_NUM - 1)) &&
c65b1445
DG		 1870 ((lba + num) > OPT_MEDIUM_ERR_ADDR)) {
1871 /* claim unrecoverable read error */
32f7ef73 1872 mk_sense_buffer(devip, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 0);
c65b1445
DG		 1873 /* set info field and valid bit for fixed descriptor */
1874 if (0x70 == (devip->sense_buff[0] & 0x7f)) {
1875 devip->sense_buff[0] |= 0x80; /* Valid bit */
32f7ef73
DG		 1876 ret = (lba < OPT_MEDIUM_ERR_ADDR)
1877 ? OPT_MEDIUM_ERR_ADDR : (int)lba;
c65b1445
DG		 1878 devip->sense_buff[3] = (ret >> 24) & 0xff;
1879 devip->sense_buff[4] = (ret >> 16) & 0xff;
1880 devip->sense_buff[5] = (ret >> 8) & 0xff;
1881 devip->sense_buff[6] = ret & 0xff;
1882 }
a87e3a67 1883 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
1da177e4
LT		 1884 return check_condition_result;
1885 }
c6a44287
MP		 1886
1887 /* DIX + T10 DIF */
1888 if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) {
395cef03 1889 int prot_ret = prot_verify_read(SCpnt, lba, num, ei_lba);
c6a44287
MP		 1890
1891 if (prot_ret) {
1892 mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, prot_ret);
1893 return illegal_condition_result;
1894 }
1895 }
1896
1da177e4 1897 read_lock_irqsave(&atomic_rw, iflags);
19789100 1898 ret = do_device_access(SCpnt, devip, lba, num, 0);
1da177e4 1899 read_unlock_irqrestore(&atomic_rw, iflags);
a4517511
AM		 1900 if (ret == -1)
1901 return DID_ERROR << 16;
1902
1903 scsi_in(SCpnt)->resid = scsi_bufflen(SCpnt) - ret;
1904
1905 return 0;
1da177e4
LT		 1906}
1907
c6a44287
MP		 1908void dump_sector(unsigned char *buf, int len)
1909{
1910 int i, j;
1911
1912 printk(KERN_ERR ">>> Sector Dump <<<\n");
1913
1914 for (i = 0 ; i < len ; i += 16) {
1915 printk(KERN_ERR "%04d: ", i);
1916
1917 for (j = 0 ; j < 16 ; j++) {
1918 unsigned char c = buf[i+j];
1919 if (c >= 0x20 && c < 0x7e)
1920 printk(" %c ", buf[i+j]);
1921 else
1922 printk("%02x ", buf[i+j]);
1923 }
1924
1925 printk("\n");
1926 }
1927}
1928
1929static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
395cef03 1930 unsigned int sectors, u32 ei_lba)
c6a44287
MP		 1931{
1932 int i, j, ret;
1933 struct sd_dif_tuple *sdt;
65f72f2a 1934 struct scatterlist *dsgl;
c6a44287
MP		 1935 struct scatterlist *psgl = scsi_prot_sglist(SCpnt);
1936 void *daddr, *paddr;
65f72f2a 1937 sector_t sector = start_sec;
c6a44287 1938 int ppage_offset;
c6a44287 1939
c6a44287
MP		 1940 BUG_ON(scsi_sg_count(SCpnt) == 0);
1941 BUG_ON(scsi_prot_sg_count(SCpnt) == 0);
1942
c6a44287
MP		 1943 ppage_offset = 0;
1944
1945 /* For each data page */
1946 scsi_for_each_sg(SCpnt, dsgl, scsi_sg_count(SCpnt), i) {
77dfce07 1947 daddr = kmap_atomic(sg_page(dsgl)) + dsgl->offset;
fc3fc352 1948 paddr = kmap_atomic(sg_page(psgl)) + psgl->offset;
c6a44287
MP		 1949
1950 /* For each sector-sized chunk in data page */
518d9df8 1951 for (j = 0; j < dsgl->length; j += scsi_debug_sector_size) {
c6a44287
MP		 1952
1953 /* If we're at the end of the current
1954 * protection page advance to the next one
1955 */
1956 if (ppage_offset >= psgl->length) {
77dfce07 1957 kunmap_atomic(paddr);
c6a44287
MP		 1958 psgl = sg_next(psgl);
1959 BUG_ON(psgl == NULL);
77dfce07 1960 paddr = kmap_atomic(sg_page(psgl))
c6a44287
MP		 1961 + psgl->offset;
1962 ppage_offset = 0;
1963 }
1964
1965 sdt = paddr + ppage_offset;
1966
65f72f2a 1967 ret = dif_verify(sdt, daddr + j, sector, ei_lba);
beb40ea4 1968 if (ret) {
518d9df8 1969 dump_sector(daddr + j, scsi_debug_sector_size);
395cef03
MP		 1970 goto out;
1971 }
1972
c6a44287 1973 sector++;
395cef03 1974 ei_lba++;
c6a44287
MP		 1975 ppage_offset += sizeof(struct sd_dif_tuple);
1976 }
1977
fc3fc352 1978 kunmap_atomic(paddr);
77dfce07 1979 kunmap_atomic(daddr);
c6a44287
MP		 1980 }
1981
65f72f2a 1982 dif_copy_prot(SCpnt, start_sec, sectors, false);
c6a44287
MP		 1983 dix_writes++;
1984
1985 return 0;
1986
1987out:
1988 dif_errors++;
77dfce07 1989 kunmap_atomic(paddr);
fc3fc352 1990 kunmap_atomic(daddr);
c6a44287
MP		 1991 return ret;
1992}
1993
b90ebc3d
AM		 1994static unsigned long lba_to_map_index(sector_t lba)
1995{
1996 if (scsi_debug_unmap_alignment) {
1997 lba += scsi_debug_unmap_granularity -
1998 scsi_debug_unmap_alignment;
1999 }
2000 do_div(lba, scsi_debug_unmap_granularity);
2001
2002 return lba;
2003}
2004
2005static sector_t map_index_to_lba(unsigned long index)
44d92694 2006{
a027b5b9
AM		 2007 sector_t lba = index * scsi_debug_unmap_granularity;
2008
2009 if (scsi_debug_unmap_alignment) {
2010 lba -= scsi_debug_unmap_granularity -
2011 scsi_debug_unmap_alignment;
2012 }
2013
2014 return lba;
b90ebc3d 2015}
44d92694 2016
b90ebc3d
AM		 2017static unsigned int map_state(sector_t lba, unsigned int *num)
2018{
2019 sector_t end;
2020 unsigned int mapped;
2021 unsigned long index;
2022 unsigned long next;
44d92694 2023
b90ebc3d
AM		 2024 index = lba_to_map_index(lba);
2025 mapped = test_bit(index, map_storep);
44d92694
MP		 2026
2027 if (mapped)
b90ebc3d 2028 next = find_next_zero_bit(map_storep, map_size, index);
44d92694 2029 else
b90ebc3d 2030 next = find_next_bit(map_storep, map_size, index);
44d92694 2031
b90ebc3d 2032 end = min_t(sector_t, sdebug_store_sectors, map_index_to_lba(next));
44d92694
MP		 2033 *num = end - lba;
2034
2035 return mapped;
2036}
2037
2038static void map_region(sector_t lba, unsigned int len)
2039{
44d92694
MP		 2040 sector_t end = lba + len;
2041
44d92694 2042 while (lba < end) {
b90ebc3d 2043 unsigned long index = lba_to_map_index(lba);
44d92694 2044
b90ebc3d
AM		 2045 if (index < map_size)
2046 set_bit(index, map_storep);
44d92694 2047
b90ebc3d 2048 lba = map_index_to_lba(index + 1);
44d92694
MP		 2049 }
2050}
2051
2052static void unmap_region(sector_t lba, unsigned int len)
2053{
44d92694
MP		 2054 sector_t end = lba + len;
2055
44d92694 2056 while (lba < end) {
b90ebc3d 2057 unsigned long index = lba_to_map_index(lba);
44d92694 2058
b90ebc3d
AM		 2059 if (lba == map_index_to_lba(index) &&
2060 lba + scsi_debug_unmap_granularity <= end &&
2061 index < map_size) {
2062 clear_bit(index, map_storep);
2063 if (scsi_debug_lbprz) {
be1dd78d 2064 memset(fake_storep +
cc34a8e6
AM		 2065 lba * scsi_debug_sector_size, 0,
2066 scsi_debug_sector_size *
2067 scsi_debug_unmap_granularity);
b90ebc3d 2068 }
e9926b43
AM		 2069 if (dif_storep) {
2070 memset(dif_storep + lba, 0xff,
2071 sizeof(*dif_storep) *
2072 scsi_debug_unmap_granularity);
2073 }
be1dd78d 2074 }
b90ebc3d 2075 lba = map_index_to_lba(index + 1);
44d92694
MP		 2076 }
2077}
2078
19789100 2079static int resp_write(struct scsi_cmnd *SCpnt, unsigned long long lba,
395cef03
MP		 2080 unsigned int num, struct sdebug_dev_info *devip,
2081 u32 ei_lba)
1da177e4
LT		 2082{
2083 unsigned long iflags;
19789100 2084 int ret;
1da177e4 2085
19789100
FT		 2086 ret = check_device_access_params(devip, lba, num);
2087 if (ret)
2088 return ret;
1da177e4 2089
c6a44287
MP		 2090 /* DIX + T10 DIF */
2091 if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) {
395cef03 2092 int prot_ret = prot_verify_write(SCpnt, lba, num, ei_lba);
c6a44287
MP		 2093
2094 if (prot_ret) {
2095 mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, prot_ret);
2096 return illegal_condition_result;
2097 }
2098 }
2099
1da177e4 2100 write_lock_irqsave(&atomic_rw, iflags);
19789100 2101 ret = do_device_access(SCpnt, devip, lba, num, 1);
9ed8d3dc 2102 if (scsi_debug_lbp())
44d92694 2103 map_region(lba, num);
1da177e4 2104 write_unlock_irqrestore(&atomic_rw, iflags);
19789100 2105 if (-1 == ret)
1da177e4 2106 return (DID_ERROR << 16);
597136ab 2107 else if ((ret < (num * scsi_debug_sector_size)) &&
1da177e4 2108 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
c65b1445 2109 printk(KERN_INFO "scsi_debug: write: cdb indicated=%u, "
597136ab 2110 " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret);
44d92694
MP		 2111
2112 return 0;
2113}
2114
2115static int resp_write_same(struct scsi_cmnd *scmd, unsigned long long lba,
2116 unsigned int num, struct sdebug_dev_info *devip,
2117 u32 ei_lba, unsigned int unmap)
2118{
2119 unsigned long iflags;
2120 unsigned long long i;
2121 int ret;
2122
2123 ret = check_device_access_params(devip, lba, num);
2124 if (ret)
2125 return ret;
2126
5b94e232
MP		 2127 if (num > scsi_debug_write_same_length) {
2128 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
2129 0);
2130 return check_condition_result;
2131 }
2132
44d92694
MP		 2133 write_lock_irqsave(&atomic_rw, iflags);
2134
9ed8d3dc 2135 if (unmap && scsi_debug_lbp()) {
44d92694
MP		 2136 unmap_region(lba, num);
2137 goto out;
2138 }
2139
2140 /* Else fetch one logical block */
2141 ret = fetch_to_dev_buffer(scmd,
2142 fake_storep + (lba * scsi_debug_sector_size),
2143 scsi_debug_sector_size);
2144
2145 if (-1 == ret) {
2146 write_unlock_irqrestore(&atomic_rw, iflags);
2147 return (DID_ERROR << 16);
2148 } else if ((ret < (num * scsi_debug_sector_size)) &&
2149 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
2150 printk(KERN_INFO "scsi_debug: write same: cdb indicated=%u, "
2151 " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret);
2152
2153 /* Copy first sector to remaining blocks */
2154 for (i = 1 ; i < num ; i++)
2155 memcpy(fake_storep + ((lba + i) * scsi_debug_sector_size),
2156 fake_storep + (lba * scsi_debug_sector_size),
2157 scsi_debug_sector_size);
2158
9ed8d3dc 2159 if (scsi_debug_lbp())
44d92694
MP		 2160 map_region(lba, num);
2161out:
2162 write_unlock_irqrestore(&atomic_rw, iflags);
2163
1da177e4
LT		 2164 return 0;
2165}
2166
44d92694
MP		 2167struct unmap_block_desc {
2168 __be64 lba;
2169 __be32 blocks;
2170 __be32 __reserved;
2171};
2172
2173static int resp_unmap(struct scsi_cmnd * scmd, struct sdebug_dev_info * devip)
2174{
2175 unsigned char *buf;
2176 struct unmap_block_desc *desc;
2177 unsigned int i, payload_len, descriptors;
2178 int ret;
2179
2180 ret = check_readiness(scmd, 1, devip);
2181 if (ret)
2182 return ret;
2183
2184 payload_len = get_unaligned_be16(&scmd->cmnd[7]);
2185 BUG_ON(scsi_bufflen(scmd) != payload_len);
2186
2187 descriptors = (payload_len - 8) / 16;
2188
2189 buf = kmalloc(scsi_bufflen(scmd), GFP_ATOMIC);
2190 if (!buf)
2191 return check_condition_result;
2192
2193 scsi_sg_copy_to_buffer(scmd, buf, scsi_bufflen(scmd));
2194
2195 BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2);
2196 BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16);
2197
2198 desc = (void *)&buf[8];
2199
2200 for (i = 0 ; i < descriptors ; i++) {
2201 unsigned long long lba = get_unaligned_be64(&desc[i].lba);
2202 unsigned int num = get_unaligned_be32(&desc[i].blocks);
2203
2204 ret = check_device_access_params(devip, lba, num);
2205 if (ret)
2206 goto out;
2207
2208 unmap_region(lba, num);
2209 }
2210
2211 ret = 0;
2212
2213out:
2214 kfree(buf);
2215
2216 return ret;
2217}
2218
2219#define SDEBUG_GET_LBA_STATUS_LEN 32
2220
2221static int resp_get_lba_status(struct scsi_cmnd * scmd,
2222 struct sdebug_dev_info * devip)
2223{
2224 unsigned long long lba;
2225 unsigned int alloc_len, mapped, num;
2226 unsigned char arr[SDEBUG_GET_LBA_STATUS_LEN];
2227 int ret;
2228
2229 ret = check_readiness(scmd, 1, devip);
2230 if (ret)
2231 return ret;
2232
2233 lba = get_unaligned_be64(&scmd->cmnd[2]);
2234 alloc_len = get_unaligned_be32(&scmd->cmnd[10]);
2235
2236 if (alloc_len < 24)
2237 return 0;
2238
2239 ret = check_device_access_params(devip, lba, 1);
2240 if (ret)
2241 return ret;
2242
2243 mapped = map_state(lba, &num);
2244
2245 memset(arr, 0, SDEBUG_GET_LBA_STATUS_LEN);
de13e965 2246 put_unaligned_be32(20, &arr[0]); /* Parameter Data Length */
44d92694
MP		 2247 put_unaligned_be64(lba, &arr[8]); /* LBA */
2248 put_unaligned_be32(num, &arr[16]); /* Number of blocks */
2249 arr[20] = !mapped; /* mapped = 0, unmapped = 1 */
2250
2251 return fill_from_dev_buffer(scmd, arr, SDEBUG_GET_LBA_STATUS_LEN);
2252}
2253
c65b1445 2254#define SDEBUG_RLUN_ARR_SZ 256
1da177e4
LT		 2255
2256static int resp_report_luns(struct scsi_cmnd * scp,
2257 struct sdebug_dev_info * devip)
2258{
2259 unsigned int alloc_len;
c65b1445 2260 int lun_cnt, i, upper, num, n, wlun, lun;
1da177e4
LT		 2261 unsigned char *cmd = (unsigned char *)scp->cmnd;
2262 int select_report = (int)cmd[2];
2263 struct scsi_lun *one_lun;
2264 unsigned char arr[SDEBUG_RLUN_ARR_SZ];
c65b1445 2265 unsigned char * max_addr;
1da177e4
LT		 2266
2267 alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
c65b1445 2268 if ((alloc_len < 4) || (select_report > 2)) {
1da177e4
LT		 2269 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
2270 0);
2271 return check_condition_result;
2272 }
2273 /* can produce response with up to 16k luns (lun 0 to lun 16383) */
2274 memset(arr, 0, SDEBUG_RLUN_ARR_SZ);
2275 lun_cnt = scsi_debug_max_luns;
c65b1445
DG		 2276 if (1 == select_report)
2277 lun_cnt = 0;
2278 else if (scsi_debug_no_lun_0 && (lun_cnt > 0))
2279 --lun_cnt;
2280 wlun = (select_report > 0) ? 1 : 0;
2281 num = lun_cnt + wlun;
2282 arr[2] = ((sizeof(struct scsi_lun) * num) >> 8) & 0xff;
2283 arr[3] = (sizeof(struct scsi_lun) * num) & 0xff;
2284 n = min((int)((SDEBUG_RLUN_ARR_SZ - 8) /
2285 sizeof(struct scsi_lun)), num);
2286 if (n < num) {
2287 wlun = 0;
2288 lun_cnt = n;
2289 }
1da177e4 2290 one_lun = (struct scsi_lun *) &arr[8];
c65b1445
DG		 2291 max_addr = arr + SDEBUG_RLUN_ARR_SZ;
2292 for (i = 0, lun = (scsi_debug_no_lun_0 ? 1 : 0);
2293 ((i < lun_cnt) && ((unsigned char *)(one_lun + i) < max_addr));
2294 i++, lun++) {
2295 upper = (lun >> 8) & 0x3f;
1da177e4
LT		 2296 if (upper)
2297 one_lun[i].scsi_lun[0] =
2298 (upper | (SAM2_LUN_ADDRESS_METHOD << 6));
c65b1445
DG		 2299 one_lun[i].scsi_lun[1] = lun & 0xff;
2300 }
2301 if (wlun) {
2302 one_lun[i].scsi_lun[0] = (SAM2_WLUN_REPORT_LUNS >> 8) & 0xff;
2303 one_lun[i].scsi_lun[1] = SAM2_WLUN_REPORT_LUNS & 0xff;
2304 i++;
1da177e4 2305 }
c65b1445 2306 alloc_len = (unsigned char *)(one_lun + i) - arr;
1da177e4
LT		 2307 return fill_from_dev_buffer(scp, arr,
2308 min((int)alloc_len, SDEBUG_RLUN_ARR_SZ));
2309}
2310
c639d14e
FT		 2311static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
2312 unsigned int num, struct sdebug_dev_info *devip)
2313{
2314 int i, j, ret = -1;
2315 unsigned char *kaddr, *buf;
2316 unsigned int offset;
2317 struct scatterlist *sg;
2318 struct scsi_data_buffer *sdb = scsi_in(scp);
2319
2320 /* better not to use temporary buffer. */
2321 buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
c5af0db9
AM		 2322 if (!buf) {
2323 mk_sense_buffer(devip, NOT_READY,
2324 LOGICAL_UNIT_COMMUNICATION_FAILURE, 0);
2325 return check_condition_result;
2326 }
c639d14e 2327
21a61829 2328 scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
c639d14e
FT		 2329
2330 offset = 0;
2331 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, i) {
77dfce07 2332 kaddr = (unsigned char *)kmap_atomic(sg_page(sg));
c639d14e
FT		 2333 if (!kaddr)
2334 goto out;
2335
2336 for (j = 0; j < sg->length; j++)
2337 *(kaddr + sg->offset + j) ^= *(buf + offset + j);
2338
2339 offset += sg->length;
77dfce07 2340 kunmap_atomic(kaddr);
c639d14e
FT		 2341 }
2342 ret = 0;
2343out:
2344 kfree(buf);
2345
2346 return ret;
2347}
2348
1da177e4
LT		 2349/* When timer goes off this function is called. */
2350static void timer_intr_handler(unsigned long indx)
2351{
2352 struct sdebug_queued_cmd * sqcp;
2353 unsigned long iflags;
2354
78d4e5a0 2355 if (indx >= scsi_debug_max_queue) {
1da177e4
LT		 2356 printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too "
2357 "large\n");
2358 return;
2359 }
2360 spin_lock_irqsave(&queued_arr_lock, iflags);
2361 sqcp = &queued_arr[(int)indx];
2362 if (! sqcp->in_use) {
2363 printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected "
2364 "interrupt\n");
2365 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2366 return;
2367 }
2368 sqcp->in_use = 0;
2369 if (sqcp->done_funct) {
2370 sqcp->a_cmnd->result = sqcp->scsi_result;
2371 sqcp->done_funct(sqcp->a_cmnd); /* callback to mid level */
2372 }
2373 sqcp->done_funct = NULL;
2374 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2375}
2376
1da177e4 2377
8dea0d02
FT		 2378static struct sdebug_dev_info *
2379sdebug_device_create(struct sdebug_host_info *sdbg_host, gfp_t flags)
5cb2fc06
FT		 2380{
2381 struct sdebug_dev_info *devip;
2382
2383 devip = kzalloc(sizeof(*devip), flags);
2384 if (devip) {
2385 devip->sdbg_host = sdbg_host;
2386 list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
2387 }
2388 return devip;
2389}
2390
1da177e4
LT		 2391static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
2392{
2393 struct sdebug_host_info * sdbg_host;
2394 struct sdebug_dev_info * open_devip = NULL;
2395 struct sdebug_dev_info * devip =
2396 (struct sdebug_dev_info *)sdev->hostdata;
2397
2398 if (devip)
2399 return devip;
d1e4c9c5
FT		 2400 sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
2401 if (!sdbg_host) {
1da177e4
LT		 2402 printk(KERN_ERR "Host info NULL\n");
2403 return NULL;
2404 }
2405 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
2406 if ((devip->used) && (devip->channel == sdev->channel) &&
2407 (devip->target == sdev->id) &&
2408 (devip->lun == sdev->lun))
2409 return devip;
2410 else {
2411 if ((!devip->used) && (!open_devip))
2412 open_devip = devip;
2413 }
2414 }
5cb2fc06
FT		 2415 if (!open_devip) { /* try and make a new one */
2416 open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC);
2417 if (!open_devip) {
1da177e4 2418 printk(KERN_ERR "%s: out of memory at line %d\n",
cadbd4a5 2419 __func__, __LINE__);
1da177e4
LT		 2420 return NULL;
2421 }
1da177e4 2422 }
a75869d1
FT		 2423
2424 open_devip->channel = sdev->channel;
2425 open_devip->target = sdev->id;
2426 open_devip->lun = sdev->lun;
2427 open_devip->sdbg_host = sdbg_host;
2428 open_devip->reset = 1;
2429 open_devip->used = 1;
2430 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
2431 if (scsi_debug_dsense)
2432 open_devip->sense_buff[0] = 0x72;
2433 else {
2434 open_devip->sense_buff[0] = 0x70;
2435 open_devip->sense_buff[7] = 0xa;
2436 }
2437 if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
2438 open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
2439
2440 return open_devip;
1da177e4
LT		 2441}
2442
8dea0d02 2443static int scsi_debug_slave_alloc(struct scsi_device *sdp)
1da177e4 2444{
8dea0d02
FT		 2445 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2446 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
2447 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
75ad23bc 2448 queue_flag_set_unlocked(QUEUE_FLAG_BIDI, sdp->request_queue);
8dea0d02
FT		 2449 return 0;
2450}
1da177e4 2451
8dea0d02
FT		 2452static int scsi_debug_slave_configure(struct scsi_device *sdp)
2453{
2454 struct sdebug_dev_info *devip;
a34c4e98 2455
8dea0d02
FT		 2456 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2457 printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n",
2458 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2459 if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN)
2460 sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN;
2461 devip = devInfoReg(sdp);
2462 if (NULL == devip)
2463 return 1; /* no resources, will be marked offline */
2464 sdp->hostdata = devip;
2465 if (sdp->host->cmd_per_lun)
2466 scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING,
2467 sdp->host->cmd_per_lun);
2468 blk_queue_max_segment_size(sdp->request_queue, 256 * 1024);
78d4e5a0
DG		 2469 if (scsi_debug_no_uld)
2470 sdp->no_uld_attach = 1;
8dea0d02
FT		 2471 return 0;
2472}
2473
2474static void scsi_debug_slave_destroy(struct scsi_device *sdp)
2475{
2476 struct sdebug_dev_info *devip =
2477 (struct sdebug_dev_info *)sdp->hostdata;
a34c4e98 2478
1da177e4 2479 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
8dea0d02
FT		 2480 printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n",
2481 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2482 if (devip) {
25985edc 2483 /* make this slot available for re-use */
8dea0d02
FT		 2484 devip->used = 0;
2485 sdp->hostdata = NULL;
2486 }
2487}
2488
2489/* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
2490static int stop_queued_cmnd(struct scsi_cmnd *cmnd)
2491{
2492 unsigned long iflags;
2493 int k;
2494 struct sdebug_queued_cmd *sqcp;
2495
2496 spin_lock_irqsave(&queued_arr_lock, iflags);
78d4e5a0 2497 for (k = 0; k < scsi_debug_max_queue; ++k) {
8dea0d02
FT		 2498 sqcp = &queued_arr[k];
2499 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
2500 del_timer_sync(&sqcp->cmnd_timer);
2501 sqcp->in_use = 0;
2502 sqcp->a_cmnd = NULL;
2503 break;
2504 }
2505 }
2506 spin_unlock_irqrestore(&queued_arr_lock, iflags);
78d4e5a0 2507 return (k < scsi_debug_max_queue) ? 1 : 0;
8dea0d02
FT		 2508}
2509
2510/* Deletes (stops) timers of all queued commands */
2511static void stop_all_queued(void)
2512{
2513 unsigned long iflags;
2514 int k;
2515 struct sdebug_queued_cmd *sqcp;
2516
2517 spin_lock_irqsave(&queued_arr_lock, iflags);
78d4e5a0 2518 for (k = 0; k < scsi_debug_max_queue; ++k) {
8dea0d02
FT		 2519 sqcp = &queued_arr[k];
2520 if (sqcp->in_use && sqcp->a_cmnd) {
2521 del_timer_sync(&sqcp->cmnd_timer);
2522 sqcp->in_use = 0;
2523 sqcp->a_cmnd = NULL;
2524 }
2525 }
2526 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1da177e4
LT		 2527}
2528
2529static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
2530{
2531 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2532 printk(KERN_INFO "scsi_debug: abort\n");
2533 ++num_aborts;
2534 stop_queued_cmnd(SCpnt);
2535 return SUCCESS;
2536}
2537
2538static int scsi_debug_biosparam(struct scsi_device *sdev,
2539 struct block_device * bdev, sector_t capacity, int *info)
2540{
2541 int res;
2542 unsigned char *buf;
2543
2544 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2545 printk(KERN_INFO "scsi_debug: biosparam\n");
2546 buf = scsi_bios_ptable(bdev);
2547 if (buf) {
2548 res = scsi_partsize(buf, capacity,
2549 &info[2], &info[0], &info[1]);
2550 kfree(buf);
2551 if (! res)
2552 return res;
2553 }
2554 info[0] = sdebug_heads;
2555 info[1] = sdebug_sectors_per;
2556 info[2] = sdebug_cylinders_per;
2557 return 0;
2558}
2559
2560static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
2561{
2562 struct sdebug_dev_info * devip;
2563
2564 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2565 printk(KERN_INFO "scsi_debug: device_reset\n");
2566 ++num_dev_resets;
2567 if (SCpnt) {
2568 devip = devInfoReg(SCpnt->device);
2569 if (devip)
2570 devip->reset = 1;
2571 }
2572 return SUCCESS;
2573}
2574
2575static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
2576{
2577 struct sdebug_host_info *sdbg_host;
2578 struct sdebug_dev_info * dev_info;
2579 struct scsi_device * sdp;
2580 struct Scsi_Host * hp;
2581
2582 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2583 printk(KERN_INFO "scsi_debug: bus_reset\n");
2584 ++num_bus_resets;
2585 if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
d1e4c9c5 2586 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
1da177e4
LT		 2587 if (sdbg_host) {
2588 list_for_each_entry(dev_info,
2589 &sdbg_host->dev_info_list,
2590 dev_list)
2591 dev_info->reset = 1;
2592 }
2593 }
2594 return SUCCESS;
2595}
2596
2597static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
2598{
2599 struct sdebug_host_info * sdbg_host;
2600 struct sdebug_dev_info * dev_info;
2601
2602 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2603 printk(KERN_INFO "scsi_debug: host_reset\n");
2604 ++num_host_resets;
2605 spin_lock(&sdebug_host_list_lock);
2606 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
2607 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
2608 dev_list)
2609 dev_info->reset = 1;
2610 }
2611 spin_unlock(&sdebug_host_list_lock);
2612 stop_all_queued();
2613 return SUCCESS;
2614}
2615
1da177e4
LT		 2616/* Initializes timers in queued array */
2617static void __init init_all_queued(void)
2618{
2619 unsigned long iflags;
2620 int k;
2621 struct sdebug_queued_cmd * sqcp;
2622
2623 spin_lock_irqsave(&queued_arr_lock, iflags);
78d4e5a0 2624 for (k = 0; k < scsi_debug_max_queue; ++k) {
1da177e4
LT		 2625 sqcp = &queued_arr[k];
2626 init_timer(&sqcp->cmnd_timer);
2627 sqcp->in_use = 0;
2628 sqcp->a_cmnd = NULL;
2629 }
2630 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2631}
2632
f58b0efb 2633static void __init sdebug_build_parts(unsigned char *ramp,
5f2578e5 2634 unsigned long store_size)
1da177e4
LT		 2635{
2636 struct partition * pp;
2637 int starts[SDEBUG_MAX_PARTS + 2];
2638 int sectors_per_part, num_sectors, k;
2639 int heads_by_sects, start_sec, end_sec;
2640
2641 /* assume partition table already zeroed */
f58b0efb 2642 if ((scsi_debug_num_parts < 1) || (store_size < 1048576))
1da177e4
LT		 2643 return;
2644 if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
2645 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
2646 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
2647 "partitions to %d\n", SDEBUG_MAX_PARTS);
2648 }
c65b1445 2649 num_sectors = (int)sdebug_store_sectors;
1da177e4
LT		 2650 sectors_per_part = (num_sectors - sdebug_sectors_per)
2651 / scsi_debug_num_parts;
2652 heads_by_sects = sdebug_heads * sdebug_sectors_per;
2653 starts[0] = sdebug_sectors_per;
2654 for (k = 1; k < scsi_debug_num_parts; ++k)
2655 starts[k] = ((k * sectors_per_part) / heads_by_sects)
2656 * heads_by_sects;
2657 starts[scsi_debug_num_parts] = num_sectors;
2658 starts[scsi_debug_num_parts + 1] = 0;
2659
2660 ramp[510] = 0x55; /* magic partition markings */
2661 ramp[511] = 0xAA;
2662 pp = (struct partition *)(ramp + 0x1be);
2663 for (k = 0; starts[k + 1]; ++k, ++pp) {
2664 start_sec = starts[k];
2665 end_sec = starts[k + 1] - 1;
2666 pp->boot_ind = 0;
2667
2668 pp->cyl = start_sec / heads_by_sects;
2669 pp->head = (start_sec - (pp->cyl * heads_by_sects))
2670 / sdebug_sectors_per;
2671 pp->sector = (start_sec % sdebug_sectors_per) + 1;
2672
2673 pp->end_cyl = end_sec / heads_by_sects;
2674 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
2675 / sdebug_sectors_per;
2676 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2677
150c3544
AM		 2678 pp->start_sect = cpu_to_le32(start_sec);
2679 pp->nr_sects = cpu_to_le32(end_sec - start_sec + 1);
1da177e4
LT		 2680 pp->sys_ind = 0x83; /* plain Linux partition */
2681 }
2682}
2683
2684static int schedule_resp(struct scsi_cmnd * cmnd,
2685 struct sdebug_dev_info * devip,
2686 done_funct_t done, int scsi_result, int delta_jiff)
2687{
2688 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
2689 if (scsi_result) {
2690 struct scsi_device * sdp = cmnd->device;
2691
c65b1445
DG		 2692 printk(KERN_INFO "scsi_debug: <%u %u %u %u> "
2693 "non-zero result=0x%x\n", sdp->host->host_no,
2694 sdp->channel, sdp->id, sdp->lun, scsi_result);
1da177e4
LT		 2695 }
2696 }
2697 if (cmnd && devip) {
2698 /* simulate autosense by this driver */
2699 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
2700 memcpy(cmnd->sense_buffer, devip->sense_buff,
2701 (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
2702 SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
2703 }
2704 if (delta_jiff <= 0) {
2705 if (cmnd)
2706 cmnd->result = scsi_result;
2707 if (done)
2708 done(cmnd);
2709 return 0;
2710 } else {
2711 unsigned long iflags;
2712 int k;
2713 struct sdebug_queued_cmd * sqcp = NULL;
2714
2715 spin_lock_irqsave(&queued_arr_lock, iflags);
78d4e5a0 2716 for (k = 0; k < scsi_debug_max_queue; ++k) {
1da177e4
LT		 2717 sqcp = &queued_arr[k];
2718 if (! sqcp->in_use)
2719 break;
2720 }
78d4e5a0 2721 if (k >= scsi_debug_max_queue) {
1da177e4
LT		 2722 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2723 printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
2724 return 1; /* report busy to mid level */
2725 }
2726 sqcp->in_use = 1;
2727 sqcp->a_cmnd = cmnd;
2728 sqcp->scsi_result = scsi_result;
2729 sqcp->done_funct = done;
2730 sqcp->cmnd_timer.function = timer_intr_handler;
2731 sqcp->cmnd_timer.data = k;
2732 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
2733 add_timer(&sqcp->cmnd_timer);
2734 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2735 if (cmnd)
2736 cmnd->result = 0;
2737 return 0;
2738 }
2739}
23183910
DG		 2740/* Note: The following macros create attribute files in the
2741 /sys/module/scsi_debug/parameters directory. Unfortunately this
2742 driver is unaware of a change and cannot trigger auxiliary actions
2743 as it can when the corresponding attribute in the
2744 /sys/bus/pseudo/drivers/scsi_debug directory is changed.
2745 */
c65b1445 2746module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
5b94e232 2747module_param_named(ato, scsi_debug_ato, int, S_IRUGO);
c65b1445
DG		 2748module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
2749module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
5b94e232
MP		 2750module_param_named(dif, scsi_debug_dif, int, S_IRUGO);
2751module_param_named(dix, scsi_debug_dix, int, S_IRUGO);
c65b1445
DG		 2752module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
2753module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
23183910 2754module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
68aee7ba 2755module_param_named(guard, scsi_debug_guard, uint, S_IRUGO);
5b94e232
MP		 2756module_param_named(lbpu, scsi_debug_lbpu, int, S_IRUGO);
2757module_param_named(lbpws, scsi_debug_lbpws, int, S_IRUGO);
2758module_param_named(lbpws10, scsi_debug_lbpws10, int, S_IRUGO);
be1dd78d 2759module_param_named(lbprz, scsi_debug_lbprz, int, S_IRUGO);
5b94e232 2760module_param_named(lowest_aligned, scsi_debug_lowest_aligned, int, S_IRUGO);
c65b1445 2761module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
78d4e5a0 2762module_param_named(max_queue, scsi_debug_max_queue, int, S_IRUGO | S_IWUSR);
c65b1445 2763module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
78d4e5a0 2764module_param_named(no_uld, scsi_debug_no_uld, int, S_IRUGO);
c65b1445
DG		 2765module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
2766module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
5b94e232 2767module_param_named(opt_blks, scsi_debug_opt_blks, int, S_IRUGO);
c65b1445 2768module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
5b94e232 2769module_param_named(physblk_exp, scsi_debug_physblk_exp, int, S_IRUGO);
c65b1445 2770module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
d986788b 2771module_param_named(removable, scsi_debug_removable, bool, S_IRUGO | S_IWUSR);
c65b1445 2772module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
597136ab 2773module_param_named(sector_size, scsi_debug_sector_size, int, S_IRUGO);
5b94e232
MP		 2774module_param_named(unmap_alignment, scsi_debug_unmap_alignment, int, S_IRUGO);
2775module_param_named(unmap_granularity, scsi_debug_unmap_granularity, int, S_IRUGO);
44d92694
MP		 2776module_param_named(unmap_max_blocks, scsi_debug_unmap_max_blocks, int, S_IRUGO);
2777module_param_named(unmap_max_desc, scsi_debug_unmap_max_desc, int, S_IRUGO);
5b94e232
MP		 2778module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
2779module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
2780 S_IRUGO | S_IWUSR);
2781module_param_named(write_same_length, scsi_debug_write_same_length, int,
2782 S_IRUGO | S_IWUSR);
1da177e4
LT		 2783
2784MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2785MODULE_DESCRIPTION("SCSI debug adapter driver");
2786MODULE_LICENSE("GPL");
2787MODULE_VERSION(SCSI_DEBUG_VERSION);
2788
2789MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
5b94e232 2790MODULE_PARM_DESC(ato, "application tag ownership: 0=disk 1=host (def=1)");
1da177e4 2791MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
c65b1445 2792MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
5b94e232
MP		 2793MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)");
2794MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)");
c65b1445 2795MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
beb87c33 2796MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
23183910 2797MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
5b94e232
MP		 2798MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");
2799MODULE_PARM_DESC(lbpu, "enable LBP, support UNMAP command (def=0)");
2800MODULE_PARM_DESC(lbpws, "enable LBP, support WRITE SAME(16) with UNMAP bit (def=0)");
2801MODULE_PARM_DESC(lbpws10, "enable LBP, support WRITE SAME(10) with UNMAP bit (def=0)");
be1dd78d 2802MODULE_PARM_DESC(lbprz, "unmapped blocks return 0 on read (def=1)");
5b94e232 2803MODULE_PARM_DESC(lowest_aligned, "lowest aligned lba (def=0)");
c65b1445 2804MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
78d4e5a0 2805MODULE_PARM_DESC(max_queue, "max number of queued commands (1 to 255(def))");
c65b1445 2806MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
78d4e5a0 2807MODULE_PARM_DESC(no_uld, "stop ULD (e.g. sd driver) attaching (def=0))");
1da177e4 2808MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
c65b1445 2809MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
5b94e232 2810MODULE_PARM_DESC(opt_blks, "optimal transfer length in block (def=64)");
6f3cbf55 2811MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
5b94e232 2812MODULE_PARM_DESC(physblk_exp, "physical block exponent (def=0)");
1da177e4 2813MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
d986788b 2814MODULE_PARM_DESC(removable, "claim to have removable media (def=0)");
1da177e4 2815MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
ea61fca5 2816MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)");
5b94e232
MP		 2817MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)");
2818MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=1)");
6014759c
MP		 2819MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0xffffffff)");
2820MODULE_PARM_DESC(unmap_max_desc, "max # of ranges that can be unmapped in one cmd (def=256)");
5b94e232
MP		 2821MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
2822MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2823MODULE_PARM_DESC(write_same_length, "Maximum blocks per WRITE SAME cmd (def=0xffff)");
1da177e4
LT		 2824
2825static char sdebug_info[256];
2826
2827static const char * scsi_debug_info(struct Scsi_Host * shp)
2828{
2829 sprintf(sdebug_info, "scsi_debug, version %s [%s], "
2830 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
2831 scsi_debug_version_date, scsi_debug_dev_size_mb,
2832 scsi_debug_opts);
2833 return sdebug_info;
2834}
2835
2836/* scsi_debug_proc_info
2837 * Used if the driver currently has no own support for /proc/scsi
2838 */
c8ed555a 2839static int scsi_debug_write_info(struct Scsi_Host *host, char *buffer, int length)
1da177e4 2840{
c8ed555a
AV		 2841 char arr[16];
2842 int opts;
2843 int minLen = length > 15 ? 15 : length;
1da177e4 2844
c8ed555a
AV		 2845 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2846 return -EACCES;
2847 memcpy(arr, buffer, minLen);
2848 arr[minLen] = '\0';
2849 if (1 != sscanf(arr, "%d", &opts))
2850 return -EINVAL;
2851 scsi_debug_opts = opts;
2852 if (scsi_debug_every_nth != 0)
2853 scsi_debug_cmnd_count = 0;
2854 return length;
2855}
1da177e4 2856
c8ed555a
AV		 2857static int scsi_debug_show_info(struct seq_file *m, struct Scsi_Host *host)
2858{
2859 seq_printf(m, "scsi_debug adapter driver, version "
1da177e4
LT		 2860 "%s [%s]\n"
2861 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2862 "every_nth=%d(curr:%d)\n"
2863 "delay=%d, max_luns=%d, scsi_level=%d\n"
2864 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2865 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
c6a44287 2866 "host_resets=%d\ndix_reads=%d dix_writes=%d dif_errors=%d\n",
1da177e4
LT		 2867 SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
2868 scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2869 scsi_debug_cmnd_count, scsi_debug_delay,
2870 scsi_debug_max_luns, scsi_debug_scsi_level,
597136ab
MP		 2871 scsi_debug_sector_size, sdebug_cylinders_per, sdebug_heads,
2872 sdebug_sectors_per, num_aborts, num_dev_resets, num_bus_resets,
c6a44287 2873 num_host_resets, dix_reads, dix_writes, dif_errors);
c8ed555a 2874 return 0;
1da177e4
LT		 2875}
2876
82069379 2877static ssize_t delay_show(struct device_driver *ddp, char *buf)
1da177e4
LT		 2878{
2879 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
2880}
2881
82069379
AM		 2882static ssize_t delay_store(struct device_driver *ddp, const char *buf,
2883 size_t count)
1da177e4
LT		 2884{
2885 int delay;
2886 char work[20];
2887
2888 if (1 == sscanf(buf, "%10s", work)) {
2889 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
2890 scsi_debug_delay = delay;
2891 return count;
2892 }
2893 }
2894 return -EINVAL;
2895}
82069379 2896static DRIVER_ATTR_RW(delay);
1da177e4 2897
82069379 2898static ssize_t opts_show(struct device_driver *ddp, char *buf)
1da177e4
LT		 2899{
2900 return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
2901}
2902
82069379
AM		 2903static ssize_t opts_store(struct device_driver *ddp, const char *buf,
2904 size_t count)
1da177e4
LT		 2905{
2906 int opts;
2907 char work[20];
2908
2909 if (1 == sscanf(buf, "%10s", work)) {
2910 if (0 == strnicmp(work,"0x", 2)) {
2911 if (1 == sscanf(&work[2], "%x", &opts))
2912 goto opts_done;
2913 } else {
2914 if (1 == sscanf(work, "%d", &opts))
2915 goto opts_done;
2916 }
2917 }
2918 return -EINVAL;
2919opts_done:
2920 scsi_debug_opts = opts;
2921 scsi_debug_cmnd_count = 0;
2922 return count;
2923}
82069379 2924static DRIVER_ATTR_RW(opts);
1da177e4 2925
82069379 2926static ssize_t ptype_show(struct device_driver *ddp, char *buf)
1da177e4
LT		 2927{
2928 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
2929}
82069379
AM		 2930static ssize_t ptype_store(struct device_driver *ddp, const char *buf,
2931 size_t count)
1da177e4
LT		 2932{
2933 int n;
2934
2935 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2936 scsi_debug_ptype = n;
2937 return count;
2938 }
2939 return -EINVAL;
2940}
82069379 2941static DRIVER_ATTR_RW(ptype);
1da177e4 2942
82069379 2943static ssize_t dsense_show(struct device_driver *ddp, char *buf)
1da177e4
LT		 2944{
2945 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
2946}
82069379
AM		 2947static ssize_t dsense_store(struct device_driver *ddp, const char *buf,
2948 size_t count)
1da177e4
LT		 2949{
2950 int n;
2951
2952 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2953 scsi_debug_dsense = n;
2954 return count;
2955 }
2956 return -EINVAL;
2957}
82069379 2958static DRIVER_ATTR_RW(dsense);
1da177e4 2959
82069379 2960static ssize_t fake_rw_show(struct device_driver *ddp, char *buf)
23183910
DG		 2961{
2962 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
2963}
82069379
AM		 2964static ssize_t fake_rw_store(struct device_driver *ddp, const char *buf,
2965 size_t count)
23183910
DG		 2966{
2967 int n;
2968
2969 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2970 scsi_debug_fake_rw = n;
2971 return count;
2972 }
2973 return -EINVAL;
2974}
82069379 2975static DRIVER_ATTR_RW(fake_rw);
23183910 2976
82069379 2977static ssize_t no_lun_0_show(struct device_driver *ddp, char *buf)
c65b1445
DG		 2978{
2979 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
2980}
82069379
AM		 2981static ssize_t no_lun_0_store(struct device_driver *ddp, const char *buf,
2982 size_t count)
c65b1445
DG		 2983{
2984 int n;
2985
2986 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2987 scsi_debug_no_lun_0 = n;
2988 return count;
2989 }
2990 return -EINVAL;
2991}
82069379 2992static DRIVER_ATTR_RW(no_lun_0);
c65b1445 2993
82069379 2994static ssize_t num_tgts_show(struct device_driver *ddp, char *buf)
1da177e4
LT		 2995{
2996 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
2997}
82069379
AM		 2998static ssize_t num_tgts_store(struct device_driver *ddp, const char *buf,
2999 size_t count)
1da177e4
LT		 3000{
3001 int n;
3002
3003 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
3004 scsi_debug_num_tgts = n;
3005 sdebug_max_tgts_luns();
3006 return count;
3007 }
3008 return -EINVAL;
3009}
82069379 3010static DRIVER_ATTR_RW(num_tgts);
1da177e4 3011
82069379 3012static ssize_t dev_size_mb_show(struct device_driver *ddp, char *buf)
1da177e4
LT		 3013{
3014 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
3015}
82069379 3016static DRIVER_ATTR_RO(dev_size_mb);
1da177e4 3017
82069379 3018static ssize_t num_parts_show(struct device_driver *ddp, char *buf)
1da177e4
LT		 3019{
3020 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
3021}
82069379 3022static DRIVER_ATTR_RO(num_parts);
1da177e4 3023
82069379 3024static ssize_t every_nth_show(struct device_driver *ddp, char *buf)
1da177e4
LT		 3025{
3026 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
3027}
82069379
AM		 3028static ssize_t every_nth_store(struct device_driver *ddp, const char *buf,
3029 size_t count)
1da177e4
LT		 3030{
3031 int nth;
3032
3033 if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
3034 scsi_debug_every_nth = nth;
3035 scsi_debug_cmnd_count = 0;
3036 return count;
3037 }
3038 return -EINVAL;
3039}
82069379 3040static DRIVER_ATTR_RW(every_nth);
1da177e4 3041
82069379 3042static ssize_t max_luns_show(struct device_driver *ddp, char *buf)
1da177e4
LT		 3043{
3044 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
3045}
82069379
AM		 3046static ssize_t max_luns_store(struct device_driver *ddp, const char *buf,
3047 size_t count)
1da177e4
LT		 3048{
3049 int n;
3050
3051 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
3052 scsi_debug_max_luns = n;
3053 sdebug_max_tgts_luns();
3054 return count;
3055 }
3056 return -EINVAL;
3057}
82069379 3058static DRIVER_ATTR_RW(max_luns);
1da177e4 3059
82069379 3060static ssize_t max_queue_show(struct device_driver *ddp, char *buf)
78d4e5a0
DG		 3061{
3062 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_queue);
3063}
82069379
AM		 3064static ssize_t max_queue_store(struct device_driver *ddp, const char *buf,
3065 size_t count)
78d4e5a0
DG		 3066{
3067 int n;
3068
3069 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n > 0) &&
3070 (n <= SCSI_DEBUG_CANQUEUE)) {
3071 scsi_debug_max_queue = n;
3072 return count;
3073 }
3074 return -EINVAL;
3075}
82069379 3076static DRIVER_ATTR_RW(max_queue);
78d4e5a0 3077
82069379 3078static ssize_t no_uld_show(struct device_driver *ddp, char *buf)
78d4e5a0
DG		 3079{
3080 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_uld);
3081}
82069379 3082static DRIVER_ATTR_RO(no_uld);
78d4e5a0 3083
82069379 3084static ssize_t scsi_level_show(struct device_driver *ddp, char *buf)
1da177e4
LT		 3085{
3086 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
3087}
82069379 3088static DRIVER_ATTR_RO(scsi_level);
1da177e4 3089
82069379 3090static ssize_t virtual_gb_show(struct device_driver *ddp, char *buf)
c65b1445
DG		 3091{
3092 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
3093}
82069379
AM		 3094static ssize_t virtual_gb_store(struct device_driver *ddp, const char *buf,
3095 size_t count)
c65b1445
DG		 3096{
3097 int n;
3098
3099 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
3100 scsi_debug_virtual_gb = n;
28898873
FT		 3101
3102 sdebug_capacity = get_sdebug_capacity();
3103
c65b1445
DG		 3104 return count;
3105 }
3106 return -EINVAL;
3107}
82069379 3108static DRIVER_ATTR_RW(virtual_gb);
c65b1445 3109
82069379 3110static ssize_t add_host_show(struct device_driver *ddp, char *buf)
1da177e4
LT		 3111{
3112 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
3113}
3114
82069379
AM		 3115static ssize_t add_host_store(struct device_driver *ddp, const char *buf,
3116 size_t count)
1da177e4 3117{
f3df41cf 3118 int delta_hosts;
1da177e4 3119
f3df41cf 3120 if (sscanf(buf, "%d", &delta_hosts) != 1)
1da177e4 3121 return -EINVAL;
1da177e4
LT		 3122 if (delta_hosts > 0) {
3123 do {
3124 sdebug_add_adapter();
3125 } while (--delta_hosts);
3126 } else if (delta_hosts < 0) {
3127 do {
3128 sdebug_remove_adapter();
3129 } while (++delta_hosts);
3130 }
3131 return count;
3132}
82069379 3133static DRIVER_ATTR_RW(add_host);
1da177e4 3134
82069379 3135static ssize_t vpd_use_hostno_show(struct device_driver *ddp, char *buf)
23183910
DG		 3136{
3137 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
3138}
82069379
AM		 3139static ssize_t vpd_use_hostno_store(struct device_driver *ddp, const char *buf,
3140 size_t count)
23183910
DG		 3141{
3142 int n;
3143
3144 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
3145 scsi_debug_vpd_use_hostno = n;
3146 return count;
3147 }
3148 return -EINVAL;
3149}
82069379 3150static DRIVER_ATTR_RW(vpd_use_hostno);
23183910 3151
82069379 3152static ssize_t sector_size_show(struct device_driver *ddp, char *buf)
597136ab
MP		 3153{
3154 return scnprintf(buf, PAGE_SIZE, "%u\n", scsi_debug_sector_size);
3155}
82069379 3156static DRIVER_ATTR_RO(sector_size);
597136ab 3157
82069379 3158static ssize_t dix_show(struct device_driver *ddp, char *buf)
c6a44287
MP		 3159{
3160 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dix);
3161}
82069379 3162static DRIVER_ATTR_RO(dix);
c6a44287 3163
82069379 3164static ssize_t dif_show(struct device_driver *ddp, char *buf)
c6a44287
MP		 3165{
3166 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dif);
3167}
82069379 3168static DRIVER_ATTR_RO(dif);
c6a44287 3169
82069379 3170static ssize_t guard_show(struct device_driver *ddp, char *buf)
c6a44287 3171{
68aee7ba 3172 return scnprintf(buf, PAGE_SIZE, "%u\n", scsi_debug_guard);
c6a44287 3173}
82069379 3174static DRIVER_ATTR_RO(guard);
c6a44287 3175
82069379 3176static ssize_t ato_show(struct device_driver *ddp, char *buf)
c6a44287
MP		 3177{
3178 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ato);
3179}
82069379 3180static DRIVER_ATTR_RO(ato);
c6a44287 3181
82069379 3182static ssize_t map_show(struct device_driver *ddp, char *buf)
44d92694
MP		 3183{
3184 ssize_t count;
3185
5b94e232 3186 if (!scsi_debug_lbp())
44d92694
MP		 3187 return scnprintf(buf, PAGE_SIZE, "0-%u\n",
3188 sdebug_store_sectors);
3189
3190 count = bitmap_scnlistprintf(buf, PAGE_SIZE, map_storep, map_size);
3191
3192 buf[count++] = '\n';
3193 buf[count++] = 0;
3194
3195 return count;
3196}
82069379 3197static DRIVER_ATTR_RO(map);
44d92694 3198
82069379 3199static ssize_t removable_show(struct device_driver *ddp, char *buf)
d986788b
MP		 3200{
3201 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_removable ? 1 : 0);
3202}
82069379
AM		 3203static ssize_t removable_store(struct device_driver *ddp, const char *buf,
3204 size_t count)
d986788b
MP		 3205{
3206 int n;
3207
3208 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
3209 scsi_debug_removable = (n > 0);
3210 return count;
3211 }
3212 return -EINVAL;
3213}
82069379 3214static DRIVER_ATTR_RW(removable);
d986788b 3215
82069379 3216/* Note: The following array creates attribute files in the
23183910
DG		 3217 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
3218 files (over those found in the /sys/module/scsi_debug/parameters
3219 directory) is that auxiliary actions can be triggered when an attribute
3220 is changed. For example see: sdebug_add_host_store() above.
3221 */
6ecaff7f 3222
82069379
AM		 3223static struct attribute *sdebug_drv_attrs[] = {
3224 &driver_attr_delay.attr,
3225 &driver_attr_opts.attr,
3226 &driver_attr_ptype.attr,
3227 &driver_attr_dsense.attr,
3228 &driver_attr_fake_rw.attr,
3229 &driver_attr_no_lun_0.attr,
3230 &driver_attr_num_tgts.attr,
3231 &driver_attr_dev_size_mb.attr,
3232 &driver_attr_num_parts.attr,
3233 &driver_attr_every_nth.attr,
3234 &driver_attr_max_luns.attr,
3235 &driver_attr_max_queue.attr,
3236 &driver_attr_no_uld.attr,
3237 &driver_attr_scsi_level.attr,
3238 &driver_attr_virtual_gb.attr,
3239 &driver_attr_add_host.attr,
3240 &driver_attr_vpd_use_hostno.attr,
3241 &driver_attr_sector_size.attr,
3242 &driver_attr_dix.attr,
3243 &driver_attr_dif.attr,
3244 &driver_attr_guard.attr,
3245 &driver_attr_ato.attr,
3246 &driver_attr_map.attr,
3247 &driver_attr_removable.attr,
3248 NULL,
3249};
3250ATTRIBUTE_GROUPS(sdebug_drv);
1da177e4 3251
11ddceca 3252static struct device *pseudo_primary;
8dea0d02 3253
1da177e4
LT		 3254static int __init scsi_debug_init(void)
3255{
5f2578e5 3256 unsigned long sz;
1da177e4
LT		 3257 int host_to_add;
3258 int k;
6ecaff7f 3259 int ret;
1da177e4 3260
597136ab
MP		 3261 switch (scsi_debug_sector_size) {
3262 case 512:
3263 case 1024:
3264 case 2048:
3265 case 4096:
3266 break;
3267 default:
c6a44287 3268 printk(KERN_ERR "scsi_debug_init: invalid sector_size %d\n",
597136ab
MP		 3269 scsi_debug_sector_size);
3270 return -EINVAL;
3271 }
3272
c6a44287
MP		 3273 switch (scsi_debug_dif) {
3274
3275 case SD_DIF_TYPE0_PROTECTION:
3276 case SD_DIF_TYPE1_PROTECTION:
395cef03 3277 case SD_DIF_TYPE2_PROTECTION:
c6a44287
MP		 3278 case SD_DIF_TYPE3_PROTECTION:
3279 break;
3280
3281 default:
395cef03 3282 printk(KERN_ERR "scsi_debug_init: dif must be 0, 1, 2 or 3\n");
c6a44287
MP		 3283 return -EINVAL;
3284 }
3285
3286 if (scsi_debug_guard > 1) {
3287 printk(KERN_ERR "scsi_debug_init: guard must be 0 or 1\n");
3288 return -EINVAL;
3289 }
3290
3291 if (scsi_debug_ato > 1) {
3292 printk(KERN_ERR "scsi_debug_init: ato must be 0 or 1\n");
3293 return -EINVAL;
3294 }
3295
ea61fca5
MP		 3296 if (scsi_debug_physblk_exp > 15) {
3297 printk(KERN_ERR "scsi_debug_init: invalid physblk_exp %u\n",
3298 scsi_debug_physblk_exp);
3299 return -EINVAL;
3300 }
3301
3302 if (scsi_debug_lowest_aligned > 0x3fff) {
3303 printk(KERN_ERR "scsi_debug_init: lowest_aligned too big: %u\n",
3304 scsi_debug_lowest_aligned);
3305 return -EINVAL;
3306 }
3307
1da177e4
LT		 3308 if (scsi_debug_dev_size_mb < 1)
3309 scsi_debug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */
5f2578e5 3310 sz = (unsigned long)scsi_debug_dev_size_mb * 1048576;
597136ab 3311 sdebug_store_sectors = sz / scsi_debug_sector_size;
28898873 3312 sdebug_capacity = get_sdebug_capacity();
1da177e4
LT		 3313
3314 /* play around with geometry, don't waste too much on track 0 */
3315 sdebug_heads = 8;
3316 sdebug_sectors_per = 32;
3317 if (scsi_debug_dev_size_mb >= 16)
3318 sdebug_heads = 32;
3319 else if (scsi_debug_dev_size_mb >= 256)
3320 sdebug_heads = 64;
3321 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
3322 (sdebug_sectors_per * sdebug_heads);
3323 if (sdebug_cylinders_per >= 1024) {
3324 /* other LLDs do this; implies >= 1GB ram disk ... */
3325 sdebug_heads = 255;
3326 sdebug_sectors_per = 63;
3327 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
3328 (sdebug_sectors_per * sdebug_heads);
3329 }
3330
1da177e4
LT		 3331 fake_storep = vmalloc(sz);
3332 if (NULL == fake_storep) {
3333 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
3334 return -ENOMEM;
3335 }
3336 memset(fake_storep, 0, sz);
3337 if (scsi_debug_num_parts > 0)
f58b0efb 3338 sdebug_build_parts(fake_storep, sz);
1da177e4 3339
7cb69d03 3340 if (scsi_debug_dix) {
c6a44287
MP		 3341 int dif_size;
3342
3343 dif_size = sdebug_store_sectors * sizeof(struct sd_dif_tuple);
3344 dif_storep = vmalloc(dif_size);
3345
3346 printk(KERN_ERR "scsi_debug_init: dif_storep %u bytes @ %p\n",
3347 dif_size, dif_storep);
3348
3349 if (dif_storep == NULL) {
3350 printk(KERN_ERR "scsi_debug_init: out of mem. (DIX)\n");
3351 ret = -ENOMEM;
3352 goto free_vm;
3353 }
3354
3355 memset(dif_storep, 0xff, dif_size);
3356 }
3357
5b94e232
MP		 3358 /* Logical Block Provisioning */
3359 if (scsi_debug_lbp()) {
6014759c
MP		 3360 scsi_debug_unmap_max_blocks =
3361 clamp(scsi_debug_unmap_max_blocks, 0U, 0xffffffffU);
3362
3363 scsi_debug_unmap_max_desc =
3364 clamp(scsi_debug_unmap_max_desc, 0U, 256U);
3365
3366 scsi_debug_unmap_granularity =
3367 clamp(scsi_debug_unmap_granularity, 1U, 0xffffffffU);
3368
3369 if (scsi_debug_unmap_alignment &&
ac17078a
AM		 3370 scsi_debug_unmap_granularity <=
3371 scsi_debug_unmap_alignment) {
44d92694 3372 printk(KERN_ERR
ac17078a 3373 "%s: ERR: unmap_granularity <= unmap_alignment\n",
44d92694
MP		 3374 __func__);
3375 return -EINVAL;
3376 }
3377
b90ebc3d
AM		 3378 map_size = lba_to_map_index(sdebug_store_sectors - 1) + 1;
3379 map_storep = vmalloc(BITS_TO_LONGS(map_size) * sizeof(long));
44d92694
MP		 3380
3381 printk(KERN_INFO "scsi_debug_init: %lu provisioning blocks\n",
3382 map_size);
3383
3384 if (map_storep == NULL) {
3385 printk(KERN_ERR "scsi_debug_init: out of mem. (MAP)\n");
3386 ret = -ENOMEM;
3387 goto free_vm;
3388 }
3389
b90ebc3d 3390 bitmap_zero(map_storep, map_size);
44d92694
MP		 3391
3392 /* Map first 1KB for partition table */
3393 if (scsi_debug_num_parts)
3394 map_region(0, 2);
3395 }
3396
9b906779
NB		 3397 pseudo_primary = root_device_register("pseudo_0");
3398 if (IS_ERR(pseudo_primary)) {
3399 printk(KERN_WARNING "scsi_debug: root_device_register() error\n");
3400 ret = PTR_ERR(pseudo_primary);
6ecaff7f
RD		 3401 goto free_vm;
3402 }
3403 ret = bus_register(&pseudo_lld_bus);
3404 if (ret < 0) {
3405 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
3406 ret);
3407 goto dev_unreg;
3408 }
3409 ret = driver_register(&sdebug_driverfs_driver);
3410 if (ret < 0) {
3411 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
3412 ret);
3413 goto bus_unreg;
3414 }
1da177e4 3415
6ecaff7f 3416 init_all_queued();
1da177e4 3417
1da177e4
LT		 3418 host_to_add = scsi_debug_add_host;
3419 scsi_debug_add_host = 0;
3420
3421 for (k = 0; k < host_to_add; k++) {
3422 if (sdebug_add_adapter()) {
3423 printk(KERN_ERR "scsi_debug_init: "
3424 "sdebug_add_adapter failed k=%d\n", k);
3425 break;
3426 }
3427 }
3428
3429 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
3430 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
3431 scsi_debug_add_host);
3432 }
3433 return 0;
6ecaff7f 3434
6ecaff7f
RD		 3435bus_unreg:
3436 bus_unregister(&pseudo_lld_bus);
3437dev_unreg:
9b906779 3438 root_device_unregister(pseudo_primary);
6ecaff7f 3439free_vm:
44d92694
MP		 3440 if (map_storep)
3441 vfree(map_storep);
c6a44287
MP		 3442 if (dif_storep)
3443 vfree(dif_storep);
6ecaff7f
RD		 3444 vfree(fake_storep);
3445
3446 return ret;
1da177e4
LT		 3447}
3448
3449static void __exit scsi_debug_exit(void)
3450{
3451 int k = scsi_debug_add_host;
3452
3453 stop_all_queued();
3454 for (; k; k--)
3455 sdebug_remove_adapter();
1da177e4
LT		 3456 driver_unregister(&sdebug_driverfs_driver);
3457 bus_unregister(&pseudo_lld_bus);
9b906779 3458 root_device_unregister(pseudo_primary);
1da177e4 3459
c6a44287
MP		 3460 if (dif_storep)
3461 vfree(dif_storep);
3462
1da177e4
LT		 3463 vfree(fake_storep);
3464}
3465
3466device_initcall(scsi_debug_init);
3467module_exit(scsi_debug_exit);
3468
1da177e4
LT		 3469static void sdebug_release_adapter(struct device * dev)
3470{
3471 struct sdebug_host_info *sdbg_host;
3472
3473 sdbg_host = to_sdebug_host(dev);
3474 kfree(sdbg_host);
3475}
3476
3477static int sdebug_add_adapter(void)
3478{
3479 int k, devs_per_host;
3480 int error = 0;
3481 struct sdebug_host_info *sdbg_host;
8b40228f 3482 struct sdebug_dev_info *sdbg_devinfo, *tmp;
1da177e4 3483
c65b1445 3484 sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
1da177e4
LT		 3485 if (NULL == sdbg_host) {
3486 printk(KERN_ERR "%s: out of memory at line %d\n",
cadbd4a5 3487 __func__, __LINE__);
1da177e4
LT		 3488 return -ENOMEM;
3489 }
3490
1da177e4
LT		 3491 INIT_LIST_HEAD(&sdbg_host->dev_info_list);
3492
3493 devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
3494 for (k = 0; k < devs_per_host; k++) {
5cb2fc06
FT		 3495 sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL);
3496 if (!sdbg_devinfo) {
1da177e4 3497 printk(KERN_ERR "%s: out of memory at line %d\n",
cadbd4a5 3498 __func__, __LINE__);
1da177e4
LT		 3499 error = -ENOMEM;
3500 goto clean;
3501 }
1da177e4
LT		 3502 }
3503
3504 spin_lock(&sdebug_host_list_lock);
3505 list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
3506 spin_unlock(&sdebug_host_list_lock);
3507
3508 sdbg_host->dev.bus = &pseudo_lld_bus;
9b906779 3509 sdbg_host->dev.parent = pseudo_primary;
1da177e4 3510 sdbg_host->dev.release = &sdebug_release_adapter;
71610f55 3511 dev_set_name(&sdbg_host->dev, "adapter%d", scsi_debug_add_host);
1da177e4
LT		 3512
3513 error = device_register(&sdbg_host->dev);
3514
3515 if (error)
3516 goto clean;
3517
3518 ++scsi_debug_add_host;
3519 return error;
3520
3521clean:
8b40228f
FT		 3522 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
3523 dev_list) {
1da177e4
LT		 3524 list_del(&sdbg_devinfo->dev_list);
3525 kfree(sdbg_devinfo);
3526 }
3527
3528 kfree(sdbg_host);
3529 return error;
3530}
3531
3532static void sdebug_remove_adapter(void)
3533{
3534 struct sdebug_host_info * sdbg_host = NULL;
3535
3536 spin_lock(&sdebug_host_list_lock);
3537 if (!list_empty(&sdebug_host_list)) {
3538 sdbg_host = list_entry(sdebug_host_list.prev,
3539 struct sdebug_host_info, host_list);
3540 list_del(&sdbg_host->host_list);
3541 }
3542 spin_unlock(&sdebug_host_list_lock);
3543
3544 if (!sdbg_host)
3545 return;
3546
3547 device_unregister(&sdbg_host->dev);
3548 --scsi_debug_add_host;
3549}
3550
639db475 3551static
f281233d 3552int scsi_debug_queuecommand_lck(struct scsi_cmnd *SCpnt, done_funct_t done)
639db475
FT		 3553{
3554 unsigned char *cmd = (unsigned char *) SCpnt->cmnd;
3555 int len, k;
3556 unsigned int num;
3557 unsigned long long lba;
395cef03 3558 u32 ei_lba;
639db475
FT		 3559 int errsts = 0;
3560 int target = SCpnt->device->id;
3561 struct sdebug_dev_info *devip = NULL;
3562 int inj_recovered = 0;
3563 int inj_transport = 0;
c6a44287
MP		 3564 int inj_dif = 0;
3565 int inj_dix = 0;
639db475 3566 int delay_override = 0;
44d92694 3567 int unmap = 0;
639db475
FT		 3568
3569 scsi_set_resid(SCpnt, 0);
3570 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) {
3571 printk(KERN_INFO "scsi_debug: cmd ");
3572 for (k = 0, len = SCpnt->cmd_len; k < len; ++k)
3573 printk("%02x ", (int)cmd[k]);
3574 printk("\n");
3575 }
3576
3577 if (target == SCpnt->device->host->hostt->this_id) {
3578 printk(KERN_INFO "scsi_debug: initiator's id used as "
3579 "target!\n");
3580 return schedule_resp(SCpnt, NULL, done,
3581 DID_NO_CONNECT << 16, 0);
3582 }
3583
3584 if ((SCpnt->device->lun >= scsi_debug_max_luns) &&
3585 (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS))
3586 return schedule_resp(SCpnt, NULL, done,
3587 DID_NO_CONNECT << 16, 0);
3588 devip = devInfoReg(SCpnt->device);
3589 if (NULL == devip)
3590 return schedule_resp(SCpnt, NULL, done,
3591 DID_NO_CONNECT << 16, 0);
3592
3593 if ((scsi_debug_every_nth != 0) &&
3594 (++scsi_debug_cmnd_count >= abs(scsi_debug_every_nth))) {
3595 scsi_debug_cmnd_count = 0;
3596 if (scsi_debug_every_nth < -1)
3597 scsi_debug_every_nth = -1;
3598 if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
3599 return 0; /* ignore command causing timeout */
18a4d0a2
MP		 3600 else if (SCSI_DEBUG_OPT_MAC_TIMEOUT & scsi_debug_opts &&
3601 scsi_medium_access_command(SCpnt))
3602 return 0; /* time out reads and writes */
639db475
FT		 3603 else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
3604 inj_recovered = 1; /* to reads and writes below */
3605 else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts)
3606 inj_transport = 1; /* to reads and writes below */
c6a44287
MP		 3607 else if (SCSI_DEBUG_OPT_DIF_ERR & scsi_debug_opts)
3608 inj_dif = 1; /* to reads and writes below */
3609 else if (SCSI_DEBUG_OPT_DIX_ERR & scsi_debug_opts)
3610 inj_dix = 1; /* to reads and writes below */
639db475
FT		 3611 }
3612
3613 if (devip->wlun) {
3614 switch (*cmd) {
3615 case INQUIRY:
3616 case REQUEST_SENSE:
3617 case TEST_UNIT_READY:
3618 case REPORT_LUNS:
3619 break; /* only allowable wlun commands */
3620 default:
3621 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
3622 printk(KERN_INFO "scsi_debug: Opcode: 0x%x "
3623 "not supported for wlun\n", *cmd);
3624 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3625 INVALID_OPCODE, 0);
3626 errsts = check_condition_result;
3627 return schedule_resp(SCpnt, devip, done, errsts,
3628 0);
3629 }
3630 }
3631
3632 switch (*cmd) {
3633 case INQUIRY: /* mandatory, ignore unit attention */
3634 delay_override = 1;
3635 errsts = resp_inquiry(SCpnt, target, devip);
3636 break;
3637 case REQUEST_SENSE: /* mandatory, ignore unit attention */
3638 delay_override = 1;
3639 errsts = resp_requests(SCpnt, devip);
3640 break;
3641 case REZERO_UNIT: /* actually this is REWIND for SSC */
3642 case START_STOP:
3643 errsts = resp_start_stop(SCpnt, devip);
3644 break;
3645 case ALLOW_MEDIUM_REMOVAL:
3646 errsts = check_readiness(SCpnt, 1, devip);
3647 if (errsts)
3648 break;
3649 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
3650 printk(KERN_INFO "scsi_debug: Medium removal %s\n",
3651 cmd[4] ? "inhibited" : "enabled");
3652 break;
3653 case SEND_DIAGNOSTIC: /* mandatory */
3654 errsts = check_readiness(SCpnt, 1, devip);
3655 break;
3656 case TEST_UNIT_READY: /* mandatory */
3657 delay_override = 1;
3658 errsts = check_readiness(SCpnt, 0, devip);
3659 break;
3660 case RESERVE:
3661 errsts = check_readiness(SCpnt, 1, devip);
3662 break;
3663 case RESERVE_10:
3664 errsts = check_readiness(SCpnt, 1, devip);
3665 break;
3666 case RELEASE:
3667 errsts = check_readiness(SCpnt, 1, devip);
3668 break;
3669 case RELEASE_10:
3670 errsts = check_readiness(SCpnt, 1, devip);
3671 break;
3672 case READ_CAPACITY:
3673 errsts = resp_readcap(SCpnt, devip);
3674 break;
3675 case SERVICE_ACTION_IN:
44d92694
MP		 3676 if (cmd[1] == SAI_READ_CAPACITY_16)
3677 errsts = resp_readcap16(SCpnt, devip);
3678 else if (cmd[1] == SAI_GET_LBA_STATUS) {
3679
5b94e232 3680 if (scsi_debug_lbp() == 0) {
44d92694
MP		 3681 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3682 INVALID_COMMAND_OPCODE, 0);
3683 errsts = check_condition_result;
3684 } else
3685 errsts = resp_get_lba_status(SCpnt, devip);
3686 } else {
639db475
FT		 3687 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3688 INVALID_OPCODE, 0);
3689 errsts = check_condition_result;
639db475 3690 }
639db475
FT		 3691 break;
3692 case MAINTENANCE_IN:
3693 if (MI_REPORT_TARGET_PGS != cmd[1]) {
3694 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3695 INVALID_OPCODE, 0);
3696 errsts = check_condition_result;
3697 break;
3698 }
3699 errsts = resp_report_tgtpgs(SCpnt, devip);
3700 break;
3701 case READ_16:
3702 case READ_12:
3703 case READ_10:
395cef03
MP		 3704 /* READ{10,12,16} and DIF Type 2 are natural enemies */
3705 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
3706 cmd[1] & 0xe0) {
3707 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3708 INVALID_COMMAND_OPCODE, 0);
3709 errsts = check_condition_result;
3710 break;
3711 }
3712
3713 if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
3714 scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
3715 (cmd[1] & 0xe0) == 0)
3716 printk(KERN_ERR "Unprotected RD/WR to DIF device\n");
3717
3718 /* fall through */
639db475 3719 case READ_6:
395cef03 3720read:
639db475
FT		 3721 errsts = check_readiness(SCpnt, 0, devip);
3722 if (errsts)
3723 break;
3724 if (scsi_debug_fake_rw)
3725 break;
395cef03
MP		 3726 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3727 errsts = resp_read(SCpnt, lba, num, devip, ei_lba);
639db475
FT		 3728 if (inj_recovered && (0 == errsts)) {
3729 mk_sense_buffer(devip, RECOVERED_ERROR,
3730 THRESHOLD_EXCEEDED, 0);
3731 errsts = check_condition_result;
3732 } else if (inj_transport && (0 == errsts)) {
3733 mk_sense_buffer(devip, ABORTED_COMMAND,
3734 TRANSPORT_PROBLEM, ACK_NAK_TO);
3735 errsts = check_condition_result;
c6a44287
MP		 3736 } else if (inj_dif && (0 == errsts)) {
3737 mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, 1);
3738 errsts = illegal_condition_result;
3739 } else if (inj_dix && (0 == errsts)) {
3740 mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, 1);
3741 errsts = illegal_condition_result;
639db475
FT		 3742 }
3743 break;
3744 case REPORT_LUNS: /* mandatory, ignore unit attention */
3745 delay_override = 1;
3746 errsts = resp_report_luns(SCpnt, devip);
3747 break;
3748 case VERIFY: /* 10 byte SBC-2 command */
3749 errsts = check_readiness(SCpnt, 0, devip);
3750 break;
3751 case WRITE_16:
3752 case WRITE_12:
3753 case WRITE_10:
395cef03
MP		 3754 /* WRITE{10,12,16} and DIF Type 2 are natural enemies */
3755 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
3756 cmd[1] & 0xe0) {
3757 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3758 INVALID_COMMAND_OPCODE, 0);
3759 errsts = check_condition_result;
3760 break;
3761 }
3762
3763 if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
3764 scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
3765 (cmd[1] & 0xe0) == 0)
3766 printk(KERN_ERR "Unprotected RD/WR to DIF device\n");
3767
3768 /* fall through */
639db475 3769 case WRITE_6:
395cef03 3770write:
639db475
FT		 3771 errsts = check_readiness(SCpnt, 0, devip);
3772 if (errsts)
3773 break;
3774 if (scsi_debug_fake_rw)
3775 break;
395cef03
MP		 3776 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3777 errsts = resp_write(SCpnt, lba, num, devip, ei_lba);
639db475
FT		 3778 if (inj_recovered && (0 == errsts)) {
3779 mk_sense_buffer(devip, RECOVERED_ERROR,
3780 THRESHOLD_EXCEEDED, 0);
3781 errsts = check_condition_result;
c6a44287
MP		 3782 } else if (inj_dif && (0 == errsts)) {
3783 mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, 1);
3784 errsts = illegal_condition_result;
3785 } else if (inj_dix && (0 == errsts)) {
3786 mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, 1);
3787 errsts = illegal_condition_result;
639db475
FT		 3788 }
3789 break;
44d92694 3790 case WRITE_SAME_16:
5b94e232 3791 case WRITE_SAME:
6014759c 3792 if (cmd[1] & 0x8) {
5b94e232
MP		 3793 if ((*cmd == WRITE_SAME_16 && scsi_debug_lbpws == 0) ||
3794 (*cmd == WRITE_SAME && scsi_debug_lbpws10 == 0)) {
6014759c
MP		 3795 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3796 INVALID_FIELD_IN_CDB, 0);
3797 errsts = check_condition_result;
3798 } else
3799 unmap = 1;
3800 }
3801 if (errsts)
3802 break;
44d92694
MP		 3803 errsts = check_readiness(SCpnt, 0, devip);
3804 if (errsts)
3805 break;
3806 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3807 errsts = resp_write_same(SCpnt, lba, num, devip, ei_lba, unmap);
3808 break;
3809 case UNMAP:
3810 errsts = check_readiness(SCpnt, 0, devip);
3811 if (errsts)
3812 break;
3813
5b94e232 3814 if (scsi_debug_unmap_max_desc == 0 || scsi_debug_lbpu == 0) {
44d92694
MP		 3815 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3816 INVALID_COMMAND_OPCODE, 0);
3817 errsts = check_condition_result;
3818 } else
3819 errsts = resp_unmap(SCpnt, devip);
3820 break;
639db475
FT		 3821 case MODE_SENSE:
3822 case MODE_SENSE_10:
3823 errsts = resp_mode_sense(SCpnt, target, devip);
3824 break;
3825 case MODE_SELECT:
3826 errsts = resp_mode_select(SCpnt, 1, devip);
3827 break;
3828 case MODE_SELECT_10:
3829 errsts = resp_mode_select(SCpnt, 0, devip);
3830 break;
3831 case LOG_SENSE:
3832 errsts = resp_log_sense(SCpnt, devip);
3833 break;
3834 case SYNCHRONIZE_CACHE:
3835 delay_override = 1;
3836 errsts = check_readiness(SCpnt, 0, devip);
3837 break;
3838 case WRITE_BUFFER:
3839 errsts = check_readiness(SCpnt, 1, devip);
3840 break;
3841 case XDWRITEREAD_10:
3842 if (!scsi_bidi_cmnd(SCpnt)) {
3843 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3844 INVALID_FIELD_IN_CDB, 0);
3845 errsts = check_condition_result;
3846 break;
3847 }
3848
3849 errsts = check_readiness(SCpnt, 0, devip);
3850 if (errsts)
3851 break;
3852 if (scsi_debug_fake_rw)
3853 break;
395cef03
MP		 3854 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3855 errsts = resp_read(SCpnt, lba, num, devip, ei_lba);
639db475
FT		 3856 if (errsts)
3857 break;
395cef03 3858 errsts = resp_write(SCpnt, lba, num, devip, ei_lba);
639db475
FT		 3859 if (errsts)
3860 break;
3861 errsts = resp_xdwriteread(SCpnt, lba, num, devip);
3862 break;
395cef03
MP		 3863 case VARIABLE_LENGTH_CMD:
3864 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION) {
3865
3866 if ((cmd[10] & 0xe0) == 0)
3867 printk(KERN_ERR
3868 "Unprotected RD/WR to DIF device\n");
3869
3870 if (cmd[9] == READ_32) {
3871 BUG_ON(SCpnt->cmd_len < 32);
3872 goto read;
3873 }
3874
3875 if (cmd[9] == WRITE_32) {
3876 BUG_ON(SCpnt->cmd_len < 32);
3877 goto write;
3878 }
3879 }
3880
3881 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3882 INVALID_FIELD_IN_CDB, 0);
3883 errsts = check_condition_result;
3884 break;
3885
639db475
FT		 3886 default:
3887 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
3888 printk(KERN_INFO "scsi_debug: Opcode: 0x%x not "
3889 "supported\n", *cmd);
3890 errsts = check_readiness(SCpnt, 1, devip);
3891 if (errsts)
3892 break; /* Unit attention takes precedence */
3893 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
3894 errsts = check_condition_result;
3895 break;
3896 }
3897 return schedule_resp(SCpnt, devip, done, errsts,
3898 (delay_override ? 0 : scsi_debug_delay));
3899}
3900
f281233d
JG		 3901static DEF_SCSI_QCMD(scsi_debug_queuecommand)
3902
9e603ca0 3903static struct scsi_host_template sdebug_driver_template = {
c8ed555a
AV		 3904 .show_info = scsi_debug_show_info,
3905 .write_info = scsi_debug_write_info,
9e603ca0
FT		 3906 .proc_name = sdebug_proc_name,
3907 .name = "SCSI DEBUG",
3908 .info = scsi_debug_info,
3909 .slave_alloc = scsi_debug_slave_alloc,
3910 .slave_configure = scsi_debug_slave_configure,
3911 .slave_destroy = scsi_debug_slave_destroy,
3912 .ioctl = scsi_debug_ioctl,
3913 .queuecommand = scsi_debug_queuecommand,
3914 .eh_abort_handler = scsi_debug_abort,
3915 .eh_bus_reset_handler = scsi_debug_bus_reset,
3916 .eh_device_reset_handler = scsi_debug_device_reset,
3917 .eh_host_reset_handler = scsi_debug_host_reset,
3918 .bios_param = scsi_debug_biosparam,
3919 .can_queue = SCSI_DEBUG_CANQUEUE,
3920 .this_id = 7,
3921 .sg_tablesize = 256,
3922 .cmd_per_lun = 16,
3923 .max_sectors = 0xffff,
3924 .use_clustering = DISABLE_CLUSTERING,
3925 .module = THIS_MODULE,
3926};
3927
1da177e4
LT		 3928static int sdebug_driver_probe(struct device * dev)
3929{
3930 int error = 0;
3931 struct sdebug_host_info *sdbg_host;
3932 struct Scsi_Host *hpnt;
c6a44287 3933 int host_prot;
1da177e4
LT		 3934
3935 sdbg_host = to_sdebug_host(dev);
3936
78d4e5a0
DG		 3937 sdebug_driver_template.can_queue = scsi_debug_max_queue;
3938 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
3939 if (NULL == hpnt) {
3940 printk(KERN_ERR "%s: scsi_register failed\n", __func__);
3941 error = -ENODEV;
1da177e4 3942 return error;
78d4e5a0 3943 }
1da177e4
LT		 3944
3945 sdbg_host->shost = hpnt;
3946 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
3947 if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
3948 hpnt->max_id = scsi_debug_num_tgts + 1;
3949 else
3950 hpnt->max_id = scsi_debug_num_tgts;
c65b1445 3951 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* = scsi_debug_max_luns; */
1da177e4 3952
c6a44287
MP		 3953 host_prot = 0;
3954
3955 switch (scsi_debug_dif) {
3956
3957 case SD_DIF_TYPE1_PROTECTION:
3958 host_prot = SHOST_DIF_TYPE1_PROTECTION;
3959 if (scsi_debug_dix)
3960 host_prot |= SHOST_DIX_TYPE1_PROTECTION;
3961 break;
3962
3963 case SD_DIF_TYPE2_PROTECTION:
3964 host_prot = SHOST_DIF_TYPE2_PROTECTION;
3965 if (scsi_debug_dix)
3966 host_prot |= SHOST_DIX_TYPE2_PROTECTION;
3967 break;
3968
3969 case SD_DIF_TYPE3_PROTECTION:
3970 host_prot = SHOST_DIF_TYPE3_PROTECTION;
3971 if (scsi_debug_dix)
3972 host_prot |= SHOST_DIX_TYPE3_PROTECTION;
3973 break;
3974
3975 default:
3976 if (scsi_debug_dix)
3977 host_prot |= SHOST_DIX_TYPE0_PROTECTION;
3978 break;
3979 }
3980
3981 scsi_host_set_prot(hpnt, host_prot);
3982
3983 printk(KERN_INFO "scsi_debug: host protection%s%s%s%s%s%s%s\n",
3984 (host_prot & SHOST_DIF_TYPE1_PROTECTION) ? " DIF1" : "",
3985 (host_prot & SHOST_DIF_TYPE2_PROTECTION) ? " DIF2" : "",
3986 (host_prot & SHOST_DIF_TYPE3_PROTECTION) ? " DIF3" : "",
3987 (host_prot & SHOST_DIX_TYPE0_PROTECTION) ? " DIX0" : "",
3988 (host_prot & SHOST_DIX_TYPE1_PROTECTION) ? " DIX1" : "",
3989 (host_prot & SHOST_DIX_TYPE2_PROTECTION) ? " DIX2" : "",
3990 (host_prot & SHOST_DIX_TYPE3_PROTECTION) ? " DIX3" : "");
3991
3992 if (scsi_debug_guard == 1)
3993 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_IP);
3994 else
3995 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_CRC);
3996
1da177e4
LT		 3997 error = scsi_add_host(hpnt, &sdbg_host->dev);
3998 if (error) {
cadbd4a5 3999 printk(KERN_ERR "%s: scsi_add_host failed\n", __func__);
1da177e4
LT		 4000 error = -ENODEV;
4001 scsi_host_put(hpnt);
4002 } else
4003 scsi_scan_host(hpnt);
4004
4005
4006 return error;
4007}
4008
4009static int sdebug_driver_remove(struct device * dev)
4010{
1da177e4 4011 struct sdebug_host_info *sdbg_host;
8b40228f 4012 struct sdebug_dev_info *sdbg_devinfo, *tmp;
1da177e4
LT		 4013
4014 sdbg_host = to_sdebug_host(dev);
4015
4016 if (!sdbg_host) {
4017 printk(KERN_ERR "%s: Unable to locate host info\n",
cadbd4a5 4018 __func__);
1da177e4
LT		 4019 return -ENODEV;
4020 }
4021
4022 scsi_remove_host(sdbg_host->shost);
4023
8b40228f
FT		 4024 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
4025 dev_list) {
1da177e4
LT		 4026 list_del(&sdbg_devinfo->dev_list);
4027 kfree(sdbg_devinfo);
4028 }
4029
4030 scsi_host_put(sdbg_host->shost);
4031 return 0;
4032}
4033
8dea0d02
FT		 4034static int pseudo_lld_bus_match(struct device *dev,
4035 struct device_driver *dev_driver)
1da177e4 4036{
8dea0d02 4037 return 1;
1da177e4 4038}
8dea0d02
FT		 4039
4040static struct bus_type pseudo_lld_bus = {
4041 .name = "pseudo",
4042 .match = pseudo_lld_bus_match,
4043 .probe = sdebug_driver_probe,
4044 .remove = sdebug_driver_remove,
82069379 4045 .drv_groups = sdebug_drv_groups,
8dea0d02 4046};
Ubuntu Jammy Linux kernel mirror