drivers/scsi/scsi_debug.c

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