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://sg.danny.cz/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/slab.h> 34 #include <linux/types.h> 35 #include <linux/string.h> 36 #include <linux/genhd.h> 37 #include <linux/fs.h> 38 #include <linux/init.h> 39 #include <linux/proc_fs.h> 40 #include <linux/vmalloc.h> 41 #include <linux/moduleparam.h> 42 #include <linux/scatterlist.h> 43 #include <linux/blkdev.h> 44 #include <linux/crc-t10dif.h> 45 46 #include <net/checksum.h> 47 48 #include <asm/unaligned.h> 49 50 #include <scsi/scsi.h> 51 #include <scsi/scsi_cmnd.h> 52 #include <scsi/scsi_device.h> 53 #include <scsi/scsi_host.h> 54 #include <scsi/scsicam.h> 55 #include <scsi/scsi_eh.h> 56 #include <scsi/scsi_dbg.h> 57 58 #include "sd.h" 59 #include "scsi_logging.h" 60 61 #define SCSI_DEBUG_VERSION "1.82" 62 static const char * scsi_debug_version_date = "20100324"; 63 64 /* Additional Sense Code (ASC) */ 65 #define NO_ADDITIONAL_SENSE 0x0 66 #define LOGICAL_UNIT_NOT_READY 0x4 67 #define UNRECOVERED_READ_ERR 0x11 68 #define PARAMETER_LIST_LENGTH_ERR 0x1a 69 #define INVALID_OPCODE 0x20 70 #define ADDR_OUT_OF_RANGE 0x21 71 #define INVALID_COMMAND_OPCODE 0x20 72 #define INVALID_FIELD_IN_CDB 0x24 73 #define INVALID_FIELD_IN_PARAM_LIST 0x26 74 #define POWERON_RESET 0x29 75 #define SAVING_PARAMS_UNSUP 0x39 76 #define TRANSPORT_PROBLEM 0x4b 77 #define THRESHOLD_EXCEEDED 0x5d 78 #define LOW_POWER_COND_ON 0x5e 79 80 /* Additional Sense Code Qualifier (ASCQ) */ 81 #define ACK_NAK_TO 0x3 82 83 #define SDEBUG_TAGGED_QUEUING 0 /* 0 | MSG_SIMPLE_TAG | MSG_ORDERED_TAG */ 84 85 /* Default values for driver parameters */ 86 #define DEF_NUM_HOST 1 87 #define DEF_NUM_TGTS 1 88 #define DEF_MAX_LUNS 1 89 /* With these defaults, this driver will make 1 host with 1 target 90 * (id 0) containing 1 logical unit (lun 0). That is 1 device. 91 */ 92 #define DEF_DELAY 1 93 #define DEF_DEV_SIZE_MB 8 94 #define DEF_EVERY_NTH 0 95 #define DEF_NUM_PARTS 0 96 #define DEF_OPTS 0 97 #define DEF_SCSI_LEVEL 5 /* INQUIRY, byte2 [5->SPC-3] */ 98 #define DEF_PTYPE 0 99 #define DEF_D_SENSE 0 100 #define DEF_NO_LUN_0 0 101 #define DEF_VIRTUAL_GB 0 102 #define DEF_FAKE_RW 0 103 #define DEF_VPD_USE_HOSTNO 1 104 #define DEF_SECTOR_SIZE 512 105 #define DEF_DIX 0 106 #define DEF_DIF 0 107 #define DEF_GUARD 0 108 #define DEF_ATO 1 109 #define DEF_PHYSBLK_EXP 0 110 #define DEF_LOWEST_ALIGNED 0 111 #define DEF_OPT_BLKS 64 112 #define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF 113 #define DEF_UNMAP_MAX_DESC 256 114 #define DEF_UNMAP_GRANULARITY 1 115 #define DEF_UNMAP_ALIGNMENT 0 116 #define DEF_TPWS 0 117 #define DEF_TPU 0 118 119 /* bit mask values for scsi_debug_opts */ 120 #define SCSI_DEBUG_OPT_NOISE 1 121 #define SCSI_DEBUG_OPT_MEDIUM_ERR 2 122 #define SCSI_DEBUG_OPT_TIMEOUT 4 123 #define SCSI_DEBUG_OPT_RECOVERED_ERR 8 124 #define SCSI_DEBUG_OPT_TRANSPORT_ERR 16 125 #define SCSI_DEBUG_OPT_DIF_ERR 32 126 #define SCSI_DEBUG_OPT_DIX_ERR 64 127 /* When "every_nth" > 0 then modulo "every_nth" commands: 128 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set 129 * - a RECOVERED_ERROR is simulated on successful read and write 130 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set. 131 * - a TRANSPORT_ERROR is simulated on successful read and write 132 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set. 133 * 134 * When "every_nth" < 0 then after "- every_nth" commands: 135 * - a no response is simulated if SCSI_DEBUG_OPT_TIMEOUT is set 136 * - a RECOVERED_ERROR is simulated on successful read and write 137 * commands if SCSI_DEBUG_OPT_RECOVERED_ERR is set. 138 * - a TRANSPORT_ERROR is simulated on successful read and write 139 * commands if SCSI_DEBUG_OPT_TRANSPORT_ERR is set. 140 * This will continue until some other action occurs (e.g. the user 141 * writing a new value (other than -1 or 1) to every_nth via sysfs). 142 */ 143 144 /* when 1==SCSI_DEBUG_OPT_MEDIUM_ERR, a medium error is simulated at this 145 * sector on read commands: */ 146 #define OPT_MEDIUM_ERR_ADDR 0x1234 /* that's sector 4660 in decimal */ 147 148 /* If REPORT LUNS has luns >= 256 it can choose "flat space" (value 1) 149 * or "peripheral device" addressing (value 0) */ 150 #define SAM2_LUN_ADDRESS_METHOD 0 151 #define SAM2_WLUN_REPORT_LUNS 0xc101 152 153 /* Can queue up to this number of commands. Typically commands that 154 * that have a non-zero delay are queued. */ 155 #define SCSI_DEBUG_CANQUEUE 255 156 157 static int scsi_debug_add_host = DEF_NUM_HOST; 158 static int scsi_debug_delay = DEF_DELAY; 159 static int scsi_debug_dev_size_mb = DEF_DEV_SIZE_MB; 160 static int scsi_debug_every_nth = DEF_EVERY_NTH; 161 static int scsi_debug_max_luns = DEF_MAX_LUNS; 162 static int scsi_debug_max_queue = SCSI_DEBUG_CANQUEUE; 163 static int scsi_debug_num_parts = DEF_NUM_PARTS; 164 static int scsi_debug_no_uld = 0; 165 static int scsi_debug_num_tgts = DEF_NUM_TGTS; /* targets per host */ 166 static int scsi_debug_opts = DEF_OPTS; 167 static int scsi_debug_scsi_level = DEF_SCSI_LEVEL; 168 static int scsi_debug_ptype = DEF_PTYPE; /* SCSI peripheral type (0==disk) */ 169 static int scsi_debug_dsense = DEF_D_SENSE; 170 static int scsi_debug_no_lun_0 = DEF_NO_LUN_0; 171 static int scsi_debug_virtual_gb = DEF_VIRTUAL_GB; 172 static int scsi_debug_fake_rw = DEF_FAKE_RW; 173 static int scsi_debug_vpd_use_hostno = DEF_VPD_USE_HOSTNO; 174 static int scsi_debug_sector_size = DEF_SECTOR_SIZE; 175 static int scsi_debug_dix = DEF_DIX; 176 static int scsi_debug_dif = DEF_DIF; 177 static int scsi_debug_guard = DEF_GUARD; 178 static int scsi_debug_ato = DEF_ATO; 179 static int scsi_debug_physblk_exp = DEF_PHYSBLK_EXP; 180 static int scsi_debug_lowest_aligned = DEF_LOWEST_ALIGNED; 181 static int scsi_debug_opt_blks = DEF_OPT_BLKS; 182 static unsigned int scsi_debug_unmap_max_desc = DEF_UNMAP_MAX_DESC; 183 static unsigned int scsi_debug_unmap_max_blocks = DEF_UNMAP_MAX_BLOCKS; 184 static unsigned int scsi_debug_unmap_granularity = DEF_UNMAP_GRANULARITY; 185 static unsigned int scsi_debug_unmap_alignment = DEF_UNMAP_ALIGNMENT; 186 static unsigned int scsi_debug_tpws = DEF_TPWS; 187 static unsigned int scsi_debug_tpu = DEF_TPU; 188 189 static int scsi_debug_cmnd_count = 0; 190 191 #define DEV_READONLY(TGT) (0) 192 #define DEV_REMOVEABLE(TGT) (0) 193 194 static unsigned int sdebug_store_sectors; 195 static sector_t sdebug_capacity; /* in sectors */ 196 197 /* old BIOS stuff, kernel may get rid of them but some mode sense pages 198 may still need them */ 199 static int sdebug_heads; /* heads per disk */ 200 static int sdebug_cylinders_per; /* cylinders per surface */ 201 static int sdebug_sectors_per; /* sectors per cylinder */ 202 203 #define SDEBUG_MAX_PARTS 4 204 205 #define SDEBUG_SENSE_LEN 32 206 207 #define SCSI_DEBUG_MAX_CMD_LEN 32 208 209 struct sdebug_dev_info { 210 struct list_head dev_list; 211 unsigned char sense_buff[SDEBUG_SENSE_LEN]; /* weak nexus */ 212 unsigned int channel; 213 unsigned int target; 214 unsigned int lun; 215 struct sdebug_host_info *sdbg_host; 216 unsigned int wlun; 217 char reset; 218 char stopped; 219 char used; 220 }; 221 222 struct sdebug_host_info { 223 struct list_head host_list; 224 struct Scsi_Host *shost; 225 struct device dev; 226 struct list_head dev_info_list; 227 }; 228 229 #define to_sdebug_host(d) \ 230 container_of(d, struct sdebug_host_info, dev) 231 232 static LIST_HEAD(sdebug_host_list); 233 static DEFINE_SPINLOCK(sdebug_host_list_lock); 234 235 typedef void (* done_funct_t) (struct scsi_cmnd *); 236 237 struct sdebug_queued_cmd { 238 int in_use; 239 struct timer_list cmnd_timer; 240 done_funct_t done_funct; 241 struct scsi_cmnd * a_cmnd; 242 int scsi_result; 243 }; 244 static struct sdebug_queued_cmd queued_arr[SCSI_DEBUG_CANQUEUE]; 245 246 static unsigned char * fake_storep; /* ramdisk storage */ 247 static unsigned char *dif_storep; /* protection info */ 248 static void *map_storep; /* provisioning map */ 249 250 static unsigned long map_size; 251 static int num_aborts = 0; 252 static int num_dev_resets = 0; 253 static int num_bus_resets = 0; 254 static int num_host_resets = 0; 255 static int dix_writes; 256 static int dix_reads; 257 static int dif_errors; 258 259 static DEFINE_SPINLOCK(queued_arr_lock); 260 static DEFINE_RWLOCK(atomic_rw); 261 262 static char sdebug_proc_name[] = "scsi_debug"; 263 264 static struct bus_type pseudo_lld_bus; 265 266 static inline sector_t dif_offset(sector_t sector) 267 { 268 return sector << 3; 269 } 270 271 static struct device_driver sdebug_driverfs_driver = { 272 .name = sdebug_proc_name, 273 .bus = &pseudo_lld_bus, 274 }; 275 276 static const int check_condition_result = 277 (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION; 278 279 static const int illegal_condition_result = 280 (DRIVER_SENSE << 24) | (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION; 281 282 static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0, 283 0, 0, 0x2, 0x4b}; 284 static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0, 285 0, 0, 0x0, 0x0}; 286 287 static int sdebug_add_adapter(void); 288 static void sdebug_remove_adapter(void); 289 290 static void sdebug_max_tgts_luns(void) 291 { 292 struct sdebug_host_info *sdbg_host; 293 struct Scsi_Host *hpnt; 294 295 spin_lock(&sdebug_host_list_lock); 296 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) { 297 hpnt = sdbg_host->shost; 298 if ((hpnt->this_id >= 0) && 299 (scsi_debug_num_tgts > hpnt->this_id)) 300 hpnt->max_id = scsi_debug_num_tgts + 1; 301 else 302 hpnt->max_id = scsi_debug_num_tgts; 303 /* scsi_debug_max_luns; */ 304 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; 305 } 306 spin_unlock(&sdebug_host_list_lock); 307 } 308 309 static void mk_sense_buffer(struct sdebug_dev_info *devip, int key, 310 int asc, int asq) 311 { 312 unsigned char *sbuff; 313 314 sbuff = devip->sense_buff; 315 memset(sbuff, 0, SDEBUG_SENSE_LEN); 316 317 scsi_build_sense_buffer(scsi_debug_dsense, sbuff, key, asc, asq); 318 319 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 320 printk(KERN_INFO "scsi_debug: [sense_key,asc,ascq]: " 321 "[0x%x,0x%x,0x%x]\n", key, asc, asq); 322 } 323 324 static void get_data_transfer_info(unsigned char *cmd, 325 unsigned long long *lba, unsigned int *num, 326 u32 *ei_lba) 327 { 328 *ei_lba = 0; 329 330 switch (*cmd) { 331 case VARIABLE_LENGTH_CMD: 332 *lba = (u64)cmd[19] | (u64)cmd[18] << 8 | 333 (u64)cmd[17] << 16 | (u64)cmd[16] << 24 | 334 (u64)cmd[15] << 32 | (u64)cmd[14] << 40 | 335 (u64)cmd[13] << 48 | (u64)cmd[12] << 56; 336 337 *ei_lba = (u32)cmd[23] | (u32)cmd[22] << 8 | 338 (u32)cmd[21] << 16 | (u32)cmd[20] << 24; 339 340 *num = (u32)cmd[31] | (u32)cmd[30] << 8 | (u32)cmd[29] << 16 | 341 (u32)cmd[28] << 24; 342 break; 343 344 case WRITE_SAME_16: 345 case WRITE_16: 346 case READ_16: 347 *lba = (u64)cmd[9] | (u64)cmd[8] << 8 | 348 (u64)cmd[7] << 16 | (u64)cmd[6] << 24 | 349 (u64)cmd[5] << 32 | (u64)cmd[4] << 40 | 350 (u64)cmd[3] << 48 | (u64)cmd[2] << 56; 351 352 *num = (u32)cmd[13] | (u32)cmd[12] << 8 | (u32)cmd[11] << 16 | 353 (u32)cmd[10] << 24; 354 break; 355 case WRITE_12: 356 case READ_12: 357 *lba = (u32)cmd[5] | (u32)cmd[4] << 8 | (u32)cmd[3] << 16 | 358 (u32)cmd[2] << 24; 359 360 *num = (u32)cmd[9] | (u32)cmd[8] << 8 | (u32)cmd[7] << 16 | 361 (u32)cmd[6] << 24; 362 break; 363 case WRITE_SAME: 364 case WRITE_10: 365 case READ_10: 366 case XDWRITEREAD_10: 367 *lba = (u32)cmd[5] | (u32)cmd[4] << 8 | (u32)cmd[3] << 16 | 368 (u32)cmd[2] << 24; 369 370 *num = (u32)cmd[8] | (u32)cmd[7] << 8; 371 break; 372 case WRITE_6: 373 case READ_6: 374 *lba = (u32)cmd[3] | (u32)cmd[2] << 8 | 375 (u32)(cmd[1] & 0x1f) << 16; 376 *num = (0 == cmd[4]) ? 256 : cmd[4]; 377 break; 378 default: 379 break; 380 } 381 } 382 383 static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg) 384 { 385 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) { 386 printk(KERN_INFO "scsi_debug: ioctl: cmd=0x%x\n", cmd); 387 } 388 return -EINVAL; 389 /* return -ENOTTY; // correct return but upsets fdisk */ 390 } 391 392 static int check_readiness(struct scsi_cmnd * SCpnt, int reset_only, 393 struct sdebug_dev_info * devip) 394 { 395 if (devip->reset) { 396 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 397 printk(KERN_INFO "scsi_debug: Reporting Unit " 398 "attention: power on reset\n"); 399 devip->reset = 0; 400 mk_sense_buffer(devip, UNIT_ATTENTION, POWERON_RESET, 0); 401 return check_condition_result; 402 } 403 if ((0 == reset_only) && devip->stopped) { 404 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 405 printk(KERN_INFO "scsi_debug: Reporting Not " 406 "ready: initializing command required\n"); 407 mk_sense_buffer(devip, NOT_READY, LOGICAL_UNIT_NOT_READY, 408 0x2); 409 return check_condition_result; 410 } 411 return 0; 412 } 413 414 /* Returns 0 if ok else (DID_ERROR << 16). Sets scp->resid . */ 415 static int fill_from_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr, 416 int arr_len) 417 { 418 int act_len; 419 struct scsi_data_buffer *sdb = scsi_in(scp); 420 421 if (!sdb->length) 422 return 0; 423 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_FROM_DEVICE)) 424 return (DID_ERROR << 16); 425 426 act_len = sg_copy_from_buffer(sdb->table.sgl, sdb->table.nents, 427 arr, arr_len); 428 if (sdb->resid) 429 sdb->resid -= act_len; 430 else 431 sdb->resid = scsi_bufflen(scp) - act_len; 432 433 return 0; 434 } 435 436 /* Returns number of bytes fetched into 'arr' or -1 if error. */ 437 static int fetch_to_dev_buffer(struct scsi_cmnd *scp, unsigned char *arr, 438 int arr_len) 439 { 440 if (!scsi_bufflen(scp)) 441 return 0; 442 if (!(scsi_bidi_cmnd(scp) || scp->sc_data_direction == DMA_TO_DEVICE)) 443 return -1; 444 445 return scsi_sg_copy_to_buffer(scp, arr, arr_len); 446 } 447 448 449 static const char * inq_vendor_id = "Linux "; 450 static const char * inq_product_id = "scsi_debug "; 451 static const char * inq_product_rev = "0004"; 452 453 static int inquiry_evpd_83(unsigned char * arr, int port_group_id, 454 int target_dev_id, int dev_id_num, 455 const char * dev_id_str, 456 int dev_id_str_len) 457 { 458 int num, port_a; 459 char b[32]; 460 461 port_a = target_dev_id + 1; 462 /* T10 vendor identifier field format (faked) */ 463 arr[0] = 0x2; /* ASCII */ 464 arr[1] = 0x1; 465 arr[2] = 0x0; 466 memcpy(&arr[4], inq_vendor_id, 8); 467 memcpy(&arr[12], inq_product_id, 16); 468 memcpy(&arr[28], dev_id_str, dev_id_str_len); 469 num = 8 + 16 + dev_id_str_len; 470 arr[3] = num; 471 num += 4; 472 if (dev_id_num >= 0) { 473 /* NAA-5, Logical unit identifier (binary) */ 474 arr[num++] = 0x1; /* binary (not necessarily sas) */ 475 arr[num++] = 0x3; /* PIV=0, lu, naa */ 476 arr[num++] = 0x0; 477 arr[num++] = 0x8; 478 arr[num++] = 0x53; /* naa-5 ieee company id=0x333333 (fake) */ 479 arr[num++] = 0x33; 480 arr[num++] = 0x33; 481 arr[num++] = 0x30; 482 arr[num++] = (dev_id_num >> 24); 483 arr[num++] = (dev_id_num >> 16) & 0xff; 484 arr[num++] = (dev_id_num >> 8) & 0xff; 485 arr[num++] = dev_id_num & 0xff; 486 /* Target relative port number */ 487 arr[num++] = 0x61; /* proto=sas, binary */ 488 arr[num++] = 0x94; /* PIV=1, target port, rel port */ 489 arr[num++] = 0x0; /* reserved */ 490 arr[num++] = 0x4; /* length */ 491 arr[num++] = 0x0; /* reserved */ 492 arr[num++] = 0x0; /* reserved */ 493 arr[num++] = 0x0; 494 arr[num++] = 0x1; /* relative port A */ 495 } 496 /* NAA-5, Target port identifier */ 497 arr[num++] = 0x61; /* proto=sas, binary */ 498 arr[num++] = 0x93; /* piv=1, target port, naa */ 499 arr[num++] = 0x0; 500 arr[num++] = 0x8; 501 arr[num++] = 0x52; /* naa-5, company id=0x222222 (fake) */ 502 arr[num++] = 0x22; 503 arr[num++] = 0x22; 504 arr[num++] = 0x20; 505 arr[num++] = (port_a >> 24); 506 arr[num++] = (port_a >> 16) & 0xff; 507 arr[num++] = (port_a >> 8) & 0xff; 508 arr[num++] = port_a & 0xff; 509 /* NAA-5, Target port group identifier */ 510 arr[num++] = 0x61; /* proto=sas, binary */ 511 arr[num++] = 0x95; /* piv=1, target port group id */ 512 arr[num++] = 0x0; 513 arr[num++] = 0x4; 514 arr[num++] = 0; 515 arr[num++] = 0; 516 arr[num++] = (port_group_id >> 8) & 0xff; 517 arr[num++] = port_group_id & 0xff; 518 /* NAA-5, Target device identifier */ 519 arr[num++] = 0x61; /* proto=sas, binary */ 520 arr[num++] = 0xa3; /* piv=1, target device, naa */ 521 arr[num++] = 0x0; 522 arr[num++] = 0x8; 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++] = (target_dev_id >> 24); 528 arr[num++] = (target_dev_id >> 16) & 0xff; 529 arr[num++] = (target_dev_id >> 8) & 0xff; 530 arr[num++] = target_dev_id & 0xff; 531 /* SCSI name string: Target device identifier */ 532 arr[num++] = 0x63; /* proto=sas, UTF-8 */ 533 arr[num++] = 0xa8; /* piv=1, target device, SCSI name string */ 534 arr[num++] = 0x0; 535 arr[num++] = 24; 536 memcpy(arr + num, "naa.52222220", 12); 537 num += 12; 538 snprintf(b, sizeof(b), "%08X", target_dev_id); 539 memcpy(arr + num, b, 8); 540 num += 8; 541 memset(arr + num, 0, 4); 542 num += 4; 543 return num; 544 } 545 546 547 static unsigned char vpd84_data[] = { 548 /* from 4th byte */ 0x22,0x22,0x22,0x0,0xbb,0x0, 549 0x22,0x22,0x22,0x0,0xbb,0x1, 550 0x22,0x22,0x22,0x0,0xbb,0x2, 551 }; 552 553 static int inquiry_evpd_84(unsigned char * arr) 554 { 555 memcpy(arr, vpd84_data, sizeof(vpd84_data)); 556 return sizeof(vpd84_data); 557 } 558 559 static int inquiry_evpd_85(unsigned char * arr) 560 { 561 int num = 0; 562 const char * na1 = "https://www.kernel.org/config"; 563 const char * na2 = "http://www.kernel.org/log"; 564 int plen, olen; 565 566 arr[num++] = 0x1; /* lu, storage config */ 567 arr[num++] = 0x0; /* reserved */ 568 arr[num++] = 0x0; 569 olen = strlen(na1); 570 plen = olen + 1; 571 if (plen % 4) 572 plen = ((plen / 4) + 1) * 4; 573 arr[num++] = plen; /* length, null termianted, padded */ 574 memcpy(arr + num, na1, olen); 575 memset(arr + num + olen, 0, plen - olen); 576 num += plen; 577 578 arr[num++] = 0x4; /* lu, logging */ 579 arr[num++] = 0x0; /* reserved */ 580 arr[num++] = 0x0; 581 olen = strlen(na2); 582 plen = olen + 1; 583 if (plen % 4) 584 plen = ((plen / 4) + 1) * 4; 585 arr[num++] = plen; /* length, null terminated, padded */ 586 memcpy(arr + num, na2, olen); 587 memset(arr + num + olen, 0, plen - olen); 588 num += plen; 589 590 return num; 591 } 592 593 /* SCSI ports VPD page */ 594 static int inquiry_evpd_88(unsigned char * arr, int target_dev_id) 595 { 596 int num = 0; 597 int port_a, port_b; 598 599 port_a = target_dev_id + 1; 600 port_b = port_a + 1; 601 arr[num++] = 0x0; /* reserved */ 602 arr[num++] = 0x0; /* reserved */ 603 arr[num++] = 0x0; 604 arr[num++] = 0x1; /* relative port 1 (primary) */ 605 memset(arr + num, 0, 6); 606 num += 6; 607 arr[num++] = 0x0; 608 arr[num++] = 12; /* length tp descriptor */ 609 /* naa-5 target port identifier (A) */ 610 arr[num++] = 0x61; /* proto=sas, binary */ 611 arr[num++] = 0x93; /* PIV=1, target port, NAA */ 612 arr[num++] = 0x0; /* reserved */ 613 arr[num++] = 0x8; /* length */ 614 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */ 615 arr[num++] = 0x22; 616 arr[num++] = 0x22; 617 arr[num++] = 0x20; 618 arr[num++] = (port_a >> 24); 619 arr[num++] = (port_a >> 16) & 0xff; 620 arr[num++] = (port_a >> 8) & 0xff; 621 arr[num++] = port_a & 0xff; 622 623 arr[num++] = 0x0; /* reserved */ 624 arr[num++] = 0x0; /* reserved */ 625 arr[num++] = 0x0; 626 arr[num++] = 0x2; /* relative port 2 (secondary) */ 627 memset(arr + num, 0, 6); 628 num += 6; 629 arr[num++] = 0x0; 630 arr[num++] = 12; /* length tp descriptor */ 631 /* naa-5 target port identifier (B) */ 632 arr[num++] = 0x61; /* proto=sas, binary */ 633 arr[num++] = 0x93; /* PIV=1, target port, NAA */ 634 arr[num++] = 0x0; /* reserved */ 635 arr[num++] = 0x8; /* length */ 636 arr[num++] = 0x52; /* NAA-5, company_id=0x222222 (fake) */ 637 arr[num++] = 0x22; 638 arr[num++] = 0x22; 639 arr[num++] = 0x20; 640 arr[num++] = (port_b >> 24); 641 arr[num++] = (port_b >> 16) & 0xff; 642 arr[num++] = (port_b >> 8) & 0xff; 643 arr[num++] = port_b & 0xff; 644 645 return num; 646 } 647 648 649 static unsigned char vpd89_data[] = { 650 /* from 4th byte */ 0,0,0,0, 651 'l','i','n','u','x',' ',' ',' ', 652 'S','A','T',' ','s','c','s','i','_','d','e','b','u','g',' ',' ', 653 '1','2','3','4', 654 0x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0, 655 0xec,0,0,0, 656 0x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0, 657 0,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20, 658 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33, 659 0x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31, 660 0x53,0x41, 661 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, 662 0x20,0x20, 663 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, 664 0x10,0x80, 665 0,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0, 666 0x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0, 667 0x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0, 668 0,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0, 669 0x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40, 670 0x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0, 671 0,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0, 672 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 673 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 674 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 675 0x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42, 676 0,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8, 677 0xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe, 678 0,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0, 679 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 680 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 681 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 682 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 683 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 684 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 685 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 686 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 687 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 688 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 689 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 690 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51, 691 }; 692 693 static int inquiry_evpd_89(unsigned char * arr) 694 { 695 memcpy(arr, vpd89_data, sizeof(vpd89_data)); 696 return sizeof(vpd89_data); 697 } 698 699 700 /* Block limits VPD page (SBC-3) */ 701 static unsigned char vpdb0_data[] = { 702 /* from 4th byte */ 0,0,0,4, 0,0,0x4,0, 0,0,0,64, 703 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 704 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 705 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 706 }; 707 708 static int inquiry_evpd_b0(unsigned char * arr) 709 { 710 unsigned int gran; 711 712 memcpy(arr, vpdb0_data, sizeof(vpdb0_data)); 713 714 /* Optimal transfer length granularity */ 715 gran = 1 << scsi_debug_physblk_exp; 716 arr[2] = (gran >> 8) & 0xff; 717 arr[3] = gran & 0xff; 718 719 /* Maximum Transfer Length */ 720 if (sdebug_store_sectors > 0x400) { 721 arr[4] = (sdebug_store_sectors >> 24) & 0xff; 722 arr[5] = (sdebug_store_sectors >> 16) & 0xff; 723 arr[6] = (sdebug_store_sectors >> 8) & 0xff; 724 arr[7] = sdebug_store_sectors & 0xff; 725 } 726 727 /* Optimal Transfer Length */ 728 put_unaligned_be32(scsi_debug_opt_blks, &arr[8]); 729 730 if (scsi_debug_tpu) { 731 /* Maximum Unmap LBA Count */ 732 put_unaligned_be32(scsi_debug_unmap_max_blocks, &arr[16]); 733 734 /* Maximum Unmap Block Descriptor Count */ 735 put_unaligned_be32(scsi_debug_unmap_max_desc, &arr[20]); 736 } 737 738 /* Unmap Granularity Alignment */ 739 if (scsi_debug_unmap_alignment) { 740 put_unaligned_be32(scsi_debug_unmap_alignment, &arr[28]); 741 arr[28] |= 0x80; /* UGAVALID */ 742 } 743 744 /* Optimal Unmap Granularity */ 745 put_unaligned_be32(scsi_debug_unmap_granularity, &arr[24]); 746 747 return 0x3c; /* Mandatory page length for thin provisioning */ 748 749 return sizeof(vpdb0_data); 750 } 751 752 /* Block device characteristics VPD page (SBC-3) */ 753 static int inquiry_evpd_b1(unsigned char *arr) 754 { 755 memset(arr, 0, 0x3c); 756 arr[0] = 0; 757 arr[1] = 1; /* non rotating medium (e.g. solid state) */ 758 arr[2] = 0; 759 arr[3] = 5; /* less than 1.8" */ 760 761 return 0x3c; 762 } 763 764 /* Thin provisioning VPD page (SBC-3) */ 765 static int inquiry_evpd_b2(unsigned char *arr) 766 { 767 memset(arr, 0, 0x8); 768 arr[0] = 0; /* threshold exponent */ 769 770 if (scsi_debug_tpu) 771 arr[1] = 1 << 7; 772 773 if (scsi_debug_tpws) 774 arr[1] |= 1 << 6; 775 776 return 0x8; 777 } 778 779 #define SDEBUG_LONG_INQ_SZ 96 780 #define SDEBUG_MAX_INQ_ARR_SZ 584 781 782 static int resp_inquiry(struct scsi_cmnd * scp, int target, 783 struct sdebug_dev_info * devip) 784 { 785 unsigned char pq_pdt; 786 unsigned char * arr; 787 unsigned char *cmd = (unsigned char *)scp->cmnd; 788 int alloc_len, n, ret; 789 790 alloc_len = (cmd[3] << 8) + cmd[4]; 791 arr = kzalloc(SDEBUG_MAX_INQ_ARR_SZ, GFP_ATOMIC); 792 if (! arr) 793 return DID_REQUEUE << 16; 794 if (devip->wlun) 795 pq_pdt = 0x1e; /* present, wlun */ 796 else if (scsi_debug_no_lun_0 && (0 == devip->lun)) 797 pq_pdt = 0x7f; /* not present, no device type */ 798 else 799 pq_pdt = (scsi_debug_ptype & 0x1f); 800 arr[0] = pq_pdt; 801 if (0x2 & cmd[1]) { /* CMDDT bit set */ 802 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 803 0); 804 kfree(arr); 805 return check_condition_result; 806 } else if (0x1 & cmd[1]) { /* EVPD bit set */ 807 int lu_id_num, port_group_id, target_dev_id, len; 808 char lu_id_str[6]; 809 int host_no = devip->sdbg_host->shost->host_no; 810 811 port_group_id = (((host_no + 1) & 0x7f) << 8) + 812 (devip->channel & 0x7f); 813 if (0 == scsi_debug_vpd_use_hostno) 814 host_no = 0; 815 lu_id_num = devip->wlun ? -1 : (((host_no + 1) * 2000) + 816 (devip->target * 1000) + devip->lun); 817 target_dev_id = ((host_no + 1) * 2000) + 818 (devip->target * 1000) - 3; 819 len = scnprintf(lu_id_str, 6, "%d", lu_id_num); 820 if (0 == cmd[2]) { /* supported vital product data pages */ 821 arr[1] = cmd[2]; /*sanity */ 822 n = 4; 823 arr[n++] = 0x0; /* this page */ 824 arr[n++] = 0x80; /* unit serial number */ 825 arr[n++] = 0x83; /* device identification */ 826 arr[n++] = 0x84; /* software interface ident. */ 827 arr[n++] = 0x85; /* management network addresses */ 828 arr[n++] = 0x86; /* extended inquiry */ 829 arr[n++] = 0x87; /* mode page policy */ 830 arr[n++] = 0x88; /* SCSI ports */ 831 arr[n++] = 0x89; /* ATA information */ 832 arr[n++] = 0xb0; /* Block limits (SBC) */ 833 arr[n++] = 0xb1; /* Block characteristics (SBC) */ 834 arr[n++] = 0xb2; /* Thin provisioning (SBC) */ 835 arr[3] = n - 4; /* number of supported VPD pages */ 836 } else if (0x80 == cmd[2]) { /* unit serial number */ 837 arr[1] = cmd[2]; /*sanity */ 838 arr[3] = len; 839 memcpy(&arr[4], lu_id_str, len); 840 } else if (0x83 == cmd[2]) { /* device identification */ 841 arr[1] = cmd[2]; /*sanity */ 842 arr[3] = inquiry_evpd_83(&arr[4], port_group_id, 843 target_dev_id, lu_id_num, 844 lu_id_str, len); 845 } else if (0x84 == cmd[2]) { /* Software interface ident. */ 846 arr[1] = cmd[2]; /*sanity */ 847 arr[3] = inquiry_evpd_84(&arr[4]); 848 } else if (0x85 == cmd[2]) { /* Management network addresses */ 849 arr[1] = cmd[2]; /*sanity */ 850 arr[3] = inquiry_evpd_85(&arr[4]); 851 } else if (0x86 == cmd[2]) { /* extended inquiry */ 852 arr[1] = cmd[2]; /*sanity */ 853 arr[3] = 0x3c; /* number of following entries */ 854 if (scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) 855 arr[4] = 0x4; /* SPT: GRD_CHK:1 */ 856 else if (scsi_debug_dif) 857 arr[4] = 0x5; /* SPT: GRD_CHK:1, REF_CHK:1 */ 858 else 859 arr[4] = 0x0; /* no protection stuff */ 860 arr[5] = 0x7; /* head of q, ordered + simple q's */ 861 } else if (0x87 == cmd[2]) { /* mode page policy */ 862 arr[1] = cmd[2]; /*sanity */ 863 arr[3] = 0x8; /* number of following entries */ 864 arr[4] = 0x2; /* disconnect-reconnect mp */ 865 arr[6] = 0x80; /* mlus, shared */ 866 arr[8] = 0x18; /* protocol specific lu */ 867 arr[10] = 0x82; /* mlus, per initiator port */ 868 } else if (0x88 == cmd[2]) { /* SCSI Ports */ 869 arr[1] = cmd[2]; /*sanity */ 870 arr[3] = inquiry_evpd_88(&arr[4], target_dev_id); 871 } else if (0x89 == cmd[2]) { /* ATA information */ 872 arr[1] = cmd[2]; /*sanity */ 873 n = inquiry_evpd_89(&arr[4]); 874 arr[2] = (n >> 8); 875 arr[3] = (n & 0xff); 876 } else if (0xb0 == cmd[2]) { /* Block limits (SBC) */ 877 arr[1] = cmd[2]; /*sanity */ 878 arr[3] = inquiry_evpd_b0(&arr[4]); 879 } else if (0xb1 == cmd[2]) { /* Block characteristics (SBC) */ 880 arr[1] = cmd[2]; /*sanity */ 881 arr[3] = inquiry_evpd_b1(&arr[4]); 882 } else if (0xb2 == cmd[2]) { /* Thin provisioning (SBC) */ 883 arr[1] = cmd[2]; /*sanity */ 884 arr[3] = inquiry_evpd_b2(&arr[4]); 885 } else { 886 /* Illegal request, invalid field in cdb */ 887 mk_sense_buffer(devip, ILLEGAL_REQUEST, 888 INVALID_FIELD_IN_CDB, 0); 889 kfree(arr); 890 return check_condition_result; 891 } 892 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len); 893 ret = fill_from_dev_buffer(scp, arr, 894 min(len, SDEBUG_MAX_INQ_ARR_SZ)); 895 kfree(arr); 896 return ret; 897 } 898 /* drops through here for a standard inquiry */ 899 arr[1] = DEV_REMOVEABLE(target) ? 0x80 : 0; /* Removable disk */ 900 arr[2] = scsi_debug_scsi_level; 901 arr[3] = 2; /* response_data_format==2 */ 902 arr[4] = SDEBUG_LONG_INQ_SZ - 5; 903 arr[5] = scsi_debug_dif ? 1 : 0; /* PROTECT bit */ 904 if (0 == scsi_debug_vpd_use_hostno) 905 arr[5] = 0x10; /* claim: implicit TGPS */ 906 arr[6] = 0x10; /* claim: MultiP */ 907 /* arr[6] |= 0x40; ... claim: EncServ (enclosure services) */ 908 arr[7] = 0xa; /* claim: LINKED + CMDQUE */ 909 memcpy(&arr[8], inq_vendor_id, 8); 910 memcpy(&arr[16], inq_product_id, 16); 911 memcpy(&arr[32], inq_product_rev, 4); 912 /* version descriptors (2 bytes each) follow */ 913 arr[58] = 0x0; arr[59] = 0x77; /* SAM-3 ANSI */ 914 arr[60] = 0x3; arr[61] = 0x14; /* SPC-3 ANSI */ 915 n = 62; 916 if (scsi_debug_ptype == 0) { 917 arr[n++] = 0x3; arr[n++] = 0x3d; /* SBC-2 ANSI */ 918 } else if (scsi_debug_ptype == 1) { 919 arr[n++] = 0x3; arr[n++] = 0x60; /* SSC-2 no version */ 920 } 921 arr[n++] = 0xc; arr[n++] = 0xf; /* SAS-1.1 rev 10 */ 922 ret = fill_from_dev_buffer(scp, arr, 923 min(alloc_len, SDEBUG_LONG_INQ_SZ)); 924 kfree(arr); 925 return ret; 926 } 927 928 static int resp_requests(struct scsi_cmnd * scp, 929 struct sdebug_dev_info * devip) 930 { 931 unsigned char * sbuff; 932 unsigned char *cmd = (unsigned char *)scp->cmnd; 933 unsigned char arr[SDEBUG_SENSE_LEN]; 934 int want_dsense; 935 int len = 18; 936 937 memset(arr, 0, sizeof(arr)); 938 if (devip->reset == 1) 939 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0); 940 want_dsense = !!(cmd[1] & 1) || scsi_debug_dsense; 941 sbuff = devip->sense_buff; 942 if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) { 943 if (want_dsense) { 944 arr[0] = 0x72; 945 arr[1] = 0x0; /* NO_SENSE in sense_key */ 946 arr[2] = THRESHOLD_EXCEEDED; 947 arr[3] = 0xff; /* TEST set and MRIE==6 */ 948 } else { 949 arr[0] = 0x70; 950 arr[2] = 0x0; /* NO_SENSE in sense_key */ 951 arr[7] = 0xa; /* 18 byte sense buffer */ 952 arr[12] = THRESHOLD_EXCEEDED; 953 arr[13] = 0xff; /* TEST set and MRIE==6 */ 954 } 955 } else { 956 memcpy(arr, sbuff, SDEBUG_SENSE_LEN); 957 if ((cmd[1] & 1) && (! scsi_debug_dsense)) { 958 /* DESC bit set and sense_buff in fixed format */ 959 memset(arr, 0, sizeof(arr)); 960 arr[0] = 0x72; 961 arr[1] = sbuff[2]; /* sense key */ 962 arr[2] = sbuff[12]; /* asc */ 963 arr[3] = sbuff[13]; /* ascq */ 964 len = 8; 965 } 966 } 967 mk_sense_buffer(devip, 0, NO_ADDITIONAL_SENSE, 0); 968 return fill_from_dev_buffer(scp, arr, len); 969 } 970 971 static int resp_start_stop(struct scsi_cmnd * scp, 972 struct sdebug_dev_info * devip) 973 { 974 unsigned char *cmd = (unsigned char *)scp->cmnd; 975 int power_cond, errsts, start; 976 977 if ((errsts = check_readiness(scp, 1, devip))) 978 return errsts; 979 power_cond = (cmd[4] & 0xf0) >> 4; 980 if (power_cond) { 981 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 982 0); 983 return check_condition_result; 984 } 985 start = cmd[4] & 1; 986 if (start == devip->stopped) 987 devip->stopped = !start; 988 return 0; 989 } 990 991 static sector_t get_sdebug_capacity(void) 992 { 993 if (scsi_debug_virtual_gb > 0) 994 return (sector_t)scsi_debug_virtual_gb * 995 (1073741824 / scsi_debug_sector_size); 996 else 997 return sdebug_store_sectors; 998 } 999 1000 #define SDEBUG_READCAP_ARR_SZ 8 1001 static int resp_readcap(struct scsi_cmnd * scp, 1002 struct sdebug_dev_info * devip) 1003 { 1004 unsigned char arr[SDEBUG_READCAP_ARR_SZ]; 1005 unsigned int capac; 1006 int errsts; 1007 1008 if ((errsts = check_readiness(scp, 1, devip))) 1009 return errsts; 1010 /* following just in case virtual_gb changed */ 1011 sdebug_capacity = get_sdebug_capacity(); 1012 memset(arr, 0, SDEBUG_READCAP_ARR_SZ); 1013 if (sdebug_capacity < 0xffffffff) { 1014 capac = (unsigned int)sdebug_capacity - 1; 1015 arr[0] = (capac >> 24); 1016 arr[1] = (capac >> 16) & 0xff; 1017 arr[2] = (capac >> 8) & 0xff; 1018 arr[3] = capac & 0xff; 1019 } else { 1020 arr[0] = 0xff; 1021 arr[1] = 0xff; 1022 arr[2] = 0xff; 1023 arr[3] = 0xff; 1024 } 1025 arr[6] = (scsi_debug_sector_size >> 8) & 0xff; 1026 arr[7] = scsi_debug_sector_size & 0xff; 1027 return fill_from_dev_buffer(scp, arr, SDEBUG_READCAP_ARR_SZ); 1028 } 1029 1030 #define SDEBUG_READCAP16_ARR_SZ 32 1031 static int resp_readcap16(struct scsi_cmnd * scp, 1032 struct sdebug_dev_info * devip) 1033 { 1034 unsigned char *cmd = (unsigned char *)scp->cmnd; 1035 unsigned char arr[SDEBUG_READCAP16_ARR_SZ]; 1036 unsigned long long capac; 1037 int errsts, k, alloc_len; 1038 1039 if ((errsts = check_readiness(scp, 1, devip))) 1040 return errsts; 1041 alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8) 1042 + cmd[13]); 1043 /* following just in case virtual_gb changed */ 1044 sdebug_capacity = get_sdebug_capacity(); 1045 memset(arr, 0, SDEBUG_READCAP16_ARR_SZ); 1046 capac = sdebug_capacity - 1; 1047 for (k = 0; k < 8; ++k, capac >>= 8) 1048 arr[7 - k] = capac & 0xff; 1049 arr[8] = (scsi_debug_sector_size >> 24) & 0xff; 1050 arr[9] = (scsi_debug_sector_size >> 16) & 0xff; 1051 arr[10] = (scsi_debug_sector_size >> 8) & 0xff; 1052 arr[11] = scsi_debug_sector_size & 0xff; 1053 arr[13] = scsi_debug_physblk_exp & 0xf; 1054 arr[14] = (scsi_debug_lowest_aligned >> 8) & 0x3f; 1055 1056 if (scsi_debug_tpu || scsi_debug_tpws) 1057 arr[14] |= 0x80; /* TPE */ 1058 1059 arr[15] = scsi_debug_lowest_aligned & 0xff; 1060 1061 if (scsi_debug_dif) { 1062 arr[12] = (scsi_debug_dif - 1) << 1; /* P_TYPE */ 1063 arr[12] |= 1; /* PROT_EN */ 1064 } 1065 1066 return fill_from_dev_buffer(scp, arr, 1067 min(alloc_len, SDEBUG_READCAP16_ARR_SZ)); 1068 } 1069 1070 #define SDEBUG_MAX_TGTPGS_ARR_SZ 1412 1071 1072 static int resp_report_tgtpgs(struct scsi_cmnd * scp, 1073 struct sdebug_dev_info * devip) 1074 { 1075 unsigned char *cmd = (unsigned char *)scp->cmnd; 1076 unsigned char * arr; 1077 int host_no = devip->sdbg_host->shost->host_no; 1078 int n, ret, alen, rlen; 1079 int port_group_a, port_group_b, port_a, port_b; 1080 1081 alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8) 1082 + cmd[9]); 1083 1084 arr = kzalloc(SDEBUG_MAX_TGTPGS_ARR_SZ, GFP_ATOMIC); 1085 if (! arr) 1086 return DID_REQUEUE << 16; 1087 /* 1088 * EVPD page 0x88 states we have two ports, one 1089 * real and a fake port with no device connected. 1090 * So we create two port groups with one port each 1091 * and set the group with port B to unavailable. 1092 */ 1093 port_a = 0x1; /* relative port A */ 1094 port_b = 0x2; /* relative port B */ 1095 port_group_a = (((host_no + 1) & 0x7f) << 8) + 1096 (devip->channel & 0x7f); 1097 port_group_b = (((host_no + 1) & 0x7f) << 8) + 1098 (devip->channel & 0x7f) + 0x80; 1099 1100 /* 1101 * The asymmetric access state is cycled according to the host_id. 1102 */ 1103 n = 4; 1104 if (0 == scsi_debug_vpd_use_hostno) { 1105 arr[n++] = host_no % 3; /* Asymm access state */ 1106 arr[n++] = 0x0F; /* claim: all states are supported */ 1107 } else { 1108 arr[n++] = 0x0; /* Active/Optimized path */ 1109 arr[n++] = 0x01; /* claim: only support active/optimized paths */ 1110 } 1111 arr[n++] = (port_group_a >> 8) & 0xff; 1112 arr[n++] = port_group_a & 0xff; 1113 arr[n++] = 0; /* Reserved */ 1114 arr[n++] = 0; /* Status code */ 1115 arr[n++] = 0; /* Vendor unique */ 1116 arr[n++] = 0x1; /* One port per group */ 1117 arr[n++] = 0; /* Reserved */ 1118 arr[n++] = 0; /* Reserved */ 1119 arr[n++] = (port_a >> 8) & 0xff; 1120 arr[n++] = port_a & 0xff; 1121 arr[n++] = 3; /* Port unavailable */ 1122 arr[n++] = 0x08; /* claim: only unavailalbe paths are supported */ 1123 arr[n++] = (port_group_b >> 8) & 0xff; 1124 arr[n++] = port_group_b & 0xff; 1125 arr[n++] = 0; /* Reserved */ 1126 arr[n++] = 0; /* Status code */ 1127 arr[n++] = 0; /* Vendor unique */ 1128 arr[n++] = 0x1; /* One port per group */ 1129 arr[n++] = 0; /* Reserved */ 1130 arr[n++] = 0; /* Reserved */ 1131 arr[n++] = (port_b >> 8) & 0xff; 1132 arr[n++] = port_b & 0xff; 1133 1134 rlen = n - 4; 1135 arr[0] = (rlen >> 24) & 0xff; 1136 arr[1] = (rlen >> 16) & 0xff; 1137 arr[2] = (rlen >> 8) & 0xff; 1138 arr[3] = rlen & 0xff; 1139 1140 /* 1141 * Return the smallest value of either 1142 * - The allocated length 1143 * - The constructed command length 1144 * - The maximum array size 1145 */ 1146 rlen = min(alen,n); 1147 ret = fill_from_dev_buffer(scp, arr, 1148 min(rlen, SDEBUG_MAX_TGTPGS_ARR_SZ)); 1149 kfree(arr); 1150 return ret; 1151 } 1152 1153 /* <<Following mode page info copied from ST318451LW>> */ 1154 1155 static int resp_err_recov_pg(unsigned char * p, int pcontrol, int target) 1156 { /* Read-Write Error Recovery page for mode_sense */ 1157 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0, 1158 5, 0, 0xff, 0xff}; 1159 1160 memcpy(p, err_recov_pg, sizeof(err_recov_pg)); 1161 if (1 == pcontrol) 1162 memset(p + 2, 0, sizeof(err_recov_pg) - 2); 1163 return sizeof(err_recov_pg); 1164 } 1165 1166 static int resp_disconnect_pg(unsigned char * p, int pcontrol, int target) 1167 { /* Disconnect-Reconnect page for mode_sense */ 1168 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0, 1169 0, 0, 0, 0, 0, 0, 0, 0}; 1170 1171 memcpy(p, disconnect_pg, sizeof(disconnect_pg)); 1172 if (1 == pcontrol) 1173 memset(p + 2, 0, sizeof(disconnect_pg) - 2); 1174 return sizeof(disconnect_pg); 1175 } 1176 1177 static int resp_format_pg(unsigned char * p, int pcontrol, int target) 1178 { /* Format device page for mode_sense */ 1179 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0, 1180 0, 0, 0, 0, 0, 0, 0, 0, 1181 0, 0, 0, 0, 0x40, 0, 0, 0}; 1182 1183 memcpy(p, format_pg, sizeof(format_pg)); 1184 p[10] = (sdebug_sectors_per >> 8) & 0xff; 1185 p[11] = sdebug_sectors_per & 0xff; 1186 p[12] = (scsi_debug_sector_size >> 8) & 0xff; 1187 p[13] = scsi_debug_sector_size & 0xff; 1188 if (DEV_REMOVEABLE(target)) 1189 p[20] |= 0x20; /* should agree with INQUIRY */ 1190 if (1 == pcontrol) 1191 memset(p + 2, 0, sizeof(format_pg) - 2); 1192 return sizeof(format_pg); 1193 } 1194 1195 static int resp_caching_pg(unsigned char * p, int pcontrol, int target) 1196 { /* Caching page for mode_sense */ 1197 unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0, 1198 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0}; 1199 1200 memcpy(p, caching_pg, sizeof(caching_pg)); 1201 if (1 == pcontrol) 1202 memset(p + 2, 0, sizeof(caching_pg) - 2); 1203 return sizeof(caching_pg); 1204 } 1205 1206 static int resp_ctrl_m_pg(unsigned char * p, int pcontrol, int target) 1207 { /* Control mode page for mode_sense */ 1208 unsigned char ch_ctrl_m_pg[] = {/* 0xa, 10, */ 0x6, 0, 0, 0, 0, 0, 1209 0, 0, 0, 0}; 1210 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0, 1211 0, 0, 0x2, 0x4b}; 1212 1213 if (scsi_debug_dsense) 1214 ctrl_m_pg[2] |= 0x4; 1215 else 1216 ctrl_m_pg[2] &= ~0x4; 1217 1218 if (scsi_debug_ato) 1219 ctrl_m_pg[5] |= 0x80; /* ATO=1 */ 1220 1221 memcpy(p, ctrl_m_pg, sizeof(ctrl_m_pg)); 1222 if (1 == pcontrol) 1223 memcpy(p + 2, ch_ctrl_m_pg, sizeof(ch_ctrl_m_pg)); 1224 else if (2 == pcontrol) 1225 memcpy(p, d_ctrl_m_pg, sizeof(d_ctrl_m_pg)); 1226 return sizeof(ctrl_m_pg); 1227 } 1228 1229 1230 static int resp_iec_m_pg(unsigned char * p, int pcontrol, int target) 1231 { /* Informational Exceptions control mode page for mode_sense */ 1232 unsigned char ch_iec_m_pg[] = {/* 0x1c, 0xa, */ 0x4, 0xf, 0, 0, 0, 0, 1233 0, 0, 0x0, 0x0}; 1234 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0, 1235 0, 0, 0x0, 0x0}; 1236 1237 memcpy(p, iec_m_pg, sizeof(iec_m_pg)); 1238 if (1 == pcontrol) 1239 memcpy(p + 2, ch_iec_m_pg, sizeof(ch_iec_m_pg)); 1240 else if (2 == pcontrol) 1241 memcpy(p, d_iec_m_pg, sizeof(d_iec_m_pg)); 1242 return sizeof(iec_m_pg); 1243 } 1244 1245 static int resp_sas_sf_m_pg(unsigned char * p, int pcontrol, int target) 1246 { /* SAS SSP mode page - short format for mode_sense */ 1247 unsigned char sas_sf_m_pg[] = {0x19, 0x6, 1248 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0}; 1249 1250 memcpy(p, sas_sf_m_pg, sizeof(sas_sf_m_pg)); 1251 if (1 == pcontrol) 1252 memset(p + 2, 0, sizeof(sas_sf_m_pg) - 2); 1253 return sizeof(sas_sf_m_pg); 1254 } 1255 1256 1257 static int resp_sas_pcd_m_spg(unsigned char * p, int pcontrol, int target, 1258 int target_dev_id) 1259 { /* SAS phy control and discover mode page for mode_sense */ 1260 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2, 1261 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0, 1262 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0, 1263 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1, 1264 0x2, 0, 0, 0, 0, 0, 0, 0, 1265 0x88, 0x99, 0, 0, 0, 0, 0, 0, 1266 0, 0, 0, 0, 0, 0, 0, 0, 1267 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0, 1268 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0, 1269 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1, 1270 0x3, 0, 0, 0, 0, 0, 0, 0, 1271 0x88, 0x99, 0, 0, 0, 0, 0, 0, 1272 0, 0, 0, 0, 0, 0, 0, 0, 1273 }; 1274 int port_a, port_b; 1275 1276 port_a = target_dev_id + 1; 1277 port_b = port_a + 1; 1278 memcpy(p, sas_pcd_m_pg, sizeof(sas_pcd_m_pg)); 1279 p[20] = (port_a >> 24); 1280 p[21] = (port_a >> 16) & 0xff; 1281 p[22] = (port_a >> 8) & 0xff; 1282 p[23] = port_a & 0xff; 1283 p[48 + 20] = (port_b >> 24); 1284 p[48 + 21] = (port_b >> 16) & 0xff; 1285 p[48 + 22] = (port_b >> 8) & 0xff; 1286 p[48 + 23] = port_b & 0xff; 1287 if (1 == pcontrol) 1288 memset(p + 4, 0, sizeof(sas_pcd_m_pg) - 4); 1289 return sizeof(sas_pcd_m_pg); 1290 } 1291 1292 static int resp_sas_sha_m_spg(unsigned char * p, int pcontrol) 1293 { /* SAS SSP shared protocol specific port mode subpage */ 1294 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0, 1295 0, 0, 0, 0, 0, 0, 0, 0, 1296 }; 1297 1298 memcpy(p, sas_sha_m_pg, sizeof(sas_sha_m_pg)); 1299 if (1 == pcontrol) 1300 memset(p + 4, 0, sizeof(sas_sha_m_pg) - 4); 1301 return sizeof(sas_sha_m_pg); 1302 } 1303 1304 #define SDEBUG_MAX_MSENSE_SZ 256 1305 1306 static int resp_mode_sense(struct scsi_cmnd * scp, int target, 1307 struct sdebug_dev_info * devip) 1308 { 1309 unsigned char dbd, llbaa; 1310 int pcontrol, pcode, subpcode, bd_len; 1311 unsigned char dev_spec; 1312 int k, alloc_len, msense_6, offset, len, errsts, target_dev_id; 1313 unsigned char * ap; 1314 unsigned char arr[SDEBUG_MAX_MSENSE_SZ]; 1315 unsigned char *cmd = (unsigned char *)scp->cmnd; 1316 1317 if ((errsts = check_readiness(scp, 1, devip))) 1318 return errsts; 1319 dbd = !!(cmd[1] & 0x8); 1320 pcontrol = (cmd[2] & 0xc0) >> 6; 1321 pcode = cmd[2] & 0x3f; 1322 subpcode = cmd[3]; 1323 msense_6 = (MODE_SENSE == cmd[0]); 1324 llbaa = msense_6 ? 0 : !!(cmd[1] & 0x10); 1325 if ((0 == scsi_debug_ptype) && (0 == dbd)) 1326 bd_len = llbaa ? 16 : 8; 1327 else 1328 bd_len = 0; 1329 alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]); 1330 memset(arr, 0, SDEBUG_MAX_MSENSE_SZ); 1331 if (0x3 == pcontrol) { /* Saving values not supported */ 1332 mk_sense_buffer(devip, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP, 1333 0); 1334 return check_condition_result; 1335 } 1336 target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) + 1337 (devip->target * 1000) - 3; 1338 /* set DPOFUA bit for disks */ 1339 if (0 == scsi_debug_ptype) 1340 dev_spec = (DEV_READONLY(target) ? 0x80 : 0x0) | 0x10; 1341 else 1342 dev_spec = 0x0; 1343 if (msense_6) { 1344 arr[2] = dev_spec; 1345 arr[3] = bd_len; 1346 offset = 4; 1347 } else { 1348 arr[3] = dev_spec; 1349 if (16 == bd_len) 1350 arr[4] = 0x1; /* set LONGLBA bit */ 1351 arr[7] = bd_len; /* assume 255 or less */ 1352 offset = 8; 1353 } 1354 ap = arr + offset; 1355 if ((bd_len > 0) && (!sdebug_capacity)) 1356 sdebug_capacity = get_sdebug_capacity(); 1357 1358 if (8 == bd_len) { 1359 if (sdebug_capacity > 0xfffffffe) { 1360 ap[0] = 0xff; 1361 ap[1] = 0xff; 1362 ap[2] = 0xff; 1363 ap[3] = 0xff; 1364 } else { 1365 ap[0] = (sdebug_capacity >> 24) & 0xff; 1366 ap[1] = (sdebug_capacity >> 16) & 0xff; 1367 ap[2] = (sdebug_capacity >> 8) & 0xff; 1368 ap[3] = sdebug_capacity & 0xff; 1369 } 1370 ap[6] = (scsi_debug_sector_size >> 8) & 0xff; 1371 ap[7] = scsi_debug_sector_size & 0xff; 1372 offset += bd_len; 1373 ap = arr + offset; 1374 } else if (16 == bd_len) { 1375 unsigned long long capac = sdebug_capacity; 1376 1377 for (k = 0; k < 8; ++k, capac >>= 8) 1378 ap[7 - k] = capac & 0xff; 1379 ap[12] = (scsi_debug_sector_size >> 24) & 0xff; 1380 ap[13] = (scsi_debug_sector_size >> 16) & 0xff; 1381 ap[14] = (scsi_debug_sector_size >> 8) & 0xff; 1382 ap[15] = scsi_debug_sector_size & 0xff; 1383 offset += bd_len; 1384 ap = arr + offset; 1385 } 1386 1387 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) { 1388 /* TODO: Control Extension page */ 1389 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 1390 0); 1391 return check_condition_result; 1392 } 1393 switch (pcode) { 1394 case 0x1: /* Read-Write error recovery page, direct access */ 1395 len = resp_err_recov_pg(ap, pcontrol, target); 1396 offset += len; 1397 break; 1398 case 0x2: /* Disconnect-Reconnect page, all devices */ 1399 len = resp_disconnect_pg(ap, pcontrol, target); 1400 offset += len; 1401 break; 1402 case 0x3: /* Format device page, direct access */ 1403 len = resp_format_pg(ap, pcontrol, target); 1404 offset += len; 1405 break; 1406 case 0x8: /* Caching page, direct access */ 1407 len = resp_caching_pg(ap, pcontrol, target); 1408 offset += len; 1409 break; 1410 case 0xa: /* Control Mode page, all devices */ 1411 len = resp_ctrl_m_pg(ap, pcontrol, target); 1412 offset += len; 1413 break; 1414 case 0x19: /* if spc==1 then sas phy, control+discover */ 1415 if ((subpcode > 0x2) && (subpcode < 0xff)) { 1416 mk_sense_buffer(devip, ILLEGAL_REQUEST, 1417 INVALID_FIELD_IN_CDB, 0); 1418 return check_condition_result; 1419 } 1420 len = 0; 1421 if ((0x0 == subpcode) || (0xff == subpcode)) 1422 len += resp_sas_sf_m_pg(ap + len, pcontrol, target); 1423 if ((0x1 == subpcode) || (0xff == subpcode)) 1424 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target, 1425 target_dev_id); 1426 if ((0x2 == subpcode) || (0xff == subpcode)) 1427 len += resp_sas_sha_m_spg(ap + len, pcontrol); 1428 offset += len; 1429 break; 1430 case 0x1c: /* Informational Exceptions Mode page, all devices */ 1431 len = resp_iec_m_pg(ap, pcontrol, target); 1432 offset += len; 1433 break; 1434 case 0x3f: /* Read all Mode pages */ 1435 if ((0 == subpcode) || (0xff == subpcode)) { 1436 len = resp_err_recov_pg(ap, pcontrol, target); 1437 len += resp_disconnect_pg(ap + len, pcontrol, target); 1438 len += resp_format_pg(ap + len, pcontrol, target); 1439 len += resp_caching_pg(ap + len, pcontrol, target); 1440 len += resp_ctrl_m_pg(ap + len, pcontrol, target); 1441 len += resp_sas_sf_m_pg(ap + len, pcontrol, target); 1442 if (0xff == subpcode) { 1443 len += resp_sas_pcd_m_spg(ap + len, pcontrol, 1444 target, target_dev_id); 1445 len += resp_sas_sha_m_spg(ap + len, pcontrol); 1446 } 1447 len += resp_iec_m_pg(ap + len, pcontrol, target); 1448 } else { 1449 mk_sense_buffer(devip, ILLEGAL_REQUEST, 1450 INVALID_FIELD_IN_CDB, 0); 1451 return check_condition_result; 1452 } 1453 offset += len; 1454 break; 1455 default: 1456 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 1457 0); 1458 return check_condition_result; 1459 } 1460 if (msense_6) 1461 arr[0] = offset - 1; 1462 else { 1463 arr[0] = ((offset - 2) >> 8) & 0xff; 1464 arr[1] = (offset - 2) & 0xff; 1465 } 1466 return fill_from_dev_buffer(scp, arr, min(alloc_len, offset)); 1467 } 1468 1469 #define SDEBUG_MAX_MSELECT_SZ 512 1470 1471 static int resp_mode_select(struct scsi_cmnd * scp, int mselect6, 1472 struct sdebug_dev_info * devip) 1473 { 1474 int pf, sp, ps, md_len, bd_len, off, spf, pg_len; 1475 int param_len, res, errsts, mpage; 1476 unsigned char arr[SDEBUG_MAX_MSELECT_SZ]; 1477 unsigned char *cmd = (unsigned char *)scp->cmnd; 1478 1479 if ((errsts = check_readiness(scp, 1, devip))) 1480 return errsts; 1481 memset(arr, 0, sizeof(arr)); 1482 pf = cmd[1] & 0x10; 1483 sp = cmd[1] & 0x1; 1484 param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]); 1485 if ((0 == pf) || sp || (param_len > SDEBUG_MAX_MSELECT_SZ)) { 1486 mk_sense_buffer(devip, ILLEGAL_REQUEST, 1487 INVALID_FIELD_IN_CDB, 0); 1488 return check_condition_result; 1489 } 1490 res = fetch_to_dev_buffer(scp, arr, param_len); 1491 if (-1 == res) 1492 return (DID_ERROR << 16); 1493 else if ((res < param_len) && 1494 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)) 1495 printk(KERN_INFO "scsi_debug: mode_select: cdb indicated=%d, " 1496 " IO sent=%d bytes\n", param_len, res); 1497 md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2); 1498 bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]); 1499 if (md_len > 2) { 1500 mk_sense_buffer(devip, ILLEGAL_REQUEST, 1501 INVALID_FIELD_IN_PARAM_LIST, 0); 1502 return check_condition_result; 1503 } 1504 off = bd_len + (mselect6 ? 4 : 8); 1505 mpage = arr[off] & 0x3f; 1506 ps = !!(arr[off] & 0x80); 1507 if (ps) { 1508 mk_sense_buffer(devip, ILLEGAL_REQUEST, 1509 INVALID_FIELD_IN_PARAM_LIST, 0); 1510 return check_condition_result; 1511 } 1512 spf = !!(arr[off] & 0x40); 1513 pg_len = spf ? ((arr[off + 2] << 8) + arr[off + 3] + 4) : 1514 (arr[off + 1] + 2); 1515 if ((pg_len + off) > param_len) { 1516 mk_sense_buffer(devip, ILLEGAL_REQUEST, 1517 PARAMETER_LIST_LENGTH_ERR, 0); 1518 return check_condition_result; 1519 } 1520 switch (mpage) { 1521 case 0xa: /* Control Mode page */ 1522 if (ctrl_m_pg[1] == arr[off + 1]) { 1523 memcpy(ctrl_m_pg + 2, arr + off + 2, 1524 sizeof(ctrl_m_pg) - 2); 1525 scsi_debug_dsense = !!(ctrl_m_pg[2] & 0x4); 1526 return 0; 1527 } 1528 break; 1529 case 0x1c: /* Informational Exceptions Mode page */ 1530 if (iec_m_pg[1] == arr[off + 1]) { 1531 memcpy(iec_m_pg + 2, arr + off + 2, 1532 sizeof(iec_m_pg) - 2); 1533 return 0; 1534 } 1535 break; 1536 default: 1537 break; 1538 } 1539 mk_sense_buffer(devip, ILLEGAL_REQUEST, 1540 INVALID_FIELD_IN_PARAM_LIST, 0); 1541 return check_condition_result; 1542 } 1543 1544 static int resp_temp_l_pg(unsigned char * arr) 1545 { 1546 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38, 1547 0x0, 0x1, 0x3, 0x2, 0x0, 65, 1548 }; 1549 1550 memcpy(arr, temp_l_pg, sizeof(temp_l_pg)); 1551 return sizeof(temp_l_pg); 1552 } 1553 1554 static int resp_ie_l_pg(unsigned char * arr) 1555 { 1556 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38, 1557 }; 1558 1559 memcpy(arr, ie_l_pg, sizeof(ie_l_pg)); 1560 if (iec_m_pg[2] & 0x4) { /* TEST bit set */ 1561 arr[4] = THRESHOLD_EXCEEDED; 1562 arr[5] = 0xff; 1563 } 1564 return sizeof(ie_l_pg); 1565 } 1566 1567 #define SDEBUG_MAX_LSENSE_SZ 512 1568 1569 static int resp_log_sense(struct scsi_cmnd * scp, 1570 struct sdebug_dev_info * devip) 1571 { 1572 int ppc, sp, pcontrol, pcode, subpcode, alloc_len, errsts, len, n; 1573 unsigned char arr[SDEBUG_MAX_LSENSE_SZ]; 1574 unsigned char *cmd = (unsigned char *)scp->cmnd; 1575 1576 if ((errsts = check_readiness(scp, 1, devip))) 1577 return errsts; 1578 memset(arr, 0, sizeof(arr)); 1579 ppc = cmd[1] & 0x2; 1580 sp = cmd[1] & 0x1; 1581 if (ppc || sp) { 1582 mk_sense_buffer(devip, ILLEGAL_REQUEST, 1583 INVALID_FIELD_IN_CDB, 0); 1584 return check_condition_result; 1585 } 1586 pcontrol = (cmd[2] & 0xc0) >> 6; 1587 pcode = cmd[2] & 0x3f; 1588 subpcode = cmd[3] & 0xff; 1589 alloc_len = (cmd[7] << 8) + cmd[8]; 1590 arr[0] = pcode; 1591 if (0 == subpcode) { 1592 switch (pcode) { 1593 case 0x0: /* Supported log pages log page */ 1594 n = 4; 1595 arr[n++] = 0x0; /* this page */ 1596 arr[n++] = 0xd; /* Temperature */ 1597 arr[n++] = 0x2f; /* Informational exceptions */ 1598 arr[3] = n - 4; 1599 break; 1600 case 0xd: /* Temperature log page */ 1601 arr[3] = resp_temp_l_pg(arr + 4); 1602 break; 1603 case 0x2f: /* Informational exceptions log page */ 1604 arr[3] = resp_ie_l_pg(arr + 4); 1605 break; 1606 default: 1607 mk_sense_buffer(devip, ILLEGAL_REQUEST, 1608 INVALID_FIELD_IN_CDB, 0); 1609 return check_condition_result; 1610 } 1611 } else if (0xff == subpcode) { 1612 arr[0] |= 0x40; 1613 arr[1] = subpcode; 1614 switch (pcode) { 1615 case 0x0: /* Supported log pages and subpages log page */ 1616 n = 4; 1617 arr[n++] = 0x0; 1618 arr[n++] = 0x0; /* 0,0 page */ 1619 arr[n++] = 0x0; 1620 arr[n++] = 0xff; /* this page */ 1621 arr[n++] = 0xd; 1622 arr[n++] = 0x0; /* Temperature */ 1623 arr[n++] = 0x2f; 1624 arr[n++] = 0x0; /* Informational exceptions */ 1625 arr[3] = n - 4; 1626 break; 1627 case 0xd: /* Temperature subpages */ 1628 n = 4; 1629 arr[n++] = 0xd; 1630 arr[n++] = 0x0; /* Temperature */ 1631 arr[3] = n - 4; 1632 break; 1633 case 0x2f: /* Informational exceptions subpages */ 1634 n = 4; 1635 arr[n++] = 0x2f; 1636 arr[n++] = 0x0; /* Informational exceptions */ 1637 arr[3] = n - 4; 1638 break; 1639 default: 1640 mk_sense_buffer(devip, ILLEGAL_REQUEST, 1641 INVALID_FIELD_IN_CDB, 0); 1642 return check_condition_result; 1643 } 1644 } else { 1645 mk_sense_buffer(devip, ILLEGAL_REQUEST, 1646 INVALID_FIELD_IN_CDB, 0); 1647 return check_condition_result; 1648 } 1649 len = min(((arr[2] << 8) + arr[3]) + 4, alloc_len); 1650 return fill_from_dev_buffer(scp, arr, 1651 min(len, SDEBUG_MAX_INQ_ARR_SZ)); 1652 } 1653 1654 static int check_device_access_params(struct sdebug_dev_info *devi, 1655 unsigned long long lba, unsigned int num) 1656 { 1657 if (lba + num > sdebug_capacity) { 1658 mk_sense_buffer(devi, ILLEGAL_REQUEST, ADDR_OUT_OF_RANGE, 0); 1659 return check_condition_result; 1660 } 1661 /* transfer length excessive (tie in to block limits VPD page) */ 1662 if (num > sdebug_store_sectors) { 1663 mk_sense_buffer(devi, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0); 1664 return check_condition_result; 1665 } 1666 return 0; 1667 } 1668 1669 static int do_device_access(struct scsi_cmnd *scmd, 1670 struct sdebug_dev_info *devi, 1671 unsigned long long lba, unsigned int num, int write) 1672 { 1673 int ret; 1674 unsigned long long block, rest = 0; 1675 int (*func)(struct scsi_cmnd *, unsigned char *, int); 1676 1677 func = write ? fetch_to_dev_buffer : fill_from_dev_buffer; 1678 1679 block = do_div(lba, sdebug_store_sectors); 1680 if (block + num > sdebug_store_sectors) 1681 rest = block + num - sdebug_store_sectors; 1682 1683 ret = func(scmd, fake_storep + (block * scsi_debug_sector_size), 1684 (num - rest) * scsi_debug_sector_size); 1685 if (!ret && rest) 1686 ret = func(scmd, fake_storep, rest * scsi_debug_sector_size); 1687 1688 return ret; 1689 } 1690 1691 static int prot_verify_read(struct scsi_cmnd *SCpnt, sector_t start_sec, 1692 unsigned int sectors, u32 ei_lba) 1693 { 1694 unsigned int i, resid; 1695 struct scatterlist *psgl; 1696 struct sd_dif_tuple *sdt; 1697 sector_t sector; 1698 sector_t tmp_sec = start_sec; 1699 void *paddr; 1700 1701 start_sec = do_div(tmp_sec, sdebug_store_sectors); 1702 1703 sdt = (struct sd_dif_tuple *)(dif_storep + dif_offset(start_sec)); 1704 1705 for (i = 0 ; i < sectors ; i++) { 1706 u16 csum; 1707 1708 if (sdt[i].app_tag == 0xffff) 1709 continue; 1710 1711 sector = start_sec + i; 1712 1713 switch (scsi_debug_guard) { 1714 case 1: 1715 csum = ip_compute_csum(fake_storep + 1716 sector * scsi_debug_sector_size, 1717 scsi_debug_sector_size); 1718 break; 1719 case 0: 1720 csum = crc_t10dif(fake_storep + 1721 sector * scsi_debug_sector_size, 1722 scsi_debug_sector_size); 1723 csum = cpu_to_be16(csum); 1724 break; 1725 default: 1726 BUG(); 1727 } 1728 1729 if (sdt[i].guard_tag != csum) { 1730 printk(KERN_ERR "%s: GUARD check failed on sector %lu" \ 1731 " rcvd 0x%04x, data 0x%04x\n", __func__, 1732 (unsigned long)sector, 1733 be16_to_cpu(sdt[i].guard_tag), 1734 be16_to_cpu(csum)); 1735 dif_errors++; 1736 return 0x01; 1737 } 1738 1739 if (scsi_debug_dif == SD_DIF_TYPE1_PROTECTION && 1740 be32_to_cpu(sdt[i].ref_tag) != (sector & 0xffffffff)) { 1741 printk(KERN_ERR "%s: REF check failed on sector %lu\n", 1742 __func__, (unsigned long)sector); 1743 dif_errors++; 1744 return 0x03; 1745 } 1746 1747 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION && 1748 be32_to_cpu(sdt[i].ref_tag) != ei_lba) { 1749 printk(KERN_ERR "%s: REF check failed on sector %lu\n", 1750 __func__, (unsigned long)sector); 1751 dif_errors++; 1752 return 0x03; 1753 } 1754 1755 ei_lba++; 1756 } 1757 1758 resid = sectors * 8; /* Bytes of protection data to copy into sgl */ 1759 sector = start_sec; 1760 1761 scsi_for_each_prot_sg(SCpnt, psgl, scsi_prot_sg_count(SCpnt), i) { 1762 int len = min(psgl->length, resid); 1763 1764 paddr = kmap_atomic(sg_page(psgl), KM_IRQ0) + psgl->offset; 1765 memcpy(paddr, dif_storep + dif_offset(sector), len); 1766 1767 sector += len >> 3; 1768 if (sector >= sdebug_store_sectors) { 1769 /* Force wrap */ 1770 tmp_sec = sector; 1771 sector = do_div(tmp_sec, sdebug_store_sectors); 1772 } 1773 resid -= len; 1774 kunmap_atomic(paddr, KM_IRQ0); 1775 } 1776 1777 dix_reads++; 1778 1779 return 0; 1780 } 1781 1782 static int resp_read(struct scsi_cmnd *SCpnt, unsigned long long lba, 1783 unsigned int num, struct sdebug_dev_info *devip, 1784 u32 ei_lba) 1785 { 1786 unsigned long iflags; 1787 int ret; 1788 1789 ret = check_device_access_params(devip, lba, num); 1790 if (ret) 1791 return ret; 1792 1793 if ((SCSI_DEBUG_OPT_MEDIUM_ERR & scsi_debug_opts) && 1794 (lba <= OPT_MEDIUM_ERR_ADDR) && 1795 ((lba + num) > OPT_MEDIUM_ERR_ADDR)) { 1796 /* claim unrecoverable read error */ 1797 mk_sense_buffer(devip, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 1798 0); 1799 /* set info field and valid bit for fixed descriptor */ 1800 if (0x70 == (devip->sense_buff[0] & 0x7f)) { 1801 devip->sense_buff[0] |= 0x80; /* Valid bit */ 1802 ret = OPT_MEDIUM_ERR_ADDR; 1803 devip->sense_buff[3] = (ret >> 24) & 0xff; 1804 devip->sense_buff[4] = (ret >> 16) & 0xff; 1805 devip->sense_buff[5] = (ret >> 8) & 0xff; 1806 devip->sense_buff[6] = ret & 0xff; 1807 } 1808 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt)); 1809 return check_condition_result; 1810 } 1811 1812 /* DIX + T10 DIF */ 1813 if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) { 1814 int prot_ret = prot_verify_read(SCpnt, lba, num, ei_lba); 1815 1816 if (prot_ret) { 1817 mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, prot_ret); 1818 return illegal_condition_result; 1819 } 1820 } 1821 1822 read_lock_irqsave(&atomic_rw, iflags); 1823 ret = do_device_access(SCpnt, devip, lba, num, 0); 1824 read_unlock_irqrestore(&atomic_rw, iflags); 1825 return ret; 1826 } 1827 1828 void dump_sector(unsigned char *buf, int len) 1829 { 1830 int i, j; 1831 1832 printk(KERN_ERR ">>> Sector Dump <<<\n"); 1833 1834 for (i = 0 ; i < len ; i += 16) { 1835 printk(KERN_ERR "%04d: ", i); 1836 1837 for (j = 0 ; j < 16 ; j++) { 1838 unsigned char c = buf[i+j]; 1839 if (c >= 0x20 && c < 0x7e) 1840 printk(" %c ", buf[i+j]); 1841 else 1842 printk("%02x ", buf[i+j]); 1843 } 1844 1845 printk("\n"); 1846 } 1847 } 1848 1849 static int prot_verify_write(struct scsi_cmnd *SCpnt, sector_t start_sec, 1850 unsigned int sectors, u32 ei_lba) 1851 { 1852 int i, j, ret; 1853 struct sd_dif_tuple *sdt; 1854 struct scatterlist *dsgl = scsi_sglist(SCpnt); 1855 struct scatterlist *psgl = scsi_prot_sglist(SCpnt); 1856 void *daddr, *paddr; 1857 sector_t tmp_sec = start_sec; 1858 sector_t sector; 1859 int ppage_offset; 1860 unsigned short csum; 1861 1862 sector = do_div(tmp_sec, sdebug_store_sectors); 1863 1864 BUG_ON(scsi_sg_count(SCpnt) == 0); 1865 BUG_ON(scsi_prot_sg_count(SCpnt) == 0); 1866 1867 paddr = kmap_atomic(sg_page(psgl), KM_IRQ1) + psgl->offset; 1868 ppage_offset = 0; 1869 1870 /* For each data page */ 1871 scsi_for_each_sg(SCpnt, dsgl, scsi_sg_count(SCpnt), i) { 1872 daddr = kmap_atomic(sg_page(dsgl), KM_IRQ0) + dsgl->offset; 1873 1874 /* For each sector-sized chunk in data page */ 1875 for (j = 0 ; j < dsgl->length ; j += scsi_debug_sector_size) { 1876 1877 /* If we're at the end of the current 1878 * protection page advance to the next one 1879 */ 1880 if (ppage_offset >= psgl->length) { 1881 kunmap_atomic(paddr, KM_IRQ1); 1882 psgl = sg_next(psgl); 1883 BUG_ON(psgl == NULL); 1884 paddr = kmap_atomic(sg_page(psgl), KM_IRQ1) 1885 + psgl->offset; 1886 ppage_offset = 0; 1887 } 1888 1889 sdt = paddr + ppage_offset; 1890 1891 switch (scsi_debug_guard) { 1892 case 1: 1893 csum = ip_compute_csum(daddr, 1894 scsi_debug_sector_size); 1895 break; 1896 case 0: 1897 csum = cpu_to_be16(crc_t10dif(daddr, 1898 scsi_debug_sector_size)); 1899 break; 1900 default: 1901 BUG(); 1902 ret = 0; 1903 goto out; 1904 } 1905 1906 if (sdt->guard_tag != csum) { 1907 printk(KERN_ERR 1908 "%s: GUARD check failed on sector %lu " \ 1909 "rcvd 0x%04x, calculated 0x%04x\n", 1910 __func__, (unsigned long)sector, 1911 be16_to_cpu(sdt->guard_tag), 1912 be16_to_cpu(csum)); 1913 ret = 0x01; 1914 dump_sector(daddr, scsi_debug_sector_size); 1915 goto out; 1916 } 1917 1918 if (scsi_debug_dif == SD_DIF_TYPE1_PROTECTION && 1919 be32_to_cpu(sdt->ref_tag) 1920 != (start_sec & 0xffffffff)) { 1921 printk(KERN_ERR 1922 "%s: REF check failed on sector %lu\n", 1923 __func__, (unsigned long)sector); 1924 ret = 0x03; 1925 dump_sector(daddr, scsi_debug_sector_size); 1926 goto out; 1927 } 1928 1929 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION && 1930 be32_to_cpu(sdt->ref_tag) != ei_lba) { 1931 printk(KERN_ERR 1932 "%s: REF check failed on sector %lu\n", 1933 __func__, (unsigned long)sector); 1934 ret = 0x03; 1935 dump_sector(daddr, scsi_debug_sector_size); 1936 goto out; 1937 } 1938 1939 /* Would be great to copy this in bigger 1940 * chunks. However, for the sake of 1941 * correctness we need to verify each sector 1942 * before writing it to "stable" storage 1943 */ 1944 memcpy(dif_storep + dif_offset(sector), sdt, 8); 1945 1946 sector++; 1947 1948 if (sector == sdebug_store_sectors) 1949 sector = 0; /* Force wrap */ 1950 1951 start_sec++; 1952 ei_lba++; 1953 daddr += scsi_debug_sector_size; 1954 ppage_offset += sizeof(struct sd_dif_tuple); 1955 } 1956 1957 kunmap_atomic(daddr, KM_IRQ0); 1958 } 1959 1960 kunmap_atomic(paddr, KM_IRQ1); 1961 1962 dix_writes++; 1963 1964 return 0; 1965 1966 out: 1967 dif_errors++; 1968 kunmap_atomic(daddr, KM_IRQ0); 1969 kunmap_atomic(paddr, KM_IRQ1); 1970 return ret; 1971 } 1972 1973 static unsigned int map_state(sector_t lba, unsigned int *num) 1974 { 1975 unsigned int granularity, alignment, mapped; 1976 sector_t block, next, end; 1977 1978 granularity = scsi_debug_unmap_granularity; 1979 alignment = granularity - scsi_debug_unmap_alignment; 1980 block = lba + alignment; 1981 do_div(block, granularity); 1982 1983 mapped = test_bit(block, map_storep); 1984 1985 if (mapped) 1986 next = find_next_zero_bit(map_storep, map_size, block); 1987 else 1988 next = find_next_bit(map_storep, map_size, block); 1989 1990 end = next * granularity - scsi_debug_unmap_alignment; 1991 *num = end - lba; 1992 1993 return mapped; 1994 } 1995 1996 static void map_region(sector_t lba, unsigned int len) 1997 { 1998 unsigned int granularity, alignment; 1999 sector_t end = lba + len; 2000 2001 granularity = scsi_debug_unmap_granularity; 2002 alignment = granularity - scsi_debug_unmap_alignment; 2003 2004 while (lba < end) { 2005 sector_t block, rem; 2006 2007 block = lba + alignment; 2008 rem = do_div(block, granularity); 2009 2010 if (block < map_size) 2011 set_bit(block, map_storep); 2012 2013 lba += granularity - rem; 2014 } 2015 } 2016 2017 static void unmap_region(sector_t lba, unsigned int len) 2018 { 2019 unsigned int granularity, alignment; 2020 sector_t end = lba + len; 2021 2022 granularity = scsi_debug_unmap_granularity; 2023 alignment = granularity - scsi_debug_unmap_alignment; 2024 2025 while (lba < end) { 2026 sector_t block, rem; 2027 2028 block = lba + alignment; 2029 rem = do_div(block, granularity); 2030 2031 if (rem == 0 && lba + granularity <= end && 2032 block < map_size) 2033 clear_bit(block, map_storep); 2034 2035 lba += granularity - rem; 2036 } 2037 } 2038 2039 static int resp_write(struct scsi_cmnd *SCpnt, unsigned long long lba, 2040 unsigned int num, struct sdebug_dev_info *devip, 2041 u32 ei_lba) 2042 { 2043 unsigned long iflags; 2044 int ret; 2045 2046 ret = check_device_access_params(devip, lba, num); 2047 if (ret) 2048 return ret; 2049 2050 /* DIX + T10 DIF */ 2051 if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) { 2052 int prot_ret = prot_verify_write(SCpnt, lba, num, ei_lba); 2053 2054 if (prot_ret) { 2055 mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, prot_ret); 2056 return illegal_condition_result; 2057 } 2058 } 2059 2060 write_lock_irqsave(&atomic_rw, iflags); 2061 ret = do_device_access(SCpnt, devip, lba, num, 1); 2062 if (scsi_debug_unmap_granularity) 2063 map_region(lba, num); 2064 write_unlock_irqrestore(&atomic_rw, iflags); 2065 if (-1 == ret) 2066 return (DID_ERROR << 16); 2067 else if ((ret < (num * scsi_debug_sector_size)) && 2068 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)) 2069 printk(KERN_INFO "scsi_debug: write: cdb indicated=%u, " 2070 " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret); 2071 2072 return 0; 2073 } 2074 2075 static int resp_write_same(struct scsi_cmnd *scmd, unsigned long long lba, 2076 unsigned int num, struct sdebug_dev_info *devip, 2077 u32 ei_lba, unsigned int unmap) 2078 { 2079 unsigned long iflags; 2080 unsigned long long i; 2081 int ret; 2082 2083 ret = check_device_access_params(devip, lba, num); 2084 if (ret) 2085 return ret; 2086 2087 write_lock_irqsave(&atomic_rw, iflags); 2088 2089 if (unmap && scsi_debug_unmap_granularity) { 2090 unmap_region(lba, num); 2091 goto out; 2092 } 2093 2094 /* Else fetch one logical block */ 2095 ret = fetch_to_dev_buffer(scmd, 2096 fake_storep + (lba * scsi_debug_sector_size), 2097 scsi_debug_sector_size); 2098 2099 if (-1 == ret) { 2100 write_unlock_irqrestore(&atomic_rw, iflags); 2101 return (DID_ERROR << 16); 2102 } else if ((ret < (num * scsi_debug_sector_size)) && 2103 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)) 2104 printk(KERN_INFO "scsi_debug: write same: cdb indicated=%u, " 2105 " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret); 2106 2107 /* Copy first sector to remaining blocks */ 2108 for (i = 1 ; i < num ; i++) 2109 memcpy(fake_storep + ((lba + i) * scsi_debug_sector_size), 2110 fake_storep + (lba * scsi_debug_sector_size), 2111 scsi_debug_sector_size); 2112 2113 if (scsi_debug_unmap_granularity) 2114 map_region(lba, num); 2115 out: 2116 write_unlock_irqrestore(&atomic_rw, iflags); 2117 2118 return 0; 2119 } 2120 2121 struct unmap_block_desc { 2122 __be64 lba; 2123 __be32 blocks; 2124 __be32 __reserved; 2125 }; 2126 2127 static int resp_unmap(struct scsi_cmnd * scmd, struct sdebug_dev_info * devip) 2128 { 2129 unsigned char *buf; 2130 struct unmap_block_desc *desc; 2131 unsigned int i, payload_len, descriptors; 2132 int ret; 2133 2134 ret = check_readiness(scmd, 1, devip); 2135 if (ret) 2136 return ret; 2137 2138 payload_len = get_unaligned_be16(&scmd->cmnd[7]); 2139 BUG_ON(scsi_bufflen(scmd) != payload_len); 2140 2141 descriptors = (payload_len - 8) / 16; 2142 2143 buf = kmalloc(scsi_bufflen(scmd), GFP_ATOMIC); 2144 if (!buf) 2145 return check_condition_result; 2146 2147 scsi_sg_copy_to_buffer(scmd, buf, scsi_bufflen(scmd)); 2148 2149 BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2); 2150 BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16); 2151 2152 desc = (void *)&buf[8]; 2153 2154 for (i = 0 ; i < descriptors ; i++) { 2155 unsigned long long lba = get_unaligned_be64(&desc[i].lba); 2156 unsigned int num = get_unaligned_be32(&desc[i].blocks); 2157 2158 ret = check_device_access_params(devip, lba, num); 2159 if (ret) 2160 goto out; 2161 2162 unmap_region(lba, num); 2163 } 2164 2165 ret = 0; 2166 2167 out: 2168 kfree(buf); 2169 2170 return ret; 2171 } 2172 2173 #define SDEBUG_GET_LBA_STATUS_LEN 32 2174 2175 static int resp_get_lba_status(struct scsi_cmnd * scmd, 2176 struct sdebug_dev_info * devip) 2177 { 2178 unsigned long long lba; 2179 unsigned int alloc_len, mapped, num; 2180 unsigned char arr[SDEBUG_GET_LBA_STATUS_LEN]; 2181 int ret; 2182 2183 ret = check_readiness(scmd, 1, devip); 2184 if (ret) 2185 return ret; 2186 2187 lba = get_unaligned_be64(&scmd->cmnd[2]); 2188 alloc_len = get_unaligned_be32(&scmd->cmnd[10]); 2189 2190 if (alloc_len < 24) 2191 return 0; 2192 2193 ret = check_device_access_params(devip, lba, 1); 2194 if (ret) 2195 return ret; 2196 2197 mapped = map_state(lba, &num); 2198 2199 memset(arr, 0, SDEBUG_GET_LBA_STATUS_LEN); 2200 put_unaligned_be32(16, &arr[0]); /* Parameter Data Length */ 2201 put_unaligned_be64(lba, &arr[8]); /* LBA */ 2202 put_unaligned_be32(num, &arr[16]); /* Number of blocks */ 2203 arr[20] = !mapped; /* mapped = 0, unmapped = 1 */ 2204 2205 return fill_from_dev_buffer(scmd, arr, SDEBUG_GET_LBA_STATUS_LEN); 2206 } 2207 2208 #define SDEBUG_RLUN_ARR_SZ 256 2209 2210 static int resp_report_luns(struct scsi_cmnd * scp, 2211 struct sdebug_dev_info * devip) 2212 { 2213 unsigned int alloc_len; 2214 int lun_cnt, i, upper, num, n, wlun, lun; 2215 unsigned char *cmd = (unsigned char *)scp->cmnd; 2216 int select_report = (int)cmd[2]; 2217 struct scsi_lun *one_lun; 2218 unsigned char arr[SDEBUG_RLUN_ARR_SZ]; 2219 unsigned char * max_addr; 2220 2221 alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24); 2222 if ((alloc_len < 4) || (select_report > 2)) { 2223 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 2224 0); 2225 return check_condition_result; 2226 } 2227 /* can produce response with up to 16k luns (lun 0 to lun 16383) */ 2228 memset(arr, 0, SDEBUG_RLUN_ARR_SZ); 2229 lun_cnt = scsi_debug_max_luns; 2230 if (1 == select_report) 2231 lun_cnt = 0; 2232 else if (scsi_debug_no_lun_0 && (lun_cnt > 0)) 2233 --lun_cnt; 2234 wlun = (select_report > 0) ? 1 : 0; 2235 num = lun_cnt + wlun; 2236 arr[2] = ((sizeof(struct scsi_lun) * num) >> 8) & 0xff; 2237 arr[3] = (sizeof(struct scsi_lun) * num) & 0xff; 2238 n = min((int)((SDEBUG_RLUN_ARR_SZ - 8) / 2239 sizeof(struct scsi_lun)), num); 2240 if (n < num) { 2241 wlun = 0; 2242 lun_cnt = n; 2243 } 2244 one_lun = (struct scsi_lun *) &arr[8]; 2245 max_addr = arr + SDEBUG_RLUN_ARR_SZ; 2246 for (i = 0, lun = (scsi_debug_no_lun_0 ? 1 : 0); 2247 ((i < lun_cnt) && ((unsigned char *)(one_lun + i) < max_addr)); 2248 i++, lun++) { 2249 upper = (lun >> 8) & 0x3f; 2250 if (upper) 2251 one_lun[i].scsi_lun[0] = 2252 (upper | (SAM2_LUN_ADDRESS_METHOD << 6)); 2253 one_lun[i].scsi_lun[1] = lun & 0xff; 2254 } 2255 if (wlun) { 2256 one_lun[i].scsi_lun[0] = (SAM2_WLUN_REPORT_LUNS >> 8) & 0xff; 2257 one_lun[i].scsi_lun[1] = SAM2_WLUN_REPORT_LUNS & 0xff; 2258 i++; 2259 } 2260 alloc_len = (unsigned char *)(one_lun + i) - arr; 2261 return fill_from_dev_buffer(scp, arr, 2262 min((int)alloc_len, SDEBUG_RLUN_ARR_SZ)); 2263 } 2264 2265 static int resp_xdwriteread(struct scsi_cmnd *scp, unsigned long long lba, 2266 unsigned int num, struct sdebug_dev_info *devip) 2267 { 2268 int i, j, ret = -1; 2269 unsigned char *kaddr, *buf; 2270 unsigned int offset; 2271 struct scatterlist *sg; 2272 struct scsi_data_buffer *sdb = scsi_in(scp); 2273 2274 /* better not to use temporary buffer. */ 2275 buf = kmalloc(scsi_bufflen(scp), GFP_ATOMIC); 2276 if (!buf) 2277 return ret; 2278 2279 scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp)); 2280 2281 offset = 0; 2282 for_each_sg(sdb->table.sgl, sg, sdb->table.nents, i) { 2283 kaddr = (unsigned char *)kmap_atomic(sg_page(sg), KM_USER0); 2284 if (!kaddr) 2285 goto out; 2286 2287 for (j = 0; j < sg->length; j++) 2288 *(kaddr + sg->offset + j) ^= *(buf + offset + j); 2289 2290 offset += sg->length; 2291 kunmap_atomic(kaddr, KM_USER0); 2292 } 2293 ret = 0; 2294 out: 2295 kfree(buf); 2296 2297 return ret; 2298 } 2299 2300 /* When timer goes off this function is called. */ 2301 static void timer_intr_handler(unsigned long indx) 2302 { 2303 struct sdebug_queued_cmd * sqcp; 2304 unsigned long iflags; 2305 2306 if (indx >= scsi_debug_max_queue) { 2307 printk(KERN_ERR "scsi_debug:timer_intr_handler: indx too " 2308 "large\n"); 2309 return; 2310 } 2311 spin_lock_irqsave(&queued_arr_lock, iflags); 2312 sqcp = &queued_arr[(int)indx]; 2313 if (! sqcp->in_use) { 2314 printk(KERN_ERR "scsi_debug:timer_intr_handler: Unexpected " 2315 "interrupt\n"); 2316 spin_unlock_irqrestore(&queued_arr_lock, iflags); 2317 return; 2318 } 2319 sqcp->in_use = 0; 2320 if (sqcp->done_funct) { 2321 sqcp->a_cmnd->result = sqcp->scsi_result; 2322 sqcp->done_funct(sqcp->a_cmnd); /* callback to mid level */ 2323 } 2324 sqcp->done_funct = NULL; 2325 spin_unlock_irqrestore(&queued_arr_lock, iflags); 2326 } 2327 2328 2329 static struct sdebug_dev_info * 2330 sdebug_device_create(struct sdebug_host_info *sdbg_host, gfp_t flags) 2331 { 2332 struct sdebug_dev_info *devip; 2333 2334 devip = kzalloc(sizeof(*devip), flags); 2335 if (devip) { 2336 devip->sdbg_host = sdbg_host; 2337 list_add_tail(&devip->dev_list, &sdbg_host->dev_info_list); 2338 } 2339 return devip; 2340 } 2341 2342 static struct sdebug_dev_info * devInfoReg(struct scsi_device * sdev) 2343 { 2344 struct sdebug_host_info * sdbg_host; 2345 struct sdebug_dev_info * open_devip = NULL; 2346 struct sdebug_dev_info * devip = 2347 (struct sdebug_dev_info *)sdev->hostdata; 2348 2349 if (devip) 2350 return devip; 2351 sdbg_host = *(struct sdebug_host_info **)shost_priv(sdev->host); 2352 if (!sdbg_host) { 2353 printk(KERN_ERR "Host info NULL\n"); 2354 return NULL; 2355 } 2356 list_for_each_entry(devip, &sdbg_host->dev_info_list, dev_list) { 2357 if ((devip->used) && (devip->channel == sdev->channel) && 2358 (devip->target == sdev->id) && 2359 (devip->lun == sdev->lun)) 2360 return devip; 2361 else { 2362 if ((!devip->used) && (!open_devip)) 2363 open_devip = devip; 2364 } 2365 } 2366 if (!open_devip) { /* try and make a new one */ 2367 open_devip = sdebug_device_create(sdbg_host, GFP_ATOMIC); 2368 if (!open_devip) { 2369 printk(KERN_ERR "%s: out of memory at line %d\n", 2370 __func__, __LINE__); 2371 return NULL; 2372 } 2373 } 2374 2375 open_devip->channel = sdev->channel; 2376 open_devip->target = sdev->id; 2377 open_devip->lun = sdev->lun; 2378 open_devip->sdbg_host = sdbg_host; 2379 open_devip->reset = 1; 2380 open_devip->used = 1; 2381 memset(open_devip->sense_buff, 0, SDEBUG_SENSE_LEN); 2382 if (scsi_debug_dsense) 2383 open_devip->sense_buff[0] = 0x72; 2384 else { 2385 open_devip->sense_buff[0] = 0x70; 2386 open_devip->sense_buff[7] = 0xa; 2387 } 2388 if (sdev->lun == SAM2_WLUN_REPORT_LUNS) 2389 open_devip->wlun = SAM2_WLUN_REPORT_LUNS & 0xff; 2390 2391 return open_devip; 2392 } 2393 2394 static int scsi_debug_slave_alloc(struct scsi_device *sdp) 2395 { 2396 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 2397 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n", 2398 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun); 2399 queue_flag_set_unlocked(QUEUE_FLAG_BIDI, sdp->request_queue); 2400 return 0; 2401 } 2402 2403 static int scsi_debug_slave_configure(struct scsi_device *sdp) 2404 { 2405 struct sdebug_dev_info *devip; 2406 2407 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 2408 printk(KERN_INFO "scsi_debug: slave_configure <%u %u %u %u>\n", 2409 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun); 2410 if (sdp->host->max_cmd_len != SCSI_DEBUG_MAX_CMD_LEN) 2411 sdp->host->max_cmd_len = SCSI_DEBUG_MAX_CMD_LEN; 2412 devip = devInfoReg(sdp); 2413 if (NULL == devip) 2414 return 1; /* no resources, will be marked offline */ 2415 sdp->hostdata = devip; 2416 if (sdp->host->cmd_per_lun) 2417 scsi_adjust_queue_depth(sdp, SDEBUG_TAGGED_QUEUING, 2418 sdp->host->cmd_per_lun); 2419 blk_queue_max_segment_size(sdp->request_queue, 256 * 1024); 2420 if (scsi_debug_no_uld) 2421 sdp->no_uld_attach = 1; 2422 return 0; 2423 } 2424 2425 static void scsi_debug_slave_destroy(struct scsi_device *sdp) 2426 { 2427 struct sdebug_dev_info *devip = 2428 (struct sdebug_dev_info *)sdp->hostdata; 2429 2430 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 2431 printk(KERN_INFO "scsi_debug: slave_destroy <%u %u %u %u>\n", 2432 sdp->host->host_no, sdp->channel, sdp->id, sdp->lun); 2433 if (devip) { 2434 /* make this slot avaliable for re-use */ 2435 devip->used = 0; 2436 sdp->hostdata = NULL; 2437 } 2438 } 2439 2440 /* Returns 1 if found 'cmnd' and deleted its timer. else returns 0 */ 2441 static int stop_queued_cmnd(struct scsi_cmnd *cmnd) 2442 { 2443 unsigned long iflags; 2444 int k; 2445 struct sdebug_queued_cmd *sqcp; 2446 2447 spin_lock_irqsave(&queued_arr_lock, iflags); 2448 for (k = 0; k < scsi_debug_max_queue; ++k) { 2449 sqcp = &queued_arr[k]; 2450 if (sqcp->in_use && (cmnd == sqcp->a_cmnd)) { 2451 del_timer_sync(&sqcp->cmnd_timer); 2452 sqcp->in_use = 0; 2453 sqcp->a_cmnd = NULL; 2454 break; 2455 } 2456 } 2457 spin_unlock_irqrestore(&queued_arr_lock, iflags); 2458 return (k < scsi_debug_max_queue) ? 1 : 0; 2459 } 2460 2461 /* Deletes (stops) timers of all queued commands */ 2462 static void stop_all_queued(void) 2463 { 2464 unsigned long iflags; 2465 int k; 2466 struct sdebug_queued_cmd *sqcp; 2467 2468 spin_lock_irqsave(&queued_arr_lock, iflags); 2469 for (k = 0; k < scsi_debug_max_queue; ++k) { 2470 sqcp = &queued_arr[k]; 2471 if (sqcp->in_use && sqcp->a_cmnd) { 2472 del_timer_sync(&sqcp->cmnd_timer); 2473 sqcp->in_use = 0; 2474 sqcp->a_cmnd = NULL; 2475 } 2476 } 2477 spin_unlock_irqrestore(&queued_arr_lock, iflags); 2478 } 2479 2480 static int scsi_debug_abort(struct scsi_cmnd * SCpnt) 2481 { 2482 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 2483 printk(KERN_INFO "scsi_debug: abort\n"); 2484 ++num_aborts; 2485 stop_queued_cmnd(SCpnt); 2486 return SUCCESS; 2487 } 2488 2489 static int scsi_debug_biosparam(struct scsi_device *sdev, 2490 struct block_device * bdev, sector_t capacity, int *info) 2491 { 2492 int res; 2493 unsigned char *buf; 2494 2495 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 2496 printk(KERN_INFO "scsi_debug: biosparam\n"); 2497 buf = scsi_bios_ptable(bdev); 2498 if (buf) { 2499 res = scsi_partsize(buf, capacity, 2500 &info[2], &info[0], &info[1]); 2501 kfree(buf); 2502 if (! res) 2503 return res; 2504 } 2505 info[0] = sdebug_heads; 2506 info[1] = sdebug_sectors_per; 2507 info[2] = sdebug_cylinders_per; 2508 return 0; 2509 } 2510 2511 static int scsi_debug_device_reset(struct scsi_cmnd * SCpnt) 2512 { 2513 struct sdebug_dev_info * devip; 2514 2515 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 2516 printk(KERN_INFO "scsi_debug: device_reset\n"); 2517 ++num_dev_resets; 2518 if (SCpnt) { 2519 devip = devInfoReg(SCpnt->device); 2520 if (devip) 2521 devip->reset = 1; 2522 } 2523 return SUCCESS; 2524 } 2525 2526 static int scsi_debug_bus_reset(struct scsi_cmnd * SCpnt) 2527 { 2528 struct sdebug_host_info *sdbg_host; 2529 struct sdebug_dev_info * dev_info; 2530 struct scsi_device * sdp; 2531 struct Scsi_Host * hp; 2532 2533 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 2534 printk(KERN_INFO "scsi_debug: bus_reset\n"); 2535 ++num_bus_resets; 2536 if (SCpnt && ((sdp = SCpnt->device)) && ((hp = sdp->host))) { 2537 sdbg_host = *(struct sdebug_host_info **)shost_priv(hp); 2538 if (sdbg_host) { 2539 list_for_each_entry(dev_info, 2540 &sdbg_host->dev_info_list, 2541 dev_list) 2542 dev_info->reset = 1; 2543 } 2544 } 2545 return SUCCESS; 2546 } 2547 2548 static int scsi_debug_host_reset(struct scsi_cmnd * SCpnt) 2549 { 2550 struct sdebug_host_info * sdbg_host; 2551 struct sdebug_dev_info * dev_info; 2552 2553 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 2554 printk(KERN_INFO "scsi_debug: host_reset\n"); 2555 ++num_host_resets; 2556 spin_lock(&sdebug_host_list_lock); 2557 list_for_each_entry(sdbg_host, &sdebug_host_list, host_list) { 2558 list_for_each_entry(dev_info, &sdbg_host->dev_info_list, 2559 dev_list) 2560 dev_info->reset = 1; 2561 } 2562 spin_unlock(&sdebug_host_list_lock); 2563 stop_all_queued(); 2564 return SUCCESS; 2565 } 2566 2567 /* Initializes timers in queued array */ 2568 static void __init init_all_queued(void) 2569 { 2570 unsigned long iflags; 2571 int k; 2572 struct sdebug_queued_cmd * sqcp; 2573 2574 spin_lock_irqsave(&queued_arr_lock, iflags); 2575 for (k = 0; k < scsi_debug_max_queue; ++k) { 2576 sqcp = &queued_arr[k]; 2577 init_timer(&sqcp->cmnd_timer); 2578 sqcp->in_use = 0; 2579 sqcp->a_cmnd = NULL; 2580 } 2581 spin_unlock_irqrestore(&queued_arr_lock, iflags); 2582 } 2583 2584 static void __init sdebug_build_parts(unsigned char *ramp, 2585 unsigned long store_size) 2586 { 2587 struct partition * pp; 2588 int starts[SDEBUG_MAX_PARTS + 2]; 2589 int sectors_per_part, num_sectors, k; 2590 int heads_by_sects, start_sec, end_sec; 2591 2592 /* assume partition table already zeroed */ 2593 if ((scsi_debug_num_parts < 1) || (store_size < 1048576)) 2594 return; 2595 if (scsi_debug_num_parts > SDEBUG_MAX_PARTS) { 2596 scsi_debug_num_parts = SDEBUG_MAX_PARTS; 2597 printk(KERN_WARNING "scsi_debug:build_parts: reducing " 2598 "partitions to %d\n", SDEBUG_MAX_PARTS); 2599 } 2600 num_sectors = (int)sdebug_store_sectors; 2601 sectors_per_part = (num_sectors - sdebug_sectors_per) 2602 / scsi_debug_num_parts; 2603 heads_by_sects = sdebug_heads * sdebug_sectors_per; 2604 starts[0] = sdebug_sectors_per; 2605 for (k = 1; k < scsi_debug_num_parts; ++k) 2606 starts[k] = ((k * sectors_per_part) / heads_by_sects) 2607 * heads_by_sects; 2608 starts[scsi_debug_num_parts] = num_sectors; 2609 starts[scsi_debug_num_parts + 1] = 0; 2610 2611 ramp[510] = 0x55; /* magic partition markings */ 2612 ramp[511] = 0xAA; 2613 pp = (struct partition *)(ramp + 0x1be); 2614 for (k = 0; starts[k + 1]; ++k, ++pp) { 2615 start_sec = starts[k]; 2616 end_sec = starts[k + 1] - 1; 2617 pp->boot_ind = 0; 2618 2619 pp->cyl = start_sec / heads_by_sects; 2620 pp->head = (start_sec - (pp->cyl * heads_by_sects)) 2621 / sdebug_sectors_per; 2622 pp->sector = (start_sec % sdebug_sectors_per) + 1; 2623 2624 pp->end_cyl = end_sec / heads_by_sects; 2625 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects)) 2626 / sdebug_sectors_per; 2627 pp->end_sector = (end_sec % sdebug_sectors_per) + 1; 2628 2629 pp->start_sect = start_sec; 2630 pp->nr_sects = end_sec - start_sec + 1; 2631 pp->sys_ind = 0x83; /* plain Linux partition */ 2632 } 2633 } 2634 2635 static int schedule_resp(struct scsi_cmnd * cmnd, 2636 struct sdebug_dev_info * devip, 2637 done_funct_t done, int scsi_result, int delta_jiff) 2638 { 2639 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmnd) { 2640 if (scsi_result) { 2641 struct scsi_device * sdp = cmnd->device; 2642 2643 printk(KERN_INFO "scsi_debug: <%u %u %u %u> " 2644 "non-zero result=0x%x\n", sdp->host->host_no, 2645 sdp->channel, sdp->id, sdp->lun, scsi_result); 2646 } 2647 } 2648 if (cmnd && devip) { 2649 /* simulate autosense by this driver */ 2650 if (SAM_STAT_CHECK_CONDITION == (scsi_result & 0xff)) 2651 memcpy(cmnd->sense_buffer, devip->sense_buff, 2652 (SCSI_SENSE_BUFFERSIZE > SDEBUG_SENSE_LEN) ? 2653 SDEBUG_SENSE_LEN : SCSI_SENSE_BUFFERSIZE); 2654 } 2655 if (delta_jiff <= 0) { 2656 if (cmnd) 2657 cmnd->result = scsi_result; 2658 if (done) 2659 done(cmnd); 2660 return 0; 2661 } else { 2662 unsigned long iflags; 2663 int k; 2664 struct sdebug_queued_cmd * sqcp = NULL; 2665 2666 spin_lock_irqsave(&queued_arr_lock, iflags); 2667 for (k = 0; k < scsi_debug_max_queue; ++k) { 2668 sqcp = &queued_arr[k]; 2669 if (! sqcp->in_use) 2670 break; 2671 } 2672 if (k >= scsi_debug_max_queue) { 2673 spin_unlock_irqrestore(&queued_arr_lock, iflags); 2674 printk(KERN_WARNING "scsi_debug: can_queue exceeded\n"); 2675 return 1; /* report busy to mid level */ 2676 } 2677 sqcp->in_use = 1; 2678 sqcp->a_cmnd = cmnd; 2679 sqcp->scsi_result = scsi_result; 2680 sqcp->done_funct = done; 2681 sqcp->cmnd_timer.function = timer_intr_handler; 2682 sqcp->cmnd_timer.data = k; 2683 sqcp->cmnd_timer.expires = jiffies + delta_jiff; 2684 add_timer(&sqcp->cmnd_timer); 2685 spin_unlock_irqrestore(&queued_arr_lock, iflags); 2686 if (cmnd) 2687 cmnd->result = 0; 2688 return 0; 2689 } 2690 } 2691 /* Note: The following macros create attribute files in the 2692 /sys/module/scsi_debug/parameters directory. Unfortunately this 2693 driver is unaware of a change and cannot trigger auxiliary actions 2694 as it can when the corresponding attribute in the 2695 /sys/bus/pseudo/drivers/scsi_debug directory is changed. 2696 */ 2697 module_param_named(add_host, scsi_debug_add_host, int, S_IRUGO | S_IWUSR); 2698 module_param_named(delay, scsi_debug_delay, int, S_IRUGO | S_IWUSR); 2699 module_param_named(dev_size_mb, scsi_debug_dev_size_mb, int, S_IRUGO); 2700 module_param_named(dsense, scsi_debug_dsense, int, S_IRUGO | S_IWUSR); 2701 module_param_named(every_nth, scsi_debug_every_nth, int, S_IRUGO | S_IWUSR); 2702 module_param_named(fake_rw, scsi_debug_fake_rw, int, S_IRUGO | S_IWUSR); 2703 module_param_named(max_luns, scsi_debug_max_luns, int, S_IRUGO | S_IWUSR); 2704 module_param_named(max_queue, scsi_debug_max_queue, int, S_IRUGO | S_IWUSR); 2705 module_param_named(no_lun_0, scsi_debug_no_lun_0, int, S_IRUGO | S_IWUSR); 2706 module_param_named(no_uld, scsi_debug_no_uld, int, S_IRUGO); 2707 module_param_named(num_parts, scsi_debug_num_parts, int, S_IRUGO); 2708 module_param_named(num_tgts, scsi_debug_num_tgts, int, S_IRUGO | S_IWUSR); 2709 module_param_named(opts, scsi_debug_opts, int, S_IRUGO | S_IWUSR); 2710 module_param_named(ptype, scsi_debug_ptype, int, S_IRUGO | S_IWUSR); 2711 module_param_named(scsi_level, scsi_debug_scsi_level, int, S_IRUGO); 2712 module_param_named(virtual_gb, scsi_debug_virtual_gb, int, S_IRUGO | S_IWUSR); 2713 module_param_named(vpd_use_hostno, scsi_debug_vpd_use_hostno, int, 2714 S_IRUGO | S_IWUSR); 2715 module_param_named(sector_size, scsi_debug_sector_size, int, S_IRUGO); 2716 module_param_named(dix, scsi_debug_dix, int, S_IRUGO); 2717 module_param_named(dif, scsi_debug_dif, int, S_IRUGO); 2718 module_param_named(guard, scsi_debug_guard, int, S_IRUGO); 2719 module_param_named(ato, scsi_debug_ato, int, S_IRUGO); 2720 module_param_named(physblk_exp, scsi_debug_physblk_exp, int, S_IRUGO); 2721 module_param_named(opt_blks, scsi_debug_opt_blks, int, S_IRUGO); 2722 module_param_named(lowest_aligned, scsi_debug_lowest_aligned, int, S_IRUGO); 2723 module_param_named(unmap_max_blocks, scsi_debug_unmap_max_blocks, int, S_IRUGO); 2724 module_param_named(unmap_max_desc, scsi_debug_unmap_max_desc, int, S_IRUGO); 2725 module_param_named(unmap_granularity, scsi_debug_unmap_granularity, int, S_IRUGO); 2726 module_param_named(unmap_alignment, scsi_debug_unmap_alignment, int, S_IRUGO); 2727 module_param_named(tpu, scsi_debug_tpu, int, S_IRUGO); 2728 module_param_named(tpws, scsi_debug_tpws, int, S_IRUGO); 2729 2730 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert"); 2731 MODULE_DESCRIPTION("SCSI debug adapter driver"); 2732 MODULE_LICENSE("GPL"); 2733 MODULE_VERSION(SCSI_DEBUG_VERSION); 2734 2735 MODULE_PARM_DESC(add_host, "0..127 hosts allowed(def=1)"); 2736 MODULE_PARM_DESC(delay, "# of jiffies to delay response(def=1)"); 2737 MODULE_PARM_DESC(dev_size_mb, "size in MB of ram shared by devs(def=8)"); 2738 MODULE_PARM_DESC(dsense, "use descriptor sense format(def=0 -> fixed)"); 2739 MODULE_PARM_DESC(every_nth, "timeout every nth command(def=0)"); 2740 MODULE_PARM_DESC(fake_rw, "fake reads/writes instead of copying (def=0)"); 2741 MODULE_PARM_DESC(max_luns, "number of LUNs per target to simulate(def=1)"); 2742 MODULE_PARM_DESC(max_queue, "max number of queued commands (1 to 255(def))"); 2743 MODULE_PARM_DESC(no_lun_0, "no LU number 0 (def=0 -> have lun 0)"); 2744 MODULE_PARM_DESC(no_uld, "stop ULD (e.g. sd driver) attaching (def=0))"); 2745 MODULE_PARM_DESC(num_parts, "number of partitions(def=0)"); 2746 MODULE_PARM_DESC(num_tgts, "number of targets per host to simulate(def=1)"); 2747 MODULE_PARM_DESC(opts, "1->noise, 2->medium_err, 4->timeout, 8->recovered_err... (def=0)"); 2748 MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])"); 2749 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])"); 2750 MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)"); 2751 MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)"); 2752 MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)"); 2753 MODULE_PARM_DESC(physblk_exp, "physical block exponent (def=0)"); 2754 MODULE_PARM_DESC(opt_blks, "optimal transfer length in block (def=64)"); 2755 MODULE_PARM_DESC(lowest_aligned, "lowest aligned lba (def=0)"); 2756 MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)"); 2757 MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)"); 2758 MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)"); 2759 MODULE_PARM_DESC(ato, "application tag ownership: 0=disk 1=host (def=1)"); 2760 MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0xffffffff)"); 2761 MODULE_PARM_DESC(unmap_max_desc, "max # of ranges that can be unmapped in one cmd (def=256)"); 2762 MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=1)"); 2763 MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)"); 2764 MODULE_PARM_DESC(tpu, "enable TP, support UNMAP command (def=0)"); 2765 MODULE_PARM_DESC(tpws, "enable TP, support WRITE SAME(16) with UNMAP bit (def=0)"); 2766 2767 static char sdebug_info[256]; 2768 2769 static const char * scsi_debug_info(struct Scsi_Host * shp) 2770 { 2771 sprintf(sdebug_info, "scsi_debug, version %s [%s], " 2772 "dev_size_mb=%d, opts=0x%x", SCSI_DEBUG_VERSION, 2773 scsi_debug_version_date, scsi_debug_dev_size_mb, 2774 scsi_debug_opts); 2775 return sdebug_info; 2776 } 2777 2778 /* scsi_debug_proc_info 2779 * Used if the driver currently has no own support for /proc/scsi 2780 */ 2781 static int scsi_debug_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset, 2782 int length, int inout) 2783 { 2784 int len, pos, begin; 2785 int orig_length; 2786 2787 orig_length = length; 2788 2789 if (inout == 1) { 2790 char arr[16]; 2791 int minLen = length > 15 ? 15 : length; 2792 2793 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO)) 2794 return -EACCES; 2795 memcpy(arr, buffer, minLen); 2796 arr[minLen] = '\0'; 2797 if (1 != sscanf(arr, "%d", &pos)) 2798 return -EINVAL; 2799 scsi_debug_opts = pos; 2800 if (scsi_debug_every_nth != 0) 2801 scsi_debug_cmnd_count = 0; 2802 return length; 2803 } 2804 begin = 0; 2805 pos = len = sprintf(buffer, "scsi_debug adapter driver, version " 2806 "%s [%s]\n" 2807 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, " 2808 "every_nth=%d(curr:%d)\n" 2809 "delay=%d, max_luns=%d, scsi_level=%d\n" 2810 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n" 2811 "number of aborts=%d, device_reset=%d, bus_resets=%d, " 2812 "host_resets=%d\ndix_reads=%d dix_writes=%d dif_errors=%d\n", 2813 SCSI_DEBUG_VERSION, scsi_debug_version_date, scsi_debug_num_tgts, 2814 scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth, 2815 scsi_debug_cmnd_count, scsi_debug_delay, 2816 scsi_debug_max_luns, scsi_debug_scsi_level, 2817 scsi_debug_sector_size, sdebug_cylinders_per, sdebug_heads, 2818 sdebug_sectors_per, num_aborts, num_dev_resets, num_bus_resets, 2819 num_host_resets, dix_reads, dix_writes, dif_errors); 2820 if (pos < offset) { 2821 len = 0; 2822 begin = pos; 2823 } 2824 *start = buffer + (offset - begin); /* Start of wanted data */ 2825 len -= (offset - begin); 2826 if (len > length) 2827 len = length; 2828 return len; 2829 } 2830 2831 static ssize_t sdebug_delay_show(struct device_driver * ddp, char * buf) 2832 { 2833 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_delay); 2834 } 2835 2836 static ssize_t sdebug_delay_store(struct device_driver * ddp, 2837 const char * buf, size_t count) 2838 { 2839 int delay; 2840 char work[20]; 2841 2842 if (1 == sscanf(buf, "%10s", work)) { 2843 if ((1 == sscanf(work, "%d", &delay)) && (delay >= 0)) { 2844 scsi_debug_delay = delay; 2845 return count; 2846 } 2847 } 2848 return -EINVAL; 2849 } 2850 DRIVER_ATTR(delay, S_IRUGO | S_IWUSR, sdebug_delay_show, 2851 sdebug_delay_store); 2852 2853 static ssize_t sdebug_opts_show(struct device_driver * ddp, char * buf) 2854 { 2855 return scnprintf(buf, PAGE_SIZE, "0x%x\n", scsi_debug_opts); 2856 } 2857 2858 static ssize_t sdebug_opts_store(struct device_driver * ddp, 2859 const char * buf, size_t count) 2860 { 2861 int opts; 2862 char work[20]; 2863 2864 if (1 == sscanf(buf, "%10s", work)) { 2865 if (0 == strnicmp(work,"0x", 2)) { 2866 if (1 == sscanf(&work[2], "%x", &opts)) 2867 goto opts_done; 2868 } else { 2869 if (1 == sscanf(work, "%d", &opts)) 2870 goto opts_done; 2871 } 2872 } 2873 return -EINVAL; 2874 opts_done: 2875 scsi_debug_opts = opts; 2876 scsi_debug_cmnd_count = 0; 2877 return count; 2878 } 2879 DRIVER_ATTR(opts, S_IRUGO | S_IWUSR, sdebug_opts_show, 2880 sdebug_opts_store); 2881 2882 static ssize_t sdebug_ptype_show(struct device_driver * ddp, char * buf) 2883 { 2884 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ptype); 2885 } 2886 static ssize_t sdebug_ptype_store(struct device_driver * ddp, 2887 const char * buf, size_t count) 2888 { 2889 int n; 2890 2891 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) { 2892 scsi_debug_ptype = n; 2893 return count; 2894 } 2895 return -EINVAL; 2896 } 2897 DRIVER_ATTR(ptype, S_IRUGO | S_IWUSR, sdebug_ptype_show, sdebug_ptype_store); 2898 2899 static ssize_t sdebug_dsense_show(struct device_driver * ddp, char * buf) 2900 { 2901 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dsense); 2902 } 2903 static ssize_t sdebug_dsense_store(struct device_driver * ddp, 2904 const char * buf, size_t count) 2905 { 2906 int n; 2907 2908 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) { 2909 scsi_debug_dsense = n; 2910 return count; 2911 } 2912 return -EINVAL; 2913 } 2914 DRIVER_ATTR(dsense, S_IRUGO | S_IWUSR, sdebug_dsense_show, 2915 sdebug_dsense_store); 2916 2917 static ssize_t sdebug_fake_rw_show(struct device_driver * ddp, char * buf) 2918 { 2919 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_fake_rw); 2920 } 2921 static ssize_t sdebug_fake_rw_store(struct device_driver * ddp, 2922 const char * buf, size_t count) 2923 { 2924 int n; 2925 2926 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) { 2927 scsi_debug_fake_rw = n; 2928 return count; 2929 } 2930 return -EINVAL; 2931 } 2932 DRIVER_ATTR(fake_rw, S_IRUGO | S_IWUSR, sdebug_fake_rw_show, 2933 sdebug_fake_rw_store); 2934 2935 static ssize_t sdebug_no_lun_0_show(struct device_driver * ddp, char * buf) 2936 { 2937 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_lun_0); 2938 } 2939 static ssize_t sdebug_no_lun_0_store(struct device_driver * ddp, 2940 const char * buf, size_t count) 2941 { 2942 int n; 2943 2944 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) { 2945 scsi_debug_no_lun_0 = n; 2946 return count; 2947 } 2948 return -EINVAL; 2949 } 2950 DRIVER_ATTR(no_lun_0, S_IRUGO | S_IWUSR, sdebug_no_lun_0_show, 2951 sdebug_no_lun_0_store); 2952 2953 static ssize_t sdebug_num_tgts_show(struct device_driver * ddp, char * buf) 2954 { 2955 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_tgts); 2956 } 2957 static ssize_t sdebug_num_tgts_store(struct device_driver * ddp, 2958 const char * buf, size_t count) 2959 { 2960 int n; 2961 2962 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) { 2963 scsi_debug_num_tgts = n; 2964 sdebug_max_tgts_luns(); 2965 return count; 2966 } 2967 return -EINVAL; 2968 } 2969 DRIVER_ATTR(num_tgts, S_IRUGO | S_IWUSR, sdebug_num_tgts_show, 2970 sdebug_num_tgts_store); 2971 2972 static ssize_t sdebug_dev_size_mb_show(struct device_driver * ddp, char * buf) 2973 { 2974 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dev_size_mb); 2975 } 2976 DRIVER_ATTR(dev_size_mb, S_IRUGO, sdebug_dev_size_mb_show, NULL); 2977 2978 static ssize_t sdebug_num_parts_show(struct device_driver * ddp, char * buf) 2979 { 2980 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_num_parts); 2981 } 2982 DRIVER_ATTR(num_parts, S_IRUGO, sdebug_num_parts_show, NULL); 2983 2984 static ssize_t sdebug_every_nth_show(struct device_driver * ddp, char * buf) 2985 { 2986 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_every_nth); 2987 } 2988 static ssize_t sdebug_every_nth_store(struct device_driver * ddp, 2989 const char * buf, size_t count) 2990 { 2991 int nth; 2992 2993 if ((count > 0) && (1 == sscanf(buf, "%d", &nth))) { 2994 scsi_debug_every_nth = nth; 2995 scsi_debug_cmnd_count = 0; 2996 return count; 2997 } 2998 return -EINVAL; 2999 } 3000 DRIVER_ATTR(every_nth, S_IRUGO | S_IWUSR, sdebug_every_nth_show, 3001 sdebug_every_nth_store); 3002 3003 static ssize_t sdebug_max_luns_show(struct device_driver * ddp, char * buf) 3004 { 3005 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_luns); 3006 } 3007 static ssize_t sdebug_max_luns_store(struct device_driver * ddp, 3008 const char * buf, size_t count) 3009 { 3010 int n; 3011 3012 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) { 3013 scsi_debug_max_luns = n; 3014 sdebug_max_tgts_luns(); 3015 return count; 3016 } 3017 return -EINVAL; 3018 } 3019 DRIVER_ATTR(max_luns, S_IRUGO | S_IWUSR, sdebug_max_luns_show, 3020 sdebug_max_luns_store); 3021 3022 static ssize_t sdebug_max_queue_show(struct device_driver * ddp, char * buf) 3023 { 3024 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_max_queue); 3025 } 3026 static ssize_t sdebug_max_queue_store(struct device_driver * ddp, 3027 const char * buf, size_t count) 3028 { 3029 int n; 3030 3031 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n > 0) && 3032 (n <= SCSI_DEBUG_CANQUEUE)) { 3033 scsi_debug_max_queue = n; 3034 return count; 3035 } 3036 return -EINVAL; 3037 } 3038 DRIVER_ATTR(max_queue, S_IRUGO | S_IWUSR, sdebug_max_queue_show, 3039 sdebug_max_queue_store); 3040 3041 static ssize_t sdebug_no_uld_show(struct device_driver * ddp, char * buf) 3042 { 3043 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_no_uld); 3044 } 3045 DRIVER_ATTR(no_uld, S_IRUGO, sdebug_no_uld_show, NULL); 3046 3047 static ssize_t sdebug_scsi_level_show(struct device_driver * ddp, char * buf) 3048 { 3049 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_scsi_level); 3050 } 3051 DRIVER_ATTR(scsi_level, S_IRUGO, sdebug_scsi_level_show, NULL); 3052 3053 static ssize_t sdebug_virtual_gb_show(struct device_driver * ddp, char * buf) 3054 { 3055 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_virtual_gb); 3056 } 3057 static ssize_t sdebug_virtual_gb_store(struct device_driver * ddp, 3058 const char * buf, size_t count) 3059 { 3060 int n; 3061 3062 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) { 3063 scsi_debug_virtual_gb = n; 3064 3065 sdebug_capacity = get_sdebug_capacity(); 3066 3067 return count; 3068 } 3069 return -EINVAL; 3070 } 3071 DRIVER_ATTR(virtual_gb, S_IRUGO | S_IWUSR, sdebug_virtual_gb_show, 3072 sdebug_virtual_gb_store); 3073 3074 static ssize_t sdebug_add_host_show(struct device_driver * ddp, char * buf) 3075 { 3076 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_add_host); 3077 } 3078 3079 static ssize_t sdebug_add_host_store(struct device_driver * ddp, 3080 const char * buf, size_t count) 3081 { 3082 int delta_hosts; 3083 3084 if (sscanf(buf, "%d", &delta_hosts) != 1) 3085 return -EINVAL; 3086 if (delta_hosts > 0) { 3087 do { 3088 sdebug_add_adapter(); 3089 } while (--delta_hosts); 3090 } else if (delta_hosts < 0) { 3091 do { 3092 sdebug_remove_adapter(); 3093 } while (++delta_hosts); 3094 } 3095 return count; 3096 } 3097 DRIVER_ATTR(add_host, S_IRUGO | S_IWUSR, sdebug_add_host_show, 3098 sdebug_add_host_store); 3099 3100 static ssize_t sdebug_vpd_use_hostno_show(struct device_driver * ddp, 3101 char * buf) 3102 { 3103 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_vpd_use_hostno); 3104 } 3105 static ssize_t sdebug_vpd_use_hostno_store(struct device_driver * ddp, 3106 const char * buf, size_t count) 3107 { 3108 int n; 3109 3110 if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) { 3111 scsi_debug_vpd_use_hostno = n; 3112 return count; 3113 } 3114 return -EINVAL; 3115 } 3116 DRIVER_ATTR(vpd_use_hostno, S_IRUGO | S_IWUSR, sdebug_vpd_use_hostno_show, 3117 sdebug_vpd_use_hostno_store); 3118 3119 static ssize_t sdebug_sector_size_show(struct device_driver * ddp, char * buf) 3120 { 3121 return scnprintf(buf, PAGE_SIZE, "%u\n", scsi_debug_sector_size); 3122 } 3123 DRIVER_ATTR(sector_size, S_IRUGO, sdebug_sector_size_show, NULL); 3124 3125 static ssize_t sdebug_dix_show(struct device_driver *ddp, char *buf) 3126 { 3127 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dix); 3128 } 3129 DRIVER_ATTR(dix, S_IRUGO, sdebug_dix_show, NULL); 3130 3131 static ssize_t sdebug_dif_show(struct device_driver *ddp, char *buf) 3132 { 3133 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_dif); 3134 } 3135 DRIVER_ATTR(dif, S_IRUGO, sdebug_dif_show, NULL); 3136 3137 static ssize_t sdebug_guard_show(struct device_driver *ddp, char *buf) 3138 { 3139 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_guard); 3140 } 3141 DRIVER_ATTR(guard, S_IRUGO, sdebug_guard_show, NULL); 3142 3143 static ssize_t sdebug_ato_show(struct device_driver *ddp, char *buf) 3144 { 3145 return scnprintf(buf, PAGE_SIZE, "%d\n", scsi_debug_ato); 3146 } 3147 DRIVER_ATTR(ato, S_IRUGO, sdebug_ato_show, NULL); 3148 3149 static ssize_t sdebug_map_show(struct device_driver *ddp, char *buf) 3150 { 3151 ssize_t count; 3152 3153 if (scsi_debug_tpu == 0 && scsi_debug_tpws == 0) 3154 return scnprintf(buf, PAGE_SIZE, "0-%u\n", 3155 sdebug_store_sectors); 3156 3157 count = bitmap_scnlistprintf(buf, PAGE_SIZE, map_storep, map_size); 3158 3159 buf[count++] = '\n'; 3160 buf[count++] = 0; 3161 3162 return count; 3163 } 3164 DRIVER_ATTR(map, S_IRUGO, sdebug_map_show, NULL); 3165 3166 3167 /* Note: The following function creates attribute files in the 3168 /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these 3169 files (over those found in the /sys/module/scsi_debug/parameters 3170 directory) is that auxiliary actions can be triggered when an attribute 3171 is changed. For example see: sdebug_add_host_store() above. 3172 */ 3173 static int do_create_driverfs_files(void) 3174 { 3175 int ret; 3176 3177 ret = driver_create_file(&sdebug_driverfs_driver, &driver_attr_add_host); 3178 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_delay); 3179 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb); 3180 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dsense); 3181 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_every_nth); 3182 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_fake_rw); 3183 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_luns); 3184 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_max_queue); 3185 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0); 3186 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_no_uld); 3187 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_parts); 3188 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_num_tgts); 3189 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ptype); 3190 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_opts); 3191 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_scsi_level); 3192 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb); 3193 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno); 3194 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_sector_size); 3195 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dix); 3196 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dif); 3197 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_guard); 3198 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ato); 3199 ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_map); 3200 return ret; 3201 } 3202 3203 static void do_remove_driverfs_files(void) 3204 { 3205 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_map); 3206 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ato); 3207 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_guard); 3208 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dif); 3209 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dix); 3210 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_sector_size); 3211 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_vpd_use_hostno); 3212 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_virtual_gb); 3213 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_scsi_level); 3214 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_opts); 3215 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ptype); 3216 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_tgts); 3217 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_num_parts); 3218 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_uld); 3219 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_no_lun_0); 3220 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_queue); 3221 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_max_luns); 3222 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_fake_rw); 3223 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_every_nth); 3224 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dsense); 3225 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dev_size_mb); 3226 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_delay); 3227 driver_remove_file(&sdebug_driverfs_driver, &driver_attr_add_host); 3228 } 3229 3230 struct device *pseudo_primary; 3231 3232 static int __init scsi_debug_init(void) 3233 { 3234 unsigned long sz; 3235 int host_to_add; 3236 int k; 3237 int ret; 3238 3239 switch (scsi_debug_sector_size) { 3240 case 512: 3241 case 1024: 3242 case 2048: 3243 case 4096: 3244 break; 3245 default: 3246 printk(KERN_ERR "scsi_debug_init: invalid sector_size %d\n", 3247 scsi_debug_sector_size); 3248 return -EINVAL; 3249 } 3250 3251 switch (scsi_debug_dif) { 3252 3253 case SD_DIF_TYPE0_PROTECTION: 3254 case SD_DIF_TYPE1_PROTECTION: 3255 case SD_DIF_TYPE2_PROTECTION: 3256 case SD_DIF_TYPE3_PROTECTION: 3257 break; 3258 3259 default: 3260 printk(KERN_ERR "scsi_debug_init: dif must be 0, 1, 2 or 3\n"); 3261 return -EINVAL; 3262 } 3263 3264 if (scsi_debug_guard > 1) { 3265 printk(KERN_ERR "scsi_debug_init: guard must be 0 or 1\n"); 3266 return -EINVAL; 3267 } 3268 3269 if (scsi_debug_ato > 1) { 3270 printk(KERN_ERR "scsi_debug_init: ato must be 0 or 1\n"); 3271 return -EINVAL; 3272 } 3273 3274 if (scsi_debug_physblk_exp > 15) { 3275 printk(KERN_ERR "scsi_debug_init: invalid physblk_exp %u\n", 3276 scsi_debug_physblk_exp); 3277 return -EINVAL; 3278 } 3279 3280 if (scsi_debug_lowest_aligned > 0x3fff) { 3281 printk(KERN_ERR "scsi_debug_init: lowest_aligned too big: %u\n", 3282 scsi_debug_lowest_aligned); 3283 return -EINVAL; 3284 } 3285 3286 if (scsi_debug_dev_size_mb < 1) 3287 scsi_debug_dev_size_mb = 1; /* force minimum 1 MB ramdisk */ 3288 sz = (unsigned long)scsi_debug_dev_size_mb * 1048576; 3289 sdebug_store_sectors = sz / scsi_debug_sector_size; 3290 sdebug_capacity = get_sdebug_capacity(); 3291 3292 /* play around with geometry, don't waste too much on track 0 */ 3293 sdebug_heads = 8; 3294 sdebug_sectors_per = 32; 3295 if (scsi_debug_dev_size_mb >= 16) 3296 sdebug_heads = 32; 3297 else if (scsi_debug_dev_size_mb >= 256) 3298 sdebug_heads = 64; 3299 sdebug_cylinders_per = (unsigned long)sdebug_capacity / 3300 (sdebug_sectors_per * sdebug_heads); 3301 if (sdebug_cylinders_per >= 1024) { 3302 /* other LLDs do this; implies >= 1GB ram disk ... */ 3303 sdebug_heads = 255; 3304 sdebug_sectors_per = 63; 3305 sdebug_cylinders_per = (unsigned long)sdebug_capacity / 3306 (sdebug_sectors_per * sdebug_heads); 3307 } 3308 3309 fake_storep = vmalloc(sz); 3310 if (NULL == fake_storep) { 3311 printk(KERN_ERR "scsi_debug_init: out of memory, 1\n"); 3312 return -ENOMEM; 3313 } 3314 memset(fake_storep, 0, sz); 3315 if (scsi_debug_num_parts > 0) 3316 sdebug_build_parts(fake_storep, sz); 3317 3318 if (scsi_debug_dif) { 3319 int dif_size; 3320 3321 dif_size = sdebug_store_sectors * sizeof(struct sd_dif_tuple); 3322 dif_storep = vmalloc(dif_size); 3323 3324 printk(KERN_ERR "scsi_debug_init: dif_storep %u bytes @ %p\n", 3325 dif_size, dif_storep); 3326 3327 if (dif_storep == NULL) { 3328 printk(KERN_ERR "scsi_debug_init: out of mem. (DIX)\n"); 3329 ret = -ENOMEM; 3330 goto free_vm; 3331 } 3332 3333 memset(dif_storep, 0xff, dif_size); 3334 } 3335 3336 /* Thin Provisioning */ 3337 if (scsi_debug_tpu || scsi_debug_tpws) { 3338 unsigned int map_bytes; 3339 3340 scsi_debug_unmap_max_blocks = 3341 clamp(scsi_debug_unmap_max_blocks, 0U, 0xffffffffU); 3342 3343 scsi_debug_unmap_max_desc = 3344 clamp(scsi_debug_unmap_max_desc, 0U, 256U); 3345 3346 scsi_debug_unmap_granularity = 3347 clamp(scsi_debug_unmap_granularity, 1U, 0xffffffffU); 3348 3349 if (scsi_debug_unmap_alignment && 3350 scsi_debug_unmap_granularity < scsi_debug_unmap_alignment) { 3351 printk(KERN_ERR 3352 "%s: ERR: unmap_granularity < unmap_alignment\n", 3353 __func__); 3354 return -EINVAL; 3355 } 3356 3357 map_size = (sdebug_store_sectors / scsi_debug_unmap_granularity); 3358 map_bytes = map_size >> 3; 3359 map_storep = vmalloc(map_bytes); 3360 3361 printk(KERN_INFO "scsi_debug_init: %lu provisioning blocks\n", 3362 map_size); 3363 3364 if (map_storep == NULL) { 3365 printk(KERN_ERR "scsi_debug_init: out of mem. (MAP)\n"); 3366 ret = -ENOMEM; 3367 goto free_vm; 3368 } 3369 3370 memset(map_storep, 0x0, map_bytes); 3371 3372 /* Map first 1KB for partition table */ 3373 if (scsi_debug_num_parts) 3374 map_region(0, 2); 3375 } 3376 3377 pseudo_primary = root_device_register("pseudo_0"); 3378 if (IS_ERR(pseudo_primary)) { 3379 printk(KERN_WARNING "scsi_debug: root_device_register() error\n"); 3380 ret = PTR_ERR(pseudo_primary); 3381 goto free_vm; 3382 } 3383 ret = bus_register(&pseudo_lld_bus); 3384 if (ret < 0) { 3385 printk(KERN_WARNING "scsi_debug: bus_register error: %d\n", 3386 ret); 3387 goto dev_unreg; 3388 } 3389 ret = driver_register(&sdebug_driverfs_driver); 3390 if (ret < 0) { 3391 printk(KERN_WARNING "scsi_debug: driver_register error: %d\n", 3392 ret); 3393 goto bus_unreg; 3394 } 3395 ret = do_create_driverfs_files(); 3396 if (ret < 0) { 3397 printk(KERN_WARNING "scsi_debug: driver_create_file error: %d\n", 3398 ret); 3399 goto del_files; 3400 } 3401 3402 init_all_queued(); 3403 3404 host_to_add = scsi_debug_add_host; 3405 scsi_debug_add_host = 0; 3406 3407 for (k = 0; k < host_to_add; k++) { 3408 if (sdebug_add_adapter()) { 3409 printk(KERN_ERR "scsi_debug_init: " 3410 "sdebug_add_adapter failed k=%d\n", k); 3411 break; 3412 } 3413 } 3414 3415 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) { 3416 printk(KERN_INFO "scsi_debug_init: built %d host(s)\n", 3417 scsi_debug_add_host); 3418 } 3419 return 0; 3420 3421 del_files: 3422 do_remove_driverfs_files(); 3423 driver_unregister(&sdebug_driverfs_driver); 3424 bus_unreg: 3425 bus_unregister(&pseudo_lld_bus); 3426 dev_unreg: 3427 root_device_unregister(pseudo_primary); 3428 free_vm: 3429 if (map_storep) 3430 vfree(map_storep); 3431 if (dif_storep) 3432 vfree(dif_storep); 3433 vfree(fake_storep); 3434 3435 return ret; 3436 } 3437 3438 static void __exit scsi_debug_exit(void) 3439 { 3440 int k = scsi_debug_add_host; 3441 3442 stop_all_queued(); 3443 for (; k; k--) 3444 sdebug_remove_adapter(); 3445 do_remove_driverfs_files(); 3446 driver_unregister(&sdebug_driverfs_driver); 3447 bus_unregister(&pseudo_lld_bus); 3448 root_device_unregister(pseudo_primary); 3449 3450 if (dif_storep) 3451 vfree(dif_storep); 3452 3453 vfree(fake_storep); 3454 } 3455 3456 device_initcall(scsi_debug_init); 3457 module_exit(scsi_debug_exit); 3458 3459 static void sdebug_release_adapter(struct device * dev) 3460 { 3461 struct sdebug_host_info *sdbg_host; 3462 3463 sdbg_host = to_sdebug_host(dev); 3464 kfree(sdbg_host); 3465 } 3466 3467 static int sdebug_add_adapter(void) 3468 { 3469 int k, devs_per_host; 3470 int error = 0; 3471 struct sdebug_host_info *sdbg_host; 3472 struct sdebug_dev_info *sdbg_devinfo, *tmp; 3473 3474 sdbg_host = kzalloc(sizeof(*sdbg_host),GFP_KERNEL); 3475 if (NULL == sdbg_host) { 3476 printk(KERN_ERR "%s: out of memory at line %d\n", 3477 __func__, __LINE__); 3478 return -ENOMEM; 3479 } 3480 3481 INIT_LIST_HEAD(&sdbg_host->dev_info_list); 3482 3483 devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns; 3484 for (k = 0; k < devs_per_host; k++) { 3485 sdbg_devinfo = sdebug_device_create(sdbg_host, GFP_KERNEL); 3486 if (!sdbg_devinfo) { 3487 printk(KERN_ERR "%s: out of memory at line %d\n", 3488 __func__, __LINE__); 3489 error = -ENOMEM; 3490 goto clean; 3491 } 3492 } 3493 3494 spin_lock(&sdebug_host_list_lock); 3495 list_add_tail(&sdbg_host->host_list, &sdebug_host_list); 3496 spin_unlock(&sdebug_host_list_lock); 3497 3498 sdbg_host->dev.bus = &pseudo_lld_bus; 3499 sdbg_host->dev.parent = pseudo_primary; 3500 sdbg_host->dev.release = &sdebug_release_adapter; 3501 dev_set_name(&sdbg_host->dev, "adapter%d", scsi_debug_add_host); 3502 3503 error = device_register(&sdbg_host->dev); 3504 3505 if (error) 3506 goto clean; 3507 3508 ++scsi_debug_add_host; 3509 return error; 3510 3511 clean: 3512 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list, 3513 dev_list) { 3514 list_del(&sdbg_devinfo->dev_list); 3515 kfree(sdbg_devinfo); 3516 } 3517 3518 kfree(sdbg_host); 3519 return error; 3520 } 3521 3522 static void sdebug_remove_adapter(void) 3523 { 3524 struct sdebug_host_info * sdbg_host = NULL; 3525 3526 spin_lock(&sdebug_host_list_lock); 3527 if (!list_empty(&sdebug_host_list)) { 3528 sdbg_host = list_entry(sdebug_host_list.prev, 3529 struct sdebug_host_info, host_list); 3530 list_del(&sdbg_host->host_list); 3531 } 3532 spin_unlock(&sdebug_host_list_lock); 3533 3534 if (!sdbg_host) 3535 return; 3536 3537 device_unregister(&sdbg_host->dev); 3538 --scsi_debug_add_host; 3539 } 3540 3541 static 3542 int scsi_debug_queuecommand_lck(struct scsi_cmnd *SCpnt, done_funct_t done) 3543 { 3544 unsigned char *cmd = (unsigned char *) SCpnt->cmnd; 3545 int len, k; 3546 unsigned int num; 3547 unsigned long long lba; 3548 u32 ei_lba; 3549 int errsts = 0; 3550 int target = SCpnt->device->id; 3551 struct sdebug_dev_info *devip = NULL; 3552 int inj_recovered = 0; 3553 int inj_transport = 0; 3554 int inj_dif = 0; 3555 int inj_dix = 0; 3556 int delay_override = 0; 3557 int unmap = 0; 3558 3559 scsi_set_resid(SCpnt, 0); 3560 if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) { 3561 printk(KERN_INFO "scsi_debug: cmd "); 3562 for (k = 0, len = SCpnt->cmd_len; k < len; ++k) 3563 printk("%02x ", (int)cmd[k]); 3564 printk("\n"); 3565 } 3566 3567 if (target == SCpnt->device->host->hostt->this_id) { 3568 printk(KERN_INFO "scsi_debug: initiator's id used as " 3569 "target!\n"); 3570 return schedule_resp(SCpnt, NULL, done, 3571 DID_NO_CONNECT << 16, 0); 3572 } 3573 3574 if ((SCpnt->device->lun >= scsi_debug_max_luns) && 3575 (SCpnt->device->lun != SAM2_WLUN_REPORT_LUNS)) 3576 return schedule_resp(SCpnt, NULL, done, 3577 DID_NO_CONNECT << 16, 0); 3578 devip = devInfoReg(SCpnt->device); 3579 if (NULL == devip) 3580 return schedule_resp(SCpnt, NULL, done, 3581 DID_NO_CONNECT << 16, 0); 3582 3583 if ((scsi_debug_every_nth != 0) && 3584 (++scsi_debug_cmnd_count >= abs(scsi_debug_every_nth))) { 3585 scsi_debug_cmnd_count = 0; 3586 if (scsi_debug_every_nth < -1) 3587 scsi_debug_every_nth = -1; 3588 if (SCSI_DEBUG_OPT_TIMEOUT & scsi_debug_opts) 3589 return 0; /* ignore command causing timeout */ 3590 else if (SCSI_DEBUG_OPT_RECOVERED_ERR & scsi_debug_opts) 3591 inj_recovered = 1; /* to reads and writes below */ 3592 else if (SCSI_DEBUG_OPT_TRANSPORT_ERR & scsi_debug_opts) 3593 inj_transport = 1; /* to reads and writes below */ 3594 else if (SCSI_DEBUG_OPT_DIF_ERR & scsi_debug_opts) 3595 inj_dif = 1; /* to reads and writes below */ 3596 else if (SCSI_DEBUG_OPT_DIX_ERR & scsi_debug_opts) 3597 inj_dix = 1; /* to reads and writes below */ 3598 } 3599 3600 if (devip->wlun) { 3601 switch (*cmd) { 3602 case INQUIRY: 3603 case REQUEST_SENSE: 3604 case TEST_UNIT_READY: 3605 case REPORT_LUNS: 3606 break; /* only allowable wlun commands */ 3607 default: 3608 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 3609 printk(KERN_INFO "scsi_debug: Opcode: 0x%x " 3610 "not supported for wlun\n", *cmd); 3611 mk_sense_buffer(devip, ILLEGAL_REQUEST, 3612 INVALID_OPCODE, 0); 3613 errsts = check_condition_result; 3614 return schedule_resp(SCpnt, devip, done, errsts, 3615 0); 3616 } 3617 } 3618 3619 switch (*cmd) { 3620 case INQUIRY: /* mandatory, ignore unit attention */ 3621 delay_override = 1; 3622 errsts = resp_inquiry(SCpnt, target, devip); 3623 break; 3624 case REQUEST_SENSE: /* mandatory, ignore unit attention */ 3625 delay_override = 1; 3626 errsts = resp_requests(SCpnt, devip); 3627 break; 3628 case REZERO_UNIT: /* actually this is REWIND for SSC */ 3629 case START_STOP: 3630 errsts = resp_start_stop(SCpnt, devip); 3631 break; 3632 case ALLOW_MEDIUM_REMOVAL: 3633 errsts = check_readiness(SCpnt, 1, devip); 3634 if (errsts) 3635 break; 3636 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 3637 printk(KERN_INFO "scsi_debug: Medium removal %s\n", 3638 cmd[4] ? "inhibited" : "enabled"); 3639 break; 3640 case SEND_DIAGNOSTIC: /* mandatory */ 3641 errsts = check_readiness(SCpnt, 1, devip); 3642 break; 3643 case TEST_UNIT_READY: /* mandatory */ 3644 delay_override = 1; 3645 errsts = check_readiness(SCpnt, 0, devip); 3646 break; 3647 case RESERVE: 3648 errsts = check_readiness(SCpnt, 1, devip); 3649 break; 3650 case RESERVE_10: 3651 errsts = check_readiness(SCpnt, 1, devip); 3652 break; 3653 case RELEASE: 3654 errsts = check_readiness(SCpnt, 1, devip); 3655 break; 3656 case RELEASE_10: 3657 errsts = check_readiness(SCpnt, 1, devip); 3658 break; 3659 case READ_CAPACITY: 3660 errsts = resp_readcap(SCpnt, devip); 3661 break; 3662 case SERVICE_ACTION_IN: 3663 if (cmd[1] == SAI_READ_CAPACITY_16) 3664 errsts = resp_readcap16(SCpnt, devip); 3665 else if (cmd[1] == SAI_GET_LBA_STATUS) { 3666 3667 if (scsi_debug_tpu == 0 && scsi_debug_tpws == 0) { 3668 mk_sense_buffer(devip, ILLEGAL_REQUEST, 3669 INVALID_COMMAND_OPCODE, 0); 3670 errsts = check_condition_result; 3671 } else 3672 errsts = resp_get_lba_status(SCpnt, devip); 3673 } else { 3674 mk_sense_buffer(devip, ILLEGAL_REQUEST, 3675 INVALID_OPCODE, 0); 3676 errsts = check_condition_result; 3677 } 3678 break; 3679 case MAINTENANCE_IN: 3680 if (MI_REPORT_TARGET_PGS != cmd[1]) { 3681 mk_sense_buffer(devip, ILLEGAL_REQUEST, 3682 INVALID_OPCODE, 0); 3683 errsts = check_condition_result; 3684 break; 3685 } 3686 errsts = resp_report_tgtpgs(SCpnt, devip); 3687 break; 3688 case READ_16: 3689 case READ_12: 3690 case READ_10: 3691 /* READ{10,12,16} and DIF Type 2 are natural enemies */ 3692 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION && 3693 cmd[1] & 0xe0) { 3694 mk_sense_buffer(devip, ILLEGAL_REQUEST, 3695 INVALID_COMMAND_OPCODE, 0); 3696 errsts = check_condition_result; 3697 break; 3698 } 3699 3700 if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION || 3701 scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) && 3702 (cmd[1] & 0xe0) == 0) 3703 printk(KERN_ERR "Unprotected RD/WR to DIF device\n"); 3704 3705 /* fall through */ 3706 case READ_6: 3707 read: 3708 errsts = check_readiness(SCpnt, 0, devip); 3709 if (errsts) 3710 break; 3711 if (scsi_debug_fake_rw) 3712 break; 3713 get_data_transfer_info(cmd, &lba, &num, &ei_lba); 3714 errsts = resp_read(SCpnt, lba, num, devip, ei_lba); 3715 if (inj_recovered && (0 == errsts)) { 3716 mk_sense_buffer(devip, RECOVERED_ERROR, 3717 THRESHOLD_EXCEEDED, 0); 3718 errsts = check_condition_result; 3719 } else if (inj_transport && (0 == errsts)) { 3720 mk_sense_buffer(devip, ABORTED_COMMAND, 3721 TRANSPORT_PROBLEM, ACK_NAK_TO); 3722 errsts = check_condition_result; 3723 } else if (inj_dif && (0 == errsts)) { 3724 mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, 1); 3725 errsts = illegal_condition_result; 3726 } else if (inj_dix && (0 == errsts)) { 3727 mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, 1); 3728 errsts = illegal_condition_result; 3729 } 3730 break; 3731 case REPORT_LUNS: /* mandatory, ignore unit attention */ 3732 delay_override = 1; 3733 errsts = resp_report_luns(SCpnt, devip); 3734 break; 3735 case VERIFY: /* 10 byte SBC-2 command */ 3736 errsts = check_readiness(SCpnt, 0, devip); 3737 break; 3738 case WRITE_16: 3739 case WRITE_12: 3740 case WRITE_10: 3741 /* WRITE{10,12,16} and DIF Type 2 are natural enemies */ 3742 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION && 3743 cmd[1] & 0xe0) { 3744 mk_sense_buffer(devip, ILLEGAL_REQUEST, 3745 INVALID_COMMAND_OPCODE, 0); 3746 errsts = check_condition_result; 3747 break; 3748 } 3749 3750 if ((scsi_debug_dif == SD_DIF_TYPE1_PROTECTION || 3751 scsi_debug_dif == SD_DIF_TYPE3_PROTECTION) && 3752 (cmd[1] & 0xe0) == 0) 3753 printk(KERN_ERR "Unprotected RD/WR to DIF device\n"); 3754 3755 /* fall through */ 3756 case WRITE_6: 3757 write: 3758 errsts = check_readiness(SCpnt, 0, devip); 3759 if (errsts) 3760 break; 3761 if (scsi_debug_fake_rw) 3762 break; 3763 get_data_transfer_info(cmd, &lba, &num, &ei_lba); 3764 errsts = resp_write(SCpnt, lba, num, devip, ei_lba); 3765 if (inj_recovered && (0 == errsts)) { 3766 mk_sense_buffer(devip, RECOVERED_ERROR, 3767 THRESHOLD_EXCEEDED, 0); 3768 errsts = check_condition_result; 3769 } else if (inj_dif && (0 == errsts)) { 3770 mk_sense_buffer(devip, ABORTED_COMMAND, 0x10, 1); 3771 errsts = illegal_condition_result; 3772 } else if (inj_dix && (0 == errsts)) { 3773 mk_sense_buffer(devip, ILLEGAL_REQUEST, 0x10, 1); 3774 errsts = illegal_condition_result; 3775 } 3776 break; 3777 case WRITE_SAME_16: 3778 if (cmd[1] & 0x8) { 3779 if (scsi_debug_tpws == 0) { 3780 mk_sense_buffer(devip, ILLEGAL_REQUEST, 3781 INVALID_FIELD_IN_CDB, 0); 3782 errsts = check_condition_result; 3783 } else 3784 unmap = 1; 3785 } 3786 if (errsts) 3787 break; 3788 /* fall through */ 3789 case WRITE_SAME: 3790 errsts = check_readiness(SCpnt, 0, devip); 3791 if (errsts) 3792 break; 3793 get_data_transfer_info(cmd, &lba, &num, &ei_lba); 3794 errsts = resp_write_same(SCpnt, lba, num, devip, ei_lba, unmap); 3795 break; 3796 case UNMAP: 3797 errsts = check_readiness(SCpnt, 0, devip); 3798 if (errsts) 3799 break; 3800 3801 if (scsi_debug_unmap_max_desc == 0 || scsi_debug_tpu == 0) { 3802 mk_sense_buffer(devip, ILLEGAL_REQUEST, 3803 INVALID_COMMAND_OPCODE, 0); 3804 errsts = check_condition_result; 3805 } else 3806 errsts = resp_unmap(SCpnt, devip); 3807 break; 3808 case MODE_SENSE: 3809 case MODE_SENSE_10: 3810 errsts = resp_mode_sense(SCpnt, target, devip); 3811 break; 3812 case MODE_SELECT: 3813 errsts = resp_mode_select(SCpnt, 1, devip); 3814 break; 3815 case MODE_SELECT_10: 3816 errsts = resp_mode_select(SCpnt, 0, devip); 3817 break; 3818 case LOG_SENSE: 3819 errsts = resp_log_sense(SCpnt, devip); 3820 break; 3821 case SYNCHRONIZE_CACHE: 3822 delay_override = 1; 3823 errsts = check_readiness(SCpnt, 0, devip); 3824 break; 3825 case WRITE_BUFFER: 3826 errsts = check_readiness(SCpnt, 1, devip); 3827 break; 3828 case XDWRITEREAD_10: 3829 if (!scsi_bidi_cmnd(SCpnt)) { 3830 mk_sense_buffer(devip, ILLEGAL_REQUEST, 3831 INVALID_FIELD_IN_CDB, 0); 3832 errsts = check_condition_result; 3833 break; 3834 } 3835 3836 errsts = check_readiness(SCpnt, 0, devip); 3837 if (errsts) 3838 break; 3839 if (scsi_debug_fake_rw) 3840 break; 3841 get_data_transfer_info(cmd, &lba, &num, &ei_lba); 3842 errsts = resp_read(SCpnt, lba, num, devip, ei_lba); 3843 if (errsts) 3844 break; 3845 errsts = resp_write(SCpnt, lba, num, devip, ei_lba); 3846 if (errsts) 3847 break; 3848 errsts = resp_xdwriteread(SCpnt, lba, num, devip); 3849 break; 3850 case VARIABLE_LENGTH_CMD: 3851 if (scsi_debug_dif == SD_DIF_TYPE2_PROTECTION) { 3852 3853 if ((cmd[10] & 0xe0) == 0) 3854 printk(KERN_ERR 3855 "Unprotected RD/WR to DIF device\n"); 3856 3857 if (cmd[9] == READ_32) { 3858 BUG_ON(SCpnt->cmd_len < 32); 3859 goto read; 3860 } 3861 3862 if (cmd[9] == WRITE_32) { 3863 BUG_ON(SCpnt->cmd_len < 32); 3864 goto write; 3865 } 3866 } 3867 3868 mk_sense_buffer(devip, ILLEGAL_REQUEST, 3869 INVALID_FIELD_IN_CDB, 0); 3870 errsts = check_condition_result; 3871 break; 3872 3873 default: 3874 if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) 3875 printk(KERN_INFO "scsi_debug: Opcode: 0x%x not " 3876 "supported\n", *cmd); 3877 errsts = check_readiness(SCpnt, 1, devip); 3878 if (errsts) 3879 break; /* Unit attention takes precedence */ 3880 mk_sense_buffer(devip, ILLEGAL_REQUEST, INVALID_OPCODE, 0); 3881 errsts = check_condition_result; 3882 break; 3883 } 3884 return schedule_resp(SCpnt, devip, done, errsts, 3885 (delay_override ? 0 : scsi_debug_delay)); 3886 } 3887 3888 static DEF_SCSI_QCMD(scsi_debug_queuecommand) 3889 3890 static struct scsi_host_template sdebug_driver_template = { 3891 .proc_info = scsi_debug_proc_info, 3892 .proc_name = sdebug_proc_name, 3893 .name = "SCSI DEBUG", 3894 .info = scsi_debug_info, 3895 .slave_alloc = scsi_debug_slave_alloc, 3896 .slave_configure = scsi_debug_slave_configure, 3897 .slave_destroy = scsi_debug_slave_destroy, 3898 .ioctl = scsi_debug_ioctl, 3899 .queuecommand = scsi_debug_queuecommand, 3900 .eh_abort_handler = scsi_debug_abort, 3901 .eh_bus_reset_handler = scsi_debug_bus_reset, 3902 .eh_device_reset_handler = scsi_debug_device_reset, 3903 .eh_host_reset_handler = scsi_debug_host_reset, 3904 .bios_param = scsi_debug_biosparam, 3905 .can_queue = SCSI_DEBUG_CANQUEUE, 3906 .this_id = 7, 3907 .sg_tablesize = 256, 3908 .cmd_per_lun = 16, 3909 .max_sectors = 0xffff, 3910 .use_clustering = DISABLE_CLUSTERING, 3911 .module = THIS_MODULE, 3912 }; 3913 3914 static int sdebug_driver_probe(struct device * dev) 3915 { 3916 int error = 0; 3917 struct sdebug_host_info *sdbg_host; 3918 struct Scsi_Host *hpnt; 3919 int host_prot; 3920 3921 sdbg_host = to_sdebug_host(dev); 3922 3923 sdebug_driver_template.can_queue = scsi_debug_max_queue; 3924 hpnt = scsi_host_alloc(&sdebug_driver_template, sizeof(sdbg_host)); 3925 if (NULL == hpnt) { 3926 printk(KERN_ERR "%s: scsi_register failed\n", __func__); 3927 error = -ENODEV; 3928 return error; 3929 } 3930 3931 sdbg_host->shost = hpnt; 3932 *((struct sdebug_host_info **)hpnt->hostdata) = sdbg_host; 3933 if ((hpnt->this_id >= 0) && (scsi_debug_num_tgts > hpnt->this_id)) 3934 hpnt->max_id = scsi_debug_num_tgts + 1; 3935 else 3936 hpnt->max_id = scsi_debug_num_tgts; 3937 hpnt->max_lun = SAM2_WLUN_REPORT_LUNS; /* = scsi_debug_max_luns; */ 3938 3939 host_prot = 0; 3940 3941 switch (scsi_debug_dif) { 3942 3943 case SD_DIF_TYPE1_PROTECTION: 3944 host_prot = SHOST_DIF_TYPE1_PROTECTION; 3945 if (scsi_debug_dix) 3946 host_prot |= SHOST_DIX_TYPE1_PROTECTION; 3947 break; 3948 3949 case SD_DIF_TYPE2_PROTECTION: 3950 host_prot = SHOST_DIF_TYPE2_PROTECTION; 3951 if (scsi_debug_dix) 3952 host_prot |= SHOST_DIX_TYPE2_PROTECTION; 3953 break; 3954 3955 case SD_DIF_TYPE3_PROTECTION: 3956 host_prot = SHOST_DIF_TYPE3_PROTECTION; 3957 if (scsi_debug_dix) 3958 host_prot |= SHOST_DIX_TYPE3_PROTECTION; 3959 break; 3960 3961 default: 3962 if (scsi_debug_dix) 3963 host_prot |= SHOST_DIX_TYPE0_PROTECTION; 3964 break; 3965 } 3966 3967 scsi_host_set_prot(hpnt, host_prot); 3968 3969 printk(KERN_INFO "scsi_debug: host protection%s%s%s%s%s%s%s\n", 3970 (host_prot & SHOST_DIF_TYPE1_PROTECTION) ? " DIF1" : "", 3971 (host_prot & SHOST_DIF_TYPE2_PROTECTION) ? " DIF2" : "", 3972 (host_prot & SHOST_DIF_TYPE3_PROTECTION) ? " DIF3" : "", 3973 (host_prot & SHOST_DIX_TYPE0_PROTECTION) ? " DIX0" : "", 3974 (host_prot & SHOST_DIX_TYPE1_PROTECTION) ? " DIX1" : "", 3975 (host_prot & SHOST_DIX_TYPE2_PROTECTION) ? " DIX2" : "", 3976 (host_prot & SHOST_DIX_TYPE3_PROTECTION) ? " DIX3" : ""); 3977 3978 if (scsi_debug_guard == 1) 3979 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_IP); 3980 else 3981 scsi_host_set_guard(hpnt, SHOST_DIX_GUARD_CRC); 3982 3983 error = scsi_add_host(hpnt, &sdbg_host->dev); 3984 if (error) { 3985 printk(KERN_ERR "%s: scsi_add_host failed\n", __func__); 3986 error = -ENODEV; 3987 scsi_host_put(hpnt); 3988 } else 3989 scsi_scan_host(hpnt); 3990 3991 3992 return error; 3993 } 3994 3995 static int sdebug_driver_remove(struct device * dev) 3996 { 3997 struct sdebug_host_info *sdbg_host; 3998 struct sdebug_dev_info *sdbg_devinfo, *tmp; 3999 4000 sdbg_host = to_sdebug_host(dev); 4001 4002 if (!sdbg_host) { 4003 printk(KERN_ERR "%s: Unable to locate host info\n", 4004 __func__); 4005 return -ENODEV; 4006 } 4007 4008 scsi_remove_host(sdbg_host->shost); 4009 4010 list_for_each_entry_safe(sdbg_devinfo, tmp, &sdbg_host->dev_info_list, 4011 dev_list) { 4012 list_del(&sdbg_devinfo->dev_list); 4013 kfree(sdbg_devinfo); 4014 } 4015 4016 scsi_host_put(sdbg_host->shost); 4017 return 0; 4018 } 4019 4020 static int pseudo_lld_bus_match(struct device *dev, 4021 struct device_driver *dev_driver) 4022 { 4023 return 1; 4024 } 4025 4026 static struct bus_type pseudo_lld_bus = { 4027 .name = "pseudo", 4028 .match = pseudo_lld_bus_match, 4029 .probe = sdebug_driver_probe, 4030 .remove = sdebug_driver_remove, 4031 }; 4032