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