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/sched.h> 44 #include <linux/timer.h> 45 #include <linux/string.h> 46 #include <linux/slab.h> 47 #include <linux/blkdev.h> 48 #include <linux/delay.h> 49 #include <linux/init.h> 50 #include <linux/completion.h> 51 #include <linux/unistd.h> 52 #include <linux/spinlock.h> 53 #include <linux/kmod.h> 54 #include <linux/interrupt.h> 55 #include <linux/notifier.h> 56 #include <linux/cpu.h> 57 #include <linux/mutex.h> 58 59 #include <scsi/scsi.h> 60 #include <scsi/scsi_cmnd.h> 61 #include <scsi/scsi_dbg.h> 62 #include <scsi/scsi_device.h> 63 #include <scsi/scsi_eh.h> 64 #include <scsi/scsi_host.h> 65 #include <scsi/scsi_tcq.h> 66 67 #include "scsi_priv.h" 68 #include "scsi_logging.h" 69 70 static void scsi_done(struct scsi_cmnd *cmd); 71 72 /* 73 * Definitions and constants. 74 */ 75 76 #define MIN_RESET_DELAY (2*HZ) 77 78 /* Do not call reset on error if we just did a reset within 15 sec. */ 79 #define MIN_RESET_PERIOD (15*HZ) 80 81 /* 82 * Macro to determine the size of SCSI command. This macro takes vendor 83 * unique commands into account. SCSI commands in groups 6 and 7 are 84 * vendor unique and we will depend upon the command length being 85 * supplied correctly in cmd_len. 86 */ 87 #define CDB_SIZE(cmd) (((((cmd)->cmnd[0] >> 5) & 7) < 6) ? \ 88 COMMAND_SIZE((cmd)->cmnd[0]) : (cmd)->cmd_len) 89 90 /* 91 * Note - the initial logging level can be set here to log events at boot time. 92 * After the system is up, you may enable logging via the /proc interface. 93 */ 94 unsigned int scsi_logging_level; 95 #if defined(CONFIG_SCSI_LOGGING) 96 EXPORT_SYMBOL(scsi_logging_level); 97 #endif 98 99 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI. 100 * You may not alter any existing entry (although adding new ones is 101 * encouraged once assigned by ANSI/INCITS T10 102 */ 103 static const char *const scsi_device_types[] = { 104 "Direct-Access ", 105 "Sequential-Access", 106 "Printer ", 107 "Processor ", 108 "WORM ", 109 "CD-ROM ", 110 "Scanner ", 111 "Optical Device ", 112 "Medium Changer ", 113 "Communications ", 114 "ASC IT8 ", 115 "ASC IT8 ", 116 "RAID ", 117 "Enclosure ", 118 "Direct-Access-RBC", 119 "Optical card ", 120 "Bridge controller", 121 "Object storage ", 122 "Automation/Drive ", 123 }; 124 125 const char * scsi_device_type(unsigned type) 126 { 127 if (type == 0x1e) 128 return "Well-known LUN "; 129 if (type == 0x1f) 130 return "No Device "; 131 if (type >= ARRAY_SIZE(scsi_device_types)) 132 return "Unknown "; 133 return scsi_device_types[type]; 134 } 135 136 EXPORT_SYMBOL(scsi_device_type); 137 138 struct scsi_host_cmd_pool { 139 struct kmem_cache *slab; 140 unsigned int users; 141 char *name; 142 unsigned int slab_flags; 143 gfp_t gfp_mask; 144 }; 145 146 static struct scsi_host_cmd_pool scsi_cmd_pool = { 147 .name = "scsi_cmd_cache", 148 .slab_flags = SLAB_HWCACHE_ALIGN, 149 }; 150 151 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = { 152 .name = "scsi_cmd_cache(DMA)", 153 .slab_flags = SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA, 154 .gfp_mask = __GFP_DMA, 155 }; 156 157 static DEFINE_MUTEX(host_cmd_pool_mutex); 158 159 struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask) 160 { 161 struct scsi_cmnd *cmd; 162 163 cmd = kmem_cache_alloc(shost->cmd_pool->slab, 164 gfp_mask | shost->cmd_pool->gfp_mask); 165 166 if (unlikely(!cmd)) { 167 unsigned long flags; 168 169 spin_lock_irqsave(&shost->free_list_lock, flags); 170 if (likely(!list_empty(&shost->free_list))) { 171 cmd = list_entry(shost->free_list.next, 172 struct scsi_cmnd, list); 173 list_del_init(&cmd->list); 174 } 175 spin_unlock_irqrestore(&shost->free_list_lock, flags); 176 } 177 178 return cmd; 179 } 180 EXPORT_SYMBOL_GPL(__scsi_get_command); 181 182 /* 183 * Function: scsi_get_command() 184 * 185 * Purpose: Allocate and setup a scsi command block 186 * 187 * Arguments: dev - parent scsi device 188 * gfp_mask- allocator flags 189 * 190 * Returns: The allocated scsi command structure. 191 */ 192 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask) 193 { 194 struct scsi_cmnd *cmd; 195 196 /* Bail if we can't get a reference to the device */ 197 if (!get_device(&dev->sdev_gendev)) 198 return NULL; 199 200 cmd = __scsi_get_command(dev->host, gfp_mask); 201 202 if (likely(cmd != NULL)) { 203 unsigned long flags; 204 205 memset(cmd, 0, sizeof(*cmd)); 206 cmd->device = dev; 207 init_timer(&cmd->eh_timeout); 208 INIT_LIST_HEAD(&cmd->list); 209 spin_lock_irqsave(&dev->list_lock, flags); 210 list_add_tail(&cmd->list, &dev->cmd_list); 211 spin_unlock_irqrestore(&dev->list_lock, flags); 212 cmd->jiffies_at_alloc = jiffies; 213 } else 214 put_device(&dev->sdev_gendev); 215 216 return cmd; 217 } 218 EXPORT_SYMBOL(scsi_get_command); 219 220 void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd, 221 struct device *dev) 222 { 223 unsigned long flags; 224 225 /* changing locks here, don't need to restore the irq state */ 226 spin_lock_irqsave(&shost->free_list_lock, flags); 227 if (unlikely(list_empty(&shost->free_list))) { 228 list_add(&cmd->list, &shost->free_list); 229 cmd = NULL; 230 } 231 spin_unlock_irqrestore(&shost->free_list_lock, flags); 232 233 if (likely(cmd != NULL)) 234 kmem_cache_free(shost->cmd_pool->slab, cmd); 235 236 put_device(dev); 237 } 238 EXPORT_SYMBOL(__scsi_put_command); 239 240 /* 241 * Function: scsi_put_command() 242 * 243 * Purpose: Free a scsi command block 244 * 245 * Arguments: cmd - command block to free 246 * 247 * Returns: Nothing. 248 * 249 * Notes: The command must not belong to any lists. 250 */ 251 void scsi_put_command(struct scsi_cmnd *cmd) 252 { 253 struct scsi_device *sdev = cmd->device; 254 unsigned long flags; 255 256 /* serious error if the command hasn't come from a device list */ 257 spin_lock_irqsave(&cmd->device->list_lock, flags); 258 BUG_ON(list_empty(&cmd->list)); 259 list_del_init(&cmd->list); 260 spin_unlock_irqrestore(&cmd->device->list_lock, flags); 261 262 __scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev); 263 } 264 EXPORT_SYMBOL(scsi_put_command); 265 266 /* 267 * Function: scsi_setup_command_freelist() 268 * 269 * Purpose: Setup the command freelist for a scsi host. 270 * 271 * Arguments: shost - host to allocate the freelist for. 272 * 273 * Returns: Nothing. 274 */ 275 int scsi_setup_command_freelist(struct Scsi_Host *shost) 276 { 277 struct scsi_host_cmd_pool *pool; 278 struct scsi_cmnd *cmd; 279 280 spin_lock_init(&shost->free_list_lock); 281 INIT_LIST_HEAD(&shost->free_list); 282 283 /* 284 * Select a command slab for this host and create it if not 285 * yet existant. 286 */ 287 mutex_lock(&host_cmd_pool_mutex); 288 pool = (shost->unchecked_isa_dma ? &scsi_cmd_dma_pool : &scsi_cmd_pool); 289 if (!pool->users) { 290 pool->slab = kmem_cache_create(pool->name, 291 sizeof(struct scsi_cmnd), 0, 292 pool->slab_flags, NULL, NULL); 293 if (!pool->slab) 294 goto fail; 295 } 296 297 pool->users++; 298 shost->cmd_pool = pool; 299 mutex_unlock(&host_cmd_pool_mutex); 300 301 /* 302 * Get one backup command for this host. 303 */ 304 cmd = kmem_cache_alloc(shost->cmd_pool->slab, 305 GFP_KERNEL | shost->cmd_pool->gfp_mask); 306 if (!cmd) 307 goto fail2; 308 list_add(&cmd->list, &shost->free_list); 309 return 0; 310 311 fail2: 312 if (!--pool->users) 313 kmem_cache_destroy(pool->slab); 314 return -ENOMEM; 315 fail: 316 mutex_unlock(&host_cmd_pool_mutex); 317 return -ENOMEM; 318 319 } 320 321 /* 322 * Function: scsi_destroy_command_freelist() 323 * 324 * Purpose: Release the command freelist for a scsi host. 325 * 326 * Arguments: shost - host that's freelist is going to be destroyed 327 */ 328 void scsi_destroy_command_freelist(struct Scsi_Host *shost) 329 { 330 while (!list_empty(&shost->free_list)) { 331 struct scsi_cmnd *cmd; 332 333 cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list); 334 list_del_init(&cmd->list); 335 kmem_cache_free(shost->cmd_pool->slab, cmd); 336 } 337 338 mutex_lock(&host_cmd_pool_mutex); 339 if (!--shost->cmd_pool->users) 340 kmem_cache_destroy(shost->cmd_pool->slab); 341 mutex_unlock(&host_cmd_pool_mutex); 342 } 343 344 #ifdef CONFIG_SCSI_LOGGING 345 void scsi_log_send(struct scsi_cmnd *cmd) 346 { 347 unsigned int level; 348 struct scsi_device *sdev; 349 350 /* 351 * If ML QUEUE log level is greater than or equal to: 352 * 353 * 1: nothing (match completion) 354 * 355 * 2: log opcode + command of all commands 356 * 357 * 3: same as 2 plus dump cmd address 358 * 359 * 4: same as 3 plus dump extra junk 360 */ 361 if (unlikely(scsi_logging_level)) { 362 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT, 363 SCSI_LOG_MLQUEUE_BITS); 364 if (level > 1) { 365 sdev = cmd->device; 366 sdev_printk(KERN_INFO, sdev, "send "); 367 if (level > 2) 368 printk("0x%p ", cmd); 369 /* 370 * spaces to match disposition and cmd->result 371 * output in scsi_log_completion. 372 */ 373 printk(" "); 374 scsi_print_command(cmd); 375 if (level > 3) { 376 printk(KERN_INFO "buffer = 0x%p, bufflen = %d," 377 " done = 0x%p, queuecommand 0x%p\n", 378 cmd->request_buffer, cmd->request_bufflen, 379 cmd->done, 380 sdev->host->hostt->queuecommand); 381 382 } 383 } 384 } 385 } 386 387 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition) 388 { 389 unsigned int level; 390 struct scsi_device *sdev; 391 392 /* 393 * If ML COMPLETE log level is greater than or equal to: 394 * 395 * 1: log disposition, result, opcode + command, and conditionally 396 * sense data for failures or non SUCCESS dispositions. 397 * 398 * 2: same as 1 but for all command completions. 399 * 400 * 3: same as 2 plus dump cmd address 401 * 402 * 4: same as 3 plus dump extra junk 403 */ 404 if (unlikely(scsi_logging_level)) { 405 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT, 406 SCSI_LOG_MLCOMPLETE_BITS); 407 if (((level > 0) && (cmd->result || disposition != SUCCESS)) || 408 (level > 1)) { 409 sdev = cmd->device; 410 sdev_printk(KERN_INFO, sdev, "done "); 411 if (level > 2) 412 printk("0x%p ", cmd); 413 /* 414 * Dump truncated values, so we usually fit within 415 * 80 chars. 416 */ 417 switch (disposition) { 418 case SUCCESS: 419 printk("SUCCESS"); 420 break; 421 case NEEDS_RETRY: 422 printk("RETRY "); 423 break; 424 case ADD_TO_MLQUEUE: 425 printk("MLQUEUE"); 426 break; 427 case FAILED: 428 printk("FAILED "); 429 break; 430 case TIMEOUT_ERROR: 431 /* 432 * If called via scsi_times_out. 433 */ 434 printk("TIMEOUT"); 435 break; 436 default: 437 printk("UNKNOWN"); 438 } 439 printk(" %8x ", cmd->result); 440 scsi_print_command(cmd); 441 if (status_byte(cmd->result) & CHECK_CONDITION) { 442 /* 443 * XXX The scsi_print_sense formatting/prefix 444 * doesn't match this function. 445 */ 446 scsi_print_sense("", cmd); 447 } 448 if (level > 3) { 449 printk(KERN_INFO "scsi host busy %d failed %d\n", 450 sdev->host->host_busy, 451 sdev->host->host_failed); 452 } 453 } 454 } 455 } 456 #endif 457 458 /* 459 * Assign a serial number and pid to the request for error recovery 460 * and debugging purposes. Protected by the Host_Lock of host. 461 */ 462 static inline void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd) 463 { 464 cmd->serial_number = host->cmd_serial_number++; 465 if (cmd->serial_number == 0) 466 cmd->serial_number = host->cmd_serial_number++; 467 468 cmd->pid = host->cmd_pid++; 469 if (cmd->pid == 0) 470 cmd->pid = host->cmd_pid++; 471 } 472 473 /* 474 * Function: scsi_dispatch_command 475 * 476 * Purpose: Dispatch a command to the low-level driver. 477 * 478 * Arguments: cmd - command block we are dispatching. 479 * 480 * Notes: 481 */ 482 int scsi_dispatch_cmd(struct scsi_cmnd *cmd) 483 { 484 struct Scsi_Host *host = cmd->device->host; 485 unsigned long flags = 0; 486 unsigned long timeout; 487 int rtn = 0; 488 489 /* check if the device is still usable */ 490 if (unlikely(cmd->device->sdev_state == SDEV_DEL)) { 491 /* in SDEV_DEL we error all commands. DID_NO_CONNECT 492 * returns an immediate error upwards, and signals 493 * that the device is no longer present */ 494 cmd->result = DID_NO_CONNECT << 16; 495 atomic_inc(&cmd->device->iorequest_cnt); 496 __scsi_done(cmd); 497 /* return 0 (because the command has been processed) */ 498 goto out; 499 } 500 501 /* Check to see if the scsi lld put this device into state SDEV_BLOCK. */ 502 if (unlikely(cmd->device->sdev_state == SDEV_BLOCK)) { 503 /* 504 * in SDEV_BLOCK, the command is just put back on the device 505 * queue. The suspend state has already blocked the queue so 506 * future requests should not occur until the device 507 * transitions out of the suspend state. 508 */ 509 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY); 510 511 SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n")); 512 513 /* 514 * NOTE: rtn is still zero here because we don't need the 515 * queue to be plugged on return (it's already stopped) 516 */ 517 goto out; 518 } 519 520 /* 521 * If SCSI-2 or lower, store the LUN value in cmnd. 522 */ 523 if (cmd->device->scsi_level <= SCSI_2 && 524 cmd->device->scsi_level != SCSI_UNKNOWN) { 525 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) | 526 (cmd->device->lun << 5 & 0xe0); 527 } 528 529 /* 530 * We will wait MIN_RESET_DELAY clock ticks after the last reset so 531 * we can avoid the drive not being ready. 532 */ 533 timeout = host->last_reset + MIN_RESET_DELAY; 534 535 if (host->resetting && time_before(jiffies, timeout)) { 536 int ticks_remaining = timeout - jiffies; 537 /* 538 * NOTE: This may be executed from within an interrupt 539 * handler! This is bad, but for now, it'll do. The irq 540 * level of the interrupt handler has been masked out by the 541 * platform dependent interrupt handling code already, so the 542 * sti() here will not cause another call to the SCSI host's 543 * interrupt handler (assuming there is one irq-level per 544 * host). 545 */ 546 while (--ticks_remaining >= 0) 547 mdelay(1 + 999 / HZ); 548 host->resetting = 0; 549 } 550 551 /* 552 * AK: unlikely race here: for some reason the timer could 553 * expire before the serial number is set up below. 554 */ 555 scsi_add_timer(cmd, cmd->timeout_per_command, scsi_times_out); 556 557 scsi_log_send(cmd); 558 559 /* 560 * We will use a queued command if possible, otherwise we will 561 * emulate the queuing and calling of completion function ourselves. 562 */ 563 atomic_inc(&cmd->device->iorequest_cnt); 564 565 /* 566 * Before we queue this command, check if the command 567 * length exceeds what the host adapter can handle. 568 */ 569 if (CDB_SIZE(cmd) > cmd->device->host->max_cmd_len) { 570 SCSI_LOG_MLQUEUE(3, 571 printk("queuecommand : command too long.\n")); 572 cmd->result = (DID_ABORT << 16); 573 574 scsi_done(cmd); 575 goto out; 576 } 577 578 spin_lock_irqsave(host->host_lock, flags); 579 scsi_cmd_get_serial(host, cmd); 580 581 if (unlikely(host->shost_state == SHOST_DEL)) { 582 cmd->result = (DID_NO_CONNECT << 16); 583 scsi_done(cmd); 584 } else { 585 rtn = host->hostt->queuecommand(cmd, scsi_done); 586 } 587 spin_unlock_irqrestore(host->host_lock, flags); 588 if (rtn) { 589 if (scsi_delete_timer(cmd)) { 590 atomic_inc(&cmd->device->iodone_cnt); 591 scsi_queue_insert(cmd, 592 (rtn == SCSI_MLQUEUE_DEVICE_BUSY) ? 593 rtn : SCSI_MLQUEUE_HOST_BUSY); 594 } 595 SCSI_LOG_MLQUEUE(3, 596 printk("queuecommand : request rejected\n")); 597 } 598 599 out: 600 SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n")); 601 return rtn; 602 } 603 604 /** 605 * scsi_req_abort_cmd -- Request command recovery for the specified command 606 * cmd: pointer to the SCSI command of interest 607 * 608 * This function requests that SCSI Core start recovery for the 609 * command by deleting the timer and adding the command to the eh 610 * queue. It can be called by either LLDDs or SCSI Core. LLDDs who 611 * implement their own error recovery MAY ignore the timeout event if 612 * they generated scsi_req_abort_cmd. 613 */ 614 void scsi_req_abort_cmd(struct scsi_cmnd *cmd) 615 { 616 if (!scsi_delete_timer(cmd)) 617 return; 618 scsi_times_out(cmd); 619 } 620 EXPORT_SYMBOL(scsi_req_abort_cmd); 621 622 /** 623 * scsi_done - Enqueue the finished SCSI command into the done queue. 624 * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives 625 * ownership back to SCSI Core -- i.e. the LLDD has finished with it. 626 * 627 * This function is the mid-level's (SCSI Core) interrupt routine, which 628 * regains ownership of the SCSI command (de facto) from a LLDD, and enqueues 629 * the command to the done queue for further processing. 630 * 631 * This is the producer of the done queue who enqueues at the tail. 632 * 633 * This function is interrupt context safe. 634 */ 635 static void scsi_done(struct scsi_cmnd *cmd) 636 { 637 /* 638 * We don't have to worry about this one timing out any more. 639 * If we are unable to remove the timer, then the command 640 * has already timed out. In which case, we have no choice but to 641 * let the timeout function run, as we have no idea where in fact 642 * that function could really be. It might be on another processor, 643 * etc, etc. 644 */ 645 if (!scsi_delete_timer(cmd)) 646 return; 647 __scsi_done(cmd); 648 } 649 650 /* Private entry to scsi_done() to complete a command when the timer 651 * isn't running --- used by scsi_times_out */ 652 void __scsi_done(struct scsi_cmnd *cmd) 653 { 654 struct request *rq = cmd->request; 655 656 /* 657 * Set the serial numbers back to zero 658 */ 659 cmd->serial_number = 0; 660 661 atomic_inc(&cmd->device->iodone_cnt); 662 if (cmd->result) 663 atomic_inc(&cmd->device->ioerr_cnt); 664 665 BUG_ON(!rq); 666 667 /* 668 * The uptodate/nbytes values don't matter, as we allow partial 669 * completes and thus will check this in the softirq callback 670 */ 671 rq->completion_data = cmd; 672 blk_complete_request(rq); 673 } 674 675 /* 676 * Function: scsi_retry_command 677 * 678 * Purpose: Send a command back to the low level to be retried. 679 * 680 * Notes: This command is always executed in the context of the 681 * bottom half handler, or the error handler thread. Low 682 * level drivers should not become re-entrant as a result of 683 * this. 684 */ 685 int scsi_retry_command(struct scsi_cmnd *cmd) 686 { 687 /* 688 * Zero the sense information from the last time we tried 689 * this command. 690 */ 691 memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer)); 692 693 return scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY); 694 } 695 696 /* 697 * Function: scsi_finish_command 698 * 699 * Purpose: Pass command off to upper layer for finishing of I/O 700 * request, waking processes that are waiting on results, 701 * etc. 702 */ 703 void scsi_finish_command(struct scsi_cmnd *cmd) 704 { 705 struct scsi_device *sdev = cmd->device; 706 struct Scsi_Host *shost = sdev->host; 707 708 scsi_device_unbusy(sdev); 709 710 /* 711 * Clear the flags which say that the device/host is no longer 712 * capable of accepting new commands. These are set in scsi_queue.c 713 * for both the queue full condition on a device, and for a 714 * host full condition on the host. 715 * 716 * XXX(hch): What about locking? 717 */ 718 shost->host_blocked = 0; 719 sdev->device_blocked = 0; 720 721 /* 722 * If we have valid sense information, then some kind of recovery 723 * must have taken place. Make a note of this. 724 */ 725 if (SCSI_SENSE_VALID(cmd)) 726 cmd->result |= (DRIVER_SENSE << 24); 727 728 SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev, 729 "Notifying upper driver of completion " 730 "(result %x)\n", cmd->result)); 731 732 cmd->done(cmd); 733 } 734 EXPORT_SYMBOL(scsi_finish_command); 735 736 /* 737 * Function: scsi_adjust_queue_depth() 738 * 739 * Purpose: Allow low level drivers to tell us to change the queue depth 740 * on a specific SCSI device 741 * 742 * Arguments: sdev - SCSI Device in question 743 * tagged - Do we use tagged queueing (non-0) or do we treat 744 * this device as an untagged device (0) 745 * tags - Number of tags allowed if tagged queueing enabled, 746 * or number of commands the low level driver can 747 * queue up in non-tagged mode (as per cmd_per_lun). 748 * 749 * Returns: Nothing 750 * 751 * Lock Status: None held on entry 752 * 753 * Notes: Low level drivers may call this at any time and we will do 754 * the right thing depending on whether or not the device is 755 * currently active and whether or not it even has the 756 * command blocks built yet. 757 */ 758 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags) 759 { 760 unsigned long flags; 761 762 /* 763 * refuse to set tagged depth to an unworkable size 764 */ 765 if (tags <= 0) 766 return; 767 768 spin_lock_irqsave(sdev->request_queue->queue_lock, flags); 769 770 /* Check to see if the queue is managed by the block layer 771 * if it is, and we fail to adjust the depth, exit */ 772 if (blk_queue_tagged(sdev->request_queue) && 773 blk_queue_resize_tags(sdev->request_queue, tags) != 0) 774 goto out; 775 776 sdev->queue_depth = tags; 777 switch (tagged) { 778 case MSG_ORDERED_TAG: 779 sdev->ordered_tags = 1; 780 sdev->simple_tags = 1; 781 break; 782 case MSG_SIMPLE_TAG: 783 sdev->ordered_tags = 0; 784 sdev->simple_tags = 1; 785 break; 786 default: 787 sdev_printk(KERN_WARNING, sdev, 788 "scsi_adjust_queue_depth, bad queue type, " 789 "disabled\n"); 790 case 0: 791 sdev->ordered_tags = sdev->simple_tags = 0; 792 sdev->queue_depth = tags; 793 break; 794 } 795 out: 796 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags); 797 } 798 EXPORT_SYMBOL(scsi_adjust_queue_depth); 799 800 /* 801 * Function: scsi_track_queue_full() 802 * 803 * Purpose: This function will track successive QUEUE_FULL events on a 804 * specific SCSI device to determine if and when there is a 805 * need to adjust the queue depth on the device. 806 * 807 * Arguments: sdev - SCSI Device in question 808 * depth - Current number of outstanding SCSI commands on 809 * this device, not counting the one returned as 810 * QUEUE_FULL. 811 * 812 * Returns: 0 - No change needed 813 * >0 - Adjust queue depth to this new depth 814 * -1 - Drop back to untagged operation using host->cmd_per_lun 815 * as the untagged command depth 816 * 817 * Lock Status: None held on entry 818 * 819 * Notes: Low level drivers may call this at any time and we will do 820 * "The Right Thing." We are interrupt context safe. 821 */ 822 int scsi_track_queue_full(struct scsi_device *sdev, int depth) 823 { 824 if ((jiffies >> 4) == sdev->last_queue_full_time) 825 return 0; 826 827 sdev->last_queue_full_time = (jiffies >> 4); 828 if (sdev->last_queue_full_depth != depth) { 829 sdev->last_queue_full_count = 1; 830 sdev->last_queue_full_depth = depth; 831 } else { 832 sdev->last_queue_full_count++; 833 } 834 835 if (sdev->last_queue_full_count <= 10) 836 return 0; 837 if (sdev->last_queue_full_depth < 8) { 838 /* Drop back to untagged */ 839 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun); 840 return -1; 841 } 842 843 if (sdev->ordered_tags) 844 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth); 845 else 846 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth); 847 return depth; 848 } 849 EXPORT_SYMBOL(scsi_track_queue_full); 850 851 /** 852 * scsi_device_get - get an addition reference to a scsi_device 853 * @sdev: device to get a reference to 854 * 855 * Gets a reference to the scsi_device and increments the use count 856 * of the underlying LLDD module. You must hold host_lock of the 857 * parent Scsi_Host or already have a reference when calling this. 858 */ 859 int scsi_device_get(struct scsi_device *sdev) 860 { 861 if (sdev->sdev_state == SDEV_DEL) 862 return -ENXIO; 863 if (!get_device(&sdev->sdev_gendev)) 864 return -ENXIO; 865 /* We can fail this if we're doing SCSI operations 866 * from module exit (like cache flush) */ 867 try_module_get(sdev->host->hostt->module); 868 869 return 0; 870 } 871 EXPORT_SYMBOL(scsi_device_get); 872 873 /** 874 * scsi_device_put - release a reference to a scsi_device 875 * @sdev: device to release a reference on. 876 * 877 * Release a reference to the scsi_device and decrements the use count 878 * of the underlying LLDD module. The device is freed once the last 879 * user vanishes. 880 */ 881 void scsi_device_put(struct scsi_device *sdev) 882 { 883 #ifdef CONFIG_MODULE_UNLOAD 884 struct module *module = sdev->host->hostt->module; 885 886 /* The module refcount will be zero if scsi_device_get() 887 * was called from a module removal routine */ 888 if (module && module_refcount(module) != 0) 889 module_put(module); 890 #endif 891 put_device(&sdev->sdev_gendev); 892 } 893 EXPORT_SYMBOL(scsi_device_put); 894 895 /* helper for shost_for_each_device, thus not documented */ 896 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost, 897 struct scsi_device *prev) 898 { 899 struct list_head *list = (prev ? &prev->siblings : &shost->__devices); 900 struct scsi_device *next = NULL; 901 unsigned long flags; 902 903 spin_lock_irqsave(shost->host_lock, flags); 904 while (list->next != &shost->__devices) { 905 next = list_entry(list->next, struct scsi_device, siblings); 906 /* skip devices that we can't get a reference to */ 907 if (!scsi_device_get(next)) 908 break; 909 next = NULL; 910 list = list->next; 911 } 912 spin_unlock_irqrestore(shost->host_lock, flags); 913 914 if (prev) 915 scsi_device_put(prev); 916 return next; 917 } 918 EXPORT_SYMBOL(__scsi_iterate_devices); 919 920 /** 921 * starget_for_each_device - helper to walk all devices of a target 922 * @starget: target whose devices we want to iterate over. 923 * 924 * This traverses over each devices of @shost. The devices have 925 * a reference that must be released by scsi_host_put when breaking 926 * out of the loop. 927 */ 928 void starget_for_each_device(struct scsi_target *starget, void * data, 929 void (*fn)(struct scsi_device *, void *)) 930 { 931 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 932 struct scsi_device *sdev; 933 934 shost_for_each_device(sdev, shost) { 935 if ((sdev->channel == starget->channel) && 936 (sdev->id == starget->id)) 937 fn(sdev, data); 938 } 939 } 940 EXPORT_SYMBOL(starget_for_each_device); 941 942 /** 943 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED) 944 * @starget: SCSI target pointer 945 * @lun: SCSI Logical Unit Number 946 * 947 * Looks up the scsi_device with the specified @lun for a give 948 * @starget. The returned scsi_device does not have an additional 949 * reference. You must hold the host's host_lock over this call and 950 * any access to the returned scsi_device. 951 * 952 * Note: The only reason why drivers would want to use this is because 953 * they're need to access the device list in irq context. Otherwise you 954 * really want to use scsi_device_lookup_by_target instead. 955 **/ 956 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget, 957 uint lun) 958 { 959 struct scsi_device *sdev; 960 961 list_for_each_entry(sdev, &starget->devices, same_target_siblings) { 962 if (sdev->lun ==lun) 963 return sdev; 964 } 965 966 return NULL; 967 } 968 EXPORT_SYMBOL(__scsi_device_lookup_by_target); 969 970 /** 971 * scsi_device_lookup_by_target - find a device given the target 972 * @starget: SCSI target pointer 973 * @lun: SCSI Logical Unit Number 974 * 975 * Looks up the scsi_device with the specified @channel, @id, @lun for a 976 * give host. The returned scsi_device has an additional reference that 977 * needs to be release with scsi_host_put once you're done with it. 978 **/ 979 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget, 980 uint lun) 981 { 982 struct scsi_device *sdev; 983 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 984 unsigned long flags; 985 986 spin_lock_irqsave(shost->host_lock, flags); 987 sdev = __scsi_device_lookup_by_target(starget, lun); 988 if (sdev && scsi_device_get(sdev)) 989 sdev = NULL; 990 spin_unlock_irqrestore(shost->host_lock, flags); 991 992 return sdev; 993 } 994 EXPORT_SYMBOL(scsi_device_lookup_by_target); 995 996 /** 997 * scsi_device_lookup - find a device given the host (UNLOCKED) 998 * @shost: SCSI host pointer 999 * @channel: SCSI channel (zero if only one channel) 1000 * @pun: SCSI target number (physical unit number) 1001 * @lun: SCSI Logical Unit Number 1002 * 1003 * Looks up the scsi_device with the specified @channel, @id, @lun for a 1004 * give host. The returned scsi_device does not have an additional reference. 1005 * You must hold the host's host_lock over this call and any access to the 1006 * returned scsi_device. 1007 * 1008 * Note: The only reason why drivers would want to use this is because 1009 * they're need to access the device list in irq context. Otherwise you 1010 * really want to use scsi_device_lookup instead. 1011 **/ 1012 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost, 1013 uint channel, uint id, uint lun) 1014 { 1015 struct scsi_device *sdev; 1016 1017 list_for_each_entry(sdev, &shost->__devices, siblings) { 1018 if (sdev->channel == channel && sdev->id == id && 1019 sdev->lun ==lun) 1020 return sdev; 1021 } 1022 1023 return NULL; 1024 } 1025 EXPORT_SYMBOL(__scsi_device_lookup); 1026 1027 /** 1028 * scsi_device_lookup - find a device given the host 1029 * @shost: SCSI host pointer 1030 * @channel: SCSI channel (zero if only one channel) 1031 * @id: SCSI target number (physical unit number) 1032 * @lun: SCSI Logical Unit Number 1033 * 1034 * Looks up the scsi_device with the specified @channel, @id, @lun for a 1035 * give host. The returned scsi_device has an additional reference that 1036 * needs to be release with scsi_host_put once you're done with it. 1037 **/ 1038 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost, 1039 uint channel, uint id, uint lun) 1040 { 1041 struct scsi_device *sdev; 1042 unsigned long flags; 1043 1044 spin_lock_irqsave(shost->host_lock, flags); 1045 sdev = __scsi_device_lookup(shost, channel, id, lun); 1046 if (sdev && scsi_device_get(sdev)) 1047 sdev = NULL; 1048 spin_unlock_irqrestore(shost->host_lock, flags); 1049 1050 return sdev; 1051 } 1052 EXPORT_SYMBOL(scsi_device_lookup); 1053 1054 /** 1055 * scsi_device_cancel - cancel outstanding IO to this device 1056 * @sdev: Pointer to struct scsi_device 1057 * @recovery: Boolean instructing function to recover device or not. 1058 * 1059 **/ 1060 int scsi_device_cancel(struct scsi_device *sdev, int recovery) 1061 { 1062 struct scsi_cmnd *scmd; 1063 LIST_HEAD(active_list); 1064 struct list_head *lh, *lh_sf; 1065 unsigned long flags; 1066 1067 scsi_device_set_state(sdev, SDEV_CANCEL); 1068 1069 spin_lock_irqsave(&sdev->list_lock, flags); 1070 list_for_each_entry(scmd, &sdev->cmd_list, list) { 1071 if (scmd->request) { 1072 /* 1073 * If we are unable to remove the timer, it means 1074 * that the command has already timed out or 1075 * finished. 1076 */ 1077 if (!scsi_delete_timer(scmd)) 1078 continue; 1079 list_add_tail(&scmd->eh_entry, &active_list); 1080 } 1081 } 1082 spin_unlock_irqrestore(&sdev->list_lock, flags); 1083 1084 if (!list_empty(&active_list)) { 1085 list_for_each_safe(lh, lh_sf, &active_list) { 1086 scmd = list_entry(lh, struct scsi_cmnd, eh_entry); 1087 list_del_init(lh); 1088 if (recovery && 1089 !scsi_eh_scmd_add(scmd, SCSI_EH_CANCEL_CMD)) { 1090 scmd->result = (DID_ABORT << 16); 1091 scsi_finish_command(scmd); 1092 } 1093 } 1094 } 1095 1096 return 0; 1097 } 1098 EXPORT_SYMBOL(scsi_device_cancel); 1099 1100 MODULE_DESCRIPTION("SCSI core"); 1101 MODULE_LICENSE("GPL"); 1102 1103 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR); 1104 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels"); 1105 1106 static int __init init_scsi(void) 1107 { 1108 int error; 1109 1110 error = scsi_init_queue(); 1111 if (error) 1112 return error; 1113 error = scsi_init_procfs(); 1114 if (error) 1115 goto cleanup_queue; 1116 error = scsi_init_devinfo(); 1117 if (error) 1118 goto cleanup_procfs; 1119 error = scsi_init_hosts(); 1120 if (error) 1121 goto cleanup_devlist; 1122 error = scsi_init_sysctl(); 1123 if (error) 1124 goto cleanup_hosts; 1125 error = scsi_sysfs_register(); 1126 if (error) 1127 goto cleanup_sysctl; 1128 1129 scsi_netlink_init(); 1130 1131 printk(KERN_NOTICE "SCSI subsystem initialized\n"); 1132 return 0; 1133 1134 cleanup_sysctl: 1135 scsi_exit_sysctl(); 1136 cleanup_hosts: 1137 scsi_exit_hosts(); 1138 cleanup_devlist: 1139 scsi_exit_devinfo(); 1140 cleanup_procfs: 1141 scsi_exit_procfs(); 1142 cleanup_queue: 1143 scsi_exit_queue(); 1144 printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n", 1145 -error); 1146 return error; 1147 } 1148 1149 static void __exit exit_scsi(void) 1150 { 1151 scsi_netlink_exit(); 1152 scsi_sysfs_unregister(); 1153 scsi_exit_sysctl(); 1154 scsi_exit_hosts(); 1155 scsi_exit_devinfo(); 1156 scsi_exit_procfs(); 1157 scsi_exit_queue(); 1158 } 1159 1160 subsys_initcall(init_scsi); 1161 module_exit(exit_scsi); 1162