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/timer.h> 43 #include <linux/timer.h>
44 #include <linux/string.h> 44 #include <linux/string.h>
45 #include <linux/slab.h> 45 #include <linux/slab.h>
46 #include <linux/blkdev.h> 46 #include <linux/blkdev.h>
47 #include <linux/delay.h> 47 #include <linux/delay.h>
48 #include <linux/init.h> 48 #include <linux/init.h>
49 #include <linux/completion.h> 49 #include <linux/completion.h>
50 #include <linux/unistd.h> 50 #include <linux/unistd.h>
51 #include <linux/spinlock.h> 51 #include <linux/spinlock.h>
52 #include <linux/kmod.h> 52 #include <linux/kmod.h>
53 #include <linux/interrupt.h> 53 #include <linux/interrupt.h>
54 #include <linux/notifier.h> 54 #include <linux/notifier.h>
55 #include <linux/cpu.h> 55 #include <linux/cpu.h>
56 #include <linux/mutex.h> 56 #include <linux/mutex.h>
57 57
58 #include <scsi/scsi.h> 58 #include <scsi/scsi.h>
59 #include <scsi/scsi_cmnd.h> 59 #include <scsi/scsi_cmnd.h>
60 #include <scsi/scsi_dbg.h> 60 #include <scsi/scsi_dbg.h>
61 #include <scsi/scsi_device.h> 61 #include <scsi/scsi_device.h>
62 #include <scsi/scsi_driver.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 66
67 #include "scsi_priv.h" 67 #include "scsi_priv.h"
68 #include "scsi_logging.h" 68 #include "scsi_logging.h"
69 69
70 static void scsi_done(struct scsi_cmnd *cmd); 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 * Note - the initial logging level can be set 91 * 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 92 * After the system is up, you may enable logging via the /proc interface.
93 */ 93 */
94 unsigned int scsi_logging_level; 94 unsigned int scsi_logging_level;
95 #if defined(CONFIG_SCSI_LOGGING) 95 #if defined(CONFIG_SCSI_LOGGING)
96 EXPORT_SYMBOL(scsi_logging_level); 96 EXPORT_SYMBOL(scsi_logging_level);
97 #endif 97 #endif
98 98
99 /* NB: These are exposed through /proc/scsi/sc 99 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
100 * You may not alter any existing entry (altho 100 * You may not alter any existing entry (although adding new ones is
101 * encouraged once assigned by ANSI/INCITS T10 101 * encouraged once assigned by ANSI/INCITS T10
102 */ 102 */
103 static const char *const scsi_device_types[] = 103 static const char *const scsi_device_types[] = {
104 "Direct-Access ", 104 "Direct-Access ",
105 "Sequential-Access", 105 "Sequential-Access",
106 "Printer ", 106 "Printer ",
107 "Processor ", 107 "Processor ",
108 "WORM ", 108 "WORM ",
109 "CD-ROM ", 109 "CD-ROM ",
110 "Scanner ", 110 "Scanner ",
111 "Optical Device ", 111 "Optical Device ",
112 "Medium Changer ", 112 "Medium Changer ",
113 "Communications ", 113 "Communications ",
114 "ASC IT8 ", 114 "ASC IT8 ",
115 "ASC IT8 ", 115 "ASC IT8 ",
116 "RAID ", 116 "RAID ",
117 "Enclosure ", 117 "Enclosure ",
118 "Direct-Access-RBC", 118 "Direct-Access-RBC",
119 "Optical card ", 119 "Optical card ",
120 "Bridge controller", 120 "Bridge controller",
121 "Object storage ", 121 "Object storage ",
122 "Automation/Drive ", 122 "Automation/Drive ",
123 }; 123 };
124 124
125 /** 125 /**
126 * scsi_device_type - Return 17 char string in 126 * scsi_device_type - Return 17 char string indicating device type.
127 * @type: type number to look up 127 * @type: type number to look up
128 */ 128 */
129 129
130 const char * scsi_device_type(unsigned type) 130 const char * scsi_device_type(unsigned type)
131 { 131 {
132 if (type == 0x1e) 132 if (type == 0x1e)
133 return "Well-known LUN "; 133 return "Well-known LUN ";
134 if (type == 0x1f) 134 if (type == 0x1f)
135 return "No Device "; 135 return "No Device ";
136 if (type >= ARRAY_SIZE(scsi_device_typ 136 if (type >= ARRAY_SIZE(scsi_device_types))
137 return "Unknown "; 137 return "Unknown ";
138 return scsi_device_types[type]; 138 return scsi_device_types[type];
139 } 139 }
140 140
141 EXPORT_SYMBOL(scsi_device_type); 141 EXPORT_SYMBOL(scsi_device_type);
142 142
143 struct scsi_host_cmd_pool { 143 struct scsi_host_cmd_pool {
144 struct kmem_cache *cmd_slab; 144 struct kmem_cache *cmd_slab;
145 struct kmem_cache *sense_slab; 145 struct kmem_cache *sense_slab;
146 unsigned int users; 146 unsigned int users;
147 char *cmd_name; 147 char *cmd_name;
148 char *sense_name; 148 char *sense_name;
149 unsigned int slab_flags; 149 unsigned int slab_flags;
150 gfp_t gfp_mask; 150 gfp_t gfp_mask;
151 }; 151 };
152 152
153 static struct scsi_host_cmd_pool scsi_cmd_pool 153 static struct scsi_host_cmd_pool scsi_cmd_pool = {
154 .cmd_name = "scsi_cmd_cache", 154 .cmd_name = "scsi_cmd_cache",
155 .sense_name = "scsi_sense_cache", 155 .sense_name = "scsi_sense_cache",
156 .slab_flags = SLAB_HWCACHE_ALIGN, 156 .slab_flags = SLAB_HWCACHE_ALIGN,
157 }; 157 };
158 158
159 static struct scsi_host_cmd_pool scsi_cmd_dma_ 159 static struct scsi_host_cmd_pool scsi_cmd_dma_pool = {
160 .cmd_name = "scsi_cmd_cache(DMA) 160 .cmd_name = "scsi_cmd_cache(DMA)",
161 .sense_name = "scsi_sense_cache(DM 161 .sense_name = "scsi_sense_cache(DMA)",
162 .slab_flags = SLAB_HWCACHE_ALIGN|S 162 .slab_flags = SLAB_HWCACHE_ALIGN|SLAB_CACHE_DMA,
163 .gfp_mask = __GFP_DMA, 163 .gfp_mask = __GFP_DMA,
164 }; 164 };
165 165
166 static DEFINE_MUTEX(host_cmd_pool_mutex); 166 static DEFINE_MUTEX(host_cmd_pool_mutex);
167 167
168 /** 168 /**
169 * __scsi_get_command - Allocate a struct scsi 169 * __scsi_get_command - Allocate a struct scsi_cmnd
170 * @shost: host to transmit command 170 * @shost: host to transmit command
171 * @gfp_mask: allocation mask 171 * @gfp_mask: allocation mask
172 * 172 *
173 * Description: allocate a struct scsi_cmd fro 173 * Description: allocate a struct scsi_cmd from host's slab, recycling from the
174 * host's free_list if necessary. 174 * host's free_list if necessary.
175 */ 175 */
176 struct scsi_cmnd *__scsi_get_command(struct Sc 176 struct scsi_cmnd *__scsi_get_command(struct Scsi_Host *shost, gfp_t gfp_mask)
177 { 177 {
178 struct scsi_cmnd *cmd; 178 struct scsi_cmnd *cmd;
179 unsigned char *buf; 179 unsigned char *buf;
180 180
181 cmd = kmem_cache_alloc(shost->cmd_pool 181 cmd = kmem_cache_alloc(shost->cmd_pool->cmd_slab,
182 gfp_mask | shos 182 gfp_mask | shost->cmd_pool->gfp_mask);
183 183
184 if (likely(cmd)) { 184 if (likely(cmd)) {
185 buf = kmem_cache_alloc(shost-> 185 buf = kmem_cache_alloc(shost->cmd_pool->sense_slab,
186 gfp_mas 186 gfp_mask | shost->cmd_pool->gfp_mask);
187 if (likely(buf)) { 187 if (likely(buf)) {
188 memset(cmd, 0, sizeof( 188 memset(cmd, 0, sizeof(*cmd));
189 cmd->sense_buffer = bu 189 cmd->sense_buffer = buf;
190 } else { 190 } else {
191 kmem_cache_free(shost- 191 kmem_cache_free(shost->cmd_pool->cmd_slab, cmd);
192 cmd = NULL; 192 cmd = NULL;
193 } 193 }
194 } 194 }
195 195
196 if (unlikely(!cmd)) { 196 if (unlikely(!cmd)) {
197 unsigned long flags; 197 unsigned long flags;
198 198
199 spin_lock_irqsave(&shost->free 199 spin_lock_irqsave(&shost->free_list_lock, flags);
200 if (likely(!list_empty(&shost- 200 if (likely(!list_empty(&shost->free_list))) {
201 cmd = list_entry(shost 201 cmd = list_entry(shost->free_list.next,
202 struc 202 struct scsi_cmnd, list);
203 list_del_init(&cmd->li 203 list_del_init(&cmd->list);
204 } 204 }
205 spin_unlock_irqrestore(&shost- 205 spin_unlock_irqrestore(&shost->free_list_lock, flags);
206 206
207 if (cmd) { 207 if (cmd) {
208 buf = cmd->sense_buffe 208 buf = cmd->sense_buffer;
209 memset(cmd, 0, sizeof( 209 memset(cmd, 0, sizeof(*cmd));
210 cmd->sense_buffer = bu 210 cmd->sense_buffer = buf;
211 } 211 }
212 } 212 }
213 213
214 return cmd; 214 return cmd;
215 } 215 }
216 EXPORT_SYMBOL_GPL(__scsi_get_command); 216 EXPORT_SYMBOL_GPL(__scsi_get_command);
217 217
218 /** 218 /**
219 * scsi_get_command - Allocate and setup a scs 219 * scsi_get_command - Allocate and setup a scsi command block
220 * @dev: parent scsi device 220 * @dev: parent scsi device
221 * @gfp_mask: allocator flags 221 * @gfp_mask: allocator flags
222 * 222 *
223 * Returns: The allocated scsi command str 223 * Returns: The allocated scsi command structure.
224 */ 224 */
225 struct scsi_cmnd *scsi_get_command(struct scsi 225 struct scsi_cmnd *scsi_get_command(struct scsi_device *dev, gfp_t gfp_mask)
226 { 226 {
227 struct scsi_cmnd *cmd; 227 struct scsi_cmnd *cmd;
228 228
229 /* Bail if we can't get a reference to 229 /* Bail if we can't get a reference to the device */
230 if (!get_device(&dev->sdev_gendev)) 230 if (!get_device(&dev->sdev_gendev))
231 return NULL; 231 return NULL;
232 232
233 cmd = __scsi_get_command(dev->host, gf 233 cmd = __scsi_get_command(dev->host, gfp_mask);
234 234
235 if (likely(cmd != NULL)) { 235 if (likely(cmd != NULL)) {
236 unsigned long flags; 236 unsigned long flags;
237 237
238 cmd->device = dev; 238 cmd->device = dev;
239 init_timer(&cmd->eh_timeout); 239 init_timer(&cmd->eh_timeout);
240 INIT_LIST_HEAD(&cmd->list); 240 INIT_LIST_HEAD(&cmd->list);
241 spin_lock_irqsave(&dev->list_l 241 spin_lock_irqsave(&dev->list_lock, flags);
242 list_add_tail(&cmd->list, &dev 242 list_add_tail(&cmd->list, &dev->cmd_list);
243 spin_unlock_irqrestore(&dev->l 243 spin_unlock_irqrestore(&dev->list_lock, flags);
244 cmd->jiffies_at_alloc = jiffie 244 cmd->jiffies_at_alloc = jiffies;
245 } else 245 } else
246 put_device(&dev->sdev_gendev); 246 put_device(&dev->sdev_gendev);
247 247
248 return cmd; 248 return cmd;
249 } 249 }
250 EXPORT_SYMBOL(scsi_get_command); 250 EXPORT_SYMBOL(scsi_get_command);
251 251
252 /** 252 /**
253 * __scsi_put_command - Free a struct scsi_cmn 253 * __scsi_put_command - Free a struct scsi_cmnd
254 * @shost: dev->host 254 * @shost: dev->host
255 * @cmd: Command to free 255 * @cmd: Command to free
256 * @dev: parent scsi device 256 * @dev: parent scsi device
257 */ 257 */
258 void __scsi_put_command(struct Scsi_Host *shos 258 void __scsi_put_command(struct Scsi_Host *shost, struct scsi_cmnd *cmd,
259 struct device *dev) 259 struct device *dev)
260 { 260 {
261 unsigned long flags; 261 unsigned long flags;
262 262
263 /* changing locks here, don't need to 263 /* changing locks here, don't need to restore the irq state */
264 spin_lock_irqsave(&shost->free_list_lo 264 spin_lock_irqsave(&shost->free_list_lock, flags);
265 if (unlikely(list_empty(&shost->free_l 265 if (unlikely(list_empty(&shost->free_list))) {
266 list_add(&cmd->list, &shost->f 266 list_add(&cmd->list, &shost->free_list);
267 cmd = NULL; 267 cmd = NULL;
268 } 268 }
269 spin_unlock_irqrestore(&shost->free_li 269 spin_unlock_irqrestore(&shost->free_list_lock, flags);
270 270
271 if (likely(cmd != NULL)) { 271 if (likely(cmd != NULL)) {
272 kmem_cache_free(shost->cmd_poo 272 kmem_cache_free(shost->cmd_pool->sense_slab,
273 cmd->sense_buf 273 cmd->sense_buffer);
274 kmem_cache_free(shost->cmd_poo 274 kmem_cache_free(shost->cmd_pool->cmd_slab, cmd);
275 } 275 }
276 276
277 put_device(dev); 277 put_device(dev);
278 } 278 }
279 EXPORT_SYMBOL(__scsi_put_command); 279 EXPORT_SYMBOL(__scsi_put_command);
280 280
281 /** 281 /**
282 * scsi_put_command - Free a scsi command bloc 282 * scsi_put_command - Free a scsi command block
283 * @cmd: command block to free 283 * @cmd: command block to free
284 * 284 *
285 * Returns: Nothing. 285 * Returns: Nothing.
286 * 286 *
287 * Notes: The command must not belong to 287 * Notes: The command must not belong to any lists.
288 */ 288 */
289 void scsi_put_command(struct scsi_cmnd *cmd) 289 void scsi_put_command(struct scsi_cmnd *cmd)
290 { 290 {
291 struct scsi_device *sdev = cmd->device 291 struct scsi_device *sdev = cmd->device;
292 unsigned long flags; 292 unsigned long flags;
293 293
294 /* serious error if the command hasn't 294 /* serious error if the command hasn't come from a device list */
295 spin_lock_irqsave(&cmd->device->list_l 295 spin_lock_irqsave(&cmd->device->list_lock, flags);
296 BUG_ON(list_empty(&cmd->list)); 296 BUG_ON(list_empty(&cmd->list));
297 list_del_init(&cmd->list); 297 list_del_init(&cmd->list);
298 spin_unlock_irqrestore(&cmd->device->l 298 spin_unlock_irqrestore(&cmd->device->list_lock, flags);
299 299
300 __scsi_put_command(cmd->device->host, 300 __scsi_put_command(cmd->device->host, cmd, &sdev->sdev_gendev);
301 } 301 }
302 EXPORT_SYMBOL(scsi_put_command); 302 EXPORT_SYMBOL(scsi_put_command);
303 303
304 /** 304 /**
305 * scsi_setup_command_freelist - Setup the com 305 * scsi_setup_command_freelist - Setup the command freelist for a scsi host.
306 * @shost: host to allocate the freelist for. 306 * @shost: host to allocate the freelist for.
307 * 307 *
308 * Description: The command freelist protects 308 * Description: The command freelist protects against system-wide out of memory
309 * deadlock by preallocating one SCSI command 309 * deadlock by preallocating one SCSI command structure for each host, so the
310 * system can always write to a swap file on a 310 * system can always write to a swap file on a device associated with that host.
311 * 311 *
312 * Returns: Nothing. 312 * Returns: Nothing.
313 */ 313 */
314 int scsi_setup_command_freelist(struct Scsi_Ho 314 int scsi_setup_command_freelist(struct Scsi_Host *shost)
315 { 315 {
316 struct scsi_host_cmd_pool *pool; 316 struct scsi_host_cmd_pool *pool;
317 struct scsi_cmnd *cmd; 317 struct scsi_cmnd *cmd;
318 318
319 spin_lock_init(&shost->free_list_lock) 319 spin_lock_init(&shost->free_list_lock);
320 INIT_LIST_HEAD(&shost->free_list); 320 INIT_LIST_HEAD(&shost->free_list);
321 321
322 /* 322 /*
323 * Select a command slab for this host 323 * Select a command slab for this host and create it if not
324 * yet existent. 324 * yet existent.
325 */ 325 */
326 mutex_lock(&host_cmd_pool_mutex); 326 mutex_lock(&host_cmd_pool_mutex);
327 pool = (shost->unchecked_isa_dma ? &sc 327 pool = (shost->unchecked_isa_dma ? &scsi_cmd_dma_pool : &scsi_cmd_pool);
328 if (!pool->users) { 328 if (!pool->users) {
329 pool->cmd_slab = kmem_cache_cr 329 pool->cmd_slab = kmem_cache_create(pool->cmd_name,
330 330 sizeof(struct scsi_cmnd), 0,
331 331 pool->slab_flags, NULL);
332 if (!pool->cmd_slab) 332 if (!pool->cmd_slab)
333 goto fail; 333 goto fail;
334 334
335 pool->sense_slab = kmem_cache_ 335 pool->sense_slab = kmem_cache_create(pool->sense_name,
336 336 SCSI_SENSE_BUFFERSIZE, 0,
337 337 pool->slab_flags, NULL);
338 if (!pool->sense_slab) { 338 if (!pool->sense_slab) {
339 kmem_cache_destroy(poo 339 kmem_cache_destroy(pool->cmd_slab);
340 goto fail; 340 goto fail;
341 } 341 }
342 } 342 }
343 343
344 pool->users++; 344 pool->users++;
345 shost->cmd_pool = pool; 345 shost->cmd_pool = pool;
346 mutex_unlock(&host_cmd_pool_mutex); 346 mutex_unlock(&host_cmd_pool_mutex);
347 347
348 /* 348 /*
349 * Get one backup command for this hos 349 * Get one backup command for this host.
350 */ 350 */
351 cmd = kmem_cache_alloc(shost->cmd_pool 351 cmd = kmem_cache_alloc(shost->cmd_pool->cmd_slab,
352 GFP_KERNEL | sh 352 GFP_KERNEL | shost->cmd_pool->gfp_mask);
353 if (!cmd) 353 if (!cmd)
354 goto fail2; 354 goto fail2;
355 355
356 cmd->sense_buffer = kmem_cache_alloc(s 356 cmd->sense_buffer = kmem_cache_alloc(shost->cmd_pool->sense_slab,
357 G 357 GFP_KERNEL |
358 s 358 shost->cmd_pool->gfp_mask);
359 if (!cmd->sense_buffer) 359 if (!cmd->sense_buffer)
360 goto fail2; 360 goto fail2;
361 361
362 list_add(&cmd->list, &shost->free_list 362 list_add(&cmd->list, &shost->free_list);
363 return 0; 363 return 0;
364 364
365 fail2: 365 fail2:
366 if (cmd) 366 if (cmd)
367 kmem_cache_free(shost->cmd_poo 367 kmem_cache_free(shost->cmd_pool->cmd_slab, cmd);
368 mutex_lock(&host_cmd_pool_mutex); 368 mutex_lock(&host_cmd_pool_mutex);
369 if (!--pool->users) { 369 if (!--pool->users) {
370 kmem_cache_destroy(pool->cmd_s 370 kmem_cache_destroy(pool->cmd_slab);
371 kmem_cache_destroy(pool->sense 371 kmem_cache_destroy(pool->sense_slab);
372 } 372 }
373 fail: 373 fail:
374 mutex_unlock(&host_cmd_pool_mutex); 374 mutex_unlock(&host_cmd_pool_mutex);
375 return -ENOMEM; 375 return -ENOMEM;
376 } 376 }
377 377
378 /** 378 /**
379 * scsi_destroy_command_freelist - Release the 379 * scsi_destroy_command_freelist - Release the command freelist for a scsi host.
380 * @shost: host whose freelist is going to be 380 * @shost: host whose freelist is going to be destroyed
381 */ 381 */
382 void scsi_destroy_command_freelist(struct Scsi 382 void scsi_destroy_command_freelist(struct Scsi_Host *shost)
383 { 383 {
384 while (!list_empty(&shost->free_list)) 384 while (!list_empty(&shost->free_list)) {
385 struct scsi_cmnd *cmd; 385 struct scsi_cmnd *cmd;
386 386
387 cmd = list_entry(shost->free_l 387 cmd = list_entry(shost->free_list.next, struct scsi_cmnd, list);
388 list_del_init(&cmd->list); 388 list_del_init(&cmd->list);
389 kmem_cache_free(shost->cmd_poo 389 kmem_cache_free(shost->cmd_pool->sense_slab,
390 cmd->sense_buf 390 cmd->sense_buffer);
391 kmem_cache_free(shost->cmd_poo 391 kmem_cache_free(shost->cmd_pool->cmd_slab, cmd);
392 } 392 }
393 393
394 mutex_lock(&host_cmd_pool_mutex); 394 mutex_lock(&host_cmd_pool_mutex);
395 if (!--shost->cmd_pool->users) { 395 if (!--shost->cmd_pool->users) {
396 kmem_cache_destroy(shost->cmd_ 396 kmem_cache_destroy(shost->cmd_pool->cmd_slab);
397 kmem_cache_destroy(shost->cmd_ 397 kmem_cache_destroy(shost->cmd_pool->sense_slab);
398 } 398 }
399 mutex_unlock(&host_cmd_pool_mutex); 399 mutex_unlock(&host_cmd_pool_mutex);
400 } 400 }
401 401
402 #ifdef CONFIG_SCSI_LOGGING 402 #ifdef CONFIG_SCSI_LOGGING
403 void scsi_log_send(struct scsi_cmnd *cmd) 403 void scsi_log_send(struct scsi_cmnd *cmd)
404 { 404 {
405 unsigned int level; 405 unsigned int level;
406 406
407 /* 407 /*
408 * If ML QUEUE log level is greater th 408 * If ML QUEUE log level is greater than or equal to:
409 * 409 *
410 * 1: nothing (match completion) 410 * 1: nothing (match completion)
411 * 411 *
412 * 2: log opcode + command of all comm 412 * 2: log opcode + command of all commands
413 * 413 *
414 * 3: same as 2 plus dump cmd address 414 * 3: same as 2 plus dump cmd address
415 * 415 *
416 * 4: same as 3 plus dump extra junk 416 * 4: same as 3 plus dump extra junk
417 */ 417 */
418 if (unlikely(scsi_logging_level)) { 418 if (unlikely(scsi_logging_level)) {
419 level = SCSI_LOG_LEVEL(SCSI_LO 419 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
420 SCSI_LO 420 SCSI_LOG_MLQUEUE_BITS);
421 if (level > 1) { 421 if (level > 1) {
422 scmd_printk(KERN_INFO, 422 scmd_printk(KERN_INFO, cmd, "Send: ");
423 if (level > 2) 423 if (level > 2)
424 printk("0x%p " 424 printk("0x%p ", cmd);
425 printk("\n"); 425 printk("\n");
426 scsi_print_command(cmd 426 scsi_print_command(cmd);
427 if (level > 3) { 427 if (level > 3) {
428 printk(KERN_IN 428 printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
429 " queue 429 " queuecommand 0x%p\n",
430 scsi_s 430 scsi_sglist(cmd), scsi_bufflen(cmd),
431 cmd->d 431 cmd->device->host->hostt->queuecommand);
432 432
433 } 433 }
434 } 434 }
435 } 435 }
436 } 436 }
437 437
438 void scsi_log_completion(struct scsi_cmnd *cmd 438 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
439 { 439 {
440 unsigned int level; 440 unsigned int level;
441 441
442 /* 442 /*
443 * If ML COMPLETE log level is greater 443 * If ML COMPLETE log level is greater than or equal to:
444 * 444 *
445 * 1: log disposition, result, opcode 445 * 1: log disposition, result, opcode + command, and conditionally
446 * sense data for failures or non SUCC 446 * sense data for failures or non SUCCESS dispositions.
447 * 447 *
448 * 2: same as 1 but for all command co 448 * 2: same as 1 but for all command completions.
449 * 449 *
450 * 3: same as 2 plus dump cmd address 450 * 3: same as 2 plus dump cmd address
451 * 451 *
452 * 4: same as 3 plus dump extra junk 452 * 4: same as 3 plus dump extra junk
453 */ 453 */
454 if (unlikely(scsi_logging_level)) { 454 if (unlikely(scsi_logging_level)) {
455 level = SCSI_LOG_LEVEL(SCSI_LO 455 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
456 SCSI_LO 456 SCSI_LOG_MLCOMPLETE_BITS);
457 if (((level > 0) && (cmd->resu 457 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
458 (level > 1)) { 458 (level > 1)) {
459 scmd_printk(KERN_INFO, 459 scmd_printk(KERN_INFO, cmd, "Done: ");
460 if (level > 2) 460 if (level > 2)
461 printk("0x%p " 461 printk("0x%p ", cmd);
462 /* 462 /*
463 * Dump truncated valu 463 * Dump truncated values, so we usually fit within
464 * 80 chars. 464 * 80 chars.
465 */ 465 */
466 switch (disposition) { 466 switch (disposition) {
467 case SUCCESS: 467 case SUCCESS:
468 printk("SUCCES 468 printk("SUCCESS\n");
469 break; 469 break;
470 case NEEDS_RETRY: 470 case NEEDS_RETRY:
471 printk("RETRY\ 471 printk("RETRY\n");
472 break; 472 break;
473 case ADD_TO_MLQUEUE: 473 case ADD_TO_MLQUEUE:
474 printk("MLQUEU 474 printk("MLQUEUE\n");
475 break; 475 break;
476 case FAILED: 476 case FAILED:
477 printk("FAILED 477 printk("FAILED\n");
478 break; 478 break;
479 case TIMEOUT_ERROR: 479 case TIMEOUT_ERROR:
480 /* 480 /*
481 * If called v 481 * If called via scsi_times_out.
482 */ 482 */
483 printk("TIMEOU 483 printk("TIMEOUT\n");
484 break; 484 break;
485 default: 485 default:
486 printk("UNKNOW 486 printk("UNKNOWN\n");
487 } 487 }
488 scsi_print_result(cmd) 488 scsi_print_result(cmd);
489 scsi_print_command(cmd 489 scsi_print_command(cmd);
490 if (status_byte(cmd->r 490 if (status_byte(cmd->result) & CHECK_CONDITION)
491 scsi_print_sen 491 scsi_print_sense("", cmd);
492 if (level > 3) 492 if (level > 3)
493 scmd_printk(KE 493 scmd_printk(KERN_INFO, cmd,
494 "s 494 "scsi host busy %d failed %d\n",
495 cm 495 cmd->device->host->host_busy,
496 cm 496 cmd->device->host->host_failed);
497 } 497 }
498 } 498 }
499 } 499 }
500 #endif 500 #endif
501 501
502 /** 502 /**
503 * scsi_cmd_get_serial - Assign a serial numbe 503 * scsi_cmd_get_serial - Assign a serial number to a command
504 * @host: the scsi host 504 * @host: the scsi host
505 * @cmd: command to assign serial number to 505 * @cmd: command to assign serial number to
506 * 506 *
507 * Description: a serial number identifies a r 507 * Description: a serial number identifies a request for error recovery
508 * and debugging purposes. Protected by the H 508 * and debugging purposes. Protected by the Host_Lock of host.
509 */ 509 */
510 static inline void scsi_cmd_get_serial(struct 510 static inline void scsi_cmd_get_serial(struct Scsi_Host *host, struct scsi_cmnd *cmd)
511 { 511 {
512 cmd->serial_number = host->cmd_serial_ 512 cmd->serial_number = host->cmd_serial_number++;
513 if (cmd->serial_number == 0) 513 if (cmd->serial_number == 0)
514 cmd->serial_number = host->cmd 514 cmd->serial_number = host->cmd_serial_number++;
515 } 515 }
516 516
517 /** 517 /**
518 * scsi_dispatch_command - Dispatch a command 518 * scsi_dispatch_command - Dispatch a command to the low-level driver.
519 * @cmd: command block we are dispatching. 519 * @cmd: command block we are dispatching.
520 * 520 *
521 * Return: nonzero return request was rejected 521 * Return: nonzero return request was rejected and device's queue needs to be
522 * plugged. 522 * plugged.
523 */ 523 */
524 int scsi_dispatch_cmd(struct scsi_cmnd *cmd) 524 int scsi_dispatch_cmd(struct scsi_cmnd *cmd)
525 { 525 {
526 struct Scsi_Host *host = cmd->device-> 526 struct Scsi_Host *host = cmd->device->host;
527 unsigned long flags = 0; 527 unsigned long flags = 0;
528 unsigned long timeout; 528 unsigned long timeout;
529 int rtn = 0; 529 int rtn = 0;
530 530
531 /* check if the device is still usable 531 /* check if the device is still usable */
532 if (unlikely(cmd->device->sdev_state = 532 if (unlikely(cmd->device->sdev_state == SDEV_DEL)) {
533 /* in SDEV_DEL we error all co 533 /* in SDEV_DEL we error all commands. DID_NO_CONNECT
534 * returns an immediate error 534 * returns an immediate error upwards, and signals
535 * that the device is no longe 535 * that the device is no longer present */
536 cmd->result = DID_NO_CONNECT < 536 cmd->result = DID_NO_CONNECT << 16;
537 atomic_inc(&cmd->device->ioreq 537 atomic_inc(&cmd->device->iorequest_cnt);
538 __scsi_done(cmd); 538 __scsi_done(cmd);
539 /* return 0 (because the comma 539 /* return 0 (because the command has been processed) */
540 goto out; 540 goto out;
541 } 541 }
542 542
543 /* Check to see if the scsi lld put th 543 /* Check to see if the scsi lld put this device into state SDEV_BLOCK. */
544 if (unlikely(cmd->device->sdev_state = 544 if (unlikely(cmd->device->sdev_state == SDEV_BLOCK)) {
545 /* 545 /*
546 * in SDEV_BLOCK, the command 546 * in SDEV_BLOCK, the command is just put back on the device
547 * queue. The suspend state h 547 * queue. The suspend state has already blocked the queue so
548 * future requests should not 548 * future requests should not occur until the device
549 * transitions out of the susp 549 * transitions out of the suspend state.
550 */ 550 */
551 scsi_queue_insert(cmd, SCSI_ML 551 scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY);
552 552
553 SCSI_LOG_MLQUEUE(3, printk("qu 553 SCSI_LOG_MLQUEUE(3, printk("queuecommand : device blocked \n"));
554 554
555 /* 555 /*
556 * NOTE: rtn is still zero her 556 * NOTE: rtn is still zero here because we don't need the
557 * queue to be plugged on retu 557 * queue to be plugged on return (it's already stopped)
558 */ 558 */
559 goto out; 559 goto out;
560 } 560 }
561 561
562 /* 562 /*
563 * If SCSI-2 or lower, store the LUN v 563 * If SCSI-2 or lower, store the LUN value in cmnd.
564 */ 564 */
565 if (cmd->device->scsi_level <= SCSI_2 565 if (cmd->device->scsi_level <= SCSI_2 &&
566 cmd->device->scsi_level != SCSI_UN 566 cmd->device->scsi_level != SCSI_UNKNOWN) {
567 cmd->cmnd[1] = (cmd->cmnd[1] & 567 cmd->cmnd[1] = (cmd->cmnd[1] & 0x1f) |
568 (cmd->device->l 568 (cmd->device->lun << 5 & 0xe0);
569 } 569 }
570 570
571 /* 571 /*
572 * We will wait MIN_RESET_DELAY clock 572 * We will wait MIN_RESET_DELAY clock ticks after the last reset so
573 * we can avoid the drive not being re 573 * we can avoid the drive not being ready.
574 */ 574 */
575 timeout = host->last_reset + MIN_RESET 575 timeout = host->last_reset + MIN_RESET_DELAY;
576 576
577 if (host->resetting && time_before(jif 577 if (host->resetting && time_before(jiffies, timeout)) {
578 int ticks_remaining = timeout 578 int ticks_remaining = timeout - jiffies;
579 /* 579 /*
580 * NOTE: This may be executed 580 * NOTE: This may be executed from within an interrupt
581 * handler! This is bad, but 581 * handler! This is bad, but for now, it'll do. The irq
582 * level of the interrupt hand 582 * level of the interrupt handler has been masked out by the
583 * platform dependent interrup 583 * platform dependent interrupt handling code already, so the
584 * sti() here will not cause a 584 * sti() here will not cause another call to the SCSI host's
585 * interrupt handler (assuming 585 * interrupt handler (assuming there is one irq-level per
586 * host). 586 * host).
587 */ 587 */
588 while (--ticks_remaining >= 0) 588 while (--ticks_remaining >= 0)
589 mdelay(1 + 999 / HZ); 589 mdelay(1 + 999 / HZ);
590 host->resetting = 0; 590 host->resetting = 0;
591 } 591 }
592 592
593 /* 593 /*
594 * AK: unlikely race here: for some re 594 * AK: unlikely race here: for some reason the timer could
595 * expire before the serial number is 595 * expire before the serial number is set up below.
596 */ 596 */
597 scsi_add_timer(cmd, cmd->timeout_per_c 597 scsi_add_timer(cmd, cmd->timeout_per_command, scsi_times_out);
598 598
599 scsi_log_send(cmd); 599 scsi_log_send(cmd);
600 600
601 /* 601 /*
602 * We will use a queued command if pos 602 * We will use a queued command if possible, otherwise we will
603 * emulate the queuing and calling of 603 * emulate the queuing and calling of completion function ourselves.
604 */ 604 */
605 atomic_inc(&cmd->device->iorequest_cnt 605 atomic_inc(&cmd->device->iorequest_cnt);
606 606
607 /* 607 /*
608 * Before we queue this command, check 608 * Before we queue this command, check if the command
609 * length exceeds what the host adapte 609 * length exceeds what the host adapter can handle.
610 */ 610 */
611 if (CDB_SIZE(cmd) > cmd->device->host- 611 if (CDB_SIZE(cmd) > cmd->device->host->max_cmd_len) {
612 SCSI_LOG_MLQUEUE(3, 612 SCSI_LOG_MLQUEUE(3,
613 printk("queuec 613 printk("queuecommand : command too long.\n"));
614 cmd->result = (DID_ABORT << 16 614 cmd->result = (DID_ABORT << 16);
615 615
616 scsi_done(cmd); 616 scsi_done(cmd);
617 goto out; 617 goto out;
618 } 618 }
619 619
620 spin_lock_irqsave(host->host_lock, fla 620 spin_lock_irqsave(host->host_lock, flags);
621 scsi_cmd_get_serial(host, cmd); 621 scsi_cmd_get_serial(host, cmd);
622 622
623 if (unlikely(host->shost_state == SHOS 623 if (unlikely(host->shost_state == SHOST_DEL)) {
624 cmd->result = (DID_NO_CONNECT 624 cmd->result = (DID_NO_CONNECT << 16);
625 scsi_done(cmd); 625 scsi_done(cmd);
626 } else { 626 } else {
627 rtn = host->hostt->queuecomman 627 rtn = host->hostt->queuecommand(cmd, scsi_done);
628 } 628 }
629 spin_unlock_irqrestore(host->host_lock 629 spin_unlock_irqrestore(host->host_lock, flags);
630 if (rtn) { 630 if (rtn) {
631 if (scsi_delete_timer(cmd)) { 631 if (scsi_delete_timer(cmd)) {
632 atomic_inc(&cmd->devic 632 atomic_inc(&cmd->device->iodone_cnt);
633 scsi_queue_insert(cmd, 633 scsi_queue_insert(cmd,
634 (rtn 634 (rtn == SCSI_MLQUEUE_DEVICE_BUSY) ?
635 rtn 635 rtn : SCSI_MLQUEUE_HOST_BUSY);
636 } 636 }
637 SCSI_LOG_MLQUEUE(3, 637 SCSI_LOG_MLQUEUE(3,
638 printk("queuecommand : req 638 printk("queuecommand : request rejected\n"));
639 } 639 }
640 640
641 out: 641 out:
642 SCSI_LOG_MLQUEUE(3, printk("leaving sc 642 SCSI_LOG_MLQUEUE(3, printk("leaving scsi_dispatch_cmnd()\n"));
643 return rtn; 643 return rtn;
644 } 644 }
645 645
646 /** 646 /**
647 * scsi_req_abort_cmd -- Request command recov 647 * scsi_req_abort_cmd -- Request command recovery for the specified command
648 * @cmd: pointer to the SCSI command of intere 648 * @cmd: pointer to the SCSI command of interest
649 * 649 *
650 * This function requests that SCSI Core start 650 * This function requests that SCSI Core start recovery for the
651 * command by deleting the timer and adding th 651 * command by deleting the timer and adding the command to the eh
652 * queue. It can be called by either LLDDs or 652 * queue. It can be called by either LLDDs or SCSI Core. LLDDs who
653 * implement their own error recovery MAY igno 653 * implement their own error recovery MAY ignore the timeout event if
654 * they generated scsi_req_abort_cmd. 654 * they generated scsi_req_abort_cmd.
655 */ 655 */
656 void scsi_req_abort_cmd(struct scsi_cmnd *cmd) 656 void scsi_req_abort_cmd(struct scsi_cmnd *cmd)
657 { 657 {
658 if (!scsi_delete_timer(cmd)) 658 if (!scsi_delete_timer(cmd))
659 return; 659 return;
660 scsi_times_out(cmd); 660 scsi_times_out(cmd);
661 } 661 }
662 EXPORT_SYMBOL(scsi_req_abort_cmd); 662 EXPORT_SYMBOL(scsi_req_abort_cmd);
663 663
664 /** 664 /**
665 * scsi_done - Enqueue the finished SCSI comma 665 * scsi_done - Enqueue the finished SCSI command into the done queue.
666 * @cmd: The SCSI Command for which a low-leve 666 * @cmd: The SCSI Command for which a low-level device driver (LLDD) gives
667 * ownership back to SCSI Core -- i.e. the LLD 667 * ownership back to SCSI Core -- i.e. the LLDD has finished with it.
668 * 668 *
669 * Description: This function is the mid-level 669 * Description: This function is the mid-level's (SCSI Core) interrupt routine,
670 * which regains ownership of the SCSI command 670 * which regains ownership of the SCSI command (de facto) from a LLDD, and
671 * enqueues the command to the done queue for 671 * enqueues the command to the done queue for further processing.
672 * 672 *
673 * This is the producer of the done queue who 673 * This is the producer of the done queue who enqueues at the tail.
674 * 674 *
675 * This function is interrupt context safe. 675 * This function is interrupt context safe.
676 */ 676 */
677 static void scsi_done(struct scsi_cmnd *cmd) 677 static void scsi_done(struct scsi_cmnd *cmd)
678 { 678 {
679 /* 679 /*
680 * We don't have to worry about this o 680 * We don't have to worry about this one timing out anymore.
681 * If we are unable to remove the time 681 * If we are unable to remove the timer, then the command
682 * has already timed out. In which ca 682 * has already timed out. In which case, we have no choice but to
683 * let the timeout function run, as we 683 * let the timeout function run, as we have no idea where in fact
684 * that function could really be. It 684 * that function could really be. It might be on another processor,
685 * etc, etc. 685 * etc, etc.
686 */ 686 */
687 if (!scsi_delete_timer(cmd)) 687 if (!scsi_delete_timer(cmd))
688 return; 688 return;
689 __scsi_done(cmd); 689 __scsi_done(cmd);
690 } 690 }
691 691
692 /* Private entry to scsi_done() to complete a 692 /* Private entry to scsi_done() to complete a command when the timer
693 * isn't running --- used by scsi_times_out */ 693 * isn't running --- used by scsi_times_out */
694 void __scsi_done(struct scsi_cmnd *cmd) 694 void __scsi_done(struct scsi_cmnd *cmd)
695 { 695 {
696 struct request *rq = cmd->request; 696 struct request *rq = cmd->request;
697 697
698 /* 698 /*
699 * Set the serial numbers back to zero 699 * Set the serial numbers back to zero
700 */ 700 */
701 cmd->serial_number = 0; 701 cmd->serial_number = 0;
702 702
703 atomic_inc(&cmd->device->iodone_cnt); 703 atomic_inc(&cmd->device->iodone_cnt);
704 if (cmd->result) 704 if (cmd->result)
705 atomic_inc(&cmd->device->ioerr 705 atomic_inc(&cmd->device->ioerr_cnt);
706 706
707 BUG_ON(!rq); 707 BUG_ON(!rq);
708 708
709 /* 709 /*
710 * The uptodate/nbytes values don't ma 710 * The uptodate/nbytes values don't matter, as we allow partial
711 * completes and thus will check this 711 * completes and thus will check this in the softirq callback
712 */ 712 */
713 rq->completion_data = cmd; 713 rq->completion_data = cmd;
714 blk_complete_request(rq); 714 blk_complete_request(rq);
715 } 715 }
716 716
717 /* Move this to a header if it becomes more ge 717 /* Move this to a header if it becomes more generally useful */
718 static struct scsi_driver *scsi_cmd_to_driver( 718 static struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd)
719 { 719 {
720 return *(struct scsi_driver **)cmd->re 720 return *(struct scsi_driver **)cmd->request->rq_disk->private_data;
721 } 721 }
722 722
723 /** 723 /**
724 * scsi_finish_command - cleanup and pass comm 724 * scsi_finish_command - cleanup and pass command back to upper layer
725 * @cmd: the command 725 * @cmd: the command
726 * 726 *
727 * Description: Pass command off to upper laye 727 * Description: Pass command off to upper layer for finishing of I/O
728 * request, waking processes that 728 * request, waking processes that are waiting on results,
729 * etc. 729 * etc.
730 */ 730 */
731 void scsi_finish_command(struct scsi_cmnd *cmd 731 void scsi_finish_command(struct scsi_cmnd *cmd)
732 { 732 {
733 struct scsi_device *sdev = cmd->device 733 struct scsi_device *sdev = cmd->device;
734 struct Scsi_Host *shost = sdev->host; 734 struct Scsi_Host *shost = sdev->host;
735 struct scsi_driver *drv; 735 struct scsi_driver *drv;
736 unsigned int good_bytes; 736 unsigned int good_bytes;
737 737
738 scsi_device_unbusy(sdev); 738 scsi_device_unbusy(sdev);
739 739
740 /* 740 /*
741 * Clear the flags which say that the 741 * Clear the flags which say that the device/host is no longer
742 * capable of accepting new commands. 742 * capable of accepting new commands. These are set in scsi_queue.c
743 * for both the queue full condition o 743 * for both the queue full condition on a device, and for a
744 * host full condition on the host. 744 * host full condition on the host.
745 * 745 *
746 * XXX(hch): What about locking? 746 * XXX(hch): What about locking?
747 */ 747 */
748 shost->host_blocked = 0; 748 shost->host_blocked = 0;
749 sdev->device_blocked = 0; 749 sdev->device_blocked = 0;
750 750
751 /* 751 /*
752 * If we have valid sense information, 752 * If we have valid sense information, then some kind of recovery
753 * must have taken place. Make a note 753 * must have taken place. Make a note of this.
754 */ 754 */
755 if (SCSI_SENSE_VALID(cmd)) 755 if (SCSI_SENSE_VALID(cmd))
756 cmd->result |= (DRIVER_SENSE < 756 cmd->result |= (DRIVER_SENSE << 24);
757 757
758 SCSI_LOG_MLCOMPLETE(4, sdev_printk(KER 758 SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
759 "Notifying upp 759 "Notifying upper driver of completion "
760 "(result %x)\n 760 "(result %x)\n", cmd->result));
761 761
762 good_bytes = scsi_bufflen(cmd) + cmd-> 762 good_bytes = scsi_bufflen(cmd) + cmd->request->extra_len;
763 if (cmd->request->cmd_type != REQ_TYPE 763 if (cmd->request->cmd_type != REQ_TYPE_BLOCK_PC) {
764 drv = scsi_cmd_to_driver(cmd); 764 drv = scsi_cmd_to_driver(cmd);
765 if (drv->done) 765 if (drv->done)
766 good_bytes = drv->done 766 good_bytes = drv->done(cmd);
767 } 767 }
768 scsi_io_completion(cmd, good_bytes); 768 scsi_io_completion(cmd, good_bytes);
769 } 769 }
770 EXPORT_SYMBOL(scsi_finish_command); 770 EXPORT_SYMBOL(scsi_finish_command);
771 771
772 /** 772 /**
773 * scsi_adjust_queue_depth - Let low level dri 773 * scsi_adjust_queue_depth - Let low level drivers change a device's queue depth
774 * @sdev: SCSI Device in question 774 * @sdev: SCSI Device in question
775 * @tagged: Do we use tagged queueing (non-0) 775 * @tagged: Do we use tagged queueing (non-0) or do we treat
776 * this device as an untagged device 776 * this device as an untagged device (0)
777 * @tags: Number of tags allowed if tagged que 777 * @tags: Number of tags allowed if tagged queueing enabled,
778 * or number of commands the low level 778 * or number of commands the low level driver can
779 * queue up in non-tagged mode (as per 779 * queue up in non-tagged mode (as per cmd_per_lun).
780 * 780 *
781 * Returns: Nothing 781 * Returns: Nothing
782 * 782 *
783 * Lock Status: None held on entry 783 * Lock Status: None held on entry
784 * 784 *
785 * Notes: Low level drivers may call thi 785 * Notes: Low level drivers may call this at any time and we will do
786 * the right thing depending on w 786 * the right thing depending on whether or not the device is
787 * currently active and whether o 787 * currently active and whether or not it even has the
788 * command blocks built yet. 788 * command blocks built yet.
789 */ 789 */
790 void scsi_adjust_queue_depth(struct scsi_devic 790 void scsi_adjust_queue_depth(struct scsi_device *sdev, int tagged, int tags)
791 { 791 {
792 unsigned long flags; 792 unsigned long flags;
793 793
794 /* 794 /*
795 * refuse to set tagged depth to an un 795 * refuse to set tagged depth to an unworkable size
796 */ 796 */
797 if (tags <= 0) 797 if (tags <= 0)
798 return; 798 return;
799 799
800 spin_lock_irqsave(sdev->request_queue- 800 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
801 801
802 /* Check to see if the queue is manage 802 /* Check to see if the queue is managed by the block layer.
803 * If it is, and we fail to adjust the 803 * If it is, and we fail to adjust the depth, exit. */
804 if (blk_queue_tagged(sdev->request_que 804 if (blk_queue_tagged(sdev->request_queue) &&
805 blk_queue_resize_tags(sdev->reques 805 blk_queue_resize_tags(sdev->request_queue, tags) != 0)
806 goto out; 806 goto out;
807 807
808 sdev->queue_depth = tags; 808 sdev->queue_depth = tags;
809 switch (tagged) { 809 switch (tagged) {
810 case MSG_ORDERED_TAG: 810 case MSG_ORDERED_TAG:
811 sdev->ordered_tags = 1 811 sdev->ordered_tags = 1;
812 sdev->simple_tags = 1; 812 sdev->simple_tags = 1;
813 break; 813 break;
814 case MSG_SIMPLE_TAG: 814 case MSG_SIMPLE_TAG:
815 sdev->ordered_tags = 0 815 sdev->ordered_tags = 0;
816 sdev->simple_tags = 1; 816 sdev->simple_tags = 1;
817 break; 817 break;
818 default: 818 default:
819 sdev_printk(KERN_WARNI 819 sdev_printk(KERN_WARNING, sdev,
820 "scsi_adju 820 "scsi_adjust_queue_depth, bad queue type, "
821 "disabled\ 821 "disabled\n");
822 case 0: 822 case 0:
823 sdev->ordered_tags = s 823 sdev->ordered_tags = sdev->simple_tags = 0;
824 sdev->queue_depth = ta 824 sdev->queue_depth = tags;
825 break; 825 break;
826 } 826 }
827 out: 827 out:
828 spin_unlock_irqrestore(sdev->request_q 828 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
829 } 829 }
830 EXPORT_SYMBOL(scsi_adjust_queue_depth); 830 EXPORT_SYMBOL(scsi_adjust_queue_depth);
831 831
832 /** 832 /**
833 * scsi_track_queue_full - track QUEUE_FULL ev 833 * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
834 * @sdev: SCSI Device in question 834 * @sdev: SCSI Device in question
835 * @depth: Current number of outstanding SCSI 835 * @depth: Current number of outstanding SCSI commands on this device,
836 * not counting the one returned as QU 836 * not counting the one returned as QUEUE_FULL.
837 * 837 *
838 * Description: This function will track succe 838 * Description: This function will track successive QUEUE_FULL events on a
839 * specific SCSI device to determ 839 * specific SCSI device to determine if and when there is a
840 * need to adjust the queue depth 840 * need to adjust the queue depth on the device.
841 * 841 *
842 * Returns: 0 - No change needed, >0 - Adj 842 * Returns: 0 - No change needed, >0 - Adjust queue depth to this new depth,
843 * -1 - Drop back to untagged ope 843 * -1 - Drop back to untagged operation using host->cmd_per_lun
844 * as the untagged comman 844 * as the untagged command depth
845 * 845 *
846 * Lock Status: None held on entry 846 * Lock Status: None held on entry
847 * 847 *
848 * Notes: Low level drivers may call thi 848 * Notes: Low level drivers may call this at any time and we will do
849 * "The Right Thing." We are int 849 * "The Right Thing." We are interrupt context safe.
850 */ 850 */
851 int scsi_track_queue_full(struct scsi_device * 851 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
852 { 852 {
853 if ((jiffies >> 4) == sdev->last_queue 853 if ((jiffies >> 4) == sdev->last_queue_full_time)
854 return 0; 854 return 0;
855 855
856 sdev->last_queue_full_time = (jiffies 856 sdev->last_queue_full_time = (jiffies >> 4);
857 if (sdev->last_queue_full_depth != dep 857 if (sdev->last_queue_full_depth != depth) {
858 sdev->last_queue_full_count = 858 sdev->last_queue_full_count = 1;
859 sdev->last_queue_full_depth = 859 sdev->last_queue_full_depth = depth;
860 } else { 860 } else {
861 sdev->last_queue_full_count++; 861 sdev->last_queue_full_count++;
862 } 862 }
863 863
864 if (sdev->last_queue_full_count <= 10) 864 if (sdev->last_queue_full_count <= 10)
865 return 0; 865 return 0;
866 if (sdev->last_queue_full_depth < 8) { 866 if (sdev->last_queue_full_depth < 8) {
867 /* Drop back to untagged */ 867 /* Drop back to untagged */
868 scsi_adjust_queue_depth(sdev, 868 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
869 return -1; 869 return -1;
870 } 870 }
871 871
872 if (sdev->ordered_tags) 872 if (sdev->ordered_tags)
873 scsi_adjust_queue_depth(sdev, 873 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
874 else 874 else
875 scsi_adjust_queue_depth(sdev, 875 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
876 return depth; 876 return depth;
877 } 877 }
878 EXPORT_SYMBOL(scsi_track_queue_full); 878 EXPORT_SYMBOL(scsi_track_queue_full);
879 879
880 /** 880 /**
881 * scsi_device_get - get an additional refer 881 * scsi_device_get - get an additional reference to a scsi_device
882 * @sdev: device to get a reference to 882 * @sdev: device to get a reference to
883 * 883 *
884 * Description: Gets a reference to the scsi_d 884 * Description: Gets a reference to the scsi_device and increments the use count
885 * of the underlying LLDD module. You must ho 885 * of the underlying LLDD module. You must hold host_lock of the
886 * parent Scsi_Host or already have a referenc 886 * parent Scsi_Host or already have a reference when calling this.
887 */ 887 */
888 int scsi_device_get(struct scsi_device *sdev) 888 int scsi_device_get(struct scsi_device *sdev)
889 { 889 {
890 if (sdev->sdev_state == SDEV_DEL) 890 if (sdev->sdev_state == SDEV_DEL)
891 return -ENXIO; 891 return -ENXIO;
892 if (!get_device(&sdev->sdev_gendev)) 892 if (!get_device(&sdev->sdev_gendev))
893 return -ENXIO; 893 return -ENXIO;
894 /* We can fail this if we're doing SCS 894 /* We can fail this if we're doing SCSI operations
895 * from module exit (like cache flush) 895 * from module exit (like cache flush) */
896 try_module_get(sdev->host->hostt->modu 896 try_module_get(sdev->host->hostt->module);
897 897
898 return 0; 898 return 0;
899 } 899 }
900 EXPORT_SYMBOL(scsi_device_get); 900 EXPORT_SYMBOL(scsi_device_get);
901 901
902 /** 902 /**
903 * scsi_device_put - release a reference to 903 * scsi_device_put - release a reference to a scsi_device
904 * @sdev: device to release a reference 904 * @sdev: device to release a reference on.
905 * 905 *
906 * Description: Release a reference to the scs 906 * Description: Release a reference to the scsi_device and decrements the use
907 * count of the underlying LLDD module. The d 907 * count of the underlying LLDD module. The device is freed once the last
908 * user vanishes. 908 * user vanishes.
909 */ 909 */
910 void scsi_device_put(struct scsi_device *sdev) 910 void scsi_device_put(struct scsi_device *sdev)
911 { 911 {
912 #ifdef CONFIG_MODULE_UNLOAD 912 #ifdef CONFIG_MODULE_UNLOAD
913 struct module *module = sdev->host->ho 913 struct module *module = sdev->host->hostt->module;
914 914
915 /* The module refcount will be zero if 915 /* The module refcount will be zero if scsi_device_get()
916 * was called from a module removal ro 916 * was called from a module removal routine */
917 if (module && module_refcount(module) 917 if (module && module_refcount(module) != 0)
918 module_put(module); 918 module_put(module);
919 #endif 919 #endif
920 put_device(&sdev->sdev_gendev); 920 put_device(&sdev->sdev_gendev);
921 } 921 }
922 EXPORT_SYMBOL(scsi_device_put); 922 EXPORT_SYMBOL(scsi_device_put);
923 923
924 /* helper for shost_for_each_device, see that 924 /* helper for shost_for_each_device, see that for documentation */
925 struct scsi_device *__scsi_iterate_devices(str 925 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
926 str 926 struct scsi_device *prev)
927 { 927 {
928 struct list_head *list = (prev ? &prev 928 struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
929 struct scsi_device *next = NULL; 929 struct scsi_device *next = NULL;
930 unsigned long flags; 930 unsigned long flags;
931 931
932 spin_lock_irqsave(shost->host_lock, fl 932 spin_lock_irqsave(shost->host_lock, flags);
933 while (list->next != &shost->__devices 933 while (list->next != &shost->__devices) {
934 next = list_entry(list->next, 934 next = list_entry(list->next, struct scsi_device, siblings);
935 /* skip devices that we can't 935 /* skip devices that we can't get a reference to */
936 if (!scsi_device_get(next)) 936 if (!scsi_device_get(next))
937 break; 937 break;
938 next = NULL; 938 next = NULL;
939 list = list->next; 939 list = list->next;
940 } 940 }
941 spin_unlock_irqrestore(shost->host_loc 941 spin_unlock_irqrestore(shost->host_lock, flags);
942 942
943 if (prev) 943 if (prev)
944 scsi_device_put(prev); 944 scsi_device_put(prev);
945 return next; 945 return next;
946 } 946 }
947 EXPORT_SYMBOL(__scsi_iterate_devices); 947 EXPORT_SYMBOL(__scsi_iterate_devices);
948 948
949 /** 949 /**
950 * starget_for_each_device - helper to walk 950 * starget_for_each_device - helper to walk all devices of a target
951 * @starget: target whose devices we want t 951 * @starget: target whose devices we want to iterate over.
952 * @data: Opaque passed to each function 952 * @data: Opaque passed to each function call.
953 * @fn: Function to call on each devic 953 * @fn: Function to call on each device
954 * 954 *
955 * This traverses over each device of @starget 955 * This traverses over each device of @starget. The devices have
956 * a reference that must be released by scsi_h 956 * a reference that must be released by scsi_host_put when breaking
957 * out of the loop. 957 * out of the loop.
958 */ 958 */
959 void starget_for_each_device(struct scsi_targe 959 void starget_for_each_device(struct scsi_target *starget, void *data,
960 void (*fn)(struct scsi_de 960 void (*fn)(struct scsi_device *, void *))
961 { 961 {
962 struct Scsi_Host *shost = dev_to_shost 962 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
963 struct scsi_device *sdev; 963 struct scsi_device *sdev;
964 964
965 shost_for_each_device(sdev, shost) { 965 shost_for_each_device(sdev, shost) {
966 if ((sdev->channel == starget- 966 if ((sdev->channel == starget->channel) &&
967 (sdev->id == starget->id)) 967 (sdev->id == starget->id))
968 fn(sdev, data); 968 fn(sdev, data);
969 } 969 }
970 } 970 }
971 EXPORT_SYMBOL(starget_for_each_device); 971 EXPORT_SYMBOL(starget_for_each_device);
972 972
973 /** 973 /**
974 * __starget_for_each_device - helper to walk 974 * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
975 * @starget: target whose devices we want t 975 * @starget: target whose devices we want to iterate over.
976 * @data: parameter for callback @fn() 976 * @data: parameter for callback @fn()
977 * @fn: callback function that is invo 977 * @fn: callback function that is invoked for each device
978 * 978 *
979 * This traverses over each device of @starget 979 * This traverses over each device of @starget. It does _not_
980 * take a reference on the scsi_device, so the 980 * take a reference on the scsi_device, so the whole loop must be
981 * protected by shost->host_lock. 981 * protected by shost->host_lock.
982 * 982 *
983 * Note: The only reason why drivers would wa 983 * Note: The only reason why drivers would want to use this is because
984 * they need to access the device list in irq 984 * they need to access the device list in irq context. Otherwise you
985 * really want to use starget_for_each_device 985 * really want to use starget_for_each_device instead.
986 **/ 986 **/
987 void __starget_for_each_device(struct scsi_tar 987 void __starget_for_each_device(struct scsi_target *starget, void *data,
988 void (*fn)(stru 988 void (*fn)(struct scsi_device *, void *))
989 { 989 {
990 struct Scsi_Host *shost = dev_to_shost 990 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
991 struct scsi_device *sdev; 991 struct scsi_device *sdev;
992 992
993 __shost_for_each_device(sdev, shost) { 993 __shost_for_each_device(sdev, shost) {
994 if ((sdev->channel == starget- 994 if ((sdev->channel == starget->channel) &&
995 (sdev->id == starget->id)) 995 (sdev->id == starget->id))
996 fn(sdev, data); 996 fn(sdev, data);
997 } 997 }
998 } 998 }
999 EXPORT_SYMBOL(__starget_for_each_device); 999 EXPORT_SYMBOL(__starget_for_each_device);
1000 1000
1001 /** 1001 /**
1002 * __scsi_device_lookup_by_target - find a de 1002 * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
1003 * @starget: SCSI target pointer 1003 * @starget: SCSI target pointer
1004 * @lun: SCSI Logical Unit Number 1004 * @lun: SCSI Logical Unit Number
1005 * 1005 *
1006 * Description: Looks up the scsi_device with 1006 * Description: Looks up the scsi_device with the specified @lun for a given
1007 * @starget. The returned scsi_device does n 1007 * @starget. The returned scsi_device does not have an additional
1008 * reference. You must hold the host's host_ 1008 * reference. You must hold the host's host_lock over this call and
1009 * any access to the returned scsi_device. 1009 * any access to the returned scsi_device.
1010 * 1010 *
1011 * Note: The only reason why drivers should 1011 * Note: The only reason why drivers should use this is because
1012 * they need to access the device list in irq 1012 * they need to access the device list in irq context. Otherwise you
1013 * really want to use scsi_device_lookup_by_t 1013 * really want to use scsi_device_lookup_by_target instead.
1014 **/ 1014 **/
1015 struct scsi_device *__scsi_device_lookup_by_t 1015 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
1016 1016 uint lun)
1017 { 1017 {
1018 struct scsi_device *sdev; 1018 struct scsi_device *sdev;
1019 1019
1020 list_for_each_entry(sdev, &starget->d 1020 list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
1021 if (sdev->lun ==lun) 1021 if (sdev->lun ==lun)
1022 return sdev; 1022 return sdev;
1023 } 1023 }
1024 1024
1025 return NULL; 1025 return NULL;
1026 } 1026 }
1027 EXPORT_SYMBOL(__scsi_device_lookup_by_target) 1027 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
1028 1028
1029 /** 1029 /**
1030 * scsi_device_lookup_by_target - find a devi 1030 * scsi_device_lookup_by_target - find a device given the target
1031 * @starget: SCSI target pointer 1031 * @starget: SCSI target pointer
1032 * @lun: SCSI Logical Unit Number 1032 * @lun: SCSI Logical Unit Number
1033 * 1033 *
1034 * Description: Looks up the scsi_device with 1034 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1035 * for a given host. The returned scsi_devic 1035 * for a given host. The returned scsi_device has an additional reference that
1036 * needs to be released with scsi_device_put 1036 * needs to be released with scsi_device_put once you're done with it.
1037 **/ 1037 **/
1038 struct scsi_device *scsi_device_lookup_by_tar 1038 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
1039 1039 uint lun)
1040 { 1040 {
1041 struct scsi_device *sdev; 1041 struct scsi_device *sdev;
1042 struct Scsi_Host *shost = dev_to_shos 1042 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1043 unsigned long flags; 1043 unsigned long flags;
1044 1044
1045 spin_lock_irqsave(shost->host_lock, f 1045 spin_lock_irqsave(shost->host_lock, flags);
1046 sdev = __scsi_device_lookup_by_target 1046 sdev = __scsi_device_lookup_by_target(starget, lun);
1047 if (sdev && scsi_device_get(sdev)) 1047 if (sdev && scsi_device_get(sdev))
1048 sdev = NULL; 1048 sdev = NULL;
1049 spin_unlock_irqrestore(shost->host_lo 1049 spin_unlock_irqrestore(shost->host_lock, flags);
1050 1050
1051 return sdev; 1051 return sdev;
1052 } 1052 }
1053 EXPORT_SYMBOL(scsi_device_lookup_by_target); 1053 EXPORT_SYMBOL(scsi_device_lookup_by_target);
1054 1054
1055 /** 1055 /**
1056 * __scsi_device_lookup - find a device given 1056 * __scsi_device_lookup - find a device given the host (UNLOCKED)
1057 * @shost: SCSI host pointer 1057 * @shost: SCSI host pointer
1058 * @channel: SCSI channel (zero if only on 1058 * @channel: SCSI channel (zero if only one channel)
1059 * @id: SCSI target number (physical 1059 * @id: SCSI target number (physical unit number)
1060 * @lun: SCSI Logical Unit Number 1060 * @lun: SCSI Logical Unit Number
1061 * 1061 *
1062 * Description: Looks up the scsi_device with 1062 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1063 * for a given host. The returned scsi_device 1063 * for a given host. The returned scsi_device does not have an additional
1064 * reference. You must hold the host's host_ 1064 * reference. You must hold the host's host_lock over this call and any access
1065 * to the returned scsi_device. 1065 * to the returned scsi_device.
1066 * 1066 *
1067 * Note: The only reason why drivers would w 1067 * Note: The only reason why drivers would want to use this is because
1068 * they need to access the device list in irq 1068 * they need to access the device list in irq context. Otherwise you
1069 * really want to use scsi_device_lookup inst 1069 * really want to use scsi_device_lookup instead.
1070 **/ 1070 **/
1071 struct scsi_device *__scsi_device_lookup(stru 1071 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
1072 uint channel, uint id, uint l 1072 uint channel, uint id, uint lun)
1073 { 1073 {
1074 struct scsi_device *sdev; 1074 struct scsi_device *sdev;
1075 1075
1076 list_for_each_entry(sdev, &shost->__d 1076 list_for_each_entry(sdev, &shost->__devices, siblings) {
1077 if (sdev->channel == channel 1077 if (sdev->channel == channel && sdev->id == id &&
1078 sdev->lun ==l 1078 sdev->lun ==lun)
1079 return sdev; 1079 return sdev;
1080 } 1080 }
1081 1081
1082 return NULL; 1082 return NULL;
1083 } 1083 }
1084 EXPORT_SYMBOL(__scsi_device_lookup); 1084 EXPORT_SYMBOL(__scsi_device_lookup);
1085 1085
1086 /** 1086 /**
1087 * scsi_device_lookup - find a device given t 1087 * scsi_device_lookup - find a device given the host
1088 * @shost: SCSI host pointer 1088 * @shost: SCSI host pointer
1089 * @channel: SCSI channel (zero if only on 1089 * @channel: SCSI channel (zero if only one channel)
1090 * @id: SCSI target number (physical 1090 * @id: SCSI target number (physical unit number)
1091 * @lun: SCSI Logical Unit Number 1091 * @lun: SCSI Logical Unit Number
1092 * 1092 *
1093 * Description: Looks up the scsi_device with 1093 * Description: Looks up the scsi_device with the specified @channel, @id, @lun
1094 * for a given host. The returned scsi_devic 1094 * for a given host. The returned scsi_device has an additional reference that
1095 * needs to be released with scsi_device_put 1095 * needs to be released with scsi_device_put once you're done with it.
1096 **/ 1096 **/
1097 struct scsi_device *scsi_device_lookup(struct 1097 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
1098 uint channel, uint id, uint l 1098 uint channel, uint id, uint lun)
1099 { 1099 {
1100 struct scsi_device *sdev; 1100 struct scsi_device *sdev;
1101 unsigned long flags; 1101 unsigned long flags;
1102 1102
1103 spin_lock_irqsave(shost->host_lock, f 1103 spin_lock_irqsave(shost->host_lock, flags);
1104 sdev = __scsi_device_lookup(shost, ch 1104 sdev = __scsi_device_lookup(shost, channel, id, lun);
1105 if (sdev && scsi_device_get(sdev)) 1105 if (sdev && scsi_device_get(sdev))
1106 sdev = NULL; 1106 sdev = NULL;
1107 spin_unlock_irqrestore(shost->host_lo 1107 spin_unlock_irqrestore(shost->host_lock, flags);
1108 1108
1109 return sdev; 1109 return sdev;
1110 } 1110 }
1111 EXPORT_SYMBOL(scsi_device_lookup); 1111 EXPORT_SYMBOL(scsi_device_lookup);
1112 1112
1113 MODULE_DESCRIPTION("SCSI core"); 1113 MODULE_DESCRIPTION("SCSI core");
1114 MODULE_LICENSE("GPL"); 1114 MODULE_LICENSE("GPL");
1115 1115
1116 module_param(scsi_logging_level, int, S_IRUGO 1116 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
1117 MODULE_PARM_DESC(scsi_logging_level, "a bit m 1117 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
1118 1118
1119 static int __init init_scsi(void) 1119 static int __init init_scsi(void)
1120 { 1120 {
1121 int error; 1121 int error;
1122 1122
1123 error = scsi_init_queue(); 1123 error = scsi_init_queue();
1124 if (error) 1124 if (error)
1125 return error; 1125 return error;
1126 error = scsi_init_procfs(); 1126 error = scsi_init_procfs();
1127 if (error) 1127 if (error)
1128 goto cleanup_queue; 1128 goto cleanup_queue;
1129 error = scsi_init_devinfo(); 1129 error = scsi_init_devinfo();
1130 if (error) 1130 if (error)
1131 goto cleanup_procfs; 1131 goto cleanup_procfs;
1132 error = scsi_init_hosts(); 1132 error = scsi_init_hosts();
1133 if (error) 1133 if (error)
1134 goto cleanup_devlist; 1134 goto cleanup_devlist;
1135 error = scsi_init_sysctl(); 1135 error = scsi_init_sysctl();
1136 if (error) 1136 if (error)
1137 goto cleanup_hosts; 1137 goto cleanup_hosts;
1138 error = scsi_sysfs_register(); 1138 error = scsi_sysfs_register();
1139 if (error) 1139 if (error)
1140 goto cleanup_sysctl; 1140 goto cleanup_sysctl;
1141 1141
1142 scsi_netlink_init(); 1142 scsi_netlink_init();
1143 1143
1144 printk(KERN_NOTICE "SCSI subsystem in 1144 printk(KERN_NOTICE "SCSI subsystem initialized\n");
1145 return 0; 1145 return 0;
1146 1146
1147 cleanup_sysctl: 1147 cleanup_sysctl:
1148 scsi_exit_sysctl(); 1148 scsi_exit_sysctl();
1149 cleanup_hosts: 1149 cleanup_hosts:
1150 scsi_exit_hosts(); 1150 scsi_exit_hosts();
1151 cleanup_devlist: 1151 cleanup_devlist:
1152 scsi_exit_devinfo(); 1152 scsi_exit_devinfo();
1153 cleanup_procfs: 1153 cleanup_procfs:
1154 scsi_exit_procfs(); 1154 scsi_exit_procfs();
1155 cleanup_queue: 1155 cleanup_queue:
1156 scsi_exit_queue(); 1156 scsi_exit_queue();
1157 printk(KERN_ERR "SCSI subsystem faile 1157 printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
1158 -error); 1158 -error);
1159 return error; 1159 return error;
1160 } 1160 }
1161 1161
1162 static void __exit exit_scsi(void) 1162 static void __exit exit_scsi(void)
1163 { 1163 {
1164 scsi_netlink_exit(); 1164 scsi_netlink_exit();
1165 scsi_sysfs_unregister(); 1165 scsi_sysfs_unregister();
1166 scsi_exit_sysctl(); 1166 scsi_exit_sysctl();
1167 scsi_exit_hosts(); 1167 scsi_exit_hosts();
1168 scsi_exit_devinfo(); 1168 scsi_exit_devinfo();
1169 scsi_exit_procfs(); 1169 scsi_exit_procfs();
1170 scsi_exit_queue(); 1170 scsi_exit_queue();
1171 } 1171 }
1172 1172
1173 subsys_initcall(init_scsi); 1173 subsys_initcall(init_scsi);
1174 module_exit(exit_scsi); 1174 module_exit(exit_scsi);
1175 1175
|
This page was automatically generated by the
LXR engine.
|