err.no Git - linux-2.6/blob - drivers/scsi/scsi_debug.c

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