scsi_debug.c 116.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
/*
 * vvvvvvvvvvvvvvvvvvvvvvv Original vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
 *  Copyright (C) 1992  Eric Youngdale
 *  Simulate a host adapter with 2 disks attached.  Do a lot of checking
 *  to make sure that we are not getting blocks mixed up, and PANIC if
 *  anything out of the ordinary is seen.
 * ^^^^^^^^^^^^^^^^^^^^^^^ Original ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 *
 *  This version is more generic, simulating a variable number of disk
D
Douglas Gilbert 已提交
10 11 12
 *  (or disk like devices) sharing a common amount of RAM. To be more
 *  realistic, the simulated devices have the transport attributes of
 *  SAS disks.
L
Linus Torvalds 已提交
13 14
 *
 *
15
 *  For documentation see http://sg.danny.cz/sg/sdebug26.html
L
Linus Torvalds 已提交
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
 *
 *   D. Gilbert (dpg) work for Magneto-Optical device test [20010421]
 *   dpg: work for devfs large number of disks [20010809]
 *        forked for lk 2.5 series [20011216, 20020101]
 *        use vmalloc() more inquiry+mode_sense [20020302]
 *        add timers for delayed responses [20020721]
 *   Patrick Mansfield <patmans@us.ibm.com> max_luns+scsi_level [20021031]
 *   Mike Anderson <andmike@us.ibm.com> sysfs work [20021118]
 *   dpg: change style of boot options to "scsi_debug.num_tgts=2" and
 *        module options to "modprobe scsi_debug num_tgts=2" [20021221]
 */

#include <linux/module.h>

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/timer.h>
33
#include <linux/slab.h>
L
Linus Torvalds 已提交
34 35 36 37 38 39 40 41
#include <linux/types.h>
#include <linux/string.h>
#include <linux/genhd.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/vmalloc.h>
#include <linux/moduleparam.h>
J
Jens Axboe 已提交
42
#include <linux/scatterlist.h>
L
Linus Torvalds 已提交
43
#include <linux/blkdev.h>
44 45 46
#include <linux/crc-t10dif.h>

#include <net/checksum.h>
47

48 49
#include <asm/unaligned.h>

50 51 52
#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
L
Linus Torvalds 已提交
53 54
#include <scsi/scsi_host.h>
#include <scsi/scsicam.h>
55
#include <scsi/scsi_eh.h>
56
#include <scsi/scsi_dbg.h>
L
Linus Torvalds 已提交
57

58
#include "sd.h"
L
Linus Torvalds 已提交
59 60
#include "scsi_logging.h"

61 62
#define SCSI_DEBUG_VERSION "1.82"
static const char * scsi_debug_version_date = "20100324";
L
Linus Torvalds 已提交
63

64
/* Additional Sense Code (ASC) */
D
Douglas Gilbert 已提交
65 66
#define NO_ADDITIONAL_SENSE 0x0
#define LOGICAL_UNIT_NOT_READY 0x4
67
#define LOGICAL_UNIT_COMMUNICATION_FAILURE 0x8
L
Linus Torvalds 已提交
68
#define UNRECOVERED_READ_ERR 0x11
D
Douglas Gilbert 已提交
69
#define PARAMETER_LIST_LENGTH_ERR 0x1a
L
Linus Torvalds 已提交
70 71
#define INVALID_OPCODE 0x20
#define ADDR_OUT_OF_RANGE 0x21
72
#define INVALID_COMMAND_OPCODE 0x20
L
Linus Torvalds 已提交
73
#define INVALID_FIELD_IN_CDB 0x24
D
Douglas Gilbert 已提交
74
#define INVALID_FIELD_IN_PARAM_LIST 0x26
L
Linus Torvalds 已提交
75 76
#define POWERON_RESET 0x29
#define SAVING_PARAMS_UNSUP 0x39
77
#define TRANSPORT_PROBLEM 0x4b
D
Douglas Gilbert 已提交
78 79
#define THRESHOLD_EXCEEDED 0x5d
#define LOW_POWER_COND_ON 0x5e
L
Linus Torvalds 已提交
80

81 82 83
/* Additional Sense Code Qualifier (ASCQ) */
#define ACK_NAK_TO 0x3

L
Linus Torvalds 已提交
84 85 86 87 88 89 90 91 92
#define SDEBUG_TAGGED_QUEUING 0 /* 0 | MSG_SIMPLE_TAG | MSG_ORDERED_TAG */

/* Default values for driver parameters */
#define DEF_NUM_HOST   1
#define DEF_NUM_TGTS   1
#define DEF_MAX_LUNS   1
/* With these defaults, this driver will make 1 host with 1 target
 * (id 0) containing 1 logical unit (lun 0). That is 1 device.
 */
93
#define DEF_ATO 1
L
Linus Torvalds 已提交
94 95
#define DEF_DELAY   1
#define DEF_DEV_SIZE_MB   8
96 97
#define DEF_DIF 0
#define DEF_DIX 0
L
Linus Torvalds 已提交
98
#define DEF_D_SENSE   0
99
#define DEF_EVERY_NTH   0
D
Douglas Gilbert 已提交
100
#define DEF_FAKE_RW	0
101
#define DEF_GUARD 0
102 103 104
#define DEF_LBPU 0
#define DEF_LBPWS 0
#define DEF_LBPWS10 0
105
#define DEF_LBPRZ 1
106
#define DEF_LOWEST_ALIGNED 0
107 108 109
#define DEF_NO_LUN_0   0
#define DEF_NUM_PARTS   0
#define DEF_OPTS   0
110
#define DEF_OPT_BLKS 64
111 112
#define DEF_PHYSBLK_EXP 0
#define DEF_PTYPE   0
113
#define DEF_REMOVABLE false
114 115 116 117
#define DEF_SCSI_LEVEL   5    /* INQUIRY, byte2 [5->SPC-3] */
#define DEF_SECTOR_SIZE 512
#define DEF_UNMAP_ALIGNMENT 0
#define DEF_UNMAP_GRANULARITY 1
118 119
#define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF
#define DEF_UNMAP_MAX_DESC 256
120 121 122
#define DEF_VIRTUAL_GB   0
#define DEF_VPD_USE_HOSTNO 1
#define DEF_WRITESAME_LENGTH 0xFFFF
L
Linus Torvalds 已提交
123 124 125 126 127 128

/* bit mask values for scsi_debug_opts */
#define SCSI_DEBUG_OPT_NOISE   1
#define SCSI_DEBUG_OPT_MEDIUM_ERR   2
#define SCSI_DEBUG_OPT_TIMEOUT   4
#define SCSI_DEBUG_OPT_RECOVERED_ERR   8
129
#define SCSI_DEBUG_OPT_TRANSPORT_ERR   16
130 131
#define SCSI_DEBUG_OPT_DIF_ERR   32
#define SCSI_DEBUG_OPT_DIX_ERR   64
132
#define SCSI_DEBUG_OPT_MAC_TIMEOUT  128
133
#define SCSI_DEBUG_OPT_SHORT_TRANSFER	256
L
Linus Torvalds 已提交
134 135 136 137
/* When "every_nth" > 0 then modulo "every_nth" commands:
 *   - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
 *   - a RECOVERED_ERROR is simulated on successful read and write
 *     commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
138 139
 *   - a TRANSPORT_ERROR is simulated on successful read and write
 *     commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
L
Linus Torvalds 已提交
140 141 142 143 144
 *
 * When "every_nth" < 0 then after "- every_nth" commands:
 *   - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
 *   - a RECOVERED_ERROR is simulated on successful read and write
 *     commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
145 146
 *   - a TRANSPORT_ERROR is simulated on successful read and write
 *     commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
L
Linus Torvalds 已提交
147 148 149 150 151 152 153
 * This will continue until some other action occurs (e.g. the user
 * writing a new value (other than -1 or 1) to every_nth via sysfs).
 */

/* when 1==SCSI_DEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
 * sector on read commands: */
#define OPT_MEDIUM_ERR_ADDR   0x1234 /* that's sector 4660 in decimal */
154
#define OPT_MEDIUM_ERR_NUM    10     /* number of consecutive medium errs */
L
Linus Torvalds 已提交
155 156 157 158

/* If REPORT LUNS has luns >= 256 it can choose "flat space" (value 1)
 * or "peripheral device" addressing (value 0) */
#define SAM2_LUN_ADDRESS_METHOD 0
D
Douglas Gilbert 已提交
159
#define SAM2_WLUN_REPORT_LUNS 0xc101
L
Linus Torvalds 已提交
160

161 162 163 164
/* Can queue up to this number of commands. Typically commands that
 * that have a non-zero delay are queued. */
#define SCSI_DEBUG_CANQUEUE  255

L
Linus Torvalds 已提交
165
static int scsi_debug_add_host = DEF_NUM_HOST;
166
static int scsi_debug_ato = DEF_ATO;
L
Linus Torvalds 已提交
167 168
static int scsi_debug_delay = DEF_DELAY;
static int scsi_debug_dev_size_mb = DEF_DEV_SIZE_MB;
169 170 171
static int scsi_debug_dif = DEF_DIF;
static int scsi_debug_dix = DEF_DIX;
static int scsi_debug_dsense = DEF_D_SENSE;
L
Linus Torvalds 已提交
172
static int scsi_debug_every_nth = DEF_EVERY_NTH;
173
static int scsi_debug_fake_rw = DEF_FAKE_RW;
174
static unsigned int scsi_debug_guard = DEF_GUARD;
175
static int scsi_debug_lowest_aligned = DEF_LOWEST_ALIGNED;
L
Linus Torvalds 已提交
176
static int scsi_debug_max_luns = DEF_MAX_LUNS;
177
static int scsi_debug_max_queue = SCSI_DEBUG_CANQUEUE;
178
static int scsi_debug_no_lun_0 = DEF_NO_LUN_0;
179
static int scsi_debug_no_uld = 0;
180
static int scsi_debug_num_parts = DEF_NUM_PARTS;
L
Linus Torvalds 已提交
181
static int scsi_debug_num_tgts = DEF_NUM_TGTS; /* targets per host */
182
static int scsi_debug_opt_blks = DEF_OPT_BLKS;
L
Linus Torvalds 已提交
183
static int scsi_debug_opts = DEF_OPTS;
184
static int scsi_debug_physblk_exp = DEF_PHYSBLK_EXP;
L
Linus Torvalds 已提交
185
static int scsi_debug_ptype = DEF_PTYPE; /* SCSI peripheral type (0==disk) */
186 187
static int scsi_debug_scsi_level = DEF_SCSI_LEVEL;
static int scsi_debug_sector_size = DEF_SECTOR_SIZE;
D
Douglas Gilbert 已提交
188
static int scsi_debug_virtual_gb = DEF_VIRTUAL_GB;
D
Douglas Gilbert 已提交
189
static int scsi_debug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
190 191 192
static unsigned int scsi_debug_lbpu = DEF_LBPU;
static unsigned int scsi_debug_lbpws = DEF_LBPWS;
static unsigned int scsi_debug_lbpws10 = DEF_LBPWS10;
193
static unsigned int scsi_debug_lbprz = DEF_LBPRZ;
194
static unsigned int scsi_debug_unmap_alignment = DEF_UNMAP_ALIGNMENT;
195 196 197 198
static unsigned int scsi_debug_unmap_granularity = DEF_UNMAP_GRANULARITY;
static unsigned int scsi_debug_unmap_max_blocks = DEF_UNMAP_MAX_BLOCKS;
static unsigned int scsi_debug_unmap_max_desc = DEF_UNMAP_MAX_DESC;
static unsigned int scsi_debug_write_same_length = DEF_WRITESAME_LENGTH;
199
static bool scsi_debug_removable = DEF_REMOVABLE;
200
static bool scsi_debug_clustering;
L
Linus Torvalds 已提交
201 202 203 204 205

static int scsi_debug_cmnd_count = 0;

#define DEV_READONLY(TGT)      (0)

D
Douglas Gilbert 已提交
206
static unsigned int sdebug_store_sectors;
L
Linus Torvalds 已提交
207 208 209 210 211 212 213 214 215 216 217 218
static sector_t sdebug_capacity;	/* in sectors */

/* old BIOS stuff, kernel may get rid of them but some mode sense pages
   may still need them */
static int sdebug_heads;		/* heads per disk */
static int sdebug_cylinders_per;	/* cylinders per surface */
static int sdebug_sectors_per;		/* sectors per cylinder */

#define SDEBUG_MAX_PARTS 4

#define SDEBUG_SENSE_LEN 32

219
#define SCSI_DEBUG_MAX_CMD_LEN 32
220

221 222 223 224 225
static unsigned int scsi_debug_lbp(void)
{
	return scsi_debug_lbpu | scsi_debug_lbpws | scsi_debug_lbpws10;
}

L
Linus Torvalds 已提交
226 227 228 229 230 231 232
struct sdebug_dev_info {
	struct list_head dev_list;
	unsigned char sense_buff[SDEBUG_SENSE_LEN];	/* weak nexus */
	unsigned int channel;
	unsigned int target;
	unsigned int lun;
	struct sdebug_host_info *sdbg_host;
D
Douglas Gilbert 已提交
233
	unsigned int wlun;
L
Linus Torvalds 已提交
234
	char reset;
D
Douglas Gilbert 已提交
235
	char stopped;
L
Linus Torvalds 已提交
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
	char used;
};

struct sdebug_host_info {
	struct list_head host_list;
	struct Scsi_Host *shost;
	struct device dev;
	struct list_head dev_info_list;
};

#define to_sdebug_host(d)	\
	container_of(d, struct sdebug_host_info, dev)

static LIST_HEAD(sdebug_host_list);
static DEFINE_SPINLOCK(sdebug_host_list_lock);

typedef void (* done_funct_t) (struct scsi_cmnd *);

struct sdebug_queued_cmd {
	int in_use;
	struct timer_list cmnd_timer;
	done_funct_t done_funct;
	struct scsi_cmnd * a_cmnd;
	int scsi_result;
};
static struct sdebug_queued_cmd queued_arr[SCSI_DEBUG_CANQUEUE];

static unsigned char * fake_storep;	/* ramdisk storage */
264
static struct sd_dif_tuple *dif_storep;	/* protection info */
265
static void *map_storep;		/* provisioning map */
L
Linus Torvalds 已提交
266

267
static unsigned long map_size;
L
Linus Torvalds 已提交
268 269 270 271
static int num_aborts = 0;
static int num_dev_resets = 0;
static int num_bus_resets = 0;
static int num_host_resets = 0;
272 273 274
static int dix_writes;
static int dix_reads;
static int dif_errors;
L
Linus Torvalds 已提交
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290

static DEFINE_SPINLOCK(queued_arr_lock);
static DEFINE_RWLOCK(atomic_rw);

static char sdebug_proc_name[] = "scsi_debug";

static struct bus_type pseudo_lld_bus;

static struct device_driver sdebug_driverfs_driver = {
	.name 		= sdebug_proc_name,
	.bus		= &pseudo_lld_bus,
};

static const int check_condition_result =
		(DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;

291 292 293
static const int illegal_condition_result =
	(DRIVER_SENSE << 24) | (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION;

D
Douglas Gilbert 已提交
294 295 296 297 298
static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
				    0, 0, 0x2, 0x4b};
static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
			           0, 0, 0x0, 0x0};

299 300 301 302 303 304 305 306 307 308 309 310 311 312
static void *fake_store(unsigned long long lba)
{
	lba = do_div(lba, sdebug_store_sectors);

	return fake_storep + lba * scsi_debug_sector_size;
}

static struct sd_dif_tuple *dif_store(sector_t sector)
{
	sector = do_div(sector, sdebug_store_sectors);

	return dif_storep + sector;
}

L
Linus Torvalds 已提交
313 314 315
static int sdebug_add_adapter(void);
static void sdebug_remove_adapter(void);

316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
static void sdebug_max_tgts_luns(void)
{
	struct sdebug_host_info *sdbg_host;
	struct Scsi_Host *hpnt;

	spin_lock(&sdebug_host_list_lock);
	list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
		hpnt = sdbg_host->shost;
		if ((hpnt->this_id >= 0) &&
		    (scsi_debug_num_tgts > hpnt->this_id))
			hpnt->max_id = scsi_debug_num_tgts + 1;
		else
			hpnt->max_id = scsi_debug_num_tgts;
		/* scsi_debug_max_luns; */
		hpnt->max_lun = SAM2_WLUN_REPORT_LUNS;
	}
	spin_unlock(&sdebug_host_list_lock);
}

static void mk_sense_buffer(struct sdebug_dev_info *devip, int key,
			    int asc, int asq)
{
	unsigned char *sbuff;

	sbuff = devip->sense_buff;
	memset(sbuff, 0, SDEBUG_SENSE_LEN);

	scsi_build_sense_buffer(scsi_debug_dsense, sbuff, key, asc, asq);

	if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
		printk(KERN_INFO "scsi_debug:    [sense_key,asc,ascq]: "
		      "[0x%x,0x%x,0x%x]\n", key, asc, asq);
}
L
Linus Torvalds 已提交
349

350
static void get_data_transfer_info(unsigned char *cmd,
351 352
				   unsigned long long *lba, unsigned int *num,
				   u32 *ei_lba)
353
{
354 355
	*ei_lba = 0;

356
	switch (*cmd) {
357 358 359 360 361 362 363 364 365 366 367 368 369
	case VARIABLE_LENGTH_CMD:
		*lba = (u64)cmd[19] | (u64)cmd[18] << 8 |
			(u64)cmd[17] << 16 | (u64)cmd[16] << 24 |
			(u64)cmd[15] << 32 | (u64)cmd[14] << 40 |
			(u64)cmd[13] << 48 | (u64)cmd[12] << 56;

		*ei_lba = (u32)cmd[23] | (u32)cmd[22] << 8 |
			(u32)cmd[21] << 16 | (u32)cmd[20] << 24;

		*num = (u32)cmd[31] | (u32)cmd[30] << 8 | (u32)cmd[29] << 16 |
			(u32)cmd[28] << 24;
		break;

370
	case WRITE_SAME_16:
371 372
	case WRITE_16:
	case READ_16:
373 374 375 376 377 378 379
		*lba = (u64)cmd[9] | (u64)cmd[8] << 8 |
			(u64)cmd[7] << 16 | (u64)cmd[6] << 24 |
			(u64)cmd[5] << 32 | (u64)cmd[4] << 40 |
			(u64)cmd[3] << 48 | (u64)cmd[2] << 56;

		*num = (u32)cmd[13] | (u32)cmd[12] << 8 | (u32)cmd[11] << 16 |
			(u32)cmd[10] << 24;
380 381 382
		break;
	case WRITE_12:
	case READ_12:
383 384 385 386 387
		*lba = (u32)cmd[5] | (u32)cmd[4] << 8 | (u32)cmd[3] << 16 |
			(u32)cmd[2] << 24;

		*num = (u32)cmd[9] | (u32)cmd[8] << 8 | (u32)cmd[7] << 16 |
			(u32)cmd[6] << 24;
388
		break;
389
	case WRITE_SAME:
390 391
	case WRITE_10:
	case READ_10:
392
	case XDWRITEREAD_10:
393 394 395 396
		*lba = (u32)cmd[5] | (u32)cmd[4] << 8 |	(u32)cmd[3] << 16 |
			(u32)cmd[2] << 24;

		*num = (u32)cmd[8] | (u32)cmd[7] << 8;
397 398 399
		break;
	case WRITE_6:
	case READ_6:
400 401
		*lba = (u32)cmd[3] | (u32)cmd[2] << 8 |
			(u32)(cmd[1] & 0x1f) << 16;
402 403 404 405 406 407
		*num = (0 == cmd[4]) ? 256 : cmd[4];
		break;
	default:
		break;
	}
}
L
Linus Torvalds 已提交
408 409 410 411 412 413 414 415 416 417

static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
{
	if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
		printk(KERN_INFO "scsi_debug: ioctl: cmd=0x%x\n", cmd);
	}
	return -EINVAL;
	/* return -ENOTTY; // correct return but upsets fdisk */
}

D
Douglas Gilbert 已提交
418 419
static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
			   struct sdebug_dev_info * devip)
L
Linus Torvalds 已提交
420 421 422 423 424 425 426 427 428
{
	if (devip->reset) {
		if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
			printk(KERN_INFO "scsi_debug: Reporting Unit "
			       "attention: power on reset\n");
		devip->reset = 0;
		mk_sense_buffer(devip, UNIT_ATTENTION, POWERON_RESET, 0);
		return check_condition_result;
	}
D
Douglas Gilbert 已提交
429 430 431 432 433 434 435 436
	if ((0 == reset_only) && devip->stopped) {
		if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
			printk(KERN_INFO "scsi_debug: Reporting Not "
			       "ready: initializing command required\n");
		mk_sense_buffer(devip, NOT_READY, LOGICAL_UNIT_NOT_READY,
				0x2);
		return check_condition_result;
	}
L
Linus Torvalds 已提交
437 438 439 440
	return 0;
}

/* Returns 0 if ok else (DID_ERROR << 16). Sets scp->resid . */
441
static int fill_from_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
L
Linus Torvalds 已提交
442 443
				int arr_len)
{
444
	int act_len;
445
	struct scsi_data_buffer *sdb = scsi_in(scp);
L
Linus Torvalds 已提交
446

447
	if (!sdb->length)
L
Linus Torvalds 已提交
448
		return 0;
449
	if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE))
L
Linus Torvalds 已提交
450
		return (DID_ERROR << 16);
451 452 453

	act_len = sg_copy_from_buffer(sdb->table.sgl, sdb->table.nents,
				      arr, arr_len);
454
	sdb->resid = scsi_bufflen(scp) - act_len;
455

L
Linus Torvalds 已提交
456 457 458 459
	return 0;
}

/* Returns number of bytes fetched into 'arr' or -1 if error. */
460 461
static int fetch_to_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr,
			       int arr_len)
L
Linus Torvalds 已提交
462
{
463
	if (!scsi_bufflen(scp))
L
Linus Torvalds 已提交
464
		return 0;
465
	if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_TO_DEVICE))
L
Linus Torvalds 已提交
466
		return -1;
467 468

	return scsi_sg_copy_to_buffer(scp, arr, arr_len);
L
Linus Torvalds 已提交
469 470 471 472 473 474 475
}


static const char * inq_vendor_id = "Linux   ";
static const char * inq_product_id = "scsi_debug      ";
static const char * inq_product_rev = "0004";

476 477 478
static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
			   int target_dev_id, int dev_id_num,
			   const char * dev_id_str,
D
Douglas Gilbert 已提交
479
			   int dev_id_str_len)
L
Linus Torvalds 已提交
480
{
D
Douglas Gilbert 已提交
481 482
	int num, port_a;
	char b[32];
L
Linus Torvalds 已提交
483

D
Douglas Gilbert 已提交
484
	port_a = target_dev_id + 1;
L
Linus Torvalds 已提交
485 486 487 488 489 490 491 492 493 494
	/* T10 vendor identifier field format (faked) */
	arr[0] = 0x2;	/* ASCII */
	arr[1] = 0x1;
	arr[2] = 0x0;
	memcpy(&arr[4], inq_vendor_id, 8);
	memcpy(&arr[12], inq_product_id, 16);
	memcpy(&arr[28], dev_id_str, dev_id_str_len);
	num = 8 + 16 + dev_id_str_len;
	arr[3] = num;
	num += 4;
D
Douglas Gilbert 已提交
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
	if (dev_id_num >= 0) {
		/* NAA-5, Logical unit identifier (binary) */
		arr[num++] = 0x1;	/* binary (not necessarily sas) */
		arr[num++] = 0x3;	/* PIV=0, lu, naa */
		arr[num++] = 0x0;
		arr[num++] = 0x8;
		arr[num++] = 0x53;  /* naa-5 ieee company id=0x333333 (fake) */
		arr[num++] = 0x33;
		arr[num++] = 0x33;
		arr[num++] = 0x30;
		arr[num++] = (dev_id_num >> 24);
		arr[num++] = (dev_id_num >> 16) & 0xff;
		arr[num++] = (dev_id_num >> 8) & 0xff;
		arr[num++] = dev_id_num & 0xff;
		/* Target relative port number */
		arr[num++] = 0x61;	/* proto=sas, binary */
		arr[num++] = 0x94;	/* PIV=1, target port, rel port */
		arr[num++] = 0x0;	/* reserved */
		arr[num++] = 0x4;	/* length */
		arr[num++] = 0x0;	/* reserved */
		arr[num++] = 0x0;	/* reserved */
		arr[num++] = 0x0;
		arr[num++] = 0x1;	/* relative port A */
	}
	/* NAA-5, Target port identifier */
	arr[num++] = 0x61;	/* proto=sas, binary */
	arr[num++] = 0x93;	/* piv=1, target port, naa */
	arr[num++] = 0x0;
	arr[num++] = 0x8;
	arr[num++] = 0x52;	/* naa-5, company id=0x222222 (fake) */
	arr[num++] = 0x22;
	arr[num++] = 0x22;
	arr[num++] = 0x20;
	arr[num++] = (port_a >> 24);
	arr[num++] = (port_a >> 16) & 0xff;
	arr[num++] = (port_a >> 8) & 0xff;
	arr[num++] = port_a & 0xff;
532 533 534 535 536 537 538 539 540
	/* NAA-5, Target port group identifier */
	arr[num++] = 0x61;	/* proto=sas, binary */
	arr[num++] = 0x95;	/* piv=1, target port group id */
	arr[num++] = 0x0;
	arr[num++] = 0x4;
	arr[num++] = 0;
	arr[num++] = 0;
	arr[num++] = (port_group_id >> 8) & 0xff;
	arr[num++] = port_group_id & 0xff;
D
Douglas Gilbert 已提交
541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
	/* NAA-5, Target device identifier */
	arr[num++] = 0x61;	/* proto=sas, binary */
	arr[num++] = 0xa3;	/* piv=1, target device, naa */
	arr[num++] = 0x0;
	arr[num++] = 0x8;
	arr[num++] = 0x52;	/* naa-5, company id=0x222222 (fake) */
	arr[num++] = 0x22;
	arr[num++] = 0x22;
	arr[num++] = 0x20;
	arr[num++] = (target_dev_id >> 24);
	arr[num++] = (target_dev_id >> 16) & 0xff;
	arr[num++] = (target_dev_id >> 8) & 0xff;
	arr[num++] = target_dev_id & 0xff;
	/* SCSI name string: Target device identifier */
	arr[num++] = 0x63;	/* proto=sas, UTF-8 */
	arr[num++] = 0xa8;	/* piv=1, target device, SCSI name string */
	arr[num++] = 0x0;
	arr[num++] = 24;
	memcpy(arr + num, "naa.52222220", 12);
	num += 12;
	snprintf(b, sizeof(b), "%08X", target_dev_id);
	memcpy(arr + num, b, 8);
	num += 8;
	memset(arr + num, 0, 4);
	num += 4;
	return num;
}


static unsigned char vpd84_data[] = {
/* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
    0x22,0x22,0x22,0x0,0xbb,0x1,
    0x22,0x22,0x22,0x0,0xbb,0x2,
};

static int inquiry_evpd_84(unsigned char * arr)
{
	memcpy(arr, vpd84_data, sizeof(vpd84_data));
	return sizeof(vpd84_data);
}

static int inquiry_evpd_85(unsigned char * arr)
{
	int num = 0;
	const char * na1 = "https://www.kernel.org/config";
	const char * na2 = "http://www.kernel.org/log";
	int plen, olen;

	arr[num++] = 0x1;	/* lu, storage config */
	arr[num++] = 0x0;	/* reserved */
	arr[num++] = 0x0;
	olen = strlen(na1);
	plen = olen + 1;
	if (plen % 4)
		plen = ((plen / 4) + 1) * 4;
	arr[num++] = plen;	/* length, null termianted, padded */
	memcpy(arr + num, na1, olen);
	memset(arr + num + olen, 0, plen - olen);
	num += plen;

	arr[num++] = 0x4;	/* lu, logging */
	arr[num++] = 0x0;	/* reserved */
	arr[num++] = 0x0;
	olen = strlen(na2);
	plen = olen + 1;
	if (plen % 4)
		plen = ((plen / 4) + 1) * 4;
	arr[num++] = plen;	/* length, null terminated, padded */
	memcpy(arr + num, na2, olen);
	memset(arr + num + olen, 0, plen - olen);
	num += plen;

	return num;
}

/* SCSI ports VPD page */
static int inquiry_evpd_88(unsigned char * arr, int target_dev_id)
{
	int num = 0;
	int port_a, port_b;

	port_a = target_dev_id + 1;
	port_b = port_a + 1;
	arr[num++] = 0x0;	/* reserved */
	arr[num++] = 0x0;	/* reserved */
	arr[num++] = 0x0;
	arr[num++] = 0x1;	/* relative port 1 (primary) */
	memset(arr + num, 0, 6);
	num += 6;
	arr[num++] = 0x0;
	arr[num++] = 12;	/* length tp descriptor */
	/* naa-5 target port identifier (A) */
	arr[num++] = 0x61;	/* proto=sas, binary */
	arr[num++] = 0x93;	/* PIV=1, target port, NAA */
	arr[num++] = 0x0;	/* reserved */
	arr[num++] = 0x8;	/* length */
	arr[num++] = 0x52;	/* NAA-5, company_id=0x222222 (fake) */
	arr[num++] = 0x22;
	arr[num++] = 0x22;
	arr[num++] = 0x20;
	arr[num++] = (port_a >> 24);
	arr[num++] = (port_a >> 16) & 0xff;
	arr[num++] = (port_a >> 8) & 0xff;
	arr[num++] = port_a & 0xff;

	arr[num++] = 0x0;	/* reserved */
	arr[num++] = 0x0;	/* reserved */
	arr[num++] = 0x0;
	arr[num++] = 0x2;	/* relative port 2 (secondary) */
	memset(arr + num, 0, 6);
	num += 6;
	arr[num++] = 0x0;
	arr[num++] = 12;	/* length tp descriptor */
	/* naa-5 target port identifier (B) */
	arr[num++] = 0x61;	/* proto=sas, binary */
	arr[num++] = 0x93;	/* PIV=1, target port, NAA */
	arr[num++] = 0x0;	/* reserved */
	arr[num++] = 0x8;	/* length */
	arr[num++] = 0x52;	/* NAA-5, company_id=0x222222 (fake) */
	arr[num++] = 0x22;
	arr[num++] = 0x22;
	arr[num++] = 0x20;
	arr[num++] = (port_b >> 24);
	arr[num++] = (port_b >> 16) & 0xff;
	arr[num++] = (port_b >> 8) & 0xff;
	arr[num++] = port_b & 0xff;

	return num;
}


static unsigned char vpd89_data[] = {
/* from 4th byte */ 0,0,0,0,
'l','i','n','u','x',' ',' ',' ',
'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
'1','2','3','4',
0x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
0xec,0,0,0,
0x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
0,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
0x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
0x53,0x41,
0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
0x20,0x20,
0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
0x10,0x80,
0,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
0x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
0x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
0x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
0x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
0,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
0,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
0xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
0,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
};

static int inquiry_evpd_89(unsigned char * arr)
{
	memcpy(arr, vpd89_data, sizeof(vpd89_data));
	return sizeof(vpd89_data);
}


723
/* Block limits VPD page (SBC-3) */
D
Douglas Gilbert 已提交
724
static unsigned char vpdb0_data[] = {
725 726 727 728
	/* from 4th byte */ 0,0,0,4, 0,0,0x4,0, 0,0,0,64,
	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
D
Douglas Gilbert 已提交
729 730 731 732
};

static int inquiry_evpd_b0(unsigned char * arr)
{
733 734
	unsigned int gran;

D
Douglas Gilbert 已提交
735
	memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
736 737

	/* Optimal transfer length granularity */
738 739 740
	gran = 1 << scsi_debug_physblk_exp;
	arr[2] = (gran >> 8) & 0xff;
	arr[3] = gran & 0xff;
741 742

	/* Maximum Transfer Length */
D
Douglas Gilbert 已提交
743 744 745 746 747 748
	if (sdebug_store_sectors > 0x400) {
		arr[4] = (sdebug_store_sectors >> 24) & 0xff;
		arr[5] = (sdebug_store_sectors >> 16) & 0xff;
		arr[6] = (sdebug_store_sectors >> 8) & 0xff;
		arr[7] = sdebug_store_sectors & 0xff;
	}
749

750 751 752
	/* Optimal Transfer Length */
	put_unaligned_be32(scsi_debug_opt_blks, &arr[8]);

753
	if (scsi_debug_lbpu) {
754
		/* Maximum Unmap LBA Count */
755
		put_unaligned_be32(scsi_debug_unmap_max_blocks, &arr[16]);
756 757

		/* Maximum Unmap Block Descriptor Count */
758 759 760
		put_unaligned_be32(scsi_debug_unmap_max_desc, &arr[20]);
	}

761
	/* Unmap Granularity Alignment */
762 763 764 765 766
	if (scsi_debug_unmap_alignment) {
		put_unaligned_be32(scsi_debug_unmap_alignment, &arr[28]);
		arr[28] |= 0x80; /* UGAVALID */
	}

767
	/* Optimal Unmap Granularity */
768 769
	put_unaligned_be32(scsi_debug_unmap_granularity, &arr[24]);

770 771 772 773
	/* Maximum WRITE SAME Length */
	put_unaligned_be64(scsi_debug_write_same_length, &arr[32]);

	return 0x3c; /* Mandatory page length for Logical Block Provisioning */
774

D
Douglas Gilbert 已提交
775
	return sizeof(vpdb0_data);
L
Linus Torvalds 已提交
776 777
}

778
/* Block device characteristics VPD page (SBC-3) */
779 780 781 782
static int inquiry_evpd_b1(unsigned char *arr)
{
	memset(arr, 0, 0x3c);
	arr[0] = 0;
783 784 785
	arr[1] = 1;	/* non rotating medium (e.g. solid state) */
	arr[2] = 0;
	arr[3] = 5;	/* less than 1.8" */
786 787 788

	return 0x3c;
}
L
Linus Torvalds 已提交
789

790
/* Logical block provisioning VPD page (SBC-3) */
791 792
static int inquiry_evpd_b2(unsigned char *arr)
{
793
	memset(arr, 0, 0x4);
794 795
	arr[0] = 0;			/* threshold exponent */

796
	if (scsi_debug_lbpu)
797 798
		arr[1] = 1 << 7;

799
	if (scsi_debug_lbpws)
800 801
		arr[1] |= 1 << 6;

802 803 804
	if (scsi_debug_lbpws10)
		arr[1] |= 1 << 5;

805 806 807
	if (scsi_debug_lbprz)
		arr[1] |= 1 << 2;

808
	return 0x4;
809 810
}

L
Linus Torvalds 已提交
811
#define SDEBUG_LONG_INQ_SZ 96
D
Douglas Gilbert 已提交
812
#define SDEBUG_MAX_INQ_ARR_SZ 584
L
Linus Torvalds 已提交
813 814 815 816 817

static int resp_inquiry(struct scsi_cmnd * scp, int target,
			struct sdebug_dev_info * devip)
{
	unsigned char pq_pdt;
818
	unsigned char * arr;
L
Linus Torvalds 已提交
819
	unsigned char *cmd = (unsigned char *)scp->cmnd;
820
	int alloc_len, n, ret;
L
Linus Torvalds 已提交
821 822

	alloc_len = (cmd[3] << 8) + cmd[4];
823 824 825
	arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
	if (! arr)
		return DID_REQUEUE << 16;
D
Douglas Gilbert 已提交
826 827 828 829 830 831
	if (devip->wlun)
		pq_pdt = 0x1e;	/* present, wlun */
	else if (scsi_debug_no_lun_0 && (0 == devip->lun))
		pq_pdt = 0x7f;	/* not present, no device type */
	else
		pq_pdt = (scsi_debug_ptype & 0x1f);
L
Linus Torvalds 已提交
832 833 834 835
	arr[0] = pq_pdt;
	if (0x2 & cmd[1]) {  /* CMDDT bit set */
		mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
			       	0);
836
		kfree(arr);
L
Linus Torvalds 已提交
837 838
		return check_condition_result;
	} else if (0x1 & cmd[1]) {  /* EVPD bit set */
839
		int lu_id_num, port_group_id, target_dev_id, len;
D
Douglas Gilbert 已提交
840 841
		char lu_id_str[6];
		int host_no = devip->sdbg_host->shost->host_no;
L
Linus Torvalds 已提交
842
		
843 844
		port_group_id = (((host_no + 1) & 0x7f) << 8) +
		    (devip->channel & 0x7f);
D
Douglas Gilbert 已提交
845 846
		if (0 == scsi_debug_vpd_use_hostno)
			host_no = 0;
D
Douglas Gilbert 已提交
847 848 849 850 851
		lu_id_num = devip->wlun ? -1 : (((host_no + 1) * 2000) +
			    (devip->target * 1000) + devip->lun);
		target_dev_id = ((host_no + 1) * 2000) +
				 (devip->target * 1000) - 3;
		len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
L
Linus Torvalds 已提交
852
		if (0 == cmd[2]) { /* supported vital product data pages */
D
Douglas Gilbert 已提交
853 854 855 856 857 858 859 860 861 862 863 864
			arr[1] = cmd[2];	/*sanity */
			n = 4;
			arr[n++] = 0x0;   /* this page */
			arr[n++] = 0x80;  /* unit serial number */
			arr[n++] = 0x83;  /* device identification */
			arr[n++] = 0x84;  /* software interface ident. */
			arr[n++] = 0x85;  /* management network addresses */
			arr[n++] = 0x86;  /* extended inquiry */
			arr[n++] = 0x87;  /* mode page policy */
			arr[n++] = 0x88;  /* SCSI ports */
			arr[n++] = 0x89;  /* ATA information */
			arr[n++] = 0xb0;  /* Block limits (SBC) */
865
			arr[n++] = 0xb1;  /* Block characteristics (SBC) */
866 867
			if (scsi_debug_lbp()) /* Logical Block Prov. (SBC) */
				arr[n++] = 0xb2;
D
Douglas Gilbert 已提交
868
			arr[3] = n - 4;	  /* number of supported VPD pages */
L
Linus Torvalds 已提交
869
		} else if (0x80 == cmd[2]) { /* unit serial number */
D
Douglas Gilbert 已提交
870
			arr[1] = cmd[2];	/*sanity */
L
Linus Torvalds 已提交
871
			arr[3] = len;
D
Douglas Gilbert 已提交
872
			memcpy(&arr[4], lu_id_str, len);
L
Linus Torvalds 已提交
873
		} else if (0x83 == cmd[2]) { /* device identification */
D
Douglas Gilbert 已提交
874
			arr[1] = cmd[2];	/*sanity */
875 876 877
			arr[3] = inquiry_evpd_83(&arr[4], port_group_id,
						 target_dev_id, lu_id_num,
						 lu_id_str, len);
D
Douglas Gilbert 已提交
878 879 880 881 882 883 884 885 886
		} else if (0x84 == cmd[2]) { /* Software interface ident. */
			arr[1] = cmd[2];	/*sanity */
			arr[3] = inquiry_evpd_84(&arr[4]);
		} else if (0x85 == cmd[2]) { /* Management network addresses */
			arr[1] = cmd[2];	/*sanity */
			arr[3] = inquiry_evpd_85(&arr[4]);
		} else if (0x86 == cmd[2]) { /* extended inquiry */
			arr[1] = cmd[2];	/*sanity */
			arr[3] = 0x3c;	/* number of following entries */
887 888 889 890 891 892
			if (scsi_debug_dif == SD_DIF_TYPE3_PROTECTION)
				arr[4] = 0x4;	/* SPT: GRD_CHK:1 */
			else if (scsi_debug_dif)
				arr[4] = 0x5;   /* SPT: GRD_CHK:1, REF_CHK:1 */
			else
				arr[4] = 0x0;   /* no protection stuff */
D
Douglas Gilbert 已提交
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
			arr[5] = 0x7;   /* head of q, ordered + simple q's */
		} else if (0x87 == cmd[2]) { /* mode page policy */
			arr[1] = cmd[2];	/*sanity */
			arr[3] = 0x8;	/* number of following entries */
			arr[4] = 0x2;	/* disconnect-reconnect mp */
			arr[6] = 0x80;	/* mlus, shared */
			arr[8] = 0x18;	 /* protocol specific lu */
			arr[10] = 0x82;	 /* mlus, per initiator port */
		} else if (0x88 == cmd[2]) { /* SCSI Ports */
			arr[1] = cmd[2];	/*sanity */
			arr[3] = inquiry_evpd_88(&arr[4], target_dev_id);
		} else if (0x89 == cmd[2]) { /* ATA information */
			arr[1] = cmd[2];        /*sanity */
			n = inquiry_evpd_89(&arr[4]);
			arr[2] = (n >> 8);
			arr[3] = (n & 0xff);
		} else if (0xb0 == cmd[2]) { /* Block limits (SBC) */
			arr[1] = cmd[2];        /*sanity */
			arr[3] = inquiry_evpd_b0(&arr[4]);
912 913 914
		} else if (0xb1 == cmd[2]) { /* Block characteristics (SBC) */
			arr[1] = cmd[2];        /*sanity */
			arr[3] = inquiry_evpd_b1(&arr[4]);
915
		} else if (0xb2 == cmd[2]) { /* Logical Block Prov. (SBC) */
916 917
			arr[1] = cmd[2];        /*sanity */
			arr[3] = inquiry_evpd_b2(&arr[4]);
L
Linus Torvalds 已提交
918 919 920 921
		} else {
			/* Illegal request, invalid field in cdb */
			mk_sense_buffer(devip, ILLEGAL_REQUEST,
					INVALID_FIELD_IN_CDB, 0);
922
			kfree(arr);
L
Linus Torvalds 已提交
923 924
			return check_condition_result;
		}
D
Douglas Gilbert 已提交
925
		len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
926
		ret = fill_from_dev_buffer(scp, arr,
D
Douglas Gilbert 已提交
927
			    min(len, SDEBUG_MAX_INQ_ARR_SZ));
928 929
		kfree(arr);
		return ret;
L
Linus Torvalds 已提交
930 931
	}
	/* drops through here for a standard inquiry */
932
	arr[1] = scsi_debug_removable ? 0x80 : 0;	/* Removable disk */
L
Linus Torvalds 已提交
933 934 935
	arr[2] = scsi_debug_scsi_level;
	arr[3] = 2;    /* response_data_format==2 */
	arr[4] = SDEBUG_LONG_INQ_SZ - 5;
936
	arr[5] = scsi_debug_dif ? 1 : 0; /* PROTECT bit */
937 938
	if (0 == scsi_debug_vpd_use_hostno)
		arr[5] = 0x10; /* claim: implicit TGPS */
D
Douglas Gilbert 已提交
939
	arr[6] = 0x10; /* claim: MultiP */
L
Linus Torvalds 已提交
940
	/* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
D
Douglas Gilbert 已提交
941
	arr[7] = 0xa; /* claim: LINKED + CMDQUE */
L
Linus Torvalds 已提交
942 943 944 945
	memcpy(&arr[8], inq_vendor_id, 8);
	memcpy(&arr[16], inq_product_id, 16);
	memcpy(&arr[32], inq_product_rev, 4);
	/* version descriptors (2 bytes each) follow */
D
Douglas Gilbert 已提交
946 947 948
	arr[58] = 0x0; arr[59] = 0x77; /* SAM-3 ANSI */
	arr[60] = 0x3; arr[61] = 0x14;  /* SPC-3 ANSI */
	n = 62;
L
Linus Torvalds 已提交
949
	if (scsi_debug_ptype == 0) {
D
Douglas Gilbert 已提交
950
		arr[n++] = 0x3; arr[n++] = 0x3d; /* SBC-2 ANSI */
L
Linus Torvalds 已提交
951
	} else if (scsi_debug_ptype == 1) {
D
Douglas Gilbert 已提交
952
		arr[n++] = 0x3; arr[n++] = 0x60; /* SSC-2 no version */
L
Linus Torvalds 已提交
953
	}
D
Douglas Gilbert 已提交
954
	arr[n++] = 0xc; arr[n++] = 0xf;  /* SAS-1.1 rev 10 */
955
	ret = fill_from_dev_buffer(scp, arr,
L
Linus Torvalds 已提交
956
			    min(alloc_len, SDEBUG_LONG_INQ_SZ));
957 958
	kfree(arr);
	return ret;
L
Linus Torvalds 已提交
959 960 961 962 963 964 965 966
}

static int resp_requests(struct scsi_cmnd * scp,
			 struct sdebug_dev_info * devip)
{
	unsigned char * sbuff;
	unsigned char *cmd = (unsigned char *)scp->cmnd;
	unsigned char arr[SDEBUG_SENSE_LEN];
D
Douglas Gilbert 已提交
967
	int want_dsense;
L
Linus Torvalds 已提交
968 969
	int len = 18;

D
Douglas Gilbert 已提交
970
	memset(arr, 0, sizeof(arr));
L
Linus Torvalds 已提交
971
	if (devip->reset == 1)
D
Douglas Gilbert 已提交
972 973
		mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
	want_dsense = !!(cmd[1] & 1) || scsi_debug_dsense;
L
Linus Torvalds 已提交
974
	sbuff = devip->sense_buff;
D
Douglas Gilbert 已提交
975 976 977 978 979 980 981 982 983 984 985 986 987 988
	if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
		if (want_dsense) {
			arr[0] = 0x72;
			arr[1] = 0x0;		/* NO_SENSE in sense_key */
			arr[2] = THRESHOLD_EXCEEDED;
			arr[3] = 0xff;		/* TEST set and MRIE==6 */
		} else {
			arr[0] = 0x70;
			arr[2] = 0x0;		/* NO_SENSE in sense_key */
			arr[7] = 0xa;   	/* 18 byte sense buffer */
			arr[12] = THRESHOLD_EXCEEDED;
			arr[13] = 0xff;		/* TEST set and MRIE==6 */
		}
	} else {
L
Linus Torvalds 已提交
989
		memcpy(arr, sbuff, SDEBUG_SENSE_LEN);
D
Douglas Gilbert 已提交
990 991 992 993 994 995 996 997 998 999 1000
		if ((cmd[1] & 1) && (! scsi_debug_dsense)) {
			/* DESC bit set and sense_buff in fixed format */
			memset(arr, 0, sizeof(arr));
			arr[0] = 0x72;
			arr[1] = sbuff[2];     /* sense key */
			arr[2] = sbuff[12];    /* asc */
			arr[3] = sbuff[13];    /* ascq */
			len = 8;
		}
	}
	mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
L
Linus Torvalds 已提交
1001 1002 1003
	return fill_from_dev_buffer(scp, arr, len);
}

D
Douglas Gilbert 已提交
1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
static int resp_start_stop(struct scsi_cmnd * scp,
			   struct sdebug_dev_info * devip)
{
	unsigned char *cmd = (unsigned char *)scp->cmnd;
	int power_cond, errsts, start;

	if ((errsts = check_readiness(scp, 1, devip)))
		return errsts;
	power_cond = (cmd[4] & 0xf0) >> 4;
	if (power_cond) {
		mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
			       	0);
		return check_condition_result;
	}
	start = cmd[4] & 1;
	if (start == devip->stopped)
		devip->stopped = !start;
	return 0;
}

1024 1025 1026
static sector_t get_sdebug_capacity(void)
{
	if (scsi_debug_virtual_gb > 0)
1027 1028
		return (sector_t)scsi_debug_virtual_gb *
			(1073741824 / scsi_debug_sector_size);
1029 1030 1031 1032
	else
		return sdebug_store_sectors;
}

L
Linus Torvalds 已提交
1033 1034 1035 1036 1037
#define SDEBUG_READCAP_ARR_SZ 8
static int resp_readcap(struct scsi_cmnd * scp,
			struct sdebug_dev_info * devip)
{
	unsigned char arr[SDEBUG_READCAP_ARR_SZ];
D
Douglas Gilbert 已提交
1038
	unsigned int capac;
L
Linus Torvalds 已提交
1039 1040
	int errsts;

D
Douglas Gilbert 已提交
1041
	if ((errsts = check_readiness(scp, 1, devip)))
L
Linus Torvalds 已提交
1042
		return errsts;
D
Douglas Gilbert 已提交
1043
	/* following just in case virtual_gb changed */
1044
	sdebug_capacity = get_sdebug_capacity();
L
Linus Torvalds 已提交
1045
	memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
D
Douglas Gilbert 已提交
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
	if (sdebug_capacity < 0xffffffff) {
		capac = (unsigned int)sdebug_capacity - 1;
		arr[0] = (capac >> 24);
		arr[1] = (capac >> 16) & 0xff;
		arr[2] = (capac >> 8) & 0xff;
		arr[3] = capac & 0xff;
	} else {
		arr[0] = 0xff;
		arr[1] = 0xff;
		arr[2] = 0xff;
		arr[3] = 0xff;
	}
1058 1059
	arr[6] = (scsi_debug_sector_size >> 8) & 0xff;
	arr[7] = scsi_debug_sector_size & 0xff;
L
Linus Torvalds 已提交
1060 1061 1062
	return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
}

D
Douglas Gilbert 已提交
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
#define SDEBUG_READCAP16_ARR_SZ 32
static int resp_readcap16(struct scsi_cmnd * scp,
			  struct sdebug_dev_info * devip)
{
	unsigned char *cmd = (unsigned char *)scp->cmnd;
	unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
	unsigned long long capac;
	int errsts, k, alloc_len;

	if ((errsts = check_readiness(scp, 1, devip)))
		return errsts;
	alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8)
		     + cmd[13]);
	/* following just in case virtual_gb changed */
1077
	sdebug_capacity = get_sdebug_capacity();
D
Douglas Gilbert 已提交
1078 1079 1080 1081
	memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
	capac = sdebug_capacity - 1;
	for (k = 0; k < 8; ++k, capac >>= 8)
		arr[7 - k] = capac & 0xff;
1082 1083 1084 1085
	arr[8] = (scsi_debug_sector_size >> 24) & 0xff;
	arr[9] = (scsi_debug_sector_size >> 16) & 0xff;
	arr[10] = (scsi_debug_sector_size >> 8) & 0xff;
	arr[11] = scsi_debug_sector_size & 0xff;
1086 1087
	arr[13] = scsi_debug_physblk_exp & 0xf;
	arr[14] = (scsi_debug_lowest_aligned >> 8) & 0x3f;
1088

1089
	if (scsi_debug_lbp()) {
1090
		arr[14] |= 0x80; /* LBPME */
1091 1092 1093
		if (scsi_debug_lbprz)
			arr[14] |= 0x40; /* LBPRZ */
	}
1094

1095
	arr[15] = scsi_debug_lowest_aligned & 0xff;
1096 1097 1098 1099 1100 1101

	if (scsi_debug_dif) {
		arr[12] = (scsi_debug_dif - 1) << 1; /* P_TYPE */
		arr[12] |= 1; /* PROT_EN */
	}

D
Douglas Gilbert 已提交
1102 1103 1104 1105
	return fill_from_dev_buffer(scp, arr,
				    min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
}

1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
#define SDEBUG_MAX_TGTPGS_ARR_SZ 1412

static int resp_report_tgtpgs(struct scsi_cmnd * scp,
			      struct sdebug_dev_info * devip)
{
	unsigned char *cmd = (unsigned char *)scp->cmnd;
	unsigned char * arr;
	int host_no = devip->sdbg_host->shost->host_no;
	int n, ret, alen, rlen;
	int port_group_a, port_group_b, port_a, port_b;

	alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8)
		+ cmd[9]);

1120 1121 1122
	arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
	if (! arr)
		return DID_REQUEUE << 16;
1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188
	/*
	 * EVPD page 0x88 states we have two ports, one
	 * real and a fake port with no device connected.
	 * So we create two port groups with one port each
	 * and set the group with port B to unavailable.
	 */
	port_a = 0x1; /* relative port A */
	port_b = 0x2; /* relative port B */
	port_group_a = (((host_no + 1) & 0x7f) << 8) +
	    (devip->channel & 0x7f);
	port_group_b = (((host_no + 1) & 0x7f) << 8) +
	    (devip->channel & 0x7f) + 0x80;

	/*
	 * The asymmetric access state is cycled according to the host_id.
	 */
	n = 4;
	if (0 == scsi_debug_vpd_use_hostno) {
	    arr[n++] = host_no % 3; /* Asymm access state */
	    arr[n++] = 0x0F; /* claim: all states are supported */
	} else {
	    arr[n++] = 0x0; /* Active/Optimized path */
	    arr[n++] = 0x01; /* claim: only support active/optimized paths */
	}
	arr[n++] = (port_group_a >> 8) & 0xff;
	arr[n++] = port_group_a & 0xff;
	arr[n++] = 0;    /* Reserved */
	arr[n++] = 0;    /* Status code */
	arr[n++] = 0;    /* Vendor unique */
	arr[n++] = 0x1;  /* One port per group */
	arr[n++] = 0;    /* Reserved */
	arr[n++] = 0;    /* Reserved */
	arr[n++] = (port_a >> 8) & 0xff;
	arr[n++] = port_a & 0xff;
	arr[n++] = 3;    /* Port unavailable */
	arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
	arr[n++] = (port_group_b >> 8) & 0xff;
	arr[n++] = port_group_b & 0xff;
	arr[n++] = 0;    /* Reserved */
	arr[n++] = 0;    /* Status code */
	arr[n++] = 0;    /* Vendor unique */
	arr[n++] = 0x1;  /* One port per group */
	arr[n++] = 0;    /* Reserved */
	arr[n++] = 0;    /* Reserved */
	arr[n++] = (port_b >> 8) & 0xff;
	arr[n++] = port_b & 0xff;

	rlen = n - 4;
	arr[0] = (rlen >> 24) & 0xff;
	arr[1] = (rlen >> 16) & 0xff;
	arr[2] = (rlen >> 8) & 0xff;
	arr[3] = rlen & 0xff;

	/*
	 * Return the smallest value of either
	 * - The allocated length
	 * - The constructed command length
	 * - The maximum array size
	 */
	rlen = min(alen,n);
	ret = fill_from_dev_buffer(scp, arr,
				   min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
	kfree(arr);
	return ret;
}

L
Linus Torvalds 已提交
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
/* <<Following mode page info copied from ST318451LW>> */

static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
{	/* Read-Write Error Recovery page for mode_sense */
	unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
					5, 0, 0xff, 0xff};

	memcpy(p, err_recov_pg, sizeof(err_recov_pg));
	if (1 == pcontrol)
		memset(p + 2, 0, sizeof(err_recov_pg) - 2);
	return sizeof(err_recov_pg);
}

static int resp_disconnect_pg(unsigned char * p, int pcontrol, int target)
{ 	/* Disconnect-Reconnect page for mode_sense */
	unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
					 0, 0, 0, 0, 0, 0, 0, 0};

	memcpy(p, disconnect_pg, sizeof(disconnect_pg));
	if (1 == pcontrol)
		memset(p + 2, 0, sizeof(disconnect_pg) - 2);
	return sizeof(disconnect_pg);
}

static int resp_format_pg(unsigned char * p, int pcontrol, int target)
{       /* Format device page for mode_sense */
1215 1216 1217 1218 1219 1220 1221 1222 1223
	unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
				     0, 0, 0, 0, 0, 0, 0, 0,
				     0, 0, 0, 0, 0x40, 0, 0, 0};

	memcpy(p, format_pg, sizeof(format_pg));
	p[10] = (sdebug_sectors_per >> 8) & 0xff;
	p[11] = sdebug_sectors_per & 0xff;
	p[12] = (scsi_debug_sector_size >> 8) & 0xff;
	p[13] = scsi_debug_sector_size & 0xff;
1224
	if (scsi_debug_removable)
1225 1226 1227 1228
		p[20] |= 0x20; /* should agree with INQUIRY */
	if (1 == pcontrol)
		memset(p + 2, 0, sizeof(format_pg) - 2);
	return sizeof(format_pg);
L
Linus Torvalds 已提交
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
}

static int resp_caching_pg(unsigned char * p, int pcontrol, int target)
{ 	/* Caching page for mode_sense */
	unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
		0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0,     0, 0, 0, 0};

	memcpy(p, caching_pg, sizeof(caching_pg));
	if (1 == pcontrol)
		memset(p + 2, 0, sizeof(caching_pg) - 2);
	return sizeof(caching_pg);
}

static int resp_ctrl_m_pg(unsigned char * p, int pcontrol, int target)
{ 	/* Control mode page for mode_sense */
D
Douglas Gilbert 已提交
1244 1245 1246
	unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
				        0, 0, 0, 0};
	unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
L
Linus Torvalds 已提交
1247 1248 1249 1250
				     0, 0, 0x2, 0x4b};

	if (scsi_debug_dsense)
		ctrl_m_pg[2] |= 0x4;
D
Douglas Gilbert 已提交
1251 1252
	else
		ctrl_m_pg[2] &= ~0x4;
1253 1254 1255 1256

	if (scsi_debug_ato)
		ctrl_m_pg[5] |= 0x80; /* ATO=1 */

L
Linus Torvalds 已提交
1257 1258
	memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
	if (1 == pcontrol)
D
Douglas Gilbert 已提交
1259 1260 1261
		memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
	else if (2 == pcontrol)
		memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
L
Linus Torvalds 已提交
1262 1263 1264
	return sizeof(ctrl_m_pg);
}

D
Douglas Gilbert 已提交
1265

L
Linus Torvalds 已提交
1266 1267
static int resp_iec_m_pg(unsigned char * p, int pcontrol, int target)
{	/* Informational Exceptions control mode page for mode_sense */
D
Douglas Gilbert 已提交
1268 1269 1270 1271 1272
	unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
				       0, 0, 0x0, 0x0};
	unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
				      0, 0, 0x0, 0x0};

L
Linus Torvalds 已提交
1273 1274
	memcpy(p, iec_m_pg, sizeof(iec_m_pg));
	if (1 == pcontrol)
D
Douglas Gilbert 已提交
1275 1276 1277
		memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
	else if (2 == pcontrol)
		memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
L
Linus Torvalds 已提交
1278 1279 1280
	return sizeof(iec_m_pg);
}

D
Douglas Gilbert 已提交
1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
static int resp_sas_sf_m_pg(unsigned char * p, int pcontrol, int target)
{	/* SAS SSP mode page - short format for mode_sense */
	unsigned char sas_sf_m_pg[] = {0x19, 0x6,
		0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};

	memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
	if (1 == pcontrol)
		memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
	return sizeof(sas_sf_m_pg);
}


static int resp_sas_pcd_m_spg(unsigned char * p, int pcontrol, int target,
			      int target_dev_id)
{	/* SAS phy control and discover mode page for mode_sense */
	unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
		    0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
		    0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
		    0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
		    0x2, 0, 0, 0, 0, 0, 0, 0,
		    0x88, 0x99, 0, 0, 0, 0, 0, 0,
		    0, 0, 0, 0, 0, 0, 0, 0,
		    0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
		    0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
		    0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
		    0x3, 0, 0, 0, 0, 0, 0, 0,
		    0x88, 0x99, 0, 0, 0, 0, 0, 0,
		    0, 0, 0, 0, 0, 0, 0, 0,
		};
	int port_a, port_b;

	port_a = target_dev_id + 1;
	port_b = port_a + 1;
	memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
	p[20] = (port_a >> 24);
	p[21] = (port_a >> 16) & 0xff;
	p[22] = (port_a >> 8) & 0xff;
	p[23] = port_a & 0xff;
	p[48 + 20] = (port_b >> 24);
	p[48 + 21] = (port_b >> 16) & 0xff;
	p[48 + 22] = (port_b >> 8) & 0xff;
	p[48 + 23] = port_b & 0xff;
	if (1 == pcontrol)
		memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
	return sizeof(sas_pcd_m_pg);
}

static int resp_sas_sha_m_spg(unsigned char * p, int pcontrol)
{	/* SAS SSP shared protocol specific port mode subpage */
	unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
		    0, 0, 0, 0, 0, 0, 0, 0,
		};

	memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
	if (1 == pcontrol)
		memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
	return sizeof(sas_sha_m_pg);
}

L
Linus Torvalds 已提交
1340 1341 1342 1343 1344
#define SDEBUG_MAX_MSENSE_SZ 256

static int resp_mode_sense(struct scsi_cmnd * scp, int target,
			   struct sdebug_dev_info * devip)
{
D
Douglas Gilbert 已提交
1345 1346
	unsigned char dbd, llbaa;
	int pcontrol, pcode, subpcode, bd_len;
L
Linus Torvalds 已提交
1347
	unsigned char dev_spec;
D
Douglas Gilbert 已提交
1348
	int k, alloc_len, msense_6, offset, len, errsts, target_dev_id;
L
Linus Torvalds 已提交
1349 1350 1351 1352
	unsigned char * ap;
	unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
	unsigned char *cmd = (unsigned char *)scp->cmnd;

D
Douglas Gilbert 已提交
1353
	if ((errsts = check_readiness(scp, 1, devip)))
L
Linus Torvalds 已提交
1354
		return errsts;
D
Douglas Gilbert 已提交
1355
	dbd = !!(cmd[1] & 0x8);
L
Linus Torvalds 已提交
1356 1357 1358 1359
	pcontrol = (cmd[2] & 0xc0) >> 6;
	pcode = cmd[2] & 0x3f;
	subpcode = cmd[3];
	msense_6 = (MODE_SENSE == cmd[0]);
D
Douglas Gilbert 已提交
1360 1361 1362 1363 1364
	llbaa = msense_6 ? 0 : !!(cmd[1] & 0x10);
	if ((0 == scsi_debug_ptype) && (0 == dbd))
		bd_len = llbaa ? 16 : 8;
	else
		bd_len = 0;
L
Linus Torvalds 已提交
1365 1366 1367 1368 1369 1370 1371
	alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]);
	memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
	if (0x3 == pcontrol) {  /* Saving values not supported */
		mk_sense_buffer(devip, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP,
			       	0);
		return check_condition_result;
	}
D
Douglas Gilbert 已提交
1372 1373
	target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
			(devip->target * 1000) - 3;
D
Douglas Gilbert 已提交
1374 1375 1376 1377 1378
	/* set DPOFUA bit for disks */
	if (0 == scsi_debug_ptype)
		dev_spec = (DEV_READONLY(target) ? 0x80 : 0x0) | 0x10;
	else
		dev_spec = 0x0;
L
Linus Torvalds 已提交
1379 1380
	if (msense_6) {
		arr[2] = dev_spec;
D
Douglas Gilbert 已提交
1381
		arr[3] = bd_len;
L
Linus Torvalds 已提交
1382 1383 1384
		offset = 4;
	} else {
		arr[3] = dev_spec;
D
Douglas Gilbert 已提交
1385 1386 1387
		if (16 == bd_len)
			arr[4] = 0x1;	/* set LONGLBA bit */
		arr[7] = bd_len;	/* assume 255 or less */
L
Linus Torvalds 已提交
1388 1389 1390
		offset = 8;
	}
	ap = arr + offset;
1391 1392 1393
	if ((bd_len > 0) && (!sdebug_capacity))
		sdebug_capacity = get_sdebug_capacity();

D
Douglas Gilbert 已提交
1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
	if (8 == bd_len) {
		if (sdebug_capacity > 0xfffffffe) {
			ap[0] = 0xff;
			ap[1] = 0xff;
			ap[2] = 0xff;
			ap[3] = 0xff;
		} else {
			ap[0] = (sdebug_capacity >> 24) & 0xff;
			ap[1] = (sdebug_capacity >> 16) & 0xff;
			ap[2] = (sdebug_capacity >> 8) & 0xff;
			ap[3] = sdebug_capacity & 0xff;
		}
1406 1407
		ap[6] = (scsi_debug_sector_size >> 8) & 0xff;
		ap[7] = scsi_debug_sector_size & 0xff;
D
Douglas Gilbert 已提交
1408 1409 1410 1411 1412 1413 1414
		offset += bd_len;
		ap = arr + offset;
	} else if (16 == bd_len) {
		unsigned long long capac = sdebug_capacity;

        	for (k = 0; k < 8; ++k, capac >>= 8)
                	ap[7 - k] = capac & 0xff;
1415 1416 1417 1418
		ap[12] = (scsi_debug_sector_size >> 24) & 0xff;
		ap[13] = (scsi_debug_sector_size >> 16) & 0xff;
		ap[14] = (scsi_debug_sector_size >> 8) & 0xff;
		ap[15] = scsi_debug_sector_size & 0xff;
D
Douglas Gilbert 已提交
1419 1420 1421
		offset += bd_len;
		ap = arr + offset;
	}
L
Linus Torvalds 已提交
1422

D
Douglas Gilbert 已提交
1423 1424
	if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
		/* TODO: Control Extension page */
L
Linus Torvalds 已提交
1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449
		mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
			       	0);
		return check_condition_result;
	}
	switch (pcode) {
	case 0x1:	/* Read-Write error recovery page, direct access */
		len = resp_err_recov_pg(ap, pcontrol, target);
		offset += len;
		break;
	case 0x2:	/* Disconnect-Reconnect page, all devices */
		len = resp_disconnect_pg(ap, pcontrol, target);
		offset += len;
		break;
        case 0x3:       /* Format device page, direct access */
                len = resp_format_pg(ap, pcontrol, target);
                offset += len;
                break;
	case 0x8:	/* Caching page, direct access */
		len = resp_caching_pg(ap, pcontrol, target);
		offset += len;
		break;
	case 0xa:	/* Control Mode page, all devices */
		len = resp_ctrl_m_pg(ap, pcontrol, target);
		offset += len;
		break;
D
Douglas Gilbert 已提交
1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
	case 0x19:	/* if spc==1 then sas phy, control+discover */
		if ((subpcode > 0x2) && (subpcode < 0xff)) {
		        mk_sense_buffer(devip, ILLEGAL_REQUEST,
					INVALID_FIELD_IN_CDB, 0);
			return check_condition_result;
	        }
		len = 0;
		if ((0x0 == subpcode) || (0xff == subpcode))
			len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
		if ((0x1 == subpcode) || (0xff == subpcode))
			len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
						  target_dev_id);
		if ((0x2 == subpcode) || (0xff == subpcode))
			len += resp_sas_sha_m_spg(ap + len, pcontrol);
		offset += len;
		break;
L
Linus Torvalds 已提交
1466 1467 1468 1469 1470
	case 0x1c:	/* Informational Exceptions Mode page, all devices */
		len = resp_iec_m_pg(ap, pcontrol, target);
		offset += len;
		break;
	case 0x3f:	/* Read all Mode pages */
D
Douglas Gilbert 已提交
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
		if ((0 == subpcode) || (0xff == subpcode)) {
			len = resp_err_recov_pg(ap, pcontrol, target);
			len += resp_disconnect_pg(ap + len, pcontrol, target);
			len += resp_format_pg(ap + len, pcontrol, target);
			len += resp_caching_pg(ap + len, pcontrol, target);
			len += resp_ctrl_m_pg(ap + len, pcontrol, target);
			len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
			if (0xff == subpcode) {
				len += resp_sas_pcd_m_spg(ap + len, pcontrol,
						  target, target_dev_id);
				len += resp_sas_sha_m_spg(ap + len, pcontrol);
			}
			len += resp_iec_m_pg(ap + len, pcontrol, target);
		} else {
			mk_sense_buffer(devip, ILLEGAL_REQUEST,
					INVALID_FIELD_IN_CDB, 0);
			return check_condition_result;
                }
L
Linus Torvalds 已提交
1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
		offset += len;
		break;
	default:
		mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
			       	0);
		return check_condition_result;
	}
	if (msense_6)
		arr[0] = offset - 1;
	else {
		arr[0] = ((offset - 2) >> 8) & 0xff;
		arr[1] = (offset - 2) & 0xff;
	}
	return fill_from_dev_buffer(scp, arr, min(alloc_len, offset));
}

D
Douglas Gilbert 已提交
1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534
#define SDEBUG_MAX_MSELECT_SZ 512

static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
			    struct sdebug_dev_info * devip)
{
	int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
	int param_len, res, errsts, mpage;
	unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
	unsigned char *cmd = (unsigned char *)scp->cmnd;

	if ((errsts = check_readiness(scp, 1, devip)))
		return errsts;
	memset(arr, 0, sizeof(arr));
	pf = cmd[1] & 0x10;
	sp = cmd[1] & 0x1;
	param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]);
	if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
		mk_sense_buffer(devip, ILLEGAL_REQUEST,
				INVALID_FIELD_IN_CDB, 0);
		return check_condition_result;
	}
        res = fetch_to_dev_buffer(scp, arr, param_len);
        if (-1 == res)
                return (DID_ERROR << 16);
        else if ((res < param_len) &&
                 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
                printk(KERN_INFO "scsi_debug: mode_select: cdb indicated=%d, "
                       " IO sent=%d bytes\n", param_len, res);
	md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2);
	bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]);
D
Douglas Gilbert 已提交
1535
	if (md_len > 2) {
D
Douglas Gilbert 已提交
1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607
		mk_sense_buffer(devip, ILLEGAL_REQUEST,
				INVALID_FIELD_IN_PARAM_LIST, 0);
		return check_condition_result;
	}
	off = bd_len + (mselect6 ? 4 : 8);
	mpage = arr[off] & 0x3f;
	ps = !!(arr[off] & 0x80);
	if (ps) {
		mk_sense_buffer(devip, ILLEGAL_REQUEST,
				INVALID_FIELD_IN_PARAM_LIST, 0);
		return check_condition_result;
	}
	spf = !!(arr[off] & 0x40);
	pg_len = spf ? ((arr[off + 2] << 8) + arr[off + 3] + 4) :
		       (arr[off + 1] + 2);
	if ((pg_len + off) > param_len) {
		mk_sense_buffer(devip, ILLEGAL_REQUEST,
				PARAMETER_LIST_LENGTH_ERR, 0);
		return check_condition_result;
	}
	switch (mpage) {
	case 0xa:      /* Control Mode page */
		if (ctrl_m_pg[1] == arr[off + 1]) {
			memcpy(ctrl_m_pg + 2, arr + off + 2,
			       sizeof(ctrl_m_pg) - 2);
			scsi_debug_dsense = !!(ctrl_m_pg[2] & 0x4);
			return 0;
		}
		break;
	case 0x1c:      /* Informational Exceptions Mode page */
		if (iec_m_pg[1] == arr[off + 1]) {
			memcpy(iec_m_pg + 2, arr + off + 2,
			       sizeof(iec_m_pg) - 2);
			return 0;
		}
		break;
	default:
		break;
	}
	mk_sense_buffer(devip, ILLEGAL_REQUEST,
			INVALID_FIELD_IN_PARAM_LIST, 0);
	return check_condition_result;
}

static int resp_temp_l_pg(unsigned char * arr)
{
	unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
				     0x0, 0x1, 0x3, 0x2, 0x0, 65,
		};

        memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
        return sizeof(temp_l_pg);
}

static int resp_ie_l_pg(unsigned char * arr)
{
	unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
		};

        memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
	if (iec_m_pg[2] & 0x4) {	/* TEST bit set */
		arr[4] = THRESHOLD_EXCEEDED;
		arr[5] = 0xff;
	}
        return sizeof(ie_l_pg);
}

#define SDEBUG_MAX_LSENSE_SZ 512

static int resp_log_sense(struct scsi_cmnd * scp,
                          struct sdebug_dev_info * devip)
{
D
Douglas Gilbert 已提交
1608
	int ppc, sp, pcontrol, pcode, subpcode, alloc_len, errsts, len, n;
D
Douglas Gilbert 已提交
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
	unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
	unsigned char *cmd = (unsigned char *)scp->cmnd;

	if ((errsts = check_readiness(scp, 1, devip)))
		return errsts;
	memset(arr, 0, sizeof(arr));
	ppc = cmd[1] & 0x2;
	sp = cmd[1] & 0x1;
	if (ppc || sp) {
		mk_sense_buffer(devip, ILLEGAL_REQUEST,
				INVALID_FIELD_IN_CDB, 0);
		return check_condition_result;
	}
	pcontrol = (cmd[2] & 0xc0) >> 6;
	pcode = cmd[2] & 0x3f;
D
Douglas Gilbert 已提交
1624
	subpcode = cmd[3] & 0xff;
D
Douglas Gilbert 已提交
1625 1626
	alloc_len = (cmd[7] << 8) + cmd[8];
	arr[0] = pcode;
D
Douglas Gilbert 已提交
1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680
	if (0 == subpcode) {
		switch (pcode) {
		case 0x0:	/* Supported log pages log page */
			n = 4;
			arr[n++] = 0x0;		/* this page */
			arr[n++] = 0xd;		/* Temperature */
			arr[n++] = 0x2f;	/* Informational exceptions */
			arr[3] = n - 4;
			break;
		case 0xd:	/* Temperature log page */
			arr[3] = resp_temp_l_pg(arr + 4);
			break;
		case 0x2f:	/* Informational exceptions log page */
			arr[3] = resp_ie_l_pg(arr + 4);
			break;
		default:
			mk_sense_buffer(devip, ILLEGAL_REQUEST,
					INVALID_FIELD_IN_CDB, 0);
			return check_condition_result;
		}
	} else if (0xff == subpcode) {
		arr[0] |= 0x40;
		arr[1] = subpcode;
		switch (pcode) {
		case 0x0:	/* Supported log pages and subpages log page */
			n = 4;
			arr[n++] = 0x0;
			arr[n++] = 0x0;		/* 0,0 page */
			arr[n++] = 0x0;
			arr[n++] = 0xff;	/* this page */
			arr[n++] = 0xd;
			arr[n++] = 0x0;		/* Temperature */
			arr[n++] = 0x2f;
			arr[n++] = 0x0;	/* Informational exceptions */
			arr[3] = n - 4;
			break;
		case 0xd:	/* Temperature subpages */
			n = 4;
			arr[n++] = 0xd;
			arr[n++] = 0x0;		/* Temperature */
			arr[3] = n - 4;
			break;
		case 0x2f:	/* Informational exceptions subpages */
			n = 4;
			arr[n++] = 0x2f;
			arr[n++] = 0x0;		/* Informational exceptions */
			arr[3] = n - 4;
			break;
		default:
			mk_sense_buffer(devip, ILLEGAL_REQUEST,
					INVALID_FIELD_IN_CDB, 0);
			return check_condition_result;
		}
	} else {
D
Douglas Gilbert 已提交
1681 1682 1683 1684 1685 1686 1687 1688 1689
		mk_sense_buffer(devip, ILLEGAL_REQUEST,
				INVALID_FIELD_IN_CDB, 0);
		return check_condition_result;
	}
	len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
	return fill_from_dev_buffer(scp, arr,
		    min(len, SDEBUG_MAX_INQ_ARR_SZ));
}

1690 1691
static int check_device_access_params(struct sdebug_dev_info *devi,
				      unsigned long long lba, unsigned int num)
L
Linus Torvalds 已提交
1692
{
D
Douglas Gilbert 已提交
1693
	if (lba + num > sdebug_capacity) {
1694
		mk_sense_buffer(devi, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE, 0);
L
Linus Torvalds 已提交
1695 1696
		return check_condition_result;
	}
D
Douglas Gilbert 已提交
1697 1698
	/* transfer length excessive (tie in to block limits VPD page) */
	if (num > sdebug_store_sectors) {
1699
		mk_sense_buffer(devi, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
D
Douglas Gilbert 已提交
1700 1701
		return check_condition_result;
	}
1702 1703 1704
	return 0;
}

1705
/* Returns number of bytes copied or -1 if error. */
1706 1707 1708 1709 1710
static int do_device_access(struct scsi_cmnd *scmd,
			    struct sdebug_dev_info *devi,
			    unsigned long long lba, unsigned int num, int write)
{
	int ret;
1711
	unsigned long long block, rest = 0;
1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725
	struct scsi_data_buffer *sdb;
	enum dma_data_direction dir;
	size_t (*func)(struct scatterlist *, unsigned int, void *, size_t,
		       off_t);

	if (write) {
		sdb = scsi_out(scmd);
		dir = DMA_TO_DEVICE;
		func = sg_pcopy_to_buffer;
	} else {
		sdb = scsi_in(scmd);
		dir = DMA_FROM_DEVICE;
		func = sg_pcopy_from_buffer;
	}
1726

1727 1728 1729 1730
	if (!sdb->length)
		return 0;
	if (!(scsi_bidi_cmnd(scmd) || scmd->sc_data_direction == dir))
		return -1;
1731 1732 1733 1734 1735

	block = do_div(lba, sdebug_store_sectors);
	if (block + num > sdebug_store_sectors)
		rest = block + num - sdebug_store_sectors;

1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746
	ret = func(sdb->table.sgl, sdb->table.nents,
		   fake_storep + (block * scsi_debug_sector_size),
		   (num - rest) * scsi_debug_sector_size, 0);
	if (ret != (num - rest) * scsi_debug_sector_size)
		return ret;

	if (rest) {
		ret += func(sdb->table.sgl, sdb->table.nents,
			    fake_storep, rest * scsi_debug_sector_size,
			    (num - rest) * scsi_debug_sector_size);
	}
1747 1748 1749 1750

	return ret;
}

1751
static __be16 dif_compute_csum(const void *buf, int len)
1752
{
1753
	__be16 csum;
1754

1755 1756 1757
	if (scsi_debug_guard)
		csum = (__force __be16)ip_compute_csum(buf, len);
	else
1758
		csum = cpu_to_be16(crc_t10dif(buf, len));
1759

1760 1761 1762 1763 1764 1765
	return csum;
}

static int dif_verify(struct sd_dif_tuple *sdt, const void *data,
		      sector_t sector, u32 ei_lba)
{
1766
	__be16 csum = dif_compute_csum(data, scsi_debug_sector_size);
1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790

	if (sdt->guard_tag != csum) {
		pr_err("%s: GUARD check failed on sector %lu rcvd 0x%04x, data 0x%04x\n",
			__func__,
			(unsigned long)sector,
			be16_to_cpu(sdt->guard_tag),
			be16_to_cpu(csum));
		return 0x01;
	}
	if (scsi_debug_dif == SD_DIF_TYPE1_PROTECTION &&
	    be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
		pr_err("%s: REF check failed on sector %lu\n",
			__func__, (unsigned long)sector);
		return 0x03;
	}
	if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
	    be32_to_cpu(sdt->ref_tag) != ei_lba) {
		pr_err("%s: REF check failed on sector %lu\n",
			__func__, (unsigned long)sector);
		return 0x03;
	}
	return 0;
}

1791
static void dif_copy_prot(struct scsi_cmnd *SCpnt, sector_t sector,
1792
			  unsigned int sectors, bool read)
1793
{
1794
	size_t resid;
1795
	void *paddr;
1796
	const void *dif_store_end = dif_storep + sdebug_store_sectors;
1797
	struct sg_mapping_iter miter;
1798

1799 1800
	/* Bytes of protection data to copy into sgl */
	resid = sectors * sizeof(*dif_storep);
1801

1802 1803 1804 1805 1806 1807
	sg_miter_start(&miter, scsi_prot_sglist(SCpnt),
			scsi_prot_sg_count(SCpnt), SG_MITER_ATOMIC |
			(read ? SG_MITER_TO_SG : SG_MITER_FROM_SG));

	while (sg_miter_next(&miter) && resid > 0) {
		size_t len = min(miter.length, resid);
1808
		void *start = dif_store(sector);
1809
		size_t rest = 0;
1810 1811 1812

		if (dif_store_end < start + len)
			rest = start + len - dif_store_end;
1813

1814
		paddr = miter.addr;
1815

1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
		if (read)
			memcpy(paddr, start, len - rest);
		else
			memcpy(start, paddr, len - rest);

		if (rest) {
			if (read)
				memcpy(paddr + len - rest, dif_storep, rest);
			else
				memcpy(dif_storep, paddr + len - rest, rest);
		}
1827

1828
		sector += len / sizeof(*dif_storep);
1829 1830
		resid -= len;
	}
1831
	sg_miter_stop(&miter);
1832 1833 1834 1835 1836 1837 1838 1839 1840
}

static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec,
			    unsigned int sectors, u32 ei_lba)
{
	unsigned int i;
	struct sd_dif_tuple *sdt;
	sector_t sector;

1841
	for (i = 0; i < sectors; i++, ei_lba++) {
1842 1843 1844 1845 1846
		int ret;

		sector = start_sec + i;
		sdt = dif_store(sector);

1847
		if (sdt->app_tag == cpu_to_be16(0xffff))
1848 1849 1850 1851 1852 1853 1854 1855
			continue;

		ret = dif_verify(sdt, fake_store(sector), sector, ei_lba);
		if (ret) {
			dif_errors++;
			return ret;
		}
	}
1856

1857
	dif_copy_prot(SCpnt, start_sec, sectors, true);
1858 1859 1860 1861 1862
	dix_reads++;

	return 0;
}

1863
static int resp_read(struct scsi_cmnd *SCpnt, unsigned long long lba,
1864 1865
		     unsigned int num, struct sdebug_dev_info *devip,
		     u32 ei_lba)
1866 1867 1868 1869 1870 1871 1872 1873
{
	unsigned long iflags;
	int ret;

	ret = check_device_access_params(devip, lba, num);
	if (ret)
		return ret;

L
Linus Torvalds 已提交
1874
	if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) &&
1875
	    (lba <= (OPT_MEDIUM_ERR_ADDR + OPT_MEDIUM_ERR_NUM - 1)) &&
D
Douglas Gilbert 已提交
1876 1877
	    ((lba + num) > OPT_MEDIUM_ERR_ADDR)) {
		/* claim unrecoverable read error */
1878
		mk_sense_buffer(devip, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 0);
D
Douglas Gilbert 已提交
1879 1880 1881
		/* set info field and valid bit for fixed descriptor */
		if (0x70 == (devip->sense_buff[0] & 0x7f)) {
			devip->sense_buff[0] |= 0x80;	/* Valid bit */
1882 1883
			ret = (lba < OPT_MEDIUM_ERR_ADDR)
			      ? OPT_MEDIUM_ERR_ADDR : (int)lba;
D
Douglas Gilbert 已提交
1884 1885 1886 1887 1888
			devip->sense_buff[3] = (ret >> 24) & 0xff;
			devip->sense_buff[4] = (ret >> 16) & 0xff;
			devip->sense_buff[5] = (ret >> 8) & 0xff;
			devip->sense_buff[6] = ret & 0xff;
		}
1889
	        scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
L
Linus Torvalds 已提交
1890 1891
		return check_condition_result;
	}
1892

1893 1894
	read_lock_irqsave(&atomic_rw, iflags);

1895 1896
	/* DIX + T10 DIF */
	if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) {
1897
		int prot_ret = prot_verify_read(SCpnt, lba, num, ei_lba);
1898 1899

		if (prot_ret) {
1900
			read_unlock_irqrestore(&atomic_rw, iflags);
1901 1902 1903 1904 1905
			mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, prot_ret);
			return illegal_condition_result;
		}
	}

1906
	ret = do_device_access(SCpnt, devip, lba, num, 0);
L
Linus Torvalds 已提交
1907
	read_unlock_irqrestore(&atomic_rw, iflags);
1908 1909 1910 1911 1912 1913
	if (ret == -1)
		return DID_ERROR << 16;

	scsi_in(SCpnt)->resid = scsi_bufflen(SCpnt) - ret;

	return 0;
L
Linus Torvalds 已提交
1914 1915
}

1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937
void dump_sector(unsigned char *buf, int len)
{
	int i, j;

	printk(KERN_ERR ">>> Sector Dump <<<\n");

	for (i = 0 ; i < len ; i += 16) {
		printk(KERN_ERR "%04d: ", i);

		for (j = 0 ; j < 16 ; j++) {
			unsigned char c = buf[i+j];
			if (c >= 0x20 && c < 0x7e)
				printk(" %c ", buf[i+j]);
			else
				printk("%02x ", buf[i+j]);
		}

		printk("\n");
	}
}

static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
1938
			     unsigned int sectors, u32 ei_lba)
1939
{
1940
	int ret;
1941
	struct sd_dif_tuple *sdt;
1942
	void *daddr;
1943
	sector_t sector = start_sec;
1944
	int ppage_offset;
1945 1946 1947
	int dpage_offset;
	struct sg_mapping_iter diter;
	struct sg_mapping_iter piter;
1948 1949 1950 1951

	BUG_ON(scsi_sg_count(SCpnt) == 0);
	BUG_ON(scsi_prot_sg_count(SCpnt) == 0);

1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964
	sg_miter_start(&piter, scsi_prot_sglist(SCpnt),
			scsi_prot_sg_count(SCpnt),
			SG_MITER_ATOMIC | SG_MITER_FROM_SG);
	sg_miter_start(&diter, scsi_sglist(SCpnt), scsi_sg_count(SCpnt),
			SG_MITER_ATOMIC | SG_MITER_FROM_SG);

	/* For each protection page */
	while (sg_miter_next(&piter)) {
		dpage_offset = 0;
		if (WARN_ON(!sg_miter_next(&diter))) {
			ret = 0x01;
			goto out;
		}
1965

1966 1967
		for (ppage_offset = 0; ppage_offset < piter.length;
		     ppage_offset += sizeof(struct sd_dif_tuple)) {
1968
			/* If we're at the end of the current
1969
			 * data page advance to the next one
1970
			 */
1971 1972 1973 1974 1975 1976
			if (dpage_offset >= diter.length) {
				if (WARN_ON(!sg_miter_next(&diter))) {
					ret = 0x01;
					goto out;
				}
				dpage_offset = 0;
1977 1978
			}

1979 1980
			sdt = piter.addr + ppage_offset;
			daddr = diter.addr + dpage_offset;
1981

1982
			ret = dif_verify(sdt, daddr, sector, ei_lba);
1983
			if (ret) {
1984
				dump_sector(daddr, scsi_debug_sector_size);
1985 1986 1987
				goto out;
			}

1988
			sector++;
1989
			ei_lba++;
1990
			dpage_offset += scsi_debug_sector_size;
1991
		}
1992 1993
		diter.consumed = dpage_offset;
		sg_miter_stop(&diter);
1994
	}
1995
	sg_miter_stop(&piter);
1996

1997
	dif_copy_prot(SCpnt, start_sec, sectors, false);
1998 1999 2000 2001 2002 2003
	dix_writes++;

	return 0;

out:
	dif_errors++;
2004 2005
	sg_miter_stop(&diter);
	sg_miter_stop(&piter);
2006 2007 2008
	return ret;
}

2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020
static unsigned long lba_to_map_index(sector_t lba)
{
	if (scsi_debug_unmap_alignment) {
		lba += scsi_debug_unmap_granularity -
			scsi_debug_unmap_alignment;
	}
	do_div(lba, scsi_debug_unmap_granularity);

	return lba;
}

static sector_t map_index_to_lba(unsigned long index)
2021
{
2022 2023 2024 2025 2026 2027 2028 2029
	sector_t lba = index * scsi_debug_unmap_granularity;

	if (scsi_debug_unmap_alignment) {
		lba -= scsi_debug_unmap_granularity -
			scsi_debug_unmap_alignment;
	}

	return lba;
2030
}
2031

2032 2033 2034 2035 2036 2037
static unsigned int map_state(sector_t lba, unsigned int *num)
{
	sector_t end;
	unsigned int mapped;
	unsigned long index;
	unsigned long next;
2038

2039 2040
	index = lba_to_map_index(lba);
	mapped = test_bit(index, map_storep);
2041 2042

	if (mapped)
2043
		next = find_next_zero_bit(map_storep, map_size, index);
2044
	else
2045
		next = find_next_bit(map_storep, map_size, index);
2046

2047
	end = min_t(sector_t, sdebug_store_sectors,  map_index_to_lba(next));
2048 2049 2050 2051 2052 2053 2054 2055 2056 2057
	*num = end - lba;

	return mapped;
}

static void map_region(sector_t lba, unsigned int len)
{
	sector_t end = lba + len;

	while (lba < end) {
2058
		unsigned long index = lba_to_map_index(lba);
2059

2060 2061
		if (index < map_size)
			set_bit(index, map_storep);
2062

2063
		lba = map_index_to_lba(index + 1);
2064 2065 2066 2067 2068 2069 2070 2071
	}
}

static void unmap_region(sector_t lba, unsigned int len)
{
	sector_t end = lba + len;

	while (lba < end) {
2072
		unsigned long index = lba_to_map_index(lba);
2073

2074 2075 2076 2077 2078
		if (lba == map_index_to_lba(index) &&
		    lba + scsi_debug_unmap_granularity <= end &&
		    index < map_size) {
			clear_bit(index, map_storep);
			if (scsi_debug_lbprz) {
2079
				memset(fake_storep +
2080 2081 2082
				       lba * scsi_debug_sector_size, 0,
				       scsi_debug_sector_size *
				       scsi_debug_unmap_granularity);
2083
			}
2084 2085 2086 2087 2088
			if (dif_storep) {
				memset(dif_storep + lba, 0xff,
				       sizeof(*dif_storep) *
				       scsi_debug_unmap_granularity);
			}
2089
		}
2090
		lba = map_index_to_lba(index + 1);
2091 2092 2093
	}
}

2094
static int resp_write(struct scsi_cmnd *SCpnt, unsigned long long lba,
2095 2096
		      unsigned int num, struct sdebug_dev_info *devip,
		      u32 ei_lba)
L
Linus Torvalds 已提交
2097 2098
{
	unsigned long iflags;
2099
	int ret;
L
Linus Torvalds 已提交
2100

2101 2102 2103
	ret = check_device_access_params(devip, lba, num);
	if (ret)
		return ret;
L
Linus Torvalds 已提交
2104

2105 2106
	write_lock_irqsave(&atomic_rw, iflags);

2107 2108
	/* DIX + T10 DIF */
	if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) {
2109
		int prot_ret = prot_verify_write(SCpnt, lba, num, ei_lba);
2110 2111

		if (prot_ret) {
2112
			write_unlock_irqrestore(&atomic_rw, iflags);
2113 2114 2115 2116 2117
			mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, prot_ret);
			return illegal_condition_result;
		}
	}

2118
	ret = do_device_access(SCpnt, devip, lba, num, 1);
2119
	if (scsi_debug_lbp())
2120
		map_region(lba, num);
L
Linus Torvalds 已提交
2121
	write_unlock_irqrestore(&atomic_rw, iflags);
2122
	if (-1 == ret)
L
Linus Torvalds 已提交
2123
		return (DID_ERROR << 16);
2124
	else if ((ret < (num * scsi_debug_sector_size)) &&
L
Linus Torvalds 已提交
2125
		 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
D
Douglas Gilbert 已提交
2126
		printk(KERN_INFO "scsi_debug: write: cdb indicated=%u, "
2127
		       " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret);
2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143

	return 0;
}

static int resp_write_same(struct scsi_cmnd *scmd, unsigned long long lba,
		      unsigned int num, struct sdebug_dev_info *devip,
			   u32 ei_lba, unsigned int unmap)
{
	unsigned long iflags;
	unsigned long long i;
	int ret;

	ret = check_device_access_params(devip, lba, num);
	if (ret)
		return ret;

2144 2145 2146 2147 2148 2149
	if (num > scsi_debug_write_same_length) {
		mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
				0);
		return check_condition_result;
	}

2150 2151
	write_lock_irqsave(&atomic_rw, iflags);

2152
	if (unmap && scsi_debug_lbp()) {
2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175
		unmap_region(lba, num);
		goto out;
	}

	/* Else fetch one logical block */
	ret = fetch_to_dev_buffer(scmd,
				  fake_storep + (lba * scsi_debug_sector_size),
				  scsi_debug_sector_size);

	if (-1 == ret) {
		write_unlock_irqrestore(&atomic_rw, iflags);
		return (DID_ERROR << 16);
	} else if ((ret < (num * scsi_debug_sector_size)) &&
		 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
		printk(KERN_INFO "scsi_debug: write same: cdb indicated=%u, "
		       " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret);

	/* Copy first sector to remaining blocks */
	for (i = 1 ; i < num ; i++)
		memcpy(fake_storep + ((lba + i) * scsi_debug_sector_size),
		       fake_storep + (lba * scsi_debug_sector_size),
		       scsi_debug_sector_size);

2176
	if (scsi_debug_lbp())
2177 2178 2179 2180
		map_region(lba, num);
out:
	write_unlock_irqrestore(&atomic_rw, iflags);

L
Linus Torvalds 已提交
2181 2182 2183
	return 0;
}

2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195
struct unmap_block_desc {
	__be64	lba;
	__be32	blocks;
	__be32	__reserved;
};

static int resp_unmap(struct scsi_cmnd * scmd, struct sdebug_dev_info * devip)
{
	unsigned char *buf;
	struct unmap_block_desc *desc;
	unsigned int i, payload_len, descriptors;
	int ret;
2196
	unsigned long iflags;
2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217

	ret = check_readiness(scmd, 1, devip);
	if (ret)
		return ret;

	payload_len = get_unaligned_be16(&scmd->cmnd[7]);
	BUG_ON(scsi_bufflen(scmd) != payload_len);

	descriptors = (payload_len - 8) / 16;

	buf = kmalloc(scsi_bufflen(scmd), GFP_ATOMIC);
	if (!buf)
		return check_condition_result;

	scsi_sg_copy_to_buffer(scmd, buf, scsi_bufflen(scmd));

	BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2);
	BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16);

	desc = (void *)&buf[8];

2218 2219
	write_lock_irqsave(&atomic_rw, iflags);

2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233
	for (i = 0 ; i < descriptors ; i++) {
		unsigned long long lba = get_unaligned_be64(&desc[i].lba);
		unsigned int num = get_unaligned_be32(&desc[i].blocks);

		ret = check_device_access_params(devip, lba, num);
		if (ret)
			goto out;

		unmap_region(lba, num);
	}

	ret = 0;

out:
2234
	write_unlock_irqrestore(&atomic_rw, iflags);
2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266
	kfree(buf);

	return ret;
}

#define SDEBUG_GET_LBA_STATUS_LEN 32

static int resp_get_lba_status(struct scsi_cmnd * scmd,
			       struct sdebug_dev_info * devip)
{
	unsigned long long lba;
	unsigned int alloc_len, mapped, num;
	unsigned char arr[SDEBUG_GET_LBA_STATUS_LEN];
	int ret;

	ret = check_readiness(scmd, 1, devip);
	if (ret)
		return ret;

	lba = get_unaligned_be64(&scmd->cmnd[2]);
	alloc_len = get_unaligned_be32(&scmd->cmnd[10]);

	if (alloc_len < 24)
		return 0;

	ret = check_device_access_params(devip, lba, 1);
	if (ret)
		return ret;

	mapped = map_state(lba, &num);

	memset(arr, 0, SDEBUG_GET_LBA_STATUS_LEN);
2267
	put_unaligned_be32(20, &arr[0]);	/* Parameter Data Length */
2268 2269 2270 2271 2272 2273 2274
	put_unaligned_be64(lba, &arr[8]);	/* LBA */
	put_unaligned_be32(num, &arr[16]);	/* Number of blocks */
	arr[20] = !mapped;			/* mapped = 0, unmapped = 1 */

	return fill_from_dev_buffer(scmd, arr, SDEBUG_GET_LBA_STATUS_LEN);
}

D
Douglas Gilbert 已提交
2275
#define SDEBUG_RLUN_ARR_SZ 256
L
Linus Torvalds 已提交
2276 2277 2278 2279 2280

static int resp_report_luns(struct scsi_cmnd * scp,
			    struct sdebug_dev_info * devip)
{
	unsigned int alloc_len;
D
Douglas Gilbert 已提交
2281
	int lun_cnt, i, upper, num, n, wlun, lun;
L
Linus Torvalds 已提交
2282 2283 2284 2285
	unsigned char *cmd = (unsigned char *)scp->cmnd;
	int select_report = (int)cmd[2];
	struct scsi_lun *one_lun;
	unsigned char arr[SDEBUG_RLUN_ARR_SZ];
D
Douglas Gilbert 已提交
2286
	unsigned char * max_addr;
L
Linus Torvalds 已提交
2287 2288

	alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
D
Douglas Gilbert 已提交
2289
	if ((alloc_len < 4) || (select_report > 2)) {
L
Linus Torvalds 已提交
2290 2291 2292 2293 2294 2295 2296
		mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
			       	0);
		return check_condition_result;
	}
	/* can produce response with up to 16k luns (lun 0 to lun 16383) */
	memset(arr, 0, SDEBUG_RLUN_ARR_SZ);
	lun_cnt = scsi_debug_max_luns;
D
Douglas Gilbert 已提交
2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
	if (1 == select_report)
		lun_cnt = 0;
	else if (scsi_debug_no_lun_0 && (lun_cnt > 0))
		--lun_cnt;
	wlun = (select_report > 0) ? 1 : 0;
	num = lun_cnt + wlun;
	arr[2] = ((sizeof(struct scsi_lun) * num) >> 8) & 0xff;
	arr[3] = (sizeof(struct scsi_lun) * num) & 0xff;
	n = min((int)((SDEBUG_RLUN_ARR_SZ - 8) /
			    sizeof(struct scsi_lun)), num);
	if (n < num) {
		wlun = 0;
		lun_cnt = n;
	}
L
Linus Torvalds 已提交
2311
	one_lun = (struct scsi_lun *) &arr[8];
D
Douglas Gilbert 已提交
2312 2313 2314 2315 2316
	max_addr = arr + SDEBUG_RLUN_ARR_SZ;
	for (i = 0, lun = (scsi_debug_no_lun_0 ? 1 : 0);
             ((i < lun_cnt) && ((unsigned char *)(one_lun + i) < max_addr));
	     i++, lun++) {
		upper = (lun >> 8) & 0x3f;
L
Linus Torvalds 已提交
2317 2318 2319
		if (upper)
			one_lun[i].scsi_lun[0] =
			    (upper | (SAM2_LUN_ADDRESS_METHOD << 6));
D
Douglas Gilbert 已提交
2320 2321 2322 2323 2324 2325
		one_lun[i].scsi_lun[1] = lun & 0xff;
	}
	if (wlun) {
		one_lun[i].scsi_lun[0] = (SAM2_WLUN_REPORT_LUNS >> 8) & 0xff;
		one_lun[i].scsi_lun[1] = SAM2_WLUN_REPORT_LUNS & 0xff;
		i++;
L
Linus Torvalds 已提交
2326
	}
D
Douglas Gilbert 已提交
2327
	alloc_len = (unsigned char *)(one_lun + i) - arr;
L
Linus Torvalds 已提交
2328 2329 2330 2331
	return fill_from_dev_buffer(scp, arr,
				    min((int)alloc_len, SDEBUG_RLUN_ARR_SZ));
}

2332 2333 2334
static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
			    unsigned int num, struct sdebug_dev_info *devip)
{
2335
	int j;
2336 2337 2338
	unsigned char *kaddr, *buf;
	unsigned int offset;
	struct scsi_data_buffer *sdb = scsi_in(scp);
2339
	struct sg_mapping_iter miter;
2340 2341 2342

	/* better not to use temporary buffer. */
	buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
2343 2344 2345 2346 2347
	if (!buf) {
		mk_sense_buffer(devip, NOT_READY,
				LOGICAL_UNIT_COMMUNICATION_FAILURE, 0);
		return check_condition_result;
	}
2348

2349
	scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
2350 2351

	offset = 0;
2352 2353
	sg_miter_start(&miter, sdb->table.sgl, sdb->table.nents,
			SG_MITER_ATOMIC | SG_MITER_TO_SG);
2354

2355 2356 2357 2358
	while (sg_miter_next(&miter)) {
		kaddr = miter.addr;
		for (j = 0; j < miter.length; j++)
			*(kaddr + j) ^= *(buf + offset + j);
2359

2360
		offset += miter.length;
2361
	}
2362
	sg_miter_stop(&miter);
2363 2364
	kfree(buf);

2365
	return 0;
2366 2367
}

L
Linus Torvalds 已提交
2368 2369 2370 2371 2372 2373
/* When timer goes off this function is called. */
static void timer_intr_handler(unsigned long indx)
{
	struct sdebug_queued_cmd * sqcp;
	unsigned long iflags;

2374
	if (indx >= scsi_debug_max_queue) {
L
Linus Torvalds 已提交
2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396
		printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too "
		       "large\n");
		return;
	}
	spin_lock_irqsave(&queued_arr_lock, iflags);
	sqcp = &queued_arr[(int)indx];
	if (! sqcp->in_use) {
		printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected "
		       "interrupt\n");
		spin_unlock_irqrestore(&queued_arr_lock, iflags);
		return;
	}
	sqcp->in_use = 0;
	if (sqcp->done_funct) {
		sqcp->a_cmnd->result = sqcp->scsi_result;
		sqcp->done_funct(sqcp->a_cmnd); /* callback to mid level */
	}
	sqcp->done_funct = NULL;
	spin_unlock_irqrestore(&queued_arr_lock, iflags);
}


2397 2398
static struct sdebug_dev_info *
sdebug_device_create(struct sdebug_host_info *sdbg_host, gfp_t flags)
2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409
{
	struct sdebug_dev_info *devip;

	devip = kzalloc(sizeof(*devip), flags);
	if (devip) {
		devip->sdbg_host = sdbg_host;
		list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
	}
	return devip;
}

L
Linus Torvalds 已提交
2410 2411 2412 2413 2414 2415 2416 2417 2418
static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
{
	struct sdebug_host_info * sdbg_host;
	struct sdebug_dev_info * open_devip = NULL;
	struct sdebug_dev_info * devip =
			(struct sdebug_dev_info *)sdev->hostdata;

	if (devip)
		return devip;
2419 2420
	sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
	if (!sdbg_host) {
L
Linus Torvalds 已提交
2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433
                printk(KERN_ERR "Host info NULL\n");
		return NULL;
        }
	list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
		if ((devip->used) && (devip->channel == sdev->channel) &&
                    (devip->target == sdev->id) &&
                    (devip->lun == sdev->lun))
                        return devip;
		else {
			if ((!devip->used) && (!open_devip))
				open_devip = devip;
		}
	}
2434 2435 2436
	if (!open_devip) { /* try and make a new one */
		open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC);
		if (!open_devip) {
L
Linus Torvalds 已提交
2437
			printk(KERN_ERR "%s: out of memory at line %d\n",
2438
				__func__, __LINE__);
L
Linus Torvalds 已提交
2439 2440 2441
			return NULL;
		}
	}
2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459

	open_devip->channel = sdev->channel;
	open_devip->target = sdev->id;
	open_devip->lun = sdev->lun;
	open_devip->sdbg_host = sdbg_host;
	open_devip->reset = 1;
	open_devip->used = 1;
	memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
	if (scsi_debug_dsense)
		open_devip->sense_buff[0] = 0x72;
	else {
		open_devip->sense_buff[0] = 0x70;
		open_devip->sense_buff[7] = 0xa;
	}
	if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
		open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;

	return open_devip;
L
Linus Torvalds 已提交
2460 2461
}

2462
static int scsi_debug_slave_alloc(struct scsi_device *sdp)
L
Linus Torvalds 已提交
2463
{
2464 2465 2466
	if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
		printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
		       sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
N
Nick Piggin 已提交
2467
	queue_flag_set_unlocked(QUEUE_FLAG_BIDI, sdp->request_queue);
2468 2469
	return 0;
}
L
Linus Torvalds 已提交
2470

2471 2472 2473
static int scsi_debug_slave_configure(struct scsi_device *sdp)
{
	struct sdebug_dev_info *devip;
2474

2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487
	if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
		printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n",
		       sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
	if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN)
		sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN;
	devip = devInfoReg(sdp);
	if (NULL == devip)
		return 1;	/* no resources, will be marked offline */
	sdp->hostdata = devip;
	if (sdp->host->cmd_per_lun)
		scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING,
					sdp->host->cmd_per_lun);
	blk_queue_max_segment_size(sdp->request_queue, 256 * 1024);
2488 2489
	if (scsi_debug_no_uld)
		sdp->no_uld_attach = 1;
2490 2491 2492 2493 2494 2495 2496
	return 0;
}

static void scsi_debug_slave_destroy(struct scsi_device *sdp)
{
	struct sdebug_dev_info *devip =
		(struct sdebug_dev_info *)sdp->hostdata;
2497

L
Linus Torvalds 已提交
2498
	if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2499 2500 2501
		printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n",
		       sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
	if (devip) {
L
Lucas De Marchi 已提交
2502
		/* make this slot available for re-use */
2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515
		devip->used = 0;
		sdp->hostdata = NULL;
	}
}

/* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
static int stop_queued_cmnd(struct scsi_cmnd *cmnd)
{
	unsigned long iflags;
	int k;
	struct sdebug_queued_cmd *sqcp;

	spin_lock_irqsave(&queued_arr_lock, iflags);
2516
	for (k = 0; k < scsi_debug_max_queue; ++k) {
2517 2518 2519 2520 2521 2522 2523 2524 2525
		sqcp = &queued_arr[k];
		if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
			del_timer_sync(&sqcp->cmnd_timer);
			sqcp->in_use = 0;
			sqcp->a_cmnd = NULL;
			break;
		}
	}
	spin_unlock_irqrestore(&queued_arr_lock, iflags);
2526
	return (k < scsi_debug_max_queue) ? 1 : 0;
2527 2528 2529 2530 2531 2532 2533 2534 2535 2536
}

/* Deletes (stops) timers of all queued commands */
static void stop_all_queued(void)
{
	unsigned long iflags;
	int k;
	struct sdebug_queued_cmd *sqcp;

	spin_lock_irqsave(&queued_arr_lock, iflags);
2537
	for (k = 0; k < scsi_debug_max_queue; ++k) {
2538 2539 2540 2541 2542 2543 2544 2545
		sqcp = &queued_arr[k];
		if (sqcp->in_use && sqcp->a_cmnd) {
			del_timer_sync(&sqcp->cmnd_timer);
			sqcp->in_use = 0;
			sqcp->a_cmnd = NULL;
		}
	}
	spin_unlock_irqrestore(&queued_arr_lock, iflags);
L
Linus Torvalds 已提交
2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604
}

static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
{
	if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
		printk(KERN_INFO "scsi_debug: abort\n");
	++num_aborts;
	stop_queued_cmnd(SCpnt);
	return SUCCESS;
}

static int scsi_debug_biosparam(struct scsi_device *sdev,
		struct block_device * bdev, sector_t capacity, int *info)
{
	int res;
	unsigned char *buf;

	if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
		printk(KERN_INFO "scsi_debug: biosparam\n");
	buf = scsi_bios_ptable(bdev);
	if (buf) {
		res = scsi_partsize(buf, capacity,
				    &info[2], &info[0], &info[1]);
		kfree(buf);
		if (! res)
			return res;
	}
	info[0] = sdebug_heads;
	info[1] = sdebug_sectors_per;
	info[2] = sdebug_cylinders_per;
	return 0;
}

static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
{
	struct sdebug_dev_info * devip;

	if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
		printk(KERN_INFO "scsi_debug: device_reset\n");
	++num_dev_resets;
	if (SCpnt) {
		devip = devInfoReg(SCpnt->device);
		if (devip)
			devip->reset = 1;
	}
	return SUCCESS;
}

static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
{
	struct sdebug_host_info *sdbg_host;
        struct sdebug_dev_info * dev_info;
        struct scsi_device * sdp;
        struct Scsi_Host * hp;

	if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
		printk(KERN_INFO "scsi_debug: bus_reset\n");
	++num_bus_resets;
	if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
2605
		sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
L
Linus Torvalds 已提交
2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642
		if (sdbg_host) {
			list_for_each_entry(dev_info,
                                            &sdbg_host->dev_info_list,
                                            dev_list)
				dev_info->reset = 1;
		}
	}
	return SUCCESS;
}

static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
{
	struct sdebug_host_info * sdbg_host;
        struct sdebug_dev_info * dev_info;

	if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
		printk(KERN_INFO "scsi_debug: host_reset\n");
	++num_host_resets;
        spin_lock(&sdebug_host_list_lock);
        list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
                list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
                                    dev_list)
                        dev_info->reset = 1;
        }
        spin_unlock(&sdebug_host_list_lock);
	stop_all_queued();
	return SUCCESS;
}

/* Initializes timers in queued array */
static void __init init_all_queued(void)
{
	unsigned long iflags;
	int k;
	struct sdebug_queued_cmd * sqcp;

	spin_lock_irqsave(&queued_arr_lock, iflags);
2643
	for (k = 0; k < scsi_debug_max_queue; ++k) {
L
Linus Torvalds 已提交
2644 2645 2646 2647 2648 2649 2650 2651
		sqcp = &queued_arr[k];
		init_timer(&sqcp->cmnd_timer);
		sqcp->in_use = 0;
		sqcp->a_cmnd = NULL;
	}
	spin_unlock_irqrestore(&queued_arr_lock, iflags);
}

2652
static void __init sdebug_build_parts(unsigned char *ramp,
2653
				      unsigned long store_size)
L
Linus Torvalds 已提交
2654 2655 2656 2657 2658 2659 2660
{
	struct partition * pp;
	int starts[SDEBUG_MAX_PARTS + 2];
	int sectors_per_part, num_sectors, k;
	int heads_by_sects, start_sec, end_sec;

	/* assume partition table already zeroed */
2661
	if ((scsi_debug_num_parts < 1) || (store_size < 1048576))
L
Linus Torvalds 已提交
2662 2663 2664 2665 2666 2667
		return;
	if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
		scsi_debug_num_parts = SDEBUG_MAX_PARTS;
		printk(KERN_WARNING "scsi_debug:build_parts: reducing "
				    "partitions to %d\n", SDEBUG_MAX_PARTS);
	}
D
Douglas Gilbert 已提交
2668
	num_sectors = (int)sdebug_store_sectors;
L
Linus Torvalds 已提交
2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696
	sectors_per_part = (num_sectors - sdebug_sectors_per)
			   / scsi_debug_num_parts;
	heads_by_sects = sdebug_heads * sdebug_sectors_per;
        starts[0] = sdebug_sectors_per;
	for (k = 1; k < scsi_debug_num_parts; ++k)
		starts[k] = ((k * sectors_per_part) / heads_by_sects)
			    * heads_by_sects;
	starts[scsi_debug_num_parts] = num_sectors;
	starts[scsi_debug_num_parts + 1] = 0;

	ramp[510] = 0x55;	/* magic partition markings */
	ramp[511] = 0xAA;
	pp = (struct partition *)(ramp + 0x1be);
	for (k = 0; starts[k + 1]; ++k, ++pp) {
		start_sec = starts[k];
		end_sec = starts[k + 1] - 1;
		pp->boot_ind = 0;

		pp->cyl = start_sec / heads_by_sects;
		pp->head = (start_sec - (pp->cyl * heads_by_sects))
			   / sdebug_sectors_per;
		pp->sector = (start_sec % sdebug_sectors_per) + 1;

		pp->end_cyl = end_sec / heads_by_sects;
		pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
			       / sdebug_sectors_per;
		pp->end_sector = (end_sec % sdebug_sectors_per) + 1;

2697 2698
		pp->start_sect = cpu_to_le32(start_sec);
		pp->nr_sects = cpu_to_le32(end_sec - start_sec + 1);
L
Linus Torvalds 已提交
2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710
		pp->sys_ind = 0x83;	/* plain Linux partition */
	}
}

static int schedule_resp(struct scsi_cmnd * cmnd,
			 struct sdebug_dev_info * devip,
			 done_funct_t done, int scsi_result, int delta_jiff)
{
	if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
		if (scsi_result) {
			struct scsi_device * sdp = cmnd->device;

D
Douglas Gilbert 已提交
2711 2712 2713
			printk(KERN_INFO "scsi_debug:    <%u %u %u %u> "
			       "non-zero result=0x%x\n", sdp->host->host_no,
			       sdp->channel, sdp->id, sdp->lun, scsi_result);
L
Linus Torvalds 已提交
2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734
		}
	}
	if (cmnd && devip) {
		/* simulate autosense by this driver */
		if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
			memcpy(cmnd->sense_buffer, devip->sense_buff,
			       (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
			       SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
	}
	if (delta_jiff <= 0) {
		if (cmnd)
			cmnd->result = scsi_result;
		if (done)
			done(cmnd);
		return 0;
	} else {
		unsigned long iflags;
		int k;
		struct sdebug_queued_cmd * sqcp = NULL;

		spin_lock_irqsave(&queued_arr_lock, iflags);
2735
		for (k = 0; k < scsi_debug_max_queue; ++k) {
L
Linus Torvalds 已提交
2736 2737 2738 2739
			sqcp = &queued_arr[k];
			if (! sqcp->in_use)
				break;
		}
2740
		if (k >= scsi_debug_max_queue) {
L
Linus Torvalds 已提交
2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758
			spin_unlock_irqrestore(&queued_arr_lock, iflags);
			printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
			return 1;	/* report busy to mid level */
		}
		sqcp->in_use = 1;
		sqcp->a_cmnd = cmnd;
		sqcp->scsi_result = scsi_result;
		sqcp->done_funct = done;
		sqcp->cmnd_timer.function = timer_intr_handler;
		sqcp->cmnd_timer.data = k;
		sqcp->cmnd_timer.expires = jiffies + delta_jiff;
		add_timer(&sqcp->cmnd_timer);
		spin_unlock_irqrestore(&queued_arr_lock, iflags);
		if (cmnd)
			cmnd->result = 0;
		return 0;
	}
}
D
Douglas Gilbert 已提交
2759 2760 2761 2762 2763 2764
/* Note: The following macros create attribute files in the
   /sys/module/scsi_debug/parameters directory. Unfortunately this
   driver is unaware of a change and cannot trigger auxiliary actions
   as it can when the corresponding attribute in the
   /sys/bus/pseudo/drivers/scsi_debug directory is changed.
 */
D
Douglas Gilbert 已提交
2765
module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
2766
module_param_named(ato, scsi_debug_ato, int, S_IRUGO);
2767
module_param_named(clustering, scsi_debug_clustering, bool, S_IRUGO | S_IWUSR);
D
Douglas Gilbert 已提交
2768 2769
module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
2770 2771
module_param_named(dif, scsi_debug_dif, int, S_IRUGO);
module_param_named(dix, scsi_debug_dix, int, S_IRUGO);
D
Douglas Gilbert 已提交
2772 2773
module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
D
Douglas Gilbert 已提交
2774
module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
2775
module_param_named(guard, scsi_debug_guard, uint, S_IRUGO);
2776 2777 2778
module_param_named(lbpu, scsi_debug_lbpu, int, S_IRUGO);
module_param_named(lbpws, scsi_debug_lbpws, int, S_IRUGO);
module_param_named(lbpws10, scsi_debug_lbpws10, int, S_IRUGO);
2779
module_param_named(lbprz, scsi_debug_lbprz, int, S_IRUGO);
2780
module_param_named(lowest_aligned, scsi_debug_lowest_aligned, int, S_IRUGO);
D
Douglas Gilbert 已提交
2781
module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
2782
module_param_named(max_queue, scsi_debug_max_queue, int, S_IRUGO | S_IWUSR);
D
Douglas Gilbert 已提交
2783
module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
2784
module_param_named(no_uld, scsi_debug_no_uld, int, S_IRUGO);
D
Douglas Gilbert 已提交
2785 2786
module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
2787
module_param_named(opt_blks, scsi_debug_opt_blks, int, S_IRUGO);
D
Douglas Gilbert 已提交
2788
module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
2789
module_param_named(physblk_exp, scsi_debug_physblk_exp, int, S_IRUGO);
D
Douglas Gilbert 已提交
2790
module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
2791
module_param_named(removable, scsi_debug_removable, bool, S_IRUGO | S_IWUSR);
D
Douglas Gilbert 已提交
2792
module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
2793
module_param_named(sector_size, scsi_debug_sector_size, int, S_IRUGO);
2794 2795
module_param_named(unmap_alignment, scsi_debug_unmap_alignment, int, S_IRUGO);
module_param_named(unmap_granularity, scsi_debug_unmap_granularity, int, S_IRUGO);
2796 2797
module_param_named(unmap_max_blocks, scsi_debug_unmap_max_blocks, int, S_IRUGO);
module_param_named(unmap_max_desc, scsi_debug_unmap_max_desc, int, S_IRUGO);
2798 2799 2800 2801 2802
module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
		   S_IRUGO | S_IWUSR);
module_param_named(write_same_length, scsi_debug_write_same_length, int,
		   S_IRUGO | S_IWUSR);
L
Linus Torvalds 已提交
2803 2804 2805 2806 2807 2808 2809

MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
MODULE_DESCRIPTION("SCSI debug adapter driver");
MODULE_LICENSE("GPL");
MODULE_VERSION(SCSI_DEBUG_VERSION);

MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
2810
MODULE_PARM_DESC(ato, "application tag ownership: 0=disk 1=host (def=1)");
2811
MODULE_PARM_DESC(clustering, "when set enables larger transfers (def=0)");
L
Linus Torvalds 已提交
2812
MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
D
Douglas Gilbert 已提交
2813
MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
2814 2815
MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)");
MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)");
D
Douglas Gilbert 已提交
2816
MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
2817
MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
D
Douglas Gilbert 已提交
2818
MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
2819 2820 2821 2822
MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");
MODULE_PARM_DESC(lbpu, "enable LBP, support UNMAP command (def=0)");
MODULE_PARM_DESC(lbpws, "enable LBP, support WRITE SAME(16) with UNMAP bit (def=0)");
MODULE_PARM_DESC(lbpws10, "enable LBP, support WRITE SAME(10) with UNMAP bit (def=0)");
2823
MODULE_PARM_DESC(lbprz, "unmapped blocks return 0 on read (def=1)");
2824
MODULE_PARM_DESC(lowest_aligned, "lowest aligned lba (def=0)");
D
Douglas Gilbert 已提交
2825
MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
2826
MODULE_PARM_DESC(max_queue, "max number of queued commands (1 to 255(def))");
D
Douglas Gilbert 已提交
2827
MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
2828
MODULE_PARM_DESC(no_uld, "stop ULD (e.g. sd driver) attaching (def=0))");
L
Linus Torvalds 已提交
2829
MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
D
Douglas Gilbert 已提交
2830
MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
2831
MODULE_PARM_DESC(opt_blks, "optimal transfer length in block (def=64)");
2832
MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
2833
MODULE_PARM_DESC(physblk_exp, "physical block exponent (def=0)");
L
Linus Torvalds 已提交
2834
MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
2835
MODULE_PARM_DESC(removable, "claim to have removable media (def=0)");
L
Linus Torvalds 已提交
2836
MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
2837
MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)");
2838 2839
MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)");
MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=1)");
2840 2841
MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0xffffffff)");
MODULE_PARM_DESC(unmap_max_desc, "max # of ranges that can be unmapped in one cmd (def=256)");
2842 2843 2844
MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
MODULE_PARM_DESC(write_same_length, "Maximum blocks per WRITE SAME cmd (def=0xffff)");
L
Linus Torvalds 已提交
2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859

static char sdebug_info[256];

static const char * scsi_debug_info(struct Scsi_Host * shp)
{
	sprintf(sdebug_info, "scsi_debug, version %s [%s], "
		"dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
		scsi_debug_version_date, scsi_debug_dev_size_mb,
		scsi_debug_opts);
	return sdebug_info;
}

/* scsi_debug_proc_info
 * Used if the driver currently has no own support for /proc/scsi
 */
A
Al Viro 已提交
2860
static int scsi_debug_write_info(struct Scsi_Host *host, char *buffer, int length)
L
Linus Torvalds 已提交
2861
{
A
Al Viro 已提交
2862 2863 2864
	char arr[16];
	int opts;
	int minLen = length > 15 ? 15 : length;
L
Linus Torvalds 已提交
2865

A
Al Viro 已提交
2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876
	if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
		return -EACCES;
	memcpy(arr, buffer, minLen);
	arr[minLen] = '\0';
	if (1 != sscanf(arr, "%d", &opts))
		return -EINVAL;
	scsi_debug_opts = opts;
	if (scsi_debug_every_nth != 0)
		scsi_debug_cmnd_count = 0;
	return length;
}
L
Linus Torvalds 已提交
2877

A
Al Viro 已提交
2878 2879 2880
static int scsi_debug_show_info(struct seq_file *m, struct Scsi_Host *host)
{
	seq_printf(m, "scsi_debug adapter driver, version "
L
Linus Torvalds 已提交
2881 2882 2883 2884 2885 2886
	    "%s [%s]\n"
	    "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
	    "every_nth=%d(curr:%d)\n"
	    "delay=%d, max_luns=%d, scsi_level=%d\n"
	    "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
	    "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2887
	    "host_resets=%d\ndix_reads=%d dix_writes=%d dif_errors=%d\n",
L
Linus Torvalds 已提交
2888 2889 2890 2891
	    SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
	    scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
	    scsi_debug_cmnd_count, scsi_debug_delay,
	    scsi_debug_max_luns, scsi_debug_scsi_level,
2892 2893
	    scsi_debug_sector_size, sdebug_cylinders_per, sdebug_heads,
	    sdebug_sectors_per, num_aborts, num_dev_resets, num_bus_resets,
2894
	    num_host_resets, dix_reads, dix_writes, dif_errors);
A
Al Viro 已提交
2895
	return 0;
L
Linus Torvalds 已提交
2896 2897
}

2898
static ssize_t delay_show(struct device_driver *ddp, char *buf)
L
Linus Torvalds 已提交
2899 2900 2901 2902
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
}

2903 2904
static ssize_t delay_store(struct device_driver *ddp, const char *buf,
			   size_t count)
L
Linus Torvalds 已提交
2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916
{
        int delay;
	char work[20];

        if (1 == sscanf(buf, "%10s", work)) {
		if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
			scsi_debug_delay = delay;
			return count;
		}
	}
	return -EINVAL;
}
2917
static DRIVER_ATTR_RW(delay);
L
Linus Torvalds 已提交
2918

2919
static ssize_t opts_show(struct device_driver *ddp, char *buf)
L
Linus Torvalds 已提交
2920 2921 2922 2923
{
        return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
}

2924 2925
static ssize_t opts_store(struct device_driver *ddp, const char *buf,
			  size_t count)
L
Linus Torvalds 已提交
2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944
{
        int opts;
	char work[20];

        if (1 == sscanf(buf, "%10s", work)) {
		if (0 == strnicmp(work,"0x", 2)) {
			if (1 == sscanf(&work[2], "%x", &opts))
				goto opts_done;
		} else {
			if (1 == sscanf(work, "%d", &opts))
				goto opts_done;
		}
	}
	return -EINVAL;
opts_done:
	scsi_debug_opts = opts;
	scsi_debug_cmnd_count = 0;
	return count;
}
2945
static DRIVER_ATTR_RW(opts);
L
Linus Torvalds 已提交
2946

2947
static ssize_t ptype_show(struct device_driver *ddp, char *buf)
L
Linus Torvalds 已提交
2948 2949 2950
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
}
2951 2952
static ssize_t ptype_store(struct device_driver *ddp, const char *buf,
			   size_t count)
L
Linus Torvalds 已提交
2953 2954 2955 2956 2957 2958 2959 2960 2961
{
        int n;

	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
		scsi_debug_ptype = n;
		return count;
	}
	return -EINVAL;
}
2962
static DRIVER_ATTR_RW(ptype);
L
Linus Torvalds 已提交
2963

2964
static ssize_t dsense_show(struct device_driver *ddp, char *buf)
L
Linus Torvalds 已提交
2965 2966 2967
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
}
2968 2969
static ssize_t dsense_store(struct device_driver *ddp, const char *buf,
			    size_t count)
L
Linus Torvalds 已提交
2970 2971 2972 2973 2974 2975 2976 2977 2978
{
        int n;

	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
		scsi_debug_dsense = n;
		return count;
	}
	return -EINVAL;
}
2979
static DRIVER_ATTR_RW(dsense);
L
Linus Torvalds 已提交
2980

2981
static ssize_t fake_rw_show(struct device_driver *ddp, char *buf)
D
Douglas Gilbert 已提交
2982 2983 2984
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
}
2985 2986
static ssize_t fake_rw_store(struct device_driver *ddp, const char *buf,
			     size_t count)
D
Douglas Gilbert 已提交
2987 2988 2989 2990 2991 2992 2993 2994 2995
{
        int n;

	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
		scsi_debug_fake_rw = n;
		return count;
	}
	return -EINVAL;
}
2996
static DRIVER_ATTR_RW(fake_rw);
D
Douglas Gilbert 已提交
2997

2998
static ssize_t no_lun_0_show(struct device_driver *ddp, char *buf)
D
Douglas Gilbert 已提交
2999 3000 3001
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
}
3002 3003
static ssize_t no_lun_0_store(struct device_driver *ddp, const char *buf,
			      size_t count)
D
Douglas Gilbert 已提交
3004 3005 3006 3007 3008 3009 3010 3011 3012
{
        int n;

	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
		scsi_debug_no_lun_0 = n;
		return count;
	}
	return -EINVAL;
}
3013
static DRIVER_ATTR_RW(no_lun_0);
D
Douglas Gilbert 已提交
3014

3015
static ssize_t num_tgts_show(struct device_driver *ddp, char *buf)
L
Linus Torvalds 已提交
3016 3017 3018
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
}
3019 3020
static ssize_t num_tgts_store(struct device_driver *ddp, const char *buf,
			      size_t count)
L
Linus Torvalds 已提交
3021 3022 3023 3024 3025 3026 3027 3028 3029 3030
{
        int n;

	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
		scsi_debug_num_tgts = n;
		sdebug_max_tgts_luns();
		return count;
	}
	return -EINVAL;
}
3031
static DRIVER_ATTR_RW(num_tgts);
L
Linus Torvalds 已提交
3032

3033
static ssize_t dev_size_mb_show(struct device_driver *ddp, char *buf)
L
Linus Torvalds 已提交
3034 3035 3036
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
}
3037
static DRIVER_ATTR_RO(dev_size_mb);
L
Linus Torvalds 已提交
3038

3039
static ssize_t num_parts_show(struct device_driver *ddp, char *buf)
L
Linus Torvalds 已提交
3040 3041 3042
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
}
3043
static DRIVER_ATTR_RO(num_parts);
L
Linus Torvalds 已提交
3044

3045
static ssize_t every_nth_show(struct device_driver *ddp, char *buf)
L
Linus Torvalds 已提交
3046 3047 3048
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
}
3049 3050
static ssize_t every_nth_store(struct device_driver *ddp, const char *buf,
			       size_t count)
L
Linus Torvalds 已提交
3051 3052 3053 3054 3055 3056 3057 3058 3059 3060
{
        int nth;

	if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
		scsi_debug_every_nth = nth;
		scsi_debug_cmnd_count = 0;
		return count;
	}
	return -EINVAL;
}
3061
static DRIVER_ATTR_RW(every_nth);
L
Linus Torvalds 已提交
3062

3063
static ssize_t max_luns_show(struct device_driver *ddp, char *buf)
L
Linus Torvalds 已提交
3064 3065 3066
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
}
3067 3068
static ssize_t max_luns_store(struct device_driver *ddp, const char *buf,
			      size_t count)
L
Linus Torvalds 已提交
3069 3070 3071 3072 3073 3074 3075 3076 3077 3078
{
        int n;

	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
		scsi_debug_max_luns = n;
		sdebug_max_tgts_luns();
		return count;
	}
	return -EINVAL;
}
3079
static DRIVER_ATTR_RW(max_luns);
L
Linus Torvalds 已提交
3080

3081
static ssize_t max_queue_show(struct device_driver *ddp, char *buf)
3082 3083 3084
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_queue);
}
3085 3086
static ssize_t max_queue_store(struct device_driver *ddp, const char *buf,
			       size_t count)
3087 3088 3089 3090 3091 3092 3093 3094 3095 3096
{
        int n;

	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n > 0) &&
	    (n <= SCSI_DEBUG_CANQUEUE)) {
		scsi_debug_max_queue = n;
		return count;
	}
	return -EINVAL;
}
3097
static DRIVER_ATTR_RW(max_queue);
3098

3099
static ssize_t no_uld_show(struct device_driver *ddp, char *buf)
3100 3101 3102
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_uld);
}
3103
static DRIVER_ATTR_RO(no_uld);
3104

3105
static ssize_t scsi_level_show(struct device_driver *ddp, char *buf)
L
Linus Torvalds 已提交
3106 3107 3108
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
}
3109
static DRIVER_ATTR_RO(scsi_level);
L
Linus Torvalds 已提交
3110

3111
static ssize_t virtual_gb_show(struct device_driver *ddp, char *buf)
D
Douglas Gilbert 已提交
3112 3113 3114
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
}
3115 3116
static ssize_t virtual_gb_store(struct device_driver *ddp, const char *buf,
				size_t count)
D
Douglas Gilbert 已提交
3117 3118 3119 3120 3121
{
        int n;

	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
		scsi_debug_virtual_gb = n;
3122 3123 3124

		sdebug_capacity = get_sdebug_capacity();

D
Douglas Gilbert 已提交
3125 3126 3127 3128
		return count;
	}
	return -EINVAL;
}
3129
static DRIVER_ATTR_RW(virtual_gb);
D
Douglas Gilbert 已提交
3130

3131
static ssize_t add_host_show(struct device_driver *ddp, char *buf)
L
Linus Torvalds 已提交
3132 3133 3134 3135
{
        return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
}

3136 3137
static ssize_t add_host_store(struct device_driver *ddp, const char *buf,
			      size_t count)
L
Linus Torvalds 已提交
3138
{
3139
	int delta_hosts;
L
Linus Torvalds 已提交
3140

3141
	if (sscanf(buf, "%d", &delta_hosts) != 1)
L
Linus Torvalds 已提交
3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153
		return -EINVAL;
	if (delta_hosts > 0) {
		do {
			sdebug_add_adapter();
		} while (--delta_hosts);
	} else if (delta_hosts < 0) {
		do {
			sdebug_remove_adapter();
		} while (++delta_hosts);
	}
	return count;
}
3154
static DRIVER_ATTR_RW(add_host);
L
Linus Torvalds 已提交
3155

3156
static ssize_t vpd_use_hostno_show(struct device_driver *ddp, char *buf)
D
Douglas Gilbert 已提交
3157 3158 3159
{
	return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
}
3160 3161
static ssize_t vpd_use_hostno_store(struct device_driver *ddp, const char *buf,
				    size_t count)
D
Douglas Gilbert 已提交
3162 3163 3164 3165 3166 3167 3168 3169 3170
{
	int n;

	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
		scsi_debug_vpd_use_hostno = n;
		return count;
	}
	return -EINVAL;
}
3171
static DRIVER_ATTR_RW(vpd_use_hostno);
D
Douglas Gilbert 已提交
3172

3173
static ssize_t sector_size_show(struct device_driver *ddp, char *buf)
3174 3175 3176
{
	return scnprintf(buf, PAGE_SIZE, "%u\n", scsi_debug_sector_size);
}
3177
static DRIVER_ATTR_RO(sector_size);
3178

3179
static ssize_t dix_show(struct device_driver *ddp, char *buf)
3180 3181 3182
{
	return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dix);
}
3183
static DRIVER_ATTR_RO(dix);
3184

3185
static ssize_t dif_show(struct device_driver *ddp, char *buf)
3186 3187 3188
{
	return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dif);
}
3189
static DRIVER_ATTR_RO(dif);
3190

3191
static ssize_t guard_show(struct device_driver *ddp, char *buf)
3192
{
3193
	return scnprintf(buf, PAGE_SIZE, "%u\n", scsi_debug_guard);
3194
}
3195
static DRIVER_ATTR_RO(guard);
3196

3197
static ssize_t ato_show(struct device_driver *ddp, char *buf)
3198 3199 3200
{
	return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ato);
}
3201
static DRIVER_ATTR_RO(ato);
3202

3203
static ssize_t map_show(struct device_driver *ddp, char *buf)
3204 3205 3206
{
	ssize_t count;

3207
	if (!scsi_debug_lbp())
3208 3209 3210 3211 3212 3213 3214 3215 3216 3217
		return scnprintf(buf, PAGE_SIZE, "0-%u\n",
				 sdebug_store_sectors);

	count = bitmap_scnlistprintf(buf, PAGE_SIZE, map_storep, map_size);

	buf[count++] = '\n';
	buf[count++] = 0;

	return count;
}
3218
static DRIVER_ATTR_RO(map);
3219

3220
static ssize_t removable_show(struct device_driver *ddp, char *buf)
3221 3222 3223
{
	return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_removable ? 1 : 0);
}
3224 3225
static ssize_t removable_store(struct device_driver *ddp, const char *buf,
			       size_t count)
3226 3227 3228 3229 3230 3231 3232 3233 3234
{
	int n;

	if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
		scsi_debug_removable = (n > 0);
		return count;
	}
	return -EINVAL;
}
3235
static DRIVER_ATTR_RW(removable);
3236

3237
/* Note: The following array creates attribute files in the
D
Douglas Gilbert 已提交
3238 3239 3240 3241 3242
   /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
   files (over those found in the /sys/module/scsi_debug/parameters
   directory) is that auxiliary actions can be triggered when an attribute
   is changed. For example see: sdebug_add_host_store() above.
 */
3243

3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271
static struct attribute *sdebug_drv_attrs[] = {
	&driver_attr_delay.attr,
	&driver_attr_opts.attr,
	&driver_attr_ptype.attr,
	&driver_attr_dsense.attr,
	&driver_attr_fake_rw.attr,
	&driver_attr_no_lun_0.attr,
	&driver_attr_num_tgts.attr,
	&driver_attr_dev_size_mb.attr,
	&driver_attr_num_parts.attr,
	&driver_attr_every_nth.attr,
	&driver_attr_max_luns.attr,
	&driver_attr_max_queue.attr,
	&driver_attr_no_uld.attr,
	&driver_attr_scsi_level.attr,
	&driver_attr_virtual_gb.attr,
	&driver_attr_add_host.attr,
	&driver_attr_vpd_use_hostno.attr,
	&driver_attr_sector_size.attr,
	&driver_attr_dix.attr,
	&driver_attr_dif.attr,
	&driver_attr_guard.attr,
	&driver_attr_ato.attr,
	&driver_attr_map.attr,
	&driver_attr_removable.attr,
	NULL,
};
ATTRIBUTE_GROUPS(sdebug_drv);
L
Linus Torvalds 已提交
3272

3273
static struct device *pseudo_primary;
3274

L
Linus Torvalds 已提交
3275 3276
static int __init scsi_debug_init(void)
{
3277
	unsigned long sz;
L
Linus Torvalds 已提交
3278 3279
	int host_to_add;
	int k;
3280
	int ret;
L
Linus Torvalds 已提交
3281

3282 3283 3284 3285 3286 3287 3288
	switch (scsi_debug_sector_size) {
	case  512:
	case 1024:
	case 2048:
	case 4096:
		break;
	default:
3289
		printk(KERN_ERR "scsi_debug_init: invalid sector_size %d\n",
3290 3291 3292 3293
		       scsi_debug_sector_size);
		return -EINVAL;
	}

3294 3295 3296 3297
	switch (scsi_debug_dif) {

	case SD_DIF_TYPE0_PROTECTION:
	case SD_DIF_TYPE1_PROTECTION:
3298
	case SD_DIF_TYPE2_PROTECTION:
3299 3300 3301 3302
	case SD_DIF_TYPE3_PROTECTION:
		break;

	default:
3303
		printk(KERN_ERR "scsi_debug_init: dif must be 0, 1, 2 or 3\n");
3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316
		return -EINVAL;
	}

	if (scsi_debug_guard > 1) {
		printk(KERN_ERR "scsi_debug_init: guard must be 0 or 1\n");
		return -EINVAL;
	}

	if (scsi_debug_ato > 1) {
		printk(KERN_ERR "scsi_debug_init: ato must be 0 or 1\n");
		return -EINVAL;
	}

3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328
	if (scsi_debug_physblk_exp > 15) {
		printk(KERN_ERR "scsi_debug_init: invalid physblk_exp %u\n",
		       scsi_debug_physblk_exp);
		return -EINVAL;
	}

	if (scsi_debug_lowest_aligned > 0x3fff) {
		printk(KERN_ERR "scsi_debug_init: lowest_aligned too big: %u\n",
		       scsi_debug_lowest_aligned);
		return -EINVAL;
	}

L
Linus Torvalds 已提交
3329 3330
	if (scsi_debug_dev_size_mb < 1)
		scsi_debug_dev_size_mb = 1;  /* force minimum 1 MB ramdisk */
3331
	sz = (unsigned long)scsi_debug_dev_size_mb * 1048576;
3332
	sdebug_store_sectors = sz / scsi_debug_sector_size;
3333
	sdebug_capacity = get_sdebug_capacity();
L
Linus Torvalds 已提交
3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358

	/* play around with geometry, don't waste too much on track 0 */
	sdebug_heads = 8;
	sdebug_sectors_per = 32;
	if (scsi_debug_dev_size_mb >= 16)
		sdebug_heads = 32;
	else if (scsi_debug_dev_size_mb >= 256)
		sdebug_heads = 64;
	sdebug_cylinders_per = (unsigned long)sdebug_capacity /
			       (sdebug_sectors_per * sdebug_heads);
	if (sdebug_cylinders_per >= 1024) {
		/* other LLDs do this; implies >= 1GB ram disk ... */
		sdebug_heads = 255;
		sdebug_sectors_per = 63;
		sdebug_cylinders_per = (unsigned long)sdebug_capacity /
			       (sdebug_sectors_per * sdebug_heads);
	}

	fake_storep = vmalloc(sz);
	if (NULL == fake_storep) {
		printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
		return -ENOMEM;
	}
	memset(fake_storep, 0, sz);
	if (scsi_debug_num_parts > 0)
3359
		sdebug_build_parts(fake_storep, sz);
L
Linus Torvalds 已提交
3360

3361
	if (scsi_debug_dix) {
3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378
		int dif_size;

		dif_size = sdebug_store_sectors * sizeof(struct sd_dif_tuple);
		dif_storep = vmalloc(dif_size);

		printk(KERN_ERR "scsi_debug_init: dif_storep %u bytes @ %p\n",
		       dif_size, dif_storep);

		if (dif_storep == NULL) {
			printk(KERN_ERR "scsi_debug_init: out of mem. (DIX)\n");
			ret = -ENOMEM;
			goto free_vm;
		}

		memset(dif_storep, 0xff, dif_size);
	}

3379 3380
	/* Logical Block Provisioning */
	if (scsi_debug_lbp()) {
3381 3382 3383 3384 3385 3386 3387 3388 3389 3390
		scsi_debug_unmap_max_blocks =
			clamp(scsi_debug_unmap_max_blocks, 0U, 0xffffffffU);

		scsi_debug_unmap_max_desc =
			clamp(scsi_debug_unmap_max_desc, 0U, 256U);

		scsi_debug_unmap_granularity =
			clamp(scsi_debug_unmap_granularity, 1U, 0xffffffffU);

		if (scsi_debug_unmap_alignment &&
3391 3392
		    scsi_debug_unmap_granularity <=
		    scsi_debug_unmap_alignment) {
3393
			printk(KERN_ERR
3394
			       "%s: ERR: unmap_granularity <= unmap_alignment\n",
3395 3396 3397 3398
			       __func__);
			return -EINVAL;
		}

3399 3400
		map_size = lba_to_map_index(sdebug_store_sectors - 1) + 1;
		map_storep = vmalloc(BITS_TO_LONGS(map_size) * sizeof(long));
3401 3402 3403 3404 3405 3406 3407 3408 3409 3410

		printk(KERN_INFO "scsi_debug_init: %lu provisioning blocks\n",
		       map_size);

		if (map_storep == NULL) {
			printk(KERN_ERR "scsi_debug_init: out of mem. (MAP)\n");
			ret = -ENOMEM;
			goto free_vm;
		}

3411
		bitmap_zero(map_storep, map_size);
3412 3413 3414 3415 3416 3417

		/* Map first 1KB for partition table */
		if (scsi_debug_num_parts)
			map_region(0, 2);
	}

3418 3419 3420 3421
	pseudo_primary = root_device_register("pseudo_0");
	if (IS_ERR(pseudo_primary)) {
		printk(KERN_WARNING "scsi_debug: root_device_register() error\n");
		ret = PTR_ERR(pseudo_primary);
3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435
		goto free_vm;
	}
	ret = bus_register(&pseudo_lld_bus);
	if (ret < 0) {
		printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
			ret);
		goto dev_unreg;
	}
	ret = driver_register(&sdebug_driverfs_driver);
	if (ret < 0) {
		printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
			ret);
		goto bus_unreg;
	}
L
Linus Torvalds 已提交
3436

3437
	init_all_queued();
L
Linus Torvalds 已提交
3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454

	host_to_add = scsi_debug_add_host;
        scsi_debug_add_host = 0;

        for (k = 0; k < host_to_add; k++) {
                if (sdebug_add_adapter()) {
                        printk(KERN_ERR "scsi_debug_init: "
                               "sdebug_add_adapter failed k=%d\n", k);
                        break;
                }
        }

	if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
		printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
		       scsi_debug_add_host);
	}
	return 0;
3455 3456 3457 3458

bus_unreg:
	bus_unregister(&pseudo_lld_bus);
dev_unreg:
3459
	root_device_unregister(pseudo_primary);
3460
free_vm:
3461 3462
	if (map_storep)
		vfree(map_storep);
3463 3464
	if (dif_storep)
		vfree(dif_storep);
3465 3466 3467
	vfree(fake_storep);

	return ret;
L
Linus Torvalds 已提交
3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478
}

static void __exit scsi_debug_exit(void)
{
	int k = scsi_debug_add_host;

	stop_all_queued();
	for (; k; k--)
		sdebug_remove_adapter();
	driver_unregister(&sdebug_driverfs_driver);
	bus_unregister(&pseudo_lld_bus);
3479
	root_device_unregister(pseudo_primary);
L
Linus Torvalds 已提交
3480

3481 3482 3483
	if (dif_storep)
		vfree(dif_storep);

L
Linus Torvalds 已提交
3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502
	vfree(fake_storep);
}

device_initcall(scsi_debug_init);
module_exit(scsi_debug_exit);

static void sdebug_release_adapter(struct device * dev)
{
        struct sdebug_host_info *sdbg_host;

	sdbg_host = to_sdebug_host(dev);
        kfree(sdbg_host);
}

static int sdebug_add_adapter(void)
{
	int k, devs_per_host;
        int error = 0;
        struct sdebug_host_info *sdbg_host;
3503
	struct sdebug_dev_info *sdbg_devinfo, *tmp;
L
Linus Torvalds 已提交
3504

D
Douglas Gilbert 已提交
3505
        sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
L
Linus Torvalds 已提交
3506 3507
        if (NULL == sdbg_host) {
                printk(KERN_ERR "%s: out of memory at line %d\n",
3508
                       __func__, __LINE__);
L
Linus Torvalds 已提交
3509 3510 3511 3512 3513 3514 3515
                return -ENOMEM;
        }

        INIT_LIST_HEAD(&sdbg_host->dev_info_list);

	devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
        for (k = 0; k < devs_per_host; k++) {
3516 3517
		sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL);
		if (!sdbg_devinfo) {
L
Linus Torvalds 已提交
3518
                        printk(KERN_ERR "%s: out of memory at line %d\n",
3519
                               __func__, __LINE__);
L
Linus Torvalds 已提交
3520 3521 3522 3523 3524 3525 3526 3527 3528 3529
                        error = -ENOMEM;
			goto clean;
                }
        }

        spin_lock(&sdebug_host_list_lock);
        list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
        spin_unlock(&sdebug_host_list_lock);

        sdbg_host->dev.bus = &pseudo_lld_bus;
3530
        sdbg_host->dev.parent = pseudo_primary;
L
Linus Torvalds 已提交
3531
        sdbg_host->dev.release = &sdebug_release_adapter;
3532
        dev_set_name(&sdbg_host->dev, "adapter%d", scsi_debug_add_host);
L
Linus Torvalds 已提交
3533 3534 3535 3536 3537 3538 3539 3540 3541 3542

        error = device_register(&sdbg_host->dev);

        if (error)
		goto clean;

	++scsi_debug_add_host;
        return error;

clean:
3543 3544
	list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
				 dev_list) {
L
Linus Torvalds 已提交
3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571
		list_del(&sdbg_devinfo->dev_list);
		kfree(sdbg_devinfo);
	}

	kfree(sdbg_host);
        return error;
}

static void sdebug_remove_adapter(void)
{
        struct sdebug_host_info * sdbg_host = NULL;

        spin_lock(&sdebug_host_list_lock);
        if (!list_empty(&sdebug_host_list)) {
                sdbg_host = list_entry(sdebug_host_list.prev,
                                       struct sdebug_host_info, host_list);
		list_del(&sdbg_host->host_list);
	}
        spin_unlock(&sdebug_host_list_lock);

	if (!sdbg_host)
		return;

        device_unregister(&sdbg_host->dev);
        --scsi_debug_add_host;
}

3572
static
J
Jeff Garzik 已提交
3573
int scsi_debug_queuecommand_lck(struct scsi_cmnd *SCpnt, done_funct_t done)
3574 3575 3576 3577 3578
{
	unsigned char *cmd = (unsigned char *) SCpnt->cmnd;
	int len, k;
	unsigned int num;
	unsigned long long lba;
3579
	u32 ei_lba;
3580 3581 3582 3583 3584
	int errsts = 0;
	int target = SCpnt->device->id;
	struct sdebug_dev_info *devip = NULL;
	int inj_recovered = 0;
	int inj_transport = 0;
3585 3586
	int inj_dif = 0;
	int inj_dix = 0;
3587
	int inj_short = 0;
3588
	int delay_override = 0;
3589
	int unmap = 0;
3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621

	scsi_set_resid(SCpnt, 0);
	if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) {
		printk(KERN_INFO "scsi_debug: cmd ");
		for (k = 0, len = SCpnt->cmd_len; k < len; ++k)
			printk("%02x ", (int)cmd[k]);
		printk("\n");
	}

	if (target == SCpnt->device->host->hostt->this_id) {
		printk(KERN_INFO "scsi_debug: initiator's id used as "
		       "target!\n");
		return schedule_resp(SCpnt, NULL, done,
				     DID_NO_CONNECT << 16, 0);
	}

	if ((SCpnt->device->lun >= scsi_debug_max_luns) &&
	    (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS))
		return schedule_resp(SCpnt, NULL, done,
				     DID_NO_CONNECT << 16, 0);
	devip = devInfoReg(SCpnt->device);
	if (NULL == devip)
		return schedule_resp(SCpnt, NULL, done,
				     DID_NO_CONNECT << 16, 0);

	if ((scsi_debug_every_nth != 0) &&
	    (++scsi_debug_cmnd_count >= abs(scsi_debug_every_nth))) {
		scsi_debug_cmnd_count = 0;
		if (scsi_debug_every_nth < -1)
			scsi_debug_every_nth = -1;
		if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
			return 0; /* ignore command causing timeout */
3622 3623 3624
		else if (SCSI_DEBUG_OPT_MAC_TIMEOUT & scsi_debug_opts &&
			 scsi_medium_access_command(SCpnt))
			return 0; /* time out reads and writes */
3625 3626 3627 3628
		else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
			inj_recovered = 1; /* to reads and writes below */
		else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts)
			inj_transport = 1; /* to reads and writes below */
3629 3630 3631 3632
		else if (SCSI_DEBUG_OPT_DIF_ERR & scsi_debug_opts)
			inj_dif = 1; /* to reads and writes below */
		else if (SCSI_DEBUG_OPT_DIX_ERR & scsi_debug_opts)
			inj_dix = 1; /* to reads and writes below */
3633 3634
		else if (SCSI_DEBUG_OPT_SHORT_TRANSFER & scsi_debug_opts)
			inj_short = 1;
3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699
	}

	if (devip->wlun) {
		switch (*cmd) {
		case INQUIRY:
		case REQUEST_SENSE:
		case TEST_UNIT_READY:
		case REPORT_LUNS:
			break;  /* only allowable wlun commands */
		default:
			if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
				printk(KERN_INFO "scsi_debug: Opcode: 0x%x "
				       "not supported for wlun\n", *cmd);
			mk_sense_buffer(devip, ILLEGAL_REQUEST,
					INVALID_OPCODE, 0);
			errsts = check_condition_result;
			return schedule_resp(SCpnt, devip, done, errsts,
					     0);
		}
	}

	switch (*cmd) {
	case INQUIRY:     /* mandatory, ignore unit attention */
		delay_override = 1;
		errsts = resp_inquiry(SCpnt, target, devip);
		break;
	case REQUEST_SENSE:	/* mandatory, ignore unit attention */
		delay_override = 1;
		errsts = resp_requests(SCpnt, devip);
		break;
	case REZERO_UNIT:	/* actually this is REWIND for SSC */
	case START_STOP:
		errsts = resp_start_stop(SCpnt, devip);
		break;
	case ALLOW_MEDIUM_REMOVAL:
		errsts = check_readiness(SCpnt, 1, devip);
		if (errsts)
			break;
		if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
			printk(KERN_INFO "scsi_debug: Medium removal %s\n",
			       cmd[4] ? "inhibited" : "enabled");
		break;
	case SEND_DIAGNOSTIC:     /* mandatory */
		errsts = check_readiness(SCpnt, 1, devip);
		break;
	case TEST_UNIT_READY:     /* mandatory */
		delay_override = 1;
		errsts = check_readiness(SCpnt, 0, devip);
		break;
	case RESERVE:
		errsts = check_readiness(SCpnt, 1, devip);
		break;
	case RESERVE_10:
		errsts = check_readiness(SCpnt, 1, devip);
		break;
	case RELEASE:
		errsts = check_readiness(SCpnt, 1, devip);
		break;
	case RELEASE_10:
		errsts = check_readiness(SCpnt, 1, devip);
		break;
	case READ_CAPACITY:
		errsts = resp_readcap(SCpnt, devip);
		break;
	case SERVICE_ACTION_IN:
3700 3701 3702 3703
		if (cmd[1] == SAI_READ_CAPACITY_16)
			errsts = resp_readcap16(SCpnt, devip);
		else if (cmd[1] == SAI_GET_LBA_STATUS) {

3704
			if (scsi_debug_lbp() == 0) {
3705 3706 3707 3708 3709 3710
				mk_sense_buffer(devip, ILLEGAL_REQUEST,
						INVALID_COMMAND_OPCODE, 0);
				errsts = check_condition_result;
			} else
				errsts = resp_get_lba_status(SCpnt, devip);
		} else {
3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727
			mk_sense_buffer(devip, ILLEGAL_REQUEST,
					INVALID_OPCODE, 0);
			errsts = check_condition_result;
		}
		break;
	case MAINTENANCE_IN:
		if (MI_REPORT_TARGET_PGS != cmd[1]) {
			mk_sense_buffer(devip, ILLEGAL_REQUEST,
					INVALID_OPCODE, 0);
			errsts = check_condition_result;
			break;
		}
		errsts = resp_report_tgtpgs(SCpnt, devip);
		break;
	case READ_16:
	case READ_12:
	case READ_10:
3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742
		/* READ{10,12,16} and DIF Type 2 are natural enemies */
		if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
		    cmd[1] & 0xe0) {
			mk_sense_buffer(devip, ILLEGAL_REQUEST,
					INVALID_COMMAND_OPCODE, 0);
			errsts = check_condition_result;
			break;
		}

		if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
		     scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
		    (cmd[1] & 0xe0) == 0)
			printk(KERN_ERR "Unprotected RD/WR to DIF device\n");

		/* fall through */
3743
	case READ_6:
3744
read:
3745 3746 3747 3748 3749
		errsts = check_readiness(SCpnt, 0, devip);
		if (errsts)
			break;
		if (scsi_debug_fake_rw)
			break;
3750
		get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3751 3752 3753 3754

		if (inj_short)
			num /= 2;

3755
		errsts = resp_read(SCpnt, lba, num, devip, ei_lba);
3756 3757 3758 3759 3760 3761 3762 3763
		if (inj_recovered && (0 == errsts)) {
			mk_sense_buffer(devip, RECOVERED_ERROR,
					THRESHOLD_EXCEEDED, 0);
			errsts = check_condition_result;
		} else if (inj_transport && (0 == errsts)) {
			mk_sense_buffer(devip, ABORTED_COMMAND,
					TRANSPORT_PROBLEM, ACK_NAK_TO);
			errsts = check_condition_result;
3764 3765 3766 3767 3768 3769
		} else if (inj_dif && (0 == errsts)) {
			mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, 1);
			errsts = illegal_condition_result;
		} else if (inj_dix && (0 == errsts)) {
			mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, 1);
			errsts = illegal_condition_result;
3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781
		}
		break;
	case REPORT_LUNS:	/* mandatory, ignore unit attention */
		delay_override = 1;
		errsts = resp_report_luns(SCpnt, devip);
		break;
	case VERIFY:		/* 10 byte SBC-2 command */
		errsts = check_readiness(SCpnt, 0, devip);
		break;
	case WRITE_16:
	case WRITE_12:
	case WRITE_10:
3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796
		/* WRITE{10,12,16} and DIF Type 2 are natural enemies */
		if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
		    cmd[1] & 0xe0) {
			mk_sense_buffer(devip, ILLEGAL_REQUEST,
					INVALID_COMMAND_OPCODE, 0);
			errsts = check_condition_result;
			break;
		}

		if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
		     scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
		    (cmd[1] & 0xe0) == 0)
			printk(KERN_ERR "Unprotected RD/WR to DIF device\n");

		/* fall through */
3797
	case WRITE_6:
3798
write:
3799 3800 3801 3802 3803
		errsts = check_readiness(SCpnt, 0, devip);
		if (errsts)
			break;
		if (scsi_debug_fake_rw)
			break;
3804 3805
		get_data_transfer_info(cmd, &lba, &num, &ei_lba);
		errsts = resp_write(SCpnt, lba, num, devip, ei_lba);
3806 3807 3808 3809
		if (inj_recovered && (0 == errsts)) {
			mk_sense_buffer(devip, RECOVERED_ERROR,
					THRESHOLD_EXCEEDED, 0);
			errsts = check_condition_result;
3810 3811 3812 3813 3814 3815
		} else if (inj_dif && (0 == errsts)) {
			mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, 1);
			errsts = illegal_condition_result;
		} else if (inj_dix && (0 == errsts)) {
			mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, 1);
			errsts = illegal_condition_result;
3816 3817
		}
		break;
3818
	case WRITE_SAME_16:
3819
	case WRITE_SAME:
3820
		if (cmd[1] & 0x8) {
3821 3822
			if ((*cmd == WRITE_SAME_16 && scsi_debug_lbpws == 0) ||
			    (*cmd == WRITE_SAME && scsi_debug_lbpws10 == 0)) {
3823 3824 3825 3826 3827 3828 3829 3830
				mk_sense_buffer(devip, ILLEGAL_REQUEST,
						INVALID_FIELD_IN_CDB, 0);
				errsts = check_condition_result;
			} else
				unmap = 1;
		}
		if (errsts)
			break;
3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841
		errsts = check_readiness(SCpnt, 0, devip);
		if (errsts)
			break;
		get_data_transfer_info(cmd, &lba, &num, &ei_lba);
		errsts = resp_write_same(SCpnt, lba, num, devip, ei_lba, unmap);
		break;
	case UNMAP:
		errsts = check_readiness(SCpnt, 0, devip);
		if (errsts)
			break;

3842
		if (scsi_debug_unmap_max_desc == 0 || scsi_debug_lbpu == 0) {
3843 3844 3845 3846 3847 3848
			mk_sense_buffer(devip, ILLEGAL_REQUEST,
					INVALID_COMMAND_OPCODE, 0);
			errsts = check_condition_result;
		} else
			errsts = resp_unmap(SCpnt, devip);
		break;
3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881
	case MODE_SENSE:
	case MODE_SENSE_10:
		errsts = resp_mode_sense(SCpnt, target, devip);
		break;
	case MODE_SELECT:
		errsts = resp_mode_select(SCpnt, 1, devip);
		break;
	case MODE_SELECT_10:
		errsts = resp_mode_select(SCpnt, 0, devip);
		break;
	case LOG_SENSE:
		errsts = resp_log_sense(SCpnt, devip);
		break;
	case SYNCHRONIZE_CACHE:
		delay_override = 1;
		errsts = check_readiness(SCpnt, 0, devip);
		break;
	case WRITE_BUFFER:
		errsts = check_readiness(SCpnt, 1, devip);
		break;
	case XDWRITEREAD_10:
		if (!scsi_bidi_cmnd(SCpnt)) {
			mk_sense_buffer(devip, ILLEGAL_REQUEST,
					INVALID_FIELD_IN_CDB, 0);
			errsts = check_condition_result;
			break;
		}

		errsts = check_readiness(SCpnt, 0, devip);
		if (errsts)
			break;
		if (scsi_debug_fake_rw)
			break;
3882 3883
		get_data_transfer_info(cmd, &lba, &num, &ei_lba);
		errsts = resp_read(SCpnt, lba, num, devip, ei_lba);
3884 3885
		if (errsts)
			break;
3886
		errsts = resp_write(SCpnt, lba, num, devip, ei_lba);
3887 3888 3889 3890
		if (errsts)
			break;
		errsts = resp_xdwriteread(SCpnt, lba, num, devip);
		break;
3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913
	case VARIABLE_LENGTH_CMD:
		if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION) {

			if ((cmd[10] & 0xe0) == 0)
				printk(KERN_ERR
				       "Unprotected RD/WR to DIF device\n");

			if (cmd[9] == READ_32) {
				BUG_ON(SCpnt->cmd_len < 32);
				goto read;
			}

			if (cmd[9] == WRITE_32) {
				BUG_ON(SCpnt->cmd_len < 32);
				goto write;
			}
		}

		mk_sense_buffer(devip, ILLEGAL_REQUEST,
				INVALID_FIELD_IN_CDB, 0);
		errsts = check_condition_result;
		break;

3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928
	default:
		if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
			printk(KERN_INFO "scsi_debug: Opcode: 0x%x not "
			       "supported\n", *cmd);
		errsts = check_readiness(SCpnt, 1, devip);
		if (errsts)
			break;	/* Unit attention takes precedence */
		mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
		errsts = check_condition_result;
		break;
	}
	return schedule_resp(SCpnt, devip, done, errsts,
			     (delay_override ? 0 : scsi_debug_delay));
}

J
Jeff Garzik 已提交
3929 3930
static DEF_SCSI_QCMD(scsi_debug_queuecommand)

3931
static struct scsi_host_template sdebug_driver_template = {
A
Al Viro 已提交
3932 3933
	.show_info =		scsi_debug_show_info,
	.write_info =		scsi_debug_write_info,
3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955
	.proc_name =		sdebug_proc_name,
	.name =			"SCSI DEBUG",
	.info =			scsi_debug_info,
	.slave_alloc =		scsi_debug_slave_alloc,
	.slave_configure =	scsi_debug_slave_configure,
	.slave_destroy =	scsi_debug_slave_destroy,
	.ioctl =		scsi_debug_ioctl,
	.queuecommand =		scsi_debug_queuecommand,
	.eh_abort_handler =	scsi_debug_abort,
	.eh_bus_reset_handler = scsi_debug_bus_reset,
	.eh_device_reset_handler = scsi_debug_device_reset,
	.eh_host_reset_handler = scsi_debug_host_reset,
	.bios_param =		scsi_debug_biosparam,
	.can_queue =		SCSI_DEBUG_CANQUEUE,
	.this_id =		7,
	.sg_tablesize =		256,
	.cmd_per_lun =		16,
	.max_sectors =		0xffff,
	.use_clustering = 	DISABLE_CLUSTERING,
	.module =		THIS_MODULE,
};

L
Linus Torvalds 已提交
3956 3957 3958 3959 3960
static int sdebug_driver_probe(struct device * dev)
{
        int error = 0;
        struct sdebug_host_info *sdbg_host;
        struct Scsi_Host *hpnt;
3961
	int host_prot;
L
Linus Torvalds 已提交
3962 3963 3964

	sdbg_host = to_sdebug_host(dev);

3965
	sdebug_driver_template.can_queue = scsi_debug_max_queue;
3966 3967
	if (scsi_debug_clustering)
		sdebug_driver_template.use_clustering = ENABLE_CLUSTERING;
3968 3969 3970 3971
	hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
	if (NULL == hpnt) {
		printk(KERN_ERR "%s: scsi_register failed\n", __func__);
		error = -ENODEV;
L
Linus Torvalds 已提交
3972
		return error;
3973
	}
L
Linus Torvalds 已提交
3974 3975 3976 3977 3978 3979 3980

        sdbg_host->shost = hpnt;
	*((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
	if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
		hpnt->max_id = scsi_debug_num_tgts + 1;
	else
		hpnt->max_id = scsi_debug_num_tgts;
D
Douglas Gilbert 已提交
3981
	hpnt->max_lun = SAM2_WLUN_REPORT_LUNS;	/* = scsi_debug_max_luns; */
L
Linus Torvalds 已提交
3982

3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026
	host_prot = 0;

	switch (scsi_debug_dif) {

	case SD_DIF_TYPE1_PROTECTION:
		host_prot = SHOST_DIF_TYPE1_PROTECTION;
		if (scsi_debug_dix)
			host_prot |= SHOST_DIX_TYPE1_PROTECTION;
		break;

	case SD_DIF_TYPE2_PROTECTION:
		host_prot = SHOST_DIF_TYPE2_PROTECTION;
		if (scsi_debug_dix)
			host_prot |= SHOST_DIX_TYPE2_PROTECTION;
		break;

	case SD_DIF_TYPE3_PROTECTION:
		host_prot = SHOST_DIF_TYPE3_PROTECTION;
		if (scsi_debug_dix)
			host_prot |= SHOST_DIX_TYPE3_PROTECTION;
		break;

	default:
		if (scsi_debug_dix)
			host_prot |= SHOST_DIX_TYPE0_PROTECTION;
		break;
	}

	scsi_host_set_prot(hpnt, host_prot);

	printk(KERN_INFO "scsi_debug: host protection%s%s%s%s%s%s%s\n",
	       (host_prot & SHOST_DIF_TYPE1_PROTECTION) ? " DIF1" : "",
	       (host_prot & SHOST_DIF_TYPE2_PROTECTION) ? " DIF2" : "",
	       (host_prot & SHOST_DIF_TYPE3_PROTECTION) ? " DIF3" : "",
	       (host_prot & SHOST_DIX_TYPE0_PROTECTION) ? " DIX0" : "",
	       (host_prot & SHOST_DIX_TYPE1_PROTECTION) ? " DIX1" : "",
	       (host_prot & SHOST_DIX_TYPE2_PROTECTION) ? " DIX2" : "",
	       (host_prot & SHOST_DIX_TYPE3_PROTECTION) ? " DIX3" : "");

	if (scsi_debug_guard == 1)
		scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_IP);
	else
		scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_CRC);

L
Linus Torvalds 已提交
4027 4028
        error = scsi_add_host(hpnt, &sdbg_host->dev);
        if (error) {
4029
                printk(KERN_ERR "%s: scsi_add_host failed\n", __func__);
L
Linus Torvalds 已提交
4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041
                error = -ENODEV;
		scsi_host_put(hpnt);
        } else
		scsi_scan_host(hpnt);


        return error;
}

static int sdebug_driver_remove(struct device * dev)
{
        struct sdebug_host_info *sdbg_host;
4042
	struct sdebug_dev_info *sdbg_devinfo, *tmp;
L
Linus Torvalds 已提交
4043 4044 4045 4046 4047

	sdbg_host = to_sdebug_host(dev);

	if (!sdbg_host) {
		printk(KERN_ERR "%s: Unable to locate host info\n",
4048
		       __func__);
L
Linus Torvalds 已提交
4049 4050 4051 4052 4053
		return -ENODEV;
	}

        scsi_remove_host(sdbg_host->shost);

4054 4055
	list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
				 dev_list) {
L
Linus Torvalds 已提交
4056 4057 4058 4059 4060 4061 4062 4063
                list_del(&sdbg_devinfo->dev_list);
                kfree(sdbg_devinfo);
        }

        scsi_host_put(sdbg_host->shost);
        return 0;
}

4064 4065
static int pseudo_lld_bus_match(struct device *dev,
				struct device_driver *dev_driver)
L
Linus Torvalds 已提交
4066
{
4067
	return 1;
L
Linus Torvalds 已提交
4068
}
4069 4070 4071 4072 4073 4074

static struct bus_type pseudo_lld_bus = {
	.name = "pseudo",
	.match = pseudo_lld_bus_match,
	.probe = sdebug_driver_probe,
	.remove = sdebug_driver_remove,
4075
	.drv_groups = sdebug_drv_groups,
4076
};