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