drivers/scsi/scsi_debug.c

   1 /*
   2  *  linux/kernel/scsi_debug.c
   3  * vvvvvvvvvvvvvvvvvvvvvvv Original vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
   4  *  Copyright (C) 1992  Eric Youngdale
   5  *  Simulate a host adapter with 2 disks attached.  Do a lot of checking
   6  *  to make sure that we are not getting blocks mixed up, and PANIC if
   7  *  anything out of the ordinary is seen.
   8  * ^^^^^^^^^^^^^^^^^^^^^^^ Original ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   9  *
  10  *  This version is more generic, simulating a variable number of disk
  11  *  (or disk like devices) sharing a common amount of RAM
  12  *
  13  *
  14  *  For documentation see http://www.torque.net/sg/sdebug25.html
  15  *
  16  *   D. Gilbert (dpg) work for Magneto-Optical device test [20010421]
  17  *   dpg: work for devfs large number of disks [20010809]
  18  *        forked for lk 2.5 series [20011216, 20020101]
  19  *        use vmalloc() more inquiry+mode_sense [20020302]
  20  *        add timers for delayed responses [20020721]
  21  *   Patrick Mansfield <patmans@us.ibm.com> max_luns+scsi_level [20021031]
  22  *   Mike Anderson <andmike@us.ibm.com> sysfs work [20021118]
  23  *   dpg: change style of boot options to "scsi_debug.num_tgts=2" and
  24  *        module options to "modprobe scsi_debug num_tgts=2" [20021221]
  25  */
  26
  27 #include <linux/config.h>
  28 #include <linux/module.h>
  29
  30 #include <linux/kernel.h>
  31 #include <linux/sched.h>
  32 #include <linux/errno.h>
  33 #include <linux/timer.h>
  34 #include <linux/types.h>
  35 #include <linux/string.h>
  36 #include <linux/genhd.h>
  37 #include <linux/fs.h>
  38 #include <linux/init.h>
  39 #include <linux/proc_fs.h>
  40 #include <linux/smp_lock.h>
  41 #include <linux/vmalloc.h>
  42 #include <linux/moduleparam.h>
  43
  44 #include <linux/blkdev.h>
  45 #include "scsi.h"
  46 #include <scsi/scsi_host.h>
  47 #include <scsi/scsicam.h>
  48
  49 #include <linux/stat.h>
  50
  51 #ifndef LINUX_VERSION_CODE
  52 #include <linux/version.h>
  53 #endif
  54
  55 #include "scsi_logging.h"
  56 #include "scsi_debug.h"
  57
  58 #define SCSI_DEBUG_VERSION "1.73"
  59 static const char * scsi_debug_version_date = "20040518";
  60
  61 /* Additional Sense Code (ASC) used */
  62 #define NO_ADDED_SENSE 0x0
  63 #define UNRECOVERED_READ_ERR 0x11
  64 #define INVALID_OPCODE 0x20
  65 #define ADDR_OUT_OF_RANGE 0x21
  66 #define INVALID_FIELD_IN_CDB 0x24
  67 #define POWERON_RESET 0x29
  68 #define SAVING_PARAMS_UNSUP 0x39
  69 #define THRESHHOLD_EXCEEDED 0x5d
  70
  71 #define SDEBUG_TAGGED_QUEUING 0 /* 0 | MSG_SIMPLE_TAG | MSG_ORDERED_TAG */
  72
  73 /* Default values for driver parameters */
  74 #define DEF_NUM_HOST   1
  75 #define DEF_NUM_TGTS   1
  76 #define DEF_MAX_LUNS   1
  77 /* With these defaults, this driver will make 1 host with 1 target
  78  * (id 0) containing 1 logical unit (lun 0). That is 1 device.
  79  */
  80 #define DEF_DELAY   1
  81 #define DEF_DEV_SIZE_MB   8
  82 #define DEF_EVERY_NTH   0
  83 #define DEF_NUM_PARTS   0
  84 #define DEF_OPTS   0
  85 #define DEF_SCSI_LEVEL   3
  86 #define DEF_PTYPE   0
  87
  88 /* bit mask values for scsi_debug_opts */
  89 #define SCSI_DEBUG_OPT_NOISE   1
  90 #define SCSI_DEBUG_OPT_MEDIUM_ERR   2
  91 #define SCSI_DEBUG_OPT_TIMEOUT   4
  92 #define SCSI_DEBUG_OPT_RECOVERED_ERR   8
  93 /* When "every_nth" > 0 then modulo "every_nth" commands:
  94  *   - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set
  95  *   - a RECOVERED_ERROR is simulated on successful read and write
  96  *     commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set.
  97  */
  98
  99 /* when 1==SCSI_DEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this
 100  * sector on read commands: */
 101 #define OPT_MEDIUM_ERR_ADDR   0x1234 /* that's sector 4660 in decimal */
 102
 103 /* If REPORT LUNS has luns >= 256 it can choose "flat space" (value 1)
 104  * or "peripheral device" addressing (value 0) */
 105 #define SAM2_LUN_ADDRESS_METHOD 0
 106
 107 static int scsi_debug_add_host = DEF_NUM_HOST;
 108 static int scsi_debug_delay = DEF_DELAY;
 109 static int scsi_debug_dev_size_mb = DEF_DEV_SIZE_MB;
 110 static int scsi_debug_every_nth = DEF_EVERY_NTH;
 111 static int scsi_debug_max_luns = DEF_MAX_LUNS;
 112 static int scsi_debug_num_parts = DEF_NUM_PARTS;
 113 static int scsi_debug_num_tgts = DEF_NUM_TGTS; /* targets per host */
 114 static int scsi_debug_opts = DEF_OPTS;
 115 static int scsi_debug_scsi_level = DEF_SCSI_LEVEL;
 116 static int scsi_debug_ptype = DEF_PTYPE; /* SCSI peripheral type (0==disk) */
 117
 118 static int scsi_debug_cmnd_count = 0;
 119
 120 #define DEV_READONLY(TGT)      (0)
 121 #define DEV_REMOVEABLE(TGT)    (0)
 122
 123 static unsigned long sdebug_store_size; /* in bytes */
 124 static sector_t sdebug_capacity;        /* in sectors */
 125
 126 /* old BIOS stuff, kernel may get rid of them but some mode sense pages
 127    may still need them */
 128 static int sdebug_heads;                /* heads per disk */
 129 static int sdebug_cylinders_per;        /* cylinders per surface */
 130 static int sdebug_sectors_per;          /* sectors per cylinder */
 131
 132 /* default sector size is 512 bytes, 2**9 bytes */
 133 #define POW2_SECT_SIZE 9
 134 #define SECT_SIZE (1 << POW2_SECT_SIZE)
 135 #define SECT_SIZE_PER(TGT) SECT_SIZE
 136
 137 #define SDEBUG_MAX_PARTS 4
 138
 139 #define SDEBUG_SENSE_LEN 32
 140
 141 struct sdebug_dev_info {
 142         struct list_head dev_list;
 143         unsigned char sense_buff[SDEBUG_SENSE_LEN];     /* weak nexus */
 144         unsigned int channel;
 145         unsigned int target;
 146         unsigned int lun;
 147         struct sdebug_host_info *sdbg_host;
 148         char reset;
 149         char used;
 150 };
 151
 152 struct sdebug_host_info {
 153         struct list_head host_list;
 154         struct Scsi_Host *shost;
 155         struct device dev;
 156         struct list_head dev_info_list;
 157 };
 158
 159 #define to_sdebug_host(d)       \
 160         container_of(d, struct sdebug_host_info, dev)
 161
 162 static LIST_HEAD(sdebug_host_list);
 163 static spinlock_t sdebug_host_list_lock = SPIN_LOCK_UNLOCKED;
 164
 165 typedef void (* done_funct_t) (struct scsi_cmnd *);
 166
 167 struct sdebug_queued_cmd {
 168         int in_use;
 169         struct timer_list cmnd_timer;
 170         done_funct_t done_funct;
 171         struct scsi_cmnd * a_cmnd;
 172         int scsi_result;
 173 };
 174 static struct sdebug_queued_cmd queued_arr[SCSI_DEBUG_CANQUEUE];
 175
 176 static Scsi_Host_Template sdebug_driver_template = {
 177         .proc_info =            scsi_debug_proc_info,
 178         .name =                 "SCSI DEBUG",
 179         .info =                 scsi_debug_info,
 180         .slave_alloc =          scsi_debug_slave_alloc,
 181         .slave_configure =      scsi_debug_slave_configure,
 182         .slave_destroy =        scsi_debug_slave_destroy,
 183         .ioctl =                scsi_debug_ioctl,
 184         .queuecommand =         scsi_debug_queuecommand,
 185         .eh_abort_handler =     scsi_debug_abort,
 186         .eh_bus_reset_handler = scsi_debug_bus_reset,
 187         .eh_device_reset_handler = scsi_debug_device_reset,
 188         .eh_host_reset_handler = scsi_debug_host_reset,
 189         .bios_param =           scsi_debug_biosparam,
 190         .can_queue =            SCSI_DEBUG_CANQUEUE,
 191         .this_id =              7,
 192         .sg_tablesize =         64,
 193         .cmd_per_lun =          3,
 194         .max_sectors =          4096,
 195         .unchecked_isa_dma =    0,
 196         .use_clustering =       ENABLE_CLUSTERING,
 197         .module =               THIS_MODULE,
 198 };
 199
 200 static unsigned char * fake_storep;     /* ramdisk storage */
 201
 202 static unsigned char spare_buff[SDEBUG_SENSE_LEN];
 203
 204 static int num_aborts = 0;
 205 static int num_dev_resets = 0;
 206 static int num_bus_resets = 0;
 207 static int num_host_resets = 0;
 208
 209 static spinlock_t queued_arr_lock = SPIN_LOCK_UNLOCKED;
 210 static rwlock_t atomic_rw = RW_LOCK_UNLOCKED;
 211
 212 static char sdebug_proc_name[] = "scsi_debug";
 213
 214 static int sdebug_driver_probe(struct device *);
 215 static int sdebug_driver_remove(struct device *);
 216 static struct bus_type pseudo_lld_bus;
 217
 218 static struct device_driver sdebug_driverfs_driver = {
 219         .name           = sdebug_proc_name,
 220         .bus            = &pseudo_lld_bus,
 221         .probe          = sdebug_driver_probe,
 222         .remove         = sdebug_driver_remove,
 223 };
 224
 225 static const int check_condition_result =
 226                 (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
 227
 228 /* function declarations */
 229 static int resp_inquiry(unsigned char * cmd, int target, unsigned char * buff,
 230                         int bufflen, struct sdebug_dev_info * devip);
 231 static int resp_mode_sense(unsigned char * cmd, int target,
 232                            unsigned char * buff, int bufflen,
 233                            struct sdebug_dev_info * devip);
 234 static int resp_read(struct scsi_cmnd * SCpnt, int upper_blk, int block,
 235                      int num, struct sdebug_dev_info * devip);
 236 static int resp_write(struct scsi_cmnd * SCpnt, int upper_blk, int block,
 237                       int num, struct sdebug_dev_info * devip);
 238 static int resp_report_luns(unsigned char * cmd, unsigned char * buff,
 239                             int bufflen, struct sdebug_dev_info * devip);
 240 static void timer_intr_handler(unsigned long);
 241 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev);
 242 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
 243                             int asc, int asq, int inbandLen);
 244 static int check_reset(struct scsi_cmnd * SCpnt,
 245                        struct sdebug_dev_info * devip);
 246 static int schedule_resp(struct scsi_cmnd * cmnd,
 247                          struct sdebug_dev_info * devip,
 248                          done_funct_t done, int scsi_result, int delta_jiff);
 249 static void __init sdebug_build_parts(unsigned char * ramp);
 250 static void __init init_all_queued(void);
 251 static void stop_all_queued(void);
 252 static int stop_queued_cmnd(struct scsi_cmnd * cmnd);
 253 static int inquiry_evpd_83(unsigned char * arr, int dev_id_num,
 254                            const char * dev_id_str, int dev_id_str_len);
 255 static void do_create_driverfs_files(void);
 256 static void do_remove_driverfs_files(void);
 257
 258 static int sdebug_add_adapter(void);
 259 static void sdebug_remove_adapter(void);
 260 static void sdebug_max_tgts_luns(void);
 261
 262 static struct device pseudo_primary;
 263 static struct bus_type pseudo_lld_bus;
 264
 265 static unsigned char * scatg2virt(const struct scatterlist * sclp)
 266 {
 267         if (NULL == sclp)
 268                 return NULL;
 269         else if (sclp->page)
 270                 return (unsigned char *)page_address(sclp->page) +
 271                        sclp->offset;
 272         else
 273                 return NULL;
 274 }
 275
 276 static
 277 int scsi_debug_queuecommand(struct scsi_cmnd * SCpnt, done_funct_t done)
 278 {
 279         unsigned char *cmd = (unsigned char *) SCpnt->cmnd;
 280         int block, upper_blk, num;
 281         unsigned char *buff;
 282         int errsts = 0;
 283         int target = SCpnt->device->id;
 284         int bufflen = SCpnt->request_bufflen;
 285         unsigned long capac;
 286         struct sdebug_dev_info * devip = NULL;
 287         unsigned char * sbuff;
 288         int inj_recovered = 0;
 289
 290         if (done == NULL)
 291                 return 0;       /* assume mid level reprocessing command */
 292
 293         if (SCpnt->use_sg) { /* just use first element */
 294                 struct scatterlist *sgpnt = (struct scatterlist *)
 295                                                 SCpnt->request_buffer;
 296
 297                 buff = scatg2virt(&sgpnt[0]);
 298                 bufflen = sgpnt[0].length;
 299                 /* READ and WRITE process scatterlist themselves */
 300         }
 301         else
 302                 buff = (unsigned char *) SCpnt->request_buffer;
 303         if (NULL == buff) {
 304                 buff = spare_buff;      /* assume cmd moves no data */
 305                 bufflen = SDEBUG_SENSE_LEN;
 306         }
 307
 308
 309         if(target == sdebug_driver_template.this_id) {
 310                 printk(KERN_INFO "scsi_debug: initiator's id used as "
 311                        "target!\n");
 312                 return schedule_resp(SCpnt, NULL, done,
 313                                      DID_NO_CONNECT << 16, 0);
 314         }
 315
 316         if (SCpnt->device->lun >= scsi_debug_max_luns)
 317                 return schedule_resp(SCpnt, NULL, done,
 318                                      DID_NO_CONNECT << 16, 0);
 319         devip = devInfoReg(SCpnt->device);
 320         if (NULL == devip)
 321                 return schedule_resp(SCpnt, NULL, done,
 322                                      DID_NO_CONNECT << 16, 0);
 323
 324         if ((scsi_debug_every_nth > 0) &&
 325             (++scsi_debug_cmnd_count >= scsi_debug_every_nth)) {
 326                 scsi_debug_cmnd_count =0;
 327                 if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
 328                         return 0; /* ignore command causing timeout */
 329                 else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
 330                         inj_recovered = 1; /* to reads and writes below */
 331         }
 332
 333         switch (*cmd) {
 334         case INQUIRY:     /* mandatory */
 335                 errsts = resp_inquiry(cmd, target, buff, bufflen, devip);
 336                 break;
 337         case REQUEST_SENSE:     /* mandatory */
 338                 /* Since this driver indicates autosense by placing the
 339                  * sense buffer in the scsi_cmnd structure in the response
 340                  * (when SAM_STAT_CHECK_CONDITION is set), the mid level
 341                  * shouldn't need to call REQUEST_SENSE */
 342                 if (devip) {
 343                         sbuff = devip->sense_buff;
 344                         memcpy(buff, sbuff, (bufflen < SDEBUG_SENSE_LEN) ?
 345                                              bufflen : SDEBUG_SENSE_LEN);
 346                         mk_sense_buffer(devip, 0, NO_ADDED_SENSE, 0, 7);
 347                 } else {
 348                         memset(buff, 0, bufflen);
 349                         buff[0] = 0x70;
 350                 }
 351                 break;
 352         case START_STOP:
 353                 errsts = check_reset(SCpnt, devip);
 354                 break;
 355         case ALLOW_MEDIUM_REMOVAL:
 356                 if ((errsts = check_reset(SCpnt, devip)))
 357                         break;
 358                 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
 359                         printk("\tMedium removal %s\n",
 360                                cmd[4] ? "inhibited" : "enabled");
 361                 break;
 362         case SEND_DIAGNOSTIC:     /* mandatory */
 363                 memset(buff, 0, bufflen);
 364                 break;
 365         case TEST_UNIT_READY:     /* mandatory */
 366                 memset(buff, 0, bufflen);
 367                 break;
 368         case RESERVE:
 369                 errsts = check_reset(SCpnt, devip);
 370                 memset(buff, 0, bufflen);
 371                 break;
 372         case RESERVE_10:
 373                 errsts = check_reset(SCpnt, devip);
 374                 memset(buff, 0, bufflen);
 375                 break;
 376         case RELEASE:
 377                 errsts = check_reset(SCpnt, devip);
 378                 memset(buff, 0, bufflen);
 379                 break;
 380         case RELEASE_10:
 381                 errsts = check_reset(SCpnt, devip);
 382                 memset(buff, 0, bufflen);
 383                 break;
 384         case READ_CAPACITY:
 385                 errsts = check_reset(SCpnt, devip);
 386                 memset(buff, 0, bufflen);
 387                 if (bufflen > 7) {
 388                         capac = (unsigned long)sdebug_capacity - 1;
 389                         buff[0] = (capac >> 24);
 390                         buff[1] = (capac >> 16) & 0xff;
 391                         buff[2] = (capac >> 8) & 0xff;
 392                         buff[3] = capac & 0xff;
 393                         buff[6] = (SECT_SIZE_PER(target) >> 8) & 0xff;
 394                         buff[7] = SECT_SIZE_PER(target) & 0xff;
 395                 }
 396                 break;
 397         case READ_16:
 398         case READ_12:
 399         case READ_10:
 400         case READ_6:
 401                 if ((errsts = check_reset(SCpnt, devip)))
 402                         break;
 403                 upper_blk = 0;
 404                 if ((*cmd) == READ_16) {
 405                         upper_blk = cmd[5] + (cmd[4] << 8) +
 406                                     (cmd[3] << 16) + (cmd[2] << 24);
 407                         block = cmd[9] + (cmd[8] << 8) +
 408                                 (cmd[7] << 16) + (cmd[6] << 24);
 409                         num = cmd[13] + (cmd[12] << 8) +
 410                                 (cmd[11] << 16) + (cmd[10] << 24);
 411                 } else if ((*cmd) == READ_12) {
 412                         block = cmd[5] + (cmd[4] << 8) +
 413                                 (cmd[3] << 16) + (cmd[2] << 24);
 414                         num = cmd[9] + (cmd[8] << 8) +
 415                                 (cmd[7] << 16) + (cmd[6] << 24);
 416                 } else if ((*cmd) == READ_10) {
 417                         block = cmd[5] + (cmd[4] << 8) +
 418                                 (cmd[3] << 16) + (cmd[2] << 24);
 419                         num = cmd[8] + (cmd[7] << 8);
 420                 } else {
 421                         block = cmd[3] + (cmd[2] << 8) +
 422                                 ((cmd[1] & 0x1f) << 16);
 423                         num = cmd[4];
 424                 }
 425                 errsts = resp_read(SCpnt, upper_blk, block, num, devip);
 426                 if (inj_recovered && (0 == errsts)) {
 427                         mk_sense_buffer(devip, RECOVERED_ERROR,
 428                                         THRESHHOLD_EXCEEDED, 0, 18);
 429                         errsts = check_condition_result;
 430                 }
 431                 break;
 432         case REPORT_LUNS:
 433                 errsts = resp_report_luns(cmd, buff, bufflen, devip);
 434                 break;
 435         case WRITE_16:
 436         case WRITE_12:
 437         case WRITE_10:
 438         case WRITE_6:
 439                 if ((errsts = check_reset(SCpnt, devip)))
 440                         break;
 441                 upper_blk = 0;
 442                 if ((*cmd) == WRITE_16) {
 443                         upper_blk = cmd[5] + (cmd[4] << 8) +
 444                                     (cmd[3] << 16) + (cmd[2] << 24);
 445                         block = cmd[9] + (cmd[8] << 8) +
 446                                 (cmd[7] << 16) + (cmd[6] << 24);
 447                         num = cmd[13] + (cmd[12] << 8) +
 448                                 (cmd[11] << 16) + (cmd[10] << 24);
 449                 } else if ((*cmd) == WRITE_12) {
 450                         block = cmd[5] + (cmd[4] << 8) +
 451                                 (cmd[3] << 16) + (cmd[2] << 24);
 452                         num = cmd[9] + (cmd[8] << 8) +
 453                                 (cmd[7] << 16) + (cmd[6] << 24);
 454                 } else if ((*cmd) == WRITE_10) {
 455                         block = cmd[5] + (cmd[4] << 8) +
 456                                 (cmd[3] << 16) + (cmd[2] << 24);
 457                         num = cmd[8] + (cmd[7] << 8);
 458                 } else {
 459                         block = cmd[3] + (cmd[2] << 8) +
 460                                 ((cmd[1] & 0x1f) << 16);
 461                         num = cmd[4];
 462                 }
 463                 errsts = resp_write(SCpnt, upper_blk, block, num, devip);
 464                 if (inj_recovered && (0 == errsts)) {
 465                         mk_sense_buffer(devip, RECOVERED_ERROR,
 466                                         THRESHHOLD_EXCEEDED, 0, 18);
 467                         errsts = check_condition_result;
 468                 }
 469                 break;
 470         case MODE_SENSE:
 471         case MODE_SENSE_10:
 472                 errsts = resp_mode_sense(cmd, target, buff, bufflen, devip);
 473                 break;
 474         case SYNCHRONIZE_CACHE:
 475                 memset(buff, 0, bufflen);
 476                 break;
 477         default:
 478                 if ((errsts = check_reset(SCpnt, devip)))
 479                         break;
 480                 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0, 18);
 481                 errsts = check_condition_result;
 482                 break;
 483         }
 484         return schedule_resp(SCpnt, devip, done, errsts, scsi_debug_delay);
 485 }
 486
 487 static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
 488 {
 489         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
 490                 printk(KERN_INFO "scsi_debug: ioctl: cmd=0x%x\n", cmd);
 491         }
 492         return -EINVAL;
 493         /* return -ENOTTY; // correct return but upsets fdisk */
 494 }
 495
 496 static int check_reset(struct scsi_cmnd * SCpnt, struct sdebug_dev_info * devip)
 497 {
 498         if (devip->reset) {
 499                 devip->reset = 0;
 500                 mk_sense_buffer(devip, UNIT_ATTENTION, POWERON_RESET, 0, 18);
 501                 return check_condition_result;
 502         }
 503         return 0;
 504 }
 505
 506 #define SDEBUG_LONG_INQ_SZ 58
 507 #define SDEBUG_MAX_INQ_ARR_SZ 128
 508
 509 static const char * vendor_id = "Linux   ";
 510 static const char * product_id = "scsi_debug      ";
 511 static const char * product_rev = "0004";
 512
 513 static int inquiry_evpd_83(unsigned char * arr, int dev_id_num,
 514                            const char * dev_id_str, int dev_id_str_len)
 515 {
 516         int num;
 517
 518         /* Two identification descriptors: */
 519         /* T10 vendor identifier field format (faked) */
 520         arr[0] = 0x2;   /* ASCII */
 521         arr[1] = 0x1;
 522         arr[2] = 0x0;
 523         memcpy(&arr[4], vendor_id, 8);
 524         memcpy(&arr[12], product_id, 16);
 525         memcpy(&arr[28], dev_id_str, dev_id_str_len);
 526         num = 8 + 16 + dev_id_str_len;
 527         arr[3] = num;
 528         num += 4;
 529         /* NAA IEEE registered identifier (faked) */
 530         arr[num] = 0x1; /* binary */
 531         arr[num + 1] = 0x3;
 532         arr[num + 2] = 0x0;
 533         arr[num + 3] = 0x8;
 534         arr[num + 4] = 0x51;    /* ieee company id=0x123456 (faked) */
 535         arr[num + 5] = 0x23;
 536         arr[num + 6] = 0x45;
 537         arr[num + 7] = 0x60;
 538         arr[num + 8] = (dev_id_num >> 24);
 539         arr[num + 9] = (dev_id_num >> 16) & 0xff;
 540         arr[num + 10] = (dev_id_num >> 8) & 0xff;
 541         arr[num + 11] = dev_id_num & 0xff;
 542         return num + 12;
 543 }
 544
 545 static int resp_inquiry(unsigned char * cmd, int target, unsigned char * buff,
 546                         int bufflen, struct sdebug_dev_info * devip)
 547 {
 548         unsigned char pq_pdt;
 549         unsigned char arr[SDEBUG_MAX_INQ_ARR_SZ];
 550         int min_len = bufflen > SDEBUG_MAX_INQ_ARR_SZ ?
 551                         SDEBUG_MAX_INQ_ARR_SZ : bufflen;
 552
 553         if (bufflen < cmd[4])
 554                 printk(KERN_INFO "scsi_debug: inquiry: bufflen=%d "
 555                        "< alloc_length=%d\n", bufflen, (int)cmd[4]);
 556         memset(buff, 0, bufflen);
 557         memset(arr, 0, SDEBUG_MAX_INQ_ARR_SZ);
 558         pq_pdt = (scsi_debug_ptype & 0x1f);
 559         arr[0] = pq_pdt;
 560         if (0x2 & cmd[1]) {  /* CMDDT bit set */
 561                 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
 562                                 0, 18);
 563                 return check_condition_result;
 564         } else if (0x1 & cmd[1]) {  /* EVPD bit set */
 565                 int dev_id_num, len;
 566                 char dev_id_str[6];
 567
 568                 dev_id_num = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
 569                              (devip->target * 1000) + devip->lun;
 570                 len = scnprintf(dev_id_str, 6, "%d", dev_id_num);
 571                 if (0 == cmd[2]) { /* supported vital product data pages */
 572                         arr[3] = 3;
 573                         arr[4] = 0x0; /* this page */
 574                         arr[5] = 0x80; /* unit serial number */
 575                         arr[6] = 0x83; /* device identification */
 576                 } else if (0x80 == cmd[2]) { /* unit serial number */
 577                         arr[1] = 0x80;
 578                         arr[3] = len;
 579                         memcpy(&arr[4], dev_id_str, len);
 580                 } else if (0x83 == cmd[2]) { /* device identification */
 581                         arr[1] = 0x83;
 582                         arr[3] = inquiry_evpd_83(&arr[4], dev_id_num,
 583                                                  dev_id_str, len);
 584                 } else {
 585                         /* Illegal request, invalid field in cdb */
 586                         mk_sense_buffer(devip, ILLEGAL_REQUEST,
 587                                         INVALID_FIELD_IN_CDB, 0, 18);
 588                         return check_condition_result;
 589                 }
 590                 memcpy(buff, arr, min_len);
 591                 return 0;
 592         }
 593         /* drops through here for a standard inquiry */
 594         arr[1] = DEV_REMOVEABLE(target) ? 0x80 : 0;     /* Removable disk */
 595         arr[2] = scsi_debug_scsi_level;
 596         arr[4] = SDEBUG_LONG_INQ_SZ - 5;
 597         arr[7] = 0x3a; /* claim: WBUS16, SYNC, LINKED + CMDQUE */
 598         memcpy(&arr[8], vendor_id, 8);
 599         memcpy(&arr[16], product_id, 16);
 600         memcpy(&arr[32], product_rev, 4);
 601         memcpy(buff, arr, min_len);
 602         return 0;
 603 }
 604
 605 /* <<Following mode page info copied from ST318451LW>> */
 606
 607 static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target)
 608 {       /* Read-Write Error Recovery page for mode_sense */
 609         unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
 610                                         5, 0, 0xff, 0xff};
 611
 612         memcpy(p, err_recov_pg, sizeof(err_recov_pg));
 613         if (1 == pcontrol)
 614                 memset(p + 2, 0, sizeof(err_recov_pg) - 2);
 615         return sizeof(err_recov_pg);
 616 }
 617
 618 static int resp_disconnect_pg(unsigned char * p, int pcontrol, int target)
 619 {       /* Disconnect-Reconnect page for mode_sense */
 620         unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
 621                                          0, 0, 0, 0, 0, 0, 0, 0};
 622
 623         memcpy(p, disconnect_pg, sizeof(disconnect_pg));
 624         if (1 == pcontrol)
 625                 memset(p + 2, 0, sizeof(disconnect_pg) - 2);
 626         return sizeof(disconnect_pg);
 627 }
 628
 629 static int resp_format_pg(unsigned char * p, int pcontrol, int target)
 630 {       /* Format device page for mode_sense */
 631         unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
 632                                      0, 0, 0, 0, 0, 0, 0, 0,
 633                                      0, 0, 0, 0, 0x40, 0, 0, 0};
 634
 635         memcpy(p, format_pg, sizeof(format_pg));
 636         p[10] = (sdebug_sectors_per >> 8) & 0xff;
 637         p[11] = sdebug_sectors_per & 0xff;
 638         p[12] = (SECT_SIZE >> 8) & 0xff;
 639         p[13] = SECT_SIZE & 0xff;
 640         if (DEV_REMOVEABLE(target))
 641                 p[20] |= 0x20; /* should agree with INQUIRY */
 642         if (1 == pcontrol)
 643                 memset(p + 2, 0, sizeof(format_pg) - 2);
 644         return sizeof(format_pg);
 645 }
 646
 647 static int resp_caching_pg(unsigned char * p, int pcontrol, int target)
 648 {       /* Caching page for mode_sense */
 649         unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
 650                 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0,     0, 0, 0, 0};
 651
 652         memcpy(p, caching_pg, sizeof(caching_pg));
 653         if (1 == pcontrol)
 654                 memset(p + 2, 0, sizeof(caching_pg) - 2);
 655         return sizeof(caching_pg);
 656 }
 657
 658 static int resp_ctrl_m_pg(unsigned char * p, int pcontrol, int target)
 659 {       /* Control mode page for mode_sense */
 660         unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
 661                                      0, 0, 0x2, 0x4b};
 662
 663         memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg));
 664         if (1 == pcontrol)
 665                 memset(p + 2, 0, sizeof(ctrl_m_pg) - 2);
 666         return sizeof(ctrl_m_pg);
 667 }
 668
 669 static int resp_iec_m_pg(unsigned char * p, int pcontrol, int target)
 670 {       /* Informational Exceptions control mode page for mode_sense */
 671         unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
 672                                     0, 0, 0x0, 0x0};
 673         memcpy(p, iec_m_pg, sizeof(iec_m_pg));
 674         if (1 == pcontrol)
 675                 memset(p + 2, 0, sizeof(iec_m_pg) - 2);
 676         return sizeof(iec_m_pg);
 677 }
 678
 679 #define SDEBUG_MAX_MSENSE_SZ 256
 680
 681 static int resp_mode_sense(unsigned char * cmd, int target,
 682                            unsigned char * buff, int bufflen,
 683                            struct sdebug_dev_info * devip)
 684 {
 685         unsigned char dbd;
 686         int pcontrol, pcode;
 687         unsigned char dev_spec;
 688         int alloc_len, msense_6, offset, len;
 689         unsigned char * ap;
 690         unsigned char arr[SDEBUG_MAX_MSENSE_SZ];
 691         int min_len = bufflen > SDEBUG_MAX_MSENSE_SZ ?
 692                         SDEBUG_MAX_MSENSE_SZ : bufflen;
 693
 694         SCSI_LOG_LLQUEUE(3, printk("Mode sense ...(%p %d)\n", buff, bufflen));
 695         dbd = cmd[1] & 0x8;
 696         pcontrol = (cmd[2] & 0xc0) >> 6;
 697         pcode = cmd[2] & 0x3f;
 698         msense_6 = (MODE_SENSE == cmd[0]);
 699         alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]);
 700         /* printk(KERN_INFO "msense: dbd=%d pcontrol=%d pcode=%d "
 701                 "msense_6=%d alloc_len=%d\n", dbd, pcontrol, pcode, "
 702                 "msense_6, alloc_len); */
 703         if (bufflen < alloc_len)
 704                 printk(KERN_INFO "scsi_debug: mode_sense: bufflen=%d "
 705                        "< alloc_length=%d\n", bufflen, alloc_len);
 706         memset(buff, 0, bufflen);
 707         memset(arr, 0, SDEBUG_MAX_MSENSE_SZ);
 708         if (0x3 == pcontrol) {  /* Saving values not supported */
 709                 mk_sense_buffer(devip, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP,
 710                                 0, 18);
 711                 return check_condition_result;
 712         }
 713         dev_spec = DEV_READONLY(target) ? 0x80 : 0x0;
 714         if (msense_6) {
 715                 arr[2] = dev_spec;
 716                 offset = 4;
 717         } else {
 718                 arr[3] = dev_spec;
 719                 offset = 8;
 720         }
 721         ap = arr + offset;
 722
 723         switch (pcode) {
 724         case 0x1:       /* Read-Write error recovery page, direct access */
 725                 len = resp_err_recov_pg(ap, pcontrol, target);
 726                 offset += len;
 727                 break;
 728         case 0x2:       /* Disconnect-Reconnect page, all devices */
 729                 len = resp_disconnect_pg(ap, pcontrol, target);
 730                 offset += len;
 731                 break;
 732         case 0x3:       /* Format device page, direct access */
 733                 len = resp_format_pg(ap, pcontrol, target);
 734                 offset += len;
 735                 break;
 736         case 0x8:       /* Caching page, direct access */
 737                 len = resp_caching_pg(ap, pcontrol, target);
 738                 offset += len;
 739                 break;
 740         case 0xa:       /* Control Mode page, all devices */
 741                 len = resp_ctrl_m_pg(ap, pcontrol, target);
 742                 offset += len;
 743                 break;
 744         case 0x1c:      /* Informational Exceptions Mode page, all devices */
 745                 len = resp_iec_m_pg(ap, pcontrol, target);
 746                 offset += len;
 747                 break;
 748         case 0x3f:      /* Read all Mode pages */
 749                 len = resp_err_recov_pg(ap, pcontrol, target);
 750                 len += resp_disconnect_pg(ap + len, pcontrol, target);
 751                 len += resp_format_pg(ap + len, pcontrol, target);
 752                 len += resp_caching_pg(ap + len, pcontrol, target);
 753                 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
 754                 len += resp_iec_m_pg(ap + len, pcontrol, target);
 755                 offset += len;
 756                 break;
 757         default:
 758                 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
 759                                 0, 18);
 760                 return check_condition_result;
 761         }
 762         if (msense_6)
 763                 arr[0] = offset - 1;
 764         else {
 765                 offset -= 2;
 766                 arr[0] = (offset >> 8) & 0xff;
 767                 arr[1] = offset & 0xff;
 768         }
 769         memcpy(buff, arr, min_len);
 770         return 0;
 771 }
 772
 773 static int resp_read(struct scsi_cmnd * SCpnt, int upper_blk, int block,
 774                      int num, struct sdebug_dev_info * devip)
 775 {
 776         unsigned char *buff = (unsigned char *) SCpnt->request_buffer;
 777         int nbytes, sgcount;
 778         struct scatterlist *sgpnt = NULL;
 779         int bufflen = SCpnt->request_bufflen;
 780         unsigned long iflags;
 781
 782         if (upper_blk || (block + num > sdebug_capacity)) {
 783                 mk_sense_buffer(devip, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE,
 784                                 0, 18);
 785                 return check_condition_result;
 786         }
 787         if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) &&
 788             (block <= OPT_MEDIUM_ERR_ADDR) &&
 789             ((block + num) > OPT_MEDIUM_ERR_ADDR)) {
 790                 mk_sense_buffer(devip, MEDIUM_ERROR, UNRECOVERED_READ_ERR,
 791                                 0, 18);
 792                 /* claim unrecoverable read error */
 793                 return check_condition_result;
 794         }
 795         read_lock_irqsave(&atomic_rw, iflags);
 796         sgcount = 0;
 797         nbytes = bufflen;
 798         /* printk(KERN_INFO "scsi_debug_read: block=%d, tot_bufflen=%d\n",
 799                block, bufflen); */
 800         if (SCpnt->use_sg) {
 801                 sgcount = 0;
 802                 sgpnt = (struct scatterlist *) buff;
 803                 buff = scatg2virt(&sgpnt[sgcount]);
 804                 bufflen = sgpnt[sgcount].length;
 805         }
 806         do {
 807                 memcpy(buff, fake_storep + (block * SECT_SIZE), bufflen);
 808                 nbytes -= bufflen;
 809                 if (SCpnt->use_sg) {
 810                         block += bufflen >> POW2_SECT_SIZE;
 811                         sgcount++;
 812                         if (nbytes) {
 813                                 buff = scatg2virt(&sgpnt[sgcount]);
 814                                 bufflen = sgpnt[sgcount].length;
 815                         }
 816                 } else if (nbytes > 0)
 817                         printk(KERN_WARNING "scsi_debug:resp_read: unexpected "
 818                                "nbytes=%d\n", nbytes);
 819         } while (nbytes);
 820         read_unlock_irqrestore(&atomic_rw, iflags);
 821         return 0;
 822 }
 823
 824 static int resp_write(struct scsi_cmnd * SCpnt, int upper_blk, int block,
 825                       int num, struct sdebug_dev_info * devip)
 826 {
 827         unsigned char *buff = (unsigned char *) SCpnt->request_buffer;
 828         int nbytes, sgcount;
 829         struct scatterlist *sgpnt = NULL;
 830         int bufflen = SCpnt->request_bufflen;
 831         unsigned long iflags;
 832
 833         if (upper_blk || (block + num > sdebug_capacity)) {
 834                 mk_sense_buffer(devip, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE,
 835                                 0, 18);
 836                 return check_condition_result;
 837         }
 838
 839         write_lock_irqsave(&atomic_rw, iflags);
 840         sgcount = 0;
 841         nbytes = bufflen;
 842         if (SCpnt->use_sg) {
 843                 sgcount = 0;
 844                 sgpnt = (struct scatterlist *) buff;
 845                 buff = scatg2virt(&sgpnt[sgcount]);
 846                 bufflen = sgpnt[sgcount].length;
 847         }
 848         do {
 849                 memcpy(fake_storep + (block * SECT_SIZE), buff, bufflen);
 850
 851                 nbytes -= bufflen;
 852                 if (SCpnt->use_sg) {
 853                         block += bufflen >> POW2_SECT_SIZE;
 854                         sgcount++;
 855                         if (nbytes) {
 856                                 buff = scatg2virt(&sgpnt[sgcount]);
 857                                 bufflen = sgpnt[sgcount].length;
 858                         }
 859                 } else if (nbytes > 0)
 860                         printk(KERN_WARNING "scsi_debug:resp_write: "
 861                                "unexpected nbytes=%d\n", nbytes);
 862         } while (nbytes);
 863         write_unlock_irqrestore(&atomic_rw, iflags);
 864         return 0;
 865 }
 866
 867 static int resp_report_luns(unsigned char * cmd, unsigned char * buff,
 868                             int bufflen, struct sdebug_dev_info * devip)
 869 {
 870         unsigned int alloc_len;
 871         int lun_cnt, i, upper;
 872         int select_report = (int)cmd[2];
 873         struct scsi_lun *one_lun;
 874
 875         alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
 876         if ((alloc_len < 16) || (select_report > 2)) {
 877                 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB,
 878                                 0, 18);
 879                 return check_condition_result;
 880         }
 881         if (bufflen > 8) { /* can produce response with up to 16k luns
 882                               (lun 0 to lun 16383) */
 883                 memset(buff, 0, bufflen);
 884                 lun_cnt = scsi_debug_max_luns;
 885                 buff[2] = ((sizeof(struct scsi_lun) * lun_cnt) >> 8) & 0xff;
 886                 buff[3] = (sizeof(struct scsi_lun) * lun_cnt) & 0xff;
 887                 lun_cnt = min((int)((bufflen - 8) / sizeof(struct scsi_lun)),
 888                               lun_cnt);
 889                 one_lun = (struct scsi_lun *) &buff[8];
 890                 for (i = 0; i < lun_cnt; i++) {
 891                         upper = (i >> 8) & 0x3f;
 892                         if (upper)
 893                                 one_lun[i].scsi_lun[0] =
 894                                     (upper | (SAM2_LUN_ADDRESS_METHOD << 6));
 895                         one_lun[i].scsi_lun[1] = i & 0xff;
 896                 }
 897         }
 898         return 0;
 899 }
 900
 901 /* When timer goes off this function is called. */
 902 static void timer_intr_handler(unsigned long indx)
 903 {
 904         struct sdebug_queued_cmd * sqcp;
 905         unsigned long iflags;
 906
 907         if (indx >= SCSI_DEBUG_CANQUEUE) {
 908                 printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too "
 909                        "large\n");
 910                 return;
 911         }
 912         spin_lock_irqsave(&queued_arr_lock, iflags);
 913         sqcp = &queued_arr[(int)indx];
 914         if (! sqcp->in_use) {
 915                 printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected "
 916                        "interrupt\n");
 917                 spin_unlock_irqrestore(&queued_arr_lock, iflags);
 918                 return;
 919         }
 920         sqcp->in_use = 0;
 921         if (sqcp->done_funct) {
 922                 sqcp->a_cmnd->result = sqcp->scsi_result;
 923                 sqcp->done_funct(sqcp->a_cmnd); /* callback to mid level */
 924         }
 925         sqcp->done_funct = NULL;
 926         spin_unlock_irqrestore(&queued_arr_lock, iflags);
 927 }
 928
 929 static int scsi_debug_slave_alloc(struct scsi_device * sdp)
 930 {
 931         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
 932                 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
 933                        sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
 934         return 0;
 935 }
 936
 937 static int scsi_debug_slave_configure(struct scsi_device * sdp)
 938 {
 939         struct sdebug_dev_info * devip;
 940
 941         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
 942                 printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n",
 943                        sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
 944         if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN)
 945                 sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN;
 946         devip = devInfoReg(sdp);
 947         sdp->hostdata = devip;
 948         if (sdp->host->cmd_per_lun)
 949                 scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING,
 950                                         sdp->host->cmd_per_lun);
 951         return 0;
 952 }
 953
 954 static void scsi_debug_slave_destroy(struct scsi_device * sdp)
 955 {
 956         struct sdebug_dev_info * devip =
 957                                 (struct sdebug_dev_info *)sdp->hostdata;
 958
 959         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
 960                 printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n",
 961                        sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
 962         if (devip) {
 963                 /* make this slot avaliable for re-use */
 964                 devip->used = 0;
 965                 sdp->hostdata = NULL;
 966         }
 967 }
 968
 969 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
 970 {
 971         struct sdebug_host_info * sdbg_host;
 972         struct sdebug_dev_info * open_devip = NULL;
 973         struct sdebug_dev_info * devip =
 974                         (struct sdebug_dev_info *)sdev->hostdata;
 975
 976         if (devip)
 977                 return devip;
 978         sdbg_host = *(struct sdebug_host_info **) sdev->host->hostdata;
 979         if(! sdbg_host) {
 980                 printk(KERN_ERR "Host info NULL\n");
 981                 return NULL;
 982         }
 983         list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
 984                 if ((devip->used) && (devip->channel == sdev->channel) &&
 985                     (devip->target == sdev->id) &&
 986                     (devip->lun == sdev->lun))
 987                         return devip;
 988                 else {
 989                         if ((!devip->used) && (!open_devip))
 990                                 open_devip = devip;
 991                 }
 992         }
 993         if (NULL == open_devip) { /* try and make a new one */
 994                 open_devip = kmalloc(sizeof(*open_devip),GFP_KERNEL);
 995                 if (NULL == open_devip) {
 996                         printk(KERN_ERR "%s: out of memory at line %d\n",
 997                                 __FUNCTION__, __LINE__);
 998                         return NULL;
 999                 }
1000                 memset(open_devip, 0, sizeof(*open_devip));
1001                 open_devip->sdbg_host = sdbg_host;
1002                 list_add_tail(&open_devip->dev_list,
1003                 &sdbg_host->dev_info_list);
1004         }
1005         if (open_devip) {
1006                 open_devip->channel = sdev->channel;
1007                 open_devip->target = sdev->id;
1008                 open_devip->lun = sdev->lun;
1009                 open_devip->sdbg_host = sdbg_host;
1010                 open_devip->reset = 1;
1011                 open_devip->used = 1;
1012                 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
1013                 open_devip->sense_buff[0] = 0x70;
1014                 return open_devip;
1015         }
1016         return NULL;
1017 }
1018
1019 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
1020                             int asc, int asq, int inbandLen)
1021 {
1022         unsigned char * sbuff;
1023
1024         sbuff = devip->sense_buff;
1025         memset(sbuff, 0, SDEBUG_SENSE_LEN);
1026         if (inbandLen > SDEBUG_SENSE_LEN)
1027                 inbandLen = SDEBUG_SENSE_LEN;
1028         sbuff[0] = 0x70;
1029         sbuff[2] = key;
1030         sbuff[7] = (inbandLen > 7) ? (inbandLen - 8) : 0;
1031         sbuff[12] = asc;
1032         sbuff[13] = asq;
1033 }
1034
1035 static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
1036 {
1037         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1038                 printk(KERN_INFO "scsi_debug: abort\n");
1039         ++num_aborts;
1040         stop_queued_cmnd(SCpnt);
1041         return SUCCESS;
1042 }
1043
1044 static int scsi_debug_biosparam(struct scsi_device *sdev,
1045                 struct block_device * bdev, sector_t capacity, int *info)
1046 {
1047         int res;
1048         unsigned char *buf;
1049
1050         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1051                 printk(KERN_INFO "scsi_debug: biosparam\n");
1052         buf = scsi_bios_ptable(bdev);
1053         if (buf) {
1054                 res = scsi_partsize(buf, capacity,
1055                                     &info[2], &info[0], &info[1]);
1056                 kfree(buf);
1057                 if (! res)
1058                         return res;
1059         }
1060         info[0] = sdebug_heads;
1061         info[1] = sdebug_sectors_per;
1062         info[2] = sdebug_cylinders_per;
1063         return 0;
1064 }
1065
1066 static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
1067 {
1068         struct sdebug_dev_info * devip;
1069
1070         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1071                 printk(KERN_INFO "scsi_debug: device_reset\n");
1072         ++num_dev_resets;
1073         if (SCpnt) {
1074                 devip = devInfoReg(SCpnt->device);
1075                 if (devip)
1076                         devip->reset = 1;
1077         }
1078         return SUCCESS;
1079 }
1080
1081 static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
1082 {
1083         struct sdebug_host_info *sdbg_host;
1084         struct sdebug_dev_info * dev_info;
1085         struct scsi_device * sdp;
1086         struct Scsi_Host * hp;
1087
1088         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1089                 printk(KERN_INFO "scsi_debug: bus_reset\n");
1090         ++num_bus_resets;
1091         if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
1092                 sdbg_host = *(struct sdebug_host_info **) hp->hostdata;
1093                 if (sdbg_host) {
1094                         list_for_each_entry(dev_info,
1095                                             &sdbg_host->dev_info_list,
1096                                             dev_list)
1097                                 dev_info->reset = 1;
1098                 }
1099         }
1100         return SUCCESS;
1101 }
1102
1103 static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
1104 {
1105         struct sdebug_host_info * sdbg_host;
1106         struct sdebug_dev_info * dev_info;
1107
1108         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1109                 printk(KERN_INFO "scsi_debug: host_reset\n");
1110         ++num_host_resets;
1111         spin_lock(&sdebug_host_list_lock);
1112         list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
1113                 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
1114                                     dev_list)
1115                         dev_info->reset = 1;
1116         }
1117         spin_unlock(&sdebug_host_list_lock);
1118         stop_all_queued();
1119         return SUCCESS;
1120 }
1121
1122 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
1123 static int stop_queued_cmnd(struct scsi_cmnd * cmnd)
1124 {
1125         unsigned long iflags;
1126         int k;
1127         struct sdebug_queued_cmd * sqcp;
1128
1129         spin_lock_irqsave(&queued_arr_lock, iflags);
1130         for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
1131                 sqcp = &queued_arr[k];
1132                 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
1133                         del_timer_sync(&sqcp->cmnd_timer);
1134                         sqcp->in_use = 0;
1135                         sqcp->a_cmnd = NULL;
1136                         break;
1137                 }
1138         }
1139         spin_unlock_irqrestore(&queued_arr_lock, iflags);
1140         return (k < SCSI_DEBUG_CANQUEUE) ? 1 : 0;
1141 }
1142
1143 /* Deletes (stops) timers of all queued commands */
1144 static void stop_all_queued(void)
1145 {
1146         unsigned long iflags;
1147         int k;
1148         struct sdebug_queued_cmd * sqcp;
1149
1150         spin_lock_irqsave(&queued_arr_lock, iflags);
1151         for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
1152                 sqcp = &queued_arr[k];
1153                 if (sqcp->in_use && sqcp->a_cmnd) {
1154                         del_timer_sync(&sqcp->cmnd_timer);
1155                         sqcp->in_use = 0;
1156                         sqcp->a_cmnd = NULL;
1157                 }
1158         }
1159         spin_unlock_irqrestore(&queued_arr_lock, iflags);
1160 }
1161
1162 /* Initializes timers in queued array */
1163 static void __init init_all_queued(void)
1164 {
1165         unsigned long iflags;
1166         int k;
1167         struct sdebug_queued_cmd * sqcp;
1168
1169         spin_lock_irqsave(&queued_arr_lock, iflags);
1170         for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
1171                 sqcp = &queued_arr[k];
1172                 init_timer(&sqcp->cmnd_timer);
1173                 sqcp->in_use = 0;
1174                 sqcp->a_cmnd = NULL;
1175         }
1176         spin_unlock_irqrestore(&queued_arr_lock, iflags);
1177 }
1178
1179 static void __init sdebug_build_parts(unsigned char * ramp)
1180 {
1181         struct partition * pp;
1182         int starts[SDEBUG_MAX_PARTS + 2];
1183         int sectors_per_part, num_sectors, k;
1184         int heads_by_sects, start_sec, end_sec;
1185
1186         /* assume partition table already zeroed */
1187         if ((scsi_debug_num_parts < 1) || (sdebug_store_size < 1048576))
1188                 return;
1189         if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
1190                 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
1191                 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
1192                                     "partitions to %d\n", SDEBUG_MAX_PARTS);
1193         }
1194         num_sectors = (int)(sdebug_store_size / SECT_SIZE);
1195         sectors_per_part = (num_sectors - sdebug_sectors_per)
1196                            / scsi_debug_num_parts;
1197         heads_by_sects = sdebug_heads * sdebug_sectors_per;
1198         starts[0] = sdebug_sectors_per;
1199         for (k = 1; k < scsi_debug_num_parts; ++k)
1200                 starts[k] = ((k * sectors_per_part) / heads_by_sects)
1201                             * heads_by_sects;
1202         starts[scsi_debug_num_parts] = num_sectors;
1203         starts[scsi_debug_num_parts + 1] = 0;
1204
1205         ramp[510] = 0x55;       /* magic partition markings */
1206         ramp[511] = 0xAA;
1207         pp = (struct partition *)(ramp + 0x1be);
1208         for (k = 0; starts[k + 1]; ++k, ++pp) {
1209                 start_sec = starts[k];
1210                 end_sec = starts[k + 1] - 1;
1211                 pp->boot_ind = 0;
1212
1213                 pp->cyl = start_sec / heads_by_sects;
1214                 pp->head = (start_sec - (pp->cyl * heads_by_sects))
1215                            / sdebug_sectors_per;
1216                 pp->sector = (start_sec % sdebug_sectors_per) + 1;
1217
1218                 pp->end_cyl = end_sec / heads_by_sects;
1219                 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
1220                                / sdebug_sectors_per;
1221                 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
1222
1223                 pp->start_sect = start_sec;
1224                 pp->nr_sects = end_sec - start_sec + 1;
1225                 pp->sys_ind = 0x83;     /* plain Linux partition */
1226         }
1227 }
1228
1229 static int schedule_resp(struct scsi_cmnd * cmnd,
1230                          struct sdebug_dev_info * devip,
1231                          done_funct_t done, int scsi_result, int delta_jiff)
1232 {
1233         int k, num;
1234
1235         if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
1236                 printk(KERN_INFO "scsi_debug: cmd ");
1237                 for (k = 0, num = cmnd->cmd_len; k < num; ++k)
1238                         printk("%02x ", (int)cmnd->cmnd[k]);
1239                 printk("\n");
1240                 if (scsi_result) {
1241                         struct scsi_device * sdp = cmnd->device;
1242
1243                         printk(KERN_INFO "scsi_debug: ... <%u %u %u %u> "
1244                                "non-zero result=0x%x\n", sdp->host->host_no,
1245                                sdp->channel, sdp->id, sdp->lun, scsi_result);
1246                 }
1247         }
1248         if (cmnd && devip) {
1249                 /* simulate autosense by this driver */
1250                 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
1251                         memcpy(cmnd->sense_buffer, devip->sense_buff,
1252                                (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
1253                                SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
1254         }
1255         if (delta_jiff <= 0) {
1256                 if (cmnd)
1257                         cmnd->result = scsi_result;
1258                 if (done)
1259                         done(cmnd);
1260                 return 0;
1261         } else {
1262                 unsigned long iflags;
1263                 int k;
1264                 struct sdebug_queued_cmd * sqcp = NULL;
1265
1266                 spin_lock_irqsave(&queued_arr_lock, iflags);
1267                 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
1268                         sqcp = &queued_arr[k];
1269                         if (! sqcp->in_use)
1270                                 break;
1271                 }
1272                 if (k >= SCSI_DEBUG_CANQUEUE) {
1273                         spin_unlock_irqrestore(&queued_arr_lock, iflags);
1274                         printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
1275                         return 1;       /* report busy to mid level */
1276                 }
1277                 sqcp->in_use = 1;
1278                 sqcp->a_cmnd = cmnd;
1279                 sqcp->scsi_result = scsi_result;
1280                 sqcp->done_funct = done;
1281                 sqcp->cmnd_timer.function = timer_intr_handler;
1282                 sqcp->cmnd_timer.data = k;
1283                 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
1284                 add_timer(&sqcp->cmnd_timer);
1285                 spin_unlock_irqrestore(&queued_arr_lock, iflags);
1286                 if (cmnd)
1287                         cmnd->result = 0;
1288                 return 0;
1289         }
1290 }
1291
1292 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
1293  * of sysfs parameters (which module_param doesn't yet support).
1294  * Sysfs parameters defined explicitly below.
1295  */
1296 module_param_named(add_host, scsi_debug_add_host, int, 0); /* perm=0644 */
1297 module_param_named(delay, scsi_debug_delay, int, 0); /* perm=0644 */
1298 module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, 0);
1299 module_param_named(every_nth, scsi_debug_every_nth, int, 0);
1300 module_param_named(max_luns, scsi_debug_max_luns, int, 0);
1301 module_param_named(num_parts, scsi_debug_num_parts, int, 0);
1302 module_param_named(num_tgts, scsi_debug_num_tgts, int, 0);
1303 module_param_named(opts, scsi_debug_opts, int, 0); /* perm=0644 */
1304 module_param_named(ptype, scsi_debug_ptype, int, 0);
1305 module_param_named(scsi_level, scsi_debug_scsi_level, int, 0);
1306
1307 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
1308 MODULE_DESCRIPTION("SCSI debug adapter driver");
1309 MODULE_LICENSE("GPL");
1310 MODULE_VERSION(SCSI_DEBUG_VERSION);
1311
1312 MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
1313 MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
1314 MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs");
1315 MODULE_PARM_DESC(every_nth, "timeout every nth command(def=100)");
1316 MODULE_PARM_DESC(max_luns, "number of SCSI LUNs per target to simulate");
1317 MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
1318 MODULE_PARM_DESC(num_tgts, "number of SCSI targets per host to simulate");
1319 MODULE_PARM_DESC(opts, "1->noise, 2->medium_error, 4->...");
1320 MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
1321 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate");
1322
1323
1324 static char sdebug_info[256];
1325
1326 static const char * scsi_debug_info(struct Scsi_Host * shp)
1327 {
1328         sprintf(sdebug_info, "scsi_debug, version %s [%s], "
1329                 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
1330                 scsi_debug_version_date, scsi_debug_dev_size_mb,
1331                 scsi_debug_opts);
1332         return sdebug_info;
1333 }
1334
1335 /* scsi_debug_proc_info
1336  * Used if the driver currently has no own support for /proc/scsi
1337  */
1338 static int scsi_debug_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
1339                                 int length, int inout)
1340 {
1341         int len, pos, begin;
1342         int orig_length;
1343
1344         orig_length = length;
1345
1346         if (inout == 1) {
1347                 char arr[16];
1348                 int minLen = length > 15 ? 15 : length;
1349
1350                 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
1351                         return -EACCES;
1352                 memcpy(arr, buffer, minLen);
1353                 arr[minLen] = '\0';
1354                 if (1 != sscanf(arr, "%d", &pos))
1355                         return -EINVAL;
1356                 scsi_debug_opts = pos;
1357                 if (scsi_debug_every_nth > 0)
1358                         scsi_debug_cmnd_count = 0;
1359                 return length;
1360         }
1361         begin = 0;
1362         pos = len = sprintf(buffer, "scsi_debug adapter driver, version "
1363             "%s [%s]\n"
1364             "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
1365             "every_nth=%d(curr:%d)\n"
1366             "delay=%d, max_luns=%d, scsi_level=%d\n"
1367             "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
1368             "number of aborts=%d, device_reset=%d, bus_resets=%d, "
1369             "host_resets=%d\n",
1370             SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
1371             scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
1372             scsi_debug_cmnd_count, scsi_debug_delay,
1373             scsi_debug_max_luns, scsi_debug_scsi_level,
1374             SECT_SIZE, sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
1375             num_aborts, num_dev_resets, num_bus_resets, num_host_resets);
1376         if (pos < offset) {
1377                 len = 0;
1378                 begin = pos;
1379         }
1380         *start = buffer + (offset - begin);     /* Start of wanted data */
1381         len -= (offset - begin);
1382         if (len > length)
1383                 len = length;
1384         return len;
1385 }
1386
1387 static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf)
1388 {
1389         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
1390 }
1391
1392 static ssize_t sdebug_delay_store(struct device_driver * ddp,
1393                                   const char * buf, size_t count)
1394 {
1395         int delay;
1396         char work[20];
1397
1398         if (1 == sscanf(buf, "%10s", work)) {
1399                 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
1400                         scsi_debug_delay = delay;
1401                         return count;
1402                 }
1403         }
1404         return -EINVAL;
1405 }
1406 DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show,
1407             sdebug_delay_store);
1408
1409 static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf)
1410 {
1411         return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
1412 }
1413
1414 static ssize_t sdebug_opts_store(struct device_driver * ddp,
1415                                  const char * buf, size_t count)
1416 {
1417         int opts;
1418         char work[20];
1419
1420         if (1 == sscanf(buf, "%10s", work)) {
1421                 if (0 == strnicmp(work,"0x", 2)) {
1422                         if (1 == sscanf(&work[2], "%x", &opts))
1423                                 goto opts_done;
1424                 } else {
1425                         if (1 == sscanf(work, "%d", &opts))
1426                                 goto opts_done;
1427                 }
1428         }
1429         return -EINVAL;
1430 opts_done:
1431         scsi_debug_opts = opts;
1432         scsi_debug_cmnd_count = 0;
1433         return count;
1434 }
1435 DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show,
1436             sdebug_opts_store);
1437
1438 static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf)
1439 {
1440         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
1441 }
1442 static ssize_t sdebug_ptype_store(struct device_driver * ddp,
1443                                   const char * buf, size_t count)
1444 {
1445         int n;
1446
1447         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
1448                 scsi_debug_ptype = n;
1449                 return count;
1450         }
1451         return -EINVAL;
1452 }
1453 DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store);
1454
1455 static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf)
1456 {
1457         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
1458 }
1459 static ssize_t sdebug_num_tgts_store(struct device_driver * ddp,
1460                                      const char * buf, size_t count)
1461 {
1462         int n;
1463
1464         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
1465                 scsi_debug_num_tgts = n;
1466                 sdebug_max_tgts_luns();
1467                 return count;
1468         }
1469         return -EINVAL;
1470 }
1471 DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show,
1472             sdebug_num_tgts_store);
1473
1474 static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf)
1475 {
1476         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
1477 }
1478 DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL);
1479
1480 static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf)
1481 {
1482         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
1483 }
1484 DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL);
1485
1486 static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf)
1487 {
1488         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
1489 }
1490 static ssize_t sdebug_every_nth_store(struct device_driver * ddp,
1491                                       const char * buf, size_t count)
1492 {
1493         int nth;
1494
1495         if ((count > 0) && (1 == sscanf(buf, "%d", &nth)) && (nth >= 0)) {
1496                 scsi_debug_every_nth = nth;
1497                 scsi_debug_cmnd_count = 0;
1498                 return count;
1499         }
1500         return -EINVAL;
1501 }
1502 DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show,
1503             sdebug_every_nth_store);
1504
1505 static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf)
1506 {
1507         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
1508 }
1509 static ssize_t sdebug_max_luns_store(struct device_driver * ddp,
1510                                      const char * buf, size_t count)
1511 {
1512         int n;
1513
1514         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
1515                 scsi_debug_max_luns = n;
1516                 sdebug_max_tgts_luns();
1517                 return count;
1518         }
1519         return -EINVAL;
1520 }
1521 DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show,
1522             sdebug_max_luns_store);
1523
1524 static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf)
1525 {
1526         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
1527 }
1528 DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL);
1529
1530 static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf)
1531 {
1532         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
1533 }
1534
1535 static ssize_t sdebug_add_host_store(struct device_driver * ddp,
1536                                      const char * buf, size_t count)
1537 {
1538         int delta_hosts;
1539         char work[20];
1540
1541         if (1 != sscanf(buf, "%10s", work))
1542                 return -EINVAL;
1543         {       /* temporary hack around sscanf() problem with -ve nums */
1544                 int neg = 0;
1545
1546                 if ('-' == *work)
1547                         neg = 1;
1548                 if (1 != sscanf(work + neg, "%d", &delta_hosts))
1549                         return -EINVAL;
1550                 if (neg)
1551                         delta_hosts = -delta_hosts;
1552         }
1553         if (delta_hosts > 0) {
1554                 do {
1555                         sdebug_add_adapter();
1556                 } while (--delta_hosts);
1557         } else if (delta_hosts < 0) {
1558                 do {
1559                         sdebug_remove_adapter();
1560                 } while (++delta_hosts);
1561         }
1562         return count;
1563 }
1564 DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show,
1565             sdebug_add_host_store);
1566
1567 static void do_create_driverfs_files(void)
1568 {
1569         driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host);
1570         driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay);
1571         driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
1572         driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
1573         driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
1574         driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
1575         driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
1576         driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype);
1577         driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts);
1578         driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
1579 }
1580
1581 static void do_remove_driverfs_files(void)
1582 {
1583         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
1584         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts);
1585         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype);
1586         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
1587         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
1588         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
1589         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
1590         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
1591         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay);
1592         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host);
1593 }
1594
1595 static int __init scsi_debug_init(void)
1596 {
1597         unsigned long sz;
1598         int host_to_add;
1599         int k;
1600
1601         if (scsi_debug_dev_size_mb < 1)
1602                 scsi_debug_dev_size_mb = 1;  /* force minimum 1 MB ramdisk */
1603         sdebug_store_size = (unsigned long)scsi_debug_dev_size_mb * 1048576;
1604         sdebug_capacity = sdebug_store_size / SECT_SIZE;
1605
1606         /* play around with geometry, don't waste too much on track 0 */
1607         sdebug_heads = 8;
1608         sdebug_sectors_per = 32;
1609         if (scsi_debug_dev_size_mb >= 16)
1610                 sdebug_heads = 32;
1611         else if (scsi_debug_dev_size_mb >= 256)
1612                 sdebug_heads = 64;
1613         sdebug_cylinders_per = (unsigned long)sdebug_capacity /
1614                                (sdebug_sectors_per * sdebug_heads);
1615         if (sdebug_cylinders_per >= 1024) {
1616                 /* other LLDs do this; implies >= 1GB ram disk ... */
1617                 sdebug_heads = 255;
1618                 sdebug_sectors_per = 63;
1619                 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
1620                                (sdebug_sectors_per * sdebug_heads);
1621         }
1622
1623         sz = sdebug_store_size;
1624         fake_storep = vmalloc(sz);
1625         if (NULL == fake_storep) {
1626                 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
1627                 return -ENOMEM;
1628         }
1629         memset(fake_storep, 0, sz);
1630         if (scsi_debug_num_parts > 0)
1631                 sdebug_build_parts(fake_storep);
1632
1633         init_all_queued();
1634
1635         device_register(&pseudo_primary);
1636         bus_register(&pseudo_lld_bus);
1637         driver_register(&sdebug_driverfs_driver);
1638         do_create_driverfs_files();
1639
1640         sdebug_driver_template.proc_name = (char *)sdebug_proc_name;
1641
1642         host_to_add = scsi_debug_add_host;
1643         scsi_debug_add_host = 0;
1644
1645         for (k = 0; k < host_to_add; k++) {
1646                 if (sdebug_add_adapter()) {
1647                         printk(KERN_ERR "scsi_debug_init: "
1648                                "sdebug_add_adapter failed k=%d\n", k);
1649                         break;
1650                 }
1651         }
1652
1653         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
1654                 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
1655                        scsi_debug_add_host);
1656         }
1657         return 0;
1658 }
1659
1660 static void __exit scsi_debug_exit(void)
1661 {
1662         int k = scsi_debug_add_host;
1663
1664         stop_all_queued();
1665         for (; k; k--)
1666                 sdebug_remove_adapter();
1667         do_remove_driverfs_files();
1668         driver_unregister(&sdebug_driverfs_driver);
1669         bus_unregister(&pseudo_lld_bus);
1670         device_unregister(&pseudo_primary);
1671
1672         vfree(fake_storep);
1673 }
1674
1675 device_initcall(scsi_debug_init);
1676 module_exit(scsi_debug_exit);
1677
1678 void pseudo_0_release(struct device * dev)
1679 {
1680         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
1681                 printk(KERN_INFO "scsi_debug: pseudo_0_release() called\n");
1682 }
1683
1684 static struct device pseudo_primary = {
1685         .bus_id         = "pseudo_0",
1686         .release        = pseudo_0_release,
1687 };
1688
1689 static int pseudo_lld_bus_match(struct device *dev,
1690                           struct device_driver *dev_driver)
1691 {
1692         return 1;
1693 }
1694
1695 static struct bus_type pseudo_lld_bus = {
1696         .name = "pseudo",
1697         .match = pseudo_lld_bus_match,
1698 };
1699
1700 static void sdebug_release_adapter(struct device * dev)
1701 {
1702         struct sdebug_host_info *sdbg_host;
1703
1704         sdbg_host = to_sdebug_host(dev);
1705         kfree(sdbg_host);
1706 }
1707
1708 static int sdebug_add_adapter(void)
1709 {
1710         int k, devs_per_host;
1711         int error = 0;
1712         struct sdebug_host_info *sdbg_host;
1713         struct sdebug_dev_info *sdbg_devinfo;
1714         struct list_head *lh, *lh_sf;
1715
1716         sdbg_host = kmalloc(sizeof(*sdbg_host),GFP_KERNEL);
1717
1718         if (NULL == sdbg_host) {
1719                 printk(KERN_ERR "%s: out of memory at line %d\n",
1720                        __FUNCTION__, __LINE__);
1721                 return -ENOMEM;
1722         }
1723
1724         memset(sdbg_host, 0, sizeof(*sdbg_host));
1725         INIT_LIST_HEAD(&sdbg_host->dev_info_list);
1726
1727         devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
1728         for (k = 0; k < devs_per_host; k++) {
1729                 sdbg_devinfo = kmalloc(sizeof(*sdbg_devinfo),GFP_KERNEL);
1730                 if (NULL == sdbg_devinfo) {
1731                         printk(KERN_ERR "%s: out of memory at line %d\n",
1732                                __FUNCTION__, __LINE__);
1733                         error = -ENOMEM;
1734                         goto clean;
1735                 }
1736                 memset(sdbg_devinfo, 0, sizeof(*sdbg_devinfo));
1737                 sdbg_devinfo->sdbg_host = sdbg_host;
1738                 list_add_tail(&sdbg_devinfo->dev_list,
1739                               &sdbg_host->dev_info_list);
1740         }
1741
1742         spin_lock(&sdebug_host_list_lock);
1743         list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
1744         spin_unlock(&sdebug_host_list_lock);
1745
1746         sdbg_host->dev.bus = &pseudo_lld_bus;
1747         sdbg_host->dev.parent = &pseudo_primary;
1748         sdbg_host->dev.release = &sdebug_release_adapter;
1749         sprintf(sdbg_host->dev.bus_id, "adapter%d", scsi_debug_add_host);
1750
1751         error = device_register(&sdbg_host->dev);
1752
1753         if (error)
1754                 goto clean;
1755
1756         ++scsi_debug_add_host;
1757         return error;
1758
1759 clean:
1760         list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
1761                 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
1762                                           dev_list);
1763                 list_del(&sdbg_devinfo->dev_list);
1764                 kfree(sdbg_devinfo);
1765         }
1766
1767         kfree(sdbg_host);
1768         return error;
1769 }
1770
1771 static void sdebug_remove_adapter(void)
1772 {
1773         struct sdebug_host_info * sdbg_host = NULL;
1774
1775         spin_lock(&sdebug_host_list_lock);
1776         if (!list_empty(&sdebug_host_list)) {
1777                 sdbg_host = list_entry(sdebug_host_list.prev,
1778                                        struct sdebug_host_info, host_list);
1779                 list_del(&sdbg_host->host_list);
1780         }
1781         spin_unlock(&sdebug_host_list_lock);
1782
1783         if (!sdbg_host)
1784                 return;
1785
1786         device_unregister(&sdbg_host->dev);
1787         --scsi_debug_add_host;
1788 }
1789
1790 static int sdebug_driver_probe(struct device * dev)
1791 {
1792         int error = 0;
1793         struct sdebug_host_info *sdbg_host;
1794         struct Scsi_Host *hpnt;
1795
1796         sdbg_host = to_sdebug_host(dev);
1797
1798         hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
1799         if (NULL == hpnt) {
1800                 printk(KERN_ERR "%s: scsi_register failed\n", __FUNCTION__);
1801                 error = -ENODEV;
1802                 return error;
1803         }
1804
1805         sdbg_host->shost = hpnt;
1806         *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
1807         if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
1808                 hpnt->max_id = scsi_debug_num_tgts + 1;
1809         else
1810                 hpnt->max_id = scsi_debug_num_tgts;
1811         hpnt->max_lun = scsi_debug_max_luns;
1812
1813         error = scsi_add_host(hpnt, &sdbg_host->dev);
1814         if (error) {
1815                 printk(KERN_ERR "%s: scsi_add_host failed\n", __FUNCTION__);
1816                 error = -ENODEV;
1817                 scsi_host_put(hpnt);
1818         } else
1819                 scsi_scan_host(hpnt);
1820
1821
1822         return error;
1823 }
1824
1825 static int sdebug_driver_remove(struct device * dev)
1826 {
1827         struct list_head *lh, *lh_sf;
1828         struct sdebug_host_info *sdbg_host;
1829         struct sdebug_dev_info *sdbg_devinfo;
1830
1831         sdbg_host = to_sdebug_host(dev);
1832
1833         if (!sdbg_host) {
1834                 printk(KERN_ERR "%s: Unable to locate host info\n",
1835                        __FUNCTION__);
1836                 return -ENODEV;
1837         }
1838
1839         scsi_remove_host(sdbg_host->shost);
1840
1841         list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
1842                 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
1843                                           dev_list);
1844                 list_del(&sdbg_devinfo->dev_list);
1845                 kfree(sdbg_devinfo);
1846         }
1847
1848         scsi_host_put(sdbg_host->shost);
1849         return 0;
1850 }
1851
1852 static void sdebug_max_tgts_luns(void)
1853 {
1854         struct sdebug_host_info * sdbg_host;
1855         struct Scsi_Host *hpnt;
1856
1857         spin_lock(&sdebug_host_list_lock);
1858         list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
1859                 hpnt = sdbg_host->shost;
1860                 if ((hpnt->this_id >= 0) &&
1861                     (scsi_debug_num_tgts > hpnt->this_id))
1862                         hpnt->max_id = scsi_debug_num_tgts + 1;
1863                 else
1864                         hpnt->max_id = scsi_debug_num_tgts;
1865                 hpnt->max_lun = scsi_debug_max_luns;
1866         }
1867         spin_unlock(&sdebug_host_list_lock);
1868 }