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