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