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