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