2019-05-19 12:08:20 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* sd.c Copyright (C) 1992 Drew Eckhardt
|
|
|
|
* Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
|
|
|
|
*
|
|
|
|
* Linux scsi disk driver
|
|
|
|
* Initial versions: Drew Eckhardt
|
|
|
|
* Subsequent revisions: Eric Youngdale
|
|
|
|
* Modification history:
|
|
|
|
* - Drew Eckhardt <drew@colorado.edu> original
|
|
|
|
* - Eric Youngdale <eric@andante.org> add scatter-gather, multiple
|
|
|
|
* outstanding request, and other enhancements.
|
|
|
|
* Support loadable low-level scsi drivers.
|
|
|
|
* - Jirka Hanika <geo@ff.cuni.cz> support more scsi disks using
|
|
|
|
* eight major numbers.
|
|
|
|
* - Richard Gooch <rgooch@atnf.csiro.au> support devfs.
|
|
|
|
* - Torben Mathiasen <tmm@image.dk> Resource allocation fixes in
|
|
|
|
* sd_init and cleanups.
|
|
|
|
* - Alex Davis <letmein@erols.com> Fix problem where partition info
|
|
|
|
* not being read in sd_open. Fix problem where removable media
|
|
|
|
* could be ejected after sd_open.
|
|
|
|
* - Douglas Gilbert <dgilbert@interlog.com> cleanup for lk 2.5.x
|
|
|
|
* - Badari Pulavarty <pbadari@us.ibm.com>, Matthew Wilcox
|
|
|
|
* <willy@debian.org>, Kurt Garloff <garloff@suse.de>:
|
|
|
|
* Support 32k/1M disks.
|
|
|
|
*
|
|
|
|
* Logging policy (needs CONFIG_SCSI_LOGGING defined):
|
|
|
|
* - setting up transfer: SCSI_LOG_HLQUEUE levels 1 and 2
|
|
|
|
* - end of transfer (bh + scsi_lib): SCSI_LOG_HLCOMPLETE level 1
|
|
|
|
* - entering sd_ioctl: SCSI_LOG_IOCTL level 1
|
|
|
|
* - entering other commands: SCSI_LOG_HLQUEUE level 3
|
|
|
|
* Note: when the logging level is set by the user, it must be greater
|
|
|
|
* than the level indicated above to trigger output.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/bio.h>
|
|
|
|
#include <linux/hdreg.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/idr.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/blkpg.h>
|
2018-09-26 21:01:03 +00:00
|
|
|
#include <linux/blk-pm.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/delay.h>
|
2021-09-20 12:33:25 +00:00
|
|
|
#include <linux/major.h>
|
2006-01-11 12:16:10 +00:00
|
|
|
#include <linux/mutex.h>
|
2008-08-31 15:41:52 +00:00
|
|
|
#include <linux/string_helpers.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>
|
2017-06-19 12:26:46 +00:00
|
|
|
#include <linux/sed-opal.h>
|
2011-12-05 01:20:26 +00:00
|
|
|
#include <linux/pm_runtime.h>
|
2015-10-15 12:10:49 +00:00
|
|
|
#include <linux/pr.h>
|
2016-09-11 17:35:41 +00:00
|
|
|
#include <linux/t10-pi.h>
|
2016-12-24 19:46:01 +00:00
|
|
|
#include <linux/uaccess.h>
|
2009-04-21 23:43:27 +00:00
|
|
|
#include <asm/unaligned.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <scsi/scsi.h>
|
|
|
|
#include <scsi/scsi_cmnd.h>
|
|
|
|
#include <scsi/scsi_dbg.h>
|
|
|
|
#include <scsi/scsi_device.h>
|
|
|
|
#include <scsi/scsi_driver.h>
|
|
|
|
#include <scsi/scsi_eh.h>
|
|
|
|
#include <scsi/scsi_host.h>
|
|
|
|
#include <scsi/scsi_ioctl.h>
|
|
|
|
#include <scsi/scsicam.h>
|
|
|
|
|
2008-06-17 16:47:32 +00:00
|
|
|
#include "sd.h"
|
2012-03-23 00:05:11 +00:00
|
|
|
#include "scsi_priv.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "scsi_logging.h"
|
|
|
|
|
2006-03-08 08:14:20 +00:00
|
|
|
MODULE_AUTHOR("Eric Youngdale");
|
|
|
|
MODULE_DESCRIPTION("SCSI disk (sd) driver");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK0_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK1_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK2_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK3_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK4_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK5_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK6_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK7_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK8_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK9_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK10_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK11_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK12_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK13_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK14_MAJOR);
|
|
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK15_MAJOR);
|
[SCSI] modalias for scsi devices
The following patch adds support for sysfs/uevent modalias
attribute for scsi devices (like disks, tapes, cdroms etc),
based on whatever current sd.c, sr.c, st.c and osst.c drivers
supports.
The modalias format is like this:
scsi:type-0x04
(for TYPE_WORM, handled by sr.c now).
Several comments.
o This hexadecimal type value is because all TYPE_XXX constants
in include/scsi/scsi.h are given in hex, but __stringify() will
not convert them to decimal (so it will NOT be scsi:type-4).
Since it does not really matter in which format it is, while
both modalias in module and modalias attribute match each other,
I descided to go for that 0x%02x format (and added a comment in
include/scsi/scsi.h to keep them that way), instead of changing
them all to decimal.
o There was no .uevent routine for SCSI bus. It might be a good
idea to add some more ueven environment variables in there.
o osst.c driver handles tapes too, like st.c, but only SOME tapes.
With this setup, hotplug scripts (or whatever is used by the
user) will try to load both st and osst modules for all SCSI
tapes found, because both modules have scsi:type-0x01 alias).
It is not harmful, but one extra module is no good either.
It is possible to solve this, by exporting more info in
modalias attribute, including vendor and device identification
strings, so that modalias becomes something like
scsi:type-0x12:vendor-Adaptec LTD:device-OnStream Tape Drive
and having that, match for all 3 attributes, not only device
type. But oh well, vendor and device strings may be large,
and they do contain spaces and whatnot.
So I left them for now, awaiting for comments first.
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-10-27 12:02:37 +00:00
|
|
|
MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK);
|
|
|
|
MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD);
|
|
|
|
MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
|
2016-10-18 06:40:34 +00:00
|
|
|
MODULE_ALIAS_SCSI_DEVICE(TYPE_ZBC);
|
2006-03-08 08:14:20 +00:00
|
|
|
|
2008-08-25 10:47:24 +00:00
|
|
|
#define SD_MINORS 16
|
2008-08-25 10:47:25 +00:00
|
|
|
|
2011-03-08 07:07:15 +00:00
|
|
|
static void sd_config_discard(struct scsi_disk *, unsigned int);
|
2012-09-18 16:19:32 +00:00
|
|
|
static void sd_config_write_same(struct scsi_disk *);
|
Revert "scsi: revert "[SCSI] Get rid of scsi_cmnd->done""
This reverts commit ac40532ef0b8649e6f7f83859ea0de1c4ed08a19, which gets
us back the original cleanup of 6f5391c283d7fdcf24bf40786ea79061919d1e1d.
It turns out that the bug that was triggered by that commit was
apparently not actually triggered by that commit at all, and just the
testing conditions had changed enough to make it appear to be due to it.
The real problem seems to have been found by Peter Osterlund:
"pktcdvd sets it [block device size] when opening the /dev/pktcdvd
device, but when the drive is later opened as /dev/scd0, there is
nothing that sets it back. (Btw, 40944 is possible if the disk is a
CDRW that was formatted with "cdrwtool -m 10236".)
The problem is that pktcdvd opens the cd device in non-blocking mode
when pktsetup is run, and doesn't close it again until pktsetup -d is
run. The effect is that if you meanwhile open the cd device,
blkdev.c:do_open() doesn't call bd_set_size() because
bdev->bd_openers is non-zero."
In particular, to repeat the bug (regardless of whether commit
6f5391c283d7fdcf24bf40786ea79061919d1e1d is applied or not):
" 1. Start with an empty drive.
2. pktsetup 0 /dev/scd0
3. Insert a CD containing an isofs filesystem.
4. mount /dev/pktcdvd/0 /mnt/tmp
5. umount /mnt/tmp
6. Press the eject button.
7. Insert a DVD containing a non-writable filesystem.
8. mount /dev/scd0 /mnt/tmp
9. find /mnt/tmp -type f -print0 | xargs -0 sha1sum >/dev/null
10. If the DVD contains data beyond the physical size of a CD, you
get I/O errors in the terminal, and dmesg reports lots of
"attempt to access beyond end of device" errors."
which in turn is because the nested open after the media change won't
cause the size to be set properly (because the original open still holds
the block device, and we only do the bd_set_size() when we don't have
other people holding the device open).
The proper fix for that is probably to just do something like
bdev->bd_inode->i_size = (loff_t)get_capacity(disk)<<9;
in fs/block_dev.c:do_open() even for the cases where we're not the
original opener (but *not* call bd_set_size(), since that will also
change the block size of the device).
Cc: Peter Osterlund <petero2@telia.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-01-06 18:17:12 +00:00
|
|
|
static int sd_revalidate_disk(struct gendisk *);
|
2010-05-15 18:09:32 +00:00
|
|
|
static void sd_unlock_native_capacity(struct gendisk *disk);
|
Revert "scsi: revert "[SCSI] Get rid of scsi_cmnd->done""
This reverts commit ac40532ef0b8649e6f7f83859ea0de1c4ed08a19, which gets
us back the original cleanup of 6f5391c283d7fdcf24bf40786ea79061919d1e1d.
It turns out that the bug that was triggered by that commit was
apparently not actually triggered by that commit at all, and just the
testing conditions had changed enough to make it appear to be due to it.
The real problem seems to have been found by Peter Osterlund:
"pktcdvd sets it [block device size] when opening the /dev/pktcdvd
device, but when the drive is later opened as /dev/scd0, there is
nothing that sets it back. (Btw, 40944 is possible if the disk is a
CDRW that was formatted with "cdrwtool -m 10236".)
The problem is that pktcdvd opens the cd device in non-blocking mode
when pktsetup is run, and doesn't close it again until pktsetup -d is
run. The effect is that if you meanwhile open the cd device,
blkdev.c:do_open() doesn't call bd_set_size() because
bdev->bd_openers is non-zero."
In particular, to repeat the bug (regardless of whether commit
6f5391c283d7fdcf24bf40786ea79061919d1e1d is applied or not):
" 1. Start with an empty drive.
2. pktsetup 0 /dev/scd0
3. Insert a CD containing an isofs filesystem.
4. mount /dev/pktcdvd/0 /mnt/tmp
5. umount /mnt/tmp
6. Press the eject button.
7. Insert a DVD containing a non-writable filesystem.
8. mount /dev/scd0 /mnt/tmp
9. find /mnt/tmp -type f -print0 | xargs -0 sha1sum >/dev/null
10. If the DVD contains data beyond the physical size of a CD, you
get I/O errors in the terminal, and dmesg reports lots of
"attempt to access beyond end of device" errors."
which in turn is because the nested open after the media change won't
cause the size to be set properly (because the original open still holds
the block device, and we only do the bd_set_size() when we don't have
other people holding the device open).
The proper fix for that is probably to just do something like
bdev->bd_inode->i_size = (loff_t)get_capacity(disk)<<9;
in fs/block_dev.c:do_open() even for the cases where we're not the
original opener (but *not* call bd_set_size(), since that will also
change the block size of the device).
Cc: Peter Osterlund <petero2@telia.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-01-06 18:17:12 +00:00
|
|
|
static int sd_probe(struct device *);
|
|
|
|
static int sd_remove(struct device *);
|
|
|
|
static void sd_shutdown(struct device *);
|
2013-09-16 11:28:15 +00:00
|
|
|
static int sd_suspend_system(struct device *);
|
|
|
|
static int sd_suspend_runtime(struct device *);
|
2021-10-06 21:54:52 +00:00
|
|
|
static int sd_resume_system(struct device *);
|
2021-07-04 07:54:02 +00:00
|
|
|
static int sd_resume_runtime(struct device *);
|
Revert "scsi: revert "[SCSI] Get rid of scsi_cmnd->done""
This reverts commit ac40532ef0b8649e6f7f83859ea0de1c4ed08a19, which gets
us back the original cleanup of 6f5391c283d7fdcf24bf40786ea79061919d1e1d.
It turns out that the bug that was triggered by that commit was
apparently not actually triggered by that commit at all, and just the
testing conditions had changed enough to make it appear to be due to it.
The real problem seems to have been found by Peter Osterlund:
"pktcdvd sets it [block device size] when opening the /dev/pktcdvd
device, but when the drive is later opened as /dev/scd0, there is
nothing that sets it back. (Btw, 40944 is possible if the disk is a
CDRW that was formatted with "cdrwtool -m 10236".)
The problem is that pktcdvd opens the cd device in non-blocking mode
when pktsetup is run, and doesn't close it again until pktsetup -d is
run. The effect is that if you meanwhile open the cd device,
blkdev.c:do_open() doesn't call bd_set_size() because
bdev->bd_openers is non-zero."
In particular, to repeat the bug (regardless of whether commit
6f5391c283d7fdcf24bf40786ea79061919d1e1d is applied or not):
" 1. Start with an empty drive.
2. pktsetup 0 /dev/scd0
3. Insert a CD containing an isofs filesystem.
4. mount /dev/pktcdvd/0 /mnt/tmp
5. umount /mnt/tmp
6. Press the eject button.
7. Insert a DVD containing a non-writable filesystem.
8. mount /dev/scd0 /mnt/tmp
9. find /mnt/tmp -type f -print0 | xargs -0 sha1sum >/dev/null
10. If the DVD contains data beyond the physical size of a CD, you
get I/O errors in the terminal, and dmesg reports lots of
"attempt to access beyond end of device" errors."
which in turn is because the nested open after the media change won't
cause the size to be set properly (because the original open still holds
the block device, and we only do the bd_set_size() when we don't have
other people holding the device open).
The proper fix for that is probably to just do something like
bdev->bd_inode->i_size = (loff_t)get_capacity(disk)<<9;
in fs/block_dev.c:do_open() even for the cases where we're not the
original opener (but *not* call bd_set_size(), since that will also
change the block size of the device).
Cc: Peter Osterlund <petero2@telia.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-01-06 18:17:12 +00:00
|
|
|
static void sd_rescan(struct device *);
|
2018-11-09 13:42:39 +00:00
|
|
|
static blk_status_t sd_init_command(struct scsi_cmnd *SCpnt);
|
2014-05-01 14:51:04 +00:00
|
|
|
static void sd_uninit_command(struct scsi_cmnd *SCpnt);
|
Revert "scsi: revert "[SCSI] Get rid of scsi_cmnd->done""
This reverts commit ac40532ef0b8649e6f7f83859ea0de1c4ed08a19, which gets
us back the original cleanup of 6f5391c283d7fdcf24bf40786ea79061919d1e1d.
It turns out that the bug that was triggered by that commit was
apparently not actually triggered by that commit at all, and just the
testing conditions had changed enough to make it appear to be due to it.
The real problem seems to have been found by Peter Osterlund:
"pktcdvd sets it [block device size] when opening the /dev/pktcdvd
device, but when the drive is later opened as /dev/scd0, there is
nothing that sets it back. (Btw, 40944 is possible if the disk is a
CDRW that was formatted with "cdrwtool -m 10236".)
The problem is that pktcdvd opens the cd device in non-blocking mode
when pktsetup is run, and doesn't close it again until pktsetup -d is
run. The effect is that if you meanwhile open the cd device,
blkdev.c:do_open() doesn't call bd_set_size() because
bdev->bd_openers is non-zero."
In particular, to repeat the bug (regardless of whether commit
6f5391c283d7fdcf24bf40786ea79061919d1e1d is applied or not):
" 1. Start with an empty drive.
2. pktsetup 0 /dev/scd0
3. Insert a CD containing an isofs filesystem.
4. mount /dev/pktcdvd/0 /mnt/tmp
5. umount /mnt/tmp
6. Press the eject button.
7. Insert a DVD containing a non-writable filesystem.
8. mount /dev/scd0 /mnt/tmp
9. find /mnt/tmp -type f -print0 | xargs -0 sha1sum >/dev/null
10. If the DVD contains data beyond the physical size of a CD, you
get I/O errors in the terminal, and dmesg reports lots of
"attempt to access beyond end of device" errors."
which in turn is because the nested open after the media change won't
cause the size to be set properly (because the original open still holds
the block device, and we only do the bd_set_size() when we don't have
other people holding the device open).
The proper fix for that is probably to just do something like
bdev->bd_inode->i_size = (loff_t)get_capacity(disk)<<9;
in fs/block_dev.c:do_open() even for the cases where we're not the
original opener (but *not* call bd_set_size(), since that will also
change the block size of the device).
Cc: Peter Osterlund <petero2@telia.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-01-06 18:17:12 +00:00
|
|
|
static int sd_done(struct scsi_cmnd *);
|
2017-04-06 13:36:29 +00:00
|
|
|
static void sd_eh_reset(struct scsi_cmnd *);
|
2013-11-11 12:44:53 +00:00
|
|
|
static int sd_eh_action(struct scsi_cmnd *, int);
|
Revert "scsi: revert "[SCSI] Get rid of scsi_cmnd->done""
This reverts commit ac40532ef0b8649e6f7f83859ea0de1c4ed08a19, which gets
us back the original cleanup of 6f5391c283d7fdcf24bf40786ea79061919d1e1d.
It turns out that the bug that was triggered by that commit was
apparently not actually triggered by that commit at all, and just the
testing conditions had changed enough to make it appear to be due to it.
The real problem seems to have been found by Peter Osterlund:
"pktcdvd sets it [block device size] when opening the /dev/pktcdvd
device, but when the drive is later opened as /dev/scd0, there is
nothing that sets it back. (Btw, 40944 is possible if the disk is a
CDRW that was formatted with "cdrwtool -m 10236".)
The problem is that pktcdvd opens the cd device in non-blocking mode
when pktsetup is run, and doesn't close it again until pktsetup -d is
run. The effect is that if you meanwhile open the cd device,
blkdev.c:do_open() doesn't call bd_set_size() because
bdev->bd_openers is non-zero."
In particular, to repeat the bug (regardless of whether commit
6f5391c283d7fdcf24bf40786ea79061919d1e1d is applied or not):
" 1. Start with an empty drive.
2. pktsetup 0 /dev/scd0
3. Insert a CD containing an isofs filesystem.
4. mount /dev/pktcdvd/0 /mnt/tmp
5. umount /mnt/tmp
6. Press the eject button.
7. Insert a DVD containing a non-writable filesystem.
8. mount /dev/scd0 /mnt/tmp
9. find /mnt/tmp -type f -print0 | xargs -0 sha1sum >/dev/null
10. If the DVD contains data beyond the physical size of a CD, you
get I/O errors in the terminal, and dmesg reports lots of
"attempt to access beyond end of device" errors."
which in turn is because the nested open after the media change won't
cause the size to be set properly (because the original open still holds
the block device, and we only do the bd_set_size() when we don't have
other people holding the device open).
The proper fix for that is probably to just do something like
bdev->bd_inode->i_size = (loff_t)get_capacity(disk)<<9;
in fs/block_dev.c:do_open() even for the cases where we're not the
original opener (but *not* call bd_set_size(), since that will also
change the block size of the device).
Cc: Peter Osterlund <petero2@telia.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-01-06 18:17:12 +00:00
|
|
|
static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
|
2008-02-21 23:13:36 +00:00
|
|
|
static void scsi_disk_release(struct device *cdev);
|
Revert "scsi: revert "[SCSI] Get rid of scsi_cmnd->done""
This reverts commit ac40532ef0b8649e6f7f83859ea0de1c4ed08a19, which gets
us back the original cleanup of 6f5391c283d7fdcf24bf40786ea79061919d1e1d.
It turns out that the bug that was triggered by that commit was
apparently not actually triggered by that commit at all, and just the
testing conditions had changed enough to make it appear to be due to it.
The real problem seems to have been found by Peter Osterlund:
"pktcdvd sets it [block device size] when opening the /dev/pktcdvd
device, but when the drive is later opened as /dev/scd0, there is
nothing that sets it back. (Btw, 40944 is possible if the disk is a
CDRW that was formatted with "cdrwtool -m 10236".)
The problem is that pktcdvd opens the cd device in non-blocking mode
when pktsetup is run, and doesn't close it again until pktsetup -d is
run. The effect is that if you meanwhile open the cd device,
blkdev.c:do_open() doesn't call bd_set_size() because
bdev->bd_openers is non-zero."
In particular, to repeat the bug (regardless of whether commit
6f5391c283d7fdcf24bf40786ea79061919d1e1d is applied or not):
" 1. Start with an empty drive.
2. pktsetup 0 /dev/scd0
3. Insert a CD containing an isofs filesystem.
4. mount /dev/pktcdvd/0 /mnt/tmp
5. umount /mnt/tmp
6. Press the eject button.
7. Insert a DVD containing a non-writable filesystem.
8. mount /dev/scd0 /mnt/tmp
9. find /mnt/tmp -type f -print0 | xargs -0 sha1sum >/dev/null
10. If the DVD contains data beyond the physical size of a CD, you
get I/O errors in the terminal, and dmesg reports lots of
"attempt to access beyond end of device" errors."
which in turn is because the nested open after the media change won't
cause the size to be set properly (because the original open still holds
the block device, and we only do the bd_set_size() when we don't have
other people holding the device open).
The proper fix for that is probably to just do something like
bdev->bd_inode->i_size = (loff_t)get_capacity(disk)<<9;
in fs/block_dev.c:do_open() even for the cases where we're not the
original opener (but *not* call bd_set_size(), since that will also
change the block size of the device).
Cc: Peter Osterlund <petero2@telia.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-01-06 18:17:12 +00:00
|
|
|
|
2008-07-14 05:59:30 +00:00
|
|
|
static DEFINE_IDA(sd_index_ida);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-12-12 13:46:55 +00:00
|
|
|
static mempool_t *sd_page_pool;
|
2021-08-16 13:19:06 +00:00
|
|
|
static struct lock_class_key sd_bio_compl_lkclass;
|
2009-09-20 20:49:38 +00:00
|
|
|
|
2006-03-18 20:14:21 +00:00
|
|
|
static const char *sd_cache_types[] = {
|
|
|
|
"write through", "none", "write back",
|
|
|
|
"write back, no read (daft)"
|
|
|
|
};
|
|
|
|
|
2014-06-03 09:37:30 +00:00
|
|
|
static void sd_set_flush_flag(struct scsi_disk *sdkp)
|
|
|
|
{
|
2016-03-30 16:06:11 +00:00
|
|
|
bool wc = false, fua = false;
|
2014-06-03 09:37:30 +00:00
|
|
|
|
|
|
|
if (sdkp->WCE) {
|
2016-03-30 16:06:11 +00:00
|
|
|
wc = true;
|
2014-06-03 09:37:30 +00:00
|
|
|
if (sdkp->DPOFUA)
|
2016-03-30 16:06:11 +00:00
|
|
|
fua = true;
|
2014-06-03 09:37:30 +00:00
|
|
|
}
|
|
|
|
|
2016-03-30 16:06:11 +00:00
|
|
|
blk_queue_write_cache(sdkp->disk->queue, wc, fua);
|
2014-06-03 09:37:30 +00:00
|
|
|
}
|
|
|
|
|
2008-02-21 23:13:36 +00:00
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
cache_type_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2006-03-18 20:14:21 +00:00
|
|
|
{
|
2017-05-25 13:34:30 +00:00
|
|
|
int ct, rcd, wce, sp;
|
2008-02-21 23:13:36 +00:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2006-03-18 20:14:21 +00:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
char buffer[64];
|
|
|
|
char *buffer_data;
|
|
|
|
struct scsi_mode_data data;
|
|
|
|
struct scsi_sense_hdr sshdr;
|
2013-05-27 18:07:19 +00:00
|
|
|
static const char temp[] = "temporary ";
|
2006-03-18 20:14:21 +00:00
|
|
|
int len;
|
|
|
|
|
2016-10-18 06:40:34 +00:00
|
|
|
if (sdp->type != TYPE_DISK && sdp->type != TYPE_ZBC)
|
2006-03-18 20:14:21 +00:00
|
|
|
/* no cache control on RBC devices; theoretically they
|
|
|
|
* can do it, but there's probably so many exceptions
|
|
|
|
* it's not worth the risk */
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-04-24 21:02:53 +00:00
|
|
|
if (strncmp(buf, temp, sizeof(temp) - 1) == 0) {
|
|
|
|
buf += sizeof(temp) - 1;
|
|
|
|
sdkp->cache_override = 1;
|
|
|
|
} else {
|
|
|
|
sdkp->cache_override = 0;
|
|
|
|
}
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
ct = sysfs_match_string(sd_cache_types, buf);
|
2006-03-18 20:14:21 +00:00
|
|
|
if (ct < 0)
|
|
|
|
return -EINVAL;
|
2017-05-25 13:34:30 +00:00
|
|
|
|
2006-03-18 20:14:21 +00:00
|
|
|
rcd = ct & 0x01 ? 1 : 0;
|
2014-08-11 12:40:37 +00:00
|
|
|
wce = (ct & 0x02) && !sdkp->write_prot ? 1 : 0;
|
2013-04-24 21:02:53 +00:00
|
|
|
|
|
|
|
if (sdkp->cache_override) {
|
|
|
|
sdkp->WCE = wce;
|
|
|
|
sdkp->RCD = rcd;
|
2014-06-03 09:37:30 +00:00
|
|
|
sd_set_flush_flag(sdkp);
|
2013-04-24 21:02:53 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2006-03-18 20:14:21 +00:00
|
|
|
if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT,
|
2020-10-01 15:35:54 +00:00
|
|
|
sdkp->max_retries, &data, NULL))
|
2006-03-18 20:14:21 +00:00
|
|
|
return -EINVAL;
|
2006-03-25 11:08:30 +00:00
|
|
|
len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
|
2006-03-18 20:14:21 +00:00
|
|
|
data.block_descriptor_length);
|
|
|
|
buffer_data = buffer + data.header_length +
|
|
|
|
data.block_descriptor_length;
|
|
|
|
buffer_data[2] &= ~0x05;
|
|
|
|
buffer_data[2] |= wce << 2 | rcd;
|
|
|
|
sp = buffer_data[0] & 0x80 ? 1 : 0;
|
sd: Clear PS bit before Mode Select.
According to SPC-4, in a Mode Select, the PS bit in Mode Pages is
reserved and must be set to 0 by the driver. In the sd implementation,
function cache_type_store does a Mode Sense, which might set the PS bit
on the read buffer, followed by a Mode Select, which receives the same
buffer, without explicitly clearing the PS bit. So, in cases where
target supports saving the Mode Page to a non-volatile location, we end
up doing a Mode Select with the PS bit set, which could cause an illegal
request error if the target is checking this.
This was observed on a new firmware change, which was subsequently
reverted, but this changes sd.c to be more compliant with SPC-4.
This patch clears the PS bit in the buffer returned by Mode Select,
right before it is used in the Mode Select command.
Signed-off-by: Gabriel Krisman Bertazi <krisman@linux.vnet.ibm.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2015-10-30 18:04:43 +00:00
|
|
|
buffer_data[0] &= ~0x80;
|
2006-03-18 20:14:21 +00:00
|
|
|
|
2018-12-23 07:41:58 +00:00
|
|
|
/*
|
|
|
|
* Ensure WP, DPOFUA, and RESERVED fields are cleared in
|
|
|
|
* received mode parameter buffer before doing MODE SELECT.
|
|
|
|
*/
|
|
|
|
data.device_specific = 0;
|
|
|
|
|
2021-09-29 09:17:44 +00:00
|
|
|
if (scsi_mode_select(sdp, 1, sp, buffer_data, len, SD_TIMEOUT,
|
2020-10-01 15:35:54 +00:00
|
|
|
sdkp->max_retries, &data, &sshdr)) {
|
2006-03-18 20:14:21 +00:00
|
|
|
if (scsi_sense_valid(&sshdr))
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_print_sense_hdr(sdkp, &sshdr);
|
2006-03-18 20:14:21 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2020-09-01 15:57:46 +00:00
|
|
|
sd_revalidate_disk(sdkp->disk);
|
2006-03-18 20:14:21 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2008-02-21 23:13:36 +00:00
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
manage_start_stop_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "%u\n", sdp->manage_start_stop);
|
2013-07-24 22:05:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
manage_start_stop_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2007-03-20 15:13:59 +00:00
|
|
|
{
|
2008-02-21 23:13:36 +00:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2007-03-20 15:13:59 +00:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2017-10-12 06:57:06 +00:00
|
|
|
bool v;
|
2007-03-20 15:13:59 +00:00
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
|
2017-10-12 06:57:06 +00:00
|
|
|
if (kstrtobool(buf, &v))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
sdp->manage_start_stop = v;
|
2007-03-20 15:13:59 +00:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
2013-07-24 22:05:28 +00:00
|
|
|
static DEVICE_ATTR_RW(manage_start_stop);
|
2007-03-20 15:13:59 +00:00
|
|
|
|
2008-02-21 23:13:36 +00:00
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
allow_restart_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "%u\n", sdkp->device->allow_restart);
|
2013-07-24 22:05:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
allow_restart_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2006-06-27 16:10:31 +00:00
|
|
|
{
|
2017-10-12 06:56:44 +00:00
|
|
|
bool v;
|
2008-02-21 23:13:36 +00:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2006-06-27 16:10:31 +00:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
|
2016-10-18 06:40:34 +00:00
|
|
|
if (sdp->type != TYPE_DISK && sdp->type != TYPE_ZBC)
|
2006-06-27 16:10:31 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2017-10-12 06:56:44 +00:00
|
|
|
if (kstrtobool(buf, &v))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
sdp->allow_restart = v;
|
2006-06-27 16:10:31 +00:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
2013-07-24 22:05:28 +00:00
|
|
|
static DEVICE_ATTR_RW(allow_restart);
|
2006-06-27 16:10:31 +00:00
|
|
|
|
2008-02-21 23:13:36 +00:00
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
cache_type_show(struct device *dev, struct device_attribute *attr, char *buf)
|
2006-03-18 20:14:21 +00:00
|
|
|
{
|
2008-02-21 23:13:36 +00:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2006-03-18 20:14:21 +00:00
|
|
|
int ct = sdkp->RCD + 2*sdkp->WCE;
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "%s\n", sd_cache_types[ct]);
|
2006-03-18 20:14:21 +00:00
|
|
|
}
|
2013-07-24 22:05:28 +00:00
|
|
|
static DEVICE_ATTR_RW(cache_type);
|
2006-03-18 20:14:21 +00:00
|
|
|
|
2008-02-21 23:13:36 +00:00
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
FUA_show(struct device *dev, struct device_attribute *attr, char *buf)
|
2006-03-18 20:14:21 +00:00
|
|
|
{
|
2008-02-21 23:13:36 +00:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2006-03-18 20:14:21 +00:00
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "%u\n", sdkp->DPOFUA);
|
2006-03-18 20:14:21 +00:00
|
|
|
}
|
2013-07-24 22:05:28 +00:00
|
|
|
static DEVICE_ATTR_RO(FUA);
|
2006-03-18 20:14:21 +00:00
|
|
|
|
2008-02-21 23:13:36 +00:00
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
protection_type_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2008-07-17 08:28:34 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "%u\n", sdkp->protection_type);
|
2008-07-17 08:28:34 +00:00
|
|
|
}
|
|
|
|
|
2012-08-28 18:29:34 +00:00
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
protection_type_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2012-08-28 18:29:34 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
unsigned int val;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
|
|
|
|
err = kstrtouint(buf, 10, &val);
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2017-08-25 20:46:35 +00:00
|
|
|
if (val <= T10_PI_TYPE3_PROTECTION)
|
2012-08-28 18:29:34 +00:00
|
|
|
sdkp->protection_type = val;
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
2013-07-24 22:05:28 +00:00
|
|
|
static DEVICE_ATTR_RW(protection_type);
|
2012-08-28 18:29:34 +00:00
|
|
|
|
2010-10-08 05:36:24 +00:00
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
protection_mode_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2010-10-08 05:36:24 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
unsigned int dif, dix;
|
|
|
|
|
|
|
|
dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
|
|
|
|
dix = scsi_host_dix_capable(sdp->host, sdkp->protection_type);
|
|
|
|
|
2016-09-11 17:35:41 +00:00
|
|
|
if (!dix && scsi_host_dix_capable(sdp->host, T10_PI_TYPE0_PROTECTION)) {
|
2010-10-08 05:36:24 +00:00
|
|
|
dif = 0;
|
|
|
|
dix = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!dif && !dix)
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "none\n");
|
2010-10-08 05:36:24 +00:00
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "%s%u\n", dix ? "dix" : "dif", dif);
|
2010-10-08 05:36:24 +00:00
|
|
|
}
|
2013-07-24 22:05:28 +00:00
|
|
|
static DEVICE_ATTR_RO(protection_mode);
|
2010-10-08 05:36:24 +00:00
|
|
|
|
2008-07-17 08:28:34 +00:00
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
app_tag_own_show(struct device *dev, struct device_attribute *attr, char *buf)
|
2008-07-17 08:28:34 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "%u\n", sdkp->ATO);
|
2008-07-17 08:28:34 +00:00
|
|
|
}
|
2013-07-24 22:05:28 +00:00
|
|
|
static DEVICE_ATTR_RO(app_tag_own);
|
2008-07-17 08:28:34 +00:00
|
|
|
|
2009-11-26 17:00:40 +00:00
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
thin_provisioning_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2009-11-26 17:00:40 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "%u\n", sdkp->lbpme);
|
2011-03-08 07:07:15 +00:00
|
|
|
}
|
2013-07-24 22:05:28 +00:00
|
|
|
static DEVICE_ATTR_RO(thin_provisioning);
|
2011-03-08 07:07:15 +00:00
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
/* sysfs_match_string() requires dense arrays */
|
2011-03-08 07:07:15 +00:00
|
|
|
static const char *lbp_mode[] = {
|
|
|
|
[SD_LBP_FULL] = "full",
|
|
|
|
[SD_LBP_UNMAP] = "unmap",
|
|
|
|
[SD_LBP_WS16] = "writesame_16",
|
|
|
|
[SD_LBP_WS10] = "writesame_10",
|
|
|
|
[SD_LBP_ZERO] = "writesame_zero",
|
|
|
|
[SD_LBP_DISABLE] = "disabled",
|
|
|
|
};
|
|
|
|
|
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
provisioning_mode_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2011-03-08 07:07:15 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "%s\n", lbp_mode[sdkp->provisioning_mode]);
|
2011-03-08 07:07:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
provisioning_mode_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2011-03-08 07:07:15 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2017-05-25 13:34:30 +00:00
|
|
|
int mode;
|
2011-03-08 07:07:15 +00:00
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
|
2016-10-18 06:40:34 +00:00
|
|
|
if (sd_is_zoned(sdkp)) {
|
|
|
|
sd_config_discard(sdkp, SD_LBP_DISABLE);
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2011-03-08 07:07:15 +00:00
|
|
|
if (sdp->type != TYPE_DISK)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
mode = sysfs_match_string(lbp_mode, buf);
|
|
|
|
if (mode < 0)
|
2011-03-08 07:07:15 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
sd_config_discard(sdkp, mode);
|
|
|
|
|
2011-03-08 07:07:15 +00:00
|
|
|
return count;
|
2009-11-26 17:00:40 +00:00
|
|
|
}
|
2013-07-24 22:05:28 +00:00
|
|
|
static DEVICE_ATTR_RW(provisioning_mode);
|
2009-11-26 17:00:40 +00:00
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
/* sysfs_match_string() requires dense arrays */
|
2017-04-05 17:21:24 +00:00
|
|
|
static const char *zeroing_mode[] = {
|
|
|
|
[SD_ZERO_WRITE] = "write",
|
|
|
|
[SD_ZERO_WS] = "writesame",
|
|
|
|
[SD_ZERO_WS16_UNMAP] = "writesame_16_unmap",
|
|
|
|
[SD_ZERO_WS10_UNMAP] = "writesame_10_unmap",
|
|
|
|
};
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
zeroing_mode_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "%s\n", zeroing_mode[sdkp->zeroing_mode]);
|
2017-04-05 17:21:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
zeroing_mode_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2017-05-25 13:34:30 +00:00
|
|
|
int mode;
|
2017-04-05 17:21:24 +00:00
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
mode = sysfs_match_string(zeroing_mode, buf);
|
|
|
|
if (mode < 0)
|
2017-04-05 17:21:24 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
sdkp->zeroing_mode = mode;
|
|
|
|
|
2017-04-05 17:21:24 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR_RW(zeroing_mode);
|
|
|
|
|
2012-02-09 18:48:53 +00:00
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
max_medium_access_timeouts_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2012-02-09 18:48:53 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "%u\n", sdkp->max_medium_access_timeouts);
|
2012-02-09 18:48:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
max_medium_access_timeouts_store(struct device *dev,
|
|
|
|
struct device_attribute *attr, const char *buf,
|
|
|
|
size_t count)
|
2012-02-09 18:48:53 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
|
|
|
|
err = kstrtouint(buf, 10, &sdkp->max_medium_access_timeouts);
|
|
|
|
|
|
|
|
return err ? err : count;
|
|
|
|
}
|
2013-07-24 22:05:28 +00:00
|
|
|
static DEVICE_ATTR_RW(max_medium_access_timeouts);
|
2012-02-09 18:48:53 +00:00
|
|
|
|
2012-09-18 16:19:32 +00:00
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
max_write_same_blocks_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2012-09-18 16:19:32 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
return sprintf(buf, "%u\n", sdkp->max_ws_blocks);
|
2012-09-18 16:19:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2013-07-24 22:05:28 +00:00
|
|
|
max_write_same_blocks_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2012-09-18 16:19:32 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
unsigned long max;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
|
2016-10-18 06:40:34 +00:00
|
|
|
if (sdp->type != TYPE_DISK && sdp->type != TYPE_ZBC)
|
2012-09-18 16:19:32 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
err = kstrtoul(buf, 10, &max);
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (max == 0)
|
|
|
|
sdp->no_write_same = 1;
|
2013-06-07 02:15:55 +00:00
|
|
|
else if (max <= SD_MAX_WS16_BLOCKS) {
|
|
|
|
sdp->no_write_same = 0;
|
2012-09-18 16:19:32 +00:00
|
|
|
sdkp->max_ws_blocks = max;
|
2013-06-07 02:15:55 +00:00
|
|
|
}
|
2012-09-18 16:19:32 +00:00
|
|
|
|
|
|
|
sd_config_write_same(sdkp);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
2013-07-24 22:05:28 +00:00
|
|
|
static DEVICE_ATTR_RW(max_write_same_blocks);
|
|
|
|
|
2020-05-15 05:48:56 +00:00
|
|
|
static ssize_t
|
|
|
|
zoned_cap_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
|
|
|
|
if (sdkp->device->type == TYPE_ZBC)
|
|
|
|
return sprintf(buf, "host-managed\n");
|
|
|
|
if (sdkp->zoned == 1)
|
|
|
|
return sprintf(buf, "host-aware\n");
|
|
|
|
if (sdkp->zoned == 2)
|
|
|
|
return sprintf(buf, "drive-managed\n");
|
|
|
|
return sprintf(buf, "none\n");
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR_RO(zoned_cap);
|
|
|
|
|
2020-10-01 15:35:54 +00:00
|
|
|
static ssize_t
|
|
|
|
max_retries_store(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
struct scsi_device *sdev = sdkp->device;
|
|
|
|
int retries, err;
|
|
|
|
|
|
|
|
err = kstrtoint(buf, 10, &retries);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (retries == SCSI_CMD_RETRIES_NO_LIMIT || retries <= SD_MAX_RETRIES) {
|
|
|
|
sdkp->max_retries = retries;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
sdev_printk(KERN_ERR, sdev, "max_retries must be between -1 and %d\n",
|
|
|
|
SD_MAX_RETRIES);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
max_retries_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", sdkp->max_retries);
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR_RW(max_retries);
|
|
|
|
|
2013-07-24 22:05:28 +00:00
|
|
|
static struct attribute *sd_disk_attrs[] = {
|
|
|
|
&dev_attr_cache_type.attr,
|
|
|
|
&dev_attr_FUA.attr,
|
|
|
|
&dev_attr_allow_restart.attr,
|
|
|
|
&dev_attr_manage_start_stop.attr,
|
|
|
|
&dev_attr_protection_type.attr,
|
|
|
|
&dev_attr_protection_mode.attr,
|
|
|
|
&dev_attr_app_tag_own.attr,
|
|
|
|
&dev_attr_thin_provisioning.attr,
|
|
|
|
&dev_attr_provisioning_mode.attr,
|
2017-04-05 17:21:24 +00:00
|
|
|
&dev_attr_zeroing_mode.attr,
|
2013-07-24 22:05:28 +00:00
|
|
|
&dev_attr_max_write_same_blocks.attr,
|
|
|
|
&dev_attr_max_medium_access_timeouts.attr,
|
2020-05-15 05:48:56 +00:00
|
|
|
&dev_attr_zoned_cap.attr,
|
2020-10-01 15:35:54 +00:00
|
|
|
&dev_attr_max_retries.attr,
|
2013-07-24 22:05:28 +00:00
|
|
|
NULL,
|
2006-03-18 20:14:21 +00:00
|
|
|
};
|
2013-07-24 22:05:28 +00:00
|
|
|
ATTRIBUTE_GROUPS(sd_disk);
|
2006-03-18 20:14:21 +00:00
|
|
|
|
|
|
|
static struct class sd_disk_class = {
|
|
|
|
.name = "scsi_disk",
|
2008-02-21 23:13:36 +00:00
|
|
|
.dev_release = scsi_disk_release,
|
2013-07-24 22:05:28 +00:00
|
|
|
.dev_groups = sd_disk_groups,
|
2006-03-18 20:14:21 +00:00
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-11-09 07:27:55 +00:00
|
|
|
static const struct dev_pm_ops sd_pm_ops = {
|
2013-09-16 11:28:15 +00:00
|
|
|
.suspend = sd_suspend_system,
|
2021-10-06 21:54:52 +00:00
|
|
|
.resume = sd_resume_system,
|
2013-09-16 11:28:15 +00:00
|
|
|
.poweroff = sd_suspend_system,
|
2021-10-06 21:54:52 +00:00
|
|
|
.restore = sd_resume_system,
|
2013-09-16 11:28:15 +00:00
|
|
|
.runtime_suspend = sd_suspend_runtime,
|
2021-07-04 07:54:02 +00:00
|
|
|
.runtime_resume = sd_resume_runtime,
|
2012-11-09 07:27:55 +00:00
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static struct scsi_driver sd_template = {
|
|
|
|
.gendrv = {
|
|
|
|
.name = "sd",
|
2014-11-12 17:34:51 +00:00
|
|
|
.owner = THIS_MODULE,
|
2005-04-16 22:20:36 +00:00
|
|
|
.probe = sd_probe,
|
2019-04-30 21:39:18 +00:00
|
|
|
.probe_type = PROBE_PREFER_ASYNCHRONOUS,
|
2005-04-16 22:20:36 +00:00
|
|
|
.remove = sd_remove,
|
|
|
|
.shutdown = sd_shutdown,
|
2012-11-09 07:27:55 +00:00
|
|
|
.pm = &sd_pm_ops,
|
2005-04-16 22:20:36 +00:00
|
|
|
},
|
|
|
|
.rescan = sd_rescan,
|
2014-05-01 14:51:04 +00:00
|
|
|
.init_command = sd_init_command,
|
|
|
|
.uninit_command = sd_uninit_command,
|
Revert "scsi: revert "[SCSI] Get rid of scsi_cmnd->done""
This reverts commit ac40532ef0b8649e6f7f83859ea0de1c4ed08a19, which gets
us back the original cleanup of 6f5391c283d7fdcf24bf40786ea79061919d1e1d.
It turns out that the bug that was triggered by that commit was
apparently not actually triggered by that commit at all, and just the
testing conditions had changed enough to make it appear to be due to it.
The real problem seems to have been found by Peter Osterlund:
"pktcdvd sets it [block device size] when opening the /dev/pktcdvd
device, but when the drive is later opened as /dev/scd0, there is
nothing that sets it back. (Btw, 40944 is possible if the disk is a
CDRW that was formatted with "cdrwtool -m 10236".)
The problem is that pktcdvd opens the cd device in non-blocking mode
when pktsetup is run, and doesn't close it again until pktsetup -d is
run. The effect is that if you meanwhile open the cd device,
blkdev.c:do_open() doesn't call bd_set_size() because
bdev->bd_openers is non-zero."
In particular, to repeat the bug (regardless of whether commit
6f5391c283d7fdcf24bf40786ea79061919d1e1d is applied or not):
" 1. Start with an empty drive.
2. pktsetup 0 /dev/scd0
3. Insert a CD containing an isofs filesystem.
4. mount /dev/pktcdvd/0 /mnt/tmp
5. umount /mnt/tmp
6. Press the eject button.
7. Insert a DVD containing a non-writable filesystem.
8. mount /dev/scd0 /mnt/tmp
9. find /mnt/tmp -type f -print0 | xargs -0 sha1sum >/dev/null
10. If the DVD contains data beyond the physical size of a CD, you
get I/O errors in the terminal, and dmesg reports lots of
"attempt to access beyond end of device" errors."
which in turn is because the nested open after the media change won't
cause the size to be set properly (because the original open still holds
the block device, and we only do the bd_set_size() when we don't have
other people holding the device open).
The proper fix for that is probably to just do something like
bdev->bd_inode->i_size = (loff_t)get_capacity(disk)<<9;
in fs/block_dev.c:do_open() even for the cases where we're not the
original opener (but *not* call bd_set_size(), since that will also
change the block size of the device).
Cc: Peter Osterlund <petero2@telia.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-01-06 18:17:12 +00:00
|
|
|
.done = sd_done,
|
2012-02-09 18:48:53 +00:00
|
|
|
.eh_action = sd_eh_action,
|
2017-04-06 13:36:29 +00:00
|
|
|
.eh_reset = sd_eh_reset,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2013-05-10 09:06:16 +00:00
|
|
|
/*
|
2020-10-29 14:58:31 +00:00
|
|
|
* Don't request a new module, as that could deadlock in multipath
|
|
|
|
* environment.
|
2013-05-10 09:06:16 +00:00
|
|
|
*/
|
2020-10-29 14:58:31 +00:00
|
|
|
static void sd_default_probe(dev_t devt)
|
2013-05-10 09:06:16 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Device no to disk mapping:
|
|
|
|
*
|
|
|
|
* major disc2 disc p1
|
|
|
|
* |............|.............|....|....| <- dev_t
|
|
|
|
* 31 20 19 8 7 4 3 0
|
|
|
|
*
|
|
|
|
* Inside a major, we have 16k disks, however mapped non-
|
|
|
|
* contiguously. The first 16 disks are for major0, the next
|
|
|
|
* ones with major1, ... Disk 256 is for major0 again, disk 272
|
|
|
|
* for major1, ...
|
|
|
|
* As we stay compatible with our numbering scheme, we can reuse
|
|
|
|
* the well-know SCSI majors 8, 65--71, 136--143.
|
|
|
|
*/
|
|
|
|
static int sd_major(int major_idx)
|
|
|
|
{
|
|
|
|
switch (major_idx) {
|
|
|
|
case 0:
|
|
|
|
return SCSI_DISK0_MAJOR;
|
|
|
|
case 1 ... 7:
|
|
|
|
return SCSI_DISK1_MAJOR + major_idx - 1;
|
|
|
|
case 8 ... 15:
|
|
|
|
return SCSI_DISK8_MAJOR + major_idx - 8;
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
return 0; /* shut up gcc */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-19 12:26:46 +00:00
|
|
|
#ifdef CONFIG_BLK_SED_OPAL
|
|
|
|
static int sd_sec_submit(void *data, u16 spsp, u8 secp, void *buffer,
|
|
|
|
size_t len, bool send)
|
|
|
|
{
|
2020-10-01 15:35:54 +00:00
|
|
|
struct scsi_disk *sdkp = data;
|
|
|
|
struct scsi_device *sdev = sdkp->device;
|
2017-06-19 12:26:46 +00:00
|
|
|
u8 cdb[12] = { 0, };
|
2022-12-29 19:01:47 +00:00
|
|
|
const struct scsi_exec_args exec_args = {
|
|
|
|
.req_flags = BLK_MQ_REQ_PM,
|
|
|
|
};
|
2017-06-19 12:26:46 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
cdb[0] = send ? SECURITY_PROTOCOL_OUT : SECURITY_PROTOCOL_IN;
|
|
|
|
cdb[1] = secp;
|
|
|
|
put_unaligned_be16(spsp, &cdb[2]);
|
|
|
|
put_unaligned_be32(len, &cdb[6]);
|
|
|
|
|
2022-12-29 19:01:47 +00:00
|
|
|
ret = scsi_execute_cmd(sdev, cdb, send ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN,
|
|
|
|
buffer, len, SD_TIMEOUT, sdkp->max_retries,
|
|
|
|
&exec_args);
|
2017-06-19 12:26:46 +00:00
|
|
|
return ret <= 0 ? ret : -EIO;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_BLK_SED_OPAL */
|
|
|
|
|
2019-01-08 15:14:52 +00:00
|
|
|
/*
|
|
|
|
* Look up the DIX operation based on whether the command is read or
|
|
|
|
* write and whether dix and dif are enabled.
|
|
|
|
*/
|
|
|
|
static unsigned int sd_prot_op(bool write, bool dix, bool dif)
|
|
|
|
{
|
|
|
|
/* Lookup table: bit 2 (write), bit 1 (dix), bit 0 (dif) */
|
|
|
|
static const unsigned int ops[] = { /* wrt dix dif */
|
|
|
|
SCSI_PROT_NORMAL, /* 0 0 0 */
|
|
|
|
SCSI_PROT_READ_STRIP, /* 0 0 1 */
|
|
|
|
SCSI_PROT_READ_INSERT, /* 0 1 0 */
|
|
|
|
SCSI_PROT_READ_PASS, /* 0 1 1 */
|
|
|
|
SCSI_PROT_NORMAL, /* 1 0 0 */
|
|
|
|
SCSI_PROT_WRITE_INSERT, /* 1 0 1 */
|
|
|
|
SCSI_PROT_WRITE_STRIP, /* 1 1 0 */
|
|
|
|
SCSI_PROT_WRITE_PASS, /* 1 1 1 */
|
|
|
|
};
|
|
|
|
|
|
|
|
return ops[write << 2 | dix << 1 | dif];
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns a mask of the protection flags that are valid for a given DIX
|
|
|
|
* operation.
|
|
|
|
*/
|
|
|
|
static unsigned int sd_prot_flag_mask(unsigned int prot_op)
|
|
|
|
{
|
|
|
|
static const unsigned int flag_mask[] = {
|
|
|
|
[SCSI_PROT_NORMAL] = 0,
|
|
|
|
|
|
|
|
[SCSI_PROT_READ_STRIP] = SCSI_PROT_TRANSFER_PI |
|
|
|
|
SCSI_PROT_GUARD_CHECK |
|
|
|
|
SCSI_PROT_REF_CHECK |
|
|
|
|
SCSI_PROT_REF_INCREMENT,
|
|
|
|
|
|
|
|
[SCSI_PROT_READ_INSERT] = SCSI_PROT_REF_INCREMENT |
|
|
|
|
SCSI_PROT_IP_CHECKSUM,
|
|
|
|
|
|
|
|
[SCSI_PROT_READ_PASS] = SCSI_PROT_TRANSFER_PI |
|
|
|
|
SCSI_PROT_GUARD_CHECK |
|
|
|
|
SCSI_PROT_REF_CHECK |
|
|
|
|
SCSI_PROT_REF_INCREMENT |
|
|
|
|
SCSI_PROT_IP_CHECKSUM,
|
|
|
|
|
|
|
|
[SCSI_PROT_WRITE_INSERT] = SCSI_PROT_TRANSFER_PI |
|
|
|
|
SCSI_PROT_REF_INCREMENT,
|
|
|
|
|
|
|
|
[SCSI_PROT_WRITE_STRIP] = SCSI_PROT_GUARD_CHECK |
|
|
|
|
SCSI_PROT_REF_CHECK |
|
|
|
|
SCSI_PROT_REF_INCREMENT |
|
|
|
|
SCSI_PROT_IP_CHECKSUM,
|
|
|
|
|
|
|
|
[SCSI_PROT_WRITE_PASS] = SCSI_PROT_TRANSFER_PI |
|
|
|
|
SCSI_PROT_GUARD_CHECK |
|
|
|
|
SCSI_PROT_REF_CHECK |
|
|
|
|
SCSI_PROT_REF_INCREMENT |
|
|
|
|
SCSI_PROT_IP_CHECKSUM,
|
|
|
|
};
|
|
|
|
|
|
|
|
return flag_mask[prot_op];
|
|
|
|
}
|
|
|
|
|
2014-09-26 23:20:08 +00:00
|
|
|
static unsigned char sd_setup_protect_cmnd(struct scsi_cmnd *scmd,
|
|
|
|
unsigned int dix, unsigned int dif)
|
2009-09-18 21:33:00 +00:00
|
|
|
{
|
2021-08-09 23:03:06 +00:00
|
|
|
struct request *rq = scsi_cmd_to_rq(scmd);
|
|
|
|
struct bio *bio = rq->bio;
|
|
|
|
unsigned int prot_op = sd_prot_op(rq_data_dir(rq), dix, dif);
|
2014-09-26 23:20:08 +00:00
|
|
|
unsigned int protect = 0;
|
|
|
|
|
|
|
|
if (dix) { /* DIX Type 0, 1, 2, 3 */
|
|
|
|
if (bio_integrity_flagged(bio, BIP_IP_CHECKSUM))
|
|
|
|
scmd->prot_flags |= SCSI_PROT_IP_CHECKSUM;
|
|
|
|
|
|
|
|
if (bio_integrity_flagged(bio, BIP_CTRL_NOCHECK) == false)
|
|
|
|
scmd->prot_flags |= SCSI_PROT_GUARD_CHECK;
|
|
|
|
}
|
|
|
|
|
2016-09-11 17:35:41 +00:00
|
|
|
if (dif != T10_PI_TYPE3_PROTECTION) { /* DIX/DIF Type 0, 1, 2 */
|
2014-09-26 23:20:08 +00:00
|
|
|
scmd->prot_flags |= SCSI_PROT_REF_INCREMENT;
|
|
|
|
|
|
|
|
if (bio_integrity_flagged(bio, BIP_CTRL_NOCHECK) == false)
|
|
|
|
scmd->prot_flags |= SCSI_PROT_REF_CHECK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dif) { /* DIX/DIF Type 1, 2, 3 */
|
|
|
|
scmd->prot_flags |= SCSI_PROT_TRANSFER_PI;
|
|
|
|
|
|
|
|
if (bio_integrity_flagged(bio, BIP_DISK_NOCHECK))
|
|
|
|
protect = 3 << 5; /* Disable target PI checking */
|
|
|
|
else
|
|
|
|
protect = 1 << 5; /* Enable target PI checking */
|
2009-09-18 21:33:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
scsi_set_prot_op(scmd, prot_op);
|
|
|
|
scsi_set_prot_type(scmd, dif);
|
2014-09-26 23:20:08 +00:00
|
|
|
scmd->prot_flags &= sd_prot_flag_mask(prot_op);
|
|
|
|
|
|
|
|
return protect;
|
2009-09-18 21:33:00 +00:00
|
|
|
}
|
|
|
|
|
2011-03-08 07:07:15 +00:00
|
|
|
static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
|
|
|
|
{
|
|
|
|
struct request_queue *q = sdkp->disk->queue;
|
|
|
|
unsigned int logical_block_size = sdkp->device->sector_size;
|
|
|
|
unsigned int max_blocks = 0;
|
|
|
|
|
2017-04-05 17:21:25 +00:00
|
|
|
q->limits.discard_alignment =
|
|
|
|
sdkp->unmap_alignment * logical_block_size;
|
|
|
|
q->limits.discard_granularity =
|
|
|
|
max(sdkp->physical_block_size,
|
|
|
|
sdkp->unmap_granularity * logical_block_size);
|
2012-02-13 20:39:00 +00:00
|
|
|
sdkp->provisioning_mode = mode;
|
|
|
|
|
2011-03-08 07:07:15 +00:00
|
|
|
switch (mode) {
|
|
|
|
|
2017-05-25 13:34:30 +00:00
|
|
|
case SD_LBP_FULL:
|
2011-03-08 07:07:15 +00:00
|
|
|
case SD_LBP_DISABLE:
|
2015-07-14 14:15:12 +00:00
|
|
|
blk_queue_max_discard_sectors(q, 0);
|
2011-03-08 07:07:15 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
case SD_LBP_UNMAP:
|
2012-09-18 16:19:32 +00:00
|
|
|
max_blocks = min_not_zero(sdkp->max_unmap_blocks,
|
|
|
|
(u32)SD_MAX_WS16_BLOCKS);
|
2011-03-08 07:07:15 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SD_LBP_WS16:
|
2017-09-28 01:35:12 +00:00
|
|
|
if (sdkp->device->unmap_limit_for_ws)
|
|
|
|
max_blocks = sdkp->max_unmap_blocks;
|
|
|
|
else
|
|
|
|
max_blocks = sdkp->max_ws_blocks;
|
|
|
|
|
|
|
|
max_blocks = min_not_zero(max_blocks, (u32)SD_MAX_WS16_BLOCKS);
|
2011-03-08 07:07:15 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SD_LBP_WS10:
|
2017-09-28 01:35:12 +00:00
|
|
|
if (sdkp->device->unmap_limit_for_ws)
|
|
|
|
max_blocks = sdkp->max_unmap_blocks;
|
|
|
|
else
|
|
|
|
max_blocks = sdkp->max_ws_blocks;
|
|
|
|
|
|
|
|
max_blocks = min_not_zero(max_blocks, (u32)SD_MAX_WS10_BLOCKS);
|
2011-03-08 07:07:15 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SD_LBP_ZERO:
|
2012-09-18 16:19:32 +00:00
|
|
|
max_blocks = min_not_zero(sdkp->max_ws_blocks,
|
|
|
|
(u32)SD_MAX_WS10_BLOCKS);
|
2011-03-08 07:07:15 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-07-14 14:15:12 +00:00
|
|
|
blk_queue_max_discard_sectors(q, max_blocks * (logical_block_size >> 9));
|
2011-03-08 07:07:15 +00:00
|
|
|
}
|
|
|
|
|
2023-02-03 15:06:15 +00:00
|
|
|
static void *sd_set_special_bvec(struct request *rq, unsigned int data_len)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = mempool_alloc(sd_page_pool, GFP_ATOMIC);
|
|
|
|
if (!page)
|
|
|
|
return NULL;
|
|
|
|
clear_highpage(page);
|
|
|
|
bvec_set_page(&rq->special_vec, page, data_len, 0);
|
|
|
|
rq->rq_flags |= RQF_SPECIAL_PAYLOAD;
|
|
|
|
return bvec_virt(&rq->special_vec);
|
|
|
|
}
|
|
|
|
|
2018-11-09 13:42:39 +00:00
|
|
|
static blk_status_t sd_setup_unmap_cmnd(struct scsi_cmnd *cmd)
|
2009-11-26 17:00:40 +00:00
|
|
|
{
|
2014-06-28 10:35:13 +00:00
|
|
|
struct scsi_device *sdp = cmd->device;
|
2021-08-09 23:03:06 +00:00
|
|
|
struct request *rq = scsi_cmd_to_rq(cmd);
|
2021-11-26 12:18:00 +00:00
|
|
|
struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
|
2019-01-16 00:49:58 +00:00
|
|
|
u64 lba = sectors_to_logical(sdp, blk_rq_pos(rq));
|
|
|
|
u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
|
2017-04-05 17:20:59 +00:00
|
|
|
unsigned int data_len = 24;
|
2011-03-08 07:07:15 +00:00
|
|
|
char *buf;
|
2009-11-26 17:00:40 +00:00
|
|
|
|
2023-02-03 15:06:15 +00:00
|
|
|
buf = sd_set_special_bvec(rq, data_len);
|
|
|
|
if (!buf)
|
2018-11-09 13:42:39 +00:00
|
|
|
return BLK_STS_RESOURCE;
|
2010-06-18 14:59:42 +00:00
|
|
|
|
2017-04-05 17:20:59 +00:00
|
|
|
cmd->cmd_len = 10;
|
|
|
|
cmd->cmnd[0] = UNMAP;
|
|
|
|
cmd->cmnd[8] = 24;
|
2009-11-26 17:00:40 +00:00
|
|
|
|
2017-04-05 17:20:59 +00:00
|
|
|
put_unaligned_be16(6 + 16, &buf[0]);
|
|
|
|
put_unaligned_be16(16, &buf[2]);
|
2019-01-16 00:49:58 +00:00
|
|
|
put_unaligned_be64(lba, &buf[8]);
|
|
|
|
put_unaligned_be32(nr_blocks, &buf[16]);
|
2009-11-26 17:00:40 +00:00
|
|
|
|
2020-10-01 15:35:54 +00:00
|
|
|
cmd->allowed = sdkp->max_retries;
|
2017-04-05 17:20:59 +00:00
|
|
|
cmd->transfersize = data_len;
|
|
|
|
rq->timeout = SD_TIMEOUT;
|
2009-11-26 17:00:40 +00:00
|
|
|
|
2020-10-05 08:41:28 +00:00
|
|
|
return scsi_alloc_sgtables(cmd);
|
2017-04-05 17:20:59 +00:00
|
|
|
}
|
2011-03-08 07:07:15 +00:00
|
|
|
|
2018-11-09 13:42:39 +00:00
|
|
|
static blk_status_t sd_setup_write_same16_cmnd(struct scsi_cmnd *cmd,
|
|
|
|
bool unmap)
|
2017-04-05 17:20:59 +00:00
|
|
|
{
|
|
|
|
struct scsi_device *sdp = cmd->device;
|
2021-08-09 23:03:06 +00:00
|
|
|
struct request *rq = scsi_cmd_to_rq(cmd);
|
2021-11-26 12:18:00 +00:00
|
|
|
struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
|
2019-01-16 00:49:58 +00:00
|
|
|
u64 lba = sectors_to_logical(sdp, blk_rq_pos(rq));
|
|
|
|
u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
|
2017-04-05 17:20:59 +00:00
|
|
|
u32 data_len = sdp->sector_size;
|
2011-03-08 07:07:15 +00:00
|
|
|
|
2023-02-03 15:06:15 +00:00
|
|
|
if (!sd_set_special_bvec(rq, data_len))
|
2018-11-09 13:42:39 +00:00
|
|
|
return BLK_STS_RESOURCE;
|
2011-03-08 07:07:15 +00:00
|
|
|
|
2017-04-05 17:20:59 +00:00
|
|
|
cmd->cmd_len = 16;
|
|
|
|
cmd->cmnd[0] = WRITE_SAME_16;
|
2017-04-05 17:21:02 +00:00
|
|
|
if (unmap)
|
2014-06-28 10:35:13 +00:00
|
|
|
cmd->cmnd[1] = 0x8; /* UNMAP */
|
2019-01-16 00:49:58 +00:00
|
|
|
put_unaligned_be64(lba, &cmd->cmnd[2]);
|
|
|
|
put_unaligned_be32(nr_blocks, &cmd->cmnd[10]);
|
2010-06-18 14:59:42 +00:00
|
|
|
|
2020-10-01 15:35:54 +00:00
|
|
|
cmd->allowed = sdkp->max_retries;
|
2017-04-05 17:20:59 +00:00
|
|
|
cmd->transfersize = data_len;
|
2017-04-05 17:21:02 +00:00
|
|
|
rq->timeout = unmap ? SD_TIMEOUT : SD_WRITE_SAME_TIMEOUT;
|
2011-03-08 07:07:15 +00:00
|
|
|
|
2020-10-05 08:41:28 +00:00
|
|
|
return scsi_alloc_sgtables(cmd);
|
2017-04-05 17:20:59 +00:00
|
|
|
}
|
2011-03-08 07:07:15 +00:00
|
|
|
|
2018-11-09 13:42:39 +00:00
|
|
|
static blk_status_t sd_setup_write_same10_cmnd(struct scsi_cmnd *cmd,
|
|
|
|
bool unmap)
|
2017-04-05 17:20:59 +00:00
|
|
|
{
|
|
|
|
struct scsi_device *sdp = cmd->device;
|
2021-08-09 23:03:06 +00:00
|
|
|
struct request *rq = scsi_cmd_to_rq(cmd);
|
2021-11-26 12:18:00 +00:00
|
|
|
struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
|
2019-01-16 00:49:58 +00:00
|
|
|
u64 lba = sectors_to_logical(sdp, blk_rq_pos(rq));
|
|
|
|
u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
|
2017-04-05 17:20:59 +00:00
|
|
|
u32 data_len = sdp->sector_size;
|
2011-03-08 07:07:15 +00:00
|
|
|
|
2023-02-03 15:06:15 +00:00
|
|
|
if (!sd_set_special_bvec(rq, data_len))
|
2018-11-09 13:42:39 +00:00
|
|
|
return BLK_STS_RESOURCE;
|
2009-11-26 17:00:40 +00:00
|
|
|
|
2017-04-05 17:20:59 +00:00
|
|
|
cmd->cmd_len = 10;
|
|
|
|
cmd->cmnd[0] = WRITE_SAME;
|
|
|
|
if (unmap)
|
|
|
|
cmd->cmnd[1] = 0x8; /* UNMAP */
|
2019-01-16 00:49:58 +00:00
|
|
|
put_unaligned_be32(lba, &cmd->cmnd[2]);
|
|
|
|
put_unaligned_be16(nr_blocks, &cmd->cmnd[7]);
|
2014-06-28 10:35:13 +00:00
|
|
|
|
2020-10-01 15:35:54 +00:00
|
|
|
cmd->allowed = sdkp->max_retries;
|
2017-04-05 17:20:59 +00:00
|
|
|
cmd->transfersize = data_len;
|
2017-04-05 17:21:02 +00:00
|
|
|
rq->timeout = unmap ? SD_TIMEOUT : SD_WRITE_SAME_TIMEOUT;
|
2014-06-28 10:35:13 +00:00
|
|
|
|
2020-10-05 08:41:28 +00:00
|
|
|
return scsi_alloc_sgtables(cmd);
|
2010-07-01 10:49:18 +00:00
|
|
|
}
|
2016-12-08 22:20:32 +00:00
|
|
|
|
2018-11-09 13:42:39 +00:00
|
|
|
static blk_status_t sd_setup_write_zeroes_cmnd(struct scsi_cmnd *cmd)
|
2017-04-05 17:21:02 +00:00
|
|
|
{
|
2021-08-09 23:03:06 +00:00
|
|
|
struct request *rq = scsi_cmd_to_rq(cmd);
|
2017-04-05 17:21:02 +00:00
|
|
|
struct scsi_device *sdp = cmd->device;
|
2021-11-26 12:18:00 +00:00
|
|
|
struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
|
2019-01-16 00:49:58 +00:00
|
|
|
u64 lba = sectors_to_logical(sdp, blk_rq_pos(rq));
|
|
|
|
u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
|
2017-04-05 17:21:02 +00:00
|
|
|
|
2017-04-05 17:21:12 +00:00
|
|
|
if (!(rq->cmd_flags & REQ_NOUNMAP)) {
|
2017-04-05 17:21:24 +00:00
|
|
|
switch (sdkp->zeroing_mode) {
|
|
|
|
case SD_ZERO_WS16_UNMAP:
|
2017-12-21 06:43:44 +00:00
|
|
|
return sd_setup_write_same16_cmnd(cmd, true);
|
2017-04-05 17:21:24 +00:00
|
|
|
case SD_ZERO_WS10_UNMAP:
|
2017-12-21 06:43:44 +00:00
|
|
|
return sd_setup_write_same10_cmnd(cmd, true);
|
2017-04-05 17:21:12 +00:00
|
|
|
}
|
|
|
|
}
|
2011-03-08 07:07:15 +00:00
|
|
|
|
2020-12-07 22:10:21 +00:00
|
|
|
if (sdp->no_write_same) {
|
|
|
|
rq->rq_flags |= RQF_QUIET;
|
2018-11-09 13:42:39 +00:00
|
|
|
return BLK_STS_TARGET;
|
2020-12-07 22:10:21 +00:00
|
|
|
}
|
2017-05-08 06:48:19 +00:00
|
|
|
|
2019-01-16 00:49:58 +00:00
|
|
|
if (sdkp->ws16 || lba > 0xffffffff || nr_blocks > 0xffff)
|
2017-12-21 06:43:44 +00:00
|
|
|
return sd_setup_write_same16_cmnd(cmd, false);
|
2017-05-08 06:48:19 +00:00
|
|
|
|
2017-12-21 06:43:44 +00:00
|
|
|
return sd_setup_write_same10_cmnd(cmd, false);
|
2010-07-01 10:49:18 +00:00
|
|
|
}
|
|
|
|
|
2012-09-18 16:19:32 +00:00
|
|
|
static void sd_config_write_same(struct scsi_disk *sdkp)
|
|
|
|
{
|
|
|
|
struct request_queue *q = sdkp->disk->queue;
|
|
|
|
unsigned int logical_block_size = sdkp->device->sector_size;
|
|
|
|
|
|
|
|
if (sdkp->device->no_write_same) {
|
|
|
|
sdkp->max_ws_blocks = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Some devices can not handle block counts above 0xffff despite
|
|
|
|
* supporting WRITE SAME(16). Consequently we default to 64k
|
|
|
|
* blocks per I/O unless the device explicitly advertises a
|
|
|
|
* bigger limit.
|
|
|
|
*/
|
2013-06-07 02:15:55 +00:00
|
|
|
if (sdkp->max_ws_blocks > SD_MAX_WS10_BLOCKS)
|
|
|
|
sdkp->max_ws_blocks = min_not_zero(sdkp->max_ws_blocks,
|
|
|
|
(u32)SD_MAX_WS16_BLOCKS);
|
|
|
|
else if (sdkp->ws16 || sdkp->ws10 || sdkp->device->no_report_opcodes)
|
|
|
|
sdkp->max_ws_blocks = min_not_zero(sdkp->max_ws_blocks,
|
|
|
|
(u32)SD_MAX_WS10_BLOCKS);
|
|
|
|
else {
|
|
|
|
sdkp->device->no_write_same = 1;
|
|
|
|
sdkp->max_ws_blocks = 0;
|
|
|
|
}
|
2012-09-18 16:19:32 +00:00
|
|
|
|
2017-04-05 17:21:24 +00:00
|
|
|
if (sdkp->lbprz && sdkp->lbpws)
|
|
|
|
sdkp->zeroing_mode = SD_ZERO_WS16_UNMAP;
|
|
|
|
else if (sdkp->lbprz && sdkp->lbpws10)
|
|
|
|
sdkp->zeroing_mode = SD_ZERO_WS10_UNMAP;
|
|
|
|
else if (sdkp->max_ws_blocks)
|
|
|
|
sdkp->zeroing_mode = SD_ZERO_WS;
|
|
|
|
else
|
|
|
|
sdkp->zeroing_mode = SD_ZERO_WRITE;
|
|
|
|
|
2017-09-05 11:55:35 +00:00
|
|
|
if (sdkp->max_ws_blocks &&
|
|
|
|
sdkp->physical_block_size > logical_block_size) {
|
|
|
|
/*
|
|
|
|
* Reporting a maximum number of blocks that is not aligned
|
|
|
|
* on the device physical size would cause a large write same
|
|
|
|
* request to be split into physically unaligned chunks by
|
2022-02-09 08:28:25 +00:00
|
|
|
* __blkdev_issue_write_zeroes() even if the caller of this
|
|
|
|
* functions took care to align the large request. So make sure
|
|
|
|
* the maximum reported is aligned to the device physical block
|
|
|
|
* size. This is only an optional optimization for regular
|
|
|
|
* disks, but this is mandatory to avoid failure of large write
|
|
|
|
* same requests directed at sequential write required zones of
|
|
|
|
* host-managed ZBC disks.
|
2017-09-05 11:55:35 +00:00
|
|
|
*/
|
|
|
|
sdkp->max_ws_blocks =
|
|
|
|
round_down(sdkp->max_ws_blocks,
|
|
|
|
bytes_to_logical(sdkp->device,
|
|
|
|
sdkp->physical_block_size));
|
|
|
|
}
|
|
|
|
|
2012-09-18 16:19:32 +00:00
|
|
|
out:
|
2017-04-05 17:21:02 +00:00
|
|
|
blk_queue_max_write_zeroes_sectors(q, sdkp->max_ws_blocks *
|
|
|
|
(logical_block_size >> 9));
|
2012-09-18 16:19:32 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 13:42:39 +00:00
|
|
|
static blk_status_t sd_setup_flush_cmnd(struct scsi_cmnd *cmd)
|
2010-07-03 08:45:34 +00:00
|
|
|
{
|
2021-08-09 23:03:06 +00:00
|
|
|
struct request *rq = scsi_cmd_to_rq(cmd);
|
2021-11-26 12:18:00 +00:00
|
|
|
struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
|
2014-06-28 10:08:05 +00:00
|
|
|
|
|
|
|
/* flush requests don't perform I/O, zero the S/G table */
|
|
|
|
memset(&cmd->sdb, 0, sizeof(cmd->sdb));
|
2010-07-03 08:45:34 +00:00
|
|
|
|
2022-11-15 00:29:05 +00:00
|
|
|
if (cmd->device->use_16_for_sync) {
|
|
|
|
cmd->cmnd[0] = SYNCHRONIZE_CACHE_16;
|
|
|
|
cmd->cmd_len = 16;
|
|
|
|
} else {
|
|
|
|
cmd->cmnd[0] = SYNCHRONIZE_CACHE;
|
|
|
|
cmd->cmd_len = 10;
|
|
|
|
}
|
2014-06-28 10:08:05 +00:00
|
|
|
cmd->transfersize = 0;
|
2020-10-01 15:35:54 +00:00
|
|
|
cmd->allowed = sdkp->max_retries;
|
2014-06-28 10:08:05 +00:00
|
|
|
|
2014-07-18 15:11:27 +00:00
|
|
|
rq->timeout = rq->q->rq_timeout * SD_FLUSH_TIMEOUT_MULTIPLIER;
|
2018-11-09 13:42:39 +00:00
|
|
|
return BLK_STS_OK;
|
2010-07-03 08:45:34 +00:00
|
|
|
}
|
|
|
|
|
2019-01-16 00:50:00 +00:00
|
|
|
static blk_status_t sd_setup_rw32_cmnd(struct scsi_cmnd *cmd, bool write,
|
|
|
|
sector_t lba, unsigned int nr_blocks,
|
|
|
|
unsigned char flags)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2019-01-16 00:50:00 +00:00
|
|
|
cmd->cmd_len = SD_EXT_CDB_SIZE;
|
|
|
|
cmd->cmnd[0] = VARIABLE_LENGTH_CMD;
|
|
|
|
cmd->cmnd[7] = 0x18; /* Additional CDB len */
|
|
|
|
cmd->cmnd[9] = write ? WRITE_32 : READ_32;
|
|
|
|
cmd->cmnd[10] = flags;
|
|
|
|
put_unaligned_be64(lba, &cmd->cmnd[12]);
|
|
|
|
put_unaligned_be32(lba, &cmd->cmnd[20]); /* Expected Indirect LBA */
|
|
|
|
put_unaligned_be32(nr_blocks, &cmd->cmnd[28]);
|
|
|
|
|
|
|
|
return BLK_STS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static blk_status_t sd_setup_rw16_cmnd(struct scsi_cmnd *cmd, bool write,
|
|
|
|
sector_t lba, unsigned int nr_blocks,
|
|
|
|
unsigned char flags)
|
|
|
|
{
|
|
|
|
cmd->cmd_len = 16;
|
|
|
|
cmd->cmnd[0] = write ? WRITE_16 : READ_16;
|
|
|
|
cmd->cmnd[1] = flags;
|
|
|
|
cmd->cmnd[14] = 0;
|
|
|
|
cmd->cmnd[15] = 0;
|
|
|
|
put_unaligned_be64(lba, &cmd->cmnd[2]);
|
|
|
|
put_unaligned_be32(nr_blocks, &cmd->cmnd[10]);
|
|
|
|
|
|
|
|
return BLK_STS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static blk_status_t sd_setup_rw10_cmnd(struct scsi_cmnd *cmd, bool write,
|
|
|
|
sector_t lba, unsigned int nr_blocks,
|
|
|
|
unsigned char flags)
|
|
|
|
{
|
|
|
|
cmd->cmd_len = 10;
|
|
|
|
cmd->cmnd[0] = write ? WRITE_10 : READ_10;
|
|
|
|
cmd->cmnd[1] = flags;
|
|
|
|
cmd->cmnd[6] = 0;
|
|
|
|
cmd->cmnd[9] = 0;
|
|
|
|
put_unaligned_be32(lba, &cmd->cmnd[2]);
|
|
|
|
put_unaligned_be16(nr_blocks, &cmd->cmnd[7]);
|
|
|
|
|
|
|
|
return BLK_STS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static blk_status_t sd_setup_rw6_cmnd(struct scsi_cmnd *cmd, bool write,
|
|
|
|
sector_t lba, unsigned int nr_blocks,
|
|
|
|
unsigned char flags)
|
|
|
|
{
|
2019-01-23 19:12:37 +00:00
|
|
|
/* Avoid that 0 blocks gets translated into 256 blocks. */
|
|
|
|
if (WARN_ON_ONCE(nr_blocks == 0))
|
|
|
|
return BLK_STS_IOERR;
|
|
|
|
|
2019-01-16 00:50:00 +00:00
|
|
|
if (unlikely(flags & 0x8)) {
|
|
|
|
/*
|
|
|
|
* This happens only if this drive failed 10byte rw
|
|
|
|
* command with ILLEGAL_REQUEST during operation and
|
|
|
|
* thus turned off use_10_for_rw.
|
|
|
|
*/
|
|
|
|
scmd_printk(KERN_ERR, cmd, "FUA write on READ/WRITE(6) drive\n");
|
|
|
|
return BLK_STS_IOERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
cmd->cmd_len = 6;
|
|
|
|
cmd->cmnd[0] = write ? WRITE_6 : READ_6;
|
|
|
|
cmd->cmnd[1] = (lba >> 16) & 0x1f;
|
|
|
|
cmd->cmnd[2] = (lba >> 8) & 0xff;
|
|
|
|
cmd->cmnd[3] = lba & 0xff;
|
|
|
|
cmd->cmnd[4] = nr_blocks;
|
|
|
|
cmd->cmnd[5] = 0;
|
|
|
|
|
|
|
|
return BLK_STS_OK;
|
|
|
|
}
|
|
|
|
|
2019-01-16 00:50:02 +00:00
|
|
|
static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2021-08-09 23:03:06 +00:00
|
|
|
struct request *rq = scsi_cmd_to_rq(cmd);
|
2019-01-16 00:50:02 +00:00
|
|
|
struct scsi_device *sdp = cmd->device;
|
2021-11-26 12:18:00 +00:00
|
|
|
struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
|
2019-01-16 00:49:59 +00:00
|
|
|
sector_t lba = sectors_to_logical(sdp, blk_rq_pos(rq));
|
2008-08-06 04:42:21 +00:00
|
|
|
sector_t threshold;
|
2019-01-16 00:49:59 +00:00
|
|
|
unsigned int nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
|
|
|
|
unsigned int mask = logical_to_sectors(sdp, 1) - 1;
|
2019-01-16 00:50:00 +00:00
|
|
|
bool write = rq_data_dir(rq) == WRITE;
|
|
|
|
unsigned char protect, fua;
|
2018-11-09 13:42:39 +00:00
|
|
|
blk_status_t ret;
|
2019-10-22 06:27:08 +00:00
|
|
|
unsigned int dif;
|
|
|
|
bool dix;
|
2007-08-04 15:06:25 +00:00
|
|
|
|
2020-10-05 08:41:28 +00:00
|
|
|
ret = scsi_alloc_sgtables(cmd);
|
2018-11-09 13:42:39 +00:00
|
|
|
if (ret != BLK_STS_OK)
|
2017-12-21 06:43:44 +00:00
|
|
|
return ret;
|
2007-08-04 15:06:25 +00:00
|
|
|
|
2020-10-05 08:41:28 +00:00
|
|
|
ret = BLK_STS_IOERR;
|
2019-01-16 00:50:01 +00:00
|
|
|
if (!scsi_device_online(sdp) || sdp->changed) {
|
2019-01-16 00:50:02 +00:00
|
|
|
scmd_printk(KERN_ERR, cmd, "device offline or changed\n");
|
2020-10-05 08:41:28 +00:00
|
|
|
goto fail;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2021-11-26 12:18:00 +00:00
|
|
|
if (blk_rq_pos(rq) + blk_rq_sectors(rq) > get_capacity(rq->q->disk)) {
|
2019-01-16 00:50:02 +00:00
|
|
|
scmd_printk(KERN_ERR, cmd, "access beyond end of device\n");
|
2020-10-05 08:41:28 +00:00
|
|
|
goto fail;
|
2019-01-16 00:50:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((blk_rq_pos(rq) & mask) || (blk_rq_sectors(rq) & mask)) {
|
2019-01-16 00:50:02 +00:00
|
|
|
scmd_printk(KERN_ERR, cmd, "request not aligned to the logical block size\n");
|
2020-10-05 08:41:28 +00:00
|
|
|
goto fail;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-08-04 15:06:25 +00:00
|
|
|
|
2008-01-20 10:12:26 +00:00
|
|
|
/*
|
2019-01-16 00:49:59 +00:00
|
|
|
* Some SD card readers can't handle accesses which touch the
|
|
|
|
* last one or two logical blocks. Split accesses as needed.
|
2008-01-20 10:12:26 +00:00
|
|
|
*/
|
2019-01-16 00:49:59 +00:00
|
|
|
threshold = sdkp->capacity - SD_LAST_BUGGY_SECTORS;
|
2008-08-06 04:42:21 +00:00
|
|
|
|
2019-01-16 00:49:58 +00:00
|
|
|
if (unlikely(sdp->last_sector_bug && lba + nr_blocks > threshold)) {
|
|
|
|
if (lba < threshold) {
|
2008-08-06 04:42:21 +00:00
|
|
|
/* Access up to the threshold but not beyond */
|
2019-01-16 00:49:58 +00:00
|
|
|
nr_blocks = threshold - lba;
|
2008-08-06 04:42:21 +00:00
|
|
|
} else {
|
2019-01-16 00:49:59 +00:00
|
|
|
/* Access only a single logical block */
|
|
|
|
nr_blocks = 1;
|
2008-08-06 04:42:21 +00:00
|
|
|
}
|
|
|
|
}
|
2008-01-20 10:12:26 +00:00
|
|
|
|
2020-05-12 08:55:51 +00:00
|
|
|
if (req_op(rq) == REQ_OP_ZONE_APPEND) {
|
|
|
|
ret = sd_zbc_prepare_zone_append(cmd, &lba, nr_blocks);
|
|
|
|
if (ret)
|
2020-10-05 08:41:28 +00:00
|
|
|
goto fail;
|
2020-05-12 08:55:51 +00:00
|
|
|
}
|
|
|
|
|
2019-01-16 00:50:00 +00:00
|
|
|
fua = rq->cmd_flags & REQ_FUA ? 0x8 : 0;
|
2019-01-16 00:50:02 +00:00
|
|
|
dix = scsi_prot_sg_count(cmd);
|
|
|
|
dif = scsi_host_dif_capable(cmd->device->host, sdkp->protection_type);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-09-26 23:20:08 +00:00
|
|
|
if (dif || dix)
|
2019-01-16 00:50:02 +00:00
|
|
|
protect = sd_setup_protect_cmnd(cmd, dix, dif);
|
2008-07-17 08:28:35 +00:00
|
|
|
else
|
2009-09-20 20:49:38 +00:00
|
|
|
protect = 0;
|
|
|
|
|
2016-09-11 17:35:41 +00:00
|
|
|
if (protect && sdkp->protection_type == T10_PI_TYPE2_PROTECTION) {
|
2019-01-16 00:50:02 +00:00
|
|
|
ret = sd_setup_rw32_cmnd(cmd, write, lba, nr_blocks,
|
2019-01-16 00:50:00 +00:00
|
|
|
protect | fua);
|
2019-01-16 00:49:58 +00:00
|
|
|
} else if (sdp->use_16_for_rw || (nr_blocks > 0xffff)) {
|
2019-01-16 00:50:02 +00:00
|
|
|
ret = sd_setup_rw16_cmnd(cmd, write, lba, nr_blocks,
|
2019-01-16 00:50:00 +00:00
|
|
|
protect | fua);
|
2019-01-16 00:49:58 +00:00
|
|
|
} else if ((nr_blocks > 0xff) || (lba > 0x1fffff) ||
|
2019-01-16 00:50:01 +00:00
|
|
|
sdp->use_10_for_rw || protect) {
|
2019-01-16 00:50:02 +00:00
|
|
|
ret = sd_setup_rw10_cmnd(cmd, write, lba, nr_blocks,
|
2019-01-16 00:50:00 +00:00
|
|
|
protect | fua);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2019-01-16 00:50:02 +00:00
|
|
|
ret = sd_setup_rw6_cmnd(cmd, write, lba, nr_blocks,
|
2019-01-16 00:50:00 +00:00
|
|
|
protect | fua);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2019-01-16 00:50:00 +00:00
|
|
|
|
|
|
|
if (unlikely(ret != BLK_STS_OK))
|
2020-10-05 08:41:28 +00:00
|
|
|
goto fail;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We shouldn't disconnect in the middle of a sector, so with a dumb
|
|
|
|
* host adapter, it's safe to assume that we can at least transfer
|
|
|
|
* this many bytes between each connect / disconnect.
|
|
|
|
*/
|
2019-01-16 00:50:02 +00:00
|
|
|
cmd->transfersize = sdp->sector_size;
|
|
|
|
cmd->underflow = nr_blocks << 9;
|
2020-10-01 15:35:54 +00:00
|
|
|
cmd->allowed = sdkp->max_retries;
|
2019-01-16 00:50:02 +00:00
|
|
|
cmd->sdb.length = nr_blocks * sdp->sector_size;
|
2019-01-16 00:50:01 +00:00
|
|
|
|
|
|
|
SCSI_LOG_HLQUEUE(1,
|
2019-01-16 00:50:02 +00:00
|
|
|
scmd_printk(KERN_INFO, cmd,
|
2019-01-16 00:50:01 +00:00
|
|
|
"%s: block=%llu, count=%d\n", __func__,
|
|
|
|
(unsigned long long)blk_rq_pos(rq),
|
|
|
|
blk_rq_sectors(rq)));
|
|
|
|
SCSI_LOG_HLQUEUE(2,
|
2019-01-16 00:50:02 +00:00
|
|
|
scmd_printk(KERN_INFO, cmd,
|
2019-01-16 00:50:01 +00:00
|
|
|
"%s %d/%u 512 byte blocks.\n",
|
|
|
|
write ? "writing" : "reading", nr_blocks,
|
|
|
|
blk_rq_sectors(rq)));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2020-10-05 08:41:28 +00:00
|
|
|
* This indicates that the command is ready from our end to be queued.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2018-11-09 13:42:39 +00:00
|
|
|
return BLK_STS_OK;
|
2020-10-05 08:41:28 +00:00
|
|
|
fail:
|
|
|
|
scsi_free_sgtables(cmd);
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2018-11-09 13:42:39 +00:00
|
|
|
static blk_status_t sd_init_command(struct scsi_cmnd *cmd)
|
2014-06-28 10:40:18 +00:00
|
|
|
{
|
2021-08-09 23:03:06 +00:00
|
|
|
struct request *rq = scsi_cmd_to_rq(cmd);
|
2014-06-28 10:40:18 +00:00
|
|
|
|
2016-06-05 19:32:17 +00:00
|
|
|
switch (req_op(rq)) {
|
|
|
|
case REQ_OP_DISCARD:
|
2021-11-26 12:18:00 +00:00
|
|
|
switch (scsi_disk(rq->q->disk)->provisioning_mode) {
|
2017-04-05 17:20:59 +00:00
|
|
|
case SD_LBP_UNMAP:
|
|
|
|
return sd_setup_unmap_cmnd(cmd);
|
|
|
|
case SD_LBP_WS16:
|
2017-04-05 17:21:02 +00:00
|
|
|
return sd_setup_write_same16_cmnd(cmd, true);
|
2017-04-05 17:20:59 +00:00
|
|
|
case SD_LBP_WS10:
|
|
|
|
return sd_setup_write_same10_cmnd(cmd, true);
|
|
|
|
case SD_LBP_ZERO:
|
|
|
|
return sd_setup_write_same10_cmnd(cmd, false);
|
|
|
|
default:
|
2018-11-09 13:42:39 +00:00
|
|
|
return BLK_STS_TARGET;
|
2017-04-05 17:20:59 +00:00
|
|
|
}
|
2017-04-05 17:21:02 +00:00
|
|
|
case REQ_OP_WRITE_ZEROES:
|
|
|
|
return sd_setup_write_zeroes_cmnd(cmd);
|
2016-06-05 19:32:23 +00:00
|
|
|
case REQ_OP_FLUSH:
|
2014-06-28 10:40:18 +00:00
|
|
|
return sd_setup_flush_cmnd(cmd);
|
2016-06-05 19:32:17 +00:00
|
|
|
case REQ_OP_READ:
|
|
|
|
case REQ_OP_WRITE:
|
2020-05-12 08:55:51 +00:00
|
|
|
case REQ_OP_ZONE_APPEND:
|
2014-06-28 10:40:18 +00:00
|
|
|
return sd_setup_read_write_cmnd(cmd);
|
2016-10-18 06:40:34 +00:00
|
|
|
case REQ_OP_ZONE_RESET:
|
2019-10-27 14:05:47 +00:00
|
|
|
return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_RESET_WRITE_POINTER,
|
|
|
|
false);
|
2019-08-01 17:26:37 +00:00
|
|
|
case REQ_OP_ZONE_RESET_ALL:
|
2019-10-27 14:05:47 +00:00
|
|
|
return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_RESET_WRITE_POINTER,
|
|
|
|
true);
|
|
|
|
case REQ_OP_ZONE_OPEN:
|
|
|
|
return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_OPEN_ZONE, false);
|
|
|
|
case REQ_OP_ZONE_CLOSE:
|
|
|
|
return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_CLOSE_ZONE, false);
|
|
|
|
case REQ_OP_ZONE_FINISH:
|
|
|
|
return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_FINISH_ZONE, false);
|
2016-06-05 19:32:17 +00:00
|
|
|
default:
|
2018-09-21 07:01:01 +00:00
|
|
|
WARN_ON_ONCE(1);
|
2018-11-09 13:42:39 +00:00
|
|
|
return BLK_STS_NOTSUPP;
|
2016-06-05 19:32:17 +00:00
|
|
|
}
|
2014-06-28 10:40:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sd_uninit_command(struct scsi_cmnd *SCpnt)
|
|
|
|
{
|
2021-08-09 23:03:06 +00:00
|
|
|
struct request *rq = scsi_cmd_to_rq(SCpnt);
|
2014-06-28 10:40:18 +00:00
|
|
|
|
2016-12-08 22:20:32 +00:00
|
|
|
if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
|
2018-12-12 13:46:55 +00:00
|
|
|
mempool_free(rq->special_vec.bv_page, sd_page_pool);
|
2014-06-28 10:40:18 +00:00
|
|
|
}
|
|
|
|
|
2023-06-08 11:02:35 +00:00
|
|
|
static bool sd_need_revalidate(struct gendisk *disk, struct scsi_disk *sdkp)
|
2021-06-17 11:55:04 +00:00
|
|
|
{
|
|
|
|
if (sdkp->device->removable || sdkp->write_prot) {
|
2023-06-08 11:02:35 +00:00
|
|
|
if (disk_check_media_change(disk))
|
2021-06-17 11:55:04 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Force a full rescan after ioctl(BLKRRPART). While the disk state has
|
|
|
|
* nothing to do with partitions, BLKRRPART is used to force a full
|
|
|
|
* revalidate after things like a format for historical reasons.
|
|
|
|
*/
|
2023-06-08 11:02:35 +00:00
|
|
|
return test_bit(GD_NEED_PART_SCAN, &disk->state);
|
2021-06-17 11:55:04 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* sd_open - open a scsi disk device
|
2023-06-08 11:02:36 +00:00
|
|
|
* @disk: disk to open
|
2023-06-08 11:02:55 +00:00
|
|
|
* @mode: open mode
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Returns 0 if successful. Returns a negated errno value in case
|
|
|
|
* of error.
|
|
|
|
*
|
|
|
|
* Note: This can be called from a user context (e.g. fsck(1) )
|
|
|
|
* or from within the kernel (e.g. as a result of a mount(1) ).
|
|
|
|
* In the latter case @inode and @filp carry an abridged amount
|
|
|
|
* of information as noted above.
|
2010-07-07 14:51:29 +00:00
|
|
|
*
|
2023-06-08 11:02:36 +00:00
|
|
|
* Locking: called with disk->open_mutex held.
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2023-06-08 11:02:55 +00:00
|
|
|
static int sd_open(struct gendisk *disk, blk_mode_t mode)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2023-06-08 11:02:36 +00:00
|
|
|
struct scsi_disk *sdkp = scsi_disk(disk);
|
2022-03-08 05:51:53 +00:00
|
|
|
struct scsi_device *sdev = sdkp->device;
|
2005-04-16 22:20:36 +00:00
|
|
|
int retval;
|
|
|
|
|
2022-03-08 05:51:53 +00:00
|
|
|
if (scsi_device_get(sdev))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENXIO;
|
|
|
|
|
2007-02-28 03:41:19 +00:00
|
|
|
SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the device is in error recovery, wait until it is done.
|
|
|
|
* If the device is offline, then disallow any access to it.
|
|
|
|
*/
|
|
|
|
retval = -ENXIO;
|
|
|
|
if (!scsi_block_when_processing_errors(sdev))
|
|
|
|
goto error_out;
|
|
|
|
|
2023-06-08 11:02:36 +00:00
|
|
|
if (sd_need_revalidate(disk, sdkp))
|
|
|
|
sd_revalidate_disk(disk);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the drive is empty, just let the open fail.
|
|
|
|
*/
|
|
|
|
retval = -ENOMEDIUM;
|
2023-06-08 11:02:55 +00:00
|
|
|
if (sdev->removable && !sdkp->media_present &&
|
|
|
|
!(mode & BLK_OPEN_NDELAY))
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the device has the write protect tab set, have the open fail
|
|
|
|
* if the user expects to be able to write to the thing.
|
|
|
|
*/
|
|
|
|
retval = -EROFS;
|
2023-06-08 11:02:55 +00:00
|
|
|
if (sdkp->write_prot && (mode & BLK_OPEN_WRITE))
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It is possible that the disk changing stuff resulted in
|
|
|
|
* the device being taken offline. If this is the case,
|
|
|
|
* report this to the user, and don't pretend that the
|
|
|
|
* open actually succeeded.
|
|
|
|
*/
|
|
|
|
retval = -ENXIO;
|
|
|
|
if (!scsi_device_online(sdev))
|
|
|
|
goto error_out;
|
|
|
|
|
2010-07-07 14:51:29 +00:00
|
|
|
if ((atomic_inc_return(&sdkp->openers) == 1) && sdev->removable) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (scsi_block_when_processing_errors(sdev))
|
|
|
|
scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error_out:
|
2022-03-08 05:51:53 +00:00
|
|
|
scsi_device_put(sdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sd_release - invoked when the (last) close(2) is called on this
|
|
|
|
* scsi disk.
|
2017-04-24 07:51:09 +00:00
|
|
|
* @disk: disk to release
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Returns 0.
|
|
|
|
*
|
|
|
|
* Note: may block (uninterruptible) if error recovery is underway
|
|
|
|
* on this disk.
|
2010-07-07 14:51:29 +00:00
|
|
|
*
|
2023-06-08 11:02:55 +00:00
|
|
|
* Locking: called with disk->open_mutex held.
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2023-06-08 11:02:37 +00:00
|
|
|
static void sd_release(struct gendisk *disk)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = scsi_disk(disk);
|
|
|
|
struct scsi_device *sdev = sdkp->device;
|
|
|
|
|
2007-03-11 17:25:33 +00:00
|
|
|
SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n"));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-07 15:27:52 +00:00
|
|
|
if (atomic_dec_return(&sdkp->openers) == 0 && sdev->removable) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (scsi_block_when_processing_errors(sdev))
|
|
|
|
scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
|
|
|
|
}
|
|
|
|
|
2022-03-08 05:51:53 +00:00
|
|
|
scsi_device_put(sdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-01-08 09:02:50 +00:00
|
|
|
static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
struct Scsi_Host *host = sdp->host;
|
2016-03-29 01:18:56 +00:00
|
|
|
sector_t capacity = logical_to_sectors(sdp, sdkp->capacity);
|
2005-04-16 22:20:36 +00:00
|
|
|
int diskinfo[4];
|
|
|
|
|
|
|
|
/* default to most commonly used values */
|
2016-03-29 01:18:56 +00:00
|
|
|
diskinfo[0] = 0x40; /* 1 << 6 */
|
|
|
|
diskinfo[1] = 0x20; /* 1 << 5 */
|
|
|
|
diskinfo[2] = capacity >> 11;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* override with calculated, extended default, or driver values */
|
|
|
|
if (host->hostt->bios_param)
|
2016-03-29 01:18:56 +00:00
|
|
|
host->hostt->bios_param(sdp, bdev, capacity, diskinfo);
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
2016-03-29 01:18:56 +00:00
|
|
|
scsicam_bios_param(bdev, capacity, diskinfo);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-08 09:02:50 +00:00
|
|
|
geo->heads = diskinfo[0];
|
|
|
|
geo->sectors = diskinfo[1];
|
|
|
|
geo->cylinders = diskinfo[2];
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2021-07-24 07:20:12 +00:00
|
|
|
* sd_ioctl - process an ioctl
|
2017-04-24 07:51:09 +00:00
|
|
|
* @bdev: target block device
|
2023-06-08 11:02:55 +00:00
|
|
|
* @mode: open mode
|
2005-04-16 22:20:36 +00:00
|
|
|
* @cmd: ioctl command number
|
2021-07-24 07:20:12 +00:00
|
|
|
* @arg: this is third argument given to ioctl(2) system call.
|
2005-04-16 22:20:36 +00:00
|
|
|
* Often contains a pointer.
|
|
|
|
*
|
2011-03-31 01:57:33 +00:00
|
|
|
* Returns 0 if successful (some ioctls return positive numbers on
|
2005-04-16 22:20:36 +00:00
|
|
|
* success as well). Returns a negated errno value in case of error.
|
|
|
|
*
|
|
|
|
* Note: most ioctls are forward onto the block subsystem or further
|
2007-10-19 21:10:43 +00:00
|
|
|
* down in the scsi subsystem.
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
2023-06-08 11:02:55 +00:00
|
|
|
static int sd_ioctl(struct block_device *bdev, blk_mode_t mode,
|
2021-07-24 07:20:12 +00:00
|
|
|
unsigned int cmd, unsigned long arg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct gendisk *disk = bdev->bd_disk;
|
2011-08-25 09:04:14 +00:00
|
|
|
struct scsi_disk *sdkp = scsi_disk(disk);
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2021-07-24 07:20:12 +00:00
|
|
|
void __user *p = (void __user *)arg;
|
2005-04-16 22:20:36 +00:00
|
|
|
int error;
|
|
|
|
|
2011-08-25 09:04:14 +00:00
|
|
|
SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp, "sd_ioctl: disk=%s, "
|
|
|
|
"cmd=0x%x\n", disk->disk_name, cmd));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-07-24 07:20:19 +00:00
|
|
|
if (bdev_is_partition(bdev) && !capable(CAP_SYS_RAWIO))
|
|
|
|
return -ENOIOCTLCMD;
|
2012-01-12 15:01:28 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* If we are in the middle of error recovery, don't let anyone
|
|
|
|
* else try and use this device. Also, if error recovery fails, it
|
|
|
|
* may try and take the device offline, in which case all further
|
|
|
|
* access to the device is prohibited.
|
|
|
|
*/
|
2014-10-11 14:25:31 +00:00
|
|
|
error = scsi_ioctl_block_when_processing_errors(sdp, cmd,
|
2023-06-08 11:02:55 +00:00
|
|
|
(mode & BLK_OPEN_NDELAY));
|
2014-10-11 14:25:31 +00:00
|
|
|
if (error)
|
2021-07-24 07:20:12 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-19 12:26:46 +00:00
|
|
|
if (is_sed_ioctl(cmd))
|
|
|
|
return sed_ioctl(sdkp->opal_dev, cmd, p);
|
2023-06-08 11:02:55 +00:00
|
|
|
return scsi_ioctl(sdp, mode & BLK_OPEN_WRITE, cmd, p);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void set_media_not_present(struct scsi_disk *sdkp)
|
|
|
|
{
|
2010-12-18 17:42:23 +00:00
|
|
|
if (sdkp->media_present)
|
|
|
|
sdkp->device->changed = 1;
|
|
|
|
|
|
|
|
if (sdkp->device->removable) {
|
|
|
|
sdkp->media_present = 0;
|
|
|
|
sdkp->capacity = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int media_not_present(struct scsi_disk *sdkp,
|
|
|
|
struct scsi_sense_hdr *sshdr)
|
|
|
|
{
|
|
|
|
if (!scsi_sense_valid(sshdr))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* not invoked for commands that could return deferred errors */
|
|
|
|
switch (sshdr->sense_key) {
|
|
|
|
case UNIT_ATTENTION:
|
|
|
|
case NOT_READY:
|
|
|
|
/* medium not present */
|
|
|
|
if (sshdr->asc == 0x3A) {
|
|
|
|
set_media_not_present(sdkp);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-12-18 17:42:23 +00:00
|
|
|
* sd_check_events - check media events
|
|
|
|
* @disk: kernel device descriptor
|
|
|
|
* @clearing: disk events currently being cleared
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2010-12-18 17:42:23 +00:00
|
|
|
* Returns mask of DISK_EVENT_*.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Note: this function is invoked from the block subsystem.
|
|
|
|
**/
|
2010-12-18 17:42:23 +00:00
|
|
|
static unsigned int sd_check_events(struct gendisk *disk, unsigned int clearing)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2022-03-08 05:51:53 +00:00
|
|
|
struct scsi_disk *sdkp = disk->private_data;
|
2016-04-26 06:06:58 +00:00
|
|
|
struct scsi_device *sdp;
|
2005-04-16 22:20:36 +00:00
|
|
|
int retval;
|
2021-04-15 22:08:22 +00:00
|
|
|
bool disk_changed;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-04-26 06:06:58 +00:00
|
|
|
if (!sdkp)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
sdp = sdkp->device;
|
2010-12-18 17:42:23 +00:00
|
|
|
SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_check_events\n"));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the device is offline, don't send any commands - just pretend as
|
|
|
|
* if the command failed. If the device ever comes back online, we
|
|
|
|
* can deal with it then. It is only because of unrecoverable errors
|
|
|
|
* that we would ever take a device offline in the first place.
|
|
|
|
*/
|
2007-08-14 12:10:39 +00:00
|
|
|
if (!scsi_device_online(sdp)) {
|
|
|
|
set_media_not_present(sdkp);
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Using TEST_UNIT_READY enables differentiation between drive with
|
|
|
|
* no cartridge loaded - NOT READY, drive with changed cartridge -
|
|
|
|
* UNIT ATTENTION, or with same cartridge - GOOD STATUS.
|
|
|
|
*
|
|
|
|
* Drives that auto spin down. eg iomega jaz 1G, will be started
|
|
|
|
* by sd_spinup_disk() from sd_revalidate_disk(), which happens whenever
|
|
|
|
* sd_revalidate() is called.
|
|
|
|
*/
|
2007-12-02 17:10:40 +00:00
|
|
|
if (scsi_block_when_processing_errors(sdp)) {
|
2017-02-14 19:15:56 +00:00
|
|
|
struct scsi_sense_hdr sshdr = { 0, };
|
|
|
|
|
2020-10-01 15:35:54 +00:00
|
|
|
retval = scsi_test_unit_ready(sdp, SD_TIMEOUT, sdkp->max_retries,
|
2017-02-14 19:15:56 +00:00
|
|
|
&sshdr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-02-14 19:15:56 +00:00
|
|
|
/* failed to execute TUR, assume media not present */
|
2021-04-27 08:30:12 +00:00
|
|
|
if (retval < 0 || host_byte(retval)) {
|
2017-02-14 19:15:56 +00:00
|
|
|
set_media_not_present(sdkp);
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-02-14 19:15:56 +00:00
|
|
|
if (media_not_present(sdkp, &sshdr))
|
|
|
|
goto out;
|
|
|
|
}
|
2010-12-18 17:42:23 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* For removable scsi disk we have to recognise the presence
|
2010-12-18 17:42:23 +00:00
|
|
|
* of a disk in the drive.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2010-12-18 17:42:23 +00:00
|
|
|
if (!sdkp->media_present)
|
|
|
|
sdp->changed = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
sdkp->media_present = 1;
|
2007-08-14 12:10:39 +00:00
|
|
|
out:
|
2010-09-07 15:44:01 +00:00
|
|
|
/*
|
2010-12-18 17:42:23 +00:00
|
|
|
* sdp->changed is set under the following conditions:
|
2010-09-07 15:44:01 +00:00
|
|
|
*
|
2010-12-18 17:42:23 +00:00
|
|
|
* Medium present state has changed in either direction.
|
|
|
|
* Device has indicated UNIT_ATTENTION.
|
2010-09-07 15:44:01 +00:00
|
|
|
*/
|
2021-04-15 22:08:22 +00:00
|
|
|
disk_changed = sdp->changed;
|
2010-12-18 17:42:23 +00:00
|
|
|
sdp->changed = 0;
|
2021-04-15 22:08:22 +00:00
|
|
|
return disk_changed ? DISK_EVENT_MEDIA_CHANGE : 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2017-05-11 12:34:24 +00:00
|
|
|
static int sd_sync_cache(struct scsi_disk *sdkp, struct scsi_sense_hdr *sshdr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int retries, res;
|
2007-02-28 03:40:55 +00:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2013-10-04 21:42:24 +00:00
|
|
|
const int timeout = sdp->request_queue->rq_timeout
|
|
|
|
* SD_FLUSH_TIMEOUT_MULTIPLIER;
|
2017-05-11 12:34:24 +00:00
|
|
|
struct scsi_sense_hdr my_sshdr;
|
2022-12-29 19:01:47 +00:00
|
|
|
const struct scsi_exec_args exec_args = {
|
|
|
|
.req_flags = BLK_MQ_REQ_PM,
|
|
|
|
/* caller might not be interested in sense, but we need it */
|
|
|
|
.sshdr = sshdr ? : &my_sshdr,
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!scsi_device_online(sdp))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2022-12-29 19:01:47 +00:00
|
|
|
sshdr = exec_args.sshdr;
|
2017-05-11 12:34:24 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
for (retries = 3; retries > 0; --retries) {
|
2022-11-15 00:29:05 +00:00
|
|
|
unsigned char cmd[16] = { 0 };
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2022-11-15 00:29:05 +00:00
|
|
|
if (sdp->use_16_for_sync)
|
|
|
|
cmd[0] = SYNCHRONIZE_CACHE_16;
|
|
|
|
else
|
|
|
|
cmd[0] = SYNCHRONIZE_CACHE;
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Leave the rest of the command zero to indicate
|
|
|
|
* flush everything.
|
|
|
|
*/
|
2022-12-29 19:01:47 +00:00
|
|
|
res = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, NULL, 0,
|
|
|
|
timeout, sdkp->max_retries, &exec_args);
|
2005-08-28 16:33:52 +00:00
|
|
|
if (res == 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-02-28 03:40:55 +00:00
|
|
|
if (res) {
|
2014-10-24 12:27:00 +00:00
|
|
|
sd_print_result(sdkp, "Synchronize Cache(10) failed", res);
|
2013-09-16 11:28:15 +00:00
|
|
|
|
2021-04-27 08:30:12 +00:00
|
|
|
if (res < 0)
|
|
|
|
return res;
|
|
|
|
|
2021-04-27 08:30:15 +00:00
|
|
|
if (scsi_status_is_check_condition(res) &&
|
|
|
|
scsi_sense_valid(sshdr)) {
|
2017-05-11 12:34:24 +00:00
|
|
|
sd_print_sense_hdr(sdkp, sshdr);
|
|
|
|
|
2021-04-27 08:30:15 +00:00
|
|
|
/* we need to evaluate the error return */
|
|
|
|
if (sshdr->asc == 0x3a || /* medium not present */
|
|
|
|
sshdr->asc == 0x20 || /* invalid command */
|
|
|
|
(sshdr->asc == 0x74 && sshdr->ascq == 0x71)) /* drive is password locked */
|
2013-09-16 11:28:15 +00:00
|
|
|
/* this is no error here */
|
|
|
|
return 0;
|
2021-04-27 08:30:15 +00:00
|
|
|
}
|
2013-09-16 11:28:15 +00:00
|
|
|
|
|
|
|
switch (host_byte(res)) {
|
|
|
|
/* ignore errors due to racing a disconnection */
|
|
|
|
case DID_BAD_TARGET:
|
|
|
|
case DID_NO_CONNECT:
|
|
|
|
return 0;
|
|
|
|
/* signal the upper layer it might try again */
|
|
|
|
case DID_BUS_BUSY:
|
|
|
|
case DID_IMM_RETRY:
|
|
|
|
case DID_REQUEUE:
|
|
|
|
case DID_SOFT_ERROR:
|
|
|
|
return -EBUSY;
|
|
|
|
default:
|
|
|
|
return -EIO;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-03-20 15:07:18 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sd_rescan(struct device *dev)
|
|
|
|
{
|
2015-02-02 13:01:25 +00:00
|
|
|
struct scsi_disk *sdkp = dev_get_drvdata(dev);
|
2005-11-04 19:44:41 +00:00
|
|
|
|
2020-11-16 14:56:55 +00:00
|
|
|
sd_revalidate_disk(sdkp->disk);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2021-10-21 06:06:02 +00:00
|
|
|
static int sd_get_unique_id(struct gendisk *disk, u8 id[16],
|
|
|
|
enum blk_unique_id type)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev = scsi_disk(disk)->device;
|
|
|
|
const struct scsi_vpd *vpd;
|
|
|
|
const unsigned char *d;
|
|
|
|
int ret = -ENXIO, len;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
vpd = rcu_dereference(sdev->vpd_pg83);
|
|
|
|
if (!vpd)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
for (d = vpd->data + 4; d < vpd->data + vpd->len; d += d[3] + 4) {
|
|
|
|
/* we only care about designators with LU association */
|
|
|
|
if (((d[1] >> 4) & 0x3) != 0x00)
|
|
|
|
continue;
|
|
|
|
if ((d[1] & 0xf) != type)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Only exit early if a 16-byte descriptor was found. Otherwise
|
|
|
|
* keep looking as one with more entropy might still show up.
|
|
|
|
*/
|
|
|
|
len = d[3];
|
|
|
|
if (len != 8 && len != 12 && len != 16)
|
|
|
|
continue;
|
|
|
|
ret = len;
|
|
|
|
memcpy(id, d + 4, len);
|
|
|
|
if (len == 16)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out_unlock:
|
|
|
|
rcu_read_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-10-15 12:10:49 +00:00
|
|
|
static char sd_pr_type(enum pr_type type)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case PR_WRITE_EXCLUSIVE:
|
|
|
|
return 0x01;
|
|
|
|
case PR_EXCLUSIVE_ACCESS:
|
|
|
|
return 0x03;
|
|
|
|
case PR_WRITE_EXCLUSIVE_REG_ONLY:
|
|
|
|
return 0x05;
|
|
|
|
case PR_EXCLUSIVE_ACCESS_REG_ONLY:
|
|
|
|
return 0x06;
|
|
|
|
case PR_WRITE_EXCLUSIVE_ALL_REGS:
|
|
|
|
return 0x07;
|
|
|
|
case PR_EXCLUSIVE_ACCESS_ALL_REGS:
|
|
|
|
return 0x08;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2022-11-22 03:26:02 +00:00
|
|
|
static int sd_scsi_to_pr_err(struct scsi_sense_hdr *sshdr, int result)
|
|
|
|
{
|
|
|
|
switch (host_byte(result)) {
|
|
|
|
case DID_TRANSPORT_MARGINAL:
|
|
|
|
case DID_TRANSPORT_DISRUPTED:
|
|
|
|
case DID_BUS_BUSY:
|
|
|
|
return PR_STS_RETRY_PATH_FAILURE;
|
|
|
|
case DID_NO_CONNECT:
|
|
|
|
return PR_STS_PATH_FAILED;
|
|
|
|
case DID_TRANSPORT_FAILFAST:
|
|
|
|
return PR_STS_PATH_FAST_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (status_byte(result)) {
|
|
|
|
case SAM_STAT_RESERVATION_CONFLICT:
|
|
|
|
return PR_STS_RESERVATION_CONFLICT;
|
|
|
|
case SAM_STAT_CHECK_CONDITION:
|
|
|
|
if (!scsi_sense_valid(sshdr))
|
|
|
|
return PR_STS_IOERR;
|
|
|
|
|
|
|
|
if (sshdr->sense_key == ILLEGAL_REQUEST &&
|
|
|
|
(sshdr->asc == 0x26 || sshdr->asc == 0x24))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
fallthrough;
|
|
|
|
default:
|
|
|
|
return PR_STS_IOERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-15 12:10:49 +00:00
|
|
|
static int sd_pr_command(struct block_device *bdev, u8 sa,
|
|
|
|
u64 key, u64 sa_key, u8 type, u8 flags)
|
|
|
|
{
|
2020-10-01 15:35:54 +00:00
|
|
|
struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
|
|
|
|
struct scsi_device *sdev = sdkp->device;
|
2015-10-15 12:10:49 +00:00
|
|
|
struct scsi_sense_hdr sshdr;
|
2022-12-29 19:01:47 +00:00
|
|
|
const struct scsi_exec_args exec_args = {
|
|
|
|
.sshdr = &sshdr,
|
|
|
|
};
|
2015-10-15 12:10:49 +00:00
|
|
|
int result;
|
|
|
|
u8 cmd[16] = { 0, };
|
|
|
|
u8 data[24] = { 0, };
|
|
|
|
|
|
|
|
cmd[0] = PERSISTENT_RESERVE_OUT;
|
|
|
|
cmd[1] = sa;
|
|
|
|
cmd[2] = type;
|
|
|
|
put_unaligned_be32(sizeof(data), &cmd[5]);
|
|
|
|
|
|
|
|
put_unaligned_be64(key, &data[0]);
|
|
|
|
put_unaligned_be64(sa_key, &data[8]);
|
|
|
|
data[20] = flags;
|
|
|
|
|
2022-12-29 19:01:47 +00:00
|
|
|
result = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_OUT, &data,
|
|
|
|
sizeof(data), SD_TIMEOUT, sdkp->max_retries,
|
|
|
|
&exec_args);
|
2015-10-15 12:10:49 +00:00
|
|
|
|
2021-04-27 08:30:15 +00:00
|
|
|
if (scsi_status_is_check_condition(result) &&
|
2018-06-25 11:20:58 +00:00
|
|
|
scsi_sense_valid(&sshdr)) {
|
2015-10-15 12:10:49 +00:00
|
|
|
sdev_printk(KERN_INFO, sdev, "PR command failed: %d\n", result);
|
|
|
|
scsi_print_sense_hdr(sdev, NULL, &sshdr);
|
|
|
|
}
|
|
|
|
|
2022-11-22 03:26:02 +00:00
|
|
|
if (result <= 0)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
return sd_scsi_to_pr_err(&sshdr, result);
|
2015-10-15 12:10:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int sd_pr_register(struct block_device *bdev, u64 old_key, u64 new_key,
|
|
|
|
u32 flags)
|
|
|
|
{
|
|
|
|
if (flags & ~PR_FL_IGNORE_KEY)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
return sd_pr_command(bdev, (flags & PR_FL_IGNORE_KEY) ? 0x06 : 0x00,
|
|
|
|
old_key, new_key, 0,
|
2016-07-08 12:23:50 +00:00
|
|
|
(1 << 0) /* APTPL */);
|
2015-10-15 12:10:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int sd_pr_reserve(struct block_device *bdev, u64 key, enum pr_type type,
|
|
|
|
u32 flags)
|
|
|
|
{
|
|
|
|
if (flags)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
return sd_pr_command(bdev, 0x01, key, 0, sd_pr_type(type), 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sd_pr_release(struct block_device *bdev, u64 key, enum pr_type type)
|
|
|
|
{
|
|
|
|
return sd_pr_command(bdev, 0x02, key, 0, sd_pr_type(type), 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sd_pr_preempt(struct block_device *bdev, u64 old_key, u64 new_key,
|
|
|
|
enum pr_type type, bool abort)
|
|
|
|
{
|
|
|
|
return sd_pr_command(bdev, abort ? 0x05 : 0x04, old_key, new_key,
|
|
|
|
sd_pr_type(type), 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sd_pr_clear(struct block_device *bdev, u64 key)
|
|
|
|
{
|
|
|
|
return sd_pr_command(bdev, 0x03, key, 0, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct pr_ops sd_pr_ops = {
|
|
|
|
.pr_register = sd_pr_register,
|
|
|
|
.pr_reserve = sd_pr_reserve,
|
|
|
|
.pr_release = sd_pr_release,
|
|
|
|
.pr_preempt = sd_pr_preempt,
|
|
|
|
.pr_clear = sd_pr_clear,
|
|
|
|
};
|
|
|
|
|
2022-03-08 05:51:53 +00:00
|
|
|
static void scsi_disk_free_disk(struct gendisk *disk)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = scsi_disk(disk);
|
|
|
|
|
|
|
|
put_device(&sdkp->disk_dev);
|
|
|
|
}
|
|
|
|
|
2009-09-22 00:01:13 +00:00
|
|
|
static const struct block_device_operations sd_fops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
2008-03-02 15:41:04 +00:00
|
|
|
.open = sd_open,
|
|
|
|
.release = sd_release,
|
2010-07-08 08:18:46 +00:00
|
|
|
.ioctl = sd_ioctl,
|
2006-01-08 09:02:50 +00:00
|
|
|
.getgeo = sd_getgeo,
|
2021-07-24 07:20:12 +00:00
|
|
|
.compat_ioctl = blkdev_compat_ptr_ioctl,
|
2010-12-18 17:42:23 +00:00
|
|
|
.check_events = sd_check_events,
|
2010-05-15 18:09:32 +00:00
|
|
|
.unlock_native_capacity = sd_unlock_native_capacity,
|
2018-10-12 10:08:49 +00:00
|
|
|
.report_zones = sd_zbc_report_zones,
|
2021-10-21 06:06:02 +00:00
|
|
|
.get_unique_id = sd_get_unique_id,
|
2022-03-08 05:51:53 +00:00
|
|
|
.free_disk = scsi_disk_free_disk,
|
2015-10-15 12:10:49 +00:00
|
|
|
.pr_ops = &sd_pr_ops,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2017-04-06 13:36:29 +00:00
|
|
|
/**
|
|
|
|
* sd_eh_reset - reset error handling callback
|
|
|
|
* @scmd: sd-issued command that has failed
|
|
|
|
*
|
|
|
|
* This function is called by the SCSI midlayer before starting
|
|
|
|
* SCSI EH. When counting medium access failures we have to be
|
|
|
|
* careful to register it only only once per device and SCSI EH run;
|
|
|
|
* there might be several timed out commands which will cause the
|
|
|
|
* 'max_medium_access_timeouts' counter to trigger after the first
|
|
|
|
* SCSI EH run already and set the device to offline.
|
|
|
|
* So this function resets the internal counter before starting SCSI EH.
|
|
|
|
**/
|
|
|
|
static void sd_eh_reset(struct scsi_cmnd *scmd)
|
|
|
|
{
|
2021-11-26 12:18:00 +00:00
|
|
|
struct scsi_disk *sdkp = scsi_disk(scsi_cmd_to_rq(scmd)->q->disk);
|
2017-04-06 13:36:29 +00:00
|
|
|
|
|
|
|
/* New SCSI EH run, reset gate variable */
|
|
|
|
sdkp->ignore_medium_access_errors = false;
|
|
|
|
}
|
|
|
|
|
2012-02-09 18:48:53 +00:00
|
|
|
/**
|
|
|
|
* sd_eh_action - error handling callback
|
|
|
|
* @scmd: sd-issued command that has failed
|
|
|
|
* @eh_disp: The recovery disposition suggested by the midlayer
|
|
|
|
*
|
2013-11-11 12:44:53 +00:00
|
|
|
* This function is called by the SCSI midlayer upon completion of an
|
|
|
|
* error test command (currently TEST UNIT READY). The result of sending
|
|
|
|
* the eh command is passed in eh_disp. We're looking for devices that
|
|
|
|
* fail medium access commands but are OK with non access commands like
|
|
|
|
* test unit ready (so wrongly see the device as having a successful
|
|
|
|
* recovery)
|
2012-02-09 18:48:53 +00:00
|
|
|
**/
|
2013-11-11 12:44:53 +00:00
|
|
|
static int sd_eh_action(struct scsi_cmnd *scmd, int eh_disp)
|
2012-02-09 18:48:53 +00:00
|
|
|
{
|
2021-11-26 12:18:00 +00:00
|
|
|
struct scsi_disk *sdkp = scsi_disk(scsi_cmd_to_rq(scmd)->q->disk);
|
2017-06-02 21:21:55 +00:00
|
|
|
struct scsi_device *sdev = scmd->device;
|
2012-02-09 18:48:53 +00:00
|
|
|
|
2017-06-02 21:21:55 +00:00
|
|
|
if (!scsi_device_online(sdev) ||
|
2013-11-11 12:44:53 +00:00
|
|
|
!scsi_medium_access_command(scmd) ||
|
|
|
|
host_byte(scmd->result) != DID_TIME_OUT ||
|
|
|
|
eh_disp != SUCCESS)
|
2012-02-09 18:48:53 +00:00
|
|
|
return eh_disp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The device has timed out executing a medium access command.
|
|
|
|
* However, the TEST UNIT READY command sent during error
|
|
|
|
* handling completed successfully. Either the device is in the
|
|
|
|
* process of recovering or has it suffered an internal failure
|
|
|
|
* that prevents access to the storage medium.
|
|
|
|
*/
|
2017-04-06 13:36:29 +00:00
|
|
|
if (!sdkp->ignore_medium_access_errors) {
|
|
|
|
sdkp->medium_access_timed_out++;
|
|
|
|
sdkp->ignore_medium_access_errors = true;
|
|
|
|
}
|
2012-02-09 18:48:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the device keeps failing read/write commands but TEST UNIT
|
|
|
|
* READY always completes successfully we assume that medium
|
|
|
|
* access is no longer possible and take the device offline.
|
|
|
|
*/
|
|
|
|
if (sdkp->medium_access_timed_out >= sdkp->max_medium_access_timeouts) {
|
|
|
|
scmd_printk(KERN_ERR, scmd,
|
|
|
|
"Medium access timeout failure. Offlining disk!\n");
|
2017-06-02 21:21:55 +00:00
|
|
|
mutex_lock(&sdev->state_mutex);
|
|
|
|
scsi_device_set_state(sdev, SDEV_OFFLINE);
|
|
|
|
mutex_unlock(&sdev->state_mutex);
|
2012-02-09 18:48:53 +00:00
|
|
|
|
2017-04-06 13:36:30 +00:00
|
|
|
return SUCCESS;
|
2012-02-09 18:48:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return eh_disp;
|
|
|
|
}
|
|
|
|
|
2008-07-17 08:28:35 +00:00
|
|
|
static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
|
|
|
|
{
|
2021-08-09 23:03:06 +00:00
|
|
|
struct request *req = scsi_cmd_to_rq(scmd);
|
2017-04-24 07:51:10 +00:00
|
|
|
struct scsi_device *sdev = scmd->device;
|
|
|
|
unsigned int transferred, good_bytes;
|
|
|
|
u64 start_lba, end_lba, bad_lba;
|
|
|
|
|
[SCSI] fix medium error problems with some arrays which can cause data corruption
Our current handling of medium error assumes that data is returned up
to the bad sector. This assumption holds good for all disk devices,
all DIF arrays and most ordinary arrays. However, an LSI array engine
was recently discovered which reports a medium error without returning
any data. This means that when we report good data up to the medium
error, we've reported junk originally in the buffer as good. Worse,
if the read consists of requested data plus a readahead, and the error
occurs in readahead, we'll just strip off the readahead and report
junk up to userspace as good data with no error.
The fix for this is to have the error position computation take into
account the amount of data returned by the driver using the scsi
residual data. Unfortunately, not every driver fills in this data,
but for those who don't, it's set to zero, which means we'll think a
full set of data was transferred and the behaviour will be identical
to the prior behaviour of the code (believe the buffer up to the error
sector). All modern drivers seem to set the residual, so that should
fix up the LSI failure/corruption case.
Reported-by: Douglas Gilbert <dgilbert@interlog.com>
Cc: Stable Tree <stable@kernel.org>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-12-17 20:36:34 +00:00
|
|
|
/*
|
2017-04-24 07:51:10 +00:00
|
|
|
* Some commands have a payload smaller than the device logical
|
|
|
|
* block size (e.g. INQUIRY on a 4K disk).
|
[SCSI] fix medium error problems with some arrays which can cause data corruption
Our current handling of medium error assumes that data is returned up
to the bad sector. This assumption holds good for all disk devices,
all DIF arrays and most ordinary arrays. However, an LSI array engine
was recently discovered which reports a medium error without returning
any data. This means that when we report good data up to the medium
error, we've reported junk originally in the buffer as good. Worse,
if the read consists of requested data plus a readahead, and the error
occurs in readahead, we'll just strip off the readahead and report
junk up to userspace as good data with no error.
The fix for this is to have the error position computation take into
account the amount of data returned by the driver using the scsi
residual data. Unfortunately, not every driver fills in this data,
but for those who don't, it's set to zero, which means we'll think a
full set of data was transferred and the behaviour will be identical
to the prior behaviour of the code (believe the buffer up to the error
sector). All modern drivers seem to set the residual, so that should
fix up the LSI failure/corruption case.
Reported-by: Douglas Gilbert <dgilbert@interlog.com>
Cc: Stable Tree <stable@kernel.org>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-12-17 20:36:34 +00:00
|
|
|
*/
|
2017-04-24 07:51:10 +00:00
|
|
|
if (scsi_bufflen(scmd) <= sdev->sector_size)
|
2008-07-17 08:28:35 +00:00
|
|
|
return 0;
|
|
|
|
|
2017-04-24 07:51:10 +00:00
|
|
|
/* Check if we have a 'bad_lba' information */
|
|
|
|
if (!scsi_get_sense_info_fld(scmd->sense_buffer,
|
|
|
|
SCSI_SENSE_BUFFERSIZE,
|
|
|
|
&bad_lba))
|
2008-07-17 08:28:35 +00:00
|
|
|
return 0;
|
|
|
|
|
2017-04-24 07:51:10 +00:00
|
|
|
/*
|
|
|
|
* If the bad lba was reported incorrectly, we have no idea where
|
2008-07-17 08:28:35 +00:00
|
|
|
* the error is.
|
|
|
|
*/
|
2017-04-24 07:51:10 +00:00
|
|
|
start_lba = sectors_to_logical(sdev, blk_rq_pos(req));
|
|
|
|
end_lba = start_lba + bytes_to_logical(sdev, scsi_bufflen(scmd));
|
|
|
|
if (bad_lba < start_lba || bad_lba >= end_lba)
|
2008-07-17 08:28:35 +00:00
|
|
|
return 0;
|
|
|
|
|
2017-04-24 07:51:10 +00:00
|
|
|
/*
|
|
|
|
* resid is optional but mostly filled in. When it's unused,
|
|
|
|
* its value is zero, so we assume the whole buffer transferred
|
2008-07-17 08:28:35 +00:00
|
|
|
*/
|
2017-04-24 07:51:10 +00:00
|
|
|
transferred = scsi_bufflen(scmd) - scsi_get_resid(scmd);
|
|
|
|
|
|
|
|
/* This computation should always be done in terms of the
|
|
|
|
* resolution of the device's medium.
|
2008-07-17 08:28:35 +00:00
|
|
|
*/
|
2017-04-24 07:51:10 +00:00
|
|
|
good_bytes = logical_to_bytes(sdev, bad_lba - start_lba);
|
|
|
|
|
[SCSI] fix medium error problems with some arrays which can cause data corruption
Our current handling of medium error assumes that data is returned up
to the bad sector. This assumption holds good for all disk devices,
all DIF arrays and most ordinary arrays. However, an LSI array engine
was recently discovered which reports a medium error without returning
any data. This means that when we report good data up to the medium
error, we've reported junk originally in the buffer as good. Worse,
if the read consists of requested data plus a readahead, and the error
occurs in readahead, we'll just strip off the readahead and report
junk up to userspace as good data with no error.
The fix for this is to have the error position computation take into
account the amount of data returned by the driver using the scsi
residual data. Unfortunately, not every driver fills in this data,
but for those who don't, it's set to zero, which means we'll think a
full set of data was transferred and the behaviour will be identical
to the prior behaviour of the code (believe the buffer up to the error
sector). All modern drivers seem to set the residual, so that should
fix up the LSI failure/corruption case.
Reported-by: Douglas Gilbert <dgilbert@interlog.com>
Cc: Stable Tree <stable@kernel.org>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-12-17 20:36:34 +00:00
|
|
|
return min(good_bytes, transferred);
|
2008-07-17 08:28:35 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
Revert "scsi: revert "[SCSI] Get rid of scsi_cmnd->done""
This reverts commit ac40532ef0b8649e6f7f83859ea0de1c4ed08a19, which gets
us back the original cleanup of 6f5391c283d7fdcf24bf40786ea79061919d1e1d.
It turns out that the bug that was triggered by that commit was
apparently not actually triggered by that commit at all, and just the
testing conditions had changed enough to make it appear to be due to it.
The real problem seems to have been found by Peter Osterlund:
"pktcdvd sets it [block device size] when opening the /dev/pktcdvd
device, but when the drive is later opened as /dev/scd0, there is
nothing that sets it back. (Btw, 40944 is possible if the disk is a
CDRW that was formatted with "cdrwtool -m 10236".)
The problem is that pktcdvd opens the cd device in non-blocking mode
when pktsetup is run, and doesn't close it again until pktsetup -d is
run. The effect is that if you meanwhile open the cd device,
blkdev.c:do_open() doesn't call bd_set_size() because
bdev->bd_openers is non-zero."
In particular, to repeat the bug (regardless of whether commit
6f5391c283d7fdcf24bf40786ea79061919d1e1d is applied or not):
" 1. Start with an empty drive.
2. pktsetup 0 /dev/scd0
3. Insert a CD containing an isofs filesystem.
4. mount /dev/pktcdvd/0 /mnt/tmp
5. umount /mnt/tmp
6. Press the eject button.
7. Insert a DVD containing a non-writable filesystem.
8. mount /dev/scd0 /mnt/tmp
9. find /mnt/tmp -type f -print0 | xargs -0 sha1sum >/dev/null
10. If the DVD contains data beyond the physical size of a CD, you
get I/O errors in the terminal, and dmesg reports lots of
"attempt to access beyond end of device" errors."
which in turn is because the nested open after the media change won't
cause the size to be set properly (because the original open still holds
the block device, and we only do the bd_set_size() when we don't have
other people holding the device open).
The proper fix for that is probably to just do something like
bdev->bd_inode->i_size = (loff_t)get_capacity(disk)<<9;
in fs/block_dev.c:do_open() even for the cases where we're not the
original opener (but *not* call bd_set_size(), since that will also
change the block size of the device).
Cc: Peter Osterlund <petero2@telia.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-01-06 18:17:12 +00:00
|
|
|
* sd_done - bottom half handler: called when the lower level
|
2005-04-16 22:20:36 +00:00
|
|
|
* driver has completed (successfully or otherwise) a scsi command.
|
|
|
|
* @SCpnt: mid-level's per command structure.
|
|
|
|
*
|
|
|
|
* Note: potentially run from within an ISR. Must not block.
|
|
|
|
**/
|
Revert "scsi: revert "[SCSI] Get rid of scsi_cmnd->done""
This reverts commit ac40532ef0b8649e6f7f83859ea0de1c4ed08a19, which gets
us back the original cleanup of 6f5391c283d7fdcf24bf40786ea79061919d1e1d.
It turns out that the bug that was triggered by that commit was
apparently not actually triggered by that commit at all, and just the
testing conditions had changed enough to make it appear to be due to it.
The real problem seems to have been found by Peter Osterlund:
"pktcdvd sets it [block device size] when opening the /dev/pktcdvd
device, but when the drive is later opened as /dev/scd0, there is
nothing that sets it back. (Btw, 40944 is possible if the disk is a
CDRW that was formatted with "cdrwtool -m 10236".)
The problem is that pktcdvd opens the cd device in non-blocking mode
when pktsetup is run, and doesn't close it again until pktsetup -d is
run. The effect is that if you meanwhile open the cd device,
blkdev.c:do_open() doesn't call bd_set_size() because
bdev->bd_openers is non-zero."
In particular, to repeat the bug (regardless of whether commit
6f5391c283d7fdcf24bf40786ea79061919d1e1d is applied or not):
" 1. Start with an empty drive.
2. pktsetup 0 /dev/scd0
3. Insert a CD containing an isofs filesystem.
4. mount /dev/pktcdvd/0 /mnt/tmp
5. umount /mnt/tmp
6. Press the eject button.
7. Insert a DVD containing a non-writable filesystem.
8. mount /dev/scd0 /mnt/tmp
9. find /mnt/tmp -type f -print0 | xargs -0 sha1sum >/dev/null
10. If the DVD contains data beyond the physical size of a CD, you
get I/O errors in the terminal, and dmesg reports lots of
"attempt to access beyond end of device" errors."
which in turn is because the nested open after the media change won't
cause the size to be set properly (because the original open still holds
the block device, and we only do the bd_set_size() when we don't have
other people holding the device open).
The proper fix for that is probably to just do something like
bdev->bd_inode->i_size = (loff_t)get_capacity(disk)<<9;
in fs/block_dev.c:do_open() even for the cases where we're not the
original opener (but *not* call bd_set_size(), since that will also
change the block size of the device).
Cc: Peter Osterlund <petero2@telia.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-01-06 18:17:12 +00:00
|
|
|
static int sd_done(struct scsi_cmnd *SCpnt)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int result = SCpnt->result;
|
2008-07-17 08:28:35 +00:00
|
|
|
unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt);
|
2017-03-01 08:27:00 +00:00
|
|
|
unsigned int sector_size = SCpnt->device->sector_size;
|
|
|
|
unsigned int resid;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct scsi_sense_hdr sshdr;
|
2021-08-09 23:03:06 +00:00
|
|
|
struct request *req = scsi_cmd_to_rq(SCpnt);
|
2021-11-26 12:18:00 +00:00
|
|
|
struct scsi_disk *sdkp = scsi_disk(req->q->disk);
|
2005-04-16 22:20:36 +00:00
|
|
|
int sense_valid = 0;
|
|
|
|
int sense_deferred = 0;
|
|
|
|
|
2016-10-18 06:40:34 +00:00
|
|
|
switch (req_op(req)) {
|
|
|
|
case REQ_OP_DISCARD:
|
2017-04-05 17:21:02 +00:00
|
|
|
case REQ_OP_WRITE_ZEROES:
|
2016-10-18 06:40:34 +00:00
|
|
|
case REQ_OP_ZONE_RESET:
|
2019-08-01 17:26:37 +00:00
|
|
|
case REQ_OP_ZONE_RESET_ALL:
|
2019-10-27 14:05:47 +00:00
|
|
|
case REQ_OP_ZONE_OPEN:
|
|
|
|
case REQ_OP_ZONE_CLOSE:
|
|
|
|
case REQ_OP_ZONE_FINISH:
|
2012-09-18 16:19:31 +00:00
|
|
|
if (!result) {
|
|
|
|
good_bytes = blk_rq_bytes(req);
|
|
|
|
scsi_set_resid(SCpnt, 0);
|
|
|
|
} else {
|
|
|
|
good_bytes = 0;
|
|
|
|
scsi_set_resid(SCpnt, blk_rq_bytes(req));
|
2016-10-18 06:40:34 +00:00
|
|
|
}
|
|
|
|
break;
|
2017-03-01 08:27:00 +00:00
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* In case of bogus fw or device, we could end up having
|
|
|
|
* an unaligned partial completion. Check this here and force
|
|
|
|
* alignment.
|
|
|
|
*/
|
|
|
|
resid = scsi_get_resid(SCpnt);
|
|
|
|
if (resid & (sector_size - 1)) {
|
|
|
|
sd_printk(KERN_INFO, sdkp,
|
|
|
|
"Unaligned partial completion (resid=%u, sector_sz=%u)\n",
|
|
|
|
resid, sector_size);
|
2019-08-28 05:35:11 +00:00
|
|
|
scsi_print_command(SCpnt);
|
2017-03-01 08:27:00 +00:00
|
|
|
resid = min(scsi_bufflen(SCpnt),
|
|
|
|
round_up(resid, sector_size));
|
|
|
|
scsi_set_resid(SCpnt, resid);
|
|
|
|
}
|
2012-09-18 16:19:31 +00:00
|
|
|
}
|
2010-07-21 01:29:37 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (result) {
|
|
|
|
sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
|
|
|
|
if (sense_valid)
|
|
|
|
sense_deferred = scsi_sense_is_deferred(&sshdr);
|
|
|
|
}
|
2014-04-10 15:08:30 +00:00
|
|
|
sdkp->medium_access_timed_out = 0;
|
|
|
|
|
2021-04-27 08:30:15 +00:00
|
|
|
if (!scsi_status_is_check_condition(result) &&
|
2006-06-23 16:39:09 +00:00
|
|
|
(!sense_valid || sense_deferred))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
switch (sshdr.sense_key) {
|
|
|
|
case HARDWARE_ERROR:
|
|
|
|
case MEDIUM_ERROR:
|
2008-07-17 08:28:35 +00:00
|
|
|
good_bytes = sd_completed_bytes(SCpnt);
|
2006-06-23 16:39:09 +00:00
|
|
|
break;
|
|
|
|
case RECOVERED_ERROR:
|
2008-07-17 08:28:35 +00:00
|
|
|
good_bytes = scsi_bufflen(SCpnt);
|
|
|
|
break;
|
2008-09-12 01:39:36 +00:00
|
|
|
case NO_SENSE:
|
|
|
|
/* This indicates a false check condition, so ignore it. An
|
|
|
|
* unknown amount of data was transferred so treat it as an
|
|
|
|
* error.
|
|
|
|
*/
|
|
|
|
SCpnt->result = 0;
|
|
|
|
memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
|
|
|
|
break;
|
2011-03-08 07:07:15 +00:00
|
|
|
case ABORTED_COMMAND:
|
|
|
|
if (sshdr.asc == 0x10) /* DIF: Target detected corruption */
|
|
|
|
good_bytes = sd_completed_bytes(SCpnt);
|
|
|
|
break;
|
|
|
|
case ILLEGAL_REQUEST:
|
2017-04-24 23:05:12 +00:00
|
|
|
switch (sshdr.asc) {
|
|
|
|
case 0x10: /* DIX: Host detected corruption */
|
2008-07-17 08:28:35 +00:00
|
|
|
good_bytes = sd_completed_bytes(SCpnt);
|
2017-04-24 23:05:12 +00:00
|
|
|
break;
|
|
|
|
case 0x20: /* INVALID COMMAND OPCODE */
|
|
|
|
case 0x24: /* INVALID FIELD IN CDB */
|
|
|
|
switch (SCpnt->cmnd[0]) {
|
2012-09-18 16:19:32 +00:00
|
|
|
case UNMAP:
|
|
|
|
sd_config_discard(sdkp, SD_LBP_DISABLE);
|
|
|
|
break;
|
|
|
|
case WRITE_SAME_16:
|
|
|
|
case WRITE_SAME:
|
2017-04-24 23:05:12 +00:00
|
|
|
if (SCpnt->cmnd[1] & 8) { /* UNMAP */
|
2012-09-18 16:19:32 +00:00
|
|
|
sd_config_discard(sdkp, SD_LBP_DISABLE);
|
2017-04-24 23:05:12 +00:00
|
|
|
} else {
|
2012-09-18 16:19:32 +00:00
|
|
|
sdkp->device->no_write_same = 1;
|
|
|
|
sd_config_write_same(sdkp);
|
2016-10-20 13:12:13 +00:00
|
|
|
req->rq_flags |= RQF_QUIET;
|
2012-09-18 16:19:32 +00:00
|
|
|
}
|
2017-04-24 23:05:12 +00:00
|
|
|
break;
|
2012-09-18 16:19:32 +00:00
|
|
|
}
|
|
|
|
}
|
2006-06-23 16:39:09 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-10-18 06:40:34 +00:00
|
|
|
|
2006-06-23 16:39:09 +00:00
|
|
|
out:
|
2016-10-18 06:40:34 +00:00
|
|
|
if (sd_is_zoned(sdkp))
|
2020-05-12 08:55:51 +00:00
|
|
|
good_bytes = sd_zbc_complete(SCpnt, good_bytes, &sshdr);
|
2016-10-18 06:40:34 +00:00
|
|
|
|
2014-10-24 12:27:00 +00:00
|
|
|
SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, SCpnt,
|
|
|
|
"sd_done: completed %d of %d bytes\n",
|
|
|
|
good_bytes, scsi_bufflen(SCpnt)));
|
|
|
|
|
Revert "scsi: revert "[SCSI] Get rid of scsi_cmnd->done""
This reverts commit ac40532ef0b8649e6f7f83859ea0de1c4ed08a19, which gets
us back the original cleanup of 6f5391c283d7fdcf24bf40786ea79061919d1e1d.
It turns out that the bug that was triggered by that commit was
apparently not actually triggered by that commit at all, and just the
testing conditions had changed enough to make it appear to be due to it.
The real problem seems to have been found by Peter Osterlund:
"pktcdvd sets it [block device size] when opening the /dev/pktcdvd
device, but when the drive is later opened as /dev/scd0, there is
nothing that sets it back. (Btw, 40944 is possible if the disk is a
CDRW that was formatted with "cdrwtool -m 10236".)
The problem is that pktcdvd opens the cd device in non-blocking mode
when pktsetup is run, and doesn't close it again until pktsetup -d is
run. The effect is that if you meanwhile open the cd device,
blkdev.c:do_open() doesn't call bd_set_size() because
bdev->bd_openers is non-zero."
In particular, to repeat the bug (regardless of whether commit
6f5391c283d7fdcf24bf40786ea79061919d1e1d is applied or not):
" 1. Start with an empty drive.
2. pktsetup 0 /dev/scd0
3. Insert a CD containing an isofs filesystem.
4. mount /dev/pktcdvd/0 /mnt/tmp
5. umount /mnt/tmp
6. Press the eject button.
7. Insert a DVD containing a non-writable filesystem.
8. mount /dev/scd0 /mnt/tmp
9. find /mnt/tmp -type f -print0 | xargs -0 sha1sum >/dev/null
10. If the DVD contains data beyond the physical size of a CD, you
get I/O errors in the terminal, and dmesg reports lots of
"attempt to access beyond end of device" errors."
which in turn is because the nested open after the media change won't
cause the size to be set properly (because the original open still holds
the block device, and we only do the bd_set_size() when we don't have
other people holding the device open).
The proper fix for that is probably to just do something like
bdev->bd_inode->i_size = (loff_t)get_capacity(disk)<<9;
in fs/block_dev.c:do_open() even for the cases where we're not the
original opener (but *not* call bd_set_size(), since that will also
change the block size of the device).
Cc: Peter Osterlund <petero2@telia.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-01-06 18:17:12 +00:00
|
|
|
return good_bytes;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* spinup disk - called only in sd_revalidate_disk()
|
|
|
|
*/
|
|
|
|
static void
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_spinup_disk(struct scsi_disk *sdkp)
|
2005-08-28 16:33:52 +00:00
|
|
|
{
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char cmd[10];
|
2005-07-12 14:45:17 +00:00
|
|
|
unsigned long spintime_expire = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
int retries, spintime;
|
|
|
|
unsigned int the_result;
|
|
|
|
struct scsi_sense_hdr sshdr;
|
2022-12-29 19:01:47 +00:00
|
|
|
const struct scsi_exec_args exec_args = {
|
|
|
|
.sshdr = &sshdr,
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
int sense_valid = 0;
|
|
|
|
|
|
|
|
spintime = 0;
|
|
|
|
|
|
|
|
/* Spin up drives, as required. Only do this at boot time */
|
|
|
|
/* Spinup needs to be done for module loads too. */
|
|
|
|
do {
|
|
|
|
retries = 0;
|
|
|
|
|
|
|
|
do {
|
2021-09-11 12:11:59 +00:00
|
|
|
bool media_was_present = sdkp->media_present;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
cmd[0] = TEST_UNIT_READY;
|
|
|
|
memset((void *) &cmd[1], 0, 9);
|
|
|
|
|
2022-12-29 19:01:47 +00:00
|
|
|
the_result = scsi_execute_cmd(sdkp->device, cmd,
|
|
|
|
REQ_OP_DRV_IN, NULL, 0,
|
|
|
|
SD_TIMEOUT,
|
|
|
|
sdkp->max_retries,
|
|
|
|
&exec_args);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-11 20:48:28 +00:00
|
|
|
/*
|
|
|
|
* If the drive has indicated to us that it
|
|
|
|
* doesn't have any media in it, don't bother
|
|
|
|
* with any more polling.
|
|
|
|
*/
|
2021-08-16 09:37:51 +00:00
|
|
|
if (media_not_present(sdkp, &sshdr)) {
|
2021-09-11 12:11:59 +00:00
|
|
|
if (media_was_present)
|
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Media removed, stopped polling\n");
|
2006-10-11 20:48:28 +00:00
|
|
|
return;
|
2021-08-16 09:37:51 +00:00
|
|
|
}
|
2006-10-11 20:48:28 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (the_result)
|
2005-08-28 16:33:52 +00:00
|
|
|
sense_valid = scsi_sense_valid(&sshdr);
|
2005-04-16 22:20:36 +00:00
|
|
|
retries++;
|
2021-04-27 08:30:15 +00:00
|
|
|
} while (retries < 3 &&
|
2005-04-16 22:20:36 +00:00
|
|
|
(!scsi_status_is_good(the_result) ||
|
2021-04-27 08:30:15 +00:00
|
|
|
(scsi_status_is_check_condition(the_result) &&
|
2005-04-16 22:20:36 +00:00
|
|
|
sense_valid && sshdr.sense_key == UNIT_ATTENTION)));
|
|
|
|
|
2021-04-27 08:30:15 +00:00
|
|
|
if (!scsi_status_is_check_condition(the_result)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* no sense, TUR either succeeded or failed
|
|
|
|
* with a status error */
|
2007-02-28 03:40:55 +00:00
|
|
|
if(!spintime && !scsi_status_is_good(the_result)) {
|
2014-10-24 12:27:00 +00:00
|
|
|
sd_print_result(sdkp, "Test Unit Ready failed",
|
|
|
|
the_result);
|
2007-02-28 03:40:55 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-10-24 12:27:00 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The device does not want the automatic start to be issued.
|
|
|
|
*/
|
2009-02-20 13:53:48 +00:00
|
|
|
if (sdkp->device->no_start_on_add)
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
2009-02-20 13:53:48 +00:00
|
|
|
if (sense_valid && sshdr.sense_key == NOT_READY) {
|
|
|
|
if (sshdr.asc == 4 && sshdr.ascq == 3)
|
|
|
|
break; /* manual intervention required */
|
|
|
|
if (sshdr.asc == 4 && sshdr.ascq == 0xb)
|
|
|
|
break; /* standby */
|
|
|
|
if (sshdr.asc == 4 && sshdr.ascq == 0xc)
|
|
|
|
break; /* unavailable */
|
2018-04-17 11:33:12 +00:00
|
|
|
if (sshdr.asc == 4 && sshdr.ascq == 0x1b)
|
|
|
|
break; /* sanitize in progress */
|
2009-02-20 13:53:48 +00:00
|
|
|
/*
|
|
|
|
* Issue command to spin up drive when not ready
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!spintime) {
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Spinning up disk...");
|
2005-04-16 22:20:36 +00:00
|
|
|
cmd[0] = START_STOP;
|
|
|
|
cmd[1] = 1; /* Return immediately */
|
|
|
|
memset((void *) &cmd[2], 0, 8);
|
|
|
|
cmd[4] = 1; /* Start spin cycle */
|
2008-05-10 22:34:07 +00:00
|
|
|
if (sdkp->device->start_stop_pwr_cond)
|
|
|
|
cmd[4] |= 1 << 4;
|
2022-12-29 19:01:47 +00:00
|
|
|
scsi_execute_cmd(sdkp->device, cmd,
|
|
|
|
REQ_OP_DRV_IN, NULL, 0,
|
2020-10-01 15:35:54 +00:00
|
|
|
SD_TIMEOUT, sdkp->max_retries,
|
2022-12-29 19:01:47 +00:00
|
|
|
&exec_args);
|
2005-07-12 14:45:17 +00:00
|
|
|
spintime_expire = jiffies + 100 * HZ;
|
|
|
|
spintime = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
/* Wait 1 second for next try */
|
|
|
|
msleep(1000);
|
2017-11-24 17:02:35 +00:00
|
|
|
printk(KERN_CONT ".");
|
2005-07-12 14:45:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for USB flash devices with slow firmware.
|
|
|
|
* Yes, this sense key/ASC combination shouldn't
|
|
|
|
* occur here. It's characteristic of these devices.
|
|
|
|
*/
|
|
|
|
} else if (sense_valid &&
|
|
|
|
sshdr.sense_key == UNIT_ATTENTION &&
|
|
|
|
sshdr.asc == 0x28) {
|
|
|
|
if (!spintime) {
|
|
|
|
spintime_expire = jiffies + 5 * HZ;
|
|
|
|
spintime = 1;
|
|
|
|
}
|
|
|
|
/* Wait 1 second for next try */
|
|
|
|
msleep(1000);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
/* we don't understand the sense code, so it's
|
|
|
|
* probably pointless to loop */
|
|
|
|
if(!spintime) {
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
|
|
|
|
sd_print_sense_hdr(sdkp, &sshdr);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-07-12 14:45:17 +00:00
|
|
|
} while (spintime && time_before_eq(jiffies, spintime_expire));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (spintime) {
|
|
|
|
if (scsi_status_is_good(the_result))
|
2017-11-24 17:02:35 +00:00
|
|
|
printk(KERN_CONT "ready\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
2017-11-24 17:02:35 +00:00
|
|
|
printk(KERN_CONT "not responding...\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-17 08:28:34 +00:00
|
|
|
/*
|
|
|
|
* Determine whether disk supports Data Integrity Field.
|
|
|
|
*/
|
2012-09-21 16:44:12 +00:00
|
|
|
static int sd_read_protection_type(struct scsi_disk *sdkp, unsigned char *buffer)
|
2008-07-17 08:28:34 +00:00
|
|
|
{
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
u8 type;
|
|
|
|
|
2020-01-09 01:12:24 +00:00
|
|
|
if (scsi_device_protection(sdp) == 0 || (buffer[12] & 1) == 0) {
|
|
|
|
sdkp->protection_type = 0;
|
2022-03-02 05:35:58 +00:00
|
|
|
return 0;
|
2020-01-09 01:12:24 +00:00
|
|
|
}
|
2009-09-18 21:33:00 +00:00
|
|
|
|
|
|
|
type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 */
|
|
|
|
|
2022-03-02 05:35:58 +00:00
|
|
|
if (type > T10_PI_TYPE3_PROTECTION) {
|
|
|
|
sd_printk(KERN_ERR, sdkp, "formatted with unsupported" \
|
|
|
|
" protection type %u. Disabling disk!\n",
|
|
|
|
type);
|
|
|
|
sdkp->protection_type = 0;
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
2008-07-17 08:28:34 +00:00
|
|
|
|
2008-09-19 22:47:20 +00:00
|
|
|
sdkp->protection_type = type;
|
|
|
|
|
2022-03-02 05:35:58 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sd_config_protection(struct scsi_disk *sdkp)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
|
|
|
|
sd_dif_config_host(sdkp);
|
|
|
|
|
|
|
|
if (!sdkp->protection_type)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!scsi_host_dif_capable(sdp->host, sdkp->protection_type)) {
|
2023-02-21 08:10:26 +00:00
|
|
|
sd_first_printk(KERN_NOTICE, sdkp,
|
|
|
|
"Disabling DIF Type %u protection\n",
|
|
|
|
sdkp->protection_type);
|
2022-03-02 05:35:58 +00:00
|
|
|
sdkp->protection_type = 0;
|
|
|
|
}
|
|
|
|
|
2023-02-21 08:10:26 +00:00
|
|
|
sd_first_printk(KERN_NOTICE, sdkp, "Enabling DIF Type %u protection\n",
|
|
|
|
sdkp->protection_type);
|
2008-07-17 08:28:34 +00:00
|
|
|
}
|
|
|
|
|
2009-03-12 18:20:29 +00:00
|
|
|
static void read_capacity_error(struct scsi_disk *sdkp, struct scsi_device *sdp,
|
|
|
|
struct scsi_sense_hdr *sshdr, int sense_valid,
|
|
|
|
int the_result)
|
|
|
|
{
|
2021-04-27 08:30:15 +00:00
|
|
|
if (sense_valid)
|
2009-03-12 18:20:29 +00:00
|
|
|
sd_print_sense_hdr(sdkp, sshdr);
|
|
|
|
else
|
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set dirty bit for removable devices if not ready -
|
|
|
|
* sometimes drives will not report this properly.
|
|
|
|
*/
|
|
|
|
if (sdp->removable &&
|
|
|
|
sense_valid && sshdr->sense_key == NOT_READY)
|
2010-12-18 17:42:23 +00:00
|
|
|
set_media_not_present(sdkp);
|
2009-03-12 18:20:29 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We used to set media_present to 0 here to indicate no media
|
|
|
|
* in the drive, but some drives fail read capacity even with
|
|
|
|
* media present, so we can't do that.
|
|
|
|
*/
|
|
|
|
sdkp->capacity = 0; /* unknown mapped to zero - as usual */
|
|
|
|
}
|
|
|
|
|
|
|
|
#define RC16_LEN 32
|
|
|
|
#if RC16_LEN > SD_BUF_SIZE
|
|
|
|
#error RC16_LEN must not be more than SD_BUF_SIZE
|
|
|
|
#endif
|
|
|
|
|
2010-04-01 14:30:01 +00:00
|
|
|
#define READ_CAPACITY_RETRIES_ON_RESET 10
|
|
|
|
|
2009-03-12 18:20:29 +00:00
|
|
|
static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
|
|
|
|
unsigned char *buffer)
|
2005-08-28 16:33:52 +00:00
|
|
|
{
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char cmd[16];
|
|
|
|
struct scsi_sense_hdr sshdr;
|
2022-12-29 19:01:47 +00:00
|
|
|
const struct scsi_exec_args exec_args = {
|
|
|
|
.sshdr = &sshdr,
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
int sense_valid = 0;
|
2009-03-12 18:20:29 +00:00
|
|
|
int the_result;
|
2010-04-01 14:30:01 +00:00
|
|
|
int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
|
2009-05-23 15:43:37 +00:00
|
|
|
unsigned int alignment;
|
2009-03-12 18:20:29 +00:00
|
|
|
unsigned long long lba;
|
|
|
|
unsigned sector_size;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-10-01 21:20:10 +00:00
|
|
|
if (sdp->no_read_capacity_16)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
do {
|
2009-03-12 18:20:29 +00:00
|
|
|
memset(cmd, 0, 16);
|
2014-11-17 13:25:19 +00:00
|
|
|
cmd[0] = SERVICE_ACTION_IN_16;
|
2009-03-12 18:20:29 +00:00
|
|
|
cmd[1] = SAI_READ_CAPACITY_16;
|
|
|
|
cmd[13] = RC16_LEN;
|
|
|
|
memset(buffer, 0, RC16_LEN);
|
|
|
|
|
2022-12-29 19:01:47 +00:00
|
|
|
the_result = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN,
|
|
|
|
buffer, RC16_LEN, SD_TIMEOUT,
|
|
|
|
sdkp->max_retries, &exec_args);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-08-28 16:33:52 +00:00
|
|
|
if (media_not_present(sdkp, &sshdr))
|
2009-03-12 18:20:29 +00:00
|
|
|
return -ENODEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-04-27 08:30:12 +00:00
|
|
|
if (the_result > 0) {
|
2005-08-28 16:33:52 +00:00
|
|
|
sense_valid = scsi_sense_valid(&sshdr);
|
2009-03-12 18:20:30 +00:00
|
|
|
if (sense_valid &&
|
|
|
|
sshdr.sense_key == ILLEGAL_REQUEST &&
|
|
|
|
(sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
|
|
|
|
sshdr.ascq == 0x00)
|
|
|
|
/* Invalid Command Operation Code or
|
|
|
|
* Invalid Field in CDB, just retry
|
|
|
|
* silently with RC10 */
|
|
|
|
return -EINVAL;
|
2010-04-01 14:30:01 +00:00
|
|
|
if (sense_valid &&
|
|
|
|
sshdr.sense_key == UNIT_ATTENTION &&
|
|
|
|
sshdr.asc == 0x29 && sshdr.ascq == 0x00)
|
|
|
|
/* Device reset might occur several times,
|
|
|
|
* give it one more chance */
|
|
|
|
if (--reset_retries > 0)
|
|
|
|
continue;
|
2009-03-12 18:20:30 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
retries--;
|
|
|
|
|
|
|
|
} while (the_result && retries);
|
|
|
|
|
2009-03-12 18:20:29 +00:00
|
|
|
if (the_result) {
|
2014-10-24 12:27:00 +00:00
|
|
|
sd_print_result(sdkp, "Read Capacity(16) failed", the_result);
|
2009-03-12 18:20:29 +00:00
|
|
|
read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2007-02-28 03:40:55 +00:00
|
|
|
|
2009-04-21 23:43:27 +00:00
|
|
|
sector_size = get_unaligned_be32(&buffer[8]);
|
|
|
|
lba = get_unaligned_be64(&buffer[0]);
|
2009-03-12 18:20:29 +00:00
|
|
|
|
2012-09-21 16:44:12 +00:00
|
|
|
if (sd_read_protection_type(sdkp, buffer) < 0) {
|
|
|
|
sdkp->capacity = 0;
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
2009-03-12 18:20:29 +00:00
|
|
|
|
2009-05-23 15:43:37 +00:00
|
|
|
/* Logical blocks per physical block exponent */
|
2010-09-28 18:48:47 +00:00
|
|
|
sdkp->physical_block_size = (1 << (buffer[13] & 0xf)) * sector_size;
|
2009-05-23 15:43:37 +00:00
|
|
|
|
2016-10-18 06:40:34 +00:00
|
|
|
/* RC basis */
|
|
|
|
sdkp->rc_basis = (buffer[12] >> 4) & 0x3;
|
|
|
|
|
2009-05-23 15:43:37 +00:00
|
|
|
/* Lowest aligned logical block */
|
|
|
|
alignment = ((buffer[14] & 0x3f) << 8 | buffer[15]) * sector_size;
|
|
|
|
blk_queue_alignment_offset(sdp->request_queue, alignment);
|
|
|
|
if (alignment && sdkp->first_scan)
|
|
|
|
sd_printk(KERN_NOTICE, sdkp,
|
|
|
|
"physical block alignment offset: %u\n", alignment);
|
|
|
|
|
2011-03-08 07:07:15 +00:00
|
|
|
if (buffer[14] & 0x80) { /* LBPME */
|
|
|
|
sdkp->lbpme = 1;
|
2009-11-26 17:00:40 +00:00
|
|
|
|
2011-03-08 07:07:15 +00:00
|
|
|
if (buffer[14] & 0x40) /* LBPRZ */
|
|
|
|
sdkp->lbprz = 1;
|
2009-11-26 17:00:40 +00:00
|
|
|
|
2011-03-08 07:07:15 +00:00
|
|
|
sd_config_discard(sdkp, SD_LBP_WS16);
|
2009-11-26 17:00:40 +00:00
|
|
|
}
|
|
|
|
|
2009-03-12 18:20:29 +00:00
|
|
|
sdkp->capacity = lba + 1;
|
|
|
|
return sector_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
|
|
|
|
unsigned char *buffer)
|
|
|
|
{
|
|
|
|
unsigned char cmd[16];
|
|
|
|
struct scsi_sense_hdr sshdr;
|
2022-12-29 19:01:47 +00:00
|
|
|
const struct scsi_exec_args exec_args = {
|
|
|
|
.sshdr = &sshdr,
|
|
|
|
};
|
2009-03-12 18:20:29 +00:00
|
|
|
int sense_valid = 0;
|
|
|
|
int the_result;
|
2010-04-01 14:30:01 +00:00
|
|
|
int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
|
2009-03-12 18:20:29 +00:00
|
|
|
sector_t lba;
|
|
|
|
unsigned sector_size;
|
|
|
|
|
|
|
|
do {
|
|
|
|
cmd[0] = READ_CAPACITY;
|
|
|
|
memset(&cmd[1], 0, 9);
|
|
|
|
memset(buffer, 0, 8);
|
|
|
|
|
2022-12-29 19:01:47 +00:00
|
|
|
the_result = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, buffer,
|
|
|
|
8, SD_TIMEOUT, sdkp->max_retries,
|
|
|
|
&exec_args);
|
2009-03-12 18:20:29 +00:00
|
|
|
|
|
|
|
if (media_not_present(sdkp, &sshdr))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2021-04-27 08:30:12 +00:00
|
|
|
if (the_result > 0) {
|
2009-03-12 18:20:29 +00:00
|
|
|
sense_valid = scsi_sense_valid(&sshdr);
|
2010-04-01 14:30:01 +00:00
|
|
|
if (sense_valid &&
|
|
|
|
sshdr.sense_key == UNIT_ATTENTION &&
|
|
|
|
sshdr.asc == 0x29 && sshdr.ascq == 0x00)
|
|
|
|
/* Device reset might occur several times,
|
|
|
|
* give it one more chance */
|
|
|
|
if (--reset_retries > 0)
|
|
|
|
continue;
|
|
|
|
}
|
2009-03-12 18:20:29 +00:00
|
|
|
retries--;
|
|
|
|
|
|
|
|
} while (the_result && retries);
|
|
|
|
|
|
|
|
if (the_result) {
|
2014-10-24 12:27:00 +00:00
|
|
|
sd_print_result(sdkp, "Read Capacity(10) failed", the_result);
|
2009-03-12 18:20:29 +00:00
|
|
|
read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-04-21 23:43:27 +00:00
|
|
|
sector_size = get_unaligned_be32(&buffer[4]);
|
|
|
|
lba = get_unaligned_be32(&buffer[0]);
|
2009-03-12 18:20:29 +00:00
|
|
|
|
2010-10-01 21:20:10 +00:00
|
|
|
if (sdp->no_read_capacity_16 && (lba == 0xffffffff)) {
|
|
|
|
/* Some buggy (usb cardreader) devices return an lba of
|
|
|
|
0xffffffff when the want to report a size of 0 (with
|
|
|
|
which they really mean no media is present) */
|
|
|
|
sdkp->capacity = 0;
|
2010-10-23 03:30:48 +00:00
|
|
|
sdkp->physical_block_size = sector_size;
|
2010-10-01 21:20:10 +00:00
|
|
|
return sector_size;
|
|
|
|
}
|
|
|
|
|
2009-03-12 18:20:29 +00:00
|
|
|
sdkp->capacity = lba + 1;
|
2010-09-28 18:48:47 +00:00
|
|
|
sdkp->physical_block_size = sector_size;
|
2009-03-12 18:20:29 +00:00
|
|
|
return sector_size;
|
|
|
|
}
|
|
|
|
|
2009-03-12 18:20:30 +00:00
|
|
|
static int sd_try_rc16_first(struct scsi_device *sdp)
|
|
|
|
{
|
2010-03-29 07:29:24 +00:00
|
|
|
if (sdp->host->max_cmd_len < 16)
|
|
|
|
return 0;
|
2012-06-20 20:04:19 +00:00
|
|
|
if (sdp->try_rc_10_first)
|
|
|
|
return 0;
|
2009-03-12 18:20:30 +00:00
|
|
|
if (sdp->scsi_level > SCSI_SPC_2)
|
|
|
|
return 1;
|
|
|
|
if (scsi_device_protection(sdp))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-12 18:20:29 +00:00
|
|
|
/*
|
|
|
|
* read disk capacity
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer)
|
|
|
|
{
|
|
|
|
int sector_size;
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
|
2009-03-12 18:20:30 +00:00
|
|
|
if (sd_try_rc16_first(sdp)) {
|
2009-03-12 18:20:29 +00:00
|
|
|
sector_size = read_capacity_16(sdkp, sdp, buffer);
|
|
|
|
if (sector_size == -EOVERFLOW)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto got_data;
|
2009-03-12 18:20:30 +00:00
|
|
|
if (sector_size == -ENODEV)
|
|
|
|
return;
|
|
|
|
if (sector_size < 0)
|
|
|
|
sector_size = read_capacity_10(sdkp, sdp, buffer);
|
2009-03-12 18:20:29 +00:00
|
|
|
if (sector_size < 0)
|
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2009-03-12 18:20:29 +00:00
|
|
|
sector_size = read_capacity_10(sdkp, sdp, buffer);
|
|
|
|
if (sector_size == -EOVERFLOW)
|
|
|
|
goto got_data;
|
|
|
|
if (sector_size < 0)
|
|
|
|
return;
|
|
|
|
if ((sizeof(sdkp->capacity) > 4) &&
|
|
|
|
(sdkp->capacity > 0xffffffffULL)) {
|
|
|
|
int old_sector_size = sector_size;
|
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Very big device. "
|
|
|
|
"Trying to use READ CAPACITY(16).\n");
|
|
|
|
sector_size = read_capacity_16(sdkp, sdp, buffer);
|
|
|
|
if (sector_size < 0) {
|
|
|
|
sd_printk(KERN_NOTICE, sdkp,
|
|
|
|
"Using 0xffffffff as device size\n");
|
|
|
|
sdkp->capacity = 1 + (sector_t) 0xffffffff;
|
|
|
|
sector_size = old_sector_size;
|
|
|
|
goto got_data;
|
|
|
|
}
|
2018-03-14 16:15:56 +00:00
|
|
|
/* Remember that READ CAPACITY(16) succeeded */
|
|
|
|
sdp->try_rc_10_first = 0;
|
2009-03-12 18:20:29 +00:00
|
|
|
}
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-02-18 15:54:44 +00:00
|
|
|
/* Some devices are known to return the total number of blocks,
|
|
|
|
* not the highest block number. Some devices have versions
|
|
|
|
* which do this and others which do not. Some devices we might
|
|
|
|
* suspect of doing this but we don't know for certain.
|
|
|
|
*
|
|
|
|
* If we know the reported capacity is wrong, decrement it. If
|
|
|
|
* we can only guess, then assume the number of blocks is even
|
|
|
|
* (usually true but not always) and err on the side of lowering
|
|
|
|
* the capacity.
|
|
|
|
*/
|
|
|
|
if (sdp->fix_capacity ||
|
|
|
|
(sdp->guess_capacity && (sdkp->capacity & 0x01))) {
|
|
|
|
sd_printk(KERN_INFO, sdkp, "Adjusting the sector count "
|
|
|
|
"from its reported value: %llu\n",
|
|
|
|
(unsigned long long) sdkp->capacity);
|
2005-04-16 22:20:36 +00:00
|
|
|
--sdkp->capacity;
|
2007-02-08 08:04:48 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
got_data:
|
|
|
|
if (sector_size == 0) {
|
|
|
|
sector_size = 512;
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, "
|
|
|
|
"assuming 512.\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sector_size != 512 &&
|
|
|
|
sector_size != 1024 &&
|
|
|
|
sector_size != 2048 &&
|
2015-05-13 08:49:09 +00:00
|
|
|
sector_size != 4096) {
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n",
|
|
|
|
sector_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The user might want to re-format the drive with
|
|
|
|
* a supported sectorsize. Once this happens, it
|
|
|
|
* would be relatively trivial to set the thing up.
|
|
|
|
* For this reason, we leave the thing in the table.
|
|
|
|
*/
|
|
|
|
sdkp->capacity = 0;
|
|
|
|
/*
|
|
|
|
* set a bogus sector size so the normal read/write
|
|
|
|
* logic in the block layer will eventually refuse any
|
|
|
|
* request on this device without tripping over power
|
|
|
|
* of two sector size assumptions
|
|
|
|
*/
|
|
|
|
sector_size = 512;
|
|
|
|
}
|
2009-05-22 21:17:49 +00:00
|
|
|
blk_queue_logical_block_size(sdp->request_queue, sector_size);
|
2016-10-18 06:40:34 +00:00
|
|
|
blk_queue_physical_block_size(sdp->request_queue,
|
|
|
|
sdkp->physical_block_size);
|
|
|
|
sdkp->device->sector_size = sector_size;
|
2008-08-31 15:41:52 +00:00
|
|
|
|
2016-10-18 06:40:34 +00:00
|
|
|
if (sdkp->capacity > 0xffffffff)
|
|
|
|
sdp->use_16_for_rw = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-10-18 06:40:34 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-10-18 06:40:34 +00:00
|
|
|
/*
|
|
|
|
* Print disk capacity
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
sd_print_capacity(struct scsi_disk *sdkp,
|
|
|
|
sector_t old_capacity)
|
|
|
|
{
|
|
|
|
int sector_size = sdkp->device->sector_size;
|
|
|
|
char cap_str_2[10], cap_str_10[10];
|
2009-05-23 15:43:37 +00:00
|
|
|
|
2019-01-30 07:07:34 +00:00
|
|
|
if (!sdkp->first_scan && old_capacity == sdkp->capacity)
|
|
|
|
return;
|
|
|
|
|
2016-10-18 06:40:34 +00:00
|
|
|
string_get_size(sdkp->capacity, sector_size,
|
|
|
|
STRING_UNITS_2, cap_str_2, sizeof(cap_str_2));
|
|
|
|
string_get_size(sdkp->capacity, sector_size,
|
2019-01-30 07:07:34 +00:00
|
|
|
STRING_UNITS_10, cap_str_10, sizeof(cap_str_10));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-01-30 07:07:34 +00:00
|
|
|
sd_printk(KERN_NOTICE, sdkp,
|
|
|
|
"%llu %d-byte logical blocks: (%s/%s)\n",
|
|
|
|
(unsigned long long)sdkp->capacity,
|
|
|
|
sector_size, cap_str_10, cap_str_2);
|
2012-11-14 22:03:22 +00:00
|
|
|
|
2019-01-30 07:07:34 +00:00
|
|
|
if (sdkp->physical_block_size != sector_size)
|
|
|
|
sd_printk(KERN_NOTICE, sdkp,
|
|
|
|
"%u-byte physical blocks\n",
|
|
|
|
sdkp->physical_block_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* called with buffer of length 512 */
|
|
|
|
static inline int
|
2020-10-01 15:35:54 +00:00
|
|
|
sd_do_mode_sense(struct scsi_disk *sdkp, int dbd, int modepage,
|
2005-08-28 16:33:52 +00:00
|
|
|
unsigned char *buffer, int len, struct scsi_mode_data *data,
|
|
|
|
struct scsi_sense_hdr *sshdr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2021-08-20 07:02:55 +00:00
|
|
|
/*
|
|
|
|
* If we must use MODE SENSE(10), make sure that the buffer length
|
|
|
|
* is at least 8 bytes so that the mode sense header fits.
|
|
|
|
*/
|
|
|
|
if (sdkp->device->use_10_for_ms && len < 8)
|
|
|
|
len = 8;
|
|
|
|
|
2020-10-01 15:35:54 +00:00
|
|
|
return scsi_mode_sense(sdkp->device, dbd, modepage, buffer, len,
|
|
|
|
SD_TIMEOUT, sdkp->max_retries, data,
|
2005-08-28 16:33:52 +00:00
|
|
|
sshdr);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* read write protect setting, if possible - called only in sd_revalidate_disk()
|
2006-02-26 14:34:10 +00:00
|
|
|
* called with buffer of length SD_BUF_SIZE
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
static void
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer)
|
2005-08-28 16:33:52 +00:00
|
|
|
{
|
2005-04-16 22:20:36 +00:00
|
|
|
int res;
|
2005-08-28 16:33:52 +00:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct scsi_mode_data data;
|
2009-03-09 15:33:31 +00:00
|
|
|
int old_wp = sdkp->write_prot;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
set_disk_ro(sdkp->disk, 0);
|
2005-08-28 16:33:52 +00:00
|
|
|
if (sdp->skip_ms_page_3f) {
|
2014-01-03 23:19:26 +00:00
|
|
|
sd_first_printk(KERN_NOTICE, sdkp, "Assuming Write Enabled\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-08-28 16:33:52 +00:00
|
|
|
if (sdp->use_192_bytes_for_3f) {
|
2020-10-01 15:35:54 +00:00
|
|
|
res = sd_do_mode_sense(sdkp, 0, 0x3F, buffer, 192, &data, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* First attempt: ask for all pages (0x3F), but only 4 bytes.
|
|
|
|
* We have to start carefully: some devices hang if we ask
|
|
|
|
* for more than is available.
|
|
|
|
*/
|
2020-10-01 15:35:54 +00:00
|
|
|
res = sd_do_mode_sense(sdkp, 0, 0x3F, buffer, 4, &data, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Second attempt: ask for page 0 When only page 0 is
|
|
|
|
* implemented, a request for page 3F may return Sense Key
|
|
|
|
* 5: Illegal Request, Sense Code 24: Invalid field in
|
|
|
|
* CDB.
|
|
|
|
*/
|
2021-04-27 08:30:09 +00:00
|
|
|
if (res < 0)
|
2020-10-01 15:35:54 +00:00
|
|
|
res = sd_do_mode_sense(sdkp, 0, 0, buffer, 4, &data, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Third attempt: ask 255 bytes, as we did earlier.
|
|
|
|
*/
|
2021-04-27 08:30:09 +00:00
|
|
|
if (res < 0)
|
2020-10-01 15:35:54 +00:00
|
|
|
res = sd_do_mode_sense(sdkp, 0, 0x3F, buffer, 255,
|
2005-08-28 16:33:52 +00:00
|
|
|
&data, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2021-04-27 08:30:09 +00:00
|
|
|
if (res < 0) {
|
2014-01-03 23:19:26 +00:00
|
|
|
sd_first_printk(KERN_WARNING, sdkp,
|
2007-02-28 03:40:55 +00:00
|
|
|
"Test WP failed, assume Write Enabled\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
sdkp->write_prot = ((data.device_specific & 0x80) != 0);
|
2019-05-20 14:57:18 +00:00
|
|
|
set_disk_ro(sdkp->disk, sdkp->write_prot);
|
2009-03-09 15:33:31 +00:00
|
|
|
if (sdkp->first_scan || old_wp != sdkp->write_prot) {
|
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n",
|
|
|
|
sdkp->write_prot ? "on" : "off");
|
2016-10-22 17:32:30 +00:00
|
|
|
sd_printk(KERN_DEBUG, sdkp, "Mode Sense: %4ph\n", buffer);
|
2009-03-09 15:33:31 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* sd_read_cache_type - called only from sd_revalidate_disk()
|
2006-02-26 14:34:10 +00:00
|
|
|
* called with buffer of length SD_BUF_SIZE
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
static void
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
|
2005-05-16 00:59:55 +00:00
|
|
|
{
|
2005-04-16 22:20:36 +00:00
|
|
|
int len = 0, res;
|
2005-08-28 16:33:52 +00:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-05-16 00:59:55 +00:00
|
|
|
int dbd;
|
|
|
|
int modepage;
|
[SCSI] Retrieve the Caching mode page (version 2)
Some kernel transport drivers unconditionally disable
retrieval of the Caching mode page. One such for example is
the BBB/CBI transport over USB. Such a restraint is too
harsh as some devices do support the Caching mode
page. Unconditionally enabling the retrieval of this mode
page over those transports at their transport code level may
result in some devices failing and becoming unusable.
This patch implements a method of retrieving the Caching
mode page without unconditionally enabling it in the
transports which unconditionally disable it. The idea is to
ask for all supported pages, page code 0x3F, and then search
for the Caching mode page in the mode parameter data
returned. The sd driver already asks for all the mode pages
supported by the attached device by setting the page code to
0x3F in order to find out if the media is write protected by
reading the WP bit in the Device Specific Parameter
field. It then attempts to retrieve only the Caching mode
page by setting the page code to 8 and actually attempting
to retrieve it if and only if the transport allows it.
The method implemented here is that if the transport doesn't
allow retrieval of the Caching mode page and the device is
not RBC, then we ask for all pages supported by setting the
page code to 0x3F (similarly to how the WP bit is retrieved
above), and then we search for the Caching mode page in the
mode parameter data returned.
With this patch, devices over SATA, report this (no change):
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] 976773168 512-byte logical blocks: (500 GB/465 GiB)
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: Attached scsi generic sg0 type 0
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
Smart devices report their Caching mode page. This is a
change where we'd previously see the kernel making
assumption about the device's cache being write-through:
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: Attached scsi generic sg2 type 0
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] 610472646 4096-byte logical blocks: (2.50 TB/2.27 TiB)
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Mode Sense: 47 00 10 08
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write cache: enabled, read cache: enabled, supports DPO and FUA
And "dumb" devices over BBB, are correctly shown not to
support reporting the Caching mode page:
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] 15663104 512-byte logical blocks: (8.01 GB/7.46 GiB)
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Write Protect is off
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Mode Sense: 23 00 00 00
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] No Caching mode page present
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Assuming drive cache: write through
Version 2 adds this:
Some devices don't support page code 0x3F, and others require a
fixed transfer length of 192 bytes. This single commit includes a
patch by Alan Stern which fixes this.
Reported-and-tested-by: Richard Senior <richard@r-senior.demon.co.uk>
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
2011-05-19 07:00:58 +00:00
|
|
|
int first_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct scsi_mode_data data;
|
|
|
|
struct scsi_sense_hdr sshdr;
|
2009-03-09 15:33:31 +00:00
|
|
|
int old_wce = sdkp->WCE;
|
|
|
|
int old_rcd = sdkp->RCD;
|
|
|
|
int old_dpofua = sdkp->DPOFUA;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-04-24 21:02:53 +00:00
|
|
|
|
|
|
|
if (sdkp->cache_override)
|
|
|
|
return;
|
|
|
|
|
[SCSI] Retrieve the Caching mode page (version 2)
Some kernel transport drivers unconditionally disable
retrieval of the Caching mode page. One such for example is
the BBB/CBI transport over USB. Such a restraint is too
harsh as some devices do support the Caching mode
page. Unconditionally enabling the retrieval of this mode
page over those transports at their transport code level may
result in some devices failing and becoming unusable.
This patch implements a method of retrieving the Caching
mode page without unconditionally enabling it in the
transports which unconditionally disable it. The idea is to
ask for all supported pages, page code 0x3F, and then search
for the Caching mode page in the mode parameter data
returned. The sd driver already asks for all the mode pages
supported by the attached device by setting the page code to
0x3F in order to find out if the media is write protected by
reading the WP bit in the Device Specific Parameter
field. It then attempts to retrieve only the Caching mode
page by setting the page code to 8 and actually attempting
to retrieve it if and only if the transport allows it.
The method implemented here is that if the transport doesn't
allow retrieval of the Caching mode page and the device is
not RBC, then we ask for all pages supported by setting the
page code to 0x3F (similarly to how the WP bit is retrieved
above), and then we search for the Caching mode page in the
mode parameter data returned.
With this patch, devices over SATA, report this (no change):
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] 976773168 512-byte logical blocks: (500 GB/465 GiB)
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: Attached scsi generic sg0 type 0
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
Smart devices report their Caching mode page. This is a
change where we'd previously see the kernel making
assumption about the device's cache being write-through:
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: Attached scsi generic sg2 type 0
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] 610472646 4096-byte logical blocks: (2.50 TB/2.27 TiB)
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Mode Sense: 47 00 10 08
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write cache: enabled, read cache: enabled, supports DPO and FUA
And "dumb" devices over BBB, are correctly shown not to
support reporting the Caching mode page:
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] 15663104 512-byte logical blocks: (8.01 GB/7.46 GiB)
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Write Protect is off
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Mode Sense: 23 00 00 00
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] No Caching mode page present
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Assuming drive cache: write through
Version 2 adds this:
Some devices don't support page code 0x3F, and others require a
fixed transfer length of 192 bytes. This single commit includes a
patch by Alan Stern which fixes this.
Reported-and-tested-by: Richard Senior <richard@r-senior.demon.co.uk>
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
2011-05-19 07:00:58 +00:00
|
|
|
first_len = 4;
|
|
|
|
if (sdp->skip_ms_page_8) {
|
|
|
|
if (sdp->type == TYPE_RBC)
|
|
|
|
goto defaults;
|
|
|
|
else {
|
|
|
|
if (sdp->skip_ms_page_3f)
|
|
|
|
goto defaults;
|
|
|
|
modepage = 0x3F;
|
|
|
|
if (sdp->use_192_bytes_for_3f)
|
|
|
|
first_len = 192;
|
|
|
|
dbd = 0;
|
|
|
|
}
|
|
|
|
} else if (sdp->type == TYPE_RBC) {
|
2005-05-16 00:59:55 +00:00
|
|
|
modepage = 6;
|
|
|
|
dbd = 8;
|
|
|
|
} else {
|
|
|
|
modepage = 8;
|
|
|
|
dbd = 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* cautiously ask */
|
2020-10-01 15:35:54 +00:00
|
|
|
res = sd_do_mode_sense(sdkp, dbd, modepage, buffer, first_len,
|
[SCSI] Retrieve the Caching mode page (version 2)
Some kernel transport drivers unconditionally disable
retrieval of the Caching mode page. One such for example is
the BBB/CBI transport over USB. Such a restraint is too
harsh as some devices do support the Caching mode
page. Unconditionally enabling the retrieval of this mode
page over those transports at their transport code level may
result in some devices failing and becoming unusable.
This patch implements a method of retrieving the Caching
mode page without unconditionally enabling it in the
transports which unconditionally disable it. The idea is to
ask for all supported pages, page code 0x3F, and then search
for the Caching mode page in the mode parameter data
returned. The sd driver already asks for all the mode pages
supported by the attached device by setting the page code to
0x3F in order to find out if the media is write protected by
reading the WP bit in the Device Specific Parameter
field. It then attempts to retrieve only the Caching mode
page by setting the page code to 8 and actually attempting
to retrieve it if and only if the transport allows it.
The method implemented here is that if the transport doesn't
allow retrieval of the Caching mode page and the device is
not RBC, then we ask for all pages supported by setting the
page code to 0x3F (similarly to how the WP bit is retrieved
above), and then we search for the Caching mode page in the
mode parameter data returned.
With this patch, devices over SATA, report this (no change):
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] 976773168 512-byte logical blocks: (500 GB/465 GiB)
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: Attached scsi generic sg0 type 0
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
Smart devices report their Caching mode page. This is a
change where we'd previously see the kernel making
assumption about the device's cache being write-through:
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: Attached scsi generic sg2 type 0
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] 610472646 4096-byte logical blocks: (2.50 TB/2.27 TiB)
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Mode Sense: 47 00 10 08
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write cache: enabled, read cache: enabled, supports DPO and FUA
And "dumb" devices over BBB, are correctly shown not to
support reporting the Caching mode page:
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] 15663104 512-byte logical blocks: (8.01 GB/7.46 GiB)
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Write Protect is off
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Mode Sense: 23 00 00 00
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] No Caching mode page present
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Assuming drive cache: write through
Version 2 adds this:
Some devices don't support page code 0x3F, and others require a
fixed transfer length of 192 bytes. This single commit includes a
patch by Alan Stern which fixes this.
Reported-and-tested-by: Richard Senior <richard@r-senior.demon.co.uk>
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
2011-05-19 07:00:58 +00:00
|
|
|
&data, &sshdr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-04-27 08:30:09 +00:00
|
|
|
if (res < 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto bad_sense;
|
|
|
|
|
2006-02-23 01:03:16 +00:00
|
|
|
if (!data.header_length) {
|
|
|
|
modepage = 6;
|
[SCSI] Retrieve the Caching mode page (version 2)
Some kernel transport drivers unconditionally disable
retrieval of the Caching mode page. One such for example is
the BBB/CBI transport over USB. Such a restraint is too
harsh as some devices do support the Caching mode
page. Unconditionally enabling the retrieval of this mode
page over those transports at their transport code level may
result in some devices failing and becoming unusable.
This patch implements a method of retrieving the Caching
mode page without unconditionally enabling it in the
transports which unconditionally disable it. The idea is to
ask for all supported pages, page code 0x3F, and then search
for the Caching mode page in the mode parameter data
returned. The sd driver already asks for all the mode pages
supported by the attached device by setting the page code to
0x3F in order to find out if the media is write protected by
reading the WP bit in the Device Specific Parameter
field. It then attempts to retrieve only the Caching mode
page by setting the page code to 8 and actually attempting
to retrieve it if and only if the transport allows it.
The method implemented here is that if the transport doesn't
allow retrieval of the Caching mode page and the device is
not RBC, then we ask for all pages supported by setting the
page code to 0x3F (similarly to how the WP bit is retrieved
above), and then we search for the Caching mode page in the
mode parameter data returned.
With this patch, devices over SATA, report this (no change):
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] 976773168 512-byte logical blocks: (500 GB/465 GiB)
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: Attached scsi generic sg0 type 0
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
Smart devices report their Caching mode page. This is a
change where we'd previously see the kernel making
assumption about the device's cache being write-through:
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: Attached scsi generic sg2 type 0
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] 610472646 4096-byte logical blocks: (2.50 TB/2.27 TiB)
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Mode Sense: 47 00 10 08
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write cache: enabled, read cache: enabled, supports DPO and FUA
And "dumb" devices over BBB, are correctly shown not to
support reporting the Caching mode page:
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] 15663104 512-byte logical blocks: (8.01 GB/7.46 GiB)
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Write Protect is off
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Mode Sense: 23 00 00 00
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] No Caching mode page present
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Assuming drive cache: write through
Version 2 adds this:
Some devices don't support page code 0x3F, and others require a
fixed transfer length of 192 bytes. This single commit includes a
patch by Alan Stern which fixes this.
Reported-and-tested-by: Richard Senior <richard@r-senior.demon.co.uk>
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
2011-05-19 07:00:58 +00:00
|
|
|
first_len = 0;
|
2014-01-03 23:19:26 +00:00
|
|
|
sd_first_printk(KERN_ERR, sdkp,
|
|
|
|
"Missing header in MODE_SENSE response\n");
|
2006-02-23 01:03:16 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* that went OK, now ask for the proper length */
|
|
|
|
len = data.length;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We're only interested in the first three bytes, actually.
|
|
|
|
* But the data cache page is defined for the first 20.
|
|
|
|
*/
|
|
|
|
if (len < 3)
|
|
|
|
goto bad_sense;
|
[SCSI] Retrieve the Caching mode page (version 2)
Some kernel transport drivers unconditionally disable
retrieval of the Caching mode page. One such for example is
the BBB/CBI transport over USB. Such a restraint is too
harsh as some devices do support the Caching mode
page. Unconditionally enabling the retrieval of this mode
page over those transports at their transport code level may
result in some devices failing and becoming unusable.
This patch implements a method of retrieving the Caching
mode page without unconditionally enabling it in the
transports which unconditionally disable it. The idea is to
ask for all supported pages, page code 0x3F, and then search
for the Caching mode page in the mode parameter data
returned. The sd driver already asks for all the mode pages
supported by the attached device by setting the page code to
0x3F in order to find out if the media is write protected by
reading the WP bit in the Device Specific Parameter
field. It then attempts to retrieve only the Caching mode
page by setting the page code to 8 and actually attempting
to retrieve it if and only if the transport allows it.
The method implemented here is that if the transport doesn't
allow retrieval of the Caching mode page and the device is
not RBC, then we ask for all pages supported by setting the
page code to 0x3F (similarly to how the WP bit is retrieved
above), and then we search for the Caching mode page in the
mode parameter data returned.
With this patch, devices over SATA, report this (no change):
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] 976773168 512-byte logical blocks: (500 GB/465 GiB)
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: Attached scsi generic sg0 type 0
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
Smart devices report their Caching mode page. This is a
change where we'd previously see the kernel making
assumption about the device's cache being write-through:
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: Attached scsi generic sg2 type 0
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] 610472646 4096-byte logical blocks: (2.50 TB/2.27 TiB)
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Mode Sense: 47 00 10 08
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write cache: enabled, read cache: enabled, supports DPO and FUA
And "dumb" devices over BBB, are correctly shown not to
support reporting the Caching mode page:
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] 15663104 512-byte logical blocks: (8.01 GB/7.46 GiB)
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Write Protect is off
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Mode Sense: 23 00 00 00
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] No Caching mode page present
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Assuming drive cache: write through
Version 2 adds this:
Some devices don't support page code 0x3F, and others require a
fixed transfer length of 192 bytes. This single commit includes a
patch by Alan Stern which fixes this.
Reported-and-tested-by: Richard Senior <richard@r-senior.demon.co.uk>
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
2011-05-19 07:00:58 +00:00
|
|
|
else if (len > SD_BUF_SIZE) {
|
2014-01-03 23:19:26 +00:00
|
|
|
sd_first_printk(KERN_NOTICE, sdkp, "Truncating mode parameter "
|
[SCSI] Retrieve the Caching mode page (version 2)
Some kernel transport drivers unconditionally disable
retrieval of the Caching mode page. One such for example is
the BBB/CBI transport over USB. Such a restraint is too
harsh as some devices do support the Caching mode
page. Unconditionally enabling the retrieval of this mode
page over those transports at their transport code level may
result in some devices failing and becoming unusable.
This patch implements a method of retrieving the Caching
mode page without unconditionally enabling it in the
transports which unconditionally disable it. The idea is to
ask for all supported pages, page code 0x3F, and then search
for the Caching mode page in the mode parameter data
returned. The sd driver already asks for all the mode pages
supported by the attached device by setting the page code to
0x3F in order to find out if the media is write protected by
reading the WP bit in the Device Specific Parameter
field. It then attempts to retrieve only the Caching mode
page by setting the page code to 8 and actually attempting
to retrieve it if and only if the transport allows it.
The method implemented here is that if the transport doesn't
allow retrieval of the Caching mode page and the device is
not RBC, then we ask for all pages supported by setting the
page code to 0x3F (similarly to how the WP bit is retrieved
above), and then we search for the Caching mode page in the
mode parameter data returned.
With this patch, devices over SATA, report this (no change):
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] 976773168 512-byte logical blocks: (500 GB/465 GiB)
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: Attached scsi generic sg0 type 0
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
Smart devices report their Caching mode page. This is a
change where we'd previously see the kernel making
assumption about the device's cache being write-through:
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: Attached scsi generic sg2 type 0
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] 610472646 4096-byte logical blocks: (2.50 TB/2.27 TiB)
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Mode Sense: 47 00 10 08
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write cache: enabled, read cache: enabled, supports DPO and FUA
And "dumb" devices over BBB, are correctly shown not to
support reporting the Caching mode page:
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] 15663104 512-byte logical blocks: (8.01 GB/7.46 GiB)
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Write Protect is off
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Mode Sense: 23 00 00 00
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] No Caching mode page present
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Assuming drive cache: write through
Version 2 adds this:
Some devices don't support page code 0x3F, and others require a
fixed transfer length of 192 bytes. This single commit includes a
patch by Alan Stern which fixes this.
Reported-and-tested-by: Richard Senior <richard@r-senior.demon.co.uk>
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
2011-05-19 07:00:58 +00:00
|
|
|
"data from %d to %d bytes\n", len, SD_BUF_SIZE);
|
|
|
|
len = SD_BUF_SIZE;
|
|
|
|
}
|
|
|
|
if (modepage == 0x3F && sdp->use_192_bytes_for_3f)
|
|
|
|
len = 192;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Get the data */
|
[SCSI] Retrieve the Caching mode page (version 2)
Some kernel transport drivers unconditionally disable
retrieval of the Caching mode page. One such for example is
the BBB/CBI transport over USB. Such a restraint is too
harsh as some devices do support the Caching mode
page. Unconditionally enabling the retrieval of this mode
page over those transports at their transport code level may
result in some devices failing and becoming unusable.
This patch implements a method of retrieving the Caching
mode page without unconditionally enabling it in the
transports which unconditionally disable it. The idea is to
ask for all supported pages, page code 0x3F, and then search
for the Caching mode page in the mode parameter data
returned. The sd driver already asks for all the mode pages
supported by the attached device by setting the page code to
0x3F in order to find out if the media is write protected by
reading the WP bit in the Device Specific Parameter
field. It then attempts to retrieve only the Caching mode
page by setting the page code to 8 and actually attempting
to retrieve it if and only if the transport allows it.
The method implemented here is that if the transport doesn't
allow retrieval of the Caching mode page and the device is
not RBC, then we ask for all pages supported by setting the
page code to 0x3F (similarly to how the WP bit is retrieved
above), and then we search for the Caching mode page in the
mode parameter data returned.
With this patch, devices over SATA, report this (no change):
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] 976773168 512-byte logical blocks: (500 GB/465 GiB)
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: Attached scsi generic sg0 type 0
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
Smart devices report their Caching mode page. This is a
change where we'd previously see the kernel making
assumption about the device's cache being write-through:
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: Attached scsi generic sg2 type 0
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] 610472646 4096-byte logical blocks: (2.50 TB/2.27 TiB)
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Mode Sense: 47 00 10 08
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write cache: enabled, read cache: enabled, supports DPO and FUA
And "dumb" devices over BBB, are correctly shown not to
support reporting the Caching mode page:
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] 15663104 512-byte logical blocks: (8.01 GB/7.46 GiB)
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Write Protect is off
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Mode Sense: 23 00 00 00
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] No Caching mode page present
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Assuming drive cache: write through
Version 2 adds this:
Some devices don't support page code 0x3F, and others require a
fixed transfer length of 192 bytes. This single commit includes a
patch by Alan Stern which fixes this.
Reported-and-tested-by: Richard Senior <richard@r-senior.demon.co.uk>
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
2011-05-19 07:00:58 +00:00
|
|
|
if (len > first_len)
|
2020-10-01 15:35:54 +00:00
|
|
|
res = sd_do_mode_sense(sdkp, dbd, modepage, buffer, len,
|
[SCSI] Retrieve the Caching mode page (version 2)
Some kernel transport drivers unconditionally disable
retrieval of the Caching mode page. One such for example is
the BBB/CBI transport over USB. Such a restraint is too
harsh as some devices do support the Caching mode
page. Unconditionally enabling the retrieval of this mode
page over those transports at their transport code level may
result in some devices failing and becoming unusable.
This patch implements a method of retrieving the Caching
mode page without unconditionally enabling it in the
transports which unconditionally disable it. The idea is to
ask for all supported pages, page code 0x3F, and then search
for the Caching mode page in the mode parameter data
returned. The sd driver already asks for all the mode pages
supported by the attached device by setting the page code to
0x3F in order to find out if the media is write protected by
reading the WP bit in the Device Specific Parameter
field. It then attempts to retrieve only the Caching mode
page by setting the page code to 8 and actually attempting
to retrieve it if and only if the transport allows it.
The method implemented here is that if the transport doesn't
allow retrieval of the Caching mode page and the device is
not RBC, then we ask for all pages supported by setting the
page code to 0x3F (similarly to how the WP bit is retrieved
above), and then we search for the Caching mode page in the
mode parameter data returned.
With this patch, devices over SATA, report this (no change):
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] 976773168 512-byte logical blocks: (500 GB/465 GiB)
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: Attached scsi generic sg0 type 0
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
Smart devices report their Caching mode page. This is a
change where we'd previously see the kernel making
assumption about the device's cache being write-through:
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: Attached scsi generic sg2 type 0
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] 610472646 4096-byte logical blocks: (2.50 TB/2.27 TiB)
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Mode Sense: 47 00 10 08
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write cache: enabled, read cache: enabled, supports DPO and FUA
And "dumb" devices over BBB, are correctly shown not to
support reporting the Caching mode page:
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] 15663104 512-byte logical blocks: (8.01 GB/7.46 GiB)
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Write Protect is off
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Mode Sense: 23 00 00 00
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] No Caching mode page present
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Assuming drive cache: write through
Version 2 adds this:
Some devices don't support page code 0x3F, and others require a
fixed transfer length of 192 bytes. This single commit includes a
patch by Alan Stern which fixes this.
Reported-and-tested-by: Richard Senior <richard@r-senior.demon.co.uk>
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
2011-05-19 07:00:58 +00:00
|
|
|
&data, &sshdr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-04-27 08:30:09 +00:00
|
|
|
if (!res) {
|
2005-05-16 00:59:55 +00:00
|
|
|
int offset = data.header_length + data.block_descriptor_length;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
[SCSI] Retrieve the Caching mode page (version 2)
Some kernel transport drivers unconditionally disable
retrieval of the Caching mode page. One such for example is
the BBB/CBI transport over USB. Such a restraint is too
harsh as some devices do support the Caching mode
page. Unconditionally enabling the retrieval of this mode
page over those transports at their transport code level may
result in some devices failing and becoming unusable.
This patch implements a method of retrieving the Caching
mode page without unconditionally enabling it in the
transports which unconditionally disable it. The idea is to
ask for all supported pages, page code 0x3F, and then search
for the Caching mode page in the mode parameter data
returned. The sd driver already asks for all the mode pages
supported by the attached device by setting the page code to
0x3F in order to find out if the media is write protected by
reading the WP bit in the Device Specific Parameter
field. It then attempts to retrieve only the Caching mode
page by setting the page code to 8 and actually attempting
to retrieve it if and only if the transport allows it.
The method implemented here is that if the transport doesn't
allow retrieval of the Caching mode page and the device is
not RBC, then we ask for all pages supported by setting the
page code to 0x3F (similarly to how the WP bit is retrieved
above), and then we search for the Caching mode page in the
mode parameter data returned.
With this patch, devices over SATA, report this (no change):
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] 976773168 512-byte logical blocks: (500 GB/465 GiB)
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: Attached scsi generic sg0 type 0
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
Smart devices report their Caching mode page. This is a
change where we'd previously see the kernel making
assumption about the device's cache being write-through:
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: Attached scsi generic sg2 type 0
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] 610472646 4096-byte logical blocks: (2.50 TB/2.27 TiB)
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Mode Sense: 47 00 10 08
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write cache: enabled, read cache: enabled, supports DPO and FUA
And "dumb" devices over BBB, are correctly shown not to
support reporting the Caching mode page:
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] 15663104 512-byte logical blocks: (8.01 GB/7.46 GiB)
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Write Protect is off
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Mode Sense: 23 00 00 00
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] No Caching mode page present
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Assuming drive cache: write through
Version 2 adds this:
Some devices don't support page code 0x3F, and others require a
fixed transfer length of 192 bytes. This single commit includes a
patch by Alan Stern which fixes this.
Reported-and-tested-by: Richard Senior <richard@r-senior.demon.co.uk>
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
2011-05-19 07:00:58 +00:00
|
|
|
while (offset < len) {
|
|
|
|
u8 page_code = buffer[offset] & 0x3F;
|
|
|
|
u8 spf = buffer[offset] & 0x40;
|
|
|
|
|
|
|
|
if (page_code == 8 || page_code == 6) {
|
|
|
|
/* We're interested only in the first 3 bytes.
|
|
|
|
*/
|
|
|
|
if (len - offset <= 2) {
|
2014-01-03 23:19:26 +00:00
|
|
|
sd_first_printk(KERN_ERR, sdkp,
|
|
|
|
"Incomplete mode parameter "
|
|
|
|
"data\n");
|
[SCSI] Retrieve the Caching mode page (version 2)
Some kernel transport drivers unconditionally disable
retrieval of the Caching mode page. One such for example is
the BBB/CBI transport over USB. Such a restraint is too
harsh as some devices do support the Caching mode
page. Unconditionally enabling the retrieval of this mode
page over those transports at their transport code level may
result in some devices failing and becoming unusable.
This patch implements a method of retrieving the Caching
mode page without unconditionally enabling it in the
transports which unconditionally disable it. The idea is to
ask for all supported pages, page code 0x3F, and then search
for the Caching mode page in the mode parameter data
returned. The sd driver already asks for all the mode pages
supported by the attached device by setting the page code to
0x3F in order to find out if the media is write protected by
reading the WP bit in the Device Specific Parameter
field. It then attempts to retrieve only the Caching mode
page by setting the page code to 8 and actually attempting
to retrieve it if and only if the transport allows it.
The method implemented here is that if the transport doesn't
allow retrieval of the Caching mode page and the device is
not RBC, then we ask for all pages supported by setting the
page code to 0x3F (similarly to how the WP bit is retrieved
above), and then we search for the Caching mode page in the
mode parameter data returned.
With this patch, devices over SATA, report this (no change):
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] 976773168 512-byte logical blocks: (500 GB/465 GiB)
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: Attached scsi generic sg0 type 0
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
Smart devices report their Caching mode page. This is a
change where we'd previously see the kernel making
assumption about the device's cache being write-through:
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: Attached scsi generic sg2 type 0
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] 610472646 4096-byte logical blocks: (2.50 TB/2.27 TiB)
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Mode Sense: 47 00 10 08
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write cache: enabled, read cache: enabled, supports DPO and FUA
And "dumb" devices over BBB, are correctly shown not to
support reporting the Caching mode page:
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] 15663104 512-byte logical blocks: (8.01 GB/7.46 GiB)
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Write Protect is off
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Mode Sense: 23 00 00 00
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] No Caching mode page present
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Assuming drive cache: write through
Version 2 adds this:
Some devices don't support page code 0x3F, and others require a
fixed transfer length of 192 bytes. This single commit includes a
patch by Alan Stern which fixes this.
Reported-and-tested-by: Richard Senior <richard@r-senior.demon.co.uk>
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
2011-05-19 07:00:58 +00:00
|
|
|
goto defaults;
|
|
|
|
} else {
|
|
|
|
modepage = page_code;
|
|
|
|
goto Page_found;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Go to the next page */
|
|
|
|
if (spf && len - offset > 3)
|
|
|
|
offset += 4 + (buffer[offset+2] << 8) +
|
|
|
|
buffer[offset+3];
|
|
|
|
else if (!spf && len - offset > 1)
|
|
|
|
offset += 2 + buffer[offset+1];
|
|
|
|
else {
|
2014-01-03 23:19:26 +00:00
|
|
|
sd_first_printk(KERN_ERR, sdkp,
|
|
|
|
"Incomplete mode "
|
|
|
|
"parameter data\n");
|
[SCSI] Retrieve the Caching mode page (version 2)
Some kernel transport drivers unconditionally disable
retrieval of the Caching mode page. One such for example is
the BBB/CBI transport over USB. Such a restraint is too
harsh as some devices do support the Caching mode
page. Unconditionally enabling the retrieval of this mode
page over those transports at their transport code level may
result in some devices failing and becoming unusable.
This patch implements a method of retrieving the Caching
mode page without unconditionally enabling it in the
transports which unconditionally disable it. The idea is to
ask for all supported pages, page code 0x3F, and then search
for the Caching mode page in the mode parameter data
returned. The sd driver already asks for all the mode pages
supported by the attached device by setting the page code to
0x3F in order to find out if the media is write protected by
reading the WP bit in the Device Specific Parameter
field. It then attempts to retrieve only the Caching mode
page by setting the page code to 8 and actually attempting
to retrieve it if and only if the transport allows it.
The method implemented here is that if the transport doesn't
allow retrieval of the Caching mode page and the device is
not RBC, then we ask for all pages supported by setting the
page code to 0x3F (similarly to how the WP bit is retrieved
above), and then we search for the Caching mode page in the
mode parameter data returned.
With this patch, devices over SATA, report this (no change):
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] 976773168 512-byte logical blocks: (500 GB/465 GiB)
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: Attached scsi generic sg0 type 0
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
Smart devices report their Caching mode page. This is a
change where we'd previously see the kernel making
assumption about the device's cache being write-through:
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: Attached scsi generic sg2 type 0
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] 610472646 4096-byte logical blocks: (2.50 TB/2.27 TiB)
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Mode Sense: 47 00 10 08
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write cache: enabled, read cache: enabled, supports DPO and FUA
And "dumb" devices over BBB, are correctly shown not to
support reporting the Caching mode page:
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] 15663104 512-byte logical blocks: (8.01 GB/7.46 GiB)
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Write Protect is off
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Mode Sense: 23 00 00 00
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] No Caching mode page present
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Assuming drive cache: write through
Version 2 adds this:
Some devices don't support page code 0x3F, and others require a
fixed transfer length of 192 bytes. This single commit includes a
patch by Alan Stern which fixes this.
Reported-and-tested-by: Richard Senior <richard@r-senior.demon.co.uk>
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
2011-05-19 07:00:58 +00:00
|
|
|
goto defaults;
|
|
|
|
}
|
|
|
|
}
|
2006-02-26 14:34:10 +00:00
|
|
|
}
|
|
|
|
|
2021-10-13 07:50:50 +00:00
|
|
|
sd_first_printk(KERN_WARNING, sdkp,
|
|
|
|
"No Caching mode page found\n");
|
2013-09-06 15:49:51 +00:00
|
|
|
goto defaults;
|
|
|
|
|
[SCSI] Retrieve the Caching mode page (version 2)
Some kernel transport drivers unconditionally disable
retrieval of the Caching mode page. One such for example is
the BBB/CBI transport over USB. Such a restraint is too
harsh as some devices do support the Caching mode
page. Unconditionally enabling the retrieval of this mode
page over those transports at their transport code level may
result in some devices failing and becoming unusable.
This patch implements a method of retrieving the Caching
mode page without unconditionally enabling it in the
transports which unconditionally disable it. The idea is to
ask for all supported pages, page code 0x3F, and then search
for the Caching mode page in the mode parameter data
returned. The sd driver already asks for all the mode pages
supported by the attached device by setting the page code to
0x3F in order to find out if the media is write protected by
reading the WP bit in the Device Specific Parameter
field. It then attempts to retrieve only the Caching mode
page by setting the page code to 8 and actually attempting
to retrieve it if and only if the transport allows it.
The method implemented here is that if the transport doesn't
allow retrieval of the Caching mode page and the device is
not RBC, then we ask for all pages supported by setting the
page code to 0x3F (similarly to how the WP bit is retrieved
above), and then we search for the Caching mode page in the
mode parameter data returned.
With this patch, devices over SATA, report this (no change):
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] 976773168 512-byte logical blocks: (500 GB/465 GiB)
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: Attached scsi generic sg0 type 0
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
Oct 22 18:45:58 localhost kernel: sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
Smart devices report their Caching mode page. This is a
change where we'd previously see the kernel making
assumption about the device's cache being write-through:
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: Attached scsi generic sg2 type 0
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] 610472646 4096-byte logical blocks: (2.50 TB/2.27 TiB)
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write Protect is off
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Mode Sense: 47 00 10 08
Oct 22 18:45:58 localhost kernel: sd 6:0:0:0: [sdb] Write cache: enabled, read cache: enabled, supports DPO and FUA
And "dumb" devices over BBB, are correctly shown not to
support reporting the Caching mode page:
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] 15663104 512-byte logical blocks: (8.01 GB/7.46 GiB)
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Write Protect is off
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Mode Sense: 23 00 00 00
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] No Caching mode page present
Oct 22 18:49:06 localhost kernel: sd 7:0:0:0: [sdc] Assuming drive cache: write through
Version 2 adds this:
Some devices don't support page code 0x3F, and others require a
fixed transfer length of 192 bytes. This single commit includes a
patch by Alan Stern which fixes this.
Reported-and-tested-by: Richard Senior <richard@r-senior.demon.co.uk>
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Luben Tuikov <ltuikov@yahoo.com>
Signed-off-by: James Bottomley <jbottomley@parallels.com>
2011-05-19 07:00:58 +00:00
|
|
|
Page_found:
|
2005-05-16 00:59:55 +00:00
|
|
|
if (modepage == 8) {
|
|
|
|
sdkp->WCE = ((buffer[offset + 2] & 0x04) != 0);
|
|
|
|
sdkp->RCD = ((buffer[offset + 2] & 0x01) != 0);
|
|
|
|
} else {
|
|
|
|
sdkp->WCE = ((buffer[offset + 2] & 0x01) == 0);
|
|
|
|
sdkp->RCD = 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-06 08:53:52 +00:00
|
|
|
sdkp->DPOFUA = (data.device_specific & 0x10) != 0;
|
2014-06-30 15:04:21 +00:00
|
|
|
if (sdp->broken_fua) {
|
|
|
|
sd_first_printk(KERN_NOTICE, sdkp, "Disabling FUA\n");
|
|
|
|
sdkp->DPOFUA = 0;
|
2017-01-12 06:25:10 +00:00
|
|
|
} else if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw &&
|
|
|
|
!sdkp->device->use_16_for_rw) {
|
2014-01-03 23:19:26 +00:00
|
|
|
sd_first_printk(KERN_NOTICE, sdkp,
|
2007-02-28 03:40:55 +00:00
|
|
|
"Uses READ/WRITE(6), disabling FUA\n");
|
2006-01-06 08:53:52 +00:00
|
|
|
sdkp->DPOFUA = 0;
|
|
|
|
}
|
|
|
|
|
2014-08-11 12:40:37 +00:00
|
|
|
/* No cache flush allowed for write protected devices */
|
|
|
|
if (sdkp->WCE && sdkp->write_prot)
|
|
|
|
sdkp->WCE = 0;
|
|
|
|
|
2009-03-09 15:33:31 +00:00
|
|
|
if (sdkp->first_scan || old_wce != sdkp->WCE ||
|
|
|
|
old_rcd != sdkp->RCD || old_dpofua != sdkp->DPOFUA)
|
|
|
|
sd_printk(KERN_NOTICE, sdkp,
|
|
|
|
"Write cache: %s, read cache: %s, %s\n",
|
|
|
|
sdkp->WCE ? "enabled" : "disabled",
|
|
|
|
sdkp->RCD ? "disabled" : "enabled",
|
|
|
|
sdkp->DPOFUA ? "supports DPO and FUA"
|
|
|
|
: "doesn't support DPO or FUA");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
bad_sense:
|
2005-08-28 16:33:52 +00:00
|
|
|
if (scsi_sense_valid(&sshdr) &&
|
2005-04-16 22:20:36 +00:00
|
|
|
sshdr.sense_key == ILLEGAL_REQUEST &&
|
|
|
|
sshdr.asc == 0x24 && sshdr.ascq == 0x0)
|
2007-02-28 03:40:55 +00:00
|
|
|
/* Invalid field in CDB */
|
2014-01-03 23:19:26 +00:00
|
|
|
sd_first_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
2014-01-03 23:19:26 +00:00
|
|
|
sd_first_printk(KERN_ERR, sdkp,
|
|
|
|
"Asking for cache data failed\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
defaults:
|
2012-07-08 03:05:08 +00:00
|
|
|
if (sdp->wce_default_on) {
|
2014-01-03 23:19:26 +00:00
|
|
|
sd_first_printk(KERN_NOTICE, sdkp,
|
|
|
|
"Assuming drive cache: write back\n");
|
2012-07-08 03:05:08 +00:00
|
|
|
sdkp->WCE = 1;
|
|
|
|
} else {
|
2021-10-13 07:50:50 +00:00
|
|
|
sd_first_printk(KERN_WARNING, sdkp,
|
2014-01-03 23:19:26 +00:00
|
|
|
"Assuming drive cache: write through\n");
|
2012-07-08 03:05:08 +00:00
|
|
|
sdkp->WCE = 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
sdkp->RCD = 0;
|
2006-02-26 14:34:10 +00:00
|
|
|
sdkp->DPOFUA = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-17 08:28:34 +00:00
|
|
|
/*
|
|
|
|
* The ATO bit indicates whether the DIF application tag is available
|
|
|
|
* for use by the operating system.
|
|
|
|
*/
|
2010-08-11 01:01:20 +00:00
|
|
|
static void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer)
|
2008-07-17 08:28:34 +00:00
|
|
|
{
|
|
|
|
int res, offset;
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
struct scsi_mode_data data;
|
|
|
|
struct scsi_sense_hdr sshdr;
|
|
|
|
|
2016-10-18 06:40:34 +00:00
|
|
|
if (sdp->type != TYPE_DISK && sdp->type != TYPE_ZBC)
|
2008-07-17 08:28:34 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (sdkp->protection_type == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
res = scsi_mode_sense(sdp, 1, 0x0a, buffer, 36, SD_TIMEOUT,
|
2020-10-01 15:35:54 +00:00
|
|
|
sdkp->max_retries, &data, &sshdr);
|
2008-07-17 08:28:34 +00:00
|
|
|
|
2021-04-27 08:30:09 +00:00
|
|
|
if (res < 0 || !data.header_length ||
|
2008-07-17 08:28:34 +00:00
|
|
|
data.length < 6) {
|
2014-01-03 23:19:26 +00:00
|
|
|
sd_first_printk(KERN_WARNING, sdkp,
|
2008-07-17 08:28:34 +00:00
|
|
|
"getting Control mode page failed, assume no ATO\n");
|
|
|
|
|
|
|
|
if (scsi_sense_valid(&sshdr))
|
|
|
|
sd_print_sense_hdr(sdkp, &sshdr);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
offset = data.header_length + data.block_descriptor_length;
|
|
|
|
|
|
|
|
if ((buffer[offset] & 0x3f) != 0x0a) {
|
2014-01-03 23:19:26 +00:00
|
|
|
sd_first_printk(KERN_ERR, sdkp, "ATO Got wrong page\n");
|
2008-07-17 08:28:34 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((buffer[offset + 5] & 0x80) == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sdkp->ATO = 1;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-05-23 15:43:39 +00:00
|
|
|
/**
|
|
|
|
* sd_read_block_limits - Query disk device for preferred I/O sizes.
|
2017-04-24 07:51:09 +00:00
|
|
|
* @sdkp: disk to query
|
2009-05-23 15:43:39 +00:00
|
|
|
*/
|
|
|
|
static void sd_read_block_limits(struct scsi_disk *sdkp)
|
|
|
|
{
|
2022-03-02 05:35:52 +00:00
|
|
|
struct scsi_vpd *vpd;
|
2009-05-23 15:43:39 +00:00
|
|
|
|
2022-03-02 05:35:52 +00:00
|
|
|
rcu_read_lock();
|
2009-05-23 15:43:39 +00:00
|
|
|
|
2022-03-02 05:35:52 +00:00
|
|
|
vpd = rcu_dereference(sdkp->device->vpd_pgb0);
|
|
|
|
if (!vpd || vpd->len < 16)
|
2009-11-03 18:33:07 +00:00
|
|
|
goto out;
|
2015-11-13 21:46:48 +00:00
|
|
|
|
2022-03-02 05:35:53 +00:00
|
|
|
sdkp->min_xfer_blocks = get_unaligned_be16(&vpd->data[6]);
|
2022-03-02 05:35:52 +00:00
|
|
|
sdkp->max_xfer_blocks = get_unaligned_be32(&vpd->data[8]);
|
|
|
|
sdkp->opt_xfer_blocks = get_unaligned_be32(&vpd->data[12]);
|
2009-05-23 15:43:39 +00:00
|
|
|
|
2022-03-02 05:35:52 +00:00
|
|
|
if (vpd->len >= 64) {
|
2011-03-08 07:07:15 +00:00
|
|
|
unsigned int lba_count, desc_count;
|
2009-11-26 17:00:40 +00:00
|
|
|
|
2022-03-02 05:35:52 +00:00
|
|
|
sdkp->max_ws_blocks = (u32)get_unaligned_be64(&vpd->data[36]);
|
2009-11-26 17:00:40 +00:00
|
|
|
|
2011-03-08 07:07:15 +00:00
|
|
|
if (!sdkp->lbpme)
|
2010-09-10 05:22:07 +00:00
|
|
|
goto out;
|
|
|
|
|
2022-03-02 05:35:52 +00:00
|
|
|
lba_count = get_unaligned_be32(&vpd->data[20]);
|
|
|
|
desc_count = get_unaligned_be32(&vpd->data[24]);
|
2010-09-10 05:22:07 +00:00
|
|
|
|
2011-03-08 07:07:15 +00:00
|
|
|
if (lba_count && desc_count)
|
|
|
|
sdkp->max_unmap_blocks = lba_count;
|
2009-11-26 17:00:40 +00:00
|
|
|
|
2022-03-02 05:35:52 +00:00
|
|
|
sdkp->unmap_granularity = get_unaligned_be32(&vpd->data[28]);
|
2009-11-26 17:00:40 +00:00
|
|
|
|
2022-03-02 05:35:52 +00:00
|
|
|
if (vpd->data[32] & 0x80)
|
2011-03-08 07:07:15 +00:00
|
|
|
sdkp->unmap_alignment =
|
2022-03-02 05:35:52 +00:00
|
|
|
get_unaligned_be32(&vpd->data[32]) & ~(1 << 31);
|
2011-03-08 07:07:15 +00:00
|
|
|
|
|
|
|
if (!sdkp->lbpvpd) { /* LBP VPD page not provided */
|
|
|
|
|
|
|
|
if (sdkp->max_unmap_blocks)
|
|
|
|
sd_config_discard(sdkp, SD_LBP_UNMAP);
|
|
|
|
else
|
|
|
|
sd_config_discard(sdkp, SD_LBP_WS16);
|
|
|
|
|
|
|
|
} else { /* LBP VPD page tells us what to use */
|
2017-04-05 17:21:25 +00:00
|
|
|
if (sdkp->lbpu && sdkp->max_unmap_blocks)
|
2014-12-05 13:58:03 +00:00
|
|
|
sd_config_discard(sdkp, SD_LBP_UNMAP);
|
|
|
|
else if (sdkp->lbpws)
|
2011-03-08 07:07:15 +00:00
|
|
|
sd_config_discard(sdkp, SD_LBP_WS16);
|
|
|
|
else if (sdkp->lbpws10)
|
|
|
|
sd_config_discard(sdkp, SD_LBP_WS10);
|
|
|
|
else
|
|
|
|
sd_config_discard(sdkp, SD_LBP_DISABLE);
|
|
|
|
}
|
2009-11-26 17:00:40 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 18:33:07 +00:00
|
|
|
out:
|
2022-03-02 05:35:52 +00:00
|
|
|
rcu_read_unlock();
|
2009-05-23 15:43:39 +00:00
|
|
|
}
|
|
|
|
|
2009-05-23 15:43:38 +00:00
|
|
|
/**
|
|
|
|
* sd_read_block_characteristics - Query block dev. characteristics
|
2017-04-24 07:51:09 +00:00
|
|
|
* @sdkp: disk to query
|
2009-05-23 15:43:38 +00:00
|
|
|
*/
|
|
|
|
static void sd_read_block_characteristics(struct scsi_disk *sdkp)
|
|
|
|
{
|
2016-10-18 06:40:34 +00:00
|
|
|
struct request_queue *q = sdkp->disk->queue;
|
2022-03-02 05:35:52 +00:00
|
|
|
struct scsi_vpd *vpd;
|
2009-05-23 15:43:38 +00:00
|
|
|
u16 rot;
|
2022-03-02 05:35:52 +00:00
|
|
|
u8 zoned;
|
2009-05-23 15:43:38 +00:00
|
|
|
|
2022-03-02 05:35:52 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
vpd = rcu_dereference(sdkp->device->vpd_pgb1);
|
2009-05-23 15:43:38 +00:00
|
|
|
|
2022-03-02 05:35:52 +00:00
|
|
|
if (!vpd || vpd->len < 8) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
2009-05-23 15:43:38 +00:00
|
|
|
|
2022-03-02 05:35:52 +00:00
|
|
|
rot = get_unaligned_be16(&vpd->data[4]);
|
|
|
|
zoned = (vpd->data[8] >> 4) & 3;
|
|
|
|
rcu_read_unlock();
|
2009-05-23 15:43:38 +00:00
|
|
|
|
2014-10-04 16:55:32 +00:00
|
|
|
if (rot == 1) {
|
2018-03-08 01:10:10 +00:00
|
|
|
blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
|
|
|
|
blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, q);
|
2014-10-04 16:55:32 +00:00
|
|
|
}
|
2009-05-23 15:43:38 +00:00
|
|
|
|
2017-01-12 06:25:11 +00:00
|
|
|
if (sdkp->device->type == TYPE_ZBC) {
|
2023-03-06 06:30:24 +00:00
|
|
|
/*
|
|
|
|
* Host-managed: Per ZBC and ZAC specifications, writes in
|
|
|
|
* sequential write required zones of host-managed devices must
|
|
|
|
* be aligned to the device physical block size.
|
|
|
|
*/
|
2022-07-06 07:03:40 +00:00
|
|
|
disk_set_zoned(sdkp->disk, BLK_ZONED_HM);
|
2023-03-06 06:30:24 +00:00
|
|
|
blk_queue_zone_write_granularity(q, sdkp->physical_block_size);
|
2017-01-12 06:25:11 +00:00
|
|
|
} else {
|
2022-03-02 05:35:52 +00:00
|
|
|
sdkp->zoned = zoned;
|
2020-09-15 07:33:46 +00:00
|
|
|
if (sdkp->zoned == 1) {
|
2017-01-12 06:25:11 +00:00
|
|
|
/* Host-aware */
|
2022-07-06 07:03:40 +00:00
|
|
|
disk_set_zoned(sdkp->disk, BLK_ZONED_HA);
|
2020-01-26 13:05:43 +00:00
|
|
|
} else {
|
2020-09-15 07:33:46 +00:00
|
|
|
/* Regular disk or drive managed disk */
|
2022-07-06 07:03:40 +00:00
|
|
|
disk_set_zoned(sdkp->disk, BLK_ZONED_NONE);
|
2020-01-26 13:05:43 +00:00
|
|
|
}
|
2017-01-12 06:25:11 +00:00
|
|
|
}
|
2020-09-15 07:33:46 +00:00
|
|
|
|
|
|
|
if (!sdkp->first_scan)
|
2022-03-02 05:35:52 +00:00
|
|
|
return;
|
2020-09-15 07:33:46 +00:00
|
|
|
|
|
|
|
if (blk_queue_is_zoned(q)) {
|
2016-10-18 06:40:34 +00:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Host-%s zoned block device\n",
|
|
|
|
q->limits.zoned == BLK_ZONED_HM ? "managed" : "aware");
|
2020-09-15 07:33:46 +00:00
|
|
|
} else {
|
|
|
|
if (sdkp->zoned == 1)
|
|
|
|
sd_printk(KERN_NOTICE, sdkp,
|
|
|
|
"Host-aware SMR disk used as regular disk\n");
|
|
|
|
else if (sdkp->zoned == 2)
|
|
|
|
sd_printk(KERN_NOTICE, sdkp,
|
|
|
|
"Drive-managed SMR disk\n");
|
|
|
|
}
|
2009-05-23 15:43:38 +00:00
|
|
|
}
|
|
|
|
|
2010-09-10 05:22:07 +00:00
|
|
|
/**
|
2011-03-08 07:07:15 +00:00
|
|
|
* sd_read_block_provisioning - Query provisioning VPD page
|
2017-04-24 07:51:09 +00:00
|
|
|
* @sdkp: disk to query
|
2010-09-10 05:22:07 +00:00
|
|
|
*/
|
2011-03-08 07:07:15 +00:00
|
|
|
static void sd_read_block_provisioning(struct scsi_disk *sdkp)
|
2010-09-10 05:22:07 +00:00
|
|
|
{
|
2022-03-02 05:35:52 +00:00
|
|
|
struct scsi_vpd *vpd;
|
2010-09-10 05:22:07 +00:00
|
|
|
|
2011-03-08 07:07:15 +00:00
|
|
|
if (sdkp->lbpme == 0)
|
2010-09-10 05:22:07 +00:00
|
|
|
return;
|
|
|
|
|
2022-03-02 05:35:52 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
vpd = rcu_dereference(sdkp->device->vpd_pgb2);
|
2010-09-10 05:22:07 +00:00
|
|
|
|
2022-03-02 05:35:52 +00:00
|
|
|
if (!vpd || vpd->len < 8) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
2010-09-10 05:22:07 +00:00
|
|
|
|
2011-03-08 07:07:15 +00:00
|
|
|
sdkp->lbpvpd = 1;
|
2022-03-02 05:35:52 +00:00
|
|
|
sdkp->lbpu = (vpd->data[5] >> 7) & 1; /* UNMAP */
|
|
|
|
sdkp->lbpws = (vpd->data[5] >> 6) & 1; /* WRITE SAME(16) w/ UNMAP */
|
|
|
|
sdkp->lbpws10 = (vpd->data[5] >> 5) & 1; /* WRITE SAME(10) w/ UNMAP */
|
|
|
|
rcu_read_unlock();
|
2010-09-10 05:22:07 +00:00
|
|
|
}
|
|
|
|
|
2012-09-18 16:19:32 +00:00
|
|
|
static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer)
|
|
|
|
{
|
2013-06-07 02:15:55 +00:00
|
|
|
struct scsi_device *sdev = sdkp->device;
|
|
|
|
|
2013-10-23 10:25:40 +00:00
|
|
|
if (sdev->host->no_write_same) {
|
|
|
|
sdev->no_write_same = 1;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-06-07 02:15:55 +00:00
|
|
|
if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, INQUIRY) < 0) {
|
2022-03-02 05:35:51 +00:00
|
|
|
struct scsi_vpd *vpd;
|
2013-09-23 12:47:32 +00:00
|
|
|
|
2013-06-07 02:15:55 +00:00
|
|
|
sdev->no_report_opcodes = 1;
|
|
|
|
|
|
|
|
/* Disable WRITE SAME if REPORT SUPPORTED OPERATION
|
|
|
|
* CODES is unsupported and the device has an ATA
|
|
|
|
* Information VPD page (SAT).
|
|
|
|
*/
|
2022-03-02 05:35:51 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
vpd = rcu_dereference(sdev->vpd_pg89);
|
|
|
|
if (vpd)
|
2013-06-07 02:15:55 +00:00
|
|
|
sdev->no_write_same = 1;
|
2022-03-02 05:35:51 +00:00
|
|
|
rcu_read_unlock();
|
2013-06-07 02:15:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, WRITE_SAME_16) == 1)
|
2012-09-18 16:19:32 +00:00
|
|
|
sdkp->ws16 = 1;
|
2013-06-07 02:15:55 +00:00
|
|
|
|
|
|
|
if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, WRITE_SAME) == 1)
|
|
|
|
sdkp->ws10 = 1;
|
2012-09-18 16:19:32 +00:00
|
|
|
}
|
|
|
|
|
2017-06-19 12:26:46 +00:00
|
|
|
static void sd_read_security(struct scsi_disk *sdkp, unsigned char *buffer)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev = sdkp->device;
|
|
|
|
|
|
|
|
if (!sdev->security_supported)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE,
|
|
|
|
SECURITY_PROTOCOL_IN) == 1 &&
|
|
|
|
scsi_report_opcode(sdev, buffer, SD_BUF_SIZE,
|
|
|
|
SECURITY_PROTOCOL_OUT) == 1)
|
|
|
|
sdkp->security = 1;
|
|
|
|
}
|
|
|
|
|
2021-10-27 02:22:20 +00:00
|
|
|
static inline sector_t sd64_to_sectors(struct scsi_disk *sdkp, u8 *buf)
|
|
|
|
{
|
|
|
|
return logical_to_sectors(sdkp->device, get_unaligned_be64(buf));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sd_read_cpr - Query concurrent positioning ranges
|
|
|
|
* @sdkp: disk to query
|
|
|
|
*/
|
|
|
|
static void sd_read_cpr(struct scsi_disk *sdkp)
|
|
|
|
{
|
|
|
|
struct blk_independent_access_ranges *iars = NULL;
|
|
|
|
unsigned char *buffer = NULL;
|
|
|
|
unsigned int nr_cpr = 0;
|
|
|
|
int i, vpd_len, buf_len = SD_BUF_SIZE;
|
|
|
|
u8 *desc;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to have the capacity set first for the block layer to be
|
|
|
|
* able to check the ranges.
|
|
|
|
*/
|
|
|
|
if (sdkp->first_scan)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!sdkp->capacity)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Concurrent Positioning Ranges VPD: there can be at most 256 ranges,
|
|
|
|
* leading to a maximum page size of 64 + 256*32 bytes.
|
|
|
|
*/
|
|
|
|
buf_len = 64 + 256*32;
|
|
|
|
buffer = kmalloc(buf_len, GFP_KERNEL);
|
|
|
|
if (!buffer || scsi_get_vpd_page(sdkp->device, 0xb9, buffer, buf_len))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* We must have at least a 64B header and one 32B range descriptor */
|
2022-06-02 22:51:13 +00:00
|
|
|
vpd_len = get_unaligned_be16(&buffer[2]) + 4;
|
2021-10-27 02:22:20 +00:00
|
|
|
if (vpd_len > buf_len || vpd_len < 64 + 32 || (vpd_len & 31)) {
|
|
|
|
sd_printk(KERN_ERR, sdkp,
|
|
|
|
"Invalid Concurrent Positioning Ranges VPD page\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
nr_cpr = (vpd_len - 64) / 32;
|
|
|
|
if (nr_cpr == 1) {
|
|
|
|
nr_cpr = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
iars = disk_alloc_independent_access_ranges(sdkp->disk, nr_cpr);
|
|
|
|
if (!iars) {
|
|
|
|
nr_cpr = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
desc = &buffer[64];
|
|
|
|
for (i = 0; i < nr_cpr; i++, desc += 32) {
|
|
|
|
if (desc[0] != i) {
|
|
|
|
sd_printk(KERN_ERR, sdkp,
|
|
|
|
"Invalid Concurrent Positioning Range number\n");
|
|
|
|
nr_cpr = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
iars->ia_range[i].sector = sd64_to_sectors(sdkp, desc + 8);
|
|
|
|
iars->ia_range[i].nr_sectors = sd64_to_sectors(sdkp, desc + 16);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
disk_set_independent_access_ranges(sdkp->disk, iars);
|
|
|
|
if (nr_cpr && sdkp->nr_actuators != nr_cpr) {
|
|
|
|
sd_printk(KERN_NOTICE, sdkp,
|
|
|
|
"%u concurrent positioning ranges\n", nr_cpr);
|
|
|
|
sdkp->nr_actuators = nr_cpr;
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(buffer);
|
|
|
|
}
|
|
|
|
|
2022-03-02 05:35:53 +00:00
|
|
|
static bool sd_validate_min_xfer_size(struct scsi_disk *sdkp)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
unsigned int min_xfer_bytes =
|
|
|
|
logical_to_bytes(sdp, sdkp->min_xfer_blocks);
|
|
|
|
|
|
|
|
if (sdkp->min_xfer_blocks == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (min_xfer_bytes & (sdkp->physical_block_size - 1)) {
|
|
|
|
sd_first_printk(KERN_WARNING, sdkp,
|
|
|
|
"Preferred minimum I/O size %u bytes not a " \
|
|
|
|
"multiple of physical block size (%u bytes)\n",
|
|
|
|
min_xfer_bytes, sdkp->physical_block_size);
|
|
|
|
sdkp->min_xfer_blocks = 0;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
sd_first_printk(KERN_INFO, sdkp, "Preferred minimum I/O size %u bytes\n",
|
|
|
|
min_xfer_bytes);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-02-12 21:21:05 +00:00
|
|
|
/*
|
|
|
|
* Determine the device's preferred I/O size for reads and writes
|
|
|
|
* unless the reported value is unreasonably small, large, not a
|
|
|
|
* multiple of the physical block size, or simply garbage.
|
|
|
|
*/
|
|
|
|
static bool sd_validate_opt_xfer_size(struct scsi_disk *sdkp,
|
|
|
|
unsigned int dev_max)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
unsigned int opt_xfer_bytes =
|
|
|
|
logical_to_bytes(sdp, sdkp->opt_xfer_blocks);
|
2022-03-02 05:35:53 +00:00
|
|
|
unsigned int min_xfer_bytes =
|
|
|
|
logical_to_bytes(sdp, sdkp->min_xfer_blocks);
|
2019-02-12 21:21:05 +00:00
|
|
|
|
2019-03-27 16:11:52 +00:00
|
|
|
if (sdkp->opt_xfer_blocks == 0)
|
|
|
|
return false;
|
|
|
|
|
2019-02-12 21:21:05 +00:00
|
|
|
if (sdkp->opt_xfer_blocks > dev_max) {
|
|
|
|
sd_first_printk(KERN_WARNING, sdkp,
|
|
|
|
"Optimal transfer size %u logical blocks " \
|
|
|
|
"> dev_max (%u logical blocks)\n",
|
|
|
|
sdkp->opt_xfer_blocks, dev_max);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sdkp->opt_xfer_blocks > SD_DEF_XFER_BLOCKS) {
|
|
|
|
sd_first_printk(KERN_WARNING, sdkp,
|
|
|
|
"Optimal transfer size %u logical blocks " \
|
|
|
|
"> sd driver limit (%u logical blocks)\n",
|
|
|
|
sdkp->opt_xfer_blocks, SD_DEF_XFER_BLOCKS);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (opt_xfer_bytes < PAGE_SIZE) {
|
|
|
|
sd_first_printk(KERN_WARNING, sdkp,
|
|
|
|
"Optimal transfer size %u bytes < " \
|
|
|
|
"PAGE_SIZE (%u bytes)\n",
|
|
|
|
opt_xfer_bytes, (unsigned int)PAGE_SIZE);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2022-03-02 05:35:53 +00:00
|
|
|
if (min_xfer_bytes && opt_xfer_bytes % min_xfer_bytes) {
|
|
|
|
sd_first_printk(KERN_WARNING, sdkp,
|
|
|
|
"Optimal transfer size %u bytes not a " \
|
|
|
|
"multiple of preferred minimum block " \
|
|
|
|
"size (%u bytes)\n",
|
|
|
|
opt_xfer_bytes, min_xfer_bytes);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-02-12 21:21:05 +00:00
|
|
|
if (opt_xfer_bytes & (sdkp->physical_block_size - 1)) {
|
|
|
|
sd_first_printk(KERN_WARNING, sdkp,
|
|
|
|
"Optimal transfer size %u bytes not a " \
|
|
|
|
"multiple of physical block size (%u bytes)\n",
|
|
|
|
opt_xfer_bytes, sdkp->physical_block_size);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
sd_first_printk(KERN_INFO, sdkp, "Optimal transfer size %u bytes\n",
|
|
|
|
opt_xfer_bytes);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* sd_revalidate_disk - called the first time a new disk is seen,
|
|
|
|
* performs disk spin up, read_capacity, etc.
|
|
|
|
* @disk: struct gendisk we care about
|
|
|
|
**/
|
|
|
|
static int sd_revalidate_disk(struct gendisk *disk)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = scsi_disk(disk);
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2015-11-13 21:46:48 +00:00
|
|
|
struct request_queue *q = sdkp->disk->queue;
|
2016-10-18 06:40:34 +00:00
|
|
|
sector_t old_capacity = sdkp->capacity;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char *buffer;
|
2015-11-13 21:46:48 +00:00
|
|
|
unsigned int dev_max, rw_max;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-28 03:41:19 +00:00
|
|
|
SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp,
|
|
|
|
"sd_revalidate_disk\n"));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the device is offline, don't try and read capacity or any
|
|
|
|
* of the other niceties.
|
|
|
|
*/
|
|
|
|
if (!scsi_device_online(sdp))
|
|
|
|
goto out;
|
|
|
|
|
2007-05-21 15:15:26 +00:00
|
|
|
buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!buffer) {
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_printk(KERN_WARNING, sdkp, "sd_revalidate_disk: Memory "
|
|
|
|
"allocation failure.\n");
|
2005-08-28 16:33:52 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_spinup_disk(sdkp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Without media there is no reason to ask; moreover, some devices
|
|
|
|
* react badly if we do.
|
|
|
|
*/
|
|
|
|
if (sdkp->media_present) {
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_read_capacity(sdkp, buffer);
|
2009-07-29 18:06:53 +00:00
|
|
|
|
2019-02-12 16:05:25 +00:00
|
|
|
/*
|
|
|
|
* set the default to rotational. All non-rotational devices
|
|
|
|
* support the block characteristics VPD page, which will
|
|
|
|
* cause this to be updated correctly and any device which
|
|
|
|
* doesn't support it should be treated as rotational.
|
|
|
|
*/
|
|
|
|
blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
|
|
|
|
blk_queue_flag_set(QUEUE_FLAG_ADD_RANDOM, q);
|
|
|
|
|
2016-04-01 06:57:36 +00:00
|
|
|
if (scsi_device_supports_vpd(sdp)) {
|
2011-03-08 07:07:15 +00:00
|
|
|
sd_read_block_provisioning(sdkp);
|
2009-07-29 18:06:53 +00:00
|
|
|
sd_read_block_limits(sdkp);
|
|
|
|
sd_read_block_characteristics(sdkp);
|
2016-10-18 06:40:34 +00:00
|
|
|
sd_zbc_read_zones(sdkp, buffer);
|
2022-03-02 05:35:57 +00:00
|
|
|
sd_read_cpr(sdkp);
|
2009-07-29 18:06:53 +00:00
|
|
|
}
|
|
|
|
|
2016-10-18 06:40:34 +00:00
|
|
|
sd_print_capacity(sdkp, old_capacity);
|
|
|
|
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_read_write_protect_flag(sdkp, buffer);
|
|
|
|
sd_read_cache_type(sdkp, buffer);
|
2008-07-17 08:28:34 +00:00
|
|
|
sd_read_app_tag_own(sdkp, buffer);
|
2012-09-18 16:19:32 +00:00
|
|
|
sd_read_write_same(sdkp, buffer);
|
2017-06-19 12:26:46 +00:00
|
|
|
sd_read_security(sdkp, buffer);
|
2022-03-02 05:35:58 +00:00
|
|
|
sd_config_protection(sdkp);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2006-01-06 08:52:55 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We now have all cache related info, determine how we deal
|
2010-09-03 09:56:16 +00:00
|
|
|
* with flush requests.
|
2006-01-06 08:52:55 +00:00
|
|
|
*/
|
2014-06-03 09:37:30 +00:00
|
|
|
sd_set_flush_flag(sdkp);
|
2006-01-06 08:52:55 +00:00
|
|
|
|
2015-11-13 21:46:48 +00:00
|
|
|
/* Initial block count limit based on CDB TRANSFER LENGTH field size. */
|
|
|
|
dev_max = sdp->use_16_for_rw ? SD_MAX_XFER_BLOCKS : SD_DEF_XFER_BLOCKS;
|
|
|
|
|
|
|
|
/* Some devices report a maximum block count for READ/WRITE requests. */
|
|
|
|
dev_max = min_not_zero(dev_max, sdkp->max_xfer_blocks);
|
|
|
|
q->limits.max_dev_sectors = logical_to_sectors(sdp, dev_max);
|
|
|
|
|
2022-03-02 05:35:53 +00:00
|
|
|
if (sd_validate_min_xfer_size(sdkp))
|
|
|
|
blk_queue_io_min(sdkp->disk->queue,
|
|
|
|
logical_to_bytes(sdp, sdkp->min_xfer_blocks));
|
|
|
|
else
|
|
|
|
blk_queue_io_min(sdkp->disk->queue, 0);
|
|
|
|
|
2019-02-12 21:21:05 +00:00
|
|
|
if (sd_validate_opt_xfer_size(sdkp, dev_max)) {
|
2016-05-13 02:17:34 +00:00
|
|
|
q->limits.io_opt = logical_to_bytes(sdp, sdkp->opt_xfer_blocks);
|
|
|
|
rw_max = logical_to_sectors(sdp, sdkp->opt_xfer_blocks);
|
2020-03-24 15:16:15 +00:00
|
|
|
} else {
|
|
|
|
q->limits.io_opt = 0;
|
2017-03-28 04:41:26 +00:00
|
|
|
rw_max = min_not_zero(logical_to_sectors(sdp, dev_max),
|
|
|
|
(sector_t)BLK_DEF_MAX_SECTORS);
|
2020-03-24 15:16:15 +00:00
|
|
|
}
|
2015-01-29 21:54:40 +00:00
|
|
|
|
2022-07-19 09:51:04 +00:00
|
|
|
/*
|
|
|
|
* Limit default to SCSI host optimal sector limit if set. There may be
|
|
|
|
* an impact on performance for when the size of a request exceeds this
|
|
|
|
* host limit.
|
|
|
|
*/
|
2022-07-14 11:15:27 +00:00
|
|
|
rw_max = min_not_zero(rw_max, sdp->host->opt_sectors);
|
|
|
|
|
2017-09-28 01:38:59 +00:00
|
|
|
/* Do not exceed controller limit */
|
|
|
|
rw_max = min(rw_max, queue_max_hw_sectors(q));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Only update max_sectors if previously unset or if the current value
|
|
|
|
* exceeds the capabilities of the hardware.
|
|
|
|
*/
|
|
|
|
if (sdkp->first_scan ||
|
|
|
|
q->limits.max_sectors > q->limits.max_dev_sectors ||
|
|
|
|
q->limits.max_sectors > q->limits.max_hw_sectors)
|
|
|
|
q->limits.max_sectors = rw_max;
|
|
|
|
|
|
|
|
sdkp->first_scan = 0;
|
2015-06-23 16:13:59 +00:00
|
|
|
|
2020-11-16 14:56:56 +00:00
|
|
|
set_capacity_and_notify(disk, logical_to_sectors(sdp, sdkp->capacity));
|
2012-09-18 16:19:32 +00:00
|
|
|
sd_config_write_same(sdkp);
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(buffer);
|
|
|
|
|
scsi: sd_zbc: Improve zone revalidation
Currently, for zoned disks, since blk_revalidate_disk_zones() requires the
disk capacity to be set already to operate correctly, zones revalidation
can only be done on the second revalidate scan once the gendisk capacity is
set at the end of the first scan. As a result, if zone revalidation fails,
there is no second chance to recover from the failure and the disk capacity
is changed to 0, with the disk left unusable.
This can be improved by shuffling around code, specifically, by moving the
call to sd_zbc_revalidate_zones() from sd_zbc_read_zones() to the end of
sd_revalidate_disk(), after set_capacity_revalidate_and_notify() is called
to set the gendisk capacity. With this change, if sd_zbc_revalidate_zones()
fails on the first scan, the second scan will call it again to recover, if
possible.
Using the new struct scsi_disk fields rev_nr_zones and rev_zone_blocks,
sd_zbc_revalidate_zones() does actual work only if it detects a change with
the disk zone configuration. This means that for a successful zones
revalidation on the first scan, the second scan will not cause another
heavy full check.
While at it, remove the unecesary "extern" declaration of
sd_zbc_read_zones().
Link: https://lore.kernel.org/r/20200731054928.668547-1-damien.lemoal@wdc.com
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: Damien Le Moal <damien.lemoal@wdc.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-07-31 05:49:28 +00:00
|
|
|
/*
|
|
|
|
* For a zoned drive, revalidating the zones can be done only once
|
|
|
|
* the gendisk capacity is set. So if this fails, set back the gendisk
|
|
|
|
* capacity to 0.
|
|
|
|
*/
|
|
|
|
if (sd_zbc_revalidate_zones(sdkp))
|
2020-11-16 14:56:56 +00:00
|
|
|
set_capacity_and_notify(disk, 0);
|
scsi: sd_zbc: Improve zone revalidation
Currently, for zoned disks, since blk_revalidate_disk_zones() requires the
disk capacity to be set already to operate correctly, zones revalidation
can only be done on the second revalidate scan once the gendisk capacity is
set at the end of the first scan. As a result, if zone revalidation fails,
there is no second chance to recover from the failure and the disk capacity
is changed to 0, with the disk left unusable.
This can be improved by shuffling around code, specifically, by moving the
call to sd_zbc_revalidate_zones() from sd_zbc_read_zones() to the end of
sd_revalidate_disk(), after set_capacity_revalidate_and_notify() is called
to set the gendisk capacity. With this change, if sd_zbc_revalidate_zones()
fails on the first scan, the second scan will call it again to recover, if
possible.
Using the new struct scsi_disk fields rev_nr_zones and rev_zone_blocks,
sd_zbc_revalidate_zones() does actual work only if it detects a change with
the disk zone configuration. This means that for a successful zones
revalidation on the first scan, the second scan will not cause another
heavy full check.
While at it, remove the unecesary "extern" declaration of
sd_zbc_read_zones().
Link: https://lore.kernel.org/r/20200731054928.668547-1-damien.lemoal@wdc.com
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: Damien Le Moal <damien.lemoal@wdc.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-07-31 05:49:28 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
out:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-15 18:09:32 +00:00
|
|
|
/**
|
|
|
|
* sd_unlock_native_capacity - unlock native capacity
|
|
|
|
* @disk: struct gendisk to set capacity for
|
|
|
|
*
|
|
|
|
* Block layer calls this function if it detects that partitions
|
|
|
|
* on @disk reach beyond the end of the device. If the SCSI host
|
|
|
|
* implements ->unlock_native_capacity() method, it's invoked to
|
|
|
|
* give it a chance to adjust the device capacity.
|
|
|
|
*
|
|
|
|
* CONTEXT:
|
|
|
|
* Defined by block layer. Might sleep.
|
|
|
|
*/
|
|
|
|
static void sd_unlock_native_capacity(struct gendisk *disk)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev = scsi_disk(disk)->device;
|
|
|
|
|
|
|
|
if (sdev->host->hostt->unlock_native_capacity)
|
|
|
|
sdev->host->hostt->unlock_native_capacity(sdev);
|
|
|
|
}
|
|
|
|
|
2008-08-25 10:56:17 +00:00
|
|
|
/**
|
|
|
|
* sd_format_disk_name - format disk name
|
|
|
|
* @prefix: name prefix - ie. "sd" for SCSI disks
|
|
|
|
* @index: index of the disk to format name for
|
|
|
|
* @buf: output buffer
|
|
|
|
* @buflen: length of the output buffer
|
|
|
|
*
|
|
|
|
* SCSI disk names starts at sda. The 26th device is sdz and the
|
|
|
|
* 27th is sdaa. The last one for two lettered suffix is sdzz
|
|
|
|
* which is followed by sdaaa.
|
|
|
|
*
|
|
|
|
* This is basically 26 base counting with one extra 'nil' entry
|
tree-wide: Assorted spelling fixes
In particular, several occurances of funny versions of 'success',
'unknown', 'therefore', 'acknowledge', 'argument', 'achieve', 'address',
'beginning', 'desirable', 'separate' and 'necessary' are fixed.
Signed-off-by: Daniel Mack <daniel@caiaq.de>
Cc: Joe Perches <joe@perches.com>
Cc: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2010-02-03 00:01:28 +00:00
|
|
|
* at the beginning from the second digit on and can be
|
2008-08-25 10:56:17 +00:00
|
|
|
* determined using similar method as 26 base conversion with the
|
|
|
|
* index shifted -1 after each digit is computed.
|
|
|
|
*
|
|
|
|
* CONTEXT:
|
|
|
|
* Don't care.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
* 0 on success, -errno on failure.
|
|
|
|
*/
|
|
|
|
static int sd_format_disk_name(char *prefix, int index, char *buf, int buflen)
|
|
|
|
{
|
|
|
|
const int base = 'z' - 'a' + 1;
|
|
|
|
char *begin = buf + strlen(prefix);
|
|
|
|
char *end = buf + buflen;
|
|
|
|
char *p;
|
|
|
|
int unit;
|
|
|
|
|
|
|
|
p = end - 1;
|
|
|
|
*p = '\0';
|
|
|
|
unit = base;
|
|
|
|
do {
|
|
|
|
if (p == begin)
|
|
|
|
return -EINVAL;
|
|
|
|
*--p = 'a' + (index % unit);
|
|
|
|
index = (index / unit) - 1;
|
|
|
|
} while (index >= 0);
|
|
|
|
|
|
|
|
memmove(begin, p, end - p);
|
|
|
|
memcpy(buf, prefix, strlen(prefix));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* sd_probe - called during driver initialization and whenever a
|
|
|
|
* new scsi device is attached to the system. It is called once
|
|
|
|
* for each scsi device (not just disks) present.
|
|
|
|
* @dev: pointer to device object
|
|
|
|
*
|
|
|
|
* Returns 0 if successful (or not interested in this scsi device
|
|
|
|
* (e.g. scanner)); 1 when there is an error.
|
|
|
|
*
|
|
|
|
* Note: this function is invoked from the scsi mid-level.
|
|
|
|
* This function sets up the mapping between a given
|
|
|
|
* <host,channel,id,lun> (found in sdp) and new device name
|
|
|
|
* (e.g. /dev/sda). More precisely it is the block device major
|
|
|
|
* and minor number that is chosen here.
|
|
|
|
*
|
2012-02-24 15:56:54 +00:00
|
|
|
* Assume sd_probe is not re-entrant (for time being)
|
|
|
|
* Also think about sd_probe() and sd_remove() running coincidentally.
|
2005-04-16 22:20:36 +00:00
|
|
|
**/
|
|
|
|
static int sd_probe(struct device *dev)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdp = to_scsi_device(dev);
|
|
|
|
struct scsi_disk *sdkp;
|
|
|
|
struct gendisk *gd;
|
2010-08-11 01:01:20 +00:00
|
|
|
int index;
|
2005-04-16 22:20:36 +00:00
|
|
|
int error;
|
|
|
|
|
2014-09-10 11:54:09 +00:00
|
|
|
scsi_autopm_get_device(sdp);
|
2005-04-16 22:20:36 +00:00
|
|
|
error = -ENODEV;
|
2016-10-18 06:40:34 +00:00
|
|
|
if (sdp->type != TYPE_DISK &&
|
|
|
|
sdp->type != TYPE_ZBC &&
|
|
|
|
sdp->type != TYPE_MOD &&
|
|
|
|
sdp->type != TYPE_RBC)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
|
2021-01-28 05:56:58 +00:00
|
|
|
if (!IS_ENABLED(CONFIG_BLK_DEV_ZONED) && sdp->type == TYPE_ZBC) {
|
|
|
|
sdev_printk(KERN_WARNING, sdp,
|
|
|
|
"Unsupported ZBC host-managed device.\n");
|
2016-10-18 06:40:34 +00:00
|
|
|
goto out;
|
2021-01-28 05:56:58 +00:00
|
|
|
}
|
|
|
|
|
2005-10-02 16:45:08 +00:00
|
|
|
SCSI_LOG_HLQUEUE(3, sdev_printk(KERN_INFO, sdp,
|
2012-02-24 15:56:54 +00:00
|
|
|
"sd_probe\n"));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
error = -ENOMEM;
|
2006-01-16 15:31:18 +00:00
|
|
|
sdkp = kzalloc(sizeof(*sdkp), GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!sdkp)
|
|
|
|
goto out;
|
|
|
|
|
2022-06-19 06:05:51 +00:00
|
|
|
gd = blk_mq_alloc_disk_for_queue(sdp->request_queue,
|
|
|
|
&sd_bio_compl_lkclass);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!gd)
|
2017-03-08 16:48:34 +00:00
|
|
|
goto out_free;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-06-11 19:26:27 +00:00
|
|
|
index = ida_alloc(&sd_index_ida, GFP_KERNEL);
|
|
|
|
if (index < 0) {
|
2011-10-19 16:49:04 +00:00
|
|
|
sdev_printk(KERN_WARNING, sdp, "sd_probe: memory exhausted.\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out_put;
|
2010-09-20 16:20:22 +00:00
|
|
|
}
|
|
|
|
|
2008-08-25 10:56:17 +00:00
|
|
|
error = sd_format_disk_name("sd", index, gd->disk_name, DISK_NAME_LEN);
|
2011-10-19 16:49:04 +00:00
|
|
|
if (error) {
|
|
|
|
sdev_printk(KERN_WARNING, sdp, "SCSI disk (sd) name length exceeded.\n");
|
2008-07-14 05:59:30 +00:00
|
|
|
goto out_free_index;
|
2011-10-19 16:49:04 +00:00
|
|
|
}
|
2008-07-14 05:59:30 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
sdkp->device = sdp;
|
|
|
|
sdkp->disk = gd;
|
|
|
|
sdkp->index = index;
|
2020-10-01 15:35:54 +00:00
|
|
|
sdkp->max_retries = SD_MAX_RETRIES;
|
2010-07-07 14:51:29 +00:00
|
|
|
atomic_set(&sdkp->openers, 0);
|
2012-06-09 14:03:39 +00:00
|
|
|
atomic_set(&sdkp->device->ioerr_cnt, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-05-26 20:35:48 +00:00
|
|
|
if (!sdp->request_queue->rq_timeout) {
|
|
|
|
if (sdp->type != TYPE_MOD)
|
|
|
|
blk_queue_rq_timeout(sdp->request_queue, SD_TIMEOUT);
|
|
|
|
else
|
|
|
|
blk_queue_rq_timeout(sdp->request_queue,
|
|
|
|
SD_MOD_TIMEOUT);
|
|
|
|
}
|
|
|
|
|
2022-03-08 05:51:50 +00:00
|
|
|
device_initialize(&sdkp->disk_dev);
|
|
|
|
sdkp->disk_dev.parent = get_device(dev);
|
|
|
|
sdkp->disk_dev.class = &sd_disk_class;
|
|
|
|
dev_set_name(&sdkp->disk_dev, "%s", dev_name(dev));
|
2009-05-26 20:35:48 +00:00
|
|
|
|
2022-03-08 05:51:50 +00:00
|
|
|
error = device_add(&sdkp->disk_dev);
|
2021-09-06 09:01:12 +00:00
|
|
|
if (error) {
|
2022-03-08 05:51:50 +00:00
|
|
|
put_device(&sdkp->disk_dev);
|
2021-09-06 09:01:12 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2009-05-26 20:35:48 +00:00
|
|
|
|
2010-06-16 18:52:17 +00:00
|
|
|
dev_set_drvdata(dev, sdkp);
|
2009-05-26 20:35:48 +00:00
|
|
|
|
2019-04-30 21:39:19 +00:00
|
|
|
gd->major = sd_major((index & 0xf0) >> 4);
|
|
|
|
gd->first_minor = ((index & 0xf) << 4) | (index & 0xfff00);
|
2021-08-16 13:19:07 +00:00
|
|
|
gd->minors = SD_MINORS;
|
2019-04-30 21:39:19 +00:00
|
|
|
|
|
|
|
gd->fops = &sd_fops;
|
2022-03-08 05:51:49 +00:00
|
|
|
gd->private_data = sdkp;
|
2019-04-30 21:39:19 +00:00
|
|
|
|
|
|
|
/* defaults, until the device tells us otherwise */
|
|
|
|
sdp->sector_size = 512;
|
|
|
|
sdkp->capacity = 0;
|
|
|
|
sdkp->media_present = 1;
|
|
|
|
sdkp->write_prot = 0;
|
|
|
|
sdkp->cache_override = 0;
|
|
|
|
sdkp->WCE = 0;
|
|
|
|
sdkp->RCD = 0;
|
|
|
|
sdkp->ATO = 0;
|
|
|
|
sdkp->first_scan = 1;
|
|
|
|
sdkp->max_medium_access_timeouts = SD_MAX_MEDIUM_TIMEOUTS;
|
|
|
|
|
|
|
|
sd_revalidate_disk(gd);
|
|
|
|
|
|
|
|
if (sdp->removable) {
|
|
|
|
gd->flags |= GENHD_FL_REMOVABLE;
|
|
|
|
gd->events |= DISK_EVENT_MEDIA_CHANGE;
|
|
|
|
gd->event_flags = DISK_EVENT_FLAG_POLL | DISK_EVENT_FLAG_UEVENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
blk_pm_runtime_init(sdp->request_queue, dev);
|
2019-09-16 15:56:49 +00:00
|
|
|
if (sdp->rpm_autosuspend) {
|
|
|
|
pm_runtime_set_autosuspend_delay(dev,
|
|
|
|
sdp->host->hostt->rpm_autosuspend_delay);
|
|
|
|
}
|
2021-10-15 23:30:20 +00:00
|
|
|
|
|
|
|
error = device_add_disk(dev, gd, NULL);
|
|
|
|
if (error) {
|
2022-03-08 05:51:50 +00:00
|
|
|
put_device(&sdkp->disk_dev);
|
2022-05-23 08:38:13 +00:00
|
|
|
put_disk(gd);
|
2021-10-15 23:30:20 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2019-04-30 21:39:19 +00:00
|
|
|
if (sdkp->security) {
|
2020-10-01 15:35:54 +00:00
|
|
|
sdkp->opal_dev = init_opal_dev(sdkp, &sd_sec_submit);
|
2019-04-30 21:39:19 +00:00
|
|
|
if (sdkp->opal_dev)
|
|
|
|
sd_printk(KERN_NOTICE, sdkp, "supports TCG Opal\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
|
|
|
|
sdp->removable ? "removable " : "");
|
|
|
|
scsi_autopm_put_device(sdp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2008-07-14 05:59:30 +00:00
|
|
|
out_free_index:
|
2018-06-11 19:26:27 +00:00
|
|
|
ida_free(&sd_index_ida, index);
|
2006-03-18 20:14:21 +00:00
|
|
|
out_put:
|
2005-04-16 22:20:36 +00:00
|
|
|
put_disk(gd);
|
2017-02-03 19:38:54 +00:00
|
|
|
out_free:
|
|
|
|
kfree(sdkp);
|
2006-03-18 20:14:21 +00:00
|
|
|
out:
|
2014-09-10 11:54:09 +00:00
|
|
|
scsi_autopm_put_device(sdp);
|
2005-04-16 22:20:36 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sd_remove - called whenever a scsi disk (previously recognized by
|
|
|
|
* sd_probe) is detached from the system. It is called (potentially
|
|
|
|
* multiple times) during sd module unload.
|
2017-01-12 21:17:20 +00:00
|
|
|
* @dev: pointer to device object
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Note: this function is invoked from the scsi mid-level.
|
|
|
|
* This function potentially frees up a device name (e.g. /dev/sdc)
|
|
|
|
* that could be re-used by a subsequent sd_probe().
|
|
|
|
* This function is not called when the built-in sd driver is "exit-ed".
|
|
|
|
**/
|
|
|
|
static int sd_remove(struct device *dev)
|
|
|
|
{
|
2022-03-08 05:51:53 +00:00
|
|
|
struct scsi_disk *sdkp = dev_get_drvdata(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-06-16 18:52:17 +00:00
|
|
|
scsi_autopm_get_device(sdkp->device);
|
|
|
|
|
2022-03-08 05:51:50 +00:00
|
|
|
device_del(&sdkp->disk_dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
del_gendisk(sdkp->disk);
|
|
|
|
sd_shutdown(dev);
|
2005-11-04 19:44:41 +00:00
|
|
|
|
2022-03-08 05:51:53 +00:00
|
|
|
put_disk(sdkp->disk);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-21 23:13:36 +00:00
|
|
|
static void scsi_disk_release(struct device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-02-21 23:13:36 +00:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2019-03-25 17:01:46 +00:00
|
|
|
|
2018-06-11 19:26:27 +00:00
|
|
|
ida_free(&sd_index_ida, sdkp->index);
|
2022-06-01 06:25:44 +00:00
|
|
|
sd_zbc_free_zone_info(sdkp);
|
2022-03-08 05:51:51 +00:00
|
|
|
put_device(&sdkp->device->sdev_gendev);
|
2022-03-08 05:51:52 +00:00
|
|
|
free_opal_dev(sdkp->opal_dev);
|
2020-05-12 08:55:51 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(sdkp);
|
|
|
|
}
|
|
|
|
|
2007-03-20 17:26:03 +00:00
|
|
|
static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
|
2007-03-20 15:13:59 +00:00
|
|
|
{
|
|
|
|
unsigned char cmd[6] = { START_STOP }; /* START_VALID */
|
2022-08-16 17:26:38 +00:00
|
|
|
struct scsi_sense_hdr sshdr;
|
2022-12-29 19:01:47 +00:00
|
|
|
const struct scsi_exec_args exec_args = {
|
|
|
|
.sshdr = &sshdr,
|
|
|
|
.req_flags = BLK_MQ_REQ_PM,
|
|
|
|
};
|
2007-03-20 17:26:03 +00:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2022-08-16 17:26:38 +00:00
|
|
|
int res;
|
2007-03-20 15:13:59 +00:00
|
|
|
|
|
|
|
if (start)
|
|
|
|
cmd[4] |= 1; /* START */
|
|
|
|
|
2008-05-10 22:34:07 +00:00
|
|
|
if (sdp->start_stop_pwr_cond)
|
|
|
|
cmd[4] |= start ? 1 << 4 : 3 << 4; /* Active or Standby */
|
|
|
|
|
2007-03-20 15:13:59 +00:00
|
|
|
if (!scsi_device_online(sdp))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2022-12-29 19:01:47 +00:00
|
|
|
res = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, NULL, 0, SD_TIMEOUT,
|
|
|
|
sdkp->max_retries, &exec_args);
|
2022-08-16 17:26:38 +00:00
|
|
|
if (res) {
|
|
|
|
sd_print_result(sdkp, "Start/Stop Unit failed", res);
|
|
|
|
if (res > 0 && scsi_sense_valid(&sshdr)) {
|
|
|
|
sd_print_sense_hdr(sdkp, &sshdr);
|
|
|
|
/* 0x3a is medium not present */
|
|
|
|
if (sshdr.asc == 0x3a)
|
|
|
|
res = 0;
|
|
|
|
}
|
|
|
|
}
|
2007-03-20 15:13:59 +00:00
|
|
|
|
2022-08-16 17:26:38 +00:00
|
|
|
/* SCSI error codes must not go to the generic layer */
|
|
|
|
if (res)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return 0;
|
2007-03-20 15:13:59 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Send a SYNCHRONIZE CACHE instruction down to the device through
|
|
|
|
* the normal SCSI command structure. Wait for the command to
|
|
|
|
* complete.
|
|
|
|
*/
|
|
|
|
static void sd_shutdown(struct device *dev)
|
|
|
|
{
|
2015-02-02 13:01:25 +00:00
|
|
|
struct scsi_disk *sdkp = dev_get_drvdata(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!sdkp)
|
|
|
|
return; /* this can happen */
|
|
|
|
|
2011-12-05 01:20:26 +00:00
|
|
|
if (pm_runtime_suspended(dev))
|
2015-02-02 13:01:25 +00:00
|
|
|
return;
|
2011-12-05 01:20:26 +00:00
|
|
|
|
2013-09-16 11:28:15 +00:00
|
|
|
if (sdkp->WCE && sdkp->media_present) {
|
2007-02-28 03:40:55 +00:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
|
2017-05-11 12:34:24 +00:00
|
|
|
sd_sync_cache(sdkp, NULL);
|
2005-11-04 19:44:41 +00:00
|
|
|
}
|
2007-03-20 15:13:59 +00:00
|
|
|
|
2007-03-20 17:26:03 +00:00
|
|
|
if (system_state != SYSTEM_RESTART && sdkp->device->manage_start_stop) {
|
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
|
|
|
|
sd_start_stop_device(sdkp, 0);
|
2007-03-20 15:13:59 +00:00
|
|
|
}
|
2005-11-04 19:44:41 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-09-16 11:28:15 +00:00
|
|
|
static int sd_suspend_common(struct device *dev, bool ignore_stop_errors)
|
2007-03-20 15:13:59 +00:00
|
|
|
{
|
2015-02-02 13:01:25 +00:00
|
|
|
struct scsi_disk *sdkp = dev_get_drvdata(dev);
|
2017-05-11 12:34:24 +00:00
|
|
|
struct scsi_sense_hdr sshdr;
|
2007-05-21 13:55:04 +00:00
|
|
|
int ret = 0;
|
2007-03-20 15:13:59 +00:00
|
|
|
|
2016-01-20 16:26:01 +00:00
|
|
|
if (!sdkp) /* E.g.: runtime suspend following sd_remove() */
|
|
|
|
return 0;
|
2007-03-20 15:13:59 +00:00
|
|
|
|
2013-09-16 11:28:15 +00:00
|
|
|
if (sdkp->WCE && sdkp->media_present) {
|
2022-02-28 11:36:51 +00:00
|
|
|
if (!sdkp->device->silence_suspend)
|
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
|
2017-05-11 12:34:24 +00:00
|
|
|
ret = sd_sync_cache(sdkp, &sshdr);
|
|
|
|
|
2013-09-16 11:28:15 +00:00
|
|
|
if (ret) {
|
|
|
|
/* ignore OFFLINE device */
|
|
|
|
if (ret == -ENODEV)
|
2017-05-11 12:34:24 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!scsi_sense_valid(&sshdr) ||
|
|
|
|
sshdr.sense_key != ILLEGAL_REQUEST)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* sshdr.sense_key == ILLEGAL_REQUEST means this drive
|
|
|
|
* doesn't support sync. There's not much to do and
|
|
|
|
* suspend shouldn't fail.
|
|
|
|
*/
|
2017-08-25 20:46:34 +00:00
|
|
|
ret = 0;
|
2013-09-16 11:28:15 +00:00
|
|
|
}
|
2007-03-20 15:13:59 +00:00
|
|
|
}
|
|
|
|
|
2012-11-09 07:27:55 +00:00
|
|
|
if (sdkp->device->manage_start_stop) {
|
2022-02-28 11:36:51 +00:00
|
|
|
if (!sdkp->device->silence_suspend)
|
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
|
2013-09-16 11:28:15 +00:00
|
|
|
/* an error is not worth aborting a system sleep */
|
2007-03-20 17:26:03 +00:00
|
|
|
ret = sd_start_stop_device(sdkp, 0);
|
2013-09-16 11:28:15 +00:00
|
|
|
if (ignore_stop_errors)
|
|
|
|
ret = 0;
|
2007-03-20 15:13:59 +00:00
|
|
|
}
|
|
|
|
|
2007-05-21 13:55:04 +00:00
|
|
|
return ret;
|
2007-03-20 15:13:59 +00:00
|
|
|
}
|
|
|
|
|
2013-09-16 11:28:15 +00:00
|
|
|
static int sd_suspend_system(struct device *dev)
|
|
|
|
{
|
2021-10-06 21:54:53 +00:00
|
|
|
if (pm_runtime_suspended(dev))
|
|
|
|
return 0;
|
|
|
|
|
2013-09-16 11:28:15 +00:00
|
|
|
return sd_suspend_common(dev, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sd_suspend_runtime(struct device *dev)
|
|
|
|
{
|
|
|
|
return sd_suspend_common(dev, false);
|
|
|
|
}
|
|
|
|
|
2007-03-20 15:13:59 +00:00
|
|
|
static int sd_resume(struct device *dev)
|
|
|
|
{
|
2015-02-02 13:01:25 +00:00
|
|
|
struct scsi_disk *sdkp = dev_get_drvdata(dev);
|
2017-06-19 12:26:46 +00:00
|
|
|
int ret;
|
2007-03-20 15:13:59 +00:00
|
|
|
|
2016-01-20 16:26:01 +00:00
|
|
|
if (!sdkp) /* E.g.: runtime resume at the start of sd_probe() */
|
|
|
|
return 0;
|
|
|
|
|
2007-03-20 17:26:03 +00:00
|
|
|
if (!sdkp->device->manage_start_stop)
|
2015-02-02 13:01:25 +00:00
|
|
|
return 0;
|
2007-03-20 15:13:59 +00:00
|
|
|
|
2007-03-20 17:26:03 +00:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
|
2017-06-19 12:26:46 +00:00
|
|
|
ret = sd_start_stop_device(sdkp, 1);
|
|
|
|
if (!ret)
|
|
|
|
opal_unlock_from_suspend(sdkp->opal_dev);
|
|
|
|
return ret;
|
2007-03-20 15:13:59 +00:00
|
|
|
}
|
|
|
|
|
2021-10-06 21:54:52 +00:00
|
|
|
static int sd_resume_system(struct device *dev)
|
|
|
|
{
|
2021-10-06 21:54:53 +00:00
|
|
|
if (pm_runtime_suspended(dev))
|
|
|
|
return 0;
|
|
|
|
|
2021-10-06 21:54:52 +00:00
|
|
|
return sd_resume(dev);
|
|
|
|
}
|
|
|
|
|
2021-07-04 07:54:02 +00:00
|
|
|
static int sd_resume_runtime(struct device *dev)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = dev_get_drvdata(dev);
|
2021-10-15 07:46:54 +00:00
|
|
|
struct scsi_device *sdp;
|
|
|
|
|
|
|
|
if (!sdkp) /* E.g.: runtime resume at the start of sd_probe() */
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
sdp = sdkp->device;
|
2021-07-04 07:54:02 +00:00
|
|
|
|
|
|
|
if (sdp->ignore_media_change) {
|
|
|
|
/* clear the device's sense data */
|
|
|
|
static const u8 cmd[10] = { REQUEST_SENSE };
|
2022-12-29 19:01:47 +00:00
|
|
|
const struct scsi_exec_args exec_args = {
|
|
|
|
.req_flags = BLK_MQ_REQ_PM,
|
|
|
|
};
|
2021-07-04 07:54:02 +00:00
|
|
|
|
2022-12-29 19:01:47 +00:00
|
|
|
if (scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, NULL, 0,
|
|
|
|
sdp->request_queue->rq_timeout, 1,
|
|
|
|
&exec_args))
|
2021-07-04 07:54:02 +00:00
|
|
|
sd_printk(KERN_NOTICE, sdkp,
|
|
|
|
"Failed to clear sense data\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
return sd_resume(dev);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* init_sd - entry point for this driver (both when built in or when
|
|
|
|
* a module).
|
|
|
|
*
|
|
|
|
* Note: this function registers this driver with the scsi mid-level.
|
|
|
|
**/
|
|
|
|
static int __init init_sd(void)
|
|
|
|
{
|
2006-10-04 09:32:54 +00:00
|
|
|
int majors = 0, i, err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n"));
|
|
|
|
|
2013-05-10 09:06:16 +00:00
|
|
|
for (i = 0; i < SD_MAJORS; i++) {
|
2020-10-29 14:58:31 +00:00
|
|
|
if (__register_blkdev(sd_major(i), "sd", sd_default_probe))
|
2013-05-10 09:06:16 +00:00
|
|
|
continue;
|
|
|
|
majors++;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!majors)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2006-10-04 09:32:54 +00:00
|
|
|
err = class_register(&sd_disk_class);
|
|
|
|
if (err)
|
|
|
|
goto err_out;
|
2006-03-18 20:14:21 +00:00
|
|
|
|
2018-12-12 13:46:55 +00:00
|
|
|
sd_page_pool = mempool_create_page_pool(SD_MEMPOOL_SIZE, 0);
|
|
|
|
if (!sd_page_pool) {
|
|
|
|
printk(KERN_ERR "sd: can't init discard page pool\n");
|
|
|
|
err = -ENOMEM;
|
2023-02-21 11:53:40 +00:00
|
|
|
goto err_out_class;
|
2018-12-12 13:46:55 +00:00
|
|
|
}
|
|
|
|
|
2012-10-10 08:36:11 +00:00
|
|
|
err = scsi_register_driver(&sd_template.gendrv);
|
|
|
|
if (err)
|
|
|
|
goto err_out_driver;
|
|
|
|
|
2006-10-04 09:32:54 +00:00
|
|
|
return 0;
|
|
|
|
|
2012-10-10 08:36:11 +00:00
|
|
|
err_out_driver:
|
2018-12-12 13:46:55 +00:00
|
|
|
mempool_destroy(sd_page_pool);
|
2006-10-04 09:32:54 +00:00
|
|
|
err_out_class:
|
|
|
|
class_unregister(&sd_disk_class);
|
|
|
|
err_out:
|
|
|
|
for (i = 0; i < SD_MAJORS; i++)
|
|
|
|
unregister_blkdev(sd_major(i), "sd");
|
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* exit_sd - exit point for this driver (when it is a module).
|
|
|
|
*
|
|
|
|
* Note: this function unregisters this driver from the scsi mid-level.
|
|
|
|
**/
|
|
|
|
static void __exit exit_sd(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
SCSI_LOG_HLQUEUE(3, printk("exit_sd: exiting sd driver\n"));
|
|
|
|
|
2012-10-10 08:36:11 +00:00
|
|
|
scsi_unregister_driver(&sd_template.gendrv);
|
2018-12-12 13:46:55 +00:00
|
|
|
mempool_destroy(sd_page_pool);
|
2009-09-20 20:49:38 +00:00
|
|
|
|
2006-10-04 09:32:54 +00:00
|
|
|
class_unregister(&sd_disk_class);
|
|
|
|
|
2020-10-29 14:58:31 +00:00
|
|
|
for (i = 0; i < SD_MAJORS; i++)
|
2005-04-16 22:20:36 +00:00
|
|
|
unregister_blkdev(sd_major(i), "sd");
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(init_sd);
|
|
|
|
module_exit(exit_sd);
|
2007-02-28 03:40:55 +00:00
|
|
|
|
2019-11-25 07:05:18 +00:00
|
|
|
void sd_print_sense_hdr(struct scsi_disk *sdkp, struct scsi_sense_hdr *sshdr)
|
2007-02-28 03:40:55 +00:00
|
|
|
{
|
2015-01-08 06:43:46 +00:00
|
|
|
scsi_print_sense_hdr(sdkp->device,
|
|
|
|
sdkp->disk ? sdkp->disk->disk_name : NULL, sshdr);
|
2007-02-28 03:40:55 +00:00
|
|
|
}
|
|
|
|
|
2019-11-25 07:05:18 +00:00
|
|
|
void sd_print_result(const struct scsi_disk *sdkp, const char *msg, int result)
|
2007-02-28 03:40:55 +00:00
|
|
|
{
|
2014-10-24 12:27:00 +00:00
|
|
|
const char *hb_string = scsi_hostbyte_string(result);
|
|
|
|
|
2021-04-27 08:30:20 +00:00
|
|
|
if (hb_string)
|
2014-10-24 12:27:00 +00:00
|
|
|
sd_printk(KERN_INFO, sdkp,
|
|
|
|
"%s: Result: hostbyte=%s driverbyte=%s\n", msg,
|
|
|
|
hb_string ? hb_string : "invalid",
|
2021-04-27 08:30:20 +00:00
|
|
|
"DRIVER_OK");
|
2014-10-24 12:27:00 +00:00
|
|
|
else
|
|
|
|
sd_printk(KERN_INFO, sdkp,
|
2021-04-27 08:30:20 +00:00
|
|
|
"%s: Result: hostbyte=0x%02x driverbyte=%s\n",
|
|
|
|
msg, host_byte(result), "DRIVER_OK");
|
2007-02-28 03:40:55 +00:00
|
|
|
}
|