SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/scsi/scsi_debug.c

   1 /*
   2  * vvvvvvvvvvvvvvvvvvvvvvv Original vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
   3  *  Copyright (C) 1992  Eric Youngdale
   4  *  Simulate a host adapter with 2 disks attached.  Do a lot of checking
   5  *  to make sure that we are not getting blocks mixed up, and PANIC if
   6  *  anything out of the ordinary is seen.
   7  * ^^^^^^^^^^^^^^^^^^^^^^^ Original ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   8  *
   9  *  This version is more generic, simulating a variable number of disk
  10  *  (or disk like devices) sharing a common amount of RAM. To be more
  11  *  realistic, the simulated devices have the transport attributes of
  12  *  SAS disks.
  13  *
  14  *
  15  *  For documentation see http://www.torque.net/sg/sdebug26.html
  16  *
  17  *   D. Gilbert (dpg) work for Magneto-Optical device test [20010421]
  18  *   dpg: work for devfs large number of disks [20010809]
  19  *        forked for lk 2.5 series [20011216, 20020101]
  20  *        use vmalloc() more inquiry+mode_sense [20020302]
  21  *        add timers for delayed responses [20020721]
  22  *   Patrick Mansfield <patmans@us.ibm.com> max_luns+scsi_level [20021031]
  23  *   Mike Anderson <andmike@us.ibm.com> sysfs work [20021118]
  24  *   dpg: change style of boot options to "scsi_debug.num_tgts=2" and
  25  *        module options to "modprobe scsi_debug num_tgts=2" [20021221]
  26  */
  27
  28 #include <linux/module.h>
  29
  30 #include <linux/kernel.h>
  31 #include <linux/errno.h>
  32 #include <linux/timer.h>
  33 #include <linux/types.h>
  34 #include <linux/string.h>
  35 #include <linux/genhd.h>
  36 #include <linux/fs.h>
  37 #include <linux/init.h>
  38 #include <linux/proc_fs.h>
  39 #include <linux/vmalloc.h>
  40 #include <linux/moduleparam.h>
  41 #include <linux/scatterlist.h>
  42 #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 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev)
2018 {
2019         struct sdebug_host_info * sdbg_host;
2020         struct sdebug_dev_info * open_devip = NULL;
2021         struct sdebug_dev_info * devip =
2022                         (struct sdebug_dev_info *)sdev->hostdata;
2023
2024         if (devip)
2025                 return devip;
2026         sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host);
2027         if (!sdbg_host) {
2028                 printk(KERN_ERR "Host info NULL\n");
2029                 return NULL;
2030         }
2031         list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) {
2032                 if ((devip->used) && (devip->channel == sdev->channel) &&
2033                     (devip->target == sdev->id) &&
2034                     (devip->lun == sdev->lun))
2035                         return devip;
2036                 else {
2037                         if ((!devip->used) && (!open_devip))
2038                                 open_devip = devip;
2039                 }
2040         }
2041         if (NULL == open_devip) { /* try and make a new one */
2042                 open_devip = kzalloc(sizeof(*open_devip),GFP_ATOMIC);
2043                 if (NULL == open_devip) {
2044                         printk(KERN_ERR "%s: out of memory at line %d\n",
2045                                 __FUNCTION__, __LINE__);
2046                         return NULL;
2047                 }
2048                 open_devip->sdbg_host = sdbg_host;
2049                 list_add_tail(&open_devip->dev_list,
2050                 &sdbg_host->dev_info_list);
2051         }
2052         if (open_devip) {
2053                 open_devip->channel = sdev->channel;
2054                 open_devip->target = sdev->id;
2055                 open_devip->lun = sdev->lun;
2056                 open_devip->sdbg_host = sdbg_host;
2057                 open_devip->reset = 1;
2058                 open_devip->used = 1;
2059                 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN);
2060                 if (scsi_debug_dsense)
2061                         open_devip->sense_buff[0] = 0x72;
2062                 else {
2063                         open_devip->sense_buff[0] = 0x70;
2064                         open_devip->sense_buff[7] = 0xa;
2065                 }
2066                 if (sdev->lun == SAM2_WLUN_REPORT_LUNS)
2067                         open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff;
2068                 return open_devip;
2069         }
2070         return NULL;
2071 }
2072
2073 static void mk_sense_buffer(struct sdebug_dev_info * devip, int key,
2074                             int asc, int asq)
2075 {
2076         unsigned char * sbuff;
2077
2078         sbuff = devip->sense_buff;
2079         memset(sbuff, 0, SDEBUG_SENSE_LEN);
2080         if (scsi_debug_dsense) {
2081                 sbuff[0] = 0x72;  /* descriptor, current */
2082                 sbuff[1] = key;
2083                 sbuff[2] = asc;
2084                 sbuff[3] = asq;
2085         } else {
2086                 sbuff[0] = 0x70;  /* fixed, current */
2087                 sbuff[2] = key;
2088                 sbuff[7] = 0xa;   /* implies 18 byte sense buffer */
2089                 sbuff[12] = asc;
2090                 sbuff[13] = asq;
2091         }
2092         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2093                 printk(KERN_INFO "scsi_debug:    [sense_key,asc,ascq]: "
2094                       "[0x%x,0x%x,0x%x]\n", key, asc, asq);
2095 }
2096
2097 static int scsi_debug_abort(struct scsi_cmnd * SCpnt)
2098 {
2099         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2100                 printk(KERN_INFO "scsi_debug: abort\n");
2101         ++num_aborts;
2102         stop_queued_cmnd(SCpnt);
2103         return SUCCESS;
2104 }
2105
2106 static int scsi_debug_biosparam(struct scsi_device *sdev,
2107                 struct block_device * bdev, sector_t capacity, int *info)
2108 {
2109         int res;
2110         unsigned char *buf;
2111
2112         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2113                 printk(KERN_INFO "scsi_debug: biosparam\n");
2114         buf = scsi_bios_ptable(bdev);
2115         if (buf) {
2116                 res = scsi_partsize(buf, capacity,
2117                                     &info[2], &info[0], &info[1]);
2118                 kfree(buf);
2119                 if (! res)
2120                         return res;
2121         }
2122         info[0] = sdebug_heads;
2123         info[1] = sdebug_sectors_per;
2124         info[2] = sdebug_cylinders_per;
2125         return 0;
2126 }
2127
2128 static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt)
2129 {
2130         struct sdebug_dev_info * devip;
2131
2132         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2133                 printk(KERN_INFO "scsi_debug: device_reset\n");
2134         ++num_dev_resets;
2135         if (SCpnt) {
2136                 devip = devInfoReg(SCpnt->device);
2137                 if (devip)
2138                         devip->reset = 1;
2139         }
2140         return SUCCESS;
2141 }
2142
2143 static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt)
2144 {
2145         struct sdebug_host_info *sdbg_host;
2146         struct sdebug_dev_info * dev_info;
2147         struct scsi_device * sdp;
2148         struct Scsi_Host * hp;
2149
2150         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2151                 printk(KERN_INFO "scsi_debug: bus_reset\n");
2152         ++num_bus_resets;
2153         if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) {
2154                 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp);
2155                 if (sdbg_host) {
2156                         list_for_each_entry(dev_info,
2157                                             &sdbg_host->dev_info_list,
2158                                             dev_list)
2159                                 dev_info->reset = 1;
2160                 }
2161         }
2162         return SUCCESS;
2163 }
2164
2165 static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt)
2166 {
2167         struct sdebug_host_info * sdbg_host;
2168         struct sdebug_dev_info * dev_info;
2169
2170         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2171                 printk(KERN_INFO "scsi_debug: host_reset\n");
2172         ++num_host_resets;
2173         spin_lock(&sdebug_host_list_lock);
2174         list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
2175                 list_for_each_entry(dev_info, &sdbg_host->dev_info_list,
2176                                     dev_list)
2177                         dev_info->reset = 1;
2178         }
2179         spin_unlock(&sdebug_host_list_lock);
2180         stop_all_queued();
2181         return SUCCESS;
2182 }
2183
2184 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */
2185 static int stop_queued_cmnd(struct scsi_cmnd * cmnd)
2186 {
2187         unsigned long iflags;
2188         int k;
2189         struct sdebug_queued_cmd * sqcp;
2190
2191         spin_lock_irqsave(&queued_arr_lock, iflags);
2192         for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2193                 sqcp = &queued_arr[k];
2194                 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) {
2195                         del_timer_sync(&sqcp->cmnd_timer);
2196                         sqcp->in_use = 0;
2197                         sqcp->a_cmnd = NULL;
2198                         break;
2199                 }
2200         }
2201         spin_unlock_irqrestore(&queued_arr_lock, iflags);
2202         return (k < SCSI_DEBUG_CANQUEUE) ? 1 : 0;
2203 }
2204
2205 /* Deletes (stops) timers of all queued commands */
2206 static void stop_all_queued(void)
2207 {
2208         unsigned long iflags;
2209         int k;
2210         struct sdebug_queued_cmd * sqcp;
2211
2212         spin_lock_irqsave(&queued_arr_lock, iflags);
2213         for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2214                 sqcp = &queued_arr[k];
2215                 if (sqcp->in_use && sqcp->a_cmnd) {
2216                         del_timer_sync(&sqcp->cmnd_timer);
2217                         sqcp->in_use = 0;
2218                         sqcp->a_cmnd = NULL;
2219                 }
2220         }
2221         spin_unlock_irqrestore(&queued_arr_lock, iflags);
2222 }
2223
2224 /* Initializes timers in queued array */
2225 static void __init init_all_queued(void)
2226 {
2227         unsigned long iflags;
2228         int k;
2229         struct sdebug_queued_cmd * sqcp;
2230
2231         spin_lock_irqsave(&queued_arr_lock, iflags);
2232         for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2233                 sqcp = &queued_arr[k];
2234                 init_timer(&sqcp->cmnd_timer);
2235                 sqcp->in_use = 0;
2236                 sqcp->a_cmnd = NULL;
2237         }
2238         spin_unlock_irqrestore(&queued_arr_lock, iflags);
2239 }
2240
2241 static void __init sdebug_build_parts(unsigned char * ramp)
2242 {
2243         struct partition * pp;
2244         int starts[SDEBUG_MAX_PARTS + 2];
2245         int sectors_per_part, num_sectors, k;
2246         int heads_by_sects, start_sec, end_sec;
2247
2248         /* assume partition table already zeroed */
2249         if ((scsi_debug_num_parts < 1) || (sdebug_store_size < 1048576))
2250                 return;
2251         if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) {
2252                 scsi_debug_num_parts = SDEBUG_MAX_PARTS;
2253                 printk(KERN_WARNING "scsi_debug:build_parts: reducing "
2254                                     "partitions to %d\n", SDEBUG_MAX_PARTS);
2255         }
2256         num_sectors = (int)sdebug_store_sectors;
2257         sectors_per_part = (num_sectors - sdebug_sectors_per)
2258                            / scsi_debug_num_parts;
2259         heads_by_sects = sdebug_heads * sdebug_sectors_per;
2260         starts[0] = sdebug_sectors_per;
2261         for (k = 1; k < scsi_debug_num_parts; ++k)
2262                 starts[k] = ((k * sectors_per_part) / heads_by_sects)
2263                             * heads_by_sects;
2264         starts[scsi_debug_num_parts] = num_sectors;
2265         starts[scsi_debug_num_parts + 1] = 0;
2266
2267         ramp[510] = 0x55;       /* magic partition markings */
2268         ramp[511] = 0xAA;
2269         pp = (struct partition *)(ramp + 0x1be);
2270         for (k = 0; starts[k + 1]; ++k, ++pp) {
2271                 start_sec = starts[k];
2272                 end_sec = starts[k + 1] - 1;
2273                 pp->boot_ind = 0;
2274
2275                 pp->cyl = start_sec / heads_by_sects;
2276                 pp->head = (start_sec - (pp->cyl * heads_by_sects))
2277                            / sdebug_sectors_per;
2278                 pp->sector = (start_sec % sdebug_sectors_per) + 1;
2279
2280                 pp->end_cyl = end_sec / heads_by_sects;
2281                 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
2282                                / sdebug_sectors_per;
2283                 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2284
2285                 pp->start_sect = start_sec;
2286                 pp->nr_sects = end_sec - start_sec + 1;
2287                 pp->sys_ind = 0x83;     /* plain Linux partition */
2288         }
2289 }
2290
2291 static int schedule_resp(struct scsi_cmnd * cmnd,
2292                          struct sdebug_dev_info * devip,
2293                          done_funct_t done, int scsi_result, int delta_jiff)
2294 {
2295         if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) {
2296                 if (scsi_result) {
2297                         struct scsi_device * sdp = cmnd->device;
2298
2299                         printk(KERN_INFO "scsi_debug:    <%u %u %u %u> "
2300                                "non-zero result=0x%x\n", sdp->host->host_no,
2301                                sdp->channel, sdp->id, sdp->lun, scsi_result);
2302                 }
2303         }
2304         if (cmnd && devip) {
2305                 /* simulate autosense by this driver */
2306                 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff))
2307                         memcpy(cmnd->sense_buffer, devip->sense_buff,
2308                                (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ?
2309                                SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE);
2310         }
2311         if (delta_jiff <= 0) {
2312                 if (cmnd)
2313                         cmnd->result = scsi_result;
2314                 if (done)
2315                         done(cmnd);
2316                 return 0;
2317         } else {
2318                 unsigned long iflags;
2319                 int k;
2320                 struct sdebug_queued_cmd * sqcp = NULL;
2321
2322                 spin_lock_irqsave(&queued_arr_lock, iflags);
2323                 for (k = 0; k < SCSI_DEBUG_CANQUEUE; ++k) {
2324                         sqcp = &queued_arr[k];
2325                         if (! sqcp->in_use)
2326                                 break;
2327                 }
2328                 if (k >= SCSI_DEBUG_CANQUEUE) {
2329                         spin_unlock_irqrestore(&queued_arr_lock, iflags);
2330                         printk(KERN_WARNING "scsi_debug: can_queue exceeded\n");
2331                         return 1;       /* report busy to mid level */
2332                 }
2333                 sqcp->in_use = 1;
2334                 sqcp->a_cmnd = cmnd;
2335                 sqcp->scsi_result = scsi_result;
2336                 sqcp->done_funct = done;
2337                 sqcp->cmnd_timer.function = timer_intr_handler;
2338                 sqcp->cmnd_timer.data = k;
2339                 sqcp->cmnd_timer.expires = jiffies + delta_jiff;
2340                 add_timer(&sqcp->cmnd_timer);
2341                 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2342                 if (cmnd)
2343                         cmnd->result = 0;
2344                 return 0;
2345         }
2346 }
2347
2348 /* Note: The following macros create attribute files in the
2349    /sys/module/scsi_debug/parameters directory. Unfortunately this
2350    driver is unaware of a change and cannot trigger auxiliary actions
2351    as it can when the corresponding attribute in the
2352    /sys/bus/pseudo/drivers/scsi_debug directory is changed.
2353  */
2354 module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR);
2355 module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR);
2356 module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO);
2357 module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR);
2358 module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR);
2359 module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR);
2360 module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR);
2361 module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR);
2362 module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO);
2363 module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR);
2364 module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR);
2365 module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR);
2366 module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO);
2367 module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR);
2368 module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int,
2369                    S_IRUGO | S_IWUSR);
2370
2371 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
2372 MODULE_DESCRIPTION("SCSI debug adapter driver");
2373 MODULE_LICENSE("GPL");
2374 MODULE_VERSION(SCSI_DEBUG_VERSION);
2375
2376 MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)");
2377 MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)");
2378 MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)");
2379 MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)");
2380 MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)");
2381 MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)");
2382 MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)");
2383 MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)");
2384 MODULE_PARM_DESC(num_parts, "number of partitions(def=0)");
2385 MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)");
2386 MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)");
2387 MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
2388 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
2389 MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
2390 MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2391
2392
2393 static char sdebug_info[256];
2394
2395 static const char * scsi_debug_info(struct Scsi_Host * shp)
2396 {
2397         sprintf(sdebug_info, "scsi_debug, version %s [%s], "
2398                 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION,
2399                 scsi_debug_version_date, scsi_debug_dev_size_mb,
2400                 scsi_debug_opts);
2401         return sdebug_info;
2402 }
2403
2404 /* scsi_debug_proc_info
2405  * Used if the driver currently has no own support for /proc/scsi
2406  */
2407 static int scsi_debug_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
2408                                 int length, int inout)
2409 {
2410         int len, pos, begin;
2411         int orig_length;
2412
2413         orig_length = length;
2414
2415         if (inout == 1) {
2416                 char arr[16];
2417                 int minLen = length > 15 ? 15 : length;
2418
2419                 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
2420                         return -EACCES;
2421                 memcpy(arr, buffer, minLen);
2422                 arr[minLen] = '\0';
2423                 if (1 != sscanf(arr, "%d", &pos))
2424                         return -EINVAL;
2425                 scsi_debug_opts = pos;
2426                 if (scsi_debug_every_nth != 0)
2427                         scsi_debug_cmnd_count = 0;
2428                 return length;
2429         }
2430         begin = 0;
2431         pos = len = sprintf(buffer, "scsi_debug adapter driver, version "
2432             "%s [%s]\n"
2433             "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2434             "every_nth=%d(curr:%d)\n"
2435             "delay=%d, max_luns=%d, scsi_level=%d\n"
2436             "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2437             "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2438             "host_resets=%d\n",
2439             SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts,
2440             scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2441             scsi_debug_cmnd_count, scsi_debug_delay,
2442             scsi_debug_max_luns, scsi_debug_scsi_level,
2443             SECT_SIZE, sdebug_cylinders_per, sdebug_heads, sdebug_sectors_per,
2444             num_aborts, num_dev_resets, num_bus_resets, num_host_resets);
2445         if (pos < offset) {
2446                 len = 0;
2447                 begin = pos;
2448         }
2449         *start = buffer + (offset - begin);     /* Start of wanted data */
2450         len -= (offset - begin);
2451         if (len > length)
2452                 len = length;
2453         return len;
2454 }
2455
2456 static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf)
2457 {
2458         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay);
2459 }
2460
2461 static ssize_t sdebug_delay_store(struct device_driver * ddp,
2462                                   const char * buf, size_t count)
2463 {
2464         int delay;
2465         char work[20];
2466
2467         if (1 == sscanf(buf, "%10s", work)) {
2468                 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) {
2469                         scsi_debug_delay = delay;
2470                         return count;
2471                 }
2472         }
2473         return -EINVAL;
2474 }
2475 DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show,
2476             sdebug_delay_store);
2477
2478 static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf)
2479 {
2480         return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts);
2481 }
2482
2483 static ssize_t sdebug_opts_store(struct device_driver * ddp,
2484                                  const char * buf, size_t count)
2485 {
2486         int opts;
2487         char work[20];
2488
2489         if (1 == sscanf(buf, "%10s", work)) {
2490                 if (0 == strnicmp(work,"0x", 2)) {
2491                         if (1 == sscanf(&work[2], "%x", &opts))
2492                                 goto opts_done;
2493                 } else {
2494                         if (1 == sscanf(work, "%d", &opts))
2495                                 goto opts_done;
2496                 }
2497         }
2498         return -EINVAL;
2499 opts_done:
2500         scsi_debug_opts = opts;
2501         scsi_debug_cmnd_count = 0;
2502         return count;
2503 }
2504 DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show,
2505             sdebug_opts_store);
2506
2507 static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf)
2508 {
2509         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype);
2510 }
2511 static ssize_t sdebug_ptype_store(struct device_driver * ddp,
2512                                   const char * buf, size_t count)
2513 {
2514         int n;
2515
2516         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2517                 scsi_debug_ptype = n;
2518                 return count;
2519         }
2520         return -EINVAL;
2521 }
2522 DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store);
2523
2524 static ssize_t sdebug_dsense_show(struct device_driver * ddp, char * buf)
2525 {
2526         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense);
2527 }
2528 static ssize_t sdebug_dsense_store(struct device_driver * ddp,
2529                                   const char * buf, size_t count)
2530 {
2531         int n;
2532
2533         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2534                 scsi_debug_dsense = n;
2535                 return count;
2536         }
2537         return -EINVAL;
2538 }
2539 DRIVER_ATTR(dsense, S_IRUGO | S_IWUSR, sdebug_dsense_show,
2540             sdebug_dsense_store);
2541
2542 static ssize_t sdebug_fake_rw_show(struct device_driver * ddp, char * buf)
2543 {
2544         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw);
2545 }
2546 static ssize_t sdebug_fake_rw_store(struct device_driver * ddp,
2547                                     const char * buf, size_t count)
2548 {
2549         int n;
2550
2551         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2552                 scsi_debug_fake_rw = n;
2553                 return count;
2554         }
2555         return -EINVAL;
2556 }
2557 DRIVER_ATTR(fake_rw, S_IRUGO | S_IWUSR, sdebug_fake_rw_show,
2558             sdebug_fake_rw_store);
2559
2560 static ssize_t sdebug_no_lun_0_show(struct device_driver * ddp, char * buf)
2561 {
2562         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0);
2563 }
2564 static ssize_t sdebug_no_lun_0_store(struct device_driver * ddp,
2565                                      const char * buf, size_t count)
2566 {
2567         int n;
2568
2569         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2570                 scsi_debug_no_lun_0 = n;
2571                 return count;
2572         }
2573         return -EINVAL;
2574 }
2575 DRIVER_ATTR(no_lun_0, S_IRUGO | S_IWUSR, sdebug_no_lun_0_show,
2576             sdebug_no_lun_0_store);
2577
2578 static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf)
2579 {
2580         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts);
2581 }
2582 static ssize_t sdebug_num_tgts_store(struct device_driver * ddp,
2583                                      const char * buf, size_t count)
2584 {
2585         int n;
2586
2587         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2588                 scsi_debug_num_tgts = n;
2589                 sdebug_max_tgts_luns();
2590                 return count;
2591         }
2592         return -EINVAL;
2593 }
2594 DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show,
2595             sdebug_num_tgts_store);
2596
2597 static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf)
2598 {
2599         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb);
2600 }
2601 DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL);
2602
2603 static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf)
2604 {
2605         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts);
2606 }
2607 DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL);
2608
2609 static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf)
2610 {
2611         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth);
2612 }
2613 static ssize_t sdebug_every_nth_store(struct device_driver * ddp,
2614                                       const char * buf, size_t count)
2615 {
2616         int nth;
2617
2618         if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) {
2619                 scsi_debug_every_nth = nth;
2620                 scsi_debug_cmnd_count = 0;
2621                 return count;
2622         }
2623         return -EINVAL;
2624 }
2625 DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show,
2626             sdebug_every_nth_store);
2627
2628 static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf)
2629 {
2630         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns);
2631 }
2632 static ssize_t sdebug_max_luns_store(struct device_driver * ddp,
2633                                      const char * buf, size_t count)
2634 {
2635         int n;
2636
2637         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2638                 scsi_debug_max_luns = n;
2639                 sdebug_max_tgts_luns();
2640                 return count;
2641         }
2642         return -EINVAL;
2643 }
2644 DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show,
2645             sdebug_max_luns_store);
2646
2647 static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf)
2648 {
2649         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level);
2650 }
2651 DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL);
2652
2653 static ssize_t sdebug_virtual_gb_show(struct device_driver * ddp, char * buf)
2654 {
2655         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb);
2656 }
2657 static ssize_t sdebug_virtual_gb_store(struct device_driver * ddp,
2658                                        const char * buf, size_t count)
2659 {
2660         int n;
2661
2662         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2663                 scsi_debug_virtual_gb = n;
2664                 if (scsi_debug_virtual_gb > 0) {
2665                         sdebug_capacity = 2048 * 1024;
2666                         sdebug_capacity *= scsi_debug_virtual_gb;
2667                 } else
2668                         sdebug_capacity = sdebug_store_sectors;
2669                 return count;
2670         }
2671         return -EINVAL;
2672 }
2673 DRIVER_ATTR(virtual_gb, S_IRUGO | S_IWUSR, sdebug_virtual_gb_show,
2674             sdebug_virtual_gb_store);
2675
2676 static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf)
2677 {
2678         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host);
2679 }
2680
2681 static ssize_t sdebug_add_host_store(struct device_driver * ddp,
2682                                      const char * buf, size_t count)
2683 {
2684         int delta_hosts;
2685
2686         if (sscanf(buf, "%d", &delta_hosts) != 1)
2687                 return -EINVAL;
2688         if (delta_hosts > 0) {
2689                 do {
2690                         sdebug_add_adapter();
2691                 } while (--delta_hosts);
2692         } else if (delta_hosts < 0) {
2693                 do {
2694                         sdebug_remove_adapter();
2695                 } while (++delta_hosts);
2696         }
2697         return count;
2698 }
2699 DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show,
2700             sdebug_add_host_store);
2701
2702 static ssize_t sdebug_vpd_use_hostno_show(struct device_driver * ddp,
2703                                           char * buf)
2704 {
2705         return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno);
2706 }
2707 static ssize_t sdebug_vpd_use_hostno_store(struct device_driver * ddp,
2708                                            const char * buf, size_t count)
2709 {
2710         int n;
2711
2712         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
2713                 scsi_debug_vpd_use_hostno = n;
2714                 return count;
2715         }
2716         return -EINVAL;
2717 }
2718 DRIVER_ATTR(vpd_use_hostno, S_IRUGO | S_IWUSR, sdebug_vpd_use_hostno_show,
2719             sdebug_vpd_use_hostno_store);
2720
2721 /* Note: The following function creates attribute files in the
2722    /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
2723    files (over those found in the /sys/module/scsi_debug/parameters
2724    directory) is that auxiliary actions can be triggered when an attribute
2725    is changed. For example see: sdebug_add_host_store() above.
2726  */
2727 static int do_create_driverfs_files(void)
2728 {
2729         int ret;
2730
2731         ret = driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2732         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay);
2733         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2734         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2735         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2736         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2737         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2738         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2739         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2740         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2741         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2742         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts);
2743         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2744         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2745         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2746         return ret;
2747 }
2748
2749 static void do_remove_driverfs_files(void)
2750 {
2751         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno);
2752         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb);
2753         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level);
2754         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts);
2755         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype);
2756         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts);
2757         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts);
2758         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0);
2759         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns);
2760         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_fake_rw);
2761         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth);
2762         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dsense);
2763         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb);
2764         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay);
2765         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host);
2766 }
2767
2768 static int __init scsi_debug_init(void)
2769 {
2770         unsigned int sz;
2771         int host_to_add;
2772         int k;
2773         int ret;
2774
2775         if (scsi_debug_dev_size_mb < 1)
2776                 scsi_debug_dev_size_mb = 1;  /* force minimum 1 MB ramdisk */
2777         sdebug_store_size = (unsigned int)scsi_debug_dev_size_mb * 1048576;
2778         sdebug_store_sectors = sdebug_store_size / SECT_SIZE;
2779         if (scsi_debug_virtual_gb > 0) {
2780                 sdebug_capacity = 2048 * 1024;
2781                 sdebug_capacity *= scsi_debug_virtual_gb;
2782         } else
2783                 sdebug_capacity = sdebug_store_sectors;
2784
2785         /* play around with geometry, don't waste too much on track 0 */
2786         sdebug_heads = 8;
2787         sdebug_sectors_per = 32;
2788         if (scsi_debug_dev_size_mb >= 16)
2789                 sdebug_heads = 32;
2790         else if (scsi_debug_dev_size_mb >= 256)
2791                 sdebug_heads = 64;
2792         sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2793                                (sdebug_sectors_per * sdebug_heads);
2794         if (sdebug_cylinders_per >= 1024) {
2795                 /* other LLDs do this; implies >= 1GB ram disk ... */
2796                 sdebug_heads = 255;
2797                 sdebug_sectors_per = 63;
2798                 sdebug_cylinders_per = (unsigned long)sdebug_capacity /
2799                                (sdebug_sectors_per * sdebug_heads);
2800         }
2801
2802         sz = sdebug_store_size;
2803         fake_storep = vmalloc(sz);
2804         if (NULL == fake_storep) {
2805                 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n");
2806                 return -ENOMEM;
2807         }
2808         memset(fake_storep, 0, sz);
2809         if (scsi_debug_num_parts > 0)
2810                 sdebug_build_parts(fake_storep);
2811
2812         ret = device_register(&pseudo_primary);
2813         if (ret < 0) {
2814                 printk(KERN_WARNING "scsi_debug: device_register error: %d\n",
2815                         ret);
2816                 goto free_vm;
2817         }
2818         ret = bus_register(&pseudo_lld_bus);
2819         if (ret < 0) {
2820                 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n",
2821                         ret);
2822                 goto dev_unreg;
2823         }
2824         ret = driver_register(&sdebug_driverfs_driver);
2825         if (ret < 0) {
2826                 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n",
2827                         ret);
2828                 goto bus_unreg;
2829         }
2830         ret = do_create_driverfs_files();
2831         if (ret < 0) {
2832                 printk(KERN_WARNING "scsi_debug: driver_create_file error: %d\n",
2833                         ret);
2834                 goto del_files;
2835         }
2836
2837         init_all_queued();
2838
2839         host_to_add = scsi_debug_add_host;
2840         scsi_debug_add_host = 0;
2841
2842         for (k = 0; k < host_to_add; k++) {
2843                 if (sdebug_add_adapter()) {
2844                         printk(KERN_ERR "scsi_debug_init: "
2845                                "sdebug_add_adapter failed k=%d\n", k);
2846                         break;
2847                 }
2848         }
2849
2850         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) {
2851                 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n",
2852                        scsi_debug_add_host);
2853         }
2854         return 0;
2855
2856 del_files:
2857         do_remove_driverfs_files();
2858         driver_unregister(&sdebug_driverfs_driver);
2859 bus_unreg:
2860         bus_unregister(&pseudo_lld_bus);
2861 dev_unreg:
2862         device_unregister(&pseudo_primary);
2863 free_vm:
2864         vfree(fake_storep);
2865
2866         return ret;
2867 }
2868
2869 static void __exit scsi_debug_exit(void)
2870 {
2871         int k = scsi_debug_add_host;
2872
2873         stop_all_queued();
2874         for (; k; k--)
2875                 sdebug_remove_adapter();
2876         do_remove_driverfs_files();
2877         driver_unregister(&sdebug_driverfs_driver);
2878         bus_unregister(&pseudo_lld_bus);
2879         device_unregister(&pseudo_primary);
2880
2881         vfree(fake_storep);
2882 }
2883
2884 device_initcall(scsi_debug_init);
2885 module_exit(scsi_debug_exit);
2886
2887 static void pseudo_0_release(struct device * dev)
2888 {
2889         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
2890                 printk(KERN_INFO "scsi_debug: pseudo_0_release() called\n");
2891 }
2892
2893 static struct device pseudo_primary = {
2894         .bus_id         = "pseudo_0",
2895         .release        = pseudo_0_release,
2896 };
2897
2898 static int pseudo_lld_bus_match(struct device *dev,
2899                           struct device_driver *dev_driver)
2900 {
2901         return 1;
2902 }
2903
2904 static struct bus_type pseudo_lld_bus = {
2905         .name = "pseudo",
2906         .match = pseudo_lld_bus_match,
2907         .probe = sdebug_driver_probe,
2908         .remove = sdebug_driver_remove,
2909 };
2910
2911 static void sdebug_release_adapter(struct device * dev)
2912 {
2913         struct sdebug_host_info *sdbg_host;
2914
2915         sdbg_host = to_sdebug_host(dev);
2916         kfree(sdbg_host);
2917 }
2918
2919 static int sdebug_add_adapter(void)
2920 {
2921         int k, devs_per_host;
2922         int error = 0;
2923         struct sdebug_host_info *sdbg_host;
2924         struct sdebug_dev_info *sdbg_devinfo;
2925         struct list_head *lh, *lh_sf;
2926
2927         sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL);
2928         if (NULL == sdbg_host) {
2929                 printk(KERN_ERR "%s: out of memory at line %d\n",
2930                        __FUNCTION__, __LINE__);
2931                 return -ENOMEM;
2932         }
2933
2934         INIT_LIST_HEAD(&sdbg_host->dev_info_list);
2935
2936         devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
2937         for (k = 0; k < devs_per_host; k++) {
2938                 sdbg_devinfo = kzalloc(sizeof(*sdbg_devinfo),GFP_KERNEL);
2939                 if (NULL == sdbg_devinfo) {
2940                         printk(KERN_ERR "%s: out of memory at line %d\n",
2941                                __FUNCTION__, __LINE__);
2942                         error = -ENOMEM;
2943                         goto clean;
2944                 }
2945                 sdbg_devinfo->sdbg_host = sdbg_host;
2946                 list_add_tail(&sdbg_devinfo->dev_list,
2947                               &sdbg_host->dev_info_list);
2948         }
2949
2950         spin_lock(&sdebug_host_list_lock);
2951         list_add_tail(&sdbg_host->host_list, &sdebug_host_list);
2952         spin_unlock(&sdebug_host_list_lock);
2953
2954         sdbg_host->dev.bus = &pseudo_lld_bus;
2955         sdbg_host->dev.parent = &pseudo_primary;
2956         sdbg_host->dev.release = &sdebug_release_adapter;
2957         sprintf(sdbg_host->dev.bus_id, "adapter%d", scsi_debug_add_host);
2958
2959         error = device_register(&sdbg_host->dev);
2960
2961         if (error)
2962                 goto clean;
2963
2964         ++scsi_debug_add_host;
2965         return error;
2966
2967 clean:
2968         list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
2969                 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
2970                                           dev_list);
2971                 list_del(&sdbg_devinfo->dev_list);
2972                 kfree(sdbg_devinfo);
2973         }
2974
2975         kfree(sdbg_host);
2976         return error;
2977 }
2978
2979 static void sdebug_remove_adapter(void)
2980 {
2981         struct sdebug_host_info * sdbg_host = NULL;
2982
2983         spin_lock(&sdebug_host_list_lock);
2984         if (!list_empty(&sdebug_host_list)) {
2985                 sdbg_host = list_entry(sdebug_host_list.prev,
2986                                        struct sdebug_host_info, host_list);
2987                 list_del(&sdbg_host->host_list);
2988         }
2989         spin_unlock(&sdebug_host_list_lock);
2990
2991         if (!sdbg_host)
2992                 return;
2993
2994         device_unregister(&sdbg_host->dev);
2995         --scsi_debug_add_host;
2996 }
2997
2998 static struct scsi_host_template sdebug_driver_template = {
2999         .proc_info =            scsi_debug_proc_info,
3000         .proc_name =            sdebug_proc_name,
3001         .name =                 "SCSI DEBUG",
3002         .info =                 scsi_debug_info,
3003         .slave_alloc =          scsi_debug_slave_alloc,
3004         .slave_configure =      scsi_debug_slave_configure,
3005         .slave_destroy =        scsi_debug_slave_destroy,
3006         .ioctl =                scsi_debug_ioctl,
3007         .queuecommand =         scsi_debug_queuecommand,
3008         .eh_abort_handler =     scsi_debug_abort,
3009         .eh_bus_reset_handler = scsi_debug_bus_reset,
3010         .eh_device_reset_handler = scsi_debug_device_reset,
3011         .eh_host_reset_handler = scsi_debug_host_reset,
3012         .bios_param =           scsi_debug_biosparam,
3013         .can_queue =            SCSI_DEBUG_CANQUEUE,
3014         .this_id =              7,
3015         .sg_tablesize =         256,
3016         .cmd_per_lun =          16,
3017         .max_sectors =          0xffff,
3018         .use_clustering =       DISABLE_CLUSTERING,
3019         .module =               THIS_MODULE,
3020 };
3021
3022 static int sdebug_driver_probe(struct device * dev)
3023 {
3024         int error = 0;
3025         struct sdebug_host_info *sdbg_host;
3026         struct Scsi_Host *hpnt;
3027
3028         sdbg_host = to_sdebug_host(dev);
3029
3030         hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host));
3031         if (NULL == hpnt) {
3032                 printk(KERN_ERR "%s: scsi_register failed\n", __FUNCTION__);
3033                 error = -ENODEV;
3034                 return error;
3035         }
3036
3037         sdbg_host->shost = hpnt;
3038         *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host;
3039         if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id))
3040                 hpnt->max_id = scsi_debug_num_tgts + 1;
3041         else
3042                 hpnt->max_id = scsi_debug_num_tgts;
3043         hpnt->max_lun = SAM2_WLUN_REPORT_LUNS;  /* = scsi_debug_max_luns; */
3044
3045         error = scsi_add_host(hpnt, &sdbg_host->dev);
3046         if (error) {
3047                 printk(KERN_ERR "%s: scsi_add_host failed\n", __FUNCTION__);
3048                 error = -ENODEV;
3049                 scsi_host_put(hpnt);
3050         } else
3051                 scsi_scan_host(hpnt);
3052
3053
3054         return error;
3055 }
3056
3057 static int sdebug_driver_remove(struct device * dev)
3058 {
3059         struct list_head *lh, *lh_sf;
3060         struct sdebug_host_info *sdbg_host;
3061         struct sdebug_dev_info *sdbg_devinfo;
3062
3063         sdbg_host = to_sdebug_host(dev);
3064
3065         if (!sdbg_host) {
3066                 printk(KERN_ERR "%s: Unable to locate host info\n",
3067                        __FUNCTION__);
3068                 return -ENODEV;
3069         }
3070
3071         scsi_remove_host(sdbg_host->shost);
3072
3073         list_for_each_safe(lh, lh_sf, &sdbg_host->dev_info_list) {
3074                 sdbg_devinfo = list_entry(lh, struct sdebug_dev_info,
3075                                           dev_list);
3076                 list_del(&sdbg_devinfo->dev_list);
3077                 kfree(sdbg_devinfo);
3078         }
3079
3080         scsi_host_put(sdbg_host->shost);
3081         return 0;
3082 }
3083
3084 static void sdebug_max_tgts_luns(void)
3085 {
3086         struct sdebug_host_info * sdbg_host;
3087         struct Scsi_Host *hpnt;
3088
3089         spin_lock(&sdebug_host_list_lock);
3090         list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) {
3091                 hpnt = sdbg_host->shost;
3092                 if ((hpnt->this_id >= 0) &&
3093                     (scsi_debug_num_tgts > hpnt->this_id))
3094                         hpnt->max_id = scsi_debug_num_tgts + 1;
3095                 else
3096                         hpnt->max_id = scsi_debug_num_tgts;
3097                 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* scsi_debug_max_luns; */
3098         }
3099         spin_unlock(&sdebug_host_list_lock);
3100 }