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