drivers/scsi/scsi_debug.c

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