projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
scsi: scsi_debug: implement IMMED bit
[linux-2.6-block.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 *
80c49563 9 * Copyright (C) 2001 - 2018 Douglas Gilbert
1da177e4 10 *
773642d9
DG		 11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2, or (at your option)
14 * any later version.
1da177e4 15 *
78d4e5a0 16 * For documentation see http://sg.danny.cz/sg/sdebug26.html
1da177e4 17 *
1da177e4
LT		 18 */
19
c1287970
TW		 20
21#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
22
1da177e4
LT		 23#include <linux/module.h>
24
25#include <linux/kernel.h>
1da177e4 26#include <linux/errno.h>
b333a819 27#include <linux/jiffies.h>
5a0e3ad6 28#include <linux/slab.h>
1da177e4
LT		 29#include <linux/types.h>
30#include <linux/string.h>
31#include <linux/genhd.h>
32#include <linux/fs.h>
33#include <linux/init.h>
34#include <linux/proc_fs.h>
1da177e4
LT		 35#include <linux/vmalloc.h>
36#include <linux/moduleparam.h>
852e034d 37#include <linux/scatterlist.h>
1da177e4 38#include <linux/blkdev.h>
c6a44287 39#include <linux/crc-t10dif.h>
cbf67842
DG		 40#include <linux/spinlock.h>
41#include <linux/interrupt.h>
42#include <linux/atomic.h>
43#include <linux/hrtimer.h>
09ba24c1 44#include <linux/uuid.h>
6ebf105c 45#include <linux/t10-pi.h>
c6a44287
MP		 46
47#include <net/checksum.h>
9ff26eef 48
44d92694
MP		 49#include <asm/unaligned.h>
50
9ff26eef
FT		 51#include <scsi/scsi.h>
52#include <scsi/scsi_cmnd.h>
53#include <scsi/scsi_device.h>
1da177e4
LT		 54#include <scsi/scsi_host.h>
55#include <scsi/scsicam.h>
a34c4e98 56#include <scsi/scsi_eh.h>
cbf67842 57#include <scsi/scsi_tcq.h>
395cef03 58#include <scsi/scsi_dbg.h>
1da177e4 59
c6a44287 60#include "sd.h"
1da177e4 61#include "scsi_logging.h"
1da177e4 62
773642d9 63/* make sure inq_product_rev string corresponds to this version */
80c49563
DG		 64#define SDEBUG_VERSION "0188" /* format to fit INQUIRY revision field */
65static const char *sdebug_version_date = "20180128";
cbf67842
DG		 66
67#define MY_NAME "scsi_debug"
1da177e4 68
6f3cbf55 69/* Additional Sense Code (ASC) */
c65b1445
DG		 70#define NO_ADDITIONAL_SENSE 0x0
71#define LOGICAL_UNIT_NOT_READY 0x4
c2248fc9 72#define LOGICAL_UNIT_COMMUNICATION_FAILURE 0x8
1da177e4 73#define UNRECOVERED_READ_ERR 0x11
c65b1445 74#define PARAMETER_LIST_LENGTH_ERR 0x1a
1da177e4 75#define INVALID_OPCODE 0x20
22017ed2 76#define LBA_OUT_OF_RANGE 0x21
1da177e4 77#define INVALID_FIELD_IN_CDB 0x24
c65b1445 78#define INVALID_FIELD_IN_PARAM_LIST 0x26
cbf67842
DG		 79#define UA_RESET_ASC 0x29
80#define UA_CHANGED_ASC 0x2a
19c8ead7
EM		 81#define TARGET_CHANGED_ASC 0x3f
82#define LUNS_CHANGED_ASCQ 0x0e
22017ed2
DG		 83#define INSUFF_RES_ASC 0x55
84#define INSUFF_RES_ASCQ 0x3
cbf67842
DG		 85#define POWER_ON_RESET_ASCQ 0x0
86#define BUS_RESET_ASCQ 0x2 /* scsi bus reset occurred */
87#define MODE_CHANGED_ASCQ 0x1 /* mode parameters changed */
22017ed2 88#define CAPACITY_CHANGED_ASCQ 0x9
1da177e4 89#define SAVING_PARAMS_UNSUP 0x39
6f3cbf55 90#define TRANSPORT_PROBLEM 0x4b
c65b1445
DG		 91#define THRESHOLD_EXCEEDED 0x5d
92#define LOW_POWER_COND_ON 0x5e
22017ed2 93#define MISCOMPARE_VERIFY_ASC 0x1d
acafd0b9
EM		 94#define MICROCODE_CHANGED_ASCQ 0x1 /* with TARGET_CHANGED_ASC */
95#define MICROCODE_CHANGED_WO_RESET_ASCQ 0x16
481b5e5c 96#define WRITE_ERROR_ASC 0xc
1da177e4 97
6f3cbf55
DG		 98/* Additional Sense Code Qualifier (ASCQ) */
99#define ACK_NAK_TO 0x3
100
1da177e4
LT		 101/* Default values for driver parameters */
102#define DEF_NUM_HOST 1
103#define DEF_NUM_TGTS 1
104#define DEF_MAX_LUNS 1
105/* With these defaults, this driver will make 1 host with 1 target
106 * (id 0) containing 1 logical unit (lun 0). That is 1 device.
107 */
5b94e232 108#define DEF_ATO 1
9b760fd8 109#define DEF_CDB_LEN 10
c2206098 110#define DEF_JDELAY 1 /* if > 0 unit is a jiffy */
1da177e4 111#define DEF_DEV_SIZE_MB 8
5b94e232
MP		 112#define DEF_DIF 0
113#define DEF_DIX 0
1da177e4 114#define DEF_D_SENSE 0
5b94e232 115#define DEF_EVERY_NTH 0
23183910 116#define DEF_FAKE_RW 0
c6a44287 117#define DEF_GUARD 0
cbf67842 118#define DEF_HOST_LOCK 0
5b94e232
MP		 119#define DEF_LBPU 0
120#define DEF_LBPWS 0
121#define DEF_LBPWS10 0
be1dd78d 122#define DEF_LBPRZ 1
ea61fca5 123#define DEF_LOWEST_ALIGNED 0
cbf67842 124#define DEF_NDELAY 0 /* if > 0 unit is a nanosecond */
5b94e232
MP		 125#define DEF_NO_LUN_0 0
126#define DEF_NUM_PARTS 0
127#define DEF_OPTS 0
32c5844a 128#define DEF_OPT_BLKS 1024
5b94e232 129#define DEF_PHYSBLK_EXP 0
86e6828a 130#define DEF_OPT_XFERLEN_EXP 0
b01f6f83 131#define DEF_PTYPE TYPE_DISK
d986788b 132#define DEF_REMOVABLE false
760f3b03 133#define DEF_SCSI_LEVEL 7 /* INQUIRY, byte2 [6->SPC-4; 7->SPC-5] */
5b94e232
MP		 134#define DEF_SECTOR_SIZE 512
135#define DEF_UNMAP_ALIGNMENT 0
136#define DEF_UNMAP_GRANULARITY 1
6014759c
MP		 137#define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF
138#define DEF_UNMAP_MAX_DESC 256
5b94e232
MP		 139#define DEF_VIRTUAL_GB 0
140#define DEF_VPD_USE_HOSTNO 1
141#define DEF_WRITESAME_LENGTH 0xFFFF
c2248fc9 142#define DEF_STRICT 0
c4837394
DG		 143#define DEF_STATISTICS false
144#define DEF_SUBMIT_QUEUES 1
09ba24c1 145#define DEF_UUID_CTL 0
c2206098 146#define JDELAY_OVERRIDDEN -9999
1da177e4 147
b01f6f83
DG		 148#define SDEBUG_LUN_0_VAL 0
149
773642d9
DG		 150/* bit mask values for sdebug_opts */
151#define SDEBUG_OPT_NOISE 1
152#define SDEBUG_OPT_MEDIUM_ERR 2
153#define SDEBUG_OPT_TIMEOUT 4
154#define SDEBUG_OPT_RECOVERED_ERR 8
155#define SDEBUG_OPT_TRANSPORT_ERR 16
156#define SDEBUG_OPT_DIF_ERR 32
157#define SDEBUG_OPT_DIX_ERR 64
158#define SDEBUG_OPT_MAC_TIMEOUT 128
159#define SDEBUG_OPT_SHORT_TRANSFER 0x100
160#define SDEBUG_OPT_Q_NOISE 0x200
161#define SDEBUG_OPT_ALL_TSF 0x400
162#define SDEBUG_OPT_RARE_TSF 0x800
163#define SDEBUG_OPT_N_WCE 0x1000
164#define SDEBUG_OPT_RESET_NOISE 0x2000
165#define SDEBUG_OPT_NO_CDB_NOISE 0x4000
7ee6d1b4 166#define SDEBUG_OPT_HOST_BUSY 0x8000
773642d9
DG		 167#define SDEBUG_OPT_ALL_NOISE (SDEBUG_OPT_NOISE | SDEBUG_OPT_Q_NOISE | \
168 SDEBUG_OPT_RESET_NOISE)
169#define SDEBUG_OPT_ALL_INJECTING (SDEBUG_OPT_RECOVERED_ERR | \
170 SDEBUG_OPT_TRANSPORT_ERR | \
171 SDEBUG_OPT_DIF_ERR | SDEBUG_OPT_DIX_ERR | \
7ee6d1b4
BVA		 172 SDEBUG_OPT_SHORT_TRANSFER | \
173 SDEBUG_OPT_HOST_BUSY)
1da177e4 174/* When "every_nth" > 0 then modulo "every_nth" commands:
fd32119b 175 * - a missing response is simulated if SDEBUG_OPT_TIMEOUT is set
1da177e4 176 * - a RECOVERED_ERROR is simulated on successful read and write
773642d9 177 * commands if SDEBUG_OPT_RECOVERED_ERR is set.
6f3cbf55 178 * - a TRANSPORT_ERROR is simulated on successful read and write
773642d9 179 * commands if SDEBUG_OPT_TRANSPORT_ERR is set.
1da177e4
LT		 180 *
181 * When "every_nth" < 0 then after "- every_nth" commands:
fd32119b 182 * - a missing response is simulated if SDEBUG_OPT_TIMEOUT is set
1da177e4 183 * - a RECOVERED_ERROR is simulated on successful read and write
773642d9 184 * commands if SDEBUG_OPT_RECOVERED_ERR is set.
6f3cbf55 185 * - a TRANSPORT_ERROR is simulated on successful read and write
773642d9
DG		 186 * commands if _DEBUG_OPT_TRANSPORT_ERR is set.
187 * This will continue on every subsequent command until some other action
188 * occurs (e.g. the user * writing a new value (other than -1 or 1) to
189 * every_nth via sysfs).
1da177e4
LT		 190 */
191
fd32119b 192/* As indicated in SAM-5 and SPC-4 Unit Attentions (UAs) are returned in
cbf67842
DG		 193 * priority order. In the subset implemented here lower numbers have higher
194 * priority. The UA numbers should be a sequence starting from 0 with
195 * SDEBUG_NUM_UAS being 1 higher than the highest numbered UA. */
196#define SDEBUG_UA_POR 0 /* Power on, reset, or bus device reset */
197#define SDEBUG_UA_BUS_RESET 1
198#define SDEBUG_UA_MODE_CHANGED 2
0d01c5df 199#define SDEBUG_UA_CAPACITY_CHANGED 3
19c8ead7 200#define SDEBUG_UA_LUNS_CHANGED 4
acafd0b9
EM		 201#define SDEBUG_UA_MICROCODE_CHANGED 5 /* simulate firmware change */
202#define SDEBUG_UA_MICROCODE_CHANGED_WO_RESET 6
203#define SDEBUG_NUM_UAS 7
cbf67842 204
773642d9 205/* when 1==SDEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
1da177e4
LT		 206 * sector on read commands: */
207#define OPT_MEDIUM_ERR_ADDR 0x1234 /* that's sector 4660 in decimal */
32f7ef73 208#define OPT_MEDIUM_ERR_NUM 10 /* number of consecutive medium errs */
1da177e4
LT		 209
210/* If REPORT LUNS has luns >= 256 it can choose "flat space" (value 1)
211 * or "peripheral device" addressing (value 0) */
212#define SAM2_LUN_ADDRESS_METHOD 0
213
c4837394
DG		 214/* SDEBUG_CANQUEUE is the maximum number of commands that can be queued
215 * (for response) per submit queue at one time. Can be reduced by max_queue
216 * option. Command responses are not queued when jdelay=0 and ndelay=0. The
217 * per-device DEF_CMD_PER_LUN can be changed via sysfs:
218 * /sys/class/scsi_device/<h:c:t:l>/device/queue_depth
219 * but cannot exceed SDEBUG_CANQUEUE .
220 */
221#define SDEBUG_CANQUEUE_WORDS 3 /* a WORD is bits in a long */
222#define SDEBUG_CANQUEUE (SDEBUG_CANQUEUE_WORDS * BITS_PER_LONG)
cbf67842
DG		 223#define DEF_CMD_PER_LUN 255
224
fd32119b
DG		 225#define F_D_IN 1
226#define F_D_OUT 2
227#define F_D_OUT_MAYBE 4 /* WRITE SAME, NDOB bit */
228#define F_D_UNKN 8
229#define F_RL_WLUN_OK 0x10
230#define F_SKIP_UA 0x20
231#define F_DELAY_OVERR 0x40
232#define F_SA_LOW 0x80 /* cdb byte 1, bits 4 to 0 */
233#define F_SA_HIGH 0x100 /* as used by variable length cdbs */
234#define F_INV_OP 0x200
235#define F_FAKE_RW 0x400
236#define F_M_ACCESS 0x800 /* media access */
80c49563 237#define F_LONG_DELAY 0x1000
fd32119b
DG		 238
239#define FF_RESPOND (F_RL_WLUN_OK | F_SKIP_UA | F_DELAY_OVERR)
46f64e70 240#define FF_MEDIA_IO (F_M_ACCESS | F_FAKE_RW)
fd32119b
DG		 241#define FF_SA (F_SA_HIGH | F_SA_LOW)
242
243#define SDEBUG_MAX_PARTS 4
244
b01f6f83 245#define SDEBUG_MAX_CMD_LEN 32
fd32119b
DG		 246
247
248struct sdebug_dev_info {
249 struct list_head dev_list;
250 unsigned int channel;
251 unsigned int target;
252 u64 lun;
bf476433 253 uuid_t lu_name;
fd32119b
DG		 254 struct sdebug_host_info *sdbg_host;
255 unsigned long uas_bm[1];
256 atomic_t num_in_q;
c4837394 257 atomic_t stopped;
fd32119b
DG		 258 bool used;
259};
260
261struct sdebug_host_info {
262 struct list_head host_list;
263 struct Scsi_Host *shost;
264 struct device dev;
265 struct list_head dev_info_list;
266};
267
268#define to_sdebug_host(d) \
269 container_of(d, struct sdebug_host_info, dev)
270
10bde980
DG		 271enum sdeb_defer_type {SDEB_DEFER_NONE = 0, SDEB_DEFER_HRT = 1,
272 SDEB_DEFER_WQ = 2};
273
fd32119b
DG		 274struct sdebug_defer {
275 struct hrtimer hrt;
276 struct execute_work ew;
c4837394
DG		 277 int sqa_idx; /* index of sdebug_queue array */
278 int qc_idx; /* index of sdebug_queued_cmd array within sqa_idx */
279 int issuing_cpu;
10bde980
DG		 280 bool init_hrt;
281 bool init_wq;
282 enum sdeb_defer_type defer_t;
fd32119b
DG		 283};
284
285struct sdebug_queued_cmd {
c4837394
DG		 286 /* corresponding bit set in in_use_bm[] in owning struct sdebug_queue
287 * instance indicates this slot is in use.
288 */
fd32119b
DG		 289 struct sdebug_defer *sd_dp;
290 struct scsi_cmnd *a_cmnd;
c4837394
DG		 291 unsigned int inj_recovered:1;
292 unsigned int inj_transport:1;
293 unsigned int inj_dif:1;
294 unsigned int inj_dix:1;
295 unsigned int inj_short:1;
7ee6d1b4 296 unsigned int inj_host_busy:1;
fd32119b
DG		 297};
298
c4837394
DG		 299struct sdebug_queue {
300 struct sdebug_queued_cmd qc_arr[SDEBUG_CANQUEUE];
301 unsigned long in_use_bm[SDEBUG_CANQUEUE_WORDS];
302 spinlock_t qc_lock;
303 atomic_t blocked; /* to temporarily stop more being queued */
fd32119b
DG		 304};
305
c4837394
DG		 306static atomic_t sdebug_cmnd_count; /* number of incoming commands */
307static atomic_t sdebug_completions; /* count of deferred completions */
308static atomic_t sdebug_miss_cpus; /* submission + completion cpus differ */
309static atomic_t sdebug_a_tsf; /* 'almost task set full' counter */
310
fd32119b 311struct opcode_info_t {
b01f6f83
DG		 312 u8 num_attached; /* 0 if this is it (i.e. a leaf); use 0xff */
313 /* for terminating element */
fd32119b
DG		 314 u8 opcode; /* if num_attached > 0, preferred */
315 u16 sa; /* service action */
316 u32 flags; /* OR-ed set of SDEB_F_* */
317 int (*pfp)(struct scsi_cmnd *, struct sdebug_dev_info *);
318 const struct opcode_info_t *arrp; /* num_attached elements or NULL */
9a051019
DG		 319 u8 len_mask[16]; /* len_mask[0]-->cdb_len, then mask for cdb */
320 /* 1 to min(cdb_len, 15); ignore cdb[15...] */
fd32119b
DG		 321};
322
323/* SCSI opcodes (first byte of cdb) of interest mapped onto these indexes */
c2248fc9
DG		 324enum sdeb_opcode_index {
325 SDEB_I_INVALID_OPCODE = 0,
326 SDEB_I_INQUIRY = 1,
327 SDEB_I_REPORT_LUNS = 2,
328 SDEB_I_REQUEST_SENSE = 3,
329 SDEB_I_TEST_UNIT_READY = 4,
330 SDEB_I_MODE_SENSE = 5, /* 6, 10 */
331 SDEB_I_MODE_SELECT = 6, /* 6, 10 */
332 SDEB_I_LOG_SENSE = 7,
333 SDEB_I_READ_CAPACITY = 8, /* 10; 16 is in SA_IN(16) */
334 SDEB_I_READ = 9, /* 6, 10, 12, 16 */
335 SDEB_I_WRITE = 10, /* 6, 10, 12, 16 */
336 SDEB_I_START_STOP = 11,
46f64e70
DG		 337 SDEB_I_SERV_ACT_IN_16 = 12, /* add ...SERV_ACT_IN_12 if needed */
338 SDEB_I_SERV_ACT_OUT_16 = 13, /* add ...SERV_ACT_OUT_12 if needed */
c2248fc9
DG		 339 SDEB_I_MAINT_IN = 14,
340 SDEB_I_MAINT_OUT = 15,
341 SDEB_I_VERIFY = 16, /* 10 only */
481b5e5c 342 SDEB_I_VARIABLE_LEN = 17, /* READ(32), WRITE(32), WR_SCAT(32) */
c2248fc9
DG		 343 SDEB_I_RESERVE = 18, /* 6, 10 */
344 SDEB_I_RELEASE = 19, /* 6, 10 */
345 SDEB_I_ALLOW_REMOVAL = 20, /* PREVENT ALLOW MEDIUM REMOVAL */
346 SDEB_I_REZERO_UNIT = 21, /* REWIND in SSC */
347 SDEB_I_ATA_PT = 22, /* 12, 16 */
348 SDEB_I_SEND_DIAG = 23,
349 SDEB_I_UNMAP = 24,
350 SDEB_I_XDWRITEREAD = 25, /* 10 only */
351 SDEB_I_WRITE_BUFFER = 26,
352 SDEB_I_WRITE_SAME = 27, /* 10, 16 */
80c49563 353 SDEB_I_SYNC_CACHE = 28, /* 10, 16 */
c2248fc9 354 SDEB_I_COMP_WRITE = 29,
9a051019 355 SDEB_I_LAST_ELEMENT = 30, /* keep this last (previous + 1) */
c2248fc9
DG		 356};
357
c4837394 358
c2248fc9
DG		 359static const unsigned char opcode_ind_arr[256] = {
360/* 0x0; 0x0->0x1f: 6 byte cdbs */
361 SDEB_I_TEST_UNIT_READY, SDEB_I_REZERO_UNIT, 0, SDEB_I_REQUEST_SENSE,
362 0, 0, 0, 0,
363 SDEB_I_READ, 0, SDEB_I_WRITE, 0, 0, 0, 0, 0,
364 0, 0, SDEB_I_INQUIRY, 0, 0, SDEB_I_MODE_SELECT, SDEB_I_RESERVE,
365 SDEB_I_RELEASE,
366 0, 0, SDEB_I_MODE_SENSE, SDEB_I_START_STOP, 0, SDEB_I_SEND_DIAG,
367 SDEB_I_ALLOW_REMOVAL, 0,
368/* 0x20; 0x20->0x3f: 10 byte cdbs */
369 0, 0, 0, 0, 0, SDEB_I_READ_CAPACITY, 0, 0,
370 SDEB_I_READ, 0, SDEB_I_WRITE, 0, 0, 0, 0, SDEB_I_VERIFY,
371 0, 0, 0, 0, 0, SDEB_I_SYNC_CACHE, 0, 0,
372 0, 0, 0, SDEB_I_WRITE_BUFFER, 0, 0, 0, 0,
373/* 0x40; 0x40->0x5f: 10 byte cdbs */
374 0, SDEB_I_WRITE_SAME, SDEB_I_UNMAP, 0, 0, 0, 0, 0,
375 0, 0, 0, 0, 0, SDEB_I_LOG_SENSE, 0, 0,
376 0, 0, 0, SDEB_I_XDWRITEREAD, 0, SDEB_I_MODE_SELECT, SDEB_I_RESERVE,
377 SDEB_I_RELEASE,
378 0, 0, SDEB_I_MODE_SENSE, 0, 0, 0, 0, 0,
fd32119b 379/* 0x60; 0x60->0x7d are reserved, 0x7e is "extended cdb" */
c2248fc9
DG		 380 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
381 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
382 0, SDEB_I_VARIABLE_LEN,
383/* 0x80; 0x80->0x9f: 16 byte cdbs */
384 0, 0, 0, 0, 0, SDEB_I_ATA_PT, 0, 0,
385 SDEB_I_READ, SDEB_I_COMP_WRITE, SDEB_I_WRITE, 0, 0, 0, 0, 0,
80c49563 386 0, SDEB_I_SYNC_CACHE, 0, SDEB_I_WRITE_SAME, 0, 0, 0, 0,
46f64e70 387 0, 0, 0, 0, 0, 0, SDEB_I_SERV_ACT_IN_16, SDEB_I_SERV_ACT_OUT_16,
c2248fc9
DG		 388/* 0xa0; 0xa0->0xbf: 12 byte cdbs */
389 SDEB_I_REPORT_LUNS, SDEB_I_ATA_PT, 0, SDEB_I_MAINT_IN,
390 SDEB_I_MAINT_OUT, 0, 0, 0,
46f64e70
DG		 391 SDEB_I_READ, 0 /* SDEB_I_SERV_ACT_OUT_12 */, SDEB_I_WRITE,
392 0 /* SDEB_I_SERV_ACT_IN_12 */, 0, 0, 0, 0,
c2248fc9
DG		 393 0, 0, 0, 0, 0, 0, 0, 0,
394 0, 0, 0, 0, 0, 0, 0, 0,
395/* 0xc0; 0xc0->0xff: vendor specific */
396 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
397 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
398 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
399 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
400};
401
80c49563
DG		 402/*
403 * The following "response" functions return the SCSI mid-level's 4 byte
404 * tuple-in-an-int. To handle commands with an IMMED bit, for a faster
405 * command completion, they can mask their return value with
406 * SDEG_RES_IMMED_MASK .
407 */
408#define SDEG_RES_IMMED_MASK 0x40000000
409
c2248fc9
DG		 410static int resp_inquiry(struct scsi_cmnd *, struct sdebug_dev_info *);
411static int resp_report_luns(struct scsi_cmnd *, struct sdebug_dev_info *);
412static int resp_requests(struct scsi_cmnd *, struct sdebug_dev_info *);
413static int resp_mode_sense(struct scsi_cmnd *, struct sdebug_dev_info *);
414static int resp_mode_select(struct scsi_cmnd *, struct sdebug_dev_info *);
415static int resp_log_sense(struct scsi_cmnd *, struct sdebug_dev_info *);
416static int resp_readcap(struct scsi_cmnd *, struct sdebug_dev_info *);
417static int resp_read_dt0(struct scsi_cmnd *, struct sdebug_dev_info *);
418static int resp_write_dt0(struct scsi_cmnd *, struct sdebug_dev_info *);
481b5e5c 419static int resp_write_scat(struct scsi_cmnd *, struct sdebug_dev_info *);
c2248fc9
DG		 420static int resp_start_stop(struct scsi_cmnd *, struct sdebug_dev_info *);
421static int resp_readcap16(struct scsi_cmnd *, struct sdebug_dev_info *);
422static int resp_get_lba_status(struct scsi_cmnd *, struct sdebug_dev_info *);
423static int resp_report_tgtpgs(struct scsi_cmnd *, struct sdebug_dev_info *);
424static int resp_unmap(struct scsi_cmnd *, struct sdebug_dev_info *);
38d5c833
DG		 425static int resp_rsup_opcodes(struct scsi_cmnd *, struct sdebug_dev_info *);
426static int resp_rsup_tmfs(struct scsi_cmnd *, struct sdebug_dev_info *);
c2248fc9
DG		 427static int resp_write_same_10(struct scsi_cmnd *, struct sdebug_dev_info *);
428static int resp_write_same_16(struct scsi_cmnd *, struct sdebug_dev_info *);
429static int resp_xdwriteread_10(struct scsi_cmnd *, struct sdebug_dev_info *);
38d5c833 430static int resp_comp_write(struct scsi_cmnd *, struct sdebug_dev_info *);
acafd0b9 431static int resp_write_buffer(struct scsi_cmnd *, struct sdebug_dev_info *);
80c49563 432static int resp_sync_cache(struct scsi_cmnd *, struct sdebug_dev_info *);
c2248fc9 433
46f64e70
DG		 434/*
435 * The following are overflow arrays for cdbs that "hit" the same index in
436 * the opcode_info_arr array. The most time sensitive (or commonly used) cdb
437 * should be placed in opcode_info_arr[], the others should be placed here.
438 */
439static const struct opcode_info_t msense_iarr[] = {
c2248fc9
DG		 440 {0, 0x1a, 0, F_D_IN, NULL, NULL,
441 {6, 0xe8, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
442};
443
46f64e70 444static const struct opcode_info_t mselect_iarr[] = {
c2248fc9
DG		 445 {0, 0x15, 0, F_D_OUT, NULL, NULL,
446 {6, 0xf1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
447};
448
46f64e70
DG		 449static const struct opcode_info_t read_iarr[] = {
450 {0, 0x28, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL,/* READ(10) */
b7e24581 451 {10, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
c2248fc9 452 0, 0, 0, 0} },
46f64e70 453 {0, 0x8, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL, /* READ(6) */
c2248fc9 454 {6, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
46f64e70 455 {0, 0xa8, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL,/* READ(12) */
b7e24581 456 {12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf,
c2248fc9
DG		 457 0xc7, 0, 0, 0, 0} },
458};
459
46f64e70
DG		 460static const struct opcode_info_t write_iarr[] = {
461 {0, 0x2a, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0, /* WRITE(10) */
462 NULL, {10, 0xfb, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7,
463 0, 0, 0, 0, 0, 0} },
464 {0, 0xa, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0, /* WRITE(6) */
465 NULL, {6, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0,
466 0, 0, 0} },
467 {0, 0xaa, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0, /* WRITE(12) */
468 NULL, {12, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
469 0xbf, 0xc7, 0, 0, 0, 0} },
c2248fc9
DG		 470};
471
46f64e70 472static const struct opcode_info_t sa_in_16_iarr[] = {
c2248fc9
DG		 473 {0, 0x9e, 0x12, F_SA_LOW | F_D_IN, resp_get_lba_status, NULL,
474 {16, 0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
46f64e70 475 0xff, 0xff, 0xff, 0, 0xc7} }, /* GET LBA STATUS(16) */
c2248fc9
DG		 476};
477
46f64e70
DG		 478static const struct opcode_info_t vl_iarr[] = { /* VARIABLE LENGTH */
479 {0, 0x7f, 0xb, F_SA_HIGH | F_D_OUT | FF_MEDIA_IO, resp_write_dt0,
b7e24581 480 NULL, {32, 0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0xb, 0xfa,
c2248fc9 481 0, 0xff, 0xff, 0xff, 0xff} }, /* WRITE(32) */
481b5e5c
DG		 482 {0, 0x7f, 0x11, F_SA_HIGH | F_D_OUT | FF_MEDIA_IO, resp_write_scat,
483 NULL, {32, 0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0x11, 0xf8,
484 0, 0xff, 0xff, 0x0, 0x0} }, /* WRITE SCATTERED(32) */
c2248fc9
DG		 485};
486
46f64e70 487static const struct opcode_info_t maint_in_iarr[] = { /* MAINT IN */
38d5c833 488 {0, 0xa3, 0xc, F_SA_LOW | F_D_IN, resp_rsup_opcodes, NULL,
c2248fc9 489 {12, 0xc, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0,
46f64e70 490 0xc7, 0, 0, 0, 0} }, /* REPORT SUPPORTED OPERATION CODES */
38d5c833 491 {0, 0xa3, 0xd, F_SA_LOW | F_D_IN, resp_rsup_tmfs, NULL,
c2248fc9 492 {12, 0xd, 0x80, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0,
46f64e70 493 0, 0} }, /* REPORTED SUPPORTED TASK MANAGEMENT FUNCTIONS */
c2248fc9
DG		 494};
495
46f64e70
DG		 496static const struct opcode_info_t write_same_iarr[] = {
497 {0, 0x93, 0, F_D_OUT_MAYBE | FF_MEDIA_IO, resp_write_same_16, NULL,
c2248fc9 498 {16, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
46f64e70 499 0xff, 0xff, 0xff, 0x3f, 0xc7} }, /* WRITE SAME(16) */
c2248fc9
DG		 500};
501
46f64e70
DG		 502static const struct opcode_info_t reserve_iarr[] = {
503 {0, 0x16, 0, F_D_OUT, NULL, NULL, /* RESERVE(6) */
c2248fc9
DG		 504 {6, 0x1f, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
505};
506
46f64e70
DG		 507static const struct opcode_info_t release_iarr[] = {
508 {0, 0x17, 0, F_D_OUT, NULL, NULL, /* RELEASE(6) */
c2248fc9
DG		 509 {6, 0x1f, 0xff, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
510};
511
80c49563
DG		 512static const struct opcode_info_t sync_cache_iarr[] = {
513 {0, 0x91, 0, F_LONG_DELAY | F_M_ACCESS, resp_sync_cache, NULL,
514 {16, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
515 0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} }, /* SYNC_CACHE (16) */
516};
517
c2248fc9
DG		 518
519/* This array is accessed via SDEB_I_* values. Make sure all are mapped,
520 * plus the terminating elements for logic that scans this table such as
521 * REPORT SUPPORTED OPERATION CODES. */
522static const struct opcode_info_t opcode_info_arr[SDEB_I_LAST_ELEMENT + 1] = {
523/* 0 */
46f64e70 524 {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* unknown opcodes */
c2248fc9 525 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
46f64e70 526 {0, 0x12, 0, FF_RESPOND | F_D_IN, resp_inquiry, NULL, /* INQUIRY */
c2248fc9
DG		 527 {6, 0xe3, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
528 {0, 0xa0, 0, FF_RESPOND | F_D_IN, resp_report_luns, NULL,
529 {12, 0xe3, 0xff, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0,
46f64e70 530 0, 0} }, /* REPORT LUNS */
c2248fc9
DG		 531 {0, 0x3, 0, FF_RESPOND | F_D_IN, resp_requests, NULL,
532 {6, 0xe1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
533 {0, 0x0, 0, F_M_ACCESS | F_RL_WLUN_OK, NULL, NULL,/* TEST UNIT READY */
534 {6, 0, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
46f64e70
DG		 535/* 5 */
536 {ARRAY_SIZE(msense_iarr), 0x5a, 0, F_D_IN, /* MODE SENSE(10) */
537 resp_mode_sense, msense_iarr, {10, 0xf8, 0xff, 0xff, 0, 0, 0,
538 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
539 {ARRAY_SIZE(mselect_iarr), 0x55, 0, F_D_OUT, /* MODE SELECT(10) */
540 resp_mode_select, mselect_iarr, {10, 0xf1, 0, 0, 0, 0, 0, 0xff,
541 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
542 {0, 0x4d, 0, F_D_IN, resp_log_sense, NULL, /* LOG SENSE */
c2248fc9
DG		 543 {10, 0xe3, 0xff, 0xff, 0, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0,
544 0, 0, 0} },
46f64e70 545 {0, 0x25, 0, F_D_IN, resp_readcap, NULL, /* READ CAPACITY(10) */
c2248fc9
DG		 546 {10, 0xe1, 0xff, 0xff, 0xff, 0xff, 0, 0, 0x1, 0xc7, 0, 0, 0, 0,
547 0, 0} },
46f64e70
DG		 548 {ARRAY_SIZE(read_iarr), 0x88, 0, F_D_IN | FF_MEDIA_IO, /* READ(16) */
549 resp_read_dt0, read_iarr, {16, 0xfe, 0xff, 0xff, 0xff, 0xff,
550 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7} },
c2248fc9 551/* 10 */
46f64e70
DG		 552 {ARRAY_SIZE(write_iarr), 0x8a, 0, F_D_OUT | FF_MEDIA_IO,
553 resp_write_dt0, write_iarr, /* WRITE(16) */
554 {16, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
80c49563
DG		 555 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7} },
556 {0, 0x1b, 0, F_LONG_DELAY, resp_start_stop, NULL,/* START STOP UNIT */
c2248fc9 557 {6, 0x1, 0, 0xf, 0xf7, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
46f64e70
DG		 558 {ARRAY_SIZE(sa_in_16_iarr), 0x9e, 0x10, F_SA_LOW | F_D_IN,
559 resp_readcap16, sa_in_16_iarr, /* SA_IN(16), READ CAPACITY(16) */
560 {16, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
561 0xff, 0xff, 0xff, 0xff, 0x1, 0xc7} },
481b5e5c
DG		 562 {0, 0x9f, 0x12, F_SA_LOW | F_D_OUT | FF_MEDIA_IO, resp_write_scat,
563 NULL, {16, 0x12, 0xf9, 0x0, 0xff, 0xff, 0, 0, 0xff, 0xff, 0xff,
564 0xff, 0xff, 0xff, 0xff, 0xc7} }, /* SA_OUT(16), WRITE SCAT(16) */
46f64e70
DG		 565 {ARRAY_SIZE(maint_in_iarr), 0xa3, 0xa, F_SA_LOW | F_D_IN,
566 resp_report_tgtpgs, /* MAINT IN, REPORT TARGET PORT GROUPS */
567 maint_in_iarr, {12, 0xea, 0, 0, 0, 0, 0xff, 0xff, 0xff,
568 0xff, 0, 0xc7, 0, 0, 0, 0} },
569/* 15 */
c2248fc9
DG		 570 {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* MAINT OUT */
571 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
46f64e70 572 {0, 0x2f, 0, F_D_OUT_MAYBE | FF_MEDIA_IO, NULL, NULL, /* VERIFY(10) */
f7f9f26b
DG		 573 {10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7,
574 0, 0, 0, 0, 0, 0} },
46f64e70
DG		 575 {ARRAY_SIZE(vl_iarr), 0x7f, 0x9, F_SA_HIGH | F_D_IN | FF_MEDIA_IO,
576 resp_read_dt0, vl_iarr, /* VARIABLE LENGTH, READ(32) */
577 {32, 0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0x9, 0xfe, 0, 0xff, 0xff,
578 0xff, 0xff} },
579 {ARRAY_SIZE(reserve_iarr), 0x56, 0, F_D_OUT,
580 NULL, reserve_iarr, /* RESERVE(10) <no response function> */
c2248fc9
DG		 581 {10, 0xff, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
582 0} },
46f64e70
DG		 583 {ARRAY_SIZE(release_iarr), 0x57, 0, F_D_OUT,
584 NULL, release_iarr, /* RELEASE(10) <no response function> */
c2248fc9
DG		 585 {10, 0x13, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
586 0} },
587/* 20 */
f7f9f26b
DG		 588 {0, 0x1e, 0, 0, NULL, NULL, /* ALLOW REMOVAL */
589 {6, 0, 0, 0, 0x3, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
c2248fc9
DG		 590 {0, 0x1, 0, 0, resp_start_stop, NULL, /* REWIND ?? */
591 {6, 0x1, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
592 {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* ATA_PT */
593 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
594 {0, 0x1d, F_D_OUT, 0, NULL, NULL, /* SEND DIAGNOSTIC */
595 {6, 0xf7, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
46f64e70 596 {0, 0x42, 0, F_D_OUT | FF_MEDIA_IO, resp_unmap, NULL, /* UNMAP */
b7e24581 597 {10, 0x1, 0, 0, 0, 0, 0x3f, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
46f64e70
DG		 598/* 25 */
599 {0, 0x53, 0, F_D_IN | F_D_OUT | FF_MEDIA_IO, resp_xdwriteread_10,
b7e24581 600 NULL, {10, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7,
46f64e70 601 0, 0, 0, 0, 0, 0} }, /* XDWRITEREAD(10) */
acafd0b9
EM		 602 {0, 0x3b, 0, F_D_OUT_MAYBE, resp_write_buffer, NULL,
603 {10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0,
604 0, 0, 0, 0} }, /* WRITE_BUFFER */
46f64e70
DG		 605 {ARRAY_SIZE(write_same_iarr), 0x41, 0, F_D_OUT_MAYBE | FF_MEDIA_IO,
606 resp_write_same_10, write_same_iarr, /* WRITE SAME(10) */
607 {10, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0,
608 0, 0, 0, 0, 0} },
80c49563
DG		 609 {ARRAY_SIZE(sync_cache_iarr), 0x35, 0, F_LONG_DELAY | F_M_ACCESS,
610 resp_sync_cache, sync_cache_iarr,
b7e24581 611 {10, 0x7, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
80c49563 612 0, 0, 0, 0} }, /* SYNC_CACHE (10) */
46f64e70 613 {0, 0x89, 0, F_D_OUT | FF_MEDIA_IO, resp_comp_write, NULL,
c2248fc9 614 {16, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0,
b7e24581 615 0, 0xff, 0x3f, 0xc7} }, /* COMPARE AND WRITE */
c2248fc9
DG		 616
617/* 30 */
618 {0xff, 0, 0, 0, NULL, NULL, /* terminating element */
619 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
620};
621
773642d9
DG		 622static int sdebug_add_host = DEF_NUM_HOST;
623static int sdebug_ato = DEF_ATO;
9b760fd8 624static int sdebug_cdb_len = DEF_CDB_LEN;
c2206098 625static int sdebug_jdelay = DEF_JDELAY; /* if > 0 then unit is jiffies */
773642d9
DG		 626static int sdebug_dev_size_mb = DEF_DEV_SIZE_MB;
627static int sdebug_dif = DEF_DIF;
628static int sdebug_dix = DEF_DIX;
629static int sdebug_dsense = DEF_D_SENSE;
630static int sdebug_every_nth = DEF_EVERY_NTH;
631static int sdebug_fake_rw = DEF_FAKE_RW;
632static unsigned int sdebug_guard = DEF_GUARD;
633static int sdebug_lowest_aligned = DEF_LOWEST_ALIGNED;
634static int sdebug_max_luns = DEF_MAX_LUNS;
c4837394 635static int sdebug_max_queue = SDEBUG_CANQUEUE; /* per submit queue */
d9da891a
LO		 636static unsigned int sdebug_medium_error_start = OPT_MEDIUM_ERR_ADDR;
637static int sdebug_medium_error_count = OPT_MEDIUM_ERR_NUM;
cbf67842 638static atomic_t retired_max_queue; /* if > 0 then was prior max_queue */
c2206098 639static int sdebug_ndelay = DEF_NDELAY; /* if > 0 then unit is nanoseconds */
773642d9
DG		 640static int sdebug_no_lun_0 = DEF_NO_LUN_0;
641static int sdebug_no_uld;
642static int sdebug_num_parts = DEF_NUM_PARTS;
643static int sdebug_num_tgts = DEF_NUM_TGTS; /* targets per host */
644static int sdebug_opt_blks = DEF_OPT_BLKS;
645static int sdebug_opts = DEF_OPTS;
646static int sdebug_physblk_exp = DEF_PHYSBLK_EXP;
86e6828a 647static int sdebug_opt_xferlen_exp = DEF_OPT_XFERLEN_EXP;
b01f6f83 648static int sdebug_ptype = DEF_PTYPE; /* SCSI peripheral device type */
773642d9
DG		 649static int sdebug_scsi_level = DEF_SCSI_LEVEL;
650static int sdebug_sector_size = DEF_SECTOR_SIZE;
651static int sdebug_virtual_gb = DEF_VIRTUAL_GB;
652static int sdebug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
653static unsigned int sdebug_lbpu = DEF_LBPU;
654static unsigned int sdebug_lbpws = DEF_LBPWS;
655static unsigned int sdebug_lbpws10 = DEF_LBPWS10;
656static unsigned int sdebug_lbprz = DEF_LBPRZ;
657static unsigned int sdebug_unmap_alignment = DEF_UNMAP_ALIGNMENT;
658static unsigned int sdebug_unmap_granularity = DEF_UNMAP_GRANULARITY;
659static unsigned int sdebug_unmap_max_blocks = DEF_UNMAP_MAX_BLOCKS;
660static unsigned int sdebug_unmap_max_desc = DEF_UNMAP_MAX_DESC;
661static unsigned int sdebug_write_same_length = DEF_WRITESAME_LENGTH;
09ba24c1 662static int sdebug_uuid_ctl = DEF_UUID_CTL;
773642d9
DG		 663static bool sdebug_removable = DEF_REMOVABLE;
664static bool sdebug_clustering;
665static bool sdebug_host_lock = DEF_HOST_LOCK;
666static bool sdebug_strict = DEF_STRICT;
817fd66b 667static bool sdebug_any_injecting_opt;
773642d9 668static bool sdebug_verbose;
f46eb0e9 669static bool have_dif_prot;
c4837394 670static bool sdebug_statistics = DEF_STATISTICS;
1da177e4 671
c65b1445 672static unsigned int sdebug_store_sectors;
1da177e4
LT		 673static sector_t sdebug_capacity; /* in sectors */
674
675/* old BIOS stuff, kernel may get rid of them but some mode sense pages
676 may still need them */
677static int sdebug_heads; /* heads per disk */
678static int sdebug_cylinders_per; /* cylinders per surface */
679static int sdebug_sectors_per; /* sectors per cylinder */
680
1da177e4
LT		 681static LIST_HEAD(sdebug_host_list);
682static DEFINE_SPINLOCK(sdebug_host_list_lock);
683
fd32119b 684static unsigned char *fake_storep; /* ramdisk storage */
6ebf105c 685static struct t10_pi_tuple *dif_storep; /* protection info */
44d92694 686static void *map_storep; /* provisioning map */
1da177e4 687
44d92694 688static unsigned long map_size;
cbf67842
DG		 689static int num_aborts;
690static int num_dev_resets;
691static int num_target_resets;
692static int num_bus_resets;
693static int num_host_resets;
c6a44287
MP		 694static int dix_writes;
695static int dix_reads;
696static int dif_errors;
1da177e4 697
c4837394
DG		 698static int submit_queues = DEF_SUBMIT_QUEUES; /* > 1 for multi-queue (mq) */
699static struct sdebug_queue *sdebug_q_arr; /* ptr to array of submit queues */
fd32119b 700
1da177e4
LT		 701static DEFINE_RWLOCK(atomic_rw);
702
cbf67842
DG		 703static char sdebug_proc_name[] = MY_NAME;
704static const char *my_name = MY_NAME;
1da177e4 705
1da177e4
LT		 706static struct bus_type pseudo_lld_bus;
707
708static struct device_driver sdebug_driverfs_driver = {
709 .name = sdebug_proc_name,
710 .bus = &pseudo_lld_bus,
1da177e4
LT		 711};
712
713static const int check_condition_result =
714 (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
715
c6a44287
MP		 716static const int illegal_condition_result =
717 (DRIVER_SENSE << 24) | (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION;
718
cbf67842
DG		 719static const int device_qfull_result =
720 (DID_OK << 16) | (COMMAND_COMPLETE << 8) | SAM_STAT_TASK_SET_FULL;
721
fd32119b 722
760f3b03
DG		 723/* Only do the extra work involved in logical block provisioning if one or
724 * more of the lbpu, lbpws or lbpws10 parameters are given and we are doing
725 * real reads and writes (i.e. not skipping them for speed).
726 */
727static inline bool scsi_debug_lbp(void)
fd32119b
DG		 728{
729 return 0 == sdebug_fake_rw &&
730 (sdebug_lbpu || sdebug_lbpws || sdebug_lbpws10);
731}
c65b1445 732
14faa944
AM		 733static void *fake_store(unsigned long long lba)
734{
735 lba = do_div(lba, sdebug_store_sectors);
736
773642d9 737 return fake_storep + lba * sdebug_sector_size;
14faa944
AM		 738}
739
6ebf105c 740static struct t10_pi_tuple *dif_store(sector_t sector)
14faa944 741{
49413112 742 sector = sector_div(sector, sdebug_store_sectors);
14faa944
AM		 743
744 return dif_storep + sector;
745}
746
8dea0d02
FT		 747static void sdebug_max_tgts_luns(void)
748{
749 struct sdebug_host_info *sdbg_host;
750 struct Scsi_Host *hpnt;
751
752 spin_lock(&sdebug_host_list_lock);
753 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
754 hpnt = sdbg_host->shost;
755 if ((hpnt->this_id >= 0) &&
773642d9
DG		 756 (sdebug_num_tgts > hpnt->this_id))
757 hpnt->max_id = sdebug_num_tgts + 1;
8dea0d02 758 else
773642d9
DG		 759 hpnt->max_id = sdebug_num_tgts;
760 /* sdebug_max_luns; */
f2d3fd29 761 hpnt->max_lun = SCSI_W_LUN_REPORT_LUNS + 1;
8dea0d02
FT		 762 }
763 spin_unlock(&sdebug_host_list_lock);
764}
765
22017ed2
DG		 766enum sdeb_cmd_data {SDEB_IN_DATA = 0, SDEB_IN_CDB = 1};
767
768/* Set in_bit to -1 to indicate no bit position of invalid field */
fd32119b
DG		 769static void mk_sense_invalid_fld(struct scsi_cmnd *scp,
770 enum sdeb_cmd_data c_d,
771 int in_byte, int in_bit)
22017ed2
DG		 772{
773 unsigned char *sbuff;
774 u8 sks[4];
775 int sl, asc;
776
777 sbuff = scp->sense_buffer;
778 if (!sbuff) {
779 sdev_printk(KERN_ERR, scp->device,
780 "%s: sense_buffer is NULL\n", __func__);
781 return;
782 }
783 asc = c_d ? INVALID_FIELD_IN_CDB : INVALID_FIELD_IN_PARAM_LIST;
784 memset(sbuff, 0, SCSI_SENSE_BUFFERSIZE);
773642d9 785 scsi_build_sense_buffer(sdebug_dsense, sbuff, ILLEGAL_REQUEST, asc, 0);
22017ed2
DG		 786 memset(sks, 0, sizeof(sks));
787 sks[0] = 0x80;
788 if (c_d)
789 sks[0] |= 0x40;
790 if (in_bit >= 0) {
791 sks[0] |= 0x8;
792 sks[0] |= 0x7 & in_bit;
793 }
794 put_unaligned_be16(in_byte, sks + 1);
773642d9 795 if (sdebug_dsense) {
22017ed2
DG		 796 sl = sbuff[7] + 8;
797 sbuff[7] = sl;
798 sbuff[sl] = 0x2;
799 sbuff[sl + 1] = 0x6;
800 memcpy(sbuff + sl + 4, sks, 3);
801 } else
802 memcpy(sbuff + 15, sks, 3);
773642d9 803 if (sdebug_verbose)
22017ed2
DG		 804 sdev_printk(KERN_INFO, scp->device, "%s: [sense_key,asc,ascq"
805 "]: [0x5,0x%x,0x0] %c byte=%d, bit=%d\n",
806 my_name, asc, c_d ? 'C' : 'D', in_byte, in_bit);
807}
808
cbf67842 809static void mk_sense_buffer(struct scsi_cmnd *scp, int key, int asc, int asq)
8dea0d02
FT		 810{
811 unsigned char *sbuff;
812
cbf67842
DG		 813 sbuff = scp->sense_buffer;
814 if (!sbuff) {
815 sdev_printk(KERN_ERR, scp->device,
816 "%s: sense_buffer is NULL\n", __func__);
817 return;
818 }
819 memset(sbuff, 0, SCSI_SENSE_BUFFERSIZE);
8dea0d02 820
773642d9 821 scsi_build_sense_buffer(sdebug_dsense, sbuff, key, asc, asq);
8dea0d02 822
773642d9 823 if (sdebug_verbose)
cbf67842
DG		 824 sdev_printk(KERN_INFO, scp->device,
825 "%s: [sense_key,asc,ascq]: [0x%x,0x%x,0x%x]\n",
826 my_name, key, asc, asq);
8dea0d02 827}
1da177e4 828
fd32119b 829static void mk_sense_invalid_opcode(struct scsi_cmnd *scp)
22017ed2
DG		 830{
831 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
832}
833
1da177e4
LT		 834static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
835{
773642d9 836 if (sdebug_verbose) {
cbf67842
DG		 837 if (0x1261 == cmd)
838 sdev_printk(KERN_INFO, dev,
839 "%s: BLKFLSBUF [0x1261]\n", __func__);
840 else if (0x5331 == cmd)
841 sdev_printk(KERN_INFO, dev,
842 "%s: CDROM_GET_CAPABILITY [0x5331]\n",
843 __func__);
844 else
845 sdev_printk(KERN_INFO, dev, "%s: cmd=0x%x\n",
846 __func__, cmd);
1da177e4
LT		 847 }
848 return -EINVAL;
849 /* return -ENOTTY; // correct return but upsets fdisk */
850}
851
9b760fd8
DG		 852static void config_cdb_len(struct scsi_device *sdev)
853{
854 switch (sdebug_cdb_len) {
855 case 6: /* suggest 6 byte READ, WRITE and MODE SENSE/SELECT */
856 sdev->use_10_for_rw = false;
857 sdev->use_16_for_rw = false;
858 sdev->use_10_for_ms = false;
859 break;
860 case 10: /* suggest 10 byte RWs and 6 byte MODE SENSE/SELECT */
861 sdev->use_10_for_rw = true;
862 sdev->use_16_for_rw = false;
863 sdev->use_10_for_ms = false;
864 break;
865 case 12: /* suggest 10 byte RWs and 10 byte MODE SENSE/SELECT */
866 sdev->use_10_for_rw = true;
867 sdev->use_16_for_rw = false;
868 sdev->use_10_for_ms = true;
869 break;
870 case 16:
871 sdev->use_10_for_rw = false;
872 sdev->use_16_for_rw = true;
873 sdev->use_10_for_ms = true;
874 break;
875 case 32: /* No knobs to suggest this so same as 16 for now */
876 sdev->use_10_for_rw = false;
877 sdev->use_16_for_rw = true;
878 sdev->use_10_for_ms = true;
879 break;
880 default:
881 pr_warn("unexpected cdb_len=%d, force to 10\n",
882 sdebug_cdb_len);
883 sdev->use_10_for_rw = true;
884 sdev->use_16_for_rw = false;
885 sdev->use_10_for_ms = false;
886 sdebug_cdb_len = 10;
887 break;
888 }
889}
890
891static void all_config_cdb_len(void)
892{
893 struct sdebug_host_info *sdbg_host;
894 struct Scsi_Host *shost;
895 struct scsi_device *sdev;
896
897 spin_lock(&sdebug_host_list_lock);
898 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
899 shost = sdbg_host->shost;
900 shost_for_each_device(sdev, shost) {
901 config_cdb_len(sdev);
902 }
903 }
904 spin_unlock(&sdebug_host_list_lock);
905}
906
19c8ead7
EM		 907static void clear_luns_changed_on_target(struct sdebug_dev_info *devip)
908{
909 struct sdebug_host_info *sdhp;
910 struct sdebug_dev_info *dp;
911
912 spin_lock(&sdebug_host_list_lock);
913 list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
914 list_for_each_entry(dp, &sdhp->dev_info_list, dev_list) {
915 if ((devip->sdbg_host == dp->sdbg_host) &&
916 (devip->target == dp->target))
917 clear_bit(SDEBUG_UA_LUNS_CHANGED, dp->uas_bm);
918 }
919 }
920 spin_unlock(&sdebug_host_list_lock);
921}
922
f46eb0e9 923static int make_ua(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
1da177e4 924{
cbf67842 925 int k;
cbf67842
DG		 926
927 k = find_first_bit(devip->uas_bm, SDEBUG_NUM_UAS);
928 if (k != SDEBUG_NUM_UAS) {
929 const char *cp = NULL;
930
931 switch (k) {
932 case SDEBUG_UA_POR:
f46eb0e9
DG		 933 mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
934 POWER_ON_RESET_ASCQ);
773642d9 935 if (sdebug_verbose)
cbf67842
DG		 936 cp = "power on reset";
937 break;
938 case SDEBUG_UA_BUS_RESET:
f46eb0e9
DG		 939 mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
940 BUS_RESET_ASCQ);
773642d9 941 if (sdebug_verbose)
cbf67842
DG		 942 cp = "bus reset";
943 break;
944 case SDEBUG_UA_MODE_CHANGED:
f46eb0e9
DG		 945 mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
946 MODE_CHANGED_ASCQ);
773642d9 947 if (sdebug_verbose)
cbf67842
DG		 948 cp = "mode parameters changed";
949 break;
0d01c5df 950 case SDEBUG_UA_CAPACITY_CHANGED:
f46eb0e9
DG		 951 mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
952 CAPACITY_CHANGED_ASCQ);
773642d9 953 if (sdebug_verbose)
0d01c5df 954 cp = "capacity data changed";
f49accf1 955 break;
acafd0b9 956 case SDEBUG_UA_MICROCODE_CHANGED:
f46eb0e9 957 mk_sense_buffer(scp, UNIT_ATTENTION,
b01f6f83
DG		 958 TARGET_CHANGED_ASC,
959 MICROCODE_CHANGED_ASCQ);
773642d9 960 if (sdebug_verbose)
acafd0b9
EM		 961 cp = "microcode has been changed";
962 break;
963 case SDEBUG_UA_MICROCODE_CHANGED_WO_RESET:
f46eb0e9 964 mk_sense_buffer(scp, UNIT_ATTENTION,
acafd0b9
EM		 965 TARGET_CHANGED_ASC,
966 MICROCODE_CHANGED_WO_RESET_ASCQ);
773642d9 967 if (sdebug_verbose)
acafd0b9
EM		 968 cp = "microcode has been changed without reset";
969 break;
19c8ead7
EM		 970 case SDEBUG_UA_LUNS_CHANGED:
971 /*
972 * SPC-3 behavior is to report a UNIT ATTENTION with
973 * ASC/ASCQ REPORTED LUNS DATA HAS CHANGED on every LUN
974 * on the target, until a REPORT LUNS command is
975 * received. SPC-4 behavior is to report it only once.
773642d9 976 * NOTE: sdebug_scsi_level does not use the same
19c8ead7
EM		 977 * values as struct scsi_device->scsi_level.
978 */
773642d9 979 if (sdebug_scsi_level >= 6) /* SPC-4 and above */
19c8ead7 980 clear_luns_changed_on_target(devip);
f46eb0e9 981 mk_sense_buffer(scp, UNIT_ATTENTION,
19c8ead7
EM		 982 TARGET_CHANGED_ASC,
983 LUNS_CHANGED_ASCQ);
773642d9 984 if (sdebug_verbose)
19c8ead7
EM		 985 cp = "reported luns data has changed";
986 break;
cbf67842 987 default:
773642d9
DG		 988 pr_warn("unexpected unit attention code=%d\n", k);
989 if (sdebug_verbose)
cbf67842
DG		 990 cp = "unknown";
991 break;
992 }
993 clear_bit(k, devip->uas_bm);
773642d9 994 if (sdebug_verbose)
f46eb0e9 995 sdev_printk(KERN_INFO, scp->device,
cbf67842
DG		 996 "%s reports: Unit attention: %s\n",
997 my_name, cp);
1da177e4
LT		 998 return check_condition_result;
999 }
1000 return 0;
1001}
1002
fb0cc8d1 1003/* Build SCSI "data-in" buffer. Returns 0 if ok else (DID_ERROR << 16). */
21a61829 1004static int fill_from_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
1da177e4
LT		 1005 int arr_len)
1006{
21a61829 1007 int act_len;
072d0bb3 1008 struct scsi_data_buffer *sdb = scsi_in(scp);
1da177e4 1009
072d0bb3 1010 if (!sdb->length)
1da177e4 1011 return 0;
072d0bb3 1012 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE))
773642d9 1013 return DID_ERROR << 16;
21a61829
FT		 1014
1015 act_len = sg_copy_from_buffer(sdb->table.sgl, sdb->table.nents,
1016 arr, arr_len);
a4517511 1017 sdb->resid = scsi_bufflen(scp) - act_len;
21a61829 1018
1da177e4
LT		 1019 return 0;
1020}
1021
fb0cc8d1
DG		 1022/* Partial build of SCSI "data-in" buffer. Returns 0 if ok else
1023 * (DID_ERROR << 16). Can write to offset in data-in buffer. If multiple
1024 * calls, not required to write in ascending offset order. Assumes resid
1025 * set to scsi_bufflen() prior to any calls.
1026 */
1027static int p_fill_from_dev_buffer(struct scsi_cmnd *scp, const void *arr,
1028 int arr_len, unsigned int off_dst)
1029{
1030 int act_len, n;
1031 struct scsi_data_buffer *sdb = scsi_in(scp);
1032 off_t skip = off_dst;
1033
1034 if (sdb->length <= off_dst)
1035 return 0;
1036 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE))
1037 return DID_ERROR << 16;
1038
1039 act_len = sg_pcopy_from_buffer(sdb->table.sgl, sdb->table.nents,
1040 arr, arr_len, skip);
1041 pr_debug("%s: off_dst=%u, scsi_bufflen=%u, act_len=%u, resid=%d\n",
1042 __func__, off_dst, scsi_bufflen(scp), act_len, sdb->resid);
1043 n = (int)scsi_bufflen(scp) - ((int)off_dst + act_len);
1044 sdb->resid = min(sdb->resid, n);
1045 return 0;
1046}
1047
1048/* Fetches from SCSI "data-out" buffer. Returns number of bytes fetched into
1049 * 'arr' or -1 if error.
1050 */
21a61829
FT		 1051static int fetch_to_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
1052 int arr_len)
1da177e4 1053{
21a61829 1054 if (!scsi_bufflen(scp))
1da177e4 1055 return 0;
072d0bb3 1056 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_TO_DEVICE))
1da177e4 1057 return -1;
21a61829
FT		 1058
1059 return scsi_sg_copy_to_buffer(scp, arr, arr_len);
1da177e4
LT		 1060}
1061
1062
e5203cf0
HR		 1063static char sdebug_inq_vendor_id[9] = "Linux ";
1064static char sdebug_inq_product_id[17] = "scsi_debug ";
9b760fd8 1065static char sdebug_inq_product_rev[5] = SDEBUG_VERSION;
1b37bd60
DG		 1066/* Use some locally assigned NAAs for SAS addresses. */
1067static const u64 naa3_comp_a = 0x3222222000000000ULL;
1068static const u64 naa3_comp_b = 0x3333333000000000ULL;
1069static const u64 naa3_comp_c = 0x3111111000000000ULL;
1da177e4 1070
cbf67842 1071/* Device identification VPD page. Returns number of bytes placed in arr */
760f3b03
DG		 1072static int inquiry_vpd_83(unsigned char *arr, int port_group_id,
1073 int target_dev_id, int dev_id_num,
09ba24c1 1074 const char *dev_id_str, int dev_id_str_len,
bf476433 1075 const uuid_t *lu_name)
1da177e4 1076{
c65b1445
DG		 1077 int num, port_a;
1078 char b[32];
1da177e4 1079
c65b1445 1080 port_a = target_dev_id + 1;
1da177e4
LT		 1081 /* T10 vendor identifier field format (faked) */
1082 arr[0] = 0x2; /* ASCII */
1083 arr[1] = 0x1;
1084 arr[2] = 0x0;
e5203cf0
HR		 1085 memcpy(&arr[4], sdebug_inq_vendor_id, 8);
1086 memcpy(&arr[12], sdebug_inq_product_id, 16);
1da177e4
LT		 1087 memcpy(&arr[28], dev_id_str, dev_id_str_len);
1088 num = 8 + 16 + dev_id_str_len;
1089 arr[3] = num;
1090 num += 4;
c65b1445 1091 if (dev_id_num >= 0) {
09ba24c1
DG		 1092 if (sdebug_uuid_ctl) {
1093 /* Locally assigned UUID */
1094 arr[num++] = 0x1; /* binary (not necessarily sas) */
1095 arr[num++] = 0xa; /* PIV=0, lu, naa */
1096 arr[num++] = 0x0;
1097 arr[num++] = 0x12;
1098 arr[num++] = 0x10; /* uuid type=1, locally assigned */
1099 arr[num++] = 0x0;
1100 memcpy(arr + num, lu_name, 16);
1101 num += 16;
1102 } else {
1b37bd60 1103 /* NAA-3, Logical unit identifier (binary) */
09ba24c1
DG		 1104 arr[num++] = 0x1; /* binary (not necessarily sas) */
1105 arr[num++] = 0x3; /* PIV=0, lu, naa */
1106 arr[num++] = 0x0;
1107 arr[num++] = 0x8;
1b37bd60 1108 put_unaligned_be64(naa3_comp_b + dev_id_num, arr + num);
09ba24c1
DG		 1109 num += 8;
1110 }
c65b1445
DG		 1111 /* Target relative port number */
1112 arr[num++] = 0x61; /* proto=sas, binary */
1113 arr[num++] = 0x94; /* PIV=1, target port, rel port */
1114 arr[num++] = 0x0; /* reserved */
1115 arr[num++] = 0x4; /* length */
1116 arr[num++] = 0x0; /* reserved */
1117 arr[num++] = 0x0; /* reserved */
1118 arr[num++] = 0x0;
1119 arr[num++] = 0x1; /* relative port A */
1120 }
1b37bd60 1121 /* NAA-3, Target port identifier */
c65b1445
DG		 1122 arr[num++] = 0x61; /* proto=sas, binary */
1123 arr[num++] = 0x93; /* piv=1, target port, naa */
1124 arr[num++] = 0x0;
1125 arr[num++] = 0x8;
1b37bd60 1126 put_unaligned_be64(naa3_comp_a + port_a, arr + num);
773642d9 1127 num += 8;
1b37bd60 1128 /* NAA-3, Target port group identifier */
5a09e398
HR		 1129 arr[num++] = 0x61; /* proto=sas, binary */
1130 arr[num++] = 0x95; /* piv=1, target port group id */
1131 arr[num++] = 0x0;
1132 arr[num++] = 0x4;
1133 arr[num++] = 0;
1134 arr[num++] = 0;
773642d9
DG		 1135 put_unaligned_be16(port_group_id, arr + num);
1136 num += 2;
1b37bd60 1137 /* NAA-3, Target device identifier */
c65b1445
DG		 1138 arr[num++] = 0x61; /* proto=sas, binary */
1139 arr[num++] = 0xa3; /* piv=1, target device, naa */
1140 arr[num++] = 0x0;
1141 arr[num++] = 0x8;
1b37bd60 1142 put_unaligned_be64(naa3_comp_a + target_dev_id, arr + num);
773642d9 1143 num += 8;
c65b1445
DG		 1144 /* SCSI name string: Target device identifier */
1145 arr[num++] = 0x63; /* proto=sas, UTF-8 */
1146 arr[num++] = 0xa8; /* piv=1, target device, SCSI name string */
1147 arr[num++] = 0x0;
1148 arr[num++] = 24;
1b37bd60 1149 memcpy(arr + num, "naa.32222220", 12);
c65b1445
DG		 1150 num += 12;
1151 snprintf(b, sizeof(b), "%08X", target_dev_id);
1152 memcpy(arr + num, b, 8);
1153 num += 8;
1154 memset(arr + num, 0, 4);
1155 num += 4;
1156 return num;
1157}
1158
c65b1445
DG		 1159static unsigned char vpd84_data[] = {
1160/* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
1161 0x22,0x22,0x22,0x0,0xbb,0x1,
1162 0x22,0x22,0x22,0x0,0xbb,0x2,
1163};
1164
cbf67842 1165/* Software interface identification VPD page */
760f3b03 1166static int inquiry_vpd_84(unsigned char *arr)
c65b1445
DG		 1167{
1168 memcpy(arr, vpd84_data, sizeof(vpd84_data));
1169 return sizeof(vpd84_data);
1170}
1171
cbf67842 1172/* Management network addresses VPD page */
760f3b03 1173static int inquiry_vpd_85(unsigned char *arr)
c65b1445
DG		 1174{
1175 int num = 0;
91d4c752
JP		 1176 const char *na1 = "https://www.kernel.org/config";
1177 const char *na2 = "http://www.kernel.org/log";
c65b1445
DG		 1178 int plen, olen;
1179
1180 arr[num++] = 0x1; /* lu, storage config */
1181 arr[num++] = 0x0; /* reserved */
1182 arr[num++] = 0x0;
1183 olen = strlen(na1);
1184 plen = olen + 1;
1185 if (plen % 4)
1186 plen = ((plen / 4) + 1) * 4;
1187 arr[num++] = plen; /* length, null termianted, padded */
1188 memcpy(arr + num, na1, olen);
1189 memset(arr + num + olen, 0, plen - olen);
1190 num += plen;
1191
1192 arr[num++] = 0x4; /* lu, logging */
1193 arr[num++] = 0x0; /* reserved */
1194 arr[num++] = 0x0;
1195 olen = strlen(na2);
1196 plen = olen + 1;
1197 if (plen % 4)
1198 plen = ((plen / 4) + 1) * 4;
1199 arr[num++] = plen; /* length, null terminated, padded */
1200 memcpy(arr + num, na2, olen);
1201 memset(arr + num + olen, 0, plen - olen);
1202 num += plen;
1203
1204 return num;
1205}
1206
1207/* SCSI ports VPD page */
760f3b03 1208static int inquiry_vpd_88(unsigned char *arr, int target_dev_id)
c65b1445
DG		 1209{
1210 int num = 0;
1211 int port_a, port_b;
1212
1213 port_a = target_dev_id + 1;
1214 port_b = port_a + 1;
1215 arr[num++] = 0x0; /* reserved */
1216 arr[num++] = 0x0; /* reserved */
1217 arr[num++] = 0x0;
1218 arr[num++] = 0x1; /* relative port 1 (primary) */
1219 memset(arr + num, 0, 6);
1220 num += 6;
1221 arr[num++] = 0x0;
1222 arr[num++] = 12; /* length tp descriptor */
1223 /* naa-5 target port identifier (A) */
1224 arr[num++] = 0x61; /* proto=sas, binary */
1225 arr[num++] = 0x93; /* PIV=1, target port, NAA */
1226 arr[num++] = 0x0; /* reserved */
1227 arr[num++] = 0x8; /* length */
1b37bd60 1228 put_unaligned_be64(naa3_comp_a + port_a, arr + num);
773642d9 1229 num += 8;
c65b1445
DG		 1230 arr[num++] = 0x0; /* reserved */
1231 arr[num++] = 0x0; /* reserved */
1232 arr[num++] = 0x0;
1233 arr[num++] = 0x2; /* relative port 2 (secondary) */
1234 memset(arr + num, 0, 6);
1235 num += 6;
1236 arr[num++] = 0x0;
1237 arr[num++] = 12; /* length tp descriptor */
1238 /* naa-5 target port identifier (B) */
1239 arr[num++] = 0x61; /* proto=sas, binary */
1240 arr[num++] = 0x93; /* PIV=1, target port, NAA */
1241 arr[num++] = 0x0; /* reserved */
1242 arr[num++] = 0x8; /* length */
1b37bd60 1243 put_unaligned_be64(naa3_comp_a + port_b, arr + num);
773642d9 1244 num += 8;
c65b1445
DG		 1245
1246 return num;
1247}
1248
1249
1250static unsigned char vpd89_data[] = {
1251/* from 4th byte */ 0,0,0,0,
1252'l','i','n','u','x',' ',' ',' ',
1253'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
1254'1','2','3','4',
12550x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
12560xec,0,0,0,
12570x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
12580,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
12590x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
12600x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
12610x53,0x41,
12620x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
12630x20,0x20,
12640x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
12650x10,0x80,
12660,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
12670x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
12680x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
12690,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
12700x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
12710x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
12720,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
12730,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12740,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12750,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12760x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
12770,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
12780xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
12790,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
12800,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12810,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12820,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12830,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12840,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12850,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12860,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12870,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12880,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12890,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12900,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
12910,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
1292};
1293
cbf67842 1294/* ATA Information VPD page */
760f3b03 1295static int inquiry_vpd_89(unsigned char *arr)
c65b1445
DG		 1296{
1297 memcpy(arr, vpd89_data, sizeof(vpd89_data));
1298 return sizeof(vpd89_data);
1299}
1300
1301
1302static unsigned char vpdb0_data[] = {
1e49f785
DG		 1303 /* from 4th byte */ 0,0,0,4, 0,0,0x4,0, 0,0,0,64,
1304 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1305 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1306 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
c65b1445
DG		 1307};
1308
cbf67842 1309/* Block limits VPD page (SBC-3) */
760f3b03 1310static int inquiry_vpd_b0(unsigned char *arr)
c65b1445 1311{
ea61fca5
MP		 1312 unsigned int gran;
1313
c65b1445 1314 memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
e308b3d1
MP		 1315
1316 /* Optimal transfer length granularity */
86e6828a
LH		 1317 if (sdebug_opt_xferlen_exp != 0 &&
1318 sdebug_physblk_exp < sdebug_opt_xferlen_exp)
1319 gran = 1 << sdebug_opt_xferlen_exp;
1320 else
1321 gran = 1 << sdebug_physblk_exp;
773642d9 1322 put_unaligned_be16(gran, arr + 2);
e308b3d1
MP		 1323
1324 /* Maximum Transfer Length */
773642d9
DG		 1325 if (sdebug_store_sectors > 0x400)
1326 put_unaligned_be32(sdebug_store_sectors, arr + 4);
44d92694 1327
e308b3d1 1328 /* Optimal Transfer Length */
773642d9 1329 put_unaligned_be32(sdebug_opt_blks, &arr[8]);
e308b3d1 1330
773642d9 1331 if (sdebug_lbpu) {
e308b3d1 1332 /* Maximum Unmap LBA Count */
773642d9 1333 put_unaligned_be32(sdebug_unmap_max_blocks, &arr[16]);
e308b3d1
MP		 1334
1335 /* Maximum Unmap Block Descriptor Count */
773642d9 1336 put_unaligned_be32(sdebug_unmap_max_desc, &arr[20]);
44d92694
MP		 1337 }
1338
e308b3d1 1339 /* Unmap Granularity Alignment */
773642d9
DG		 1340 if (sdebug_unmap_alignment) {
1341 put_unaligned_be32(sdebug_unmap_alignment, &arr[28]);
44d92694
MP		 1342 arr[28] |= 0x80; /* UGAVALID */
1343 }
1344
e308b3d1 1345 /* Optimal Unmap Granularity */
773642d9 1346 put_unaligned_be32(sdebug_unmap_granularity, &arr[24]);
6014759c 1347
5b94e232 1348 /* Maximum WRITE SAME Length */
773642d9 1349 put_unaligned_be64(sdebug_write_same_length, &arr[32]);
5b94e232
MP		 1350
1351 return 0x3c; /* Mandatory page length for Logical Block Provisioning */
44d92694 1352
c65b1445 1353 return sizeof(vpdb0_data);
1da177e4
LT		 1354}
1355
1e49f785 1356/* Block device characteristics VPD page (SBC-3) */
760f3b03 1357static int inquiry_vpd_b1(unsigned char *arr)
eac6e8e4
MW		 1358{
1359 memset(arr, 0, 0x3c);
1360 arr[0] = 0;
1e49f785
DG		 1361 arr[1] = 1; /* non rotating medium (e.g. solid state) */
1362 arr[2] = 0;
1363 arr[3] = 5; /* less than 1.8" */
eac6e8e4
MW		 1364
1365 return 0x3c;
1366}
1da177e4 1367
760f3b03
DG		 1368/* Logical block provisioning VPD page (SBC-4) */
1369static int inquiry_vpd_b2(unsigned char *arr)
6014759c 1370{
3f0bc3b3 1371 memset(arr, 0, 0x4);
6014759c 1372 arr[0] = 0; /* threshold exponent */
773642d9 1373 if (sdebug_lbpu)
6014759c 1374 arr[1] = 1 << 7;
773642d9 1375 if (sdebug_lbpws)
6014759c 1376 arr[1] |= 1 << 6;
773642d9 1377 if (sdebug_lbpws10)
5b94e232 1378 arr[1] |= 1 << 5;
760f3b03
DG		 1379 if (sdebug_lbprz && scsi_debug_lbp())
1380 arr[1] |= (sdebug_lbprz & 0x7) << 2; /* sbc4r07 and later */
1381 /* anc_sup=0; dp=0 (no provisioning group descriptor) */
1382 /* minimum_percentage=0; provisioning_type=0 (unknown) */
1383 /* threshold_percentage=0 */
3f0bc3b3 1384 return 0x4;
6014759c
MP		 1385}
1386
1da177e4 1387#define SDEBUG_LONG_INQ_SZ 96
c65b1445 1388#define SDEBUG_MAX_INQ_ARR_SZ 584
1da177e4 1389
c2248fc9 1390static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
1da177e4
LT		 1391{
1392 unsigned char pq_pdt;
91d4c752 1393 unsigned char *arr;
01123ef4 1394 unsigned char *cmd = scp->cmnd;
5a09e398 1395 int alloc_len, n, ret;
760f3b03 1396 bool have_wlun, is_disk;
1da177e4 1397
773642d9 1398 alloc_len = get_unaligned_be16(cmd + 3);
6f3cbf55
DG		 1399 arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
1400 if (! arr)
1401 return DID_REQUEUE << 16;
760f3b03 1402 is_disk = (sdebug_ptype == TYPE_DISK);
b01f6f83 1403 have_wlun = scsi_is_wlun(scp->device->lun);
c2248fc9 1404 if (have_wlun)
b01f6f83
DG		 1405 pq_pdt = TYPE_WLUN; /* present, wlun */
1406 else if (sdebug_no_lun_0 && (devip->lun == SDEBUG_LUN_0_VAL))
1407 pq_pdt = 0x7f; /* not present, PQ=3, PDT=0x1f */
c65b1445 1408 else
773642d9 1409 pq_pdt = (sdebug_ptype & 0x1f);
1da177e4
LT		 1410 arr[0] = pq_pdt;
1411 if (0x2 & cmd[1]) { /* CMDDT bit set */
22017ed2 1412 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 1);
5a09e398 1413 kfree(arr);
1da177e4
LT		 1414 return check_condition_result;
1415 } else if (0x1 & cmd[1]) { /* EVPD bit set */
5a09e398 1416 int lu_id_num, port_group_id, target_dev_id, len;
c65b1445
DG		 1417 char lu_id_str[6];
1418 int host_no = devip->sdbg_host->shost->host_no;
1da177e4 1419
5a09e398
HR		 1420 port_group_id = (((host_no + 1) & 0x7f) << 8) +
1421 (devip->channel & 0x7f);
b01f6f83 1422 if (sdebug_vpd_use_hostno == 0)
23183910 1423 host_no = 0;
c2248fc9 1424 lu_id_num = have_wlun ? -1 : (((host_no + 1) * 2000) +
c65b1445
DG		 1425 (devip->target * 1000) + devip->lun);
1426 target_dev_id = ((host_no + 1) * 2000) +
1427 (devip->target * 1000) - 3;
1428 len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
1da177e4 1429 if (0 == cmd[2]) { /* supported vital product data pages */
c65b1445
DG		 1430 arr[1] = cmd[2]; /*sanity */
1431 n = 4;
1432 arr[n++] = 0x0; /* this page */
1433 arr[n++] = 0x80; /* unit serial number */
1434 arr[n++] = 0x83; /* device identification */
1435 arr[n++] = 0x84; /* software interface ident. */
1436 arr[n++] = 0x85; /* management network addresses */
1437 arr[n++] = 0x86; /* extended inquiry */
1438 arr[n++] = 0x87; /* mode page policy */
1439 arr[n++] = 0x88; /* SCSI ports */
760f3b03
DG		 1440 if (is_disk) { /* SBC only */
1441 arr[n++] = 0x89; /* ATA information */
1442 arr[n++] = 0xb0; /* Block limits */
1443 arr[n++] = 0xb1; /* Block characteristics */
1444 arr[n++] = 0xb2; /* Logical Block Prov */
1445 }
c65b1445 1446 arr[3] = n - 4; /* number of supported VPD pages */
1da177e4 1447 } else if (0x80 == cmd[2]) { /* unit serial number */
c65b1445 1448 arr[1] = cmd[2]; /*sanity */
1da177e4 1449 arr[3] = len;
c65b1445 1450 memcpy(&arr[4], lu_id_str, len);
1da177e4 1451 } else if (0x83 == cmd[2]) { /* device identification */
c65b1445 1452 arr[1] = cmd[2]; /*sanity */
760f3b03
DG		 1453 arr[3] = inquiry_vpd_83(&arr[4], port_group_id,
1454 target_dev_id, lu_id_num,
09ba24c1
DG		 1455 lu_id_str, len,
1456 &devip->lu_name);
c65b1445
DG		 1457 } else if (0x84 == cmd[2]) { /* Software interface ident. */
1458 arr[1] = cmd[2]; /*sanity */
760f3b03 1459 arr[3] = inquiry_vpd_84(&arr[4]);
c65b1445
DG		 1460 } else if (0x85 == cmd[2]) { /* Management network addresses */
1461 arr[1] = cmd[2]; /*sanity */
760f3b03 1462 arr[3] = inquiry_vpd_85(&arr[4]);
c65b1445
DG		 1463 } else if (0x86 == cmd[2]) { /* extended inquiry */
1464 arr[1] = cmd[2]; /*sanity */
1465 arr[3] = 0x3c; /* number of following entries */
8475c811 1466 if (sdebug_dif == T10_PI_TYPE3_PROTECTION)
c6a44287 1467 arr[4] = 0x4; /* SPT: GRD_CHK:1 */
760f3b03 1468 else if (have_dif_prot)
c6a44287
MP		 1469 arr[4] = 0x5; /* SPT: GRD_CHK:1, REF_CHK:1 */
1470 else
1471 arr[4] = 0x0; /* no protection stuff */
c65b1445
DG		 1472 arr[5] = 0x7; /* head of q, ordered + simple q's */
1473 } else if (0x87 == cmd[2]) { /* mode page policy */
1474 arr[1] = cmd[2]; /*sanity */
1475 arr[3] = 0x8; /* number of following entries */
1476 arr[4] = 0x2; /* disconnect-reconnect mp */
1477 arr[6] = 0x80; /* mlus, shared */
1478 arr[8] = 0x18; /* protocol specific lu */
1479 arr[10] = 0x82; /* mlus, per initiator port */
1480 } else if (0x88 == cmd[2]) { /* SCSI Ports */
1481 arr[1] = cmd[2]; /*sanity */
760f3b03
DG		 1482 arr[3] = inquiry_vpd_88(&arr[4], target_dev_id);
1483 } else if (is_disk && 0x89 == cmd[2]) { /* ATA information */
c65b1445 1484 arr[1] = cmd[2]; /*sanity */
760f3b03 1485 n = inquiry_vpd_89(&arr[4]);
773642d9 1486 put_unaligned_be16(n, arr + 2);
760f3b03 1487 } else if (is_disk && 0xb0 == cmd[2]) { /* Block limits */
c65b1445 1488 arr[1] = cmd[2]; /*sanity */
760f3b03
DG		 1489 arr[3] = inquiry_vpd_b0(&arr[4]);
1490 } else if (is_disk && 0xb1 == cmd[2]) { /* Block char. */
eac6e8e4 1491 arr[1] = cmd[2]; /*sanity */
760f3b03
DG		 1492 arr[3] = inquiry_vpd_b1(&arr[4]);
1493 } else if (is_disk && 0xb2 == cmd[2]) { /* LB Prov. */
6014759c 1494 arr[1] = cmd[2]; /*sanity */
760f3b03 1495 arr[3] = inquiry_vpd_b2(&arr[4]);
1da177e4 1496 } else {
22017ed2 1497 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, -1);
5a09e398 1498 kfree(arr);
1da177e4
LT		 1499 return check_condition_result;
1500 }
773642d9 1501 len = min(get_unaligned_be16(arr + 2) + 4, alloc_len);
5a09e398 1502 ret = fill_from_dev_buffer(scp, arr,
c65b1445 1503 min(len, SDEBUG_MAX_INQ_ARR_SZ));
5a09e398
HR		 1504 kfree(arr);
1505 return ret;
1da177e4
LT		 1506 }
1507 /* drops through here for a standard inquiry */
773642d9
DG		 1508 arr[1] = sdebug_removable ? 0x80 : 0; /* Removable disk */
1509 arr[2] = sdebug_scsi_level;
1da177e4
LT		 1510 arr[3] = 2; /* response_data_format==2 */
1511 arr[4] = SDEBUG_LONG_INQ_SZ - 5;
f46eb0e9 1512 arr[5] = (int)have_dif_prot; /* PROTECT bit */
b01f6f83 1513 if (sdebug_vpd_use_hostno == 0)
70bdf202 1514 arr[5] |= 0x10; /* claim: implicit TPGS */
c65b1445 1515 arr[6] = 0x10; /* claim: MultiP */
1da177e4 1516 /* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
c65b1445 1517 arr[7] = 0xa; /* claim: LINKED + CMDQUE */
e5203cf0
HR		 1518 memcpy(&arr[8], sdebug_inq_vendor_id, 8);
1519 memcpy(&arr[16], sdebug_inq_product_id, 16);
1520 memcpy(&arr[32], sdebug_inq_product_rev, 4);
9b760fd8
DG		 1521 /* Use Vendor Specific area to place driver date in ASCII hex */
1522 memcpy(&arr[36], sdebug_version_date, 8);
1da177e4 1523 /* version descriptors (2 bytes each) follow */
760f3b03
DG		 1524 put_unaligned_be16(0xc0, arr + 58); /* SAM-6 no version claimed */
1525 put_unaligned_be16(0x5c0, arr + 60); /* SPC-5 no version claimed */
c65b1445 1526 n = 62;
760f3b03
DG		 1527 if (is_disk) { /* SBC-4 no version claimed */
1528 put_unaligned_be16(0x600, arr + n);
1529 n += 2;
1530 } else if (sdebug_ptype == TYPE_TAPE) { /* SSC-4 rev 3 */
1531 put_unaligned_be16(0x525, arr + n);
1532 n += 2;
1da177e4 1533 }
760f3b03 1534 put_unaligned_be16(0x2100, arr + n); /* SPL-4 no version claimed */
5a09e398 1535 ret = fill_from_dev_buffer(scp, arr,
1da177e4 1536 min(alloc_len, SDEBUG_LONG_INQ_SZ));
5a09e398
HR		 1537 kfree(arr);
1538 return ret;
1da177e4
LT		 1539}
1540
fd32119b
DG		 1541static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1542 0, 0, 0x0, 0x0};
1543
91d4c752
JP		 1544static int resp_requests(struct scsi_cmnd *scp,
1545 struct sdebug_dev_info *devip)
1da177e4 1546{
91d4c752 1547 unsigned char *sbuff;
01123ef4 1548 unsigned char *cmd = scp->cmnd;
cbf67842 1549 unsigned char arr[SCSI_SENSE_BUFFERSIZE];
2492fc09 1550 bool dsense;
1da177e4
LT		 1551 int len = 18;
1552
c65b1445 1553 memset(arr, 0, sizeof(arr));
c2248fc9 1554 dsense = !!(cmd[1] & 1);
cbf67842 1555 sbuff = scp->sense_buffer;
c65b1445 1556 if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
c2248fc9 1557 if (dsense) {
c65b1445
DG		 1558 arr[0] = 0x72;
1559 arr[1] = 0x0; /* NO_SENSE in sense_key */
1560 arr[2] = THRESHOLD_EXCEEDED;
1561 arr[3] = 0xff; /* TEST set and MRIE==6 */
c2248fc9 1562 len = 8;
c65b1445
DG		 1563 } else {
1564 arr[0] = 0x70;
1565 arr[2] = 0x0; /* NO_SENSE in sense_key */
1566 arr[7] = 0xa; /* 18 byte sense buffer */
1567 arr[12] = THRESHOLD_EXCEEDED;
1568 arr[13] = 0xff; /* TEST set and MRIE==6 */
1569 }
c65b1445 1570 } else {
cbf67842 1571 memcpy(arr, sbuff, SCSI_SENSE_BUFFERSIZE);
773642d9 1572 if (arr[0] >= 0x70 && dsense == sdebug_dsense)
c2248fc9
DG		 1573 ; /* have sense and formats match */
1574 else if (arr[0] <= 0x70) {
1575 if (dsense) {
1576 memset(arr, 0, 8);
1577 arr[0] = 0x72;
1578 len = 8;
1579 } else {
1580 memset(arr, 0, 18);
1581 arr[0] = 0x70;
1582 arr[7] = 0xa;
1583 }
1584 } else if (dsense) {
1585 memset(arr, 0, 8);
c65b1445
DG		 1586 arr[0] = 0x72;
1587 arr[1] = sbuff[2]; /* sense key */
1588 arr[2] = sbuff[12]; /* asc */
1589 arr[3] = sbuff[13]; /* ascq */
1590 len = 8;
c2248fc9
DG		 1591 } else {
1592 memset(arr, 0, 18);
1593 arr[0] = 0x70;
1594 arr[2] = sbuff[1];
1595 arr[7] = 0xa;
1596 arr[12] = sbuff[1];
1597 arr[13] = sbuff[3];
c65b1445 1598 }
c2248fc9 1599
c65b1445 1600 }
cbf67842 1601 mk_sense_buffer(scp, 0, NO_ADDITIONAL_SENSE, 0);
1da177e4
LT		 1602 return fill_from_dev_buffer(scp, arr, len);
1603}
1604
91d4c752
JP		 1605static int resp_start_stop(struct scsi_cmnd *scp,
1606 struct sdebug_dev_info *devip)
c65b1445 1607{
01123ef4 1608 unsigned char *cmd = scp->cmnd;
c4837394 1609 int power_cond, stop;
c65b1445 1610
c65b1445
DG		 1611 power_cond = (cmd[4] & 0xf0) >> 4;
1612 if (power_cond) {
22017ed2 1613 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, 7);
c65b1445
DG		 1614 return check_condition_result;
1615 }
c4837394
DG		 1616 stop = !(cmd[4] & 1);
1617 atomic_xchg(&devip->stopped, stop);
80c49563 1618 return (cmd[1] & 0x1) ? SDEG_RES_IMMED_MASK : 0; /* check IMMED bit */
c65b1445
DG		 1619}
1620
28898873
FT		 1621static sector_t get_sdebug_capacity(void)
1622{
773642d9
DG		 1623 static const unsigned int gibibyte = 1073741824;
1624
1625 if (sdebug_virtual_gb > 0)
1626 return (sector_t)sdebug_virtual_gb *
1627 (gibibyte / sdebug_sector_size);
28898873
FT		 1628 else
1629 return sdebug_store_sectors;
1630}
1631
1da177e4 1632#define SDEBUG_READCAP_ARR_SZ 8
91d4c752
JP		 1633static int resp_readcap(struct scsi_cmnd *scp,
1634 struct sdebug_dev_info *devip)
1da177e4
LT		 1635{
1636 unsigned char arr[SDEBUG_READCAP_ARR_SZ];
c65b1445 1637 unsigned int capac;
1da177e4 1638
c65b1445 1639 /* following just in case virtual_gb changed */
28898873 1640 sdebug_capacity = get_sdebug_capacity();
1da177e4 1641 memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
c65b1445
DG		 1642 if (sdebug_capacity < 0xffffffff) {
1643 capac = (unsigned int)sdebug_capacity - 1;
773642d9
DG		 1644 put_unaligned_be32(capac, arr + 0);
1645 } else
1646 put_unaligned_be32(0xffffffff, arr + 0);
1647 put_unaligned_be16(sdebug_sector_size, arr + 6);
1da177e4
LT		 1648 return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
1649}
1650
c65b1445 1651#define SDEBUG_READCAP16_ARR_SZ 32
91d4c752
JP		 1652static int resp_readcap16(struct scsi_cmnd *scp,
1653 struct sdebug_dev_info *devip)
c65b1445 1654{
01123ef4 1655 unsigned char *cmd = scp->cmnd;
c65b1445 1656 unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
773642d9 1657 int alloc_len;
c65b1445 1658
773642d9 1659 alloc_len = get_unaligned_be32(cmd + 10);
c65b1445 1660 /* following just in case virtual_gb changed */
28898873 1661 sdebug_capacity = get_sdebug_capacity();
c65b1445 1662 memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
773642d9
DG		 1663 put_unaligned_be64((u64)(sdebug_capacity - 1), arr + 0);
1664 put_unaligned_be32(sdebug_sector_size, arr + 8);
1665 arr[13] = sdebug_physblk_exp & 0xf;
1666 arr[14] = (sdebug_lowest_aligned >> 8) & 0x3f;
44d92694 1667
be1dd78d 1668 if (scsi_debug_lbp()) {
5b94e232 1669 arr[14] |= 0x80; /* LBPME */
760f3b03
DG		 1670 /* from sbc4r07, this LBPRZ field is 1 bit, but the LBPRZ in
1671 * the LB Provisioning VPD page is 3 bits. Note that lbprz=2
1672 * in the wider field maps to 0 in this field.
1673 */
1674 if (sdebug_lbprz & 1) /* precisely what the draft requires */
1675 arr[14] |= 0x40;
be1dd78d 1676 }
44d92694 1677
773642d9 1678 arr[15] = sdebug_lowest_aligned & 0xff;
c6a44287 1679
760f3b03 1680 if (have_dif_prot) {
773642d9 1681 arr[12] = (sdebug_dif - 1) << 1; /* P_TYPE */
c6a44287
MP		 1682 arr[12] |= 1; /* PROT_EN */
1683 }
1684
c65b1445
DG		 1685 return fill_from_dev_buffer(scp, arr,
1686 min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
1687}
1688
5a09e398
HR		 1689#define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
1690
91d4c752
JP		 1691static int resp_report_tgtpgs(struct scsi_cmnd *scp,
1692 struct sdebug_dev_info *devip)
5a09e398 1693{
01123ef4 1694 unsigned char *cmd = scp->cmnd;
91d4c752 1695 unsigned char *arr;
5a09e398
HR		 1696 int host_no = devip->sdbg_host->shost->host_no;
1697 int n, ret, alen, rlen;
1698 int port_group_a, port_group_b, port_a, port_b;
1699
773642d9 1700 alen = get_unaligned_be32(cmd + 6);
6f3cbf55
DG		 1701 arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
1702 if (! arr)
1703 return DID_REQUEUE << 16;
5a09e398
HR		 1704 /*
1705 * EVPD page 0x88 states we have two ports, one
1706 * real and a fake port with no device connected.
1707 * So we create two port groups with one port each
1708 * and set the group with port B to unavailable.
1709 */
1710 port_a = 0x1; /* relative port A */
1711 port_b = 0x2; /* relative port B */
1712 port_group_a = (((host_no + 1) & 0x7f) << 8) +
773642d9 1713 (devip->channel & 0x7f);
5a09e398 1714 port_group_b = (((host_no + 1) & 0x7f) << 8) +
773642d9 1715 (devip->channel & 0x7f) + 0x80;
5a09e398
HR		 1716
1717 /*
1718 * The asymmetric access state is cycled according to the host_id.
1719 */
1720 n = 4;
b01f6f83 1721 if (sdebug_vpd_use_hostno == 0) {
773642d9
DG		 1722 arr[n++] = host_no % 3; /* Asymm access state */
1723 arr[n++] = 0x0F; /* claim: all states are supported */
5a09e398 1724 } else {
773642d9
DG		 1725 arr[n++] = 0x0; /* Active/Optimized path */
1726 arr[n++] = 0x01; /* only support active/optimized paths */
5a09e398 1727 }
773642d9
DG		 1728 put_unaligned_be16(port_group_a, arr + n);
1729 n += 2;
5a09e398
HR		 1730 arr[n++] = 0; /* Reserved */
1731 arr[n++] = 0; /* Status code */
1732 arr[n++] = 0; /* Vendor unique */
1733 arr[n++] = 0x1; /* One port per group */
1734 arr[n++] = 0; /* Reserved */
1735 arr[n++] = 0; /* Reserved */
773642d9
DG		 1736 put_unaligned_be16(port_a, arr + n);
1737 n += 2;
5a09e398
HR		 1738 arr[n++] = 3; /* Port unavailable */
1739 arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
773642d9
DG		 1740 put_unaligned_be16(port_group_b, arr + n);
1741 n += 2;
5a09e398
HR		 1742 arr[n++] = 0; /* Reserved */
1743 arr[n++] = 0; /* Status code */
1744 arr[n++] = 0; /* Vendor unique */
1745 arr[n++] = 0x1; /* One port per group */
1746 arr[n++] = 0; /* Reserved */
1747 arr[n++] = 0; /* Reserved */
773642d9
DG		 1748 put_unaligned_be16(port_b, arr + n);
1749 n += 2;
5a09e398
HR		 1750
1751 rlen = n - 4;
773642d9 1752 put_unaligned_be32(rlen, arr + 0);
5a09e398
HR		 1753
1754 /*
1755 * Return the smallest value of either
1756 * - The allocated length
1757 * - The constructed command length
1758 * - The maximum array size
1759 */
1760 rlen = min(alen,n);
1761 ret = fill_from_dev_buffer(scp, arr,
1762 min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
1763 kfree(arr);
1764 return ret;
1765}
1766
fd32119b
DG		 1767static int resp_rsup_opcodes(struct scsi_cmnd *scp,
1768 struct sdebug_dev_info *devip)
38d5c833
DG		 1769{
1770 bool rctd;
1771 u8 reporting_opts, req_opcode, sdeb_i, supp;
1772 u16 req_sa, u;
1773 u32 alloc_len, a_len;
1774 int k, offset, len, errsts, count, bump, na;
1775 const struct opcode_info_t *oip;
1776 const struct opcode_info_t *r_oip;
1777 u8 *arr;
1778 u8 *cmd = scp->cmnd;
1779
1780 rctd = !!(cmd[2] & 0x80);
1781 reporting_opts = cmd[2] & 0x7;
1782 req_opcode = cmd[3];
1783 req_sa = get_unaligned_be16(cmd + 4);
1784 alloc_len = get_unaligned_be32(cmd + 6);
6d310dfb 1785 if (alloc_len < 4 || alloc_len > 0xffff) {
38d5c833
DG		 1786 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
1787 return check_condition_result;
1788 }
1789 if (alloc_len > 8192)
1790 a_len = 8192;
1791 else
1792 a_len = alloc_len;
99531e60 1793 arr = kzalloc((a_len < 256) ? 320 : a_len + 64, GFP_ATOMIC);
38d5c833
DG		 1794 if (NULL == arr) {
1795 mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
1796 INSUFF_RES_ASCQ);
1797 return check_condition_result;
1798 }
1799 switch (reporting_opts) {
1800 case 0: /* all commands */
1801 /* count number of commands */
1802 for (count = 0, oip = opcode_info_arr;
1803 oip->num_attached != 0xff; ++oip) {
1804 if (F_INV_OP & oip->flags)
1805 continue;
1806 count += (oip->num_attached + 1);
1807 }
1808 bump = rctd ? 20 : 8;
1809 put_unaligned_be32(count * bump, arr);
1810 for (offset = 4, oip = opcode_info_arr;
1811 oip->num_attached != 0xff && offset < a_len; ++oip) {
1812 if (F_INV_OP & oip->flags)
1813 continue;
1814 na = oip->num_attached;
1815 arr[offset] = oip->opcode;
1816 put_unaligned_be16(oip->sa, arr + offset + 2);
1817 if (rctd)
1818 arr[offset + 5] |= 0x2;
1819 if (FF_SA & oip->flags)
1820 arr[offset + 5] |= 0x1;
1821 put_unaligned_be16(oip->len_mask[0], arr + offset + 6);
1822 if (rctd)
1823 put_unaligned_be16(0xa, arr + offset + 8);
1824 r_oip = oip;
1825 for (k = 0, oip = oip->arrp; k < na; ++k, ++oip) {
1826 if (F_INV_OP & oip->flags)
1827 continue;
1828 offset += bump;
1829 arr[offset] = oip->opcode;
1830 put_unaligned_be16(oip->sa, arr + offset + 2);
1831 if (rctd)
1832 arr[offset + 5] |= 0x2;
1833 if (FF_SA & oip->flags)
1834 arr[offset + 5] |= 0x1;
1835 put_unaligned_be16(oip->len_mask[0],
1836 arr + offset + 6);
1837 if (rctd)
1838 put_unaligned_be16(0xa,
1839 arr + offset + 8);
1840 }
1841 oip = r_oip;
1842 offset += bump;
1843 }
1844 break;
1845 case 1: /* one command: opcode only */
1846 case 2: /* one command: opcode plus service action */
1847 case 3: /* one command: if sa==0 then opcode only else opcode+sa */
1848 sdeb_i = opcode_ind_arr[req_opcode];
1849 oip = &opcode_info_arr[sdeb_i];
1850 if (F_INV_OP & oip->flags) {
1851 supp = 1;
1852 offset = 4;
1853 } else {
1854 if (1 == reporting_opts) {
1855 if (FF_SA & oip->flags) {
1856 mk_sense_invalid_fld(scp, SDEB_IN_CDB,
1857 2, 2);
1858 kfree(arr);
1859 return check_condition_result;
1860 }
1861 req_sa = 0;
1862 } else if (2 == reporting_opts &&
1863 0 == (FF_SA & oip->flags)) {
1864 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, -1);
1865 kfree(arr); /* point at requested sa */
1866 return check_condition_result;
1867 }
1868 if (0 == (FF_SA & oip->flags) &&
1869 req_opcode == oip->opcode)
1870 supp = 3;
1871 else if (0 == (FF_SA & oip->flags)) {
1872 na = oip->num_attached;
1873 for (k = 0, oip = oip->arrp; k < na;
1874 ++k, ++oip) {
1875 if (req_opcode == oip->opcode)
1876 break;
1877 }
1878 supp = (k >= na) ? 1 : 3;
1879 } else if (req_sa != oip->sa) {
1880 na = oip->num_attached;
1881 for (k = 0, oip = oip->arrp; k < na;
1882 ++k, ++oip) {
1883 if (req_sa == oip->sa)
1884 break;
1885 }
1886 supp = (k >= na) ? 1 : 3;
1887 } else
1888 supp = 3;
1889 if (3 == supp) {
1890 u = oip->len_mask[0];
1891 put_unaligned_be16(u, arr + 2);
1892 arr[4] = oip->opcode;
1893 for (k = 1; k < u; ++k)
1894 arr[4 + k] = (k < 16) ?
1895 oip->len_mask[k] : 0xff;
1896 offset = 4 + u;
1897 } else
1898 offset = 4;
1899 }
1900 arr[1] = (rctd ? 0x80 : 0) | supp;
1901 if (rctd) {
1902 put_unaligned_be16(0xa, arr + offset);
1903 offset += 12;
1904 }
1905 break;
1906 default:
1907 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 2);
1908 kfree(arr);
1909 return check_condition_result;
1910 }
1911 offset = (offset < a_len) ? offset : a_len;
1912 len = (offset < alloc_len) ? offset : alloc_len;
1913 errsts = fill_from_dev_buffer(scp, arr, len);
1914 kfree(arr);
1915 return errsts;
1916}
1917
fd32119b
DG		 1918static int resp_rsup_tmfs(struct scsi_cmnd *scp,
1919 struct sdebug_dev_info *devip)
38d5c833
DG		 1920{
1921 bool repd;
1922 u32 alloc_len, len;
1923 u8 arr[16];
1924 u8 *cmd = scp->cmnd;
1925
1926 memset(arr, 0, sizeof(arr));
1927 repd = !!(cmd[2] & 0x80);
1928 alloc_len = get_unaligned_be32(cmd + 6);
1929 if (alloc_len < 4) {
1930 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
1931 return check_condition_result;
1932 }
1933 arr[0] = 0xc8; /* ATS | ATSS | LURS */
1934 arr[1] = 0x1; /* ITNRS */
1935 if (repd) {
1936 arr[3] = 0xc;
1937 len = 16;
1938 } else
1939 len = 4;
1940
1941 len = (len < alloc_len) ? len : alloc_len;
1942 return fill_from_dev_buffer(scp, arr, len);
1943}
1944
1da177e4
LT		 1945/* <<Following mode page info copied from ST318451LW>> */
1946
91d4c752 1947static int resp_err_recov_pg(unsigned char *p, int pcontrol, int target)
1da177e4
LT		 1948{ /* Read-Write Error Recovery page for mode_sense */
1949 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
1950 5, 0, 0xff, 0xff};
1951
1952 memcpy(p, err_recov_pg, sizeof(err_recov_pg));
1953 if (1 == pcontrol)
1954 memset(p + 2, 0, sizeof(err_recov_pg) - 2);
1955 return sizeof(err_recov_pg);
1956}
1957
91d4c752 1958static int resp_disconnect_pg(unsigned char *p, int pcontrol, int target)
1da177e4
LT		 1959{ /* Disconnect-Reconnect page for mode_sense */
1960 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
1961 0, 0, 0, 0, 0, 0, 0, 0};
1962
1963 memcpy(p, disconnect_pg, sizeof(disconnect_pg));
1964 if (1 == pcontrol)
1965 memset(p + 2, 0, sizeof(disconnect_pg) - 2);
1966 return sizeof(disconnect_pg);
1967}
1968
91d4c752 1969static int resp_format_pg(unsigned char *p, int pcontrol, int target)
1da177e4 1970{ /* Format device page for mode_sense */
597136ab
MP		 1971 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
1972 0, 0, 0, 0, 0, 0, 0, 0,
1973 0, 0, 0, 0, 0x40, 0, 0, 0};
1974
1975 memcpy(p, format_pg, sizeof(format_pg));
773642d9
DG		 1976 put_unaligned_be16(sdebug_sectors_per, p + 10);
1977 put_unaligned_be16(sdebug_sector_size, p + 12);
1978 if (sdebug_removable)
597136ab
MP		 1979 p[20] |= 0x20; /* should agree with INQUIRY */
1980 if (1 == pcontrol)
1981 memset(p + 2, 0, sizeof(format_pg) - 2);
1982 return sizeof(format_pg);
1da177e4
LT		 1983}
1984
fd32119b
DG		 1985static unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1986 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0,
1987 0, 0, 0, 0};
1988
91d4c752 1989static int resp_caching_pg(unsigned char *p, int pcontrol, int target)
1da177e4 1990{ /* Caching page for mode_sense */
cbf67842
DG		 1991 unsigned char ch_caching_pg[] = {/* 0x8, 18, */ 0x4, 0, 0, 0, 0, 0,
1992 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1993 unsigned char d_caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1da177e4
LT		 1994 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
1995
773642d9 1996 if (SDEBUG_OPT_N_WCE & sdebug_opts)
cbf67842 1997 caching_pg[2] &= ~0x4; /* set WCE=0 (default WCE=1) */
1da177e4
LT		 1998 memcpy(p, caching_pg, sizeof(caching_pg));
1999 if (1 == pcontrol)
cbf67842
DG		 2000 memcpy(p + 2, ch_caching_pg, sizeof(ch_caching_pg));
2001 else if (2 == pcontrol)
2002 memcpy(p, d_caching_pg, sizeof(d_caching_pg));
1da177e4
LT		 2003 return sizeof(caching_pg);
2004}
2005
fd32119b
DG		 2006static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
2007 0, 0, 0x2, 0x4b};
2008
91d4c752 2009static int resp_ctrl_m_pg(unsigned char *p, int pcontrol, int target)
1da177e4 2010{ /* Control mode page for mode_sense */
c65b1445 2011 unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
9a051019 2012 0, 0, 0, 0};
c65b1445 2013 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1da177e4
LT		 2014 0, 0, 0x2, 0x4b};
2015
773642d9 2016 if (sdebug_dsense)
1da177e4 2017 ctrl_m_pg[2] |= 0x4;
c65b1445
DG		 2018 else
2019 ctrl_m_pg[2] &= ~0x4;
c6a44287 2020
773642d9 2021 if (sdebug_ato)
c6a44287
MP		 2022 ctrl_m_pg[5] |= 0x80; /* ATO=1 */
2023
1da177e4
LT		 2024 memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
2025 if (1 == pcontrol)
c65b1445
DG		 2026 memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
2027 else if (2 == pcontrol)
2028 memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
1da177e4
LT		 2029 return sizeof(ctrl_m_pg);
2030}
2031
c65b1445 2032
91d4c752 2033static int resp_iec_m_pg(unsigned char *p, int pcontrol, int target)
1da177e4 2034{ /* Informational Exceptions control mode page for mode_sense */
c65b1445
DG		 2035 unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
2036 0, 0, 0x0, 0x0};
2037 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
2038 0, 0, 0x0, 0x0};
2039
1da177e4
LT		 2040 memcpy(p, iec_m_pg, sizeof(iec_m_pg));
2041 if (1 == pcontrol)
c65b1445
DG		 2042 memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
2043 else if (2 == pcontrol)
2044 memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
1da177e4
LT		 2045 return sizeof(iec_m_pg);
2046}
2047
91d4c752 2048static int resp_sas_sf_m_pg(unsigned char *p, int pcontrol, int target)
c65b1445
DG		 2049{ /* SAS SSP mode page - short format for mode_sense */
2050 unsigned char sas_sf_m_pg[] = {0x19, 0x6,
2051 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
2052
2053 memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
2054 if (1 == pcontrol)
2055 memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
2056 return sizeof(sas_sf_m_pg);
2057}
2058
2059
91d4c752 2060static int resp_sas_pcd_m_spg(unsigned char *p, int pcontrol, int target,
c65b1445
DG		 2061 int target_dev_id)
2062{ /* SAS phy control and discover mode page for mode_sense */
2063 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
2064 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
773642d9
DG		 2065 0, 0, 0, 0, 0, 0, 0, 0, /* insert SAS addr */
2066 0, 0, 0, 0, 0, 0, 0, 0, /* insert SAS addr */
c65b1445
DG		 2067 0x2, 0, 0, 0, 0, 0, 0, 0,
2068 0x88, 0x99, 0, 0, 0, 0, 0, 0,
2069 0, 0, 0, 0, 0, 0, 0, 0,
2070 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
773642d9
DG		 2071 0, 0, 0, 0, 0, 0, 0, 0, /* insert SAS addr */
2072 0, 0, 0, 0, 0, 0, 0, 0, /* insert SAS addr */
c65b1445
DG		 2073 0x3, 0, 0, 0, 0, 0, 0, 0,
2074 0x88, 0x99, 0, 0, 0, 0, 0, 0,
2075 0, 0, 0, 0, 0, 0, 0, 0,
2076 };
2077 int port_a, port_b;
2078
1b37bd60
DG		 2079 put_unaligned_be64(naa3_comp_a, sas_pcd_m_pg + 16);
2080 put_unaligned_be64(naa3_comp_c + 1, sas_pcd_m_pg + 24);
2081 put_unaligned_be64(naa3_comp_a, sas_pcd_m_pg + 64);
2082 put_unaligned_be64(naa3_comp_c + 1, sas_pcd_m_pg + 72);
c65b1445
DG		 2083 port_a = target_dev_id + 1;
2084 port_b = port_a + 1;
2085 memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
773642d9
DG		 2086 put_unaligned_be32(port_a, p + 20);
2087 put_unaligned_be32(port_b, p + 48 + 20);
c65b1445
DG		 2088 if (1 == pcontrol)
2089 memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
2090 return sizeof(sas_pcd_m_pg);
2091}
2092
91d4c752 2093static int resp_sas_sha_m_spg(unsigned char *p, int pcontrol)
c65b1445
DG		 2094{ /* SAS SSP shared protocol specific port mode subpage */
2095 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
2096 0, 0, 0, 0, 0, 0, 0, 0,
2097 };
2098
2099 memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
2100 if (1 == pcontrol)
2101 memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
2102 return sizeof(sas_sha_m_pg);
2103}
2104
1da177e4
LT		 2105#define SDEBUG_MAX_MSENSE_SZ 256
2106
fd32119b
DG		 2107static int resp_mode_sense(struct scsi_cmnd *scp,
2108 struct sdebug_dev_info *devip)
1da177e4 2109{
23183910 2110 int pcontrol, pcode, subpcode, bd_len;
1da177e4 2111 unsigned char dev_spec;
760f3b03 2112 int alloc_len, offset, len, target_dev_id;
c2248fc9 2113 int target = scp->device->id;
91d4c752 2114 unsigned char *ap;
1da177e4 2115 unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
01123ef4 2116 unsigned char *cmd = scp->cmnd;
760f3b03 2117 bool dbd, llbaa, msense_6, is_disk, bad_pcode;
1da177e4 2118
760f3b03 2119 dbd = !!(cmd[1] & 0x8); /* disable block descriptors */
1da177e4
LT		 2120 pcontrol = (cmd[2] & 0xc0) >> 6;
2121 pcode = cmd[2] & 0x3f;
2122 subpcode = cmd[3];
2123 msense_6 = (MODE_SENSE == cmd[0]);
760f3b03
DG		 2124 llbaa = msense_6 ? false : !!(cmd[1] & 0x10);
2125 is_disk = (sdebug_ptype == TYPE_DISK);
2126 if (is_disk && !dbd)
23183910
DG		 2127 bd_len = llbaa ? 16 : 8;
2128 else
2129 bd_len = 0;
773642d9 2130 alloc_len = msense_6 ? cmd[4] : get_unaligned_be16(cmd + 7);
1da177e4
LT		 2131 memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
2132 if (0x3 == pcontrol) { /* Saving values not supported */
cbf67842 2133 mk_sense_buffer(scp, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP, 0);
1da177e4
LT		 2134 return check_condition_result;
2135 }
c65b1445
DG		 2136 target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
2137 (devip->target * 1000) - 3;
b01f6f83 2138 /* for disks set DPOFUA bit and clear write protect (WP) bit */
760f3b03 2139 if (is_disk)
b01f6f83 2140 dev_spec = 0x10; /* =0x90 if WP=1 implies read-only */
23183910
DG		 2141 else
2142 dev_spec = 0x0;
1da177e4
LT		 2143 if (msense_6) {
2144 arr[2] = dev_spec;
23183910 2145 arr[3] = bd_len;
1da177e4
LT		 2146 offset = 4;
2147 } else {
2148 arr[3] = dev_spec;
23183910
DG		 2149 if (16 == bd_len)
2150 arr[4] = 0x1; /* set LONGLBA bit */
2151 arr[7] = bd_len; /* assume 255 or less */
1da177e4
LT		 2152 offset = 8;
2153 }
2154 ap = arr + offset;
28898873
FT		 2155 if ((bd_len > 0) && (!sdebug_capacity))
2156 sdebug_capacity = get_sdebug_capacity();
2157
23183910 2158 if (8 == bd_len) {
773642d9
DG		 2159 if (sdebug_capacity > 0xfffffffe)
2160 put_unaligned_be32(0xffffffff, ap + 0);
2161 else
2162 put_unaligned_be32(sdebug_capacity, ap + 0);
2163 put_unaligned_be16(sdebug_sector_size, ap + 6);
23183910
DG		 2164 offset += bd_len;
2165 ap = arr + offset;
2166 } else if (16 == bd_len) {
773642d9
DG		 2167 put_unaligned_be64((u64)sdebug_capacity, ap + 0);
2168 put_unaligned_be32(sdebug_sector_size, ap + 12);
23183910
DG		 2169 offset += bd_len;
2170 ap = arr + offset;
2171 }
1da177e4 2172
c65b1445
DG		 2173 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
2174 /* TODO: Control Extension page */
22017ed2 2175 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
1da177e4
LT		 2176 return check_condition_result;
2177 }
760f3b03
DG		 2178 bad_pcode = false;
2179
1da177e4
LT		 2180 switch (pcode) {
2181 case 0x1: /* Read-Write error recovery page, direct access */
2182 len = resp_err_recov_pg(ap, pcontrol, target);
2183 offset += len;
2184 break;
2185 case 0x2: /* Disconnect-Reconnect page, all devices */
2186 len = resp_disconnect_pg(ap, pcontrol, target);
2187 offset += len;
2188 break;
9a051019 2189 case 0x3: /* Format device page, direct access */
760f3b03
DG		 2190 if (is_disk) {
2191 len = resp_format_pg(ap, pcontrol, target);
2192 offset += len;
2193 } else
2194 bad_pcode = true;
9a051019 2195 break;
1da177e4 2196 case 0x8: /* Caching page, direct access */
760f3b03
DG		 2197 if (is_disk) {
2198 len = resp_caching_pg(ap, pcontrol, target);
2199 offset += len;
2200 } else
2201 bad_pcode = true;
1da177e4
LT		 2202 break;
2203 case 0xa: /* Control Mode page, all devices */
2204 len = resp_ctrl_m_pg(ap, pcontrol, target);
2205 offset += len;
2206 break;
c65b1445
DG		 2207 case 0x19: /* if spc==1 then sas phy, control+discover */
2208 if ((subpcode > 0x2) && (subpcode < 0xff)) {
22017ed2 2209 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
c65b1445 2210 return check_condition_result;
9a051019 2211 }
c65b1445
DG		 2212 len = 0;
2213 if ((0x0 == subpcode) || (0xff == subpcode))
2214 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
2215 if ((0x1 == subpcode) || (0xff == subpcode))
2216 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
2217 target_dev_id);
2218 if ((0x2 == subpcode) || (0xff == subpcode))
2219 len += resp_sas_sha_m_spg(ap + len, pcontrol);
2220 offset += len;
2221 break;
1da177e4
LT		 2222 case 0x1c: /* Informational Exceptions Mode page, all devices */
2223 len = resp_iec_m_pg(ap, pcontrol, target);
2224 offset += len;
2225 break;
2226 case 0x3f: /* Read all Mode pages */
c65b1445
DG		 2227 if ((0 == subpcode) || (0xff == subpcode)) {
2228 len = resp_err_recov_pg(ap, pcontrol, target);
2229 len += resp_disconnect_pg(ap + len, pcontrol, target);
760f3b03
DG		 2230 if (is_disk) {
2231 len += resp_format_pg(ap + len, pcontrol,
2232 target);
2233 len += resp_caching_pg(ap + len, pcontrol,
2234 target);
2235 }
c65b1445
DG		 2236 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
2237 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
2238 if (0xff == subpcode) {
2239 len += resp_sas_pcd_m_spg(ap + len, pcontrol,
2240 target, target_dev_id);
2241 len += resp_sas_sha_m_spg(ap + len, pcontrol);
2242 }
2243 len += resp_iec_m_pg(ap + len, pcontrol, target);
760f3b03 2244 offset += len;
c65b1445 2245 } else {
22017ed2 2246 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
c65b1445 2247 return check_condition_result;
9a051019 2248 }
1da177e4
LT		 2249 break;
2250 default:
760f3b03
DG		 2251 bad_pcode = true;
2252 break;
2253 }
2254 if (bad_pcode) {
22017ed2 2255 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
1da177e4
LT		 2256 return check_condition_result;
2257 }
2258 if (msense_6)
2259 arr[0] = offset - 1;
773642d9
DG		 2260 else
2261 put_unaligned_be16((offset - 2), arr + 0);
1da177e4
LT		 2262 return fill_from_dev_buffer(scp, arr, min(alloc_len, offset));
2263}
2264
c65b1445
DG		 2265#define SDEBUG_MAX_MSELECT_SZ 512
2266
fd32119b
DG		 2267static int resp_mode_select(struct scsi_cmnd *scp,
2268 struct sdebug_dev_info *devip)
c65b1445
DG		 2269{
2270 int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
c2248fc9 2271 int param_len, res, mpage;
c65b1445 2272 unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
01123ef4 2273 unsigned char *cmd = scp->cmnd;
c2248fc9 2274 int mselect6 = (MODE_SELECT == cmd[0]);
c65b1445 2275
c65b1445
DG		 2276 memset(arr, 0, sizeof(arr));
2277 pf = cmd[1] & 0x10;
2278 sp = cmd[1] & 0x1;
773642d9 2279 param_len = mselect6 ? cmd[4] : get_unaligned_be16(cmd + 7);
c65b1445 2280 if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
22017ed2 2281 mk_sense_invalid_fld(scp, SDEB_IN_CDB, mselect6 ? 4 : 7, -1);
c65b1445
DG		 2282 return check_condition_result;
2283 }
9a051019
DG		 2284 res = fetch_to_dev_buffer(scp, arr, param_len);
2285 if (-1 == res)
773642d9
DG		 2286 return DID_ERROR << 16;
2287 else if (sdebug_verbose && (res < param_len))
cbf67842
DG		 2288 sdev_printk(KERN_INFO, scp->device,
2289 "%s: cdb indicated=%d, IO sent=%d bytes\n",
2290 __func__, param_len, res);
773642d9
DG		 2291 md_len = mselect6 ? (arr[0] + 1) : (get_unaligned_be16(arr + 0) + 2);
2292 bd_len = mselect6 ? arr[3] : get_unaligned_be16(arr + 6);
23183910 2293 if (md_len > 2) {
22017ed2 2294 mk_sense_invalid_fld(scp, SDEB_IN_DATA, 0, -1);
c65b1445
DG		 2295 return check_condition_result;
2296 }
2297 off = bd_len + (mselect6 ? 4 : 8);
2298 mpage = arr[off] & 0x3f;
2299 ps = !!(arr[off] & 0x80);
2300 if (ps) {
22017ed2 2301 mk_sense_invalid_fld(scp, SDEB_IN_DATA, off, 7);
c65b1445
DG		 2302 return check_condition_result;
2303 }
2304 spf = !!(arr[off] & 0x40);
773642d9 2305 pg_len = spf ? (get_unaligned_be16(arr + off + 2) + 4) :
c65b1445
DG		 2306 (arr[off + 1] + 2);
2307 if ((pg_len + off) > param_len) {
cbf67842 2308 mk_sense_buffer(scp, ILLEGAL_REQUEST,
c65b1445
DG		 2309 PARAMETER_LIST_LENGTH_ERR, 0);
2310 return check_condition_result;
2311 }
2312 switch (mpage) {
cbf67842
DG		 2313 case 0x8: /* Caching Mode page */
2314 if (caching_pg[1] == arr[off + 1]) {
2315 memcpy(caching_pg + 2, arr + off + 2,
2316 sizeof(caching_pg) - 2);
2317 goto set_mode_changed_ua;
2318 }
2319 break;
c65b1445
DG		 2320 case 0xa: /* Control Mode page */
2321 if (ctrl_m_pg[1] == arr[off + 1]) {
2322 memcpy(ctrl_m_pg + 2, arr + off + 2,
2323 sizeof(ctrl_m_pg) - 2);
773642d9 2324 sdebug_dsense = !!(ctrl_m_pg[2] & 0x4);
cbf67842 2325 goto set_mode_changed_ua;
c65b1445
DG		 2326 }
2327 break;
2328 case 0x1c: /* Informational Exceptions Mode page */
2329 if (iec_m_pg[1] == arr[off + 1]) {
2330 memcpy(iec_m_pg + 2, arr + off + 2,
2331 sizeof(iec_m_pg) - 2);
cbf67842 2332 goto set_mode_changed_ua;
c65b1445
DG		 2333 }
2334 break;
2335 default:
2336 break;
2337 }
22017ed2 2338 mk_sense_invalid_fld(scp, SDEB_IN_DATA, off, 5);
c65b1445 2339 return check_condition_result;
cbf67842
DG		 2340set_mode_changed_ua:
2341 set_bit(SDEBUG_UA_MODE_CHANGED, devip->uas_bm);
2342 return 0;
c65b1445
DG		 2343}
2344
91d4c752 2345static int resp_temp_l_pg(unsigned char *arr)
c65b1445
DG		 2346{
2347 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
2348 0x0, 0x1, 0x3, 0x2, 0x0, 65,
2349 };
2350
9a051019
DG		 2351 memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
2352 return sizeof(temp_l_pg);
c65b1445
DG		 2353}
2354
91d4c752 2355static int resp_ie_l_pg(unsigned char *arr)
c65b1445
DG		 2356{
2357 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
2358 };
2359
9a051019 2360 memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
c65b1445
DG		 2361 if (iec_m_pg[2] & 0x4) { /* TEST bit set */
2362 arr[4] = THRESHOLD_EXCEEDED;
2363 arr[5] = 0xff;
2364 }
9a051019 2365 return sizeof(ie_l_pg);
c65b1445
DG		 2366}
2367
2368#define SDEBUG_MAX_LSENSE_SZ 512
2369
9a051019
DG		 2370static int resp_log_sense(struct scsi_cmnd *scp,
2371 struct sdebug_dev_info *devip)
c65b1445 2372{
ab17241c 2373 int ppc, sp, pcode, subpcode, alloc_len, len, n;
c65b1445 2374 unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
01123ef4 2375 unsigned char *cmd = scp->cmnd;
c65b1445 2376
c65b1445
DG		 2377 memset(arr, 0, sizeof(arr));
2378 ppc = cmd[1] & 0x2;
2379 sp = cmd[1] & 0x1;
2380 if (ppc || sp) {
22017ed2 2381 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, ppc ? 1 : 0);
c65b1445
DG		 2382 return check_condition_result;
2383 }
c65b1445 2384 pcode = cmd[2] & 0x3f;
23183910 2385 subpcode = cmd[3] & 0xff;
773642d9 2386 alloc_len = get_unaligned_be16(cmd + 7);
c65b1445 2387 arr[0] = pcode;
23183910
DG		 2388 if (0 == subpcode) {
2389 switch (pcode) {
2390 case 0x0: /* Supported log pages log page */
2391 n = 4;
2392 arr[n++] = 0x0; /* this page */
2393 arr[n++] = 0xd; /* Temperature */
2394 arr[n++] = 0x2f; /* Informational exceptions */
2395 arr[3] = n - 4;
2396 break;
2397 case 0xd: /* Temperature log page */
2398 arr[3] = resp_temp_l_pg(arr + 4);
2399 break;
2400 case 0x2f: /* Informational exceptions log page */
2401 arr[3] = resp_ie_l_pg(arr + 4);
2402 break;
2403 default:
22017ed2 2404 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
23183910
DG		 2405 return check_condition_result;
2406 }
2407 } else if (0xff == subpcode) {
2408 arr[0] |= 0x40;
2409 arr[1] = subpcode;
2410 switch (pcode) {
2411 case 0x0: /* Supported log pages and subpages log page */
2412 n = 4;
2413 arr[n++] = 0x0;
2414 arr[n++] = 0x0; /* 0,0 page */
2415 arr[n++] = 0x0;
2416 arr[n++] = 0xff; /* this page */
2417 arr[n++] = 0xd;
2418 arr[n++] = 0x0; /* Temperature */
2419 arr[n++] = 0x2f;
2420 arr[n++] = 0x0; /* Informational exceptions */
2421 arr[3] = n - 4;
2422 break;
2423 case 0xd: /* Temperature subpages */
2424 n = 4;
2425 arr[n++] = 0xd;
2426 arr[n++] = 0x0; /* Temperature */
2427 arr[3] = n - 4;
2428 break;
2429 case 0x2f: /* Informational exceptions subpages */
2430 n = 4;
2431 arr[n++] = 0x2f;
2432 arr[n++] = 0x0; /* Informational exceptions */
2433 arr[3] = n - 4;
2434 break;
2435 default:
22017ed2 2436 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
23183910
DG		 2437 return check_condition_result;
2438 }
2439 } else {
22017ed2 2440 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
c65b1445
DG		 2441 return check_condition_result;
2442 }
773642d9 2443 len = min(get_unaligned_be16(arr + 2) + 4, alloc_len);
c65b1445
DG		 2444 return fill_from_dev_buffer(scp, arr,
2445 min(len, SDEBUG_MAX_INQ_ARR_SZ));
2446}
2447
cbf67842 2448static int check_device_access_params(struct scsi_cmnd *scp,
19789100 2449 unsigned long long lba, unsigned int num)
1da177e4 2450{
c65b1445 2451 if (lba + num > sdebug_capacity) {
22017ed2 2452 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
1da177e4
LT		 2453 return check_condition_result;
2454 }
c65b1445
DG		 2455 /* transfer length excessive (tie in to block limits VPD page) */
2456 if (num > sdebug_store_sectors) {
22017ed2 2457 /* needs work to find which cdb byte 'num' comes from */
cbf67842 2458 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
c65b1445
DG		 2459 return check_condition_result;
2460 }
19789100
FT		 2461 return 0;
2462}
2463
a4517511 2464/* Returns number of bytes copied or -1 if error. */
0a7e69c7
DG		 2465static int do_device_access(struct scsi_cmnd *scmd, u32 sg_skip, u64 lba,
2466 u32 num, bool do_write)
19789100
FT		 2467{
2468 int ret;
c2248fc9 2469 u64 block, rest = 0;
a4517511
AM		 2470 struct scsi_data_buffer *sdb;
2471 enum dma_data_direction dir;
a4517511 2472
c2248fc9 2473 if (do_write) {
a4517511
AM		 2474 sdb = scsi_out(scmd);
2475 dir = DMA_TO_DEVICE;
a4517511
AM		 2476 } else {
2477 sdb = scsi_in(scmd);
2478 dir = DMA_FROM_DEVICE;
a4517511 2479 }
19789100 2480
a4517511
AM		 2481 if (!sdb->length)
2482 return 0;
2483 if (!(scsi_bidi_cmnd(scmd) || scmd->sc_data_direction == dir))
2484 return -1;
19789100
FT		 2485
2486 block = do_div(lba, sdebug_store_sectors);
2487 if (block + num > sdebug_store_sectors)
2488 rest = block + num - sdebug_store_sectors;
2489
386ecb12 2490 ret = sg_copy_buffer(sdb->table.sgl, sdb->table.nents,
773642d9 2491 fake_storep + (block * sdebug_sector_size),
0a7e69c7 2492 (num - rest) * sdebug_sector_size, sg_skip, do_write);
773642d9 2493 if (ret != (num - rest) * sdebug_sector_size)
a4517511
AM		 2494 return ret;
2495
2496 if (rest) {
386ecb12 2497 ret += sg_copy_buffer(sdb->table.sgl, sdb->table.nents,
773642d9 2498 fake_storep, rest * sdebug_sector_size,
0a7e69c7
DG		 2499 sg_skip + ((num - rest) * sdebug_sector_size),
2500 do_write);
a4517511 2501 }
19789100
FT		 2502
2503 return ret;
2504}
2505
38d5c833
DG		 2506/* If fake_store(lba,num) compares equal to arr(num), then copy top half of
2507 * arr into fake_store(lba,num) and return true. If comparison fails then
2508 * return false. */
fd32119b 2509static bool comp_write_worker(u64 lba, u32 num, const u8 *arr)
38d5c833
DG		 2510{
2511 bool res;
2512 u64 block, rest = 0;
2513 u32 store_blks = sdebug_store_sectors;
773642d9 2514 u32 lb_size = sdebug_sector_size;
38d5c833
DG		 2515
2516 block = do_div(lba, store_blks);
2517 if (block + num > store_blks)
2518 rest = block + num - store_blks;
2519
2520 res = !memcmp(fake_storep + (block * lb_size), arr,
2521 (num - rest) * lb_size);
2522 if (!res)
2523 return res;
2524 if (rest)
2525 res = memcmp(fake_storep, arr + ((num - rest) * lb_size),
2526 rest * lb_size);
2527 if (!res)
2528 return res;
2529 arr += num * lb_size;
2530 memcpy(fake_storep + (block * lb_size), arr, (num - rest) * lb_size);
2531 if (rest)
2532 memcpy(fake_storep, arr + ((num - rest) * lb_size),
2533 rest * lb_size);
2534 return res;
2535}
2536
51d648af 2537static __be16 dif_compute_csum(const void *buf, int len)
beb40ea4 2538{
51d648af 2539 __be16 csum;
beb40ea4 2540
773642d9 2541 if (sdebug_guard)
51d648af
AM		 2542 csum = (__force __be16)ip_compute_csum(buf, len);
2543 else
beb40ea4 2544 csum = cpu_to_be16(crc_t10dif(buf, len));
51d648af 2545
beb40ea4
AM		 2546 return csum;
2547}
2548
6ebf105c 2549static int dif_verify(struct t10_pi_tuple *sdt, const void *data,
beb40ea4
AM		 2550 sector_t sector, u32 ei_lba)
2551{
773642d9 2552 __be16 csum = dif_compute_csum(data, sdebug_sector_size);
beb40ea4
AM		 2553
2554 if (sdt->guard_tag != csum) {
c1287970 2555 pr_err("GUARD check failed on sector %lu rcvd 0x%04x, data 0x%04x\n",
beb40ea4
AM		 2556 (unsigned long)sector,
2557 be16_to_cpu(sdt->guard_tag),
2558 be16_to_cpu(csum));
2559 return 0x01;
2560 }
8475c811 2561 if (sdebug_dif == T10_PI_TYPE1_PROTECTION &&
beb40ea4 2562 be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
c1287970
TW		 2563 pr_err("REF check failed on sector %lu\n",
2564 (unsigned long)sector);
beb40ea4
AM		 2565 return 0x03;
2566 }
8475c811 2567 if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
beb40ea4 2568 be32_to_cpu(sdt->ref_tag) != ei_lba) {
c1287970
TW		 2569 pr_err("REF check failed on sector %lu\n",
2570 (unsigned long)sector);
beb40ea4
AM		 2571 return 0x03;
2572 }
2573 return 0;
2574}
2575
bb8c063c 2576static void dif_copy_prot(struct scsi_cmnd *SCpnt, sector_t sector,
65f72f2a 2577 unsigned int sectors, bool read)
c6a44287 2578{
be4e11be 2579 size_t resid;
c6a44287 2580 void *paddr;
14faa944 2581 const void *dif_store_end = dif_storep + sdebug_store_sectors;
be4e11be 2582 struct sg_mapping_iter miter;
c6a44287 2583
e18d8bea
AM		 2584 /* Bytes of protection data to copy into sgl */
2585 resid = sectors * sizeof(*dif_storep);
c6a44287 2586
be4e11be
AM		 2587 sg_miter_start(&miter, scsi_prot_sglist(SCpnt),
2588 scsi_prot_sg_count(SCpnt), SG_MITER_ATOMIC |
2589 (read ? SG_MITER_TO_SG : SG_MITER_FROM_SG));
2590
2591 while (sg_miter_next(&miter) && resid > 0) {
2592 size_t len = min(miter.length, resid);
14faa944 2593 void *start = dif_store(sector);
be4e11be 2594 size_t rest = 0;
14faa944
AM		 2595
2596 if (dif_store_end < start + len)
2597 rest = start + len - dif_store_end;
c6a44287 2598
be4e11be 2599 paddr = miter.addr;
14faa944 2600
65f72f2a
AM		 2601 if (read)
2602 memcpy(paddr, start, len - rest);
2603 else
2604 memcpy(start, paddr, len - rest);
2605
2606 if (rest) {
2607 if (read)
2608 memcpy(paddr + len - rest, dif_storep, rest);
2609 else
2610 memcpy(dif_storep, paddr + len - rest, rest);
2611 }
c6a44287 2612
e18d8bea 2613 sector += len / sizeof(*dif_storep);
c6a44287 2614 resid -= len;
c6a44287 2615 }
be4e11be 2616 sg_miter_stop(&miter);
bb8c063c
AM		 2617}
2618
2619static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec,
2620 unsigned int sectors, u32 ei_lba)
2621{
2622 unsigned int i;
6ebf105c 2623 struct t10_pi_tuple *sdt;
bb8c063c
AM		 2624 sector_t sector;
2625
c45eabec 2626 for (i = 0; i < sectors; i++, ei_lba++) {
bb8c063c
AM		 2627 int ret;
2628
2629 sector = start_sec + i;
2630 sdt = dif_store(sector);
2631
51d648af 2632 if (sdt->app_tag == cpu_to_be16(0xffff))
bb8c063c
AM		 2633 continue;
2634
2635 ret = dif_verify(sdt, fake_store(sector), sector, ei_lba);
2636 if (ret) {
2637 dif_errors++;
2638 return ret;
2639 }
bb8c063c 2640 }
c6a44287 2641
65f72f2a 2642 dif_copy_prot(SCpnt, start_sec, sectors, true);
c6a44287
MP		 2643 dix_reads++;
2644
2645 return 0;
2646}
2647
fd32119b 2648static int resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
19789100 2649{
c2248fc9 2650 u8 *cmd = scp->cmnd;
c4837394 2651 struct sdebug_queued_cmd *sqcp;
c2248fc9
DG		 2652 u64 lba;
2653 u32 num;
2654 u32 ei_lba;
19789100
FT		 2655 unsigned long iflags;
2656 int ret;
c2248fc9 2657 bool check_prot;
19789100 2658
c2248fc9
DG		 2659 switch (cmd[0]) {
2660 case READ_16:
2661 ei_lba = 0;
2662 lba = get_unaligned_be64(cmd + 2);
2663 num = get_unaligned_be32(cmd + 10);
2664 check_prot = true;
2665 break;
2666 case READ_10:
2667 ei_lba = 0;
2668 lba = get_unaligned_be32(cmd + 2);
2669 num = get_unaligned_be16(cmd + 7);
2670 check_prot = true;
2671 break;
2672 case READ_6:
2673 ei_lba = 0;
2674 lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
2675 (u32)(cmd[1] & 0x1f) << 16;
2676 num = (0 == cmd[4]) ? 256 : cmd[4];
2677 check_prot = true;
2678 break;
2679 case READ_12:
2680 ei_lba = 0;
2681 lba = get_unaligned_be32(cmd + 2);
2682 num = get_unaligned_be32(cmd + 6);
2683 check_prot = true;
2684 break;
2685 case XDWRITEREAD_10:
2686 ei_lba = 0;
2687 lba = get_unaligned_be32(cmd + 2);
2688 num = get_unaligned_be16(cmd + 7);
2689 check_prot = false;
2690 break;
2691 default: /* assume READ(32) */
2692 lba = get_unaligned_be64(cmd + 12);
2693 ei_lba = get_unaligned_be32(cmd + 20);
2694 num = get_unaligned_be32(cmd + 28);
2695 check_prot = false;
2696 break;
2697 }
f46eb0e9 2698 if (unlikely(have_dif_prot && check_prot)) {
8475c811 2699 if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
c2248fc9
DG		 2700 (cmd[1] & 0xe0)) {
2701 mk_sense_invalid_opcode(scp);
2702 return check_condition_result;
2703 }
8475c811
CH		 2704 if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
2705 sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
c2248fc9
DG		 2706 (cmd[1] & 0xe0) == 0)
2707 sdev_printk(KERN_ERR, scp->device, "Unprotected RD "
2708 "to DIF device\n");
2709 }
f46eb0e9 2710 if (unlikely(sdebug_any_injecting_opt)) {
c4837394 2711 sqcp = (struct sdebug_queued_cmd *)scp->host_scribble;
c2248fc9 2712
c4837394
DG		 2713 if (sqcp) {
2714 if (sqcp->inj_short)
2715 num /= 2;
2716 }
2717 } else
2718 sqcp = NULL;
c2248fc9
DG		 2719
2720 /* inline check_device_access_params() */
f46eb0e9 2721 if (unlikely(lba + num > sdebug_capacity)) {
c2248fc9
DG		 2722 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
2723 return check_condition_result;
2724 }
2725 /* transfer length excessive (tie in to block limits VPD page) */
f46eb0e9 2726 if (unlikely(num > sdebug_store_sectors)) {
c2248fc9
DG		 2727 /* needs work to find which cdb byte 'num' comes from */
2728 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
2729 return check_condition_result;
2730 }
19789100 2731
f46eb0e9 2732 if (unlikely((SDEBUG_OPT_MEDIUM_ERR & sdebug_opts) &&
d9da891a
LO		 2733 (lba <= (sdebug_medium_error_start + sdebug_medium_error_count - 1)) &&
2734 ((lba + num) > sdebug_medium_error_start))) {
c65b1445 2735 /* claim unrecoverable read error */
c2248fc9 2736 mk_sense_buffer(scp, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 0);
c65b1445 2737 /* set info field and valid bit for fixed descriptor */
c2248fc9
DG		 2738 if (0x70 == (scp->sense_buffer[0] & 0x7f)) {
2739 scp->sense_buffer[0] |= 0x80; /* Valid bit */
32f7ef73
DG		 2740 ret = (lba < OPT_MEDIUM_ERR_ADDR)
2741 ? OPT_MEDIUM_ERR_ADDR : (int)lba;
c2248fc9 2742 put_unaligned_be32(ret, scp->sense_buffer + 3);
c65b1445 2743 }
c2248fc9 2744 scsi_set_resid(scp, scsi_bufflen(scp));
1da177e4
LT		 2745 return check_condition_result;
2746 }
c6a44287 2747
6c78cc06
AM		 2748 read_lock_irqsave(&atomic_rw, iflags);
2749
c6a44287 2750 /* DIX + T10 DIF */
f46eb0e9 2751 if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
c2248fc9 2752 int prot_ret = prot_verify_read(scp, lba, num, ei_lba);
c6a44287
MP		 2753
2754 if (prot_ret) {
6c78cc06 2755 read_unlock_irqrestore(&atomic_rw, iflags);
c2248fc9 2756 mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, prot_ret);
c6a44287
MP		 2757 return illegal_condition_result;
2758 }
2759 }
2760
0a7e69c7 2761 ret = do_device_access(scp, 0, lba, num, false);
1da177e4 2762 read_unlock_irqrestore(&atomic_rw, iflags);
f46eb0e9 2763 if (unlikely(ret == -1))
a4517511
AM		 2764 return DID_ERROR << 16;
2765
c2248fc9 2766 scsi_in(scp)->resid = scsi_bufflen(scp) - ret;
a4517511 2767
c4837394
DG		 2768 if (unlikely(sqcp)) {
2769 if (sqcp->inj_recovered) {
c2248fc9
DG		 2770 mk_sense_buffer(scp, RECOVERED_ERROR,
2771 THRESHOLD_EXCEEDED, 0);
2772 return check_condition_result;
c4837394 2773 } else if (sqcp->inj_transport) {
c2248fc9
DG		 2774 mk_sense_buffer(scp, ABORTED_COMMAND,
2775 TRANSPORT_PROBLEM, ACK_NAK_TO);
2776 return check_condition_result;
c4837394 2777 } else if (sqcp->inj_dif) {
c2248fc9
DG		 2778 /* Logical block guard check failed */
2779 mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
2780 return illegal_condition_result;
c4837394 2781 } else if (sqcp->inj_dix) {
c2248fc9
DG		 2782 mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
2783 return illegal_condition_result;
2784 }
2785 }
a4517511 2786 return 0;
1da177e4
LT		 2787}
2788
58a8635d 2789static void dump_sector(unsigned char *buf, int len)
c6a44287 2790{
cbf67842 2791 int i, j, n;
c6a44287 2792
cbf67842 2793 pr_err(">>> Sector Dump <<<\n");
c6a44287 2794 for (i = 0 ; i < len ; i += 16) {
cbf67842 2795 char b[128];
c6a44287 2796
cbf67842 2797 for (j = 0, n = 0; j < 16; j++) {
c6a44287 2798 unsigned char c = buf[i+j];
cbf67842 2799
c6a44287 2800 if (c >= 0x20 && c < 0x7e)
cbf67842
DG		 2801 n += scnprintf(b + n, sizeof(b) - n,
2802 " %c ", buf[i+j]);
c6a44287 2803 else
cbf67842
DG		 2804 n += scnprintf(b + n, sizeof(b) - n,
2805 "%02x ", buf[i+j]);
c6a44287 2806 }
cbf67842 2807 pr_err("%04d: %s\n", i, b);
c6a44287
MP		 2808 }
2809}
2810
2811static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
395cef03 2812 unsigned int sectors, u32 ei_lba)
c6a44287 2813{
be4e11be 2814 int ret;
6ebf105c 2815 struct t10_pi_tuple *sdt;
be4e11be 2816 void *daddr;
65f72f2a 2817 sector_t sector = start_sec;
c6a44287 2818 int ppage_offset;
be4e11be
AM		 2819 int dpage_offset;
2820 struct sg_mapping_iter diter;
2821 struct sg_mapping_iter piter;
c6a44287 2822
c6a44287
MP		 2823 BUG_ON(scsi_sg_count(SCpnt) == 0);
2824 BUG_ON(scsi_prot_sg_count(SCpnt) == 0);
2825
be4e11be
AM		 2826 sg_miter_start(&piter, scsi_prot_sglist(SCpnt),
2827 scsi_prot_sg_count(SCpnt),
2828 SG_MITER_ATOMIC | SG_MITER_FROM_SG);
2829 sg_miter_start(&diter, scsi_sglist(SCpnt), scsi_sg_count(SCpnt),
2830 SG_MITER_ATOMIC | SG_MITER_FROM_SG);
2831
2832 /* For each protection page */
2833 while (sg_miter_next(&piter)) {
2834 dpage_offset = 0;
2835 if (WARN_ON(!sg_miter_next(&diter))) {
2836 ret = 0x01;
2837 goto out;
2838 }
c6a44287 2839
be4e11be 2840 for (ppage_offset = 0; ppage_offset < piter.length;
6ebf105c 2841 ppage_offset += sizeof(struct t10_pi_tuple)) {
c6a44287 2842 /* If we're at the end of the current
be4e11be 2843 * data page advance to the next one
c6a44287 2844 */
be4e11be
AM		 2845 if (dpage_offset >= diter.length) {
2846 if (WARN_ON(!sg_miter_next(&diter))) {
2847 ret = 0x01;
2848 goto out;
2849 }
2850 dpage_offset = 0;
c6a44287
MP		 2851 }
2852
be4e11be
AM		 2853 sdt = piter.addr + ppage_offset;
2854 daddr = diter.addr + dpage_offset;
c6a44287 2855
be4e11be 2856 ret = dif_verify(sdt, daddr, sector, ei_lba);
beb40ea4 2857 if (ret) {
773642d9 2858 dump_sector(daddr, sdebug_sector_size);
395cef03
MP		 2859 goto out;
2860 }
2861
c6a44287 2862 sector++;
395cef03 2863 ei_lba++;
773642d9 2864 dpage_offset += sdebug_sector_size;
c6a44287 2865 }
be4e11be
AM		 2866 diter.consumed = dpage_offset;
2867 sg_miter_stop(&diter);
c6a44287 2868 }
be4e11be 2869 sg_miter_stop(&piter);
c6a44287 2870
65f72f2a 2871 dif_copy_prot(SCpnt, start_sec, sectors, false);
c6a44287
MP		 2872 dix_writes++;
2873
2874 return 0;
2875
2876out:
2877 dif_errors++;
be4e11be
AM		 2878 sg_miter_stop(&diter);
2879 sg_miter_stop(&piter);
c6a44287
MP		 2880 return ret;
2881}
2882
b90ebc3d
AM		 2883static unsigned long lba_to_map_index(sector_t lba)
2884{
773642d9
DG		 2885 if (sdebug_unmap_alignment)
2886 lba += sdebug_unmap_granularity - sdebug_unmap_alignment;
2887 sector_div(lba, sdebug_unmap_granularity);
b90ebc3d
AM		 2888 return lba;
2889}
2890
2891static sector_t map_index_to_lba(unsigned long index)
44d92694 2892{
773642d9 2893 sector_t lba = index * sdebug_unmap_granularity;
a027b5b9 2894
773642d9
DG		 2895 if (sdebug_unmap_alignment)
2896 lba -= sdebug_unmap_granularity - sdebug_unmap_alignment;
a027b5b9 2897 return lba;
b90ebc3d 2898}
44d92694 2899
b90ebc3d
AM		 2900static unsigned int map_state(sector_t lba, unsigned int *num)
2901{
2902 sector_t end;
2903 unsigned int mapped;
2904 unsigned long index;
2905 unsigned long next;
44d92694 2906
b90ebc3d
AM		 2907 index = lba_to_map_index(lba);
2908 mapped = test_bit(index, map_storep);
44d92694
MP		 2909
2910 if (mapped)
b90ebc3d 2911 next = find_next_zero_bit(map_storep, map_size, index);
44d92694 2912 else
b90ebc3d 2913 next = find_next_bit(map_storep, map_size, index);
44d92694 2914
b90ebc3d 2915 end = min_t(sector_t, sdebug_store_sectors, map_index_to_lba(next));
44d92694 2916 *num = end - lba;
44d92694
MP		 2917 return mapped;
2918}
2919
2920static void map_region(sector_t lba, unsigned int len)
2921{
44d92694
MP		 2922 sector_t end = lba + len;
2923
44d92694 2924 while (lba < end) {
b90ebc3d 2925 unsigned long index = lba_to_map_index(lba);
44d92694 2926
b90ebc3d
AM		 2927 if (index < map_size)
2928 set_bit(index, map_storep);
44d92694 2929
b90ebc3d 2930 lba = map_index_to_lba(index + 1);
44d92694
MP		 2931 }
2932}
2933
2934static void unmap_region(sector_t lba, unsigned int len)
2935{
44d92694
MP		 2936 sector_t end = lba + len;
2937
44d92694 2938 while (lba < end) {
b90ebc3d 2939 unsigned long index = lba_to_map_index(lba);
44d92694 2940
b90ebc3d 2941 if (lba == map_index_to_lba(index) &&
773642d9 2942 lba + sdebug_unmap_granularity <= end &&
b90ebc3d
AM		 2943 index < map_size) {
2944 clear_bit(index, map_storep);
760f3b03 2945 if (sdebug_lbprz) { /* for LBPRZ=2 return 0xff_s */
be1dd78d 2946 memset(fake_storep +
760f3b03
DG		 2947 lba * sdebug_sector_size,
2948 (sdebug_lbprz & 1) ? 0 : 0xff,
773642d9
DG		 2949 sdebug_sector_size *
2950 sdebug_unmap_granularity);
b90ebc3d 2951 }
e9926b43
AM		 2952 if (dif_storep) {
2953 memset(dif_storep + lba, 0xff,
2954 sizeof(*dif_storep) *
773642d9 2955 sdebug_unmap_granularity);
e9926b43 2956 }
be1dd78d 2957 }
b90ebc3d 2958 lba = map_index_to_lba(index + 1);
44d92694
MP		 2959 }
2960}
2961
fd32119b 2962static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
1da177e4 2963{
c2248fc9
DG		 2964 u8 *cmd = scp->cmnd;
2965 u64 lba;
2966 u32 num;
2967 u32 ei_lba;
1da177e4 2968 unsigned long iflags;
19789100 2969 int ret;
c2248fc9 2970 bool check_prot;
1da177e4 2971
c2248fc9
DG		 2972 switch (cmd[0]) {
2973 case WRITE_16:
2974 ei_lba = 0;
2975 lba = get_unaligned_be64(cmd + 2);
2976 num = get_unaligned_be32(cmd + 10);
2977 check_prot = true;
2978 break;
2979 case WRITE_10:
2980 ei_lba = 0;
2981 lba = get_unaligned_be32(cmd + 2);
2982 num = get_unaligned_be16(cmd + 7);
2983 check_prot = true;
2984 break;
2985 case WRITE_6:
2986 ei_lba = 0;
2987 lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
2988 (u32)(cmd[1] & 0x1f) << 16;
2989 num = (0 == cmd[4]) ? 256 : cmd[4];
2990 check_prot = true;
2991 break;
2992 case WRITE_12:
2993 ei_lba = 0;
2994 lba = get_unaligned_be32(cmd + 2);
2995 num = get_unaligned_be32(cmd + 6);
2996 check_prot = true;
2997 break;
2998 case 0x53: /* XDWRITEREAD(10) */
2999 ei_lba = 0;
3000 lba = get_unaligned_be32(cmd + 2);
3001 num = get_unaligned_be16(cmd + 7);
3002 check_prot = false;
3003 break;
3004 default: /* assume WRITE(32) */
3005 lba = get_unaligned_be64(cmd + 12);
3006 ei_lba = get_unaligned_be32(cmd + 20);
3007 num = get_unaligned_be32(cmd + 28);
3008 check_prot = false;
3009 break;
3010 }
f46eb0e9 3011 if (unlikely(have_dif_prot && check_prot)) {
8475c811 3012 if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
c2248fc9
DG		 3013 (cmd[1] & 0xe0)) {
3014 mk_sense_invalid_opcode(scp);
3015 return check_condition_result;
3016 }
8475c811
CH		 3017 if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3018 sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
c2248fc9
DG		 3019 (cmd[1] & 0xe0) == 0)
3020 sdev_printk(KERN_ERR, scp->device, "Unprotected WR "
3021 "to DIF device\n");
3022 }
3023
3024 /* inline check_device_access_params() */
f46eb0e9 3025 if (unlikely(lba + num > sdebug_capacity)) {
c2248fc9
DG		 3026 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
3027 return check_condition_result;
3028 }
3029 /* transfer length excessive (tie in to block limits VPD page) */
f46eb0e9 3030 if (unlikely(num > sdebug_store_sectors)) {
c2248fc9
DG		 3031 /* needs work to find which cdb byte 'num' comes from */
3032 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
3033 return check_condition_result;
3034 }
1da177e4 3035
6c78cc06
AM		 3036 write_lock_irqsave(&atomic_rw, iflags);
3037
c6a44287 3038 /* DIX + T10 DIF */
f46eb0e9 3039 if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
c2248fc9 3040 int prot_ret = prot_verify_write(scp, lba, num, ei_lba);
c6a44287
MP		 3041
3042 if (prot_ret) {
6c78cc06 3043 write_unlock_irqrestore(&atomic_rw, iflags);
c2248fc9 3044 mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, prot_ret);
c6a44287
MP		 3045 return illegal_condition_result;
3046 }
3047 }
3048
0a7e69c7 3049 ret = do_device_access(scp, 0, lba, num, true);
f46eb0e9 3050 if (unlikely(scsi_debug_lbp()))
44d92694 3051 map_region(lba, num);
1da177e4 3052 write_unlock_irqrestore(&atomic_rw, iflags);
f46eb0e9 3053 if (unlikely(-1 == ret))
773642d9 3054 return DID_ERROR << 16;
c4837394
DG		 3055 else if (unlikely(sdebug_verbose &&
3056 (ret < (num * sdebug_sector_size))))
c2248fc9 3057 sdev_printk(KERN_INFO, scp->device,
cbf67842 3058 "%s: write: cdb indicated=%u, IO sent=%d bytes\n",
773642d9 3059 my_name, num * sdebug_sector_size, ret);
44d92694 3060
f46eb0e9 3061 if (unlikely(sdebug_any_injecting_opt)) {
c4837394
DG		 3062 struct sdebug_queued_cmd *sqcp =
3063 (struct sdebug_queued_cmd *)scp->host_scribble;
c2248fc9 3064
c4837394
DG		 3065 if (sqcp) {
3066 if (sqcp->inj_recovered) {
3067 mk_sense_buffer(scp, RECOVERED_ERROR,
3068 THRESHOLD_EXCEEDED, 0);
3069 return check_condition_result;
3070 } else if (sqcp->inj_dif) {
3071 /* Logical block guard check failed */
3072 mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
3073 return illegal_condition_result;
3074 } else if (sqcp->inj_dix) {
3075 mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
3076 return illegal_condition_result;
3077 }
c2248fc9
DG		 3078 }
3079 }
44d92694
MP		 3080 return 0;
3081}
3082
481b5e5c
DG		 3083/*
3084 * T10 has only specified WRITE SCATTERED(16) and WRITE SCATTERED(32).
3085 * No READ GATHERED yet (requires bidi or long cdb holding gather list).
3086 */
3087static int resp_write_scat(struct scsi_cmnd *scp,
3088 struct sdebug_dev_info *devip)
3089{
3090 u8 *cmd = scp->cmnd;
3091 u8 *lrdp = NULL;
3092 u8 *up;
3093 u8 wrprotect;
3094 u16 lbdof, num_lrd, k;
3095 u32 num, num_by, bt_len, lbdof_blen, sg_off, cum_lb;
3096 u32 lb_size = sdebug_sector_size;
3097 u32 ei_lba;
3098 u64 lba;
3099 unsigned long iflags;
3100 int ret, res;
3101 bool is_16;
3102 static const u32 lrd_size = 32; /* + parameter list header size */
3103
3104 if (cmd[0] == VARIABLE_LENGTH_CMD) {
3105 is_16 = false;
3106 wrprotect = (cmd[10] >> 5) & 0x7;
3107 lbdof = get_unaligned_be16(cmd + 12);
3108 num_lrd = get_unaligned_be16(cmd + 16);
3109 bt_len = get_unaligned_be32(cmd + 28);
3110 } else { /* that leaves WRITE SCATTERED(16) */
3111 is_16 = true;
3112 wrprotect = (cmd[2] >> 5) & 0x7;
3113 lbdof = get_unaligned_be16(cmd + 4);
3114 num_lrd = get_unaligned_be16(cmd + 8);
3115 bt_len = get_unaligned_be32(cmd + 10);
3116 if (unlikely(have_dif_prot)) {
3117 if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
3118 wrprotect) {
3119 mk_sense_invalid_opcode(scp);
3120 return illegal_condition_result;
3121 }
3122 if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3123 sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
3124 wrprotect == 0)
3125 sdev_printk(KERN_ERR, scp->device,
3126 "Unprotected WR to DIF device\n");
3127 }
3128 }
3129 if ((num_lrd == 0) || (bt_len == 0))
3130 return 0; /* T10 says these do-nothings are not errors */
3131 if (lbdof == 0) {
3132 if (sdebug_verbose)
3133 sdev_printk(KERN_INFO, scp->device,
3134 "%s: %s: LB Data Offset field bad\n",
3135 my_name, __func__);
3136 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
3137 return illegal_condition_result;
3138 }
3139 lbdof_blen = lbdof * lb_size;
3140 if ((lrd_size + (num_lrd * lrd_size)) > lbdof_blen) {
3141 if (sdebug_verbose)
3142 sdev_printk(KERN_INFO, scp->device,
3143 "%s: %s: LBA range descriptors don't fit\n",
3144 my_name, __func__);
3145 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
3146 return illegal_condition_result;
3147 }
3148 lrdp = kzalloc(lbdof_blen, GFP_ATOMIC);
3149 if (lrdp == NULL)
3150 return SCSI_MLQUEUE_HOST_BUSY;
3151 if (sdebug_verbose)
3152 sdev_printk(KERN_INFO, scp->device,
3153 "%s: %s: Fetch header+scatter_list, lbdof_blen=%u\n",
3154 my_name, __func__, lbdof_blen);
3155 res = fetch_to_dev_buffer(scp, lrdp, lbdof_blen);
3156 if (res == -1) {
3157 ret = DID_ERROR << 16;
3158 goto err_out;
3159 }
3160
3161 write_lock_irqsave(&atomic_rw, iflags);
3162 sg_off = lbdof_blen;
3163 /* Spec says Buffer xfer Length field in number of LBs in dout */
3164 cum_lb = 0;
3165 for (k = 0, up = lrdp + lrd_size; k < num_lrd; ++k, up += lrd_size) {
3166 lba = get_unaligned_be64(up + 0);
3167 num = get_unaligned_be32(up + 8);
3168 if (sdebug_verbose)
3169 sdev_printk(KERN_INFO, scp->device,
3170 "%s: %s: k=%d LBA=0x%llx num=%u sg_off=%u\n",
3171 my_name, __func__, k, lba, num, sg_off);
3172 if (num == 0)
3173 continue;
3174 ret = check_device_access_params(scp, lba, num);
3175 if (ret)
3176 goto err_out_unlock;
3177 num_by = num * lb_size;
3178 ei_lba = is_16 ? 0 : get_unaligned_be32(up + 12);
3179
3180 if ((cum_lb + num) > bt_len) {
3181 if (sdebug_verbose)
3182 sdev_printk(KERN_INFO, scp->device,
3183 "%s: %s: sum of blocks > data provided\n",
3184 my_name, __func__);
3185 mk_sense_buffer(scp, ILLEGAL_REQUEST, WRITE_ERROR_ASC,
3186 0);
3187 ret = illegal_condition_result;
3188 goto err_out_unlock;
3189 }
3190
3191 /* DIX + T10 DIF */
3192 if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
3193 int prot_ret = prot_verify_write(scp, lba, num,
3194 ei_lba);
3195
3196 if (prot_ret) {
3197 mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10,
3198 prot_ret);
3199 ret = illegal_condition_result;
3200 goto err_out_unlock;
3201 }
3202 }
3203
3204 ret = do_device_access(scp, sg_off, lba, num, true);
3205 if (unlikely(scsi_debug_lbp()))
3206 map_region(lba, num);
3207 if (unlikely(-1 == ret)) {
3208 ret = DID_ERROR << 16;
3209 goto err_out_unlock;
3210 } else if (unlikely(sdebug_verbose && (ret < num_by)))
3211 sdev_printk(KERN_INFO, scp->device,
3212 "%s: write: cdb indicated=%u, IO sent=%d bytes\n",
3213 my_name, num_by, ret);
3214
3215 if (unlikely(sdebug_any_injecting_opt)) {
3216 struct sdebug_queued_cmd *sqcp =
3217 (struct sdebug_queued_cmd *)scp->host_scribble;
3218
3219 if (sqcp) {
3220 if (sqcp->inj_recovered) {
3221 mk_sense_buffer(scp, RECOVERED_ERROR,
3222 THRESHOLD_EXCEEDED, 0);
3223 ret = illegal_condition_result;
3224 goto err_out_unlock;
3225 } else if (sqcp->inj_dif) {
3226 /* Logical block guard check failed */
3227 mk_sense_buffer(scp, ABORTED_COMMAND,
3228 0x10, 1);
3229 ret = illegal_condition_result;
3230 goto err_out_unlock;
3231 } else if (sqcp->inj_dix) {
3232 mk_sense_buffer(scp, ILLEGAL_REQUEST,
3233 0x10, 1);
3234 ret = illegal_condition_result;
3235 goto err_out_unlock;
3236 }
3237 }
3238 }
3239 sg_off += num_by;
3240 cum_lb += num;
3241 }
3242 ret = 0;
3243err_out_unlock:
3244 write_unlock_irqrestore(&atomic_rw, iflags);
3245err_out:
3246 kfree(lrdp);
3247 return ret;
3248}
3249
fd32119b
DG		 3250static int resp_write_same(struct scsi_cmnd *scp, u64 lba, u32 num,
3251 u32 ei_lba, bool unmap, bool ndob)
44d92694
MP		 3252{
3253 unsigned long iflags;
3254 unsigned long long i;
3255 int ret;
773642d9 3256 u64 lba_off;
44d92694 3257
c2248fc9 3258 ret = check_device_access_params(scp, lba, num);
44d92694
MP		 3259 if (ret)
3260 return ret;
3261
3262 write_lock_irqsave(&atomic_rw, iflags);
3263
9ed8d3dc 3264 if (unmap && scsi_debug_lbp()) {
44d92694
MP		 3265 unmap_region(lba, num);
3266 goto out;
3267 }
3268
773642d9 3269 lba_off = lba * sdebug_sector_size;
c2248fc9
DG		 3270 /* if ndob then zero 1 logical block, else fetch 1 logical block */
3271 if (ndob) {
773642d9 3272 memset(fake_storep + lba_off, 0, sdebug_sector_size);
c2248fc9
DG		 3273 ret = 0;
3274 } else
773642d9
DG		 3275 ret = fetch_to_dev_buffer(scp, fake_storep + lba_off,
3276 sdebug_sector_size);
44d92694
MP		 3277
3278 if (-1 == ret) {
3279 write_unlock_irqrestore(&atomic_rw, iflags);
773642d9 3280 return DID_ERROR << 16;
e33d7c56 3281 } else if (sdebug_verbose && !ndob && (ret < sdebug_sector_size))
c2248fc9 3282 sdev_printk(KERN_INFO, scp->device,
e33d7c56 3283 "%s: %s: lb size=%u, IO sent=%d bytes\n",
cbf67842 3284 my_name, "write same",
e33d7c56 3285 sdebug_sector_size, ret);
44d92694
MP		 3286
3287 /* Copy first sector to remaining blocks */
3288 for (i = 1 ; i < num ; i++)
773642d9
DG		 3289 memcpy(fake_storep + ((lba + i) * sdebug_sector_size),
3290 fake_storep + lba_off,
3291 sdebug_sector_size);
44d92694 3292
9ed8d3dc 3293 if (scsi_debug_lbp())
44d92694
MP		 3294 map_region(lba, num);
3295out:
3296 write_unlock_irqrestore(&atomic_rw, iflags);
3297
1da177e4
LT		 3298 return 0;
3299}
3300
fd32119b
DG		 3301static int resp_write_same_10(struct scsi_cmnd *scp,
3302 struct sdebug_dev_info *devip)
c2248fc9
DG		 3303{
3304 u8 *cmd = scp->cmnd;
3305 u32 lba;
3306 u16 num;
3307 u32 ei_lba = 0;
3308 bool unmap = false;
3309
3310 if (cmd[1] & 0x8) {
773642d9 3311 if (sdebug_lbpws10 == 0) {
c2248fc9
DG		 3312 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 3);
3313 return check_condition_result;
3314 } else
3315 unmap = true;
3316 }
3317 lba = get_unaligned_be32(cmd + 2);
3318 num = get_unaligned_be16(cmd + 7);
773642d9 3319 if (num > sdebug_write_same_length) {
c2248fc9
DG		 3320 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 7, -1);
3321 return check_condition_result;
3322 }
3323 return resp_write_same(scp, lba, num, ei_lba, unmap, false);
3324}
3325
fd32119b
DG		 3326static int resp_write_same_16(struct scsi_cmnd *scp,
3327 struct sdebug_dev_info *devip)
c2248fc9
DG		 3328{
3329 u8 *cmd = scp->cmnd;
3330 u64 lba;
3331 u32 num;
3332 u32 ei_lba = 0;
3333 bool unmap = false;
3334 bool ndob = false;
3335
3336 if (cmd[1] & 0x8) { /* UNMAP */
773642d9 3337 if (sdebug_lbpws == 0) {
c2248fc9
DG		 3338 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 3);
3339 return check_condition_result;
3340 } else
3341 unmap = true;
3342 }
3343 if (cmd[1] & 0x1) /* NDOB (no data-out buffer, assumes zeroes) */
3344 ndob = true;
3345 lba = get_unaligned_be64(cmd + 2);
3346 num = get_unaligned_be32(cmd + 10);
773642d9 3347 if (num > sdebug_write_same_length) {
c2248fc9
DG		 3348 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 10, -1);
3349 return check_condition_result;
3350 }
3351 return resp_write_same(scp, lba, num, ei_lba, unmap, ndob);
3352}
3353
acafd0b9
EM		 3354/* Note the mode field is in the same position as the (lower) service action
3355 * field. For the Report supported operation codes command, SPC-4 suggests
3356 * each mode of this command should be reported separately; for future. */
fd32119b
DG		 3357static int resp_write_buffer(struct scsi_cmnd *scp,
3358 struct sdebug_dev_info *devip)
acafd0b9
EM		 3359{
3360 u8 *cmd = scp->cmnd;
3361 struct scsi_device *sdp = scp->device;
3362 struct sdebug_dev_info *dp;
3363 u8 mode;
3364
3365 mode = cmd[1] & 0x1f;
3366 switch (mode) {
3367 case 0x4: /* download microcode (MC) and activate (ACT) */
3368 /* set UAs on this device only */
3369 set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
3370 set_bit(SDEBUG_UA_MICROCODE_CHANGED, devip->uas_bm);
3371 break;
3372 case 0x5: /* download MC, save and ACT */
3373 set_bit(SDEBUG_UA_MICROCODE_CHANGED_WO_RESET, devip->uas_bm);
3374 break;
3375 case 0x6: /* download MC with offsets and ACT */
3376 /* set UAs on most devices (LUs) in this target */
3377 list_for_each_entry(dp,
3378 &devip->sdbg_host->dev_info_list,
3379 dev_list)
3380 if (dp->target == sdp->id) {
3381 set_bit(SDEBUG_UA_BUS_RESET, dp->uas_bm);
3382 if (devip != dp)
3383 set_bit(SDEBUG_UA_MICROCODE_CHANGED,
3384 dp->uas_bm);
3385 }
3386 break;
3387 case 0x7: /* download MC with offsets, save, and ACT */
3388 /* set UA on all devices (LUs) in this target */
3389 list_for_each_entry(dp,
3390 &devip->sdbg_host->dev_info_list,
3391 dev_list)
3392 if (dp->target == sdp->id)
3393 set_bit(SDEBUG_UA_MICROCODE_CHANGED_WO_RESET,
3394 dp->uas_bm);
3395 break;
3396 default:
3397 /* do nothing for this command for other mode values */
3398 break;
3399 }
3400 return 0;
3401}
3402
fd32119b
DG		 3403static int resp_comp_write(struct scsi_cmnd *scp,
3404 struct sdebug_dev_info *devip)
38d5c833
DG		 3405{
3406 u8 *cmd = scp->cmnd;
3407 u8 *arr;
3408 u8 *fake_storep_hold;
3409 u64 lba;
3410 u32 dnum;
773642d9 3411 u32 lb_size = sdebug_sector_size;
38d5c833
DG		 3412 u8 num;
3413 unsigned long iflags;
3414 int ret;
d467d31f 3415 int retval = 0;
38d5c833 3416
d467d31f 3417 lba = get_unaligned_be64(cmd + 2);
38d5c833
DG		 3418 num = cmd[13]; /* 1 to a maximum of 255 logical blocks */
3419 if (0 == num)
3420 return 0; /* degenerate case, not an error */
8475c811 3421 if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
38d5c833
DG		 3422 (cmd[1] & 0xe0)) {
3423 mk_sense_invalid_opcode(scp);
3424 return check_condition_result;
3425 }
8475c811
CH		 3426 if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3427 sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
38d5c833
DG		 3428 (cmd[1] & 0xe0) == 0)
3429 sdev_printk(KERN_ERR, scp->device, "Unprotected WR "
3430 "to DIF device\n");
3431
3432 /* inline check_device_access_params() */
3433 if (lba + num > sdebug_capacity) {
3434 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
3435 return check_condition_result;
3436 }
3437 /* transfer length excessive (tie in to block limits VPD page) */
3438 if (num > sdebug_store_sectors) {
3439 /* needs work to find which cdb byte 'num' comes from */
3440 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
3441 return check_condition_result;
3442 }
d467d31f
DG		 3443 dnum = 2 * num;
3444 arr = kzalloc(dnum * lb_size, GFP_ATOMIC);
3445 if (NULL == arr) {
3446 mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
3447 INSUFF_RES_ASCQ);
3448 return check_condition_result;
3449 }
38d5c833
DG		 3450
3451 write_lock_irqsave(&atomic_rw, iflags);
3452
3453 /* trick do_device_access() to fetch both compare and write buffers
3454 * from data-in into arr. Safe (atomic) since write_lock held. */
3455 fake_storep_hold = fake_storep;
3456 fake_storep = arr;
0a7e69c7 3457 ret = do_device_access(scp, 0, 0, dnum, true);
38d5c833
DG		 3458 fake_storep = fake_storep_hold;
3459 if (ret == -1) {
d467d31f
DG		 3460 retval = DID_ERROR << 16;
3461 goto cleanup;
773642d9 3462 } else if (sdebug_verbose && (ret < (dnum * lb_size)))
38d5c833
DG		 3463 sdev_printk(KERN_INFO, scp->device, "%s: compare_write: cdb "
3464 "indicated=%u, IO sent=%d bytes\n", my_name,
3465 dnum * lb_size, ret);
3466 if (!comp_write_worker(lba, num, arr)) {
38d5c833 3467 mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
d467d31f
DG		 3468 retval = check_condition_result;
3469 goto cleanup;
38d5c833
DG		 3470 }
3471 if (scsi_debug_lbp())
3472 map_region(lba, num);
d467d31f 3473cleanup:
38d5c833 3474 write_unlock_irqrestore(&atomic_rw, iflags);
d467d31f
DG		 3475 kfree(arr);
3476 return retval;
38d5c833
DG		 3477}
3478
44d92694
MP		 3479struct unmap_block_desc {
3480 __be64 lba;
3481 __be32 blocks;
3482 __be32 __reserved;
3483};
3484
fd32119b 3485static int resp_unmap(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
44d92694
MP		 3486{
3487 unsigned char *buf;
3488 struct unmap_block_desc *desc;
3489 unsigned int i, payload_len, descriptors;
3490 int ret;
6c78cc06 3491 unsigned long iflags;
44d92694 3492
44d92694 3493
c2248fc9
DG		 3494 if (!scsi_debug_lbp())
3495 return 0; /* fib and say its done */
3496 payload_len = get_unaligned_be16(scp->cmnd + 7);
3497 BUG_ON(scsi_bufflen(scp) != payload_len);
44d92694
MP		 3498
3499 descriptors = (payload_len - 8) / 16;
773642d9 3500 if (descriptors > sdebug_unmap_max_desc) {
c2248fc9
DG		 3501 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 7, -1);
3502 return check_condition_result;
3503 }
44d92694 3504
b333a819 3505 buf = kzalloc(scsi_bufflen(scp), GFP_ATOMIC);
c2248fc9
DG		 3506 if (!buf) {
3507 mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
3508 INSUFF_RES_ASCQ);
44d92694 3509 return check_condition_result;
c2248fc9 3510 }
44d92694 3511
c2248fc9 3512 scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
44d92694
MP		 3513
3514 BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2);
3515 BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16);
3516
3517 desc = (void *)&buf[8];
3518
6c78cc06
AM		 3519 write_lock_irqsave(&atomic_rw, iflags);
3520
44d92694
MP		 3521 for (i = 0 ; i < descriptors ; i++) {
3522 unsigned long long lba = get_unaligned_be64(&desc[i].lba);
3523 unsigned int num = get_unaligned_be32(&desc[i].blocks);
3524
c2248fc9 3525 ret = check_device_access_params(scp, lba, num);
44d92694
MP		 3526 if (ret)
3527 goto out;
3528
3529 unmap_region(lba, num);
3530 }
3531
3532 ret = 0;
3533
3534out:
6c78cc06 3535 write_unlock_irqrestore(&atomic_rw, iflags);
44d92694
MP		 3536 kfree(buf);
3537
3538 return ret;
3539}
3540
3541#define SDEBUG_GET_LBA_STATUS_LEN 32
3542
fd32119b
DG		 3543static int resp_get_lba_status(struct scsi_cmnd *scp,
3544 struct sdebug_dev_info *devip)
44d92694 3545{
c2248fc9
DG		 3546 u8 *cmd = scp->cmnd;
3547 u64 lba;
3548 u32 alloc_len, mapped, num;
3549 u8 arr[SDEBUG_GET_LBA_STATUS_LEN];
44d92694
MP		 3550 int ret;
3551
c2248fc9
DG		 3552 lba = get_unaligned_be64(cmd + 2);
3553 alloc_len = get_unaligned_be32(cmd + 10);
44d92694
MP		 3554
3555 if (alloc_len < 24)
3556 return 0;
3557
c2248fc9 3558 ret = check_device_access_params(scp, lba, 1);
44d92694
MP		 3559 if (ret)
3560 return ret;
3561
c2248fc9
DG		 3562 if (scsi_debug_lbp())
3563 mapped = map_state(lba, &num);
3564 else {
3565 mapped = 1;
3566 /* following just in case virtual_gb changed */
3567 sdebug_capacity = get_sdebug_capacity();
3568 if (sdebug_capacity - lba <= 0xffffffff)
3569 num = sdebug_capacity - lba;
3570 else
3571 num = 0xffffffff;
3572 }
44d92694
MP		 3573
3574 memset(arr, 0, SDEBUG_GET_LBA_STATUS_LEN);
c2248fc9
DG		 3575 put_unaligned_be32(20, arr); /* Parameter Data Length */
3576 put_unaligned_be64(lba, arr + 8); /* LBA */
3577 put_unaligned_be32(num, arr + 16); /* Number of blocks */
3578 arr[20] = !mapped; /* prov_stat=0: mapped; 1: dealloc */
44d92694 3579
c2248fc9 3580 return fill_from_dev_buffer(scp, arr, SDEBUG_GET_LBA_STATUS_LEN);
44d92694
MP		 3581}
3582
80c49563
DG		 3583static int resp_sync_cache(struct scsi_cmnd *scp,
3584 struct sdebug_dev_info *devip)
3585{
3586 u64 lba;
3587 u32 num_blocks;
3588 u8 *cmd = scp->cmnd;
3589
3590 if (cmd[0] == SYNCHRONIZE_CACHE) { /* 10 byte cdb */
3591 lba = get_unaligned_be32(cmd + 2);
3592 num_blocks = get_unaligned_be16(cmd + 7);
3593 } else { /* SYNCHRONIZE_CACHE(16) */
3594 lba = get_unaligned_be64(cmd + 2);
3595 num_blocks = get_unaligned_be32(cmd + 10);
3596 }
3597 if (lba + num_blocks > sdebug_capacity) {
3598 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
3599 return check_condition_result;
3600 }
3601 return (cmd[1] & 0x2) ? SDEG_RES_IMMED_MASK : 0; /* check IMMED bit */
3602}
3603
fb0cc8d1
DG		 3604#define RL_BUCKET_ELEMS 8
3605
8d039e22
DG		 3606/* Even though each pseudo target has a REPORT LUNS "well known logical unit"
3607 * (W-LUN), the normal Linux scanning logic does not associate it with a
3608 * device (e.g. /dev/sg7). The following magic will make that association:
3609 * "cd /sys/class/scsi_host/host<n> ; echo '- - 49409' > scan"
3610 * where <n> is a host number. If there are multiple targets in a host then
3611 * the above will associate a W-LUN to each target. To only get a W-LUN
3612 * for target 2, then use "echo '- 2 49409' > scan" .
3613 */
3614static int resp_report_luns(struct scsi_cmnd *scp,
3615 struct sdebug_dev_info *devip)
1da177e4 3616{
8d039e22 3617 unsigned char *cmd = scp->cmnd;
1da177e4 3618 unsigned int alloc_len;
8d039e22 3619 unsigned char select_report;
22017ed2 3620 u64 lun;
8d039e22 3621 struct scsi_lun *lun_p;
fb0cc8d1 3622 u8 arr[RL_BUCKET_ELEMS * sizeof(struct scsi_lun)];
8d039e22
DG		 3623 unsigned int lun_cnt; /* normal LUN count (max: 256) */
3624 unsigned int wlun_cnt; /* report luns W-LUN count */
3625 unsigned int tlun_cnt; /* total LUN count */
3626 unsigned int rlen; /* response length (in bytes) */
fb0cc8d1
DG		 3627 int k, j, n, res;
3628 unsigned int off_rsp = 0;
3629 const int sz_lun = sizeof(struct scsi_lun);
1da177e4 3630
19c8ead7 3631 clear_luns_changed_on_target(devip);
8d039e22
DG		 3632
3633 select_report = cmd[2];
3634 alloc_len = get_unaligned_be32(cmd + 6);
3635
3636 if (alloc_len < 4) {
3637 pr_err("alloc len too small %d\n", alloc_len);
3638 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
1da177e4
LT		 3639 return check_condition_result;
3640 }
8d039e22
DG		 3641
3642 switch (select_report) {
3643 case 0: /* all LUNs apart from W-LUNs */
3644 lun_cnt = sdebug_max_luns;
3645 wlun_cnt = 0;
3646 break;
3647 case 1: /* only W-LUNs */
c65b1445 3648 lun_cnt = 0;
8d039e22
DG		 3649 wlun_cnt = 1;
3650 break;
3651 case 2: /* all LUNs */
3652 lun_cnt = sdebug_max_luns;
3653 wlun_cnt = 1;
3654 break;
3655 case 0x10: /* only administrative LUs */
3656 case 0x11: /* see SPC-5 */
3657 case 0x12: /* only subsiduary LUs owned by referenced LU */
3658 default:
3659 pr_debug("select report invalid %d\n", select_report);
3660 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, -1);
3661 return check_condition_result;
3662 }
3663
3664 if (sdebug_no_lun_0 && (lun_cnt > 0))
c65b1445 3665 --lun_cnt;
8d039e22
DG		 3666
3667 tlun_cnt = lun_cnt + wlun_cnt;
fb0cc8d1
DG		 3668 rlen = tlun_cnt * sz_lun; /* excluding 8 byte header */
3669 scsi_set_resid(scp, scsi_bufflen(scp));
8d039e22
DG		 3670 pr_debug("select_report %d luns = %d wluns = %d no_lun0 %d\n",
3671 select_report, lun_cnt, wlun_cnt, sdebug_no_lun_0);
3672
fb0cc8d1 3673 /* loops rely on sizeof response header same as sizeof lun (both 8) */
8d039e22 3674 lun = sdebug_no_lun_0 ? 1 : 0;
fb0cc8d1
DG		 3675 for (k = 0, j = 0, res = 0; true; ++k, j = 0) {
3676 memset(arr, 0, sizeof(arr));
3677 lun_p = (struct scsi_lun *)&arr[0];
3678 if (k == 0) {
3679 put_unaligned_be32(rlen, &arr[0]);
3680 ++lun_p;
3681 j = 1;
3682 }
3683 for ( ; j < RL_BUCKET_ELEMS; ++j, ++lun_p) {
3684 if ((k * RL_BUCKET_ELEMS) + j > lun_cnt)
3685 break;
3686 int_to_scsilun(lun++, lun_p);
3687 }
3688 if (j < RL_BUCKET_ELEMS)
3689 break;
3690 n = j * sz_lun;
3691 res = p_fill_from_dev_buffer(scp, arr, n, off_rsp);
3692 if (res)
3693 return res;
3694 off_rsp += n;
3695 }
3696 if (wlun_cnt) {
3697 int_to_scsilun(SCSI_W_LUN_REPORT_LUNS, lun_p);
3698 ++j;
3699 }
3700 if (j > 0)
3701 res = p_fill_from_dev_buffer(scp, arr, j * sz_lun, off_rsp);
8d039e22 3702 return res;
1da177e4
LT		 3703}
3704
c639d14e
FT		 3705static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
3706 unsigned int num, struct sdebug_dev_info *devip)
3707{
be4e11be 3708 int j;
c639d14e
FT		 3709 unsigned char *kaddr, *buf;
3710 unsigned int offset;
c639d14e 3711 struct scsi_data_buffer *sdb = scsi_in(scp);
be4e11be 3712 struct sg_mapping_iter miter;
c639d14e
FT		 3713
3714 /* better not to use temporary buffer. */
b333a819 3715 buf = kzalloc(scsi_bufflen(scp), GFP_ATOMIC);
c5af0db9 3716 if (!buf) {
22017ed2
DG		 3717 mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
3718 INSUFF_RES_ASCQ);
c5af0db9
AM		 3719 return check_condition_result;
3720 }
c639d14e 3721
21a61829 3722 scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
c639d14e
FT		 3723
3724 offset = 0;
be4e11be
AM		 3725 sg_miter_start(&miter, sdb->table.sgl, sdb->table.nents,
3726 SG_MITER_ATOMIC | SG_MITER_TO_SG);
c639d14e 3727
be4e11be
AM		 3728 while (sg_miter_next(&miter)) {
3729 kaddr = miter.addr;
3730 for (j = 0; j < miter.length; j++)
3731 *(kaddr + j) ^= *(buf + offset + j);
c639d14e 3732
be4e11be 3733 offset += miter.length;
c639d14e 3734 }
be4e11be 3735 sg_miter_stop(&miter);
c639d14e
FT		 3736 kfree(buf);
3737
be4e11be 3738 return 0;
c639d14e
FT		 3739}
3740
fd32119b
DG		 3741static int resp_xdwriteread_10(struct scsi_cmnd *scp,
3742 struct sdebug_dev_info *devip)
c2248fc9
DG		 3743{
3744 u8 *cmd = scp->cmnd;
3745 u64 lba;
3746 u32 num;
3747 int errsts;
3748
3749 if (!scsi_bidi_cmnd(scp)) {
3750 mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
3751 INSUFF_RES_ASCQ);
3752 return check_condition_result;
3753 }
3754 errsts = resp_read_dt0(scp, devip);
3755 if (errsts)
3756 return errsts;
3757 if (!(cmd[1] & 0x4)) { /* DISABLE_WRITE is not set */
3758 errsts = resp_write_dt0(scp, devip);
3759 if (errsts)
3760 return errsts;
3761 }
3762 lba = get_unaligned_be32(cmd + 2);
3763 num = get_unaligned_be16(cmd + 7);
3764 return resp_xdwriteread(scp, lba, num, devip);
3765}
3766
c4837394
DG		 3767static struct sdebug_queue *get_queue(struct scsi_cmnd *cmnd)
3768{
458df78b
BVA		 3769 u32 tag = blk_mq_unique_tag(cmnd->request);
3770 u16 hwq = blk_mq_unique_tag_to_hwq(tag);
c4837394 3771
458df78b
BVA		 3772 pr_debug("tag=%#x, hwq=%d\n", tag, hwq);
3773 if (WARN_ON_ONCE(hwq >= submit_queues))
3774 hwq = 0;
3775 return sdebug_q_arr + hwq;
c4837394
DG		 3776}
3777
3778/* Queued (deferred) command completions converge here. */
fd32119b 3779static void sdebug_q_cmd_complete(struct sdebug_defer *sd_dp)
1da177e4 3780{
c4837394 3781 int qc_idx;
cbf67842 3782 int retiring = 0;
1da177e4 3783 unsigned long iflags;
c4837394 3784 struct sdebug_queue *sqp;
cbf67842
DG		 3785 struct sdebug_queued_cmd *sqcp;
3786 struct scsi_cmnd *scp;
3787 struct sdebug_dev_info *devip;
1da177e4 3788
10bde980 3789 sd_dp->defer_t = SDEB_DEFER_NONE;
c4837394
DG		 3790 qc_idx = sd_dp->qc_idx;
3791 sqp = sdebug_q_arr + sd_dp->sqa_idx;
3792 if (sdebug_statistics) {
3793 atomic_inc(&sdebug_completions);
3794 if (raw_smp_processor_id() != sd_dp->issuing_cpu)
3795 atomic_inc(&sdebug_miss_cpus);
3796 }
3797 if (unlikely((qc_idx < 0) || (qc_idx >= SDEBUG_CANQUEUE))) {
3798 pr_err("wild qc_idx=%d\n", qc_idx);
1da177e4
LT		 3799 return;
3800 }
c4837394
DG		 3801 spin_lock_irqsave(&sqp->qc_lock, iflags);
3802 sqcp = &sqp->qc_arr[qc_idx];
cbf67842 3803 scp = sqcp->a_cmnd;
b01f6f83 3804 if (unlikely(scp == NULL)) {
c4837394
DG		 3805 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
3806 pr_err("scp is NULL, sqa_idx=%d, qc_idx=%d\n",
3807 sd_dp->sqa_idx, qc_idx);
cbf67842
DG		 3808 return;
3809 }
3810 devip = (struct sdebug_dev_info *)scp->device->hostdata;
f46eb0e9 3811 if (likely(devip))
cbf67842
DG		 3812 atomic_dec(&devip->num_in_q);
3813 else
c1287970 3814 pr_err("devip=NULL\n");
f46eb0e9 3815 if (unlikely(atomic_read(&retired_max_queue) > 0))
cbf67842
DG		 3816 retiring = 1;
3817
3818 sqcp->a_cmnd = NULL;
c4837394
DG		 3819 if (unlikely(!test_and_clear_bit(qc_idx, sqp->in_use_bm))) {
3820 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
c1287970 3821 pr_err("Unexpected completion\n");
1da177e4
LT		 3822 return;
3823 }
cbf67842
DG		 3824
3825 if (unlikely(retiring)) { /* user has reduced max_queue */
3826 int k, retval;
3827
3828 retval = atomic_read(&retired_max_queue);
c4837394
DG		 3829 if (qc_idx >= retval) {
3830 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
c1287970 3831 pr_err("index %d too large\n", retval);
cbf67842
DG		 3832 return;
3833 }
c4837394 3834 k = find_last_bit(sqp->in_use_bm, retval);
773642d9 3835 if ((k < sdebug_max_queue) || (k == retval))
cbf67842
DG		 3836 atomic_set(&retired_max_queue, 0);
3837 else
3838 atomic_set(&retired_max_queue, k + 1);
1da177e4 3839 }
c4837394 3840 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
cbf67842 3841 scp->scsi_done(scp); /* callback to mid level */
1da177e4
LT		 3842}
3843
cbf67842 3844/* When high resolution timer goes off this function is called. */
fd32119b 3845static enum hrtimer_restart sdebug_q_cmd_hrt_complete(struct hrtimer *timer)
cbf67842 3846{
a10bc12a
DG		 3847 struct sdebug_defer *sd_dp = container_of(timer, struct sdebug_defer,
3848 hrt);
3849 sdebug_q_cmd_complete(sd_dp);
cbf67842
DG		 3850 return HRTIMER_NORESTART;
3851}
1da177e4 3852
a10bc12a 3853/* When work queue schedules work, it calls this function. */
fd32119b 3854static void sdebug_q_cmd_wq_complete(struct work_struct *work)
a10bc12a
DG		 3855{
3856 struct sdebug_defer *sd_dp = container_of(work, struct sdebug_defer,
3857 ew.work);
3858 sdebug_q_cmd_complete(sd_dp);
3859}
3860
09ba24c1 3861static bool got_shared_uuid;
bf476433 3862static uuid_t shared_uuid;
09ba24c1 3863
fd32119b
DG		 3864static struct sdebug_dev_info *sdebug_device_create(
3865 struct sdebug_host_info *sdbg_host, gfp_t flags)
5cb2fc06
FT		 3866{
3867 struct sdebug_dev_info *devip;
3868
3869 devip = kzalloc(sizeof(*devip), flags);
3870 if (devip) {
09ba24c1 3871 if (sdebug_uuid_ctl == 1)
bf476433 3872 uuid_gen(&devip->lu_name);
09ba24c1
DG		 3873 else if (sdebug_uuid_ctl == 2) {
3874 if (got_shared_uuid)
3875 devip->lu_name = shared_uuid;
3876 else {
bf476433 3877 uuid_gen(&shared_uuid);
09ba24c1
DG		 3878 got_shared_uuid = true;
3879 devip->lu_name = shared_uuid;
3880 }
3881 }
5cb2fc06
FT		 3882 devip->sdbg_host = sdbg_host;
3883 list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
3884 }
3885 return devip;
3886}
3887
f46eb0e9 3888static struct sdebug_dev_info *find_build_dev_info(struct scsi_device *sdev)
1da177e4 3889{
f46eb0e9
DG		 3890 struct sdebug_host_info *sdbg_host;
3891 struct sdebug_dev_info *open_devip = NULL;
3892 struct sdebug_dev_info *devip;
1da177e4 3893
d1e4c9c5
FT		 3894 sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
3895 if (!sdbg_host) {
c1287970 3896 pr_err("Host info NULL\n");
1da177e4 3897 return NULL;
9a051019 3898 }
1da177e4
LT		 3899 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
3900 if ((devip->used) && (devip->channel == sdev->channel) &&
9a051019
DG		 3901 (devip->target == sdev->id) &&
3902 (devip->lun == sdev->lun))
3903 return devip;
1da177e4
LT		 3904 else {
3905 if ((!devip->used) && (!open_devip))
3906 open_devip = devip;
3907 }
3908 }
5cb2fc06
FT		 3909 if (!open_devip) { /* try and make a new one */
3910 open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC);
3911 if (!open_devip) {
c1287970 3912 pr_err("out of memory at line %d\n", __LINE__);
1da177e4
LT		 3913 return NULL;
3914 }
1da177e4 3915 }
a75869d1
FT		 3916
3917 open_devip->channel = sdev->channel;
3918 open_devip->target = sdev->id;
3919 open_devip->lun = sdev->lun;
3920 open_devip->sdbg_host = sdbg_host;
cbf67842
DG		 3921 atomic_set(&open_devip->num_in_q, 0);
3922 set_bit(SDEBUG_UA_POR, open_devip->uas_bm);
c2248fc9 3923 open_devip->used = true;
a75869d1 3924 return open_devip;
1da177e4
LT		 3925}
3926
8dea0d02 3927static int scsi_debug_slave_alloc(struct scsi_device *sdp)
1da177e4 3928{
773642d9 3929 if (sdebug_verbose)
c1287970 3930 pr_info("slave_alloc <%u %u %u %llu>\n",
8dea0d02 3931 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
75ad23bc 3932 queue_flag_set_unlocked(QUEUE_FLAG_BIDI, sdp->request_queue);
8dea0d02
FT		 3933 return 0;
3934}
1da177e4 3935
8dea0d02
FT		 3936static int scsi_debug_slave_configure(struct scsi_device *sdp)
3937{
f46eb0e9
DG		 3938 struct sdebug_dev_info *devip =
3939 (struct sdebug_dev_info *)sdp->hostdata;
a34c4e98 3940
773642d9 3941 if (sdebug_verbose)
c1287970 3942 pr_info("slave_configure <%u %u %u %llu>\n",
8dea0d02 3943 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
b01f6f83
DG		 3944 if (sdp->host->max_cmd_len != SDEBUG_MAX_CMD_LEN)
3945 sdp->host->max_cmd_len = SDEBUG_MAX_CMD_LEN;
3946 if (devip == NULL) {
f46eb0e9 3947 devip = find_build_dev_info(sdp);
b01f6f83 3948 if (devip == NULL)
f46eb0e9
DG		 3949 return 1; /* no resources, will be marked offline */
3950 }
c8b09f6f 3951 sdp->hostdata = devip;
6bb5e6e7 3952 blk_queue_max_segment_size(sdp->request_queue, -1U);
773642d9 3953 if (sdebug_no_uld)
78d4e5a0 3954 sdp->no_uld_attach = 1;
9b760fd8 3955 config_cdb_len(sdp);
8dea0d02
FT		 3956 return 0;
3957}
3958
3959static void scsi_debug_slave_destroy(struct scsi_device *sdp)
3960{
3961 struct sdebug_dev_info *devip =
3962 (struct sdebug_dev_info *)sdp->hostdata;
a34c4e98 3963
773642d9 3964 if (sdebug_verbose)
c1287970 3965 pr_info("slave_destroy <%u %u %u %llu>\n",
8dea0d02
FT		 3966 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
3967 if (devip) {
25985edc 3968 /* make this slot available for re-use */
c2248fc9 3969 devip->used = false;
8dea0d02
FT		 3970 sdp->hostdata = NULL;
3971 }
3972}
3973
10bde980
DG		 3974static void stop_qc_helper(struct sdebug_defer *sd_dp,
3975 enum sdeb_defer_type defer_t)
c4837394
DG		 3976{
3977 if (!sd_dp)
3978 return;
10bde980 3979 if (defer_t == SDEB_DEFER_HRT)
c4837394 3980 hrtimer_cancel(&sd_dp->hrt);
10bde980 3981 else if (defer_t == SDEB_DEFER_WQ)
c4837394
DG		 3982 cancel_work_sync(&sd_dp->ew.work);
3983}
3984
a10bc12a
DG		 3985/* If @cmnd found deletes its timer or work queue and returns true; else
3986 returns false */
3987static bool stop_queued_cmnd(struct scsi_cmnd *cmnd)
8dea0d02
FT		 3988{
3989 unsigned long iflags;
c4837394 3990 int j, k, qmax, r_qmax;
10bde980 3991 enum sdeb_defer_type l_defer_t;
c4837394 3992 struct sdebug_queue *sqp;
8dea0d02 3993 struct sdebug_queued_cmd *sqcp;
cbf67842 3994 struct sdebug_dev_info *devip;
a10bc12a 3995 struct sdebug_defer *sd_dp;
8dea0d02 3996
c4837394
DG		 3997 for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
3998 spin_lock_irqsave(&sqp->qc_lock, iflags);
3999 qmax = sdebug_max_queue;
4000 r_qmax = atomic_read(&retired_max_queue);
4001 if (r_qmax > qmax)
4002 qmax = r_qmax;
4003 for (k = 0; k < qmax; ++k) {
4004 if (test_bit(k, sqp->in_use_bm)) {
4005 sqcp = &sqp->qc_arr[k];
4006 if (cmnd != sqcp->a_cmnd)
4007 continue;
4008 /* found */
4009 devip = (struct sdebug_dev_info *)
4010 cmnd->device->hostdata;
4011 if (devip)
4012 atomic_dec(&devip->num_in_q);
4013 sqcp->a_cmnd = NULL;
4014 sd_dp = sqcp->sd_dp;
10bde980
DG		 4015 if (sd_dp) {
4016 l_defer_t = sd_dp->defer_t;
4017 sd_dp->defer_t = SDEB_DEFER_NONE;
4018 } else
4019 l_defer_t = SDEB_DEFER_NONE;
c4837394 4020 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
10bde980 4021 stop_qc_helper(sd_dp, l_defer_t);
c4837394
DG		 4022 clear_bit(k, sqp->in_use_bm);
4023 return true;
cbf67842 4024 }
8dea0d02 4025 }
c4837394 4026 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
8dea0d02 4027 }
a10bc12a 4028 return false;
8dea0d02
FT		 4029}
4030
a10bc12a 4031/* Deletes (stops) timers or work queues of all queued commands */
8dea0d02
FT		 4032static void stop_all_queued(void)
4033{
4034 unsigned long iflags;
c4837394 4035 int j, k;
10bde980 4036 enum sdeb_defer_type l_defer_t;
c4837394 4037 struct sdebug_queue *sqp;
8dea0d02 4038 struct sdebug_queued_cmd *sqcp;
cbf67842 4039 struct sdebug_dev_info *devip;
a10bc12a 4040 struct sdebug_defer *sd_dp;
8dea0d02 4041
c4837394
DG		 4042 for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
4043 spin_lock_irqsave(&sqp->qc_lock, iflags);
4044 for (k = 0; k < SDEBUG_CANQUEUE; ++k) {
4045 if (test_bit(k, sqp->in_use_bm)) {
4046 sqcp = &sqp->qc_arr[k];
4047 if (sqcp->a_cmnd == NULL)
4048 continue;
4049 devip = (struct sdebug_dev_info *)
4050 sqcp->a_cmnd->device->hostdata;
4051 if (devip)
4052 atomic_dec(&devip->num_in_q);
4053 sqcp->a_cmnd = NULL;
4054 sd_dp = sqcp->sd_dp;
10bde980
DG		 4055 if (sd_dp) {
4056 l_defer_t = sd_dp->defer_t;
4057 sd_dp->defer_t = SDEB_DEFER_NONE;
4058 } else
4059 l_defer_t = SDEB_DEFER_NONE;
c4837394 4060 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
10bde980 4061 stop_qc_helper(sd_dp, l_defer_t);
c4837394
DG		 4062 clear_bit(k, sqp->in_use_bm);
4063 spin_lock_irqsave(&sqp->qc_lock, iflags);
cbf67842 4064 }
8dea0d02 4065 }
c4837394 4066 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
8dea0d02 4067 }
1da177e4
LT		 4068}
4069
cbf67842
DG		 4070/* Free queued command memory on heap */
4071static void free_all_queued(void)
1da177e4 4072{
c4837394
DG		 4073 int j, k;
4074 struct sdebug_queue *sqp;
cbf67842
DG		 4075 struct sdebug_queued_cmd *sqcp;
4076
c4837394
DG		 4077 for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
4078 for (k = 0; k < SDEBUG_CANQUEUE; ++k) {
4079 sqcp = &sqp->qc_arr[k];
4080 kfree(sqcp->sd_dp);
4081 sqcp->sd_dp = NULL;
4082 }
cbf67842 4083 }
1da177e4
LT		 4084}
4085
cbf67842 4086static int scsi_debug_abort(struct scsi_cmnd *SCpnt)
1da177e4 4087{
a10bc12a
DG		 4088 bool ok;
4089
cbf67842
DG		 4090 ++num_aborts;
4091 if (SCpnt) {
a10bc12a
DG		 4092 ok = stop_queued_cmnd(SCpnt);
4093 if (SCpnt->device && (SDEBUG_OPT_ALL_NOISE & sdebug_opts))
4094 sdev_printk(KERN_INFO, SCpnt->device,
4095 "%s: command%s found\n", __func__,
4096 ok ? "" : " not");
cbf67842
DG		 4097 }
4098 return SUCCESS;
1da177e4
LT		 4099}
4100
91d4c752 4101static int scsi_debug_device_reset(struct scsi_cmnd *SCpnt)
1da177e4 4102{
1da177e4 4103 ++num_dev_resets;
cbf67842
DG		 4104 if (SCpnt && SCpnt->device) {
4105 struct scsi_device *sdp = SCpnt->device;
f46eb0e9
DG		 4106 struct sdebug_dev_info *devip =
4107 (struct sdebug_dev_info *)sdp->hostdata;
cbf67842 4108
773642d9 4109 if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
cbf67842 4110 sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
1da177e4 4111 if (devip)
cbf67842
DG		 4112 set_bit(SDEBUG_UA_POR, devip->uas_bm);
4113 }
4114 return SUCCESS;
4115}
4116
4117static int scsi_debug_target_reset(struct scsi_cmnd *SCpnt)
4118{
4119 struct sdebug_host_info *sdbg_host;
4120 struct sdebug_dev_info *devip;
4121 struct scsi_device *sdp;
4122 struct Scsi_Host *hp;
4123 int k = 0;
4124
4125 ++num_target_resets;
4126 if (!SCpnt)
4127 goto lie;
4128 sdp = SCpnt->device;
4129 if (!sdp)
4130 goto lie;
773642d9 4131 if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
cbf67842
DG		 4132 sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
4133 hp = sdp->host;
4134 if (!hp)
4135 goto lie;
4136 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
4137 if (sdbg_host) {
4138 list_for_each_entry(devip,
4139 &sdbg_host->dev_info_list,
4140 dev_list)
4141 if (devip->target == sdp->id) {
4142 set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
4143 ++k;
4144 }
1da177e4 4145 }
773642d9 4146 if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
cbf67842
DG		 4147 sdev_printk(KERN_INFO, sdp,
4148 "%s: %d device(s) found in target\n", __func__, k);
4149lie:
1da177e4
LT		 4150 return SUCCESS;
4151}
4152
91d4c752 4153static int scsi_debug_bus_reset(struct scsi_cmnd *SCpnt)
1da177e4
LT		 4154{
4155 struct sdebug_host_info *sdbg_host;
cbf67842 4156 struct sdebug_dev_info *devip;
9a051019
DG		 4157 struct scsi_device *sdp;
4158 struct Scsi_Host *hp;
cbf67842 4159 int k = 0;
1da177e4 4160
1da177e4 4161 ++num_bus_resets;
cbf67842
DG		 4162 if (!(SCpnt && SCpnt->device))
4163 goto lie;
4164 sdp = SCpnt->device;
773642d9 4165 if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
cbf67842
DG		 4166 sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
4167 hp = sdp->host;
4168 if (hp) {
d1e4c9c5 4169 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
1da177e4 4170 if (sdbg_host) {
cbf67842 4171 list_for_each_entry(devip,
9a051019 4172 &sdbg_host->dev_info_list,
cbf67842
DG		 4173 dev_list) {
4174 set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
4175 ++k;
4176 }
1da177e4
LT		 4177 }
4178 }
773642d9 4179 if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
cbf67842
DG		 4180 sdev_printk(KERN_INFO, sdp,
4181 "%s: %d device(s) found in host\n", __func__, k);
4182lie:
1da177e4
LT		 4183 return SUCCESS;
4184}
4185
91d4c752 4186static int scsi_debug_host_reset(struct scsi_cmnd *SCpnt)
1da177e4 4187{
91d4c752 4188 struct sdebug_host_info *sdbg_host;
cbf67842
DG		 4189 struct sdebug_dev_info *devip;
4190 int k = 0;
1da177e4 4191
1da177e4 4192 ++num_host_resets;
773642d9 4193 if ((SCpnt->device) && (SDEBUG_OPT_ALL_NOISE & sdebug_opts))
cbf67842 4194 sdev_printk(KERN_INFO, SCpnt->device, "%s\n", __func__);
9a051019
DG		 4195 spin_lock(&sdebug_host_list_lock);
4196 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
cbf67842
DG		 4197 list_for_each_entry(devip, &sdbg_host->dev_info_list,
4198 dev_list) {
4199 set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
4200 ++k;
4201 }
9a051019
DG		 4202 }
4203 spin_unlock(&sdebug_host_list_lock);
1da177e4 4204 stop_all_queued();
773642d9 4205 if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
cbf67842
DG		 4206 sdev_printk(KERN_INFO, SCpnt->device,
4207 "%s: %d device(s) found\n", __func__, k);
1da177e4
LT		 4208 return SUCCESS;
4209}
4210
f58b0efb 4211static void __init sdebug_build_parts(unsigned char *ramp,
5f2578e5 4212 unsigned long store_size)
1da177e4 4213{
91d4c752 4214 struct partition *pp;
1da177e4
LT		 4215 int starts[SDEBUG_MAX_PARTS + 2];
4216 int sectors_per_part, num_sectors, k;
4217 int heads_by_sects, start_sec, end_sec;
4218
4219 /* assume partition table already zeroed */
773642d9 4220 if ((sdebug_num_parts < 1) || (store_size < 1048576))
1da177e4 4221 return;
773642d9
DG		 4222 if (sdebug_num_parts > SDEBUG_MAX_PARTS) {
4223 sdebug_num_parts = SDEBUG_MAX_PARTS;
c1287970 4224 pr_warn("reducing partitions to %d\n", SDEBUG_MAX_PARTS);
1da177e4 4225 }
c65b1445 4226 num_sectors = (int)sdebug_store_sectors;
1da177e4 4227 sectors_per_part = (num_sectors - sdebug_sectors_per)
773642d9 4228 / sdebug_num_parts;
1da177e4 4229 heads_by_sects = sdebug_heads * sdebug_sectors_per;
9a051019 4230 starts[0] = sdebug_sectors_per;
773642d9 4231 for (k = 1; k < sdebug_num_parts; ++k)
1da177e4
LT		 4232 starts[k] = ((k * sectors_per_part) / heads_by_sects)
4233 * heads_by_sects;
773642d9
DG		 4234 starts[sdebug_num_parts] = num_sectors;
4235 starts[sdebug_num_parts + 1] = 0;
1da177e4
LT		 4236
4237 ramp[510] = 0x55; /* magic partition markings */
4238 ramp[511] = 0xAA;
4239 pp = (struct partition *)(ramp + 0x1be);
4240 for (k = 0; starts[k + 1]; ++k, ++pp) {
4241 start_sec = starts[k];
4242 end_sec = starts[k + 1] - 1;
4243 pp->boot_ind = 0;
4244
4245 pp->cyl = start_sec / heads_by_sects;
4246 pp->head = (start_sec - (pp->cyl * heads_by_sects))
4247 / sdebug_sectors_per;
4248 pp->sector = (start_sec % sdebug_sectors_per) + 1;
4249
4250 pp->end_cyl = end_sec / heads_by_sects;
4251 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
4252 / sdebug_sectors_per;
4253 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
4254
150c3544
AM		 4255 pp->start_sect = cpu_to_le32(start_sec);
4256 pp->nr_sects = cpu_to_le32(end_sec - start_sec + 1);
1da177e4
LT		 4257 pp->sys_ind = 0x83; /* plain Linux partition */
4258 }
4259}
4260
c4837394
DG		 4261static void block_unblock_all_queues(bool block)
4262{
4263 int j;
4264 struct sdebug_queue *sqp;
4265
4266 for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp)
4267 atomic_set(&sqp->blocked, (int)block);
4268}
4269
4270/* Adjust (by rounding down) the sdebug_cmnd_count so abs(every_nth)-1
4271 * commands will be processed normally before triggers occur.
4272 */
4273static void tweak_cmnd_count(void)
4274{
4275 int count, modulo;
4276
4277 modulo = abs(sdebug_every_nth);
4278 if (modulo < 2)
4279 return;
4280 block_unblock_all_queues(true);
4281 count = atomic_read(&sdebug_cmnd_count);
4282 atomic_set(&sdebug_cmnd_count, (count / modulo) * modulo);
4283 block_unblock_all_queues(false);
4284}
4285
4286static void clear_queue_stats(void)
4287{
4288 atomic_set(&sdebug_cmnd_count, 0);
4289 atomic_set(&sdebug_completions, 0);
4290 atomic_set(&sdebug_miss_cpus, 0);
4291 atomic_set(&sdebug_a_tsf, 0);
4292}
4293
4294static void setup_inject(struct sdebug_queue *sqp,
4295 struct sdebug_queued_cmd *sqcp)
4296{
4297 if ((atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth)) > 0)
4298 return;
4299 sqcp->inj_recovered = !!(SDEBUG_OPT_RECOVERED_ERR & sdebug_opts);
4300 sqcp->inj_transport = !!(SDEBUG_OPT_TRANSPORT_ERR & sdebug_opts);
4301 sqcp->inj_dif = !!(SDEBUG_OPT_DIF_ERR & sdebug_opts);
4302 sqcp->inj_dix = !!(SDEBUG_OPT_DIX_ERR & sdebug_opts);
4303 sqcp->inj_short = !!(SDEBUG_OPT_SHORT_TRANSFER & sdebug_opts);
7ee6d1b4 4304 sqcp->inj_host_busy = !!(SDEBUG_OPT_HOST_BUSY & sdebug_opts);
c4837394
DG		 4305}
4306
4307/* Complete the processing of the thread that queued a SCSI command to this
4308 * driver. It either completes the command by calling cmnd_done() or
4309 * schedules a hr timer or work queue then returns 0. Returns
4310 * SCSI_MLQUEUE_HOST_BUSY if temporarily out of resources.
4311 */
fd32119b 4312static int schedule_resp(struct scsi_cmnd *cmnd, struct sdebug_dev_info *devip,
10bde980 4313 int scsi_result, int delta_jiff, int ndelay)
1da177e4 4314{
cbf67842 4315 unsigned long iflags;
cd62b7da 4316 int k, num_in_q, qdepth, inject;
c4837394
DG		 4317 struct sdebug_queue *sqp;
4318 struct sdebug_queued_cmd *sqcp;
299b6c07 4319 struct scsi_device *sdp;
a10bc12a 4320 struct sdebug_defer *sd_dp;
299b6c07 4321
b01f6f83
DG		 4322 if (unlikely(devip == NULL)) {
4323 if (scsi_result == 0)
f46eb0e9
DG		 4324 scsi_result = DID_NO_CONNECT << 16;
4325 goto respond_in_thread;
cbf67842 4326 }
299b6c07
TW		 4327 sdp = cmnd->device;
4328
f46eb0e9 4329 if (unlikely(sdebug_verbose && scsi_result))
cbf67842
DG		 4330 sdev_printk(KERN_INFO, sdp, "%s: non-zero result=0x%x\n",
4331 __func__, scsi_result);
cd62b7da
DG		 4332 if (delta_jiff == 0)
4333 goto respond_in_thread;
1da177e4 4334
cd62b7da 4335 /* schedule the response at a later time if resources permit */
c4837394
DG		 4336 sqp = get_queue(cmnd);
4337 spin_lock_irqsave(&sqp->qc_lock, iflags);
4338 if (unlikely(atomic_read(&sqp->blocked))) {
4339 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
4340 return SCSI_MLQUEUE_HOST_BUSY;
4341 }
cbf67842
DG		 4342 num_in_q = atomic_read(&devip->num_in_q);
4343 qdepth = cmnd->device->queue_depth;
cbf67842 4344 inject = 0;
f46eb0e9 4345 if (unlikely((qdepth > 0) && (num_in_q >= qdepth))) {
cd62b7da 4346 if (scsi_result) {
c4837394 4347 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
cd62b7da
DG		 4348 goto respond_in_thread;
4349 } else
4350 scsi_result = device_qfull_result;
c4837394 4351 } else if (unlikely(sdebug_every_nth &&
f46eb0e9
DG		 4352 (SDEBUG_OPT_RARE_TSF & sdebug_opts) &&
4353 (scsi_result == 0))) {
cbf67842
DG		 4354 if ((num_in_q == (qdepth - 1)) &&
4355 (atomic_inc_return(&sdebug_a_tsf) >=
773642d9 4356 abs(sdebug_every_nth))) {
cbf67842
DG		 4357 atomic_set(&sdebug_a_tsf, 0);
4358 inject = 1;
cd62b7da 4359 scsi_result = device_qfull_result;
1da177e4
LT		 4360 }
4361 }
1da177e4 4362
c4837394 4363 k = find_first_zero_bit(sqp->in_use_bm, sdebug_max_queue);
f46eb0e9 4364 if (unlikely(k >= sdebug_max_queue)) {
c4837394 4365 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
cd62b7da
DG		 4366 if (scsi_result)
4367 goto respond_in_thread;
773642d9 4368 else if (SDEBUG_OPT_ALL_TSF & sdebug_opts)
cd62b7da 4369 scsi_result = device_qfull_result;
773642d9 4370 if (SDEBUG_OPT_Q_NOISE & sdebug_opts)
cbf67842 4371 sdev_printk(KERN_INFO, sdp,
cd62b7da 4372 "%s: max_queue=%d exceeded, %s\n",
773642d9 4373 __func__, sdebug_max_queue,
cd62b7da
DG		 4374 (scsi_result ? "status: TASK SET FULL" :
4375 "report: host busy"));
4376 if (scsi_result)
4377 goto respond_in_thread;
4378 else
cbf67842
DG		 4379 return SCSI_MLQUEUE_HOST_BUSY;
4380 }
c4837394 4381 __set_bit(k, sqp->in_use_bm);
cbf67842 4382 atomic_inc(&devip->num_in_q);
c4837394 4383 sqcp = &sqp->qc_arr[k];
cbf67842 4384 sqcp->a_cmnd = cmnd;
c4837394 4385 cmnd->host_scribble = (unsigned char *)sqcp;
cbf67842 4386 cmnd->result = scsi_result;
a10bc12a 4387 sd_dp = sqcp->sd_dp;
c4837394
DG		 4388 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
4389 if (unlikely(sdebug_every_nth && sdebug_any_injecting_opt))
4390 setup_inject(sqp, sqcp);
10bde980
DG		 4391 if (sd_dp == NULL) {
4392 sd_dp = kzalloc(sizeof(*sd_dp), GFP_ATOMIC);
4393 if (sd_dp == NULL)
4394 return SCSI_MLQUEUE_HOST_BUSY;
4395 }
4396 if (delta_jiff > 0 || ndelay > 0) {
b333a819 4397 ktime_t kt;
cbf67842 4398
b333a819 4399 if (delta_jiff > 0) {
13f6b610 4400 kt = ns_to_ktime((u64)delta_jiff * (NSEC_PER_SEC / HZ));
b333a819 4401 } else
10bde980
DG		 4402 kt = ndelay;
4403 if (!sd_dp->init_hrt) {
4404 sd_dp->init_hrt = true;
a10bc12a
DG		 4405 sqcp->sd_dp = sd_dp;
4406 hrtimer_init(&sd_dp->hrt, CLOCK_MONOTONIC,
c4837394 4407 HRTIMER_MODE_REL_PINNED);
a10bc12a 4408 sd_dp->hrt.function = sdebug_q_cmd_hrt_complete;
c4837394
DG		 4409 sd_dp->sqa_idx = sqp - sdebug_q_arr;
4410 sd_dp->qc_idx = k;
1da177e4 4411 }
c4837394
DG		 4412 if (sdebug_statistics)
4413 sd_dp->issuing_cpu = raw_smp_processor_id();
10bde980 4414 sd_dp->defer_t = SDEB_DEFER_HRT;
c4837394
DG		 4415 hrtimer_start(&sd_dp->hrt, kt, HRTIMER_MODE_REL_PINNED);
4416 } else { /* jdelay < 0, use work queue */
10bde980
DG		 4417 if (!sd_dp->init_wq) {
4418 sd_dp->init_wq = true;
a10bc12a 4419 sqcp->sd_dp = sd_dp;
c4837394
DG		 4420 sd_dp->sqa_idx = sqp - sdebug_q_arr;
4421 sd_dp->qc_idx = k;
a10bc12a 4422 INIT_WORK(&sd_dp->ew.work, sdebug_q_cmd_wq_complete);
cbf67842 4423 }
c4837394
DG		 4424 if (sdebug_statistics)
4425 sd_dp->issuing_cpu = raw_smp_processor_id();
10bde980 4426 sd_dp->defer_t = SDEB_DEFER_WQ;
a10bc12a 4427 schedule_work(&sd_dp->ew.work);
1da177e4 4428 }
f46eb0e9
DG		 4429 if (unlikely((SDEBUG_OPT_Q_NOISE & sdebug_opts) &&
4430 (scsi_result == device_qfull_result)))
cbf67842
DG		 4431 sdev_printk(KERN_INFO, sdp,
4432 "%s: num_in_q=%d +1, %s%s\n", __func__,
4433 num_in_q, (inject ? "<inject> " : ""),
4434 "status: TASK SET FULL");
4435 return 0;
cd62b7da
DG		 4436
4437respond_in_thread: /* call back to mid-layer using invocation thread */
4438 cmnd->result = scsi_result;
4439 cmnd->scsi_done(cmnd);
4440 return 0;
1da177e4 4441}
cbf67842 4442
23183910
DG		 4443/* Note: The following macros create attribute files in the
4444 /sys/module/scsi_debug/parameters directory. Unfortunately this
4445 driver is unaware of a change and cannot trigger auxiliary actions
4446 as it can when the corresponding attribute in the
4447 /sys/bus/pseudo/drivers/scsi_debug directory is changed.
4448 */
773642d9
DG		 4449module_param_named(add_host, sdebug_add_host, int, S_IRUGO | S_IWUSR);
4450module_param_named(ato, sdebug_ato, int, S_IRUGO);
9b760fd8 4451module_param_named(cdb_len, sdebug_cdb_len, int, 0644);
773642d9 4452module_param_named(clustering, sdebug_clustering, bool, S_IRUGO | S_IWUSR);
c2206098 4453module_param_named(delay, sdebug_jdelay, int, S_IRUGO | S_IWUSR);
773642d9
DG		 4454module_param_named(dev_size_mb, sdebug_dev_size_mb, int, S_IRUGO);
4455module_param_named(dif, sdebug_dif, int, S_IRUGO);
4456module_param_named(dix, sdebug_dix, int, S_IRUGO);
4457module_param_named(dsense, sdebug_dsense, int, S_IRUGO | S_IWUSR);
4458module_param_named(every_nth, sdebug_every_nth, int, S_IRUGO | S_IWUSR);
4459module_param_named(fake_rw, sdebug_fake_rw, int, S_IRUGO | S_IWUSR);
4460module_param_named(guard, sdebug_guard, uint, S_IRUGO);
4461module_param_named(host_lock, sdebug_host_lock, bool, S_IRUGO | S_IWUSR);
e5203cf0
HR		 4462module_param_string(inq_vendor, sdebug_inq_vendor_id,
4463 sizeof(sdebug_inq_vendor_id), S_IRUGO|S_IWUSR);
4464module_param_string(inq_product, sdebug_inq_product_id,
4465 sizeof(sdebug_inq_product_id), S_IRUGO|S_IWUSR);
4466module_param_string(inq_rev, sdebug_inq_product_rev,
4467 sizeof(sdebug_inq_product_rev), S_IRUGO|S_IWUSR);
773642d9
DG		 4468module_param_named(lbpu, sdebug_lbpu, int, S_IRUGO);
4469module_param_named(lbpws, sdebug_lbpws, int, S_IRUGO);
4470module_param_named(lbpws10, sdebug_lbpws10, int, S_IRUGO);
4471module_param_named(lbprz, sdebug_lbprz, int, S_IRUGO);
4472module_param_named(lowest_aligned, sdebug_lowest_aligned, int, S_IRUGO);
4473module_param_named(max_luns, sdebug_max_luns, int, S_IRUGO | S_IWUSR);
4474module_param_named(max_queue, sdebug_max_queue, int, S_IRUGO | S_IWUSR);
d9da891a
LO		 4475module_param_named(medium_error_start, sdebug_medium_error_start, int, S_IRUGO | S_IWUSR);
4476module_param_named(medium_error_count, sdebug_medium_error_count, int, S_IRUGO | S_IWUSR);
773642d9
DG		 4477module_param_named(ndelay, sdebug_ndelay, int, S_IRUGO | S_IWUSR);
4478module_param_named(no_lun_0, sdebug_no_lun_0, int, S_IRUGO | S_IWUSR);
4479module_param_named(no_uld, sdebug_no_uld, int, S_IRUGO);
4480module_param_named(num_parts, sdebug_num_parts, int, S_IRUGO);
4481module_param_named(num_tgts, sdebug_num_tgts, int, S_IRUGO | S_IWUSR);
4482module_param_named(opt_blks, sdebug_opt_blks, int, S_IRUGO);
4483module_param_named(opts, sdebug_opts, int, S_IRUGO | S_IWUSR);
4484module_param_named(physblk_exp, sdebug_physblk_exp, int, S_IRUGO);
86e6828a 4485module_param_named(opt_xferlen_exp, sdebug_opt_xferlen_exp, int, S_IRUGO);
773642d9
DG		 4486module_param_named(ptype, sdebug_ptype, int, S_IRUGO | S_IWUSR);
4487module_param_named(removable, sdebug_removable, bool, S_IRUGO | S_IWUSR);
4488module_param_named(scsi_level, sdebug_scsi_level, int, S_IRUGO);
4489module_param_named(sector_size, sdebug_sector_size, int, S_IRUGO);
c4837394 4490module_param_named(statistics, sdebug_statistics, bool, S_IRUGO | S_IWUSR);
773642d9 4491module_param_named(strict, sdebug_strict, bool, S_IRUGO | S_IWUSR);
c4837394 4492module_param_named(submit_queues, submit_queues, int, S_IRUGO);
773642d9
DG		 4493module_param_named(unmap_alignment, sdebug_unmap_alignment, int, S_IRUGO);
4494module_param_named(unmap_granularity, sdebug_unmap_granularity, int, S_IRUGO);
4495module_param_named(unmap_max_blocks, sdebug_unmap_max_blocks, int, S_IRUGO);
4496module_param_named(unmap_max_desc, sdebug_unmap_max_desc, int, S_IRUGO);
4497module_param_named(virtual_gb, sdebug_virtual_gb, int, S_IRUGO | S_IWUSR);
09ba24c1 4498module_param_named(uuid_ctl, sdebug_uuid_ctl, int, S_IRUGO);
773642d9 4499module_param_named(vpd_use_hostno, sdebug_vpd_use_hostno, int,
5b94e232 4500 S_IRUGO | S_IWUSR);
773642d9 4501module_param_named(write_same_length, sdebug_write_same_length, int,
5b94e232 4502 S_IRUGO | S_IWUSR);
1da177e4
LT		 4503
4504MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
4505MODULE_DESCRIPTION("SCSI debug adapter driver");
4506MODULE_LICENSE("GPL");
b01f6f83 4507MODULE_VERSION(SDEBUG_VERSION);
1da177e4
LT		 4508
4509MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
5b94e232 4510MODULE_PARM_DESC(ato, "application tag ownership: 0=disk 1=host (def=1)");
9b760fd8 4511MODULE_PARM_DESC(cdb_len, "suggest CDB lengths to drivers (def=10)");
0759c666 4512MODULE_PARM_DESC(clustering, "when set enables larger transfers (def=0)");
cbf67842 4513MODULE_PARM_DESC(delay, "response delay (def=1 jiffy); 0:imm, -1,-2:tiny");
c2248fc9 4514MODULE_PARM_DESC(dev_size_mb, "size in MiB of ram shared by devs(def=8)");
5b94e232
MP		 4515MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)");
4516MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)");
c65b1445 4517MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
beb87c33 4518MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
23183910 4519MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
5b94e232 4520MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");
185dd232 4521MODULE_PARM_DESC(host_lock, "host_lock is ignored (def=0)");
e5203cf0
HR		 4522MODULE_PARM_DESC(inq_vendor, "SCSI INQUIRY vendor string (def=\"Linux\")");
4523MODULE_PARM_DESC(inq_product, "SCSI INQUIRY product string (def=\"scsi_debug\")");
9b760fd8
DG		 4524MODULE_PARM_DESC(inq_rev, "SCSI INQUIRY revision string (def=\""
4525 SDEBUG_VERSION "\")");
5b94e232
MP		 4526MODULE_PARM_DESC(lbpu, "enable LBP, support UNMAP command (def=0)");
4527MODULE_PARM_DESC(lbpws, "enable LBP, support WRITE SAME(16) with UNMAP bit (def=0)");
4528MODULE_PARM_DESC(lbpws10, "enable LBP, support WRITE SAME(10) with UNMAP bit (def=0)");
760f3b03
DG		 4529MODULE_PARM_DESC(lbprz,
4530 "on read unmapped LBs return 0 when 1 (def), return 0xff when 2");
5b94e232 4531MODULE_PARM_DESC(lowest_aligned, "lowest aligned lba (def=0)");
c65b1445 4532MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
cbf67842 4533MODULE_PARM_DESC(max_queue, "max number of queued commands (1 to max(def))");
d9da891a
LO		 4534MODULE_PARM_DESC(medium_error_start, "starting sector number to return MEDIUM error");
4535MODULE_PARM_DESC(medium_error_count, "count of sectors to return follow on MEDIUM error");
cbf67842 4536MODULE_PARM_DESC(ndelay, "response delay in nanoseconds (def=0 -> ignore)");
c65b1445 4537MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
78d4e5a0 4538MODULE_PARM_DESC(no_uld, "stop ULD (e.g. sd driver) attaching (def=0))");
1da177e4 4539MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
c65b1445 4540MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
32c5844a 4541MODULE_PARM_DESC(opt_blks, "optimal transfer length in blocks (def=1024)");
6f3cbf55 4542MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
5b94e232 4543MODULE_PARM_DESC(physblk_exp, "physical block exponent (def=0)");
86e6828a 4544MODULE_PARM_DESC(opt_xferlen_exp, "optimal transfer length granularity exponent (def=physblk_exp)");
1da177e4 4545MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
d986788b 4546MODULE_PARM_DESC(removable, "claim to have removable media (def=0)");
760f3b03 4547MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=7[SPC-5])");
ea61fca5 4548MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)");
c4837394 4549MODULE_PARM_DESC(statistics, "collect statistics on commands, queues (def=0)");
c2248fc9 4550MODULE_PARM_DESC(strict, "stricter checks: reserved field in cdb (def=0)");
c4837394 4551MODULE_PARM_DESC(submit_queues, "support for block multi-queue (def=1)");
5b94e232
MP		 4552MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)");
4553MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=1)");
6014759c
MP		 4554MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0xffffffff)");
4555MODULE_PARM_DESC(unmap_max_desc, "max # of ranges that can be unmapped in one cmd (def=256)");
09ba24c1
DG		 4556MODULE_PARM_DESC(uuid_ctl,
4557 "1->use uuid for lu name, 0->don't, 2->all use same (def=0)");
c2248fc9 4558MODULE_PARM_DESC(virtual_gb, "virtual gigabyte (GiB) size (def=0 -> use dev_size_mb)");
5b94e232
MP		 4559MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
4560MODULE_PARM_DESC(write_same_length, "Maximum blocks per WRITE SAME cmd (def=0xffff)");
1da177e4 4561
760f3b03
DG		 4562#define SDEBUG_INFO_LEN 256
4563static char sdebug_info[SDEBUG_INFO_LEN];
1da177e4 4564
91d4c752 4565static const char *scsi_debug_info(struct Scsi_Host *shp)
1da177e4 4566{
c4837394
DG		 4567 int k;
4568
760f3b03
DG		 4569 k = scnprintf(sdebug_info, SDEBUG_INFO_LEN, "%s: version %s [%s]\n",
4570 my_name, SDEBUG_VERSION, sdebug_version_date);
4571 if (k >= (SDEBUG_INFO_LEN - 1))
c4837394 4572 return sdebug_info;
760f3b03
DG		 4573 scnprintf(sdebug_info + k, SDEBUG_INFO_LEN - k,
4574 " dev_size_mb=%d, opts=0x%x, submit_queues=%d, %s=%d",
4575 sdebug_dev_size_mb, sdebug_opts, submit_queues,
4576 "statistics", (int)sdebug_statistics);
1da177e4
LT		 4577 return sdebug_info;
4578}
4579
cbf67842 4580/* 'echo <val> > /proc/scsi/scsi_debug/<host_id>' writes to opts */
fd32119b
DG		 4581static int scsi_debug_write_info(struct Scsi_Host *host, char *buffer,
4582 int length)
1da177e4 4583{
c8ed555a
AV		 4584 char arr[16];
4585 int opts;
4586 int minLen = length > 15 ? 15 : length;
1da177e4 4587
c8ed555a
AV		 4588 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
4589 return -EACCES;
4590 memcpy(arr, buffer, minLen);
4591 arr[minLen] = '\0';
4592 if (1 != sscanf(arr, "%d", &opts))
4593 return -EINVAL;
773642d9
DG		 4594 sdebug_opts = opts;
4595 sdebug_verbose = !!(SDEBUG_OPT_NOISE & opts);
4596 sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & opts);
4597 if (sdebug_every_nth != 0)
c4837394 4598 tweak_cmnd_count();
c8ed555a
AV		 4599 return length;
4600}
1da177e4 4601
cbf67842
DG		 4602/* Output seen with 'cat /proc/scsi/scsi_debug/<host_id>'. It will be the
4603 * same for each scsi_debug host (if more than one). Some of the counters
4604 * output are not atomics so might be inaccurate in a busy system. */
c8ed555a
AV		 4605static int scsi_debug_show_info(struct seq_file *m, struct Scsi_Host *host)
4606{
c4837394
DG		 4607 int f, j, l;
4608 struct sdebug_queue *sqp;
4609
4610 seq_printf(m, "scsi_debug adapter driver, version %s [%s]\n",
4611 SDEBUG_VERSION, sdebug_version_date);
4612 seq_printf(m, "num_tgts=%d, %ssize=%d MB, opts=0x%x, every_nth=%d\n",
4613 sdebug_num_tgts, "shared (ram) ", sdebug_dev_size_mb,
4614 sdebug_opts, sdebug_every_nth);
4615 seq_printf(m, "delay=%d, ndelay=%d, max_luns=%d, sector_size=%d %s\n",
4616 sdebug_jdelay, sdebug_ndelay, sdebug_max_luns,
4617 sdebug_sector_size, "bytes");
4618 seq_printf(m, "cylinders=%d, heads=%d, sectors=%d, command aborts=%d\n",
4619 sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
4620 num_aborts);
4621 seq_printf(m, "RESETs: device=%d, target=%d, bus=%d, host=%d\n",
4622 num_dev_resets, num_target_resets, num_bus_resets,
4623 num_host_resets);
4624 seq_printf(m, "dix_reads=%d, dix_writes=%d, dif_errors=%d\n",
4625 dix_reads, dix_writes, dif_errors);
458df78b
BVA		 4626 seq_printf(m, "usec_in_jiffy=%lu, statistics=%d\n", TICK_NSEC / 1000,
4627 sdebug_statistics);
c4837394
DG		 4628 seq_printf(m, "cmnd_count=%d, completions=%d, %s=%d, a_tsf=%d\n",
4629 atomic_read(&sdebug_cmnd_count),
4630 atomic_read(&sdebug_completions),
4631 "miss_cpus", atomic_read(&sdebug_miss_cpus),
4632 atomic_read(&sdebug_a_tsf));
4633
4634 seq_printf(m, "submit_queues=%d\n", submit_queues);
4635 for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
4636 seq_printf(m, " queue %d:\n", j);
4637 f = find_first_bit(sqp->in_use_bm, sdebug_max_queue);
4638 if (f != sdebug_max_queue) {
4639 l = find_last_bit(sqp->in_use_bm, sdebug_max_queue);
4640 seq_printf(m, " in_use_bm BUSY: %s: %d,%d\n",
4641 "first,last bits", f, l);
4642 }
cbf67842 4643 }
c8ed555a 4644 return 0;
1da177e4
LT		 4645}
4646
82069379 4647static ssize_t delay_show(struct device_driver *ddp, char *buf)
1da177e4 4648{
c2206098 4649 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_jdelay);
1da177e4 4650}
c4837394
DG		 4651/* Returns -EBUSY if jdelay is being changed and commands are queued. The unit
4652 * of delay is jiffies.
4653 */
82069379
AM		 4654static ssize_t delay_store(struct device_driver *ddp, const char *buf,
4655 size_t count)
1da177e4 4656{
c2206098 4657 int jdelay, res;
cbf67842 4658
b01f6f83 4659 if (count > 0 && sscanf(buf, "%d", &jdelay) == 1) {
cbf67842 4660 res = count;
c2206098 4661 if (sdebug_jdelay != jdelay) {
c4837394
DG		 4662 int j, k;
4663 struct sdebug_queue *sqp;
4664
4665 block_unblock_all_queues(true);
4666 for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
4667 ++j, ++sqp) {
4668 k = find_first_bit(sqp->in_use_bm,
4669 sdebug_max_queue);
4670 if (k != sdebug_max_queue) {
4671 res = -EBUSY; /* queued commands */
4672 break;
4673 }
4674 }
4675 if (res > 0) {
c2206098 4676 sdebug_jdelay = jdelay;
773642d9 4677 sdebug_ndelay = 0;
cbf67842 4678 }
c4837394 4679 block_unblock_all_queues(false);
1da177e4 4680 }
cbf67842 4681 return res;
1da177e4
LT		 4682 }
4683 return -EINVAL;
4684}
82069379 4685static DRIVER_ATTR_RW(delay);
1da177e4 4686
cbf67842
DG		 4687static ssize_t ndelay_show(struct device_driver *ddp, char *buf)
4688{
773642d9 4689 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ndelay);
cbf67842
DG		 4690}
4691/* Returns -EBUSY if ndelay is being changed and commands are queued */
c2206098 4692/* If > 0 and accepted then sdebug_jdelay is set to JDELAY_OVERRIDDEN */
cbf67842 4693static ssize_t ndelay_store(struct device_driver *ddp, const char *buf,
fd32119b 4694 size_t count)
cbf67842 4695{
c4837394 4696 int ndelay, res;
cbf67842
DG		 4697
4698 if ((count > 0) && (1 == sscanf(buf, "%d", &ndelay)) &&
c4837394 4699 (ndelay >= 0) && (ndelay < (1000 * 1000 * 1000))) {
cbf67842 4700 res = count;
773642d9 4701 if (sdebug_ndelay != ndelay) {
c4837394
DG		 4702 int j, k;
4703 struct sdebug_queue *sqp;
4704
4705 block_unblock_all_queues(true);
4706 for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
4707 ++j, ++sqp) {
4708 k = find_first_bit(sqp->in_use_bm,
4709 sdebug_max_queue);
4710 if (k != sdebug_max_queue) {
4711 res = -EBUSY; /* queued commands */
4712 break;
4713 }
4714 }
4715 if (res > 0) {
773642d9 4716 sdebug_ndelay = ndelay;
c2206098
DG		 4717 sdebug_jdelay = ndelay ? JDELAY_OVERRIDDEN
4718 : DEF_JDELAY;
cbf67842 4719 }
c4837394 4720 block_unblock_all_queues(false);
cbf67842
DG		 4721 }
4722 return res;
4723 }
4724 return -EINVAL;
4725}
4726static DRIVER_ATTR_RW(ndelay);
4727
82069379 4728static ssize_t opts_show(struct device_driver *ddp, char *buf)
1da177e4 4729{
773642d9 4730 return scnprintf(buf, PAGE_SIZE, "0x%x\n", sdebug_opts);
1da177e4
LT		 4731}
4732
82069379
AM		 4733static ssize_t opts_store(struct device_driver *ddp, const char *buf,
4734 size_t count)
1da177e4 4735{
9a051019 4736 int opts;
1da177e4
LT		 4737 char work[20];
4738
9a051019
DG		 4739 if (sscanf(buf, "%10s", work) == 1) {
4740 if (strncasecmp(work, "0x", 2) == 0) {
4741 if (kstrtoint(work + 2, 16, &opts) == 0)
1da177e4
LT		 4742 goto opts_done;
4743 } else {
9a051019 4744 if (kstrtoint(work, 10, &opts) == 0)
1da177e4
LT		 4745 goto opts_done;
4746 }
4747 }
4748 return -EINVAL;
4749opts_done:
773642d9
DG		 4750 sdebug_opts = opts;
4751 sdebug_verbose = !!(SDEBUG_OPT_NOISE & opts);
4752 sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & opts);
c4837394 4753 tweak_cmnd_count();
1da177e4
LT		 4754 return count;
4755}
82069379 4756static DRIVER_ATTR_RW(opts);
1da177e4 4757
82069379 4758static ssize_t ptype_show(struct device_driver *ddp, char *buf)
1da177e4 4759{
773642d9 4760 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ptype);
1da177e4 4761}
82069379
AM		 4762static ssize_t ptype_store(struct device_driver *ddp, const char *buf,
4763 size_t count)
1da177e4 4764{
9a051019 4765 int n;
1da177e4
LT		 4766
4767 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 4768 sdebug_ptype = n;
1da177e4
LT		 4769 return count;
4770 }
4771 return -EINVAL;
4772}
82069379 4773static DRIVER_ATTR_RW(ptype);
1da177e4 4774
82069379 4775static ssize_t dsense_show(struct device_driver *ddp, char *buf)
1da177e4 4776{
773642d9 4777 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dsense);
1da177e4 4778}
82069379
AM		 4779static ssize_t dsense_store(struct device_driver *ddp, const char *buf,
4780 size_t count)
1da177e4 4781{
9a051019 4782 int n;
1da177e4
LT		 4783
4784 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 4785 sdebug_dsense = n;
1da177e4
LT		 4786 return count;
4787 }
4788 return -EINVAL;
4789}
82069379 4790static DRIVER_ATTR_RW(dsense);
1da177e4 4791
82069379 4792static ssize_t fake_rw_show(struct device_driver *ddp, char *buf)
23183910 4793{
773642d9 4794 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_fake_rw);
23183910 4795}
82069379
AM		 4796static ssize_t fake_rw_store(struct device_driver *ddp, const char *buf,
4797 size_t count)
23183910 4798{
9a051019 4799 int n;
23183910
DG		 4800
4801 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
cbf67842 4802 n = (n > 0);
773642d9
DG		 4803 sdebug_fake_rw = (sdebug_fake_rw > 0);
4804 if (sdebug_fake_rw != n) {
cbf67842
DG		 4805 if ((0 == n) && (NULL == fake_storep)) {
4806 unsigned long sz =
773642d9 4807 (unsigned long)sdebug_dev_size_mb *
cbf67842
DG		 4808 1048576;
4809
4810 fake_storep = vmalloc(sz);
4811 if (NULL == fake_storep) {
c1287970 4812 pr_err("out of memory, 9\n");
cbf67842
DG		 4813 return -ENOMEM;
4814 }
4815 memset(fake_storep, 0, sz);
4816 }
773642d9 4817 sdebug_fake_rw = n;
cbf67842 4818 }
23183910
DG		 4819 return count;
4820 }
4821 return -EINVAL;
4822}
82069379 4823static DRIVER_ATTR_RW(fake_rw);
23183910 4824
82069379 4825static ssize_t no_lun_0_show(struct device_driver *ddp, char *buf)
c65b1445 4826{
773642d9 4827 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_lun_0);
c65b1445 4828}
82069379
AM		 4829static ssize_t no_lun_0_store(struct device_driver *ddp, const char *buf,
4830 size_t count)
c65b1445 4831{
9a051019 4832 int n;
c65b1445
DG		 4833
4834 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 4835 sdebug_no_lun_0 = n;
c65b1445
DG		 4836 return count;
4837 }
4838 return -EINVAL;
4839}
82069379 4840static DRIVER_ATTR_RW(no_lun_0);
c65b1445 4841
82069379 4842static ssize_t num_tgts_show(struct device_driver *ddp, char *buf)
1da177e4 4843{
773642d9 4844 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_tgts);
1da177e4 4845}
82069379
AM		 4846static ssize_t num_tgts_store(struct device_driver *ddp, const char *buf,
4847 size_t count)
1da177e4 4848{
9a051019 4849 int n;
1da177e4
LT		 4850
4851 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 4852 sdebug_num_tgts = n;
1da177e4
LT		 4853 sdebug_max_tgts_luns();
4854 return count;
4855 }
4856 return -EINVAL;
4857}
82069379 4858static DRIVER_ATTR_RW(num_tgts);
1da177e4 4859
82069379 4860static ssize_t dev_size_mb_show(struct device_driver *ddp, char *buf)
1da177e4 4861{
773642d9 4862 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dev_size_mb);
1da177e4 4863}
82069379 4864static DRIVER_ATTR_RO(dev_size_mb);
1da177e4 4865
82069379 4866static ssize_t num_parts_show(struct device_driver *ddp, char *buf)
1da177e4 4867{
773642d9 4868 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_parts);
1da177e4 4869}
82069379 4870static DRIVER_ATTR_RO(num_parts);
1da177e4 4871
82069379 4872static ssize_t every_nth_show(struct device_driver *ddp, char *buf)
1da177e4 4873{
773642d9 4874 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_every_nth);
1da177e4 4875}
82069379
AM		 4876static ssize_t every_nth_store(struct device_driver *ddp, const char *buf,
4877 size_t count)
1da177e4 4878{
9a051019 4879 int nth;
1da177e4
LT		 4880
4881 if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
773642d9 4882 sdebug_every_nth = nth;
c4837394
DG		 4883 if (nth && !sdebug_statistics) {
4884 pr_info("every_nth needs statistics=1, set it\n");
4885 sdebug_statistics = true;
4886 }
4887 tweak_cmnd_count();
1da177e4
LT		 4888 return count;
4889 }
4890 return -EINVAL;
4891}
82069379 4892static DRIVER_ATTR_RW(every_nth);
1da177e4 4893
82069379 4894static ssize_t max_luns_show(struct device_driver *ddp, char *buf)
1da177e4 4895{
773642d9 4896 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_max_luns);
1da177e4 4897}
82069379
AM		 4898static ssize_t max_luns_store(struct device_driver *ddp, const char *buf,
4899 size_t count)
1da177e4 4900{
9a051019 4901 int n;
19c8ead7 4902 bool changed;
1da177e4
LT		 4903
4904 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
8d039e22
DG		 4905 if (n > 256) {
4906 pr_warn("max_luns can be no more than 256\n");
4907 return -EINVAL;
4908 }
773642d9
DG		 4909 changed = (sdebug_max_luns != n);
4910 sdebug_max_luns = n;
1da177e4 4911 sdebug_max_tgts_luns();
773642d9 4912 if (changed && (sdebug_scsi_level >= 5)) { /* >= SPC-3 */
19c8ead7
EM		 4913 struct sdebug_host_info *sdhp;
4914 struct sdebug_dev_info *dp;
4915
4916 spin_lock(&sdebug_host_list_lock);
4917 list_for_each_entry(sdhp, &sdebug_host_list,
4918 host_list) {
4919 list_for_each_entry(dp, &sdhp->dev_info_list,
4920 dev_list) {
4921 set_bit(SDEBUG_UA_LUNS_CHANGED,
4922 dp->uas_bm);
4923 }
4924 }
4925 spin_unlock(&sdebug_host_list_lock);
4926 }
1da177e4
LT		 4927 return count;
4928 }
4929 return -EINVAL;
4930}
82069379 4931static DRIVER_ATTR_RW(max_luns);
1da177e4 4932
82069379 4933static ssize_t max_queue_show(struct device_driver *ddp, char *buf)
78d4e5a0 4934{
773642d9 4935 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_max_queue);
78d4e5a0 4936}
cbf67842
DG		 4937/* N.B. max_queue can be changed while there are queued commands. In flight
4938 * commands beyond the new max_queue will be completed. */
82069379
AM		 4939static ssize_t max_queue_store(struct device_driver *ddp, const char *buf,
4940 size_t count)
78d4e5a0 4941{
c4837394
DG		 4942 int j, n, k, a;
4943 struct sdebug_queue *sqp;
78d4e5a0
DG		 4944
4945 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n > 0) &&
c4837394
DG		 4946 (n <= SDEBUG_CANQUEUE)) {
4947 block_unblock_all_queues(true);
4948 k = 0;
4949 for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
4950 ++j, ++sqp) {
4951 a = find_last_bit(sqp->in_use_bm, SDEBUG_CANQUEUE);
4952 if (a > k)
4953 k = a;
4954 }
773642d9 4955 sdebug_max_queue = n;
c4837394 4956 if (k == SDEBUG_CANQUEUE)
cbf67842
DG		 4957 atomic_set(&retired_max_queue, 0);
4958 else if (k >= n)
4959 atomic_set(&retired_max_queue, k + 1);
4960 else
4961 atomic_set(&retired_max_queue, 0);
c4837394 4962 block_unblock_all_queues(false);
78d4e5a0
DG		 4963 return count;
4964 }
4965 return -EINVAL;
4966}
82069379 4967static DRIVER_ATTR_RW(max_queue);
78d4e5a0 4968
82069379 4969static ssize_t no_uld_show(struct device_driver *ddp, char *buf)
78d4e5a0 4970{
773642d9 4971 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_uld);
78d4e5a0 4972}
82069379 4973static DRIVER_ATTR_RO(no_uld);
78d4e5a0 4974
82069379 4975static ssize_t scsi_level_show(struct device_driver *ddp, char *buf)
1da177e4 4976{
773642d9 4977 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_scsi_level);
1da177e4 4978}
82069379 4979static DRIVER_ATTR_RO(scsi_level);
1da177e4 4980
82069379 4981static ssize_t virtual_gb_show(struct device_driver *ddp, char *buf)
c65b1445 4982{
773642d9 4983 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_virtual_gb);
c65b1445 4984}
82069379
AM		 4985static ssize_t virtual_gb_store(struct device_driver *ddp, const char *buf,
4986 size_t count)
c65b1445 4987{
9a051019 4988 int n;
0d01c5df 4989 bool changed;
c65b1445
DG		 4990
4991 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9
DG		 4992 changed = (sdebug_virtual_gb != n);
4993 sdebug_virtual_gb = n;
28898873 4994 sdebug_capacity = get_sdebug_capacity();
0d01c5df
DG		 4995 if (changed) {
4996 struct sdebug_host_info *sdhp;
4997 struct sdebug_dev_info *dp;
4998
4bc6b634 4999 spin_lock(&sdebug_host_list_lock);
0d01c5df
DG		 5000 list_for_each_entry(sdhp, &sdebug_host_list,
5001 host_list) {
5002 list_for_each_entry(dp, &sdhp->dev_info_list,
5003 dev_list) {
5004 set_bit(SDEBUG_UA_CAPACITY_CHANGED,
5005 dp->uas_bm);
5006 }
5007 }
4bc6b634 5008 spin_unlock(&sdebug_host_list_lock);
0d01c5df 5009 }
c65b1445
DG		 5010 return count;
5011 }
5012 return -EINVAL;
5013}
82069379 5014static DRIVER_ATTR_RW(virtual_gb);
c65b1445 5015
82069379 5016static ssize_t add_host_show(struct device_driver *ddp, char *buf)
1da177e4 5017{
773642d9 5018 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_add_host);
1da177e4
LT		 5019}
5020
fd32119b
DG		 5021static int sdebug_add_adapter(void);
5022static void sdebug_remove_adapter(void);
5023
82069379
AM		 5024static ssize_t add_host_store(struct device_driver *ddp, const char *buf,
5025 size_t count)
1da177e4 5026{
f3df41cf 5027 int delta_hosts;
1da177e4 5028
f3df41cf 5029 if (sscanf(buf, "%d", &delta_hosts) != 1)
1da177e4 5030 return -EINVAL;
1da177e4
LT		 5031 if (delta_hosts > 0) {
5032 do {
5033 sdebug_add_adapter();
5034 } while (--delta_hosts);
5035 } else if (delta_hosts < 0) {
5036 do {
5037 sdebug_remove_adapter();
5038 } while (++delta_hosts);
5039 }
5040 return count;
5041}
82069379 5042static DRIVER_ATTR_RW(add_host);
1da177e4 5043
82069379 5044static ssize_t vpd_use_hostno_show(struct device_driver *ddp, char *buf)
23183910 5045{
773642d9 5046 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_vpd_use_hostno);
23183910 5047}
82069379
AM		 5048static ssize_t vpd_use_hostno_store(struct device_driver *ddp, const char *buf,
5049 size_t count)
23183910
DG		 5050{
5051 int n;
5052
5053 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 5054 sdebug_vpd_use_hostno = n;
23183910
DG		 5055 return count;
5056 }
5057 return -EINVAL;
5058}
82069379 5059static DRIVER_ATTR_RW(vpd_use_hostno);
23183910 5060
c4837394
DG		 5061static ssize_t statistics_show(struct device_driver *ddp, char *buf)
5062{
5063 return scnprintf(buf, PAGE_SIZE, "%d\n", (int)sdebug_statistics);
5064}
5065static ssize_t statistics_store(struct device_driver *ddp, const char *buf,
5066 size_t count)
5067{
5068 int n;
5069
5070 if ((count > 0) && (sscanf(buf, "%d", &n) == 1) && (n >= 0)) {
5071 if (n > 0)
5072 sdebug_statistics = true;
5073 else {
5074 clear_queue_stats();
5075 sdebug_statistics = false;
5076 }
5077 return count;
5078 }
5079 return -EINVAL;
5080}
5081static DRIVER_ATTR_RW(statistics);
5082
82069379 5083static ssize_t sector_size_show(struct device_driver *ddp, char *buf)
597136ab 5084{
773642d9 5085 return scnprintf(buf, PAGE_SIZE, "%u\n", sdebug_sector_size);
597136ab 5086}
82069379 5087static DRIVER_ATTR_RO(sector_size);
597136ab 5088
c4837394
DG		 5089static ssize_t submit_queues_show(struct device_driver *ddp, char *buf)
5090{
5091 return scnprintf(buf, PAGE_SIZE, "%d\n", submit_queues);
5092}
5093static DRIVER_ATTR_RO(submit_queues);
5094
82069379 5095static ssize_t dix_show(struct device_driver *ddp, char *buf)
c6a44287 5096{
773642d9 5097 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dix);
c6a44287 5098}
82069379 5099static DRIVER_ATTR_RO(dix);
c6a44287 5100
82069379 5101static ssize_t dif_show(struct device_driver *ddp, char *buf)
c6a44287 5102{
773642d9 5103 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dif);
c6a44287 5104}
82069379 5105static DRIVER_ATTR_RO(dif);
c6a44287 5106
82069379 5107static ssize_t guard_show(struct device_driver *ddp, char *buf)
c6a44287 5108{
773642d9 5109 return scnprintf(buf, PAGE_SIZE, "%u\n", sdebug_guard);
c6a44287 5110}
82069379 5111static DRIVER_ATTR_RO(guard);
c6a44287 5112
82069379 5113static ssize_t ato_show(struct device_driver *ddp, char *buf)
c6a44287 5114{
773642d9 5115 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ato);
c6a44287 5116}
82069379 5117static DRIVER_ATTR_RO(ato);
c6a44287 5118
82069379 5119static ssize_t map_show(struct device_driver *ddp, char *buf)
44d92694
MP		 5120{
5121 ssize_t count;
5122
5b94e232 5123 if (!scsi_debug_lbp())
44d92694
MP		 5124 return scnprintf(buf, PAGE_SIZE, "0-%u\n",
5125 sdebug_store_sectors);
5126
c7badc90
TH		 5127 count = scnprintf(buf, PAGE_SIZE - 1, "%*pbl",
5128 (int)map_size, map_storep);
44d92694 5129 buf[count++] = '\n';
c7badc90 5130 buf[count] = '\0';
44d92694
MP		 5131
5132 return count;
5133}
82069379 5134static DRIVER_ATTR_RO(map);
44d92694 5135
82069379 5136static ssize_t removable_show(struct device_driver *ddp, char *buf)
d986788b 5137{
773642d9 5138 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_removable ? 1 : 0);
d986788b 5139}
82069379
AM		 5140static ssize_t removable_store(struct device_driver *ddp, const char *buf,
5141 size_t count)
d986788b
MP		 5142{
5143 int n;
5144
5145 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 5146 sdebug_removable = (n > 0);
d986788b
MP		 5147 return count;
5148 }
5149 return -EINVAL;
5150}
82069379 5151static DRIVER_ATTR_RW(removable);
d986788b 5152
cbf67842
DG		 5153static ssize_t host_lock_show(struct device_driver *ddp, char *buf)
5154{
773642d9 5155 return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_host_lock);
cbf67842 5156}
185dd232 5157/* N.B. sdebug_host_lock does nothing, kept for backward compatibility */
cbf67842
DG		 5158static ssize_t host_lock_store(struct device_driver *ddp, const char *buf,
5159 size_t count)
5160{
185dd232 5161 int n;
cbf67842
DG		 5162
5163 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
185dd232
DG		 5164 sdebug_host_lock = (n > 0);
5165 return count;
cbf67842
DG		 5166 }
5167 return -EINVAL;
5168}
5169static DRIVER_ATTR_RW(host_lock);
5170
c2248fc9
DG		 5171static ssize_t strict_show(struct device_driver *ddp, char *buf)
5172{
773642d9 5173 return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_strict);
c2248fc9
DG		 5174}
5175static ssize_t strict_store(struct device_driver *ddp, const char *buf,
5176 size_t count)
5177{
5178 int n;
5179
5180 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 5181 sdebug_strict = (n > 0);
c2248fc9
DG		 5182 return count;
5183 }
5184 return -EINVAL;
5185}
5186static DRIVER_ATTR_RW(strict);
5187
09ba24c1
DG		 5188static ssize_t uuid_ctl_show(struct device_driver *ddp, char *buf)
5189{
5190 return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_uuid_ctl);
5191}
5192static DRIVER_ATTR_RO(uuid_ctl);
5193
9b760fd8
DG		 5194static ssize_t cdb_len_show(struct device_driver *ddp, char *buf)
5195{
5196 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_cdb_len);
5197}
5198static ssize_t cdb_len_store(struct device_driver *ddp, const char *buf,
5199 size_t count)
5200{
5201 int ret, n;
5202
5203 ret = kstrtoint(buf, 0, &n);
5204 if (ret)
5205 return ret;
5206 sdebug_cdb_len = n;
5207 all_config_cdb_len();
5208 return count;
5209}
5210static DRIVER_ATTR_RW(cdb_len);
5211
cbf67842 5212
82069379 5213/* Note: The following array creates attribute files in the
23183910
DG		 5214 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
5215 files (over those found in the /sys/module/scsi_debug/parameters
5216 directory) is that auxiliary actions can be triggered when an attribute
5217 is changed. For example see: sdebug_add_host_store() above.
5218 */
6ecaff7f 5219
82069379
AM		 5220static struct attribute *sdebug_drv_attrs[] = {
5221 &driver_attr_delay.attr,
5222 &driver_attr_opts.attr,
5223 &driver_attr_ptype.attr,
5224 &driver_attr_dsense.attr,
5225 &driver_attr_fake_rw.attr,
5226 &driver_attr_no_lun_0.attr,
5227 &driver_attr_num_tgts.attr,
5228 &driver_attr_dev_size_mb.attr,
5229 &driver_attr_num_parts.attr,
5230 &driver_attr_every_nth.attr,
5231 &driver_attr_max_luns.attr,
5232 &driver_attr_max_queue.attr,
5233 &driver_attr_no_uld.attr,
5234 &driver_attr_scsi_level.attr,
5235 &driver_attr_virtual_gb.attr,
5236 &driver_attr_add_host.attr,
5237 &driver_attr_vpd_use_hostno.attr,
5238 &driver_attr_sector_size.attr,
c4837394
DG		 5239 &driver_attr_statistics.attr,
5240 &driver_attr_submit_queues.attr,
82069379
AM		 5241 &driver_attr_dix.attr,
5242 &driver_attr_dif.attr,
5243 &driver_attr_guard.attr,
5244 &driver_attr_ato.attr,
5245 &driver_attr_map.attr,
5246 &driver_attr_removable.attr,
cbf67842
DG		 5247 &driver_attr_host_lock.attr,
5248 &driver_attr_ndelay.attr,
c2248fc9 5249 &driver_attr_strict.attr,
09ba24c1 5250 &driver_attr_uuid_ctl.attr,
9b760fd8 5251 &driver_attr_cdb_len.attr,
82069379
AM		 5252 NULL,
5253};
5254ATTRIBUTE_GROUPS(sdebug_drv);
1da177e4 5255
11ddceca 5256static struct device *pseudo_primary;
8dea0d02 5257
1da177e4
LT		 5258static int __init scsi_debug_init(void)
5259{
5f2578e5 5260 unsigned long sz;
1da177e4
LT		 5261 int host_to_add;
5262 int k;
6ecaff7f 5263 int ret;
1da177e4 5264
cbf67842
DG		 5265 atomic_set(&retired_max_queue, 0);
5266
773642d9 5267 if (sdebug_ndelay >= 1000 * 1000 * 1000) {
c1287970 5268 pr_warn("ndelay must be less than 1 second, ignored\n");
773642d9
DG		 5269 sdebug_ndelay = 0;
5270 } else if (sdebug_ndelay > 0)
c2206098 5271 sdebug_jdelay = JDELAY_OVERRIDDEN;
cbf67842 5272
773642d9 5273 switch (sdebug_sector_size) {
597136ab
MP		 5274 case 512:
5275 case 1024:
5276 case 2048:
5277 case 4096:
5278 break;
5279 default:
773642d9 5280 pr_err("invalid sector_size %d\n", sdebug_sector_size);
597136ab
MP		 5281 return -EINVAL;
5282 }
5283
773642d9 5284 switch (sdebug_dif) {
8475c811 5285 case T10_PI_TYPE0_PROTECTION:
f46eb0e9 5286 break;
8475c811
CH		 5287 case T10_PI_TYPE1_PROTECTION:
5288 case T10_PI_TYPE2_PROTECTION:
5289 case T10_PI_TYPE3_PROTECTION:
f46eb0e9 5290 have_dif_prot = true;
c6a44287
MP		 5291 break;
5292
5293 default:
c1287970 5294 pr_err("dif must be 0, 1, 2 or 3\n");
c6a44287
MP		 5295 return -EINVAL;
5296 }
5297
773642d9 5298 if (sdebug_guard > 1) {
c1287970 5299 pr_err("guard must be 0 or 1\n");
c6a44287
MP		 5300 return -EINVAL;
5301 }
5302
773642d9 5303 if (sdebug_ato > 1) {
c1287970 5304 pr_err("ato must be 0 or 1\n");
c6a44287
MP		 5305 return -EINVAL;
5306 }
5307
773642d9
DG		 5308 if (sdebug_physblk_exp > 15) {
5309 pr_err("invalid physblk_exp %u\n", sdebug_physblk_exp);
ea61fca5
MP		 5310 return -EINVAL;
5311 }
8d039e22
DG		 5312 if (sdebug_max_luns > 256) {
5313 pr_warn("max_luns can be no more than 256, use default\n");
5314 sdebug_max_luns = DEF_MAX_LUNS;
5315 }
ea61fca5 5316
773642d9
DG		 5317 if (sdebug_lowest_aligned > 0x3fff) {
5318 pr_err("lowest_aligned too big: %u\n", sdebug_lowest_aligned);
ea61fca5
MP		 5319 return -EINVAL;
5320 }
5321
c4837394
DG		 5322 if (submit_queues < 1) {
5323 pr_err("submit_queues must be 1 or more\n");
5324 return -EINVAL;
5325 }
5326 sdebug_q_arr = kcalloc(submit_queues, sizeof(struct sdebug_queue),
5327 GFP_KERNEL);
5328 if (sdebug_q_arr == NULL)
5329 return -ENOMEM;
5330 for (k = 0; k < submit_queues; ++k)
5331 spin_lock_init(&sdebug_q_arr[k].qc_lock);
5332
773642d9
DG		 5333 if (sdebug_dev_size_mb < 1)
5334 sdebug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */
5335 sz = (unsigned long)sdebug_dev_size_mb * 1048576;
5336 sdebug_store_sectors = sz / sdebug_sector_size;
28898873 5337 sdebug_capacity = get_sdebug_capacity();
1da177e4
LT		 5338
5339 /* play around with geometry, don't waste too much on track 0 */
5340 sdebug_heads = 8;
5341 sdebug_sectors_per = 32;
773642d9 5342 if (sdebug_dev_size_mb >= 256)
1da177e4 5343 sdebug_heads = 64;
773642d9 5344 else if (sdebug_dev_size_mb >= 16)
fa785f0a 5345 sdebug_heads = 32;
1da177e4
LT		 5346 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
5347 (sdebug_sectors_per * sdebug_heads);
5348 if (sdebug_cylinders_per >= 1024) {
5349 /* other LLDs do this; implies >= 1GB ram disk ... */
5350 sdebug_heads = 255;
5351 sdebug_sectors_per = 63;
5352 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
5353 (sdebug_sectors_per * sdebug_heads);
5354 }
5355
b01f6f83 5356 if (sdebug_fake_rw == 0) {
cbf67842
DG		 5357 fake_storep = vmalloc(sz);
5358 if (NULL == fake_storep) {
c1287970 5359 pr_err("out of memory, 1\n");
c4837394
DG		 5360 ret = -ENOMEM;
5361 goto free_q_arr;
cbf67842
DG		 5362 }
5363 memset(fake_storep, 0, sz);
773642d9 5364 if (sdebug_num_parts > 0)
cbf67842 5365 sdebug_build_parts(fake_storep, sz);
1da177e4 5366 }
1da177e4 5367
773642d9 5368 if (sdebug_dix) {
c6a44287
MP		 5369 int dif_size;
5370
6ebf105c 5371 dif_size = sdebug_store_sectors * sizeof(struct t10_pi_tuple);
c6a44287
MP		 5372 dif_storep = vmalloc(dif_size);
5373
c1287970 5374 pr_err("dif_storep %u bytes @ %p\n", dif_size, dif_storep);
c6a44287
MP		 5375
5376 if (dif_storep == NULL) {
c1287970 5377 pr_err("out of mem. (DIX)\n");
c6a44287
MP		 5378 ret = -ENOMEM;
5379 goto free_vm;
5380 }
5381
5382 memset(dif_storep, 0xff, dif_size);
5383 }
5384
5b94e232
MP		 5385 /* Logical Block Provisioning */
5386 if (scsi_debug_lbp()) {
773642d9
DG		 5387 sdebug_unmap_max_blocks =
5388 clamp(sdebug_unmap_max_blocks, 0U, 0xffffffffU);
6014759c 5389
773642d9
DG		 5390 sdebug_unmap_max_desc =
5391 clamp(sdebug_unmap_max_desc, 0U, 256U);
6014759c 5392
773642d9
DG		 5393 sdebug_unmap_granularity =
5394 clamp(sdebug_unmap_granularity, 1U, 0xffffffffU);
6014759c 5395
773642d9
DG		 5396 if (sdebug_unmap_alignment &&
5397 sdebug_unmap_granularity <=
5398 sdebug_unmap_alignment) {
c1287970 5399 pr_err("ERR: unmap_granularity <= unmap_alignment\n");
c4837394
DG		 5400 ret = -EINVAL;
5401 goto free_vm;
44d92694
MP		 5402 }
5403
b90ebc3d
AM		 5404 map_size = lba_to_map_index(sdebug_store_sectors - 1) + 1;
5405 map_storep = vmalloc(BITS_TO_LONGS(map_size) * sizeof(long));
44d92694 5406
c1287970 5407 pr_info("%lu provisioning blocks\n", map_size);
44d92694
MP		 5408
5409 if (map_storep == NULL) {
c1287970 5410 pr_err("out of mem. (MAP)\n");
44d92694
MP		 5411 ret = -ENOMEM;
5412 goto free_vm;
5413 }
5414
b90ebc3d 5415 bitmap_zero(map_storep, map_size);
44d92694
MP		 5416
5417 /* Map first 1KB for partition table */
773642d9 5418 if (sdebug_num_parts)
44d92694
MP		 5419 map_region(0, 2);
5420 }
5421
9b906779
NB		 5422 pseudo_primary = root_device_register("pseudo_0");
5423 if (IS_ERR(pseudo_primary)) {
c1287970 5424 pr_warn("root_device_register() error\n");
9b906779 5425 ret = PTR_ERR(pseudo_primary);
6ecaff7f
RD		 5426 goto free_vm;
5427 }
5428 ret = bus_register(&pseudo_lld_bus);
5429 if (ret < 0) {
c1287970 5430 pr_warn("bus_register error: %d\n", ret);
6ecaff7f
RD		 5431 goto dev_unreg;
5432 }
5433 ret = driver_register(&sdebug_driverfs_driver);
5434 if (ret < 0) {
c1287970 5435 pr_warn("driver_register error: %d\n", ret);
6ecaff7f
RD		 5436 goto bus_unreg;
5437 }
1da177e4 5438
773642d9
DG		 5439 host_to_add = sdebug_add_host;
5440 sdebug_add_host = 0;
1da177e4 5441
9a051019
DG		 5442 for (k = 0; k < host_to_add; k++) {
5443 if (sdebug_add_adapter()) {
c1287970 5444 pr_err("sdebug_add_adapter failed k=%d\n", k);
9a051019
DG		 5445 break;
5446 }
5447 }
1da177e4 5448
773642d9
DG		 5449 if (sdebug_verbose)
5450 pr_info("built %d host(s)\n", sdebug_add_host);
c1287970 5451
1da177e4 5452 return 0;
6ecaff7f 5453
6ecaff7f
RD		 5454bus_unreg:
5455 bus_unregister(&pseudo_lld_bus);
5456dev_unreg:
9b906779 5457 root_device_unregister(pseudo_primary);
6ecaff7f 5458free_vm:
de232af6
TW		 5459 vfree(map_storep);
5460 vfree(dif_storep);
6ecaff7f 5461 vfree(fake_storep);
c4837394
DG		 5462free_q_arr:
5463 kfree(sdebug_q_arr);
6ecaff7f 5464 return ret;
1da177e4
LT		 5465}
5466
5467static void __exit scsi_debug_exit(void)
5468{
773642d9 5469 int k = sdebug_add_host;
1da177e4
LT		 5470
5471 stop_all_queued();
cbf67842 5472 free_all_queued();
1da177e4
LT		 5473 for (; k; k--)
5474 sdebug_remove_adapter();
1da177e4
LT		 5475 driver_unregister(&sdebug_driverfs_driver);
5476 bus_unregister(&pseudo_lld_bus);
9b906779 5477 root_device_unregister(pseudo_primary);
1da177e4 5478
4d2b496f 5479 vfree(map_storep);
de232af6 5480 vfree(dif_storep);
1da177e4 5481 vfree(fake_storep);
c4837394 5482 kfree(sdebug_q_arr);
1da177e4
LT		 5483}
5484
5485device_initcall(scsi_debug_init);
5486module_exit(scsi_debug_exit);
5487
91d4c752 5488static void sdebug_release_adapter(struct device *dev)
1da177e4 5489{
9a051019 5490 struct sdebug_host_info *sdbg_host;
1da177e4
LT		 5491
5492 sdbg_host = to_sdebug_host(dev);
9a051019 5493 kfree(sdbg_host);
1da177e4
LT		 5494}
5495
5496static int sdebug_add_adapter(void)
5497{
5498 int k, devs_per_host;
9a051019
DG		 5499 int error = 0;
5500 struct sdebug_host_info *sdbg_host;
8b40228f 5501 struct sdebug_dev_info *sdbg_devinfo, *tmp;
1da177e4 5502
9a051019
DG		 5503 sdbg_host = kzalloc(sizeof(*sdbg_host), GFP_KERNEL);
5504 if (sdbg_host == NULL) {
c1287970 5505 pr_err("out of memory at line %d\n", __LINE__);
9a051019
DG		 5506 return -ENOMEM;
5507 }
1da177e4 5508
9a051019 5509 INIT_LIST_HEAD(&sdbg_host->dev_info_list);
1da177e4 5510
773642d9 5511 devs_per_host = sdebug_num_tgts * sdebug_max_luns;
9a051019 5512 for (k = 0; k < devs_per_host; k++) {
5cb2fc06
FT		 5513 sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL);
5514 if (!sdbg_devinfo) {
c1287970 5515 pr_err("out of memory at line %d\n", __LINE__);
9a051019 5516 error = -ENOMEM;
1da177e4 5517 goto clean;
9a051019
DG		 5518 }
5519 }
1da177e4 5520
9a051019
DG		 5521 spin_lock(&sdebug_host_list_lock);
5522 list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
5523 spin_unlock(&sdebug_host_list_lock);
1da177e4 5524
9a051019
DG		 5525 sdbg_host->dev.bus = &pseudo_lld_bus;
5526 sdbg_host->dev.parent = pseudo_primary;
5527 sdbg_host->dev.release = &sdebug_release_adapter;
773642d9 5528 dev_set_name(&sdbg_host->dev, "adapter%d", sdebug_add_host);
1da177e4 5529
9a051019 5530 error = device_register(&sdbg_host->dev);
1da177e4 5531
9a051019 5532 if (error)
1da177e4
LT		 5533 goto clean;
5534
773642d9 5535 ++sdebug_add_host;
9a051019 5536 return error;
1da177e4
LT		 5537
5538clean:
8b40228f
FT		 5539 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
5540 dev_list) {
1da177e4
LT		 5541 list_del(&sdbg_devinfo->dev_list);
5542 kfree(sdbg_devinfo);
5543 }
5544
5545 kfree(sdbg_host);
9a051019 5546 return error;
1da177e4
LT		 5547}
5548
5549static void sdebug_remove_adapter(void)
5550{
9a051019 5551 struct sdebug_host_info *sdbg_host = NULL;
1da177e4 5552
9a051019
DG		 5553 spin_lock(&sdebug_host_list_lock);
5554 if (!list_empty(&sdebug_host_list)) {
5555 sdbg_host = list_entry(sdebug_host_list.prev,
5556 struct sdebug_host_info, host_list);
1da177e4
LT		 5557 list_del(&sdbg_host->host_list);
5558 }
9a051019 5559 spin_unlock(&sdebug_host_list_lock);
1da177e4
LT		 5560
5561 if (!sdbg_host)
5562 return;
5563
773642d9
DG		 5564 device_unregister(&sdbg_host->dev);
5565 --sdebug_add_host;
1da177e4
LT		 5566}
5567
fd32119b 5568static int sdebug_change_qdepth(struct scsi_device *sdev, int qdepth)
cbf67842
DG		 5569{
5570 int num_in_q = 0;
cbf67842
DG		 5571 struct sdebug_dev_info *devip;
5572
c4837394 5573 block_unblock_all_queues(true);
cbf67842
DG		 5574 devip = (struct sdebug_dev_info *)sdev->hostdata;
5575 if (NULL == devip) {
c4837394 5576 block_unblock_all_queues(false);
cbf67842
DG		 5577 return -ENODEV;
5578 }
5579 num_in_q = atomic_read(&devip->num_in_q);
c40ecc12
CH		 5580
5581 if (qdepth < 1)
5582 qdepth = 1;
c4837394
DG		 5583 /* allow to exceed max host qc_arr elements for testing */
5584 if (qdepth > SDEBUG_CANQUEUE + 10)
5585 qdepth = SDEBUG_CANQUEUE + 10;
db5ed4df 5586 scsi_change_queue_depth(sdev, qdepth);
c40ecc12 5587
773642d9 5588 if (SDEBUG_OPT_Q_NOISE & sdebug_opts) {
c4837394 5589 sdev_printk(KERN_INFO, sdev, "%s: qdepth=%d, num_in_q=%d\n",
c40ecc12 5590 __func__, qdepth, num_in_q);
cbf67842 5591 }
c4837394 5592 block_unblock_all_queues(false);
cbf67842
DG		 5593 return sdev->queue_depth;
5594}
5595
c4837394 5596static bool fake_timeout(struct scsi_cmnd *scp)
817fd66b 5597{
c4837394 5598 if (0 == (atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth))) {
773642d9
DG		 5599 if (sdebug_every_nth < -1)
5600 sdebug_every_nth = -1;
5601 if (SDEBUG_OPT_TIMEOUT & sdebug_opts)
c4837394 5602 return true; /* ignore command causing timeout */
773642d9 5603 else if (SDEBUG_OPT_MAC_TIMEOUT & sdebug_opts &&
817fd66b 5604 scsi_medium_access_command(scp))
c4837394 5605 return true; /* time out reads and writes */
817fd66b 5606 }
c4837394 5607 return false;
817fd66b
DG		 5608}
5609
7ee6d1b4
BVA		 5610static bool fake_host_busy(struct scsi_cmnd *scp)
5611{
5612 return (sdebug_opts & SDEBUG_OPT_HOST_BUSY) &&
5613 (atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth)) == 0;
5614}
5615
fd32119b
DG		 5616static int scsi_debug_queuecommand(struct Scsi_Host *shost,
5617 struct scsi_cmnd *scp)
c2248fc9
DG		 5618{
5619 u8 sdeb_i;
5620 struct scsi_device *sdp = scp->device;
5621 const struct opcode_info_t *oip;
5622 const struct opcode_info_t *r_oip;
5623 struct sdebug_dev_info *devip;
5624 u8 *cmd = scp->cmnd;
5625 int (*r_pfp)(struct scsi_cmnd *, struct sdebug_dev_info *);
5626 int k, na;
5627 int errsts = 0;
c2248fc9
DG		 5628 u32 flags;
5629 u16 sa;
5630 u8 opcode = cmd[0];
5631 bool has_wlun_rl;
c2248fc9
DG		 5632
5633 scsi_set_resid(scp, 0);
c4837394
DG		 5634 if (sdebug_statistics)
5635 atomic_inc(&sdebug_cmnd_count);
f46eb0e9
DG		 5636 if (unlikely(sdebug_verbose &&
5637 !(SDEBUG_OPT_NO_CDB_NOISE & sdebug_opts))) {
c2248fc9
DG		 5638 char b[120];
5639 int n, len, sb;
5640
5641 len = scp->cmd_len;
5642 sb = (int)sizeof(b);
5643 if (len > 32)
5644 strcpy(b, "too long, over 32 bytes");
5645 else {
5646 for (k = 0, n = 0; k < len && n < sb; ++k)
5647 n += scnprintf(b + n, sb - n, "%02x ",
5648 (u32)cmd[k]);
5649 }
458df78b
BVA		 5650 sdev_printk(KERN_INFO, sdp, "%s: tag=%#x, cmd %s\n", my_name,
5651 blk_mq_unique_tag(scp->request), b);
c2248fc9 5652 }
7ee6d1b4
BVA		 5653 if (fake_host_busy(scp))
5654 return SCSI_MLQUEUE_HOST_BUSY;
34d55434 5655 has_wlun_rl = (sdp->lun == SCSI_W_LUN_REPORT_LUNS);
f46eb0e9
DG		 5656 if (unlikely((sdp->lun >= sdebug_max_luns) && !has_wlun_rl))
5657 goto err_out;
c2248fc9
DG		 5658
5659 sdeb_i = opcode_ind_arr[opcode]; /* fully mapped */
5660 oip = &opcode_info_arr[sdeb_i]; /* safe if table consistent */
5661 devip = (struct sdebug_dev_info *)sdp->hostdata;
f46eb0e9
DG		 5662 if (unlikely(!devip)) {
5663 devip = find_build_dev_info(sdp);
c2248fc9 5664 if (NULL == devip)
f46eb0e9 5665 goto err_out;
c2248fc9
DG		 5666 }
5667 na = oip->num_attached;
5668 r_pfp = oip->pfp;
5669 if (na) { /* multiple commands with this opcode */
5670 r_oip = oip;
5671 if (FF_SA & r_oip->flags) {
5672 if (F_SA_LOW & oip->flags)
5673 sa = 0x1f & cmd[1];
5674 else
5675 sa = get_unaligned_be16(cmd + 8);
5676 for (k = 0; k <= na; oip = r_oip->arrp + k++) {
5677 if (opcode == oip->opcode && sa == oip->sa)
5678 break;
5679 }
5680 } else { /* since no service action only check opcode */
5681 for (k = 0; k <= na; oip = r_oip->arrp + k++) {
5682 if (opcode == oip->opcode)
5683 break;
5684 }
5685 }
5686 if (k > na) {
5687 if (F_SA_LOW & r_oip->flags)
5688 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 4);
5689 else if (F_SA_HIGH & r_oip->flags)
5690 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 8, 7);
5691 else
5692 mk_sense_invalid_opcode(scp);
5693 goto check_cond;
5694 }
5695 } /* else (when na==0) we assume the oip is a match */
5696 flags = oip->flags;
f46eb0e9 5697 if (unlikely(F_INV_OP & flags)) {
c2248fc9
DG		 5698 mk_sense_invalid_opcode(scp);
5699 goto check_cond;
5700 }
f46eb0e9 5701 if (unlikely(has_wlun_rl && !(F_RL_WLUN_OK & flags))) {
773642d9
DG		 5702 if (sdebug_verbose)
5703 sdev_printk(KERN_INFO, sdp, "%s: Opcode 0x%x not%s\n",
5704 my_name, opcode, " supported for wlun");
c2248fc9
DG		 5705 mk_sense_invalid_opcode(scp);
5706 goto check_cond;
5707 }
f46eb0e9 5708 if (unlikely(sdebug_strict)) { /* check cdb against mask */
c2248fc9
DG		 5709 u8 rem;
5710 int j;
5711
5712 for (k = 1; k < oip->len_mask[0] && k < 16; ++k) {
5713 rem = ~oip->len_mask[k] & cmd[k];
5714 if (rem) {
5715 for (j = 7; j >= 0; --j, rem <<= 1) {
5716 if (0x80 & rem)
5717 break;
5718 }
5719 mk_sense_invalid_fld(scp, SDEB_IN_CDB, k, j);
5720 goto check_cond;
5721 }
5722 }
5723 }
f46eb0e9 5724 if (unlikely(!(F_SKIP_UA & flags) &&
b01f6f83
DG		 5725 find_first_bit(devip->uas_bm,
5726 SDEBUG_NUM_UAS) != SDEBUG_NUM_UAS)) {
f46eb0e9 5727 errsts = make_ua(scp, devip);
c2248fc9
DG		 5728 if (errsts)
5729 goto check_cond;
5730 }
c4837394 5731 if (unlikely((F_M_ACCESS & flags) && atomic_read(&devip->stopped))) {
c2248fc9 5732 mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x2);
773642d9 5733 if (sdebug_verbose)
c2248fc9
DG		 5734 sdev_printk(KERN_INFO, sdp, "%s reports: Not ready: "
5735 "%s\n", my_name, "initializing command "
5736 "required");
5737 errsts = check_condition_result;
5738 goto fini;
5739 }
773642d9 5740 if (sdebug_fake_rw && (F_FAKE_RW & flags))
c2248fc9 5741 goto fini;
f46eb0e9 5742 if (unlikely(sdebug_every_nth)) {
c4837394 5743 if (fake_timeout(scp))
c2248fc9
DG		 5744 return 0; /* ignore command: make trouble */
5745 }
f46eb0e9
DG		 5746 if (likely(oip->pfp))
5747 errsts = oip->pfp(scp, devip); /* calls a resp_* function */
c2248fc9
DG		 5748 else if (r_pfp) /* if leaf function ptr NULL, try the root's */
5749 errsts = r_pfp(scp, devip);
80c49563
DG		 5750 if (errsts & SDEG_RES_IMMED_MASK) {
5751 errsts &= ~SDEG_RES_IMMED_MASK;
5752 flags |= F_DELAY_OVERR;
5753 flags &= ~F_LONG_DELAY;
5754 }
5755
c2248fc9
DG		 5756
5757fini:
10bde980
DG		 5758 if (F_DELAY_OVERR & flags)
5759 return schedule_resp(scp, devip, errsts, 0, 0);
80c49563
DG		 5760 else if ((sdebug_jdelay || sdebug_ndelay) && (flags & F_LONG_DELAY)) {
5761 /*
5762 * If any delay is active, want F_LONG_DELAY to be at least 1
5763 * second and if sdebug_jdelay>0 want a long delay of that
5764 * many seconds.
5765 */
5766 int jdelay = (sdebug_jdelay < 2) ? 1 : sdebug_jdelay;
5767
5768 jdelay = mult_frac(USER_HZ * jdelay, HZ, USER_HZ);
5769 return schedule_resp(scp, devip, errsts, jdelay, 0);
5770 } else
10bde980
DG		 5771 return schedule_resp(scp, devip, errsts, sdebug_jdelay,
5772 sdebug_ndelay);
c2248fc9 5773check_cond:
10bde980 5774 return schedule_resp(scp, devip, check_condition_result, 0, 0);
f46eb0e9 5775err_out:
10bde980 5776 return schedule_resp(scp, NULL, DID_NO_CONNECT << 16, 0, 0);
c2248fc9
DG		 5777}
5778
9e603ca0 5779static struct scsi_host_template sdebug_driver_template = {
c8ed555a
AV		 5780 .show_info = scsi_debug_show_info,
5781 .write_info = scsi_debug_write_info,
9e603ca0
FT		 5782 .proc_name = sdebug_proc_name,
5783 .name = "SCSI DEBUG",
5784 .info = scsi_debug_info,
5785 .slave_alloc = scsi_debug_slave_alloc,
5786 .slave_configure = scsi_debug_slave_configure,
5787 .slave_destroy = scsi_debug_slave_destroy,
5788 .ioctl = scsi_debug_ioctl,
185dd232 5789 .queuecommand = scsi_debug_queuecommand,
cbf67842 5790 .change_queue_depth = sdebug_change_qdepth,
9e603ca0 5791 .eh_abort_handler = scsi_debug_abort,
9e603ca0 5792 .eh_device_reset_handler = scsi_debug_device_reset,
cbf67842
DG		 5793 .eh_target_reset_handler = scsi_debug_target_reset,
5794 .eh_bus_reset_handler = scsi_debug_bus_reset,
9e603ca0 5795 .eh_host_reset_handler = scsi_debug_host_reset,
c4837394 5796 .can_queue = SDEBUG_CANQUEUE,
9e603ca0 5797 .this_id = 7,
65e8617f 5798 .sg_tablesize = SG_MAX_SEGMENTS,
cbf67842 5799 .cmd_per_lun = DEF_CMD_PER_LUN,
6bb5e6e7 5800 .max_sectors = -1U,
9e603ca0
FT		 5801 .use_clustering = DISABLE_CLUSTERING,
5802 .module = THIS_MODULE,
c40ecc12 5803 .track_queue_depth = 1,
9e603ca0
FT		 5804};
5805
91d4c752 5806static int sdebug_driver_probe(struct device *dev)
1da177e4 5807{
22017ed2
DG		 5808 int error = 0;
5809 struct sdebug_host_info *sdbg_host;
5810 struct Scsi_Host *hpnt;
f46eb0e9 5811 int hprot;
1da177e4
LT		 5812
5813 sdbg_host = to_sdebug_host(dev);
5814
773642d9
DG		 5815 sdebug_driver_template.can_queue = sdebug_max_queue;
5816 if (sdebug_clustering)
0759c666 5817 sdebug_driver_template.use_clustering = ENABLE_CLUSTERING;
78d4e5a0
DG		 5818 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
5819 if (NULL == hpnt) {
c1287970 5820 pr_err("scsi_host_alloc failed\n");
78d4e5a0 5821 error = -ENODEV;
1da177e4 5822 return error;
78d4e5a0 5823 }
c4837394 5824 if (submit_queues > nr_cpu_ids) {
9b130ad5 5825 pr_warn("%s: trim submit_queues (was %d) to nr_cpu_ids=%u\n",
c4837394
DG		 5826 my_name, submit_queues, nr_cpu_ids);
5827 submit_queues = nr_cpu_ids;
5828 }
5829 /* Decide whether to tell scsi subsystem that we want mq */
5830 /* Following should give the same answer for each host */
458df78b 5831 if (shost_use_blk_mq(hpnt))
c4837394 5832 hpnt->nr_hw_queues = submit_queues;
1da177e4 5833
9a051019 5834 sdbg_host->shost = hpnt;
1da177e4 5835 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
773642d9
DG		 5836 if ((hpnt->this_id >= 0) && (sdebug_num_tgts > hpnt->this_id))
5837 hpnt->max_id = sdebug_num_tgts + 1;
1da177e4 5838 else
773642d9
DG		 5839 hpnt->max_id = sdebug_num_tgts;
5840 /* = sdebug_max_luns; */
f2d3fd29 5841 hpnt->max_lun = SCSI_W_LUN_REPORT_LUNS + 1;
1da177e4 5842
f46eb0e9 5843 hprot = 0;
c6a44287 5844
773642d9 5845 switch (sdebug_dif) {
c6a44287 5846
8475c811 5847 case T10_PI_TYPE1_PROTECTION:
f46eb0e9 5848 hprot = SHOST_DIF_TYPE1_PROTECTION;
773642d9 5849 if (sdebug_dix)
f46eb0e9 5850 hprot |= SHOST_DIX_TYPE1_PROTECTION;
c6a44287
MP		 5851 break;
5852
8475c811 5853 case T10_PI_TYPE2_PROTECTION:
f46eb0e9 5854 hprot = SHOST_DIF_TYPE2_PROTECTION;
773642d9 5855 if (sdebug_dix)
f46eb0e9 5856 hprot |= SHOST_DIX_TYPE2_PROTECTION;
c6a44287
MP		 5857 break;
5858
8475c811 5859 case T10_PI_TYPE3_PROTECTION:
f46eb0e9 5860 hprot = SHOST_DIF_TYPE3_PROTECTION;
773642d9 5861 if (sdebug_dix)
f46eb0e9 5862 hprot |= SHOST_DIX_TYPE3_PROTECTION;
c6a44287
MP		 5863 break;
5864
5865 default:
773642d9 5866 if (sdebug_dix)
f46eb0e9 5867 hprot |= SHOST_DIX_TYPE0_PROTECTION;
c6a44287
MP		 5868 break;
5869 }
5870
f46eb0e9 5871 scsi_host_set_prot(hpnt, hprot);
c6a44287 5872
f46eb0e9
DG		 5873 if (have_dif_prot || sdebug_dix)
5874 pr_info("host protection%s%s%s%s%s%s%s\n",
5875 (hprot & SHOST_DIF_TYPE1_PROTECTION) ? " DIF1" : "",
5876 (hprot & SHOST_DIF_TYPE2_PROTECTION) ? " DIF2" : "",
5877 (hprot & SHOST_DIF_TYPE3_PROTECTION) ? " DIF3" : "",
5878 (hprot & SHOST_DIX_TYPE0_PROTECTION) ? " DIX0" : "",
5879 (hprot & SHOST_DIX_TYPE1_PROTECTION) ? " DIX1" : "",
5880 (hprot & SHOST_DIX_TYPE2_PROTECTION) ? " DIX2" : "",
5881 (hprot & SHOST_DIX_TYPE3_PROTECTION) ? " DIX3" : "");
c6a44287 5882
773642d9 5883 if (sdebug_guard == 1)
c6a44287
MP		 5884 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_IP);
5885 else
5886 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_CRC);
5887
773642d9
DG		 5888 sdebug_verbose = !!(SDEBUG_OPT_NOISE & sdebug_opts);
5889 sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & sdebug_opts);
c4837394
DG		 5890 if (sdebug_every_nth) /* need stats counters for every_nth */
5891 sdebug_statistics = true;
9a051019
DG		 5892 error = scsi_add_host(hpnt, &sdbg_host->dev);
5893 if (error) {
c1287970 5894 pr_err("scsi_add_host failed\n");
9a051019 5895 error = -ENODEV;
1da177e4 5896 scsi_host_put(hpnt);
9a051019 5897 } else
1da177e4
LT		 5898 scsi_scan_host(hpnt);
5899
cbf67842 5900 return error;
1da177e4
LT		 5901}
5902
91d4c752 5903static int sdebug_driver_remove(struct device *dev)
1da177e4 5904{
9a051019 5905 struct sdebug_host_info *sdbg_host;
8b40228f 5906 struct sdebug_dev_info *sdbg_devinfo, *tmp;
1da177e4
LT		 5907
5908 sdbg_host = to_sdebug_host(dev);
5909
5910 if (!sdbg_host) {
c1287970 5911 pr_err("Unable to locate host info\n");
1da177e4
LT		 5912 return -ENODEV;
5913 }
5914
9a051019 5915 scsi_remove_host(sdbg_host->shost);
1da177e4 5916
8b40228f
FT		 5917 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
5918 dev_list) {
9a051019
DG		 5919 list_del(&sdbg_devinfo->dev_list);
5920 kfree(sdbg_devinfo);
5921 }
1da177e4 5922
9a051019
DG		 5923 scsi_host_put(sdbg_host->shost);
5924 return 0;
1da177e4
LT		 5925}
5926
8dea0d02
FT		 5927static int pseudo_lld_bus_match(struct device *dev,
5928 struct device_driver *dev_driver)
1da177e4 5929{
8dea0d02 5930 return 1;
1da177e4 5931}
8dea0d02
FT		 5932
5933static struct bus_type pseudo_lld_bus = {
5934 .name = "pseudo",
5935 .match = pseudo_lld_bus_match,
5936 .probe = sdebug_driver_probe,
5937 .remove = sdebug_driver_remove,
82069379 5938 .drv_groups = sdebug_drv_groups,
8dea0d02 5939};
Linux 6.x block layer and io_uring tree(s)