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