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

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