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