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