drivers/scsi/scsi_debug.c

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