Linux Audio

Check our new training course

Loading...
v5.9
   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 - 2020 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
  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/genhd.h>
  27#include <linux/fs.h>
  28#include <linux/init.h>
  29#include <linux/proc_fs.h>
  30#include <linux/vmalloc.h>
  31#include <linux/moduleparam.h>
  32#include <linux/scatterlist.h>
  33#include <linux/blkdev.h>
  34#include <linux/crc-t10dif.h>
  35#include <linux/spinlock.h>
  36#include <linux/interrupt.h>
  37#include <linux/atomic.h>
  38#include <linux/hrtimer.h>
  39#include <linux/uuid.h>
  40#include <linux/t10-pi.h>
  41#include <linux/msdos_partition.h>
  42#include <linux/random.h>
  43#include <linux/xarray.h>
  44#include <linux/prefetch.h>
 
 
  45
  46#include <net/checksum.h>
  47
  48#include <asm/unaligned.h>
  49
  50#include <scsi/scsi.h>
  51#include <scsi/scsi_cmnd.h>
  52#include <scsi/scsi_device.h>
  53#include <scsi/scsi_host.h>
  54#include <scsi/scsicam.h>
  55#include <scsi/scsi_eh.h>
  56#include <scsi/scsi_tcq.h>
  57#include <scsi/scsi_dbg.h>
  58
  59#include "sd.h"
  60#include "scsi_logging.h"
  61
  62/* make sure inq_product_rev string corresponds to this version */
  63#define SDEBUG_VERSION "0190"	/* format to fit INQUIRY revision field */
  64static const char *sdebug_version_date = "20200710";
  65
  66#define MY_NAME "scsi_debug"
  67
  68/* Additional Sense Code (ASC) */
  69#define NO_ADDITIONAL_SENSE 0x0
  70#define LOGICAL_UNIT_NOT_READY 0x4
  71#define LOGICAL_UNIT_COMMUNICATION_FAILURE 0x8
  72#define UNRECOVERED_READ_ERR 0x11
  73#define PARAMETER_LIST_LENGTH_ERR 0x1a
  74#define INVALID_OPCODE 0x20
  75#define LBA_OUT_OF_RANGE 0x21
  76#define INVALID_FIELD_IN_CDB 0x24
  77#define INVALID_FIELD_IN_PARAM_LIST 0x26
  78#define WRITE_PROTECTED 0x27
  79#define UA_RESET_ASC 0x29
  80#define UA_CHANGED_ASC 0x2a
  81#define TARGET_CHANGED_ASC 0x3f
  82#define LUNS_CHANGED_ASCQ 0x0e
  83#define INSUFF_RES_ASC 0x55
  84#define INSUFF_RES_ASCQ 0x3
  85#define POWER_ON_RESET_ASCQ 0x0
 
  86#define BUS_RESET_ASCQ 0x2	/* scsi bus reset occurred */
  87#define MODE_CHANGED_ASCQ 0x1	/* mode parameters changed */
  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 INSUFF_ZONE_ASCQ 0xe
 102
 103/* Additional Sense Code Qualifier (ASCQ) */
 104#define ACK_NAK_TO 0x3
 105
 106/* Default values for driver parameters */
 107#define DEF_NUM_HOST   1
 108#define DEF_NUM_TGTS   1
 109#define DEF_MAX_LUNS   1
 110/* With these defaults, this driver will make 1 host with 1 target
 111 * (id 0) containing 1 logical unit (lun 0). That is 1 device.
 112 */
 113#define DEF_ATO 1
 114#define DEF_CDB_LEN 10
 115#define DEF_JDELAY   1		/* if > 0 unit is a jiffy */
 116#define DEF_DEV_SIZE_PRE_INIT   0
 117#define DEF_DEV_SIZE_MB   8
 118#define DEF_ZBC_DEV_SIZE_MB   128
 119#define DEF_DIF 0
 120#define DEF_DIX 0
 121#define DEF_PER_HOST_STORE false
 122#define DEF_D_SENSE   0
 123#define DEF_EVERY_NTH   0
 124#define DEF_FAKE_RW	0
 125#define DEF_GUARD 0
 126#define DEF_HOST_LOCK 0
 127#define DEF_LBPU 0
 128#define DEF_LBPWS 0
 129#define DEF_LBPWS10 0
 130#define DEF_LBPRZ 1
 131#define DEF_LOWEST_ALIGNED 0
 132#define DEF_NDELAY   0		/* if > 0 unit is a nanosecond */
 133#define DEF_NO_LUN_0   0
 134#define DEF_NUM_PARTS   0
 135#define DEF_OPTS   0
 136#define DEF_OPT_BLKS 1024
 137#define DEF_PHYSBLK_EXP 0
 138#define DEF_OPT_XFERLEN_EXP 0
 139#define DEF_PTYPE   TYPE_DISK
 140#define DEF_RANDOM false
 141#define DEF_REMOVABLE false
 142#define DEF_SCSI_LEVEL   7    /* INQUIRY, byte2 [6->SPC-4; 7->SPC-5] */
 143#define DEF_SECTOR_SIZE 512
 144#define DEF_UNMAP_ALIGNMENT 0
 145#define DEF_UNMAP_GRANULARITY 1
 146#define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF
 147#define DEF_UNMAP_MAX_DESC 256
 148#define DEF_VIRTUAL_GB   0
 149#define DEF_VPD_USE_HOSTNO 1
 150#define DEF_WRITESAME_LENGTH 0xFFFF
 151#define DEF_STRICT 0
 152#define DEF_STATISTICS false
 153#define DEF_SUBMIT_QUEUES 1
 154#define DEF_TUR_MS_TO_READY 0
 155#define DEF_UUID_CTL 0
 156#define JDELAY_OVERRIDDEN -9999
 157
 158/* Default parameters for ZBC drives */
 159#define DEF_ZBC_ZONE_SIZE_MB	128
 160#define DEF_ZBC_MAX_OPEN_ZONES	8
 161#define DEF_ZBC_NR_CONV_ZONES	1
 162
 163#define SDEBUG_LUN_0_VAL 0
 164
 165/* bit mask values for sdebug_opts */
 166#define SDEBUG_OPT_NOISE		1
 167#define SDEBUG_OPT_MEDIUM_ERR		2
 168#define SDEBUG_OPT_TIMEOUT		4
 169#define SDEBUG_OPT_RECOVERED_ERR	8
 170#define SDEBUG_OPT_TRANSPORT_ERR	16
 171#define SDEBUG_OPT_DIF_ERR		32
 172#define SDEBUG_OPT_DIX_ERR		64
 173#define SDEBUG_OPT_MAC_TIMEOUT		128
 174#define SDEBUG_OPT_SHORT_TRANSFER	0x100
 175#define SDEBUG_OPT_Q_NOISE		0x200
 176#define SDEBUG_OPT_ALL_TSF		0x400
 177#define SDEBUG_OPT_RARE_TSF		0x800
 178#define SDEBUG_OPT_N_WCE		0x1000
 179#define SDEBUG_OPT_RESET_NOISE		0x2000
 180#define SDEBUG_OPT_NO_CDB_NOISE		0x4000
 181#define SDEBUG_OPT_HOST_BUSY		0x8000
 182#define SDEBUG_OPT_CMD_ABORT		0x10000
 183#define SDEBUG_OPT_ALL_NOISE (SDEBUG_OPT_NOISE | SDEBUG_OPT_Q_NOISE | \
 184			      SDEBUG_OPT_RESET_NOISE)
 185#define SDEBUG_OPT_ALL_INJECTING (SDEBUG_OPT_RECOVERED_ERR | \
 186				  SDEBUG_OPT_TRANSPORT_ERR | \
 187				  SDEBUG_OPT_DIF_ERR | SDEBUG_OPT_DIX_ERR | \
 188				  SDEBUG_OPT_SHORT_TRANSFER | \
 189				  SDEBUG_OPT_HOST_BUSY | \
 190				  SDEBUG_OPT_CMD_ABORT)
 191#define SDEBUG_OPT_RECOV_DIF_DIX (SDEBUG_OPT_RECOVERED_ERR | \
 192				  SDEBUG_OPT_DIF_ERR | SDEBUG_OPT_DIX_ERR)
 193
 194/* As indicated in SAM-5 and SPC-4 Unit Attentions (UAs) are returned in
 195 * priority order. In the subset implemented here lower numbers have higher
 196 * priority. The UA numbers should be a sequence starting from 0 with
 197 * SDEBUG_NUM_UAS being 1 higher than the highest numbered UA. */
 198#define SDEBUG_UA_POR 0		/* Power on, reset, or bus device reset */
 199#define SDEBUG_UA_BUS_RESET 1
 200#define SDEBUG_UA_MODE_CHANGED 2
 201#define SDEBUG_UA_CAPACITY_CHANGED 3
 202#define SDEBUG_UA_LUNS_CHANGED 4
 203#define SDEBUG_UA_MICROCODE_CHANGED 5	/* simulate firmware change */
 204#define SDEBUG_UA_MICROCODE_CHANGED_WO_RESET 6
 205#define SDEBUG_NUM_UAS 7
 
 206
 207/* when 1==SDEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
 208 * sector on read commands: */
 209#define OPT_MEDIUM_ERR_ADDR   0x1234 /* that's sector 4660 in decimal */
 210#define OPT_MEDIUM_ERR_NUM    10     /* number of consecutive medium errs */
 211
 212/* If REPORT LUNS has luns >= 256 it can choose "flat space" (value 1)
 213 * or "peripheral device" addressing (value 0) */
 214#define SAM2_LUN_ADDRESS_METHOD 0
 215
 216/* SDEBUG_CANQUEUE is the maximum number of commands that can be queued
 217 * (for response) per submit queue at one time. Can be reduced by max_queue
 218 * option. Command responses are not queued when jdelay=0 and ndelay=0. The
 219 * per-device DEF_CMD_PER_LUN can be changed via sysfs:
 220 * /sys/class/scsi_device/<h:c:t:l>/device/queue_depth
 221 * but cannot exceed SDEBUG_CANQUEUE .
 222 */
 223#define SDEBUG_CANQUEUE_WORDS  3	/* a WORD is bits in a long */
 224#define SDEBUG_CANQUEUE  (SDEBUG_CANQUEUE_WORDS * BITS_PER_LONG)
 225#define DEF_CMD_PER_LUN  255
 226
 227/* UA - Unit Attention; SA - Service Action; SSU - Start Stop Unit */
 228#define F_D_IN			1	/* Data-in command (e.g. READ) */
 229#define F_D_OUT			2	/* Data-out command (e.g. WRITE) */
 230#define F_D_OUT_MAYBE		4	/* WRITE SAME, NDOB bit */
 231#define F_D_UNKN		8
 232#define F_RL_WLUN_OK		0x10	/* allowed with REPORT LUNS W-LUN */
 233#define F_SKIP_UA		0x20	/* bypass UAs (e.g. INQUIRY command) */
 234#define F_DELAY_OVERR		0x40	/* for commands like INQUIRY */
 235#define F_SA_LOW		0x80	/* SA is in cdb byte 1, bits 4 to 0 */
 236#define F_SA_HIGH		0x100	/* SA is in cdb bytes 8 and 9 */
 237#define F_INV_OP		0x200	/* invalid opcode (not supported) */
 238#define F_FAKE_RW		0x400	/* bypass resp_*() when fake_rw set */
 239#define F_M_ACCESS		0x800	/* media access, reacts to SSU state */
 240#define F_SSU_DELAY		0x1000	/* SSU command delay (long-ish) */
 241#define F_SYNC_DELAY		0x2000	/* SYNCHRONIZE CACHE delay */
 242
 243/* Useful combinations of the above flags */
 244#define FF_RESPOND (F_RL_WLUN_OK | F_SKIP_UA | F_DELAY_OVERR)
 245#define FF_MEDIA_IO (F_M_ACCESS | F_FAKE_RW)
 246#define FF_SA (F_SA_HIGH | F_SA_LOW)
 247#define F_LONG_DELAY		(F_SSU_DELAY | F_SYNC_DELAY)
 248
 249#define SDEBUG_MAX_PARTS 4
 250
 251#define SDEBUG_MAX_CMD_LEN 32
 252
 253#define SDEB_XA_NOT_IN_USE XA_MARK_1
 254
 
 
 
 
 
 255/* Zone types (zbcr05 table 25) */
 256enum sdebug_z_type {
 257	ZBC_ZONE_TYPE_CNV	= 0x1,
 258	ZBC_ZONE_TYPE_SWR	= 0x2,
 259	ZBC_ZONE_TYPE_SWP	= 0x3,
 
 
 260};
 261
 262/* enumeration names taken from table 26, zbcr05 */
 263enum sdebug_z_cond {
 264	ZBC_NOT_WRITE_POINTER	= 0x0,
 265	ZC1_EMPTY		= 0x1,
 266	ZC2_IMPLICIT_OPEN	= 0x2,
 267	ZC3_EXPLICIT_OPEN	= 0x3,
 268	ZC4_CLOSED		= 0x4,
 269	ZC6_READ_ONLY		= 0xd,
 270	ZC5_FULL		= 0xe,
 271	ZC7_OFFLINE		= 0xf,
 272};
 273
 274struct sdeb_zone_state {	/* ZBC: per zone state */
 275	enum sdebug_z_type z_type;
 276	enum sdebug_z_cond z_cond;
 277	bool z_non_seq_resource;
 278	unsigned int z_size;
 279	sector_t z_start;
 280	sector_t z_wp;
 281};
 282
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 283struct sdebug_dev_info {
 284	struct list_head dev_list;
 285	unsigned int channel;
 286	unsigned int target;
 287	u64 lun;
 288	uuid_t lu_name;
 289	struct sdebug_host_info *sdbg_host;
 290	unsigned long uas_bm[1];
 291	atomic_t num_in_q;
 292	atomic_t stopped;	/* 1: by SSU, 2: device start */
 293	bool used;
 294
 295	/* For ZBC devices */
 296	enum blk_zoned_model zmodel;
 
 297	unsigned int zsize;
 298	unsigned int zsize_shift;
 299	unsigned int nr_zones;
 300	unsigned int nr_conv_zones;
 
 301	unsigned int nr_imp_open;
 302	unsigned int nr_exp_open;
 303	unsigned int nr_closed;
 304	unsigned int max_open;
 305	ktime_t create_ts;	/* time since bootup that this device was created */
 306	struct sdeb_zone_state *zstate;
 
 
 
 
 
 
 
 
 
 307};
 308
 309struct sdebug_host_info {
 310	struct list_head host_list;
 311	int si_idx;	/* sdeb_store_info (per host) xarray index */
 312	struct Scsi_Host *shost;
 313	struct device dev;
 314	struct list_head dev_info_list;
 315};
 316
 317/* There is an xarray of pointers to this struct's objects, one per host */
 318struct sdeb_store_info {
 319	rwlock_t macc_lck;	/* for atomic media access on this store */
 320	u8 *storep;		/* user data storage (ram) */
 321	struct t10_pi_tuple *dif_storep; /* protection info */
 322	void *map_storep;	/* provisioning map */
 323};
 324
 325#define to_sdebug_host(d)	\
 326	container_of(d, struct sdebug_host_info, dev)
 327
 
 
 
 328enum sdeb_defer_type {SDEB_DEFER_NONE = 0, SDEB_DEFER_HRT = 1,
 329		      SDEB_DEFER_WQ = 2};
 330
 331struct sdebug_defer {
 332	struct hrtimer hrt;
 333	struct execute_work ew;
 334	int sqa_idx;	/* index of sdebug_queue array */
 335	int qc_idx;	/* index of sdebug_queued_cmd array within sqa_idx */
 336	int hc_idx;	/* hostwide tag index */
 337	int issuing_cpu;
 338	bool init_hrt;
 339	bool init_wq;
 340	bool aborted;	/* true when blk_abort_request() already called */
 341	enum sdeb_defer_type defer_t;
 342};
 343
 344struct sdebug_queued_cmd {
 345	/* corresponding bit set in in_use_bm[] in owning struct sdebug_queue
 346	 * instance indicates this slot is in use.
 347	 */
 348	struct sdebug_defer *sd_dp;
 349	struct scsi_cmnd *a_cmnd;
 350};
 351
 352struct sdebug_queue {
 353	struct sdebug_queued_cmd qc_arr[SDEBUG_CANQUEUE];
 354	unsigned long in_use_bm[SDEBUG_CANQUEUE_WORDS];
 355	spinlock_t qc_lock;
 356	atomic_t blocked;	/* to temporarily stop more being queued */
 357};
 358
 359static atomic_t sdebug_cmnd_count;   /* number of incoming commands */
 360static atomic_t sdebug_completions;  /* count of deferred completions */
 361static atomic_t sdebug_miss_cpus;    /* submission + completion cpus differ */
 362static atomic_t sdebug_a_tsf;	     /* 'almost task set full' counter */
 363static atomic_t sdeb_inject_pending;
 
 364
 365struct opcode_info_t {
 366	u8 num_attached;	/* 0 if this is it (i.e. a leaf); use 0xff */
 367				/* for terminating element */
 368	u8 opcode;		/* if num_attached > 0, preferred */
 369	u16 sa;			/* service action */
 370	u32 flags;		/* OR-ed set of SDEB_F_* */
 371	int (*pfp)(struct scsi_cmnd *, struct sdebug_dev_info *);
 372	const struct opcode_info_t *arrp;  /* num_attached elements or NULL */
 373	u8 len_mask[16];	/* len_mask[0]-->cdb_len, then mask for cdb */
 374				/* 1 to min(cdb_len, 15); ignore cdb[15...] */
 375};
 376
 377/* SCSI opcodes (first byte of cdb) of interest mapped onto these indexes */
 378enum sdeb_opcode_index {
 379	SDEB_I_INVALID_OPCODE =	0,
 380	SDEB_I_INQUIRY = 1,
 381	SDEB_I_REPORT_LUNS = 2,
 382	SDEB_I_REQUEST_SENSE = 3,
 383	SDEB_I_TEST_UNIT_READY = 4,
 384	SDEB_I_MODE_SENSE = 5,		/* 6, 10 */
 385	SDEB_I_MODE_SELECT = 6,		/* 6, 10 */
 386	SDEB_I_LOG_SENSE = 7,
 387	SDEB_I_READ_CAPACITY = 8,	/* 10; 16 is in SA_IN(16) */
 388	SDEB_I_READ = 9,		/* 6, 10, 12, 16 */
 389	SDEB_I_WRITE = 10,		/* 6, 10, 12, 16 */
 390	SDEB_I_START_STOP = 11,
 391	SDEB_I_SERV_ACT_IN_16 = 12,	/* add ...SERV_ACT_IN_12 if needed */
 392	SDEB_I_SERV_ACT_OUT_16 = 13,	/* add ...SERV_ACT_OUT_12 if needed */
 393	SDEB_I_MAINT_IN = 14,
 394	SDEB_I_MAINT_OUT = 15,
 395	SDEB_I_VERIFY = 16,		/* VERIFY(10), VERIFY(16) */
 396	SDEB_I_VARIABLE_LEN = 17,	/* READ(32), WRITE(32), WR_SCAT(32) */
 397	SDEB_I_RESERVE = 18,		/* 6, 10 */
 398	SDEB_I_RELEASE = 19,		/* 6, 10 */
 399	SDEB_I_ALLOW_REMOVAL = 20,	/* PREVENT ALLOW MEDIUM REMOVAL */
 400	SDEB_I_REZERO_UNIT = 21,	/* REWIND in SSC */
 401	SDEB_I_ATA_PT = 22,		/* 12, 16 */
 402	SDEB_I_SEND_DIAG = 23,
 403	SDEB_I_UNMAP = 24,
 404	SDEB_I_WRITE_BUFFER = 25,
 405	SDEB_I_WRITE_SAME = 26,		/* 10, 16 */
 406	SDEB_I_SYNC_CACHE = 27,		/* 10, 16 */
 407	SDEB_I_COMP_WRITE = 28,
 408	SDEB_I_PRE_FETCH = 29,		/* 10, 16 */
 409	SDEB_I_ZONE_OUT = 30,		/* 0x94+SA; includes no data xfer */
 410	SDEB_I_ZONE_IN = 31,		/* 0x95+SA; all have data-in */
 411	SDEB_I_LAST_ELEM_P1 = 32,	/* keep this last (previous + 1) */
 412};
 413
 414
 415static const unsigned char opcode_ind_arr[256] = {
 416/* 0x0; 0x0->0x1f: 6 byte cdbs */
 417	SDEB_I_TEST_UNIT_READY, SDEB_I_REZERO_UNIT, 0, SDEB_I_REQUEST_SENSE,
 418	    0, 0, 0, 0,
 419	SDEB_I_READ, 0, SDEB_I_WRITE, 0, 0, 0, 0, 0,
 420	0, 0, SDEB_I_INQUIRY, 0, 0, SDEB_I_MODE_SELECT, SDEB_I_RESERVE,
 421	    SDEB_I_RELEASE,
 422	0, 0, SDEB_I_MODE_SENSE, SDEB_I_START_STOP, 0, SDEB_I_SEND_DIAG,
 423	    SDEB_I_ALLOW_REMOVAL, 0,
 424/* 0x20; 0x20->0x3f: 10 byte cdbs */
 425	0, 0, 0, 0, 0, SDEB_I_READ_CAPACITY, 0, 0,
 426	SDEB_I_READ, 0, SDEB_I_WRITE, 0, 0, 0, 0, SDEB_I_VERIFY,
 427	0, 0, 0, 0, SDEB_I_PRE_FETCH, SDEB_I_SYNC_CACHE, 0, 0,
 428	0, 0, 0, SDEB_I_WRITE_BUFFER, 0, 0, 0, 0,
 429/* 0x40; 0x40->0x5f: 10 byte cdbs */
 430	0, SDEB_I_WRITE_SAME, SDEB_I_UNMAP, 0, 0, 0, 0, 0,
 431	0, 0, 0, 0, 0, SDEB_I_LOG_SENSE, 0, 0,
 432	0, 0, 0, 0, 0, SDEB_I_MODE_SELECT, SDEB_I_RESERVE,
 433	    SDEB_I_RELEASE,
 434	0, 0, SDEB_I_MODE_SENSE, 0, 0, 0, 0, 0,
 435/* 0x60; 0x60->0x7d are reserved, 0x7e is "extended cdb" */
 436	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 437	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 438	0, SDEB_I_VARIABLE_LEN,
 439/* 0x80; 0x80->0x9f: 16 byte cdbs */
 440	0, 0, 0, 0, 0, SDEB_I_ATA_PT, 0, 0,
 441	SDEB_I_READ, SDEB_I_COMP_WRITE, SDEB_I_WRITE, 0,
 442	0, 0, 0, SDEB_I_VERIFY,
 443	SDEB_I_PRE_FETCH, SDEB_I_SYNC_CACHE, 0, SDEB_I_WRITE_SAME,
 444	SDEB_I_ZONE_OUT, SDEB_I_ZONE_IN, 0, 0,
 445	0, 0, 0, 0, 0, 0, SDEB_I_SERV_ACT_IN_16, SDEB_I_SERV_ACT_OUT_16,
 446/* 0xa0; 0xa0->0xbf: 12 byte cdbs */
 447	SDEB_I_REPORT_LUNS, SDEB_I_ATA_PT, 0, SDEB_I_MAINT_IN,
 448	     SDEB_I_MAINT_OUT, 0, 0, 0,
 449	SDEB_I_READ, 0 /* SDEB_I_SERV_ACT_OUT_12 */, SDEB_I_WRITE,
 450	     0 /* SDEB_I_SERV_ACT_IN_12 */, 0, 0, 0, 0,
 451	0, 0, 0, 0, 0, 0, 0, 0,
 452	0, 0, 0, 0, 0, 0, 0, 0,
 453/* 0xc0; 0xc0->0xff: vendor specific */
 454	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 455	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 456	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 457	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 458};
 459
 460/*
 461 * The following "response" functions return the SCSI mid-level's 4 byte
 462 * tuple-in-an-int. To handle commands with an IMMED bit, for a faster
 463 * command completion, they can mask their return value with
 464 * SDEG_RES_IMMED_MASK .
 465 */
 466#define SDEG_RES_IMMED_MASK 0x40000000
 467
 468static int resp_inquiry(struct scsi_cmnd *, struct sdebug_dev_info *);
 469static int resp_report_luns(struct scsi_cmnd *, struct sdebug_dev_info *);
 470static int resp_requests(struct scsi_cmnd *, struct sdebug_dev_info *);
 471static int resp_mode_sense(struct scsi_cmnd *, struct sdebug_dev_info *);
 472static int resp_mode_select(struct scsi_cmnd *, struct sdebug_dev_info *);
 473static int resp_log_sense(struct scsi_cmnd *, struct sdebug_dev_info *);
 474static int resp_readcap(struct scsi_cmnd *, struct sdebug_dev_info *);
 475static int resp_read_dt0(struct scsi_cmnd *, struct sdebug_dev_info *);
 476static int resp_write_dt0(struct scsi_cmnd *, struct sdebug_dev_info *);
 477static int resp_write_scat(struct scsi_cmnd *, struct sdebug_dev_info *);
 478static int resp_start_stop(struct scsi_cmnd *, struct sdebug_dev_info *);
 479static int resp_readcap16(struct scsi_cmnd *, struct sdebug_dev_info *);
 480static int resp_get_lba_status(struct scsi_cmnd *, struct sdebug_dev_info *);
 481static int resp_report_tgtpgs(struct scsi_cmnd *, struct sdebug_dev_info *);
 482static int resp_unmap(struct scsi_cmnd *, struct sdebug_dev_info *);
 483static int resp_rsup_opcodes(struct scsi_cmnd *, struct sdebug_dev_info *);
 484static int resp_rsup_tmfs(struct scsi_cmnd *, struct sdebug_dev_info *);
 485static int resp_verify(struct scsi_cmnd *, struct sdebug_dev_info *);
 486static int resp_write_same_10(struct scsi_cmnd *, struct sdebug_dev_info *);
 487static int resp_write_same_16(struct scsi_cmnd *, struct sdebug_dev_info *);
 488static int resp_comp_write(struct scsi_cmnd *, struct sdebug_dev_info *);
 489static int resp_write_buffer(struct scsi_cmnd *, struct sdebug_dev_info *);
 490static int resp_sync_cache(struct scsi_cmnd *, struct sdebug_dev_info *);
 491static int resp_pre_fetch(struct scsi_cmnd *, struct sdebug_dev_info *);
 492static int resp_report_zones(struct scsi_cmnd *, struct sdebug_dev_info *);
 493static int resp_open_zone(struct scsi_cmnd *, struct sdebug_dev_info *);
 494static int resp_close_zone(struct scsi_cmnd *, struct sdebug_dev_info *);
 495static int resp_finish_zone(struct scsi_cmnd *, struct sdebug_dev_info *);
 496static int resp_rwp_zone(struct scsi_cmnd *, struct sdebug_dev_info *);
 497
 498static int sdebug_do_add_host(bool mk_new_store);
 499static int sdebug_add_host_helper(int per_host_idx);
 500static void sdebug_do_remove_host(bool the_end);
 501static int sdebug_add_store(void);
 502static void sdebug_erase_store(int idx, struct sdeb_store_info *sip);
 503static void sdebug_erase_all_stores(bool apart_from_first);
 504
 
 
 505/*
 506 * The following are overflow arrays for cdbs that "hit" the same index in
 507 * the opcode_info_arr array. The most time sensitive (or commonly used) cdb
 508 * should be placed in opcode_info_arr[], the others should be placed here.
 509 */
 510static const struct opcode_info_t msense_iarr[] = {
 511	{0, 0x1a, 0, F_D_IN, NULL, NULL,
 512	    {6,  0xe8, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 513};
 514
 515static const struct opcode_info_t mselect_iarr[] = {
 516	{0, 0x15, 0, F_D_OUT, NULL, NULL,
 517	    {6,  0xf1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 518};
 519
 520static const struct opcode_info_t read_iarr[] = {
 521	{0, 0x28, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL,/* READ(10) */
 522	    {10,  0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
 523	     0, 0, 0, 0} },
 524	{0, 0x8, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL, /* READ(6) */
 525	    {6,  0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 526	{0, 0xa8, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL,/* READ(12) */
 527	    {12,  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf,
 528	     0xc7, 0, 0, 0, 0} },
 529};
 530
 531static const struct opcode_info_t write_iarr[] = {
 532	{0, 0x2a, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0,  /* WRITE(10) */
 533	    NULL, {10,  0xfb, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7,
 534		   0, 0, 0, 0, 0, 0} },
 535	{0, 0xa, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0,   /* WRITE(6) */
 536	    NULL, {6,  0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0,
 537		   0, 0, 0} },
 538	{0, 0xaa, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0,  /* WRITE(12) */
 539	    NULL, {12,  0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 540		   0xbf, 0xc7, 0, 0, 0, 0} },
 541};
 542
 543static const struct opcode_info_t verify_iarr[] = {
 544	{0, 0x2f, 0, F_D_OUT_MAYBE | FF_MEDIA_IO, resp_verify,/* VERIFY(10) */
 545	    NULL, {10,  0xf7, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xc7,
 546		   0, 0, 0, 0, 0, 0} },
 547};
 548
 549static const struct opcode_info_t sa_in_16_iarr[] = {
 550	{0, 0x9e, 0x12, F_SA_LOW | F_D_IN, resp_get_lba_status, NULL,
 551	    {16,  0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 552	     0xff, 0xff, 0xff, 0, 0xc7} },	/* GET LBA STATUS(16) */
 553};
 554
 555static const struct opcode_info_t vl_iarr[] = {	/* VARIABLE LENGTH */
 556	{0, 0x7f, 0xb, F_SA_HIGH | F_D_OUT | FF_MEDIA_IO, resp_write_dt0,
 557	    NULL, {32,  0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0xb, 0xfa,
 558		   0, 0xff, 0xff, 0xff, 0xff} },	/* WRITE(32) */
 559	{0, 0x7f, 0x11, F_SA_HIGH | F_D_OUT | FF_MEDIA_IO, resp_write_scat,
 560	    NULL, {32,  0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0x11, 0xf8,
 561		   0, 0xff, 0xff, 0x0, 0x0} },	/* WRITE SCATTERED(32) */
 562};
 563
 564static const struct opcode_info_t maint_in_iarr[] = {	/* MAINT IN */
 565	{0, 0xa3, 0xc, F_SA_LOW | F_D_IN, resp_rsup_opcodes, NULL,
 566	    {12,  0xc, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0,
 567	     0xc7, 0, 0, 0, 0} }, /* REPORT SUPPORTED OPERATION CODES */
 568	{0, 0xa3, 0xd, F_SA_LOW | F_D_IN, resp_rsup_tmfs, NULL,
 569	    {12,  0xd, 0x80, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0,
 570	     0, 0} },	/* REPORTED SUPPORTED TASK MANAGEMENT FUNCTIONS */
 571};
 572
 573static const struct opcode_info_t write_same_iarr[] = {
 574	{0, 0x93, 0, F_D_OUT_MAYBE | FF_MEDIA_IO, resp_write_same_16, NULL,
 575	    {16,  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 576	     0xff, 0xff, 0xff, 0x3f, 0xc7} },		/* WRITE SAME(16) */
 577};
 578
 579static const struct opcode_info_t reserve_iarr[] = {
 580	{0, 0x16, 0, F_D_OUT, NULL, NULL,		/* RESERVE(6) */
 581	    {6,  0x1f, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 582};
 583
 584static const struct opcode_info_t release_iarr[] = {
 585	{0, 0x17, 0, F_D_OUT, NULL, NULL,		/* RELEASE(6) */
 586	    {6,  0x1f, 0xff, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 587};
 588
 589static const struct opcode_info_t sync_cache_iarr[] = {
 590	{0, 0x91, 0, F_SYNC_DELAY | F_M_ACCESS, resp_sync_cache, NULL,
 591	    {16,  0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 592	     0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} },	/* SYNC_CACHE (16) */
 593};
 594
 595static const struct opcode_info_t pre_fetch_iarr[] = {
 596	{0, 0x90, 0, F_SYNC_DELAY | FF_MEDIA_IO, resp_pre_fetch, NULL,
 597	    {16,  0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 598	     0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} },	/* PRE-FETCH (16) */
 599};
 600
 601static const struct opcode_info_t zone_out_iarr[] = {	/* ZONE OUT(16) */
 602	{0, 0x94, 0x1, F_SA_LOW | F_M_ACCESS, resp_close_zone, NULL,
 603	    {16, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 604	     0xff, 0, 0, 0xff, 0xff, 0x1, 0xc7} },	/* CLOSE ZONE */
 605	{0, 0x94, 0x2, F_SA_LOW | F_M_ACCESS, resp_finish_zone, NULL,
 606	    {16, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 607	     0xff, 0, 0, 0xff, 0xff, 0x1, 0xc7} },	/* FINISH ZONE */
 608	{0, 0x94, 0x4, F_SA_LOW | F_M_ACCESS, resp_rwp_zone, NULL,
 609	    {16, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 610	     0xff, 0, 0, 0xff, 0xff, 0x1, 0xc7} },  /* RESET WRITE POINTER */
 611};
 612
 613static const struct opcode_info_t zone_in_iarr[] = {	/* ZONE IN(16) */
 614	{0, 0x95, 0x6, F_SA_LOW | F_D_IN | F_M_ACCESS, NULL, NULL,
 615	    {16, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 616	     0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} }, /* REPORT ZONES */
 617};
 618
 619
 620/* This array is accessed via SDEB_I_* values. Make sure all are mapped,
 621 * plus the terminating elements for logic that scans this table such as
 622 * REPORT SUPPORTED OPERATION CODES. */
 623static const struct opcode_info_t opcode_info_arr[SDEB_I_LAST_ELEM_P1 + 1] = {
 624/* 0 */
 625	{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL,	/* unknown opcodes */
 626	    {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 627	{0, 0x12, 0, FF_RESPOND | F_D_IN, resp_inquiry, NULL, /* INQUIRY */
 628	    {6,  0xe3, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 629	{0, 0xa0, 0, FF_RESPOND | F_D_IN, resp_report_luns, NULL,
 630	    {12,  0xe3, 0xff, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0,
 631	     0, 0} },					/* REPORT LUNS */
 632	{0, 0x3, 0, FF_RESPOND | F_D_IN, resp_requests, NULL,
 633	    {6,  0xe1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 634	{0, 0x0, 0, F_M_ACCESS | F_RL_WLUN_OK, NULL, NULL,/* TEST UNIT READY */
 635	    {6,  0, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 636/* 5 */
 637	{ARRAY_SIZE(msense_iarr), 0x5a, 0, F_D_IN,	/* MODE SENSE(10) */
 638	    resp_mode_sense, msense_iarr, {10,  0xf8, 0xff, 0xff, 0, 0, 0,
 639		0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
 640	{ARRAY_SIZE(mselect_iarr), 0x55, 0, F_D_OUT,	/* MODE SELECT(10) */
 641	    resp_mode_select, mselect_iarr, {10,  0xf1, 0, 0, 0, 0, 0, 0xff,
 642		0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
 643	{0, 0x4d, 0, F_D_IN, resp_log_sense, NULL,	/* LOG SENSE */
 644	    {10,  0xe3, 0xff, 0xff, 0, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0,
 645	     0, 0, 0} },
 646	{0, 0x25, 0, F_D_IN, resp_readcap, NULL,    /* READ CAPACITY(10) */
 647	    {10,  0xe1, 0xff, 0xff, 0xff, 0xff, 0, 0, 0x1, 0xc7, 0, 0, 0, 0,
 648	     0, 0} },
 649	{ARRAY_SIZE(read_iarr), 0x88, 0, F_D_IN | FF_MEDIA_IO, /* READ(16) */
 650	    resp_read_dt0, read_iarr, {16,  0xfe, 0xff, 0xff, 0xff, 0xff,
 651	    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7} },
 652/* 10 */
 653	{ARRAY_SIZE(write_iarr), 0x8a, 0, F_D_OUT | FF_MEDIA_IO,
 654	    resp_write_dt0, write_iarr,			/* WRITE(16) */
 655		{16,  0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 656		 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7} },
 657	{0, 0x1b, 0, F_SSU_DELAY, resp_start_stop, NULL,/* START STOP UNIT */
 658	    {6,  0x1, 0, 0xf, 0xf7, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 659	{ARRAY_SIZE(sa_in_16_iarr), 0x9e, 0x10, F_SA_LOW | F_D_IN,
 660	    resp_readcap16, sa_in_16_iarr, /* SA_IN(16), READ CAPACITY(16) */
 661		{16,  0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 662		 0xff, 0xff, 0xff, 0xff, 0x1, 0xc7} },
 663	{0, 0x9f, 0x12, F_SA_LOW | F_D_OUT | FF_MEDIA_IO, resp_write_scat,
 664	    NULL, {16,  0x12, 0xf9, 0x0, 0xff, 0xff, 0, 0, 0xff, 0xff, 0xff,
 665	    0xff, 0xff, 0xff, 0xff, 0xc7} },  /* SA_OUT(16), WRITE SCAT(16) */
 666	{ARRAY_SIZE(maint_in_iarr), 0xa3, 0xa, F_SA_LOW | F_D_IN,
 667	    resp_report_tgtpgs,	/* MAINT IN, REPORT TARGET PORT GROUPS */
 668		maint_in_iarr, {12,  0xea, 0, 0, 0, 0, 0xff, 0xff, 0xff,
 669				0xff, 0, 0xc7, 0, 0, 0, 0} },
 670/* 15 */
 671	{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* MAINT OUT */
 672	    {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 673	{ARRAY_SIZE(verify_iarr), 0x8f, 0,
 674	    F_D_OUT_MAYBE | FF_MEDIA_IO, resp_verify,	/* VERIFY(16) */
 675	    verify_iarr, {16,  0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 676			  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} },
 677	{ARRAY_SIZE(vl_iarr), 0x7f, 0x9, F_SA_HIGH | F_D_IN | FF_MEDIA_IO,
 678	    resp_read_dt0, vl_iarr,	/* VARIABLE LENGTH, READ(32) */
 679	    {32,  0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0x9, 0xfe, 0, 0xff, 0xff,
 680	     0xff, 0xff} },
 681	{ARRAY_SIZE(reserve_iarr), 0x56, 0, F_D_OUT,
 682	    NULL, reserve_iarr,	/* RESERVE(10) <no response function> */
 683	    {10,  0xff, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
 684	     0} },
 685	{ARRAY_SIZE(release_iarr), 0x57, 0, F_D_OUT,
 686	    NULL, release_iarr, /* RELEASE(10) <no response function> */
 687	    {10,  0x13, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
 688	     0} },
 689/* 20 */
 690	{0, 0x1e, 0, 0, NULL, NULL, /* ALLOW REMOVAL */
 691	    {6,  0, 0, 0, 0x3, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 692	{0, 0x1, 0, 0, resp_start_stop, NULL, /* REWIND ?? */
 693	    {6,  0x1, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 694	{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* ATA_PT */
 695	    {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 696	{0, 0x1d, F_D_OUT, 0, NULL, NULL,	/* SEND DIAGNOSTIC */
 697	    {6,  0xf7, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 698	{0, 0x42, 0, F_D_OUT | FF_MEDIA_IO, resp_unmap, NULL, /* UNMAP */
 699	    {10,  0x1, 0, 0, 0, 0, 0x3f, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
 700/* 25 */
 701	{0, 0x3b, 0, F_D_OUT_MAYBE, resp_write_buffer, NULL,
 702	    {10,  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0,
 703	     0, 0, 0, 0} },			/* WRITE_BUFFER */
 704	{ARRAY_SIZE(write_same_iarr), 0x41, 0, F_D_OUT_MAYBE | FF_MEDIA_IO,
 705	    resp_write_same_10, write_same_iarr,	/* WRITE SAME(10) */
 706		{10,  0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0,
 707		 0, 0, 0, 0, 0} },
 708	{ARRAY_SIZE(sync_cache_iarr), 0x35, 0, F_SYNC_DELAY | F_M_ACCESS,
 709	    resp_sync_cache, sync_cache_iarr,
 710	    {10,  0x7, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
 711	     0, 0, 0, 0} },			/* SYNC_CACHE (10) */
 712	{0, 0x89, 0, F_D_OUT | FF_MEDIA_IO, resp_comp_write, NULL,
 713	    {16,  0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0,
 714	     0, 0xff, 0x3f, 0xc7} },		/* COMPARE AND WRITE */
 715	{ARRAY_SIZE(pre_fetch_iarr), 0x34, 0, F_SYNC_DELAY | FF_MEDIA_IO,
 716	    resp_pre_fetch, pre_fetch_iarr,
 717	    {10,  0x2, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
 718	     0, 0, 0, 0} },			/* PRE-FETCH (10) */
 719
 720/* 30 */
 721	{ARRAY_SIZE(zone_out_iarr), 0x94, 0x3, F_SA_LOW | F_M_ACCESS,
 722	    resp_open_zone, zone_out_iarr, /* ZONE_OUT(16), OPEN ZONE) */
 723		{16,  0x3 /* SA */, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 724		 0xff, 0xff, 0x0, 0x0, 0xff, 0xff, 0x1, 0xc7} },
 725	{ARRAY_SIZE(zone_in_iarr), 0x95, 0x0, F_SA_LOW | F_M_ACCESS,
 726	    resp_report_zones, zone_in_iarr, /* ZONE_IN(16), REPORT ZONES) */
 727		{16,  0x0 /* SA */, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 728		 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xc7} },
 729/* sentinel */
 730	{0xff, 0, 0, 0, NULL, NULL,		/* terminating element */
 731	    {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 732};
 733
 734static int sdebug_num_hosts;
 735static int sdebug_add_host = DEF_NUM_HOST;  /* in sysfs this is relative */
 736static int sdebug_ato = DEF_ATO;
 737static int sdebug_cdb_len = DEF_CDB_LEN;
 738static int sdebug_jdelay = DEF_JDELAY;	/* if > 0 then unit is jiffies */
 739static int sdebug_dev_size_mb = DEF_DEV_SIZE_PRE_INIT;
 740static int sdebug_dif = DEF_DIF;
 741static int sdebug_dix = DEF_DIX;
 742static int sdebug_dsense = DEF_D_SENSE;
 743static int sdebug_every_nth = DEF_EVERY_NTH;
 744static int sdebug_fake_rw = DEF_FAKE_RW;
 745static unsigned int sdebug_guard = DEF_GUARD;
 746static int sdebug_host_max_queue;	/* per host */
 747static int sdebug_lowest_aligned = DEF_LOWEST_ALIGNED;
 748static int sdebug_max_luns = DEF_MAX_LUNS;
 749static int sdebug_max_queue = SDEBUG_CANQUEUE;	/* per submit queue */
 750static unsigned int sdebug_medium_error_start = OPT_MEDIUM_ERR_ADDR;
 751static int sdebug_medium_error_count = OPT_MEDIUM_ERR_NUM;
 752static atomic_t retired_max_queue;	/* if > 0 then was prior max_queue */
 753static int sdebug_ndelay = DEF_NDELAY;	/* if > 0 then unit is nanoseconds */
 754static int sdebug_no_lun_0 = DEF_NO_LUN_0;
 755static int sdebug_no_uld;
 756static int sdebug_num_parts = DEF_NUM_PARTS;
 757static int sdebug_num_tgts = DEF_NUM_TGTS; /* targets per host */
 758static int sdebug_opt_blks = DEF_OPT_BLKS;
 759static int sdebug_opts = DEF_OPTS;
 760static int sdebug_physblk_exp = DEF_PHYSBLK_EXP;
 761static int sdebug_opt_xferlen_exp = DEF_OPT_XFERLEN_EXP;
 762static int sdebug_ptype = DEF_PTYPE; /* SCSI peripheral device type */
 763static int sdebug_scsi_level = DEF_SCSI_LEVEL;
 764static int sdebug_sector_size = DEF_SECTOR_SIZE;
 765static int sdeb_tur_ms_to_ready = DEF_TUR_MS_TO_READY;
 766static int sdebug_virtual_gb = DEF_VIRTUAL_GB;
 767static int sdebug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
 768static unsigned int sdebug_lbpu = DEF_LBPU;
 769static unsigned int sdebug_lbpws = DEF_LBPWS;
 770static unsigned int sdebug_lbpws10 = DEF_LBPWS10;
 771static unsigned int sdebug_lbprz = DEF_LBPRZ;
 772static unsigned int sdebug_unmap_alignment = DEF_UNMAP_ALIGNMENT;
 773static unsigned int sdebug_unmap_granularity = DEF_UNMAP_GRANULARITY;
 774static unsigned int sdebug_unmap_max_blocks = DEF_UNMAP_MAX_BLOCKS;
 775static unsigned int sdebug_unmap_max_desc = DEF_UNMAP_MAX_DESC;
 776static unsigned int sdebug_write_same_length = DEF_WRITESAME_LENGTH;
 777static int sdebug_uuid_ctl = DEF_UUID_CTL;
 778static bool sdebug_random = DEF_RANDOM;
 779static bool sdebug_per_host_store = DEF_PER_HOST_STORE;
 780static bool sdebug_removable = DEF_REMOVABLE;
 781static bool sdebug_clustering;
 782static bool sdebug_host_lock = DEF_HOST_LOCK;
 783static bool sdebug_strict = DEF_STRICT;
 784static bool sdebug_any_injecting_opt;
 
 785static bool sdebug_verbose;
 786static bool have_dif_prot;
 787static bool write_since_sync;
 788static bool sdebug_statistics = DEF_STATISTICS;
 789static bool sdebug_wp;
 790/* Following enum: 0: no zbc, def; 1: host aware; 2: host managed */
 791static enum blk_zoned_model sdeb_zbc_model = BLK_ZONED_NONE;
 
 
 
 
 792static char *sdeb_zbc_model_s;
 793
 
 
 
 
 
 
 
 794static unsigned int sdebug_store_sectors;
 795static sector_t sdebug_capacity;	/* in sectors */
 796
 797/* old BIOS stuff, kernel may get rid of them but some mode sense pages
 798   may still need them */
 799static int sdebug_heads;		/* heads per disk */
 800static int sdebug_cylinders_per;	/* cylinders per surface */
 801static int sdebug_sectors_per;		/* sectors per cylinder */
 802
 803static LIST_HEAD(sdebug_host_list);
 804static DEFINE_SPINLOCK(sdebug_host_list_lock);
 805
 806static struct xarray per_store_arr;
 807static struct xarray *per_store_ap = &per_store_arr;
 808static int sdeb_first_idx = -1;		/* invalid index ==> none created */
 809static int sdeb_most_recent_idx = -1;
 810static DEFINE_RWLOCK(sdeb_fake_rw_lck);	/* need a RW lock when fake_rw=1 */
 811
 812static unsigned long map_size;
 813static int num_aborts;
 814static int num_dev_resets;
 815static int num_target_resets;
 816static int num_bus_resets;
 817static int num_host_resets;
 818static int dix_writes;
 819static int dix_reads;
 820static int dif_errors;
 821
 822/* ZBC global data */
 823static bool sdeb_zbc_in_use;	/* true for host-aware and host-managed disks */
 
 824static int sdeb_zbc_zone_size_mb;
 825static int sdeb_zbc_max_open = DEF_ZBC_MAX_OPEN_ZONES;
 826static int sdeb_zbc_nr_conv = DEF_ZBC_NR_CONV_ZONES;
 827
 828static int submit_queues = DEF_SUBMIT_QUEUES;  /* > 1 for multi-queue (mq) */
 829static struct sdebug_queue *sdebug_q_arr;  /* ptr to array of submit queues */
 830
 831static DEFINE_RWLOCK(atomic_rw);
 832static DEFINE_RWLOCK(atomic_rw2);
 833
 834static rwlock_t *ramdisk_lck_a[2];
 835
 836static char sdebug_proc_name[] = MY_NAME;
 837static const char *my_name = MY_NAME;
 838
 839static struct bus_type pseudo_lld_bus;
 840
 841static struct device_driver sdebug_driverfs_driver = {
 842	.name 		= sdebug_proc_name,
 843	.bus		= &pseudo_lld_bus,
 844};
 845
 846static const int check_condition_result =
 847		(DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
 848
 849static const int illegal_condition_result =
 850	(DRIVER_SENSE << 24) | (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION;
 851
 852static const int device_qfull_result =
 853	(DID_OK << 16) | (COMMAND_COMPLETE << 8) | SAM_STAT_TASK_SET_FULL;
 854
 855static const int condition_met_result = SAM_STAT_CONDITION_MET;
 856
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 857
 858/* Only do the extra work involved in logical block provisioning if one or
 859 * more of the lbpu, lbpws or lbpws10 parameters are given and we are doing
 860 * real reads and writes (i.e. not skipping them for speed).
 861 */
 862static inline bool scsi_debug_lbp(void)
 863{
 864	return 0 == sdebug_fake_rw &&
 865		(sdebug_lbpu || sdebug_lbpws || sdebug_lbpws10);
 866}
 867
 868static void *lba2fake_store(struct sdeb_store_info *sip,
 869			    unsigned long long lba)
 870{
 871	struct sdeb_store_info *lsip = sip;
 872
 873	lba = do_div(lba, sdebug_store_sectors);
 874	if (!sip || !sip->storep) {
 875		WARN_ON_ONCE(true);
 876		lsip = xa_load(per_store_ap, 0);  /* should never be NULL */
 877	}
 878	return lsip->storep + lba * sdebug_sector_size;
 879}
 880
 881static struct t10_pi_tuple *dif_store(struct sdeb_store_info *sip,
 882				      sector_t sector)
 883{
 884	sector = sector_div(sector, sdebug_store_sectors);
 885
 886	return sip->dif_storep + sector;
 887}
 888
 889static void sdebug_max_tgts_luns(void)
 890{
 891	struct sdebug_host_info *sdbg_host;
 892	struct Scsi_Host *hpnt;
 893
 894	spin_lock(&sdebug_host_list_lock);
 895	list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
 896		hpnt = sdbg_host->shost;
 897		if ((hpnt->this_id >= 0) &&
 898		    (sdebug_num_tgts > hpnt->this_id))
 899			hpnt->max_id = sdebug_num_tgts + 1;
 900		else
 901			hpnt->max_id = sdebug_num_tgts;
 902		/* sdebug_max_luns; */
 903		hpnt->max_lun = SCSI_W_LUN_REPORT_LUNS + 1;
 904	}
 905	spin_unlock(&sdebug_host_list_lock);
 906}
 907
 908enum sdeb_cmd_data {SDEB_IN_DATA = 0, SDEB_IN_CDB = 1};
 909
 910/* Set in_bit to -1 to indicate no bit position of invalid field */
 911static void mk_sense_invalid_fld(struct scsi_cmnd *scp,
 912				 enum sdeb_cmd_data c_d,
 913				 int in_byte, int in_bit)
 914{
 915	unsigned char *sbuff;
 916	u8 sks[4];
 917	int sl, asc;
 918
 919	sbuff = scp->sense_buffer;
 920	if (!sbuff) {
 921		sdev_printk(KERN_ERR, scp->device,
 922			    "%s: sense_buffer is NULL\n", __func__);
 923		return;
 924	}
 925	asc = c_d ? INVALID_FIELD_IN_CDB : INVALID_FIELD_IN_PARAM_LIST;
 926	memset(sbuff, 0, SCSI_SENSE_BUFFERSIZE);
 927	scsi_build_sense_buffer(sdebug_dsense, sbuff, ILLEGAL_REQUEST, asc, 0);
 928	memset(sks, 0, sizeof(sks));
 929	sks[0] = 0x80;
 930	if (c_d)
 931		sks[0] |= 0x40;
 932	if (in_bit >= 0) {
 933		sks[0] |= 0x8;
 934		sks[0] |= 0x7 & in_bit;
 935	}
 936	put_unaligned_be16(in_byte, sks + 1);
 937	if (sdebug_dsense) {
 938		sl = sbuff[7] + 8;
 939		sbuff[7] = sl;
 940		sbuff[sl] = 0x2;
 941		sbuff[sl + 1] = 0x6;
 942		memcpy(sbuff + sl + 4, sks, 3);
 943	} else
 944		memcpy(sbuff + 15, sks, 3);
 945	if (sdebug_verbose)
 946		sdev_printk(KERN_INFO, scp->device, "%s:  [sense_key,asc,ascq"
 947			    "]: [0x5,0x%x,0x0] %c byte=%d, bit=%d\n",
 948			    my_name, asc, c_d ? 'C' : 'D', in_byte, in_bit);
 949}
 950
 951static void mk_sense_buffer(struct scsi_cmnd *scp, int key, int asc, int asq)
 952{
 953	unsigned char *sbuff;
 954
 955	sbuff = scp->sense_buffer;
 956	if (!sbuff) {
 957		sdev_printk(KERN_ERR, scp->device,
 958			    "%s: sense_buffer is NULL\n", __func__);
 959		return;
 960	}
 961	memset(sbuff, 0, SCSI_SENSE_BUFFERSIZE);
 962
 963	scsi_build_sense_buffer(sdebug_dsense, sbuff, key, asc, asq);
 964
 965	if (sdebug_verbose)
 966		sdev_printk(KERN_INFO, scp->device,
 967			    "%s:  [sense_key,asc,ascq]: [0x%x,0x%x,0x%x]\n",
 968			    my_name, key, asc, asq);
 969}
 970
 971static void mk_sense_invalid_opcode(struct scsi_cmnd *scp)
 972{
 973	mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
 974}
 975
 976static int scsi_debug_ioctl(struct scsi_device *dev, unsigned int cmd,
 977			    void __user *arg)
 978{
 979	if (sdebug_verbose) {
 980		if (0x1261 == cmd)
 981			sdev_printk(KERN_INFO, dev,
 982				    "%s: BLKFLSBUF [0x1261]\n", __func__);
 983		else if (0x5331 == cmd)
 984			sdev_printk(KERN_INFO, dev,
 985				    "%s: CDROM_GET_CAPABILITY [0x5331]\n",
 986				    __func__);
 987		else
 988			sdev_printk(KERN_INFO, dev, "%s: cmd=0x%x\n",
 989				    __func__, cmd);
 990	}
 991	return -EINVAL;
 992	/* return -ENOTTY; // correct return but upsets fdisk */
 993}
 994
 995static void config_cdb_len(struct scsi_device *sdev)
 996{
 997	switch (sdebug_cdb_len) {
 998	case 6:	/* suggest 6 byte READ, WRITE and MODE SENSE/SELECT */
 999		sdev->use_10_for_rw = false;
1000		sdev->use_16_for_rw = false;
1001		sdev->use_10_for_ms = false;
1002		break;
1003	case 10: /* suggest 10 byte RWs and 6 byte MODE SENSE/SELECT */
1004		sdev->use_10_for_rw = true;
1005		sdev->use_16_for_rw = false;
1006		sdev->use_10_for_ms = false;
1007		break;
1008	case 12: /* suggest 10 byte RWs and 10 byte MODE SENSE/SELECT */
1009		sdev->use_10_for_rw = true;
1010		sdev->use_16_for_rw = false;
1011		sdev->use_10_for_ms = true;
1012		break;
1013	case 16:
1014		sdev->use_10_for_rw = false;
1015		sdev->use_16_for_rw = true;
1016		sdev->use_10_for_ms = true;
1017		break;
1018	case 32: /* No knobs to suggest this so same as 16 for now */
1019		sdev->use_10_for_rw = false;
1020		sdev->use_16_for_rw = true;
1021		sdev->use_10_for_ms = true;
1022		break;
1023	default:
1024		pr_warn("unexpected cdb_len=%d, force to 10\n",
1025			sdebug_cdb_len);
1026		sdev->use_10_for_rw = true;
1027		sdev->use_16_for_rw = false;
1028		sdev->use_10_for_ms = false;
1029		sdebug_cdb_len = 10;
1030		break;
1031	}
1032}
1033
1034static void all_config_cdb_len(void)
1035{
1036	struct sdebug_host_info *sdbg_host;
1037	struct Scsi_Host *shost;
1038	struct scsi_device *sdev;
1039
1040	spin_lock(&sdebug_host_list_lock);
1041	list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
1042		shost = sdbg_host->shost;
1043		shost_for_each_device(sdev, shost) {
1044			config_cdb_len(sdev);
1045		}
1046	}
1047	spin_unlock(&sdebug_host_list_lock);
1048}
1049
1050static void clear_luns_changed_on_target(struct sdebug_dev_info *devip)
1051{
1052	struct sdebug_host_info *sdhp;
1053	struct sdebug_dev_info *dp;
1054
1055	spin_lock(&sdebug_host_list_lock);
1056	list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
1057		list_for_each_entry(dp, &sdhp->dev_info_list, dev_list) {
1058			if ((devip->sdbg_host == dp->sdbg_host) &&
1059			    (devip->target == dp->target))
1060				clear_bit(SDEBUG_UA_LUNS_CHANGED, dp->uas_bm);
1061		}
1062	}
1063	spin_unlock(&sdebug_host_list_lock);
1064}
1065
1066static int make_ua(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
1067{
1068	int k;
1069
1070	k = find_first_bit(devip->uas_bm, SDEBUG_NUM_UAS);
1071	if (k != SDEBUG_NUM_UAS) {
1072		const char *cp = NULL;
1073
1074		switch (k) {
1075		case SDEBUG_UA_POR:
1076			mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
1077					POWER_ON_RESET_ASCQ);
1078			if (sdebug_verbose)
1079				cp = "power on reset";
1080			break;
 
 
 
 
 
 
1081		case SDEBUG_UA_BUS_RESET:
1082			mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
1083					BUS_RESET_ASCQ);
1084			if (sdebug_verbose)
1085				cp = "bus reset";
1086			break;
1087		case SDEBUG_UA_MODE_CHANGED:
1088			mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
1089					MODE_CHANGED_ASCQ);
1090			if (sdebug_verbose)
1091				cp = "mode parameters changed";
1092			break;
1093		case SDEBUG_UA_CAPACITY_CHANGED:
1094			mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
1095					CAPACITY_CHANGED_ASCQ);
1096			if (sdebug_verbose)
1097				cp = "capacity data changed";
1098			break;
1099		case SDEBUG_UA_MICROCODE_CHANGED:
1100			mk_sense_buffer(scp, UNIT_ATTENTION,
1101					TARGET_CHANGED_ASC,
1102					MICROCODE_CHANGED_ASCQ);
1103			if (sdebug_verbose)
1104				cp = "microcode has been changed";
1105			break;
1106		case SDEBUG_UA_MICROCODE_CHANGED_WO_RESET:
1107			mk_sense_buffer(scp, UNIT_ATTENTION,
1108					TARGET_CHANGED_ASC,
1109					MICROCODE_CHANGED_WO_RESET_ASCQ);
1110			if (sdebug_verbose)
1111				cp = "microcode has been changed without reset";
1112			break;
1113		case SDEBUG_UA_LUNS_CHANGED:
1114			/*
1115			 * SPC-3 behavior is to report a UNIT ATTENTION with
1116			 * ASC/ASCQ REPORTED LUNS DATA HAS CHANGED on every LUN
1117			 * on the target, until a REPORT LUNS command is
1118			 * received.  SPC-4 behavior is to report it only once.
1119			 * NOTE:  sdebug_scsi_level does not use the same
1120			 * values as struct scsi_device->scsi_level.
1121			 */
1122			if (sdebug_scsi_level >= 6)	/* SPC-4 and above */
1123				clear_luns_changed_on_target(devip);
1124			mk_sense_buffer(scp, UNIT_ATTENTION,
1125					TARGET_CHANGED_ASC,
1126					LUNS_CHANGED_ASCQ);
1127			if (sdebug_verbose)
1128				cp = "reported luns data has changed";
1129			break;
1130		default:
1131			pr_warn("unexpected unit attention code=%d\n", k);
1132			if (sdebug_verbose)
1133				cp = "unknown";
1134			break;
1135		}
1136		clear_bit(k, devip->uas_bm);
1137		if (sdebug_verbose)
1138			sdev_printk(KERN_INFO, scp->device,
1139				   "%s reports: Unit attention: %s\n",
1140				   my_name, cp);
1141		return check_condition_result;
1142	}
1143	return 0;
1144}
1145
1146/* Build SCSI "data-in" buffer. Returns 0 if ok else (DID_ERROR << 16). */
1147static int fill_from_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
1148				int arr_len)
1149{
1150	int act_len;
1151	struct scsi_data_buffer *sdb = &scp->sdb;
1152
1153	if (!sdb->length)
1154		return 0;
1155	if (scp->sc_data_direction != DMA_FROM_DEVICE)
1156		return DID_ERROR << 16;
1157
1158	act_len = sg_copy_from_buffer(sdb->table.sgl, sdb->table.nents,
1159				      arr, arr_len);
1160	scsi_set_resid(scp, scsi_bufflen(scp) - act_len);
1161
1162	return 0;
1163}
1164
1165/* Partial build of SCSI "data-in" buffer. Returns 0 if ok else
1166 * (DID_ERROR << 16). Can write to offset in data-in buffer. If multiple
1167 * calls, not required to write in ascending offset order. Assumes resid
1168 * set to scsi_bufflen() prior to any calls.
1169 */
1170static int p_fill_from_dev_buffer(struct scsi_cmnd *scp, const void *arr,
1171				  int arr_len, unsigned int off_dst)
1172{
1173	unsigned int act_len, n;
1174	struct scsi_data_buffer *sdb = &scp->sdb;
1175	off_t skip = off_dst;
1176
1177	if (sdb->length <= off_dst)
1178		return 0;
1179	if (scp->sc_data_direction != DMA_FROM_DEVICE)
1180		return DID_ERROR << 16;
1181
1182	act_len = sg_pcopy_from_buffer(sdb->table.sgl, sdb->table.nents,
1183				       arr, arr_len, skip);
1184	pr_debug("%s: off_dst=%u, scsi_bufflen=%u, act_len=%u, resid=%d\n",
1185		 __func__, off_dst, scsi_bufflen(scp), act_len,
1186		 scsi_get_resid(scp));
1187	n = scsi_bufflen(scp) - (off_dst + act_len);
1188	scsi_set_resid(scp, min_t(int, scsi_get_resid(scp), n));
1189	return 0;
1190}
1191
1192/* Fetches from SCSI "data-out" buffer. Returns number of bytes fetched into
1193 * 'arr' or -1 if error.
1194 */
1195static int fetch_to_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
1196			       int arr_len)
1197{
1198	if (!scsi_bufflen(scp))
1199		return 0;
1200	if (scp->sc_data_direction != DMA_TO_DEVICE)
1201		return -1;
1202
1203	return scsi_sg_copy_to_buffer(scp, arr, arr_len);
1204}
1205
1206
1207static char sdebug_inq_vendor_id[9] = "Linux   ";
1208static char sdebug_inq_product_id[17] = "scsi_debug      ";
1209static char sdebug_inq_product_rev[5] = SDEBUG_VERSION;
1210/* Use some locally assigned NAAs for SAS addresses. */
1211static const u64 naa3_comp_a = 0x3222222000000000ULL;
1212static const u64 naa3_comp_b = 0x3333333000000000ULL;
1213static const u64 naa3_comp_c = 0x3111111000000000ULL;
1214
1215/* Device identification VPD page. Returns number of bytes placed in arr */
1216static int inquiry_vpd_83(unsigned char *arr, int port_group_id,
1217			  int target_dev_id, int dev_id_num,
1218			  const char *dev_id_str, int dev_id_str_len,
1219			  const uuid_t *lu_name)
1220{
1221	int num, port_a;
1222	char b[32];
1223
1224	port_a = target_dev_id + 1;
1225	/* T10 vendor identifier field format (faked) */
1226	arr[0] = 0x2;	/* ASCII */
1227	arr[1] = 0x1;
1228	arr[2] = 0x0;
1229	memcpy(&arr[4], sdebug_inq_vendor_id, 8);
1230	memcpy(&arr[12], sdebug_inq_product_id, 16);
1231	memcpy(&arr[28], dev_id_str, dev_id_str_len);
1232	num = 8 + 16 + dev_id_str_len;
1233	arr[3] = num;
1234	num += 4;
1235	if (dev_id_num >= 0) {
1236		if (sdebug_uuid_ctl) {
1237			/* Locally assigned UUID */
1238			arr[num++] = 0x1;  /* binary (not necessarily sas) */
1239			arr[num++] = 0xa;  /* PIV=0, lu, naa */
1240			arr[num++] = 0x0;
1241			arr[num++] = 0x12;
1242			arr[num++] = 0x10; /* uuid type=1, locally assigned */
1243			arr[num++] = 0x0;
1244			memcpy(arr + num, lu_name, 16);
1245			num += 16;
1246		} else {
1247			/* NAA-3, Logical unit identifier (binary) */
1248			arr[num++] = 0x1;  /* binary (not necessarily sas) */
1249			arr[num++] = 0x3;  /* PIV=0, lu, naa */
1250			arr[num++] = 0x0;
1251			arr[num++] = 0x8;
1252			put_unaligned_be64(naa3_comp_b + dev_id_num, arr + num);
1253			num += 8;
1254		}
1255		/* Target relative port number */
1256		arr[num++] = 0x61;	/* proto=sas, binary */
1257		arr[num++] = 0x94;	/* PIV=1, target port, rel port */
1258		arr[num++] = 0x0;	/* reserved */
1259		arr[num++] = 0x4;	/* length */
1260		arr[num++] = 0x0;	/* reserved */
1261		arr[num++] = 0x0;	/* reserved */
1262		arr[num++] = 0x0;
1263		arr[num++] = 0x1;	/* relative port A */
1264	}
1265	/* NAA-3, Target port identifier */
1266	arr[num++] = 0x61;	/* proto=sas, binary */
1267	arr[num++] = 0x93;	/* piv=1, target port, naa */
1268	arr[num++] = 0x0;
1269	arr[num++] = 0x8;
1270	put_unaligned_be64(naa3_comp_a + port_a, arr + num);
1271	num += 8;
1272	/* NAA-3, Target port group identifier */
1273	arr[num++] = 0x61;	/* proto=sas, binary */
1274	arr[num++] = 0x95;	/* piv=1, target port group id */
1275	arr[num++] = 0x0;
1276	arr[num++] = 0x4;
1277	arr[num++] = 0;
1278	arr[num++] = 0;
1279	put_unaligned_be16(port_group_id, arr + num);
1280	num += 2;
1281	/* NAA-3, Target device identifier */
1282	arr[num++] = 0x61;	/* proto=sas, binary */
1283	arr[num++] = 0xa3;	/* piv=1, target device, naa */
1284	arr[num++] = 0x0;
1285	arr[num++] = 0x8;
1286	put_unaligned_be64(naa3_comp_a + target_dev_id, arr + num);
1287	num += 8;
1288	/* SCSI name string: Target device identifier */
1289	arr[num++] = 0x63;	/* proto=sas, UTF-8 */
1290	arr[num++] = 0xa8;	/* piv=1, target device, SCSI name string */
1291	arr[num++] = 0x0;
1292	arr[num++] = 24;
1293	memcpy(arr + num, "naa.32222220", 12);
1294	num += 12;
1295	snprintf(b, sizeof(b), "%08X", target_dev_id);
1296	memcpy(arr + num, b, 8);
1297	num += 8;
1298	memset(arr + num, 0, 4);
1299	num += 4;
1300	return num;
1301}
1302
1303static unsigned char vpd84_data[] = {
1304/* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
1305    0x22,0x22,0x22,0x0,0xbb,0x1,
1306    0x22,0x22,0x22,0x0,0xbb,0x2,
1307};
1308
1309/*  Software interface identification VPD page */
1310static int inquiry_vpd_84(unsigned char *arr)
1311{
1312	memcpy(arr, vpd84_data, sizeof(vpd84_data));
1313	return sizeof(vpd84_data);
1314}
1315
1316/* Management network addresses VPD page */
1317static int inquiry_vpd_85(unsigned char *arr)
1318{
1319	int num = 0;
1320	const char *na1 = "https://www.kernel.org/config";
1321	const char *na2 = "http://www.kernel.org/log";
1322	int plen, olen;
1323
1324	arr[num++] = 0x1;	/* lu, storage config */
1325	arr[num++] = 0x0;	/* reserved */
1326	arr[num++] = 0x0;
1327	olen = strlen(na1);
1328	plen = olen + 1;
1329	if (plen % 4)
1330		plen = ((plen / 4) + 1) * 4;
1331	arr[num++] = plen;	/* length, null termianted, padded */
1332	memcpy(arr + num, na1, olen);
1333	memset(arr + num + olen, 0, plen - olen);
1334	num += plen;
1335
1336	arr[num++] = 0x4;	/* lu, logging */
1337	arr[num++] = 0x0;	/* reserved */
1338	arr[num++] = 0x0;
1339	olen = strlen(na2);
1340	plen = olen + 1;
1341	if (plen % 4)
1342		plen = ((plen / 4) + 1) * 4;
1343	arr[num++] = plen;	/* length, null terminated, padded */
1344	memcpy(arr + num, na2, olen);
1345	memset(arr + num + olen, 0, plen - olen);
1346	num += plen;
1347
1348	return num;
1349}
1350
1351/* SCSI ports VPD page */
1352static int inquiry_vpd_88(unsigned char *arr, int target_dev_id)
1353{
1354	int num = 0;
1355	int port_a, port_b;
1356
1357	port_a = target_dev_id + 1;
1358	port_b = port_a + 1;
1359	arr[num++] = 0x0;	/* reserved */
1360	arr[num++] = 0x0;	/* reserved */
1361	arr[num++] = 0x0;
1362	arr[num++] = 0x1;	/* relative port 1 (primary) */
1363	memset(arr + num, 0, 6);
1364	num += 6;
1365	arr[num++] = 0x0;
1366	arr[num++] = 12;	/* length tp descriptor */
1367	/* naa-5 target port identifier (A) */
1368	arr[num++] = 0x61;	/* proto=sas, binary */
1369	arr[num++] = 0x93;	/* PIV=1, target port, NAA */
1370	arr[num++] = 0x0;	/* reserved */
1371	arr[num++] = 0x8;	/* length */
1372	put_unaligned_be64(naa3_comp_a + port_a, arr + num);
1373	num += 8;
1374	arr[num++] = 0x0;	/* reserved */
1375	arr[num++] = 0x0;	/* reserved */
1376	arr[num++] = 0x0;
1377	arr[num++] = 0x2;	/* relative port 2 (secondary) */
1378	memset(arr + num, 0, 6);
1379	num += 6;
1380	arr[num++] = 0x0;
1381	arr[num++] = 12;	/* length tp descriptor */
1382	/* naa-5 target port identifier (B) */
1383	arr[num++] = 0x61;	/* proto=sas, binary */
1384	arr[num++] = 0x93;	/* PIV=1, target port, NAA */
1385	arr[num++] = 0x0;	/* reserved */
1386	arr[num++] = 0x8;	/* length */
1387	put_unaligned_be64(naa3_comp_a + port_b, arr + num);
1388	num += 8;
1389
1390	return num;
1391}
1392
1393
1394static unsigned char vpd89_data[] = {
1395/* from 4th byte */ 0,0,0,0,
1396'l','i','n','u','x',' ',' ',' ',
1397'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
1398'1','2','3','4',
13990x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
14000xec,0,0,0,
14010x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
14020,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
14030x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
14040x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
14050x53,0x41,
14060x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
14070x20,0x20,
14080x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
14090x10,0x80,
14100,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
14110x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
14120x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
14130,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
14140x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
14150x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
14160,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
14170,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14180,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14190,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14200x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
14210,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
14220xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
14230,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
14240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14250,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14260,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14270,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14280,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14290,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14300,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14310,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14320,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14330,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14340,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
14350,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
1436};
1437
1438/* ATA Information VPD page */
1439static int inquiry_vpd_89(unsigned char *arr)
1440{
1441	memcpy(arr, vpd89_data, sizeof(vpd89_data));
1442	return sizeof(vpd89_data);
1443}
1444
1445
1446static unsigned char vpdb0_data[] = {
1447	/* from 4th byte */ 0,0,0,4, 0,0,0x4,0, 0,0,0,64,
1448	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1449	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1450	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1451};
1452
1453/* Block limits VPD page (SBC-3) */
1454static int inquiry_vpd_b0(unsigned char *arr)
1455{
1456	unsigned int gran;
1457
1458	memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
1459
1460	/* Optimal transfer length granularity */
1461	if (sdebug_opt_xferlen_exp != 0 &&
1462	    sdebug_physblk_exp < sdebug_opt_xferlen_exp)
1463		gran = 1 << sdebug_opt_xferlen_exp;
1464	else
1465		gran = 1 << sdebug_physblk_exp;
1466	put_unaligned_be16(gran, arr + 2);
1467
1468	/* Maximum Transfer Length */
1469	if (sdebug_store_sectors > 0x400)
1470		put_unaligned_be32(sdebug_store_sectors, arr + 4);
1471
1472	/* Optimal Transfer Length */
1473	put_unaligned_be32(sdebug_opt_blks, &arr[8]);
1474
1475	if (sdebug_lbpu) {
1476		/* Maximum Unmap LBA Count */
1477		put_unaligned_be32(sdebug_unmap_max_blocks, &arr[16]);
1478
1479		/* Maximum Unmap Block Descriptor Count */
1480		put_unaligned_be32(sdebug_unmap_max_desc, &arr[20]);
1481	}
1482
1483	/* Unmap Granularity Alignment */
1484	if (sdebug_unmap_alignment) {
1485		put_unaligned_be32(sdebug_unmap_alignment, &arr[28]);
1486		arr[28] |= 0x80; /* UGAVALID */
1487	}
1488
1489	/* Optimal Unmap Granularity */
1490	put_unaligned_be32(sdebug_unmap_granularity, &arr[24]);
1491
1492	/* Maximum WRITE SAME Length */
1493	put_unaligned_be64(sdebug_write_same_length, &arr[32]);
1494
1495	return 0x3c; /* Mandatory page length for Logical Block Provisioning */
1496
1497	return sizeof(vpdb0_data);
1498}
1499
1500/* Block device characteristics VPD page (SBC-3) */
1501static int inquiry_vpd_b1(struct sdebug_dev_info *devip, unsigned char *arr)
1502{
1503	memset(arr, 0, 0x3c);
1504	arr[0] = 0;
1505	arr[1] = 1;	/* non rotating medium (e.g. solid state) */
1506	arr[2] = 0;
1507	arr[3] = 5;	/* less than 1.8" */
1508	if (devip->zmodel == BLK_ZONED_HA)
1509		arr[4] = 1 << 4;	/* zoned field = 01b */
1510
1511	return 0x3c;
1512}
1513
1514/* Logical block provisioning VPD page (SBC-4) */
1515static int inquiry_vpd_b2(unsigned char *arr)
1516{
1517	memset(arr, 0, 0x4);
1518	arr[0] = 0;			/* threshold exponent */
1519	if (sdebug_lbpu)
1520		arr[1] = 1 << 7;
1521	if (sdebug_lbpws)
1522		arr[1] |= 1 << 6;
1523	if (sdebug_lbpws10)
1524		arr[1] |= 1 << 5;
1525	if (sdebug_lbprz && scsi_debug_lbp())
1526		arr[1] |= (sdebug_lbprz & 0x7) << 2;  /* sbc4r07 and later */
1527	/* anc_sup=0; dp=0 (no provisioning group descriptor) */
1528	/* minimum_percentage=0; provisioning_type=0 (unknown) */
1529	/* threshold_percentage=0 */
1530	return 0x4;
1531}
1532
1533/* Zoned block device characteristics VPD page (ZBC mandatory) */
1534static int inquiry_vpd_b6(struct sdebug_dev_info *devip, unsigned char *arr)
1535{
1536	memset(arr, 0, 0x3c);
1537	arr[0] = 0x1; /* set URSWRZ (unrestricted read in seq. wr req zone) */
1538	/*
1539	 * Set Optimal number of open sequential write preferred zones and
1540	 * Optimal number of non-sequentially written sequential write
1541	 * preferred zones fields to 'not reported' (0xffffffff). Leave other
1542	 * fields set to zero, apart from Max. number of open swrz_s field.
1543	 */
1544	put_unaligned_be32(0xffffffff, &arr[4]);
1545	put_unaligned_be32(0xffffffff, &arr[8]);
1546	if (sdeb_zbc_model == BLK_ZONED_HM && devip->max_open)
1547		put_unaligned_be32(devip->max_open, &arr[12]);
1548	else
1549		put_unaligned_be32(0xffffffff, &arr[12]);
 
 
 
 
 
 
1550	return 0x3c;
1551}
1552
1553#define SDEBUG_LONG_INQ_SZ 96
1554#define SDEBUG_MAX_INQ_ARR_SZ 584
1555
1556static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
1557{
1558	unsigned char pq_pdt;
1559	unsigned char *arr;
1560	unsigned char *cmd = scp->cmnd;
1561	int alloc_len, n, ret;
 
1562	bool have_wlun, is_disk, is_zbc, is_disk_zbc;
1563
1564	alloc_len = get_unaligned_be16(cmd + 3);
1565	arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
1566	if (! arr)
1567		return DID_REQUEUE << 16;
1568	is_disk = (sdebug_ptype == TYPE_DISK);
1569	is_zbc = (devip->zmodel != BLK_ZONED_NONE);
1570	is_disk_zbc = (is_disk || is_zbc);
1571	have_wlun = scsi_is_wlun(scp->device->lun);
1572	if (have_wlun)
1573		pq_pdt = TYPE_WLUN;	/* present, wlun */
1574	else if (sdebug_no_lun_0 && (devip->lun == SDEBUG_LUN_0_VAL))
1575		pq_pdt = 0x7f;	/* not present, PQ=3, PDT=0x1f */
1576	else
1577		pq_pdt = (sdebug_ptype & 0x1f);
1578	arr[0] = pq_pdt;
1579	if (0x2 & cmd[1]) {  /* CMDDT bit set */
1580		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 1);
1581		kfree(arr);
1582		return check_condition_result;
1583	} else if (0x1 & cmd[1]) {  /* EVPD bit set */
1584		int lu_id_num, port_group_id, target_dev_id, len;
 
1585		char lu_id_str[6];
1586		int host_no = devip->sdbg_host->shost->host_no;
1587		
1588		port_group_id = (((host_no + 1) & 0x7f) << 8) +
1589		    (devip->channel & 0x7f);
1590		if (sdebug_vpd_use_hostno == 0)
1591			host_no = 0;
1592		lu_id_num = have_wlun ? -1 : (((host_no + 1) * 2000) +
1593			    (devip->target * 1000) + devip->lun);
1594		target_dev_id = ((host_no + 1) * 2000) +
1595				 (devip->target * 1000) - 3;
1596		len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
1597		if (0 == cmd[2]) { /* supported vital product data pages */
1598			arr[1] = cmd[2];	/*sanity */
1599			n = 4;
1600			arr[n++] = 0x0;   /* this page */
1601			arr[n++] = 0x80;  /* unit serial number */
1602			arr[n++] = 0x83;  /* device identification */
1603			arr[n++] = 0x84;  /* software interface ident. */
1604			arr[n++] = 0x85;  /* management network addresses */
1605			arr[n++] = 0x86;  /* extended inquiry */
1606			arr[n++] = 0x87;  /* mode page policy */
1607			arr[n++] = 0x88;  /* SCSI ports */
1608			if (is_disk_zbc) {	  /* SBC or ZBC */
1609				arr[n++] = 0x89;  /* ATA information */
1610				arr[n++] = 0xb0;  /* Block limits */
1611				arr[n++] = 0xb1;  /* Block characteristics */
1612				if (is_disk)
1613					arr[n++] = 0xb2;  /* LB Provisioning */
1614				if (is_zbc)
1615					arr[n++] = 0xb6;  /* ZB dev. char. */
1616			}
1617			arr[3] = n - 4;	  /* number of supported VPD pages */
1618		} else if (0x80 == cmd[2]) { /* unit serial number */
1619			arr[1] = cmd[2];	/*sanity */
1620			arr[3] = len;
1621			memcpy(&arr[4], lu_id_str, len);
1622		} else if (0x83 == cmd[2]) { /* device identification */
1623			arr[1] = cmd[2];	/*sanity */
1624			arr[3] = inquiry_vpd_83(&arr[4], port_group_id,
1625						target_dev_id, lu_id_num,
1626						lu_id_str, len,
1627						&devip->lu_name);
1628		} else if (0x84 == cmd[2]) { /* Software interface ident. */
1629			arr[1] = cmd[2];	/*sanity */
1630			arr[3] = inquiry_vpd_84(&arr[4]);
1631		} else if (0x85 == cmd[2]) { /* Management network addresses */
1632			arr[1] = cmd[2];	/*sanity */
1633			arr[3] = inquiry_vpd_85(&arr[4]);
1634		} else if (0x86 == cmd[2]) { /* extended inquiry */
1635			arr[1] = cmd[2];	/*sanity */
1636			arr[3] = 0x3c;	/* number of following entries */
1637			if (sdebug_dif == T10_PI_TYPE3_PROTECTION)
1638				arr[4] = 0x4;	/* SPT: GRD_CHK:1 */
1639			else if (have_dif_prot)
1640				arr[4] = 0x5;   /* SPT: GRD_CHK:1, REF_CHK:1 */
1641			else
1642				arr[4] = 0x0;   /* no protection stuff */
1643			arr[5] = 0x7;   /* head of q, ordered + simple q's */
1644		} else if (0x87 == cmd[2]) { /* mode page policy */
1645			arr[1] = cmd[2];	/*sanity */
1646			arr[3] = 0x8;	/* number of following entries */
1647			arr[4] = 0x2;	/* disconnect-reconnect mp */
1648			arr[6] = 0x80;	/* mlus, shared */
1649			arr[8] = 0x18;	 /* protocol specific lu */
1650			arr[10] = 0x82;	 /* mlus, per initiator port */
1651		} else if (0x88 == cmd[2]) { /* SCSI Ports */
1652			arr[1] = cmd[2];	/*sanity */
1653			arr[3] = inquiry_vpd_88(&arr[4], target_dev_id);
1654		} else if (is_disk_zbc && 0x89 == cmd[2]) { /* ATA info */
1655			arr[1] = cmd[2];        /*sanity */
1656			n = inquiry_vpd_89(&arr[4]);
1657			put_unaligned_be16(n, arr + 2);
1658		} else if (is_disk_zbc && 0xb0 == cmd[2]) { /* Block limits */
1659			arr[1] = cmd[2];        /*sanity */
1660			arr[3] = inquiry_vpd_b0(&arr[4]);
1661		} else if (is_disk_zbc && 0xb1 == cmd[2]) { /* Block char. */
1662			arr[1] = cmd[2];        /*sanity */
1663			arr[3] = inquiry_vpd_b1(devip, &arr[4]);
1664		} else if (is_disk && 0xb2 == cmd[2]) { /* LB Prov. */
1665			arr[1] = cmd[2];        /*sanity */
1666			arr[3] = inquiry_vpd_b2(&arr[4]);
1667		} else if (is_zbc && cmd[2] == 0xb6) { /* ZB dev. charact. */
1668			arr[1] = cmd[2];        /*sanity */
1669			arr[3] = inquiry_vpd_b6(devip, &arr[4]);
1670		} else {
1671			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, -1);
1672			kfree(arr);
1673			return check_condition_result;
1674		}
1675		len = min(get_unaligned_be16(arr + 2) + 4, alloc_len);
1676		ret = fill_from_dev_buffer(scp, arr,
1677			    min(len, SDEBUG_MAX_INQ_ARR_SZ));
1678		kfree(arr);
1679		return ret;
1680	}
1681	/* drops through here for a standard inquiry */
1682	arr[1] = sdebug_removable ? 0x80 : 0;	/* Removable disk */
1683	arr[2] = sdebug_scsi_level;
1684	arr[3] = 2;    /* response_data_format==2 */
1685	arr[4] = SDEBUG_LONG_INQ_SZ - 5;
1686	arr[5] = (int)have_dif_prot;	/* PROTECT bit */
1687	if (sdebug_vpd_use_hostno == 0)
1688		arr[5] |= 0x10; /* claim: implicit TPGS */
1689	arr[6] = 0x10; /* claim: MultiP */
1690	/* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
1691	arr[7] = 0xa; /* claim: LINKED + CMDQUE */
1692	memcpy(&arr[8], sdebug_inq_vendor_id, 8);
1693	memcpy(&arr[16], sdebug_inq_product_id, 16);
1694	memcpy(&arr[32], sdebug_inq_product_rev, 4);
1695	/* Use Vendor Specific area to place driver date in ASCII hex */
1696	memcpy(&arr[36], sdebug_version_date, 8);
1697	/* version descriptors (2 bytes each) follow */
1698	put_unaligned_be16(0xc0, arr + 58);   /* SAM-6 no version claimed */
1699	put_unaligned_be16(0x5c0, arr + 60);  /* SPC-5 no version claimed */
1700	n = 62;
1701	if (is_disk) {		/* SBC-4 no version claimed */
1702		put_unaligned_be16(0x600, arr + n);
1703		n += 2;
1704	} else if (sdebug_ptype == TYPE_TAPE) {	/* SSC-4 rev 3 */
1705		put_unaligned_be16(0x525, arr + n);
1706		n += 2;
1707	} else if (is_zbc) {	/* ZBC BSR INCITS 536 revision 05 */
1708		put_unaligned_be16(0x624, arr + n);
1709		n += 2;
1710	}
1711	put_unaligned_be16(0x2100, arr + n);	/* SPL-4 no version claimed */
1712	ret = fill_from_dev_buffer(scp, arr,
1713			    min_t(int, alloc_len, SDEBUG_LONG_INQ_SZ));
1714	kfree(arr);
1715	return ret;
1716}
1717
1718/* See resp_iec_m_pg() for how this data is manipulated */
1719static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1720				   0, 0, 0x0, 0x0};
1721
1722static int resp_requests(struct scsi_cmnd *scp,
1723			 struct sdebug_dev_info *devip)
1724{
1725	unsigned char *cmd = scp->cmnd;
1726	unsigned char arr[SCSI_SENSE_BUFFERSIZE];	/* assume >= 18 bytes */
1727	bool dsense = !!(cmd[1] & 1);
1728	int alloc_len = cmd[4];
1729	int len = 18;
1730	int stopped_state = atomic_read(&devip->stopped);
1731
1732	memset(arr, 0, sizeof(arr));
1733	if (stopped_state > 0) {	/* some "pollable" data [spc6r02: 5.12.2] */
1734		if (dsense) {
1735			arr[0] = 0x72;
1736			arr[1] = NOT_READY;
1737			arr[2] = LOGICAL_UNIT_NOT_READY;
1738			arr[3] = (stopped_state == 2) ? 0x1 : 0x2;
1739			len = 8;
1740		} else {
1741			arr[0] = 0x70;
1742			arr[2] = NOT_READY;		/* NO_SENSE in sense_key */
1743			arr[7] = 0xa;			/* 18 byte sense buffer */
1744			arr[12] = LOGICAL_UNIT_NOT_READY;
1745			arr[13] = (stopped_state == 2) ? 0x1 : 0x2;
1746		}
1747	} else if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
1748		/* Information exceptions control mode page: TEST=1, MRIE=6 */
1749		if (dsense) {
1750			arr[0] = 0x72;
1751			arr[1] = 0x0;		/* NO_SENSE in sense_key */
1752			arr[2] = THRESHOLD_EXCEEDED;
1753			arr[3] = 0xff;		/* Failure prediction(false) */
1754			len = 8;
1755		} else {
1756			arr[0] = 0x70;
1757			arr[2] = 0x0;		/* NO_SENSE in sense_key */
1758			arr[7] = 0xa;   	/* 18 byte sense buffer */
1759			arr[12] = THRESHOLD_EXCEEDED;
1760			arr[13] = 0xff;		/* Failure prediction(false) */
1761		}
1762	} else {	/* nothing to report */
1763		if (dsense) {
1764			len = 8;
1765			memset(arr, 0, len);
1766			arr[0] = 0x72;
1767		} else {
1768			memset(arr, 0, len);
1769			arr[0] = 0x70;
1770			arr[7] = 0xa;
1771		}
1772	}
1773	return fill_from_dev_buffer(scp, arr, min_t(int, len, alloc_len));
1774}
1775
1776static int resp_start_stop(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
1777{
1778	unsigned char *cmd = scp->cmnd;
1779	int power_cond, want_stop, stopped_state;
1780	bool changing;
1781
1782	power_cond = (cmd[4] & 0xf0) >> 4;
1783	if (power_cond) {
1784		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, 7);
1785		return check_condition_result;
1786	}
1787	want_stop = !(cmd[4] & 1);
1788	stopped_state = atomic_read(&devip->stopped);
1789	if (stopped_state == 2) {
1790		ktime_t now_ts = ktime_get_boottime();
1791
1792		if (ktime_to_ns(now_ts) > ktime_to_ns(devip->create_ts)) {
1793			u64 diff_ns = ktime_to_ns(ktime_sub(now_ts, devip->create_ts));
1794
1795			if (diff_ns >= ((u64)sdeb_tur_ms_to_ready * 1000000)) {
1796				/* tur_ms_to_ready timer extinguished */
1797				atomic_set(&devip->stopped, 0);
1798				stopped_state = 0;
1799			}
1800		}
1801		if (stopped_state == 2) {
1802			if (want_stop) {
1803				stopped_state = 1;	/* dummy up success */
1804			} else {	/* Disallow tur_ms_to_ready delay to be overridden */
1805				mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, 0 /* START bit */);
1806				return check_condition_result;
1807			}
1808		}
1809	}
1810	changing = (stopped_state != want_stop);
1811	if (changing)
1812		atomic_xchg(&devip->stopped, want_stop);
1813	if (!changing || (cmd[1] & 0x1))  /* state unchanged or IMMED bit set in cdb */
1814		return SDEG_RES_IMMED_MASK;
1815	else
1816		return 0;
1817}
1818
1819static sector_t get_sdebug_capacity(void)
1820{
1821	static const unsigned int gibibyte = 1073741824;
1822
1823	if (sdebug_virtual_gb > 0)
1824		return (sector_t)sdebug_virtual_gb *
1825			(gibibyte / sdebug_sector_size);
1826	else
1827		return sdebug_store_sectors;
1828}
1829
1830#define SDEBUG_READCAP_ARR_SZ 8
1831static int resp_readcap(struct scsi_cmnd *scp,
1832			struct sdebug_dev_info *devip)
1833{
1834	unsigned char arr[SDEBUG_READCAP_ARR_SZ];
1835	unsigned int capac;
1836
1837	/* following just in case virtual_gb changed */
1838	sdebug_capacity = get_sdebug_capacity();
1839	memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
1840	if (sdebug_capacity < 0xffffffff) {
1841		capac = (unsigned int)sdebug_capacity - 1;
1842		put_unaligned_be32(capac, arr + 0);
1843	} else
1844		put_unaligned_be32(0xffffffff, arr + 0);
1845	put_unaligned_be16(sdebug_sector_size, arr + 6);
1846	return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
1847}
1848
1849#define SDEBUG_READCAP16_ARR_SZ 32
1850static int resp_readcap16(struct scsi_cmnd *scp,
1851			  struct sdebug_dev_info *devip)
1852{
1853	unsigned char *cmd = scp->cmnd;
1854	unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
1855	int alloc_len;
1856
1857	alloc_len = get_unaligned_be32(cmd + 10);
1858	/* following just in case virtual_gb changed */
1859	sdebug_capacity = get_sdebug_capacity();
1860	memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
1861	put_unaligned_be64((u64)(sdebug_capacity - 1), arr + 0);
1862	put_unaligned_be32(sdebug_sector_size, arr + 8);
1863	arr[13] = sdebug_physblk_exp & 0xf;
1864	arr[14] = (sdebug_lowest_aligned >> 8) & 0x3f;
1865
1866	if (scsi_debug_lbp()) {
1867		arr[14] |= 0x80; /* LBPME */
1868		/* from sbc4r07, this LBPRZ field is 1 bit, but the LBPRZ in
1869		 * the LB Provisioning VPD page is 3 bits. Note that lbprz=2
1870		 * in the wider field maps to 0 in this field.
1871		 */
1872		if (sdebug_lbprz & 1)	/* precisely what the draft requires */
1873			arr[14] |= 0x40;
1874	}
1875
 
 
 
 
 
 
 
1876	arr[15] = sdebug_lowest_aligned & 0xff;
1877
1878	if (have_dif_prot) {
1879		arr[12] = (sdebug_dif - 1) << 1; /* P_TYPE */
1880		arr[12] |= 1; /* PROT_EN */
1881	}
1882
1883	return fill_from_dev_buffer(scp, arr,
1884			    min_t(int, alloc_len, SDEBUG_READCAP16_ARR_SZ));
1885}
1886
1887#define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
1888
1889static int resp_report_tgtpgs(struct scsi_cmnd *scp,
1890			      struct sdebug_dev_info *devip)
1891{
1892	unsigned char *cmd = scp->cmnd;
1893	unsigned char *arr;
1894	int host_no = devip->sdbg_host->shost->host_no;
1895	int n, ret, alen, rlen;
1896	int port_group_a, port_group_b, port_a, port_b;
 
 
1897
1898	alen = get_unaligned_be32(cmd + 6);
1899	arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
1900	if (! arr)
1901		return DID_REQUEUE << 16;
1902	/*
1903	 * EVPD page 0x88 states we have two ports, one
1904	 * real and a fake port with no device connected.
1905	 * So we create two port groups with one port each
1906	 * and set the group with port B to unavailable.
1907	 */
1908	port_a = 0x1; /* relative port A */
1909	port_b = 0x2; /* relative port B */
1910	port_group_a = (((host_no + 1) & 0x7f) << 8) +
1911			(devip->channel & 0x7f);
1912	port_group_b = (((host_no + 1) & 0x7f) << 8) +
1913			(devip->channel & 0x7f) + 0x80;
1914
1915	/*
1916	 * The asymmetric access state is cycled according to the host_id.
1917	 */
1918	n = 4;
1919	if (sdebug_vpd_use_hostno == 0) {
1920		arr[n++] = host_no % 3; /* Asymm access state */
1921		arr[n++] = 0x0F; /* claim: all states are supported */
1922	} else {
1923		arr[n++] = 0x0; /* Active/Optimized path */
1924		arr[n++] = 0x01; /* only support active/optimized paths */
1925	}
1926	put_unaligned_be16(port_group_a, arr + n);
1927	n += 2;
1928	arr[n++] = 0;    /* Reserved */
1929	arr[n++] = 0;    /* Status code */
1930	arr[n++] = 0;    /* Vendor unique */
1931	arr[n++] = 0x1;  /* One port per group */
1932	arr[n++] = 0;    /* Reserved */
1933	arr[n++] = 0;    /* Reserved */
1934	put_unaligned_be16(port_a, arr + n);
1935	n += 2;
1936	arr[n++] = 3;    /* Port unavailable */
1937	arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
1938	put_unaligned_be16(port_group_b, arr + n);
1939	n += 2;
1940	arr[n++] = 0;    /* Reserved */
1941	arr[n++] = 0;    /* Status code */
1942	arr[n++] = 0;    /* Vendor unique */
1943	arr[n++] = 0x1;  /* One port per group */
1944	arr[n++] = 0;    /* Reserved */
1945	arr[n++] = 0;    /* Reserved */
1946	put_unaligned_be16(port_b, arr + n);
1947	n += 2;
1948
1949	rlen = n - 4;
1950	put_unaligned_be32(rlen, arr + 0);
1951
1952	/*
1953	 * Return the smallest value of either
1954	 * - The allocated length
1955	 * - The constructed command length
1956	 * - The maximum array size
1957	 */
1958	rlen = min_t(int, alen, n);
1959	ret = fill_from_dev_buffer(scp, arr,
1960			   min_t(int, rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
1961	kfree(arr);
1962	return ret;
1963}
1964
1965static int resp_rsup_opcodes(struct scsi_cmnd *scp,
1966			     struct sdebug_dev_info *devip)
1967{
1968	bool rctd;
1969	u8 reporting_opts, req_opcode, sdeb_i, supp;
1970	u16 req_sa, u;
1971	u32 alloc_len, a_len;
1972	int k, offset, len, errsts, count, bump, na;
1973	const struct opcode_info_t *oip;
1974	const struct opcode_info_t *r_oip;
1975	u8 *arr;
1976	u8 *cmd = scp->cmnd;
1977
1978	rctd = !!(cmd[2] & 0x80);
1979	reporting_opts = cmd[2] & 0x7;
1980	req_opcode = cmd[3];
1981	req_sa = get_unaligned_be16(cmd + 4);
1982	alloc_len = get_unaligned_be32(cmd + 6);
1983	if (alloc_len < 4 || alloc_len > 0xffff) {
1984		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
1985		return check_condition_result;
1986	}
1987	if (alloc_len > 8192)
1988		a_len = 8192;
1989	else
1990		a_len = alloc_len;
1991	arr = kzalloc((a_len < 256) ? 320 : a_len + 64, GFP_ATOMIC);
1992	if (NULL == arr) {
1993		mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
1994				INSUFF_RES_ASCQ);
1995		return check_condition_result;
1996	}
1997	switch (reporting_opts) {
1998	case 0:	/* all commands */
1999		/* count number of commands */
2000		for (count = 0, oip = opcode_info_arr;
2001		     oip->num_attached != 0xff; ++oip) {
2002			if (F_INV_OP & oip->flags)
2003				continue;
2004			count += (oip->num_attached + 1);
2005		}
2006		bump = rctd ? 20 : 8;
2007		put_unaligned_be32(count * bump, arr);
2008		for (offset = 4, oip = opcode_info_arr;
2009		     oip->num_attached != 0xff && offset < a_len; ++oip) {
2010			if (F_INV_OP & oip->flags)
2011				continue;
2012			na = oip->num_attached;
2013			arr[offset] = oip->opcode;
2014			put_unaligned_be16(oip->sa, arr + offset + 2);
2015			if (rctd)
2016				arr[offset + 5] |= 0x2;
2017			if (FF_SA & oip->flags)
2018				arr[offset + 5] |= 0x1;
2019			put_unaligned_be16(oip->len_mask[0], arr + offset + 6);
2020			if (rctd)
2021				put_unaligned_be16(0xa, arr + offset + 8);
2022			r_oip = oip;
2023			for (k = 0, oip = oip->arrp; k < na; ++k, ++oip) {
2024				if (F_INV_OP & oip->flags)
2025					continue;
2026				offset += bump;
2027				arr[offset] = oip->opcode;
2028				put_unaligned_be16(oip->sa, arr + offset + 2);
2029				if (rctd)
2030					arr[offset + 5] |= 0x2;
2031				if (FF_SA & oip->flags)
2032					arr[offset + 5] |= 0x1;
2033				put_unaligned_be16(oip->len_mask[0],
2034						   arr + offset + 6);
2035				if (rctd)
2036					put_unaligned_be16(0xa,
2037							   arr + offset + 8);
2038			}
2039			oip = r_oip;
2040			offset += bump;
2041		}
2042		break;
2043	case 1:	/* one command: opcode only */
2044	case 2:	/* one command: opcode plus service action */
2045	case 3:	/* one command: if sa==0 then opcode only else opcode+sa */
2046		sdeb_i = opcode_ind_arr[req_opcode];
2047		oip = &opcode_info_arr[sdeb_i];
2048		if (F_INV_OP & oip->flags) {
2049			supp = 1;
2050			offset = 4;
2051		} else {
2052			if (1 == reporting_opts) {
2053				if (FF_SA & oip->flags) {
2054					mk_sense_invalid_fld(scp, SDEB_IN_CDB,
2055							     2, 2);
2056					kfree(arr);
2057					return check_condition_result;
2058				}
2059				req_sa = 0;
2060			} else if (2 == reporting_opts &&
2061				   0 == (FF_SA & oip->flags)) {
2062				mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, -1);
2063				kfree(arr);	/* point at requested sa */
2064				return check_condition_result;
2065			}
2066			if (0 == (FF_SA & oip->flags) &&
2067			    req_opcode == oip->opcode)
2068				supp = 3;
2069			else if (0 == (FF_SA & oip->flags)) {
2070				na = oip->num_attached;
2071				for (k = 0, oip = oip->arrp; k < na;
2072				     ++k, ++oip) {
2073					if (req_opcode == oip->opcode)
2074						break;
2075				}
2076				supp = (k >= na) ? 1 : 3;
2077			} else if (req_sa != oip->sa) {
2078				na = oip->num_attached;
2079				for (k = 0, oip = oip->arrp; k < na;
2080				     ++k, ++oip) {
2081					if (req_sa == oip->sa)
2082						break;
2083				}
2084				supp = (k >= na) ? 1 : 3;
2085			} else
2086				supp = 3;
2087			if (3 == supp) {
2088				u = oip->len_mask[0];
2089				put_unaligned_be16(u, arr + 2);
2090				arr[4] = oip->opcode;
2091				for (k = 1; k < u; ++k)
2092					arr[4 + k] = (k < 16) ?
2093						 oip->len_mask[k] : 0xff;
2094				offset = 4 + u;
2095			} else
2096				offset = 4;
2097		}
2098		arr[1] = (rctd ? 0x80 : 0) | supp;
2099		if (rctd) {
2100			put_unaligned_be16(0xa, arr + offset);
2101			offset += 12;
2102		}
2103		break;
2104	default:
2105		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 2);
2106		kfree(arr);
2107		return check_condition_result;
2108	}
2109	offset = (offset < a_len) ? offset : a_len;
2110	len = (offset < alloc_len) ? offset : alloc_len;
2111	errsts = fill_from_dev_buffer(scp, arr, len);
2112	kfree(arr);
2113	return errsts;
2114}
2115
2116static int resp_rsup_tmfs(struct scsi_cmnd *scp,
2117			  struct sdebug_dev_info *devip)
2118{
2119	bool repd;
2120	u32 alloc_len, len;
2121	u8 arr[16];
2122	u8 *cmd = scp->cmnd;
2123
2124	memset(arr, 0, sizeof(arr));
2125	repd = !!(cmd[2] & 0x80);
2126	alloc_len = get_unaligned_be32(cmd + 6);
2127	if (alloc_len < 4) {
2128		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
2129		return check_condition_result;
2130	}
2131	arr[0] = 0xc8;		/* ATS | ATSS | LURS */
2132	arr[1] = 0x1;		/* ITNRS */
2133	if (repd) {
2134		arr[3] = 0xc;
2135		len = 16;
2136	} else
2137		len = 4;
2138
2139	len = (len < alloc_len) ? len : alloc_len;
2140	return fill_from_dev_buffer(scp, arr, len);
2141}
2142
2143/* <<Following mode page info copied from ST318451LW>> */
2144
2145static int resp_err_recov_pg(unsigned char *p, int pcontrol, int target)
2146{	/* Read-Write Error Recovery page for mode_sense */
2147	unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
2148					5, 0, 0xff, 0xff};
2149
2150	memcpy(p, err_recov_pg, sizeof(err_recov_pg));
2151	if (1 == pcontrol)
2152		memset(p + 2, 0, sizeof(err_recov_pg) - 2);
2153	return sizeof(err_recov_pg);
2154}
2155
2156static int resp_disconnect_pg(unsigned char *p, int pcontrol, int target)
2157{ 	/* Disconnect-Reconnect page for mode_sense */
2158	unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
2159					 0, 0, 0, 0, 0, 0, 0, 0};
2160
2161	memcpy(p, disconnect_pg, sizeof(disconnect_pg));
2162	if (1 == pcontrol)
2163		memset(p + 2, 0, sizeof(disconnect_pg) - 2);
2164	return sizeof(disconnect_pg);
2165}
2166
2167static int resp_format_pg(unsigned char *p, int pcontrol, int target)
2168{       /* Format device page for mode_sense */
2169	unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
2170				     0, 0, 0, 0, 0, 0, 0, 0,
2171				     0, 0, 0, 0, 0x40, 0, 0, 0};
2172
2173	memcpy(p, format_pg, sizeof(format_pg));
2174	put_unaligned_be16(sdebug_sectors_per, p + 10);
2175	put_unaligned_be16(sdebug_sector_size, p + 12);
2176	if (sdebug_removable)
2177		p[20] |= 0x20; /* should agree with INQUIRY */
2178	if (1 == pcontrol)
2179		memset(p + 2, 0, sizeof(format_pg) - 2);
2180	return sizeof(format_pg);
2181}
2182
2183static unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
2184				     0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0,
2185				     0, 0, 0, 0};
2186
2187static int resp_caching_pg(unsigned char *p, int pcontrol, int target)
2188{ 	/* Caching page for mode_sense */
2189	unsigned char ch_caching_pg[] = {/* 0x8, 18, */ 0x4, 0, 0, 0, 0, 0,
2190		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
2191	unsigned char d_caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
2192		0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0,     0, 0, 0, 0};
2193
2194	if (SDEBUG_OPT_N_WCE & sdebug_opts)
2195		caching_pg[2] &= ~0x4;	/* set WCE=0 (default WCE=1) */
2196	memcpy(p, caching_pg, sizeof(caching_pg));
2197	if (1 == pcontrol)
2198		memcpy(p + 2, ch_caching_pg, sizeof(ch_caching_pg));
2199	else if (2 == pcontrol)
2200		memcpy(p, d_caching_pg, sizeof(d_caching_pg));
2201	return sizeof(caching_pg);
2202}
2203
2204static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
2205				    0, 0, 0x2, 0x4b};
2206
2207static int resp_ctrl_m_pg(unsigned char *p, int pcontrol, int target)
2208{ 	/* Control mode page for mode_sense */
2209	unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
2210					0, 0, 0, 0};
2211	unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
2212				     0, 0, 0x2, 0x4b};
2213
2214	if (sdebug_dsense)
2215		ctrl_m_pg[2] |= 0x4;
2216	else
2217		ctrl_m_pg[2] &= ~0x4;
2218
2219	if (sdebug_ato)
2220		ctrl_m_pg[5] |= 0x80; /* ATO=1 */
2221
2222	memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
2223	if (1 == pcontrol)
2224		memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
2225	else if (2 == pcontrol)
2226		memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
2227	return sizeof(ctrl_m_pg);
2228}
2229
2230
2231static int resp_iec_m_pg(unsigned char *p, int pcontrol, int target)
2232{	/* Informational Exceptions control mode page for mode_sense */
2233	unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
2234				       0, 0, 0x0, 0x0};
2235	unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
2236				      0, 0, 0x0, 0x0};
2237
2238	memcpy(p, iec_m_pg, sizeof(iec_m_pg));
2239	if (1 == pcontrol)
2240		memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
2241	else if (2 == pcontrol)
2242		memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
2243	return sizeof(iec_m_pg);
2244}
2245
2246static int resp_sas_sf_m_pg(unsigned char *p, int pcontrol, int target)
2247{	/* SAS SSP mode page - short format for mode_sense */
2248	unsigned char sas_sf_m_pg[] = {0x19, 0x6,
2249		0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
2250
2251	memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
2252	if (1 == pcontrol)
2253		memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
2254	return sizeof(sas_sf_m_pg);
2255}
2256
2257
2258static int resp_sas_pcd_m_spg(unsigned char *p, int pcontrol, int target,
2259			      int target_dev_id)
2260{	/* SAS phy control and discover mode page for mode_sense */
2261	unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
2262		    0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
2263		    0, 0, 0, 0, 0, 0, 0, 0,	/* insert SAS addr */
2264		    0, 0, 0, 0, 0, 0, 0, 0,	/* insert SAS addr */
2265		    0x2, 0, 0, 0, 0, 0, 0, 0,
2266		    0x88, 0x99, 0, 0, 0, 0, 0, 0,
2267		    0, 0, 0, 0, 0, 0, 0, 0,
2268		    0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
2269		    0, 0, 0, 0, 0, 0, 0, 0,	/* insert SAS addr */
2270		    0, 0, 0, 0, 0, 0, 0, 0,	/* insert SAS addr */
2271		    0x3, 0, 0, 0, 0, 0, 0, 0,
2272		    0x88, 0x99, 0, 0, 0, 0, 0, 0,
2273		    0, 0, 0, 0, 0, 0, 0, 0,
2274		};
2275	int port_a, port_b;
2276
2277	put_unaligned_be64(naa3_comp_a, sas_pcd_m_pg + 16);
2278	put_unaligned_be64(naa3_comp_c + 1, sas_pcd_m_pg + 24);
2279	put_unaligned_be64(naa3_comp_a, sas_pcd_m_pg + 64);
2280	put_unaligned_be64(naa3_comp_c + 1, sas_pcd_m_pg + 72);
2281	port_a = target_dev_id + 1;
2282	port_b = port_a + 1;
2283	memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
2284	put_unaligned_be32(port_a, p + 20);
2285	put_unaligned_be32(port_b, p + 48 + 20);
2286	if (1 == pcontrol)
2287		memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
2288	return sizeof(sas_pcd_m_pg);
2289}
2290
2291static int resp_sas_sha_m_spg(unsigned char *p, int pcontrol)
2292{	/* SAS SSP shared protocol specific port mode subpage */
2293	unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
2294		    0, 0, 0, 0, 0, 0, 0, 0,
2295		};
2296
2297	memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
2298	if (1 == pcontrol)
2299		memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
2300	return sizeof(sas_sha_m_pg);
2301}
2302
2303#define SDEBUG_MAX_MSENSE_SZ 256
2304
2305static int resp_mode_sense(struct scsi_cmnd *scp,
2306			   struct sdebug_dev_info *devip)
2307{
2308	int pcontrol, pcode, subpcode, bd_len;
2309	unsigned char dev_spec;
2310	int alloc_len, offset, len, target_dev_id;
 
2311	int target = scp->device->id;
2312	unsigned char *ap;
2313	unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
2314	unsigned char *cmd = scp->cmnd;
2315	bool dbd, llbaa, msense_6, is_disk, is_zbc, bad_pcode;
2316
2317	dbd = !!(cmd[1] & 0x8);		/* disable block descriptors */
2318	pcontrol = (cmd[2] & 0xc0) >> 6;
2319	pcode = cmd[2] & 0x3f;
2320	subpcode = cmd[3];
2321	msense_6 = (MODE_SENSE == cmd[0]);
2322	llbaa = msense_6 ? false : !!(cmd[1] & 0x10);
2323	is_disk = (sdebug_ptype == TYPE_DISK);
2324	is_zbc = (devip->zmodel != BLK_ZONED_NONE);
2325	if ((is_disk || is_zbc) && !dbd)
2326		bd_len = llbaa ? 16 : 8;
2327	else
2328		bd_len = 0;
2329	alloc_len = msense_6 ? cmd[4] : get_unaligned_be16(cmd + 7);
2330	memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
2331	if (0x3 == pcontrol) {  /* Saving values not supported */
2332		mk_sense_buffer(scp, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP, 0);
2333		return check_condition_result;
2334	}
2335	target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
2336			(devip->target * 1000) - 3;
2337	/* for disks+zbc set DPOFUA bit and clear write protect (WP) bit */
2338	if (is_disk || is_zbc) {
2339		dev_spec = 0x10;	/* =0x90 if WP=1 implies read-only */
2340		if (sdebug_wp)
2341			dev_spec |= 0x80;
2342	} else
2343		dev_spec = 0x0;
2344	if (msense_6) {
2345		arr[2] = dev_spec;
2346		arr[3] = bd_len;
2347		offset = 4;
2348	} else {
2349		arr[3] = dev_spec;
2350		if (16 == bd_len)
2351			arr[4] = 0x1;	/* set LONGLBA bit */
2352		arr[7] = bd_len;	/* assume 255 or less */
2353		offset = 8;
2354	}
2355	ap = arr + offset;
2356	if ((bd_len > 0) && (!sdebug_capacity))
2357		sdebug_capacity = get_sdebug_capacity();
2358
2359	if (8 == bd_len) {
2360		if (sdebug_capacity > 0xfffffffe)
2361			put_unaligned_be32(0xffffffff, ap + 0);
2362		else
2363			put_unaligned_be32(sdebug_capacity, ap + 0);
2364		put_unaligned_be16(sdebug_sector_size, ap + 6);
2365		offset += bd_len;
2366		ap = arr + offset;
2367	} else if (16 == bd_len) {
2368		put_unaligned_be64((u64)sdebug_capacity, ap + 0);
2369		put_unaligned_be32(sdebug_sector_size, ap + 12);
2370		offset += bd_len;
2371		ap = arr + offset;
2372	}
2373
2374	if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
2375		/* TODO: Control Extension page */
2376		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
2377		return check_condition_result;
2378	}
2379	bad_pcode = false;
2380
2381	switch (pcode) {
2382	case 0x1:	/* Read-Write error recovery page, direct access */
2383		len = resp_err_recov_pg(ap, pcontrol, target);
2384		offset += len;
2385		break;
2386	case 0x2:	/* Disconnect-Reconnect page, all devices */
2387		len = resp_disconnect_pg(ap, pcontrol, target);
2388		offset += len;
2389		break;
2390	case 0x3:       /* Format device page, direct access */
2391		if (is_disk) {
2392			len = resp_format_pg(ap, pcontrol, target);
2393			offset += len;
2394		} else
2395			bad_pcode = true;
2396		break;
2397	case 0x8:	/* Caching page, direct access */
2398		if (is_disk || is_zbc) {
2399			len = resp_caching_pg(ap, pcontrol, target);
2400			offset += len;
2401		} else
2402			bad_pcode = true;
2403		break;
2404	case 0xa:	/* Control Mode page, all devices */
2405		len = resp_ctrl_m_pg(ap, pcontrol, target);
2406		offset += len;
2407		break;
2408	case 0x19:	/* if spc==1 then sas phy, control+discover */
2409		if ((subpcode > 0x2) && (subpcode < 0xff)) {
2410			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
2411			return check_condition_result;
2412		}
2413		len = 0;
2414		if ((0x0 == subpcode) || (0xff == subpcode))
2415			len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
2416		if ((0x1 == subpcode) || (0xff == subpcode))
2417			len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
2418						  target_dev_id);
2419		if ((0x2 == subpcode) || (0xff == subpcode))
2420			len += resp_sas_sha_m_spg(ap + len, pcontrol);
2421		offset += len;
2422		break;
2423	case 0x1c:	/* Informational Exceptions Mode page, all devices */
2424		len = resp_iec_m_pg(ap, pcontrol, target);
2425		offset += len;
2426		break;
2427	case 0x3f:	/* Read all Mode pages */
2428		if ((0 == subpcode) || (0xff == subpcode)) {
2429			len = resp_err_recov_pg(ap, pcontrol, target);
2430			len += resp_disconnect_pg(ap + len, pcontrol, target);
2431			if (is_disk) {
2432				len += resp_format_pg(ap + len, pcontrol,
2433						      target);
2434				len += resp_caching_pg(ap + len, pcontrol,
2435						       target);
2436			} else if (is_zbc) {
2437				len += resp_caching_pg(ap + len, pcontrol,
2438						       target);
2439			}
2440			len += resp_ctrl_m_pg(ap + len, pcontrol, target);
2441			len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
2442			if (0xff == subpcode) {
2443				len += resp_sas_pcd_m_spg(ap + len, pcontrol,
2444						  target, target_dev_id);
2445				len += resp_sas_sha_m_spg(ap + len, pcontrol);
2446			}
2447			len += resp_iec_m_pg(ap + len, pcontrol, target);
2448			offset += len;
2449		} else {
2450			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
2451			return check_condition_result;
2452		}
2453		break;
2454	default:
2455		bad_pcode = true;
2456		break;
2457	}
2458	if (bad_pcode) {
2459		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
2460		return check_condition_result;
2461	}
2462	if (msense_6)
2463		arr[0] = offset - 1;
2464	else
2465		put_unaligned_be16((offset - 2), arr + 0);
2466	return fill_from_dev_buffer(scp, arr, min_t(int, alloc_len, offset));
2467}
2468
2469#define SDEBUG_MAX_MSELECT_SZ 512
2470
2471static int resp_mode_select(struct scsi_cmnd *scp,
2472			    struct sdebug_dev_info *devip)
2473{
2474	int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
2475	int param_len, res, mpage;
2476	unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
2477	unsigned char *cmd = scp->cmnd;
2478	int mselect6 = (MODE_SELECT == cmd[0]);
2479
2480	memset(arr, 0, sizeof(arr));
2481	pf = cmd[1] & 0x10;
2482	sp = cmd[1] & 0x1;
2483	param_len = mselect6 ? cmd[4] : get_unaligned_be16(cmd + 7);
2484	if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
2485		mk_sense_invalid_fld(scp, SDEB_IN_CDB, mselect6 ? 4 : 7, -1);
2486		return check_condition_result;
2487	}
2488	res = fetch_to_dev_buffer(scp, arr, param_len);
2489	if (-1 == res)
2490		return DID_ERROR << 16;
2491	else if (sdebug_verbose && (res < param_len))
2492		sdev_printk(KERN_INFO, scp->device,
2493			    "%s: cdb indicated=%d, IO sent=%d bytes\n",
2494			    __func__, param_len, res);
2495	md_len = mselect6 ? (arr[0] + 1) : (get_unaligned_be16(arr + 0) + 2);
2496	bd_len = mselect6 ? arr[3] : get_unaligned_be16(arr + 6);
2497	if (md_len > 2) {
 
2498		mk_sense_invalid_fld(scp, SDEB_IN_DATA, 0, -1);
2499		return check_condition_result;
2500	}
2501	off = bd_len + (mselect6 ? 4 : 8);
2502	mpage = arr[off] & 0x3f;
2503	ps = !!(arr[off] & 0x80);
2504	if (ps) {
2505		mk_sense_invalid_fld(scp, SDEB_IN_DATA, off, 7);
2506		return check_condition_result;
2507	}
2508	spf = !!(arr[off] & 0x40);
2509	pg_len = spf ? (get_unaligned_be16(arr + off + 2) + 4) :
2510		       (arr[off + 1] + 2);
2511	if ((pg_len + off) > param_len) {
2512		mk_sense_buffer(scp, ILLEGAL_REQUEST,
2513				PARAMETER_LIST_LENGTH_ERR, 0);
2514		return check_condition_result;
2515	}
2516	switch (mpage) {
2517	case 0x8:      /* Caching Mode page */
2518		if (caching_pg[1] == arr[off + 1]) {
2519			memcpy(caching_pg + 2, arr + off + 2,
2520			       sizeof(caching_pg) - 2);
2521			goto set_mode_changed_ua;
2522		}
2523		break;
2524	case 0xa:      /* Control Mode page */
2525		if (ctrl_m_pg[1] == arr[off + 1]) {
2526			memcpy(ctrl_m_pg + 2, arr + off + 2,
2527			       sizeof(ctrl_m_pg) - 2);
2528			if (ctrl_m_pg[4] & 0x8)
2529				sdebug_wp = true;
2530			else
2531				sdebug_wp = false;
2532			sdebug_dsense = !!(ctrl_m_pg[2] & 0x4);
2533			goto set_mode_changed_ua;
2534		}
2535		break;
2536	case 0x1c:      /* Informational Exceptions Mode page */
2537		if (iec_m_pg[1] == arr[off + 1]) {
2538			memcpy(iec_m_pg + 2, arr + off + 2,
2539			       sizeof(iec_m_pg) - 2);
2540			goto set_mode_changed_ua;
2541		}
2542		break;
2543	default:
2544		break;
2545	}
2546	mk_sense_invalid_fld(scp, SDEB_IN_DATA, off, 5);
2547	return check_condition_result;
2548set_mode_changed_ua:
2549	set_bit(SDEBUG_UA_MODE_CHANGED, devip->uas_bm);
2550	return 0;
2551}
2552
2553static int resp_temp_l_pg(unsigned char *arr)
2554{
2555	unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
2556				     0x0, 0x1, 0x3, 0x2, 0x0, 65,
2557		};
2558
2559	memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
2560	return sizeof(temp_l_pg);
2561}
2562
2563static int resp_ie_l_pg(unsigned char *arr)
2564{
2565	unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
2566		};
2567
2568	memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
2569	if (iec_m_pg[2] & 0x4) {	/* TEST bit set */
2570		arr[4] = THRESHOLD_EXCEEDED;
2571		arr[5] = 0xff;
2572	}
2573	return sizeof(ie_l_pg);
2574}
2575
 
 
 
 
 
 
 
 
 
 
 
 
2576#define SDEBUG_MAX_LSENSE_SZ 512
2577
2578static int resp_log_sense(struct scsi_cmnd *scp,
2579			  struct sdebug_dev_info *devip)
2580{
2581	int ppc, sp, pcode, subpcode, alloc_len, len, n;
 
2582	unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
2583	unsigned char *cmd = scp->cmnd;
2584
2585	memset(arr, 0, sizeof(arr));
2586	ppc = cmd[1] & 0x2;
2587	sp = cmd[1] & 0x1;
2588	if (ppc || sp) {
2589		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, ppc ? 1 : 0);
2590		return check_condition_result;
2591	}
2592	pcode = cmd[2] & 0x3f;
2593	subpcode = cmd[3] & 0xff;
2594	alloc_len = get_unaligned_be16(cmd + 7);
2595	arr[0] = pcode;
2596	if (0 == subpcode) {
2597		switch (pcode) {
2598		case 0x0:	/* Supported log pages log page */
2599			n = 4;
2600			arr[n++] = 0x0;		/* this page */
2601			arr[n++] = 0xd;		/* Temperature */
2602			arr[n++] = 0x2f;	/* Informational exceptions */
2603			arr[3] = n - 4;
2604			break;
2605		case 0xd:	/* Temperature log page */
2606			arr[3] = resp_temp_l_pg(arr + 4);
2607			break;
2608		case 0x2f:	/* Informational exceptions log page */
2609			arr[3] = resp_ie_l_pg(arr + 4);
2610			break;
2611		default:
2612			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
2613			return check_condition_result;
2614		}
2615	} else if (0xff == subpcode) {
2616		arr[0] |= 0x40;
2617		arr[1] = subpcode;
2618		switch (pcode) {
2619		case 0x0:	/* Supported log pages and subpages log page */
2620			n = 4;
2621			arr[n++] = 0x0;
2622			arr[n++] = 0x0;		/* 0,0 page */
2623			arr[n++] = 0x0;
2624			arr[n++] = 0xff;	/* this page */
2625			arr[n++] = 0xd;
2626			arr[n++] = 0x0;		/* Temperature */
 
 
 
 
2627			arr[n++] = 0x2f;
2628			arr[n++] = 0x0;	/* Informational exceptions */
 
 
2629			arr[3] = n - 4;
2630			break;
2631		case 0xd:	/* Temperature subpages */
2632			n = 4;
2633			arr[n++] = 0xd;
2634			arr[n++] = 0x0;		/* Temperature */
 
 
 
 
2635			arr[3] = n - 4;
2636			break;
2637		case 0x2f:	/* Informational exceptions subpages */
2638			n = 4;
2639			arr[n++] = 0x2f;
2640			arr[n++] = 0x0;		/* Informational exceptions */
 
 
2641			arr[3] = n - 4;
2642			break;
2643		default:
2644			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
2645			return check_condition_result;
2646		}
 
 
 
 
 
 
 
 
 
2647	} else {
2648		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
2649		return check_condition_result;
2650	}
2651	len = min_t(int, get_unaligned_be16(arr + 2) + 4, alloc_len);
2652	return fill_from_dev_buffer(scp, arr,
2653		    min_t(int, len, SDEBUG_MAX_INQ_ARR_SZ));
2654}
2655
2656static inline bool sdebug_dev_is_zoned(struct sdebug_dev_info *devip)
2657{
2658	return devip->nr_zones != 0;
2659}
2660
2661static struct sdeb_zone_state *zbc_zone(struct sdebug_dev_info *devip,
2662					unsigned long long lba)
2663{
2664	return &devip->zstate[lba >> devip->zsize_shift];
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2665}
2666
2667static inline bool zbc_zone_is_conv(struct sdeb_zone_state *zsp)
2668{
2669	return zsp->z_type == ZBC_ZONE_TYPE_CNV;
 
 
 
 
 
 
 
 
 
 
2670}
2671
2672static void zbc_close_zone(struct sdebug_dev_info *devip,
2673			   struct sdeb_zone_state *zsp)
2674{
2675	enum sdebug_z_cond zc;
2676
2677	if (zbc_zone_is_conv(zsp))
2678		return;
2679
2680	zc = zsp->z_cond;
2681	if (!(zc == ZC2_IMPLICIT_OPEN || zc == ZC3_EXPLICIT_OPEN))
2682		return;
2683
2684	if (zc == ZC2_IMPLICIT_OPEN)
2685		devip->nr_imp_open--;
2686	else
2687		devip->nr_exp_open--;
2688
2689	if (zsp->z_wp == zsp->z_start) {
2690		zsp->z_cond = ZC1_EMPTY;
2691	} else {
2692		zsp->z_cond = ZC4_CLOSED;
2693		devip->nr_closed++;
2694	}
2695}
2696
2697static void zbc_close_imp_open_zone(struct sdebug_dev_info *devip)
2698{
2699	struct sdeb_zone_state *zsp = &devip->zstate[0];
2700	unsigned int i;
2701
2702	for (i = 0; i < devip->nr_zones; i++, zsp++) {
2703		if (zsp->z_cond == ZC2_IMPLICIT_OPEN) {
2704			zbc_close_zone(devip, zsp);
2705			return;
2706		}
2707	}
2708}
2709
2710static void zbc_open_zone(struct sdebug_dev_info *devip,
2711			  struct sdeb_zone_state *zsp, bool explicit)
2712{
2713	enum sdebug_z_cond zc;
2714
2715	if (zbc_zone_is_conv(zsp))
2716		return;
2717
2718	zc = zsp->z_cond;
2719	if ((explicit && zc == ZC3_EXPLICIT_OPEN) ||
2720	    (!explicit && zc == ZC2_IMPLICIT_OPEN))
2721		return;
2722
2723	/* Close an implicit open zone if necessary */
2724	if (explicit && zsp->z_cond == ZC2_IMPLICIT_OPEN)
2725		zbc_close_zone(devip, zsp);
2726	else if (devip->max_open &&
2727		 devip->nr_imp_open + devip->nr_exp_open >= devip->max_open)
2728		zbc_close_imp_open_zone(devip);
2729
2730	if (zsp->z_cond == ZC4_CLOSED)
2731		devip->nr_closed--;
2732	if (explicit) {
2733		zsp->z_cond = ZC3_EXPLICIT_OPEN;
2734		devip->nr_exp_open++;
2735	} else {
2736		zsp->z_cond = ZC2_IMPLICIT_OPEN;
2737		devip->nr_imp_open++;
2738	}
2739}
2740
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2741static void zbc_inc_wp(struct sdebug_dev_info *devip,
2742		       unsigned long long lba, unsigned int num)
2743{
2744	struct sdeb_zone_state *zsp = zbc_zone(devip, lba);
2745	unsigned long long n, end, zend = zsp->z_start + zsp->z_size;
2746
2747	if (zbc_zone_is_conv(zsp))
2748		return;
2749
2750	if (zsp->z_type == ZBC_ZONE_TYPE_SWR) {
2751		zsp->z_wp += num;
2752		if (zsp->z_wp >= zend)
2753			zsp->z_cond = ZC5_FULL;
2754		return;
2755	}
2756
2757	while (num) {
2758		if (lba != zsp->z_wp)
2759			zsp->z_non_seq_resource = true;
2760
2761		end = lba + num;
2762		if (end >= zend) {
2763			n = zend - lba;
2764			zsp->z_wp = zend;
2765		} else if (end > zsp->z_wp) {
2766			n = num;
2767			zsp->z_wp = end;
2768		} else {
2769			n = num;
2770		}
2771		if (zsp->z_wp >= zend)
2772			zsp->z_cond = ZC5_FULL;
2773
2774		num -= n;
2775		lba += n;
2776		if (num) {
2777			zsp++;
2778			zend = zsp->z_start + zsp->z_size;
2779		}
2780	}
2781}
2782
2783static int check_zbc_access_params(struct scsi_cmnd *scp,
2784			unsigned long long lba, unsigned int num, bool write)
2785{
2786	struct scsi_device *sdp = scp->device;
2787	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
2788	struct sdeb_zone_state *zsp = zbc_zone(devip, lba);
2789	struct sdeb_zone_state *zsp_end = zbc_zone(devip, lba + num - 1);
2790
2791	if (!write) {
2792		if (devip->zmodel == BLK_ZONED_HA)
2793			return 0;
2794		/* For host-managed, reads cannot cross zone types boundaries */
2795		if (zsp_end != zsp &&
2796		    zbc_zone_is_conv(zsp) &&
2797		    !zbc_zone_is_conv(zsp_end)) {
2798			mk_sense_buffer(scp, ILLEGAL_REQUEST,
2799					LBA_OUT_OF_RANGE,
2800					READ_INVDATA_ASCQ);
2801			return check_condition_result;
2802		}
2803		return 0;
2804	}
2805
 
 
 
 
 
 
 
2806	/* No restrictions for writes within conventional zones */
2807	if (zbc_zone_is_conv(zsp)) {
2808		if (!zbc_zone_is_conv(zsp_end)) {
2809			mk_sense_buffer(scp, ILLEGAL_REQUEST,
2810					LBA_OUT_OF_RANGE,
2811					WRITE_BOUNDARY_ASCQ);
2812			return check_condition_result;
2813		}
2814		return 0;
2815	}
2816
2817	if (zsp->z_type == ZBC_ZONE_TYPE_SWR) {
2818		/* Writes cannot cross sequential zone boundaries */
2819		if (zsp_end != zsp) {
2820			mk_sense_buffer(scp, ILLEGAL_REQUEST,
2821					LBA_OUT_OF_RANGE,
2822					WRITE_BOUNDARY_ASCQ);
2823			return check_condition_result;
2824		}
2825		/* Cannot write full zones */
2826		if (zsp->z_cond == ZC5_FULL) {
2827			mk_sense_buffer(scp, ILLEGAL_REQUEST,
2828					INVALID_FIELD_IN_CDB, 0);
2829			return check_condition_result;
2830		}
2831		/* Writes must be aligned to the zone WP */
2832		if (lba != zsp->z_wp) {
2833			mk_sense_buffer(scp, ILLEGAL_REQUEST,
2834					LBA_OUT_OF_RANGE,
2835					UNALIGNED_WRITE_ASCQ);
2836			return check_condition_result;
2837		}
2838	}
2839
2840	/* Handle implicit open of closed and empty zones */
2841	if (zsp->z_cond == ZC1_EMPTY || zsp->z_cond == ZC4_CLOSED) {
2842		if (devip->max_open &&
2843		    devip->nr_exp_open >= devip->max_open) {
2844			mk_sense_buffer(scp, DATA_PROTECT,
2845					INSUFF_RES_ASC,
2846					INSUFF_ZONE_ASCQ);
2847			return check_condition_result;
2848		}
2849		zbc_open_zone(devip, zsp, false);
2850	}
2851
2852	return 0;
2853}
2854
2855static inline int check_device_access_params
2856			(struct scsi_cmnd *scp, unsigned long long lba,
2857			 unsigned int num, bool write)
2858{
2859	struct scsi_device *sdp = scp->device;
2860	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
2861
2862	if (lba + num > sdebug_capacity) {
2863		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
2864		return check_condition_result;
2865	}
2866	/* transfer length excessive (tie in to block limits VPD page) */
2867	if (num > sdebug_store_sectors) {
2868		/* needs work to find which cdb byte 'num' comes from */
2869		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
2870		return check_condition_result;
2871	}
2872	if (write && unlikely(sdebug_wp)) {
2873		mk_sense_buffer(scp, DATA_PROTECT, WRITE_PROTECTED, 0x2);
2874		return check_condition_result;
2875	}
2876	if (sdebug_dev_is_zoned(devip))
2877		return check_zbc_access_params(scp, lba, num, write);
2878
2879	return 0;
2880}
2881
2882/*
2883 * Note: if BUG_ON() fires it usually indicates a problem with the parser
2884 * tables. Perhaps a missing F_FAKE_RW or FF_MEDIA_IO flag. Response functions
2885 * that access any of the "stores" in struct sdeb_store_info should call this
2886 * function with bug_if_fake_rw set to true.
2887 */
2888static inline struct sdeb_store_info *devip2sip(struct sdebug_dev_info *devip,
2889						bool bug_if_fake_rw)
2890{
2891	if (sdebug_fake_rw) {
2892		BUG_ON(bug_if_fake_rw);	/* See note above */
2893		return NULL;
2894	}
2895	return xa_load(per_store_ap, devip->sdbg_host->si_idx);
2896}
2897
2898/* Returns number of bytes copied or -1 if error. */
2899static int do_device_access(struct sdeb_store_info *sip, struct scsi_cmnd *scp,
2900			    u32 sg_skip, u64 lba, u32 num, bool do_write)
2901{
2902	int ret;
2903	u64 block, rest = 0;
2904	enum dma_data_direction dir;
2905	struct scsi_data_buffer *sdb = &scp->sdb;
2906	u8 *fsp;
2907
2908	if (do_write) {
2909		dir = DMA_TO_DEVICE;
2910		write_since_sync = true;
2911	} else {
2912		dir = DMA_FROM_DEVICE;
2913	}
2914
2915	if (!sdb->length || !sip)
2916		return 0;
2917	if (scp->sc_data_direction != dir)
2918		return -1;
2919	fsp = sip->storep;
2920
2921	block = do_div(lba, sdebug_store_sectors);
2922	if (block + num > sdebug_store_sectors)
2923		rest = block + num - sdebug_store_sectors;
2924
2925	ret = sg_copy_buffer(sdb->table.sgl, sdb->table.nents,
2926		   fsp + (block * sdebug_sector_size),
2927		   (num - rest) * sdebug_sector_size, sg_skip, do_write);
2928	if (ret != (num - rest) * sdebug_sector_size)
2929		return ret;
2930
2931	if (rest) {
2932		ret += sg_copy_buffer(sdb->table.sgl, sdb->table.nents,
2933			    fsp, rest * sdebug_sector_size,
2934			    sg_skip + ((num - rest) * sdebug_sector_size),
2935			    do_write);
2936	}
2937
2938	return ret;
2939}
2940
2941/* Returns number of bytes copied or -1 if error. */
2942static int do_dout_fetch(struct scsi_cmnd *scp, u32 num, u8 *doutp)
2943{
2944	struct scsi_data_buffer *sdb = &scp->sdb;
2945
2946	if (!sdb->length)
2947		return 0;
2948	if (scp->sc_data_direction != DMA_TO_DEVICE)
2949		return -1;
2950	return sg_copy_buffer(sdb->table.sgl, sdb->table.nents, doutp,
2951			      num * sdebug_sector_size, 0, true);
2952}
2953
2954/* If sip->storep+lba compares equal to arr(num), then copy top half of
2955 * arr into sip->storep+lba and return true. If comparison fails then
2956 * return false. */
2957static bool comp_write_worker(struct sdeb_store_info *sip, u64 lba, u32 num,
2958			      const u8 *arr, bool compare_only)
2959{
2960	bool res;
2961	u64 block, rest = 0;
2962	u32 store_blks = sdebug_store_sectors;
2963	u32 lb_size = sdebug_sector_size;
2964	u8 *fsp = sip->storep;
2965
2966	block = do_div(lba, store_blks);
2967	if (block + num > store_blks)
2968		rest = block + num - store_blks;
2969
2970	res = !memcmp(fsp + (block * lb_size), arr, (num - rest) * lb_size);
2971	if (!res)
2972		return res;
2973	if (rest)
2974		res = memcmp(fsp, arr + ((num - rest) * lb_size),
2975			     rest * lb_size);
2976	if (!res)
2977		return res;
2978	if (compare_only)
2979		return true;
2980	arr += num * lb_size;
2981	memcpy(fsp + (block * lb_size), arr, (num - rest) * lb_size);
2982	if (rest)
2983		memcpy(fsp, arr + ((num - rest) * lb_size), rest * lb_size);
2984	return res;
2985}
2986
2987static __be16 dif_compute_csum(const void *buf, int len)
2988{
2989	__be16 csum;
2990
2991	if (sdebug_guard)
2992		csum = (__force __be16)ip_compute_csum(buf, len);
2993	else
2994		csum = cpu_to_be16(crc_t10dif(buf, len));
2995
2996	return csum;
2997}
2998
2999static int dif_verify(struct t10_pi_tuple *sdt, const void *data,
3000		      sector_t sector, u32 ei_lba)
3001{
3002	__be16 csum = dif_compute_csum(data, sdebug_sector_size);
3003
3004	if (sdt->guard_tag != csum) {
3005		pr_err("GUARD check failed on sector %lu rcvd 0x%04x, data 0x%04x\n",
3006			(unsigned long)sector,
3007			be16_to_cpu(sdt->guard_tag),
3008			be16_to_cpu(csum));
3009		return 0x01;
3010	}
3011	if (sdebug_dif == T10_PI_TYPE1_PROTECTION &&
3012	    be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
3013		pr_err("REF check failed on sector %lu\n",
3014			(unsigned long)sector);
3015		return 0x03;
3016	}
3017	if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
3018	    be32_to_cpu(sdt->ref_tag) != ei_lba) {
3019		pr_err("REF check failed on sector %lu\n",
3020			(unsigned long)sector);
3021		return 0x03;
3022	}
3023	return 0;
3024}
3025
3026static void dif_copy_prot(struct scsi_cmnd *scp, sector_t sector,
3027			  unsigned int sectors, bool read)
3028{
3029	size_t resid;
3030	void *paddr;
3031	struct sdeb_store_info *sip = devip2sip((struct sdebug_dev_info *)
3032						scp->device->hostdata, true);
3033	struct t10_pi_tuple *dif_storep = sip->dif_storep;
3034	const void *dif_store_end = dif_storep + sdebug_store_sectors;
3035	struct sg_mapping_iter miter;
3036
3037	/* Bytes of protection data to copy into sgl */
3038	resid = sectors * sizeof(*dif_storep);
3039
3040	sg_miter_start(&miter, scsi_prot_sglist(scp),
3041		       scsi_prot_sg_count(scp), SG_MITER_ATOMIC |
3042		       (read ? SG_MITER_TO_SG : SG_MITER_FROM_SG));
3043
3044	while (sg_miter_next(&miter) && resid > 0) {
3045		size_t len = min_t(size_t, miter.length, resid);
3046		void *start = dif_store(sip, sector);
3047		size_t rest = 0;
3048
3049		if (dif_store_end < start + len)
3050			rest = start + len - dif_store_end;
3051
3052		paddr = miter.addr;
3053
3054		if (read)
3055			memcpy(paddr, start, len - rest);
3056		else
3057			memcpy(start, paddr, len - rest);
3058
3059		if (rest) {
3060			if (read)
3061				memcpy(paddr + len - rest, dif_storep, rest);
3062			else
3063				memcpy(dif_storep, paddr + len - rest, rest);
3064		}
3065
3066		sector += len / sizeof(*dif_storep);
3067		resid -= len;
3068	}
3069	sg_miter_stop(&miter);
3070}
3071
3072static int prot_verify_read(struct scsi_cmnd *scp, sector_t start_sec,
3073			    unsigned int sectors, u32 ei_lba)
3074{
 
3075	unsigned int i;
3076	sector_t sector;
3077	struct sdeb_store_info *sip = devip2sip((struct sdebug_dev_info *)
3078						scp->device->hostdata, true);
3079	struct t10_pi_tuple *sdt;
3080
3081	for (i = 0; i < sectors; i++, ei_lba++) {
3082		int ret;
3083
3084		sector = start_sec + i;
3085		sdt = dif_store(sip, sector);
3086
3087		if (sdt->app_tag == cpu_to_be16(0xffff))
3088			continue;
3089
3090		ret = dif_verify(sdt, lba2fake_store(sip, sector), sector,
3091				 ei_lba);
3092		if (ret) {
3093			dif_errors++;
3094			return ret;
 
 
 
 
 
 
 
 
 
3095		}
3096	}
3097
3098	dif_copy_prot(scp, start_sec, sectors, true);
3099	dix_reads++;
3100
3101	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3102}
3103
3104static int resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
3105{
3106	bool check_prot;
3107	u32 num;
3108	u32 ei_lba;
3109	int ret;
3110	u64 lba;
3111	struct sdeb_store_info *sip = devip2sip(devip, true);
3112	rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
3113	u8 *cmd = scp->cmnd;
3114
3115	switch (cmd[0]) {
3116	case READ_16:
3117		ei_lba = 0;
3118		lba = get_unaligned_be64(cmd + 2);
3119		num = get_unaligned_be32(cmd + 10);
3120		check_prot = true;
3121		break;
3122	case READ_10:
3123		ei_lba = 0;
3124		lba = get_unaligned_be32(cmd + 2);
3125		num = get_unaligned_be16(cmd + 7);
3126		check_prot = true;
3127		break;
3128	case READ_6:
3129		ei_lba = 0;
3130		lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
3131		      (u32)(cmd[1] & 0x1f) << 16;
3132		num = (0 == cmd[4]) ? 256 : cmd[4];
3133		check_prot = true;
3134		break;
3135	case READ_12:
3136		ei_lba = 0;
3137		lba = get_unaligned_be32(cmd + 2);
3138		num = get_unaligned_be32(cmd + 6);
3139		check_prot = true;
3140		break;
3141	case XDWRITEREAD_10:
3142		ei_lba = 0;
3143		lba = get_unaligned_be32(cmd + 2);
3144		num = get_unaligned_be16(cmd + 7);
3145		check_prot = false;
3146		break;
3147	default:	/* assume READ(32) */
3148		lba = get_unaligned_be64(cmd + 12);
3149		ei_lba = get_unaligned_be32(cmd + 20);
3150		num = get_unaligned_be32(cmd + 28);
3151		check_prot = false;
3152		break;
3153	}
3154	if (unlikely(have_dif_prot && check_prot)) {
3155		if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
3156		    (cmd[1] & 0xe0)) {
3157			mk_sense_invalid_opcode(scp);
3158			return check_condition_result;
3159		}
3160		if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3161		     sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
3162		    (cmd[1] & 0xe0) == 0)
3163			sdev_printk(KERN_ERR, scp->device, "Unprotected RD "
3164				    "to DIF device\n");
3165	}
3166	if (unlikely((sdebug_opts & SDEBUG_OPT_SHORT_TRANSFER) &&
3167		     atomic_read(&sdeb_inject_pending))) {
3168		num /= 2;
3169		atomic_set(&sdeb_inject_pending, 0);
3170	}
3171
3172	ret = check_device_access_params(scp, lba, num, false);
3173	if (ret)
3174		return ret;
3175	if (unlikely((SDEBUG_OPT_MEDIUM_ERR & sdebug_opts) &&
3176		     (lba <= (sdebug_medium_error_start + sdebug_medium_error_count - 1)) &&
3177		     ((lba + num) > sdebug_medium_error_start))) {
3178		/* claim unrecoverable read error */
3179		mk_sense_buffer(scp, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 0);
3180		/* set info field and valid bit for fixed descriptor */
3181		if (0x70 == (scp->sense_buffer[0] & 0x7f)) {
3182			scp->sense_buffer[0] |= 0x80;	/* Valid bit */
3183			ret = (lba < OPT_MEDIUM_ERR_ADDR)
3184			      ? OPT_MEDIUM_ERR_ADDR : (int)lba;
3185			put_unaligned_be32(ret, scp->sense_buffer + 3);
3186		}
3187		scsi_set_resid(scp, scsi_bufflen(scp));
3188		return check_condition_result;
3189	}
3190
3191	read_lock(macc_lckp);
3192
3193	/* DIX + T10 DIF */
3194	if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
3195		int prot_ret = prot_verify_read(scp, lba, num, ei_lba);
3196
3197		if (prot_ret) {
3198			read_unlock(macc_lckp);
3199			mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, prot_ret);
3200			return illegal_condition_result;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3201		}
3202	}
3203
3204	ret = do_device_access(sip, scp, 0, lba, num, false);
3205	read_unlock(macc_lckp);
3206	if (unlikely(ret == -1))
3207		return DID_ERROR << 16;
3208
3209	scsi_set_resid(scp, scsi_bufflen(scp) - ret);
3210
3211	if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
3212		     atomic_read(&sdeb_inject_pending))) {
3213		if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
3214			mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
3215			atomic_set(&sdeb_inject_pending, 0);
3216			return check_condition_result;
3217		} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
3218			/* Logical block guard check failed */
3219			mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
3220			atomic_set(&sdeb_inject_pending, 0);
3221			return illegal_condition_result;
3222		} else if (SDEBUG_OPT_DIX_ERR & sdebug_opts) {
3223			mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
3224			atomic_set(&sdeb_inject_pending, 0);
3225			return illegal_condition_result;
3226		}
3227	}
3228	return 0;
3229}
3230
3231static void dump_sector(unsigned char *buf, int len)
3232{
3233	int i, j, n;
3234
3235	pr_err(">>> Sector Dump <<<\n");
3236	for (i = 0 ; i < len ; i += 16) {
3237		char b[128];
3238
3239		for (j = 0, n = 0; j < 16; j++) {
3240			unsigned char c = buf[i+j];
3241
3242			if (c >= 0x20 && c < 0x7e)
3243				n += scnprintf(b + n, sizeof(b) - n,
3244					       " %c ", buf[i+j]);
3245			else
3246				n += scnprintf(b + n, sizeof(b) - n,
3247					       "%02x ", buf[i+j]);
3248		}
3249		pr_err("%04d: %s\n", i, b);
3250	}
3251}
3252
3253static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
3254			     unsigned int sectors, u32 ei_lba)
3255{
3256	int ret;
3257	struct t10_pi_tuple *sdt;
3258	void *daddr;
3259	sector_t sector = start_sec;
3260	int ppage_offset;
3261	int dpage_offset;
3262	struct sg_mapping_iter diter;
3263	struct sg_mapping_iter piter;
3264
3265	BUG_ON(scsi_sg_count(SCpnt) == 0);
3266	BUG_ON(scsi_prot_sg_count(SCpnt) == 0);
3267
3268	sg_miter_start(&piter, scsi_prot_sglist(SCpnt),
3269			scsi_prot_sg_count(SCpnt),
3270			SG_MITER_ATOMIC | SG_MITER_FROM_SG);
3271	sg_miter_start(&diter, scsi_sglist(SCpnt), scsi_sg_count(SCpnt),
3272			SG_MITER_ATOMIC | SG_MITER_FROM_SG);
3273
3274	/* For each protection page */
3275	while (sg_miter_next(&piter)) {
3276		dpage_offset = 0;
3277		if (WARN_ON(!sg_miter_next(&diter))) {
3278			ret = 0x01;
3279			goto out;
3280		}
3281
3282		for (ppage_offset = 0; ppage_offset < piter.length;
3283		     ppage_offset += sizeof(struct t10_pi_tuple)) {
3284			/* If we're at the end of the current
3285			 * data page advance to the next one
3286			 */
3287			if (dpage_offset >= diter.length) {
3288				if (WARN_ON(!sg_miter_next(&diter))) {
3289					ret = 0x01;
3290					goto out;
3291				}
3292				dpage_offset = 0;
3293			}
3294
3295			sdt = piter.addr + ppage_offset;
3296			daddr = diter.addr + dpage_offset;
3297
3298			ret = dif_verify(sdt, daddr, sector, ei_lba);
3299			if (ret) {
3300				dump_sector(daddr, sdebug_sector_size);
3301				goto out;
3302			}
3303
3304			sector++;
3305			ei_lba++;
3306			dpage_offset += sdebug_sector_size;
3307		}
3308		diter.consumed = dpage_offset;
3309		sg_miter_stop(&diter);
3310	}
3311	sg_miter_stop(&piter);
3312
3313	dif_copy_prot(SCpnt, start_sec, sectors, false);
3314	dix_writes++;
3315
3316	return 0;
3317
3318out:
3319	dif_errors++;
3320	sg_miter_stop(&diter);
3321	sg_miter_stop(&piter);
3322	return ret;
3323}
3324
3325static unsigned long lba_to_map_index(sector_t lba)
3326{
3327	if (sdebug_unmap_alignment)
3328		lba += sdebug_unmap_granularity - sdebug_unmap_alignment;
3329	sector_div(lba, sdebug_unmap_granularity);
3330	return lba;
3331}
3332
3333static sector_t map_index_to_lba(unsigned long index)
3334{
3335	sector_t lba = index * sdebug_unmap_granularity;
3336
3337	if (sdebug_unmap_alignment)
3338		lba -= sdebug_unmap_granularity - sdebug_unmap_alignment;
3339	return lba;
3340}
3341
3342static unsigned int map_state(struct sdeb_store_info *sip, sector_t lba,
3343			      unsigned int *num)
3344{
3345	sector_t end;
3346	unsigned int mapped;
3347	unsigned long index;
3348	unsigned long next;
3349
3350	index = lba_to_map_index(lba);
3351	mapped = test_bit(index, sip->map_storep);
3352
3353	if (mapped)
3354		next = find_next_zero_bit(sip->map_storep, map_size, index);
3355	else
3356		next = find_next_bit(sip->map_storep, map_size, index);
3357
3358	end = min_t(sector_t, sdebug_store_sectors,  map_index_to_lba(next));
3359	*num = end - lba;
3360	return mapped;
3361}
3362
3363static void map_region(struct sdeb_store_info *sip, sector_t lba,
3364		       unsigned int len)
3365{
3366	sector_t end = lba + len;
3367
3368	while (lba < end) {
3369		unsigned long index = lba_to_map_index(lba);
3370
3371		if (index < map_size)
3372			set_bit(index, sip->map_storep);
3373
3374		lba = map_index_to_lba(index + 1);
3375	}
3376}
3377
3378static void unmap_region(struct sdeb_store_info *sip, sector_t lba,
3379			 unsigned int len)
3380{
3381	sector_t end = lba + len;
3382	u8 *fsp = sip->storep;
3383
3384	while (lba < end) {
3385		unsigned long index = lba_to_map_index(lba);
3386
3387		if (lba == map_index_to_lba(index) &&
3388		    lba + sdebug_unmap_granularity <= end &&
3389		    index < map_size) {
3390			clear_bit(index, sip->map_storep);
3391			if (sdebug_lbprz) {  /* for LBPRZ=2 return 0xff_s */
3392				memset(fsp + lba * sdebug_sector_size,
3393				       (sdebug_lbprz & 1) ? 0 : 0xff,
3394				       sdebug_sector_size *
3395				       sdebug_unmap_granularity);
3396			}
3397			if (sip->dif_storep) {
3398				memset(sip->dif_storep + lba, 0xff,
3399				       sizeof(*sip->dif_storep) *
3400				       sdebug_unmap_granularity);
3401			}
3402		}
3403		lba = map_index_to_lba(index + 1);
3404	}
3405}
3406
3407static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
3408{
3409	bool check_prot;
3410	u32 num;
3411	u32 ei_lba;
3412	int ret;
3413	u64 lba;
3414	struct sdeb_store_info *sip = devip2sip(devip, true);
3415	rwlock_t *macc_lckp = &sip->macc_lck;
3416	u8 *cmd = scp->cmnd;
3417
3418	switch (cmd[0]) {
3419	case WRITE_16:
3420		ei_lba = 0;
3421		lba = get_unaligned_be64(cmd + 2);
3422		num = get_unaligned_be32(cmd + 10);
3423		check_prot = true;
3424		break;
3425	case WRITE_10:
3426		ei_lba = 0;
3427		lba = get_unaligned_be32(cmd + 2);
3428		num = get_unaligned_be16(cmd + 7);
3429		check_prot = true;
3430		break;
3431	case WRITE_6:
3432		ei_lba = 0;
3433		lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
3434		      (u32)(cmd[1] & 0x1f) << 16;
3435		num = (0 == cmd[4]) ? 256 : cmd[4];
3436		check_prot = true;
3437		break;
3438	case WRITE_12:
3439		ei_lba = 0;
3440		lba = get_unaligned_be32(cmd + 2);
3441		num = get_unaligned_be32(cmd + 6);
3442		check_prot = true;
3443		break;
3444	case 0x53:	/* XDWRITEREAD(10) */
3445		ei_lba = 0;
3446		lba = get_unaligned_be32(cmd + 2);
3447		num = get_unaligned_be16(cmd + 7);
3448		check_prot = false;
3449		break;
3450	default:	/* assume WRITE(32) */
3451		lba = get_unaligned_be64(cmd + 12);
3452		ei_lba = get_unaligned_be32(cmd + 20);
3453		num = get_unaligned_be32(cmd + 28);
3454		check_prot = false;
3455		break;
3456	}
3457	if (unlikely(have_dif_prot && check_prot)) {
3458		if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
3459		    (cmd[1] & 0xe0)) {
3460			mk_sense_invalid_opcode(scp);
3461			return check_condition_result;
3462		}
3463		if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3464		     sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
3465		    (cmd[1] & 0xe0) == 0)
3466			sdev_printk(KERN_ERR, scp->device, "Unprotected WR "
3467				    "to DIF device\n");
3468	}
3469
3470	write_lock(macc_lckp);
3471	ret = check_device_access_params(scp, lba, num, true);
3472	if (ret) {
3473		write_unlock(macc_lckp);
3474		return ret;
3475	}
3476
3477	/* DIX + T10 DIF */
3478	if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
3479		int prot_ret = prot_verify_write(scp, lba, num, ei_lba);
3480
3481		if (prot_ret) {
3482			write_unlock(macc_lckp);
3483			mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, prot_ret);
3484			return illegal_condition_result;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3485		}
3486	}
3487
3488	ret = do_device_access(sip, scp, 0, lba, num, true);
3489	if (unlikely(scsi_debug_lbp()))
3490		map_region(sip, lba, num);
3491	/* If ZBC zone then bump its write pointer */
3492	if (sdebug_dev_is_zoned(devip))
3493		zbc_inc_wp(devip, lba, num);
3494	write_unlock(macc_lckp);
3495	if (unlikely(-1 == ret))
3496		return DID_ERROR << 16;
3497	else if (unlikely(sdebug_verbose &&
3498			  (ret < (num * sdebug_sector_size))))
3499		sdev_printk(KERN_INFO, scp->device,
3500			    "%s: write: cdb indicated=%u, IO sent=%d bytes\n",
3501			    my_name, num * sdebug_sector_size, ret);
3502
3503	if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
3504		     atomic_read(&sdeb_inject_pending))) {
3505		if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
3506			mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
3507			atomic_set(&sdeb_inject_pending, 0);
3508			return check_condition_result;
3509		} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
3510			/* Logical block guard check failed */
3511			mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
3512			atomic_set(&sdeb_inject_pending, 0);
3513			return illegal_condition_result;
3514		} else if (sdebug_opts & SDEBUG_OPT_DIX_ERR) {
3515			mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
3516			atomic_set(&sdeb_inject_pending, 0);
3517			return illegal_condition_result;
3518		}
3519	}
3520	return 0;
3521}
3522
3523/*
3524 * T10 has only specified WRITE SCATTERED(16) and WRITE SCATTERED(32).
3525 * No READ GATHERED yet (requires bidi or long cdb holding gather list).
3526 */
3527static int resp_write_scat(struct scsi_cmnd *scp,
3528			   struct sdebug_dev_info *devip)
3529{
3530	u8 *cmd = scp->cmnd;
3531	u8 *lrdp = NULL;
3532	u8 *up;
3533	struct sdeb_store_info *sip = devip2sip(devip, true);
3534	rwlock_t *macc_lckp = &sip->macc_lck;
3535	u8 wrprotect;
3536	u16 lbdof, num_lrd, k;
3537	u32 num, num_by, bt_len, lbdof_blen, sg_off, cum_lb;
3538	u32 lb_size = sdebug_sector_size;
3539	u32 ei_lba;
3540	u64 lba;
3541	int ret, res;
3542	bool is_16;
3543	static const u32 lrd_size = 32; /* + parameter list header size */
3544
3545	if (cmd[0] == VARIABLE_LENGTH_CMD) {
3546		is_16 = false;
3547		wrprotect = (cmd[10] >> 5) & 0x7;
3548		lbdof = get_unaligned_be16(cmd + 12);
3549		num_lrd = get_unaligned_be16(cmd + 16);
3550		bt_len = get_unaligned_be32(cmd + 28);
3551	} else {        /* that leaves WRITE SCATTERED(16) */
3552		is_16 = true;
3553		wrprotect = (cmd[2] >> 5) & 0x7;
3554		lbdof = get_unaligned_be16(cmd + 4);
3555		num_lrd = get_unaligned_be16(cmd + 8);
3556		bt_len = get_unaligned_be32(cmd + 10);
3557		if (unlikely(have_dif_prot)) {
3558			if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
3559			    wrprotect) {
3560				mk_sense_invalid_opcode(scp);
3561				return illegal_condition_result;
3562			}
3563			if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3564			     sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
3565			     wrprotect == 0)
3566				sdev_printk(KERN_ERR, scp->device,
3567					    "Unprotected WR to DIF device\n");
3568		}
3569	}
3570	if ((num_lrd == 0) || (bt_len == 0))
3571		return 0;       /* T10 says these do-nothings are not errors */
3572	if (lbdof == 0) {
3573		if (sdebug_verbose)
3574			sdev_printk(KERN_INFO, scp->device,
3575				"%s: %s: LB Data Offset field bad\n",
3576				my_name, __func__);
3577		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
3578		return illegal_condition_result;
3579	}
3580	lbdof_blen = lbdof * lb_size;
3581	if ((lrd_size + (num_lrd * lrd_size)) > lbdof_blen) {
3582		if (sdebug_verbose)
3583			sdev_printk(KERN_INFO, scp->device,
3584				"%s: %s: LBA range descriptors don't fit\n",
3585				my_name, __func__);
3586		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
3587		return illegal_condition_result;
3588	}
3589	lrdp = kzalloc(lbdof_blen, GFP_ATOMIC);
3590	if (lrdp == NULL)
3591		return SCSI_MLQUEUE_HOST_BUSY;
3592	if (sdebug_verbose)
3593		sdev_printk(KERN_INFO, scp->device,
3594			"%s: %s: Fetch header+scatter_list, lbdof_blen=%u\n",
3595			my_name, __func__, lbdof_blen);
3596	res = fetch_to_dev_buffer(scp, lrdp, lbdof_blen);
3597	if (res == -1) {
3598		ret = DID_ERROR << 16;
3599		goto err_out;
3600	}
3601
3602	write_lock(macc_lckp);
3603	sg_off = lbdof_blen;
3604	/* Spec says Buffer xfer Length field in number of LBs in dout */
3605	cum_lb = 0;
3606	for (k = 0, up = lrdp + lrd_size; k < num_lrd; ++k, up += lrd_size) {
3607		lba = get_unaligned_be64(up + 0);
3608		num = get_unaligned_be32(up + 8);
3609		if (sdebug_verbose)
3610			sdev_printk(KERN_INFO, scp->device,
3611				"%s: %s: k=%d  LBA=0x%llx num=%u  sg_off=%u\n",
3612				my_name, __func__, k, lba, num, sg_off);
3613		if (num == 0)
3614			continue;
3615		ret = check_device_access_params(scp, lba, num, true);
3616		if (ret)
3617			goto err_out_unlock;
3618		num_by = num * lb_size;
3619		ei_lba = is_16 ? 0 : get_unaligned_be32(up + 12);
3620
3621		if ((cum_lb + num) > bt_len) {
3622			if (sdebug_verbose)
3623				sdev_printk(KERN_INFO, scp->device,
3624				    "%s: %s: sum of blocks > data provided\n",
3625				    my_name, __func__);
3626			mk_sense_buffer(scp, ILLEGAL_REQUEST, WRITE_ERROR_ASC,
3627					0);
3628			ret = illegal_condition_result;
3629			goto err_out_unlock;
3630		}
3631
3632		/* DIX + T10 DIF */
3633		if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
3634			int prot_ret = prot_verify_write(scp, lba, num,
3635							 ei_lba);
3636
3637			if (prot_ret) {
3638				mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10,
3639						prot_ret);
3640				ret = illegal_condition_result;
3641				goto err_out_unlock;
3642			}
3643		}
3644
3645		ret = do_device_access(sip, scp, sg_off, lba, num, true);
3646		/* If ZBC zone then bump its write pointer */
3647		if (sdebug_dev_is_zoned(devip))
3648			zbc_inc_wp(devip, lba, num);
3649		if (unlikely(scsi_debug_lbp()))
3650			map_region(sip, lba, num);
3651		if (unlikely(-1 == ret)) {
3652			ret = DID_ERROR << 16;
3653			goto err_out_unlock;
3654		} else if (unlikely(sdebug_verbose && (ret < num_by)))
3655			sdev_printk(KERN_INFO, scp->device,
3656			    "%s: write: cdb indicated=%u, IO sent=%d bytes\n",
3657			    my_name, num_by, ret);
3658
3659		if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
3660			     atomic_read(&sdeb_inject_pending))) {
3661			if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
3662				mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
3663				atomic_set(&sdeb_inject_pending, 0);
3664				ret = check_condition_result;
3665				goto err_out_unlock;
3666			} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
3667				/* Logical block guard check failed */
3668				mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
3669				atomic_set(&sdeb_inject_pending, 0);
3670				ret = illegal_condition_result;
3671				goto err_out_unlock;
3672			} else if (sdebug_opts & SDEBUG_OPT_DIX_ERR) {
3673				mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
3674				atomic_set(&sdeb_inject_pending, 0);
3675				ret = illegal_condition_result;
3676				goto err_out_unlock;
3677			}
3678		}
3679		sg_off += num_by;
3680		cum_lb += num;
3681	}
3682	ret = 0;
3683err_out_unlock:
3684	write_unlock(macc_lckp);
3685err_out:
3686	kfree(lrdp);
3687	return ret;
3688}
3689
3690static int resp_write_same(struct scsi_cmnd *scp, u64 lba, u32 num,
3691			   u32 ei_lba, bool unmap, bool ndob)
3692{
3693	struct scsi_device *sdp = scp->device;
3694	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
3695	unsigned long long i;
3696	u64 block, lbaa;
3697	u32 lb_size = sdebug_sector_size;
3698	int ret;
3699	struct sdeb_store_info *sip = devip2sip((struct sdebug_dev_info *)
3700						scp->device->hostdata, true);
3701	rwlock_t *macc_lckp = &sip->macc_lck;
3702	u8 *fs1p;
3703	u8 *fsp;
3704
3705	write_lock(macc_lckp);
3706
3707	ret = check_device_access_params(scp, lba, num, true);
3708	if (ret) {
3709		write_unlock(macc_lckp);
3710		return ret;
3711	}
3712
3713	if (unmap && scsi_debug_lbp()) {
3714		unmap_region(sip, lba, num);
3715		goto out;
3716	}
3717	lbaa = lba;
3718	block = do_div(lbaa, sdebug_store_sectors);
3719	/* if ndob then zero 1 logical block, else fetch 1 logical block */
3720	fsp = sip->storep;
3721	fs1p = fsp + (block * lb_size);
3722	if (ndob) {
3723		memset(fs1p, 0, lb_size);
3724		ret = 0;
3725	} else
3726		ret = fetch_to_dev_buffer(scp, fs1p, lb_size);
3727
3728	if (-1 == ret) {
3729		write_unlock(&sip->macc_lck);
3730		return DID_ERROR << 16;
3731	} else if (sdebug_verbose && !ndob && (ret < lb_size))
3732		sdev_printk(KERN_INFO, scp->device,
3733			    "%s: %s: lb size=%u, IO sent=%d bytes\n",
3734			    my_name, "write same", lb_size, ret);
3735
3736	/* Copy first sector to remaining blocks */
3737	for (i = 1 ; i < num ; i++) {
3738		lbaa = lba + i;
3739		block = do_div(lbaa, sdebug_store_sectors);
3740		memmove(fsp + (block * lb_size), fs1p, lb_size);
3741	}
3742	if (scsi_debug_lbp())
3743		map_region(sip, lba, num);
3744	/* If ZBC zone then bump its write pointer */
3745	if (sdebug_dev_is_zoned(devip))
3746		zbc_inc_wp(devip, lba, num);
3747out:
3748	write_unlock(macc_lckp);
3749
3750	return 0;
3751}
3752
3753static int resp_write_same_10(struct scsi_cmnd *scp,
3754			      struct sdebug_dev_info *devip)
3755{
3756	u8 *cmd = scp->cmnd;
3757	u32 lba;
3758	u16 num;
3759	u32 ei_lba = 0;
3760	bool unmap = false;
3761
3762	if (cmd[1] & 0x8) {
3763		if (sdebug_lbpws10 == 0) {
3764			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 3);
3765			return check_condition_result;
3766		} else
3767			unmap = true;
3768	}
3769	lba = get_unaligned_be32(cmd + 2);
3770	num = get_unaligned_be16(cmd + 7);
3771	if (num > sdebug_write_same_length) {
3772		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 7, -1);
3773		return check_condition_result;
3774	}
3775	return resp_write_same(scp, lba, num, ei_lba, unmap, false);
3776}
3777
3778static int resp_write_same_16(struct scsi_cmnd *scp,
3779			      struct sdebug_dev_info *devip)
3780{
3781	u8 *cmd = scp->cmnd;
3782	u64 lba;
3783	u32 num;
3784	u32 ei_lba = 0;
3785	bool unmap = false;
3786	bool ndob = false;
3787
3788	if (cmd[1] & 0x8) {	/* UNMAP */
3789		if (sdebug_lbpws == 0) {
3790			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 3);
3791			return check_condition_result;
3792		} else
3793			unmap = true;
3794	}
3795	if (cmd[1] & 0x1)  /* NDOB (no data-out buffer, assumes zeroes) */
3796		ndob = true;
3797	lba = get_unaligned_be64(cmd + 2);
3798	num = get_unaligned_be32(cmd + 10);
3799	if (num > sdebug_write_same_length) {
3800		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 10, -1);
3801		return check_condition_result;
3802	}
3803	return resp_write_same(scp, lba, num, ei_lba, unmap, ndob);
3804}
3805
3806/* Note the mode field is in the same position as the (lower) service action
3807 * field. For the Report supported operation codes command, SPC-4 suggests
3808 * each mode of this command should be reported separately; for future. */
3809static int resp_write_buffer(struct scsi_cmnd *scp,
3810			     struct sdebug_dev_info *devip)
3811{
3812	u8 *cmd = scp->cmnd;
3813	struct scsi_device *sdp = scp->device;
3814	struct sdebug_dev_info *dp;
3815	u8 mode;
3816
3817	mode = cmd[1] & 0x1f;
3818	switch (mode) {
3819	case 0x4:	/* download microcode (MC) and activate (ACT) */
3820		/* set UAs on this device only */
3821		set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
3822		set_bit(SDEBUG_UA_MICROCODE_CHANGED, devip->uas_bm);
3823		break;
3824	case 0x5:	/* download MC, save and ACT */
3825		set_bit(SDEBUG_UA_MICROCODE_CHANGED_WO_RESET, devip->uas_bm);
3826		break;
3827	case 0x6:	/* download MC with offsets and ACT */
3828		/* set UAs on most devices (LUs) in this target */
3829		list_for_each_entry(dp,
3830				    &devip->sdbg_host->dev_info_list,
3831				    dev_list)
3832			if (dp->target == sdp->id) {
3833				set_bit(SDEBUG_UA_BUS_RESET, dp->uas_bm);
3834				if (devip != dp)
3835					set_bit(SDEBUG_UA_MICROCODE_CHANGED,
3836						dp->uas_bm);
3837			}
3838		break;
3839	case 0x7:	/* download MC with offsets, save, and ACT */
3840		/* set UA on all devices (LUs) in this target */
3841		list_for_each_entry(dp,
3842				    &devip->sdbg_host->dev_info_list,
3843				    dev_list)
3844			if (dp->target == sdp->id)
3845				set_bit(SDEBUG_UA_MICROCODE_CHANGED_WO_RESET,
3846					dp->uas_bm);
3847		break;
3848	default:
3849		/* do nothing for this command for other mode values */
3850		break;
3851	}
3852	return 0;
3853}
3854
3855static int resp_comp_write(struct scsi_cmnd *scp,
3856			   struct sdebug_dev_info *devip)
3857{
3858	u8 *cmd = scp->cmnd;
3859	u8 *arr;
3860	struct sdeb_store_info *sip = devip2sip(devip, true);
3861	rwlock_t *macc_lckp = &sip->macc_lck;
3862	u64 lba;
3863	u32 dnum;
3864	u32 lb_size = sdebug_sector_size;
3865	u8 num;
3866	int ret;
3867	int retval = 0;
3868
3869	lba = get_unaligned_be64(cmd + 2);
3870	num = cmd[13];		/* 1 to a maximum of 255 logical blocks */
3871	if (0 == num)
3872		return 0;	/* degenerate case, not an error */
3873	if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
3874	    (cmd[1] & 0xe0)) {
3875		mk_sense_invalid_opcode(scp);
3876		return check_condition_result;
3877	}
3878	if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3879	     sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
3880	    (cmd[1] & 0xe0) == 0)
3881		sdev_printk(KERN_ERR, scp->device, "Unprotected WR "
3882			    "to DIF device\n");
3883	ret = check_device_access_params(scp, lba, num, false);
3884	if (ret)
3885		return ret;
3886	dnum = 2 * num;
3887	arr = kcalloc(lb_size, dnum, GFP_ATOMIC);
3888	if (NULL == arr) {
3889		mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
3890				INSUFF_RES_ASCQ);
3891		return check_condition_result;
3892	}
3893
3894	write_lock(macc_lckp);
3895
3896	ret = do_dout_fetch(scp, dnum, arr);
3897	if (ret == -1) {
3898		retval = DID_ERROR << 16;
3899		goto cleanup;
3900	} else if (sdebug_verbose && (ret < (dnum * lb_size)))
3901		sdev_printk(KERN_INFO, scp->device, "%s: compare_write: cdb "
3902			    "indicated=%u, IO sent=%d bytes\n", my_name,
3903			    dnum * lb_size, ret);
3904	if (!comp_write_worker(sip, lba, num, arr, false)) {
3905		mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
3906		retval = check_condition_result;
3907		goto cleanup;
3908	}
3909	if (scsi_debug_lbp())
3910		map_region(sip, lba, num);
3911cleanup:
3912	write_unlock(macc_lckp);
3913	kfree(arr);
3914	return retval;
3915}
3916
3917struct unmap_block_desc {
3918	__be64	lba;
3919	__be32	blocks;
3920	__be32	__reserved;
3921};
3922
3923static int resp_unmap(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
3924{
3925	unsigned char *buf;
3926	struct unmap_block_desc *desc;
3927	struct sdeb_store_info *sip = devip2sip(devip, true);
3928	rwlock_t *macc_lckp = &sip->macc_lck;
3929	unsigned int i, payload_len, descriptors;
3930	int ret;
3931
3932	if (!scsi_debug_lbp())
3933		return 0;	/* fib and say its done */
3934	payload_len = get_unaligned_be16(scp->cmnd + 7);
3935	BUG_ON(scsi_bufflen(scp) != payload_len);
3936
3937	descriptors = (payload_len - 8) / 16;
3938	if (descriptors > sdebug_unmap_max_desc) {
3939		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 7, -1);
3940		return check_condition_result;
3941	}
3942
3943	buf = kzalloc(scsi_bufflen(scp), GFP_ATOMIC);
3944	if (!buf) {
3945		mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
3946				INSUFF_RES_ASCQ);
3947		return check_condition_result;
3948	}
3949
3950	scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
3951
3952	BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2);
3953	BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16);
3954
3955	desc = (void *)&buf[8];
3956
3957	write_lock(macc_lckp);
3958
3959	for (i = 0 ; i < descriptors ; i++) {
3960		unsigned long long lba = get_unaligned_be64(&desc[i].lba);
3961		unsigned int num = get_unaligned_be32(&desc[i].blocks);
3962
3963		ret = check_device_access_params(scp, lba, num, true);
3964		if (ret)
3965			goto out;
3966
3967		unmap_region(sip, lba, num);
3968	}
3969
3970	ret = 0;
3971
3972out:
3973	write_unlock(macc_lckp);
3974	kfree(buf);
3975
3976	return ret;
3977}
3978
3979#define SDEBUG_GET_LBA_STATUS_LEN 32
3980
3981static int resp_get_lba_status(struct scsi_cmnd *scp,
3982			       struct sdebug_dev_info *devip)
3983{
3984	u8 *cmd = scp->cmnd;
3985	u64 lba;
3986	u32 alloc_len, mapped, num;
3987	int ret;
3988	u8 arr[SDEBUG_GET_LBA_STATUS_LEN];
3989
3990	lba = get_unaligned_be64(cmd + 2);
3991	alloc_len = get_unaligned_be32(cmd + 10);
3992
3993	if (alloc_len < 24)
3994		return 0;
3995
3996	ret = check_device_access_params(scp, lba, 1, false);
3997	if (ret)
3998		return ret;
3999
4000	if (scsi_debug_lbp()) {
4001		struct sdeb_store_info *sip = devip2sip(devip, true);
4002
4003		mapped = map_state(sip, lba, &num);
4004	} else {
4005		mapped = 1;
4006		/* following just in case virtual_gb changed */
4007		sdebug_capacity = get_sdebug_capacity();
4008		if (sdebug_capacity - lba <= 0xffffffff)
4009			num = sdebug_capacity - lba;
4010		else
4011			num = 0xffffffff;
4012	}
4013
4014	memset(arr, 0, SDEBUG_GET_LBA_STATUS_LEN);
4015	put_unaligned_be32(20, arr);		/* Parameter Data Length */
4016	put_unaligned_be64(lba, arr + 8);	/* LBA */
4017	put_unaligned_be32(num, arr + 16);	/* Number of blocks */
4018	arr[20] = !mapped;		/* prov_stat=0: mapped; 1: dealloc */
4019
4020	return fill_from_dev_buffer(scp, arr, SDEBUG_GET_LBA_STATUS_LEN);
4021}
4022
4023static int resp_sync_cache(struct scsi_cmnd *scp,
4024			   struct sdebug_dev_info *devip)
4025{
4026	int res = 0;
4027	u64 lba;
4028	u32 num_blocks;
4029	u8 *cmd = scp->cmnd;
4030
4031	if (cmd[0] == SYNCHRONIZE_CACHE) {	/* 10 byte cdb */
4032		lba = get_unaligned_be32(cmd + 2);
4033		num_blocks = get_unaligned_be16(cmd + 7);
4034	} else {				/* SYNCHRONIZE_CACHE(16) */
4035		lba = get_unaligned_be64(cmd + 2);
4036		num_blocks = get_unaligned_be32(cmd + 10);
4037	}
4038	if (lba + num_blocks > sdebug_capacity) {
4039		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4040		return check_condition_result;
4041	}
4042	if (!write_since_sync || (cmd[1] & 0x2))
4043		res = SDEG_RES_IMMED_MASK;
4044	else		/* delay if write_since_sync and IMMED clear */
4045		write_since_sync = false;
4046	return res;
4047}
4048
4049/*
4050 * Assuming the LBA+num_blocks is not out-of-range, this function will return
4051 * CONDITION MET if the specified blocks will/have fitted in the cache, and
4052 * a GOOD status otherwise. Model a disk with a big cache and yield
4053 * CONDITION MET. Actually tries to bring range in main memory into the
4054 * cache associated with the CPU(s).
4055 */
4056static int resp_pre_fetch(struct scsi_cmnd *scp,
4057			  struct sdebug_dev_info *devip)
4058{
4059	int res = 0;
4060	u64 lba;
4061	u64 block, rest = 0;
4062	u32 nblks;
4063	u8 *cmd = scp->cmnd;
4064	struct sdeb_store_info *sip = devip2sip(devip, true);
4065	rwlock_t *macc_lckp = &sip->macc_lck;
4066	u8 *fsp = sip->storep;
4067
4068	if (cmd[0] == PRE_FETCH) {	/* 10 byte cdb */
4069		lba = get_unaligned_be32(cmd + 2);
4070		nblks = get_unaligned_be16(cmd + 7);
4071	} else {			/* PRE-FETCH(16) */
4072		lba = get_unaligned_be64(cmd + 2);
4073		nblks = get_unaligned_be32(cmd + 10);
4074	}
4075	if (lba + nblks > sdebug_capacity) {
4076		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4077		return check_condition_result;
4078	}
4079	if (!fsp)
4080		goto fini;
4081	/* PRE-FETCH spec says nothing about LBP or PI so skip them */
4082	block = do_div(lba, sdebug_store_sectors);
4083	if (block + nblks > sdebug_store_sectors)
4084		rest = block + nblks - sdebug_store_sectors;
4085
4086	/* Try to bring the PRE-FETCH range into CPU's cache */
4087	read_lock(macc_lckp);
4088	prefetch_range(fsp + (sdebug_sector_size * block),
4089		       (nblks - rest) * sdebug_sector_size);
4090	if (rest)
4091		prefetch_range(fsp, rest * sdebug_sector_size);
4092	read_unlock(macc_lckp);
4093fini:
4094	if (cmd[1] & 0x2)
4095		res = SDEG_RES_IMMED_MASK;
4096	return res | condition_met_result;
4097}
4098
4099#define RL_BUCKET_ELEMS 8
4100
4101/* Even though each pseudo target has a REPORT LUNS "well known logical unit"
4102 * (W-LUN), the normal Linux scanning logic does not associate it with a
4103 * device (e.g. /dev/sg7). The following magic will make that association:
4104 *   "cd /sys/class/scsi_host/host<n> ; echo '- - 49409' > scan"
4105 * where <n> is a host number. If there are multiple targets in a host then
4106 * the above will associate a W-LUN to each target. To only get a W-LUN
4107 * for target 2, then use "echo '- 2 49409' > scan" .
4108 */
4109static int resp_report_luns(struct scsi_cmnd *scp,
4110			    struct sdebug_dev_info *devip)
4111{
4112	unsigned char *cmd = scp->cmnd;
4113	unsigned int alloc_len;
4114	unsigned char select_report;
4115	u64 lun;
4116	struct scsi_lun *lun_p;
4117	u8 arr[RL_BUCKET_ELEMS * sizeof(struct scsi_lun)];
4118	unsigned int lun_cnt;	/* normal LUN count (max: 256) */
4119	unsigned int wlun_cnt;	/* report luns W-LUN count */
4120	unsigned int tlun_cnt;	/* total LUN count */
4121	unsigned int rlen;	/* response length (in bytes) */
4122	int k, j, n, res;
4123	unsigned int off_rsp = 0;
4124	const int sz_lun = sizeof(struct scsi_lun);
4125
4126	clear_luns_changed_on_target(devip);
4127
4128	select_report = cmd[2];
4129	alloc_len = get_unaligned_be32(cmd + 6);
4130
4131	if (alloc_len < 4) {
4132		pr_err("alloc len too small %d\n", alloc_len);
4133		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
4134		return check_condition_result;
4135	}
4136
4137	switch (select_report) {
4138	case 0:		/* all LUNs apart from W-LUNs */
4139		lun_cnt = sdebug_max_luns;
4140		wlun_cnt = 0;
4141		break;
4142	case 1:		/* only W-LUNs */
4143		lun_cnt = 0;
4144		wlun_cnt = 1;
4145		break;
4146	case 2:		/* all LUNs */
4147		lun_cnt = sdebug_max_luns;
4148		wlun_cnt = 1;
4149		break;
4150	case 0x10:	/* only administrative LUs */
4151	case 0x11:	/* see SPC-5 */
4152	case 0x12:	/* only subsiduary LUs owned by referenced LU */
4153	default:
4154		pr_debug("select report invalid %d\n", select_report);
4155		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, -1);
4156		return check_condition_result;
4157	}
4158
4159	if (sdebug_no_lun_0 && (lun_cnt > 0))
4160		--lun_cnt;
4161
4162	tlun_cnt = lun_cnt + wlun_cnt;
4163	rlen = tlun_cnt * sz_lun;	/* excluding 8 byte header */
4164	scsi_set_resid(scp, scsi_bufflen(scp));
4165	pr_debug("select_report %d luns = %d wluns = %d no_lun0 %d\n",
4166		 select_report, lun_cnt, wlun_cnt, sdebug_no_lun_0);
4167
4168	/* loops rely on sizeof response header same as sizeof lun (both 8) */
4169	lun = sdebug_no_lun_0 ? 1 : 0;
4170	for (k = 0, j = 0, res = 0; true; ++k, j = 0) {
4171		memset(arr, 0, sizeof(arr));
4172		lun_p = (struct scsi_lun *)&arr[0];
4173		if (k == 0) {
4174			put_unaligned_be32(rlen, &arr[0]);
4175			++lun_p;
4176			j = 1;
4177		}
4178		for ( ; j < RL_BUCKET_ELEMS; ++j, ++lun_p) {
4179			if ((k * RL_BUCKET_ELEMS) + j > lun_cnt)
4180				break;
4181			int_to_scsilun(lun++, lun_p);
 
 
4182		}
4183		if (j < RL_BUCKET_ELEMS)
4184			break;
4185		n = j * sz_lun;
4186		res = p_fill_from_dev_buffer(scp, arr, n, off_rsp);
4187		if (res)
4188			return res;
4189		off_rsp += n;
4190	}
4191	if (wlun_cnt) {
4192		int_to_scsilun(SCSI_W_LUN_REPORT_LUNS, lun_p);
4193		++j;
4194	}
4195	if (j > 0)
4196		res = p_fill_from_dev_buffer(scp, arr, j * sz_lun, off_rsp);
4197	return res;
4198}
4199
4200static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
4201{
4202	bool is_bytchk3 = false;
4203	u8 bytchk;
4204	int ret, j;
4205	u32 vnum, a_num, off;
4206	const u32 lb_size = sdebug_sector_size;
4207	u64 lba;
4208	u8 *arr;
4209	u8 *cmd = scp->cmnd;
4210	struct sdeb_store_info *sip = devip2sip(devip, true);
4211	rwlock_t *macc_lckp = &sip->macc_lck;
4212
4213	bytchk = (cmd[1] >> 1) & 0x3;
4214	if (bytchk == 0) {
4215		return 0;	/* always claim internal verify okay */
4216	} else if (bytchk == 2) {
4217		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 2);
4218		return check_condition_result;
4219	} else if (bytchk == 3) {
4220		is_bytchk3 = true;	/* 1 block sent, compared repeatedly */
4221	}
4222	switch (cmd[0]) {
4223	case VERIFY_16:
4224		lba = get_unaligned_be64(cmd + 2);
4225		vnum = get_unaligned_be32(cmd + 10);
4226		break;
4227	case VERIFY:		/* is VERIFY(10) */
4228		lba = get_unaligned_be32(cmd + 2);
4229		vnum = get_unaligned_be16(cmd + 7);
4230		break;
4231	default:
4232		mk_sense_invalid_opcode(scp);
4233		return check_condition_result;
4234	}
 
 
4235	a_num = is_bytchk3 ? 1 : vnum;
4236	/* Treat following check like one for read (i.e. no write) access */
4237	ret = check_device_access_params(scp, lba, a_num, false);
4238	if (ret)
4239		return ret;
4240
4241	arr = kcalloc(lb_size, vnum, GFP_ATOMIC);
4242	if (!arr) {
4243		mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
4244				INSUFF_RES_ASCQ);
4245		return check_condition_result;
4246	}
4247	/* Not changing store, so only need read access */
4248	read_lock(macc_lckp);
4249
4250	ret = do_dout_fetch(scp, a_num, arr);
4251	if (ret == -1) {
4252		ret = DID_ERROR << 16;
4253		goto cleanup;
4254	} else if (sdebug_verbose && (ret < (a_num * lb_size))) {
4255		sdev_printk(KERN_INFO, scp->device,
4256			    "%s: %s: cdb indicated=%u, IO sent=%d bytes\n",
4257			    my_name, __func__, a_num * lb_size, ret);
4258	}
4259	if (is_bytchk3) {
4260		for (j = 1, off = lb_size; j < vnum; ++j, off += lb_size)
4261			memcpy(arr + off, arr, lb_size);
4262	}
4263	ret = 0;
4264	if (!comp_write_worker(sip, lba, vnum, arr, true)) {
4265		mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
4266		ret = check_condition_result;
4267		goto cleanup;
4268	}
4269cleanup:
4270	read_unlock(macc_lckp);
4271	kfree(arr);
4272	return ret;
4273}
4274
4275#define RZONES_DESC_HD 64
4276
4277/* Report zones depending on start LBA nad reporting options */
4278static int resp_report_zones(struct scsi_cmnd *scp,
4279			     struct sdebug_dev_info *devip)
4280{
4281	unsigned int i, max_zones, rep_max_zones, nrz = 0;
4282	int ret = 0;
4283	u32 alloc_len, rep_opts, rep_len;
4284	bool partial;
4285	u64 lba, zs_lba;
4286	u8 *arr = NULL, *desc;
4287	u8 *cmd = scp->cmnd;
4288	struct sdeb_zone_state *zsp;
4289	struct sdeb_store_info *sip = devip2sip(devip, false);
4290	rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
4291
4292	if (!sdebug_dev_is_zoned(devip)) {
4293		mk_sense_invalid_opcode(scp);
4294		return check_condition_result;
4295	}
4296	zs_lba = get_unaligned_be64(cmd + 2);
4297	alloc_len = get_unaligned_be32(cmd + 10);
 
 
4298	rep_opts = cmd[14] & 0x3f;
4299	partial = cmd[14] & 0x80;
4300
4301	if (zs_lba >= sdebug_capacity) {
4302		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4303		return check_condition_result;
4304	}
4305
4306	max_zones = devip->nr_zones - (zs_lba >> devip->zsize_shift);
4307	rep_max_zones = min((alloc_len - 64) >> ilog2(RZONES_DESC_HD),
4308			    max_zones);
4309
4310	arr = kcalloc(RZONES_DESC_HD, alloc_len, GFP_ATOMIC);
4311	if (!arr) {
4312		mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
4313				INSUFF_RES_ASCQ);
4314		return check_condition_result;
4315	}
4316
4317	read_lock(macc_lckp);
4318
4319	desc = arr + 64;
4320	for (i = 0; i < max_zones; i++) {
4321		lba = zs_lba + devip->zsize * i;
4322		if (lba > sdebug_capacity)
4323			break;
4324		zsp = zbc_zone(devip, lba);
4325		switch (rep_opts) {
4326		case 0x00:
4327			/* All zones */
4328			break;
4329		case 0x01:
4330			/* Empty zones */
4331			if (zsp->z_cond != ZC1_EMPTY)
4332				continue;
4333			break;
4334		case 0x02:
4335			/* Implicit open zones */
4336			if (zsp->z_cond != ZC2_IMPLICIT_OPEN)
4337				continue;
4338			break;
4339		case 0x03:
4340			/* Explicit open zones */
4341			if (zsp->z_cond != ZC3_EXPLICIT_OPEN)
4342				continue;
4343			break;
4344		case 0x04:
4345			/* Closed zones */
4346			if (zsp->z_cond != ZC4_CLOSED)
4347				continue;
4348			break;
4349		case 0x05:
4350			/* Full zones */
4351			if (zsp->z_cond != ZC5_FULL)
4352				continue;
4353			break;
4354		case 0x06:
4355		case 0x07:
4356		case 0x10:
4357			/*
4358			 * Read-only, offline, reset WP recommended are
4359			 * not emulated: no zones to report;
4360			 */
4361			continue;
4362		case 0x11:
4363			/* non-seq-resource set */
4364			if (!zsp->z_non_seq_resource)
4365				continue;
4366			break;
 
 
 
 
 
4367		case 0x3f:
4368			/* Not write pointer (conventional) zones */
4369			if (!zbc_zone_is_conv(zsp))
4370				continue;
4371			break;
4372		default:
4373			mk_sense_buffer(scp, ILLEGAL_REQUEST,
4374					INVALID_FIELD_IN_CDB, 0);
4375			ret = check_condition_result;
4376			goto fini;
4377		}
4378
4379		if (nrz < rep_max_zones) {
4380			/* Fill zone descriptor */
4381			desc[0] = zsp->z_type;
4382			desc[1] = zsp->z_cond << 4;
4383			if (zsp->z_non_seq_resource)
4384				desc[1] |= 1 << 1;
4385			put_unaligned_be64((u64)zsp->z_size, desc + 8);
4386			put_unaligned_be64((u64)zsp->z_start, desc + 16);
4387			put_unaligned_be64((u64)zsp->z_wp, desc + 24);
4388			desc += 64;
4389		}
4390
4391		if (partial && nrz >= rep_max_zones)
4392			break;
4393
4394		nrz++;
4395	}
4396
4397	/* Report header */
 
4398	put_unaligned_be32(nrz * RZONES_DESC_HD, arr + 0);
 
4399	put_unaligned_be64(sdebug_capacity - 1, arr + 8);
 
 
 
4400
4401	rep_len = (unsigned long)desc - (unsigned long)arr;
4402	ret = fill_from_dev_buffer(scp, arr, min_t(int, alloc_len, rep_len));
4403
4404fini:
4405	read_unlock(macc_lckp);
4406	kfree(arr);
4407	return ret;
4408}
4409
4410/* Logic transplanted from tcmu-runner, file_zbc.c */
4411static void zbc_open_all(struct sdebug_dev_info *devip)
4412{
4413	struct sdeb_zone_state *zsp = &devip->zstate[0];
4414	unsigned int i;
4415
4416	for (i = 0; i < devip->nr_zones; i++, zsp++) {
4417		if (zsp->z_cond == ZC4_CLOSED)
4418			zbc_open_zone(devip, &devip->zstate[i], true);
4419	}
4420}
4421
4422static int resp_open_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
4423{
4424	int res = 0;
4425	u64 z_id;
4426	enum sdebug_z_cond zc;
4427	u8 *cmd = scp->cmnd;
4428	struct sdeb_zone_state *zsp;
4429	bool all = cmd[14] & 0x01;
4430	struct sdeb_store_info *sip = devip2sip(devip, false);
4431	rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
4432
4433	if (!sdebug_dev_is_zoned(devip)) {
4434		mk_sense_invalid_opcode(scp);
4435		return check_condition_result;
4436	}
4437
4438	write_lock(macc_lckp);
4439
4440	if (all) {
4441		/* Check if all closed zones can be open */
4442		if (devip->max_open &&
4443		    devip->nr_exp_open + devip->nr_closed > devip->max_open) {
4444			mk_sense_buffer(scp, DATA_PROTECT, INSUFF_RES_ASC,
4445					INSUFF_ZONE_ASCQ);
4446			res = check_condition_result;
4447			goto fini;
4448		}
4449		/* Open all closed zones */
4450		zbc_open_all(devip);
4451		goto fini;
4452	}
4453
4454	/* Open the specified zone */
4455	z_id = get_unaligned_be64(cmd + 2);
4456	if (z_id >= sdebug_capacity) {
4457		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4458		res = check_condition_result;
4459		goto fini;
4460	}
4461
4462	zsp = zbc_zone(devip, z_id);
4463	if (z_id != zsp->z_start) {
4464		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4465		res = check_condition_result;
4466		goto fini;
4467	}
4468	if (zbc_zone_is_conv(zsp)) {
4469		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4470		res = check_condition_result;
4471		goto fini;
4472	}
4473
4474	zc = zsp->z_cond;
4475	if (zc == ZC3_EXPLICIT_OPEN || zc == ZC5_FULL)
4476		goto fini;
4477
4478	if (devip->max_open && devip->nr_exp_open >= devip->max_open) {
4479		mk_sense_buffer(scp, DATA_PROTECT, INSUFF_RES_ASC,
4480				INSUFF_ZONE_ASCQ);
4481		res = check_condition_result;
4482		goto fini;
4483	}
4484
4485	zbc_open_zone(devip, zsp, true);
4486fini:
4487	write_unlock(macc_lckp);
4488	return res;
4489}
4490
4491static void zbc_close_all(struct sdebug_dev_info *devip)
4492{
4493	unsigned int i;
4494
4495	for (i = 0; i < devip->nr_zones; i++)
4496		zbc_close_zone(devip, &devip->zstate[i]);
4497}
4498
4499static int resp_close_zone(struct scsi_cmnd *scp,
4500			   struct sdebug_dev_info *devip)
4501{
4502	int res = 0;
4503	u64 z_id;
4504	u8 *cmd = scp->cmnd;
4505	struct sdeb_zone_state *zsp;
4506	bool all = cmd[14] & 0x01;
4507	struct sdeb_store_info *sip = devip2sip(devip, false);
4508	rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
4509
4510	if (!sdebug_dev_is_zoned(devip)) {
4511		mk_sense_invalid_opcode(scp);
4512		return check_condition_result;
4513	}
4514
4515	write_lock(macc_lckp);
4516
4517	if (all) {
4518		zbc_close_all(devip);
4519		goto fini;
4520	}
4521
4522	/* Close specified zone */
4523	z_id = get_unaligned_be64(cmd + 2);
4524	if (z_id >= sdebug_capacity) {
4525		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4526		res = check_condition_result;
4527		goto fini;
4528	}
4529
4530	zsp = zbc_zone(devip, z_id);
4531	if (z_id != zsp->z_start) {
4532		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4533		res = check_condition_result;
4534		goto fini;
4535	}
4536	if (zbc_zone_is_conv(zsp)) {
4537		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4538		res = check_condition_result;
4539		goto fini;
4540	}
4541
4542	zbc_close_zone(devip, zsp);
4543fini:
4544	write_unlock(macc_lckp);
4545	return res;
4546}
4547
4548static void zbc_finish_zone(struct sdebug_dev_info *devip,
4549			    struct sdeb_zone_state *zsp, bool empty)
4550{
4551	enum sdebug_z_cond zc = zsp->z_cond;
4552
4553	if (zc == ZC4_CLOSED || zc == ZC2_IMPLICIT_OPEN ||
4554	    zc == ZC3_EXPLICIT_OPEN || (empty && zc == ZC1_EMPTY)) {
4555		if (zc == ZC2_IMPLICIT_OPEN || zc == ZC3_EXPLICIT_OPEN)
4556			zbc_close_zone(devip, zsp);
4557		if (zsp->z_cond == ZC4_CLOSED)
4558			devip->nr_closed--;
4559		zsp->z_wp = zsp->z_start + zsp->z_size;
4560		zsp->z_cond = ZC5_FULL;
4561	}
4562}
4563
4564static void zbc_finish_all(struct sdebug_dev_info *devip)
4565{
4566	unsigned int i;
4567
4568	for (i = 0; i < devip->nr_zones; i++)
4569		zbc_finish_zone(devip, &devip->zstate[i], false);
4570}
4571
4572static int resp_finish_zone(struct scsi_cmnd *scp,
4573			    struct sdebug_dev_info *devip)
4574{
4575	struct sdeb_zone_state *zsp;
4576	int res = 0;
4577	u64 z_id;
4578	u8 *cmd = scp->cmnd;
4579	bool all = cmd[14] & 0x01;
4580	struct sdeb_store_info *sip = devip2sip(devip, false);
4581	rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
4582
4583	if (!sdebug_dev_is_zoned(devip)) {
4584		mk_sense_invalid_opcode(scp);
4585		return check_condition_result;
4586	}
4587
4588	write_lock(macc_lckp);
4589
4590	if (all) {
4591		zbc_finish_all(devip);
4592		goto fini;
4593	}
4594
4595	/* Finish the specified zone */
4596	z_id = get_unaligned_be64(cmd + 2);
4597	if (z_id >= sdebug_capacity) {
4598		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4599		res = check_condition_result;
4600		goto fini;
4601	}
4602
4603	zsp = zbc_zone(devip, z_id);
4604	if (z_id != zsp->z_start) {
4605		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4606		res = check_condition_result;
4607		goto fini;
4608	}
4609	if (zbc_zone_is_conv(zsp)) {
4610		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4611		res = check_condition_result;
4612		goto fini;
4613	}
4614
4615	zbc_finish_zone(devip, zsp, true);
4616fini:
4617	write_unlock(macc_lckp);
4618	return res;
4619}
4620
4621static void zbc_rwp_zone(struct sdebug_dev_info *devip,
4622			 struct sdeb_zone_state *zsp)
4623{
4624	enum sdebug_z_cond zc;
 
4625
4626	if (zbc_zone_is_conv(zsp))
4627		return;
4628
4629	zc = zsp->z_cond;
4630	if (zc == ZC2_IMPLICIT_OPEN || zc == ZC3_EXPLICIT_OPEN)
4631		zbc_close_zone(devip, zsp);
4632
4633	if (zsp->z_cond == ZC4_CLOSED)
4634		devip->nr_closed--;
4635
 
 
 
 
4636	zsp->z_non_seq_resource = false;
4637	zsp->z_wp = zsp->z_start;
4638	zsp->z_cond = ZC1_EMPTY;
4639}
4640
4641static void zbc_rwp_all(struct sdebug_dev_info *devip)
4642{
4643	unsigned int i;
4644
4645	for (i = 0; i < devip->nr_zones; i++)
4646		zbc_rwp_zone(devip, &devip->zstate[i]);
4647}
4648
4649static int resp_rwp_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
4650{
4651	struct sdeb_zone_state *zsp;
4652	int res = 0;
4653	u64 z_id;
4654	u8 *cmd = scp->cmnd;
4655	bool all = cmd[14] & 0x01;
4656	struct sdeb_store_info *sip = devip2sip(devip, false);
4657	rwlock_t *macc_lckp = sip ? &sip->macc_lck : &sdeb_fake_rw_lck;
4658
4659	if (!sdebug_dev_is_zoned(devip)) {
4660		mk_sense_invalid_opcode(scp);
4661		return check_condition_result;
4662	}
4663
4664	write_lock(macc_lckp);
4665
4666	if (all) {
4667		zbc_rwp_all(devip);
4668		goto fini;
4669	}
4670
4671	z_id = get_unaligned_be64(cmd + 2);
4672	if (z_id >= sdebug_capacity) {
4673		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4674		res = check_condition_result;
4675		goto fini;
4676	}
4677
4678	zsp = zbc_zone(devip, z_id);
4679	if (z_id != zsp->z_start) {
4680		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4681		res = check_condition_result;
4682		goto fini;
4683	}
4684	if (zbc_zone_is_conv(zsp)) {
4685		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4686		res = check_condition_result;
4687		goto fini;
4688	}
4689
4690	zbc_rwp_zone(devip, zsp);
4691fini:
4692	write_unlock(macc_lckp);
4693	return res;
4694}
4695
4696static struct sdebug_queue *get_queue(struct scsi_cmnd *cmnd)
4697{
4698	u16 hwq;
4699
4700	if (sdebug_host_max_queue) {
4701		/* Provide a simple method to choose the hwq */
4702		hwq = smp_processor_id() % submit_queues;
4703	} else {
4704		u32 tag = blk_mq_unique_tag(cmnd->request);
4705
4706		hwq = blk_mq_unique_tag_to_hwq(tag);
4707
4708		pr_debug("tag=%#x, hwq=%d\n", tag, hwq);
4709		if (WARN_ON_ONCE(hwq >= submit_queues))
4710			hwq = 0;
4711	}
4712	return sdebug_q_arr + hwq;
4713}
4714
4715static u32 get_tag(struct scsi_cmnd *cmnd)
4716{
4717	return blk_mq_unique_tag(cmnd->request);
4718}
4719
4720/* Queued (deferred) command completions converge here. */
4721static void sdebug_q_cmd_complete(struct sdebug_defer *sd_dp)
4722{
4723	bool aborted = sd_dp->aborted;
4724	int qc_idx;
4725	int retiring = 0;
4726	unsigned long iflags;
4727	struct sdebug_queue *sqp;
4728	struct sdebug_queued_cmd *sqcp;
4729	struct scsi_cmnd *scp;
4730	struct sdebug_dev_info *devip;
4731
4732	sd_dp->defer_t = SDEB_DEFER_NONE;
4733	if (unlikely(aborted))
4734		sd_dp->aborted = false;
4735	qc_idx = sd_dp->qc_idx;
4736	sqp = sdebug_q_arr + sd_dp->sqa_idx;
4737	if (sdebug_statistics) {
4738		atomic_inc(&sdebug_completions);
4739		if (raw_smp_processor_id() != sd_dp->issuing_cpu)
4740			atomic_inc(&sdebug_miss_cpus);
4741	}
4742	if (unlikely((qc_idx < 0) || (qc_idx >= SDEBUG_CANQUEUE))) {
4743		pr_err("wild qc_idx=%d\n", qc_idx);
4744		return;
4745	}
4746	spin_lock_irqsave(&sqp->qc_lock, iflags);
4747	sqcp = &sqp->qc_arr[qc_idx];
4748	scp = sqcp->a_cmnd;
4749	if (unlikely(scp == NULL)) {
4750		spin_unlock_irqrestore(&sqp->qc_lock, iflags);
4751		pr_err("scp is NULL, sqa_idx=%d, qc_idx=%d, hc_idx=%d\n",
4752		       sd_dp->sqa_idx, qc_idx, sd_dp->hc_idx);
4753		return;
4754	}
4755	devip = (struct sdebug_dev_info *)scp->device->hostdata;
4756	if (likely(devip))
4757		atomic_dec(&devip->num_in_q);
4758	else
4759		pr_err("devip=NULL\n");
4760	if (unlikely(atomic_read(&retired_max_queue) > 0))
4761		retiring = 1;
4762
4763	sqcp->a_cmnd = NULL;
4764	if (unlikely(!test_and_clear_bit(qc_idx, sqp->in_use_bm))) {
4765		spin_unlock_irqrestore(&sqp->qc_lock, iflags);
4766		pr_err("Unexpected completion\n");
4767		return;
4768	}
4769
4770	if (unlikely(retiring)) {	/* user has reduced max_queue */
4771		int k, retval;
 
 
 
 
4772
4773		retval = atomic_read(&retired_max_queue);
4774		if (qc_idx >= retval) {
4775			spin_unlock_irqrestore(&sqp->qc_lock, iflags);
4776			pr_err("index %d too large\n", retval);
4777			return;
4778		}
4779		k = find_last_bit(sqp->in_use_bm, retval);
4780		if ((k < sdebug_max_queue) || (k == retval))
4781			atomic_set(&retired_max_queue, 0);
4782		else
4783			atomic_set(&retired_max_queue, k + 1);
4784	}
4785	spin_unlock_irqrestore(&sqp->qc_lock, iflags);
4786	if (unlikely(aborted)) {
4787		if (sdebug_verbose)
4788			pr_info("bypassing scsi_done() due to aborted cmd\n");
4789		return;
4790	}
4791	scp->scsi_done(scp); /* callback to mid level */
 
 
 
4792}
4793
4794/* When high resolution timer goes off this function is called. */
4795static enum hrtimer_restart sdebug_q_cmd_hrt_complete(struct hrtimer *timer)
4796{
4797	struct sdebug_defer *sd_dp = container_of(timer, struct sdebug_defer,
4798						  hrt);
4799	sdebug_q_cmd_complete(sd_dp);
4800	return HRTIMER_NORESTART;
4801}
4802
4803/* When work queue schedules work, it calls this function. */
4804static void sdebug_q_cmd_wq_complete(struct work_struct *work)
4805{
4806	struct sdebug_defer *sd_dp = container_of(work, struct sdebug_defer,
4807						  ew.work);
4808	sdebug_q_cmd_complete(sd_dp);
4809}
4810
4811static bool got_shared_uuid;
4812static uuid_t shared_uuid;
4813
4814static int sdebug_device_create_zones(struct sdebug_dev_info *devip)
4815{
4816	struct sdeb_zone_state *zsp;
4817	sector_t capacity = get_sdebug_capacity();
 
4818	sector_t zstart = 0;
4819	unsigned int i;
4820
4821	/*
4822	 * Set the zone size: if sdeb_zbc_zone_size_mb is not set, figure out
4823	 * a zone size allowing for at least 4 zones on the device. Otherwise,
4824	 * use the specified zone size checking that at least 2 zones can be
4825	 * created for the device.
4826	 */
4827	if (!sdeb_zbc_zone_size_mb) {
4828		devip->zsize = (DEF_ZBC_ZONE_SIZE_MB * SZ_1M)
4829			>> ilog2(sdebug_sector_size);
4830		while (capacity < devip->zsize << 2 && devip->zsize >= 2)
4831			devip->zsize >>= 1;
4832		if (devip->zsize < 2) {
4833			pr_err("Device capacity too small\n");
4834			return -EINVAL;
4835		}
4836	} else {
4837		if (!is_power_of_2(sdeb_zbc_zone_size_mb)) {
4838			pr_err("Zone size is not a power of 2\n");
4839			return -EINVAL;
4840		}
4841		devip->zsize = (sdeb_zbc_zone_size_mb * SZ_1M)
4842			>> ilog2(sdebug_sector_size);
4843		if (devip->zsize >= capacity) {
4844			pr_err("Zone size too large for device capacity\n");
4845			return -EINVAL;
4846		}
4847	}
4848
4849	devip->zsize_shift = ilog2(devip->zsize);
4850	devip->nr_zones = (capacity + devip->zsize - 1) >> devip->zsize_shift;
4851
4852	if (sdeb_zbc_nr_conv >= devip->nr_zones) {
 
 
 
 
 
 
 
 
 
 
 
 
4853		pr_err("Number of conventional zones too large\n");
4854		return -EINVAL;
4855	}
4856	devip->nr_conv_zones = sdeb_zbc_nr_conv;
 
 
 
 
 
 
 
4857
4858	if (devip->zmodel == BLK_ZONED_HM) {
4859		/* zbc_max_open_zones can be 0, meaning "not reported" */
4860		if (sdeb_zbc_max_open >= devip->nr_zones - 1)
4861			devip->max_open = (devip->nr_zones - 1) / 2;
4862		else
4863			devip->max_open = sdeb_zbc_max_open;
4864	}
4865
4866	devip->zstate = kcalloc(devip->nr_zones,
4867				sizeof(struct sdeb_zone_state), GFP_KERNEL);
4868	if (!devip->zstate)
4869		return -ENOMEM;
4870
4871	for (i = 0; i < devip->nr_zones; i++) {
4872		zsp = &devip->zstate[i];
4873
4874		zsp->z_start = zstart;
4875
4876		if (i < devip->nr_conv_zones) {
4877			zsp->z_type = ZBC_ZONE_TYPE_CNV;
4878			zsp->z_cond = ZBC_NOT_WRITE_POINTER;
4879			zsp->z_wp = (sector_t)-1;
4880		} else {
4881			if (devip->zmodel == BLK_ZONED_HM)
4882				zsp->z_type = ZBC_ZONE_TYPE_SWR;
 
 
4883			else
4884				zsp->z_type = ZBC_ZONE_TYPE_SWP;
4885			zsp->z_cond = ZC1_EMPTY;
4886			zsp->z_wp = zsp->z_start;
 
 
 
 
 
 
 
 
4887		}
4888
4889		if (zsp->z_start + devip->zsize < capacity)
4890			zsp->z_size = devip->zsize;
4891		else
4892			zsp->z_size = capacity - zsp->z_start;
4893
4894		zstart += zsp->z_size;
4895	}
4896
4897	return 0;
4898}
4899
4900static struct sdebug_dev_info *sdebug_device_create(
4901			struct sdebug_host_info *sdbg_host, gfp_t flags)
4902{
4903	struct sdebug_dev_info *devip;
4904
4905	devip = kzalloc(sizeof(*devip), flags);
4906	if (devip) {
4907		if (sdebug_uuid_ctl == 1)
4908			uuid_gen(&devip->lu_name);
4909		else if (sdebug_uuid_ctl == 2) {
4910			if (got_shared_uuid)
4911				devip->lu_name = shared_uuid;
4912			else {
4913				uuid_gen(&shared_uuid);
4914				got_shared_uuid = true;
4915				devip->lu_name = shared_uuid;
4916			}
4917		}
4918		devip->sdbg_host = sdbg_host;
4919		if (sdeb_zbc_in_use) {
4920			devip->zmodel = sdeb_zbc_model;
4921			if (sdebug_device_create_zones(devip)) {
4922				kfree(devip);
4923				return NULL;
4924			}
4925		} else {
4926			devip->zmodel = BLK_ZONED_NONE;
4927		}
4928		devip->sdbg_host = sdbg_host;
4929		devip->create_ts = ktime_get_boottime();
4930		atomic_set(&devip->stopped, (sdeb_tur_ms_to_ready > 0 ? 2 : 0));
 
 
4931		list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
4932	}
4933	return devip;
4934}
4935
4936static struct sdebug_dev_info *find_build_dev_info(struct scsi_device *sdev)
4937{
4938	struct sdebug_host_info *sdbg_host;
4939	struct sdebug_dev_info *open_devip = NULL;
4940	struct sdebug_dev_info *devip;
4941
4942	sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
4943	if (!sdbg_host) {
4944		pr_err("Host info NULL\n");
4945		return NULL;
4946	}
4947	list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
4948		if ((devip->used) && (devip->channel == sdev->channel) &&
4949		    (devip->target == sdev->id) &&
4950		    (devip->lun == sdev->lun))
4951			return devip;
4952		else {
4953			if ((!devip->used) && (!open_devip))
4954				open_devip = devip;
4955		}
4956	}
4957	if (!open_devip) { /* try and make a new one */
4958		open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC);
4959		if (!open_devip) {
4960			pr_err("out of memory at line %d\n", __LINE__);
4961			return NULL;
4962		}
4963	}
4964
4965	open_devip->channel = sdev->channel;
4966	open_devip->target = sdev->id;
4967	open_devip->lun = sdev->lun;
4968	open_devip->sdbg_host = sdbg_host;
4969	atomic_set(&open_devip->num_in_q, 0);
4970	set_bit(SDEBUG_UA_POR, open_devip->uas_bm);
4971	open_devip->used = true;
4972	return open_devip;
4973}
4974
4975static int scsi_debug_slave_alloc(struct scsi_device *sdp)
4976{
4977	if (sdebug_verbose)
4978		pr_info("slave_alloc <%u %u %u %llu>\n",
4979		       sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
 
4980	return 0;
4981}
4982
4983static int scsi_debug_slave_configure(struct scsi_device *sdp)
4984{
4985	struct sdebug_dev_info *devip =
4986			(struct sdebug_dev_info *)sdp->hostdata;
 
4987
4988	if (sdebug_verbose)
4989		pr_info("slave_configure <%u %u %u %llu>\n",
4990		       sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
4991	if (sdp->host->max_cmd_len != SDEBUG_MAX_CMD_LEN)
4992		sdp->host->max_cmd_len = SDEBUG_MAX_CMD_LEN;
4993	if (devip == NULL) {
4994		devip = find_build_dev_info(sdp);
4995		if (devip == NULL)
4996			return 1;  /* no resources, will be marked offline */
4997	}
4998	sdp->hostdata = devip;
4999	if (sdebug_no_uld)
5000		sdp->no_uld_attach = 1;
5001	config_cdb_len(sdp);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5002	return 0;
5003}
5004
5005static void scsi_debug_slave_destroy(struct scsi_device *sdp)
5006{
5007	struct sdebug_dev_info *devip =
5008		(struct sdebug_dev_info *)sdp->hostdata;
 
5009
5010	if (sdebug_verbose)
5011		pr_info("slave_destroy <%u %u %u %llu>\n",
5012		       sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
5013	if (devip) {
5014		/* make this slot available for re-use */
5015		devip->used = false;
5016		sdp->hostdata = NULL;
 
 
 
 
5017	}
 
 
 
 
 
 
 
5018}
5019
5020static void stop_qc_helper(struct sdebug_defer *sd_dp,
 
5021			   enum sdeb_defer_type defer_t)
5022{
5023	if (!sd_dp)
5024		return;
5025	if (defer_t == SDEB_DEFER_HRT)
5026		hrtimer_cancel(&sd_dp->hrt);
5027	else if (defer_t == SDEB_DEFER_WQ)
5028		cancel_work_sync(&sd_dp->ew.work);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5029}
5030
5031/* If @cmnd found deletes its timer or work queue and returns true; else
5032   returns false */
5033static bool stop_queued_cmnd(struct scsi_cmnd *cmnd)
5034{
5035	unsigned long iflags;
5036	int j, k, qmax, r_qmax;
5037	enum sdeb_defer_type l_defer_t;
5038	struct sdebug_queue *sqp;
5039	struct sdebug_queued_cmd *sqcp;
5040	struct sdebug_dev_info *devip;
5041	struct sdebug_defer *sd_dp;
 
 
5042
5043	for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
5044		spin_lock_irqsave(&sqp->qc_lock, iflags);
5045		qmax = sdebug_max_queue;
5046		r_qmax = atomic_read(&retired_max_queue);
5047		if (r_qmax > qmax)
5048			qmax = r_qmax;
5049		for (k = 0; k < qmax; ++k) {
5050			if (test_bit(k, sqp->in_use_bm)) {
5051				sqcp = &sqp->qc_arr[k];
5052				if (cmnd != sqcp->a_cmnd)
5053					continue;
5054				/* found */
5055				devip = (struct sdebug_dev_info *)
5056						cmnd->device->hostdata;
5057				if (devip)
5058					atomic_dec(&devip->num_in_q);
5059				sqcp->a_cmnd = NULL;
5060				sd_dp = sqcp->sd_dp;
5061				if (sd_dp) {
5062					l_defer_t = sd_dp->defer_t;
5063					sd_dp->defer_t = SDEB_DEFER_NONE;
5064				} else
5065					l_defer_t = SDEB_DEFER_NONE;
5066				spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5067				stop_qc_helper(sd_dp, l_defer_t);
5068				clear_bit(k, sqp->in_use_bm);
5069				return true;
5070			}
5071		}
5072		spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5073	}
5074	return false;
 
 
 
 
 
 
 
5075}
5076
5077/* Deletes (stops) timers or work queues of all queued commands */
5078static void stop_all_queued(void)
5079{
5080	unsigned long iflags;
5081	int j, k;
5082	enum sdeb_defer_type l_defer_t;
5083	struct sdebug_queue *sqp;
5084	struct sdebug_queued_cmd *sqcp;
5085	struct sdebug_dev_info *devip;
5086	struct sdebug_defer *sd_dp;
5087
5088	for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
5089		spin_lock_irqsave(&sqp->qc_lock, iflags);
5090		for (k = 0; k < SDEBUG_CANQUEUE; ++k) {
5091			if (test_bit(k, sqp->in_use_bm)) {
5092				sqcp = &sqp->qc_arr[k];
5093				if (sqcp->a_cmnd == NULL)
5094					continue;
5095				devip = (struct sdebug_dev_info *)
5096					sqcp->a_cmnd->device->hostdata;
5097				if (devip)
5098					atomic_dec(&devip->num_in_q);
5099				sqcp->a_cmnd = NULL;
5100				sd_dp = sqcp->sd_dp;
5101				if (sd_dp) {
5102					l_defer_t = sd_dp->defer_t;
5103					sd_dp->defer_t = SDEB_DEFER_NONE;
5104				} else
5105					l_defer_t = SDEB_DEFER_NONE;
5106				spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5107				stop_qc_helper(sd_dp, l_defer_t);
5108				clear_bit(k, sqp->in_use_bm);
5109				spin_lock_irqsave(&sqp->qc_lock, iflags);
5110			}
5111		}
5112		spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5113	}
 
5114}
5115
5116/* Free queued command memory on heap */
5117static void free_all_queued(void)
5118{
5119	int j, k;
5120	struct sdebug_queue *sqp;
5121	struct sdebug_queued_cmd *sqcp;
 
 
 
 
 
5122
5123	for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
5124		for (k = 0; k < SDEBUG_CANQUEUE; ++k) {
5125			sqcp = &sqp->qc_arr[k];
5126			kfree(sqcp->sd_dp);
5127			sqcp->sd_dp = NULL;
 
 
 
 
 
5128		}
5129	}
 
 
 
5130}
5131
5132static int scsi_debug_abort(struct scsi_cmnd *SCpnt)
5133{
5134	bool ok;
 
 
5135
5136	++num_aborts;
5137	if (SCpnt) {
5138		ok = stop_queued_cmnd(SCpnt);
5139		if (SCpnt->device && (SDEBUG_OPT_ALL_NOISE & sdebug_opts))
5140			sdev_printk(KERN_INFO, SCpnt->device,
5141				    "%s: command%s found\n", __func__,
5142				    ok ? "" : " not");
 
 
 
 
5143	}
 
5144	return SUCCESS;
5145}
5146
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5147static int scsi_debug_device_reset(struct scsi_cmnd *SCpnt)
5148{
 
 
 
 
 
5149	++num_dev_resets;
5150	if (SCpnt && SCpnt->device) {
5151		struct scsi_device *sdp = SCpnt->device;
5152		struct sdebug_dev_info *devip =
5153				(struct sdebug_dev_info *)sdp->hostdata;
5154
5155		if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
5156			sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
5157		if (devip)
5158			set_bit(SDEBUG_UA_POR, devip->uas_bm);
 
 
5159	}
 
5160	return SUCCESS;
5161}
5162
 
 
 
 
 
 
 
 
 
 
 
 
5163static int scsi_debug_target_reset(struct scsi_cmnd *SCpnt)
5164{
5165	struct sdebug_host_info *sdbg_host;
 
5166	struct sdebug_dev_info *devip;
5167	struct scsi_device *sdp;
5168	struct Scsi_Host *hp;
5169	int k = 0;
5170
5171	++num_target_resets;
5172	if (!SCpnt)
5173		goto lie;
5174	sdp = SCpnt->device;
5175	if (!sdp)
5176		goto lie;
5177	if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
5178		sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
5179	hp = sdp->host;
5180	if (!hp)
5181		goto lie;
5182	sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
5183	if (sdbg_host) {
5184		list_for_each_entry(devip,
5185				    &sdbg_host->dev_info_list,
5186				    dev_list)
5187			if (devip->target == sdp->id) {
5188				set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
5189				++k;
5190			}
5191	}
 
5192	if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
5193		sdev_printk(KERN_INFO, sdp,
5194			    "%s: %d device(s) found in target\n", __func__, k);
5195lie:
 
 
 
 
 
 
5196	return SUCCESS;
5197}
5198
5199static int scsi_debug_bus_reset(struct scsi_cmnd *SCpnt)
5200{
5201	struct sdebug_host_info *sdbg_host;
 
5202	struct sdebug_dev_info *devip;
5203	struct scsi_device *sdp;
5204	struct Scsi_Host *hp;
5205	int k = 0;
5206
5207	++num_bus_resets;
5208	if (!(SCpnt && SCpnt->device))
5209		goto lie;
5210	sdp = SCpnt->device;
5211	if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
5212		sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
5213	hp = sdp->host;
5214	if (hp) {
5215		sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
5216		if (sdbg_host) {
5217			list_for_each_entry(devip,
5218					    &sdbg_host->dev_info_list,
5219					    dev_list) {
5220				set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
5221				++k;
5222			}
5223		}
5224	}
 
5225	if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
5226		sdev_printk(KERN_INFO, sdp,
5227			    "%s: %d device(s) found in host\n", __func__, k);
5228lie:
5229	return SUCCESS;
5230}
5231
5232static int scsi_debug_host_reset(struct scsi_cmnd *SCpnt)
5233{
5234	struct sdebug_host_info *sdbg_host;
5235	struct sdebug_dev_info *devip;
5236	int k = 0;
5237
5238	++num_host_resets;
5239	if ((SCpnt->device) && (SDEBUG_OPT_ALL_NOISE & sdebug_opts))
5240		sdev_printk(KERN_INFO, SCpnt->device, "%s\n", __func__);
5241	spin_lock(&sdebug_host_list_lock);
5242	list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
5243		list_for_each_entry(devip, &sdbg_host->dev_info_list,
5244				    dev_list) {
5245			set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
5246			++k;
5247		}
5248	}
5249	spin_unlock(&sdebug_host_list_lock);
5250	stop_all_queued();
5251	if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
5252		sdev_printk(KERN_INFO, SCpnt->device,
5253			    "%s: %d device(s) found\n", __func__, k);
5254	return SUCCESS;
5255}
5256
5257static void sdebug_build_parts(unsigned char *ramp, unsigned long store_size)
5258{
5259	struct msdos_partition *pp;
5260	int starts[SDEBUG_MAX_PARTS + 2];
5261	int sectors_per_part, num_sectors, k;
5262	int heads_by_sects, start_sec, end_sec;
5263
5264	/* assume partition table already zeroed */
5265	if ((sdebug_num_parts < 1) || (store_size < 1048576))
5266		return;
5267	if (sdebug_num_parts > SDEBUG_MAX_PARTS) {
5268		sdebug_num_parts = SDEBUG_MAX_PARTS;
5269		pr_warn("reducing partitions to %d\n", SDEBUG_MAX_PARTS);
5270	}
5271	num_sectors = (int)sdebug_store_sectors;
5272	sectors_per_part = (num_sectors - sdebug_sectors_per)
5273			   / sdebug_num_parts;
5274	heads_by_sects = sdebug_heads * sdebug_sectors_per;
5275	starts[0] = sdebug_sectors_per;
5276	for (k = 1; k < sdebug_num_parts; ++k)
 
5277		starts[k] = ((k * sectors_per_part) / heads_by_sects)
5278			    * heads_by_sects;
 
 
 
5279	starts[sdebug_num_parts] = num_sectors;
5280	starts[sdebug_num_parts + 1] = 0;
5281
5282	ramp[510] = 0x55;	/* magic partition markings */
5283	ramp[511] = 0xAA;
5284	pp = (struct msdos_partition *)(ramp + 0x1be);
5285	for (k = 0; starts[k + 1]; ++k, ++pp) {
5286		start_sec = starts[k];
5287		end_sec = starts[k + 1] - 1;
5288		pp->boot_ind = 0;
5289
5290		pp->cyl = start_sec / heads_by_sects;
5291		pp->head = (start_sec - (pp->cyl * heads_by_sects))
5292			   / sdebug_sectors_per;
5293		pp->sector = (start_sec % sdebug_sectors_per) + 1;
5294
5295		pp->end_cyl = end_sec / heads_by_sects;
5296		pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
5297			       / sdebug_sectors_per;
5298		pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
5299
5300		pp->start_sect = cpu_to_le32(start_sec);
5301		pp->nr_sects = cpu_to_le32(end_sec - start_sec + 1);
5302		pp->sys_ind = 0x83;	/* plain Linux partition */
5303	}
5304}
5305
5306static void block_unblock_all_queues(bool block)
5307{
5308	int j;
5309	struct sdebug_queue *sqp;
5310
5311	for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp)
5312		atomic_set(&sqp->blocked, (int)block);
 
 
 
 
 
 
 
 
5313}
5314
5315/* Adjust (by rounding down) the sdebug_cmnd_count so abs(every_nth)-1
5316 * commands will be processed normally before triggers occur.
5317 */
5318static void tweak_cmnd_count(void)
5319{
5320	int count, modulo;
5321
5322	modulo = abs(sdebug_every_nth);
5323	if (modulo < 2)
5324		return;
 
 
5325	block_unblock_all_queues(true);
5326	count = atomic_read(&sdebug_cmnd_count);
5327	atomic_set(&sdebug_cmnd_count, (count / modulo) * modulo);
5328	block_unblock_all_queues(false);
 
5329}
5330
5331static void clear_queue_stats(void)
5332{
5333	atomic_set(&sdebug_cmnd_count, 0);
5334	atomic_set(&sdebug_completions, 0);
5335	atomic_set(&sdebug_miss_cpus, 0);
5336	atomic_set(&sdebug_a_tsf, 0);
5337}
5338
5339static bool inject_on_this_cmd(void)
5340{
5341	if (sdebug_every_nth == 0)
5342		return false;
5343	return (atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth)) == 0;
5344}
5345
5346#define INCLUSIVE_TIMING_MAX_NS 1000000		/* 1 millisecond */
5347
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5348/* Complete the processing of the thread that queued a SCSI command to this
5349 * driver. It either completes the command by calling cmnd_done() or
5350 * schedules a hr timer or work queue then returns 0. Returns
5351 * SCSI_MLQUEUE_HOST_BUSY if temporarily out of resources.
5352 */
5353static int schedule_resp(struct scsi_cmnd *cmnd, struct sdebug_dev_info *devip,
5354			 int scsi_result,
5355			 int (*pfp)(struct scsi_cmnd *,
5356				    struct sdebug_dev_info *),
5357			 int delta_jiff, int ndelay)
5358{
5359	bool new_sd_dp;
5360	bool inject = false;
5361	int k, num_in_q, qdepth;
5362	unsigned long iflags;
5363	u64 ns_from_boot = 0;
5364	struct sdebug_queue *sqp;
5365	struct sdebug_queued_cmd *sqcp;
5366	struct scsi_device *sdp;
5367	struct sdebug_defer *sd_dp;
5368
5369	if (unlikely(devip == NULL)) {
5370		if (scsi_result == 0)
5371			scsi_result = DID_NO_CONNECT << 16;
5372		goto respond_in_thread;
5373	}
5374	sdp = cmnd->device;
5375
5376	if (delta_jiff == 0)
5377		goto respond_in_thread;
5378
5379	sqp = get_queue(cmnd);
5380	spin_lock_irqsave(&sqp->qc_lock, iflags);
5381	if (unlikely(atomic_read(&sqp->blocked))) {
5382		spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5383		return SCSI_MLQUEUE_HOST_BUSY;
5384	}
5385	num_in_q = atomic_read(&devip->num_in_q);
5386	qdepth = cmnd->device->queue_depth;
5387	if (unlikely((qdepth > 0) && (num_in_q >= qdepth))) {
5388		if (scsi_result) {
5389			spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5390			goto respond_in_thread;
5391		} else
5392			scsi_result = device_qfull_result;
5393	} else if (unlikely(sdebug_every_nth &&
5394			    (SDEBUG_OPT_RARE_TSF & sdebug_opts) &&
5395			    (scsi_result == 0))) {
5396		if ((num_in_q == (qdepth - 1)) &&
5397		    (atomic_inc_return(&sdebug_a_tsf) >=
5398		     abs(sdebug_every_nth))) {
5399			atomic_set(&sdebug_a_tsf, 0);
5400			inject = true;
5401			scsi_result = device_qfull_result;
5402		}
5403	}
5404
5405	k = find_first_zero_bit(sqp->in_use_bm, sdebug_max_queue);
5406	if (unlikely(k >= sdebug_max_queue)) {
5407		spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5408		if (scsi_result)
5409			goto respond_in_thread;
5410		else if (SDEBUG_OPT_ALL_TSF & sdebug_opts)
5411			scsi_result = device_qfull_result;
5412		if (SDEBUG_OPT_Q_NOISE & sdebug_opts)
5413			sdev_printk(KERN_INFO, sdp,
5414				    "%s: max_queue=%d exceeded, %s\n",
5415				    __func__, sdebug_max_queue,
5416				    (scsi_result ?  "status: TASK SET FULL" :
5417						    "report: host busy"));
5418		if (scsi_result)
5419			goto respond_in_thread;
5420		else
5421			return SCSI_MLQUEUE_HOST_BUSY;
5422	}
5423	set_bit(k, sqp->in_use_bm);
5424	atomic_inc(&devip->num_in_q);
5425	sqcp = &sqp->qc_arr[k];
5426	sqcp->a_cmnd = cmnd;
5427	cmnd->host_scribble = (unsigned char *)sqcp;
5428	sd_dp = sqcp->sd_dp;
5429	spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5430	if (!sd_dp) {
5431		sd_dp = kzalloc(sizeof(*sd_dp), GFP_ATOMIC);
5432		if (!sd_dp) {
5433			atomic_dec(&devip->num_in_q);
5434			clear_bit(k, sqp->in_use_bm);
5435			return SCSI_MLQUEUE_HOST_BUSY;
5436		}
5437		new_sd_dp = true;
5438	} else {
5439		new_sd_dp = false;
5440	}
5441
5442	/* Set the hostwide tag */
5443	if (sdebug_host_max_queue)
5444		sd_dp->hc_idx = get_tag(cmnd);
 
 
 
5445
5446	if (ndelay > 0 && ndelay < INCLUSIVE_TIMING_MAX_NS)
5447		ns_from_boot = ktime_get_boottime_ns();
5448
5449	/* one of the resp_*() response functions is called here */
5450	cmnd->result = pfp ? pfp(cmnd, devip) : 0;
5451	if (cmnd->result & SDEG_RES_IMMED_MASK) {
5452		cmnd->result &= ~SDEG_RES_IMMED_MASK;
5453		delta_jiff = ndelay = 0;
5454	}
5455	if (cmnd->result == 0 && scsi_result != 0)
5456		cmnd->result = scsi_result;
5457	if (cmnd->result == 0 && unlikely(sdebug_opts & SDEBUG_OPT_TRANSPORT_ERR)) {
5458		if (atomic_read(&sdeb_inject_pending)) {
5459			mk_sense_buffer(cmnd, ABORTED_COMMAND, TRANSPORT_PROBLEM, ACK_NAK_TO);
5460			atomic_set(&sdeb_inject_pending, 0);
5461			cmnd->result = check_condition_result;
5462		}
5463	}
5464
5465	if (unlikely(sdebug_verbose && cmnd->result))
5466		sdev_printk(KERN_INFO, sdp, "%s: non-zero result=0x%x\n",
5467			    __func__, cmnd->result);
5468
5469	if (delta_jiff > 0 || ndelay > 0) {
5470		ktime_t kt;
5471
5472		if (delta_jiff > 0) {
5473			u64 ns = jiffies_to_nsecs(delta_jiff);
5474
5475			if (sdebug_random && ns < U32_MAX) {
5476				ns = prandom_u32_max((u32)ns);
5477			} else if (sdebug_random) {
5478				ns >>= 12;	/* scale to 4 usec precision */
5479				if (ns < U32_MAX)	/* over 4 hours max */
5480					ns = prandom_u32_max((u32)ns);
5481				ns <<= 12;
5482			}
5483			kt = ns_to_ktime(ns);
5484		} else {	/* ndelay has a 4.2 second max */
5485			kt = sdebug_random ? prandom_u32_max((u32)ndelay) :
5486					     (u32)ndelay;
5487			if (ndelay < INCLUSIVE_TIMING_MAX_NS) {
5488				u64 d = ktime_get_boottime_ns() - ns_from_boot;
5489
5490				if (kt <= d) {	/* elapsed duration >= kt */
5491					spin_lock_irqsave(&sqp->qc_lock, iflags);
5492					sqcp->a_cmnd = NULL;
5493					atomic_dec(&devip->num_in_q);
5494					clear_bit(k, sqp->in_use_bm);
5495					spin_unlock_irqrestore(&sqp->qc_lock, iflags);
5496					if (new_sd_dp)
5497						kfree(sd_dp);
5498					/* call scsi_done() from this thread */
5499					cmnd->scsi_done(cmnd);
 
5500					return 0;
5501				}
5502				/* otherwise reduce kt by elapsed time */
5503				kt -= d;
5504			}
5505		}
5506		if (!sd_dp->init_hrt) {
5507			sd_dp->init_hrt = true;
5508			sqcp->sd_dp = sd_dp;
5509			hrtimer_init(&sd_dp->hrt, CLOCK_MONOTONIC,
5510				     HRTIMER_MODE_REL_PINNED);
5511			sd_dp->hrt.function = sdebug_q_cmd_hrt_complete;
5512			sd_dp->sqa_idx = sqp - sdebug_q_arr;
5513			sd_dp->qc_idx = k;
5514		}
5515		if (sdebug_statistics)
5516			sd_dp->issuing_cpu = raw_smp_processor_id();
5517		sd_dp->defer_t = SDEB_DEFER_HRT;
5518		/* schedule the invocation of scsi_done() for a later time */
5519		hrtimer_start(&sd_dp->hrt, kt, HRTIMER_MODE_REL_PINNED);
5520	} else {	/* jdelay < 0, use work queue */
5521		if (!sd_dp->init_wq) {
5522			sd_dp->init_wq = true;
5523			sqcp->sd_dp = sd_dp;
5524			sd_dp->sqa_idx = sqp - sdebug_q_arr;
5525			sd_dp->qc_idx = k;
5526			INIT_WORK(&sd_dp->ew.work, sdebug_q_cmd_wq_complete);
 
 
 
 
 
 
 
 
 
5527		}
5528		if (sdebug_statistics)
5529			sd_dp->issuing_cpu = raw_smp_processor_id();
5530		sd_dp->defer_t = SDEB_DEFER_WQ;
5531		if (unlikely((sdebug_opts & SDEBUG_OPT_CMD_ABORT) &&
5532			     atomic_read(&sdeb_inject_pending)))
5533			sd_dp->aborted = true;
5534		schedule_work(&sd_dp->ew.work);
5535		if (unlikely((sdebug_opts & SDEBUG_OPT_CMD_ABORT) &&
5536			     atomic_read(&sdeb_inject_pending))) {
5537			sdev_printk(KERN_INFO, sdp, "abort request tag %d\n", cmnd->request->tag);
5538			blk_abort_request(cmnd->request);
5539			atomic_set(&sdeb_inject_pending, 0);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5540		}
5541	}
5542	if (unlikely((SDEBUG_OPT_Q_NOISE & sdebug_opts) && scsi_result == device_qfull_result))
5543		sdev_printk(KERN_INFO, sdp, "%s: num_in_q=%d +1, %s%s\n", __func__,
5544			    num_in_q, (inject ? "<inject> " : ""), "status: TASK SET FULL");
5545	return 0;
5546
5547respond_in_thread:	/* call back to mid-layer using invocation thread */
5548	cmnd->result = pfp != NULL ? pfp(cmnd, devip) : 0;
5549	cmnd->result &= ~SDEG_RES_IMMED_MASK;
5550	if (cmnd->result == 0 && scsi_result != 0)
5551		cmnd->result = scsi_result;
5552	cmnd->scsi_done(cmnd);
5553	return 0;
5554}
5555
5556/* Note: The following macros create attribute files in the
5557   /sys/module/scsi_debug/parameters directory. Unfortunately this
5558   driver is unaware of a change and cannot trigger auxiliary actions
5559   as it can when the corresponding attribute in the
5560   /sys/bus/pseudo/drivers/scsi_debug directory is changed.
5561 */
5562module_param_named(add_host, sdebug_add_host, int, S_IRUGO | S_IWUSR);
5563module_param_named(ato, sdebug_ato, int, S_IRUGO);
5564module_param_named(cdb_len, sdebug_cdb_len, int, 0644);
5565module_param_named(clustering, sdebug_clustering, bool, S_IRUGO | S_IWUSR);
5566module_param_named(delay, sdebug_jdelay, int, S_IRUGO | S_IWUSR);
5567module_param_named(dev_size_mb, sdebug_dev_size_mb, int, S_IRUGO);
5568module_param_named(dif, sdebug_dif, int, S_IRUGO);
5569module_param_named(dix, sdebug_dix, int, S_IRUGO);
5570module_param_named(dsense, sdebug_dsense, int, S_IRUGO | S_IWUSR);
5571module_param_named(every_nth, sdebug_every_nth, int, S_IRUGO | S_IWUSR);
5572module_param_named(fake_rw, sdebug_fake_rw, int, S_IRUGO | S_IWUSR);
5573module_param_named(guard, sdebug_guard, uint, S_IRUGO);
5574module_param_named(host_lock, sdebug_host_lock, bool, S_IRUGO | S_IWUSR);
5575module_param_named(host_max_queue, sdebug_host_max_queue, int, S_IRUGO);
5576module_param_string(inq_product, sdebug_inq_product_id,
5577		    sizeof(sdebug_inq_product_id), S_IRUGO | S_IWUSR);
5578module_param_string(inq_rev, sdebug_inq_product_rev,
5579		    sizeof(sdebug_inq_product_rev), S_IRUGO | S_IWUSR);
5580module_param_string(inq_vendor, sdebug_inq_vendor_id,
5581		    sizeof(sdebug_inq_vendor_id), S_IRUGO | S_IWUSR);
5582module_param_named(lbprz, sdebug_lbprz, int, S_IRUGO);
5583module_param_named(lbpu, sdebug_lbpu, int, S_IRUGO);
5584module_param_named(lbpws, sdebug_lbpws, int, S_IRUGO);
5585module_param_named(lbpws10, sdebug_lbpws10, int, S_IRUGO);
5586module_param_named(lowest_aligned, sdebug_lowest_aligned, int, S_IRUGO);
 
5587module_param_named(max_luns, sdebug_max_luns, int, S_IRUGO | S_IWUSR);
5588module_param_named(max_queue, sdebug_max_queue, int, S_IRUGO | S_IWUSR);
5589module_param_named(medium_error_count, sdebug_medium_error_count, int,
5590		   S_IRUGO | S_IWUSR);
5591module_param_named(medium_error_start, sdebug_medium_error_start, int,
5592		   S_IRUGO | S_IWUSR);
5593module_param_named(ndelay, sdebug_ndelay, int, S_IRUGO | S_IWUSR);
5594module_param_named(no_lun_0, sdebug_no_lun_0, int, S_IRUGO | S_IWUSR);
 
5595module_param_named(no_uld, sdebug_no_uld, int, S_IRUGO);
5596module_param_named(num_parts, sdebug_num_parts, int, S_IRUGO);
5597module_param_named(num_tgts, sdebug_num_tgts, int, S_IRUGO | S_IWUSR);
5598module_param_named(opt_blks, sdebug_opt_blks, int, S_IRUGO);
5599module_param_named(opt_xferlen_exp, sdebug_opt_xferlen_exp, int, S_IRUGO);
5600module_param_named(opts, sdebug_opts, int, S_IRUGO | S_IWUSR);
5601module_param_named(per_host_store, sdebug_per_host_store, bool,
5602		   S_IRUGO | S_IWUSR);
5603module_param_named(physblk_exp, sdebug_physblk_exp, int, S_IRUGO);
5604module_param_named(ptype, sdebug_ptype, int, S_IRUGO | S_IWUSR);
5605module_param_named(random, sdebug_random, bool, S_IRUGO | S_IWUSR);
5606module_param_named(removable, sdebug_removable, bool, S_IRUGO | S_IWUSR);
5607module_param_named(scsi_level, sdebug_scsi_level, int, S_IRUGO);
5608module_param_named(sector_size, sdebug_sector_size, int, S_IRUGO);
5609module_param_named(statistics, sdebug_statistics, bool, S_IRUGO | S_IWUSR);
5610module_param_named(strict, sdebug_strict, bool, S_IRUGO | S_IWUSR);
5611module_param_named(submit_queues, submit_queues, int, S_IRUGO);
 
5612module_param_named(tur_ms_to_ready, sdeb_tur_ms_to_ready, int, S_IRUGO);
5613module_param_named(unmap_alignment, sdebug_unmap_alignment, int, S_IRUGO);
5614module_param_named(unmap_granularity, sdebug_unmap_granularity, int, S_IRUGO);
5615module_param_named(unmap_max_blocks, sdebug_unmap_max_blocks, int, S_IRUGO);
5616module_param_named(unmap_max_desc, sdebug_unmap_max_desc, int, S_IRUGO);
5617module_param_named(uuid_ctl, sdebug_uuid_ctl, int, S_IRUGO);
5618module_param_named(virtual_gb, sdebug_virtual_gb, int, S_IRUGO | S_IWUSR);
5619module_param_named(vpd_use_hostno, sdebug_vpd_use_hostno, int,
5620		   S_IRUGO | S_IWUSR);
5621module_param_named(wp, sdebug_wp, bool, S_IRUGO | S_IWUSR);
5622module_param_named(write_same_length, sdebug_write_same_length, int,
5623		   S_IRUGO | S_IWUSR);
5624module_param_named(zbc, sdeb_zbc_model_s, charp, S_IRUGO);
 
5625module_param_named(zone_max_open, sdeb_zbc_max_open, int, S_IRUGO);
5626module_param_named(zone_nr_conv, sdeb_zbc_nr_conv, int, S_IRUGO);
5627module_param_named(zone_size_mb, sdeb_zbc_zone_size_mb, int, S_IRUGO);
 
5628
5629MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
5630MODULE_DESCRIPTION("SCSI debug adapter driver");
5631MODULE_LICENSE("GPL");
5632MODULE_VERSION(SDEBUG_VERSION);
5633
5634MODULE_PARM_DESC(add_host, "add n hosts, in sysfs if negative remove host(s) (def=1)");
5635MODULE_PARM_DESC(ato, "application tag ownership: 0=disk 1=host (def=1)");
5636MODULE_PARM_DESC(cdb_len, "suggest CDB lengths to drivers (def=10)");
5637MODULE_PARM_DESC(clustering, "when set enables larger transfers (def=0)");
5638MODULE_PARM_DESC(delay, "response delay (def=1 jiffy); 0:imm, -1,-2:tiny");
5639MODULE_PARM_DESC(dev_size_mb, "size in MiB of ram shared by devs(def=8)");
5640MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)");
5641MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)");
5642MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
5643MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
5644MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
5645MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");
5646MODULE_PARM_DESC(host_lock, "host_lock is ignored (def=0)");
5647MODULE_PARM_DESC(host_max_queue,
5648		 "host max # of queued cmds (0 to max(def) [max_queue fixed equal for !0])");
5649MODULE_PARM_DESC(inq_product, "SCSI INQUIRY product string (def=\"scsi_debug\")");
5650MODULE_PARM_DESC(inq_rev, "SCSI INQUIRY revision string (def=\""
5651		 SDEBUG_VERSION "\")");
5652MODULE_PARM_DESC(inq_vendor, "SCSI INQUIRY vendor string (def=\"Linux\")");
5653MODULE_PARM_DESC(lbprz,
5654		 "on read unmapped LBs return 0 when 1 (def), return 0xff when 2");
5655MODULE_PARM_DESC(lbpu, "enable LBP, support UNMAP command (def=0)");
5656MODULE_PARM_DESC(lbpws, "enable LBP, support WRITE SAME(16) with UNMAP bit (def=0)");
5657MODULE_PARM_DESC(lbpws10, "enable LBP, support WRITE SAME(10) with UNMAP bit (def=0)");
5658MODULE_PARM_DESC(lowest_aligned, "lowest aligned lba (def=0)");
 
5659MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
5660MODULE_PARM_DESC(max_queue, "max number of queued commands (1 to max(def))");
5661MODULE_PARM_DESC(medium_error_count, "count of sectors to return follow on MEDIUM error");
5662MODULE_PARM_DESC(medium_error_start, "starting sector number to return MEDIUM error");
5663MODULE_PARM_DESC(ndelay, "response delay in nanoseconds (def=0 -> ignore)");
5664MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
 
5665MODULE_PARM_DESC(no_uld, "stop ULD (e.g. sd driver) attaching (def=0))");
5666MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
5667MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
5668MODULE_PARM_DESC(opt_blks, "optimal transfer length in blocks (def=1024)");
5669MODULE_PARM_DESC(opt_xferlen_exp, "optimal transfer length granularity exponent (def=physblk_exp)");
5670MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
5671MODULE_PARM_DESC(per_host_store, "If set, next positive add_host will get new store (def=0)");
5672MODULE_PARM_DESC(physblk_exp, "physical block exponent (def=0)");
 
5673MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
5674MODULE_PARM_DESC(random, "If set, uniformly randomize command duration between 0 and delay_in_ns");
5675MODULE_PARM_DESC(removable, "claim to have removable media (def=0)");
5676MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=7[SPC-5])");
5677MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)");
5678MODULE_PARM_DESC(statistics, "collect statistics on commands, queues (def=0)");
5679MODULE_PARM_DESC(strict, "stricter checks: reserved field in cdb (def=0)");
5680MODULE_PARM_DESC(submit_queues, "support for block multi-queue (def=1)");
5681MODULE_PARM_DESC(tur_ms_to_ready, "TEST UNIT READY millisecs before initial good status (def=0)");
5682MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)");
5683MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=1)");
5684MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0xffffffff)");
5685MODULE_PARM_DESC(unmap_max_desc, "max # of ranges that can be unmapped in one cmd (def=256)");
5686MODULE_PARM_DESC(uuid_ctl,
5687		 "1->use uuid for lu name, 0->don't, 2->all use same (def=0)");
5688MODULE_PARM_DESC(virtual_gb, "virtual gigabyte (GiB) size (def=0 -> use dev_size_mb)");
5689MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
5690MODULE_PARM_DESC(wp, "Write Protect (def=0)");
5691MODULE_PARM_DESC(write_same_length, "Maximum blocks per WRITE SAME cmd (def=0xffff)");
5692MODULE_PARM_DESC(zbc, "'none' [0]; 'aware' [1]; 'managed' [2] (def=0). Can have 'host-' prefix");
 
5693MODULE_PARM_DESC(zone_max_open, "Maximum number of open zones; [0] for no limit (def=auto)");
5694MODULE_PARM_DESC(zone_nr_conv, "Number of conventional zones (def=1)");
5695MODULE_PARM_DESC(zone_size_mb, "Zone size in MiB (def=auto)");
 
5696
5697#define SDEBUG_INFO_LEN 256
5698static char sdebug_info[SDEBUG_INFO_LEN];
5699
5700static const char *scsi_debug_info(struct Scsi_Host *shp)
5701{
5702	int k;
5703
5704	k = scnprintf(sdebug_info, SDEBUG_INFO_LEN, "%s: version %s [%s]\n",
5705		      my_name, SDEBUG_VERSION, sdebug_version_date);
5706	if (k >= (SDEBUG_INFO_LEN - 1))
5707		return sdebug_info;
5708	scnprintf(sdebug_info + k, SDEBUG_INFO_LEN - k,
5709		  "  dev_size_mb=%d, opts=0x%x, submit_queues=%d, %s=%d",
5710		  sdebug_dev_size_mb, sdebug_opts, submit_queues,
5711		  "statistics", (int)sdebug_statistics);
5712	return sdebug_info;
5713}
5714
5715/* 'echo <val> > /proc/scsi/scsi_debug/<host_id>' writes to opts */
5716static int scsi_debug_write_info(struct Scsi_Host *host, char *buffer,
5717				 int length)
5718{
5719	char arr[16];
5720	int opts;
5721	int minLen = length > 15 ? 15 : length;
5722
5723	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
5724		return -EACCES;
5725	memcpy(arr, buffer, minLen);
5726	arr[minLen] = '\0';
5727	if (1 != sscanf(arr, "%d", &opts))
5728		return -EINVAL;
5729	sdebug_opts = opts;
5730	sdebug_verbose = !!(SDEBUG_OPT_NOISE & opts);
5731	sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & opts);
5732	if (sdebug_every_nth != 0)
5733		tweak_cmnd_count();
5734	return length;
5735}
5736
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5737/* Output seen with 'cat /proc/scsi/scsi_debug/<host_id>'. It will be the
5738 * same for each scsi_debug host (if more than one). Some of the counters
5739 * output are not atomics so might be inaccurate in a busy system. */
5740static int scsi_debug_show_info(struct seq_file *m, struct Scsi_Host *host)
5741{
5742	int f, j, l;
5743	struct sdebug_queue *sqp;
5744	struct sdebug_host_info *sdhp;
 
5745
5746	seq_printf(m, "scsi_debug adapter driver, version %s [%s]\n",
5747		   SDEBUG_VERSION, sdebug_version_date);
5748	seq_printf(m, "num_tgts=%d, %ssize=%d MB, opts=0x%x, every_nth=%d\n",
5749		   sdebug_num_tgts, "shared (ram) ", sdebug_dev_size_mb,
5750		   sdebug_opts, sdebug_every_nth);
5751	seq_printf(m, "delay=%d, ndelay=%d, max_luns=%d, sector_size=%d %s\n",
5752		   sdebug_jdelay, sdebug_ndelay, sdebug_max_luns,
5753		   sdebug_sector_size, "bytes");
5754	seq_printf(m, "cylinders=%d, heads=%d, sectors=%d, command aborts=%d\n",
5755		   sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
5756		   num_aborts);
5757	seq_printf(m, "RESETs: device=%d, target=%d, bus=%d, host=%d\n",
5758		   num_dev_resets, num_target_resets, num_bus_resets,
5759		   num_host_resets);
5760	seq_printf(m, "dix_reads=%d, dix_writes=%d, dif_errors=%d\n",
5761		   dix_reads, dix_writes, dif_errors);
5762	seq_printf(m, "usec_in_jiffy=%lu, statistics=%d\n", TICK_NSEC / 1000,
5763		   sdebug_statistics);
5764	seq_printf(m, "cmnd_count=%d, completions=%d, %s=%d, a_tsf=%d\n",
5765		   atomic_read(&sdebug_cmnd_count),
5766		   atomic_read(&sdebug_completions),
5767		   "miss_cpus", atomic_read(&sdebug_miss_cpus),
5768		   atomic_read(&sdebug_a_tsf));
 
5769
5770	seq_printf(m, "submit_queues=%d\n", submit_queues);
5771	for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
 
 
 
 
 
 
5772		seq_printf(m, "  queue %d:\n", j);
5773		f = find_first_bit(sqp->in_use_bm, sdebug_max_queue);
5774		if (f != sdebug_max_queue) {
5775			l = find_last_bit(sqp->in_use_bm, sdebug_max_queue);
5776			seq_printf(m, "    in_use_bm BUSY: %s: %d,%d\n",
5777				   "first,last bits", f, l);
5778		}
5779	}
5780
5781	seq_printf(m, "this host_no=%d\n", host->host_no);
5782	if (!xa_empty(per_store_ap)) {
5783		bool niu;
5784		int idx;
5785		unsigned long l_idx;
5786		struct sdeb_store_info *sip;
5787
5788		seq_puts(m, "\nhost list:\n");
5789		j = 0;
5790		list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
5791			idx = sdhp->si_idx;
5792			seq_printf(m, "  %d: host_no=%d, si_idx=%d\n", j,
5793				   sdhp->shost->host_no, idx);
5794			++j;
5795		}
5796		seq_printf(m, "\nper_store array [most_recent_idx=%d]:\n",
5797			   sdeb_most_recent_idx);
5798		j = 0;
5799		xa_for_each(per_store_ap, l_idx, sip) {
5800			niu = xa_get_mark(per_store_ap, l_idx,
5801					  SDEB_XA_NOT_IN_USE);
5802			idx = (int)l_idx;
5803			seq_printf(m, "  %d: idx=%d%s\n", j, idx,
5804				   (niu ? "  not_in_use" : ""));
5805			++j;
5806		}
5807	}
5808	return 0;
5809}
5810
5811static ssize_t delay_show(struct device_driver *ddp, char *buf)
5812{
5813	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_jdelay);
5814}
5815/* Returns -EBUSY if jdelay is being changed and commands are queued. The unit
5816 * of delay is jiffies.
5817 */
5818static ssize_t delay_store(struct device_driver *ddp, const char *buf,
5819			   size_t count)
5820{
5821	int jdelay, res;
5822
5823	if (count > 0 && sscanf(buf, "%d", &jdelay) == 1) {
5824		res = count;
5825		if (sdebug_jdelay != jdelay) {
5826			int j, k;
5827			struct sdebug_queue *sqp;
5828
 
5829			block_unblock_all_queues(true);
5830			for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
5831			     ++j, ++sqp) {
5832				k = find_first_bit(sqp->in_use_bm,
5833						   sdebug_max_queue);
5834				if (k != sdebug_max_queue) {
5835					res = -EBUSY;   /* queued commands */
5836					break;
5837				}
5838			}
5839			if (res > 0) {
5840				sdebug_jdelay = jdelay;
5841				sdebug_ndelay = 0;
5842			}
5843			block_unblock_all_queues(false);
 
5844		}
5845		return res;
5846	}
5847	return -EINVAL;
5848}
5849static DRIVER_ATTR_RW(delay);
5850
5851static ssize_t ndelay_show(struct device_driver *ddp, char *buf)
5852{
5853	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ndelay);
5854}
5855/* Returns -EBUSY if ndelay is being changed and commands are queued */
5856/* If > 0 and accepted then sdebug_jdelay is set to JDELAY_OVERRIDDEN */
5857static ssize_t ndelay_store(struct device_driver *ddp, const char *buf,
5858			    size_t count)
5859{
5860	int ndelay, res;
5861
5862	if ((count > 0) && (1 == sscanf(buf, "%d", &ndelay)) &&
5863	    (ndelay >= 0) && (ndelay < (1000 * 1000 * 1000))) {
5864		res = count;
5865		if (sdebug_ndelay != ndelay) {
5866			int j, k;
5867			struct sdebug_queue *sqp;
5868
 
5869			block_unblock_all_queues(true);
5870			for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
5871			     ++j, ++sqp) {
5872				k = find_first_bit(sqp->in_use_bm,
5873						   sdebug_max_queue);
5874				if (k != sdebug_max_queue) {
5875					res = -EBUSY;   /* queued commands */
5876					break;
5877				}
5878			}
 
5879			if (res > 0) {
5880				sdebug_ndelay = ndelay;
5881				sdebug_jdelay = ndelay  ? JDELAY_OVERRIDDEN
5882							: DEF_JDELAY;
5883			}
5884			block_unblock_all_queues(false);
 
5885		}
5886		return res;
5887	}
5888	return -EINVAL;
5889}
5890static DRIVER_ATTR_RW(ndelay);
5891
5892static ssize_t opts_show(struct device_driver *ddp, char *buf)
5893{
5894	return scnprintf(buf, PAGE_SIZE, "0x%x\n", sdebug_opts);
5895}
5896
5897static ssize_t opts_store(struct device_driver *ddp, const char *buf,
5898			  size_t count)
5899{
5900	int opts;
5901	char work[20];
5902
5903	if (sscanf(buf, "%10s", work) == 1) {
5904		if (strncasecmp(work, "0x", 2) == 0) {
5905			if (kstrtoint(work + 2, 16, &opts) == 0)
5906				goto opts_done;
5907		} else {
5908			if (kstrtoint(work, 10, &opts) == 0)
5909				goto opts_done;
5910		}
5911	}
5912	return -EINVAL;
5913opts_done:
5914	sdebug_opts = opts;
5915	sdebug_verbose = !!(SDEBUG_OPT_NOISE & opts);
5916	sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & opts);
5917	tweak_cmnd_count();
5918	return count;
5919}
5920static DRIVER_ATTR_RW(opts);
5921
5922static ssize_t ptype_show(struct device_driver *ddp, char *buf)
5923{
5924	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ptype);
5925}
5926static ssize_t ptype_store(struct device_driver *ddp, const char *buf,
5927			   size_t count)
5928{
5929	int n;
5930
5931	/* Cannot change from or to TYPE_ZBC with sysfs */
5932	if (sdebug_ptype == TYPE_ZBC)
5933		return -EINVAL;
5934
5935	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
5936		if (n == TYPE_ZBC)
5937			return -EINVAL;
5938		sdebug_ptype = n;
5939		return count;
5940	}
5941	return -EINVAL;
5942}
5943static DRIVER_ATTR_RW(ptype);
5944
5945static ssize_t dsense_show(struct device_driver *ddp, char *buf)
5946{
5947	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dsense);
5948}
5949static ssize_t dsense_store(struct device_driver *ddp, const char *buf,
5950			    size_t count)
5951{
5952	int n;
5953
5954	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
5955		sdebug_dsense = n;
5956		return count;
5957	}
5958	return -EINVAL;
5959}
5960static DRIVER_ATTR_RW(dsense);
5961
5962static ssize_t fake_rw_show(struct device_driver *ddp, char *buf)
5963{
5964	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_fake_rw);
5965}
5966static ssize_t fake_rw_store(struct device_driver *ddp, const char *buf,
5967			     size_t count)
5968{
5969	int n, idx;
5970
5971	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
5972		bool want_store = (n == 0);
5973		struct sdebug_host_info *sdhp;
5974
5975		n = (n > 0);
5976		sdebug_fake_rw = (sdebug_fake_rw > 0);
5977		if (sdebug_fake_rw == n)
5978			return count;	/* not transitioning so do nothing */
5979
5980		if (want_store) {	/* 1 --> 0 transition, set up store */
5981			if (sdeb_first_idx < 0) {
5982				idx = sdebug_add_store();
5983				if (idx < 0)
5984					return idx;
5985			} else {
5986				idx = sdeb_first_idx;
5987				xa_clear_mark(per_store_ap, idx,
5988					      SDEB_XA_NOT_IN_USE);
5989			}
5990			/* make all hosts use same store */
5991			list_for_each_entry(sdhp, &sdebug_host_list,
5992					    host_list) {
5993				if (sdhp->si_idx != idx) {
5994					xa_set_mark(per_store_ap, sdhp->si_idx,
5995						    SDEB_XA_NOT_IN_USE);
5996					sdhp->si_idx = idx;
5997				}
5998			}
5999			sdeb_most_recent_idx = idx;
6000		} else {	/* 0 --> 1 transition is trigger for shrink */
6001			sdebug_erase_all_stores(true /* apart from first */);
6002		}
6003		sdebug_fake_rw = n;
6004		return count;
6005	}
6006	return -EINVAL;
6007}
6008static DRIVER_ATTR_RW(fake_rw);
6009
6010static ssize_t no_lun_0_show(struct device_driver *ddp, char *buf)
6011{
6012	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_lun_0);
6013}
6014static ssize_t no_lun_0_store(struct device_driver *ddp, const char *buf,
6015			      size_t count)
6016{
6017	int n;
6018
6019	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6020		sdebug_no_lun_0 = n;
6021		return count;
6022	}
6023	return -EINVAL;
6024}
6025static DRIVER_ATTR_RW(no_lun_0);
6026
6027static ssize_t num_tgts_show(struct device_driver *ddp, char *buf)
6028{
6029	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_tgts);
6030}
6031static ssize_t num_tgts_store(struct device_driver *ddp, const char *buf,
6032			      size_t count)
6033{
6034	int n;
6035
6036	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6037		sdebug_num_tgts = n;
6038		sdebug_max_tgts_luns();
6039		return count;
6040	}
6041	return -EINVAL;
6042}
6043static DRIVER_ATTR_RW(num_tgts);
6044
6045static ssize_t dev_size_mb_show(struct device_driver *ddp, char *buf)
6046{
6047	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dev_size_mb);
6048}
6049static DRIVER_ATTR_RO(dev_size_mb);
6050
6051static ssize_t per_host_store_show(struct device_driver *ddp, char *buf)
6052{
6053	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_per_host_store);
6054}
6055
6056static ssize_t per_host_store_store(struct device_driver *ddp, const char *buf,
6057				    size_t count)
6058{
6059	bool v;
6060
6061	if (kstrtobool(buf, &v))
6062		return -EINVAL;
6063
6064	sdebug_per_host_store = v;
6065	return count;
6066}
6067static DRIVER_ATTR_RW(per_host_store);
6068
6069static ssize_t num_parts_show(struct device_driver *ddp, char *buf)
6070{
6071	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_parts);
6072}
6073static DRIVER_ATTR_RO(num_parts);
6074
6075static ssize_t every_nth_show(struct device_driver *ddp, char *buf)
6076{
6077	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_every_nth);
6078}
6079static ssize_t every_nth_store(struct device_driver *ddp, const char *buf,
6080			       size_t count)
6081{
6082	int nth;
6083	char work[20];
6084
6085	if (sscanf(buf, "%10s", work) == 1) {
6086		if (strncasecmp(work, "0x", 2) == 0) {
6087			if (kstrtoint(work + 2, 16, &nth) == 0)
6088				goto every_nth_done;
6089		} else {
6090			if (kstrtoint(work, 10, &nth) == 0)
6091				goto every_nth_done;
6092		}
6093	}
6094	return -EINVAL;
6095
6096every_nth_done:
6097	sdebug_every_nth = nth;
6098	if (nth && !sdebug_statistics) {
6099		pr_info("every_nth needs statistics=1, set it\n");
6100		sdebug_statistics = true;
6101	}
6102	tweak_cmnd_count();
6103	return count;
6104}
6105static DRIVER_ATTR_RW(every_nth);
6106
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6107static ssize_t max_luns_show(struct device_driver *ddp, char *buf)
6108{
6109	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_max_luns);
6110}
6111static ssize_t max_luns_store(struct device_driver *ddp, const char *buf,
6112			      size_t count)
6113{
6114	int n;
6115	bool changed;
6116
6117	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6118		if (n > 256) {
6119			pr_warn("max_luns can be no more than 256\n");
6120			return -EINVAL;
6121		}
6122		changed = (sdebug_max_luns != n);
6123		sdebug_max_luns = n;
6124		sdebug_max_tgts_luns();
6125		if (changed && (sdebug_scsi_level >= 5)) {	/* >= SPC-3 */
6126			struct sdebug_host_info *sdhp;
6127			struct sdebug_dev_info *dp;
6128
6129			spin_lock(&sdebug_host_list_lock);
6130			list_for_each_entry(sdhp, &sdebug_host_list,
6131					    host_list) {
6132				list_for_each_entry(dp, &sdhp->dev_info_list,
6133						    dev_list) {
6134					set_bit(SDEBUG_UA_LUNS_CHANGED,
6135						dp->uas_bm);
6136				}
6137			}
6138			spin_unlock(&sdebug_host_list_lock);
6139		}
6140		return count;
6141	}
6142	return -EINVAL;
6143}
6144static DRIVER_ATTR_RW(max_luns);
6145
6146static ssize_t max_queue_show(struct device_driver *ddp, char *buf)
6147{
6148	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_max_queue);
6149}
6150/* N.B. max_queue can be changed while there are queued commands. In flight
6151 * commands beyond the new max_queue will be completed. */
6152static ssize_t max_queue_store(struct device_driver *ddp, const char *buf,
6153			       size_t count)
6154{
6155	int j, n, k, a;
6156	struct sdebug_queue *sqp;
6157
6158	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n > 0) &&
6159	    (n <= SDEBUG_CANQUEUE) &&
6160	    (sdebug_host_max_queue == 0)) {
6161		block_unblock_all_queues(true);
6162		k = 0;
6163		for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
6164		     ++j, ++sqp) {
6165			a = find_last_bit(sqp->in_use_bm, SDEBUG_CANQUEUE);
6166			if (a > k)
6167				k = a;
6168		}
6169		sdebug_max_queue = n;
6170		if (k == SDEBUG_CANQUEUE)
6171			atomic_set(&retired_max_queue, 0);
6172		else if (k >= n)
6173			atomic_set(&retired_max_queue, k + 1);
6174		else
6175			atomic_set(&retired_max_queue, 0);
6176		block_unblock_all_queues(false);
6177		return count;
6178	}
6179	return -EINVAL;
6180}
6181static DRIVER_ATTR_RW(max_queue);
6182
6183static ssize_t host_max_queue_show(struct device_driver *ddp, char *buf)
6184{
6185	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_host_max_queue);
6186}
6187
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6188/*
6189 * Since this is used for .can_queue, and we get the hc_idx tag from the bitmap
6190 * in range [0, sdebug_host_max_queue), we can't change it.
6191 */
6192static DRIVER_ATTR_RO(host_max_queue);
6193
6194static ssize_t no_uld_show(struct device_driver *ddp, char *buf)
6195{
6196	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_uld);
6197}
6198static DRIVER_ATTR_RO(no_uld);
6199
6200static ssize_t scsi_level_show(struct device_driver *ddp, char *buf)
6201{
6202	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_scsi_level);
6203}
6204static DRIVER_ATTR_RO(scsi_level);
6205
6206static ssize_t virtual_gb_show(struct device_driver *ddp, char *buf)
6207{
6208	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_virtual_gb);
6209}
6210static ssize_t virtual_gb_store(struct device_driver *ddp, const char *buf,
6211				size_t count)
6212{
6213	int n;
6214	bool changed;
6215
6216	/* Ignore capacity change for ZBC drives for now */
6217	if (sdeb_zbc_in_use)
6218		return -ENOTSUPP;
6219
6220	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6221		changed = (sdebug_virtual_gb != n);
6222		sdebug_virtual_gb = n;
6223		sdebug_capacity = get_sdebug_capacity();
6224		if (changed) {
6225			struct sdebug_host_info *sdhp;
6226			struct sdebug_dev_info *dp;
6227
6228			spin_lock(&sdebug_host_list_lock);
6229			list_for_each_entry(sdhp, &sdebug_host_list,
6230					    host_list) {
6231				list_for_each_entry(dp, &sdhp->dev_info_list,
6232						    dev_list) {
6233					set_bit(SDEBUG_UA_CAPACITY_CHANGED,
6234						dp->uas_bm);
6235				}
6236			}
6237			spin_unlock(&sdebug_host_list_lock);
6238		}
6239		return count;
6240	}
6241	return -EINVAL;
6242}
6243static DRIVER_ATTR_RW(virtual_gb);
6244
6245static ssize_t add_host_show(struct device_driver *ddp, char *buf)
6246{
6247	/* absolute number of hosts currently active is what is shown */
6248	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_hosts);
6249}
6250
6251static ssize_t add_host_store(struct device_driver *ddp, const char *buf,
6252			      size_t count)
6253{
6254	bool found;
6255	unsigned long idx;
6256	struct sdeb_store_info *sip;
6257	bool want_phs = (sdebug_fake_rw == 0) && sdebug_per_host_store;
6258	int delta_hosts;
6259
6260	if (sscanf(buf, "%d", &delta_hosts) != 1)
6261		return -EINVAL;
6262	if (delta_hosts > 0) {
6263		do {
6264			found = false;
6265			if (want_phs) {
6266				xa_for_each_marked(per_store_ap, idx, sip,
6267						   SDEB_XA_NOT_IN_USE) {
6268					sdeb_most_recent_idx = (int)idx;
6269					found = true;
6270					break;
6271				}
6272				if (found)	/* re-use case */
6273					sdebug_add_host_helper((int)idx);
6274				else
6275					sdebug_do_add_host(true);
6276			} else {
6277				sdebug_do_add_host(false);
6278			}
6279		} while (--delta_hosts);
6280	} else if (delta_hosts < 0) {
6281		do {
6282			sdebug_do_remove_host(false);
6283		} while (++delta_hosts);
6284	}
6285	return count;
6286}
6287static DRIVER_ATTR_RW(add_host);
6288
6289static ssize_t vpd_use_hostno_show(struct device_driver *ddp, char *buf)
6290{
6291	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_vpd_use_hostno);
6292}
6293static ssize_t vpd_use_hostno_store(struct device_driver *ddp, const char *buf,
6294				    size_t count)
6295{
6296	int n;
6297
6298	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6299		sdebug_vpd_use_hostno = n;
6300		return count;
6301	}
6302	return -EINVAL;
6303}
6304static DRIVER_ATTR_RW(vpd_use_hostno);
6305
6306static ssize_t statistics_show(struct device_driver *ddp, char *buf)
6307{
6308	return scnprintf(buf, PAGE_SIZE, "%d\n", (int)sdebug_statistics);
6309}
6310static ssize_t statistics_store(struct device_driver *ddp, const char *buf,
6311				size_t count)
6312{
6313	int n;
6314
6315	if ((count > 0) && (sscanf(buf, "%d", &n) == 1) && (n >= 0)) {
6316		if (n > 0)
6317			sdebug_statistics = true;
6318		else {
6319			clear_queue_stats();
6320			sdebug_statistics = false;
6321		}
6322		return count;
6323	}
6324	return -EINVAL;
6325}
6326static DRIVER_ATTR_RW(statistics);
6327
6328static ssize_t sector_size_show(struct device_driver *ddp, char *buf)
6329{
6330	return scnprintf(buf, PAGE_SIZE, "%u\n", sdebug_sector_size);
6331}
6332static DRIVER_ATTR_RO(sector_size);
6333
6334static ssize_t submit_queues_show(struct device_driver *ddp, char *buf)
6335{
6336	return scnprintf(buf, PAGE_SIZE, "%d\n", submit_queues);
6337}
6338static DRIVER_ATTR_RO(submit_queues);
6339
6340static ssize_t dix_show(struct device_driver *ddp, char *buf)
6341{
6342	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dix);
6343}
6344static DRIVER_ATTR_RO(dix);
6345
6346static ssize_t dif_show(struct device_driver *ddp, char *buf)
6347{
6348	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dif);
6349}
6350static DRIVER_ATTR_RO(dif);
6351
6352static ssize_t guard_show(struct device_driver *ddp, char *buf)
6353{
6354	return scnprintf(buf, PAGE_SIZE, "%u\n", sdebug_guard);
6355}
6356static DRIVER_ATTR_RO(guard);
6357
6358static ssize_t ato_show(struct device_driver *ddp, char *buf)
6359{
6360	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ato);
6361}
6362static DRIVER_ATTR_RO(ato);
6363
6364static ssize_t map_show(struct device_driver *ddp, char *buf)
6365{
6366	ssize_t count = 0;
6367
6368	if (!scsi_debug_lbp())
6369		return scnprintf(buf, PAGE_SIZE, "0-%u\n",
6370				 sdebug_store_sectors);
6371
6372	if (sdebug_fake_rw == 0 && !xa_empty(per_store_ap)) {
6373		struct sdeb_store_info *sip = xa_load(per_store_ap, 0);
6374
6375		if (sip)
6376			count = scnprintf(buf, PAGE_SIZE - 1, "%*pbl",
6377					  (int)map_size, sip->map_storep);
6378	}
6379	buf[count++] = '\n';
6380	buf[count] = '\0';
6381
6382	return count;
6383}
6384static DRIVER_ATTR_RO(map);
6385
6386static ssize_t random_show(struct device_driver *ddp, char *buf)
6387{
6388	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_random);
6389}
6390
6391static ssize_t random_store(struct device_driver *ddp, const char *buf,
6392			    size_t count)
6393{
6394	bool v;
6395
6396	if (kstrtobool(buf, &v))
6397		return -EINVAL;
6398
6399	sdebug_random = v;
6400	return count;
6401}
6402static DRIVER_ATTR_RW(random);
6403
6404static ssize_t removable_show(struct device_driver *ddp, char *buf)
6405{
6406	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_removable ? 1 : 0);
6407}
6408static ssize_t removable_store(struct device_driver *ddp, const char *buf,
6409			       size_t count)
6410{
6411	int n;
6412
6413	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6414		sdebug_removable = (n > 0);
6415		return count;
6416	}
6417	return -EINVAL;
6418}
6419static DRIVER_ATTR_RW(removable);
6420
6421static ssize_t host_lock_show(struct device_driver *ddp, char *buf)
6422{
6423	return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_host_lock);
6424}
6425/* N.B. sdebug_host_lock does nothing, kept for backward compatibility */
6426static ssize_t host_lock_store(struct device_driver *ddp, const char *buf,
6427			       size_t count)
6428{
6429	int n;
6430
6431	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6432		sdebug_host_lock = (n > 0);
6433		return count;
6434	}
6435	return -EINVAL;
6436}
6437static DRIVER_ATTR_RW(host_lock);
6438
6439static ssize_t strict_show(struct device_driver *ddp, char *buf)
6440{
6441	return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_strict);
6442}
6443static ssize_t strict_store(struct device_driver *ddp, const char *buf,
6444			    size_t count)
6445{
6446	int n;
6447
6448	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6449		sdebug_strict = (n > 0);
6450		return count;
6451	}
6452	return -EINVAL;
6453}
6454static DRIVER_ATTR_RW(strict);
6455
6456static ssize_t uuid_ctl_show(struct device_driver *ddp, char *buf)
6457{
6458	return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_uuid_ctl);
6459}
6460static DRIVER_ATTR_RO(uuid_ctl);
6461
6462static ssize_t cdb_len_show(struct device_driver *ddp, char *buf)
6463{
6464	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_cdb_len);
6465}
6466static ssize_t cdb_len_store(struct device_driver *ddp, const char *buf,
6467			     size_t count)
6468{
6469	int ret, n;
6470
6471	ret = kstrtoint(buf, 0, &n);
6472	if (ret)
6473		return ret;
6474	sdebug_cdb_len = n;
6475	all_config_cdb_len();
6476	return count;
6477}
6478static DRIVER_ATTR_RW(cdb_len);
6479
6480static const char * const zbc_model_strs_a[] = {
6481	[BLK_ZONED_NONE] = "none",
6482	[BLK_ZONED_HA]   = "host-aware",
6483	[BLK_ZONED_HM]   = "host-managed",
6484};
6485
6486static const char * const zbc_model_strs_b[] = {
6487	[BLK_ZONED_NONE] = "no",
6488	[BLK_ZONED_HA]   = "aware",
6489	[BLK_ZONED_HM]   = "managed",
6490};
6491
6492static const char * const zbc_model_strs_c[] = {
6493	[BLK_ZONED_NONE] = "0",
6494	[BLK_ZONED_HA]   = "1",
6495	[BLK_ZONED_HM]   = "2",
6496};
6497
6498static int sdeb_zbc_model_str(const char *cp)
6499{
6500	int res = sysfs_match_string(zbc_model_strs_a, cp);
6501
6502	if (res < 0) {
6503		res = sysfs_match_string(zbc_model_strs_b, cp);
6504		if (res < 0) {
6505			res = sysfs_match_string(zbc_model_strs_c, cp);
6506			if (res < 0)
6507				return -EINVAL;
6508		}
6509	}
6510	return res;
6511}
6512
6513static ssize_t zbc_show(struct device_driver *ddp, char *buf)
6514{
6515	return scnprintf(buf, PAGE_SIZE, "%s\n",
6516			 zbc_model_strs_a[sdeb_zbc_model]);
6517}
6518static DRIVER_ATTR_RO(zbc);
6519
6520static ssize_t tur_ms_to_ready_show(struct device_driver *ddp, char *buf)
6521{
6522	return scnprintf(buf, PAGE_SIZE, "%d\n", sdeb_tur_ms_to_ready);
6523}
6524static DRIVER_ATTR_RO(tur_ms_to_ready);
6525
6526/* Note: The following array creates attribute files in the
6527   /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
6528   files (over those found in the /sys/module/scsi_debug/parameters
6529   directory) is that auxiliary actions can be triggered when an attribute
6530   is changed. For example see: add_host_store() above.
6531 */
6532
6533static struct attribute *sdebug_drv_attrs[] = {
6534	&driver_attr_delay.attr,
6535	&driver_attr_opts.attr,
6536	&driver_attr_ptype.attr,
6537	&driver_attr_dsense.attr,
6538	&driver_attr_fake_rw.attr,
6539	&driver_attr_host_max_queue.attr,
6540	&driver_attr_no_lun_0.attr,
6541	&driver_attr_num_tgts.attr,
6542	&driver_attr_dev_size_mb.attr,
6543	&driver_attr_num_parts.attr,
6544	&driver_attr_every_nth.attr,
 
6545	&driver_attr_max_luns.attr,
6546	&driver_attr_max_queue.attr,
 
6547	&driver_attr_no_uld.attr,
6548	&driver_attr_scsi_level.attr,
6549	&driver_attr_virtual_gb.attr,
6550	&driver_attr_add_host.attr,
6551	&driver_attr_per_host_store.attr,
6552	&driver_attr_vpd_use_hostno.attr,
6553	&driver_attr_sector_size.attr,
6554	&driver_attr_statistics.attr,
6555	&driver_attr_submit_queues.attr,
6556	&driver_attr_dix.attr,
6557	&driver_attr_dif.attr,
6558	&driver_attr_guard.attr,
6559	&driver_attr_ato.attr,
6560	&driver_attr_map.attr,
6561	&driver_attr_random.attr,
6562	&driver_attr_removable.attr,
6563	&driver_attr_host_lock.attr,
6564	&driver_attr_ndelay.attr,
6565	&driver_attr_strict.attr,
6566	&driver_attr_uuid_ctl.attr,
6567	&driver_attr_cdb_len.attr,
6568	&driver_attr_tur_ms_to_ready.attr,
6569	&driver_attr_zbc.attr,
6570	NULL,
6571};
6572ATTRIBUTE_GROUPS(sdebug_drv);
6573
6574static struct device *pseudo_primary;
6575
6576static int __init scsi_debug_init(void)
6577{
6578	bool want_store = (sdebug_fake_rw == 0);
6579	unsigned long sz;
6580	int k, ret, hosts_to_add;
6581	int idx = -1;
6582
6583	ramdisk_lck_a[0] = &atomic_rw;
6584	ramdisk_lck_a[1] = &atomic_rw2;
6585	atomic_set(&retired_max_queue, 0);
6586
6587	if (sdebug_ndelay >= 1000 * 1000 * 1000) {
6588		pr_warn("ndelay must be less than 1 second, ignored\n");
6589		sdebug_ndelay = 0;
6590	} else if (sdebug_ndelay > 0)
6591		sdebug_jdelay = JDELAY_OVERRIDDEN;
6592
6593	switch (sdebug_sector_size) {
6594	case  512:
6595	case 1024:
6596	case 2048:
6597	case 4096:
6598		break;
6599	default:
6600		pr_err("invalid sector_size %d\n", sdebug_sector_size);
6601		return -EINVAL;
6602	}
6603
6604	switch (sdebug_dif) {
6605	case T10_PI_TYPE0_PROTECTION:
6606		break;
6607	case T10_PI_TYPE1_PROTECTION:
6608	case T10_PI_TYPE2_PROTECTION:
6609	case T10_PI_TYPE3_PROTECTION:
6610		have_dif_prot = true;
6611		break;
6612
6613	default:
6614		pr_err("dif must be 0, 1, 2 or 3\n");
6615		return -EINVAL;
6616	}
6617
6618	if (sdebug_num_tgts < 0) {
6619		pr_err("num_tgts must be >= 0\n");
6620		return -EINVAL;
6621	}
6622
6623	if (sdebug_guard > 1) {
6624		pr_err("guard must be 0 or 1\n");
6625		return -EINVAL;
6626	}
6627
6628	if (sdebug_ato > 1) {
6629		pr_err("ato must be 0 or 1\n");
6630		return -EINVAL;
6631	}
6632
6633	if (sdebug_physblk_exp > 15) {
6634		pr_err("invalid physblk_exp %u\n", sdebug_physblk_exp);
6635		return -EINVAL;
6636	}
 
 
 
 
 
 
 
6637	if (sdebug_max_luns > 256) {
6638		pr_warn("max_luns can be no more than 256, use default\n");
6639		sdebug_max_luns = DEF_MAX_LUNS;
 
 
 
6640	}
6641
6642	if (sdebug_lowest_aligned > 0x3fff) {
6643		pr_err("lowest_aligned too big: %u\n", sdebug_lowest_aligned);
6644		return -EINVAL;
6645	}
6646
6647	if (submit_queues < 1) {
6648		pr_err("submit_queues must be 1 or more\n");
6649		return -EINVAL;
6650	}
6651
6652	if ((sdebug_max_queue > SDEBUG_CANQUEUE) || (sdebug_max_queue < 1)) {
6653		pr_err("max_queue must be in range [1, %d]\n", SDEBUG_CANQUEUE);
6654		return -EINVAL;
6655	}
6656
6657	if ((sdebug_host_max_queue > SDEBUG_CANQUEUE) ||
6658	    (sdebug_host_max_queue < 0)) {
6659		pr_err("host_max_queue must be in range [0 %d]\n",
6660		       SDEBUG_CANQUEUE);
6661		return -EINVAL;
6662	}
6663
6664	if (sdebug_host_max_queue &&
6665	    (sdebug_max_queue != sdebug_host_max_queue)) {
6666		sdebug_max_queue = sdebug_host_max_queue;
6667		pr_warn("fixing max submit queue depth to host max queue depth, %d\n",
6668			sdebug_max_queue);
6669	}
6670
6671	sdebug_q_arr = kcalloc(submit_queues, sizeof(struct sdebug_queue),
6672			       GFP_KERNEL);
6673	if (sdebug_q_arr == NULL)
6674		return -ENOMEM;
6675	for (k = 0; k < submit_queues; ++k)
6676		spin_lock_init(&sdebug_q_arr[k].qc_lock);
6677
6678	/*
6679	 * check for host managed zoned block device specified with
6680	 * ptype=0x14 or zbc=XXX.
6681	 */
6682	if (sdebug_ptype == TYPE_ZBC) {
6683		sdeb_zbc_model = BLK_ZONED_HM;
6684	} else if (sdeb_zbc_model_s && *sdeb_zbc_model_s) {
6685		k = sdeb_zbc_model_str(sdeb_zbc_model_s);
6686		if (k < 0) {
6687			ret = k;
6688			goto free_vm;
6689		}
6690		sdeb_zbc_model = k;
6691		switch (sdeb_zbc_model) {
6692		case BLK_ZONED_NONE:
6693		case BLK_ZONED_HA:
6694			sdebug_ptype = TYPE_DISK;
6695			break;
6696		case BLK_ZONED_HM:
6697			sdebug_ptype = TYPE_ZBC;
6698			break;
6699		default:
6700			pr_err("Invalid ZBC model\n");
6701			return -EINVAL;
6702		}
6703	}
6704	if (sdeb_zbc_model != BLK_ZONED_NONE) {
6705		sdeb_zbc_in_use = true;
6706		if (sdebug_dev_size_mb == DEF_DEV_SIZE_PRE_INIT)
6707			sdebug_dev_size_mb = DEF_ZBC_DEV_SIZE_MB;
6708	}
6709
6710	if (sdebug_dev_size_mb == DEF_DEV_SIZE_PRE_INIT)
6711		sdebug_dev_size_mb = DEF_DEV_SIZE_MB;
6712	if (sdebug_dev_size_mb < 1)
6713		sdebug_dev_size_mb = 1;  /* force minimum 1 MB ramdisk */
6714	sz = (unsigned long)sdebug_dev_size_mb * 1048576;
6715	sdebug_store_sectors = sz / sdebug_sector_size;
6716	sdebug_capacity = get_sdebug_capacity();
6717
6718	/* play around with geometry, don't waste too much on track 0 */
6719	sdebug_heads = 8;
6720	sdebug_sectors_per = 32;
6721	if (sdebug_dev_size_mb >= 256)
6722		sdebug_heads = 64;
6723	else if (sdebug_dev_size_mb >= 16)
6724		sdebug_heads = 32;
6725	sdebug_cylinders_per = (unsigned long)sdebug_capacity /
6726			       (sdebug_sectors_per * sdebug_heads);
6727	if (sdebug_cylinders_per >= 1024) {
6728		/* other LLDs do this; implies >= 1GB ram disk ... */
6729		sdebug_heads = 255;
6730		sdebug_sectors_per = 63;
6731		sdebug_cylinders_per = (unsigned long)sdebug_capacity /
6732			       (sdebug_sectors_per * sdebug_heads);
6733	}
6734	if (scsi_debug_lbp()) {
6735		sdebug_unmap_max_blocks =
6736			clamp(sdebug_unmap_max_blocks, 0U, 0xffffffffU);
6737
6738		sdebug_unmap_max_desc =
6739			clamp(sdebug_unmap_max_desc, 0U, 256U);
6740
6741		sdebug_unmap_granularity =
6742			clamp(sdebug_unmap_granularity, 1U, 0xffffffffU);
6743
6744		if (sdebug_unmap_alignment &&
6745		    sdebug_unmap_granularity <=
6746		    sdebug_unmap_alignment) {
6747			pr_err("ERR: unmap_granularity <= unmap_alignment\n");
6748			ret = -EINVAL;
6749			goto free_q_arr;
6750		}
6751	}
6752	xa_init_flags(per_store_ap, XA_FLAGS_ALLOC | XA_FLAGS_LOCK_IRQ);
6753	if (want_store) {
6754		idx = sdebug_add_store();
6755		if (idx < 0) {
6756			ret = idx;
6757			goto free_q_arr;
6758		}
6759	}
6760
6761	pseudo_primary = root_device_register("pseudo_0");
6762	if (IS_ERR(pseudo_primary)) {
6763		pr_warn("root_device_register() error\n");
6764		ret = PTR_ERR(pseudo_primary);
6765		goto free_vm;
6766	}
6767	ret = bus_register(&pseudo_lld_bus);
6768	if (ret < 0) {
6769		pr_warn("bus_register error: %d\n", ret);
6770		goto dev_unreg;
6771	}
6772	ret = driver_register(&sdebug_driverfs_driver);
6773	if (ret < 0) {
6774		pr_warn("driver_register error: %d\n", ret);
6775		goto bus_unreg;
6776	}
6777
6778	hosts_to_add = sdebug_add_host;
6779	sdebug_add_host = 0;
6780
 
 
 
 
 
 
 
 
 
 
6781	for (k = 0; k < hosts_to_add; k++) {
6782		if (want_store && k == 0) {
6783			ret = sdebug_add_host_helper(idx);
6784			if (ret < 0) {
6785				pr_err("add_host_helper k=%d, error=%d\n",
6786				       k, -ret);
6787				break;
6788			}
6789		} else {
6790			ret = sdebug_do_add_host(want_store &&
6791						 sdebug_per_host_store);
6792			if (ret < 0) {
6793				pr_err("add_host k=%d error=%d\n", k, -ret);
6794				break;
6795			}
6796		}
6797	}
6798	if (sdebug_verbose)
6799		pr_info("built %d host(s)\n", sdebug_num_hosts);
6800
6801	return 0;
6802
 
 
6803bus_unreg:
6804	bus_unregister(&pseudo_lld_bus);
6805dev_unreg:
6806	root_device_unregister(pseudo_primary);
6807free_vm:
6808	sdebug_erase_store(idx, NULL);
6809free_q_arr:
6810	kfree(sdebug_q_arr);
6811	return ret;
6812}
6813
6814static void __exit scsi_debug_exit(void)
6815{
6816	int k = sdebug_num_hosts;
6817
6818	stop_all_queued();
6819	for (; k; k--)
6820		sdebug_do_remove_host(true);
6821	free_all_queued();
6822	driver_unregister(&sdebug_driverfs_driver);
6823	bus_unregister(&pseudo_lld_bus);
6824	root_device_unregister(pseudo_primary);
6825
6826	sdebug_erase_all_stores(false);
6827	xa_destroy(per_store_ap);
 
6828}
6829
6830device_initcall(scsi_debug_init);
6831module_exit(scsi_debug_exit);
6832
6833static void sdebug_release_adapter(struct device *dev)
6834{
6835	struct sdebug_host_info *sdbg_host;
6836
6837	sdbg_host = to_sdebug_host(dev);
6838	kfree(sdbg_host);
6839}
6840
6841/* idx must be valid, if sip is NULL then it will be obtained using idx */
6842static void sdebug_erase_store(int idx, struct sdeb_store_info *sip)
6843{
6844	if (idx < 0)
6845		return;
6846	if (!sip) {
6847		if (xa_empty(per_store_ap))
6848			return;
6849		sip = xa_load(per_store_ap, idx);
6850		if (!sip)
6851			return;
6852	}
6853	vfree(sip->map_storep);
6854	vfree(sip->dif_storep);
6855	vfree(sip->storep);
6856	xa_erase(per_store_ap, idx);
6857	kfree(sip);
6858}
6859
6860/* Assume apart_from_first==false only in shutdown case. */
6861static void sdebug_erase_all_stores(bool apart_from_first)
6862{
6863	unsigned long idx;
6864	struct sdeb_store_info *sip = NULL;
6865
6866	xa_for_each(per_store_ap, idx, sip) {
6867		if (apart_from_first)
6868			apart_from_first = false;
6869		else
6870			sdebug_erase_store(idx, sip);
6871	}
6872	if (apart_from_first)
6873		sdeb_most_recent_idx = sdeb_first_idx;
6874}
6875
6876/*
6877 * Returns store xarray new element index (idx) if >=0 else negated errno.
6878 * Limit the number of stores to 65536.
6879 */
6880static int sdebug_add_store(void)
6881{
6882	int res;
6883	u32 n_idx;
6884	unsigned long iflags;
6885	unsigned long sz = (unsigned long)sdebug_dev_size_mb * 1048576;
6886	struct sdeb_store_info *sip = NULL;
6887	struct xa_limit xal = { .max = 1 << 16, .min = 0 };
6888
6889	sip = kzalloc(sizeof(*sip), GFP_KERNEL);
6890	if (!sip)
6891		return -ENOMEM;
6892
6893	xa_lock_irqsave(per_store_ap, iflags);
6894	res = __xa_alloc(per_store_ap, &n_idx, sip, xal, GFP_ATOMIC);
6895	if (unlikely(res < 0)) {
6896		xa_unlock_irqrestore(per_store_ap, iflags);
6897		kfree(sip);
6898		pr_warn("%s: xa_alloc() errno=%d\n", __func__, -res);
6899		return res;
6900	}
6901	sdeb_most_recent_idx = n_idx;
6902	if (sdeb_first_idx < 0)
6903		sdeb_first_idx = n_idx;
6904	xa_unlock_irqrestore(per_store_ap, iflags);
6905
6906	res = -ENOMEM;
6907	sip->storep = vzalloc(sz);
6908	if (!sip->storep) {
6909		pr_err("user data oom\n");
6910		goto err;
6911	}
6912	if (sdebug_num_parts > 0)
6913		sdebug_build_parts(sip->storep, sz);
6914
6915	/* DIF/DIX: what T10 calls Protection Information (PI) */
6916	if (sdebug_dix) {
6917		int dif_size;
6918
6919		dif_size = sdebug_store_sectors * sizeof(struct t10_pi_tuple);
6920		sip->dif_storep = vmalloc(dif_size);
6921
6922		pr_info("dif_storep %u bytes @ %pK\n", dif_size,
6923			sip->dif_storep);
6924
6925		if (!sip->dif_storep) {
6926			pr_err("DIX oom\n");
6927			goto err;
6928		}
6929		memset(sip->dif_storep, 0xff, dif_size);
6930	}
6931	/* Logical Block Provisioning */
6932	if (scsi_debug_lbp()) {
6933		map_size = lba_to_map_index(sdebug_store_sectors - 1) + 1;
6934		sip->map_storep = vmalloc(array_size(sizeof(long),
6935						     BITS_TO_LONGS(map_size)));
6936
6937		pr_info("%lu provisioning blocks\n", map_size);
6938
6939		if (!sip->map_storep) {
6940			pr_err("LBP map oom\n");
6941			goto err;
6942		}
6943
6944		bitmap_zero(sip->map_storep, map_size);
6945
6946		/* Map first 1KB for partition table */
6947		if (sdebug_num_parts)
6948			map_region(sip, 0, 2);
6949	}
6950
6951	rwlock_init(&sip->macc_lck);
6952	return (int)n_idx;
6953err:
6954	sdebug_erase_store((int)n_idx, sip);
6955	pr_warn("%s: failed, errno=%d\n", __func__, -res);
6956	return res;
6957}
6958
6959static int sdebug_add_host_helper(int per_host_idx)
6960{
6961	int k, devs_per_host, idx;
6962	int error = -ENOMEM;
6963	struct sdebug_host_info *sdbg_host;
6964	struct sdebug_dev_info *sdbg_devinfo, *tmp;
6965
6966	sdbg_host = kzalloc(sizeof(*sdbg_host), GFP_KERNEL);
6967	if (!sdbg_host)
6968		return -ENOMEM;
6969	idx = (per_host_idx < 0) ? sdeb_first_idx : per_host_idx;
6970	if (xa_get_mark(per_store_ap, idx, SDEB_XA_NOT_IN_USE))
6971		xa_clear_mark(per_store_ap, idx, SDEB_XA_NOT_IN_USE);
6972	sdbg_host->si_idx = idx;
6973
6974	INIT_LIST_HEAD(&sdbg_host->dev_info_list);
6975
6976	devs_per_host = sdebug_num_tgts * sdebug_max_luns;
6977	for (k = 0; k < devs_per_host; k++) {
6978		sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL);
6979		if (!sdbg_devinfo)
6980			goto clean;
6981	}
6982
6983	spin_lock(&sdebug_host_list_lock);
6984	list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
6985	spin_unlock(&sdebug_host_list_lock);
6986
6987	sdbg_host->dev.bus = &pseudo_lld_bus;
6988	sdbg_host->dev.parent = pseudo_primary;
6989	sdbg_host->dev.release = &sdebug_release_adapter;
6990	dev_set_name(&sdbg_host->dev, "adapter%d", sdebug_num_hosts);
6991
6992	error = device_register(&sdbg_host->dev);
6993	if (error)
 
 
 
6994		goto clean;
 
6995
6996	++sdebug_num_hosts;
6997	return 0;
6998
6999clean:
7000	list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
7001				 dev_list) {
7002		list_del(&sdbg_devinfo->dev_list);
7003		kfree(sdbg_devinfo->zstate);
7004		kfree(sdbg_devinfo);
7005	}
7006	kfree(sdbg_host);
 
 
 
7007	pr_warn("%s: failed, errno=%d\n", __func__, -error);
7008	return error;
7009}
7010
7011static int sdebug_do_add_host(bool mk_new_store)
7012{
7013	int ph_idx = sdeb_most_recent_idx;
7014
7015	if (mk_new_store) {
7016		ph_idx = sdebug_add_store();
7017		if (ph_idx < 0)
7018			return ph_idx;
7019	}
7020	return sdebug_add_host_helper(ph_idx);
7021}
7022
7023static void sdebug_do_remove_host(bool the_end)
7024{
7025	int idx = -1;
7026	struct sdebug_host_info *sdbg_host = NULL;
7027	struct sdebug_host_info *sdbg_host2;
7028
7029	spin_lock(&sdebug_host_list_lock);
7030	if (!list_empty(&sdebug_host_list)) {
7031		sdbg_host = list_entry(sdebug_host_list.prev,
7032				       struct sdebug_host_info, host_list);
7033		idx = sdbg_host->si_idx;
7034	}
7035	if (!the_end && idx >= 0) {
7036		bool unique = true;
7037
7038		list_for_each_entry(sdbg_host2, &sdebug_host_list, host_list) {
7039			if (sdbg_host2 == sdbg_host)
7040				continue;
7041			if (idx == sdbg_host2->si_idx) {
7042				unique = false;
7043				break;
7044			}
7045		}
7046		if (unique) {
7047			xa_set_mark(per_store_ap, idx, SDEB_XA_NOT_IN_USE);
7048			if (idx == sdeb_most_recent_idx)
7049				--sdeb_most_recent_idx;
7050		}
7051	}
7052	if (sdbg_host)
7053		list_del(&sdbg_host->host_list);
7054	spin_unlock(&sdebug_host_list_lock);
7055
7056	if (!sdbg_host)
7057		return;
7058
7059	device_unregister(&sdbg_host->dev);
7060	--sdebug_num_hosts;
7061}
7062
7063static int sdebug_change_qdepth(struct scsi_device *sdev, int qdepth)
7064{
7065	int num_in_q = 0;
7066	struct sdebug_dev_info *devip;
7067
7068	block_unblock_all_queues(true);
7069	devip = (struct sdebug_dev_info *)sdev->hostdata;
7070	if (NULL == devip) {
7071		block_unblock_all_queues(false);
7072		return	-ENODEV;
7073	}
7074	num_in_q = atomic_read(&devip->num_in_q);
7075
 
 
 
 
 
 
 
 
7076	if (qdepth < 1)
7077		qdepth = 1;
7078	/* allow to exceed max host qc_arr elements for testing */
7079	if (qdepth > SDEBUG_CANQUEUE + 10)
7080		qdepth = SDEBUG_CANQUEUE + 10;
7081	scsi_change_queue_depth(sdev, qdepth);
7082
7083	if (SDEBUG_OPT_Q_NOISE & sdebug_opts) {
7084		sdev_printk(KERN_INFO, sdev, "%s: qdepth=%d, num_in_q=%d\n",
7085			    __func__, qdepth, num_in_q);
7086	}
7087	block_unblock_all_queues(false);
 
 
 
 
 
7088	return sdev->queue_depth;
7089}
7090
7091static bool fake_timeout(struct scsi_cmnd *scp)
7092{
7093	if (0 == (atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth))) {
7094		if (sdebug_every_nth < -1)
7095			sdebug_every_nth = -1;
7096		if (SDEBUG_OPT_TIMEOUT & sdebug_opts)
7097			return true; /* ignore command causing timeout */
7098		else if (SDEBUG_OPT_MAC_TIMEOUT & sdebug_opts &&
7099			 scsi_medium_access_command(scp))
7100			return true; /* time out reads and writes */
7101	}
7102	return false;
7103}
7104
7105/* Response to TUR or media access command when device stopped */
7106static int resp_not_ready(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
7107{
7108	int stopped_state;
7109	u64 diff_ns = 0;
7110	ktime_t now_ts = ktime_get_boottime();
7111	struct scsi_device *sdp = scp->device;
7112
7113	stopped_state = atomic_read(&devip->stopped);
7114	if (stopped_state == 2) {
7115		if (ktime_to_ns(now_ts) > ktime_to_ns(devip->create_ts)) {
7116			diff_ns = ktime_to_ns(ktime_sub(now_ts, devip->create_ts));
7117			if (diff_ns >= ((u64)sdeb_tur_ms_to_ready * 1000000)) {
7118				/* tur_ms_to_ready timer extinguished */
7119				atomic_set(&devip->stopped, 0);
7120				return 0;
7121			}
7122		}
7123		mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x1);
7124		if (sdebug_verbose)
7125			sdev_printk(KERN_INFO, sdp,
7126				    "%s: Not ready: in process of becoming ready\n", my_name);
7127		if (scp->cmnd[0] == TEST_UNIT_READY) {
7128			u64 tur_nanosecs_to_ready = (u64)sdeb_tur_ms_to_ready * 1000000;
7129
7130			if (diff_ns <= tur_nanosecs_to_ready)
7131				diff_ns = tur_nanosecs_to_ready - diff_ns;
7132			else
7133				diff_ns = tur_nanosecs_to_ready;
7134			/* As per 20-061r2 approved for spc6 by T10 on 20200716 */
7135			do_div(diff_ns, 1000000);	/* diff_ns becomes milliseconds */
7136			scsi_set_sense_information(scp->sense_buffer, SCSI_SENSE_BUFFERSIZE,
7137						   diff_ns);
7138			return check_condition_result;
7139		}
7140	}
7141	mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x2);
7142	if (sdebug_verbose)
7143		sdev_printk(KERN_INFO, sdp, "%s: Not ready: initializing command required\n",
7144			    my_name);
7145	return check_condition_result;
7146}
7147
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7148static int scsi_debug_queuecommand(struct Scsi_Host *shost,
7149				   struct scsi_cmnd *scp)
7150{
7151	u8 sdeb_i;
7152	struct scsi_device *sdp = scp->device;
7153	const struct opcode_info_t *oip;
7154	const struct opcode_info_t *r_oip;
7155	struct sdebug_dev_info *devip;
7156	u8 *cmd = scp->cmnd;
7157	int (*r_pfp)(struct scsi_cmnd *, struct sdebug_dev_info *);
7158	int (*pfp)(struct scsi_cmnd *, struct sdebug_dev_info *) = NULL;
7159	int k, na;
7160	int errsts = 0;
 
7161	u32 flags;
7162	u16 sa;
7163	u8 opcode = cmd[0];
7164	bool has_wlun_rl;
7165	bool inject_now;
 
 
7166
7167	scsi_set_resid(scp, 0);
7168	if (sdebug_statistics) {
7169		atomic_inc(&sdebug_cmnd_count);
7170		inject_now = inject_on_this_cmd();
7171	} else {
7172		inject_now = false;
7173	}
7174	if (unlikely(sdebug_verbose &&
7175		     !(SDEBUG_OPT_NO_CDB_NOISE & sdebug_opts))) {
7176		char b[120];
7177		int n, len, sb;
7178
7179		len = scp->cmd_len;
7180		sb = (int)sizeof(b);
7181		if (len > 32)
7182			strcpy(b, "too long, over 32 bytes");
7183		else {
7184			for (k = 0, n = 0; k < len && n < sb; ++k)
7185				n += scnprintf(b + n, sb - n, "%02x ",
7186					       (u32)cmd[k]);
7187		}
7188		sdev_printk(KERN_INFO, sdp, "%s: tag=%#x, cmd %s\n", my_name,
7189			    blk_mq_unique_tag(scp->request), b);
7190	}
7191	if (unlikely(inject_now && (sdebug_opts & SDEBUG_OPT_HOST_BUSY)))
7192		return SCSI_MLQUEUE_HOST_BUSY;
7193	has_wlun_rl = (sdp->lun == SCSI_W_LUN_REPORT_LUNS);
7194	if (unlikely((sdp->lun >= sdebug_max_luns) && !has_wlun_rl))
7195		goto err_out;
7196
7197	sdeb_i = opcode_ind_arr[opcode];	/* fully mapped */
7198	oip = &opcode_info_arr[sdeb_i];		/* safe if table consistent */
7199	devip = (struct sdebug_dev_info *)sdp->hostdata;
7200	if (unlikely(!devip)) {
7201		devip = find_build_dev_info(sdp);
7202		if (NULL == devip)
7203			goto err_out;
7204	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7205	if (unlikely(inject_now && !atomic_read(&sdeb_inject_pending)))
7206		atomic_set(&sdeb_inject_pending, 1);
7207
7208	na = oip->num_attached;
7209	r_pfp = oip->pfp;
7210	if (na) {	/* multiple commands with this opcode */
7211		r_oip = oip;
7212		if (FF_SA & r_oip->flags) {
7213			if (F_SA_LOW & oip->flags)
7214				sa = 0x1f & cmd[1];
7215			else
7216				sa = get_unaligned_be16(cmd + 8);
7217			for (k = 0; k <= na; oip = r_oip->arrp + k++) {
7218				if (opcode == oip->opcode && sa == oip->sa)
7219					break;
7220			}
7221		} else {   /* since no service action only check opcode */
7222			for (k = 0; k <= na; oip = r_oip->arrp + k++) {
7223				if (opcode == oip->opcode)
7224					break;
7225			}
7226		}
7227		if (k > na) {
7228			if (F_SA_LOW & r_oip->flags)
7229				mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 4);
7230			else if (F_SA_HIGH & r_oip->flags)
7231				mk_sense_invalid_fld(scp, SDEB_IN_CDB, 8, 7);
7232			else
7233				mk_sense_invalid_opcode(scp);
7234			goto check_cond;
7235		}
7236	}	/* else (when na==0) we assume the oip is a match */
7237	flags = oip->flags;
7238	if (unlikely(F_INV_OP & flags)) {
7239		mk_sense_invalid_opcode(scp);
7240		goto check_cond;
7241	}
7242	if (unlikely(has_wlun_rl && !(F_RL_WLUN_OK & flags))) {
7243		if (sdebug_verbose)
7244			sdev_printk(KERN_INFO, sdp, "%s: Opcode 0x%x not%s\n",
7245				    my_name, opcode, " supported for wlun");
7246		mk_sense_invalid_opcode(scp);
7247		goto check_cond;
7248	}
7249	if (unlikely(sdebug_strict)) {	/* check cdb against mask */
7250		u8 rem;
7251		int j;
7252
7253		for (k = 1; k < oip->len_mask[0] && k < 16; ++k) {
7254			rem = ~oip->len_mask[k] & cmd[k];
7255			if (rem) {
7256				for (j = 7; j >= 0; --j, rem <<= 1) {
7257					if (0x80 & rem)
7258						break;
7259				}
7260				mk_sense_invalid_fld(scp, SDEB_IN_CDB, k, j);
7261				goto check_cond;
7262			}
7263		}
7264	}
7265	if (unlikely(!(F_SKIP_UA & flags) &&
7266		     find_first_bit(devip->uas_bm,
7267				    SDEBUG_NUM_UAS) != SDEBUG_NUM_UAS)) {
7268		errsts = make_ua(scp, devip);
7269		if (errsts)
7270			goto check_cond;
7271	}
7272	if (unlikely(((F_M_ACCESS & flags) || scp->cmnd[0] == TEST_UNIT_READY) &&
7273		     atomic_read(&devip->stopped))) {
7274		errsts = resp_not_ready(scp, devip);
7275		if (errsts)
7276			goto fini;
7277	}
7278	if (sdebug_fake_rw && (F_FAKE_RW & flags))
7279		goto fini;
7280	if (unlikely(sdebug_every_nth)) {
7281		if (fake_timeout(scp))
7282			return 0;	/* ignore command: make trouble */
7283	}
7284	if (likely(oip->pfp))
7285		pfp = oip->pfp;	/* calls a resp_* function */
7286	else
7287		pfp = r_pfp;    /* if leaf function ptr NULL, try the root's */
7288
7289fini:
7290	if (F_DELAY_OVERR & flags)	/* cmds like INQUIRY respond asap */
7291		return schedule_resp(scp, devip, errsts, pfp, 0, 0);
7292	else if ((flags & F_LONG_DELAY) && (sdebug_jdelay > 0 ||
7293					    sdebug_ndelay > 10000)) {
7294		/*
7295		 * Skip long delays if ndelay <= 10 microseconds. Otherwise
7296		 * for Start Stop Unit (SSU) want at least 1 second delay and
7297		 * if sdebug_jdelay>1 want a long delay of that many seconds.
7298		 * For Synchronize Cache want 1/20 of SSU's delay.
7299		 */
7300		int jdelay = (sdebug_jdelay < 2) ? 1 : sdebug_jdelay;
7301		int denom = (flags & F_SYNC_DELAY) ? 20 : 1;
7302
7303		jdelay = mult_frac(USER_HZ * jdelay, HZ, denom * USER_HZ);
7304		return schedule_resp(scp, devip, errsts, pfp, jdelay, 0);
7305	} else
7306		return schedule_resp(scp, devip, errsts, pfp, sdebug_jdelay,
7307				     sdebug_ndelay);
7308check_cond:
7309	return schedule_resp(scp, devip, check_condition_result, NULL, 0, 0);
7310err_out:
7311	return schedule_resp(scp, NULL, DID_NO_CONNECT << 16, NULL, 0, 0);
7312}
7313
 
 
 
 
 
 
 
 
 
7314static struct scsi_host_template sdebug_driver_template = {
7315	.show_info =		scsi_debug_show_info,
7316	.write_info =		scsi_debug_write_info,
7317	.proc_name =		sdebug_proc_name,
7318	.name =			"SCSI DEBUG",
7319	.info =			scsi_debug_info,
7320	.slave_alloc =		scsi_debug_slave_alloc,
7321	.slave_configure =	scsi_debug_slave_configure,
7322	.slave_destroy =	scsi_debug_slave_destroy,
7323	.ioctl =		scsi_debug_ioctl,
7324	.queuecommand =		scsi_debug_queuecommand,
7325	.change_queue_depth =	sdebug_change_qdepth,
 
 
7326	.eh_abort_handler =	scsi_debug_abort,
7327	.eh_device_reset_handler = scsi_debug_device_reset,
7328	.eh_target_reset_handler = scsi_debug_target_reset,
7329	.eh_bus_reset_handler = scsi_debug_bus_reset,
7330	.eh_host_reset_handler = scsi_debug_host_reset,
7331	.can_queue =		SDEBUG_CANQUEUE,
7332	.this_id =		7,
7333	.sg_tablesize =		SG_MAX_SEGMENTS,
7334	.cmd_per_lun =		DEF_CMD_PER_LUN,
7335	.max_sectors =		-1U,
7336	.max_segment_size =	-1U,
7337	.module =		THIS_MODULE,
7338	.track_queue_depth =	1,
 
 
 
 
7339};
7340
7341static int sdebug_driver_probe(struct device *dev)
7342{
7343	int error = 0;
7344	struct sdebug_host_info *sdbg_host;
7345	struct Scsi_Host *hpnt;
7346	int hprot;
7347
7348	sdbg_host = to_sdebug_host(dev);
7349
7350	if (sdebug_host_max_queue)
7351		sdebug_driver_template.can_queue = sdebug_host_max_queue;
7352	else
7353		sdebug_driver_template.can_queue = sdebug_max_queue;
7354	if (!sdebug_clustering)
7355		sdebug_driver_template.dma_boundary = PAGE_SIZE - 1;
7356
7357	hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
7358	if (NULL == hpnt) {
7359		pr_err("scsi_host_alloc failed\n");
7360		error = -ENODEV;
7361		return error;
7362	}
7363	if (submit_queues > nr_cpu_ids) {
7364		pr_warn("%s: trim submit_queues (was %d) to nr_cpu_ids=%u\n",
7365			my_name, submit_queues, nr_cpu_ids);
7366		submit_queues = nr_cpu_ids;
7367	}
7368	/*
7369	 * Decide whether to tell scsi subsystem that we want mq. The
7370	 * following should give the same answer for each host. If the host
7371	 * has a limit of hostwide max commands, then do not set.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7372	 */
7373	if (!sdebug_host_max_queue)
7374		hpnt->nr_hw_queues = submit_queues;
 
 
 
 
 
 
 
 
7375
7376	sdbg_host->shost = hpnt;
7377	*((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
7378	if ((hpnt->this_id >= 0) && (sdebug_num_tgts > hpnt->this_id))
7379		hpnt->max_id = sdebug_num_tgts + 1;
7380	else
7381		hpnt->max_id = sdebug_num_tgts;
7382	/* = sdebug_max_luns; */
7383	hpnt->max_lun = SCSI_W_LUN_REPORT_LUNS + 1;
7384
7385	hprot = 0;
7386
7387	switch (sdebug_dif) {
7388
7389	case T10_PI_TYPE1_PROTECTION:
7390		hprot = SHOST_DIF_TYPE1_PROTECTION;
7391		if (sdebug_dix)
7392			hprot |= SHOST_DIX_TYPE1_PROTECTION;
7393		break;
7394
7395	case T10_PI_TYPE2_PROTECTION:
7396		hprot = SHOST_DIF_TYPE2_PROTECTION;
7397		if (sdebug_dix)
7398			hprot |= SHOST_DIX_TYPE2_PROTECTION;
7399		break;
7400
7401	case T10_PI_TYPE3_PROTECTION:
7402		hprot = SHOST_DIF_TYPE3_PROTECTION;
7403		if (sdebug_dix)
7404			hprot |= SHOST_DIX_TYPE3_PROTECTION;
7405		break;
7406
7407	default:
7408		if (sdebug_dix)
7409			hprot |= SHOST_DIX_TYPE0_PROTECTION;
7410		break;
7411	}
7412
7413	scsi_host_set_prot(hpnt, hprot);
7414
7415	if (have_dif_prot || sdebug_dix)
7416		pr_info("host protection%s%s%s%s%s%s%s\n",
7417			(hprot & SHOST_DIF_TYPE1_PROTECTION) ? " DIF1" : "",
7418			(hprot & SHOST_DIF_TYPE2_PROTECTION) ? " DIF2" : "",
7419			(hprot & SHOST_DIF_TYPE3_PROTECTION) ? " DIF3" : "",
7420			(hprot & SHOST_DIX_TYPE0_PROTECTION) ? " DIX0" : "",
7421			(hprot & SHOST_DIX_TYPE1_PROTECTION) ? " DIX1" : "",
7422			(hprot & SHOST_DIX_TYPE2_PROTECTION) ? " DIX2" : "",
7423			(hprot & SHOST_DIX_TYPE3_PROTECTION) ? " DIX3" : "");
7424
7425	if (sdebug_guard == 1)
7426		scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_IP);
7427	else
7428		scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_CRC);
7429
7430	sdebug_verbose = !!(SDEBUG_OPT_NOISE & sdebug_opts);
7431	sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & sdebug_opts);
7432	if (sdebug_every_nth)	/* need stats counters for every_nth */
7433		sdebug_statistics = true;
7434	error = scsi_add_host(hpnt, &sdbg_host->dev);
7435	if (error) {
7436		pr_err("scsi_add_host failed\n");
7437		error = -ENODEV;
7438		scsi_host_put(hpnt);
7439	} else {
7440		scsi_scan_host(hpnt);
7441	}
7442
7443	return error;
7444}
7445
7446static int sdebug_driver_remove(struct device *dev)
7447{
7448	struct sdebug_host_info *sdbg_host;
7449	struct sdebug_dev_info *sdbg_devinfo, *tmp;
7450
7451	sdbg_host = to_sdebug_host(dev);
7452
7453	if (!sdbg_host) {
7454		pr_err("Unable to locate host info\n");
7455		return -ENODEV;
7456	}
7457
7458	scsi_remove_host(sdbg_host->shost);
7459
7460	list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
7461				 dev_list) {
7462		list_del(&sdbg_devinfo->dev_list);
7463		kfree(sdbg_devinfo->zstate);
7464		kfree(sdbg_devinfo);
7465	}
7466
7467	scsi_host_put(sdbg_host->shost);
7468	return 0;
7469}
7470
7471static int pseudo_lld_bus_match(struct device *dev,
7472				struct device_driver *dev_driver)
7473{
7474	return 1;
7475}
7476
7477static struct bus_type pseudo_lld_bus = {
7478	.name = "pseudo",
7479	.match = pseudo_lld_bus_match,
7480	.probe = sdebug_driver_probe,
7481	.remove = sdebug_driver_remove,
7482	.drv_groups = sdebug_drv_groups,
7483};
v6.8
   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#include <linux/debugfs.h>
  45#include <linux/async.h>
  46
  47#include <net/checksum.h>
  48
  49#include <asm/unaligned.h>
  50
  51#include <scsi/scsi.h>
  52#include <scsi/scsi_cmnd.h>
  53#include <scsi/scsi_device.h>
  54#include <scsi/scsi_host.h>
  55#include <scsi/scsicam.h>
  56#include <scsi/scsi_eh.h>
  57#include <scsi/scsi_tcq.h>
  58#include <scsi/scsi_dbg.h>
  59
  60#include "sd.h"
  61#include "scsi_logging.h"
  62
  63/* make sure inq_product_rev string corresponds to this version */
  64#define SDEBUG_VERSION "0191"	/* format to fit INQUIRY revision field */
  65static const char *sdebug_version_date = "20210520";
  66
  67#define MY_NAME "scsi_debug"
  68
  69/* Additional Sense Code (ASC) */
  70#define NO_ADDITIONAL_SENSE 0x0
  71#define LOGICAL_UNIT_NOT_READY 0x4
  72#define LOGICAL_UNIT_COMMUNICATION_FAILURE 0x8
  73#define UNRECOVERED_READ_ERR 0x11
  74#define PARAMETER_LIST_LENGTH_ERR 0x1a
  75#define INVALID_OPCODE 0x20
  76#define LBA_OUT_OF_RANGE 0x21
  77#define INVALID_FIELD_IN_CDB 0x24
  78#define INVALID_FIELD_IN_PARAM_LIST 0x26
  79#define WRITE_PROTECTED 0x27
  80#define UA_RESET_ASC 0x29
  81#define UA_CHANGED_ASC 0x2a
  82#define TARGET_CHANGED_ASC 0x3f
  83#define LUNS_CHANGED_ASCQ 0x0e
  84#define INSUFF_RES_ASC 0x55
  85#define INSUFF_RES_ASCQ 0x3
  86#define POWER_ON_RESET_ASCQ 0x0
  87#define POWER_ON_OCCURRED_ASCQ 0x1
  88#define BUS_RESET_ASCQ 0x2	/* scsi bus reset occurred */
  89#define MODE_CHANGED_ASCQ 0x1	/* mode parameters changed */
  90#define CAPACITY_CHANGED_ASCQ 0x9
  91#define SAVING_PARAMS_UNSUP 0x39
  92#define TRANSPORT_PROBLEM 0x4b
  93#define THRESHOLD_EXCEEDED 0x5d
  94#define LOW_POWER_COND_ON 0x5e
  95#define MISCOMPARE_VERIFY_ASC 0x1d
  96#define MICROCODE_CHANGED_ASCQ 0x1	/* with TARGET_CHANGED_ASC */
  97#define MICROCODE_CHANGED_WO_RESET_ASCQ 0x16
  98#define WRITE_ERROR_ASC 0xc
  99#define UNALIGNED_WRITE_ASCQ 0x4
 100#define WRITE_BOUNDARY_ASCQ 0x5
 101#define READ_INVDATA_ASCQ 0x6
 102#define READ_BOUNDARY_ASCQ 0x7
 103#define ATTEMPT_ACCESS_GAP 0x9
 104#define INSUFF_ZONE_ASCQ 0xe
 105
 106/* Additional Sense Code Qualifier (ASCQ) */
 107#define ACK_NAK_TO 0x3
 108
 109/* Default values for driver parameters */
 110#define DEF_NUM_HOST   1
 111#define DEF_NUM_TGTS   1
 112#define DEF_MAX_LUNS   1
 113/* With these defaults, this driver will make 1 host with 1 target
 114 * (id 0) containing 1 logical unit (lun 0). That is 1 device.
 115 */
 116#define DEF_ATO 1
 117#define DEF_CDB_LEN 10
 118#define DEF_JDELAY   1		/* if > 0 unit is a jiffy */
 119#define DEF_DEV_SIZE_PRE_INIT   0
 120#define DEF_DEV_SIZE_MB   8
 121#define DEF_ZBC_DEV_SIZE_MB   128
 122#define DEF_DIF 0
 123#define DEF_DIX 0
 124#define DEF_PER_HOST_STORE false
 125#define DEF_D_SENSE   0
 126#define DEF_EVERY_NTH   0
 127#define DEF_FAKE_RW	0
 128#define DEF_GUARD 0
 129#define DEF_HOST_LOCK 0
 130#define DEF_LBPU 0
 131#define DEF_LBPWS 0
 132#define DEF_LBPWS10 0
 133#define DEF_LBPRZ 1
 134#define DEF_LOWEST_ALIGNED 0
 135#define DEF_NDELAY   0		/* if > 0 unit is a nanosecond */
 136#define DEF_NO_LUN_0   0
 137#define DEF_NUM_PARTS   0
 138#define DEF_OPTS   0
 139#define DEF_OPT_BLKS 1024
 140#define DEF_PHYSBLK_EXP 0
 141#define DEF_OPT_XFERLEN_EXP 0
 142#define DEF_PTYPE   TYPE_DISK
 143#define DEF_RANDOM false
 144#define DEF_REMOVABLE false
 145#define DEF_SCSI_LEVEL   7    /* INQUIRY, byte2 [6->SPC-4; 7->SPC-5] */
 146#define DEF_SECTOR_SIZE 512
 147#define DEF_UNMAP_ALIGNMENT 0
 148#define DEF_UNMAP_GRANULARITY 1
 149#define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF
 150#define DEF_UNMAP_MAX_DESC 256
 151#define DEF_VIRTUAL_GB   0
 152#define DEF_VPD_USE_HOSTNO 1
 153#define DEF_WRITESAME_LENGTH 0xFFFF
 154#define DEF_STRICT 0
 155#define DEF_STATISTICS false
 156#define DEF_SUBMIT_QUEUES 1
 157#define DEF_TUR_MS_TO_READY 0
 158#define DEF_UUID_CTL 0
 159#define JDELAY_OVERRIDDEN -9999
 160
 161/* Default parameters for ZBC drives */
 162#define DEF_ZBC_ZONE_SIZE_MB	128
 163#define DEF_ZBC_MAX_OPEN_ZONES	8
 164#define DEF_ZBC_NR_CONV_ZONES	1
 165
 166#define SDEBUG_LUN_0_VAL 0
 167
 168/* bit mask values for sdebug_opts */
 169#define SDEBUG_OPT_NOISE		1
 170#define SDEBUG_OPT_MEDIUM_ERR		2
 171#define SDEBUG_OPT_TIMEOUT		4
 172#define SDEBUG_OPT_RECOVERED_ERR	8
 173#define SDEBUG_OPT_TRANSPORT_ERR	16
 174#define SDEBUG_OPT_DIF_ERR		32
 175#define SDEBUG_OPT_DIX_ERR		64
 176#define SDEBUG_OPT_MAC_TIMEOUT		128
 177#define SDEBUG_OPT_SHORT_TRANSFER	0x100
 178#define SDEBUG_OPT_Q_NOISE		0x200
 179#define SDEBUG_OPT_ALL_TSF		0x400	/* ignore */
 180#define SDEBUG_OPT_RARE_TSF		0x800
 181#define SDEBUG_OPT_N_WCE		0x1000
 182#define SDEBUG_OPT_RESET_NOISE		0x2000
 183#define SDEBUG_OPT_NO_CDB_NOISE		0x4000
 184#define SDEBUG_OPT_HOST_BUSY		0x8000
 185#define SDEBUG_OPT_CMD_ABORT		0x10000
 186#define SDEBUG_OPT_ALL_NOISE (SDEBUG_OPT_NOISE | SDEBUG_OPT_Q_NOISE | \
 187			      SDEBUG_OPT_RESET_NOISE)
 188#define SDEBUG_OPT_ALL_INJECTING (SDEBUG_OPT_RECOVERED_ERR | \
 189				  SDEBUG_OPT_TRANSPORT_ERR | \
 190				  SDEBUG_OPT_DIF_ERR | SDEBUG_OPT_DIX_ERR | \
 191				  SDEBUG_OPT_SHORT_TRANSFER | \
 192				  SDEBUG_OPT_HOST_BUSY | \
 193				  SDEBUG_OPT_CMD_ABORT)
 194#define SDEBUG_OPT_RECOV_DIF_DIX (SDEBUG_OPT_RECOVERED_ERR | \
 195				  SDEBUG_OPT_DIF_ERR | SDEBUG_OPT_DIX_ERR)
 196
 197/* As indicated in SAM-5 and SPC-4 Unit Attentions (UAs) are returned in
 198 * priority order. In the subset implemented here lower numbers have higher
 199 * priority. The UA numbers should be a sequence starting from 0 with
 200 * SDEBUG_NUM_UAS being 1 higher than the highest numbered UA. */
 201#define SDEBUG_UA_POR 0		/* Power on, reset, or bus device reset */
 202#define SDEBUG_UA_POOCCUR 1	/* Power on occurred */
 203#define SDEBUG_UA_BUS_RESET 2
 204#define SDEBUG_UA_MODE_CHANGED 3
 205#define SDEBUG_UA_CAPACITY_CHANGED 4
 206#define SDEBUG_UA_LUNS_CHANGED 5
 207#define SDEBUG_UA_MICROCODE_CHANGED 6	/* simulate firmware change */
 208#define SDEBUG_UA_MICROCODE_CHANGED_WO_RESET 7
 209#define SDEBUG_NUM_UAS 8
 210
 211/* when 1==SDEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
 212 * sector on read commands: */
 213#define OPT_MEDIUM_ERR_ADDR   0x1234 /* that's sector 4660 in decimal */
 214#define OPT_MEDIUM_ERR_NUM    10     /* number of consecutive medium errs */
 215
 
 
 
 
 216/* SDEBUG_CANQUEUE is the maximum number of commands that can be queued
 217 * (for response) per submit queue at one time. Can be reduced by max_queue
 218 * option. Command responses are not queued when jdelay=0 and ndelay=0. The
 219 * per-device DEF_CMD_PER_LUN can be changed via sysfs:
 220 * /sys/class/scsi_device/<h:c:t:l>/device/queue_depth
 221 * but cannot exceed SDEBUG_CANQUEUE .
 222 */
 223#define SDEBUG_CANQUEUE_WORDS  3	/* a WORD is bits in a long */
 224#define SDEBUG_CANQUEUE  (SDEBUG_CANQUEUE_WORDS * BITS_PER_LONG)
 225#define DEF_CMD_PER_LUN  SDEBUG_CANQUEUE
 226
 227/* UA - Unit Attention; SA - Service Action; SSU - Start Stop Unit */
 228#define F_D_IN			1	/* Data-in command (e.g. READ) */
 229#define F_D_OUT			2	/* Data-out command (e.g. WRITE) */
 230#define F_D_OUT_MAYBE		4	/* WRITE SAME, NDOB bit */
 231#define F_D_UNKN		8
 232#define F_RL_WLUN_OK		0x10	/* allowed with REPORT LUNS W-LUN */
 233#define F_SKIP_UA		0x20	/* bypass UAs (e.g. INQUIRY command) */
 234#define F_DELAY_OVERR		0x40	/* for commands like INQUIRY */
 235#define F_SA_LOW		0x80	/* SA is in cdb byte 1, bits 4 to 0 */
 236#define F_SA_HIGH		0x100	/* SA is in cdb bytes 8 and 9 */
 237#define F_INV_OP		0x200	/* invalid opcode (not supported) */
 238#define F_FAKE_RW		0x400	/* bypass resp_*() when fake_rw set */
 239#define F_M_ACCESS		0x800	/* media access, reacts to SSU state */
 240#define F_SSU_DELAY		0x1000	/* SSU command delay (long-ish) */
 241#define F_SYNC_DELAY		0x2000	/* SYNCHRONIZE CACHE delay */
 242
 243/* Useful combinations of the above flags */
 244#define FF_RESPOND (F_RL_WLUN_OK | F_SKIP_UA | F_DELAY_OVERR)
 245#define FF_MEDIA_IO (F_M_ACCESS | F_FAKE_RW)
 246#define FF_SA (F_SA_HIGH | F_SA_LOW)
 247#define F_LONG_DELAY		(F_SSU_DELAY | F_SYNC_DELAY)
 248
 249#define SDEBUG_MAX_PARTS 4
 250
 251#define SDEBUG_MAX_CMD_LEN 32
 252
 253#define SDEB_XA_NOT_IN_USE XA_MARK_1
 254
 255static struct kmem_cache *queued_cmd_cache;
 256
 257#define TO_QUEUED_CMD(scmd)  ((void *)(scmd)->host_scribble)
 258#define ASSIGN_QUEUED_CMD(scmnd, qc) { (scmnd)->host_scribble = (void *) qc; }
 259
 260/* Zone types (zbcr05 table 25) */
 261enum sdebug_z_type {
 262	ZBC_ZTYPE_CNV	= 0x1,
 263	ZBC_ZTYPE_SWR	= 0x2,
 264	ZBC_ZTYPE_SWP	= 0x3,
 265	/* ZBC_ZTYPE_SOBR = 0x4, */
 266	ZBC_ZTYPE_GAP	= 0x5,
 267};
 268
 269/* enumeration names taken from table 26, zbcr05 */
 270enum sdebug_z_cond {
 271	ZBC_NOT_WRITE_POINTER	= 0x0,
 272	ZC1_EMPTY		= 0x1,
 273	ZC2_IMPLICIT_OPEN	= 0x2,
 274	ZC3_EXPLICIT_OPEN	= 0x3,
 275	ZC4_CLOSED		= 0x4,
 276	ZC6_READ_ONLY		= 0xd,
 277	ZC5_FULL		= 0xe,
 278	ZC7_OFFLINE		= 0xf,
 279};
 280
 281struct sdeb_zone_state {	/* ZBC: per zone state */
 282	enum sdebug_z_type z_type;
 283	enum sdebug_z_cond z_cond;
 284	bool z_non_seq_resource;
 285	unsigned int z_size;
 286	sector_t z_start;
 287	sector_t z_wp;
 288};
 289
 290enum sdebug_err_type {
 291	ERR_TMOUT_CMD		= 0,	/* make specific scsi command timeout */
 292	ERR_FAIL_QUEUE_CMD	= 1,	/* make specific scsi command's */
 293					/* queuecmd return failed */
 294	ERR_FAIL_CMD		= 2,	/* make specific scsi command's */
 295					/* queuecmd return succeed but */
 296					/* with errors set in scsi_cmnd */
 297	ERR_ABORT_CMD_FAILED	= 3,	/* control return FAILED from */
 298					/* scsi_debug_abort() */
 299	ERR_LUN_RESET_FAILED	= 4,	/* control return FAILED from */
 300					/* scsi_debug_device_reseLUN_RESET_FAILEDt() */
 301};
 302
 303struct sdebug_err_inject {
 304	int type;
 305	struct list_head list;
 306	int cnt;
 307	unsigned char cmd;
 308	struct rcu_head rcu;
 309
 310	union {
 311		/*
 312		 * For ERR_FAIL_QUEUE_CMD
 313		 */
 314		int queuecmd_ret;
 315
 316		/*
 317		 * For ERR_FAIL_CMD
 318		 */
 319		struct {
 320			unsigned char host_byte;
 321			unsigned char driver_byte;
 322			unsigned char status_byte;
 323			unsigned char sense_key;
 324			unsigned char asc;
 325			unsigned char asq;
 326		};
 327	};
 328};
 329
 330struct sdebug_dev_info {
 331	struct list_head dev_list;
 332	unsigned int channel;
 333	unsigned int target;
 334	u64 lun;
 335	uuid_t lu_name;
 336	struct sdebug_host_info *sdbg_host;
 337	unsigned long uas_bm[1];
 
 338	atomic_t stopped;	/* 1: by SSU, 2: device start */
 339	bool used;
 340
 341	/* For ZBC devices */
 342	bool zoned;
 343	unsigned int zcap;
 344	unsigned int zsize;
 345	unsigned int zsize_shift;
 346	unsigned int nr_zones;
 347	unsigned int nr_conv_zones;
 348	unsigned int nr_seq_zones;
 349	unsigned int nr_imp_open;
 350	unsigned int nr_exp_open;
 351	unsigned int nr_closed;
 352	unsigned int max_open;
 353	ktime_t create_ts;	/* time since bootup that this device was created */
 354	struct sdeb_zone_state *zstate;
 355
 356	struct dentry *debugfs_entry;
 357	struct spinlock list_lock;
 358	struct list_head inject_err_list;
 359};
 360
 361struct sdebug_target_info {
 362	bool reset_fail;
 363	struct dentry *debugfs_entry;
 364};
 365
 366struct sdebug_host_info {
 367	struct list_head host_list;
 368	int si_idx;	/* sdeb_store_info (per host) xarray index */
 369	struct Scsi_Host *shost;
 370	struct device dev;
 371	struct list_head dev_info_list;
 372};
 373
 374/* There is an xarray of pointers to this struct's objects, one per host */
 375struct sdeb_store_info {
 376	rwlock_t macc_lck;	/* for atomic media access on this store */
 377	u8 *storep;		/* user data storage (ram) */
 378	struct t10_pi_tuple *dif_storep; /* protection info */
 379	void *map_storep;	/* provisioning map */
 380};
 381
 382#define dev_to_sdebug_host(d)	\
 383	container_of(d, struct sdebug_host_info, dev)
 384
 385#define shost_to_sdebug_host(shost)	\
 386	dev_to_sdebug_host(shost->dma_dev)
 387
 388enum sdeb_defer_type {SDEB_DEFER_NONE = 0, SDEB_DEFER_HRT = 1,
 389		      SDEB_DEFER_WQ = 2, SDEB_DEFER_POLL = 3};
 390
 391struct sdebug_defer {
 392	struct hrtimer hrt;
 393	struct execute_work ew;
 394	ktime_t cmpl_ts;/* time since boot to complete this cmd */
 
 
 395	int issuing_cpu;
 
 
 396	bool aborted;	/* true when blk_abort_request() already called */
 397	enum sdeb_defer_type defer_t;
 398};
 399
 400struct sdebug_queued_cmd {
 401	/* corresponding bit set in in_use_bm[] in owning struct sdebug_queue
 402	 * instance indicates this slot is in use.
 403	 */
 404	struct sdebug_defer sd_dp;
 405	struct scsi_cmnd *scmd;
 406};
 407
 408struct sdebug_scsi_cmd {
 409	spinlock_t   lock;
 
 
 
 410};
 411
 412static atomic_t sdebug_cmnd_count;   /* number of incoming commands */
 413static atomic_t sdebug_completions;  /* count of deferred completions */
 414static atomic_t sdebug_miss_cpus;    /* submission + completion cpus differ */
 415static atomic_t sdebug_a_tsf;	     /* 'almost task set full' counter */
 416static atomic_t sdeb_inject_pending;
 417static atomic_t sdeb_mq_poll_count;  /* bumped when mq_poll returns > 0 */
 418
 419struct opcode_info_t {
 420	u8 num_attached;	/* 0 if this is it (i.e. a leaf); use 0xff */
 421				/* for terminating element */
 422	u8 opcode;		/* if num_attached > 0, preferred */
 423	u16 sa;			/* service action */
 424	u32 flags;		/* OR-ed set of SDEB_F_* */
 425	int (*pfp)(struct scsi_cmnd *, struct sdebug_dev_info *);
 426	const struct opcode_info_t *arrp;  /* num_attached elements or NULL */
 427	u8 len_mask[16];	/* len_mask[0]-->cdb_len, then mask for cdb */
 428				/* 1 to min(cdb_len, 15); ignore cdb[15...] */
 429};
 430
 431/* SCSI opcodes (first byte of cdb) of interest mapped onto these indexes */
 432enum sdeb_opcode_index {
 433	SDEB_I_INVALID_OPCODE =	0,
 434	SDEB_I_INQUIRY = 1,
 435	SDEB_I_REPORT_LUNS = 2,
 436	SDEB_I_REQUEST_SENSE = 3,
 437	SDEB_I_TEST_UNIT_READY = 4,
 438	SDEB_I_MODE_SENSE = 5,		/* 6, 10 */
 439	SDEB_I_MODE_SELECT = 6,		/* 6, 10 */
 440	SDEB_I_LOG_SENSE = 7,
 441	SDEB_I_READ_CAPACITY = 8,	/* 10; 16 is in SA_IN(16) */
 442	SDEB_I_READ = 9,		/* 6, 10, 12, 16 */
 443	SDEB_I_WRITE = 10,		/* 6, 10, 12, 16 */
 444	SDEB_I_START_STOP = 11,
 445	SDEB_I_SERV_ACT_IN_16 = 12,	/* add ...SERV_ACT_IN_12 if needed */
 446	SDEB_I_SERV_ACT_OUT_16 = 13,	/* add ...SERV_ACT_OUT_12 if needed */
 447	SDEB_I_MAINT_IN = 14,
 448	SDEB_I_MAINT_OUT = 15,
 449	SDEB_I_VERIFY = 16,		/* VERIFY(10), VERIFY(16) */
 450	SDEB_I_VARIABLE_LEN = 17,	/* READ(32), WRITE(32), WR_SCAT(32) */
 451	SDEB_I_RESERVE = 18,		/* 6, 10 */
 452	SDEB_I_RELEASE = 19,		/* 6, 10 */
 453	SDEB_I_ALLOW_REMOVAL = 20,	/* PREVENT ALLOW MEDIUM REMOVAL */
 454	SDEB_I_REZERO_UNIT = 21,	/* REWIND in SSC */
 455	SDEB_I_ATA_PT = 22,		/* 12, 16 */
 456	SDEB_I_SEND_DIAG = 23,
 457	SDEB_I_UNMAP = 24,
 458	SDEB_I_WRITE_BUFFER = 25,
 459	SDEB_I_WRITE_SAME = 26,		/* 10, 16 */
 460	SDEB_I_SYNC_CACHE = 27,		/* 10, 16 */
 461	SDEB_I_COMP_WRITE = 28,
 462	SDEB_I_PRE_FETCH = 29,		/* 10, 16 */
 463	SDEB_I_ZONE_OUT = 30,		/* 0x94+SA; includes no data xfer */
 464	SDEB_I_ZONE_IN = 31,		/* 0x95+SA; all have data-in */
 465	SDEB_I_LAST_ELEM_P1 = 32,	/* keep this last (previous + 1) */
 466};
 467
 468
 469static const unsigned char opcode_ind_arr[256] = {
 470/* 0x0; 0x0->0x1f: 6 byte cdbs */
 471	SDEB_I_TEST_UNIT_READY, SDEB_I_REZERO_UNIT, 0, SDEB_I_REQUEST_SENSE,
 472	    0, 0, 0, 0,
 473	SDEB_I_READ, 0, SDEB_I_WRITE, 0, 0, 0, 0, 0,
 474	0, 0, SDEB_I_INQUIRY, 0, 0, SDEB_I_MODE_SELECT, SDEB_I_RESERVE,
 475	    SDEB_I_RELEASE,
 476	0, 0, SDEB_I_MODE_SENSE, SDEB_I_START_STOP, 0, SDEB_I_SEND_DIAG,
 477	    SDEB_I_ALLOW_REMOVAL, 0,
 478/* 0x20; 0x20->0x3f: 10 byte cdbs */
 479	0, 0, 0, 0, 0, SDEB_I_READ_CAPACITY, 0, 0,
 480	SDEB_I_READ, 0, SDEB_I_WRITE, 0, 0, 0, 0, SDEB_I_VERIFY,
 481	0, 0, 0, 0, SDEB_I_PRE_FETCH, SDEB_I_SYNC_CACHE, 0, 0,
 482	0, 0, 0, SDEB_I_WRITE_BUFFER, 0, 0, 0, 0,
 483/* 0x40; 0x40->0x5f: 10 byte cdbs */
 484	0, SDEB_I_WRITE_SAME, SDEB_I_UNMAP, 0, 0, 0, 0, 0,
 485	0, 0, 0, 0, 0, SDEB_I_LOG_SENSE, 0, 0,
 486	0, 0, 0, 0, 0, SDEB_I_MODE_SELECT, SDEB_I_RESERVE,
 487	    SDEB_I_RELEASE,
 488	0, 0, SDEB_I_MODE_SENSE, 0, 0, 0, 0, 0,
 489/* 0x60; 0x60->0x7d are reserved, 0x7e is "extended cdb" */
 490	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 491	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 492	0, SDEB_I_VARIABLE_LEN,
 493/* 0x80; 0x80->0x9f: 16 byte cdbs */
 494	0, 0, 0, 0, 0, SDEB_I_ATA_PT, 0, 0,
 495	SDEB_I_READ, SDEB_I_COMP_WRITE, SDEB_I_WRITE, 0,
 496	0, 0, 0, SDEB_I_VERIFY,
 497	SDEB_I_PRE_FETCH, SDEB_I_SYNC_CACHE, 0, SDEB_I_WRITE_SAME,
 498	SDEB_I_ZONE_OUT, SDEB_I_ZONE_IN, 0, 0,
 499	0, 0, 0, 0, 0, 0, SDEB_I_SERV_ACT_IN_16, SDEB_I_SERV_ACT_OUT_16,
 500/* 0xa0; 0xa0->0xbf: 12 byte cdbs */
 501	SDEB_I_REPORT_LUNS, SDEB_I_ATA_PT, 0, SDEB_I_MAINT_IN,
 502	     SDEB_I_MAINT_OUT, 0, 0, 0,
 503	SDEB_I_READ, 0 /* SDEB_I_SERV_ACT_OUT_12 */, SDEB_I_WRITE,
 504	     0 /* SDEB_I_SERV_ACT_IN_12 */, 0, 0, 0, 0,
 505	0, 0, 0, 0, 0, 0, 0, 0,
 506	0, 0, 0, 0, 0, 0, 0, 0,
 507/* 0xc0; 0xc0->0xff: vendor specific */
 508	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 509	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 510	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 511	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 512};
 513
 514/*
 515 * The following "response" functions return the SCSI mid-level's 4 byte
 516 * tuple-in-an-int. To handle commands with an IMMED bit, for a faster
 517 * command completion, they can mask their return value with
 518 * SDEG_RES_IMMED_MASK .
 519 */
 520#define SDEG_RES_IMMED_MASK 0x40000000
 521
 522static int resp_inquiry(struct scsi_cmnd *, struct sdebug_dev_info *);
 523static int resp_report_luns(struct scsi_cmnd *, struct sdebug_dev_info *);
 524static int resp_requests(struct scsi_cmnd *, struct sdebug_dev_info *);
 525static int resp_mode_sense(struct scsi_cmnd *, struct sdebug_dev_info *);
 526static int resp_mode_select(struct scsi_cmnd *, struct sdebug_dev_info *);
 527static int resp_log_sense(struct scsi_cmnd *, struct sdebug_dev_info *);
 528static int resp_readcap(struct scsi_cmnd *, struct sdebug_dev_info *);
 529static int resp_read_dt0(struct scsi_cmnd *, struct sdebug_dev_info *);
 530static int resp_write_dt0(struct scsi_cmnd *, struct sdebug_dev_info *);
 531static int resp_write_scat(struct scsi_cmnd *, struct sdebug_dev_info *);
 532static int resp_start_stop(struct scsi_cmnd *, struct sdebug_dev_info *);
 533static int resp_readcap16(struct scsi_cmnd *, struct sdebug_dev_info *);
 534static int resp_get_lba_status(struct scsi_cmnd *, struct sdebug_dev_info *);
 535static int resp_report_tgtpgs(struct scsi_cmnd *, struct sdebug_dev_info *);
 536static int resp_unmap(struct scsi_cmnd *, struct sdebug_dev_info *);
 537static int resp_rsup_opcodes(struct scsi_cmnd *, struct sdebug_dev_info *);
 538static int resp_rsup_tmfs(struct scsi_cmnd *, struct sdebug_dev_info *);
 539static int resp_verify(struct scsi_cmnd *, struct sdebug_dev_info *);
 540static int resp_write_same_10(struct scsi_cmnd *, struct sdebug_dev_info *);
 541static int resp_write_same_16(struct scsi_cmnd *, struct sdebug_dev_info *);
 542static int resp_comp_write(struct scsi_cmnd *, struct sdebug_dev_info *);
 543static int resp_write_buffer(struct scsi_cmnd *, struct sdebug_dev_info *);
 544static int resp_sync_cache(struct scsi_cmnd *, struct sdebug_dev_info *);
 545static int resp_pre_fetch(struct scsi_cmnd *, struct sdebug_dev_info *);
 546static int resp_report_zones(struct scsi_cmnd *, struct sdebug_dev_info *);
 547static int resp_open_zone(struct scsi_cmnd *, struct sdebug_dev_info *);
 548static int resp_close_zone(struct scsi_cmnd *, struct sdebug_dev_info *);
 549static int resp_finish_zone(struct scsi_cmnd *, struct sdebug_dev_info *);
 550static int resp_rwp_zone(struct scsi_cmnd *, struct sdebug_dev_info *);
 551
 552static int sdebug_do_add_host(bool mk_new_store);
 553static int sdebug_add_host_helper(int per_host_idx);
 554static void sdebug_do_remove_host(bool the_end);
 555static int sdebug_add_store(void);
 556static void sdebug_erase_store(int idx, struct sdeb_store_info *sip);
 557static void sdebug_erase_all_stores(bool apart_from_first);
 558
 559static void sdebug_free_queued_cmd(struct sdebug_queued_cmd *sqcp);
 560
 561/*
 562 * The following are overflow arrays for cdbs that "hit" the same index in
 563 * the opcode_info_arr array. The most time sensitive (or commonly used) cdb
 564 * should be placed in opcode_info_arr[], the others should be placed here.
 565 */
 566static const struct opcode_info_t msense_iarr[] = {
 567	{0, 0x1a, 0, F_D_IN, NULL, NULL,
 568	    {6,  0xe8, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 569};
 570
 571static const struct opcode_info_t mselect_iarr[] = {
 572	{0, 0x15, 0, F_D_OUT, NULL, NULL,
 573	    {6,  0xf1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 574};
 575
 576static const struct opcode_info_t read_iarr[] = {
 577	{0, 0x28, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL,/* READ(10) */
 578	    {10,  0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
 579	     0, 0, 0, 0} },
 580	{0, 0x8, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL, /* READ(6) */
 581	    {6,  0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 582	{0, 0xa8, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL,/* READ(12) */
 583	    {12,  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf,
 584	     0xc7, 0, 0, 0, 0} },
 585};
 586
 587static const struct opcode_info_t write_iarr[] = {
 588	{0, 0x2a, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0,  /* WRITE(10) */
 589	    NULL, {10,  0xfb, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7,
 590		   0, 0, 0, 0, 0, 0} },
 591	{0, 0xa, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0,   /* WRITE(6) */
 592	    NULL, {6,  0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0,
 593		   0, 0, 0} },
 594	{0, 0xaa, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0,  /* WRITE(12) */
 595	    NULL, {12,  0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 596		   0xbf, 0xc7, 0, 0, 0, 0} },
 597};
 598
 599static const struct opcode_info_t verify_iarr[] = {
 600	{0, 0x2f, 0, F_D_OUT_MAYBE | FF_MEDIA_IO, resp_verify,/* VERIFY(10) */
 601	    NULL, {10,  0xf7, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xc7,
 602		   0, 0, 0, 0, 0, 0} },
 603};
 604
 605static const struct opcode_info_t sa_in_16_iarr[] = {
 606	{0, 0x9e, 0x12, F_SA_LOW | F_D_IN, resp_get_lba_status, NULL,
 607	    {16,  0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 608	     0xff, 0xff, 0xff, 0, 0xc7} },	/* GET LBA STATUS(16) */
 609};
 610
 611static const struct opcode_info_t vl_iarr[] = {	/* VARIABLE LENGTH */
 612	{0, 0x7f, 0xb, F_SA_HIGH | F_D_OUT | FF_MEDIA_IO, resp_write_dt0,
 613	    NULL, {32,  0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0xb, 0xfa,
 614		   0, 0xff, 0xff, 0xff, 0xff} },	/* WRITE(32) */
 615	{0, 0x7f, 0x11, F_SA_HIGH | F_D_OUT | FF_MEDIA_IO, resp_write_scat,
 616	    NULL, {32,  0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0x11, 0xf8,
 617		   0, 0xff, 0xff, 0x0, 0x0} },	/* WRITE SCATTERED(32) */
 618};
 619
 620static const struct opcode_info_t maint_in_iarr[] = {	/* MAINT IN */
 621	{0, 0xa3, 0xc, F_SA_LOW | F_D_IN, resp_rsup_opcodes, NULL,
 622	    {12,  0xc, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0,
 623	     0xc7, 0, 0, 0, 0} }, /* REPORT SUPPORTED OPERATION CODES */
 624	{0, 0xa3, 0xd, F_SA_LOW | F_D_IN, resp_rsup_tmfs, NULL,
 625	    {12,  0xd, 0x80, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0,
 626	     0, 0} },	/* REPORTED SUPPORTED TASK MANAGEMENT FUNCTIONS */
 627};
 628
 629static const struct opcode_info_t write_same_iarr[] = {
 630	{0, 0x93, 0, F_D_OUT_MAYBE | FF_MEDIA_IO, resp_write_same_16, NULL,
 631	    {16,  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 632	     0xff, 0xff, 0xff, 0x3f, 0xc7} },		/* WRITE SAME(16) */
 633};
 634
 635static const struct opcode_info_t reserve_iarr[] = {
 636	{0, 0x16, 0, F_D_OUT, NULL, NULL,		/* RESERVE(6) */
 637	    {6,  0x1f, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 638};
 639
 640static const struct opcode_info_t release_iarr[] = {
 641	{0, 0x17, 0, F_D_OUT, NULL, NULL,		/* RELEASE(6) */
 642	    {6,  0x1f, 0xff, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 643};
 644
 645static const struct opcode_info_t sync_cache_iarr[] = {
 646	{0, 0x91, 0, F_SYNC_DELAY | F_M_ACCESS, resp_sync_cache, NULL,
 647	    {16,  0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 648	     0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} },	/* SYNC_CACHE (16) */
 649};
 650
 651static const struct opcode_info_t pre_fetch_iarr[] = {
 652	{0, 0x90, 0, F_SYNC_DELAY | FF_MEDIA_IO, resp_pre_fetch, NULL,
 653	    {16,  0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 654	     0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} },	/* PRE-FETCH (16) */
 655};
 656
 657static const struct opcode_info_t zone_out_iarr[] = {	/* ZONE OUT(16) */
 658	{0, 0x94, 0x1, F_SA_LOW | F_M_ACCESS, resp_close_zone, NULL,
 659	    {16, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 660	     0xff, 0, 0, 0xff, 0xff, 0x1, 0xc7} },	/* CLOSE ZONE */
 661	{0, 0x94, 0x2, F_SA_LOW | F_M_ACCESS, resp_finish_zone, NULL,
 662	    {16, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 663	     0xff, 0, 0, 0xff, 0xff, 0x1, 0xc7} },	/* FINISH ZONE */
 664	{0, 0x94, 0x4, F_SA_LOW | F_M_ACCESS, resp_rwp_zone, NULL,
 665	    {16, 0x4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 666	     0xff, 0, 0, 0xff, 0xff, 0x1, 0xc7} },  /* RESET WRITE POINTER */
 667};
 668
 669static const struct opcode_info_t zone_in_iarr[] = {	/* ZONE IN(16) */
 670	{0, 0x95, 0x6, F_SA_LOW | F_D_IN | F_M_ACCESS, NULL, NULL,
 671	    {16, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 672	     0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} }, /* REPORT ZONES */
 673};
 674
 675
 676/* This array is accessed via SDEB_I_* values. Make sure all are mapped,
 677 * plus the terminating elements for logic that scans this table such as
 678 * REPORT SUPPORTED OPERATION CODES. */
 679static const struct opcode_info_t opcode_info_arr[SDEB_I_LAST_ELEM_P1 + 1] = {
 680/* 0 */
 681	{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL,	/* unknown opcodes */
 682	    {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 683	{0, 0x12, 0, FF_RESPOND | F_D_IN, resp_inquiry, NULL, /* INQUIRY */
 684	    {6,  0xe3, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 685	{0, 0xa0, 0, FF_RESPOND | F_D_IN, resp_report_luns, NULL,
 686	    {12,  0xe3, 0xff, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0,
 687	     0, 0} },					/* REPORT LUNS */
 688	{0, 0x3, 0, FF_RESPOND | F_D_IN, resp_requests, NULL,
 689	    {6,  0xe1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 690	{0, 0x0, 0, F_M_ACCESS | F_RL_WLUN_OK, NULL, NULL,/* TEST UNIT READY */
 691	    {6,  0, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 692/* 5 */
 693	{ARRAY_SIZE(msense_iarr), 0x5a, 0, F_D_IN,	/* MODE SENSE(10) */
 694	    resp_mode_sense, msense_iarr, {10,  0xf8, 0xff, 0xff, 0, 0, 0,
 695		0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
 696	{ARRAY_SIZE(mselect_iarr), 0x55, 0, F_D_OUT,	/* MODE SELECT(10) */
 697	    resp_mode_select, mselect_iarr, {10,  0xf1, 0, 0, 0, 0, 0, 0xff,
 698		0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
 699	{0, 0x4d, 0, F_D_IN, resp_log_sense, NULL,	/* LOG SENSE */
 700	    {10,  0xe3, 0xff, 0xff, 0, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0,
 701	     0, 0, 0} },
 702	{0, 0x25, 0, F_D_IN, resp_readcap, NULL,    /* READ CAPACITY(10) */
 703	    {10,  0xe1, 0xff, 0xff, 0xff, 0xff, 0, 0, 0x1, 0xc7, 0, 0, 0, 0,
 704	     0, 0} },
 705	{ARRAY_SIZE(read_iarr), 0x88, 0, F_D_IN | FF_MEDIA_IO, /* READ(16) */
 706	    resp_read_dt0, read_iarr, {16,  0xfe, 0xff, 0xff, 0xff, 0xff,
 707	    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7} },
 708/* 10 */
 709	{ARRAY_SIZE(write_iarr), 0x8a, 0, F_D_OUT | FF_MEDIA_IO,
 710	    resp_write_dt0, write_iarr,			/* WRITE(16) */
 711		{16,  0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 712		 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7} },
 713	{0, 0x1b, 0, F_SSU_DELAY, resp_start_stop, NULL,/* START STOP UNIT */
 714	    {6,  0x1, 0, 0xf, 0xf7, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 715	{ARRAY_SIZE(sa_in_16_iarr), 0x9e, 0x10, F_SA_LOW | F_D_IN,
 716	    resp_readcap16, sa_in_16_iarr, /* SA_IN(16), READ CAPACITY(16) */
 717		{16,  0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 718		 0xff, 0xff, 0xff, 0xff, 0x1, 0xc7} },
 719	{0, 0x9f, 0x12, F_SA_LOW | F_D_OUT | FF_MEDIA_IO, resp_write_scat,
 720	    NULL, {16,  0x12, 0xf9, 0x0, 0xff, 0xff, 0, 0, 0xff, 0xff, 0xff,
 721	    0xff, 0xff, 0xff, 0xff, 0xc7} },  /* SA_OUT(16), WRITE SCAT(16) */
 722	{ARRAY_SIZE(maint_in_iarr), 0xa3, 0xa, F_SA_LOW | F_D_IN,
 723	    resp_report_tgtpgs,	/* MAINT IN, REPORT TARGET PORT GROUPS */
 724		maint_in_iarr, {12,  0xea, 0, 0, 0, 0, 0xff, 0xff, 0xff,
 725				0xff, 0, 0xc7, 0, 0, 0, 0} },
 726/* 15 */
 727	{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* MAINT OUT */
 728	    {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 729	{ARRAY_SIZE(verify_iarr), 0x8f, 0,
 730	    F_D_OUT_MAYBE | FF_MEDIA_IO, resp_verify,	/* VERIFY(16) */
 731	    verify_iarr, {16,  0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 732			  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} },
 733	{ARRAY_SIZE(vl_iarr), 0x7f, 0x9, F_SA_HIGH | F_D_IN | FF_MEDIA_IO,
 734	    resp_read_dt0, vl_iarr,	/* VARIABLE LENGTH, READ(32) */
 735	    {32,  0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0x9, 0xfe, 0, 0xff, 0xff,
 736	     0xff, 0xff} },
 737	{ARRAY_SIZE(reserve_iarr), 0x56, 0, F_D_OUT,
 738	    NULL, reserve_iarr,	/* RESERVE(10) <no response function> */
 739	    {10,  0xff, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
 740	     0} },
 741	{ARRAY_SIZE(release_iarr), 0x57, 0, F_D_OUT,
 742	    NULL, release_iarr, /* RELEASE(10) <no response function> */
 743	    {10,  0x13, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
 744	     0} },
 745/* 20 */
 746	{0, 0x1e, 0, 0, NULL, NULL, /* ALLOW REMOVAL */
 747	    {6,  0, 0, 0, 0x3, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 748	{0, 0x1, 0, 0, resp_start_stop, NULL, /* REWIND ?? */
 749	    {6,  0x1, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 750	{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* ATA_PT */
 751	    {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 752	{0, 0x1d, F_D_OUT, 0, NULL, NULL,	/* SEND DIAGNOSTIC */
 753	    {6,  0xf7, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 754	{0, 0x42, 0, F_D_OUT | FF_MEDIA_IO, resp_unmap, NULL, /* UNMAP */
 755	    {10,  0x1, 0, 0, 0, 0, 0x3f, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
 756/* 25 */
 757	{0, 0x3b, 0, F_D_OUT_MAYBE, resp_write_buffer, NULL,
 758	    {10,  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0,
 759	     0, 0, 0, 0} },			/* WRITE_BUFFER */
 760	{ARRAY_SIZE(write_same_iarr), 0x41, 0, F_D_OUT_MAYBE | FF_MEDIA_IO,
 761	    resp_write_same_10, write_same_iarr,	/* WRITE SAME(10) */
 762		{10,  0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0,
 763		 0, 0, 0, 0, 0} },
 764	{ARRAY_SIZE(sync_cache_iarr), 0x35, 0, F_SYNC_DELAY | F_M_ACCESS,
 765	    resp_sync_cache, sync_cache_iarr,
 766	    {10,  0x7, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
 767	     0, 0, 0, 0} },			/* SYNC_CACHE (10) */
 768	{0, 0x89, 0, F_D_OUT | FF_MEDIA_IO, resp_comp_write, NULL,
 769	    {16,  0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0,
 770	     0, 0xff, 0x3f, 0xc7} },		/* COMPARE AND WRITE */
 771	{ARRAY_SIZE(pre_fetch_iarr), 0x34, 0, F_SYNC_DELAY | FF_MEDIA_IO,
 772	    resp_pre_fetch, pre_fetch_iarr,
 773	    {10,  0x2, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
 774	     0, 0, 0, 0} },			/* PRE-FETCH (10) */
 775
 776/* 30 */
 777	{ARRAY_SIZE(zone_out_iarr), 0x94, 0x3, F_SA_LOW | F_M_ACCESS,
 778	    resp_open_zone, zone_out_iarr, /* ZONE_OUT(16), OPEN ZONE) */
 779		{16,  0x3 /* SA */, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 780		 0xff, 0xff, 0x0, 0x0, 0xff, 0xff, 0x1, 0xc7} },
 781	{ARRAY_SIZE(zone_in_iarr), 0x95, 0x0, F_SA_LOW | F_M_ACCESS,
 782	    resp_report_zones, zone_in_iarr, /* ZONE_IN(16), REPORT ZONES) */
 783		{16,  0x0 /* SA */, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 784		 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xc7} },
 785/* sentinel */
 786	{0xff, 0, 0, 0, NULL, NULL,		/* terminating element */
 787	    {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
 788};
 789
 790static int sdebug_num_hosts;
 791static int sdebug_add_host = DEF_NUM_HOST;  /* in sysfs this is relative */
 792static int sdebug_ato = DEF_ATO;
 793static int sdebug_cdb_len = DEF_CDB_LEN;
 794static int sdebug_jdelay = DEF_JDELAY;	/* if > 0 then unit is jiffies */
 795static int sdebug_dev_size_mb = DEF_DEV_SIZE_PRE_INIT;
 796static int sdebug_dif = DEF_DIF;
 797static int sdebug_dix = DEF_DIX;
 798static int sdebug_dsense = DEF_D_SENSE;
 799static int sdebug_every_nth = DEF_EVERY_NTH;
 800static int sdebug_fake_rw = DEF_FAKE_RW;
 801static unsigned int sdebug_guard = DEF_GUARD;
 802static int sdebug_host_max_queue;	/* per host */
 803static int sdebug_lowest_aligned = DEF_LOWEST_ALIGNED;
 804static int sdebug_max_luns = DEF_MAX_LUNS;
 805static int sdebug_max_queue = SDEBUG_CANQUEUE;	/* per submit queue */
 806static unsigned int sdebug_medium_error_start = OPT_MEDIUM_ERR_ADDR;
 807static int sdebug_medium_error_count = OPT_MEDIUM_ERR_NUM;
 
 808static int sdebug_ndelay = DEF_NDELAY;	/* if > 0 then unit is nanoseconds */
 809static int sdebug_no_lun_0 = DEF_NO_LUN_0;
 810static int sdebug_no_uld;
 811static int sdebug_num_parts = DEF_NUM_PARTS;
 812static int sdebug_num_tgts = DEF_NUM_TGTS; /* targets per host */
 813static int sdebug_opt_blks = DEF_OPT_BLKS;
 814static int sdebug_opts = DEF_OPTS;
 815static int sdebug_physblk_exp = DEF_PHYSBLK_EXP;
 816static int sdebug_opt_xferlen_exp = DEF_OPT_XFERLEN_EXP;
 817static int sdebug_ptype = DEF_PTYPE; /* SCSI peripheral device type */
 818static int sdebug_scsi_level = DEF_SCSI_LEVEL;
 819static int sdebug_sector_size = DEF_SECTOR_SIZE;
 820static int sdeb_tur_ms_to_ready = DEF_TUR_MS_TO_READY;
 821static int sdebug_virtual_gb = DEF_VIRTUAL_GB;
 822static int sdebug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
 823static unsigned int sdebug_lbpu = DEF_LBPU;
 824static unsigned int sdebug_lbpws = DEF_LBPWS;
 825static unsigned int sdebug_lbpws10 = DEF_LBPWS10;
 826static unsigned int sdebug_lbprz = DEF_LBPRZ;
 827static unsigned int sdebug_unmap_alignment = DEF_UNMAP_ALIGNMENT;
 828static unsigned int sdebug_unmap_granularity = DEF_UNMAP_GRANULARITY;
 829static unsigned int sdebug_unmap_max_blocks = DEF_UNMAP_MAX_BLOCKS;
 830static unsigned int sdebug_unmap_max_desc = DEF_UNMAP_MAX_DESC;
 831static unsigned int sdebug_write_same_length = DEF_WRITESAME_LENGTH;
 832static int sdebug_uuid_ctl = DEF_UUID_CTL;
 833static bool sdebug_random = DEF_RANDOM;
 834static bool sdebug_per_host_store = DEF_PER_HOST_STORE;
 835static bool sdebug_removable = DEF_REMOVABLE;
 836static bool sdebug_clustering;
 837static bool sdebug_host_lock = DEF_HOST_LOCK;
 838static bool sdebug_strict = DEF_STRICT;
 839static bool sdebug_any_injecting_opt;
 840static bool sdebug_no_rwlock;
 841static bool sdebug_verbose;
 842static bool have_dif_prot;
 843static bool write_since_sync;
 844static bool sdebug_statistics = DEF_STATISTICS;
 845static bool sdebug_wp;
 846static bool sdebug_allow_restart;
 847static enum {
 848	BLK_ZONED_NONE	= 0,
 849	BLK_ZONED_HA	= 1,
 850	BLK_ZONED_HM	= 2,
 851} sdeb_zbc_model = BLK_ZONED_NONE;
 852static char *sdeb_zbc_model_s;
 853
 854enum sam_lun_addr_method {SAM_LUN_AM_PERIPHERAL = 0x0,
 855			  SAM_LUN_AM_FLAT = 0x1,
 856			  SAM_LUN_AM_LOGICAL_UNIT = 0x2,
 857			  SAM_LUN_AM_EXTENDED = 0x3};
 858static enum sam_lun_addr_method sdebug_lun_am = SAM_LUN_AM_PERIPHERAL;
 859static int sdebug_lun_am_i = (int)SAM_LUN_AM_PERIPHERAL;
 860
 861static unsigned int sdebug_store_sectors;
 862static sector_t sdebug_capacity;	/* in sectors */
 863
 864/* old BIOS stuff, kernel may get rid of them but some mode sense pages
 865   may still need them */
 866static int sdebug_heads;		/* heads per disk */
 867static int sdebug_cylinders_per;	/* cylinders per surface */
 868static int sdebug_sectors_per;		/* sectors per cylinder */
 869
 870static LIST_HEAD(sdebug_host_list);
 871static DEFINE_MUTEX(sdebug_host_list_mutex);
 872
 873static struct xarray per_store_arr;
 874static struct xarray *per_store_ap = &per_store_arr;
 875static int sdeb_first_idx = -1;		/* invalid index ==> none created */
 876static int sdeb_most_recent_idx = -1;
 877static DEFINE_RWLOCK(sdeb_fake_rw_lck);	/* need a RW lock when fake_rw=1 */
 878
 879static unsigned long map_size;
 880static int num_aborts;
 881static int num_dev_resets;
 882static int num_target_resets;
 883static int num_bus_resets;
 884static int num_host_resets;
 885static int dix_writes;
 886static int dix_reads;
 887static int dif_errors;
 888
 889/* ZBC global data */
 890static bool sdeb_zbc_in_use;	/* true for host-aware and host-managed disks */
 891static int sdeb_zbc_zone_cap_mb;
 892static int sdeb_zbc_zone_size_mb;
 893static int sdeb_zbc_max_open = DEF_ZBC_MAX_OPEN_ZONES;
 894static int sdeb_zbc_nr_conv = DEF_ZBC_NR_CONV_ZONES;
 895
 896static int submit_queues = DEF_SUBMIT_QUEUES;  /* > 1 for multi-queue (mq) */
 897static int poll_queues; /* iouring iopoll interface.*/
 
 
 
 
 
 898
 899static char sdebug_proc_name[] = MY_NAME;
 900static const char *my_name = MY_NAME;
 901
 902static struct bus_type pseudo_lld_bus;
 903
 904static struct device_driver sdebug_driverfs_driver = {
 905	.name 		= sdebug_proc_name,
 906	.bus		= &pseudo_lld_bus,
 907};
 908
 909static const int check_condition_result =
 910	SAM_STAT_CHECK_CONDITION;
 911
 912static const int illegal_condition_result =
 913	(DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION;
 914
 915static const int device_qfull_result =
 916	(DID_ABORT << 16) | SAM_STAT_TASK_SET_FULL;
 917
 918static const int condition_met_result = SAM_STAT_CONDITION_MET;
 919
 920static struct dentry *sdebug_debugfs_root;
 921
 922static void sdebug_err_free(struct rcu_head *head)
 923{
 924	struct sdebug_err_inject *inject =
 925		container_of(head, typeof(*inject), rcu);
 926
 927	kfree(inject);
 928}
 929
 930static void sdebug_err_add(struct scsi_device *sdev, struct sdebug_err_inject *new)
 931{
 932	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdev->hostdata;
 933	struct sdebug_err_inject *err;
 934
 935	spin_lock(&devip->list_lock);
 936	list_for_each_entry_rcu(err, &devip->inject_err_list, list) {
 937		if (err->type == new->type && err->cmd == new->cmd) {
 938			list_del_rcu(&err->list);
 939			call_rcu(&err->rcu, sdebug_err_free);
 940		}
 941	}
 942
 943	list_add_tail_rcu(&new->list, &devip->inject_err_list);
 944	spin_unlock(&devip->list_lock);
 945}
 946
 947static int sdebug_err_remove(struct scsi_device *sdev, const char *buf, size_t count)
 948{
 949	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdev->hostdata;
 950	struct sdebug_err_inject *err;
 951	int type;
 952	unsigned char cmd;
 953
 954	if (sscanf(buf, "- %d %hhx", &type, &cmd) != 2) {
 955		kfree(buf);
 956		return -EINVAL;
 957	}
 958
 959	spin_lock(&devip->list_lock);
 960	list_for_each_entry_rcu(err, &devip->inject_err_list, list) {
 961		if (err->type == type && err->cmd == cmd) {
 962			list_del_rcu(&err->list);
 963			call_rcu(&err->rcu, sdebug_err_free);
 964			spin_unlock(&devip->list_lock);
 965			kfree(buf);
 966			return count;
 967		}
 968	}
 969	spin_unlock(&devip->list_lock);
 970
 971	kfree(buf);
 972	return -EINVAL;
 973}
 974
 975static int sdebug_error_show(struct seq_file *m, void *p)
 976{
 977	struct scsi_device *sdev = (struct scsi_device *)m->private;
 978	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdev->hostdata;
 979	struct sdebug_err_inject *err;
 980
 981	seq_puts(m, "Type\tCount\tCommand\n");
 982
 983	rcu_read_lock();
 984	list_for_each_entry_rcu(err, &devip->inject_err_list, list) {
 985		switch (err->type) {
 986		case ERR_TMOUT_CMD:
 987		case ERR_ABORT_CMD_FAILED:
 988		case ERR_LUN_RESET_FAILED:
 989			seq_printf(m, "%d\t%d\t0x%x\n", err->type, err->cnt,
 990				err->cmd);
 991		break;
 992
 993		case ERR_FAIL_QUEUE_CMD:
 994			seq_printf(m, "%d\t%d\t0x%x\t0x%x\n", err->type,
 995				err->cnt, err->cmd, err->queuecmd_ret);
 996		break;
 997
 998		case ERR_FAIL_CMD:
 999			seq_printf(m, "%d\t%d\t0x%x\t0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1000				err->type, err->cnt, err->cmd,
1001				err->host_byte, err->driver_byte,
1002				err->status_byte, err->sense_key,
1003				err->asc, err->asq);
1004		break;
1005		}
1006	}
1007	rcu_read_unlock();
1008
1009	return 0;
1010}
1011
1012static int sdebug_error_open(struct inode *inode, struct file *file)
1013{
1014	return single_open(file, sdebug_error_show, inode->i_private);
1015}
1016
1017static ssize_t sdebug_error_write(struct file *file, const char __user *ubuf,
1018		size_t count, loff_t *ppos)
1019{
1020	char *buf;
1021	unsigned int inject_type;
1022	struct sdebug_err_inject *inject;
1023	struct scsi_device *sdev = (struct scsi_device *)file->f_inode->i_private;
1024
1025	buf = kzalloc(count + 1, GFP_KERNEL);
1026	if (!buf)
1027		return -ENOMEM;
1028
1029	if (copy_from_user(buf, ubuf, count)) {
1030		kfree(buf);
1031		return -EFAULT;
1032	}
1033
1034	if (buf[0] == '-')
1035		return sdebug_err_remove(sdev, buf, count);
1036
1037	if (sscanf(buf, "%d", &inject_type) != 1) {
1038		kfree(buf);
1039		return -EINVAL;
1040	}
1041
1042	inject = kzalloc(sizeof(struct sdebug_err_inject), GFP_KERNEL);
1043	if (!inject) {
1044		kfree(buf);
1045		return -ENOMEM;
1046	}
1047
1048	switch (inject_type) {
1049	case ERR_TMOUT_CMD:
1050	case ERR_ABORT_CMD_FAILED:
1051	case ERR_LUN_RESET_FAILED:
1052		if (sscanf(buf, "%d %d %hhx", &inject->type, &inject->cnt,
1053			   &inject->cmd) != 3)
1054			goto out_error;
1055	break;
1056
1057	case ERR_FAIL_QUEUE_CMD:
1058		if (sscanf(buf, "%d %d %hhx %x", &inject->type, &inject->cnt,
1059			   &inject->cmd, &inject->queuecmd_ret) != 4)
1060			goto out_error;
1061	break;
1062
1063	case ERR_FAIL_CMD:
1064		if (sscanf(buf, "%d %d %hhx %hhx %hhx %hhx %hhx %hhx %hhx",
1065			   &inject->type, &inject->cnt, &inject->cmd,
1066			   &inject->host_byte, &inject->driver_byte,
1067			   &inject->status_byte, &inject->sense_key,
1068			   &inject->asc, &inject->asq) != 9)
1069			goto out_error;
1070	break;
1071
1072	default:
1073		goto out_error;
1074	break;
1075	}
1076
1077	kfree(buf);
1078	sdebug_err_add(sdev, inject);
1079
1080	return count;
1081
1082out_error:
1083	kfree(buf);
1084	kfree(inject);
1085	return -EINVAL;
1086}
1087
1088static const struct file_operations sdebug_error_fops = {
1089	.open	= sdebug_error_open,
1090	.read	= seq_read,
1091	.write	= sdebug_error_write,
1092	.release = single_release,
1093};
1094
1095static int sdebug_target_reset_fail_show(struct seq_file *m, void *p)
1096{
1097	struct scsi_target *starget = (struct scsi_target *)m->private;
1098	struct sdebug_target_info *targetip =
1099		(struct sdebug_target_info *)starget->hostdata;
1100
1101	if (targetip)
1102		seq_printf(m, "%c\n", targetip->reset_fail ? 'Y' : 'N');
1103
1104	return 0;
1105}
1106
1107static int sdebug_target_reset_fail_open(struct inode *inode, struct file *file)
1108{
1109	return single_open(file, sdebug_target_reset_fail_show, inode->i_private);
1110}
1111
1112static ssize_t sdebug_target_reset_fail_write(struct file *file,
1113		const char __user *ubuf, size_t count, loff_t *ppos)
1114{
1115	int ret;
1116	struct scsi_target *starget =
1117		(struct scsi_target *)file->f_inode->i_private;
1118	struct sdebug_target_info *targetip =
1119		(struct sdebug_target_info *)starget->hostdata;
1120
1121	if (targetip) {
1122		ret = kstrtobool_from_user(ubuf, count, &targetip->reset_fail);
1123		return ret < 0 ? ret : count;
1124	}
1125	return -ENODEV;
1126}
1127
1128static const struct file_operations sdebug_target_reset_fail_fops = {
1129	.open	= sdebug_target_reset_fail_open,
1130	.read	= seq_read,
1131	.write	= sdebug_target_reset_fail_write,
1132	.release = single_release,
1133};
1134
1135static int sdebug_target_alloc(struct scsi_target *starget)
1136{
1137	struct sdebug_target_info *targetip;
1138
1139	targetip = kzalloc(sizeof(struct sdebug_target_info), GFP_KERNEL);
1140	if (!targetip)
1141		return -ENOMEM;
1142
1143	targetip->debugfs_entry = debugfs_create_dir(dev_name(&starget->dev),
1144				sdebug_debugfs_root);
1145
1146	debugfs_create_file("fail_reset", 0600, targetip->debugfs_entry, starget,
1147				&sdebug_target_reset_fail_fops);
1148
1149	starget->hostdata = targetip;
1150
1151	return 0;
1152}
1153
1154static void sdebug_tartget_cleanup_async(void *data, async_cookie_t cookie)
1155{
1156	struct sdebug_target_info *targetip = data;
1157
1158	debugfs_remove(targetip->debugfs_entry);
1159	kfree(targetip);
1160}
1161
1162static void sdebug_target_destroy(struct scsi_target *starget)
1163{
1164	struct sdebug_target_info *targetip;
1165
1166	targetip = (struct sdebug_target_info *)starget->hostdata;
1167	if (targetip) {
1168		starget->hostdata = NULL;
1169		async_schedule(sdebug_tartget_cleanup_async, targetip);
1170	}
1171}
1172
1173/* Only do the extra work involved in logical block provisioning if one or
1174 * more of the lbpu, lbpws or lbpws10 parameters are given and we are doing
1175 * real reads and writes (i.e. not skipping them for speed).
1176 */
1177static inline bool scsi_debug_lbp(void)
1178{
1179	return 0 == sdebug_fake_rw &&
1180		(sdebug_lbpu || sdebug_lbpws || sdebug_lbpws10);
1181}
1182
1183static void *lba2fake_store(struct sdeb_store_info *sip,
1184			    unsigned long long lba)
1185{
1186	struct sdeb_store_info *lsip = sip;
1187
1188	lba = do_div(lba, sdebug_store_sectors);
1189	if (!sip || !sip->storep) {
1190		WARN_ON_ONCE(true);
1191		lsip = xa_load(per_store_ap, 0);  /* should never be NULL */
1192	}
1193	return lsip->storep + lba * sdebug_sector_size;
1194}
1195
1196static struct t10_pi_tuple *dif_store(struct sdeb_store_info *sip,
1197				      sector_t sector)
1198{
1199	sector = sector_div(sector, sdebug_store_sectors);
1200
1201	return sip->dif_storep + sector;
1202}
1203
1204static void sdebug_max_tgts_luns(void)
1205{
1206	struct sdebug_host_info *sdbg_host;
1207	struct Scsi_Host *hpnt;
1208
1209	mutex_lock(&sdebug_host_list_mutex);
1210	list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
1211		hpnt = sdbg_host->shost;
1212		if ((hpnt->this_id >= 0) &&
1213		    (sdebug_num_tgts > hpnt->this_id))
1214			hpnt->max_id = sdebug_num_tgts + 1;
1215		else
1216			hpnt->max_id = sdebug_num_tgts;
1217		/* sdebug_max_luns; */
1218		hpnt->max_lun = SCSI_W_LUN_REPORT_LUNS + 1;
1219	}
1220	mutex_unlock(&sdebug_host_list_mutex);
1221}
1222
1223enum sdeb_cmd_data {SDEB_IN_DATA = 0, SDEB_IN_CDB = 1};
1224
1225/* Set in_bit to -1 to indicate no bit position of invalid field */
1226static void mk_sense_invalid_fld(struct scsi_cmnd *scp,
1227				 enum sdeb_cmd_data c_d,
1228				 int in_byte, int in_bit)
1229{
1230	unsigned char *sbuff;
1231	u8 sks[4];
1232	int sl, asc;
1233
1234	sbuff = scp->sense_buffer;
1235	if (!sbuff) {
1236		sdev_printk(KERN_ERR, scp->device,
1237			    "%s: sense_buffer is NULL\n", __func__);
1238		return;
1239	}
1240	asc = c_d ? INVALID_FIELD_IN_CDB : INVALID_FIELD_IN_PARAM_LIST;
1241	memset(sbuff, 0, SCSI_SENSE_BUFFERSIZE);
1242	scsi_build_sense(scp, sdebug_dsense, ILLEGAL_REQUEST, asc, 0);
1243	memset(sks, 0, sizeof(sks));
1244	sks[0] = 0x80;
1245	if (c_d)
1246		sks[0] |= 0x40;
1247	if (in_bit >= 0) {
1248		sks[0] |= 0x8;
1249		sks[0] |= 0x7 & in_bit;
1250	}
1251	put_unaligned_be16(in_byte, sks + 1);
1252	if (sdebug_dsense) {
1253		sl = sbuff[7] + 8;
1254		sbuff[7] = sl;
1255		sbuff[sl] = 0x2;
1256		sbuff[sl + 1] = 0x6;
1257		memcpy(sbuff + sl + 4, sks, 3);
1258	} else
1259		memcpy(sbuff + 15, sks, 3);
1260	if (sdebug_verbose)
1261		sdev_printk(KERN_INFO, scp->device, "%s:  [sense_key,asc,ascq"
1262			    "]: [0x5,0x%x,0x0] %c byte=%d, bit=%d\n",
1263			    my_name, asc, c_d ? 'C' : 'D', in_byte, in_bit);
1264}
1265
1266static void mk_sense_buffer(struct scsi_cmnd *scp, int key, int asc, int asq)
1267{
1268	if (!scp->sense_buffer) {
 
 
 
1269		sdev_printk(KERN_ERR, scp->device,
1270			    "%s: sense_buffer is NULL\n", __func__);
1271		return;
1272	}
1273	memset(scp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1274
1275	scsi_build_sense(scp, sdebug_dsense, key, asc, asq);
1276
1277	if (sdebug_verbose)
1278		sdev_printk(KERN_INFO, scp->device,
1279			    "%s:  [sense_key,asc,ascq]: [0x%x,0x%x,0x%x]\n",
1280			    my_name, key, asc, asq);
1281}
1282
1283static void mk_sense_invalid_opcode(struct scsi_cmnd *scp)
1284{
1285	mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
1286}
1287
1288static int scsi_debug_ioctl(struct scsi_device *dev, unsigned int cmd,
1289			    void __user *arg)
1290{
1291	if (sdebug_verbose) {
1292		if (0x1261 == cmd)
1293			sdev_printk(KERN_INFO, dev,
1294				    "%s: BLKFLSBUF [0x1261]\n", __func__);
1295		else if (0x5331 == cmd)
1296			sdev_printk(KERN_INFO, dev,
1297				    "%s: CDROM_GET_CAPABILITY [0x5331]\n",
1298				    __func__);
1299		else
1300			sdev_printk(KERN_INFO, dev, "%s: cmd=0x%x\n",
1301				    __func__, cmd);
1302	}
1303	return -EINVAL;
1304	/* return -ENOTTY; // correct return but upsets fdisk */
1305}
1306
1307static void config_cdb_len(struct scsi_device *sdev)
1308{
1309	switch (sdebug_cdb_len) {
1310	case 6:	/* suggest 6 byte READ, WRITE and MODE SENSE/SELECT */
1311		sdev->use_10_for_rw = false;
1312		sdev->use_16_for_rw = false;
1313		sdev->use_10_for_ms = false;
1314		break;
1315	case 10: /* suggest 10 byte RWs and 6 byte MODE SENSE/SELECT */
1316		sdev->use_10_for_rw = true;
1317		sdev->use_16_for_rw = false;
1318		sdev->use_10_for_ms = false;
1319		break;
1320	case 12: /* suggest 10 byte RWs and 10 byte MODE SENSE/SELECT */
1321		sdev->use_10_for_rw = true;
1322		sdev->use_16_for_rw = false;
1323		sdev->use_10_for_ms = true;
1324		break;
1325	case 16:
1326		sdev->use_10_for_rw = false;
1327		sdev->use_16_for_rw = true;
1328		sdev->use_10_for_ms = true;
1329		break;
1330	case 32: /* No knobs to suggest this so same as 16 for now */
1331		sdev->use_10_for_rw = false;
1332		sdev->use_16_for_rw = true;
1333		sdev->use_10_for_ms = true;
1334		break;
1335	default:
1336		pr_warn("unexpected cdb_len=%d, force to 10\n",
1337			sdebug_cdb_len);
1338		sdev->use_10_for_rw = true;
1339		sdev->use_16_for_rw = false;
1340		sdev->use_10_for_ms = false;
1341		sdebug_cdb_len = 10;
1342		break;
1343	}
1344}
1345
1346static void all_config_cdb_len(void)
1347{
1348	struct sdebug_host_info *sdbg_host;
1349	struct Scsi_Host *shost;
1350	struct scsi_device *sdev;
1351
1352	mutex_lock(&sdebug_host_list_mutex);
1353	list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
1354		shost = sdbg_host->shost;
1355		shost_for_each_device(sdev, shost) {
1356			config_cdb_len(sdev);
1357		}
1358	}
1359	mutex_unlock(&sdebug_host_list_mutex);
1360}
1361
1362static void clear_luns_changed_on_target(struct sdebug_dev_info *devip)
1363{
1364	struct sdebug_host_info *sdhp = devip->sdbg_host;
1365	struct sdebug_dev_info *dp;
1366
1367	list_for_each_entry(dp, &sdhp->dev_info_list, dev_list) {
1368		if ((devip->sdbg_host == dp->sdbg_host) &&
1369		    (devip->target == dp->target)) {
1370			clear_bit(SDEBUG_UA_LUNS_CHANGED, dp->uas_bm);
 
 
1371		}
1372	}
 
1373}
1374
1375static int make_ua(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
1376{
1377	int k;
1378
1379	k = find_first_bit(devip->uas_bm, SDEBUG_NUM_UAS);
1380	if (k != SDEBUG_NUM_UAS) {
1381		const char *cp = NULL;
1382
1383		switch (k) {
1384		case SDEBUG_UA_POR:
1385			mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
1386					POWER_ON_RESET_ASCQ);
1387			if (sdebug_verbose)
1388				cp = "power on reset";
1389			break;
1390		case SDEBUG_UA_POOCCUR:
1391			mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
1392					POWER_ON_OCCURRED_ASCQ);
1393			if (sdebug_verbose)
1394				cp = "power on occurred";
1395			break;
1396		case SDEBUG_UA_BUS_RESET:
1397			mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
1398					BUS_RESET_ASCQ);
1399			if (sdebug_verbose)
1400				cp = "bus reset";
1401			break;
1402		case SDEBUG_UA_MODE_CHANGED:
1403			mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
1404					MODE_CHANGED_ASCQ);
1405			if (sdebug_verbose)
1406				cp = "mode parameters changed";
1407			break;
1408		case SDEBUG_UA_CAPACITY_CHANGED:
1409			mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
1410					CAPACITY_CHANGED_ASCQ);
1411			if (sdebug_verbose)
1412				cp = "capacity data changed";
1413			break;
1414		case SDEBUG_UA_MICROCODE_CHANGED:
1415			mk_sense_buffer(scp, UNIT_ATTENTION,
1416					TARGET_CHANGED_ASC,
1417					MICROCODE_CHANGED_ASCQ);
1418			if (sdebug_verbose)
1419				cp = "microcode has been changed";
1420			break;
1421		case SDEBUG_UA_MICROCODE_CHANGED_WO_RESET:
1422			mk_sense_buffer(scp, UNIT_ATTENTION,
1423					TARGET_CHANGED_ASC,
1424					MICROCODE_CHANGED_WO_RESET_ASCQ);
1425			if (sdebug_verbose)
1426				cp = "microcode has been changed without reset";
1427			break;
1428		case SDEBUG_UA_LUNS_CHANGED:
1429			/*
1430			 * SPC-3 behavior is to report a UNIT ATTENTION with
1431			 * ASC/ASCQ REPORTED LUNS DATA HAS CHANGED on every LUN
1432			 * on the target, until a REPORT LUNS command is
1433			 * received.  SPC-4 behavior is to report it only once.
1434			 * NOTE:  sdebug_scsi_level does not use the same
1435			 * values as struct scsi_device->scsi_level.
1436			 */
1437			if (sdebug_scsi_level >= 6)	/* SPC-4 and above */
1438				clear_luns_changed_on_target(devip);
1439			mk_sense_buffer(scp, UNIT_ATTENTION,
1440					TARGET_CHANGED_ASC,
1441					LUNS_CHANGED_ASCQ);
1442			if (sdebug_verbose)
1443				cp = "reported luns data has changed";
1444			break;
1445		default:
1446			pr_warn("unexpected unit attention code=%d\n", k);
1447			if (sdebug_verbose)
1448				cp = "unknown";
1449			break;
1450		}
1451		clear_bit(k, devip->uas_bm);
1452		if (sdebug_verbose)
1453			sdev_printk(KERN_INFO, scp->device,
1454				   "%s reports: Unit attention: %s\n",
1455				   my_name, cp);
1456		return check_condition_result;
1457	}
1458	return 0;
1459}
1460
1461/* Build SCSI "data-in" buffer. Returns 0 if ok else (DID_ERROR << 16). */
1462static int fill_from_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
1463				int arr_len)
1464{
1465	int act_len;
1466	struct scsi_data_buffer *sdb = &scp->sdb;
1467
1468	if (!sdb->length)
1469		return 0;
1470	if (scp->sc_data_direction != DMA_FROM_DEVICE)
1471		return DID_ERROR << 16;
1472
1473	act_len = sg_copy_from_buffer(sdb->table.sgl, sdb->table.nents,
1474				      arr, arr_len);
1475	scsi_set_resid(scp, scsi_bufflen(scp) - act_len);
1476
1477	return 0;
1478}
1479
1480/* Partial build of SCSI "data-in" buffer. Returns 0 if ok else
1481 * (DID_ERROR << 16). Can write to offset in data-in buffer. If multiple
1482 * calls, not required to write in ascending offset order. Assumes resid
1483 * set to scsi_bufflen() prior to any calls.
1484 */
1485static int p_fill_from_dev_buffer(struct scsi_cmnd *scp, const void *arr,
1486				  int arr_len, unsigned int off_dst)
1487{
1488	unsigned int act_len, n;
1489	struct scsi_data_buffer *sdb = &scp->sdb;
1490	off_t skip = off_dst;
1491
1492	if (sdb->length <= off_dst)
1493		return 0;
1494	if (scp->sc_data_direction != DMA_FROM_DEVICE)
1495		return DID_ERROR << 16;
1496
1497	act_len = sg_pcopy_from_buffer(sdb->table.sgl, sdb->table.nents,
1498				       arr, arr_len, skip);
1499	pr_debug("%s: off_dst=%u, scsi_bufflen=%u, act_len=%u, resid=%d\n",
1500		 __func__, off_dst, scsi_bufflen(scp), act_len,
1501		 scsi_get_resid(scp));
1502	n = scsi_bufflen(scp) - (off_dst + act_len);
1503	scsi_set_resid(scp, min_t(u32, scsi_get_resid(scp), n));
1504	return 0;
1505}
1506
1507/* Fetches from SCSI "data-out" buffer. Returns number of bytes fetched into
1508 * 'arr' or -1 if error.
1509 */
1510static int fetch_to_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
1511			       int arr_len)
1512{
1513	if (!scsi_bufflen(scp))
1514		return 0;
1515	if (scp->sc_data_direction != DMA_TO_DEVICE)
1516		return -1;
1517
1518	return scsi_sg_copy_to_buffer(scp, arr, arr_len);
1519}
1520
1521
1522static char sdebug_inq_vendor_id[9] = "Linux   ";
1523static char sdebug_inq_product_id[17] = "scsi_debug      ";
1524static char sdebug_inq_product_rev[5] = SDEBUG_VERSION;
1525/* Use some locally assigned NAAs for SAS addresses. */
1526static const u64 naa3_comp_a = 0x3222222000000000ULL;
1527static const u64 naa3_comp_b = 0x3333333000000000ULL;
1528static const u64 naa3_comp_c = 0x3111111000000000ULL;
1529
1530/* Device identification VPD page. Returns number of bytes placed in arr */
1531static int inquiry_vpd_83(unsigned char *arr, int port_group_id,
1532			  int target_dev_id, int dev_id_num,
1533			  const char *dev_id_str, int dev_id_str_len,
1534			  const uuid_t *lu_name)
1535{
1536	int num, port_a;
1537	char b[32];
1538
1539	port_a = target_dev_id + 1;
1540	/* T10 vendor identifier field format (faked) */
1541	arr[0] = 0x2;	/* ASCII */
1542	arr[1] = 0x1;
1543	arr[2] = 0x0;
1544	memcpy(&arr[4], sdebug_inq_vendor_id, 8);
1545	memcpy(&arr[12], sdebug_inq_product_id, 16);
1546	memcpy(&arr[28], dev_id_str, dev_id_str_len);
1547	num = 8 + 16 + dev_id_str_len;
1548	arr[3] = num;
1549	num += 4;
1550	if (dev_id_num >= 0) {
1551		if (sdebug_uuid_ctl) {
1552			/* Locally assigned UUID */
1553			arr[num++] = 0x1;  /* binary (not necessarily sas) */
1554			arr[num++] = 0xa;  /* PIV=0, lu, naa */
1555			arr[num++] = 0x0;
1556			arr[num++] = 0x12;
1557			arr[num++] = 0x10; /* uuid type=1, locally assigned */
1558			arr[num++] = 0x0;
1559			memcpy(arr + num, lu_name, 16);
1560			num += 16;
1561		} else {
1562			/* NAA-3, Logical unit identifier (binary) */
1563			arr[num++] = 0x1;  /* binary (not necessarily sas) */
1564			arr[num++] = 0x3;  /* PIV=0, lu, naa */
1565			arr[num++] = 0x0;
1566			arr[num++] = 0x8;
1567			put_unaligned_be64(naa3_comp_b + dev_id_num, arr + num);
1568			num += 8;
1569		}
1570		/* Target relative port number */
1571		arr[num++] = 0x61;	/* proto=sas, binary */
1572		arr[num++] = 0x94;	/* PIV=1, target port, rel port */
1573		arr[num++] = 0x0;	/* reserved */
1574		arr[num++] = 0x4;	/* length */
1575		arr[num++] = 0x0;	/* reserved */
1576		arr[num++] = 0x0;	/* reserved */
1577		arr[num++] = 0x0;
1578		arr[num++] = 0x1;	/* relative port A */
1579	}
1580	/* NAA-3, Target port identifier */
1581	arr[num++] = 0x61;	/* proto=sas, binary */
1582	arr[num++] = 0x93;	/* piv=1, target port, naa */
1583	arr[num++] = 0x0;
1584	arr[num++] = 0x8;
1585	put_unaligned_be64(naa3_comp_a + port_a, arr + num);
1586	num += 8;
1587	/* NAA-3, Target port group identifier */
1588	arr[num++] = 0x61;	/* proto=sas, binary */
1589	arr[num++] = 0x95;	/* piv=1, target port group id */
1590	arr[num++] = 0x0;
1591	arr[num++] = 0x4;
1592	arr[num++] = 0;
1593	arr[num++] = 0;
1594	put_unaligned_be16(port_group_id, arr + num);
1595	num += 2;
1596	/* NAA-3, Target device identifier */
1597	arr[num++] = 0x61;	/* proto=sas, binary */
1598	arr[num++] = 0xa3;	/* piv=1, target device, naa */
1599	arr[num++] = 0x0;
1600	arr[num++] = 0x8;
1601	put_unaligned_be64(naa3_comp_a + target_dev_id, arr + num);
1602	num += 8;
1603	/* SCSI name string: Target device identifier */
1604	arr[num++] = 0x63;	/* proto=sas, UTF-8 */
1605	arr[num++] = 0xa8;	/* piv=1, target device, SCSI name string */
1606	arr[num++] = 0x0;
1607	arr[num++] = 24;
1608	memcpy(arr + num, "naa.32222220", 12);
1609	num += 12;
1610	snprintf(b, sizeof(b), "%08X", target_dev_id);
1611	memcpy(arr + num, b, 8);
1612	num += 8;
1613	memset(arr + num, 0, 4);
1614	num += 4;
1615	return num;
1616}
1617
1618static unsigned char vpd84_data[] = {
1619/* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
1620    0x22,0x22,0x22,0x0,0xbb,0x1,
1621    0x22,0x22,0x22,0x0,0xbb,0x2,
1622};
1623
1624/*  Software interface identification VPD page */
1625static int inquiry_vpd_84(unsigned char *arr)
1626{
1627	memcpy(arr, vpd84_data, sizeof(vpd84_data));
1628	return sizeof(vpd84_data);
1629}
1630
1631/* Management network addresses VPD page */
1632static int inquiry_vpd_85(unsigned char *arr)
1633{
1634	int num = 0;
1635	const char *na1 = "https://www.kernel.org/config";
1636	const char *na2 = "http://www.kernel.org/log";
1637	int plen, olen;
1638
1639	arr[num++] = 0x1;	/* lu, storage config */
1640	arr[num++] = 0x0;	/* reserved */
1641	arr[num++] = 0x0;
1642	olen = strlen(na1);
1643	plen = olen + 1;
1644	if (plen % 4)
1645		plen = ((plen / 4) + 1) * 4;
1646	arr[num++] = plen;	/* length, null termianted, padded */
1647	memcpy(arr + num, na1, olen);
1648	memset(arr + num + olen, 0, plen - olen);
1649	num += plen;
1650
1651	arr[num++] = 0x4;	/* lu, logging */
1652	arr[num++] = 0x0;	/* reserved */
1653	arr[num++] = 0x0;
1654	olen = strlen(na2);
1655	plen = olen + 1;
1656	if (plen % 4)
1657		plen = ((plen / 4) + 1) * 4;
1658	arr[num++] = plen;	/* length, null terminated, padded */
1659	memcpy(arr + num, na2, olen);
1660	memset(arr + num + olen, 0, plen - olen);
1661	num += plen;
1662
1663	return num;
1664}
1665
1666/* SCSI ports VPD page */
1667static int inquiry_vpd_88(unsigned char *arr, int target_dev_id)
1668{
1669	int num = 0;
1670	int port_a, port_b;
1671
1672	port_a = target_dev_id + 1;
1673	port_b = port_a + 1;
1674	arr[num++] = 0x0;	/* reserved */
1675	arr[num++] = 0x0;	/* reserved */
1676	arr[num++] = 0x0;
1677	arr[num++] = 0x1;	/* relative port 1 (primary) */
1678	memset(arr + num, 0, 6);
1679	num += 6;
1680	arr[num++] = 0x0;
1681	arr[num++] = 12;	/* length tp descriptor */
1682	/* naa-5 target port identifier (A) */
1683	arr[num++] = 0x61;	/* proto=sas, binary */
1684	arr[num++] = 0x93;	/* PIV=1, target port, NAA */
1685	arr[num++] = 0x0;	/* reserved */
1686	arr[num++] = 0x8;	/* length */
1687	put_unaligned_be64(naa3_comp_a + port_a, arr + num);
1688	num += 8;
1689	arr[num++] = 0x0;	/* reserved */
1690	arr[num++] = 0x0;	/* reserved */
1691	arr[num++] = 0x0;
1692	arr[num++] = 0x2;	/* relative port 2 (secondary) */
1693	memset(arr + num, 0, 6);
1694	num += 6;
1695	arr[num++] = 0x0;
1696	arr[num++] = 12;	/* length tp descriptor */
1697	/* naa-5 target port identifier (B) */
1698	arr[num++] = 0x61;	/* proto=sas, binary */
1699	arr[num++] = 0x93;	/* PIV=1, target port, NAA */
1700	arr[num++] = 0x0;	/* reserved */
1701	arr[num++] = 0x8;	/* length */
1702	put_unaligned_be64(naa3_comp_a + port_b, arr + num);
1703	num += 8;
1704
1705	return num;
1706}
1707
1708
1709static unsigned char vpd89_data[] = {
1710/* from 4th byte */ 0,0,0,0,
1711'l','i','n','u','x',' ',' ',' ',
1712'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
1713'1','2','3','4',
17140x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
17150xec,0,0,0,
17160x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
17170,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
17180x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
17190x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
17200x53,0x41,
17210x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
17220x20,0x20,
17230x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
17240x10,0x80,
17250,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
17260x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
17270x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
17280,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
17290x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
17300x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
17310,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
17320,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17330,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17340,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17350x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
17360,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
17370xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
17380,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
17390,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17400,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17410,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17420,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17430,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17440,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17450,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17460,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17470,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17480,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17490,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
17500,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
1751};
1752
1753/* ATA Information VPD page */
1754static int inquiry_vpd_89(unsigned char *arr)
1755{
1756	memcpy(arr, vpd89_data, sizeof(vpd89_data));
1757	return sizeof(vpd89_data);
1758}
1759
1760
1761static unsigned char vpdb0_data[] = {
1762	/* from 4th byte */ 0,0,0,4, 0,0,0x4,0, 0,0,0,64,
1763	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1764	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1765	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1766};
1767
1768/* Block limits VPD page (SBC-3) */
1769static int inquiry_vpd_b0(unsigned char *arr)
1770{
1771	unsigned int gran;
1772
1773	memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
1774
1775	/* Optimal transfer length granularity */
1776	if (sdebug_opt_xferlen_exp != 0 &&
1777	    sdebug_physblk_exp < sdebug_opt_xferlen_exp)
1778		gran = 1 << sdebug_opt_xferlen_exp;
1779	else
1780		gran = 1 << sdebug_physblk_exp;
1781	put_unaligned_be16(gran, arr + 2);
1782
1783	/* Maximum Transfer Length */
1784	if (sdebug_store_sectors > 0x400)
1785		put_unaligned_be32(sdebug_store_sectors, arr + 4);
1786
1787	/* Optimal Transfer Length */
1788	put_unaligned_be32(sdebug_opt_blks, &arr[8]);
1789
1790	if (sdebug_lbpu) {
1791		/* Maximum Unmap LBA Count */
1792		put_unaligned_be32(sdebug_unmap_max_blocks, &arr[16]);
1793
1794		/* Maximum Unmap Block Descriptor Count */
1795		put_unaligned_be32(sdebug_unmap_max_desc, &arr[20]);
1796	}
1797
1798	/* Unmap Granularity Alignment */
1799	if (sdebug_unmap_alignment) {
1800		put_unaligned_be32(sdebug_unmap_alignment, &arr[28]);
1801		arr[28] |= 0x80; /* UGAVALID */
1802	}
1803
1804	/* Optimal Unmap Granularity */
1805	put_unaligned_be32(sdebug_unmap_granularity, &arr[24]);
1806
1807	/* Maximum WRITE SAME Length */
1808	put_unaligned_be64(sdebug_write_same_length, &arr[32]);
1809
1810	return 0x3c; /* Mandatory page length for Logical Block Provisioning */
 
 
1811}
1812
1813/* Block device characteristics VPD page (SBC-3) */
1814static int inquiry_vpd_b1(struct sdebug_dev_info *devip, unsigned char *arr)
1815{
1816	memset(arr, 0, 0x3c);
1817	arr[0] = 0;
1818	arr[1] = 1;	/* non rotating medium (e.g. solid state) */
1819	arr[2] = 0;
1820	arr[3] = 5;	/* less than 1.8" */
 
 
1821
1822	return 0x3c;
1823}
1824
1825/* Logical block provisioning VPD page (SBC-4) */
1826static int inquiry_vpd_b2(unsigned char *arr)
1827{
1828	memset(arr, 0, 0x4);
1829	arr[0] = 0;			/* threshold exponent */
1830	if (sdebug_lbpu)
1831		arr[1] = 1 << 7;
1832	if (sdebug_lbpws)
1833		arr[1] |= 1 << 6;
1834	if (sdebug_lbpws10)
1835		arr[1] |= 1 << 5;
1836	if (sdebug_lbprz && scsi_debug_lbp())
1837		arr[1] |= (sdebug_lbprz & 0x7) << 2;  /* sbc4r07 and later */
1838	/* anc_sup=0; dp=0 (no provisioning group descriptor) */
1839	/* minimum_percentage=0; provisioning_type=0 (unknown) */
1840	/* threshold_percentage=0 */
1841	return 0x4;
1842}
1843
1844/* Zoned block device characteristics VPD page (ZBC mandatory) */
1845static int inquiry_vpd_b6(struct sdebug_dev_info *devip, unsigned char *arr)
1846{
1847	memset(arr, 0, 0x3c);
1848	arr[0] = 0x1; /* set URSWRZ (unrestricted read in seq. wr req zone) */
1849	/*
1850	 * Set Optimal number of open sequential write preferred zones and
1851	 * Optimal number of non-sequentially written sequential write
1852	 * preferred zones fields to 'not reported' (0xffffffff). Leave other
1853	 * fields set to zero, apart from Max. number of open swrz_s field.
1854	 */
1855	put_unaligned_be32(0xffffffff, &arr[4]);
1856	put_unaligned_be32(0xffffffff, &arr[8]);
1857	if (sdeb_zbc_model == BLK_ZONED_HM && devip->max_open)
1858		put_unaligned_be32(devip->max_open, &arr[12]);
1859	else
1860		put_unaligned_be32(0xffffffff, &arr[12]);
1861	if (devip->zcap < devip->zsize) {
1862		arr[19] = ZBC_CONSTANT_ZONE_START_OFFSET;
1863		put_unaligned_be64(devip->zsize, &arr[20]);
1864	} else {
1865		arr[19] = 0;
1866	}
1867	return 0x3c;
1868}
1869
1870#define SDEBUG_LONG_INQ_SZ 96
1871#define SDEBUG_MAX_INQ_ARR_SZ 584
1872
1873static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
1874{
1875	unsigned char pq_pdt;
1876	unsigned char *arr;
1877	unsigned char *cmd = scp->cmnd;
1878	u32 alloc_len, n;
1879	int ret;
1880	bool have_wlun, is_disk, is_zbc, is_disk_zbc;
1881
1882	alloc_len = get_unaligned_be16(cmd + 3);
1883	arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
1884	if (! arr)
1885		return DID_REQUEUE << 16;
1886	is_disk = (sdebug_ptype == TYPE_DISK);
1887	is_zbc = devip->zoned;
1888	is_disk_zbc = (is_disk || is_zbc);
1889	have_wlun = scsi_is_wlun(scp->device->lun);
1890	if (have_wlun)
1891		pq_pdt = TYPE_WLUN;	/* present, wlun */
1892	else if (sdebug_no_lun_0 && (devip->lun == SDEBUG_LUN_0_VAL))
1893		pq_pdt = 0x7f;	/* not present, PQ=3, PDT=0x1f */
1894	else
1895		pq_pdt = (sdebug_ptype & 0x1f);
1896	arr[0] = pq_pdt;
1897	if (0x2 & cmd[1]) {  /* CMDDT bit set */
1898		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 1);
1899		kfree(arr);
1900		return check_condition_result;
1901	} else if (0x1 & cmd[1]) {  /* EVPD bit set */
1902		int lu_id_num, port_group_id, target_dev_id;
1903		u32 len;
1904		char lu_id_str[6];
1905		int host_no = devip->sdbg_host->shost->host_no;
1906		
1907		port_group_id = (((host_no + 1) & 0x7f) << 8) +
1908		    (devip->channel & 0x7f);
1909		if (sdebug_vpd_use_hostno == 0)
1910			host_no = 0;
1911		lu_id_num = have_wlun ? -1 : (((host_no + 1) * 2000) +
1912			    (devip->target * 1000) + devip->lun);
1913		target_dev_id = ((host_no + 1) * 2000) +
1914				 (devip->target * 1000) - 3;
1915		len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
1916		if (0 == cmd[2]) { /* supported vital product data pages */
1917			arr[1] = cmd[2];	/*sanity */
1918			n = 4;
1919			arr[n++] = 0x0;   /* this page */
1920			arr[n++] = 0x80;  /* unit serial number */
1921			arr[n++] = 0x83;  /* device identification */
1922			arr[n++] = 0x84;  /* software interface ident. */
1923			arr[n++] = 0x85;  /* management network addresses */
1924			arr[n++] = 0x86;  /* extended inquiry */
1925			arr[n++] = 0x87;  /* mode page policy */
1926			arr[n++] = 0x88;  /* SCSI ports */
1927			if (is_disk_zbc) {	  /* SBC or ZBC */
1928				arr[n++] = 0x89;  /* ATA information */
1929				arr[n++] = 0xb0;  /* Block limits */
1930				arr[n++] = 0xb1;  /* Block characteristics */
1931				if (is_disk)
1932					arr[n++] = 0xb2;  /* LB Provisioning */
1933				if (is_zbc)
1934					arr[n++] = 0xb6;  /* ZB dev. char. */
1935			}
1936			arr[3] = n - 4;	  /* number of supported VPD pages */
1937		} else if (0x80 == cmd[2]) { /* unit serial number */
1938			arr[1] = cmd[2];	/*sanity */
1939			arr[3] = len;
1940			memcpy(&arr[4], lu_id_str, len);
1941		} else if (0x83 == cmd[2]) { /* device identification */
1942			arr[1] = cmd[2];	/*sanity */
1943			arr[3] = inquiry_vpd_83(&arr[4], port_group_id,
1944						target_dev_id, lu_id_num,
1945						lu_id_str, len,
1946						&devip->lu_name);
1947		} else if (0x84 == cmd[2]) { /* Software interface ident. */
1948			arr[1] = cmd[2];	/*sanity */
1949			arr[3] = inquiry_vpd_84(&arr[4]);
1950		} else if (0x85 == cmd[2]) { /* Management network addresses */
1951			arr[1] = cmd[2];	/*sanity */
1952			arr[3] = inquiry_vpd_85(&arr[4]);
1953		} else if (0x86 == cmd[2]) { /* extended inquiry */
1954			arr[1] = cmd[2];	/*sanity */
1955			arr[3] = 0x3c;	/* number of following entries */
1956			if (sdebug_dif == T10_PI_TYPE3_PROTECTION)
1957				arr[4] = 0x4;	/* SPT: GRD_CHK:1 */
1958			else if (have_dif_prot)
1959				arr[4] = 0x5;   /* SPT: GRD_CHK:1, REF_CHK:1 */
1960			else
1961				arr[4] = 0x0;   /* no protection stuff */
1962			arr[5] = 0x7;   /* head of q, ordered + simple q's */
1963		} else if (0x87 == cmd[2]) { /* mode page policy */
1964			arr[1] = cmd[2];	/*sanity */
1965			arr[3] = 0x8;	/* number of following entries */
1966			arr[4] = 0x2;	/* disconnect-reconnect mp */
1967			arr[6] = 0x80;	/* mlus, shared */
1968			arr[8] = 0x18;	 /* protocol specific lu */
1969			arr[10] = 0x82;	 /* mlus, per initiator port */
1970		} else if (0x88 == cmd[2]) { /* SCSI Ports */
1971			arr[1] = cmd[2];	/*sanity */
1972			arr[3] = inquiry_vpd_88(&arr[4], target_dev_id);
1973		} else if (is_disk_zbc && 0x89 == cmd[2]) { /* ATA info */
1974			arr[1] = cmd[2];        /*sanity */
1975			n = inquiry_vpd_89(&arr[4]);
1976			put_unaligned_be16(n, arr + 2);
1977		} else if (is_disk_zbc && 0xb0 == cmd[2]) { /* Block limits */
1978			arr[1] = cmd[2];        /*sanity */
1979			arr[3] = inquiry_vpd_b0(&arr[4]);
1980		} else if (is_disk_zbc && 0xb1 == cmd[2]) { /* Block char. */
1981			arr[1] = cmd[2];        /*sanity */
1982			arr[3] = inquiry_vpd_b1(devip, &arr[4]);
1983		} else if (is_disk && 0xb2 == cmd[2]) { /* LB Prov. */
1984			arr[1] = cmd[2];        /*sanity */
1985			arr[3] = inquiry_vpd_b2(&arr[4]);
1986		} else if (is_zbc && cmd[2] == 0xb6) { /* ZB dev. charact. */
1987			arr[1] = cmd[2];        /*sanity */
1988			arr[3] = inquiry_vpd_b6(devip, &arr[4]);
1989		} else {
1990			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, -1);
1991			kfree(arr);
1992			return check_condition_result;
1993		}
1994		len = min_t(u32, get_unaligned_be16(arr + 2) + 4, alloc_len);
1995		ret = fill_from_dev_buffer(scp, arr,
1996			    min_t(u32, len, SDEBUG_MAX_INQ_ARR_SZ));
1997		kfree(arr);
1998		return ret;
1999	}
2000	/* drops through here for a standard inquiry */
2001	arr[1] = sdebug_removable ? 0x80 : 0;	/* Removable disk */
2002	arr[2] = sdebug_scsi_level;
2003	arr[3] = 2;    /* response_data_format==2 */
2004	arr[4] = SDEBUG_LONG_INQ_SZ - 5;
2005	arr[5] = (int)have_dif_prot;	/* PROTECT bit */
2006	if (sdebug_vpd_use_hostno == 0)
2007		arr[5] |= 0x10; /* claim: implicit TPGS */
2008	arr[6] = 0x10; /* claim: MultiP */
2009	/* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
2010	arr[7] = 0xa; /* claim: LINKED + CMDQUE */
2011	memcpy(&arr[8], sdebug_inq_vendor_id, 8);
2012	memcpy(&arr[16], sdebug_inq_product_id, 16);
2013	memcpy(&arr[32], sdebug_inq_product_rev, 4);
2014	/* Use Vendor Specific area to place driver date in ASCII hex */
2015	memcpy(&arr[36], sdebug_version_date, 8);
2016	/* version descriptors (2 bytes each) follow */
2017	put_unaligned_be16(0xc0, arr + 58);   /* SAM-6 no version claimed */
2018	put_unaligned_be16(0x5c0, arr + 60);  /* SPC-5 no version claimed */
2019	n = 62;
2020	if (is_disk) {		/* SBC-4 no version claimed */
2021		put_unaligned_be16(0x600, arr + n);
2022		n += 2;
2023	} else if (sdebug_ptype == TYPE_TAPE) {	/* SSC-4 rev 3 */
2024		put_unaligned_be16(0x525, arr + n);
2025		n += 2;
2026	} else if (is_zbc) {	/* ZBC BSR INCITS 536 revision 05 */
2027		put_unaligned_be16(0x624, arr + n);
2028		n += 2;
2029	}
2030	put_unaligned_be16(0x2100, arr + n);	/* SPL-4 no version claimed */
2031	ret = fill_from_dev_buffer(scp, arr,
2032			    min_t(u32, alloc_len, SDEBUG_LONG_INQ_SZ));
2033	kfree(arr);
2034	return ret;
2035}
2036
2037/* See resp_iec_m_pg() for how this data is manipulated */
2038static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
2039				   0, 0, 0x0, 0x0};
2040
2041static int resp_requests(struct scsi_cmnd *scp,
2042			 struct sdebug_dev_info *devip)
2043{
2044	unsigned char *cmd = scp->cmnd;
2045	unsigned char arr[SCSI_SENSE_BUFFERSIZE];	/* assume >= 18 bytes */
2046	bool dsense = !!(cmd[1] & 1);
2047	u32 alloc_len = cmd[4];
2048	u32 len = 18;
2049	int stopped_state = atomic_read(&devip->stopped);
2050
2051	memset(arr, 0, sizeof(arr));
2052	if (stopped_state > 0) {	/* some "pollable" data [spc6r02: 5.12.2] */
2053		if (dsense) {
2054			arr[0] = 0x72;
2055			arr[1] = NOT_READY;
2056			arr[2] = LOGICAL_UNIT_NOT_READY;
2057			arr[3] = (stopped_state == 2) ? 0x1 : 0x2;
2058			len = 8;
2059		} else {
2060			arr[0] = 0x70;
2061			arr[2] = NOT_READY;		/* NO_SENSE in sense_key */
2062			arr[7] = 0xa;			/* 18 byte sense buffer */
2063			arr[12] = LOGICAL_UNIT_NOT_READY;
2064			arr[13] = (stopped_state == 2) ? 0x1 : 0x2;
2065		}
2066	} else if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
2067		/* Information exceptions control mode page: TEST=1, MRIE=6 */
2068		if (dsense) {
2069			arr[0] = 0x72;
2070			arr[1] = 0x0;		/* NO_SENSE in sense_key */
2071			arr[2] = THRESHOLD_EXCEEDED;
2072			arr[3] = 0xff;		/* Failure prediction(false) */
2073			len = 8;
2074		} else {
2075			arr[0] = 0x70;
2076			arr[2] = 0x0;		/* NO_SENSE in sense_key */
2077			arr[7] = 0xa;   	/* 18 byte sense buffer */
2078			arr[12] = THRESHOLD_EXCEEDED;
2079			arr[13] = 0xff;		/* Failure prediction(false) */
2080		}
2081	} else {	/* nothing to report */
2082		if (dsense) {
2083			len = 8;
2084			memset(arr, 0, len);
2085			arr[0] = 0x72;
2086		} else {
2087			memset(arr, 0, len);
2088			arr[0] = 0x70;
2089			arr[7] = 0xa;
2090		}
2091	}
2092	return fill_from_dev_buffer(scp, arr, min_t(u32, len, alloc_len));
2093}
2094
2095static int resp_start_stop(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
2096{
2097	unsigned char *cmd = scp->cmnd;
2098	int power_cond, want_stop, stopped_state;
2099	bool changing;
2100
2101	power_cond = (cmd[4] & 0xf0) >> 4;
2102	if (power_cond) {
2103		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, 7);
2104		return check_condition_result;
2105	}
2106	want_stop = !(cmd[4] & 1);
2107	stopped_state = atomic_read(&devip->stopped);
2108	if (stopped_state == 2) {
2109		ktime_t now_ts = ktime_get_boottime();
2110
2111		if (ktime_to_ns(now_ts) > ktime_to_ns(devip->create_ts)) {
2112			u64 diff_ns = ktime_to_ns(ktime_sub(now_ts, devip->create_ts));
2113
2114			if (diff_ns >= ((u64)sdeb_tur_ms_to_ready * 1000000)) {
2115				/* tur_ms_to_ready timer extinguished */
2116				atomic_set(&devip->stopped, 0);
2117				stopped_state = 0;
2118			}
2119		}
2120		if (stopped_state == 2) {
2121			if (want_stop) {
2122				stopped_state = 1;	/* dummy up success */
2123			} else {	/* Disallow tur_ms_to_ready delay to be overridden */
2124				mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, 0 /* START bit */);
2125				return check_condition_result;
2126			}
2127		}
2128	}
2129	changing = (stopped_state != want_stop);
2130	if (changing)
2131		atomic_xchg(&devip->stopped, want_stop);
2132	if (!changing || (cmd[1] & 0x1))  /* state unchanged or IMMED bit set in cdb */
2133		return SDEG_RES_IMMED_MASK;
2134	else
2135		return 0;
2136}
2137
2138static sector_t get_sdebug_capacity(void)
2139{
2140	static const unsigned int gibibyte = 1073741824;
2141
2142	if (sdebug_virtual_gb > 0)
2143		return (sector_t)sdebug_virtual_gb *
2144			(gibibyte / sdebug_sector_size);
2145	else
2146		return sdebug_store_sectors;
2147}
2148
2149#define SDEBUG_READCAP_ARR_SZ 8
2150static int resp_readcap(struct scsi_cmnd *scp,
2151			struct sdebug_dev_info *devip)
2152{
2153	unsigned char arr[SDEBUG_READCAP_ARR_SZ];
2154	unsigned int capac;
2155
2156	/* following just in case virtual_gb changed */
2157	sdebug_capacity = get_sdebug_capacity();
2158	memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
2159	if (sdebug_capacity < 0xffffffff) {
2160		capac = (unsigned int)sdebug_capacity - 1;
2161		put_unaligned_be32(capac, arr + 0);
2162	} else
2163		put_unaligned_be32(0xffffffff, arr + 0);
2164	put_unaligned_be16(sdebug_sector_size, arr + 6);
2165	return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
2166}
2167
2168#define SDEBUG_READCAP16_ARR_SZ 32
2169static int resp_readcap16(struct scsi_cmnd *scp,
2170			  struct sdebug_dev_info *devip)
2171{
2172	unsigned char *cmd = scp->cmnd;
2173	unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
2174	u32 alloc_len;
2175
2176	alloc_len = get_unaligned_be32(cmd + 10);
2177	/* following just in case virtual_gb changed */
2178	sdebug_capacity = get_sdebug_capacity();
2179	memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
2180	put_unaligned_be64((u64)(sdebug_capacity - 1), arr + 0);
2181	put_unaligned_be32(sdebug_sector_size, arr + 8);
2182	arr[13] = sdebug_physblk_exp & 0xf;
2183	arr[14] = (sdebug_lowest_aligned >> 8) & 0x3f;
2184
2185	if (scsi_debug_lbp()) {
2186		arr[14] |= 0x80; /* LBPME */
2187		/* from sbc4r07, this LBPRZ field is 1 bit, but the LBPRZ in
2188		 * the LB Provisioning VPD page is 3 bits. Note that lbprz=2
2189		 * in the wider field maps to 0 in this field.
2190		 */
2191		if (sdebug_lbprz & 1)	/* precisely what the draft requires */
2192			arr[14] |= 0x40;
2193	}
2194
2195	/*
2196	 * Since the scsi_debug READ CAPACITY implementation always reports the
2197	 * total disk capacity, set RC BASIS = 1 for host-managed ZBC devices.
2198	 */
2199	if (devip->zoned)
2200		arr[12] |= 1 << 4;
2201
2202	arr[15] = sdebug_lowest_aligned & 0xff;
2203
2204	if (have_dif_prot) {
2205		arr[12] = (sdebug_dif - 1) << 1; /* P_TYPE */
2206		arr[12] |= 1; /* PROT_EN */
2207	}
2208
2209	return fill_from_dev_buffer(scp, arr,
2210			    min_t(u32, alloc_len, SDEBUG_READCAP16_ARR_SZ));
2211}
2212
2213#define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
2214
2215static int resp_report_tgtpgs(struct scsi_cmnd *scp,
2216			      struct sdebug_dev_info *devip)
2217{
2218	unsigned char *cmd = scp->cmnd;
2219	unsigned char *arr;
2220	int host_no = devip->sdbg_host->shost->host_no;
 
2221	int port_group_a, port_group_b, port_a, port_b;
2222	u32 alen, n, rlen;
2223	int ret;
2224
2225	alen = get_unaligned_be32(cmd + 6);
2226	arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
2227	if (! arr)
2228		return DID_REQUEUE << 16;
2229	/*
2230	 * EVPD page 0x88 states we have two ports, one
2231	 * real and a fake port with no device connected.
2232	 * So we create two port groups with one port each
2233	 * and set the group with port B to unavailable.
2234	 */
2235	port_a = 0x1; /* relative port A */
2236	port_b = 0x2; /* relative port B */
2237	port_group_a = (((host_no + 1) & 0x7f) << 8) +
2238			(devip->channel & 0x7f);
2239	port_group_b = (((host_no + 1) & 0x7f) << 8) +
2240			(devip->channel & 0x7f) + 0x80;
2241
2242	/*
2243	 * The asymmetric access state is cycled according to the host_id.
2244	 */
2245	n = 4;
2246	if (sdebug_vpd_use_hostno == 0) {
2247		arr[n++] = host_no % 3; /* Asymm access state */
2248		arr[n++] = 0x0F; /* claim: all states are supported */
2249	} else {
2250		arr[n++] = 0x0; /* Active/Optimized path */
2251		arr[n++] = 0x01; /* only support active/optimized paths */
2252	}
2253	put_unaligned_be16(port_group_a, arr + n);
2254	n += 2;
2255	arr[n++] = 0;    /* Reserved */
2256	arr[n++] = 0;    /* Status code */
2257	arr[n++] = 0;    /* Vendor unique */
2258	arr[n++] = 0x1;  /* One port per group */
2259	arr[n++] = 0;    /* Reserved */
2260	arr[n++] = 0;    /* Reserved */
2261	put_unaligned_be16(port_a, arr + n);
2262	n += 2;
2263	arr[n++] = 3;    /* Port unavailable */
2264	arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
2265	put_unaligned_be16(port_group_b, arr + n);
2266	n += 2;
2267	arr[n++] = 0;    /* Reserved */
2268	arr[n++] = 0;    /* Status code */
2269	arr[n++] = 0;    /* Vendor unique */
2270	arr[n++] = 0x1;  /* One port per group */
2271	arr[n++] = 0;    /* Reserved */
2272	arr[n++] = 0;    /* Reserved */
2273	put_unaligned_be16(port_b, arr + n);
2274	n += 2;
2275
2276	rlen = n - 4;
2277	put_unaligned_be32(rlen, arr + 0);
2278
2279	/*
2280	 * Return the smallest value of either
2281	 * - The allocated length
2282	 * - The constructed command length
2283	 * - The maximum array size
2284	 */
2285	rlen = min(alen, n);
2286	ret = fill_from_dev_buffer(scp, arr,
2287			   min_t(u32, rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
2288	kfree(arr);
2289	return ret;
2290}
2291
2292static int resp_rsup_opcodes(struct scsi_cmnd *scp,
2293			     struct sdebug_dev_info *devip)
2294{
2295	bool rctd;
2296	u8 reporting_opts, req_opcode, sdeb_i, supp;
2297	u16 req_sa, u;
2298	u32 alloc_len, a_len;
2299	int k, offset, len, errsts, count, bump, na;
2300	const struct opcode_info_t *oip;
2301	const struct opcode_info_t *r_oip;
2302	u8 *arr;
2303	u8 *cmd = scp->cmnd;
2304
2305	rctd = !!(cmd[2] & 0x80);
2306	reporting_opts = cmd[2] & 0x7;
2307	req_opcode = cmd[3];
2308	req_sa = get_unaligned_be16(cmd + 4);
2309	alloc_len = get_unaligned_be32(cmd + 6);
2310	if (alloc_len < 4 || alloc_len > 0xffff) {
2311		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
2312		return check_condition_result;
2313	}
2314	if (alloc_len > 8192)
2315		a_len = 8192;
2316	else
2317		a_len = alloc_len;
2318	arr = kzalloc((a_len < 256) ? 320 : a_len + 64, GFP_ATOMIC);
2319	if (NULL == arr) {
2320		mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
2321				INSUFF_RES_ASCQ);
2322		return check_condition_result;
2323	}
2324	switch (reporting_opts) {
2325	case 0:	/* all commands */
2326		/* count number of commands */
2327		for (count = 0, oip = opcode_info_arr;
2328		     oip->num_attached != 0xff; ++oip) {
2329			if (F_INV_OP & oip->flags)
2330				continue;
2331			count += (oip->num_attached + 1);
2332		}
2333		bump = rctd ? 20 : 8;
2334		put_unaligned_be32(count * bump, arr);
2335		for (offset = 4, oip = opcode_info_arr;
2336		     oip->num_attached != 0xff && offset < a_len; ++oip) {
2337			if (F_INV_OP & oip->flags)
2338				continue;
2339			na = oip->num_attached;
2340			arr[offset] = oip->opcode;
2341			put_unaligned_be16(oip->sa, arr + offset + 2);
2342			if (rctd)
2343				arr[offset + 5] |= 0x2;
2344			if (FF_SA & oip->flags)
2345				arr[offset + 5] |= 0x1;
2346			put_unaligned_be16(oip->len_mask[0], arr + offset + 6);
2347			if (rctd)
2348				put_unaligned_be16(0xa, arr + offset + 8);
2349			r_oip = oip;
2350			for (k = 0, oip = oip->arrp; k < na; ++k, ++oip) {
2351				if (F_INV_OP & oip->flags)
2352					continue;
2353				offset += bump;
2354				arr[offset] = oip->opcode;
2355				put_unaligned_be16(oip->sa, arr + offset + 2);
2356				if (rctd)
2357					arr[offset + 5] |= 0x2;
2358				if (FF_SA & oip->flags)
2359					arr[offset + 5] |= 0x1;
2360				put_unaligned_be16(oip->len_mask[0],
2361						   arr + offset + 6);
2362				if (rctd)
2363					put_unaligned_be16(0xa,
2364							   arr + offset + 8);
2365			}
2366			oip = r_oip;
2367			offset += bump;
2368		}
2369		break;
2370	case 1:	/* one command: opcode only */
2371	case 2:	/* one command: opcode plus service action */
2372	case 3:	/* one command: if sa==0 then opcode only else opcode+sa */
2373		sdeb_i = opcode_ind_arr[req_opcode];
2374		oip = &opcode_info_arr[sdeb_i];
2375		if (F_INV_OP & oip->flags) {
2376			supp = 1;
2377			offset = 4;
2378		} else {
2379			if (1 == reporting_opts) {
2380				if (FF_SA & oip->flags) {
2381					mk_sense_invalid_fld(scp, SDEB_IN_CDB,
2382							     2, 2);
2383					kfree(arr);
2384					return check_condition_result;
2385				}
2386				req_sa = 0;
2387			} else if (2 == reporting_opts &&
2388				   0 == (FF_SA & oip->flags)) {
2389				mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, -1);
2390				kfree(arr);	/* point at requested sa */
2391				return check_condition_result;
2392			}
2393			if (0 == (FF_SA & oip->flags) &&
2394			    req_opcode == oip->opcode)
2395				supp = 3;
2396			else if (0 == (FF_SA & oip->flags)) {
2397				na = oip->num_attached;
2398				for (k = 0, oip = oip->arrp; k < na;
2399				     ++k, ++oip) {
2400					if (req_opcode == oip->opcode)
2401						break;
2402				}
2403				supp = (k >= na) ? 1 : 3;
2404			} else if (req_sa != oip->sa) {
2405				na = oip->num_attached;
2406				for (k = 0, oip = oip->arrp; k < na;
2407				     ++k, ++oip) {
2408					if (req_sa == oip->sa)
2409						break;
2410				}
2411				supp = (k >= na) ? 1 : 3;
2412			} else
2413				supp = 3;
2414			if (3 == supp) {
2415				u = oip->len_mask[0];
2416				put_unaligned_be16(u, arr + 2);
2417				arr[4] = oip->opcode;
2418				for (k = 1; k < u; ++k)
2419					arr[4 + k] = (k < 16) ?
2420						 oip->len_mask[k] : 0xff;
2421				offset = 4 + u;
2422			} else
2423				offset = 4;
2424		}
2425		arr[1] = (rctd ? 0x80 : 0) | supp;
2426		if (rctd) {
2427			put_unaligned_be16(0xa, arr + offset);
2428			offset += 12;
2429		}
2430		break;
2431	default:
2432		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 2);
2433		kfree(arr);
2434		return check_condition_result;
2435	}
2436	offset = (offset < a_len) ? offset : a_len;
2437	len = (offset < alloc_len) ? offset : alloc_len;
2438	errsts = fill_from_dev_buffer(scp, arr, len);
2439	kfree(arr);
2440	return errsts;
2441}
2442
2443static int resp_rsup_tmfs(struct scsi_cmnd *scp,
2444			  struct sdebug_dev_info *devip)
2445{
2446	bool repd;
2447	u32 alloc_len, len;
2448	u8 arr[16];
2449	u8 *cmd = scp->cmnd;
2450
2451	memset(arr, 0, sizeof(arr));
2452	repd = !!(cmd[2] & 0x80);
2453	alloc_len = get_unaligned_be32(cmd + 6);
2454	if (alloc_len < 4) {
2455		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
2456		return check_condition_result;
2457	}
2458	arr[0] = 0xc8;		/* ATS | ATSS | LURS */
2459	arr[1] = 0x1;		/* ITNRS */
2460	if (repd) {
2461		arr[3] = 0xc;
2462		len = 16;
2463	} else
2464		len = 4;
2465
2466	len = (len < alloc_len) ? len : alloc_len;
2467	return fill_from_dev_buffer(scp, arr, len);
2468}
2469
2470/* <<Following mode page info copied from ST318451LW>> */
2471
2472static int resp_err_recov_pg(unsigned char *p, int pcontrol, int target)
2473{	/* Read-Write Error Recovery page for mode_sense */
2474	unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
2475					5, 0, 0xff, 0xff};
2476
2477	memcpy(p, err_recov_pg, sizeof(err_recov_pg));
2478	if (1 == pcontrol)
2479		memset(p + 2, 0, sizeof(err_recov_pg) - 2);
2480	return sizeof(err_recov_pg);
2481}
2482
2483static int resp_disconnect_pg(unsigned char *p, int pcontrol, int target)
2484{ 	/* Disconnect-Reconnect page for mode_sense */
2485	unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
2486					 0, 0, 0, 0, 0, 0, 0, 0};
2487
2488	memcpy(p, disconnect_pg, sizeof(disconnect_pg));
2489	if (1 == pcontrol)
2490		memset(p + 2, 0, sizeof(disconnect_pg) - 2);
2491	return sizeof(disconnect_pg);
2492}
2493
2494static int resp_format_pg(unsigned char *p, int pcontrol, int target)
2495{       /* Format device page for mode_sense */
2496	unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
2497				     0, 0, 0, 0, 0, 0, 0, 0,
2498				     0, 0, 0, 0, 0x40, 0, 0, 0};
2499
2500	memcpy(p, format_pg, sizeof(format_pg));
2501	put_unaligned_be16(sdebug_sectors_per, p + 10);
2502	put_unaligned_be16(sdebug_sector_size, p + 12);
2503	if (sdebug_removable)
2504		p[20] |= 0x20; /* should agree with INQUIRY */
2505	if (1 == pcontrol)
2506		memset(p + 2, 0, sizeof(format_pg) - 2);
2507	return sizeof(format_pg);
2508}
2509
2510static unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
2511				     0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0,
2512				     0, 0, 0, 0};
2513
2514static int resp_caching_pg(unsigned char *p, int pcontrol, int target)
2515{ 	/* Caching page for mode_sense */
2516	unsigned char ch_caching_pg[] = {/* 0x8, 18, */ 0x4, 0, 0, 0, 0, 0,
2517		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
2518	unsigned char d_caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
2519		0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0,     0, 0, 0, 0};
2520
2521	if (SDEBUG_OPT_N_WCE & sdebug_opts)
2522		caching_pg[2] &= ~0x4;	/* set WCE=0 (default WCE=1) */
2523	memcpy(p, caching_pg, sizeof(caching_pg));
2524	if (1 == pcontrol)
2525		memcpy(p + 2, ch_caching_pg, sizeof(ch_caching_pg));
2526	else if (2 == pcontrol)
2527		memcpy(p, d_caching_pg, sizeof(d_caching_pg));
2528	return sizeof(caching_pg);
2529}
2530
2531static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
2532				    0, 0, 0x2, 0x4b};
2533
2534static int resp_ctrl_m_pg(unsigned char *p, int pcontrol, int target)
2535{ 	/* Control mode page for mode_sense */
2536	unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
2537					0, 0, 0, 0};
2538	unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
2539				     0, 0, 0x2, 0x4b};
2540
2541	if (sdebug_dsense)
2542		ctrl_m_pg[2] |= 0x4;
2543	else
2544		ctrl_m_pg[2] &= ~0x4;
2545
2546	if (sdebug_ato)
2547		ctrl_m_pg[5] |= 0x80; /* ATO=1 */
2548
2549	memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
2550	if (1 == pcontrol)
2551		memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
2552	else if (2 == pcontrol)
2553		memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
2554	return sizeof(ctrl_m_pg);
2555}
2556
2557
2558static int resp_iec_m_pg(unsigned char *p, int pcontrol, int target)
2559{	/* Informational Exceptions control mode page for mode_sense */
2560	unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
2561				       0, 0, 0x0, 0x0};
2562	unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
2563				      0, 0, 0x0, 0x0};
2564
2565	memcpy(p, iec_m_pg, sizeof(iec_m_pg));
2566	if (1 == pcontrol)
2567		memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
2568	else if (2 == pcontrol)
2569		memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
2570	return sizeof(iec_m_pg);
2571}
2572
2573static int resp_sas_sf_m_pg(unsigned char *p, int pcontrol, int target)
2574{	/* SAS SSP mode page - short format for mode_sense */
2575	unsigned char sas_sf_m_pg[] = {0x19, 0x6,
2576		0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
2577
2578	memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
2579	if (1 == pcontrol)
2580		memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
2581	return sizeof(sas_sf_m_pg);
2582}
2583
2584
2585static int resp_sas_pcd_m_spg(unsigned char *p, int pcontrol, int target,
2586			      int target_dev_id)
2587{	/* SAS phy control and discover mode page for mode_sense */
2588	unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
2589		    0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
2590		    0, 0, 0, 0, 0, 0, 0, 0,	/* insert SAS addr */
2591		    0, 0, 0, 0, 0, 0, 0, 0,	/* insert SAS addr */
2592		    0x2, 0, 0, 0, 0, 0, 0, 0,
2593		    0x88, 0x99, 0, 0, 0, 0, 0, 0,
2594		    0, 0, 0, 0, 0, 0, 0, 0,
2595		    0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
2596		    0, 0, 0, 0, 0, 0, 0, 0,	/* insert SAS addr */
2597		    0, 0, 0, 0, 0, 0, 0, 0,	/* insert SAS addr */
2598		    0x3, 0, 0, 0, 0, 0, 0, 0,
2599		    0x88, 0x99, 0, 0, 0, 0, 0, 0,
2600		    0, 0, 0, 0, 0, 0, 0, 0,
2601		};
2602	int port_a, port_b;
2603
2604	put_unaligned_be64(naa3_comp_a, sas_pcd_m_pg + 16);
2605	put_unaligned_be64(naa3_comp_c + 1, sas_pcd_m_pg + 24);
2606	put_unaligned_be64(naa3_comp_a, sas_pcd_m_pg + 64);
2607	put_unaligned_be64(naa3_comp_c + 1, sas_pcd_m_pg + 72);
2608	port_a = target_dev_id + 1;
2609	port_b = port_a + 1;
2610	memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
2611	put_unaligned_be32(port_a, p + 20);
2612	put_unaligned_be32(port_b, p + 48 + 20);
2613	if (1 == pcontrol)
2614		memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
2615	return sizeof(sas_pcd_m_pg);
2616}
2617
2618static int resp_sas_sha_m_spg(unsigned char *p, int pcontrol)
2619{	/* SAS SSP shared protocol specific port mode subpage */
2620	unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
2621		    0, 0, 0, 0, 0, 0, 0, 0,
2622		};
2623
2624	memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
2625	if (1 == pcontrol)
2626		memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
2627	return sizeof(sas_sha_m_pg);
2628}
2629
2630#define SDEBUG_MAX_MSENSE_SZ 256
2631
2632static int resp_mode_sense(struct scsi_cmnd *scp,
2633			   struct sdebug_dev_info *devip)
2634{
2635	int pcontrol, pcode, subpcode, bd_len;
2636	unsigned char dev_spec;
2637	u32 alloc_len, offset, len;
2638	int target_dev_id;
2639	int target = scp->device->id;
2640	unsigned char *ap;
2641	unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
2642	unsigned char *cmd = scp->cmnd;
2643	bool dbd, llbaa, msense_6, is_disk, is_zbc, bad_pcode;
2644
2645	dbd = !!(cmd[1] & 0x8);		/* disable block descriptors */
2646	pcontrol = (cmd[2] & 0xc0) >> 6;
2647	pcode = cmd[2] & 0x3f;
2648	subpcode = cmd[3];
2649	msense_6 = (MODE_SENSE == cmd[0]);
2650	llbaa = msense_6 ? false : !!(cmd[1] & 0x10);
2651	is_disk = (sdebug_ptype == TYPE_DISK);
2652	is_zbc = devip->zoned;
2653	if ((is_disk || is_zbc) && !dbd)
2654		bd_len = llbaa ? 16 : 8;
2655	else
2656		bd_len = 0;
2657	alloc_len = msense_6 ? cmd[4] : get_unaligned_be16(cmd + 7);
2658	memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
2659	if (0x3 == pcontrol) {  /* Saving values not supported */
2660		mk_sense_buffer(scp, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP, 0);
2661		return check_condition_result;
2662	}
2663	target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
2664			(devip->target * 1000) - 3;
2665	/* for disks+zbc set DPOFUA bit and clear write protect (WP) bit */
2666	if (is_disk || is_zbc) {
2667		dev_spec = 0x10;	/* =0x90 if WP=1 implies read-only */
2668		if (sdebug_wp)
2669			dev_spec |= 0x80;
2670	} else
2671		dev_spec = 0x0;
2672	if (msense_6) {
2673		arr[2] = dev_spec;
2674		arr[3] = bd_len;
2675		offset = 4;
2676	} else {
2677		arr[3] = dev_spec;
2678		if (16 == bd_len)
2679			arr[4] = 0x1;	/* set LONGLBA bit */
2680		arr[7] = bd_len;	/* assume 255 or less */
2681		offset = 8;
2682	}
2683	ap = arr + offset;
2684	if ((bd_len > 0) && (!sdebug_capacity))
2685		sdebug_capacity = get_sdebug_capacity();
2686
2687	if (8 == bd_len) {
2688		if (sdebug_capacity > 0xfffffffe)
2689			put_unaligned_be32(0xffffffff, ap + 0);
2690		else
2691			put_unaligned_be32(sdebug_capacity, ap + 0);
2692		put_unaligned_be16(sdebug_sector_size, ap + 6);
2693		offset += bd_len;
2694		ap = arr + offset;
2695	} else if (16 == bd_len) {
2696		put_unaligned_be64((u64)sdebug_capacity, ap + 0);
2697		put_unaligned_be32(sdebug_sector_size, ap + 12);
2698		offset += bd_len;
2699		ap = arr + offset;
2700	}
2701
2702	if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
2703		/* TODO: Control Extension page */
2704		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
2705		return check_condition_result;
2706	}
2707	bad_pcode = false;
2708
2709	switch (pcode) {
2710	case 0x1:	/* Read-Write error recovery page, direct access */
2711		len = resp_err_recov_pg(ap, pcontrol, target);
2712		offset += len;
2713		break;
2714	case 0x2:	/* Disconnect-Reconnect page, all devices */
2715		len = resp_disconnect_pg(ap, pcontrol, target);
2716		offset += len;
2717		break;
2718	case 0x3:       /* Format device page, direct access */
2719		if (is_disk) {
2720			len = resp_format_pg(ap, pcontrol, target);
2721			offset += len;
2722		} else
2723			bad_pcode = true;
2724		break;
2725	case 0x8:	/* Caching page, direct access */
2726		if (is_disk || is_zbc) {
2727			len = resp_caching_pg(ap, pcontrol, target);
2728			offset += len;
2729		} else
2730			bad_pcode = true;
2731		break;
2732	case 0xa:	/* Control Mode page, all devices */
2733		len = resp_ctrl_m_pg(ap, pcontrol, target);
2734		offset += len;
2735		break;
2736	case 0x19:	/* if spc==1 then sas phy, control+discover */
2737		if ((subpcode > 0x2) && (subpcode < 0xff)) {
2738			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
2739			return check_condition_result;
2740		}
2741		len = 0;
2742		if ((0x0 == subpcode) || (0xff == subpcode))
2743			len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
2744		if ((0x1 == subpcode) || (0xff == subpcode))
2745			len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
2746						  target_dev_id);
2747		if ((0x2 == subpcode) || (0xff == subpcode))
2748			len += resp_sas_sha_m_spg(ap + len, pcontrol);
2749		offset += len;
2750		break;
2751	case 0x1c:	/* Informational Exceptions Mode page, all devices */
2752		len = resp_iec_m_pg(ap, pcontrol, target);
2753		offset += len;
2754		break;
2755	case 0x3f:	/* Read all Mode pages */
2756		if ((0 == subpcode) || (0xff == subpcode)) {
2757			len = resp_err_recov_pg(ap, pcontrol, target);
2758			len += resp_disconnect_pg(ap + len, pcontrol, target);
2759			if (is_disk) {
2760				len += resp_format_pg(ap + len, pcontrol,
2761						      target);
2762				len += resp_caching_pg(ap + len, pcontrol,
2763						       target);
2764			} else if (is_zbc) {
2765				len += resp_caching_pg(ap + len, pcontrol,
2766						       target);
2767			}
2768			len += resp_ctrl_m_pg(ap + len, pcontrol, target);
2769			len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
2770			if (0xff == subpcode) {
2771				len += resp_sas_pcd_m_spg(ap + len, pcontrol,
2772						  target, target_dev_id);
2773				len += resp_sas_sha_m_spg(ap + len, pcontrol);
2774			}
2775			len += resp_iec_m_pg(ap + len, pcontrol, target);
2776			offset += len;
2777		} else {
2778			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
2779			return check_condition_result;
2780		}
2781		break;
2782	default:
2783		bad_pcode = true;
2784		break;
2785	}
2786	if (bad_pcode) {
2787		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
2788		return check_condition_result;
2789	}
2790	if (msense_6)
2791		arr[0] = offset - 1;
2792	else
2793		put_unaligned_be16((offset - 2), arr + 0);
2794	return fill_from_dev_buffer(scp, arr, min_t(u32, alloc_len, offset));
2795}
2796
2797#define SDEBUG_MAX_MSELECT_SZ 512
2798
2799static int resp_mode_select(struct scsi_cmnd *scp,
2800			    struct sdebug_dev_info *devip)
2801{
2802	int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
2803	int param_len, res, mpage;
2804	unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
2805	unsigned char *cmd = scp->cmnd;
2806	int mselect6 = (MODE_SELECT == cmd[0]);
2807
2808	memset(arr, 0, sizeof(arr));
2809	pf = cmd[1] & 0x10;
2810	sp = cmd[1] & 0x1;
2811	param_len = mselect6 ? cmd[4] : get_unaligned_be16(cmd + 7);
2812	if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
2813		mk_sense_invalid_fld(scp, SDEB_IN_CDB, mselect6 ? 4 : 7, -1);
2814		return check_condition_result;
2815	}
2816	res = fetch_to_dev_buffer(scp, arr, param_len);
2817	if (-1 == res)
2818		return DID_ERROR << 16;
2819	else if (sdebug_verbose && (res < param_len))
2820		sdev_printk(KERN_INFO, scp->device,
2821			    "%s: cdb indicated=%d, IO sent=%d bytes\n",
2822			    __func__, param_len, res);
2823	md_len = mselect6 ? (arr[0] + 1) : (get_unaligned_be16(arr + 0) + 2);
2824	bd_len = mselect6 ? arr[3] : get_unaligned_be16(arr + 6);
2825	off = bd_len + (mselect6 ? 4 : 8);
2826	if (md_len > 2 || off >= res) {
2827		mk_sense_invalid_fld(scp, SDEB_IN_DATA, 0, -1);
2828		return check_condition_result;
2829	}
 
2830	mpage = arr[off] & 0x3f;
2831	ps = !!(arr[off] & 0x80);
2832	if (ps) {
2833		mk_sense_invalid_fld(scp, SDEB_IN_DATA, off, 7);
2834		return check_condition_result;
2835	}
2836	spf = !!(arr[off] & 0x40);
2837	pg_len = spf ? (get_unaligned_be16(arr + off + 2) + 4) :
2838		       (arr[off + 1] + 2);
2839	if ((pg_len + off) > param_len) {
2840		mk_sense_buffer(scp, ILLEGAL_REQUEST,
2841				PARAMETER_LIST_LENGTH_ERR, 0);
2842		return check_condition_result;
2843	}
2844	switch (mpage) {
2845	case 0x8:      /* Caching Mode page */
2846		if (caching_pg[1] == arr[off + 1]) {
2847			memcpy(caching_pg + 2, arr + off + 2,
2848			       sizeof(caching_pg) - 2);
2849			goto set_mode_changed_ua;
2850		}
2851		break;
2852	case 0xa:      /* Control Mode page */
2853		if (ctrl_m_pg[1] == arr[off + 1]) {
2854			memcpy(ctrl_m_pg + 2, arr + off + 2,
2855			       sizeof(ctrl_m_pg) - 2);
2856			if (ctrl_m_pg[4] & 0x8)
2857				sdebug_wp = true;
2858			else
2859				sdebug_wp = false;
2860			sdebug_dsense = !!(ctrl_m_pg[2] & 0x4);
2861			goto set_mode_changed_ua;
2862		}
2863		break;
2864	case 0x1c:      /* Informational Exceptions Mode page */
2865		if (iec_m_pg[1] == arr[off + 1]) {
2866			memcpy(iec_m_pg + 2, arr + off + 2,
2867			       sizeof(iec_m_pg) - 2);
2868			goto set_mode_changed_ua;
2869		}
2870		break;
2871	default:
2872		break;
2873	}
2874	mk_sense_invalid_fld(scp, SDEB_IN_DATA, off, 5);
2875	return check_condition_result;
2876set_mode_changed_ua:
2877	set_bit(SDEBUG_UA_MODE_CHANGED, devip->uas_bm);
2878	return 0;
2879}
2880
2881static int resp_temp_l_pg(unsigned char *arr)
2882{
2883	unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
2884				     0x0, 0x1, 0x3, 0x2, 0x0, 65,
2885		};
2886
2887	memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
2888	return sizeof(temp_l_pg);
2889}
2890
2891static int resp_ie_l_pg(unsigned char *arr)
2892{
2893	unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
2894		};
2895
2896	memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
2897	if (iec_m_pg[2] & 0x4) {	/* TEST bit set */
2898		arr[4] = THRESHOLD_EXCEEDED;
2899		arr[5] = 0xff;
2900	}
2901	return sizeof(ie_l_pg);
2902}
2903
2904static int resp_env_rep_l_spg(unsigned char *arr)
2905{
2906	unsigned char env_rep_l_spg[] = {0x0, 0x0, 0x23, 0x8,
2907					 0x0, 40, 72, 0xff, 45, 18, 0, 0,
2908					 0x1, 0x0, 0x23, 0x8,
2909					 0x0, 55, 72, 35, 55, 45, 0, 0,
2910		};
2911
2912	memcpy(arr, env_rep_l_spg, sizeof(env_rep_l_spg));
2913	return sizeof(env_rep_l_spg);
2914}
2915
2916#define SDEBUG_MAX_LSENSE_SZ 512
2917
2918static int resp_log_sense(struct scsi_cmnd *scp,
2919			  struct sdebug_dev_info *devip)
2920{
2921	int ppc, sp, pcode, subpcode;
2922	u32 alloc_len, len, n;
2923	unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
2924	unsigned char *cmd = scp->cmnd;
2925
2926	memset(arr, 0, sizeof(arr));
2927	ppc = cmd[1] & 0x2;
2928	sp = cmd[1] & 0x1;
2929	if (ppc || sp) {
2930		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, ppc ? 1 : 0);
2931		return check_condition_result;
2932	}
2933	pcode = cmd[2] & 0x3f;
2934	subpcode = cmd[3] & 0xff;
2935	alloc_len = get_unaligned_be16(cmd + 7);
2936	arr[0] = pcode;
2937	if (0 == subpcode) {
2938		switch (pcode) {
2939		case 0x0:	/* Supported log pages log page */
2940			n = 4;
2941			arr[n++] = 0x0;		/* this page */
2942			arr[n++] = 0xd;		/* Temperature */
2943			arr[n++] = 0x2f;	/* Informational exceptions */
2944			arr[3] = n - 4;
2945			break;
2946		case 0xd:	/* Temperature log page */
2947			arr[3] = resp_temp_l_pg(arr + 4);
2948			break;
2949		case 0x2f:	/* Informational exceptions log page */
2950			arr[3] = resp_ie_l_pg(arr + 4);
2951			break;
2952		default:
2953			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
2954			return check_condition_result;
2955		}
2956	} else if (0xff == subpcode) {
2957		arr[0] |= 0x40;
2958		arr[1] = subpcode;
2959		switch (pcode) {
2960		case 0x0:	/* Supported log pages and subpages log page */
2961			n = 4;
2962			arr[n++] = 0x0;
2963			arr[n++] = 0x0;		/* 0,0 page */
2964			arr[n++] = 0x0;
2965			arr[n++] = 0xff;	/* this page */
2966			arr[n++] = 0xd;
2967			arr[n++] = 0x0;		/* Temperature */
2968			arr[n++] = 0xd;
2969			arr[n++] = 0x1;		/* Environment reporting */
2970			arr[n++] = 0xd;
2971			arr[n++] = 0xff;	/* all 0xd subpages */
2972			arr[n++] = 0x2f;
2973			arr[n++] = 0x0;	/* Informational exceptions */
2974			arr[n++] = 0x2f;
2975			arr[n++] = 0xff;	/* all 0x2f subpages */
2976			arr[3] = n - 4;
2977			break;
2978		case 0xd:	/* Temperature subpages */
2979			n = 4;
2980			arr[n++] = 0xd;
2981			arr[n++] = 0x0;		/* Temperature */
2982			arr[n++] = 0xd;
2983			arr[n++] = 0x1;		/* Environment reporting */
2984			arr[n++] = 0xd;
2985			arr[n++] = 0xff;	/* these subpages */
2986			arr[3] = n - 4;
2987			break;
2988		case 0x2f:	/* Informational exceptions subpages */
2989			n = 4;
2990			arr[n++] = 0x2f;
2991			arr[n++] = 0x0;		/* Informational exceptions */
2992			arr[n++] = 0x2f;
2993			arr[n++] = 0xff;	/* these subpages */
2994			arr[3] = n - 4;
2995			break;
2996		default:
2997			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
2998			return check_condition_result;
2999		}
3000	} else if (subpcode > 0) {
3001		arr[0] |= 0x40;
3002		arr[1] = subpcode;
3003		if (pcode == 0xd && subpcode == 1)
3004			arr[3] = resp_env_rep_l_spg(arr + 4);
3005		else {
3006			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
3007			return check_condition_result;
3008		}
3009	} else {
3010		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
3011		return check_condition_result;
3012	}
3013	len = min_t(u32, get_unaligned_be16(arr + 2) + 4, alloc_len);
3014	return fill_from_dev_buffer(scp, arr,
3015		    min_t(u32, len, SDEBUG_MAX_INQ_ARR_SZ));
3016}
3017
3018static inline bool sdebug_dev_is_zoned(struct sdebug_dev_info *devip)
3019{
3020	return devip->nr_zones != 0;
3021}
3022
3023static struct sdeb_zone_state *zbc_zone(struct sdebug_dev_info *devip,
3024					unsigned long long lba)
3025{
3026	u32 zno = lba >> devip->zsize_shift;
3027	struct sdeb_zone_state *zsp;
3028
3029	if (devip->zcap == devip->zsize || zno < devip->nr_conv_zones)
3030		return &devip->zstate[zno];
3031
3032	/*
3033	 * If the zone capacity is less than the zone size, adjust for gap
3034	 * zones.
3035	 */
3036	zno = 2 * zno - devip->nr_conv_zones;
3037	WARN_ONCE(zno >= devip->nr_zones, "%u > %u\n", zno, devip->nr_zones);
3038	zsp = &devip->zstate[zno];
3039	if (lba >= zsp->z_start + zsp->z_size)
3040		zsp++;
3041	WARN_ON_ONCE(lba >= zsp->z_start + zsp->z_size);
3042	return zsp;
3043}
3044
3045static inline bool zbc_zone_is_conv(struct sdeb_zone_state *zsp)
3046{
3047	return zsp->z_type == ZBC_ZTYPE_CNV;
3048}
3049
3050static inline bool zbc_zone_is_gap(struct sdeb_zone_state *zsp)
3051{
3052	return zsp->z_type == ZBC_ZTYPE_GAP;
3053}
3054
3055static inline bool zbc_zone_is_seq(struct sdeb_zone_state *zsp)
3056{
3057	return !zbc_zone_is_conv(zsp) && !zbc_zone_is_gap(zsp);
3058}
3059
3060static void zbc_close_zone(struct sdebug_dev_info *devip,
3061			   struct sdeb_zone_state *zsp)
3062{
3063	enum sdebug_z_cond zc;
3064
3065	if (!zbc_zone_is_seq(zsp))
3066		return;
3067
3068	zc = zsp->z_cond;
3069	if (!(zc == ZC2_IMPLICIT_OPEN || zc == ZC3_EXPLICIT_OPEN))
3070		return;
3071
3072	if (zc == ZC2_IMPLICIT_OPEN)
3073		devip->nr_imp_open--;
3074	else
3075		devip->nr_exp_open--;
3076
3077	if (zsp->z_wp == zsp->z_start) {
3078		zsp->z_cond = ZC1_EMPTY;
3079	} else {
3080		zsp->z_cond = ZC4_CLOSED;
3081		devip->nr_closed++;
3082	}
3083}
3084
3085static void zbc_close_imp_open_zone(struct sdebug_dev_info *devip)
3086{
3087	struct sdeb_zone_state *zsp = &devip->zstate[0];
3088	unsigned int i;
3089
3090	for (i = 0; i < devip->nr_zones; i++, zsp++) {
3091		if (zsp->z_cond == ZC2_IMPLICIT_OPEN) {
3092			zbc_close_zone(devip, zsp);
3093			return;
3094		}
3095	}
3096}
3097
3098static void zbc_open_zone(struct sdebug_dev_info *devip,
3099			  struct sdeb_zone_state *zsp, bool explicit)
3100{
3101	enum sdebug_z_cond zc;
3102
3103	if (!zbc_zone_is_seq(zsp))
3104		return;
3105
3106	zc = zsp->z_cond;
3107	if ((explicit && zc == ZC3_EXPLICIT_OPEN) ||
3108	    (!explicit && zc == ZC2_IMPLICIT_OPEN))
3109		return;
3110
3111	/* Close an implicit open zone if necessary */
3112	if (explicit && zsp->z_cond == ZC2_IMPLICIT_OPEN)
3113		zbc_close_zone(devip, zsp);
3114	else if (devip->max_open &&
3115		 devip->nr_imp_open + devip->nr_exp_open >= devip->max_open)
3116		zbc_close_imp_open_zone(devip);
3117
3118	if (zsp->z_cond == ZC4_CLOSED)
3119		devip->nr_closed--;
3120	if (explicit) {
3121		zsp->z_cond = ZC3_EXPLICIT_OPEN;
3122		devip->nr_exp_open++;
3123	} else {
3124		zsp->z_cond = ZC2_IMPLICIT_OPEN;
3125		devip->nr_imp_open++;
3126	}
3127}
3128
3129static inline void zbc_set_zone_full(struct sdebug_dev_info *devip,
3130				     struct sdeb_zone_state *zsp)
3131{
3132	switch (zsp->z_cond) {
3133	case ZC2_IMPLICIT_OPEN:
3134		devip->nr_imp_open--;
3135		break;
3136	case ZC3_EXPLICIT_OPEN:
3137		devip->nr_exp_open--;
3138		break;
3139	default:
3140		WARN_ONCE(true, "Invalid zone %llu condition %x\n",
3141			  zsp->z_start, zsp->z_cond);
3142		break;
3143	}
3144	zsp->z_cond = ZC5_FULL;
3145}
3146
3147static void zbc_inc_wp(struct sdebug_dev_info *devip,
3148		       unsigned long long lba, unsigned int num)
3149{
3150	struct sdeb_zone_state *zsp = zbc_zone(devip, lba);
3151	unsigned long long n, end, zend = zsp->z_start + zsp->z_size;
3152
3153	if (!zbc_zone_is_seq(zsp))
3154		return;
3155
3156	if (zsp->z_type == ZBC_ZTYPE_SWR) {
3157		zsp->z_wp += num;
3158		if (zsp->z_wp >= zend)
3159			zbc_set_zone_full(devip, zsp);
3160		return;
3161	}
3162
3163	while (num) {
3164		if (lba != zsp->z_wp)
3165			zsp->z_non_seq_resource = true;
3166
3167		end = lba + num;
3168		if (end >= zend) {
3169			n = zend - lba;
3170			zsp->z_wp = zend;
3171		} else if (end > zsp->z_wp) {
3172			n = num;
3173			zsp->z_wp = end;
3174		} else {
3175			n = num;
3176		}
3177		if (zsp->z_wp >= zend)
3178			zbc_set_zone_full(devip, zsp);
3179
3180		num -= n;
3181		lba += n;
3182		if (num) {
3183			zsp++;
3184			zend = zsp->z_start + zsp->z_size;
3185		}
3186	}
3187}
3188
3189static int check_zbc_access_params(struct scsi_cmnd *scp,
3190			unsigned long long lba, unsigned int num, bool write)
3191{
3192	struct scsi_device *sdp = scp->device;
3193	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
3194	struct sdeb_zone_state *zsp = zbc_zone(devip, lba);
3195	struct sdeb_zone_state *zsp_end = zbc_zone(devip, lba + num - 1);
3196
3197	if (!write) {
 
 
3198		/* For host-managed, reads cannot cross zone types boundaries */
3199		if (zsp->z_type != zsp_end->z_type) {
 
 
3200			mk_sense_buffer(scp, ILLEGAL_REQUEST,
3201					LBA_OUT_OF_RANGE,
3202					READ_INVDATA_ASCQ);
3203			return check_condition_result;
3204		}
3205		return 0;
3206	}
3207
3208	/* Writing into a gap zone is not allowed */
3209	if (zbc_zone_is_gap(zsp)) {
3210		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE,
3211				ATTEMPT_ACCESS_GAP);
3212		return check_condition_result;
3213	}
3214
3215	/* No restrictions for writes within conventional zones */
3216	if (zbc_zone_is_conv(zsp)) {
3217		if (!zbc_zone_is_conv(zsp_end)) {
3218			mk_sense_buffer(scp, ILLEGAL_REQUEST,
3219					LBA_OUT_OF_RANGE,
3220					WRITE_BOUNDARY_ASCQ);
3221			return check_condition_result;
3222		}
3223		return 0;
3224	}
3225
3226	if (zsp->z_type == ZBC_ZTYPE_SWR) {
3227		/* Writes cannot cross sequential zone boundaries */
3228		if (zsp_end != zsp) {
3229			mk_sense_buffer(scp, ILLEGAL_REQUEST,
3230					LBA_OUT_OF_RANGE,
3231					WRITE_BOUNDARY_ASCQ);
3232			return check_condition_result;
3233		}
3234		/* Cannot write full zones */
3235		if (zsp->z_cond == ZC5_FULL) {
3236			mk_sense_buffer(scp, ILLEGAL_REQUEST,
3237					INVALID_FIELD_IN_CDB, 0);
3238			return check_condition_result;
3239		}
3240		/* Writes must be aligned to the zone WP */
3241		if (lba != zsp->z_wp) {
3242			mk_sense_buffer(scp, ILLEGAL_REQUEST,
3243					LBA_OUT_OF_RANGE,
3244					UNALIGNED_WRITE_ASCQ);
3245			return check_condition_result;
3246		}
3247	}
3248
3249	/* Handle implicit open of closed and empty zones */
3250	if (zsp->z_cond == ZC1_EMPTY || zsp->z_cond == ZC4_CLOSED) {
3251		if (devip->max_open &&
3252		    devip->nr_exp_open >= devip->max_open) {
3253			mk_sense_buffer(scp, DATA_PROTECT,
3254					INSUFF_RES_ASC,
3255					INSUFF_ZONE_ASCQ);
3256			return check_condition_result;
3257		}
3258		zbc_open_zone(devip, zsp, false);
3259	}
3260
3261	return 0;
3262}
3263
3264static inline int check_device_access_params
3265			(struct scsi_cmnd *scp, unsigned long long lba,
3266			 unsigned int num, bool write)
3267{
3268	struct scsi_device *sdp = scp->device;
3269	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
3270
3271	if (lba + num > sdebug_capacity) {
3272		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
3273		return check_condition_result;
3274	}
3275	/* transfer length excessive (tie in to block limits VPD page) */
3276	if (num > sdebug_store_sectors) {
3277		/* needs work to find which cdb byte 'num' comes from */
3278		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
3279		return check_condition_result;
3280	}
3281	if (write && unlikely(sdebug_wp)) {
3282		mk_sense_buffer(scp, DATA_PROTECT, WRITE_PROTECTED, 0x2);
3283		return check_condition_result;
3284	}
3285	if (sdebug_dev_is_zoned(devip))
3286		return check_zbc_access_params(scp, lba, num, write);
3287
3288	return 0;
3289}
3290
3291/*
3292 * Note: if BUG_ON() fires it usually indicates a problem with the parser
3293 * tables. Perhaps a missing F_FAKE_RW or FF_MEDIA_IO flag. Response functions
3294 * that access any of the "stores" in struct sdeb_store_info should call this
3295 * function with bug_if_fake_rw set to true.
3296 */
3297static inline struct sdeb_store_info *devip2sip(struct sdebug_dev_info *devip,
3298						bool bug_if_fake_rw)
3299{
3300	if (sdebug_fake_rw) {
3301		BUG_ON(bug_if_fake_rw);	/* See note above */
3302		return NULL;
3303	}
3304	return xa_load(per_store_ap, devip->sdbg_host->si_idx);
3305}
3306
3307/* Returns number of bytes copied or -1 if error. */
3308static int do_device_access(struct sdeb_store_info *sip, struct scsi_cmnd *scp,
3309			    u32 sg_skip, u64 lba, u32 num, bool do_write)
3310{
3311	int ret;
3312	u64 block, rest = 0;
3313	enum dma_data_direction dir;
3314	struct scsi_data_buffer *sdb = &scp->sdb;
3315	u8 *fsp;
3316
3317	if (do_write) {
3318		dir = DMA_TO_DEVICE;
3319		write_since_sync = true;
3320	} else {
3321		dir = DMA_FROM_DEVICE;
3322	}
3323
3324	if (!sdb->length || !sip)
3325		return 0;
3326	if (scp->sc_data_direction != dir)
3327		return -1;
3328	fsp = sip->storep;
3329
3330	block = do_div(lba, sdebug_store_sectors);
3331	if (block + num > sdebug_store_sectors)
3332		rest = block + num - sdebug_store_sectors;
3333
3334	ret = sg_copy_buffer(sdb->table.sgl, sdb->table.nents,
3335		   fsp + (block * sdebug_sector_size),
3336		   (num - rest) * sdebug_sector_size, sg_skip, do_write);
3337	if (ret != (num - rest) * sdebug_sector_size)
3338		return ret;
3339
3340	if (rest) {
3341		ret += sg_copy_buffer(sdb->table.sgl, sdb->table.nents,
3342			    fsp, rest * sdebug_sector_size,
3343			    sg_skip + ((num - rest) * sdebug_sector_size),
3344			    do_write);
3345	}
3346
3347	return ret;
3348}
3349
3350/* Returns number of bytes copied or -1 if error. */
3351static int do_dout_fetch(struct scsi_cmnd *scp, u32 num, u8 *doutp)
3352{
3353	struct scsi_data_buffer *sdb = &scp->sdb;
3354
3355	if (!sdb->length)
3356		return 0;
3357	if (scp->sc_data_direction != DMA_TO_DEVICE)
3358		return -1;
3359	return sg_copy_buffer(sdb->table.sgl, sdb->table.nents, doutp,
3360			      num * sdebug_sector_size, 0, true);
3361}
3362
3363/* If sip->storep+lba compares equal to arr(num), then copy top half of
3364 * arr into sip->storep+lba and return true. If comparison fails then
3365 * return false. */
3366static bool comp_write_worker(struct sdeb_store_info *sip, u64 lba, u32 num,
3367			      const u8 *arr, bool compare_only)
3368{
3369	bool res;
3370	u64 block, rest = 0;
3371	u32 store_blks = sdebug_store_sectors;
3372	u32 lb_size = sdebug_sector_size;
3373	u8 *fsp = sip->storep;
3374
3375	block = do_div(lba, store_blks);
3376	if (block + num > store_blks)
3377		rest = block + num - store_blks;
3378
3379	res = !memcmp(fsp + (block * lb_size), arr, (num - rest) * lb_size);
3380	if (!res)
3381		return res;
3382	if (rest)
3383		res = memcmp(fsp, arr + ((num - rest) * lb_size),
3384			     rest * lb_size);
3385	if (!res)
3386		return res;
3387	if (compare_only)
3388		return true;
3389	arr += num * lb_size;
3390	memcpy(fsp + (block * lb_size), arr, (num - rest) * lb_size);
3391	if (rest)
3392		memcpy(fsp, arr + ((num - rest) * lb_size), rest * lb_size);
3393	return res;
3394}
3395
3396static __be16 dif_compute_csum(const void *buf, int len)
3397{
3398	__be16 csum;
3399
3400	if (sdebug_guard)
3401		csum = (__force __be16)ip_compute_csum(buf, len);
3402	else
3403		csum = cpu_to_be16(crc_t10dif(buf, len));
3404
3405	return csum;
3406}
3407
3408static int dif_verify(struct t10_pi_tuple *sdt, const void *data,
3409		      sector_t sector, u32 ei_lba)
3410{
3411	__be16 csum = dif_compute_csum(data, sdebug_sector_size);
3412
3413	if (sdt->guard_tag != csum) {
3414		pr_err("GUARD check failed on sector %lu rcvd 0x%04x, data 0x%04x\n",
3415			(unsigned long)sector,
3416			be16_to_cpu(sdt->guard_tag),
3417			be16_to_cpu(csum));
3418		return 0x01;
3419	}
3420	if (sdebug_dif == T10_PI_TYPE1_PROTECTION &&
3421	    be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
3422		pr_err("REF check failed on sector %lu\n",
3423			(unsigned long)sector);
3424		return 0x03;
3425	}
3426	if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
3427	    be32_to_cpu(sdt->ref_tag) != ei_lba) {
3428		pr_err("REF check failed on sector %lu\n",
3429			(unsigned long)sector);
3430		return 0x03;
3431	}
3432	return 0;
3433}
3434
3435static void dif_copy_prot(struct scsi_cmnd *scp, sector_t sector,
3436			  unsigned int sectors, bool read)
3437{
3438	size_t resid;
3439	void *paddr;
3440	struct sdeb_store_info *sip = devip2sip((struct sdebug_dev_info *)
3441						scp->device->hostdata, true);
3442	struct t10_pi_tuple *dif_storep = sip->dif_storep;
3443	const void *dif_store_end = dif_storep + sdebug_store_sectors;
3444	struct sg_mapping_iter miter;
3445
3446	/* Bytes of protection data to copy into sgl */
3447	resid = sectors * sizeof(*dif_storep);
3448
3449	sg_miter_start(&miter, scsi_prot_sglist(scp),
3450		       scsi_prot_sg_count(scp), SG_MITER_ATOMIC |
3451		       (read ? SG_MITER_TO_SG : SG_MITER_FROM_SG));
3452
3453	while (sg_miter_next(&miter) && resid > 0) {
3454		size_t len = min_t(size_t, miter.length, resid);
3455		void *start = dif_store(sip, sector);
3456		size_t rest = 0;
3457
3458		if (dif_store_end < start + len)
3459			rest = start + len - dif_store_end;
3460
3461		paddr = miter.addr;
3462
3463		if (read)
3464			memcpy(paddr, start, len - rest);
3465		else
3466			memcpy(start, paddr, len - rest);
3467
3468		if (rest) {
3469			if (read)
3470				memcpy(paddr + len - rest, dif_storep, rest);
3471			else
3472				memcpy(dif_storep, paddr + len - rest, rest);
3473		}
3474
3475		sector += len / sizeof(*dif_storep);
3476		resid -= len;
3477	}
3478	sg_miter_stop(&miter);
3479}
3480
3481static int prot_verify_read(struct scsi_cmnd *scp, sector_t start_sec,
3482			    unsigned int sectors, u32 ei_lba)
3483{
3484	int ret = 0;
3485	unsigned int i;
3486	sector_t sector;
3487	struct sdeb_store_info *sip = devip2sip((struct sdebug_dev_info *)
3488						scp->device->hostdata, true);
3489	struct t10_pi_tuple *sdt;
3490
3491	for (i = 0; i < sectors; i++, ei_lba++) {
 
 
3492		sector = start_sec + i;
3493		sdt = dif_store(sip, sector);
3494
3495		if (sdt->app_tag == cpu_to_be16(0xffff))
3496			continue;
3497
3498		/*
3499		 * Because scsi_debug acts as both initiator and
3500		 * target we proceed to verify the PI even if
3501		 * RDPROTECT=3. This is done so the "initiator" knows
3502		 * which type of error to return. Otherwise we would
3503		 * have to iterate over the PI twice.
3504		 */
3505		if (scp->cmnd[1] >> 5) { /* RDPROTECT */
3506			ret = dif_verify(sdt, lba2fake_store(sip, sector),
3507					 sector, ei_lba);
3508			if (ret) {
3509				dif_errors++;
3510				break;
3511			}
3512		}
3513	}
3514
3515	dif_copy_prot(scp, start_sec, sectors, true);
3516	dix_reads++;
3517
3518	return ret;
3519}
3520
3521static inline void
3522sdeb_read_lock(struct sdeb_store_info *sip)
3523{
3524	if (sdebug_no_rwlock) {
3525		if (sip)
3526			__acquire(&sip->macc_lck);
3527		else
3528			__acquire(&sdeb_fake_rw_lck);
3529	} else {
3530		if (sip)
3531			read_lock(&sip->macc_lck);
3532		else
3533			read_lock(&sdeb_fake_rw_lck);
3534	}
3535}
3536
3537static inline void
3538sdeb_read_unlock(struct sdeb_store_info *sip)
3539{
3540	if (sdebug_no_rwlock) {
3541		if (sip)
3542			__release(&sip->macc_lck);
3543		else
3544			__release(&sdeb_fake_rw_lck);
3545	} else {
3546		if (sip)
3547			read_unlock(&sip->macc_lck);
3548		else
3549			read_unlock(&sdeb_fake_rw_lck);
3550	}
3551}
3552
3553static inline void
3554sdeb_write_lock(struct sdeb_store_info *sip)
3555{
3556	if (sdebug_no_rwlock) {
3557		if (sip)
3558			__acquire(&sip->macc_lck);
3559		else
3560			__acquire(&sdeb_fake_rw_lck);
3561	} else {
3562		if (sip)
3563			write_lock(&sip->macc_lck);
3564		else
3565			write_lock(&sdeb_fake_rw_lck);
3566	}
3567}
3568
3569static inline void
3570sdeb_write_unlock(struct sdeb_store_info *sip)
3571{
3572	if (sdebug_no_rwlock) {
3573		if (sip)
3574			__release(&sip->macc_lck);
3575		else
3576			__release(&sdeb_fake_rw_lck);
3577	} else {
3578		if (sip)
3579			write_unlock(&sip->macc_lck);
3580		else
3581			write_unlock(&sdeb_fake_rw_lck);
3582	}
3583}
3584
3585static int resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
3586{
3587	bool check_prot;
3588	u32 num;
3589	u32 ei_lba;
3590	int ret;
3591	u64 lba;
3592	struct sdeb_store_info *sip = devip2sip(devip, true);
 
3593	u8 *cmd = scp->cmnd;
3594
3595	switch (cmd[0]) {
3596	case READ_16:
3597		ei_lba = 0;
3598		lba = get_unaligned_be64(cmd + 2);
3599		num = get_unaligned_be32(cmd + 10);
3600		check_prot = true;
3601		break;
3602	case READ_10:
3603		ei_lba = 0;
3604		lba = get_unaligned_be32(cmd + 2);
3605		num = get_unaligned_be16(cmd + 7);
3606		check_prot = true;
3607		break;
3608	case READ_6:
3609		ei_lba = 0;
3610		lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
3611		      (u32)(cmd[1] & 0x1f) << 16;
3612		num = (0 == cmd[4]) ? 256 : cmd[4];
3613		check_prot = true;
3614		break;
3615	case READ_12:
3616		ei_lba = 0;
3617		lba = get_unaligned_be32(cmd + 2);
3618		num = get_unaligned_be32(cmd + 6);
3619		check_prot = true;
3620		break;
3621	case XDWRITEREAD_10:
3622		ei_lba = 0;
3623		lba = get_unaligned_be32(cmd + 2);
3624		num = get_unaligned_be16(cmd + 7);
3625		check_prot = false;
3626		break;
3627	default:	/* assume READ(32) */
3628		lba = get_unaligned_be64(cmd + 12);
3629		ei_lba = get_unaligned_be32(cmd + 20);
3630		num = get_unaligned_be32(cmd + 28);
3631		check_prot = false;
3632		break;
3633	}
3634	if (unlikely(have_dif_prot && check_prot)) {
3635		if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
3636		    (cmd[1] & 0xe0)) {
3637			mk_sense_invalid_opcode(scp);
3638			return check_condition_result;
3639		}
3640		if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3641		     sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
3642		    (cmd[1] & 0xe0) == 0)
3643			sdev_printk(KERN_ERR, scp->device, "Unprotected RD "
3644				    "to DIF device\n");
3645	}
3646	if (unlikely((sdebug_opts & SDEBUG_OPT_SHORT_TRANSFER) &&
3647		     atomic_read(&sdeb_inject_pending))) {
3648		num /= 2;
3649		atomic_set(&sdeb_inject_pending, 0);
3650	}
3651
3652	ret = check_device_access_params(scp, lba, num, false);
3653	if (ret)
3654		return ret;
3655	if (unlikely((SDEBUG_OPT_MEDIUM_ERR & sdebug_opts) &&
3656		     (lba <= (sdebug_medium_error_start + sdebug_medium_error_count - 1)) &&
3657		     ((lba + num) > sdebug_medium_error_start))) {
3658		/* claim unrecoverable read error */
3659		mk_sense_buffer(scp, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 0);
3660		/* set info field and valid bit for fixed descriptor */
3661		if (0x70 == (scp->sense_buffer[0] & 0x7f)) {
3662			scp->sense_buffer[0] |= 0x80;	/* Valid bit */
3663			ret = (lba < OPT_MEDIUM_ERR_ADDR)
3664			      ? OPT_MEDIUM_ERR_ADDR : (int)lba;
3665			put_unaligned_be32(ret, scp->sense_buffer + 3);
3666		}
3667		scsi_set_resid(scp, scsi_bufflen(scp));
3668		return check_condition_result;
3669	}
3670
3671	sdeb_read_lock(sip);
3672
3673	/* DIX + T10 DIF */
3674	if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
3675		switch (prot_verify_read(scp, lba, num, ei_lba)) {
3676		case 1: /* Guard tag error */
3677			if (cmd[1] >> 5 != 3) { /* RDPROTECT != 3 */
3678				sdeb_read_unlock(sip);
3679				mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
3680				return check_condition_result;
3681			} else if (scp->prot_flags & SCSI_PROT_GUARD_CHECK) {
3682				sdeb_read_unlock(sip);
3683				mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
3684				return illegal_condition_result;
3685			}
3686			break;
3687		case 3: /* Reference tag error */
3688			if (cmd[1] >> 5 != 3) { /* RDPROTECT != 3 */
3689				sdeb_read_unlock(sip);
3690				mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 3);
3691				return check_condition_result;
3692			} else if (scp->prot_flags & SCSI_PROT_REF_CHECK) {
3693				sdeb_read_unlock(sip);
3694				mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 3);
3695				return illegal_condition_result;
3696			}
3697			break;
3698		}
3699	}
3700
3701	ret = do_device_access(sip, scp, 0, lba, num, false);
3702	sdeb_read_unlock(sip);
3703	if (unlikely(ret == -1))
3704		return DID_ERROR << 16;
3705
3706	scsi_set_resid(scp, scsi_bufflen(scp) - ret);
3707
3708	if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
3709		     atomic_read(&sdeb_inject_pending))) {
3710		if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
3711			mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
3712			atomic_set(&sdeb_inject_pending, 0);
3713			return check_condition_result;
3714		} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
3715			/* Logical block guard check failed */
3716			mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
3717			atomic_set(&sdeb_inject_pending, 0);
3718			return illegal_condition_result;
3719		} else if (SDEBUG_OPT_DIX_ERR & sdebug_opts) {
3720			mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
3721			atomic_set(&sdeb_inject_pending, 0);
3722			return illegal_condition_result;
3723		}
3724	}
3725	return 0;
3726}
3727
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3728static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
3729			     unsigned int sectors, u32 ei_lba)
3730{
3731	int ret;
3732	struct t10_pi_tuple *sdt;
3733	void *daddr;
3734	sector_t sector = start_sec;
3735	int ppage_offset;
3736	int dpage_offset;
3737	struct sg_mapping_iter diter;
3738	struct sg_mapping_iter piter;
3739
3740	BUG_ON(scsi_sg_count(SCpnt) == 0);
3741	BUG_ON(scsi_prot_sg_count(SCpnt) == 0);
3742
3743	sg_miter_start(&piter, scsi_prot_sglist(SCpnt),
3744			scsi_prot_sg_count(SCpnt),
3745			SG_MITER_ATOMIC | SG_MITER_FROM_SG);
3746	sg_miter_start(&diter, scsi_sglist(SCpnt), scsi_sg_count(SCpnt),
3747			SG_MITER_ATOMIC | SG_MITER_FROM_SG);
3748
3749	/* For each protection page */
3750	while (sg_miter_next(&piter)) {
3751		dpage_offset = 0;
3752		if (WARN_ON(!sg_miter_next(&diter))) {
3753			ret = 0x01;
3754			goto out;
3755		}
3756
3757		for (ppage_offset = 0; ppage_offset < piter.length;
3758		     ppage_offset += sizeof(struct t10_pi_tuple)) {
3759			/* If we're at the end of the current
3760			 * data page advance to the next one
3761			 */
3762			if (dpage_offset >= diter.length) {
3763				if (WARN_ON(!sg_miter_next(&diter))) {
3764					ret = 0x01;
3765					goto out;
3766				}
3767				dpage_offset = 0;
3768			}
3769
3770			sdt = piter.addr + ppage_offset;
3771			daddr = diter.addr + dpage_offset;
3772
3773			if (SCpnt->cmnd[1] >> 5 != 3) { /* WRPROTECT */
3774				ret = dif_verify(sdt, daddr, sector, ei_lba);
3775				if (ret)
3776					goto out;
3777			}
3778
3779			sector++;
3780			ei_lba++;
3781			dpage_offset += sdebug_sector_size;
3782		}
3783		diter.consumed = dpage_offset;
3784		sg_miter_stop(&diter);
3785	}
3786	sg_miter_stop(&piter);
3787
3788	dif_copy_prot(SCpnt, start_sec, sectors, false);
3789	dix_writes++;
3790
3791	return 0;
3792
3793out:
3794	dif_errors++;
3795	sg_miter_stop(&diter);
3796	sg_miter_stop(&piter);
3797	return ret;
3798}
3799
3800static unsigned long lba_to_map_index(sector_t lba)
3801{
3802	if (sdebug_unmap_alignment)
3803		lba += sdebug_unmap_granularity - sdebug_unmap_alignment;
3804	sector_div(lba, sdebug_unmap_granularity);
3805	return lba;
3806}
3807
3808static sector_t map_index_to_lba(unsigned long index)
3809{
3810	sector_t lba = index * sdebug_unmap_granularity;
3811
3812	if (sdebug_unmap_alignment)
3813		lba -= sdebug_unmap_granularity - sdebug_unmap_alignment;
3814	return lba;
3815}
3816
3817static unsigned int map_state(struct sdeb_store_info *sip, sector_t lba,
3818			      unsigned int *num)
3819{
3820	sector_t end;
3821	unsigned int mapped;
3822	unsigned long index;
3823	unsigned long next;
3824
3825	index = lba_to_map_index(lba);
3826	mapped = test_bit(index, sip->map_storep);
3827
3828	if (mapped)
3829		next = find_next_zero_bit(sip->map_storep, map_size, index);
3830	else
3831		next = find_next_bit(sip->map_storep, map_size, index);
3832
3833	end = min_t(sector_t, sdebug_store_sectors,  map_index_to_lba(next));
3834	*num = end - lba;
3835	return mapped;
3836}
3837
3838static void map_region(struct sdeb_store_info *sip, sector_t lba,
3839		       unsigned int len)
3840{
3841	sector_t end = lba + len;
3842
3843	while (lba < end) {
3844		unsigned long index = lba_to_map_index(lba);
3845
3846		if (index < map_size)
3847			set_bit(index, sip->map_storep);
3848
3849		lba = map_index_to_lba(index + 1);
3850	}
3851}
3852
3853static void unmap_region(struct sdeb_store_info *sip, sector_t lba,
3854			 unsigned int len)
3855{
3856	sector_t end = lba + len;
3857	u8 *fsp = sip->storep;
3858
3859	while (lba < end) {
3860		unsigned long index = lba_to_map_index(lba);
3861
3862		if (lba == map_index_to_lba(index) &&
3863		    lba + sdebug_unmap_granularity <= end &&
3864		    index < map_size) {
3865			clear_bit(index, sip->map_storep);
3866			if (sdebug_lbprz) {  /* for LBPRZ=2 return 0xff_s */
3867				memset(fsp + lba * sdebug_sector_size,
3868				       (sdebug_lbprz & 1) ? 0 : 0xff,
3869				       sdebug_sector_size *
3870				       sdebug_unmap_granularity);
3871			}
3872			if (sip->dif_storep) {
3873				memset(sip->dif_storep + lba, 0xff,
3874				       sizeof(*sip->dif_storep) *
3875				       sdebug_unmap_granularity);
3876			}
3877		}
3878		lba = map_index_to_lba(index + 1);
3879	}
3880}
3881
3882static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
3883{
3884	bool check_prot;
3885	u32 num;
3886	u32 ei_lba;
3887	int ret;
3888	u64 lba;
3889	struct sdeb_store_info *sip = devip2sip(devip, true);
 
3890	u8 *cmd = scp->cmnd;
3891
3892	switch (cmd[0]) {
3893	case WRITE_16:
3894		ei_lba = 0;
3895		lba = get_unaligned_be64(cmd + 2);
3896		num = get_unaligned_be32(cmd + 10);
3897		check_prot = true;
3898		break;
3899	case WRITE_10:
3900		ei_lba = 0;
3901		lba = get_unaligned_be32(cmd + 2);
3902		num = get_unaligned_be16(cmd + 7);
3903		check_prot = true;
3904		break;
3905	case WRITE_6:
3906		ei_lba = 0;
3907		lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
3908		      (u32)(cmd[1] & 0x1f) << 16;
3909		num = (0 == cmd[4]) ? 256 : cmd[4];
3910		check_prot = true;
3911		break;
3912	case WRITE_12:
3913		ei_lba = 0;
3914		lba = get_unaligned_be32(cmd + 2);
3915		num = get_unaligned_be32(cmd + 6);
3916		check_prot = true;
3917		break;
3918	case 0x53:	/* XDWRITEREAD(10) */
3919		ei_lba = 0;
3920		lba = get_unaligned_be32(cmd + 2);
3921		num = get_unaligned_be16(cmd + 7);
3922		check_prot = false;
3923		break;
3924	default:	/* assume WRITE(32) */
3925		lba = get_unaligned_be64(cmd + 12);
3926		ei_lba = get_unaligned_be32(cmd + 20);
3927		num = get_unaligned_be32(cmd + 28);
3928		check_prot = false;
3929		break;
3930	}
3931	if (unlikely(have_dif_prot && check_prot)) {
3932		if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
3933		    (cmd[1] & 0xe0)) {
3934			mk_sense_invalid_opcode(scp);
3935			return check_condition_result;
3936		}
3937		if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
3938		     sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
3939		    (cmd[1] & 0xe0) == 0)
3940			sdev_printk(KERN_ERR, scp->device, "Unprotected WR "
3941				    "to DIF device\n");
3942	}
3943
3944	sdeb_write_lock(sip);
3945	ret = check_device_access_params(scp, lba, num, true);
3946	if (ret) {
3947		sdeb_write_unlock(sip);
3948		return ret;
3949	}
3950
3951	/* DIX + T10 DIF */
3952	if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
3953		switch (prot_verify_write(scp, lba, num, ei_lba)) {
3954		case 1: /* Guard tag error */
3955			if (scp->prot_flags & SCSI_PROT_GUARD_CHECK) {
3956				sdeb_write_unlock(sip);
3957				mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
3958				return illegal_condition_result;
3959			} else if (scp->cmnd[1] >> 5 != 3) { /* WRPROTECT != 3 */
3960				sdeb_write_unlock(sip);
3961				mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
3962				return check_condition_result;
3963			}
3964			break;
3965		case 3: /* Reference tag error */
3966			if (scp->prot_flags & SCSI_PROT_REF_CHECK) {
3967				sdeb_write_unlock(sip);
3968				mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 3);
3969				return illegal_condition_result;
3970			} else if (scp->cmnd[1] >> 5 != 3) { /* WRPROTECT != 3 */
3971				sdeb_write_unlock(sip);
3972				mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 3);
3973				return check_condition_result;
3974			}
3975			break;
3976		}
3977	}
3978
3979	ret = do_device_access(sip, scp, 0, lba, num, true);
3980	if (unlikely(scsi_debug_lbp()))
3981		map_region(sip, lba, num);
3982	/* If ZBC zone then bump its write pointer */
3983	if (sdebug_dev_is_zoned(devip))
3984		zbc_inc_wp(devip, lba, num);
3985	sdeb_write_unlock(sip);
3986	if (unlikely(-1 == ret))
3987		return DID_ERROR << 16;
3988	else if (unlikely(sdebug_verbose &&
3989			  (ret < (num * sdebug_sector_size))))
3990		sdev_printk(KERN_INFO, scp->device,
3991			    "%s: write: cdb indicated=%u, IO sent=%d bytes\n",
3992			    my_name, num * sdebug_sector_size, ret);
3993
3994	if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
3995		     atomic_read(&sdeb_inject_pending))) {
3996		if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
3997			mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
3998			atomic_set(&sdeb_inject_pending, 0);
3999			return check_condition_result;
4000		} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
4001			/* Logical block guard check failed */
4002			mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
4003			atomic_set(&sdeb_inject_pending, 0);
4004			return illegal_condition_result;
4005		} else if (sdebug_opts & SDEBUG_OPT_DIX_ERR) {
4006			mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
4007			atomic_set(&sdeb_inject_pending, 0);
4008			return illegal_condition_result;
4009		}
4010	}
4011	return 0;
4012}
4013
4014/*
4015 * T10 has only specified WRITE SCATTERED(16) and WRITE SCATTERED(32).
4016 * No READ GATHERED yet (requires bidi or long cdb holding gather list).
4017 */
4018static int resp_write_scat(struct scsi_cmnd *scp,
4019			   struct sdebug_dev_info *devip)
4020{
4021	u8 *cmd = scp->cmnd;
4022	u8 *lrdp = NULL;
4023	u8 *up;
4024	struct sdeb_store_info *sip = devip2sip(devip, true);
 
4025	u8 wrprotect;
4026	u16 lbdof, num_lrd, k;
4027	u32 num, num_by, bt_len, lbdof_blen, sg_off, cum_lb;
4028	u32 lb_size = sdebug_sector_size;
4029	u32 ei_lba;
4030	u64 lba;
4031	int ret, res;
4032	bool is_16;
4033	static const u32 lrd_size = 32; /* + parameter list header size */
4034
4035	if (cmd[0] == VARIABLE_LENGTH_CMD) {
4036		is_16 = false;
4037		wrprotect = (cmd[10] >> 5) & 0x7;
4038		lbdof = get_unaligned_be16(cmd + 12);
4039		num_lrd = get_unaligned_be16(cmd + 16);
4040		bt_len = get_unaligned_be32(cmd + 28);
4041	} else {        /* that leaves WRITE SCATTERED(16) */
4042		is_16 = true;
4043		wrprotect = (cmd[2] >> 5) & 0x7;
4044		lbdof = get_unaligned_be16(cmd + 4);
4045		num_lrd = get_unaligned_be16(cmd + 8);
4046		bt_len = get_unaligned_be32(cmd + 10);
4047		if (unlikely(have_dif_prot)) {
4048			if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
4049			    wrprotect) {
4050				mk_sense_invalid_opcode(scp);
4051				return illegal_condition_result;
4052			}
4053			if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
4054			     sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
4055			     wrprotect == 0)
4056				sdev_printk(KERN_ERR, scp->device,
4057					    "Unprotected WR to DIF device\n");
4058		}
4059	}
4060	if ((num_lrd == 0) || (bt_len == 0))
4061		return 0;       /* T10 says these do-nothings are not errors */
4062	if (lbdof == 0) {
4063		if (sdebug_verbose)
4064			sdev_printk(KERN_INFO, scp->device,
4065				"%s: %s: LB Data Offset field bad\n",
4066				my_name, __func__);
4067		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4068		return illegal_condition_result;
4069	}
4070	lbdof_blen = lbdof * lb_size;
4071	if ((lrd_size + (num_lrd * lrd_size)) > lbdof_blen) {
4072		if (sdebug_verbose)
4073			sdev_printk(KERN_INFO, scp->device,
4074				"%s: %s: LBA range descriptors don't fit\n",
4075				my_name, __func__);
4076		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4077		return illegal_condition_result;
4078	}
4079	lrdp = kzalloc(lbdof_blen, GFP_ATOMIC | __GFP_NOWARN);
4080	if (lrdp == NULL)
4081		return SCSI_MLQUEUE_HOST_BUSY;
4082	if (sdebug_verbose)
4083		sdev_printk(KERN_INFO, scp->device,
4084			"%s: %s: Fetch header+scatter_list, lbdof_blen=%u\n",
4085			my_name, __func__, lbdof_blen);
4086	res = fetch_to_dev_buffer(scp, lrdp, lbdof_blen);
4087	if (res == -1) {
4088		ret = DID_ERROR << 16;
4089		goto err_out;
4090	}
4091
4092	sdeb_write_lock(sip);
4093	sg_off = lbdof_blen;
4094	/* Spec says Buffer xfer Length field in number of LBs in dout */
4095	cum_lb = 0;
4096	for (k = 0, up = lrdp + lrd_size; k < num_lrd; ++k, up += lrd_size) {
4097		lba = get_unaligned_be64(up + 0);
4098		num = get_unaligned_be32(up + 8);
4099		if (sdebug_verbose)
4100			sdev_printk(KERN_INFO, scp->device,
4101				"%s: %s: k=%d  LBA=0x%llx num=%u  sg_off=%u\n",
4102				my_name, __func__, k, lba, num, sg_off);
4103		if (num == 0)
4104			continue;
4105		ret = check_device_access_params(scp, lba, num, true);
4106		if (ret)
4107			goto err_out_unlock;
4108		num_by = num * lb_size;
4109		ei_lba = is_16 ? 0 : get_unaligned_be32(up + 12);
4110
4111		if ((cum_lb + num) > bt_len) {
4112			if (sdebug_verbose)
4113				sdev_printk(KERN_INFO, scp->device,
4114				    "%s: %s: sum of blocks > data provided\n",
4115				    my_name, __func__);
4116			mk_sense_buffer(scp, ILLEGAL_REQUEST, WRITE_ERROR_ASC,
4117					0);
4118			ret = illegal_condition_result;
4119			goto err_out_unlock;
4120		}
4121
4122		/* DIX + T10 DIF */
4123		if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
4124			int prot_ret = prot_verify_write(scp, lba, num,
4125							 ei_lba);
4126
4127			if (prot_ret) {
4128				mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10,
4129						prot_ret);
4130				ret = illegal_condition_result;
4131				goto err_out_unlock;
4132			}
4133		}
4134
4135		ret = do_device_access(sip, scp, sg_off, lba, num, true);
4136		/* If ZBC zone then bump its write pointer */
4137		if (sdebug_dev_is_zoned(devip))
4138			zbc_inc_wp(devip, lba, num);
4139		if (unlikely(scsi_debug_lbp()))
4140			map_region(sip, lba, num);
4141		if (unlikely(-1 == ret)) {
4142			ret = DID_ERROR << 16;
4143			goto err_out_unlock;
4144		} else if (unlikely(sdebug_verbose && (ret < num_by)))
4145			sdev_printk(KERN_INFO, scp->device,
4146			    "%s: write: cdb indicated=%u, IO sent=%d bytes\n",
4147			    my_name, num_by, ret);
4148
4149		if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
4150			     atomic_read(&sdeb_inject_pending))) {
4151			if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
4152				mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
4153				atomic_set(&sdeb_inject_pending, 0);
4154				ret = check_condition_result;
4155				goto err_out_unlock;
4156			} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
4157				/* Logical block guard check failed */
4158				mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
4159				atomic_set(&sdeb_inject_pending, 0);
4160				ret = illegal_condition_result;
4161				goto err_out_unlock;
4162			} else if (sdebug_opts & SDEBUG_OPT_DIX_ERR) {
4163				mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
4164				atomic_set(&sdeb_inject_pending, 0);
4165				ret = illegal_condition_result;
4166				goto err_out_unlock;
4167			}
4168		}
4169		sg_off += num_by;
4170		cum_lb += num;
4171	}
4172	ret = 0;
4173err_out_unlock:
4174	sdeb_write_unlock(sip);
4175err_out:
4176	kfree(lrdp);
4177	return ret;
4178}
4179
4180static int resp_write_same(struct scsi_cmnd *scp, u64 lba, u32 num,
4181			   u32 ei_lba, bool unmap, bool ndob)
4182{
4183	struct scsi_device *sdp = scp->device;
4184	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
4185	unsigned long long i;
4186	u64 block, lbaa;
4187	u32 lb_size = sdebug_sector_size;
4188	int ret;
4189	struct sdeb_store_info *sip = devip2sip((struct sdebug_dev_info *)
4190						scp->device->hostdata, true);
 
4191	u8 *fs1p;
4192	u8 *fsp;
4193
4194	sdeb_write_lock(sip);
4195
4196	ret = check_device_access_params(scp, lba, num, true);
4197	if (ret) {
4198		sdeb_write_unlock(sip);
4199		return ret;
4200	}
4201
4202	if (unmap && scsi_debug_lbp()) {
4203		unmap_region(sip, lba, num);
4204		goto out;
4205	}
4206	lbaa = lba;
4207	block = do_div(lbaa, sdebug_store_sectors);
4208	/* if ndob then zero 1 logical block, else fetch 1 logical block */
4209	fsp = sip->storep;
4210	fs1p = fsp + (block * lb_size);
4211	if (ndob) {
4212		memset(fs1p, 0, lb_size);
4213		ret = 0;
4214	} else
4215		ret = fetch_to_dev_buffer(scp, fs1p, lb_size);
4216
4217	if (-1 == ret) {
4218		sdeb_write_unlock(sip);
4219		return DID_ERROR << 16;
4220	} else if (sdebug_verbose && !ndob && (ret < lb_size))
4221		sdev_printk(KERN_INFO, scp->device,
4222			    "%s: %s: lb size=%u, IO sent=%d bytes\n",
4223			    my_name, "write same", lb_size, ret);
4224
4225	/* Copy first sector to remaining blocks */
4226	for (i = 1 ; i < num ; i++) {
4227		lbaa = lba + i;
4228		block = do_div(lbaa, sdebug_store_sectors);
4229		memmove(fsp + (block * lb_size), fs1p, lb_size);
4230	}
4231	if (scsi_debug_lbp())
4232		map_region(sip, lba, num);
4233	/* If ZBC zone then bump its write pointer */
4234	if (sdebug_dev_is_zoned(devip))
4235		zbc_inc_wp(devip, lba, num);
4236out:
4237	sdeb_write_unlock(sip);
4238
4239	return 0;
4240}
4241
4242static int resp_write_same_10(struct scsi_cmnd *scp,
4243			      struct sdebug_dev_info *devip)
4244{
4245	u8 *cmd = scp->cmnd;
4246	u32 lba;
4247	u16 num;
4248	u32 ei_lba = 0;
4249	bool unmap = false;
4250
4251	if (cmd[1] & 0x8) {
4252		if (sdebug_lbpws10 == 0) {
4253			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 3);
4254			return check_condition_result;
4255		} else
4256			unmap = true;
4257	}
4258	lba = get_unaligned_be32(cmd + 2);
4259	num = get_unaligned_be16(cmd + 7);
4260	if (num > sdebug_write_same_length) {
4261		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 7, -1);
4262		return check_condition_result;
4263	}
4264	return resp_write_same(scp, lba, num, ei_lba, unmap, false);
4265}
4266
4267static int resp_write_same_16(struct scsi_cmnd *scp,
4268			      struct sdebug_dev_info *devip)
4269{
4270	u8 *cmd = scp->cmnd;
4271	u64 lba;
4272	u32 num;
4273	u32 ei_lba = 0;
4274	bool unmap = false;
4275	bool ndob = false;
4276
4277	if (cmd[1] & 0x8) {	/* UNMAP */
4278		if (sdebug_lbpws == 0) {
4279			mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 3);
4280			return check_condition_result;
4281		} else
4282			unmap = true;
4283	}
4284	if (cmd[1] & 0x1)  /* NDOB (no data-out buffer, assumes zeroes) */
4285		ndob = true;
4286	lba = get_unaligned_be64(cmd + 2);
4287	num = get_unaligned_be32(cmd + 10);
4288	if (num > sdebug_write_same_length) {
4289		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 10, -1);
4290		return check_condition_result;
4291	}
4292	return resp_write_same(scp, lba, num, ei_lba, unmap, ndob);
4293}
4294
4295/* Note the mode field is in the same position as the (lower) service action
4296 * field. For the Report supported operation codes command, SPC-4 suggests
4297 * each mode of this command should be reported separately; for future. */
4298static int resp_write_buffer(struct scsi_cmnd *scp,
4299			     struct sdebug_dev_info *devip)
4300{
4301	u8 *cmd = scp->cmnd;
4302	struct scsi_device *sdp = scp->device;
4303	struct sdebug_dev_info *dp;
4304	u8 mode;
4305
4306	mode = cmd[1] & 0x1f;
4307	switch (mode) {
4308	case 0x4:	/* download microcode (MC) and activate (ACT) */
4309		/* set UAs on this device only */
4310		set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
4311		set_bit(SDEBUG_UA_MICROCODE_CHANGED, devip->uas_bm);
4312		break;
4313	case 0x5:	/* download MC, save and ACT */
4314		set_bit(SDEBUG_UA_MICROCODE_CHANGED_WO_RESET, devip->uas_bm);
4315		break;
4316	case 0x6:	/* download MC with offsets and ACT */
4317		/* set UAs on most devices (LUs) in this target */
4318		list_for_each_entry(dp,
4319				    &devip->sdbg_host->dev_info_list,
4320				    dev_list)
4321			if (dp->target == sdp->id) {
4322				set_bit(SDEBUG_UA_BUS_RESET, dp->uas_bm);
4323				if (devip != dp)
4324					set_bit(SDEBUG_UA_MICROCODE_CHANGED,
4325						dp->uas_bm);
4326			}
4327		break;
4328	case 0x7:	/* download MC with offsets, save, and ACT */
4329		/* set UA on all devices (LUs) in this target */
4330		list_for_each_entry(dp,
4331				    &devip->sdbg_host->dev_info_list,
4332				    dev_list)
4333			if (dp->target == sdp->id)
4334				set_bit(SDEBUG_UA_MICROCODE_CHANGED_WO_RESET,
4335					dp->uas_bm);
4336		break;
4337	default:
4338		/* do nothing for this command for other mode values */
4339		break;
4340	}
4341	return 0;
4342}
4343
4344static int resp_comp_write(struct scsi_cmnd *scp,
4345			   struct sdebug_dev_info *devip)
4346{
4347	u8 *cmd = scp->cmnd;
4348	u8 *arr;
4349	struct sdeb_store_info *sip = devip2sip(devip, true);
 
4350	u64 lba;
4351	u32 dnum;
4352	u32 lb_size = sdebug_sector_size;
4353	u8 num;
4354	int ret;
4355	int retval = 0;
4356
4357	lba = get_unaligned_be64(cmd + 2);
4358	num = cmd[13];		/* 1 to a maximum of 255 logical blocks */
4359	if (0 == num)
4360		return 0;	/* degenerate case, not an error */
4361	if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
4362	    (cmd[1] & 0xe0)) {
4363		mk_sense_invalid_opcode(scp);
4364		return check_condition_result;
4365	}
4366	if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
4367	     sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
4368	    (cmd[1] & 0xe0) == 0)
4369		sdev_printk(KERN_ERR, scp->device, "Unprotected WR "
4370			    "to DIF device\n");
4371	ret = check_device_access_params(scp, lba, num, false);
4372	if (ret)
4373		return ret;
4374	dnum = 2 * num;
4375	arr = kcalloc(lb_size, dnum, GFP_ATOMIC);
4376	if (NULL == arr) {
4377		mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
4378				INSUFF_RES_ASCQ);
4379		return check_condition_result;
4380	}
4381
4382	sdeb_write_lock(sip);
4383
4384	ret = do_dout_fetch(scp, dnum, arr);
4385	if (ret == -1) {
4386		retval = DID_ERROR << 16;
4387		goto cleanup;
4388	} else if (sdebug_verbose && (ret < (dnum * lb_size)))
4389		sdev_printk(KERN_INFO, scp->device, "%s: compare_write: cdb "
4390			    "indicated=%u, IO sent=%d bytes\n", my_name,
4391			    dnum * lb_size, ret);
4392	if (!comp_write_worker(sip, lba, num, arr, false)) {
4393		mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
4394		retval = check_condition_result;
4395		goto cleanup;
4396	}
4397	if (scsi_debug_lbp())
4398		map_region(sip, lba, num);
4399cleanup:
4400	sdeb_write_unlock(sip);
4401	kfree(arr);
4402	return retval;
4403}
4404
4405struct unmap_block_desc {
4406	__be64	lba;
4407	__be32	blocks;
4408	__be32	__reserved;
4409};
4410
4411static int resp_unmap(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
4412{
4413	unsigned char *buf;
4414	struct unmap_block_desc *desc;
4415	struct sdeb_store_info *sip = devip2sip(devip, true);
 
4416	unsigned int i, payload_len, descriptors;
4417	int ret;
4418
4419	if (!scsi_debug_lbp())
4420		return 0;	/* fib and say its done */
4421	payload_len = get_unaligned_be16(scp->cmnd + 7);
4422	BUG_ON(scsi_bufflen(scp) != payload_len);
4423
4424	descriptors = (payload_len - 8) / 16;
4425	if (descriptors > sdebug_unmap_max_desc) {
4426		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 7, -1);
4427		return check_condition_result;
4428	}
4429
4430	buf = kzalloc(scsi_bufflen(scp), GFP_ATOMIC);
4431	if (!buf) {
4432		mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
4433				INSUFF_RES_ASCQ);
4434		return check_condition_result;
4435	}
4436
4437	scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
4438
4439	BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2);
4440	BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16);
4441
4442	desc = (void *)&buf[8];
4443
4444	sdeb_write_lock(sip);
4445
4446	for (i = 0 ; i < descriptors ; i++) {
4447		unsigned long long lba = get_unaligned_be64(&desc[i].lba);
4448		unsigned int num = get_unaligned_be32(&desc[i].blocks);
4449
4450		ret = check_device_access_params(scp, lba, num, true);
4451		if (ret)
4452			goto out;
4453
4454		unmap_region(sip, lba, num);
4455	}
4456
4457	ret = 0;
4458
4459out:
4460	sdeb_write_unlock(sip);
4461	kfree(buf);
4462
4463	return ret;
4464}
4465
4466#define SDEBUG_GET_LBA_STATUS_LEN 32
4467
4468static int resp_get_lba_status(struct scsi_cmnd *scp,
4469			       struct sdebug_dev_info *devip)
4470{
4471	u8 *cmd = scp->cmnd;
4472	u64 lba;
4473	u32 alloc_len, mapped, num;
4474	int ret;
4475	u8 arr[SDEBUG_GET_LBA_STATUS_LEN];
4476
4477	lba = get_unaligned_be64(cmd + 2);
4478	alloc_len = get_unaligned_be32(cmd + 10);
4479
4480	if (alloc_len < 24)
4481		return 0;
4482
4483	ret = check_device_access_params(scp, lba, 1, false);
4484	if (ret)
4485		return ret;
4486
4487	if (scsi_debug_lbp()) {
4488		struct sdeb_store_info *sip = devip2sip(devip, true);
4489
4490		mapped = map_state(sip, lba, &num);
4491	} else {
4492		mapped = 1;
4493		/* following just in case virtual_gb changed */
4494		sdebug_capacity = get_sdebug_capacity();
4495		if (sdebug_capacity - lba <= 0xffffffff)
4496			num = sdebug_capacity - lba;
4497		else
4498			num = 0xffffffff;
4499	}
4500
4501	memset(arr, 0, SDEBUG_GET_LBA_STATUS_LEN);
4502	put_unaligned_be32(20, arr);		/* Parameter Data Length */
4503	put_unaligned_be64(lba, arr + 8);	/* LBA */
4504	put_unaligned_be32(num, arr + 16);	/* Number of blocks */
4505	arr[20] = !mapped;		/* prov_stat=0: mapped; 1: dealloc */
4506
4507	return fill_from_dev_buffer(scp, arr, SDEBUG_GET_LBA_STATUS_LEN);
4508}
4509
4510static int resp_sync_cache(struct scsi_cmnd *scp,
4511			   struct sdebug_dev_info *devip)
4512{
4513	int res = 0;
4514	u64 lba;
4515	u32 num_blocks;
4516	u8 *cmd = scp->cmnd;
4517
4518	if (cmd[0] == SYNCHRONIZE_CACHE) {	/* 10 byte cdb */
4519		lba = get_unaligned_be32(cmd + 2);
4520		num_blocks = get_unaligned_be16(cmd + 7);
4521	} else {				/* SYNCHRONIZE_CACHE(16) */
4522		lba = get_unaligned_be64(cmd + 2);
4523		num_blocks = get_unaligned_be32(cmd + 10);
4524	}
4525	if (lba + num_blocks > sdebug_capacity) {
4526		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4527		return check_condition_result;
4528	}
4529	if (!write_since_sync || (cmd[1] & 0x2))
4530		res = SDEG_RES_IMMED_MASK;
4531	else		/* delay if write_since_sync and IMMED clear */
4532		write_since_sync = false;
4533	return res;
4534}
4535
4536/*
4537 * Assuming the LBA+num_blocks is not out-of-range, this function will return
4538 * CONDITION MET if the specified blocks will/have fitted in the cache, and
4539 * a GOOD status otherwise. Model a disk with a big cache and yield
4540 * CONDITION MET. Actually tries to bring range in main memory into the
4541 * cache associated with the CPU(s).
4542 */
4543static int resp_pre_fetch(struct scsi_cmnd *scp,
4544			  struct sdebug_dev_info *devip)
4545{
4546	int res = 0;
4547	u64 lba;
4548	u64 block, rest = 0;
4549	u32 nblks;
4550	u8 *cmd = scp->cmnd;
4551	struct sdeb_store_info *sip = devip2sip(devip, true);
 
4552	u8 *fsp = sip->storep;
4553
4554	if (cmd[0] == PRE_FETCH) {	/* 10 byte cdb */
4555		lba = get_unaligned_be32(cmd + 2);
4556		nblks = get_unaligned_be16(cmd + 7);
4557	} else {			/* PRE-FETCH(16) */
4558		lba = get_unaligned_be64(cmd + 2);
4559		nblks = get_unaligned_be32(cmd + 10);
4560	}
4561	if (lba + nblks > sdebug_capacity) {
4562		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4563		return check_condition_result;
4564	}
4565	if (!fsp)
4566		goto fini;
4567	/* PRE-FETCH spec says nothing about LBP or PI so skip them */
4568	block = do_div(lba, sdebug_store_sectors);
4569	if (block + nblks > sdebug_store_sectors)
4570		rest = block + nblks - sdebug_store_sectors;
4571
4572	/* Try to bring the PRE-FETCH range into CPU's cache */
4573	sdeb_read_lock(sip);
4574	prefetch_range(fsp + (sdebug_sector_size * block),
4575		       (nblks - rest) * sdebug_sector_size);
4576	if (rest)
4577		prefetch_range(fsp, rest * sdebug_sector_size);
4578	sdeb_read_unlock(sip);
4579fini:
4580	if (cmd[1] & 0x2)
4581		res = SDEG_RES_IMMED_MASK;
4582	return res | condition_met_result;
4583}
4584
4585#define RL_BUCKET_ELEMS 8
4586
4587/* Even though each pseudo target has a REPORT LUNS "well known logical unit"
4588 * (W-LUN), the normal Linux scanning logic does not associate it with a
4589 * device (e.g. /dev/sg7). The following magic will make that association:
4590 *   "cd /sys/class/scsi_host/host<n> ; echo '- - 49409' > scan"
4591 * where <n> is a host number. If there are multiple targets in a host then
4592 * the above will associate a W-LUN to each target. To only get a W-LUN
4593 * for target 2, then use "echo '- 2 49409' > scan" .
4594 */
4595static int resp_report_luns(struct scsi_cmnd *scp,
4596			    struct sdebug_dev_info *devip)
4597{
4598	unsigned char *cmd = scp->cmnd;
4599	unsigned int alloc_len;
4600	unsigned char select_report;
4601	u64 lun;
4602	struct scsi_lun *lun_p;
4603	u8 arr[RL_BUCKET_ELEMS * sizeof(struct scsi_lun)];
4604	unsigned int lun_cnt;	/* normal LUN count (max: 256) */
4605	unsigned int wlun_cnt;	/* report luns W-LUN count */
4606	unsigned int tlun_cnt;	/* total LUN count */
4607	unsigned int rlen;	/* response length (in bytes) */
4608	int k, j, n, res;
4609	unsigned int off_rsp = 0;
4610	const int sz_lun = sizeof(struct scsi_lun);
4611
4612	clear_luns_changed_on_target(devip);
4613
4614	select_report = cmd[2];
4615	alloc_len = get_unaligned_be32(cmd + 6);
4616
4617	if (alloc_len < 4) {
4618		pr_err("alloc len too small %d\n", alloc_len);
4619		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
4620		return check_condition_result;
4621	}
4622
4623	switch (select_report) {
4624	case 0:		/* all LUNs apart from W-LUNs */
4625		lun_cnt = sdebug_max_luns;
4626		wlun_cnt = 0;
4627		break;
4628	case 1:		/* only W-LUNs */
4629		lun_cnt = 0;
4630		wlun_cnt = 1;
4631		break;
4632	case 2:		/* all LUNs */
4633		lun_cnt = sdebug_max_luns;
4634		wlun_cnt = 1;
4635		break;
4636	case 0x10:	/* only administrative LUs */
4637	case 0x11:	/* see SPC-5 */
4638	case 0x12:	/* only subsiduary LUs owned by referenced LU */
4639	default:
4640		pr_debug("select report invalid %d\n", select_report);
4641		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, -1);
4642		return check_condition_result;
4643	}
4644
4645	if (sdebug_no_lun_0 && (lun_cnt > 0))
4646		--lun_cnt;
4647
4648	tlun_cnt = lun_cnt + wlun_cnt;
4649	rlen = tlun_cnt * sz_lun;	/* excluding 8 byte header */
4650	scsi_set_resid(scp, scsi_bufflen(scp));
4651	pr_debug("select_report %d luns = %d wluns = %d no_lun0 %d\n",
4652		 select_report, lun_cnt, wlun_cnt, sdebug_no_lun_0);
4653
4654	/* loops rely on sizeof response header same as sizeof lun (both 8) */
4655	lun = sdebug_no_lun_0 ? 1 : 0;
4656	for (k = 0, j = 0, res = 0; true; ++k, j = 0) {
4657		memset(arr, 0, sizeof(arr));
4658		lun_p = (struct scsi_lun *)&arr[0];
4659		if (k == 0) {
4660			put_unaligned_be32(rlen, &arr[0]);
4661			++lun_p;
4662			j = 1;
4663		}
4664		for ( ; j < RL_BUCKET_ELEMS; ++j, ++lun_p) {
4665			if ((k * RL_BUCKET_ELEMS) + j > lun_cnt)
4666				break;
4667			int_to_scsilun(lun++, lun_p);
4668			if (lun > 1 && sdebug_lun_am == SAM_LUN_AM_FLAT)
4669				lun_p->scsi_lun[0] |= 0x40;
4670		}
4671		if (j < RL_BUCKET_ELEMS)
4672			break;
4673		n = j * sz_lun;
4674		res = p_fill_from_dev_buffer(scp, arr, n, off_rsp);
4675		if (res)
4676			return res;
4677		off_rsp += n;
4678	}
4679	if (wlun_cnt) {
4680		int_to_scsilun(SCSI_W_LUN_REPORT_LUNS, lun_p);
4681		++j;
4682	}
4683	if (j > 0)
4684		res = p_fill_from_dev_buffer(scp, arr, j * sz_lun, off_rsp);
4685	return res;
4686}
4687
4688static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
4689{
4690	bool is_bytchk3 = false;
4691	u8 bytchk;
4692	int ret, j;
4693	u32 vnum, a_num, off;
4694	const u32 lb_size = sdebug_sector_size;
4695	u64 lba;
4696	u8 *arr;
4697	u8 *cmd = scp->cmnd;
4698	struct sdeb_store_info *sip = devip2sip(devip, true);
 
4699
4700	bytchk = (cmd[1] >> 1) & 0x3;
4701	if (bytchk == 0) {
4702		return 0;	/* always claim internal verify okay */
4703	} else if (bytchk == 2) {
4704		mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 2);
4705		return check_condition_result;
4706	} else if (bytchk == 3) {
4707		is_bytchk3 = true;	/* 1 block sent, compared repeatedly */
4708	}
4709	switch (cmd[0]) {
4710	case VERIFY_16:
4711		lba = get_unaligned_be64(cmd + 2);
4712		vnum = get_unaligned_be32(cmd + 10);
4713		break;
4714	case VERIFY:		/* is VERIFY(10) */
4715		lba = get_unaligned_be32(cmd + 2);
4716		vnum = get_unaligned_be16(cmd + 7);
4717		break;
4718	default:
4719		mk_sense_invalid_opcode(scp);
4720		return check_condition_result;
4721	}
4722	if (vnum == 0)
4723		return 0;	/* not an error */
4724	a_num = is_bytchk3 ? 1 : vnum;
4725	/* Treat following check like one for read (i.e. no write) access */
4726	ret = check_device_access_params(scp, lba, a_num, false);
4727	if (ret)
4728		return ret;
4729
4730	arr = kcalloc(lb_size, vnum, GFP_ATOMIC | __GFP_NOWARN);
4731	if (!arr) {
4732		mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
4733				INSUFF_RES_ASCQ);
4734		return check_condition_result;
4735	}
4736	/* Not changing store, so only need read access */
4737	sdeb_read_lock(sip);
4738
4739	ret = do_dout_fetch(scp, a_num, arr);
4740	if (ret == -1) {
4741		ret = DID_ERROR << 16;
4742		goto cleanup;
4743	} else if (sdebug_verbose && (ret < (a_num * lb_size))) {
4744		sdev_printk(KERN_INFO, scp->device,
4745			    "%s: %s: cdb indicated=%u, IO sent=%d bytes\n",
4746			    my_name, __func__, a_num * lb_size, ret);
4747	}
4748	if (is_bytchk3) {
4749		for (j = 1, off = lb_size; j < vnum; ++j, off += lb_size)
4750			memcpy(arr + off, arr, lb_size);
4751	}
4752	ret = 0;
4753	if (!comp_write_worker(sip, lba, vnum, arr, true)) {
4754		mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
4755		ret = check_condition_result;
4756		goto cleanup;
4757	}
4758cleanup:
4759	sdeb_read_unlock(sip);
4760	kfree(arr);
4761	return ret;
4762}
4763
4764#define RZONES_DESC_HD 64
4765
4766/* Report zones depending on start LBA and reporting options */
4767static int resp_report_zones(struct scsi_cmnd *scp,
4768			     struct sdebug_dev_info *devip)
4769{
4770	unsigned int rep_max_zones, nrz = 0;
4771	int ret = 0;
4772	u32 alloc_len, rep_opts, rep_len;
4773	bool partial;
4774	u64 lba, zs_lba;
4775	u8 *arr = NULL, *desc;
4776	u8 *cmd = scp->cmnd;
4777	struct sdeb_zone_state *zsp = NULL;
4778	struct sdeb_store_info *sip = devip2sip(devip, false);
 
4779
4780	if (!sdebug_dev_is_zoned(devip)) {
4781		mk_sense_invalid_opcode(scp);
4782		return check_condition_result;
4783	}
4784	zs_lba = get_unaligned_be64(cmd + 2);
4785	alloc_len = get_unaligned_be32(cmd + 10);
4786	if (alloc_len == 0)
4787		return 0;	/* not an error */
4788	rep_opts = cmd[14] & 0x3f;
4789	partial = cmd[14] & 0x80;
4790
4791	if (zs_lba >= sdebug_capacity) {
4792		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4793		return check_condition_result;
4794	}
4795
4796	rep_max_zones = (alloc_len - 64) >> ilog2(RZONES_DESC_HD);
 
 
4797
4798	arr = kzalloc(alloc_len, GFP_ATOMIC | __GFP_NOWARN);
4799	if (!arr) {
4800		mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
4801				INSUFF_RES_ASCQ);
4802		return check_condition_result;
4803	}
4804
4805	sdeb_read_lock(sip);
4806
4807	desc = arr + 64;
4808	for (lba = zs_lba; lba < sdebug_capacity;
4809	     lba = zsp->z_start + zsp->z_size) {
4810		if (WARN_ONCE(zbc_zone(devip, lba) == zsp, "lba = %llu\n", lba))
4811			break;
4812		zsp = zbc_zone(devip, lba);
4813		switch (rep_opts) {
4814		case 0x00:
4815			/* All zones */
4816			break;
4817		case 0x01:
4818			/* Empty zones */
4819			if (zsp->z_cond != ZC1_EMPTY)
4820				continue;
4821			break;
4822		case 0x02:
4823			/* Implicit open zones */
4824			if (zsp->z_cond != ZC2_IMPLICIT_OPEN)
4825				continue;
4826			break;
4827		case 0x03:
4828			/* Explicit open zones */
4829			if (zsp->z_cond != ZC3_EXPLICIT_OPEN)
4830				continue;
4831			break;
4832		case 0x04:
4833			/* Closed zones */
4834			if (zsp->z_cond != ZC4_CLOSED)
4835				continue;
4836			break;
4837		case 0x05:
4838			/* Full zones */
4839			if (zsp->z_cond != ZC5_FULL)
4840				continue;
4841			break;
4842		case 0x06:
4843		case 0x07:
4844		case 0x10:
4845			/*
4846			 * Read-only, offline, reset WP recommended are
4847			 * not emulated: no zones to report;
4848			 */
4849			continue;
4850		case 0x11:
4851			/* non-seq-resource set */
4852			if (!zsp->z_non_seq_resource)
4853				continue;
4854			break;
4855		case 0x3e:
4856			/* All zones except gap zones. */
4857			if (zbc_zone_is_gap(zsp))
4858				continue;
4859			break;
4860		case 0x3f:
4861			/* Not write pointer (conventional) zones */
4862			if (zbc_zone_is_seq(zsp))
4863				continue;
4864			break;
4865		default:
4866			mk_sense_buffer(scp, ILLEGAL_REQUEST,
4867					INVALID_FIELD_IN_CDB, 0);
4868			ret = check_condition_result;
4869			goto fini;
4870		}
4871
4872		if (nrz < rep_max_zones) {
4873			/* Fill zone descriptor */
4874			desc[0] = zsp->z_type;
4875			desc[1] = zsp->z_cond << 4;
4876			if (zsp->z_non_seq_resource)
4877				desc[1] |= 1 << 1;
4878			put_unaligned_be64((u64)zsp->z_size, desc + 8);
4879			put_unaligned_be64((u64)zsp->z_start, desc + 16);
4880			put_unaligned_be64((u64)zsp->z_wp, desc + 24);
4881			desc += 64;
4882		}
4883
4884		if (partial && nrz >= rep_max_zones)
4885			break;
4886
4887		nrz++;
4888	}
4889
4890	/* Report header */
4891	/* Zone list length. */
4892	put_unaligned_be32(nrz * RZONES_DESC_HD, arr + 0);
4893	/* Maximum LBA */
4894	put_unaligned_be64(sdebug_capacity - 1, arr + 8);
4895	/* Zone starting LBA granularity. */
4896	if (devip->zcap < devip->zsize)
4897		put_unaligned_be64(devip->zsize, arr + 16);
4898
4899	rep_len = (unsigned long)desc - (unsigned long)arr;
4900	ret = fill_from_dev_buffer(scp, arr, min_t(u32, alloc_len, rep_len));
4901
4902fini:
4903	sdeb_read_unlock(sip);
4904	kfree(arr);
4905	return ret;
4906}
4907
4908/* Logic transplanted from tcmu-runner, file_zbc.c */
4909static void zbc_open_all(struct sdebug_dev_info *devip)
4910{
4911	struct sdeb_zone_state *zsp = &devip->zstate[0];
4912	unsigned int i;
4913
4914	for (i = 0; i < devip->nr_zones; i++, zsp++) {
4915		if (zsp->z_cond == ZC4_CLOSED)
4916			zbc_open_zone(devip, &devip->zstate[i], true);
4917	}
4918}
4919
4920static int resp_open_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
4921{
4922	int res = 0;
4923	u64 z_id;
4924	enum sdebug_z_cond zc;
4925	u8 *cmd = scp->cmnd;
4926	struct sdeb_zone_state *zsp;
4927	bool all = cmd[14] & 0x01;
4928	struct sdeb_store_info *sip = devip2sip(devip, false);
 
4929
4930	if (!sdebug_dev_is_zoned(devip)) {
4931		mk_sense_invalid_opcode(scp);
4932		return check_condition_result;
4933	}
4934
4935	sdeb_write_lock(sip);
4936
4937	if (all) {
4938		/* Check if all closed zones can be open */
4939		if (devip->max_open &&
4940		    devip->nr_exp_open + devip->nr_closed > devip->max_open) {
4941			mk_sense_buffer(scp, DATA_PROTECT, INSUFF_RES_ASC,
4942					INSUFF_ZONE_ASCQ);
4943			res = check_condition_result;
4944			goto fini;
4945		}
4946		/* Open all closed zones */
4947		zbc_open_all(devip);
4948		goto fini;
4949	}
4950
4951	/* Open the specified zone */
4952	z_id = get_unaligned_be64(cmd + 2);
4953	if (z_id >= sdebug_capacity) {
4954		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
4955		res = check_condition_result;
4956		goto fini;
4957	}
4958
4959	zsp = zbc_zone(devip, z_id);
4960	if (z_id != zsp->z_start) {
4961		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4962		res = check_condition_result;
4963		goto fini;
4964	}
4965	if (zbc_zone_is_conv(zsp)) {
4966		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
4967		res = check_condition_result;
4968		goto fini;
4969	}
4970
4971	zc = zsp->z_cond;
4972	if (zc == ZC3_EXPLICIT_OPEN || zc == ZC5_FULL)
4973		goto fini;
4974
4975	if (devip->max_open && devip->nr_exp_open >= devip->max_open) {
4976		mk_sense_buffer(scp, DATA_PROTECT, INSUFF_RES_ASC,
4977				INSUFF_ZONE_ASCQ);
4978		res = check_condition_result;
4979		goto fini;
4980	}
4981
4982	zbc_open_zone(devip, zsp, true);
4983fini:
4984	sdeb_write_unlock(sip);
4985	return res;
4986}
4987
4988static void zbc_close_all(struct sdebug_dev_info *devip)
4989{
4990	unsigned int i;
4991
4992	for (i = 0; i < devip->nr_zones; i++)
4993		zbc_close_zone(devip, &devip->zstate[i]);
4994}
4995
4996static int resp_close_zone(struct scsi_cmnd *scp,
4997			   struct sdebug_dev_info *devip)
4998{
4999	int res = 0;
5000	u64 z_id;
5001	u8 *cmd = scp->cmnd;
5002	struct sdeb_zone_state *zsp;
5003	bool all = cmd[14] & 0x01;
5004	struct sdeb_store_info *sip = devip2sip(devip, false);
 
5005
5006	if (!sdebug_dev_is_zoned(devip)) {
5007		mk_sense_invalid_opcode(scp);
5008		return check_condition_result;
5009	}
5010
5011	sdeb_write_lock(sip);
5012
5013	if (all) {
5014		zbc_close_all(devip);
5015		goto fini;
5016	}
5017
5018	/* Close specified zone */
5019	z_id = get_unaligned_be64(cmd + 2);
5020	if (z_id >= sdebug_capacity) {
5021		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
5022		res = check_condition_result;
5023		goto fini;
5024	}
5025
5026	zsp = zbc_zone(devip, z_id);
5027	if (z_id != zsp->z_start) {
5028		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
5029		res = check_condition_result;
5030		goto fini;
5031	}
5032	if (zbc_zone_is_conv(zsp)) {
5033		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
5034		res = check_condition_result;
5035		goto fini;
5036	}
5037
5038	zbc_close_zone(devip, zsp);
5039fini:
5040	sdeb_write_unlock(sip);
5041	return res;
5042}
5043
5044static void zbc_finish_zone(struct sdebug_dev_info *devip,
5045			    struct sdeb_zone_state *zsp, bool empty)
5046{
5047	enum sdebug_z_cond zc = zsp->z_cond;
5048
5049	if (zc == ZC4_CLOSED || zc == ZC2_IMPLICIT_OPEN ||
5050	    zc == ZC3_EXPLICIT_OPEN || (empty && zc == ZC1_EMPTY)) {
5051		if (zc == ZC2_IMPLICIT_OPEN || zc == ZC3_EXPLICIT_OPEN)
5052			zbc_close_zone(devip, zsp);
5053		if (zsp->z_cond == ZC4_CLOSED)
5054			devip->nr_closed--;
5055		zsp->z_wp = zsp->z_start + zsp->z_size;
5056		zsp->z_cond = ZC5_FULL;
5057	}
5058}
5059
5060static void zbc_finish_all(struct sdebug_dev_info *devip)
5061{
5062	unsigned int i;
5063
5064	for (i = 0; i < devip->nr_zones; i++)
5065		zbc_finish_zone(devip, &devip->zstate[i], false);
5066}
5067
5068static int resp_finish_zone(struct scsi_cmnd *scp,
5069			    struct sdebug_dev_info *devip)
5070{
5071	struct sdeb_zone_state *zsp;
5072	int res = 0;
5073	u64 z_id;
5074	u8 *cmd = scp->cmnd;
5075	bool all = cmd[14] & 0x01;
5076	struct sdeb_store_info *sip = devip2sip(devip, false);
 
5077
5078	if (!sdebug_dev_is_zoned(devip)) {
5079		mk_sense_invalid_opcode(scp);
5080		return check_condition_result;
5081	}
5082
5083	sdeb_write_lock(sip);
5084
5085	if (all) {
5086		zbc_finish_all(devip);
5087		goto fini;
5088	}
5089
5090	/* Finish the specified zone */
5091	z_id = get_unaligned_be64(cmd + 2);
5092	if (z_id >= sdebug_capacity) {
5093		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
5094		res = check_condition_result;
5095		goto fini;
5096	}
5097
5098	zsp = zbc_zone(devip, z_id);
5099	if (z_id != zsp->z_start) {
5100		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
5101		res = check_condition_result;
5102		goto fini;
5103	}
5104	if (zbc_zone_is_conv(zsp)) {
5105		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
5106		res = check_condition_result;
5107		goto fini;
5108	}
5109
5110	zbc_finish_zone(devip, zsp, true);
5111fini:
5112	sdeb_write_unlock(sip);
5113	return res;
5114}
5115
5116static void zbc_rwp_zone(struct sdebug_dev_info *devip,
5117			 struct sdeb_zone_state *zsp)
5118{
5119	enum sdebug_z_cond zc;
5120	struct sdeb_store_info *sip = devip2sip(devip, false);
5121
5122	if (!zbc_zone_is_seq(zsp))
5123		return;
5124
5125	zc = zsp->z_cond;
5126	if (zc == ZC2_IMPLICIT_OPEN || zc == ZC3_EXPLICIT_OPEN)
5127		zbc_close_zone(devip, zsp);
5128
5129	if (zsp->z_cond == ZC4_CLOSED)
5130		devip->nr_closed--;
5131
5132	if (zsp->z_wp > zsp->z_start)
5133		memset(sip->storep + zsp->z_start * sdebug_sector_size, 0,
5134		       (zsp->z_wp - zsp->z_start) * sdebug_sector_size);
5135
5136	zsp->z_non_seq_resource = false;
5137	zsp->z_wp = zsp->z_start;
5138	zsp->z_cond = ZC1_EMPTY;
5139}
5140
5141static void zbc_rwp_all(struct sdebug_dev_info *devip)
5142{
5143	unsigned int i;
5144
5145	for (i = 0; i < devip->nr_zones; i++)
5146		zbc_rwp_zone(devip, &devip->zstate[i]);
5147}
5148
5149static int resp_rwp_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
5150{
5151	struct sdeb_zone_state *zsp;
5152	int res = 0;
5153	u64 z_id;
5154	u8 *cmd = scp->cmnd;
5155	bool all = cmd[14] & 0x01;
5156	struct sdeb_store_info *sip = devip2sip(devip, false);
 
5157
5158	if (!sdebug_dev_is_zoned(devip)) {
5159		mk_sense_invalid_opcode(scp);
5160		return check_condition_result;
5161	}
5162
5163	sdeb_write_lock(sip);
5164
5165	if (all) {
5166		zbc_rwp_all(devip);
5167		goto fini;
5168	}
5169
5170	z_id = get_unaligned_be64(cmd + 2);
5171	if (z_id >= sdebug_capacity) {
5172		mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
5173		res = check_condition_result;
5174		goto fini;
5175	}
5176
5177	zsp = zbc_zone(devip, z_id);
5178	if (z_id != zsp->z_start) {
5179		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
5180		res = check_condition_result;
5181		goto fini;
5182	}
5183	if (zbc_zone_is_conv(zsp)) {
5184		mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
5185		res = check_condition_result;
5186		goto fini;
5187	}
5188
5189	zbc_rwp_zone(devip, zsp);
5190fini:
5191	sdeb_write_unlock(sip);
5192	return res;
5193}
5194
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5195static u32 get_tag(struct scsi_cmnd *cmnd)
5196{
5197	return blk_mq_unique_tag(scsi_cmd_to_rq(cmnd));
5198}
5199
5200/* Queued (deferred) command completions converge here. */
5201static void sdebug_q_cmd_complete(struct sdebug_defer *sd_dp)
5202{
5203	struct sdebug_queued_cmd *sqcp = container_of(sd_dp, struct sdebug_queued_cmd, sd_dp);
5204	unsigned long flags;
5205	struct scsi_cmnd *scp = sqcp->scmd;
5206	struct sdebug_scsi_cmd *sdsc;
5207	bool aborted;
 
 
 
5208
 
 
 
 
 
5209	if (sdebug_statistics) {
5210		atomic_inc(&sdebug_completions);
5211		if (raw_smp_processor_id() != sd_dp->issuing_cpu)
5212			atomic_inc(&sdebug_miss_cpus);
5213	}
5214
5215	if (!scp) {
5216		pr_err("scmd=NULL\n");
5217		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5218	}
5219
5220	sdsc = scsi_cmd_priv(scp);
5221	spin_lock_irqsave(&sdsc->lock, flags);
5222	aborted = sd_dp->aborted;
5223	if (unlikely(aborted))
5224		sd_dp->aborted = false;
5225	ASSIGN_QUEUED_CMD(scp, NULL);
5226
5227	spin_unlock_irqrestore(&sdsc->lock, flags);
5228
5229	if (aborted) {
5230		pr_info("bypassing scsi_done() due to aborted cmd, kicking-off EH\n");
5231		blk_abort_request(scsi_cmd_to_rq(scp));
5232		goto out;
 
 
 
 
 
 
 
 
 
 
 
5233	}
5234
5235	scsi_done(scp); /* callback to mid level */
5236out:
5237	sdebug_free_queued_cmd(sqcp);
5238}
5239
5240/* When high resolution timer goes off this function is called. */
5241static enum hrtimer_restart sdebug_q_cmd_hrt_complete(struct hrtimer *timer)
5242{
5243	struct sdebug_defer *sd_dp = container_of(timer, struct sdebug_defer,
5244						  hrt);
5245	sdebug_q_cmd_complete(sd_dp);
5246	return HRTIMER_NORESTART;
5247}
5248
5249/* When work queue schedules work, it calls this function. */
5250static void sdebug_q_cmd_wq_complete(struct work_struct *work)
5251{
5252	struct sdebug_defer *sd_dp = container_of(work, struct sdebug_defer,
5253						  ew.work);
5254	sdebug_q_cmd_complete(sd_dp);
5255}
5256
5257static bool got_shared_uuid;
5258static uuid_t shared_uuid;
5259
5260static int sdebug_device_create_zones(struct sdebug_dev_info *devip)
5261{
5262	struct sdeb_zone_state *zsp;
5263	sector_t capacity = get_sdebug_capacity();
5264	sector_t conv_capacity;
5265	sector_t zstart = 0;
5266	unsigned int i;
5267
5268	/*
5269	 * Set the zone size: if sdeb_zbc_zone_size_mb is not set, figure out
5270	 * a zone size allowing for at least 4 zones on the device. Otherwise,
5271	 * use the specified zone size checking that at least 2 zones can be
5272	 * created for the device.
5273	 */
5274	if (!sdeb_zbc_zone_size_mb) {
5275		devip->zsize = (DEF_ZBC_ZONE_SIZE_MB * SZ_1M)
5276			>> ilog2(sdebug_sector_size);
5277		while (capacity < devip->zsize << 2 && devip->zsize >= 2)
5278			devip->zsize >>= 1;
5279		if (devip->zsize < 2) {
5280			pr_err("Device capacity too small\n");
5281			return -EINVAL;
5282		}
5283	} else {
5284		if (!is_power_of_2(sdeb_zbc_zone_size_mb)) {
5285			pr_err("Zone size is not a power of 2\n");
5286			return -EINVAL;
5287		}
5288		devip->zsize = (sdeb_zbc_zone_size_mb * SZ_1M)
5289			>> ilog2(sdebug_sector_size);
5290		if (devip->zsize >= capacity) {
5291			pr_err("Zone size too large for device capacity\n");
5292			return -EINVAL;
5293		}
5294	}
5295
5296	devip->zsize_shift = ilog2(devip->zsize);
5297	devip->nr_zones = (capacity + devip->zsize - 1) >> devip->zsize_shift;
5298
5299	if (sdeb_zbc_zone_cap_mb == 0) {
5300		devip->zcap = devip->zsize;
5301	} else {
5302		devip->zcap = (sdeb_zbc_zone_cap_mb * SZ_1M) >>
5303			      ilog2(sdebug_sector_size);
5304		if (devip->zcap > devip->zsize) {
5305			pr_err("Zone capacity too large\n");
5306			return -EINVAL;
5307		}
5308	}
5309
5310	conv_capacity = (sector_t)sdeb_zbc_nr_conv << devip->zsize_shift;
5311	if (conv_capacity >= capacity) {
5312		pr_err("Number of conventional zones too large\n");
5313		return -EINVAL;
5314	}
5315	devip->nr_conv_zones = sdeb_zbc_nr_conv;
5316	devip->nr_seq_zones = ALIGN(capacity - conv_capacity, devip->zsize) >>
5317			      devip->zsize_shift;
5318	devip->nr_zones = devip->nr_conv_zones + devip->nr_seq_zones;
5319
5320	/* Add gap zones if zone capacity is smaller than the zone size */
5321	if (devip->zcap < devip->zsize)
5322		devip->nr_zones += devip->nr_seq_zones;
5323
5324	if (devip->zoned) {
5325		/* zbc_max_open_zones can be 0, meaning "not reported" */
5326		if (sdeb_zbc_max_open >= devip->nr_zones - 1)
5327			devip->max_open = (devip->nr_zones - 1) / 2;
5328		else
5329			devip->max_open = sdeb_zbc_max_open;
5330	}
5331
5332	devip->zstate = kcalloc(devip->nr_zones,
5333				sizeof(struct sdeb_zone_state), GFP_KERNEL);
5334	if (!devip->zstate)
5335		return -ENOMEM;
5336
5337	for (i = 0; i < devip->nr_zones; i++) {
5338		zsp = &devip->zstate[i];
5339
5340		zsp->z_start = zstart;
5341
5342		if (i < devip->nr_conv_zones) {
5343			zsp->z_type = ZBC_ZTYPE_CNV;
5344			zsp->z_cond = ZBC_NOT_WRITE_POINTER;
5345			zsp->z_wp = (sector_t)-1;
5346			zsp->z_size =
5347				min_t(u64, devip->zsize, capacity - zstart);
5348		} else if ((zstart & (devip->zsize - 1)) == 0) {
5349			if (devip->zoned)
5350				zsp->z_type = ZBC_ZTYPE_SWR;
5351			else
5352				zsp->z_type = ZBC_ZTYPE_SWP;
5353			zsp->z_cond = ZC1_EMPTY;
5354			zsp->z_wp = zsp->z_start;
5355			zsp->z_size =
5356				min_t(u64, devip->zcap, capacity - zstart);
5357		} else {
5358			zsp->z_type = ZBC_ZTYPE_GAP;
5359			zsp->z_cond = ZBC_NOT_WRITE_POINTER;
5360			zsp->z_wp = (sector_t)-1;
5361			zsp->z_size = min_t(u64, devip->zsize - devip->zcap,
5362					    capacity - zstart);
5363		}
5364
5365		WARN_ON_ONCE((int)zsp->z_size <= 0);
 
 
 
 
5366		zstart += zsp->z_size;
5367	}
5368
5369	return 0;
5370}
5371
5372static struct sdebug_dev_info *sdebug_device_create(
5373			struct sdebug_host_info *sdbg_host, gfp_t flags)
5374{
5375	struct sdebug_dev_info *devip;
5376
5377	devip = kzalloc(sizeof(*devip), flags);
5378	if (devip) {
5379		if (sdebug_uuid_ctl == 1)
5380			uuid_gen(&devip->lu_name);
5381		else if (sdebug_uuid_ctl == 2) {
5382			if (got_shared_uuid)
5383				devip->lu_name = shared_uuid;
5384			else {
5385				uuid_gen(&shared_uuid);
5386				got_shared_uuid = true;
5387				devip->lu_name = shared_uuid;
5388			}
5389		}
5390		devip->sdbg_host = sdbg_host;
5391		if (sdeb_zbc_in_use) {
5392			devip->zoned = sdeb_zbc_model == BLK_ZONED_HM;
5393			if (sdebug_device_create_zones(devip)) {
5394				kfree(devip);
5395				return NULL;
5396			}
5397		} else {
5398			devip->zoned = false;
5399		}
 
5400		devip->create_ts = ktime_get_boottime();
5401		atomic_set(&devip->stopped, (sdeb_tur_ms_to_ready > 0 ? 2 : 0));
5402		spin_lock_init(&devip->list_lock);
5403		INIT_LIST_HEAD(&devip->inject_err_list);
5404		list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
5405	}
5406	return devip;
5407}
5408
5409static struct sdebug_dev_info *find_build_dev_info(struct scsi_device *sdev)
5410{
5411	struct sdebug_host_info *sdbg_host;
5412	struct sdebug_dev_info *open_devip = NULL;
5413	struct sdebug_dev_info *devip;
5414
5415	sdbg_host = shost_to_sdebug_host(sdev->host);
5416
 
 
 
5417	list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
5418		if ((devip->used) && (devip->channel == sdev->channel) &&
5419		    (devip->target == sdev->id) &&
5420		    (devip->lun == sdev->lun))
5421			return devip;
5422		else {
5423			if ((!devip->used) && (!open_devip))
5424				open_devip = devip;
5425		}
5426	}
5427	if (!open_devip) { /* try and make a new one */
5428		open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC);
5429		if (!open_devip) {
5430			pr_err("out of memory at line %d\n", __LINE__);
5431			return NULL;
5432		}
5433	}
5434
5435	open_devip->channel = sdev->channel;
5436	open_devip->target = sdev->id;
5437	open_devip->lun = sdev->lun;
5438	open_devip->sdbg_host = sdbg_host;
5439	set_bit(SDEBUG_UA_POOCCUR, open_devip->uas_bm);
 
5440	open_devip->used = true;
5441	return open_devip;
5442}
5443
5444static int scsi_debug_slave_alloc(struct scsi_device *sdp)
5445{
5446	if (sdebug_verbose)
5447		pr_info("slave_alloc <%u %u %u %llu>\n",
5448		       sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
5449
5450	return 0;
5451}
5452
5453static int scsi_debug_slave_configure(struct scsi_device *sdp)
5454{
5455	struct sdebug_dev_info *devip =
5456			(struct sdebug_dev_info *)sdp->hostdata;
5457	struct dentry *dentry;
5458
5459	if (sdebug_verbose)
5460		pr_info("slave_configure <%u %u %u %llu>\n",
5461		       sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
5462	if (sdp->host->max_cmd_len != SDEBUG_MAX_CMD_LEN)
5463		sdp->host->max_cmd_len = SDEBUG_MAX_CMD_LEN;
5464	if (devip == NULL) {
5465		devip = find_build_dev_info(sdp);
5466		if (devip == NULL)
5467			return 1;  /* no resources, will be marked offline */
5468	}
5469	sdp->hostdata = devip;
5470	if (sdebug_no_uld)
5471		sdp->no_uld_attach = 1;
5472	config_cdb_len(sdp);
5473
5474	if (sdebug_allow_restart)
5475		sdp->allow_restart = 1;
5476
5477	devip->debugfs_entry = debugfs_create_dir(dev_name(&sdp->sdev_dev),
5478				sdebug_debugfs_root);
5479	if (IS_ERR_OR_NULL(devip->debugfs_entry))
5480		pr_info("%s: failed to create debugfs directory for device %s\n",
5481			__func__, dev_name(&sdp->sdev_gendev));
5482
5483	dentry = debugfs_create_file("error", 0600, devip->debugfs_entry, sdp,
5484				&sdebug_error_fops);
5485	if (IS_ERR_OR_NULL(dentry))
5486		pr_info("%s: failed to create error file for device %s\n",
5487			__func__, dev_name(&sdp->sdev_gendev));
5488
5489	return 0;
5490}
5491
5492static void scsi_debug_slave_destroy(struct scsi_device *sdp)
5493{
5494	struct sdebug_dev_info *devip =
5495		(struct sdebug_dev_info *)sdp->hostdata;
5496	struct sdebug_err_inject *err;
5497
5498	if (sdebug_verbose)
5499		pr_info("slave_destroy <%u %u %u %llu>\n",
5500		       sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
5501
5502	if (!devip)
5503		return;
5504
5505	spin_lock(&devip->list_lock);
5506	list_for_each_entry_rcu(err, &devip->inject_err_list, list) {
5507		list_del_rcu(&err->list);
5508		call_rcu(&err->rcu, sdebug_err_free);
5509	}
5510	spin_unlock(&devip->list_lock);
5511
5512	debugfs_remove(devip->debugfs_entry);
5513
5514	/* make this slot available for re-use */
5515	devip->used = false;
5516	sdp->hostdata = NULL;
5517}
5518
5519/* Returns true if we require the queued memory to be freed by the caller. */
5520static bool stop_qc_helper(struct sdebug_defer *sd_dp,
5521			   enum sdeb_defer_type defer_t)
5522{
5523	if (defer_t == SDEB_DEFER_HRT) {
5524		int res = hrtimer_try_to_cancel(&sd_dp->hrt);
5525
5526		switch (res) {
5527		case 0: /* Not active, it must have already run */
5528		case -1: /* -1 It's executing the CB */
5529			return false;
5530		case 1: /* Was active, we've now cancelled */
5531		default:
5532			return true;
5533		}
5534	} else if (defer_t == SDEB_DEFER_WQ) {
5535		/* Cancel if pending */
5536		if (cancel_work_sync(&sd_dp->ew.work))
5537			return true;
5538		/* Was not pending, so it must have run */
5539		return false;
5540	} else if (defer_t == SDEB_DEFER_POLL) {
5541		return true;
5542	}
5543
5544	return false;
5545}
5546
5547
5548static bool scsi_debug_stop_cmnd(struct scsi_cmnd *cmnd)
 
5549{
 
 
5550	enum sdeb_defer_type l_defer_t;
 
 
 
5551	struct sdebug_defer *sd_dp;
5552	struct sdebug_scsi_cmd *sdsc = scsi_cmd_priv(cmnd);
5553	struct sdebug_queued_cmd *sqcp = TO_QUEUED_CMD(cmnd);
5554
5555	lockdep_assert_held(&sdsc->lock);
5556
5557	if (!sqcp)
5558		return false;
5559	sd_dp = &sqcp->sd_dp;
5560	l_defer_t = READ_ONCE(sd_dp->defer_t);
5561	ASSIGN_QUEUED_CMD(cmnd, NULL);
5562
5563	if (stop_qc_helper(sd_dp, l_defer_t))
5564		sdebug_free_queued_cmd(sqcp);
5565
5566	return true;
5567}
5568
5569/*
5570 * Called from scsi_debug_abort() only, which is for timed-out cmd.
5571 */
5572static bool scsi_debug_abort_cmnd(struct scsi_cmnd *cmnd)
5573{
5574	struct sdebug_scsi_cmd *sdsc = scsi_cmd_priv(cmnd);
5575	unsigned long flags;
5576	bool res;
5577
5578	spin_lock_irqsave(&sdsc->lock, flags);
5579	res = scsi_debug_stop_cmnd(cmnd);
5580	spin_unlock_irqrestore(&sdsc->lock, flags);
5581
5582	return res;
5583}
5584
5585/*
5586 * All we can do is set the cmnd as internally aborted and wait for it to
5587 * finish. We cannot call scsi_done() as normal completion path may do that.
5588 */
5589static bool sdebug_stop_cmnd(struct request *rq, void *data)
5590{
5591	scsi_debug_abort_cmnd(blk_mq_rq_to_pdu(rq));
5592
5593	return true;
5594}
5595
5596/* Deletes (stops) timers or work queues of all queued commands */
5597static void stop_all_queued(void)
5598{
5599	struct sdebug_host_info *sdhp;
 
 
 
 
 
 
5600
5601	mutex_lock(&sdebug_host_list_mutex);
5602	list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
5603		struct Scsi_Host *shost = sdhp->shost;
5604
5605		blk_mq_tagset_busy_iter(&shost->tag_set, sdebug_stop_cmnd, NULL);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5606	}
5607	mutex_unlock(&sdebug_host_list_mutex);
5608}
5609
5610static int sdebug_fail_abort(struct scsi_cmnd *cmnd)
 
5611{
5612	struct scsi_device *sdp = cmnd->device;
5613	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
5614	struct sdebug_err_inject *err;
5615	unsigned char *cmd = cmnd->cmnd;
5616	int ret = 0;
5617
5618	if (devip == NULL)
5619		return 0;
5620
5621	rcu_read_lock();
5622	list_for_each_entry_rcu(err, &devip->inject_err_list, list) {
5623		if (err->type == ERR_ABORT_CMD_FAILED &&
5624		    (err->cmd == cmd[0] || err->cmd == 0xff)) {
5625			ret = !!err->cnt;
5626			if (err->cnt < 0)
5627				err->cnt++;
5628
5629			rcu_read_unlock();
5630			return ret;
5631		}
5632	}
5633	rcu_read_unlock();
5634
5635	return 0;
5636}
5637
5638static int scsi_debug_abort(struct scsi_cmnd *SCpnt)
5639{
5640	bool ok = scsi_debug_abort_cmnd(SCpnt);
5641	u8 *cmd = SCpnt->cmnd;
5642	u8 opcode = cmd[0];
5643
5644	++num_aborts;
5645
5646	if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
5647		sdev_printk(KERN_INFO, SCpnt->device,
5648			    "%s: command%s found\n", __func__,
5649			    ok ? "" : " not");
5650
5651	if (sdebug_fail_abort(SCpnt)) {
5652		scmd_printk(KERN_INFO, SCpnt, "fail abort command 0x%x\n",
5653			    opcode);
5654		return FAILED;
5655	}
5656
5657	return SUCCESS;
5658}
5659
5660static bool scsi_debug_stop_all_queued_iter(struct request *rq, void *data)
5661{
5662	struct scsi_device *sdp = data;
5663	struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq);
5664
5665	if (scmd->device == sdp)
5666		scsi_debug_abort_cmnd(scmd);
5667
5668	return true;
5669}
5670
5671/* Deletes (stops) timers or work queues of all queued commands per sdev */
5672static void scsi_debug_stop_all_queued(struct scsi_device *sdp)
5673{
5674	struct Scsi_Host *shost = sdp->host;
5675
5676	blk_mq_tagset_busy_iter(&shost->tag_set,
5677				scsi_debug_stop_all_queued_iter, sdp);
5678}
5679
5680static int sdebug_fail_lun_reset(struct scsi_cmnd *cmnd)
5681{
5682	struct scsi_device *sdp = cmnd->device;
5683	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
5684	struct sdebug_err_inject *err;
5685	unsigned char *cmd = cmnd->cmnd;
5686	int ret = 0;
5687
5688	if (devip == NULL)
5689		return 0;
5690
5691	rcu_read_lock();
5692	list_for_each_entry_rcu(err, &devip->inject_err_list, list) {
5693		if (err->type == ERR_LUN_RESET_FAILED &&
5694		    (err->cmd == cmd[0] || err->cmd == 0xff)) {
5695			ret = !!err->cnt;
5696			if (err->cnt < 0)
5697				err->cnt++;
5698
5699			rcu_read_unlock();
5700			return ret;
5701		}
5702	}
5703	rcu_read_unlock();
5704
5705	return 0;
5706}
5707
5708static int scsi_debug_device_reset(struct scsi_cmnd *SCpnt)
5709{
5710	struct scsi_device *sdp = SCpnt->device;
5711	struct sdebug_dev_info *devip = sdp->hostdata;
5712	u8 *cmd = SCpnt->cmnd;
5713	u8 opcode = cmd[0];
5714
5715	++num_dev_resets;
5716
5717	if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
5718		sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
5719
5720	scsi_debug_stop_all_queued(sdp);
5721	if (devip)
5722		set_bit(SDEBUG_UA_POR, devip->uas_bm);
5723
5724	if (sdebug_fail_lun_reset(SCpnt)) {
5725		scmd_printk(KERN_INFO, SCpnt, "fail lun reset 0x%x\n", opcode);
5726		return FAILED;
5727	}
5728
5729	return SUCCESS;
5730}
5731
5732static int sdebug_fail_target_reset(struct scsi_cmnd *cmnd)
5733{
5734	struct scsi_target *starget = scsi_target(cmnd->device);
5735	struct sdebug_target_info *targetip =
5736		(struct sdebug_target_info *)starget->hostdata;
5737
5738	if (targetip)
5739		return targetip->reset_fail;
5740
5741	return 0;
5742}
5743
5744static int scsi_debug_target_reset(struct scsi_cmnd *SCpnt)
5745{
5746	struct scsi_device *sdp = SCpnt->device;
5747	struct sdebug_host_info *sdbg_host = shost_to_sdebug_host(sdp->host);
5748	struct sdebug_dev_info *devip;
5749	u8 *cmd = SCpnt->cmnd;
5750	u8 opcode = cmd[0];
5751	int k = 0;
5752
5753	++num_target_resets;
 
 
 
 
 
5754	if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
5755		sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
5756
5757	list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
5758		if (devip->target == sdp->id) {
5759			set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
5760			++k;
5761		}
 
 
 
 
 
 
5762	}
5763
5764	if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
5765		sdev_printk(KERN_INFO, sdp,
5766			    "%s: %d device(s) found in target\n", __func__, k);
5767
5768	if (sdebug_fail_target_reset(SCpnt)) {
5769		scmd_printk(KERN_INFO, SCpnt, "fail target reset 0x%x\n",
5770			    opcode);
5771		return FAILED;
5772	}
5773
5774	return SUCCESS;
5775}
5776
5777static int scsi_debug_bus_reset(struct scsi_cmnd *SCpnt)
5778{
5779	struct scsi_device *sdp = SCpnt->device;
5780	struct sdebug_host_info *sdbg_host = shost_to_sdebug_host(sdp->host);
5781	struct sdebug_dev_info *devip;
 
 
5782	int k = 0;
5783
5784	++num_bus_resets;
5785
 
 
5786	if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
5787		sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
5788
5789	list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
5790		set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
5791		++k;
 
 
 
 
 
 
 
5792	}
5793
5794	if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
5795		sdev_printk(KERN_INFO, sdp,
5796			    "%s: %d device(s) found in host\n", __func__, k);
 
5797	return SUCCESS;
5798}
5799
5800static int scsi_debug_host_reset(struct scsi_cmnd *SCpnt)
5801{
5802	struct sdebug_host_info *sdbg_host;
5803	struct sdebug_dev_info *devip;
5804	int k = 0;
5805
5806	++num_host_resets;
5807	if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
5808		sdev_printk(KERN_INFO, SCpnt->device, "%s\n", __func__);
5809	mutex_lock(&sdebug_host_list_mutex);
5810	list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
5811		list_for_each_entry(devip, &sdbg_host->dev_info_list,
5812				    dev_list) {
5813			set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
5814			++k;
5815		}
5816	}
5817	mutex_unlock(&sdebug_host_list_mutex);
5818	stop_all_queued();
5819	if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
5820		sdev_printk(KERN_INFO, SCpnt->device,
5821			    "%s: %d device(s) found\n", __func__, k);
5822	return SUCCESS;
5823}
5824
5825static void sdebug_build_parts(unsigned char *ramp, unsigned long store_size)
5826{
5827	struct msdos_partition *pp;
5828	int starts[SDEBUG_MAX_PARTS + 2], max_part_secs;
5829	int sectors_per_part, num_sectors, k;
5830	int heads_by_sects, start_sec, end_sec;
5831
5832	/* assume partition table already zeroed */
5833	if ((sdebug_num_parts < 1) || (store_size < 1048576))
5834		return;
5835	if (sdebug_num_parts > SDEBUG_MAX_PARTS) {
5836		sdebug_num_parts = SDEBUG_MAX_PARTS;
5837		pr_warn("reducing partitions to %d\n", SDEBUG_MAX_PARTS);
5838	}
5839	num_sectors = (int)get_sdebug_capacity();
5840	sectors_per_part = (num_sectors - sdebug_sectors_per)
5841			   / sdebug_num_parts;
5842	heads_by_sects = sdebug_heads * sdebug_sectors_per;
5843	starts[0] = sdebug_sectors_per;
5844	max_part_secs = sectors_per_part;
5845	for (k = 1; k < sdebug_num_parts; ++k) {
5846		starts[k] = ((k * sectors_per_part) / heads_by_sects)
5847			    * heads_by_sects;
5848		if (starts[k] - starts[k - 1] < max_part_secs)
5849			max_part_secs = starts[k] - starts[k - 1];
5850	}
5851	starts[sdebug_num_parts] = num_sectors;
5852	starts[sdebug_num_parts + 1] = 0;
5853
5854	ramp[510] = 0x55;	/* magic partition markings */
5855	ramp[511] = 0xAA;
5856	pp = (struct msdos_partition *)(ramp + 0x1be);
5857	for (k = 0; starts[k + 1]; ++k, ++pp) {
5858		start_sec = starts[k];
5859		end_sec = starts[k] + max_part_secs - 1;
5860		pp->boot_ind = 0;
5861
5862		pp->cyl = start_sec / heads_by_sects;
5863		pp->head = (start_sec - (pp->cyl * heads_by_sects))
5864			   / sdebug_sectors_per;
5865		pp->sector = (start_sec % sdebug_sectors_per) + 1;
5866
5867		pp->end_cyl = end_sec / heads_by_sects;
5868		pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
5869			       / sdebug_sectors_per;
5870		pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
5871
5872		pp->start_sect = cpu_to_le32(start_sec);
5873		pp->nr_sects = cpu_to_le32(end_sec - start_sec + 1);
5874		pp->sys_ind = 0x83;	/* plain Linux partition */
5875	}
5876}
5877
5878static void block_unblock_all_queues(bool block)
5879{
5880	struct sdebug_host_info *sdhp;
 
5881
5882	lockdep_assert_held(&sdebug_host_list_mutex);
5883
5884	list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
5885		struct Scsi_Host *shost = sdhp->shost;
5886
5887		if (block)
5888			scsi_block_requests(shost);
5889		else
5890			scsi_unblock_requests(shost);
5891	}
5892}
5893
5894/* Adjust (by rounding down) the sdebug_cmnd_count so abs(every_nth)-1
5895 * commands will be processed normally before triggers occur.
5896 */
5897static void tweak_cmnd_count(void)
5898{
5899	int count, modulo;
5900
5901	modulo = abs(sdebug_every_nth);
5902	if (modulo < 2)
5903		return;
5904
5905	mutex_lock(&sdebug_host_list_mutex);
5906	block_unblock_all_queues(true);
5907	count = atomic_read(&sdebug_cmnd_count);
5908	atomic_set(&sdebug_cmnd_count, (count / modulo) * modulo);
5909	block_unblock_all_queues(false);
5910	mutex_unlock(&sdebug_host_list_mutex);
5911}
5912
5913static void clear_queue_stats(void)
5914{
5915	atomic_set(&sdebug_cmnd_count, 0);
5916	atomic_set(&sdebug_completions, 0);
5917	atomic_set(&sdebug_miss_cpus, 0);
5918	atomic_set(&sdebug_a_tsf, 0);
5919}
5920
5921static bool inject_on_this_cmd(void)
5922{
5923	if (sdebug_every_nth == 0)
5924		return false;
5925	return (atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth)) == 0;
5926}
5927
5928#define INCLUSIVE_TIMING_MAX_NS 1000000		/* 1 millisecond */
5929
5930
5931void sdebug_free_queued_cmd(struct sdebug_queued_cmd *sqcp)
5932{
5933	if (sqcp)
5934		kmem_cache_free(queued_cmd_cache, sqcp);
5935}
5936
5937static struct sdebug_queued_cmd *sdebug_alloc_queued_cmd(struct scsi_cmnd *scmd)
5938{
5939	struct sdebug_queued_cmd *sqcp;
5940	struct sdebug_defer *sd_dp;
5941
5942	sqcp = kmem_cache_zalloc(queued_cmd_cache, GFP_ATOMIC);
5943	if (!sqcp)
5944		return NULL;
5945
5946	sd_dp = &sqcp->sd_dp;
5947
5948	hrtimer_init(&sd_dp->hrt, CLOCK_MONOTONIC, HRTIMER_MODE_REL_PINNED);
5949	sd_dp->hrt.function = sdebug_q_cmd_hrt_complete;
5950	INIT_WORK(&sd_dp->ew.work, sdebug_q_cmd_wq_complete);
5951
5952	sqcp->scmd = scmd;
5953
5954	return sqcp;
5955}
5956
5957/* Complete the processing of the thread that queued a SCSI command to this
5958 * driver. It either completes the command by calling cmnd_done() or
5959 * schedules a hr timer or work queue then returns 0. Returns
5960 * SCSI_MLQUEUE_HOST_BUSY if temporarily out of resources.
5961 */
5962static int schedule_resp(struct scsi_cmnd *cmnd, struct sdebug_dev_info *devip,
5963			 int scsi_result,
5964			 int (*pfp)(struct scsi_cmnd *,
5965				    struct sdebug_dev_info *),
5966			 int delta_jiff, int ndelay)
5967{
5968	struct request *rq = scsi_cmd_to_rq(cmnd);
5969	bool polled = rq->cmd_flags & REQ_POLLED;
5970	struct sdebug_scsi_cmd *sdsc = scsi_cmd_priv(cmnd);
5971	unsigned long flags;
5972	u64 ns_from_boot = 0;
 
5973	struct sdebug_queued_cmd *sqcp;
5974	struct scsi_device *sdp;
5975	struct sdebug_defer *sd_dp;
5976
5977	if (unlikely(devip == NULL)) {
5978		if (scsi_result == 0)
5979			scsi_result = DID_NO_CONNECT << 16;
5980		goto respond_in_thread;
5981	}
5982	sdp = cmnd->device;
5983
5984	if (delta_jiff == 0)
5985		goto respond_in_thread;
5986
5987
5988	if (unlikely(sdebug_every_nth && (SDEBUG_OPT_RARE_TSF & sdebug_opts) &&
5989		     (scsi_result == 0))) {
5990		int num_in_q = scsi_device_busy(sdp);
5991		int qdepth = cmnd->device->queue_depth;
5992
5993		if ((num_in_q == qdepth) &&
 
 
 
 
 
 
 
 
 
 
 
5994		    (atomic_inc_return(&sdebug_a_tsf) >=
5995		     abs(sdebug_every_nth))) {
5996			atomic_set(&sdebug_a_tsf, 0);
 
5997			scsi_result = device_qfull_result;
 
 
5998
5999			if (unlikely(SDEBUG_OPT_Q_NOISE & sdebug_opts))
6000				sdev_printk(KERN_INFO, sdp, "%s: num_in_q=%d +1, <inject> status: TASK SET FULL\n",
6001					    __func__, num_in_q);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6002		}
 
 
 
6003	}
6004
6005	sqcp = sdebug_alloc_queued_cmd(cmnd);
6006	if (!sqcp) {
6007		pr_err("%s no alloc\n", __func__);
6008		return SCSI_MLQUEUE_HOST_BUSY;
6009	}
6010	sd_dp = &sqcp->sd_dp;
6011
6012	if (polled)
6013		ns_from_boot = ktime_get_boottime_ns();
6014
6015	/* one of the resp_*() response functions is called here */
6016	cmnd->result = pfp ? pfp(cmnd, devip) : 0;
6017	if (cmnd->result & SDEG_RES_IMMED_MASK) {
6018		cmnd->result &= ~SDEG_RES_IMMED_MASK;
6019		delta_jiff = ndelay = 0;
6020	}
6021	if (cmnd->result == 0 && scsi_result != 0)
6022		cmnd->result = scsi_result;
6023	if (cmnd->result == 0 && unlikely(sdebug_opts & SDEBUG_OPT_TRANSPORT_ERR)) {
6024		if (atomic_read(&sdeb_inject_pending)) {
6025			mk_sense_buffer(cmnd, ABORTED_COMMAND, TRANSPORT_PROBLEM, ACK_NAK_TO);
6026			atomic_set(&sdeb_inject_pending, 0);
6027			cmnd->result = check_condition_result;
6028		}
6029	}
6030
6031	if (unlikely(sdebug_verbose && cmnd->result))
6032		sdev_printk(KERN_INFO, sdp, "%s: non-zero result=0x%x\n",
6033			    __func__, cmnd->result);
6034
6035	if (delta_jiff > 0 || ndelay > 0) {
6036		ktime_t kt;
6037
6038		if (delta_jiff > 0) {
6039			u64 ns = jiffies_to_nsecs(delta_jiff);
6040
6041			if (sdebug_random && ns < U32_MAX) {
6042				ns = get_random_u32_below((u32)ns);
6043			} else if (sdebug_random) {
6044				ns >>= 12;	/* scale to 4 usec precision */
6045				if (ns < U32_MAX)	/* over 4 hours max */
6046					ns = get_random_u32_below((u32)ns);
6047				ns <<= 12;
6048			}
6049			kt = ns_to_ktime(ns);
6050		} else {	/* ndelay has a 4.2 second max */
6051			kt = sdebug_random ? get_random_u32_below((u32)ndelay) :
6052					     (u32)ndelay;
6053			if (ndelay < INCLUSIVE_TIMING_MAX_NS) {
6054				u64 d = ktime_get_boottime_ns() - ns_from_boot;
6055
6056				if (kt <= d) {	/* elapsed duration >= kt */
 
 
 
 
 
 
 
6057					/* call scsi_done() from this thread */
6058					sdebug_free_queued_cmd(sqcp);
6059					scsi_done(cmnd);
6060					return 0;
6061				}
6062				/* otherwise reduce kt by elapsed time */
6063				kt -= d;
6064			}
6065		}
 
 
 
 
 
 
 
 
 
6066		if (sdebug_statistics)
6067			sd_dp->issuing_cpu = raw_smp_processor_id();
6068		if (polled) {
6069			spin_lock_irqsave(&sdsc->lock, flags);
6070			sd_dp->cmpl_ts = ktime_add(ns_to_ktime(ns_from_boot), kt);
6071			ASSIGN_QUEUED_CMD(cmnd, sqcp);
6072			WRITE_ONCE(sd_dp->defer_t, SDEB_DEFER_POLL);
6073			spin_unlock_irqrestore(&sdsc->lock, flags);
6074		} else {
6075			/* schedule the invocation of scsi_done() for a later time */
6076			spin_lock_irqsave(&sdsc->lock, flags);
6077			ASSIGN_QUEUED_CMD(cmnd, sqcp);
6078			WRITE_ONCE(sd_dp->defer_t, SDEB_DEFER_HRT);
6079			hrtimer_start(&sd_dp->hrt, kt, HRTIMER_MODE_REL_PINNED);
6080			/*
6081			 * The completion handler will try to grab sqcp->lock,
6082			 * so there is no chance that the completion handler
6083			 * will call scsi_done() until we release the lock
6084			 * here (so ok to keep referencing sdsc).
6085			 */
6086			spin_unlock_irqrestore(&sdsc->lock, flags);
6087		}
6088	} else {	/* jdelay < 0, use work queue */
 
 
 
 
 
 
6089		if (unlikely((sdebug_opts & SDEBUG_OPT_CMD_ABORT) &&
6090			     atomic_read(&sdeb_inject_pending))) {
6091			sd_dp->aborted = true;
 
6092			atomic_set(&sdeb_inject_pending, 0);
6093			sdev_printk(KERN_INFO, sdp, "abort request tag=%#x\n",
6094				    blk_mq_unique_tag_to_tag(get_tag(cmnd)));
6095		}
6096
6097		if (sdebug_statistics)
6098			sd_dp->issuing_cpu = raw_smp_processor_id();
6099		if (polled) {
6100			spin_lock_irqsave(&sdsc->lock, flags);
6101			ASSIGN_QUEUED_CMD(cmnd, sqcp);
6102			sd_dp->cmpl_ts = ns_to_ktime(ns_from_boot);
6103			WRITE_ONCE(sd_dp->defer_t, SDEB_DEFER_POLL);
6104			spin_unlock_irqrestore(&sdsc->lock, flags);
6105		} else {
6106			spin_lock_irqsave(&sdsc->lock, flags);
6107			ASSIGN_QUEUED_CMD(cmnd, sqcp);
6108			WRITE_ONCE(sd_dp->defer_t, SDEB_DEFER_WQ);
6109			schedule_work(&sd_dp->ew.work);
6110			spin_unlock_irqrestore(&sdsc->lock, flags);
6111		}
6112	}
6113
 
 
6114	return 0;
6115
6116respond_in_thread:	/* call back to mid-layer using invocation thread */
6117	cmnd->result = pfp != NULL ? pfp(cmnd, devip) : 0;
6118	cmnd->result &= ~SDEG_RES_IMMED_MASK;
6119	if (cmnd->result == 0 && scsi_result != 0)
6120		cmnd->result = scsi_result;
6121	scsi_done(cmnd);
6122	return 0;
6123}
6124
6125/* Note: The following macros create attribute files in the
6126   /sys/module/scsi_debug/parameters directory. Unfortunately this
6127   driver is unaware of a change and cannot trigger auxiliary actions
6128   as it can when the corresponding attribute in the
6129   /sys/bus/pseudo/drivers/scsi_debug directory is changed.
6130 */
6131module_param_named(add_host, sdebug_add_host, int, S_IRUGO | S_IWUSR);
6132module_param_named(ato, sdebug_ato, int, S_IRUGO);
6133module_param_named(cdb_len, sdebug_cdb_len, int, 0644);
6134module_param_named(clustering, sdebug_clustering, bool, S_IRUGO | S_IWUSR);
6135module_param_named(delay, sdebug_jdelay, int, S_IRUGO | S_IWUSR);
6136module_param_named(dev_size_mb, sdebug_dev_size_mb, int, S_IRUGO);
6137module_param_named(dif, sdebug_dif, int, S_IRUGO);
6138module_param_named(dix, sdebug_dix, int, S_IRUGO);
6139module_param_named(dsense, sdebug_dsense, int, S_IRUGO | S_IWUSR);
6140module_param_named(every_nth, sdebug_every_nth, int, S_IRUGO | S_IWUSR);
6141module_param_named(fake_rw, sdebug_fake_rw, int, S_IRUGO | S_IWUSR);
6142module_param_named(guard, sdebug_guard, uint, S_IRUGO);
6143module_param_named(host_lock, sdebug_host_lock, bool, S_IRUGO | S_IWUSR);
6144module_param_named(host_max_queue, sdebug_host_max_queue, int, S_IRUGO);
6145module_param_string(inq_product, sdebug_inq_product_id,
6146		    sizeof(sdebug_inq_product_id), S_IRUGO | S_IWUSR);
6147module_param_string(inq_rev, sdebug_inq_product_rev,
6148		    sizeof(sdebug_inq_product_rev), S_IRUGO | S_IWUSR);
6149module_param_string(inq_vendor, sdebug_inq_vendor_id,
6150		    sizeof(sdebug_inq_vendor_id), S_IRUGO | S_IWUSR);
6151module_param_named(lbprz, sdebug_lbprz, int, S_IRUGO);
6152module_param_named(lbpu, sdebug_lbpu, int, S_IRUGO);
6153module_param_named(lbpws, sdebug_lbpws, int, S_IRUGO);
6154module_param_named(lbpws10, sdebug_lbpws10, int, S_IRUGO);
6155module_param_named(lowest_aligned, sdebug_lowest_aligned, int, S_IRUGO);
6156module_param_named(lun_format, sdebug_lun_am_i, int, S_IRUGO | S_IWUSR);
6157module_param_named(max_luns, sdebug_max_luns, int, S_IRUGO | S_IWUSR);
6158module_param_named(max_queue, sdebug_max_queue, int, S_IRUGO | S_IWUSR);
6159module_param_named(medium_error_count, sdebug_medium_error_count, int,
6160		   S_IRUGO | S_IWUSR);
6161module_param_named(medium_error_start, sdebug_medium_error_start, int,
6162		   S_IRUGO | S_IWUSR);
6163module_param_named(ndelay, sdebug_ndelay, int, S_IRUGO | S_IWUSR);
6164module_param_named(no_lun_0, sdebug_no_lun_0, int, S_IRUGO | S_IWUSR);
6165module_param_named(no_rwlock, sdebug_no_rwlock, bool, S_IRUGO | S_IWUSR);
6166module_param_named(no_uld, sdebug_no_uld, int, S_IRUGO);
6167module_param_named(num_parts, sdebug_num_parts, int, S_IRUGO);
6168module_param_named(num_tgts, sdebug_num_tgts, int, S_IRUGO | S_IWUSR);
6169module_param_named(opt_blks, sdebug_opt_blks, int, S_IRUGO);
6170module_param_named(opt_xferlen_exp, sdebug_opt_xferlen_exp, int, S_IRUGO);
6171module_param_named(opts, sdebug_opts, int, S_IRUGO | S_IWUSR);
6172module_param_named(per_host_store, sdebug_per_host_store, bool,
6173		   S_IRUGO | S_IWUSR);
6174module_param_named(physblk_exp, sdebug_physblk_exp, int, S_IRUGO);
6175module_param_named(ptype, sdebug_ptype, int, S_IRUGO | S_IWUSR);
6176module_param_named(random, sdebug_random, bool, S_IRUGO | S_IWUSR);
6177module_param_named(removable, sdebug_removable, bool, S_IRUGO | S_IWUSR);
6178module_param_named(scsi_level, sdebug_scsi_level, int, S_IRUGO);
6179module_param_named(sector_size, sdebug_sector_size, int, S_IRUGO);
6180module_param_named(statistics, sdebug_statistics, bool, S_IRUGO | S_IWUSR);
6181module_param_named(strict, sdebug_strict, bool, S_IRUGO | S_IWUSR);
6182module_param_named(submit_queues, submit_queues, int, S_IRUGO);
6183module_param_named(poll_queues, poll_queues, int, S_IRUGO);
6184module_param_named(tur_ms_to_ready, sdeb_tur_ms_to_ready, int, S_IRUGO);
6185module_param_named(unmap_alignment, sdebug_unmap_alignment, int, S_IRUGO);
6186module_param_named(unmap_granularity, sdebug_unmap_granularity, int, S_IRUGO);
6187module_param_named(unmap_max_blocks, sdebug_unmap_max_blocks, int, S_IRUGO);
6188module_param_named(unmap_max_desc, sdebug_unmap_max_desc, int, S_IRUGO);
6189module_param_named(uuid_ctl, sdebug_uuid_ctl, int, S_IRUGO);
6190module_param_named(virtual_gb, sdebug_virtual_gb, int, S_IRUGO | S_IWUSR);
6191module_param_named(vpd_use_hostno, sdebug_vpd_use_hostno, int,
6192		   S_IRUGO | S_IWUSR);
6193module_param_named(wp, sdebug_wp, bool, S_IRUGO | S_IWUSR);
6194module_param_named(write_same_length, sdebug_write_same_length, int,
6195		   S_IRUGO | S_IWUSR);
6196module_param_named(zbc, sdeb_zbc_model_s, charp, S_IRUGO);
6197module_param_named(zone_cap_mb, sdeb_zbc_zone_cap_mb, int, S_IRUGO);
6198module_param_named(zone_max_open, sdeb_zbc_max_open, int, S_IRUGO);
6199module_param_named(zone_nr_conv, sdeb_zbc_nr_conv, int, S_IRUGO);
6200module_param_named(zone_size_mb, sdeb_zbc_zone_size_mb, int, S_IRUGO);
6201module_param_named(allow_restart, sdebug_allow_restart, bool, S_IRUGO | S_IWUSR);
6202
6203MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
6204MODULE_DESCRIPTION("SCSI debug adapter driver");
6205MODULE_LICENSE("GPL");
6206MODULE_VERSION(SDEBUG_VERSION);
6207
6208MODULE_PARM_DESC(add_host, "add n hosts, in sysfs if negative remove host(s) (def=1)");
6209MODULE_PARM_DESC(ato, "application tag ownership: 0=disk 1=host (def=1)");
6210MODULE_PARM_DESC(cdb_len, "suggest CDB lengths to drivers (def=10)");
6211MODULE_PARM_DESC(clustering, "when set enables larger transfers (def=0)");
6212MODULE_PARM_DESC(delay, "response delay (def=1 jiffy); 0:imm, -1,-2:tiny");
6213MODULE_PARM_DESC(dev_size_mb, "size in MiB of ram shared by devs(def=8)");
6214MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)");
6215MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)");
6216MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
6217MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
6218MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
6219MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");
6220MODULE_PARM_DESC(host_lock, "host_lock is ignored (def=0)");
6221MODULE_PARM_DESC(host_max_queue,
6222		 "host max # of queued cmds (0 to max(def) [max_queue fixed equal for !0])");
6223MODULE_PARM_DESC(inq_product, "SCSI INQUIRY product string (def=\"scsi_debug\")");
6224MODULE_PARM_DESC(inq_rev, "SCSI INQUIRY revision string (def=\""
6225		 SDEBUG_VERSION "\")");
6226MODULE_PARM_DESC(inq_vendor, "SCSI INQUIRY vendor string (def=\"Linux\")");
6227MODULE_PARM_DESC(lbprz,
6228		 "on read unmapped LBs return 0 when 1 (def), return 0xff when 2");
6229MODULE_PARM_DESC(lbpu, "enable LBP, support UNMAP command (def=0)");
6230MODULE_PARM_DESC(lbpws, "enable LBP, support WRITE SAME(16) with UNMAP bit (def=0)");
6231MODULE_PARM_DESC(lbpws10, "enable LBP, support WRITE SAME(10) with UNMAP bit (def=0)");
6232MODULE_PARM_DESC(lowest_aligned, "lowest aligned lba (def=0)");
6233MODULE_PARM_DESC(lun_format, "LUN format: 0->peripheral (def); 1 --> flat address method");
6234MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
6235MODULE_PARM_DESC(max_queue, "max number of queued commands (1 to max(def))");
6236MODULE_PARM_DESC(medium_error_count, "count of sectors to return follow on MEDIUM error");
6237MODULE_PARM_DESC(medium_error_start, "starting sector number to return MEDIUM error");
6238MODULE_PARM_DESC(ndelay, "response delay in nanoseconds (def=0 -> ignore)");
6239MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
6240MODULE_PARM_DESC(no_rwlock, "don't protect user data reads+writes (def=0)");
6241MODULE_PARM_DESC(no_uld, "stop ULD (e.g. sd driver) attaching (def=0))");
6242MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
6243MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
6244MODULE_PARM_DESC(opt_blks, "optimal transfer length in blocks (def=1024)");
6245MODULE_PARM_DESC(opt_xferlen_exp, "optimal transfer length granularity exponent (def=physblk_exp)");
6246MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
6247MODULE_PARM_DESC(per_host_store, "If set, next positive add_host will get new store (def=0)");
6248MODULE_PARM_DESC(physblk_exp, "physical block exponent (def=0)");
6249MODULE_PARM_DESC(poll_queues, "support for iouring iopoll queues (1 to max(submit_queues - 1))");
6250MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
6251MODULE_PARM_DESC(random, "If set, uniformly randomize command duration between 0 and delay_in_ns");
6252MODULE_PARM_DESC(removable, "claim to have removable media (def=0)");
6253MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=7[SPC-5])");
6254MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)");
6255MODULE_PARM_DESC(statistics, "collect statistics on commands, queues (def=0)");
6256MODULE_PARM_DESC(strict, "stricter checks: reserved field in cdb (def=0)");
6257MODULE_PARM_DESC(submit_queues, "support for block multi-queue (def=1)");
6258MODULE_PARM_DESC(tur_ms_to_ready, "TEST UNIT READY millisecs before initial good status (def=0)");
6259MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)");
6260MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=1)");
6261MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0xffffffff)");
6262MODULE_PARM_DESC(unmap_max_desc, "max # of ranges that can be unmapped in one cmd (def=256)");
6263MODULE_PARM_DESC(uuid_ctl,
6264		 "1->use uuid for lu name, 0->don't, 2->all use same (def=0)");
6265MODULE_PARM_DESC(virtual_gb, "virtual gigabyte (GiB) size (def=0 -> use dev_size_mb)");
6266MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
6267MODULE_PARM_DESC(wp, "Write Protect (def=0)");
6268MODULE_PARM_DESC(write_same_length, "Maximum blocks per WRITE SAME cmd (def=0xffff)");
6269MODULE_PARM_DESC(zbc, "'none' [0]; 'aware' [1]; 'managed' [2] (def=0). Can have 'host-' prefix");
6270MODULE_PARM_DESC(zone_cap_mb, "Zone capacity in MiB (def=zone size)");
6271MODULE_PARM_DESC(zone_max_open, "Maximum number of open zones; [0] for no limit (def=auto)");
6272MODULE_PARM_DESC(zone_nr_conv, "Number of conventional zones (def=1)");
6273MODULE_PARM_DESC(zone_size_mb, "Zone size in MiB (def=auto)");
6274MODULE_PARM_DESC(allow_restart, "Set scsi_device's allow_restart flag(def=0)");
6275
6276#define SDEBUG_INFO_LEN 256
6277static char sdebug_info[SDEBUG_INFO_LEN];
6278
6279static const char *scsi_debug_info(struct Scsi_Host *shp)
6280{
6281	int k;
6282
6283	k = scnprintf(sdebug_info, SDEBUG_INFO_LEN, "%s: version %s [%s]\n",
6284		      my_name, SDEBUG_VERSION, sdebug_version_date);
6285	if (k >= (SDEBUG_INFO_LEN - 1))
6286		return sdebug_info;
6287	scnprintf(sdebug_info + k, SDEBUG_INFO_LEN - k,
6288		  "  dev_size_mb=%d, opts=0x%x, submit_queues=%d, %s=%d",
6289		  sdebug_dev_size_mb, sdebug_opts, submit_queues,
6290		  "statistics", (int)sdebug_statistics);
6291	return sdebug_info;
6292}
6293
6294/* 'echo <val> > /proc/scsi/scsi_debug/<host_id>' writes to opts */
6295static int scsi_debug_write_info(struct Scsi_Host *host, char *buffer,
6296				 int length)
6297{
6298	char arr[16];
6299	int opts;
6300	int minLen = length > 15 ? 15 : length;
6301
6302	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
6303		return -EACCES;
6304	memcpy(arr, buffer, minLen);
6305	arr[minLen] = '\0';
6306	if (1 != sscanf(arr, "%d", &opts))
6307		return -EINVAL;
6308	sdebug_opts = opts;
6309	sdebug_verbose = !!(SDEBUG_OPT_NOISE & opts);
6310	sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & opts);
6311	if (sdebug_every_nth != 0)
6312		tweak_cmnd_count();
6313	return length;
6314}
6315
6316struct sdebug_submit_queue_data {
6317	int *first;
6318	int *last;
6319	int queue_num;
6320};
6321
6322static bool sdebug_submit_queue_iter(struct request *rq, void *opaque)
6323{
6324	struct sdebug_submit_queue_data *data = opaque;
6325	u32 unique_tag = blk_mq_unique_tag(rq);
6326	u16 hwq = blk_mq_unique_tag_to_hwq(unique_tag);
6327	u16 tag = blk_mq_unique_tag_to_tag(unique_tag);
6328	int queue_num = data->queue_num;
6329
6330	if (hwq != queue_num)
6331		return true;
6332
6333	/* Rely on iter'ing in ascending tag order */
6334	if (*data->first == -1)
6335		*data->first = *data->last = tag;
6336	else
6337		*data->last = tag;
6338
6339	return true;
6340}
6341
6342/* Output seen with 'cat /proc/scsi/scsi_debug/<host_id>'. It will be the
6343 * same for each scsi_debug host (if more than one). Some of the counters
6344 * output are not atomics so might be inaccurate in a busy system. */
6345static int scsi_debug_show_info(struct seq_file *m, struct Scsi_Host *host)
6346{
 
 
6347	struct sdebug_host_info *sdhp;
6348	int j;
6349
6350	seq_printf(m, "scsi_debug adapter driver, version %s [%s]\n",
6351		   SDEBUG_VERSION, sdebug_version_date);
6352	seq_printf(m, "num_tgts=%d, %ssize=%d MB, opts=0x%x, every_nth=%d\n",
6353		   sdebug_num_tgts, "shared (ram) ", sdebug_dev_size_mb,
6354		   sdebug_opts, sdebug_every_nth);
6355	seq_printf(m, "delay=%d, ndelay=%d, max_luns=%d, sector_size=%d %s\n",
6356		   sdebug_jdelay, sdebug_ndelay, sdebug_max_luns,
6357		   sdebug_sector_size, "bytes");
6358	seq_printf(m, "cylinders=%d, heads=%d, sectors=%d, command aborts=%d\n",
6359		   sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
6360		   num_aborts);
6361	seq_printf(m, "RESETs: device=%d, target=%d, bus=%d, host=%d\n",
6362		   num_dev_resets, num_target_resets, num_bus_resets,
6363		   num_host_resets);
6364	seq_printf(m, "dix_reads=%d, dix_writes=%d, dif_errors=%d\n",
6365		   dix_reads, dix_writes, dif_errors);
6366	seq_printf(m, "usec_in_jiffy=%lu, statistics=%d\n", TICK_NSEC / 1000,
6367		   sdebug_statistics);
6368	seq_printf(m, "cmnd_count=%d, completions=%d, %s=%d, a_tsf=%d, mq_polls=%d\n",
6369		   atomic_read(&sdebug_cmnd_count),
6370		   atomic_read(&sdebug_completions),
6371		   "miss_cpus", atomic_read(&sdebug_miss_cpus),
6372		   atomic_read(&sdebug_a_tsf),
6373		   atomic_read(&sdeb_mq_poll_count));
6374
6375	seq_printf(m, "submit_queues=%d\n", submit_queues);
6376	for (j = 0; j < submit_queues; ++j) {
6377		int f = -1, l = -1;
6378		struct sdebug_submit_queue_data data = {
6379			.queue_num = j,
6380			.first = &f,
6381			.last = &l,
6382		};
6383		seq_printf(m, "  queue %d:\n", j);
6384		blk_mq_tagset_busy_iter(&host->tag_set, sdebug_submit_queue_iter,
6385					&data);
6386		if (f >= 0) {
6387			seq_printf(m, "    in_use_bm BUSY: %s: %d,%d\n",
6388				   "first,last bits", f, l);
6389		}
6390	}
6391
6392	seq_printf(m, "this host_no=%d\n", host->host_no);
6393	if (!xa_empty(per_store_ap)) {
6394		bool niu;
6395		int idx;
6396		unsigned long l_idx;
6397		struct sdeb_store_info *sip;
6398
6399		seq_puts(m, "\nhost list:\n");
6400		j = 0;
6401		list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
6402			idx = sdhp->si_idx;
6403			seq_printf(m, "  %d: host_no=%d, si_idx=%d\n", j,
6404				   sdhp->shost->host_no, idx);
6405			++j;
6406		}
6407		seq_printf(m, "\nper_store array [most_recent_idx=%d]:\n",
6408			   sdeb_most_recent_idx);
6409		j = 0;
6410		xa_for_each(per_store_ap, l_idx, sip) {
6411			niu = xa_get_mark(per_store_ap, l_idx,
6412					  SDEB_XA_NOT_IN_USE);
6413			idx = (int)l_idx;
6414			seq_printf(m, "  %d: idx=%d%s\n", j, idx,
6415				   (niu ? "  not_in_use" : ""));
6416			++j;
6417		}
6418	}
6419	return 0;
6420}
6421
6422static ssize_t delay_show(struct device_driver *ddp, char *buf)
6423{
6424	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_jdelay);
6425}
6426/* Returns -EBUSY if jdelay is being changed and commands are queued. The unit
6427 * of delay is jiffies.
6428 */
6429static ssize_t delay_store(struct device_driver *ddp, const char *buf,
6430			   size_t count)
6431{
6432	int jdelay, res;
6433
6434	if (count > 0 && sscanf(buf, "%d", &jdelay) == 1) {
6435		res = count;
6436		if (sdebug_jdelay != jdelay) {
6437			struct sdebug_host_info *sdhp;
 
6438
6439			mutex_lock(&sdebug_host_list_mutex);
6440			block_unblock_all_queues(true);
6441
6442			list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
6443				struct Scsi_Host *shost = sdhp->shost;
6444
6445				if (scsi_host_busy(shost)) {
6446					res = -EBUSY;   /* queued commands */
6447					break;
6448				}
6449			}
6450			if (res > 0) {
6451				sdebug_jdelay = jdelay;
6452				sdebug_ndelay = 0;
6453			}
6454			block_unblock_all_queues(false);
6455			mutex_unlock(&sdebug_host_list_mutex);
6456		}
6457		return res;
6458	}
6459	return -EINVAL;
6460}
6461static DRIVER_ATTR_RW(delay);
6462
6463static ssize_t ndelay_show(struct device_driver *ddp, char *buf)
6464{
6465	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ndelay);
6466}
6467/* Returns -EBUSY if ndelay is being changed and commands are queued */
6468/* If > 0 and accepted then sdebug_jdelay is set to JDELAY_OVERRIDDEN */
6469static ssize_t ndelay_store(struct device_driver *ddp, const char *buf,
6470			    size_t count)
6471{
6472	int ndelay, res;
6473
6474	if ((count > 0) && (1 == sscanf(buf, "%d", &ndelay)) &&
6475	    (ndelay >= 0) && (ndelay < (1000 * 1000 * 1000))) {
6476		res = count;
6477		if (sdebug_ndelay != ndelay) {
6478			struct sdebug_host_info *sdhp;
 
6479
6480			mutex_lock(&sdebug_host_list_mutex);
6481			block_unblock_all_queues(true);
6482
6483			list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
6484				struct Scsi_Host *shost = sdhp->shost;
6485
6486				if (scsi_host_busy(shost)) {
6487					res = -EBUSY;   /* queued commands */
6488					break;
6489				}
6490			}
6491
6492			if (res > 0) {
6493				sdebug_ndelay = ndelay;
6494				sdebug_jdelay = ndelay  ? JDELAY_OVERRIDDEN
6495							: DEF_JDELAY;
6496			}
6497			block_unblock_all_queues(false);
6498			mutex_unlock(&sdebug_host_list_mutex);
6499		}
6500		return res;
6501	}
6502	return -EINVAL;
6503}
6504static DRIVER_ATTR_RW(ndelay);
6505
6506static ssize_t opts_show(struct device_driver *ddp, char *buf)
6507{
6508	return scnprintf(buf, PAGE_SIZE, "0x%x\n", sdebug_opts);
6509}
6510
6511static ssize_t opts_store(struct device_driver *ddp, const char *buf,
6512			  size_t count)
6513{
6514	int opts;
6515	char work[20];
6516
6517	if (sscanf(buf, "%10s", work) == 1) {
6518		if (strncasecmp(work, "0x", 2) == 0) {
6519			if (kstrtoint(work + 2, 16, &opts) == 0)
6520				goto opts_done;
6521		} else {
6522			if (kstrtoint(work, 10, &opts) == 0)
6523				goto opts_done;
6524		}
6525	}
6526	return -EINVAL;
6527opts_done:
6528	sdebug_opts = opts;
6529	sdebug_verbose = !!(SDEBUG_OPT_NOISE & opts);
6530	sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & opts);
6531	tweak_cmnd_count();
6532	return count;
6533}
6534static DRIVER_ATTR_RW(opts);
6535
6536static ssize_t ptype_show(struct device_driver *ddp, char *buf)
6537{
6538	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ptype);
6539}
6540static ssize_t ptype_store(struct device_driver *ddp, const char *buf,
6541			   size_t count)
6542{
6543	int n;
6544
6545	/* Cannot change from or to TYPE_ZBC with sysfs */
6546	if (sdebug_ptype == TYPE_ZBC)
6547		return -EINVAL;
6548
6549	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6550		if (n == TYPE_ZBC)
6551			return -EINVAL;
6552		sdebug_ptype = n;
6553		return count;
6554	}
6555	return -EINVAL;
6556}
6557static DRIVER_ATTR_RW(ptype);
6558
6559static ssize_t dsense_show(struct device_driver *ddp, char *buf)
6560{
6561	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dsense);
6562}
6563static ssize_t dsense_store(struct device_driver *ddp, const char *buf,
6564			    size_t count)
6565{
6566	int n;
6567
6568	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6569		sdebug_dsense = n;
6570		return count;
6571	}
6572	return -EINVAL;
6573}
6574static DRIVER_ATTR_RW(dsense);
6575
6576static ssize_t fake_rw_show(struct device_driver *ddp, char *buf)
6577{
6578	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_fake_rw);
6579}
6580static ssize_t fake_rw_store(struct device_driver *ddp, const char *buf,
6581			     size_t count)
6582{
6583	int n, idx;
6584
6585	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6586		bool want_store = (n == 0);
6587		struct sdebug_host_info *sdhp;
6588
6589		n = (n > 0);
6590		sdebug_fake_rw = (sdebug_fake_rw > 0);
6591		if (sdebug_fake_rw == n)
6592			return count;	/* not transitioning so do nothing */
6593
6594		if (want_store) {	/* 1 --> 0 transition, set up store */
6595			if (sdeb_first_idx < 0) {
6596				idx = sdebug_add_store();
6597				if (idx < 0)
6598					return idx;
6599			} else {
6600				idx = sdeb_first_idx;
6601				xa_clear_mark(per_store_ap, idx,
6602					      SDEB_XA_NOT_IN_USE);
6603			}
6604			/* make all hosts use same store */
6605			list_for_each_entry(sdhp, &sdebug_host_list,
6606					    host_list) {
6607				if (sdhp->si_idx != idx) {
6608					xa_set_mark(per_store_ap, sdhp->si_idx,
6609						    SDEB_XA_NOT_IN_USE);
6610					sdhp->si_idx = idx;
6611				}
6612			}
6613			sdeb_most_recent_idx = idx;
6614		} else {	/* 0 --> 1 transition is trigger for shrink */
6615			sdebug_erase_all_stores(true /* apart from first */);
6616		}
6617		sdebug_fake_rw = n;
6618		return count;
6619	}
6620	return -EINVAL;
6621}
6622static DRIVER_ATTR_RW(fake_rw);
6623
6624static ssize_t no_lun_0_show(struct device_driver *ddp, char *buf)
6625{
6626	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_lun_0);
6627}
6628static ssize_t no_lun_0_store(struct device_driver *ddp, const char *buf,
6629			      size_t count)
6630{
6631	int n;
6632
6633	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6634		sdebug_no_lun_0 = n;
6635		return count;
6636	}
6637	return -EINVAL;
6638}
6639static DRIVER_ATTR_RW(no_lun_0);
6640
6641static ssize_t num_tgts_show(struct device_driver *ddp, char *buf)
6642{
6643	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_tgts);
6644}
6645static ssize_t num_tgts_store(struct device_driver *ddp, const char *buf,
6646			      size_t count)
6647{
6648	int n;
6649
6650	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6651		sdebug_num_tgts = n;
6652		sdebug_max_tgts_luns();
6653		return count;
6654	}
6655	return -EINVAL;
6656}
6657static DRIVER_ATTR_RW(num_tgts);
6658
6659static ssize_t dev_size_mb_show(struct device_driver *ddp, char *buf)
6660{
6661	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dev_size_mb);
6662}
6663static DRIVER_ATTR_RO(dev_size_mb);
6664
6665static ssize_t per_host_store_show(struct device_driver *ddp, char *buf)
6666{
6667	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_per_host_store);
6668}
6669
6670static ssize_t per_host_store_store(struct device_driver *ddp, const char *buf,
6671				    size_t count)
6672{
6673	bool v;
6674
6675	if (kstrtobool(buf, &v))
6676		return -EINVAL;
6677
6678	sdebug_per_host_store = v;
6679	return count;
6680}
6681static DRIVER_ATTR_RW(per_host_store);
6682
6683static ssize_t num_parts_show(struct device_driver *ddp, char *buf)
6684{
6685	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_parts);
6686}
6687static DRIVER_ATTR_RO(num_parts);
6688
6689static ssize_t every_nth_show(struct device_driver *ddp, char *buf)
6690{
6691	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_every_nth);
6692}
6693static ssize_t every_nth_store(struct device_driver *ddp, const char *buf,
6694			       size_t count)
6695{
6696	int nth;
6697	char work[20];
6698
6699	if (sscanf(buf, "%10s", work) == 1) {
6700		if (strncasecmp(work, "0x", 2) == 0) {
6701			if (kstrtoint(work + 2, 16, &nth) == 0)
6702				goto every_nth_done;
6703		} else {
6704			if (kstrtoint(work, 10, &nth) == 0)
6705				goto every_nth_done;
6706		}
6707	}
6708	return -EINVAL;
6709
6710every_nth_done:
6711	sdebug_every_nth = nth;
6712	if (nth && !sdebug_statistics) {
6713		pr_info("every_nth needs statistics=1, set it\n");
6714		sdebug_statistics = true;
6715	}
6716	tweak_cmnd_count();
6717	return count;
6718}
6719static DRIVER_ATTR_RW(every_nth);
6720
6721static ssize_t lun_format_show(struct device_driver *ddp, char *buf)
6722{
6723	return scnprintf(buf, PAGE_SIZE, "%d\n", (int)sdebug_lun_am);
6724}
6725static ssize_t lun_format_store(struct device_driver *ddp, const char *buf,
6726				size_t count)
6727{
6728	int n;
6729	bool changed;
6730
6731	if (kstrtoint(buf, 0, &n))
6732		return -EINVAL;
6733	if (n >= 0) {
6734		if (n > (int)SAM_LUN_AM_FLAT) {
6735			pr_warn("only LUN address methods 0 and 1 are supported\n");
6736			return -EINVAL;
6737		}
6738		changed = ((int)sdebug_lun_am != n);
6739		sdebug_lun_am = n;
6740		if (changed && sdebug_scsi_level >= 5) {	/* >= SPC-3 */
6741			struct sdebug_host_info *sdhp;
6742			struct sdebug_dev_info *dp;
6743
6744			mutex_lock(&sdebug_host_list_mutex);
6745			list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
6746				list_for_each_entry(dp, &sdhp->dev_info_list, dev_list) {
6747					set_bit(SDEBUG_UA_LUNS_CHANGED, dp->uas_bm);
6748				}
6749			}
6750			mutex_unlock(&sdebug_host_list_mutex);
6751		}
6752		return count;
6753	}
6754	return -EINVAL;
6755}
6756static DRIVER_ATTR_RW(lun_format);
6757
6758static ssize_t max_luns_show(struct device_driver *ddp, char *buf)
6759{
6760	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_max_luns);
6761}
6762static ssize_t max_luns_store(struct device_driver *ddp, const char *buf,
6763			      size_t count)
6764{
6765	int n;
6766	bool changed;
6767
6768	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6769		if (n > 256) {
6770			pr_warn("max_luns can be no more than 256\n");
6771			return -EINVAL;
6772		}
6773		changed = (sdebug_max_luns != n);
6774		sdebug_max_luns = n;
6775		sdebug_max_tgts_luns();
6776		if (changed && (sdebug_scsi_level >= 5)) {	/* >= SPC-3 */
6777			struct sdebug_host_info *sdhp;
6778			struct sdebug_dev_info *dp;
6779
6780			mutex_lock(&sdebug_host_list_mutex);
6781			list_for_each_entry(sdhp, &sdebug_host_list,
6782					    host_list) {
6783				list_for_each_entry(dp, &sdhp->dev_info_list,
6784						    dev_list) {
6785					set_bit(SDEBUG_UA_LUNS_CHANGED,
6786						dp->uas_bm);
6787				}
6788			}
6789			mutex_unlock(&sdebug_host_list_mutex);
6790		}
6791		return count;
6792	}
6793	return -EINVAL;
6794}
6795static DRIVER_ATTR_RW(max_luns);
6796
6797static ssize_t max_queue_show(struct device_driver *ddp, char *buf)
6798{
6799	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_max_queue);
6800}
6801/* N.B. max_queue can be changed while there are queued commands. In flight
6802 * commands beyond the new max_queue will be completed. */
6803static ssize_t max_queue_store(struct device_driver *ddp, const char *buf,
6804			       size_t count)
6805{
6806	int n;
 
6807
6808	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n > 0) &&
6809	    (n <= SDEBUG_CANQUEUE) &&
6810	    (sdebug_host_max_queue == 0)) {
6811		mutex_lock(&sdebug_host_list_mutex);
6812
6813		/* We may only change sdebug_max_queue when we have no shosts */
6814		if (list_empty(&sdebug_host_list))
6815			sdebug_max_queue = n;
 
 
 
 
 
 
 
 
6816		else
6817			count = -EBUSY;
6818		mutex_unlock(&sdebug_host_list_mutex);
6819		return count;
6820	}
6821	return -EINVAL;
6822}
6823static DRIVER_ATTR_RW(max_queue);
6824
6825static ssize_t host_max_queue_show(struct device_driver *ddp, char *buf)
6826{
6827	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_host_max_queue);
6828}
6829
6830static ssize_t no_rwlock_show(struct device_driver *ddp, char *buf)
6831{
6832	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_rwlock);
6833}
6834
6835static ssize_t no_rwlock_store(struct device_driver *ddp, const char *buf, size_t count)
6836{
6837	bool v;
6838
6839	if (kstrtobool(buf, &v))
6840		return -EINVAL;
6841
6842	sdebug_no_rwlock = v;
6843	return count;
6844}
6845static DRIVER_ATTR_RW(no_rwlock);
6846
6847/*
6848 * Since this is used for .can_queue, and we get the hc_idx tag from the bitmap
6849 * in range [0, sdebug_host_max_queue), we can't change it.
6850 */
6851static DRIVER_ATTR_RO(host_max_queue);
6852
6853static ssize_t no_uld_show(struct device_driver *ddp, char *buf)
6854{
6855	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_uld);
6856}
6857static DRIVER_ATTR_RO(no_uld);
6858
6859static ssize_t scsi_level_show(struct device_driver *ddp, char *buf)
6860{
6861	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_scsi_level);
6862}
6863static DRIVER_ATTR_RO(scsi_level);
6864
6865static ssize_t virtual_gb_show(struct device_driver *ddp, char *buf)
6866{
6867	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_virtual_gb);
6868}
6869static ssize_t virtual_gb_store(struct device_driver *ddp, const char *buf,
6870				size_t count)
6871{
6872	int n;
6873	bool changed;
6874
6875	/* Ignore capacity change for ZBC drives for now */
6876	if (sdeb_zbc_in_use)
6877		return -ENOTSUPP;
6878
6879	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6880		changed = (sdebug_virtual_gb != n);
6881		sdebug_virtual_gb = n;
6882		sdebug_capacity = get_sdebug_capacity();
6883		if (changed) {
6884			struct sdebug_host_info *sdhp;
6885			struct sdebug_dev_info *dp;
6886
6887			mutex_lock(&sdebug_host_list_mutex);
6888			list_for_each_entry(sdhp, &sdebug_host_list,
6889					    host_list) {
6890				list_for_each_entry(dp, &sdhp->dev_info_list,
6891						    dev_list) {
6892					set_bit(SDEBUG_UA_CAPACITY_CHANGED,
6893						dp->uas_bm);
6894				}
6895			}
6896			mutex_unlock(&sdebug_host_list_mutex);
6897		}
6898		return count;
6899	}
6900	return -EINVAL;
6901}
6902static DRIVER_ATTR_RW(virtual_gb);
6903
6904static ssize_t add_host_show(struct device_driver *ddp, char *buf)
6905{
6906	/* absolute number of hosts currently active is what is shown */
6907	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_hosts);
6908}
6909
6910static ssize_t add_host_store(struct device_driver *ddp, const char *buf,
6911			      size_t count)
6912{
6913	bool found;
6914	unsigned long idx;
6915	struct sdeb_store_info *sip;
6916	bool want_phs = (sdebug_fake_rw == 0) && sdebug_per_host_store;
6917	int delta_hosts;
6918
6919	if (sscanf(buf, "%d", &delta_hosts) != 1)
6920		return -EINVAL;
6921	if (delta_hosts > 0) {
6922		do {
6923			found = false;
6924			if (want_phs) {
6925				xa_for_each_marked(per_store_ap, idx, sip,
6926						   SDEB_XA_NOT_IN_USE) {
6927					sdeb_most_recent_idx = (int)idx;
6928					found = true;
6929					break;
6930				}
6931				if (found)	/* re-use case */
6932					sdebug_add_host_helper((int)idx);
6933				else
6934					sdebug_do_add_host(true);
6935			} else {
6936				sdebug_do_add_host(false);
6937			}
6938		} while (--delta_hosts);
6939	} else if (delta_hosts < 0) {
6940		do {
6941			sdebug_do_remove_host(false);
6942		} while (++delta_hosts);
6943	}
6944	return count;
6945}
6946static DRIVER_ATTR_RW(add_host);
6947
6948static ssize_t vpd_use_hostno_show(struct device_driver *ddp, char *buf)
6949{
6950	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_vpd_use_hostno);
6951}
6952static ssize_t vpd_use_hostno_store(struct device_driver *ddp, const char *buf,
6953				    size_t count)
6954{
6955	int n;
6956
6957	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
6958		sdebug_vpd_use_hostno = n;
6959		return count;
6960	}
6961	return -EINVAL;
6962}
6963static DRIVER_ATTR_RW(vpd_use_hostno);
6964
6965static ssize_t statistics_show(struct device_driver *ddp, char *buf)
6966{
6967	return scnprintf(buf, PAGE_SIZE, "%d\n", (int)sdebug_statistics);
6968}
6969static ssize_t statistics_store(struct device_driver *ddp, const char *buf,
6970				size_t count)
6971{
6972	int n;
6973
6974	if ((count > 0) && (sscanf(buf, "%d", &n) == 1) && (n >= 0)) {
6975		if (n > 0)
6976			sdebug_statistics = true;
6977		else {
6978			clear_queue_stats();
6979			sdebug_statistics = false;
6980		}
6981		return count;
6982	}
6983	return -EINVAL;
6984}
6985static DRIVER_ATTR_RW(statistics);
6986
6987static ssize_t sector_size_show(struct device_driver *ddp, char *buf)
6988{
6989	return scnprintf(buf, PAGE_SIZE, "%u\n", sdebug_sector_size);
6990}
6991static DRIVER_ATTR_RO(sector_size);
6992
6993static ssize_t submit_queues_show(struct device_driver *ddp, char *buf)
6994{
6995	return scnprintf(buf, PAGE_SIZE, "%d\n", submit_queues);
6996}
6997static DRIVER_ATTR_RO(submit_queues);
6998
6999static ssize_t dix_show(struct device_driver *ddp, char *buf)
7000{
7001	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dix);
7002}
7003static DRIVER_ATTR_RO(dix);
7004
7005static ssize_t dif_show(struct device_driver *ddp, char *buf)
7006{
7007	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dif);
7008}
7009static DRIVER_ATTR_RO(dif);
7010
7011static ssize_t guard_show(struct device_driver *ddp, char *buf)
7012{
7013	return scnprintf(buf, PAGE_SIZE, "%u\n", sdebug_guard);
7014}
7015static DRIVER_ATTR_RO(guard);
7016
7017static ssize_t ato_show(struct device_driver *ddp, char *buf)
7018{
7019	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ato);
7020}
7021static DRIVER_ATTR_RO(ato);
7022
7023static ssize_t map_show(struct device_driver *ddp, char *buf)
7024{
7025	ssize_t count = 0;
7026
7027	if (!scsi_debug_lbp())
7028		return scnprintf(buf, PAGE_SIZE, "0-%u\n",
7029				 sdebug_store_sectors);
7030
7031	if (sdebug_fake_rw == 0 && !xa_empty(per_store_ap)) {
7032		struct sdeb_store_info *sip = xa_load(per_store_ap, 0);
7033
7034		if (sip)
7035			count = scnprintf(buf, PAGE_SIZE - 1, "%*pbl",
7036					  (int)map_size, sip->map_storep);
7037	}
7038	buf[count++] = '\n';
7039	buf[count] = '\0';
7040
7041	return count;
7042}
7043static DRIVER_ATTR_RO(map);
7044
7045static ssize_t random_show(struct device_driver *ddp, char *buf)
7046{
7047	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_random);
7048}
7049
7050static ssize_t random_store(struct device_driver *ddp, const char *buf,
7051			    size_t count)
7052{
7053	bool v;
7054
7055	if (kstrtobool(buf, &v))
7056		return -EINVAL;
7057
7058	sdebug_random = v;
7059	return count;
7060}
7061static DRIVER_ATTR_RW(random);
7062
7063static ssize_t removable_show(struct device_driver *ddp, char *buf)
7064{
7065	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_removable ? 1 : 0);
7066}
7067static ssize_t removable_store(struct device_driver *ddp, const char *buf,
7068			       size_t count)
7069{
7070	int n;
7071
7072	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
7073		sdebug_removable = (n > 0);
7074		return count;
7075	}
7076	return -EINVAL;
7077}
7078static DRIVER_ATTR_RW(removable);
7079
7080static ssize_t host_lock_show(struct device_driver *ddp, char *buf)
7081{
7082	return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_host_lock);
7083}
7084/* N.B. sdebug_host_lock does nothing, kept for backward compatibility */
7085static ssize_t host_lock_store(struct device_driver *ddp, const char *buf,
7086			       size_t count)
7087{
7088	int n;
7089
7090	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
7091		sdebug_host_lock = (n > 0);
7092		return count;
7093	}
7094	return -EINVAL;
7095}
7096static DRIVER_ATTR_RW(host_lock);
7097
7098static ssize_t strict_show(struct device_driver *ddp, char *buf)
7099{
7100	return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_strict);
7101}
7102static ssize_t strict_store(struct device_driver *ddp, const char *buf,
7103			    size_t count)
7104{
7105	int n;
7106
7107	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
7108		sdebug_strict = (n > 0);
7109		return count;
7110	}
7111	return -EINVAL;
7112}
7113static DRIVER_ATTR_RW(strict);
7114
7115static ssize_t uuid_ctl_show(struct device_driver *ddp, char *buf)
7116{
7117	return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_uuid_ctl);
7118}
7119static DRIVER_ATTR_RO(uuid_ctl);
7120
7121static ssize_t cdb_len_show(struct device_driver *ddp, char *buf)
7122{
7123	return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_cdb_len);
7124}
7125static ssize_t cdb_len_store(struct device_driver *ddp, const char *buf,
7126			     size_t count)
7127{
7128	int ret, n;
7129
7130	ret = kstrtoint(buf, 0, &n);
7131	if (ret)
7132		return ret;
7133	sdebug_cdb_len = n;
7134	all_config_cdb_len();
7135	return count;
7136}
7137static DRIVER_ATTR_RW(cdb_len);
7138
7139static const char * const zbc_model_strs_a[] = {
7140	[BLK_ZONED_NONE] = "none",
7141	[BLK_ZONED_HA]   = "host-aware",
7142	[BLK_ZONED_HM]   = "host-managed",
7143};
7144
7145static const char * const zbc_model_strs_b[] = {
7146	[BLK_ZONED_NONE] = "no",
7147	[BLK_ZONED_HA]   = "aware",
7148	[BLK_ZONED_HM]   = "managed",
7149};
7150
7151static const char * const zbc_model_strs_c[] = {
7152	[BLK_ZONED_NONE] = "0",
7153	[BLK_ZONED_HA]   = "1",
7154	[BLK_ZONED_HM]   = "2",
7155};
7156
7157static int sdeb_zbc_model_str(const char *cp)
7158{
7159	int res = sysfs_match_string(zbc_model_strs_a, cp);
7160
7161	if (res < 0) {
7162		res = sysfs_match_string(zbc_model_strs_b, cp);
7163		if (res < 0) {
7164			res = sysfs_match_string(zbc_model_strs_c, cp);
7165			if (res < 0)
7166				return -EINVAL;
7167		}
7168	}
7169	return res;
7170}
7171
7172static ssize_t zbc_show(struct device_driver *ddp, char *buf)
7173{
7174	return scnprintf(buf, PAGE_SIZE, "%s\n",
7175			 zbc_model_strs_a[sdeb_zbc_model]);
7176}
7177static DRIVER_ATTR_RO(zbc);
7178
7179static ssize_t tur_ms_to_ready_show(struct device_driver *ddp, char *buf)
7180{
7181	return scnprintf(buf, PAGE_SIZE, "%d\n", sdeb_tur_ms_to_ready);
7182}
7183static DRIVER_ATTR_RO(tur_ms_to_ready);
7184
7185/* Note: The following array creates attribute files in the
7186   /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
7187   files (over those found in the /sys/module/scsi_debug/parameters
7188   directory) is that auxiliary actions can be triggered when an attribute
7189   is changed. For example see: add_host_store() above.
7190 */
7191
7192static struct attribute *sdebug_drv_attrs[] = {
7193	&driver_attr_delay.attr,
7194	&driver_attr_opts.attr,
7195	&driver_attr_ptype.attr,
7196	&driver_attr_dsense.attr,
7197	&driver_attr_fake_rw.attr,
7198	&driver_attr_host_max_queue.attr,
7199	&driver_attr_no_lun_0.attr,
7200	&driver_attr_num_tgts.attr,
7201	&driver_attr_dev_size_mb.attr,
7202	&driver_attr_num_parts.attr,
7203	&driver_attr_every_nth.attr,
7204	&driver_attr_lun_format.attr,
7205	&driver_attr_max_luns.attr,
7206	&driver_attr_max_queue.attr,
7207	&driver_attr_no_rwlock.attr,
7208	&driver_attr_no_uld.attr,
7209	&driver_attr_scsi_level.attr,
7210	&driver_attr_virtual_gb.attr,
7211	&driver_attr_add_host.attr,
7212	&driver_attr_per_host_store.attr,
7213	&driver_attr_vpd_use_hostno.attr,
7214	&driver_attr_sector_size.attr,
7215	&driver_attr_statistics.attr,
7216	&driver_attr_submit_queues.attr,
7217	&driver_attr_dix.attr,
7218	&driver_attr_dif.attr,
7219	&driver_attr_guard.attr,
7220	&driver_attr_ato.attr,
7221	&driver_attr_map.attr,
7222	&driver_attr_random.attr,
7223	&driver_attr_removable.attr,
7224	&driver_attr_host_lock.attr,
7225	&driver_attr_ndelay.attr,
7226	&driver_attr_strict.attr,
7227	&driver_attr_uuid_ctl.attr,
7228	&driver_attr_cdb_len.attr,
7229	&driver_attr_tur_ms_to_ready.attr,
7230	&driver_attr_zbc.attr,
7231	NULL,
7232};
7233ATTRIBUTE_GROUPS(sdebug_drv);
7234
7235static struct device *pseudo_primary;
7236
7237static int __init scsi_debug_init(void)
7238{
7239	bool want_store = (sdebug_fake_rw == 0);
7240	unsigned long sz;
7241	int k, ret, hosts_to_add;
7242	int idx = -1;
7243
 
 
 
 
7244	if (sdebug_ndelay >= 1000 * 1000 * 1000) {
7245		pr_warn("ndelay must be less than 1 second, ignored\n");
7246		sdebug_ndelay = 0;
7247	} else if (sdebug_ndelay > 0)
7248		sdebug_jdelay = JDELAY_OVERRIDDEN;
7249
7250	switch (sdebug_sector_size) {
7251	case  512:
7252	case 1024:
7253	case 2048:
7254	case 4096:
7255		break;
7256	default:
7257		pr_err("invalid sector_size %d\n", sdebug_sector_size);
7258		return -EINVAL;
7259	}
7260
7261	switch (sdebug_dif) {
7262	case T10_PI_TYPE0_PROTECTION:
7263		break;
7264	case T10_PI_TYPE1_PROTECTION:
7265	case T10_PI_TYPE2_PROTECTION:
7266	case T10_PI_TYPE3_PROTECTION:
7267		have_dif_prot = true;
7268		break;
7269
7270	default:
7271		pr_err("dif must be 0, 1, 2 or 3\n");
7272		return -EINVAL;
7273	}
7274
7275	if (sdebug_num_tgts < 0) {
7276		pr_err("num_tgts must be >= 0\n");
7277		return -EINVAL;
7278	}
7279
7280	if (sdebug_guard > 1) {
7281		pr_err("guard must be 0 or 1\n");
7282		return -EINVAL;
7283	}
7284
7285	if (sdebug_ato > 1) {
7286		pr_err("ato must be 0 or 1\n");
7287		return -EINVAL;
7288	}
7289
7290	if (sdebug_physblk_exp > 15) {
7291		pr_err("invalid physblk_exp %u\n", sdebug_physblk_exp);
7292		return -EINVAL;
7293	}
7294
7295	sdebug_lun_am = sdebug_lun_am_i;
7296	if (sdebug_lun_am > SAM_LUN_AM_FLAT) {
7297		pr_warn("Invalid LUN format %u, using default\n", (int)sdebug_lun_am);
7298		sdebug_lun_am = SAM_LUN_AM_PERIPHERAL;
7299	}
7300
7301	if (sdebug_max_luns > 256) {
7302		if (sdebug_max_luns > 16384) {
7303			pr_warn("max_luns can be no more than 16384, use default\n");
7304			sdebug_max_luns = DEF_MAX_LUNS;
7305		}
7306		sdebug_lun_am = SAM_LUN_AM_FLAT;
7307	}
7308
7309	if (sdebug_lowest_aligned > 0x3fff) {
7310		pr_err("lowest_aligned too big: %u\n", sdebug_lowest_aligned);
7311		return -EINVAL;
7312	}
7313
7314	if (submit_queues < 1) {
7315		pr_err("submit_queues must be 1 or more\n");
7316		return -EINVAL;
7317	}
7318
7319	if ((sdebug_max_queue > SDEBUG_CANQUEUE) || (sdebug_max_queue < 1)) {
7320		pr_err("max_queue must be in range [1, %d]\n", SDEBUG_CANQUEUE);
7321		return -EINVAL;
7322	}
7323
7324	if ((sdebug_host_max_queue > SDEBUG_CANQUEUE) ||
7325	    (sdebug_host_max_queue < 0)) {
7326		pr_err("host_max_queue must be in range [0 %d]\n",
7327		       SDEBUG_CANQUEUE);
7328		return -EINVAL;
7329	}
7330
7331	if (sdebug_host_max_queue &&
7332	    (sdebug_max_queue != sdebug_host_max_queue)) {
7333		sdebug_max_queue = sdebug_host_max_queue;
7334		pr_warn("fixing max submit queue depth to host max queue depth, %d\n",
7335			sdebug_max_queue);
7336	}
7337
 
 
 
 
 
 
 
7338	/*
7339	 * check for host managed zoned block device specified with
7340	 * ptype=0x14 or zbc=XXX.
7341	 */
7342	if (sdebug_ptype == TYPE_ZBC) {
7343		sdeb_zbc_model = BLK_ZONED_HM;
7344	} else if (sdeb_zbc_model_s && *sdeb_zbc_model_s) {
7345		k = sdeb_zbc_model_str(sdeb_zbc_model_s);
7346		if (k < 0)
7347			return k;
 
 
7348		sdeb_zbc_model = k;
7349		switch (sdeb_zbc_model) {
7350		case BLK_ZONED_NONE:
7351		case BLK_ZONED_HA:
7352			sdebug_ptype = TYPE_DISK;
7353			break;
7354		case BLK_ZONED_HM:
7355			sdebug_ptype = TYPE_ZBC;
7356			break;
7357		default:
7358			pr_err("Invalid ZBC model\n");
7359			return -EINVAL;
7360		}
7361	}
7362	if (sdeb_zbc_model != BLK_ZONED_NONE) {
7363		sdeb_zbc_in_use = true;
7364		if (sdebug_dev_size_mb == DEF_DEV_SIZE_PRE_INIT)
7365			sdebug_dev_size_mb = DEF_ZBC_DEV_SIZE_MB;
7366	}
7367
7368	if (sdebug_dev_size_mb == DEF_DEV_SIZE_PRE_INIT)
7369		sdebug_dev_size_mb = DEF_DEV_SIZE_MB;
7370	if (sdebug_dev_size_mb < 1)
7371		sdebug_dev_size_mb = 1;  /* force minimum 1 MB ramdisk */
7372	sz = (unsigned long)sdebug_dev_size_mb * 1048576;
7373	sdebug_store_sectors = sz / sdebug_sector_size;
7374	sdebug_capacity = get_sdebug_capacity();
7375
7376	/* play around with geometry, don't waste too much on track 0 */
7377	sdebug_heads = 8;
7378	sdebug_sectors_per = 32;
7379	if (sdebug_dev_size_mb >= 256)
7380		sdebug_heads = 64;
7381	else if (sdebug_dev_size_mb >= 16)
7382		sdebug_heads = 32;
7383	sdebug_cylinders_per = (unsigned long)sdebug_capacity /
7384			       (sdebug_sectors_per * sdebug_heads);
7385	if (sdebug_cylinders_per >= 1024) {
7386		/* other LLDs do this; implies >= 1GB ram disk ... */
7387		sdebug_heads = 255;
7388		sdebug_sectors_per = 63;
7389		sdebug_cylinders_per = (unsigned long)sdebug_capacity /
7390			       (sdebug_sectors_per * sdebug_heads);
7391	}
7392	if (scsi_debug_lbp()) {
7393		sdebug_unmap_max_blocks =
7394			clamp(sdebug_unmap_max_blocks, 0U, 0xffffffffU);
7395
7396		sdebug_unmap_max_desc =
7397			clamp(sdebug_unmap_max_desc, 0U, 256U);
7398
7399		sdebug_unmap_granularity =
7400			clamp(sdebug_unmap_granularity, 1U, 0xffffffffU);
7401
7402		if (sdebug_unmap_alignment &&
7403		    sdebug_unmap_granularity <=
7404		    sdebug_unmap_alignment) {
7405			pr_err("ERR: unmap_granularity <= unmap_alignment\n");
7406			return -EINVAL;
 
7407		}
7408	}
7409	xa_init_flags(per_store_ap, XA_FLAGS_ALLOC | XA_FLAGS_LOCK_IRQ);
7410	if (want_store) {
7411		idx = sdebug_add_store();
7412		if (idx < 0)
7413			return idx;
 
 
7414	}
7415
7416	pseudo_primary = root_device_register("pseudo_0");
7417	if (IS_ERR(pseudo_primary)) {
7418		pr_warn("root_device_register() error\n");
7419		ret = PTR_ERR(pseudo_primary);
7420		goto free_vm;
7421	}
7422	ret = bus_register(&pseudo_lld_bus);
7423	if (ret < 0) {
7424		pr_warn("bus_register error: %d\n", ret);
7425		goto dev_unreg;
7426	}
7427	ret = driver_register(&sdebug_driverfs_driver);
7428	if (ret < 0) {
7429		pr_warn("driver_register error: %d\n", ret);
7430		goto bus_unreg;
7431	}
7432
7433	hosts_to_add = sdebug_add_host;
7434	sdebug_add_host = 0;
7435
7436	queued_cmd_cache = KMEM_CACHE(sdebug_queued_cmd, SLAB_HWCACHE_ALIGN);
7437	if (!queued_cmd_cache) {
7438		ret = -ENOMEM;
7439		goto driver_unreg;
7440	}
7441
7442	sdebug_debugfs_root = debugfs_create_dir("scsi_debug", NULL);
7443	if (IS_ERR_OR_NULL(sdebug_debugfs_root))
7444		pr_info("%s: failed to create initial debugfs directory\n", __func__);
7445
7446	for (k = 0; k < hosts_to_add; k++) {
7447		if (want_store && k == 0) {
7448			ret = sdebug_add_host_helper(idx);
7449			if (ret < 0) {
7450				pr_err("add_host_helper k=%d, error=%d\n",
7451				       k, -ret);
7452				break;
7453			}
7454		} else {
7455			ret = sdebug_do_add_host(want_store &&
7456						 sdebug_per_host_store);
7457			if (ret < 0) {
7458				pr_err("add_host k=%d error=%d\n", k, -ret);
7459				break;
7460			}
7461		}
7462	}
7463	if (sdebug_verbose)
7464		pr_info("built %d host(s)\n", sdebug_num_hosts);
7465
7466	return 0;
7467
7468driver_unreg:
7469	driver_unregister(&sdebug_driverfs_driver);
7470bus_unreg:
7471	bus_unregister(&pseudo_lld_bus);
7472dev_unreg:
7473	root_device_unregister(pseudo_primary);
7474free_vm:
7475	sdebug_erase_store(idx, NULL);
 
 
7476	return ret;
7477}
7478
7479static void __exit scsi_debug_exit(void)
7480{
7481	int k = sdebug_num_hosts;
7482
 
7483	for (; k; k--)
7484		sdebug_do_remove_host(true);
7485	kmem_cache_destroy(queued_cmd_cache);
7486	driver_unregister(&sdebug_driverfs_driver);
7487	bus_unregister(&pseudo_lld_bus);
7488	root_device_unregister(pseudo_primary);
7489
7490	sdebug_erase_all_stores(false);
7491	xa_destroy(per_store_ap);
7492	debugfs_remove(sdebug_debugfs_root);
7493}
7494
7495device_initcall(scsi_debug_init);
7496module_exit(scsi_debug_exit);
7497
7498static void sdebug_release_adapter(struct device *dev)
7499{
7500	struct sdebug_host_info *sdbg_host;
7501
7502	sdbg_host = dev_to_sdebug_host(dev);
7503	kfree(sdbg_host);
7504}
7505
7506/* idx must be valid, if sip is NULL then it will be obtained using idx */
7507static void sdebug_erase_store(int idx, struct sdeb_store_info *sip)
7508{
7509	if (idx < 0)
7510		return;
7511	if (!sip) {
7512		if (xa_empty(per_store_ap))
7513			return;
7514		sip = xa_load(per_store_ap, idx);
7515		if (!sip)
7516			return;
7517	}
7518	vfree(sip->map_storep);
7519	vfree(sip->dif_storep);
7520	vfree(sip->storep);
7521	xa_erase(per_store_ap, idx);
7522	kfree(sip);
7523}
7524
7525/* Assume apart_from_first==false only in shutdown case. */
7526static void sdebug_erase_all_stores(bool apart_from_first)
7527{
7528	unsigned long idx;
7529	struct sdeb_store_info *sip = NULL;
7530
7531	xa_for_each(per_store_ap, idx, sip) {
7532		if (apart_from_first)
7533			apart_from_first = false;
7534		else
7535			sdebug_erase_store(idx, sip);
7536	}
7537	if (apart_from_first)
7538		sdeb_most_recent_idx = sdeb_first_idx;
7539}
7540
7541/*
7542 * Returns store xarray new element index (idx) if >=0 else negated errno.
7543 * Limit the number of stores to 65536.
7544 */
7545static int sdebug_add_store(void)
7546{
7547	int res;
7548	u32 n_idx;
7549	unsigned long iflags;
7550	unsigned long sz = (unsigned long)sdebug_dev_size_mb * 1048576;
7551	struct sdeb_store_info *sip = NULL;
7552	struct xa_limit xal = { .max = 1 << 16, .min = 0 };
7553
7554	sip = kzalloc(sizeof(*sip), GFP_KERNEL);
7555	if (!sip)
7556		return -ENOMEM;
7557
7558	xa_lock_irqsave(per_store_ap, iflags);
7559	res = __xa_alloc(per_store_ap, &n_idx, sip, xal, GFP_ATOMIC);
7560	if (unlikely(res < 0)) {
7561		xa_unlock_irqrestore(per_store_ap, iflags);
7562		kfree(sip);
7563		pr_warn("%s: xa_alloc() errno=%d\n", __func__, -res);
7564		return res;
7565	}
7566	sdeb_most_recent_idx = n_idx;
7567	if (sdeb_first_idx < 0)
7568		sdeb_first_idx = n_idx;
7569	xa_unlock_irqrestore(per_store_ap, iflags);
7570
7571	res = -ENOMEM;
7572	sip->storep = vzalloc(sz);
7573	if (!sip->storep) {
7574		pr_err("user data oom\n");
7575		goto err;
7576	}
7577	if (sdebug_num_parts > 0)
7578		sdebug_build_parts(sip->storep, sz);
7579
7580	/* DIF/DIX: what T10 calls Protection Information (PI) */
7581	if (sdebug_dix) {
7582		int dif_size;
7583
7584		dif_size = sdebug_store_sectors * sizeof(struct t10_pi_tuple);
7585		sip->dif_storep = vmalloc(dif_size);
7586
7587		pr_info("dif_storep %u bytes @ %pK\n", dif_size,
7588			sip->dif_storep);
7589
7590		if (!sip->dif_storep) {
7591			pr_err("DIX oom\n");
7592			goto err;
7593		}
7594		memset(sip->dif_storep, 0xff, dif_size);
7595	}
7596	/* Logical Block Provisioning */
7597	if (scsi_debug_lbp()) {
7598		map_size = lba_to_map_index(sdebug_store_sectors - 1) + 1;
7599		sip->map_storep = vmalloc(array_size(sizeof(long),
7600						     BITS_TO_LONGS(map_size)));
7601
7602		pr_info("%lu provisioning blocks\n", map_size);
7603
7604		if (!sip->map_storep) {
7605			pr_err("LBP map oom\n");
7606			goto err;
7607		}
7608
7609		bitmap_zero(sip->map_storep, map_size);
7610
7611		/* Map first 1KB for partition table */
7612		if (sdebug_num_parts)
7613			map_region(sip, 0, 2);
7614	}
7615
7616	rwlock_init(&sip->macc_lck);
7617	return (int)n_idx;
7618err:
7619	sdebug_erase_store((int)n_idx, sip);
7620	pr_warn("%s: failed, errno=%d\n", __func__, -res);
7621	return res;
7622}
7623
7624static int sdebug_add_host_helper(int per_host_idx)
7625{
7626	int k, devs_per_host, idx;
7627	int error = -ENOMEM;
7628	struct sdebug_host_info *sdbg_host;
7629	struct sdebug_dev_info *sdbg_devinfo, *tmp;
7630
7631	sdbg_host = kzalloc(sizeof(*sdbg_host), GFP_KERNEL);
7632	if (!sdbg_host)
7633		return -ENOMEM;
7634	idx = (per_host_idx < 0) ? sdeb_first_idx : per_host_idx;
7635	if (xa_get_mark(per_store_ap, idx, SDEB_XA_NOT_IN_USE))
7636		xa_clear_mark(per_store_ap, idx, SDEB_XA_NOT_IN_USE);
7637	sdbg_host->si_idx = idx;
7638
7639	INIT_LIST_HEAD(&sdbg_host->dev_info_list);
7640
7641	devs_per_host = sdebug_num_tgts * sdebug_max_luns;
7642	for (k = 0; k < devs_per_host; k++) {
7643		sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL);
7644		if (!sdbg_devinfo)
7645			goto clean;
7646	}
7647
7648	mutex_lock(&sdebug_host_list_mutex);
7649	list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
7650	mutex_unlock(&sdebug_host_list_mutex);
7651
7652	sdbg_host->dev.bus = &pseudo_lld_bus;
7653	sdbg_host->dev.parent = pseudo_primary;
7654	sdbg_host->dev.release = &sdebug_release_adapter;
7655	dev_set_name(&sdbg_host->dev, "adapter%d", sdebug_num_hosts);
7656
7657	error = device_register(&sdbg_host->dev);
7658	if (error) {
7659		mutex_lock(&sdebug_host_list_mutex);
7660		list_del(&sdbg_host->host_list);
7661		mutex_unlock(&sdebug_host_list_mutex);
7662		goto clean;
7663	}
7664
7665	++sdebug_num_hosts;
7666	return 0;
7667
7668clean:
7669	list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
7670				 dev_list) {
7671		list_del(&sdbg_devinfo->dev_list);
7672		kfree(sdbg_devinfo->zstate);
7673		kfree(sdbg_devinfo);
7674	}
7675	if (sdbg_host->dev.release)
7676		put_device(&sdbg_host->dev);
7677	else
7678		kfree(sdbg_host);
7679	pr_warn("%s: failed, errno=%d\n", __func__, -error);
7680	return error;
7681}
7682
7683static int sdebug_do_add_host(bool mk_new_store)
7684{
7685	int ph_idx = sdeb_most_recent_idx;
7686
7687	if (mk_new_store) {
7688		ph_idx = sdebug_add_store();
7689		if (ph_idx < 0)
7690			return ph_idx;
7691	}
7692	return sdebug_add_host_helper(ph_idx);
7693}
7694
7695static void sdebug_do_remove_host(bool the_end)
7696{
7697	int idx = -1;
7698	struct sdebug_host_info *sdbg_host = NULL;
7699	struct sdebug_host_info *sdbg_host2;
7700
7701	mutex_lock(&sdebug_host_list_mutex);
7702	if (!list_empty(&sdebug_host_list)) {
7703		sdbg_host = list_entry(sdebug_host_list.prev,
7704				       struct sdebug_host_info, host_list);
7705		idx = sdbg_host->si_idx;
7706	}
7707	if (!the_end && idx >= 0) {
7708		bool unique = true;
7709
7710		list_for_each_entry(sdbg_host2, &sdebug_host_list, host_list) {
7711			if (sdbg_host2 == sdbg_host)
7712				continue;
7713			if (idx == sdbg_host2->si_idx) {
7714				unique = false;
7715				break;
7716			}
7717		}
7718		if (unique) {
7719			xa_set_mark(per_store_ap, idx, SDEB_XA_NOT_IN_USE);
7720			if (idx == sdeb_most_recent_idx)
7721				--sdeb_most_recent_idx;
7722		}
7723	}
7724	if (sdbg_host)
7725		list_del(&sdbg_host->host_list);
7726	mutex_unlock(&sdebug_host_list_mutex);
7727
7728	if (!sdbg_host)
7729		return;
7730
7731	device_unregister(&sdbg_host->dev);
7732	--sdebug_num_hosts;
7733}
7734
7735static int sdebug_change_qdepth(struct scsi_device *sdev, int qdepth)
7736{
7737	struct sdebug_dev_info *devip = sdev->hostdata;
 
7738
7739	if (!devip)
 
 
 
7740		return	-ENODEV;
 
 
7741
7742	mutex_lock(&sdebug_host_list_mutex);
7743	block_unblock_all_queues(true);
7744
7745	if (qdepth > SDEBUG_CANQUEUE) {
7746		qdepth = SDEBUG_CANQUEUE;
7747		pr_warn("%s: requested qdepth [%d] exceeds canqueue [%d], trim\n", __func__,
7748			qdepth, SDEBUG_CANQUEUE);
7749	}
7750	if (qdepth < 1)
7751		qdepth = 1;
7752	if (qdepth != sdev->queue_depth)
7753		scsi_change_queue_depth(sdev, qdepth);
7754
 
 
 
 
 
 
7755	block_unblock_all_queues(false);
7756	mutex_unlock(&sdebug_host_list_mutex);
7757
7758	if (SDEBUG_OPT_Q_NOISE & sdebug_opts)
7759		sdev_printk(KERN_INFO, sdev, "%s: qdepth=%d\n", __func__, qdepth);
7760
7761	return sdev->queue_depth;
7762}
7763
7764static bool fake_timeout(struct scsi_cmnd *scp)
7765{
7766	if (0 == (atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth))) {
7767		if (sdebug_every_nth < -1)
7768			sdebug_every_nth = -1;
7769		if (SDEBUG_OPT_TIMEOUT & sdebug_opts)
7770			return true; /* ignore command causing timeout */
7771		else if (SDEBUG_OPT_MAC_TIMEOUT & sdebug_opts &&
7772			 scsi_medium_access_command(scp))
7773			return true; /* time out reads and writes */
7774	}
7775	return false;
7776}
7777
7778/* Response to TUR or media access command when device stopped */
7779static int resp_not_ready(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
7780{
7781	int stopped_state;
7782	u64 diff_ns = 0;
7783	ktime_t now_ts = ktime_get_boottime();
7784	struct scsi_device *sdp = scp->device;
7785
7786	stopped_state = atomic_read(&devip->stopped);
7787	if (stopped_state == 2) {
7788		if (ktime_to_ns(now_ts) > ktime_to_ns(devip->create_ts)) {
7789			diff_ns = ktime_to_ns(ktime_sub(now_ts, devip->create_ts));
7790			if (diff_ns >= ((u64)sdeb_tur_ms_to_ready * 1000000)) {
7791				/* tur_ms_to_ready timer extinguished */
7792				atomic_set(&devip->stopped, 0);
7793				return 0;
7794			}
7795		}
7796		mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x1);
7797		if (sdebug_verbose)
7798			sdev_printk(KERN_INFO, sdp,
7799				    "%s: Not ready: in process of becoming ready\n", my_name);
7800		if (scp->cmnd[0] == TEST_UNIT_READY) {
7801			u64 tur_nanosecs_to_ready = (u64)sdeb_tur_ms_to_ready * 1000000;
7802
7803			if (diff_ns <= tur_nanosecs_to_ready)
7804				diff_ns = tur_nanosecs_to_ready - diff_ns;
7805			else
7806				diff_ns = tur_nanosecs_to_ready;
7807			/* As per 20-061r2 approved for spc6 by T10 on 20200716 */
7808			do_div(diff_ns, 1000000);	/* diff_ns becomes milliseconds */
7809			scsi_set_sense_information(scp->sense_buffer, SCSI_SENSE_BUFFERSIZE,
7810						   diff_ns);
7811			return check_condition_result;
7812		}
7813	}
7814	mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x2);
7815	if (sdebug_verbose)
7816		sdev_printk(KERN_INFO, sdp, "%s: Not ready: initializing command required\n",
7817			    my_name);
7818	return check_condition_result;
7819}
7820
7821static void sdebug_map_queues(struct Scsi_Host *shost)
7822{
7823	int i, qoff;
7824
7825	if (shost->nr_hw_queues == 1)
7826		return;
7827
7828	for (i = 0, qoff = 0; i < HCTX_MAX_TYPES; i++) {
7829		struct blk_mq_queue_map *map = &shost->tag_set.map[i];
7830
7831		map->nr_queues  = 0;
7832
7833		if (i == HCTX_TYPE_DEFAULT)
7834			map->nr_queues = submit_queues - poll_queues;
7835		else if (i == HCTX_TYPE_POLL)
7836			map->nr_queues = poll_queues;
7837
7838		if (!map->nr_queues) {
7839			BUG_ON(i == HCTX_TYPE_DEFAULT);
7840			continue;
7841		}
7842
7843		map->queue_offset = qoff;
7844		blk_mq_map_queues(map);
7845
7846		qoff += map->nr_queues;
7847	}
7848}
7849
7850struct sdebug_blk_mq_poll_data {
7851	unsigned int queue_num;
7852	int *num_entries;
7853};
7854
7855/*
7856 * We don't handle aborted commands here, but it does not seem possible to have
7857 * aborted polled commands from schedule_resp()
7858 */
7859static bool sdebug_blk_mq_poll_iter(struct request *rq, void *opaque)
7860{
7861	struct sdebug_blk_mq_poll_data *data = opaque;
7862	struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq);
7863	struct sdebug_scsi_cmd *sdsc = scsi_cmd_priv(cmd);
7864	struct sdebug_defer *sd_dp;
7865	u32 unique_tag = blk_mq_unique_tag(rq);
7866	u16 hwq = blk_mq_unique_tag_to_hwq(unique_tag);
7867	struct sdebug_queued_cmd *sqcp;
7868	unsigned long flags;
7869	int queue_num = data->queue_num;
7870	ktime_t time;
7871
7872	/* We're only interested in one queue for this iteration */
7873	if (hwq != queue_num)
7874		return true;
7875
7876	/* Subsequent checks would fail if this failed, but check anyway */
7877	if (!test_bit(SCMD_STATE_INFLIGHT, &cmd->state))
7878		return true;
7879
7880	time = ktime_get_boottime();
7881
7882	spin_lock_irqsave(&sdsc->lock, flags);
7883	sqcp = TO_QUEUED_CMD(cmd);
7884	if (!sqcp) {
7885		spin_unlock_irqrestore(&sdsc->lock, flags);
7886		return true;
7887	}
7888
7889	sd_dp = &sqcp->sd_dp;
7890	if (READ_ONCE(sd_dp->defer_t) != SDEB_DEFER_POLL) {
7891		spin_unlock_irqrestore(&sdsc->lock, flags);
7892		return true;
7893	}
7894
7895	if (time < sd_dp->cmpl_ts) {
7896		spin_unlock_irqrestore(&sdsc->lock, flags);
7897		return true;
7898	}
7899
7900	ASSIGN_QUEUED_CMD(cmd, NULL);
7901	spin_unlock_irqrestore(&sdsc->lock, flags);
7902
7903	if (sdebug_statistics) {
7904		atomic_inc(&sdebug_completions);
7905		if (raw_smp_processor_id() != sd_dp->issuing_cpu)
7906			atomic_inc(&sdebug_miss_cpus);
7907	}
7908
7909	sdebug_free_queued_cmd(sqcp);
7910
7911	scsi_done(cmd); /* callback to mid level */
7912	(*data->num_entries)++;
7913	return true;
7914}
7915
7916static int sdebug_blk_mq_poll(struct Scsi_Host *shost, unsigned int queue_num)
7917{
7918	int num_entries = 0;
7919	struct sdebug_blk_mq_poll_data data = {
7920		.queue_num = queue_num,
7921		.num_entries = &num_entries,
7922	};
7923
7924	blk_mq_tagset_busy_iter(&shost->tag_set, sdebug_blk_mq_poll_iter,
7925				&data);
7926
7927	if (num_entries > 0)
7928		atomic_add(num_entries, &sdeb_mq_poll_count);
7929	return num_entries;
7930}
7931
7932static int sdebug_timeout_cmd(struct scsi_cmnd *cmnd)
7933{
7934	struct scsi_device *sdp = cmnd->device;
7935	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
7936	struct sdebug_err_inject *err;
7937	unsigned char *cmd = cmnd->cmnd;
7938	int ret = 0;
7939
7940	if (devip == NULL)
7941		return 0;
7942
7943	rcu_read_lock();
7944	list_for_each_entry_rcu(err, &devip->inject_err_list, list) {
7945		if (err->type == ERR_TMOUT_CMD &&
7946		    (err->cmd == cmd[0] || err->cmd == 0xff)) {
7947			ret = !!err->cnt;
7948			if (err->cnt < 0)
7949				err->cnt++;
7950
7951			rcu_read_unlock();
7952			return ret;
7953		}
7954	}
7955	rcu_read_unlock();
7956
7957	return 0;
7958}
7959
7960static int sdebug_fail_queue_cmd(struct scsi_cmnd *cmnd)
7961{
7962	struct scsi_device *sdp = cmnd->device;
7963	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
7964	struct sdebug_err_inject *err;
7965	unsigned char *cmd = cmnd->cmnd;
7966	int ret = 0;
7967
7968	if (devip == NULL)
7969		return 0;
7970
7971	rcu_read_lock();
7972	list_for_each_entry_rcu(err, &devip->inject_err_list, list) {
7973		if (err->type == ERR_FAIL_QUEUE_CMD &&
7974		    (err->cmd == cmd[0] || err->cmd == 0xff)) {
7975			ret = err->cnt ? err->queuecmd_ret : 0;
7976			if (err->cnt < 0)
7977				err->cnt++;
7978
7979			rcu_read_unlock();
7980			return ret;
7981		}
7982	}
7983	rcu_read_unlock();
7984
7985	return 0;
7986}
7987
7988static int sdebug_fail_cmd(struct scsi_cmnd *cmnd, int *retval,
7989			   struct sdebug_err_inject *info)
7990{
7991	struct scsi_device *sdp = cmnd->device;
7992	struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
7993	struct sdebug_err_inject *err;
7994	unsigned char *cmd = cmnd->cmnd;
7995	int ret = 0;
7996	int result;
7997
7998	if (devip == NULL)
7999		return 0;
8000
8001	rcu_read_lock();
8002	list_for_each_entry_rcu(err, &devip->inject_err_list, list) {
8003		if (err->type == ERR_FAIL_CMD &&
8004		    (err->cmd == cmd[0] || err->cmd == 0xff)) {
8005			if (!err->cnt) {
8006				rcu_read_unlock();
8007				return 0;
8008			}
8009
8010			ret = !!err->cnt;
8011			rcu_read_unlock();
8012			goto out_handle;
8013		}
8014	}
8015	rcu_read_unlock();
8016
8017	return 0;
8018
8019out_handle:
8020	if (err->cnt < 0)
8021		err->cnt++;
8022	mk_sense_buffer(cmnd, err->sense_key, err->asc, err->asq);
8023	result = err->status_byte | err->host_byte << 16 | err->driver_byte << 24;
8024	*info = *err;
8025	*retval = schedule_resp(cmnd, devip, result, NULL, 0, 0);
8026
8027	return ret;
8028}
8029
8030static int scsi_debug_queuecommand(struct Scsi_Host *shost,
8031				   struct scsi_cmnd *scp)
8032{
8033	u8 sdeb_i;
8034	struct scsi_device *sdp = scp->device;
8035	const struct opcode_info_t *oip;
8036	const struct opcode_info_t *r_oip;
8037	struct sdebug_dev_info *devip;
8038	u8 *cmd = scp->cmnd;
8039	int (*r_pfp)(struct scsi_cmnd *, struct sdebug_dev_info *);
8040	int (*pfp)(struct scsi_cmnd *, struct sdebug_dev_info *) = NULL;
8041	int k, na;
8042	int errsts = 0;
8043	u64 lun_index = sdp->lun & 0x3FFF;
8044	u32 flags;
8045	u16 sa;
8046	u8 opcode = cmd[0];
8047	bool has_wlun_rl;
8048	bool inject_now;
8049	int ret = 0;
8050	struct sdebug_err_inject err;
8051
8052	scsi_set_resid(scp, 0);
8053	if (sdebug_statistics) {
8054		atomic_inc(&sdebug_cmnd_count);
8055		inject_now = inject_on_this_cmd();
8056	} else {
8057		inject_now = false;
8058	}
8059	if (unlikely(sdebug_verbose &&
8060		     !(SDEBUG_OPT_NO_CDB_NOISE & sdebug_opts))) {
8061		char b[120];
8062		int n, len, sb;
8063
8064		len = scp->cmd_len;
8065		sb = (int)sizeof(b);
8066		if (len > 32)
8067			strcpy(b, "too long, over 32 bytes");
8068		else {
8069			for (k = 0, n = 0; k < len && n < sb; ++k)
8070				n += scnprintf(b + n, sb - n, "%02x ",
8071					       (u32)cmd[k]);
8072		}
8073		sdev_printk(KERN_INFO, sdp, "%s: tag=%#x, cmd %s\n", my_name,
8074			    blk_mq_unique_tag(scsi_cmd_to_rq(scp)), b);
8075	}
8076	if (unlikely(inject_now && (sdebug_opts & SDEBUG_OPT_HOST_BUSY)))
8077		return SCSI_MLQUEUE_HOST_BUSY;
8078	has_wlun_rl = (sdp->lun == SCSI_W_LUN_REPORT_LUNS);
8079	if (unlikely(lun_index >= sdebug_max_luns && !has_wlun_rl))
8080		goto err_out;
8081
8082	sdeb_i = opcode_ind_arr[opcode];	/* fully mapped */
8083	oip = &opcode_info_arr[sdeb_i];		/* safe if table consistent */
8084	devip = (struct sdebug_dev_info *)sdp->hostdata;
8085	if (unlikely(!devip)) {
8086		devip = find_build_dev_info(sdp);
8087		if (NULL == devip)
8088			goto err_out;
8089	}
8090
8091	if (sdebug_timeout_cmd(scp)) {
8092		scmd_printk(KERN_INFO, scp, "timeout command 0x%x\n", opcode);
8093		return 0;
8094	}
8095
8096	ret = sdebug_fail_queue_cmd(scp);
8097	if (ret) {
8098		scmd_printk(KERN_INFO, scp, "fail queue command 0x%x with 0x%x\n",
8099				opcode, ret);
8100		return ret;
8101	}
8102
8103	if (sdebug_fail_cmd(scp, &ret, &err)) {
8104		scmd_printk(KERN_INFO, scp,
8105			"fail command 0x%x with hostbyte=0x%x, "
8106			"driverbyte=0x%x, statusbyte=0x%x, "
8107			"sense_key=0x%x, asc=0x%x, asq=0x%x\n",
8108			opcode, err.host_byte, err.driver_byte,
8109			err.status_byte, err.sense_key, err.asc, err.asq);
8110		return ret;
8111	}
8112
8113	if (unlikely(inject_now && !atomic_read(&sdeb_inject_pending)))
8114		atomic_set(&sdeb_inject_pending, 1);
8115
8116	na = oip->num_attached;
8117	r_pfp = oip->pfp;
8118	if (na) {	/* multiple commands with this opcode */
8119		r_oip = oip;
8120		if (FF_SA & r_oip->flags) {
8121			if (F_SA_LOW & oip->flags)
8122				sa = 0x1f & cmd[1];
8123			else
8124				sa = get_unaligned_be16(cmd + 8);
8125			for (k = 0; k <= na; oip = r_oip->arrp + k++) {
8126				if (opcode == oip->opcode && sa == oip->sa)
8127					break;
8128			}
8129		} else {   /* since no service action only check opcode */
8130			for (k = 0; k <= na; oip = r_oip->arrp + k++) {
8131				if (opcode == oip->opcode)
8132					break;
8133			}
8134		}
8135		if (k > na) {
8136			if (F_SA_LOW & r_oip->flags)
8137				mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 4);
8138			else if (F_SA_HIGH & r_oip->flags)
8139				mk_sense_invalid_fld(scp, SDEB_IN_CDB, 8, 7);
8140			else
8141				mk_sense_invalid_opcode(scp);
8142			goto check_cond;
8143		}
8144	}	/* else (when na==0) we assume the oip is a match */
8145	flags = oip->flags;
8146	if (unlikely(F_INV_OP & flags)) {
8147		mk_sense_invalid_opcode(scp);
8148		goto check_cond;
8149	}
8150	if (unlikely(has_wlun_rl && !(F_RL_WLUN_OK & flags))) {
8151		if (sdebug_verbose)
8152			sdev_printk(KERN_INFO, sdp, "%s: Opcode 0x%x not%s\n",
8153				    my_name, opcode, " supported for wlun");
8154		mk_sense_invalid_opcode(scp);
8155		goto check_cond;
8156	}
8157	if (unlikely(sdebug_strict)) {	/* check cdb against mask */
8158		u8 rem;
8159		int j;
8160
8161		for (k = 1; k < oip->len_mask[0] && k < 16; ++k) {
8162			rem = ~oip->len_mask[k] & cmd[k];
8163			if (rem) {
8164				for (j = 7; j >= 0; --j, rem <<= 1) {
8165					if (0x80 & rem)
8166						break;
8167				}
8168				mk_sense_invalid_fld(scp, SDEB_IN_CDB, k, j);
8169				goto check_cond;
8170			}
8171		}
8172	}
8173	if (unlikely(!(F_SKIP_UA & flags) &&
8174		     find_first_bit(devip->uas_bm,
8175				    SDEBUG_NUM_UAS) != SDEBUG_NUM_UAS)) {
8176		errsts = make_ua(scp, devip);
8177		if (errsts)
8178			goto check_cond;
8179	}
8180	if (unlikely(((F_M_ACCESS & flags) || scp->cmnd[0] == TEST_UNIT_READY) &&
8181		     atomic_read(&devip->stopped))) {
8182		errsts = resp_not_ready(scp, devip);
8183		if (errsts)
8184			goto fini;
8185	}
8186	if (sdebug_fake_rw && (F_FAKE_RW & flags))
8187		goto fini;
8188	if (unlikely(sdebug_every_nth)) {
8189		if (fake_timeout(scp))
8190			return 0;	/* ignore command: make trouble */
8191	}
8192	if (likely(oip->pfp))
8193		pfp = oip->pfp;	/* calls a resp_* function */
8194	else
8195		pfp = r_pfp;    /* if leaf function ptr NULL, try the root's */
8196
8197fini:
8198	if (F_DELAY_OVERR & flags)	/* cmds like INQUIRY respond asap */
8199		return schedule_resp(scp, devip, errsts, pfp, 0, 0);
8200	else if ((flags & F_LONG_DELAY) && (sdebug_jdelay > 0 ||
8201					    sdebug_ndelay > 10000)) {
8202		/*
8203		 * Skip long delays if ndelay <= 10 microseconds. Otherwise
8204		 * for Start Stop Unit (SSU) want at least 1 second delay and
8205		 * if sdebug_jdelay>1 want a long delay of that many seconds.
8206		 * For Synchronize Cache want 1/20 of SSU's delay.
8207		 */
8208		int jdelay = (sdebug_jdelay < 2) ? 1 : sdebug_jdelay;
8209		int denom = (flags & F_SYNC_DELAY) ? 20 : 1;
8210
8211		jdelay = mult_frac(USER_HZ * jdelay, HZ, denom * USER_HZ);
8212		return schedule_resp(scp, devip, errsts, pfp, jdelay, 0);
8213	} else
8214		return schedule_resp(scp, devip, errsts, pfp, sdebug_jdelay,
8215				     sdebug_ndelay);
8216check_cond:
8217	return schedule_resp(scp, devip, check_condition_result, NULL, 0, 0);
8218err_out:
8219	return schedule_resp(scp, NULL, DID_NO_CONNECT << 16, NULL, 0, 0);
8220}
8221
8222static int sdebug_init_cmd_priv(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
8223{
8224	struct sdebug_scsi_cmd *sdsc = scsi_cmd_priv(cmd);
8225
8226	spin_lock_init(&sdsc->lock);
8227
8228	return 0;
8229}
8230
8231static struct scsi_host_template sdebug_driver_template = {
8232	.show_info =		scsi_debug_show_info,
8233	.write_info =		scsi_debug_write_info,
8234	.proc_name =		sdebug_proc_name,
8235	.name =			"SCSI DEBUG",
8236	.info =			scsi_debug_info,
8237	.slave_alloc =		scsi_debug_slave_alloc,
8238	.slave_configure =	scsi_debug_slave_configure,
8239	.slave_destroy =	scsi_debug_slave_destroy,
8240	.ioctl =		scsi_debug_ioctl,
8241	.queuecommand =		scsi_debug_queuecommand,
8242	.change_queue_depth =	sdebug_change_qdepth,
8243	.map_queues =		sdebug_map_queues,
8244	.mq_poll =		sdebug_blk_mq_poll,
8245	.eh_abort_handler =	scsi_debug_abort,
8246	.eh_device_reset_handler = scsi_debug_device_reset,
8247	.eh_target_reset_handler = scsi_debug_target_reset,
8248	.eh_bus_reset_handler = scsi_debug_bus_reset,
8249	.eh_host_reset_handler = scsi_debug_host_reset,
8250	.can_queue =		SDEBUG_CANQUEUE,
8251	.this_id =		7,
8252	.sg_tablesize =		SG_MAX_SEGMENTS,
8253	.cmd_per_lun =		DEF_CMD_PER_LUN,
8254	.max_sectors =		-1U,
8255	.max_segment_size =	-1U,
8256	.module =		THIS_MODULE,
8257	.track_queue_depth =	1,
8258	.cmd_size = sizeof(struct sdebug_scsi_cmd),
8259	.init_cmd_priv = sdebug_init_cmd_priv,
8260	.target_alloc =		sdebug_target_alloc,
8261	.target_destroy =	sdebug_target_destroy,
8262};
8263
8264static int sdebug_driver_probe(struct device *dev)
8265{
8266	int error = 0;
8267	struct sdebug_host_info *sdbg_host;
8268	struct Scsi_Host *hpnt;
8269	int hprot;
8270
8271	sdbg_host = dev_to_sdebug_host(dev);
8272
8273	sdebug_driver_template.can_queue = sdebug_max_queue;
8274	sdebug_driver_template.cmd_per_lun = sdebug_max_queue;
 
 
8275	if (!sdebug_clustering)
8276		sdebug_driver_template.dma_boundary = PAGE_SIZE - 1;
8277
8278	hpnt = scsi_host_alloc(&sdebug_driver_template, 0);
8279	if (NULL == hpnt) {
8280		pr_err("scsi_host_alloc failed\n");
8281		error = -ENODEV;
8282		return error;
8283	}
8284	if (submit_queues > nr_cpu_ids) {
8285		pr_warn("%s: trim submit_queues (was %d) to nr_cpu_ids=%u\n",
8286			my_name, submit_queues, nr_cpu_ids);
8287		submit_queues = nr_cpu_ids;
8288	}
8289	/*
8290	 * Decide whether to tell scsi subsystem that we want mq. The
8291	 * following should give the same answer for each host.
8292	 */
8293	hpnt->nr_hw_queues = submit_queues;
8294	if (sdebug_host_max_queue)
8295		hpnt->host_tagset = 1;
8296
8297	/* poll queues are possible for nr_hw_queues > 1 */
8298	if (hpnt->nr_hw_queues == 1 || (poll_queues < 1)) {
8299		pr_warn("%s: trim poll_queues to 0. poll_q/nr_hw = (%d/%d)\n",
8300			 my_name, poll_queues, hpnt->nr_hw_queues);
8301		poll_queues = 0;
8302	}
8303
8304	/*
8305	 * Poll queues don't need interrupts, but we need at least one I/O queue
8306	 * left over for non-polled I/O.
8307	 * If condition not met, trim poll_queues to 1 (just for simplicity).
8308	 */
8309	if (poll_queues >= submit_queues) {
8310		if (submit_queues < 3)
8311			pr_warn("%s: trim poll_queues to 1\n", my_name);
8312		else
8313			pr_warn("%s: trim poll_queues to 1. Perhaps try poll_queues=%d\n",
8314				my_name, submit_queues - 1);
8315		poll_queues = 1;
8316	}
8317	if (poll_queues)
8318		hpnt->nr_maps = 3;
8319
8320	sdbg_host->shost = hpnt;
 
8321	if ((hpnt->this_id >= 0) && (sdebug_num_tgts > hpnt->this_id))
8322		hpnt->max_id = sdebug_num_tgts + 1;
8323	else
8324		hpnt->max_id = sdebug_num_tgts;
8325	/* = sdebug_max_luns; */
8326	hpnt->max_lun = SCSI_W_LUN_REPORT_LUNS + 1;
8327
8328	hprot = 0;
8329
8330	switch (sdebug_dif) {
8331
8332	case T10_PI_TYPE1_PROTECTION:
8333		hprot = SHOST_DIF_TYPE1_PROTECTION;
8334		if (sdebug_dix)
8335			hprot |= SHOST_DIX_TYPE1_PROTECTION;
8336		break;
8337
8338	case T10_PI_TYPE2_PROTECTION:
8339		hprot = SHOST_DIF_TYPE2_PROTECTION;
8340		if (sdebug_dix)
8341			hprot |= SHOST_DIX_TYPE2_PROTECTION;
8342		break;
8343
8344	case T10_PI_TYPE3_PROTECTION:
8345		hprot = SHOST_DIF_TYPE3_PROTECTION;
8346		if (sdebug_dix)
8347			hprot |= SHOST_DIX_TYPE3_PROTECTION;
8348		break;
8349
8350	default:
8351		if (sdebug_dix)
8352			hprot |= SHOST_DIX_TYPE0_PROTECTION;
8353		break;
8354	}
8355
8356	scsi_host_set_prot(hpnt, hprot);
8357
8358	if (have_dif_prot || sdebug_dix)
8359		pr_info("host protection%s%s%s%s%s%s%s\n",
8360			(hprot & SHOST_DIF_TYPE1_PROTECTION) ? " DIF1" : "",
8361			(hprot & SHOST_DIF_TYPE2_PROTECTION) ? " DIF2" : "",
8362			(hprot & SHOST_DIF_TYPE3_PROTECTION) ? " DIF3" : "",
8363			(hprot & SHOST_DIX_TYPE0_PROTECTION) ? " DIX0" : "",
8364			(hprot & SHOST_DIX_TYPE1_PROTECTION) ? " DIX1" : "",
8365			(hprot & SHOST_DIX_TYPE2_PROTECTION) ? " DIX2" : "",
8366			(hprot & SHOST_DIX_TYPE3_PROTECTION) ? " DIX3" : "");
8367
8368	if (sdebug_guard == 1)
8369		scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_IP);
8370	else
8371		scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_CRC);
8372
8373	sdebug_verbose = !!(SDEBUG_OPT_NOISE & sdebug_opts);
8374	sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & sdebug_opts);
8375	if (sdebug_every_nth)	/* need stats counters for every_nth */
8376		sdebug_statistics = true;
8377	error = scsi_add_host(hpnt, &sdbg_host->dev);
8378	if (error) {
8379		pr_err("scsi_add_host failed\n");
8380		error = -ENODEV;
8381		scsi_host_put(hpnt);
8382	} else {
8383		scsi_scan_host(hpnt);
8384	}
8385
8386	return error;
8387}
8388
8389static void sdebug_driver_remove(struct device *dev)
8390{
8391	struct sdebug_host_info *sdbg_host;
8392	struct sdebug_dev_info *sdbg_devinfo, *tmp;
8393
8394	sdbg_host = dev_to_sdebug_host(dev);
 
 
 
 
 
8395
8396	scsi_remove_host(sdbg_host->shost);
8397
8398	list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
8399				 dev_list) {
8400		list_del(&sdbg_devinfo->dev_list);
8401		kfree(sdbg_devinfo->zstate);
8402		kfree(sdbg_devinfo);
8403	}
8404
8405	scsi_host_put(sdbg_host->shost);
 
 
 
 
 
 
 
8406}
8407
8408static struct bus_type pseudo_lld_bus = {
8409	.name = "pseudo",
 
8410	.probe = sdebug_driver_probe,
8411	.remove = sdebug_driver_remove,
8412	.drv_groups = sdebug_drv_groups,
8413};