← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/scsi/scsi.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

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