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