1 /* 2 * scsi.c Copyright (C) 1992 Drew Eckhardt 3 * Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale 4 * Copyright (C) 2002, 2003 Christoph Hellwig 5 * 6 * generic mid-level SCSI driver 7 * Initial versions: Drew Eckhardt 8 * Subsequent revisions: Eric Youngdale 9 * 10 * <drew@colorado.edu> 11 * 12 * Bug correction thanks go to : 13 * Rik Faith <faith@cs.unc.edu> 14 * Tommy Thorn <tthorn> 15 * Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de> 16 * 17 * Modified by Eric Youngdale eric@andante.org or ericy@gnu.ai.mit.edu to 18 * add scatter-gather, multiple outstanding request, and other 19 * enhancements. 20 * 21 * Native multichannel, wide scsi, /proc/scsi and hot plugging 22 * support added by Michael Neuffer <mike@i-connect.net> 23 * 24 * Added request_module("scsi_hostadapter") for kerneld: 25 * (Put an "alias scsi_hostadapter your_hostadapter" in /etc/modprobe.conf) 26 * Bjorn Ekwall <bj0rn@blox.se> 27 * (changed to kmod) 28 * 29 * Major improvements to the timeout, abort, and reset processing, 30 * as well as performance modifications for large queue depths by 31 * Leonard N. Zubkoff <lnz@dandelion.com> 32 * 33 * Converted cli() code to spinlocks, Ingo Molnar 34 * 35 * Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli 36 * 37 * out_of_space hacks, D. Gilbert (dpg) 990608 38 */ 39 40 #include <linux/module.h> 41 #include <linux/moduleparam.h> 42 #include <linux/kernel.h> 43 #include <linux/timer.h> 44 #include <linux/string.h> 45 #include <linux/slab.h> 46 #include <linux/blkdev.h> 47 #include <linux/delay.h> 48 #include <linux/init.h> 49 #include <linux/completion.h> 50 #include <linux/unistd.h> 51 #include <linux/spinlock.h> 52 #include <linux/kmod.h> 53 #include <linux/interrupt.h> 54 #include <linux/notifier.h> 55 #include <linux/cpu.h> 56 #include <linux/mutex.h> 57 #include <linux/async.h> 58 #include <asm/unaligned.h> 59 60 #include <scsi/scsi.h> 61 #include <scsi/scsi_cmnd.h> 62 #include <scsi/scsi_dbg.h> 63 #include <scsi/scsi_device.h> 64 #include <scsi/scsi_driver.h> 65 #include <scsi/scsi_eh.h> 66 #include <scsi/scsi_host.h> 67 #include <scsi/scsi_tcq.h> 68 69 #include "scsi_priv.h" 70 #include "scsi_logging.h" 71 72 #define CREATE_TRACE_POINTS 73 #include <trace/events/scsi.h> 74 75 /* 76 * Definitions and constants. 77 */ 78 79 /* 80 * Note - the initial logging level can be set here to log events at boot time. 81 * After the system is up, you may enable logging via the /proc interface. 82 */ 83 unsigned int scsi_logging_level; 84 #if defined(CONFIG_SCSI_LOGGING) 85 EXPORT_SYMBOL(scsi_logging_level); 86 #endif 87 88 /* sd, scsi core and power management need to coordinate flushing async actions */ 89 ASYNC_DOMAIN(scsi_sd_probe_domain); 90 EXPORT_SYMBOL(scsi_sd_probe_domain); 91 92 /* 93 * Separate domain (from scsi_sd_probe_domain) to maximize the benefit of 94 * asynchronous system resume operations. It is marked 'exclusive' to avoid 95 * being included in the async_synchronize_full() that is invoked by 96 * dpm_resume() 97 */ 98 ASYNC_DOMAIN_EXCLUSIVE(scsi_sd_pm_domain); 99 EXPORT_SYMBOL(scsi_sd_pm_domain); 100 101 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI. 102 * You may not alter any existing entry (although adding new ones is 103 * encouraged once assigned by ANSI/INCITS T10 104 */ 105 static const char *const scsi_device_types[] = { 106 "Direct-Access ", 107 "Sequential-Access", 108 "Printer ", 109 "Processor ", 110 "WORM ", 111 "CD-ROM ", 112 "Scanner ", 113 "Optical Device ", 114 "Medium Changer ", 115 "Communications ", 116 "ASC IT8 ", 117 "ASC IT8 ", 118 "RAID ", 119 "Enclosure ", 120 "Direct-Access-RBC", 121 "Optical card ", 122 "Bridge controller", 123 "Object storage ", 124 "Automation/Drive ", 125 "Security Manager ", 126 "Direct-Access-ZBC", 127 }; 128 129 /** 130 * scsi_device_type - Return 17 char string indicating device type. 131 * @type: type number to look up 132 */ 133 134 const char * scsi_device_type(unsigned type) 135 { 136 if (type == 0x1e) 137 return "Well-known LUN "; 138 if (type == 0x1f) 139 return "No Device "; 140 if (type >= ARRAY_SIZE(scsi_device_types)) 141 return "Unknown "; 142 return scsi_device_types[type]; 143 } 144 145 EXPORT_SYMBOL(scsi_device_type); 146 147 struct scsi_host_cmd_pool { 148 struct kmem_cache *cmd_slab; 149 struct kmem_cache *sense_slab; 150 unsigned int users; 151 char *cmd_name; 152 char *sense_name; 153 unsigned int slab_flags; 154 gfp_t gfp_mask; 155 }; 156 157 static struct scsi_host_cmd_pool scsi_cmd_pool = { 158 .cmd_name = "scsi_cmd_cache", 159 .sense_name = "scsi_sense_cache", 160 .slab_flags = SLAB_HWCACHE_ALIGN, 161 }; 162 163 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = { 164 .cmd_name = "scsi_cmd_cache(DMA)", 165 .sense_name = "scsi_sense_cache(DMA)", 166 .slab_flags = SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA, 167 .gfp_mask = __GFP_DMA, 168 }; 169 170 static DEFINE_MUTEX(host_cmd_pool_mutex); 171 172 /** 173 * scsi_host_free_command - internal function to release a command 174 * @shost: host to free the command for 175 * @cmd: command to release 176 * 177 * the command must previously have been allocated by 178 * scsi_host_alloc_command. 179 */ 180 static void 181 scsi_host_free_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd) 182 { 183 struct scsi_host_cmd_pool *pool = shost->cmd_pool; 184 185 if (cmd->prot_sdb) 186 kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb); 187 kmem_cache_free(pool->sense_slab, cmd->sense_buffer); 188 kmem_cache_free(pool->cmd_slab, cmd); 189 } 190 191 /** 192 * scsi_host_alloc_command - internal function to allocate command 193 * @shost: SCSI host whose pool to allocate from 194 * @gfp_mask: mask for the allocation 195 * 196 * Returns a fully allocated command with sense buffer and protection 197 * data buffer (where applicable) or NULL on failure 198 */ 199 static struct scsi_cmnd * 200 scsi_host_alloc_command(struct Scsi_Host *shost, gfp_t gfp_mask) 201 { 202 struct scsi_host_cmd_pool *pool = shost->cmd_pool; 203 struct scsi_cmnd *cmd; 204 205 cmd = kmem_cache_zalloc(pool->cmd_slab, gfp_mask | pool->gfp_mask); 206 if (!cmd) 207 goto fail; 208 209 cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab, 210 gfp_mask | pool->gfp_mask); 211 if (!cmd->sense_buffer) 212 goto fail_free_cmd; 213 214 if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) { 215 cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask); 216 if (!cmd->prot_sdb) 217 goto fail_free_sense; 218 } 219 220 return cmd; 221 222 fail_free_sense: 223 kmem_cache_free(pool->sense_slab, cmd->sense_buffer); 224 fail_free_cmd: 225 kmem_cache_free(pool->cmd_slab, cmd); 226 fail: 227 return NULL; 228 } 229 230 /** 231 * __scsi_get_command - Allocate a struct scsi_cmnd 232 * @shost: host to transmit command 233 * @gfp_mask: allocation mask 234 * 235 * Description: allocate a struct scsi_cmd from host's slab, recycling from the 236 * host's free_list if necessary. 237 */ 238 static struct scsi_cmnd * 239 __scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask) 240 { 241 struct scsi_cmnd *cmd = scsi_host_alloc_command(shost, gfp_mask); 242 243 if (unlikely(!cmd)) { 244 unsigned long flags; 245 246 spin_lock_irqsave(&shost->free_list_lock, flags); 247 if (likely(!list_empty(&shost->free_list))) { 248 cmd = list_entry(shost->free_list.next, 249 struct scsi_cmnd, list); 250 list_del_init(&cmd->list); 251 } 252 spin_unlock_irqrestore(&shost->free_list_lock, flags); 253 254 if (cmd) { 255 void *buf, *prot; 256 257 buf = cmd->sense_buffer; 258 prot = cmd->prot_sdb; 259 260 memset(cmd, 0, sizeof(*cmd)); 261 262 cmd->sense_buffer = buf; 263 cmd->prot_sdb = prot; 264 } 265 } 266 267 return cmd; 268 } 269 270 /** 271 * scsi_get_command - Allocate and setup a scsi command block 272 * @dev: parent scsi device 273 * @gfp_mask: allocator flags 274 * 275 * Returns: The allocated scsi command structure. 276 */ 277 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask) 278 { 279 struct scsi_cmnd *cmd = __scsi_get_command(dev->host, gfp_mask); 280 unsigned long flags; 281 282 if (unlikely(cmd == NULL)) 283 return NULL; 284 285 cmd->device = dev; 286 INIT_LIST_HEAD(&cmd->list); 287 INIT_DELAYED_WORK(&cmd->abort_work, scmd_eh_abort_handler); 288 spin_lock_irqsave(&dev->list_lock, flags); 289 list_add_tail(&cmd->list, &dev->cmd_list); 290 spin_unlock_irqrestore(&dev->list_lock, flags); 291 cmd->jiffies_at_alloc = jiffies; 292 return cmd; 293 } 294 295 /** 296 * __scsi_put_command - Free a struct scsi_cmnd 297 * @shost: dev->host 298 * @cmd: Command to free 299 */ 300 static void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd) 301 { 302 unsigned long flags; 303 304 if (unlikely(list_empty(&shost->free_list))) { 305 spin_lock_irqsave(&shost->free_list_lock, flags); 306 if (list_empty(&shost->free_list)) { 307 list_add(&cmd->list, &shost->free_list); 308 cmd = NULL; 309 } 310 spin_unlock_irqrestore(&shost->free_list_lock, flags); 311 } 312 313 if (likely(cmd != NULL)) 314 scsi_host_free_command(shost, cmd); 315 } 316 317 /** 318 * scsi_put_command - Free a scsi command block 319 * @cmd: command block to free 320 * 321 * Returns: Nothing. 322 * 323 * Notes: The command must not belong to any lists. 324 */ 325 void scsi_put_command(struct scsi_cmnd *cmd) 326 { 327 unsigned long flags; 328 329 /* serious error if the command hasn't come from a device list */ 330 spin_lock_irqsave(&cmd->device->list_lock, flags); 331 BUG_ON(list_empty(&cmd->list)); 332 list_del_init(&cmd->list); 333 spin_unlock_irqrestore(&cmd->device->list_lock, flags); 334 335 BUG_ON(delayed_work_pending(&cmd->abort_work)); 336 337 __scsi_put_command(cmd->device->host, cmd); 338 } 339 340 static struct scsi_host_cmd_pool * 341 scsi_find_host_cmd_pool(struct Scsi_Host *shost) 342 { 343 if (shost->hostt->cmd_size) 344 return shost->hostt->cmd_pool; 345 if (shost->unchecked_isa_dma) 346 return &scsi_cmd_dma_pool; 347 return &scsi_cmd_pool; 348 } 349 350 static void 351 scsi_free_host_cmd_pool(struct scsi_host_cmd_pool *pool) 352 { 353 kfree(pool->sense_name); 354 kfree(pool->cmd_name); 355 kfree(pool); 356 } 357 358 static struct scsi_host_cmd_pool * 359 scsi_alloc_host_cmd_pool(struct Scsi_Host *shost) 360 { 361 struct scsi_host_template *hostt = shost->hostt; 362 struct scsi_host_cmd_pool *pool; 363 364 pool = kzalloc(sizeof(*pool), GFP_KERNEL); 365 if (!pool) 366 return NULL; 367 368 pool->cmd_name = kasprintf(GFP_KERNEL, "%s_cmd", hostt->proc_name); 369 pool->sense_name = kasprintf(GFP_KERNEL, "%s_sense", hostt->proc_name); 370 if (!pool->cmd_name || !pool->sense_name) { 371 scsi_free_host_cmd_pool(pool); 372 return NULL; 373 } 374 375 pool->slab_flags = SLAB_HWCACHE_ALIGN; 376 if (shost->unchecked_isa_dma) { 377 pool->slab_flags |= SLAB_CACHE_DMA; 378 pool->gfp_mask = __GFP_DMA; 379 } 380 381 if (hostt->cmd_size) 382 hostt->cmd_pool = pool; 383 384 return pool; 385 } 386 387 static struct scsi_host_cmd_pool * 388 scsi_get_host_cmd_pool(struct Scsi_Host *shost) 389 { 390 struct scsi_host_template *hostt = shost->hostt; 391 struct scsi_host_cmd_pool *retval = NULL, *pool; 392 size_t cmd_size = sizeof(struct scsi_cmnd) + hostt->cmd_size; 393 394 /* 395 * Select a command slab for this host and create it if not 396 * yet existent. 397 */ 398 mutex_lock(&host_cmd_pool_mutex); 399 pool = scsi_find_host_cmd_pool(shost); 400 if (!pool) { 401 pool = scsi_alloc_host_cmd_pool(shost); 402 if (!pool) 403 goto out; 404 } 405 406 if (!pool->users) { 407 pool->cmd_slab = kmem_cache_create(pool->cmd_name, cmd_size, 0, 408 pool->slab_flags, NULL); 409 if (!pool->cmd_slab) 410 goto out_free_pool; 411 412 pool->sense_slab = kmem_cache_create(pool->sense_name, 413 SCSI_SENSE_BUFFERSIZE, 0, 414 pool->slab_flags, NULL); 415 if (!pool->sense_slab) 416 goto out_free_slab; 417 } 418 419 pool->users++; 420 retval = pool; 421 out: 422 mutex_unlock(&host_cmd_pool_mutex); 423 return retval; 424 425 out_free_slab: 426 kmem_cache_destroy(pool->cmd_slab); 427 out_free_pool: 428 if (hostt->cmd_size) { 429 scsi_free_host_cmd_pool(pool); 430 hostt->cmd_pool = NULL; 431 } 432 goto out; 433 } 434 435 static void scsi_put_host_cmd_pool(struct Scsi_Host *shost) 436 { 437 struct scsi_host_template *hostt = shost->hostt; 438 struct scsi_host_cmd_pool *pool; 439 440 mutex_lock(&host_cmd_pool_mutex); 441 pool = scsi_find_host_cmd_pool(shost); 442 443 /* 444 * This may happen if a driver has a mismatched get and put 445 * of the command pool; the driver should be implicated in 446 * the stack trace 447 */ 448 BUG_ON(pool->users == 0); 449 450 if (!--pool->users) { 451 kmem_cache_destroy(pool->cmd_slab); 452 kmem_cache_destroy(pool->sense_slab); 453 if (hostt->cmd_size) { 454 scsi_free_host_cmd_pool(pool); 455 hostt->cmd_pool = NULL; 456 } 457 } 458 mutex_unlock(&host_cmd_pool_mutex); 459 } 460 461 /** 462 * scsi_setup_command_freelist - Setup the command freelist for a scsi host. 463 * @shost: host to allocate the freelist for. 464 * 465 * Description: The command freelist protects against system-wide out of memory 466 * deadlock by preallocating one SCSI command structure for each host, so the 467 * system can always write to a swap file on a device associated with that host. 468 * 469 * Returns: Nothing. 470 */ 471 int scsi_setup_command_freelist(struct Scsi_Host *shost) 472 { 473 const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL; 474 struct scsi_cmnd *cmd; 475 476 spin_lock_init(&shost->free_list_lock); 477 INIT_LIST_HEAD(&shost->free_list); 478 479 shost->cmd_pool = scsi_get_host_cmd_pool(shost); 480 if (!shost->cmd_pool) 481 return -ENOMEM; 482 483 /* 484 * Get one backup command for this host. 485 */ 486 cmd = scsi_host_alloc_command(shost, gfp_mask); 487 if (!cmd) { 488 scsi_put_host_cmd_pool(shost); 489 shost->cmd_pool = NULL; 490 return -ENOMEM; 491 } 492 list_add(&cmd->list, &shost->free_list); 493 return 0; 494 } 495 496 /** 497 * scsi_destroy_command_freelist - Release the command freelist for a scsi host. 498 * @shost: host whose freelist is going to be destroyed 499 */ 500 void scsi_destroy_command_freelist(struct Scsi_Host *shost) 501 { 502 /* 503 * If cmd_pool is NULL the free list was not initialized, so 504 * do not attempt to release resources. 505 */ 506 if (!shost->cmd_pool) 507 return; 508 509 while (!list_empty(&shost->free_list)) { 510 struct scsi_cmnd *cmd; 511 512 cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list); 513 list_del_init(&cmd->list); 514 scsi_host_free_command(shost, cmd); 515 } 516 shost->cmd_pool = NULL; 517 scsi_put_host_cmd_pool(shost); 518 } 519 520 #ifdef CONFIG_SCSI_LOGGING 521 void scsi_log_send(struct scsi_cmnd *cmd) 522 { 523 unsigned int level; 524 525 /* 526 * If ML QUEUE log level is greater than or equal to: 527 * 528 * 1: nothing (match completion) 529 * 530 * 2: log opcode + command of all commands + cmd address 531 * 532 * 3: same as 2 533 * 534 * 4: same as 3 535 */ 536 if (unlikely(scsi_logging_level)) { 537 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT, 538 SCSI_LOG_MLQUEUE_BITS); 539 if (level > 1) { 540 scmd_printk(KERN_INFO, cmd, 541 "Send: scmd 0x%p\n", cmd); 542 scsi_print_command(cmd); 543 } 544 } 545 } 546 547 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition) 548 { 549 unsigned int level; 550 551 /* 552 * If ML COMPLETE log level is greater than or equal to: 553 * 554 * 1: log disposition, result, opcode + command, and conditionally 555 * sense data for failures or non SUCCESS dispositions. 556 * 557 * 2: same as 1 but for all command completions. 558 * 559 * 3: same as 2 560 * 561 * 4: same as 3 plus dump extra junk 562 */ 563 if (unlikely(scsi_logging_level)) { 564 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT, 565 SCSI_LOG_MLCOMPLETE_BITS); 566 if (((level > 0) && (cmd->result || disposition != SUCCESS)) || 567 (level > 1)) { 568 scsi_print_result(cmd, "Done", disposition); 569 scsi_print_command(cmd); 570 if (status_byte(cmd->result) & CHECK_CONDITION) 571 scsi_print_sense(cmd); 572 if (level > 3) 573 scmd_printk(KERN_INFO, cmd, 574 "scsi host busy %d failed %d\n", 575 atomic_read(&cmd->device->host->host_busy), 576 cmd->device->host->host_failed); 577 } 578 } 579 } 580 #endif 581 582 /** 583 * scsi_cmd_get_serial - Assign a serial number to a command 584 * @host: the scsi host 585 * @cmd: command to assign serial number to 586 * 587 * Description: a serial number identifies a request for error recovery 588 * and debugging purposes. Protected by the Host_Lock of host. 589 */ 590 void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd) 591 { 592 cmd->serial_number = host->cmd_serial_number++; 593 if (cmd->serial_number == 0) 594 cmd->serial_number = host->cmd_serial_number++; 595 } 596 EXPORT_SYMBOL(scsi_cmd_get_serial); 597 598 /** 599 * scsi_finish_command - cleanup and pass command back to upper layer 600 * @cmd: the command 601 * 602 * Description: Pass command off to upper layer for finishing of I/O 603 * request, waking processes that are waiting on results, 604 * etc. 605 */ 606 void scsi_finish_command(struct scsi_cmnd *cmd) 607 { 608 struct scsi_device *sdev = cmd->device; 609 struct scsi_target *starget = scsi_target(sdev); 610 struct Scsi_Host *shost = sdev->host; 611 struct scsi_driver *drv; 612 unsigned int good_bytes; 613 614 scsi_device_unbusy(sdev); 615 616 /* 617 * Clear the flags that say that the device/target/host is no longer 618 * capable of accepting new commands. 619 */ 620 if (atomic_read(&shost->host_blocked)) 621 atomic_set(&shost->host_blocked, 0); 622 if (atomic_read(&starget->target_blocked)) 623 atomic_set(&starget->target_blocked, 0); 624 if (atomic_read(&sdev->device_blocked)) 625 atomic_set(&sdev->device_blocked, 0); 626 627 /* 628 * If we have valid sense information, then some kind of recovery 629 * must have taken place. Make a note of this. 630 */ 631 if (SCSI_SENSE_VALID(cmd)) 632 cmd->result |= (DRIVER_SENSE << 24); 633 634 SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev, 635 "Notifying upper driver of completion " 636 "(result %x)\n", cmd->result)); 637 638 good_bytes = scsi_bufflen(cmd); 639 if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) { 640 int old_good_bytes = good_bytes; 641 drv = scsi_cmd_to_driver(cmd); 642 if (drv->done) 643 good_bytes = drv->done(cmd); 644 /* 645 * USB may not give sense identifying bad sector and 646 * simply return a residue instead, so subtract off the 647 * residue if drv->done() error processing indicates no 648 * change to the completion length. 649 */ 650 if (good_bytes == old_good_bytes) 651 good_bytes -= scsi_get_resid(cmd); 652 } 653 scsi_io_completion(cmd, good_bytes); 654 } 655 656 /** 657 * scsi_change_queue_depth - change a device's queue depth 658 * @sdev: SCSI Device in question 659 * @depth: number of commands allowed to be queued to the driver 660 * 661 * Sets the device queue depth and returns the new value. 662 */ 663 int scsi_change_queue_depth(struct scsi_device *sdev, int depth) 664 { 665 unsigned long flags; 666 667 if (depth <= 0) 668 goto out; 669 670 spin_lock_irqsave(sdev->request_queue->queue_lock, flags); 671 672 /* 673 * Check to see if the queue is managed by the block layer. 674 * If it is, and we fail to adjust the depth, exit. 675 * 676 * Do not resize the tag map if it is a host wide share bqt, 677 * because the size should be the hosts's can_queue. If there 678 * is more IO than the LLD's can_queue (so there are not enuogh 679 * tags) request_fn's host queue ready check will handle it. 680 */ 681 if (!shost_use_blk_mq(sdev->host) && !sdev->host->bqt) { 682 if (blk_queue_tagged(sdev->request_queue) && 683 blk_queue_resize_tags(sdev->request_queue, depth) != 0) 684 goto out_unlock; 685 } 686 687 sdev->queue_depth = depth; 688 out_unlock: 689 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags); 690 out: 691 return sdev->queue_depth; 692 } 693 EXPORT_SYMBOL(scsi_change_queue_depth); 694 695 /** 696 * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth 697 * @sdev: SCSI Device in question 698 * @depth: Current number of outstanding SCSI commands on this device, 699 * not counting the one returned as QUEUE_FULL. 700 * 701 * Description: This function will track successive QUEUE_FULL events on a 702 * specific SCSI device to determine if and when there is a 703 * need to adjust the queue depth on the device. 704 * 705 * Returns: 0 - No change needed, >0 - Adjust queue depth to this new depth, 706 * -1 - Drop back to untagged operation using host->cmd_per_lun 707 * as the untagged command depth 708 * 709 * Lock Status: None held on entry 710 * 711 * Notes: Low level drivers may call this at any time and we will do 712 * "The Right Thing." We are interrupt context safe. 713 */ 714 int scsi_track_queue_full(struct scsi_device *sdev, int depth) 715 { 716 717 /* 718 * Don't let QUEUE_FULLs on the same 719 * jiffies count, they could all be from 720 * same event. 721 */ 722 if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4)) 723 return 0; 724 725 sdev->last_queue_full_time = jiffies; 726 if (sdev->last_queue_full_depth != depth) { 727 sdev->last_queue_full_count = 1; 728 sdev->last_queue_full_depth = depth; 729 } else { 730 sdev->last_queue_full_count++; 731 } 732 733 if (sdev->last_queue_full_count <= 10) 734 return 0; 735 736 return scsi_change_queue_depth(sdev, depth); 737 } 738 EXPORT_SYMBOL(scsi_track_queue_full); 739 740 /** 741 * scsi_vpd_inquiry - Request a device provide us with a VPD page 742 * @sdev: The device to ask 743 * @buffer: Where to put the result 744 * @page: Which Vital Product Data to return 745 * @len: The length of the buffer 746 * 747 * This is an internal helper function. You probably want to use 748 * scsi_get_vpd_page instead. 749 * 750 * Returns size of the vpd page on success or a negative error number. 751 */ 752 static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer, 753 u8 page, unsigned len) 754 { 755 int result; 756 unsigned char cmd[16]; 757 758 if (len < 4) 759 return -EINVAL; 760 761 cmd[0] = INQUIRY; 762 cmd[1] = 1; /* EVPD */ 763 cmd[2] = page; 764 cmd[3] = len >> 8; 765 cmd[4] = len & 0xff; 766 cmd[5] = 0; /* Control byte */ 767 768 /* 769 * I'm not convinced we need to try quite this hard to get VPD, but 770 * all the existing users tried this hard. 771 */ 772 result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, 773 len, NULL, 30 * HZ, 3, NULL); 774 if (result) 775 return -EIO; 776 777 /* Sanity check that we got the page back that we asked for */ 778 if (buffer[1] != page) 779 return -EIO; 780 781 return get_unaligned_be16(&buffer[2]) + 4; 782 } 783 784 /** 785 * scsi_get_vpd_page - Get Vital Product Data from a SCSI device 786 * @sdev: The device to ask 787 * @page: Which Vital Product Data to return 788 * @buf: where to store the VPD 789 * @buf_len: number of bytes in the VPD buffer area 790 * 791 * SCSI devices may optionally supply Vital Product Data. Each 'page' 792 * of VPD is defined in the appropriate SCSI document (eg SPC, SBC). 793 * If the device supports this VPD page, this routine returns a pointer 794 * to a buffer containing the data from that page. The caller is 795 * responsible for calling kfree() on this pointer when it is no longer 796 * needed. If we cannot retrieve the VPD page this routine returns %NULL. 797 */ 798 int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf, 799 int buf_len) 800 { 801 int i, result; 802 803 if (sdev->skip_vpd_pages) 804 goto fail; 805 806 /* Ask for all the pages supported by this device */ 807 result = scsi_vpd_inquiry(sdev, buf, 0, buf_len); 808 if (result < 4) 809 goto fail; 810 811 /* If the user actually wanted this page, we can skip the rest */ 812 if (page == 0) 813 return 0; 814 815 for (i = 4; i < min(result, buf_len); i++) 816 if (buf[i] == page) 817 goto found; 818 819 if (i < result && i >= buf_len) 820 /* ran off the end of the buffer, give us benefit of doubt */ 821 goto found; 822 /* The device claims it doesn't support the requested page */ 823 goto fail; 824 825 found: 826 result = scsi_vpd_inquiry(sdev, buf, page, buf_len); 827 if (result < 0) 828 goto fail; 829 830 return 0; 831 832 fail: 833 return -EINVAL; 834 } 835 EXPORT_SYMBOL_GPL(scsi_get_vpd_page); 836 837 /** 838 * scsi_attach_vpd - Attach Vital Product Data to a SCSI device structure 839 * @sdev: The device to ask 840 * 841 * Attach the 'Device Identification' VPD page (0x83) and the 842 * 'Unit Serial Number' VPD page (0x80) to a SCSI device 843 * structure. This information can be used to identify the device 844 * uniquely. 845 */ 846 void scsi_attach_vpd(struct scsi_device *sdev) 847 { 848 int result, i; 849 int vpd_len = SCSI_VPD_PG_LEN; 850 int pg80_supported = 0; 851 int pg83_supported = 0; 852 unsigned char *vpd_buf; 853 854 if (sdev->skip_vpd_pages) 855 return; 856 retry_pg0: 857 vpd_buf = kmalloc(vpd_len, GFP_KERNEL); 858 if (!vpd_buf) 859 return; 860 861 /* Ask for all the pages supported by this device */ 862 result = scsi_vpd_inquiry(sdev, vpd_buf, 0, vpd_len); 863 if (result < 0) { 864 kfree(vpd_buf); 865 return; 866 } 867 if (result > vpd_len) { 868 vpd_len = result; 869 kfree(vpd_buf); 870 goto retry_pg0; 871 } 872 873 for (i = 4; i < result; i++) { 874 if (vpd_buf[i] == 0x80) 875 pg80_supported = 1; 876 if (vpd_buf[i] == 0x83) 877 pg83_supported = 1; 878 } 879 kfree(vpd_buf); 880 vpd_len = SCSI_VPD_PG_LEN; 881 882 if (pg80_supported) { 883 retry_pg80: 884 vpd_buf = kmalloc(vpd_len, GFP_KERNEL); 885 if (!vpd_buf) 886 return; 887 888 result = scsi_vpd_inquiry(sdev, vpd_buf, 0x80, vpd_len); 889 if (result < 0) { 890 kfree(vpd_buf); 891 return; 892 } 893 if (result > vpd_len) { 894 vpd_len = result; 895 kfree(vpd_buf); 896 goto retry_pg80; 897 } 898 sdev->vpd_pg80_len = result; 899 sdev->vpd_pg80 = vpd_buf; 900 vpd_len = SCSI_VPD_PG_LEN; 901 } 902 903 if (pg83_supported) { 904 retry_pg83: 905 vpd_buf = kmalloc(vpd_len, GFP_KERNEL); 906 if (!vpd_buf) 907 return; 908 909 result = scsi_vpd_inquiry(sdev, vpd_buf, 0x83, vpd_len); 910 if (result < 0) { 911 kfree(vpd_buf); 912 return; 913 } 914 if (result > vpd_len) { 915 vpd_len = result; 916 kfree(vpd_buf); 917 goto retry_pg83; 918 } 919 sdev->vpd_pg83_len = result; 920 sdev->vpd_pg83 = vpd_buf; 921 } 922 } 923 924 /** 925 * scsi_report_opcode - Find out if a given command opcode is supported 926 * @sdev: scsi device to query 927 * @buffer: scratch buffer (must be at least 20 bytes long) 928 * @len: length of buffer 929 * @opcode: opcode for command to look up 930 * 931 * Uses the REPORT SUPPORTED OPERATION CODES to look up the given 932 * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is 933 * unsupported and 1 if the device claims to support the command. 934 */ 935 int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer, 936 unsigned int len, unsigned char opcode) 937 { 938 unsigned char cmd[16]; 939 struct scsi_sense_hdr sshdr; 940 int result; 941 942 if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3) 943 return -EINVAL; 944 945 memset(cmd, 0, 16); 946 cmd[0] = MAINTENANCE_IN; 947 cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES; 948 cmd[2] = 1; /* One command format */ 949 cmd[3] = opcode; 950 put_unaligned_be32(len, &cmd[6]); 951 memset(buffer, 0, len); 952 953 result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len, 954 &sshdr, 30 * HZ, 3, NULL); 955 956 if (result && scsi_sense_valid(&sshdr) && 957 sshdr.sense_key == ILLEGAL_REQUEST && 958 (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00) 959 return -EINVAL; 960 961 if ((buffer[1] & 3) == 3) /* Command supported */ 962 return 1; 963 964 return 0; 965 } 966 EXPORT_SYMBOL(scsi_report_opcode); 967 968 /** 969 * scsi_device_get - get an additional reference to a scsi_device 970 * @sdev: device to get a reference to 971 * 972 * Description: Gets a reference to the scsi_device and increments the use count 973 * of the underlying LLDD module. You must hold host_lock of the 974 * parent Scsi_Host or already have a reference when calling this. 975 */ 976 int scsi_device_get(struct scsi_device *sdev) 977 { 978 if (sdev->sdev_state == SDEV_DEL) 979 return -ENXIO; 980 if (!get_device(&sdev->sdev_gendev)) 981 return -ENXIO; 982 /* We can fail try_module_get if we're doing SCSI operations 983 * from module exit (like cache flush) */ 984 __module_get(sdev->host->hostt->module); 985 986 return 0; 987 } 988 EXPORT_SYMBOL(scsi_device_get); 989 990 /** 991 * scsi_device_put - release a reference to a scsi_device 992 * @sdev: device to release a reference on. 993 * 994 * Description: Release a reference to the scsi_device and decrements the use 995 * count of the underlying LLDD module. The device is freed once the last 996 * user vanishes. 997 */ 998 void scsi_device_put(struct scsi_device *sdev) 999 { 1000 module_put(sdev->host->hostt->module); 1001 put_device(&sdev->sdev_gendev); 1002 } 1003 EXPORT_SYMBOL(scsi_device_put); 1004 1005 /* helper for shost_for_each_device, see that for documentation */ 1006 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost, 1007 struct scsi_device *prev) 1008 { 1009 struct list_head *list = (prev ? &prev->siblings : &shost->__devices); 1010 struct scsi_device *next = NULL; 1011 unsigned long flags; 1012 1013 spin_lock_irqsave(shost->host_lock, flags); 1014 while (list->next != &shost->__devices) { 1015 next = list_entry(list->next, struct scsi_device, siblings); 1016 /* skip devices that we can't get a reference to */ 1017 if (!scsi_device_get(next)) 1018 break; 1019 next = NULL; 1020 list = list->next; 1021 } 1022 spin_unlock_irqrestore(shost->host_lock, flags); 1023 1024 if (prev) 1025 scsi_device_put(prev); 1026 return next; 1027 } 1028 EXPORT_SYMBOL(__scsi_iterate_devices); 1029 1030 /** 1031 * starget_for_each_device - helper to walk all devices of a target 1032 * @starget: target whose devices we want to iterate over. 1033 * @data: Opaque passed to each function call. 1034 * @fn: Function to call on each device 1035 * 1036 * This traverses over each device of @starget. The devices have 1037 * a reference that must be released by scsi_host_put when breaking 1038 * out of the loop. 1039 */ 1040 void starget_for_each_device(struct scsi_target *starget, void *data, 1041 void (*fn)(struct scsi_device *, void *)) 1042 { 1043 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1044 struct scsi_device *sdev; 1045 1046 shost_for_each_device(sdev, shost) { 1047 if ((sdev->channel == starget->channel) && 1048 (sdev->id == starget->id)) 1049 fn(sdev, data); 1050 } 1051 } 1052 EXPORT_SYMBOL(starget_for_each_device); 1053 1054 /** 1055 * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED) 1056 * @starget: target whose devices we want to iterate over. 1057 * @data: parameter for callback @fn() 1058 * @fn: callback function that is invoked for each device 1059 * 1060 * This traverses over each device of @starget. It does _not_ 1061 * take a reference on the scsi_device, so the whole loop must be 1062 * protected by shost->host_lock. 1063 * 1064 * Note: The only reason why drivers would want to use this is because 1065 * they need to access the device list in irq context. Otherwise you 1066 * really want to use starget_for_each_device instead. 1067 **/ 1068 void __starget_for_each_device(struct scsi_target *starget, void *data, 1069 void (*fn)(struct scsi_device *, void *)) 1070 { 1071 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1072 struct scsi_device *sdev; 1073 1074 __shost_for_each_device(sdev, shost) { 1075 if ((sdev->channel == starget->channel) && 1076 (sdev->id == starget->id)) 1077 fn(sdev, data); 1078 } 1079 } 1080 EXPORT_SYMBOL(__starget_for_each_device); 1081 1082 /** 1083 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED) 1084 * @starget: SCSI target pointer 1085 * @lun: SCSI Logical Unit Number 1086 * 1087 * Description: Looks up the scsi_device with the specified @lun for a given 1088 * @starget. The returned scsi_device does not have an additional 1089 * reference. You must hold the host's host_lock over this call and 1090 * any access to the returned scsi_device. A scsi_device in state 1091 * SDEV_DEL is skipped. 1092 * 1093 * Note: The only reason why drivers should use this is because 1094 * they need to access the device list in irq context. Otherwise you 1095 * really want to use scsi_device_lookup_by_target instead. 1096 **/ 1097 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget, 1098 u64 lun) 1099 { 1100 struct scsi_device *sdev; 1101 1102 list_for_each_entry(sdev, &starget->devices, same_target_siblings) { 1103 if (sdev->sdev_state == SDEV_DEL) 1104 continue; 1105 if (sdev->lun ==lun) 1106 return sdev; 1107 } 1108 1109 return NULL; 1110 } 1111 EXPORT_SYMBOL(__scsi_device_lookup_by_target); 1112 1113 /** 1114 * scsi_device_lookup_by_target - find a device given the target 1115 * @starget: SCSI target pointer 1116 * @lun: SCSI Logical Unit Number 1117 * 1118 * Description: Looks up the scsi_device with the specified @lun for a given 1119 * @starget. The returned scsi_device has an additional reference that 1120 * needs to be released with scsi_device_put once you're done with it. 1121 **/ 1122 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget, 1123 u64 lun) 1124 { 1125 struct scsi_device *sdev; 1126 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1127 unsigned long flags; 1128 1129 spin_lock_irqsave(shost->host_lock, flags); 1130 sdev = __scsi_device_lookup_by_target(starget, lun); 1131 if (sdev && scsi_device_get(sdev)) 1132 sdev = NULL; 1133 spin_unlock_irqrestore(shost->host_lock, flags); 1134 1135 return sdev; 1136 } 1137 EXPORT_SYMBOL(scsi_device_lookup_by_target); 1138 1139 /** 1140 * __scsi_device_lookup - find a device given the host (UNLOCKED) 1141 * @shost: SCSI host pointer 1142 * @channel: SCSI channel (zero if only one channel) 1143 * @id: SCSI target number (physical unit number) 1144 * @lun: SCSI Logical Unit Number 1145 * 1146 * Description: Looks up the scsi_device with the specified @channel, @id, @lun 1147 * for a given host. The returned scsi_device does not have an additional 1148 * reference. You must hold the host's host_lock over this call and any access 1149 * to the returned scsi_device. 1150 * 1151 * Note: The only reason why drivers would want to use this is because 1152 * they need to access the device list in irq context. Otherwise you 1153 * really want to use scsi_device_lookup instead. 1154 **/ 1155 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost, 1156 uint channel, uint id, u64 lun) 1157 { 1158 struct scsi_device *sdev; 1159 1160 list_for_each_entry(sdev, &shost->__devices, siblings) { 1161 if (sdev->channel == channel && sdev->id == id && 1162 sdev->lun ==lun) 1163 return sdev; 1164 } 1165 1166 return NULL; 1167 } 1168 EXPORT_SYMBOL(__scsi_device_lookup); 1169 1170 /** 1171 * scsi_device_lookup - find a device given the host 1172 * @shost: SCSI host pointer 1173 * @channel: SCSI channel (zero if only one channel) 1174 * @id: SCSI target number (physical unit number) 1175 * @lun: SCSI Logical Unit Number 1176 * 1177 * Description: Looks up the scsi_device with the specified @channel, @id, @lun 1178 * for a given host. The returned scsi_device has an additional reference that 1179 * needs to be released with scsi_device_put once you're done with it. 1180 **/ 1181 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost, 1182 uint channel, uint id, u64 lun) 1183 { 1184 struct scsi_device *sdev; 1185 unsigned long flags; 1186 1187 spin_lock_irqsave(shost->host_lock, flags); 1188 sdev = __scsi_device_lookup(shost, channel, id, lun); 1189 if (sdev && scsi_device_get(sdev)) 1190 sdev = NULL; 1191 spin_unlock_irqrestore(shost->host_lock, flags); 1192 1193 return sdev; 1194 } 1195 EXPORT_SYMBOL(scsi_device_lookup); 1196 1197 MODULE_DESCRIPTION("SCSI core"); 1198 MODULE_LICENSE("GPL"); 1199 1200 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR); 1201 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels"); 1202 1203 #ifdef CONFIG_SCSI_MQ_DEFAULT 1204 bool scsi_use_blk_mq = true; 1205 #else 1206 bool scsi_use_blk_mq = false; 1207 #endif 1208 module_param_named(use_blk_mq, scsi_use_blk_mq, bool, S_IWUSR | S_IRUGO); 1209 1210 static int __init init_scsi(void) 1211 { 1212 int error; 1213 1214 error = scsi_init_queue(); 1215 if (error) 1216 return error; 1217 error = scsi_init_procfs(); 1218 if (error) 1219 goto cleanup_queue; 1220 error = scsi_init_devinfo(); 1221 if (error) 1222 goto cleanup_procfs; 1223 error = scsi_init_hosts(); 1224 if (error) 1225 goto cleanup_devlist; 1226 error = scsi_init_sysctl(); 1227 if (error) 1228 goto cleanup_hosts; 1229 error = scsi_sysfs_register(); 1230 if (error) 1231 goto cleanup_sysctl; 1232 1233 scsi_netlink_init(); 1234 1235 printk(KERN_NOTICE "SCSI subsystem initialized\n"); 1236 return 0; 1237 1238 cleanup_sysctl: 1239 scsi_exit_sysctl(); 1240 cleanup_hosts: 1241 scsi_exit_hosts(); 1242 cleanup_devlist: 1243 scsi_exit_devinfo(); 1244 cleanup_procfs: 1245 scsi_exit_procfs(); 1246 cleanup_queue: 1247 scsi_exit_queue(); 1248 printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n", 1249 -error); 1250 return error; 1251 } 1252 1253 static void __exit exit_scsi(void) 1254 { 1255 scsi_netlink_exit(); 1256 scsi_sysfs_unregister(); 1257 scsi_exit_sysctl(); 1258 scsi_exit_hosts(); 1259 scsi_exit_devinfo(); 1260 scsi_exit_procfs(); 1261 scsi_exit_queue(); 1262 async_unregister_domain(&scsi_sd_probe_domain); 1263 } 1264 1265 subsys_initcall(init_scsi); 1266 module_exit(exit_scsi); 1267