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