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