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