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