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 * Note - the initial logging level can be set here to log events at boot time. 83 * After the system is up, you may enable logging via the /proc interface. 84 */ 85 unsigned int scsi_logging_level; 86 #if defined(CONFIG_SCSI_LOGGING) 87 EXPORT_SYMBOL(scsi_logging_level); 88 #endif 89 90 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI. 91 * You may not alter any existing entry (although adding new ones is 92 * encouraged once assigned by ANSI/INCITS T10 93 */ 94 static const char *const scsi_device_types[] = { 95 "Direct-Access ", 96 "Sequential-Access", 97 "Printer ", 98 "Processor ", 99 "WORM ", 100 "CD-ROM ", 101 "Scanner ", 102 "Optical Device ", 103 "Medium Changer ", 104 "Communications ", 105 "ASC IT8 ", 106 "ASC IT8 ", 107 "RAID ", 108 "Enclosure ", 109 "Direct-Access-RBC", 110 "Optical card ", 111 "Bridge controller", 112 "Object storage ", 113 "Automation/Drive ", 114 }; 115 116 /** 117 * scsi_device_type - Return 17 char string indicating device type. 118 * @type: type number to look up 119 */ 120 121 const char * scsi_device_type(unsigned type) 122 { 123 if (type == 0x1e) 124 return "Well-known LUN "; 125 if (type == 0x1f) 126 return "No Device "; 127 if (type >= ARRAY_SIZE(scsi_device_types)) 128 return "Unknown "; 129 return scsi_device_types[type]; 130 } 131 132 EXPORT_SYMBOL(scsi_device_type); 133 134 struct scsi_host_cmd_pool { 135 struct kmem_cache *cmd_slab; 136 struct kmem_cache *sense_slab; 137 unsigned int users; 138 char *cmd_name; 139 char *sense_name; 140 unsigned int slab_flags; 141 gfp_t gfp_mask; 142 }; 143 144 static struct scsi_host_cmd_pool scsi_cmd_pool = { 145 .cmd_name = "scsi_cmd_cache", 146 .sense_name = "scsi_sense_cache", 147 .slab_flags = SLAB_HWCACHE_ALIGN, 148 }; 149 150 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = { 151 .cmd_name = "scsi_cmd_cache(DMA)", 152 .sense_name = "scsi_sense_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 /** 160 * scsi_pool_alloc_command - internal function to get a fully allocated command 161 * @pool: slab pool to allocate the command from 162 * @gfp_mask: mask for the allocation 163 * 164 * Returns a fully allocated command (with the allied sense buffer) or 165 * NULL on failure 166 */ 167 static struct scsi_cmnd * 168 scsi_pool_alloc_command(struct scsi_host_cmd_pool *pool, gfp_t gfp_mask) 169 { 170 struct scsi_cmnd *cmd; 171 172 cmd = kmem_cache_zalloc(pool->cmd_slab, gfp_mask | pool->gfp_mask); 173 if (!cmd) 174 return NULL; 175 176 cmd->sense_buffer = kmem_cache_alloc(pool->sense_slab, 177 gfp_mask | pool->gfp_mask); 178 if (!cmd->sense_buffer) { 179 kmem_cache_free(pool->cmd_slab, cmd); 180 return NULL; 181 } 182 183 return cmd; 184 } 185 186 /** 187 * scsi_pool_free_command - internal function to release a command 188 * @pool: slab pool to allocate the command from 189 * @cmd: command to release 190 * 191 * the command must previously have been allocated by 192 * scsi_pool_alloc_command. 193 */ 194 static void 195 scsi_pool_free_command(struct scsi_host_cmd_pool *pool, 196 struct scsi_cmnd *cmd) 197 { 198 if (cmd->prot_sdb) 199 kmem_cache_free(scsi_sdb_cache, cmd->prot_sdb); 200 201 kmem_cache_free(pool->sense_slab, cmd->sense_buffer); 202 kmem_cache_free(pool->cmd_slab, cmd); 203 } 204 205 /** 206 * scsi_host_alloc_command - internal function to allocate command 207 * @shost: SCSI host whose pool to allocate from 208 * @gfp_mask: mask for the allocation 209 * 210 * Returns a fully allocated command with sense buffer and protection 211 * data buffer (where applicable) or NULL on failure 212 */ 213 static struct scsi_cmnd * 214 scsi_host_alloc_command(struct Scsi_Host *shost, gfp_t gfp_mask) 215 { 216 struct scsi_cmnd *cmd; 217 218 cmd = scsi_pool_alloc_command(shost->cmd_pool, gfp_mask); 219 if (!cmd) 220 return NULL; 221 222 if (scsi_host_get_prot(shost) >= SHOST_DIX_TYPE0_PROTECTION) { 223 cmd->prot_sdb = kmem_cache_zalloc(scsi_sdb_cache, gfp_mask); 224 225 if (!cmd->prot_sdb) { 226 scsi_pool_free_command(shost->cmd_pool, cmd); 227 return NULL; 228 } 229 } 230 231 return cmd; 232 } 233 234 /** 235 * __scsi_get_command - Allocate a struct scsi_cmnd 236 * @shost: host to transmit command 237 * @gfp_mask: allocation mask 238 * 239 * Description: allocate a struct scsi_cmd from host's slab, recycling from the 240 * host's free_list if necessary. 241 */ 242 struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask) 243 { 244 struct scsi_cmnd *cmd = scsi_host_alloc_command(shost, gfp_mask); 245 246 if (unlikely(!cmd)) { 247 unsigned long flags; 248 249 spin_lock_irqsave(&shost->free_list_lock, flags); 250 if (likely(!list_empty(&shost->free_list))) { 251 cmd = list_entry(shost->free_list.next, 252 struct scsi_cmnd, list); 253 list_del_init(&cmd->list); 254 } 255 spin_unlock_irqrestore(&shost->free_list_lock, flags); 256 257 if (cmd) { 258 void *buf, *prot; 259 260 buf = cmd->sense_buffer; 261 prot = cmd->prot_sdb; 262 263 memset(cmd, 0, sizeof(*cmd)); 264 265 cmd->sense_buffer = buf; 266 cmd->prot_sdb = prot; 267 } 268 } 269 270 return cmd; 271 } 272 EXPORT_SYMBOL_GPL(__scsi_get_command); 273 274 /** 275 * scsi_get_command - Allocate and setup a scsi command block 276 * @dev: parent scsi device 277 * @gfp_mask: allocator flags 278 * 279 * Returns: The allocated scsi command structure. 280 */ 281 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask) 282 { 283 struct scsi_cmnd *cmd; 284 285 /* Bail if we can't get a reference to the device */ 286 if (!get_device(&dev->sdev_gendev)) 287 return NULL; 288 289 cmd = __scsi_get_command(dev->host, gfp_mask); 290 291 if (likely(cmd != NULL)) { 292 unsigned long flags; 293 294 cmd->device = dev; 295 INIT_LIST_HEAD(&cmd->list); 296 spin_lock_irqsave(&dev->list_lock, flags); 297 list_add_tail(&cmd->list, &dev->cmd_list); 298 spin_unlock_irqrestore(&dev->list_lock, flags); 299 cmd->jiffies_at_alloc = jiffies; 300 } else 301 put_device(&dev->sdev_gendev); 302 303 return cmd; 304 } 305 EXPORT_SYMBOL(scsi_get_command); 306 307 /** 308 * __scsi_put_command - Free a struct scsi_cmnd 309 * @shost: dev->host 310 * @cmd: Command to free 311 * @dev: parent scsi device 312 */ 313 void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd, 314 struct device *dev) 315 { 316 unsigned long flags; 317 318 /* changing locks here, don't need to restore the irq state */ 319 spin_lock_irqsave(&shost->free_list_lock, flags); 320 if (unlikely(list_empty(&shost->free_list))) { 321 list_add(&cmd->list, &shost->free_list); 322 cmd = NULL; 323 } 324 spin_unlock_irqrestore(&shost->free_list_lock, flags); 325 326 if (likely(cmd != NULL)) 327 scsi_pool_free_command(shost->cmd_pool, cmd); 328 329 put_device(dev); 330 } 331 EXPORT_SYMBOL(__scsi_put_command); 332 333 /** 334 * scsi_put_command - Free a scsi command block 335 * @cmd: command block to free 336 * 337 * Returns: Nothing. 338 * 339 * Notes: The command must not belong to any lists. 340 */ 341 void scsi_put_command(struct scsi_cmnd *cmd) 342 { 343 struct scsi_device *sdev = cmd->device; 344 unsigned long flags; 345 346 /* serious error if the command hasn't come from a device list */ 347 spin_lock_irqsave(&cmd->device->list_lock, flags); 348 BUG_ON(list_empty(&cmd->list)); 349 list_del_init(&cmd->list); 350 spin_unlock_irqrestore(&cmd->device->list_lock, flags); 351 352 __scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev); 353 } 354 EXPORT_SYMBOL(scsi_put_command); 355 356 static struct scsi_host_cmd_pool *scsi_get_host_cmd_pool(gfp_t gfp_mask) 357 { 358 struct scsi_host_cmd_pool *retval = NULL, *pool; 359 /* 360 * Select a command slab for this host and create it if not 361 * yet existent. 362 */ 363 mutex_lock(&host_cmd_pool_mutex); 364 pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool : 365 &scsi_cmd_pool; 366 if (!pool->users) { 367 pool->cmd_slab = kmem_cache_create(pool->cmd_name, 368 sizeof(struct scsi_cmnd), 0, 369 pool->slab_flags, NULL); 370 if (!pool->cmd_slab) 371 goto fail; 372 373 pool->sense_slab = kmem_cache_create(pool->sense_name, 374 SCSI_SENSE_BUFFERSIZE, 0, 375 pool->slab_flags, NULL); 376 if (!pool->sense_slab) { 377 kmem_cache_destroy(pool->cmd_slab); 378 goto fail; 379 } 380 } 381 382 pool->users++; 383 retval = pool; 384 fail: 385 mutex_unlock(&host_cmd_pool_mutex); 386 return retval; 387 } 388 389 static void scsi_put_host_cmd_pool(gfp_t gfp_mask) 390 { 391 struct scsi_host_cmd_pool *pool; 392 393 mutex_lock(&host_cmd_pool_mutex); 394 pool = (gfp_mask & __GFP_DMA) ? &scsi_cmd_dma_pool : 395 &scsi_cmd_pool; 396 /* 397 * This may happen if a driver has a mismatched get and put 398 * of the command pool; the driver should be implicated in 399 * the stack trace 400 */ 401 BUG_ON(pool->users == 0); 402 403 if (!--pool->users) { 404 kmem_cache_destroy(pool->cmd_slab); 405 kmem_cache_destroy(pool->sense_slab); 406 } 407 mutex_unlock(&host_cmd_pool_mutex); 408 } 409 410 /** 411 * scsi_allocate_command - get a fully allocated SCSI command 412 * @gfp_mask: allocation mask 413 * 414 * This function is for use outside of the normal host based pools. 415 * It allocates the relevant command and takes an additional reference 416 * on the pool it used. This function *must* be paired with 417 * scsi_free_command which also has the identical mask, otherwise the 418 * free pool counts will eventually go wrong and you'll trigger a bug. 419 * 420 * This function should *only* be used by drivers that need a static 421 * command allocation at start of day for internal functions. 422 */ 423 struct scsi_cmnd *scsi_allocate_command(gfp_t gfp_mask) 424 { 425 struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask); 426 427 if (!pool) 428 return NULL; 429 430 return scsi_pool_alloc_command(pool, gfp_mask); 431 } 432 EXPORT_SYMBOL(scsi_allocate_command); 433 434 /** 435 * scsi_free_command - free a command allocated by scsi_allocate_command 436 * @gfp_mask: mask used in the original allocation 437 * @cmd: command to free 438 * 439 * Note: using the original allocation mask is vital because that's 440 * what determines which command pool we use to free the command. Any 441 * mismatch will cause the system to BUG eventually. 442 */ 443 void scsi_free_command(gfp_t gfp_mask, struct scsi_cmnd *cmd) 444 { 445 struct scsi_host_cmd_pool *pool = scsi_get_host_cmd_pool(gfp_mask); 446 447 /* 448 * this could trigger if the mask to scsi_allocate_command 449 * doesn't match this mask. Otherwise we're guaranteed that this 450 * succeeds because scsi_allocate_command must have taken a reference 451 * on the pool 452 */ 453 BUG_ON(!pool); 454 455 scsi_pool_free_command(pool, cmd); 456 /* 457 * scsi_put_host_cmd_pool is called twice; once to release the 458 * reference we took above, and once to release the reference 459 * originally taken by scsi_allocate_command 460 */ 461 scsi_put_host_cmd_pool(gfp_mask); 462 scsi_put_host_cmd_pool(gfp_mask); 463 } 464 EXPORT_SYMBOL(scsi_free_command); 465 466 /** 467 * scsi_setup_command_freelist - Setup the command freelist for a scsi host. 468 * @shost: host to allocate the freelist for. 469 * 470 * Description: The command freelist protects against system-wide out of memory 471 * deadlock by preallocating one SCSI command structure for each host, so the 472 * system can always write to a swap file on a device associated with that host. 473 * 474 * Returns: Nothing. 475 */ 476 int scsi_setup_command_freelist(struct Scsi_Host *shost) 477 { 478 struct scsi_cmnd *cmd; 479 const gfp_t gfp_mask = shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL; 480 481 spin_lock_init(&shost->free_list_lock); 482 INIT_LIST_HEAD(&shost->free_list); 483 484 shost->cmd_pool = scsi_get_host_cmd_pool(gfp_mask); 485 486 if (!shost->cmd_pool) 487 return -ENOMEM; 488 489 /* 490 * Get one backup command for this host. 491 */ 492 cmd = scsi_host_alloc_command(shost, gfp_mask); 493 if (!cmd) { 494 scsi_put_host_cmd_pool(gfp_mask); 495 shost->cmd_pool = NULL; 496 return -ENOMEM; 497 } 498 list_add(&cmd->list, &shost->free_list); 499 return 0; 500 } 501 502 /** 503 * scsi_destroy_command_freelist - Release the command freelist for a scsi host. 504 * @shost: host whose freelist is going to be destroyed 505 */ 506 void scsi_destroy_command_freelist(struct Scsi_Host *shost) 507 { 508 /* 509 * If cmd_pool is NULL the free list was not initialized, so 510 * do not attempt to release resources. 511 */ 512 if (!shost->cmd_pool) 513 return; 514 515 while (!list_empty(&shost->free_list)) { 516 struct scsi_cmnd *cmd; 517 518 cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list); 519 list_del_init(&cmd->list); 520 scsi_pool_free_command(shost->cmd_pool, cmd); 521 } 522 shost->cmd_pool = NULL; 523 scsi_put_host_cmd_pool(shost->unchecked_isa_dma ? GFP_DMA : GFP_KERNEL); 524 } 525 526 #ifdef CONFIG_SCSI_LOGGING 527 void scsi_log_send(struct scsi_cmnd *cmd) 528 { 529 unsigned int level; 530 531 /* 532 * If ML QUEUE log level is greater than or equal to: 533 * 534 * 1: nothing (match completion) 535 * 536 * 2: log opcode + command of all commands 537 * 538 * 3: same as 2 plus dump cmd address 539 * 540 * 4: same as 3 plus dump extra junk 541 */ 542 if (unlikely(scsi_logging_level)) { 543 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT, 544 SCSI_LOG_MLQUEUE_BITS); 545 if (level > 1) { 546 scmd_printk(KERN_INFO, cmd, "Send: "); 547 if (level > 2) 548 printk("0x%p ", cmd); 549 printk("\n"); 550 scsi_print_command(cmd); 551 if (level > 3) { 552 printk(KERN_INFO "buffer = 0x%p, bufflen = %d," 553 " queuecommand 0x%p\n", 554 scsi_sglist(cmd), scsi_bufflen(cmd), 555 cmd->device->host->hostt->queuecommand); 556 557 } 558 } 559 } 560 } 561 562 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition) 563 { 564 unsigned int level; 565 566 /* 567 * If ML COMPLETE log level is greater than or equal to: 568 * 569 * 1: log disposition, result, opcode + command, and conditionally 570 * sense data for failures or non SUCCESS dispositions. 571 * 572 * 2: same as 1 but for all command completions. 573 * 574 * 3: same as 2 plus dump cmd address 575 * 576 * 4: same as 3 plus dump extra junk 577 */ 578 if (unlikely(scsi_logging_level)) { 579 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT, 580 SCSI_LOG_MLCOMPLETE_BITS); 581 if (((level > 0) && (cmd->result || disposition != SUCCESS)) || 582 (level > 1)) { 583 scmd_printk(KERN_INFO, cmd, "Done: "); 584 if (level > 2) 585 printk("0x%p ", cmd); 586 /* 587 * Dump truncated values, so we usually fit within 588 * 80 chars. 589 */ 590 switch (disposition) { 591 case SUCCESS: 592 printk("SUCCESS\n"); 593 break; 594 case NEEDS_RETRY: 595 printk("RETRY\n"); 596 break; 597 case ADD_TO_MLQUEUE: 598 printk("MLQUEUE\n"); 599 break; 600 case FAILED: 601 printk("FAILED\n"); 602 break; 603 case TIMEOUT_ERROR: 604 /* 605 * If called via scsi_times_out. 606 */ 607 printk("TIMEOUT\n"); 608 break; 609 default: 610 printk("UNKNOWN\n"); 611 } 612 scsi_print_result(cmd); 613 scsi_print_command(cmd); 614 if (status_byte(cmd->result) & CHECK_CONDITION) 615 scsi_print_sense("", cmd); 616 if (level > 3) 617 scmd_printk(KERN_INFO, cmd, 618 "scsi host busy %d failed %d\n", 619 cmd->device->host->host_busy, 620 cmd->device->host->host_failed); 621 } 622 } 623 } 624 #endif 625 626 /** 627 * scsi_cmd_get_serial - Assign a serial number to a command 628 * @host: the scsi host 629 * @cmd: command to assign serial number to 630 * 631 * Description: a serial number identifies a request for error recovery 632 * and debugging purposes. Protected by the Host_Lock of host. 633 */ 634 static inline void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd) 635 { 636 cmd->serial_number = host->cmd_serial_number++; 637 if (cmd->serial_number == 0) 638 cmd->serial_number = host->cmd_serial_number++; 639 } 640 641 /** 642 * scsi_dispatch_command - Dispatch a command to the low-level driver. 643 * @cmd: command block we are dispatching. 644 * 645 * Return: nonzero return request was rejected and device's queue needs to be 646 * plugged. 647 */ 648 int scsi_dispatch_cmd(struct scsi_cmnd *cmd) 649 { 650 struct Scsi_Host *host = cmd->device->host; 651 unsigned long flags = 0; 652 unsigned long timeout; 653 int rtn = 0; 654 655 atomic_inc(&cmd->device->iorequest_cnt); 656 657 /* check if the device is still usable */ 658 if (unlikely(cmd->device->sdev_state == SDEV_DEL)) { 659 /* in SDEV_DEL we error all commands. DID_NO_CONNECT 660 * returns an immediate error upwards, and signals 661 * that the device is no longer present */ 662 cmd->result = DID_NO_CONNECT << 16; 663 scsi_done(cmd); 664 /* return 0 (because the command has been processed) */ 665 goto out; 666 } 667 668 /* Check to see if the scsi lld made this device blocked. */ 669 if (unlikely(scsi_device_blocked(cmd->device))) { 670 /* 671 * in blocked state, the command is just put back on 672 * the device queue. The suspend state has already 673 * blocked the queue so future requests should not 674 * occur until the device transitions out of the 675 * suspend state. 676 */ 677 678 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY); 679 680 SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n")); 681 682 /* 683 * NOTE: rtn is still zero here because we don't need the 684 * queue to be plugged on return (it's already stopped) 685 */ 686 goto out; 687 } 688 689 /* 690 * If SCSI-2 or lower, store the LUN value in cmnd. 691 */ 692 if (cmd->device->scsi_level <= SCSI_2 && 693 cmd->device->scsi_level != SCSI_UNKNOWN) { 694 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) | 695 (cmd->device->lun << 5 & 0xe0); 696 } 697 698 /* 699 * We will wait MIN_RESET_DELAY clock ticks after the last reset so 700 * we can avoid the drive not being ready. 701 */ 702 timeout = host->last_reset + MIN_RESET_DELAY; 703 704 if (host->resetting && time_before(jiffies, timeout)) { 705 int ticks_remaining = timeout - jiffies; 706 /* 707 * NOTE: This may be executed from within an interrupt 708 * handler! This is bad, but for now, it'll do. The irq 709 * level of the interrupt handler has been masked out by the 710 * platform dependent interrupt handling code already, so the 711 * sti() here will not cause another call to the SCSI host's 712 * interrupt handler (assuming there is one irq-level per 713 * host). 714 */ 715 while (--ticks_remaining >= 0) 716 mdelay(1 + 999 / HZ); 717 host->resetting = 0; 718 } 719 720 scsi_log_send(cmd); 721 722 /* 723 * Before we queue this command, check if the command 724 * length exceeds what the host adapter can handle. 725 */ 726 if (cmd->cmd_len > cmd->device->host->max_cmd_len) { 727 SCSI_LOG_MLQUEUE(3, 728 printk("queuecommand : command too long. " 729 "cdb_size=%d host->max_cmd_len=%d\n", 730 cmd->cmd_len, cmd->device->host->max_cmd_len)); 731 cmd->result = (DID_ABORT << 16); 732 733 scsi_done(cmd); 734 goto out; 735 } 736 737 spin_lock_irqsave(host->host_lock, flags); 738 /* 739 * AK: unlikely race here: for some reason the timer could 740 * expire before the serial number is set up below. 741 * 742 * TODO: kill serial or move to blk layer 743 */ 744 scsi_cmd_get_serial(host, cmd); 745 746 if (unlikely(host->shost_state == SHOST_DEL)) { 747 cmd->result = (DID_NO_CONNECT << 16); 748 scsi_done(cmd); 749 } else { 750 rtn = host->hostt->queuecommand(cmd, scsi_done); 751 } 752 spin_unlock_irqrestore(host->host_lock, flags); 753 if (rtn) { 754 if (rtn != SCSI_MLQUEUE_DEVICE_BUSY && 755 rtn != SCSI_MLQUEUE_TARGET_BUSY) 756 rtn = SCSI_MLQUEUE_HOST_BUSY; 757 758 scsi_queue_insert(cmd, rtn); 759 760 SCSI_LOG_MLQUEUE(3, 761 printk("queuecommand : request rejected\n")); 762 } 763 764 out: 765 SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n")); 766 return rtn; 767 } 768 769 /** 770 * scsi_done - Enqueue the finished SCSI command into the done queue. 771 * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives 772 * ownership back to SCSI Core -- i.e. the LLDD has finished with it. 773 * 774 * Description: This function is the mid-level's (SCSI Core) interrupt routine, 775 * which regains ownership of the SCSI command (de facto) from a LLDD, and 776 * enqueues the command to the done queue for further processing. 777 * 778 * This is the producer of the done queue who enqueues at the tail. 779 * 780 * This function is interrupt context safe. 781 */ 782 static void scsi_done(struct scsi_cmnd *cmd) 783 { 784 blk_complete_request(cmd->request); 785 } 786 787 /* Move this to a header if it becomes more generally useful */ 788 static struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd) 789 { 790 return *(struct scsi_driver **)cmd->request->rq_disk->private_data; 791 } 792 793 /** 794 * scsi_finish_command - cleanup and pass command back to upper layer 795 * @cmd: the command 796 * 797 * Description: Pass command off to upper layer for finishing of I/O 798 * request, waking processes that are waiting on results, 799 * etc. 800 */ 801 void scsi_finish_command(struct scsi_cmnd *cmd) 802 { 803 struct scsi_device *sdev = cmd->device; 804 struct scsi_target *starget = scsi_target(sdev); 805 struct Scsi_Host *shost = sdev->host; 806 struct scsi_driver *drv; 807 unsigned int good_bytes; 808 809 scsi_device_unbusy(sdev); 810 811 /* 812 * Clear the flags which say that the device/host is no longer 813 * capable of accepting new commands. These are set in scsi_queue.c 814 * for both the queue full condition on a device, and for a 815 * host full condition on the host. 816 * 817 * XXX(hch): What about locking? 818 */ 819 shost->host_blocked = 0; 820 starget->target_blocked = 0; 821 sdev->device_blocked = 0; 822 823 /* 824 * If we have valid sense information, then some kind of recovery 825 * must have taken place. Make a note of this. 826 */ 827 if (SCSI_SENSE_VALID(cmd)) 828 cmd->result |= (DRIVER_SENSE << 24); 829 830 SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev, 831 "Notifying upper driver of completion " 832 "(result %x)\n", cmd->result)); 833 834 good_bytes = scsi_bufflen(cmd); 835 if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) { 836 int old_good_bytes = good_bytes; 837 drv = scsi_cmd_to_driver(cmd); 838 if (drv->done) 839 good_bytes = drv->done(cmd); 840 /* 841 * USB may not give sense identifying bad sector and 842 * simply return a residue instead, so subtract off the 843 * residue if drv->done() error processing indicates no 844 * change to the completion length. 845 */ 846 if (good_bytes == old_good_bytes) 847 good_bytes -= scsi_get_resid(cmd); 848 } 849 scsi_io_completion(cmd, good_bytes); 850 } 851 EXPORT_SYMBOL(scsi_finish_command); 852 853 /** 854 * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth 855 * @sdev: SCSI Device in question 856 * @tagged: Do we use tagged queueing (non-0) or do we treat 857 * this device as an untagged device (0) 858 * @tags: Number of tags allowed if tagged queueing enabled, 859 * or number of commands the low level driver can 860 * queue up in non-tagged mode (as per cmd_per_lun). 861 * 862 * Returns: Nothing 863 * 864 * Lock Status: None held on entry 865 * 866 * Notes: Low level drivers may call this at any time and we will do 867 * the right thing depending on whether or not the device is 868 * currently active and whether or not it even has the 869 * command blocks built yet. 870 */ 871 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags) 872 { 873 unsigned long flags; 874 875 /* 876 * refuse to set tagged depth to an unworkable size 877 */ 878 if (tags <= 0) 879 return; 880 881 spin_lock_irqsave(sdev->request_queue->queue_lock, flags); 882 883 /* 884 * Check to see if the queue is managed by the block layer. 885 * If it is, and we fail to adjust the depth, exit. 886 * 887 * Do not resize the tag map if it is a host wide share bqt, 888 * because the size should be the hosts's can_queue. If there 889 * is more IO than the LLD's can_queue (so there are not enuogh 890 * tags) request_fn's host queue ready check will handle it. 891 */ 892 if (!sdev->host->bqt) { 893 if (blk_queue_tagged(sdev->request_queue) && 894 blk_queue_resize_tags(sdev->request_queue, tags) != 0) 895 goto out; 896 } 897 898 sdev->queue_depth = tags; 899 switch (tagged) { 900 case MSG_ORDERED_TAG: 901 sdev->ordered_tags = 1; 902 sdev->simple_tags = 1; 903 break; 904 case MSG_SIMPLE_TAG: 905 sdev->ordered_tags = 0; 906 sdev->simple_tags = 1; 907 break; 908 default: 909 sdev_printk(KERN_WARNING, sdev, 910 "scsi_adjust_queue_depth, bad queue type, " 911 "disabled\n"); 912 case 0: 913 sdev->ordered_tags = sdev->simple_tags = 0; 914 sdev->queue_depth = tags; 915 break; 916 } 917 out: 918 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags); 919 } 920 EXPORT_SYMBOL(scsi_adjust_queue_depth); 921 922 /** 923 * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth 924 * @sdev: SCSI Device in question 925 * @depth: Current number of outstanding SCSI commands on this device, 926 * not counting the one returned as QUEUE_FULL. 927 * 928 * Description: This function will track successive QUEUE_FULL events on a 929 * specific SCSI device to determine if and when there is a 930 * need to adjust the queue depth on the device. 931 * 932 * Returns: 0 - No change needed, >0 - Adjust queue depth to this new depth, 933 * -1 - Drop back to untagged operation using host->cmd_per_lun 934 * as the untagged command depth 935 * 936 * Lock Status: None held on entry 937 * 938 * Notes: Low level drivers may call this at any time and we will do 939 * "The Right Thing." We are interrupt context safe. 940 */ 941 int scsi_track_queue_full(struct scsi_device *sdev, int depth) 942 { 943 944 /* 945 * Don't let QUEUE_FULLs on the same 946 * jiffies count, they could all be from 947 * same event. 948 */ 949 if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4)) 950 return 0; 951 952 sdev->last_queue_full_time = jiffies; 953 if (sdev->last_queue_full_depth != depth) { 954 sdev->last_queue_full_count = 1; 955 sdev->last_queue_full_depth = depth; 956 } else { 957 sdev->last_queue_full_count++; 958 } 959 960 if (sdev->last_queue_full_count <= 10) 961 return 0; 962 if (sdev->last_queue_full_depth < 8) { 963 /* Drop back to untagged */ 964 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun); 965 return -1; 966 } 967 968 if (sdev->ordered_tags) 969 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth); 970 else 971 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth); 972 return depth; 973 } 974 EXPORT_SYMBOL(scsi_track_queue_full); 975 976 /** 977 * scsi_vpd_inquiry - Request a device provide us with a VPD page 978 * @sdev: The device to ask 979 * @buffer: Where to put the result 980 * @page: Which Vital Product Data to return 981 * @len: The length of the buffer 982 * 983 * This is an internal helper function. You probably want to use 984 * scsi_get_vpd_page instead. 985 * 986 * Returns 0 on success or a negative error number. 987 */ 988 static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer, 989 u8 page, unsigned len) 990 { 991 int result; 992 unsigned char cmd[16]; 993 994 cmd[0] = INQUIRY; 995 cmd[1] = 1; /* EVPD */ 996 cmd[2] = page; 997 cmd[3] = len >> 8; 998 cmd[4] = len & 0xff; 999 cmd[5] = 0; /* Control byte */ 1000 1001 /* 1002 * I'm not convinced we need to try quite this hard to get VPD, but 1003 * all the existing users tried this hard. 1004 */ 1005 result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, 1006 len, NULL, 30 * HZ, 3, NULL); 1007 if (result) 1008 return result; 1009 1010 /* Sanity check that we got the page back that we asked for */ 1011 if (buffer[1] != page) 1012 return -EIO; 1013 1014 return 0; 1015 } 1016 1017 /** 1018 * scsi_get_vpd_page - Get Vital Product Data from a SCSI device 1019 * @sdev: The device to ask 1020 * @page: Which Vital Product Data to return 1021 * 1022 * SCSI devices may optionally supply Vital Product Data. Each 'page' 1023 * of VPD is defined in the appropriate SCSI document (eg SPC, SBC). 1024 * If the device supports this VPD page, this routine returns a pointer 1025 * to a buffer containing the data from that page. The caller is 1026 * responsible for calling kfree() on this pointer when it is no longer 1027 * needed. If we cannot retrieve the VPD page this routine returns %NULL. 1028 */ 1029 unsigned char *scsi_get_vpd_page(struct scsi_device *sdev, u8 page) 1030 { 1031 int i, result; 1032 unsigned int len; 1033 const unsigned int init_vpd_len = 255; 1034 unsigned char *buf = kmalloc(init_vpd_len, GFP_KERNEL); 1035 1036 if (!buf) 1037 return NULL; 1038 1039 /* Ask for all the pages supported by this device */ 1040 result = scsi_vpd_inquiry(sdev, buf, 0, init_vpd_len); 1041 if (result) 1042 goto fail; 1043 1044 /* If the user actually wanted this page, we can skip the rest */ 1045 if (page == 0) 1046 return buf; 1047 1048 for (i = 0; i < buf[3]; i++) 1049 if (buf[i + 4] == page) 1050 goto found; 1051 /* The device claims it doesn't support the requested page */ 1052 goto fail; 1053 1054 found: 1055 result = scsi_vpd_inquiry(sdev, buf, page, 255); 1056 if (result) 1057 goto fail; 1058 1059 /* 1060 * Some pages are longer than 255 bytes. The actual length of 1061 * the page is returned in the header. 1062 */ 1063 len = ((buf[2] << 8) | buf[3]) + 4; 1064 if (len <= init_vpd_len) 1065 return buf; 1066 1067 kfree(buf); 1068 buf = kmalloc(len, GFP_KERNEL); 1069 result = scsi_vpd_inquiry(sdev, buf, page, len); 1070 if (result) 1071 goto fail; 1072 1073 return buf; 1074 1075 fail: 1076 kfree(buf); 1077 return NULL; 1078 } 1079 EXPORT_SYMBOL_GPL(scsi_get_vpd_page); 1080 1081 /** 1082 * scsi_device_get - get an additional reference to a scsi_device 1083 * @sdev: device to get a reference to 1084 * 1085 * Description: Gets a reference to the scsi_device and increments the use count 1086 * of the underlying LLDD module. You must hold host_lock of the 1087 * parent Scsi_Host or already have a reference when calling this. 1088 */ 1089 int scsi_device_get(struct scsi_device *sdev) 1090 { 1091 if (sdev->sdev_state == SDEV_DEL) 1092 return -ENXIO; 1093 if (!get_device(&sdev->sdev_gendev)) 1094 return -ENXIO; 1095 /* We can fail this if we're doing SCSI operations 1096 * from module exit (like cache flush) */ 1097 try_module_get(sdev->host->hostt->module); 1098 1099 return 0; 1100 } 1101 EXPORT_SYMBOL(scsi_device_get); 1102 1103 /** 1104 * scsi_device_put - release a reference to a scsi_device 1105 * @sdev: device to release a reference on. 1106 * 1107 * Description: Release a reference to the scsi_device and decrements the use 1108 * count of the underlying LLDD module. The device is freed once the last 1109 * user vanishes. 1110 */ 1111 void scsi_device_put(struct scsi_device *sdev) 1112 { 1113 #ifdef CONFIG_MODULE_UNLOAD 1114 struct module *module = sdev->host->hostt->module; 1115 1116 /* The module refcount will be zero if scsi_device_get() 1117 * was called from a module removal routine */ 1118 if (module && module_refcount(module) != 0) 1119 module_put(module); 1120 #endif 1121 put_device(&sdev->sdev_gendev); 1122 } 1123 EXPORT_SYMBOL(scsi_device_put); 1124 1125 /* helper for shost_for_each_device, see that for documentation */ 1126 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost, 1127 struct scsi_device *prev) 1128 { 1129 struct list_head *list = (prev ? &prev->siblings : &shost->__devices); 1130 struct scsi_device *next = NULL; 1131 unsigned long flags; 1132 1133 spin_lock_irqsave(shost->host_lock, flags); 1134 while (list->next != &shost->__devices) { 1135 next = list_entry(list->next, struct scsi_device, siblings); 1136 /* skip devices that we can't get a reference to */ 1137 if (!scsi_device_get(next)) 1138 break; 1139 next = NULL; 1140 list = list->next; 1141 } 1142 spin_unlock_irqrestore(shost->host_lock, flags); 1143 1144 if (prev) 1145 scsi_device_put(prev); 1146 return next; 1147 } 1148 EXPORT_SYMBOL(__scsi_iterate_devices); 1149 1150 /** 1151 * starget_for_each_device - helper to walk all devices of a target 1152 * @starget: target whose devices we want to iterate over. 1153 * @data: Opaque passed to each function call. 1154 * @fn: Function to call on each device 1155 * 1156 * This traverses over each device of @starget. The devices have 1157 * a reference that must be released by scsi_host_put when breaking 1158 * out of the loop. 1159 */ 1160 void starget_for_each_device(struct scsi_target *starget, void *data, 1161 void (*fn)(struct scsi_device *, void *)) 1162 { 1163 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1164 struct scsi_device *sdev; 1165 1166 shost_for_each_device(sdev, shost) { 1167 if ((sdev->channel == starget->channel) && 1168 (sdev->id == starget->id)) 1169 fn(sdev, data); 1170 } 1171 } 1172 EXPORT_SYMBOL(starget_for_each_device); 1173 1174 /** 1175 * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED) 1176 * @starget: target whose devices we want to iterate over. 1177 * @data: parameter for callback @fn() 1178 * @fn: callback function that is invoked for each device 1179 * 1180 * This traverses over each device of @starget. It does _not_ 1181 * take a reference on the scsi_device, so the whole loop must be 1182 * protected by shost->host_lock. 1183 * 1184 * Note: The only reason why drivers would want to use this is because 1185 * they need to access the device list in irq context. Otherwise you 1186 * really want to use starget_for_each_device instead. 1187 **/ 1188 void __starget_for_each_device(struct scsi_target *starget, void *data, 1189 void (*fn)(struct scsi_device *, void *)) 1190 { 1191 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1192 struct scsi_device *sdev; 1193 1194 __shost_for_each_device(sdev, shost) { 1195 if ((sdev->channel == starget->channel) && 1196 (sdev->id == starget->id)) 1197 fn(sdev, data); 1198 } 1199 } 1200 EXPORT_SYMBOL(__starget_for_each_device); 1201 1202 /** 1203 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED) 1204 * @starget: SCSI target pointer 1205 * @lun: SCSI Logical Unit Number 1206 * 1207 * Description: Looks up the scsi_device with the specified @lun for a given 1208 * @starget. The returned scsi_device does not have an additional 1209 * reference. You must hold the host's host_lock over this call and 1210 * any access to the returned scsi_device. A scsi_device in state 1211 * SDEV_DEL is skipped. 1212 * 1213 * Note: The only reason why drivers should use this is because 1214 * they need to access the device list in irq context. Otherwise you 1215 * really want to use scsi_device_lookup_by_target instead. 1216 **/ 1217 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget, 1218 uint lun) 1219 { 1220 struct scsi_device *sdev; 1221 1222 list_for_each_entry(sdev, &starget->devices, same_target_siblings) { 1223 if (sdev->sdev_state == SDEV_DEL) 1224 continue; 1225 if (sdev->lun ==lun) 1226 return sdev; 1227 } 1228 1229 return NULL; 1230 } 1231 EXPORT_SYMBOL(__scsi_device_lookup_by_target); 1232 1233 /** 1234 * scsi_device_lookup_by_target - find a device given the target 1235 * @starget: SCSI target pointer 1236 * @lun: SCSI Logical Unit Number 1237 * 1238 * Description: Looks up the scsi_device with the specified @lun for a given 1239 * @starget. The returned scsi_device has an additional reference that 1240 * needs to be released with scsi_device_put once you're done with it. 1241 **/ 1242 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget, 1243 uint lun) 1244 { 1245 struct scsi_device *sdev; 1246 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); 1247 unsigned long flags; 1248 1249 spin_lock_irqsave(shost->host_lock, flags); 1250 sdev = __scsi_device_lookup_by_target(starget, lun); 1251 if (sdev && scsi_device_get(sdev)) 1252 sdev = NULL; 1253 spin_unlock_irqrestore(shost->host_lock, flags); 1254 1255 return sdev; 1256 } 1257 EXPORT_SYMBOL(scsi_device_lookup_by_target); 1258 1259 /** 1260 * __scsi_device_lookup - find a device given the host (UNLOCKED) 1261 * @shost: SCSI host pointer 1262 * @channel: SCSI channel (zero if only one channel) 1263 * @id: SCSI target number (physical unit number) 1264 * @lun: SCSI Logical Unit Number 1265 * 1266 * Description: Looks up the scsi_device with the specified @channel, @id, @lun 1267 * for a given host. The returned scsi_device does not have an additional 1268 * reference. You must hold the host's host_lock over this call and any access 1269 * to the returned scsi_device. 1270 * 1271 * Note: The only reason why drivers would want to use this is because 1272 * they need to access the device list in irq context. Otherwise you 1273 * really want to use scsi_device_lookup instead. 1274 **/ 1275 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost, 1276 uint channel, uint id, uint lun) 1277 { 1278 struct scsi_device *sdev; 1279 1280 list_for_each_entry(sdev, &shost->__devices, siblings) { 1281 if (sdev->channel == channel && sdev->id == id && 1282 sdev->lun ==lun) 1283 return sdev; 1284 } 1285 1286 return NULL; 1287 } 1288 EXPORT_SYMBOL(__scsi_device_lookup); 1289 1290 /** 1291 * scsi_device_lookup - find a device given the host 1292 * @shost: SCSI host pointer 1293 * @channel: SCSI channel (zero if only one channel) 1294 * @id: SCSI target number (physical unit number) 1295 * @lun: SCSI Logical Unit Number 1296 * 1297 * Description: Looks up the scsi_device with the specified @channel, @id, @lun 1298 * for a given host. The returned scsi_device has an additional reference that 1299 * needs to be released with scsi_device_put once you're done with it. 1300 **/ 1301 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost, 1302 uint channel, uint id, uint lun) 1303 { 1304 struct scsi_device *sdev; 1305 unsigned long flags; 1306 1307 spin_lock_irqsave(shost->host_lock, flags); 1308 sdev = __scsi_device_lookup(shost, channel, id, lun); 1309 if (sdev && scsi_device_get(sdev)) 1310 sdev = NULL; 1311 spin_unlock_irqrestore(shost->host_lock, flags); 1312 1313 return sdev; 1314 } 1315 EXPORT_SYMBOL(scsi_device_lookup); 1316 1317 MODULE_DESCRIPTION("SCSI core"); 1318 MODULE_LICENSE("GPL"); 1319 1320 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR); 1321 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels"); 1322 1323 static int __init init_scsi(void) 1324 { 1325 int error; 1326 1327 error = scsi_init_queue(); 1328 if (error) 1329 return error; 1330 error = scsi_init_procfs(); 1331 if (error) 1332 goto cleanup_queue; 1333 error = scsi_init_devinfo(); 1334 if (error) 1335 goto cleanup_procfs; 1336 error = scsi_init_hosts(); 1337 if (error) 1338 goto cleanup_devlist; 1339 error = scsi_init_sysctl(); 1340 if (error) 1341 goto cleanup_hosts; 1342 error = scsi_sysfs_register(); 1343 if (error) 1344 goto cleanup_sysctl; 1345 1346 scsi_netlink_init(); 1347 1348 printk(KERN_NOTICE "SCSI subsystem initialized\n"); 1349 return 0; 1350 1351 cleanup_sysctl: 1352 scsi_exit_sysctl(); 1353 cleanup_hosts: 1354 scsi_exit_hosts(); 1355 cleanup_devlist: 1356 scsi_exit_devinfo(); 1357 cleanup_procfs: 1358 scsi_exit_procfs(); 1359 cleanup_queue: 1360 scsi_exit_queue(); 1361 printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n", 1362 -error); 1363 return error; 1364 } 1365 1366 static void __exit exit_scsi(void) 1367 { 1368 scsi_netlink_exit(); 1369 scsi_sysfs_unregister(); 1370 scsi_exit_sysctl(); 1371 scsi_exit_hosts(); 1372 scsi_exit_devinfo(); 1373 scsi_exit_procfs(); 1374 scsi_exit_queue(); 1375 } 1376 1377 subsys_initcall(init_scsi); 1378 module_exit(exit_scsi); 1379