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