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