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_driver.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); 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 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 scmd_printk(KERN_INFO, cmd, "Send: "); 365 if (level > 2) 366 printk("0x%p ", cmd); 367 printk("\n"); 368 scsi_print_command(cmd); 369 if (level > 3) { 370 printk(KERN_INFO "buffer = 0x%p, bufflen = %d," 371 " queuecommand 0x%p\n", 372 scsi_sglist(cmd), scsi_bufflen(cmd), 373 cmd->device->host->hostt->queuecommand); 374 375 } 376 } 377 } 378 } 379 380 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition) 381 { 382 unsigned int level; 383 384 /* 385 * If ML COMPLETE log level is greater than or equal to: 386 * 387 * 1: log disposition, result, opcode + command, and conditionally 388 * sense data for failures or non SUCCESS dispositions. 389 * 390 * 2: same as 1 but for all command completions. 391 * 392 * 3: same as 2 plus dump cmd address 393 * 394 * 4: same as 3 plus dump extra junk 395 */ 396 if (unlikely(scsi_logging_level)) { 397 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT, 398 SCSI_LOG_MLCOMPLETE_BITS); 399 if (((level > 0) && (cmd->result || disposition != SUCCESS)) || 400 (level > 1)) { 401 scmd_printk(KERN_INFO, cmd, "Done: "); 402 if (level > 2) 403 printk("0x%p ", cmd); 404 /* 405 * Dump truncated values, so we usually fit within 406 * 80 chars. 407 */ 408 switch (disposition) { 409 case SUCCESS: 410 printk("SUCCESS\n"); 411 break; 412 case NEEDS_RETRY: 413 printk("RETRY\n"); 414 break; 415 case ADD_TO_MLQUEUE: 416 printk("MLQUEUE\n"); 417 break; 418 case FAILED: 419 printk("FAILED\n"); 420 break; 421 case TIMEOUT_ERROR: 422 /* 423 * If called via scsi_times_out. 424 */ 425 printk("TIMEOUT\n"); 426 break; 427 default: 428 printk("UNKNOWN\n"); 429 } 430 scsi_print_result(cmd); 431 scsi_print_command(cmd); 432 if (status_byte(cmd->result) & CHECK_CONDITION) 433 scsi_print_sense("", cmd); 434 if (level > 3) 435 scmd_printk(KERN_INFO, cmd, 436 "scsi host busy %d failed %d\n", 437 cmd->device->host->host_busy, 438 cmd->device->host->host_failed); 439 } 440 } 441 } 442 #endif 443 444 /* 445 * Assign a serial number to the request for error recovery 446 * and debugging purposes. Protected by the Host_Lock of host. 447 */ 448 static inline void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd) 449 { 450 cmd->serial_number = host->cmd_serial_number++; 451 if (cmd->serial_number == 0) 452 cmd->serial_number = host->cmd_serial_number++; 453 } 454 455 /* 456 * Function: scsi_dispatch_command 457 * 458 * Purpose: Dispatch a command to the low-level driver. 459 * 460 * Arguments: cmd - command block we are dispatching. 461 * 462 * Notes: 463 */ 464 int scsi_dispatch_cmd(struct scsi_cmnd *cmd) 465 { 466 struct Scsi_Host *host = cmd->device->host; 467 unsigned long flags = 0; 468 unsigned long timeout; 469 int rtn = 0; 470 471 /* check if the device is still usable */ 472 if (unlikely(cmd->device->sdev_state == SDEV_DEL)) { 473 /* in SDEV_DEL we error all commands. DID_NO_CONNECT 474 * returns an immediate error upwards, and signals 475 * that the device is no longer present */ 476 cmd->result = DID_NO_CONNECT << 16; 477 atomic_inc(&cmd->device->iorequest_cnt); 478 __scsi_done(cmd); 479 /* return 0 (because the command has been processed) */ 480 goto out; 481 } 482 483 /* Check to see if the scsi lld put this device into state SDEV_BLOCK. */ 484 if (unlikely(cmd->device->sdev_state == SDEV_BLOCK)) { 485 /* 486 * in SDEV_BLOCK, the command is just put back on the device 487 * queue. The suspend state has already blocked the queue so 488 * future requests should not occur until the device 489 * transitions out of the suspend state. 490 */ 491 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY); 492 493 SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n")); 494 495 /* 496 * NOTE: rtn is still zero here because we don't need the 497 * queue to be plugged on return (it's already stopped) 498 */ 499 goto out; 500 } 501 502 /* 503 * If SCSI-2 or lower, store the LUN value in cmnd. 504 */ 505 if (cmd->device->scsi_level <= SCSI_2 && 506 cmd->device->scsi_level != SCSI_UNKNOWN) { 507 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) | 508 (cmd->device->lun << 5 & 0xe0); 509 } 510 511 /* 512 * We will wait MIN_RESET_DELAY clock ticks after the last reset so 513 * we can avoid the drive not being ready. 514 */ 515 timeout = host->last_reset + MIN_RESET_DELAY; 516 517 if (host->resetting && time_before(jiffies, timeout)) { 518 int ticks_remaining = timeout - jiffies; 519 /* 520 * NOTE: This may be executed from within an interrupt 521 * handler! This is bad, but for now, it'll do. The irq 522 * level of the interrupt handler has been masked out by the 523 * platform dependent interrupt handling code already, so the 524 * sti() here will not cause another call to the SCSI host's 525 * interrupt handler (assuming there is one irq-level per 526 * host). 527 */ 528 while (--ticks_remaining >= 0) 529 mdelay(1 + 999 / HZ); 530 host->resetting = 0; 531 } 532 533 /* 534 * AK: unlikely race here: for some reason the timer could 535 * expire before the serial number is set up below. 536 */ 537 scsi_add_timer(cmd, cmd->timeout_per_command, scsi_times_out); 538 539 scsi_log_send(cmd); 540 541 /* 542 * We will use a queued command if possible, otherwise we will 543 * emulate the queuing and calling of completion function ourselves. 544 */ 545 atomic_inc(&cmd->device->iorequest_cnt); 546 547 /* 548 * Before we queue this command, check if the command 549 * length exceeds what the host adapter can handle. 550 */ 551 if (CDB_SIZE(cmd) > cmd->device->host->max_cmd_len) { 552 SCSI_LOG_MLQUEUE(3, 553 printk("queuecommand : command too long.\n")); 554 cmd->result = (DID_ABORT << 16); 555 556 scsi_done(cmd); 557 goto out; 558 } 559 560 spin_lock_irqsave(host->host_lock, flags); 561 scsi_cmd_get_serial(host, cmd); 562 563 if (unlikely(host->shost_state == SHOST_DEL)) { 564 cmd->result = (DID_NO_CONNECT << 16); 565 scsi_done(cmd); 566 } else { 567 rtn = host->hostt->queuecommand(cmd, scsi_done); 568 } 569 spin_unlock_irqrestore(host->host_lock, flags); 570 if (rtn) { 571 if (scsi_delete_timer(cmd)) { 572 atomic_inc(&cmd->device->iodone_cnt); 573 scsi_queue_insert(cmd, 574 (rtn == SCSI_MLQUEUE_DEVICE_BUSY) ? 575 rtn : SCSI_MLQUEUE_HOST_BUSY); 576 } 577 SCSI_LOG_MLQUEUE(3, 578 printk("queuecommand : request rejected\n")); 579 } 580 581 out: 582 SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n")); 583 return rtn; 584 } 585 586 /** 587 * scsi_req_abort_cmd -- Request command recovery for the specified command 588 * cmd: pointer to the SCSI command of interest 589 * 590 * This function requests that SCSI Core start recovery for the 591 * command by deleting the timer and adding the command to the eh 592 * queue. It can be called by either LLDDs or SCSI Core. LLDDs who 593 * implement their own error recovery MAY ignore the timeout event if 594 * they generated scsi_req_abort_cmd. 595 */ 596 void scsi_req_abort_cmd(struct scsi_cmnd *cmd) 597 { 598 if (!scsi_delete_timer(cmd)) 599 return; 600 scsi_times_out(cmd); 601 } 602 EXPORT_SYMBOL(scsi_req_abort_cmd); 603 604 /** 605 * scsi_done - Enqueue the finished SCSI command into the done queue. 606 * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives 607 * ownership back to SCSI Core -- i.e. the LLDD has finished with it. 608 * 609 * This function is the mid-level's (SCSI Core) interrupt routine, which 610 * regains ownership of the SCSI command (de facto) from a LLDD, and enqueues 611 * the command to the done queue for further processing. 612 * 613 * This is the producer of the done queue who enqueues at the tail. 614 * 615 * This function is interrupt context safe. 616 */ 617 static void scsi_done(struct scsi_cmnd *cmd) 618 { 619 /* 620 * We don't have to worry about this one timing out any more. 621 * If we are unable to remove the timer, then the command 622 * has already timed out. In which case, we have no choice but to 623 * let the timeout function run, as we have no idea where in fact 624 * that function could really be. It might be on another processor, 625 * etc, etc. 626 */ 627 if (!scsi_delete_timer(cmd)) 628 return; 629 __scsi_done(cmd); 630 } 631 632 /* Private entry to scsi_done() to complete a command when the timer 633 * isn't running --- used by scsi_times_out */ 634 void __scsi_done(struct scsi_cmnd *cmd) 635 { 636 struct request *rq = cmd->request; 637 638 /* 639 * Set the serial numbers back to zero 640 */ 641 cmd->serial_number = 0; 642 643 atomic_inc(&cmd->device->iodone_cnt); 644 if (cmd->result) 645 atomic_inc(&cmd->device->ioerr_cnt); 646 647 BUG_ON(!rq); 648 649 /* 650 * The uptodate/nbytes values don't matter, as we allow partial 651 * completes and thus will check this in the softirq callback 652 */ 653 rq->completion_data = cmd; 654 blk_complete_request(rq); 655 } 656 657 /* Move this to a header if it becomes more generally useful */ 658 static struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd) 659 { 660 return *(struct scsi_driver **)cmd->request->rq_disk->private_data; 661 } 662 663 /* 664 * Function: scsi_finish_command 665 * 666 * Purpose: Pass command off to upper layer for finishing of I/O 667 * request, waking processes that are waiting on results, 668 * etc. 669 */ 670 void scsi_finish_command(struct scsi_cmnd *cmd) 671 { 672 struct scsi_device *sdev = cmd->device; 673 struct Scsi_Host *shost = sdev->host; 674 struct scsi_driver *drv; 675 unsigned int good_bytes; 676 677 scsi_device_unbusy(sdev); 678 679 /* 680 * Clear the flags which say that the device/host is no longer 681 * capable of accepting new commands. These are set in scsi_queue.c 682 * for both the queue full condition on a device, and for a 683 * host full condition on the host. 684 * 685 * XXX(hch): What about locking? 686 */ 687 shost->host_blocked = 0; 688 sdev->device_blocked = 0; 689 690 /* 691 * If we have valid sense information, then some kind of recovery 692 * must have taken place. Make a note of this. 693 */ 694 if (SCSI_SENSE_VALID(cmd)) 695 cmd->result |= (DRIVER_SENSE << 24); 696 697 SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev, 698 "Notifying upper driver of completion " 699 "(result %x)\n", cmd->result)); 700 701 good_bytes = cmd->request_bufflen; 702 if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) { 703 drv = scsi_cmd_to_driver(cmd); 704 if (drv->done) 705 good_bytes = drv->done(cmd); 706 } 707 scsi_io_completion(cmd, good_bytes); 708 } 709 EXPORT_SYMBOL(scsi_finish_command); 710 711 /* 712 * Function: scsi_adjust_queue_depth() 713 * 714 * Purpose: Allow low level drivers to tell us to change the queue depth 715 * on a specific SCSI device 716 * 717 * Arguments: sdev - SCSI Device in question 718 * tagged - Do we use tagged queueing (non-0) or do we treat 719 * this device as an untagged device (0) 720 * tags - Number of tags allowed if tagged queueing enabled, 721 * or number of commands the low level driver can 722 * queue up in non-tagged mode (as per cmd_per_lun). 723 * 724 * Returns: Nothing 725 * 726 * Lock Status: None held on entry 727 * 728 * Notes: Low level drivers may call this at any time and we will do 729 * the right thing depending on whether or not the device is 730 * currently active and whether or not it even has the 731 * command blocks built yet. 732 */ 733 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags) 734 { 735 unsigned long flags; 736 737 /* 738 * refuse to set tagged depth to an unworkable size 739 */ 740 if (tags <= 0) 741 return; 742 743 spin_lock_irqsave(sdev->request_queue->queue_lock, flags); 744 745 /* Check to see if the queue is managed by the block layer 746 * if it is, and we fail to adjust the depth, exit */ 747 if (blk_queue_tagged(sdev->request_queue) && 748 blk_queue_resize_tags(sdev->request_queue, tags) != 0) 749 goto out; 750 751 sdev->queue_depth = tags; 752 switch (tagged) { 753 case MSG_ORDERED_TAG: 754 sdev->ordered_tags = 1; 755 sdev->simple_tags = 1; 756 break; 757 case MSG_SIMPLE_TAG: 758 sdev->ordered_tags = 0; 759 sdev->simple_tags = 1; 760 break; 761 default: 762 sdev_printk(KERN_WARNING, sdev, 763 "scsi_adjust_queue_depth, bad queue type, " 764 "disabled\n"); 765 case 0: 766 sdev->ordered_tags = sdev->simple_tags = 0; 767 sdev->queue_depth = tags; 768 break; 769 } 770 out: 771 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags); 772 } 773 EXPORT_SYMBOL(scsi_adjust_queue_depth); 774 775 /* 776 * Function: scsi_track_queue_full() 777 * 778 * Purpose: This function will track successive QUEUE_FULL events on a 779 * specific SCSI device to determine if and when there is a 780 * need to adjust the queue depth on the device. 781 * 782 * Arguments: sdev - SCSI Device in question 783 * depth - Current number of outstanding SCSI commands on 784 * this device, not counting the one returned as 785 * QUEUE_FULL. 786 * 787 * Returns: 0 - No change needed 788 * >0 - Adjust queue depth to this new depth 789 * -1 - Drop back to untagged operation using host->cmd_per_lun 790 * as the untagged command depth 791 * 792 * Lock Status: None held on entry 793 * 794 * Notes: Low level drivers may call this at any time and we will do 795 * "The Right Thing." We are interrupt context safe. 796 */ 797 int scsi_track_queue_full(struct scsi_device *sdev, int depth) 798 { 799 if ((jiffies >> 4) == sdev->last_queue_full_time) 800 return 0; 801 802 sdev->last_queue_full_time = (jiffies >> 4); 803 if (sdev->last_queue_full_depth != depth) { 804 sdev->last_queue_full_count = 1; 805 sdev->last_queue_full_depth = depth; 806 } else { 807 sdev->last_queue_full_count++; 808 } 809 810 if (sdev->last_queue_full_count <= 10) 811 return 0; 812 if (sdev->last_queue_full_depth < 8) { 813 /* Drop back to untagged */ 814 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun); 815 return -1; 816 } 817 818 if (sdev->ordered_tags) 819 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth); 820 else 821 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth); 822 return depth; 823 } 824 EXPORT_SYMBOL(scsi_track_queue_full); 825 826 /** 827 * scsi_device_get - get an addition reference to a scsi_device 828 * @sdev: device to get a reference to 829 * 830 * Gets a reference to the scsi_device and increments the use count 831 * of the underlying LLDD module. You must hold host_lock of the 832 * parent Scsi_Host or already have a reference when calling this. 833 */ 834 int scsi_device_get(struct scsi_device *sdev) 835 { 836 if (sdev->sdev_state == SDEV_DEL) 837 return -ENXIO; 838 if (!get_device(&sdev->sdev_gendev)) 839 return -ENXIO; 840 /* We can fail this if we're doing SCSI operations 841 * from module exit (like cache flush) */ 842 try_module_get(sdev->host->hostt->module); 843 844 return 0; 845 } 846 EXPORT_SYMBOL(scsi_device_get); 847 848 /** 849 * scsi_device_put - release a reference to a scsi_device 850 * @sdev: device to release a reference on. 851 * 852 * Release a reference to the scsi_device and decrements the use count 853 * of the underlying LLDD module. The device is freed once the last 854 * user vanishes. 855 */ 856 void scsi_device_put(struct scsi_device *sdev) 857 { 858 #ifdef CONFIG_MODULE_UNLOAD 859 struct module *module = sdev->host->hostt->module; 860 861 /* The module refcount will be zero if scsi_device_get() 862 * was called from a module removal routine */ 863 if (module && module_refcount(module) != 0) 864 module_put(module); 865 #endif 866 put_device(&sdev->sdev_gendev); 867 } 868 EXPORT_SYMBOL(scsi_device_put); 869 870 /* helper for shost_for_each_device, thus not documented */ 871 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost, 872 struct scsi_device *prev) 873 { 874 struct list_head *list = (prev ? &prev->siblings : &shost->__devices); 875 struct scsi_device *next = NULL; 876 unsigned long flags; 877 878 spin_lock_irqsave(shost->host_lock, flags); 879 while (list->next != &shost->__devices) { 880 next = list_entry(list->next, struct scsi_device, siblings); 881 /* skip devices that we can't get a reference to */ 882 if (!scsi_device_get(next)) 883 break; 884 next = NULL; 885 list = list->next; 886 } 887 spin_unlock_irqrestore(shost->host_lock, flags); 888 889 if (prev) 890 scsi_device_put(prev); 891 return next; 892 } 893 EXPORT_SYMBOL(__scsi_iterate_devices); 894 895 /** 896 * starget_for_each_device - helper to walk all devices of a target 897 * @starget: target whose devices we want to iterate over. 898 * 899 * This traverses over each devices of @shost. The devices have 900 * a reference that must be released by scsi_host_put when breaking 901 * out of the loop. 902 */ 903 void starget_for_each_device(struct scsi_target *starget, void * data, 904 void (*fn)(struct scsi_device *, void *)) 905 { 906 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 907 struct scsi_device *sdev; 908 909 shost_for_each_device(sdev, shost) { 910 if ((sdev->channel == starget->channel) && 911 (sdev->id == starget->id)) 912 fn(sdev, data); 913 } 914 } 915 EXPORT_SYMBOL(starget_for_each_device); 916 917 /** 918 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED) 919 * @starget: SCSI target pointer 920 * @lun: SCSI Logical Unit Number 921 * 922 * Looks up the scsi_device with the specified @lun for a give 923 * @starget. The returned scsi_device does not have an additional 924 * reference. You must hold the host's host_lock over this call and 925 * any access to the returned scsi_device. 926 * 927 * Note: The only reason why drivers would want to use this is because 928 * they're need to access the device list in irq context. Otherwise you 929 * really want to use scsi_device_lookup_by_target instead. 930 **/ 931 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget, 932 uint lun) 933 { 934 struct scsi_device *sdev; 935 936 list_for_each_entry(sdev, &starget->devices, same_target_siblings) { 937 if (sdev->lun ==lun) 938 return sdev; 939 } 940 941 return NULL; 942 } 943 EXPORT_SYMBOL(__scsi_device_lookup_by_target); 944 945 /** 946 * scsi_device_lookup_by_target - find a device given the target 947 * @starget: SCSI target pointer 948 * @lun: SCSI Logical Unit Number 949 * 950 * Looks up the scsi_device with the specified @channel, @id, @lun for a 951 * give host. The returned scsi_device has an additional reference that 952 * needs to be release with scsi_host_put once you're done with it. 953 **/ 954 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget, 955 uint lun) 956 { 957 struct scsi_device *sdev; 958 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 959 unsigned long flags; 960 961 spin_lock_irqsave(shost->host_lock, flags); 962 sdev = __scsi_device_lookup_by_target(starget, lun); 963 if (sdev && scsi_device_get(sdev)) 964 sdev = NULL; 965 spin_unlock_irqrestore(shost->host_lock, flags); 966 967 return sdev; 968 } 969 EXPORT_SYMBOL(scsi_device_lookup_by_target); 970 971 /** 972 * scsi_device_lookup - find a device given the host (UNLOCKED) 973 * @shost: SCSI host pointer 974 * @channel: SCSI channel (zero if only one channel) 975 * @pun: SCSI target number (physical unit number) 976 * @lun: SCSI Logical Unit Number 977 * 978 * Looks up the scsi_device with the specified @channel, @id, @lun for a 979 * give host. The returned scsi_device does not have an additional reference. 980 * You must hold the host's host_lock over this call and any access to the 981 * returned scsi_device. 982 * 983 * Note: The only reason why drivers would want to use this is because 984 * they're need to access the device list in irq context. Otherwise you 985 * really want to use scsi_device_lookup instead. 986 **/ 987 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost, 988 uint channel, uint id, uint lun) 989 { 990 struct scsi_device *sdev; 991 992 list_for_each_entry(sdev, &shost->__devices, siblings) { 993 if (sdev->channel == channel && sdev->id == id && 994 sdev->lun ==lun) 995 return sdev; 996 } 997 998 return NULL; 999 } 1000 EXPORT_SYMBOL(__scsi_device_lookup); 1001 1002 /** 1003 * scsi_device_lookup - find a device given the host 1004 * @shost: SCSI host pointer 1005 * @channel: SCSI channel (zero if only one channel) 1006 * @id: SCSI target number (physical unit number) 1007 * @lun: SCSI Logical Unit Number 1008 * 1009 * Looks up the scsi_device with the specified @channel, @id, @lun for a 1010 * give host. The returned scsi_device has an additional reference that 1011 * needs to be release with scsi_host_put once you're done with it. 1012 **/ 1013 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost, 1014 uint channel, uint id, uint lun) 1015 { 1016 struct scsi_device *sdev; 1017 unsigned long flags; 1018 1019 spin_lock_irqsave(shost->host_lock, flags); 1020 sdev = __scsi_device_lookup(shost, channel, id, lun); 1021 if (sdev && scsi_device_get(sdev)) 1022 sdev = NULL; 1023 spin_unlock_irqrestore(shost->host_lock, flags); 1024 1025 return sdev; 1026 } 1027 EXPORT_SYMBOL(scsi_device_lookup); 1028 1029 MODULE_DESCRIPTION("SCSI core"); 1030 MODULE_LICENSE("GPL"); 1031 1032 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR); 1033 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels"); 1034 1035 static int __init init_scsi(void) 1036 { 1037 int error; 1038 1039 error = scsi_init_queue(); 1040 if (error) 1041 return error; 1042 error = scsi_init_procfs(); 1043 if (error) 1044 goto cleanup_queue; 1045 error = scsi_init_devinfo(); 1046 if (error) 1047 goto cleanup_procfs; 1048 error = scsi_init_hosts(); 1049 if (error) 1050 goto cleanup_devlist; 1051 error = scsi_init_sysctl(); 1052 if (error) 1053 goto cleanup_hosts; 1054 error = scsi_sysfs_register(); 1055 if (error) 1056 goto cleanup_sysctl; 1057 1058 scsi_netlink_init(); 1059 1060 printk(KERN_NOTICE "SCSI subsystem initialized\n"); 1061 return 0; 1062 1063 cleanup_sysctl: 1064 scsi_exit_sysctl(); 1065 cleanup_hosts: 1066 scsi_exit_hosts(); 1067 cleanup_devlist: 1068 scsi_exit_devinfo(); 1069 cleanup_procfs: 1070 scsi_exit_procfs(); 1071 cleanup_queue: 1072 scsi_exit_queue(); 1073 printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n", 1074 -error); 1075 return error; 1076 } 1077 1078 static void __exit exit_scsi(void) 1079 { 1080 scsi_netlink_exit(); 1081 scsi_sysfs_unregister(); 1082 scsi_exit_sysctl(); 1083 scsi_exit_hosts(); 1084 scsi_exit_devinfo(); 1085 scsi_exit_procfs(); 1086 scsi_exit_queue(); 1087 } 1088 1089 subsys_initcall(init_scsi); 1090 module_exit(exit_scsi); 1091