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 resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
 284                             unsigned int num, struct sdebug_dev_info *devip);
 285 static int fill_from_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
 286                                 int arr_len);
 287 static int fetch_to_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
 288                                int max_arr_len);
 289 static void timer_intr_handler(unsigned long);
 290 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev);
 291 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
 292                             int asc, int asq);
 293 static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
 294                            struct sdebug_dev_info * devip);
 295 static int schedule_resp(struct scsi_cmnd * cmnd,
 296                          struct sdebug_dev_info * devip,
 297                          done_funct_t done, int scsi_result, int delta_jiff);
 298 static void __init sdebug_build_parts(unsigned char * ramp);
 299 static void __init init_all_queued(void);
 300 static void stop_all_queued(void);
 301 static int stop_queued_cmnd(struct scsi_cmnd * cmnd);
 302 static int inquiry_evpd_83(unsigned char * arr, int port_group_id,
 303                            int target_dev_id, int dev_id_num,
 304                            const char * dev_id_str, int dev_id_str_len);
 305 static int inquiry_evpd_88(unsigned char * arr, int target_dev_id);
 306 static int do_create_driverfs_files(void);
 307 static void do_remove_driverfs_files(void);
 308
 309 static int sdebug_add_adapter(void);
 310 static void sdebug_remove_adapter(void);
 311 static void sdebug_max_tgts_luns(void);
 312
 313 static struct device pseudo_primary;
 314 static struct bus_type pseudo_lld_bus;
 315
 316 static void get_data_transfer_info(unsigned char *cmd,
 317                                    unsigned long long *lba, unsigned int *num)
 318 {
 319         int i;
 320
 321         switch (*cmd) {
 322         case WRITE_16:
 323         case READ_16:
 324                 for (*lba = 0, i = 0; i < 8; ++i) {
 325                         if (i > 0)
 326                                 *lba <<= 8;
 327                         *lba += cmd[2 + i];
 328                 }
 329                 *num = cmd[13] + (cmd[12] << 8) +
 330                         (cmd[11] << 16) + (cmd[10] << 24);
 331                 break;
 332         case WRITE_12:
 333         case READ_12:
 334                 *lba = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24);
 335                 *num = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
 336                 break;
 337         case WRITE_10:
 338         case READ_10:
 339         case XDWRITEREAD_10:
 340                 *lba = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24);
 341                 *num = cmd[8] + (cmd[7] << 8);
 342                 break;
 343         case WRITE_6:
 344         case READ_6:
 345                 *lba = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
 346                 *num = (0 == cmd[4]) ? 256 : cmd[4];
 347                 break;
 348         default:
 349                 break;
 350         }
 351 }
 352
 353 static
 354 int scsi_debug_queuecommand(struct scsi_cmnd * SCpnt, done_funct_t done)
 355 {
 356         unsigned char *cmd = (unsigned char *) SCpnt->cmnd;
 357         int len, k;
 358         unsigned int num;
 359         unsigned long long lba;
 360         int errsts = 0;
 361         int target = SCpnt->device->id;
 362         struct sdebug_dev_info * devip = NULL;
 363         int inj_recovered = 0;
 364         int inj_transport = 0;
 365         int delay_override = 0;
 366
 367         if (done == NULL)
 368                 return 0;       /* assume mid level reprocessing command */
 369
 370         scsi_set_resid(SCpnt, 0);
 371         if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) {
 372                 printk(KERN_INFO "scsi_debug: cmd ");
 373                 for (k = 0, len = SCpnt->cmd_len; k < len; ++k)
 374                         printk("%02x ", (int)cmd[k]);
 375                 printk("\n");
 376         }
 377         if(target == sdebug_driver_template.this_id) {
 378                 printk(KERN_INFO "scsi_debug: initiator's id used as "
 379                        "target!\n");
 380                 return schedule_resp(SCpnt, NULL, done,
 381                                      DID_NO_CONNECT << 16, 0);
 382         }
 383
 384         if ((SCpnt->device->lun >= scsi_debug_max_luns) &&
 385             (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS))
 386                 return schedule_resp(SCpnt, NULL, done,
 387                                      DID_NO_CONNECT << 16, 0);
 388         devip = devInfoReg(SCpnt->device);
 389         if (NULL == devip)
 390                 return schedule_resp(SCpnt, NULL, done,
 391                                      DID_NO_CONNECT << 16, 0);
 392
 393         if ((scsi_debug_every_nth != 0) &&
 394             (++scsi_debug_cmnd_count >= abs(scsi_debug_every_nth))) {
 395                 scsi_debug_cmnd_count = 0;
 396                 if (scsi_debug_every_nth < -1)
 397                         scsi_debug_every_nth = -1;
 398                 if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts)
 399                         return 0; /* ignore command causing timeout */
 400                 else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts)
 401                         inj_recovered = 1; /* to reads and writes below */
 402                 else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts)
 403                         inj_transport = 1; /* to reads and writes below */
 404         }
 405
 406         if (devip->wlun) {
 407                 switch (*cmd) {
 408                 case INQUIRY:
 409                 case REQUEST_SENSE:
 410                 case TEST_UNIT_READY:
 411                 case REPORT_LUNS:
 412                         break;  /* only allowable wlun commands */
 413                 default:
 414                         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
 415                                 printk(KERN_INFO "scsi_debug: Opcode: 0x%x "
 416                                        "not supported for wlun\n", *cmd);
 417                         mk_sense_buffer(devip, ILLEGAL_REQUEST,
 418                                         INVALID_OPCODE, 0);
 419                         errsts = check_condition_result;
 420                         return schedule_resp(SCpnt, devip, done, errsts,
 421                                              0);
 422                 }
 423         }
 424
 425         switch (*cmd) {
 426         case INQUIRY:     /* mandatory, ignore unit attention */
 427                 delay_override = 1;
 428                 errsts = resp_inquiry(SCpnt, target, devip);
 429                 break;
 430         case REQUEST_SENSE:     /* mandatory, ignore unit attention */
 431                 delay_override = 1;
 432                 errsts = resp_requests(SCpnt, devip);
 433                 break;
 434         case REZERO_UNIT:       /* actually this is REWIND for SSC */
 435         case START_STOP:
 436                 errsts = resp_start_stop(SCpnt, devip);
 437                 break;
 438         case ALLOW_MEDIUM_REMOVAL:
 439                 if ((errsts = check_readiness(SCpnt, 1, devip)))
 440                         break;
 441                 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
 442                         printk(KERN_INFO "scsi_debug: Medium removal %s\n",
 443                                 cmd[4] ? "inhibited" : "enabled");
 444                 break;
 445         case SEND_DIAGNOSTIC:     /* mandatory */
 446                 errsts = check_readiness(SCpnt, 1, devip);
 447                 break;
 448         case TEST_UNIT_READY:     /* mandatory */
 449                 delay_override = 1;
 450                 errsts = check_readiness(SCpnt, 0, devip);
 451                 break;
 452         case RESERVE:
 453                 errsts = check_readiness(SCpnt, 1, devip);
 454                 break;
 455         case RESERVE_10:
 456                 errsts = check_readiness(SCpnt, 1, devip);
 457                 break;
 458         case RELEASE:
 459                 errsts = check_readiness(SCpnt, 1, devip);
 460                 break;
 461         case RELEASE_10:
 462                 errsts = check_readiness(SCpnt, 1, devip);
 463                 break;
 464         case READ_CAPACITY:
 465                 errsts = resp_readcap(SCpnt, devip);
 466                 break;
 467         case SERVICE_ACTION_IN:
 468                 if (SAI_READ_CAPACITY_16 != cmd[1]) {
 469                         mk_sense_buffer(devip, ILLEGAL_REQUEST,
 470                                         INVALID_OPCODE, 0);
 471                         errsts = check_condition_result;
 472                         break;
 473                 }
 474                 errsts = resp_readcap16(SCpnt, devip);
 475                 break;
 476         case MAINTENANCE_IN:
 477                 if (MI_REPORT_TARGET_PGS != cmd[1]) {
 478                         mk_sense_buffer(devip, ILLEGAL_REQUEST,
 479                                         INVALID_OPCODE, 0);
 480                         errsts = check_condition_result;
 481                         break;
 482                 }
 483                 errsts = resp_report_tgtpgs(SCpnt, devip);
 484                 break;
 485         case READ_16:
 486         case READ_12:
 487         case READ_10:
 488         case READ_6:
 489                 if ((errsts = check_readiness(SCpnt, 0, devip)))
 490                         break;
 491                 if (scsi_debug_fake_rw)
 492                         break;
 493                 get_data_transfer_info(cmd, &lba, &num);
 494                 errsts = resp_read(SCpnt, lba, num, devip);
 495                 if (inj_recovered && (0 == errsts)) {
 496                         mk_sense_buffer(devip, RECOVERED_ERROR,
 497                                         THRESHOLD_EXCEEDED, 0);
 498                         errsts = check_condition_result;
 499                 } else if (inj_transport && (0 == errsts)) {
 500                         mk_sense_buffer(devip, ABORTED_COMMAND,
 501                                         TRANSPORT_PROBLEM, ACK_NAK_TO);
 502                         errsts = check_condition_result;
 503                 }
 504                 break;
 505         case REPORT_LUNS:       /* mandatory, ignore unit attention */
 506                 delay_override = 1;
 507                 errsts = resp_report_luns(SCpnt, devip);
 508                 break;
 509         case VERIFY:            /* 10 byte SBC-2 command */
 510                 errsts = check_readiness(SCpnt, 0, devip);
 511                 break;
 512         case WRITE_16:
 513         case WRITE_12:
 514         case WRITE_10:
 515         case WRITE_6:
 516                 if ((errsts = check_readiness(SCpnt, 0, devip)))
 517                         break;
 518                 if (scsi_debug_fake_rw)
 519                         break;
 520                 get_data_transfer_info(cmd, &lba, &num);
 521                 errsts = resp_write(SCpnt, lba, num, devip);
 522                 if (inj_recovered && (0 == errsts)) {
 523                         mk_sense_buffer(devip, RECOVERED_ERROR,
 524                                         THRESHOLD_EXCEEDED, 0);
 525                         errsts = check_condition_result;
 526                 }
 527                 break;
 528         case MODE_SENSE:
 529         case MODE_SENSE_10:
 530                 errsts = resp_mode_sense(SCpnt, target, devip);
 531                 break;
 532         case MODE_SELECT:
 533                 errsts = resp_mode_select(SCpnt, 1, devip);
 534                 break;
 535         case MODE_SELECT_10:
 536                 errsts = resp_mode_select(SCpnt, 0, devip);
 537                 break;
 538         case LOG_SENSE:
 539                 errsts = resp_log_sense(SCpnt, devip);
 540                 break;
 541         case SYNCHRONIZE_CACHE:
 542                 delay_override = 1;
 543                 errsts = check_readiness(SCpnt, 0, devip);
 544                 break;
 545         case WRITE_BUFFER:
 546                 errsts = check_readiness(SCpnt, 1, devip);
 547                 break;
 548         case XDWRITEREAD_10:
 549                 if (!scsi_bidi_cmnd(SCpnt)) {
 550                         mk_sense_buffer(devip, ILLEGAL_REQUEST,
 551                                         INVALID_FIELD_IN_CDB, 0);
 552                         errsts = check_condition_result;
 553                         break;
 554                 }
 555
 556                 errsts = check_readiness(SCpnt, 0, devip);
 557                 if (errsts)
 558                         break;
 559                 if (scsi_debug_fake_rw)
 560                         break;
 561                 get_data_transfer_info(cmd, &lba, &num);
 562                 errsts = resp_read(SCpnt, lba, num, devip);
 563                 if (errsts)
 564                         break;
 565                 errsts = resp_write(SCpnt, lba, num, devip);
 566                 if (errsts)
 567                         break;
 568                 errsts = resp_xdwriteread(SCpnt, lba, num, devip);
 569                 break;
 570         default:
 571                 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
 572                         printk(KERN_INFO "scsi_debug: Opcode: 0x%x not "
 573                                "supported\n", *cmd);
 574                 if ((errsts = check_readiness(SCpnt, 1, devip)))
 575                         break;  /* Unit attention takes precedence */
 576                 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
 577                 errsts = check_condition_result;
 578                 break;
 579         }
 580         return schedule_resp(SCpnt, devip, done, errsts,
 581                              (delay_override ? 0 : scsi_debug_delay));
 582 }
 583
 584 static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
 585 {
 586         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
 587                 printk(KERN_INFO "scsi_debug: ioctl: cmd=0x%x\n", cmd);
 588         }
 589         return -EINVAL;
 590         /* return -ENOTTY; // correct return but upsets fdisk */
 591 }
 592
 593 static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only,
 594                            struct sdebug_dev_info * devip)
 595 {
 596         if (devip->reset) {
 597                 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
 598                         printk(KERN_INFO "scsi_debug: Reporting Unit "
 599                                "attention: power on reset\n");
 600                 devip->reset = 0;
 601                 mk_sense_buffer(devip, UNIT_ATTENTION, POWERON_RESET, 0);
 602                 return check_condition_result;
 603         }
 604         if ((0 == reset_only) && devip->stopped) {
 605                 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
 606                         printk(KERN_INFO "scsi_debug: Reporting Not "
 607                                "ready: initializing command required\n");
 608                 mk_sense_buffer(devip, NOT_READY, LOGICAL_UNIT_NOT_READY,
 609                                 0x2);
 610                 return check_condition_result;
 611         }
 612         return 0;
 613 }
 614
 615 /* Returns 0 if ok else (DID_ERROR << 16). Sets scp->resid . */
 616 static int fill_from_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
 617                                 int arr_len)
 618 {
 619         int k, req_len, act_len, len, active;
 620         void * kaddr;
 621         void * kaddr_off;
 622         struct scatterlist *sg;
 623         struct scsi_data_buffer *sdb = scsi_in(scp);
 624
 625         if (!sdb->length)
 626                 return 0;
 627         if (!sdb->table.sgl)
 628                 return (DID_ERROR << 16);
 629         if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE))
 630                 return (DID_ERROR << 16);
 631         active = 1;
 632         req_len = act_len = 0;
 633         for_each_sg(sdb->table.sgl, sg, sdb->table.nents, k) {
 634                 if (active) {
 635                         kaddr = (unsigned char *)
 636                                 kmap_atomic(sg_page(sg), KM_USER0);
 637                         if (NULL == kaddr)
 638                                 return (DID_ERROR << 16);
 639                         kaddr_off = (unsigned char *)kaddr + sg->offset;
 640                         len = sg->length;
 641                         if ((req_len + len) > arr_len) {
 642                                 active = 0;
 643                                 len = arr_len - req_len;
 644                         }
 645                         memcpy(kaddr_off, arr + req_len, len);
 646                         kunmap_atomic(kaddr, KM_USER0);
 647                         act_len += len;
 648                 }
 649                 req_len += sg->length;
 650         }
 651         if (sdb->resid)
 652                 sdb->resid -= act_len;
 653         else
 654                 sdb->resid = req_len - act_len;
 655         return 0;
 656 }
 657
 658 /* Returns number of bytes fetched into 'arr' or -1 if error. */
 659 static int fetch_to_dev_buffer(struct scsi_cmnd * scp, unsigned char * arr,
 660                                int max_arr_len)
 661 {
 662         int k, req_len, len, fin;
 663         void * kaddr;
 664         void * kaddr_off;
 665         struct scatterlist * sg;
 666
 667         if (0 == scsi_bufflen(scp))
 668                 return 0;
 669         if (NULL == scsi_sglist(scp))
 670                 return -1;
 671         if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_TO_DEVICE))
 672                 return -1;
 673         req_len = fin = 0;
 674         scsi_for_each_sg(scp, sg, scsi_sg_count(scp), k) {
 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 static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba,
1977                             unsigned int num, struct sdebug_dev_info *devip)
1978 {
1979         int i, j, ret = -1;
1980         unsigned char *kaddr, *buf;
1981         unsigned int offset;
1982         struct scatterlist *sg;
1983         struct scsi_data_buffer *sdb = scsi_in(scp);
1984
1985         /* better not to use temporary buffer. */
1986         buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC);
1987         if (!buf)
1988                 return ret;
1989
1990         offset = 0;
1991         scsi_for_each_sg(scp, sg, scsi_sg_count(scp), i) {
1992                 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
1993                 if (!kaddr)
1994                         goto out;
1995
1996                 memcpy(buf + offset, kaddr + sg->offset, sg->length);
1997                 offset += sg->length;
1998                 kunmap_atomic(kaddr, KM_USER0);
1999         }
2000
2001         offset = 0;
2002         for_each_sg(sdb->table.sgl, sg, sdb->table.nents, i) {
2003                 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0);
2004                 if (!kaddr)
2005                         goto out;
2006
2007                 for (j = 0; j < sg->length; j++)
2008                         *(kaddr + sg->offset + j) ^= *(buf + offset + j);
2009
2010                 offset += sg->length;
2011                 kunmap_atomic(kaddr, KM_USER0);
2012         }
2013         ret = 0;
2014 out:
2015         kfree(buf);
2016
2017         return ret;
2018 }
2019
2020 /* When timer goes off this function is called. */
2021 static void timer_intr_handler(unsigned long indx)
2022 {
2023         struct sdebug_queued_cmd * sqcp;
2024         unsigned long iflags;
2025
2026         if (indx >= SCSI_DEBUG_CANQUEUE) {
2027                 printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too "
2028                        "large\n");
2029                 return;
2030         }
2031         spin_lock_irqsave(&queued_arr_lock, iflags);
2032         sqcp = &queued_arr[(int)indx];
2033         if (! sqcp->in_use) {
2034                 printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected "
2035                        "interrupt\n");
2036                 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2037                 return;
2038         }
2039         sqcp->in_use = 0;
2040         if (sqcp->done_funct) {
2041                 sqcp->a_cmnd->result = sqcp->scsi_result;
2042                 sqcp->done_funct(sqcp->a_cmnd); /* callback to mid level */
2043         }
2044         sqcp->done_funct = NULL;
2045         spin_unlock_irqrestore(&queued_arr_lock, iflags);
2046 }
2047
2048 static int scsi_debug_slave_alloc(struct scsi_device * sdp)
2049 {
2050         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2051                 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
2052                        sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2053         set_bit(QUEUE_FLAG_BIDI, &sdp->request_queue->queue_flags);
2054         return 0;
2055 }
2056
2057 static int scsi_debug_slave_configure(struct scsi_device * sdp)
2058 {
2059         struct sdebug_dev_info * devip;
2060
2061         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2062                 printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n",
2063                        sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2064         if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN)
2065                 sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN;
2066         devip = devInfoReg(sdp);
2067         if (NULL == devip)
2068                 return 1;       /* no resources, will be marked offline */
2069         sdp->hostdata = devip;
2070         if (sdp->host->cmd_per_lun)
2071                 scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING,
2072                                         sdp->host->cmd_per_lun);
2073         blk_queue_max_segment_size(sdp->request_queue, 256 * 1024);
2074         return 0;
2075 }
2076
2077 static void scsi_debug_slave_destroy(struct scsi_device * sdp)
2078 {
2079         struct sdebug_dev_info * devip =
2080                                 (struct sdebug_dev_info *)sdp->hostdata;
2081
2082         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2083                 printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n",
2084                        sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
2085         if (devip) {
2086                 /* make this slot avaliable for re-use */
2087                 devip->used = 0;
2088                 sdp->hostdata = NULL;
2089         }
2090 }
2091
2092 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
2093 {
2094         struct sdebug_host_info * sdbg_host;
2095         struct sdebug_dev_info * open_devip = NULL;
2096         struct sdebug_dev_info * devip =
2097                         (struct sdebug_dev_info *)sdev->hostdata;
2098
2099         if (devip)
2100                 return devip;
2101         sdbg_host = *(struct sdebug_host_info **) sdev->host->hostdata;
2102         if(! sdbg_host) {
2103                 printk(KERN_ERR "Host info NULL\n");
2104                 return NULL;
2105         }
2106         list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
2107                 if ((devip->used) && (devip->channel == sdev->channel) &&
2108                     (devip->target == sdev->id) &&
2109                     (devip->lun == sdev->lun))
2110                         return devip;
2111                 else {
2112                         if ((!devip->used) && (!open_devip))
2113                                 open_devip = devip;
2114                 }
2115         }
2116         if (NULL == open_devip) { /* try and make a new one */
2117                 open_devip = kzalloc(sizeof(*open_devip),GFP_ATOMIC);
2118                 if (NULL == open_devip) {
2119                         printk(KERN_ERR "%s: out of memory at line %d\n",
2120                                 __FUNCTION__, __LINE__);
2121                         return NULL;
2122                 }
2123                 open_devip->sdbg_host = sdbg_host;
2124                 list_add_tail(&open_devip->dev_list,
2125                 &sdbg_host->dev_info_list);
2126         }
2127         if (open_devip) {
2128                 open_devip->channel = sdev->channel;
2129                 open_devip->target = sdev->id;
2130                 open_devip->lun = sdev->lun;
2131                 open_devip->sdbg_host = sdbg_host;
2132                 open_devip->reset = 1;
2133                 open_devip->used = 1;
2134                 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
2135                 if (scsi_debug_dsense)
2136                         open_devip->sense_buff[0] = 0x72;
2137                 else {
2138                         open_devip->sense_buff[0] = 0x70;
2139                         open_devip->sense_buff[7] = 0xa;
2140                 }
2141                 if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
2142                         open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
2143                 return open_devip;
2144         }
2145         return NULL;
2146 }
2147
2148 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
2149                             int asc, int asq)
2150 {
2151         unsigned char * sbuff;
2152
2153         sbuff = devip->sense_buff;
2154         memset(sbuff, 0, SDEBUG_SENSE_LEN);
2155         if (scsi_debug_dsense) {
2156                 sbuff[0] = 0x72;  /* descriptor, current */
2157                 sbuff[1] = key;
2158                 sbuff[2] = asc;
2159                 sbuff[3] = asq;
2160         } else {
2161                 sbuff[0] = 0x70;  /* fixed, current */
2162                 sbuff[2] = key;
2163                 sbuff[7] = 0xa;   /* implies 18 byte sense buffer */
2164                 sbuff[12] = asc;
2165                 sbuff[13] = asq;
2166         }
2167         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2168                 printk(KERN_INFO "scsi_debug:    [sense_key,asc,ascq]: "
2169                       "[0x%x,0x%x,0x%x]\n", key, asc, asq);
2170 }
2171
2172 static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
2173 {
2174         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2175                 printk(KERN_INFO "scsi_debug: abort\n");
2176         ++num_aborts;
2177         stop_queued_cmnd(SCpnt);
2178         return SUCCESS;
2179 }
2180
2181 static int scsi_debug_biosparam(struct scsi_device *sdev,
2182                 struct block_device * bdev, sector_t capacity, int *info)
2183 {
2184         int res;
2185         unsigned char *buf;
2186
2187         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2188                 printk(KERN_INFO "scsi_debug: biosparam\n");
2189         buf = scsi_bios_ptable(bdev);
2190         if (buf) {
2191                 res = scsi_partsize(buf, capacity,
2192                                     &info[2], &info[0], &info[1]);
2193                 kfree(buf);
2194                 if (! res)
2195                         return res;
2196         }
2197         info[0] = sdebug_heads;
2198         info[1] = sdebug_sectors_per;
2199         info[2] = sdebug_cylinders_per;
2200         return 0;
2201 }
2202
2203 static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
2204 {
2205         struct sdebug_dev_info * devip;
2206
2207         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2208                 printk(KERN_INFO "scsi_debug: device_reset\n");
2209         ++num_dev_resets;
2210         if (SCpnt) {
2211                 devip = devInfoReg(SCpnt->device);
2212                 if (devip)
2213                         devip->reset = 1;
2214         }
2215         return SUCCESS;
2216 }
2217
2218 static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
2219 {
2220         struct sdebug_host_info *sdbg_host;
2221         struct sdebug_dev_info * dev_info;
2222         struct scsi_device * sdp;
2223         struct Scsi_Host * hp;
2224
2225         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2226                 printk(KERN_INFO "scsi_debug: bus_reset\n");
2227         ++num_bus_resets;
2228         if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
2229                 sdbg_host = *(struct sdebug_host_info **) hp->hostdata;
2230                 if (sdbg_host) {
2231                         list_for_each_entry(dev_info,
2232                                             &sdbg_host->dev_info_list,
2233                                             dev_list)
2234                                 dev_info->reset = 1;
2235                 }
2236         }
2237         return SUCCESS;
2238 }
2239
2240 static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
2241 {
2242         struct sdebug_host_info * sdbg_host;
2243         struct sdebug_dev_info * dev_info;
2244
2245         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2246                 printk(KERN_INFO "scsi_debug: host_reset\n");
2247         ++num_host_resets;
2248         spin_lock(&sdebug_host_list_lock);
2249         list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
2250                 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
2251                                     dev_list)
2252                         dev_info->reset = 1;
2253         }
2254         spin_unlock(&sdebug_host_list_lock);
2255         stop_all_queued();
2256         return SUCCESS;
2257 }
2258
2259 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
2260 static int stop_queued_cmnd(struct scsi_cmnd * cmnd)
2261 {
2262         unsigned long iflags;
2263         int k;
2264         struct sdebug_queued_cmd * sqcp;
2265
2266         spin_lock_irqsave(&queued_arr_lock, iflags);
2267         for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2268                 sqcp = &queued_arr[k];
2269                 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
2270                         del_timer_sync(&sqcp->cmnd_timer);
2271                         sqcp->in_use = 0;
2272                         sqcp->a_cmnd = NULL;
2273                         break;
2274                 }
2275         }
2276         spin_unlock_irqrestore(&queued_arr_lock, iflags);
2277         return (k < SCSI_DEBUG_CANQUEUE) ? 1 : 0;
2278 }
2279
2280 /* Deletes (stops) timers of all queued commands */
2281 static void stop_all_queued(void)
2282 {
2283         unsigned long iflags;
2284         int k;
2285         struct sdebug_queued_cmd * sqcp;
2286
2287         spin_lock_irqsave(&queued_arr_lock, iflags);
2288         for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2289                 sqcp = &queued_arr[k];
2290                 if (sqcp->in_use && sqcp->a_cmnd) {
2291                         del_timer_sync(&sqcp->cmnd_timer);
2292                         sqcp->in_use = 0;
2293                         sqcp->a_cmnd = NULL;
2294                 }
2295         }
2296         spin_unlock_irqrestore(&queued_arr_lock, iflags);
2297 }
2298
2299 /* Initializes timers in queued array */
2300 static void __init init_all_queued(void)
2301 {
2302         unsigned long iflags;
2303         int k;
2304         struct sdebug_queued_cmd * sqcp;
2305
2306         spin_lock_irqsave(&queued_arr_lock, iflags);
2307         for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2308                 sqcp = &queued_arr[k];
2309                 init_timer(&sqcp->cmnd_timer);
2310                 sqcp->in_use = 0;
2311                 sqcp->a_cmnd = NULL;
2312         }
2313         spin_unlock_irqrestore(&queued_arr_lock, iflags);
2314 }
2315
2316 static void __init sdebug_build_parts(unsigned char * ramp)
2317 {
2318         struct partition * pp;
2319         int starts[SDEBUG_MAX_PARTS + 2];
2320         int sectors_per_part, num_sectors, k;
2321         int heads_by_sects, start_sec, end_sec;
2322
2323         /* assume partition table already zeroed */
2324         if ((scsi_debug_num_parts < 1) || (sdebug_store_size < 1048576))
2325                 return;
2326         if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
2327                 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
2328                 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
2329                                     "partitions to %d\n", SDEBUG_MAX_PARTS);
2330         }
2331         num_sectors = (int)sdebug_store_sectors;
2332         sectors_per_part = (num_sectors - sdebug_sectors_per)
2333                            / scsi_debug_num_parts;
2334         heads_by_sects = sdebug_heads * sdebug_sectors_per;
2335         starts[0] = sdebug_sectors_per;
2336         for (k = 1; k < scsi_debug_num_parts; ++k)
2337                 starts[k] = ((k * sectors_per_part) / heads_by_sects)
2338                             * heads_by_sects;
2339         starts[scsi_debug_num_parts] = num_sectors;
2340         starts[scsi_debug_num_parts + 1] = 0;
2341
2342         ramp[510] = 0x55;       /* magic partition markings */
2343         ramp[511] = 0xAA;
2344         pp = (struct partition *)(ramp + 0x1be);
2345         for (k = 0; starts[k + 1]; ++k, ++pp) {
2346                 start_sec = starts[k];
2347                 end_sec = starts[k + 1] - 1;
2348                 pp->boot_ind = 0;
2349
2350                 pp->cyl = start_sec / heads_by_sects;
2351                 pp->head = (start_sec - (pp->cyl * heads_by_sects))
2352                            / sdebug_sectors_per;
2353                 pp->sector = (start_sec % sdebug_sectors_per) + 1;
2354
2355                 pp->end_cyl = end_sec / heads_by_sects;
2356                 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
2357                                / sdebug_sectors_per;
2358                 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2359
2360                 pp->start_sect = start_sec;
2361                 pp->nr_sects = end_sec - start_sec + 1;
2362                 pp->sys_ind = 0x83;     /* plain Linux partition */
2363         }
2364 }
2365
2366 static int schedule_resp(struct scsi_cmnd * cmnd,
2367                          struct sdebug_dev_info * devip,
2368                          done_funct_t done, int scsi_result, int delta_jiff)
2369 {
2370         if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
2371                 if (scsi_result) {
2372                         struct scsi_device * sdp = cmnd->device;
2373
2374                         printk(KERN_INFO "scsi_debug:    <%u %u %u %u> "
2375                                "non-zero result=0x%x\n", sdp->host->host_no,
2376                                sdp->channel, sdp->id, sdp->lun, scsi_result);
2377                 }
2378         }
2379         if (cmnd && devip) {
2380                 /* simulate autosense by this driver */
2381                 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
2382                         memcpy(cmnd->sense_buffer, devip->sense_buff,
2383                                (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
2384                                SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
2385         }
2386         if (delta_jiff <= 0) {
2387                 if (cmnd)
2388                         cmnd->result = scsi_result;
2389                 if (done)
2390                         done(cmnd);
2391                 return 0;
2392         } else {
2393                 unsigned long iflags;
2394                 int k;
2395                 struct sdebug_queued_cmd * sqcp = NULL;
2396
2397                 spin_lock_irqsave(&queued_arr_lock, iflags);
2398                 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2399                         sqcp = &queued_arr[k];
2400                         if (! sqcp->in_use)
2401                                 break;
2402                 }
2403                 if (k >= SCSI_DEBUG_CANQUEUE) {
2404                         spin_unlock_irqrestore(&queued_arr_lock, iflags);
2405                         printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
2406                         return 1;       /* report busy to mid level */
2407                 }
2408                 sqcp->in_use = 1;
2409                 sqcp->a_cmnd = cmnd;
2410                 sqcp->scsi_result = scsi_result;
2411                 sqcp->done_funct = done;
2412                 sqcp->cmnd_timer.function = timer_intr_handler;
2413                 sqcp->cmnd_timer.data = k;
2414                 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
2415                 add_timer(&sqcp->cmnd_timer);
2416                 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2417                 if (cmnd)
2418                         cmnd->result = 0;
2419                 return 0;
2420         }
2421 }
2422
2423 /* Note: The following macros create attribute files in the
2424    /sys/module/scsi_debug/parameters directory. Unfortunately this
2425    driver is unaware of a change and cannot trigger auxiliary actions
2426    as it can when the corresponding attribute in the
2427    /sys/bus/pseudo/drivers/scsi_debug directory is changed.
2428  */
2429 module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
2430 module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
2431 module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
2432 module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
2433 module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
2434 module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
2435 module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
2436 module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
2437 module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
2438 module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
2439 module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
2440 module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
2441 module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
2442 module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
2443 module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
2444                    S_IRUGO | S_IWUSR);
2445
2446 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2447 MODULE_DESCRIPTION("SCSI debug adapter driver");
2448 MODULE_LICENSE("GPL");
2449 MODULE_VERSION(SCSI_DEBUG_VERSION);
2450
2451 MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
2452 MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
2453 MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
2454 MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
2455 MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
2456 MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
2457 MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
2458 MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
2459 MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
2460 MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
2461 MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
2462 MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
2463 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
2464 MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
2465 MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2466
2467
2468 static char sdebug_info[256];
2469
2470 static const char * scsi_debug_info(struct Scsi_Host * shp)
2471 {
2472         sprintf(sdebug_info, "scsi_debug, version %s [%s], "
2473                 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
2474                 scsi_debug_version_date, scsi_debug_dev_size_mb,
2475                 scsi_debug_opts);
2476         return sdebug_info;
2477 }
2478
2479 /* scsi_debug_proc_info
2480  * Used if the driver currently has no own support for /proc/scsi
2481  */
2482 static int scsi_debug_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
2483                                 int length, int inout)
2484 {
2485         int len, pos, begin;
2486         int orig_length;
2487
2488         orig_length = length;
2489
2490         if (inout == 1) {
2491                 char arr[16];
2492                 int minLen = length > 15 ? 15 : length;
2493
2494                 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2495                         return -EACCES;
2496                 memcpy(arr, buffer, minLen);
2497                 arr[minLen] = '\0';
2498                 if (1 != sscanf(arr, "%d", &pos))
2499                         return -EINVAL;
2500                 scsi_debug_opts = pos;
2501                 if (scsi_debug_every_nth != 0)
2502                         scsi_debug_cmnd_count = 0;
2503                 return length;
2504         }
2505         begin = 0;
2506         pos = len = sprintf(buffer, "scsi_debug adapter driver, version "
2507             "%s [%s]\n"
2508             "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2509             "every_nth=%d(curr:%d)\n"
2510             "delay=%d, max_luns=%d, scsi_level=%d\n"
2511             "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2512             "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2513             "host_resets=%d\n",
2514             SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
2515             scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2516             scsi_debug_cmnd_count, scsi_debug_delay,
2517             scsi_debug_max_luns, scsi_debug_scsi_level,
2518             SECT_SIZE, sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
2519             num_aborts, num_dev_resets, num_bus_resets, num_host_resets);
2520         if (pos < offset) {
2521                 len = 0;
2522                 begin = pos;
2523         }
2524         *start = buffer + (offset - begin);     /* Start of wanted data */
2525         len -= (offset - begin);
2526         if (len > length)
2527                 len = length;
2528         return len;
2529 }
2530
2531 static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf)
2532 {
2533         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
2534 }
2535
2536 static ssize_t sdebug_delay_store(struct device_driver * ddp,
2537                                   const char * buf, size_t count)
2538 {
2539         int delay;
2540         char work[20];
2541
2542         if (1 == sscanf(buf, "%10s", work)) {
2543                 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
2544                         scsi_debug_delay = delay;
2545                         return count;
2546                 }
2547         }
2548         return -EINVAL;
2549 }
2550 DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show,
2551             sdebug_delay_store);
2552
2553 static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf)
2554 {
2555         return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
2556 }
2557
2558 static ssize_t sdebug_opts_store(struct device_driver * ddp,
2559                                  const char * buf, size_t count)
2560 {
2561         int opts;
2562         char work[20];
2563
2564         if (1 == sscanf(buf, "%10s", work)) {
2565                 if (0 == strnicmp(work,"0x", 2)) {
2566                         if (1 == sscanf(&work[2], "%x", &opts))
2567                                 goto opts_done;
2568                 } else {
2569                         if (1 == sscanf(work, "%d", &opts))
2570                                 goto opts_done;
2571                 }
2572         }
2573         return -EINVAL;
2574 opts_done:
2575         scsi_debug_opts = opts;
2576         scsi_debug_cmnd_count = 0;
2577         return count;
2578 }
2579 DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show,
2580             sdebug_opts_store);
2581
2582 static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf)
2583 {
2584         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
2585 }
2586 static ssize_t sdebug_ptype_store(struct device_driver * ddp,
2587                                   const char * buf, size_t count)
2588 {
2589         int n;
2590
2591         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2592                 scsi_debug_ptype = n;
2593                 return count;
2594         }
2595         return -EINVAL;
2596 }
2597 DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store);
2598
2599 static ssize_t sdebug_dsense_show(struct device_driver * ddp, char * buf)
2600 {
2601         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
2602 }
2603 static ssize_t sdebug_dsense_store(struct device_driver * ddp,
2604                                   const char * buf, size_t count)
2605 {
2606         int n;
2607
2608         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2609                 scsi_debug_dsense = n;
2610                 return count;
2611         }
2612         return -EINVAL;
2613 }
2614 DRIVER_ATTR(dsense, S_IRUGO | S_IWUSR, sdebug_dsense_show,
2615             sdebug_dsense_store);
2616
2617 static ssize_t sdebug_fake_rw_show(struct device_driver * ddp, char * buf)
2618 {
2619         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
2620 }
2621 static ssize_t sdebug_fake_rw_store(struct device_driver * ddp,
2622                                     const char * buf, size_t count)
2623 {
2624         int n;
2625
2626         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2627                 scsi_debug_fake_rw = n;
2628                 return count;
2629         }
2630         return -EINVAL;
2631 }
2632 DRIVER_ATTR(fake_rw, S_IRUGO | S_IWUSR, sdebug_fake_rw_show,
2633             sdebug_fake_rw_store);
2634
2635 static ssize_t sdebug_no_lun_0_show(struct device_driver * ddp, char * buf)
2636 {
2637         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
2638 }
2639 static ssize_t sdebug_no_lun_0_store(struct device_driver * ddp,
2640                                      const char * buf, size_t count)
2641 {
2642         int n;
2643
2644         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2645                 scsi_debug_no_lun_0 = n;
2646                 return count;
2647         }
2648         return -EINVAL;
2649 }
2650 DRIVER_ATTR(no_lun_0, S_IRUGO | S_IWUSR, sdebug_no_lun_0_show,
2651             sdebug_no_lun_0_store);
2652
2653 static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf)
2654 {
2655         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
2656 }
2657 static ssize_t sdebug_num_tgts_store(struct device_driver * ddp,
2658                                      const char * buf, size_t count)
2659 {
2660         int n;
2661
2662         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2663                 scsi_debug_num_tgts = n;
2664                 sdebug_max_tgts_luns();
2665                 return count;
2666         }
2667         return -EINVAL;
2668 }
2669 DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show,
2670             sdebug_num_tgts_store);
2671
2672 static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf)
2673 {
2674         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
2675 }
2676 DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL);
2677
2678 static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf)
2679 {
2680         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
2681 }
2682 DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL);
2683
2684 static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf)
2685 {
2686         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
2687 }
2688 static ssize_t sdebug_every_nth_store(struct device_driver * ddp,
2689                                       const char * buf, size_t count)
2690 {
2691         int nth;
2692
2693         if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
2694                 scsi_debug_every_nth = nth;
2695                 scsi_debug_cmnd_count = 0;
2696                 return count;
2697         }
2698         return -EINVAL;
2699 }
2700 DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show,
2701             sdebug_every_nth_store);
2702
2703 static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf)
2704 {
2705         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
2706 }
2707 static ssize_t sdebug_max_luns_store(struct device_driver * ddp,
2708                                      const char * buf, size_t count)
2709 {
2710         int n;
2711
2712         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2713                 scsi_debug_max_luns = n;
2714                 sdebug_max_tgts_luns();
2715                 return count;
2716         }
2717         return -EINVAL;
2718 }
2719 DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show,
2720             sdebug_max_luns_store);
2721
2722 static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf)
2723 {
2724         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
2725 }
2726 DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL);
2727
2728 static ssize_t sdebug_virtual_gb_show(struct device_driver * ddp, char * buf)
2729 {
2730         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
2731 }
2732 static ssize_t sdebug_virtual_gb_store(struct device_driver * ddp,
2733                                        const char * buf, size_t count)
2734 {
2735         int n;
2736
2737         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2738                 scsi_debug_virtual_gb = n;
2739                 if (scsi_debug_virtual_gb > 0) {
2740                         sdebug_capacity = 2048 * 1024;
2741                         sdebug_capacity *= scsi_debug_virtual_gb;
2742                 } else
2743                         sdebug_capacity = sdebug_store_sectors;
2744                 return count;
2745         }
2746         return -EINVAL;
2747 }
2748 DRIVER_ATTR(virtual_gb, S_IRUGO | S_IWUSR, sdebug_virtual_gb_show,
2749             sdebug_virtual_gb_store);
2750
2751 static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf)
2752 {
2753         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
2754 }
2755
2756 static ssize_t sdebug_add_host_store(struct device_driver * ddp,
2757                                      const char * buf, size_t count)
2758 {
2759         int delta_hosts;
2760         char work[20];
2761
2762         if (1 != sscanf(buf, "%10s", work))
2763                 return -EINVAL;
2764         {       /* temporary hack around sscanf() problem with -ve nums */
2765                 int neg = 0;
2766
2767                 if ('-' == *work)
2768                         neg = 1;
2769                 if (1 != sscanf(work + neg, "%d", &delta_hosts))
2770                         return -EINVAL;
2771                 if (neg)
2772                         delta_hosts = -delta_hosts;
2773         }
2774         if (delta_hosts > 0) {
2775                 do {
2776                         sdebug_add_adapter();
2777                 } while (--delta_hosts);
2778         } else if (delta_hosts < 0) {
2779                 do {
2780                         sdebug_remove_adapter();
2781                 } while (++delta_hosts);
2782         }
2783         return count;
2784 }
2785 DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show,
2786             sdebug_add_host_store);
2787
2788 static ssize_t sdebug_vpd_use_hostno_show(struct device_driver * ddp,
2789                                           char * buf)
2790 {
2791         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
2792 }
2793 static ssize_t sdebug_vpd_use_hostno_store(struct device_driver * ddp,
2794                                            const char * buf, size_t count)
2795 {
2796         int n;
2797
2798         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2799                 scsi_debug_vpd_use_hostno = n;
2800                 return count;
2801         }
2802         return -EINVAL;
2803 }
2804 DRIVER_ATTR(vpd_use_hostno, S_IRUGO | S_IWUSR, sdebug_vpd_use_hostno_show,
2805             sdebug_vpd_use_hostno_store);
2806
2807 /* Note: The following function creates attribute files in the
2808    /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
2809    files (over those found in the /sys/module/scsi_debug/parameters
2810    directory) is that auxiliary actions can be triggered when an attribute
2811    is changed. For example see: sdebug_add_host_store() above.
2812  */
2813 static int do_create_driverfs_files(void)
2814 {
2815         int ret;
2816
2817         ret = driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2818         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay);
2819         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2820         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2821         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2822         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2823         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2824         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2825         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2826         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2827         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2828         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts);
2829         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2830         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2831         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2832         return ret;
2833 }
2834
2835 static void do_remove_driverfs_files(void)
2836 {
2837         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2838         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2839         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2840         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts);
2841         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2842         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2843         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2844         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2845         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2846         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2847         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2848         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2849         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2850         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay);
2851         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2852 }
2853
2854 static int __init scsi_debug_init(void)
2855 {
2856         unsigned int sz;
2857         int host_to_add;
2858         int k;
2859         int ret;
2860
2861         if (scsi_debug_dev_size_mb < 1)
2862                 scsi_debug_dev_size_mb = 1;  /* force minimum 1 MB ramdisk */
2863         sdebug_store_size = (unsigned int)scsi_debug_dev_size_mb * 1048576;
2864         sdebug_store_sectors = sdebug_store_size / SECT_SIZE;
2865         if (scsi_debug_virtual_gb > 0) {
2866                 sdebug_capacity = 2048 * 1024;
2867                 sdebug_capacity *= scsi_debug_virtual_gb;
2868         } else
2869                 sdebug_capacity = sdebug_store_sectors;
2870
2871         /* play around with geometry, don't waste too much on track 0 */
2872         sdebug_heads = 8;
2873         sdebug_sectors_per = 32;
2874         if (scsi_debug_dev_size_mb >= 16)
2875                 sdebug_heads = 32;
2876         else if (scsi_debug_dev_size_mb >= 256)
2877                 sdebug_heads = 64;
2878         sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2879                                (sdebug_sectors_per * sdebug_heads);
2880         if (sdebug_cylinders_per >= 1024) {
2881                 /* other LLDs do this; implies >= 1GB ram disk ... */
2882                 sdebug_heads = 255;
2883                 sdebug_sectors_per = 63;
2884                 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2885                                (sdebug_sectors_per * sdebug_heads);
2886         }
2887
2888         sz = sdebug_store_size;
2889         fake_storep = vmalloc(sz);
2890         if (NULL == fake_storep) {
2891                 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
2892                 return -ENOMEM;
2893         }
2894         memset(fake_storep, 0, sz);
2895         if (scsi_debug_num_parts > 0)
2896                 sdebug_build_parts(fake_storep);
2897
2898         ret = device_register(&pseudo_primary);
2899         if (ret < 0) {
2900                 printk(KERN_WARNING "scsi_debug: device_register error: %d\n",
2901                         ret);
2902                 goto free_vm;
2903         }
2904         ret = bus_register(&pseudo_lld_bus);
2905         if (ret < 0) {
2906                 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
2907                         ret);
2908                 goto dev_unreg;
2909         }
2910         ret = driver_register(&sdebug_driverfs_driver);
2911         if (ret < 0) {
2912                 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
2913                         ret);
2914                 goto bus_unreg;
2915         }
2916         ret = do_create_driverfs_files();
2917         if (ret < 0) {
2918                 printk(KERN_WARNING "scsi_debug: driver_create_file error: %d\n",
2919                         ret);
2920                 goto del_files;
2921         }
2922
2923         init_all_queued();
2924
2925         sdebug_driver_template.proc_name = sdebug_proc_name;
2926
2927         host_to_add = scsi_debug_add_host;
2928         scsi_debug_add_host = 0;
2929
2930         for (k = 0; k < host_to_add; k++) {
2931                 if (sdebug_add_adapter()) {
2932                         printk(KERN_ERR "scsi_debug_init: "
2933                                "sdebug_add_adapter failed k=%d\n", k);
2934                         break;
2935                 }
2936         }
2937
2938         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
2939                 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
2940                        scsi_debug_add_host);
2941         }
2942         return 0;
2943
2944 del_files:
2945         do_remove_driverfs_files();
2946         driver_unregister(&sdebug_driverfs_driver);
2947 bus_unreg:
2948         bus_unregister(&pseudo_lld_bus);
2949 dev_unreg:
2950         device_unregister(&pseudo_primary);
2951 free_vm:
2952         vfree(fake_storep);
2953
2954         return ret;
2955 }
2956
2957 static void __exit scsi_debug_exit(void)
2958 {
2959         int k = scsi_debug_add_host;
2960
2961         stop_all_queued();
2962         for (; k; k--)
2963                 sdebug_remove_adapter();
2964         do_remove_driverfs_files();
2965         driver_unregister(&sdebug_driverfs_driver);
2966         bus_unregister(&pseudo_lld_bus);
2967         device_unregister(&pseudo_primary);
2968
2969         vfree(fake_storep);
2970 }
2971
2972 device_initcall(scsi_debug_init);
2973 module_exit(scsi_debug_exit);
2974
2975 static void pseudo_0_release(struct device * dev)
2976 {
2977         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2978                 printk(KERN_INFO "scsi_debug: pseudo_0_release() called\n");
2979 }
2980
2981 static struct device pseudo_primary = {
2982         .bus_id         = "pseudo_0",
2983         .release        = pseudo_0_release,
2984 };
2985
2986 static int pseudo_lld_bus_match(struct device *dev,
2987                           struct device_driver *dev_driver)
2988 {
2989         return 1;
2990 }
2991
2992 static struct bus_type pseudo_lld_bus = {
2993         .name = "pseudo",
2994         .match = pseudo_lld_bus_match,
2995         .probe = sdebug_driver_probe,
2996         .remove = sdebug_driver_remove,
2997 };
2998
2999 static void sdebug_release_adapter(struct device * dev)
3000 {
3001         struct sdebug_host_info *sdbg_host;
3002
3003         sdbg_host = to_sdebug_host(dev);
3004         kfree(sdbg_host);
3005 }
3006
3007 static int sdebug_add_adapter(void)
3008 {
3009         int k, devs_per_host;
3010         int error = 0;
3011         struct sdebug_host_info *sdbg_host;
3012         struct sdebug_dev_info *sdbg_devinfo;
3013         struct list_head *lh, *lh_sf;
3014
3015         sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
3016         if (NULL == sdbg_host) {
3017                 printk(KERN_ERR "%s: out of memory at line %d\n",
3018                        __FUNCTION__, __LINE__);
3019                 return -ENOMEM;
3020         }
3021
3022         INIT_LIST_HEAD(&sdbg_host->dev_info_list);
3023
3024         devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
3025         for (k = 0; k < devs_per_host; k++) {
3026                 sdbg_devinfo = kzalloc(sizeof(*sdbg_devinfo),GFP_KERNEL);
3027                 if (NULL == sdbg_devinfo) {
3028                         printk(KERN_ERR "%s: out of memory at line %d\n",
3029                                __FUNCTION__, __LINE__);
3030                         error = -ENOMEM;
3031                         goto clean;
3032                 }
3033                 sdbg_devinfo->sdbg_host = sdbg_host;
3034                 list_add_tail(&sdbg_devinfo->dev_list,
3035                               &sdbg_host->dev_info_list);
3036         }
3037
3038         spin_lock(&sdebug_host_list_lock);
3039         list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
3040         spin_unlock(&sdebug_host_list_lock);
3041
3042         sdbg_host->dev.bus = &pseudo_lld_bus;
3043         sdbg_host->dev.parent = &pseudo_primary;
3044         sdbg_host->dev.release = &sdebug_release_adapter;
3045         sprintf(sdbg_host->dev.bus_id, "adapter%d", scsi_debug_add_host);
3046
3047         error = device_register(&sdbg_host->dev);
3048
3049         if (error)
3050                 goto clean;
3051
3052         ++scsi_debug_add_host;
3053         return error;
3054
3055 clean:
3056         list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
3057                 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
3058                                           dev_list);
3059                 list_del(&sdbg_devinfo->dev_list);
3060                 kfree(sdbg_devinfo);
3061         }
3062
3063         kfree(sdbg_host);
3064         return error;
3065 }
3066
3067 static void sdebug_remove_adapter(void)
3068 {
3069         struct sdebug_host_info * sdbg_host = NULL;
3070
3071         spin_lock(&sdebug_host_list_lock);
3072         if (!list_empty(&sdebug_host_list)) {
3073                 sdbg_host = list_entry(sdebug_host_list.prev,
3074                                        struct sdebug_host_info, host_list);
3075                 list_del(&sdbg_host->host_list);
3076         }
3077         spin_unlock(&sdebug_host_list_lock);
3078
3079         if (!sdbg_host)
3080                 return;
3081
3082         device_unregister(&sdbg_host->dev);
3083         --scsi_debug_add_host;
3084 }
3085
3086 static int sdebug_driver_probe(struct device * dev)
3087 {
3088         int error = 0;
3089         struct sdebug_host_info *sdbg_host;
3090         struct Scsi_Host *hpnt;
3091
3092         sdbg_host = to_sdebug_host(dev);
3093
3094         hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
3095         if (NULL == hpnt) {
3096                 printk(KERN_ERR "%s: scsi_register failed\n", __FUNCTION__);
3097                 error = -ENODEV;
3098                 return error;
3099         }
3100
3101         sdbg_host->shost = hpnt;
3102         *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
3103         if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
3104                 hpnt->max_id = scsi_debug_num_tgts + 1;
3105         else
3106                 hpnt->max_id = scsi_debug_num_tgts;
3107         hpnt->max_lun = SAM2_WLUN_REPORT_LUNS;  /* = scsi_debug_max_luns; */
3108
3109         error = scsi_add_host(hpnt, &sdbg_host->dev);
3110         if (error) {
3111                 printk(KERN_ERR "%s: scsi_add_host failed\n", __FUNCTION__);
3112                 error = -ENODEV;
3113                 scsi_host_put(hpnt);
3114         } else
3115                 scsi_scan_host(hpnt);
3116
3117
3118         return error;
3119 }
3120
3121 static int sdebug_driver_remove(struct device * dev)
3122 {
3123         struct list_head *lh, *lh_sf;
3124         struct sdebug_host_info *sdbg_host;
3125         struct sdebug_dev_info *sdbg_devinfo;
3126
3127         sdbg_host = to_sdebug_host(dev);
3128
3129         if (!sdbg_host) {
3130                 printk(KERN_ERR "%s: Unable to locate host info\n",
3131                        __FUNCTION__);
3132                 return -ENODEV;
3133         }
3134
3135         scsi_remove_host(sdbg_host->shost);
3136
3137         list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
3138                 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
3139                                           dev_list);
3140                 list_del(&sdbg_devinfo->dev_list);
3141                 kfree(sdbg_devinfo);
3142         }
3143
3144         scsi_host_put(sdbg_host->shost);
3145         return 0;
3146 }
3147
3148 static void sdebug_max_tgts_luns(void)
3149 {
3150         struct sdebug_host_info * sdbg_host;
3151         struct Scsi_Host *hpnt;
3152
3153         spin_lock(&sdebug_host_list_lock);
3154         list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
3155                 hpnt = sdbg_host->shost;
3156                 if ((hpnt->this_id >= 0) &&
3157                     (scsi_debug_num_tgts > hpnt->this_id))
3158                         hpnt->max_id = scsi_debug_num_tgts + 1;
3159                 else
3160                         hpnt->max_id = scsi_debug_num_tgts;
3161                 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* scsi_debug_max_luns; */
3162         }
3163         spin_unlock(&sdebug_host_list_lock);
3164 }