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