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