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