]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - drivers/scsi/scsi_debug.c
projects / mirror_ubuntu-zesty-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzi...
[mirror_ubuntu-zesty-kernel.git] / drivers / scsi / scsi_debug.c
CommitLineData
1da177e4 1/*
1da177e4
LT		 2 * vvvvvvvvvvvvvvvvvvvvvvv Original vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
3 * Copyright (C) 1992 Eric Youngdale
4 * Simulate a host adapter with 2 disks attached. Do a lot of checking
5 * to make sure that we are not getting blocks mixed up, and PANIC if
6 * anything out of the ordinary is seen.
7 * ^^^^^^^^^^^^^^^^^^^^^^^ Original ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 *
9 * This version is more generic, simulating a variable number of disk
23183910
DG		 10 * (or disk like devices) sharing a common amount of RAM. To be more
11 * realistic, the simulated devices have the transport attributes of
12 * SAS disks.
1da177e4
LT		 13 *
14 *
15 * For documentation see http://www.torque.net/sg/sdebug26.html
16 *
17 * D. Gilbert (dpg) work for Magneto-Optical device test [20010421]
18 * dpg: work for devfs large number of disks [20010809]
19 * forked for lk 2.5 series [20011216, 20020101]
20 * use vmalloc() more inquiry+mode_sense [20020302]
21 * add timers for delayed responses [20020721]
22 * Patrick Mansfield <patmans@us.ibm.com> max_luns+scsi_level [20021031]
23 * Mike Anderson <andmike@us.ibm.com> sysfs work [20021118]
24 * dpg: change style of boot options to "scsi_debug.num_tgts=2" and
25 * module options to "modprobe scsi_debug num_tgts=2" [20021221]
26 */
27
1da177e4
LT		 28#include <linux/module.h>
29
30#include <linux/kernel.h>
1da177e4
LT		 31#include <linux/errno.h>
32#include <linux/timer.h>
33#include <linux/types.h>
34#include <linux/string.h>
35#include <linux/genhd.h>
36#include <linux/fs.h>
37#include <linux/init.h>
38#include <linux/proc_fs.h>
1da177e4
LT		 39#include <linux/vmalloc.h>
40#include <linux/moduleparam.h>
852e034d 41#include <linux/scatterlist.h>
1da177e4
LT		 42
43#include <linux/blkdev.h>
44#include "scsi.h"
45#include <scsi/scsi_host.h>
46#include <scsi/scsicam.h>
47
48#include <linux/stat.h>
49
1da177e4
LT		 50#include "scsi_logging.h"
51#include "scsi_debug.h"
52
6f3cbf55
DG		 53#define SCSI_DEBUG_VERSION "1.81"
54static const char * scsi_debug_version_date = "20070104";
1da177e4 55
6f3cbf55 56/* Additional Sense Code (ASC) */
c65b1445
DG		 57#define NO_ADDITIONAL_SENSE 0x0
58#define LOGICAL_UNIT_NOT_READY 0x4
1da177e4 59#define UNRECOVERED_READ_ERR 0x11
c65b1445 60#define PARAMETER_LIST_LENGTH_ERR 0x1a
1da177e4
LT		 61#define INVALID_OPCODE 0x20
62#define ADDR_OUT_OF_RANGE 0x21
63#define INVALID_FIELD_IN_CDB 0x24
c65b1445 64#define INVALID_FIELD_IN_PARAM_LIST 0x26
1da177e4
LT		 65#define POWERON_RESET 0x29
66#define SAVING_PARAMS_UNSUP 0x39
6f3cbf55 67#define TRANSPORT_PROBLEM 0x4b
c65b1445
DG		 68#define THRESHOLD_EXCEEDED 0x5d
69#define LOW_POWER_COND_ON 0x5e
1da177e4 70
6f3cbf55
DG		 71/* Additional Sense Code Qualifier (ASCQ) */
72#define ACK_NAK_TO 0x3
73
1da177e4
LT		 74#define SDEBUG_TAGGED_QUEUING 0 /* 0 | MSG_SIMPLE_TAG | MSG_ORDERED_TAG */
75
76/* Default values for driver parameters */
77#define DEF_NUM_HOST 1
78#define DEF_NUM_TGTS 1
79#define DEF_MAX_LUNS 1
80/* With these defaults, this driver will make 1 host with 1 target
81 * (id 0) containing 1 logical unit (lun 0). That is 1 device.
82 */
83#define DEF_DELAY 1
84#define DEF_DEV_SIZE_MB 8
85#define DEF_EVERY_NTH 0
86#define DEF_NUM_PARTS 0
87#define DEF_OPTS 0
88#define DEF_SCSI_LEVEL 5 /* INQUIRY, byte2 [5->SPC-3] */
89#define DEF_PTYPE 0
90#define DEF_D_SENSE 0
c65b1445
DG		 91#define DEF_NO_LUN_0 0
92#define DEF_VIRTUAL_GB 0
23183910
DG		 93#define DEF_FAKE_RW 0
94#define DEF_VPD_USE_HOSTNO 1
1da177e4
LT		 95
96/* bit mask values for scsi_debug_opts */
97#define SCSI_DEBUG_OPT_NOISE 1
98#define SCSI_DEBUG_OPT_MEDIUM_ERR 2
99#define SCSI_DEBUG_OPT_TIMEOUT 4
100#define SCSI_DEBUG_OPT_RECOVERED_ERR 8
6f3cbf55 101#define SCSI_DEBUG_OPT_TRANSPORT_ERR 16
1da177e4
LT		 102/* When "every_nth" > 0 then modulo "every_nth" commands:
103 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
104 * - a RECOVERED_ERROR is simulated on successful read and write
105 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
6f3cbf55
DG		 106 * - a TRANSPORT_ERROR is simulated on successful read and write
107 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
1da177e4
LT		 108 *
109 * When "every_nth" < 0 then after "- every_nth" commands:
110 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
111 * - a RECOVERED_ERROR is simulated on successful read and write
112 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
6f3cbf55
DG		 113 * - a TRANSPORT_ERROR is simulated on successful read and write
114 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set.
1da177e4
LT		 115 * This will continue until some other action occurs (e.g. the user
116 * writing a new value (other than -1 or 1) to every_nth via sysfs).
117 */
118
119/* when 1==SCSI_DEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
120 * sector on read commands: */
121#define OPT_MEDIUM_ERR_ADDR 0x1234 /* that's sector 4660 in decimal */
122
123/* If REPORT LUNS has luns >= 256 it can choose "flat space" (value 1)
124 * or "peripheral device" addressing (value 0) */
125#define SAM2_LUN_ADDRESS_METHOD 0
c65b1445 126#define SAM2_WLUN_REPORT_LUNS 0xc101
1da177e4
LT		 127
128static int scsi_debug_add_host = DEF_NUM_HOST;
129static int scsi_debug_delay = DEF_DELAY;
130static int scsi_debug_dev_size_mb = DEF_DEV_SIZE_MB;
131static int scsi_debug_every_nth = DEF_EVERY_NTH;
132static int scsi_debug_max_luns = DEF_MAX_LUNS;
133static int scsi_debug_num_parts = DEF_NUM_PARTS;
134static int scsi_debug_num_tgts = DEF_NUM_TGTS; /* targets per host */
135static int scsi_debug_opts = DEF_OPTS;
136static int scsi_debug_scsi_level = DEF_SCSI_LEVEL;
137static int scsi_debug_ptype = DEF_PTYPE; /* SCSI peripheral type (0==disk) */
138static int scsi_debug_dsense = DEF_D_SENSE;
c65b1445
DG		 139static int scsi_debug_no_lun_0 = DEF_NO_LUN_0;
140static int scsi_debug_virtual_gb = DEF_VIRTUAL_GB;
23183910
DG		 141static int scsi_debug_fake_rw = DEF_FAKE_RW;
142static int scsi_debug_vpd_use_hostno = DEF_VPD_USE_HOSTNO;
1da177e4
LT		 143
144static int scsi_debug_cmnd_count = 0;
145
146#define DEV_READONLY(TGT) (0)
147#define DEV_REMOVEABLE(TGT) (0)
148
c65b1445
DG		 149static unsigned int sdebug_store_size; /* in bytes */
150static unsigned int sdebug_store_sectors;
1da177e4
LT		 151static sector_t sdebug_capacity; /* in sectors */
152
153/* old BIOS stuff, kernel may get rid of them but some mode sense pages
154 may still need them */
155static int sdebug_heads; /* heads per disk */
156static int sdebug_cylinders_per; /* cylinders per surface */
157static int sdebug_sectors_per; /* sectors per cylinder */
158
159/* default sector size is 512 bytes, 2**9 bytes */
160#define POW2_SECT_SIZE 9
161#define SECT_SIZE (1 << POW2_SECT_SIZE)
162#define SECT_SIZE_PER(TGT) SECT_SIZE
163
164#define SDEBUG_MAX_PARTS 4
165
166#define SDEBUG_SENSE_LEN 32
167
168struct sdebug_dev_info {
169 struct list_head dev_list;
170 unsigned char sense_buff[SDEBUG_SENSE_LEN]; /* weak nexus */
171 unsigned int channel;
172 unsigned int target;
173 unsigned int lun;
174 struct sdebug_host_info *sdbg_host;
c65b1445 175 unsigned int wlun;
1da177e4 176 char reset;
c65b1445 177 char stopped;
1da177e4
LT		 178 char used;
179};
180
181struct sdebug_host_info {
182 struct list_head host_list;
183 struct Scsi_Host *shost;
184 struct device dev;
185 struct list_head dev_info_list;
186};
187
188#define to_sdebug_host(d) \
189 container_of(d, struct sdebug_host_info, dev)
190
191static LIST_HEAD(sdebug_host_list);
192static DEFINE_SPINLOCK(sdebug_host_list_lock);
193
194typedef void (* done_funct_t) (struct scsi_cmnd *);
195
196struct sdebug_queued_cmd {
197 int in_use;
198 struct timer_list cmnd_timer;
199 done_funct_t done_funct;
200 struct scsi_cmnd * a_cmnd;
201 int scsi_result;
202};
203static struct sdebug_queued_cmd queued_arr[SCSI_DEBUG_CANQUEUE];
204
d0be4a7d 205static struct scsi_host_template sdebug_driver_template = {
1da177e4
LT		 206 .proc_info = scsi_debug_proc_info,
207 .name = "SCSI DEBUG",
208 .info = scsi_debug_info,
209 .slave_alloc = scsi_debug_slave_alloc,
210 .slave_configure = scsi_debug_slave_configure,
211 .slave_destroy = scsi_debug_slave_destroy,
212 .ioctl = scsi_debug_ioctl,
213 .queuecommand = scsi_debug_queuecommand,
214 .eh_abort_handler = scsi_debug_abort,
215 .eh_bus_reset_handler = scsi_debug_bus_reset,
216 .eh_device_reset_handler = scsi_debug_device_reset,
217 .eh_host_reset_handler = scsi_debug_host_reset,
218 .bios_param = scsi_debug_biosparam,
219 .can_queue = SCSI_DEBUG_CANQUEUE,
220 .this_id = 7,
c65b1445
DG		 221 .sg_tablesize = 256,
222 .cmd_per_lun = 16,
223 .max_sectors = 0xffff,
1da177e4 224 .unchecked_isa_dma = 0,
c65b1445 225 .use_clustering = ENABLE_CLUSTERING,
1da177e4
LT		 226 .module = THIS_MODULE,
227};
228
229static unsigned char * fake_storep; /* ramdisk storage */
230
231static int num_aborts = 0;
232static int num_dev_resets = 0;
233static int num_bus_resets = 0;
234static int num_host_resets = 0;
235
236static DEFINE_SPINLOCK(queued_arr_lock);
237static DEFINE_RWLOCK(atomic_rw);
238
239static char sdebug_proc_name[] = "scsi_debug";
240
241static int sdebug_driver_probe(struct device *);
242static int sdebug_driver_remove(struct device *);
243static struct bus_type pseudo_lld_bus;
244
245static struct device_driver sdebug_driverfs_driver = {
246 .name = sdebug_proc_name,
247 .bus = &pseudo_lld_bus,
1da177e4
LT		 248};
249
250static const int check_condition_result =
251 (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
252
c65b1445
DG		 253static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
254 0, 0, 0x2, 0x4b};
255static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
256 0, 0, 0x0, 0x0};
257
1da177e4
LT		 258/* function declarations */
259static int resp_inquiry(struct scsi_cmnd * SCpnt, int target,
260 struct sdebug_dev_info * devip);
261static int resp_requests(struct scsi_cmnd * SCpnt,
262 struct sdebug_dev_info * devip);
c65b1445
DG		 263static int resp_start_stop(struct scsi_cmnd * scp,
264 struct sdebug_dev_info * devip);
5a09e398
HR		 265static int resp_report_tgtpgs(struct scsi_cmnd * scp,
266 struct sdebug_dev_info * devip);
1da177e4
LT		 267static int resp_readcap(struct scsi_cmnd * SCpnt,
268 struct sdebug_dev_info * devip);
c65b1445
DG		 269static int resp_readcap16(struct scsi_cmnd * SCpnt,
270 struct sdebug_dev_info * devip);
271static int resp_mode_sense(struct scsi_cmnd * scp, int target,
1da177e4 272 struct sdebug_dev_info * devip);
c65b1445
DG		 273static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
274 struct sdebug_dev_info * devip);
275static int resp_log_sense(struct scsi_cmnd * scp,
276 struct sdebug_dev_info * devip);
277static int resp_read(struct scsi_cmnd * SCpnt, unsigned long long lba,
278 unsigned int num, struct sdebug_dev_info * devip);
279static int resp_write(struct scsi_cmnd * SCpnt, unsigned long long lba,
280 unsigned int num, struct sdebug_dev_info * devip);
1da177e4
LT		 281static int resp_report_luns(struct scsi_cmnd * SCpnt,
282 struct sdebug_dev_info * devip);
c639d14e
FT		 283static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
284 unsigned int num, struct sdebug_dev_info *devip);
1da177e4
LT		 285static int fill_from_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
286 int arr_len);
287static int fetch_to_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
288 int max_arr_len);
289static void timer_intr_handler(unsigned long);
290static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev);
291static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
292 int asc, int asq);
c65b1445
DG		 293static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
294 struct sdebug_dev_info * devip);
1da177e4
LT		 295static int schedule_resp(struct scsi_cmnd * cmnd,
296 struct sdebug_dev_info * devip,
297 done_funct_t done, int scsi_result, int delta_jiff);
298static void __init sdebug_build_parts(unsigned char * ramp);
299static void __init init_all_queued(void);
300static void stop_all_queued(void);
301static int stop_queued_cmnd(struct scsi_cmnd * cmnd);
5a09e398
HR		 302static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
303 int target_dev_id, int dev_id_num,
304 const char * dev_id_str, int dev_id_str_len);
c65b1445 305static int inquiry_evpd_88(unsigned char * arr, int target_dev_id);
6ecaff7f 306static int do_create_driverfs_files(void);
1da177e4
LT		 307static void do_remove_driverfs_files(void);
308
309static int sdebug_add_adapter(void);
310static void sdebug_remove_adapter(void);
311static void sdebug_max_tgts_luns(void);
312
313static struct device pseudo_primary;
314static struct bus_type pseudo_lld_bus;
315
3de9f944
FT		 316static void get_data_transfer_info(unsigned char *cmd,
317 unsigned long long *lba, unsigned int *num)
318{
319 int i;
320
321 switch (*cmd) {
322 case WRITE_16:
323 case READ_16:
324 for (*lba = 0, i = 0; i < 8; ++i) {
325 if (i > 0)
326 *lba <<= 8;
327 *lba += cmd[2 + i];
328 }
329 *num = cmd[13] + (cmd[12] << 8) +
330 (cmd[11] << 16) + (cmd[10] << 24);
331 break;
332 case WRITE_12:
333 case READ_12:
334 *lba = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24);
335 *num = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
336 break;
337 case WRITE_10:
338 case READ_10:
c639d14e 339 case XDWRITEREAD_10:
3de9f944
FT		 340 *lba = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24);
341 *num = cmd[8] + (cmd[7] << 8);
342 break;
343 case WRITE_6:
344 case READ_6:
345 *lba = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
346 *num = (0 == cmd[4]) ? 256 : cmd[4];
347 break;
348 default:
349 break;
350 }
351}
1da177e4
LT		 352
353static
354int scsi_debug_queuecommand(struct scsi_cmnd * SCpnt, done_funct_t done)
355{
356 unsigned char *cmd = (unsigned char *) SCpnt->cmnd;
3de9f944 357 int len, k;
c65b1445
DG		 358 unsigned int num;
359 unsigned long long lba;
1da177e4 360 int errsts = 0;
c65b1445 361 int target = SCpnt->device->id;
1da177e4
LT		 362 struct sdebug_dev_info * devip = NULL;
363 int inj_recovered = 0;
6f3cbf55 364 int inj_transport = 0;
c65b1445 365 int delay_override = 0;
1da177e4
LT		 366
367 if (done == NULL)
368 return 0; /* assume mid level reprocessing command */
369
c73961e5 370 scsi_set_resid(SCpnt, 0);
1da177e4
LT		 371 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) {
372 printk(KERN_INFO "scsi_debug: cmd ");
c65b1445 373 for (k = 0, len = SCpnt->cmd_len; k < len; ++k)
1da177e4
LT		 374 printk("%02x ", (int)cmd[k]);
375 printk("\n");
376 }
377 if(target == sdebug_driver_template.this_id) {
378 printk(KERN_INFO "scsi_debug: initiator's id used as "
379 "target!\n");
380 return schedule_resp(SCpnt, NULL, done,
381 DID_NO_CONNECT << 16, 0);
382 }
383
c65b1445
DG		 384 if ((SCpnt->device->lun >= scsi_debug_max_luns) &&
385 (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS))
1da177e4
LT		 386 return schedule_resp(SCpnt, NULL, done,
387 DID_NO_CONNECT << 16, 0);
388 devip = devInfoReg(SCpnt->device);
389 if (NULL == devip)
390 return schedule_resp(SCpnt, NULL, done,
391 DID_NO_CONNECT << 16, 0);
392
393 if ((scsi_debug_every_nth != 0) &&
394 (++scsi_debug_cmnd_count >= abs(scsi_debug_every_nth))) {
395 scsi_debug_cmnd_count = 0;
396 if (scsi_debug_every_nth < -1)
397 scsi_debug_every_nth = -1;
398 if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
399 return 0; /* ignore command causing timeout */
400 else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
401 inj_recovered = 1; /* to reads and writes below */
6f3cbf55
DG		 402 else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts)
403 inj_transport = 1; /* to reads and writes below */
1da177e4
LT		 404 }
405
c65b1445
DG		 406 if (devip->wlun) {
407 switch (*cmd) {
408 case INQUIRY:
409 case REQUEST_SENSE:
410 case TEST_UNIT_READY:
411 case REPORT_LUNS:
412 break; /* only allowable wlun commands */
413 default:
414 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
415 printk(KERN_INFO "scsi_debug: Opcode: 0x%x "
416 "not supported for wlun\n", *cmd);
417 mk_sense_buffer(devip, ILLEGAL_REQUEST,
418 INVALID_OPCODE, 0);
419 errsts = check_condition_result;
420 return schedule_resp(SCpnt, devip, done, errsts,
421 0);
422 }
423 }
424
1da177e4
LT		 425 switch (*cmd) {
426 case INQUIRY: /* mandatory, ignore unit attention */
c65b1445 427 delay_override = 1;
1da177e4
LT		 428 errsts = resp_inquiry(SCpnt, target, devip);
429 break;
430 case REQUEST_SENSE: /* mandatory, ignore unit attention */
c65b1445 431 delay_override = 1;
1da177e4
LT		 432 errsts = resp_requests(SCpnt, devip);
433 break;
434 case REZERO_UNIT: /* actually this is REWIND for SSC */
435 case START_STOP:
c65b1445 436 errsts = resp_start_stop(SCpnt, devip);
1da177e4
LT		 437 break;
438 case ALLOW_MEDIUM_REMOVAL:
c65b1445 439 if ((errsts = check_readiness(SCpnt, 1, devip)))
1da177e4
LT		 440 break;
441 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
442 printk(KERN_INFO "scsi_debug: Medium removal %s\n",
443 cmd[4] ? "inhibited" : "enabled");
444 break;
445 case SEND_DIAGNOSTIC: /* mandatory */
c65b1445 446 errsts = check_readiness(SCpnt, 1, devip);
1da177e4
LT		 447 break;
448 case TEST_UNIT_READY: /* mandatory */
c65b1445
DG		 449 delay_override = 1;
450 errsts = check_readiness(SCpnt, 0, devip);
1da177e4
LT		 451 break;
452 case RESERVE:
c65b1445 453 errsts = check_readiness(SCpnt, 1, devip);
1da177e4
LT		 454 break;
455 case RESERVE_10:
c65b1445 456 errsts = check_readiness(SCpnt, 1, devip);
1da177e4
LT		 457 break;
458 case RELEASE:
c65b1445 459 errsts = check_readiness(SCpnt, 1, devip);
1da177e4
LT		 460 break;
461 case RELEASE_10:
c65b1445 462 errsts = check_readiness(SCpnt, 1, devip);
1da177e4
LT		 463 break;
464 case READ_CAPACITY:
465 errsts = resp_readcap(SCpnt, devip);
466 break;
c65b1445
DG		 467 case SERVICE_ACTION_IN:
468 if (SAI_READ_CAPACITY_16 != cmd[1]) {
469 mk_sense_buffer(devip, ILLEGAL_REQUEST,
470 INVALID_OPCODE, 0);
471 errsts = check_condition_result;
472 break;
473 }
474 errsts = resp_readcap16(SCpnt, devip);
475 break;
5a09e398
HR		 476 case MAINTENANCE_IN:
477 if (MI_REPORT_TARGET_PGS != cmd[1]) {
478 mk_sense_buffer(devip, ILLEGAL_REQUEST,
479 INVALID_OPCODE, 0);
480 errsts = check_condition_result;
481 break;
482 }
483 errsts = resp_report_tgtpgs(SCpnt, devip);
484 break;
1da177e4
LT		 485 case READ_16:
486 case READ_12:
487 case READ_10:
488 case READ_6:
c65b1445 489 if ((errsts = check_readiness(SCpnt, 0, devip)))
1da177e4 490 break;
23183910
DG		 491 if (scsi_debug_fake_rw)
492 break;
3de9f944 493 get_data_transfer_info(cmd, &lba, &num);
c65b1445 494 errsts = resp_read(SCpnt, lba, num, devip);
1da177e4
LT		 495 if (inj_recovered && (0 == errsts)) {
496 mk_sense_buffer(devip, RECOVERED_ERROR,
c65b1445 497 THRESHOLD_EXCEEDED, 0);
1da177e4 498 errsts = check_condition_result;
6f3cbf55
DG		 499 } else if (inj_transport && (0 == errsts)) {
500 mk_sense_buffer(devip, ABORTED_COMMAND,
501 TRANSPORT_PROBLEM, ACK_NAK_TO);
502 errsts = check_condition_result;
503 }
1da177e4
LT		 504 break;
505 case REPORT_LUNS: /* mandatory, ignore unit attention */
c65b1445 506 delay_override = 1;
1da177e4
LT		 507 errsts = resp_report_luns(SCpnt, devip);
508 break;
509 case VERIFY: /* 10 byte SBC-2 command */
c65b1445 510 errsts = check_readiness(SCpnt, 0, devip);
1da177e4
LT		 511 break;
512 case WRITE_16:
513 case WRITE_12:
514 case WRITE_10:
515 case WRITE_6:
c65b1445 516 if ((errsts = check_readiness(SCpnt, 0, devip)))
1da177e4 517 break;
23183910
DG		 518 if (scsi_debug_fake_rw)
519 break;
3de9f944 520 get_data_transfer_info(cmd, &lba, &num);
c65b1445 521 errsts = resp_write(SCpnt, lba, num, devip);
1da177e4
LT		 522 if (inj_recovered && (0 == errsts)) {
523 mk_sense_buffer(devip, RECOVERED_ERROR,
c65b1445 524 THRESHOLD_EXCEEDED, 0);
1da177e4
LT		 525 errsts = check_condition_result;
526 }
527 break;
528 case MODE_SENSE:
529 case MODE_SENSE_10:
530 errsts = resp_mode_sense(SCpnt, target, devip);
531 break;
c65b1445
DG		 532 case MODE_SELECT:
533 errsts = resp_mode_select(SCpnt, 1, devip);
534 break;
535 case MODE_SELECT_10:
536 errsts = resp_mode_select(SCpnt, 0, devip);
537 break;
538 case LOG_SENSE:
539 errsts = resp_log_sense(SCpnt, devip);
540 break;
1da177e4 541 case SYNCHRONIZE_CACHE:
c65b1445
DG		 542 delay_override = 1;
543 errsts = check_readiness(SCpnt, 0, devip);
1da177e4 544 break;
6f3cbf55
DG		 545 case WRITE_BUFFER:
546 errsts = check_readiness(SCpnt, 1, devip);
547 break;
c639d14e
FT		 548 case XDWRITEREAD_10:
549 if (!scsi_bidi_cmnd(SCpnt)) {
550 mk_sense_buffer(devip, ILLEGAL_REQUEST,
551 INVALID_FIELD_IN_CDB, 0);
552 errsts = check_condition_result;
553 break;
554 }
555
556 errsts = check_readiness(SCpnt, 0, devip);
557 if (errsts)
558 break;
559 if (scsi_debug_fake_rw)
560 break;
561 get_data_transfer_info(cmd, &lba, &num);
562 errsts = resp_read(SCpnt, lba, num, devip);
563 if (errsts)
564 break;
565 errsts = resp_write(SCpnt, lba, num, devip);
566 if (errsts)
567 break;
568 errsts = resp_xdwriteread(SCpnt, lba, num, devip);
569 break;
1da177e4
LT		 570 default:
571 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
572 printk(KERN_INFO "scsi_debug: Opcode: 0x%x not "
573 "supported\n", *cmd);
c65b1445 574 if ((errsts = check_readiness(SCpnt, 1, devip)))
1da177e4
LT		 575 break; /* Unit attention takes precedence */
576 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
577 errsts = check_condition_result;
578 break;
579 }
c65b1445
DG		 580 return schedule_resp(SCpnt, devip, done, errsts,
581 (delay_override ? 0 : scsi_debug_delay));
1da177e4
LT		 582}
583
584static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
585{
586 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
587 printk(KERN_INFO "scsi_debug: ioctl: cmd=0x%x\n", cmd);
588 }
589 return -EINVAL;
590 /* return -ENOTTY; // correct return but upsets fdisk */
591}
592
c65b1445
DG		 593static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
594 struct sdebug_dev_info * devip)
1da177e4
LT		 595{
596 if (devip->reset) {
597 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
598 printk(KERN_INFO "scsi_debug: Reporting Unit "
599 "attention: power on reset\n");
600 devip->reset = 0;
601 mk_sense_buffer(devip, UNIT_ATTENTION, POWERON_RESET, 0);
602 return check_condition_result;
603 }
c65b1445
DG		 604 if ((0 == reset_only) && devip->stopped) {
605 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
606 printk(KERN_INFO "scsi_debug: Reporting Not "
607 "ready: initializing command required\n");
608 mk_sense_buffer(devip, NOT_READY, LOGICAL_UNIT_NOT_READY,
609 0x2);
610 return check_condition_result;
611 }
1da177e4
LT		 612 return 0;
613}
614
615/* Returns 0 if ok else (DID_ERROR << 16). Sets scp->resid . */
616static int fill_from_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
617 int arr_len)
618{
619 int k, req_len, act_len, len, active;
620 void * kaddr;
621 void * kaddr_off;
072d0bb3
FT		 622 struct scatterlist *sg;
623 struct scsi_data_buffer *sdb = scsi_in(scp);
1da177e4 624
072d0bb3 625 if (!sdb->length)
1da177e4 626 return 0;
072d0bb3 627 if (!sdb->table.sgl)
1da177e4 628 return (DID_ERROR << 16);
072d0bb3 629 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE))
1da177e4 630 return (DID_ERROR << 16);
1da177e4 631 active = 1;
852e034d 632 req_len = act_len = 0;
072d0bb3 633 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, k) {
1da177e4
LT		 634 if (active) {
635 kaddr = (unsigned char *)
45711f1a 636 kmap_atomic(sg_page(sg), KM_USER0);
1da177e4
LT		 637 if (NULL == kaddr)
638 return (DID_ERROR << 16);
852e034d
JA		 639 kaddr_off = (unsigned char *)kaddr + sg->offset;
640 len = sg->length;
1da177e4
LT		 641 if ((req_len + len) > arr_len) {
642 active = 0;
643 len = arr_len - req_len;
644 }
645 memcpy(kaddr_off, arr + req_len, len);
646 kunmap_atomic(kaddr, KM_USER0);
647 act_len += len;
648 }
852e034d 649 req_len += sg->length;
1da177e4 650 }
072d0bb3
FT		 651 if (sdb->resid)
652 sdb->resid -= act_len;
c65b1445 653 else
072d0bb3 654 sdb->resid = req_len - act_len;
1da177e4
LT		 655 return 0;
656}
657
658/* Returns number of bytes fetched into 'arr' or -1 if error. */
659static int fetch_to_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
660 int max_arr_len)
661{
662 int k, req_len, len, fin;
663 void * kaddr;
664 void * kaddr_off;
852e034d 665 struct scatterlist * sg;
1da177e4 666
c73961e5 667 if (0 == scsi_bufflen(scp))
1da177e4 668 return 0;
c73961e5 669 if (NULL == scsi_sglist(scp))
1da177e4 670 return -1;
072d0bb3 671 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_TO_DEVICE))
1da177e4 672 return -1;
852e034d 673 req_len = fin = 0;
c73961e5 674 scsi_for_each_sg(scp, sg, scsi_sg_count(scp), k) {
45711f1a 675 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
1da177e4
LT		 676 if (NULL == kaddr)
677 return -1;
852e034d
JA		 678 kaddr_off = (unsigned char *)kaddr + sg->offset;
679 len = sg->length;
1da177e4
LT		 680 if ((req_len + len) > max_arr_len) {
681 len = max_arr_len - req_len;
682 fin = 1;
683 }
684 memcpy(arr + req_len, kaddr_off, len);
685 kunmap_atomic(kaddr, KM_USER0);
686 if (fin)
687 return req_len + len;
852e034d 688 req_len += sg->length;
1da177e4
LT		 689 }
690 return req_len;
691}
692
693
694static const char * inq_vendor_id = "Linux ";
695static const char * inq_product_id = "scsi_debug ";
696static const char * inq_product_rev = "0004";
697
5a09e398
HR		 698static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
699 int target_dev_id, int dev_id_num,
700 const char * dev_id_str,
c65b1445 701 int dev_id_str_len)
1da177e4 702{
c65b1445
DG		 703 int num, port_a;
704 char b[32];
1da177e4 705
c65b1445 706 port_a = target_dev_id + 1;
1da177e4
LT		 707 /* T10 vendor identifier field format (faked) */
708 arr[0] = 0x2; /* ASCII */
709 arr[1] = 0x1;
710 arr[2] = 0x0;
711 memcpy(&arr[4], inq_vendor_id, 8);
712 memcpy(&arr[12], inq_product_id, 16);
713 memcpy(&arr[28], dev_id_str, dev_id_str_len);
714 num = 8 + 16 + dev_id_str_len;
715 arr[3] = num;
716 num += 4;
c65b1445
DG		 717 if (dev_id_num >= 0) {
718 /* NAA-5, Logical unit identifier (binary) */
719 arr[num++] = 0x1; /* binary (not necessarily sas) */
720 arr[num++] = 0x3; /* PIV=0, lu, naa */
721 arr[num++] = 0x0;
722 arr[num++] = 0x8;
723 arr[num++] = 0x53; /* naa-5 ieee company id=0x333333 (fake) */
724 arr[num++] = 0x33;
725 arr[num++] = 0x33;
726 arr[num++] = 0x30;
727 arr[num++] = (dev_id_num >> 24);
728 arr[num++] = (dev_id_num >> 16) & 0xff;
729 arr[num++] = (dev_id_num >> 8) & 0xff;
730 arr[num++] = dev_id_num & 0xff;
731 /* Target relative port number */
732 arr[num++] = 0x61; /* proto=sas, binary */
733 arr[num++] = 0x94; /* PIV=1, target port, rel port */
734 arr[num++] = 0x0; /* reserved */
735 arr[num++] = 0x4; /* length */
736 arr[num++] = 0x0; /* reserved */
737 arr[num++] = 0x0; /* reserved */
738 arr[num++] = 0x0;
739 arr[num++] = 0x1; /* relative port A */
740 }
741 /* NAA-5, Target port identifier */
742 arr[num++] = 0x61; /* proto=sas, binary */
743 arr[num++] = 0x93; /* piv=1, target port, naa */
744 arr[num++] = 0x0;
745 arr[num++] = 0x8;
746 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
747 arr[num++] = 0x22;
748 arr[num++] = 0x22;
749 arr[num++] = 0x20;
750 arr[num++] = (port_a >> 24);
751 arr[num++] = (port_a >> 16) & 0xff;
752 arr[num++] = (port_a >> 8) & 0xff;
753 arr[num++] = port_a & 0xff;
5a09e398
HR		 754 /* NAA-5, Target port group identifier */
755 arr[num++] = 0x61; /* proto=sas, binary */
756 arr[num++] = 0x95; /* piv=1, target port group id */
757 arr[num++] = 0x0;
758 arr[num++] = 0x4;
759 arr[num++] = 0;
760 arr[num++] = 0;
761 arr[num++] = (port_group_id >> 8) & 0xff;
762 arr[num++] = port_group_id & 0xff;
c65b1445
DG		 763 /* NAA-5, Target device identifier */
764 arr[num++] = 0x61; /* proto=sas, binary */
765 arr[num++] = 0xa3; /* piv=1, target device, naa */
766 arr[num++] = 0x0;
767 arr[num++] = 0x8;
768 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */
769 arr[num++] = 0x22;
770 arr[num++] = 0x22;
771 arr[num++] = 0x20;
772 arr[num++] = (target_dev_id >> 24);
773 arr[num++] = (target_dev_id >> 16) & 0xff;
774 arr[num++] = (target_dev_id >> 8) & 0xff;
775 arr[num++] = target_dev_id & 0xff;
776 /* SCSI name string: Target device identifier */
777 arr[num++] = 0x63; /* proto=sas, UTF-8 */
778 arr[num++] = 0xa8; /* piv=1, target device, SCSI name string */
779 arr[num++] = 0x0;
780 arr[num++] = 24;
781 memcpy(arr + num, "naa.52222220", 12);
782 num += 12;
783 snprintf(b, sizeof(b), "%08X", target_dev_id);
784 memcpy(arr + num, b, 8);
785 num += 8;
786 memset(arr + num, 0, 4);
787 num += 4;
788 return num;
789}
790
791
792static unsigned char vpd84_data[] = {
793/* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0,
794 0x22,0x22,0x22,0x0,0xbb,0x1,
795 0x22,0x22,0x22,0x0,0xbb,0x2,
796};
797
798static int inquiry_evpd_84(unsigned char * arr)
799{
800 memcpy(arr, vpd84_data, sizeof(vpd84_data));
801 return sizeof(vpd84_data);
802}
803
804static int inquiry_evpd_85(unsigned char * arr)
805{
806 int num = 0;
807 const char * na1 = "https://www.kernel.org/config";
808 const char * na2 = "http://www.kernel.org/log";
809 int plen, olen;
810
811 arr[num++] = 0x1; /* lu, storage config */
812 arr[num++] = 0x0; /* reserved */
813 arr[num++] = 0x0;
814 olen = strlen(na1);
815 plen = olen + 1;
816 if (plen % 4)
817 plen = ((plen / 4) + 1) * 4;
818 arr[num++] = plen; /* length, null termianted, padded */
819 memcpy(arr + num, na1, olen);
820 memset(arr + num + olen, 0, plen - olen);
821 num += plen;
822
823 arr[num++] = 0x4; /* lu, logging */
824 arr[num++] = 0x0; /* reserved */
825 arr[num++] = 0x0;
826 olen = strlen(na2);
827 plen = olen + 1;
828 if (plen % 4)
829 plen = ((plen / 4) + 1) * 4;
830 arr[num++] = plen; /* length, null terminated, padded */
831 memcpy(arr + num, na2, olen);
832 memset(arr + num + olen, 0, plen - olen);
833 num += plen;
834
835 return num;
836}
837
838/* SCSI ports VPD page */
839static int inquiry_evpd_88(unsigned char * arr, int target_dev_id)
840{
841 int num = 0;
842 int port_a, port_b;
843
844 port_a = target_dev_id + 1;
845 port_b = port_a + 1;
846 arr[num++] = 0x0; /* reserved */
847 arr[num++] = 0x0; /* reserved */
848 arr[num++] = 0x0;
849 arr[num++] = 0x1; /* relative port 1 (primary) */
850 memset(arr + num, 0, 6);
851 num += 6;
852 arr[num++] = 0x0;
853 arr[num++] = 12; /* length tp descriptor */
854 /* naa-5 target port identifier (A) */
855 arr[num++] = 0x61; /* proto=sas, binary */
856 arr[num++] = 0x93; /* PIV=1, target port, NAA */
857 arr[num++] = 0x0; /* reserved */
858 arr[num++] = 0x8; /* length */
859 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
860 arr[num++] = 0x22;
861 arr[num++] = 0x22;
862 arr[num++] = 0x20;
863 arr[num++] = (port_a >> 24);
864 arr[num++] = (port_a >> 16) & 0xff;
865 arr[num++] = (port_a >> 8) & 0xff;
866 arr[num++] = port_a & 0xff;
867
868 arr[num++] = 0x0; /* reserved */
869 arr[num++] = 0x0; /* reserved */
870 arr[num++] = 0x0;
871 arr[num++] = 0x2; /* relative port 2 (secondary) */
872 memset(arr + num, 0, 6);
873 num += 6;
874 arr[num++] = 0x0;
875 arr[num++] = 12; /* length tp descriptor */
876 /* naa-5 target port identifier (B) */
877 arr[num++] = 0x61; /* proto=sas, binary */
878 arr[num++] = 0x93; /* PIV=1, target port, NAA */
879 arr[num++] = 0x0; /* reserved */
880 arr[num++] = 0x8; /* length */
881 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */
882 arr[num++] = 0x22;
883 arr[num++] = 0x22;
884 arr[num++] = 0x20;
885 arr[num++] = (port_b >> 24);
886 arr[num++] = (port_b >> 16) & 0xff;
887 arr[num++] = (port_b >> 8) & 0xff;
888 arr[num++] = port_b & 0xff;
889
890 return num;
891}
892
893
894static unsigned char vpd89_data[] = {
895/* from 4th byte */ 0,0,0,0,
896'l','i','n','u','x',' ',' ',' ',
897'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ',
898'1','2','3','4',
8990x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
9000xec,0,0,0,
9010x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
9020,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
9030x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
9040x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
9050x53,0x41,
9060x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
9070x20,0x20,
9080x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
9090x10,0x80,
9100,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
9110x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
9120x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
9130,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
9140x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
9150x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
9160,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
9170,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9180,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9190,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9200x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
9210,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
9220xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
9230,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
9240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9250,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9260,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9270,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9280,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9290,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9300,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9310,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9320,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9330,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9340,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
9350,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
936};
937
938static int inquiry_evpd_89(unsigned char * arr)
939{
940 memcpy(arr, vpd89_data, sizeof(vpd89_data));
941 return sizeof(vpd89_data);
942}
943
944
945static unsigned char vpdb0_data[] = {
946 /* from 4th byte */ 0,0,0,4,
947 0,0,0x4,0,
948 0,0,0,64,
949};
950
951static int inquiry_evpd_b0(unsigned char * arr)
952{
953 memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
954 if (sdebug_store_sectors > 0x400) {
955 arr[4] = (sdebug_store_sectors >> 24) & 0xff;
956 arr[5] = (sdebug_store_sectors >> 16) & 0xff;
957 arr[6] = (sdebug_store_sectors >> 8) & 0xff;
958 arr[7] = sdebug_store_sectors & 0xff;
959 }
960 return sizeof(vpdb0_data);
1da177e4
LT		 961}
962
963
964#define SDEBUG_LONG_INQ_SZ 96
c65b1445 965#define SDEBUG_MAX_INQ_ARR_SZ 584
1da177e4
LT		 966
967static int resp_inquiry(struct scsi_cmnd * scp, int target,
968 struct sdebug_dev_info * devip)
969{
970 unsigned char pq_pdt;
5a09e398 971 unsigned char * arr;
1da177e4 972 unsigned char *cmd = (unsigned char *)scp->cmnd;
5a09e398 973 int alloc_len, n, ret;
1da177e4
LT		 974
975 alloc_len = (cmd[3] << 8) + cmd[4];
6f3cbf55
DG		 976 arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC);
977 if (! arr)
978 return DID_REQUEUE << 16;
c65b1445
DG		 979 if (devip->wlun)
980 pq_pdt = 0x1e; /* present, wlun */
981 else if (scsi_debug_no_lun_0 && (0 == devip->lun))
982 pq_pdt = 0x7f; /* not present, no device type */
983 else
984 pq_pdt = (scsi_debug_ptype & 0x1f);
1da177e4
LT		 985 arr[0] = pq_pdt;
986 if (0x2 & cmd[1]) { /* CMDDT bit set */
987 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
988 0);
5a09e398 989 kfree(arr);
1da177e4
LT		 990 return check_condition_result;
991 } else if (0x1 & cmd[1]) { /* EVPD bit set */
5a09e398 992 int lu_id_num, port_group_id, target_dev_id, len;
c65b1445
DG		 993 char lu_id_str[6];
994 int host_no = devip->sdbg_host->shost->host_no;
1da177e4 995
5a09e398
HR		 996 port_group_id = (((host_no + 1) & 0x7f) << 8) +
997 (devip->channel & 0x7f);
23183910
DG		 998 if (0 == scsi_debug_vpd_use_hostno)
999 host_no = 0;
c65b1445
DG		 1000 lu_id_num = devip->wlun ? -1 : (((host_no + 1) * 2000) +
1001 (devip->target * 1000) + devip->lun);
1002 target_dev_id = ((host_no + 1) * 2000) +
1003 (devip->target * 1000) - 3;
1004 len = scnprintf(lu_id_str, 6, "%d", lu_id_num);
1da177e4 1005 if (0 == cmd[2]) { /* supported vital product data pages */
c65b1445
DG		 1006 arr[1] = cmd[2]; /*sanity */
1007 n = 4;
1008 arr[n++] = 0x0; /* this page */
1009 arr[n++] = 0x80; /* unit serial number */
1010 arr[n++] = 0x83; /* device identification */
1011 arr[n++] = 0x84; /* software interface ident. */
1012 arr[n++] = 0x85; /* management network addresses */
1013 arr[n++] = 0x86; /* extended inquiry */
1014 arr[n++] = 0x87; /* mode page policy */
1015 arr[n++] = 0x88; /* SCSI ports */
1016 arr[n++] = 0x89; /* ATA information */
1017 arr[n++] = 0xb0; /* Block limits (SBC) */
1018 arr[3] = n - 4; /* number of supported VPD pages */
1da177e4 1019 } else if (0x80 == cmd[2]) { /* unit serial number */
c65b1445 1020 arr[1] = cmd[2]; /*sanity */
1da177e4 1021 arr[3] = len;
c65b1445 1022 memcpy(&arr[4], lu_id_str, len);
1da177e4 1023 } else if (0x83 == cmd[2]) { /* device identification */
c65b1445 1024 arr[1] = cmd[2]; /*sanity */
5a09e398
HR		 1025 arr[3] = inquiry_evpd_83(&arr[4], port_group_id,
1026 target_dev_id, lu_id_num,
1027 lu_id_str, len);
c65b1445
DG		 1028 } else if (0x84 == cmd[2]) { /* Software interface ident. */
1029 arr[1] = cmd[2]; /*sanity */
1030 arr[3] = inquiry_evpd_84(&arr[4]);
1031 } else if (0x85 == cmd[2]) { /* Management network addresses */
1032 arr[1] = cmd[2]; /*sanity */
1033 arr[3] = inquiry_evpd_85(&arr[4]);
1034 } else if (0x86 == cmd[2]) { /* extended inquiry */
1035 arr[1] = cmd[2]; /*sanity */
1036 arr[3] = 0x3c; /* number of following entries */
1037 arr[4] = 0x0; /* no protection stuff */
1038 arr[5] = 0x7; /* head of q, ordered + simple q's */
1039 } else if (0x87 == cmd[2]) { /* mode page policy */
1040 arr[1] = cmd[2]; /*sanity */
1041 arr[3] = 0x8; /* number of following entries */
1042 arr[4] = 0x2; /* disconnect-reconnect mp */
1043 arr[6] = 0x80; /* mlus, shared */
1044 arr[8] = 0x18; /* protocol specific lu */
1045 arr[10] = 0x82; /* mlus, per initiator port */
1046 } else if (0x88 == cmd[2]) { /* SCSI Ports */
1047 arr[1] = cmd[2]; /*sanity */
1048 arr[3] = inquiry_evpd_88(&arr[4], target_dev_id);
1049 } else if (0x89 == cmd[2]) { /* ATA information */
1050 arr[1] = cmd[2]; /*sanity */
1051 n = inquiry_evpd_89(&arr[4]);
1052 arr[2] = (n >> 8);
1053 arr[3] = (n & 0xff);
1054 } else if (0xb0 == cmd[2]) { /* Block limits (SBC) */
1055 arr[1] = cmd[2]; /*sanity */
1056 arr[3] = inquiry_evpd_b0(&arr[4]);
1da177e4
LT		 1057 } else {
1058 /* Illegal request, invalid field in cdb */
1059 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1060 INVALID_FIELD_IN_CDB, 0);
5a09e398 1061 kfree(arr);
1da177e4
LT		 1062 return check_condition_result;
1063 }
c65b1445 1064 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
5a09e398 1065 ret = fill_from_dev_buffer(scp, arr,
c65b1445 1066 min(len, SDEBUG_MAX_INQ_ARR_SZ));
5a09e398
HR		 1067 kfree(arr);
1068 return ret;
1da177e4
LT		 1069 }
1070 /* drops through here for a standard inquiry */
1071 arr[1] = DEV_REMOVEABLE(target) ? 0x80 : 0; /* Removable disk */
1072 arr[2] = scsi_debug_scsi_level;
1073 arr[3] = 2; /* response_data_format==2 */
1074 arr[4] = SDEBUG_LONG_INQ_SZ - 5;
5a09e398
HR		 1075 if (0 == scsi_debug_vpd_use_hostno)
1076 arr[5] = 0x10; /* claim: implicit TGPS */
c65b1445 1077 arr[6] = 0x10; /* claim: MultiP */
1da177e4 1078 /* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */
c65b1445 1079 arr[7] = 0xa; /* claim: LINKED + CMDQUE */
1da177e4
LT		 1080 memcpy(&arr[8], inq_vendor_id, 8);
1081 memcpy(&arr[16], inq_product_id, 16);
1082 memcpy(&arr[32], inq_product_rev, 4);
1083 /* version descriptors (2 bytes each) follow */
c65b1445
DG		 1084 arr[58] = 0x0; arr[59] = 0x77; /* SAM-3 ANSI */
1085 arr[60] = 0x3; arr[61] = 0x14; /* SPC-3 ANSI */
1086 n = 62;
1da177e4 1087 if (scsi_debug_ptype == 0) {
c65b1445 1088 arr[n++] = 0x3; arr[n++] = 0x3d; /* SBC-2 ANSI */
1da177e4 1089 } else if (scsi_debug_ptype == 1) {
c65b1445 1090 arr[n++] = 0x3; arr[n++] = 0x60; /* SSC-2 no version */
1da177e4 1091 }
c65b1445 1092 arr[n++] = 0xc; arr[n++] = 0xf; /* SAS-1.1 rev 10 */
5a09e398 1093 ret = fill_from_dev_buffer(scp, arr,
1da177e4 1094 min(alloc_len, SDEBUG_LONG_INQ_SZ));
5a09e398
HR		 1095 kfree(arr);
1096 return ret;
1da177e4
LT		 1097}
1098
1099static int resp_requests(struct scsi_cmnd * scp,
1100 struct sdebug_dev_info * devip)
1101{
1102 unsigned char * sbuff;
1103 unsigned char *cmd = (unsigned char *)scp->cmnd;
1104 unsigned char arr[SDEBUG_SENSE_LEN];
c65b1445 1105 int want_dsense;
1da177e4
LT		 1106 int len = 18;
1107
c65b1445 1108 memset(arr, 0, sizeof(arr));
1da177e4 1109 if (devip->reset == 1)
c65b1445
DG		 1110 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
1111 want_dsense = !!(cmd[1] & 1) || scsi_debug_dsense;
1da177e4 1112 sbuff = devip->sense_buff;
c65b1445
DG		 1113 if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
1114 if (want_dsense) {
1115 arr[0] = 0x72;
1116 arr[1] = 0x0; /* NO_SENSE in sense_key */
1117 arr[2] = THRESHOLD_EXCEEDED;
1118 arr[3] = 0xff; /* TEST set and MRIE==6 */
1119 } else {
1120 arr[0] = 0x70;
1121 arr[2] = 0x0; /* NO_SENSE in sense_key */
1122 arr[7] = 0xa; /* 18 byte sense buffer */
1123 arr[12] = THRESHOLD_EXCEEDED;
1124 arr[13] = 0xff; /* TEST set and MRIE==6 */
1125 }
c65b1445 1126 } else {
1da177e4 1127 memcpy(arr, sbuff, SDEBUG_SENSE_LEN);
c65b1445
DG		 1128 if ((cmd[1] & 1) && (! scsi_debug_dsense)) {
1129 /* DESC bit set and sense_buff in fixed format */
1130 memset(arr, 0, sizeof(arr));
1131 arr[0] = 0x72;
1132 arr[1] = sbuff[2]; /* sense key */
1133 arr[2] = sbuff[12]; /* asc */
1134 arr[3] = sbuff[13]; /* ascq */
1135 len = 8;
1136 }
1137 }
1138 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0);
1da177e4
LT		 1139 return fill_from_dev_buffer(scp, arr, len);
1140}
1141
c65b1445
DG		 1142static int resp_start_stop(struct scsi_cmnd * scp,
1143 struct sdebug_dev_info * devip)
1144{
1145 unsigned char *cmd = (unsigned char *)scp->cmnd;
1146 int power_cond, errsts, start;
1147
1148 if ((errsts = check_readiness(scp, 1, devip)))
1149 return errsts;
1150 power_cond = (cmd[4] & 0xf0) >> 4;
1151 if (power_cond) {
1152 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1153 0);
1154 return check_condition_result;
1155 }
1156 start = cmd[4] & 1;
1157 if (start == devip->stopped)
1158 devip->stopped = !start;
1159 return 0;
1160}
1161
1da177e4
LT		 1162#define SDEBUG_READCAP_ARR_SZ 8
1163static int resp_readcap(struct scsi_cmnd * scp,
1164 struct sdebug_dev_info * devip)
1165{
1166 unsigned char arr[SDEBUG_READCAP_ARR_SZ];
c65b1445 1167 unsigned int capac;
1da177e4
LT		 1168 int errsts;
1169
c65b1445 1170 if ((errsts = check_readiness(scp, 1, devip)))
1da177e4 1171 return errsts;
c65b1445
DG		 1172 /* following just in case virtual_gb changed */
1173 if (scsi_debug_virtual_gb > 0) {
1174 sdebug_capacity = 2048 * 1024;
1175 sdebug_capacity *= scsi_debug_virtual_gb;
1176 } else
1177 sdebug_capacity = sdebug_store_sectors;
1da177e4 1178 memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
c65b1445
DG		 1179 if (sdebug_capacity < 0xffffffff) {
1180 capac = (unsigned int)sdebug_capacity - 1;
1181 arr[0] = (capac >> 24);
1182 arr[1] = (capac >> 16) & 0xff;
1183 arr[2] = (capac >> 8) & 0xff;
1184 arr[3] = capac & 0xff;
1185 } else {
1186 arr[0] = 0xff;
1187 arr[1] = 0xff;
1188 arr[2] = 0xff;
1189 arr[3] = 0xff;
1190 }
1da177e4
LT		 1191 arr[6] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1192 arr[7] = SECT_SIZE_PER(target) & 0xff;
1193 return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
1194}
1195
c65b1445
DG		 1196#define SDEBUG_READCAP16_ARR_SZ 32
1197static int resp_readcap16(struct scsi_cmnd * scp,
1198 struct sdebug_dev_info * devip)
1199{
1200 unsigned char *cmd = (unsigned char *)scp->cmnd;
1201 unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
1202 unsigned long long capac;
1203 int errsts, k, alloc_len;
1204
1205 if ((errsts = check_readiness(scp, 1, devip)))
1206 return errsts;
1207 alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8)
1208 + cmd[13]);
1209 /* following just in case virtual_gb changed */
1210 if (scsi_debug_virtual_gb > 0) {
1211 sdebug_capacity = 2048 * 1024;
1212 sdebug_capacity *= scsi_debug_virtual_gb;
1213 } else
1214 sdebug_capacity = sdebug_store_sectors;
1215 memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
1216 capac = sdebug_capacity - 1;
1217 for (k = 0; k < 8; ++k, capac >>= 8)
1218 arr[7 - k] = capac & 0xff;
1219 arr[8] = (SECT_SIZE_PER(target) >> 24) & 0xff;
1220 arr[9] = (SECT_SIZE_PER(target) >> 16) & 0xff;
1221 arr[10] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1222 arr[11] = SECT_SIZE_PER(target) & 0xff;
1223 return fill_from_dev_buffer(scp, arr,
1224 min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
1225}
1226
5a09e398
HR		 1227#define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
1228
1229static int resp_report_tgtpgs(struct scsi_cmnd * scp,
1230 struct sdebug_dev_info * devip)
1231{
1232 unsigned char *cmd = (unsigned char *)scp->cmnd;
1233 unsigned char * arr;
1234 int host_no = devip->sdbg_host->shost->host_no;
1235 int n, ret, alen, rlen;
1236 int port_group_a, port_group_b, port_a, port_b;
1237
1238 alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8)
1239 + cmd[9]);
1240
6f3cbf55
DG		 1241 arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
1242 if (! arr)
1243 return DID_REQUEUE << 16;
5a09e398
HR		 1244 /*
1245 * EVPD page 0x88 states we have two ports, one
1246 * real and a fake port with no device connected.
1247 * So we create two port groups with one port each
1248 * and set the group with port B to unavailable.
1249 */
1250 port_a = 0x1; /* relative port A */
1251 port_b = 0x2; /* relative port B */
1252 port_group_a = (((host_no + 1) & 0x7f) << 8) +
1253 (devip->channel & 0x7f);
1254 port_group_b = (((host_no + 1) & 0x7f) << 8) +
1255 (devip->channel & 0x7f) + 0x80;
1256
1257 /*
1258 * The asymmetric access state is cycled according to the host_id.
1259 */
1260 n = 4;
1261 if (0 == scsi_debug_vpd_use_hostno) {
1262 arr[n++] = host_no % 3; /* Asymm access state */
1263 arr[n++] = 0x0F; /* claim: all states are supported */
1264 } else {
1265 arr[n++] = 0x0; /* Active/Optimized path */
1266 arr[n++] = 0x01; /* claim: only support active/optimized paths */
1267 }
1268 arr[n++] = (port_group_a >> 8) & 0xff;
1269 arr[n++] = port_group_a & 0xff;
1270 arr[n++] = 0; /* Reserved */
1271 arr[n++] = 0; /* Status code */
1272 arr[n++] = 0; /* Vendor unique */
1273 arr[n++] = 0x1; /* One port per group */
1274 arr[n++] = 0; /* Reserved */
1275 arr[n++] = 0; /* Reserved */
1276 arr[n++] = (port_a >> 8) & 0xff;
1277 arr[n++] = port_a & 0xff;
1278 arr[n++] = 3; /* Port unavailable */
1279 arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
1280 arr[n++] = (port_group_b >> 8) & 0xff;
1281 arr[n++] = port_group_b & 0xff;
1282 arr[n++] = 0; /* Reserved */
1283 arr[n++] = 0; /* Status code */
1284 arr[n++] = 0; /* Vendor unique */
1285 arr[n++] = 0x1; /* One port per group */
1286 arr[n++] = 0; /* Reserved */
1287 arr[n++] = 0; /* Reserved */
1288 arr[n++] = (port_b >> 8) & 0xff;
1289 arr[n++] = port_b & 0xff;
1290
1291 rlen = n - 4;
1292 arr[0] = (rlen >> 24) & 0xff;
1293 arr[1] = (rlen >> 16) & 0xff;
1294 arr[2] = (rlen >> 8) & 0xff;
1295 arr[3] = rlen & 0xff;
1296
1297 /*
1298 * Return the smallest value of either
1299 * - The allocated length
1300 * - The constructed command length
1301 * - The maximum array size
1302 */
1303 rlen = min(alen,n);
1304 ret = fill_from_dev_buffer(scp, arr,
1305 min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
1306 kfree(arr);
1307 return ret;
1308}
1309
1da177e4
LT		 1310/* <<Following mode page info copied from ST318451LW>> */
1311
1312static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
1313{ /* Read-Write Error Recovery page for mode_sense */
1314 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
1315 5, 0, 0xff, 0xff};
1316
1317 memcpy(p, err_recov_pg, sizeof(err_recov_pg));
1318 if (1 == pcontrol)
1319 memset(p + 2, 0, sizeof(err_recov_pg) - 2);
1320 return sizeof(err_recov_pg);
1321}
1322
1323static int resp_disconnect_pg(unsigned char * p, int pcontrol, int target)
1324{ /* Disconnect-Reconnect page for mode_sense */
1325 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
1326 0, 0, 0, 0, 0, 0, 0, 0};
1327
1328 memcpy(p, disconnect_pg, sizeof(disconnect_pg));
1329 if (1 == pcontrol)
1330 memset(p + 2, 0, sizeof(disconnect_pg) - 2);
1331 return sizeof(disconnect_pg);
1332}
1333
1334static int resp_format_pg(unsigned char * p, int pcontrol, int target)
1335{ /* Format device page for mode_sense */
1336 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
1337 0, 0, 0, 0, 0, 0, 0, 0,
1338 0, 0, 0, 0, 0x40, 0, 0, 0};
1339
1340 memcpy(p, format_pg, sizeof(format_pg));
1341 p[10] = (sdebug_sectors_per >> 8) & 0xff;
1342 p[11] = sdebug_sectors_per & 0xff;
1343 p[12] = (SECT_SIZE >> 8) & 0xff;
1344 p[13] = SECT_SIZE & 0xff;
1345 if (DEV_REMOVEABLE(target))
1346 p[20] |= 0x20; /* should agree with INQUIRY */
1347 if (1 == pcontrol)
1348 memset(p + 2, 0, sizeof(format_pg) - 2);
1349 return sizeof(format_pg);
1350}
1351
1352static int resp_caching_pg(unsigned char * p, int pcontrol, int target)
1353{ /* Caching page for mode_sense */
1354 unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1355 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
1356
1357 memcpy(p, caching_pg, sizeof(caching_pg));
1358 if (1 == pcontrol)
1359 memset(p + 2, 0, sizeof(caching_pg) - 2);
1360 return sizeof(caching_pg);
1361}
1362
1363static int resp_ctrl_m_pg(unsigned char * p, int pcontrol, int target)
1364{ /* Control mode page for mode_sense */
c65b1445
DG		 1365 unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
1366 0, 0, 0, 0};
1367 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1da177e4
LT		 1368 0, 0, 0x2, 0x4b};
1369
1370 if (scsi_debug_dsense)
1371 ctrl_m_pg[2] |= 0x4;
c65b1445
DG		 1372 else
1373 ctrl_m_pg[2] &= ~0x4;
1da177e4
LT		 1374 memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
1375 if (1 == pcontrol)
c65b1445
DG		 1376 memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
1377 else if (2 == pcontrol)
1378 memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
1da177e4
LT		 1379 return sizeof(ctrl_m_pg);
1380}
1381
c65b1445 1382
1da177e4
LT		 1383static int resp_iec_m_pg(unsigned char * p, int pcontrol, int target)
1384{ /* Informational Exceptions control mode page for mode_sense */
c65b1445
DG		 1385 unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
1386 0, 0, 0x0, 0x0};
1387 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1388 0, 0, 0x0, 0x0};
1389
1da177e4
LT		 1390 memcpy(p, iec_m_pg, sizeof(iec_m_pg));
1391 if (1 == pcontrol)
c65b1445
DG		 1392 memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
1393 else if (2 == pcontrol)
1394 memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
1da177e4
LT		 1395 return sizeof(iec_m_pg);
1396}
1397
c65b1445
DG		 1398static int resp_sas_sf_m_pg(unsigned char * p, int pcontrol, int target)
1399{ /* SAS SSP mode page - short format for mode_sense */
1400 unsigned char sas_sf_m_pg[] = {0x19, 0x6,
1401 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
1402
1403 memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
1404 if (1 == pcontrol)
1405 memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
1406 return sizeof(sas_sf_m_pg);
1407}
1408
1409
1410static int resp_sas_pcd_m_spg(unsigned char * p, int pcontrol, int target,
1411 int target_dev_id)
1412{ /* SAS phy control and discover mode page for mode_sense */
1413 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
1414 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
1415 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1416 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1417 0x2, 0, 0, 0, 0, 0, 0, 0,
1418 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1419 0, 0, 0, 0, 0, 0, 0, 0,
1420 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
1421 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1422 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1423 0x3, 0, 0, 0, 0, 0, 0, 0,
1424 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1425 0, 0, 0, 0, 0, 0, 0, 0,
1426 };
1427 int port_a, port_b;
1428
1429 port_a = target_dev_id + 1;
1430 port_b = port_a + 1;
1431 memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
1432 p[20] = (port_a >> 24);
1433 p[21] = (port_a >> 16) & 0xff;
1434 p[22] = (port_a >> 8) & 0xff;
1435 p[23] = port_a & 0xff;
1436 p[48 + 20] = (port_b >> 24);
1437 p[48 + 21] = (port_b >> 16) & 0xff;
1438 p[48 + 22] = (port_b >> 8) & 0xff;
1439 p[48 + 23] = port_b & 0xff;
1440 if (1 == pcontrol)
1441 memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
1442 return sizeof(sas_pcd_m_pg);
1443}
1444
1445static int resp_sas_sha_m_spg(unsigned char * p, int pcontrol)
1446{ /* SAS SSP shared protocol specific port mode subpage */
1447 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
1448 0, 0, 0, 0, 0, 0, 0, 0,
1449 };
1450
1451 memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
1452 if (1 == pcontrol)
1453 memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
1454 return sizeof(sas_sha_m_pg);
1455}
1456
1da177e4
LT		 1457#define SDEBUG_MAX_MSENSE_SZ 256
1458
1459static int resp_mode_sense(struct scsi_cmnd * scp, int target,
1460 struct sdebug_dev_info * devip)
1461{
23183910
DG		 1462 unsigned char dbd, llbaa;
1463 int pcontrol, pcode, subpcode, bd_len;
1da177e4 1464 unsigned char dev_spec;
23183910 1465 int k, alloc_len, msense_6, offset, len, errsts, target_dev_id;
1da177e4
LT		 1466 unsigned char * ap;
1467 unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
1468 unsigned char *cmd = (unsigned char *)scp->cmnd;
1469
c65b1445 1470 if ((errsts = check_readiness(scp, 1, devip)))
1da177e4 1471 return errsts;
23183910 1472 dbd = !!(cmd[1] & 0x8);
1da177e4
LT		 1473 pcontrol = (cmd[2] & 0xc0) >> 6;
1474 pcode = cmd[2] & 0x3f;
1475 subpcode = cmd[3];
1476 msense_6 = (MODE_SENSE == cmd[0]);
23183910
DG		 1477 llbaa = msense_6 ? 0 : !!(cmd[1] & 0x10);
1478 if ((0 == scsi_debug_ptype) && (0 == dbd))
1479 bd_len = llbaa ? 16 : 8;
1480 else
1481 bd_len = 0;
1da177e4
LT		 1482 alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]);
1483 memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
1484 if (0x3 == pcontrol) { /* Saving values not supported */
1485 mk_sense_buffer(devip, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP,
1486 0);
1487 return check_condition_result;
1488 }
c65b1445
DG		 1489 target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
1490 (devip->target * 1000) - 3;
23183910
DG		 1491 /* set DPOFUA bit for disks */
1492 if (0 == scsi_debug_ptype)
1493 dev_spec = (DEV_READONLY(target) ? 0x80 : 0x0) | 0x10;
1494 else
1495 dev_spec = 0x0;
1da177e4
LT		 1496 if (msense_6) {
1497 arr[2] = dev_spec;
23183910 1498 arr[3] = bd_len;
1da177e4
LT		 1499 offset = 4;
1500 } else {
1501 arr[3] = dev_spec;
23183910
DG		 1502 if (16 == bd_len)
1503 arr[4] = 0x1; /* set LONGLBA bit */
1504 arr[7] = bd_len; /* assume 255 or less */
1da177e4
LT		 1505 offset = 8;
1506 }
1507 ap = arr + offset;
23183910
DG		 1508 if ((bd_len > 0) && (0 == sdebug_capacity)) {
1509 if (scsi_debug_virtual_gb > 0) {
1510 sdebug_capacity = 2048 * 1024;
1511 sdebug_capacity *= scsi_debug_virtual_gb;
1512 } else
1513 sdebug_capacity = sdebug_store_sectors;
1514 }
1515 if (8 == bd_len) {
1516 if (sdebug_capacity > 0xfffffffe) {
1517 ap[0] = 0xff;
1518 ap[1] = 0xff;
1519 ap[2] = 0xff;
1520 ap[3] = 0xff;
1521 } else {
1522 ap[0] = (sdebug_capacity >> 24) & 0xff;
1523 ap[1] = (sdebug_capacity >> 16) & 0xff;
1524 ap[2] = (sdebug_capacity >> 8) & 0xff;
1525 ap[3] = sdebug_capacity & 0xff;
1526 }
1527 ap[6] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1528 ap[7] = SECT_SIZE_PER(target) & 0xff;
1529 offset += bd_len;
1530 ap = arr + offset;
1531 } else if (16 == bd_len) {
1532 unsigned long long capac = sdebug_capacity;
1533
1534 for (k = 0; k < 8; ++k, capac >>= 8)
1535 ap[7 - k] = capac & 0xff;
1536 ap[12] = (SECT_SIZE_PER(target) >> 24) & 0xff;
1537 ap[13] = (SECT_SIZE_PER(target) >> 16) & 0xff;
1538 ap[14] = (SECT_SIZE_PER(target) >> 8) & 0xff;
1539 ap[15] = SECT_SIZE_PER(target) & 0xff;
1540 offset += bd_len;
1541 ap = arr + offset;
1542 }
1da177e4 1543
c65b1445
DG		 1544 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
1545 /* TODO: Control Extension page */
1da177e4
LT		 1546 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1547 0);
1548 return check_condition_result;
1549 }
1550 switch (pcode) {
1551 case 0x1: /* Read-Write error recovery page, direct access */
1552 len = resp_err_recov_pg(ap, pcontrol, target);
1553 offset += len;
1554 break;
1555 case 0x2: /* Disconnect-Reconnect page, all devices */
1556 len = resp_disconnect_pg(ap, pcontrol, target);
1557 offset += len;
1558 break;
1559 case 0x3: /* Format device page, direct access */
1560 len = resp_format_pg(ap, pcontrol, target);
1561 offset += len;
1562 break;
1563 case 0x8: /* Caching page, direct access */
1564 len = resp_caching_pg(ap, pcontrol, target);
1565 offset += len;
1566 break;
1567 case 0xa: /* Control Mode page, all devices */
1568 len = resp_ctrl_m_pg(ap, pcontrol, target);
1569 offset += len;
1570 break;
c65b1445
DG		 1571 case 0x19: /* if spc==1 then sas phy, control+discover */
1572 if ((subpcode > 0x2) && (subpcode < 0xff)) {
1573 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1574 INVALID_FIELD_IN_CDB, 0);
1575 return check_condition_result;
1576 }
1577 len = 0;
1578 if ((0x0 == subpcode) || (0xff == subpcode))
1579 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1580 if ((0x1 == subpcode) || (0xff == subpcode))
1581 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
1582 target_dev_id);
1583 if ((0x2 == subpcode) || (0xff == subpcode))
1584 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1585 offset += len;
1586 break;
1da177e4
LT		 1587 case 0x1c: /* Informational Exceptions Mode page, all devices */
1588 len = resp_iec_m_pg(ap, pcontrol, target);
1589 offset += len;
1590 break;
1591 case 0x3f: /* Read all Mode pages */
c65b1445
DG		 1592 if ((0 == subpcode) || (0xff == subpcode)) {
1593 len = resp_err_recov_pg(ap, pcontrol, target);
1594 len += resp_disconnect_pg(ap + len, pcontrol, target);
1595 len += resp_format_pg(ap + len, pcontrol, target);
1596 len += resp_caching_pg(ap + len, pcontrol, target);
1597 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
1598 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1599 if (0xff == subpcode) {
1600 len += resp_sas_pcd_m_spg(ap + len, pcontrol,
1601 target, target_dev_id);
1602 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1603 }
1604 len += resp_iec_m_pg(ap + len, pcontrol, target);
1605 } else {
1606 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1607 INVALID_FIELD_IN_CDB, 0);
1608 return check_condition_result;
1609 }
1da177e4
LT		 1610 offset += len;
1611 break;
1612 default:
1613 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1614 0);
1615 return check_condition_result;
1616 }
1617 if (msense_6)
1618 arr[0] = offset - 1;
1619 else {
1620 arr[0] = ((offset - 2) >> 8) & 0xff;
1621 arr[1] = (offset - 2) & 0xff;
1622 }
1623 return fill_from_dev_buffer(scp, arr, min(alloc_len, offset));
1624}
1625
c65b1445
DG		 1626#define SDEBUG_MAX_MSELECT_SZ 512
1627
1628static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
1629 struct sdebug_dev_info * devip)
1630{
1631 int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
1632 int param_len, res, errsts, mpage;
1633 unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
1634 unsigned char *cmd = (unsigned char *)scp->cmnd;
1635
1636 if ((errsts = check_readiness(scp, 1, devip)))
1637 return errsts;
1638 memset(arr, 0, sizeof(arr));
1639 pf = cmd[1] & 0x10;
1640 sp = cmd[1] & 0x1;
1641 param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]);
1642 if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
1643 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1644 INVALID_FIELD_IN_CDB, 0);
1645 return check_condition_result;
1646 }
1647 res = fetch_to_dev_buffer(scp, arr, param_len);
1648 if (-1 == res)
1649 return (DID_ERROR << 16);
1650 else if ((res < param_len) &&
1651 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1652 printk(KERN_INFO "scsi_debug: mode_select: cdb indicated=%d, "
1653 " IO sent=%d bytes\n", param_len, res);
1654 md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2);
1655 bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]);
23183910 1656 if (md_len > 2) {
c65b1445
DG		 1657 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1658 INVALID_FIELD_IN_PARAM_LIST, 0);
1659 return check_condition_result;
1660 }
1661 off = bd_len + (mselect6 ? 4 : 8);
1662 mpage = arr[off] & 0x3f;
1663 ps = !!(arr[off] & 0x80);
1664 if (ps) {
1665 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1666 INVALID_FIELD_IN_PARAM_LIST, 0);
1667 return check_condition_result;
1668 }
1669 spf = !!(arr[off] & 0x40);
1670 pg_len = spf ? ((arr[off + 2] << 8) + arr[off + 3] + 4) :
1671 (arr[off + 1] + 2);
1672 if ((pg_len + off) > param_len) {
1673 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1674 PARAMETER_LIST_LENGTH_ERR, 0);
1675 return check_condition_result;
1676 }
1677 switch (mpage) {
1678 case 0xa: /* Control Mode page */
1679 if (ctrl_m_pg[1] == arr[off + 1]) {
1680 memcpy(ctrl_m_pg + 2, arr + off + 2,
1681 sizeof(ctrl_m_pg) - 2);
1682 scsi_debug_dsense = !!(ctrl_m_pg[2] & 0x4);
1683 return 0;
1684 }
1685 break;
1686 case 0x1c: /* Informational Exceptions Mode page */
1687 if (iec_m_pg[1] == arr[off + 1]) {
1688 memcpy(iec_m_pg + 2, arr + off + 2,
1689 sizeof(iec_m_pg) - 2);
1690 return 0;
1691 }
1692 break;
1693 default:
1694 break;
1695 }
1696 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1697 INVALID_FIELD_IN_PARAM_LIST, 0);
1698 return check_condition_result;
1699}
1700
1701static int resp_temp_l_pg(unsigned char * arr)
1702{
1703 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
1704 0x0, 0x1, 0x3, 0x2, 0x0, 65,
1705 };
1706
1707 memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
1708 return sizeof(temp_l_pg);
1709}
1710
1711static int resp_ie_l_pg(unsigned char * arr)
1712{
1713 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
1714 };
1715
1716 memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
1717 if (iec_m_pg[2] & 0x4) { /* TEST bit set */
1718 arr[4] = THRESHOLD_EXCEEDED;
1719 arr[5] = 0xff;
1720 }
1721 return sizeof(ie_l_pg);
1722}
1723
1724#define SDEBUG_MAX_LSENSE_SZ 512
1725
1726static int resp_log_sense(struct scsi_cmnd * scp,
1727 struct sdebug_dev_info * devip)
1728{
23183910 1729 int ppc, sp, pcontrol, pcode, subpcode, alloc_len, errsts, len, n;
c65b1445
DG		 1730 unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
1731 unsigned char *cmd = (unsigned char *)scp->cmnd;
1732
1733 if ((errsts = check_readiness(scp, 1, devip)))
1734 return errsts;
1735 memset(arr, 0, sizeof(arr));
1736 ppc = cmd[1] & 0x2;
1737 sp = cmd[1] & 0x1;
1738 if (ppc || sp) {
1739 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1740 INVALID_FIELD_IN_CDB, 0);
1741 return check_condition_result;
1742 }
1743 pcontrol = (cmd[2] & 0xc0) >> 6;
1744 pcode = cmd[2] & 0x3f;
23183910 1745 subpcode = cmd[3] & 0xff;
c65b1445
DG		 1746 alloc_len = (cmd[7] << 8) + cmd[8];
1747 arr[0] = pcode;
23183910
DG		 1748 if (0 == subpcode) {
1749 switch (pcode) {
1750 case 0x0: /* Supported log pages log page */
1751 n = 4;
1752 arr[n++] = 0x0; /* this page */
1753 arr[n++] = 0xd; /* Temperature */
1754 arr[n++] = 0x2f; /* Informational exceptions */
1755 arr[3] = n - 4;
1756 break;
1757 case 0xd: /* Temperature log page */
1758 arr[3] = resp_temp_l_pg(arr + 4);
1759 break;
1760 case 0x2f: /* Informational exceptions log page */
1761 arr[3] = resp_ie_l_pg(arr + 4);
1762 break;
1763 default:
1764 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1765 INVALID_FIELD_IN_CDB, 0);
1766 return check_condition_result;
1767 }
1768 } else if (0xff == subpcode) {
1769 arr[0] |= 0x40;
1770 arr[1] = subpcode;
1771 switch (pcode) {
1772 case 0x0: /* Supported log pages and subpages log page */
1773 n = 4;
1774 arr[n++] = 0x0;
1775 arr[n++] = 0x0; /* 0,0 page */
1776 arr[n++] = 0x0;
1777 arr[n++] = 0xff; /* this page */
1778 arr[n++] = 0xd;
1779 arr[n++] = 0x0; /* Temperature */
1780 arr[n++] = 0x2f;
1781 arr[n++] = 0x0; /* Informational exceptions */
1782 arr[3] = n - 4;
1783 break;
1784 case 0xd: /* Temperature subpages */
1785 n = 4;
1786 arr[n++] = 0xd;
1787 arr[n++] = 0x0; /* Temperature */
1788 arr[3] = n - 4;
1789 break;
1790 case 0x2f: /* Informational exceptions subpages */
1791 n = 4;
1792 arr[n++] = 0x2f;
1793 arr[n++] = 0x0; /* Informational exceptions */
1794 arr[3] = n - 4;
1795 break;
1796 default:
1797 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1798 INVALID_FIELD_IN_CDB, 0);
1799 return check_condition_result;
1800 }
1801 } else {
c65b1445
DG		 1802 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1803 INVALID_FIELD_IN_CDB, 0);
1804 return check_condition_result;
1805 }
1806 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
1807 return fill_from_dev_buffer(scp, arr,
1808 min(len, SDEBUG_MAX_INQ_ARR_SZ));
1809}
1810
1811static int resp_read(struct scsi_cmnd * SCpnt, unsigned long long lba,
1812 unsigned int num, struct sdebug_dev_info * devip)
1da177e4
LT		 1813{
1814 unsigned long iflags;
c65b1445
DG		 1815 unsigned int block, from_bottom;
1816 unsigned long long u;
1da177e4
LT		 1817 int ret;
1818
c65b1445 1819 if (lba + num > sdebug_capacity) {
1da177e4
LT		 1820 mk_sense_buffer(devip, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE,
1821 0);
1822 return check_condition_result;
1823 }
c65b1445
DG		 1824 /* transfer length excessive (tie in to block limits VPD page) */
1825 if (num > sdebug_store_sectors) {
1826 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1827 0);
1828 return check_condition_result;
1829 }
1da177e4 1830 if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) &&
c65b1445
DG		 1831 (lba <= OPT_MEDIUM_ERR_ADDR) &&
1832 ((lba + num) > OPT_MEDIUM_ERR_ADDR)) {
1833 /* claim unrecoverable read error */
1da177e4
LT		 1834 mk_sense_buffer(devip, MEDIUM_ERROR, UNRECOVERED_READ_ERR,
1835 0);
c65b1445
DG		 1836 /* set info field and valid bit for fixed descriptor */
1837 if (0x70 == (devip->sense_buff[0] & 0x7f)) {
1838 devip->sense_buff[0] |= 0x80; /* Valid bit */
1839 ret = OPT_MEDIUM_ERR_ADDR;
1840 devip->sense_buff[3] = (ret >> 24) & 0xff;
1841 devip->sense_buff[4] = (ret >> 16) & 0xff;
1842 devip->sense_buff[5] = (ret >> 8) & 0xff;
1843 devip->sense_buff[6] = ret & 0xff;
1844 }
1da177e4
LT		 1845 return check_condition_result;
1846 }
1847 read_lock_irqsave(&atomic_rw, iflags);
c65b1445
DG		 1848 if ((lba + num) <= sdebug_store_sectors)
1849 ret = fill_from_dev_buffer(SCpnt,
1850 fake_storep + (lba * SECT_SIZE),
1851 num * SECT_SIZE);
1852 else {
1853 /* modulo when one arg is 64 bits needs do_div() */
1854 u = lba;
1855 block = do_div(u, sdebug_store_sectors);
1856 from_bottom = 0;
1857 if ((block + num) > sdebug_store_sectors)
1858 from_bottom = (block + num) - sdebug_store_sectors;
1859 ret = fill_from_dev_buffer(SCpnt,
1860 fake_storep + (block * SECT_SIZE),
1861 (num - from_bottom) * SECT_SIZE);
1862 if ((0 == ret) && (from_bottom > 0))
1863 ret = fill_from_dev_buffer(SCpnt, fake_storep,
1864 from_bottom * SECT_SIZE);
1865 }
1da177e4
LT		 1866 read_unlock_irqrestore(&atomic_rw, iflags);
1867 return ret;
1868}
1869
c65b1445
DG		 1870static int resp_write(struct scsi_cmnd * SCpnt, unsigned long long lba,
1871 unsigned int num, struct sdebug_dev_info * devip)
1da177e4
LT		 1872{
1873 unsigned long iflags;
c65b1445
DG		 1874 unsigned int block, to_bottom;
1875 unsigned long long u;
1da177e4
LT		 1876 int res;
1877
c65b1445 1878 if (lba + num > sdebug_capacity) {
1da177e4
LT		 1879 mk_sense_buffer(devip, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE,
1880 0);
1881 return check_condition_result;
1882 }
c65b1445
DG		 1883 /* transfer length excessive (tie in to block limits VPD page) */
1884 if (num > sdebug_store_sectors) {
1885 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1886 0);
1887 return check_condition_result;
1888 }
1da177e4
LT		 1889
1890 write_lock_irqsave(&atomic_rw, iflags);
c65b1445
DG		 1891 if ((lba + num) <= sdebug_store_sectors)
1892 res = fetch_to_dev_buffer(SCpnt,
1893 fake_storep + (lba * SECT_SIZE),
1894 num * SECT_SIZE);
1895 else {
1896 /* modulo when one arg is 64 bits needs do_div() */
1897 u = lba;
1898 block = do_div(u, sdebug_store_sectors);
1899 to_bottom = 0;
1900 if ((block + num) > sdebug_store_sectors)
1901 to_bottom = (block + num) - sdebug_store_sectors;
1902 res = fetch_to_dev_buffer(SCpnt,
1903 fake_storep + (block * SECT_SIZE),
1904 (num - to_bottom) * SECT_SIZE);
1905 if ((0 == res) && (to_bottom > 0))
1906 res = fetch_to_dev_buffer(SCpnt, fake_storep,
1907 to_bottom * SECT_SIZE);
1908 }
1da177e4
LT		 1909 write_unlock_irqrestore(&atomic_rw, iflags);
1910 if (-1 == res)
1911 return (DID_ERROR << 16);
1912 else if ((res < (num * SECT_SIZE)) &&
1913 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
c65b1445 1914 printk(KERN_INFO "scsi_debug: write: cdb indicated=%u, "
1da177e4
LT		 1915 " IO sent=%d bytes\n", num * SECT_SIZE, res);
1916 return 0;
1917}
1918
c65b1445 1919#define SDEBUG_RLUN_ARR_SZ 256
1da177e4
LT		 1920
1921static int resp_report_luns(struct scsi_cmnd * scp,
1922 struct sdebug_dev_info * devip)
1923{
1924 unsigned int alloc_len;
c65b1445 1925 int lun_cnt, i, upper, num, n, wlun, lun;
1da177e4
LT		 1926 unsigned char *cmd = (unsigned char *)scp->cmnd;
1927 int select_report = (int)cmd[2];
1928 struct scsi_lun *one_lun;
1929 unsigned char arr[SDEBUG_RLUN_ARR_SZ];
c65b1445 1930 unsigned char * max_addr;
1da177e4
LT		 1931
1932 alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
c65b1445 1933 if ((alloc_len < 4) || (select_report > 2)) {
1da177e4
LT		 1934 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1935 0);
1936 return check_condition_result;
1937 }
1938 /* can produce response with up to 16k luns (lun 0 to lun 16383) */
1939 memset(arr, 0, SDEBUG_RLUN_ARR_SZ);
1940 lun_cnt = scsi_debug_max_luns;
c65b1445
DG		 1941 if (1 == select_report)
1942 lun_cnt = 0;
1943 else if (scsi_debug_no_lun_0 && (lun_cnt > 0))
1944 --lun_cnt;
1945 wlun = (select_report > 0) ? 1 : 0;
1946 num = lun_cnt + wlun;
1947 arr[2] = ((sizeof(struct scsi_lun) * num) >> 8) & 0xff;
1948 arr[3] = (sizeof(struct scsi_lun) * num) & 0xff;
1949 n = min((int)((SDEBUG_RLUN_ARR_SZ - 8) /
1950 sizeof(struct scsi_lun)), num);
1951 if (n < num) {
1952 wlun = 0;
1953 lun_cnt = n;
1954 }
1da177e4 1955 one_lun = (struct scsi_lun *) &arr[8];
c65b1445
DG		 1956 max_addr = arr + SDEBUG_RLUN_ARR_SZ;
1957 for (i = 0, lun = (scsi_debug_no_lun_0 ? 1 : 0);
1958 ((i < lun_cnt) && ((unsigned char *)(one_lun + i) < max_addr));
1959 i++, lun++) {
1960 upper = (lun >> 8) & 0x3f;
1da177e4
LT		 1961 if (upper)
1962 one_lun[i].scsi_lun[0] =
1963 (upper | (SAM2_LUN_ADDRESS_METHOD << 6));
c65b1445
DG		 1964 one_lun[i].scsi_lun[1] = lun & 0xff;
1965 }
1966 if (wlun) {
1967 one_lun[i].scsi_lun[0] = (SAM2_WLUN_REPORT_LUNS >> 8) & 0xff;
1968 one_lun[i].scsi_lun[1] = SAM2_WLUN_REPORT_LUNS & 0xff;
1969 i++;
1da177e4 1970 }
c65b1445 1971 alloc_len = (unsigned char *)(one_lun + i) - arr;
1da177e4
LT		 1972 return fill_from_dev_buffer(scp, arr,
1973 min((int)alloc_len, SDEBUG_RLUN_ARR_SZ));
1974}
1975
c639d14e
FT		 1976static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
1977 unsigned int num, struct sdebug_dev_info *devip)
1978{
1979 int i, j, ret = -1;
1980 unsigned char *kaddr, *buf;
1981 unsigned int offset;
1982 struct scatterlist *sg;
1983 struct scsi_data_buffer *sdb = scsi_in(scp);
1984
1985 /* better not to use temporary buffer. */
1986 buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
1987 if (!buf)
1988 return ret;
1989
1990 offset = 0;
1991 scsi_for_each_sg(scp, sg, scsi_sg_count(scp), i) {
1992 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
1993 if (!kaddr)
1994 goto out;
1995
1996 memcpy(buf + offset, kaddr + sg->offset, sg->length);
1997 offset += sg->length;
1998 kunmap_atomic(kaddr, KM_USER0);
1999 }
2000
2001 offset = 0;
2002 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, i) {
2003 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
2004 if (!kaddr)
2005 goto out;
2006
2007 for (j = 0; j < sg->length; j++)
2008 *(kaddr + sg->offset + j) ^= *(buf + offset + j);
2009
2010 offset += sg->length;
2011 kunmap_atomic(kaddr, KM_USER0);
2012 }
2013 ret = 0;
2014out:
2015 kfree(buf);
2016
2017 return ret;
2018}
2019
1da177e4
LT		 2020/* When timer goes off this function is called. */
2021static void timer_intr_handler(unsigned long indx)
2022{
2023 struct sdebug_queued_cmd * sqcp;
2024 unsigned long iflags;
2025
2026 if (indx >= SCSI_DEBUG_CANQUEUE) {
2027 printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too "
2028 "large\n");
2029 return;
2030 }
2031 spin_lock_irqsave(&queued_arr_lock, iflags);
2032 sqcp = &queued_arr[(int)indx];
2033 if (! sqcp->in_use) {
2034 printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected "
2035 "interrupt\n");
2036 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2037 return;
2038 }
2039 sqcp->in_use = 0;
2040 if (sqcp->done_funct) {
2041 sqcp->a_cmnd->result = sqcp->scsi_result;
2042 sqcp->done_funct(sqcp->a_cmnd); /* callback to mid level */
2043 }
2044 sqcp->done_funct = NULL;
2045 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2046}
2047
2048static int scsi_debug_slave_alloc(struct scsi_device * sdp)
2049{
2050 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
c65b1445
DG		 2051 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
2052 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
c639d14e 2053 set_bit(QUEUE_FLAG_BIDI, &sdp->request_queue->queue_flags);
1da177e4
LT		 2054 return 0;
2055}
2056
2057static int scsi_debug_slave_configure(struct scsi_device * sdp)
2058{
2059 struct sdebug_dev_info * devip;
2060
2061 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
c65b1445
DG		 2062 printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n",
2063 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
1da177e4
LT		 2064 if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN)
2065 sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN;
2066 devip = devInfoReg(sdp);
6f3cbf55
DG		 2067 if (NULL == devip)
2068 return 1; /* no resources, will be marked offline */
1da177e4
LT		 2069 sdp->hostdata = devip;
2070 if (sdp->host->cmd_per_lun)
2071 scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING,
2072 sdp->host->cmd_per_lun);
c65b1445 2073 blk_queue_max_segment_size(sdp->request_queue, 256 * 1024);
1da177e4
LT		 2074 return 0;
2075}
2076
2077static void scsi_debug_slave_destroy(struct scsi_device * sdp)
2078{
2079 struct sdebug_dev_info * devip =
2080 (struct sdebug_dev_info *)sdp->hostdata;
2081
2082 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
c65b1445
DG		 2083 printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n",
2084 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
1da177e4
LT		 2085 if (devip) {
2086 /* make this slot avaliable for re-use */
2087 devip->used = 0;
2088 sdp->hostdata = NULL;
2089 }
2090}
2091
2092static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
2093{
2094 struct sdebug_host_info * sdbg_host;
2095 struct sdebug_dev_info * open_devip = NULL;
2096 struct sdebug_dev_info * devip =
2097 (struct sdebug_dev_info *)sdev->hostdata;
2098
2099 if (devip)
2100 return devip;
2101 sdbg_host = *(struct sdebug_host_info **) sdev->host->hostdata;
2102 if(! sdbg_host) {
2103 printk(KERN_ERR "Host info NULL\n");
2104 return NULL;
2105 }
2106 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
2107 if ((devip->used) && (devip->channel == sdev->channel) &&
2108 (devip->target == sdev->id) &&
2109 (devip->lun == sdev->lun))
2110 return devip;
2111 else {
2112 if ((!devip->used) && (!open_devip))
2113 open_devip = devip;
2114 }
2115 }
2116 if (NULL == open_devip) { /* try and make a new one */
6f3cbf55 2117 open_devip = kzalloc(sizeof(*open_devip),GFP_ATOMIC);
1da177e4
LT		 2118 if (NULL == open_devip) {
2119 printk(KERN_ERR "%s: out of memory at line %d\n",
2120 __FUNCTION__, __LINE__);
2121 return NULL;
2122 }
1da177e4
LT		 2123 open_devip->sdbg_host = sdbg_host;
2124 list_add_tail(&open_devip->dev_list,
2125 &sdbg_host->dev_info_list);
2126 }
2127 if (open_devip) {
2128 open_devip->channel = sdev->channel;
2129 open_devip->target = sdev->id;
2130 open_devip->lun = sdev->lun;
2131 open_devip->sdbg_host = sdbg_host;
2132 open_devip->reset = 1;
2133 open_devip->used = 1;
2134 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
2135 if (scsi_debug_dsense)
2136 open_devip->sense_buff[0] = 0x72;
2137 else {
2138 open_devip->sense_buff[0] = 0x70;
2139 open_devip->sense_buff[7] = 0xa;
2140 }
c65b1445
DG		 2141 if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
2142 open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
1da177e4
LT		 2143 return open_devip;
2144 }
2145 return NULL;
2146}
2147
2148static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
2149 int asc, int asq)
2150{
2151 unsigned char * sbuff;
2152
2153 sbuff = devip->sense_buff;
2154 memset(sbuff, 0, SDEBUG_SENSE_LEN);
2155 if (scsi_debug_dsense) {
2156 sbuff[0] = 0x72; /* descriptor, current */
2157 sbuff[1] = key;
2158 sbuff[2] = asc;
2159 sbuff[3] = asq;
2160 } else {
2161 sbuff[0] = 0x70; /* fixed, current */
2162 sbuff[2] = key;
2163 sbuff[7] = 0xa; /* implies 18 byte sense buffer */
2164 sbuff[12] = asc;
2165 sbuff[13] = asq;
2166 }
2167 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2168 printk(KERN_INFO "scsi_debug: [sense_key,asc,ascq]: "
2169 "[0x%x,0x%x,0x%x]\n", key, asc, asq);
2170}
2171
2172static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
2173{
2174 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2175 printk(KERN_INFO "scsi_debug: abort\n");
2176 ++num_aborts;
2177 stop_queued_cmnd(SCpnt);
2178 return SUCCESS;
2179}
2180
2181static int scsi_debug_biosparam(struct scsi_device *sdev,
2182 struct block_device * bdev, sector_t capacity, int *info)
2183{
2184 int res;
2185 unsigned char *buf;
2186
2187 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2188 printk(KERN_INFO "scsi_debug: biosparam\n");
2189 buf = scsi_bios_ptable(bdev);
2190 if (buf) {
2191 res = scsi_partsize(buf, capacity,
2192 &info[2], &info[0], &info[1]);
2193 kfree(buf);
2194 if (! res)
2195 return res;
2196 }
2197 info[0] = sdebug_heads;
2198 info[1] = sdebug_sectors_per;
2199 info[2] = sdebug_cylinders_per;
2200 return 0;
2201}
2202
2203static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
2204{
2205 struct sdebug_dev_info * devip;
2206
2207 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2208 printk(KERN_INFO "scsi_debug: device_reset\n");
2209 ++num_dev_resets;
2210 if (SCpnt) {
2211 devip = devInfoReg(SCpnt->device);
2212 if (devip)
2213 devip->reset = 1;
2214 }
2215 return SUCCESS;
2216}
2217
2218static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
2219{
2220 struct sdebug_host_info *sdbg_host;
2221 struct sdebug_dev_info * dev_info;
2222 struct scsi_device * sdp;
2223 struct Scsi_Host * hp;
2224
2225 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2226 printk(KERN_INFO "scsi_debug: bus_reset\n");
2227 ++num_bus_resets;
2228 if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
2229 sdbg_host = *(struct sdebug_host_info **) hp->hostdata;
2230 if (sdbg_host) {
2231 list_for_each_entry(dev_info,
2232 &sdbg_host->dev_info_list,
2233 dev_list)
2234 dev_info->reset = 1;
2235 }
2236 }
2237 return SUCCESS;
2238}
2239
2240static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
2241{
2242 struct sdebug_host_info * sdbg_host;
2243 struct sdebug_dev_info * dev_info;
2244
2245 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2246 printk(KERN_INFO "scsi_debug: host_reset\n");
2247 ++num_host_resets;
2248 spin_lock(&sdebug_host_list_lock);
2249 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
2250 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
2251 dev_list)
2252 dev_info->reset = 1;
2253 }
2254 spin_unlock(&sdebug_host_list_lock);
2255 stop_all_queued();
2256 return SUCCESS;
2257}
2258
2259/* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
2260static int stop_queued_cmnd(struct scsi_cmnd * cmnd)
2261{
2262 unsigned long iflags;
2263 int k;
2264 struct sdebug_queued_cmd * sqcp;
2265
2266 spin_lock_irqsave(&queued_arr_lock, iflags);
2267 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2268 sqcp = &queued_arr[k];
2269 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
2270 del_timer_sync(&sqcp->cmnd_timer);
2271 sqcp->in_use = 0;
2272 sqcp->a_cmnd = NULL;
2273 break;
2274 }
2275 }
2276 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2277 return (k < SCSI_DEBUG_CANQUEUE) ? 1 : 0;
2278}
2279
2280/* Deletes (stops) timers of all queued commands */
2281static void stop_all_queued(void)
2282{
2283 unsigned long iflags;
2284 int k;
2285 struct sdebug_queued_cmd * sqcp;
2286
2287 spin_lock_irqsave(&queued_arr_lock, iflags);
2288 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2289 sqcp = &queued_arr[k];
2290 if (sqcp->in_use && sqcp->a_cmnd) {
2291 del_timer_sync(&sqcp->cmnd_timer);
2292 sqcp->in_use = 0;
2293 sqcp->a_cmnd = NULL;
2294 }
2295 }
2296 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2297}
2298
2299/* Initializes timers in queued array */
2300static void __init init_all_queued(void)
2301{
2302 unsigned long iflags;
2303 int k;
2304 struct sdebug_queued_cmd * sqcp;
2305
2306 spin_lock_irqsave(&queued_arr_lock, iflags);
2307 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2308 sqcp = &queued_arr[k];
2309 init_timer(&sqcp->cmnd_timer);
2310 sqcp->in_use = 0;
2311 sqcp->a_cmnd = NULL;
2312 }
2313 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2314}
2315
2316static void __init sdebug_build_parts(unsigned char * ramp)
2317{
2318 struct partition * pp;
2319 int starts[SDEBUG_MAX_PARTS + 2];
2320 int sectors_per_part, num_sectors, k;
2321 int heads_by_sects, start_sec, end_sec;
2322
2323 /* assume partition table already zeroed */
2324 if ((scsi_debug_num_parts < 1) || (sdebug_store_size < 1048576))
2325 return;
2326 if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
2327 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
2328 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
2329 "partitions to %d\n", SDEBUG_MAX_PARTS);
2330 }
c65b1445 2331 num_sectors = (int)sdebug_store_sectors;
1da177e4
LT		 2332 sectors_per_part = (num_sectors - sdebug_sectors_per)
2333 / scsi_debug_num_parts;
2334 heads_by_sects = sdebug_heads * sdebug_sectors_per;
2335 starts[0] = sdebug_sectors_per;
2336 for (k = 1; k < scsi_debug_num_parts; ++k)
2337 starts[k] = ((k * sectors_per_part) / heads_by_sects)
2338 * heads_by_sects;
2339 starts[scsi_debug_num_parts] = num_sectors;
2340 starts[scsi_debug_num_parts + 1] = 0;
2341
2342 ramp[510] = 0x55; /* magic partition markings */
2343 ramp[511] = 0xAA;
2344 pp = (struct partition *)(ramp + 0x1be);
2345 for (k = 0; starts[k + 1]; ++k, ++pp) {
2346 start_sec = starts[k];
2347 end_sec = starts[k + 1] - 1;
2348 pp->boot_ind = 0;
2349
2350 pp->cyl = start_sec / heads_by_sects;
2351 pp->head = (start_sec - (pp->cyl * heads_by_sects))
2352 / sdebug_sectors_per;
2353 pp->sector = (start_sec % sdebug_sectors_per) + 1;
2354
2355 pp->end_cyl = end_sec / heads_by_sects;
2356 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
2357 / sdebug_sectors_per;
2358 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2359
2360 pp->start_sect = start_sec;
2361 pp->nr_sects = end_sec - start_sec + 1;
2362 pp->sys_ind = 0x83; /* plain Linux partition */
2363 }
2364}
2365
2366static int schedule_resp(struct scsi_cmnd * cmnd,
2367 struct sdebug_dev_info * devip,
2368 done_funct_t done, int scsi_result, int delta_jiff)
2369{
2370 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
2371 if (scsi_result) {
2372 struct scsi_device * sdp = cmnd->device;
2373
c65b1445
DG		 2374 printk(KERN_INFO "scsi_debug: <%u %u %u %u> "
2375 "non-zero result=0x%x\n", sdp->host->host_no,
2376 sdp->channel, sdp->id, sdp->lun, scsi_result);
1da177e4
LT		 2377 }
2378 }
2379 if (cmnd && devip) {
2380 /* simulate autosense by this driver */
2381 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
2382 memcpy(cmnd->sense_buffer, devip->sense_buff,
2383 (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
2384 SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
2385 }
2386 if (delta_jiff <= 0) {
2387 if (cmnd)
2388 cmnd->result = scsi_result;
2389 if (done)
2390 done(cmnd);
2391 return 0;
2392 } else {
2393 unsigned long iflags;
2394 int k;
2395 struct sdebug_queued_cmd * sqcp = NULL;
2396
2397 spin_lock_irqsave(&queued_arr_lock, iflags);
2398 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2399 sqcp = &queued_arr[k];
2400 if (! sqcp->in_use)
2401 break;
2402 }
2403 if (k >= SCSI_DEBUG_CANQUEUE) {
2404 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2405 printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
2406 return 1; /* report busy to mid level */
2407 }
2408 sqcp->in_use = 1;
2409 sqcp->a_cmnd = cmnd;
2410 sqcp->scsi_result = scsi_result;
2411 sqcp->done_funct = done;
2412 sqcp->cmnd_timer.function = timer_intr_handler;
2413 sqcp->cmnd_timer.data = k;
2414 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
2415 add_timer(&sqcp->cmnd_timer);
2416 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2417 if (cmnd)
2418 cmnd->result = 0;
2419 return 0;
2420 }
2421}
2422
23183910
DG		 2423/* Note: The following macros create attribute files in the
2424 /sys/module/scsi_debug/parameters directory. Unfortunately this
2425 driver is unaware of a change and cannot trigger auxiliary actions
2426 as it can when the corresponding attribute in the
2427 /sys/bus/pseudo/drivers/scsi_debug directory is changed.
2428 */
c65b1445
DG		 2429module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
2430module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
2431module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
2432module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
2433module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
23183910 2434module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
c65b1445
DG		 2435module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
2436module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
2437module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
2438module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
2439module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
2440module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
2441module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
2442module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
23183910
DG		 2443module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
2444 S_IRUGO | S_IWUSR);
1da177e4
LT		 2445
2446MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2447MODULE_DESCRIPTION("SCSI debug adapter driver");
2448MODULE_LICENSE("GPL");
2449MODULE_VERSION(SCSI_DEBUG_VERSION);
2450
2451MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
2452MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
c65b1445
DG		 2453MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
2454MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
beb87c33 2455MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
23183910 2456MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
c65b1445
DG		 2457MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
2458MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
1da177e4 2459MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
c65b1445 2460MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
6f3cbf55 2461MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
1da177e4
LT		 2462MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
2463MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
c65b1445 2464MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
23183910 2465MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
1da177e4
LT		 2466
2467
2468static char sdebug_info[256];
2469
2470static const char * scsi_debug_info(struct Scsi_Host * shp)
2471{
2472 sprintf(sdebug_info, "scsi_debug, version %s [%s], "
2473 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
2474 scsi_debug_version_date, scsi_debug_dev_size_mb,
2475 scsi_debug_opts);
2476 return sdebug_info;
2477}
2478
2479/* scsi_debug_proc_info
2480 * Used if the driver currently has no own support for /proc/scsi
2481 */
2482static int scsi_debug_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
2483 int length, int inout)
2484{
2485 int len, pos, begin;
2486 int orig_length;
2487
2488 orig_length = length;
2489
2490 if (inout == 1) {
2491 char arr[16];
2492 int minLen = length > 15 ? 15 : length;
2493
2494 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2495 return -EACCES;
2496 memcpy(arr, buffer, minLen);
2497 arr[minLen] = '\0';
2498 if (1 != sscanf(arr, "%d", &pos))
2499 return -EINVAL;
2500 scsi_debug_opts = pos;
2501 if (scsi_debug_every_nth != 0)
2502 scsi_debug_cmnd_count = 0;
2503 return length;
2504 }
2505 begin = 0;
2506 pos = len = sprintf(buffer, "scsi_debug adapter driver, version "
2507 "%s [%s]\n"
2508 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2509 "every_nth=%d(curr:%d)\n"
2510 "delay=%d, max_luns=%d, scsi_level=%d\n"
2511 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2512 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2513 "host_resets=%d\n",
2514 SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
2515 scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2516 scsi_debug_cmnd_count, scsi_debug_delay,
2517 scsi_debug_max_luns, scsi_debug_scsi_level,
2518 SECT_SIZE, sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
2519 num_aborts, num_dev_resets, num_bus_resets, num_host_resets);
2520 if (pos < offset) {
2521 len = 0;
2522 begin = pos;
2523 }
2524 *start = buffer + (offset - begin); /* Start of wanted data */
2525 len -= (offset - begin);
2526 if (len > length)
2527 len = length;
2528 return len;
2529}
2530
2531static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf)
2532{
2533 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
2534}
2535
2536static ssize_t sdebug_delay_store(struct device_driver * ddp,
2537 const char * buf, size_t count)
2538{
2539 int delay;
2540 char work[20];
2541
2542 if (1 == sscanf(buf, "%10s", work)) {
2543 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
2544 scsi_debug_delay = delay;
2545 return count;
2546 }
2547 }
2548 return -EINVAL;
2549}
2550DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show,
2551 sdebug_delay_store);
2552
2553static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf)
2554{
2555 return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
2556}
2557
2558static ssize_t sdebug_opts_store(struct device_driver * ddp,
2559 const char * buf, size_t count)
2560{
2561 int opts;
2562 char work[20];
2563
2564 if (1 == sscanf(buf, "%10s", work)) {
2565 if (0 == strnicmp(work,"0x", 2)) {
2566 if (1 == sscanf(&work[2], "%x", &opts))
2567 goto opts_done;
2568 } else {
2569 if (1 == sscanf(work, "%d", &opts))
2570 goto opts_done;
2571 }
2572 }
2573 return -EINVAL;
2574opts_done:
2575 scsi_debug_opts = opts;
2576 scsi_debug_cmnd_count = 0;
2577 return count;
2578}
2579DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show,
2580 sdebug_opts_store);
2581
2582static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf)
2583{
2584 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
2585}
2586static ssize_t sdebug_ptype_store(struct device_driver * ddp,
2587 const char * buf, size_t count)
2588{
2589 int n;
2590
2591 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2592 scsi_debug_ptype = n;
2593 return count;
2594 }
2595 return -EINVAL;
2596}
2597DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store);
2598
2599static ssize_t sdebug_dsense_show(struct device_driver * ddp, char * buf)
2600{
2601 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
2602}
2603static ssize_t sdebug_dsense_store(struct device_driver * ddp,
2604 const char * buf, size_t count)
2605{
2606 int n;
2607
2608 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2609 scsi_debug_dsense = n;
2610 return count;
2611 }
2612 return -EINVAL;
2613}
2614DRIVER_ATTR(dsense, S_IRUGO | S_IWUSR, sdebug_dsense_show,
2615 sdebug_dsense_store);
2616
23183910
DG		 2617static ssize_t sdebug_fake_rw_show(struct device_driver * ddp, char * buf)
2618{
2619 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
2620}
2621static ssize_t sdebug_fake_rw_store(struct device_driver * ddp,
2622 const char * buf, size_t count)
2623{
2624 int n;
2625
2626 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2627 scsi_debug_fake_rw = n;
2628 return count;
2629 }
2630 return -EINVAL;
2631}
2632DRIVER_ATTR(fake_rw, S_IRUGO | S_IWUSR, sdebug_fake_rw_show,
2633 sdebug_fake_rw_store);
2634
c65b1445
DG		 2635static ssize_t sdebug_no_lun_0_show(struct device_driver * ddp, char * buf)
2636{
2637 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
2638}
2639static ssize_t sdebug_no_lun_0_store(struct device_driver * ddp,
2640 const char * buf, size_t count)
2641{
2642 int n;
2643
2644 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2645 scsi_debug_no_lun_0 = n;
2646 return count;
2647 }
2648 return -EINVAL;
2649}
2650DRIVER_ATTR(no_lun_0, S_IRUGO | S_IWUSR, sdebug_no_lun_0_show,
2651 sdebug_no_lun_0_store);
2652
1da177e4
LT		 2653static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf)
2654{
2655 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
2656}
2657static ssize_t sdebug_num_tgts_store(struct device_driver * ddp,
2658 const char * buf, size_t count)
2659{
2660 int n;
2661
2662 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2663 scsi_debug_num_tgts = n;
2664 sdebug_max_tgts_luns();
2665 return count;
2666 }
2667 return -EINVAL;
2668}
2669DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show,
2670 sdebug_num_tgts_store);
2671
2672static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf)
2673{
2674 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
2675}
2676DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL);
2677
2678static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf)
2679{
2680 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
2681}
2682DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL);
2683
2684static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf)
2685{
2686 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
2687}
2688static ssize_t sdebug_every_nth_store(struct device_driver * ddp,
2689 const char * buf, size_t count)
2690{
2691 int nth;
2692
2693 if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
2694 scsi_debug_every_nth = nth;
2695 scsi_debug_cmnd_count = 0;
2696 return count;
2697 }
2698 return -EINVAL;
2699}
2700DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show,
2701 sdebug_every_nth_store);
2702
2703static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf)
2704{
2705 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
2706}
2707static ssize_t sdebug_max_luns_store(struct device_driver * ddp,
2708 const char * buf, size_t count)
2709{
2710 int n;
2711
2712 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2713 scsi_debug_max_luns = n;
2714 sdebug_max_tgts_luns();
2715 return count;
2716 }
2717 return -EINVAL;
2718}
2719DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show,
2720 sdebug_max_luns_store);
2721
2722static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf)
2723{
2724 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
2725}
2726DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL);
2727
c65b1445
DG		 2728static ssize_t sdebug_virtual_gb_show(struct device_driver * ddp, char * buf)
2729{
2730 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
2731}
2732static ssize_t sdebug_virtual_gb_store(struct device_driver * ddp,
2733 const char * buf, size_t count)
2734{
2735 int n;
2736
2737 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2738 scsi_debug_virtual_gb = n;
2739 if (scsi_debug_virtual_gb > 0) {
2740 sdebug_capacity = 2048 * 1024;
2741 sdebug_capacity *= scsi_debug_virtual_gb;
2742 } else
2743 sdebug_capacity = sdebug_store_sectors;
2744 return count;
2745 }
2746 return -EINVAL;
2747}
2748DRIVER_ATTR(virtual_gb, S_IRUGO | S_IWUSR, sdebug_virtual_gb_show,
2749 sdebug_virtual_gb_store);
2750
1da177e4
LT		 2751static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf)
2752{
2753 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
2754}
2755
2756static ssize_t sdebug_add_host_store(struct device_driver * ddp,
2757 const char * buf, size_t count)
2758{
2759 int delta_hosts;
2760 char work[20];
2761
2762 if (1 != sscanf(buf, "%10s", work))
2763 return -EINVAL;
2764 { /* temporary hack around sscanf() problem with -ve nums */
2765 int neg = 0;
2766
2767 if ('-' == *work)
2768 neg = 1;
2769 if (1 != sscanf(work + neg, "%d", &delta_hosts))
2770 return -EINVAL;
2771 if (neg)
2772 delta_hosts = -delta_hosts;
2773 }
2774 if (delta_hosts > 0) {
2775 do {
2776 sdebug_add_adapter();
2777 } while (--delta_hosts);
2778 } else if (delta_hosts < 0) {
2779 do {
2780 sdebug_remove_adapter();
2781 } while (++delta_hosts);
2782 }
2783 return count;
2784}
2785DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show,
2786 sdebug_add_host_store);
2787
23183910
DG		 2788static ssize_t sdebug_vpd_use_hostno_show(struct device_driver * ddp,
2789 char * buf)
2790{
2791 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
2792}
2793static ssize_t sdebug_vpd_use_hostno_store(struct device_driver * ddp,
2794 const char * buf, size_t count)
2795{
2796 int n;
2797
2798 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2799 scsi_debug_vpd_use_hostno = n;
2800 return count;
2801 }
2802 return -EINVAL;
2803}
2804DRIVER_ATTR(vpd_use_hostno, S_IRUGO | S_IWUSR, sdebug_vpd_use_hostno_show,
2805 sdebug_vpd_use_hostno_store);
2806
2807/* Note: The following function creates attribute files in the
2808 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
2809 files (over those found in the /sys/module/scsi_debug/parameters
2810 directory) is that auxiliary actions can be triggered when an attribute
2811 is changed. For example see: sdebug_add_host_store() above.
2812 */
6ecaff7f 2813static int do_create_driverfs_files(void)
1da177e4 2814{
6ecaff7f
RD		 2815 int ret;
2816
2817 ret = driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2818 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay);
2819 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2820 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2821 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
23183910 2822 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
6ecaff7f 2823 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
23183910 2824 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
6ecaff7f 2825 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
23183910 2826 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
6ecaff7f
RD		 2827 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2828 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts);
2829 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
23183910
DG		 2830 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2831 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
6ecaff7f 2832 return ret;
1da177e4
LT		 2833}
2834
2835static void do_remove_driverfs_files(void)
2836{
23183910
DG		 2837 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2838 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
1da177e4
LT		 2839 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2840 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts);
2841 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype);
1da177e4 2842 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
23183910
DG		 2843 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2844 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
1da177e4 2845 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
23183910 2846 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
1da177e4
LT		 2847 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2848 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2849 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2850 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay);
2851 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2852}
2853
2854static int __init scsi_debug_init(void)
2855{
c65b1445 2856 unsigned int sz;
1da177e4
LT		 2857 int host_to_add;
2858 int k;
6ecaff7f 2859 int ret;
1da177e4
LT		 2860
2861 if (scsi_debug_dev_size_mb < 1)
2862 scsi_debug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */
c65b1445
DG		 2863 sdebug_store_size = (unsigned int)scsi_debug_dev_size_mb * 1048576;
2864 sdebug_store_sectors = sdebug_store_size / SECT_SIZE;
2865 if (scsi_debug_virtual_gb > 0) {
2866 sdebug_capacity = 2048 * 1024;
2867 sdebug_capacity *= scsi_debug_virtual_gb;
2868 } else
2869 sdebug_capacity = sdebug_store_sectors;
1da177e4
LT		 2870
2871 /* play around with geometry, don't waste too much on track 0 */
2872 sdebug_heads = 8;
2873 sdebug_sectors_per = 32;
2874 if (scsi_debug_dev_size_mb >= 16)
2875 sdebug_heads = 32;
2876 else if (scsi_debug_dev_size_mb >= 256)
2877 sdebug_heads = 64;
2878 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2879 (sdebug_sectors_per * sdebug_heads);
2880 if (sdebug_cylinders_per >= 1024) {
2881 /* other LLDs do this; implies >= 1GB ram disk ... */
2882 sdebug_heads = 255;
2883 sdebug_sectors_per = 63;
2884 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2885 (sdebug_sectors_per * sdebug_heads);
2886 }
2887
2888 sz = sdebug_store_size;
2889 fake_storep = vmalloc(sz);
2890 if (NULL == fake_storep) {
2891 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
2892 return -ENOMEM;
2893 }
2894 memset(fake_storep, 0, sz);
2895 if (scsi_debug_num_parts > 0)
2896 sdebug_build_parts(fake_storep);
2897
6ecaff7f
RD		 2898 ret = device_register(&pseudo_primary);
2899 if (ret < 0) {
2900 printk(KERN_WARNING "scsi_debug: device_register error: %d\n",
2901 ret);
2902 goto free_vm;
2903 }
2904 ret = bus_register(&pseudo_lld_bus);
2905 if (ret < 0) {
2906 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
2907 ret);
2908 goto dev_unreg;
2909 }
2910 ret = driver_register(&sdebug_driverfs_driver);
2911 if (ret < 0) {
2912 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
2913 ret);
2914 goto bus_unreg;
2915 }
2916 ret = do_create_driverfs_files();
2917 if (ret < 0) {
2918 printk(KERN_WARNING "scsi_debug: driver_create_file error: %d\n",
2919 ret);
2920 goto del_files;
2921 }
1da177e4 2922
6ecaff7f 2923 init_all_queued();
1da177e4 2924
b02b6bc4 2925 sdebug_driver_template.proc_name = sdebug_proc_name;
1da177e4
LT		 2926
2927 host_to_add = scsi_debug_add_host;
2928 scsi_debug_add_host = 0;
2929
2930 for (k = 0; k < host_to_add; k++) {
2931 if (sdebug_add_adapter()) {
2932 printk(KERN_ERR "scsi_debug_init: "
2933 "sdebug_add_adapter failed k=%d\n", k);
2934 break;
2935 }
2936 }
2937
2938 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
2939 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
2940 scsi_debug_add_host);
2941 }
2942 return 0;
6ecaff7f
RD		 2943
2944del_files:
2945 do_remove_driverfs_files();
2946 driver_unregister(&sdebug_driverfs_driver);
2947bus_unreg:
2948 bus_unregister(&pseudo_lld_bus);
2949dev_unreg:
2950 device_unregister(&pseudo_primary);
2951free_vm:
2952 vfree(fake_storep);
2953
2954 return ret;
1da177e4
LT		 2955}
2956
2957static void __exit scsi_debug_exit(void)
2958{
2959 int k = scsi_debug_add_host;
2960
2961 stop_all_queued();
2962 for (; k; k--)
2963 sdebug_remove_adapter();
2964 do_remove_driverfs_files();
2965 driver_unregister(&sdebug_driverfs_driver);
2966 bus_unregister(&pseudo_lld_bus);
2967 device_unregister(&pseudo_primary);
2968
2969 vfree(fake_storep);
2970}
2971
2972device_initcall(scsi_debug_init);
2973module_exit(scsi_debug_exit);
2974
52c1da39 2975static void pseudo_0_release(struct device * dev)
1da177e4
LT		 2976{
2977 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2978 printk(KERN_INFO "scsi_debug: pseudo_0_release() called\n");
2979}
2980
2981static struct device pseudo_primary = {
2982 .bus_id = "pseudo_0",
2983 .release = pseudo_0_release,
2984};
2985
2986static int pseudo_lld_bus_match(struct device *dev,
2987 struct device_driver *dev_driver)
2988{
2989 return 1;
2990}
2991
2992static struct bus_type pseudo_lld_bus = {
2993 .name = "pseudo",
2994 .match = pseudo_lld_bus_match,
bbbe3a41
RK		 2995 .probe = sdebug_driver_probe,
2996 .remove = sdebug_driver_remove,
1da177e4
LT		 2997};
2998
2999static void sdebug_release_adapter(struct device * dev)
3000{
3001 struct sdebug_host_info *sdbg_host;
3002
3003 sdbg_host = to_sdebug_host(dev);
3004 kfree(sdbg_host);
3005}
3006
3007static int sdebug_add_adapter(void)
3008{
3009 int k, devs_per_host;
3010 int error = 0;
3011 struct sdebug_host_info *sdbg_host;
3012 struct sdebug_dev_info *sdbg_devinfo;
3013 struct list_head *lh, *lh_sf;
3014
c65b1445 3015 sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
1da177e4
LT		 3016 if (NULL == sdbg_host) {
3017 printk(KERN_ERR "%s: out of memory at line %d\n",
3018 __FUNCTION__, __LINE__);
3019 return -ENOMEM;
3020 }
3021
1da177e4
LT		 3022 INIT_LIST_HEAD(&sdbg_host->dev_info_list);
3023
3024 devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
3025 for (k = 0; k < devs_per_host; k++) {
c65b1445 3026 sdbg_devinfo = kzalloc(sizeof(*sdbg_devinfo),GFP_KERNEL);
1da177e4
LT		 3027 if (NULL == sdbg_devinfo) {
3028 printk(KERN_ERR "%s: out of memory at line %d\n",
3029 __FUNCTION__, __LINE__);
3030 error = -ENOMEM;
3031 goto clean;
3032 }
1da177e4
LT		 3033 sdbg_devinfo->sdbg_host = sdbg_host;
3034 list_add_tail(&sdbg_devinfo->dev_list,
3035 &sdbg_host->dev_info_list);
3036 }
3037
3038 spin_lock(&sdebug_host_list_lock);
3039 list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
3040 spin_unlock(&sdebug_host_list_lock);
3041
3042 sdbg_host->dev.bus = &pseudo_lld_bus;
3043 sdbg_host->dev.parent = &pseudo_primary;
3044 sdbg_host->dev.release = &sdebug_release_adapter;
3045 sprintf(sdbg_host->dev.bus_id, "adapter%d", scsi_debug_add_host);
3046
3047 error = device_register(&sdbg_host->dev);
3048
3049 if (error)
3050 goto clean;
3051
3052 ++scsi_debug_add_host;
3053 return error;
3054
3055clean:
3056 list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
3057 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
3058 dev_list);
3059 list_del(&sdbg_devinfo->dev_list);
3060 kfree(sdbg_devinfo);
3061 }
3062
3063 kfree(sdbg_host);
3064 return error;
3065}
3066
3067static void sdebug_remove_adapter(void)
3068{
3069 struct sdebug_host_info * sdbg_host = NULL;
3070
3071 spin_lock(&sdebug_host_list_lock);
3072 if (!list_empty(&sdebug_host_list)) {
3073 sdbg_host = list_entry(sdebug_host_list.prev,
3074 struct sdebug_host_info, host_list);
3075 list_del(&sdbg_host->host_list);
3076 }
3077 spin_unlock(&sdebug_host_list_lock);
3078
3079 if (!sdbg_host)
3080 return;
3081
3082 device_unregister(&sdbg_host->dev);
3083 --scsi_debug_add_host;
3084}
3085
3086static int sdebug_driver_probe(struct device * dev)
3087{
3088 int error = 0;
3089 struct sdebug_host_info *sdbg_host;
3090 struct Scsi_Host *hpnt;
3091
3092 sdbg_host = to_sdebug_host(dev);
3093
3094 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
3095 if (NULL == hpnt) {
3096 printk(KERN_ERR "%s: scsi_register failed\n", __FUNCTION__);
3097 error = -ENODEV;
3098 return error;
3099 }
3100
3101 sdbg_host->shost = hpnt;
3102 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
3103 if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
3104 hpnt->max_id = scsi_debug_num_tgts + 1;
3105 else
3106 hpnt->max_id = scsi_debug_num_tgts;
c65b1445 3107 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* = scsi_debug_max_luns; */
1da177e4
LT		 3108
3109 error = scsi_add_host(hpnt, &sdbg_host->dev);
3110 if (error) {
3111 printk(KERN_ERR "%s: scsi_add_host failed\n", __FUNCTION__);
3112 error = -ENODEV;
3113 scsi_host_put(hpnt);
3114 } else
3115 scsi_scan_host(hpnt);
3116
3117
3118 return error;
3119}
3120
3121static int sdebug_driver_remove(struct device * dev)
3122{
3123 struct list_head *lh, *lh_sf;
3124 struct sdebug_host_info *sdbg_host;
3125 struct sdebug_dev_info *sdbg_devinfo;
3126
3127 sdbg_host = to_sdebug_host(dev);
3128
3129 if (!sdbg_host) {
3130 printk(KERN_ERR "%s: Unable to locate host info\n",
3131 __FUNCTION__);
3132 return -ENODEV;
3133 }
3134
3135 scsi_remove_host(sdbg_host->shost);
3136
3137 list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
3138 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
3139 dev_list);
3140 list_del(&sdbg_devinfo->dev_list);
3141 kfree(sdbg_devinfo);
3142 }
3143
3144 scsi_host_put(sdbg_host->shost);
3145 return 0;
3146}
3147
3148static void sdebug_max_tgts_luns(void)
3149{
3150 struct sdebug_host_info * sdbg_host;
3151 struct Scsi_Host *hpnt;
3152
3153 spin_lock(&sdebug_host_list_lock);
3154 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
3155 hpnt = sdbg_host->shost;
3156 if ((hpnt->this_id >= 0) &&
3157 (scsi_debug_num_tgts > hpnt->this_id))
3158 hpnt->max_id = scsi_debug_num_tgts + 1;
3159 else
3160 hpnt->max_id = scsi_debug_num_tgts;
c65b1445 3161 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* scsi_debug_max_luns; */
1da177e4
LT		 3162 }
3163 spin_unlock(&sdebug_host_list_lock);
3164}
ubuntu-zesty-kernel mirror