drivers/scsi/scsi_debug.c

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