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