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