lib/test_meminit: fix off-by-one error in test_pages()
[platform/kernel/linux-starfive.git] / drivers / scsi / scsi.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  scsi.c Copyright (C) 1992 Drew Eckhardt
4  *         Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
5  *         Copyright (C) 2002, 2003 Christoph Hellwig
6  *
7  *  generic mid-level SCSI driver
8  *      Initial versions: Drew Eckhardt
9  *      Subsequent revisions: Eric Youngdale
10  *
11  *  <drew@colorado.edu>
12  *
13  *  Bug correction thanks go to :
14  *      Rik Faith <faith@cs.unc.edu>
15  *      Tommy Thorn <tthorn>
16  *      Thomas Wuensche <tw@fgb1.fgb.mw.tu-muenchen.de>
17  *
18  *  Modified by Eric Youngdale eric@andante.org or ericy@gnu.ai.mit.edu to
19  *  add scatter-gather, multiple outstanding request, and other
20  *  enhancements.
21  *
22  *  Native multichannel, wide scsi, /proc/scsi and hot plugging
23  *  support added by Michael Neuffer <mike@i-connect.net>
24  *
25  *  Added request_module("scsi_hostadapter") for kerneld:
26  *  (Put an "alias scsi_hostadapter your_hostadapter" in /etc/modprobe.conf)
27  *  Bjorn Ekwall  <bj0rn@blox.se>
28  *  (changed to kmod)
29  *
30  *  Major improvements to the timeout, abort, and reset processing,
31  *  as well as performance modifications for large queue depths by
32  *  Leonard N. Zubkoff <lnz@dandelion.com>
33  *
34  *  Converted cli() code to spinlocks, Ingo Molnar
35  *
36  *  Jiffies wrap fixes (host->resetting), 3 Dec 1998 Andrea Arcangeli
37  *
38  *  out_of_space hacks, D. Gilbert (dpg) 990608
39  */
40
41 #include <linux/module.h>
42 #include <linux/moduleparam.h>
43 #include <linux/kernel.h>
44 #include <linux/timer.h>
45 #include <linux/string.h>
46 #include <linux/slab.h>
47 #include <linux/blkdev.h>
48 #include <linux/delay.h>
49 #include <linux/init.h>
50 #include <linux/completion.h>
51 #include <linux/unistd.h>
52 #include <linux/spinlock.h>
53 #include <linux/kmod.h>
54 #include <linux/interrupt.h>
55 #include <linux/notifier.h>
56 #include <linux/cpu.h>
57 #include <linux/mutex.h>
58 #include <asm/unaligned.h>
59
60 #include <scsi/scsi.h>
61 #include <scsi/scsi_cmnd.h>
62 #include <scsi/scsi_dbg.h>
63 #include <scsi/scsi_device.h>
64 #include <scsi/scsi_driver.h>
65 #include <scsi/scsi_eh.h>
66 #include <scsi/scsi_host.h>
67 #include <scsi/scsi_tcq.h>
68
69 #include "scsi_priv.h"
70 #include "scsi_logging.h"
71
72 #define CREATE_TRACE_POINTS
73 #include <trace/events/scsi.h>
74
75 /*
76  * Definitions and constants.
77  */
78
79 /*
80  * Note - the initial logging level can be set here to log events at boot time.
81  * After the system is up, you may enable logging via the /proc interface.
82  */
83 unsigned int scsi_logging_level;
84 #if defined(CONFIG_SCSI_LOGGING)
85 EXPORT_SYMBOL(scsi_logging_level);
86 #endif
87
88 #ifdef CONFIG_SCSI_LOGGING
89 void scsi_log_send(struct scsi_cmnd *cmd)
90 {
91         unsigned int level;
92
93         /*
94          * If ML QUEUE log level is greater than or equal to:
95          *
96          * 1: nothing (match completion)
97          *
98          * 2: log opcode + command of all commands + cmd address
99          *
100          * 3: same as 2
101          *
102          * 4: same as 3
103          */
104         if (unlikely(scsi_logging_level)) {
105                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
106                                        SCSI_LOG_MLQUEUE_BITS);
107                 if (level > 1) {
108                         scmd_printk(KERN_INFO, cmd,
109                                     "Send: scmd 0x%p\n", cmd);
110                         scsi_print_command(cmd);
111                 }
112         }
113 }
114
115 void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
116 {
117         unsigned int level;
118
119         /*
120          * If ML COMPLETE log level is greater than or equal to:
121          *
122          * 1: log disposition, result, opcode + command, and conditionally
123          * sense data for failures or non SUCCESS dispositions.
124          *
125          * 2: same as 1 but for all command completions.
126          *
127          * 3: same as 2
128          *
129          * 4: same as 3 plus dump extra junk
130          */
131         if (unlikely(scsi_logging_level)) {
132                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLCOMPLETE_SHIFT,
133                                        SCSI_LOG_MLCOMPLETE_BITS);
134                 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
135                     (level > 1)) {
136                         scsi_print_result(cmd, "Done", disposition);
137                         scsi_print_command(cmd);
138                         if (scsi_status_is_check_condition(cmd->result))
139                                 scsi_print_sense(cmd);
140                         if (level > 3)
141                                 scmd_printk(KERN_INFO, cmd,
142                                             "scsi host busy %d failed %d\n",
143                                             scsi_host_busy(cmd->device->host),
144                                             cmd->device->host->host_failed);
145                 }
146         }
147 }
148 #endif
149
150 /**
151  * scsi_finish_command - cleanup and pass command back to upper layer
152  * @cmd: the command
153  *
154  * Description: Pass command off to upper layer for finishing of I/O
155  *              request, waking processes that are waiting on results,
156  *              etc.
157  */
158 void scsi_finish_command(struct scsi_cmnd *cmd)
159 {
160         struct scsi_device *sdev = cmd->device;
161         struct scsi_target *starget = scsi_target(sdev);
162         struct Scsi_Host *shost = sdev->host;
163         struct scsi_driver *drv;
164         unsigned int good_bytes;
165
166         scsi_device_unbusy(sdev, cmd);
167
168         /*
169          * Clear the flags that say that the device/target/host is no longer
170          * capable of accepting new commands.
171          */
172         if (atomic_read(&shost->host_blocked))
173                 atomic_set(&shost->host_blocked, 0);
174         if (atomic_read(&starget->target_blocked))
175                 atomic_set(&starget->target_blocked, 0);
176         if (atomic_read(&sdev->device_blocked))
177                 atomic_set(&sdev->device_blocked, 0);
178
179         SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
180                                 "Notifying upper driver of completion "
181                                 "(result %x)\n", cmd->result));
182
183         good_bytes = scsi_bufflen(cmd);
184         if (!blk_rq_is_passthrough(scsi_cmd_to_rq(cmd))) {
185                 int old_good_bytes = good_bytes;
186                 drv = scsi_cmd_to_driver(cmd);
187                 if (drv->done)
188                         good_bytes = drv->done(cmd);
189                 /*
190                  * USB may not give sense identifying bad sector and
191                  * simply return a residue instead, so subtract off the
192                  * residue if drv->done() error processing indicates no
193                  * change to the completion length.
194                  */
195                 if (good_bytes == old_good_bytes)
196                         good_bytes -= scsi_get_resid(cmd);
197         }
198         scsi_io_completion(cmd, good_bytes);
199 }
200
201
202 /*
203  * 4096 is big enough for saturating fast SCSI LUNs.
204  */
205 int scsi_device_max_queue_depth(struct scsi_device *sdev)
206 {
207         return min_t(int, sdev->host->can_queue, 4096);
208 }
209
210 /**
211  * scsi_change_queue_depth - change a device's queue depth
212  * @sdev: SCSI Device in question
213  * @depth: number of commands allowed to be queued to the driver
214  *
215  * Sets the device queue depth and returns the new value.
216  */
217 int scsi_change_queue_depth(struct scsi_device *sdev, int depth)
218 {
219         depth = min_t(int, depth, scsi_device_max_queue_depth(sdev));
220
221         if (depth > 0) {
222                 sdev->queue_depth = depth;
223                 wmb();
224         }
225
226         if (sdev->request_queue)
227                 blk_set_queue_depth(sdev->request_queue, depth);
228
229         sbitmap_resize(&sdev->budget_map, sdev->queue_depth);
230
231         return sdev->queue_depth;
232 }
233 EXPORT_SYMBOL(scsi_change_queue_depth);
234
235 /**
236  * scsi_track_queue_full - track QUEUE_FULL events to adjust queue depth
237  * @sdev: SCSI Device in question
238  * @depth: Current number of outstanding SCSI commands on this device,
239  *         not counting the one returned as QUEUE_FULL.
240  *
241  * Description: This function will track successive QUEUE_FULL events on a
242  *              specific SCSI device to determine if and when there is a
243  *              need to adjust the queue depth on the device.
244  *
245  * Returns:     0 - No change needed, >0 - Adjust queue depth to this new depth,
246  *              -1 - Drop back to untagged operation using host->cmd_per_lun
247  *                      as the untagged command depth
248  *
249  * Lock Status: None held on entry
250  *
251  * Notes:       Low level drivers may call this at any time and we will do
252  *              "The Right Thing."  We are interrupt context safe.
253  */
254 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
255 {
256
257         /*
258          * Don't let QUEUE_FULLs on the same
259          * jiffies count, they could all be from
260          * same event.
261          */
262         if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
263                 return 0;
264
265         sdev->last_queue_full_time = jiffies;
266         if (sdev->last_queue_full_depth != depth) {
267                 sdev->last_queue_full_count = 1;
268                 sdev->last_queue_full_depth = depth;
269         } else {
270                 sdev->last_queue_full_count++;
271         }
272
273         if (sdev->last_queue_full_count <= 10)
274                 return 0;
275
276         return scsi_change_queue_depth(sdev, depth);
277 }
278 EXPORT_SYMBOL(scsi_track_queue_full);
279
280 /**
281  * scsi_vpd_inquiry - Request a device provide us with a VPD page
282  * @sdev: The device to ask
283  * @buffer: Where to put the result
284  * @page: Which Vital Product Data to return
285  * @len: The length of the buffer
286  *
287  * This is an internal helper function.  You probably want to use
288  * scsi_get_vpd_page instead.
289  *
290  * Returns size of the vpd page on success or a negative error number.
291  */
292 static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
293                                                         u8 page, unsigned len)
294 {
295         int result;
296         unsigned char cmd[16];
297
298         if (len < 4)
299                 return -EINVAL;
300
301         cmd[0] = INQUIRY;
302         cmd[1] = 1;             /* EVPD */
303         cmd[2] = page;
304         cmd[3] = len >> 8;
305         cmd[4] = len & 0xff;
306         cmd[5] = 0;             /* Control byte */
307
308         /*
309          * I'm not convinced we need to try quite this hard to get VPD, but
310          * all the existing users tried this hard.
311          */
312         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
313                                   len, NULL, 30 * HZ, 3, NULL);
314         if (result)
315                 return -EIO;
316
317         /*
318          * Sanity check that we got the page back that we asked for and that
319          * the page size is not 0.
320          */
321         if (buffer[1] != page)
322                 return -EIO;
323
324         result = get_unaligned_be16(&buffer[2]);
325         if (!result)
326                 return -EIO;
327
328         return result + 4;
329 }
330
331 static int scsi_get_vpd_size(struct scsi_device *sdev, u8 page)
332 {
333         unsigned char vpd_header[SCSI_VPD_HEADER_SIZE] __aligned(4);
334         int result;
335
336         if (sdev->no_vpd_size)
337                 return SCSI_DEFAULT_VPD_LEN;
338
339         /*
340          * Fetch the VPD page header to find out how big the page
341          * is. This is done to prevent problems on legacy devices
342          * which can not handle allocation lengths as large as
343          * potentially requested by the caller.
344          */
345         result = scsi_vpd_inquiry(sdev, vpd_header, page, sizeof(vpd_header));
346         if (result < 0)
347                 return 0;
348
349         if (result < SCSI_VPD_HEADER_SIZE) {
350                 dev_warn_once(&sdev->sdev_gendev,
351                               "%s: short VPD page 0x%02x length: %d bytes\n",
352                               __func__, page, result);
353                 return 0;
354         }
355
356         return result;
357 }
358
359 /**
360  * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
361  * @sdev: The device to ask
362  * @page: Which Vital Product Data to return
363  * @buf: where to store the VPD
364  * @buf_len: number of bytes in the VPD buffer area
365  *
366  * SCSI devices may optionally supply Vital Product Data.  Each 'page'
367  * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
368  * If the device supports this VPD page, this routine fills @buf
369  * with the data from that page and return 0. If the VPD page is not
370  * supported or its content cannot be retrieved, -EINVAL is returned.
371  */
372 int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
373                       int buf_len)
374 {
375         int result, vpd_len;
376
377         if (!scsi_device_supports_vpd(sdev))
378                 return -EINVAL;
379
380         vpd_len = scsi_get_vpd_size(sdev, page);
381         if (vpd_len <= 0)
382                 return -EINVAL;
383
384         vpd_len = min(vpd_len, buf_len);
385
386         /*
387          * Fetch the actual page. Since the appropriate size was reported
388          * by the device it is now safe to ask for something bigger.
389          */
390         memset(buf, 0, buf_len);
391         result = scsi_vpd_inquiry(sdev, buf, page, vpd_len);
392         if (result < 0)
393                 return -EINVAL;
394         else if (result > vpd_len)
395                 dev_warn_once(&sdev->sdev_gendev,
396                               "%s: VPD page 0x%02x result %d > %d bytes\n",
397                               __func__, page, result, vpd_len);
398
399         return 0;
400 }
401 EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
402
403 /**
404  * scsi_get_vpd_buf - Get Vital Product Data from a SCSI device
405  * @sdev: The device to ask
406  * @page: Which Vital Product Data to return
407  *
408  * Returns %NULL upon failure.
409  */
410 static struct scsi_vpd *scsi_get_vpd_buf(struct scsi_device *sdev, u8 page)
411 {
412         struct scsi_vpd *vpd_buf;
413         int vpd_len, result;
414
415         vpd_len = scsi_get_vpd_size(sdev, page);
416         if (vpd_len <= 0)
417                 return NULL;
418
419 retry_pg:
420         /*
421          * Fetch the actual page. Since the appropriate size was reported
422          * by the device it is now safe to ask for something bigger.
423          */
424         vpd_buf = kmalloc(sizeof(*vpd_buf) + vpd_len, GFP_KERNEL);
425         if (!vpd_buf)
426                 return NULL;
427
428         result = scsi_vpd_inquiry(sdev, vpd_buf->data, page, vpd_len);
429         if (result < 0) {
430                 kfree(vpd_buf);
431                 return NULL;
432         }
433         if (result > vpd_len) {
434                 dev_warn_once(&sdev->sdev_gendev,
435                               "%s: VPD page 0x%02x result %d > %d bytes\n",
436                               __func__, page, result, vpd_len);
437                 vpd_len = result;
438                 kfree(vpd_buf);
439                 goto retry_pg;
440         }
441
442         vpd_buf->len = result;
443
444         return vpd_buf;
445 }
446
447 static void scsi_update_vpd_page(struct scsi_device *sdev, u8 page,
448                                  struct scsi_vpd __rcu **sdev_vpd_buf)
449 {
450         struct scsi_vpd *vpd_buf;
451
452         vpd_buf = scsi_get_vpd_buf(sdev, page);
453         if (!vpd_buf)
454                 return;
455
456         mutex_lock(&sdev->inquiry_mutex);
457         vpd_buf = rcu_replace_pointer(*sdev_vpd_buf, vpd_buf,
458                                       lockdep_is_held(&sdev->inquiry_mutex));
459         mutex_unlock(&sdev->inquiry_mutex);
460
461         if (vpd_buf)
462                 kfree_rcu(vpd_buf, rcu);
463 }
464
465 /**
466  * scsi_attach_vpd - Attach Vital Product Data to a SCSI device structure
467  * @sdev: The device to ask
468  *
469  * Attach the 'Device Identification' VPD page (0x83) and the
470  * 'Unit Serial Number' VPD page (0x80) to a SCSI device
471  * structure. This information can be used to identify the device
472  * uniquely.
473  */
474 void scsi_attach_vpd(struct scsi_device *sdev)
475 {
476         int i;
477         struct scsi_vpd *vpd_buf;
478
479         if (!scsi_device_supports_vpd(sdev))
480                 return;
481
482         /* Ask for all the pages supported by this device */
483         vpd_buf = scsi_get_vpd_buf(sdev, 0);
484         if (!vpd_buf)
485                 return;
486
487         for (i = 4; i < vpd_buf->len; i++) {
488                 if (vpd_buf->data[i] == 0x0)
489                         scsi_update_vpd_page(sdev, 0x0, &sdev->vpd_pg0);
490                 if (vpd_buf->data[i] == 0x80)
491                         scsi_update_vpd_page(sdev, 0x80, &sdev->vpd_pg80);
492                 if (vpd_buf->data[i] == 0x83)
493                         scsi_update_vpd_page(sdev, 0x83, &sdev->vpd_pg83);
494                 if (vpd_buf->data[i] == 0x89)
495                         scsi_update_vpd_page(sdev, 0x89, &sdev->vpd_pg89);
496                 if (vpd_buf->data[i] == 0xb0)
497                         scsi_update_vpd_page(sdev, 0xb0, &sdev->vpd_pgb0);
498                 if (vpd_buf->data[i] == 0xb1)
499                         scsi_update_vpd_page(sdev, 0xb1, &sdev->vpd_pgb1);
500                 if (vpd_buf->data[i] == 0xb2)
501                         scsi_update_vpd_page(sdev, 0xb2, &sdev->vpd_pgb2);
502         }
503         kfree(vpd_buf);
504 }
505
506 /**
507  * scsi_report_opcode - Find out if a given command opcode is supported
508  * @sdev:       scsi device to query
509  * @buffer:     scratch buffer (must be at least 20 bytes long)
510  * @len:        length of buffer
511  * @opcode:     opcode for command to look up
512  *
513  * Uses the REPORT SUPPORTED OPERATION CODES to look up the given
514  * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is
515  * unsupported and 1 if the device claims to support the command.
516  */
517 int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
518                        unsigned int len, unsigned char opcode)
519 {
520         unsigned char cmd[16];
521         struct scsi_sense_hdr sshdr;
522         int result, request_len;
523
524         if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
525                 return -EINVAL;
526
527         /* RSOC header + size of command we are asking about */
528         request_len = 4 + COMMAND_SIZE(opcode);
529         if (request_len > len) {
530                 dev_warn_once(&sdev->sdev_gendev,
531                               "%s: len %u bytes, opcode 0x%02x needs %u\n",
532                               __func__, len, opcode, request_len);
533                 return -EINVAL;
534         }
535
536         memset(cmd, 0, 16);
537         cmd[0] = MAINTENANCE_IN;
538         cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
539         cmd[2] = 1;             /* One command format */
540         cmd[3] = opcode;
541         put_unaligned_be32(request_len, &cmd[6]);
542         memset(buffer, 0, len);
543
544         result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer,
545                                   request_len, &sshdr, 30 * HZ, 3, NULL);
546
547         if (result < 0)
548                 return result;
549         if (result && scsi_sense_valid(&sshdr) &&
550             sshdr.sense_key == ILLEGAL_REQUEST &&
551             (sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
552                 return -EINVAL;
553
554         if ((buffer[1] & 3) == 3) /* Command supported */
555                 return 1;
556
557         return 0;
558 }
559 EXPORT_SYMBOL(scsi_report_opcode);
560
561 /**
562  * scsi_device_get  -  get an additional reference to a scsi_device
563  * @sdev:       device to get a reference to
564  *
565  * Description: Gets a reference to the scsi_device and increments the use count
566  * of the underlying LLDD module.  You must hold host_lock of the
567  * parent Scsi_Host or already have a reference when calling this.
568  *
569  * This will fail if a device is deleted or cancelled, or when the LLD module
570  * is in the process of being unloaded.
571  */
572 int scsi_device_get(struct scsi_device *sdev)
573 {
574         if (sdev->sdev_state == SDEV_DEL || sdev->sdev_state == SDEV_CANCEL)
575                 goto fail;
576         if (!get_device(&sdev->sdev_gendev))
577                 goto fail;
578         if (!try_module_get(sdev->host->hostt->module))
579                 goto fail_put_device;
580         return 0;
581
582 fail_put_device:
583         put_device(&sdev->sdev_gendev);
584 fail:
585         return -ENXIO;
586 }
587 EXPORT_SYMBOL(scsi_device_get);
588
589 /**
590  * scsi_device_put  -  release a reference to a scsi_device
591  * @sdev:       device to release a reference on.
592  *
593  * Description: Release a reference to the scsi_device and decrements the use
594  * count of the underlying LLDD module.  The device is freed once the last
595  * user vanishes.
596  */
597 void scsi_device_put(struct scsi_device *sdev)
598 {
599         struct module *mod = sdev->host->hostt->module;
600
601         put_device(&sdev->sdev_gendev);
602         module_put(mod);
603 }
604 EXPORT_SYMBOL(scsi_device_put);
605
606 /* helper for shost_for_each_device, see that for documentation */
607 struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost,
608                                            struct scsi_device *prev)
609 {
610         struct list_head *list = (prev ? &prev->siblings : &shost->__devices);
611         struct scsi_device *next = NULL;
612         unsigned long flags;
613
614         spin_lock_irqsave(shost->host_lock, flags);
615         while (list->next != &shost->__devices) {
616                 next = list_entry(list->next, struct scsi_device, siblings);
617                 /* skip devices that we can't get a reference to */
618                 if (!scsi_device_get(next))
619                         break;
620                 next = NULL;
621                 list = list->next;
622         }
623         spin_unlock_irqrestore(shost->host_lock, flags);
624
625         if (prev)
626                 scsi_device_put(prev);
627         return next;
628 }
629 EXPORT_SYMBOL(__scsi_iterate_devices);
630
631 /**
632  * starget_for_each_device  -  helper to walk all devices of a target
633  * @starget:    target whose devices we want to iterate over.
634  * @data:       Opaque passed to each function call.
635  * @fn:         Function to call on each device
636  *
637  * This traverses over each device of @starget.  The devices have
638  * a reference that must be released by scsi_host_put when breaking
639  * out of the loop.
640  */
641 void starget_for_each_device(struct scsi_target *starget, void *data,
642                      void (*fn)(struct scsi_device *, void *))
643 {
644         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
645         struct scsi_device *sdev;
646
647         shost_for_each_device(sdev, shost) {
648                 if ((sdev->channel == starget->channel) &&
649                     (sdev->id == starget->id))
650                         fn(sdev, data);
651         }
652 }
653 EXPORT_SYMBOL(starget_for_each_device);
654
655 /**
656  * __starget_for_each_device - helper to walk all devices of a target (UNLOCKED)
657  * @starget:    target whose devices we want to iterate over.
658  * @data:       parameter for callback @fn()
659  * @fn:         callback function that is invoked for each device
660  *
661  * This traverses over each device of @starget.  It does _not_
662  * take a reference on the scsi_device, so the whole loop must be
663  * protected by shost->host_lock.
664  *
665  * Note:  The only reason why drivers would want to use this is because
666  * they need to access the device list in irq context.  Otherwise you
667  * really want to use starget_for_each_device instead.
668  **/
669 void __starget_for_each_device(struct scsi_target *starget, void *data,
670                                void (*fn)(struct scsi_device *, void *))
671 {
672         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
673         struct scsi_device *sdev;
674
675         __shost_for_each_device(sdev, shost) {
676                 if ((sdev->channel == starget->channel) &&
677                     (sdev->id == starget->id))
678                         fn(sdev, data);
679         }
680 }
681 EXPORT_SYMBOL(__starget_for_each_device);
682
683 /**
684  * __scsi_device_lookup_by_target - find a device given the target (UNLOCKED)
685  * @starget:    SCSI target pointer
686  * @lun:        SCSI Logical Unit Number
687  *
688  * Description: Looks up the scsi_device with the specified @lun for a given
689  * @starget.  The returned scsi_device does not have an additional
690  * reference.  You must hold the host's host_lock over this call and
691  * any access to the returned scsi_device. A scsi_device in state
692  * SDEV_DEL is skipped.
693  *
694  * Note:  The only reason why drivers should use this is because
695  * they need to access the device list in irq context.  Otherwise you
696  * really want to use scsi_device_lookup_by_target instead.
697  **/
698 struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
699                                                    u64 lun)
700 {
701         struct scsi_device *sdev;
702
703         list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
704                 if (sdev->sdev_state == SDEV_DEL)
705                         continue;
706                 if (sdev->lun ==lun)
707                         return sdev;
708         }
709
710         return NULL;
711 }
712 EXPORT_SYMBOL(__scsi_device_lookup_by_target);
713
714 /**
715  * scsi_device_lookup_by_target - find a device given the target
716  * @starget:    SCSI target pointer
717  * @lun:        SCSI Logical Unit Number
718  *
719  * Description: Looks up the scsi_device with the specified @lun for a given
720  * @starget.  The returned scsi_device has an additional reference that
721  * needs to be released with scsi_device_put once you're done with it.
722  **/
723 struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *starget,
724                                                  u64 lun)
725 {
726         struct scsi_device *sdev;
727         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
728         unsigned long flags;
729
730         spin_lock_irqsave(shost->host_lock, flags);
731         sdev = __scsi_device_lookup_by_target(starget, lun);
732         if (sdev && scsi_device_get(sdev))
733                 sdev = NULL;
734         spin_unlock_irqrestore(shost->host_lock, flags);
735
736         return sdev;
737 }
738 EXPORT_SYMBOL(scsi_device_lookup_by_target);
739
740 /**
741  * __scsi_device_lookup - find a device given the host (UNLOCKED)
742  * @shost:      SCSI host pointer
743  * @channel:    SCSI channel (zero if only one channel)
744  * @id:         SCSI target number (physical unit number)
745  * @lun:        SCSI Logical Unit Number
746  *
747  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
748  * for a given host. The returned scsi_device does not have an additional
749  * reference.  You must hold the host's host_lock over this call and any access
750  * to the returned scsi_device.
751  *
752  * Note:  The only reason why drivers would want to use this is because
753  * they need to access the device list in irq context.  Otherwise you
754  * really want to use scsi_device_lookup instead.
755  **/
756 struct scsi_device *__scsi_device_lookup(struct Scsi_Host *shost,
757                 uint channel, uint id, u64 lun)
758 {
759         struct scsi_device *sdev;
760
761         list_for_each_entry(sdev, &shost->__devices, siblings) {
762                 if (sdev->sdev_state == SDEV_DEL)
763                         continue;
764                 if (sdev->channel == channel && sdev->id == id &&
765                                 sdev->lun ==lun)
766                         return sdev;
767         }
768
769         return NULL;
770 }
771 EXPORT_SYMBOL(__scsi_device_lookup);
772
773 /**
774  * scsi_device_lookup - find a device given the host
775  * @shost:      SCSI host pointer
776  * @channel:    SCSI channel (zero if only one channel)
777  * @id:         SCSI target number (physical unit number)
778  * @lun:        SCSI Logical Unit Number
779  *
780  * Description: Looks up the scsi_device with the specified @channel, @id, @lun
781  * for a given host.  The returned scsi_device has an additional reference that
782  * needs to be released with scsi_device_put once you're done with it.
783  **/
784 struct scsi_device *scsi_device_lookup(struct Scsi_Host *shost,
785                 uint channel, uint id, u64 lun)
786 {
787         struct scsi_device *sdev;
788         unsigned long flags;
789
790         spin_lock_irqsave(shost->host_lock, flags);
791         sdev = __scsi_device_lookup(shost, channel, id, lun);
792         if (sdev && scsi_device_get(sdev))
793                 sdev = NULL;
794         spin_unlock_irqrestore(shost->host_lock, flags);
795
796         return sdev;
797 }
798 EXPORT_SYMBOL(scsi_device_lookup);
799
800 MODULE_DESCRIPTION("SCSI core");
801 MODULE_LICENSE("GPL");
802
803 module_param(scsi_logging_level, int, S_IRUGO|S_IWUSR);
804 MODULE_PARM_DESC(scsi_logging_level, "a bit mask of logging levels");
805
806 static int __init init_scsi(void)
807 {
808         int error;
809
810         error = scsi_init_procfs();
811         if (error)
812                 goto cleanup_queue;
813         error = scsi_init_devinfo();
814         if (error)
815                 goto cleanup_procfs;
816         error = scsi_init_hosts();
817         if (error)
818                 goto cleanup_devlist;
819         error = scsi_init_sysctl();
820         if (error)
821                 goto cleanup_hosts;
822         error = scsi_sysfs_register();
823         if (error)
824                 goto cleanup_sysctl;
825
826         scsi_netlink_init();
827
828         printk(KERN_NOTICE "SCSI subsystem initialized\n");
829         return 0;
830
831 cleanup_sysctl:
832         scsi_exit_sysctl();
833 cleanup_hosts:
834         scsi_exit_hosts();
835 cleanup_devlist:
836         scsi_exit_devinfo();
837 cleanup_procfs:
838         scsi_exit_procfs();
839 cleanup_queue:
840         scsi_exit_queue();
841         printk(KERN_ERR "SCSI subsystem failed to initialize, error = %d\n",
842                -error);
843         return error;
844 }
845
846 static void __exit exit_scsi(void)
847 {
848         scsi_netlink_exit();
849         scsi_sysfs_unregister();
850         scsi_exit_sysctl();
851         scsi_exit_hosts();
852         scsi_exit_devinfo();
853         scsi_exit_procfs();
854         scsi_exit_queue();
855 }
856
857 subsys_initcall(init_scsi);
858 module_exit(exit_scsi);