← Back to branch summary

~ubuntu-branches/ubuntu/utopic/linux-ti-omap/utopic

« back to all changes in this revision

Viewing changes to drivers/scsi/scsi.c

  • Committer: Bazaar Package Importer
  • Author(s): Amit Kucheria, Amit Kucheria
  • Date: 2010-03-10 02:28:15 UTC
  • Revision ID: james.westby@ubuntu.com-20100310022815-7sd3gwvn5kenaq33
Tags: 2.6.33-500.1
[ Amit Kucheria ]

* Initial release of a 2.6.33-based OMAP kernel
* UBUNTU: [Upstream] Fix omap 1-wire driver compilation
* UBUNTU: ubuntu: AppArmor -- update to mainline 2010-03-04

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