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