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