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