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