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