?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
thinkpad-acpi: explain errors from acpi_install_notify_handler
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / scsi / scsi_debug.c
blobbc3e3636a3b8180cf1c04bd5ea44e37de1a92543
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 (sector_t)scsi_debug_virtual_gb *
918 (1073741824 / scsi_debug_sector_size);
919 else
920 return sdebug_store_sectors;
921 }
922
923 #define SDEBUG_READCAP_ARR_SZ 8
924 static int resp_readcap(struct scsi_cmnd * scp,
925 struct sdebug_dev_info * devip)
926 {
927 unsigned char arr[SDEBUG_READCAP_ARR_SZ];
928 unsigned int capac;
929 int errsts;
930
931 if ((errsts = check_readiness(scp, 1, devip)))
932 return errsts;
933 /* following just in case virtual_gb changed */
934 sdebug_capacity = get_sdebug_capacity();
935 memset(arr, 0, SDEBUG_READCAP_ARR_SZ);
936 if (sdebug_capacity < 0xffffffff) {
937 capac = (unsigned int)sdebug_capacity - 1;
938 arr[0] = (capac >> 24);
939 arr[1] = (capac >> 16) & 0xff;
940 arr[2] = (capac >> 8) & 0xff;
941 arr[3] = capac & 0xff;
942 } else {
943 arr[0] = 0xff;
944 arr[1] = 0xff;
945 arr[2] = 0xff;
946 arr[3] = 0xff;
947 }
948 arr[6] = (scsi_debug_sector_size >> 8) & 0xff;
949 arr[7] = scsi_debug_sector_size & 0xff;
950 return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ);
951 }
952
953 #define SDEBUG_READCAP16_ARR_SZ 32
954 static int resp_readcap16(struct scsi_cmnd * scp,
955 struct sdebug_dev_info * devip)
956 {
957 unsigned char *cmd = (unsigned char *)scp->cmnd;
958 unsigned char arr[SDEBUG_READCAP16_ARR_SZ];
959 unsigned long long capac;
960 int errsts, k, alloc_len;
961
962 if ((errsts = check_readiness(scp, 1, devip)))
963 return errsts;
964 alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8)
965 + cmd[13]);
966 /* following just in case virtual_gb changed */
967 sdebug_capacity = get_sdebug_capacity();
968 memset(arr, 0, SDEBUG_READCAP16_ARR_SZ);
969 capac = sdebug_capacity - 1;
970 for (k = 0; k < 8; ++k, capac >>= 8)
971 arr[7 - k] = capac & 0xff;
972 arr[8] = (scsi_debug_sector_size >> 24) & 0xff;
973 arr[9] = (scsi_debug_sector_size >> 16) & 0xff;
974 arr[10] = (scsi_debug_sector_size >> 8) & 0xff;
975 arr[11] = scsi_debug_sector_size & 0xff;
976 arr[13] = scsi_debug_physblk_exp & 0xf;
977 arr[14] = (scsi_debug_lowest_aligned >> 8) & 0x3f;
978 arr[15] = scsi_debug_lowest_aligned & 0xff;
979
980 if (scsi_debug_dif) {
981 arr[12] = (scsi_debug_dif - 1) << 1; /* P_TYPE */
982 arr[12] |= 1; /* PROT_EN */
983 }
984
985 return fill_from_dev_buffer(scp, arr,
986 min(alloc_len, SDEBUG_READCAP16_ARR_SZ));
987 }
988
989 #define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
990
991 static int resp_report_tgtpgs(struct scsi_cmnd * scp,
992 struct sdebug_dev_info * devip)
993 {
994 unsigned char *cmd = (unsigned char *)scp->cmnd;
995 unsigned char * arr;
996 int host_no = devip->sdbg_host->shost->host_no;
997 int n, ret, alen, rlen;
998 int port_group_a, port_group_b, port_a, port_b;
999
1000 alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8)
1001 + cmd[9]);
1002
1003 arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC);
1004 if (! arr)
1005 return DID_REQUEUE << 16;
1006 /*
1007 * EVPD page 0x88 states we have two ports, one
1008 * real and a fake port with no device connected.
1009 * So we create two port groups with one port each
1010 * and set the group with port B to unavailable.
1011 */
1012 port_a = 0x1; /* relative port A */
1013 port_b = 0x2; /* relative port B */
1014 port_group_a = (((host_no + 1) & 0x7f) << 8) +
1015 (devip->channel & 0x7f);
1016 port_group_b = (((host_no + 1) & 0x7f) << 8) +
1017 (devip->channel & 0x7f) + 0x80;
1018
1019 /*
1020 * The asymmetric access state is cycled according to the host_id.
1021 */
1022 n = 4;
1023 if (0 == scsi_debug_vpd_use_hostno) {
1024 arr[n++] = host_no % 3; /* Asymm access state */
1025 arr[n++] = 0x0F; /* claim: all states are supported */
1026 } else {
1027 arr[n++] = 0x0; /* Active/Optimized path */
1028 arr[n++] = 0x01; /* claim: only support active/optimized paths */
1029 }
1030 arr[n++] = (port_group_a >> 8) & 0xff;
1031 arr[n++] = port_group_a & 0xff;
1032 arr[n++] = 0; /* Reserved */
1033 arr[n++] = 0; /* Status code */
1034 arr[n++] = 0; /* Vendor unique */
1035 arr[n++] = 0x1; /* One port per group */
1036 arr[n++] = 0; /* Reserved */
1037 arr[n++] = 0; /* Reserved */
1038 arr[n++] = (port_a >> 8) & 0xff;
1039 arr[n++] = port_a & 0xff;
1040 arr[n++] = 3; /* Port unavailable */
1041 arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */
1042 arr[n++] = (port_group_b >> 8) & 0xff;
1043 arr[n++] = port_group_b & 0xff;
1044 arr[n++] = 0; /* Reserved */
1045 arr[n++] = 0; /* Status code */
1046 arr[n++] = 0; /* Vendor unique */
1047 arr[n++] = 0x1; /* One port per group */
1048 arr[n++] = 0; /* Reserved */
1049 arr[n++] = 0; /* Reserved */
1050 arr[n++] = (port_b >> 8) & 0xff;
1051 arr[n++] = port_b & 0xff;
1052
1053 rlen = n - 4;
1054 arr[0] = (rlen >> 24) & 0xff;
1055 arr[1] = (rlen >> 16) & 0xff;
1056 arr[2] = (rlen >> 8) & 0xff;
1057 arr[3] = rlen & 0xff;
1058
1059 /*
1060 * Return the smallest value of either
1061 * - The allocated length
1062 * - The constructed command length
1063 * - The maximum array size
1064 */
1065 rlen = min(alen,n);
1066 ret = fill_from_dev_buffer(scp, arr,
1067 min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ));
1068 kfree(arr);
1069 return ret;
1070 }
1071
1072 /* <<Following mode page info copied from ST318451LW>> */
1073
1074 static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
1075 { /* Read-Write Error Recovery page for mode_sense */
1076 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
1077 5, 0, 0xff, 0xff};
1078
1079 memcpy(p, err_recov_pg, sizeof(err_recov_pg));
1080 if (1 == pcontrol)
1081 memset(p + 2, 0, sizeof(err_recov_pg) - 2);
1082 return sizeof(err_recov_pg);
1083 }
1084
1085 static int resp_disconnect_pg(unsigned char * p, int pcontrol, int target)
1086 { /* Disconnect-Reconnect page for mode_sense */
1087 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
1088 0, 0, 0, 0, 0, 0, 0, 0};
1089
1090 memcpy(p, disconnect_pg, sizeof(disconnect_pg));
1091 if (1 == pcontrol)
1092 memset(p + 2, 0, sizeof(disconnect_pg) - 2);
1093 return sizeof(disconnect_pg);
1094 }
1095
1096 static int resp_format_pg(unsigned char * p, int pcontrol, int target)
1097 { /* Format device page for mode_sense */
1098 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
1099 0, 0, 0, 0, 0, 0, 0, 0,
1100 0, 0, 0, 0, 0x40, 0, 0, 0};
1101
1102 memcpy(p, format_pg, sizeof(format_pg));
1103 p[10] = (sdebug_sectors_per >> 8) & 0xff;
1104 p[11] = sdebug_sectors_per & 0xff;
1105 p[12] = (scsi_debug_sector_size >> 8) & 0xff;
1106 p[13] = scsi_debug_sector_size & 0xff;
1107 if (DEV_REMOVEABLE(target))
1108 p[20] |= 0x20; /* should agree with INQUIRY */
1109 if (1 == pcontrol)
1110 memset(p + 2, 0, sizeof(format_pg) - 2);
1111 return sizeof(format_pg);
1112 }
1113
1114 static int resp_caching_pg(unsigned char * p, int pcontrol, int target)
1115 { /* Caching page for mode_sense */
1116 unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1117 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
1118
1119 memcpy(p, caching_pg, sizeof(caching_pg));
1120 if (1 == pcontrol)
1121 memset(p + 2, 0, sizeof(caching_pg) - 2);
1122 return sizeof(caching_pg);
1123 }
1124
1125 static int resp_ctrl_m_pg(unsigned char * p, int pcontrol, int target)
1126 { /* Control mode page for mode_sense */
1127 unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0,
1128 0, 0, 0, 0};
1129 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1130 0, 0, 0x2, 0x4b};
1131
1132 if (scsi_debug_dsense)
1133 ctrl_m_pg[2] |= 0x4;
1134 else
1135 ctrl_m_pg[2] &= ~0x4;
1136
1137 if (scsi_debug_ato)
1138 ctrl_m_pg[5] |= 0x80; /* ATO=1 */
1139
1140 memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
1141 if (1 == pcontrol)
1142 memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg));
1143 else if (2 == pcontrol)
1144 memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg));
1145 return sizeof(ctrl_m_pg);
1146 }
1147
1148
1149 static int resp_iec_m_pg(unsigned char * p, int pcontrol, int target)
1150 { /* Informational Exceptions control mode page for mode_sense */
1151 unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0,
1152 0, 0, 0x0, 0x0};
1153 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1154 0, 0, 0x0, 0x0};
1155
1156 memcpy(p, iec_m_pg, sizeof(iec_m_pg));
1157 if (1 == pcontrol)
1158 memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg));
1159 else if (2 == pcontrol)
1160 memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg));
1161 return sizeof(iec_m_pg);
1162 }
1163
1164 static int resp_sas_sf_m_pg(unsigned char * p, int pcontrol, int target)
1165 { /* SAS SSP mode page - short format for mode_sense */
1166 unsigned char sas_sf_m_pg[] = {0x19, 0x6,
1167 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
1168
1169 memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg));
1170 if (1 == pcontrol)
1171 memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2);
1172 return sizeof(sas_sf_m_pg);
1173 }
1174
1175
1176 static int resp_sas_pcd_m_spg(unsigned char * p, int pcontrol, int target,
1177 int target_dev_id)
1178 { /* SAS phy control and discover mode page for mode_sense */
1179 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
1180 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
1181 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1182 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1183 0x2, 0, 0, 0, 0, 0, 0, 0,
1184 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1185 0, 0, 0, 0, 0, 0, 0, 0,
1186 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
1187 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1188 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1189 0x3, 0, 0, 0, 0, 0, 0, 0,
1190 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1191 0, 0, 0, 0, 0, 0, 0, 0,
1192 };
1193 int port_a, port_b;
1194
1195 port_a = target_dev_id + 1;
1196 port_b = port_a + 1;
1197 memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg));
1198 p[20] = (port_a >> 24);
1199 p[21] = (port_a >> 16) & 0xff;
1200 p[22] = (port_a >> 8) & 0xff;
1201 p[23] = port_a & 0xff;
1202 p[48 + 20] = (port_b >> 24);
1203 p[48 + 21] = (port_b >> 16) & 0xff;
1204 p[48 + 22] = (port_b >> 8) & 0xff;
1205 p[48 + 23] = port_b & 0xff;
1206 if (1 == pcontrol)
1207 memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4);
1208 return sizeof(sas_pcd_m_pg);
1209 }
1210
1211 static int resp_sas_sha_m_spg(unsigned char * p, int pcontrol)
1212 { /* SAS SSP shared protocol specific port mode subpage */
1213 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
1214 0, 0, 0, 0, 0, 0, 0, 0,
1215 };
1216
1217 memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg));
1218 if (1 == pcontrol)
1219 memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4);
1220 return sizeof(sas_sha_m_pg);
1221 }
1222
1223 #define SDEBUG_MAX_MSENSE_SZ 256
1224
1225 static int resp_mode_sense(struct scsi_cmnd * scp, int target,
1226 struct sdebug_dev_info * devip)
1227 {
1228 unsigned char dbd, llbaa;
1229 int pcontrol, pcode, subpcode, bd_len;
1230 unsigned char dev_spec;
1231 int k, alloc_len, msense_6, offset, len, errsts, target_dev_id;
1232 unsigned char * ap;
1233 unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
1234 unsigned char *cmd = (unsigned char *)scp->cmnd;
1235
1236 if ((errsts = check_readiness(scp, 1, devip)))
1237 return errsts;
1238 dbd = !!(cmd[1] & 0x8);
1239 pcontrol = (cmd[2] & 0xc0) >> 6;
1240 pcode = cmd[2] & 0x3f;
1241 subpcode = cmd[3];
1242 msense_6 = (MODE_SENSE == cmd[0]);
1243 llbaa = msense_6 ? 0 : !!(cmd[1] & 0x10);
1244 if ((0 == scsi_debug_ptype) && (0 == dbd))
1245 bd_len = llbaa ? 16 : 8;
1246 else
1247 bd_len = 0;
1248 alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]);
1249 memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
1250 if (0x3 == pcontrol) { /* Saving values not supported */
1251 mk_sense_buffer(devip, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP,
1252 0);
1253 return check_condition_result;
1254 }
1255 target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
1256 (devip->target * 1000) - 3;
1257 /* set DPOFUA bit for disks */
1258 if (0 == scsi_debug_ptype)
1259 dev_spec = (DEV_READONLY(target) ? 0x80 : 0x0) | 0x10;
1260 else
1261 dev_spec = 0x0;
1262 if (msense_6) {
1263 arr[2] = dev_spec;
1264 arr[3] = bd_len;
1265 offset = 4;
1266 } else {
1267 arr[3] = dev_spec;
1268 if (16 == bd_len)
1269 arr[4] = 0x1; /* set LONGLBA bit */
1270 arr[7] = bd_len; /* assume 255 or less */
1271 offset = 8;
1272 }
1273 ap = arr + offset;
1274 if ((bd_len > 0) && (!sdebug_capacity))
1275 sdebug_capacity = get_sdebug_capacity();
1276
1277 if (8 == bd_len) {
1278 if (sdebug_capacity > 0xfffffffe) {
1279 ap[0] = 0xff;
1280 ap[1] = 0xff;
1281 ap[2] = 0xff;
1282 ap[3] = 0xff;
1283 } else {
1284 ap[0] = (sdebug_capacity >> 24) & 0xff;
1285 ap[1] = (sdebug_capacity >> 16) & 0xff;
1286 ap[2] = (sdebug_capacity >> 8) & 0xff;
1287 ap[3] = sdebug_capacity & 0xff;
1288 }
1289 ap[6] = (scsi_debug_sector_size >> 8) & 0xff;
1290 ap[7] = scsi_debug_sector_size & 0xff;
1291 offset += bd_len;
1292 ap = arr + offset;
1293 } else if (16 == bd_len) {
1294 unsigned long long capac = sdebug_capacity;
1295
1296 for (k = 0; k < 8; ++k, capac >>= 8)
1297 ap[7 - k] = capac & 0xff;
1298 ap[12] = (scsi_debug_sector_size >> 24) & 0xff;
1299 ap[13] = (scsi_debug_sector_size >> 16) & 0xff;
1300 ap[14] = (scsi_debug_sector_size >> 8) & 0xff;
1301 ap[15] = scsi_debug_sector_size & 0xff;
1302 offset += bd_len;
1303 ap = arr + offset;
1304 }
1305
1306 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
1307 /* TODO: Control Extension page */
1308 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1309 0);
1310 return check_condition_result;
1311 }
1312 switch (pcode) {
1313 case 0x1: /* Read-Write error recovery page, direct access */
1314 len = resp_err_recov_pg(ap, pcontrol, target);
1315 offset += len;
1316 break;
1317 case 0x2: /* Disconnect-Reconnect page, all devices */
1318 len = resp_disconnect_pg(ap, pcontrol, target);
1319 offset += len;
1320 break;
1321 case 0x3: /* Format device page, direct access */
1322 len = resp_format_pg(ap, pcontrol, target);
1323 offset += len;
1324 break;
1325 case 0x8: /* Caching page, direct access */
1326 len = resp_caching_pg(ap, pcontrol, target);
1327 offset += len;
1328 break;
1329 case 0xa: /* Control Mode page, all devices */
1330 len = resp_ctrl_m_pg(ap, pcontrol, target);
1331 offset += len;
1332 break;
1333 case 0x19: /* if spc==1 then sas phy, control+discover */
1334 if ((subpcode > 0x2) && (subpcode < 0xff)) {
1335 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1336 INVALID_FIELD_IN_CDB, 0);
1337 return check_condition_result;
1338 }
1339 len = 0;
1340 if ((0x0 == subpcode) || (0xff == subpcode))
1341 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1342 if ((0x1 == subpcode) || (0xff == subpcode))
1343 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
1344 target_dev_id);
1345 if ((0x2 == subpcode) || (0xff == subpcode))
1346 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1347 offset += len;
1348 break;
1349 case 0x1c: /* Informational Exceptions Mode page, all devices */
1350 len = resp_iec_m_pg(ap, pcontrol, target);
1351 offset += len;
1352 break;
1353 case 0x3f: /* Read all Mode pages */
1354 if ((0 == subpcode) || (0xff == subpcode)) {
1355 len = resp_err_recov_pg(ap, pcontrol, target);
1356 len += resp_disconnect_pg(ap + len, pcontrol, target);
1357 len += resp_format_pg(ap + len, pcontrol, target);
1358 len += resp_caching_pg(ap + len, pcontrol, target);
1359 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
1360 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1361 if (0xff == subpcode) {
1362 len += resp_sas_pcd_m_spg(ap + len, pcontrol,
1363 target, target_dev_id);
1364 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1365 }
1366 len += resp_iec_m_pg(ap + len, pcontrol, target);
1367 } else {
1368 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1369 INVALID_FIELD_IN_CDB, 0);
1370 return check_condition_result;
1371 }
1372 offset += len;
1373 break;
1374 default:
1375 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1376 0);
1377 return check_condition_result;
1378 }
1379 if (msense_6)
1380 arr[0] = offset - 1;
1381 else {
1382 arr[0] = ((offset - 2) >> 8) & 0xff;
1383 arr[1] = (offset - 2) & 0xff;
1384 }
1385 return fill_from_dev_buffer(scp, arr, min(alloc_len, offset));
1386 }
1387
1388 #define SDEBUG_MAX_MSELECT_SZ 512
1389
1390 static int resp_mode_select(struct scsi_cmnd * scp, int mselect6,
1391 struct sdebug_dev_info * devip)
1392 {
1393 int pf, sp, ps, md_len, bd_len, off, spf, pg_len;
1394 int param_len, res, errsts, mpage;
1395 unsigned char arr[SDEBUG_MAX_MSELECT_SZ];
1396 unsigned char *cmd = (unsigned char *)scp->cmnd;
1397
1398 if ((errsts = check_readiness(scp, 1, devip)))
1399 return errsts;
1400 memset(arr, 0, sizeof(arr));
1401 pf = cmd[1] & 0x10;
1402 sp = cmd[1] & 0x1;
1403 param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]);
1404 if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) {
1405 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1406 INVALID_FIELD_IN_CDB, 0);
1407 return check_condition_result;
1408 }
1409 res = fetch_to_dev_buffer(scp, arr, param_len);
1410 if (-1 == res)
1411 return (DID_ERROR << 16);
1412 else if ((res < param_len) &&
1413 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1414 printk(KERN_INFO "scsi_debug: mode_select: cdb indicated=%d, "
1415 " IO sent=%d bytes\n", param_len, res);
1416 md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2);
1417 bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]);
1418 if (md_len > 2) {
1419 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1420 INVALID_FIELD_IN_PARAM_LIST, 0);
1421 return check_condition_result;
1422 }
1423 off = bd_len + (mselect6 ? 4 : 8);
1424 mpage = arr[off] & 0x3f;
1425 ps = !!(arr[off] & 0x80);
1426 if (ps) {
1427 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1428 INVALID_FIELD_IN_PARAM_LIST, 0);
1429 return check_condition_result;
1430 }
1431 spf = !!(arr[off] & 0x40);
1432 pg_len = spf ? ((arr[off + 2] << 8) + arr[off + 3] + 4) :
1433 (arr[off + 1] + 2);
1434 if ((pg_len + off) > param_len) {
1435 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1436 PARAMETER_LIST_LENGTH_ERR, 0);
1437 return check_condition_result;
1438 }
1439 switch (mpage) {
1440 case 0xa: /* Control Mode page */
1441 if (ctrl_m_pg[1] == arr[off + 1]) {
1442 memcpy(ctrl_m_pg + 2, arr + off + 2,
1443 sizeof(ctrl_m_pg) - 2);
1444 scsi_debug_dsense = !!(ctrl_m_pg[2] & 0x4);
1445 return 0;
1446 }
1447 break;
1448 case 0x1c: /* Informational Exceptions Mode page */
1449 if (iec_m_pg[1] == arr[off + 1]) {
1450 memcpy(iec_m_pg + 2, arr + off + 2,
1451 sizeof(iec_m_pg) - 2);
1452 return 0;
1453 }
1454 break;
1455 default:
1456 break;
1457 }
1458 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1459 INVALID_FIELD_IN_PARAM_LIST, 0);
1460 return check_condition_result;
1461 }
1462
1463 static int resp_temp_l_pg(unsigned char * arr)
1464 {
1465 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
1466 0x0, 0x1, 0x3, 0x2, 0x0, 65,
1467 };
1468
1469 memcpy(arr, temp_l_pg, sizeof(temp_l_pg));
1470 return sizeof(temp_l_pg);
1471 }
1472
1473 static int resp_ie_l_pg(unsigned char * arr)
1474 {
1475 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
1476 };
1477
1478 memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
1479 if (iec_m_pg[2] & 0x4) { /* TEST bit set */
1480 arr[4] = THRESHOLD_EXCEEDED;
1481 arr[5] = 0xff;
1482 }
1483 return sizeof(ie_l_pg);
1484 }
1485
1486 #define SDEBUG_MAX_LSENSE_SZ 512
1487
1488 static int resp_log_sense(struct scsi_cmnd * scp,
1489 struct sdebug_dev_info * devip)
1490 {
1491 int ppc, sp, pcontrol, pcode, subpcode, alloc_len, errsts, len, n;
1492 unsigned char arr[SDEBUG_MAX_LSENSE_SZ];
1493 unsigned char *cmd = (unsigned char *)scp->cmnd;
1494
1495 if ((errsts = check_readiness(scp, 1, devip)))
1496 return errsts;
1497 memset(arr, 0, sizeof(arr));
1498 ppc = cmd[1] & 0x2;
1499 sp = cmd[1] & 0x1;
1500 if (ppc || sp) {
1501 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1502 INVALID_FIELD_IN_CDB, 0);
1503 return check_condition_result;
1504 }
1505 pcontrol = (cmd[2] & 0xc0) >> 6;
1506 pcode = cmd[2] & 0x3f;
1507 subpcode = cmd[3] & 0xff;
1508 alloc_len = (cmd[7] << 8) + cmd[8];
1509 arr[0] = pcode;
1510 if (0 == subpcode) {
1511 switch (pcode) {
1512 case 0x0: /* Supported log pages log page */
1513 n = 4;
1514 arr[n++] = 0x0; /* this page */
1515 arr[n++] = 0xd; /* Temperature */
1516 arr[n++] = 0x2f; /* Informational exceptions */
1517 arr[3] = n - 4;
1518 break;
1519 case 0xd: /* Temperature log page */
1520 arr[3] = resp_temp_l_pg(arr + 4);
1521 break;
1522 case 0x2f: /* Informational exceptions log page */
1523 arr[3] = resp_ie_l_pg(arr + 4);
1524 break;
1525 default:
1526 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1527 INVALID_FIELD_IN_CDB, 0);
1528 return check_condition_result;
1529 }
1530 } else if (0xff == subpcode) {
1531 arr[0] |= 0x40;
1532 arr[1] = subpcode;
1533 switch (pcode) {
1534 case 0x0: /* Supported log pages and subpages log page */
1535 n = 4;
1536 arr[n++] = 0x0;
1537 arr[n++] = 0x0; /* 0,0 page */
1538 arr[n++] = 0x0;
1539 arr[n++] = 0xff; /* this page */
1540 arr[n++] = 0xd;
1541 arr[n++] = 0x0; /* Temperature */
1542 arr[n++] = 0x2f;
1543 arr[n++] = 0x0; /* Informational exceptions */
1544 arr[3] = n - 4;
1545 break;
1546 case 0xd: /* Temperature subpages */
1547 n = 4;
1548 arr[n++] = 0xd;
1549 arr[n++] = 0x0; /* Temperature */
1550 arr[3] = n - 4;
1551 break;
1552 case 0x2f: /* Informational exceptions subpages */
1553 n = 4;
1554 arr[n++] = 0x2f;
1555 arr[n++] = 0x0; /* Informational exceptions */
1556 arr[3] = n - 4;
1557 break;
1558 default:
1559 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1560 INVALID_FIELD_IN_CDB, 0);
1561 return check_condition_result;
1562 }
1563 } else {
1564 mk_sense_buffer(devip, ILLEGAL_REQUEST,
1565 INVALID_FIELD_IN_CDB, 0);
1566 return check_condition_result;
1567 }
1568 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
1569 return fill_from_dev_buffer(scp, arr,
1570 min(len, SDEBUG_MAX_INQ_ARR_SZ));
1571 }
1572
1573 static int check_device_access_params(struct sdebug_dev_info *devi,
1574 unsigned long long lba, unsigned int num)
1575 {
1576 if (lba + num > sdebug_capacity) {
1577 mk_sense_buffer(devi, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE, 0);
1578 return check_condition_result;
1579 }
1580 /* transfer length excessive (tie in to block limits VPD page) */
1581 if (num > sdebug_store_sectors) {
1582 mk_sense_buffer(devi, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
1583 return check_condition_result;
1584 }
1585 return 0;
1586 }
1587
1588 static int do_device_access(struct scsi_cmnd *scmd,
1589 struct sdebug_dev_info *devi,
1590 unsigned long long lba, unsigned int num, int write)
1591 {
1592 int ret;
1593 unsigned int block, rest = 0;
1594 int (*func)(struct scsi_cmnd *, unsigned char *, int);
1595
1596 func = write ? fetch_to_dev_buffer : fill_from_dev_buffer;
1597
1598 block = do_div(lba, sdebug_store_sectors);
1599 if (block + num > sdebug_store_sectors)
1600 rest = block + num - sdebug_store_sectors;
1601
1602 ret = func(scmd, fake_storep + (block * scsi_debug_sector_size),
1603 (num - rest) * scsi_debug_sector_size);
1604 if (!ret && rest)
1605 ret = func(scmd, fake_storep, rest * scsi_debug_sector_size);
1606
1607 return ret;
1608 }
1609
1610 static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec,
1611 unsigned int sectors, u32 ei_lba)
1612 {
1613 unsigned int i, resid;
1614 struct scatterlist *psgl;
1615 struct sd_dif_tuple *sdt;
1616 sector_t sector;
1617 sector_t tmp_sec = start_sec;
1618 void *paddr;
1619
1620 start_sec = do_div(tmp_sec, sdebug_store_sectors);
1621
1622 sdt = (struct sd_dif_tuple *)(dif_storep + dif_offset(start_sec));
1623
1624 for (i = 0 ; i < sectors ; i++) {
1625 u16 csum;
1626
1627 if (sdt[i].app_tag == 0xffff)
1628 continue;
1629
1630 sector = start_sec + i;
1631
1632 switch (scsi_debug_guard) {
1633 case 1:
1634 csum = ip_compute_csum(fake_storep +
1635 sector * scsi_debug_sector_size,
1636 scsi_debug_sector_size);
1637 break;
1638 case 0:
1639 csum = crc_t10dif(fake_storep +
1640 sector * scsi_debug_sector_size,
1641 scsi_debug_sector_size);
1642 csum = cpu_to_be16(csum);
1643 break;
1644 default:
1645 BUG();
1646 }
1647
1648 if (sdt[i].guard_tag != csum) {
1649 printk(KERN_ERR "%s: GUARD check failed on sector %lu" \
1650 " rcvd 0x%04x, data 0x%04x\n", __func__,
1651 (unsigned long)sector,
1652 be16_to_cpu(sdt[i].guard_tag),
1653 be16_to_cpu(csum));
1654 dif_errors++;
1655 return 0x01;
1656 }
1657
1658 if (scsi_debug_dif == SD_DIF_TYPE1_PROTECTION &&
1659 be32_to_cpu(sdt[i].ref_tag) != (sector & 0xffffffff)) {
1660 printk(KERN_ERR "%s: REF check failed on sector %lu\n",
1661 __func__, (unsigned long)sector);
1662 dif_errors++;
1663 return 0x03;
1664 }
1665
1666 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
1667 be32_to_cpu(sdt[i].ref_tag) != ei_lba) {
1668 printk(KERN_ERR "%s: REF check failed on sector %lu\n",
1669 __func__, (unsigned long)sector);
1670 dif_errors++;
1671 return 0x03;
1672 }
1673
1674 ei_lba++;
1675 }
1676
1677 resid = sectors * 8; /* Bytes of protection data to copy into sgl */
1678 sector = start_sec;
1679
1680 scsi_for_each_prot_sg(SCpnt, psgl, scsi_prot_sg_count(SCpnt), i) {
1681 int len = min(psgl->length, resid);
1682
1683 paddr = kmap_atomic(sg_page(psgl), KM_IRQ0) + psgl->offset;
1684 memcpy(paddr, dif_storep + dif_offset(sector), len);
1685
1686 sector += len >> 3;
1687 if (sector >= sdebug_store_sectors) {
1688 /* Force wrap */
1689 tmp_sec = sector;
1690 sector = do_div(tmp_sec, sdebug_store_sectors);
1691 }
1692 resid -= len;
1693 kunmap_atomic(paddr, KM_IRQ0);
1694 }
1695
1696 dix_reads++;
1697
1698 return 0;
1699 }
1700
1701 static int resp_read(struct scsi_cmnd *SCpnt, unsigned long long lba,
1702 unsigned int num, struct sdebug_dev_info *devip,
1703 u32 ei_lba)
1704 {
1705 unsigned long iflags;
1706 int ret;
1707
1708 ret = check_device_access_params(devip, lba, num);
1709 if (ret)
1710 return ret;
1711
1712 if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) &&
1713 (lba <= OPT_MEDIUM_ERR_ADDR) &&
1714 ((lba + num) > OPT_MEDIUM_ERR_ADDR)) {
1715 /* claim unrecoverable read error */
1716 mk_sense_buffer(devip, MEDIUM_ERROR, UNRECOVERED_READ_ERR,
1717 0);
1718 /* set info field and valid bit for fixed descriptor */
1719 if (0x70 == (devip->sense_buff[0] & 0x7f)) {
1720 devip->sense_buff[0] |= 0x80; /* Valid bit */
1721 ret = OPT_MEDIUM_ERR_ADDR;
1722 devip->sense_buff[3] = (ret >> 24) & 0xff;
1723 devip->sense_buff[4] = (ret >> 16) & 0xff;
1724 devip->sense_buff[5] = (ret >> 8) & 0xff;
1725 devip->sense_buff[6] = ret & 0xff;
1726 }
1727 return check_condition_result;
1728 }
1729
1730 /* DIX + T10 DIF */
1731 if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) {
1732 int prot_ret = prot_verify_read(SCpnt, lba, num, ei_lba);
1733
1734 if (prot_ret) {
1735 mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, prot_ret);
1736 return illegal_condition_result;
1737 }
1738 }
1739
1740 read_lock_irqsave(&atomic_rw, iflags);
1741 ret = do_device_access(SCpnt, devip, lba, num, 0);
1742 read_unlock_irqrestore(&atomic_rw, iflags);
1743 return ret;
1744 }
1745
1746 void dump_sector(unsigned char *buf, int len)
1747 {
1748 int i, j;
1749
1750 printk(KERN_ERR ">>> Sector Dump <<<\n");
1751
1752 for (i = 0 ; i < len ; i += 16) {
1753 printk(KERN_ERR "%04d: ", i);
1754
1755 for (j = 0 ; j < 16 ; j++) {
1756 unsigned char c = buf[i+j];
1757 if (c >= 0x20 && c < 0x7e)
1758 printk(" %c ", buf[i+j]);
1759 else
1760 printk("%02x ", buf[i+j]);
1761 }
1762
1763 printk("\n");
1764 }
1765 }
1766
1767 static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec,
1768 unsigned int sectors, u32 ei_lba)
1769 {
1770 int i, j, ret;
1771 struct sd_dif_tuple *sdt;
1772 struct scatterlist *dsgl = scsi_sglist(SCpnt);
1773 struct scatterlist *psgl = scsi_prot_sglist(SCpnt);
1774 void *daddr, *paddr;
1775 sector_t tmp_sec = start_sec;
1776 sector_t sector;
1777 int ppage_offset;
1778 unsigned short csum;
1779
1780 sector = do_div(tmp_sec, sdebug_store_sectors);
1781
1782 BUG_ON(scsi_sg_count(SCpnt) == 0);
1783 BUG_ON(scsi_prot_sg_count(SCpnt) == 0);
1784
1785 paddr = kmap_atomic(sg_page(psgl), KM_IRQ1) + psgl->offset;
1786 ppage_offset = 0;
1787
1788 /* For each data page */
1789 scsi_for_each_sg(SCpnt, dsgl, scsi_sg_count(SCpnt), i) {
1790 daddr = kmap_atomic(sg_page(dsgl), KM_IRQ0) + dsgl->offset;
1791
1792 /* For each sector-sized chunk in data page */
1793 for (j = 0 ; j < dsgl->length ; j += scsi_debug_sector_size) {
1794
1795 /* If we're at the end of the current
1796 * protection page advance to the next one
1797 */
1798 if (ppage_offset >= psgl->length) {
1799 kunmap_atomic(paddr, KM_IRQ1);
1800 psgl = sg_next(psgl);
1801 BUG_ON(psgl == NULL);
1802 paddr = kmap_atomic(sg_page(psgl), KM_IRQ1)
1803 + psgl->offset;
1804 ppage_offset = 0;
1805 }
1806
1807 sdt = paddr + ppage_offset;
1808
1809 switch (scsi_debug_guard) {
1810 case 1:
1811 csum = ip_compute_csum(daddr,
1812 scsi_debug_sector_size);
1813 break;
1814 case 0:
1815 csum = cpu_to_be16(crc_t10dif(daddr,
1816 scsi_debug_sector_size));
1817 break;
1818 default:
1819 BUG();
1820 ret = 0;
1821 goto out;
1822 }
1823
1824 if (sdt->guard_tag != csum) {
1825 printk(KERN_ERR
1826 "%s: GUARD check failed on sector %lu " \
1827 "rcvd 0x%04x, calculated 0x%04x\n",
1828 __func__, (unsigned long)sector,
1829 be16_to_cpu(sdt->guard_tag),
1830 be16_to_cpu(csum));
1831 ret = 0x01;
1832 dump_sector(daddr, scsi_debug_sector_size);
1833 goto out;
1834 }
1835
1836 if (scsi_debug_dif == SD_DIF_TYPE1_PROTECTION &&
1837 be32_to_cpu(sdt->ref_tag)
1838 != (start_sec & 0xffffffff)) {
1839 printk(KERN_ERR
1840 "%s: REF check failed on sector %lu\n",
1841 __func__, (unsigned long)sector);
1842 ret = 0x03;
1843 dump_sector(daddr, scsi_debug_sector_size);
1844 goto out;
1845 }
1846
1847 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
1848 be32_to_cpu(sdt->ref_tag) != ei_lba) {
1849 printk(KERN_ERR
1850 "%s: REF check failed on sector %lu\n",
1851 __func__, (unsigned long)sector);
1852 ret = 0x03;
1853 dump_sector(daddr, scsi_debug_sector_size);
1854 goto out;
1855 }
1856
1857 /* Would be great to copy this in bigger
1858 * chunks. However, for the sake of
1859 * correctness we need to verify each sector
1860 * before writing it to "stable" storage
1861 */
1862 memcpy(dif_storep + dif_offset(sector), sdt, 8);
1863
1864 sector++;
1865
1866 if (sector == sdebug_store_sectors)
1867 sector = 0; /* Force wrap */
1868
1869 start_sec++;
1870 ei_lba++;
1871 daddr += scsi_debug_sector_size;
1872 ppage_offset += sizeof(struct sd_dif_tuple);
1873 }
1874
1875 kunmap_atomic(daddr, KM_IRQ0);
1876 }
1877
1878 kunmap_atomic(paddr, KM_IRQ1);
1879
1880 dix_writes++;
1881
1882 return 0;
1883
1884 out:
1885 dif_errors++;
1886 kunmap_atomic(daddr, KM_IRQ0);
1887 kunmap_atomic(paddr, KM_IRQ1);
1888 return ret;
1889 }
1890
1891 static int resp_write(struct scsi_cmnd *SCpnt, unsigned long long lba,
1892 unsigned int num, struct sdebug_dev_info *devip,
1893 u32 ei_lba)
1894 {
1895 unsigned long iflags;
1896 int ret;
1897
1898 ret = check_device_access_params(devip, lba, num);
1899 if (ret)
1900 return ret;
1901
1902 /* DIX + T10 DIF */
1903 if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) {
1904 int prot_ret = prot_verify_write(SCpnt, lba, num, ei_lba);
1905
1906 if (prot_ret) {
1907 mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, prot_ret);
1908 return illegal_condition_result;
1909 }
1910 }
1911
1912 write_lock_irqsave(&atomic_rw, iflags);
1913 ret = do_device_access(SCpnt, devip, lba, num, 1);
1914 write_unlock_irqrestore(&atomic_rw, iflags);
1915 if (-1 == ret)
1916 return (DID_ERROR << 16);
1917 else if ((ret < (num * scsi_debug_sector_size)) &&
1918 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
1919 printk(KERN_INFO "scsi_debug: write: cdb indicated=%u, "
1920 " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret);
1921 return 0;
1922 }
1923
1924 #define SDEBUG_RLUN_ARR_SZ 256
1925
1926 static int resp_report_luns(struct scsi_cmnd * scp,
1927 struct sdebug_dev_info * devip)
1928 {
1929 unsigned int alloc_len;
1930 int lun_cnt, i, upper, num, n, wlun, lun;
1931 unsigned char *cmd = (unsigned char *)scp->cmnd;
1932 int select_report = (int)cmd[2];
1933 struct scsi_lun *one_lun;
1934 unsigned char arr[SDEBUG_RLUN_ARR_SZ];
1935 unsigned char * max_addr;
1936
1937 alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
1938 if ((alloc_len < 4) || (select_report > 2)) {
1939 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
1940 0);
1941 return check_condition_result;
1942 }
1943 /* can produce response with up to 16k luns (lun 0 to lun 16383) */
1944 memset(arr, 0, SDEBUG_RLUN_ARR_SZ);
1945 lun_cnt = scsi_debug_max_luns;
1946 if (1 == select_report)
1947 lun_cnt = 0;
1948 else if (scsi_debug_no_lun_0 && (lun_cnt > 0))
1949 --lun_cnt;
1950 wlun = (select_report > 0) ? 1 : 0;
1951 num = lun_cnt + wlun;
1952 arr[2] = ((sizeof(struct scsi_lun) * num) >> 8) & 0xff;
1953 arr[3] = (sizeof(struct scsi_lun) * num) & 0xff;
1954 n = min((int)((SDEBUG_RLUN_ARR_SZ - 8) /
1955 sizeof(struct scsi_lun)), num);
1956 if (n < num) {
1957 wlun = 0;
1958 lun_cnt = n;
1959 }
1960 one_lun = (struct scsi_lun *) &arr[8];
1961 max_addr = arr + SDEBUG_RLUN_ARR_SZ;
1962 for (i = 0, lun = (scsi_debug_no_lun_0 ? 1 : 0);
1963 ((i < lun_cnt) && ((unsigned char *)(one_lun + i) < max_addr));
1964 i++, lun++) {
1965 upper = (lun >> 8) & 0x3f;
1966 if (upper)
1967 one_lun[i].scsi_lun[0] =
1968 (upper | (SAM2_LUN_ADDRESS_METHOD << 6));
1969 one_lun[i].scsi_lun[1] = lun & 0xff;
1970 }
1971 if (wlun) {
1972 one_lun[i].scsi_lun[0] = (SAM2_WLUN_REPORT_LUNS >> 8) & 0xff;
1973 one_lun[i].scsi_lun[1] = SAM2_WLUN_REPORT_LUNS & 0xff;
1974 i++;
1975 }
1976 alloc_len = (unsigned char *)(one_lun + i) - arr;
1977 return fill_from_dev_buffer(scp, arr,
1978 min((int)alloc_len, SDEBUG_RLUN_ARR_SZ));
1979 }
1980
1981 static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
1982 unsigned int num, struct sdebug_dev_info *devip)
1983 {
1984 int i, j, ret = -1;
1985 unsigned char *kaddr, *buf;
1986 unsigned int offset;
1987 struct scatterlist *sg;
1988 struct scsi_data_buffer *sdb = scsi_in(scp);
1989
1990 /* better not to use temporary buffer. */
1991 buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
1992 if (!buf)
1993 return ret;
1994
1995 scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
1996
1997 offset = 0;
1998 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, i) {
1999 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
2000 if (!kaddr)
2001 goto out;
2002
2003 for (j = 0; j < sg->length; j++)
2004 *(kaddr + sg->offset + j) ^= *(buf + offset + j);
2005
2006 offset += sg->length;
2007 kunmap_atomic(kaddr, KM_USER0);
2008 }
2009 ret = 0;
2010 out:
2011 kfree(buf);
2012
2013 return ret;
2014 }
2015
2016 /* When timer goes off this function is called. */
2017 static void timer_intr_handler(unsigned long indx)
2018 {
2019 struct sdebug_queued_cmd * sqcp;
2020 unsigned long iflags;
2021
2022 if (indx >= SCSI_DEBUG_CANQUEUE) {
2023 printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too "
2024 "large\n");
2025 return;
2026 }
2027 spin_lock_irqsave(&queued_arr_lock, iflags);
2028 sqcp = &queued_arr[(int)indx];
2029 if (! sqcp->in_use) {
2030 printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected "
2031 "interrupt\n");
2032 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2033 return;
2034 }
2035 sqcp->in_use = 0;
2036 if (sqcp->done_funct) {
2037 sqcp->a_cmnd->result = sqcp->scsi_result;
2038 sqcp->done_funct(sqcp->a_cmnd); /* callback to mid level */
2039 }
2040 sqcp->done_funct = NULL;
2041 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2042 }
2043
2044
2045 static struct sdebug_dev_info *
2046 sdebug_device_create(struct sdebug_host_info *sdbg_host, gfp_t flags)
2047 {
2048 struct sdebug_dev_info *devip;
2049
2050 devip = kzalloc(sizeof(*devip), flags);
2051 if (devip) {
2052 devip->sdbg_host = sdbg_host;
2053 list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list);
2054 }
2055 return devip;
2056 }
2057
2058 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
2059 {
2060 struct sdebug_host_info * sdbg_host;
2061 struct sdebug_dev_info * open_devip = NULL;
2062 struct sdebug_dev_info * devip =
2063 (struct sdebug_dev_info *)sdev->hostdata;
2064
2065 if (devip)
2066 return devip;
2067 sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
2068 if (!sdbg_host) {
2069 printk(KERN_ERR "Host info NULL\n");
2070 return NULL;
2071 }
2072 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
2073 if ((devip->used) && (devip->channel == sdev->channel) &&
2074 (devip->target == sdev->id) &&
2075 (devip->lun == sdev->lun))
2076 return devip;
2077 else {
2078 if ((!devip->used) && (!open_devip))
2079 open_devip = devip;
2080 }
2081 }
2082 if (!open_devip) { /* try and make a new one */
2083 open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC);
2084 if (!open_devip) {
2085 printk(KERN_ERR "%s: out of memory at line %d\n",
2086 __func__, __LINE__);
2087 return NULL;
2088 }
2089 }
2090
2091 open_devip->channel = sdev->channel;
2092 open_devip->target = sdev->id;
2093 open_devip->lun = sdev->lun;
2094 open_devip->sdbg_host = sdbg_host;
2095 open_devip->reset = 1;
2096 open_devip->used = 1;
2097 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
2098 if (scsi_debug_dsense)
2099 open_devip->sense_buff[0] = 0x72;
2100 else {
2101 open_devip->sense_buff[0] = 0x70;
2102 open_devip->sense_buff[7] = 0xa;
2103 }
2104 if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
2105 open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
2106
2107 return open_devip;
2108 }
2109
2110 static int scsi_debug_slave_alloc(struct scsi_device *sdp)
2111 {
2112 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2113 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
2114 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2115 queue_flag_set_unlocked(QUEUE_FLAG_BIDI, sdp->request_queue);
2116 return 0;
2117 }
2118
2119 static int scsi_debug_slave_configure(struct scsi_device *sdp)
2120 {
2121 struct sdebug_dev_info *devip;
2122
2123 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2124 printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n",
2125 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2126 if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN)
2127 sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN;
2128 devip = devInfoReg(sdp);
2129 if (NULL == devip)
2130 return 1; /* no resources, will be marked offline */
2131 sdp->hostdata = devip;
2132 if (sdp->host->cmd_per_lun)
2133 scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING,
2134 sdp->host->cmd_per_lun);
2135 blk_queue_max_segment_size(sdp->request_queue, 256 * 1024);
2136 return 0;
2137 }
2138
2139 static void scsi_debug_slave_destroy(struct scsi_device *sdp)
2140 {
2141 struct sdebug_dev_info *devip =
2142 (struct sdebug_dev_info *)sdp->hostdata;
2143
2144 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2145 printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n",
2146 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2147 if (devip) {
2148 /* make this slot avaliable for re-use */
2149 devip->used = 0;
2150 sdp->hostdata = NULL;
2151 }
2152 }
2153
2154 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
2155 static int stop_queued_cmnd(struct scsi_cmnd *cmnd)
2156 {
2157 unsigned long iflags;
2158 int k;
2159 struct sdebug_queued_cmd *sqcp;
2160
2161 spin_lock_irqsave(&queued_arr_lock, iflags);
2162 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2163 sqcp = &queued_arr[k];
2164 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
2165 del_timer_sync(&sqcp->cmnd_timer);
2166 sqcp->in_use = 0;
2167 sqcp->a_cmnd = NULL;
2168 break;
2169 }
2170 }
2171 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2172 return (k < SCSI_DEBUG_CANQUEUE) ? 1 : 0;
2173 }
2174
2175 /* Deletes (stops) timers of all queued commands */
2176 static void stop_all_queued(void)
2177 {
2178 unsigned long iflags;
2179 int k;
2180 struct sdebug_queued_cmd *sqcp;
2181
2182 spin_lock_irqsave(&queued_arr_lock, iflags);
2183 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2184 sqcp = &queued_arr[k];
2185 if (sqcp->in_use && sqcp->a_cmnd) {
2186 del_timer_sync(&sqcp->cmnd_timer);
2187 sqcp->in_use = 0;
2188 sqcp->a_cmnd = NULL;
2189 }
2190 }
2191 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2192 }
2193
2194 static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
2195 {
2196 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2197 printk(KERN_INFO "scsi_debug: abort\n");
2198 ++num_aborts;
2199 stop_queued_cmnd(SCpnt);
2200 return SUCCESS;
2201 }
2202
2203 static int scsi_debug_biosparam(struct scsi_device *sdev,
2204 struct block_device * bdev, sector_t capacity, int *info)
2205 {
2206 int res;
2207 unsigned char *buf;
2208
2209 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2210 printk(KERN_INFO "scsi_debug: biosparam\n");
2211 buf = scsi_bios_ptable(bdev);
2212 if (buf) {
2213 res = scsi_partsize(buf, capacity,
2214 &info[2], &info[0], &info[1]);
2215 kfree(buf);
2216 if (! res)
2217 return res;
2218 }
2219 info[0] = sdebug_heads;
2220 info[1] = sdebug_sectors_per;
2221 info[2] = sdebug_cylinders_per;
2222 return 0;
2223 }
2224
2225 static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
2226 {
2227 struct sdebug_dev_info * devip;
2228
2229 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2230 printk(KERN_INFO "scsi_debug: device_reset\n");
2231 ++num_dev_resets;
2232 if (SCpnt) {
2233 devip = devInfoReg(SCpnt->device);
2234 if (devip)
2235 devip->reset = 1;
2236 }
2237 return SUCCESS;
2238 }
2239
2240 static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
2241 {
2242 struct sdebug_host_info *sdbg_host;
2243 struct sdebug_dev_info * dev_info;
2244 struct scsi_device * sdp;
2245 struct Scsi_Host * hp;
2246
2247 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2248 printk(KERN_INFO "scsi_debug: bus_reset\n");
2249 ++num_bus_resets;
2250 if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
2251 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
2252 if (sdbg_host) {
2253 list_for_each_entry(dev_info,
2254 &sdbg_host->dev_info_list,
2255 dev_list)
2256 dev_info->reset = 1;
2257 }
2258 }
2259 return SUCCESS;
2260 }
2261
2262 static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
2263 {
2264 struct sdebug_host_info * sdbg_host;
2265 struct sdebug_dev_info * dev_info;
2266
2267 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2268 printk(KERN_INFO "scsi_debug: host_reset\n");
2269 ++num_host_resets;
2270 spin_lock(&sdebug_host_list_lock);
2271 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
2272 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
2273 dev_list)
2274 dev_info->reset = 1;
2275 }
2276 spin_unlock(&sdebug_host_list_lock);
2277 stop_all_queued();
2278 return SUCCESS;
2279 }
2280
2281 /* Initializes timers in queued array */
2282 static void __init init_all_queued(void)
2283 {
2284 unsigned long iflags;
2285 int k;
2286 struct sdebug_queued_cmd * sqcp;
2287
2288 spin_lock_irqsave(&queued_arr_lock, iflags);
2289 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2290 sqcp = &queued_arr[k];
2291 init_timer(&sqcp->cmnd_timer);
2292 sqcp->in_use = 0;
2293 sqcp->a_cmnd = NULL;
2294 }
2295 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2296 }
2297
2298 static void __init sdebug_build_parts(unsigned char *ramp,
2299 unsigned long store_size)
2300 {
2301 struct partition * pp;
2302 int starts[SDEBUG_MAX_PARTS + 2];
2303 int sectors_per_part, num_sectors, k;
2304 int heads_by_sects, start_sec, end_sec;
2305
2306 /* assume partition table already zeroed */
2307 if ((scsi_debug_num_parts < 1) || (store_size < 1048576))
2308 return;
2309 if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
2310 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
2311 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
2312 "partitions to %d\n", SDEBUG_MAX_PARTS);
2313 }
2314 num_sectors = (int)sdebug_store_sectors;
2315 sectors_per_part = (num_sectors - sdebug_sectors_per)
2316 / scsi_debug_num_parts;
2317 heads_by_sects = sdebug_heads * sdebug_sectors_per;
2318 starts[0] = sdebug_sectors_per;
2319 for (k = 1; k < scsi_debug_num_parts; ++k)
2320 starts[k] = ((k * sectors_per_part) / heads_by_sects)
2321 * heads_by_sects;
2322 starts[scsi_debug_num_parts] = num_sectors;
2323 starts[scsi_debug_num_parts + 1] = 0;
2324
2325 ramp[510] = 0x55; /* magic partition markings */
2326 ramp[511] = 0xAA;
2327 pp = (struct partition *)(ramp + 0x1be);
2328 for (k = 0; starts[k + 1]; ++k, ++pp) {
2329 start_sec = starts[k];
2330 end_sec = starts[k + 1] - 1;
2331 pp->boot_ind = 0;
2332
2333 pp->cyl = start_sec / heads_by_sects;
2334 pp->head = (start_sec - (pp->cyl * heads_by_sects))
2335 / sdebug_sectors_per;
2336 pp->sector = (start_sec % sdebug_sectors_per) + 1;
2337
2338 pp->end_cyl = end_sec / heads_by_sects;
2339 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
2340 / sdebug_sectors_per;
2341 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2342
2343 pp->start_sect = start_sec;
2344 pp->nr_sects = end_sec - start_sec + 1;
2345 pp->sys_ind = 0x83; /* plain Linux partition */
2346 }
2347 }
2348
2349 static int schedule_resp(struct scsi_cmnd * cmnd,
2350 struct sdebug_dev_info * devip,
2351 done_funct_t done, int scsi_result, int delta_jiff)
2352 {
2353 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
2354 if (scsi_result) {
2355 struct scsi_device * sdp = cmnd->device;
2356
2357 printk(KERN_INFO "scsi_debug: <%u %u %u %u> "
2358 "non-zero result=0x%x\n", sdp->host->host_no,
2359 sdp->channel, sdp->id, sdp->lun, scsi_result);
2360 }
2361 }
2362 if (cmnd && devip) {
2363 /* simulate autosense by this driver */
2364 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
2365 memcpy(cmnd->sense_buffer, devip->sense_buff,
2366 (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
2367 SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
2368 }
2369 if (delta_jiff <= 0) {
2370 if (cmnd)
2371 cmnd->result = scsi_result;
2372 if (done)
2373 done(cmnd);
2374 return 0;
2375 } else {
2376 unsigned long iflags;
2377 int k;
2378 struct sdebug_queued_cmd * sqcp = NULL;
2379
2380 spin_lock_irqsave(&queued_arr_lock, iflags);
2381 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2382 sqcp = &queued_arr[k];
2383 if (! sqcp->in_use)
2384 break;
2385 }
2386 if (k >= SCSI_DEBUG_CANQUEUE) {
2387 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2388 printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
2389 return 1; /* report busy to mid level */
2390 }
2391 sqcp->in_use = 1;
2392 sqcp->a_cmnd = cmnd;
2393 sqcp->scsi_result = scsi_result;
2394 sqcp->done_funct = done;
2395 sqcp->cmnd_timer.function = timer_intr_handler;
2396 sqcp->cmnd_timer.data = k;
2397 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
2398 add_timer(&sqcp->cmnd_timer);
2399 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2400 if (cmnd)
2401 cmnd->result = 0;
2402 return 0;
2403 }
2404 }
2405 /* Note: The following macros create attribute files in the
2406 /sys/module/scsi_debug/parameters directory. Unfortunately this
2407 driver is unaware of a change and cannot trigger auxiliary actions
2408 as it can when the corresponding attribute in the
2409 /sys/bus/pseudo/drivers/scsi_debug directory is changed.
2410 */
2411 module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
2412 module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
2413 module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
2414 module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
2415 module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
2416 module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
2417 module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
2418 module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
2419 module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
2420 module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
2421 module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
2422 module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
2423 module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
2424 module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
2425 module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
2426 S_IRUGO | S_IWUSR);
2427 module_param_named(sector_size, scsi_debug_sector_size, int, S_IRUGO);
2428 module_param_named(dix, scsi_debug_dix, int, S_IRUGO);
2429 module_param_named(dif, scsi_debug_dif, int, S_IRUGO);
2430 module_param_named(guard, scsi_debug_guard, int, S_IRUGO);
2431 module_param_named(ato, scsi_debug_ato, int, S_IRUGO);
2432 module_param_named(physblk_exp, scsi_debug_physblk_exp, int, S_IRUGO);
2433 module_param_named(lowest_aligned, scsi_debug_lowest_aligned, int, S_IRUGO);
2434
2435 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2436 MODULE_DESCRIPTION("SCSI debug adapter driver");
2437 MODULE_LICENSE("GPL");
2438 MODULE_VERSION(SCSI_DEBUG_VERSION);
2439
2440 MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
2441 MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
2442 MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
2443 MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
2444 MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
2445 MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
2446 MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
2447 MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
2448 MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
2449 MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
2450 MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
2451 MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
2452 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
2453 MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
2454 MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2455 MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)");
2456 MODULE_PARM_DESC(physblk_exp, "physical block exponent (def=0)");
2457 MODULE_PARM_DESC(lowest_aligned, "lowest aligned lba (def=0)");
2458 MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)");
2459 MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)");
2460 MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");
2461 MODULE_PARM_DESC(ato, "application tag ownership: 0=disk 1=host (def=1)");
2462
2463 static char sdebug_info[256];
2464
2465 static const char * scsi_debug_info(struct Scsi_Host * shp)
2466 {
2467 sprintf(sdebug_info, "scsi_debug, version %s [%s], "
2468 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
2469 scsi_debug_version_date, scsi_debug_dev_size_mb,
2470 scsi_debug_opts);
2471 return sdebug_info;
2472 }
2473
2474 /* scsi_debug_proc_info
2475 * Used if the driver currently has no own support for /proc/scsi
2476 */
2477 static int scsi_debug_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
2478 int length, int inout)
2479 {
2480 int len, pos, begin;
2481 int orig_length;
2482
2483 orig_length = length;
2484
2485 if (inout == 1) {
2486 char arr[16];
2487 int minLen = length > 15 ? 15 : length;
2488
2489 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2490 return -EACCES;
2491 memcpy(arr, buffer, minLen);
2492 arr[minLen] = '\0';
2493 if (1 != sscanf(arr, "%d", &pos))
2494 return -EINVAL;
2495 scsi_debug_opts = pos;
2496 if (scsi_debug_every_nth != 0)
2497 scsi_debug_cmnd_count = 0;
2498 return length;
2499 }
2500 begin = 0;
2501 pos = len = sprintf(buffer, "scsi_debug adapter driver, version "
2502 "%s [%s]\n"
2503 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2504 "every_nth=%d(curr:%d)\n"
2505 "delay=%d, max_luns=%d, scsi_level=%d\n"
2506 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2507 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2508 "host_resets=%d\ndix_reads=%d dix_writes=%d dif_errors=%d\n",
2509 SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
2510 scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2511 scsi_debug_cmnd_count, scsi_debug_delay,
2512 scsi_debug_max_luns, scsi_debug_scsi_level,
2513 scsi_debug_sector_size, sdebug_cylinders_per, sdebug_heads,
2514 sdebug_sectors_per, num_aborts, num_dev_resets, num_bus_resets,
2515 num_host_resets, dix_reads, dix_writes, dif_errors);
2516 if (pos < offset) {
2517 len = 0;
2518 begin = pos;
2519 }
2520 *start = buffer + (offset - begin); /* Start of wanted data */
2521 len -= (offset - begin);
2522 if (len > length)
2523 len = length;
2524 return len;
2525 }
2526
2527 static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf)
2528 {
2529 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
2530 }
2531
2532 static ssize_t sdebug_delay_store(struct device_driver * ddp,
2533 const char * buf, size_t count)
2534 {
2535 int delay;
2536 char work[20];
2537
2538 if (1 == sscanf(buf, "%10s", work)) {
2539 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
2540 scsi_debug_delay = delay;
2541 return count;
2542 }
2543 }
2544 return -EINVAL;
2545 }
2546 DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show,
2547 sdebug_delay_store);
2548
2549 static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf)
2550 {
2551 return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
2552 }
2553
2554 static ssize_t sdebug_opts_store(struct device_driver * ddp,
2555 const char * buf, size_t count)
2556 {
2557 int opts;
2558 char work[20];
2559
2560 if (1 == sscanf(buf, "%10s", work)) {
2561 if (0 == strnicmp(work,"0x", 2)) {
2562 if (1 == sscanf(&work[2], "%x", &opts))
2563 goto opts_done;
2564 } else {
2565 if (1 == sscanf(work, "%d", &opts))
2566 goto opts_done;
2567 }
2568 }
2569 return -EINVAL;
2570 opts_done:
2571 scsi_debug_opts = opts;
2572 scsi_debug_cmnd_count = 0;
2573 return count;
2574 }
2575 DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show,
2576 sdebug_opts_store);
2577
2578 static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf)
2579 {
2580 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
2581 }
2582 static ssize_t sdebug_ptype_store(struct device_driver * ddp,
2583 const char * buf, size_t count)
2584 {
2585 int n;
2586
2587 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2588 scsi_debug_ptype = n;
2589 return count;
2590 }
2591 return -EINVAL;
2592 }
2593 DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store);
2594
2595 static ssize_t sdebug_dsense_show(struct device_driver * ddp, char * buf)
2596 {
2597 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
2598 }
2599 static ssize_t sdebug_dsense_store(struct device_driver * ddp,
2600 const char * buf, size_t count)
2601 {
2602 int n;
2603
2604 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2605 scsi_debug_dsense = n;
2606 return count;
2607 }
2608 return -EINVAL;
2609 }
2610 DRIVER_ATTR(dsense, S_IRUGO | S_IWUSR, sdebug_dsense_show,
2611 sdebug_dsense_store);
2612
2613 static ssize_t sdebug_fake_rw_show(struct device_driver * ddp, char * buf)
2614 {
2615 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
2616 }
2617 static ssize_t sdebug_fake_rw_store(struct device_driver * ddp,
2618 const char * buf, size_t count)
2619 {
2620 int n;
2621
2622 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2623 scsi_debug_fake_rw = n;
2624 return count;
2625 }
2626 return -EINVAL;
2627 }
2628 DRIVER_ATTR(fake_rw, S_IRUGO | S_IWUSR, sdebug_fake_rw_show,
2629 sdebug_fake_rw_store);
2630
2631 static ssize_t sdebug_no_lun_0_show(struct device_driver * ddp, char * buf)
2632 {
2633 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
2634 }
2635 static ssize_t sdebug_no_lun_0_store(struct device_driver * ddp,
2636 const char * buf, size_t count)
2637 {
2638 int n;
2639
2640 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2641 scsi_debug_no_lun_0 = n;
2642 return count;
2643 }
2644 return -EINVAL;
2645 }
2646 DRIVER_ATTR(no_lun_0, S_IRUGO | S_IWUSR, sdebug_no_lun_0_show,
2647 sdebug_no_lun_0_store);
2648
2649 static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf)
2650 {
2651 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
2652 }
2653 static ssize_t sdebug_num_tgts_store(struct device_driver * ddp,
2654 const char * buf, size_t count)
2655 {
2656 int n;
2657
2658 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2659 scsi_debug_num_tgts = n;
2660 sdebug_max_tgts_luns();
2661 return count;
2662 }
2663 return -EINVAL;
2664 }
2665 DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show,
2666 sdebug_num_tgts_store);
2667
2668 static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf)
2669 {
2670 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
2671 }
2672 DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL);
2673
2674 static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf)
2675 {
2676 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
2677 }
2678 DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL);
2679
2680 static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf)
2681 {
2682 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
2683 }
2684 static ssize_t sdebug_every_nth_store(struct device_driver * ddp,
2685 const char * buf, size_t count)
2686 {
2687 int nth;
2688
2689 if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
2690 scsi_debug_every_nth = nth;
2691 scsi_debug_cmnd_count = 0;
2692 return count;
2693 }
2694 return -EINVAL;
2695 }
2696 DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show,
2697 sdebug_every_nth_store);
2698
2699 static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf)
2700 {
2701 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
2702 }
2703 static ssize_t sdebug_max_luns_store(struct device_driver * ddp,
2704 const char * buf, size_t count)
2705 {
2706 int n;
2707
2708 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2709 scsi_debug_max_luns = n;
2710 sdebug_max_tgts_luns();
2711 return count;
2712 }
2713 return -EINVAL;
2714 }
2715 DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show,
2716 sdebug_max_luns_store);
2717
2718 static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf)
2719 {
2720 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
2721 }
2722 DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL);
2723
2724 static ssize_t sdebug_virtual_gb_show(struct device_driver * ddp, char * buf)
2725 {
2726 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
2727 }
2728 static ssize_t sdebug_virtual_gb_store(struct device_driver * ddp,
2729 const char * buf, size_t count)
2730 {
2731 int n;
2732
2733 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2734 scsi_debug_virtual_gb = n;
2735
2736 sdebug_capacity = get_sdebug_capacity();
2737
2738 return count;
2739 }
2740 return -EINVAL;
2741 }
2742 DRIVER_ATTR(virtual_gb, S_IRUGO | S_IWUSR, sdebug_virtual_gb_show,
2743 sdebug_virtual_gb_store);
2744
2745 static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf)
2746 {
2747 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
2748 }
2749
2750 static ssize_t sdebug_add_host_store(struct device_driver * ddp,
2751 const char * buf, size_t count)
2752 {
2753 int delta_hosts;
2754
2755 if (sscanf(buf, "%d", &delta_hosts) != 1)
2756 return -EINVAL;
2757 if (delta_hosts > 0) {
2758 do {
2759 sdebug_add_adapter();
2760 } while (--delta_hosts);
2761 } else if (delta_hosts < 0) {
2762 do {
2763 sdebug_remove_adapter();
2764 } while (++delta_hosts);
2765 }
2766 return count;
2767 }
2768 DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show,
2769 sdebug_add_host_store);
2770
2771 static ssize_t sdebug_vpd_use_hostno_show(struct device_driver * ddp,
2772 char * buf)
2773 {
2774 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
2775 }
2776 static ssize_t sdebug_vpd_use_hostno_store(struct device_driver * ddp,
2777 const char * buf, size_t count)
2778 {
2779 int n;
2780
2781 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2782 scsi_debug_vpd_use_hostno = n;
2783 return count;
2784 }
2785 return -EINVAL;
2786 }
2787 DRIVER_ATTR(vpd_use_hostno, S_IRUGO | S_IWUSR, sdebug_vpd_use_hostno_show,
2788 sdebug_vpd_use_hostno_store);
2789
2790 static ssize_t sdebug_sector_size_show(struct device_driver * ddp, char * buf)
2791 {
2792 return scnprintf(buf, PAGE_SIZE, "%u\n", scsi_debug_sector_size);
2793 }
2794 DRIVER_ATTR(sector_size, S_IRUGO, sdebug_sector_size_show, NULL);
2795
2796 static ssize_t sdebug_dix_show(struct device_driver *ddp, char *buf)
2797 {
2798 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dix);
2799 }
2800 DRIVER_ATTR(dix, S_IRUGO, sdebug_dix_show, NULL);
2801
2802 static ssize_t sdebug_dif_show(struct device_driver *ddp, char *buf)
2803 {
2804 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dif);
2805 }
2806 DRIVER_ATTR(dif, S_IRUGO, sdebug_dif_show, NULL);
2807
2808 static ssize_t sdebug_guard_show(struct device_driver *ddp, char *buf)
2809 {
2810 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_guard);
2811 }
2812 DRIVER_ATTR(guard, S_IRUGO, sdebug_guard_show, NULL);
2813
2814 static ssize_t sdebug_ato_show(struct device_driver *ddp, char *buf)
2815 {
2816 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ato);
2817 }
2818 DRIVER_ATTR(ato, S_IRUGO, sdebug_ato_show, NULL);
2819
2820
2821 /* Note: The following function creates attribute files in the
2822 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
2823 files (over those found in the /sys/module/scsi_debug/parameters
2824 directory) is that auxiliary actions can be triggered when an attribute
2825 is changed. For example see: sdebug_add_host_store() above.
2826 */
2827 static int do_create_driverfs_files(void)
2828 {
2829 int ret;
2830
2831 ret = driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2832 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay);
2833 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2834 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2835 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2836 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2837 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2838 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2839 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2840 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2841 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2842 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts);
2843 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2844 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2845 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2846 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_sector_size);
2847 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dix);
2848 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dif);
2849 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_guard);
2850 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ato);
2851 return ret;
2852 }
2853
2854 static void do_remove_driverfs_files(void)
2855 {
2856 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ato);
2857 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_guard);
2858 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dif);
2859 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dix);
2860 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_sector_size);
2861 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2862 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2863 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2864 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts);
2865 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2866 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2867 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2868 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2869 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2870 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2871 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2872 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2873 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2874 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay);
2875 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2876 }
2877
2878 static void pseudo_0_release(struct device *dev)
2879 {
2880 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2881 printk(KERN_INFO "scsi_debug: pseudo_0_release() called\n");
2882 }
2883
2884 static struct device pseudo_primary = {
2885 .init_name = "pseudo_0",
2886 .release = pseudo_0_release,
2887 };
2888
2889 static int __init scsi_debug_init(void)
2890 {
2891 unsigned long sz;
2892 int host_to_add;
2893 int k;
2894 int ret;
2895
2896 switch (scsi_debug_sector_size) {
2897 case 512:
2898 case 1024:
2899 case 2048:
2900 case 4096:
2901 break;
2902 default:
2903 printk(KERN_ERR "scsi_debug_init: invalid sector_size %d\n",
2904 scsi_debug_sector_size);
2905 return -EINVAL;
2906 }
2907
2908 switch (scsi_debug_dif) {
2909
2910 case SD_DIF_TYPE0_PROTECTION:
2911 case SD_DIF_TYPE1_PROTECTION:
2912 case SD_DIF_TYPE2_PROTECTION:
2913 case SD_DIF_TYPE3_PROTECTION:
2914 break;
2915
2916 default:
2917 printk(KERN_ERR "scsi_debug_init: dif must be 0, 1, 2 or 3\n");
2918 return -EINVAL;
2919 }
2920
2921 if (scsi_debug_guard > 1) {
2922 printk(KERN_ERR "scsi_debug_init: guard must be 0 or 1\n");
2923 return -EINVAL;
2924 }
2925
2926 if (scsi_debug_ato > 1) {
2927 printk(KERN_ERR "scsi_debug_init: ato must be 0 or 1\n");
2928 return -EINVAL;
2929 }
2930
2931 if (scsi_debug_physblk_exp > 15) {
2932 printk(KERN_ERR "scsi_debug_init: invalid physblk_exp %u\n",
2933 scsi_debug_physblk_exp);
2934 return -EINVAL;
2935 }
2936
2937 if (scsi_debug_lowest_aligned > 0x3fff) {
2938 printk(KERN_ERR "scsi_debug_init: lowest_aligned too big: %u\n",
2939 scsi_debug_lowest_aligned);
2940 return -EINVAL;
2941 }
2942
2943 if (scsi_debug_dev_size_mb < 1)
2944 scsi_debug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */
2945 sz = (unsigned long)scsi_debug_dev_size_mb * 1048576;
2946 sdebug_store_sectors = sz / scsi_debug_sector_size;
2947 sdebug_capacity = get_sdebug_capacity();
2948
2949 /* play around with geometry, don't waste too much on track 0 */
2950 sdebug_heads = 8;
2951 sdebug_sectors_per = 32;
2952 if (scsi_debug_dev_size_mb >= 16)
2953 sdebug_heads = 32;
2954 else if (scsi_debug_dev_size_mb >= 256)
2955 sdebug_heads = 64;
2956 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2957 (sdebug_sectors_per * sdebug_heads);
2958 if (sdebug_cylinders_per >= 1024) {
2959 /* other LLDs do this; implies >= 1GB ram disk ... */
2960 sdebug_heads = 255;
2961 sdebug_sectors_per = 63;
2962 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2963 (sdebug_sectors_per * sdebug_heads);
2964 }
2965
2966 fake_storep = vmalloc(sz);
2967 if (NULL == fake_storep) {
2968 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
2969 return -ENOMEM;
2970 }
2971 memset(fake_storep, 0, sz);
2972 if (scsi_debug_num_parts > 0)
2973 sdebug_build_parts(fake_storep, sz);
2974
2975 if (scsi_debug_dif) {
2976 int dif_size;
2977
2978 dif_size = sdebug_store_sectors * sizeof(struct sd_dif_tuple);
2979 dif_storep = vmalloc(dif_size);
2980
2981 printk(KERN_ERR "scsi_debug_init: dif_storep %u bytes @ %p\n",
2982 dif_size, dif_storep);
2983
2984 if (dif_storep == NULL) {
2985 printk(KERN_ERR "scsi_debug_init: out of mem. (DIX)\n");
2986 ret = -ENOMEM;
2987 goto free_vm;
2988 }
2989
2990 memset(dif_storep, 0xff, dif_size);
2991 }
2992
2993 ret = device_register(&pseudo_primary);
2994 if (ret < 0) {
2995 printk(KERN_WARNING "scsi_debug: device_register error: %d\n",
2996 ret);
2997 goto free_vm;
2998 }
2999 ret = bus_register(&pseudo_lld_bus);
3000 if (ret < 0) {
3001 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
3002 ret);
3003 goto dev_unreg;
3004 }
3005 ret = driver_register(&sdebug_driverfs_driver);
3006 if (ret < 0) {
3007 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
3008 ret);
3009 goto bus_unreg;
3010 }
3011 ret = do_create_driverfs_files();
3012 if (ret < 0) {
3013 printk(KERN_WARNING "scsi_debug: driver_create_file error: %d\n",
3014 ret);
3015 goto del_files;
3016 }
3017
3018 init_all_queued();
3019
3020 host_to_add = scsi_debug_add_host;
3021 scsi_debug_add_host = 0;
3022
3023 for (k = 0; k < host_to_add; k++) {
3024 if (sdebug_add_adapter()) {
3025 printk(KERN_ERR "scsi_debug_init: "
3026 "sdebug_add_adapter failed k=%d\n", k);
3027 break;
3028 }
3029 }
3030
3031 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
3032 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
3033 scsi_debug_add_host);
3034 }
3035 return 0;
3036
3037 del_files:
3038 do_remove_driverfs_files();
3039 driver_unregister(&sdebug_driverfs_driver);
3040 bus_unreg:
3041 bus_unregister(&pseudo_lld_bus);
3042 dev_unreg:
3043 device_unregister(&pseudo_primary);
3044 free_vm:
3045 if (dif_storep)
3046 vfree(dif_storep);
3047 vfree(fake_storep);
3048
3049 return ret;
3050 }
3051
3052 static void __exit scsi_debug_exit(void)
3053 {
3054 int k = scsi_debug_add_host;
3055
3056 stop_all_queued();
3057 for (; k; k--)
3058 sdebug_remove_adapter();
3059 do_remove_driverfs_files();
3060 driver_unregister(&sdebug_driverfs_driver);
3061 bus_unregister(&pseudo_lld_bus);
3062 device_unregister(&pseudo_primary);
3063
3064 if (dif_storep)
3065 vfree(dif_storep);
3066
3067 vfree(fake_storep);
3068 }
3069
3070 device_initcall(scsi_debug_init);
3071 module_exit(scsi_debug_exit);
3072
3073 static void sdebug_release_adapter(struct device * dev)
3074 {
3075 struct sdebug_host_info *sdbg_host;
3076
3077 sdbg_host = to_sdebug_host(dev);
3078 kfree(sdbg_host);
3079 }
3080
3081 static int sdebug_add_adapter(void)
3082 {
3083 int k, devs_per_host;
3084 int error = 0;
3085 struct sdebug_host_info *sdbg_host;
3086 struct sdebug_dev_info *sdbg_devinfo, *tmp;
3087
3088 sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
3089 if (NULL == sdbg_host) {
3090 printk(KERN_ERR "%s: out of memory at line %d\n",
3091 __func__, __LINE__);
3092 return -ENOMEM;
3093 }
3094
3095 INIT_LIST_HEAD(&sdbg_host->dev_info_list);
3096
3097 devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
3098 for (k = 0; k < devs_per_host; k++) {
3099 sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL);
3100 if (!sdbg_devinfo) {
3101 printk(KERN_ERR "%s: out of memory at line %d\n",
3102 __func__, __LINE__);
3103 error = -ENOMEM;
3104 goto clean;
3105 }
3106 }
3107
3108 spin_lock(&sdebug_host_list_lock);
3109 list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
3110 spin_unlock(&sdebug_host_list_lock);
3111
3112 sdbg_host->dev.bus = &pseudo_lld_bus;
3113 sdbg_host->dev.parent = &pseudo_primary;
3114 sdbg_host->dev.release = &sdebug_release_adapter;
3115 dev_set_name(&sdbg_host->dev, "adapter%d", scsi_debug_add_host);
3116
3117 error = device_register(&sdbg_host->dev);
3118
3119 if (error)
3120 goto clean;
3121
3122 ++scsi_debug_add_host;
3123 return error;
3124
3125 clean:
3126 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
3127 dev_list) {
3128 list_del(&sdbg_devinfo->dev_list);
3129 kfree(sdbg_devinfo);
3130 }
3131
3132 kfree(sdbg_host);
3133 return error;
3134 }
3135
3136 static void sdebug_remove_adapter(void)
3137 {
3138 struct sdebug_host_info * sdbg_host = NULL;
3139
3140 spin_lock(&sdebug_host_list_lock);
3141 if (!list_empty(&sdebug_host_list)) {
3142 sdbg_host = list_entry(sdebug_host_list.prev,
3143 struct sdebug_host_info, host_list);
3144 list_del(&sdbg_host->host_list);
3145 }
3146 spin_unlock(&sdebug_host_list_lock);
3147
3148 if (!sdbg_host)
3149 return;
3150
3151 device_unregister(&sdbg_host->dev);
3152 --scsi_debug_add_host;
3153 }
3154
3155 static
3156 int scsi_debug_queuecommand(struct scsi_cmnd *SCpnt, done_funct_t done)
3157 {
3158 unsigned char *cmd = (unsigned char *) SCpnt->cmnd;
3159 int len, k;
3160 unsigned int num;
3161 unsigned long long lba;
3162 u32 ei_lba;
3163 int errsts = 0;
3164 int target = SCpnt->device->id;
3165 struct sdebug_dev_info *devip = NULL;
3166 int inj_recovered = 0;
3167 int inj_transport = 0;
3168 int inj_dif = 0;
3169 int inj_dix = 0;
3170 int delay_override = 0;
3171
3172 scsi_set_resid(SCpnt, 0);
3173 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) {
3174 printk(KERN_INFO "scsi_debug: cmd ");
3175 for (k = 0, len = SCpnt->cmd_len; k < len; ++k)
3176 printk("%02x ", (int)cmd[k]);
3177 printk("\n");
3178 }
3179
3180 if (target == SCpnt->device->host->hostt->this_id) {
3181 printk(KERN_INFO "scsi_debug: initiator's id used as "
3182 "target!\n");
3183 return schedule_resp(SCpnt, NULL, done,
3184 DID_NO_CONNECT << 16, 0);
3185 }
3186
3187 if ((SCpnt->device->lun >= scsi_debug_max_luns) &&
3188 (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS))
3189 return schedule_resp(SCpnt, NULL, done,
3190 DID_NO_CONNECT << 16, 0);
3191 devip = devInfoReg(SCpnt->device);
3192 if (NULL == devip)
3193 return schedule_resp(SCpnt, NULL, done,
3194 DID_NO_CONNECT << 16, 0);
3195
3196 if ((scsi_debug_every_nth != 0) &&
3197 (++scsi_debug_cmnd_count >= abs(scsi_debug_every_nth))) {
3198 scsi_debug_cmnd_count = 0;
3199 if (scsi_debug_every_nth < -1)
3200 scsi_debug_every_nth = -1;
3201 if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
3202 return 0; /* ignore command causing timeout */
3203 else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
3204 inj_recovered = 1; /* to reads and writes below */
3205 else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts)
3206 inj_transport = 1; /* to reads and writes below */
3207 else if (SCSI_DEBUG_OPT_DIF_ERR & scsi_debug_opts)
3208 inj_dif = 1; /* to reads and writes below */
3209 else if (SCSI_DEBUG_OPT_DIX_ERR & scsi_debug_opts)
3210 inj_dix = 1; /* to reads and writes below */
3211 }
3212
3213 if (devip->wlun) {
3214 switch (*cmd) {
3215 case INQUIRY:
3216 case REQUEST_SENSE:
3217 case TEST_UNIT_READY:
3218 case REPORT_LUNS:
3219 break; /* only allowable wlun commands */
3220 default:
3221 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
3222 printk(KERN_INFO "scsi_debug: Opcode: 0x%x "
3223 "not supported for wlun\n", *cmd);
3224 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3225 INVALID_OPCODE, 0);
3226 errsts = check_condition_result;
3227 return schedule_resp(SCpnt, devip, done, errsts,
3228 0);
3229 }
3230 }
3231
3232 switch (*cmd) {
3233 case INQUIRY: /* mandatory, ignore unit attention */
3234 delay_override = 1;
3235 errsts = resp_inquiry(SCpnt, target, devip);
3236 break;
3237 case REQUEST_SENSE: /* mandatory, ignore unit attention */
3238 delay_override = 1;
3239 errsts = resp_requests(SCpnt, devip);
3240 break;
3241 case REZERO_UNIT: /* actually this is REWIND for SSC */
3242 case START_STOP:
3243 errsts = resp_start_stop(SCpnt, devip);
3244 break;
3245 case ALLOW_MEDIUM_REMOVAL:
3246 errsts = check_readiness(SCpnt, 1, devip);
3247 if (errsts)
3248 break;
3249 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
3250 printk(KERN_INFO "scsi_debug: Medium removal %s\n",
3251 cmd[4] ? "inhibited" : "enabled");
3252 break;
3253 case SEND_DIAGNOSTIC: /* mandatory */
3254 errsts = check_readiness(SCpnt, 1, devip);
3255 break;
3256 case TEST_UNIT_READY: /* mandatory */
3257 delay_override = 1;
3258 errsts = check_readiness(SCpnt, 0, devip);
3259 break;
3260 case RESERVE:
3261 errsts = check_readiness(SCpnt, 1, devip);
3262 break;
3263 case RESERVE_10:
3264 errsts = check_readiness(SCpnt, 1, devip);
3265 break;
3266 case RELEASE:
3267 errsts = check_readiness(SCpnt, 1, devip);
3268 break;
3269 case RELEASE_10:
3270 errsts = check_readiness(SCpnt, 1, devip);
3271 break;
3272 case READ_CAPACITY:
3273 errsts = resp_readcap(SCpnt, devip);
3274 break;
3275 case SERVICE_ACTION_IN:
3276 if (SAI_READ_CAPACITY_16 != cmd[1]) {
3277 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3278 INVALID_OPCODE, 0);
3279 errsts = check_condition_result;
3280 break;
3281 }
3282 errsts = resp_readcap16(SCpnt, devip);
3283 break;
3284 case MAINTENANCE_IN:
3285 if (MI_REPORT_TARGET_PGS != cmd[1]) {
3286 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3287 INVALID_OPCODE, 0);
3288 errsts = check_condition_result;
3289 break;
3290 }
3291 errsts = resp_report_tgtpgs(SCpnt, devip);
3292 break;
3293 case READ_16:
3294 case READ_12:
3295 case READ_10:
3296 /* READ{10,12,16} and DIF Type 2 are natural enemies */
3297 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
3298 cmd[1] & 0xe0) {
3299 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3300 INVALID_COMMAND_OPCODE, 0);
3301 errsts = check_condition_result;
3302 break;
3303 }
3304
3305 if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
3306 scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
3307 (cmd[1] & 0xe0) == 0)
3308 printk(KERN_ERR "Unprotected RD/WR to DIF device\n");
3309
3310 /* fall through */
3311 case READ_6:
3312 read:
3313 errsts = check_readiness(SCpnt, 0, devip);
3314 if (errsts)
3315 break;
3316 if (scsi_debug_fake_rw)
3317 break;
3318 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3319 errsts = resp_read(SCpnt, lba, num, devip, ei_lba);
3320 if (inj_recovered && (0 == errsts)) {
3321 mk_sense_buffer(devip, RECOVERED_ERROR,
3322 THRESHOLD_EXCEEDED, 0);
3323 errsts = check_condition_result;
3324 } else if (inj_transport && (0 == errsts)) {
3325 mk_sense_buffer(devip, ABORTED_COMMAND,
3326 TRANSPORT_PROBLEM, ACK_NAK_TO);
3327 errsts = check_condition_result;
3328 } else if (inj_dif && (0 == errsts)) {
3329 mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, 1);
3330 errsts = illegal_condition_result;
3331 } else if (inj_dix && (0 == errsts)) {
3332 mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, 1);
3333 errsts = illegal_condition_result;
3334 }
3335 break;
3336 case REPORT_LUNS: /* mandatory, ignore unit attention */
3337 delay_override = 1;
3338 errsts = resp_report_luns(SCpnt, devip);
3339 break;
3340 case VERIFY: /* 10 byte SBC-2 command */
3341 errsts = check_readiness(SCpnt, 0, devip);
3342 break;
3343 case WRITE_16:
3344 case WRITE_12:
3345 case WRITE_10:
3346 /* WRITE{10,12,16} and DIF Type 2 are natural enemies */
3347 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION &&
3348 cmd[1] & 0xe0) {
3349 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3350 INVALID_COMMAND_OPCODE, 0);
3351 errsts = check_condition_result;
3352 break;
3353 }
3354
3355 if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION ||
3356 scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) &&
3357 (cmd[1] & 0xe0) == 0)
3358 printk(KERN_ERR "Unprotected RD/WR to DIF device\n");
3359
3360 /* fall through */
3361 case WRITE_6:
3362 write:
3363 errsts = check_readiness(SCpnt, 0, devip);
3364 if (errsts)
3365 break;
3366 if (scsi_debug_fake_rw)
3367 break;
3368 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3369 errsts = resp_write(SCpnt, lba, num, devip, ei_lba);
3370 if (inj_recovered && (0 == errsts)) {
3371 mk_sense_buffer(devip, RECOVERED_ERROR,
3372 THRESHOLD_EXCEEDED, 0);
3373 errsts = check_condition_result;
3374 } else if (inj_dif && (0 == errsts)) {
3375 mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, 1);
3376 errsts = illegal_condition_result;
3377 } else if (inj_dix && (0 == errsts)) {
3378 mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, 1);
3379 errsts = illegal_condition_result;
3380 }
3381 break;
3382 case MODE_SENSE:
3383 case MODE_SENSE_10:
3384 errsts = resp_mode_sense(SCpnt, target, devip);
3385 break;
3386 case MODE_SELECT:
3387 errsts = resp_mode_select(SCpnt, 1, devip);
3388 break;
3389 case MODE_SELECT_10:
3390 errsts = resp_mode_select(SCpnt, 0, devip);
3391 break;
3392 case LOG_SENSE:
3393 errsts = resp_log_sense(SCpnt, devip);
3394 break;
3395 case SYNCHRONIZE_CACHE:
3396 delay_override = 1;
3397 errsts = check_readiness(SCpnt, 0, devip);
3398 break;
3399 case WRITE_BUFFER:
3400 errsts = check_readiness(SCpnt, 1, devip);
3401 break;
3402 case XDWRITEREAD_10:
3403 if (!scsi_bidi_cmnd(SCpnt)) {
3404 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3405 INVALID_FIELD_IN_CDB, 0);
3406 errsts = check_condition_result;
3407 break;
3408 }
3409
3410 errsts = check_readiness(SCpnt, 0, devip);
3411 if (errsts)
3412 break;
3413 if (scsi_debug_fake_rw)
3414 break;
3415 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3416 errsts = resp_read(SCpnt, lba, num, devip, ei_lba);
3417 if (errsts)
3418 break;
3419 errsts = resp_write(SCpnt, lba, num, devip, ei_lba);
3420 if (errsts)
3421 break;
3422 errsts = resp_xdwriteread(SCpnt, lba, num, devip);
3423 break;
3424 case VARIABLE_LENGTH_CMD:
3425 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION) {
3426
3427 if ((cmd[10] & 0xe0) == 0)
3428 printk(KERN_ERR
3429 "Unprotected RD/WR to DIF device\n");
3430
3431 if (cmd[9] == READ_32) {
3432 BUG_ON(SCpnt->cmd_len < 32);
3433 goto read;
3434 }
3435
3436 if (cmd[9] == WRITE_32) {
3437 BUG_ON(SCpnt->cmd_len < 32);
3438 goto write;
3439 }
3440 }
3441
3442 mk_sense_buffer(devip, ILLEGAL_REQUEST,
3443 INVALID_FIELD_IN_CDB, 0);
3444 errsts = check_condition_result;
3445 break;
3446
3447 default:
3448 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
3449 printk(KERN_INFO "scsi_debug: Opcode: 0x%x not "
3450 "supported\n", *cmd);
3451 errsts = check_readiness(SCpnt, 1, devip);
3452 if (errsts)
3453 break; /* Unit attention takes precedence */
3454 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
3455 errsts = check_condition_result;
3456 break;
3457 }
3458 return schedule_resp(SCpnt, devip, done, errsts,
3459 (delay_override ? 0 : scsi_debug_delay));
3460 }
3461
3462 static struct scsi_host_template sdebug_driver_template = {
3463 .proc_info = scsi_debug_proc_info,
3464 .proc_name = sdebug_proc_name,
3465 .name = "SCSI DEBUG",
3466 .info = scsi_debug_info,
3467 .slave_alloc = scsi_debug_slave_alloc,
3468 .slave_configure = scsi_debug_slave_configure,
3469 .slave_destroy = scsi_debug_slave_destroy,
3470 .ioctl = scsi_debug_ioctl,
3471 .queuecommand = scsi_debug_queuecommand,
3472 .eh_abort_handler = scsi_debug_abort,
3473 .eh_bus_reset_handler = scsi_debug_bus_reset,
3474 .eh_device_reset_handler = scsi_debug_device_reset,
3475 .eh_host_reset_handler = scsi_debug_host_reset,
3476 .bios_param = scsi_debug_biosparam,
3477 .can_queue = SCSI_DEBUG_CANQUEUE,
3478 .this_id = 7,
3479 .sg_tablesize = 256,
3480 .cmd_per_lun = 16,
3481 .max_sectors = 0xffff,
3482 .use_clustering = DISABLE_CLUSTERING,
3483 .module = THIS_MODULE,
3484 };
3485
3486 static int sdebug_driver_probe(struct device * dev)
3487 {
3488 int error = 0;
3489 struct sdebug_host_info *sdbg_host;
3490 struct Scsi_Host *hpnt;
3491 int host_prot;
3492
3493 sdbg_host = to_sdebug_host(dev);
3494
3495 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
3496 if (NULL == hpnt) {
3497 printk(KERN_ERR "%s: scsi_register failed\n", __func__);
3498 error = -ENODEV;
3499 return error;
3500 }
3501
3502 sdbg_host->shost = hpnt;
3503 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
3504 if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
3505 hpnt->max_id = scsi_debug_num_tgts + 1;
3506 else
3507 hpnt->max_id = scsi_debug_num_tgts;
3508 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* = scsi_debug_max_luns; */
3509
3510 host_prot = 0;
3511
3512 switch (scsi_debug_dif) {
3513
3514 case SD_DIF_TYPE1_PROTECTION:
3515 host_prot = SHOST_DIF_TYPE1_PROTECTION;
3516 if (scsi_debug_dix)
3517 host_prot |= SHOST_DIX_TYPE1_PROTECTION;
3518 break;
3519
3520 case SD_DIF_TYPE2_PROTECTION:
3521 host_prot = SHOST_DIF_TYPE2_PROTECTION;
3522 if (scsi_debug_dix)
3523 host_prot |= SHOST_DIX_TYPE2_PROTECTION;
3524 break;
3525
3526 case SD_DIF_TYPE3_PROTECTION:
3527 host_prot = SHOST_DIF_TYPE3_PROTECTION;
3528 if (scsi_debug_dix)
3529 host_prot |= SHOST_DIX_TYPE3_PROTECTION;
3530 break;
3531
3532 default:
3533 if (scsi_debug_dix)
3534 host_prot |= SHOST_DIX_TYPE0_PROTECTION;
3535 break;
3536 }
3537
3538 scsi_host_set_prot(hpnt, host_prot);
3539
3540 printk(KERN_INFO "scsi_debug: host protection%s%s%s%s%s%s%s\n",
3541 (host_prot & SHOST_DIF_TYPE1_PROTECTION) ? " DIF1" : "",
3542 (host_prot & SHOST_DIF_TYPE2_PROTECTION) ? " DIF2" : "",
3543 (host_prot & SHOST_DIF_TYPE3_PROTECTION) ? " DIF3" : "",
3544 (host_prot & SHOST_DIX_TYPE0_PROTECTION) ? " DIX0" : "",
3545 (host_prot & SHOST_DIX_TYPE1_PROTECTION) ? " DIX1" : "",
3546 (host_prot & SHOST_DIX_TYPE2_PROTECTION) ? " DIX2" : "",
3547 (host_prot & SHOST_DIX_TYPE3_PROTECTION) ? " DIX3" : "");
3548
3549 if (scsi_debug_guard == 1)
3550 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_IP);
3551 else
3552 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_CRC);
3553
3554 error = scsi_add_host(hpnt, &sdbg_host->dev);
3555 if (error) {
3556 printk(KERN_ERR "%s: scsi_add_host failed\n", __func__);
3557 error = -ENODEV;
3558 scsi_host_put(hpnt);
3559 } else
3560 scsi_scan_host(hpnt);
3561
3562
3563 return error;
3564 }
3565
3566 static int sdebug_driver_remove(struct device * dev)
3567 {
3568 struct sdebug_host_info *sdbg_host;
3569 struct sdebug_dev_info *sdbg_devinfo, *tmp;
3570
3571 sdbg_host = to_sdebug_host(dev);
3572
3573 if (!sdbg_host) {
3574 printk(KERN_ERR "%s: Unable to locate host info\n",
3575 __func__);
3576 return -ENODEV;
3577 }
3578
3579 scsi_remove_host(sdbg_host->shost);
3580
3581 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list,
3582 dev_list) {
3583 list_del(&sdbg_devinfo->dev_list);
3584 kfree(sdbg_devinfo);
3585 }
3586
3587 scsi_host_put(sdbg_host->shost);
3588 return 0;
3589 }
3590
3591 static int pseudo_lld_bus_match(struct device *dev,
3592 struct device_driver *dev_driver)
3593 {
3594 return 1;
3595 }
3596
3597 static struct bus_type pseudo_lld_bus = {
3598 .name = "pseudo",
3599 .match = pseudo_lld_bus_match,
3600 .probe = sdebug_driver_probe,
3601 .remove = sdebug_driver_remove,
3602 };
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree