git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/scsi_debug.c

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