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