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