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