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