License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* scsi_scan.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 2000 Eric Youngdale,
|
|
|
|
* Copyright (C) 2002 Patrick Mansfield
|
|
|
|
*
|
|
|
|
* The general scanning/probing algorithm is as follows, exceptions are
|
|
|
|
* made to it depending on device specific flags, compilation options, and
|
|
|
|
* global variable (boot or module load time) settings.
|
|
|
|
*
|
|
|
|
* A specific LUN is scanned via an INQUIRY command; if the LUN has a
|
2005-10-31 17:32:08 +00:00
|
|
|
* device attached, a scsi_device is allocated and setup for it.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* For every id of every channel on the given host:
|
|
|
|
*
|
|
|
|
* Scan LUN 0; if the target responds to LUN 0 (even if there is no
|
|
|
|
* device or storage attached to LUN 0):
|
|
|
|
*
|
|
|
|
* If LUN 0 has a device attached, allocate and setup a
|
2005-10-31 17:32:08 +00:00
|
|
|
* scsi_device for it.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* If target is SCSI-3 or up, issue a REPORT LUN, and scan
|
|
|
|
* all of the LUNs returned by the REPORT LUN; else,
|
|
|
|
* sequentially scan LUNs up until some maximum is reached,
|
|
|
|
* or a LUN is seen that cannot have a device attached to it.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/blkdev.h>
|
2006-09-28 21:19:20 +00:00
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/kthread.h>
|
|
|
|
#include <linux/spinlock.h>
|
2009-01-04 13:32:28 +00:00
|
|
|
#include <linux/async.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2014-12-16 16:01:19 +00:00
|
|
|
#include <asm/unaligned.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <scsi/scsi.h>
|
2006-06-10 16:01:03 +00:00
|
|
|
#include <scsi/scsi_cmnd.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <scsi/scsi_device.h>
|
|
|
|
#include <scsi/scsi_driver.h>
|
|
|
|
#include <scsi/scsi_devinfo.h>
|
|
|
|
#include <scsi/scsi_host.h>
|
|
|
|
#include <scsi/scsi_transport.h>
|
2016-02-19 08:17:16 +00:00
|
|
|
#include <scsi/scsi_dh.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <scsi/scsi_eh.h>
|
|
|
|
|
|
|
|
#include "scsi_priv.h"
|
|
|
|
#include "scsi_logging.h"
|
|
|
|
|
|
|
|
#define ALLOC_FAILURE_MSG KERN_ERR "%s: Allocation failure during" \
|
|
|
|
" SCSI scanning, some SCSI devices might not be configured\n"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Default timeout
|
|
|
|
*/
|
|
|
|
#define SCSI_TIMEOUT (2*HZ)
|
2015-09-04 19:47:06 +00:00
|
|
|
#define SCSI_REPORT_LUNS_TIMEOUT (30*HZ)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2007-02-17 18:13:42 +00:00
|
|
|
* Prefix values for the SCSI id's (stored in sysfs name field)
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
#define SCSI_UID_SER_NUM 'S'
|
|
|
|
#define SCSI_UID_UNKNOWN 'Z'
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return values of some of the scanning functions.
|
|
|
|
*
|
|
|
|
* SCSI_SCAN_NO_RESPONSE: no valid response received from the target, this
|
|
|
|
* includes allocation or general failures preventing IO from being sent.
|
|
|
|
*
|
|
|
|
* SCSI_SCAN_TARGET_PRESENT: target responded, but no device is available
|
|
|
|
* on the given LUN.
|
|
|
|
*
|
|
|
|
* SCSI_SCAN_LUN_PRESENT: target responded, and a device is available on a
|
|
|
|
* given LUN.
|
|
|
|
*/
|
|
|
|
#define SCSI_SCAN_NO_RESPONSE 0
|
|
|
|
#define SCSI_SCAN_TARGET_PRESENT 1
|
|
|
|
#define SCSI_SCAN_LUN_PRESENT 2
|
|
|
|
|
2005-11-28 15:22:25 +00:00
|
|
|
static const char *scsi_null_device_strs = "nullnullnullnull";
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define MAX_SCSI_LUNS 512
|
|
|
|
|
2014-06-25 13:27:38 +00:00
|
|
|
static u64 max_scsi_luns = MAX_SCSI_LUNS;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-25 13:27:38 +00:00
|
|
|
module_param_named(max_luns, max_scsi_luns, ullong, S_IRUGO|S_IWUSR);
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_PARM_DESC(max_luns,
|
2014-06-25 13:27:38 +00:00
|
|
|
"last scsi LUN (should be between 1 and 2^64-1)");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-11-22 20:24:52 +00:00
|
|
|
#ifdef CONFIG_SCSI_SCAN_ASYNC
|
|
|
|
#define SCSI_SCAN_TYPE_DEFAULT "async"
|
|
|
|
#else
|
|
|
|
#define SCSI_SCAN_TYPE_DEFAULT "sync"
|
|
|
|
#endif
|
|
|
|
|
2021-11-29 19:45:59 +00:00
|
|
|
static char scsi_scan_type[7] = SCSI_SCAN_TYPE_DEFAULT;
|
2006-09-28 21:19:20 +00:00
|
|
|
|
2016-03-17 07:39:45 +00:00
|
|
|
module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type),
|
|
|
|
S_IRUGO|S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(scan, "sync, async, manual, or none. "
|
|
|
|
"Setting to 'manual' disables automatic scanning, but allows "
|
|
|
|
"for manual device scan via the 'scan' sysfs attribute.");
|
2006-09-28 21:19:20 +00:00
|
|
|
|
2009-03-12 15:08:51 +00:00
|
|
|
static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-09-19 13:59:16 +00:00
|
|
|
module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR);
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_PARM_DESC(inq_timeout,
|
|
|
|
"Timeout (in seconds) waiting for devices to answer INQUIRY."
|
2009-03-12 15:08:51 +00:00
|
|
|
" Default is 20. Some devices may need more; most need less.");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-06-26 21:18:51 +00:00
|
|
|
/* This lock protects only this list */
|
2006-09-28 21:19:20 +00:00
|
|
|
static DEFINE_SPINLOCK(async_scan_lock);
|
|
|
|
static LIST_HEAD(scanning_hosts);
|
|
|
|
|
|
|
|
struct async_scan_data {
|
|
|
|
struct list_head list;
|
|
|
|
struct Scsi_Host *shost;
|
|
|
|
struct completion prev_finished;
|
|
|
|
};
|
|
|
|
|
2021-11-29 19:45:58 +00:00
|
|
|
/*
|
2021-10-06 21:54:51 +00:00
|
|
|
* scsi_enable_async_suspend - Enable async suspend and resume
|
|
|
|
*/
|
|
|
|
void scsi_enable_async_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* If a user has disabled async probing a likely reason is due to a
|
|
|
|
* storage enclosure that does not inject staggered spin-ups. For
|
|
|
|
* safety, make resume synchronous as well in that case.
|
|
|
|
*/
|
|
|
|
if (strncmp(scsi_scan_type, "async", 5) != 0)
|
|
|
|
return;
|
|
|
|
/* Enable asynchronous suspend and resume. */
|
|
|
|
device_enable_async_suspend(dev);
|
|
|
|
}
|
|
|
|
|
2006-09-28 21:19:20 +00:00
|
|
|
/**
|
|
|
|
* scsi_complete_async_scans - Wait for asynchronous scans to complete
|
|
|
|
*
|
2006-12-08 02:29:27 +00:00
|
|
|
* When this function returns, any host which started scanning before
|
|
|
|
* this function was called will have finished its scan. Hosts which
|
|
|
|
* started scanning after this function was called may or may not have
|
|
|
|
* finished.
|
2006-09-28 21:19:20 +00:00
|
|
|
*/
|
|
|
|
int scsi_complete_async_scans(void)
|
|
|
|
{
|
|
|
|
struct async_scan_data *data;
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (list_empty(&scanning_hosts))
|
2012-07-10 02:33:45 +00:00
|
|
|
return 0;
|
2006-09-28 21:19:20 +00:00
|
|
|
/* If we can't get memory immediately, that's OK. Just
|
|
|
|
* sleep a little. Even if we never get memory, the async
|
|
|
|
* scans will finish eventually.
|
|
|
|
*/
|
|
|
|
data = kmalloc(sizeof(*data), GFP_KERNEL);
|
|
|
|
if (!data)
|
|
|
|
msleep(1);
|
|
|
|
} while (!data);
|
|
|
|
|
|
|
|
data->shost = NULL;
|
|
|
|
init_completion(&data->prev_finished);
|
|
|
|
|
|
|
|
spin_lock(&async_scan_lock);
|
|
|
|
/* Check that there's still somebody else on the list */
|
|
|
|
if (list_empty(&scanning_hosts))
|
|
|
|
goto done;
|
|
|
|
list_add_tail(&data->list, &scanning_hosts);
|
|
|
|
spin_unlock(&async_scan_lock);
|
|
|
|
|
|
|
|
printk(KERN_INFO "scsi: waiting for bus probes to complete ...\n");
|
|
|
|
wait_for_completion(&data->prev_finished);
|
|
|
|
|
|
|
|
spin_lock(&async_scan_lock);
|
|
|
|
list_del(&data->list);
|
2006-12-08 02:29:27 +00:00
|
|
|
if (!list_empty(&scanning_hosts)) {
|
|
|
|
struct async_scan_data *next = list_entry(scanning_hosts.next,
|
|
|
|
struct async_scan_data, list);
|
|
|
|
complete(&next->prev_finished);
|
|
|
|
}
|
2006-09-28 21:19:20 +00:00
|
|
|
done:
|
|
|
|
spin_unlock(&async_scan_lock);
|
2012-05-25 17:55:07 +00:00
|
|
|
|
2012-07-10 02:33:45 +00:00
|
|
|
kfree(data);
|
2006-09-28 21:19:20 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* scsi_unlock_floptical - unlock device via a special MODE SENSE command
|
2005-06-15 23:48:29 +00:00
|
|
|
* @sdev: scsi device to send command to
|
2005-04-16 22:20:36 +00:00
|
|
|
* @result: area to store the result of the MODE SENSE
|
|
|
|
*
|
|
|
|
* Description:
|
2005-06-15 23:48:29 +00:00
|
|
|
* Send a vendor specific MODE SENSE (not a MODE SELECT) command.
|
2005-04-16 22:20:36 +00:00
|
|
|
* Called for BLIST_KEY devices.
|
|
|
|
**/
|
2005-06-15 23:48:29 +00:00
|
|
|
static void scsi_unlock_floptical(struct scsi_device *sdev,
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char *result)
|
|
|
|
{
|
|
|
|
unsigned char scsi_cmd[MAX_COMMAND_SIZE];
|
|
|
|
|
2014-06-25 14:39:59 +00:00
|
|
|
sdev_printk(KERN_NOTICE, sdev, "unlocking floptical drive\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
scsi_cmd[0] = MODE_SENSE;
|
|
|
|
scsi_cmd[1] = 0;
|
|
|
|
scsi_cmd[2] = 0x2e;
|
|
|
|
scsi_cmd[3] = 0;
|
2005-06-15 23:48:29 +00:00
|
|
|
scsi_cmd[4] = 0x2a; /* size */
|
2005-04-16 22:20:36 +00:00
|
|
|
scsi_cmd[5] = 0;
|
2005-06-15 23:48:29 +00:00
|
|
|
scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL,
|
2008-12-04 05:24:39 +00:00
|
|
|
SCSI_TIMEOUT, 3, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2022-01-27 15:37:33 +00:00
|
|
|
static int scsi_realloc_sdev_budget_map(struct scsi_device *sdev,
|
|
|
|
unsigned int depth)
|
|
|
|
{
|
|
|
|
int new_shift = sbitmap_calculate_shift(depth);
|
|
|
|
bool need_alloc = !sdev->budget_map.map;
|
|
|
|
bool need_free = false;
|
|
|
|
int ret;
|
|
|
|
struct sbitmap sb_backup;
|
|
|
|
|
2022-03-16 09:44:30 +00:00
|
|
|
depth = min_t(unsigned int, depth, scsi_device_max_queue_depth(sdev));
|
|
|
|
|
2022-01-27 15:37:33 +00:00
|
|
|
/*
|
|
|
|
* realloc if new shift is calculated, which is caused by setting
|
|
|
|
* up one new default queue depth after calling ->slave_configure
|
|
|
|
*/
|
|
|
|
if (!need_alloc && new_shift != sdev->budget_map.shift)
|
|
|
|
need_alloc = need_free = true;
|
|
|
|
|
|
|
|
if (!need_alloc)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Request queue has to be frozen for reallocating budget map,
|
|
|
|
* and here disk isn't added yet, so freezing is pretty fast
|
|
|
|
*/
|
|
|
|
if (need_free) {
|
|
|
|
blk_mq_freeze_queue(sdev->request_queue);
|
|
|
|
sb_backup = sdev->budget_map;
|
|
|
|
}
|
|
|
|
ret = sbitmap_init_node(&sdev->budget_map,
|
|
|
|
scsi_device_max_queue_depth(sdev),
|
|
|
|
new_shift, GFP_KERNEL,
|
|
|
|
sdev->request_queue->node, false, true);
|
2022-03-16 09:44:30 +00:00
|
|
|
if (!ret)
|
|
|
|
sbitmap_resize(&sdev->budget_map, depth);
|
|
|
|
|
2022-01-27 15:37:33 +00:00
|
|
|
if (need_free) {
|
|
|
|
if (ret)
|
|
|
|
sdev->budget_map = sb_backup;
|
|
|
|
else
|
|
|
|
sbitmap_free(&sb_backup);
|
|
|
|
ret = 0;
|
|
|
|
blk_mq_unfreeze_queue(sdev->request_queue);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* scsi_alloc_sdev - allocate and setup a scsi_Device
|
2007-11-03 18:30:39 +00:00
|
|
|
* @starget: which target to allocate a &scsi_device for
|
|
|
|
* @lun: which lun
|
|
|
|
* @hostdata: usually NULL and set by ->slave_alloc instead
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Allocate, initialize for io, and return a pointer to a scsi_Device.
|
|
|
|
* Stores the @shost, @channel, @id, and @lun in the scsi_Device, and
|
|
|
|
* adds scsi_Device to the appropriate list.
|
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
* scsi_Device pointer, or NULL on failure.
|
|
|
|
**/
|
|
|
|
static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
|
2014-06-25 13:27:36 +00:00
|
|
|
u64 lun, void *hostdata)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2021-01-22 02:33:17 +00:00
|
|
|
unsigned int depth;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct scsi_device *sdev;
|
2021-06-22 02:46:54 +00:00
|
|
|
struct request_queue *q;
|
2005-04-16 22:20:36 +00:00
|
|
|
int display_failure_msg = 1, ret;
|
|
|
|
struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
|
|
|
|
|
2006-01-16 15:31:18 +00:00
|
|
|
sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
|
scsi: core: replace GFP_ATOMIC with GFP_KERNEL in scsi_scan.c
We had a test-report where, under memory pressure, adding LUNs to the
systems would fail (the tests add LUNs strictly in sequence):
[ 5525.853432] scsi 0:0:1:1088045124: Direct-Access IBM 2107900 .148 PQ: 0 ANSI: 5
[ 5525.853826] scsi 0:0:1:1088045124: alua: supports implicit TPGS
[ 5525.853830] scsi 0:0:1:1088045124: alua: device naa.6005076303ffd32700000000000044da port group 0 rel port 43
[ 5525.853931] sd 0:0:1:1088045124: Attached scsi generic sg10 type 0
[ 5525.854075] sd 0:0:1:1088045124: [sdk] Disabling DIF Type 1 protection
[ 5525.855495] sd 0:0:1:1088045124: [sdk] 2097152 512-byte logical blocks: (1.07 GB/1.00 GiB)
[ 5525.855606] sd 0:0:1:1088045124: [sdk] Write Protect is off
[ 5525.855609] sd 0:0:1:1088045124: [sdk] Mode Sense: ed 00 00 08
[ 5525.855795] sd 0:0:1:1088045124: [sdk] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
[ 5525.857838] sdk: sdk1
[ 5525.859468] sd 0:0:1:1088045124: [sdk] Attached SCSI disk
[ 5525.865073] sd 0:0:1:1088045124: alua: transition timeout set to 60 seconds
[ 5525.865078] sd 0:0:1:1088045124: alua: port group 00 state A preferred supports tolusnA
[ 5526.015070] sd 0:0:1:1088045124: alua: port group 00 state A preferred supports tolusnA
[ 5526.015213] sd 0:0:1:1088045124: alua: port group 00 state A preferred supports tolusnA
[ 5526.587439] scsi_alloc_sdev: Allocation failure during SCSI scanning, some SCSI devices might not be configured
[ 5526.588562] scsi_alloc_sdev: Allocation failure during SCSI scanning, some SCSI devices might not be configured
Looking at the code of scsi_alloc_sdev(), and all the calling contexts,
there seems to be no reason to use GFP_ATMOIC here. All the different
call-contexts use a mutex at some point, and nothing in between that
requires no sleeping, as far as I could see. Additionally, the code that
later allocates the block queue for the device (scsi_mq_alloc_queue())
already uses GFP_KERNEL.
There are similar allocations in two other functions:
scsi_probe_and_add_lun(), and scsi_add_lun(),; that can also be done with
GFP_KERNEL.
Here is the contexts for the three functions so far:
scsi_alloc_sdev()
scsi_probe_and_add_lun()
scsi_sequential_lun_scan()
__scsi_scan_target()
scsi_scan_target()
mutex_lock()
scsi_scan_channel()
scsi_scan_host_selected()
mutex_lock()
scsi_report_lun_scan()
__scsi_scan_target()
...
__scsi_add_device()
mutex_lock()
__scsi_scan_target()
...
scsi_report_lun_scan()
...
scsi_get_host_dev()
mutex_lock()
scsi_probe_and_add_lun()
...
scsi_add_lun()
scsi_probe_and_add_lun()
...
So replace all these, and give them a bit of a better chance to succeed,
with more chances of reclaim.
Signed-off-by: Benjamin Block <bblock@linux.ibm.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-02-21 09:18:00 +00:00
|
|
|
GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!sdev)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
sdev->vendor = scsi_null_device_strs;
|
|
|
|
sdev->model = scsi_null_device_strs;
|
|
|
|
sdev->rev = scsi_null_device_strs;
|
|
|
|
sdev->host = shost;
|
2009-10-22 22:46:33 +00:00
|
|
|
sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;
|
2005-04-16 22:20:36 +00:00
|
|
|
sdev->id = starget->id;
|
|
|
|
sdev->lun = lun;
|
|
|
|
sdev->channel = starget->channel;
|
2017-06-02 21:21:55 +00:00
|
|
|
mutex_init(&sdev->state_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
sdev->sdev_state = SDEV_CREATED;
|
|
|
|
INIT_LIST_HEAD(&sdev->siblings);
|
|
|
|
INIT_LIST_HEAD(&sdev->same_target_siblings);
|
|
|
|
INIT_LIST_HEAD(&sdev->starved_entry);
|
2007-10-29 21:15:22 +00:00
|
|
|
INIT_LIST_HEAD(&sdev->event_list);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_init(&sdev->list_lock);
|
2015-11-09 12:24:28 +00:00
|
|
|
mutex_init(&sdev->inquiry_mutex);
|
2007-10-29 21:15:22 +00:00
|
|
|
INIT_WORK(&sdev->event_work, scsi_evt_thread);
|
2011-05-17 09:04:44 +00:00
|
|
|
INIT_WORK(&sdev->requeue_work, scsi_requeue_run_queue);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
sdev->sdev_gendev.parent = get_device(&starget->dev);
|
|
|
|
sdev->sdev_target = starget;
|
|
|
|
|
|
|
|
/* usually NULL and set by ->slave_alloc instead */
|
|
|
|
sdev->hostdata = hostdata;
|
|
|
|
|
|
|
|
/* if the device needs this changing, it may do so in the
|
|
|
|
* slave_configure function */
|
|
|
|
sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some low level driver could use device->type
|
|
|
|
*/
|
|
|
|
sdev->type = -1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Assume that the device will have handshaking problems,
|
|
|
|
* and then fix this field later if it turns out it
|
|
|
|
* doesn't
|
|
|
|
*/
|
|
|
|
sdev->borken = 1;
|
|
|
|
|
2021-07-29 06:48:44 +00:00
|
|
|
sdev->sg_reserved_size = INT_MAX;
|
|
|
|
|
2021-06-22 02:46:54 +00:00
|
|
|
q = blk_mq_init_queue(&sdev->host->tag_set);
|
|
|
|
if (IS_ERR(q)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* release fn is set up in scsi_sysfs_device_initialise, so
|
|
|
|
* have to free and put manually here */
|
|
|
|
put_device(&starget->dev);
|
2006-03-09 15:21:27 +00:00
|
|
|
kfree(sdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2021-06-22 02:46:54 +00:00
|
|
|
sdev->request_queue = q;
|
|
|
|
q->queuedata = sdev;
|
|
|
|
__scsi_init_queue(sdev->host, q);
|
|
|
|
WARN_ON_ONCE(!blk_get_queue(q));
|
2014-11-03 13:09:02 +00:00
|
|
|
|
2021-01-22 02:33:17 +00:00
|
|
|
depth = sdev->host->cmd_per_lun ?: 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Use .can_queue as budget map's depth because we have to
|
|
|
|
* support adjusting queue depth from sysfs. Meantime use
|
|
|
|
* default device queue depth to figure out sbitmap shift
|
|
|
|
* since we use this queue depth most of times.
|
|
|
|
*/
|
2022-01-27 15:37:33 +00:00
|
|
|
if (scsi_realloc_sdev_budget_map(sdev, depth)) {
|
2021-01-22 02:33:17 +00:00
|
|
|
put_device(&starget->dev);
|
|
|
|
kfree(sdev);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
scsi_change_queue_depth(sdev, depth);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
scsi_sysfs_device_initialize(sdev);
|
|
|
|
|
|
|
|
if (shost->hostt->slave_alloc) {
|
|
|
|
ret = shost->hostt->slave_alloc(sdev);
|
|
|
|
if (ret) {
|
|
|
|
/*
|
|
|
|
* if LLDD reports slave not present, don't clutter
|
|
|
|
* console with alloc failure messages
|
|
|
|
*/
|
|
|
|
if (ret == -ENXIO)
|
|
|
|
display_failure_msg = 0;
|
|
|
|
goto out_device_destroy;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return sdev;
|
|
|
|
|
|
|
|
out_device_destroy:
|
2011-11-07 14:51:24 +00:00
|
|
|
__scsi_remove_device(sdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
out:
|
|
|
|
if (display_failure_msg)
|
2008-07-04 06:47:27 +00:00
|
|
|
printk(ALLOC_FAILURE_MSG, __func__);
|
2005-04-16 22:20:36 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-03-23 03:42:27 +00:00
|
|
|
static void scsi_target_destroy(struct scsi_target *starget)
|
|
|
|
{
|
|
|
|
struct device *dev = &starget->dev;
|
|
|
|
struct Scsi_Host *shost = dev_to_shost(dev->parent);
|
|
|
|
unsigned long flags;
|
|
|
|
|
2016-04-05 09:50:44 +00:00
|
|
|
BUG_ON(starget->state == STARGET_DEL);
|
2014-01-21 15:01:41 +00:00
|
|
|
starget->state = STARGET_DEL;
|
2008-03-23 03:42:27 +00:00
|
|
|
transport_destroy_device(dev);
|
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
|
|
|
if (shost->hostt->target_destroy)
|
|
|
|
shost->hostt->target_destroy(starget);
|
|
|
|
list_del_init(&starget->siblings);
|
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
put_device(dev);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static void scsi_target_dev_release(struct device *dev)
|
|
|
|
{
|
|
|
|
struct device *parent = dev->parent;
|
|
|
|
struct scsi_target *starget = to_scsi_target(dev);
|
2005-05-24 17:06:38 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(starget);
|
|
|
|
put_device(parent);
|
|
|
|
}
|
|
|
|
|
2008-07-04 06:47:33 +00:00
|
|
|
static struct device_type scsi_target_type = {
|
2008-03-18 13:32:28 +00:00
|
|
|
.name = "scsi_target",
|
|
|
|
.release = scsi_target_dev_release,
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
int scsi_is_target_device(const struct device *dev)
|
|
|
|
{
|
2008-03-18 13:32:28 +00:00
|
|
|
return dev->type == &scsi_target_type;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_is_target_device);
|
|
|
|
|
|
|
|
static struct scsi_target *__scsi_find_target(struct device *parent,
|
|
|
|
int channel, uint id)
|
|
|
|
{
|
|
|
|
struct scsi_target *starget, *found_starget = NULL;
|
|
|
|
struct Scsi_Host *shost = dev_to_shost(parent);
|
|
|
|
/*
|
|
|
|
* Search for an existing target for this sdev.
|
|
|
|
*/
|
|
|
|
list_for_each_entry(starget, &shost->__targets, siblings) {
|
|
|
|
if (starget->id == id &&
|
|
|
|
starget->channel == channel) {
|
|
|
|
found_starget = starget;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (found_starget)
|
|
|
|
get_device(&found_starget->dev);
|
|
|
|
|
|
|
|
return found_starget;
|
|
|
|
}
|
|
|
|
|
2014-01-21 15:00:50 +00:00
|
|
|
/**
|
|
|
|
* scsi_target_reap_ref_release - remove target from visibility
|
|
|
|
* @kref: the reap_ref in the target being released
|
|
|
|
*
|
|
|
|
* Called on last put of reap_ref, which is the indication that no device
|
|
|
|
* under this target is visible anymore, so render the target invisible in
|
|
|
|
* sysfs. Note: we have to be in user context here because the target reaps
|
|
|
|
* should be done in places where the scsi device visibility is being removed.
|
|
|
|
*/
|
|
|
|
static void scsi_target_reap_ref_release(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct scsi_target *starget
|
|
|
|
= container_of(kref, struct scsi_target, reap_ref);
|
|
|
|
|
2014-01-21 15:01:41 +00:00
|
|
|
/*
|
2017-06-27 18:55:58 +00:00
|
|
|
* if we get here and the target is still in a CREATED state that
|
2014-01-21 15:01:41 +00:00
|
|
|
* means it was allocated but never made visible (because a scan
|
|
|
|
* turned up no LUNs), so don't call device_del() on it.
|
|
|
|
*/
|
2017-06-27 18:55:58 +00:00
|
|
|
if ((starget->state != STARGET_CREATED) &&
|
|
|
|
(starget->state != STARGET_CREATED_REMOVE)) {
|
2014-01-21 15:01:41 +00:00
|
|
|
transport_remove_device(&starget->dev);
|
|
|
|
device_del(&starget->dev);
|
|
|
|
}
|
2014-01-21 15:00:50 +00:00
|
|
|
scsi_target_destroy(starget);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void scsi_target_reap_ref_put(struct scsi_target *starget)
|
|
|
|
{
|
|
|
|
kref_put(&starget->reap_ref, scsi_target_reap_ref_release);
|
|
|
|
}
|
|
|
|
|
2006-09-05 21:26:41 +00:00
|
|
|
/**
|
|
|
|
* scsi_alloc_target - allocate a new or find an existing target
|
|
|
|
* @parent: parent of the target (need not be a scsi host)
|
|
|
|
* @channel: target channel number (zero if no channels)
|
|
|
|
* @id: target id number
|
|
|
|
*
|
|
|
|
* Return an existing target if one exists, provided it hasn't already
|
|
|
|
* gone into STARGET_DEL state, otherwise allocate a new target.
|
|
|
|
*
|
|
|
|
* The target is returned with an incremented reference, so the caller
|
|
|
|
* is responsible for both reaping and doing a last put
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
static struct scsi_target *scsi_alloc_target(struct device *parent,
|
|
|
|
int channel, uint id)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = dev_to_shost(parent);
|
|
|
|
struct device *dev = NULL;
|
|
|
|
unsigned long flags;
|
|
|
|
const int size = sizeof(struct scsi_target)
|
|
|
|
+ shost->transportt->target_size;
|
2005-06-11 02:24:30 +00:00
|
|
|
struct scsi_target *starget;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct scsi_target *found_target;
|
2014-01-21 15:00:50 +00:00
|
|
|
int error, ref_got;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-16 15:31:18 +00:00
|
|
|
starget = kzalloc(size, GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!starget) {
|
2008-07-04 06:47:27 +00:00
|
|
|
printk(KERN_ERR "%s: allocation failure\n", __func__);
|
2005-04-16 22:20:36 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
dev = &starget->dev;
|
|
|
|
device_initialize(dev);
|
2014-01-21 15:00:50 +00:00
|
|
|
kref_init(&starget->reap_ref);
|
2005-04-16 22:20:36 +00:00
|
|
|
dev->parent = get_device(parent);
|
2008-12-03 21:41:36 +00:00
|
|
|
dev_set_name(dev, "target%d:%d:%d", shost->host_no, channel, id);
|
2008-03-18 13:32:28 +00:00
|
|
|
dev->bus = &scsi_bus_type;
|
|
|
|
dev->type = &scsi_target_type;
|
2021-10-06 21:54:51 +00:00
|
|
|
scsi_enable_async_suspend(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
starget->id = id;
|
|
|
|
starget->channel = channel;
|
[SCSI] Add helper code so transport classes/driver can control queueing (v3)
SCSI-ml manages the queueing limits for the device and host, but
does not do so at the target level. However something something similar
can come in userful when a driver is transitioning a transport object to
the the blocked state, becuase at that time we do not want to queue
io and we do not want the queuecommand to be called again.
The patch adds code similar to the exisiting SCSI_ML_*BUSY handlers.
You can now return SCSI_MLQUEUE_TARGET_BUSY when we hit
a transport level queueing issue like the hw cannot allocate some
resource at the iscsi session/connection level, or the target has temporarily
closed or shrunk the queueing window, or if we are transitioning
to the blocked state.
bnx2i, when they rework their firmware according to netdev
developers requests, will also need to be able to limit queueing at this
level. bnx2i will hook into libiscsi, but will allocate a scsi host per
netdevice/hba, so unlike pure software iscsi/iser which is allocating
a host per session, it cannot set the scsi_host->can_queue and return
SCSI_MLQUEUE_HOST_BUSY to reflect queueing limits on the transport.
The iscsi class/driver can also set a scsi_target->can_queue value which
reflects the max commands the driver/class can support. For iscsi this
reflects the number of commands we can support for each session due to
session/connection hw limits, driver limits, and to also reflect the
session/targets's queueing window.
Changes:
v1 - initial patch.
v2 - Fix scsi_run_queue handling of multiple blocked targets.
Previously we would break from the main loop if a device was added back on
the starved list. We now run over the list and check if any target is
blocked.
v3 - Rediff for scsi-misc.
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
2008-08-17 20:24:38 +00:00
|
|
|
starget->can_queue = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
INIT_LIST_HEAD(&starget->siblings);
|
|
|
|
INIT_LIST_HEAD(&starget->devices);
|
2008-03-23 03:42:27 +00:00
|
|
|
starget->state = STARGET_CREATED;
|
2007-01-08 16:12:32 +00:00
|
|
|
starget->scsi_level = SCSI_2;
|
2009-04-09 17:02:22 +00:00
|
|
|
starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED;
|
2006-02-23 20:27:18 +00:00
|
|
|
retry:
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
|
|
|
|
|
|
|
found_target = __scsi_find_target(parent, channel, id);
|
|
|
|
if (found_target)
|
|
|
|
goto found;
|
|
|
|
|
|
|
|
list_add_tail(&starget->siblings, &shost->__targets);
|
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
/* allocate and add */
|
2005-05-24 17:06:38 +00:00
|
|
|
transport_setup_device(dev);
|
|
|
|
if (shost->hostt->target_alloc) {
|
2006-02-22 20:28:24 +00:00
|
|
|
error = shost->hostt->target_alloc(starget);
|
2005-05-24 17:06:38 +00:00
|
|
|
|
|
|
|
if(error) {
|
2021-07-26 11:54:02 +00:00
|
|
|
if (error != -ENXIO)
|
|
|
|
dev_err(dev, "target allocation failed, error %d\n", error);
|
2005-05-24 17:06:38 +00:00
|
|
|
/* don't want scsi_target_reap to do the final
|
|
|
|
* put because it will be under the host lock */
|
2008-03-23 03:42:27 +00:00
|
|
|
scsi_target_destroy(starget);
|
2005-05-24 17:06:38 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
2006-09-05 21:26:41 +00:00
|
|
|
get_device(dev);
|
2005-05-24 17:06:38 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return starget;
|
|
|
|
|
|
|
|
found:
|
2014-01-21 15:00:50 +00:00
|
|
|
/*
|
|
|
|
* release routine already fired if kref is zero, so if we can still
|
|
|
|
* take the reference, the target must be alive. If we can't, it must
|
|
|
|
* be dying and we need to wait for a new target
|
|
|
|
*/
|
|
|
|
ref_got = kref_get_unless_zero(&found_target->reap_ref);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
2014-01-21 15:00:50 +00:00
|
|
|
if (ref_got) {
|
2010-03-18 19:41:22 +00:00
|
|
|
put_device(dev);
|
2006-02-23 20:27:18 +00:00
|
|
|
return found_target;
|
|
|
|
}
|
2014-01-21 15:00:50 +00:00
|
|
|
/*
|
|
|
|
* Unfortunately, we found a dying target; need to wait until it's
|
|
|
|
* dead before we can get a new one. There is an anomaly here. We
|
|
|
|
* *should* call scsi_target_reap() to balance the kref_get() of the
|
|
|
|
* reap_ref above. However, since the target being released, it's
|
|
|
|
* already invisible and the reap_ref is irrelevant. If we call
|
|
|
|
* scsi_target_reap() we might spuriously do another device_del() on
|
|
|
|
* an already invisible target.
|
|
|
|
*/
|
2006-02-23 20:27:18 +00:00
|
|
|
put_device(&found_target->dev);
|
2014-01-21 15:00:50 +00:00
|
|
|
/*
|
|
|
|
* length of time is irrelevant here, we just want to yield the CPU
|
|
|
|
* for a tick to avoid busy waiting for the target to die.
|
|
|
|
*/
|
|
|
|
msleep(1);
|
2006-02-23 20:27:18 +00:00
|
|
|
goto retry;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_target_reap - check to see if target is in use and destroy if not
|
|
|
|
* @starget: target to be checked
|
|
|
|
*
|
|
|
|
* This is used after removing a LUN or doing a last put of the target
|
|
|
|
* it checks atomically that nothing is using the target and removes
|
|
|
|
* it if so.
|
|
|
|
*/
|
|
|
|
void scsi_target_reap(struct scsi_target *starget)
|
|
|
|
{
|
2014-01-21 15:01:41 +00:00
|
|
|
/*
|
|
|
|
* serious problem if this triggers: STARGET_DEL is only set in the if
|
|
|
|
* the reap_ref drops to zero, so we're trying to do another final put
|
|
|
|
* on an already released kref
|
|
|
|
*/
|
2014-01-21 15:00:50 +00:00
|
|
|
BUG_ON(starget->state == STARGET_DEL);
|
2014-01-21 15:01:41 +00:00
|
|
|
scsi_target_reap_ref_put(starget);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-08-21 19:53:25 +00:00
|
|
|
/**
|
2016-01-28 02:16:26 +00:00
|
|
|
* scsi_sanitize_inquiry_string - remove non-graphical chars from an
|
|
|
|
* INQUIRY result string
|
2006-08-21 19:53:25 +00:00
|
|
|
* @s: INQUIRY result string to sanitize
|
|
|
|
* @len: length of the string
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* The SCSI spec says that INQUIRY vendor, product, and revision
|
|
|
|
* strings must consist entirely of graphic ASCII characters,
|
|
|
|
* padded on the right with spaces. Since not all devices obey
|
|
|
|
* this rule, we will replace non-graphic or non-ASCII characters
|
|
|
|
* with spaces. Exception: a NUL character is interpreted as a
|
|
|
|
* string terminator, so all the following characters are set to
|
|
|
|
* spaces.
|
|
|
|
**/
|
2016-01-28 02:16:26 +00:00
|
|
|
void scsi_sanitize_inquiry_string(unsigned char *s, int len)
|
2006-08-21 19:53:25 +00:00
|
|
|
{
|
|
|
|
int terminated = 0;
|
|
|
|
|
|
|
|
for (; len > 0; (--len, ++s)) {
|
|
|
|
if (*s == 0)
|
|
|
|
terminated = 1;
|
|
|
|
if (terminated || *s < 0x20 || *s > 0x7e)
|
|
|
|
*s = ' ';
|
|
|
|
}
|
|
|
|
}
|
2016-01-28 02:16:26 +00:00
|
|
|
EXPORT_SYMBOL(scsi_sanitize_inquiry_string);
|
2006-08-21 19:53:25 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* scsi_probe_lun - probe a single LUN using a SCSI INQUIRY
|
2005-06-15 23:48:29 +00:00
|
|
|
* @sdev: scsi_device to probe
|
2005-04-16 22:20:36 +00:00
|
|
|
* @inq_result: area to store the INQUIRY result
|
2005-06-15 23:48:29 +00:00
|
|
|
* @result_len: len of inq_result
|
2005-04-16 22:20:36 +00:00
|
|
|
* @bflags: store any bflags found here
|
|
|
|
*
|
|
|
|
* Description:
|
2005-06-15 23:48:29 +00:00
|
|
|
* Probe the lun associated with @req using a standard SCSI INQUIRY;
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2005-06-15 23:48:29 +00:00
|
|
|
* If the INQUIRY is successful, zero is returned and the
|
2005-04-16 22:20:36 +00:00
|
|
|
* INQUIRY data is in @inq_result; the scsi_level and INQUIRY length
|
2005-10-31 17:32:08 +00:00
|
|
|
* are copied to the scsi_device any flags value is stored in *@bflags.
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2006-08-21 19:53:25 +00:00
|
|
|
static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
|
2017-11-15 11:07:30 +00:00
|
|
|
int result_len, blist_flags_t *bflags)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned char scsi_cmd[MAX_COMMAND_SIZE];
|
|
|
|
int first_inquiry_len, try_inquiry_len, next_inquiry_len;
|
|
|
|
int response_len = 0;
|
2005-06-15 23:48:29 +00:00
|
|
|
int pass, count, result;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct scsi_sense_hdr sshdr;
|
|
|
|
|
|
|
|
*bflags = 0;
|
|
|
|
|
|
|
|
/* Perform up to 3 passes. The first pass uses a conservative
|
|
|
|
* transfer length of 36 unless sdev->inquiry_len specifies a
|
|
|
|
* different value. */
|
|
|
|
first_inquiry_len = sdev->inquiry_len ? sdev->inquiry_len : 36;
|
|
|
|
try_inquiry_len = first_inquiry_len;
|
|
|
|
pass = 1;
|
|
|
|
|
|
|
|
next_pass:
|
2005-10-02 16:45:08 +00:00
|
|
|
SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
|
|
|
|
"scsi scan: INQUIRY pass %d length %d\n",
|
|
|
|
pass, try_inquiry_len));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Each pass gets up to three chances to ignore Unit Attention */
|
|
|
|
for (count = 0; count < 3; ++count) {
|
2008-12-05 02:21:46 +00:00
|
|
|
int resid;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
memset(scsi_cmd, 0, 6);
|
|
|
|
scsi_cmd[0] = INQUIRY;
|
|
|
|
scsi_cmd[4] = (unsigned char) try_inquiry_len;
|
|
|
|
|
|
|
|
memset(inq_result, 0, try_inquiry_len);
|
2005-06-15 23:48:29 +00:00
|
|
|
|
|
|
|
result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
|
2005-08-28 16:33:52 +00:00
|
|
|
inq_result, try_inquiry_len, &sshdr,
|
2008-12-04 05:24:39 +00:00
|
|
|
HZ / 2 + HZ * scsi_inq_timeout, 3,
|
2008-12-05 02:21:46 +00:00
|
|
|
&resid);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-25 14:39:59 +00:00
|
|
|
SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
|
|
|
|
"scsi scan: INQUIRY %s with code 0x%x\n",
|
2005-06-15 23:48:29 +00:00
|
|
|
result ? "failed" : "successful", result));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-04-27 08:30:12 +00:00
|
|
|
if (result > 0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* not-ready to ready transition [asc/ascq=0x28/0x0]
|
|
|
|
* or power-on, reset [asc/ascq=0x29/0x0], continue.
|
|
|
|
* INQUIRY should not yield UNIT_ATTENTION
|
|
|
|
* but many buggy devices do so anyway.
|
|
|
|
*/
|
2021-04-27 08:30:15 +00:00
|
|
|
if (scsi_status_is_check_condition(result) &&
|
2005-08-28 16:33:52 +00:00
|
|
|
scsi_sense_valid(&sshdr)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if ((sshdr.sense_key == UNIT_ATTENTION) &&
|
|
|
|
((sshdr.asc == 0x28) ||
|
|
|
|
(sshdr.asc == 0x29)) &&
|
|
|
|
(sshdr.ascq == 0))
|
|
|
|
continue;
|
|
|
|
}
|
2021-04-27 08:30:12 +00:00
|
|
|
} else if (result == 0) {
|
2008-12-05 02:21:46 +00:00
|
|
|
/*
|
|
|
|
* if nothing was transferred, we try
|
|
|
|
* again. It's a workaround for some USB
|
|
|
|
* devices.
|
|
|
|
*/
|
|
|
|
if (resid == try_inquiry_len)
|
|
|
|
continue;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-06-15 23:48:29 +00:00
|
|
|
if (result == 0) {
|
2016-01-28 02:16:26 +00:00
|
|
|
scsi_sanitize_inquiry_string(&inq_result[8], 8);
|
|
|
|
scsi_sanitize_inquiry_string(&inq_result[16], 16);
|
|
|
|
scsi_sanitize_inquiry_string(&inq_result[32], 4);
|
2006-08-21 19:53:25 +00:00
|
|
|
|
|
|
|
response_len = inq_result[4] + 5;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (response_len > 255)
|
|
|
|
response_len = first_inquiry_len; /* sanity */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get any flags for this device.
|
|
|
|
*
|
2005-10-31 17:32:08 +00:00
|
|
|
* XXX add a bflags to scsi_device, and replace the
|
|
|
|
* corresponding bit fields in scsi_device, so bflags
|
2005-04-16 22:20:36 +00:00
|
|
|
* need not be passed as an argument.
|
|
|
|
*/
|
|
|
|
*bflags = scsi_get_device_flags(sdev, &inq_result[8],
|
|
|
|
&inq_result[16]);
|
|
|
|
|
|
|
|
/* When the first pass succeeds we gain information about
|
|
|
|
* what larger transfer lengths might work. */
|
|
|
|
if (pass == 1) {
|
|
|
|
if (BLIST_INQUIRY_36 & *bflags)
|
|
|
|
next_inquiry_len = 36;
|
|
|
|
else if (sdev->inquiry_len)
|
|
|
|
next_inquiry_len = sdev->inquiry_len;
|
|
|
|
else
|
|
|
|
next_inquiry_len = response_len;
|
|
|
|
|
|
|
|
/* If more data is available perform the second pass */
|
|
|
|
if (next_inquiry_len > try_inquiry_len) {
|
|
|
|
try_inquiry_len = next_inquiry_len;
|
|
|
|
pass = 2;
|
|
|
|
goto next_pass;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (pass == 2) {
|
2014-06-25 14:39:59 +00:00
|
|
|
sdev_printk(KERN_INFO, sdev,
|
|
|
|
"scsi scan: %d byte inquiry failed. "
|
|
|
|
"Consider BLIST_INQUIRY_36 for this device\n",
|
|
|
|
try_inquiry_len);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* If this pass failed, the third pass goes back and transfers
|
|
|
|
* the same amount as we successfully got in the first pass. */
|
|
|
|
try_inquiry_len = first_inquiry_len;
|
|
|
|
pass = 3;
|
|
|
|
goto next_pass;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the last transfer attempt got an error, assume the
|
|
|
|
* peripheral doesn't exist or is dead. */
|
2005-06-15 23:48:29 +00:00
|
|
|
if (result)
|
|
|
|
return -EIO;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Don't report any more data than the device says is valid */
|
|
|
|
sdev->inquiry_len = min(try_inquiry_len, response_len);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX Abort if the response length is less than 36? If less than
|
|
|
|
* 32, the lookup of the device flags (above) could be invalid,
|
|
|
|
* and it would be possible to take an incorrect action - we do
|
|
|
|
* not want to hang because of a short INQUIRY. On the flip side,
|
|
|
|
* if the device is spun down or becoming ready (and so it gives a
|
|
|
|
* short INQUIRY), an abort here prevents any further use of the
|
|
|
|
* device, including spin up.
|
|
|
|
*
|
2007-02-16 09:46:38 +00:00
|
|
|
* On the whole, the best approach seems to be to assume the first
|
|
|
|
* 36 bytes are valid no matter what the device says. That's
|
|
|
|
* better than copying < 36 bytes to the inquiry-result buffer
|
|
|
|
* and displaying garbage for the Vendor, Product, or Revision
|
|
|
|
* strings.
|
|
|
|
*/
|
|
|
|
if (sdev->inquiry_len < 36) {
|
2015-11-19 13:17:06 +00:00
|
|
|
if (!sdev->host->short_inquiry) {
|
|
|
|
shost_printk(KERN_INFO, sdev->host,
|
|
|
|
"scsi scan: INQUIRY result too short (%d),"
|
|
|
|
" using 36\n", sdev->inquiry_len);
|
|
|
|
sdev->host->short_inquiry = 1;
|
|
|
|
}
|
2007-02-16 09:46:38 +00:00
|
|
|
sdev->inquiry_len = 36;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Related to the above issue:
|
|
|
|
*
|
|
|
|
* XXX Devices (disk or all?) should be sent a TEST UNIT READY,
|
|
|
|
* and if not ready, sent a START_STOP to start (maybe spin up) and
|
|
|
|
* then send the INQUIRY again, since the INQUIRY can change after
|
|
|
|
* a device is initialized.
|
|
|
|
*
|
|
|
|
* Ideally, start a device if explicitly asked to do so. This
|
|
|
|
* assumes that a device is spun up on power on, spun down on
|
|
|
|
* request, and then spun up on request.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The scanning code needs to know the scsi_level, even if no
|
|
|
|
* device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so
|
|
|
|
* non-zero LUNs can be scanned.
|
|
|
|
*/
|
|
|
|
sdev->scsi_level = inq_result[2] & 0x07;
|
|
|
|
if (sdev->scsi_level >= 2 ||
|
|
|
|
(sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1))
|
|
|
|
sdev->scsi_level++;
|
2005-09-23 01:33:28 +00:00
|
|
|
sdev->sdev_target->scsi_level = sdev->scsi_level;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-09-02 15:35:50 +00:00
|
|
|
/*
|
|
|
|
* If SCSI-2 or lower, and if the transport requires it,
|
|
|
|
* store the LUN value in CDB[1].
|
|
|
|
*/
|
|
|
|
sdev->lun_in_cdb = 0;
|
|
|
|
if (sdev->scsi_level <= SCSI_2 &&
|
|
|
|
sdev->scsi_level != SCSI_UNKNOWN &&
|
|
|
|
!sdev->host->no_scsi2_lun_in_cdb)
|
|
|
|
sdev->lun_in_cdb = 1;
|
|
|
|
|
2005-06-15 23:48:29 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2005-10-31 17:32:08 +00:00
|
|
|
* scsi_add_lun - allocate and fully initialze a scsi_device
|
2007-07-11 18:54:55 +00:00
|
|
|
* @sdev: holds information to be stored in the new scsi_device
|
2005-04-16 22:20:36 +00:00
|
|
|
* @inq_result: holds the result of a previous INQUIRY to the LUN
|
|
|
|
* @bflags: black/white list flag
|
2007-07-11 18:54:55 +00:00
|
|
|
* @async: 1 if this device is being scanned asynchronously
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Description:
|
2007-07-11 18:54:55 +00:00
|
|
|
* Initialize the scsi_device @sdev. Optionally set fields based
|
|
|
|
* on values in *@bflags.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Return:
|
2005-10-31 17:32:08 +00:00
|
|
|
* SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
|
|
|
|
* SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2006-08-21 19:53:25 +00:00
|
|
|
static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
|
2017-12-12 18:23:28 +00:00
|
|
|
blist_flags_t *bflags, int async)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-08-22 21:53:31 +00:00
|
|
|
int ret;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* XXX do not save the inquiry, since it can change underneath us,
|
|
|
|
* save just vendor/model/rev.
|
|
|
|
*
|
|
|
|
* Rather than save it and have an ioctl that retrieves the saved
|
|
|
|
* value, have an ioctl that executes the same INQUIRY code used
|
|
|
|
* in scsi_probe_lun, let user level programs doing INQUIRY
|
|
|
|
* scanning run at their own risk, or supply a user level program
|
|
|
|
* that can correctly scan.
|
|
|
|
*/
|
2006-11-10 20:27:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy at least 36 bytes of INQUIRY data, so that we don't
|
|
|
|
* dereference unallocated memory when accessing the Vendor,
|
|
|
|
* Product, and Revision strings. Badly behaved devices may set
|
|
|
|
* the INQUIRY Additional Length byte to a small value, indicating
|
|
|
|
* these strings are invalid, but often they contain plausible data
|
|
|
|
* nonetheless. It doesn't matter if the device sent < 36 bytes
|
|
|
|
* total, since scsi_probe_lun() initializes inq_result with 0s.
|
|
|
|
*/
|
|
|
|
sdev->inquiry = kmemdup(inq_result,
|
|
|
|
max_t(size_t, sdev->inquiry_len, 36),
|
scsi: core: replace GFP_ATOMIC with GFP_KERNEL in scsi_scan.c
We had a test-report where, under memory pressure, adding LUNs to the
systems would fail (the tests add LUNs strictly in sequence):
[ 5525.853432] scsi 0:0:1:1088045124: Direct-Access IBM 2107900 .148 PQ: 0 ANSI: 5
[ 5525.853826] scsi 0:0:1:1088045124: alua: supports implicit TPGS
[ 5525.853830] scsi 0:0:1:1088045124: alua: device naa.6005076303ffd32700000000000044da port group 0 rel port 43
[ 5525.853931] sd 0:0:1:1088045124: Attached scsi generic sg10 type 0
[ 5525.854075] sd 0:0:1:1088045124: [sdk] Disabling DIF Type 1 protection
[ 5525.855495] sd 0:0:1:1088045124: [sdk] 2097152 512-byte logical blocks: (1.07 GB/1.00 GiB)
[ 5525.855606] sd 0:0:1:1088045124: [sdk] Write Protect is off
[ 5525.855609] sd 0:0:1:1088045124: [sdk] Mode Sense: ed 00 00 08
[ 5525.855795] sd 0:0:1:1088045124: [sdk] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
[ 5525.857838] sdk: sdk1
[ 5525.859468] sd 0:0:1:1088045124: [sdk] Attached SCSI disk
[ 5525.865073] sd 0:0:1:1088045124: alua: transition timeout set to 60 seconds
[ 5525.865078] sd 0:0:1:1088045124: alua: port group 00 state A preferred supports tolusnA
[ 5526.015070] sd 0:0:1:1088045124: alua: port group 00 state A preferred supports tolusnA
[ 5526.015213] sd 0:0:1:1088045124: alua: port group 00 state A preferred supports tolusnA
[ 5526.587439] scsi_alloc_sdev: Allocation failure during SCSI scanning, some SCSI devices might not be configured
[ 5526.588562] scsi_alloc_sdev: Allocation failure during SCSI scanning, some SCSI devices might not be configured
Looking at the code of scsi_alloc_sdev(), and all the calling contexts,
there seems to be no reason to use GFP_ATMOIC here. All the different
call-contexts use a mutex at some point, and nothing in between that
requires no sleeping, as far as I could see. Additionally, the code that
later allocates the block queue for the device (scsi_mq_alloc_queue())
already uses GFP_KERNEL.
There are similar allocations in two other functions:
scsi_probe_and_add_lun(), and scsi_add_lun(),; that can also be done with
GFP_KERNEL.
Here is the contexts for the three functions so far:
scsi_alloc_sdev()
scsi_probe_and_add_lun()
scsi_sequential_lun_scan()
__scsi_scan_target()
scsi_scan_target()
mutex_lock()
scsi_scan_channel()
scsi_scan_host_selected()
mutex_lock()
scsi_report_lun_scan()
__scsi_scan_target()
...
__scsi_add_device()
mutex_lock()
__scsi_scan_target()
...
scsi_report_lun_scan()
...
scsi_get_host_dev()
mutex_lock()
scsi_probe_and_add_lun()
...
scsi_add_lun()
scsi_probe_and_add_lun()
...
So replace all these, and give them a bit of a better chance to succeed,
with more chances of reclaim.
Signed-off-by: Benjamin Block <bblock@linux.ibm.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2019-02-21 09:18:00 +00:00
|
|
|
GFP_KERNEL);
|
2006-11-10 20:27:57 +00:00
|
|
|
if (sdev->inquiry == NULL)
|
2005-04-16 22:20:36 +00:00
|
|
|
return SCSI_SCAN_NO_RESPONSE;
|
|
|
|
|
|
|
|
sdev->vendor = (char *) (sdev->inquiry + 8);
|
|
|
|
sdev->model = (char *) (sdev->inquiry + 16);
|
|
|
|
sdev->rev = (char *) (sdev->inquiry + 32);
|
|
|
|
|
2012-07-25 19:55:55 +00:00
|
|
|
if (strncmp(sdev->vendor, "ATA ", 8) == 0) {
|
|
|
|
/*
|
|
|
|
* sata emulation layer device. This is a hack to work around
|
|
|
|
* the SATL power management specifications which state that
|
|
|
|
* when the SATL detects the device has gone into standby
|
|
|
|
* mode, it shall respond with NOT READY.
|
|
|
|
*/
|
|
|
|
sdev->allow_restart = 1;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (*bflags & BLIST_ISROM) {
|
2007-07-11 18:54:55 +00:00
|
|
|
sdev->type = TYPE_ROM;
|
|
|
|
sdev->removable = 1;
|
|
|
|
} else {
|
|
|
|
sdev->type = (inq_result[0] & 0x1f);
|
|
|
|
sdev->removable = (inq_result[1] & 0x80) >> 7;
|
2014-09-25 12:32:19 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* some devices may respond with wrong type for
|
|
|
|
* well-known logical units. Force well-known type
|
|
|
|
* to enumerate them correctly.
|
|
|
|
*/
|
|
|
|
if (scsi_is_wlun(sdev->lun) && sdev->type != TYPE_WLUN) {
|
|
|
|
sdev_printk(KERN_WARNING, sdev,
|
|
|
|
"%s: correcting incorrect peripheral device type 0x%x for W-LUN 0x%16xhN\n",
|
|
|
|
__func__, sdev->type, (unsigned int)sdev->lun);
|
|
|
|
sdev->type = TYPE_WLUN;
|
|
|
|
}
|
|
|
|
|
2007-07-11 18:54:55 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-11 18:54:55 +00:00
|
|
|
if (sdev->type == TYPE_RBC || sdev->type == TYPE_ROM) {
|
|
|
|
/* RBC and MMC devices can return SCSI-3 compliance and yet
|
|
|
|
* still not support REPORT LUNS, so make them act as
|
|
|
|
* BLIST_NOREPORTLUN unless BLIST_REPORTLUN2 is
|
|
|
|
* specifically set */
|
|
|
|
if ((*bflags & BLIST_REPORTLUN2) == 0)
|
|
|
|
*bflags |= BLIST_NOREPORTLUN;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* For a peripheral qualifier (PQ) value of 1 (001b), the SCSI
|
|
|
|
* spec says: The device server is capable of supporting the
|
|
|
|
* specified peripheral device type on this logical unit. However,
|
|
|
|
* the physical device is not currently connected to this logical
|
|
|
|
* unit.
|
|
|
|
*
|
|
|
|
* The above is vague, as it implies that we could treat 001 and
|
|
|
|
* 011 the same. Stay compatible with previous code, and create a
|
2005-10-31 17:32:08 +00:00
|
|
|
* scsi_device for a PQ of 1
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Don't set the device offline here; rather let the upper
|
|
|
|
* level drivers eval the PQ to decide whether they should
|
|
|
|
* attach. So remove ((inq_result[0] >> 5) & 7) == 1 check.
|
|
|
|
*/
|
|
|
|
|
|
|
|
sdev->inq_periph_qual = (inq_result[0] >> 5) & 7;
|
|
|
|
sdev->lockable = sdev->removable;
|
|
|
|
sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2);
|
|
|
|
|
2007-07-11 18:54:55 +00:00
|
|
|
if (sdev->scsi_level >= SCSI_3 ||
|
|
|
|
(sdev->inquiry_len > 56 && inq_result[56] & 0x04))
|
2005-04-16 22:20:36 +00:00
|
|
|
sdev->ppr = 1;
|
|
|
|
if (inq_result[7] & 0x60)
|
|
|
|
sdev->wdtr = 1;
|
|
|
|
if (inq_result[7] & 0x10)
|
|
|
|
sdev->sdtr = 1;
|
|
|
|
|
2006-08-06 23:15:22 +00:00
|
|
|
sdev_printk(KERN_NOTICE, sdev, "%s %.8s %.16s %.4s PQ: %d "
|
2006-07-04 18:15:20 +00:00
|
|
|
"ANSI: %d%s\n", scsi_device_type(sdev->type),
|
|
|
|
sdev->vendor, sdev->model, sdev->rev,
|
|
|
|
sdev->inq_periph_qual, inq_result[2] & 0x07,
|
|
|
|
(inq_result[3] & 0x0f) == 1 ? " CCS" : "");
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&
|
2014-11-03 19:15:14 +00:00
|
|
|
!(*bflags & BLIST_NOTQ)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
sdev->tagged_supported = 1;
|
2014-11-03 19:15:14 +00:00
|
|
|
sdev->simple_tags = 1;
|
|
|
|
}
|
2007-07-11 18:54:55 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Some devices (Texel CD ROM drives) have handshaking problems
|
|
|
|
* when used with the Seagate controllers. borken is initialized
|
|
|
|
* to 1, and then set it to 0 here.
|
|
|
|
*/
|
|
|
|
if ((*bflags & BLIST_BORKEN) == 0)
|
|
|
|
sdev->borken = 0;
|
|
|
|
|
2007-07-11 18:54:55 +00:00
|
|
|
if (*bflags & BLIST_NO_ULD_ATTACH)
|
|
|
|
sdev->no_uld_attach = 1;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Apparently some really broken devices (contrary to the SCSI
|
|
|
|
* standards) need to be selected without asserting ATN
|
|
|
|
*/
|
|
|
|
if (*bflags & BLIST_SELECT_NO_ATN)
|
|
|
|
sdev->select_no_atn = 1;
|
|
|
|
|
2006-04-01 02:07:45 +00:00
|
|
|
/*
|
|
|
|
* Maximum 512 sector transfer length
|
|
|
|
* broken RA4x00 Compaq Disk Array
|
|
|
|
*/
|
|
|
|
if (*bflags & BLIST_MAX_512)
|
2010-02-26 05:20:38 +00:00
|
|
|
blk_queue_max_hw_sectors(sdev->request_queue, 512);
|
2015-04-21 03:42:24 +00:00
|
|
|
/*
|
|
|
|
* Max 1024 sector transfer length for targets that report incorrect
|
|
|
|
* max/optimal lengths and relied on the old block layer safe default
|
|
|
|
*/
|
|
|
|
else if (*bflags & BLIST_MAX_1024)
|
|
|
|
blk_queue_max_hw_sectors(sdev->request_queue, 1024);
|
2006-04-01 02:07:45 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Some devices may not want to have a start command automatically
|
|
|
|
* issued when a device is added.
|
|
|
|
*/
|
|
|
|
if (*bflags & BLIST_NOSTARTONADD)
|
|
|
|
sdev->no_start_on_add = 1;
|
|
|
|
|
|
|
|
if (*bflags & BLIST_SINGLELUN)
|
2007-11-12 15:00:44 +00:00
|
|
|
scsi_target(sdev)->single_lun = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
sdev->use_10_for_rw = 1;
|
|
|
|
|
2014-07-24 13:48:46 +00:00
|
|
|
/* some devices don't like REPORT SUPPORTED OPERATION CODES
|
|
|
|
* and will simply timeout causing sd_mod init to take a very
|
|
|
|
* very long time */
|
|
|
|
if (*bflags & BLIST_NO_RSOC)
|
|
|
|
sdev->no_report_opcodes = 1;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* set the device running here so that slave configure
|
|
|
|
* may do I/O */
|
2017-06-02 21:21:55 +00:00
|
|
|
mutex_lock(&sdev->state_mutex);
|
2008-08-22 21:53:31 +00:00
|
|
|
ret = scsi_device_set_state(sdev, SDEV_RUNNING);
|
2017-06-02 21:21:55 +00:00
|
|
|
if (ret)
|
2008-08-22 21:53:31 +00:00
|
|
|
ret = scsi_device_set_state(sdev, SDEV_BLOCK);
|
2017-06-02 21:21:55 +00:00
|
|
|
mutex_unlock(&sdev->state_mutex);
|
2008-08-22 21:53:31 +00:00
|
|
|
|
2017-06-02 21:21:55 +00:00
|
|
|
if (ret) {
|
|
|
|
sdev_printk(KERN_ERR, sdev,
|
|
|
|
"in wrong state %s to complete scan\n",
|
|
|
|
scsi_device_state_name(sdev->sdev_state));
|
|
|
|
return SCSI_SCAN_NO_RESPONSE;
|
2008-08-22 21:53:31 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (*bflags & BLIST_NOT_LOCKABLE)
|
|
|
|
sdev->lockable = 0;
|
|
|
|
|
|
|
|
if (*bflags & BLIST_RETRY_HWERROR)
|
|
|
|
sdev->retry_hwerror = 1;
|
|
|
|
|
2012-08-28 18:29:35 +00:00
|
|
|
if (*bflags & BLIST_NO_DIF)
|
|
|
|
sdev->no_dif = 1;
|
|
|
|
|
2017-09-28 01:35:12 +00:00
|
|
|
if (*bflags & BLIST_UNMAP_LIMIT_WS)
|
|
|
|
sdev->unmap_limit_for_ws = 1;
|
|
|
|
|
2021-07-04 07:54:01 +00:00
|
|
|
if (*bflags & BLIST_IGN_MEDIA_CHANGE)
|
|
|
|
sdev->ignore_media_change = 1;
|
|
|
|
|
2013-05-10 14:36:04 +00:00
|
|
|
sdev->eh_timeout = SCSI_DEFAULT_EH_TIMEOUT;
|
|
|
|
|
2014-07-15 16:49:17 +00:00
|
|
|
if (*bflags & BLIST_TRY_VPD_PAGES)
|
|
|
|
sdev->try_vpd_pages = 1;
|
|
|
|
else if (*bflags & BLIST_SKIP_VPD_PAGES)
|
2013-04-25 01:19:47 +00:00
|
|
|
sdev->skip_vpd_pages = 1;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
transport_configure_device(&sdev->sdev_gendev);
|
|
|
|
|
2006-02-17 11:11:29 +00:00
|
|
|
if (sdev->host->hostt->slave_configure) {
|
2008-08-22 21:53:31 +00:00
|
|
|
ret = sdev->host->hostt->slave_configure(sdev);
|
2006-02-17 11:11:29 +00:00
|
|
|
if (ret) {
|
|
|
|
/*
|
|
|
|
* if LLDD reports slave not present, don't clutter
|
|
|
|
* console with alloc failure messages
|
|
|
|
*/
|
|
|
|
if (ret != -ENXIO) {
|
|
|
|
sdev_printk(KERN_ERR, sdev,
|
|
|
|
"failed to configure device\n");
|
|
|
|
}
|
|
|
|
return SCSI_SCAN_NO_RESPONSE;
|
|
|
|
}
|
2022-01-27 15:37:33 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The queue_depth is often changed in ->slave_configure.
|
|
|
|
* Set up budget map again since memory consumption of
|
|
|
|
* the map depends on actual queue depth.
|
|
|
|
*/
|
|
|
|
scsi_realloc_sdev_budget_map(sdev, sdev->queue_depth);
|
2006-02-17 11:11:29 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-03-15 08:51:49 +00:00
|
|
|
if (sdev->scsi_level >= SCSI_3)
|
|
|
|
scsi_attach_vpd(sdev);
|
|
|
|
|
2009-10-22 22:46:33 +00:00
|
|
|
sdev->max_queue_depth = sdev->queue_depth;
|
2021-01-22 02:33:17 +00:00
|
|
|
WARN_ON_ONCE(sdev->max_queue_depth > sdev->budget_map.depth);
|
2017-10-02 14:26:34 +00:00
|
|
|
sdev->sdev_bflags = *bflags;
|
2009-10-22 22:46:33 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Ok, the device is now all set up, we can
|
|
|
|
* register it and tell the rest of the kernel
|
|
|
|
* about it.
|
|
|
|
*/
|
2006-09-28 21:19:20 +00:00
|
|
|
if (!async && scsi_sysfs_add_sdev(sdev) != 0)
|
2005-07-27 18:43:46 +00:00
|
|
|
return SCSI_SCAN_NO_RESPONSE;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return SCSI_SCAN_LUN_PRESENT;
|
|
|
|
}
|
|
|
|
|
2006-04-15 07:30:24 +00:00
|
|
|
#ifdef CONFIG_SCSI_LOGGING
|
2006-04-03 13:18:35 +00:00
|
|
|
/**
|
2007-11-03 18:30:39 +00:00
|
|
|
* scsi_inq_str - print INQUIRY data from min to max index, strip trailing whitespace
|
2006-04-03 13:18:35 +00:00
|
|
|
* @buf: Output buffer with at least end-first+1 bytes of space
|
|
|
|
* @inq: Inquiry buffer (input)
|
|
|
|
* @first: Offset of string into inq
|
|
|
|
* @end: Index after last character in inq
|
|
|
|
*/
|
2006-04-15 07:30:24 +00:00
|
|
|
static unsigned char *scsi_inq_str(unsigned char *buf, unsigned char *inq,
|
2006-04-03 13:18:35 +00:00
|
|
|
unsigned first, unsigned end)
|
|
|
|
{
|
|
|
|
unsigned term = 0, idx;
|
2006-04-15 07:30:24 +00:00
|
|
|
|
|
|
|
for (idx = 0; idx + first < end && idx + first < inq[4] + 5; idx++) {
|
|
|
|
if (inq[idx+first] > ' ') {
|
2006-04-03 13:18:35 +00:00
|
|
|
buf[idx] = inq[idx+first];
|
|
|
|
term = idx+1;
|
|
|
|
} else {
|
|
|
|
buf[idx] = ' ';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
buf[term] = 0;
|
|
|
|
return buf;
|
|
|
|
}
|
2006-04-15 07:30:24 +00:00
|
|
|
#endif
|
2005-09-23 01:33:28 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* scsi_probe_and_add_lun - probe a LUN, if a LUN is found add it
|
|
|
|
* @starget: pointer to target device structure
|
|
|
|
* @lun: LUN of target device
|
|
|
|
* @bflagsp: store bflags here if not NULL
|
2007-11-03 18:30:39 +00:00
|
|
|
* @sdevp: probe the LUN corresponding to this scsi_device
|
2016-03-17 07:39:45 +00:00
|
|
|
* @rescan: if not equal to SCSI_SCAN_INITIAL skip some code only
|
|
|
|
* needed on first scan
|
2007-11-03 18:30:39 +00:00
|
|
|
* @hostdata: passed to scsi_alloc_sdev()
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Call scsi_probe_lun, if a LUN with an attached device is found,
|
|
|
|
* allocate and set it up by calling scsi_add_lun.
|
|
|
|
*
|
|
|
|
* Return:
|
2017-05-12 13:04:14 +00:00
|
|
|
*
|
|
|
|
* - SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
|
|
|
|
* - SCSI_SCAN_TARGET_PRESENT: target responded, but no device is
|
2005-04-16 22:20:36 +00:00
|
|
|
* attached at the LUN
|
2017-05-12 13:04:14 +00:00
|
|
|
* - SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
|
|
|
static int scsi_probe_and_add_lun(struct scsi_target *starget,
|
2017-12-12 18:23:28 +00:00
|
|
|
u64 lun, blist_flags_t *bflagsp,
|
2016-03-17 07:39:45 +00:00
|
|
|
struct scsi_device **sdevp,
|
|
|
|
enum scsi_scan_mode rescan,
|
2005-04-16 22:20:36 +00:00
|
|
|
void *hostdata)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev;
|
|
|
|
unsigned char *result;
|
2017-12-12 18:23:28 +00:00
|
|
|
blist_flags_t bflags;
|
|
|
|
int res = SCSI_SCAN_NO_RESPONSE, result_len = 256;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The rescan flag is used as an optimization, the first scan of a
|
|
|
|
* host adapter calls into here with rescan == 0.
|
|
|
|
*/
|
2005-09-23 01:33:28 +00:00
|
|
|
sdev = scsi_device_lookup_by_target(starget, lun);
|
|
|
|
if (sdev) {
|
2016-03-17 07:39:45 +00:00
|
|
|
if (rescan != SCSI_SCAN_INITIAL || !scsi_device_created(sdev)) {
|
2014-06-25 14:39:59 +00:00
|
|
|
SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
|
2005-04-16 22:20:36 +00:00
|
|
|
"scsi scan: device exists on %s\n",
|
2008-12-03 21:41:36 +00:00
|
|
|
dev_name(&sdev->sdev_gendev)));
|
2005-04-16 22:20:36 +00:00
|
|
|
if (sdevp)
|
|
|
|
*sdevp = sdev;
|
|
|
|
else
|
|
|
|
scsi_device_put(sdev);
|
|
|
|
|
|
|
|
if (bflagsp)
|
|
|
|
*bflagsp = scsi_get_device_flags(sdev,
|
|
|
|
sdev->vendor,
|
|
|
|
sdev->model);
|
|
|
|
return SCSI_SCAN_LUN_PRESENT;
|
|
|
|
}
|
2005-09-23 01:33:28 +00:00
|
|
|
scsi_device_put(sdev);
|
|
|
|
} else
|
|
|
|
sdev = scsi_alloc_sdev(starget, lun, hostdata);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!sdev)
|
|
|
|
goto out;
|
2005-06-15 23:48:29 +00:00
|
|
|
|
2021-03-31 07:29:58 +00:00
|
|
|
result = kmalloc(result_len, GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!result)
|
2005-06-15 23:48:29 +00:00
|
|
|
goto out_free_sdev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-15 23:48:29 +00:00
|
|
|
if (scsi_probe_lun(sdev, result, result_len, &bflags))
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_free_result;
|
|
|
|
|
2006-04-03 13:16:48 +00:00
|
|
|
if (bflagsp)
|
|
|
|
*bflagsp = bflags;
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* result contains valid SCSI INQUIRY data.
|
|
|
|
*/
|
2017-06-19 12:27:23 +00:00
|
|
|
if ((result[0] >> 5) == 3) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* For a Peripheral qualifier 3 (011b), the SCSI
|
|
|
|
* spec says: The device server is not capable of
|
|
|
|
* supporting a physical device on this logical
|
|
|
|
* unit.
|
|
|
|
*
|
|
|
|
* For disks, this implies that there is no
|
|
|
|
* logical disk configured at sdev->lun, but there
|
|
|
|
* is a target id responding.
|
|
|
|
*/
|
2006-04-03 13:18:35 +00:00
|
|
|
SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:"
|
|
|
|
" peripheral qualifier of 3, device not"
|
|
|
|
" added\n"))
|
|
|
|
if (lun == 0) {
|
2006-04-15 07:30:24 +00:00
|
|
|
SCSI_LOG_SCAN_BUS(1, {
|
|
|
|
unsigned char vend[9];
|
|
|
|
unsigned char mod[17];
|
|
|
|
|
|
|
|
sdev_printk(KERN_INFO, sdev,
|
2006-04-03 13:18:35 +00:00
|
|
|
"scsi scan: consider passing scsi_mod."
|
2007-01-09 01:28:54 +00:00
|
|
|
"dev_flags=%s:%s:0x240 or 0x1000240\n",
|
2006-04-03 13:18:35 +00:00
|
|
|
scsi_inq_str(vend, result, 8, 16),
|
2006-04-15 07:30:24 +00:00
|
|
|
scsi_inq_str(mod, result, 16, 32));
|
|
|
|
});
|
2008-03-23 03:42:27 +00:00
|
|
|
|
2006-04-03 13:18:35 +00:00
|
|
|
}
|
2008-03-23 03:42:27 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
res = SCSI_SCAN_TARGET_PRESENT;
|
|
|
|
goto out_free_result;
|
|
|
|
}
|
|
|
|
|
2006-02-09 20:26:18 +00:00
|
|
|
/*
|
2006-08-09 18:56:32 +00:00
|
|
|
* Some targets may set slight variations of PQ and PDT to signal
|
|
|
|
* that no LUN is present, so don't add sdev in these cases.
|
|
|
|
* Two specific examples are:
|
|
|
|
* 1) NetApp targets: return PQ=1, PDT=0x1f
|
2019-04-15 05:20:31 +00:00
|
|
|
* 2) IBM/2145 targets: return PQ=1, PDT=0
|
|
|
|
* 3) USB UFI: returns PDT=0x1f, with the PQ bits being "reserved"
|
2006-08-09 18:56:32 +00:00
|
|
|
* in the UFI 1.0 spec (we cannot rely on reserved bits).
|
|
|
|
*
|
|
|
|
* References:
|
|
|
|
* 1) SCSI SPC-3, pp. 145-146
|
|
|
|
* PQ=1: "A peripheral device having the specified peripheral
|
|
|
|
* device type is not connected to this logical unit. However, the
|
|
|
|
* device server is capable of supporting the specified peripheral
|
|
|
|
* device type on this logical unit."
|
|
|
|
* PDT=0x1f: "Unknown or no device type"
|
|
|
|
* 2) USB UFI 1.0, p. 20
|
|
|
|
* PDT=00h Direct-access device (floppy)
|
|
|
|
* PDT=1Fh none (no FDD connected to the requested logical unit)
|
2006-02-09 20:26:18 +00:00
|
|
|
*/
|
2019-04-15 05:20:31 +00:00
|
|
|
if (((result[0] >> 5) == 1 ||
|
|
|
|
(starget->pdt_1f_for_no_lun && (result[0] & 0x1f) == 0x1f)) &&
|
2008-08-21 20:14:14 +00:00
|
|
|
!scsi_is_wlun(lun)) {
|
2014-06-25 14:39:59 +00:00
|
|
|
SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
|
2006-02-09 20:26:18 +00:00
|
|
|
"scsi scan: peripheral device type"
|
|
|
|
" of 31, no device added\n"));
|
|
|
|
res = SCSI_SCAN_TARGET_PRESENT;
|
|
|
|
goto out_free_result;
|
|
|
|
}
|
|
|
|
|
2006-09-28 21:19:20 +00:00
|
|
|
res = scsi_add_lun(sdev, result, &bflags, shost->async_scan);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (res == SCSI_SCAN_LUN_PRESENT) {
|
|
|
|
if (bflags & BLIST_KEY) {
|
|
|
|
sdev->lockable = 0;
|
2005-06-15 23:48:29 +00:00
|
|
|
scsi_unlock_floptical(sdev, result);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out_free_result:
|
|
|
|
kfree(result);
|
|
|
|
out_free_sdev:
|
|
|
|
if (res == SCSI_SCAN_LUN_PRESENT) {
|
|
|
|
if (sdevp) {
|
2005-07-26 14:30:40 +00:00
|
|
|
if (scsi_device_get(sdev) == 0) {
|
|
|
|
*sdevp = sdev;
|
|
|
|
} else {
|
|
|
|
__scsi_remove_device(sdev);
|
|
|
|
res = SCSI_SCAN_NO_RESPONSE;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-09-23 01:33:28 +00:00
|
|
|
} else
|
2009-11-19 22:48:29 +00:00
|
|
|
__scsi_remove_device(sdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
out:
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_sequential_lun_scan - sequentially scan a SCSI target
|
|
|
|
* @starget: pointer to target structure to scan
|
|
|
|
* @bflags: black/white list flag for LUN 0
|
2007-11-03 18:30:39 +00:00
|
|
|
* @scsi_level: Which version of the standard does this device adhere to
|
|
|
|
* @rescan: passed to scsi_probe_add_lun()
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Generally, scan from LUN 1 (LUN 0 is assumed to already have been
|
|
|
|
* scanned) to some maximum lun until a LUN is found with no device
|
|
|
|
* attached. Use the bflags to figure out any oddities.
|
|
|
|
*
|
|
|
|
* Modifies sdevscan->lun.
|
|
|
|
**/
|
|
|
|
static void scsi_sequential_lun_scan(struct scsi_target *starget,
|
2017-12-12 18:23:28 +00:00
|
|
|
blist_flags_t bflags, int scsi_level,
|
2016-03-17 07:39:45 +00:00
|
|
|
enum scsi_scan_mode rescan)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-06-25 13:27:36 +00:00
|
|
|
uint max_dev_lun;
|
|
|
|
u64 sparse_lun, lun;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
|
|
|
|
|
2014-06-25 14:39:59 +00:00
|
|
|
SCSI_LOG_SCAN_BUS(3, starget_printk(KERN_INFO, starget,
|
|
|
|
"scsi scan: Sequential scan\n"));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
max_dev_lun = min(max_scsi_luns, shost->max_lun);
|
|
|
|
/*
|
|
|
|
* If this device is known to support sparse multiple units,
|
|
|
|
* override the other settings, and scan all of them. Normally,
|
|
|
|
* SCSI-3 devices should be scanned via the REPORT LUNS.
|
|
|
|
*/
|
|
|
|
if (bflags & BLIST_SPARSELUN) {
|
|
|
|
max_dev_lun = shost->max_lun;
|
|
|
|
sparse_lun = 1;
|
|
|
|
} else
|
|
|
|
sparse_lun = 0;
|
|
|
|
|
|
|
|
/*
|
2014-10-09 11:39:40 +00:00
|
|
|
* If less than SCSI_1_CCS, and no special lun scanning, stop
|
2005-04-16 22:20:36 +00:00
|
|
|
* scanning; this matches 2.4 behaviour, but could just be a bug
|
2014-10-09 11:39:40 +00:00
|
|
|
* (to continue scanning a SCSI_1_CCS device).
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* This test is broken. We might not have any device on lun0 for
|
|
|
|
* a sparselun device, and if that's the case then how would we
|
|
|
|
* know the real scsi_level, eh? It might make sense to just not
|
|
|
|
* scan any SCSI_1 device for non-0 luns, but that check would best
|
|
|
|
* go into scsi_alloc_sdev() and just have it return null when asked
|
|
|
|
* to alloc an sdev for lun > 0 on an already found SCSI_1 device.
|
|
|
|
*
|
|
|
|
if ((sdevscan->scsi_level < SCSI_1_CCS) &&
|
|
|
|
((bflags & (BLIST_FORCELUN | BLIST_SPARSELUN | BLIST_MAX5LUN))
|
|
|
|
== 0))
|
|
|
|
return;
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* If this device is known to support multiple units, override
|
|
|
|
* the other settings, and scan all of them.
|
|
|
|
*/
|
|
|
|
if (bflags & BLIST_FORCELUN)
|
|
|
|
max_dev_lun = shost->max_lun;
|
|
|
|
/*
|
|
|
|
* REGAL CDC-4X: avoid hang after LUN 4
|
|
|
|
*/
|
|
|
|
if (bflags & BLIST_MAX5LUN)
|
|
|
|
max_dev_lun = min(5U, max_dev_lun);
|
|
|
|
/*
|
|
|
|
* Do not scan SCSI-2 or lower device past LUN 7, unless
|
|
|
|
* BLIST_LARGELUN.
|
|
|
|
*/
|
|
|
|
if (scsi_level < SCSI_3 && !(bflags & BLIST_LARGELUN))
|
|
|
|
max_dev_lun = min(8U, max_dev_lun);
|
2017-06-19 12:27:23 +00:00
|
|
|
else
|
2014-06-03 08:58:53 +00:00
|
|
|
max_dev_lun = min(256U, max_dev_lun);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* We have already scanned LUN 0, so start at LUN 1. Keep scanning
|
|
|
|
* until we reach the max, or no LUN is found and we are not
|
|
|
|
* sparse_lun.
|
|
|
|
*/
|
|
|
|
for (lun = 1; lun < max_dev_lun; ++lun)
|
|
|
|
if ((scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan,
|
|
|
|
NULL) != SCSI_SCAN_LUN_PRESENT) &&
|
|
|
|
!sparse_lun)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_report_lun_scan - Scan using SCSI REPORT LUN results
|
2007-11-03 18:30:39 +00:00
|
|
|
* @starget: which target
|
|
|
|
* @bflags: Zero or a mix of BLIST_NOLUN, BLIST_REPORTLUN2, or BLIST_NOREPORTLUN
|
|
|
|
* @rescan: nonzero if we can skip code only needed on first scan
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Description:
|
2007-11-03 18:30:39 +00:00
|
|
|
* Fast scanning for modern (SCSI-3) devices by sending a REPORT LUN command.
|
|
|
|
* Scan the resulting list of LUNs by calling scsi_probe_and_add_lun.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2007-11-03 18:30:39 +00:00
|
|
|
* If BLINK_REPORTLUN2 is set, scan a target that supports more than 8
|
|
|
|
* LUNs even if it's older than SCSI-3.
|
|
|
|
* If BLIST_NOREPORTLUN is set, return 1 always.
|
|
|
|
* If BLIST_NOLUN is set, return 0 always.
|
2012-01-10 18:43:30 +00:00
|
|
|
* If starget->no_report_luns is set, return 1 always.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Return:
|
|
|
|
* 0: scan completed (or no memory, so further scanning is futile)
|
2007-11-03 18:30:39 +00:00
|
|
|
* 1: could not scan with REPORT LUN
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2017-12-12 18:23:28 +00:00
|
|
|
static int scsi_report_lun_scan(struct scsi_target *starget, blist_flags_t bflags,
|
2016-03-17 07:39:45 +00:00
|
|
|
enum scsi_scan_mode rescan)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned char scsi_cmd[MAX_COMMAND_SIZE];
|
|
|
|
unsigned int length;
|
2014-06-25 13:27:36 +00:00
|
|
|
u64 lun;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int num_luns;
|
|
|
|
unsigned int retries;
|
2005-06-15 23:48:29 +00:00
|
|
|
int result;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct scsi_lun *lunp, *lun_data;
|
|
|
|
struct scsi_sense_hdr sshdr;
|
2005-09-23 01:33:28 +00:00
|
|
|
struct scsi_device *sdev;
|
|
|
|
struct Scsi_Host *shost = dev_to_shost(&starget->dev);
|
2005-11-08 20:51:55 +00:00
|
|
|
int ret = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Only support SCSI-3 and up devices if BLIST_NOREPORTLUN is not set.
|
|
|
|
* Also allow SCSI-2 if BLIST_REPORTLUN2 is set and host adapter does
|
|
|
|
* support more than 8 LUNs.
|
2012-01-10 18:43:30 +00:00
|
|
|
* Don't attempt if the target doesn't support REPORT LUNS.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2006-04-01 02:07:45 +00:00
|
|
|
if (bflags & BLIST_NOREPORTLUN)
|
|
|
|
return 1;
|
|
|
|
if (starget->scsi_level < SCSI_2 &&
|
|
|
|
starget->scsi_level != SCSI_UNKNOWN)
|
|
|
|
return 1;
|
|
|
|
if (starget->scsi_level < SCSI_3 &&
|
|
|
|
(!(bflags & BLIST_REPORTLUN2) || shost->max_lun <= 8))
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
|
|
|
if (bflags & BLIST_NOLUN)
|
|
|
|
return 0;
|
2012-01-10 18:43:30 +00:00
|
|
|
if (starget->no_report_luns)
|
|
|
|
return 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-09-23 01:33:28 +00:00
|
|
|
if (!(sdev = scsi_device_lookup_by_target(starget, 0))) {
|
|
|
|
sdev = scsi_alloc_sdev(starget, 0, NULL);
|
|
|
|
if (!sdev)
|
|
|
|
return 0;
|
2010-02-12 17:13:31 +00:00
|
|
|
if (scsi_device_get(sdev)) {
|
|
|
|
__scsi_remove_device(sdev);
|
2005-09-23 01:33:28 +00:00
|
|
|
return 0;
|
2010-02-12 17:13:31 +00:00
|
|
|
}
|
2005-09-23 01:33:28 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Allocate enough to hold the header (the same size as one scsi_lun)
|
2014-12-16 16:01:20 +00:00
|
|
|
* plus the number of luns we are requesting. 511 was the default
|
|
|
|
* value of the now removed max_report_luns parameter.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2014-12-16 16:01:20 +00:00
|
|
|
length = (511 + 1) * sizeof(struct scsi_lun);
|
|
|
|
retry:
|
2021-03-31 07:29:58 +00:00
|
|
|
lun_data = kmalloc(length, GFP_KERNEL);
|
2005-09-23 01:33:28 +00:00
|
|
|
if (!lun_data) {
|
2008-07-04 06:47:27 +00:00
|
|
|
printk(ALLOC_FAILURE_MSG, __func__);
|
2005-06-15 23:48:29 +00:00
|
|
|
goto out;
|
2005-09-23 01:33:28 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
scsi_cmd[0] = REPORT_LUNS;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bytes 1 - 5: reserved, set to zero.
|
|
|
|
*/
|
|
|
|
memset(&scsi_cmd[1], 0, 5);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bytes 6 - 9: length of the command.
|
|
|
|
*/
|
2014-12-16 16:01:19 +00:00
|
|
|
put_unaligned_be32(length, &scsi_cmd[6]);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
scsi_cmd[10] = 0; /* reserved */
|
|
|
|
scsi_cmd[11] = 0; /* control */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can get a UNIT ATTENTION, for example a power on/reset, so
|
|
|
|
* retry a few times (like sd.c does for TEST UNIT READY).
|
|
|
|
* Experience shows some combinations of adapter/devices get at
|
|
|
|
* least two power on/resets.
|
|
|
|
*
|
|
|
|
* Illegal requests (for devices that do not support REPORT LUNS)
|
|
|
|
* should come through as a check condition, and will not generate
|
|
|
|
* a retry.
|
|
|
|
*/
|
|
|
|
for (retries = 0; retries < 3; retries++) {
|
2014-06-25 14:39:59 +00:00
|
|
|
SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
|
|
|
|
"scsi scan: Sending REPORT LUNS to (try %d)\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
retries));
|
2005-06-15 23:48:29 +00:00
|
|
|
|
|
|
|
result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
|
2005-08-28 16:33:52 +00:00
|
|
|
lun_data, length, &sshdr,
|
2015-09-04 19:47:06 +00:00
|
|
|
SCSI_REPORT_LUNS_TIMEOUT, 3, NULL);
|
2005-06-15 23:48:29 +00:00
|
|
|
|
2014-06-25 14:39:59 +00:00
|
|
|
SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
|
|
|
|
"scsi scan: REPORT LUNS"
|
|
|
|
" %s (try %d) result 0x%x\n",
|
|
|
|
result ? "failed" : "successful",
|
|
|
|
retries, result));
|
2005-06-15 23:48:29 +00:00
|
|
|
if (result == 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2005-08-28 16:33:52 +00:00
|
|
|
else if (scsi_sense_valid(&sshdr)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (sshdr.sense_key != UNIT_ATTENTION)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-15 23:48:29 +00:00
|
|
|
if (result) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The device probably does not support a REPORT LUN command
|
|
|
|
*/
|
2005-11-08 20:51:55 +00:00
|
|
|
ret = 1;
|
|
|
|
goto out_err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the length from the first four bytes of lun_data.
|
|
|
|
*/
|
2014-12-16 16:01:20 +00:00
|
|
|
if (get_unaligned_be32(lun_data->scsi_lun) +
|
|
|
|
sizeof(struct scsi_lun) > length) {
|
|
|
|
length = get_unaligned_be32(lun_data->scsi_lun) +
|
|
|
|
sizeof(struct scsi_lun);
|
|
|
|
kfree(lun_data);
|
|
|
|
goto retry;
|
|
|
|
}
|
2014-12-16 16:01:19 +00:00
|
|
|
length = get_unaligned_be32(lun_data->scsi_lun);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
num_luns = (length / sizeof(struct scsi_lun));
|
|
|
|
|
2005-10-24 22:04:06 +00:00
|
|
|
SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
|
|
|
|
"scsi scan: REPORT LUN scan\n"));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Scan the luns in lun_data. The entry at offset 0 is really
|
|
|
|
* the header, so start at 1 and go up to and including num_luns.
|
|
|
|
*/
|
|
|
|
for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++) {
|
|
|
|
lun = scsilun_to_int(lunp);
|
|
|
|
|
2014-06-25 13:27:36 +00:00
|
|
|
if (lun > sdev->host->max_lun) {
|
2014-06-25 14:39:59 +00:00
|
|
|
sdev_printk(KERN_WARNING, sdev,
|
|
|
|
"lun%llu has a LUN larger than"
|
|
|
|
" allowed by the host adapter\n", lun);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
int res;
|
|
|
|
|
|
|
|
res = scsi_probe_and_add_lun(starget,
|
|
|
|
lun, NULL, NULL, rescan, NULL);
|
|
|
|
if (res == SCSI_SCAN_NO_RESPONSE) {
|
|
|
|
/*
|
|
|
|
* Got some results, but now none, abort.
|
|
|
|
*/
|
2005-10-24 22:04:06 +00:00
|
|
|
sdev_printk(KERN_ERR, sdev,
|
|
|
|
"Unexpected response"
|
2014-06-25 13:27:36 +00:00
|
|
|
" from lun %llu while scanning, scan"
|
|
|
|
" aborted\n", (unsigned long long)lun);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-08 20:51:55 +00:00
|
|
|
out_err:
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(lun_data);
|
|
|
|
out:
|
2008-08-22 21:43:59 +00:00
|
|
|
if (scsi_device_created(sdev))
|
2005-09-23 01:33:28 +00:00
|
|
|
/*
|
|
|
|
* the sdev we used didn't appear in the report luns scan
|
|
|
|
*/
|
2009-11-19 22:48:29 +00:00
|
|
|
__scsi_remove_device(sdev);
|
scsi: Fix use-after-free
This patch fixes one use-after-free report[1] by KASAN.
In __scsi_scan_target(), when a type 31 device is probed,
SCSI_SCAN_TARGET_PRESENT is returned and the target will be scanned
again.
Inside the following scsi_report_lun_scan(), one new scsi_device
instance is allocated, and scsi_probe_and_add_lun() is called again to
probe the target and still see type 31 device, finally
__scsi_remove_device() is called to remove & free the device at the end
of scsi_probe_and_add_lun(), so cause use-after-free in
scsi_report_lun_scan().
And the following SCSI log can be observed:
scsi 0:0:2:0: scsi scan: INQUIRY pass 1 length 36
scsi 0:0:2:0: scsi scan: INQUIRY successful with code 0x0
scsi 0:0:2:0: scsi scan: peripheral device type of 31, no device added
scsi 0:0:2:0: scsi scan: Sending REPORT LUNS to (try 0)
scsi 0:0:2:0: scsi scan: REPORT LUNS successful (try 0) result 0x0
scsi 0:0:2:0: scsi scan: REPORT LUN scan
scsi 0:0:2:0: scsi scan: INQUIRY pass 1 length 36
scsi 0:0:2:0: scsi scan: INQUIRY successful with code 0x0
scsi 0:0:2:0: scsi scan: peripheral device type of 31, no device added
BUG: KASAN: use-after-free in __scsi_scan_target+0xbf8/0xe40 at addr ffff88007b44a104
This patch fixes the issue by moving the putting reference at
the end of scsi_report_lun_scan().
[1] KASAN report
==================================================================
[ 3.274597] PM: Adding info for serio:serio1
[ 3.275127] BUG: KASAN: use-after-free in __scsi_scan_target+0xd87/0xdf0 at addr ffff880254d8c304
[ 3.275653] Read of size 4 by task kworker/u10:0/27
[ 3.275903] CPU: 3 PID: 27 Comm: kworker/u10:0 Not tainted 4.8.0 #2121
[ 3.276258] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS Ubuntu-1.8.2-1ubuntu1 04/01/2014
[ 3.276797] Workqueue: events_unbound async_run_entry_fn
[ 3.277083] ffff880254d8c380 ffff880259a37870 ffffffff94bbc6c1 ffff880078402d80
[ 3.277532] ffff880254d8bb80 ffff880259a37898 ffffffff9459fec1 ffff880259a37930
[ 3.277989] ffff880254d8bb80 ffff880078402d80 ffff880259a37920 ffffffff945a0165
[ 3.278436] Call Trace:
[ 3.278528] [<ffffffff94bbc6c1>] dump_stack+0x65/0x84
[ 3.278797] [<ffffffff9459fec1>] kasan_object_err+0x21/0x70
[ 3.279063] device: 'psaux': device_add
[ 3.279616] [<ffffffff945a0165>] kasan_report_error+0x205/0x500
[ 3.279651] PM: Adding info for No Bus:psaux
[ 3.280202] [<ffffffff944ecd22>] ? kfree_const+0x22/0x30
[ 3.280486] [<ffffffff94bc2dc9>] ? kobject_release+0x119/0x370
[ 3.280805] [<ffffffff945a0543>] __asan_report_load4_noabort+0x43/0x50
[ 3.281170] [<ffffffff9507e1f7>] ? __scsi_scan_target+0xd87/0xdf0
[ 3.281506] [<ffffffff9507e1f7>] __scsi_scan_target+0xd87/0xdf0
[ 3.281848] [<ffffffff9507d470>] ? scsi_add_device+0x30/0x30
[ 3.282156] [<ffffffff94f7f660>] ? pm_runtime_autosuspend_expiration+0x60/0x60
[ 3.282570] [<ffffffff956ddb07>] ? _raw_spin_lock+0x17/0x40
[ 3.282880] [<ffffffff9507e505>] scsi_scan_channel+0x105/0x160
[ 3.283200] [<ffffffff9507e8a2>] scsi_scan_host_selected+0x212/0x2f0
[ 3.283563] [<ffffffff9507eb3c>] do_scsi_scan_host+0x1bc/0x250
[ 3.283882] [<ffffffff9507efc1>] do_scan_async+0x41/0x450
[ 3.284173] [<ffffffff941c1fee>] async_run_entry_fn+0xfe/0x610
[ 3.284492] [<ffffffff941a8954>] ? pwq_dec_nr_in_flight+0x124/0x2a0
[ 3.284876] [<ffffffff941d1770>] ? preempt_count_add+0x130/0x160
[ 3.285207] [<ffffffff941a9a84>] process_one_work+0x544/0x12d0
[ 3.285526] [<ffffffff941aa8e9>] worker_thread+0xd9/0x12f0
[ 3.285844] [<ffffffff941aa810>] ? process_one_work+0x12d0/0x12d0
[ 3.286182] [<ffffffff941bb365>] kthread+0x1c5/0x260
[ 3.286443] [<ffffffff940855cd>] ? __switch_to+0x88d/0x1430
[ 3.286745] [<ffffffff941bb1a0>] ? kthread_worker_fn+0x5a0/0x5a0
[ 3.287085] [<ffffffff956dde9f>] ret_from_fork+0x1f/0x40
[ 3.287368] [<ffffffff941bb1a0>] ? kthread_worker_fn+0x5a0/0x5a0
[ 3.287697] Object at ffff880254d8bb80, in cache kmalloc-2048 size: 2048
[ 3.288064] Allocated:
[ 3.288147] PID = 27
[ 3.288218] [<ffffffff940b27ab>] save_stack_trace+0x2b/0x50
[ 3.288531] [<ffffffff9459f246>] save_stack+0x46/0xd0
[ 3.288806] [<ffffffff9459f4bd>] kasan_kmalloc+0xad/0xe0
[ 3.289098] [<ffffffff9459c07e>] __kmalloc+0x13e/0x250
[ 3.289378] [<ffffffff95078e5a>] scsi_alloc_sdev+0xea/0xcf0
[ 3.289701] [<ffffffff9507de76>] __scsi_scan_target+0xa06/0xdf0
[ 3.290034] [<ffffffff9507e505>] scsi_scan_channel+0x105/0x160
[ 3.290362] [<ffffffff9507e8a2>] scsi_scan_host_selected+0x212/0x2f0
[ 3.290724] [<ffffffff9507eb3c>] do_scsi_scan_host+0x1bc/0x250
[ 3.291055] [<ffffffff9507efc1>] do_scan_async+0x41/0x450
[ 3.291354] [<ffffffff941c1fee>] async_run_entry_fn+0xfe/0x610
[ 3.291695] [<ffffffff941a9a84>] process_one_work+0x544/0x12d0
[ 3.292022] [<ffffffff941aa8e9>] worker_thread+0xd9/0x12f0
[ 3.292325] [<ffffffff941bb365>] kthread+0x1c5/0x260
[ 3.292594] [<ffffffff956dde9f>] ret_from_fork+0x1f/0x40
[ 3.292886] Freed:
[ 3.292945] PID = 27
[ 3.293016] [<ffffffff940b27ab>] save_stack_trace+0x2b/0x50
[ 3.293327] [<ffffffff9459f246>] save_stack+0x46/0xd0
[ 3.293600] [<ffffffff9459fa61>] kasan_slab_free+0x71/0xb0
[ 3.293916] [<ffffffff9459bac2>] kfree+0xa2/0x1f0
[ 3.294168] [<ffffffff9508158a>] scsi_device_dev_release_usercontext+0x50a/0x730
[ 3.294598] [<ffffffff941ace9a>] execute_in_process_context+0xda/0x130
[ 3.294974] [<ffffffff9508107c>] scsi_device_dev_release+0x1c/0x20
[ 3.295322] [<ffffffff94f566f6>] device_release+0x76/0x1e0
[ 3.295626] [<ffffffff94bc2db7>] kobject_release+0x107/0x370
[ 3.295942] [<ffffffff94bc29ce>] kobject_put+0x4e/0xa0
[ 3.296222] [<ffffffff94f56e17>] put_device+0x17/0x20
[ 3.296497] [<ffffffff9505201c>] scsi_device_put+0x7c/0xa0
[ 3.296801] [<ffffffff9507e1bc>] __scsi_scan_target+0xd4c/0xdf0
[ 3.297132] [<ffffffff9507e505>] scsi_scan_channel+0x105/0x160
[ 3.297458] [<ffffffff9507e8a2>] scsi_scan_host_selected+0x212/0x2f0
[ 3.297829] [<ffffffff9507eb3c>] do_scsi_scan_host+0x1bc/0x250
[ 3.298156] [<ffffffff9507efc1>] do_scan_async+0x41/0x450
[ 3.298453] [<ffffffff941c1fee>] async_run_entry_fn+0xfe/0x610
[ 3.298777] [<ffffffff941a9a84>] process_one_work+0x544/0x12d0
[ 3.299105] [<ffffffff941aa8e9>] worker_thread+0xd9/0x12f0
[ 3.299408] [<ffffffff941bb365>] kthread+0x1c5/0x260
[ 3.299676] [<ffffffff956dde9f>] ret_from_fork+0x1f/0x40
[ 3.299967] Memory state around the buggy address:
[ 3.300209] ffff880254d8c200: fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb
[ 3.300608] ffff880254d8c280: fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb
[ 3.300986] >ffff880254d8c300: fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb fb
[ 3.301408] ^
[ 3.301550] ffff880254d8c380: fc fc fc fc fc fc fc fc fc fc fc fc fc fc fc fc
[ 3.301987] ffff880254d8c400: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
[ 3.302396]
==================================================================
Cc: Christoph Hellwig <hch@lst.de>
Cc: stable@vger.kernel.org
Signed-off-by: Ming Lei <tom.leiming@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2016-10-09 05:23:27 +00:00
|
|
|
scsi_device_put(sdev);
|
2005-11-08 20:51:55 +00:00
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
|
2014-06-25 13:27:36 +00:00
|
|
|
uint id, u64 lun, void *hostdata)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-02-05 15:01:33 +00:00
|
|
|
struct scsi_device *sdev = ERR_PTR(-ENODEV);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct device *parent = &shost->shost_gendev;
|
2006-01-13 18:04:00 +00:00
|
|
|
struct scsi_target *starget;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-01-16 01:07:09 +00:00
|
|
|
if (strncmp(scsi_scan_type, "none", 4) == 0)
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
|
2006-01-13 18:04:00 +00:00
|
|
|
starget = scsi_alloc_target(parent, channel, id);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!starget)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
scsi_autopm_get_target(starget);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-11 12:16:10 +00:00
|
|
|
mutex_lock(&shost->scan_mutex);
|
2007-06-26 21:18:51 +00:00
|
|
|
if (!shost->async_scan)
|
|
|
|
scsi_complete_async_scans();
|
|
|
|
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
|
2006-02-05 15:01:33 +00:00
|
|
|
scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
scsi_autopm_put_host(shost);
|
|
|
|
}
|
2006-01-11 12:16:10 +00:00
|
|
|
mutex_unlock(&shost->scan_mutex);
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
scsi_autopm_put_target(starget);
|
2014-01-21 15:00:50 +00:00
|
|
|
/*
|
|
|
|
* paired with scsi_alloc_target(). Target will be destroyed unless
|
|
|
|
* scsi_probe_and_add_lun made an underlying device visible
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
scsi_target_reap(starget);
|
|
|
|
put_device(&starget->dev);
|
|
|
|
|
|
|
|
return sdev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__scsi_add_device);
|
|
|
|
|
2005-09-10 17:44:09 +00:00
|
|
|
int scsi_add_device(struct Scsi_Host *host, uint channel,
|
2014-06-25 13:27:36 +00:00
|
|
|
uint target, u64 lun)
|
2005-09-10 17:44:09 +00:00
|
|
|
{
|
|
|
|
struct scsi_device *sdev =
|
|
|
|
__scsi_add_device(host, channel, target, lun, NULL);
|
|
|
|
if (IS_ERR(sdev))
|
|
|
|
return PTR_ERR(sdev);
|
|
|
|
|
|
|
|
scsi_device_put(sdev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_add_device);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
void scsi_rescan_device(struct device *dev)
|
|
|
|
{
|
2016-02-19 08:17:16 +00:00
|
|
|
struct scsi_device *sdev = to_scsi_device(dev);
|
|
|
|
|
2015-02-02 13:01:24 +00:00
|
|
|
device_lock(dev);
|
2015-11-09 12:24:28 +00:00
|
|
|
|
2016-02-19 08:17:16 +00:00
|
|
|
scsi_attach_vpd(sdev);
|
|
|
|
|
|
|
|
if (sdev->handler && sdev->handler->rescan)
|
|
|
|
sdev->handler->rescan(sdev);
|
2015-11-09 12:24:28 +00:00
|
|
|
|
2015-02-02 13:01:24 +00:00
|
|
|
if (dev->driver && try_module_get(dev->driver->owner)) {
|
2014-11-12 17:34:51 +00:00
|
|
|
struct scsi_driver *drv = to_scsi_driver(dev->driver);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (drv->rescan)
|
|
|
|
drv->rescan(dev);
|
2014-11-12 17:34:51 +00:00
|
|
|
module_put(dev->driver->owner);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2015-02-02 13:01:24 +00:00
|
|
|
device_unlock(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_rescan_device);
|
|
|
|
|
2005-07-26 14:18:45 +00:00
|
|
|
static void __scsi_scan_target(struct device *parent, unsigned int channel,
|
2016-03-17 07:39:45 +00:00
|
|
|
unsigned int id, u64 lun, enum scsi_scan_mode rescan)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = dev_to_shost(parent);
|
2017-12-12 18:23:28 +00:00
|
|
|
blist_flags_t bflags = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
int res;
|
|
|
|
struct scsi_target *starget;
|
|
|
|
|
|
|
|
if (shost->this_id == id)
|
|
|
|
/*
|
|
|
|
* Don't scan the host adapter
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
|
|
|
|
starget = scsi_alloc_target(parent, channel, id);
|
|
|
|
if (!starget)
|
|
|
|
return;
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
scsi_autopm_get_target(starget);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (lun != SCAN_WILD_CARD) {
|
|
|
|
/*
|
|
|
|
* Scan for a specific host/chan/id/lun.
|
|
|
|
*/
|
|
|
|
scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL);
|
|
|
|
goto out_reap;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scan LUN 0, if there is some response, scan further. Ideally, we
|
|
|
|
* would not configure LUN 0 until all LUNs are scanned.
|
|
|
|
*/
|
2005-09-23 01:33:28 +00:00
|
|
|
res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL);
|
|
|
|
if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) {
|
|
|
|
if (scsi_report_lun_scan(starget, bflags, rescan) != 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The REPORT LUN did not scan the target,
|
|
|
|
* do a sequential scan.
|
|
|
|
*/
|
|
|
|
scsi_sequential_lun_scan(starget, bflags,
|
2006-04-03 13:16:48 +00:00
|
|
|
starget->scsi_level, rescan);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
out_reap:
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
scsi_autopm_put_target(starget);
|
2014-01-21 15:00:50 +00:00
|
|
|
/*
|
|
|
|
* paired with scsi_alloc_target(): determine if the target has
|
|
|
|
* any children at all and if not, nuke it
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
scsi_target_reap(starget);
|
|
|
|
|
|
|
|
put_device(&starget->dev);
|
|
|
|
}
|
2005-07-26 14:18:45 +00:00
|
|
|
|
|
|
|
/**
|
2008-03-01 06:02:50 +00:00
|
|
|
* scsi_scan_target - scan a target id, possibly including all LUNs on the target.
|
2005-07-26 14:18:45 +00:00
|
|
|
* @parent: host to scan
|
|
|
|
* @channel: channel to scan
|
|
|
|
* @id: target id to scan
|
|
|
|
* @lun: Specific LUN to scan or SCAN_WILD_CARD
|
2016-03-17 07:39:45 +00:00
|
|
|
* @rescan: passed to LUN scanning routines; SCSI_SCAN_INITIAL for
|
|
|
|
* no rescan, SCSI_SCAN_RESCAN to rescan existing LUNs,
|
|
|
|
* and SCSI_SCAN_MANUAL to force scanning even if
|
|
|
|
* 'scan=manual' is set.
|
2005-07-26 14:18:45 +00:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Scan the target id on @parent, @channel, and @id. Scan at least LUN 0,
|
|
|
|
* and possibly all LUNs on the target id.
|
|
|
|
*
|
|
|
|
* First try a REPORT LUN scan, if that does not scan the target, do a
|
|
|
|
* sequential scan of LUNs on the target id.
|
|
|
|
**/
|
|
|
|
void scsi_scan_target(struct device *parent, unsigned int channel,
|
2016-03-17 07:39:45 +00:00
|
|
|
unsigned int id, u64 lun, enum scsi_scan_mode rescan)
|
2005-07-26 14:18:45 +00:00
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = dev_to_shost(parent);
|
|
|
|
|
2006-11-22 20:24:53 +00:00
|
|
|
if (strncmp(scsi_scan_type, "none", 4) == 0)
|
|
|
|
return;
|
|
|
|
|
2016-03-17 07:39:45 +00:00
|
|
|
if (rescan != SCSI_SCAN_MANUAL &&
|
|
|
|
strncmp(scsi_scan_type, "manual", 6) == 0)
|
|
|
|
return;
|
|
|
|
|
2007-06-26 21:18:51 +00:00
|
|
|
mutex_lock(&shost->scan_mutex);
|
2006-09-28 21:19:20 +00:00
|
|
|
if (!shost->async_scan)
|
|
|
|
scsi_complete_async_scans();
|
|
|
|
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
|
2005-07-26 14:18:45 +00:00
|
|
|
__scsi_scan_target(parent, channel, id, lun, rescan);
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
scsi_autopm_put_host(shost);
|
|
|
|
}
|
2006-01-11 12:16:10 +00:00
|
|
|
mutex_unlock(&shost->scan_mutex);
|
2005-07-26 14:18:45 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
EXPORT_SYMBOL(scsi_scan_target);
|
|
|
|
|
|
|
|
static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel,
|
2016-03-17 07:39:45 +00:00
|
|
|
unsigned int id, u64 lun,
|
|
|
|
enum scsi_scan_mode rescan)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
uint order_id;
|
|
|
|
|
|
|
|
if (id == SCAN_WILD_CARD)
|
|
|
|
for (id = 0; id < shost->max_id; ++id) {
|
|
|
|
/*
|
|
|
|
* XXX adapter drivers when possible (FCP, iSCSI)
|
|
|
|
* could modify max_id to match the current max,
|
|
|
|
* not the absolute max.
|
|
|
|
*
|
|
|
|
* XXX add a shost id iterator, so for example,
|
|
|
|
* the FC ID can be the same as a target id
|
|
|
|
* without a huge overhead of sparse id's.
|
|
|
|
*/
|
|
|
|
if (shost->reverse_ordering)
|
|
|
|
/*
|
|
|
|
* Scan from high to low id.
|
|
|
|
*/
|
|
|
|
order_id = shost->max_id - id - 1;
|
|
|
|
else
|
|
|
|
order_id = id;
|
2005-07-26 14:18:45 +00:00
|
|
|
__scsi_scan_target(&shost->shost_gendev, channel,
|
|
|
|
order_id, lun, rescan);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
else
|
2005-07-26 14:18:45 +00:00
|
|
|
__scsi_scan_target(&shost->shost_gendev, channel,
|
|
|
|
id, lun, rescan);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,
|
2016-03-17 07:39:45 +00:00
|
|
|
unsigned int id, u64 lun,
|
|
|
|
enum scsi_scan_mode rescan)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-10-24 22:04:06 +00:00
|
|
|
SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,
|
2014-06-25 13:27:36 +00:00
|
|
|
"%s: <%u:%u:%llu>\n",
|
2008-07-04 06:47:27 +00:00
|
|
|
__func__, channel, id, lun));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
|
2006-05-19 23:14:50 +00:00
|
|
|
((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
|
2014-10-09 11:39:48 +00:00
|
|
|
((lun != SCAN_WILD_CARD) && (lun >= shost->max_lun)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2006-01-11 12:16:10 +00:00
|
|
|
mutex_lock(&shost->scan_mutex);
|
2007-06-26 21:18:51 +00:00
|
|
|
if (!shost->async_scan)
|
|
|
|
scsi_complete_async_scans();
|
|
|
|
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
|
2005-06-16 18:14:33 +00:00
|
|
|
if (channel == SCAN_WILD_CARD)
|
|
|
|
for (channel = 0; channel <= shost->max_channel;
|
|
|
|
channel++)
|
|
|
|
scsi_scan_channel(shost, channel, id, lun,
|
|
|
|
rescan);
|
|
|
|
else
|
2005-04-16 22:20:36 +00:00
|
|
|
scsi_scan_channel(shost, channel, id, lun, rescan);
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
scsi_autopm_put_host(shost);
|
2005-06-16 18:14:33 +00:00
|
|
|
}
|
2006-01-11 12:16:10 +00:00
|
|
|
mutex_unlock(&shost->scan_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-28 21:19:20 +00:00
|
|
|
static void scsi_sysfs_add_devices(struct Scsi_Host *shost)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev;
|
|
|
|
shost_for_each_device(sdev, shost) {
|
2012-06-22 06:47:28 +00:00
|
|
|
/* target removed before the device could be added */
|
|
|
|
if (sdev->sdev_state == SDEV_DEL)
|
|
|
|
continue;
|
2014-09-25 12:32:20 +00:00
|
|
|
/* If device is already visible, skip adding it to sysfs */
|
|
|
|
if (sdev->is_visible)
|
|
|
|
continue;
|
2007-06-26 21:18:51 +00:00
|
|
|
if (!scsi_host_scan_allowed(shost) ||
|
|
|
|
scsi_sysfs_add_sdev(sdev) != 0)
|
2009-11-19 22:48:29 +00:00
|
|
|
__scsi_remove_device(sdev);
|
2006-09-28 21:19:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_prep_async_scan - prepare for an async scan
|
|
|
|
* @shost: the host which will be scanned
|
|
|
|
* Returns: a cookie to be passed to scsi_finish_async_scan()
|
|
|
|
*
|
|
|
|
* Tells the midlayer this host is going to do an asynchronous scan.
|
|
|
|
* It reserves the host's position in the scanning list and ensures
|
|
|
|
* that other asynchronous scans started after this one won't affect the
|
|
|
|
* ordering of the discovered devices.
|
|
|
|
*/
|
2006-11-22 20:24:54 +00:00
|
|
|
static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)
|
2006-09-28 21:19:20 +00:00
|
|
|
{
|
2020-10-10 03:25:39 +00:00
|
|
|
struct async_scan_data *data = NULL;
|
2007-06-26 21:18:51 +00:00
|
|
|
unsigned long flags;
|
2006-09-28 21:19:20 +00:00
|
|
|
|
|
|
|
if (strncmp(scsi_scan_type, "sync", 4) == 0)
|
|
|
|
return NULL;
|
|
|
|
|
2020-10-10 03:25:39 +00:00
|
|
|
mutex_lock(&shost->scan_mutex);
|
2006-09-28 21:19:20 +00:00
|
|
|
if (shost->async_scan) {
|
2015-10-30 11:37:49 +00:00
|
|
|
shost_printk(KERN_DEBUG, shost, "%s called twice\n", __func__);
|
2020-10-10 03:25:39 +00:00
|
|
|
goto err;
|
2006-09-28 21:19:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
data = kmalloc(sizeof(*data), GFP_KERNEL);
|
|
|
|
if (!data)
|
|
|
|
goto err;
|
|
|
|
data->shost = scsi_host_get(shost);
|
|
|
|
if (!data->shost)
|
|
|
|
goto err;
|
|
|
|
init_completion(&data->prev_finished);
|
|
|
|
|
2007-06-26 21:18:51 +00:00
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
2006-09-28 21:19:20 +00:00
|
|
|
shost->async_scan = 1;
|
2007-06-26 21:18:51 +00:00
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
mutex_unlock(&shost->scan_mutex);
|
|
|
|
|
|
|
|
spin_lock(&async_scan_lock);
|
2006-09-28 21:19:20 +00:00
|
|
|
if (list_empty(&scanning_hosts))
|
|
|
|
complete(&data->prev_finished);
|
|
|
|
list_add_tail(&data->list, &scanning_hosts);
|
|
|
|
spin_unlock(&async_scan_lock);
|
|
|
|
|
|
|
|
return data;
|
|
|
|
|
|
|
|
err:
|
2020-10-10 03:25:39 +00:00
|
|
|
mutex_unlock(&shost->scan_mutex);
|
2006-09-28 21:19:20 +00:00
|
|
|
kfree(data);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_finish_async_scan - asynchronous scan has finished
|
|
|
|
* @data: cookie returned from earlier call to scsi_prep_async_scan()
|
|
|
|
*
|
|
|
|
* All the devices currently attached to this host have been found.
|
|
|
|
* This function announces all the devices it has found to the rest
|
|
|
|
* of the system.
|
|
|
|
*/
|
2006-11-22 20:24:54 +00:00
|
|
|
static void scsi_finish_async_scan(struct async_scan_data *data)
|
2006-09-28 21:19:20 +00:00
|
|
|
{
|
|
|
|
struct Scsi_Host *shost;
|
2007-06-26 21:18:51 +00:00
|
|
|
unsigned long flags;
|
2006-09-28 21:19:20 +00:00
|
|
|
|
|
|
|
if (!data)
|
|
|
|
return;
|
|
|
|
|
|
|
|
shost = data->shost;
|
2007-06-26 21:18:51 +00:00
|
|
|
|
|
|
|
mutex_lock(&shost->scan_mutex);
|
|
|
|
|
2006-09-28 21:19:20 +00:00
|
|
|
if (!shost->async_scan) {
|
2014-06-25 14:39:59 +00:00
|
|
|
shost_printk(KERN_INFO, shost, "%s called twice\n", __func__);
|
2006-09-28 21:19:20 +00:00
|
|
|
dump_stack();
|
2008-07-21 07:58:30 +00:00
|
|
|
mutex_unlock(&shost->scan_mutex);
|
2006-09-28 21:19:20 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
wait_for_completion(&data->prev_finished);
|
|
|
|
|
|
|
|
scsi_sysfs_add_devices(shost);
|
|
|
|
|
2007-06-26 21:18:51 +00:00
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
2006-09-28 21:19:20 +00:00
|
|
|
shost->async_scan = 0;
|
2007-06-26 21:18:51 +00:00
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
|
|
|
|
mutex_unlock(&shost->scan_mutex);
|
|
|
|
|
|
|
|
spin_lock(&async_scan_lock);
|
2006-09-28 21:19:20 +00:00
|
|
|
list_del(&data->list);
|
|
|
|
if (!list_empty(&scanning_hosts)) {
|
|
|
|
struct async_scan_data *next = list_entry(scanning_hosts.next,
|
|
|
|
struct async_scan_data, list);
|
|
|
|
complete(&next->prev_finished);
|
|
|
|
}
|
|
|
|
spin_unlock(&async_scan_lock);
|
|
|
|
|
[SCSI] scsi_scan: Fix 'Poison overwritten' warning caused by using freed 'shost'
In do_scan_async(), calling scsi_autopm_put_host(shost) may reference
freed shost, and cause Posison overwitten warning.
Yes, this case can happen, for example, an USB is disconnected just
when do_scan_async() thread starts to run, then scsi_host_put() called
in scsi_finish_async_scan() will lead to shost be freed(because the
refcount of shost->shost_gendev decreases to 1 after USB disconnects),
at this point, if references shost again, system will show following
warning msg.
To make scsi_autopm_put_host(shost) always reference a valid shost,
put it just before scsi_host_put() in function
scsi_finish_async_scan().
[ 299.281565] =============================================================================
[ 299.281634] BUG kmalloc-4096 (Tainted: G I ): Poison overwritten
[ 299.281682] -----------------------------------------------------------------------------
[ 299.281684]
[ 299.281752] INFO: 0xffff880056c305d0-0xffff880056c305d0. First byte
0x6a instead of 0x6b
[ 299.281816] INFO: Allocated in scsi_host_alloc+0x4a/0x490 age=1688
cpu=1 pid=2004
[ 299.281870] __slab_alloc+0x617/0x6c1
[ 299.281901] __kmalloc+0x28c/0x2e0
[ 299.281931] scsi_host_alloc+0x4a/0x490
[ 299.281966] usb_stor_probe1+0x5b/0xc40 [usb_storage]
[ 299.282010] storage_probe+0xa4/0xe0 [usb_storage]
[ 299.282062] usb_probe_interface+0x172/0x330 [usbcore]
[ 299.282105] driver_probe_device+0x257/0x3b0
[ 299.282138] __driver_attach+0x103/0x110
[ 299.282171] bus_for_each_dev+0x8e/0xe0
[ 299.282201] driver_attach+0x26/0x30
[ 299.282230] bus_add_driver+0x1c4/0x430
[ 299.282260] driver_register+0xb6/0x230
[ 299.282298] usb_register_driver+0xe5/0x270 [usbcore]
[ 299.282337] 0xffffffffa04ab03d
[ 299.282364] do_one_initcall+0x47/0x230
[ 299.282396] sys_init_module+0xa0f/0x1fe0
[ 299.282429] INFO: Freed in scsi_host_dev_release+0x18a/0x1d0 age=85
cpu=0 pid=2008
[ 299.282482] __slab_free+0x3c/0x2a1
[ 299.282510] kfree+0x296/0x310
[ 299.282536] scsi_host_dev_release+0x18a/0x1d0
[ 299.282574] device_release+0x74/0x100
[ 299.282606] kobject_release+0xc7/0x2a0
[ 299.282637] kobject_put+0x54/0xa0
[ 299.282668] put_device+0x27/0x40
[ 299.282694] scsi_host_put+0x1d/0x30
[ 299.282723] do_scan_async+0x1fc/0x2b0
[ 299.282753] kthread+0xdf/0xf0
[ 299.282782] kernel_thread_helper+0x4/0x10
[ 299.282817] INFO: Slab 0xffffea00015b0c00 objects=7 used=7 fp=0x
(null) flags=0x100000000004080
[ 299.282882] INFO: Object 0xffff880056c30000 @offset=0 fp=0x (null)
[ 299.282884]
...
Signed-off-by: Huajun Li <huajun.li.lee@gmail.com>
Cc: stable@kernel.org
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2012-02-12 11:59:14 +00:00
|
|
|
scsi_autopm_put_host(shost);
|
2006-09-28 21:19:20 +00:00
|
|
|
scsi_host_put(shost);
|
|
|
|
kfree(data);
|
|
|
|
}
|
|
|
|
|
2006-11-22 20:24:54 +00:00
|
|
|
static void do_scsi_scan_host(struct Scsi_Host *shost)
|
2006-09-28 21:19:20 +00:00
|
|
|
{
|
2006-11-22 20:24:54 +00:00
|
|
|
if (shost->hostt->scan_finished) {
|
|
|
|
unsigned long start = jiffies;
|
|
|
|
if (shost->hostt->scan_start)
|
|
|
|
shost->hostt->scan_start(shost);
|
|
|
|
|
|
|
|
while (!shost->hostt->scan_finished(shost, jiffies - start))
|
|
|
|
msleep(10);
|
|
|
|
} else {
|
|
|
|
scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,
|
2006-09-28 21:19:20 +00:00
|
|
|
SCAN_WILD_CARD, 0);
|
2006-11-22 20:24:54 +00:00
|
|
|
}
|
|
|
|
}
|
2006-09-28 21:19:20 +00:00
|
|
|
|
2012-07-10 02:33:35 +00:00
|
|
|
static void do_scan_async(void *_data, async_cookie_t c)
|
2006-11-22 20:24:54 +00:00
|
|
|
{
|
|
|
|
struct async_scan_data *data = _data;
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
struct Scsi_Host *shost = data->shost;
|
|
|
|
|
|
|
|
do_scsi_scan_host(shost);
|
2006-09-28 21:19:20 +00:00
|
|
|
scsi_finish_async_scan(data);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* scsi_scan_host - scan the given adapter
|
|
|
|
* @shost: adapter to scan
|
|
|
|
**/
|
|
|
|
void scsi_scan_host(struct Scsi_Host *shost)
|
|
|
|
{
|
2006-09-28 21:19:20 +00:00
|
|
|
struct async_scan_data *data;
|
|
|
|
|
2016-03-17 07:39:45 +00:00
|
|
|
if (strncmp(scsi_scan_type, "none", 4) == 0 ||
|
|
|
|
strncmp(scsi_scan_type, "manual", 6) == 0)
|
2006-09-28 21:19:20 +00:00
|
|
|
return;
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
if (scsi_autopm_get_host(shost) < 0)
|
|
|
|
return;
|
2006-09-28 21:19:20 +00:00
|
|
|
|
|
|
|
data = scsi_prep_async_scan(shost);
|
|
|
|
if (!data) {
|
2006-11-22 20:24:54 +00:00
|
|
|
do_scsi_scan_host(shost);
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 14:41:42 +00:00
|
|
|
scsi_autopm_put_host(shost);
|
2006-09-28 21:19:20 +00:00
|
|
|
return;
|
|
|
|
}
|
2006-11-22 20:24:54 +00:00
|
|
|
|
2012-07-10 02:33:35 +00:00
|
|
|
/* register with the async subsystem so wait_for_device_probe()
|
|
|
|
* will flush this work
|
|
|
|
*/
|
|
|
|
async_schedule(do_scan_async, data);
|
|
|
|
|
[SCSI] scsi_scan: Fix 'Poison overwritten' warning caused by using freed 'shost'
In do_scan_async(), calling scsi_autopm_put_host(shost) may reference
freed shost, and cause Posison overwitten warning.
Yes, this case can happen, for example, an USB is disconnected just
when do_scan_async() thread starts to run, then scsi_host_put() called
in scsi_finish_async_scan() will lead to shost be freed(because the
refcount of shost->shost_gendev decreases to 1 after USB disconnects),
at this point, if references shost again, system will show following
warning msg.
To make scsi_autopm_put_host(shost) always reference a valid shost,
put it just before scsi_host_put() in function
scsi_finish_async_scan().
[ 299.281565] =============================================================================
[ 299.281634] BUG kmalloc-4096 (Tainted: G I ): Poison overwritten
[ 299.281682] -----------------------------------------------------------------------------
[ 299.281684]
[ 299.281752] INFO: 0xffff880056c305d0-0xffff880056c305d0. First byte
0x6a instead of 0x6b
[ 299.281816] INFO: Allocated in scsi_host_alloc+0x4a/0x490 age=1688
cpu=1 pid=2004
[ 299.281870] __slab_alloc+0x617/0x6c1
[ 299.281901] __kmalloc+0x28c/0x2e0
[ 299.281931] scsi_host_alloc+0x4a/0x490
[ 299.281966] usb_stor_probe1+0x5b/0xc40 [usb_storage]
[ 299.282010] storage_probe+0xa4/0xe0 [usb_storage]
[ 299.282062] usb_probe_interface+0x172/0x330 [usbcore]
[ 299.282105] driver_probe_device+0x257/0x3b0
[ 299.282138] __driver_attach+0x103/0x110
[ 299.282171] bus_for_each_dev+0x8e/0xe0
[ 299.282201] driver_attach+0x26/0x30
[ 299.282230] bus_add_driver+0x1c4/0x430
[ 299.282260] driver_register+0xb6/0x230
[ 299.282298] usb_register_driver+0xe5/0x270 [usbcore]
[ 299.282337] 0xffffffffa04ab03d
[ 299.282364] do_one_initcall+0x47/0x230
[ 299.282396] sys_init_module+0xa0f/0x1fe0
[ 299.282429] INFO: Freed in scsi_host_dev_release+0x18a/0x1d0 age=85
cpu=0 pid=2008
[ 299.282482] __slab_free+0x3c/0x2a1
[ 299.282510] kfree+0x296/0x310
[ 299.282536] scsi_host_dev_release+0x18a/0x1d0
[ 299.282574] device_release+0x74/0x100
[ 299.282606] kobject_release+0xc7/0x2a0
[ 299.282637] kobject_put+0x54/0xa0
[ 299.282668] put_device+0x27/0x40
[ 299.282694] scsi_host_put+0x1d/0x30
[ 299.282723] do_scan_async+0x1fc/0x2b0
[ 299.282753] kthread+0xdf/0xf0
[ 299.282782] kernel_thread_helper+0x4/0x10
[ 299.282817] INFO: Slab 0xffffea00015b0c00 objects=7 used=7 fp=0x
(null) flags=0x100000000004080
[ 299.282882] INFO: Object 0xffff880056c30000 @offset=0 fp=0x (null)
[ 299.282884]
...
Signed-off-by: Huajun Li <huajun.li.lee@gmail.com>
Cc: stable@kernel.org
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2012-02-12 11:59:14 +00:00
|
|
|
/* scsi_autopm_put_host(shost) is called in scsi_finish_async_scan() */
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(scsi_scan_host);
|
|
|
|
|
|
|
|
void scsi_forget_host(struct Scsi_Host *shost)
|
|
|
|
{
|
2005-07-26 14:27:10 +00:00
|
|
|
struct scsi_device *sdev;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
2005-07-26 14:27:10 +00:00
|
|
|
restart:
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_irqsave(shost->host_lock, flags);
|
2005-07-26 14:27:10 +00:00
|
|
|
list_for_each_entry(sdev, &shost->__devices, siblings) {
|
|
|
|
if (sdev->sdev_state == SDEV_DEL)
|
|
|
|
continue;
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
2005-07-26 14:27:10 +00:00
|
|
|
__scsi_remove_device(sdev);
|
|
|
|
goto restart;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(shost->host_lock, flags);
|
|
|
|
}
|
|
|
|
|