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 */ 83unsigned int scsi_logging_level; 84#if defined(CONFIG_SCSI_LOGGING) 85EXPORT_SYMBOL(scsi_logging_level); 86#endif 87 88/* sd, scsi core and power management need to coordinate flushing async actions */ 89ASYNC_DOMAIN(scsi_sd_probe_domain); 90EXPORT_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 */ 98ASYNC_DOMAIN_EXCLUSIVE(scsi_sd_pm_domain); 99EXPORT_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 */ 105static 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 134const 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 145EXPORT_SYMBOL(scsi_device_type); 146 147struct 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 157static 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 163static 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 170static 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 */ 180static void 181scsi_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 */ 199static struct scsi_cmnd * 200scsi_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 222fail_free_sense: 223 kmem_cache_free(pool->sense_slab, cmd->sense_buffer); 224fail_free_cmd: 225 kmem_cache_free(pool->cmd_slab, cmd); 226fail: 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 */ 238static 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 */ 277struct 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 */ 300static 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 */ 325void 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 340static struct scsi_host_cmd_pool * 341scsi_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 350static void 351scsi_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 358static struct scsi_host_cmd_pool * 359scsi_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 387static struct scsi_host_cmd_pool * 388scsi_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; 421out: 422 mutex_unlock(&host_cmd_pool_mutex); 423 return retval; 424 425out_free_slab: 426 kmem_cache_destroy(pool->cmd_slab); 427out_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 435static 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 */ 471int 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 */ 500void 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 521void 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 547void 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 */ 590void 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} 596EXPORT_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 */ 606void 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 */ 663int 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; 688out_unlock: 689 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags); 690out: 691 return sdev->queue_depth; 692} 693EXPORT_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 */ 714int 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} 738EXPORT_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 */ 752static 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 */ 798int 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} 835EXPORT_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 */ 846void 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; 856retry_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) { 883retry_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) { 904retry_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 */ 935int 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} 966EXPORT_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 * This will fail if a device is deleted or cancelled, or when the LLD module 977 * is in the process of being unloaded. 978 */ 979int scsi_device_get(struct scsi_device *sdev) 980{ 981 if (sdev->sdev_state == SDEV_DEL || sdev->sdev_state == SDEV_CANCEL) 982 goto fail; 983 if (!get_device(&sdev->sdev_gendev)) 984 goto fail; 985 if (!try_module_get(sdev->host->hostt->module)) 986 goto fail_put_device; 987 return 0; 988 989fail_put_device: 990 put_device(&sdev->sdev_gendev); 991fail: 992 return -ENXIO; 993} 994EXPORT_SYMBOL(scsi_device_get); 995 996/** 997 * scsi_device_put - release a reference to a scsi_device 998 * @sdev: device to release a reference on. 999 * 1000 * Description: Release a reference to the scsi_device and decrements the use 1001 * count of the underlying LLDD module. The device is freed once the last 1002 * user vanishes. 1003 */ 1004void scsi_device_put(struct scsi_device *sdev) 1005{ 1006 module_put(sdev->host->hostt->module); 1007 put_device(&sdev->sdev_gendev); 1008} 1009EXPORT_SYMBOL(scsi_device_put); 1010 1011/* helper for shost_for_each_device, see that for documentation */ 1012struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost, 1013 struct scsi_device *prev) 1014{ 1015 struct list_head *list = (prev ? &prev->siblings : &shost->__devices); 1016 struct scsi_device *next = NULL; 1017 unsigned long flags; 1018 1019 spin_lock_irqsave(shost->host_lock, flags); 1020 while (list->next != &shost->__devices) { 1021 next = list_entry(list->next, struct scsi_device, siblings); 1022 /* skip devices that we can't get a reference to */ 1023 if (!scsi_device_get(next)) 1024 break; 1025 next = NULL; 1026 list = list->next; 1027 } 1028 spin_unlock_irqrestore(shost->host_lock, flags); 1029 1030 if (prev) 1031 scsi_device_put(prev); 1032 return next; 1033} 1034EXPORT_SYMBOL(__scsi_iterate_devices); 1035 1036/** 1037 * starget_for_each_device - helper to walk all devices of a target 1038 * @starget: target whose devices we want to iterate over. 1039 * @data: Opaque passed to each function call. 1040 * @fn: Function to call on each device 1041 * 1042 * This traverses over each device of @starget. The devices have 1043 * a reference that must be released by scsi_host_put when breaking 1044 * out of the loop. 1045 */ 1046void starget_for_each_device(struct scsi_target *starget, void *data, 1047 void (*fn)(struct scsi_device *, void *)) 1048{ 1049 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1050 struct scsi_device *sdev; 1051 1052 shost_for_each_device(sdev, shost) { 1053 if ((sdev->channel == starget->channel) && 1054 (sdev->id == starget->id)) 1055 fn(sdev, data); 1056 } 1057} 1058EXPORT_SYMBOL(starget_for_each_device); 1059 1060/** 1061 * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED) 1062 * @starget: target whose devices we want to iterate over. 1063 * @data: parameter for callback @fn() 1064 * @fn: callback function that is invoked for each device 1065 * 1066 * This traverses over each device of @starget. It does _not_ 1067 * take a reference on the scsi_device, so the whole loop must be 1068 * protected by shost->host_lock. 1069 * 1070 * Note: The only reason why drivers would want to use this is because 1071 * they need to access the device list in irq context. Otherwise you 1072 * really want to use starget_for_each_device instead. 1073 **/ 1074void __starget_for_each_device(struct scsi_target *starget, void *data, 1075 void (*fn)(struct scsi_device *, void *)) 1076{ 1077 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1078 struct scsi_device *sdev; 1079 1080 __shost_for_each_device(sdev, shost) { 1081 if ((sdev->channel == starget->channel) && 1082 (sdev->id == starget->id)) 1083 fn(sdev, data); 1084 } 1085} 1086EXPORT_SYMBOL(__starget_for_each_device); 1087 1088/** 1089 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED) 1090 * @starget: SCSI target pointer 1091 * @lun: SCSI Logical Unit Number 1092 * 1093 * Description: Looks up the scsi_device with the specified @lun for a given 1094 * @starget. The returned scsi_device does not have an additional 1095 * reference. You must hold the host's host_lock over this call and 1096 * any access to the returned scsi_device. A scsi_device in state 1097 * SDEV_DEL is skipped. 1098 * 1099 * Note: The only reason why drivers should use this is because 1100 * they need to access the device list in irq context. Otherwise you 1101 * really want to use scsi_device_lookup_by_target instead. 1102 **/ 1103struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget, 1104 u64 lun) 1105{ 1106 struct scsi_device *sdev; 1107 1108 list_for_each_entry(sdev, &starget->devices, same_target_siblings) { 1109 if (sdev->sdev_state == SDEV_DEL) 1110 continue; 1111 if (sdev->lun ==lun) 1112 return sdev; 1113 } 1114 1115 return NULL; 1116} 1117EXPORT_SYMBOL(__scsi_device_lookup_by_target); 1118 1119/** 1120 * scsi_device_lookup_by_target - find a device given the target 1121 * @starget: SCSI target pointer 1122 * @lun: SCSI Logical Unit Number 1123 * 1124 * Description: Looks up the scsi_device with the specified @lun for a given 1125 * @starget. The returned scsi_device has an additional reference that 1126 * needs to be released with scsi_device_put once you're done with it. 1127 **/ 1128struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget, 1129 u64 lun) 1130{ 1131 struct scsi_device *sdev; 1132 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1133 unsigned long flags; 1134 1135 spin_lock_irqsave(shost->host_lock, flags); 1136 sdev = __scsi_device_lookup_by_target(starget, lun); 1137 if (sdev && scsi_device_get(sdev)) 1138 sdev = NULL; 1139 spin_unlock_irqrestore(shost->host_lock, flags); 1140 1141 return sdev; 1142} 1143EXPORT_SYMBOL(scsi_device_lookup_by_target); 1144 1145/** 1146 * __scsi_device_lookup - find a device given the host (UNLOCKED) 1147 * @shost: SCSI host pointer 1148 * @channel: SCSI channel (zero if only one channel) 1149 * @id: SCSI target number (physical unit number) 1150 * @lun: SCSI Logical Unit Number 1151 * 1152 * Description: Looks up the scsi_device with the specified @channel, @id, @lun 1153 * for a given host. The returned scsi_device does not have an additional 1154 * reference. You must hold the host's host_lock over this call and any access 1155 * to the returned scsi_device. 1156 * 1157 * Note: The only reason why drivers would want to use this is because 1158 * they need to access the device list in irq context. Otherwise you 1159 * really want to use scsi_device_lookup instead. 1160 **/ 1161struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost, 1162 uint channel, uint id, u64 lun) 1163{ 1164 struct scsi_device *sdev; 1165 1166 list_for_each_entry(sdev, &shost->__devices, siblings) { 1167 if (sdev->channel == channel && sdev->id == id && 1168 sdev->lun ==lun) 1169 return sdev; 1170 } 1171 1172 return NULL; 1173} 1174EXPORT_SYMBOL(__scsi_device_lookup); 1175 1176/** 1177 * scsi_device_lookup - find a device given the host 1178 * @shost: SCSI host pointer 1179 * @channel: SCSI channel (zero if only one channel) 1180 * @id: SCSI target number (physical unit number) 1181 * @lun: SCSI Logical Unit Number 1182 * 1183 * Description: Looks up the scsi_device with the specified @channel, @id, @lun 1184 * for a given host. The returned scsi_device has an additional reference that 1185 * needs to be released with scsi_device_put once you're done with it. 1186 **/ 1187struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost, 1188 uint channel, uint id, u64 lun) 1189{ 1190 struct scsi_device *sdev; 1191 unsigned long flags; 1192 1193 spin_lock_irqsave(shost->host_lock, flags); 1194 sdev = __scsi_device_lookup(shost, channel, id, lun); 1195 if (sdev && scsi_device_get(sdev)) 1196 sdev = NULL; 1197 spin_unlock_irqrestore(shost->host_lock, flags); 1198 1199 return sdev; 1200} 1201EXPORT_SYMBOL(scsi_device_lookup); 1202 1203MODULE_DESCRIPTION("SCSI core"); 1204MODULE_LICENSE("GPL"); 1205 1206module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR); 1207MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels"); 1208 1209#ifdef CONFIG_SCSI_MQ_DEFAULT 1210bool scsi_use_blk_mq = true; 1211#else 1212bool scsi_use_blk_mq = false; 1213#endif 1214module_param_named(use_blk_mq, scsi_use_blk_mq, bool, S_IWUSR | S_IRUGO); 1215 1216static int __init init_scsi(void) 1217{ 1218 int error; 1219 1220 error = scsi_init_queue(); 1221 if (error) 1222 return error; 1223 error = scsi_init_procfs(); 1224 if (error) 1225 goto cleanup_queue; 1226 error = scsi_init_devinfo(); 1227 if (error) 1228 goto cleanup_procfs; 1229 error = scsi_init_hosts(); 1230 if (error) 1231 goto cleanup_devlist; 1232 error = scsi_init_sysctl(); 1233 if (error) 1234 goto cleanup_hosts; 1235 error = scsi_sysfs_register(); 1236 if (error) 1237 goto cleanup_sysctl; 1238 1239 scsi_netlink_init(); 1240 1241 printk(KERN_NOTICE "SCSI subsystem initialized\n"); 1242 return 0; 1243 1244cleanup_sysctl: 1245 scsi_exit_sysctl(); 1246cleanup_hosts: 1247 scsi_exit_hosts(); 1248cleanup_devlist: 1249 scsi_exit_devinfo(); 1250cleanup_procfs: 1251 scsi_exit_procfs(); 1252cleanup_queue: 1253 scsi_exit_queue(); 1254 printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n", 1255 -error); 1256 return error; 1257} 1258 1259static void __exit exit_scsi(void) 1260{ 1261 scsi_netlink_exit(); 1262 scsi_sysfs_unregister(); 1263 scsi_exit_sysctl(); 1264 scsi_exit_hosts(); 1265 scsi_exit_devinfo(); 1266 scsi_exit_procfs(); 1267 scsi_exit_queue(); 1268 async_unregister_domain(&scsi_sd_probe_domain); 1269} 1270 1271subsys_initcall(init_scsi); 1272module_exit(exit_scsi); 1273