Diff markup
1 /* 1 /*
2 * scsi.c Copyright (C) 1992 Drew Eckhardt 2 * scsi.c Copyright (C) 1992 Drew Eckhardt
3 * Copyright (C) 1993, 1994, 1995, 199 3 * Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
4 * Copyright (C) 2002, 2003 Christoph 4 * Copyright (C) 2002, 2003 Christoph Hellwig
5 * 5 *
6 * generic mid-level SCSI driver 6 * generic mid-level SCSI driver
7 * Initial versions: Drew Eckhardt 7 * Initial versions: Drew Eckhardt
8 * Subsequent revisions: Eric Youngdale 8 * Subsequent revisions: Eric Youngdale
9 * 9 *
10 * <drew@colorado.edu> 10 * <drew@colorado.edu>
11 * 11 *
12 * Bug correction thanks go to : 12 * Bug correction thanks go to :
13 * Rik Faith <faith@cs.unc.edu> 13 * Rik Faith <faith@cs.unc.edu>
14 * Tommy Thorn <tthorn> 14 * Tommy Thorn <tthorn>
15 * Thomas Wuensche <tw@fgb1.fgb.mw.tu-mue 15 * Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de>
16 * 16 *
17 * Modified by Eric Youngdale eric@andante.or 17 * Modified by Eric Youngdale eric@andante.org or ericy@gnu.ai.mit.edu to
18 * add scatter-gather, multiple outstanding r 18 * add scatter-gather, multiple outstanding request, and other
19 * enhancements. 19 * enhancements.
20 * 20 *
21 * Native multichannel, wide scsi, /proc/scsi 21 * Native multichannel, wide scsi, /proc/scsi and hot plugging
22 * support added by Michael Neuffer <mike@i-c 22 * support added by Michael Neuffer <mike@i-connect.net>
23 * 23 *
24 * Added request_module("scsi_hostadapter") f 24 * Added request_module("scsi_hostadapter") for kerneld:
25 * (Put an "alias scsi_hostadapter your_hosta 25 * (Put an "alias scsi_hostadapter your_hostadapter" in /etc/modprobe.conf)
26 * Bjorn Ekwall <bj0rn@blox.se> 26 * Bjorn Ekwall <bj0rn@blox.se>
27 * (changed to kmod) 27 * (changed to kmod)
28 * 28 *
29 * Major improvements to the timeout, abort, 29 * Major improvements to the timeout, abort, and reset processing,
30 * as well as performance modifications for l 30 * as well as performance modifications for large queue depths by
31 * Leonard N. Zubkoff <lnz@dandelion.com> 31 * Leonard N. Zubkoff <lnz@dandelion.com>
32 * 32 *
33 * Converted cli() code to spinlocks, Ingo Mo 33 * Converted cli() code to spinlocks, Ingo Molnar
34 * 34 *
35 * Jiffies wrap fixes (host->resetting), 3 De 35 * Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
36 * 36 *
37 * out_of_space hacks, D. Gilbert (dpg) 99060 37 * out_of_space hacks, D. Gilbert (dpg) 990608
38 */ 38 */
39 39
40 #include <linux/module.h> 40 #include <linux/module.h>
41 #include <linux/moduleparam.h> 41 #include <linux/moduleparam.h>
42 #include <linux/kernel.h> 42 #include <linux/kernel.h>
>> 43 #include <linux/sched.h>
43 #include <linux/timer.h> 44 #include <linux/timer.h>
44 #include <linux/string.h> 45 #include <linux/string.h>
45 #include <linux/slab.h> 46 #include <linux/slab.h>
46 #include <linux/blkdev.h> 47 #include <linux/blkdev.h>
47 #include <linux/delay.h> 48 #include <linux/delay.h>
48 #include <linux/init.h> 49 #include <linux/init.h>
49 #include <linux/completion.h> 50 #include <linux/completion.h>
>> 51 #include <linux/devfs_fs_kernel.h>
50 #include <linux/unistd.h> 52 #include <linux/unistd.h>
51 #include <linux/spinlock.h> 53 #include <linux/spinlock.h>
52 #include <linux/kmod.h> 54 #include <linux/kmod.h>
53 #include <linux/interrupt.h> 55 #include <linux/interrupt.h>
54 #include <linux/notifier.h> 56 #include <linux/notifier.h>
55 #include <linux/cpu.h> 57 #include <linux/cpu.h>
56 #include <linux/mutex.h> <<
57 58
58 #include <scsi/scsi.h> 59 #include <scsi/scsi.h>
59 #include <scsi/scsi_cmnd.h> 60 #include <scsi/scsi_cmnd.h>
60 #include <scsi/scsi_dbg.h> 61 #include <scsi/scsi_dbg.h>
61 #include <scsi/scsi_device.h> 62 #include <scsi/scsi_device.h>
62 #include <scsi/scsi_driver.h> <<
63 #include <scsi/scsi_eh.h> 63 #include <scsi/scsi_eh.h>
64 #include <scsi/scsi_host.h> 64 #include <scsi/scsi_host.h>
65 #include <scsi/scsi_tcq.h> 65 #include <scsi/scsi_tcq.h>
>> 66 #include <scsi/scsi_request.h>
66 67
67 #include "scsi_priv.h" 68 #include "scsi_priv.h"
68 #include "scsi_logging.h" 69 #include "scsi_logging.h"
69 70
70 static void scsi_done(struct scsi_cmnd *cmd); <<
71 71
72 /* 72 /*
73 * Definitions and constants. 73 * Definitions and constants.
74 */ 74 */
75 75
76 #define MIN_RESET_DELAY (2*HZ) 76 #define MIN_RESET_DELAY (2*HZ)
77 77
78 /* Do not call reset on error if we just did a 78 /* Do not call reset on error if we just did a reset within 15 sec. */
79 #define MIN_RESET_PERIOD (15*HZ) 79 #define MIN_RESET_PERIOD (15*HZ)
80 80
81 /* 81 /*
82 * Macro to determine the size of SCSI command 82 * Macro to determine the size of SCSI command. This macro takes vendor
83 * unique commands into account. SCSI commands 83 * unique commands into account. SCSI commands in groups 6 and 7 are
84 * vendor unique and we will depend upon the c 84 * vendor unique and we will depend upon the command length being
85 * supplied correctly in cmd_len. 85 * supplied correctly in cmd_len.
86 */ 86 */
87 #define CDB_SIZE(cmd) (((((cmd)->cmnd[0] >> 87 #define CDB_SIZE(cmd) (((((cmd)->cmnd[0] >> 5) & 7) < 6) ? \
88 COMMAND_SIZE(( 88 COMMAND_SIZE((cmd)->cmnd[0]) : (cmd)->cmd_len)
89 89
90 /* 90 /*
>> 91 * Data declarations.
>> 92 */
>> 93 unsigned long scsi_pid;
>> 94 static unsigned long serial_number;
>> 95
>> 96 /*
91 * Note - the initial logging level can be set 97 * Note - the initial logging level can be set here to log events at boot time.
92 * After the system is up, you may enable logg 98 * After the system is up, you may enable logging via the /proc interface.
93 */ 99 */
94 unsigned int scsi_logging_level; 100 unsigned int scsi_logging_level;
95 #if defined(CONFIG_SCSI_LOGGING) 101 #if defined(CONFIG_SCSI_LOGGING)
96 EXPORT_SYMBOL(scsi_logging_level); 102 EXPORT_SYMBOL(scsi_logging_level);
97 #endif 103 #endif
98 104
99 /* NB: These are exposed through /proc/scsi/sc !! 105 const char *const scsi_device_types[MAX_SCSI_DEVICE_CODE] = {
100 * You may not alter any existing entry (altho <<
101 * encouraged once assigned by ANSI/INCITS T10 <<
102 */ <<
103 static const char *const scsi_device_types[] = <<
104 "Direct-Access ", 106 "Direct-Access ",
105 "Sequential-Access", 107 "Sequential-Access",
106 "Printer ", 108 "Printer ",
107 "Processor ", 109 "Processor ",
108 "WORM ", 110 "WORM ",
109 "CD-ROM ", 111 "CD-ROM ",
110 "Scanner ", 112 "Scanner ",
111 "Optical Device ", 113 "Optical Device ",
112 "Medium Changer ", 114 "Medium Changer ",
113 "Communications ", 115 "Communications ",
114 "ASC IT8 ", !! 116 "Unknown ",
115 "ASC IT8 ", !! 117 "Unknown ",
116 "RAID ", 118 "RAID ",
117 "Enclosure ", 119 "Enclosure ",
118 "Direct-Access-RBC", <<
119 "Optical card ", <<
120 "Bridge controller", <<
121 "Object storage ", <<
122 "Automation/Drive ", <<
123 }; 120 };
>> 121 EXPORT_SYMBOL(scsi_device_types);
124 122
125 /** !! 123 /*
126 * scsi_device_type - Return 17 char string in !! 124 * Function: scsi_allocate_request
127 * @type: type number to look up !! 125 *
>> 126 * Purpose: Allocate a request descriptor.
>> 127 *
>> 128 * Arguments: device - device for which we want a request
>> 129 * gfp_mask - allocation flags passed to kmalloc
>> 130 *
>> 131 * Lock status: No locks assumed to be held. This function is SMP-safe.
>> 132 *
>> 133 * Returns: Pointer to request block.
128 */ 134 */
>> 135 struct scsi_request *scsi_allocate_request(struct scsi_device *sdev,
>> 136 int gfp_mask)
>> 137 {
>> 138 const int offset = ALIGN(sizeof(struct scsi_request), 4);
>> 139 const int size = offset + sizeof(struct request);
>> 140 struct scsi_request *sreq;
>> 141
>> 142 sreq = kmalloc(size, gfp_mask);
>> 143 if (likely(sreq != NULL)) {
>> 144 memset(sreq, 0, size);
>> 145 sreq->sr_request = (struct request *)(((char *)sreq) + offset);
>> 146 sreq->sr_device = sdev;
>> 147 sreq->sr_host = sdev->host;
>> 148 sreq->sr_magic = SCSI_REQ_MAGIC;
>> 149 sreq->sr_data_direction = DMA_BIDIRECTIONAL;
>> 150 }
>> 151
>> 152 return sreq;
>> 153 }
>> 154 EXPORT_SYMBOL(scsi_allocate_request);
129 155
130 const char * scsi_device_type(unsigned type) !! 156 void __scsi_release_request(struct scsi_request *sreq)
131 { 157 {
132 if (type == 0x1e) !! 158 struct request *req = sreq->sr_request;
133 return "Well-known LUN "; !! 159
134 if (type == 0x1f) !! 160 /* unlikely because the tag was usually ended earlier by the
135 return "No Device "; !! 161 * mid-layer. However, for layering reasons ULD's don't end
136 if (type >= ARRAY_SIZE(scsi_device_typ !! 162 * the tag of commands they generate. */
137 return "Unknown "; !! 163 if (unlikely(blk_rq_tagged(req))) {
138 return scsi_device_types[type]; !! 164 unsigned long flags;
>> 165 struct request_queue *q = req->q;
>> 166
>> 167 spin_lock_irqsave(q->queue_lock, flags);
>> 168 blk_queue_end_tag(q, req);
>> 169 spin_unlock_irqrestore(q->queue_lock, flags);
>> 170 }
>> 171
>> 172
>> 173 if (likely(sreq->sr_command != NULL)) {
>> 174 struct scsi_cmnd *cmd = sreq->sr_command;
>> 175
>> 176 sreq->sr_command = NULL;
>> 177 scsi_next_command(cmd);
>> 178 }
139 } 179 }
140 180
141 EXPORT_SYMBOL(scsi_device_type); !! 181 /*
>> 182 * Function: scsi_release_request
>> 183 *
>> 184 * Purpose: Release a request descriptor.
>> 185 *
>> 186 * Arguments: sreq - request to release
>> 187 *
>> 188 * Lock status: No locks assumed to be held. This function is SMP-safe.
>> 189 */
>> 190 void scsi_release_request(struct scsi_request *sreq)
>> 191 {
>> 192 __scsi_release_request(sreq);
>> 193 kfree(sreq);
>> 194 }
>> 195 EXPORT_SYMBOL(scsi_release_request);
142 196
143 struct scsi_host_cmd_pool { 197 struct scsi_host_cmd_pool {
144 struct kmem_cache *cmd_slab; !! 198 kmem_cache_t *slab;
145 struct kmem_cache *sense_slab; !! 199 unsigned int users;
146 unsigned int users; !! 200 char *name;
147 char *cmd_name; !! 201 unsigned int slab_flags;
148 char *sense_name; !! 202 unsigned int gfp_mask;
149 unsigned int slab_flags; <<
150 gfp_t gfp_mask; <<
151 }; 203 };
152 204
153 static struct scsi_host_cmd_pool scsi_cmd_pool 205 static struct scsi_host_cmd_pool scsi_cmd_pool = {
154 .cmd_name = "scsi_cmd_cache", !! 206 .name = "scsi_cmd_cache",
155 .sense_name = "scsi_sense_cache", <<
156 .slab_flags = SLAB_HWCACHE_ALIGN, 207 .slab_flags = SLAB_HWCACHE_ALIGN,
157 }; 208 };
158 209
159 static struct scsi_host_cmd_pool scsi_cmd_dma_ 210 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
160 .cmd_name = "scsi_cmd_cache(DMA) !! 211 .name = "scsi_cmd_cache(DMA)",
161 .sense_name = "scsi_sense_cache(DM <<
162 .slab_flags = SLAB_HWCACHE_ALIGN|S 212 .slab_flags = SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
163 .gfp_mask = __GFP_DMA, 213 .gfp_mask = __GFP_DMA,
164 }; 214 };
165 215
166 static DEFINE_MUTEX(host_cmd_pool_mutex); !! 216 static DECLARE_MUTEX(host_cmd_pool_mutex);
167 217
168 /** !! 218 static struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost,
169 * __scsi_get_command - Allocate a struct scsi !! 219 int gfp_mask)
170 * @shost: host to transmit command <<
171 * @gfp_mask: allocation mask <<
172 * <<
173 * Description: allocate a struct scsi_cmd fro <<
174 * host's free_list if necessary. <<
175 */ <<
176 struct scsi_cmnd *__scsi_get_command(struct Sc <<
177 { 220 {
178 struct scsi_cmnd *cmd; 221 struct scsi_cmnd *cmd;
179 unsigned char *buf; <<
180 222
181 cmd = kmem_cache_alloc(shost->cmd_pool !! 223 cmd = kmem_cache_alloc(shost->cmd_pool->slab,
182 gfp_mask | shos !! 224 gfp_mask | shost->cmd_pool->gfp_mask);
183 <<
184 if (likely(cmd)) { <<
185 buf = kmem_cache_alloc(shost-> <<
186 gfp_mas <<
187 if (likely(buf)) { <<
188 memset(cmd, 0, sizeof( <<
189 cmd->sense_buffer = bu <<
190 } else { <<
191 kmem_cache_free(shost- <<
192 cmd = NULL; <<
193 } <<
194 } <<
195 225
196 if (unlikely(!cmd)) { 226 if (unlikely(!cmd)) {
197 unsigned long flags; 227 unsigned long flags;
198 228
199 spin_lock_irqsave(&shost->free 229 spin_lock_irqsave(&shost->free_list_lock, flags);
200 if (likely(!list_empty(&shost- 230 if (likely(!list_empty(&shost->free_list))) {
201 cmd = list_entry(shost 231 cmd = list_entry(shost->free_list.next,
202 struc 232 struct scsi_cmnd, list);
203 list_del_init(&cmd->li 233 list_del_init(&cmd->list);
204 } 234 }
205 spin_unlock_irqrestore(&shost- 235 spin_unlock_irqrestore(&shost->free_list_lock, flags);
206 <<
207 if (cmd) { <<
208 buf = cmd->sense_buffe <<
209 memset(cmd, 0, sizeof( <<
210 cmd->sense_buffer = bu <<
211 } <<
212 } 236 }
213 237
214 return cmd; 238 return cmd;
215 } 239 }
216 EXPORT_SYMBOL_GPL(__scsi_get_command); <<
217 240
218 /** !! 241 /*
219 * scsi_get_command - Allocate and setup a scs !! 242 * Function: scsi_get_command()
220 * @dev: parent scsi device !! 243 *
221 * @gfp_mask: allocator flags !! 244 * Purpose: Allocate and setup a scsi command block
>> 245 *
>> 246 * Arguments: dev - parent scsi device
>> 247 * gfp_mask- allocator flags
222 * 248 *
223 * Returns: The allocated scsi command str 249 * Returns: The allocated scsi command structure.
224 */ 250 */
225 struct scsi_cmnd *scsi_get_command(struct scsi !! 251 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, int gfp_mask)
226 { 252 {
227 struct scsi_cmnd *cmd; 253 struct scsi_cmnd *cmd;
228 254
229 /* Bail if we can't get a reference to 255 /* Bail if we can't get a reference to the device */
230 if (!get_device(&dev->sdev_gendev)) 256 if (!get_device(&dev->sdev_gendev))
231 return NULL; 257 return NULL;
232 258
233 cmd = __scsi_get_command(dev->host, gf 259 cmd = __scsi_get_command(dev->host, gfp_mask);
234 260
235 if (likely(cmd != NULL)) { 261 if (likely(cmd != NULL)) {
236 unsigned long flags; 262 unsigned long flags;
237 263
>> 264 memset(cmd, 0, sizeof(*cmd));
238 cmd->device = dev; 265 cmd->device = dev;
>> 266 cmd->state = SCSI_STATE_UNUSED;
>> 267 cmd->owner = SCSI_OWNER_NOBODY;
239 init_timer(&cmd->eh_timeout); 268 init_timer(&cmd->eh_timeout);
240 INIT_LIST_HEAD(&cmd->list); 269 INIT_LIST_HEAD(&cmd->list);
241 spin_lock_irqsave(&dev->list_l 270 spin_lock_irqsave(&dev->list_lock, flags);
242 list_add_tail(&cmd->list, &dev 271 list_add_tail(&cmd->list, &dev->cmd_list);
243 spin_unlock_irqrestore(&dev->l 272 spin_unlock_irqrestore(&dev->list_lock, flags);
244 cmd->jiffies_at_alloc = jiffie <<
245 } else 273 } else
246 put_device(&dev->sdev_gendev); 274 put_device(&dev->sdev_gendev);
247 275
248 return cmd; 276 return cmd;
249 } !! 277 }
250 EXPORT_SYMBOL(scsi_get_command); 278 EXPORT_SYMBOL(scsi_get_command);
251 279
252 /** !! 280 /*
253 * __scsi_put_command - Free a struct scsi_cmn !! 281 * Function: scsi_put_command()
254 * @shost: dev->host !! 282 *
255 * @cmd: Command to free !! 283 * Purpose: Free a scsi command block
256 * @dev: parent scsi device !! 284 *
257 */ !! 285 * Arguments: cmd - command block to free
258 void __scsi_put_command(struct Scsi_Host *shos <<
259 struct device *dev) <<
260 { <<
261 unsigned long flags; <<
262 <<
263 /* changing locks here, don't need to <<
264 spin_lock_irqsave(&shost->free_list_lo <<
265 if (unlikely(list_empty(&shost->free_l <<
266 list_add(&cmd->list, &shost->f <<
267 cmd = NULL; <<
268 } <<
269 spin_unlock_irqrestore(&shost->free_li <<
270 <<
271 if (likely(cmd != NULL)) { <<
272 kmem_cache_free(shost->cmd_poo <<
273 cmd->sense_buf <<
274 kmem_cache_free(shost->cmd_poo <<
275 } <<
276 <<
277 put_device(dev); <<
278 } <<
279 EXPORT_SYMBOL(__scsi_put_command); <<
280 <<
281 /** <<
282 * scsi_put_command - Free a scsi command bloc <<
283 * @cmd: command block to free <<
284 * 286 *
285 * Returns: Nothing. 287 * Returns: Nothing.
286 * 288 *
287 * Notes: The command must not belong to 289 * Notes: The command must not belong to any lists.
288 */ 290 */
289 void scsi_put_command(struct scsi_cmnd *cmd) 291 void scsi_put_command(struct scsi_cmnd *cmd)
290 { 292 {
291 struct scsi_device *sdev = cmd->device 293 struct scsi_device *sdev = cmd->device;
>> 294 struct Scsi_Host *shost = sdev->host;
292 unsigned long flags; 295 unsigned long flags;
293 !! 296
294 /* serious error if the command hasn't 297 /* serious error if the command hasn't come from a device list */
295 spin_lock_irqsave(&cmd->device->list_l 298 spin_lock_irqsave(&cmd->device->list_lock, flags);
296 BUG_ON(list_empty(&cmd->list)); 299 BUG_ON(list_empty(&cmd->list));
297 list_del_init(&cmd->list); 300 list_del_init(&cmd->list);
298 spin_unlock_irqrestore(&cmd->device->l !! 301 spin_unlock(&cmd->device->list_lock);
>> 302 /* changing locks here, don't need to restore the irq state */
>> 303 spin_lock(&shost->free_list_lock);
>> 304 if (unlikely(list_empty(&shost->free_list))) {
>> 305 list_add(&cmd->list, &shost->free_list);
>> 306 cmd = NULL;
>> 307 }
>> 308 spin_unlock_irqrestore(&shost->free_list_lock, flags);
>> 309
>> 310 if (likely(cmd != NULL))
>> 311 kmem_cache_free(shost->cmd_pool->slab, cmd);
299 312
300 __scsi_put_command(cmd->device->host, !! 313 put_device(&sdev->sdev_gendev);
301 } 314 }
302 EXPORT_SYMBOL(scsi_put_command); 315 EXPORT_SYMBOL(scsi_put_command);
303 316
304 /** !! 317 /*
305 * scsi_setup_command_freelist - Setup the com !! 318 * Function: scsi_setup_command_freelist()
306 * @shost: host to allocate the freelist for. !! 319 *
>> 320 * Purpose: Setup the command freelist for a scsi host.
307 * 321 *
308 * Description: The command freelist protects !! 322 * Arguments: shost - host to allocate the freelist for.
309 * deadlock by preallocating one SCSI command <<
310 * system can always write to a swap file on a <<
311 * 323 *
312 * Returns: Nothing. 324 * Returns: Nothing.
313 */ 325 */
314 int scsi_setup_command_freelist(struct Scsi_Ho 326 int scsi_setup_command_freelist(struct Scsi_Host *shost)
315 { 327 {
316 struct scsi_host_cmd_pool *pool; 328 struct scsi_host_cmd_pool *pool;
317 struct scsi_cmnd *cmd; 329 struct scsi_cmnd *cmd;
318 330
319 spin_lock_init(&shost->free_list_lock) 331 spin_lock_init(&shost->free_list_lock);
320 INIT_LIST_HEAD(&shost->free_list); 332 INIT_LIST_HEAD(&shost->free_list);
321 333
322 /* 334 /*
323 * Select a command slab for this host 335 * Select a command slab for this host and create it if not
324 * yet existent. !! 336 * yet existant.
325 */ 337 */
326 mutex_lock(&host_cmd_pool_mutex); !! 338 down(&host_cmd_pool_mutex);
327 pool = (shost->unchecked_isa_dma ? &sc 339 pool = (shost->unchecked_isa_dma ? &scsi_cmd_dma_pool : &scsi_cmd_pool);
328 if (!pool->users) { 340 if (!pool->users) {
329 pool->cmd_slab = kmem_cache_cr !! 341 pool->slab = kmem_cache_create(pool->name,
330 !! 342 sizeof(struct scsi_cmnd), 0,
331 !! 343 pool->slab_flags, NULL, NULL);
332 if (!pool->cmd_slab) !! 344 if (!pool->slab)
333 goto fail; 345 goto fail;
334 <<
335 pool->sense_slab = kmem_cache_ <<
336 <<
337 <<
338 if (!pool->sense_slab) { <<
339 kmem_cache_destroy(poo <<
340 goto fail; <<
341 } <<
342 } 346 }
343 347
344 pool->users++; 348 pool->users++;
345 shost->cmd_pool = pool; 349 shost->cmd_pool = pool;
346 mutex_unlock(&host_cmd_pool_mutex); !! 350 up(&host_cmd_pool_mutex);
347 351
348 /* 352 /*
349 * Get one backup command for this hos 353 * Get one backup command for this host.
350 */ 354 */
351 cmd = kmem_cache_alloc(shost->cmd_pool !! 355 cmd = kmem_cache_alloc(shost->cmd_pool->slab,
352 GFP_KERNEL | sh !! 356 GFP_KERNEL | shost->cmd_pool->gfp_mask);
353 if (!cmd) 357 if (!cmd)
354 goto fail2; 358 goto fail2;
355 !! 359 list_add(&cmd->list, &shost->free_list);
356 cmd->sense_buffer = kmem_cache_alloc(s <<
357 G <<
358 s <<
359 if (!cmd->sense_buffer) <<
360 goto fail2; <<
361 <<
362 list_add(&cmd->list, &shost->free_list <<
363 return 0; 360 return 0;
364 361
365 fail2: 362 fail2:
366 if (cmd) !! 363 if (!--pool->users)
367 kmem_cache_free(shost->cmd_poo !! 364 kmem_cache_destroy(pool->slab);
368 mutex_lock(&host_cmd_pool_mutex); !! 365 return -ENOMEM;
369 if (!--pool->users) { <<
370 kmem_cache_destroy(pool->cmd_s <<
371 kmem_cache_destroy(pool->sense <<
372 } <<
373 fail: 366 fail:
374 mutex_unlock(&host_cmd_pool_mutex); !! 367 up(&host_cmd_pool_mutex);
375 return -ENOMEM; 368 return -ENOMEM;
>> 369
376 } 370 }
377 371
378 /** !! 372 /*
379 * scsi_destroy_command_freelist - Release the !! 373 * Function: scsi_destroy_command_freelist()
380 * @shost: host whose freelist is going to be !! 374 *
>> 375 * Purpose: Release the command freelist for a scsi host.
>> 376 *
>> 377 * Arguments: shost - host that's freelist is going to be destroyed
381 */ 378 */
382 void scsi_destroy_command_freelist(struct Scsi 379 void scsi_destroy_command_freelist(struct Scsi_Host *shost)
383 { 380 {
384 while (!list_empty(&shost->free_list)) 381 while (!list_empty(&shost->free_list)) {
385 struct scsi_cmnd *cmd; 382 struct scsi_cmnd *cmd;
386 383
387 cmd = list_entry(shost->free_l 384 cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
388 list_del_init(&cmd->list); 385 list_del_init(&cmd->list);
389 kmem_cache_free(shost->cmd_poo !! 386 kmem_cache_free(shost->cmd_pool->slab, cmd);
390 cmd->sense_buf <<
391 kmem_cache_free(shost->cmd_poo <<
392 } 387 }
393 388
394 mutex_lock(&host_cmd_pool_mutex); !! 389 down(&host_cmd_pool_mutex);
395 if (!--shost->cmd_pool->users) { !! 390 if (!--shost->cmd_pool->users)
396 kmem_cache_destroy(shost->cmd_ !! 391 kmem_cache_destroy(shost->cmd_pool->slab);
397 kmem_cache_destroy(shost->cmd_ !! 392 up(&host_cmd_pool_mutex);
398 } <<
399 mutex_unlock(&host_cmd_pool_mutex); <<
400 } 393 }
401 394
402 #ifdef CONFIG_SCSI_LOGGING 395 #ifdef CONFIG_SCSI_LOGGING
403 void scsi_log_send(struct scsi_cmnd *cmd) 396 void scsi_log_send(struct scsi_cmnd *cmd)
404 { 397 {
405 unsigned int level; 398 unsigned int level;
>> 399 struct scsi_device *sdev;
406 400
407 /* 401 /*
408 * If ML QUEUE log level is greater th 402 * If ML QUEUE log level is greater than or equal to:
409 * 403 *
410 * 1: nothing (match completion) 404 * 1: nothing (match completion)
411 * 405 *
412 * 2: log opcode + command of all comm 406 * 2: log opcode + command of all commands
413 * 407 *
414 * 3: same as 2 plus dump cmd address 408 * 3: same as 2 plus dump cmd address
415 * 409 *
416 * 4: same as 3 plus dump extra junk 410 * 4: same as 3 plus dump extra junk
417 */ 411 */
418 if (unlikely(scsi_logging_level)) { 412 if (unlikely(scsi_logging_level)) {
419 level = SCSI_LOG_LEVEL(SCSI_LO 413 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
420 SCSI_LO 414 SCSI_LOG_MLQUEUE_BITS);
421 if (level > 1) { 415 if (level > 1) {
422 scmd_printk(KERN_INFO, !! 416 sdev = cmd->device;
>> 417 printk(KERN_INFO "scsi <%d:%d:%d:%d> send ",
>> 418 sdev->host->host_no, sdev->channel, sdev->id,
>> 419 sdev->lun);
423 if (level > 2) 420 if (level > 2)
424 printk("0x%p " 421 printk("0x%p ", cmd);
425 printk("\n"); !! 422 /*
>> 423 * spaces to match disposition and cmd->result
>> 424 * output in scsi_log_completion.
>> 425 */
>> 426 printk(" ");
426 scsi_print_command(cmd 427 scsi_print_command(cmd);
427 if (level > 3) { 428 if (level > 3) {
428 printk(KERN_IN 429 printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
429 " queue !! 430 " done = 0x%p, queuecommand 0x%p\n",
430 scsi_s !! 431 cmd->buffer, cmd->bufflen,
431 cmd->d !! 432 cmd->done,
>> 433 sdev->host->hostt->queuecommand);
432 434
433 } 435 }
434 } 436 }
435 } 437 }
436 } 438 }
437 439
438 void scsi_log_completion(struct scsi_cmnd *cmd 440 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
439 { 441 {
440 unsigned int level; 442 unsigned int level;
>> 443 struct scsi_device *sdev;
441 444
442 /* 445 /*
443 * If ML COMPLETE log level is greater 446 * If ML COMPLETE log level is greater than or equal to:
444 * 447 *
445 * 1: log disposition, result, opcode 448 * 1: log disposition, result, opcode + command, and conditionally
446 * sense data for failures or non SUCC 449 * sense data for failures or non SUCCESS dispositions.
447 * 450 *
448 * 2: same as 1 but for all command co 451 * 2: same as 1 but for all command completions.
449 * 452 *
450 * 3: same as 2 plus dump cmd address 453 * 3: same as 2 plus dump cmd address
451 * 454 *
452 * 4: same as 3 plus dump extra junk 455 * 4: same as 3 plus dump extra junk
453 */ 456 */
454 if (unlikely(scsi_logging_level)) { 457 if (unlikely(scsi_logging_level)) {
455 level = SCSI_LOG_LEVEL(SCSI_LO 458 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
456 SCSI_LO 459 SCSI_LOG_MLCOMPLETE_BITS);
457 if (((level > 0) && (cmd->resu 460 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
458 (level > 1)) { 461 (level > 1)) {
459 scmd_printk(KERN_INFO, !! 462 sdev = cmd->device;
>> 463 printk(KERN_INFO "scsi <%d:%d:%d:%d> done ",
>> 464 sdev->host->host_no, sdev->channel, sdev->id,
>> 465 sdev->lun);
460 if (level > 2) 466 if (level > 2)
461 printk("0x%p " 467 printk("0x%p ", cmd);
462 /* 468 /*
463 * Dump truncated valu 469 * Dump truncated values, so we usually fit within
464 * 80 chars. 470 * 80 chars.
465 */ 471 */
466 switch (disposition) { 472 switch (disposition) {
467 case SUCCESS: 473 case SUCCESS:
468 printk("SUCCES !! 474 printk("SUCCESS");
469 break; 475 break;
470 case NEEDS_RETRY: 476 case NEEDS_RETRY:
471 printk("RETRY\ !! 477 printk("RETRY ");
472 break; 478 break;
473 case ADD_TO_MLQUEUE: 479 case ADD_TO_MLQUEUE:
474 printk("MLQUEU !! 480 printk("MLQUEUE");
475 break; 481 break;
476 case FAILED: 482 case FAILED:
477 printk("FAILED !! 483 printk("FAILED ");
478 break; 484 break;
479 case TIMEOUT_ERROR: 485 case TIMEOUT_ERROR:
480 /* 486 /*
481 * If called v 487 * If called via scsi_times_out.
482 */ 488 */
483 printk("TIMEOU !! 489 printk("TIMEOUT");
484 break; 490 break;
485 default: 491 default:
486 printk("UNKNOW !! 492 printk("UNKNOWN");
487 } 493 }
488 scsi_print_result(cmd) !! 494 printk(" %8x ", cmd->result);
489 scsi_print_command(cmd 495 scsi_print_command(cmd);
490 if (status_byte(cmd->r !! 496 if (status_byte(cmd->result) & CHECK_CONDITION) {
>> 497 /*
>> 498 * XXX The print_sense formatting/prefix
>> 499 * doesn't match this function.
>> 500 */
491 scsi_print_sen 501 scsi_print_sense("", cmd);
492 if (level > 3) !! 502 }
493 scmd_printk(KE !! 503 if (level > 3) {
494 "s !! 504 printk(KERN_INFO "scsi host busy %d failed %d\n",
495 cm !! 505 sdev->host->host_busy,
496 cm !! 506 sdev->host->host_failed);
>> 507 }
497 } 508 }
498 } 509 }
499 } 510 }
500 #endif 511 #endif
501 512
502 /** !! 513 /*
503 * scsi_cmd_get_serial - Assign a serial numbe !! 514 * Function: scsi_dispatch_command
504 * @host: the scsi host !! 515 *
505 * @cmd: command to assign serial number to !! 516 * Purpose: Dispatch a command to the low-level driver.
506 * <<
507 * Description: a serial number identifies a r <<
508 * and debugging purposes. Protected by the H <<
509 */ <<
510 static inline void scsi_cmd_get_serial(struct <<
511 { <<
512 cmd->serial_number = host->cmd_serial_ <<
513 if (cmd->serial_number == 0) <<
514 cmd->serial_number = host->cmd <<
515 } <<
516 <<
517 /** <<
518 * scsi_dispatch_command - Dispatch a command <<
519 * @cmd: command block we are dispatching. <<
520 * 517 *
521 * Return: nonzero return request was rejected !! 518 * Arguments: cmd - command block we are dispatching.
522 * plugged. !! 519 *
>> 520 * Notes:
523 */ 521 */
524 int scsi_dispatch_cmd(struct scsi_cmnd *cmd) 522 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
525 { 523 {
526 struct Scsi_Host *host = cmd->device-> 524 struct Scsi_Host *host = cmd->device->host;
527 unsigned long flags = 0; 525 unsigned long flags = 0;
528 unsigned long timeout; 526 unsigned long timeout;
529 int rtn = 0; 527 int rtn = 0;
530 528
531 /* check if the device is still usable 529 /* check if the device is still usable */
532 if (unlikely(cmd->device->sdev_state = 530 if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
533 /* in SDEV_DEL we error all co 531 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
534 * returns an immediate error 532 * returns an immediate error upwards, and signals
535 * that the device is no longe 533 * that the device is no longer present */
536 cmd->result = DID_NO_CONNECT < 534 cmd->result = DID_NO_CONNECT << 16;
537 atomic_inc(&cmd->device->ioreq !! 535 scsi_done(cmd);
538 __scsi_done(cmd); <<
539 /* return 0 (because the comma 536 /* return 0 (because the command has been processed) */
540 goto out; 537 goto out;
541 } 538 }
542 539
543 /* Check to see if the scsi lld put th 540 /* Check to see if the scsi lld put this device into state SDEV_BLOCK. */
544 if (unlikely(cmd->device->sdev_state = 541 if (unlikely(cmd->device->sdev_state == SDEV_BLOCK)) {
545 /* 542 /*
546 * in SDEV_BLOCK, the command 543 * in SDEV_BLOCK, the command is just put back on the device
547 * queue. The suspend state h 544 * queue. The suspend state has already blocked the queue so
548 * future requests should not 545 * future requests should not occur until the device
549 * transitions out of the susp 546 * transitions out of the suspend state.
550 */ 547 */
551 scsi_queue_insert(cmd, SCSI_ML 548 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
552 549
553 SCSI_LOG_MLQUEUE(3, printk("qu 550 SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
554 551
555 /* 552 /*
556 * NOTE: rtn is still zero her 553 * NOTE: rtn is still zero here because we don't need the
557 * queue to be plugged on retu 554 * queue to be plugged on return (it's already stopped)
558 */ 555 */
559 goto out; 556 goto out;
560 } 557 }
561 558
>> 559 /* Assign a unique nonzero serial_number. */
>> 560 /* XXX(hch): this is racy */
>> 561 if (++serial_number == 0)
>> 562 serial_number = 1;
>> 563 cmd->serial_number = serial_number;
>> 564 cmd->pid = scsi_pid++;
>> 565
562 /* 566 /*
563 * If SCSI-2 or lower, store the LUN v 567 * If SCSI-2 or lower, store the LUN value in cmnd.
564 */ 568 */
565 if (cmd->device->scsi_level <= SCSI_2 !! 569 if (cmd->device->scsi_level <= SCSI_2) {
566 cmd->device->scsi_level != SCSI_UN <<
567 cmd->cmnd[1] = (cmd->cmnd[1] & 570 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
568 (cmd->device->l 571 (cmd->device->lun << 5 & 0xe0);
569 } 572 }
570 573
571 /* 574 /*
572 * We will wait MIN_RESET_DELAY clock 575 * We will wait MIN_RESET_DELAY clock ticks after the last reset so
573 * we can avoid the drive not being re 576 * we can avoid the drive not being ready.
574 */ 577 */
575 timeout = host->last_reset + MIN_RESET 578 timeout = host->last_reset + MIN_RESET_DELAY;
576 579
577 if (host->resetting && time_before(jif 580 if (host->resetting && time_before(jiffies, timeout)) {
578 int ticks_remaining = timeout 581 int ticks_remaining = timeout - jiffies;
579 /* 582 /*
580 * NOTE: This may be executed 583 * NOTE: This may be executed from within an interrupt
581 * handler! This is bad, but 584 * handler! This is bad, but for now, it'll do. The irq
582 * level of the interrupt hand 585 * level of the interrupt handler has been masked out by the
583 * platform dependent interrup 586 * platform dependent interrupt handling code already, so the
584 * sti() here will not cause a 587 * sti() here will not cause another call to the SCSI host's
585 * interrupt handler (assuming 588 * interrupt handler (assuming there is one irq-level per
586 * host). 589 * host).
587 */ 590 */
588 while (--ticks_remaining >= 0) 591 while (--ticks_remaining >= 0)
589 mdelay(1 + 999 / HZ); 592 mdelay(1 + 999 / HZ);
590 host->resetting = 0; 593 host->resetting = 0;
591 } 594 }
592 595
593 /* <<
594 * AK: unlikely race here: for some re <<
595 * expire before the serial number is <<
596 */ <<
597 scsi_add_timer(cmd, cmd->timeout_per_c 596 scsi_add_timer(cmd, cmd->timeout_per_command, scsi_times_out);
598 597
599 scsi_log_send(cmd); 598 scsi_log_send(cmd);
600 599
601 /* 600 /*
602 * We will use a queued command if pos 601 * We will use a queued command if possible, otherwise we will
603 * emulate the queuing and calling of 602 * emulate the queuing and calling of completion function ourselves.
604 */ 603 */
605 atomic_inc(&cmd->device->iorequest_cnt !! 604
>> 605 cmd->state = SCSI_STATE_QUEUED;
>> 606 cmd->owner = SCSI_OWNER_LOWLEVEL;
606 607
607 /* 608 /*
608 * Before we queue this command, check 609 * Before we queue this command, check if the command
609 * length exceeds what the host adapte 610 * length exceeds what the host adapter can handle.
610 */ 611 */
611 if (CDB_SIZE(cmd) > cmd->device->host- 612 if (CDB_SIZE(cmd) > cmd->device->host->max_cmd_len) {
612 SCSI_LOG_MLQUEUE(3, 613 SCSI_LOG_MLQUEUE(3,
613 printk("queuec 614 printk("queuecommand : command too long.\n"));
614 cmd->result = (DID_ABORT << 16 615 cmd->result = (DID_ABORT << 16);
615 616
616 scsi_done(cmd); 617 scsi_done(cmd);
617 goto out; 618 goto out;
618 } 619 }
619 620
620 spin_lock_irqsave(host->host_lock, fla 621 spin_lock_irqsave(host->host_lock, flags);
621 scsi_cmd_get_serial(host, cmd); !! 622 if (unlikely(test_bit(SHOST_CANCEL, &host->shost_state))) {
622 <<
623 if (unlikely(host->shost_state == SHOS <<
624 cmd->result = (DID_NO_CONNECT 623 cmd->result = (DID_NO_CONNECT << 16);
625 scsi_done(cmd); 624 scsi_done(cmd);
626 } else { 625 } else {
627 rtn = host->hostt->queuecomman 626 rtn = host->hostt->queuecommand(cmd, scsi_done);
628 } 627 }
629 spin_unlock_irqrestore(host->host_lock 628 spin_unlock_irqrestore(host->host_lock, flags);
630 if (rtn) { 629 if (rtn) {
631 if (scsi_delete_timer(cmd)) { !! 630 scsi_queue_insert(cmd,
632 atomic_inc(&cmd->devic !! 631 (rtn == SCSI_MLQUEUE_DEVICE_BUSY) ?
633 scsi_queue_insert(cmd, !! 632 rtn : SCSI_MLQUEUE_HOST_BUSY);
634 (rtn <<
635 rtn <<
636 } <<
637 SCSI_LOG_MLQUEUE(3, 633 SCSI_LOG_MLQUEUE(3,
638 printk("queuecommand : req 634 printk("queuecommand : request rejected\n"));
639 } 635 }
640 636
641 out: 637 out:
642 SCSI_LOG_MLQUEUE(3, printk("leaving sc 638 SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
643 return rtn; 639 return rtn;
644 } 640 }
645 641
646 /** !! 642 /*
647 * scsi_req_abort_cmd -- Request command recov !! 643 * Function: scsi_init_cmd_from_req
648 * @cmd: pointer to the SCSI command of intere !! 644 *
>> 645 * Purpose: Queue a SCSI command
>> 646 * Purpose: Initialize a struct scsi_cmnd from a struct scsi_request
>> 647 *
>> 648 * Arguments: cmd - command descriptor.
>> 649 * sreq - Request from the queue.
649 * 650 *
650 * This function requests that SCSI Core start !! 651 * Lock status: None needed.
651 * command by deleting the timer and adding th !! 652 *
652 * queue. It can be called by either LLDDs or !! 653 * Returns: Nothing.
653 * implement their own error recovery MAY igno !! 654 *
654 * they generated scsi_req_abort_cmd. !! 655 * Notes: Mainly transfer data from the request structure to the
>> 656 * command structure. The request structure is allocated
>> 657 * using the normal memory allocator, and requests can pile
>> 658 * up to more or less any depth. The command structure represents
>> 659 * a consumable resource, as these are allocated into a pool
>> 660 * when the SCSI subsystem initializes. The preallocation is
>> 661 * required so that in low-memory situations a disk I/O request
>> 662 * won't cause the memory manager to try and write out a page.
>> 663 * The request structure is generally used by ioctls and character
>> 664 * devices.
655 */ 665 */
656 void scsi_req_abort_cmd(struct scsi_cmnd *cmd) !! 666 void scsi_init_cmd_from_req(struct scsi_cmnd *cmd, struct scsi_request *sreq)
657 { 667 {
658 if (!scsi_delete_timer(cmd)) !! 668 sreq->sr_command = cmd;
659 return; !! 669
660 scsi_times_out(cmd); !! 670 cmd->owner = SCSI_OWNER_MIDLEVEL;
>> 671 cmd->cmd_len = sreq->sr_cmd_len;
>> 672 cmd->use_sg = sreq->sr_use_sg;
>> 673
>> 674 cmd->request = sreq->sr_request;
>> 675 memcpy(cmd->data_cmnd, sreq->sr_cmnd, sizeof(cmd->data_cmnd));
>> 676 cmd->serial_number = 0;
>> 677 cmd->serial_number_at_timeout = 0;
>> 678 cmd->bufflen = sreq->sr_bufflen;
>> 679 cmd->buffer = sreq->sr_buffer;
>> 680 cmd->retries = 0;
>> 681 cmd->allowed = sreq->sr_allowed;
>> 682 cmd->done = sreq->sr_done;
>> 683 cmd->timeout_per_command = sreq->sr_timeout_per_command;
>> 684 cmd->sc_data_direction = sreq->sr_data_direction;
>> 685 cmd->sglist_len = sreq->sr_sglist_len;
>> 686 cmd->underflow = sreq->sr_underflow;
>> 687 cmd->sc_request = sreq;
>> 688 memcpy(cmd->cmnd, sreq->sr_cmnd, sizeof(sreq->sr_cmnd));
>> 689
>> 690 /*
>> 691 * Zero the sense buffer. Some host adapters automatically request
>> 692 * sense on error. 0 is not a valid sense code.
>> 693 */
>> 694 memset(cmd->sense_buffer, 0, sizeof(sreq->sr_sense_buffer));
>> 695 cmd->request_buffer = sreq->sr_buffer;
>> 696 cmd->request_bufflen = sreq->sr_bufflen;
>> 697 cmd->old_use_sg = cmd->use_sg;
>> 698 if (cmd->cmd_len == 0)
>> 699 cmd->cmd_len = COMMAND_SIZE(cmd->cmnd[0]);
>> 700 cmd->old_cmd_len = cmd->cmd_len;
>> 701 cmd->sc_old_data_direction = cmd->sc_data_direction;
>> 702 cmd->old_underflow = cmd->underflow;
>> 703
>> 704 /*
>> 705 * Start the timer ticking.
>> 706 */
>> 707 cmd->internal_timeout = NORMAL_TIMEOUT;
>> 708 cmd->abort_reason = 0;
>> 709 cmd->result = 0;
>> 710
>> 711 SCSI_LOG_MLQUEUE(3, printk("Leaving scsi_init_cmd_from_req()\n"));
661 } 712 }
662 EXPORT_SYMBOL(scsi_req_abort_cmd); !! 713
>> 714 /*
>> 715 * Per-CPU I/O completion queue.
>> 716 */
>> 717 static DEFINE_PER_CPU(struct list_head, scsi_done_q);
663 718
664 /** 719 /**
665 * scsi_done - Enqueue the finished SCSI comma 720 * scsi_done - Enqueue the finished SCSI command into the done queue.
666 * @cmd: The SCSI Command for which a low-leve 721 * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
667 * ownership back to SCSI Core -- i.e. the LLD 722 * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
668 * 723 *
669 * Description: This function is the mid-level !! 724 * This function is the mid-level's (SCSI Core) interrupt routine, which
670 * which regains ownership of the SCSI command !! 725 * regains ownership of the SCSI command (de facto) from a LLDD, and enqueues
671 * enqueues the command to the done queue for !! 726 * the command to the done queue for further processing.
672 * 727 *
673 * This is the producer of the done queue who 728 * This is the producer of the done queue who enqueues at the tail.
674 * 729 *
675 * This function is interrupt context safe. 730 * This function is interrupt context safe.
676 */ 731 */
677 static void scsi_done(struct scsi_cmnd *cmd) !! 732 void scsi_done(struct scsi_cmnd *cmd)
678 { 733 {
679 /* 734 /*
680 * We don't have to worry about this o !! 735 * We don't have to worry about this one timing out any more.
681 * If we are unable to remove the time 736 * If we are unable to remove the timer, then the command
682 * has already timed out. In which ca 737 * has already timed out. In which case, we have no choice but to
683 * let the timeout function run, as we 738 * let the timeout function run, as we have no idea where in fact
684 * that function could really be. It 739 * that function could really be. It might be on another processor,
685 * etc, etc. 740 * etc, etc.
686 */ 741 */
687 if (!scsi_delete_timer(cmd)) 742 if (!scsi_delete_timer(cmd))
688 return; 743 return;
689 __scsi_done(cmd); 744 __scsi_done(cmd);
690 } 745 }
691 746
692 /* Private entry to scsi_done() to complete a 747 /* Private entry to scsi_done() to complete a command when the timer
693 * isn't running --- used by scsi_times_out */ 748 * isn't running --- used by scsi_times_out */
694 void __scsi_done(struct scsi_cmnd *cmd) 749 void __scsi_done(struct scsi_cmnd *cmd)
695 { 750 {
696 struct request *rq = cmd->request; !! 751 unsigned long flags;
697 752
698 /* 753 /*
699 * Set the serial numbers back to zero 754 * Set the serial numbers back to zero
700 */ 755 */
701 cmd->serial_number = 0; 756 cmd->serial_number = 0;
702 !! 757 cmd->serial_number_at_timeout = 0;
703 atomic_inc(&cmd->device->iodone_cnt); !! 758 cmd->state = SCSI_STATE_BHQUEUE;
704 if (cmd->result) !! 759 cmd->owner = SCSI_OWNER_BH_HANDLER;
705 atomic_inc(&cmd->device->ioerr <<
706 <<
707 BUG_ON(!rq); <<
708 760
709 /* 761 /*
710 * The uptodate/nbytes values don't ma !! 762 * Next, enqueue the command into the done queue.
711 * completes and thus will check this !! 763 * It is a per-CPU queue, so we just disable local interrupts
>> 764 * and need no spinlock.
712 */ 765 */
713 rq->completion_data = cmd; !! 766 local_irq_save(flags);
714 blk_complete_request(rq); !! 767 list_add_tail(&cmd->eh_entry, &__get_cpu_var(scsi_done_q));
>> 768 raise_softirq_irqoff(SCSI_SOFTIRQ);
>> 769 local_irq_restore(flags);
715 } 770 }
716 771
717 /* Move this to a header if it becomes more ge !! 772 /**
718 static struct scsi_driver *scsi_cmd_to_driver( !! 773 * scsi_softirq - Perform post-interrupt processing of finished SCSI commands.
>> 774 *
>> 775 * This is the consumer of the done queue.
>> 776 *
>> 777 * This is called with all interrupts enabled. This should reduce
>> 778 * interrupt latency, stack depth, and reentrancy of the low-level
>> 779 * drivers.
>> 780 */
>> 781 static void scsi_softirq(struct softirq_action *h)
719 { 782 {
720 return *(struct scsi_driver **)cmd->re !! 783 int disposition;
>> 784 LIST_HEAD(local_q);
>> 785
>> 786 local_irq_disable();
>> 787 list_splice_init(&__get_cpu_var(scsi_done_q), &local_q);
>> 788 local_irq_enable();
>> 789
>> 790 while (!list_empty(&local_q)) {
>> 791 struct scsi_cmnd *cmd = list_entry(local_q.next,
>> 792 struct scsi_cmnd, eh_entry);
>> 793 list_del_init(&cmd->eh_entry);
>> 794
>> 795 disposition = scsi_decide_disposition(cmd);
>> 796 scsi_log_completion(cmd, disposition);
>> 797 switch (disposition) {
>> 798 case SUCCESS:
>> 799 scsi_finish_command(cmd);
>> 800 break;
>> 801 case NEEDS_RETRY:
>> 802 scsi_retry_command(cmd);
>> 803 break;
>> 804 case ADD_TO_MLQUEUE:
>> 805 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
>> 806 break;
>> 807 default:
>> 808 if (!scsi_eh_scmd_add(cmd, 0))
>> 809 scsi_finish_command(cmd);
>> 810 }
>> 811 }
721 } 812 }
722 813
723 /** !! 814 /*
724 * scsi_finish_command - cleanup and pass comm !! 815 * Function: scsi_retry_command
725 * @cmd: the command <<
726 * 816 *
727 * Description: Pass command off to upper laye !! 817 * Purpose: Send a command back to the low level to be retried.
>> 818 *
>> 819 * Notes: This command is always executed in the context of the
>> 820 * bottom half handler, or the error handler thread. Low
>> 821 * level drivers should not become re-entrant as a result of
>> 822 * this.
>> 823 */
>> 824 int scsi_retry_command(struct scsi_cmnd *cmd)
>> 825 {
>> 826 /*
>> 827 * Restore the SCSI command state.
>> 828 */
>> 829 scsi_setup_cmd_retry(cmd);
>> 830
>> 831 /*
>> 832 * Zero the sense information from the last time we tried
>> 833 * this command.
>> 834 */
>> 835 memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
>> 836
>> 837 return scsi_queue_insert(cmd, SCSI_MLQUEUE_EH_RETRY);
>> 838 }
>> 839
>> 840 /*
>> 841 * Function: scsi_finish_command
>> 842 *
>> 843 * Purpose: Pass command off to upper layer for finishing of I/O
728 * request, waking processes that 844 * request, waking processes that are waiting on results,
729 * etc. 845 * etc.
730 */ 846 */
731 void scsi_finish_command(struct scsi_cmnd *cmd 847 void scsi_finish_command(struct scsi_cmnd *cmd)
732 { 848 {
733 struct scsi_device *sdev = cmd->device 849 struct scsi_device *sdev = cmd->device;
734 struct Scsi_Host *shost = sdev->host; 850 struct Scsi_Host *shost = sdev->host;
735 struct scsi_driver *drv; !! 851 struct scsi_request *sreq;
736 unsigned int good_bytes; <<
737 852
738 scsi_device_unbusy(sdev); 853 scsi_device_unbusy(sdev);
739 854
740 /* 855 /*
741 * Clear the flags which say that the 856 * Clear the flags which say that the device/host is no longer
742 * capable of accepting new commands. 857 * capable of accepting new commands. These are set in scsi_queue.c
743 * for both the queue full condition o 858 * for both the queue full condition on a device, and for a
744 * host full condition on the host. 859 * host full condition on the host.
745 * 860 *
746 * XXX(hch): What about locking? 861 * XXX(hch): What about locking?
747 */ 862 */
748 shost->host_blocked = 0; 863 shost->host_blocked = 0;
749 sdev->device_blocked = 0; 864 sdev->device_blocked = 0;
750 865
751 /* 866 /*
752 * If we have valid sense information, 867 * If we have valid sense information, then some kind of recovery
753 * must have taken place. Make a note 868 * must have taken place. Make a note of this.
754 */ 869 */
755 if (SCSI_SENSE_VALID(cmd)) 870 if (SCSI_SENSE_VALID(cmd))
756 cmd->result |= (DRIVER_SENSE < 871 cmd->result |= (DRIVER_SENSE << 24);
757 872
758 SCSI_LOG_MLCOMPLETE(4, sdev_printk(KER !! 873 SCSI_LOG_MLCOMPLETE(4, printk("Notifying upper driver of completion "
759 "Notifying upp !! 874 "for device %d %x\n", sdev->id, cmd->result));
760 "(result %x)\n !! 875
761 !! 876 cmd->owner = SCSI_OWNER_HIGHLEVEL;
762 good_bytes = scsi_bufflen(cmd) + cmd-> !! 877 cmd->state = SCSI_STATE_FINISHED;
763 if (cmd->request->cmd_type != REQ_TYPE !! 878
764 drv = scsi_cmd_to_driver(cmd); !! 879 /*
765 if (drv->done) !! 880 * We can get here with use_sg=0, causing a panic in the upper level
766 good_bytes = drv->done !! 881 */
>> 882 cmd->use_sg = cmd->old_use_sg;
>> 883
>> 884 /*
>> 885 * If there is an associated request structure, copy the data over
>> 886 * before we call the completion function.
>> 887 */
>> 888 sreq = cmd->sc_request;
>> 889 if (sreq) {
>> 890 sreq->sr_result = sreq->sr_command->result;
>> 891 if (sreq->sr_result) {
>> 892 memcpy(sreq->sr_sense_buffer,
>> 893 sreq->sr_command->sense_buffer,
>> 894 sizeof(sreq->sr_sense_buffer));
>> 895 }
767 } 896 }
768 scsi_io_completion(cmd, good_bytes); !! 897
>> 898 cmd->done(cmd);
769 } 899 }
770 EXPORT_SYMBOL(scsi_finish_command); 900 EXPORT_SYMBOL(scsi_finish_command);
771 901
772 /** !! 902 /*
773 * scsi_adjust_queue_depth - Let low level dri !! 903 * Function: scsi_adjust_queue_depth()
774 * @sdev: SCSI Device in question !! 904 *
775 * @tagged: Do we use tagged queueing (non-0) !! 905 * Purpose: Allow low level drivers to tell us to change the queue depth
776 * this device as an untagged device !! 906 * on a specific SCSI device
777 * @tags: Number of tags allowed if tagged que !! 907 *
778 * or number of commands the low level !! 908 * Arguments: sdev - SCSI Device in question
779 * queue up in non-tagged mode (as per !! 909 * tagged - Do we use tagged queueing (non-0) or do we treat
>> 910 * this device as an untagged device (0)
>> 911 * tags - Number of tags allowed if tagged queueing enabled,
>> 912 * or number of commands the low level driver can
>> 913 * queue up in non-tagged mode (as per cmd_per_lun).
780 * 914 *
781 * Returns: Nothing 915 * Returns: Nothing
782 * 916 *
783 * Lock Status: None held on entry 917 * Lock Status: None held on entry
784 * 918 *
785 * Notes: Low level drivers may call thi 919 * Notes: Low level drivers may call this at any time and we will do
786 * the right thing depending on w 920 * the right thing depending on whether or not the device is
787 * currently active and whether o 921 * currently active and whether or not it even has the
788 * command blocks built yet. 922 * command blocks built yet.
>> 923 *
>> 924 * XXX(hch): What exactly is device_request_lock trying to protect?
789 */ 925 */
790 void scsi_adjust_queue_depth(struct scsi_devic 926 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
791 { 927 {
>> 928 static DEFINE_SPINLOCK(device_request_lock);
792 unsigned long flags; 929 unsigned long flags;
793 930
794 /* 931 /*
795 * refuse to set tagged depth to an un 932 * refuse to set tagged depth to an unworkable size
796 */ 933 */
797 if (tags <= 0) 934 if (tags <= 0)
798 return; 935 return;
799 936
800 spin_lock_irqsave(sdev->request_queue- !! 937 spin_lock_irqsave(&device_request_lock, flags);
>> 938 spin_lock(sdev->request_queue->queue_lock);
801 939
802 /* Check to see if the queue is manage !! 940 /* Check to see if the queue is managed by the block layer
803 * If it is, and we fail to adjust the !! 941 * if it is, and we fail to adjust the depth, exit */
804 if (blk_queue_tagged(sdev->request_que 942 if (blk_queue_tagged(sdev->request_queue) &&
805 blk_queue_resize_tags(sdev->reques 943 blk_queue_resize_tags(sdev->request_queue, tags) != 0)
806 goto out; 944 goto out;
807 945
808 sdev->queue_depth = tags; 946 sdev->queue_depth = tags;
809 switch (tagged) { 947 switch (tagged) {
810 case MSG_ORDERED_TAG: 948 case MSG_ORDERED_TAG:
811 sdev->ordered_tags = 1 949 sdev->ordered_tags = 1;
812 sdev->simple_tags = 1; 950 sdev->simple_tags = 1;
813 break; 951 break;
814 case MSG_SIMPLE_TAG: 952 case MSG_SIMPLE_TAG:
815 sdev->ordered_tags = 0 953 sdev->ordered_tags = 0;
816 sdev->simple_tags = 1; 954 sdev->simple_tags = 1;
817 break; 955 break;
818 default: 956 default:
819 sdev_printk(KERN_WARNI !! 957 printk(KERN_WARNING "(scsi%d:%d:%d:%d) "
820 "scsi_adju !! 958 "scsi_adjust_queue_depth, bad queue type, "
821 "disabled\ !! 959 "disabled\n", sdev->host->host_no,
>> 960 sdev->channel, sdev->id, sdev->lun);
822 case 0: 961 case 0:
823 sdev->ordered_tags = s 962 sdev->ordered_tags = sdev->simple_tags = 0;
824 sdev->queue_depth = ta 963 sdev->queue_depth = tags;
825 break; 964 break;
826 } 965 }
827 out: 966 out:
828 spin_unlock_irqrestore(sdev->request_q !! 967 spin_unlock(sdev->request_queue->queue_lock);
>> 968 spin_unlock_irqrestore(&device_request_lock, flags);
829 } 969 }
830 EXPORT_SYMBOL(scsi_adjust_queue_depth); 970 EXPORT_SYMBOL(scsi_adjust_queue_depth);
831 971
832 /** !! 972 /*
833 * scsi_track_queue_full - track QUEUE_FULL ev !! 973 * Function: scsi_track_queue_full()
834 * @sdev: SCSI Device in question <<
835 * @depth: Current number of outstanding SCSI <<
836 * not counting the one returned as QU <<
837 * 974 *
838 * Description: This function will track succe !! 975 * Purpose: This function will track successive QUEUE_FULL events on a
839 * specific SCSI device to determ 976 * specific SCSI device to determine if and when there is a
840 * need to adjust the queue depth 977 * need to adjust the queue depth on the device.
841 * 978 *
842 * Returns: 0 - No change needed, >0 - Adj !! 979 * Arguments: sdev - SCSI Device in question
>> 980 * depth - Current number of outstanding SCSI commands on
>> 981 * this device, not counting the one returned as
>> 982 * QUEUE_FULL.
>> 983 *
>> 984 * Returns: 0 - No change needed
>> 985 * >0 - Adjust queue depth to this new depth
843 * -1 - Drop back to untagged ope 986 * -1 - Drop back to untagged operation using host->cmd_per_lun
844 * as the untagged comman 987 * as the untagged command depth
845 * 988 *
846 * Lock Status: None held on entry 989 * Lock Status: None held on entry
847 * 990 *
848 * Notes: Low level drivers may call thi 991 * Notes: Low level drivers may call this at any time and we will do
849 * "The Right Thing." We are int 992 * "The Right Thing." We are interrupt context safe.
850 */ 993 */
851 int scsi_track_queue_full(struct scsi_device * 994 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
852 { 995 {
853 if ((jiffies >> 4) == sdev->last_queue 996 if ((jiffies >> 4) == sdev->last_queue_full_time)
854 return 0; 997 return 0;
855 998
856 sdev->last_queue_full_time = (jiffies 999 sdev->last_queue_full_time = (jiffies >> 4);
857 if (sdev->last_queue_full_depth != dep 1000 if (sdev->last_queue_full_depth != depth) {
858 sdev->last_queue_full_count = 1001 sdev->last_queue_full_count = 1;
859 sdev->last_queue_full_depth = 1002 sdev->last_queue_full_depth = depth;
860 } else { 1003 } else {
861 sdev->last_queue_full_count++; 1004 sdev->last_queue_full_count++;
862 } 1005 }
863 1006
864 if (sdev->last_queue_full_count <= 10) 1007 if (sdev->last_queue_full_count <= 10)
865 return 0; 1008 return 0;
866 if (sdev->last_queue_full_depth < 8) { 1009 if (sdev->last_queue_full_depth < 8) {
867 /* Drop back to untagged */ 1010 /* Drop back to untagged */
868 scsi_adjust_queue_depth(sdev, 1011 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
869 return -1; 1012 return -1;
870 } 1013 }
871 1014
872 if (sdev->ordered_tags) 1015 if (sdev->ordered_tags)
873 scsi_adjust_queue_depth(sdev, 1016 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
874 else 1017 else
875 scsi_adjust_queue_depth(sdev, 1018 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
876 return depth; 1019 return depth;
877 } 1020 }
878 EXPORT_SYMBOL(scsi_track_queue_full); 1021 EXPORT_SYMBOL(scsi_track_queue_full);
879 1022
880 /** 1023 /**
881 * scsi_device_get - get an additional refer !! 1024 * scsi_device_get - get an addition reference to a scsi_device
882 * @sdev: device to get a reference to 1025 * @sdev: device to get a reference to
883 * 1026 *
884 * Description: Gets a reference to the scsi_d !! 1027 * Gets a reference to the scsi_device and increments the use count
885 * of the underlying LLDD module. You must ho 1028 * of the underlying LLDD module. You must hold host_lock of the
886 * parent Scsi_Host or already have a referenc 1029 * parent Scsi_Host or already have a reference when calling this.
887 */ 1030 */
888 int scsi_device_get(struct scsi_device *sdev) 1031 int scsi_device_get(struct scsi_device *sdev)
889 { 1032 {
890 if (sdev->sdev_state == SDEV_DEL) !! 1033 if (sdev->sdev_state == SDEV_DEL || sdev->sdev_state == SDEV_CANCEL)
891 return -ENXIO; 1034 return -ENXIO;
892 if (!get_device(&sdev->sdev_gendev)) 1035 if (!get_device(&sdev->sdev_gendev))
893 return -ENXIO; 1036 return -ENXIO;
894 /* We can fail this if we're doing SCS !! 1037 if (!try_module_get(sdev->host->hostt->module)) {
895 * from module exit (like cache flush) !! 1038 put_device(&sdev->sdev_gendev);
896 try_module_get(sdev->host->hostt->modu !! 1039 return -ENXIO;
897 !! 1040 }
898 return 0; 1041 return 0;
899 } 1042 }
900 EXPORT_SYMBOL(scsi_device_get); 1043 EXPORT_SYMBOL(scsi_device_get);
901 1044
902 /** 1045 /**
903 * scsi_device_put - release a reference to 1046 * scsi_device_put - release a reference to a scsi_device
904 * @sdev: device to release a reference 1047 * @sdev: device to release a reference on.
905 * 1048 *
906 * Description: Release a reference to the scs !! 1049 * Release a reference to the scsi_device and decrements the use count
907 * count of the underlying LLDD module. The d !! 1050 * of the underlying LLDD module. The device is freed once the last
908 * user vanishes. 1051 * user vanishes.
909 */ 1052 */
910 void scsi_device_put(struct scsi_device *sdev) 1053 void scsi_device_put(struct scsi_device *sdev)
911 { 1054 {
912 #ifdef CONFIG_MODULE_UNLOAD !! 1055 module_put(sdev->host->hostt->module);
913 struct module *module = sdev->host->ho <<
914 <<
915 /* The module refcount will be zero if <<
916 * was called from a module removal ro <<
917 if (module && module_refcount(module) <<
918 module_put(module); <<
919 #endif <<
920 put_device(&sdev->sdev_gendev); 1056 put_device(&sdev->sdev_gendev);
921 } 1057 }
922 EXPORT_SYMBOL(scsi_device_put); 1058 EXPORT_SYMBOL(scsi_device_put);
923 1059
924 /* helper for shost_for_each_device, see that !! 1060 /* helper for shost_for_each_device, thus not documented */
925 struct scsi_device *__scsi_iterate_devices(str 1061 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
926 str 1062 struct scsi_device *prev)
927 { 1063 {
928 struct list_head *list = (prev ? &prev 1064 struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
929 struct scsi_device *next = NULL; 1065 struct scsi_device *next = NULL;
930 unsigned long flags; 1066 unsigned long flags;
931 1067
932 spin_lock_irqsave(shost->host_lock, fl 1068 spin_lock_irqsave(shost->host_lock, flags);
933 while (list->next != &shost->__devices 1069 while (list->next != &shost->__devices) {
934 next = list_entry(list->next, 1070 next = list_entry(list->next, struct scsi_device, siblings);
935 /* skip devices that we can't 1071 /* skip devices that we can't get a reference to */
936 if (!scsi_device_get(next)) 1072 if (!scsi_device_get(next))
937 break; 1073 break;
938 next = NULL; 1074 next = NULL;
939 list = list->next; 1075 list = list->next;
940 } 1076 }
941 spin_unlock_irqrestore(shost->host_loc 1077 spin_unlock_irqrestore(shost->host_lock, flags);
942 1078
943 if (prev) 1079 if (prev)
944 scsi_device_put(prev); 1080 scsi_device_put(prev);
945 return next; 1081 return next;
946 } 1082 }
947 EXPORT_SYMBOL(__scsi_iterate_devices); 1083 EXPORT_SYMBOL(__scsi_iterate_devices);
948 1084
949 /** 1085 /**
950 * starget_for_each_device - helper to walk 1086 * starget_for_each_device - helper to walk all devices of a target
951 * @starget: target whose devices we want t 1087 * @starget: target whose devices we want to iterate over.
952 * @data: Opaque passed to each function <<
953 * @fn: Function to call on each devic <<
954 * 1088 *
955 * This traverses over each device of @starget !! 1089 * This traverses over each devices of @shost. The devices have
956 * a reference that must be released by scsi_h 1090 * a reference that must be released by scsi_host_put when breaking
957 * out of the loop. 1091 * out of the loop.
958 */ 1092 */
959 void starget_for_each_device(struct scsi_targe !! 1093 void starget_for_each_device(struct scsi_target *starget, void * data,
960 void (*fn)(struct scsi_de 1094 void (*fn)(struct scsi_device *, void *))
961 { 1095 {
962 struct Scsi_Host *shost = dev_to_shost 1096 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
963 struct scsi_device *sdev; 1097 struct scsi_device *sdev;
964 1098
965 shost_for_each_device(sdev, shost) { 1099 shost_for_each_device(sdev, shost) {
966 if ((sdev->channel == starget- 1100 if ((sdev->channel == starget->channel) &&
967 (sdev->id == starget->id)) 1101 (sdev->id == starget->id))
968 fn(sdev, data); 1102 fn(sdev, data);
969 } 1103 }
970 } 1104 }
971 EXPORT_SYMBOL(starget_for_each_device); 1105 EXPORT_SYMBOL(starget_for_each_device);
972 1106
973 /** 1107 /**
974 * __starget_for_each_device - helper to walk !! 1108 * scsi_device_lookup - find a device given the host (UNLOCKED)
975 * @starget: target whose devices we want t <<
976 * @data: parameter for callback @fn() <<
977 * @fn: callback function that is invo <<
978 * <<
979 * This traverses over each device of @starget <<
980 * take a reference on the scsi_device, so the <<
981 * protected by shost->host_lock. <<
982 * <<
983 * Note: The only reason why drivers would wa <<
984 * they need to access the device list in irq <<
985 * really want to use starget_for_each_device <<
986 **/ <<
987 void __starget_for_each_device(struct scsi_tar <<
988 void (*fn)(stru <<
989 { <<
990 struct Scsi_Host *shost = dev_to_shost <<
991 struct scsi_device *sdev; <<
992 <<
993 __shost_for_each_device(sdev, shost) { <<
994 if ((sdev->channel == starget- <<
995 (sdev->id == starget->id)) <<
996 fn(sdev, data); <<
997 } <<
998 } <<
999 EXPORT_SYMBOL(__starget_for_each_device); <<
1000 <<
1001 /** <<
1002 * __scsi_device_lookup_by_target - find a de <<
1003 * @starget: SCSI target pointer <<
1004 * @lun: SCSI Logical Unit Number <<
1005 * <<
1006 * Description: Looks up the scsi_device with <<
1007 * @starget. The returned scsi_device does n <<
1008 * reference. You must hold the host's host_ <<
1009 * any access to the returned scsi_device. <<
1010 * <<
1011 * Note: The only reason why drivers should <<
1012 * they need to access the device list in irq <<
1013 * really want to use scsi_device_lookup_by_t <<
1014 **/ <<
1015 struct scsi_device *__scsi_device_lookup_by_t <<
1016 <<
1017 { <<
1018 struct scsi_device *sdev; <<
1019 <<
1020 list_for_each_entry(sdev, &starget->d <<
1021 if (sdev->lun ==lun) <<
1022 return sdev; <<
1023 } <<
1024 <<
1025 return NULL; <<
1026 } <<
1027 EXPORT_SYMBOL(__scsi_device_lookup_by_target) <<
1028 <<
1029 /** <<
1030 * scsi_device_lookup_by_target - find a devi <<
1031 * @starget: SCSI target pointer <<
1032 * @lun: SCSI Logical Unit Number <<
1033 * <<
1034 * Description: Looks up the scsi_device with <<
1035 * for a given host. The returned scsi_devic <<
1036 * needs to be released with scsi_device_put <<
1037 **/ <<
1038 struct scsi_device *scsi_device_lookup_by_tar <<
1039 <<
1040 { <<
1041 struct scsi_device *sdev; <<
1042 struct Scsi_Host *shost = dev_to_shos <<
1043 unsigned long flags; <<
1044 <<
1045 spin_lock_irqsave(shost->host_lock, f <<
1046 sdev = __scsi_device_lookup_by_target <<
1047 if (sdev && scsi_device_get(sdev)) <<
1048 sdev = NULL; <<
1049 spin_unlock_irqrestore(shost->host_lo <<
1050 <<
1051 return sdev; <<
1052 } <<
1053 EXPORT_SYMBOL(scsi_device_lookup_by_target); <<
1054 <<
1055 /** <<
1056 * __scsi_device_lookup - find a device given <<
1057 * @shost: SCSI host pointer 1109 * @shost: SCSI host pointer
1058 * @channel: SCSI channel (zero if only on 1110 * @channel: SCSI channel (zero if only one channel)
1059 * @id: SCSI target number (physical !! 1111 * @pun: SCSI target number (physical unit number)
1060 * @lun: SCSI Logical Unit Number 1112 * @lun: SCSI Logical Unit Number
1061 * 1113 *
1062 * Description: Looks up the scsi_device with !! 1114 * Looks up the scsi_device with the specified @channel, @id, @lun for a
1063 * for a given host. The returned scsi_device !! 1115 * give host. The returned scsi_device does not have an additional reference.
1064 * reference. You must hold the host's host_ !! 1116 * You must hold the host's host_lock over this call and any access to the
1065 * to the returned scsi_device. !! 1117 * returned scsi_device.
1066 * 1118 *
1067 * Note: The only reason why drivers would w 1119 * Note: The only reason why drivers would want to use this is because
1068 * they need to access the device list in irq !! 1120 * they're need to access the device list in irq context. Otherwise you
1069 * really want to use scsi_device_lookup inst 1121 * really want to use scsi_device_lookup instead.
1070 **/ 1122 **/
1071 struct scsi_device *__scsi_device_lookup(stru 1123 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1072 uint channel, uint id, uint l 1124 uint channel, uint id, uint lun)
1073 { 1125 {
1074 struct scsi_device *sdev; 1126 struct scsi_device *sdev;
1075 1127
1076 list_for_each_entry(sdev, &shost->__d 1128 list_for_each_entry(sdev, &shost->__devices, siblings) {
1077 if (sdev->channel == channel 1129 if (sdev->channel == channel && sdev->id == id &&
1078 sdev->lun ==l 1130 sdev->lun ==lun)
1079 return sdev; 1131 return sdev;
1080 } 1132 }
1081 1133
1082 return NULL; 1134 return NULL;
1083 } 1135 }
1084 EXPORT_SYMBOL(__scsi_device_lookup); 1136 EXPORT_SYMBOL(__scsi_device_lookup);
1085 1137
1086 /** 1138 /**
1087 * scsi_device_lookup - find a device given t 1139 * scsi_device_lookup - find a device given the host
1088 * @shost: SCSI host pointer 1140 * @shost: SCSI host pointer
1089 * @channel: SCSI channel (zero if only on 1141 * @channel: SCSI channel (zero if only one channel)
1090 * @id: SCSI target number (physical 1142 * @id: SCSI target number (physical unit number)
1091 * @lun: SCSI Logical Unit Number 1143 * @lun: SCSI Logical Unit Number
1092 * 1144 *
1093 * Description: Looks up the scsi_device with !! 1145 * Looks up the scsi_device with the specified @channel, @id, @lun for a
1094 * for a given host. The returned scsi_devic !! 1146 * give host. The returned scsi_device has an additional reference that
1095 * needs to be released with scsi_device_put !! 1147 * needs to be release with scsi_host_put once you're done with it.
1096 **/ 1148 **/
1097 struct scsi_device *scsi_device_lookup(struct 1149 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1098 uint channel, uint id, uint l 1150 uint channel, uint id, uint lun)
1099 { 1151 {
1100 struct scsi_device *sdev; 1152 struct scsi_device *sdev;
1101 unsigned long flags; 1153 unsigned long flags;
1102 1154
1103 spin_lock_irqsave(shost->host_lock, f 1155 spin_lock_irqsave(shost->host_lock, flags);
1104 sdev = __scsi_device_lookup(shost, ch 1156 sdev = __scsi_device_lookup(shost, channel, id, lun);
1105 if (sdev && scsi_device_get(sdev)) 1157 if (sdev && scsi_device_get(sdev))
1106 sdev = NULL; 1158 sdev = NULL;
1107 spin_unlock_irqrestore(shost->host_lo 1159 spin_unlock_irqrestore(shost->host_lock, flags);
1108 1160
1109 return sdev; 1161 return sdev;
1110 } 1162 }
1111 EXPORT_SYMBOL(scsi_device_lookup); 1163 EXPORT_SYMBOL(scsi_device_lookup);
1112 1164
>> 1165 /**
>> 1166 * scsi_device_cancel - cancel outstanding IO to this device
>> 1167 * @sdev: Pointer to struct scsi_device
>> 1168 * @recovery: Boolean instructing function to recover device or not.
>> 1169 *
>> 1170 **/
>> 1171 int scsi_device_cancel(struct scsi_device *sdev, int recovery)
>> 1172 {
>> 1173 struct scsi_cmnd *scmd;
>> 1174 LIST_HEAD(active_list);
>> 1175 struct list_head *lh, *lh_sf;
>> 1176 unsigned long flags;
>> 1177
>> 1178 scsi_device_set_state(sdev, SDEV_CANCEL);
>> 1179
>> 1180 spin_lock_irqsave(&sdev->list_lock, flags);
>> 1181 list_for_each_entry(scmd, &sdev->cmd_list, list) {
>> 1182 if (scmd->request && scmd->request->rq_status != RQ_INACTIVE) {
>> 1183 /*
>> 1184 * If we are unable to remove the timer, it means
>> 1185 * that the command has already timed out or
>> 1186 * finished.
>> 1187 */
>> 1188 if (!scsi_delete_timer(scmd))
>> 1189 continue;
>> 1190 list_add_tail(&scmd->eh_entry, &active_list);
>> 1191 }
>> 1192 }
>> 1193 spin_unlock_irqrestore(&sdev->list_lock, flags);
>> 1194
>> 1195 if (!list_empty(&active_list)) {
>> 1196 list_for_each_safe(lh, lh_sf, &active_list) {
>> 1197 scmd = list_entry(lh, struct scsi_cmnd, eh_entry);
>> 1198 list_del_init(lh);
>> 1199 if (recovery) {
>> 1200 scsi_eh_scmd_add(scmd, SCSI_EH_CANCEL_CMD);
>> 1201 } else {
>> 1202 scmd->result = (DID_ABORT << 16);
>> 1203 scsi_finish_command(scmd);
>> 1204 }
>> 1205 }
>> 1206 }
>> 1207
>> 1208 return 0;
>> 1209 }
>> 1210 EXPORT_SYMBOL(scsi_device_cancel);
>> 1211
>> 1212 #ifdef CONFIG_HOTPLUG_CPU
>> 1213 static int scsi_cpu_notify(struct notifier_block *self,
>> 1214 unsigned long action, void *hcpu)
>> 1215 {
>> 1216 int cpu = (unsigned long)hcpu;
>> 1217
>> 1218 switch(action) {
>> 1219 case CPU_DEAD:
>> 1220 /* Drain scsi_done_q. */
>> 1221 local_irq_disable();
>> 1222 list_splice_init(&per_cpu(scsi_done_q, cpu),
>> 1223 &__get_cpu_var(scsi_done_q));
>> 1224 raise_softirq_irqoff(SCSI_SOFTIRQ);
>> 1225 local_irq_enable();
>> 1226 break;
>> 1227 default:
>> 1228 break;
>> 1229 }
>> 1230 return NOTIFY_OK;
>> 1231 }
>> 1232
>> 1233 static struct notifier_block __devinitdata scsi_cpu_nb = {
>> 1234 .notifier_call = scsi_cpu_notify,
>> 1235 };
>> 1236
>> 1237 #define register_scsi_cpu() register_cpu_notifier(&scsi_cpu_nb)
>> 1238 #define unregister_scsi_cpu() unregister_cpu_notifier(&scsi_cpu_nb)
>> 1239 #else
>> 1240 #define register_scsi_cpu()
>> 1241 #define unregister_scsi_cpu()
>> 1242 #endif /* CONFIG_HOTPLUG_CPU */
>> 1243
1113 MODULE_DESCRIPTION("SCSI core"); 1244 MODULE_DESCRIPTION("SCSI core");
1114 MODULE_LICENSE("GPL"); 1245 MODULE_LICENSE("GPL");
1115 1246
1116 module_param(scsi_logging_level, int, S_IRUGO 1247 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1117 MODULE_PARM_DESC(scsi_logging_level, "a bit m 1248 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1118 1249
1119 static int __init init_scsi(void) 1250 static int __init init_scsi(void)
1120 { 1251 {
1121 int error; !! 1252 int error, i;
1122 1253
1123 error = scsi_init_queue(); 1254 error = scsi_init_queue();
1124 if (error) 1255 if (error)
1125 return error; 1256 return error;
1126 error = scsi_init_procfs(); 1257 error = scsi_init_procfs();
1127 if (error) 1258 if (error)
1128 goto cleanup_queue; 1259 goto cleanup_queue;
1129 error = scsi_init_devinfo(); 1260 error = scsi_init_devinfo();
1130 if (error) 1261 if (error)
1131 goto cleanup_procfs; 1262 goto cleanup_procfs;
1132 error = scsi_init_hosts(); 1263 error = scsi_init_hosts();
1133 if (error) 1264 if (error)
1134 goto cleanup_devlist; 1265 goto cleanup_devlist;
1135 error = scsi_init_sysctl(); 1266 error = scsi_init_sysctl();
1136 if (error) 1267 if (error)
1137 goto cleanup_hosts; 1268 goto cleanup_hosts;
1138 error = scsi_sysfs_register(); 1269 error = scsi_sysfs_register();
1139 if (error) 1270 if (error)
1140 goto cleanup_sysctl; 1271 goto cleanup_sysctl;
1141 1272
1142 scsi_netlink_init(); !! 1273 for (i = 0; i < NR_CPUS; i++)
>> 1274 INIT_LIST_HEAD(&per_cpu(scsi_done_q, i));
1143 1275
>> 1276 devfs_mk_dir("scsi");
>> 1277 open_softirq(SCSI_SOFTIRQ, scsi_softirq, NULL);
>> 1278 register_scsi_cpu();
1144 printk(KERN_NOTICE "SCSI subsystem in 1279 printk(KERN_NOTICE "SCSI subsystem initialized\n");
1145 return 0; 1280 return 0;
1146 1281
1147 cleanup_sysctl: 1282 cleanup_sysctl:
1148 scsi_exit_sysctl(); 1283 scsi_exit_sysctl();
1149 cleanup_hosts: 1284 cleanup_hosts:
1150 scsi_exit_hosts(); 1285 scsi_exit_hosts();
1151 cleanup_devlist: 1286 cleanup_devlist:
1152 scsi_exit_devinfo(); 1287 scsi_exit_devinfo();
1153 cleanup_procfs: 1288 cleanup_procfs:
1154 scsi_exit_procfs(); 1289 scsi_exit_procfs();
1155 cleanup_queue: 1290 cleanup_queue:
1156 scsi_exit_queue(); 1291 scsi_exit_queue();
1157 printk(KERN_ERR "SCSI subsystem faile 1292 printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1158 -error); 1293 -error);
1159 return error; 1294 return error;
1160 } 1295 }
1161 1296
1162 static void __exit exit_scsi(void) 1297 static void __exit exit_scsi(void)
1163 { 1298 {
1164 scsi_netlink_exit(); <<
1165 scsi_sysfs_unregister(); 1299 scsi_sysfs_unregister();
1166 scsi_exit_sysctl(); 1300 scsi_exit_sysctl();
1167 scsi_exit_hosts(); 1301 scsi_exit_hosts();
1168 scsi_exit_devinfo(); 1302 scsi_exit_devinfo();
>> 1303 devfs_remove("scsi");
1169 scsi_exit_procfs(); 1304 scsi_exit_procfs();
1170 scsi_exit_queue(); 1305 scsi_exit_queue();
>> 1306 unregister_scsi_cpu();
1171 } 1307 }
1172 1308
1173 subsys_initcall(init_scsi); 1309 subsys_initcall(init_scsi);
1174 module_exit(exit_scsi); 1310 module_exit(exit_scsi);
1175 1311
|
This page was automatically generated by the
LXR engine.
|