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