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