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