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