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