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