2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* vvvvvvvvvvvvvvvvvvvvvvv Original vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
|
|
|
|
* Copyright (C) 1992 Eric Youngdale
|
|
|
|
* Simulate a host adapter with 2 disks attached. Do a lot of checking
|
|
|
|
* to make sure that we are not getting blocks mixed up, and PANIC if
|
|
|
|
* anything out of the ordinary is seen.
|
|
|
|
* ^^^^^^^^^^^^^^^^^^^^^^^ Original ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
*
|
2018-02-10 02:36:39 +00:00
|
|
|
* Copyright (C) 2001 - 2018 Douglas Gilbert
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2016-04-25 16:16:28 +00:00
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
* any later version.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2010-03-25 21:29:05 +00:00
|
|
|
* For documentation see http://sg.danny.cz/sg/sdebug26.html
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2015-07-28 13:54:20 +00:00
|
|
|
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/module.h>
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
2016-04-25 16:16:30 +00:00
|
|
|
#include <linux/jiffies.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/genhd.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include <linux/moduleparam.h>
|
2007-07-16 08:19:24 +00:00
|
|
|
#include <linux/scatterlist.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/blkdev.h>
|
2009-01-04 08:08:19 +00:00
|
|
|
#include <linux/crc-t10dif.h>
|
2014-07-26 15:55:35 +00:00
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/atomic.h>
|
|
|
|
#include <linux/hrtimer.h>
|
2016-05-06 04:40:28 +00:00
|
|
|
#include <linux/uuid.h>
|
2016-09-11 17:35:39 +00:00
|
|
|
#include <linux/t10-pi.h>
|
2009-01-04 08:08:19 +00:00
|
|
|
|
|
|
|
#include <net/checksum.h>
|
2008-03-02 09:30:15 +00:00
|
|
|
|
2009-10-15 18:45:27 +00:00
|
|
|
#include <asm/unaligned.h>
|
|
|
|
|
2008-03-02 09:30:15 +00:00
|
|
|
#include <scsi/scsi.h>
|
|
|
|
#include <scsi/scsi_cmnd.h>
|
|
|
|
#include <scsi/scsi_device.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <scsi/scsi_host.h>
|
|
|
|
#include <scsi/scsicam.h>
|
2008-03-25 00:26:50 +00:00
|
|
|
#include <scsi/scsi_eh.h>
|
2014-07-26 15:55:35 +00:00
|
|
|
#include <scsi/scsi_tcq.h>
|
2009-09-18 21:33:03 +00:00
|
|
|
#include <scsi/scsi_dbg.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-01-04 08:08:19 +00:00
|
|
|
#include "sd.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "scsi_logging.h"
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
/* make sure inq_product_rev string corresponds to this version */
|
2018-02-10 02:36:39 +00:00
|
|
|
#define SDEBUG_VERSION "0188" /* format to fit INQUIRY revision field */
|
2019-01-25 17:46:09 +00:00
|
|
|
static const char *sdebug_version_date = "20190125";
|
2014-07-26 15:55:35 +00:00
|
|
|
|
|
|
|
#define MY_NAME "scsi_debug"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-01-05 05:05:25 +00:00
|
|
|
/* Additional Sense Code (ASC) */
|
2006-06-06 04:11:24 +00:00
|
|
|
#define NO_ADDITIONAL_SENSE 0x0
|
|
|
|
#define LOGICAL_UNIT_NOT_READY 0x4
|
2014-11-25 01:46:29 +00:00
|
|
|
#define LOGICAL_UNIT_COMMUNICATION_FAILURE 0x8
|
2005-04-16 22:20:36 +00:00
|
|
|
#define UNRECOVERED_READ_ERR 0x11
|
2006-06-06 04:11:24 +00:00
|
|
|
#define PARAMETER_LIST_LENGTH_ERR 0x1a
|
2005-04-16 22:20:36 +00:00
|
|
|
#define INVALID_OPCODE 0x20
|
2014-11-25 04:04:47 +00:00
|
|
|
#define LBA_OUT_OF_RANGE 0x21
|
2005-04-16 22:20:36 +00:00
|
|
|
#define INVALID_FIELD_IN_CDB 0x24
|
2006-06-06 04:11:24 +00:00
|
|
|
#define INVALID_FIELD_IN_PARAM_LIST 0x26
|
2019-02-08 23:37:25 +00:00
|
|
|
#define WRITE_PROTECTED 0x27
|
2014-07-26 15:55:35 +00:00
|
|
|
#define UA_RESET_ASC 0x29
|
|
|
|
#define UA_CHANGED_ASC 0x2a
|
2014-12-04 16:49:27 +00:00
|
|
|
#define TARGET_CHANGED_ASC 0x3f
|
|
|
|
#define LUNS_CHANGED_ASCQ 0x0e
|
2014-11-25 04:04:47 +00:00
|
|
|
#define INSUFF_RES_ASC 0x55
|
|
|
|
#define INSUFF_RES_ASCQ 0x3
|
2014-07-26 15:55:35 +00:00
|
|
|
#define POWER_ON_RESET_ASCQ 0x0
|
|
|
|
#define BUS_RESET_ASCQ 0x2 /* scsi bus reset occurred */
|
|
|
|
#define MODE_CHANGED_ASCQ 0x1 /* mode parameters changed */
|
2014-11-25 04:04:47 +00:00
|
|
|
#define CAPACITY_CHANGED_ASCQ 0x9
|
2005-04-16 22:20:36 +00:00
|
|
|
#define SAVING_PARAMS_UNSUP 0x39
|
2007-01-05 05:05:25 +00:00
|
|
|
#define TRANSPORT_PROBLEM 0x4b
|
2006-06-06 04:11:24 +00:00
|
|
|
#define THRESHOLD_EXCEEDED 0x5d
|
|
|
|
#define LOW_POWER_COND_ON 0x5e
|
2014-11-25 04:04:47 +00:00
|
|
|
#define MISCOMPARE_VERIFY_ASC 0x1d
|
2014-12-04 16:49:28 +00:00
|
|
|
#define MICROCODE_CHANGED_ASCQ 0x1 /* with TARGET_CHANGED_ASC */
|
|
|
|
#define MICROCODE_CHANGED_WO_RESET_ASCQ 0x16
|
2017-12-23 17:48:14 +00:00
|
|
|
#define WRITE_ERROR_ASC 0xc
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-01-05 05:05:25 +00:00
|
|
|
/* Additional Sense Code Qualifier (ASCQ) */
|
|
|
|
#define ACK_NAK_TO 0x3
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Default values for driver parameters */
|
|
|
|
#define DEF_NUM_HOST 1
|
|
|
|
#define DEF_NUM_TGTS 1
|
|
|
|
#define DEF_MAX_LUNS 1
|
|
|
|
/* With these defaults, this driver will make 1 host with 1 target
|
|
|
|
* (id 0) containing 1 logical unit (lun 0). That is 1 device.
|
|
|
|
*/
|
2011-03-08 07:08:11 +00:00
|
|
|
#define DEF_ATO 1
|
2017-12-05 05:05:49 +00:00
|
|
|
#define DEF_CDB_LEN 10
|
2016-04-25 16:16:31 +00:00
|
|
|
#define DEF_JDELAY 1 /* if > 0 unit is a jiffy */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define DEF_DEV_SIZE_MB 8
|
2011-03-08 07:08:11 +00:00
|
|
|
#define DEF_DIF 0
|
|
|
|
#define DEF_DIX 0
|
2005-04-16 22:20:36 +00:00
|
|
|
#define DEF_D_SENSE 0
|
2011-03-08 07:08:11 +00:00
|
|
|
#define DEF_EVERY_NTH 0
|
2006-09-17 00:30:47 +00:00
|
|
|
#define DEF_FAKE_RW 0
|
2009-01-04 08:08:19 +00:00
|
|
|
#define DEF_GUARD 0
|
2014-07-26 15:55:35 +00:00
|
|
|
#define DEF_HOST_LOCK 0
|
2011-03-08 07:08:11 +00:00
|
|
|
#define DEF_LBPU 0
|
|
|
|
#define DEF_LBPWS 0
|
|
|
|
#define DEF_LBPWS10 0
|
2012-03-08 06:03:59 +00:00
|
|
|
#define DEF_LBPRZ 1
|
2009-05-15 04:40:33 +00:00
|
|
|
#define DEF_LOWEST_ALIGNED 0
|
2014-07-26 15:55:35 +00:00
|
|
|
#define DEF_NDELAY 0 /* if > 0 unit is a nanosecond */
|
2011-03-08 07:08:11 +00:00
|
|
|
#define DEF_NO_LUN_0 0
|
|
|
|
#define DEF_NUM_PARTS 0
|
|
|
|
#define DEF_OPTS 0
|
2015-12-16 22:53:51 +00:00
|
|
|
#define DEF_OPT_BLKS 1024
|
2011-03-08 07:08:11 +00:00
|
|
|
#define DEF_PHYSBLK_EXP 0
|
2017-01-26 09:00:37 +00:00
|
|
|
#define DEF_OPT_XFERLEN_EXP 0
|
2016-05-01 02:44:42 +00:00
|
|
|
#define DEF_PTYPE TYPE_DISK
|
2012-09-06 10:04:33 +00:00
|
|
|
#define DEF_REMOVABLE false
|
2016-05-06 04:40:27 +00:00
|
|
|
#define DEF_SCSI_LEVEL 7 /* INQUIRY, byte2 [6->SPC-4; 7->SPC-5] */
|
2011-03-08 07:08:11 +00:00
|
|
|
#define DEF_SECTOR_SIZE 512
|
|
|
|
#define DEF_UNMAP_ALIGNMENT 0
|
|
|
|
#define DEF_UNMAP_GRANULARITY 1
|
2010-08-19 15:49:00 +00:00
|
|
|
#define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF
|
|
|
|
#define DEF_UNMAP_MAX_DESC 256
|
2011-03-08 07:08:11 +00:00
|
|
|
#define DEF_VIRTUAL_GB 0
|
|
|
|
#define DEF_VPD_USE_HOSTNO 1
|
|
|
|
#define DEF_WRITESAME_LENGTH 0xFFFF
|
2014-11-25 01:46:29 +00:00
|
|
|
#define DEF_STRICT 0
|
2016-05-06 04:40:26 +00:00
|
|
|
#define DEF_STATISTICS false
|
|
|
|
#define DEF_SUBMIT_QUEUES 1
|
2016-05-06 04:40:28 +00:00
|
|
|
#define DEF_UUID_CTL 0
|
2016-04-25 16:16:31 +00:00
|
|
|
#define JDELAY_OVERRIDDEN -9999
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-05-01 02:44:42 +00:00
|
|
|
#define SDEBUG_LUN_0_VAL 0
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
/* bit mask values for sdebug_opts */
|
|
|
|
#define SDEBUG_OPT_NOISE 1
|
|
|
|
#define SDEBUG_OPT_MEDIUM_ERR 2
|
|
|
|
#define SDEBUG_OPT_TIMEOUT 4
|
|
|
|
#define SDEBUG_OPT_RECOVERED_ERR 8
|
|
|
|
#define SDEBUG_OPT_TRANSPORT_ERR 16
|
|
|
|
#define SDEBUG_OPT_DIF_ERR 32
|
|
|
|
#define SDEBUG_OPT_DIX_ERR 64
|
|
|
|
#define SDEBUG_OPT_MAC_TIMEOUT 128
|
|
|
|
#define SDEBUG_OPT_SHORT_TRANSFER 0x100
|
|
|
|
#define SDEBUG_OPT_Q_NOISE 0x200
|
|
|
|
#define SDEBUG_OPT_ALL_TSF 0x400
|
|
|
|
#define SDEBUG_OPT_RARE_TSF 0x800
|
|
|
|
#define SDEBUG_OPT_N_WCE 0x1000
|
|
|
|
#define SDEBUG_OPT_RESET_NOISE 0x2000
|
|
|
|
#define SDEBUG_OPT_NO_CDB_NOISE 0x4000
|
2017-12-07 22:56:18 +00:00
|
|
|
#define SDEBUG_OPT_HOST_BUSY 0x8000
|
2018-07-21 05:10:04 +00:00
|
|
|
#define SDEBUG_OPT_CMD_ABORT 0x10000
|
2016-04-25 16:16:28 +00:00
|
|
|
#define SDEBUG_OPT_ALL_NOISE (SDEBUG_OPT_NOISE | SDEBUG_OPT_Q_NOISE | \
|
|
|
|
SDEBUG_OPT_RESET_NOISE)
|
|
|
|
#define SDEBUG_OPT_ALL_INJECTING (SDEBUG_OPT_RECOVERED_ERR | \
|
|
|
|
SDEBUG_OPT_TRANSPORT_ERR | \
|
|
|
|
SDEBUG_OPT_DIF_ERR | SDEBUG_OPT_DIX_ERR | \
|
2017-12-07 22:56:18 +00:00
|
|
|
SDEBUG_OPT_SHORT_TRANSFER | \
|
2018-07-21 05:10:04 +00:00
|
|
|
SDEBUG_OPT_HOST_BUSY | \
|
|
|
|
SDEBUG_OPT_CMD_ABORT)
|
2005-04-16 22:20:36 +00:00
|
|
|
/* When "every_nth" > 0 then modulo "every_nth" commands:
|
2016-04-25 16:16:33 +00:00
|
|
|
* - a missing response is simulated if SDEBUG_OPT_TIMEOUT is set
|
2005-04-16 22:20:36 +00:00
|
|
|
* - a RECOVERED_ERROR is simulated on successful read and write
|
2016-04-25 16:16:28 +00:00
|
|
|
* commands if SDEBUG_OPT_RECOVERED_ERR is set.
|
2007-01-05 05:05:25 +00:00
|
|
|
* - a TRANSPORT_ERROR is simulated on successful read and write
|
2016-04-25 16:16:28 +00:00
|
|
|
* commands if SDEBUG_OPT_TRANSPORT_ERR is set.
|
2018-07-21 05:10:04 +00:00
|
|
|
* - similarly for DIF_ERR, DIX_ERR, SHORT_TRANSFER, HOST_BUSY and
|
|
|
|
* CMD_ABORT
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2018-07-21 05:10:04 +00:00
|
|
|
* When "every_nth" < 0 then after "- every_nth" commands the selected
|
|
|
|
* error will be injected. The error will be injected on every subsequent
|
|
|
|
* command until some other action occurs; for example, the user writing
|
|
|
|
* a new value (other than -1 or 1) to every_nth:
|
|
|
|
* echo 0 > /sys/bus/pseudo/drivers/scsi_debug/every_nth
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
/* As indicated in SAM-5 and SPC-4 Unit Attentions (UAs) are returned in
|
2014-07-26 15:55:35 +00:00
|
|
|
* priority order. In the subset implemented here lower numbers have higher
|
|
|
|
* priority. The UA numbers should be a sequence starting from 0 with
|
|
|
|
* SDEBUG_NUM_UAS being 1 higher than the highest numbered UA. */
|
|
|
|
#define SDEBUG_UA_POR 0 /* Power on, reset, or bus device reset */
|
|
|
|
#define SDEBUG_UA_BUS_RESET 1
|
|
|
|
#define SDEBUG_UA_MODE_CHANGED 2
|
2014-11-25 01:27:51 +00:00
|
|
|
#define SDEBUG_UA_CAPACITY_CHANGED 3
|
2014-12-04 16:49:27 +00:00
|
|
|
#define SDEBUG_UA_LUNS_CHANGED 4
|
2014-12-04 16:49:28 +00:00
|
|
|
#define SDEBUG_UA_MICROCODE_CHANGED 5 /* simulate firmware change */
|
|
|
|
#define SDEBUG_UA_MICROCODE_CHANGED_WO_RESET 6
|
|
|
|
#define SDEBUG_NUM_UAS 7
|
2014-07-26 15:55:35 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
/* when 1==SDEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
|
2005-04-16 22:20:36 +00:00
|
|
|
* sector on read commands: */
|
|
|
|
#define OPT_MEDIUM_ERR_ADDR 0x1234 /* that's sector 4660 in decimal */
|
2011-03-11 15:43:35 +00:00
|
|
|
#define OPT_MEDIUM_ERR_NUM 10 /* number of consecutive medium errs */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* If REPORT LUNS has luns >= 256 it can choose "flat space" (value 1)
|
|
|
|
* or "peripheral device" addressing (value 0) */
|
|
|
|
#define SAM2_LUN_ADDRESS_METHOD 0
|
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
/* SDEBUG_CANQUEUE is the maximum number of commands that can be queued
|
|
|
|
* (for response) per submit queue at one time. Can be reduced by max_queue
|
|
|
|
* option. Command responses are not queued when jdelay=0 and ndelay=0. The
|
|
|
|
* per-device DEF_CMD_PER_LUN can be changed via sysfs:
|
|
|
|
* /sys/class/scsi_device/<h:c:t:l>/device/queue_depth
|
|
|
|
* but cannot exceed SDEBUG_CANQUEUE .
|
|
|
|
*/
|
|
|
|
#define SDEBUG_CANQUEUE_WORDS 3 /* a WORD is bits in a long */
|
|
|
|
#define SDEBUG_CANQUEUE (SDEBUG_CANQUEUE_WORDS * BITS_PER_LONG)
|
2014-07-26 15:55:35 +00:00
|
|
|
#define DEF_CMD_PER_LUN 255
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
#define F_D_IN 1
|
|
|
|
#define F_D_OUT 2
|
|
|
|
#define F_D_OUT_MAYBE 4 /* WRITE SAME, NDOB bit */
|
|
|
|
#define F_D_UNKN 8
|
|
|
|
#define F_RL_WLUN_OK 0x10
|
|
|
|
#define F_SKIP_UA 0x20
|
|
|
|
#define F_DELAY_OVERR 0x40
|
|
|
|
#define F_SA_LOW 0x80 /* cdb byte 1, bits 4 to 0 */
|
|
|
|
#define F_SA_HIGH 0x100 /* as used by variable length cdbs */
|
|
|
|
#define F_INV_OP 0x200
|
|
|
|
#define F_FAKE_RW 0x400
|
|
|
|
#define F_M_ACCESS 0x800 /* media access */
|
2018-04-10 17:00:36 +00:00
|
|
|
#define F_SSU_DELAY 0x1000
|
|
|
|
#define F_SYNC_DELAY 0x2000
|
2016-04-25 16:16:33 +00:00
|
|
|
|
|
|
|
#define FF_RESPOND (F_RL_WLUN_OK | F_SKIP_UA | F_DELAY_OVERR)
|
2017-12-23 17:48:13 +00:00
|
|
|
#define FF_MEDIA_IO (F_M_ACCESS | F_FAKE_RW)
|
2016-04-25 16:16:33 +00:00
|
|
|
#define FF_SA (F_SA_HIGH | F_SA_LOW)
|
2018-04-10 17:00:36 +00:00
|
|
|
#define F_LONG_DELAY (F_SSU_DELAY | F_SYNC_DELAY)
|
2016-04-25 16:16:33 +00:00
|
|
|
|
|
|
|
#define SDEBUG_MAX_PARTS 4
|
|
|
|
|
2016-05-01 02:44:42 +00:00
|
|
|
#define SDEBUG_MAX_CMD_LEN 32
|
2016-04-25 16:16:33 +00:00
|
|
|
|
|
|
|
|
|
|
|
struct sdebug_dev_info {
|
|
|
|
struct list_head dev_list;
|
|
|
|
unsigned int channel;
|
|
|
|
unsigned int target;
|
|
|
|
u64 lun;
|
2017-05-17 07:55:26 +00:00
|
|
|
uuid_t lu_name;
|
2016-04-25 16:16:33 +00:00
|
|
|
struct sdebug_host_info *sdbg_host;
|
|
|
|
unsigned long uas_bm[1];
|
|
|
|
atomic_t num_in_q;
|
2016-05-06 04:40:26 +00:00
|
|
|
atomic_t stopped;
|
2016-04-25 16:16:33 +00:00
|
|
|
bool used;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct sdebug_host_info {
|
|
|
|
struct list_head host_list;
|
|
|
|
struct Scsi_Host *shost;
|
|
|
|
struct device dev;
|
|
|
|
struct list_head dev_info_list;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define to_sdebug_host(d) \
|
|
|
|
container_of(d, struct sdebug_host_info, dev)
|
|
|
|
|
2018-01-10 21:57:31 +00:00
|
|
|
enum sdeb_defer_type {SDEB_DEFER_NONE = 0, SDEB_DEFER_HRT = 1,
|
|
|
|
SDEB_DEFER_WQ = 2};
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
struct sdebug_defer {
|
|
|
|
struct hrtimer hrt;
|
|
|
|
struct execute_work ew;
|
2016-05-06 04:40:26 +00:00
|
|
|
int sqa_idx; /* index of sdebug_queue array */
|
|
|
|
int qc_idx; /* index of sdebug_queued_cmd array within sqa_idx */
|
|
|
|
int issuing_cpu;
|
2018-01-10 21:57:31 +00:00
|
|
|
bool init_hrt;
|
|
|
|
bool init_wq;
|
2018-07-21 05:10:04 +00:00
|
|
|
bool aborted; /* true when blk_abort_request() already called */
|
2018-01-10 21:57:31 +00:00
|
|
|
enum sdeb_defer_type defer_t;
|
2016-04-25 16:16:33 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct sdebug_queued_cmd {
|
2016-05-06 04:40:26 +00:00
|
|
|
/* corresponding bit set in in_use_bm[] in owning struct sdebug_queue
|
|
|
|
* instance indicates this slot is in use.
|
|
|
|
*/
|
2016-04-25 16:16:33 +00:00
|
|
|
struct sdebug_defer *sd_dp;
|
|
|
|
struct scsi_cmnd *a_cmnd;
|
2016-05-06 04:40:26 +00:00
|
|
|
unsigned int inj_recovered:1;
|
|
|
|
unsigned int inj_transport:1;
|
|
|
|
unsigned int inj_dif:1;
|
|
|
|
unsigned int inj_dix:1;
|
|
|
|
unsigned int inj_short:1;
|
2017-12-07 22:56:18 +00:00
|
|
|
unsigned int inj_host_busy:1;
|
2018-07-21 05:10:04 +00:00
|
|
|
unsigned int inj_cmd_abort:1;
|
2016-04-25 16:16:33 +00:00
|
|
|
};
|
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
struct sdebug_queue {
|
|
|
|
struct sdebug_queued_cmd qc_arr[SDEBUG_CANQUEUE];
|
|
|
|
unsigned long in_use_bm[SDEBUG_CANQUEUE_WORDS];
|
|
|
|
spinlock_t qc_lock;
|
|
|
|
atomic_t blocked; /* to temporarily stop more being queued */
|
2016-04-25 16:16:33 +00:00
|
|
|
};
|
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
static atomic_t sdebug_cmnd_count; /* number of incoming commands */
|
|
|
|
static atomic_t sdebug_completions; /* count of deferred completions */
|
|
|
|
static atomic_t sdebug_miss_cpus; /* submission + completion cpus differ */
|
|
|
|
static atomic_t sdebug_a_tsf; /* 'almost task set full' counter */
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
struct opcode_info_t {
|
2016-05-01 02:44:42 +00:00
|
|
|
u8 num_attached; /* 0 if this is it (i.e. a leaf); use 0xff */
|
|
|
|
/* for terminating element */
|
2016-04-25 16:16:33 +00:00
|
|
|
u8 opcode; /* if num_attached > 0, preferred */
|
|
|
|
u16 sa; /* service action */
|
|
|
|
u32 flags; /* OR-ed set of SDEB_F_* */
|
|
|
|
int (*pfp)(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
const struct opcode_info_t *arrp; /* num_attached elements or NULL */
|
2017-12-23 17:48:10 +00:00
|
|
|
u8 len_mask[16]; /* len_mask[0]-->cdb_len, then mask for cdb */
|
|
|
|
/* 1 to min(cdb_len, 15); ignore cdb[15...] */
|
2016-04-25 16:16:33 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* SCSI opcodes (first byte of cdb) of interest mapped onto these indexes */
|
2014-11-25 01:46:29 +00:00
|
|
|
enum sdeb_opcode_index {
|
|
|
|
SDEB_I_INVALID_OPCODE = 0,
|
|
|
|
SDEB_I_INQUIRY = 1,
|
|
|
|
SDEB_I_REPORT_LUNS = 2,
|
|
|
|
SDEB_I_REQUEST_SENSE = 3,
|
|
|
|
SDEB_I_TEST_UNIT_READY = 4,
|
|
|
|
SDEB_I_MODE_SENSE = 5, /* 6, 10 */
|
|
|
|
SDEB_I_MODE_SELECT = 6, /* 6, 10 */
|
|
|
|
SDEB_I_LOG_SENSE = 7,
|
|
|
|
SDEB_I_READ_CAPACITY = 8, /* 10; 16 is in SA_IN(16) */
|
|
|
|
SDEB_I_READ = 9, /* 6, 10, 12, 16 */
|
|
|
|
SDEB_I_WRITE = 10, /* 6, 10, 12, 16 */
|
|
|
|
SDEB_I_START_STOP = 11,
|
2017-12-23 17:48:13 +00:00
|
|
|
SDEB_I_SERV_ACT_IN_16 = 12, /* add ...SERV_ACT_IN_12 if needed */
|
|
|
|
SDEB_I_SERV_ACT_OUT_16 = 13, /* add ...SERV_ACT_OUT_12 if needed */
|
2014-11-25 01:46:29 +00:00
|
|
|
SDEB_I_MAINT_IN = 14,
|
|
|
|
SDEB_I_MAINT_OUT = 15,
|
|
|
|
SDEB_I_VERIFY = 16, /* 10 only */
|
2017-12-23 17:48:14 +00:00
|
|
|
SDEB_I_VARIABLE_LEN = 17, /* READ(32), WRITE(32), WR_SCAT(32) */
|
2014-11-25 01:46:29 +00:00
|
|
|
SDEB_I_RESERVE = 18, /* 6, 10 */
|
|
|
|
SDEB_I_RELEASE = 19, /* 6, 10 */
|
|
|
|
SDEB_I_ALLOW_REMOVAL = 20, /* PREVENT ALLOW MEDIUM REMOVAL */
|
|
|
|
SDEB_I_REZERO_UNIT = 21, /* REWIND in SSC */
|
|
|
|
SDEB_I_ATA_PT = 22, /* 12, 16 */
|
|
|
|
SDEB_I_SEND_DIAG = 23,
|
|
|
|
SDEB_I_UNMAP = 24,
|
2019-02-08 21:21:27 +00:00
|
|
|
SDEB_I_WRITE_BUFFER = 25,
|
|
|
|
SDEB_I_WRITE_SAME = 26, /* 10, 16 */
|
|
|
|
SDEB_I_SYNC_CACHE = 27, /* 10, 16 */
|
|
|
|
SDEB_I_COMP_WRITE = 28,
|
|
|
|
SDEB_I_LAST_ELEMENT = 29, /* keep this last (previous + 1) */
|
2014-11-25 01:46:29 +00:00
|
|
|
};
|
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
static const unsigned char opcode_ind_arr[256] = {
|
|
|
|
/* 0x0; 0x0->0x1f: 6 byte cdbs */
|
|
|
|
SDEB_I_TEST_UNIT_READY, SDEB_I_REZERO_UNIT, 0, SDEB_I_REQUEST_SENSE,
|
|
|
|
0, 0, 0, 0,
|
|
|
|
SDEB_I_READ, 0, SDEB_I_WRITE, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, SDEB_I_INQUIRY, 0, 0, SDEB_I_MODE_SELECT, SDEB_I_RESERVE,
|
|
|
|
SDEB_I_RELEASE,
|
|
|
|
0, 0, SDEB_I_MODE_SENSE, SDEB_I_START_STOP, 0, SDEB_I_SEND_DIAG,
|
|
|
|
SDEB_I_ALLOW_REMOVAL, 0,
|
|
|
|
/* 0x20; 0x20->0x3f: 10 byte cdbs */
|
|
|
|
0, 0, 0, 0, 0, SDEB_I_READ_CAPACITY, 0, 0,
|
|
|
|
SDEB_I_READ, 0, SDEB_I_WRITE, 0, 0, 0, 0, SDEB_I_VERIFY,
|
|
|
|
0, 0, 0, 0, 0, SDEB_I_SYNC_CACHE, 0, 0,
|
|
|
|
0, 0, 0, SDEB_I_WRITE_BUFFER, 0, 0, 0, 0,
|
|
|
|
/* 0x40; 0x40->0x5f: 10 byte cdbs */
|
|
|
|
0, SDEB_I_WRITE_SAME, SDEB_I_UNMAP, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, SDEB_I_LOG_SENSE, 0, 0,
|
2019-02-08 21:21:27 +00:00
|
|
|
0, 0, 0, 0, 0, SDEB_I_MODE_SELECT, SDEB_I_RESERVE,
|
2014-11-25 01:46:29 +00:00
|
|
|
SDEB_I_RELEASE,
|
|
|
|
0, 0, SDEB_I_MODE_SENSE, 0, 0, 0, 0, 0,
|
2016-04-25 16:16:33 +00:00
|
|
|
/* 0x60; 0x60->0x7d are reserved, 0x7e is "extended cdb" */
|
2014-11-25 01:46:29 +00:00
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, SDEB_I_VARIABLE_LEN,
|
|
|
|
/* 0x80; 0x80->0x9f: 16 byte cdbs */
|
|
|
|
0, 0, 0, 0, 0, SDEB_I_ATA_PT, 0, 0,
|
|
|
|
SDEB_I_READ, SDEB_I_COMP_WRITE, SDEB_I_WRITE, 0, 0, 0, 0, 0,
|
2018-02-10 02:36:39 +00:00
|
|
|
0, SDEB_I_SYNC_CACHE, 0, SDEB_I_WRITE_SAME, 0, 0, 0, 0,
|
2017-12-23 17:48:13 +00:00
|
|
|
0, 0, 0, 0, 0, 0, SDEB_I_SERV_ACT_IN_16, SDEB_I_SERV_ACT_OUT_16,
|
2014-11-25 01:46:29 +00:00
|
|
|
/* 0xa0; 0xa0->0xbf: 12 byte cdbs */
|
|
|
|
SDEB_I_REPORT_LUNS, SDEB_I_ATA_PT, 0, SDEB_I_MAINT_IN,
|
|
|
|
SDEB_I_MAINT_OUT, 0, 0, 0,
|
2017-12-23 17:48:13 +00:00
|
|
|
SDEB_I_READ, 0 /* SDEB_I_SERV_ACT_OUT_12 */, SDEB_I_WRITE,
|
|
|
|
0 /* SDEB_I_SERV_ACT_IN_12 */, 0, 0, 0, 0,
|
2014-11-25 01:46:29 +00:00
|
|
|
0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
/* 0xc0; 0xc0->0xff: vendor specific */
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
};
|
|
|
|
|
2018-02-10 02:36:39 +00:00
|
|
|
/*
|
|
|
|
* The following "response" functions return the SCSI mid-level's 4 byte
|
|
|
|
* tuple-in-an-int. To handle commands with an IMMED bit, for a faster
|
|
|
|
* command completion, they can mask their return value with
|
|
|
|
* SDEG_RES_IMMED_MASK .
|
|
|
|
*/
|
|
|
|
#define SDEG_RES_IMMED_MASK 0x40000000
|
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
static int resp_inquiry(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_report_luns(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_requests(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_mode_sense(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_mode_select(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_log_sense(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_readcap(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_read_dt0(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_write_dt0(struct scsi_cmnd *, struct sdebug_dev_info *);
|
2017-12-23 17:48:14 +00:00
|
|
|
static int resp_write_scat(struct scsi_cmnd *, struct sdebug_dev_info *);
|
2014-11-25 01:46:29 +00:00
|
|
|
static int resp_start_stop(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_readcap16(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_get_lba_status(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_report_tgtpgs(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_unmap(struct scsi_cmnd *, struct sdebug_dev_info *);
|
2014-11-25 02:27:12 +00:00
|
|
|
static int resp_rsup_opcodes(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_rsup_tmfs(struct scsi_cmnd *, struct sdebug_dev_info *);
|
2014-11-25 01:46:29 +00:00
|
|
|
static int resp_write_same_10(struct scsi_cmnd *, struct sdebug_dev_info *);
|
|
|
|
static int resp_write_same_16(struct scsi_cmnd *, struct sdebug_dev_info *);
|
2014-11-25 02:27:12 +00:00
|
|
|
static int resp_comp_write(struct scsi_cmnd *, struct sdebug_dev_info *);
|
2014-12-04 16:49:28 +00:00
|
|
|
static int resp_write_buffer(struct scsi_cmnd *, struct sdebug_dev_info *);
|
2018-02-10 02:36:39 +00:00
|
|
|
static int resp_sync_cache(struct scsi_cmnd *, struct sdebug_dev_info *);
|
2014-11-25 01:46:29 +00:00
|
|
|
|
2017-12-23 17:48:13 +00:00
|
|
|
/*
|
|
|
|
* The following are overflow arrays for cdbs that "hit" the same index in
|
|
|
|
* the opcode_info_arr array. The most time sensitive (or commonly used) cdb
|
|
|
|
* should be placed in opcode_info_arr[], the others should be placed here.
|
|
|
|
*/
|
|
|
|
static const struct opcode_info_t msense_iarr[] = {
|
2014-11-25 01:46:29 +00:00
|
|
|
{0, 0x1a, 0, F_D_IN, NULL, NULL,
|
|
|
|
{6, 0xe8, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
|
|
|
};
|
|
|
|
|
2017-12-23 17:48:13 +00:00
|
|
|
static const struct opcode_info_t mselect_iarr[] = {
|
2014-11-25 01:46:29 +00:00
|
|
|
{0, 0x15, 0, F_D_OUT, NULL, NULL,
|
|
|
|
{6, 0xf1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
|
|
|
};
|
|
|
|
|
2017-12-23 17:48:13 +00:00
|
|
|
static const struct opcode_info_t read_iarr[] = {
|
|
|
|
{0, 0x28, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL,/* READ(10) */
|
2017-12-23 17:48:11 +00:00
|
|
|
{10, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
|
2014-11-25 01:46:29 +00:00
|
|
|
0, 0, 0, 0} },
|
2017-12-23 17:48:13 +00:00
|
|
|
{0, 0x8, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL, /* READ(6) */
|
2014-11-25 01:46:29 +00:00
|
|
|
{6, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
2017-12-23 17:48:13 +00:00
|
|
|
{0, 0xa8, 0, F_D_IN | FF_MEDIA_IO, resp_read_dt0, NULL,/* READ(12) */
|
2017-12-23 17:48:11 +00:00
|
|
|
{12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf,
|
2014-11-25 01:46:29 +00:00
|
|
|
0xc7, 0, 0, 0, 0} },
|
|
|
|
};
|
|
|
|
|
2017-12-23 17:48:13 +00:00
|
|
|
static const struct opcode_info_t write_iarr[] = {
|
|
|
|
{0, 0x2a, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0, /* WRITE(10) */
|
|
|
|
NULL, {10, 0xfb, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7,
|
|
|
|
0, 0, 0, 0, 0, 0} },
|
|
|
|
{0, 0xa, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0, /* WRITE(6) */
|
|
|
|
NULL, {6, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0} },
|
|
|
|
{0, 0xaa, 0, F_D_OUT | FF_MEDIA_IO, resp_write_dt0, /* WRITE(12) */
|
|
|
|
NULL, {12, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0xbf, 0xc7, 0, 0, 0, 0} },
|
2014-11-25 01:46:29 +00:00
|
|
|
};
|
|
|
|
|
2017-12-23 17:48:13 +00:00
|
|
|
static const struct opcode_info_t sa_in_16_iarr[] = {
|
2014-11-25 01:46:29 +00:00
|
|
|
{0, 0x9e, 0x12, F_SA_LOW | F_D_IN, resp_get_lba_status, NULL,
|
|
|
|
{16, 0x12, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
2017-12-23 17:48:13 +00:00
|
|
|
0xff, 0xff, 0xff, 0, 0xc7} }, /* GET LBA STATUS(16) */
|
2014-11-25 01:46:29 +00:00
|
|
|
};
|
|
|
|
|
2017-12-23 17:48:13 +00:00
|
|
|
static const struct opcode_info_t vl_iarr[] = { /* VARIABLE LENGTH */
|
|
|
|
{0, 0x7f, 0xb, F_SA_HIGH | F_D_OUT | FF_MEDIA_IO, resp_write_dt0,
|
2017-12-23 17:48:11 +00:00
|
|
|
NULL, {32, 0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0xb, 0xfa,
|
2014-11-25 01:46:29 +00:00
|
|
|
0, 0xff, 0xff, 0xff, 0xff} }, /* WRITE(32) */
|
2017-12-23 17:48:14 +00:00
|
|
|
{0, 0x7f, 0x11, F_SA_HIGH | F_D_OUT | FF_MEDIA_IO, resp_write_scat,
|
|
|
|
NULL, {32, 0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0x11, 0xf8,
|
|
|
|
0, 0xff, 0xff, 0x0, 0x0} }, /* WRITE SCATTERED(32) */
|
2014-11-25 01:46:29 +00:00
|
|
|
};
|
|
|
|
|
2017-12-23 17:48:13 +00:00
|
|
|
static const struct opcode_info_t maint_in_iarr[] = { /* MAINT IN */
|
2014-11-25 02:27:12 +00:00
|
|
|
{0, 0xa3, 0xc, F_SA_LOW | F_D_IN, resp_rsup_opcodes, NULL,
|
2014-11-25 01:46:29 +00:00
|
|
|
{12, 0xc, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0,
|
2017-12-23 17:48:13 +00:00
|
|
|
0xc7, 0, 0, 0, 0} }, /* REPORT SUPPORTED OPERATION CODES */
|
2014-11-25 02:27:12 +00:00
|
|
|
{0, 0xa3, 0xd, F_SA_LOW | F_D_IN, resp_rsup_tmfs, NULL,
|
2014-11-25 01:46:29 +00:00
|
|
|
{12, 0xd, 0x80, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0,
|
2017-12-23 17:48:13 +00:00
|
|
|
0, 0} }, /* REPORTED SUPPORTED TASK MANAGEMENT FUNCTIONS */
|
2014-11-25 01:46:29 +00:00
|
|
|
};
|
|
|
|
|
2017-12-23 17:48:13 +00:00
|
|
|
static const struct opcode_info_t write_same_iarr[] = {
|
|
|
|
{0, 0x93, 0, F_D_OUT_MAYBE | FF_MEDIA_IO, resp_write_same_16, NULL,
|
2014-11-25 01:46:29 +00:00
|
|
|
{16, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
2017-12-23 17:48:13 +00:00
|
|
|
0xff, 0xff, 0xff, 0x3f, 0xc7} }, /* WRITE SAME(16) */
|
2014-11-25 01:46:29 +00:00
|
|
|
};
|
|
|
|
|
2017-12-23 17:48:13 +00:00
|
|
|
static const struct opcode_info_t reserve_iarr[] = {
|
|
|
|
{0, 0x16, 0, F_D_OUT, NULL, NULL, /* RESERVE(6) */
|
2014-11-25 01:46:29 +00:00
|
|
|
{6, 0x1f, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
|
|
|
};
|
|
|
|
|
2017-12-23 17:48:13 +00:00
|
|
|
static const struct opcode_info_t release_iarr[] = {
|
|
|
|
{0, 0x17, 0, F_D_OUT, NULL, NULL, /* RELEASE(6) */
|
2014-11-25 01:46:29 +00:00
|
|
|
{6, 0x1f, 0xff, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
|
|
|
};
|
|
|
|
|
2018-02-10 02:36:39 +00:00
|
|
|
static const struct opcode_info_t sync_cache_iarr[] = {
|
2018-04-10 17:00:36 +00:00
|
|
|
{0, 0x91, 0, F_SYNC_DELAY | F_M_ACCESS, resp_sync_cache, NULL,
|
2018-02-10 02:36:39 +00:00
|
|
|
{16, 0x6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x3f, 0xc7} }, /* SYNC_CACHE (16) */
|
|
|
|
};
|
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
|
|
|
|
/* This array is accessed via SDEB_I_* values. Make sure all are mapped,
|
|
|
|
* plus the terminating elements for logic that scans this table such as
|
|
|
|
* REPORT SUPPORTED OPERATION CODES. */
|
|
|
|
static const struct opcode_info_t opcode_info_arr[SDEB_I_LAST_ELEMENT + 1] = {
|
|
|
|
/* 0 */
|
2017-12-23 17:48:13 +00:00
|
|
|
{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* unknown opcodes */
|
2014-11-25 01:46:29 +00:00
|
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
2017-12-23 17:48:13 +00:00
|
|
|
{0, 0x12, 0, FF_RESPOND | F_D_IN, resp_inquiry, NULL, /* INQUIRY */
|
2014-11-25 01:46:29 +00:00
|
|
|
{6, 0xe3, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
|
|
|
{0, 0xa0, 0, FF_RESPOND | F_D_IN, resp_report_luns, NULL,
|
|
|
|
{12, 0xe3, 0xff, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0,
|
2017-12-23 17:48:13 +00:00
|
|
|
0, 0} }, /* REPORT LUNS */
|
2014-11-25 01:46:29 +00:00
|
|
|
{0, 0x3, 0, FF_RESPOND | F_D_IN, resp_requests, NULL,
|
|
|
|
{6, 0xe1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
|
|
|
{0, 0x0, 0, F_M_ACCESS | F_RL_WLUN_OK, NULL, NULL,/* TEST UNIT READY */
|
|
|
|
{6, 0, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
2017-12-23 17:48:13 +00:00
|
|
|
/* 5 */
|
|
|
|
{ARRAY_SIZE(msense_iarr), 0x5a, 0, F_D_IN, /* MODE SENSE(10) */
|
|
|
|
resp_mode_sense, msense_iarr, {10, 0xf8, 0xff, 0xff, 0, 0, 0,
|
|
|
|
0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
|
|
|
|
{ARRAY_SIZE(mselect_iarr), 0x55, 0, F_D_OUT, /* MODE SELECT(10) */
|
|
|
|
resp_mode_select, mselect_iarr, {10, 0xf1, 0, 0, 0, 0, 0, 0xff,
|
|
|
|
0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
|
|
|
|
{0, 0x4d, 0, F_D_IN, resp_log_sense, NULL, /* LOG SENSE */
|
2014-11-25 01:46:29 +00:00
|
|
|
{10, 0xe3, 0xff, 0xff, 0, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0,
|
|
|
|
0, 0, 0} },
|
2017-12-23 17:48:13 +00:00
|
|
|
{0, 0x25, 0, F_D_IN, resp_readcap, NULL, /* READ CAPACITY(10) */
|
2014-11-25 01:46:29 +00:00
|
|
|
{10, 0xe1, 0xff, 0xff, 0xff, 0xff, 0, 0, 0x1, 0xc7, 0, 0, 0, 0,
|
|
|
|
0, 0} },
|
2017-12-23 17:48:13 +00:00
|
|
|
{ARRAY_SIZE(read_iarr), 0x88, 0, F_D_IN | FF_MEDIA_IO, /* READ(16) */
|
|
|
|
resp_read_dt0, read_iarr, {16, 0xfe, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7} },
|
2014-11-25 01:46:29 +00:00
|
|
|
/* 10 */
|
2017-12-23 17:48:13 +00:00
|
|
|
{ARRAY_SIZE(write_iarr), 0x8a, 0, F_D_OUT | FF_MEDIA_IO,
|
|
|
|
resp_write_dt0, write_iarr, /* WRITE(16) */
|
|
|
|
{16, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
2018-02-10 02:36:39 +00:00
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xc7} },
|
2018-04-10 17:00:36 +00:00
|
|
|
{0, 0x1b, 0, F_SSU_DELAY, resp_start_stop, NULL,/* START STOP UNIT */
|
2014-11-25 01:46:29 +00:00
|
|
|
{6, 0x1, 0, 0xf, 0xf7, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
2017-12-23 17:48:13 +00:00
|
|
|
{ARRAY_SIZE(sa_in_16_iarr), 0x9e, 0x10, F_SA_LOW | F_D_IN,
|
|
|
|
resp_readcap16, sa_in_16_iarr, /* SA_IN(16), READ CAPACITY(16) */
|
|
|
|
{16, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x1, 0xc7} },
|
2017-12-23 17:48:14 +00:00
|
|
|
{0, 0x9f, 0x12, F_SA_LOW | F_D_OUT | FF_MEDIA_IO, resp_write_scat,
|
|
|
|
NULL, {16, 0x12, 0xf9, 0x0, 0xff, 0xff, 0, 0, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xc7} }, /* SA_OUT(16), WRITE SCAT(16) */
|
2017-12-23 17:48:13 +00:00
|
|
|
{ARRAY_SIZE(maint_in_iarr), 0xa3, 0xa, F_SA_LOW | F_D_IN,
|
|
|
|
resp_report_tgtpgs, /* MAINT IN, REPORT TARGET PORT GROUPS */
|
|
|
|
maint_in_iarr, {12, 0xea, 0, 0, 0, 0, 0xff, 0xff, 0xff,
|
|
|
|
0xff, 0, 0xc7, 0, 0, 0, 0} },
|
|
|
|
/* 15 */
|
2014-11-25 01:46:29 +00:00
|
|
|
{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* MAINT OUT */
|
|
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
2017-12-23 17:48:13 +00:00
|
|
|
{0, 0x2f, 0, F_D_OUT_MAYBE | FF_MEDIA_IO, NULL, NULL, /* VERIFY(10) */
|
2015-11-22 17:11:28 +00:00
|
|
|
{10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7,
|
|
|
|
0, 0, 0, 0, 0, 0} },
|
2017-12-23 17:48:13 +00:00
|
|
|
{ARRAY_SIZE(vl_iarr), 0x7f, 0x9, F_SA_HIGH | F_D_IN | FF_MEDIA_IO,
|
|
|
|
resp_read_dt0, vl_iarr, /* VARIABLE LENGTH, READ(32) */
|
|
|
|
{32, 0xc7, 0, 0, 0, 0, 0x3f, 0x18, 0x0, 0x9, 0xfe, 0, 0xff, 0xff,
|
|
|
|
0xff, 0xff} },
|
|
|
|
{ARRAY_SIZE(reserve_iarr), 0x56, 0, F_D_OUT,
|
|
|
|
NULL, reserve_iarr, /* RESERVE(10) <no response function> */
|
2014-11-25 01:46:29 +00:00
|
|
|
{10, 0xff, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
|
|
|
|
0} },
|
2017-12-23 17:48:13 +00:00
|
|
|
{ARRAY_SIZE(release_iarr), 0x57, 0, F_D_OUT,
|
|
|
|
NULL, release_iarr, /* RELEASE(10) <no response function> */
|
2014-11-25 01:46:29 +00:00
|
|
|
{10, 0x13, 0xff, 0xff, 0, 0, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0,
|
|
|
|
0} },
|
|
|
|
/* 20 */
|
2015-11-22 17:11:28 +00:00
|
|
|
{0, 0x1e, 0, 0, NULL, NULL, /* ALLOW REMOVAL */
|
|
|
|
{6, 0, 0, 0, 0x3, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
2014-11-25 01:46:29 +00:00
|
|
|
{0, 0x1, 0, 0, resp_start_stop, NULL, /* REWIND ?? */
|
|
|
|
{6, 0x1, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
|
|
|
{0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* ATA_PT */
|
|
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
|
|
|
{0, 0x1d, F_D_OUT, 0, NULL, NULL, /* SEND DIAGNOSTIC */
|
|
|
|
{6, 0xf7, 0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
2017-12-23 17:48:13 +00:00
|
|
|
{0, 0x42, 0, F_D_OUT | FF_MEDIA_IO, resp_unmap, NULL, /* UNMAP */
|
2017-12-23 17:48:11 +00:00
|
|
|
{10, 0x1, 0, 0, 0, 0, 0x3f, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
|
2017-12-23 17:48:13 +00:00
|
|
|
/* 25 */
|
2014-12-04 16:49:28 +00:00
|
|
|
{0, 0x3b, 0, F_D_OUT_MAYBE, resp_write_buffer, NULL,
|
|
|
|
{10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0,
|
|
|
|
0, 0, 0, 0} }, /* WRITE_BUFFER */
|
2017-12-23 17:48:13 +00:00
|
|
|
{ARRAY_SIZE(write_same_iarr), 0x41, 0, F_D_OUT_MAYBE | FF_MEDIA_IO,
|
|
|
|
resp_write_same_10, write_same_iarr, /* WRITE SAME(10) */
|
|
|
|
{10, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0,
|
|
|
|
0, 0, 0, 0, 0} },
|
2018-04-10 17:00:36 +00:00
|
|
|
{ARRAY_SIZE(sync_cache_iarr), 0x35, 0, F_SYNC_DELAY | F_M_ACCESS,
|
2018-02-10 02:36:39 +00:00
|
|
|
resp_sync_cache, sync_cache_iarr,
|
2017-12-23 17:48:11 +00:00
|
|
|
{10, 0x7, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xc7, 0, 0,
|
2018-02-10 02:36:39 +00:00
|
|
|
0, 0, 0, 0} }, /* SYNC_CACHE (10) */
|
2017-12-23 17:48:13 +00:00
|
|
|
{0, 0x89, 0, F_D_OUT | FF_MEDIA_IO, resp_comp_write, NULL,
|
2014-11-25 01:46:29 +00:00
|
|
|
{16, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0,
|
2017-12-23 17:48:11 +00:00
|
|
|
0, 0xff, 0x3f, 0xc7} }, /* COMPARE AND WRITE */
|
2014-11-25 01:46:29 +00:00
|
|
|
|
2019-02-08 21:21:27 +00:00
|
|
|
/* 29 */
|
2014-11-25 01:46:29 +00:00
|
|
|
{0xff, 0, 0, 0, NULL, NULL, /* terminating element */
|
|
|
|
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
|
|
|
|
};
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
static int sdebug_add_host = DEF_NUM_HOST;
|
|
|
|
static int sdebug_ato = DEF_ATO;
|
2017-12-05 05:05:49 +00:00
|
|
|
static int sdebug_cdb_len = DEF_CDB_LEN;
|
2016-04-25 16:16:31 +00:00
|
|
|
static int sdebug_jdelay = DEF_JDELAY; /* if > 0 then unit is jiffies */
|
2016-04-25 16:16:28 +00:00
|
|
|
static int sdebug_dev_size_mb = DEF_DEV_SIZE_MB;
|
|
|
|
static int sdebug_dif = DEF_DIF;
|
|
|
|
static int sdebug_dix = DEF_DIX;
|
|
|
|
static int sdebug_dsense = DEF_D_SENSE;
|
|
|
|
static int sdebug_every_nth = DEF_EVERY_NTH;
|
|
|
|
static int sdebug_fake_rw = DEF_FAKE_RW;
|
|
|
|
static unsigned int sdebug_guard = DEF_GUARD;
|
|
|
|
static int sdebug_lowest_aligned = DEF_LOWEST_ALIGNED;
|
|
|
|
static int sdebug_max_luns = DEF_MAX_LUNS;
|
2016-05-06 04:40:26 +00:00
|
|
|
static int sdebug_max_queue = SDEBUG_CANQUEUE; /* per submit queue */
|
2018-02-03 18:38:35 +00:00
|
|
|
static unsigned int sdebug_medium_error_start = OPT_MEDIUM_ERR_ADDR;
|
|
|
|
static int sdebug_medium_error_count = OPT_MEDIUM_ERR_NUM;
|
2014-07-26 15:55:35 +00:00
|
|
|
static atomic_t retired_max_queue; /* if > 0 then was prior max_queue */
|
2016-04-25 16:16:31 +00:00
|
|
|
static int sdebug_ndelay = DEF_NDELAY; /* if > 0 then unit is nanoseconds */
|
2016-04-25 16:16:28 +00:00
|
|
|
static int sdebug_no_lun_0 = DEF_NO_LUN_0;
|
|
|
|
static int sdebug_no_uld;
|
|
|
|
static int sdebug_num_parts = DEF_NUM_PARTS;
|
|
|
|
static int sdebug_num_tgts = DEF_NUM_TGTS; /* targets per host */
|
|
|
|
static int sdebug_opt_blks = DEF_OPT_BLKS;
|
|
|
|
static int sdebug_opts = DEF_OPTS;
|
|
|
|
static int sdebug_physblk_exp = DEF_PHYSBLK_EXP;
|
2017-01-26 09:00:37 +00:00
|
|
|
static int sdebug_opt_xferlen_exp = DEF_OPT_XFERLEN_EXP;
|
2016-05-01 02:44:42 +00:00
|
|
|
static int sdebug_ptype = DEF_PTYPE; /* SCSI peripheral device type */
|
2016-04-25 16:16:28 +00:00
|
|
|
static int sdebug_scsi_level = DEF_SCSI_LEVEL;
|
|
|
|
static int sdebug_sector_size = DEF_SECTOR_SIZE;
|
|
|
|
static int sdebug_virtual_gb = DEF_VIRTUAL_GB;
|
|
|
|
static int sdebug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
|
|
|
|
static unsigned int sdebug_lbpu = DEF_LBPU;
|
|
|
|
static unsigned int sdebug_lbpws = DEF_LBPWS;
|
|
|
|
static unsigned int sdebug_lbpws10 = DEF_LBPWS10;
|
|
|
|
static unsigned int sdebug_lbprz = DEF_LBPRZ;
|
|
|
|
static unsigned int sdebug_unmap_alignment = DEF_UNMAP_ALIGNMENT;
|
|
|
|
static unsigned int sdebug_unmap_granularity = DEF_UNMAP_GRANULARITY;
|
|
|
|
static unsigned int sdebug_unmap_max_blocks = DEF_UNMAP_MAX_BLOCKS;
|
|
|
|
static unsigned int sdebug_unmap_max_desc = DEF_UNMAP_MAX_DESC;
|
|
|
|
static unsigned int sdebug_write_same_length = DEF_WRITESAME_LENGTH;
|
2016-05-06 04:40:28 +00:00
|
|
|
static int sdebug_uuid_ctl = DEF_UUID_CTL;
|
2016-04-25 16:16:28 +00:00
|
|
|
static bool sdebug_removable = DEF_REMOVABLE;
|
|
|
|
static bool sdebug_clustering;
|
|
|
|
static bool sdebug_host_lock = DEF_HOST_LOCK;
|
|
|
|
static bool sdebug_strict = DEF_STRICT;
|
2014-11-25 01:18:02 +00:00
|
|
|
static bool sdebug_any_injecting_opt;
|
2016-04-25 16:16:28 +00:00
|
|
|
static bool sdebug_verbose;
|
2016-04-25 16:16:34 +00:00
|
|
|
static bool have_dif_prot;
|
2018-04-10 17:00:36 +00:00
|
|
|
static bool write_since_sync;
|
2016-05-06 04:40:26 +00:00
|
|
|
static bool sdebug_statistics = DEF_STATISTICS;
|
2019-02-08 23:37:25 +00:00
|
|
|
static bool sdebug_wp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-06 04:11:24 +00:00
|
|
|
static unsigned int sdebug_store_sectors;
|
2005-04-16 22:20:36 +00:00
|
|
|
static sector_t sdebug_capacity; /* in sectors */
|
|
|
|
|
|
|
|
/* old BIOS stuff, kernel may get rid of them but some mode sense pages
|
|
|
|
may still need them */
|
|
|
|
static int sdebug_heads; /* heads per disk */
|
|
|
|
static int sdebug_cylinders_per; /* cylinders per surface */
|
|
|
|
static int sdebug_sectors_per; /* sectors per cylinder */
|
|
|
|
|
|
|
|
static LIST_HEAD(sdebug_host_list);
|
|
|
|
static DEFINE_SPINLOCK(sdebug_host_list_lock);
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static unsigned char *fake_storep; /* ramdisk storage */
|
2016-09-11 17:35:39 +00:00
|
|
|
static struct t10_pi_tuple *dif_storep; /* protection info */
|
2009-10-15 18:45:27 +00:00
|
|
|
static void *map_storep; /* provisioning map */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-10-15 18:45:27 +00:00
|
|
|
static unsigned long map_size;
|
2014-07-26 15:55:35 +00:00
|
|
|
static int num_aborts;
|
|
|
|
static int num_dev_resets;
|
|
|
|
static int num_target_resets;
|
|
|
|
static int num_bus_resets;
|
|
|
|
static int num_host_resets;
|
2009-01-04 08:08:19 +00:00
|
|
|
static int dix_writes;
|
|
|
|
static int dix_reads;
|
|
|
|
static int dif_errors;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
static int submit_queues = DEF_SUBMIT_QUEUES; /* > 1 for multi-queue (mq) */
|
|
|
|
static struct sdebug_queue *sdebug_q_arr; /* ptr to array of submit queues */
|
2016-04-25 16:16:33 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static DEFINE_RWLOCK(atomic_rw);
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
static char sdebug_proc_name[] = MY_NAME;
|
|
|
|
static const char *my_name = MY_NAME;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static struct bus_type pseudo_lld_bus;
|
|
|
|
|
|
|
|
static struct device_driver sdebug_driverfs_driver = {
|
|
|
|
.name = sdebug_proc_name,
|
|
|
|
.bus = &pseudo_lld_bus,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const int check_condition_result =
|
|
|
|
(DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
|
|
|
|
|
2009-01-04 08:08:19 +00:00
|
|
|
static const int illegal_condition_result =
|
|
|
|
(DRIVER_SENSE << 24) | (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION;
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
static const int device_qfull_result =
|
|
|
|
(DID_OK << 16) | (COMMAND_COMPLETE << 8) | SAM_STAT_TASK_SET_FULL;
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
|
2016-05-06 04:40:27 +00:00
|
|
|
/* Only do the extra work involved in logical block provisioning if one or
|
|
|
|
* more of the lbpu, lbpws or lbpws10 parameters are given and we are doing
|
|
|
|
* real reads and writes (i.e. not skipping them for speed).
|
|
|
|
*/
|
|
|
|
static inline bool scsi_debug_lbp(void)
|
2016-04-25 16:16:33 +00:00
|
|
|
{
|
|
|
|
return 0 == sdebug_fake_rw &&
|
|
|
|
(sdebug_lbpu || sdebug_lbpws || sdebug_lbpws10);
|
|
|
|
}
|
2006-06-06 04:11:24 +00:00
|
|
|
|
2019-01-25 17:46:09 +00:00
|
|
|
static void *lba2fake_store(unsigned long long lba)
|
2013-09-18 12:27:24 +00:00
|
|
|
{
|
|
|
|
lba = do_div(lba, sdebug_store_sectors);
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
return fake_storep + lba * sdebug_sector_size;
|
2013-09-18 12:27:24 +00:00
|
|
|
}
|
|
|
|
|
2016-09-11 17:35:39 +00:00
|
|
|
static struct t10_pi_tuple *dif_store(sector_t sector)
|
2013-09-18 12:27:24 +00:00
|
|
|
{
|
2015-11-20 16:38:28 +00:00
|
|
|
sector = sector_div(sector, sdebug_store_sectors);
|
2013-09-18 12:27:24 +00:00
|
|
|
|
|
|
|
return dif_storep + sector;
|
|
|
|
}
|
|
|
|
|
2008-03-29 15:59:58 +00:00
|
|
|
static void sdebug_max_tgts_luns(void)
|
|
|
|
{
|
|
|
|
struct sdebug_host_info *sdbg_host;
|
|
|
|
struct Scsi_Host *hpnt;
|
|
|
|
|
|
|
|
spin_lock(&sdebug_host_list_lock);
|
|
|
|
list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
|
|
|
|
hpnt = sdbg_host->shost;
|
|
|
|
if ((hpnt->this_id >= 0) &&
|
2016-04-25 16:16:28 +00:00
|
|
|
(sdebug_num_tgts > hpnt->this_id))
|
|
|
|
hpnt->max_id = sdebug_num_tgts + 1;
|
2008-03-29 15:59:58 +00:00
|
|
|
else
|
2016-04-25 16:16:28 +00:00
|
|
|
hpnt->max_id = sdebug_num_tgts;
|
|
|
|
/* sdebug_max_luns; */
|
2015-07-28 13:54:25 +00:00
|
|
|
hpnt->max_lun = SCSI_W_LUN_REPORT_LUNS + 1;
|
2008-03-29 15:59:58 +00:00
|
|
|
}
|
|
|
|
spin_unlock(&sdebug_host_list_lock);
|
|
|
|
}
|
|
|
|
|
2014-11-25 04:04:47 +00:00
|
|
|
enum sdeb_cmd_data {SDEB_IN_DATA = 0, SDEB_IN_CDB = 1};
|
|
|
|
|
|
|
|
/* Set in_bit to -1 to indicate no bit position of invalid field */
|
2016-04-25 16:16:33 +00:00
|
|
|
static void mk_sense_invalid_fld(struct scsi_cmnd *scp,
|
|
|
|
enum sdeb_cmd_data c_d,
|
|
|
|
int in_byte, int in_bit)
|
2014-11-25 04:04:47 +00:00
|
|
|
{
|
|
|
|
unsigned char *sbuff;
|
|
|
|
u8 sks[4];
|
|
|
|
int sl, asc;
|
|
|
|
|
|
|
|
sbuff = scp->sense_buffer;
|
|
|
|
if (!sbuff) {
|
|
|
|
sdev_printk(KERN_ERR, scp->device,
|
|
|
|
"%s: sense_buffer is NULL\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
asc = c_d ? INVALID_FIELD_IN_CDB : INVALID_FIELD_IN_PARAM_LIST;
|
|
|
|
memset(sbuff, 0, SCSI_SENSE_BUFFERSIZE);
|
2016-04-25 16:16:28 +00:00
|
|
|
scsi_build_sense_buffer(sdebug_dsense, sbuff, ILLEGAL_REQUEST, asc, 0);
|
2014-11-25 04:04:47 +00:00
|
|
|
memset(sks, 0, sizeof(sks));
|
|
|
|
sks[0] = 0x80;
|
|
|
|
if (c_d)
|
|
|
|
sks[0] |= 0x40;
|
|
|
|
if (in_bit >= 0) {
|
|
|
|
sks[0] |= 0x8;
|
|
|
|
sks[0] |= 0x7 & in_bit;
|
|
|
|
}
|
|
|
|
put_unaligned_be16(in_byte, sks + 1);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_dsense) {
|
2014-11-25 04:04:47 +00:00
|
|
|
sl = sbuff[7] + 8;
|
|
|
|
sbuff[7] = sl;
|
|
|
|
sbuff[sl] = 0x2;
|
|
|
|
sbuff[sl + 1] = 0x6;
|
|
|
|
memcpy(sbuff + sl + 4, sks, 3);
|
|
|
|
} else
|
|
|
|
memcpy(sbuff + 15, sks, 3);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2014-11-25 04:04:47 +00:00
|
|
|
sdev_printk(KERN_INFO, scp->device, "%s: [sense_key,asc,ascq"
|
|
|
|
"]: [0x5,0x%x,0x0] %c byte=%d, bit=%d\n",
|
|
|
|
my_name, asc, c_d ? 'C' : 'D', in_byte, in_bit);
|
|
|
|
}
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
static void mk_sense_buffer(struct scsi_cmnd *scp, int key, int asc, int asq)
|
2008-03-29 15:59:58 +00:00
|
|
|
{
|
|
|
|
unsigned char *sbuff;
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
sbuff = scp->sense_buffer;
|
|
|
|
if (!sbuff) {
|
|
|
|
sdev_printk(KERN_ERR, scp->device,
|
|
|
|
"%s: sense_buffer is NULL\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
memset(sbuff, 0, SCSI_SENSE_BUFFERSIZE);
|
2008-03-29 15:59:58 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
scsi_build_sense_buffer(sdebug_dsense, sbuff, key, asc, asq);
|
2008-03-29 15:59:58 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2014-07-26 15:55:35 +00:00
|
|
|
sdev_printk(KERN_INFO, scp->device,
|
|
|
|
"%s: [sense_key,asc,ascq]: [0x%x,0x%x,0x%x]\n",
|
|
|
|
my_name, key, asc, asq);
|
2008-03-29 15:59:58 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static void mk_sense_invalid_opcode(struct scsi_cmnd *scp)
|
2014-11-25 04:04:47 +00:00
|
|
|
{
|
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
|
|
|
|
}
|
|
|
|
|
2019-02-07 16:07:20 +00:00
|
|
|
static int scsi_debug_ioctl(struct scsi_device *dev, unsigned int cmd,
|
|
|
|
void __user *arg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose) {
|
2014-07-26 15:55:35 +00:00
|
|
|
if (0x1261 == cmd)
|
|
|
|
sdev_printk(KERN_INFO, dev,
|
|
|
|
"%s: BLKFLSBUF [0x1261]\n", __func__);
|
|
|
|
else if (0x5331 == cmd)
|
|
|
|
sdev_printk(KERN_INFO, dev,
|
|
|
|
"%s: CDROM_GET_CAPABILITY [0x5331]\n",
|
|
|
|
__func__);
|
|
|
|
else
|
|
|
|
sdev_printk(KERN_INFO, dev, "%s: cmd=0x%x\n",
|
|
|
|
__func__, cmd);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
/* return -ENOTTY; // correct return but upsets fdisk */
|
|
|
|
}
|
|
|
|
|
2017-12-05 05:05:49 +00:00
|
|
|
static void config_cdb_len(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
switch (sdebug_cdb_len) {
|
|
|
|
case 6: /* suggest 6 byte READ, WRITE and MODE SENSE/SELECT */
|
|
|
|
sdev->use_10_for_rw = false;
|
|
|
|
sdev->use_16_for_rw = false;
|
|
|
|
sdev->use_10_for_ms = false;
|
|
|
|
break;
|
|
|
|
case 10: /* suggest 10 byte RWs and 6 byte MODE SENSE/SELECT */
|
|
|
|
sdev->use_10_for_rw = true;
|
|
|
|
sdev->use_16_for_rw = false;
|
|
|
|
sdev->use_10_for_ms = false;
|
|
|
|
break;
|
|
|
|
case 12: /* suggest 10 byte RWs and 10 byte MODE SENSE/SELECT */
|
|
|
|
sdev->use_10_for_rw = true;
|
|
|
|
sdev->use_16_for_rw = false;
|
|
|
|
sdev->use_10_for_ms = true;
|
|
|
|
break;
|
|
|
|
case 16:
|
|
|
|
sdev->use_10_for_rw = false;
|
|
|
|
sdev->use_16_for_rw = true;
|
|
|
|
sdev->use_10_for_ms = true;
|
|
|
|
break;
|
|
|
|
case 32: /* No knobs to suggest this so same as 16 for now */
|
|
|
|
sdev->use_10_for_rw = false;
|
|
|
|
sdev->use_16_for_rw = true;
|
|
|
|
sdev->use_10_for_ms = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
pr_warn("unexpected cdb_len=%d, force to 10\n",
|
|
|
|
sdebug_cdb_len);
|
|
|
|
sdev->use_10_for_rw = true;
|
|
|
|
sdev->use_16_for_rw = false;
|
|
|
|
sdev->use_10_for_ms = false;
|
|
|
|
sdebug_cdb_len = 10;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void all_config_cdb_len(void)
|
|
|
|
{
|
|
|
|
struct sdebug_host_info *sdbg_host;
|
|
|
|
struct Scsi_Host *shost;
|
|
|
|
struct scsi_device *sdev;
|
|
|
|
|
|
|
|
spin_lock(&sdebug_host_list_lock);
|
|
|
|
list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
|
|
|
|
shost = sdbg_host->shost;
|
|
|
|
shost_for_each_device(sdev, shost) {
|
|
|
|
config_cdb_len(sdev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&sdebug_host_list_lock);
|
|
|
|
}
|
|
|
|
|
2014-12-04 16:49:27 +00:00
|
|
|
static void clear_luns_changed_on_target(struct sdebug_dev_info *devip)
|
|
|
|
{
|
|
|
|
struct sdebug_host_info *sdhp;
|
|
|
|
struct sdebug_dev_info *dp;
|
|
|
|
|
|
|
|
spin_lock(&sdebug_host_list_lock);
|
|
|
|
list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
|
|
|
|
list_for_each_entry(dp, &sdhp->dev_info_list, dev_list) {
|
|
|
|
if ((devip->sdbg_host == dp->sdbg_host) &&
|
|
|
|
(devip->target == dp->target))
|
|
|
|
clear_bit(SDEBUG_UA_LUNS_CHANGED, dp->uas_bm);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&sdebug_host_list_lock);
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:34 +00:00
|
|
|
static int make_ua(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-07-26 15:55:35 +00:00
|
|
|
int k;
|
|
|
|
|
|
|
|
k = find_first_bit(devip->uas_bm, SDEBUG_NUM_UAS);
|
|
|
|
if (k != SDEBUG_NUM_UAS) {
|
|
|
|
const char *cp = NULL;
|
|
|
|
|
|
|
|
switch (k) {
|
|
|
|
case SDEBUG_UA_POR:
|
2016-04-25 16:16:34 +00:00
|
|
|
mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
|
|
|
|
POWER_ON_RESET_ASCQ);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2014-07-26 15:55:35 +00:00
|
|
|
cp = "power on reset";
|
|
|
|
break;
|
|
|
|
case SDEBUG_UA_BUS_RESET:
|
2016-04-25 16:16:34 +00:00
|
|
|
mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
|
|
|
|
BUS_RESET_ASCQ);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2014-07-26 15:55:35 +00:00
|
|
|
cp = "bus reset";
|
|
|
|
break;
|
|
|
|
case SDEBUG_UA_MODE_CHANGED:
|
2016-04-25 16:16:34 +00:00
|
|
|
mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
|
|
|
|
MODE_CHANGED_ASCQ);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2014-07-26 15:55:35 +00:00
|
|
|
cp = "mode parameters changed";
|
|
|
|
break;
|
2014-11-25 01:27:51 +00:00
|
|
|
case SDEBUG_UA_CAPACITY_CHANGED:
|
2016-04-25 16:16:34 +00:00
|
|
|
mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
|
|
|
|
CAPACITY_CHANGED_ASCQ);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2014-11-25 01:27:51 +00:00
|
|
|
cp = "capacity data changed";
|
2014-12-04 16:49:25 +00:00
|
|
|
break;
|
2014-12-04 16:49:28 +00:00
|
|
|
case SDEBUG_UA_MICROCODE_CHANGED:
|
2016-04-25 16:16:34 +00:00
|
|
|
mk_sense_buffer(scp, UNIT_ATTENTION,
|
2016-05-01 02:44:42 +00:00
|
|
|
TARGET_CHANGED_ASC,
|
|
|
|
MICROCODE_CHANGED_ASCQ);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2014-12-04 16:49:28 +00:00
|
|
|
cp = "microcode has been changed";
|
|
|
|
break;
|
|
|
|
case SDEBUG_UA_MICROCODE_CHANGED_WO_RESET:
|
2016-04-25 16:16:34 +00:00
|
|
|
mk_sense_buffer(scp, UNIT_ATTENTION,
|
2014-12-04 16:49:28 +00:00
|
|
|
TARGET_CHANGED_ASC,
|
|
|
|
MICROCODE_CHANGED_WO_RESET_ASCQ);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2014-12-04 16:49:28 +00:00
|
|
|
cp = "microcode has been changed without reset";
|
|
|
|
break;
|
2014-12-04 16:49:27 +00:00
|
|
|
case SDEBUG_UA_LUNS_CHANGED:
|
|
|
|
/*
|
|
|
|
* SPC-3 behavior is to report a UNIT ATTENTION with
|
|
|
|
* ASC/ASCQ REPORTED LUNS DATA HAS CHANGED on every LUN
|
|
|
|
* on the target, until a REPORT LUNS command is
|
|
|
|
* received. SPC-4 behavior is to report it only once.
|
2016-04-25 16:16:28 +00:00
|
|
|
* NOTE: sdebug_scsi_level does not use the same
|
2014-12-04 16:49:27 +00:00
|
|
|
* values as struct scsi_device->scsi_level.
|
|
|
|
*/
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_scsi_level >= 6) /* SPC-4 and above */
|
2014-12-04 16:49:27 +00:00
|
|
|
clear_luns_changed_on_target(devip);
|
2016-04-25 16:16:34 +00:00
|
|
|
mk_sense_buffer(scp, UNIT_ATTENTION,
|
2014-12-04 16:49:27 +00:00
|
|
|
TARGET_CHANGED_ASC,
|
|
|
|
LUNS_CHANGED_ASCQ);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2014-12-04 16:49:27 +00:00
|
|
|
cp = "reported luns data has changed";
|
|
|
|
break;
|
2014-07-26 15:55:35 +00:00
|
|
|
default:
|
2016-04-25 16:16:28 +00:00
|
|
|
pr_warn("unexpected unit attention code=%d\n", k);
|
|
|
|
if (sdebug_verbose)
|
2014-07-26 15:55:35 +00:00
|
|
|
cp = "unknown";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
clear_bit(k, devip->uas_bm);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2016-04-25 16:16:34 +00:00
|
|
|
sdev_printk(KERN_INFO, scp->device,
|
2014-07-26 15:55:35 +00:00
|
|
|
"%s reports: Unit attention: %s\n",
|
|
|
|
my_name, cp);
|
2005-04-16 22:20:36 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-05-31 21:15:07 +00:00
|
|
|
/* Build SCSI "data-in" buffer. Returns 0 if ok else (DID_ERROR << 16). */
|
2008-03-09 04:44:30 +00:00
|
|
|
static int fill_from_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
|
2005-04-16 22:20:36 +00:00
|
|
|
int arr_len)
|
|
|
|
{
|
2008-03-09 04:44:30 +00:00
|
|
|
int act_len;
|
2019-01-29 08:33:07 +00:00
|
|
|
struct scsi_data_buffer *sdb = &scp->sdb;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-01-22 16:32:00 +00:00
|
|
|
if (!sdb->length)
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
2019-01-29 08:33:07 +00:00
|
|
|
if (scp->sc_data_direction != DMA_FROM_DEVICE)
|
2016-04-25 16:16:28 +00:00
|
|
|
return DID_ERROR << 16;
|
2008-03-09 04:44:30 +00:00
|
|
|
|
|
|
|
act_len = sg_copy_from_buffer(sdb->table.sgl, sdb->table.nents,
|
|
|
|
arr, arr_len);
|
2019-02-08 21:25:00 +00:00
|
|
|
scsi_set_resid(scp, scsi_bufflen(scp) - act_len);
|
2008-03-09 04:44:30 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-05-31 21:15:07 +00:00
|
|
|
/* Partial build of SCSI "data-in" buffer. Returns 0 if ok else
|
|
|
|
* (DID_ERROR << 16). Can write to offset in data-in buffer. If multiple
|
|
|
|
* calls, not required to write in ascending offset order. Assumes resid
|
|
|
|
* set to scsi_bufflen() prior to any calls.
|
|
|
|
*/
|
|
|
|
static int p_fill_from_dev_buffer(struct scsi_cmnd *scp, const void *arr,
|
|
|
|
int arr_len, unsigned int off_dst)
|
|
|
|
{
|
|
|
|
int act_len, n;
|
2019-01-29 08:33:07 +00:00
|
|
|
struct scsi_data_buffer *sdb = &scp->sdb;
|
2016-05-31 21:15:07 +00:00
|
|
|
off_t skip = off_dst;
|
|
|
|
|
|
|
|
if (sdb->length <= off_dst)
|
|
|
|
return 0;
|
2019-01-29 08:33:07 +00:00
|
|
|
if (scp->sc_data_direction != DMA_FROM_DEVICE)
|
2016-05-31 21:15:07 +00:00
|
|
|
return DID_ERROR << 16;
|
|
|
|
|
|
|
|
act_len = sg_pcopy_from_buffer(sdb->table.sgl, sdb->table.nents,
|
|
|
|
arr, arr_len, skip);
|
|
|
|
pr_debug("%s: off_dst=%u, scsi_bufflen=%u, act_len=%u, resid=%d\n",
|
2019-02-08 21:25:00 +00:00
|
|
|
__func__, off_dst, scsi_bufflen(scp), act_len,
|
|
|
|
scsi_get_resid(scp));
|
2016-05-31 21:15:07 +00:00
|
|
|
n = (int)scsi_bufflen(scp) - ((int)off_dst + act_len);
|
2019-02-08 21:25:00 +00:00
|
|
|
scsi_set_resid(scp, min(scsi_get_resid(scp), n));
|
2016-05-31 21:15:07 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fetches from SCSI "data-out" buffer. Returns number of bytes fetched into
|
|
|
|
* 'arr' or -1 if error.
|
|
|
|
*/
|
2008-03-09 04:44:30 +00:00
|
|
|
static int fetch_to_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
|
|
|
|
int arr_len)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-03-09 04:44:30 +00:00
|
|
|
if (!scsi_bufflen(scp))
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
2019-01-29 08:33:07 +00:00
|
|
|
if (scp->sc_data_direction != DMA_TO_DEVICE)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -1;
|
2008-03-09 04:44:30 +00:00
|
|
|
|
|
|
|
return scsi_sg_copy_to_buffer(scp, arr, arr_len);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-10-02 14:26:33 +00:00
|
|
|
static char sdebug_inq_vendor_id[9] = "Linux ";
|
|
|
|
static char sdebug_inq_product_id[17] = "scsi_debug ";
|
2017-12-05 05:05:49 +00:00
|
|
|
static char sdebug_inq_product_rev[5] = SDEBUG_VERSION;
|
2016-05-06 04:40:29 +00:00
|
|
|
/* Use some locally assigned NAAs for SAS addresses. */
|
|
|
|
static const u64 naa3_comp_a = 0x3222222000000000ULL;
|
|
|
|
static const u64 naa3_comp_b = 0x3333333000000000ULL;
|
|
|
|
static const u64 naa3_comp_c = 0x3111111000000000ULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
/* Device identification VPD page. Returns number of bytes placed in arr */
|
2016-05-06 04:40:27 +00:00
|
|
|
static int inquiry_vpd_83(unsigned char *arr, int port_group_id,
|
|
|
|
int target_dev_id, int dev_id_num,
|
2016-05-06 04:40:28 +00:00
|
|
|
const char *dev_id_str, int dev_id_str_len,
|
2017-05-17 07:55:26 +00:00
|
|
|
const uuid_t *lu_name)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-06-06 04:11:24 +00:00
|
|
|
int num, port_a;
|
|
|
|
char b[32];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-06 04:11:24 +00:00
|
|
|
port_a = target_dev_id + 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
/* T10 vendor identifier field format (faked) */
|
|
|
|
arr[0] = 0x2; /* ASCII */
|
|
|
|
arr[1] = 0x1;
|
|
|
|
arr[2] = 0x0;
|
2017-10-02 14:26:33 +00:00
|
|
|
memcpy(&arr[4], sdebug_inq_vendor_id, 8);
|
|
|
|
memcpy(&arr[12], sdebug_inq_product_id, 16);
|
2005-04-16 22:20:36 +00:00
|
|
|
memcpy(&arr[28], dev_id_str, dev_id_str_len);
|
|
|
|
num = 8 + 16 + dev_id_str_len;
|
|
|
|
arr[3] = num;
|
|
|
|
num += 4;
|
2006-06-06 04:11:24 +00:00
|
|
|
if (dev_id_num >= 0) {
|
2016-05-06 04:40:28 +00:00
|
|
|
if (sdebug_uuid_ctl) {
|
|
|
|
/* Locally assigned UUID */
|
|
|
|
arr[num++] = 0x1; /* binary (not necessarily sas) */
|
|
|
|
arr[num++] = 0xa; /* PIV=0, lu, naa */
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
arr[num++] = 0x12;
|
|
|
|
arr[num++] = 0x10; /* uuid type=1, locally assigned */
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
memcpy(arr + num, lu_name, 16);
|
|
|
|
num += 16;
|
|
|
|
} else {
|
2016-05-06 04:40:29 +00:00
|
|
|
/* NAA-3, Logical unit identifier (binary) */
|
2016-05-06 04:40:28 +00:00
|
|
|
arr[num++] = 0x1; /* binary (not necessarily sas) */
|
|
|
|
arr[num++] = 0x3; /* PIV=0, lu, naa */
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
arr[num++] = 0x8;
|
2016-05-06 04:40:29 +00:00
|
|
|
put_unaligned_be64(naa3_comp_b + dev_id_num, arr + num);
|
2016-05-06 04:40:28 +00:00
|
|
|
num += 8;
|
|
|
|
}
|
2006-06-06 04:11:24 +00:00
|
|
|
/* Target relative port number */
|
|
|
|
arr[num++] = 0x61; /* proto=sas, binary */
|
|
|
|
arr[num++] = 0x94; /* PIV=1, target port, rel port */
|
|
|
|
arr[num++] = 0x0; /* reserved */
|
|
|
|
arr[num++] = 0x4; /* length */
|
|
|
|
arr[num++] = 0x0; /* reserved */
|
|
|
|
arr[num++] = 0x0; /* reserved */
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
arr[num++] = 0x1; /* relative port A */
|
|
|
|
}
|
2016-05-06 04:40:29 +00:00
|
|
|
/* NAA-3, Target port identifier */
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[num++] = 0x61; /* proto=sas, binary */
|
|
|
|
arr[num++] = 0x93; /* piv=1, target port, naa */
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
arr[num++] = 0x8;
|
2016-05-06 04:40:29 +00:00
|
|
|
put_unaligned_be64(naa3_comp_a + port_a, arr + num);
|
2016-04-25 16:16:28 +00:00
|
|
|
num += 8;
|
2016-05-06 04:40:29 +00:00
|
|
|
/* NAA-3, Target port group identifier */
|
2006-10-20 07:58:47 +00:00
|
|
|
arr[num++] = 0x61; /* proto=sas, binary */
|
|
|
|
arr[num++] = 0x95; /* piv=1, target port group id */
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
arr[num++] = 0x4;
|
|
|
|
arr[num++] = 0;
|
|
|
|
arr[num++] = 0;
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be16(port_group_id, arr + num);
|
|
|
|
num += 2;
|
2016-05-06 04:40:29 +00:00
|
|
|
/* NAA-3, Target device identifier */
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[num++] = 0x61; /* proto=sas, binary */
|
|
|
|
arr[num++] = 0xa3; /* piv=1, target device, naa */
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
arr[num++] = 0x8;
|
2016-05-06 04:40:29 +00:00
|
|
|
put_unaligned_be64(naa3_comp_a + target_dev_id, arr + num);
|
2016-04-25 16:16:28 +00:00
|
|
|
num += 8;
|
2006-06-06 04:11:24 +00:00
|
|
|
/* SCSI name string: Target device identifier */
|
|
|
|
arr[num++] = 0x63; /* proto=sas, UTF-8 */
|
|
|
|
arr[num++] = 0xa8; /* piv=1, target device, SCSI name string */
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
arr[num++] = 24;
|
2016-05-06 04:40:29 +00:00
|
|
|
memcpy(arr + num, "naa.32222220", 12);
|
2006-06-06 04:11:24 +00:00
|
|
|
num += 12;
|
|
|
|
snprintf(b, sizeof(b), "%08X", target_dev_id);
|
|
|
|
memcpy(arr + num, b, 8);
|
|
|
|
num += 8;
|
|
|
|
memset(arr + num, 0, 4);
|
|
|
|
num += 4;
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned char vpd84_data[] = {
|
|
|
|
/* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
|
|
|
|
0x22,0x22,0x22,0x0,0xbb,0x1,
|
|
|
|
0x22,0x22,0x22,0x0,0xbb,0x2,
|
|
|
|
};
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
/* Software interface identification VPD page */
|
2016-05-06 04:40:27 +00:00
|
|
|
static int inquiry_vpd_84(unsigned char *arr)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
|
|
|
memcpy(arr, vpd84_data, sizeof(vpd84_data));
|
|
|
|
return sizeof(vpd84_data);
|
|
|
|
}
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
/* Management network addresses VPD page */
|
2016-05-06 04:40:27 +00:00
|
|
|
static int inquiry_vpd_85(unsigned char *arr)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
|
|
|
int num = 0;
|
2018-02-10 02:12:43 +00:00
|
|
|
const char *na1 = "https://www.kernel.org/config";
|
|
|
|
const char *na2 = "http://www.kernel.org/log";
|
2006-06-06 04:11:24 +00:00
|
|
|
int plen, olen;
|
|
|
|
|
|
|
|
arr[num++] = 0x1; /* lu, storage config */
|
|
|
|
arr[num++] = 0x0; /* reserved */
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
olen = strlen(na1);
|
|
|
|
plen = olen + 1;
|
|
|
|
if (plen % 4)
|
|
|
|
plen = ((plen / 4) + 1) * 4;
|
|
|
|
arr[num++] = plen; /* length, null termianted, padded */
|
|
|
|
memcpy(arr + num, na1, olen);
|
|
|
|
memset(arr + num + olen, 0, plen - olen);
|
|
|
|
num += plen;
|
|
|
|
|
|
|
|
arr[num++] = 0x4; /* lu, logging */
|
|
|
|
arr[num++] = 0x0; /* reserved */
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
olen = strlen(na2);
|
|
|
|
plen = olen + 1;
|
|
|
|
if (plen % 4)
|
|
|
|
plen = ((plen / 4) + 1) * 4;
|
|
|
|
arr[num++] = plen; /* length, null terminated, padded */
|
|
|
|
memcpy(arr + num, na2, olen);
|
|
|
|
memset(arr + num + olen, 0, plen - olen);
|
|
|
|
num += plen;
|
|
|
|
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* SCSI ports VPD page */
|
2016-05-06 04:40:27 +00:00
|
|
|
static int inquiry_vpd_88(unsigned char *arr, int target_dev_id)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
|
|
|
int num = 0;
|
|
|
|
int port_a, port_b;
|
|
|
|
|
|
|
|
port_a = target_dev_id + 1;
|
|
|
|
port_b = port_a + 1;
|
|
|
|
arr[num++] = 0x0; /* reserved */
|
|
|
|
arr[num++] = 0x0; /* reserved */
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
arr[num++] = 0x1; /* relative port 1 (primary) */
|
|
|
|
memset(arr + num, 0, 6);
|
|
|
|
num += 6;
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
arr[num++] = 12; /* length tp descriptor */
|
|
|
|
/* naa-5 target port identifier (A) */
|
|
|
|
arr[num++] = 0x61; /* proto=sas, binary */
|
|
|
|
arr[num++] = 0x93; /* PIV=1, target port, NAA */
|
|
|
|
arr[num++] = 0x0; /* reserved */
|
|
|
|
arr[num++] = 0x8; /* length */
|
2016-05-06 04:40:29 +00:00
|
|
|
put_unaligned_be64(naa3_comp_a + port_a, arr + num);
|
2016-04-25 16:16:28 +00:00
|
|
|
num += 8;
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[num++] = 0x0; /* reserved */
|
|
|
|
arr[num++] = 0x0; /* reserved */
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
arr[num++] = 0x2; /* relative port 2 (secondary) */
|
|
|
|
memset(arr + num, 0, 6);
|
|
|
|
num += 6;
|
|
|
|
arr[num++] = 0x0;
|
|
|
|
arr[num++] = 12; /* length tp descriptor */
|
|
|
|
/* naa-5 target port identifier (B) */
|
|
|
|
arr[num++] = 0x61; /* proto=sas, binary */
|
|
|
|
arr[num++] = 0x93; /* PIV=1, target port, NAA */
|
|
|
|
arr[num++] = 0x0; /* reserved */
|
|
|
|
arr[num++] = 0x8; /* length */
|
2016-05-06 04:40:29 +00:00
|
|
|
put_unaligned_be64(naa3_comp_a + port_b, arr + num);
|
2016-04-25 16:16:28 +00:00
|
|
|
num += 8;
|
2006-06-06 04:11:24 +00:00
|
|
|
|
|
|
|
return num;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static unsigned char vpd89_data[] = {
|
|
|
|
/* from 4th byte */ 0,0,0,0,
|
|
|
|
'l','i','n','u','x',' ',' ',' ',
|
|
|
|
'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
|
|
|
|
'1','2','3','4',
|
|
|
|
0x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
|
|
|
|
0xec,0,0,0,
|
|
|
|
0x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
|
|
|
|
0,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
|
|
|
|
0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
|
|
|
|
0x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
|
|
|
|
0x53,0x41,
|
|
|
|
0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
|
|
|
|
0x20,0x20,
|
|
|
|
0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
|
|
|
|
0x10,0x80,
|
|
|
|
0,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
|
|
|
|
0x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
|
|
|
|
0x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
|
|
|
|
0x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
|
|
|
|
0x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
|
|
|
|
0,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
|
|
|
|
0xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
|
|
|
|
0,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
|
|
|
|
};
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
/* ATA Information VPD page */
|
2016-05-06 04:40:27 +00:00
|
|
|
static int inquiry_vpd_89(unsigned char *arr)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
|
|
|
memcpy(arr, vpd89_data, sizeof(vpd89_data));
|
|
|
|
return sizeof(vpd89_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static unsigned char vpdb0_data[] = {
|
2009-10-29 05:48:31 +00:00
|
|
|
/* from 4th byte */ 0,0,0,4, 0,0,0x4,0, 0,0,0,64,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
2006-06-06 04:11:24 +00:00
|
|
|
};
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
/* Block limits VPD page (SBC-3) */
|
2016-05-06 04:40:27 +00:00
|
|
|
static int inquiry_vpd_b0(unsigned char *arr)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
2009-05-15 04:40:33 +00:00
|
|
|
unsigned int gran;
|
|
|
|
|
2006-06-06 04:11:24 +00:00
|
|
|
memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
|
2010-03-23 05:12:27 +00:00
|
|
|
|
|
|
|
/* Optimal transfer length granularity */
|
2017-01-26 09:00:37 +00:00
|
|
|
if (sdebug_opt_xferlen_exp != 0 &&
|
|
|
|
sdebug_physblk_exp < sdebug_opt_xferlen_exp)
|
|
|
|
gran = 1 << sdebug_opt_xferlen_exp;
|
|
|
|
else
|
|
|
|
gran = 1 << sdebug_physblk_exp;
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be16(gran, arr + 2);
|
2010-03-23 05:12:27 +00:00
|
|
|
|
|
|
|
/* Maximum Transfer Length */
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_store_sectors > 0x400)
|
|
|
|
put_unaligned_be32(sdebug_store_sectors, arr + 4);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2010-03-23 05:12:27 +00:00
|
|
|
/* Optimal Transfer Length */
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be32(sdebug_opt_blks, &arr[8]);
|
2010-03-23 05:12:27 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_lbpu) {
|
2010-03-23 05:12:27 +00:00
|
|
|
/* Maximum Unmap LBA Count */
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be32(sdebug_unmap_max_blocks, &arr[16]);
|
2010-03-23 05:12:27 +00:00
|
|
|
|
|
|
|
/* Maximum Unmap Block Descriptor Count */
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be32(sdebug_unmap_max_desc, &arr[20]);
|
2009-10-15 18:45:27 +00:00
|
|
|
}
|
|
|
|
|
2010-03-23 05:12:27 +00:00
|
|
|
/* Unmap Granularity Alignment */
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_unmap_alignment) {
|
|
|
|
put_unaligned_be32(sdebug_unmap_alignment, &arr[28]);
|
2009-10-15 18:45:27 +00:00
|
|
|
arr[28] |= 0x80; /* UGAVALID */
|
|
|
|
}
|
|
|
|
|
2010-03-23 05:12:27 +00:00
|
|
|
/* Optimal Unmap Granularity */
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be32(sdebug_unmap_granularity, &arr[24]);
|
2010-08-19 15:49:00 +00:00
|
|
|
|
2011-03-08 07:08:11 +00:00
|
|
|
/* Maximum WRITE SAME Length */
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be64(sdebug_write_same_length, &arr[32]);
|
2011-03-08 07:08:11 +00:00
|
|
|
|
|
|
|
return 0x3c; /* Mandatory page length for Logical Block Provisioning */
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2006-06-06 04:11:24 +00:00
|
|
|
return sizeof(vpdb0_data);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-10-29 05:48:31 +00:00
|
|
|
/* Block device characteristics VPD page (SBC-3) */
|
2016-05-06 04:40:27 +00:00
|
|
|
static int inquiry_vpd_b1(unsigned char *arr)
|
2008-06-19 16:02:58 +00:00
|
|
|
{
|
|
|
|
memset(arr, 0, 0x3c);
|
|
|
|
arr[0] = 0;
|
2009-10-29 05:48:31 +00:00
|
|
|
arr[1] = 1; /* non rotating medium (e.g. solid state) */
|
|
|
|
arr[2] = 0;
|
|
|
|
arr[3] = 5; /* less than 1.8" */
|
2008-06-19 16:02:58 +00:00
|
|
|
|
|
|
|
return 0x3c;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-05-06 04:40:27 +00:00
|
|
|
/* Logical block provisioning VPD page (SBC-4) */
|
|
|
|
static int inquiry_vpd_b2(unsigned char *arr)
|
2010-08-19 15:49:00 +00:00
|
|
|
{
|
2012-03-08 15:48:29 +00:00
|
|
|
memset(arr, 0, 0x4);
|
2010-08-19 15:49:00 +00:00
|
|
|
arr[0] = 0; /* threshold exponent */
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_lbpu)
|
2010-08-19 15:49:00 +00:00
|
|
|
arr[1] = 1 << 7;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_lbpws)
|
2010-08-19 15:49:00 +00:00
|
|
|
arr[1] |= 1 << 6;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_lbpws10)
|
2011-03-08 07:08:11 +00:00
|
|
|
arr[1] |= 1 << 5;
|
2016-05-06 04:40:27 +00:00
|
|
|
if (sdebug_lbprz && scsi_debug_lbp())
|
|
|
|
arr[1] |= (sdebug_lbprz & 0x7) << 2; /* sbc4r07 and later */
|
|
|
|
/* anc_sup=0; dp=0 (no provisioning group descriptor) */
|
|
|
|
/* minimum_percentage=0; provisioning_type=0 (unknown) */
|
|
|
|
/* threshold_percentage=0 */
|
2012-03-08 15:48:29 +00:00
|
|
|
return 0x4;
|
2010-08-19 15:49:00 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define SDEBUG_LONG_INQ_SZ 96
|
2006-06-06 04:11:24 +00:00
|
|
|
#define SDEBUG_MAX_INQ_ARR_SZ 584
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
static int resp_inquiry(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned char pq_pdt;
|
2018-02-10 02:12:43 +00:00
|
|
|
unsigned char *arr;
|
2014-08-05 10:20:02 +00:00
|
|
|
unsigned char *cmd = scp->cmnd;
|
2006-10-20 07:58:47 +00:00
|
|
|
int alloc_len, n, ret;
|
2016-05-06 04:40:27 +00:00
|
|
|
bool have_wlun, is_disk;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
alloc_len = get_unaligned_be16(cmd + 3);
|
2007-01-05 05:05:25 +00:00
|
|
|
arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
|
|
|
|
if (! arr)
|
|
|
|
return DID_REQUEUE << 16;
|
2016-05-06 04:40:27 +00:00
|
|
|
is_disk = (sdebug_ptype == TYPE_DISK);
|
2016-05-01 02:44:42 +00:00
|
|
|
have_wlun = scsi_is_wlun(scp->device->lun);
|
2014-11-25 01:46:29 +00:00
|
|
|
if (have_wlun)
|
2016-05-01 02:44:42 +00:00
|
|
|
pq_pdt = TYPE_WLUN; /* present, wlun */
|
|
|
|
else if (sdebug_no_lun_0 && (devip->lun == SDEBUG_LUN_0_VAL))
|
|
|
|
pq_pdt = 0x7f; /* not present, PQ=3, PDT=0x1f */
|
2006-06-06 04:11:24 +00:00
|
|
|
else
|
2016-04-25 16:16:28 +00:00
|
|
|
pq_pdt = (sdebug_ptype & 0x1f);
|
2005-04-16 22:20:36 +00:00
|
|
|
arr[0] = pq_pdt;
|
|
|
|
if (0x2 & cmd[1]) { /* CMDDT bit set */
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 1);
|
2006-10-20 07:58:47 +00:00
|
|
|
kfree(arr);
|
2005-04-16 22:20:36 +00:00
|
|
|
return check_condition_result;
|
|
|
|
} else if (0x1 & cmd[1]) { /* EVPD bit set */
|
2006-10-20 07:58:47 +00:00
|
|
|
int lu_id_num, port_group_id, target_dev_id, len;
|
2006-06-06 04:11:24 +00:00
|
|
|
char lu_id_str[6];
|
|
|
|
int host_no = devip->sdbg_host->shost->host_no;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-20 07:58:47 +00:00
|
|
|
port_group_id = (((host_no + 1) & 0x7f) << 8) +
|
|
|
|
(devip->channel & 0x7f);
|
2016-05-01 02:44:42 +00:00
|
|
|
if (sdebug_vpd_use_hostno == 0)
|
2006-09-17 00:30:47 +00:00
|
|
|
host_no = 0;
|
2014-11-25 01:46:29 +00:00
|
|
|
lu_id_num = have_wlun ? -1 : (((host_no + 1) * 2000) +
|
2006-06-06 04:11:24 +00:00
|
|
|
(devip->target * 1000) + devip->lun);
|
|
|
|
target_dev_id = ((host_no + 1) * 2000) +
|
|
|
|
(devip->target * 1000) - 3;
|
|
|
|
len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (0 == cmd[2]) { /* supported vital product data pages */
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[1] = cmd[2]; /*sanity */
|
|
|
|
n = 4;
|
|
|
|
arr[n++] = 0x0; /* this page */
|
|
|
|
arr[n++] = 0x80; /* unit serial number */
|
|
|
|
arr[n++] = 0x83; /* device identification */
|
|
|
|
arr[n++] = 0x84; /* software interface ident. */
|
|
|
|
arr[n++] = 0x85; /* management network addresses */
|
|
|
|
arr[n++] = 0x86; /* extended inquiry */
|
|
|
|
arr[n++] = 0x87; /* mode page policy */
|
|
|
|
arr[n++] = 0x88; /* SCSI ports */
|
2016-05-06 04:40:27 +00:00
|
|
|
if (is_disk) { /* SBC only */
|
|
|
|
arr[n++] = 0x89; /* ATA information */
|
|
|
|
arr[n++] = 0xb0; /* Block limits */
|
|
|
|
arr[n++] = 0xb1; /* Block characteristics */
|
|
|
|
arr[n++] = 0xb2; /* Logical Block Prov */
|
|
|
|
}
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[3] = n - 4; /* number of supported VPD pages */
|
2005-04-16 22:20:36 +00:00
|
|
|
} else if (0x80 == cmd[2]) { /* unit serial number */
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[1] = cmd[2]; /*sanity */
|
2005-04-16 22:20:36 +00:00
|
|
|
arr[3] = len;
|
2006-06-06 04:11:24 +00:00
|
|
|
memcpy(&arr[4], lu_id_str, len);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else if (0x83 == cmd[2]) { /* device identification */
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[1] = cmd[2]; /*sanity */
|
2016-05-06 04:40:27 +00:00
|
|
|
arr[3] = inquiry_vpd_83(&arr[4], port_group_id,
|
|
|
|
target_dev_id, lu_id_num,
|
2016-05-06 04:40:28 +00:00
|
|
|
lu_id_str, len,
|
|
|
|
&devip->lu_name);
|
2006-06-06 04:11:24 +00:00
|
|
|
} else if (0x84 == cmd[2]) { /* Software interface ident. */
|
|
|
|
arr[1] = cmd[2]; /*sanity */
|
2016-05-06 04:40:27 +00:00
|
|
|
arr[3] = inquiry_vpd_84(&arr[4]);
|
2006-06-06 04:11:24 +00:00
|
|
|
} else if (0x85 == cmd[2]) { /* Management network addresses */
|
|
|
|
arr[1] = cmd[2]; /*sanity */
|
2016-05-06 04:40:27 +00:00
|
|
|
arr[3] = inquiry_vpd_85(&arr[4]);
|
2006-06-06 04:11:24 +00:00
|
|
|
} else if (0x86 == cmd[2]) { /* extended inquiry */
|
|
|
|
arr[1] = cmd[2]; /*sanity */
|
|
|
|
arr[3] = 0x3c; /* number of following entries */
|
2016-09-11 17:35:41 +00:00
|
|
|
if (sdebug_dif == T10_PI_TYPE3_PROTECTION)
|
2009-01-04 08:08:19 +00:00
|
|
|
arr[4] = 0x4; /* SPT: GRD_CHK:1 */
|
2016-05-06 04:40:27 +00:00
|
|
|
else if (have_dif_prot)
|
2009-01-04 08:08:19 +00:00
|
|
|
arr[4] = 0x5; /* SPT: GRD_CHK:1, REF_CHK:1 */
|
|
|
|
else
|
|
|
|
arr[4] = 0x0; /* no protection stuff */
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[5] = 0x7; /* head of q, ordered + simple q's */
|
|
|
|
} else if (0x87 == cmd[2]) { /* mode page policy */
|
|
|
|
arr[1] = cmd[2]; /*sanity */
|
|
|
|
arr[3] = 0x8; /* number of following entries */
|
|
|
|
arr[4] = 0x2; /* disconnect-reconnect mp */
|
|
|
|
arr[6] = 0x80; /* mlus, shared */
|
|
|
|
arr[8] = 0x18; /* protocol specific lu */
|
|
|
|
arr[10] = 0x82; /* mlus, per initiator port */
|
|
|
|
} else if (0x88 == cmd[2]) { /* SCSI Ports */
|
|
|
|
arr[1] = cmd[2]; /*sanity */
|
2016-05-06 04:40:27 +00:00
|
|
|
arr[3] = inquiry_vpd_88(&arr[4], target_dev_id);
|
|
|
|
} else if (is_disk && 0x89 == cmd[2]) { /* ATA information */
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[1] = cmd[2]; /*sanity */
|
2016-05-06 04:40:27 +00:00
|
|
|
n = inquiry_vpd_89(&arr[4]);
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be16(n, arr + 2);
|
2016-05-06 04:40:27 +00:00
|
|
|
} else if (is_disk && 0xb0 == cmd[2]) { /* Block limits */
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[1] = cmd[2]; /*sanity */
|
2016-05-06 04:40:27 +00:00
|
|
|
arr[3] = inquiry_vpd_b0(&arr[4]);
|
|
|
|
} else if (is_disk && 0xb1 == cmd[2]) { /* Block char. */
|
2008-06-19 16:02:58 +00:00
|
|
|
arr[1] = cmd[2]; /*sanity */
|
2016-05-06 04:40:27 +00:00
|
|
|
arr[3] = inquiry_vpd_b1(&arr[4]);
|
|
|
|
} else if (is_disk && 0xb2 == cmd[2]) { /* LB Prov. */
|
2010-08-19 15:49:00 +00:00
|
|
|
arr[1] = cmd[2]; /*sanity */
|
2016-05-06 04:40:27 +00:00
|
|
|
arr[3] = inquiry_vpd_b2(&arr[4]);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, -1);
|
2006-10-20 07:58:47 +00:00
|
|
|
kfree(arr);
|
2005-04-16 22:20:36 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
2016-04-25 16:16:28 +00:00
|
|
|
len = min(get_unaligned_be16(arr + 2) + 4, alloc_len);
|
2006-10-20 07:58:47 +00:00
|
|
|
ret = fill_from_dev_buffer(scp, arr,
|
2006-06-06 04:11:24 +00:00
|
|
|
min(len, SDEBUG_MAX_INQ_ARR_SZ));
|
2006-10-20 07:58:47 +00:00
|
|
|
kfree(arr);
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
/* drops through here for a standard inquiry */
|
2016-04-25 16:16:28 +00:00
|
|
|
arr[1] = sdebug_removable ? 0x80 : 0; /* Removable disk */
|
|
|
|
arr[2] = sdebug_scsi_level;
|
2005-04-16 22:20:36 +00:00
|
|
|
arr[3] = 2; /* response_data_format==2 */
|
|
|
|
arr[4] = SDEBUG_LONG_INQ_SZ - 5;
|
2016-04-25 16:16:34 +00:00
|
|
|
arr[5] = (int)have_dif_prot; /* PROTECT bit */
|
2016-05-01 02:44:42 +00:00
|
|
|
if (sdebug_vpd_use_hostno == 0)
|
2017-05-19 16:39:36 +00:00
|
|
|
arr[5] |= 0x10; /* claim: implicit TPGS */
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[6] = 0x10; /* claim: MultiP */
|
2005-04-16 22:20:36 +00:00
|
|
|
/* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[7] = 0xa; /* claim: LINKED + CMDQUE */
|
2017-10-02 14:26:33 +00:00
|
|
|
memcpy(&arr[8], sdebug_inq_vendor_id, 8);
|
|
|
|
memcpy(&arr[16], sdebug_inq_product_id, 16);
|
|
|
|
memcpy(&arr[32], sdebug_inq_product_rev, 4);
|
2017-12-05 05:05:49 +00:00
|
|
|
/* Use Vendor Specific area to place driver date in ASCII hex */
|
|
|
|
memcpy(&arr[36], sdebug_version_date, 8);
|
2005-04-16 22:20:36 +00:00
|
|
|
/* version descriptors (2 bytes each) follow */
|
2016-05-06 04:40:27 +00:00
|
|
|
put_unaligned_be16(0xc0, arr + 58); /* SAM-6 no version claimed */
|
|
|
|
put_unaligned_be16(0x5c0, arr + 60); /* SPC-5 no version claimed */
|
2006-06-06 04:11:24 +00:00
|
|
|
n = 62;
|
2016-05-06 04:40:27 +00:00
|
|
|
if (is_disk) { /* SBC-4 no version claimed */
|
|
|
|
put_unaligned_be16(0x600, arr + n);
|
|
|
|
n += 2;
|
|
|
|
} else if (sdebug_ptype == TYPE_TAPE) { /* SSC-4 rev 3 */
|
|
|
|
put_unaligned_be16(0x525, arr + n);
|
|
|
|
n += 2;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-05-06 04:40:27 +00:00
|
|
|
put_unaligned_be16(0x2100, arr + n); /* SPL-4 no version claimed */
|
2006-10-20 07:58:47 +00:00
|
|
|
ret = fill_from_dev_buffer(scp, arr,
|
2005-04-16 22:20:36 +00:00
|
|
|
min(alloc_len, SDEBUG_LONG_INQ_SZ));
|
2006-10-20 07:58:47 +00:00
|
|
|
kfree(arr);
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0x0, 0x0};
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_requests(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2018-02-10 02:12:43 +00:00
|
|
|
unsigned char *sbuff;
|
2014-08-05 10:20:02 +00:00
|
|
|
unsigned char *cmd = scp->cmnd;
|
2014-07-26 15:55:35 +00:00
|
|
|
unsigned char arr[SCSI_SENSE_BUFFERSIZE];
|
2015-07-28 13:54:26 +00:00
|
|
|
bool dsense;
|
2005-04-16 22:20:36 +00:00
|
|
|
int len = 18;
|
|
|
|
|
2006-06-06 04:11:24 +00:00
|
|
|
memset(arr, 0, sizeof(arr));
|
2014-11-25 01:46:29 +00:00
|
|
|
dsense = !!(cmd[1] & 1);
|
2014-07-26 15:55:35 +00:00
|
|
|
sbuff = scp->sense_buffer;
|
2006-06-06 04:11:24 +00:00
|
|
|
if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
|
2014-11-25 01:46:29 +00:00
|
|
|
if (dsense) {
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[0] = 0x72;
|
|
|
|
arr[1] = 0x0; /* NO_SENSE in sense_key */
|
|
|
|
arr[2] = THRESHOLD_EXCEEDED;
|
|
|
|
arr[3] = 0xff; /* TEST set and MRIE==6 */
|
2014-11-25 01:46:29 +00:00
|
|
|
len = 8;
|
2006-06-06 04:11:24 +00:00
|
|
|
} else {
|
|
|
|
arr[0] = 0x70;
|
|
|
|
arr[2] = 0x0; /* NO_SENSE in sense_key */
|
|
|
|
arr[7] = 0xa; /* 18 byte sense buffer */
|
|
|
|
arr[12] = THRESHOLD_EXCEEDED;
|
|
|
|
arr[13] = 0xff; /* TEST set and MRIE==6 */
|
|
|
|
}
|
|
|
|
} else {
|
2014-07-26 15:55:35 +00:00
|
|
|
memcpy(arr, sbuff, SCSI_SENSE_BUFFERSIZE);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (arr[0] >= 0x70 && dsense == sdebug_dsense)
|
2014-11-25 01:46:29 +00:00
|
|
|
; /* have sense and formats match */
|
|
|
|
else if (arr[0] <= 0x70) {
|
|
|
|
if (dsense) {
|
|
|
|
memset(arr, 0, 8);
|
|
|
|
arr[0] = 0x72;
|
|
|
|
len = 8;
|
|
|
|
} else {
|
|
|
|
memset(arr, 0, 18);
|
|
|
|
arr[0] = 0x70;
|
|
|
|
arr[7] = 0xa;
|
|
|
|
}
|
|
|
|
} else if (dsense) {
|
|
|
|
memset(arr, 0, 8);
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[0] = 0x72;
|
|
|
|
arr[1] = sbuff[2]; /* sense key */
|
|
|
|
arr[2] = sbuff[12]; /* asc */
|
|
|
|
arr[3] = sbuff[13]; /* ascq */
|
|
|
|
len = 8;
|
2014-11-25 01:46:29 +00:00
|
|
|
} else {
|
|
|
|
memset(arr, 0, 18);
|
|
|
|
arr[0] = 0x70;
|
|
|
|
arr[2] = sbuff[1];
|
|
|
|
arr[7] = 0xa;
|
|
|
|
arr[12] = sbuff[1];
|
|
|
|
arr[13] = sbuff[3];
|
2006-06-06 04:11:24 +00:00
|
|
|
}
|
2014-11-25 01:46:29 +00:00
|
|
|
|
2006-06-06 04:11:24 +00:00
|
|
|
}
|
2014-07-26 15:55:35 +00:00
|
|
|
mk_sense_buffer(scp, 0, NO_ADDITIONAL_SENSE, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
return fill_from_dev_buffer(scp, arr, len);
|
|
|
|
}
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_start_stop(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
2014-08-05 10:20:02 +00:00
|
|
|
unsigned char *cmd = scp->cmnd;
|
2016-05-06 04:40:26 +00:00
|
|
|
int power_cond, stop;
|
2018-04-10 17:00:36 +00:00
|
|
|
bool changing;
|
2006-06-06 04:11:24 +00:00
|
|
|
|
|
|
|
power_cond = (cmd[4] & 0xf0) >> 4;
|
|
|
|
if (power_cond) {
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, 7);
|
2006-06-06 04:11:24 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
stop = !(cmd[4] & 1);
|
2018-04-10 17:00:36 +00:00
|
|
|
changing = atomic_read(&devip->stopped) == !stop;
|
2016-05-06 04:40:26 +00:00
|
|
|
atomic_xchg(&devip->stopped, stop);
|
2018-04-10 17:00:36 +00:00
|
|
|
if (!changing || cmd[1] & 0x1) /* state unchanged or IMMED set */
|
|
|
|
return SDEG_RES_IMMED_MASK;
|
|
|
|
else
|
|
|
|
return 0;
|
2006-06-06 04:11:24 +00:00
|
|
|
}
|
|
|
|
|
2008-03-29 15:59:55 +00:00
|
|
|
static sector_t get_sdebug_capacity(void)
|
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
static const unsigned int gibibyte = 1073741824;
|
|
|
|
|
|
|
|
if (sdebug_virtual_gb > 0)
|
|
|
|
return (sector_t)sdebug_virtual_gb *
|
|
|
|
(gibibyte / sdebug_sector_size);
|
2008-03-29 15:59:55 +00:00
|
|
|
else
|
|
|
|
return sdebug_store_sectors;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define SDEBUG_READCAP_ARR_SZ 8
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_readcap(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned char arr[SDEBUG_READCAP_ARR_SZ];
|
2006-06-06 04:11:24 +00:00
|
|
|
unsigned int capac;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-06 04:11:24 +00:00
|
|
|
/* following just in case virtual_gb changed */
|
2008-03-29 15:59:55 +00:00
|
|
|
sdebug_capacity = get_sdebug_capacity();
|
2005-04-16 22:20:36 +00:00
|
|
|
memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
|
2006-06-06 04:11:24 +00:00
|
|
|
if (sdebug_capacity < 0xffffffff) {
|
|
|
|
capac = (unsigned int)sdebug_capacity - 1;
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be32(capac, arr + 0);
|
|
|
|
} else
|
|
|
|
put_unaligned_be32(0xffffffff, arr + 0);
|
|
|
|
put_unaligned_be16(sdebug_sector_size, arr + 6);
|
2005-04-16 22:20:36 +00:00
|
|
|
return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
|
|
|
|
}
|
|
|
|
|
2006-06-06 04:11:24 +00:00
|
|
|
#define SDEBUG_READCAP16_ARR_SZ 32
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_readcap16(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
2014-08-05 10:20:02 +00:00
|
|
|
unsigned char *cmd = scp->cmnd;
|
2006-06-06 04:11:24 +00:00
|
|
|
unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
|
2016-04-25 16:16:28 +00:00
|
|
|
int alloc_len;
|
2006-06-06 04:11:24 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
alloc_len = get_unaligned_be32(cmd + 10);
|
2006-06-06 04:11:24 +00:00
|
|
|
/* following just in case virtual_gb changed */
|
2008-03-29 15:59:55 +00:00
|
|
|
sdebug_capacity = get_sdebug_capacity();
|
2006-06-06 04:11:24 +00:00
|
|
|
memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be64((u64)(sdebug_capacity - 1), arr + 0);
|
|
|
|
put_unaligned_be32(sdebug_sector_size, arr + 8);
|
|
|
|
arr[13] = sdebug_physblk_exp & 0xf;
|
|
|
|
arr[14] = (sdebug_lowest_aligned >> 8) & 0x3f;
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2012-03-08 06:03:59 +00:00
|
|
|
if (scsi_debug_lbp()) {
|
2011-03-08 07:08:11 +00:00
|
|
|
arr[14] |= 0x80; /* LBPME */
|
2016-05-06 04:40:27 +00:00
|
|
|
/* from sbc4r07, this LBPRZ field is 1 bit, but the LBPRZ in
|
|
|
|
* the LB Provisioning VPD page is 3 bits. Note that lbprz=2
|
|
|
|
* in the wider field maps to 0 in this field.
|
|
|
|
*/
|
|
|
|
if (sdebug_lbprz & 1) /* precisely what the draft requires */
|
|
|
|
arr[14] |= 0x40;
|
2012-03-08 06:03:59 +00:00
|
|
|
}
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
arr[15] = sdebug_lowest_aligned & 0xff;
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2016-05-06 04:40:27 +00:00
|
|
|
if (have_dif_prot) {
|
2016-04-25 16:16:28 +00:00
|
|
|
arr[12] = (sdebug_dif - 1) << 1; /* P_TYPE */
|
2009-01-04 08:08:19 +00:00
|
|
|
arr[12] |= 1; /* PROT_EN */
|
|
|
|
}
|
|
|
|
|
2006-06-06 04:11:24 +00:00
|
|
|
return fill_from_dev_buffer(scp, arr,
|
|
|
|
min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
|
|
|
|
}
|
|
|
|
|
2006-10-20 07:58:47 +00:00
|
|
|
#define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_report_tgtpgs(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2006-10-20 07:58:47 +00:00
|
|
|
{
|
2014-08-05 10:20:02 +00:00
|
|
|
unsigned char *cmd = scp->cmnd;
|
2018-02-10 02:12:43 +00:00
|
|
|
unsigned char *arr;
|
2006-10-20 07:58:47 +00:00
|
|
|
int host_no = devip->sdbg_host->shost->host_no;
|
|
|
|
int n, ret, alen, rlen;
|
|
|
|
int port_group_a, port_group_b, port_a, port_b;
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
alen = get_unaligned_be32(cmd + 6);
|
2007-01-05 05:05:25 +00:00
|
|
|
arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
|
|
|
|
if (! arr)
|
|
|
|
return DID_REQUEUE << 16;
|
2006-10-20 07:58:47 +00:00
|
|
|
/*
|
|
|
|
* EVPD page 0x88 states we have two ports, one
|
|
|
|
* real and a fake port with no device connected.
|
|
|
|
* So we create two port groups with one port each
|
|
|
|
* and set the group with port B to unavailable.
|
|
|
|
*/
|
|
|
|
port_a = 0x1; /* relative port A */
|
|
|
|
port_b = 0x2; /* relative port B */
|
|
|
|
port_group_a = (((host_no + 1) & 0x7f) << 8) +
|
2016-04-25 16:16:28 +00:00
|
|
|
(devip->channel & 0x7f);
|
2006-10-20 07:58:47 +00:00
|
|
|
port_group_b = (((host_no + 1) & 0x7f) << 8) +
|
2016-04-25 16:16:28 +00:00
|
|
|
(devip->channel & 0x7f) + 0x80;
|
2006-10-20 07:58:47 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The asymmetric access state is cycled according to the host_id.
|
|
|
|
*/
|
|
|
|
n = 4;
|
2016-05-01 02:44:42 +00:00
|
|
|
if (sdebug_vpd_use_hostno == 0) {
|
2016-04-25 16:16:28 +00:00
|
|
|
arr[n++] = host_no % 3; /* Asymm access state */
|
|
|
|
arr[n++] = 0x0F; /* claim: all states are supported */
|
2006-10-20 07:58:47 +00:00
|
|
|
} else {
|
2016-04-25 16:16:28 +00:00
|
|
|
arr[n++] = 0x0; /* Active/Optimized path */
|
|
|
|
arr[n++] = 0x01; /* only support active/optimized paths */
|
2006-10-20 07:58:47 +00:00
|
|
|
}
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be16(port_group_a, arr + n);
|
|
|
|
n += 2;
|
2006-10-20 07:58:47 +00:00
|
|
|
arr[n++] = 0; /* Reserved */
|
|
|
|
arr[n++] = 0; /* Status code */
|
|
|
|
arr[n++] = 0; /* Vendor unique */
|
|
|
|
arr[n++] = 0x1; /* One port per group */
|
|
|
|
arr[n++] = 0; /* Reserved */
|
|
|
|
arr[n++] = 0; /* Reserved */
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be16(port_a, arr + n);
|
|
|
|
n += 2;
|
2006-10-20 07:58:47 +00:00
|
|
|
arr[n++] = 3; /* Port unavailable */
|
|
|
|
arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be16(port_group_b, arr + n);
|
|
|
|
n += 2;
|
2006-10-20 07:58:47 +00:00
|
|
|
arr[n++] = 0; /* Reserved */
|
|
|
|
arr[n++] = 0; /* Status code */
|
|
|
|
arr[n++] = 0; /* Vendor unique */
|
|
|
|
arr[n++] = 0x1; /* One port per group */
|
|
|
|
arr[n++] = 0; /* Reserved */
|
|
|
|
arr[n++] = 0; /* Reserved */
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be16(port_b, arr + n);
|
|
|
|
n += 2;
|
2006-10-20 07:58:47 +00:00
|
|
|
|
|
|
|
rlen = n - 4;
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be32(rlen, arr + 0);
|
2006-10-20 07:58:47 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the smallest value of either
|
|
|
|
* - The allocated length
|
|
|
|
* - The constructed command length
|
|
|
|
* - The maximum array size
|
|
|
|
*/
|
|
|
|
rlen = min(alen,n);
|
|
|
|
ret = fill_from_dev_buffer(scp, arr,
|
|
|
|
min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
|
|
|
|
kfree(arr);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_rsup_opcodes(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2014-11-25 02:27:12 +00:00
|
|
|
{
|
|
|
|
bool rctd;
|
|
|
|
u8 reporting_opts, req_opcode, sdeb_i, supp;
|
|
|
|
u16 req_sa, u;
|
|
|
|
u32 alloc_len, a_len;
|
|
|
|
int k, offset, len, errsts, count, bump, na;
|
|
|
|
const struct opcode_info_t *oip;
|
|
|
|
const struct opcode_info_t *r_oip;
|
|
|
|
u8 *arr;
|
|
|
|
u8 *cmd = scp->cmnd;
|
|
|
|
|
|
|
|
rctd = !!(cmd[2] & 0x80);
|
|
|
|
reporting_opts = cmd[2] & 0x7;
|
|
|
|
req_opcode = cmd[3];
|
|
|
|
req_sa = get_unaligned_be16(cmd + 4);
|
|
|
|
alloc_len = get_unaligned_be32(cmd + 6);
|
2015-01-22 11:20:40 +00:00
|
|
|
if (alloc_len < 4 || alloc_len > 0xffff) {
|
2014-11-25 02:27:12 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
if (alloc_len > 8192)
|
|
|
|
a_len = 8192;
|
|
|
|
else
|
|
|
|
a_len = alloc_len;
|
2015-01-17 22:47:37 +00:00
|
|
|
arr = kzalloc((a_len < 256) ? 320 : a_len + 64, GFP_ATOMIC);
|
2014-11-25 02:27:12 +00:00
|
|
|
if (NULL == arr) {
|
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
|
|
|
|
INSUFF_RES_ASCQ);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
switch (reporting_opts) {
|
|
|
|
case 0: /* all commands */
|
|
|
|
/* count number of commands */
|
|
|
|
for (count = 0, oip = opcode_info_arr;
|
|
|
|
oip->num_attached != 0xff; ++oip) {
|
|
|
|
if (F_INV_OP & oip->flags)
|
|
|
|
continue;
|
|
|
|
count += (oip->num_attached + 1);
|
|
|
|
}
|
|
|
|
bump = rctd ? 20 : 8;
|
|
|
|
put_unaligned_be32(count * bump, arr);
|
|
|
|
for (offset = 4, oip = opcode_info_arr;
|
|
|
|
oip->num_attached != 0xff && offset < a_len; ++oip) {
|
|
|
|
if (F_INV_OP & oip->flags)
|
|
|
|
continue;
|
|
|
|
na = oip->num_attached;
|
|
|
|
arr[offset] = oip->opcode;
|
|
|
|
put_unaligned_be16(oip->sa, arr + offset + 2);
|
|
|
|
if (rctd)
|
|
|
|
arr[offset + 5] |= 0x2;
|
|
|
|
if (FF_SA & oip->flags)
|
|
|
|
arr[offset + 5] |= 0x1;
|
|
|
|
put_unaligned_be16(oip->len_mask[0], arr + offset + 6);
|
|
|
|
if (rctd)
|
|
|
|
put_unaligned_be16(0xa, arr + offset + 8);
|
|
|
|
r_oip = oip;
|
|
|
|
for (k = 0, oip = oip->arrp; k < na; ++k, ++oip) {
|
|
|
|
if (F_INV_OP & oip->flags)
|
|
|
|
continue;
|
|
|
|
offset += bump;
|
|
|
|
arr[offset] = oip->opcode;
|
|
|
|
put_unaligned_be16(oip->sa, arr + offset + 2);
|
|
|
|
if (rctd)
|
|
|
|
arr[offset + 5] |= 0x2;
|
|
|
|
if (FF_SA & oip->flags)
|
|
|
|
arr[offset + 5] |= 0x1;
|
|
|
|
put_unaligned_be16(oip->len_mask[0],
|
|
|
|
arr + offset + 6);
|
|
|
|
if (rctd)
|
|
|
|
put_unaligned_be16(0xa,
|
|
|
|
arr + offset + 8);
|
|
|
|
}
|
|
|
|
oip = r_oip;
|
|
|
|
offset += bump;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 1: /* one command: opcode only */
|
|
|
|
case 2: /* one command: opcode plus service action */
|
|
|
|
case 3: /* one command: if sa==0 then opcode only else opcode+sa */
|
|
|
|
sdeb_i = opcode_ind_arr[req_opcode];
|
|
|
|
oip = &opcode_info_arr[sdeb_i];
|
|
|
|
if (F_INV_OP & oip->flags) {
|
|
|
|
supp = 1;
|
|
|
|
offset = 4;
|
|
|
|
} else {
|
|
|
|
if (1 == reporting_opts) {
|
|
|
|
if (FF_SA & oip->flags) {
|
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB,
|
|
|
|
2, 2);
|
|
|
|
kfree(arr);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
req_sa = 0;
|
|
|
|
} else if (2 == reporting_opts &&
|
|
|
|
0 == (FF_SA & oip->flags)) {
|
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 4, -1);
|
|
|
|
kfree(arr); /* point at requested sa */
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
if (0 == (FF_SA & oip->flags) &&
|
|
|
|
req_opcode == oip->opcode)
|
|
|
|
supp = 3;
|
|
|
|
else if (0 == (FF_SA & oip->flags)) {
|
|
|
|
na = oip->num_attached;
|
|
|
|
for (k = 0, oip = oip->arrp; k < na;
|
|
|
|
++k, ++oip) {
|
|
|
|
if (req_opcode == oip->opcode)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
supp = (k >= na) ? 1 : 3;
|
|
|
|
} else if (req_sa != oip->sa) {
|
|
|
|
na = oip->num_attached;
|
|
|
|
for (k = 0, oip = oip->arrp; k < na;
|
|
|
|
++k, ++oip) {
|
|
|
|
if (req_sa == oip->sa)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
supp = (k >= na) ? 1 : 3;
|
|
|
|
} else
|
|
|
|
supp = 3;
|
|
|
|
if (3 == supp) {
|
|
|
|
u = oip->len_mask[0];
|
|
|
|
put_unaligned_be16(u, arr + 2);
|
|
|
|
arr[4] = oip->opcode;
|
|
|
|
for (k = 1; k < u; ++k)
|
|
|
|
arr[4 + k] = (k < 16) ?
|
|
|
|
oip->len_mask[k] : 0xff;
|
|
|
|
offset = 4 + u;
|
|
|
|
} else
|
|
|
|
offset = 4;
|
|
|
|
}
|
|
|
|
arr[1] = (rctd ? 0x80 : 0) | supp;
|
|
|
|
if (rctd) {
|
|
|
|
put_unaligned_be16(0xa, arr + offset);
|
|
|
|
offset += 12;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 2);
|
|
|
|
kfree(arr);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
offset = (offset < a_len) ? offset : a_len;
|
|
|
|
len = (offset < alloc_len) ? offset : alloc_len;
|
|
|
|
errsts = fill_from_dev_buffer(scp, arr, len);
|
|
|
|
kfree(arr);
|
|
|
|
return errsts;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_rsup_tmfs(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2014-11-25 02:27:12 +00:00
|
|
|
{
|
|
|
|
bool repd;
|
|
|
|
u32 alloc_len, len;
|
|
|
|
u8 arr[16];
|
|
|
|
u8 *cmd = scp->cmnd;
|
|
|
|
|
|
|
|
memset(arr, 0, sizeof(arr));
|
|
|
|
repd = !!(cmd[2] & 0x80);
|
|
|
|
alloc_len = get_unaligned_be32(cmd + 6);
|
|
|
|
if (alloc_len < 4) {
|
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
arr[0] = 0xc8; /* ATS | ATSS | LURS */
|
|
|
|
arr[1] = 0x1; /* ITNRS */
|
|
|
|
if (repd) {
|
|
|
|
arr[3] = 0xc;
|
|
|
|
len = 16;
|
|
|
|
} else
|
|
|
|
len = 4;
|
|
|
|
|
|
|
|
len = (len < alloc_len) ? len : alloc_len;
|
|
|
|
return fill_from_dev_buffer(scp, arr, len);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* <<Following mode page info copied from ST318451LW>> */
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_err_recov_pg(unsigned char *p, int pcontrol, int target)
|
2005-04-16 22:20:36 +00:00
|
|
|
{ /* Read-Write Error Recovery page for mode_sense */
|
|
|
|
unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
|
|
|
|
5, 0, 0xff, 0xff};
|
|
|
|
|
|
|
|
memcpy(p, err_recov_pg, sizeof(err_recov_pg));
|
|
|
|
if (1 == pcontrol)
|
|
|
|
memset(p + 2, 0, sizeof(err_recov_pg) - 2);
|
|
|
|
return sizeof(err_recov_pg);
|
|
|
|
}
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_disconnect_pg(unsigned char *p, int pcontrol, int target)
|
2005-04-16 22:20:36 +00:00
|
|
|
{ /* Disconnect-Reconnect page for mode_sense */
|
|
|
|
unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0};
|
|
|
|
|
|
|
|
memcpy(p, disconnect_pg, sizeof(disconnect_pg));
|
|
|
|
if (1 == pcontrol)
|
|
|
|
memset(p + 2, 0, sizeof(disconnect_pg) - 2);
|
|
|
|
return sizeof(disconnect_pg);
|
|
|
|
}
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_format_pg(unsigned char *p, int pcontrol, int target)
|
2005-04-16 22:20:36 +00:00
|
|
|
{ /* Format device page for mode_sense */
|
2008-06-05 04:12:59 +00:00
|
|
|
unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0x40, 0, 0, 0};
|
|
|
|
|
|
|
|
memcpy(p, format_pg, sizeof(format_pg));
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be16(sdebug_sectors_per, p + 10);
|
|
|
|
put_unaligned_be16(sdebug_sector_size, p + 12);
|
|
|
|
if (sdebug_removable)
|
2008-06-05 04:12:59 +00:00
|
|
|
p[20] |= 0x20; /* should agree with INQUIRY */
|
|
|
|
if (1 == pcontrol)
|
|
|
|
memset(p + 2, 0, sizeof(format_pg) - 2);
|
|
|
|
return sizeof(format_pg);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0,
|
|
|
|
0, 0, 0, 0};
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_caching_pg(unsigned char *p, int pcontrol, int target)
|
2005-04-16 22:20:36 +00:00
|
|
|
{ /* Caching page for mode_sense */
|
2014-07-26 15:55:35 +00:00
|
|
|
unsigned char ch_caching_pg[] = {/* 0x8, 18, */ 0x4, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
|
|
|
unsigned char d_caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
|
2005-04-16 22:20:36 +00:00
|
|
|
0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (SDEBUG_OPT_N_WCE & sdebug_opts)
|
2014-07-26 15:55:35 +00:00
|
|
|
caching_pg[2] &= ~0x4; /* set WCE=0 (default WCE=1) */
|
2005-04-16 22:20:36 +00:00
|
|
|
memcpy(p, caching_pg, sizeof(caching_pg));
|
|
|
|
if (1 == pcontrol)
|
2014-07-26 15:55:35 +00:00
|
|
|
memcpy(p + 2, ch_caching_pg, sizeof(ch_caching_pg));
|
|
|
|
else if (2 == pcontrol)
|
|
|
|
memcpy(p, d_caching_pg, sizeof(d_caching_pg));
|
2005-04-16 22:20:36 +00:00
|
|
|
return sizeof(caching_pg);
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0x2, 0x4b};
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_ctrl_m_pg(unsigned char *p, int pcontrol, int target)
|
2005-04-16 22:20:36 +00:00
|
|
|
{ /* Control mode page for mode_sense */
|
2006-06-06 04:11:24 +00:00
|
|
|
unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
|
2017-12-23 17:48:10 +00:00
|
|
|
0, 0, 0, 0};
|
2006-06-06 04:11:24 +00:00
|
|
|
unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
|
2005-04-16 22:20:36 +00:00
|
|
|
0, 0, 0x2, 0x4b};
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_dsense)
|
2005-04-16 22:20:36 +00:00
|
|
|
ctrl_m_pg[2] |= 0x4;
|
2006-06-06 04:11:24 +00:00
|
|
|
else
|
|
|
|
ctrl_m_pg[2] &= ~0x4;
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_ato)
|
2009-01-04 08:08:19 +00:00
|
|
|
ctrl_m_pg[5] |= 0x80; /* ATO=1 */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
|
|
|
|
if (1 == pcontrol)
|
2006-06-06 04:11:24 +00:00
|
|
|
memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
|
|
|
|
else if (2 == pcontrol)
|
|
|
|
memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
|
2005-04-16 22:20:36 +00:00
|
|
|
return sizeof(ctrl_m_pg);
|
|
|
|
}
|
|
|
|
|
2006-06-06 04:11:24 +00:00
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_iec_m_pg(unsigned char *p, int pcontrol, int target)
|
2005-04-16 22:20:36 +00:00
|
|
|
{ /* Informational Exceptions control mode page for mode_sense */
|
2006-06-06 04:11:24 +00:00
|
|
|
unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
|
|
|
|
0, 0, 0x0, 0x0};
|
|
|
|
unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0x0, 0x0};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
memcpy(p, iec_m_pg, sizeof(iec_m_pg));
|
|
|
|
if (1 == pcontrol)
|
2006-06-06 04:11:24 +00:00
|
|
|
memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
|
|
|
|
else if (2 == pcontrol)
|
|
|
|
memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
|
2005-04-16 22:20:36 +00:00
|
|
|
return sizeof(iec_m_pg);
|
|
|
|
}
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_sas_sf_m_pg(unsigned char *p, int pcontrol, int target)
|
2006-06-06 04:11:24 +00:00
|
|
|
{ /* SAS SSP mode page - short format for mode_sense */
|
|
|
|
unsigned char sas_sf_m_pg[] = {0x19, 0x6,
|
|
|
|
0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
|
|
|
|
|
|
|
|
memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
|
|
|
|
if (1 == pcontrol)
|
|
|
|
memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
|
|
|
|
return sizeof(sas_sf_m_pg);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_sas_pcd_m_spg(unsigned char *p, int pcontrol, int target,
|
2006-06-06 04:11:24 +00:00
|
|
|
int target_dev_id)
|
|
|
|
{ /* SAS phy control and discover mode page for mode_sense */
|
|
|
|
unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
|
|
|
|
0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
|
2016-04-25 16:16:28 +00:00
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, /* insert SAS addr */
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, /* insert SAS addr */
|
2006-06-06 04:11:24 +00:00
|
|
|
0x2, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0x88, 0x99, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
|
2016-04-25 16:16:28 +00:00
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, /* insert SAS addr */
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, /* insert SAS addr */
|
2006-06-06 04:11:24 +00:00
|
|
|
0x3, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0x88, 0x99, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
};
|
|
|
|
int port_a, port_b;
|
|
|
|
|
2016-05-06 04:40:29 +00:00
|
|
|
put_unaligned_be64(naa3_comp_a, sas_pcd_m_pg + 16);
|
|
|
|
put_unaligned_be64(naa3_comp_c + 1, sas_pcd_m_pg + 24);
|
|
|
|
put_unaligned_be64(naa3_comp_a, sas_pcd_m_pg + 64);
|
|
|
|
put_unaligned_be64(naa3_comp_c + 1, sas_pcd_m_pg + 72);
|
2006-06-06 04:11:24 +00:00
|
|
|
port_a = target_dev_id + 1;
|
|
|
|
port_b = port_a + 1;
|
|
|
|
memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be32(port_a, p + 20);
|
|
|
|
put_unaligned_be32(port_b, p + 48 + 20);
|
2006-06-06 04:11:24 +00:00
|
|
|
if (1 == pcontrol)
|
|
|
|
memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
|
|
|
|
return sizeof(sas_pcd_m_pg);
|
|
|
|
}
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_sas_sha_m_spg(unsigned char *p, int pcontrol)
|
2006-06-06 04:11:24 +00:00
|
|
|
{ /* SAS SSP shared protocol specific port mode subpage */
|
|
|
|
unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
|
|
|
|
if (1 == pcontrol)
|
|
|
|
memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
|
|
|
|
return sizeof(sas_sha_m_pg);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define SDEBUG_MAX_MSENSE_SZ 256
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_mode_sense(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-09-17 00:30:47 +00:00
|
|
|
int pcontrol, pcode, subpcode, bd_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char dev_spec;
|
2016-05-06 04:40:27 +00:00
|
|
|
int alloc_len, offset, len, target_dev_id;
|
2014-11-25 01:46:29 +00:00
|
|
|
int target = scp->device->id;
|
2018-02-10 02:12:43 +00:00
|
|
|
unsigned char *ap;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
|
2014-08-05 10:20:02 +00:00
|
|
|
unsigned char *cmd = scp->cmnd;
|
2016-05-06 04:40:27 +00:00
|
|
|
bool dbd, llbaa, msense_6, is_disk, bad_pcode;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-05-06 04:40:27 +00:00
|
|
|
dbd = !!(cmd[1] & 0x8); /* disable block descriptors */
|
2005-04-16 22:20:36 +00:00
|
|
|
pcontrol = (cmd[2] & 0xc0) >> 6;
|
|
|
|
pcode = cmd[2] & 0x3f;
|
|
|
|
subpcode = cmd[3];
|
|
|
|
msense_6 = (MODE_SENSE == cmd[0]);
|
2016-05-06 04:40:27 +00:00
|
|
|
llbaa = msense_6 ? false : !!(cmd[1] & 0x10);
|
|
|
|
is_disk = (sdebug_ptype == TYPE_DISK);
|
|
|
|
if (is_disk && !dbd)
|
2006-09-17 00:30:47 +00:00
|
|
|
bd_len = llbaa ? 16 : 8;
|
|
|
|
else
|
|
|
|
bd_len = 0;
|
2016-04-25 16:16:28 +00:00
|
|
|
alloc_len = msense_6 ? cmd[4] : get_unaligned_be16(cmd + 7);
|
2005-04-16 22:20:36 +00:00
|
|
|
memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
|
|
|
|
if (0x3 == pcontrol) { /* Saving values not supported */
|
2014-07-26 15:55:35 +00:00
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
2006-06-06 04:11:24 +00:00
|
|
|
target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
|
|
|
|
(devip->target * 1000) - 3;
|
2016-05-01 02:44:42 +00:00
|
|
|
/* for disks set DPOFUA bit and clear write protect (WP) bit */
|
2019-02-08 23:37:25 +00:00
|
|
|
if (is_disk) {
|
2016-05-01 02:44:42 +00:00
|
|
|
dev_spec = 0x10; /* =0x90 if WP=1 implies read-only */
|
2019-02-08 23:37:25 +00:00
|
|
|
if (sdebug_wp)
|
|
|
|
dev_spec |= 0x80;
|
|
|
|
} else
|
2006-09-17 00:30:47 +00:00
|
|
|
dev_spec = 0x0;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (msense_6) {
|
|
|
|
arr[2] = dev_spec;
|
2006-09-17 00:30:47 +00:00
|
|
|
arr[3] = bd_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
offset = 4;
|
|
|
|
} else {
|
|
|
|
arr[3] = dev_spec;
|
2006-09-17 00:30:47 +00:00
|
|
|
if (16 == bd_len)
|
|
|
|
arr[4] = 0x1; /* set LONGLBA bit */
|
|
|
|
arr[7] = bd_len; /* assume 255 or less */
|
2005-04-16 22:20:36 +00:00
|
|
|
offset = 8;
|
|
|
|
}
|
|
|
|
ap = arr + offset;
|
2008-03-29 15:59:55 +00:00
|
|
|
if ((bd_len > 0) && (!sdebug_capacity))
|
|
|
|
sdebug_capacity = get_sdebug_capacity();
|
|
|
|
|
2006-09-17 00:30:47 +00:00
|
|
|
if (8 == bd_len) {
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_capacity > 0xfffffffe)
|
|
|
|
put_unaligned_be32(0xffffffff, ap + 0);
|
|
|
|
else
|
|
|
|
put_unaligned_be32(sdebug_capacity, ap + 0);
|
|
|
|
put_unaligned_be16(sdebug_sector_size, ap + 6);
|
2006-09-17 00:30:47 +00:00
|
|
|
offset += bd_len;
|
|
|
|
ap = arr + offset;
|
|
|
|
} else if (16 == bd_len) {
|
2016-04-25 16:16:28 +00:00
|
|
|
put_unaligned_be64((u64)sdebug_capacity, ap + 0);
|
|
|
|
put_unaligned_be32(sdebug_sector_size, ap + 12);
|
2006-09-17 00:30:47 +00:00
|
|
|
offset += bd_len;
|
|
|
|
ap = arr + offset;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-06 04:11:24 +00:00
|
|
|
if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
|
|
|
|
/* TODO: Control Extension page */
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
|
2005-04-16 22:20:36 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
2016-05-06 04:40:27 +00:00
|
|
|
bad_pcode = false;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (pcode) {
|
|
|
|
case 0x1: /* Read-Write error recovery page, direct access */
|
|
|
|
len = resp_err_recov_pg(ap, pcontrol, target);
|
|
|
|
offset += len;
|
|
|
|
break;
|
|
|
|
case 0x2: /* Disconnect-Reconnect page, all devices */
|
|
|
|
len = resp_disconnect_pg(ap, pcontrol, target);
|
|
|
|
offset += len;
|
|
|
|
break;
|
2017-12-23 17:48:10 +00:00
|
|
|
case 0x3: /* Format device page, direct access */
|
2016-05-06 04:40:27 +00:00
|
|
|
if (is_disk) {
|
|
|
|
len = resp_format_pg(ap, pcontrol, target);
|
|
|
|
offset += len;
|
|
|
|
} else
|
|
|
|
bad_pcode = true;
|
2017-12-23 17:48:10 +00:00
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
case 0x8: /* Caching page, direct access */
|
2016-05-06 04:40:27 +00:00
|
|
|
if (is_disk) {
|
|
|
|
len = resp_caching_pg(ap, pcontrol, target);
|
|
|
|
offset += len;
|
|
|
|
} else
|
|
|
|
bad_pcode = true;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case 0xa: /* Control Mode page, all devices */
|
|
|
|
len = resp_ctrl_m_pg(ap, pcontrol, target);
|
|
|
|
offset += len;
|
|
|
|
break;
|
2006-06-06 04:11:24 +00:00
|
|
|
case 0x19: /* if spc==1 then sas phy, control+discover */
|
|
|
|
if ((subpcode > 0x2) && (subpcode < 0xff)) {
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
|
2006-06-06 04:11:24 +00:00
|
|
|
return check_condition_result;
|
2017-12-23 17:48:10 +00:00
|
|
|
}
|
2006-06-06 04:11:24 +00:00
|
|
|
len = 0;
|
|
|
|
if ((0x0 == subpcode) || (0xff == subpcode))
|
|
|
|
len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
|
|
|
|
if ((0x1 == subpcode) || (0xff == subpcode))
|
|
|
|
len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
|
|
|
|
target_dev_id);
|
|
|
|
if ((0x2 == subpcode) || (0xff == subpcode))
|
|
|
|
len += resp_sas_sha_m_spg(ap + len, pcontrol);
|
|
|
|
offset += len;
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
case 0x1c: /* Informational Exceptions Mode page, all devices */
|
|
|
|
len = resp_iec_m_pg(ap, pcontrol, target);
|
|
|
|
offset += len;
|
|
|
|
break;
|
|
|
|
case 0x3f: /* Read all Mode pages */
|
2006-06-06 04:11:24 +00:00
|
|
|
if ((0 == subpcode) || (0xff == subpcode)) {
|
|
|
|
len = resp_err_recov_pg(ap, pcontrol, target);
|
|
|
|
len += resp_disconnect_pg(ap + len, pcontrol, target);
|
2016-05-06 04:40:27 +00:00
|
|
|
if (is_disk) {
|
|
|
|
len += resp_format_pg(ap + len, pcontrol,
|
|
|
|
target);
|
|
|
|
len += resp_caching_pg(ap + len, pcontrol,
|
|
|
|
target);
|
|
|
|
}
|
2006-06-06 04:11:24 +00:00
|
|
|
len += resp_ctrl_m_pg(ap + len, pcontrol, target);
|
|
|
|
len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
|
|
|
|
if (0xff == subpcode) {
|
|
|
|
len += resp_sas_pcd_m_spg(ap + len, pcontrol,
|
|
|
|
target, target_dev_id);
|
|
|
|
len += resp_sas_sha_m_spg(ap + len, pcontrol);
|
|
|
|
}
|
|
|
|
len += resp_iec_m_pg(ap + len, pcontrol, target);
|
2016-05-06 04:40:27 +00:00
|
|
|
offset += len;
|
2006-06-06 04:11:24 +00:00
|
|
|
} else {
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
|
2006-06-06 04:11:24 +00:00
|
|
|
return check_condition_result;
|
2017-12-23 17:48:10 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
2016-05-06 04:40:27 +00:00
|
|
|
bad_pcode = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (bad_pcode) {
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
|
2005-04-16 22:20:36 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
if (msense_6)
|
|
|
|
arr[0] = offset - 1;
|
2016-04-25 16:16:28 +00:00
|
|
|
else
|
|
|
|
put_unaligned_be16((offset - 2), arr + 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
return fill_from_dev_buffer(scp, arr, min(alloc_len, offset));
|
|
|
|
}
|
|
|
|
|
2006-06-06 04:11:24 +00:00
|
|
|
#define SDEBUG_MAX_MSELECT_SZ 512
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_mode_select(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
|
|
|
int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
|
2014-11-25 01:46:29 +00:00
|
|
|
int param_len, res, mpage;
|
2006-06-06 04:11:24 +00:00
|
|
|
unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
|
2014-08-05 10:20:02 +00:00
|
|
|
unsigned char *cmd = scp->cmnd;
|
2014-11-25 01:46:29 +00:00
|
|
|
int mselect6 = (MODE_SELECT == cmd[0]);
|
2006-06-06 04:11:24 +00:00
|
|
|
|
|
|
|
memset(arr, 0, sizeof(arr));
|
|
|
|
pf = cmd[1] & 0x10;
|
|
|
|
sp = cmd[1] & 0x1;
|
2016-04-25 16:16:28 +00:00
|
|
|
param_len = mselect6 ? cmd[4] : get_unaligned_be16(cmd + 7);
|
2006-06-06 04:11:24 +00:00
|
|
|
if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, mselect6 ? 4 : 7, -1);
|
2006-06-06 04:11:24 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
2017-12-23 17:48:10 +00:00
|
|
|
res = fetch_to_dev_buffer(scp, arr, param_len);
|
|
|
|
if (-1 == res)
|
2016-04-25 16:16:28 +00:00
|
|
|
return DID_ERROR << 16;
|
|
|
|
else if (sdebug_verbose && (res < param_len))
|
2014-07-26 15:55:35 +00:00
|
|
|
sdev_printk(KERN_INFO, scp->device,
|
|
|
|
"%s: cdb indicated=%d, IO sent=%d bytes\n",
|
|
|
|
__func__, param_len, res);
|
2016-04-25 16:16:28 +00:00
|
|
|
md_len = mselect6 ? (arr[0] + 1) : (get_unaligned_be16(arr + 0) + 2);
|
|
|
|
bd_len = mselect6 ? arr[3] : get_unaligned_be16(arr + 6);
|
2006-09-17 00:30:47 +00:00
|
|
|
if (md_len > 2) {
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_DATA, 0, -1);
|
2006-06-06 04:11:24 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
off = bd_len + (mselect6 ? 4 : 8);
|
|
|
|
mpage = arr[off] & 0x3f;
|
|
|
|
ps = !!(arr[off] & 0x80);
|
|
|
|
if (ps) {
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_DATA, off, 7);
|
2006-06-06 04:11:24 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
spf = !!(arr[off] & 0x40);
|
2016-04-25 16:16:28 +00:00
|
|
|
pg_len = spf ? (get_unaligned_be16(arr + off + 2) + 4) :
|
2006-06-06 04:11:24 +00:00
|
|
|
(arr[off + 1] + 2);
|
|
|
|
if ((pg_len + off) > param_len) {
|
2014-07-26 15:55:35 +00:00
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST,
|
2006-06-06 04:11:24 +00:00
|
|
|
PARAMETER_LIST_LENGTH_ERR, 0);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
switch (mpage) {
|
2014-07-26 15:55:35 +00:00
|
|
|
case 0x8: /* Caching Mode page */
|
|
|
|
if (caching_pg[1] == arr[off + 1]) {
|
|
|
|
memcpy(caching_pg + 2, arr + off + 2,
|
|
|
|
sizeof(caching_pg) - 2);
|
|
|
|
goto set_mode_changed_ua;
|
|
|
|
}
|
|
|
|
break;
|
2006-06-06 04:11:24 +00:00
|
|
|
case 0xa: /* Control Mode page */
|
|
|
|
if (ctrl_m_pg[1] == arr[off + 1]) {
|
|
|
|
memcpy(ctrl_m_pg + 2, arr + off + 2,
|
|
|
|
sizeof(ctrl_m_pg) - 2);
|
2019-02-08 23:37:25 +00:00
|
|
|
if (ctrl_m_pg[4] & 0x8)
|
|
|
|
sdebug_wp = true;
|
|
|
|
else
|
|
|
|
sdebug_wp = false;
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_dsense = !!(ctrl_m_pg[2] & 0x4);
|
2014-07-26 15:55:35 +00:00
|
|
|
goto set_mode_changed_ua;
|
2006-06-06 04:11:24 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 0x1c: /* Informational Exceptions Mode page */
|
|
|
|
if (iec_m_pg[1] == arr[off + 1]) {
|
|
|
|
memcpy(iec_m_pg + 2, arr + off + 2,
|
|
|
|
sizeof(iec_m_pg) - 2);
|
2014-07-26 15:55:35 +00:00
|
|
|
goto set_mode_changed_ua;
|
2006-06-06 04:11:24 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_DATA, off, 5);
|
2006-06-06 04:11:24 +00:00
|
|
|
return check_condition_result;
|
2014-07-26 15:55:35 +00:00
|
|
|
set_mode_changed_ua:
|
|
|
|
set_bit(SDEBUG_UA_MODE_CHANGED, devip->uas_bm);
|
|
|
|
return 0;
|
2006-06-06 04:11:24 +00:00
|
|
|
}
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_temp_l_pg(unsigned char *arr)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
|
|
|
unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
|
|
|
|
0x0, 0x1, 0x3, 0x2, 0x0, 65,
|
|
|
|
};
|
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
|
|
|
|
return sizeof(temp_l_pg);
|
2006-06-06 04:11:24 +00:00
|
|
|
}
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int resp_ie_l_pg(unsigned char *arr)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
|
|
|
unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
|
|
|
|
};
|
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
|
2006-06-06 04:11:24 +00:00
|
|
|
if (iec_m_pg[2] & 0x4) { /* TEST bit set */
|
|
|
|
arr[4] = THRESHOLD_EXCEEDED;
|
|
|
|
arr[5] = 0xff;
|
|
|
|
}
|
2017-12-23 17:48:10 +00:00
|
|
|
return sizeof(ie_l_pg);
|
2006-06-06 04:11:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define SDEBUG_MAX_LSENSE_SZ 512
|
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
static int resp_log_sense(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
2017-08-25 20:46:42 +00:00
|
|
|
int ppc, sp, pcode, subpcode, alloc_len, len, n;
|
2006-06-06 04:11:24 +00:00
|
|
|
unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
|
2014-08-05 10:20:02 +00:00
|
|
|
unsigned char *cmd = scp->cmnd;
|
2006-06-06 04:11:24 +00:00
|
|
|
|
|
|
|
memset(arr, 0, sizeof(arr));
|
|
|
|
ppc = cmd[1] & 0x2;
|
|
|
|
sp = cmd[1] & 0x1;
|
|
|
|
if (ppc || sp) {
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, ppc ? 1 : 0);
|
2006-06-06 04:11:24 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
pcode = cmd[2] & 0x3f;
|
2006-09-17 00:30:47 +00:00
|
|
|
subpcode = cmd[3] & 0xff;
|
2016-04-25 16:16:28 +00:00
|
|
|
alloc_len = get_unaligned_be16(cmd + 7);
|
2006-06-06 04:11:24 +00:00
|
|
|
arr[0] = pcode;
|
2006-09-17 00:30:47 +00:00
|
|
|
if (0 == subpcode) {
|
|
|
|
switch (pcode) {
|
|
|
|
case 0x0: /* Supported log pages log page */
|
|
|
|
n = 4;
|
|
|
|
arr[n++] = 0x0; /* this page */
|
|
|
|
arr[n++] = 0xd; /* Temperature */
|
|
|
|
arr[n++] = 0x2f; /* Informational exceptions */
|
|
|
|
arr[3] = n - 4;
|
|
|
|
break;
|
|
|
|
case 0xd: /* Temperature log page */
|
|
|
|
arr[3] = resp_temp_l_pg(arr + 4);
|
|
|
|
break;
|
|
|
|
case 0x2f: /* Informational exceptions log page */
|
|
|
|
arr[3] = resp_ie_l_pg(arr + 4);
|
|
|
|
break;
|
|
|
|
default:
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
|
2006-09-17 00:30:47 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
} else if (0xff == subpcode) {
|
|
|
|
arr[0] |= 0x40;
|
|
|
|
arr[1] = subpcode;
|
|
|
|
switch (pcode) {
|
|
|
|
case 0x0: /* Supported log pages and subpages log page */
|
|
|
|
n = 4;
|
|
|
|
arr[n++] = 0x0;
|
|
|
|
arr[n++] = 0x0; /* 0,0 page */
|
|
|
|
arr[n++] = 0x0;
|
|
|
|
arr[n++] = 0xff; /* this page */
|
|
|
|
arr[n++] = 0xd;
|
|
|
|
arr[n++] = 0x0; /* Temperature */
|
|
|
|
arr[n++] = 0x2f;
|
|
|
|
arr[n++] = 0x0; /* Informational exceptions */
|
|
|
|
arr[3] = n - 4;
|
|
|
|
break;
|
|
|
|
case 0xd: /* Temperature subpages */
|
|
|
|
n = 4;
|
|
|
|
arr[n++] = 0xd;
|
|
|
|
arr[n++] = 0x0; /* Temperature */
|
|
|
|
arr[3] = n - 4;
|
|
|
|
break;
|
|
|
|
case 0x2f: /* Informational exceptions subpages */
|
|
|
|
n = 4;
|
|
|
|
arr[n++] = 0x2f;
|
|
|
|
arr[n++] = 0x0; /* Informational exceptions */
|
|
|
|
arr[3] = n - 4;
|
|
|
|
break;
|
|
|
|
default:
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, 5);
|
2006-09-17 00:30:47 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
} else {
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 3, -1);
|
2006-06-06 04:11:24 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
2016-04-25 16:16:28 +00:00
|
|
|
len = min(get_unaligned_be16(arr + 2) + 4, alloc_len);
|
2006-06-06 04:11:24 +00:00
|
|
|
return fill_from_dev_buffer(scp, arr,
|
|
|
|
min(len, SDEBUG_MAX_INQ_ARR_SZ));
|
|
|
|
}
|
|
|
|
|
2019-02-08 23:37:25 +00:00
|
|
|
static inline int check_device_access_params(struct scsi_cmnd *scp,
|
|
|
|
unsigned long long lba, unsigned int num, bool write)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-06-06 04:11:24 +00:00
|
|
|
if (lba + num > sdebug_capacity) {
|
2014-11-25 04:04:47 +00:00
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
2006-06-06 04:11:24 +00:00
|
|
|
/* transfer length excessive (tie in to block limits VPD page) */
|
|
|
|
if (num > sdebug_store_sectors) {
|
2014-11-25 04:04:47 +00:00
|
|
|
/* needs work to find which cdb byte 'num' comes from */
|
2014-07-26 15:55:35 +00:00
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
|
2006-06-06 04:11:24 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
2019-02-08 23:37:25 +00:00
|
|
|
if (write && unlikely(sdebug_wp)) {
|
|
|
|
mk_sense_buffer(scp, DATA_PROTECT, WRITE_PROTECTED, 0x2);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
2008-03-29 15:59:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-08 23:01:57 +00:00
|
|
|
/* Returns number of bytes copied or -1 if error. */
|
2017-12-23 17:48:12 +00:00
|
|
|
static int do_device_access(struct scsi_cmnd *scmd, u32 sg_skip, u64 lba,
|
|
|
|
u32 num, bool do_write)
|
2008-03-29 15:59:56 +00:00
|
|
|
{
|
|
|
|
int ret;
|
2014-11-25 01:46:29 +00:00
|
|
|
u64 block, rest = 0;
|
2019-01-29 08:33:07 +00:00
|
|
|
struct scsi_data_buffer *sdb = &scmd->sdb;
|
2013-07-08 23:01:57 +00:00
|
|
|
enum dma_data_direction dir;
|
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
if (do_write) {
|
2013-07-08 23:01:57 +00:00
|
|
|
dir = DMA_TO_DEVICE;
|
2018-04-10 17:00:36 +00:00
|
|
|
write_since_sync = true;
|
2013-07-08 23:01:57 +00:00
|
|
|
} else {
|
|
|
|
dir = DMA_FROM_DEVICE;
|
|
|
|
}
|
2008-03-29 15:59:56 +00:00
|
|
|
|
2013-07-08 23:01:57 +00:00
|
|
|
if (!sdb->length)
|
|
|
|
return 0;
|
2019-01-29 08:33:07 +00:00
|
|
|
if (scmd->sc_data_direction != dir)
|
2013-07-08 23:01:57 +00:00
|
|
|
return -1;
|
2008-03-29 15:59:56 +00:00
|
|
|
|
|
|
|
block = do_div(lba, sdebug_store_sectors);
|
|
|
|
if (block + num > sdebug_store_sectors)
|
|
|
|
rest = block + num - sdebug_store_sectors;
|
|
|
|
|
2015-06-30 21:58:57 +00:00
|
|
|
ret = sg_copy_buffer(sdb->table.sgl, sdb->table.nents,
|
2016-04-25 16:16:28 +00:00
|
|
|
fake_storep + (block * sdebug_sector_size),
|
2017-12-23 17:48:12 +00:00
|
|
|
(num - rest) * sdebug_sector_size, sg_skip, do_write);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (ret != (num - rest) * sdebug_sector_size)
|
2013-07-08 23:01:57 +00:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (rest) {
|
2015-06-30 21:58:57 +00:00
|
|
|
ret += sg_copy_buffer(sdb->table.sgl, sdb->table.nents,
|
2016-04-25 16:16:28 +00:00
|
|
|
fake_storep, rest * sdebug_sector_size,
|
2017-12-23 17:48:12 +00:00
|
|
|
sg_skip + ((num - rest) * sdebug_sector_size),
|
|
|
|
do_write);
|
2013-07-08 23:01:57 +00:00
|
|
|
}
|
2008-03-29 15:59:56 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-01-25 17:46:09 +00:00
|
|
|
/* If lba2fake_store(lba,num) compares equal to arr(num), then copy top half of
|
|
|
|
* arr into lba2fake_store(lba,num) and return true. If comparison fails then
|
2014-11-25 02:27:12 +00:00
|
|
|
* return false. */
|
2016-04-25 16:16:33 +00:00
|
|
|
static bool comp_write_worker(u64 lba, u32 num, const u8 *arr)
|
2014-11-25 02:27:12 +00:00
|
|
|
{
|
|
|
|
bool res;
|
|
|
|
u64 block, rest = 0;
|
|
|
|
u32 store_blks = sdebug_store_sectors;
|
2016-04-25 16:16:28 +00:00
|
|
|
u32 lb_size = sdebug_sector_size;
|
2014-11-25 02:27:12 +00:00
|
|
|
|
|
|
|
block = do_div(lba, store_blks);
|
|
|
|
if (block + num > store_blks)
|
|
|
|
rest = block + num - store_blks;
|
|
|
|
|
|
|
|
res = !memcmp(fake_storep + (block * lb_size), arr,
|
|
|
|
(num - rest) * lb_size);
|
|
|
|
if (!res)
|
|
|
|
return res;
|
|
|
|
if (rest)
|
|
|
|
res = memcmp(fake_storep, arr + ((num - rest) * lb_size),
|
|
|
|
rest * lb_size);
|
|
|
|
if (!res)
|
|
|
|
return res;
|
|
|
|
arr += num * lb_size;
|
|
|
|
memcpy(fake_storep + (block * lb_size), arr, (num - rest) * lb_size);
|
|
|
|
if (rest)
|
|
|
|
memcpy(fake_storep, arr + ((num - rest) * lb_size),
|
|
|
|
rest * lb_size);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2013-09-18 12:27:28 +00:00
|
|
|
static __be16 dif_compute_csum(const void *buf, int len)
|
2013-06-29 08:59:19 +00:00
|
|
|
{
|
2013-09-18 12:27:28 +00:00
|
|
|
__be16 csum;
|
2013-06-29 08:59:19 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_guard)
|
2013-09-18 12:27:28 +00:00
|
|
|
csum = (__force __be16)ip_compute_csum(buf, len);
|
|
|
|
else
|
2013-06-29 08:59:19 +00:00
|
|
|
csum = cpu_to_be16(crc_t10dif(buf, len));
|
2013-09-18 12:27:28 +00:00
|
|
|
|
2013-06-29 08:59:19 +00:00
|
|
|
return csum;
|
|
|
|
}
|
|
|
|
|
2016-09-11 17:35:39 +00:00
|
|
|
static int dif_verify(struct t10_pi_tuple *sdt, const void *data,
|
2013-06-29 08:59:19 +00:00
|
|
|
sector_t sector, u32 ei_lba)
|
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
__be16 csum = dif_compute_csum(data, sdebug_sector_size);
|
2013-06-29 08:59:19 +00:00
|
|
|
|
|
|
|
if (sdt->guard_tag != csum) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("GUARD check failed on sector %lu rcvd 0x%04x, data 0x%04x\n",
|
2013-06-29 08:59:19 +00:00
|
|
|
(unsigned long)sector,
|
|
|
|
be16_to_cpu(sdt->guard_tag),
|
|
|
|
be16_to_cpu(csum));
|
|
|
|
return 0x01;
|
|
|
|
}
|
2016-09-11 17:35:41 +00:00
|
|
|
if (sdebug_dif == T10_PI_TYPE1_PROTECTION &&
|
2013-06-29 08:59:19 +00:00
|
|
|
be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("REF check failed on sector %lu\n",
|
|
|
|
(unsigned long)sector);
|
2013-06-29 08:59:19 +00:00
|
|
|
return 0x03;
|
|
|
|
}
|
2016-09-11 17:35:41 +00:00
|
|
|
if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
|
2013-06-29 08:59:19 +00:00
|
|
|
be32_to_cpu(sdt->ref_tag) != ei_lba) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("REF check failed on sector %lu\n",
|
|
|
|
(unsigned long)sector);
|
2013-06-29 08:59:19 +00:00
|
|
|
return 0x03;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-18 12:27:25 +00:00
|
|
|
static void dif_copy_prot(struct scsi_cmnd *SCpnt, sector_t sector,
|
2013-09-18 12:27:26 +00:00
|
|
|
unsigned int sectors, bool read)
|
2009-01-04 08:08:19 +00:00
|
|
|
{
|
2014-02-26 13:57:02 +00:00
|
|
|
size_t resid;
|
2009-01-04 08:08:19 +00:00
|
|
|
void *paddr;
|
2013-09-18 12:27:24 +00:00
|
|
|
const void *dif_store_end = dif_storep + sdebug_store_sectors;
|
2014-02-26 13:57:02 +00:00
|
|
|
struct sg_mapping_iter miter;
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2013-06-29 08:59:18 +00:00
|
|
|
/* Bytes of protection data to copy into sgl */
|
|
|
|
resid = sectors * sizeof(*dif_storep);
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2014-02-26 13:57:02 +00:00
|
|
|
sg_miter_start(&miter, scsi_prot_sglist(SCpnt),
|
|
|
|
scsi_prot_sg_count(SCpnt), SG_MITER_ATOMIC |
|
|
|
|
(read ? SG_MITER_TO_SG : SG_MITER_FROM_SG));
|
|
|
|
|
|
|
|
while (sg_miter_next(&miter) && resid > 0) {
|
|
|
|
size_t len = min(miter.length, resid);
|
2013-09-18 12:27:24 +00:00
|
|
|
void *start = dif_store(sector);
|
2014-02-26 13:57:02 +00:00
|
|
|
size_t rest = 0;
|
2013-09-18 12:27:24 +00:00
|
|
|
|
|
|
|
if (dif_store_end < start + len)
|
|
|
|
rest = start + len - dif_store_end;
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2014-02-26 13:57:02 +00:00
|
|
|
paddr = miter.addr;
|
2013-09-18 12:27:24 +00:00
|
|
|
|
2013-09-18 12:27:26 +00:00
|
|
|
if (read)
|
|
|
|
memcpy(paddr, start, len - rest);
|
|
|
|
else
|
|
|
|
memcpy(start, paddr, len - rest);
|
|
|
|
|
|
|
|
if (rest) {
|
|
|
|
if (read)
|
|
|
|
memcpy(paddr + len - rest, dif_storep, rest);
|
|
|
|
else
|
|
|
|
memcpy(dif_storep, paddr + len - rest, rest);
|
|
|
|
}
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2013-06-29 08:59:18 +00:00
|
|
|
sector += len / sizeof(*dif_storep);
|
2009-01-04 08:08:19 +00:00
|
|
|
resid -= len;
|
|
|
|
}
|
2014-02-26 13:57:02 +00:00
|
|
|
sg_miter_stop(&miter);
|
2013-09-18 12:27:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec,
|
|
|
|
unsigned int sectors, u32 ei_lba)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
2016-09-11 17:35:39 +00:00
|
|
|
struct t10_pi_tuple *sdt;
|
2013-09-18 12:27:25 +00:00
|
|
|
sector_t sector;
|
|
|
|
|
2014-02-26 13:56:58 +00:00
|
|
|
for (i = 0; i < sectors; i++, ei_lba++) {
|
2013-09-18 12:27:25 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
sector = start_sec + i;
|
|
|
|
sdt = dif_store(sector);
|
|
|
|
|
2013-09-18 12:27:28 +00:00
|
|
|
if (sdt->app_tag == cpu_to_be16(0xffff))
|
2013-09-18 12:27:25 +00:00
|
|
|
continue;
|
|
|
|
|
2019-01-25 17:46:09 +00:00
|
|
|
ret = dif_verify(sdt, lba2fake_store(sector), sector, ei_lba);
|
2013-09-18 12:27:25 +00:00
|
|
|
if (ret) {
|
|
|
|
dif_errors++;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2013-09-18 12:27:26 +00:00
|
|
|
dif_copy_prot(SCpnt, start_sec, sectors, true);
|
2009-01-04 08:08:19 +00:00
|
|
|
dix_reads++;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
|
2008-03-29 15:59:56 +00:00
|
|
|
{
|
2014-11-25 01:46:29 +00:00
|
|
|
u8 *cmd = scp->cmnd;
|
2016-05-06 04:40:26 +00:00
|
|
|
struct sdebug_queued_cmd *sqcp;
|
2014-11-25 01:46:29 +00:00
|
|
|
u64 lba;
|
|
|
|
u32 num;
|
|
|
|
u32 ei_lba;
|
2008-03-29 15:59:56 +00:00
|
|
|
unsigned long iflags;
|
|
|
|
int ret;
|
2014-11-25 01:46:29 +00:00
|
|
|
bool check_prot;
|
2008-03-29 15:59:56 +00:00
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
switch (cmd[0]) {
|
|
|
|
case READ_16:
|
|
|
|
ei_lba = 0;
|
|
|
|
lba = get_unaligned_be64(cmd + 2);
|
|
|
|
num = get_unaligned_be32(cmd + 10);
|
|
|
|
check_prot = true;
|
|
|
|
break;
|
|
|
|
case READ_10:
|
|
|
|
ei_lba = 0;
|
|
|
|
lba = get_unaligned_be32(cmd + 2);
|
|
|
|
num = get_unaligned_be16(cmd + 7);
|
|
|
|
check_prot = true;
|
|
|
|
break;
|
|
|
|
case READ_6:
|
|
|
|
ei_lba = 0;
|
|
|
|
lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
|
|
|
|
(u32)(cmd[1] & 0x1f) << 16;
|
|
|
|
num = (0 == cmd[4]) ? 256 : cmd[4];
|
|
|
|
check_prot = true;
|
|
|
|
break;
|
|
|
|
case READ_12:
|
|
|
|
ei_lba = 0;
|
|
|
|
lba = get_unaligned_be32(cmd + 2);
|
|
|
|
num = get_unaligned_be32(cmd + 6);
|
|
|
|
check_prot = true;
|
|
|
|
break;
|
|
|
|
case XDWRITEREAD_10:
|
|
|
|
ei_lba = 0;
|
|
|
|
lba = get_unaligned_be32(cmd + 2);
|
|
|
|
num = get_unaligned_be16(cmd + 7);
|
|
|
|
check_prot = false;
|
|
|
|
break;
|
|
|
|
default: /* assume READ(32) */
|
|
|
|
lba = get_unaligned_be64(cmd + 12);
|
|
|
|
ei_lba = get_unaligned_be32(cmd + 20);
|
|
|
|
num = get_unaligned_be32(cmd + 28);
|
|
|
|
check_prot = false;
|
|
|
|
break;
|
|
|
|
}
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(have_dif_prot && check_prot)) {
|
2016-09-11 17:35:41 +00:00
|
|
|
if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
|
2014-11-25 01:46:29 +00:00
|
|
|
(cmd[1] & 0xe0)) {
|
|
|
|
mk_sense_invalid_opcode(scp);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
2016-09-11 17:35:41 +00:00
|
|
|
if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
|
|
|
|
sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
|
2014-11-25 01:46:29 +00:00
|
|
|
(cmd[1] & 0xe0) == 0)
|
|
|
|
sdev_printk(KERN_ERR, scp->device, "Unprotected RD "
|
|
|
|
"to DIF device\n");
|
|
|
|
}
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(sdebug_any_injecting_opt)) {
|
2016-05-06 04:40:26 +00:00
|
|
|
sqcp = (struct sdebug_queued_cmd *)scp->host_scribble;
|
2014-11-25 01:46:29 +00:00
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
if (sqcp) {
|
|
|
|
if (sqcp->inj_short)
|
|
|
|
num /= 2;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
sqcp = NULL;
|
2014-11-25 01:46:29 +00:00
|
|
|
|
2019-02-08 23:37:25 +00:00
|
|
|
ret = check_device_access_params(scp, lba, num, false);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely((SDEBUG_OPT_MEDIUM_ERR & sdebug_opts) &&
|
2018-02-03 18:38:35 +00:00
|
|
|
(lba <= (sdebug_medium_error_start + sdebug_medium_error_count - 1)) &&
|
|
|
|
((lba + num) > sdebug_medium_error_start))) {
|
2006-06-06 04:11:24 +00:00
|
|
|
/* claim unrecoverable read error */
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_buffer(scp, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 0);
|
2006-06-06 04:11:24 +00:00
|
|
|
/* set info field and valid bit for fixed descriptor */
|
2014-11-25 01:46:29 +00:00
|
|
|
if (0x70 == (scp->sense_buffer[0] & 0x7f)) {
|
|
|
|
scp->sense_buffer[0] |= 0x80; /* Valid bit */
|
2011-03-11 15:43:35 +00:00
|
|
|
ret = (lba < OPT_MEDIUM_ERR_ADDR)
|
|
|
|
? OPT_MEDIUM_ERR_ADDR : (int)lba;
|
2014-11-25 01:46:29 +00:00
|
|
|
put_unaligned_be32(ret, scp->sense_buffer + 3);
|
2006-06-06 04:11:24 +00:00
|
|
|
}
|
2014-11-25 01:46:29 +00:00
|
|
|
scsi_set_resid(scp, scsi_bufflen(scp));
|
2005-04-16 22:20:36 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2014-02-26 13:57:03 +00:00
|
|
|
read_lock_irqsave(&atomic_rw, iflags);
|
|
|
|
|
2009-01-04 08:08:19 +00:00
|
|
|
/* DIX + T10 DIF */
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
|
2014-11-25 01:46:29 +00:00
|
|
|
int prot_ret = prot_verify_read(scp, lba, num, ei_lba);
|
2009-01-04 08:08:19 +00:00
|
|
|
|
|
|
|
if (prot_ret) {
|
2014-02-26 13:57:03 +00:00
|
|
|
read_unlock_irqrestore(&atomic_rw, iflags);
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, prot_ret);
|
2009-01-04 08:08:19 +00:00
|
|
|
return illegal_condition_result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-23 17:48:12 +00:00
|
|
|
ret = do_device_access(scp, 0, lba, num, false);
|
2005-04-16 22:20:36 +00:00
|
|
|
read_unlock_irqrestore(&atomic_rw, iflags);
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(ret == -1))
|
2013-07-08 23:01:57 +00:00
|
|
|
return DID_ERROR << 16;
|
|
|
|
|
2019-02-08 21:25:00 +00:00
|
|
|
scsi_set_resid(scp, scsi_bufflen(scp) - ret);
|
2013-07-08 23:01:57 +00:00
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
if (unlikely(sqcp)) {
|
|
|
|
if (sqcp->inj_recovered) {
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_buffer(scp, RECOVERED_ERROR,
|
|
|
|
THRESHOLD_EXCEEDED, 0);
|
|
|
|
return check_condition_result;
|
2016-05-06 04:40:26 +00:00
|
|
|
} else if (sqcp->inj_transport) {
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_buffer(scp, ABORTED_COMMAND,
|
|
|
|
TRANSPORT_PROBLEM, ACK_NAK_TO);
|
|
|
|
return check_condition_result;
|
2016-05-06 04:40:26 +00:00
|
|
|
} else if (sqcp->inj_dif) {
|
2014-11-25 01:46:29 +00:00
|
|
|
/* Logical block guard check failed */
|
|
|
|
mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
|
|
|
|
return illegal_condition_result;
|
2016-05-06 04:40:26 +00:00
|
|
|
} else if (sqcp->inj_dix) {
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
|
|
|
|
return illegal_condition_result;
|
|
|
|
}
|
|
|
|
}
|
2013-07-08 23:01:57 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2015-07-28 13:54:23 +00:00
|
|
|
static void dump_sector(unsigned char *buf, int len)
|
2009-01-04 08:08:19 +00:00
|
|
|
{
|
2014-07-26 15:55:35 +00:00
|
|
|
int i, j, n;
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
pr_err(">>> Sector Dump <<<\n");
|
2009-01-04 08:08:19 +00:00
|
|
|
for (i = 0 ; i < len ; i += 16) {
|
2014-07-26 15:55:35 +00:00
|
|
|
char b[128];
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
for (j = 0, n = 0; j < 16; j++) {
|
2009-01-04 08:08:19 +00:00
|
|
|
unsigned char c = buf[i+j];
|
2014-07-26 15:55:35 +00:00
|
|
|
|
2009-01-04 08:08:19 +00:00
|
|
|
if (c >= 0x20 && c < 0x7e)
|
2014-07-26 15:55:35 +00:00
|
|
|
n += scnprintf(b + n, sizeof(b) - n,
|
|
|
|
" %c ", buf[i+j]);
|
2009-01-04 08:08:19 +00:00
|
|
|
else
|
2014-07-26 15:55:35 +00:00
|
|
|
n += scnprintf(b + n, sizeof(b) - n,
|
|
|
|
"%02x ", buf[i+j]);
|
2009-01-04 08:08:19 +00:00
|
|
|
}
|
2014-07-26 15:55:35 +00:00
|
|
|
pr_err("%04d: %s\n", i, b);
|
2009-01-04 08:08:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
|
2009-09-18 21:33:03 +00:00
|
|
|
unsigned int sectors, u32 ei_lba)
|
2009-01-04 08:08:19 +00:00
|
|
|
{
|
2014-02-26 13:57:02 +00:00
|
|
|
int ret;
|
2016-09-11 17:35:39 +00:00
|
|
|
struct t10_pi_tuple *sdt;
|
2014-02-26 13:57:02 +00:00
|
|
|
void *daddr;
|
2013-09-18 12:27:26 +00:00
|
|
|
sector_t sector = start_sec;
|
2009-01-04 08:08:19 +00:00
|
|
|
int ppage_offset;
|
2014-02-26 13:57:02 +00:00
|
|
|
int dpage_offset;
|
|
|
|
struct sg_mapping_iter diter;
|
|
|
|
struct sg_mapping_iter piter;
|
2009-01-04 08:08:19 +00:00
|
|
|
|
|
|
|
BUG_ON(scsi_sg_count(SCpnt) == 0);
|
|
|
|
BUG_ON(scsi_prot_sg_count(SCpnt) == 0);
|
|
|
|
|
2014-02-26 13:57:02 +00:00
|
|
|
sg_miter_start(&piter, scsi_prot_sglist(SCpnt),
|
|
|
|
scsi_prot_sg_count(SCpnt),
|
|
|
|
SG_MITER_ATOMIC | SG_MITER_FROM_SG);
|
|
|
|
sg_miter_start(&diter, scsi_sglist(SCpnt), scsi_sg_count(SCpnt),
|
|
|
|
SG_MITER_ATOMIC | SG_MITER_FROM_SG);
|
|
|
|
|
|
|
|
/* For each protection page */
|
|
|
|
while (sg_miter_next(&piter)) {
|
|
|
|
dpage_offset = 0;
|
|
|
|
if (WARN_ON(!sg_miter_next(&diter))) {
|
|
|
|
ret = 0x01;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2014-02-26 13:57:02 +00:00
|
|
|
for (ppage_offset = 0; ppage_offset < piter.length;
|
2016-09-11 17:35:39 +00:00
|
|
|
ppage_offset += sizeof(struct t10_pi_tuple)) {
|
2009-01-04 08:08:19 +00:00
|
|
|
/* If we're at the end of the current
|
2014-02-26 13:57:02 +00:00
|
|
|
* data page advance to the next one
|
2009-01-04 08:08:19 +00:00
|
|
|
*/
|
2014-02-26 13:57:02 +00:00
|
|
|
if (dpage_offset >= diter.length) {
|
|
|
|
if (WARN_ON(!sg_miter_next(&diter))) {
|
|
|
|
ret = 0x01;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
dpage_offset = 0;
|
2009-01-04 08:08:19 +00:00
|
|
|
}
|
|
|
|
|
2014-02-26 13:57:02 +00:00
|
|
|
sdt = piter.addr + ppage_offset;
|
|
|
|
daddr = diter.addr + dpage_offset;
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2014-02-26 13:57:02 +00:00
|
|
|
ret = dif_verify(sdt, daddr, sector, ei_lba);
|
2013-06-29 08:59:19 +00:00
|
|
|
if (ret) {
|
2016-04-25 16:16:28 +00:00
|
|
|
dump_sector(daddr, sdebug_sector_size);
|
2009-09-18 21:33:03 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-01-04 08:08:19 +00:00
|
|
|
sector++;
|
2009-09-18 21:33:03 +00:00
|
|
|
ei_lba++;
|
2016-04-25 16:16:28 +00:00
|
|
|
dpage_offset += sdebug_sector_size;
|
2009-01-04 08:08:19 +00:00
|
|
|
}
|
2014-02-26 13:57:02 +00:00
|
|
|
diter.consumed = dpage_offset;
|
|
|
|
sg_miter_stop(&diter);
|
2009-01-04 08:08:19 +00:00
|
|
|
}
|
2014-02-26 13:57:02 +00:00
|
|
|
sg_miter_stop(&piter);
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2013-09-18 12:27:26 +00:00
|
|
|
dif_copy_prot(SCpnt, start_sec, sectors, false);
|
2009-01-04 08:08:19 +00:00
|
|
|
dix_writes++;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
dif_errors++;
|
2014-02-26 13:57:02 +00:00
|
|
|
sg_miter_stop(&diter);
|
|
|
|
sg_miter_stop(&piter);
|
2009-01-04 08:08:19 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-04-16 13:11:58 +00:00
|
|
|
static unsigned long lba_to_map_index(sector_t lba)
|
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_unmap_alignment)
|
|
|
|
lba += sdebug_unmap_granularity - sdebug_unmap_alignment;
|
|
|
|
sector_div(lba, sdebug_unmap_granularity);
|
2013-04-16 13:11:58 +00:00
|
|
|
return lba;
|
|
|
|
}
|
|
|
|
|
|
|
|
static sector_t map_index_to_lba(unsigned long index)
|
2009-10-15 18:45:27 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
sector_t lba = index * sdebug_unmap_granularity;
|
2013-08-26 13:08:41 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_unmap_alignment)
|
|
|
|
lba -= sdebug_unmap_granularity - sdebug_unmap_alignment;
|
2013-08-26 13:08:41 +00:00
|
|
|
return lba;
|
2013-04-16 13:11:58 +00:00
|
|
|
}
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2013-04-16 13:11:58 +00:00
|
|
|
static unsigned int map_state(sector_t lba, unsigned int *num)
|
|
|
|
{
|
|
|
|
sector_t end;
|
|
|
|
unsigned int mapped;
|
|
|
|
unsigned long index;
|
|
|
|
unsigned long next;
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2013-04-16 13:11:58 +00:00
|
|
|
index = lba_to_map_index(lba);
|
|
|
|
mapped = test_bit(index, map_storep);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
|
|
|
if (mapped)
|
2013-04-16 13:11:58 +00:00
|
|
|
next = find_next_zero_bit(map_storep, map_size, index);
|
2009-10-15 18:45:27 +00:00
|
|
|
else
|
2013-04-16 13:11:58 +00:00
|
|
|
next = find_next_bit(map_storep, map_size, index);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2013-04-16 13:11:58 +00:00
|
|
|
end = min_t(sector_t, sdebug_store_sectors, map_index_to_lba(next));
|
2009-10-15 18:45:27 +00:00
|
|
|
*num = end - lba;
|
|
|
|
return mapped;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void map_region(sector_t lba, unsigned int len)
|
|
|
|
{
|
|
|
|
sector_t end = lba + len;
|
|
|
|
|
|
|
|
while (lba < end) {
|
2013-04-16 13:11:58 +00:00
|
|
|
unsigned long index = lba_to_map_index(lba);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2013-04-16 13:11:58 +00:00
|
|
|
if (index < map_size)
|
|
|
|
set_bit(index, map_storep);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2013-04-16 13:11:58 +00:00
|
|
|
lba = map_index_to_lba(index + 1);
|
2009-10-15 18:45:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void unmap_region(sector_t lba, unsigned int len)
|
|
|
|
{
|
|
|
|
sector_t end = lba + len;
|
|
|
|
|
|
|
|
while (lba < end) {
|
2013-04-16 13:11:58 +00:00
|
|
|
unsigned long index = lba_to_map_index(lba);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2013-04-16 13:11:58 +00:00
|
|
|
if (lba == map_index_to_lba(index) &&
|
2016-04-25 16:16:28 +00:00
|
|
|
lba + sdebug_unmap_granularity <= end &&
|
2013-04-16 13:11:58 +00:00
|
|
|
index < map_size) {
|
|
|
|
clear_bit(index, map_storep);
|
2016-05-06 04:40:27 +00:00
|
|
|
if (sdebug_lbprz) { /* for LBPRZ=2 return 0xff_s */
|
2012-03-08 06:03:59 +00:00
|
|
|
memset(fake_storep +
|
2016-05-06 04:40:27 +00:00
|
|
|
lba * sdebug_sector_size,
|
|
|
|
(sdebug_lbprz & 1) ? 0 : 0xff,
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_sector_size *
|
|
|
|
sdebug_unmap_granularity);
|
2013-04-16 13:11:58 +00:00
|
|
|
}
|
2013-06-29 08:59:17 +00:00
|
|
|
if (dif_storep) {
|
|
|
|
memset(dif_storep + lba, 0xff,
|
|
|
|
sizeof(*dif_storep) *
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_unmap_granularity);
|
2013-06-29 08:59:17 +00:00
|
|
|
}
|
2012-03-08 06:03:59 +00:00
|
|
|
}
|
2013-04-16 13:11:58 +00:00
|
|
|
lba = map_index_to_lba(index + 1);
|
2009-10-15 18:45:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-11-25 01:46:29 +00:00
|
|
|
u8 *cmd = scp->cmnd;
|
|
|
|
u64 lba;
|
|
|
|
u32 num;
|
|
|
|
u32 ei_lba;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long iflags;
|
2008-03-29 15:59:56 +00:00
|
|
|
int ret;
|
2014-11-25 01:46:29 +00:00
|
|
|
bool check_prot;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
switch (cmd[0]) {
|
|
|
|
case WRITE_16:
|
|
|
|
ei_lba = 0;
|
|
|
|
lba = get_unaligned_be64(cmd + 2);
|
|
|
|
num = get_unaligned_be32(cmd + 10);
|
|
|
|
check_prot = true;
|
|
|
|
break;
|
|
|
|
case WRITE_10:
|
|
|
|
ei_lba = 0;
|
|
|
|
lba = get_unaligned_be32(cmd + 2);
|
|
|
|
num = get_unaligned_be16(cmd + 7);
|
|
|
|
check_prot = true;
|
|
|
|
break;
|
|
|
|
case WRITE_6:
|
|
|
|
ei_lba = 0;
|
|
|
|
lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
|
|
|
|
(u32)(cmd[1] & 0x1f) << 16;
|
|
|
|
num = (0 == cmd[4]) ? 256 : cmd[4];
|
|
|
|
check_prot = true;
|
|
|
|
break;
|
|
|
|
case WRITE_12:
|
|
|
|
ei_lba = 0;
|
|
|
|
lba = get_unaligned_be32(cmd + 2);
|
|
|
|
num = get_unaligned_be32(cmd + 6);
|
|
|
|
check_prot = true;
|
|
|
|
break;
|
|
|
|
case 0x53: /* XDWRITEREAD(10) */
|
|
|
|
ei_lba = 0;
|
|
|
|
lba = get_unaligned_be32(cmd + 2);
|
|
|
|
num = get_unaligned_be16(cmd + 7);
|
|
|
|
check_prot = false;
|
|
|
|
break;
|
|
|
|
default: /* assume WRITE(32) */
|
|
|
|
lba = get_unaligned_be64(cmd + 12);
|
|
|
|
ei_lba = get_unaligned_be32(cmd + 20);
|
|
|
|
num = get_unaligned_be32(cmd + 28);
|
|
|
|
check_prot = false;
|
|
|
|
break;
|
|
|
|
}
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(have_dif_prot && check_prot)) {
|
2016-09-11 17:35:41 +00:00
|
|
|
if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
|
2014-11-25 01:46:29 +00:00
|
|
|
(cmd[1] & 0xe0)) {
|
|
|
|
mk_sense_invalid_opcode(scp);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
2016-09-11 17:35:41 +00:00
|
|
|
if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
|
|
|
|
sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
|
2014-11-25 01:46:29 +00:00
|
|
|
(cmd[1] & 0xe0) == 0)
|
|
|
|
sdev_printk(KERN_ERR, scp->device, "Unprotected WR "
|
|
|
|
"to DIF device\n");
|
|
|
|
}
|
2019-02-08 23:37:25 +00:00
|
|
|
ret = check_device_access_params(scp, lba, num, true);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2014-02-26 13:57:03 +00:00
|
|
|
write_lock_irqsave(&atomic_rw, iflags);
|
|
|
|
|
2009-01-04 08:08:19 +00:00
|
|
|
/* DIX + T10 DIF */
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
|
2014-11-25 01:46:29 +00:00
|
|
|
int prot_ret = prot_verify_write(scp, lba, num, ei_lba);
|
2009-01-04 08:08:19 +00:00
|
|
|
|
|
|
|
if (prot_ret) {
|
2014-02-26 13:57:03 +00:00
|
|
|
write_unlock_irqrestore(&atomic_rw, iflags);
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, prot_ret);
|
2009-01-04 08:08:19 +00:00
|
|
|
return illegal_condition_result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-23 17:48:12 +00:00
|
|
|
ret = do_device_access(scp, 0, lba, num, true);
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(scsi_debug_lbp()))
|
2009-10-15 18:45:27 +00:00
|
|
|
map_region(lba, num);
|
2005-04-16 22:20:36 +00:00
|
|
|
write_unlock_irqrestore(&atomic_rw, iflags);
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(-1 == ret))
|
2016-04-25 16:16:28 +00:00
|
|
|
return DID_ERROR << 16;
|
2016-05-06 04:40:26 +00:00
|
|
|
else if (unlikely(sdebug_verbose &&
|
|
|
|
(ret < (num * sdebug_sector_size))))
|
2014-11-25 01:46:29 +00:00
|
|
|
sdev_printk(KERN_INFO, scp->device,
|
2014-07-26 15:55:35 +00:00
|
|
|
"%s: write: cdb indicated=%u, IO sent=%d bytes\n",
|
2016-04-25 16:16:28 +00:00
|
|
|
my_name, num * sdebug_sector_size, ret);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(sdebug_any_injecting_opt)) {
|
2016-05-06 04:40:26 +00:00
|
|
|
struct sdebug_queued_cmd *sqcp =
|
|
|
|
(struct sdebug_queued_cmd *)scp->host_scribble;
|
2014-11-25 01:46:29 +00:00
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
if (sqcp) {
|
|
|
|
if (sqcp->inj_recovered) {
|
|
|
|
mk_sense_buffer(scp, RECOVERED_ERROR,
|
|
|
|
THRESHOLD_EXCEEDED, 0);
|
|
|
|
return check_condition_result;
|
|
|
|
} else if (sqcp->inj_dif) {
|
|
|
|
/* Logical block guard check failed */
|
|
|
|
mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
|
|
|
|
return illegal_condition_result;
|
|
|
|
} else if (sqcp->inj_dix) {
|
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
|
|
|
|
return illegal_condition_result;
|
|
|
|
}
|
2014-11-25 01:46:29 +00:00
|
|
|
}
|
|
|
|
}
|
2009-10-15 18:45:27 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-12-23 17:48:14 +00:00
|
|
|
/*
|
|
|
|
* T10 has only specified WRITE SCATTERED(16) and WRITE SCATTERED(32).
|
|
|
|
* No READ GATHERED yet (requires bidi or long cdb holding gather list).
|
|
|
|
*/
|
|
|
|
static int resp_write_scat(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
|
|
|
{
|
|
|
|
u8 *cmd = scp->cmnd;
|
|
|
|
u8 *lrdp = NULL;
|
|
|
|
u8 *up;
|
|
|
|
u8 wrprotect;
|
|
|
|
u16 lbdof, num_lrd, k;
|
|
|
|
u32 num, num_by, bt_len, lbdof_blen, sg_off, cum_lb;
|
|
|
|
u32 lb_size = sdebug_sector_size;
|
|
|
|
u32 ei_lba;
|
|
|
|
u64 lba;
|
|
|
|
unsigned long iflags;
|
|
|
|
int ret, res;
|
|
|
|
bool is_16;
|
|
|
|
static const u32 lrd_size = 32; /* + parameter list header size */
|
|
|
|
|
|
|
|
if (cmd[0] == VARIABLE_LENGTH_CMD) {
|
|
|
|
is_16 = false;
|
|
|
|
wrprotect = (cmd[10] >> 5) & 0x7;
|
|
|
|
lbdof = get_unaligned_be16(cmd + 12);
|
|
|
|
num_lrd = get_unaligned_be16(cmd + 16);
|
|
|
|
bt_len = get_unaligned_be32(cmd + 28);
|
|
|
|
} else { /* that leaves WRITE SCATTERED(16) */
|
|
|
|
is_16 = true;
|
|
|
|
wrprotect = (cmd[2] >> 5) & 0x7;
|
|
|
|
lbdof = get_unaligned_be16(cmd + 4);
|
|
|
|
num_lrd = get_unaligned_be16(cmd + 8);
|
|
|
|
bt_len = get_unaligned_be32(cmd + 10);
|
|
|
|
if (unlikely(have_dif_prot)) {
|
|
|
|
if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
|
|
|
|
wrprotect) {
|
|
|
|
mk_sense_invalid_opcode(scp);
|
|
|
|
return illegal_condition_result;
|
|
|
|
}
|
|
|
|
if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
|
|
|
|
sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
|
|
|
|
wrprotect == 0)
|
|
|
|
sdev_printk(KERN_ERR, scp->device,
|
|
|
|
"Unprotected WR to DIF device\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((num_lrd == 0) || (bt_len == 0))
|
|
|
|
return 0; /* T10 says these do-nothings are not errors */
|
|
|
|
if (lbdof == 0) {
|
|
|
|
if (sdebug_verbose)
|
|
|
|
sdev_printk(KERN_INFO, scp->device,
|
|
|
|
"%s: %s: LB Data Offset field bad\n",
|
|
|
|
my_name, __func__);
|
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
|
|
|
|
return illegal_condition_result;
|
|
|
|
}
|
|
|
|
lbdof_blen = lbdof * lb_size;
|
|
|
|
if ((lrd_size + (num_lrd * lrd_size)) > lbdof_blen) {
|
|
|
|
if (sdebug_verbose)
|
|
|
|
sdev_printk(KERN_INFO, scp->device,
|
|
|
|
"%s: %s: LBA range descriptors don't fit\n",
|
|
|
|
my_name, __func__);
|
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
|
|
|
|
return illegal_condition_result;
|
|
|
|
}
|
|
|
|
lrdp = kzalloc(lbdof_blen, GFP_ATOMIC);
|
|
|
|
if (lrdp == NULL)
|
|
|
|
return SCSI_MLQUEUE_HOST_BUSY;
|
|
|
|
if (sdebug_verbose)
|
|
|
|
sdev_printk(KERN_INFO, scp->device,
|
|
|
|
"%s: %s: Fetch header+scatter_list, lbdof_blen=%u\n",
|
|
|
|
my_name, __func__, lbdof_blen);
|
|
|
|
res = fetch_to_dev_buffer(scp, lrdp, lbdof_blen);
|
|
|
|
if (res == -1) {
|
|
|
|
ret = DID_ERROR << 16;
|
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
write_lock_irqsave(&atomic_rw, iflags);
|
|
|
|
sg_off = lbdof_blen;
|
|
|
|
/* Spec says Buffer xfer Length field in number of LBs in dout */
|
|
|
|
cum_lb = 0;
|
|
|
|
for (k = 0, up = lrdp + lrd_size; k < num_lrd; ++k, up += lrd_size) {
|
|
|
|
lba = get_unaligned_be64(up + 0);
|
|
|
|
num = get_unaligned_be32(up + 8);
|
|
|
|
if (sdebug_verbose)
|
|
|
|
sdev_printk(KERN_INFO, scp->device,
|
|
|
|
"%s: %s: k=%d LBA=0x%llx num=%u sg_off=%u\n",
|
|
|
|
my_name, __func__, k, lba, num, sg_off);
|
|
|
|
if (num == 0)
|
|
|
|
continue;
|
2019-02-08 23:37:25 +00:00
|
|
|
ret = check_device_access_params(scp, lba, num, true);
|
2017-12-23 17:48:14 +00:00
|
|
|
if (ret)
|
|
|
|
goto err_out_unlock;
|
|
|
|
num_by = num * lb_size;
|
|
|
|
ei_lba = is_16 ? 0 : get_unaligned_be32(up + 12);
|
|
|
|
|
|
|
|
if ((cum_lb + num) > bt_len) {
|
|
|
|
if (sdebug_verbose)
|
|
|
|
sdev_printk(KERN_INFO, scp->device,
|
|
|
|
"%s: %s: sum of blocks > data provided\n",
|
|
|
|
my_name, __func__);
|
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, WRITE_ERROR_ASC,
|
|
|
|
0);
|
|
|
|
ret = illegal_condition_result;
|
|
|
|
goto err_out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* DIX + T10 DIF */
|
|
|
|
if (unlikely(sdebug_dix && scsi_prot_sg_count(scp))) {
|
|
|
|
int prot_ret = prot_verify_write(scp, lba, num,
|
|
|
|
ei_lba);
|
|
|
|
|
|
|
|
if (prot_ret) {
|
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10,
|
|
|
|
prot_ret);
|
|
|
|
ret = illegal_condition_result;
|
|
|
|
goto err_out_unlock;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = do_device_access(scp, sg_off, lba, num, true);
|
|
|
|
if (unlikely(scsi_debug_lbp()))
|
|
|
|
map_region(lba, num);
|
|
|
|
if (unlikely(-1 == ret)) {
|
|
|
|
ret = DID_ERROR << 16;
|
|
|
|
goto err_out_unlock;
|
|
|
|
} else if (unlikely(sdebug_verbose && (ret < num_by)))
|
|
|
|
sdev_printk(KERN_INFO, scp->device,
|
|
|
|
"%s: write: cdb indicated=%u, IO sent=%d bytes\n",
|
|
|
|
my_name, num_by, ret);
|
|
|
|
|
|
|
|
if (unlikely(sdebug_any_injecting_opt)) {
|
|
|
|
struct sdebug_queued_cmd *sqcp =
|
|
|
|
(struct sdebug_queued_cmd *)scp->host_scribble;
|
|
|
|
|
|
|
|
if (sqcp) {
|
|
|
|
if (sqcp->inj_recovered) {
|
|
|
|
mk_sense_buffer(scp, RECOVERED_ERROR,
|
|
|
|
THRESHOLD_EXCEEDED, 0);
|
|
|
|
ret = illegal_condition_result;
|
|
|
|
goto err_out_unlock;
|
|
|
|
} else if (sqcp->inj_dif) {
|
|
|
|
/* Logical block guard check failed */
|
|
|
|
mk_sense_buffer(scp, ABORTED_COMMAND,
|
|
|
|
0x10, 1);
|
|
|
|
ret = illegal_condition_result;
|
|
|
|
goto err_out_unlock;
|
|
|
|
} else if (sqcp->inj_dix) {
|
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST,
|
|
|
|
0x10, 1);
|
|
|
|
ret = illegal_condition_result;
|
|
|
|
goto err_out_unlock;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sg_off += num_by;
|
|
|
|
cum_lb += num;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
err_out_unlock:
|
|
|
|
write_unlock_irqrestore(&atomic_rw, iflags);
|
|
|
|
err_out:
|
|
|
|
kfree(lrdp);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_write_same(struct scsi_cmnd *scp, u64 lba, u32 num,
|
|
|
|
u32 ei_lba, bool unmap, bool ndob)
|
2009-10-15 18:45:27 +00:00
|
|
|
{
|
2019-01-25 17:46:09 +00:00
|
|
|
int ret;
|
2009-10-15 18:45:27 +00:00
|
|
|
unsigned long iflags;
|
|
|
|
unsigned long long i;
|
2019-01-25 17:46:09 +00:00
|
|
|
u32 lb_size = sdebug_sector_size;
|
|
|
|
u64 block, lbaa;
|
|
|
|
u8 *fs1p;
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2019-02-08 23:37:25 +00:00
|
|
|
ret = check_device_access_params(scp, lba, num, true);
|
2009-10-15 18:45:27 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
write_lock_irqsave(&atomic_rw, iflags);
|
|
|
|
|
2013-04-16 13:11:55 +00:00
|
|
|
if (unmap && scsi_debug_lbp()) {
|
2009-10-15 18:45:27 +00:00
|
|
|
unmap_region(lba, num);
|
|
|
|
goto out;
|
|
|
|
}
|
2019-01-25 17:46:09 +00:00
|
|
|
lbaa = lba;
|
|
|
|
block = do_div(lbaa, sdebug_store_sectors);
|
2014-11-25 01:46:29 +00:00
|
|
|
/* if ndob then zero 1 logical block, else fetch 1 logical block */
|
2019-01-25 17:46:09 +00:00
|
|
|
fs1p = fake_storep + (block * lb_size);
|
2014-11-25 01:46:29 +00:00
|
|
|
if (ndob) {
|
2019-01-25 17:46:09 +00:00
|
|
|
memset(fs1p, 0, lb_size);
|
2014-11-25 01:46:29 +00:00
|
|
|
ret = 0;
|
|
|
|
} else
|
2019-01-25 17:46:09 +00:00
|
|
|
ret = fetch_to_dev_buffer(scp, fs1p, lb_size);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
|
|
|
if (-1 == ret) {
|
|
|
|
write_unlock_irqrestore(&atomic_rw, iflags);
|
2016-04-25 16:16:28 +00:00
|
|
|
return DID_ERROR << 16;
|
2019-01-25 17:46:09 +00:00
|
|
|
} else if (sdebug_verbose && !ndob && (ret < lb_size))
|
2014-11-25 01:46:29 +00:00
|
|
|
sdev_printk(KERN_INFO, scp->device,
|
2017-10-29 14:47:19 +00:00
|
|
|
"%s: %s: lb size=%u, IO sent=%d bytes\n",
|
2019-01-25 17:46:09 +00:00
|
|
|
my_name, "write same", lb_size, ret);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
|
|
|
/* Copy first sector to remaining blocks */
|
2019-01-25 17:46:09 +00:00
|
|
|
for (i = 1 ; i < num ; i++) {
|
|
|
|
lbaa = lba + i;
|
|
|
|
block = do_div(lbaa, sdebug_store_sectors);
|
|
|
|
memmove(fake_storep + (block * lb_size), fs1p, lb_size);
|
|
|
|
}
|
2013-04-16 13:11:55 +00:00
|
|
|
if (scsi_debug_lbp())
|
2009-10-15 18:45:27 +00:00
|
|
|
map_region(lba, num);
|
|
|
|
out:
|
|
|
|
write_unlock_irqrestore(&atomic_rw, iflags);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_write_same_10(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2014-11-25 01:46:29 +00:00
|
|
|
{
|
|
|
|
u8 *cmd = scp->cmnd;
|
|
|
|
u32 lba;
|
|
|
|
u16 num;
|
|
|
|
u32 ei_lba = 0;
|
|
|
|
bool unmap = false;
|
|
|
|
|
|
|
|
if (cmd[1] & 0x8) {
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_lbpws10 == 0) {
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 3);
|
|
|
|
return check_condition_result;
|
|
|
|
} else
|
|
|
|
unmap = true;
|
|
|
|
}
|
|
|
|
lba = get_unaligned_be32(cmd + 2);
|
|
|
|
num = get_unaligned_be16(cmd + 7);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (num > sdebug_write_same_length) {
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 7, -1);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
return resp_write_same(scp, lba, num, ei_lba, unmap, false);
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_write_same_16(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2014-11-25 01:46:29 +00:00
|
|
|
{
|
|
|
|
u8 *cmd = scp->cmnd;
|
|
|
|
u64 lba;
|
|
|
|
u32 num;
|
|
|
|
u32 ei_lba = 0;
|
|
|
|
bool unmap = false;
|
|
|
|
bool ndob = false;
|
|
|
|
|
|
|
|
if (cmd[1] & 0x8) { /* UNMAP */
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_lbpws == 0) {
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 3);
|
|
|
|
return check_condition_result;
|
|
|
|
} else
|
|
|
|
unmap = true;
|
|
|
|
}
|
|
|
|
if (cmd[1] & 0x1) /* NDOB (no data-out buffer, assumes zeroes) */
|
|
|
|
ndob = true;
|
|
|
|
lba = get_unaligned_be64(cmd + 2);
|
|
|
|
num = get_unaligned_be32(cmd + 10);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (num > sdebug_write_same_length) {
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 10, -1);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
return resp_write_same(scp, lba, num, ei_lba, unmap, ndob);
|
|
|
|
}
|
|
|
|
|
2014-12-04 16:49:28 +00:00
|
|
|
/* Note the mode field is in the same position as the (lower) service action
|
|
|
|
* field. For the Report supported operation codes command, SPC-4 suggests
|
|
|
|
* each mode of this command should be reported separately; for future. */
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_write_buffer(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2014-12-04 16:49:28 +00:00
|
|
|
{
|
|
|
|
u8 *cmd = scp->cmnd;
|
|
|
|
struct scsi_device *sdp = scp->device;
|
|
|
|
struct sdebug_dev_info *dp;
|
|
|
|
u8 mode;
|
|
|
|
|
|
|
|
mode = cmd[1] & 0x1f;
|
|
|
|
switch (mode) {
|
|
|
|
case 0x4: /* download microcode (MC) and activate (ACT) */
|
|
|
|
/* set UAs on this device only */
|
|
|
|
set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
|
|
|
|
set_bit(SDEBUG_UA_MICROCODE_CHANGED, devip->uas_bm);
|
|
|
|
break;
|
|
|
|
case 0x5: /* download MC, save and ACT */
|
|
|
|
set_bit(SDEBUG_UA_MICROCODE_CHANGED_WO_RESET, devip->uas_bm);
|
|
|
|
break;
|
|
|
|
case 0x6: /* download MC with offsets and ACT */
|
|
|
|
/* set UAs on most devices (LUs) in this target */
|
|
|
|
list_for_each_entry(dp,
|
|
|
|
&devip->sdbg_host->dev_info_list,
|
|
|
|
dev_list)
|
|
|
|
if (dp->target == sdp->id) {
|
|
|
|
set_bit(SDEBUG_UA_BUS_RESET, dp->uas_bm);
|
|
|
|
if (devip != dp)
|
|
|
|
set_bit(SDEBUG_UA_MICROCODE_CHANGED,
|
|
|
|
dp->uas_bm);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 0x7: /* download MC with offsets, save, and ACT */
|
|
|
|
/* set UA on all devices (LUs) in this target */
|
|
|
|
list_for_each_entry(dp,
|
|
|
|
&devip->sdbg_host->dev_info_list,
|
|
|
|
dev_list)
|
|
|
|
if (dp->target == sdp->id)
|
|
|
|
set_bit(SDEBUG_UA_MICROCODE_CHANGED_WO_RESET,
|
|
|
|
dp->uas_bm);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* do nothing for this command for other mode values */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_comp_write(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2014-11-25 02:27:12 +00:00
|
|
|
{
|
|
|
|
u8 *cmd = scp->cmnd;
|
|
|
|
u8 *arr;
|
|
|
|
u8 *fake_storep_hold;
|
|
|
|
u64 lba;
|
|
|
|
u32 dnum;
|
2016-04-25 16:16:28 +00:00
|
|
|
u32 lb_size = sdebug_sector_size;
|
2014-11-25 02:27:12 +00:00
|
|
|
u8 num;
|
|
|
|
unsigned long iflags;
|
|
|
|
int ret;
|
2014-11-26 17:33:48 +00:00
|
|
|
int retval = 0;
|
2014-11-25 02:27:12 +00:00
|
|
|
|
2014-11-26 17:33:48 +00:00
|
|
|
lba = get_unaligned_be64(cmd + 2);
|
2014-11-25 02:27:12 +00:00
|
|
|
num = cmd[13]; /* 1 to a maximum of 255 logical blocks */
|
|
|
|
if (0 == num)
|
|
|
|
return 0; /* degenerate case, not an error */
|
2016-09-11 17:35:41 +00:00
|
|
|
if (sdebug_dif == T10_PI_TYPE2_PROTECTION &&
|
2014-11-25 02:27:12 +00:00
|
|
|
(cmd[1] & 0xe0)) {
|
|
|
|
mk_sense_invalid_opcode(scp);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
2016-09-11 17:35:41 +00:00
|
|
|
if ((sdebug_dif == T10_PI_TYPE1_PROTECTION ||
|
|
|
|
sdebug_dif == T10_PI_TYPE3_PROTECTION) &&
|
2014-11-25 02:27:12 +00:00
|
|
|
(cmd[1] & 0xe0) == 0)
|
|
|
|
sdev_printk(KERN_ERR, scp->device, "Unprotected WR "
|
|
|
|
"to DIF device\n");
|
2019-02-08 23:37:25 +00:00
|
|
|
ret = check_device_access_params(scp, lba, num, false);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2014-11-26 17:33:48 +00:00
|
|
|
dnum = 2 * num;
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 21:03:40 +00:00
|
|
|
arr = kcalloc(lb_size, dnum, GFP_ATOMIC);
|
2014-11-26 17:33:48 +00:00
|
|
|
if (NULL == arr) {
|
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
|
|
|
|
INSUFF_RES_ASCQ);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
2014-11-25 02:27:12 +00:00
|
|
|
|
|
|
|
write_lock_irqsave(&atomic_rw, iflags);
|
|
|
|
|
|
|
|
/* trick do_device_access() to fetch both compare and write buffers
|
|
|
|
* from data-in into arr. Safe (atomic) since write_lock held. */
|
|
|
|
fake_storep_hold = fake_storep;
|
|
|
|
fake_storep = arr;
|
2017-12-23 17:48:12 +00:00
|
|
|
ret = do_device_access(scp, 0, 0, dnum, true);
|
2014-11-25 02:27:12 +00:00
|
|
|
fake_storep = fake_storep_hold;
|
|
|
|
if (ret == -1) {
|
2014-11-26 17:33:48 +00:00
|
|
|
retval = DID_ERROR << 16;
|
|
|
|
goto cleanup;
|
2016-04-25 16:16:28 +00:00
|
|
|
} else if (sdebug_verbose && (ret < (dnum * lb_size)))
|
2014-11-25 02:27:12 +00:00
|
|
|
sdev_printk(KERN_INFO, scp->device, "%s: compare_write: cdb "
|
|
|
|
"indicated=%u, IO sent=%d bytes\n", my_name,
|
|
|
|
dnum * lb_size, ret);
|
|
|
|
if (!comp_write_worker(lba, num, arr)) {
|
|
|
|
mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
|
2014-11-26 17:33:48 +00:00
|
|
|
retval = check_condition_result;
|
|
|
|
goto cleanup;
|
2014-11-25 02:27:12 +00:00
|
|
|
}
|
|
|
|
if (scsi_debug_lbp())
|
|
|
|
map_region(lba, num);
|
2014-11-26 17:33:48 +00:00
|
|
|
cleanup:
|
2014-11-25 02:27:12 +00:00
|
|
|
write_unlock_irqrestore(&atomic_rw, iflags);
|
2014-11-26 17:33:48 +00:00
|
|
|
kfree(arr);
|
|
|
|
return retval;
|
2014-11-25 02:27:12 +00:00
|
|
|
}
|
|
|
|
|
2009-10-15 18:45:27 +00:00
|
|
|
struct unmap_block_desc {
|
|
|
|
__be64 lba;
|
|
|
|
__be32 blocks;
|
|
|
|
__be32 __reserved;
|
|
|
|
};
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_unmap(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
|
2009-10-15 18:45:27 +00:00
|
|
|
{
|
|
|
|
unsigned char *buf;
|
|
|
|
struct unmap_block_desc *desc;
|
|
|
|
unsigned int i, payload_len, descriptors;
|
|
|
|
int ret;
|
2014-02-26 13:57:03 +00:00
|
|
|
unsigned long iflags;
|
2009-10-15 18:45:27 +00:00
|
|
|
|
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
if (!scsi_debug_lbp())
|
|
|
|
return 0; /* fib and say its done */
|
|
|
|
payload_len = get_unaligned_be16(scp->cmnd + 7);
|
|
|
|
BUG_ON(scsi_bufflen(scp) != payload_len);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
|
|
|
descriptors = (payload_len - 8) / 16;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (descriptors > sdebug_unmap_max_desc) {
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 7, -1);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2016-04-25 16:16:30 +00:00
|
|
|
buf = kzalloc(scsi_bufflen(scp), GFP_ATOMIC);
|
2014-11-25 01:46:29 +00:00
|
|
|
if (!buf) {
|
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
|
|
|
|
INSUFF_RES_ASCQ);
|
2009-10-15 18:45:27 +00:00
|
|
|
return check_condition_result;
|
2014-11-25 01:46:29 +00:00
|
|
|
}
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
|
2009-10-15 18:45:27 +00:00
|
|
|
|
|
|
|
BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2);
|
|
|
|
BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16);
|
|
|
|
|
|
|
|
desc = (void *)&buf[8];
|
|
|
|
|
2014-02-26 13:57:03 +00:00
|
|
|
write_lock_irqsave(&atomic_rw, iflags);
|
|
|
|
|
2009-10-15 18:45:27 +00:00
|
|
|
for (i = 0 ; i < descriptors ; i++) {
|
|
|
|
unsigned long long lba = get_unaligned_be64(&desc[i].lba);
|
|
|
|
unsigned int num = get_unaligned_be32(&desc[i].blocks);
|
|
|
|
|
2019-02-08 23:37:25 +00:00
|
|
|
ret = check_device_access_params(scp, lba, num, true);
|
2009-10-15 18:45:27 +00:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
unmap_region(lba, num);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
2014-02-26 13:57:03 +00:00
|
|
|
write_unlock_irqrestore(&atomic_rw, iflags);
|
2009-10-15 18:45:27 +00:00
|
|
|
kfree(buf);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SDEBUG_GET_LBA_STATUS_LEN 32
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int resp_get_lba_status(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2009-10-15 18:45:27 +00:00
|
|
|
{
|
2014-11-25 01:46:29 +00:00
|
|
|
u8 *cmd = scp->cmnd;
|
|
|
|
u64 lba;
|
|
|
|
u32 alloc_len, mapped, num;
|
|
|
|
u8 arr[SDEBUG_GET_LBA_STATUS_LEN];
|
2009-10-15 18:45:27 +00:00
|
|
|
int ret;
|
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
lba = get_unaligned_be64(cmd + 2);
|
|
|
|
alloc_len = get_unaligned_be32(cmd + 10);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
|
|
|
if (alloc_len < 24)
|
|
|
|
return 0;
|
|
|
|
|
2019-02-08 23:37:25 +00:00
|
|
|
ret = check_device_access_params(scp, lba, 1, false);
|
2009-10-15 18:45:27 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
if (scsi_debug_lbp())
|
|
|
|
mapped = map_state(lba, &num);
|
|
|
|
else {
|
|
|
|
mapped = 1;
|
|
|
|
/* following just in case virtual_gb changed */
|
|
|
|
sdebug_capacity = get_sdebug_capacity();
|
|
|
|
if (sdebug_capacity - lba <= 0xffffffff)
|
|
|
|
num = sdebug_capacity - lba;
|
|
|
|
else
|
|
|
|
num = 0xffffffff;
|
|
|
|
}
|
2009-10-15 18:45:27 +00:00
|
|
|
|
|
|
|
memset(arr, 0, SDEBUG_GET_LBA_STATUS_LEN);
|
2014-11-25 01:46:29 +00:00
|
|
|
put_unaligned_be32(20, arr); /* Parameter Data Length */
|
|
|
|
put_unaligned_be64(lba, arr + 8); /* LBA */
|
|
|
|
put_unaligned_be32(num, arr + 16); /* Number of blocks */
|
|
|
|
arr[20] = !mapped; /* prov_stat=0: mapped; 1: dealloc */
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
return fill_from_dev_buffer(scp, arr, SDEBUG_GET_LBA_STATUS_LEN);
|
2009-10-15 18:45:27 +00:00
|
|
|
}
|
|
|
|
|
2018-02-10 02:36:39 +00:00
|
|
|
static int resp_sync_cache(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
|
|
|
{
|
2018-04-10 17:00:36 +00:00
|
|
|
int res = 0;
|
2018-02-10 02:36:39 +00:00
|
|
|
u64 lba;
|
|
|
|
u32 num_blocks;
|
|
|
|
u8 *cmd = scp->cmnd;
|
|
|
|
|
|
|
|
if (cmd[0] == SYNCHRONIZE_CACHE) { /* 10 byte cdb */
|
|
|
|
lba = get_unaligned_be32(cmd + 2);
|
|
|
|
num_blocks = get_unaligned_be16(cmd + 7);
|
|
|
|
} else { /* SYNCHRONIZE_CACHE(16) */
|
|
|
|
lba = get_unaligned_be64(cmd + 2);
|
|
|
|
num_blocks = get_unaligned_be32(cmd + 10);
|
|
|
|
}
|
|
|
|
if (lba + num_blocks > sdebug_capacity) {
|
|
|
|
mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
2018-04-10 17:00:36 +00:00
|
|
|
if (!write_since_sync || cmd[1] & 0x2)
|
|
|
|
res = SDEG_RES_IMMED_MASK;
|
|
|
|
else /* delay if write_since_sync and IMMED clear */
|
|
|
|
write_since_sync = false;
|
|
|
|
return res;
|
2018-02-10 02:36:39 +00:00
|
|
|
}
|
|
|
|
|
2016-05-31 21:15:07 +00:00
|
|
|
#define RL_BUCKET_ELEMS 8
|
|
|
|
|
2016-05-01 02:44:43 +00:00
|
|
|
/* Even though each pseudo target has a REPORT LUNS "well known logical unit"
|
|
|
|
* (W-LUN), the normal Linux scanning logic does not associate it with a
|
|
|
|
* device (e.g. /dev/sg7). The following magic will make that association:
|
|
|
|
* "cd /sys/class/scsi_host/host<n> ; echo '- - 49409' > scan"
|
|
|
|
* where <n> is a host number. If there are multiple targets in a host then
|
|
|
|
* the above will associate a W-LUN to each target. To only get a W-LUN
|
|
|
|
* for target 2, then use "echo '- 2 49409' > scan" .
|
|
|
|
*/
|
|
|
|
static int resp_report_luns(struct scsi_cmnd *scp,
|
|
|
|
struct sdebug_dev_info *devip)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-05-01 02:44:43 +00:00
|
|
|
unsigned char *cmd = scp->cmnd;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int alloc_len;
|
2016-05-01 02:44:43 +00:00
|
|
|
unsigned char select_report;
|
2014-11-25 04:04:47 +00:00
|
|
|
u64 lun;
|
2016-05-01 02:44:43 +00:00
|
|
|
struct scsi_lun *lun_p;
|
2016-05-31 21:15:07 +00:00
|
|
|
u8 arr[RL_BUCKET_ELEMS * sizeof(struct scsi_lun)];
|
2016-05-01 02:44:43 +00:00
|
|
|
unsigned int lun_cnt; /* normal LUN count (max: 256) */
|
|
|
|
unsigned int wlun_cnt; /* report luns W-LUN count */
|
|
|
|
unsigned int tlun_cnt; /* total LUN count */
|
|
|
|
unsigned int rlen; /* response length (in bytes) */
|
2016-05-31 21:15:07 +00:00
|
|
|
int k, j, n, res;
|
|
|
|
unsigned int off_rsp = 0;
|
|
|
|
const int sz_lun = sizeof(struct scsi_lun);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-12-04 16:49:27 +00:00
|
|
|
clear_luns_changed_on_target(devip);
|
2016-05-01 02:44:43 +00:00
|
|
|
|
|
|
|
select_report = cmd[2];
|
|
|
|
alloc_len = get_unaligned_be32(cmd + 6);
|
|
|
|
|
|
|
|
if (alloc_len < 4) {
|
|
|
|
pr_err("alloc len too small %d\n", alloc_len);
|
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 6, -1);
|
2005-04-16 22:20:36 +00:00
|
|
|
return check_condition_result;
|
|
|
|
}
|
2016-05-01 02:44:43 +00:00
|
|
|
|
|
|
|
switch (select_report) {
|
|
|
|
case 0: /* all LUNs apart from W-LUNs */
|
|
|
|
lun_cnt = sdebug_max_luns;
|
|
|
|
wlun_cnt = 0;
|
|
|
|
break;
|
|
|
|
case 1: /* only W-LUNs */
|
2006-06-06 04:11:24 +00:00
|
|
|
lun_cnt = 0;
|
2016-05-01 02:44:43 +00:00
|
|
|
wlun_cnt = 1;
|
|
|
|
break;
|
|
|
|
case 2: /* all LUNs */
|
|
|
|
lun_cnt = sdebug_max_luns;
|
|
|
|
wlun_cnt = 1;
|
|
|
|
break;
|
|
|
|
case 0x10: /* only administrative LUs */
|
|
|
|
case 0x11: /* see SPC-5 */
|
|
|
|
case 0x12: /* only subsiduary LUs owned by referenced LU */
|
|
|
|
default:
|
|
|
|
pr_debug("select report invalid %d\n", select_report);
|
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 2, -1);
|
|
|
|
return check_condition_result;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sdebug_no_lun_0 && (lun_cnt > 0))
|
2006-06-06 04:11:24 +00:00
|
|
|
--lun_cnt;
|
2016-05-01 02:44:43 +00:00
|
|
|
|
|
|
|
tlun_cnt = lun_cnt + wlun_cnt;
|
2016-05-31 21:15:07 +00:00
|
|
|
rlen = tlun_cnt * sz_lun; /* excluding 8 byte header */
|
|
|
|
scsi_set_resid(scp, scsi_bufflen(scp));
|
2016-05-01 02:44:43 +00:00
|
|
|
pr_debug("select_report %d luns = %d wluns = %d no_lun0 %d\n",
|
|
|
|
select_report, lun_cnt, wlun_cnt, sdebug_no_lun_0);
|
|
|
|
|
2016-05-31 21:15:07 +00:00
|
|
|
/* loops rely on sizeof response header same as sizeof lun (both 8) */
|
2016-05-01 02:44:43 +00:00
|
|
|
lun = sdebug_no_lun_0 ? 1 : 0;
|
2016-05-31 21:15:07 +00:00
|
|
|
for (k = 0, j = 0, res = 0; true; ++k, j = 0) {
|
|
|
|
memset(arr, 0, sizeof(arr));
|
|
|
|
lun_p = (struct scsi_lun *)&arr[0];
|
|
|
|
if (k == 0) {
|
|
|
|
put_unaligned_be32(rlen, &arr[0]);
|
|
|
|
++lun_p;
|
|
|
|
j = 1;
|
|
|
|
}
|
|
|
|
for ( ; j < RL_BUCKET_ELEMS; ++j, ++lun_p) {
|
|
|
|
if ((k * RL_BUCKET_ELEMS) + j > lun_cnt)
|
|
|
|
break;
|
|
|
|
int_to_scsilun(lun++, lun_p);
|
|
|
|
}
|
|
|
|
if (j < RL_BUCKET_ELEMS)
|
|
|
|
break;
|
|
|
|
n = j * sz_lun;
|
|
|
|
res = p_fill_from_dev_buffer(scp, arr, n, off_rsp);
|
|
|
|
if (res)
|
|
|
|
return res;
|
|
|
|
off_rsp += n;
|
|
|
|
}
|
|
|
|
if (wlun_cnt) {
|
|
|
|
int_to_scsilun(SCSI_W_LUN_REPORT_LUNS, lun_p);
|
|
|
|
++j;
|
|
|
|
}
|
|
|
|
if (j > 0)
|
|
|
|
res = p_fill_from_dev_buffer(scp, arr, j * sz_lun, off_rsp);
|
2016-05-01 02:44:43 +00:00
|
|
|
return res;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
static struct sdebug_queue *get_queue(struct scsi_cmnd *cmnd)
|
|
|
|
{
|
2018-01-26 16:52:19 +00:00
|
|
|
u32 tag = blk_mq_unique_tag(cmnd->request);
|
|
|
|
u16 hwq = blk_mq_unique_tag_to_hwq(tag);
|
2016-05-06 04:40:26 +00:00
|
|
|
|
2018-01-26 16:52:19 +00:00
|
|
|
pr_debug("tag=%#x, hwq=%d\n", tag, hwq);
|
|
|
|
if (WARN_ON_ONCE(hwq >= submit_queues))
|
|
|
|
hwq = 0;
|
|
|
|
return sdebug_q_arr + hwq;
|
2016-05-06 04:40:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Queued (deferred) command completions converge here. */
|
2016-04-25 16:16:33 +00:00
|
|
|
static void sdebug_q_cmd_complete(struct sdebug_defer *sd_dp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2018-07-21 05:10:04 +00:00
|
|
|
bool aborted = sd_dp->aborted;
|
2016-05-06 04:40:26 +00:00
|
|
|
int qc_idx;
|
2014-07-26 15:55:35 +00:00
|
|
|
int retiring = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long iflags;
|
2016-05-06 04:40:26 +00:00
|
|
|
struct sdebug_queue *sqp;
|
2014-07-26 15:55:35 +00:00
|
|
|
struct sdebug_queued_cmd *sqcp;
|
|
|
|
struct scsi_cmnd *scp;
|
|
|
|
struct sdebug_dev_info *devip;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-01-10 21:57:31 +00:00
|
|
|
sd_dp->defer_t = SDEB_DEFER_NONE;
|
2018-07-21 05:10:04 +00:00
|
|
|
if (unlikely(aborted))
|
|
|
|
sd_dp->aborted = false;
|
2016-05-06 04:40:26 +00:00
|
|
|
qc_idx = sd_dp->qc_idx;
|
|
|
|
sqp = sdebug_q_arr + sd_dp->sqa_idx;
|
|
|
|
if (sdebug_statistics) {
|
|
|
|
atomic_inc(&sdebug_completions);
|
|
|
|
if (raw_smp_processor_id() != sd_dp->issuing_cpu)
|
|
|
|
atomic_inc(&sdebug_miss_cpus);
|
|
|
|
}
|
|
|
|
if (unlikely((qc_idx < 0) || (qc_idx >= SDEBUG_CANQUEUE))) {
|
|
|
|
pr_err("wild qc_idx=%d\n", qc_idx);
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
spin_lock_irqsave(&sqp->qc_lock, iflags);
|
|
|
|
sqcp = &sqp->qc_arr[qc_idx];
|
2014-07-26 15:55:35 +00:00
|
|
|
scp = sqcp->a_cmnd;
|
2016-05-01 02:44:42 +00:00
|
|
|
if (unlikely(scp == NULL)) {
|
2016-05-06 04:40:26 +00:00
|
|
|
spin_unlock_irqrestore(&sqp->qc_lock, iflags);
|
|
|
|
pr_err("scp is NULL, sqa_idx=%d, qc_idx=%d\n",
|
|
|
|
sd_dp->sqa_idx, qc_idx);
|
2014-07-26 15:55:35 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
devip = (struct sdebug_dev_info *)scp->device->hostdata;
|
2016-04-25 16:16:34 +00:00
|
|
|
if (likely(devip))
|
2014-07-26 15:55:35 +00:00
|
|
|
atomic_dec(&devip->num_in_q);
|
|
|
|
else
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("devip=NULL\n");
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(atomic_read(&retired_max_queue) > 0))
|
2014-07-26 15:55:35 +00:00
|
|
|
retiring = 1;
|
|
|
|
|
|
|
|
sqcp->a_cmnd = NULL;
|
2016-05-06 04:40:26 +00:00
|
|
|
if (unlikely(!test_and_clear_bit(qc_idx, sqp->in_use_bm))) {
|
|
|
|
spin_unlock_irqrestore(&sqp->qc_lock, iflags);
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("Unexpected completion\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
}
|
2014-07-26 15:55:35 +00:00
|
|
|
|
|
|
|
if (unlikely(retiring)) { /* user has reduced max_queue */
|
|
|
|
int k, retval;
|
|
|
|
|
|
|
|
retval = atomic_read(&retired_max_queue);
|
2016-05-06 04:40:26 +00:00
|
|
|
if (qc_idx >= retval) {
|
|
|
|
spin_unlock_irqrestore(&sqp->qc_lock, iflags);
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("index %d too large\n", retval);
|
2014-07-26 15:55:35 +00:00
|
|
|
return;
|
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
k = find_last_bit(sqp->in_use_bm, retval);
|
2016-04-25 16:16:28 +00:00
|
|
|
if ((k < sdebug_max_queue) || (k == retval))
|
2014-07-26 15:55:35 +00:00
|
|
|
atomic_set(&retired_max_queue, 0);
|
|
|
|
else
|
|
|
|
atomic_set(&retired_max_queue, k + 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
spin_unlock_irqrestore(&sqp->qc_lock, iflags);
|
2018-07-21 05:10:04 +00:00
|
|
|
if (unlikely(aborted)) {
|
|
|
|
if (sdebug_verbose)
|
|
|
|
pr_info("bypassing scsi_done() due to aborted cmd\n");
|
|
|
|
return;
|
|
|
|
}
|
2014-07-26 15:55:35 +00:00
|
|
|
scp->scsi_done(scp); /* callback to mid level */
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
/* When high resolution timer goes off this function is called. */
|
2016-04-25 16:16:33 +00:00
|
|
|
static enum hrtimer_restart sdebug_q_cmd_hrt_complete(struct hrtimer *timer)
|
2014-07-26 15:55:35 +00:00
|
|
|
{
|
2016-04-25 16:16:32 +00:00
|
|
|
struct sdebug_defer *sd_dp = container_of(timer, struct sdebug_defer,
|
|
|
|
hrt);
|
|
|
|
sdebug_q_cmd_complete(sd_dp);
|
2014-07-26 15:55:35 +00:00
|
|
|
return HRTIMER_NORESTART;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-04-25 16:16:32 +00:00
|
|
|
/* When work queue schedules work, it calls this function. */
|
2016-04-25 16:16:33 +00:00
|
|
|
static void sdebug_q_cmd_wq_complete(struct work_struct *work)
|
2016-04-25 16:16:32 +00:00
|
|
|
{
|
|
|
|
struct sdebug_defer *sd_dp = container_of(work, struct sdebug_defer,
|
|
|
|
ew.work);
|
|
|
|
sdebug_q_cmd_complete(sd_dp);
|
|
|
|
}
|
|
|
|
|
2016-05-06 04:40:28 +00:00
|
|
|
static bool got_shared_uuid;
|
2017-05-17 07:55:26 +00:00
|
|
|
static uuid_t shared_uuid;
|
2016-05-06 04:40:28 +00:00
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static struct sdebug_dev_info *sdebug_device_create(
|
|
|
|
struct sdebug_host_info *sdbg_host, gfp_t flags)
|
2008-03-20 02:09:16 +00:00
|
|
|
{
|
|
|
|
struct sdebug_dev_info *devip;
|
|
|
|
|
|
|
|
devip = kzalloc(sizeof(*devip), flags);
|
|
|
|
if (devip) {
|
2016-05-06 04:40:28 +00:00
|
|
|
if (sdebug_uuid_ctl == 1)
|
2017-05-17 07:55:26 +00:00
|
|
|
uuid_gen(&devip->lu_name);
|
2016-05-06 04:40:28 +00:00
|
|
|
else if (sdebug_uuid_ctl == 2) {
|
|
|
|
if (got_shared_uuid)
|
|
|
|
devip->lu_name = shared_uuid;
|
|
|
|
else {
|
2017-05-17 07:55:26 +00:00
|
|
|
uuid_gen(&shared_uuid);
|
2016-05-06 04:40:28 +00:00
|
|
|
got_shared_uuid = true;
|
|
|
|
devip->lu_name = shared_uuid;
|
|
|
|
}
|
|
|
|
}
|
2008-03-20 02:09:16 +00:00
|
|
|
devip->sdbg_host = sdbg_host;
|
|
|
|
list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
|
|
|
|
}
|
|
|
|
return devip;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:34 +00:00
|
|
|
static struct sdebug_dev_info *find_build_dev_info(struct scsi_device *sdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:34 +00:00
|
|
|
struct sdebug_host_info *sdbg_host;
|
|
|
|
struct sdebug_dev_info *open_devip = NULL;
|
|
|
|
struct sdebug_dev_info *devip;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-02 09:30:18 +00:00
|
|
|
sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
|
|
|
|
if (!sdbg_host) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("Host info NULL\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return NULL;
|
2017-12-23 17:48:10 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
|
|
|
|
if ((devip->used) && (devip->channel == sdev->channel) &&
|
2017-12-23 17:48:10 +00:00
|
|
|
(devip->target == sdev->id) &&
|
|
|
|
(devip->lun == sdev->lun))
|
|
|
|
return devip;
|
2005-04-16 22:20:36 +00:00
|
|
|
else {
|
|
|
|
if ((!devip->used) && (!open_devip))
|
|
|
|
open_devip = devip;
|
|
|
|
}
|
|
|
|
}
|
2008-03-20 02:09:16 +00:00
|
|
|
if (!open_devip) { /* try and make a new one */
|
|
|
|
open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC);
|
|
|
|
if (!open_devip) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("out of memory at line %d\n", __LINE__);
|
2005-04-16 22:20:36 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
2008-03-20 02:09:17 +00:00
|
|
|
|
|
|
|
open_devip->channel = sdev->channel;
|
|
|
|
open_devip->target = sdev->id;
|
|
|
|
open_devip->lun = sdev->lun;
|
|
|
|
open_devip->sdbg_host = sdbg_host;
|
2014-07-26 15:55:35 +00:00
|
|
|
atomic_set(&open_devip->num_in_q, 0);
|
|
|
|
set_bit(SDEBUG_UA_POR, open_devip->uas_bm);
|
2014-11-25 01:46:29 +00:00
|
|
|
open_devip->used = true;
|
2008-03-20 02:09:17 +00:00
|
|
|
return open_devip;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-03-29 15:59:58 +00:00
|
|
|
static int scsi_debug_slave_alloc(struct scsi_device *sdp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_info("slave_alloc <%u %u %u %llu>\n",
|
2008-03-29 15:59:58 +00:00
|
|
|
sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-29 15:59:58 +00:00
|
|
|
static int scsi_debug_slave_configure(struct scsi_device *sdp)
|
|
|
|
{
|
2016-04-25 16:16:34 +00:00
|
|
|
struct sdebug_dev_info *devip =
|
|
|
|
(struct sdebug_dev_info *)sdp->hostdata;
|
2008-03-25 00:26:50 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_info("slave_configure <%u %u %u %llu>\n",
|
2008-03-29 15:59:58 +00:00
|
|
|
sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
|
2016-05-01 02:44:42 +00:00
|
|
|
if (sdp->host->max_cmd_len != SDEBUG_MAX_CMD_LEN)
|
|
|
|
sdp->host->max_cmd_len = SDEBUG_MAX_CMD_LEN;
|
|
|
|
if (devip == NULL) {
|
2016-04-25 16:16:34 +00:00
|
|
|
devip = find_build_dev_info(sdp);
|
2016-05-01 02:44:42 +00:00
|
|
|
if (devip == NULL)
|
2016-04-25 16:16:34 +00:00
|
|
|
return 1; /* no resources, will be marked offline */
|
|
|
|
}
|
2014-11-03 19:15:14 +00:00
|
|
|
sdp->hostdata = devip;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_no_uld)
|
2010-03-25 21:29:05 +00:00
|
|
|
sdp->no_uld_attach = 1;
|
2017-12-05 05:05:49 +00:00
|
|
|
config_cdb_len(sdp);
|
2008-03-29 15:59:58 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void scsi_debug_slave_destroy(struct scsi_device *sdp)
|
|
|
|
{
|
|
|
|
struct sdebug_dev_info *devip =
|
|
|
|
(struct sdebug_dev_info *)sdp->hostdata;
|
2008-03-25 00:26:50 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_info("slave_destroy <%u %u %u %llu>\n",
|
2008-03-29 15:59:58 +00:00
|
|
|
sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
|
|
|
|
if (devip) {
|
2011-03-31 01:57:33 +00:00
|
|
|
/* make this slot available for re-use */
|
2014-11-25 01:46:29 +00:00
|
|
|
devip->used = false;
|
2008-03-29 15:59:58 +00:00
|
|
|
sdp->hostdata = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-10 21:57:31 +00:00
|
|
|
static void stop_qc_helper(struct sdebug_defer *sd_dp,
|
|
|
|
enum sdeb_defer_type defer_t)
|
2016-05-06 04:40:26 +00:00
|
|
|
{
|
|
|
|
if (!sd_dp)
|
|
|
|
return;
|
2018-01-10 21:57:31 +00:00
|
|
|
if (defer_t == SDEB_DEFER_HRT)
|
2016-05-06 04:40:26 +00:00
|
|
|
hrtimer_cancel(&sd_dp->hrt);
|
2018-01-10 21:57:31 +00:00
|
|
|
else if (defer_t == SDEB_DEFER_WQ)
|
2016-05-06 04:40:26 +00:00
|
|
|
cancel_work_sync(&sd_dp->ew.work);
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:32 +00:00
|
|
|
/* If @cmnd found deletes its timer or work queue and returns true; else
|
|
|
|
returns false */
|
|
|
|
static bool stop_queued_cmnd(struct scsi_cmnd *cmnd)
|
2008-03-29 15:59:58 +00:00
|
|
|
{
|
|
|
|
unsigned long iflags;
|
2016-05-06 04:40:26 +00:00
|
|
|
int j, k, qmax, r_qmax;
|
2018-01-10 21:57:31 +00:00
|
|
|
enum sdeb_defer_type l_defer_t;
|
2016-05-06 04:40:26 +00:00
|
|
|
struct sdebug_queue *sqp;
|
2008-03-29 15:59:58 +00:00
|
|
|
struct sdebug_queued_cmd *sqcp;
|
2014-07-26 15:55:35 +00:00
|
|
|
struct sdebug_dev_info *devip;
|
2016-04-25 16:16:32 +00:00
|
|
|
struct sdebug_defer *sd_dp;
|
2008-03-29 15:59:58 +00:00
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
|
|
|
|
spin_lock_irqsave(&sqp->qc_lock, iflags);
|
|
|
|
qmax = sdebug_max_queue;
|
|
|
|
r_qmax = atomic_read(&retired_max_queue);
|
|
|
|
if (r_qmax > qmax)
|
|
|
|
qmax = r_qmax;
|
|
|
|
for (k = 0; k < qmax; ++k) {
|
|
|
|
if (test_bit(k, sqp->in_use_bm)) {
|
|
|
|
sqcp = &sqp->qc_arr[k];
|
|
|
|
if (cmnd != sqcp->a_cmnd)
|
|
|
|
continue;
|
|
|
|
/* found */
|
|
|
|
devip = (struct sdebug_dev_info *)
|
|
|
|
cmnd->device->hostdata;
|
|
|
|
if (devip)
|
|
|
|
atomic_dec(&devip->num_in_q);
|
|
|
|
sqcp->a_cmnd = NULL;
|
|
|
|
sd_dp = sqcp->sd_dp;
|
2018-01-10 21:57:31 +00:00
|
|
|
if (sd_dp) {
|
|
|
|
l_defer_t = sd_dp->defer_t;
|
|
|
|
sd_dp->defer_t = SDEB_DEFER_NONE;
|
|
|
|
} else
|
|
|
|
l_defer_t = SDEB_DEFER_NONE;
|
2016-05-06 04:40:26 +00:00
|
|
|
spin_unlock_irqrestore(&sqp->qc_lock, iflags);
|
2018-01-10 21:57:31 +00:00
|
|
|
stop_qc_helper(sd_dp, l_defer_t);
|
2016-05-06 04:40:26 +00:00
|
|
|
clear_bit(k, sqp->in_use_bm);
|
|
|
|
return true;
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
2008-03-29 15:59:58 +00:00
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
spin_unlock_irqrestore(&sqp->qc_lock, iflags);
|
2008-03-29 15:59:58 +00:00
|
|
|
}
|
2016-04-25 16:16:32 +00:00
|
|
|
return false;
|
2008-03-29 15:59:58 +00:00
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:32 +00:00
|
|
|
/* Deletes (stops) timers or work queues of all queued commands */
|
2008-03-29 15:59:58 +00:00
|
|
|
static void stop_all_queued(void)
|
|
|
|
{
|
|
|
|
unsigned long iflags;
|
2016-05-06 04:40:26 +00:00
|
|
|
int j, k;
|
2018-01-10 21:57:31 +00:00
|
|
|
enum sdeb_defer_type l_defer_t;
|
2016-05-06 04:40:26 +00:00
|
|
|
struct sdebug_queue *sqp;
|
2008-03-29 15:59:58 +00:00
|
|
|
struct sdebug_queued_cmd *sqcp;
|
2014-07-26 15:55:35 +00:00
|
|
|
struct sdebug_dev_info *devip;
|
2016-04-25 16:16:32 +00:00
|
|
|
struct sdebug_defer *sd_dp;
|
2008-03-29 15:59:58 +00:00
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
|
|
|
|
spin_lock_irqsave(&sqp->qc_lock, iflags);
|
|
|
|
for (k = 0; k < SDEBUG_CANQUEUE; ++k) {
|
|
|
|
if (test_bit(k, sqp->in_use_bm)) {
|
|
|
|
sqcp = &sqp->qc_arr[k];
|
|
|
|
if (sqcp->a_cmnd == NULL)
|
|
|
|
continue;
|
|
|
|
devip = (struct sdebug_dev_info *)
|
|
|
|
sqcp->a_cmnd->device->hostdata;
|
|
|
|
if (devip)
|
|
|
|
atomic_dec(&devip->num_in_q);
|
|
|
|
sqcp->a_cmnd = NULL;
|
|
|
|
sd_dp = sqcp->sd_dp;
|
2018-01-10 21:57:31 +00:00
|
|
|
if (sd_dp) {
|
|
|
|
l_defer_t = sd_dp->defer_t;
|
|
|
|
sd_dp->defer_t = SDEB_DEFER_NONE;
|
|
|
|
} else
|
|
|
|
l_defer_t = SDEB_DEFER_NONE;
|
2016-05-06 04:40:26 +00:00
|
|
|
spin_unlock_irqrestore(&sqp->qc_lock, iflags);
|
2018-01-10 21:57:31 +00:00
|
|
|
stop_qc_helper(sd_dp, l_defer_t);
|
2016-05-06 04:40:26 +00:00
|
|
|
clear_bit(k, sqp->in_use_bm);
|
|
|
|
spin_lock_irqsave(&sqp->qc_lock, iflags);
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
2008-03-29 15:59:58 +00:00
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
spin_unlock_irqrestore(&sqp->qc_lock, iflags);
|
2008-03-29 15:59:58 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
/* Free queued command memory on heap */
|
|
|
|
static void free_all_queued(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-05-06 04:40:26 +00:00
|
|
|
int j, k;
|
|
|
|
struct sdebug_queue *sqp;
|
2014-07-26 15:55:35 +00:00
|
|
|
struct sdebug_queued_cmd *sqcp;
|
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
|
|
|
|
for (k = 0; k < SDEBUG_CANQUEUE; ++k) {
|
|
|
|
sqcp = &sqp->qc_arr[k];
|
|
|
|
kfree(sqcp->sd_dp);
|
|
|
|
sqcp->sd_dp = NULL;
|
|
|
|
}
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
static int scsi_debug_abort(struct scsi_cmnd *SCpnt)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:32 +00:00
|
|
|
bool ok;
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
++num_aborts;
|
|
|
|
if (SCpnt) {
|
2016-04-25 16:16:32 +00:00
|
|
|
ok = stop_queued_cmnd(SCpnt);
|
|
|
|
if (SCpnt->device && (SDEBUG_OPT_ALL_NOISE & sdebug_opts))
|
|
|
|
sdev_printk(KERN_INFO, SCpnt->device,
|
|
|
|
"%s: command%s found\n", __func__,
|
|
|
|
ok ? "" : " not");
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
|
|
|
return SUCCESS;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int scsi_debug_device_reset(struct scsi_cmnd *SCpnt)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
++num_dev_resets;
|
2014-07-26 15:55:35 +00:00
|
|
|
if (SCpnt && SCpnt->device) {
|
|
|
|
struct scsi_device *sdp = SCpnt->device;
|
2016-04-25 16:16:34 +00:00
|
|
|
struct sdebug_dev_info *devip =
|
|
|
|
(struct sdebug_dev_info *)sdp->hostdata;
|
2014-07-26 15:55:35 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
|
2014-07-26 15:55:35 +00:00
|
|
|
sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (devip)
|
2014-07-26 15:55:35 +00:00
|
|
|
set_bit(SDEBUG_UA_POR, devip->uas_bm);
|
|
|
|
}
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int scsi_debug_target_reset(struct scsi_cmnd *SCpnt)
|
|
|
|
{
|
|
|
|
struct sdebug_host_info *sdbg_host;
|
|
|
|
struct sdebug_dev_info *devip;
|
|
|
|
struct scsi_device *sdp;
|
|
|
|
struct Scsi_Host *hp;
|
|
|
|
int k = 0;
|
|
|
|
|
|
|
|
++num_target_resets;
|
|
|
|
if (!SCpnt)
|
|
|
|
goto lie;
|
|
|
|
sdp = SCpnt->device;
|
|
|
|
if (!sdp)
|
|
|
|
goto lie;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
|
2014-07-26 15:55:35 +00:00
|
|
|
sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
|
|
|
|
hp = sdp->host;
|
|
|
|
if (!hp)
|
|
|
|
goto lie;
|
|
|
|
sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
|
|
|
|
if (sdbg_host) {
|
|
|
|
list_for_each_entry(devip,
|
|
|
|
&sdbg_host->dev_info_list,
|
|
|
|
dev_list)
|
|
|
|
if (devip->target == sdp->id) {
|
|
|
|
set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
|
|
|
|
++k;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-04-25 16:16:28 +00:00
|
|
|
if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
|
2014-07-26 15:55:35 +00:00
|
|
|
sdev_printk(KERN_INFO, sdp,
|
|
|
|
"%s: %d device(s) found in target\n", __func__, k);
|
|
|
|
lie:
|
2005-04-16 22:20:36 +00:00
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int scsi_debug_bus_reset(struct scsi_cmnd *SCpnt)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct sdebug_host_info *sdbg_host;
|
2014-07-26 15:55:35 +00:00
|
|
|
struct sdebug_dev_info *devip;
|
2017-12-23 17:48:10 +00:00
|
|
|
struct scsi_device *sdp;
|
|
|
|
struct Scsi_Host *hp;
|
2014-07-26 15:55:35 +00:00
|
|
|
int k = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
++num_bus_resets;
|
2014-07-26 15:55:35 +00:00
|
|
|
if (!(SCpnt && SCpnt->device))
|
|
|
|
goto lie;
|
|
|
|
sdp = SCpnt->device;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (SDEBUG_OPT_ALL_NOISE & sdebug_opts)
|
2014-07-26 15:55:35 +00:00
|
|
|
sdev_printk(KERN_INFO, sdp, "%s\n", __func__);
|
|
|
|
hp = sdp->host;
|
|
|
|
if (hp) {
|
2008-03-02 09:30:18 +00:00
|
|
|
sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (sdbg_host) {
|
2014-07-26 15:55:35 +00:00
|
|
|
list_for_each_entry(devip,
|
2017-12-23 17:48:10 +00:00
|
|
|
&sdbg_host->dev_info_list,
|
2014-07-26 15:55:35 +00:00
|
|
|
dev_list) {
|
|
|
|
set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
|
|
|
|
++k;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2016-04-25 16:16:28 +00:00
|
|
|
if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
|
2014-07-26 15:55:35 +00:00
|
|
|
sdev_printk(KERN_INFO, sdp,
|
|
|
|
"%s: %d device(s) found in host\n", __func__, k);
|
|
|
|
lie:
|
2005-04-16 22:20:36 +00:00
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int scsi_debug_host_reset(struct scsi_cmnd *SCpnt)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2018-02-10 02:12:43 +00:00
|
|
|
struct sdebug_host_info *sdbg_host;
|
2014-07-26 15:55:35 +00:00
|
|
|
struct sdebug_dev_info *devip;
|
|
|
|
int k = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
++num_host_resets;
|
2016-04-25 16:16:28 +00:00
|
|
|
if ((SCpnt->device) && (SDEBUG_OPT_ALL_NOISE & sdebug_opts))
|
2014-07-26 15:55:35 +00:00
|
|
|
sdev_printk(KERN_INFO, SCpnt->device, "%s\n", __func__);
|
2017-12-23 17:48:10 +00:00
|
|
|
spin_lock(&sdebug_host_list_lock);
|
|
|
|
list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
|
2014-07-26 15:55:35 +00:00
|
|
|
list_for_each_entry(devip, &sdbg_host->dev_info_list,
|
|
|
|
dev_list) {
|
|
|
|
set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
|
|
|
|
++k;
|
|
|
|
}
|
2017-12-23 17:48:10 +00:00
|
|
|
}
|
|
|
|
spin_unlock(&sdebug_host_list_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
stop_all_queued();
|
2016-04-25 16:16:28 +00:00
|
|
|
if (SDEBUG_OPT_RESET_NOISE & sdebug_opts)
|
2014-07-26 15:55:35 +00:00
|
|
|
sdev_printk(KERN_INFO, SCpnt->device,
|
|
|
|
"%s: %d device(s) found\n", __func__, k);
|
2005-04-16 22:20:36 +00:00
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
|
2008-03-29 15:59:54 +00:00
|
|
|
static void __init sdebug_build_parts(unsigned char *ramp,
|
2008-03-29 15:59:57 +00:00
|
|
|
unsigned long store_size)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2018-02-10 02:12:43 +00:00
|
|
|
struct partition *pp;
|
2005-04-16 22:20:36 +00:00
|
|
|
int starts[SDEBUG_MAX_PARTS + 2];
|
|
|
|
int sectors_per_part, num_sectors, k;
|
|
|
|
int heads_by_sects, start_sec, end_sec;
|
|
|
|
|
|
|
|
/* assume partition table already zeroed */
|
2016-04-25 16:16:28 +00:00
|
|
|
if ((sdebug_num_parts < 1) || (store_size < 1048576))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_num_parts > SDEBUG_MAX_PARTS) {
|
|
|
|
sdebug_num_parts = SDEBUG_MAX_PARTS;
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_warn("reducing partitions to %d\n", SDEBUG_MAX_PARTS);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-06-06 04:11:24 +00:00
|
|
|
num_sectors = (int)sdebug_store_sectors;
|
2005-04-16 22:20:36 +00:00
|
|
|
sectors_per_part = (num_sectors - sdebug_sectors_per)
|
2016-04-25 16:16:28 +00:00
|
|
|
/ sdebug_num_parts;
|
2005-04-16 22:20:36 +00:00
|
|
|
heads_by_sects = sdebug_heads * sdebug_sectors_per;
|
2017-12-23 17:48:10 +00:00
|
|
|
starts[0] = sdebug_sectors_per;
|
2016-04-25 16:16:28 +00:00
|
|
|
for (k = 1; k < sdebug_num_parts; ++k)
|
2005-04-16 22:20:36 +00:00
|
|
|
starts[k] = ((k * sectors_per_part) / heads_by_sects)
|
|
|
|
* heads_by_sects;
|
2016-04-25 16:16:28 +00:00
|
|
|
starts[sdebug_num_parts] = num_sectors;
|
|
|
|
starts[sdebug_num_parts + 1] = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
ramp[510] = 0x55; /* magic partition markings */
|
|
|
|
ramp[511] = 0xAA;
|
|
|
|
pp = (struct partition *)(ramp + 0x1be);
|
|
|
|
for (k = 0; starts[k + 1]; ++k, ++pp) {
|
|
|
|
start_sec = starts[k];
|
|
|
|
end_sec = starts[k + 1] - 1;
|
|
|
|
pp->boot_ind = 0;
|
|
|
|
|
|
|
|
pp->cyl = start_sec / heads_by_sects;
|
|
|
|
pp->head = (start_sec - (pp->cyl * heads_by_sects))
|
|
|
|
/ sdebug_sectors_per;
|
|
|
|
pp->sector = (start_sec % sdebug_sectors_per) + 1;
|
|
|
|
|
|
|
|
pp->end_cyl = end_sec / heads_by_sects;
|
|
|
|
pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
|
|
|
|
/ sdebug_sectors_per;
|
|
|
|
pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
|
|
|
|
|
2013-08-26 13:08:40 +00:00
|
|
|
pp->start_sect = cpu_to_le32(start_sec);
|
|
|
|
pp->nr_sects = cpu_to_le32(end_sec - start_sec + 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
pp->sys_ind = 0x83; /* plain Linux partition */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
static void block_unblock_all_queues(bool block)
|
|
|
|
{
|
|
|
|
int j;
|
|
|
|
struct sdebug_queue *sqp;
|
|
|
|
|
|
|
|
for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp)
|
|
|
|
atomic_set(&sqp->blocked, (int)block);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Adjust (by rounding down) the sdebug_cmnd_count so abs(every_nth)-1
|
|
|
|
* commands will be processed normally before triggers occur.
|
|
|
|
*/
|
|
|
|
static void tweak_cmnd_count(void)
|
|
|
|
{
|
|
|
|
int count, modulo;
|
|
|
|
|
|
|
|
modulo = abs(sdebug_every_nth);
|
|
|
|
if (modulo < 2)
|
|
|
|
return;
|
|
|
|
block_unblock_all_queues(true);
|
|
|
|
count = atomic_read(&sdebug_cmnd_count);
|
|
|
|
atomic_set(&sdebug_cmnd_count, (count / modulo) * modulo);
|
|
|
|
block_unblock_all_queues(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void clear_queue_stats(void)
|
|
|
|
{
|
|
|
|
atomic_set(&sdebug_cmnd_count, 0);
|
|
|
|
atomic_set(&sdebug_completions, 0);
|
|
|
|
atomic_set(&sdebug_miss_cpus, 0);
|
|
|
|
atomic_set(&sdebug_a_tsf, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void setup_inject(struct sdebug_queue *sqp,
|
|
|
|
struct sdebug_queued_cmd *sqcp)
|
|
|
|
{
|
2018-01-29 23:35:52 +00:00
|
|
|
if ((atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth)) > 0) {
|
|
|
|
if (sdebug_every_nth > 0)
|
|
|
|
sqcp->inj_recovered = sqcp->inj_transport
|
|
|
|
= sqcp->inj_dif
|
2018-07-21 05:10:04 +00:00
|
|
|
= sqcp->inj_dix = sqcp->inj_short
|
|
|
|
= sqcp->inj_host_busy = sqcp->inj_cmd_abort = 0;
|
2016-05-06 04:40:26 +00:00
|
|
|
return;
|
2018-01-29 23:35:52 +00:00
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
sqcp->inj_recovered = !!(SDEBUG_OPT_RECOVERED_ERR & sdebug_opts);
|
|
|
|
sqcp->inj_transport = !!(SDEBUG_OPT_TRANSPORT_ERR & sdebug_opts);
|
|
|
|
sqcp->inj_dif = !!(SDEBUG_OPT_DIF_ERR & sdebug_opts);
|
|
|
|
sqcp->inj_dix = !!(SDEBUG_OPT_DIX_ERR & sdebug_opts);
|
|
|
|
sqcp->inj_short = !!(SDEBUG_OPT_SHORT_TRANSFER & sdebug_opts);
|
2017-12-07 22:56:18 +00:00
|
|
|
sqcp->inj_host_busy = !!(SDEBUG_OPT_HOST_BUSY & sdebug_opts);
|
2018-07-21 05:10:04 +00:00
|
|
|
sqcp->inj_cmd_abort = !!(SDEBUG_OPT_CMD_ABORT & sdebug_opts);
|
2016-05-06 04:40:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Complete the processing of the thread that queued a SCSI command to this
|
|
|
|
* driver. It either completes the command by calling cmnd_done() or
|
|
|
|
* schedules a hr timer or work queue then returns 0. Returns
|
|
|
|
* SCSI_MLQUEUE_HOST_BUSY if temporarily out of resources.
|
|
|
|
*/
|
2016-04-25 16:16:33 +00:00
|
|
|
static int schedule_resp(struct scsi_cmnd *cmnd, struct sdebug_dev_info *devip,
|
2018-02-14 10:05:57 +00:00
|
|
|
int scsi_result,
|
|
|
|
int (*pfp)(struct scsi_cmnd *,
|
|
|
|
struct sdebug_dev_info *),
|
|
|
|
int delta_jiff, int ndelay)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-07-26 15:55:35 +00:00
|
|
|
unsigned long iflags;
|
2014-08-05 10:20:46 +00:00
|
|
|
int k, num_in_q, qdepth, inject;
|
2016-05-06 04:40:26 +00:00
|
|
|
struct sdebug_queue *sqp;
|
|
|
|
struct sdebug_queued_cmd *sqcp;
|
2015-07-28 13:54:24 +00:00
|
|
|
struct scsi_device *sdp;
|
2016-04-25 16:16:32 +00:00
|
|
|
struct sdebug_defer *sd_dp;
|
2015-07-28 13:54:24 +00:00
|
|
|
|
2016-05-01 02:44:42 +00:00
|
|
|
if (unlikely(devip == NULL)) {
|
|
|
|
if (scsi_result == 0)
|
2016-04-25 16:16:34 +00:00
|
|
|
scsi_result = DID_NO_CONNECT << 16;
|
|
|
|
goto respond_in_thread;
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
2015-07-28 13:54:24 +00:00
|
|
|
sdp = cmnd->device;
|
|
|
|
|
2014-08-05 10:20:46 +00:00
|
|
|
if (delta_jiff == 0)
|
|
|
|
goto respond_in_thread;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-08-05 10:20:46 +00:00
|
|
|
/* schedule the response at a later time if resources permit */
|
2016-05-06 04:40:26 +00:00
|
|
|
sqp = get_queue(cmnd);
|
|
|
|
spin_lock_irqsave(&sqp->qc_lock, iflags);
|
|
|
|
if (unlikely(atomic_read(&sqp->blocked))) {
|
|
|
|
spin_unlock_irqrestore(&sqp->qc_lock, iflags);
|
|
|
|
return SCSI_MLQUEUE_HOST_BUSY;
|
|
|
|
}
|
2014-07-26 15:55:35 +00:00
|
|
|
num_in_q = atomic_read(&devip->num_in_q);
|
|
|
|
qdepth = cmnd->device->queue_depth;
|
|
|
|
inject = 0;
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely((qdepth > 0) && (num_in_q >= qdepth))) {
|
2014-08-05 10:20:46 +00:00
|
|
|
if (scsi_result) {
|
2016-05-06 04:40:26 +00:00
|
|
|
spin_unlock_irqrestore(&sqp->qc_lock, iflags);
|
2014-08-05 10:20:46 +00:00
|
|
|
goto respond_in_thread;
|
|
|
|
} else
|
|
|
|
scsi_result = device_qfull_result;
|
2016-05-06 04:40:26 +00:00
|
|
|
} else if (unlikely(sdebug_every_nth &&
|
2016-04-25 16:16:34 +00:00
|
|
|
(SDEBUG_OPT_RARE_TSF & sdebug_opts) &&
|
|
|
|
(scsi_result == 0))) {
|
2014-07-26 15:55:35 +00:00
|
|
|
if ((num_in_q == (qdepth - 1)) &&
|
|
|
|
(atomic_inc_return(&sdebug_a_tsf) >=
|
2016-04-25 16:16:28 +00:00
|
|
|
abs(sdebug_every_nth))) {
|
2014-07-26 15:55:35 +00:00
|
|
|
atomic_set(&sdebug_a_tsf, 0);
|
|
|
|
inject = 1;
|
2014-08-05 10:20:46 +00:00
|
|
|
scsi_result = device_qfull_result;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
k = find_first_zero_bit(sqp->in_use_bm, sdebug_max_queue);
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(k >= sdebug_max_queue)) {
|
2016-05-06 04:40:26 +00:00
|
|
|
spin_unlock_irqrestore(&sqp->qc_lock, iflags);
|
2014-08-05 10:20:46 +00:00
|
|
|
if (scsi_result)
|
|
|
|
goto respond_in_thread;
|
2016-04-25 16:16:28 +00:00
|
|
|
else if (SDEBUG_OPT_ALL_TSF & sdebug_opts)
|
2014-08-05 10:20:46 +00:00
|
|
|
scsi_result = device_qfull_result;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (SDEBUG_OPT_Q_NOISE & sdebug_opts)
|
2014-07-26 15:55:35 +00:00
|
|
|
sdev_printk(KERN_INFO, sdp,
|
2014-08-05 10:20:46 +00:00
|
|
|
"%s: max_queue=%d exceeded, %s\n",
|
2016-04-25 16:16:28 +00:00
|
|
|
__func__, sdebug_max_queue,
|
2014-08-05 10:20:46 +00:00
|
|
|
(scsi_result ? "status: TASK SET FULL" :
|
|
|
|
"report: host busy"));
|
|
|
|
if (scsi_result)
|
|
|
|
goto respond_in_thread;
|
|
|
|
else
|
2014-07-26 15:55:35 +00:00
|
|
|
return SCSI_MLQUEUE_HOST_BUSY;
|
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
__set_bit(k, sqp->in_use_bm);
|
2014-07-26 15:55:35 +00:00
|
|
|
atomic_inc(&devip->num_in_q);
|
2016-05-06 04:40:26 +00:00
|
|
|
sqcp = &sqp->qc_arr[k];
|
2014-07-26 15:55:35 +00:00
|
|
|
sqcp->a_cmnd = cmnd;
|
2016-05-06 04:40:26 +00:00
|
|
|
cmnd->host_scribble = (unsigned char *)sqcp;
|
2016-04-25 16:16:32 +00:00
|
|
|
sd_dp = sqcp->sd_dp;
|
2016-05-06 04:40:26 +00:00
|
|
|
spin_unlock_irqrestore(&sqp->qc_lock, iflags);
|
|
|
|
if (unlikely(sdebug_every_nth && sdebug_any_injecting_opt))
|
|
|
|
setup_inject(sqp, sqcp);
|
2018-01-10 21:57:31 +00:00
|
|
|
if (sd_dp == NULL) {
|
|
|
|
sd_dp = kzalloc(sizeof(*sd_dp), GFP_ATOMIC);
|
|
|
|
if (sd_dp == NULL)
|
|
|
|
return SCSI_MLQUEUE_HOST_BUSY;
|
|
|
|
}
|
2018-02-14 10:05:57 +00:00
|
|
|
|
|
|
|
cmnd->result = pfp != NULL ? pfp(cmnd, devip) : 0;
|
|
|
|
if (cmnd->result & SDEG_RES_IMMED_MASK) {
|
|
|
|
/*
|
|
|
|
* This is the F_DELAY_OVERR case. No delay.
|
|
|
|
*/
|
|
|
|
cmnd->result &= ~SDEG_RES_IMMED_MASK;
|
|
|
|
delta_jiff = ndelay = 0;
|
|
|
|
}
|
|
|
|
if (cmnd->result == 0 && scsi_result != 0)
|
|
|
|
cmnd->result = scsi_result;
|
|
|
|
|
|
|
|
if (unlikely(sdebug_verbose && cmnd->result))
|
|
|
|
sdev_printk(KERN_INFO, sdp, "%s: non-zero result=0x%x\n",
|
|
|
|
__func__, cmnd->result);
|
|
|
|
|
2018-01-10 21:57:31 +00:00
|
|
|
if (delta_jiff > 0 || ndelay > 0) {
|
2016-04-25 16:16:30 +00:00
|
|
|
ktime_t kt;
|
2014-07-26 15:55:35 +00:00
|
|
|
|
2016-04-25 16:16:30 +00:00
|
|
|
if (delta_jiff > 0) {
|
2017-11-27 11:36:25 +00:00
|
|
|
kt = ns_to_ktime((u64)delta_jiff * (NSEC_PER_SEC / HZ));
|
2016-04-25 16:16:30 +00:00
|
|
|
} else
|
2018-01-10 21:57:31 +00:00
|
|
|
kt = ndelay;
|
|
|
|
if (!sd_dp->init_hrt) {
|
|
|
|
sd_dp->init_hrt = true;
|
2016-04-25 16:16:32 +00:00
|
|
|
sqcp->sd_dp = sd_dp;
|
|
|
|
hrtimer_init(&sd_dp->hrt, CLOCK_MONOTONIC,
|
2016-05-06 04:40:26 +00:00
|
|
|
HRTIMER_MODE_REL_PINNED);
|
2016-04-25 16:16:32 +00:00
|
|
|
sd_dp->hrt.function = sdebug_q_cmd_hrt_complete;
|
2016-05-06 04:40:26 +00:00
|
|
|
sd_dp->sqa_idx = sqp - sdebug_q_arr;
|
|
|
|
sd_dp->qc_idx = k;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
if (sdebug_statistics)
|
|
|
|
sd_dp->issuing_cpu = raw_smp_processor_id();
|
2018-01-10 21:57:31 +00:00
|
|
|
sd_dp->defer_t = SDEB_DEFER_HRT;
|
2016-05-06 04:40:26 +00:00
|
|
|
hrtimer_start(&sd_dp->hrt, kt, HRTIMER_MODE_REL_PINNED);
|
|
|
|
} else { /* jdelay < 0, use work queue */
|
2018-01-10 21:57:31 +00:00
|
|
|
if (!sd_dp->init_wq) {
|
|
|
|
sd_dp->init_wq = true;
|
2016-04-25 16:16:32 +00:00
|
|
|
sqcp->sd_dp = sd_dp;
|
2016-05-06 04:40:26 +00:00
|
|
|
sd_dp->sqa_idx = sqp - sdebug_q_arr;
|
|
|
|
sd_dp->qc_idx = k;
|
2016-04-25 16:16:32 +00:00
|
|
|
INIT_WORK(&sd_dp->ew.work, sdebug_q_cmd_wq_complete);
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
if (sdebug_statistics)
|
|
|
|
sd_dp->issuing_cpu = raw_smp_processor_id();
|
2018-01-10 21:57:31 +00:00
|
|
|
sd_dp->defer_t = SDEB_DEFER_WQ;
|
2018-07-21 05:10:04 +00:00
|
|
|
if (unlikely(sqcp->inj_cmd_abort))
|
|
|
|
sd_dp->aborted = true;
|
2016-04-25 16:16:32 +00:00
|
|
|
schedule_work(&sd_dp->ew.work);
|
2018-07-21 05:10:04 +00:00
|
|
|
if (unlikely(sqcp->inj_cmd_abort)) {
|
|
|
|
sdev_printk(KERN_INFO, sdp, "abort request tag %d\n",
|
|
|
|
cmnd->request->tag);
|
|
|
|
blk_abort_request(cmnd->request);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely((SDEBUG_OPT_Q_NOISE & sdebug_opts) &&
|
|
|
|
(scsi_result == device_qfull_result)))
|
2014-07-26 15:55:35 +00:00
|
|
|
sdev_printk(KERN_INFO, sdp,
|
|
|
|
"%s: num_in_q=%d +1, %s%s\n", __func__,
|
|
|
|
num_in_q, (inject ? "<inject> " : ""),
|
|
|
|
"status: TASK SET FULL");
|
|
|
|
return 0;
|
2014-08-05 10:20:46 +00:00
|
|
|
|
|
|
|
respond_in_thread: /* call back to mid-layer using invocation thread */
|
2018-02-14 10:05:57 +00:00
|
|
|
cmnd->result = pfp != NULL ? pfp(cmnd, devip) : 0;
|
|
|
|
cmnd->result &= ~SDEG_RES_IMMED_MASK;
|
|
|
|
if (cmnd->result == 0 && scsi_result != 0)
|
|
|
|
cmnd->result = scsi_result;
|
2014-08-05 10:20:46 +00:00
|
|
|
cmnd->scsi_done(cmnd);
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2014-07-26 15:55:35 +00:00
|
|
|
|
2006-09-17 00:30:47 +00:00
|
|
|
/* Note: The following macros create attribute files in the
|
|
|
|
/sys/module/scsi_debug/parameters directory. Unfortunately this
|
|
|
|
driver is unaware of a change and cannot trigger auxiliary actions
|
|
|
|
as it can when the corresponding attribute in the
|
|
|
|
/sys/bus/pseudo/drivers/scsi_debug directory is changed.
|
|
|
|
*/
|
2016-04-25 16:16:28 +00:00
|
|
|
module_param_named(add_host, sdebug_add_host, int, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_named(ato, sdebug_ato, int, S_IRUGO);
|
2017-12-05 05:05:49 +00:00
|
|
|
module_param_named(cdb_len, sdebug_cdb_len, int, 0644);
|
2016-04-25 16:16:28 +00:00
|
|
|
module_param_named(clustering, sdebug_clustering, bool, S_IRUGO | S_IWUSR);
|
2016-04-25 16:16:31 +00:00
|
|
|
module_param_named(delay, sdebug_jdelay, int, S_IRUGO | S_IWUSR);
|
2016-04-25 16:16:28 +00:00
|
|
|
module_param_named(dev_size_mb, sdebug_dev_size_mb, int, S_IRUGO);
|
|
|
|
module_param_named(dif, sdebug_dif, int, S_IRUGO);
|
|
|
|
module_param_named(dix, sdebug_dix, int, S_IRUGO);
|
|
|
|
module_param_named(dsense, sdebug_dsense, int, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_named(every_nth, sdebug_every_nth, int, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_named(fake_rw, sdebug_fake_rw, int, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_named(guard, sdebug_guard, uint, S_IRUGO);
|
|
|
|
module_param_named(host_lock, sdebug_host_lock, bool, S_IRUGO | S_IWUSR);
|
2017-10-02 14:26:33 +00:00
|
|
|
module_param_string(inq_vendor, sdebug_inq_vendor_id,
|
|
|
|
sizeof(sdebug_inq_vendor_id), S_IRUGO|S_IWUSR);
|
|
|
|
module_param_string(inq_product, sdebug_inq_product_id,
|
|
|
|
sizeof(sdebug_inq_product_id), S_IRUGO|S_IWUSR);
|
|
|
|
module_param_string(inq_rev, sdebug_inq_product_rev,
|
|
|
|
sizeof(sdebug_inq_product_rev), S_IRUGO|S_IWUSR);
|
2016-04-25 16:16:28 +00:00
|
|
|
module_param_named(lbpu, sdebug_lbpu, int, S_IRUGO);
|
|
|
|
module_param_named(lbpws, sdebug_lbpws, int, S_IRUGO);
|
|
|
|
module_param_named(lbpws10, sdebug_lbpws10, int, S_IRUGO);
|
|
|
|
module_param_named(lbprz, sdebug_lbprz, int, S_IRUGO);
|
|
|
|
module_param_named(lowest_aligned, sdebug_lowest_aligned, int, S_IRUGO);
|
|
|
|
module_param_named(max_luns, sdebug_max_luns, int, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_named(max_queue, sdebug_max_queue, int, S_IRUGO | S_IWUSR);
|
2018-02-03 18:38:35 +00:00
|
|
|
module_param_named(medium_error_start, sdebug_medium_error_start, int, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_named(medium_error_count, sdebug_medium_error_count, int, S_IRUGO | S_IWUSR);
|
2016-04-25 16:16:28 +00:00
|
|
|
module_param_named(ndelay, sdebug_ndelay, int, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_named(no_lun_0, sdebug_no_lun_0, int, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_named(no_uld, sdebug_no_uld, int, S_IRUGO);
|
|
|
|
module_param_named(num_parts, sdebug_num_parts, int, S_IRUGO);
|
|
|
|
module_param_named(num_tgts, sdebug_num_tgts, int, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_named(opt_blks, sdebug_opt_blks, int, S_IRUGO);
|
|
|
|
module_param_named(opts, sdebug_opts, int, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_named(physblk_exp, sdebug_physblk_exp, int, S_IRUGO);
|
2017-01-26 09:00:37 +00:00
|
|
|
module_param_named(opt_xferlen_exp, sdebug_opt_xferlen_exp, int, S_IRUGO);
|
2016-04-25 16:16:28 +00:00
|
|
|
module_param_named(ptype, sdebug_ptype, int, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_named(removable, sdebug_removable, bool, S_IRUGO | S_IWUSR);
|
|
|
|
module_param_named(scsi_level, sdebug_scsi_level, int, S_IRUGO);
|
|
|
|
module_param_named(sector_size, sdebug_sector_size, int, S_IRUGO);
|
2016-05-06 04:40:26 +00:00
|
|
|
module_param_named(statistics, sdebug_statistics, bool, S_IRUGO | S_IWUSR);
|
2016-04-25 16:16:28 +00:00
|
|
|
module_param_named(strict, sdebug_strict, bool, S_IRUGO | S_IWUSR);
|
2016-05-06 04:40:26 +00:00
|
|
|
module_param_named(submit_queues, submit_queues, int, S_IRUGO);
|
2016-04-25 16:16:28 +00:00
|
|
|
module_param_named(unmap_alignment, sdebug_unmap_alignment, int, S_IRUGO);
|
|
|
|
module_param_named(unmap_granularity, sdebug_unmap_granularity, int, S_IRUGO);
|
|
|
|
module_param_named(unmap_max_blocks, sdebug_unmap_max_blocks, int, S_IRUGO);
|
|
|
|
module_param_named(unmap_max_desc, sdebug_unmap_max_desc, int, S_IRUGO);
|
|
|
|
module_param_named(virtual_gb, sdebug_virtual_gb, int, S_IRUGO | S_IWUSR);
|
2016-05-06 04:40:28 +00:00
|
|
|
module_param_named(uuid_ctl, sdebug_uuid_ctl, int, S_IRUGO);
|
2016-04-25 16:16:28 +00:00
|
|
|
module_param_named(vpd_use_hostno, sdebug_vpd_use_hostno, int,
|
2011-03-08 07:08:11 +00:00
|
|
|
S_IRUGO | S_IWUSR);
|
2019-02-08 23:37:25 +00:00
|
|
|
module_param_named(wp, sdebug_wp, bool, S_IRUGO | S_IWUSR);
|
2016-04-25 16:16:28 +00:00
|
|
|
module_param_named(write_same_length, sdebug_write_same_length, int,
|
2011-03-08 07:08:11 +00:00
|
|
|
S_IRUGO | S_IWUSR);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
|
|
|
|
MODULE_DESCRIPTION("SCSI debug adapter driver");
|
|
|
|
MODULE_LICENSE("GPL");
|
2016-05-01 02:44:42 +00:00
|
|
|
MODULE_VERSION(SDEBUG_VERSION);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
|
2011-03-08 07:08:11 +00:00
|
|
|
MODULE_PARM_DESC(ato, "application tag ownership: 0=disk 1=host (def=1)");
|
2017-12-05 05:05:49 +00:00
|
|
|
MODULE_PARM_DESC(cdb_len, "suggest CDB lengths to drivers (def=10)");
|
2014-02-26 13:57:04 +00:00
|
|
|
MODULE_PARM_DESC(clustering, "when set enables larger transfers (def=0)");
|
2014-07-26 15:55:35 +00:00
|
|
|
MODULE_PARM_DESC(delay, "response delay (def=1 jiffy); 0:imm, -1,-2:tiny");
|
2014-11-25 01:46:29 +00:00
|
|
|
MODULE_PARM_DESC(dev_size_mb, "size in MiB of ram shared by devs(def=8)");
|
2011-03-08 07:08:11 +00:00
|
|
|
MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)");
|
|
|
|
MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)");
|
2006-06-06 04:11:24 +00:00
|
|
|
MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
|
2007-06-11 18:36:40 +00:00
|
|
|
MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
|
2006-09-17 00:30:47 +00:00
|
|
|
MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
|
2011-03-08 07:08:11 +00:00
|
|
|
MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");
|
2016-04-25 16:16:29 +00:00
|
|
|
MODULE_PARM_DESC(host_lock, "host_lock is ignored (def=0)");
|
2017-10-02 14:26:33 +00:00
|
|
|
MODULE_PARM_DESC(inq_vendor, "SCSI INQUIRY vendor string (def=\"Linux\")");
|
|
|
|
MODULE_PARM_DESC(inq_product, "SCSI INQUIRY product string (def=\"scsi_debug\")");
|
2017-12-05 05:05:49 +00:00
|
|
|
MODULE_PARM_DESC(inq_rev, "SCSI INQUIRY revision string (def=\""
|
|
|
|
SDEBUG_VERSION "\")");
|
2011-03-08 07:08:11 +00:00
|
|
|
MODULE_PARM_DESC(lbpu, "enable LBP, support UNMAP command (def=0)");
|
|
|
|
MODULE_PARM_DESC(lbpws, "enable LBP, support WRITE SAME(16) with UNMAP bit (def=0)");
|
|
|
|
MODULE_PARM_DESC(lbpws10, "enable LBP, support WRITE SAME(10) with UNMAP bit (def=0)");
|
2016-05-06 04:40:27 +00:00
|
|
|
MODULE_PARM_DESC(lbprz,
|
|
|
|
"on read unmapped LBs return 0 when 1 (def), return 0xff when 2");
|
2011-03-08 07:08:11 +00:00
|
|
|
MODULE_PARM_DESC(lowest_aligned, "lowest aligned lba (def=0)");
|
2006-06-06 04:11:24 +00:00
|
|
|
MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
|
2014-07-26 15:55:35 +00:00
|
|
|
MODULE_PARM_DESC(max_queue, "max number of queued commands (1 to max(def))");
|
2018-02-03 18:38:35 +00:00
|
|
|
MODULE_PARM_DESC(medium_error_start, "starting sector number to return MEDIUM error");
|
|
|
|
MODULE_PARM_DESC(medium_error_count, "count of sectors to return follow on MEDIUM error");
|
2014-07-26 15:55:35 +00:00
|
|
|
MODULE_PARM_DESC(ndelay, "response delay in nanoseconds (def=0 -> ignore)");
|
2006-06-06 04:11:24 +00:00
|
|
|
MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
|
2010-03-25 21:29:05 +00:00
|
|
|
MODULE_PARM_DESC(no_uld, "stop ULD (e.g. sd driver) attaching (def=0))");
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
|
2006-06-06 04:11:24 +00:00
|
|
|
MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
|
2015-12-16 22:53:51 +00:00
|
|
|
MODULE_PARM_DESC(opt_blks, "optimal transfer length in blocks (def=1024)");
|
2007-01-05 05:05:25 +00:00
|
|
|
MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
|
2011-03-08 07:08:11 +00:00
|
|
|
MODULE_PARM_DESC(physblk_exp, "physical block exponent (def=0)");
|
2017-01-26 09:00:37 +00:00
|
|
|
MODULE_PARM_DESC(opt_xferlen_exp, "optimal transfer length granularity exponent (def=physblk_exp)");
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
|
2012-09-06 10:04:33 +00:00
|
|
|
MODULE_PARM_DESC(removable, "claim to have removable media (def=0)");
|
2016-05-06 04:40:27 +00:00
|
|
|
MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=7[SPC-5])");
|
2009-05-15 04:40:33 +00:00
|
|
|
MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)");
|
2016-05-06 04:40:26 +00:00
|
|
|
MODULE_PARM_DESC(statistics, "collect statistics on commands, queues (def=0)");
|
2014-11-25 01:46:29 +00:00
|
|
|
MODULE_PARM_DESC(strict, "stricter checks: reserved field in cdb (def=0)");
|
2016-05-06 04:40:26 +00:00
|
|
|
MODULE_PARM_DESC(submit_queues, "support for block multi-queue (def=1)");
|
2011-03-08 07:08:11 +00:00
|
|
|
MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)");
|
|
|
|
MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=1)");
|
2010-08-19 15:49:00 +00:00
|
|
|
MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0xffffffff)");
|
|
|
|
MODULE_PARM_DESC(unmap_max_desc, "max # of ranges that can be unmapped in one cmd (def=256)");
|
2016-05-06 04:40:28 +00:00
|
|
|
MODULE_PARM_DESC(uuid_ctl,
|
|
|
|
"1->use uuid for lu name, 0->don't, 2->all use same (def=0)");
|
2014-11-25 01:46:29 +00:00
|
|
|
MODULE_PARM_DESC(virtual_gb, "virtual gigabyte (GiB) size (def=0 -> use dev_size_mb)");
|
2011-03-08 07:08:11 +00:00
|
|
|
MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
|
2019-02-08 23:37:25 +00:00
|
|
|
MODULE_PARM_DESC(wp, "Write Protect (def=0)");
|
2011-03-08 07:08:11 +00:00
|
|
|
MODULE_PARM_DESC(write_same_length, "Maximum blocks per WRITE SAME cmd (def=0xffff)");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-05-06 04:40:27 +00:00
|
|
|
#define SDEBUG_INFO_LEN 256
|
|
|
|
static char sdebug_info[SDEBUG_INFO_LEN];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static const char *scsi_debug_info(struct Scsi_Host *shp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-05-06 04:40:26 +00:00
|
|
|
int k;
|
|
|
|
|
2016-05-06 04:40:27 +00:00
|
|
|
k = scnprintf(sdebug_info, SDEBUG_INFO_LEN, "%s: version %s [%s]\n",
|
|
|
|
my_name, SDEBUG_VERSION, sdebug_version_date);
|
|
|
|
if (k >= (SDEBUG_INFO_LEN - 1))
|
2016-05-06 04:40:26 +00:00
|
|
|
return sdebug_info;
|
2016-05-06 04:40:27 +00:00
|
|
|
scnprintf(sdebug_info + k, SDEBUG_INFO_LEN - k,
|
|
|
|
" dev_size_mb=%d, opts=0x%x, submit_queues=%d, %s=%d",
|
|
|
|
sdebug_dev_size_mb, sdebug_opts, submit_queues,
|
|
|
|
"statistics", (int)sdebug_statistics);
|
2005-04-16 22:20:36 +00:00
|
|
|
return sdebug_info;
|
|
|
|
}
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
/* 'echo <val> > /proc/scsi/scsi_debug/<host_id>' writes to opts */
|
2016-04-25 16:16:33 +00:00
|
|
|
static int scsi_debug_write_info(struct Scsi_Host *host, char *buffer,
|
|
|
|
int length)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-03-31 05:46:06 +00:00
|
|
|
char arr[16];
|
|
|
|
int opts;
|
|
|
|
int minLen = length > 15 ? 15 : length;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-03-31 05:46:06 +00:00
|
|
|
if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
|
|
|
|
return -EACCES;
|
|
|
|
memcpy(arr, buffer, minLen);
|
|
|
|
arr[minLen] = '\0';
|
|
|
|
if (1 != sscanf(arr, "%d", &opts))
|
|
|
|
return -EINVAL;
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_opts = opts;
|
|
|
|
sdebug_verbose = !!(SDEBUG_OPT_NOISE & opts);
|
|
|
|
sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & opts);
|
|
|
|
if (sdebug_every_nth != 0)
|
2016-05-06 04:40:26 +00:00
|
|
|
tweak_cmnd_count();
|
2013-03-31 05:46:06 +00:00
|
|
|
return length;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
/* Output seen with 'cat /proc/scsi/scsi_debug/<host_id>'. It will be the
|
|
|
|
* same for each scsi_debug host (if more than one). Some of the counters
|
|
|
|
* output are not atomics so might be inaccurate in a busy system. */
|
2013-03-31 05:46:06 +00:00
|
|
|
static int scsi_debug_show_info(struct seq_file *m, struct Scsi_Host *host)
|
|
|
|
{
|
2016-05-06 04:40:26 +00:00
|
|
|
int f, j, l;
|
|
|
|
struct sdebug_queue *sqp;
|
|
|
|
|
|
|
|
seq_printf(m, "scsi_debug adapter driver, version %s [%s]\n",
|
|
|
|
SDEBUG_VERSION, sdebug_version_date);
|
|
|
|
seq_printf(m, "num_tgts=%d, %ssize=%d MB, opts=0x%x, every_nth=%d\n",
|
|
|
|
sdebug_num_tgts, "shared (ram) ", sdebug_dev_size_mb,
|
|
|
|
sdebug_opts, sdebug_every_nth);
|
|
|
|
seq_printf(m, "delay=%d, ndelay=%d, max_luns=%d, sector_size=%d %s\n",
|
|
|
|
sdebug_jdelay, sdebug_ndelay, sdebug_max_luns,
|
|
|
|
sdebug_sector_size, "bytes");
|
|
|
|
seq_printf(m, "cylinders=%d, heads=%d, sectors=%d, command aborts=%d\n",
|
|
|
|
sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
|
|
|
|
num_aborts);
|
|
|
|
seq_printf(m, "RESETs: device=%d, target=%d, bus=%d, host=%d\n",
|
|
|
|
num_dev_resets, num_target_resets, num_bus_resets,
|
|
|
|
num_host_resets);
|
|
|
|
seq_printf(m, "dix_reads=%d, dix_writes=%d, dif_errors=%d\n",
|
|
|
|
dix_reads, dix_writes, dif_errors);
|
2018-01-26 16:52:19 +00:00
|
|
|
seq_printf(m, "usec_in_jiffy=%lu, statistics=%d\n", TICK_NSEC / 1000,
|
|
|
|
sdebug_statistics);
|
2016-05-06 04:40:26 +00:00
|
|
|
seq_printf(m, "cmnd_count=%d, completions=%d, %s=%d, a_tsf=%d\n",
|
|
|
|
atomic_read(&sdebug_cmnd_count),
|
|
|
|
atomic_read(&sdebug_completions),
|
|
|
|
"miss_cpus", atomic_read(&sdebug_miss_cpus),
|
|
|
|
atomic_read(&sdebug_a_tsf));
|
|
|
|
|
|
|
|
seq_printf(m, "submit_queues=%d\n", submit_queues);
|
|
|
|
for (j = 0, sqp = sdebug_q_arr; j < submit_queues; ++j, ++sqp) {
|
|
|
|
seq_printf(m, " queue %d:\n", j);
|
|
|
|
f = find_first_bit(sqp->in_use_bm, sdebug_max_queue);
|
|
|
|
if (f != sdebug_max_queue) {
|
|
|
|
l = find_last_bit(sqp->in_use_bm, sdebug_max_queue);
|
|
|
|
seq_printf(m, " in_use_bm BUSY: %s: %d,%d\n",
|
|
|
|
"first,last bits", f, l);
|
|
|
|
}
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
2013-03-31 05:46:06 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t delay_show(struct device_driver *ddp, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:31 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_jdelay);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
/* Returns -EBUSY if jdelay is being changed and commands are queued. The unit
|
|
|
|
* of delay is jiffies.
|
|
|
|
*/
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t delay_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:31 +00:00
|
|
|
int jdelay, res;
|
2014-07-26 15:55:35 +00:00
|
|
|
|
2016-05-01 02:44:42 +00:00
|
|
|
if (count > 0 && sscanf(buf, "%d", &jdelay) == 1) {
|
2014-07-26 15:55:35 +00:00
|
|
|
res = count;
|
2016-04-25 16:16:31 +00:00
|
|
|
if (sdebug_jdelay != jdelay) {
|
2016-05-06 04:40:26 +00:00
|
|
|
int j, k;
|
|
|
|
struct sdebug_queue *sqp;
|
|
|
|
|
|
|
|
block_unblock_all_queues(true);
|
|
|
|
for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
|
|
|
|
++j, ++sqp) {
|
|
|
|
k = find_first_bit(sqp->in_use_bm,
|
|
|
|
sdebug_max_queue);
|
|
|
|
if (k != sdebug_max_queue) {
|
|
|
|
res = -EBUSY; /* queued commands */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (res > 0) {
|
2016-04-25 16:16:31 +00:00
|
|
|
sdebug_jdelay = jdelay;
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_ndelay = 0;
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
block_unblock_all_queues(false);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2014-07-26 15:55:35 +00:00
|
|
|
return res;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(delay);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
static ssize_t ndelay_show(struct device_driver *ddp, char *buf)
|
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ndelay);
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
|
|
|
/* Returns -EBUSY if ndelay is being changed and commands are queued */
|
2016-04-25 16:16:31 +00:00
|
|
|
/* If > 0 and accepted then sdebug_jdelay is set to JDELAY_OVERRIDDEN */
|
2014-07-26 15:55:35 +00:00
|
|
|
static ssize_t ndelay_store(struct device_driver *ddp, const char *buf,
|
2016-04-25 16:16:33 +00:00
|
|
|
size_t count)
|
2014-07-26 15:55:35 +00:00
|
|
|
{
|
2016-05-06 04:40:26 +00:00
|
|
|
int ndelay, res;
|
2014-07-26 15:55:35 +00:00
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &ndelay)) &&
|
2016-05-06 04:40:26 +00:00
|
|
|
(ndelay >= 0) && (ndelay < (1000 * 1000 * 1000))) {
|
2014-07-26 15:55:35 +00:00
|
|
|
res = count;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_ndelay != ndelay) {
|
2016-05-06 04:40:26 +00:00
|
|
|
int j, k;
|
|
|
|
struct sdebug_queue *sqp;
|
|
|
|
|
|
|
|
block_unblock_all_queues(true);
|
|
|
|
for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
|
|
|
|
++j, ++sqp) {
|
|
|
|
k = find_first_bit(sqp->in_use_bm,
|
|
|
|
sdebug_max_queue);
|
|
|
|
if (k != sdebug_max_queue) {
|
|
|
|
res = -EBUSY; /* queued commands */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (res > 0) {
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_ndelay = ndelay;
|
2016-04-25 16:16:31 +00:00
|
|
|
sdebug_jdelay = ndelay ? JDELAY_OVERRIDDEN
|
|
|
|
: DEF_JDELAY;
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
block_unblock_all_queues(false);
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
static DRIVER_ATTR_RW(ndelay);
|
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t opts_show(struct device_driver *ddp, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "0x%x\n", sdebug_opts);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t opts_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-12-23 17:48:10 +00:00
|
|
|
int opts;
|
2005-04-16 22:20:36 +00:00
|
|
|
char work[20];
|
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
if (sscanf(buf, "%10s", work) == 1) {
|
|
|
|
if (strncasecmp(work, "0x", 2) == 0) {
|
|
|
|
if (kstrtoint(work + 2, 16, &opts) == 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto opts_done;
|
|
|
|
} else {
|
2017-12-23 17:48:10 +00:00
|
|
|
if (kstrtoint(work, 10, &opts) == 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto opts_done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
opts_done:
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_opts = opts;
|
|
|
|
sdebug_verbose = !!(SDEBUG_OPT_NOISE & opts);
|
|
|
|
sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & opts);
|
2016-05-06 04:40:26 +00:00
|
|
|
tweak_cmnd_count();
|
2005-04-16 22:20:36 +00:00
|
|
|
return count;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(opts);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t ptype_show(struct device_driver *ddp, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ptype);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t ptype_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-12-23 17:48:10 +00:00
|
|
|
int n;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_ptype = n;
|
2005-04-16 22:20:36 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(ptype);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t dsense_show(struct device_driver *ddp, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dsense);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t dsense_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-12-23 17:48:10 +00:00
|
|
|
int n;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_dsense = n;
|
2005-04-16 22:20:36 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(dsense);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t fake_rw_show(struct device_driver *ddp, char *buf)
|
2006-09-17 00:30:47 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_fake_rw);
|
2006-09-17 00:30:47 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t fake_rw_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2006-09-17 00:30:47 +00:00
|
|
|
{
|
2017-12-23 17:48:10 +00:00
|
|
|
int n;
|
2006-09-17 00:30:47 +00:00
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
|
2014-07-26 15:55:35 +00:00
|
|
|
n = (n > 0);
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_fake_rw = (sdebug_fake_rw > 0);
|
|
|
|
if (sdebug_fake_rw != n) {
|
2014-07-26 15:55:35 +00:00
|
|
|
if ((0 == n) && (NULL == fake_storep)) {
|
|
|
|
unsigned long sz =
|
2016-04-25 16:16:28 +00:00
|
|
|
(unsigned long)sdebug_dev_size_mb *
|
2014-07-26 15:55:35 +00:00
|
|
|
1048576;
|
|
|
|
|
2018-07-21 05:10:04 +00:00
|
|
|
fake_storep = vzalloc(sz);
|
2014-07-26 15:55:35 +00:00
|
|
|
if (NULL == fake_storep) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("out of memory, 9\n");
|
2014-07-26 15:55:35 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_fake_rw = n;
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
2006-09-17 00:30:47 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(fake_rw);
|
2006-09-17 00:30:47 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t no_lun_0_show(struct device_driver *ddp, char *buf)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_lun_0);
|
2006-06-06 04:11:24 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t no_lun_0_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
2017-12-23 17:48:10 +00:00
|
|
|
int n;
|
2006-06-06 04:11:24 +00:00
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_no_lun_0 = n;
|
2006-06-06 04:11:24 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(no_lun_0);
|
2006-06-06 04:11:24 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t num_tgts_show(struct device_driver *ddp, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_tgts);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t num_tgts_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-12-23 17:48:10 +00:00
|
|
|
int n;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_num_tgts = n;
|
2005-04-16 22:20:36 +00:00
|
|
|
sdebug_max_tgts_luns();
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(num_tgts);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t dev_size_mb_show(struct device_driver *ddp, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dev_size_mb);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RO(dev_size_mb);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t num_parts_show(struct device_driver *ddp, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_num_parts);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RO(num_parts);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t every_nth_show(struct device_driver *ddp, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_every_nth);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t every_nth_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-12-23 17:48:10 +00:00
|
|
|
int nth;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_every_nth = nth;
|
2016-05-06 04:40:26 +00:00
|
|
|
if (nth && !sdebug_statistics) {
|
|
|
|
pr_info("every_nth needs statistics=1, set it\n");
|
|
|
|
sdebug_statistics = true;
|
|
|
|
}
|
|
|
|
tweak_cmnd_count();
|
2005-04-16 22:20:36 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(every_nth);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t max_luns_show(struct device_driver *ddp, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_max_luns);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t max_luns_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-12-23 17:48:10 +00:00
|
|
|
int n;
|
2014-12-04 16:49:27 +00:00
|
|
|
bool changed;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
|
2016-05-01 02:44:43 +00:00
|
|
|
if (n > 256) {
|
|
|
|
pr_warn("max_luns can be no more than 256\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2016-04-25 16:16:28 +00:00
|
|
|
changed = (sdebug_max_luns != n);
|
|
|
|
sdebug_max_luns = n;
|
2005-04-16 22:20:36 +00:00
|
|
|
sdebug_max_tgts_luns();
|
2016-04-25 16:16:28 +00:00
|
|
|
if (changed && (sdebug_scsi_level >= 5)) { /* >= SPC-3 */
|
2014-12-04 16:49:27 +00:00
|
|
|
struct sdebug_host_info *sdhp;
|
|
|
|
struct sdebug_dev_info *dp;
|
|
|
|
|
|
|
|
spin_lock(&sdebug_host_list_lock);
|
|
|
|
list_for_each_entry(sdhp, &sdebug_host_list,
|
|
|
|
host_list) {
|
|
|
|
list_for_each_entry(dp, &sdhp->dev_info_list,
|
|
|
|
dev_list) {
|
|
|
|
set_bit(SDEBUG_UA_LUNS_CHANGED,
|
|
|
|
dp->uas_bm);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&sdebug_host_list_lock);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(max_luns);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t max_queue_show(struct device_driver *ddp, char *buf)
|
2010-03-25 21:29:05 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_max_queue);
|
2010-03-25 21:29:05 +00:00
|
|
|
}
|
2014-07-26 15:55:35 +00:00
|
|
|
/* N.B. max_queue can be changed while there are queued commands. In flight
|
|
|
|
* commands beyond the new max_queue will be completed. */
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t max_queue_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2010-03-25 21:29:05 +00:00
|
|
|
{
|
2016-05-06 04:40:26 +00:00
|
|
|
int j, n, k, a;
|
|
|
|
struct sdebug_queue *sqp;
|
2010-03-25 21:29:05 +00:00
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n > 0) &&
|
2016-05-06 04:40:26 +00:00
|
|
|
(n <= SDEBUG_CANQUEUE)) {
|
|
|
|
block_unblock_all_queues(true);
|
|
|
|
k = 0;
|
|
|
|
for (j = 0, sqp = sdebug_q_arr; j < submit_queues;
|
|
|
|
++j, ++sqp) {
|
|
|
|
a = find_last_bit(sqp->in_use_bm, SDEBUG_CANQUEUE);
|
|
|
|
if (a > k)
|
|
|
|
k = a;
|
|
|
|
}
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_max_queue = n;
|
2016-05-06 04:40:26 +00:00
|
|
|
if (k == SDEBUG_CANQUEUE)
|
2014-07-26 15:55:35 +00:00
|
|
|
atomic_set(&retired_max_queue, 0);
|
|
|
|
else if (k >= n)
|
|
|
|
atomic_set(&retired_max_queue, k + 1);
|
|
|
|
else
|
|
|
|
atomic_set(&retired_max_queue, 0);
|
2016-05-06 04:40:26 +00:00
|
|
|
block_unblock_all_queues(false);
|
2010-03-25 21:29:05 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(max_queue);
|
2010-03-25 21:29:05 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t no_uld_show(struct device_driver *ddp, char *buf)
|
2010-03-25 21:29:05 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_no_uld);
|
2010-03-25 21:29:05 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RO(no_uld);
|
2010-03-25 21:29:05 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t scsi_level_show(struct device_driver *ddp, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_scsi_level);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RO(scsi_level);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t virtual_gb_show(struct device_driver *ddp, char *buf)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_virtual_gb);
|
2006-06-06 04:11:24 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t virtual_gb_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2006-06-06 04:11:24 +00:00
|
|
|
{
|
2017-12-23 17:48:10 +00:00
|
|
|
int n;
|
2014-11-25 01:27:51 +00:00
|
|
|
bool changed;
|
2006-06-06 04:11:24 +00:00
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
|
2016-04-25 16:16:28 +00:00
|
|
|
changed = (sdebug_virtual_gb != n);
|
|
|
|
sdebug_virtual_gb = n;
|
2008-03-29 15:59:55 +00:00
|
|
|
sdebug_capacity = get_sdebug_capacity();
|
2014-11-25 01:27:51 +00:00
|
|
|
if (changed) {
|
|
|
|
struct sdebug_host_info *sdhp;
|
|
|
|
struct sdebug_dev_info *dp;
|
|
|
|
|
2014-12-04 16:49:26 +00:00
|
|
|
spin_lock(&sdebug_host_list_lock);
|
2014-11-25 01:27:51 +00:00
|
|
|
list_for_each_entry(sdhp, &sdebug_host_list,
|
|
|
|
host_list) {
|
|
|
|
list_for_each_entry(dp, &sdhp->dev_info_list,
|
|
|
|
dev_list) {
|
|
|
|
set_bit(SDEBUG_UA_CAPACITY_CHANGED,
|
|
|
|
dp->uas_bm);
|
|
|
|
}
|
|
|
|
}
|
2014-12-04 16:49:26 +00:00
|
|
|
spin_unlock(&sdebug_host_list_lock);
|
2014-11-25 01:27:51 +00:00
|
|
|
}
|
2006-06-06 04:11:24 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(virtual_gb);
|
2006-06-06 04:11:24 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t add_host_show(struct device_driver *ddp, char *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_add_host);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int sdebug_add_adapter(void);
|
|
|
|
static void sdebug_remove_adapter(void);
|
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t add_host_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-03-20 02:09:15 +00:00
|
|
|
int delta_hosts;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-20 02:09:15 +00:00
|
|
|
if (sscanf(buf, "%d", &delta_hosts) != 1)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
if (delta_hosts > 0) {
|
|
|
|
do {
|
|
|
|
sdebug_add_adapter();
|
|
|
|
} while (--delta_hosts);
|
|
|
|
} else if (delta_hosts < 0) {
|
|
|
|
do {
|
|
|
|
sdebug_remove_adapter();
|
|
|
|
} while (++delta_hosts);
|
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(add_host);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t vpd_use_hostno_show(struct device_driver *ddp, char *buf)
|
2006-09-17 00:30:47 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_vpd_use_hostno);
|
2006-09-17 00:30:47 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t vpd_use_hostno_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2006-09-17 00:30:47 +00:00
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_vpd_use_hostno = n;
|
2006-09-17 00:30:47 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(vpd_use_hostno);
|
2006-09-17 00:30:47 +00:00
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
static ssize_t statistics_show(struct device_driver *ddp, char *buf)
|
|
|
|
{
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", (int)sdebug_statistics);
|
|
|
|
}
|
|
|
|
static ssize_t statistics_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
if ((count > 0) && (sscanf(buf, "%d", &n) == 1) && (n >= 0)) {
|
|
|
|
if (n > 0)
|
|
|
|
sdebug_statistics = true;
|
|
|
|
else {
|
|
|
|
clear_queue_stats();
|
|
|
|
sdebug_statistics = false;
|
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
static DRIVER_ATTR_RW(statistics);
|
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t sector_size_show(struct device_driver *ddp, char *buf)
|
2008-06-05 04:12:59 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%u\n", sdebug_sector_size);
|
2008-06-05 04:12:59 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RO(sector_size);
|
2008-06-05 04:12:59 +00:00
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
static ssize_t submit_queues_show(struct device_driver *ddp, char *buf)
|
|
|
|
{
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", submit_queues);
|
|
|
|
}
|
|
|
|
static DRIVER_ATTR_RO(submit_queues);
|
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t dix_show(struct device_driver *ddp, char *buf)
|
2009-01-04 08:08:19 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dix);
|
2009-01-04 08:08:19 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RO(dix);
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t dif_show(struct device_driver *ddp, char *buf)
|
2009-01-04 08:08:19 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_dif);
|
2009-01-04 08:08:19 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RO(dif);
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t guard_show(struct device_driver *ddp, char *buf)
|
2009-01-04 08:08:19 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%u\n", sdebug_guard);
|
2009-01-04 08:08:19 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RO(guard);
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t ato_show(struct device_driver *ddp, char *buf)
|
2009-01-04 08:08:19 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_ato);
|
2009-01-04 08:08:19 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RO(ato);
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t map_show(struct device_driver *ddp, char *buf)
|
2009-10-15 18:45:27 +00:00
|
|
|
{
|
|
|
|
ssize_t count;
|
|
|
|
|
2011-03-08 07:08:11 +00:00
|
|
|
if (!scsi_debug_lbp())
|
2009-10-15 18:45:27 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "0-%u\n",
|
|
|
|
sdebug_store_sectors);
|
|
|
|
|
2015-02-13 22:37:51 +00:00
|
|
|
count = scnprintf(buf, PAGE_SIZE - 1, "%*pbl",
|
|
|
|
(int)map_size, map_storep);
|
2009-10-15 18:45:27 +00:00
|
|
|
buf[count++] = '\n';
|
2015-02-13 22:37:51 +00:00
|
|
|
buf[count] = '\0';
|
2009-10-15 18:45:27 +00:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RO(map);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t removable_show(struct device_driver *ddp, char *buf)
|
2012-09-06 10:04:33 +00:00
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_removable ? 1 : 0);
|
2012-09-06 10:04:33 +00:00
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static ssize_t removable_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
2012-09-06 10:04:33 +00:00
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_removable = (n > 0);
|
2012-09-06 10:04:33 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-10-14 13:48:04 +00:00
|
|
|
static DRIVER_ATTR_RW(removable);
|
2012-09-06 10:04:33 +00:00
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
static ssize_t host_lock_show(struct device_driver *ddp, char *buf)
|
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_host_lock);
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
2016-04-25 16:16:29 +00:00
|
|
|
/* N.B. sdebug_host_lock does nothing, kept for backward compatibility */
|
2014-07-26 15:55:35 +00:00
|
|
|
static ssize_t host_lock_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
|
|
|
{
|
2016-04-25 16:16:29 +00:00
|
|
|
int n;
|
2014-07-26 15:55:35 +00:00
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
|
2016-04-25 16:16:29 +00:00
|
|
|
sdebug_host_lock = (n > 0);
|
|
|
|
return count;
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
static DRIVER_ATTR_RW(host_lock);
|
|
|
|
|
2014-11-25 01:46:29 +00:00
|
|
|
static ssize_t strict_show(struct device_driver *ddp, char *buf)
|
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_strict);
|
2014-11-25 01:46:29 +00:00
|
|
|
}
|
|
|
|
static ssize_t strict_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_strict = (n > 0);
|
2014-11-25 01:46:29 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
static DRIVER_ATTR_RW(strict);
|
|
|
|
|
2016-05-06 04:40:28 +00:00
|
|
|
static ssize_t uuid_ctl_show(struct device_driver *ddp, char *buf)
|
|
|
|
{
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", !!sdebug_uuid_ctl);
|
|
|
|
}
|
|
|
|
static DRIVER_ATTR_RO(uuid_ctl);
|
|
|
|
|
2017-12-05 05:05:49 +00:00
|
|
|
static ssize_t cdb_len_show(struct device_driver *ddp, char *buf)
|
|
|
|
{
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", sdebug_cdb_len);
|
|
|
|
}
|
|
|
|
static ssize_t cdb_len_store(struct device_driver *ddp, const char *buf,
|
|
|
|
size_t count)
|
|
|
|
{
|
|
|
|
int ret, n;
|
|
|
|
|
|
|
|
ret = kstrtoint(buf, 0, &n);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
sdebug_cdb_len = n;
|
|
|
|
all_config_cdb_len();
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
static DRIVER_ATTR_RW(cdb_len);
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
/* Note: The following array creates attribute files in the
|
2006-09-17 00:30:47 +00:00
|
|
|
/sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
|
|
|
|
files (over those found in the /sys/module/scsi_debug/parameters
|
|
|
|
directory) is that auxiliary actions can be triggered when an attribute
|
|
|
|
is changed. For example see: sdebug_add_host_store() above.
|
|
|
|
*/
|
2006-07-12 03:53:22 +00:00
|
|
|
|
2013-10-14 13:48:04 +00:00
|
|
|
static struct attribute *sdebug_drv_attrs[] = {
|
|
|
|
&driver_attr_delay.attr,
|
|
|
|
&driver_attr_opts.attr,
|
|
|
|
&driver_attr_ptype.attr,
|
|
|
|
&driver_attr_dsense.attr,
|
|
|
|
&driver_attr_fake_rw.attr,
|
|
|
|
&driver_attr_no_lun_0.attr,
|
|
|
|
&driver_attr_num_tgts.attr,
|
|
|
|
&driver_attr_dev_size_mb.attr,
|
|
|
|
&driver_attr_num_parts.attr,
|
|
|
|
&driver_attr_every_nth.attr,
|
|
|
|
&driver_attr_max_luns.attr,
|
|
|
|
&driver_attr_max_queue.attr,
|
|
|
|
&driver_attr_no_uld.attr,
|
|
|
|
&driver_attr_scsi_level.attr,
|
|
|
|
&driver_attr_virtual_gb.attr,
|
|
|
|
&driver_attr_add_host.attr,
|
|
|
|
&driver_attr_vpd_use_hostno.attr,
|
|
|
|
&driver_attr_sector_size.attr,
|
2016-05-06 04:40:26 +00:00
|
|
|
&driver_attr_statistics.attr,
|
|
|
|
&driver_attr_submit_queues.attr,
|
2013-10-14 13:48:04 +00:00
|
|
|
&driver_attr_dix.attr,
|
|
|
|
&driver_attr_dif.attr,
|
|
|
|
&driver_attr_guard.attr,
|
|
|
|
&driver_attr_ato.attr,
|
|
|
|
&driver_attr_map.attr,
|
|
|
|
&driver_attr_removable.attr,
|
2014-07-26 15:55:35 +00:00
|
|
|
&driver_attr_host_lock.attr,
|
|
|
|
&driver_attr_ndelay.attr,
|
2014-11-25 01:46:29 +00:00
|
|
|
&driver_attr_strict.attr,
|
2016-05-06 04:40:28 +00:00
|
|
|
&driver_attr_uuid_ctl.attr,
|
2017-12-05 05:05:49 +00:00
|
|
|
&driver_attr_cdb_len.attr,
|
2013-10-14 13:48:04 +00:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
ATTRIBUTE_GROUPS(sdebug_drv);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-02-26 13:56:59 +00:00
|
|
|
static struct device *pseudo_primary;
|
2008-03-29 15:59:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int __init scsi_debug_init(void)
|
|
|
|
{
|
2008-03-29 15:59:57 +00:00
|
|
|
unsigned long sz;
|
2005-04-16 22:20:36 +00:00
|
|
|
int host_to_add;
|
|
|
|
int k;
|
2006-07-12 03:53:22 +00:00
|
|
|
int ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
atomic_set(&retired_max_queue, 0);
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_ndelay >= 1000 * 1000 * 1000) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_warn("ndelay must be less than 1 second, ignored\n");
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_ndelay = 0;
|
|
|
|
} else if (sdebug_ndelay > 0)
|
2016-04-25 16:16:31 +00:00
|
|
|
sdebug_jdelay = JDELAY_OVERRIDDEN;
|
2014-07-26 15:55:35 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
switch (sdebug_sector_size) {
|
2008-06-05 04:12:59 +00:00
|
|
|
case 512:
|
|
|
|
case 1024:
|
|
|
|
case 2048:
|
|
|
|
case 4096:
|
|
|
|
break;
|
|
|
|
default:
|
2016-04-25 16:16:28 +00:00
|
|
|
pr_err("invalid sector_size %d\n", sdebug_sector_size);
|
2008-06-05 04:12:59 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
switch (sdebug_dif) {
|
2016-09-11 17:35:41 +00:00
|
|
|
case T10_PI_TYPE0_PROTECTION:
|
2016-04-25 16:16:34 +00:00
|
|
|
break;
|
2016-09-11 17:35:41 +00:00
|
|
|
case T10_PI_TYPE1_PROTECTION:
|
|
|
|
case T10_PI_TYPE2_PROTECTION:
|
|
|
|
case T10_PI_TYPE3_PROTECTION:
|
2016-04-25 16:16:34 +00:00
|
|
|
have_dif_prot = true;
|
2009-01-04 08:08:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("dif must be 0, 1, 2 or 3\n");
|
2009-01-04 08:08:19 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_guard > 1) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("guard must be 0 or 1\n");
|
2009-01-04 08:08:19 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_ato > 1) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("ato must be 0 or 1\n");
|
2009-01-04 08:08:19 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_physblk_exp > 15) {
|
|
|
|
pr_err("invalid physblk_exp %u\n", sdebug_physblk_exp);
|
2009-05-15 04:40:33 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2016-05-01 02:44:43 +00:00
|
|
|
if (sdebug_max_luns > 256) {
|
|
|
|
pr_warn("max_luns can be no more than 256, use default\n");
|
|
|
|
sdebug_max_luns = DEF_MAX_LUNS;
|
|
|
|
}
|
2009-05-15 04:40:33 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_lowest_aligned > 0x3fff) {
|
|
|
|
pr_err("lowest_aligned too big: %u\n", sdebug_lowest_aligned);
|
2009-05-15 04:40:33 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
if (submit_queues < 1) {
|
|
|
|
pr_err("submit_queues must be 1 or more\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
sdebug_q_arr = kcalloc(submit_queues, sizeof(struct sdebug_queue),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (sdebug_q_arr == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
for (k = 0; k < submit_queues; ++k)
|
|
|
|
spin_lock_init(&sdebug_q_arr[k].qc_lock);
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_dev_size_mb < 1)
|
|
|
|
sdebug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */
|
|
|
|
sz = (unsigned long)sdebug_dev_size_mb * 1048576;
|
|
|
|
sdebug_store_sectors = sz / sdebug_sector_size;
|
2008-03-29 15:59:55 +00:00
|
|
|
sdebug_capacity = get_sdebug_capacity();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* play around with geometry, don't waste too much on track 0 */
|
|
|
|
sdebug_heads = 8;
|
|
|
|
sdebug_sectors_per = 32;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_dev_size_mb >= 256)
|
2005-04-16 22:20:36 +00:00
|
|
|
sdebug_heads = 64;
|
2016-04-25 16:16:28 +00:00
|
|
|
else if (sdebug_dev_size_mb >= 16)
|
2015-11-26 18:22:50 +00:00
|
|
|
sdebug_heads = 32;
|
2005-04-16 22:20:36 +00:00
|
|
|
sdebug_cylinders_per = (unsigned long)sdebug_capacity /
|
|
|
|
(sdebug_sectors_per * sdebug_heads);
|
|
|
|
if (sdebug_cylinders_per >= 1024) {
|
|
|
|
/* other LLDs do this; implies >= 1GB ram disk ... */
|
|
|
|
sdebug_heads = 255;
|
|
|
|
sdebug_sectors_per = 63;
|
|
|
|
sdebug_cylinders_per = (unsigned long)sdebug_capacity /
|
|
|
|
(sdebug_sectors_per * sdebug_heads);
|
|
|
|
}
|
|
|
|
|
2016-05-01 02:44:42 +00:00
|
|
|
if (sdebug_fake_rw == 0) {
|
2018-07-21 05:10:04 +00:00
|
|
|
fake_storep = vzalloc(sz);
|
2014-07-26 15:55:35 +00:00
|
|
|
if (NULL == fake_storep) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("out of memory, 1\n");
|
2016-05-06 04:40:26 +00:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto free_q_arr;
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_num_parts > 0)
|
2014-07-26 15:55:35 +00:00
|
|
|
sdebug_build_parts(fake_storep, sz);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_dix) {
|
2009-01-04 08:08:19 +00:00
|
|
|
int dif_size;
|
|
|
|
|
2016-09-11 17:35:39 +00:00
|
|
|
dif_size = sdebug_store_sectors * sizeof(struct t10_pi_tuple);
|
2009-01-04 08:08:19 +00:00
|
|
|
dif_storep = vmalloc(dif_size);
|
|
|
|
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("dif_storep %u bytes @ %p\n", dif_size, dif_storep);
|
2009-01-04 08:08:19 +00:00
|
|
|
|
|
|
|
if (dif_storep == NULL) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("out of mem. (DIX)\n");
|
2009-01-04 08:08:19 +00:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto free_vm;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(dif_storep, 0xff, dif_size);
|
|
|
|
}
|
|
|
|
|
2011-03-08 07:08:11 +00:00
|
|
|
/* Logical Block Provisioning */
|
|
|
|
if (scsi_debug_lbp()) {
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_unmap_max_blocks =
|
|
|
|
clamp(sdebug_unmap_max_blocks, 0U, 0xffffffffU);
|
2010-08-19 15:49:00 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_unmap_max_desc =
|
|
|
|
clamp(sdebug_unmap_max_desc, 0U, 256U);
|
2010-08-19 15:49:00 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_unmap_granularity =
|
|
|
|
clamp(sdebug_unmap_granularity, 1U, 0xffffffffU);
|
2010-08-19 15:49:00 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_unmap_alignment &&
|
|
|
|
sdebug_unmap_granularity <=
|
|
|
|
sdebug_unmap_alignment) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("ERR: unmap_granularity <= unmap_alignment\n");
|
2016-05-06 04:40:26 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto free_vm;
|
2009-10-15 18:45:27 +00:00
|
|
|
}
|
|
|
|
|
2013-04-16 13:11:58 +00:00
|
|
|
map_size = lba_to_map_index(sdebug_store_sectors - 1) + 1;
|
treewide: Use array_size() in vmalloc()
The vmalloc() function has no 2-factor argument form, so multiplication
factors need to be wrapped in array_size(). This patch replaces cases of:
vmalloc(a * b)
with:
vmalloc(array_size(a, b))
as well as handling cases of:
vmalloc(a * b * c)
with:
vmalloc(array3_size(a, b, c))
This does, however, attempt to ignore constant size factors like:
vmalloc(4 * 1024)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
vmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
vmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
vmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
vmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
vmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
vmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
vmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
vmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
vmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
vmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
vmalloc(
- sizeof(TYPE) * (COUNT_ID)
+ array_size(COUNT_ID, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * COUNT_ID
+ array_size(COUNT_ID, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * (COUNT_CONST)
+ array_size(COUNT_CONST, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * COUNT_CONST
+ array_size(COUNT_CONST, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(THING) * (COUNT_ID)
+ array_size(COUNT_ID, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * COUNT_ID
+ array_size(COUNT_ID, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * (COUNT_CONST)
+ array_size(COUNT_CONST, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * COUNT_CONST
+ array_size(COUNT_CONST, sizeof(THING))
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
vmalloc(
- SIZE * COUNT
+ array_size(COUNT, SIZE)
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
vmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
vmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
vmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
vmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
vmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
vmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
vmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
vmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
vmalloc(C1 * C2 * C3, ...)
|
vmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants.
@@
expression E1, E2;
constant C1, C2;
@@
(
vmalloc(C1 * C2, ...)
|
vmalloc(
- E1 * E2
+ array_size(E1, E2)
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 21:27:11 +00:00
|
|
|
map_storep = vmalloc(array_size(sizeof(long),
|
|
|
|
BITS_TO_LONGS(map_size)));
|
2009-10-15 18:45:27 +00:00
|
|
|
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_info("%lu provisioning blocks\n", map_size);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
|
|
|
if (map_storep == NULL) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("out of mem. (MAP)\n");
|
2009-10-15 18:45:27 +00:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto free_vm;
|
|
|
|
}
|
|
|
|
|
2013-04-16 13:11:58 +00:00
|
|
|
bitmap_zero(map_storep, map_size);
|
2009-10-15 18:45:27 +00:00
|
|
|
|
|
|
|
/* Map first 1KB for partition table */
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_num_parts)
|
2009-10-15 18:45:27 +00:00
|
|
|
map_region(0, 2);
|
|
|
|
}
|
|
|
|
|
2010-09-07 00:24:28 +00:00
|
|
|
pseudo_primary = root_device_register("pseudo_0");
|
|
|
|
if (IS_ERR(pseudo_primary)) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_warn("root_device_register() error\n");
|
2010-09-07 00:24:28 +00:00
|
|
|
ret = PTR_ERR(pseudo_primary);
|
2006-07-12 03:53:22 +00:00
|
|
|
goto free_vm;
|
|
|
|
}
|
|
|
|
ret = bus_register(&pseudo_lld_bus);
|
|
|
|
if (ret < 0) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_warn("bus_register error: %d\n", ret);
|
2006-07-12 03:53:22 +00:00
|
|
|
goto dev_unreg;
|
|
|
|
}
|
|
|
|
ret = driver_register(&sdebug_driverfs_driver);
|
|
|
|
if (ret < 0) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_warn("driver_register error: %d\n", ret);
|
2006-07-12 03:53:22 +00:00
|
|
|
goto bus_unreg;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
host_to_add = sdebug_add_host;
|
|
|
|
sdebug_add_host = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
for (k = 0; k < host_to_add; k++) {
|
|
|
|
if (sdebug_add_adapter()) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("sdebug_add_adapter failed k=%d\n", k);
|
2017-12-23 17:48:10 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
|
|
|
pr_info("built %d host(s)\n", sdebug_add_host);
|
2015-07-28 13:54:20 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
2006-07-12 03:53:22 +00:00
|
|
|
|
|
|
|
bus_unreg:
|
|
|
|
bus_unregister(&pseudo_lld_bus);
|
|
|
|
dev_unreg:
|
2010-09-07 00:24:28 +00:00
|
|
|
root_device_unregister(pseudo_primary);
|
2006-07-12 03:53:22 +00:00
|
|
|
free_vm:
|
2015-07-28 13:54:22 +00:00
|
|
|
vfree(map_storep);
|
|
|
|
vfree(dif_storep);
|
2006-07-12 03:53:22 +00:00
|
|
|
vfree(fake_storep);
|
2016-05-06 04:40:26 +00:00
|
|
|
free_q_arr:
|
|
|
|
kfree(sdebug_q_arr);
|
2006-07-12 03:53:22 +00:00
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit scsi_debug_exit(void)
|
|
|
|
{
|
2016-04-25 16:16:28 +00:00
|
|
|
int k = sdebug_add_host;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
stop_all_queued();
|
|
|
|
for (; k; k--)
|
|
|
|
sdebug_remove_adapter();
|
2018-06-18 16:08:03 +00:00
|
|
|
free_all_queued();
|
2005-04-16 22:20:36 +00:00
|
|
|
driver_unregister(&sdebug_driverfs_driver);
|
|
|
|
bus_unregister(&pseudo_lld_bus);
|
2010-09-07 00:24:28 +00:00
|
|
|
root_device_unregister(pseudo_primary);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-10-26 15:22:53 +00:00
|
|
|
vfree(map_storep);
|
2015-07-28 13:54:22 +00:00
|
|
|
vfree(dif_storep);
|
2005-04-16 22:20:36 +00:00
|
|
|
vfree(fake_storep);
|
2016-05-06 04:40:26 +00:00
|
|
|
kfree(sdebug_q_arr);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
device_initcall(scsi_debug_init);
|
|
|
|
module_exit(scsi_debug_exit);
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static void sdebug_release_adapter(struct device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-12-23 17:48:10 +00:00
|
|
|
struct sdebug_host_info *sdbg_host;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
sdbg_host = to_sdebug_host(dev);
|
2017-12-23 17:48:10 +00:00
|
|
|
kfree(sdbg_host);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int sdebug_add_adapter(void)
|
|
|
|
{
|
|
|
|
int k, devs_per_host;
|
2017-12-23 17:48:10 +00:00
|
|
|
int error = 0;
|
|
|
|
struct sdebug_host_info *sdbg_host;
|
2008-03-20 02:09:18 +00:00
|
|
|
struct sdebug_dev_info *sdbg_devinfo, *tmp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
sdbg_host = kzalloc(sizeof(*sdbg_host), GFP_KERNEL);
|
|
|
|
if (sdbg_host == NULL) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("out of memory at line %d\n", __LINE__);
|
2017-12-23 17:48:10 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
INIT_LIST_HEAD(&sdbg_host->dev_info_list);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
devs_per_host = sdebug_num_tgts * sdebug_max_luns;
|
2017-12-23 17:48:10 +00:00
|
|
|
for (k = 0; k < devs_per_host; k++) {
|
2008-03-20 02:09:16 +00:00
|
|
|
sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL);
|
|
|
|
if (!sdbg_devinfo) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("out of memory at line %d\n", __LINE__);
|
2017-12-23 17:48:10 +00:00
|
|
|
error = -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto clean;
|
2017-12-23 17:48:10 +00:00
|
|
|
}
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
spin_lock(&sdebug_host_list_lock);
|
|
|
|
list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
|
|
|
|
spin_unlock(&sdebug_host_list_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
sdbg_host->dev.bus = &pseudo_lld_bus;
|
|
|
|
sdbg_host->dev.parent = pseudo_primary;
|
|
|
|
sdbg_host->dev.release = &sdebug_release_adapter;
|
2016-04-25 16:16:28 +00:00
|
|
|
dev_set_name(&sdbg_host->dev, "adapter%d", sdebug_add_host);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
error = device_register(&sdbg_host->dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
if (error)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto clean;
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
++sdebug_add_host;
|
2017-12-23 17:48:10 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
clean:
|
2008-03-20 02:09:18 +00:00
|
|
|
list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
|
|
|
|
dev_list) {
|
2005-04-16 22:20:36 +00:00
|
|
|
list_del(&sdbg_devinfo->dev_list);
|
|
|
|
kfree(sdbg_devinfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(sdbg_host);
|
2017-12-23 17:48:10 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sdebug_remove_adapter(void)
|
|
|
|
{
|
2017-12-23 17:48:10 +00:00
|
|
|
struct sdebug_host_info *sdbg_host = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
spin_lock(&sdebug_host_list_lock);
|
|
|
|
if (!list_empty(&sdebug_host_list)) {
|
|
|
|
sdbg_host = list_entry(sdebug_host_list.prev,
|
|
|
|
struct sdebug_host_info, host_list);
|
2005-04-16 22:20:36 +00:00
|
|
|
list_del(&sdbg_host->host_list);
|
|
|
|
}
|
2017-12-23 17:48:10 +00:00
|
|
|
spin_unlock(&sdebug_host_list_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!sdbg_host)
|
|
|
|
return;
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
device_unregister(&sdbg_host->dev);
|
|
|
|
--sdebug_add_host;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int sdebug_change_qdepth(struct scsi_device *sdev, int qdepth)
|
2014-07-26 15:55:35 +00:00
|
|
|
{
|
|
|
|
int num_in_q = 0;
|
|
|
|
struct sdebug_dev_info *devip;
|
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
block_unblock_all_queues(true);
|
2014-07-26 15:55:35 +00:00
|
|
|
devip = (struct sdebug_dev_info *)sdev->hostdata;
|
|
|
|
if (NULL == devip) {
|
2016-05-06 04:40:26 +00:00
|
|
|
block_unblock_all_queues(false);
|
2014-07-26 15:55:35 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
num_in_q = atomic_read(&devip->num_in_q);
|
2014-11-13 13:25:11 +00:00
|
|
|
|
|
|
|
if (qdepth < 1)
|
|
|
|
qdepth = 1;
|
2016-05-06 04:40:26 +00:00
|
|
|
/* allow to exceed max host qc_arr elements for testing */
|
|
|
|
if (qdepth > SDEBUG_CANQUEUE + 10)
|
|
|
|
qdepth = SDEBUG_CANQUEUE + 10;
|
2014-11-13 14:08:42 +00:00
|
|
|
scsi_change_queue_depth(sdev, qdepth);
|
2014-11-13 13:25:11 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (SDEBUG_OPT_Q_NOISE & sdebug_opts) {
|
2016-05-06 04:40:26 +00:00
|
|
|
sdev_printk(KERN_INFO, sdev, "%s: qdepth=%d, num_in_q=%d\n",
|
2014-11-13 13:25:11 +00:00
|
|
|
__func__, qdepth, num_in_q);
|
2014-07-26 15:55:35 +00:00
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
block_unblock_all_queues(false);
|
2014-07-26 15:55:35 +00:00
|
|
|
return sdev->queue_depth;
|
|
|
|
}
|
|
|
|
|
2016-05-06 04:40:26 +00:00
|
|
|
static bool fake_timeout(struct scsi_cmnd *scp)
|
2014-11-25 01:18:02 +00:00
|
|
|
{
|
2016-05-06 04:40:26 +00:00
|
|
|
if (0 == (atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth))) {
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_every_nth < -1)
|
|
|
|
sdebug_every_nth = -1;
|
|
|
|
if (SDEBUG_OPT_TIMEOUT & sdebug_opts)
|
2016-05-06 04:40:26 +00:00
|
|
|
return true; /* ignore command causing timeout */
|
2016-04-25 16:16:28 +00:00
|
|
|
else if (SDEBUG_OPT_MAC_TIMEOUT & sdebug_opts &&
|
2014-11-25 01:18:02 +00:00
|
|
|
scsi_medium_access_command(scp))
|
2016-05-06 04:40:26 +00:00
|
|
|
return true; /* time out reads and writes */
|
2014-11-25 01:18:02 +00:00
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
return false;
|
2014-11-25 01:18:02 +00:00
|
|
|
}
|
|
|
|
|
2017-12-07 22:56:18 +00:00
|
|
|
static bool fake_host_busy(struct scsi_cmnd *scp)
|
|
|
|
{
|
|
|
|
return (sdebug_opts & SDEBUG_OPT_HOST_BUSY) &&
|
|
|
|
(atomic_read(&sdebug_cmnd_count) % abs(sdebug_every_nth)) == 0;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:33 +00:00
|
|
|
static int scsi_debug_queuecommand(struct Scsi_Host *shost,
|
|
|
|
struct scsi_cmnd *scp)
|
2014-11-25 01:46:29 +00:00
|
|
|
{
|
|
|
|
u8 sdeb_i;
|
|
|
|
struct scsi_device *sdp = scp->device;
|
|
|
|
const struct opcode_info_t *oip;
|
|
|
|
const struct opcode_info_t *r_oip;
|
|
|
|
struct sdebug_dev_info *devip;
|
|
|
|
u8 *cmd = scp->cmnd;
|
|
|
|
int (*r_pfp)(struct scsi_cmnd *, struct sdebug_dev_info *);
|
2018-02-14 10:05:57 +00:00
|
|
|
int (*pfp)(struct scsi_cmnd *, struct sdebug_dev_info *) = NULL;
|
2014-11-25 01:46:29 +00:00
|
|
|
int k, na;
|
|
|
|
int errsts = 0;
|
|
|
|
u32 flags;
|
|
|
|
u16 sa;
|
|
|
|
u8 opcode = cmd[0];
|
|
|
|
bool has_wlun_rl;
|
|
|
|
|
|
|
|
scsi_set_resid(scp, 0);
|
2016-05-06 04:40:26 +00:00
|
|
|
if (sdebug_statistics)
|
|
|
|
atomic_inc(&sdebug_cmnd_count);
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(sdebug_verbose &&
|
|
|
|
!(SDEBUG_OPT_NO_CDB_NOISE & sdebug_opts))) {
|
2014-11-25 01:46:29 +00:00
|
|
|
char b[120];
|
|
|
|
int n, len, sb;
|
|
|
|
|
|
|
|
len = scp->cmd_len;
|
|
|
|
sb = (int)sizeof(b);
|
|
|
|
if (len > 32)
|
|
|
|
strcpy(b, "too long, over 32 bytes");
|
|
|
|
else {
|
|
|
|
for (k = 0, n = 0; k < len && n < sb; ++k)
|
|
|
|
n += scnprintf(b + n, sb - n, "%02x ",
|
|
|
|
(u32)cmd[k]);
|
|
|
|
}
|
2018-01-26 16:52:19 +00:00
|
|
|
sdev_printk(KERN_INFO, sdp, "%s: tag=%#x, cmd %s\n", my_name,
|
|
|
|
blk_mq_unique_tag(scp->request), b);
|
2014-11-25 01:46:29 +00:00
|
|
|
}
|
2017-12-07 22:56:18 +00:00
|
|
|
if (fake_host_busy(scp))
|
|
|
|
return SCSI_MLQUEUE_HOST_BUSY;
|
2015-07-28 13:54:21 +00:00
|
|
|
has_wlun_rl = (sdp->lun == SCSI_W_LUN_REPORT_LUNS);
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely((sdp->lun >= sdebug_max_luns) && !has_wlun_rl))
|
|
|
|
goto err_out;
|
2014-11-25 01:46:29 +00:00
|
|
|
|
|
|
|
sdeb_i = opcode_ind_arr[opcode]; /* fully mapped */
|
|
|
|
oip = &opcode_info_arr[sdeb_i]; /* safe if table consistent */
|
|
|
|
devip = (struct sdebug_dev_info *)sdp->hostdata;
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(!devip)) {
|
|
|
|
devip = find_build_dev_info(sdp);
|
2014-11-25 01:46:29 +00:00
|
|
|
if (NULL == devip)
|
2016-04-25 16:16:34 +00:00
|
|
|
goto err_out;
|
2014-11-25 01:46:29 +00:00
|
|
|
}
|
|
|
|
na = oip->num_attached;
|
|
|
|
r_pfp = oip->pfp;
|
|
|
|
if (na) { /* multiple commands with this opcode */
|
|
|
|
r_oip = oip;
|
|
|
|
if (FF_SA & r_oip->flags) {
|
|
|
|
if (F_SA_LOW & oip->flags)
|
|
|
|
sa = 0x1f & cmd[1];
|
|
|
|
else
|
|
|
|
sa = get_unaligned_be16(cmd + 8);
|
|
|
|
for (k = 0; k <= na; oip = r_oip->arrp + k++) {
|
|
|
|
if (opcode == oip->opcode && sa == oip->sa)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else { /* since no service action only check opcode */
|
|
|
|
for (k = 0; k <= na; oip = r_oip->arrp + k++) {
|
|
|
|
if (opcode == oip->opcode)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (k > na) {
|
|
|
|
if (F_SA_LOW & r_oip->flags)
|
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 1, 4);
|
|
|
|
else if (F_SA_HIGH & r_oip->flags)
|
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, 8, 7);
|
|
|
|
else
|
|
|
|
mk_sense_invalid_opcode(scp);
|
|
|
|
goto check_cond;
|
|
|
|
}
|
|
|
|
} /* else (when na==0) we assume the oip is a match */
|
|
|
|
flags = oip->flags;
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(F_INV_OP & flags)) {
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_invalid_opcode(scp);
|
|
|
|
goto check_cond;
|
|
|
|
}
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(has_wlun_rl && !(F_RL_WLUN_OK & flags))) {
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
|
|
|
sdev_printk(KERN_INFO, sdp, "%s: Opcode 0x%x not%s\n",
|
|
|
|
my_name, opcode, " supported for wlun");
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_invalid_opcode(scp);
|
|
|
|
goto check_cond;
|
|
|
|
}
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(sdebug_strict)) { /* check cdb against mask */
|
2014-11-25 01:46:29 +00:00
|
|
|
u8 rem;
|
|
|
|
int j;
|
|
|
|
|
|
|
|
for (k = 1; k < oip->len_mask[0] && k < 16; ++k) {
|
|
|
|
rem = ~oip->len_mask[k] & cmd[k];
|
|
|
|
if (rem) {
|
|
|
|
for (j = 7; j >= 0; --j, rem <<= 1) {
|
|
|
|
if (0x80 & rem)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mk_sense_invalid_fld(scp, SDEB_IN_CDB, k, j);
|
|
|
|
goto check_cond;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(!(F_SKIP_UA & flags) &&
|
2016-05-01 02:44:42 +00:00
|
|
|
find_first_bit(devip->uas_bm,
|
|
|
|
SDEBUG_NUM_UAS) != SDEBUG_NUM_UAS)) {
|
2016-04-25 16:16:34 +00:00
|
|
|
errsts = make_ua(scp, devip);
|
2014-11-25 01:46:29 +00:00
|
|
|
if (errsts)
|
|
|
|
goto check_cond;
|
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
if (unlikely((F_M_ACCESS & flags) && atomic_read(&devip->stopped))) {
|
2014-11-25 01:46:29 +00:00
|
|
|
mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x2);
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_verbose)
|
2014-11-25 01:46:29 +00:00
|
|
|
sdev_printk(KERN_INFO, sdp, "%s reports: Not ready: "
|
|
|
|
"%s\n", my_name, "initializing command "
|
|
|
|
"required");
|
|
|
|
errsts = check_condition_result;
|
|
|
|
goto fini;
|
|
|
|
}
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_fake_rw && (F_FAKE_RW & flags))
|
2014-11-25 01:46:29 +00:00
|
|
|
goto fini;
|
2016-04-25 16:16:34 +00:00
|
|
|
if (unlikely(sdebug_every_nth)) {
|
2016-05-06 04:40:26 +00:00
|
|
|
if (fake_timeout(scp))
|
2014-11-25 01:46:29 +00:00
|
|
|
return 0; /* ignore command: make trouble */
|
|
|
|
}
|
2016-04-25 16:16:34 +00:00
|
|
|
if (likely(oip->pfp))
|
2018-02-14 10:05:57 +00:00
|
|
|
pfp = oip->pfp; /* calls a resp_* function */
|
|
|
|
else
|
|
|
|
pfp = r_pfp; /* if leaf function ptr NULL, try the root's */
|
2014-11-25 01:46:29 +00:00
|
|
|
|
|
|
|
fini:
|
2018-01-10 21:57:31 +00:00
|
|
|
if (F_DELAY_OVERR & flags)
|
2018-02-14 10:05:57 +00:00
|
|
|
return schedule_resp(scp, devip, errsts, pfp, 0, 0);
|
2018-07-12 17:35:42 +00:00
|
|
|
else if ((flags & F_LONG_DELAY) && (sdebug_jdelay > 0 ||
|
|
|
|
sdebug_ndelay > 10000)) {
|
2018-02-10 02:36:39 +00:00
|
|
|
/*
|
2018-07-12 17:35:42 +00:00
|
|
|
* Skip long delays if ndelay <= 10 microseconds. Otherwise
|
|
|
|
* for Start Stop Unit (SSU) want at least 1 second delay and
|
|
|
|
* if sdebug_jdelay>1 want a long delay of that many seconds.
|
|
|
|
* For Synchronize Cache want 1/20 of SSU's delay.
|
2018-02-10 02:36:39 +00:00
|
|
|
*/
|
|
|
|
int jdelay = (sdebug_jdelay < 2) ? 1 : sdebug_jdelay;
|
2018-04-10 17:00:36 +00:00
|
|
|
int denom = (flags & F_SYNC_DELAY) ? 20 : 1;
|
2018-02-10 02:36:39 +00:00
|
|
|
|
2018-04-10 17:00:36 +00:00
|
|
|
jdelay = mult_frac(USER_HZ * jdelay, HZ, denom * USER_HZ);
|
2018-02-14 10:05:57 +00:00
|
|
|
return schedule_resp(scp, devip, errsts, pfp, jdelay, 0);
|
2018-02-10 02:36:39 +00:00
|
|
|
} else
|
2018-02-14 10:05:57 +00:00
|
|
|
return schedule_resp(scp, devip, errsts, pfp, sdebug_jdelay,
|
2018-01-10 21:57:31 +00:00
|
|
|
sdebug_ndelay);
|
2014-11-25 01:46:29 +00:00
|
|
|
check_cond:
|
2018-02-14 10:05:57 +00:00
|
|
|
return schedule_resp(scp, devip, check_condition_result, NULL, 0, 0);
|
2016-04-25 16:16:34 +00:00
|
|
|
err_out:
|
2018-02-14 10:05:57 +00:00
|
|
|
return schedule_resp(scp, NULL, DID_NO_CONNECT << 16, NULL, 0, 0);
|
2014-11-25 01:46:29 +00:00
|
|
|
}
|
|
|
|
|
2008-03-02 09:30:16 +00:00
|
|
|
static struct scsi_host_template sdebug_driver_template = {
|
2013-03-31 05:46:06 +00:00
|
|
|
.show_info = scsi_debug_show_info,
|
|
|
|
.write_info = scsi_debug_write_info,
|
2008-03-02 09:30:16 +00:00
|
|
|
.proc_name = sdebug_proc_name,
|
|
|
|
.name = "SCSI DEBUG",
|
|
|
|
.info = scsi_debug_info,
|
|
|
|
.slave_alloc = scsi_debug_slave_alloc,
|
|
|
|
.slave_configure = scsi_debug_slave_configure,
|
|
|
|
.slave_destroy = scsi_debug_slave_destroy,
|
|
|
|
.ioctl = scsi_debug_ioctl,
|
2016-04-25 16:16:29 +00:00
|
|
|
.queuecommand = scsi_debug_queuecommand,
|
2014-07-26 15:55:35 +00:00
|
|
|
.change_queue_depth = sdebug_change_qdepth,
|
2008-03-02 09:30:16 +00:00
|
|
|
.eh_abort_handler = scsi_debug_abort,
|
|
|
|
.eh_device_reset_handler = scsi_debug_device_reset,
|
2014-07-26 15:55:35 +00:00
|
|
|
.eh_target_reset_handler = scsi_debug_target_reset,
|
|
|
|
.eh_bus_reset_handler = scsi_debug_bus_reset,
|
2008-03-02 09:30:16 +00:00
|
|
|
.eh_host_reset_handler = scsi_debug_host_reset,
|
2016-05-06 04:40:26 +00:00
|
|
|
.can_queue = SDEBUG_CANQUEUE,
|
2008-03-02 09:30:16 +00:00
|
|
|
.this_id = 7,
|
2016-04-04 21:48:10 +00:00
|
|
|
.sg_tablesize = SG_MAX_SEGMENTS,
|
2014-07-26 15:55:35 +00:00
|
|
|
.cmd_per_lun = DEF_CMD_PER_LUN,
|
2014-06-02 13:56:49 +00:00
|
|
|
.max_sectors = -1U,
|
2018-12-13 15:17:03 +00:00
|
|
|
.max_segment_size = -1U,
|
2008-03-02 09:30:16 +00:00
|
|
|
.module = THIS_MODULE,
|
2014-11-13 13:25:11 +00:00
|
|
|
.track_queue_depth = 1,
|
2008-03-02 09:30:16 +00:00
|
|
|
};
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int sdebug_driver_probe(struct device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-11-25 04:04:47 +00:00
|
|
|
int error = 0;
|
|
|
|
struct sdebug_host_info *sdbg_host;
|
|
|
|
struct Scsi_Host *hpnt;
|
2016-04-25 16:16:34 +00:00
|
|
|
int hprot;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
sdbg_host = to_sdebug_host(dev);
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_driver_template.can_queue = sdebug_max_queue;
|
2018-12-13 15:17:02 +00:00
|
|
|
if (!sdebug_clustering)
|
2018-12-13 15:17:09 +00:00
|
|
|
sdebug_driver_template.dma_boundary = PAGE_SIZE - 1;
|
|
|
|
|
2010-03-25 21:29:05 +00:00
|
|
|
hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
|
|
|
|
if (NULL == hpnt) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("scsi_host_alloc failed\n");
|
2010-03-25 21:29:05 +00:00
|
|
|
error = -ENODEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
return error;
|
2010-03-25 21:29:05 +00:00
|
|
|
}
|
2016-05-06 04:40:26 +00:00
|
|
|
if (submit_queues > nr_cpu_ids) {
|
2017-09-08 23:14:18 +00:00
|
|
|
pr_warn("%s: trim submit_queues (was %d) to nr_cpu_ids=%u\n",
|
2016-05-06 04:40:26 +00:00
|
|
|
my_name, submit_queues, nr_cpu_ids);
|
|
|
|
submit_queues = nr_cpu_ids;
|
|
|
|
}
|
|
|
|
/* Decide whether to tell scsi subsystem that we want mq */
|
|
|
|
/* Following should give the same answer for each host */
|
2018-11-01 22:36:27 +00:00
|
|
|
hpnt->nr_hw_queues = submit_queues;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
sdbg_host->shost = hpnt;
|
2005-04-16 22:20:36 +00:00
|
|
|
*((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
|
2016-04-25 16:16:28 +00:00
|
|
|
if ((hpnt->this_id >= 0) && (sdebug_num_tgts > hpnt->this_id))
|
|
|
|
hpnt->max_id = sdebug_num_tgts + 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
2016-04-25 16:16:28 +00:00
|
|
|
hpnt->max_id = sdebug_num_tgts;
|
|
|
|
/* = sdebug_max_luns; */
|
2015-07-28 13:54:25 +00:00
|
|
|
hpnt->max_lun = SCSI_W_LUN_REPORT_LUNS + 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-04-25 16:16:34 +00:00
|
|
|
hprot = 0;
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
switch (sdebug_dif) {
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2016-09-11 17:35:41 +00:00
|
|
|
case T10_PI_TYPE1_PROTECTION:
|
2016-04-25 16:16:34 +00:00
|
|
|
hprot = SHOST_DIF_TYPE1_PROTECTION;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_dix)
|
2016-04-25 16:16:34 +00:00
|
|
|
hprot |= SHOST_DIX_TYPE1_PROTECTION;
|
2009-01-04 08:08:19 +00:00
|
|
|
break;
|
|
|
|
|
2016-09-11 17:35:41 +00:00
|
|
|
case T10_PI_TYPE2_PROTECTION:
|
2016-04-25 16:16:34 +00:00
|
|
|
hprot = SHOST_DIF_TYPE2_PROTECTION;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_dix)
|
2016-04-25 16:16:34 +00:00
|
|
|
hprot |= SHOST_DIX_TYPE2_PROTECTION;
|
2009-01-04 08:08:19 +00:00
|
|
|
break;
|
|
|
|
|
2016-09-11 17:35:41 +00:00
|
|
|
case T10_PI_TYPE3_PROTECTION:
|
2016-04-25 16:16:34 +00:00
|
|
|
hprot = SHOST_DIF_TYPE3_PROTECTION;
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_dix)
|
2016-04-25 16:16:34 +00:00
|
|
|
hprot |= SHOST_DIX_TYPE3_PROTECTION;
|
2009-01-04 08:08:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_dix)
|
2016-04-25 16:16:34 +00:00
|
|
|
hprot |= SHOST_DIX_TYPE0_PROTECTION;
|
2009-01-04 08:08:19 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-04-25 16:16:34 +00:00
|
|
|
scsi_host_set_prot(hpnt, hprot);
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2016-04-25 16:16:34 +00:00
|
|
|
if (have_dif_prot || sdebug_dix)
|
|
|
|
pr_info("host protection%s%s%s%s%s%s%s\n",
|
|
|
|
(hprot & SHOST_DIF_TYPE1_PROTECTION) ? " DIF1" : "",
|
|
|
|
(hprot & SHOST_DIF_TYPE2_PROTECTION) ? " DIF2" : "",
|
|
|
|
(hprot & SHOST_DIF_TYPE3_PROTECTION) ? " DIF3" : "",
|
|
|
|
(hprot & SHOST_DIX_TYPE0_PROTECTION) ? " DIX0" : "",
|
|
|
|
(hprot & SHOST_DIX_TYPE1_PROTECTION) ? " DIX1" : "",
|
|
|
|
(hprot & SHOST_DIX_TYPE2_PROTECTION) ? " DIX2" : "",
|
|
|
|
(hprot & SHOST_DIX_TYPE3_PROTECTION) ? " DIX3" : "");
|
2009-01-04 08:08:19 +00:00
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
if (sdebug_guard == 1)
|
2009-01-04 08:08:19 +00:00
|
|
|
scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_IP);
|
|
|
|
else
|
|
|
|
scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_CRC);
|
|
|
|
|
2016-04-25 16:16:28 +00:00
|
|
|
sdebug_verbose = !!(SDEBUG_OPT_NOISE & sdebug_opts);
|
|
|
|
sdebug_any_injecting_opt = !!(SDEBUG_OPT_ALL_INJECTING & sdebug_opts);
|
2016-05-06 04:40:26 +00:00
|
|
|
if (sdebug_every_nth) /* need stats counters for every_nth */
|
|
|
|
sdebug_statistics = true;
|
2017-12-23 17:48:10 +00:00
|
|
|
error = scsi_add_host(hpnt, &sdbg_host->dev);
|
|
|
|
if (error) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("scsi_add_host failed\n");
|
2017-12-23 17:48:10 +00:00
|
|
|
error = -ENODEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
scsi_host_put(hpnt);
|
2017-12-23 17:48:10 +00:00
|
|
|
} else
|
2005-04-16 22:20:36 +00:00
|
|
|
scsi_scan_host(hpnt);
|
|
|
|
|
2014-07-26 15:55:35 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2018-02-10 02:12:43 +00:00
|
|
|
static int sdebug_driver_remove(struct device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-12-23 17:48:10 +00:00
|
|
|
struct sdebug_host_info *sdbg_host;
|
2008-03-20 02:09:18 +00:00
|
|
|
struct sdebug_dev_info *sdbg_devinfo, *tmp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
sdbg_host = to_sdebug_host(dev);
|
|
|
|
|
|
|
|
if (!sdbg_host) {
|
2015-07-28 13:54:20 +00:00
|
|
|
pr_err("Unable to locate host info\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
scsi_remove_host(sdbg_host->shost);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-20 02:09:18 +00:00
|
|
|
list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
|
|
|
|
dev_list) {
|
2017-12-23 17:48:10 +00:00
|
|
|
list_del(&sdbg_devinfo->dev_list);
|
|
|
|
kfree(sdbg_devinfo);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-12-23 17:48:10 +00:00
|
|
|
scsi_host_put(sdbg_host->shost);
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-03-29 15:59:58 +00:00
|
|
|
static int pseudo_lld_bus_match(struct device *dev,
|
|
|
|
struct device_driver *dev_driver)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-03-29 15:59:58 +00:00
|
|
|
return 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-03-29 15:59:58 +00:00
|
|
|
|
|
|
|
static struct bus_type pseudo_lld_bus = {
|
|
|
|
.name = "pseudo",
|
|
|
|
.match = pseudo_lld_bus_match,
|
|
|
|
.probe = sdebug_driver_probe,
|
|
|
|
.remove = sdebug_driver_remove,
|
2013-10-14 13:48:04 +00:00
|
|
|
.drv_groups = sdebug_drv_groups,
|
2008-03-29 15:59:58 +00:00
|
|
|
};
|