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