projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drm/amdgpu: Fix RAS function interface
[linux-block.git] / drivers / scsi / scsi_debug.c
CommitLineData
8d7c56d0 1// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 2/*
1da177e4
LT		 3 * vvvvvvvvvvvvvvvvvvvvvvv Original vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
4 * Copyright (C) 1992 Eric Youngdale
5 * Simulate a host adapter with 2 disks attached. Do a lot of checking
6 * to make sure that we are not getting blocks mixed up, and PANIC if
7 * anything out of the ordinary is seen.
8 * ^^^^^^^^^^^^^^^^^^^^^^^ Original ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
9 *
48e3bf16 10 * Copyright (C) 2001 - 2020 Douglas Gilbert
1da177e4 11 *
30f67481 12 * For documentation see http://sg.danny.cz/sg/scsi_debug.html
1da177e4
LT		 13 */
14
c1287970
TW		 15
16#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
17
1da177e4
LT		 18#include <linux/module.h>
19
20#include <linux/kernel.h>
1da177e4 21#include <linux/errno.h>
b333a819 22#include <linux/jiffies.h>
5a0e3ad6 23#include <linux/slab.h>
1da177e4
LT		 24#include <linux/types.h>
25#include <linux/string.h>
26#include <linux/genhd.h>
27#include <linux/fs.h>
28#include <linux/init.h>
29#include <linux/proc_fs.h>
1da177e4
LT		 30#include <linux/vmalloc.h>
31#include <linux/moduleparam.h>
852e034d 32#include <linux/scatterlist.h>
1da177e4 33#include <linux/blkdev.h>
c6a44287 34#include <linux/crc-t10dif.h>
cbf67842
DG		 35#include <linux/spinlock.h>
36#include <linux/interrupt.h>
37#include <linux/atomic.h>
38#include <linux/hrtimer.h>
09ba24c1 39#include <linux/uuid.h>
6ebf105c 40#include <linux/t10-pi.h>
1442f76d 41#include <linux/msdos_partition.h>
0c4bc91d 42#include <linux/random.h>
87c715dc 43#include <linux/xarray.h>
ed9f3e25 44#include <linux/prefetch.h>
c6a44287
MP		 45
46#include <net/checksum.h>
9ff26eef 47
44d92694
MP		 48#include <asm/unaligned.h>
49
9ff26eef
FT		 50#include <scsi/scsi.h>
51#include <scsi/scsi_cmnd.h>
52#include <scsi/scsi_device.h>
1da177e4
LT		 53#include <scsi/scsi_host.h>
54#include <scsi/scsicam.h>
a34c4e98 55#include <scsi/scsi_eh.h>
cbf67842 56#include <scsi/scsi_tcq.h>
395cef03 57#include <scsi/scsi_dbg.h>
1da177e4 58
c6a44287 59#include "sd.h"
1da177e4 60#include "scsi_logging.h"
1da177e4 61
773642d9 62/* make sure inq_product_rev string corresponds to this version */
30f67481
DG		 63#define SDEBUG_VERSION "0190" /* format to fit INQUIRY revision field */
64static const char *sdebug_version_date = "20200710";
cbf67842
DG		 65
66#define MY_NAME "scsi_debug"
1da177e4 67
6f3cbf55 68/* Additional Sense Code (ASC) */
c65b1445
DG		 69#define NO_ADDITIONAL_SENSE 0x0
70#define LOGICAL_UNIT_NOT_READY 0x4
c2248fc9 71#define LOGICAL_UNIT_COMMUNICATION_FAILURE 0x8
1da177e4 72#define UNRECOVERED_READ_ERR 0x11
c65b1445 73#define PARAMETER_LIST_LENGTH_ERR 0x1a
1da177e4 74#define INVALID_OPCODE 0x20
22017ed2 75#define LBA_OUT_OF_RANGE 0x21
1da177e4 76#define INVALID_FIELD_IN_CDB 0x24
c65b1445 77#define INVALID_FIELD_IN_PARAM_LIST 0x26
9447b6ce 78#define WRITE_PROTECTED 0x27
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
f0d1cf93
DG		 97#define UNALIGNED_WRITE_ASCQ 0x4
98#define WRITE_BOUNDARY_ASCQ 0x5
99#define READ_INVDATA_ASCQ 0x6
100#define READ_BOUNDARY_ASCQ 0x7
101#define INSUFF_ZONE_ASCQ 0xe
1da177e4 102
6f3cbf55
DG		 103/* Additional Sense Code Qualifier (ASCQ) */
104#define ACK_NAK_TO 0x3
105
1da177e4
LT		 106/* Default values for driver parameters */
107#define DEF_NUM_HOST 1
108#define DEF_NUM_TGTS 1
109#define DEF_MAX_LUNS 1
110/* With these defaults, this driver will make 1 host with 1 target
111 * (id 0) containing 1 logical unit (lun 0). That is 1 device.
112 */
5b94e232 113#define DEF_ATO 1
9b760fd8 114#define DEF_CDB_LEN 10
c2206098 115#define DEF_JDELAY 1 /* if > 0 unit is a jiffy */
9267e0eb 116#define DEF_DEV_SIZE_PRE_INIT 0
1da177e4 117#define DEF_DEV_SIZE_MB 8
9267e0eb 118#define DEF_ZBC_DEV_SIZE_MB 128
5b94e232
MP		 119#define DEF_DIF 0
120#define DEF_DIX 0
87c715dc 121#define DEF_PER_HOST_STORE false
1da177e4 122#define DEF_D_SENSE 0
5b94e232 123#define DEF_EVERY_NTH 0
23183910 124#define DEF_FAKE_RW 0
c6a44287 125#define DEF_GUARD 0
cbf67842 126#define DEF_HOST_LOCK 0
5b94e232
MP		 127#define DEF_LBPU 0
128#define DEF_LBPWS 0
129#define DEF_LBPWS10 0
be1dd78d 130#define DEF_LBPRZ 1
ea61fca5 131#define DEF_LOWEST_ALIGNED 0
cbf67842 132#define DEF_NDELAY 0 /* if > 0 unit is a nanosecond */
5b94e232
MP		 133#define DEF_NO_LUN_0 0
134#define DEF_NUM_PARTS 0
135#define DEF_OPTS 0
32c5844a 136#define DEF_OPT_BLKS 1024
5b94e232 137#define DEF_PHYSBLK_EXP 0
86e6828a 138#define DEF_OPT_XFERLEN_EXP 0
b01f6f83 139#define DEF_PTYPE TYPE_DISK
0c4bc91d 140#define DEF_RANDOM false
d986788b 141#define DEF_REMOVABLE false
760f3b03 142#define DEF_SCSI_LEVEL 7 /* INQUIRY, byte2 [6->SPC-4; 7->SPC-5] */
5b94e232
MP		 143#define DEF_SECTOR_SIZE 512
144#define DEF_UNMAP_ALIGNMENT 0
145#define DEF_UNMAP_GRANULARITY 1
6014759c
MP		 146#define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF
147#define DEF_UNMAP_MAX_DESC 256
5b94e232
MP		 148#define DEF_VIRTUAL_GB 0
149#define DEF_VPD_USE_HOSTNO 1
150#define DEF_WRITESAME_LENGTH 0xFFFF
c2248fc9 151#define DEF_STRICT 0
c4837394
DG		 152#define DEF_STATISTICS false
153#define DEF_SUBMIT_QUEUES 1
fc13638a 154#define DEF_TUR_MS_TO_READY 0
09ba24c1 155#define DEF_UUID_CTL 0
c2206098 156#define JDELAY_OVERRIDDEN -9999
1da177e4 157
f0d1cf93
DG		 158/* Default parameters for ZBC drives */
159#define DEF_ZBC_ZONE_SIZE_MB 128
160#define DEF_ZBC_MAX_OPEN_ZONES 8
aa8fecf9 161#define DEF_ZBC_NR_CONV_ZONES 1
f0d1cf93 162
b01f6f83
DG		 163#define SDEBUG_LUN_0_VAL 0
164
773642d9
DG		 165/* bit mask values for sdebug_opts */
166#define SDEBUG_OPT_NOISE 1
167#define SDEBUG_OPT_MEDIUM_ERR 2
168#define SDEBUG_OPT_TIMEOUT 4
169#define SDEBUG_OPT_RECOVERED_ERR 8
170#define SDEBUG_OPT_TRANSPORT_ERR 16
171#define SDEBUG_OPT_DIF_ERR 32
172#define SDEBUG_OPT_DIX_ERR 64
173#define SDEBUG_OPT_MAC_TIMEOUT 128
174#define SDEBUG_OPT_SHORT_TRANSFER 0x100
175#define SDEBUG_OPT_Q_NOISE 0x200
176#define SDEBUG_OPT_ALL_TSF 0x400
177#define SDEBUG_OPT_RARE_TSF 0x800
178#define SDEBUG_OPT_N_WCE 0x1000
179#define SDEBUG_OPT_RESET_NOISE 0x2000
180#define SDEBUG_OPT_NO_CDB_NOISE 0x4000
7ee6d1b4 181#define SDEBUG_OPT_HOST_BUSY 0x8000
7382f9d8 182#define SDEBUG_OPT_CMD_ABORT 0x10000
773642d9
DG		 183#define SDEBUG_OPT_ALL_NOISE (SDEBUG_OPT_NOISE | SDEBUG_OPT_Q_NOISE | \
184 SDEBUG_OPT_RESET_NOISE)
185#define SDEBUG_OPT_ALL_INJECTING (SDEBUG_OPT_RECOVERED_ERR | \
186 SDEBUG_OPT_TRANSPORT_ERR | \
187 SDEBUG_OPT_DIF_ERR | SDEBUG_OPT_DIX_ERR | \
7ee6d1b4 188 SDEBUG_OPT_SHORT_TRANSFER | \
7382f9d8
DG		 189 SDEBUG_OPT_HOST_BUSY | \
190 SDEBUG_OPT_CMD_ABORT)
3a90a63d
DG		 191#define SDEBUG_OPT_RECOV_DIF_DIX (SDEBUG_OPT_RECOVERED_ERR | \
192 SDEBUG_OPT_DIF_ERR | SDEBUG_OPT_DIX_ERR)
1da177e4 193
fd32119b 194/* As indicated in SAM-5 and SPC-4 Unit Attentions (UAs) are returned in
cbf67842
DG		 195 * priority order. In the subset implemented here lower numbers have higher
196 * priority. The UA numbers should be a sequence starting from 0 with
197 * SDEBUG_NUM_UAS being 1 higher than the highest numbered UA. */
198#define SDEBUG_UA_POR 0 /* Power on, reset, or bus device reset */
199#define SDEBUG_UA_BUS_RESET 1
200#define SDEBUG_UA_MODE_CHANGED 2
0d01c5df 201#define SDEBUG_UA_CAPACITY_CHANGED 3
19c8ead7 202#define SDEBUG_UA_LUNS_CHANGED 4
acafd0b9
EM		 203#define SDEBUG_UA_MICROCODE_CHANGED 5 /* simulate firmware change */
204#define SDEBUG_UA_MICROCODE_CHANGED_WO_RESET 6
205#define SDEBUG_NUM_UAS 7
cbf67842 206
773642d9 207/* when 1==SDEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
1da177e4
LT		 208 * sector on read commands: */
209#define OPT_MEDIUM_ERR_ADDR 0x1234 /* that's sector 4660 in decimal */
32f7ef73 210#define OPT_MEDIUM_ERR_NUM 10 /* number of consecutive medium errs */
1da177e4 211
c4837394
DG		 212/* SDEBUG_CANQUEUE is the maximum number of commands that can be queued
213 * (for response) per submit queue at one time. Can be reduced by max_queue
214 * option. Command responses are not queued when jdelay=0 and ndelay=0. The
215 * per-device DEF_CMD_PER_LUN can be changed via sysfs:
216 * /sys/class/scsi_device/<h:c:t:l>/device/queue_depth
217 * but cannot exceed SDEBUG_CANQUEUE .
218 */
219#define SDEBUG_CANQUEUE_WORDS 3 /* a WORD is bits in a long */
220#define SDEBUG_CANQUEUE (SDEBUG_CANQUEUE_WORDS * BITS_PER_LONG)
fc09acb7 221#define DEF_CMD_PER_LUN SDEBUG_CANQUEUE
cbf67842 222
b6ff8ca7
DG		 223/* UA - Unit Attention; SA - Service Action; SSU - Start Stop Unit */
224#define F_D_IN 1 /* Data-in command (e.g. READ) */
225#define F_D_OUT 2 /* Data-out command (e.g. WRITE) */
fd32119b
DG		 226#define F_D_OUT_MAYBE 4 /* WRITE SAME, NDOB bit */
227#define F_D_UNKN 8
b6ff8ca7
DG		 228#define F_RL_WLUN_OK 0x10 /* allowed with REPORT LUNS W-LUN */
229#define F_SKIP_UA 0x20 /* bypass UAs (e.g. INQUIRY command) */
230#define F_DELAY_OVERR 0x40 /* for commands like INQUIRY */
231#define F_SA_LOW 0x80 /* SA is in cdb byte 1, bits 4 to 0 */
232#define F_SA_HIGH 0x100 /* SA is in cdb bytes 8 and 9 */
233#define F_INV_OP 0x200 /* invalid opcode (not supported) */
234#define F_FAKE_RW 0x400 /* bypass resp_*() when fake_rw set */
235#define F_M_ACCESS 0x800 /* media access, reacts to SSU state */
236#define F_SSU_DELAY 0x1000 /* SSU command delay (long-ish) */
237#define F_SYNC_DELAY 0x2000 /* SYNCHRONIZE CACHE delay */
238
239/* Useful combinations of the above flags */
fd32119b 240#define FF_RESPOND (F_RL_WLUN_OK | F_SKIP_UA | F_DELAY_OVERR)
46f64e70 241#define FF_MEDIA_IO (F_M_ACCESS | F_FAKE_RW)
fd32119b 242#define FF_SA (F_SA_HIGH | F_SA_LOW)
4f2c8bf6 243#define F_LONG_DELAY (F_SSU_DELAY | F_SYNC_DELAY)
fd32119b
DG		 244
245#define SDEBUG_MAX_PARTS 4
246
b01f6f83 247#define SDEBUG_MAX_CMD_LEN 32
fd32119b 248
87c715dc
DG		 249#define SDEB_XA_NOT_IN_USE XA_MARK_1
250
64e14ece
DLM		 251/* Zone types (zbcr05 table 25) */
252enum sdebug_z_type {
253 ZBC_ZONE_TYPE_CNV = 0x1,
254 ZBC_ZONE_TYPE_SWR = 0x2,
255 ZBC_ZONE_TYPE_SWP = 0x3,
256};
257
f0d1cf93
DG		 258/* enumeration names taken from table 26, zbcr05 */
259enum sdebug_z_cond {
260 ZBC_NOT_WRITE_POINTER = 0x0,
261 ZC1_EMPTY = 0x1,
262 ZC2_IMPLICIT_OPEN = 0x2,
263 ZC3_EXPLICIT_OPEN = 0x3,
264 ZC4_CLOSED = 0x4,
265 ZC6_READ_ONLY = 0xd,
266 ZC5_FULL = 0xe,
267 ZC7_OFFLINE = 0xf,
268};
269
270struct sdeb_zone_state { /* ZBC: per zone state */
64e14ece 271 enum sdebug_z_type z_type;
f0d1cf93 272 enum sdebug_z_cond z_cond;
64e14ece 273 bool z_non_seq_resource;
f0d1cf93
DG		 274 unsigned int z_size;
275 sector_t z_start;
276 sector_t z_wp;
277};
fd32119b
DG		 278
279struct sdebug_dev_info {
280 struct list_head dev_list;
281 unsigned int channel;
282 unsigned int target;
283 u64 lun;
bf476433 284 uuid_t lu_name;
fd32119b
DG		 285 struct sdebug_host_info *sdbg_host;
286 unsigned long uas_bm[1];
287 atomic_t num_in_q;
fc13638a 288 atomic_t stopped; /* 1: by SSU, 2: device start */
fd32119b 289 bool used;
f0d1cf93
DG		 290
291 /* For ZBC devices */
64e14ece 292 enum blk_zoned_model zmodel;
f0d1cf93
DG		 293 unsigned int zsize;
294 unsigned int zsize_shift;
295 unsigned int nr_zones;
aa8fecf9 296 unsigned int nr_conv_zones;
f0d1cf93
DG		 297 unsigned int nr_imp_open;
298 unsigned int nr_exp_open;
299 unsigned int nr_closed;
300 unsigned int max_open;
fc13638a 301 ktime_t create_ts; /* time since bootup that this device was created */
f0d1cf93 302 struct sdeb_zone_state *zstate;
fd32119b
DG		 303};
304
305struct sdebug_host_info {
306 struct list_head host_list;
87c715dc 307 int si_idx; /* sdeb_store_info (per host) xarray index */
fd32119b
DG		 308 struct Scsi_Host *shost;
309 struct device dev;
310 struct list_head dev_info_list;
311};
312
87c715dc
DG		 313/* There is an xarray of pointers to this struct's objects, one per host */
314struct sdeb_store_info {
315 rwlock_t macc_lck; /* for atomic media access on this store */
316 u8 *storep; /* user data storage (ram) */
317 struct t10_pi_tuple *dif_storep; /* protection info */
318 void *map_storep; /* provisioning map */
319};
320
fd32119b
DG		 321#define to_sdebug_host(d) \
322 container_of(d, struct sdebug_host_info, dev)
323
10bde980 324enum sdeb_defer_type {SDEB_DEFER_NONE = 0, SDEB_DEFER_HRT = 1,
4a0c6f43 325 SDEB_DEFER_WQ = 2, SDEB_DEFER_POLL = 3};
10bde980 326
fd32119b
DG		 327struct sdebug_defer {
328 struct hrtimer hrt;
329 struct execute_work ew;
4a0c6f43 330 ktime_t cmpl_ts;/* time since boot to complete this cmd */
c4837394
DG		 331 int sqa_idx; /* index of sdebug_queue array */
332 int qc_idx; /* index of sdebug_queued_cmd array within sqa_idx */
c10fa55f 333 int hc_idx; /* hostwide tag index */
c4837394 334 int issuing_cpu;
10bde980
DG		 335 bool init_hrt;
336 bool init_wq;
4a0c6f43 337 bool init_poll;
7382f9d8 338 bool aborted; /* true when blk_abort_request() already called */
10bde980 339 enum sdeb_defer_type defer_t;
fd32119b
DG		 340};
341
342struct sdebug_queued_cmd {
c4837394
DG		 343 /* corresponding bit set in in_use_bm[] in owning struct sdebug_queue
344 * instance indicates this slot is in use.
345 */
fd32119b
DG		 346 struct sdebug_defer *sd_dp;
347 struct scsi_cmnd *a_cmnd;
348};
349
c4837394
DG		 350struct sdebug_queue {
351 struct sdebug_queued_cmd qc_arr[SDEBUG_CANQUEUE];
352 unsigned long in_use_bm[SDEBUG_CANQUEUE_WORDS];
353 spinlock_t qc_lock;
354 atomic_t blocked; /* to temporarily stop more being queued */
fd32119b
DG		 355};
356
c4837394
DG		 357static atomic_t sdebug_cmnd_count; /* number of incoming commands */
358static atomic_t sdebug_completions; /* count of deferred completions */
359static atomic_t sdebug_miss_cpus; /* submission + completion cpus differ */
360static atomic_t sdebug_a_tsf; /* 'almost task set full' counter */
3a90a63d 361static atomic_t sdeb_inject_pending;
4a0c6f43 362static atomic_t sdeb_mq_poll_count; /* bumped when mq_poll returns > 0 */
c4837394 363
fd32119b 364struct opcode_info_t {
b01f6f83
DG		 365 u8 num_attached; /* 0 if this is it (i.e. a leaf); use 0xff */
366 /* for terminating element */
fd32119b
DG		 367 u8 opcode; /* if num_attached > 0, preferred */
368 u16 sa; /* service action */
369 u32 flags; /* OR-ed set of SDEB_F_* */
370 int (*pfp)(struct scsi_cmnd *, struct sdebug_dev_info *);
371 const struct opcode_info_t *arrp; /* num_attached elements or NULL */
9a051019
DG		 372 u8 len_mask[16]; /* len_mask[0]-->cdb_len, then mask for cdb */
373 /* 1 to min(cdb_len, 15); ignore cdb[15...] */
fd32119b
DG		 374};
375
376/* SCSI opcodes (first byte of cdb) of interest mapped onto these indexes */
c2248fc9
DG		 377enum sdeb_opcode_index {
378 SDEB_I_INVALID_OPCODE = 0,
379 SDEB_I_INQUIRY = 1,
380 SDEB_I_REPORT_LUNS = 2,
381 SDEB_I_REQUEST_SENSE = 3,
382 SDEB_I_TEST_UNIT_READY = 4,
383 SDEB_I_MODE_SENSE = 5, /* 6, 10 */
384 SDEB_I_MODE_SELECT = 6, /* 6, 10 */
385 SDEB_I_LOG_SENSE = 7,
386 SDEB_I_READ_CAPACITY = 8, /* 10; 16 is in SA_IN(16) */
387 SDEB_I_READ = 9, /* 6, 10, 12, 16 */
388 SDEB_I_WRITE = 10, /* 6, 10, 12, 16 */
389 SDEB_I_START_STOP = 11,
46f64e70
DG		 390 SDEB_I_SERV_ACT_IN_16 = 12, /* add ...SERV_ACT_IN_12 if needed */
391 SDEB_I_SERV_ACT_OUT_16 = 13, /* add ...SERV_ACT_OUT_12 if needed */
c2248fc9
DG		 392 SDEB_I_MAINT_IN = 14,
393 SDEB_I_MAINT_OUT = 15,
c3e2fe92 394 SDEB_I_VERIFY = 16, /* VERIFY(10), VERIFY(16) */
481b5e5c 395 SDEB_I_VARIABLE_LEN = 17, /* READ(32), WRITE(32), WR_SCAT(32) */
c2248fc9
DG		 396 SDEB_I_RESERVE = 18, /* 6, 10 */
397 SDEB_I_RELEASE = 19, /* 6, 10 */
398 SDEB_I_ALLOW_REMOVAL = 20, /* PREVENT ALLOW MEDIUM REMOVAL */
399 SDEB_I_REZERO_UNIT = 21, /* REWIND in SSC */
400 SDEB_I_ATA_PT = 22, /* 12, 16 */
401 SDEB_I_SEND_DIAG = 23,
402 SDEB_I_UNMAP = 24,
c208556a
BVA		 403 SDEB_I_WRITE_BUFFER = 25,
404 SDEB_I_WRITE_SAME = 26, /* 10, 16 */
405 SDEB_I_SYNC_CACHE = 27, /* 10, 16 */
406 SDEB_I_COMP_WRITE = 28,
ed9f3e25 407 SDEB_I_PRE_FETCH = 29, /* 10, 16 */
f0d1cf93
DG		 408 SDEB_I_ZONE_OUT = 30, /* 0x94+SA; includes no data xfer */
409 SDEB_I_ZONE_IN = 31, /* 0x95+SA; all have data-in */
410 SDEB_I_LAST_ELEM_P1 = 32, /* keep this last (previous + 1) */
c2248fc9
DG		 411};
412
c4837394 413
c2248fc9
DG		 414static const unsigned char opcode_ind_arr[256] = {
415/* 0x0; 0x0->0x1f: 6 byte cdbs */
416 SDEB_I_TEST_UNIT_READY, SDEB_I_REZERO_UNIT, 0, SDEB_I_REQUEST_SENSE,
417 0, 0, 0, 0,
418 SDEB_I_READ, 0, SDEB_I_WRITE, 0, 0, 0, 0, 0,
419 0, 0, SDEB_I_INQUIRY, 0, 0, SDEB_I_MODE_SELECT, SDEB_I_RESERVE,
420 SDEB_I_RELEASE,
421 0, 0, SDEB_I_MODE_SENSE, SDEB_I_START_STOP, 0, SDEB_I_SEND_DIAG,
422 SDEB_I_ALLOW_REMOVAL, 0,
423/* 0x20; 0x20->0x3f: 10 byte cdbs */
424 0, 0, 0, 0, 0, SDEB_I_READ_CAPACITY, 0, 0,
425 SDEB_I_READ, 0, SDEB_I_WRITE, 0, 0, 0, 0, SDEB_I_VERIFY,
ed9f3e25 426 0, 0, 0, 0, SDEB_I_PRE_FETCH, SDEB_I_SYNC_CACHE, 0, 0,
c2248fc9
DG		 427 0, 0, 0, SDEB_I_WRITE_BUFFER, 0, 0, 0, 0,
428/* 0x40; 0x40->0x5f: 10 byte cdbs */
429 0, SDEB_I_WRITE_SAME, SDEB_I_UNMAP, 0, 0, 0, 0, 0,
430 0, 0, 0, 0, 0, SDEB_I_LOG_SENSE, 0, 0,
c208556a 431 0, 0, 0, 0, 0, SDEB_I_MODE_SELECT, SDEB_I_RESERVE,
c2248fc9
DG		 432 SDEB_I_RELEASE,
433 0, 0, SDEB_I_MODE_SENSE, 0, 0, 0, 0, 0,
fd32119b 434/* 0x60; 0x60->0x7d are reserved, 0x7e is "extended cdb" */
c2248fc9
DG		 435 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
436 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
437 0, SDEB_I_VARIABLE_LEN,
438/* 0x80; 0x80->0x9f: 16 byte cdbs */
439 0, 0, 0, 0, 0, SDEB_I_ATA_PT, 0, 0,
c3e2fe92
DG		 440 SDEB_I_READ, SDEB_I_COMP_WRITE, SDEB_I_WRITE, 0,
441 0, 0, 0, SDEB_I_VERIFY,
f0d1cf93
DG		 442 SDEB_I_PRE_FETCH, SDEB_I_SYNC_CACHE, 0, SDEB_I_WRITE_SAME,
443 SDEB_I_ZONE_OUT, SDEB_I_ZONE_IN, 0, 0,
46f64e70 444 0, 0, 0, 0, 0, 0, SDEB_I_SERV_ACT_IN_16, SDEB_I_SERV_ACT_OUT_16,
c2248fc9
DG		 445/* 0xa0; 0xa0->0xbf: 12 byte cdbs */
446 SDEB_I_REPORT_LUNS, SDEB_I_ATA_PT, 0, SDEB_I_MAINT_IN,
447 SDEB_I_MAINT_OUT, 0, 0, 0,
46f64e70
DG		 448 SDEB_I_READ, 0 /* SDEB_I_SERV_ACT_OUT_12 */, SDEB_I_WRITE,
449 0 /* SDEB_I_SERV_ACT_IN_12 */, 0, 0, 0, 0,
c2248fc9
DG		 450 0, 0, 0, 0, 0, 0, 0, 0,
451 0, 0, 0, 0, 0, 0, 0, 0,
452/* 0xc0; 0xc0->0xff: vendor specific */
453 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
454 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
455 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
456 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
457};
458
80c49563
DG		 459/*
460 * The following "response" functions return the SCSI mid-level's 4 byte
461 * tuple-in-an-int. To handle commands with an IMMED bit, for a faster
462 * command completion, they can mask their return value with
463 * SDEG_RES_IMMED_MASK .
464 */
465#define SDEG_RES_IMMED_MASK 0x40000000
466
c2248fc9
DG		 467static int resp_inquiry(struct scsi_cmnd *, struct sdebug_dev_info *);
468static int resp_report_luns(struct scsi_cmnd *, struct sdebug_dev_info *);
469static int resp_requests(struct scsi_cmnd *, struct sdebug_dev_info *);
470static int resp_mode_sense(struct scsi_cmnd *, struct sdebug_dev_info *);
471static int resp_mode_select(struct scsi_cmnd *, struct sdebug_dev_info *);
472static int resp_log_sense(struct scsi_cmnd *, struct sdebug_dev_info *);
473static int resp_readcap(struct scsi_cmnd *, struct sdebug_dev_info *);
474static int resp_read_dt0(struct scsi_cmnd *, struct sdebug_dev_info *);
475static int resp_write_dt0(struct scsi_cmnd *, struct sdebug_dev_info *);
481b5e5c 476static int resp_write_scat(struct scsi_cmnd *, struct sdebug_dev_info *);
c2248fc9
DG		 477static int resp_start_stop(struct scsi_cmnd *, struct sdebug_dev_info *);
478static int resp_readcap16(struct scsi_cmnd *, struct sdebug_dev_info *);
479static int resp_get_lba_status(struct scsi_cmnd *, struct sdebug_dev_info *);
480static int resp_report_tgtpgs(struct scsi_cmnd *, struct sdebug_dev_info *);
481static int resp_unmap(struct scsi_cmnd *, struct sdebug_dev_info *);
38d5c833
DG		 482static int resp_rsup_opcodes(struct scsi_cmnd *, struct sdebug_dev_info *);
483static int resp_rsup_tmfs(struct scsi_cmnd *, struct sdebug_dev_info *);
c3e2fe92 484static int resp_verify(struct scsi_cmnd *, struct sdebug_dev_info *);
c2248fc9
DG		 485static int resp_write_same_10(struct scsi_cmnd *, struct sdebug_dev_info *);
486static int resp_write_same_16(struct scsi_cmnd *, struct sdebug_dev_info *);
38d5c833 487static int resp_comp_write(struct scsi_cmnd *, struct sdebug_dev_info *);
acafd0b9 488static int resp_write_buffer(struct scsi_cmnd *, struct sdebug_dev_info *);
80c49563 489static int resp_sync_cache(struct scsi_cmnd *, struct sdebug_dev_info *);
ed9f3e25 490static int resp_pre_fetch(struct scsi_cmnd *, struct sdebug_dev_info *);
f0d1cf93
DG		 491static int resp_report_zones(struct scsi_cmnd *, struct sdebug_dev_info *);
492static int resp_open_zone(struct scsi_cmnd *, struct sdebug_dev_info *);
493static int resp_close_zone(struct scsi_cmnd *, struct sdebug_dev_info *);
494static int resp_finish_zone(struct scsi_cmnd *, struct sdebug_dev_info *);
495static int resp_rwp_zone(struct scsi_cmnd *, struct sdebug_dev_info *);
c2248fc9 496
87c715dc
DG		 497static int sdebug_do_add_host(bool mk_new_store);
498static int sdebug_add_host_helper(int per_host_idx);
499static void sdebug_do_remove_host(bool the_end);
500static int sdebug_add_store(void);
501static void sdebug_erase_store(int idx, struct sdeb_store_info *sip);
502static void sdebug_erase_all_stores(bool apart_from_first);
503
46f64e70
DG		 504/*
505 * The following are overflow arrays for cdbs that "hit" the same index in
506 * the opcode_info_arr array. The most time sensitive (or commonly used) cdb
507 * should be placed in opcode_info_arr[], the others should be placed here.
508 */
509static const struct opcode_info_t msense_iarr[] = {
c2248fc9
DG		 510 {0, 0x1a, 0, F_D_IN, NULL, NULL,
511 {6, 0xe8, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
512};
513
46f64e70 514static const struct opcode_info_t mselect_iarr[] = {
c2248fc9
DG		 515 {0, 0x15, 0, F_D_OUT, NULL, NULL,
516 {6, 0xf1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
517};
518
46f64e70
DG		 519static const struct opcode_info_t read_iarr[] = {
520 {0, 0x28, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL,/* READ(10) */
b7e24581 521 {10, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
c2248fc9 522 0, 0, 0, 0} },
46f64e70 523 {0, 0x8, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL, /* READ(6) */
c2248fc9 524 {6, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
46f64e70 525 {0, 0xa8, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL,/* READ(12) */
b7e24581 526 {12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf,
c2248fc9
DG		 527 0xc7, 0, 0, 0, 0} },
528};
529
46f64e70
DG		 530static const struct opcode_info_t write_iarr[] = {
531 {0, 0x2a, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0, /* WRITE(10) */
532 NULL, {10, 0xfb, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7,
533 0, 0, 0, 0, 0, 0} },
534 {0, 0xa, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0, /* WRITE(6) */
535 NULL, {6, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0,
536 0, 0, 0} },
537 {0, 0xaa, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0, /* WRITE(12) */
538 NULL, {12, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
539 0xbf, 0xc7, 0, 0, 0, 0} },
c2248fc9
DG		 540};
541
c3e2fe92
DG		 542static const struct opcode_info_t verify_iarr[] = {
543 {0, 0x2f, 0, F_D_OUT_MAYBE | FF_MEDIA_IO, resp_verify,/* VERIFY(10) */
544 NULL, {10, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xc7,
545 0, 0, 0, 0, 0, 0} },
546};
547
46f64e70 548static const struct opcode_info_t sa_in_16_iarr[] = {
c2248fc9
DG		 549 {0, 0x9e, 0x12, F_SA_LOW | F_D_IN, resp_get_lba_status, NULL,
550 {16, 0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
46f64e70 551 0xff, 0xff, 0xff, 0, 0xc7} }, /* GET LBA STATUS(16) */
c2248fc9
DG		 552};
553
46f64e70
DG		 554static const struct opcode_info_t vl_iarr[] = { /* VARIABLE LENGTH */
555 {0, 0x7f, 0xb, F_SA_HIGH | F_D_OUT | FF_MEDIA_IO, resp_write_dt0,
b7e24581 556 NULL, {32, 0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0xb, 0xfa,
c2248fc9 557 0, 0xff, 0xff, 0xff, 0xff} }, /* WRITE(32) */
481b5e5c
DG		 558 {0, 0x7f, 0x11, F_SA_HIGH | F_D_OUT | FF_MEDIA_IO, resp_write_scat,
559 NULL, {32, 0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0x11, 0xf8,
560 0, 0xff, 0xff, 0x0, 0x0} }, /* WRITE SCATTERED(32) */
c2248fc9
DG		 561};
562
46f64e70 563static const struct opcode_info_t maint_in_iarr[] = { /* MAINT IN */
38d5c833 564 {0, 0xa3, 0xc, F_SA_LOW | F_D_IN, resp_rsup_opcodes, NULL,
c2248fc9 565 {12, 0xc, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0,
46f64e70 566 0xc7, 0, 0, 0, 0} }, /* REPORT SUPPORTED OPERATION CODES */
38d5c833 567 {0, 0xa3, 0xd, F_SA_LOW | F_D_IN, resp_rsup_tmfs, NULL,
c2248fc9 568 {12, 0xd, 0x80, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0,
46f64e70 569 0, 0} }, /* REPORTED SUPPORTED TASK MANAGEMENT FUNCTIONS */
c2248fc9
DG		 570};
571
46f64e70
DG		 572static const struct opcode_info_t write_same_iarr[] = {
573 {0, 0x93, 0, F_D_OUT_MAYBE | FF_MEDIA_IO, resp_write_same_16, NULL,
c2248fc9 574 {16, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
46f64e70 575 0xff, 0xff, 0xff, 0x3f, 0xc7} }, /* WRITE SAME(16) */
c2248fc9
DG		 576};
577
46f64e70
DG		 578static const struct opcode_info_t reserve_iarr[] = {
579 {0, 0x16, 0, F_D_OUT, NULL, NULL, /* RESERVE(6) */
c2248fc9
DG		 580 {6, 0x1f, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
581};
582
46f64e70
DG		 583static const struct opcode_info_t release_iarr[] = {
584 {0, 0x17, 0, F_D_OUT, NULL, NULL, /* RELEASE(6) */
c2248fc9
DG		 585 {6, 0x1f, 0xff, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
586};
587
80c49563 588static const struct opcode_info_t sync_cache_iarr[] = {
4f2c8bf6 589 {0, 0x91, 0, F_SYNC_DELAY | F_M_ACCESS, resp_sync_cache, NULL,
80c49563
DG		 590 {16, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
591 0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} }, /* SYNC_CACHE (16) */
592};
593
ed9f3e25 594static const struct opcode_info_t pre_fetch_iarr[] = {
b6ff8ca7 595 {0, 0x90, 0, F_SYNC_DELAY | FF_MEDIA_IO, resp_pre_fetch, NULL,
ed9f3e25
DG		 596 {16, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
597 0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} }, /* PRE-FETCH (16) */
598};
599
f0d1cf93 600static const struct opcode_info_t zone_out_iarr[] = { /* ZONE OUT(16) */
b6ff8ca7 601 {0, 0x94, 0x1, F_SA_LOW | F_M_ACCESS, resp_close_zone, NULL,
f0d1cf93
DG		 602 {16, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
603 0xff, 0, 0, 0xff, 0xff, 0x1, 0xc7} }, /* CLOSE ZONE */
b6ff8ca7 604 {0, 0x94, 0x2, F_SA_LOW | F_M_ACCESS, resp_finish_zone, NULL,
f0d1cf93
DG		 605 {16, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
606 0xff, 0, 0, 0xff, 0xff, 0x1, 0xc7} }, /* FINISH ZONE */
b6ff8ca7 607 {0, 0x94, 0x4, F_SA_LOW | F_M_ACCESS, resp_rwp_zone, NULL,
f0d1cf93
DG		 608 {16, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
609 0xff, 0, 0, 0xff, 0xff, 0x1, 0xc7} }, /* RESET WRITE POINTER */
610};
611
612static const struct opcode_info_t zone_in_iarr[] = { /* ZONE IN(16) */
b6ff8ca7 613 {0, 0x95, 0x6, F_SA_LOW | F_D_IN | F_M_ACCESS, NULL, NULL,
f0d1cf93
DG		 614 {16, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
615 0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} }, /* REPORT ZONES */
616};
617
c2248fc9
DG		 618
619/* This array is accessed via SDEB_I_* values. Make sure all are mapped,
620 * plus the terminating elements for logic that scans this table such as
621 * REPORT SUPPORTED OPERATION CODES. */
ed9f3e25 622static const struct opcode_info_t opcode_info_arr[SDEB_I_LAST_ELEM_P1 + 1] = {
c2248fc9 623/* 0 */
46f64e70 624 {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* unknown opcodes */
c2248fc9 625 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
46f64e70 626 {0, 0x12, 0, FF_RESPOND | F_D_IN, resp_inquiry, NULL, /* INQUIRY */
c2248fc9
DG		 627 {6, 0xe3, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
628 {0, 0xa0, 0, FF_RESPOND | F_D_IN, resp_report_luns, NULL,
629 {12, 0xe3, 0xff, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0,
46f64e70 630 0, 0} }, /* REPORT LUNS */
c2248fc9
DG		 631 {0, 0x3, 0, FF_RESPOND | F_D_IN, resp_requests, NULL,
632 {6, 0xe1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
633 {0, 0x0, 0, F_M_ACCESS | F_RL_WLUN_OK, NULL, NULL,/* TEST UNIT READY */
634 {6, 0, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
46f64e70
DG		 635/* 5 */
636 {ARRAY_SIZE(msense_iarr), 0x5a, 0, F_D_IN, /* MODE SENSE(10) */
637 resp_mode_sense, msense_iarr, {10, 0xf8, 0xff, 0xff, 0, 0, 0,
638 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
639 {ARRAY_SIZE(mselect_iarr), 0x55, 0, F_D_OUT, /* MODE SELECT(10) */
640 resp_mode_select, mselect_iarr, {10, 0xf1, 0, 0, 0, 0, 0, 0xff,
641 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
642 {0, 0x4d, 0, F_D_IN, resp_log_sense, NULL, /* LOG SENSE */
c2248fc9
DG		 643 {10, 0xe3, 0xff, 0xff, 0, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0,
644 0, 0, 0} },
46f64e70 645 {0, 0x25, 0, F_D_IN, resp_readcap, NULL, /* READ CAPACITY(10) */
c2248fc9
DG		 646 {10, 0xe1, 0xff, 0xff, 0xff, 0xff, 0, 0, 0x1, 0xc7, 0, 0, 0, 0,
647 0, 0} },
46f64e70
DG		 648 {ARRAY_SIZE(read_iarr), 0x88, 0, F_D_IN | FF_MEDIA_IO, /* READ(16) */
649 resp_read_dt0, read_iarr, {16, 0xfe, 0xff, 0xff, 0xff, 0xff,
650 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7} },
c2248fc9 651/* 10 */
46f64e70
DG		 652 {ARRAY_SIZE(write_iarr), 0x8a, 0, F_D_OUT | FF_MEDIA_IO,
653 resp_write_dt0, write_iarr, /* WRITE(16) */
654 {16, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
80c49563 655 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7} },
4f2c8bf6 656 {0, 0x1b, 0, F_SSU_DELAY, resp_start_stop, NULL,/* START STOP UNIT */
c2248fc9 657 {6, 0x1, 0, 0xf, 0xf7, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
46f64e70
DG		 658 {ARRAY_SIZE(sa_in_16_iarr), 0x9e, 0x10, F_SA_LOW | F_D_IN,
659 resp_readcap16, sa_in_16_iarr, /* SA_IN(16), READ CAPACITY(16) */
660 {16, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
661 0xff, 0xff, 0xff, 0xff, 0x1, 0xc7} },
481b5e5c
DG		 662 {0, 0x9f, 0x12, F_SA_LOW | F_D_OUT | FF_MEDIA_IO, resp_write_scat,
663 NULL, {16, 0x12, 0xf9, 0x0, 0xff, 0xff, 0, 0, 0xff, 0xff, 0xff,
664 0xff, 0xff, 0xff, 0xff, 0xc7} }, /* SA_OUT(16), WRITE SCAT(16) */
46f64e70
DG		 665 {ARRAY_SIZE(maint_in_iarr), 0xa3, 0xa, F_SA_LOW | F_D_IN,
666 resp_report_tgtpgs, /* MAINT IN, REPORT TARGET PORT GROUPS */
667 maint_in_iarr, {12, 0xea, 0, 0, 0, 0, 0xff, 0xff, 0xff,
668 0xff, 0, 0xc7, 0, 0, 0, 0} },
669/* 15 */
c2248fc9
DG		 670 {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* MAINT OUT */
671 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
c3e2fe92
DG		 672 {ARRAY_SIZE(verify_iarr), 0x8f, 0,
673 F_D_OUT_MAYBE | FF_MEDIA_IO, resp_verify, /* VERIFY(16) */
674 verify_iarr, {16, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
675 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} },
46f64e70
DG		 676 {ARRAY_SIZE(vl_iarr), 0x7f, 0x9, F_SA_HIGH | F_D_IN | FF_MEDIA_IO,
677 resp_read_dt0, vl_iarr, /* VARIABLE LENGTH, READ(32) */
678 {32, 0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0x9, 0xfe, 0, 0xff, 0xff,
679 0xff, 0xff} },
680 {ARRAY_SIZE(reserve_iarr), 0x56, 0, F_D_OUT,
681 NULL, reserve_iarr, /* RESERVE(10) <no response function> */
c2248fc9
DG		 682 {10, 0xff, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
683 0} },
46f64e70
DG		 684 {ARRAY_SIZE(release_iarr), 0x57, 0, F_D_OUT,
685 NULL, release_iarr, /* RELEASE(10) <no response function> */
c2248fc9
DG		 686 {10, 0x13, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
687 0} },
688/* 20 */
f7f9f26b
DG		 689 {0, 0x1e, 0, 0, NULL, NULL, /* ALLOW REMOVAL */
690 {6, 0, 0, 0, 0x3, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
c2248fc9
DG		 691 {0, 0x1, 0, 0, resp_start_stop, NULL, /* REWIND ?? */
692 {6, 0x1, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
693 {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* ATA_PT */
694 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
695 {0, 0x1d, F_D_OUT, 0, NULL, NULL, /* SEND DIAGNOSTIC */
696 {6, 0xf7, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
46f64e70 697 {0, 0x42, 0, F_D_OUT | FF_MEDIA_IO, resp_unmap, NULL, /* UNMAP */
b7e24581 698 {10, 0x1, 0, 0, 0, 0, 0x3f, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
46f64e70 699/* 25 */
acafd0b9
EM		 700 {0, 0x3b, 0, F_D_OUT_MAYBE, resp_write_buffer, NULL,
701 {10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0,
702 0, 0, 0, 0} }, /* WRITE_BUFFER */
46f64e70
DG		 703 {ARRAY_SIZE(write_same_iarr), 0x41, 0, F_D_OUT_MAYBE | FF_MEDIA_IO,
704 resp_write_same_10, write_same_iarr, /* WRITE SAME(10) */
705 {10, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0,
706 0, 0, 0, 0, 0} },
4f2c8bf6 707 {ARRAY_SIZE(sync_cache_iarr), 0x35, 0, F_SYNC_DELAY | F_M_ACCESS,
80c49563 708 resp_sync_cache, sync_cache_iarr,
b7e24581 709 {10, 0x7, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
80c49563 710 0, 0, 0, 0} }, /* SYNC_CACHE (10) */
46f64e70 711 {0, 0x89, 0, F_D_OUT | FF_MEDIA_IO, resp_comp_write, NULL,
c2248fc9 712 {16, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0,
b7e24581 713 0, 0xff, 0x3f, 0xc7} }, /* COMPARE AND WRITE */
b6ff8ca7 714 {ARRAY_SIZE(pre_fetch_iarr), 0x34, 0, F_SYNC_DELAY | FF_MEDIA_IO,
ed9f3e25
DG		 715 resp_pre_fetch, pre_fetch_iarr,
716 {10, 0x2, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
717 0, 0, 0, 0} }, /* PRE-FETCH (10) */
c2248fc9 718
ed9f3e25 719/* 30 */
b6ff8ca7 720 {ARRAY_SIZE(zone_out_iarr), 0x94, 0x3, F_SA_LOW | F_M_ACCESS,
f0d1cf93
DG		 721 resp_open_zone, zone_out_iarr, /* ZONE_OUT(16), OPEN ZONE) */
722 {16, 0x3 /* SA */, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
723 0xff, 0xff, 0x0, 0x0, 0xff, 0xff, 0x1, 0xc7} },
b6ff8ca7 724 {ARRAY_SIZE(zone_in_iarr), 0x95, 0x0, F_SA_LOW | F_M_ACCESS,
f0d1cf93
DG		 725 resp_report_zones, zone_in_iarr, /* ZONE_IN(16), REPORT ZONES) */
726 {16, 0x0 /* SA */, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
727 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xc7} },
728/* sentinel */
c2248fc9
DG		 729 {0xff, 0, 0, 0, NULL, NULL, /* terminating element */
730 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
731};
732
87c715dc
DG		 733static int sdebug_num_hosts;
734static int sdebug_add_host = DEF_NUM_HOST; /* in sysfs this is relative */
773642d9 735static int sdebug_ato = DEF_ATO;
9b760fd8 736static int sdebug_cdb_len = DEF_CDB_LEN;
c2206098 737static int sdebug_jdelay = DEF_JDELAY; /* if > 0 then unit is jiffies */
9267e0eb 738static int sdebug_dev_size_mb = DEF_DEV_SIZE_PRE_INIT;
773642d9
DG		 739static int sdebug_dif = DEF_DIF;
740static int sdebug_dix = DEF_DIX;
741static int sdebug_dsense = DEF_D_SENSE;
742static int sdebug_every_nth = DEF_EVERY_NTH;
743static int sdebug_fake_rw = DEF_FAKE_RW;
744static unsigned int sdebug_guard = DEF_GUARD;
c10fa55f 745static int sdebug_host_max_queue; /* per host */
773642d9
DG		 746static int sdebug_lowest_aligned = DEF_LOWEST_ALIGNED;
747static int sdebug_max_luns = DEF_MAX_LUNS;
c4837394 748static int sdebug_max_queue = SDEBUG_CANQUEUE; /* per submit queue */
d9da891a
LO		 749static unsigned int sdebug_medium_error_start = OPT_MEDIUM_ERR_ADDR;
750static int sdebug_medium_error_count = OPT_MEDIUM_ERR_NUM;
cbf67842 751static atomic_t retired_max_queue; /* if > 0 then was prior max_queue */
c2206098 752static int sdebug_ndelay = DEF_NDELAY; /* if > 0 then unit is nanoseconds */
773642d9
DG		 753static int sdebug_no_lun_0 = DEF_NO_LUN_0;
754static int sdebug_no_uld;
755static int sdebug_num_parts = DEF_NUM_PARTS;
756static int sdebug_num_tgts = DEF_NUM_TGTS; /* targets per host */
757static int sdebug_opt_blks = DEF_OPT_BLKS;
758static int sdebug_opts = DEF_OPTS;
759static int sdebug_physblk_exp = DEF_PHYSBLK_EXP;
86e6828a 760static int sdebug_opt_xferlen_exp = DEF_OPT_XFERLEN_EXP;
b01f6f83 761static int sdebug_ptype = DEF_PTYPE; /* SCSI peripheral device type */
773642d9
DG		 762static int sdebug_scsi_level = DEF_SCSI_LEVEL;
763static int sdebug_sector_size = DEF_SECTOR_SIZE;
fc13638a 764static int sdeb_tur_ms_to_ready = DEF_TUR_MS_TO_READY;
773642d9
DG		 765static int sdebug_virtual_gb = DEF_VIRTUAL_GB;
766static int sdebug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
767static unsigned int sdebug_lbpu = DEF_LBPU;
768static unsigned int sdebug_lbpws = DEF_LBPWS;
769static unsigned int sdebug_lbpws10 = DEF_LBPWS10;
770static unsigned int sdebug_lbprz = DEF_LBPRZ;
771static unsigned int sdebug_unmap_alignment = DEF_UNMAP_ALIGNMENT;
772static unsigned int sdebug_unmap_granularity = DEF_UNMAP_GRANULARITY;
773static unsigned int sdebug_unmap_max_blocks = DEF_UNMAP_MAX_BLOCKS;
774static unsigned int sdebug_unmap_max_desc = DEF_UNMAP_MAX_DESC;
775static unsigned int sdebug_write_same_length = DEF_WRITESAME_LENGTH;
09ba24c1 776static int sdebug_uuid_ctl = DEF_UUID_CTL;
0c4bc91d 777static bool sdebug_random = DEF_RANDOM;
87c715dc 778static bool sdebug_per_host_store = DEF_PER_HOST_STORE;
773642d9
DG		 779static bool sdebug_removable = DEF_REMOVABLE;
780static bool sdebug_clustering;
781static bool sdebug_host_lock = DEF_HOST_LOCK;
782static bool sdebug_strict = DEF_STRICT;
817fd66b 783static bool sdebug_any_injecting_opt;
773642d9 784static bool sdebug_verbose;
f46eb0e9 785static bool have_dif_prot;
4f2c8bf6 786static bool write_since_sync;
c4837394 787static bool sdebug_statistics = DEF_STATISTICS;
9447b6ce 788static bool sdebug_wp;
9267e0eb
DG		 789/* Following enum: 0: no zbc, def; 1: host aware; 2: host managed */
790static enum blk_zoned_model sdeb_zbc_model = BLK_ZONED_NONE;
791static char *sdeb_zbc_model_s;
1da177e4 792
ad0c7775
DG		 793enum sam_lun_addr_method {SAM_LUN_AM_PERIPHERAL = 0x0,
794 SAM_LUN_AM_FLAT = 0x1,
795 SAM_LUN_AM_LOGICAL_UNIT = 0x2,
796 SAM_LUN_AM_EXTENDED = 0x3};
797static enum sam_lun_addr_method sdebug_lun_am = SAM_LUN_AM_PERIPHERAL;
798static int sdebug_lun_am_i = (int)SAM_LUN_AM_PERIPHERAL;
799
c65b1445 800static unsigned int sdebug_store_sectors;
1da177e4
LT		 801static sector_t sdebug_capacity; /* in sectors */
802
803/* old BIOS stuff, kernel may get rid of them but some mode sense pages
804 may still need them */
805static int sdebug_heads; /* heads per disk */
806static int sdebug_cylinders_per; /* cylinders per surface */
807static int sdebug_sectors_per; /* sectors per cylinder */
808
1da177e4
LT		 809static LIST_HEAD(sdebug_host_list);
810static DEFINE_SPINLOCK(sdebug_host_list_lock);
811
87c715dc
DG		 812static struct xarray per_store_arr;
813static struct xarray *per_store_ap = &per_store_arr;
814static int sdeb_first_idx = -1; /* invalid index ==> none created */
815static int sdeb_most_recent_idx = -1;
816static DEFINE_RWLOCK(sdeb_fake_rw_lck); /* need a RW lock when fake_rw=1 */
1da177e4 817
44d92694 818static unsigned long map_size;
cbf67842
DG		 819static int num_aborts;
820static int num_dev_resets;
821static int num_target_resets;
822static int num_bus_resets;
823static int num_host_resets;
c6a44287
MP		 824static int dix_writes;
825static int dix_reads;
826static int dif_errors;
1da177e4 827
f0d1cf93 828/* ZBC global data */
64e14ece 829static bool sdeb_zbc_in_use; /* true for host-aware and host-managed disks */
98e0a689 830static int sdeb_zbc_zone_size_mb;
380603a5 831static int sdeb_zbc_max_open = DEF_ZBC_MAX_OPEN_ZONES;
aa8fecf9 832static int sdeb_zbc_nr_conv = DEF_ZBC_NR_CONV_ZONES;
f0d1cf93 833
c4837394 834static int submit_queues = DEF_SUBMIT_QUEUES; /* > 1 for multi-queue (mq) */
c4b57d89 835static int poll_queues; /* iouring iopoll interface.*/
c4837394 836static struct sdebug_queue *sdebug_q_arr; /* ptr to array of submit queues */
fd32119b 837
1da177e4 838static DEFINE_RWLOCK(atomic_rw);
87c715dc
DG		 839static DEFINE_RWLOCK(atomic_rw2);
840
841static rwlock_t *ramdisk_lck_a[2];
1da177e4 842
cbf67842
DG		 843static char sdebug_proc_name[] = MY_NAME;
844static const char *my_name = MY_NAME;
1da177e4 845
1da177e4
LT		 846static struct bus_type pseudo_lld_bus;
847
848static struct device_driver sdebug_driverfs_driver = {
849 .name = sdebug_proc_name,
850 .bus = &pseudo_lld_bus,
1da177e4
LT		 851};
852
853static const int check_condition_result =
854 (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
855
c6a44287
MP		 856static const int illegal_condition_result =
857 (DRIVER_SENSE << 24) | (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION;
858
cbf67842 859static const int device_qfull_result =
7a64c814 860 (DID_OK << 16) | SAM_STAT_TASK_SET_FULL;
cbf67842 861
ed9f3e25
DG		 862static const int condition_met_result = SAM_STAT_CONDITION_MET;
863
fd32119b 864
760f3b03
DG		 865/* Only do the extra work involved in logical block provisioning if one or
866 * more of the lbpu, lbpws or lbpws10 parameters are given and we are doing
867 * real reads and writes (i.e. not skipping them for speed).
868 */
869static inline bool scsi_debug_lbp(void)
fd32119b
DG		 870{
871 return 0 == sdebug_fake_rw &&
872 (sdebug_lbpu || sdebug_lbpws || sdebug_lbpws10);
873}
c65b1445 874
87c715dc
DG		 875static void *lba2fake_store(struct sdeb_store_info *sip,
876 unsigned long long lba)
14faa944 877{
87c715dc 878 struct sdeb_store_info *lsip = sip;
14faa944 879
87c715dc
DG		 880 lba = do_div(lba, sdebug_store_sectors);
881 if (!sip || !sip->storep) {
882 WARN_ON_ONCE(true);
883 lsip = xa_load(per_store_ap, 0); /* should never be NULL */
884 }
885 return lsip->storep + lba * sdebug_sector_size;
14faa944
AM		 886}
887
87c715dc
DG		 888static struct t10_pi_tuple *dif_store(struct sdeb_store_info *sip,
889 sector_t sector)
14faa944 890{
49413112 891 sector = sector_div(sector, sdebug_store_sectors);
14faa944 892
87c715dc 893 return sip->dif_storep + sector;
14faa944
AM		 894}
895
8dea0d02
FT		 896static void sdebug_max_tgts_luns(void)
897{
898 struct sdebug_host_info *sdbg_host;
899 struct Scsi_Host *hpnt;
900
901 spin_lock(&sdebug_host_list_lock);
902 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
903 hpnt = sdbg_host->shost;
904 if ((hpnt->this_id >= 0) &&
773642d9
DG		 905 (sdebug_num_tgts > hpnt->this_id))
906 hpnt->max_id = sdebug_num_tgts + 1;
8dea0d02 907 else
773642d9
DG		 908 hpnt->max_id = sdebug_num_tgts;
909 /* sdebug_max_luns; */
f2d3fd29 910 hpnt->max_lun = SCSI_W_LUN_REPORT_LUNS + 1;
8dea0d02
FT		 911 }
912 spin_unlock(&sdebug_host_list_lock);
913}
914
22017ed2
DG		 915enum sdeb_cmd_data {SDEB_IN_DATA = 0, SDEB_IN_CDB = 1};
916
917/* Set in_bit to -1 to indicate no bit position of invalid field */
fd32119b
DG		 918static void mk_sense_invalid_fld(struct scsi_cmnd *scp,
919 enum sdeb_cmd_data c_d,
920 int in_byte, int in_bit)
22017ed2
DG		 921{
922 unsigned char *sbuff;
923 u8 sks[4];
924 int sl, asc;
925
926 sbuff = scp->sense_buffer;
927 if (!sbuff) {
928 sdev_printk(KERN_ERR, scp->device,
929 "%s: sense_buffer is NULL\n", __func__);
930 return;
931 }
932 asc = c_d ? INVALID_FIELD_IN_CDB : INVALID_FIELD_IN_PARAM_LIST;
933 memset(sbuff, 0, SCSI_SENSE_BUFFERSIZE);
773642d9 934 scsi_build_sense_buffer(sdebug_dsense, sbuff, ILLEGAL_REQUEST, asc, 0);
22017ed2
DG		 935 memset(sks, 0, sizeof(sks));
936 sks[0] = 0x80;
937 if (c_d)
938 sks[0] |= 0x40;
939 if (in_bit >= 0) {
940 sks[0] |= 0x8;
941 sks[0] |= 0x7 & in_bit;
942 }
943 put_unaligned_be16(in_byte, sks + 1);
773642d9 944 if (sdebug_dsense) {
22017ed2
DG		 945 sl = sbuff[7] + 8;
946 sbuff[7] = sl;
947 sbuff[sl] = 0x2;
948 sbuff[sl + 1] = 0x6;
949 memcpy(sbuff + sl + 4, sks, 3);
950 } else
951 memcpy(sbuff + 15, sks, 3);
773642d9 952 if (sdebug_verbose)
22017ed2
DG		 953 sdev_printk(KERN_INFO, scp->device, "%s: [sense_key,asc,ascq"
954 "]: [0x5,0x%x,0x0] %c byte=%d, bit=%d\n",
955 my_name, asc, c_d ? 'C' : 'D', in_byte, in_bit);
956}
957
cbf67842 958static void mk_sense_buffer(struct scsi_cmnd *scp, int key, int asc, int asq)
8dea0d02
FT		 959{
960 unsigned char *sbuff;
961
cbf67842
DG		 962 sbuff = scp->sense_buffer;
963 if (!sbuff) {
964 sdev_printk(KERN_ERR, scp->device,
965 "%s: sense_buffer is NULL\n", __func__);
966 return;
967 }
968 memset(sbuff, 0, SCSI_SENSE_BUFFERSIZE);
8dea0d02 969
773642d9 970 scsi_build_sense_buffer(sdebug_dsense, sbuff, key, asc, asq);
8dea0d02 971
773642d9 972 if (sdebug_verbose)
cbf67842
DG		 973 sdev_printk(KERN_INFO, scp->device,
974 "%s: [sense_key,asc,ascq]: [0x%x,0x%x,0x%x]\n",
975 my_name, key, asc, asq);
8dea0d02 976}
1da177e4 977
fd32119b 978static void mk_sense_invalid_opcode(struct scsi_cmnd *scp)
22017ed2
DG		 979{
980 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
981}
982
6f4e626f
NC		 983static int scsi_debug_ioctl(struct scsi_device *dev, unsigned int cmd,
984 void __user *arg)
1da177e4 985{
773642d9 986 if (sdebug_verbose) {
cbf67842
DG		 987 if (0x1261 == cmd)
988 sdev_printk(KERN_INFO, dev,
989 "%s: BLKFLSBUF [0x1261]\n", __func__);
990 else if (0x5331 == cmd)
991 sdev_printk(KERN_INFO, dev,
992 "%s: CDROM_GET_CAPABILITY [0x5331]\n",
993 __func__);
994 else
995 sdev_printk(KERN_INFO, dev, "%s: cmd=0x%x\n",
996 __func__, cmd);
1da177e4
LT		 997 }
998 return -EINVAL;
999 /* return -ENOTTY; // correct return but upsets fdisk */
1000}
1001
9b760fd8
DG		 1002static void config_cdb_len(struct scsi_device *sdev)
1003{
1004 switch (sdebug_cdb_len) {
1005 case 6: /* suggest 6 byte READ, WRITE and MODE SENSE/SELECT */
1006 sdev->use_10_for_rw = false;
1007 sdev->use_16_for_rw = false;
1008 sdev->use_10_for_ms = false;
1009 break;
1010 case 10: /* suggest 10 byte RWs and 6 byte MODE SENSE/SELECT */
1011 sdev->use_10_for_rw = true;
1012 sdev->use_16_for_rw = false;
1013 sdev->use_10_for_ms = false;
1014 break;
1015 case 12: /* suggest 10 byte RWs and 10 byte MODE SENSE/SELECT */
1016 sdev->use_10_for_rw = true;
1017 sdev->use_16_for_rw = false;
1018 sdev->use_10_for_ms = true;
1019 break;
1020 case 16:
1021 sdev->use_10_for_rw = false;
1022 sdev->use_16_for_rw = true;
1023 sdev->use_10_for_ms = true;
1024 break;
1025 case 32: /* No knobs to suggest this so same as 16 for now */
1026 sdev->use_10_for_rw = false;
1027 sdev->use_16_for_rw = true;
1028 sdev->use_10_for_ms = true;
1029 break;
1030 default:
1031 pr_warn("unexpected cdb_len=%d, force to 10\n",
1032 sdebug_cdb_len);
1033 sdev->use_10_for_rw = true;
1034 sdev->use_16_for_rw = false;
1035 sdev->use_10_for_ms = false;
1036 sdebug_cdb_len = 10;
1037 break;
1038 }
1039}
1040
1041static void all_config_cdb_len(void)
1042{
1043 struct sdebug_host_info *sdbg_host;
1044 struct Scsi_Host *shost;
1045 struct scsi_device *sdev;
1046
1047 spin_lock(&sdebug_host_list_lock);
1048 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
1049 shost = sdbg_host->shost;
1050 shost_for_each_device(sdev, shost) {
1051 config_cdb_len(sdev);
1052 }
1053 }
1054 spin_unlock(&sdebug_host_list_lock);
1055}
1056
19c8ead7
EM		 1057static void clear_luns_changed_on_target(struct sdebug_dev_info *devip)
1058{
1059 struct sdebug_host_info *sdhp;
1060 struct sdebug_dev_info *dp;
1061
1062 spin_lock(&sdebug_host_list_lock);
1063 list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
1064 list_for_each_entry(dp, &sdhp->dev_info_list, dev_list) {
1065 if ((devip->sdbg_host == dp->sdbg_host) &&
1066 (devip->target == dp->target))
1067 clear_bit(SDEBUG_UA_LUNS_CHANGED, dp->uas_bm);
1068 }
1069 }
1070 spin_unlock(&sdebug_host_list_lock);
1071}
1072
f46eb0e9 1073static int make_ua(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
1da177e4 1074{
cbf67842 1075 int k;
cbf67842
DG		 1076
1077 k = find_first_bit(devip->uas_bm, SDEBUG_NUM_UAS);
1078 if (k != SDEBUG_NUM_UAS) {
1079 const char *cp = NULL;
1080
1081 switch (k) {
1082 case SDEBUG_UA_POR:
f46eb0e9
DG		 1083 mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
1084 POWER_ON_RESET_ASCQ);
773642d9 1085 if (sdebug_verbose)
cbf67842
DG		 1086 cp = "power on reset";
1087 break;
1088 case SDEBUG_UA_BUS_RESET:
f46eb0e9
DG		 1089 mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
1090 BUS_RESET_ASCQ);
773642d9 1091 if (sdebug_verbose)
cbf67842
DG		 1092 cp = "bus reset";
1093 break;
1094 case SDEBUG_UA_MODE_CHANGED:
f46eb0e9
DG		 1095 mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
1096 MODE_CHANGED_ASCQ);
773642d9 1097 if (sdebug_verbose)
cbf67842
DG		 1098 cp = "mode parameters changed";
1099 break;
0d01c5df 1100 case SDEBUG_UA_CAPACITY_CHANGED:
f46eb0e9
DG		 1101 mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
1102 CAPACITY_CHANGED_ASCQ);
773642d9 1103 if (sdebug_verbose)
0d01c5df 1104 cp = "capacity data changed";
f49accf1 1105 break;
acafd0b9 1106 case SDEBUG_UA_MICROCODE_CHANGED:
f46eb0e9 1107 mk_sense_buffer(scp, UNIT_ATTENTION,
b01f6f83
DG		 1108 TARGET_CHANGED_ASC,
1109 MICROCODE_CHANGED_ASCQ);
773642d9 1110 if (sdebug_verbose)
acafd0b9
EM		 1111 cp = "microcode has been changed";
1112 break;
1113 case SDEBUG_UA_MICROCODE_CHANGED_WO_RESET:
f46eb0e9 1114 mk_sense_buffer(scp, UNIT_ATTENTION,
acafd0b9
EM		 1115 TARGET_CHANGED_ASC,
1116 MICROCODE_CHANGED_WO_RESET_ASCQ);
773642d9 1117 if (sdebug_verbose)
acafd0b9
EM		 1118 cp = "microcode has been changed without reset";
1119 break;
19c8ead7
EM		 1120 case SDEBUG_UA_LUNS_CHANGED:
1121 /*
1122 * SPC-3 behavior is to report a UNIT ATTENTION with
1123 * ASC/ASCQ REPORTED LUNS DATA HAS CHANGED on every LUN
1124 * on the target, until a REPORT LUNS command is
1125 * received. SPC-4 behavior is to report it only once.
773642d9 1126 * NOTE: sdebug_scsi_level does not use the same
19c8ead7
EM		 1127 * values as struct scsi_device->scsi_level.
1128 */
773642d9 1129 if (sdebug_scsi_level >= 6) /* SPC-4 and above */
19c8ead7 1130 clear_luns_changed_on_target(devip);
f46eb0e9 1131 mk_sense_buffer(scp, UNIT_ATTENTION,
19c8ead7
EM		 1132 TARGET_CHANGED_ASC,
1133 LUNS_CHANGED_ASCQ);
773642d9 1134 if (sdebug_verbose)
19c8ead7
EM		 1135 cp = "reported luns data has changed";
1136 break;
cbf67842 1137 default:
773642d9
DG		 1138 pr_warn("unexpected unit attention code=%d\n", k);
1139 if (sdebug_verbose)
cbf67842
DG		 1140 cp = "unknown";
1141 break;
1142 }
1143 clear_bit(k, devip->uas_bm);
773642d9 1144 if (sdebug_verbose)
f46eb0e9 1145 sdev_printk(KERN_INFO, scp->device,
cbf67842
DG		 1146 "%s reports: Unit attention: %s\n",
1147 my_name, cp);
1da177e4
LT		 1148 return check_condition_result;
1149 }
1150 return 0;
1151}
1152
fb0cc8d1 1153/* Build SCSI "data-in" buffer. Returns 0 if ok else (DID_ERROR << 16). */
21a61829 1154static int fill_from_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
1da177e4
LT		 1155 int arr_len)
1156{
21a61829 1157 int act_len;
ae3d56d8 1158 struct scsi_data_buffer *sdb = &scp->sdb;
1da177e4 1159
072d0bb3 1160 if (!sdb->length)
1da177e4 1161 return 0;
ae3d56d8 1162 if (scp->sc_data_direction != DMA_FROM_DEVICE)
773642d9 1163 return DID_ERROR << 16;
21a61829
FT		 1164
1165 act_len = sg_copy_from_buffer(sdb->table.sgl, sdb->table.nents,
1166 arr, arr_len);
42d387be 1167 scsi_set_resid(scp, scsi_bufflen(scp) - act_len);
21a61829 1168
1da177e4
LT		 1169 return 0;
1170}
1171
fb0cc8d1
DG		 1172/* Partial build of SCSI "data-in" buffer. Returns 0 if ok else
1173 * (DID_ERROR << 16). Can write to offset in data-in buffer. If multiple
1174 * calls, not required to write in ascending offset order. Assumes resid
1175 * set to scsi_bufflen() prior to any calls.
1176 */
1177static int p_fill_from_dev_buffer(struct scsi_cmnd *scp, const void *arr,
1178 int arr_len, unsigned int off_dst)
1179{
9237f04e 1180 unsigned int act_len, n;
ae3d56d8 1181 struct scsi_data_buffer *sdb = &scp->sdb;
fb0cc8d1
DG		 1182 off_t skip = off_dst;
1183
1184 if (sdb->length <= off_dst)
1185 return 0;
ae3d56d8 1186 if (scp->sc_data_direction != DMA_FROM_DEVICE)
fb0cc8d1
DG		 1187 return DID_ERROR << 16;
1188
1189 act_len = sg_pcopy_from_buffer(sdb->table.sgl, sdb->table.nents,
1190 arr, arr_len, skip);
1191 pr_debug("%s: off_dst=%u, scsi_bufflen=%u, act_len=%u, resid=%d\n",
42d387be
BVA		 1192 __func__, off_dst, scsi_bufflen(scp), act_len,
1193 scsi_get_resid(scp));
9237f04e 1194 n = scsi_bufflen(scp) - (off_dst + act_len);
87c715dc 1195 scsi_set_resid(scp, min_t(int, scsi_get_resid(scp), n));
fb0cc8d1
DG		 1196 return 0;
1197}
1198
1199/* Fetches from SCSI "data-out" buffer. Returns number of bytes fetched into
1200 * 'arr' or -1 if error.
1201 */
21a61829
FT		 1202static int fetch_to_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
1203 int arr_len)
1da177e4 1204{
21a61829 1205 if (!scsi_bufflen(scp))
1da177e4 1206 return 0;
ae3d56d8 1207 if (scp->sc_data_direction != DMA_TO_DEVICE)
1da177e4 1208 return -1;
21a61829
FT		 1209
1210 return scsi_sg_copy_to_buffer(scp, arr, arr_len);
1da177e4
LT		 1211}
1212
1213
e5203cf0
HR		 1214static char sdebug_inq_vendor_id[9] = "Linux ";
1215static char sdebug_inq_product_id[17] = "scsi_debug ";
9b760fd8 1216static char sdebug_inq_product_rev[5] = SDEBUG_VERSION;
1b37bd60
DG		 1217/* Use some locally assigned NAAs for SAS addresses. */
1218static const u64 naa3_comp_a = 0x3222222000000000ULL;
1219static const u64 naa3_comp_b = 0x3333333000000000ULL;
1220static const u64 naa3_comp_c = 0x3111111000000000ULL;
1da177e4 1221
cbf67842 1222/* Device identification VPD page. Returns number of bytes placed in arr */
760f3b03
DG		 1223static int inquiry_vpd_83(unsigned char *arr, int port_group_id,
1224 int target_dev_id, int dev_id_num,
09ba24c1 1225 const char *dev_id_str, int dev_id_str_len,
bf476433 1226 const uuid_t *lu_name)
1da177e4 1227{
c65b1445
DG		 1228 int num, port_a;
1229 char b[32];
1da177e4 1230
c65b1445 1231 port_a = target_dev_id + 1;
1da177e4
LT		 1232 /* T10 vendor identifier field format (faked) */
1233 arr[0] = 0x2; /* ASCII */
1234 arr[1] = 0x1;
1235 arr[2] = 0x0;
e5203cf0
HR		 1236 memcpy(&arr[4], sdebug_inq_vendor_id, 8);
1237 memcpy(&arr[12], sdebug_inq_product_id, 16);
1da177e4
LT		 1238 memcpy(&arr[28], dev_id_str, dev_id_str_len);
1239 num = 8 + 16 + dev_id_str_len;
1240 arr[3] = num;
1241 num += 4;
c65b1445 1242 if (dev_id_num >= 0) {
09ba24c1
DG		 1243 if (sdebug_uuid_ctl) {
1244 /* Locally assigned UUID */
1245 arr[num++] = 0x1; /* binary (not necessarily sas) */
1246 arr[num++] = 0xa; /* PIV=0, lu, naa */
1247 arr[num++] = 0x0;
1248 arr[num++] = 0x12;
1249 arr[num++] = 0x10; /* uuid type=1, locally assigned */
1250 arr[num++] = 0x0;
1251 memcpy(arr + num, lu_name, 16);
1252 num += 16;
1253 } else {
1b37bd60 1254 /* NAA-3, Logical unit identifier (binary) */
09ba24c1
DG		 1255 arr[num++] = 0x1; /* binary (not necessarily sas) */
1256 arr[num++] = 0x3; /* PIV=0, lu, naa */
1257 arr[num++] = 0x0;
1258 arr[num++] = 0x8;
1b37bd60 1259 put_unaligned_be64(naa3_comp_b + dev_id_num, arr + num);
09ba24c1
DG		 1260 num += 8;
1261 }
c65b1445
DG		 1262 /* Target relative port number */
1263 arr[num++] = 0x61; /* proto=sas, binary */
1264 arr[num++] = 0x94; /* PIV=1, target port, rel port */
1265 arr[num++] = 0x0; /* reserved */
1266 arr[num++] = 0x4; /* length */
1267 arr[num++] = 0x0; /* reserved */
1268 arr[num++] = 0x0; /* reserved */
1269 arr[num++] = 0x0;
1270 arr[num++] = 0x1; /* relative port A */
1271 }
1b37bd60 1272 /* NAA-3, Target port identifier */
c65b1445
DG		 1273 arr[num++] = 0x61; /* proto=sas, binary */
1274 arr[num++] = 0x93; /* piv=1, target port, naa */
1275 arr[num++] = 0x0;
1276 arr[num++] = 0x8;
1b37bd60 1277 put_unaligned_be64(naa3_comp_a + port_a, arr + num);
773642d9 1278 num += 8;
1b37bd60 1279 /* NAA-3, Target port group identifier */
5a09e398
HR		 1280 arr[num++] = 0x61; /* proto=sas, binary */
1281 arr[num++] = 0x95; /* piv=1, target port group id */
1282 arr[num++] = 0x0;
1283 arr[num++] = 0x4;
1284 arr[num++] = 0;
1285 arr[num++] = 0;
773642d9
DG		 1286 put_unaligned_be16(port_group_id, arr + num);
1287 num += 2;
1b37bd60 1288 /* NAA-3, Target device identifier */
c65b1445
DG		 1289 arr[num++] = 0x61; /* proto=sas, binary */
1290 arr[num++] = 0xa3; /* piv=1, target device, naa */
1291 arr[num++] = 0x0;
1292 arr[num++] = 0x8;
1b37bd60 1293 put_unaligned_be64(naa3_comp_a + target_dev_id, arr + num);
773642d9 1294 num += 8;
c65b1445
DG		 1295 /* SCSI name string: Target device identifier */
1296 arr[num++] = 0x63; /* proto=sas, UTF-8 */
1297 arr[num++] = 0xa8; /* piv=1, target device, SCSI name string */
1298 arr[num++] = 0x0;
1299 arr[num++] = 24;
1b37bd60 1300 memcpy(arr + num, "naa.32222220", 12);
c65b1445
DG		 1301 num += 12;
1302 snprintf(b, sizeof(b), "%08X", target_dev_id);
1303 memcpy(arr + num, b, 8);
1304 num += 8;
1305 memset(arr + num, 0, 4);
1306 num += 4;
1307 return num;
1308}
1309
c65b1445
DG		 1310static unsigned char vpd84_data[] = {
1311/* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
1312 0x22,0x22,0x22,0x0,0xbb,0x1,
1313 0x22,0x22,0x22,0x0,0xbb,0x2,
1314};
1315
cbf67842 1316/* Software interface identification VPD page */
760f3b03 1317static int inquiry_vpd_84(unsigned char *arr)
c65b1445
DG		 1318{
1319 memcpy(arr, vpd84_data, sizeof(vpd84_data));
1320 return sizeof(vpd84_data);
1321}
1322
cbf67842 1323/* Management network addresses VPD page */
760f3b03 1324static int inquiry_vpd_85(unsigned char *arr)
c65b1445
DG		 1325{
1326 int num = 0;
91d4c752
JP		 1327 const char *na1 = "https://www.kernel.org/config";
1328 const char *na2 = "http://www.kernel.org/log";
c65b1445
DG		 1329 int plen, olen;
1330
1331 arr[num++] = 0x1; /* lu, storage config */
1332 arr[num++] = 0x0; /* reserved */
1333 arr[num++] = 0x0;
1334 olen = strlen(na1);
1335 plen = olen + 1;
1336 if (plen % 4)
1337 plen = ((plen / 4) + 1) * 4;
1338 arr[num++] = plen; /* length, null termianted, padded */
1339 memcpy(arr + num, na1, olen);
1340 memset(arr + num + olen, 0, plen - olen);
1341 num += plen;
1342
1343 arr[num++] = 0x4; /* lu, logging */
1344 arr[num++] = 0x0; /* reserved */
1345 arr[num++] = 0x0;
1346 olen = strlen(na2);
1347 plen = olen + 1;
1348 if (plen % 4)
1349 plen = ((plen / 4) + 1) * 4;
1350 arr[num++] = plen; /* length, null terminated, padded */
1351 memcpy(arr + num, na2, olen);
1352 memset(arr + num + olen, 0, plen - olen);
1353 num += plen;
1354
1355 return num;
1356}
1357
1358/* SCSI ports VPD page */
760f3b03 1359static int inquiry_vpd_88(unsigned char *arr, int target_dev_id)
c65b1445
DG		 1360{
1361 int num = 0;
1362 int port_a, port_b;
1363
1364 port_a = target_dev_id + 1;
1365 port_b = port_a + 1;
1366 arr[num++] = 0x0; /* reserved */
1367 arr[num++] = 0x0; /* reserved */
1368 arr[num++] = 0x0;
1369 arr[num++] = 0x1; /* relative port 1 (primary) */
1370 memset(arr + num, 0, 6);
1371 num += 6;
1372 arr[num++] = 0x0;
1373 arr[num++] = 12; /* length tp descriptor */
1374 /* naa-5 target port identifier (A) */
1375 arr[num++] = 0x61; /* proto=sas, binary */
1376 arr[num++] = 0x93; /* PIV=1, target port, NAA */
1377 arr[num++] = 0x0; /* reserved */
1378 arr[num++] = 0x8; /* length */
1b37bd60 1379 put_unaligned_be64(naa3_comp_a + port_a, arr + num);
773642d9 1380 num += 8;
c65b1445
DG		 1381 arr[num++] = 0x0; /* reserved */
1382 arr[num++] = 0x0; /* reserved */
1383 arr[num++] = 0x0;
1384 arr[num++] = 0x2; /* relative port 2 (secondary) */
1385 memset(arr + num, 0, 6);
1386 num += 6;
1387 arr[num++] = 0x0;
1388 arr[num++] = 12; /* length tp descriptor */
1389 /* naa-5 target port identifier (B) */
1390 arr[num++] = 0x61; /* proto=sas, binary */
1391 arr[num++] = 0x93; /* PIV=1, target port, NAA */
1392 arr[num++] = 0x0; /* reserved */
1393 arr[num++] = 0x8; /* length */
1b37bd60 1394 put_unaligned_be64(naa3_comp_a + port_b, arr + num);
773642d9 1395 num += 8;
c65b1445
DG		 1396
1397 return num;
1398}
1399
1400
1401static unsigned char vpd89_data[] = {
1402/* from 4th byte */ 0,0,0,0,
1403'l','i','n','u','x',' ',' ',' ',
1404'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
1405'1','2','3','4',
14060x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
14070xec,0,0,0,
14080x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
14090,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
14100x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
14110x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
14120x53,0x41,
14130x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
14140x20,0x20,
14150x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
14160x10,0x80,
14170,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
14180x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
14190x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
14200,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
14210x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
14220x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
14230,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
14240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14250,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14260,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14270x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
14280,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
14290xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
14300,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
14310,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14320,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14330,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14340,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14350,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14360,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14370,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14380,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14390,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14400,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14410,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14420,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
1443};
1444
cbf67842 1445/* ATA Information VPD page */
760f3b03 1446static int inquiry_vpd_89(unsigned char *arr)
c65b1445
DG		 1447{
1448 memcpy(arr, vpd89_data, sizeof(vpd89_data));
1449 return sizeof(vpd89_data);
1450}
1451
1452
1453static unsigned char vpdb0_data[] = {
1e49f785
DG		 1454 /* from 4th byte */ 0,0,0,4, 0,0,0x4,0, 0,0,0,64,
1455 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1456 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1457 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
c65b1445
DG		 1458};
1459
cbf67842 1460/* Block limits VPD page (SBC-3) */
760f3b03 1461static int inquiry_vpd_b0(unsigned char *arr)
c65b1445 1462{
ea61fca5
MP		 1463 unsigned int gran;
1464
c65b1445 1465 memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
e308b3d1
MP		 1466
1467 /* Optimal transfer length granularity */
86e6828a
LH		 1468 if (sdebug_opt_xferlen_exp != 0 &&
1469 sdebug_physblk_exp < sdebug_opt_xferlen_exp)
1470 gran = 1 << sdebug_opt_xferlen_exp;
1471 else
1472 gran = 1 << sdebug_physblk_exp;
773642d9 1473 put_unaligned_be16(gran, arr + 2);
e308b3d1
MP		 1474
1475 /* Maximum Transfer Length */
773642d9
DG		 1476 if (sdebug_store_sectors > 0x400)
1477 put_unaligned_be32(sdebug_store_sectors, arr + 4);
44d92694 1478
e308b3d1 1479 /* Optimal Transfer Length */
773642d9 1480 put_unaligned_be32(sdebug_opt_blks, &arr[8]);
e308b3d1 1481
773642d9 1482 if (sdebug_lbpu) {
e308b3d1 1483 /* Maximum Unmap LBA Count */
773642d9 1484 put_unaligned_be32(sdebug_unmap_max_blocks, &arr[16]);
e308b3d1
MP		 1485
1486 /* Maximum Unmap Block Descriptor Count */
773642d9 1487 put_unaligned_be32(sdebug_unmap_max_desc, &arr[20]);
44d92694
MP		 1488 }
1489
e308b3d1 1490 /* Unmap Granularity Alignment */
773642d9
DG		 1491 if (sdebug_unmap_alignment) {
1492 put_unaligned_be32(sdebug_unmap_alignment, &arr[28]);
44d92694
MP		 1493 arr[28] |= 0x80; /* UGAVALID */
1494 }
1495
e308b3d1 1496 /* Optimal Unmap Granularity */
773642d9 1497 put_unaligned_be32(sdebug_unmap_granularity, &arr[24]);
6014759c 1498
5b94e232 1499 /* Maximum WRITE SAME Length */
773642d9 1500 put_unaligned_be64(sdebug_write_same_length, &arr[32]);
5b94e232
MP		 1501
1502 return 0x3c; /* Mandatory page length for Logical Block Provisioning */
44d92694 1503
c65b1445 1504 return sizeof(vpdb0_data);
1da177e4
LT		 1505}
1506
1e49f785 1507/* Block device characteristics VPD page (SBC-3) */
64e14ece 1508static int inquiry_vpd_b1(struct sdebug_dev_info *devip, unsigned char *arr)
eac6e8e4
MW		 1509{
1510 memset(arr, 0, 0x3c);
1511 arr[0] = 0;
1e49f785
DG		 1512 arr[1] = 1; /* non rotating medium (e.g. solid state) */
1513 arr[2] = 0;
1514 arr[3] = 5; /* less than 1.8" */
64e14ece
DLM		 1515 if (devip->zmodel == BLK_ZONED_HA)
1516 arr[4] = 1 << 4; /* zoned field = 01b */
eac6e8e4
MW		 1517
1518 return 0x3c;
1519}
1da177e4 1520
760f3b03
DG		 1521/* Logical block provisioning VPD page (SBC-4) */
1522static int inquiry_vpd_b2(unsigned char *arr)
6014759c 1523{
3f0bc3b3 1524 memset(arr, 0, 0x4);
6014759c 1525 arr[0] = 0; /* threshold exponent */
773642d9 1526 if (sdebug_lbpu)
6014759c 1527 arr[1] = 1 << 7;
773642d9 1528 if (sdebug_lbpws)
6014759c 1529 arr[1] |= 1 << 6;
773642d9 1530 if (sdebug_lbpws10)
5b94e232 1531 arr[1] |= 1 << 5;
760f3b03
DG		 1532 if (sdebug_lbprz && scsi_debug_lbp())
1533 arr[1] |= (sdebug_lbprz & 0x7) << 2; /* sbc4r07 and later */
1534 /* anc_sup=0; dp=0 (no provisioning group descriptor) */
1535 /* minimum_percentage=0; provisioning_type=0 (unknown) */
1536 /* threshold_percentage=0 */
3f0bc3b3 1537 return 0x4;
6014759c
MP		 1538}
1539
d36da305 1540/* Zoned block device characteristics VPD page (ZBC mandatory) */
f0d1cf93 1541static int inquiry_vpd_b6(struct sdebug_dev_info *devip, unsigned char *arr)
d36da305
DG		 1542{
1543 memset(arr, 0, 0x3c);
1544 arr[0] = 0x1; /* set URSWRZ (unrestricted read in seq. wr req zone) */
1545 /*
1546 * Set Optimal number of open sequential write preferred zones and
1547 * Optimal number of non-sequentially written sequential write
f0d1cf93
DG		 1548 * preferred zones fields to 'not reported' (0xffffffff). Leave other
1549 * fields set to zero, apart from Max. number of open swrz_s field.
d36da305
DG		 1550 */
1551 put_unaligned_be32(0xffffffff, &arr[4]);
1552 put_unaligned_be32(0xffffffff, &arr[8]);
64e14ece 1553 if (sdeb_zbc_model == BLK_ZONED_HM && devip->max_open)
f0d1cf93
DG		 1554 put_unaligned_be32(devip->max_open, &arr[12]);
1555 else
1556 put_unaligned_be32(0xffffffff, &arr[12]);
d36da305
DG		 1557 return 0x3c;
1558}
1559
1da177e4 1560#define SDEBUG_LONG_INQ_SZ 96
c65b1445 1561#define SDEBUG_MAX_INQ_ARR_SZ 584
1da177e4 1562
c2248fc9 1563static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
1da177e4
LT		 1564{
1565 unsigned char pq_pdt;
91d4c752 1566 unsigned char *arr;
01123ef4 1567 unsigned char *cmd = scp->cmnd;
5a09e398 1568 int alloc_len, n, ret;
d36da305 1569 bool have_wlun, is_disk, is_zbc, is_disk_zbc;
1da177e4 1570
773642d9 1571 alloc_len = get_unaligned_be16(cmd + 3);
6f3cbf55
DG		 1572 arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
1573 if (! arr)
1574 return DID_REQUEUE << 16;
760f3b03 1575 is_disk = (sdebug_ptype == TYPE_DISK);
64e14ece 1576 is_zbc = (devip->zmodel != BLK_ZONED_NONE);
d36da305 1577 is_disk_zbc = (is_disk || is_zbc);
b01f6f83 1578 have_wlun = scsi_is_wlun(scp->device->lun);
c2248fc9 1579 if (have_wlun)
b01f6f83
DG		 1580 pq_pdt = TYPE_WLUN; /* present, wlun */
1581 else if (sdebug_no_lun_0 && (devip->lun == SDEBUG_LUN_0_VAL))
1582 pq_pdt = 0x7f; /* not present, PQ=3, PDT=0x1f */
c65b1445 1583 else
773642d9 1584 pq_pdt = (sdebug_ptype & 0x1f);
1da177e4
LT		 1585 arr[0] = pq_pdt;
1586 if (0x2 & cmd[1]) { /* CMDDT bit set */
22017ed2 1587 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 1);
5a09e398 1588 kfree(arr);
1da177e4
LT		 1589 return check_condition_result;
1590 } else if (0x1 & cmd[1]) { /* EVPD bit set */
5a09e398 1591 int lu_id_num, port_group_id, target_dev_id, len;
c65b1445
DG		 1592 char lu_id_str[6];
1593 int host_no = devip->sdbg_host->shost->host_no;
1da177e4 1594
5a09e398
HR		 1595 port_group_id = (((host_no + 1) & 0x7f) << 8) +
1596 (devip->channel & 0x7f);
b01f6f83 1597 if (sdebug_vpd_use_hostno == 0)
23183910 1598 host_no = 0;
c2248fc9 1599 lu_id_num = have_wlun ? -1 : (((host_no + 1) * 2000) +
c65b1445
DG		 1600 (devip->target * 1000) + devip->lun);
1601 target_dev_id = ((host_no + 1) * 2000) +
1602 (devip->target * 1000) - 3;
1603 len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
1da177e4 1604 if (0 == cmd[2]) { /* supported vital product data pages */
c65b1445
DG		 1605 arr[1] = cmd[2]; /*sanity */
1606 n = 4;
1607 arr[n++] = 0x0; /* this page */
1608 arr[n++] = 0x80; /* unit serial number */
1609 arr[n++] = 0x83; /* device identification */
1610 arr[n++] = 0x84; /* software interface ident. */
1611 arr[n++] = 0x85; /* management network addresses */
1612 arr[n++] = 0x86; /* extended inquiry */
1613 arr[n++] = 0x87; /* mode page policy */
1614 arr[n++] = 0x88; /* SCSI ports */
d36da305 1615 if (is_disk_zbc) { /* SBC or ZBC */
760f3b03
DG		 1616 arr[n++] = 0x89; /* ATA information */
1617 arr[n++] = 0xb0; /* Block limits */
1618 arr[n++] = 0xb1; /* Block characteristics */
d36da305
DG		 1619 if (is_disk)
1620 arr[n++] = 0xb2; /* LB Provisioning */
64e14ece 1621 if (is_zbc)
d36da305 1622 arr[n++] = 0xb6; /* ZB dev. char. */
760f3b03 1623 }
c65b1445 1624 arr[3] = n - 4; /* number of supported VPD pages */
1da177e4 1625 } else if (0x80 == cmd[2]) { /* unit serial number */
c65b1445 1626 arr[1] = cmd[2]; /*sanity */
1da177e4 1627 arr[3] = len;
c65b1445 1628 memcpy(&arr[4], lu_id_str, len);
1da177e4 1629 } else if (0x83 == cmd[2]) { /* device identification */
c65b1445 1630 arr[1] = cmd[2]; /*sanity */
760f3b03
DG		 1631 arr[3] = inquiry_vpd_83(&arr[4], port_group_id,
1632 target_dev_id, lu_id_num,
09ba24c1
DG		 1633 lu_id_str, len,
1634 &devip->lu_name);
c65b1445
DG		 1635 } else if (0x84 == cmd[2]) { /* Software interface ident. */
1636 arr[1] = cmd[2]; /*sanity */
760f3b03 1637 arr[3] = inquiry_vpd_84(&arr[4]);
c65b1445
DG		 1638 } else if (0x85 == cmd[2]) { /* Management network addresses */
1639 arr[1] = cmd[2]; /*sanity */
760f3b03 1640 arr[3] = inquiry_vpd_85(&arr[4]);
c65b1445
DG		 1641 } else if (0x86 == cmd[2]) { /* extended inquiry */
1642 arr[1] = cmd[2]; /*sanity */
1643 arr[3] = 0x3c; /* number of following entries */
8475c811 1644 if (sdebug_dif == T10_PI_TYPE3_PROTECTION)
c6a44287 1645 arr[4] = 0x4; /* SPT: GRD_CHK:1 */
760f3b03 1646 else if (have_dif_prot)
c6a44287
MP		 1647 arr[4] = 0x5; /* SPT: GRD_CHK:1, REF_CHK:1 */
1648 else
1649 arr[4] = 0x0; /* no protection stuff */
c65b1445
DG		 1650 arr[5] = 0x7; /* head of q, ordered + simple q's */
1651 } else if (0x87 == cmd[2]) { /* mode page policy */
1652 arr[1] = cmd[2]; /*sanity */
1653 arr[3] = 0x8; /* number of following entries */
1654 arr[4] = 0x2; /* disconnect-reconnect mp */
1655 arr[6] = 0x80; /* mlus, shared */
1656 arr[8] = 0x18; /* protocol specific lu */
1657 arr[10] = 0x82; /* mlus, per initiator port */
1658 } else if (0x88 == cmd[2]) { /* SCSI Ports */
1659 arr[1] = cmd[2]; /*sanity */
760f3b03 1660 arr[3] = inquiry_vpd_88(&arr[4], target_dev_id);
d36da305 1661 } else if (is_disk_zbc && 0x89 == cmd[2]) { /* ATA info */
c65b1445 1662 arr[1] = cmd[2]; /*sanity */
760f3b03 1663 n = inquiry_vpd_89(&arr[4]);
773642d9 1664 put_unaligned_be16(n, arr + 2);
d36da305 1665 } else if (is_disk_zbc && 0xb0 == cmd[2]) { /* Block limits */
c65b1445 1666 arr[1] = cmd[2]; /*sanity */
760f3b03 1667 arr[3] = inquiry_vpd_b0(&arr[4]);
d36da305 1668 } else if (is_disk_zbc && 0xb1 == cmd[2]) { /* Block char. */
eac6e8e4 1669 arr[1] = cmd[2]; /*sanity */
64e14ece 1670 arr[3] = inquiry_vpd_b1(devip, &arr[4]);
760f3b03 1671 } else if (is_disk && 0xb2 == cmd[2]) { /* LB Prov. */
6014759c 1672 arr[1] = cmd[2]; /*sanity */
760f3b03 1673 arr[3] = inquiry_vpd_b2(&arr[4]);
d36da305
DG		 1674 } else if (is_zbc && cmd[2] == 0xb6) { /* ZB dev. charact. */
1675 arr[1] = cmd[2]; /*sanity */
f0d1cf93 1676 arr[3] = inquiry_vpd_b6(devip, &arr[4]);
1da177e4 1677 } else {
22017ed2 1678 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, -1);
5a09e398 1679 kfree(arr);
1da177e4
LT		 1680 return check_condition_result;
1681 }
773642d9 1682 len = min(get_unaligned_be16(arr + 2) + 4, alloc_len);
5a09e398 1683 ret = fill_from_dev_buffer(scp, arr,
c65b1445 1684 min(len, SDEBUG_MAX_INQ_ARR_SZ));
5a09e398
HR		 1685 kfree(arr);
1686 return ret;
1da177e4
LT		 1687 }
1688 /* drops through here for a standard inquiry */
773642d9
DG		 1689 arr[1] = sdebug_removable ? 0x80 : 0; /* Removable disk */
1690 arr[2] = sdebug_scsi_level;
1da177e4
LT		 1691 arr[3] = 2; /* response_data_format==2 */
1692 arr[4] = SDEBUG_LONG_INQ_SZ - 5;
f46eb0e9 1693 arr[5] = (int)have_dif_prot; /* PROTECT bit */
b01f6f83 1694 if (sdebug_vpd_use_hostno == 0)
70bdf202 1695 arr[5] |= 0x10; /* claim: implicit TPGS */
c65b1445 1696 arr[6] = 0x10; /* claim: MultiP */
1da177e4 1697 /* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
c65b1445 1698 arr[7] = 0xa; /* claim: LINKED + CMDQUE */
e5203cf0
HR		 1699 memcpy(&arr[8], sdebug_inq_vendor_id, 8);
1700 memcpy(&arr[16], sdebug_inq_product_id, 16);
1701 memcpy(&arr[32], sdebug_inq_product_rev, 4);
9b760fd8
DG		 1702 /* Use Vendor Specific area to place driver date in ASCII hex */
1703 memcpy(&arr[36], sdebug_version_date, 8);
1da177e4 1704 /* version descriptors (2 bytes each) follow */
760f3b03
DG		 1705 put_unaligned_be16(0xc0, arr + 58); /* SAM-6 no version claimed */
1706 put_unaligned_be16(0x5c0, arr + 60); /* SPC-5 no version claimed */
c65b1445 1707 n = 62;
760f3b03
DG		 1708 if (is_disk) { /* SBC-4 no version claimed */
1709 put_unaligned_be16(0x600, arr + n);
1710 n += 2;
1711 } else if (sdebug_ptype == TYPE_TAPE) { /* SSC-4 rev 3 */
1712 put_unaligned_be16(0x525, arr + n);
1713 n += 2;
d36da305
DG		 1714 } else if (is_zbc) { /* ZBC BSR INCITS 536 revision 05 */
1715 put_unaligned_be16(0x624, arr + n);
1716 n += 2;
1da177e4 1717 }
760f3b03 1718 put_unaligned_be16(0x2100, arr + n); /* SPL-4 no version claimed */
5a09e398 1719 ret = fill_from_dev_buffer(scp, arr,
87c715dc 1720 min_t(int, alloc_len, SDEBUG_LONG_INQ_SZ));
5a09e398
HR		 1721 kfree(arr);
1722 return ret;
1da177e4
LT		 1723}
1724
84905d34 1725/* See resp_iec_m_pg() for how this data is manipulated */
fd32119b
DG		 1726static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1727 0, 0, 0x0, 0x0};
1728
91d4c752
JP		 1729static int resp_requests(struct scsi_cmnd *scp,
1730 struct sdebug_dev_info *devip)
1da177e4 1731{
01123ef4 1732 unsigned char *cmd = scp->cmnd;
84905d34
DG		 1733 unsigned char arr[SCSI_SENSE_BUFFERSIZE]; /* assume >= 18 bytes */
1734 bool dsense = !!(cmd[1] & 1);
1735 int alloc_len = cmd[4];
1da177e4 1736 int len = 18;
84905d34 1737 int stopped_state = atomic_read(&devip->stopped);
1da177e4 1738
c65b1445 1739 memset(arr, 0, sizeof(arr));
84905d34
DG		 1740 if (stopped_state > 0) { /* some "pollable" data [spc6r02: 5.12.2] */
1741 if (dsense) {
1742 arr[0] = 0x72;
1743 arr[1] = NOT_READY;
1744 arr[2] = LOGICAL_UNIT_NOT_READY;
1745 arr[3] = (stopped_state == 2) ? 0x1 : 0x2;
1746 len = 8;
1747 } else {
1748 arr[0] = 0x70;
1749 arr[2] = NOT_READY; /* NO_SENSE in sense_key */
1750 arr[7] = 0xa; /* 18 byte sense buffer */
1751 arr[12] = LOGICAL_UNIT_NOT_READY;
1752 arr[13] = (stopped_state == 2) ? 0x1 : 0x2;
1753 }
1754 } else if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
1755 /* Information exceptions control mode page: TEST=1, MRIE=6 */
c2248fc9 1756 if (dsense) {
c65b1445
DG		 1757 arr[0] = 0x72;
1758 arr[1] = 0x0; /* NO_SENSE in sense_key */
1759 arr[2] = THRESHOLD_EXCEEDED;
84905d34 1760 arr[3] = 0xff; /* Failure prediction(false) */
c2248fc9 1761 len = 8;
c65b1445
DG		 1762 } else {
1763 arr[0] = 0x70;
1764 arr[2] = 0x0; /* NO_SENSE in sense_key */
1765 arr[7] = 0xa; /* 18 byte sense buffer */
1766 arr[12] = THRESHOLD_EXCEEDED;
84905d34 1767 arr[13] = 0xff; /* Failure prediction(false) */
c65b1445 1768 }
84905d34
DG		 1769 } else { /* nothing to report */
1770 if (dsense) {
c65b1445 1771 len = 8;
84905d34
DG		 1772 memset(arr, 0, len);
1773 arr[0] = 0x72;
c2248fc9 1774 } else {
84905d34 1775 memset(arr, 0, len);
c2248fc9 1776 arr[0] = 0x70;
c2248fc9 1777 arr[7] = 0xa;
c65b1445
DG		 1778 }
1779 }
84905d34 1780 return fill_from_dev_buffer(scp, arr, min_t(int, len, alloc_len));
1da177e4
LT		 1781}
1782
fc13638a 1783static int resp_start_stop(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
c65b1445 1784{
01123ef4 1785 unsigned char *cmd = scp->cmnd;
fc13638a 1786 int power_cond, want_stop, stopped_state;
4f2c8bf6 1787 bool changing;
c65b1445 1788
c65b1445
DG		 1789 power_cond = (cmd[4] & 0xf0) >> 4;
1790 if (power_cond) {
22017ed2 1791 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, 7);
c65b1445
DG		 1792 return check_condition_result;
1793 }
fc13638a
DG		 1794 want_stop = !(cmd[4] & 1);
1795 stopped_state = atomic_read(&devip->stopped);
1796 if (stopped_state == 2) {
1797 ktime_t now_ts = ktime_get_boottime();
1798
1799 if (ktime_to_ns(now_ts) > ktime_to_ns(devip->create_ts)) {
1800 u64 diff_ns = ktime_to_ns(ktime_sub(now_ts, devip->create_ts));
1801
1802 if (diff_ns >= ((u64)sdeb_tur_ms_to_ready * 1000000)) {
1803 /* tur_ms_to_ready timer extinguished */
1804 atomic_set(&devip->stopped, 0);
1805 stopped_state = 0;
1806 }
1807 }
1808 if (stopped_state == 2) {
1809 if (want_stop) {
1810 stopped_state = 1; /* dummy up success */
1811 } else { /* Disallow tur_ms_to_ready delay to be overridden */
1812 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, 0 /* START bit */);
1813 return check_condition_result;
1814 }
1815 }
1816 }
1817 changing = (stopped_state != want_stop);
1818 if (changing)
1819 atomic_xchg(&devip->stopped, want_stop);
1820 if (!changing || (cmd[1] & 0x1)) /* state unchanged or IMMED bit set in cdb */
4f2c8bf6
DG		 1821 return SDEG_RES_IMMED_MASK;
1822 else
1823 return 0;
c65b1445
DG		 1824}
1825
28898873
FT		 1826static sector_t get_sdebug_capacity(void)
1827{
773642d9
DG		 1828 static const unsigned int gibibyte = 1073741824;
1829
1830 if (sdebug_virtual_gb > 0)
1831 return (sector_t)sdebug_virtual_gb *
1832 (gibibyte / sdebug_sector_size);
28898873
FT		 1833 else
1834 return sdebug_store_sectors;
1835}
1836
1da177e4 1837#define SDEBUG_READCAP_ARR_SZ 8
91d4c752
JP		 1838static int resp_readcap(struct scsi_cmnd *scp,
1839 struct sdebug_dev_info *devip)
1da177e4
LT		 1840{
1841 unsigned char arr[SDEBUG_READCAP_ARR_SZ];
c65b1445 1842 unsigned int capac;
1da177e4 1843
c65b1445 1844 /* following just in case virtual_gb changed */
28898873 1845 sdebug_capacity = get_sdebug_capacity();
1da177e4 1846 memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
c65b1445
DG		 1847 if (sdebug_capacity < 0xffffffff) {
1848 capac = (unsigned int)sdebug_capacity - 1;
773642d9
DG		 1849 put_unaligned_be32(capac, arr + 0);
1850 } else
1851 put_unaligned_be32(0xffffffff, arr + 0);
1852 put_unaligned_be16(sdebug_sector_size, arr + 6);
1da177e4
LT		 1853 return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
1854}
1855
c65b1445 1856#define SDEBUG_READCAP16_ARR_SZ 32
91d4c752
JP		 1857static int resp_readcap16(struct scsi_cmnd *scp,
1858 struct sdebug_dev_info *devip)
c65b1445 1859{
01123ef4 1860 unsigned char *cmd = scp->cmnd;
c65b1445 1861 unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
773642d9 1862 int alloc_len;
c65b1445 1863
773642d9 1864 alloc_len = get_unaligned_be32(cmd + 10);
c65b1445 1865 /* following just in case virtual_gb changed */
28898873 1866 sdebug_capacity = get_sdebug_capacity();
c65b1445 1867 memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
773642d9
DG		 1868 put_unaligned_be64((u64)(sdebug_capacity - 1), arr + 0);
1869 put_unaligned_be32(sdebug_sector_size, arr + 8);
1870 arr[13] = sdebug_physblk_exp & 0xf;
1871 arr[14] = (sdebug_lowest_aligned >> 8) & 0x3f;
44d92694 1872
be1dd78d 1873 if (scsi_debug_lbp()) {
5b94e232 1874 arr[14] |= 0x80; /* LBPME */
760f3b03
DG		 1875 /* from sbc4r07, this LBPRZ field is 1 bit, but the LBPRZ in
1876 * the LB Provisioning VPD page is 3 bits. Note that lbprz=2
1877 * in the wider field maps to 0 in this field.
1878 */
1879 if (sdebug_lbprz & 1) /* precisely what the draft requires */
1880 arr[14] |= 0x40;
be1dd78d 1881 }
44d92694 1882
773642d9 1883 arr[15] = sdebug_lowest_aligned & 0xff;
c6a44287 1884
760f3b03 1885 if (have_dif_prot) {
773642d9 1886 arr[12] = (sdebug_dif - 1) << 1; /* P_TYPE */
c6a44287
MP		 1887 arr[12] |= 1; /* PROT_EN */
1888 }
1889
c65b1445 1890 return fill_from_dev_buffer(scp, arr,
87c715dc 1891 min_t(int, alloc_len, SDEBUG_READCAP16_ARR_SZ));
c65b1445
DG		 1892}
1893
5a09e398
HR		 1894#define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
1895
91d4c752
JP		 1896static int resp_report_tgtpgs(struct scsi_cmnd *scp,
1897 struct sdebug_dev_info *devip)
5a09e398 1898{
01123ef4 1899 unsigned char *cmd = scp->cmnd;
91d4c752 1900 unsigned char *arr;
5a09e398
HR		 1901 int host_no = devip->sdbg_host->shost->host_no;
1902 int n, ret, alen, rlen;
1903 int port_group_a, port_group_b, port_a, port_b;
1904
773642d9 1905 alen = get_unaligned_be32(cmd + 6);
6f3cbf55
DG		 1906 arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
1907 if (! arr)
1908 return DID_REQUEUE << 16;
5a09e398
HR		 1909 /*
1910 * EVPD page 0x88 states we have two ports, one
1911 * real and a fake port with no device connected.
1912 * So we create two port groups with one port each
1913 * and set the group with port B to unavailable.
1914 */
1915 port_a = 0x1; /* relative port A */
1916 port_b = 0x2; /* relative port B */
1917 port_group_a = (((host_no + 1) & 0x7f) << 8) +
773642d9 1918 (devip->channel & 0x7f);
5a09e398 1919 port_group_b = (((host_no + 1) & 0x7f) << 8) +
773642d9 1920 (devip->channel & 0x7f) + 0x80;
5a09e398
HR		 1921
1922 /*
1923 * The asymmetric access state is cycled according to the host_id.
1924 */
1925 n = 4;
b01f6f83 1926 if (sdebug_vpd_use_hostno == 0) {
773642d9
DG		 1927 arr[n++] = host_no % 3; /* Asymm access state */
1928 arr[n++] = 0x0F; /* claim: all states are supported */
5a09e398 1929 } else {
773642d9
DG		 1930 arr[n++] = 0x0; /* Active/Optimized path */
1931 arr[n++] = 0x01; /* only support active/optimized paths */
5a09e398 1932 }
773642d9
DG		 1933 put_unaligned_be16(port_group_a, arr + n);
1934 n += 2;
5a09e398
HR		 1935 arr[n++] = 0; /* Reserved */
1936 arr[n++] = 0; /* Status code */
1937 arr[n++] = 0; /* Vendor unique */
1938 arr[n++] = 0x1; /* One port per group */
1939 arr[n++] = 0; /* Reserved */
1940 arr[n++] = 0; /* Reserved */
773642d9
DG		 1941 put_unaligned_be16(port_a, arr + n);
1942 n += 2;
5a09e398
HR		 1943 arr[n++] = 3; /* Port unavailable */
1944 arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
773642d9
DG		 1945 put_unaligned_be16(port_group_b, arr + n);
1946 n += 2;
5a09e398
HR		 1947 arr[n++] = 0; /* Reserved */
1948 arr[n++] = 0; /* Status code */
1949 arr[n++] = 0; /* Vendor unique */
1950 arr[n++] = 0x1; /* One port per group */
1951 arr[n++] = 0; /* Reserved */
1952 arr[n++] = 0; /* Reserved */
773642d9
DG		 1953 put_unaligned_be16(port_b, arr + n);
1954 n += 2;
5a09e398
HR		 1955
1956 rlen = n - 4;
773642d9 1957 put_unaligned_be32(rlen, arr + 0);
5a09e398
HR		 1958
1959 /*
1960 * Return the smallest value of either
1961 * - The allocated length
1962 * - The constructed command length
1963 * - The maximum array size
1964 */
87c715dc 1965 rlen = min_t(int, alen, n);
5a09e398 1966 ret = fill_from_dev_buffer(scp, arr,
87c715dc 1967 min_t(int, rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
5a09e398
HR		 1968 kfree(arr);
1969 return ret;
1970}
1971
fd32119b
DG		 1972static int resp_rsup_opcodes(struct scsi_cmnd *scp,
1973 struct sdebug_dev_info *devip)
38d5c833
DG		 1974{
1975 bool rctd;
1976 u8 reporting_opts, req_opcode, sdeb_i, supp;
1977 u16 req_sa, u;
1978 u32 alloc_len, a_len;
1979 int k, offset, len, errsts, count, bump, na;
1980 const struct opcode_info_t *oip;
1981 const struct opcode_info_t *r_oip;
1982 u8 *arr;
1983 u8 *cmd = scp->cmnd;
1984
1985 rctd = !!(cmd[2] & 0x80);
1986 reporting_opts = cmd[2] & 0x7;
1987 req_opcode = cmd[3];
1988 req_sa = get_unaligned_be16(cmd + 4);
1989 alloc_len = get_unaligned_be32(cmd + 6);
6d310dfb 1990 if (alloc_len < 4 || alloc_len > 0xffff) {
38d5c833
DG		 1991 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
1992 return check_condition_result;
1993 }
1994 if (alloc_len > 8192)
1995 a_len = 8192;
1996 else
1997 a_len = alloc_len;
99531e60 1998 arr = kzalloc((a_len < 256) ? 320 : a_len + 64, GFP_ATOMIC);
38d5c833
DG		 1999 if (NULL == arr) {
2000 mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
2001 INSUFF_RES_ASCQ);
2002 return check_condition_result;
2003 }
2004 switch (reporting_opts) {
2005 case 0: /* all commands */
2006 /* count number of commands */
2007 for (count = 0, oip = opcode_info_arr;
2008 oip->num_attached != 0xff; ++oip) {
2009 if (F_INV_OP & oip->flags)
2010 continue;
2011 count += (oip->num_attached + 1);
2012 }
2013 bump = rctd ? 20 : 8;
2014 put_unaligned_be32(count * bump, arr);
2015 for (offset = 4, oip = opcode_info_arr;
2016 oip->num_attached != 0xff && offset < a_len; ++oip) {
2017 if (F_INV_OP & oip->flags)
2018 continue;
2019 na = oip->num_attached;
2020 arr[offset] = oip->opcode;
2021 put_unaligned_be16(oip->sa, arr + offset + 2);
2022 if (rctd)
2023 arr[offset + 5] |= 0x2;
2024 if (FF_SA & oip->flags)
2025 arr[offset + 5] |= 0x1;
2026 put_unaligned_be16(oip->len_mask[0], arr + offset + 6);
2027 if (rctd)
2028 put_unaligned_be16(0xa, arr + offset + 8);
2029 r_oip = oip;
2030 for (k = 0, oip = oip->arrp; k < na; ++k, ++oip) {
2031 if (F_INV_OP & oip->flags)
2032 continue;
2033 offset += bump;
2034 arr[offset] = oip->opcode;
2035 put_unaligned_be16(oip->sa, arr + offset + 2);
2036 if (rctd)
2037 arr[offset + 5] |= 0x2;
2038 if (FF_SA & oip->flags)
2039 arr[offset + 5] |= 0x1;
2040 put_unaligned_be16(oip->len_mask[0],
2041 arr + offset + 6);
2042 if (rctd)
2043 put_unaligned_be16(0xa,
2044 arr + offset + 8);
2045 }
2046 oip = r_oip;
2047 offset += bump;
2048 }
2049 break;
2050 case 1: /* one command: opcode only */
2051 case 2: /* one command: opcode plus service action */
2052 case 3: /* one command: if sa==0 then opcode only else opcode+sa */
2053 sdeb_i = opcode_ind_arr[req_opcode];
2054 oip = &opcode_info_arr[sdeb_i];
2055 if (F_INV_OP & oip->flags) {
2056 supp = 1;
2057 offset = 4;
2058 } else {
2059 if (1 == reporting_opts) {
2060 if (FF_SA & oip->flags) {
2061 mk_sense_invalid_fld(scp, SDEB_IN_CDB,
2062 2, 2);
2063 kfree(arr);
2064 return check_condition_result;
2065 }
2066 req_sa = 0;
2067 } else if (2 == reporting_opts &&
2068 0 == (FF_SA & oip->flags)) {
2069 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, -1);
2070 kfree(arr); /* point at requested sa */
2071 return check_condition_result;
2072 }
2073 if (0 == (FF_SA & oip->flags) &&
2074 req_opcode == oip->opcode)
2075 supp = 3;
2076 else if (0 == (FF_SA & oip->flags)) {
2077 na = oip->num_attached;
2078 for (k = 0, oip = oip->arrp; k < na;
2079 ++k, ++oip) {
2080 if (req_opcode == oip->opcode)
2081 break;
2082 }
2083 supp = (k >= na) ? 1 : 3;
2084 } else if (req_sa != oip->sa) {
2085 na = oip->num_attached;
2086 for (k = 0, oip = oip->arrp; k < na;
2087 ++k, ++oip) {
2088 if (req_sa == oip->sa)
2089 break;
2090 }
2091 supp = (k >= na) ? 1 : 3;
2092 } else
2093 supp = 3;
2094 if (3 == supp) {
2095 u = oip->len_mask[0];
2096 put_unaligned_be16(u, arr + 2);
2097 arr[4] = oip->opcode;
2098 for (k = 1; k < u; ++k)
2099 arr[4 + k] = (k < 16) ?
2100 oip->len_mask[k] : 0xff;
2101 offset = 4 + u;
2102 } else
2103 offset = 4;
2104 }
2105 arr[1] = (rctd ? 0x80 : 0) | supp;
2106 if (rctd) {
2107 put_unaligned_be16(0xa, arr + offset);
2108 offset += 12;
2109 }
2110 break;
2111 default:
2112 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 2);
2113 kfree(arr);
2114 return check_condition_result;
2115 }
2116 offset = (offset < a_len) ? offset : a_len;
2117 len = (offset < alloc_len) ? offset : alloc_len;
2118 errsts = fill_from_dev_buffer(scp, arr, len);
2119 kfree(arr);
2120 return errsts;
2121}
2122
fd32119b
DG		 2123static int resp_rsup_tmfs(struct scsi_cmnd *scp,
2124 struct sdebug_dev_info *devip)
38d5c833
DG		 2125{
2126 bool repd;
2127 u32 alloc_len, len;
2128 u8 arr[16];
2129 u8 *cmd = scp->cmnd;
2130
2131 memset(arr, 0, sizeof(arr));
2132 repd = !!(cmd[2] & 0x80);
2133 alloc_len = get_unaligned_be32(cmd + 6);
2134 if (alloc_len < 4) {
2135 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
2136 return check_condition_result;
2137 }
2138 arr[0] = 0xc8; /* ATS | ATSS | LURS */
2139 arr[1] = 0x1; /* ITNRS */
2140 if (repd) {
2141 arr[3] = 0xc;
2142 len = 16;
2143 } else
2144 len = 4;
2145
2146 len = (len < alloc_len) ? len : alloc_len;
2147 return fill_from_dev_buffer(scp, arr, len);
2148}
2149
1da177e4
LT		 2150/* <<Following mode page info copied from ST318451LW>> */
2151
91d4c752 2152static int resp_err_recov_pg(unsigned char *p, int pcontrol, int target)
1da177e4
LT		 2153{ /* Read-Write Error Recovery page for mode_sense */
2154 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
2155 5, 0, 0xff, 0xff};
2156
2157 memcpy(p, err_recov_pg, sizeof(err_recov_pg));
2158 if (1 == pcontrol)
2159 memset(p + 2, 0, sizeof(err_recov_pg) - 2);
2160 return sizeof(err_recov_pg);
2161}
2162
91d4c752 2163static int resp_disconnect_pg(unsigned char *p, int pcontrol, int target)
1da177e4
LT		 2164{ /* Disconnect-Reconnect page for mode_sense */
2165 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
2166 0, 0, 0, 0, 0, 0, 0, 0};
2167
2168 memcpy(p, disconnect_pg, sizeof(disconnect_pg));
2169 if (1 == pcontrol)
2170 memset(p + 2, 0, sizeof(disconnect_pg) - 2);
2171 return sizeof(disconnect_pg);
2172}
2173
91d4c752 2174static int resp_format_pg(unsigned char *p, int pcontrol, int target)
1da177e4 2175{ /* Format device page for mode_sense */
597136ab
MP		 2176 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
2177 0, 0, 0, 0, 0, 0, 0, 0,
2178 0, 0, 0, 0, 0x40, 0, 0, 0};
2179
2180 memcpy(p, format_pg, sizeof(format_pg));
773642d9
DG		 2181 put_unaligned_be16(sdebug_sectors_per, p + 10);
2182 put_unaligned_be16(sdebug_sector_size, p + 12);
2183 if (sdebug_removable)
597136ab
MP		 2184 p[20] |= 0x20; /* should agree with INQUIRY */
2185 if (1 == pcontrol)
2186 memset(p + 2, 0, sizeof(format_pg) - 2);
2187 return sizeof(format_pg);
1da177e4
LT		 2188}
2189
fd32119b
DG		 2190static unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
2191 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0,
2192 0, 0, 0, 0};
2193
91d4c752 2194static int resp_caching_pg(unsigned char *p, int pcontrol, int target)
1da177e4 2195{ /* Caching page for mode_sense */
cbf67842
DG		 2196 unsigned char ch_caching_pg[] = {/* 0x8, 18, */ 0x4, 0, 0, 0, 0, 0,
2197 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
2198 unsigned char d_caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1da177e4
LT		 2199 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
2200
773642d9 2201 if (SDEBUG_OPT_N_WCE & sdebug_opts)
cbf67842 2202 caching_pg[2] &= ~0x4; /* set WCE=0 (default WCE=1) */
1da177e4
LT		 2203 memcpy(p, caching_pg, sizeof(caching_pg));
2204 if (1 == pcontrol)
cbf67842
DG		 2205 memcpy(p + 2, ch_caching_pg, sizeof(ch_caching_pg));
2206 else if (2 == pcontrol)
2207 memcpy(p, d_caching_pg, sizeof(d_caching_pg));
1da177e4
LT		 2208 return sizeof(caching_pg);
2209}
2210
fd32119b
DG		 2211static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
2212 0, 0, 0x2, 0x4b};
2213
91d4c752 2214static int resp_ctrl_m_pg(unsigned char *p, int pcontrol, int target)
1da177e4 2215{ /* Control mode page for mode_sense */
c65b1445 2216 unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
9a051019 2217 0, 0, 0, 0};
c65b1445 2218 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1da177e4
LT		 2219 0, 0, 0x2, 0x4b};
2220
773642d9 2221 if (sdebug_dsense)
1da177e4 2222 ctrl_m_pg[2] |= 0x4;
c65b1445
DG		 2223 else
2224 ctrl_m_pg[2] &= ~0x4;
c6a44287 2225
773642d9 2226 if (sdebug_ato)
c6a44287
MP		 2227 ctrl_m_pg[5] |= 0x80; /* ATO=1 */
2228
1da177e4
LT		 2229 memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
2230 if (1 == pcontrol)
c65b1445
DG		 2231 memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
2232 else if (2 == pcontrol)
2233 memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
1da177e4
LT		 2234 return sizeof(ctrl_m_pg);
2235}
2236
c65b1445 2237
91d4c752 2238static int resp_iec_m_pg(unsigned char *p, int pcontrol, int target)
1da177e4 2239{ /* Informational Exceptions control mode page for mode_sense */
c65b1445
DG		 2240 unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
2241 0, 0, 0x0, 0x0};
2242 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
2243 0, 0, 0x0, 0x0};
2244
1da177e4
LT		 2245 memcpy(p, iec_m_pg, sizeof(iec_m_pg));
2246 if (1 == pcontrol)
c65b1445
DG		 2247 memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
2248 else if (2 == pcontrol)
2249 memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
1da177e4
LT		 2250 return sizeof(iec_m_pg);
2251}
2252
91d4c752 2253static int resp_sas_sf_m_pg(unsigned char *p, int pcontrol, int target)
c65b1445
DG		 2254{ /* SAS SSP mode page - short format for mode_sense */
2255 unsigned char sas_sf_m_pg[] = {0x19, 0x6,
2256 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
2257
2258 memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
2259 if (1 == pcontrol)
2260 memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
2261 return sizeof(sas_sf_m_pg);
2262}
2263
2264
91d4c752 2265static int resp_sas_pcd_m_spg(unsigned char *p, int pcontrol, int target,
c65b1445
DG		 2266 int target_dev_id)
2267{ /* SAS phy control and discover mode page for mode_sense */
2268 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
2269 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
773642d9
DG		 2270 0, 0, 0, 0, 0, 0, 0, 0, /* insert SAS addr */
2271 0, 0, 0, 0, 0, 0, 0, 0, /* insert SAS addr */
c65b1445
DG		 2272 0x2, 0, 0, 0, 0, 0, 0, 0,
2273 0x88, 0x99, 0, 0, 0, 0, 0, 0,
2274 0, 0, 0, 0, 0, 0, 0, 0,
2275 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
773642d9
DG		 2276 0, 0, 0, 0, 0, 0, 0, 0, /* insert SAS addr */
2277 0, 0, 0, 0, 0, 0, 0, 0, /* insert SAS addr */
c65b1445
DG		 2278 0x3, 0, 0, 0, 0, 0, 0, 0,
2279 0x88, 0x99, 0, 0, 0, 0, 0, 0,
2280 0, 0, 0, 0, 0, 0, 0, 0,
2281 };
2282 int port_a, port_b;
2283
1b37bd60
DG		 2284 put_unaligned_be64(naa3_comp_a, sas_pcd_m_pg + 16);
2285 put_unaligned_be64(naa3_comp_c + 1, sas_pcd_m_pg + 24);
2286 put_unaligned_be64(naa3_comp_a, sas_pcd_m_pg + 64);
2287 put_unaligned_be64(naa3_comp_c + 1, sas_pcd_m_pg + 72);
c65b1445
DG		 2288 port_a = target_dev_id + 1;
2289 port_b = port_a + 1;
2290 memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
773642d9
DG		 2291 put_unaligned_be32(port_a, p + 20);
2292 put_unaligned_be32(port_b, p + 48 + 20);
c65b1445
DG		 2293 if (1 == pcontrol)
2294 memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
2295 return sizeof(sas_pcd_m_pg);
2296}
2297
91d4c752 2298static int resp_sas_sha_m_spg(unsigned char *p, int pcontrol)
c65b1445
DG		 2299{ /* SAS SSP shared protocol specific port mode subpage */
2300 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
2301 0, 0, 0, 0, 0, 0, 0, 0,
2302 };
2303
2304 memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
2305 if (1 == pcontrol)
2306 memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
2307 return sizeof(sas_sha_m_pg);
2308}
2309
1da177e4
LT		 2310#define SDEBUG_MAX_MSENSE_SZ 256
2311
fd32119b
DG		 2312static int resp_mode_sense(struct scsi_cmnd *scp,
2313 struct sdebug_dev_info *devip)
1da177e4 2314{
23183910 2315 int pcontrol, pcode, subpcode, bd_len;
1da177e4 2316 unsigned char dev_spec;
760f3b03 2317 int alloc_len, offset, len, target_dev_id;
c2248fc9 2318 int target = scp->device->id;
91d4c752 2319 unsigned char *ap;
1da177e4 2320 unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
01123ef4 2321 unsigned char *cmd = scp->cmnd;
d36da305 2322 bool dbd, llbaa, msense_6, is_disk, is_zbc, bad_pcode;
1da177e4 2323
760f3b03 2324 dbd = !!(cmd[1] & 0x8); /* disable block descriptors */
1da177e4
LT		 2325 pcontrol = (cmd[2] & 0xc0) >> 6;
2326 pcode = cmd[2] & 0x3f;
2327 subpcode = cmd[3];
2328 msense_6 = (MODE_SENSE == cmd[0]);
760f3b03
DG		 2329 llbaa = msense_6 ? false : !!(cmd[1] & 0x10);
2330 is_disk = (sdebug_ptype == TYPE_DISK);
64e14ece 2331 is_zbc = (devip->zmodel != BLK_ZONED_NONE);
d36da305 2332 if ((is_disk || is_zbc) && !dbd)
23183910
DG		 2333 bd_len = llbaa ? 16 : 8;
2334 else
2335 bd_len = 0;
773642d9 2336 alloc_len = msense_6 ? cmd[4] : get_unaligned_be16(cmd + 7);
1da177e4
LT		 2337 memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
2338 if (0x3 == pcontrol) { /* Saving values not supported */
cbf67842 2339 mk_sense_buffer(scp, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP, 0);
1da177e4
LT		 2340 return check_condition_result;
2341 }
c65b1445
DG		 2342 target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
2343 (devip->target * 1000) - 3;
d36da305
DG		 2344 /* for disks+zbc set DPOFUA bit and clear write protect (WP) bit */
2345 if (is_disk || is_zbc) {
b01f6f83 2346 dev_spec = 0x10; /* =0x90 if WP=1 implies read-only */
9447b6ce
MP		 2347 if (sdebug_wp)
2348 dev_spec |= 0x80;
2349 } else
23183910 2350 dev_spec = 0x0;
1da177e4
LT		 2351 if (msense_6) {
2352 arr[2] = dev_spec;
23183910 2353 arr[3] = bd_len;
1da177e4
LT		 2354 offset = 4;
2355 } else {
2356 arr[3] = dev_spec;
23183910
DG		 2357 if (16 == bd_len)
2358 arr[4] = 0x1; /* set LONGLBA bit */
2359 arr[7] = bd_len; /* assume 255 or less */
1da177e4
LT		 2360 offset = 8;
2361 }
2362 ap = arr + offset;
28898873
FT		 2363 if ((bd_len > 0) && (!sdebug_capacity))
2364 sdebug_capacity = get_sdebug_capacity();
2365
23183910 2366 if (8 == bd_len) {
773642d9
DG		 2367 if (sdebug_capacity > 0xfffffffe)
2368 put_unaligned_be32(0xffffffff, ap + 0);
2369 else
2370 put_unaligned_be32(sdebug_capacity, ap + 0);
2371 put_unaligned_be16(sdebug_sector_size, ap + 6);
23183910
DG		 2372 offset += bd_len;
2373 ap = arr + offset;
2374 } else if (16 == bd_len) {
773642d9
DG		 2375 put_unaligned_be64((u64)sdebug_capacity, ap + 0);
2376 put_unaligned_be32(sdebug_sector_size, ap + 12);
23183910
DG		 2377 offset += bd_len;
2378 ap = arr + offset;
2379 }
1da177e4 2380
c65b1445
DG		 2381 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
2382 /* TODO: Control Extension page */
22017ed2 2383 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
1da177e4
LT		 2384 return check_condition_result;
2385 }
760f3b03
DG		 2386 bad_pcode = false;
2387
1da177e4
LT		 2388 switch (pcode) {
2389 case 0x1: /* Read-Write error recovery page, direct access */
2390 len = resp_err_recov_pg(ap, pcontrol, target);
2391 offset += len;
2392 break;
2393 case 0x2: /* Disconnect-Reconnect page, all devices */
2394 len = resp_disconnect_pg(ap, pcontrol, target);
2395 offset += len;
2396 break;
9a051019 2397 case 0x3: /* Format device page, direct access */
760f3b03
DG		 2398 if (is_disk) {
2399 len = resp_format_pg(ap, pcontrol, target);
2400 offset += len;
2401 } else
2402 bad_pcode = true;
9a051019 2403 break;
1da177e4 2404 case 0x8: /* Caching page, direct access */
d36da305 2405 if (is_disk || is_zbc) {
760f3b03
DG		 2406 len = resp_caching_pg(ap, pcontrol, target);
2407 offset += len;
2408 } else
2409 bad_pcode = true;
1da177e4
LT		 2410 break;
2411 case 0xa: /* Control Mode page, all devices */
2412 len = resp_ctrl_m_pg(ap, pcontrol, target);
2413 offset += len;
2414 break;
c65b1445
DG		 2415 case 0x19: /* if spc==1 then sas phy, control+discover */
2416 if ((subpcode > 0x2) && (subpcode < 0xff)) {
22017ed2 2417 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
c65b1445 2418 return check_condition_result;
9a051019 2419 }
c65b1445
DG		 2420 len = 0;
2421 if ((0x0 == subpcode) || (0xff == subpcode))
2422 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
2423 if ((0x1 == subpcode) || (0xff == subpcode))
2424 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
2425 target_dev_id);
2426 if ((0x2 == subpcode) || (0xff == subpcode))
2427 len += resp_sas_sha_m_spg(ap + len, pcontrol);
2428 offset += len;
2429 break;
1da177e4
LT		 2430 case 0x1c: /* Informational Exceptions Mode page, all devices */
2431 len = resp_iec_m_pg(ap, pcontrol, target);
2432 offset += len;
2433 break;
2434 case 0x3f: /* Read all Mode pages */
c65b1445
DG		 2435 if ((0 == subpcode) || (0xff == subpcode)) {
2436 len = resp_err_recov_pg(ap, pcontrol, target);
2437 len += resp_disconnect_pg(ap + len, pcontrol, target);
760f3b03
DG		 2438 if (is_disk) {
2439 len += resp_format_pg(ap + len, pcontrol,
2440 target);
2441 len += resp_caching_pg(ap + len, pcontrol,
2442 target);
d36da305
DG		 2443 } else if (is_zbc) {
2444 len += resp_caching_pg(ap + len, pcontrol,
2445 target);
760f3b03 2446 }
c65b1445
DG		 2447 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
2448 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
2449 if (0xff == subpcode) {
2450 len += resp_sas_pcd_m_spg(ap + len, pcontrol,
2451 target, target_dev_id);
2452 len += resp_sas_sha_m_spg(ap + len, pcontrol);
2453 }
2454 len += resp_iec_m_pg(ap + len, pcontrol, target);
760f3b03 2455 offset += len;
c65b1445 2456 } else {
22017ed2 2457 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
c65b1445 2458 return check_condition_result;
9a051019 2459 }
1da177e4
LT		 2460 break;
2461 default:
760f3b03
DG		 2462 bad_pcode = true;
2463 break;
2464 }
2465 if (bad_pcode) {
22017ed2 2466 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
1da177e4
LT		 2467 return check_condition_result;
2468 }
2469 if (msense_6)
2470 arr[0] = offset - 1;
773642d9
DG		 2471 else
2472 put_unaligned_be16((offset - 2), arr + 0);
87c715dc 2473 return fill_from_dev_buffer(scp, arr, min_t(int, alloc_len, offset));
1da177e4
LT		 2474}
2475
c65b1445
DG		 2476#define SDEBUG_MAX_MSELECT_SZ 512
2477
fd32119b
DG		 2478static int resp_mode_select(struct scsi_cmnd *scp,
2479 struct sdebug_dev_info *devip)
c65b1445
DG		 2480{
2481 int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
c2248fc9 2482 int param_len, res, mpage;
c65b1445 2483 unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
01123ef4 2484 unsigned char *cmd = scp->cmnd;
c2248fc9 2485 int mselect6 = (MODE_SELECT == cmd[0]);
c65b1445 2486
c65b1445
DG		 2487 memset(arr, 0, sizeof(arr));
2488 pf = cmd[1] & 0x10;
2489 sp = cmd[1] & 0x1;
773642d9 2490 param_len = mselect6 ? cmd[4] : get_unaligned_be16(cmd + 7);
c65b1445 2491 if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
22017ed2 2492 mk_sense_invalid_fld(scp, SDEB_IN_CDB, mselect6 ? 4 : 7, -1);
c65b1445
DG		 2493 return check_condition_result;
2494 }
9a051019
DG		 2495 res = fetch_to_dev_buffer(scp, arr, param_len);
2496 if (-1 == res)
773642d9
DG		 2497 return DID_ERROR << 16;
2498 else if (sdebug_verbose && (res < param_len))
cbf67842
DG		 2499 sdev_printk(KERN_INFO, scp->device,
2500 "%s: cdb indicated=%d, IO sent=%d bytes\n",
2501 __func__, param_len, res);
773642d9
DG		 2502 md_len = mselect6 ? (arr[0] + 1) : (get_unaligned_be16(arr + 0) + 2);
2503 bd_len = mselect6 ? arr[3] : get_unaligned_be16(arr + 6);
23183910 2504 if (md_len > 2) {
22017ed2 2505 mk_sense_invalid_fld(scp, SDEB_IN_DATA, 0, -1);
c65b1445
DG		 2506 return check_condition_result;
2507 }
2508 off = bd_len + (mselect6 ? 4 : 8);
2509 mpage = arr[off] & 0x3f;
2510 ps = !!(arr[off] & 0x80);
2511 if (ps) {
22017ed2 2512 mk_sense_invalid_fld(scp, SDEB_IN_DATA, off, 7);
c65b1445
DG		 2513 return check_condition_result;
2514 }
2515 spf = !!(arr[off] & 0x40);
773642d9 2516 pg_len = spf ? (get_unaligned_be16(arr + off + 2) + 4) :
c65b1445
DG		 2517 (arr[off + 1] + 2);
2518 if ((pg_len + off) > param_len) {
cbf67842 2519 mk_sense_buffer(scp, ILLEGAL_REQUEST,
c65b1445
DG		 2520 PARAMETER_LIST_LENGTH_ERR, 0);
2521 return check_condition_result;
2522 }
2523 switch (mpage) {
cbf67842
DG		 2524 case 0x8: /* Caching Mode page */
2525 if (caching_pg[1] == arr[off + 1]) {
2526 memcpy(caching_pg + 2, arr + off + 2,
2527 sizeof(caching_pg) - 2);
2528 goto set_mode_changed_ua;
2529 }
2530 break;
c65b1445
DG		 2531 case 0xa: /* Control Mode page */
2532 if (ctrl_m_pg[1] == arr[off + 1]) {
2533 memcpy(ctrl_m_pg + 2, arr + off + 2,
2534 sizeof(ctrl_m_pg) - 2);
9447b6ce
MP		 2535 if (ctrl_m_pg[4] & 0x8)
2536 sdebug_wp = true;
2537 else
2538 sdebug_wp = false;
773642d9 2539 sdebug_dsense = !!(ctrl_m_pg[2] & 0x4);
cbf67842 2540 goto set_mode_changed_ua;
c65b1445
DG		 2541 }
2542 break;
2543 case 0x1c: /* Informational Exceptions Mode page */
2544 if (iec_m_pg[1] == arr[off + 1]) {
2545 memcpy(iec_m_pg + 2, arr + off + 2,
2546 sizeof(iec_m_pg) - 2);
cbf67842 2547 goto set_mode_changed_ua;
c65b1445
DG		 2548 }
2549 break;
2550 default:
2551 break;
2552 }
22017ed2 2553 mk_sense_invalid_fld(scp, SDEB_IN_DATA, off, 5);
c65b1445 2554 return check_condition_result;
cbf67842
DG		 2555set_mode_changed_ua:
2556 set_bit(SDEBUG_UA_MODE_CHANGED, devip->uas_bm);
2557 return 0;
c65b1445
DG		 2558}
2559
91d4c752 2560static int resp_temp_l_pg(unsigned char *arr)
c65b1445
DG		 2561{
2562 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
2563 0x0, 0x1, 0x3, 0x2, 0x0, 65,
2564 };
2565
9a051019
DG		 2566 memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
2567 return sizeof(temp_l_pg);
c65b1445
DG		 2568}
2569
91d4c752 2570static int resp_ie_l_pg(unsigned char *arr)
c65b1445
DG		 2571{
2572 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
2573 };
2574
9a051019 2575 memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
c65b1445
DG		 2576 if (iec_m_pg[2] & 0x4) { /* TEST bit set */
2577 arr[4] = THRESHOLD_EXCEEDED;
2578 arr[5] = 0xff;
2579 }
9a051019 2580 return sizeof(ie_l_pg);
c65b1445
DG		 2581}
2582
2583#define SDEBUG_MAX_LSENSE_SZ 512
2584
9a051019
DG		 2585static int resp_log_sense(struct scsi_cmnd *scp,
2586 struct sdebug_dev_info *devip)
c65b1445 2587{
ab17241c 2588 int ppc, sp, pcode, subpcode, alloc_len, len, n;
c65b1445 2589 unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
01123ef4 2590 unsigned char *cmd = scp->cmnd;
c65b1445 2591
c65b1445
DG		 2592 memset(arr, 0, sizeof(arr));
2593 ppc = cmd[1] & 0x2;
2594 sp = cmd[1] & 0x1;
2595 if (ppc || sp) {
22017ed2 2596 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, ppc ? 1 : 0);
c65b1445
DG		 2597 return check_condition_result;
2598 }
c65b1445 2599 pcode = cmd[2] & 0x3f;
23183910 2600 subpcode = cmd[3] & 0xff;
773642d9 2601 alloc_len = get_unaligned_be16(cmd + 7);
c65b1445 2602 arr[0] = pcode;
23183910
DG		 2603 if (0 == subpcode) {
2604 switch (pcode) {
2605 case 0x0: /* Supported log pages log page */
2606 n = 4;
2607 arr[n++] = 0x0; /* this page */
2608 arr[n++] = 0xd; /* Temperature */
2609 arr[n++] = 0x2f; /* Informational exceptions */
2610 arr[3] = n - 4;
2611 break;
2612 case 0xd: /* Temperature log page */
2613 arr[3] = resp_temp_l_pg(arr + 4);
2614 break;
2615 case 0x2f: /* Informational exceptions log page */
2616 arr[3] = resp_ie_l_pg(arr + 4);
2617 break;
2618 default:
22017ed2 2619 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
23183910
DG		 2620 return check_condition_result;
2621 }
2622 } else if (0xff == subpcode) {
2623 arr[0] |= 0x40;
2624 arr[1] = subpcode;
2625 switch (pcode) {
2626 case 0x0: /* Supported log pages and subpages log page */
2627 n = 4;
2628 arr[n++] = 0x0;
2629 arr[n++] = 0x0; /* 0,0 page */
2630 arr[n++] = 0x0;
2631 arr[n++] = 0xff; /* this page */
2632 arr[n++] = 0xd;
2633 arr[n++] = 0x0; /* Temperature */
2634 arr[n++] = 0x2f;
2635 arr[n++] = 0x0; /* Informational exceptions */
2636 arr[3] = n - 4;
2637 break;
2638 case 0xd: /* Temperature subpages */
2639 n = 4;
2640 arr[n++] = 0xd;
2641 arr[n++] = 0x0; /* Temperature */
2642 arr[3] = n - 4;
2643 break;
2644 case 0x2f: /* Informational exceptions subpages */
2645 n = 4;
2646 arr[n++] = 0x2f;
2647 arr[n++] = 0x0; /* Informational exceptions */
2648 arr[3] = n - 4;
2649 break;
2650 default:
22017ed2 2651 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
23183910
DG		 2652 return check_condition_result;
2653 }
2654 } else {
22017ed2 2655 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
c65b1445
DG		 2656 return check_condition_result;
2657 }
87c715dc 2658 len = min_t(int, get_unaligned_be16(arr + 2) + 4, alloc_len);
c65b1445 2659 return fill_from_dev_buffer(scp, arr,
87c715dc 2660 min_t(int, len, SDEBUG_MAX_INQ_ARR_SZ));
c65b1445
DG		 2661}
2662
f0d1cf93
DG		 2663static inline bool sdebug_dev_is_zoned(struct sdebug_dev_info *devip)
2664{
2665 return devip->nr_zones != 0;
2666}
2667
2668static struct sdeb_zone_state *zbc_zone(struct sdebug_dev_info *devip,
2669 unsigned long long lba)
2670{
108e36f0 2671 return &devip->zstate[lba >> devip->zsize_shift];
f0d1cf93
DG		 2672}
2673
2674static inline bool zbc_zone_is_conv(struct sdeb_zone_state *zsp)
2675{
64e14ece 2676 return zsp->z_type == ZBC_ZONE_TYPE_CNV;
f0d1cf93
DG		 2677}
2678
2679static void zbc_close_zone(struct sdebug_dev_info *devip,
2680 struct sdeb_zone_state *zsp)
2681{
2682 enum sdebug_z_cond zc;
2683
2684 if (zbc_zone_is_conv(zsp))
2685 return;
2686
2687 zc = zsp->z_cond;
2688 if (!(zc == ZC2_IMPLICIT_OPEN || zc == ZC3_EXPLICIT_OPEN))
2689 return;
2690
2691 if (zc == ZC2_IMPLICIT_OPEN)
2692 devip->nr_imp_open--;
2693 else
2694 devip->nr_exp_open--;
2695
2696 if (zsp->z_wp == zsp->z_start) {
2697 zsp->z_cond = ZC1_EMPTY;
2698 } else {
2699 zsp->z_cond = ZC4_CLOSED;
2700 devip->nr_closed++;
2701 }
2702}
2703
2704static void zbc_close_imp_open_zone(struct sdebug_dev_info *devip)
2705{
2706 struct sdeb_zone_state *zsp = &devip->zstate[0];
2707 unsigned int i;
2708
2709 for (i = 0; i < devip->nr_zones; i++, zsp++) {
2710 if (zsp->z_cond == ZC2_IMPLICIT_OPEN) {
2711 zbc_close_zone(devip, zsp);
2712 return;
2713 }
2714 }
2715}
2716
2717static void zbc_open_zone(struct sdebug_dev_info *devip,
2718 struct sdeb_zone_state *zsp, bool explicit)
2719{
2720 enum sdebug_z_cond zc;
2721
2722 if (zbc_zone_is_conv(zsp))
2723 return;
2724
2725 zc = zsp->z_cond;
2726 if ((explicit && zc == ZC3_EXPLICIT_OPEN) ||
2727 (!explicit && zc == ZC2_IMPLICIT_OPEN))
2728 return;
2729
2730 /* Close an implicit open zone if necessary */
2731 if (explicit && zsp->z_cond == ZC2_IMPLICIT_OPEN)
2732 zbc_close_zone(devip, zsp);
2733 else if (devip->max_open &&
2734 devip->nr_imp_open + devip->nr_exp_open >= devip->max_open)
2735 zbc_close_imp_open_zone(devip);
2736
2737 if (zsp->z_cond == ZC4_CLOSED)
2738 devip->nr_closed--;
2739 if (explicit) {
2740 zsp->z_cond = ZC3_EXPLICIT_OPEN;
2741 devip->nr_exp_open++;
2742 } else {
2743 zsp->z_cond = ZC2_IMPLICIT_OPEN;
2744 devip->nr_imp_open++;
2745 }
2746}
2747
2748static void zbc_inc_wp(struct sdebug_dev_info *devip,
2749 unsigned long long lba, unsigned int num)
2750{
2751 struct sdeb_zone_state *zsp = zbc_zone(devip, lba);
64e14ece 2752 unsigned long long n, end, zend = zsp->z_start + zsp->z_size;
f0d1cf93
DG		 2753
2754 if (zbc_zone_is_conv(zsp))
2755 return;
2756
64e14ece
DLM		 2757 if (zsp->z_type == ZBC_ZONE_TYPE_SWR) {
2758 zsp->z_wp += num;
2759 if (zsp->z_wp >= zend)
2760 zsp->z_cond = ZC5_FULL;
2761 return;
2762 }
2763
2764 while (num) {
2765 if (lba != zsp->z_wp)
2766 zsp->z_non_seq_resource = true;
2767
2768 end = lba + num;
2769 if (end >= zend) {
2770 n = zend - lba;
2771 zsp->z_wp = zend;
2772 } else if (end > zsp->z_wp) {
2773 n = num;
2774 zsp->z_wp = end;
2775 } else {
2776 n = num;
2777 }
2778 if (zsp->z_wp >= zend)
2779 zsp->z_cond = ZC5_FULL;
2780
2781 num -= n;
2782 lba += n;
2783 if (num) {
2784 zsp++;
2785 zend = zsp->z_start + zsp->z_size;
2786 }
2787 }
f0d1cf93
DG		 2788}
2789
2790static int check_zbc_access_params(struct scsi_cmnd *scp,
2791 unsigned long long lba, unsigned int num, bool write)
2792{
2793 struct scsi_device *sdp = scp->device;
2794 struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
2795 struct sdeb_zone_state *zsp = zbc_zone(devip, lba);
2796 struct sdeb_zone_state *zsp_end = zbc_zone(devip, lba + num - 1);
2797
2798 if (!write) {
64e14ece
DLM		 2799 if (devip->zmodel == BLK_ZONED_HA)
2800 return 0;
2801 /* For host-managed, reads cannot cross zone types boundaries */
f0d1cf93
DG		 2802 if (zsp_end != zsp &&
2803 zbc_zone_is_conv(zsp) &&
2804 !zbc_zone_is_conv(zsp_end)) {
2805 mk_sense_buffer(scp, ILLEGAL_REQUEST,
2806 LBA_OUT_OF_RANGE,
2807 READ_INVDATA_ASCQ);
2808 return check_condition_result;
2809 }
2810 return 0;
2811 }
2812
2813 /* No restrictions for writes within conventional zones */
2814 if (zbc_zone_is_conv(zsp)) {
2815 if (!zbc_zone_is_conv(zsp_end)) {
2816 mk_sense_buffer(scp, ILLEGAL_REQUEST,
2817 LBA_OUT_OF_RANGE,
2818 WRITE_BOUNDARY_ASCQ);
2819 return check_condition_result;
2820 }
2821 return 0;
2822 }
2823
64e14ece
DLM		 2824 if (zsp->z_type == ZBC_ZONE_TYPE_SWR) {
2825 /* Writes cannot cross sequential zone boundaries */
2826 if (zsp_end != zsp) {
2827 mk_sense_buffer(scp, ILLEGAL_REQUEST,
2828 LBA_OUT_OF_RANGE,
2829 WRITE_BOUNDARY_ASCQ);
2830 return check_condition_result;
2831 }
2832 /* Cannot write full zones */
2833 if (zsp->z_cond == ZC5_FULL) {
2834 mk_sense_buffer(scp, ILLEGAL_REQUEST,
2835 INVALID_FIELD_IN_CDB, 0);
2836 return check_condition_result;
2837 }
2838 /* Writes must be aligned to the zone WP */
2839 if (lba != zsp->z_wp) {
2840 mk_sense_buffer(scp, ILLEGAL_REQUEST,
2841 LBA_OUT_OF_RANGE,
2842 UNALIGNED_WRITE_ASCQ);
2843 return check_condition_result;
2844 }
f0d1cf93
DG		 2845 }
2846
2847 /* Handle implicit open of closed and empty zones */
2848 if (zsp->z_cond == ZC1_EMPTY || zsp->z_cond == ZC4_CLOSED) {
2849 if (devip->max_open &&
2850 devip->nr_exp_open >= devip->max_open) {
2851 mk_sense_buffer(scp, DATA_PROTECT,
2852 INSUFF_RES_ASC,
2853 INSUFF_ZONE_ASCQ);
2854 return check_condition_result;
2855 }
2856 zbc_open_zone(devip, zsp, false);
2857 }
2858
2859 return 0;
2860}
2861
2862static inline int check_device_access_params
2863 (struct scsi_cmnd *scp, unsigned long long lba,
2864 unsigned int num, bool write)
1da177e4 2865{
f0d1cf93
DG		 2866 struct scsi_device *sdp = scp->device;
2867 struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
2868
c65b1445 2869 if (lba + num > sdebug_capacity) {
22017ed2 2870 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
1da177e4
LT		 2871 return check_condition_result;
2872 }
c65b1445
DG		 2873 /* transfer length excessive (tie in to block limits VPD page) */
2874 if (num > sdebug_store_sectors) {
22017ed2 2875 /* needs work to find which cdb byte 'num' comes from */
cbf67842 2876 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
c65b1445
DG		 2877 return check_condition_result;
2878 }
9447b6ce
MP		 2879 if (write && unlikely(sdebug_wp)) {
2880 mk_sense_buffer(scp, DATA_PROTECT, WRITE_PROTECTED, 0x2);
2881 return check_condition_result;
2882 }
f0d1cf93
DG		 2883 if (sdebug_dev_is_zoned(devip))
2884 return check_zbc_access_params(scp, lba, num, write);
2885
19789100
FT		 2886 return 0;
2887}
2888
b6ff8ca7
DG		 2889/*
2890 * Note: if BUG_ON() fires it usually indicates a problem with the parser
2891 * tables. Perhaps a missing F_FAKE_RW or FF_MEDIA_IO flag. Response functions
2892 * that access any of the "stores" in struct sdeb_store_info should call this
2893 * function with bug_if_fake_rw set to true.
2894 */
2895static inline struct sdeb_store_info *devip2sip(struct sdebug_dev_info *devip,
2896 bool bug_if_fake_rw)
87c715dc 2897{
b6ff8ca7
DG		 2898 if (sdebug_fake_rw) {
2899 BUG_ON(bug_if_fake_rw); /* See note above */
2900 return NULL;
2901 }
2902 return xa_load(per_store_ap, devip->sdbg_host->si_idx);
87c715dc
DG		 2903}
2904
a4517511 2905/* Returns number of bytes copied or -1 if error. */
87c715dc
DG		 2906static int do_device_access(struct sdeb_store_info *sip, struct scsi_cmnd *scp,
2907 u32 sg_skip, u64 lba, u32 num, bool do_write)
19789100
FT		 2908{
2909 int ret;
c2248fc9 2910 u64 block, rest = 0;
a4517511 2911 enum dma_data_direction dir;
87c715dc
DG		 2912 struct scsi_data_buffer *sdb = &scp->sdb;
2913 u8 *fsp;
a4517511 2914
c2248fc9 2915 if (do_write) {
a4517511 2916 dir = DMA_TO_DEVICE;
4f2c8bf6 2917 write_since_sync = true;
a4517511 2918 } else {
a4517511 2919 dir = DMA_FROM_DEVICE;
a4517511 2920 }
19789100 2921
87c715dc 2922 if (!sdb->length || !sip)
a4517511 2923 return 0;
87c715dc 2924 if (scp->sc_data_direction != dir)
a4517511 2925 return -1;
87c715dc 2926 fsp = sip->storep;
19789100
FT		 2927
2928 block = do_div(lba, sdebug_store_sectors);
2929 if (block + num > sdebug_store_sectors)
2930 rest = block + num - sdebug_store_sectors;
2931
386ecb12 2932 ret = sg_copy_buffer(sdb->table.sgl, sdb->table.nents,
87c715dc 2933 fsp + (block * sdebug_sector_size),
0a7e69c7 2934 (num - rest) * sdebug_sector_size, sg_skip, do_write);
773642d9 2935 if (ret != (num - rest) * sdebug_sector_size)
a4517511
AM		 2936 return ret;
2937
2938 if (rest) {
386ecb12 2939 ret += sg_copy_buffer(sdb->table.sgl, sdb->table.nents,
87c715dc 2940 fsp, rest * sdebug_sector_size,
0a7e69c7
DG		 2941 sg_skip + ((num - rest) * sdebug_sector_size),
2942 do_write);
a4517511 2943 }
19789100
FT		 2944
2945 return ret;
2946}
2947
87c715dc
DG		 2948/* Returns number of bytes copied or -1 if error. */
2949static int do_dout_fetch(struct scsi_cmnd *scp, u32 num, u8 *doutp)
2950{
2951 struct scsi_data_buffer *sdb = &scp->sdb;
2952
2953 if (!sdb->length)
2954 return 0;
2955 if (scp->sc_data_direction != DMA_TO_DEVICE)
2956 return -1;
2957 return sg_copy_buffer(sdb->table.sgl, sdb->table.nents, doutp,
2958 num * sdebug_sector_size, 0, true);
2959}
2960
2961/* If sip->storep+lba compares equal to arr(num), then copy top half of
2962 * arr into sip->storep+lba and return true. If comparison fails then
38d5c833 2963 * return false. */
87c715dc 2964static bool comp_write_worker(struct sdeb_store_info *sip, u64 lba, u32 num,
c3e2fe92 2965 const u8 *arr, bool compare_only)
38d5c833
DG		 2966{
2967 bool res;
2968 u64 block, rest = 0;
2969 u32 store_blks = sdebug_store_sectors;
773642d9 2970 u32 lb_size = sdebug_sector_size;
87c715dc 2971 u8 *fsp = sip->storep;
38d5c833
DG		 2972
2973 block = do_div(lba, store_blks);
2974 if (block + num > store_blks)
2975 rest = block + num - store_blks;
2976
87c715dc 2977 res = !memcmp(fsp + (block * lb_size), arr, (num - rest) * lb_size);
38d5c833
DG		 2978 if (!res)
2979 return res;
2980 if (rest)
87c715dc 2981 res = memcmp(fsp, arr + ((num - rest) * lb_size),
38d5c833
DG		 2982 rest * lb_size);
2983 if (!res)
2984 return res;
c3e2fe92
DG		 2985 if (compare_only)
2986 return true;
38d5c833 2987 arr += num * lb_size;
87c715dc 2988 memcpy(fsp + (block * lb_size), arr, (num - rest) * lb_size);
38d5c833 2989 if (rest)
87c715dc 2990 memcpy(fsp, arr + ((num - rest) * lb_size), rest * lb_size);
38d5c833
DG		 2991 return res;
2992}
2993
51d648af 2994static __be16 dif_compute_csum(const void *buf, int len)
beb40ea4 2995{
51d648af 2996 __be16 csum;
beb40ea4 2997
773642d9 2998 if (sdebug_guard)
51d648af
AM		 2999 csum = (__force __be16)ip_compute_csum(buf, len);
3000 else
beb40ea4 3001 csum = cpu_to_be16(crc_t10dif(buf, len));
51d648af 3002
beb40ea4
AM		 3003 return csum;
3004}
3005
6ebf105c 3006static int dif_verify(struct t10_pi_tuple *sdt, const void *data,
beb40ea4
AM		 3007 sector_t sector, u32 ei_lba)
3008{
773642d9 3009 __be16 csum = dif_compute_csum(data, sdebug_sector_size);
beb40ea4
AM		 3010
3011 if (sdt->guard_tag != csum) {
c1287970 3012 pr_err("GUARD check failed on sector %lu rcvd 0x%04x, data 0x%04x\n",
beb40ea4
AM		 3013 (unsigned long)sector,
3014 be16_to_cpu(sdt->guard_tag),
3015 be16_to_cpu(csum));
3016 return 0x01;
3017 }
8475c811 3018 if (sdebug_dif == T10_PI_TYPE1_PROTECTION &&
beb40ea4 3019 be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
c1287970
TW		 3020 pr_err("REF check failed on sector %lu\n",
3021 (unsigned long)sector);
beb40ea4
AM		 3022 return 0x03;
3023 }
8475c811 3024 if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
beb40ea4 3025 be32_to_cpu(sdt->ref_tag) != ei_lba) {
c1287970
TW		 3026 pr_err("REF check failed on sector %lu\n",
3027 (unsigned long)sector);
beb40ea4
AM		 3028 return 0x03;
3029 }
3030 return 0;
3031}
3032
87c715dc 3033static void dif_copy_prot(struct scsi_cmnd *scp, sector_t sector,
65f72f2a 3034 unsigned int sectors, bool read)
c6a44287 3035{
be4e11be 3036 size_t resid;
c6a44287 3037 void *paddr;
87c715dc 3038 struct sdeb_store_info *sip = devip2sip((struct sdebug_dev_info *)
b6ff8ca7 3039 scp->device->hostdata, true);
87c715dc 3040 struct t10_pi_tuple *dif_storep = sip->dif_storep;
14faa944 3041 const void *dif_store_end = dif_storep + sdebug_store_sectors;
be4e11be 3042 struct sg_mapping_iter miter;
c6a44287 3043
e18d8bea
AM		 3044 /* Bytes of protection data to copy into sgl */
3045 resid = sectors * sizeof(*dif_storep);
c6a44287 3046
87c715dc
DG		 3047 sg_miter_start(&miter, scsi_prot_sglist(scp),
3048 scsi_prot_sg_count(scp), SG_MITER_ATOMIC |
3049 (read ? SG_MITER_TO_SG : SG_MITER_FROM_SG));
be4e11be
AM		 3050
3051 while (sg_miter_next(&miter) && resid > 0) {
87c715dc
DG		 3052 size_t len = min_t(size_t, miter.length, resid);
3053 void *start = dif_store(sip, sector);
be4e11be 3054 size_t rest = 0;
14faa944
AM		 3055
3056 if (dif_store_end < start + len)
3057 rest = start + len - dif_store_end;
c6a44287 3058
be4e11be 3059 paddr = miter.addr;
14faa944 3060
65f72f2a
AM		 3061 if (read)
3062 memcpy(paddr, start, len - rest);
3063 else
3064 memcpy(start, paddr, len - rest);
3065
3066 if (rest) {
3067 if (read)
3068 memcpy(paddr + len - rest, dif_storep, rest);
3069 else
3070 memcpy(dif_storep, paddr + len - rest, rest);
3071 }
c6a44287 3072
e18d8bea 3073 sector += len / sizeof(*dif_storep);
c6a44287 3074 resid -= len;
c6a44287 3075 }
be4e11be 3076 sg_miter_stop(&miter);
bb8c063c
AM		 3077}
3078
87c715dc 3079static int prot_verify_read(struct scsi_cmnd *scp, sector_t start_sec,
bb8c063c
AM		 3080 unsigned int sectors, u32 ei_lba)
3081{
3082 unsigned int i;
bb8c063c 3083 sector_t sector;
87c715dc 3084 struct sdeb_store_info *sip = devip2sip((struct sdebug_dev_info *)
b6ff8ca7 3085 scp->device->hostdata, true);
87c715dc 3086 struct t10_pi_tuple *sdt;
bb8c063c 3087
c45eabec 3088 for (i = 0; i < sectors; i++, ei_lba++) {
bb8c063c
AM		 3089 int ret;
3090
3091 sector = start_sec + i;
87c715dc 3092 sdt = dif_store(sip, sector);
bb8c063c 3093
51d648af 3094 if (sdt->app_tag == cpu_to_be16(0xffff))
bb8c063c
AM		 3095 continue;
3096
87c715dc
DG		 3097 ret = dif_verify(sdt, lba2fake_store(sip, sector), sector,
3098 ei_lba);
bb8c063c
AM		 3099 if (ret) {
3100 dif_errors++;
3101 return ret;
3102 }
bb8c063c 3103 }
c6a44287 3104
87c715dc 3105 dif_copy_prot(scp, start_sec, sectors, true);
c6a44287
MP		 3106 dix_reads++;
3107
3108 return 0;
3109}
3110
fd32119b 3111static int resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
19789100 3112{
87c715dc 3113 bool check_prot;
c2248fc9
DG		 3114 u32 num;
3115 u32 ei_lba;
19789100 3116 int ret;
87c715dc 3117 u64 lba;
b6ff8ca7 3118 struct sdeb_store_info *sip = devip2sip(devip, true);
87c715dc
DG		 3119 rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
3120 u8 *cmd = scp->cmnd;
19789100 3121
c2248fc9
DG		 3122 switch (cmd[0]) {
3123 case READ_16:
3124 ei_lba = 0;
3125 lba = get_unaligned_be64(cmd + 2);
3126 num = get_unaligned_be32(cmd + 10);
3127 check_prot = true;
3128 break;
3129 case READ_10:
3130 ei_lba = 0;
3131 lba = get_unaligned_be32(cmd + 2);
3132 num = get_unaligned_be16(cmd + 7);
3133 check_prot = true;
3134 break;
3135 case READ_6:
3136 ei_lba = 0;
3137 lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
3138 (u32)(cmd[1] & 0x1f) << 16;
3139 num = (0 == cmd[4]) ? 256 : cmd[4];
3140 check_prot = true;
3141 break;
3142 case READ_12:
3143 ei_lba = 0;
3144 lba = get_unaligned_be32(cmd + 2);
3145 num = get_unaligned_be32(cmd + 6);
3146 check_prot = true;
3147 break;
3148 case XDWRITEREAD_10:
3149 ei_lba = 0;
3150 lba = get_unaligned_be32(cmd + 2);
3151 num = get_unaligned_be16(cmd + 7);
3152 check_prot = false;
3153 break;
3154 default: /* assume READ(32) */
3155 lba = get_unaligned_be64(cmd + 12);
3156 ei_lba = get_unaligned_be32(cmd + 20);
3157 num = get_unaligned_be32(cmd + 28);
3158 check_prot = false;
3159 break;
3160 }
f46eb0e9 3161 if (unlikely(have_dif_prot && check_prot)) {
8475c811 3162 if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
c2248fc9
DG		 3163 (cmd[1] & 0xe0)) {
3164 mk_sense_invalid_opcode(scp);
3165 return check_condition_result;
3166 }
8475c811
CH		 3167 if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3168 sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
c2248fc9
DG		 3169 (cmd[1] & 0xe0) == 0)
3170 sdev_printk(KERN_ERR, scp->device, "Unprotected RD "
3171 "to DIF device\n");
3172 }
3a90a63d
DG		 3173 if (unlikely((sdebug_opts & SDEBUG_OPT_SHORT_TRANSFER) &&
3174 atomic_read(&sdeb_inject_pending))) {
3175 num /= 2;
3176 atomic_set(&sdeb_inject_pending, 0);
3177 }
c2248fc9 3178
9447b6ce
MP		 3179 ret = check_device_access_params(scp, lba, num, false);
3180 if (ret)
3181 return ret;
f46eb0e9 3182 if (unlikely((SDEBUG_OPT_MEDIUM_ERR & sdebug_opts) &&
d9da891a
LO		 3183 (lba <= (sdebug_medium_error_start + sdebug_medium_error_count - 1)) &&
3184 ((lba + num) > sdebug_medium_error_start))) {
c65b1445 3185 /* claim unrecoverable read error */
c2248fc9 3186 mk_sense_buffer(scp, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 0);
c65b1445 3187 /* set info field and valid bit for fixed descriptor */
c2248fc9
DG		 3188 if (0x70 == (scp->sense_buffer[0] & 0x7f)) {
3189 scp->sense_buffer[0] |= 0x80; /* Valid bit */
32f7ef73
DG		 3190 ret = (lba < OPT_MEDIUM_ERR_ADDR)
3191 ? OPT_MEDIUM_ERR_ADDR : (int)lba;
c2248fc9 3192 put_unaligned_be32(ret, scp->sense_buffer + 3);
c65b1445 3193 }
c2248fc9 3194 scsi_set_resid(scp, scsi_bufflen(scp));
1da177e4
LT		 3195 return check_condition_result;
3196 }
c6a44287 3197
67da413f 3198 read_lock(macc_lckp);
6c78cc06 3199
c6a44287 3200 /* DIX + T10 DIF */
f46eb0e9 3201 if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
c2248fc9 3202 int prot_ret = prot_verify_read(scp, lba, num, ei_lba);
c6a44287
MP		 3203
3204 if (prot_ret) {
67da413f 3205 read_unlock(macc_lckp);
c2248fc9 3206 mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, prot_ret);
c6a44287
MP		 3207 return illegal_condition_result;
3208 }
3209 }
3210
87c715dc 3211 ret = do_device_access(sip, scp, 0, lba, num, false);
67da413f 3212 read_unlock(macc_lckp);
f46eb0e9 3213 if (unlikely(ret == -1))
a4517511
AM		 3214 return DID_ERROR << 16;
3215
42d387be 3216 scsi_set_resid(scp, scsi_bufflen(scp) - ret);
a4517511 3217
3a90a63d
DG		 3218 if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
3219 atomic_read(&sdeb_inject_pending))) {
3220 if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
3221 mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
3222 atomic_set(&sdeb_inject_pending, 0);
c2248fc9 3223 return check_condition_result;
3a90a63d 3224 } else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
c2248fc9
DG		 3225 /* Logical block guard check failed */
3226 mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
3a90a63d 3227 atomic_set(&sdeb_inject_pending, 0);
c2248fc9 3228 return illegal_condition_result;
3a90a63d 3229 } else if (SDEBUG_OPT_DIX_ERR & sdebug_opts) {
c2248fc9 3230 mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
3a90a63d 3231 atomic_set(&sdeb_inject_pending, 0);
c2248fc9
DG		 3232 return illegal_condition_result;
3233 }
3234 }
a4517511 3235 return 0;
1da177e4
LT		 3236}
3237
58a8635d 3238static void dump_sector(unsigned char *buf, int len)
c6a44287 3239{
cbf67842 3240 int i, j, n;
c6a44287 3241
cbf67842 3242 pr_err(">>> Sector Dump <<<\n");
c6a44287 3243 for (i = 0 ; i < len ; i += 16) {
cbf67842 3244 char b[128];
c6a44287 3245
cbf67842 3246 for (j = 0, n = 0; j < 16; j++) {
c6a44287 3247 unsigned char c = buf[i+j];
cbf67842 3248
c6a44287 3249 if (c >= 0x20 && c < 0x7e)
cbf67842
DG		 3250 n += scnprintf(b + n, sizeof(b) - n,
3251 " %c ", buf[i+j]);
c6a44287 3252 else
cbf67842
DG		 3253 n += scnprintf(b + n, sizeof(b) - n,
3254 "%02x ", buf[i+j]);
c6a44287 3255 }
cbf67842 3256 pr_err("%04d: %s\n", i, b);
c6a44287
MP		 3257 }
3258}
3259
3260static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
395cef03 3261 unsigned int sectors, u32 ei_lba)
c6a44287 3262{
be4e11be 3263 int ret;
6ebf105c 3264 struct t10_pi_tuple *sdt;
be4e11be 3265 void *daddr;
65f72f2a 3266 sector_t sector = start_sec;
c6a44287 3267 int ppage_offset;
be4e11be
AM		 3268 int dpage_offset;
3269 struct sg_mapping_iter diter;
3270 struct sg_mapping_iter piter;
c6a44287 3271
c6a44287
MP		 3272 BUG_ON(scsi_sg_count(SCpnt) == 0);
3273 BUG_ON(scsi_prot_sg_count(SCpnt) == 0);
3274
be4e11be
AM		 3275 sg_miter_start(&piter, scsi_prot_sglist(SCpnt),
3276 scsi_prot_sg_count(SCpnt),
3277 SG_MITER_ATOMIC | SG_MITER_FROM_SG);
3278 sg_miter_start(&diter, scsi_sglist(SCpnt), scsi_sg_count(SCpnt),
3279 SG_MITER_ATOMIC | SG_MITER_FROM_SG);
3280
3281 /* For each protection page */
3282 while (sg_miter_next(&piter)) {
3283 dpage_offset = 0;
3284 if (WARN_ON(!sg_miter_next(&diter))) {
3285 ret = 0x01;
3286 goto out;
3287 }
c6a44287 3288
be4e11be 3289 for (ppage_offset = 0; ppage_offset < piter.length;
6ebf105c 3290 ppage_offset += sizeof(struct t10_pi_tuple)) {
c6a44287 3291 /* If we're at the end of the current
be4e11be 3292 * data page advance to the next one
c6a44287 3293 */
be4e11be
AM		 3294 if (dpage_offset >= diter.length) {
3295 if (WARN_ON(!sg_miter_next(&diter))) {
3296 ret = 0x01;
3297 goto out;
3298 }
3299 dpage_offset = 0;
c6a44287
MP		 3300 }
3301
be4e11be
AM		 3302 sdt = piter.addr + ppage_offset;
3303 daddr = diter.addr + dpage_offset;
c6a44287 3304
be4e11be 3305 ret = dif_verify(sdt, daddr, sector, ei_lba);
beb40ea4 3306 if (ret) {
773642d9 3307 dump_sector(daddr, sdebug_sector_size);
395cef03
MP		 3308 goto out;
3309 }
3310
c6a44287 3311 sector++;
395cef03 3312 ei_lba++;
773642d9 3313 dpage_offset += sdebug_sector_size;
c6a44287 3314 }
be4e11be
AM		 3315 diter.consumed = dpage_offset;
3316 sg_miter_stop(&diter);
c6a44287 3317 }
be4e11be 3318 sg_miter_stop(&piter);
c6a44287 3319
65f72f2a 3320 dif_copy_prot(SCpnt, start_sec, sectors, false);
c6a44287
MP		 3321 dix_writes++;
3322
3323 return 0;
3324
3325out:
3326 dif_errors++;
be4e11be
AM		 3327 sg_miter_stop(&diter);
3328 sg_miter_stop(&piter);
c6a44287
MP		 3329 return ret;
3330}
3331
b90ebc3d
AM		 3332static unsigned long lba_to_map_index(sector_t lba)
3333{
773642d9
DG		 3334 if (sdebug_unmap_alignment)
3335 lba += sdebug_unmap_granularity - sdebug_unmap_alignment;
3336 sector_div(lba, sdebug_unmap_granularity);
b90ebc3d
AM		 3337 return lba;
3338}
3339
3340static sector_t map_index_to_lba(unsigned long index)
44d92694 3341{
773642d9 3342 sector_t lba = index * sdebug_unmap_granularity;
a027b5b9 3343
773642d9
DG		 3344 if (sdebug_unmap_alignment)
3345 lba -= sdebug_unmap_granularity - sdebug_unmap_alignment;
a027b5b9 3346 return lba;
b90ebc3d 3347}
44d92694 3348
87c715dc
DG		 3349static unsigned int map_state(struct sdeb_store_info *sip, sector_t lba,
3350 unsigned int *num)
b90ebc3d
AM		 3351{
3352 sector_t end;
3353 unsigned int mapped;
3354 unsigned long index;
3355 unsigned long next;
44d92694 3356
b90ebc3d 3357 index = lba_to_map_index(lba);
87c715dc 3358 mapped = test_bit(index, sip->map_storep);
44d92694
MP		 3359
3360 if (mapped)
87c715dc 3361 next = find_next_zero_bit(sip->map_storep, map_size, index);
44d92694 3362 else
87c715dc 3363 next = find_next_bit(sip->map_storep, map_size, index);
44d92694 3364
b90ebc3d 3365 end = min_t(sector_t, sdebug_store_sectors, map_index_to_lba(next));
44d92694 3366 *num = end - lba;
44d92694
MP		 3367 return mapped;
3368}
3369
87c715dc
DG		 3370static void map_region(struct sdeb_store_info *sip, sector_t lba,
3371 unsigned int len)
44d92694 3372{
44d92694
MP		 3373 sector_t end = lba + len;
3374
44d92694 3375 while (lba < end) {
b90ebc3d 3376 unsigned long index = lba_to_map_index(lba);
44d92694 3377
b90ebc3d 3378 if (index < map_size)
87c715dc 3379 set_bit(index, sip->map_storep);
44d92694 3380
b90ebc3d 3381 lba = map_index_to_lba(index + 1);
44d92694
MP		 3382 }
3383}
3384
87c715dc
DG		 3385static void unmap_region(struct sdeb_store_info *sip, sector_t lba,
3386 unsigned int len)
44d92694 3387{
44d92694 3388 sector_t end = lba + len;
87c715dc 3389 u8 *fsp = sip->storep;
44d92694 3390
44d92694 3391 while (lba < end) {
b90ebc3d 3392 unsigned long index = lba_to_map_index(lba);
44d92694 3393
b90ebc3d 3394 if (lba == map_index_to_lba(index) &&
773642d9 3395 lba + sdebug_unmap_granularity <= end &&
b90ebc3d 3396 index < map_size) {
87c715dc 3397 clear_bit(index, sip->map_storep);
760f3b03 3398 if (sdebug_lbprz) { /* for LBPRZ=2 return 0xff_s */
87c715dc 3399 memset(fsp + lba * sdebug_sector_size,
760f3b03 3400 (sdebug_lbprz & 1) ? 0 : 0xff,
773642d9
DG		 3401 sdebug_sector_size *
3402 sdebug_unmap_granularity);
b90ebc3d 3403 }
87c715dc
DG		 3404 if (sip->dif_storep) {
3405 memset(sip->dif_storep + lba, 0xff,
3406 sizeof(*sip->dif_storep) *
773642d9 3407 sdebug_unmap_granularity);
e9926b43 3408 }
be1dd78d 3409 }
b90ebc3d 3410 lba = map_index_to_lba(index + 1);
44d92694
MP		 3411 }
3412}
3413
fd32119b 3414static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
1da177e4 3415{
87c715dc 3416 bool check_prot;
c2248fc9
DG		 3417 u32 num;
3418 u32 ei_lba;
19789100 3419 int ret;
87c715dc 3420 u64 lba;
b6ff8ca7
DG		 3421 struct sdeb_store_info *sip = devip2sip(devip, true);
3422 rwlock_t *macc_lckp = &sip->macc_lck;
87c715dc 3423 u8 *cmd = scp->cmnd;
1da177e4 3424
c2248fc9
DG		 3425 switch (cmd[0]) {
3426 case WRITE_16:
3427 ei_lba = 0;
3428 lba = get_unaligned_be64(cmd + 2);
3429 num = get_unaligned_be32(cmd + 10);
3430 check_prot = true;
3431 break;
3432 case WRITE_10:
3433 ei_lba = 0;
3434 lba = get_unaligned_be32(cmd + 2);
3435 num = get_unaligned_be16(cmd + 7);
3436 check_prot = true;
3437 break;
3438 case WRITE_6:
3439 ei_lba = 0;
3440 lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
3441 (u32)(cmd[1] & 0x1f) << 16;
3442 num = (0 == cmd[4]) ? 256 : cmd[4];
3443 check_prot = true;
3444 break;
3445 case WRITE_12:
3446 ei_lba = 0;
3447 lba = get_unaligned_be32(cmd + 2);
3448 num = get_unaligned_be32(cmd + 6);
3449 check_prot = true;
3450 break;
3451 case 0x53: /* XDWRITEREAD(10) */
3452 ei_lba = 0;
3453 lba = get_unaligned_be32(cmd + 2);
3454 num = get_unaligned_be16(cmd + 7);
3455 check_prot = false;
3456 break;
3457 default: /* assume WRITE(32) */
3458 lba = get_unaligned_be64(cmd + 12);
3459 ei_lba = get_unaligned_be32(cmd + 20);
3460 num = get_unaligned_be32(cmd + 28);
3461 check_prot = false;
3462 break;
3463 }
f46eb0e9 3464 if (unlikely(have_dif_prot && check_prot)) {
8475c811 3465 if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
c2248fc9
DG		 3466 (cmd[1] & 0xe0)) {
3467 mk_sense_invalid_opcode(scp);
3468 return check_condition_result;
3469 }
8475c811
CH		 3470 if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3471 sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
c2248fc9
DG		 3472 (cmd[1] & 0xe0) == 0)
3473 sdev_printk(KERN_ERR, scp->device, "Unprotected WR "
3474 "to DIF device\n");
3475 }
f0d1cf93
DG		 3476
3477 write_lock(macc_lckp);
9447b6ce 3478 ret = check_device_access_params(scp, lba, num, true);
f0d1cf93
DG		 3479 if (ret) {
3480 write_unlock(macc_lckp);
9447b6ce 3481 return ret;
f0d1cf93 3482 }
6c78cc06 3483
c6a44287 3484 /* DIX + T10 DIF */
f46eb0e9 3485 if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
c2248fc9 3486 int prot_ret = prot_verify_write(scp, lba, num, ei_lba);
c6a44287
MP		 3487
3488 if (prot_ret) {
67da413f 3489 write_unlock(macc_lckp);
c2248fc9 3490 mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, prot_ret);
c6a44287
MP		 3491 return illegal_condition_result;
3492 }
3493 }
3494
87c715dc 3495 ret = do_device_access(sip, scp, 0, lba, num, true);
f46eb0e9 3496 if (unlikely(scsi_debug_lbp()))
87c715dc 3497 map_region(sip, lba, num);
f0d1cf93
DG		 3498 /* If ZBC zone then bump its write pointer */
3499 if (sdebug_dev_is_zoned(devip))
3500 zbc_inc_wp(devip, lba, num);
67da413f 3501 write_unlock(macc_lckp);
f46eb0e9 3502 if (unlikely(-1 == ret))
773642d9 3503 return DID_ERROR << 16;
c4837394
DG		 3504 else if (unlikely(sdebug_verbose &&
3505 (ret < (num * sdebug_sector_size))))
c2248fc9 3506 sdev_printk(KERN_INFO, scp->device,
cbf67842 3507 "%s: write: cdb indicated=%u, IO sent=%d bytes\n",
773642d9 3508 my_name, num * sdebug_sector_size, ret);
44d92694 3509
3a90a63d
DG		 3510 if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
3511 atomic_read(&sdeb_inject_pending))) {
3512 if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
3513 mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
3514 atomic_set(&sdeb_inject_pending, 0);
3515 return check_condition_result;
3516 } else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
3517 /* Logical block guard check failed */
3518 mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
3519 atomic_set(&sdeb_inject_pending, 0);
3520 return illegal_condition_result;
3521 } else if (sdebug_opts & SDEBUG_OPT_DIX_ERR) {
3522 mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
3523 atomic_set(&sdeb_inject_pending, 0);
3524 return illegal_condition_result;
c2248fc9
DG		 3525 }
3526 }
44d92694
MP		 3527 return 0;
3528}
3529
481b5e5c
DG		 3530/*
3531 * T10 has only specified WRITE SCATTERED(16) and WRITE SCATTERED(32).
3532 * No READ GATHERED yet (requires bidi or long cdb holding gather list).
3533 */
3534static int resp_write_scat(struct scsi_cmnd *scp,
3535 struct sdebug_dev_info *devip)
3536{
3537 u8 *cmd = scp->cmnd;
3538 u8 *lrdp = NULL;
3539 u8 *up;
b6ff8ca7
DG		 3540 struct sdeb_store_info *sip = devip2sip(devip, true);
3541 rwlock_t *macc_lckp = &sip->macc_lck;
481b5e5c
DG		 3542 u8 wrprotect;
3543 u16 lbdof, num_lrd, k;
3544 u32 num, num_by, bt_len, lbdof_blen, sg_off, cum_lb;
3545 u32 lb_size = sdebug_sector_size;
3546 u32 ei_lba;
3547 u64 lba;
481b5e5c
DG		 3548 int ret, res;
3549 bool is_16;
3550 static const u32 lrd_size = 32; /* + parameter list header size */
3551
3552 if (cmd[0] == VARIABLE_LENGTH_CMD) {
3553 is_16 = false;
3554 wrprotect = (cmd[10] >> 5) & 0x7;
3555 lbdof = get_unaligned_be16(cmd + 12);
3556 num_lrd = get_unaligned_be16(cmd + 16);
3557 bt_len = get_unaligned_be32(cmd + 28);
3558 } else { /* that leaves WRITE SCATTERED(16) */
3559 is_16 = true;
3560 wrprotect = (cmd[2] >> 5) & 0x7;
3561 lbdof = get_unaligned_be16(cmd + 4);
3562 num_lrd = get_unaligned_be16(cmd + 8);
3563 bt_len = get_unaligned_be32(cmd + 10);
3564 if (unlikely(have_dif_prot)) {
3565 if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
3566 wrprotect) {
3567 mk_sense_invalid_opcode(scp);
3568 return illegal_condition_result;
3569 }
3570 if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3571 sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
3572 wrprotect == 0)
3573 sdev_printk(KERN_ERR, scp->device,
3574 "Unprotected WR to DIF device\n");
3575 }
3576 }
3577 if ((num_lrd == 0) || (bt_len == 0))
3578 return 0; /* T10 says these do-nothings are not errors */
3579 if (lbdof == 0) {
3580 if (sdebug_verbose)
3581 sdev_printk(KERN_INFO, scp->device,
3582 "%s: %s: LB Data Offset field bad\n",
3583 my_name, __func__);
3584 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
3585 return illegal_condition_result;
3586 }
3587 lbdof_blen = lbdof * lb_size;
3588 if ((lrd_size + (num_lrd * lrd_size)) > lbdof_blen) {
3589 if (sdebug_verbose)
3590 sdev_printk(KERN_INFO, scp->device,
3591 "%s: %s: LBA range descriptors don't fit\n",
3592 my_name, __func__);
3593 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
3594 return illegal_condition_result;
3595 }
3596 lrdp = kzalloc(lbdof_blen, GFP_ATOMIC);
3597 if (lrdp == NULL)
3598 return SCSI_MLQUEUE_HOST_BUSY;
3599 if (sdebug_verbose)
3600 sdev_printk(KERN_INFO, scp->device,
3601 "%s: %s: Fetch header+scatter_list, lbdof_blen=%u\n",
3602 my_name, __func__, lbdof_blen);
3603 res = fetch_to_dev_buffer(scp, lrdp, lbdof_blen);
3604 if (res == -1) {
3605 ret = DID_ERROR << 16;
3606 goto err_out;
3607 }
3608
67da413f 3609 write_lock(macc_lckp);
481b5e5c
DG		 3610 sg_off = lbdof_blen;
3611 /* Spec says Buffer xfer Length field in number of LBs in dout */
3612 cum_lb = 0;
3613 for (k = 0, up = lrdp + lrd_size; k < num_lrd; ++k, up += lrd_size) {
3614 lba = get_unaligned_be64(up + 0);
3615 num = get_unaligned_be32(up + 8);
3616 if (sdebug_verbose)
3617 sdev_printk(KERN_INFO, scp->device,
3618 "%s: %s: k=%d LBA=0x%llx num=%u sg_off=%u\n",
3619 my_name, __func__, k, lba, num, sg_off);
3620 if (num == 0)
3621 continue;
9447b6ce 3622 ret = check_device_access_params(scp, lba, num, true);
481b5e5c
DG		 3623 if (ret)
3624 goto err_out_unlock;
3625 num_by = num * lb_size;
3626 ei_lba = is_16 ? 0 : get_unaligned_be32(up + 12);
3627
3628 if ((cum_lb + num) > bt_len) {
3629 if (sdebug_verbose)
3630 sdev_printk(KERN_INFO, scp->device,
3631 "%s: %s: sum of blocks > data provided\n",
3632 my_name, __func__);
3633 mk_sense_buffer(scp, ILLEGAL_REQUEST, WRITE_ERROR_ASC,
3634 0);
3635 ret = illegal_condition_result;
3636 goto err_out_unlock;
3637 }
3638
3639 /* DIX + T10 DIF */
3640 if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
3641 int prot_ret = prot_verify_write(scp, lba, num,
3642 ei_lba);
3643
3644 if (prot_ret) {
3645 mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10,
3646 prot_ret);
3647 ret = illegal_condition_result;
3648 goto err_out_unlock;
3649 }
3650 }
3651
87c715dc 3652 ret = do_device_access(sip, scp, sg_off, lba, num, true);
f0d1cf93
DG		 3653 /* If ZBC zone then bump its write pointer */
3654 if (sdebug_dev_is_zoned(devip))
3655 zbc_inc_wp(devip, lba, num);
481b5e5c 3656 if (unlikely(scsi_debug_lbp()))
87c715dc 3657 map_region(sip, lba, num);
481b5e5c
DG		 3658 if (unlikely(-1 == ret)) {
3659 ret = DID_ERROR << 16;
3660 goto err_out_unlock;
3661 } else if (unlikely(sdebug_verbose && (ret < num_by)))
3662 sdev_printk(KERN_INFO, scp->device,
3663 "%s: write: cdb indicated=%u, IO sent=%d bytes\n",
3664 my_name, num_by, ret);
3665
3a90a63d
DG		 3666 if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
3667 atomic_read(&sdeb_inject_pending))) {
3668 if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
3669 mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
3670 atomic_set(&sdeb_inject_pending, 0);
3671 ret = check_condition_result;
3672 goto err_out_unlock;
3673 } else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
3674 /* Logical block guard check failed */
3675 mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
3676 atomic_set(&sdeb_inject_pending, 0);
3677 ret = illegal_condition_result;
3678 goto err_out_unlock;
3679 } else if (sdebug_opts & SDEBUG_OPT_DIX_ERR) {
3680 mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
3681 atomic_set(&sdeb_inject_pending, 0);
3682 ret = illegal_condition_result;
3683 goto err_out_unlock;
481b5e5c
DG		 3684 }
3685 }
3686 sg_off += num_by;
3687 cum_lb += num;
3688 }
3689 ret = 0;
3690err_out_unlock:
67da413f 3691 write_unlock(macc_lckp);
481b5e5c
DG		 3692err_out:
3693 kfree(lrdp);
3694 return ret;
3695}
3696
fd32119b
DG		 3697static int resp_write_same(struct scsi_cmnd *scp, u64 lba, u32 num,
3698 u32 ei_lba, bool unmap, bool ndob)
44d92694 3699{
f0d1cf93
DG		 3700 struct scsi_device *sdp = scp->device;
3701 struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
44d92694 3702 unsigned long long i;
40d07b52 3703 u64 block, lbaa;
87c715dc
DG		 3704 u32 lb_size = sdebug_sector_size;
3705 int ret;
3706 struct sdeb_store_info *sip = devip2sip((struct sdebug_dev_info *)
b6ff8ca7
DG		 3707 scp->device->hostdata, true);
3708 rwlock_t *macc_lckp = &sip->macc_lck;
40d07b52 3709 u8 *fs1p;
87c715dc 3710 u8 *fsp;
44d92694 3711
f0d1cf93
DG		 3712 write_lock(macc_lckp);
3713
9447b6ce 3714 ret = check_device_access_params(scp, lba, num, true);
f0d1cf93
DG		 3715 if (ret) {
3716 write_unlock(macc_lckp);
44d92694 3717 return ret;
f0d1cf93 3718 }
44d92694 3719
9ed8d3dc 3720 if (unmap && scsi_debug_lbp()) {
87c715dc 3721 unmap_region(sip, lba, num);
44d92694
MP		 3722 goto out;
3723 }
40d07b52
DG		 3724 lbaa = lba;
3725 block = do_div(lbaa, sdebug_store_sectors);
c2248fc9 3726 /* if ndob then zero 1 logical block, else fetch 1 logical block */
87c715dc
DG		 3727 fsp = sip->storep;
3728 fs1p = fsp + (block * lb_size);
c2248fc9 3729 if (ndob) {
40d07b52 3730 memset(fs1p, 0, lb_size);
c2248fc9
DG		 3731 ret = 0;
3732 } else
40d07b52 3733 ret = fetch_to_dev_buffer(scp, fs1p, lb_size);
44d92694
MP		 3734
3735 if (-1 == ret) {
67da413f 3736 write_unlock(&sip->macc_lck);
773642d9 3737 return DID_ERROR << 16;
40d07b52 3738 } else if (sdebug_verbose && !ndob && (ret < lb_size))
c2248fc9 3739 sdev_printk(KERN_INFO, scp->device,
e33d7c56 3740 "%s: %s: lb size=%u, IO sent=%d bytes\n",
40d07b52 3741 my_name, "write same", lb_size, ret);
44d92694
MP		 3742
3743 /* Copy first sector to remaining blocks */
40d07b52
DG		 3744 for (i = 1 ; i < num ; i++) {
3745 lbaa = lba + i;
3746 block = do_div(lbaa, sdebug_store_sectors);
87c715dc 3747 memmove(fsp + (block * lb_size), fs1p, lb_size);
40d07b52 3748 }
9ed8d3dc 3749 if (scsi_debug_lbp())
87c715dc 3750 map_region(sip, lba, num);
f0d1cf93
DG		 3751 /* If ZBC zone then bump its write pointer */
3752 if (sdebug_dev_is_zoned(devip))
3753 zbc_inc_wp(devip, lba, num);
44d92694 3754out:
67da413f 3755 write_unlock(macc_lckp);
44d92694 3756
1da177e4
LT		 3757 return 0;
3758}
3759
fd32119b
DG		 3760static int resp_write_same_10(struct scsi_cmnd *scp,
3761 struct sdebug_dev_info *devip)
c2248fc9
DG		 3762{
3763 u8 *cmd = scp->cmnd;
3764 u32 lba;
3765 u16 num;
3766 u32 ei_lba = 0;
3767 bool unmap = false;
3768
3769 if (cmd[1] & 0x8) {
773642d9 3770 if (sdebug_lbpws10 == 0) {
c2248fc9
DG		 3771 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 3);
3772 return check_condition_result;
3773 } else
3774 unmap = true;
3775 }
3776 lba = get_unaligned_be32(cmd + 2);
3777 num = get_unaligned_be16(cmd + 7);
773642d9 3778 if (num > sdebug_write_same_length) {
c2248fc9
DG		 3779 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 7, -1);
3780 return check_condition_result;
3781 }
3782 return resp_write_same(scp, lba, num, ei_lba, unmap, false);
3783}
3784
fd32119b
DG		 3785static int resp_write_same_16(struct scsi_cmnd *scp,
3786 struct sdebug_dev_info *devip)
c2248fc9
DG		 3787{
3788 u8 *cmd = scp->cmnd;
3789 u64 lba;
3790 u32 num;
3791 u32 ei_lba = 0;
3792 bool unmap = false;
3793 bool ndob = false;
3794
3795 if (cmd[1] & 0x8) { /* UNMAP */
773642d9 3796 if (sdebug_lbpws == 0) {
c2248fc9
DG		 3797 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 3);
3798 return check_condition_result;
3799 } else
3800 unmap = true;
3801 }
3802 if (cmd[1] & 0x1) /* NDOB (no data-out buffer, assumes zeroes) */
3803 ndob = true;
3804 lba = get_unaligned_be64(cmd + 2);
3805 num = get_unaligned_be32(cmd + 10);
773642d9 3806 if (num > sdebug_write_same_length) {
c2248fc9
DG		 3807 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 10, -1);
3808 return check_condition_result;
3809 }
3810 return resp_write_same(scp, lba, num, ei_lba, unmap, ndob);
3811}
3812
acafd0b9
EM		 3813/* Note the mode field is in the same position as the (lower) service action
3814 * field. For the Report supported operation codes command, SPC-4 suggests
3815 * each mode of this command should be reported separately; for future. */
fd32119b
DG		 3816static int resp_write_buffer(struct scsi_cmnd *scp,
3817 struct sdebug_dev_info *devip)
acafd0b9
EM		 3818{
3819 u8 *cmd = scp->cmnd;
3820 struct scsi_device *sdp = scp->device;
3821 struct sdebug_dev_info *dp;
3822 u8 mode;
3823
3824 mode = cmd[1] & 0x1f;
3825 switch (mode) {
3826 case 0x4: /* download microcode (MC) and activate (ACT) */
3827 /* set UAs on this device only */
3828 set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
3829 set_bit(SDEBUG_UA_MICROCODE_CHANGED, devip->uas_bm);
3830 break;
3831 case 0x5: /* download MC, save and ACT */
3832 set_bit(SDEBUG_UA_MICROCODE_CHANGED_WO_RESET, devip->uas_bm);
3833 break;
3834 case 0x6: /* download MC with offsets and ACT */
3835 /* set UAs on most devices (LUs) in this target */
3836 list_for_each_entry(dp,
3837 &devip->sdbg_host->dev_info_list,
3838 dev_list)
3839 if (dp->target == sdp->id) {
3840 set_bit(SDEBUG_UA_BUS_RESET, dp->uas_bm);
3841 if (devip != dp)
3842 set_bit(SDEBUG_UA_MICROCODE_CHANGED,
3843 dp->uas_bm);
3844 }
3845 break;
3846 case 0x7: /* download MC with offsets, save, and ACT */
3847 /* set UA on all devices (LUs) in this target */
3848 list_for_each_entry(dp,
3849 &devip->sdbg_host->dev_info_list,
3850 dev_list)
3851 if (dp->target == sdp->id)
3852 set_bit(SDEBUG_UA_MICROCODE_CHANGED_WO_RESET,
3853 dp->uas_bm);
3854 break;
3855 default:
3856 /* do nothing for this command for other mode values */
3857 break;
3858 }
3859 return 0;
3860}
3861
fd32119b
DG		 3862static int resp_comp_write(struct scsi_cmnd *scp,
3863 struct sdebug_dev_info *devip)
38d5c833
DG		 3864{
3865 u8 *cmd = scp->cmnd;
3866 u8 *arr;
b6ff8ca7
DG		 3867 struct sdeb_store_info *sip = devip2sip(devip, true);
3868 rwlock_t *macc_lckp = &sip->macc_lck;
38d5c833
DG		 3869 u64 lba;
3870 u32 dnum;
773642d9 3871 u32 lb_size = sdebug_sector_size;
38d5c833 3872 u8 num;
38d5c833 3873 int ret;
d467d31f 3874 int retval = 0;
38d5c833 3875
d467d31f 3876 lba = get_unaligned_be64(cmd + 2);
38d5c833
DG		 3877 num = cmd[13]; /* 1 to a maximum of 255 logical blocks */
3878 if (0 == num)
3879 return 0; /* degenerate case, not an error */
8475c811 3880 if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
38d5c833
DG		 3881 (cmd[1] & 0xe0)) {
3882 mk_sense_invalid_opcode(scp);
3883 return check_condition_result;
3884 }
8475c811
CH		 3885 if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3886 sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
38d5c833
DG		 3887 (cmd[1] & 0xe0) == 0)
3888 sdev_printk(KERN_ERR, scp->device, "Unprotected WR "
3889 "to DIF device\n");
9447b6ce
MP		 3890 ret = check_device_access_params(scp, lba, num, false);
3891 if (ret)
3892 return ret;
d467d31f 3893 dnum = 2 * num;
6396bb22 3894 arr = kcalloc(lb_size, dnum, GFP_ATOMIC);
d467d31f
DG		 3895 if (NULL == arr) {
3896 mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
3897 INSUFF_RES_ASCQ);
3898 return check_condition_result;
3899 }
38d5c833 3900
67da413f 3901 write_lock(macc_lckp);
38d5c833 3902
87c715dc 3903 ret = do_dout_fetch(scp, dnum, arr);
38d5c833 3904 if (ret == -1) {
d467d31f
DG		 3905 retval = DID_ERROR << 16;
3906 goto cleanup;
773642d9 3907 } else if (sdebug_verbose && (ret < (dnum * lb_size)))
38d5c833
DG		 3908 sdev_printk(KERN_INFO, scp->device, "%s: compare_write: cdb "
3909 "indicated=%u, IO sent=%d bytes\n", my_name,
3910 dnum * lb_size, ret);
c3e2fe92 3911 if (!comp_write_worker(sip, lba, num, arr, false)) {
38d5c833 3912 mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
d467d31f
DG		 3913 retval = check_condition_result;
3914 goto cleanup;
38d5c833
DG		 3915 }
3916 if (scsi_debug_lbp())
87c715dc 3917 map_region(sip, lba, num);
d467d31f 3918cleanup:
67da413f 3919 write_unlock(macc_lckp);
d467d31f
DG		 3920 kfree(arr);
3921 return retval;
38d5c833
DG		 3922}
3923
44d92694
MP		 3924struct unmap_block_desc {
3925 __be64 lba;
3926 __be32 blocks;
3927 __be32 __reserved;
3928};
3929
fd32119b 3930static int resp_unmap(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
44d92694
MP		 3931{
3932 unsigned char *buf;
3933 struct unmap_block_desc *desc;
b6ff8ca7
DG		 3934 struct sdeb_store_info *sip = devip2sip(devip, true);
3935 rwlock_t *macc_lckp = &sip->macc_lck;
44d92694
MP		 3936 unsigned int i, payload_len, descriptors;
3937 int ret;
44d92694 3938
c2248fc9
DG		 3939 if (!scsi_debug_lbp())
3940 return 0; /* fib and say its done */
3941 payload_len = get_unaligned_be16(scp->cmnd + 7);
3942 BUG_ON(scsi_bufflen(scp) != payload_len);
44d92694
MP		 3943
3944 descriptors = (payload_len - 8) / 16;
773642d9 3945 if (descriptors > sdebug_unmap_max_desc) {
c2248fc9
DG		 3946 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 7, -1);
3947 return check_condition_result;
3948 }
44d92694 3949
b333a819 3950 buf = kzalloc(scsi_bufflen(scp), GFP_ATOMIC);
c2248fc9
DG		 3951 if (!buf) {
3952 mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
3953 INSUFF_RES_ASCQ);
44d92694 3954 return check_condition_result;
c2248fc9 3955 }
44d92694 3956
c2248fc9 3957 scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
44d92694
MP		 3958
3959 BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2);
3960 BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16);
3961
3962 desc = (void *)&buf[8];
3963
67da413f 3964 write_lock(macc_lckp);
6c78cc06 3965
44d92694
MP		 3966 for (i = 0 ; i < descriptors ; i++) {
3967 unsigned long long lba = get_unaligned_be64(&desc[i].lba);
3968 unsigned int num = get_unaligned_be32(&desc[i].blocks);
3969
9447b6ce 3970 ret = check_device_access_params(scp, lba, num, true);
44d92694
MP		 3971 if (ret)
3972 goto out;
3973
87c715dc 3974 unmap_region(sip, lba, num);
44d92694
MP		 3975 }
3976
3977 ret = 0;
3978
3979out:
67da413f 3980 write_unlock(macc_lckp);
44d92694
MP		 3981 kfree(buf);
3982
3983 return ret;
3984}
3985
3986#define SDEBUG_GET_LBA_STATUS_LEN 32
3987
fd32119b
DG		 3988static int resp_get_lba_status(struct scsi_cmnd *scp,
3989 struct sdebug_dev_info *devip)
44d92694 3990{
c2248fc9
DG		 3991 u8 *cmd = scp->cmnd;
3992 u64 lba;
3993 u32 alloc_len, mapped, num;
44d92694 3994 int ret;
87c715dc 3995 u8 arr[SDEBUG_GET_LBA_STATUS_LEN];
44d92694 3996
c2248fc9
DG		 3997 lba = get_unaligned_be64(cmd + 2);
3998 alloc_len = get_unaligned_be32(cmd + 10);
44d92694
MP		 3999
4000 if (alloc_len < 24)
4001 return 0;
4002
9447b6ce 4003 ret = check_device_access_params(scp, lba, 1, false);
44d92694
MP		 4004 if (ret)
4005 return ret;
4006
b6ff8ca7
DG		 4007 if (scsi_debug_lbp()) {
4008 struct sdeb_store_info *sip = devip2sip(devip, true);
4009
87c715dc 4010 mapped = map_state(sip, lba, &num);
b6ff8ca7 4011 } else {
c2248fc9
DG		 4012 mapped = 1;
4013 /* following just in case virtual_gb changed */
4014 sdebug_capacity = get_sdebug_capacity();
4015 if (sdebug_capacity - lba <= 0xffffffff)
4016 num = sdebug_capacity - lba;
4017 else
4018 num = 0xffffffff;
4019 }
44d92694
MP		 4020
4021 memset(arr, 0, SDEBUG_GET_LBA_STATUS_LEN);
c2248fc9
DG		 4022 put_unaligned_be32(20, arr); /* Parameter Data Length */
4023 put_unaligned_be64(lba, arr + 8); /* LBA */
4024 put_unaligned_be32(num, arr + 16); /* Number of blocks */
4025 arr[20] = !mapped; /* prov_stat=0: mapped; 1: dealloc */
44d92694 4026
c2248fc9 4027 return fill_from_dev_buffer(scp, arr, SDEBUG_GET_LBA_STATUS_LEN);
44d92694
MP		 4028}
4029
80c49563
DG		 4030static int resp_sync_cache(struct scsi_cmnd *scp,
4031 struct sdebug_dev_info *devip)
4032{
4f2c8bf6 4033 int res = 0;
80c49563
DG		 4034 u64 lba;
4035 u32 num_blocks;
4036 u8 *cmd = scp->cmnd;
4037
4038 if (cmd[0] == SYNCHRONIZE_CACHE) { /* 10 byte cdb */
4039 lba = get_unaligned_be32(cmd + 2);
4040 num_blocks = get_unaligned_be16(cmd + 7);
4041 } else { /* SYNCHRONIZE_CACHE(16) */
4042 lba = get_unaligned_be64(cmd + 2);
4043 num_blocks = get_unaligned_be32(cmd + 10);
4044 }
4045 if (lba + num_blocks > sdebug_capacity) {
4046 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4047 return check_condition_result;
4048 }
fc13638a 4049 if (!write_since_sync || (cmd[1] & 0x2))
4f2c8bf6
DG		 4050 res = SDEG_RES_IMMED_MASK;
4051 else /* delay if write_since_sync and IMMED clear */
4052 write_since_sync = false;
4053 return res;
80c49563
DG		 4054}
4055
ed9f3e25
DG		 4056/*
4057 * Assuming the LBA+num_blocks is not out-of-range, this function will return
4058 * CONDITION MET if the specified blocks will/have fitted in the cache, and
4059 * a GOOD status otherwise. Model a disk with a big cache and yield
4060 * CONDITION MET. Actually tries to bring range in main memory into the
4061 * cache associated with the CPU(s).
4062 */
4063static int resp_pre_fetch(struct scsi_cmnd *scp,
4064 struct sdebug_dev_info *devip)
4065{
4066 int res = 0;
4067 u64 lba;
4068 u64 block, rest = 0;
4069 u32 nblks;
4070 u8 *cmd = scp->cmnd;
b6ff8ca7
DG		 4071 struct sdeb_store_info *sip = devip2sip(devip, true);
4072 rwlock_t *macc_lckp = &sip->macc_lck;
4073 u8 *fsp = sip->storep;
ed9f3e25
DG		 4074
4075 if (cmd[0] == PRE_FETCH) { /* 10 byte cdb */
4076 lba = get_unaligned_be32(cmd + 2);
4077 nblks = get_unaligned_be16(cmd + 7);
4078 } else { /* PRE-FETCH(16) */
4079 lba = get_unaligned_be64(cmd + 2);
4080 nblks = get_unaligned_be32(cmd + 10);
4081 }
4082 if (lba + nblks > sdebug_capacity) {
4083 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4084 return check_condition_result;
4085 }
4086 if (!fsp)
4087 goto fini;
4088 /* PRE-FETCH spec says nothing about LBP or PI so skip them */
4089 block = do_div(lba, sdebug_store_sectors);
4090 if (block + nblks > sdebug_store_sectors)
4091 rest = block + nblks - sdebug_store_sectors;
4092
4093 /* Try to bring the PRE-FETCH range into CPU's cache */
4094 read_lock(macc_lckp);
4095 prefetch_range(fsp + (sdebug_sector_size * block),
4096 (nblks - rest) * sdebug_sector_size);
4097 if (rest)
4098 prefetch_range(fsp, rest * sdebug_sector_size);
4099 read_unlock(macc_lckp);
4100fini:
4101 if (cmd[1] & 0x2)
4102 res = SDEG_RES_IMMED_MASK;
4103 return res | condition_met_result;
4104}
4105
fb0cc8d1
DG		 4106#define RL_BUCKET_ELEMS 8
4107
8d039e22
DG		 4108/* Even though each pseudo target has a REPORT LUNS "well known logical unit"
4109 * (W-LUN), the normal Linux scanning logic does not associate it with a
4110 * device (e.g. /dev/sg7). The following magic will make that association:
4111 * "cd /sys/class/scsi_host/host<n> ; echo '- - 49409' > scan"
4112 * where <n> is a host number. If there are multiple targets in a host then
4113 * the above will associate a W-LUN to each target. To only get a W-LUN
4114 * for target 2, then use "echo '- 2 49409' > scan" .
4115 */
4116static int resp_report_luns(struct scsi_cmnd *scp,
4117 struct sdebug_dev_info *devip)
1da177e4 4118{
8d039e22 4119 unsigned char *cmd = scp->cmnd;
1da177e4 4120 unsigned int alloc_len;
8d039e22 4121 unsigned char select_report;
22017ed2 4122 u64 lun;
8d039e22 4123 struct scsi_lun *lun_p;
fb0cc8d1 4124 u8 arr[RL_BUCKET_ELEMS * sizeof(struct scsi_lun)];
8d039e22
DG		 4125 unsigned int lun_cnt; /* normal LUN count (max: 256) */
4126 unsigned int wlun_cnt; /* report luns W-LUN count */
4127 unsigned int tlun_cnt; /* total LUN count */
4128 unsigned int rlen; /* response length (in bytes) */
fb0cc8d1
DG		 4129 int k, j, n, res;
4130 unsigned int off_rsp = 0;
4131 const int sz_lun = sizeof(struct scsi_lun);
1da177e4 4132
19c8ead7 4133 clear_luns_changed_on_target(devip);
8d039e22
DG		 4134
4135 select_report = cmd[2];
4136 alloc_len = get_unaligned_be32(cmd + 6);
4137
4138 if (alloc_len < 4) {
4139 pr_err("alloc len too small %d\n", alloc_len);
4140 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
1da177e4
LT		 4141 return check_condition_result;
4142 }
8d039e22
DG		 4143
4144 switch (select_report) {
4145 case 0: /* all LUNs apart from W-LUNs */
4146 lun_cnt = sdebug_max_luns;
4147 wlun_cnt = 0;
4148 break;
4149 case 1: /* only W-LUNs */
c65b1445 4150 lun_cnt = 0;
8d039e22
DG		 4151 wlun_cnt = 1;
4152 break;
4153 case 2: /* all LUNs */
4154 lun_cnt = sdebug_max_luns;
4155 wlun_cnt = 1;
4156 break;
4157 case 0x10: /* only administrative LUs */
4158 case 0x11: /* see SPC-5 */
4159 case 0x12: /* only subsiduary LUs owned by referenced LU */
4160 default:
4161 pr_debug("select report invalid %d\n", select_report);
4162 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, -1);
4163 return check_condition_result;
4164 }
4165
4166 if (sdebug_no_lun_0 && (lun_cnt > 0))
c65b1445 4167 --lun_cnt;
8d039e22
DG		 4168
4169 tlun_cnt = lun_cnt + wlun_cnt;
fb0cc8d1
DG		 4170 rlen = tlun_cnt * sz_lun; /* excluding 8 byte header */
4171 scsi_set_resid(scp, scsi_bufflen(scp));
8d039e22
DG		 4172 pr_debug("select_report %d luns = %d wluns = %d no_lun0 %d\n",
4173 select_report, lun_cnt, wlun_cnt, sdebug_no_lun_0);
4174
fb0cc8d1 4175 /* loops rely on sizeof response header same as sizeof lun (both 8) */
8d039e22 4176 lun = sdebug_no_lun_0 ? 1 : 0;
fb0cc8d1
DG		 4177 for (k = 0, j = 0, res = 0; true; ++k, j = 0) {
4178 memset(arr, 0, sizeof(arr));
4179 lun_p = (struct scsi_lun *)&arr[0];
4180 if (k == 0) {
4181 put_unaligned_be32(rlen, &arr[0]);
4182 ++lun_p;
4183 j = 1;
4184 }
4185 for ( ; j < RL_BUCKET_ELEMS; ++j, ++lun_p) {
4186 if ((k * RL_BUCKET_ELEMS) + j > lun_cnt)
4187 break;
4188 int_to_scsilun(lun++, lun_p);
ad0c7775
DG		 4189 if (lun > 1 && sdebug_lun_am == SAM_LUN_AM_FLAT)
4190 lun_p->scsi_lun[0] |= 0x40;
fb0cc8d1
DG		 4191 }
4192 if (j < RL_BUCKET_ELEMS)
4193 break;
4194 n = j * sz_lun;
4195 res = p_fill_from_dev_buffer(scp, arr, n, off_rsp);
4196 if (res)
4197 return res;
4198 off_rsp += n;
4199 }
4200 if (wlun_cnt) {
4201 int_to_scsilun(SCSI_W_LUN_REPORT_LUNS, lun_p);
4202 ++j;
4203 }
4204 if (j > 0)
4205 res = p_fill_from_dev_buffer(scp, arr, j * sz_lun, off_rsp);
8d039e22 4206 return res;
1da177e4
LT		 4207}
4208
c3e2fe92
DG		 4209static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
4210{
4211 bool is_bytchk3 = false;
4212 u8 bytchk;
4213 int ret, j;
4214 u32 vnum, a_num, off;
4215 const u32 lb_size = sdebug_sector_size;
c3e2fe92
DG		 4216 u64 lba;
4217 u8 *arr;
4218 u8 *cmd = scp->cmnd;
b6ff8ca7
DG		 4219 struct sdeb_store_info *sip = devip2sip(devip, true);
4220 rwlock_t *macc_lckp = &sip->macc_lck;
c3e2fe92
DG		 4221
4222 bytchk = (cmd[1] >> 1) & 0x3;
4223 if (bytchk == 0) {
4224 return 0; /* always claim internal verify okay */
4225 } else if (bytchk == 2) {
4226 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 2);
4227 return check_condition_result;
4228 } else if (bytchk == 3) {
4229 is_bytchk3 = true; /* 1 block sent, compared repeatedly */
4230 }
4231 switch (cmd[0]) {
4232 case VERIFY_16:
4233 lba = get_unaligned_be64(cmd + 2);
4234 vnum = get_unaligned_be32(cmd + 10);
4235 break;
4236 case VERIFY: /* is VERIFY(10) */
4237 lba = get_unaligned_be32(cmd + 2);
4238 vnum = get_unaligned_be16(cmd + 7);
4239 break;
4240 default:
4241 mk_sense_invalid_opcode(scp);
4242 return check_condition_result;
4243 }
4244 a_num = is_bytchk3 ? 1 : vnum;
4245 /* Treat following check like one for read (i.e. no write) access */
4246 ret = check_device_access_params(scp, lba, a_num, false);
4247 if (ret)
4248 return ret;
4249
4250 arr = kcalloc(lb_size, vnum, GFP_ATOMIC);
4251 if (!arr) {
4252 mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
4253 INSUFF_RES_ASCQ);
4254 return check_condition_result;
4255 }
4256 /* Not changing store, so only need read access */
67da413f 4257 read_lock(macc_lckp);
c3e2fe92
DG		 4258
4259 ret = do_dout_fetch(scp, a_num, arr);
4260 if (ret == -1) {
4261 ret = DID_ERROR << 16;
4262 goto cleanup;
4263 } else if (sdebug_verbose && (ret < (a_num * lb_size))) {
4264 sdev_printk(KERN_INFO, scp->device,
4265 "%s: %s: cdb indicated=%u, IO sent=%d bytes\n",
4266 my_name, __func__, a_num * lb_size, ret);
4267 }
4268 if (is_bytchk3) {
4269 for (j = 1, off = lb_size; j < vnum; ++j, off += lb_size)
4270 memcpy(arr + off, arr, lb_size);
4271 }
4272 ret = 0;
4273 if (!comp_write_worker(sip, lba, vnum, arr, true)) {
4274 mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
4275 ret = check_condition_result;
4276 goto cleanup;
4277 }
4278cleanup:
67da413f 4279 read_unlock(macc_lckp);
c3e2fe92
DG		 4280 kfree(arr);
4281 return ret;
4282}
4283
f0d1cf93
DG		 4284#define RZONES_DESC_HD 64
4285
4286/* Report zones depending on start LBA nad reporting options */
4287static int resp_report_zones(struct scsi_cmnd *scp,
4288 struct sdebug_dev_info *devip)
4289{
4290 unsigned int i, max_zones, rep_max_zones, nrz = 0;
4291 int ret = 0;
4292 u32 alloc_len, rep_opts, rep_len;
4293 bool partial;
4294 u64 lba, zs_lba;
4295 u8 *arr = NULL, *desc;
4296 u8 *cmd = scp->cmnd;
4297 struct sdeb_zone_state *zsp;
b6ff8ca7 4298 struct sdeb_store_info *sip = devip2sip(devip, false);
f0d1cf93
DG		 4299 rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
4300
4301 if (!sdebug_dev_is_zoned(devip)) {
4302 mk_sense_invalid_opcode(scp);
4303 return check_condition_result;
4304 }
4305 zs_lba = get_unaligned_be64(cmd + 2);
4306 alloc_len = get_unaligned_be32(cmd + 10);
4307 rep_opts = cmd[14] & 0x3f;
4308 partial = cmd[14] & 0x80;
4309
4310 if (zs_lba >= sdebug_capacity) {
4311 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4312 return check_condition_result;
4313 }
4314
108e36f0 4315 max_zones = devip->nr_zones - (zs_lba >> devip->zsize_shift);
f0d1cf93
DG		 4316 rep_max_zones = min((alloc_len - 64) >> ilog2(RZONES_DESC_HD),
4317 max_zones);
4318
4319 arr = kcalloc(RZONES_DESC_HD, alloc_len, GFP_ATOMIC);
4320 if (!arr) {
4321 mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
4322 INSUFF_RES_ASCQ);
4323 return check_condition_result;
4324 }
4325
4326 read_lock(macc_lckp);
4327
4328 desc = arr + 64;
4329 for (i = 0; i < max_zones; i++) {
4330 lba = zs_lba + devip->zsize * i;
4331 if (lba > sdebug_capacity)
4332 break;
4333 zsp = zbc_zone(devip, lba);
4334 switch (rep_opts) {
4335 case 0x00:
4336 /* All zones */
4337 break;
4338 case 0x01:
4339 /* Empty zones */
4340 if (zsp->z_cond != ZC1_EMPTY)
4341 continue;
4342 break;
4343 case 0x02:
4344 /* Implicit open zones */
4345 if (zsp->z_cond != ZC2_IMPLICIT_OPEN)
4346 continue;
4347 break;
4348 case 0x03:
4349 /* Explicit open zones */
4350 if (zsp->z_cond != ZC3_EXPLICIT_OPEN)
4351 continue;
4352 break;
4353 case 0x04:
4354 /* Closed zones */
4355 if (zsp->z_cond != ZC4_CLOSED)
4356 continue;
4357 break;
4358 case 0x05:
4359 /* Full zones */
4360 if (zsp->z_cond != ZC5_FULL)
4361 continue;
4362 break;
4363 case 0x06:
4364 case 0x07:
4365 case 0x10:
f0d1cf93 4366 /*
64e14ece
DLM		 4367 * Read-only, offline, reset WP recommended are
4368 * not emulated: no zones to report;
f0d1cf93
DG		 4369 */
4370 continue;
64e14ece
DLM		 4371 case 0x11:
4372 /* non-seq-resource set */
4373 if (!zsp->z_non_seq_resource)
4374 continue;
4375 break;
f0d1cf93
DG		 4376 case 0x3f:
4377 /* Not write pointer (conventional) zones */
4378 if (!zbc_zone_is_conv(zsp))
4379 continue;
4380 break;
4381 default:
4382 mk_sense_buffer(scp, ILLEGAL_REQUEST,
4383 INVALID_FIELD_IN_CDB, 0);
4384 ret = check_condition_result;
4385 goto fini;
4386 }
4387
4388 if (nrz < rep_max_zones) {
4389 /* Fill zone descriptor */
64e14ece 4390 desc[0] = zsp->z_type;
f0d1cf93 4391 desc[1] = zsp->z_cond << 4;
64e14ece
DLM		 4392 if (zsp->z_non_seq_resource)
4393 desc[1] |= 1 << 1;
f0d1cf93
DG		 4394 put_unaligned_be64((u64)zsp->z_size, desc + 8);
4395 put_unaligned_be64((u64)zsp->z_start, desc + 16);
4396 put_unaligned_be64((u64)zsp->z_wp, desc + 24);
4397 desc += 64;
4398 }
4399
4400 if (partial && nrz >= rep_max_zones)
4401 break;
4402
4403 nrz++;
4404 }
4405
4406 /* Report header */
4407 put_unaligned_be32(nrz * RZONES_DESC_HD, arr + 0);
4408 put_unaligned_be64(sdebug_capacity - 1, arr + 8);
4409
4410 rep_len = (unsigned long)desc - (unsigned long)arr;
4411 ret = fill_from_dev_buffer(scp, arr, min_t(int, alloc_len, rep_len));
4412
4413fini:
4414 read_unlock(macc_lckp);
4415 kfree(arr);
4416 return ret;
4417}
4418
4419/* Logic transplanted from tcmu-runner, file_zbc.c */
4420static void zbc_open_all(struct sdebug_dev_info *devip)
4421{
4422 struct sdeb_zone_state *zsp = &devip->zstate[0];
4423 unsigned int i;
4424
4425 for (i = 0; i < devip->nr_zones; i++, zsp++) {
4426 if (zsp->z_cond == ZC4_CLOSED)
4427 zbc_open_zone(devip, &devip->zstate[i], true);
4428 }
4429}
4430
4431static int resp_open_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
4432{
4433 int res = 0;
4434 u64 z_id;
4435 enum sdebug_z_cond zc;
4436 u8 *cmd = scp->cmnd;
4437 struct sdeb_zone_state *zsp;
4438 bool all = cmd[14] & 0x01;
b6ff8ca7 4439 struct sdeb_store_info *sip = devip2sip(devip, false);
f0d1cf93
DG		 4440 rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
4441
4442 if (!sdebug_dev_is_zoned(devip)) {
4443 mk_sense_invalid_opcode(scp);
4444 return check_condition_result;
4445 }
4446
4447 write_lock(macc_lckp);
4448
4449 if (all) {
4450 /* Check if all closed zones can be open */
4451 if (devip->max_open &&
4452 devip->nr_exp_open + devip->nr_closed > devip->max_open) {
4453 mk_sense_buffer(scp, DATA_PROTECT, INSUFF_RES_ASC,
4454 INSUFF_ZONE_ASCQ);
4455 res = check_condition_result;
4456 goto fini;
4457 }
4458 /* Open all closed zones */
4459 zbc_open_all(devip);
4460 goto fini;
4461 }
4462
4463 /* Open the specified zone */
4464 z_id = get_unaligned_be64(cmd + 2);
4465 if (z_id >= sdebug_capacity) {
4466 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4467 res = check_condition_result;
4468 goto fini;
4469 }
4470
4471 zsp = zbc_zone(devip, z_id);
4472 if (z_id != zsp->z_start) {
4473 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4474 res = check_condition_result;
4475 goto fini;
4476 }
4477 if (zbc_zone_is_conv(zsp)) {
4478 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4479 res = check_condition_result;
4480 goto fini;
4481 }
4482
4483 zc = zsp->z_cond;
4484 if (zc == ZC3_EXPLICIT_OPEN || zc == ZC5_FULL)
4485 goto fini;
4486
4487 if (devip->max_open && devip->nr_exp_open >= devip->max_open) {
4488 mk_sense_buffer(scp, DATA_PROTECT, INSUFF_RES_ASC,
4489 INSUFF_ZONE_ASCQ);
4490 res = check_condition_result;
4491 goto fini;
4492 }
4493
f0d1cf93
DG		 4494 zbc_open_zone(devip, zsp, true);
4495fini:
4496 write_unlock(macc_lckp);
4497 return res;
4498}
4499
4500static void zbc_close_all(struct sdebug_dev_info *devip)
4501{
4502 unsigned int i;
4503
4504 for (i = 0; i < devip->nr_zones; i++)
4505 zbc_close_zone(devip, &devip->zstate[i]);
4506}
4507
4508static int resp_close_zone(struct scsi_cmnd *scp,
4509 struct sdebug_dev_info *devip)
4510{
4511 int res = 0;
4512 u64 z_id;
4513 u8 *cmd = scp->cmnd;
4514 struct sdeb_zone_state *zsp;
4515 bool all = cmd[14] & 0x01;
b6ff8ca7 4516 struct sdeb_store_info *sip = devip2sip(devip, false);
f0d1cf93
DG		 4517 rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
4518
4519 if (!sdebug_dev_is_zoned(devip)) {
4520 mk_sense_invalid_opcode(scp);
4521 return check_condition_result;
4522 }
4523
4524 write_lock(macc_lckp);
4525
4526 if (all) {
4527 zbc_close_all(devip);
4528 goto fini;
4529 }
4530
4531 /* Close specified zone */
4532 z_id = get_unaligned_be64(cmd + 2);
4533 if (z_id >= sdebug_capacity) {
4534 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4535 res = check_condition_result;
4536 goto fini;
4537 }
4538
4539 zsp = zbc_zone(devip, z_id);
4540 if (z_id != zsp->z_start) {
4541 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4542 res = check_condition_result;
4543 goto fini;
4544 }
4545 if (zbc_zone_is_conv(zsp)) {
4546 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4547 res = check_condition_result;
4548 goto fini;
4549 }
4550
4551 zbc_close_zone(devip, zsp);
4552fini:
4553 write_unlock(macc_lckp);
4554 return res;
4555}
4556
4557static void zbc_finish_zone(struct sdebug_dev_info *devip,
4558 struct sdeb_zone_state *zsp, bool empty)
4559{
4560 enum sdebug_z_cond zc = zsp->z_cond;
4561
4562 if (zc == ZC4_CLOSED || zc == ZC2_IMPLICIT_OPEN ||
4563 zc == ZC3_EXPLICIT_OPEN || (empty && zc == ZC1_EMPTY)) {
4564 if (zc == ZC2_IMPLICIT_OPEN || zc == ZC3_EXPLICIT_OPEN)
4565 zbc_close_zone(devip, zsp);
4566 if (zsp->z_cond == ZC4_CLOSED)
4567 devip->nr_closed--;
4568 zsp->z_wp = zsp->z_start + zsp->z_size;
4569 zsp->z_cond = ZC5_FULL;
4570 }
4571}
4572
4573static void zbc_finish_all(struct sdebug_dev_info *devip)
4574{
4575 unsigned int i;
4576
4577 for (i = 0; i < devip->nr_zones; i++)
4578 zbc_finish_zone(devip, &devip->zstate[i], false);
4579}
4580
4581static int resp_finish_zone(struct scsi_cmnd *scp,
4582 struct sdebug_dev_info *devip)
4583{
4584 struct sdeb_zone_state *zsp;
4585 int res = 0;
4586 u64 z_id;
4587 u8 *cmd = scp->cmnd;
4588 bool all = cmd[14] & 0x01;
b6ff8ca7 4589 struct sdeb_store_info *sip = devip2sip(devip, false);
f0d1cf93
DG		 4590 rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
4591
4592 if (!sdebug_dev_is_zoned(devip)) {
4593 mk_sense_invalid_opcode(scp);
4594 return check_condition_result;
4595 }
4596
4597 write_lock(macc_lckp);
4598
4599 if (all) {
4600 zbc_finish_all(devip);
4601 goto fini;
4602 }
4603
4604 /* Finish the specified zone */
4605 z_id = get_unaligned_be64(cmd + 2);
4606 if (z_id >= sdebug_capacity) {
4607 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4608 res = check_condition_result;
4609 goto fini;
4610 }
4611
4612 zsp = zbc_zone(devip, z_id);
4613 if (z_id != zsp->z_start) {
4614 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4615 res = check_condition_result;
4616 goto fini;
4617 }
4618 if (zbc_zone_is_conv(zsp)) {
4619 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4620 res = check_condition_result;
4621 goto fini;
4622 }
4623
4624 zbc_finish_zone(devip, zsp, true);
4625fini:
4626 write_unlock(macc_lckp);
4627 return res;
4628}
4629
4630static void zbc_rwp_zone(struct sdebug_dev_info *devip,
4631 struct sdeb_zone_state *zsp)
4632{
4633 enum sdebug_z_cond zc;
4634
4635 if (zbc_zone_is_conv(zsp))
4636 return;
4637
4638 zc = zsp->z_cond;
4639 if (zc == ZC2_IMPLICIT_OPEN || zc == ZC3_EXPLICIT_OPEN)
4640 zbc_close_zone(devip, zsp);
4641
4642 if (zsp->z_cond == ZC4_CLOSED)
4643 devip->nr_closed--;
4644
64e14ece 4645 zsp->z_non_seq_resource = false;
f0d1cf93
DG		 4646 zsp->z_wp = zsp->z_start;
4647 zsp->z_cond = ZC1_EMPTY;
4648}
4649
4650static void zbc_rwp_all(struct sdebug_dev_info *devip)
4651{
4652 unsigned int i;
4653
4654 for (i = 0; i < devip->nr_zones; i++)
4655 zbc_rwp_zone(devip, &devip->zstate[i]);
4656}
4657
4658static int resp_rwp_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
4659{
4660 struct sdeb_zone_state *zsp;
4661 int res = 0;
4662 u64 z_id;
4663 u8 *cmd = scp->cmnd;
4664 bool all = cmd[14] & 0x01;
b6ff8ca7 4665 struct sdeb_store_info *sip = devip2sip(devip, false);
f0d1cf93
DG		 4666 rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
4667
4668 if (!sdebug_dev_is_zoned(devip)) {
4669 mk_sense_invalid_opcode(scp);
4670 return check_condition_result;
4671 }
4672
4673 write_lock(macc_lckp);
4674
4675 if (all) {
4676 zbc_rwp_all(devip);
4677 goto fini;
4678 }
4679
4680 z_id = get_unaligned_be64(cmd + 2);
4681 if (z_id >= sdebug_capacity) {
4682 mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4683 res = check_condition_result;
4684 goto fini;
4685 }
4686
4687 zsp = zbc_zone(devip, z_id);
4688 if (z_id != zsp->z_start) {
4689 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4690 res = check_condition_result;
4691 goto fini;
4692 }
4693 if (zbc_zone_is_conv(zsp)) {
4694 mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4695 res = check_condition_result;
4696 goto fini;
4697 }
4698
4699 zbc_rwp_zone(devip, zsp);
4700fini:
4701 write_unlock(macc_lckp);
4702 return res;
4703}
4704
c4837394
DG		 4705static struct sdebug_queue *get_queue(struct scsi_cmnd *cmnd)
4706{
c10fa55f 4707 u16 hwq;
f7c4cdc7 4708 u32 tag = blk_mq_unique_tag(cmnd->request);
c4837394 4709
f7c4cdc7 4710 hwq = blk_mq_unique_tag_to_hwq(tag);
c10fa55f 4711
f7c4cdc7
JG		 4712 pr_debug("tag=%#x, hwq=%d\n", tag, hwq);
4713 if (WARN_ON_ONCE(hwq >= submit_queues))
4714 hwq = 0;
c10fa55f 4715
458df78b 4716 return sdebug_q_arr + hwq;
c4837394
DG		 4717}
4718
c10fa55f
JG		 4719static u32 get_tag(struct scsi_cmnd *cmnd)
4720{
4721 return blk_mq_unique_tag(cmnd->request);
4722}
4723
c4837394 4724/* Queued (deferred) command completions converge here. */
fd32119b 4725static void sdebug_q_cmd_complete(struct sdebug_defer *sd_dp)
1da177e4 4726{
7382f9d8 4727 bool aborted = sd_dp->aborted;
c4837394 4728 int qc_idx;
cbf67842 4729 int retiring = 0;
1da177e4 4730 unsigned long iflags;
c4837394 4731 struct sdebug_queue *sqp;
cbf67842
DG		 4732 struct sdebug_queued_cmd *sqcp;
4733 struct scsi_cmnd *scp;
4734 struct sdebug_dev_info *devip;
1da177e4 4735
7382f9d8
DG		 4736 if (unlikely(aborted))
4737 sd_dp->aborted = false;
c4837394
DG		 4738 qc_idx = sd_dp->qc_idx;
4739 sqp = sdebug_q_arr + sd_dp->sqa_idx;
4740 if (sdebug_statistics) {
4741 atomic_inc(&sdebug_completions);
4742 if (raw_smp_processor_id() != sd_dp->issuing_cpu)
4743 atomic_inc(&sdebug_miss_cpus);
4744 }
4745 if (unlikely((qc_idx < 0) || (qc_idx >= SDEBUG_CANQUEUE))) {
4746 pr_err("wild qc_idx=%d\n", qc_idx);
1da177e4
LT		 4747 return;
4748 }
c4837394 4749 spin_lock_irqsave(&sqp->qc_lock, iflags);
4a0c6f43 4750 sd_dp->defer_t = SDEB_DEFER_NONE;
c4837394 4751 sqcp = &sqp->qc_arr[qc_idx];
cbf67842 4752 scp = sqcp->a_cmnd;
b01f6f83 4753 if (unlikely(scp == NULL)) {
c4837394 4754 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
c10fa55f
JG		 4755 pr_err("scp is NULL, sqa_idx=%d, qc_idx=%d, hc_idx=%d\n",
4756 sd_dp->sqa_idx, qc_idx, sd_dp->hc_idx);
cbf67842
DG		 4757 return;
4758 }
4759 devip = (struct sdebug_dev_info *)scp->device->hostdata;
f46eb0e9 4760 if (likely(devip))
cbf67842
DG		 4761 atomic_dec(&devip->num_in_q);
4762 else
c1287970 4763 pr_err("devip=NULL\n");
f46eb0e9 4764 if (unlikely(atomic_read(&retired_max_queue) > 0))
cbf67842
DG		 4765 retiring = 1;
4766
4767 sqcp->a_cmnd = NULL;
c4837394
DG		 4768 if (unlikely(!test_and_clear_bit(qc_idx, sqp->in_use_bm))) {
4769 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
c1287970 4770 pr_err("Unexpected completion\n");
1da177e4
LT		 4771 return;
4772 }
cbf67842
DG		 4773
4774 if (unlikely(retiring)) { /* user has reduced max_queue */
4775 int k, retval;
4776
4777 retval = atomic_read(&retired_max_queue);
c4837394
DG		 4778 if (qc_idx >= retval) {
4779 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
c1287970 4780 pr_err("index %d too large\n", retval);
cbf67842
DG		 4781 return;
4782 }
c4837394 4783 k = find_last_bit(sqp->in_use_bm, retval);
773642d9 4784 if ((k < sdebug_max_queue) || (k == retval))
cbf67842
DG		 4785 atomic_set(&retired_max_queue, 0);
4786 else
4787 atomic_set(&retired_max_queue, k + 1);
1da177e4 4788 }
c4837394 4789 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
7382f9d8
DG		 4790 if (unlikely(aborted)) {
4791 if (sdebug_verbose)
4792 pr_info("bypassing scsi_done() due to aborted cmd\n");
4793 return;
4794 }
cbf67842 4795 scp->scsi_done(scp); /* callback to mid level */
1da177e4
LT		 4796}
4797
cbf67842 4798/* When high resolution timer goes off this function is called. */
fd32119b 4799static enum hrtimer_restart sdebug_q_cmd_hrt_complete(struct hrtimer *timer)
cbf67842 4800{
a10bc12a
DG		 4801 struct sdebug_defer *sd_dp = container_of(timer, struct sdebug_defer,
4802 hrt);
4803 sdebug_q_cmd_complete(sd_dp);
cbf67842
DG		 4804 return HRTIMER_NORESTART;
4805}
1da177e4 4806
a10bc12a 4807/* When work queue schedules work, it calls this function. */
fd32119b 4808static void sdebug_q_cmd_wq_complete(struct work_struct *work)
a10bc12a
DG		 4809{
4810 struct sdebug_defer *sd_dp = container_of(work, struct sdebug_defer,
4811 ew.work);
4812 sdebug_q_cmd_complete(sd_dp);
4813}
4814
09ba24c1 4815static bool got_shared_uuid;
bf476433 4816static uuid_t shared_uuid;
09ba24c1 4817
f0d1cf93
DG		 4818static int sdebug_device_create_zones(struct sdebug_dev_info *devip)
4819{
4820 struct sdeb_zone_state *zsp;
4821 sector_t capacity = get_sdebug_capacity();
4822 sector_t zstart = 0;
4823 unsigned int i;
4824
4825 /*
98e0a689
DLM		 4826 * Set the zone size: if sdeb_zbc_zone_size_mb is not set, figure out
4827 * a zone size allowing for at least 4 zones on the device. Otherwise,
f0d1cf93
DG		 4828 * use the specified zone size checking that at least 2 zones can be
4829 * created for the device.
4830 */
98e0a689 4831 if (!sdeb_zbc_zone_size_mb) {
f0d1cf93
DG		 4832 devip->zsize = (DEF_ZBC_ZONE_SIZE_MB * SZ_1M)
4833 >> ilog2(sdebug_sector_size);
4834 while (capacity < devip->zsize << 2 && devip->zsize >= 2)
4835 devip->zsize >>= 1;
4836 if (devip->zsize < 2) {
4837 pr_err("Device capacity too small\n");
4838 return -EINVAL;
4839 }
4840 } else {
108e36f0
DLM		 4841 if (!is_power_of_2(sdeb_zbc_zone_size_mb)) {
4842 pr_err("Zone size is not a power of 2\n");
4843 return -EINVAL;
4844 }
98e0a689 4845 devip->zsize = (sdeb_zbc_zone_size_mb * SZ_1M)
f0d1cf93
DG		 4846 >> ilog2(sdebug_sector_size);
4847 if (devip->zsize >= capacity) {
4848 pr_err("Zone size too large for device capacity\n");
4849 return -EINVAL;
4850 }
4851 }
4852
108e36f0 4853 devip->zsize_shift = ilog2(devip->zsize);
f0d1cf93
DG		 4854 devip->nr_zones = (capacity + devip->zsize - 1) >> devip->zsize_shift;
4855
aa8fecf9
DLM		 4856 if (sdeb_zbc_nr_conv >= devip->nr_zones) {
4857 pr_err("Number of conventional zones too large\n");
4858 return -EINVAL;
4859 }
4860 devip->nr_conv_zones = sdeb_zbc_nr_conv;
4861
64e14ece
DLM		 4862 if (devip->zmodel == BLK_ZONED_HM) {
4863 /* zbc_max_open_zones can be 0, meaning "not reported" */
4864 if (sdeb_zbc_max_open >= devip->nr_zones - 1)
4865 devip->max_open = (devip->nr_zones - 1) / 2;
4866 else
4867 devip->max_open = sdeb_zbc_max_open;
4868 }
f0d1cf93
DG		 4869
4870 devip->zstate = kcalloc(devip->nr_zones,
4871 sizeof(struct sdeb_zone_state), GFP_KERNEL);
4872 if (!devip->zstate)
4873 return -ENOMEM;
4874
4875 for (i = 0; i < devip->nr_zones; i++) {
4876 zsp = &devip->zstate[i];
4877
4878 zsp->z_start = zstart;
4879
aa8fecf9 4880 if (i < devip->nr_conv_zones) {
64e14ece 4881 zsp->z_type = ZBC_ZONE_TYPE_CNV;
f0d1cf93
DG		 4882 zsp->z_cond = ZBC_NOT_WRITE_POINTER;
4883 zsp->z_wp = (sector_t)-1;
4884 } else {
64e14ece
DLM		 4885 if (devip->zmodel == BLK_ZONED_HM)
4886 zsp->z_type = ZBC_ZONE_TYPE_SWR;
4887 else
4888 zsp->z_type = ZBC_ZONE_TYPE_SWP;
f0d1cf93
DG		 4889 zsp->z_cond = ZC1_EMPTY;
4890 zsp->z_wp = zsp->z_start;
4891 }
4892
4893 if (zsp->z_start + devip->zsize < capacity)
4894 zsp->z_size = devip->zsize;
4895 else
4896 zsp->z_size = capacity - zsp->z_start;
4897
4898 zstart += zsp->z_size;
4899 }
4900
4901 return 0;
4902}
4903
fd32119b
DG		 4904static struct sdebug_dev_info *sdebug_device_create(
4905 struct sdebug_host_info *sdbg_host, gfp_t flags)
5cb2fc06
FT		 4906{
4907 struct sdebug_dev_info *devip;
4908
4909 devip = kzalloc(sizeof(*devip), flags);
4910 if (devip) {
09ba24c1 4911 if (sdebug_uuid_ctl == 1)
bf476433 4912 uuid_gen(&devip->lu_name);
09ba24c1
DG		 4913 else if (sdebug_uuid_ctl == 2) {
4914 if (got_shared_uuid)
4915 devip->lu_name = shared_uuid;
4916 else {
bf476433 4917 uuid_gen(&shared_uuid);
09ba24c1
DG		 4918 got_shared_uuid = true;
4919 devip->lu_name = shared_uuid;
4920 }
4921 }
5cb2fc06 4922 devip->sdbg_host = sdbg_host;
f0d1cf93 4923 if (sdeb_zbc_in_use) {
64e14ece 4924 devip->zmodel = sdeb_zbc_model;
f0d1cf93
DG		 4925 if (sdebug_device_create_zones(devip)) {
4926 kfree(devip);
4927 return NULL;
4928 }
64e14ece
DLM		 4929 } else {
4930 devip->zmodel = BLK_ZONED_NONE;
f0d1cf93
DG		 4931 }
4932 devip->sdbg_host = sdbg_host;
fc13638a
DG		 4933 devip->create_ts = ktime_get_boottime();
4934 atomic_set(&devip->stopped, (sdeb_tur_ms_to_ready > 0 ? 2 : 0));
5cb2fc06
FT		 4935 list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
4936 }
4937 return devip;
4938}
4939
f46eb0e9 4940static struct sdebug_dev_info *find_build_dev_info(struct scsi_device *sdev)
1da177e4 4941{
f46eb0e9
DG		 4942 struct sdebug_host_info *sdbg_host;
4943 struct sdebug_dev_info *open_devip = NULL;
4944 struct sdebug_dev_info *devip;
1da177e4 4945
d1e4c9c5
FT		 4946 sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
4947 if (!sdbg_host) {
c1287970 4948 pr_err("Host info NULL\n");
1da177e4 4949 return NULL;
9a051019 4950 }
ad0c7775 4951
1da177e4
LT		 4952 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
4953 if ((devip->used) && (devip->channel == sdev->channel) &&
9a051019
DG		 4954 (devip->target == sdev->id) &&
4955 (devip->lun == sdev->lun))
4956 return devip;
1da177e4
LT		 4957 else {
4958 if ((!devip->used) && (!open_devip))
4959 open_devip = devip;
4960 }
4961 }
5cb2fc06
FT		 4962 if (!open_devip) { /* try and make a new one */
4963 open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC);
4964 if (!open_devip) {
c1287970 4965 pr_err("out of memory at line %d\n", __LINE__);
1da177e4
LT		 4966 return NULL;
4967 }
1da177e4 4968 }
a75869d1
FT		 4969
4970 open_devip->channel = sdev->channel;
4971 open_devip->target = sdev->id;
4972 open_devip->lun = sdev->lun;
4973 open_devip->sdbg_host = sdbg_host;
cbf67842
DG		 4974 atomic_set(&open_devip->num_in_q, 0);
4975 set_bit(SDEBUG_UA_POR, open_devip->uas_bm);
c2248fc9 4976 open_devip->used = true;
a75869d1 4977 return open_devip;
1da177e4
LT		 4978}
4979
8dea0d02 4980static int scsi_debug_slave_alloc(struct scsi_device *sdp)
1da177e4 4981{
773642d9 4982 if (sdebug_verbose)
c1287970 4983 pr_info("slave_alloc <%u %u %u %llu>\n",
8dea0d02 4984 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
8dea0d02
FT		 4985 return 0;
4986}
1da177e4 4987
8dea0d02
FT		 4988static int scsi_debug_slave_configure(struct scsi_device *sdp)
4989{
f46eb0e9
DG		 4990 struct sdebug_dev_info *devip =
4991 (struct sdebug_dev_info *)sdp->hostdata;
a34c4e98 4992
773642d9 4993 if (sdebug_verbose)
c1287970 4994 pr_info("slave_configure <%u %u %u %llu>\n",
8dea0d02 4995 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
b01f6f83
DG		 4996 if (sdp->host->max_cmd_len != SDEBUG_MAX_CMD_LEN)
4997 sdp->host->max_cmd_len = SDEBUG_MAX_CMD_LEN;
4998 if (devip == NULL) {
f46eb0e9 4999 devip = find_build_dev_info(sdp);
b01f6f83 5000 if (devip == NULL)
f46eb0e9
DG		 5001 return 1; /* no resources, will be marked offline */
5002 }
c8b09f6f 5003 sdp->hostdata = devip;
773642d9 5004 if (sdebug_no_uld)
78d4e5a0 5005 sdp->no_uld_attach = 1;
9b760fd8 5006 config_cdb_len(sdp);
8dea0d02
FT		 5007 return 0;
5008}
5009
5010static void scsi_debug_slave_destroy(struct scsi_device *sdp)
5011{
5012 struct sdebug_dev_info *devip =
5013 (struct sdebug_dev_info *)sdp->hostdata;
a34c4e98 5014
773642d9 5015 if (sdebug_verbose)
c1287970 5016 pr_info("slave_destroy <%u %u %u %llu>\n",
8dea0d02
FT		 5017 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
5018 if (devip) {
25985edc 5019 /* make this slot available for re-use */
c2248fc9 5020 devip->used = false;
8dea0d02
FT		 5021 sdp->hostdata = NULL;
5022 }
5023}
5024
10bde980
DG		 5025static void stop_qc_helper(struct sdebug_defer *sd_dp,
5026 enum sdeb_defer_type defer_t)
c4837394
DG		 5027{
5028 if (!sd_dp)
5029 return;
10bde980 5030 if (defer_t == SDEB_DEFER_HRT)
c4837394 5031 hrtimer_cancel(&sd_dp->hrt);
10bde980 5032 else if (defer_t == SDEB_DEFER_WQ)
c4837394
DG		 5033 cancel_work_sync(&sd_dp->ew.work);
5034}
5035
a10bc12a
DG		 5036/* If @cmnd found deletes its timer or work queue and returns true; else
5037 returns false */
5038static bool stop_queued_cmnd(struct scsi_cmnd *cmnd)
8dea0d02
FT		 5039{
5040 unsigned long iflags;
c4837394 5041 int j, k, qmax, r_qmax;
10bde980 5042 enum sdeb_defer_type l_defer_t;
c4837394 5043 struct sdebug_queue *sqp;
8dea0d02 5044 struct sdebug_queued_cmd *sqcp;
cbf67842 5045 struct sdebug_dev_info *devip;
a10bc12a 5046 struct sdebug_defer *sd_dp;
8dea0d02 5047
c4837394
DG		 5048 for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
5049 spin_lock_irqsave(&sqp->qc_lock, iflags);
5050 qmax = sdebug_max_queue;
5051 r_qmax = atomic_read(&retired_max_queue);
5052 if (r_qmax > qmax)
5053 qmax = r_qmax;
5054 for (k = 0; k < qmax; ++k) {
5055 if (test_bit(k, sqp->in_use_bm)) {
5056 sqcp = &sqp->qc_arr[k];
5057 if (cmnd != sqcp->a_cmnd)
5058 continue;
5059 /* found */
5060 devip = (struct sdebug_dev_info *)
5061 cmnd->device->hostdata;
5062 if (devip)
5063 atomic_dec(&devip->num_in_q);
5064 sqcp->a_cmnd = NULL;
5065 sd_dp = sqcp->sd_dp;
10bde980
DG		 5066 if (sd_dp) {
5067 l_defer_t = sd_dp->defer_t;
5068 sd_dp->defer_t = SDEB_DEFER_NONE;
5069 } else
5070 l_defer_t = SDEB_DEFER_NONE;
c4837394 5071 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
10bde980 5072 stop_qc_helper(sd_dp, l_defer_t);
c4837394
DG		 5073 clear_bit(k, sqp->in_use_bm);
5074 return true;
cbf67842 5075 }
8dea0d02 5076 }
c4837394 5077 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
8dea0d02 5078 }
a10bc12a 5079 return false;
8dea0d02
FT		 5080}
5081
a10bc12a 5082/* Deletes (stops) timers or work queues of all queued commands */
8dea0d02
FT		 5083static void stop_all_queued(void)
5084{
5085 unsigned long iflags;
c4837394 5086 int j, k;
10bde980 5087 enum sdeb_defer_type l_defer_t;
c4837394 5088 struct sdebug_queue *sqp;
8dea0d02 5089 struct sdebug_queued_cmd *sqcp;
cbf67842 5090 struct sdebug_dev_info *devip;
a10bc12a 5091 struct sdebug_defer *sd_dp;
8dea0d02 5092
c4837394
DG		 5093 for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
5094 spin_lock_irqsave(&sqp->qc_lock, iflags);
5095 for (k = 0; k < SDEBUG_CANQUEUE; ++k) {
5096 if (test_bit(k, sqp->in_use_bm)) {
5097 sqcp = &sqp->qc_arr[k];
5098 if (sqcp->a_cmnd == NULL)
5099 continue;
5100 devip = (struct sdebug_dev_info *)
5101 sqcp->a_cmnd->device->hostdata;
5102 if (devip)
5103 atomic_dec(&devip->num_in_q);
5104 sqcp->a_cmnd = NULL;
5105 sd_dp = sqcp->sd_dp;
10bde980
DG		 5106 if (sd_dp) {
5107 l_defer_t = sd_dp->defer_t;
5108 sd_dp->defer_t = SDEB_DEFER_NONE;
5109 } else
5110 l_defer_t = SDEB_DEFER_NONE;
c4837394 5111 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
10bde980 5112 stop_qc_helper(sd_dp, l_defer_t);
c4837394
DG		 5113 clear_bit(k, sqp->in_use_bm);
5114 spin_lock_irqsave(&sqp->qc_lock, iflags);
cbf67842 5115 }
8dea0d02 5116 }
c4837394 5117 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
8dea0d02 5118 }
1da177e4
LT		 5119}
5120
cbf67842
DG		 5121/* Free queued command memory on heap */
5122static void free_all_queued(void)
1da177e4 5123{
c4837394
DG		 5124 int j, k;
5125 struct sdebug_queue *sqp;
cbf67842
DG		 5126 struct sdebug_queued_cmd *sqcp;
5127
c4837394
DG		 5128 for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
5129 for (k = 0; k < SDEBUG_CANQUEUE; ++k) {
5130 sqcp = &sqp->qc_arr[k];
5131 kfree(sqcp->sd_dp);
5132 sqcp->sd_dp = NULL;
5133 }
cbf67842 5134 }
1da177e4
LT		 5135}
5136
cbf67842 5137static int scsi_debug_abort(struct scsi_cmnd *SCpnt)
1da177e4 5138{
a10bc12a
DG		 5139 bool ok;
5140
cbf67842
DG		 5141 ++num_aborts;
5142 if (SCpnt) {
a10bc12a
DG		 5143 ok = stop_queued_cmnd(SCpnt);
5144 if (SCpnt->device && (SDEBUG_OPT_ALL_NOISE & sdebug_opts))
5145 sdev_printk(KERN_INFO, SCpnt->device,
5146 "%s: command%s found\n", __func__,
5147 ok ? "" : " not");
cbf67842
DG		 5148 }
5149 return SUCCESS;
1da177e4
LT		 5150}
5151
91d4c752 5152static int scsi_debug_device_reset(struct scsi_cmnd *SCpnt)
1da177e4 5153{
1da177e4 5154 ++num_dev_resets;
cbf67842
DG		 5155 if (SCpnt && SCpnt->device) {
5156 struct scsi_device *sdp = SCpnt->device;
f46eb0e9
DG		 5157 struct sdebug_dev_info *devip =
5158 (struct sdebug_dev_info *)sdp->hostdata;
cbf67842 5159
773642d9 5160 if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
cbf67842 5161 sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
1da177e4 5162 if (devip)
cbf67842
DG		 5163 set_bit(SDEBUG_UA_POR, devip->uas_bm);
5164 }
5165 return SUCCESS;
5166}
5167
5168static int scsi_debug_target_reset(struct scsi_cmnd *SCpnt)
5169{
5170 struct sdebug_host_info *sdbg_host;
5171 struct sdebug_dev_info *devip;
5172 struct scsi_device *sdp;
5173 struct Scsi_Host *hp;
5174 int k = 0;
5175
5176 ++num_target_resets;
5177 if (!SCpnt)
5178 goto lie;
5179 sdp = SCpnt->device;
5180 if (!sdp)
5181 goto lie;
773642d9 5182 if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
cbf67842
DG		 5183 sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
5184 hp = sdp->host;
5185 if (!hp)
5186 goto lie;
5187 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
5188 if (sdbg_host) {
5189 list_for_each_entry(devip,
5190 &sdbg_host->dev_info_list,
5191 dev_list)
5192 if (devip->target == sdp->id) {
5193 set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
5194 ++k;
5195 }
1da177e4 5196 }
773642d9 5197 if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
cbf67842
DG		 5198 sdev_printk(KERN_INFO, sdp,
5199 "%s: %d device(s) found in target\n", __func__, k);
5200lie:
1da177e4
LT		 5201 return SUCCESS;
5202}
5203
91d4c752 5204static int scsi_debug_bus_reset(struct scsi_cmnd *SCpnt)
1da177e4
LT		 5205{
5206 struct sdebug_host_info *sdbg_host;
cbf67842 5207 struct sdebug_dev_info *devip;
9a051019
DG		 5208 struct scsi_device *sdp;
5209 struct Scsi_Host *hp;
cbf67842 5210 int k = 0;
1da177e4 5211
1da177e4 5212 ++num_bus_resets;
cbf67842
DG		 5213 if (!(SCpnt && SCpnt->device))
5214 goto lie;
5215 sdp = SCpnt->device;
773642d9 5216 if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
cbf67842
DG		 5217 sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
5218 hp = sdp->host;
5219 if (hp) {
d1e4c9c5 5220 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
1da177e4 5221 if (sdbg_host) {
cbf67842 5222 list_for_each_entry(devip,
9a051019 5223 &sdbg_host->dev_info_list,
cbf67842
DG		 5224 dev_list) {
5225 set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
5226 ++k;
5227 }
1da177e4
LT		 5228 }
5229 }
773642d9 5230 if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
cbf67842
DG		 5231 sdev_printk(KERN_INFO, sdp,
5232 "%s: %d device(s) found in host\n", __func__, k);
5233lie:
1da177e4
LT		 5234 return SUCCESS;
5235}
5236
91d4c752 5237static int scsi_debug_host_reset(struct scsi_cmnd *SCpnt)
1da177e4 5238{
91d4c752 5239 struct sdebug_host_info *sdbg_host;
cbf67842
DG		 5240 struct sdebug_dev_info *devip;
5241 int k = 0;
1da177e4 5242
1da177e4 5243 ++num_host_resets;
773642d9 5244 if ((SCpnt->device) && (SDEBUG_OPT_ALL_NOISE & sdebug_opts))
cbf67842 5245 sdev_printk(KERN_INFO, SCpnt->device, "%s\n", __func__);
9a051019
DG		 5246 spin_lock(&sdebug_host_list_lock);
5247 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
cbf67842
DG		 5248 list_for_each_entry(devip, &sdbg_host->dev_info_list,
5249 dev_list) {
5250 set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
5251 ++k;
5252 }
9a051019
DG		 5253 }
5254 spin_unlock(&sdebug_host_list_lock);
1da177e4 5255 stop_all_queued();
773642d9 5256 if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
cbf67842
DG		 5257 sdev_printk(KERN_INFO, SCpnt->device,
5258 "%s: %d device(s) found\n", __func__, k);
1da177e4
LT		 5259 return SUCCESS;
5260}
5261
87c715dc 5262static void sdebug_build_parts(unsigned char *ramp, unsigned long store_size)
1da177e4 5263{
1442f76d 5264 struct msdos_partition *pp;
979e0dc3 5265 int starts[SDEBUG_MAX_PARTS + 2], max_part_secs;
1da177e4
LT		 5266 int sectors_per_part, num_sectors, k;
5267 int heads_by_sects, start_sec, end_sec;
5268
5269 /* assume partition table already zeroed */
773642d9 5270 if ((sdebug_num_parts < 1) || (store_size < 1048576))
1da177e4 5271 return;
773642d9
DG		 5272 if (sdebug_num_parts > SDEBUG_MAX_PARTS) {
5273 sdebug_num_parts = SDEBUG_MAX_PARTS;
c1287970 5274 pr_warn("reducing partitions to %d\n", SDEBUG_MAX_PARTS);
1da177e4 5275 }
8c657235 5276 num_sectors = (int)get_sdebug_capacity();
1da177e4 5277 sectors_per_part = (num_sectors - sdebug_sectors_per)
773642d9 5278 / sdebug_num_parts;
1da177e4 5279 heads_by_sects = sdebug_heads * sdebug_sectors_per;
9a051019 5280 starts[0] = sdebug_sectors_per;
979e0dc3
JP		 5281 max_part_secs = sectors_per_part;
5282 for (k = 1; k < sdebug_num_parts; ++k) {
1da177e4
LT		 5283 starts[k] = ((k * sectors_per_part) / heads_by_sects)
5284 * heads_by_sects;
979e0dc3
JP		 5285 if (starts[k] - starts[k - 1] < max_part_secs)
5286 max_part_secs = starts[k] - starts[k - 1];
5287 }
773642d9
DG		 5288 starts[sdebug_num_parts] = num_sectors;
5289 starts[sdebug_num_parts + 1] = 0;
1da177e4
LT		 5290
5291 ramp[510] = 0x55; /* magic partition markings */
5292 ramp[511] = 0xAA;
1442f76d 5293 pp = (struct msdos_partition *)(ramp + 0x1be);
1da177e4
LT		 5294 for (k = 0; starts[k + 1]; ++k, ++pp) {
5295 start_sec = starts[k];
979e0dc3 5296 end_sec = starts[k] + max_part_secs - 1;
1da177e4
LT		 5297 pp->boot_ind = 0;
5298
5299 pp->cyl = start_sec / heads_by_sects;
5300 pp->head = (start_sec - (pp->cyl * heads_by_sects))
5301 / sdebug_sectors_per;
5302 pp->sector = (start_sec % sdebug_sectors_per) + 1;
5303
5304 pp->end_cyl = end_sec / heads_by_sects;
5305 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
5306 / sdebug_sectors_per;
5307 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
5308
150c3544
AM		 5309 pp->start_sect = cpu_to_le32(start_sec);
5310 pp->nr_sects = cpu_to_le32(end_sec - start_sec + 1);
1da177e4
LT		 5311 pp->sys_ind = 0x83; /* plain Linux partition */
5312 }
5313}
5314
c4837394
DG		 5315static void block_unblock_all_queues(bool block)
5316{
5317 int j;
5318 struct sdebug_queue *sqp;
5319
5320 for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp)
5321 atomic_set(&sqp->blocked, (int)block);
5322}
5323
5324/* Adjust (by rounding down) the sdebug_cmnd_count so abs(every_nth)-1
5325 * commands will be processed normally before triggers occur.
5326 */
5327static void tweak_cmnd_count(void)
5328{
5329 int count, modulo;
5330
5331 modulo = abs(sdebug_every_nth);
5332 if (modulo < 2)
5333 return;
5334 block_unblock_all_queues(true);
5335 count = atomic_read(&sdebug_cmnd_count);
5336 atomic_set(&sdebug_cmnd_count, (count / modulo) * modulo);
5337 block_unblock_all_queues(false);
5338}
5339
5340static void clear_queue_stats(void)
5341{
5342 atomic_set(&sdebug_cmnd_count, 0);
5343 atomic_set(&sdebug_completions, 0);
5344 atomic_set(&sdebug_miss_cpus, 0);
5345 atomic_set(&sdebug_a_tsf, 0);
5346}
5347
3a90a63d 5348static bool inject_on_this_cmd(void)
c4837394 5349{
3a90a63d
DG		 5350 if (sdebug_every_nth == 0)
5351 return false;
5352 return (atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth)) == 0;
c4837394
DG		 5353}
5354
a2aede97
DG		 5355#define INCLUSIVE_TIMING_MAX_NS 1000000 /* 1 millisecond */
5356
c4837394
DG		 5357/* Complete the processing of the thread that queued a SCSI command to this
5358 * driver. It either completes the command by calling cmnd_done() or
5359 * schedules a hr timer or work queue then returns 0. Returns
5360 * SCSI_MLQUEUE_HOST_BUSY if temporarily out of resources.
5361 */
fd32119b 5362static int schedule_resp(struct scsi_cmnd *cmnd, struct sdebug_dev_info *devip,
f66b8517
MW		 5363 int scsi_result,
5364 int (*pfp)(struct scsi_cmnd *,
5365 struct sdebug_dev_info *),
5366 int delta_jiff, int ndelay)
1da177e4 5367{
a2aede97 5368 bool new_sd_dp;
3a90a63d 5369 bool inject = false;
771f712b 5370 bool hipri = (cmnd->request->cmd_flags & REQ_HIPRI);
3a90a63d 5371 int k, num_in_q, qdepth;
a2aede97
DG		 5372 unsigned long iflags;
5373 u64 ns_from_boot = 0;
c4837394
DG		 5374 struct sdebug_queue *sqp;
5375 struct sdebug_queued_cmd *sqcp;
299b6c07 5376 struct scsi_device *sdp;
a10bc12a 5377 struct sdebug_defer *sd_dp;
299b6c07 5378
b01f6f83
DG		 5379 if (unlikely(devip == NULL)) {
5380 if (scsi_result == 0)
f46eb0e9
DG		 5381 scsi_result = DID_NO_CONNECT << 16;
5382 goto respond_in_thread;
cbf67842 5383 }
299b6c07
TW		 5384 sdp = cmnd->device;
5385
cd62b7da
DG		 5386 if (delta_jiff == 0)
5387 goto respond_in_thread;
1da177e4 5388
c4837394
DG		 5389 sqp = get_queue(cmnd);
5390 spin_lock_irqsave(&sqp->qc_lock, iflags);
5391 if (unlikely(atomic_read(&sqp->blocked))) {
5392 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5393 return SCSI_MLQUEUE_HOST_BUSY;
5394 }
cbf67842
DG		 5395 num_in_q = atomic_read(&devip->num_in_q);
5396 qdepth = cmnd->device->queue_depth;
f46eb0e9 5397 if (unlikely((qdepth > 0) && (num_in_q >= qdepth))) {
cd62b7da 5398 if (scsi_result) {
c4837394 5399 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
cd62b7da
DG		 5400 goto respond_in_thread;
5401 } else
5402 scsi_result = device_qfull_result;
c4837394 5403 } else if (unlikely(sdebug_every_nth &&
f46eb0e9
DG		 5404 (SDEBUG_OPT_RARE_TSF & sdebug_opts) &&
5405 (scsi_result == 0))) {
cbf67842
DG		 5406 if ((num_in_q == (qdepth - 1)) &&
5407 (atomic_inc_return(&sdebug_a_tsf) >=
773642d9 5408 abs(sdebug_every_nth))) {
cbf67842 5409 atomic_set(&sdebug_a_tsf, 0);
3a90a63d 5410 inject = true;
cd62b7da 5411 scsi_result = device_qfull_result;
1da177e4
LT		 5412 }
5413 }
1da177e4 5414
c4837394 5415 k = find_first_zero_bit(sqp->in_use_bm, sdebug_max_queue);
f46eb0e9 5416 if (unlikely(k >= sdebug_max_queue)) {
c4837394 5417 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
cd62b7da
DG		 5418 if (scsi_result)
5419 goto respond_in_thread;
773642d9 5420 else if (SDEBUG_OPT_ALL_TSF & sdebug_opts)
cd62b7da 5421 scsi_result = device_qfull_result;
773642d9 5422 if (SDEBUG_OPT_Q_NOISE & sdebug_opts)
cbf67842 5423 sdev_printk(KERN_INFO, sdp,
cd62b7da 5424 "%s: max_queue=%d exceeded, %s\n",
773642d9 5425 __func__, sdebug_max_queue,
cd62b7da
DG		 5426 (scsi_result ? "status: TASK SET FULL" :
5427 "report: host busy"));
5428 if (scsi_result)
5429 goto respond_in_thread;
5430 else
cbf67842
DG		 5431 return SCSI_MLQUEUE_HOST_BUSY;
5432 }
74595c04 5433 set_bit(k, sqp->in_use_bm);
cbf67842 5434 atomic_inc(&devip->num_in_q);
c4837394 5435 sqcp = &sqp->qc_arr[k];
cbf67842 5436 sqcp->a_cmnd = cmnd;
c4837394 5437 cmnd->host_scribble = (unsigned char *)sqcp;
a10bc12a 5438 sd_dp = sqcp->sd_dp;
c4837394 5439 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
c4b57d89 5440
74595c04 5441 if (!sd_dp) {
10bde980 5442 sd_dp = kzalloc(sizeof(*sd_dp), GFP_ATOMIC);
74595c04
DG		 5443 if (!sd_dp) {
5444 atomic_dec(&devip->num_in_q);
5445 clear_bit(k, sqp->in_use_bm);
10bde980 5446 return SCSI_MLQUEUE_HOST_BUSY;
74595c04 5447 }
a2aede97
DG		 5448 new_sd_dp = true;
5449 } else {
5450 new_sd_dp = false;
10bde980 5451 }
f66b8517 5452
c10fa55f
JG		 5453 /* Set the hostwide tag */
5454 if (sdebug_host_max_queue)
5455 sd_dp->hc_idx = get_tag(cmnd);
5456
771f712b 5457 if (hipri)
a2aede97
DG		 5458 ns_from_boot = ktime_get_boottime_ns();
5459
5460 /* one of the resp_*() response functions is called here */
3a90a63d 5461 cmnd->result = pfp ? pfp(cmnd, devip) : 0;
f66b8517 5462 if (cmnd->result & SDEG_RES_IMMED_MASK) {
f66b8517
MW		 5463 cmnd->result &= ~SDEG_RES_IMMED_MASK;
5464 delta_jiff = ndelay = 0;
5465 }
5466 if (cmnd->result == 0 && scsi_result != 0)
5467 cmnd->result = scsi_result;
3a90a63d
DG		 5468 if (cmnd->result == 0 && unlikely(sdebug_opts & SDEBUG_OPT_TRANSPORT_ERR)) {
5469 if (atomic_read(&sdeb_inject_pending)) {
5470 mk_sense_buffer(cmnd, ABORTED_COMMAND, TRANSPORT_PROBLEM, ACK_NAK_TO);
5471 atomic_set(&sdeb_inject_pending, 0);
5472 cmnd->result = check_condition_result;
5473 }
5474 }
f66b8517
MW		 5475
5476 if (unlikely(sdebug_verbose && cmnd->result))
5477 sdev_printk(KERN_INFO, sdp, "%s: non-zero result=0x%x\n",
5478 __func__, cmnd->result);
5479
10bde980 5480 if (delta_jiff > 0 || ndelay > 0) {
b333a819 5481 ktime_t kt;
cbf67842 5482
b333a819 5483 if (delta_jiff > 0) {
0c4bc91d
DG		 5484 u64 ns = jiffies_to_nsecs(delta_jiff);
5485
5486 if (sdebug_random && ns < U32_MAX) {
5487 ns = prandom_u32_max((u32)ns);
5488 } else if (sdebug_random) {
5489 ns >>= 12; /* scale to 4 usec precision */
5490 if (ns < U32_MAX) /* over 4 hours max */
5491 ns = prandom_u32_max((u32)ns);
5492 ns <<= 12;
5493 }
5494 kt = ns_to_ktime(ns);
5495 } else { /* ndelay has a 4.2 second max */
5496 kt = sdebug_random ? prandom_u32_max((u32)ndelay) :
5497 (u32)ndelay;
a2aede97
DG		 5498 if (ndelay < INCLUSIVE_TIMING_MAX_NS) {
5499 u64 d = ktime_get_boottime_ns() - ns_from_boot;
5500
5501 if (kt <= d) { /* elapsed duration >= kt */
223f91b4 5502 spin_lock_irqsave(&sqp->qc_lock, iflags);
a2aede97
DG		 5503 sqcp->a_cmnd = NULL;
5504 atomic_dec(&devip->num_in_q);
5505 clear_bit(k, sqp->in_use_bm);
223f91b4 5506 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
a2aede97
DG		 5507 if (new_sd_dp)
5508 kfree(sd_dp);
5509 /* call scsi_done() from this thread */
5510 cmnd->scsi_done(cmnd);
5511 return 0;
5512 }
5513 /* otherwise reduce kt by elapsed time */
5514 kt -= d;
5515 }
0c4bc91d 5516 }
771f712b
DG		 5517 if (hipri) {
5518 sd_dp->cmpl_ts = ktime_add(ns_to_ktime(ns_from_boot), kt);
4a0c6f43
DG		 5519 spin_lock_irqsave(&sqp->qc_lock, iflags);
5520 if (!sd_dp->init_poll) {
5521 sd_dp->init_poll = true;
5522 sqcp->sd_dp = sd_dp;
5523 sd_dp->sqa_idx = sqp - sdebug_q_arr;
5524 sd_dp->qc_idx = k;
5525 }
5526 sd_dp->defer_t = SDEB_DEFER_POLL;
5527 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5528 } else {
5529 if (!sd_dp->init_hrt) {
5530 sd_dp->init_hrt = true;
5531 sqcp->sd_dp = sd_dp;
5532 hrtimer_init(&sd_dp->hrt, CLOCK_MONOTONIC,
5533 HRTIMER_MODE_REL_PINNED);
5534 sd_dp->hrt.function = sdebug_q_cmd_hrt_complete;
5535 sd_dp->sqa_idx = sqp - sdebug_q_arr;
5536 sd_dp->qc_idx = k;
5537 }
5538 sd_dp->defer_t = SDEB_DEFER_HRT;
5539 /* schedule the invocation of scsi_done() for a later time */
5540 hrtimer_start(&sd_dp->hrt, kt, HRTIMER_MODE_REL_PINNED);
1da177e4 5541 }
c4837394
DG		 5542 if (sdebug_statistics)
5543 sd_dp->issuing_cpu = raw_smp_processor_id();
c4837394 5544 } else { /* jdelay < 0, use work queue */
3a90a63d
DG		 5545 if (unlikely((sdebug_opts & SDEBUG_OPT_CMD_ABORT) &&
5546 atomic_read(&sdeb_inject_pending)))
7382f9d8 5547 sd_dp->aborted = true;
771f712b
DG		 5548 if (hipri) {
5549 sd_dp->cmpl_ts = ns_to_ktime(ns_from_boot);
4a0c6f43
DG		 5550 spin_lock_irqsave(&sqp->qc_lock, iflags);
5551 if (!sd_dp->init_poll) {
5552 sd_dp->init_poll = true;
5553 sqcp->sd_dp = sd_dp;
5554 sd_dp->sqa_idx = sqp - sdebug_q_arr;
5555 sd_dp->qc_idx = k;
5556 }
5557 sd_dp->defer_t = SDEB_DEFER_POLL;
5558 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5559 } else {
5560 if (!sd_dp->init_wq) {
5561 sd_dp->init_wq = true;
5562 sqcp->sd_dp = sd_dp;
5563 sd_dp->sqa_idx = sqp - sdebug_q_arr;
5564 sd_dp->qc_idx = k;
5565 INIT_WORK(&sd_dp->ew.work, sdebug_q_cmd_wq_complete);
5566 }
5567 sd_dp->defer_t = SDEB_DEFER_WQ;
5568 schedule_work(&sd_dp->ew.work);
5569 }
5570 if (sdebug_statistics)
5571 sd_dp->issuing_cpu = raw_smp_processor_id();
5572 if (unlikely(sd_dp->aborted)) {
3a90a63d 5573 sdev_printk(KERN_INFO, sdp, "abort request tag %d\n", cmnd->request->tag);
7382f9d8 5574 blk_abort_request(cmnd->request);
3a90a63d 5575 atomic_set(&sdeb_inject_pending, 0);
4a0c6f43 5576 sd_dp->aborted = false;
7382f9d8 5577 }
1da177e4 5578 }
3a90a63d
DG		 5579 if (unlikely((SDEBUG_OPT_Q_NOISE & sdebug_opts) && scsi_result == device_qfull_result))
5580 sdev_printk(KERN_INFO, sdp, "%s: num_in_q=%d +1, %s%s\n", __func__,
5581 num_in_q, (inject ? "<inject> " : ""), "status: TASK SET FULL");
cbf67842 5582 return 0;
cd62b7da
DG		 5583
5584respond_in_thread: /* call back to mid-layer using invocation thread */
f66b8517
MW		 5585 cmnd->result = pfp != NULL ? pfp(cmnd, devip) : 0;
5586 cmnd->result &= ~SDEG_RES_IMMED_MASK;
5587 if (cmnd->result == 0 && scsi_result != 0)
5588 cmnd->result = scsi_result;
cd62b7da
DG		 5589 cmnd->scsi_done(cmnd);
5590 return 0;
1da177e4 5591}
cbf67842 5592
23183910
DG		 5593/* Note: The following macros create attribute files in the
5594 /sys/module/scsi_debug/parameters directory. Unfortunately this
5595 driver is unaware of a change and cannot trigger auxiliary actions
5596 as it can when the corresponding attribute in the
5597 /sys/bus/pseudo/drivers/scsi_debug directory is changed.
5598 */
773642d9
DG		 5599module_param_named(add_host, sdebug_add_host, int, S_IRUGO | S_IWUSR);
5600module_param_named(ato, sdebug_ato, int, S_IRUGO);
9b760fd8 5601module_param_named(cdb_len, sdebug_cdb_len, int, 0644);
773642d9 5602module_param_named(clustering, sdebug_clustering, bool, S_IRUGO | S_IWUSR);
c2206098 5603module_param_named(delay, sdebug_jdelay, int, S_IRUGO | S_IWUSR);
773642d9
DG		 5604module_param_named(dev_size_mb, sdebug_dev_size_mb, int, S_IRUGO);
5605module_param_named(dif, sdebug_dif, int, S_IRUGO);
5606module_param_named(dix, sdebug_dix, int, S_IRUGO);
5607module_param_named(dsense, sdebug_dsense, int, S_IRUGO | S_IWUSR);
5608module_param_named(every_nth, sdebug_every_nth, int, S_IRUGO | S_IWUSR);
5609module_param_named(fake_rw, sdebug_fake_rw, int, S_IRUGO | S_IWUSR);
5610module_param_named(guard, sdebug_guard, uint, S_IRUGO);
5611module_param_named(host_lock, sdebug_host_lock, bool, S_IRUGO | S_IWUSR);
c10fa55f 5612module_param_named(host_max_queue, sdebug_host_max_queue, int, S_IRUGO);
e5203cf0 5613module_param_string(inq_product, sdebug_inq_product_id,
5d807076 5614 sizeof(sdebug_inq_product_id), S_IRUGO | S_IWUSR);
e5203cf0 5615module_param_string(inq_rev, sdebug_inq_product_rev,
5d807076
DG		 5616 sizeof(sdebug_inq_product_rev), S_IRUGO | S_IWUSR);
5617module_param_string(inq_vendor, sdebug_inq_vendor_id,
5618 sizeof(sdebug_inq_vendor_id), S_IRUGO | S_IWUSR);
5619module_param_named(lbprz, sdebug_lbprz, int, S_IRUGO);
773642d9
DG		 5620module_param_named(lbpu, sdebug_lbpu, int, S_IRUGO);
5621module_param_named(lbpws, sdebug_lbpws, int, S_IRUGO);
5622module_param_named(lbpws10, sdebug_lbpws10, int, S_IRUGO);
773642d9 5623module_param_named(lowest_aligned, sdebug_lowest_aligned, int, S_IRUGO);
ad0c7775 5624module_param_named(lun_format, sdebug_lun_am_i, int, S_IRUGO | S_IWUSR);
773642d9
DG		 5625module_param_named(max_luns, sdebug_max_luns, int, S_IRUGO | S_IWUSR);
5626module_param_named(max_queue, sdebug_max_queue, int, S_IRUGO | S_IWUSR);
5d807076
DG		 5627module_param_named(medium_error_count, sdebug_medium_error_count, int,
5628 S_IRUGO | S_IWUSR);
5629module_param_named(medium_error_start, sdebug_medium_error_start, int,
5630 S_IRUGO | S_IWUSR);
773642d9
DG		 5631module_param_named(ndelay, sdebug_ndelay, int, S_IRUGO | S_IWUSR);
5632module_param_named(no_lun_0, sdebug_no_lun_0, int, S_IRUGO | S_IWUSR);
5633module_param_named(no_uld, sdebug_no_uld, int, S_IRUGO);
5634module_param_named(num_parts, sdebug_num_parts, int, S_IRUGO);
5635module_param_named(num_tgts, sdebug_num_tgts, int, S_IRUGO | S_IWUSR);
5636module_param_named(opt_blks, sdebug_opt_blks, int, S_IRUGO);
5d807076 5637module_param_named(opt_xferlen_exp, sdebug_opt_xferlen_exp, int, S_IRUGO);
773642d9 5638module_param_named(opts, sdebug_opts, int, S_IRUGO | S_IWUSR);
87c715dc
DG		 5639module_param_named(per_host_store, sdebug_per_host_store, bool,
5640 S_IRUGO | S_IWUSR);
773642d9
DG		 5641module_param_named(physblk_exp, sdebug_physblk_exp, int, S_IRUGO);
5642module_param_named(ptype, sdebug_ptype, int, S_IRUGO | S_IWUSR);
0c4bc91d 5643module_param_named(random, sdebug_random, bool, S_IRUGO | S_IWUSR);
773642d9
DG		 5644module_param_named(removable, sdebug_removable, bool, S_IRUGO | S_IWUSR);
5645module_param_named(scsi_level, sdebug_scsi_level, int, S_IRUGO);
5646module_param_named(sector_size, sdebug_sector_size, int, S_IRUGO);
c4837394 5647module_param_named(statistics, sdebug_statistics, bool, S_IRUGO | S_IWUSR);
773642d9 5648module_param_named(strict, sdebug_strict, bool, S_IRUGO | S_IWUSR);
c4837394 5649module_param_named(submit_queues, submit_queues, int, S_IRUGO);
c4b57d89 5650module_param_named(poll_queues, poll_queues, int, S_IRUGO);
fc13638a 5651module_param_named(tur_ms_to_ready, sdeb_tur_ms_to_ready, int, S_IRUGO);
773642d9
DG		 5652module_param_named(unmap_alignment, sdebug_unmap_alignment, int, S_IRUGO);
5653module_param_named(unmap_granularity, sdebug_unmap_granularity, int, S_IRUGO);
5654module_param_named(unmap_max_blocks, sdebug_unmap_max_blocks, int, S_IRUGO);
5655module_param_named(unmap_max_desc, sdebug_unmap_max_desc, int, S_IRUGO);
09ba24c1 5656module_param_named(uuid_ctl, sdebug_uuid_ctl, int, S_IRUGO);
5d807076 5657module_param_named(virtual_gb, sdebug_virtual_gb, int, S_IRUGO | S_IWUSR);
773642d9 5658module_param_named(vpd_use_hostno, sdebug_vpd_use_hostno, int,
5b94e232 5659 S_IRUGO | S_IWUSR);
9447b6ce 5660module_param_named(wp, sdebug_wp, bool, S_IRUGO | S_IWUSR);
773642d9 5661module_param_named(write_same_length, sdebug_write_same_length, int,
5b94e232 5662 S_IRUGO | S_IWUSR);
9267e0eb 5663module_param_named(zbc, sdeb_zbc_model_s, charp, S_IRUGO);
380603a5 5664module_param_named(zone_max_open, sdeb_zbc_max_open, int, S_IRUGO);
aa8fecf9 5665module_param_named(zone_nr_conv, sdeb_zbc_nr_conv, int, S_IRUGO);
98e0a689 5666module_param_named(zone_size_mb, sdeb_zbc_zone_size_mb, int, S_IRUGO);
1da177e4
LT		 5667
5668MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
5669MODULE_DESCRIPTION("SCSI debug adapter driver");
5670MODULE_LICENSE("GPL");
b01f6f83 5671MODULE_VERSION(SDEBUG_VERSION);
1da177e4 5672
5d807076 5673MODULE_PARM_DESC(add_host, "add n hosts, in sysfs if negative remove host(s) (def=1)");
5b94e232 5674MODULE_PARM_DESC(ato, "application tag ownership: 0=disk 1=host (def=1)");
9b760fd8 5675MODULE_PARM_DESC(cdb_len, "suggest CDB lengths to drivers (def=10)");
0759c666 5676MODULE_PARM_DESC(clustering, "when set enables larger transfers (def=0)");
cbf67842 5677MODULE_PARM_DESC(delay, "response delay (def=1 jiffy); 0:imm, -1,-2:tiny");
c2248fc9 5678MODULE_PARM_DESC(dev_size_mb, "size in MiB of ram shared by devs(def=8)");
5b94e232
MP		 5679MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)");
5680MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)");
c65b1445 5681MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
beb87c33 5682MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
23183910 5683MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
5b94e232 5684MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");
185dd232 5685MODULE_PARM_DESC(host_lock, "host_lock is ignored (def=0)");
c10fa55f
JG		 5686MODULE_PARM_DESC(host_max_queue,
5687 "host max # of queued cmds (0 to max(def) [max_queue fixed equal for !0])");
e5203cf0 5688MODULE_PARM_DESC(inq_product, "SCSI INQUIRY product string (def=\"scsi_debug\")");
9b760fd8
DG		 5689MODULE_PARM_DESC(inq_rev, "SCSI INQUIRY revision string (def=\""
5690 SDEBUG_VERSION "\")");
5d807076
DG		 5691MODULE_PARM_DESC(inq_vendor, "SCSI INQUIRY vendor string (def=\"Linux\")");
5692MODULE_PARM_DESC(lbprz,
5693 "on read unmapped LBs return 0 when 1 (def), return 0xff when 2");
5b94e232
MP		 5694MODULE_PARM_DESC(lbpu, "enable LBP, support UNMAP command (def=0)");
5695MODULE_PARM_DESC(lbpws, "enable LBP, support WRITE SAME(16) with UNMAP bit (def=0)");
5696MODULE_PARM_DESC(lbpws10, "enable LBP, support WRITE SAME(10) with UNMAP bit (def=0)");
5697MODULE_PARM_DESC(lowest_aligned, "lowest aligned lba (def=0)");
ad0c7775 5698MODULE_PARM_DESC(lun_format, "LUN format: 0->peripheral (def); 1 --> flat address method");
fc09acb7 5699MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
cbf67842 5700MODULE_PARM_DESC(max_queue, "max number of queued commands (1 to max(def))");
d9da891a 5701MODULE_PARM_DESC(medium_error_count, "count of sectors to return follow on MEDIUM error");
5d807076 5702MODULE_PARM_DESC(medium_error_start, "starting sector number to return MEDIUM error");
cbf67842 5703MODULE_PARM_DESC(ndelay, "response delay in nanoseconds (def=0 -> ignore)");
c65b1445 5704MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
78d4e5a0 5705MODULE_PARM_DESC(no_uld, "stop ULD (e.g. sd driver) attaching (def=0))");
1da177e4 5706MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
c65b1445 5707MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
32c5844a 5708MODULE_PARM_DESC(opt_blks, "optimal transfer length in blocks (def=1024)");
5d807076 5709MODULE_PARM_DESC(opt_xferlen_exp, "optimal transfer length granularity exponent (def=physblk_exp)");
6f3cbf55 5710MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
5d807076 5711MODULE_PARM_DESC(per_host_store, "If set, next positive add_host will get new store (def=0)");
5b94e232 5712MODULE_PARM_DESC(physblk_exp, "physical block exponent (def=0)");
fc09acb7 5713MODULE_PARM_DESC(poll_queues, "support for iouring iopoll queues (1 to max(submit_queues - 1))");
1da177e4 5714MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
0c4bc91d 5715MODULE_PARM_DESC(random, "If set, uniformly randomize command duration between 0 and delay_in_ns");
d986788b 5716MODULE_PARM_DESC(removable, "claim to have removable media (def=0)");
760f3b03 5717MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=7[SPC-5])");
ea61fca5 5718MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)");
c4837394 5719MODULE_PARM_DESC(statistics, "collect statistics on commands, queues (def=0)");
c2248fc9 5720MODULE_PARM_DESC(strict, "stricter checks: reserved field in cdb (def=0)");
c4837394 5721MODULE_PARM_DESC(submit_queues, "support for block multi-queue (def=1)");
fc13638a 5722MODULE_PARM_DESC(tur_ms_to_ready, "TEST UNIT READY millisecs before initial good status (def=0)");
5b94e232
MP		 5723MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)");
5724MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=1)");
6014759c
MP		 5725MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0xffffffff)");
5726MODULE_PARM_DESC(unmap_max_desc, "max # of ranges that can be unmapped in one cmd (def=256)");
09ba24c1
DG		 5727MODULE_PARM_DESC(uuid_ctl,
5728 "1->use uuid for lu name, 0->don't, 2->all use same (def=0)");
c2248fc9 5729MODULE_PARM_DESC(virtual_gb, "virtual gigabyte (GiB) size (def=0 -> use dev_size_mb)");
5b94e232 5730MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
9447b6ce 5731MODULE_PARM_DESC(wp, "Write Protect (def=0)");
5b94e232 5732MODULE_PARM_DESC(write_same_length, "Maximum blocks per WRITE SAME cmd (def=0xffff)");
9267e0eb 5733MODULE_PARM_DESC(zbc, "'none' [0]; 'aware' [1]; 'managed' [2] (def=0). Can have 'host-' prefix");
380603a5 5734MODULE_PARM_DESC(zone_max_open, "Maximum number of open zones; [0] for no limit (def=auto)");
aa8fecf9 5735MODULE_PARM_DESC(zone_nr_conv, "Number of conventional zones (def=1)");
98e0a689 5736MODULE_PARM_DESC(zone_size_mb, "Zone size in MiB (def=auto)");
1da177e4 5737
760f3b03
DG		 5738#define SDEBUG_INFO_LEN 256
5739static char sdebug_info[SDEBUG_INFO_LEN];
1da177e4 5740
91d4c752 5741static const char *scsi_debug_info(struct Scsi_Host *shp)
1da177e4 5742{
c4837394
DG		 5743 int k;
5744
760f3b03
DG		 5745 k = scnprintf(sdebug_info, SDEBUG_INFO_LEN, "%s: version %s [%s]\n",
5746 my_name, SDEBUG_VERSION, sdebug_version_date);
5747 if (k >= (SDEBUG_INFO_LEN - 1))
c4837394 5748 return sdebug_info;
760f3b03
DG		 5749 scnprintf(sdebug_info + k, SDEBUG_INFO_LEN - k,
5750 " dev_size_mb=%d, opts=0x%x, submit_queues=%d, %s=%d",
5751 sdebug_dev_size_mb, sdebug_opts, submit_queues,
5752 "statistics", (int)sdebug_statistics);
1da177e4
LT		 5753 return sdebug_info;
5754}
5755
cbf67842 5756/* 'echo <val> > /proc/scsi/scsi_debug/<host_id>' writes to opts */
fd32119b
DG		 5757static int scsi_debug_write_info(struct Scsi_Host *host, char *buffer,
5758 int length)
1da177e4 5759{
c8ed555a
AV		 5760 char arr[16];
5761 int opts;
5762 int minLen = length > 15 ? 15 : length;
1da177e4 5763
c8ed555a
AV		 5764 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
5765 return -EACCES;
5766 memcpy(arr, buffer, minLen);
5767 arr[minLen] = '\0';
5768 if (1 != sscanf(arr, "%d", &opts))
5769 return -EINVAL;
773642d9
DG		 5770 sdebug_opts = opts;
5771 sdebug_verbose = !!(SDEBUG_OPT_NOISE & opts);
5772 sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & opts);
5773 if (sdebug_every_nth != 0)
c4837394 5774 tweak_cmnd_count();
c8ed555a
AV		 5775 return length;
5776}
1da177e4 5777
cbf67842
DG		 5778/* Output seen with 'cat /proc/scsi/scsi_debug/<host_id>'. It will be the
5779 * same for each scsi_debug host (if more than one). Some of the counters
5780 * output are not atomics so might be inaccurate in a busy system. */
c8ed555a
AV		 5781static int scsi_debug_show_info(struct seq_file *m, struct Scsi_Host *host)
5782{
c4837394
DG		 5783 int f, j, l;
5784 struct sdebug_queue *sqp;
87c715dc 5785 struct sdebug_host_info *sdhp;
c4837394
DG		 5786
5787 seq_printf(m, "scsi_debug adapter driver, version %s [%s]\n",
5788 SDEBUG_VERSION, sdebug_version_date);
5789 seq_printf(m, "num_tgts=%d, %ssize=%d MB, opts=0x%x, every_nth=%d\n",
5790 sdebug_num_tgts, "shared (ram) ", sdebug_dev_size_mb,
5791 sdebug_opts, sdebug_every_nth);
5792 seq_printf(m, "delay=%d, ndelay=%d, max_luns=%d, sector_size=%d %s\n",
5793 sdebug_jdelay, sdebug_ndelay, sdebug_max_luns,
5794 sdebug_sector_size, "bytes");
5795 seq_printf(m, "cylinders=%d, heads=%d, sectors=%d, command aborts=%d\n",
5796 sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
5797 num_aborts);
5798 seq_printf(m, "RESETs: device=%d, target=%d, bus=%d, host=%d\n",
5799 num_dev_resets, num_target_resets, num_bus_resets,
5800 num_host_resets);
5801 seq_printf(m, "dix_reads=%d, dix_writes=%d, dif_errors=%d\n",
5802 dix_reads, dix_writes, dif_errors);
458df78b
BVA		 5803 seq_printf(m, "usec_in_jiffy=%lu, statistics=%d\n", TICK_NSEC / 1000,
5804 sdebug_statistics);
4a0c6f43 5805 seq_printf(m, "cmnd_count=%d, completions=%d, %s=%d, a_tsf=%d, mq_polls=%d\n",
c4837394
DG		 5806 atomic_read(&sdebug_cmnd_count),
5807 atomic_read(&sdebug_completions),
5808 "miss_cpus", atomic_read(&sdebug_miss_cpus),
4a0c6f43
DG		 5809 atomic_read(&sdebug_a_tsf),
5810 atomic_read(&sdeb_mq_poll_count));
c4837394
DG		 5811
5812 seq_printf(m, "submit_queues=%d\n", submit_queues);
5813 for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
5814 seq_printf(m, " queue %d:\n", j);
5815 f = find_first_bit(sqp->in_use_bm, sdebug_max_queue);
5816 if (f != sdebug_max_queue) {
5817 l = find_last_bit(sqp->in_use_bm, sdebug_max_queue);
5818 seq_printf(m, " in_use_bm BUSY: %s: %d,%d\n",
5819 "first,last bits", f, l);
5820 }
cbf67842 5821 }
87c715dc
DG		 5822
5823 seq_printf(m, "this host_no=%d\n", host->host_no);
5824 if (!xa_empty(per_store_ap)) {
5825 bool niu;
5826 int idx;
5827 unsigned long l_idx;
5828 struct sdeb_store_info *sip;
5829
5830 seq_puts(m, "\nhost list:\n");
5831 j = 0;
5832 list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
5833 idx = sdhp->si_idx;
5834 seq_printf(m, " %d: host_no=%d, si_idx=%d\n", j,
5835 sdhp->shost->host_no, idx);
5836 ++j;
5837 }
5838 seq_printf(m, "\nper_store array [most_recent_idx=%d]:\n",
5839 sdeb_most_recent_idx);
5840 j = 0;
5841 xa_for_each(per_store_ap, l_idx, sip) {
5842 niu = xa_get_mark(per_store_ap, l_idx,
5843 SDEB_XA_NOT_IN_USE);
5844 idx = (int)l_idx;
5845 seq_printf(m, " %d: idx=%d%s\n", j, idx,
5846 (niu ? " not_in_use" : ""));
5847 ++j;
5848 }
5849 }
c8ed555a 5850 return 0;
1da177e4
LT		 5851}
5852
82069379 5853static ssize_t delay_show(struct device_driver *ddp, char *buf)
1da177e4 5854{
c2206098 5855 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_jdelay);
1da177e4 5856}
c4837394
DG		 5857/* Returns -EBUSY if jdelay is being changed and commands are queued. The unit
5858 * of delay is jiffies.
5859 */
82069379
AM		 5860static ssize_t delay_store(struct device_driver *ddp, const char *buf,
5861 size_t count)
1da177e4 5862{
c2206098 5863 int jdelay, res;
cbf67842 5864
b01f6f83 5865 if (count > 0 && sscanf(buf, "%d", &jdelay) == 1) {
cbf67842 5866 res = count;
c2206098 5867 if (sdebug_jdelay != jdelay) {
c4837394
DG		 5868 int j, k;
5869 struct sdebug_queue *sqp;
5870
5871 block_unblock_all_queues(true);
5872 for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
5873 ++j, ++sqp) {
5874 k = find_first_bit(sqp->in_use_bm,
5875 sdebug_max_queue);
5876 if (k != sdebug_max_queue) {
5877 res = -EBUSY; /* queued commands */
5878 break;
5879 }
5880 }
5881 if (res > 0) {
c2206098 5882 sdebug_jdelay = jdelay;
773642d9 5883 sdebug_ndelay = 0;
cbf67842 5884 }
c4837394 5885 block_unblock_all_queues(false);
1da177e4 5886 }
cbf67842 5887 return res;
1da177e4
LT		 5888 }
5889 return -EINVAL;
5890}
82069379 5891static DRIVER_ATTR_RW(delay);
1da177e4 5892
cbf67842
DG		 5893static ssize_t ndelay_show(struct device_driver *ddp, char *buf)
5894{
773642d9 5895 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ndelay);
cbf67842
DG		 5896}
5897/* Returns -EBUSY if ndelay is being changed and commands are queued */
c2206098 5898/* If > 0 and accepted then sdebug_jdelay is set to JDELAY_OVERRIDDEN */
cbf67842 5899static ssize_t ndelay_store(struct device_driver *ddp, const char *buf,
fd32119b 5900 size_t count)
cbf67842 5901{
c4837394 5902 int ndelay, res;
cbf67842
DG		 5903
5904 if ((count > 0) && (1 == sscanf(buf, "%d", &ndelay)) &&
c4837394 5905 (ndelay >= 0) && (ndelay < (1000 * 1000 * 1000))) {
cbf67842 5906 res = count;
773642d9 5907 if (sdebug_ndelay != ndelay) {
c4837394
DG		 5908 int j, k;
5909 struct sdebug_queue *sqp;
5910
5911 block_unblock_all_queues(true);
5912 for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
5913 ++j, ++sqp) {
5914 k = find_first_bit(sqp->in_use_bm,
5915 sdebug_max_queue);
5916 if (k != sdebug_max_queue) {
5917 res = -EBUSY; /* queued commands */
5918 break;
5919 }
5920 }
5921 if (res > 0) {
773642d9 5922 sdebug_ndelay = ndelay;
c2206098
DG		 5923 sdebug_jdelay = ndelay ? JDELAY_OVERRIDDEN
5924 : DEF_JDELAY;
cbf67842 5925 }
c4837394 5926 block_unblock_all_queues(false);
cbf67842
DG		 5927 }
5928 return res;
5929 }
5930 return -EINVAL;
5931}
5932static DRIVER_ATTR_RW(ndelay);
5933
82069379 5934static ssize_t opts_show(struct device_driver *ddp, char *buf)
1da177e4 5935{
773642d9 5936 return scnprintf(buf, PAGE_SIZE, "0x%x\n", sdebug_opts);
1da177e4
LT		 5937}
5938
82069379
AM		 5939static ssize_t opts_store(struct device_driver *ddp, const char *buf,
5940 size_t count)
1da177e4 5941{
9a051019 5942 int opts;
1da177e4
LT		 5943 char work[20];
5944
9a051019
DG		 5945 if (sscanf(buf, "%10s", work) == 1) {
5946 if (strncasecmp(work, "0x", 2) == 0) {
5947 if (kstrtoint(work + 2, 16, &opts) == 0)
1da177e4
LT		 5948 goto opts_done;
5949 } else {
9a051019 5950 if (kstrtoint(work, 10, &opts) == 0)
1da177e4
LT		 5951 goto opts_done;
5952 }
5953 }
5954 return -EINVAL;
5955opts_done:
773642d9
DG		 5956 sdebug_opts = opts;
5957 sdebug_verbose = !!(SDEBUG_OPT_NOISE & opts);
5958 sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & opts);
c4837394 5959 tweak_cmnd_count();
1da177e4
LT		 5960 return count;
5961}
82069379 5962static DRIVER_ATTR_RW(opts);
1da177e4 5963
82069379 5964static ssize_t ptype_show(struct device_driver *ddp, char *buf)
1da177e4 5965{
773642d9 5966 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ptype);
1da177e4 5967}
82069379
AM		 5968static ssize_t ptype_store(struct device_driver *ddp, const char *buf,
5969 size_t count)
1da177e4 5970{
9a051019 5971 int n;
1da177e4 5972
f0d1cf93
DG		 5973 /* Cannot change from or to TYPE_ZBC with sysfs */
5974 if (sdebug_ptype == TYPE_ZBC)
5975 return -EINVAL;
5976
1da177e4 5977 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
f0d1cf93
DG		 5978 if (n == TYPE_ZBC)
5979 return -EINVAL;
773642d9 5980 sdebug_ptype = n;
1da177e4
LT		 5981 return count;
5982 }
5983 return -EINVAL;
5984}
82069379 5985static DRIVER_ATTR_RW(ptype);
1da177e4 5986
82069379 5987static ssize_t dsense_show(struct device_driver *ddp, char *buf)
1da177e4 5988{
773642d9 5989 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dsense);
1da177e4 5990}
82069379
AM		 5991static ssize_t dsense_store(struct device_driver *ddp, const char *buf,
5992 size_t count)
1da177e4 5993{
9a051019 5994 int n;
1da177e4
LT		 5995
5996 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 5997 sdebug_dsense = n;
1da177e4
LT		 5998 return count;
5999 }
6000 return -EINVAL;
6001}
82069379 6002static DRIVER_ATTR_RW(dsense);
1da177e4 6003
82069379 6004static ssize_t fake_rw_show(struct device_driver *ddp, char *buf)
23183910 6005{
773642d9 6006 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_fake_rw);
23183910 6007}
82069379
AM		 6008static ssize_t fake_rw_store(struct device_driver *ddp, const char *buf,
6009 size_t count)
23183910 6010{
87c715dc 6011 int n, idx;
23183910
DG		 6012
6013 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
87c715dc
DG		 6014 bool want_store = (n == 0);
6015 struct sdebug_host_info *sdhp;
6016
cbf67842 6017 n = (n > 0);
773642d9 6018 sdebug_fake_rw = (sdebug_fake_rw > 0);
87c715dc
DG		 6019 if (sdebug_fake_rw == n)
6020 return count; /* not transitioning so do nothing */
6021
6022 if (want_store) { /* 1 --> 0 transition, set up store */
6023 if (sdeb_first_idx < 0) {
6024 idx = sdebug_add_store();
6025 if (idx < 0)
6026 return idx;
6027 } else {
6028 idx = sdeb_first_idx;
6029 xa_clear_mark(per_store_ap, idx,
6030 SDEB_XA_NOT_IN_USE);
6031 }
6032 /* make all hosts use same store */
6033 list_for_each_entry(sdhp, &sdebug_host_list,
6034 host_list) {
6035 if (sdhp->si_idx != idx) {
6036 xa_set_mark(per_store_ap, sdhp->si_idx,
6037 SDEB_XA_NOT_IN_USE);
6038 sdhp->si_idx = idx;
cbf67842 6039 }
cbf67842 6040 }
87c715dc
DG		 6041 sdeb_most_recent_idx = idx;
6042 } else { /* 0 --> 1 transition is trigger for shrink */
6043 sdebug_erase_all_stores(true /* apart from first */);
cbf67842 6044 }
87c715dc 6045 sdebug_fake_rw = n;
23183910
DG		 6046 return count;
6047 }
6048 return -EINVAL;
6049}
82069379 6050static DRIVER_ATTR_RW(fake_rw);
23183910 6051
82069379 6052static ssize_t no_lun_0_show(struct device_driver *ddp, char *buf)
c65b1445 6053{
773642d9 6054 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_lun_0);
c65b1445 6055}
82069379
AM		 6056static ssize_t no_lun_0_store(struct device_driver *ddp, const char *buf,
6057 size_t count)
c65b1445 6058{
9a051019 6059 int n;
c65b1445
DG		 6060
6061 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 6062 sdebug_no_lun_0 = n;
c65b1445
DG		 6063 return count;
6064 }
6065 return -EINVAL;
6066}
82069379 6067static DRIVER_ATTR_RW(no_lun_0);
c65b1445 6068
82069379 6069static ssize_t num_tgts_show(struct device_driver *ddp, char *buf)
1da177e4 6070{
773642d9 6071 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_tgts);
1da177e4 6072}
82069379
AM		 6073static ssize_t num_tgts_store(struct device_driver *ddp, const char *buf,
6074 size_t count)
1da177e4 6075{
9a051019 6076 int n;
1da177e4
LT		 6077
6078 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 6079 sdebug_num_tgts = n;
1da177e4
LT		 6080 sdebug_max_tgts_luns();
6081 return count;
6082 }
6083 return -EINVAL;
6084}
82069379 6085static DRIVER_ATTR_RW(num_tgts);
1da177e4 6086
82069379 6087static ssize_t dev_size_mb_show(struct device_driver *ddp, char *buf)
1da177e4 6088{
773642d9 6089 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dev_size_mb);
1da177e4 6090}
82069379 6091static DRIVER_ATTR_RO(dev_size_mb);
1da177e4 6092
87c715dc
DG		 6093static ssize_t per_host_store_show(struct device_driver *ddp, char *buf)
6094{
6095 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_per_host_store);
6096}
6097
6098static ssize_t per_host_store_store(struct device_driver *ddp, const char *buf,
6099 size_t count)
6100{
6101 bool v;
6102
6103 if (kstrtobool(buf, &v))
6104 return -EINVAL;
6105
6106 sdebug_per_host_store = v;
6107 return count;
6108}
6109static DRIVER_ATTR_RW(per_host_store);
6110
82069379 6111static ssize_t num_parts_show(struct device_driver *ddp, char *buf)
1da177e4 6112{
773642d9 6113 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_parts);
1da177e4 6114}
82069379 6115static DRIVER_ATTR_RO(num_parts);
1da177e4 6116
82069379 6117static ssize_t every_nth_show(struct device_driver *ddp, char *buf)
1da177e4 6118{
773642d9 6119 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_every_nth);
1da177e4 6120}
82069379
AM		 6121static ssize_t every_nth_store(struct device_driver *ddp, const char *buf,
6122 size_t count)
1da177e4 6123{
9a051019 6124 int nth;
3a90a63d 6125 char work[20];
1da177e4 6126
3a90a63d
DG		 6127 if (sscanf(buf, "%10s", work) == 1) {
6128 if (strncasecmp(work, "0x", 2) == 0) {
6129 if (kstrtoint(work + 2, 16, &nth) == 0)
6130 goto every_nth_done;
6131 } else {
6132 if (kstrtoint(work, 10, &nth) == 0)
6133 goto every_nth_done;
c4837394 6134 }
1da177e4
LT		 6135 }
6136 return -EINVAL;
3a90a63d
DG		 6137
6138every_nth_done:
6139 sdebug_every_nth = nth;
6140 if (nth && !sdebug_statistics) {
6141 pr_info("every_nth needs statistics=1, set it\n");
6142 sdebug_statistics = true;
6143 }
6144 tweak_cmnd_count();
6145 return count;
1da177e4 6146}
82069379 6147static DRIVER_ATTR_RW(every_nth);
1da177e4 6148
ad0c7775
DG		 6149static ssize_t lun_format_show(struct device_driver *ddp, char *buf)
6150{
6151 return scnprintf(buf, PAGE_SIZE, "%d\n", (int)sdebug_lun_am);
6152}
6153static ssize_t lun_format_store(struct device_driver *ddp, const char *buf,
6154 size_t count)
6155{
6156 int n;
6157 bool changed;
6158
6159 if (kstrtoint(buf, 0, &n))
6160 return -EINVAL;
6161 if (n >= 0) {
6162 if (n > (int)SAM_LUN_AM_FLAT) {
6163 pr_warn("only LUN address methods 0 and 1 are supported\n");
6164 return -EINVAL;
6165 }
6166 changed = ((int)sdebug_lun_am != n);
6167 sdebug_lun_am = n;
6168 if (changed && sdebug_scsi_level >= 5) { /* >= SPC-3 */
6169 struct sdebug_host_info *sdhp;
6170 struct sdebug_dev_info *dp;
6171
6172 spin_lock(&sdebug_host_list_lock);
6173 list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
6174 list_for_each_entry(dp, &sdhp->dev_info_list, dev_list) {
6175 set_bit(SDEBUG_UA_LUNS_CHANGED, dp->uas_bm);
6176 }
6177 }
6178 spin_unlock(&sdebug_host_list_lock);
6179 }
6180 return count;
6181 }
6182 return -EINVAL;
6183}
6184static DRIVER_ATTR_RW(lun_format);
6185
82069379 6186static ssize_t max_luns_show(struct device_driver *ddp, char *buf)
1da177e4 6187{
773642d9 6188 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_max_luns);
1da177e4 6189}
82069379
AM		 6190static ssize_t max_luns_store(struct device_driver *ddp, const char *buf,
6191 size_t count)
1da177e4 6192{
9a051019 6193 int n;
19c8ead7 6194 bool changed;
1da177e4
LT		 6195
6196 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
8d039e22
DG		 6197 if (n > 256) {
6198 pr_warn("max_luns can be no more than 256\n");
6199 return -EINVAL;
6200 }
773642d9
DG		 6201 changed = (sdebug_max_luns != n);
6202 sdebug_max_luns = n;
1da177e4 6203 sdebug_max_tgts_luns();
773642d9 6204 if (changed && (sdebug_scsi_level >= 5)) { /* >= SPC-3 */
19c8ead7
EM		 6205 struct sdebug_host_info *sdhp;
6206 struct sdebug_dev_info *dp;
6207
6208 spin_lock(&sdebug_host_list_lock);
6209 list_for_each_entry(sdhp, &sdebug_host_list,
6210 host_list) {
6211 list_for_each_entry(dp, &sdhp->dev_info_list,
6212 dev_list) {
6213 set_bit(SDEBUG_UA_LUNS_CHANGED,
6214 dp->uas_bm);
6215 }
6216 }
6217 spin_unlock(&sdebug_host_list_lock);
6218 }
1da177e4
LT		 6219 return count;
6220 }
6221 return -EINVAL;
6222}
82069379 6223static DRIVER_ATTR_RW(max_luns);
1da177e4 6224
82069379 6225static ssize_t max_queue_show(struct device_driver *ddp, char *buf)
78d4e5a0 6226{
773642d9 6227 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_max_queue);
78d4e5a0 6228}
cbf67842
DG		 6229/* N.B. max_queue can be changed while there are queued commands. In flight
6230 * commands beyond the new max_queue will be completed. */
82069379
AM		 6231static ssize_t max_queue_store(struct device_driver *ddp, const char *buf,
6232 size_t count)
78d4e5a0 6233{
c4837394
DG		 6234 int j, n, k, a;
6235 struct sdebug_queue *sqp;
78d4e5a0
DG		 6236
6237 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n > 0) &&
c10fa55f
JG		 6238 (n <= SDEBUG_CANQUEUE) &&
6239 (sdebug_host_max_queue == 0)) {
c4837394
DG		 6240 block_unblock_all_queues(true);
6241 k = 0;
6242 for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
6243 ++j, ++sqp) {
6244 a = find_last_bit(sqp->in_use_bm, SDEBUG_CANQUEUE);
6245 if (a > k)
6246 k = a;
6247 }
773642d9 6248 sdebug_max_queue = n;
c4837394 6249 if (k == SDEBUG_CANQUEUE)
cbf67842
DG		 6250 atomic_set(&retired_max_queue, 0);
6251 else if (k >= n)
6252 atomic_set(&retired_max_queue, k + 1);
6253 else
6254 atomic_set(&retired_max_queue, 0);
c4837394 6255 block_unblock_all_queues(false);
78d4e5a0
DG		 6256 return count;
6257 }
6258 return -EINVAL;
6259}
82069379 6260static DRIVER_ATTR_RW(max_queue);
78d4e5a0 6261
c10fa55f
JG		 6262static ssize_t host_max_queue_show(struct device_driver *ddp, char *buf)
6263{
6264 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_host_max_queue);
6265}
6266
6267/*
6268 * Since this is used for .can_queue, and we get the hc_idx tag from the bitmap
6269 * in range [0, sdebug_host_max_queue), we can't change it.
6270 */
6271static DRIVER_ATTR_RO(host_max_queue);
6272
82069379 6273static ssize_t no_uld_show(struct device_driver *ddp, char *buf)
78d4e5a0 6274{
773642d9 6275 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_uld);
78d4e5a0 6276}
82069379 6277static DRIVER_ATTR_RO(no_uld);
78d4e5a0 6278
82069379 6279static ssize_t scsi_level_show(struct device_driver *ddp, char *buf)
1da177e4 6280{
773642d9 6281 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_scsi_level);
1da177e4 6282}
82069379 6283static DRIVER_ATTR_RO(scsi_level);
1da177e4 6284
82069379 6285static ssize_t virtual_gb_show(struct device_driver *ddp, char *buf)
c65b1445 6286{
773642d9 6287 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_virtual_gb);
c65b1445 6288}
82069379
AM		 6289static ssize_t virtual_gb_store(struct device_driver *ddp, const char *buf,
6290 size_t count)
c65b1445 6291{
9a051019 6292 int n;
0d01c5df 6293 bool changed;
c65b1445 6294
f0d1cf93
DG		 6295 /* Ignore capacity change for ZBC drives for now */
6296 if (sdeb_zbc_in_use)
6297 return -ENOTSUPP;
6298
c65b1445 6299 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9
DG		 6300 changed = (sdebug_virtual_gb != n);
6301 sdebug_virtual_gb = n;
28898873 6302 sdebug_capacity = get_sdebug_capacity();
0d01c5df
DG		 6303 if (changed) {
6304 struct sdebug_host_info *sdhp;
6305 struct sdebug_dev_info *dp;
6306
4bc6b634 6307 spin_lock(&sdebug_host_list_lock);
0d01c5df
DG		 6308 list_for_each_entry(sdhp, &sdebug_host_list,
6309 host_list) {
6310 list_for_each_entry(dp, &sdhp->dev_info_list,
6311 dev_list) {
6312 set_bit(SDEBUG_UA_CAPACITY_CHANGED,
6313 dp->uas_bm);
6314 }
6315 }
4bc6b634 6316 spin_unlock(&sdebug_host_list_lock);
0d01c5df 6317 }
c65b1445
DG		 6318 return count;
6319 }
6320 return -EINVAL;
6321}
82069379 6322static DRIVER_ATTR_RW(virtual_gb);
c65b1445 6323
82069379 6324static ssize_t add_host_show(struct device_driver *ddp, char *buf)
1da177e4 6325{
87c715dc
DG		 6326 /* absolute number of hosts currently active is what is shown */
6327 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_hosts);
1da177e4
LT		 6328}
6329
82069379
AM		 6330static ssize_t add_host_store(struct device_driver *ddp, const char *buf,
6331 size_t count)
1da177e4 6332{
87c715dc
DG		 6333 bool found;
6334 unsigned long idx;
6335 struct sdeb_store_info *sip;
6336 bool want_phs = (sdebug_fake_rw == 0) && sdebug_per_host_store;
f3df41cf 6337 int delta_hosts;
1da177e4 6338
f3df41cf 6339 if (sscanf(buf, "%d", &delta_hosts) != 1)
1da177e4 6340 return -EINVAL;
1da177e4
LT		 6341 if (delta_hosts > 0) {
6342 do {
87c715dc
DG		 6343 found = false;
6344 if (want_phs) {
6345 xa_for_each_marked(per_store_ap, idx, sip,
6346 SDEB_XA_NOT_IN_USE) {
6347 sdeb_most_recent_idx = (int)idx;
6348 found = true;
6349 break;
6350 }
6351 if (found) /* re-use case */
6352 sdebug_add_host_helper((int)idx);
6353 else
6354 sdebug_do_add_host(true);
6355 } else {
6356 sdebug_do_add_host(false);
6357 }
1da177e4
LT		 6358 } while (--delta_hosts);
6359 } else if (delta_hosts < 0) {
6360 do {
87c715dc 6361 sdebug_do_remove_host(false);
1da177e4
LT		 6362 } while (++delta_hosts);
6363 }
6364 return count;
6365}
82069379 6366static DRIVER_ATTR_RW(add_host);
1da177e4 6367
82069379 6368static ssize_t vpd_use_hostno_show(struct device_driver *ddp, char *buf)
23183910 6369{
773642d9 6370 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_vpd_use_hostno);
23183910 6371}
82069379
AM		 6372static ssize_t vpd_use_hostno_store(struct device_driver *ddp, const char *buf,
6373 size_t count)
23183910
DG		 6374{
6375 int n;
6376
6377 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 6378 sdebug_vpd_use_hostno = n;
23183910
DG		 6379 return count;
6380 }
6381 return -EINVAL;
6382}
82069379 6383static DRIVER_ATTR_RW(vpd_use_hostno);
23183910 6384
c4837394
DG		 6385static ssize_t statistics_show(struct device_driver *ddp, char *buf)
6386{
6387 return scnprintf(buf, PAGE_SIZE, "%d\n", (int)sdebug_statistics);
6388}
6389static ssize_t statistics_store(struct device_driver *ddp, const char *buf,
6390 size_t count)
6391{
6392 int n;
6393
6394 if ((count > 0) && (sscanf(buf, "%d", &n) == 1) && (n >= 0)) {
6395 if (n > 0)
6396 sdebug_statistics = true;
6397 else {
6398 clear_queue_stats();
6399 sdebug_statistics = false;
6400 }
6401 return count;
6402 }
6403 return -EINVAL;
6404}
6405static DRIVER_ATTR_RW(statistics);
6406
82069379 6407static ssize_t sector_size_show(struct device_driver *ddp, char *buf)
597136ab 6408{
773642d9 6409 return scnprintf(buf, PAGE_SIZE, "%u\n", sdebug_sector_size);
597136ab 6410}
82069379 6411static DRIVER_ATTR_RO(sector_size);
597136ab 6412
c4837394
DG		 6413static ssize_t submit_queues_show(struct device_driver *ddp, char *buf)
6414{
6415 return scnprintf(buf, PAGE_SIZE, "%d\n", submit_queues);
6416}
6417static DRIVER_ATTR_RO(submit_queues);
6418
82069379 6419static ssize_t dix_show(struct device_driver *ddp, char *buf)
c6a44287 6420{
773642d9 6421 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dix);
c6a44287 6422}
82069379 6423static DRIVER_ATTR_RO(dix);
c6a44287 6424
82069379 6425static ssize_t dif_show(struct device_driver *ddp, char *buf)
c6a44287 6426{
773642d9 6427 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dif);
c6a44287 6428}
82069379 6429static DRIVER_ATTR_RO(dif);
c6a44287 6430
82069379 6431static ssize_t guard_show(struct device_driver *ddp, char *buf)
c6a44287 6432{
773642d9 6433 return scnprintf(buf, PAGE_SIZE, "%u\n", sdebug_guard);
c6a44287 6434}
82069379 6435static DRIVER_ATTR_RO(guard);
c6a44287 6436
82069379 6437static ssize_t ato_show(struct device_driver *ddp, char *buf)
c6a44287 6438{
773642d9 6439 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ato);
c6a44287 6440}
82069379 6441static DRIVER_ATTR_RO(ato);
c6a44287 6442
82069379 6443static ssize_t map_show(struct device_driver *ddp, char *buf)
44d92694 6444{
87c715dc 6445 ssize_t count = 0;
44d92694 6446
5b94e232 6447 if (!scsi_debug_lbp())
44d92694
MP		 6448 return scnprintf(buf, PAGE_SIZE, "0-%u\n",
6449 sdebug_store_sectors);
6450
87c715dc
DG		 6451 if (sdebug_fake_rw == 0 && !xa_empty(per_store_ap)) {
6452 struct sdeb_store_info *sip = xa_load(per_store_ap, 0);
6453
6454 if (sip)
6455 count = scnprintf(buf, PAGE_SIZE - 1, "%*pbl",
6456 (int)map_size, sip->map_storep);
6457 }
44d92694 6458 buf[count++] = '\n';
c7badc90 6459 buf[count] = '\0';
44d92694
MP		 6460
6461 return count;
6462}
82069379 6463static DRIVER_ATTR_RO(map);
44d92694 6464
0c4bc91d
DG		 6465static ssize_t random_show(struct device_driver *ddp, char *buf)
6466{
6467 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_random);
6468}
6469
6470static ssize_t random_store(struct device_driver *ddp, const char *buf,
6471 size_t count)
6472{
6473 bool v;
6474
6475 if (kstrtobool(buf, &v))
6476 return -EINVAL;
6477
6478 sdebug_random = v;
6479 return count;
6480}
6481static DRIVER_ATTR_RW(random);
6482
82069379 6483static ssize_t removable_show(struct device_driver *ddp, char *buf)
d986788b 6484{
773642d9 6485 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_removable ? 1 : 0);
d986788b 6486}
82069379
AM		 6487static ssize_t removable_store(struct device_driver *ddp, const char *buf,
6488 size_t count)
d986788b
MP		 6489{
6490 int n;
6491
6492 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 6493 sdebug_removable = (n > 0);
d986788b
MP		 6494 return count;
6495 }
6496 return -EINVAL;
6497}
82069379 6498static DRIVER_ATTR_RW(removable);
d986788b 6499
cbf67842
DG		 6500static ssize_t host_lock_show(struct device_driver *ddp, char *buf)
6501{
773642d9 6502 return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_host_lock);
cbf67842 6503}
185dd232 6504/* N.B. sdebug_host_lock does nothing, kept for backward compatibility */
cbf67842
DG		 6505static ssize_t host_lock_store(struct device_driver *ddp, const char *buf,
6506 size_t count)
6507{
185dd232 6508 int n;
cbf67842
DG		 6509
6510 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
185dd232
DG		 6511 sdebug_host_lock = (n > 0);
6512 return count;
cbf67842
DG		 6513 }
6514 return -EINVAL;
6515}
6516static DRIVER_ATTR_RW(host_lock);
6517
c2248fc9
DG		 6518static ssize_t strict_show(struct device_driver *ddp, char *buf)
6519{
773642d9 6520 return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_strict);
c2248fc9
DG		 6521}
6522static ssize_t strict_store(struct device_driver *ddp, const char *buf,
6523 size_t count)
6524{
6525 int n;
6526
6527 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
773642d9 6528 sdebug_strict = (n > 0);
c2248fc9
DG		 6529 return count;
6530 }
6531 return -EINVAL;
6532}
6533static DRIVER_ATTR_RW(strict);
6534
09ba24c1
DG		 6535static ssize_t uuid_ctl_show(struct device_driver *ddp, char *buf)
6536{
6537 return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_uuid_ctl);
6538}
6539static DRIVER_ATTR_RO(uuid_ctl);
6540
9b760fd8
DG		 6541static ssize_t cdb_len_show(struct device_driver *ddp, char *buf)
6542{
6543 return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_cdb_len);
6544}
6545static ssize_t cdb_len_store(struct device_driver *ddp, const char *buf,
6546 size_t count)
6547{
6548 int ret, n;
6549
6550 ret = kstrtoint(buf, 0, &n);
6551 if (ret)
6552 return ret;
6553 sdebug_cdb_len = n;
6554 all_config_cdb_len();
6555 return count;
6556}
6557static DRIVER_ATTR_RW(cdb_len);
6558
9267e0eb
DG		 6559static const char * const zbc_model_strs_a[] = {
6560 [BLK_ZONED_NONE] = "none",
6561 [BLK_ZONED_HA] = "host-aware",
6562 [BLK_ZONED_HM] = "host-managed",
6563};
6564
6565static const char * const zbc_model_strs_b[] = {
6566 [BLK_ZONED_NONE] = "no",
6567 [BLK_ZONED_HA] = "aware",
6568 [BLK_ZONED_HM] = "managed",
6569};
6570
6571static const char * const zbc_model_strs_c[] = {
6572 [BLK_ZONED_NONE] = "0",
6573 [BLK_ZONED_HA] = "1",
6574 [BLK_ZONED_HM] = "2",
6575};
6576
6577static int sdeb_zbc_model_str(const char *cp)
6578{
6579 int res = sysfs_match_string(zbc_model_strs_a, cp);
6580
6581 if (res < 0) {
6582 res = sysfs_match_string(zbc_model_strs_b, cp);
6583 if (res < 0) {
6584 res = sysfs_match_string(zbc_model_strs_c, cp);
47742bde 6585 if (res < 0)
9267e0eb
DG		 6586 return -EINVAL;
6587 }
6588 }
6589 return res;
6590}
6591
6592static ssize_t zbc_show(struct device_driver *ddp, char *buf)
6593{
6594 return scnprintf(buf, PAGE_SIZE, "%s\n",
6595 zbc_model_strs_a[sdeb_zbc_model]);
6596}
6597static DRIVER_ATTR_RO(zbc);
cbf67842 6598
fc13638a
DG		 6599static ssize_t tur_ms_to_ready_show(struct device_driver *ddp, char *buf)
6600{
6601 return scnprintf(buf, PAGE_SIZE, "%d\n", sdeb_tur_ms_to_ready);
6602}
6603static DRIVER_ATTR_RO(tur_ms_to_ready);
6604
82069379 6605/* Note: The following array creates attribute files in the
23183910
DG		 6606 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
6607 files (over those found in the /sys/module/scsi_debug/parameters
6608 directory) is that auxiliary actions can be triggered when an attribute
87c715dc 6609 is changed. For example see: add_host_store() above.
23183910 6610 */
6ecaff7f 6611
82069379
AM		 6612static struct attribute *sdebug_drv_attrs[] = {
6613 &driver_attr_delay.attr,
6614 &driver_attr_opts.attr,
6615 &driver_attr_ptype.attr,
6616 &driver_attr_dsense.attr,
6617 &driver_attr_fake_rw.attr,
c10fa55f 6618 &driver_attr_host_max_queue.attr,
82069379
AM		 6619 &driver_attr_no_lun_0.attr,
6620 &driver_attr_num_tgts.attr,
6621 &driver_attr_dev_size_mb.attr,
6622 &driver_attr_num_parts.attr,
6623 &driver_attr_every_nth.attr,
ad0c7775 6624 &driver_attr_lun_format.attr,
82069379
AM		 6625 &driver_attr_max_luns.attr,
6626 &driver_attr_max_queue.attr,
6627 &driver_attr_no_uld.attr,
6628 &driver_attr_scsi_level.attr,
6629 &driver_attr_virtual_gb.attr,
6630 &driver_attr_add_host.attr,
87c715dc 6631 &driver_attr_per_host_store.attr,
82069379
AM		 6632 &driver_attr_vpd_use_hostno.attr,
6633 &driver_attr_sector_size.attr,
c4837394
DG		 6634 &driver_attr_statistics.attr,
6635 &driver_attr_submit_queues.attr,
82069379
AM		 6636 &driver_attr_dix.attr,
6637 &driver_attr_dif.attr,
6638 &driver_attr_guard.attr,
6639 &driver_attr_ato.attr,
6640 &driver_attr_map.attr,
0c4bc91d 6641 &driver_attr_random.attr,
82069379 6642 &driver_attr_removable.attr,
cbf67842
DG		 6643 &driver_attr_host_lock.attr,
6644 &driver_attr_ndelay.attr,
c2248fc9 6645 &driver_attr_strict.attr,
09ba24c1 6646 &driver_attr_uuid_ctl.attr,
9b760fd8 6647 &driver_attr_cdb_len.attr,
fc13638a 6648 &driver_attr_tur_ms_to_ready.attr,
9267e0eb 6649 &driver_attr_zbc.attr,
82069379
AM		 6650 NULL,
6651};
6652ATTRIBUTE_GROUPS(sdebug_drv);
1da177e4 6653
11ddceca 6654static struct device *pseudo_primary;
8dea0d02 6655
1da177e4
LT		 6656static int __init scsi_debug_init(void)
6657{
87c715dc 6658 bool want_store = (sdebug_fake_rw == 0);
5f2578e5 6659 unsigned long sz;
87c715dc
DG		 6660 int k, ret, hosts_to_add;
6661 int idx = -1;
1da177e4 6662
87c715dc
DG		 6663 ramdisk_lck_a[0] = &atomic_rw;
6664 ramdisk_lck_a[1] = &atomic_rw2;
cbf67842
DG		 6665 atomic_set(&retired_max_queue, 0);
6666
773642d9 6667 if (sdebug_ndelay >= 1000 * 1000 * 1000) {
c1287970 6668 pr_warn("ndelay must be less than 1 second, ignored\n");
773642d9
DG		 6669 sdebug_ndelay = 0;
6670 } else if (sdebug_ndelay > 0)
c2206098 6671 sdebug_jdelay = JDELAY_OVERRIDDEN;
cbf67842 6672
773642d9 6673 switch (sdebug_sector_size) {
597136ab
MP		 6674 case 512:
6675 case 1024:
6676 case 2048:
6677 case 4096:
6678 break;
6679 default:
773642d9 6680 pr_err("invalid sector_size %d\n", sdebug_sector_size);
597136ab
MP		 6681 return -EINVAL;
6682 }
6683
773642d9 6684 switch (sdebug_dif) {
8475c811 6685 case T10_PI_TYPE0_PROTECTION:
f46eb0e9 6686 break;
8475c811
CH		 6687 case T10_PI_TYPE1_PROTECTION:
6688 case T10_PI_TYPE2_PROTECTION:
6689 case T10_PI_TYPE3_PROTECTION:
f46eb0e9 6690 have_dif_prot = true;
c6a44287
MP		 6691 break;
6692
6693 default:
c1287970 6694 pr_err("dif must be 0, 1, 2 or 3\n");
c6a44287
MP		 6695 return -EINVAL;
6696 }
6697
aa5334c4
ML		 6698 if (sdebug_num_tgts < 0) {
6699 pr_err("num_tgts must be >= 0\n");
6700 return -EINVAL;
6701 }
6702
773642d9 6703 if (sdebug_guard > 1) {
c1287970 6704 pr_err("guard must be 0 or 1\n");
c6a44287
MP		 6705 return -EINVAL;
6706 }
6707
773642d9 6708 if (sdebug_ato > 1) {
c1287970 6709 pr_err("ato must be 0 or 1\n");
c6a44287
MP		 6710 return -EINVAL;
6711 }
6712
773642d9
DG		 6713 if (sdebug_physblk_exp > 15) {
6714 pr_err("invalid physblk_exp %u\n", sdebug_physblk_exp);
ea61fca5
MP		 6715 return -EINVAL;
6716 }
ad0c7775
DG		 6717
6718 sdebug_lun_am = sdebug_lun_am_i;
6719 if (sdebug_lun_am > SAM_LUN_AM_FLAT) {
6720 pr_warn("Invalid LUN format %u, using default\n", (int)sdebug_lun_am);
6721 sdebug_lun_am = SAM_LUN_AM_PERIPHERAL;
6722 }
6723
8d039e22 6724 if (sdebug_max_luns > 256) {
ad0c7775
DG		 6725 if (sdebug_max_luns > 16384) {
6726 pr_warn("max_luns can be no more than 16384, use default\n");
6727 sdebug_max_luns = DEF_MAX_LUNS;
6728 }
6729 sdebug_lun_am = SAM_LUN_AM_FLAT;
8d039e22 6730 }
ea61fca5 6731
773642d9
DG		 6732 if (sdebug_lowest_aligned > 0x3fff) {
6733 pr_err("lowest_aligned too big: %u\n", sdebug_lowest_aligned);
ea61fca5
MP		 6734 return -EINVAL;
6735 }
6736
c4837394
DG		 6737 if (submit_queues < 1) {
6738 pr_err("submit_queues must be 1 or more\n");
6739 return -EINVAL;
6740 }
c87bf24c
JG		 6741
6742 if ((sdebug_max_queue > SDEBUG_CANQUEUE) || (sdebug_max_queue < 1)) {
6743 pr_err("max_queue must be in range [1, %d]\n", SDEBUG_CANQUEUE);
6744 return -EINVAL;
6745 }
6746
c10fa55f
JG		 6747 if ((sdebug_host_max_queue > SDEBUG_CANQUEUE) ||
6748 (sdebug_host_max_queue < 0)) {
6749 pr_err("host_max_queue must be in range [0 %d]\n",
6750 SDEBUG_CANQUEUE);
6751 return -EINVAL;
6752 }
6753
6754 if (sdebug_host_max_queue &&
6755 (sdebug_max_queue != sdebug_host_max_queue)) {
6756 sdebug_max_queue = sdebug_host_max_queue;
6757 pr_warn("fixing max submit queue depth to host max queue depth, %d\n",
6758 sdebug_max_queue);
6759 }
6760
c4837394
DG		 6761 sdebug_q_arr = kcalloc(submit_queues, sizeof(struct sdebug_queue),
6762 GFP_KERNEL);
6763 if (sdebug_q_arr == NULL)
6764 return -ENOMEM;
6765 for (k = 0; k < submit_queues; ++k)
6766 spin_lock_init(&sdebug_q_arr[k].qc_lock);
6767
f0d1cf93 6768 /*
9267e0eb
DG		 6769 * check for host managed zoned block device specified with
6770 * ptype=0x14 or zbc=XXX.
f0d1cf93 6771 */
9267e0eb
DG		 6772 if (sdebug_ptype == TYPE_ZBC) {
6773 sdeb_zbc_model = BLK_ZONED_HM;
6774 } else if (sdeb_zbc_model_s && *sdeb_zbc_model_s) {
6775 k = sdeb_zbc_model_str(sdeb_zbc_model_s);
6776 if (k < 0) {
6777 ret = k;
3b01d7ea 6778 goto free_q_arr;
9267e0eb
DG		 6779 }
6780 sdeb_zbc_model = k;
6781 switch (sdeb_zbc_model) {
6782 case BLK_ZONED_NONE:
64e14ece 6783 case BLK_ZONED_HA:
9267e0eb
DG		 6784 sdebug_ptype = TYPE_DISK;
6785 break;
6786 case BLK_ZONED_HM:
6787 sdebug_ptype = TYPE_ZBC;
6788 break;
9267e0eb
DG		 6789 default:
6790 pr_err("Invalid ZBC model\n");
3b01d7ea
DL		 6791 ret = -EINVAL;
6792 goto free_q_arr;
9267e0eb
DG		 6793 }
6794 }
6795 if (sdeb_zbc_model != BLK_ZONED_NONE) {
f0d1cf93 6796 sdeb_zbc_in_use = true;
9267e0eb
DG		 6797 if (sdebug_dev_size_mb == DEF_DEV_SIZE_PRE_INIT)
6798 sdebug_dev_size_mb = DEF_ZBC_DEV_SIZE_MB;
6799 }
f0d1cf93 6800
9267e0eb
DG		 6801 if (sdebug_dev_size_mb == DEF_DEV_SIZE_PRE_INIT)
6802 sdebug_dev_size_mb = DEF_DEV_SIZE_MB;
773642d9
DG		 6803 if (sdebug_dev_size_mb < 1)
6804 sdebug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */
6805 sz = (unsigned long)sdebug_dev_size_mb * 1048576;
6806 sdebug_store_sectors = sz / sdebug_sector_size;
28898873 6807 sdebug_capacity = get_sdebug_capacity();
1da177e4
LT		 6808
6809 /* play around with geometry, don't waste too much on track 0 */
6810 sdebug_heads = 8;
6811 sdebug_sectors_per = 32;
773642d9 6812 if (sdebug_dev_size_mb >= 256)
1da177e4 6813 sdebug_heads = 64;
773642d9 6814 else if (sdebug_dev_size_mb >= 16)
fa785f0a 6815 sdebug_heads = 32;
1da177e4
LT		 6816 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
6817 (sdebug_sectors_per * sdebug_heads);
6818 if (sdebug_cylinders_per >= 1024) {
6819 /* other LLDs do this; implies >= 1GB ram disk ... */
6820 sdebug_heads = 255;
6821 sdebug_sectors_per = 63;
6822 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
6823 (sdebug_sectors_per * sdebug_heads);
6824 }
5b94e232 6825 if (scsi_debug_lbp()) {
773642d9
DG		 6826 sdebug_unmap_max_blocks =
6827 clamp(sdebug_unmap_max_blocks, 0U, 0xffffffffU);
6014759c 6828
773642d9
DG		 6829 sdebug_unmap_max_desc =
6830 clamp(sdebug_unmap_max_desc, 0U, 256U);
6014759c 6831
773642d9
DG		 6832 sdebug_unmap_granularity =
6833 clamp(sdebug_unmap_granularity, 1U, 0xffffffffU);
6014759c 6834
773642d9
DG		 6835 if (sdebug_unmap_alignment &&
6836 sdebug_unmap_granularity <=
6837 sdebug_unmap_alignment) {
c1287970 6838 pr_err("ERR: unmap_granularity <= unmap_alignment\n");
c4837394 6839 ret = -EINVAL;
87c715dc 6840 goto free_q_arr;
44d92694 6841 }
87c715dc
DG		 6842 }
6843 xa_init_flags(per_store_ap, XA_FLAGS_ALLOC | XA_FLAGS_LOCK_IRQ);
6844 if (want_store) {
6845 idx = sdebug_add_store();
6846 if (idx < 0) {
6847 ret = idx;
6848 goto free_q_arr;
44d92694 6849 }
44d92694
MP		 6850 }
6851
9b906779
NB		 6852 pseudo_primary = root_device_register("pseudo_0");
6853 if (IS_ERR(pseudo_primary)) {
c1287970 6854 pr_warn("root_device_register() error\n");
9b906779 6855 ret = PTR_ERR(pseudo_primary);
6ecaff7f
RD		 6856 goto free_vm;
6857 }
6858 ret = bus_register(&pseudo_lld_bus);
6859 if (ret < 0) {
c1287970 6860 pr_warn("bus_register error: %d\n", ret);
6ecaff7f
RD		 6861 goto dev_unreg;
6862 }
6863 ret = driver_register(&sdebug_driverfs_driver);
6864 if (ret < 0) {
c1287970 6865 pr_warn("driver_register error: %d\n", ret);
6ecaff7f
RD		 6866 goto bus_unreg;
6867 }
1da177e4 6868
87c715dc 6869 hosts_to_add = sdebug_add_host;
773642d9 6870 sdebug_add_host = 0;
1da177e4 6871
87c715dc
DG		 6872 for (k = 0; k < hosts_to_add; k++) {
6873 if (want_store && k == 0) {
6874 ret = sdebug_add_host_helper(idx);
6875 if (ret < 0) {
6876 pr_err("add_host_helper k=%d, error=%d\n",
6877 k, -ret);
6878 break;
6879 }
6880 } else {
6881 ret = sdebug_do_add_host(want_store &&
6882 sdebug_per_host_store);
6883 if (ret < 0) {
6884 pr_err("add_host k=%d error=%d\n", k, -ret);
6885 break;
6886 }
9a051019
DG		 6887 }
6888 }
773642d9 6889 if (sdebug_verbose)
87c715dc 6890 pr_info("built %d host(s)\n", sdebug_num_hosts);
c1287970 6891
1da177e4 6892 return 0;
6ecaff7f 6893
6ecaff7f
RD		 6894bus_unreg:
6895 bus_unregister(&pseudo_lld_bus);
6896dev_unreg:
9b906779 6897 root_device_unregister(pseudo_primary);
6ecaff7f 6898free_vm:
87c715dc 6899 sdebug_erase_store(idx, NULL);
c4837394
DG		 6900free_q_arr:
6901 kfree(sdebug_q_arr);
6ecaff7f 6902 return ret;
1da177e4
LT		 6903}
6904
6905static void __exit scsi_debug_exit(void)
6906{
87c715dc 6907 int k = sdebug_num_hosts;
1da177e4
LT		 6908
6909 stop_all_queued();
6910 for (; k; k--)
87c715dc 6911 sdebug_do_remove_host(true);
52ab9768 6912 free_all_queued();
1da177e4
LT		 6913 driver_unregister(&sdebug_driverfs_driver);
6914 bus_unregister(&pseudo_lld_bus);
9b906779 6915 root_device_unregister(pseudo_primary);
1da177e4 6916
87c715dc
DG		 6917 sdebug_erase_all_stores(false);
6918 xa_destroy(per_store_ap);
f852c596 6919 kfree(sdebug_q_arr);
1da177e4
LT		 6920}
6921
6922device_initcall(scsi_debug_init);
6923module_exit(scsi_debug_exit);
6924
91d4c752 6925static void sdebug_release_adapter(struct device *dev)
1da177e4 6926{
9a051019 6927 struct sdebug_host_info *sdbg_host;
1da177e4
LT		 6928
6929 sdbg_host = to_sdebug_host(dev);
9a051019 6930 kfree(sdbg_host);
1da177e4
LT		 6931}
6932
87c715dc
DG		 6933/* idx must be valid, if sip is NULL then it will be obtained using idx */
6934static void sdebug_erase_store(int idx, struct sdeb_store_info *sip)
1da177e4 6935{
87c715dc
DG		 6936 if (idx < 0)
6937 return;
6938 if (!sip) {
6939 if (xa_empty(per_store_ap))
6940 return;
6941 sip = xa_load(per_store_ap, idx);
6942 if (!sip)
6943 return;
6944 }
6945 vfree(sip->map_storep);
6946 vfree(sip->dif_storep);
6947 vfree(sip->storep);
6948 xa_erase(per_store_ap, idx);
6949 kfree(sip);
6950}
6951
6952/* Assume apart_from_first==false only in shutdown case. */
6953static void sdebug_erase_all_stores(bool apart_from_first)
6954{
6955 unsigned long idx;
6956 struct sdeb_store_info *sip = NULL;
6957
6958 xa_for_each(per_store_ap, idx, sip) {
6959 if (apart_from_first)
6960 apart_from_first = false;
6961 else
6962 sdebug_erase_store(idx, sip);
6963 }
6964 if (apart_from_first)
6965 sdeb_most_recent_idx = sdeb_first_idx;
6966}
6967
6968/*
6969 * Returns store xarray new element index (idx) if >=0 else negated errno.
6970 * Limit the number of stores to 65536.
6971 */
6972static int sdebug_add_store(void)
6973{
6974 int res;
6975 u32 n_idx;
6976 unsigned long iflags;
6977 unsigned long sz = (unsigned long)sdebug_dev_size_mb * 1048576;
6978 struct sdeb_store_info *sip = NULL;
6979 struct xa_limit xal = { .max = 1 << 16, .min = 0 };
6980
6981 sip = kzalloc(sizeof(*sip), GFP_KERNEL);
6982 if (!sip)
6983 return -ENOMEM;
6984
6985 xa_lock_irqsave(per_store_ap, iflags);
6986 res = __xa_alloc(per_store_ap, &n_idx, sip, xal, GFP_ATOMIC);
6987 if (unlikely(res < 0)) {
6988 xa_unlock_irqrestore(per_store_ap, iflags);
6989 kfree(sip);
6990 pr_warn("%s: xa_alloc() errno=%d\n", __func__, -res);
6991 return res;
6992 }
6993 sdeb_most_recent_idx = n_idx;
6994 if (sdeb_first_idx < 0)
6995 sdeb_first_idx = n_idx;
6996 xa_unlock_irqrestore(per_store_ap, iflags);
6997
6998 res = -ENOMEM;
6999 sip->storep = vzalloc(sz);
7000 if (!sip->storep) {
7001 pr_err("user data oom\n");
7002 goto err;
7003 }
7004 if (sdebug_num_parts > 0)
7005 sdebug_build_parts(sip->storep, sz);
7006
7007 /* DIF/DIX: what T10 calls Protection Information (PI) */
7008 if (sdebug_dix) {
7009 int dif_size;
7010
7011 dif_size = sdebug_store_sectors * sizeof(struct t10_pi_tuple);
7012 sip->dif_storep = vmalloc(dif_size);
7013
7014 pr_info("dif_storep %u bytes @ %pK\n", dif_size,
7015 sip->dif_storep);
7016
7017 if (!sip->dif_storep) {
7018 pr_err("DIX oom\n");
7019 goto err;
7020 }
7021 memset(sip->dif_storep, 0xff, dif_size);
7022 }
7023 /* Logical Block Provisioning */
7024 if (scsi_debug_lbp()) {
7025 map_size = lba_to_map_index(sdebug_store_sectors - 1) + 1;
7026 sip->map_storep = vmalloc(array_size(sizeof(long),
7027 BITS_TO_LONGS(map_size)));
7028
7029 pr_info("%lu provisioning blocks\n", map_size);
7030
7031 if (!sip->map_storep) {
7032 pr_err("LBP map oom\n");
7033 goto err;
7034 }
7035
7036 bitmap_zero(sip->map_storep, map_size);
7037
7038 /* Map first 1KB for partition table */
7039 if (sdebug_num_parts)
7040 map_region(sip, 0, 2);
7041 }
7042
7043 rwlock_init(&sip->macc_lck);
7044 return (int)n_idx;
7045err:
7046 sdebug_erase_store((int)n_idx, sip);
7047 pr_warn("%s: failed, errno=%d\n", __func__, -res);
7048 return res;
7049}
7050
7051static int sdebug_add_host_helper(int per_host_idx)
7052{
7053 int k, devs_per_host, idx;
7054 int error = -ENOMEM;
9a051019 7055 struct sdebug_host_info *sdbg_host;
8b40228f 7056 struct sdebug_dev_info *sdbg_devinfo, *tmp;
1da177e4 7057
9a051019 7058 sdbg_host = kzalloc(sizeof(*sdbg_host), GFP_KERNEL);
87c715dc 7059 if (!sdbg_host)
9a051019 7060 return -ENOMEM;
87c715dc
DG		 7061 idx = (per_host_idx < 0) ? sdeb_first_idx : per_host_idx;
7062 if (xa_get_mark(per_store_ap, idx, SDEB_XA_NOT_IN_USE))
7063 xa_clear_mark(per_store_ap, idx, SDEB_XA_NOT_IN_USE);
7064 sdbg_host->si_idx = idx;
1da177e4 7065
9a051019 7066 INIT_LIST_HEAD(&sdbg_host->dev_info_list);
1da177e4 7067
773642d9 7068 devs_per_host = sdebug_num_tgts * sdebug_max_luns;
9a051019 7069 for (k = 0; k < devs_per_host; k++) {
5cb2fc06 7070 sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL);
87c715dc 7071 if (!sdbg_devinfo)
1da177e4 7072 goto clean;
9a051019 7073 }
1da177e4 7074
9a051019
DG		 7075 spin_lock(&sdebug_host_list_lock);
7076 list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
7077 spin_unlock(&sdebug_host_list_lock);
1da177e4 7078
9a051019
DG		 7079 sdbg_host->dev.bus = &pseudo_lld_bus;
7080 sdbg_host->dev.parent = pseudo_primary;
7081 sdbg_host->dev.release = &sdebug_release_adapter;
87c715dc 7082 dev_set_name(&sdbg_host->dev, "adapter%d", sdebug_num_hosts);
1da177e4 7083
9a051019 7084 error = device_register(&sdbg_host->dev);
9a051019 7085 if (error)
1da177e4
LT		 7086 goto clean;
7087
87c715dc
DG		 7088 ++sdebug_num_hosts;
7089 return 0;
1da177e4
LT		 7090
7091clean:
8b40228f
FT		 7092 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
7093 dev_list) {
1da177e4 7094 list_del(&sdbg_devinfo->dev_list);
f0d1cf93 7095 kfree(sdbg_devinfo->zstate);
1da177e4
LT		 7096 kfree(sdbg_devinfo);
7097 }
1da177e4 7098 kfree(sdbg_host);
87c715dc 7099 pr_warn("%s: failed, errno=%d\n", __func__, -error);
9a051019 7100 return error;
1da177e4
LT		 7101}
7102
87c715dc 7103static int sdebug_do_add_host(bool mk_new_store)
1da177e4 7104{
87c715dc
DG		 7105 int ph_idx = sdeb_most_recent_idx;
7106
7107 if (mk_new_store) {
7108 ph_idx = sdebug_add_store();
7109 if (ph_idx < 0)
7110 return ph_idx;
7111 }
7112 return sdebug_add_host_helper(ph_idx);
7113}
7114
7115static void sdebug_do_remove_host(bool the_end)
7116{
7117 int idx = -1;
9a051019 7118 struct sdebug_host_info *sdbg_host = NULL;
87c715dc 7119 struct sdebug_host_info *sdbg_host2;
1da177e4 7120
9a051019
DG		 7121 spin_lock(&sdebug_host_list_lock);
7122 if (!list_empty(&sdebug_host_list)) {
7123 sdbg_host = list_entry(sdebug_host_list.prev,
7124 struct sdebug_host_info, host_list);
87c715dc 7125 idx = sdbg_host->si_idx;
1da177e4 7126 }
87c715dc
DG		 7127 if (!the_end && idx >= 0) {
7128 bool unique = true;
7129
7130 list_for_each_entry(sdbg_host2, &sdebug_host_list, host_list) {
7131 if (sdbg_host2 == sdbg_host)
7132 continue;
7133 if (idx == sdbg_host2->si_idx) {
7134 unique = false;
7135 break;
7136 }
7137 }
7138 if (unique) {
7139 xa_set_mark(per_store_ap, idx, SDEB_XA_NOT_IN_USE);
7140 if (idx == sdeb_most_recent_idx)
7141 --sdeb_most_recent_idx;
7142 }
7143 }
7144 if (sdbg_host)
7145 list_del(&sdbg_host->host_list);
9a051019 7146 spin_unlock(&sdebug_host_list_lock);
1da177e4
LT		 7147
7148 if (!sdbg_host)
7149 return;
7150
773642d9 7151 device_unregister(&sdbg_host->dev);
87c715dc 7152 --sdebug_num_hosts;
1da177e4
LT		 7153}
7154
fd32119b 7155static int sdebug_change_qdepth(struct scsi_device *sdev, int qdepth)
cbf67842
DG		 7156{
7157 int num_in_q = 0;
cbf67842
DG		 7158 struct sdebug_dev_info *devip;
7159
c4837394 7160 block_unblock_all_queues(true);
cbf67842
DG		 7161 devip = (struct sdebug_dev_info *)sdev->hostdata;
7162 if (NULL == devip) {
c4837394 7163 block_unblock_all_queues(false);
cbf67842
DG		 7164 return -ENODEV;
7165 }
7166 num_in_q = atomic_read(&devip->num_in_q);
c40ecc12 7167
fc09acb7
DG		 7168 if (qdepth > SDEBUG_CANQUEUE) {
7169 qdepth = SDEBUG_CANQUEUE;
7170 pr_warn("%s: requested qdepth [%d] exceeds canqueue [%d], trim\n", __func__,
7171 qdepth, SDEBUG_CANQUEUE);
7172 }
c40ecc12
CH		 7173 if (qdepth < 1)
7174 qdepth = 1;
fc09acb7
DG		 7175 if (qdepth != sdev->queue_depth)
7176 scsi_change_queue_depth(sdev, qdepth);
c40ecc12 7177
773642d9 7178 if (SDEBUG_OPT_Q_NOISE & sdebug_opts) {
c4837394 7179 sdev_printk(KERN_INFO, sdev, "%s: qdepth=%d, num_in_q=%d\n",
c40ecc12 7180 __func__, qdepth, num_in_q);
cbf67842 7181 }
c4837394 7182 block_unblock_all_queues(false);
cbf67842
DG		 7183 return sdev->queue_depth;
7184}
7185
c4837394 7186static bool fake_timeout(struct scsi_cmnd *scp)
817fd66b 7187{
c4837394 7188 if (0 == (atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth))) {
773642d9
DG		 7189 if (sdebug_every_nth < -1)
7190 sdebug_every_nth = -1;
7191 if (SDEBUG_OPT_TIMEOUT & sdebug_opts)
c4837394 7192 return true; /* ignore command causing timeout */
773642d9 7193 else if (SDEBUG_OPT_MAC_TIMEOUT & sdebug_opts &&
817fd66b 7194 scsi_medium_access_command(scp))
c4837394 7195 return true; /* time out reads and writes */
817fd66b 7196 }
c4837394 7197 return false;
817fd66b
DG		 7198}
7199
fc13638a
DG		 7200/* Response to TUR or media access command when device stopped */
7201static int resp_not_ready(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
7202{
7203 int stopped_state;
7204 u64 diff_ns = 0;
7205 ktime_t now_ts = ktime_get_boottime();
7206 struct scsi_device *sdp = scp->device;
7207
7208 stopped_state = atomic_read(&devip->stopped);
7209 if (stopped_state == 2) {
7210 if (ktime_to_ns(now_ts) > ktime_to_ns(devip->create_ts)) {
7211 diff_ns = ktime_to_ns(ktime_sub(now_ts, devip->create_ts));
7212 if (diff_ns >= ((u64)sdeb_tur_ms_to_ready * 1000000)) {
7213 /* tur_ms_to_ready timer extinguished */
7214 atomic_set(&devip->stopped, 0);
7215 return 0;
7216 }
7217 }
7218 mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x1);
7219 if (sdebug_verbose)
7220 sdev_printk(KERN_INFO, sdp,
7221 "%s: Not ready: in process of becoming ready\n", my_name);
7222 if (scp->cmnd[0] == TEST_UNIT_READY) {
7223 u64 tur_nanosecs_to_ready = (u64)sdeb_tur_ms_to_ready * 1000000;
7224
7225 if (diff_ns <= tur_nanosecs_to_ready)
7226 diff_ns = tur_nanosecs_to_ready - diff_ns;
7227 else
7228 diff_ns = tur_nanosecs_to_ready;
7229 /* As per 20-061r2 approved for spc6 by T10 on 20200716 */
7230 do_div(diff_ns, 1000000); /* diff_ns becomes milliseconds */
7231 scsi_set_sense_information(scp->sense_buffer, SCSI_SENSE_BUFFERSIZE,
7232 diff_ns);
7233 return check_condition_result;
7234 }
7235 }
7236 mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x2);
7237 if (sdebug_verbose)
7238 sdev_printk(KERN_INFO, sdp, "%s: Not ready: initializing command required\n",
7239 my_name);
7240 return check_condition_result;
7241}
7242
c4b57d89
KD		 7243static int sdebug_map_queues(struct Scsi_Host *shost)
7244{
7245 int i, qoff;
7246
7247 if (shost->nr_hw_queues == 1)
7248 return 0;
7249
7250 for (i = 0, qoff = 0; i < HCTX_MAX_TYPES; i++) {
7251 struct blk_mq_queue_map *map = &shost->tag_set.map[i];
7252
7253 map->nr_queues = 0;
7254
7255 if (i == HCTX_TYPE_DEFAULT)
7256 map->nr_queues = submit_queues - poll_queues;
7257 else if (i == HCTX_TYPE_POLL)
7258 map->nr_queues = poll_queues;
7259
7260 if (!map->nr_queues) {
7261 BUG_ON(i == HCTX_TYPE_DEFAULT);
7262 continue;
7263 }
7264
7265 map->queue_offset = qoff;
7266 blk_mq_map_queues(map);
7267
7268 qoff += map->nr_queues;
7269 }
7270
7271 return 0;
7272
7273}
7274
7275static int sdebug_blk_mq_poll(struct Scsi_Host *shost, unsigned int queue_num)
7276{
4a0c6f43
DG		 7277 bool first;
7278 bool retiring = false;
7279 int num_entries = 0;
7280 unsigned int qc_idx = 0;
c4b57d89 7281 unsigned long iflags;
4a0c6f43 7282 ktime_t kt_from_boot = ktime_get_boottime();
c4b57d89
KD		 7283 struct sdebug_queue *sqp;
7284 struct sdebug_queued_cmd *sqcp;
7285 struct scsi_cmnd *scp;
7286 struct sdebug_dev_info *devip;
4a0c6f43 7287 struct sdebug_defer *sd_dp;
c4b57d89
KD		 7288
7289 sqp = sdebug_q_arr + queue_num;
4a0c6f43 7290 spin_lock_irqsave(&sqp->qc_lock, iflags);
c4b57d89 7291
4a0c6f43
DG		 7292 for (first = true; first || qc_idx + 1 < sdebug_max_queue; ) {
7293 if (first) {
7294 qc_idx = find_first_bit(sqp->in_use_bm, sdebug_max_queue);
7295 first = false;
7296 } else {
7297 qc_idx = find_next_bit(sqp->in_use_bm, sdebug_max_queue, qc_idx + 1);
7298 }
7299 if (unlikely(qc_idx >= sdebug_max_queue))
7300 break;
c4b57d89
KD		 7301
7302 sqcp = &sqp->qc_arr[qc_idx];
4a0c6f43
DG		 7303 sd_dp = sqcp->sd_dp;
7304 if (unlikely(!sd_dp))
7305 continue;
c4b57d89
KD		 7306 scp = sqcp->a_cmnd;
7307 if (unlikely(scp == NULL)) {
4a0c6f43 7308 pr_err("scp is NULL, queue_num=%d, qc_idx=%u from %s\n",
c4b57d89 7309 queue_num, qc_idx, __func__);
4a0c6f43 7310 break;
c4b57d89 7311 }
4a0c6f43
DG		 7312 if (sd_dp->defer_t == SDEB_DEFER_POLL) {
7313 if (kt_from_boot < sd_dp->cmpl_ts)
7314 continue;
7315
7316 } else /* ignoring non REQ_HIPRI requests */
7317 continue;
c4b57d89
KD		 7318 devip = (struct sdebug_dev_info *)scp->device->hostdata;
7319 if (likely(devip))
7320 atomic_dec(&devip->num_in_q);
7321 else
7322 pr_err("devip=NULL from %s\n", __func__);
7323 if (unlikely(atomic_read(&retired_max_queue) > 0))
4a0c6f43 7324 retiring = true;
c4b57d89
KD		 7325
7326 sqcp->a_cmnd = NULL;
7327 if (unlikely(!test_and_clear_bit(qc_idx, sqp->in_use_bm))) {
4a0c6f43 7328 pr_err("Unexpected completion sqp %p queue_num=%d qc_idx=%u from %s\n",
c4b57d89 7329 sqp, queue_num, qc_idx, __func__);
4a0c6f43 7330 break;
c4b57d89 7331 }
c4b57d89
KD		 7332 if (unlikely(retiring)) { /* user has reduced max_queue */
7333 int k, retval;
7334
7335 retval = atomic_read(&retired_max_queue);
7336 if (qc_idx >= retval) {
7337 pr_err("index %d too large\n", retval);
4a0c6f43 7338 break;
c4b57d89
KD		 7339 }
7340 k = find_last_bit(sqp->in_use_bm, retval);
7341 if ((k < sdebug_max_queue) || (k == retval))
7342 atomic_set(&retired_max_queue, 0);
7343 else
7344 atomic_set(&retired_max_queue, k + 1);
7345 }
4a0c6f43 7346 sd_dp->defer_t = SDEB_DEFER_NONE;
c4b57d89
KD		 7347 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
7348 scp->scsi_done(scp); /* callback to mid level */
4a0c6f43 7349 spin_lock_irqsave(&sqp->qc_lock, iflags);
c4b57d89 7350 num_entries++;
4a0c6f43 7351 }
c4b57d89 7352 spin_unlock_irqrestore(&sqp->qc_lock, iflags);
4a0c6f43
DG		 7353 if (num_entries > 0)
7354 atomic_add(num_entries, &sdeb_mq_poll_count);
c4b57d89
KD		 7355 return num_entries;
7356}
7357
fd32119b
DG		 7358static int scsi_debug_queuecommand(struct Scsi_Host *shost,
7359 struct scsi_cmnd *scp)
c2248fc9
DG		 7360{
7361 u8 sdeb_i;
7362 struct scsi_device *sdp = scp->device;
7363 const struct opcode_info_t *oip;
7364 const struct opcode_info_t *r_oip;
7365 struct sdebug_dev_info *devip;
7366 u8 *cmd = scp->cmnd;
7367 int (*r_pfp)(struct scsi_cmnd *, struct sdebug_dev_info *);
f66b8517 7368 int (*pfp)(struct scsi_cmnd *, struct sdebug_dev_info *) = NULL;
c2248fc9
DG		 7369 int k, na;
7370 int errsts = 0;
ad0c7775 7371 u64 lun_index = sdp->lun & 0x3FFF;
c2248fc9
DG		 7372 u32 flags;
7373 u16 sa;
7374 u8 opcode = cmd[0];
7375 bool has_wlun_rl;
3a90a63d 7376 bool inject_now;
c2248fc9
DG		 7377
7378 scsi_set_resid(scp, 0);
3a90a63d 7379 if (sdebug_statistics) {
c4837394 7380 atomic_inc(&sdebug_cmnd_count);
3a90a63d
DG		 7381 inject_now = inject_on_this_cmd();
7382 } else {
7383 inject_now = false;
7384 }
f46eb0e9
DG		 7385 if (unlikely(sdebug_verbose &&
7386 !(SDEBUG_OPT_NO_CDB_NOISE & sdebug_opts))) {
c2248fc9
DG		 7387 char b[120];
7388 int n, len, sb;
7389
7390 len = scp->cmd_len;
7391 sb = (int)sizeof(b);
7392 if (len > 32)
7393 strcpy(b, "too long, over 32 bytes");
7394 else {
7395 for (k = 0, n = 0; k < len && n < sb; ++k)
7396 n += scnprintf(b + n, sb - n, "%02x ",
7397 (u32)cmd[k]);
7398 }
458df78b
BVA		 7399 sdev_printk(KERN_INFO, sdp, "%s: tag=%#x, cmd %s\n", my_name,
7400 blk_mq_unique_tag(scp->request), b);
c2248fc9 7401 }
3a90a63d 7402 if (unlikely(inject_now && (sdebug_opts & SDEBUG_OPT_HOST_BUSY)))
7ee6d1b4 7403 return SCSI_MLQUEUE_HOST_BUSY;
34d55434 7404 has_wlun_rl = (sdp->lun == SCSI_W_LUN_REPORT_LUNS);
ad0c7775 7405 if (unlikely(lun_index >= sdebug_max_luns && !has_wlun_rl))
f46eb0e9 7406 goto err_out;
c2248fc9
DG		 7407
7408 sdeb_i = opcode_ind_arr[opcode]; /* fully mapped */
7409 oip = &opcode_info_arr[sdeb_i]; /* safe if table consistent */
7410 devip = (struct sdebug_dev_info *)sdp->hostdata;
f46eb0e9
DG		 7411 if (unlikely(!devip)) {
7412 devip = find_build_dev_info(sdp);
c2248fc9 7413 if (NULL == devip)
f46eb0e9 7414 goto err_out;
c2248fc9 7415 }
3a90a63d
DG		 7416 if (unlikely(inject_now && !atomic_read(&sdeb_inject_pending)))
7417 atomic_set(&sdeb_inject_pending, 1);
7418
c2248fc9
DG		 7419 na = oip->num_attached;
7420 r_pfp = oip->pfp;
7421 if (na) { /* multiple commands with this opcode */
7422 r_oip = oip;
7423 if (FF_SA & r_oip->flags) {
7424 if (F_SA_LOW & oip->flags)
7425 sa = 0x1f & cmd[1];
7426 else
7427 sa = get_unaligned_be16(cmd + 8);
7428 for (k = 0; k <= na; oip = r_oip->arrp + k++) {
7429 if (opcode == oip->opcode && sa == oip->sa)
7430 break;
7431 }
7432 } else { /* since no service action only check opcode */
7433 for (k = 0; k <= na; oip = r_oip->arrp + k++) {
7434 if (opcode == oip->opcode)
7435 break;
7436 }
7437 }
7438 if (k > na) {
7439 if (F_SA_LOW & r_oip->flags)
7440 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 4);
7441 else if (F_SA_HIGH & r_oip->flags)
7442 mk_sense_invalid_fld(scp, SDEB_IN_CDB, 8, 7);
7443 else
7444 mk_sense_invalid_opcode(scp);
7445 goto check_cond;
7446 }
7447 } /* else (when na==0) we assume the oip is a match */
7448 flags = oip->flags;
f46eb0e9 7449 if (unlikely(F_INV_OP & flags)) {
c2248fc9
DG		 7450 mk_sense_invalid_opcode(scp);
7451 goto check_cond;
7452 }
f46eb0e9 7453 if (unlikely(has_wlun_rl && !(F_RL_WLUN_OK & flags))) {
773642d9
DG		 7454 if (sdebug_verbose)
7455 sdev_printk(KERN_INFO, sdp, "%s: Opcode 0x%x not%s\n",
7456 my_name, opcode, " supported for wlun");
c2248fc9
DG		 7457 mk_sense_invalid_opcode(scp);
7458 goto check_cond;
7459 }
f46eb0e9 7460 if (unlikely(sdebug_strict)) { /* check cdb against mask */
c2248fc9
DG		 7461 u8 rem;
7462 int j;
7463
7464 for (k = 1; k < oip->len_mask[0] && k < 16; ++k) {
7465 rem = ~oip->len_mask[k] & cmd[k];
7466 if (rem) {
7467 for (j = 7; j >= 0; --j, rem <<= 1) {
7468 if (0x80 & rem)
7469 break;
7470 }
7471 mk_sense_invalid_fld(scp, SDEB_IN_CDB, k, j);
7472 goto check_cond;
7473 }
7474 }
7475 }
f46eb0e9 7476 if (unlikely(!(F_SKIP_UA & flags) &&
b01f6f83
DG		 7477 find_first_bit(devip->uas_bm,
7478 SDEBUG_NUM_UAS) != SDEBUG_NUM_UAS)) {
f46eb0e9 7479 errsts = make_ua(scp, devip);
c2248fc9
DG		 7480 if (errsts)
7481 goto check_cond;
7482 }
fc13638a
DG		 7483 if (unlikely(((F_M_ACCESS & flags) || scp->cmnd[0] == TEST_UNIT_READY) &&
7484 atomic_read(&devip->stopped))) {
7485 errsts = resp_not_ready(scp, devip);
7486 if (errsts)
7487 goto fini;
c2248fc9 7488 }
773642d9 7489 if (sdebug_fake_rw && (F_FAKE_RW & flags))
c2248fc9 7490 goto fini;
f46eb0e9 7491 if (unlikely(sdebug_every_nth)) {
c4837394 7492 if (fake_timeout(scp))
c2248fc9
DG		 7493 return 0; /* ignore command: make trouble */
7494 }
f46eb0e9 7495 if (likely(oip->pfp))
f66b8517
MW		 7496 pfp = oip->pfp; /* calls a resp_* function */
7497 else
7498 pfp = r_pfp; /* if leaf function ptr NULL, try the root's */
c2248fc9
DG		 7499
7500fini:
67da413f 7501 if (F_DELAY_OVERR & flags) /* cmds like INQUIRY respond asap */
f66b8517 7502 return schedule_resp(scp, devip, errsts, pfp, 0, 0);
75aa3209
DG		 7503 else if ((flags & F_LONG_DELAY) && (sdebug_jdelay > 0 ||
7504 sdebug_ndelay > 10000)) {
80c49563 7505 /*
75aa3209
DG		 7506 * Skip long delays if ndelay <= 10 microseconds. Otherwise
7507 * for Start Stop Unit (SSU) want at least 1 second delay and
7508 * if sdebug_jdelay>1 want a long delay of that many seconds.
7509 * For Synchronize Cache want 1/20 of SSU's delay.
80c49563
DG		 7510 */
7511 int jdelay = (sdebug_jdelay < 2) ? 1 : sdebug_jdelay;
4f2c8bf6 7512 int denom = (flags & F_SYNC_DELAY) ? 20 : 1;
80c49563 7513
4f2c8bf6 7514 jdelay = mult_frac(USER_HZ * jdelay, HZ, denom * USER_HZ);
f66b8517 7515 return schedule_resp(scp, devip, errsts, pfp, jdelay, 0);
80c49563 7516 } else
f66b8517 7517 return schedule_resp(scp, devip, errsts, pfp, sdebug_jdelay,
10bde980 7518 sdebug_ndelay);
c2248fc9 7519check_cond:
f66b8517 7520 return schedule_resp(scp, devip, check_condition_result, NULL, 0, 0);
f46eb0e9 7521err_out:
f66b8517 7522 return schedule_resp(scp, NULL, DID_NO_CONNECT << 16, NULL, 0, 0);
c2248fc9
DG		 7523}
7524
9e603ca0 7525static struct scsi_host_template sdebug_driver_template = {
c8ed555a
AV		 7526 .show_info = scsi_debug_show_info,
7527 .write_info = scsi_debug_write_info,
9e603ca0
FT		 7528 .proc_name = sdebug_proc_name,
7529 .name = "SCSI DEBUG",
7530 .info = scsi_debug_info,
7531 .slave_alloc = scsi_debug_slave_alloc,
7532 .slave_configure = scsi_debug_slave_configure,
7533 .slave_destroy = scsi_debug_slave_destroy,
7534 .ioctl = scsi_debug_ioctl,
185dd232 7535 .queuecommand = scsi_debug_queuecommand,
cbf67842 7536 .change_queue_depth = sdebug_change_qdepth,
c4b57d89
KD		 7537 .map_queues = sdebug_map_queues,
7538 .mq_poll = sdebug_blk_mq_poll,
9e603ca0 7539 .eh_abort_handler = scsi_debug_abort,
9e603ca0 7540 .eh_device_reset_handler = scsi_debug_device_reset,
cbf67842
DG		 7541 .eh_target_reset_handler = scsi_debug_target_reset,
7542 .eh_bus_reset_handler = scsi_debug_bus_reset,
9e603ca0 7543 .eh_host_reset_handler = scsi_debug_host_reset,
c4837394 7544 .can_queue = SDEBUG_CANQUEUE,
9e603ca0 7545 .this_id = 7,
65e8617f 7546 .sg_tablesize = SG_MAX_SEGMENTS,
cbf67842 7547 .cmd_per_lun = DEF_CMD_PER_LUN,
6bb5e6e7 7548 .max_sectors = -1U,
50c2e910 7549 .max_segment_size = -1U,
9e603ca0 7550 .module = THIS_MODULE,
c40ecc12 7551 .track_queue_depth = 1,
9e603ca0
FT		 7552};
7553
91d4c752 7554static int sdebug_driver_probe(struct device *dev)
1da177e4 7555{
22017ed2
DG		 7556 int error = 0;
7557 struct sdebug_host_info *sdbg_host;
7558 struct Scsi_Host *hpnt;
f46eb0e9 7559 int hprot;
1da177e4
LT		 7560
7561 sdbg_host = to_sdebug_host(dev);
7562
f7c4cdc7 7563 sdebug_driver_template.can_queue = sdebug_max_queue;
fc09acb7 7564 sdebug_driver_template.cmd_per_lun = sdebug_max_queue;
2a3d4eb8 7565 if (!sdebug_clustering)
4af14d11
CH		 7566 sdebug_driver_template.dma_boundary = PAGE_SIZE - 1;
7567
78d4e5a0
DG		 7568 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
7569 if (NULL == hpnt) {
c1287970 7570 pr_err("scsi_host_alloc failed\n");
78d4e5a0 7571 error = -ENODEV;
1da177e4 7572 return error;
78d4e5a0 7573 }
c4837394 7574 if (submit_queues > nr_cpu_ids) {
9b130ad5 7575 pr_warn("%s: trim submit_queues (was %d) to nr_cpu_ids=%u\n",
c4837394
DG		 7576 my_name, submit_queues, nr_cpu_ids);
7577 submit_queues = nr_cpu_ids;
7578 }
c10fa55f
JG		 7579 /*
7580 * Decide whether to tell scsi subsystem that we want mq. The
f7c4cdc7 7581 * following should give the same answer for each host.
c10fa55f 7582 */
f7c4cdc7
JG		 7583 hpnt->nr_hw_queues = submit_queues;
7584 if (sdebug_host_max_queue)
7585 hpnt->host_tagset = 1;
1da177e4 7586
c4b57d89
KD		 7587 /* poll queues are possible for nr_hw_queues > 1 */
7588 if (hpnt->nr_hw_queues == 1 || (poll_queues < 1)) {
7589 pr_warn("%s: trim poll_queues to 0. poll_q/nr_hw = (%d/%d)\n",
7590 my_name, poll_queues, hpnt->nr_hw_queues);
7591 poll_queues = 0;
7592 }
7593
7594 /*
7595 * Poll queues don't need interrupts, but we need at least one I/O queue
7596 * left over for non-polled I/O.
7597 * If condition not met, trim poll_queues to 1 (just for simplicity).
7598 */
7599 if (poll_queues >= submit_queues) {
fc09acb7
DG		 7600 if (submit_queues < 3)
7601 pr_warn("%s: trim poll_queues to 1\n", my_name);
7602 else
7603 pr_warn("%s: trim poll_queues to 1. Perhaps try poll_queues=%d\n",
7604 my_name, submit_queues - 1);
c4b57d89
KD		 7605 poll_queues = 1;
7606 }
7607 if (poll_queues)
7608 hpnt->nr_maps = 3;
7609
9a051019 7610 sdbg_host->shost = hpnt;
1da177e4 7611 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
773642d9
DG		 7612 if ((hpnt->this_id >= 0) && (sdebug_num_tgts > hpnt->this_id))
7613 hpnt->max_id = sdebug_num_tgts + 1;
1da177e4 7614 else
773642d9
DG		 7615 hpnt->max_id = sdebug_num_tgts;
7616 /* = sdebug_max_luns; */
f2d3fd29 7617 hpnt->max_lun = SCSI_W_LUN_REPORT_LUNS + 1;
1da177e4 7618
f46eb0e9 7619 hprot = 0;
c6a44287 7620
773642d9 7621 switch (sdebug_dif) {
c6a44287 7622
8475c811 7623 case T10_PI_TYPE1_PROTECTION:
f46eb0e9 7624 hprot = SHOST_DIF_TYPE1_PROTECTION;
773642d9 7625 if (sdebug_dix)
f46eb0e9 7626 hprot |= SHOST_DIX_TYPE1_PROTECTION;
c6a44287
MP		 7627 break;
7628
8475c811 7629 case T10_PI_TYPE2_PROTECTION:
f46eb0e9 7630 hprot = SHOST_DIF_TYPE2_PROTECTION;
773642d9 7631 if (sdebug_dix)
f46eb0e9 7632 hprot |= SHOST_DIX_TYPE2_PROTECTION;
c6a44287
MP		 7633 break;
7634
8475c811 7635 case T10_PI_TYPE3_PROTECTION:
f46eb0e9 7636 hprot = SHOST_DIF_TYPE3_PROTECTION;
773642d9 7637 if (sdebug_dix)
f46eb0e9 7638 hprot |= SHOST_DIX_TYPE3_PROTECTION;
c6a44287
MP		 7639 break;
7640
7641 default:
773642d9 7642 if (sdebug_dix)
f46eb0e9 7643 hprot |= SHOST_DIX_TYPE0_PROTECTION;
c6a44287
MP		 7644 break;
7645 }
7646
f46eb0e9 7647 scsi_host_set_prot(hpnt, hprot);
c6a44287 7648
f46eb0e9
DG		 7649 if (have_dif_prot || sdebug_dix)
7650 pr_info("host protection%s%s%s%s%s%s%s\n",
7651 (hprot & SHOST_DIF_TYPE1_PROTECTION) ? " DIF1" : "",
7652 (hprot & SHOST_DIF_TYPE2_PROTECTION) ? " DIF2" : "",
7653 (hprot & SHOST_DIF_TYPE3_PROTECTION) ? " DIF3" : "",
7654 (hprot & SHOST_DIX_TYPE0_PROTECTION) ? " DIX0" : "",
7655 (hprot & SHOST_DIX_TYPE1_PROTECTION) ? " DIX1" : "",
7656 (hprot & SHOST_DIX_TYPE2_PROTECTION) ? " DIX2" : "",
7657 (hprot & SHOST_DIX_TYPE3_PROTECTION) ? " DIX3" : "");
c6a44287 7658
773642d9 7659 if (sdebug_guard == 1)
c6a44287
MP		 7660 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_IP);
7661 else
7662 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_CRC);
7663
773642d9
DG		 7664 sdebug_verbose = !!(SDEBUG_OPT_NOISE & sdebug_opts);
7665 sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & sdebug_opts);
c4837394
DG		 7666 if (sdebug_every_nth) /* need stats counters for every_nth */
7667 sdebug_statistics = true;
9a051019
DG		 7668 error = scsi_add_host(hpnt, &sdbg_host->dev);
7669 if (error) {
c1287970 7670 pr_err("scsi_add_host failed\n");
9a051019 7671 error = -ENODEV;
1da177e4 7672 scsi_host_put(hpnt);
87c715dc 7673 } else {
1da177e4 7674 scsi_scan_host(hpnt);
87c715dc 7675 }
1da177e4 7676
cbf67842 7677 return error;
1da177e4
LT		 7678}
7679
91d4c752 7680static int sdebug_driver_remove(struct device *dev)
1da177e4 7681{
9a051019 7682 struct sdebug_host_info *sdbg_host;
8b40228f 7683 struct sdebug_dev_info *sdbg_devinfo, *tmp;
1da177e4
LT		 7684
7685 sdbg_host = to_sdebug_host(dev);
7686
7687 if (!sdbg_host) {
c1287970 7688 pr_err("Unable to locate host info\n");
1da177e4
LT		 7689 return -ENODEV;
7690 }
7691
9a051019 7692 scsi_remove_host(sdbg_host->shost);
1da177e4 7693
8b40228f
FT		 7694 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
7695 dev_list) {
9a051019 7696 list_del(&sdbg_devinfo->dev_list);
f0d1cf93 7697 kfree(sdbg_devinfo->zstate);
9a051019
DG		 7698 kfree(sdbg_devinfo);
7699 }
1da177e4 7700
9a051019
DG		 7701 scsi_host_put(sdbg_host->shost);
7702 return 0;
1da177e4
LT		 7703}
7704
8dea0d02
FT		 7705static int pseudo_lld_bus_match(struct device *dev,
7706 struct device_driver *dev_driver)
1da177e4 7707{
8dea0d02 7708 return 1;
1da177e4 7709}
8dea0d02
FT		 7710
7711static struct bus_type pseudo_lld_bus = {
7712 .name = "pseudo",
7713 .match = pseudo_lld_bus_match,
7714 .probe = sdebug_driver_probe,
7715 .remove = sdebug_driver_remove,
82069379 7716 .drv_groups = sdebug_drv_groups,
8dea0d02 7717};
Linux 6.x block layer and io_uring tree(s)