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