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