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/* 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 */
97static 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
124const 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
135EXPORT_SYMBOL(scsi_device_type);
136
137struct 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
147static 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
153static 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
160static 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 */
170static struct scsi_cmnd *
171scsi_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 */
197static void
198scsi_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 */
216static struct scsi_cmnd *
217scsi_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 */
245struct 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}
275EXPORT_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 */
284struct 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}
308EXPORT_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 */
316void __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}
334EXPORT_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 */
344void 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}
357EXPORT_SYMBOL(scsi_put_command);
358
359static 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
392static 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 */
426struct 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}
435EXPORT_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 */
446void 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}
467EXPORT_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 */
479int 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 */
509void 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
530void 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
565void 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 */
637void 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}
643EXPORT_SYMBOL(scsi_cmd_get_serial);
644
645/**
646 * scsi_dispatch_command - Dispatch a command to the low-level driver.
647 * @cmd: command block we are dispatching.
648 *
649 * Return: nonzero return request was rejected and device's queue needs to be
650 * plugged.
651 */
652int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
653{
654 struct Scsi_Host *host = cmd->device->host;
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 if (unlikely(host->shost_state == SHOST_DEL)) {
741 cmd->result = (DID_NO_CONNECT << 16);
742 scsi_done(cmd);
743 } else {
744 trace_scsi_dispatch_cmd_start(cmd);
745 cmd->scsi_done = scsi_done;
746 rtn = host->hostt->queuecommand(host, cmd);
747 }
748
749 if (rtn) {
750 trace_scsi_dispatch_cmd_error(cmd, rtn);
751 if (rtn != SCSI_MLQUEUE_DEVICE_BUSY &&
752 rtn != SCSI_MLQUEUE_TARGET_BUSY)
753 rtn = SCSI_MLQUEUE_HOST_BUSY;
754
755 scsi_queue_insert(cmd, rtn);
756
757 SCSI_LOG_MLQUEUE(3,
758 printk("queuecommand : request rejected\n"));
759 }
760
761 out:
762 SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
763 return rtn;
764}
765
766/**
767 * scsi_done - Enqueue the finished SCSI command into the done queue.
768 * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
769 * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
770 *
771 * Description: This function is the mid-level's (SCSI Core) interrupt routine,
772 * which regains ownership of the SCSI command (de facto) from a LLDD, and
773 * enqueues the command to the done queue for further processing.
774 *
775 * This is the producer of the done queue who enqueues at the tail.
776 *
777 * This function is interrupt context safe.
778 */
779static void scsi_done(struct scsi_cmnd *cmd)
780{
781 trace_scsi_dispatch_cmd_done(cmd);
782 blk_complete_request(cmd->request);
783}
784
785/* Move this to a header if it becomes more generally useful */
786static struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd)
787{
788 return *(struct scsi_driver **)cmd->request->rq_disk->private_data;
789}
790
791/**
792 * scsi_finish_command - cleanup and pass command back to upper layer
793 * @cmd: the command
794 *
795 * Description: Pass command off to upper layer for finishing of I/O
796 * request, waking processes that are waiting on results,
797 * etc.
798 */
799void scsi_finish_command(struct scsi_cmnd *cmd)
800{
801 struct scsi_device *sdev = cmd->device;
802 struct scsi_target *starget = scsi_target(sdev);
803 struct Scsi_Host *shost = sdev->host;
804 struct scsi_driver *drv;
805 unsigned int good_bytes;
806
807 scsi_device_unbusy(sdev);
808
809 /*
810 * Clear the flags which say that the device/host is no longer
811 * capable of accepting new commands. These are set in scsi_queue.c
812 * for both the queue full condition on a device, and for a
813 * host full condition on the host.
814 *
815 * XXX(hch): What about locking?
816 */
817 shost->host_blocked = 0;
818 starget->target_blocked = 0;
819 sdev->device_blocked = 0;
820
821 /*
822 * If we have valid sense information, then some kind of recovery
823 * must have taken place. Make a note of this.
824 */
825 if (SCSI_SENSE_VALID(cmd))
826 cmd->result |= (DRIVER_SENSE << 24);
827
828 SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
829 "Notifying upper driver of completion "
830 "(result %x)\n", cmd->result));
831
832 good_bytes = scsi_bufflen(cmd);
833 if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
834 int old_good_bytes = good_bytes;
835 drv = scsi_cmd_to_driver(cmd);
836 if (drv->done)
837 good_bytes = drv->done(cmd);
838 /*
839 * USB may not give sense identifying bad sector and
840 * simply return a residue instead, so subtract off the
841 * residue if drv->done() error processing indicates no
842 * change to the completion length.
843 */
844 if (good_bytes == old_good_bytes)
845 good_bytes -= scsi_get_resid(cmd);
846 }
847 scsi_io_completion(cmd, good_bytes);
848}
849EXPORT_SYMBOL(scsi_finish_command);
850
851/**
852 * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth
853 * @sdev: SCSI Device in question
854 * @tagged: Do we use tagged queueing (non-0) or do we treat
855 * this device as an untagged device (0)
856 * @tags: Number of tags allowed if tagged queueing enabled,
857 * or number of commands the low level driver can
858 * queue up in non-tagged mode (as per cmd_per_lun).
859 *
860 * Returns: Nothing
861 *
862 * Lock Status: None held on entry
863 *
864 * Notes: Low level drivers may call this at any time and we will do
865 * the right thing depending on whether or not the device is
866 * currently active and whether or not it even has the
867 * command blocks built yet.
868 */
869void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
870{
871 unsigned long flags;
872
873 /*
874 * refuse to set tagged depth to an unworkable size
875 */
876 if (tags <= 0)
877 return;
878
879 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
880
881 /*
882 * Check to see if the queue is managed by the block layer.
883 * If it is, and we fail to adjust the depth, exit.
884 *
885 * Do not resize the tag map if it is a host wide share bqt,
886 * because the size should be the hosts's can_queue. If there
887 * is more IO than the LLD's can_queue (so there are not enuogh
888 * tags) request_fn's host queue ready check will handle it.
889 */
890 if (!sdev->host->bqt) {
891 if (blk_queue_tagged(sdev->request_queue) &&
892 blk_queue_resize_tags(sdev->request_queue, tags) != 0)
893 goto out;
894 }
895
896 sdev->queue_depth = tags;
897 switch (tagged) {
898 case MSG_ORDERED_TAG:
899 sdev->ordered_tags = 1;
900 sdev->simple_tags = 1;
901 break;
902 case MSG_SIMPLE_TAG:
903 sdev->ordered_tags = 0;
904 sdev->simple_tags = 1;
905 break;
906 default:
907 sdev_printk(KERN_WARNING, sdev,
908 "scsi_adjust_queue_depth, bad queue type, "
909 "disabled\n");
910 case 0:
911 sdev->ordered_tags = sdev->simple_tags = 0;
912 sdev->queue_depth = tags;
913 break;
914 }
915 out:
916 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
917}
918EXPORT_SYMBOL(scsi_adjust_queue_depth);
919
920/**
921 * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
922 * @sdev: SCSI Device in question
923 * @depth: Current number of outstanding SCSI commands on this device,
924 * not counting the one returned as QUEUE_FULL.
925 *
926 * Description: This function will track successive QUEUE_FULL events on a
927 * specific SCSI device to determine if and when there is a
928 * need to adjust the queue depth on the device.
929 *
930 * Returns: 0 - No change needed, >0 - Adjust queue depth to this new depth,
931 * -1 - Drop back to untagged operation using host->cmd_per_lun
932 * as the untagged command depth
933 *
934 * Lock Status: None held on entry
935 *
936 * Notes: Low level drivers may call this at any time and we will do
937 * "The Right Thing." We are interrupt context safe.
938 */
939int scsi_track_queue_full(struct scsi_device *sdev, int depth)
940{
941
942 /*
943 * Don't let QUEUE_FULLs on the same
944 * jiffies count, they could all be from
945 * same event.
946 */
947 if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
948 return 0;
949
950 sdev->last_queue_full_time = jiffies;
951 if (sdev->last_queue_full_depth != depth) {
952 sdev->last_queue_full_count = 1;
953 sdev->last_queue_full_depth = depth;
954 } else {
955 sdev->last_queue_full_count++;
956 }
957
958 if (sdev->last_queue_full_count <= 10)
959 return 0;
960 if (sdev->last_queue_full_depth < 8) {
961 /* Drop back to untagged */
962 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
963 return -1;
964 }
965
966 if (sdev->ordered_tags)
967 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
968 else
969 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
970 return depth;
971}
972EXPORT_SYMBOL(scsi_track_queue_full);
973
974/**
975 * scsi_vpd_inquiry - Request a device provide us with a VPD page
976 * @sdev: The device to ask
977 * @buffer: Where to put the result
978 * @page: Which Vital Product Data to return
979 * @len: The length of the buffer
980 *
981 * This is an internal helper function. You probably want to use
982 * scsi_get_vpd_page instead.
983 *
984 * Returns 0 on success or a negative error number.
985 */
986static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
987 u8 page, unsigned len)
988{
989 int result;
990 unsigned char cmd[16];
991
992 cmd[0] = INQUIRY;
993 cmd[1] = 1; /* EVPD */
994 cmd[2] = page;
995 cmd[3] = len >> 8;
996 cmd[4] = len & 0xff;
997 cmd[5] = 0; /* Control byte */
998
999 /*
1000 * I'm not convinced we need to try quite this hard to get VPD, but
1001 * all the existing users tried this hard.
1002 */
1003 result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
1004 len, NULL, 30 * HZ, 3, NULL);
1005 if (result)
1006 return result;
1007
1008 /* Sanity check that we got the page back that we asked for */
1009 if (buffer[1] != page)
1010 return -EIO;
1011
1012 return 0;
1013}
1014
1015/**
1016 * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
1017 * @sdev: The device to ask
1018 * @page: Which Vital Product Data to return
1019 * @buf: where to store the VPD
1020 * @buf_len: number of bytes in the VPD buffer area
1021 *
1022 * SCSI devices may optionally supply Vital Product Data. Each 'page'
1023 * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
1024 * If the device supports this VPD page, this routine returns a pointer
1025 * to a buffer containing the data from that page. The caller is
1026 * responsible for calling kfree() on this pointer when it is no longer
1027 * needed. If we cannot retrieve the VPD page this routine returns %NULL.
1028 */
1029int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
1030 int buf_len)
1031{
1032 int i, result;
1033
1034 /* Ask for all the pages supported by this device */
1035 result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
1036 if (result)
1037 goto fail;
1038
1039 /* If the user actually wanted this page, we can skip the rest */
1040 if (page == 0)
1041 return 0;
1042
1043 for (i = 0; i < min((int)buf[3], buf_len - 4); i++)
1044 if (buf[i + 4] == page)
1045 goto found;
1046
1047 if (i < buf[3] && i >= buf_len - 4)
1048 /* ran off the end of the buffer, give us benefit of doubt */
1049 goto found;
1050 /* The device claims it doesn't support the requested page */
1051 goto fail;
1052
1053 found:
1054 result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
1055 if (result)
1056 goto fail;
1057
1058 return 0;
1059
1060 fail:
1061 return -EINVAL;
1062}
1063EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
1064
1065/**
1066 * scsi_device_get - get an additional reference to a scsi_device
1067 * @sdev: device to get a reference to
1068 *
1069 * Description: Gets a reference to the scsi_device and increments the use count
1070 * of the underlying LLDD module. You must hold host_lock of the
1071 * parent Scsi_Host or already have a reference when calling this.
1072 */
1073int scsi_device_get(struct scsi_device *sdev)
1074{
1075 if (sdev->sdev_state == SDEV_DEL)
1076 return -ENXIO;
1077 if (!get_device(&sdev->sdev_gendev))
1078 return -ENXIO;
1079 /* We can fail this if we're doing SCSI operations
1080 * from module exit (like cache flush) */
1081 try_module_get(sdev->host->hostt->module);
1082
1083 return 0;
1084}
1085EXPORT_SYMBOL(scsi_device_get);
1086
1087/**
1088 * scsi_device_put - release a reference to a scsi_device
1089 * @sdev: device to release a reference on.
1090 *
1091 * Description: Release a reference to the scsi_device and decrements the use
1092 * count of the underlying LLDD module. The device is freed once the last
1093 * user vanishes.
1094 */
1095void scsi_device_put(struct scsi_device *sdev)
1096{
1097#ifdef CONFIG_MODULE_UNLOAD
1098 struct module *module = sdev->host->hostt->module;
1099
1100 /* The module refcount will be zero if scsi_device_get()
1101 * was called from a module removal routine */
1102 if (module && module_refcount(module) != 0)
1103 module_put(module);
1104#endif
1105 put_device(&sdev->sdev_gendev);
1106}
1107EXPORT_SYMBOL(scsi_device_put);
1108
1109/* helper for shost_for_each_device, see that for documentation */
1110struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
1111 struct scsi_device *prev)
1112{
1113 struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
1114 struct scsi_device *next = NULL;
1115 unsigned long flags;
1116
1117 spin_lock_irqsave(shost->host_lock, flags);
1118 while (list->next != &shost->__devices) {
1119 next = list_entry(list->next, struct scsi_device, siblings);
1120 /* skip devices that we can't get a reference to */
1121 if (!scsi_device_get(next))
1122 break;
1123 next = NULL;
1124 list = list->next;
1125 }
1126 spin_unlock_irqrestore(shost->host_lock, flags);
1127
1128 if (prev)
1129 scsi_device_put(prev);
1130 return next;
1131}
1132EXPORT_SYMBOL(__scsi_iterate_devices);
1133
1134/**
1135 * starget_for_each_device - helper to walk all devices of a target
1136 * @starget: target whose devices we want to iterate over.
1137 * @data: Opaque passed to each function call.
1138 * @fn: Function to call on each device
1139 *
1140 * This traverses over each device of @starget. The devices have
1141 * a reference that must be released by scsi_host_put when breaking
1142 * out of the loop.
1143 */
1144void starget_for_each_device(struct scsi_target *starget, void *data,
1145 void (*fn)(struct scsi_device *, void *))
1146{
1147 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1148 struct scsi_device *sdev;
1149
1150 shost_for_each_device(sdev, shost) {
1151 if ((sdev->channel == starget->channel) &&
1152 (sdev->id == starget->id))
1153 fn(sdev, data);
1154 }
1155}
1156EXPORT_SYMBOL(starget_for_each_device);
1157
1158/**
1159 * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
1160 * @starget: target whose devices we want to iterate over.
1161 * @data: parameter for callback @fn()
1162 * @fn: callback function that is invoked for each device
1163 *
1164 * This traverses over each device of @starget. It does _not_
1165 * take a reference on the scsi_device, so the whole loop must be
1166 * protected by shost->host_lock.
1167 *
1168 * Note: The only reason why drivers would want to use this is because
1169 * they need to access the device list in irq context. Otherwise you
1170 * really want to use starget_for_each_device instead.
1171 **/
1172void __starget_for_each_device(struct scsi_target *starget, void *data,
1173 void (*fn)(struct scsi_device *, void *))
1174{
1175 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1176 struct scsi_device *sdev;
1177
1178 __shost_for_each_device(sdev, shost) {
1179 if ((sdev->channel == starget->channel) &&
1180 (sdev->id == starget->id))
1181 fn(sdev, data);
1182 }
1183}
1184EXPORT_SYMBOL(__starget_for_each_device);
1185
1186/**
1187 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1188 * @starget: SCSI target pointer
1189 * @lun: SCSI Logical Unit Number
1190 *
1191 * Description: Looks up the scsi_device with the specified @lun for a given
1192 * @starget. The returned scsi_device does not have an additional
1193 * reference. You must hold the host's host_lock over this call and
1194 * any access to the returned scsi_device. A scsi_device in state
1195 * SDEV_DEL is skipped.
1196 *
1197 * Note: The only reason why drivers should use this is because
1198 * they need to access the device list in irq context. Otherwise you
1199 * really want to use scsi_device_lookup_by_target instead.
1200 **/
1201struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
1202 uint lun)
1203{
1204 struct scsi_device *sdev;
1205
1206 list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
1207 if (sdev->sdev_state == SDEV_DEL)
1208 continue;
1209 if (sdev->lun ==lun)
1210 return sdev;
1211 }
1212
1213 return NULL;
1214}
1215EXPORT_SYMBOL(__scsi_device_lookup_by_target);
1216
1217/**
1218 * scsi_device_lookup_by_target - find a device given the target
1219 * @starget: SCSI target pointer
1220 * @lun: SCSI Logical Unit Number
1221 *
1222 * Description: Looks up the scsi_device with the specified @lun for a given
1223 * @starget. The returned scsi_device has an additional reference that
1224 * needs to be released with scsi_device_put once you're done with it.
1225 **/
1226struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
1227 uint lun)
1228{
1229 struct scsi_device *sdev;
1230 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1231 unsigned long flags;
1232
1233 spin_lock_irqsave(shost->host_lock, flags);
1234 sdev = __scsi_device_lookup_by_target(starget, lun);
1235 if (sdev && scsi_device_get(sdev))
1236 sdev = NULL;
1237 spin_unlock_irqrestore(shost->host_lock, flags);
1238
1239 return sdev;
1240}
1241EXPORT_SYMBOL(scsi_device_lookup_by_target);
1242
1243/**
1244 * __scsi_device_lookup - find a device given the host (UNLOCKED)
1245 * @shost: SCSI host pointer
1246 * @channel: SCSI channel (zero if only one channel)
1247 * @id: SCSI target number (physical unit number)
1248 * @lun: SCSI Logical Unit Number
1249 *
1250 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1251 * for a given host. The returned scsi_device does not have an additional
1252 * reference. You must hold the host's host_lock over this call and any access
1253 * to the returned scsi_device.
1254 *
1255 * Note: The only reason why drivers would want to use this is because
1256 * they need to access the device list in irq context. Otherwise you
1257 * really want to use scsi_device_lookup instead.
1258 **/
1259struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1260 uint channel, uint id, uint lun)
1261{
1262 struct scsi_device *sdev;
1263
1264 list_for_each_entry(sdev, &shost->__devices, siblings) {
1265 if (sdev->channel == channel && sdev->id == id &&
1266 sdev->lun ==lun)
1267 return sdev;
1268 }
1269
1270 return NULL;
1271}
1272EXPORT_SYMBOL(__scsi_device_lookup);
1273
1274/**
1275 * scsi_device_lookup - find a device given the host
1276 * @shost: SCSI host pointer
1277 * @channel: SCSI channel (zero if only one channel)
1278 * @id: SCSI target number (physical unit number)
1279 * @lun: SCSI Logical Unit Number
1280 *
1281 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1282 * for a given host. The returned scsi_device has an additional reference that
1283 * needs to be released with scsi_device_put once you're done with it.
1284 **/
1285struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1286 uint channel, uint id, uint lun)
1287{
1288 struct scsi_device *sdev;
1289 unsigned long flags;
1290
1291 spin_lock_irqsave(shost->host_lock, flags);
1292 sdev = __scsi_device_lookup(shost, channel, id, lun);
1293 if (sdev && scsi_device_get(sdev))
1294 sdev = NULL;
1295 spin_unlock_irqrestore(shost->host_lock, flags);
1296
1297 return sdev;
1298}
1299EXPORT_SYMBOL(scsi_device_lookup);
1300
1301MODULE_DESCRIPTION("SCSI core");
1302MODULE_LICENSE("GPL");
1303
1304module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1305MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1306
1307static int __init init_scsi(void)
1308{
1309 int error;
1310
1311 error = scsi_init_queue();
1312 if (error)
1313 return error;
1314 error = scsi_init_procfs();
1315 if (error)
1316 goto cleanup_queue;
1317 error = scsi_init_devinfo();
1318 if (error)
1319 goto cleanup_procfs;
1320 error = scsi_init_hosts();
1321 if (error)
1322 goto cleanup_devlist;
1323 error = scsi_init_sysctl();
1324 if (error)
1325 goto cleanup_hosts;
1326 error = scsi_sysfs_register();
1327 if (error)
1328 goto cleanup_sysctl;
1329
1330 scsi_netlink_init();
1331
1332 printk(KERN_NOTICE "SCSI subsystem initialized\n");
1333 return 0;
1334
1335cleanup_sysctl:
1336 scsi_exit_sysctl();
1337cleanup_hosts:
1338 scsi_exit_hosts();
1339cleanup_devlist:
1340 scsi_exit_devinfo();
1341cleanup_procfs:
1342 scsi_exit_procfs();
1343cleanup_queue:
1344 scsi_exit_queue();
1345 printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1346 -error);
1347 return error;
1348}
1349
1350static void __exit exit_scsi(void)
1351{
1352 scsi_netlink_exit();
1353 scsi_sysfs_unregister();
1354 scsi_exit_sysctl();
1355 scsi_exit_hosts();
1356 scsi_exit_devinfo();
1357 scsi_exit_procfs();
1358 scsi_exit_queue();
1359}
1360
1361subsys_initcall(init_scsi);
1362module_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 <asm/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 result -= SCSI_VPD_HEADER_SIZE;
354 if (!memchr(&vpd[SCSI_VPD_HEADER_SIZE], page, result))
355 return 0;
356 }
357 /*
358 * Fetch the VPD page header to find out how big the page
359 * is. This is done to prevent problems on legacy devices
360 * which can not handle allocation lengths as large as
361 * potentially requested by the caller.
362 */
363 result = scsi_vpd_inquiry(sdev, vpd, page, SCSI_VPD_HEADER_SIZE);
364 if (result < 0)
365 return 0;
366
367 if (result < SCSI_VPD_HEADER_SIZE) {
368 dev_warn_once(&sdev->sdev_gendev,
369 "%s: short VPD page 0x%02x length: %d bytes\n",
370 __func__, page, result);
371 return 0;
372 }
373
374 return result;
375}
376
377/**
378 * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
379 * @sdev: The device to ask
380 * @page: Which Vital Product Data to return
381 * @buf: where to store the VPD
382 * @buf_len: number of bytes in the VPD buffer area
383 *
384 * SCSI devices may optionally supply Vital Product Data. Each 'page'
385 * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
386 * If the device supports this VPD page, this routine fills @buf
387 * with the data from that page and return 0. If the VPD page is not
388 * supported or its content cannot be retrieved, -EINVAL is returned.
389 */
390int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
391 int buf_len)
392{
393 int result, vpd_len;
394
395 if (!scsi_device_supports_vpd(sdev))
396 return -EINVAL;
397
398 vpd_len = scsi_get_vpd_size(sdev, page);
399 if (vpd_len <= 0)
400 return -EINVAL;
401
402 vpd_len = min(vpd_len, buf_len);
403
404 /*
405 * Fetch the actual page. Since the appropriate size was reported
406 * by the device it is now safe to ask for something bigger.
407 */
408 memset(buf, 0, buf_len);
409 result = scsi_vpd_inquiry(sdev, buf, page, vpd_len);
410 if (result < 0)
411 return -EINVAL;
412 else if (result > vpd_len)
413 dev_warn_once(&sdev->sdev_gendev,
414 "%s: VPD page 0x%02x result %d > %d bytes\n",
415 __func__, page, result, vpd_len);
416
417 return 0;
418}
419EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
420
421/**
422 * scsi_get_vpd_buf - Get Vital Product Data from a SCSI device
423 * @sdev: The device to ask
424 * @page: Which Vital Product Data to return
425 *
426 * Returns %NULL upon failure.
427 */
428static struct scsi_vpd *scsi_get_vpd_buf(struct scsi_device *sdev, u8 page)
429{
430 struct scsi_vpd *vpd_buf;
431 int vpd_len, result;
432
433 vpd_len = scsi_get_vpd_size(sdev, page);
434 if (vpd_len <= 0)
435 return NULL;
436
437retry_pg:
438 /*
439 * Fetch the actual page. Since the appropriate size was reported
440 * by the device it is now safe to ask for something bigger.
441 */
442 vpd_buf = kmalloc(sizeof(*vpd_buf) + vpd_len, GFP_KERNEL);
443 if (!vpd_buf)
444 return NULL;
445
446 result = scsi_vpd_inquiry(sdev, vpd_buf->data, page, vpd_len);
447 if (result < 0) {
448 kfree(vpd_buf);
449 return NULL;
450 }
451 if (result > vpd_len) {
452 dev_warn_once(&sdev->sdev_gendev,
453 "%s: VPD page 0x%02x result %d > %d bytes\n",
454 __func__, page, result, vpd_len);
455 vpd_len = result;
456 kfree(vpd_buf);
457 goto retry_pg;
458 }
459
460 vpd_buf->len = result;
461
462 return vpd_buf;
463}
464
465static void scsi_update_vpd_page(struct scsi_device *sdev, u8 page,
466 struct scsi_vpd __rcu **sdev_vpd_buf)
467{
468 struct scsi_vpd *vpd_buf;
469
470 vpd_buf = scsi_get_vpd_buf(sdev, page);
471 if (!vpd_buf)
472 return;
473
474 mutex_lock(&sdev->inquiry_mutex);
475 vpd_buf = rcu_replace_pointer(*sdev_vpd_buf, vpd_buf,
476 lockdep_is_held(&sdev->inquiry_mutex));
477 mutex_unlock(&sdev->inquiry_mutex);
478
479 if (vpd_buf)
480 kfree_rcu(vpd_buf, rcu);
481}
482
483/**
484 * scsi_attach_vpd - Attach Vital Product Data to a SCSI device structure
485 * @sdev: The device to ask
486 *
487 * Attach the 'Device Identification' VPD page (0x83) and the
488 * 'Unit Serial Number' VPD page (0x80) to a SCSI device
489 * structure. This information can be used to identify the device
490 * uniquely.
491 */
492void scsi_attach_vpd(struct scsi_device *sdev)
493{
494 int i;
495 struct scsi_vpd *vpd_buf;
496
497 if (!scsi_device_supports_vpd(sdev))
498 return;
499
500 /* Ask for all the pages supported by this device */
501 vpd_buf = scsi_get_vpd_buf(sdev, 0);
502 if (!vpd_buf)
503 return;
504
505 for (i = 4; i < vpd_buf->len; i++) {
506 if (vpd_buf->data[i] == 0x0)
507 scsi_update_vpd_page(sdev, 0x0, &sdev->vpd_pg0);
508 if (vpd_buf->data[i] == 0x80)
509 scsi_update_vpd_page(sdev, 0x80, &sdev->vpd_pg80);
510 if (vpd_buf->data[i] == 0x83)
511 scsi_update_vpd_page(sdev, 0x83, &sdev->vpd_pg83);
512 if (vpd_buf->data[i] == 0x89)
513 scsi_update_vpd_page(sdev, 0x89, &sdev->vpd_pg89);
514 if (vpd_buf->data[i] == 0xb0)
515 scsi_update_vpd_page(sdev, 0xb0, &sdev->vpd_pgb0);
516 if (vpd_buf->data[i] == 0xb1)
517 scsi_update_vpd_page(sdev, 0xb1, &sdev->vpd_pgb1);
518 if (vpd_buf->data[i] == 0xb2)
519 scsi_update_vpd_page(sdev, 0xb2, &sdev->vpd_pgb2);
520 if (vpd_buf->data[i] == 0xb7)
521 scsi_update_vpd_page(sdev, 0xb7, &sdev->vpd_pgb7);
522 }
523 kfree(vpd_buf);
524}
525
526/**
527 * scsi_report_opcode - Find out if a given command is supported
528 * @sdev: scsi device to query
529 * @buffer: scratch buffer (must be at least 20 bytes long)
530 * @len: length of buffer
531 * @opcode: opcode for the command to look up
532 * @sa: service action for the command to look up
533 *
534 * Uses the REPORT SUPPORTED OPERATION CODES to check support for the
535 * command identified with @opcode and @sa. If the command does not
536 * have a service action, @sa must be 0. Returns -EINVAL if RSOC fails,
537 * 0 if the command is not supported and 1 if the device claims to
538 * support the command.
539 */
540int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
541 unsigned int len, unsigned char opcode,
542 unsigned short sa)
543{
544 unsigned char cmd[16];
545 struct scsi_sense_hdr sshdr;
546 int result, request_len;
547 const struct scsi_exec_args exec_args = {
548 .sshdr = &sshdr,
549 };
550
551 if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
552 return -EINVAL;
553
554 /* RSOC header + size of command we are asking about */
555 request_len = 4 + COMMAND_SIZE(opcode);
556 if (request_len > len) {
557 dev_warn_once(&sdev->sdev_gendev,
558 "%s: len %u bytes, opcode 0x%02x needs %u\n",
559 __func__, len, opcode, request_len);
560 return -EINVAL;
561 }
562
563 memset(cmd, 0, 16);
564 cmd[0] = MAINTENANCE_IN;
565 cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
566 if (!sa) {
567 cmd[2] = 1; /* One command format */
568 cmd[3] = opcode;
569 } else {
570 cmd[2] = 3; /* One command format with service action */
571 cmd[3] = opcode;
572 put_unaligned_be16(sa, &cmd[4]);
573 }
574 put_unaligned_be32(request_len, &cmd[6]);
575 memset(buffer, 0, len);
576
577 result = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_IN, buffer,
578 request_len, 30 * HZ, 3, &exec_args);
579 if (result < 0)
580 return result;
581 if (result && scsi_sense_valid(&sshdr) &&
582 sshdr.sense_key == ILLEGAL_REQUEST &&
583 (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
584 return -EINVAL;
585
586 if ((buffer[1] & 3) == 3) /* Command supported */
587 return 1;
588
589 return 0;
590}
591EXPORT_SYMBOL(scsi_report_opcode);
592
593#define SCSI_CDL_CHECK_BUF_LEN 64
594
595static bool scsi_cdl_check_cmd(struct scsi_device *sdev, u8 opcode, u16 sa,
596 unsigned char *buf)
597{
598 int ret;
599 u8 cdlp;
600
601 /* Check operation code */
602 ret = scsi_report_opcode(sdev, buf, SCSI_CDL_CHECK_BUF_LEN, opcode, sa);
603 if (ret <= 0)
604 return false;
605
606 if ((buf[1] & 0x03) != 0x03)
607 return false;
608
609 /*
610 * See SPC-6, One_command parameter data format for
611 * REPORT SUPPORTED OPERATION CODES. We have the following cases
612 * depending on rwcdlp (buf[0] & 0x01) value:
613 * - rwcdlp == 0: then cdlp indicates support for the A mode page when
614 * it is equal to 1 and for the B mode page when it is
615 * equal to 2.
616 * - rwcdlp == 1: then cdlp indicates support for the T2A mode page
617 * when it is equal to 1 and for the T2B mode page when
618 * it is equal to 2.
619 * Overall, to detect support for command duration limits, we only need
620 * to check that cdlp is 1 or 2.
621 */
622 cdlp = (buf[1] & 0x18) >> 3;
623
624 return cdlp == 0x01 || cdlp == 0x02;
625}
626
627/**
628 * scsi_cdl_check - Check if a SCSI device supports Command Duration Limits
629 * @sdev: The device to check
630 */
631void scsi_cdl_check(struct scsi_device *sdev)
632{
633 bool cdl_supported;
634 unsigned char *buf;
635
636 /*
637 * Support for CDL was defined in SPC-5. Ignore devices reporting an
638 * lower SPC version. This also avoids problems with old drives choking
639 * on MAINTENANCE_IN / MI_REPORT_SUPPORTED_OPERATION_CODES with a
640 * service action specified, as done in scsi_cdl_check_cmd().
641 */
642 if (sdev->scsi_level < SCSI_SPC_5) {
643 sdev->cdl_supported = 0;
644 return;
645 }
646
647 buf = kmalloc(SCSI_CDL_CHECK_BUF_LEN, GFP_KERNEL);
648 if (!buf) {
649 sdev->cdl_supported = 0;
650 return;
651 }
652
653 /* Check support for READ_16, WRITE_16, READ_32 and WRITE_32 commands */
654 cdl_supported =
655 scsi_cdl_check_cmd(sdev, READ_16, 0, buf) ||
656 scsi_cdl_check_cmd(sdev, WRITE_16, 0, buf) ||
657 scsi_cdl_check_cmd(sdev, VARIABLE_LENGTH_CMD, READ_32, buf) ||
658 scsi_cdl_check_cmd(sdev, VARIABLE_LENGTH_CMD, WRITE_32, buf);
659 if (cdl_supported) {
660 /*
661 * We have CDL support: force the use of READ16/WRITE16.
662 * READ32 and WRITE32 will be used for devices that support
663 * the T10_PI_TYPE2_PROTECTION protection type.
664 */
665 sdev->use_16_for_rw = 1;
666 sdev->use_10_for_rw = 0;
667
668 sdev->cdl_supported = 1;
669 } else {
670 sdev->cdl_supported = 0;
671 }
672
673 kfree(buf);
674}
675
676/**
677 * scsi_cdl_enable - Enable or disable a SCSI device supports for Command
678 * Duration Limits
679 * @sdev: The target device
680 * @enable: the target state
681 */
682int scsi_cdl_enable(struct scsi_device *sdev, bool enable)
683{
684 struct scsi_mode_data data;
685 struct scsi_sense_hdr sshdr;
686 struct scsi_vpd *vpd;
687 bool is_ata = false;
688 char buf[64];
689 int ret;
690
691 if (!sdev->cdl_supported)
692 return -EOPNOTSUPP;
693
694 rcu_read_lock();
695 vpd = rcu_dereference(sdev->vpd_pg89);
696 if (vpd)
697 is_ata = true;
698 rcu_read_unlock();
699
700 /*
701 * For ATA devices, CDL needs to be enabled with a SET FEATURES command.
702 */
703 if (is_ata) {
704 char *buf_data;
705 int len;
706
707 ret = scsi_mode_sense(sdev, 0x08, 0x0a, 0xf2, buf, sizeof(buf),
708 5 * HZ, 3, &data, NULL);
709 if (ret)
710 return -EINVAL;
711
712 /* Enable CDL using the ATA feature page */
713 len = min_t(size_t, sizeof(buf),
714 data.length - data.header_length -
715 data.block_descriptor_length);
716 buf_data = buf + data.header_length +
717 data.block_descriptor_length;
718 if (enable)
719 buf_data[4] = 0x02;
720 else
721 buf_data[4] = 0;
722
723 ret = scsi_mode_select(sdev, 1, 0, buf_data, len, 5 * HZ, 3,
724 &data, &sshdr);
725 if (ret) {
726 if (ret > 0 && scsi_sense_valid(&sshdr))
727 scsi_print_sense_hdr(sdev,
728 dev_name(&sdev->sdev_gendev), &sshdr);
729 return ret;
730 }
731 }
732
733 sdev->cdl_enable = enable;
734
735 return 0;
736}
737
738/**
739 * scsi_device_get - get an additional reference to a scsi_device
740 * @sdev: device to get a reference to
741 *
742 * Description: Gets a reference to the scsi_device and increments the use count
743 * of the underlying LLDD module. You must hold host_lock of the
744 * parent Scsi_Host or already have a reference when calling this.
745 *
746 * This will fail if a device is deleted or cancelled, or when the LLD module
747 * is in the process of being unloaded.
748 */
749int scsi_device_get(struct scsi_device *sdev)
750{
751 if (sdev->sdev_state == SDEV_DEL || sdev->sdev_state == SDEV_CANCEL)
752 goto fail;
753 if (!try_module_get(sdev->host->hostt->module))
754 goto fail;
755 if (!get_device(&sdev->sdev_gendev))
756 goto fail_put_module;
757 return 0;
758
759fail_put_module:
760 module_put(sdev->host->hostt->module);
761fail:
762 return -ENXIO;
763}
764EXPORT_SYMBOL(scsi_device_get);
765
766/**
767 * scsi_device_put - release a reference to a scsi_device
768 * @sdev: device to release a reference on.
769 *
770 * Description: Release a reference to the scsi_device and decrements the use
771 * count of the underlying LLDD module. The device is freed once the last
772 * user vanishes.
773 */
774void scsi_device_put(struct scsi_device *sdev)
775{
776 struct module *mod = sdev->host->hostt->module;
777
778 put_device(&sdev->sdev_gendev);
779 module_put(mod);
780}
781EXPORT_SYMBOL(scsi_device_put);
782
783/* helper for shost_for_each_device, see that for documentation */
784struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
785 struct scsi_device *prev)
786{
787 struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
788 struct scsi_device *next = NULL;
789 unsigned long flags;
790
791 spin_lock_irqsave(shost->host_lock, flags);
792 while (list->next != &shost->__devices) {
793 next = list_entry(list->next, struct scsi_device, siblings);
794 /* skip devices that we can't get a reference to */
795 if (!scsi_device_get(next))
796 break;
797 next = NULL;
798 list = list->next;
799 }
800 spin_unlock_irqrestore(shost->host_lock, flags);
801
802 if (prev)
803 scsi_device_put(prev);
804 return next;
805}
806EXPORT_SYMBOL(__scsi_iterate_devices);
807
808/**
809 * starget_for_each_device - helper to walk all devices of a target
810 * @starget: target whose devices we want to iterate over.
811 * @data: Opaque passed to each function call.
812 * @fn: Function to call on each device
813 *
814 * This traverses over each device of @starget. The devices have
815 * a reference that must be released by scsi_host_put when breaking
816 * out of the loop.
817 */
818void starget_for_each_device(struct scsi_target *starget, void *data,
819 void (*fn)(struct scsi_device *, void *))
820{
821 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
822 struct scsi_device *sdev;
823
824 shost_for_each_device(sdev, shost) {
825 if ((sdev->channel == starget->channel) &&
826 (sdev->id == starget->id))
827 fn(sdev, data);
828 }
829}
830EXPORT_SYMBOL(starget_for_each_device);
831
832/**
833 * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
834 * @starget: target whose devices we want to iterate over.
835 * @data: parameter for callback @fn()
836 * @fn: callback function that is invoked for each device
837 *
838 * This traverses over each device of @starget. It does _not_
839 * take a reference on the scsi_device, so the whole loop must be
840 * protected by shost->host_lock.
841 *
842 * Note: The only reason why drivers would want to use this is because
843 * they need to access the device list in irq context. Otherwise you
844 * really want to use starget_for_each_device instead.
845 **/
846void __starget_for_each_device(struct scsi_target *starget, void *data,
847 void (*fn)(struct scsi_device *, void *))
848{
849 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
850 struct scsi_device *sdev;
851
852 __shost_for_each_device(sdev, shost) {
853 if ((sdev->channel == starget->channel) &&
854 (sdev->id == starget->id))
855 fn(sdev, data);
856 }
857}
858EXPORT_SYMBOL(__starget_for_each_device);
859
860/**
861 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
862 * @starget: SCSI target pointer
863 * @lun: SCSI Logical Unit Number
864 *
865 * Description: Looks up the scsi_device with the specified @lun for a given
866 * @starget. The returned scsi_device does not have an additional
867 * reference. You must hold the host's host_lock over this call and
868 * any access to the returned scsi_device. A scsi_device in state
869 * SDEV_DEL is skipped.
870 *
871 * Note: The only reason why drivers should use this is because
872 * they need to access the device list in irq context. Otherwise you
873 * really want to use scsi_device_lookup_by_target instead.
874 **/
875struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
876 u64 lun)
877{
878 struct scsi_device *sdev;
879
880 list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
881 if (sdev->sdev_state == SDEV_DEL)
882 continue;
883 if (sdev->lun ==lun)
884 return sdev;
885 }
886
887 return NULL;
888}
889EXPORT_SYMBOL(__scsi_device_lookup_by_target);
890
891/**
892 * scsi_device_lookup_by_target - find a device given the target
893 * @starget: SCSI target pointer
894 * @lun: SCSI Logical Unit Number
895 *
896 * Description: Looks up the scsi_device with the specified @lun for a given
897 * @starget. The returned scsi_device has an additional reference that
898 * needs to be released with scsi_device_put once you're done with it.
899 **/
900struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
901 u64 lun)
902{
903 struct scsi_device *sdev;
904 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
905 unsigned long flags;
906
907 spin_lock_irqsave(shost->host_lock, flags);
908 sdev = __scsi_device_lookup_by_target(starget, lun);
909 if (sdev && scsi_device_get(sdev))
910 sdev = NULL;
911 spin_unlock_irqrestore(shost->host_lock, flags);
912
913 return sdev;
914}
915EXPORT_SYMBOL(scsi_device_lookup_by_target);
916
917/**
918 * __scsi_device_lookup - find a device given the host (UNLOCKED)
919 * @shost: SCSI host pointer
920 * @channel: SCSI channel (zero if only one channel)
921 * @id: SCSI target number (physical unit number)
922 * @lun: SCSI Logical Unit Number
923 *
924 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
925 * for a given host. The returned scsi_device does not have an additional
926 * reference. You must hold the host's host_lock over this call and any access
927 * to the returned scsi_device.
928 *
929 * Note: The only reason why drivers would want to use this is because
930 * they need to access the device list in irq context. Otherwise you
931 * really want to use scsi_device_lookup instead.
932 **/
933struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
934 uint channel, uint id, u64 lun)
935{
936 struct scsi_device *sdev;
937
938 list_for_each_entry(sdev, &shost->__devices, siblings) {
939 if (sdev->sdev_state == SDEV_DEL)
940 continue;
941 if (sdev->channel == channel && sdev->id == id &&
942 sdev->lun ==lun)
943 return sdev;
944 }
945
946 return NULL;
947}
948EXPORT_SYMBOL(__scsi_device_lookup);
949
950/**
951 * scsi_device_lookup - find a device given the host
952 * @shost: SCSI host pointer
953 * @channel: SCSI channel (zero if only one channel)
954 * @id: SCSI target number (physical unit number)
955 * @lun: SCSI Logical Unit Number
956 *
957 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
958 * for a given host. The returned scsi_device has an additional reference that
959 * needs to be released with scsi_device_put once you're done with it.
960 **/
961struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
962 uint channel, uint id, u64 lun)
963{
964 struct scsi_device *sdev;
965 unsigned long flags;
966
967 spin_lock_irqsave(shost->host_lock, flags);
968 sdev = __scsi_device_lookup(shost, channel, id, lun);
969 if (sdev && scsi_device_get(sdev))
970 sdev = NULL;
971 spin_unlock_irqrestore(shost->host_lock, flags);
972
973 return sdev;
974}
975EXPORT_SYMBOL(scsi_device_lookup);
976
977MODULE_DESCRIPTION("SCSI core");
978MODULE_LICENSE("GPL");
979
980module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
981MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
982
983static int __init init_scsi(void)
984{
985 int error;
986
987 error = scsi_init_procfs();
988 if (error)
989 goto cleanup_queue;
990 error = scsi_init_devinfo();
991 if (error)
992 goto cleanup_procfs;
993 error = scsi_init_hosts();
994 if (error)
995 goto cleanup_devlist;
996 error = scsi_init_sysctl();
997 if (error)
998 goto cleanup_hosts;
999 error = scsi_sysfs_register();
1000 if (error)
1001 goto cleanup_sysctl;
1002
1003 scsi_netlink_init();
1004
1005 printk(KERN_NOTICE "SCSI subsystem initialized\n");
1006 return 0;
1007
1008cleanup_sysctl:
1009 scsi_exit_sysctl();
1010cleanup_hosts:
1011 scsi_exit_hosts();
1012cleanup_devlist:
1013 scsi_exit_devinfo();
1014cleanup_procfs:
1015 scsi_exit_procfs();
1016cleanup_queue:
1017 scsi_exit_queue();
1018 printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1019 -error);
1020 return error;
1021}
1022
1023static void __exit exit_scsi(void)
1024{
1025 scsi_netlink_exit();
1026 scsi_sysfs_unregister();
1027 scsi_exit_sysctl();
1028 scsi_exit_hosts();
1029 scsi_exit_devinfo();
1030 scsi_exit_procfs();
1031 scsi_exit_queue();
1032}
1033
1034subsys_initcall(init_scsi);
1035module_exit(exit_scsi);