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