2005-04-16 16:20:36 -06: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/genhd.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>
|
|
|
|
#include <linux/delay.h>
|
2006-01-11 05:16:10 -07:00
|
|
|
#include <linux/mutex.h>
|
2008-08-31 09:41:52 -06:00
|
|
|
#include <linux/string_helpers.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
|
|
|
#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 10:47:32 -06:00
|
|
|
#include "sd.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "scsi_logging.h"
|
|
|
|
|
2006-03-08 01:14:20 -07: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 06:02:37 -06:00
|
|
|
MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK);
|
|
|
|
MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD);
|
|
|
|
MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
|
2006-03-08 01:14:20 -07:00
|
|
|
|
2008-08-25 04:47:25 -06:00
|
|
|
#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
|
2008-08-25 04:47:24 -06:00
|
|
|
#define SD_MINORS 16
|
2008-08-25 04:47:25 -06:00
|
|
|
#else
|
2008-08-25 04:56:17 -06:00
|
|
|
#define SD_MINORS 0
|
2008-08-25 04:47:25 -06:00
|
|
|
#endif
|
|
|
|
|
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 11:17:12 -07:00
|
|
|
static int sd_revalidate_disk(struct gendisk *);
|
|
|
|
static int sd_probe(struct device *);
|
|
|
|
static int sd_remove(struct device *);
|
|
|
|
static void sd_shutdown(struct device *);
|
|
|
|
static int sd_suspend(struct device *, pm_message_t state);
|
|
|
|
static int sd_resume(struct device *);
|
|
|
|
static void sd_rescan(struct device *);
|
|
|
|
static int sd_done(struct scsi_cmnd *);
|
|
|
|
static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
|
2008-02-21 16:13:36 -07: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 11:17:12 -07:00
|
|
|
static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
|
|
|
|
static void sd_print_result(struct scsi_disk *, int);
|
|
|
|
|
2008-07-13 23:59:30 -06:00
|
|
|
static DEFINE_IDA(sd_index_ida);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* This semaphore is used to mediate the 0->1 reference get in the
|
|
|
|
* face of object destruction (i.e. we can't allow a get on an
|
|
|
|
* object after last put) */
|
2006-01-11 05:16:10 -07:00
|
|
|
static DEFINE_MUTEX(sd_ref_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-03-18 13:14:21 -07:00
|
|
|
static const char *sd_cache_types[] = {
|
|
|
|
"write through", "none", "write back",
|
|
|
|
"write back, no read (daft)"
|
|
|
|
};
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
static ssize_t
|
|
|
|
sd_store_cache_type(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2006-03-18 13:14:21 -07:00
|
|
|
{
|
|
|
|
int i, ct = -1, rcd, wce, sp;
|
2008-02-21 16:13:36 -07:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2006-03-18 13:14:21 -07:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
char buffer[64];
|
|
|
|
char *buffer_data;
|
|
|
|
struct scsi_mode_data data;
|
|
|
|
struct scsi_sense_hdr sshdr;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (sdp->type != TYPE_DISK)
|
|
|
|
/* 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;
|
|
|
|
|
2006-06-08 23:23:48 -06:00
|
|
|
for (i = 0; i < ARRAY_SIZE(sd_cache_types); i++) {
|
2006-03-18 13:14:21 -07:00
|
|
|
const int len = strlen(sd_cache_types[i]);
|
|
|
|
if (strncmp(sd_cache_types[i], buf, len) == 0 &&
|
|
|
|
buf[len] == '\n') {
|
|
|
|
ct = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ct < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
rcd = ct & 0x01 ? 1 : 0;
|
|
|
|
wce = ct & 0x02 ? 1 : 0;
|
|
|
|
if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT,
|
|
|
|
SD_MAX_RETRIES, &data, NULL))
|
|
|
|
return -EINVAL;
|
2006-03-25 04:08:30 -07:00
|
|
|
len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
|
2006-03-18 13:14:21 -07: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;
|
|
|
|
|
|
|
|
if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT,
|
|
|
|
SD_MAX_RETRIES, &data, &sshdr)) {
|
|
|
|
if (scsi_sense_valid(&sshdr))
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_print_sense_hdr(sdkp, &sshdr);
|
2006-03-18 13:14:21 -07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2008-09-04 14:27:35 -06:00
|
|
|
revalidate_disk(sdkp->disk);
|
2006-03-18 13:14:21 -07:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
static ssize_t
|
|
|
|
sd_store_manage_start_stop(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2007-03-20 09:13:59 -06:00
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2007-03-20 09:13:59 -06:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
|
|
|
|
sdp->manage_start_stop = simple_strtoul(buf, NULL, 10);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
static ssize_t
|
|
|
|
sd_store_allow_restart(struct device *dev, struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2006-06-27 10:10:31 -06:00
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2006-06-27 10:10:31 -06:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EACCES;
|
|
|
|
|
|
|
|
if (sdp->type != TYPE_DISK)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
sdp->allow_restart = simple_strtoul(buf, NULL, 10);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
static ssize_t
|
|
|
|
sd_show_cache_type(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2006-03-18 13:14:21 -07:00
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2006-03-18 13:14:21 -07:00
|
|
|
int ct = sdkp->RCD + 2*sdkp->WCE;
|
|
|
|
|
|
|
|
return snprintf(buf, 40, "%s\n", sd_cache_types[ct]);
|
|
|
|
}
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
static ssize_t
|
|
|
|
sd_show_fua(struct device *dev, struct device_attribute *attr, char *buf)
|
2006-03-18 13:14:21 -07:00
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2006-03-18 13:14:21 -07:00
|
|
|
|
|
|
|
return snprintf(buf, 20, "%u\n", sdkp->DPOFUA);
|
|
|
|
}
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
static ssize_t
|
|
|
|
sd_show_manage_start_stop(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2007-03-20 09:13:59 -06:00
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2007-03-20 09:13:59 -06:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
|
|
|
|
return snprintf(buf, 20, "%u\n", sdp->manage_start_stop);
|
|
|
|
}
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
static ssize_t
|
|
|
|
sd_show_allow_restart(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2006-06-27 10:10:31 -06:00
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2006-06-27 10:10:31 -06:00
|
|
|
|
|
|
|
return snprintf(buf, 40, "%d\n", sdkp->device->allow_restart);
|
|
|
|
}
|
|
|
|
|
2008-07-17 02:28:34 -06:00
|
|
|
static ssize_t
|
|
|
|
sd_show_protection_type(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
|
|
|
|
return snprintf(buf, 20, "%u\n", sdkp->protection_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
sd_show_app_tag_own(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
|
|
|
|
|
|
|
return snprintf(buf, 20, "%u\n", sdkp->ATO);
|
|
|
|
}
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
static struct device_attribute sd_disk_attrs[] = {
|
2006-03-18 13:14:21 -07:00
|
|
|
__ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
|
|
|
|
sd_store_cache_type),
|
|
|
|
__ATTR(FUA, S_IRUGO, sd_show_fua, NULL),
|
2006-06-27 10:10:31 -06:00
|
|
|
__ATTR(allow_restart, S_IRUGO|S_IWUSR, sd_show_allow_restart,
|
|
|
|
sd_store_allow_restart),
|
2007-03-20 09:13:59 -06:00
|
|
|
__ATTR(manage_start_stop, S_IRUGO|S_IWUSR, sd_show_manage_start_stop,
|
|
|
|
sd_store_manage_start_stop),
|
2008-07-17 02:28:34 -06:00
|
|
|
__ATTR(protection_type, S_IRUGO, sd_show_protection_type, NULL),
|
|
|
|
__ATTR(app_tag_own, S_IRUGO, sd_show_app_tag_own, NULL),
|
2006-03-18 13:14:21 -07:00
|
|
|
__ATTR_NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct class sd_disk_class = {
|
|
|
|
.name = "scsi_disk",
|
|
|
|
.owner = THIS_MODULE,
|
2008-02-21 16:13:36 -07:00
|
|
|
.dev_release = scsi_disk_release,
|
|
|
|
.dev_attrs = sd_disk_attrs,
|
2006-03-18 13:14:21 -07:00
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static struct scsi_driver sd_template = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.gendrv = {
|
|
|
|
.name = "sd",
|
|
|
|
.probe = sd_probe,
|
|
|
|
.remove = sd_remove,
|
2007-03-20 09:13:59 -06:00
|
|
|
.suspend = sd_suspend,
|
|
|
|
.resume = sd_resume,
|
2005-04-16 16:20:36 -06:00
|
|
|
.shutdown = sd_shutdown,
|
|
|
|
},
|
|
|
|
.rescan = sd_rescan,
|
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 11:17:12 -07:00
|
|
|
.done = sd_done,
|
2005-04-16 16:20:36 -06: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 */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-04 12:44:41 -07:00
|
|
|
static struct scsi_disk *__scsi_disk_get(struct gendisk *disk)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = NULL;
|
|
|
|
|
2005-11-04 12:44:41 -07:00
|
|
|
if (disk->private_data) {
|
|
|
|
sdkp = scsi_disk(disk);
|
|
|
|
if (scsi_device_get(sdkp->device) == 0)
|
2008-02-21 16:13:36 -07:00
|
|
|
get_device(&sdkp->dev);
|
2005-11-04 12:44:41 -07:00
|
|
|
else
|
|
|
|
sdkp = NULL;
|
|
|
|
}
|
|
|
|
return sdkp;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct scsi_disk *scsi_disk_get(struct gendisk *disk)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp;
|
|
|
|
|
2006-01-11 05:16:10 -07:00
|
|
|
mutex_lock(&sd_ref_mutex);
|
2005-11-04 12:44:41 -07:00
|
|
|
sdkp = __scsi_disk_get(disk);
|
2006-01-11 05:16:10 -07:00
|
|
|
mutex_unlock(&sd_ref_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
return sdkp;
|
2005-11-04 12:44:41 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-04 12:44:41 -07:00
|
|
|
static struct scsi_disk *scsi_disk_get_from_dev(struct device *dev)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp;
|
|
|
|
|
2006-01-11 05:16:10 -07:00
|
|
|
mutex_lock(&sd_ref_mutex);
|
2005-11-04 12:44:41 -07:00
|
|
|
sdkp = dev_get_drvdata(dev);
|
|
|
|
if (sdkp)
|
|
|
|
sdkp = __scsi_disk_get(sdkp->disk);
|
2006-01-11 05:16:10 -07:00
|
|
|
mutex_unlock(&sd_ref_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
return sdkp;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void scsi_disk_put(struct scsi_disk *sdkp)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdev = sdkp->device;
|
|
|
|
|
2006-01-11 05:16:10 -07:00
|
|
|
mutex_lock(&sd_ref_mutex);
|
2008-02-21 16:13:36 -07:00
|
|
|
put_device(&sdkp->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
scsi_device_put(sdev);
|
2006-01-11 05:16:10 -07:00
|
|
|
mutex_unlock(&sd_ref_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sd_init_command - build a scsi (read or write) command from
|
|
|
|
* information in the request structure.
|
|
|
|
* @SCpnt: pointer to mid-level's per scsi command structure that
|
|
|
|
* contains request and into which the scsi command is written
|
|
|
|
*
|
|
|
|
* Returns 1 if successful and 0 if error (or cannot be done now).
|
|
|
|
**/
|
2007-08-04 09:06:25 -06:00
|
|
|
static int sd_prep_fn(struct request_queue *q, struct request *rq)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-08-04 09:06:25 -06:00
|
|
|
struct scsi_cmnd *SCpnt;
|
|
|
|
struct scsi_device *sdp = q->queuedata;
|
2006-01-06 10:34:07 -07:00
|
|
|
struct gendisk *disk = rq->rq_disk;
|
2008-07-17 02:28:35 -06:00
|
|
|
struct scsi_disk *sdkp;
|
2006-01-06 10:34:07 -07:00
|
|
|
sector_t block = rq->sector;
|
2008-08-05 22:42:21 -06:00
|
|
|
sector_t threshold;
|
2007-08-04 09:06:25 -06:00
|
|
|
unsigned int this_count = rq->nr_sectors;
|
2008-09-19 16:47:19 -06:00
|
|
|
int ret, host_dif;
|
2007-08-04 09:06:25 -06:00
|
|
|
|
|
|
|
if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
|
|
|
|
ret = scsi_setup_blk_pc_cmnd(sdp, rq);
|
|
|
|
goto out;
|
|
|
|
} else if (rq->cmd_type != REQ_TYPE_FS) {
|
|
|
|
ret = BLKPREP_KILL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = scsi_setup_fs_cmnd(sdp, rq);
|
|
|
|
if (ret != BLKPREP_OK)
|
|
|
|
goto out;
|
|
|
|
SCpnt = rq->special;
|
2008-07-17 02:28:35 -06:00
|
|
|
sdkp = scsi_disk(disk);
|
2007-08-04 09:06:25 -06:00
|
|
|
|
|
|
|
/* from here on until we're complete, any goto out
|
|
|
|
* is used for a killable error condition */
|
|
|
|
ret = BLKPREP_KILL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-27 20:41:19 -07:00
|
|
|
SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
|
|
|
|
"sd_init_command: block=%llu, "
|
|
|
|
"count=%d\n",
|
|
|
|
(unsigned long long)block,
|
|
|
|
this_count));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!sdp || !scsi_device_online(sdp) ||
|
|
|
|
block + rq->nr_sectors > get_capacity(disk)) {
|
2007-02-27 20:41:19 -07:00
|
|
|
SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
|
|
|
|
"Finishing %ld sectors\n",
|
|
|
|
rq->nr_sectors));
|
|
|
|
SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
|
|
|
|
"Retry with 0x%p\n", SCpnt));
|
2007-08-04 09:06:25 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sdp->changed) {
|
|
|
|
/*
|
|
|
|
* quietly refuse to do anything to a changed disc until
|
|
|
|
* the changed bit has been reset
|
|
|
|
*/
|
|
|
|
/* printk("SCSI disk has been changed. Prohibiting further I/O.\n"); */
|
2007-08-04 09:06:25 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-08-04 09:06:25 -06:00
|
|
|
|
2008-01-20 03:12:26 -07:00
|
|
|
/*
|
2008-08-05 22:42:21 -06:00
|
|
|
* Some SD card readers can't handle multi-sector accesses which touch
|
|
|
|
* the last one or two hardware sectors. Split accesses as needed.
|
2008-01-20 03:12:26 -07:00
|
|
|
*/
|
2008-08-05 22:42:21 -06:00
|
|
|
threshold = get_capacity(disk) - SD_LAST_BUGGY_SECTORS *
|
|
|
|
(sdp->sector_size / 512);
|
|
|
|
|
|
|
|
if (unlikely(sdp->last_sector_bug && block + this_count > threshold)) {
|
|
|
|
if (block < threshold) {
|
|
|
|
/* Access up to the threshold but not beyond */
|
|
|
|
this_count = threshold - block;
|
|
|
|
} else {
|
|
|
|
/* Access only a single hardware sector */
|
|
|
|
this_count = sdp->sector_size / 512;
|
|
|
|
}
|
|
|
|
}
|
2008-01-20 03:12:26 -07:00
|
|
|
|
2007-02-27 20:41:19 -07:00
|
|
|
SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n",
|
|
|
|
(unsigned long long)block));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have a 1K hardware sectorsize, prevent access to single
|
|
|
|
* 512 byte sectors. In theory we could handle this - in fact
|
|
|
|
* the scsi cdrom driver must be able to handle this because
|
|
|
|
* we typically use 1K blocksizes, and cdroms typically have
|
|
|
|
* 2K hardware sectorsizes. Of course, things are simpler
|
|
|
|
* with the cdrom, since it is read-only. For performance
|
|
|
|
* reasons, the filesystems should be able to handle this
|
|
|
|
* and not force the scsi disk driver to use bounce buffers
|
|
|
|
* for this.
|
|
|
|
*/
|
|
|
|
if (sdp->sector_size == 1024) {
|
|
|
|
if ((block & 1) || (rq->nr_sectors & 1)) {
|
2007-02-27 20:40:55 -07:00
|
|
|
scmd_printk(KERN_ERR, SCpnt,
|
|
|
|
"Bad block number requested\n");
|
2007-08-04 09:06:25 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
block = block >> 1;
|
|
|
|
this_count = this_count >> 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sdp->sector_size == 2048) {
|
|
|
|
if ((block & 3) || (rq->nr_sectors & 3)) {
|
2007-02-27 20:40:55 -07:00
|
|
|
scmd_printk(KERN_ERR, SCpnt,
|
|
|
|
"Bad block number requested\n");
|
2007-08-04 09:06:25 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
block = block >> 2;
|
|
|
|
this_count = this_count >> 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sdp->sector_size == 4096) {
|
|
|
|
if ((block & 7) || (rq->nr_sectors & 7)) {
|
2007-02-27 20:40:55 -07:00
|
|
|
scmd_printk(KERN_ERR, SCpnt,
|
|
|
|
"Bad block number requested\n");
|
2007-08-04 09:06:25 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
block = block >> 3;
|
|
|
|
this_count = this_count >> 3;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (rq_data_dir(rq) == WRITE) {
|
|
|
|
if (!sdp->writeable) {
|
2007-08-04 09:06:25 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
SCpnt->cmnd[0] = WRITE_6;
|
|
|
|
SCpnt->sc_data_direction = DMA_TO_DEVICE;
|
2008-07-17 02:28:35 -06:00
|
|
|
|
|
|
|
if (blk_integrity_rq(rq) &&
|
|
|
|
sd_dif_prepare(rq, block, sdp->sector_size) == -EIO)
|
|
|
|
goto out;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
} else if (rq_data_dir(rq) == READ) {
|
|
|
|
SCpnt->cmnd[0] = READ_6;
|
|
|
|
SCpnt->sc_data_direction = DMA_FROM_DEVICE;
|
|
|
|
} else {
|
2007-02-27 20:40:55 -07:00
|
|
|
scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags);
|
2007-08-04 09:06:25 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-27 20:41:19 -07:00
|
|
|
SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
|
|
|
|
"%s %d/%ld 512 byte blocks.\n",
|
|
|
|
(rq_data_dir(rq) == WRITE) ?
|
|
|
|
"writing" : "reading", this_count,
|
|
|
|
rq->nr_sectors));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-17 02:28:35 -06:00
|
|
|
/* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
|
2008-09-19 16:47:19 -06:00
|
|
|
host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
|
|
|
|
if (host_dif)
|
2008-07-17 02:28:35 -06:00
|
|
|
SCpnt->cmnd[1] = 1 << 5;
|
|
|
|
else
|
|
|
|
SCpnt->cmnd[1] = 0;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (block > 0xffffffff) {
|
|
|
|
SCpnt->cmnd[0] += READ_16 - READ_6;
|
2006-01-06 01:53:52 -07:00
|
|
|
SCpnt->cmnd[1] |= blk_fua_rq(rq) ? 0x8 : 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
|
|
|
|
SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
|
|
|
|
SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
|
|
|
|
SCpnt->cmnd[5] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
|
|
|
|
SCpnt->cmnd[6] = (unsigned char) (block >> 24) & 0xff;
|
|
|
|
SCpnt->cmnd[7] = (unsigned char) (block >> 16) & 0xff;
|
|
|
|
SCpnt->cmnd[8] = (unsigned char) (block >> 8) & 0xff;
|
|
|
|
SCpnt->cmnd[9] = (unsigned char) block & 0xff;
|
|
|
|
SCpnt->cmnd[10] = (unsigned char) (this_count >> 24) & 0xff;
|
|
|
|
SCpnt->cmnd[11] = (unsigned char) (this_count >> 16) & 0xff;
|
|
|
|
SCpnt->cmnd[12] = (unsigned char) (this_count >> 8) & 0xff;
|
|
|
|
SCpnt->cmnd[13] = (unsigned char) this_count & 0xff;
|
|
|
|
SCpnt->cmnd[14] = SCpnt->cmnd[15] = 0;
|
|
|
|
} else if ((this_count > 0xff) || (block > 0x1fffff) ||
|
2008-07-17 02:28:35 -06:00
|
|
|
scsi_device_protection(SCpnt->device) ||
|
2005-04-16 16:20:36 -06:00
|
|
|
SCpnt->device->use_10_for_rw) {
|
|
|
|
if (this_count > 0xffff)
|
|
|
|
this_count = 0xffff;
|
|
|
|
|
|
|
|
SCpnt->cmnd[0] += READ_10 - READ_6;
|
2006-01-06 01:53:52 -07:00
|
|
|
SCpnt->cmnd[1] |= blk_fua_rq(rq) ? 0x8 : 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
|
|
|
|
SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
|
|
|
|
SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
|
|
|
|
SCpnt->cmnd[5] = (unsigned char) block & 0xff;
|
|
|
|
SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0;
|
|
|
|
SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
|
|
|
|
SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
|
|
|
|
} else {
|
2006-01-06 01:53:52 -07:00
|
|
|
if (unlikely(blk_fua_rq(rq))) {
|
|
|
|
/*
|
|
|
|
* This happens only if this drive failed
|
|
|
|
* 10byte rw command with ILLEGAL_REQUEST
|
|
|
|
* during operation and thus turned off
|
|
|
|
* use_10_for_rw.
|
|
|
|
*/
|
2007-02-27 20:40:55 -07:00
|
|
|
scmd_printk(KERN_ERR, SCpnt,
|
|
|
|
"FUA write on READ/WRITE(6) drive\n");
|
2007-08-04 09:06:25 -06:00
|
|
|
goto out;
|
2006-01-06 01:53:52 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
SCpnt->cmnd[1] |= (unsigned char) ((block >> 16) & 0x1f);
|
|
|
|
SCpnt->cmnd[2] = (unsigned char) ((block >> 8) & 0xff);
|
|
|
|
SCpnt->cmnd[3] = (unsigned char) block & 0xff;
|
|
|
|
SCpnt->cmnd[4] = (unsigned char) this_count;
|
|
|
|
SCpnt->cmnd[5] = 0;
|
|
|
|
}
|
2007-12-13 04:47:40 -07:00
|
|
|
SCpnt->sdb.length = this_count * sdp->sector_size;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-17 02:28:35 -06:00
|
|
|
/* If DIF or DIX is enabled, tell HBA how to handle request */
|
2008-09-19 16:47:19 -06:00
|
|
|
if (host_dif || scsi_prot_sg_count(SCpnt))
|
2008-09-19 16:47:21 -06:00
|
|
|
sd_dif_op(SCpnt, host_dif, scsi_prot_sg_count(SCpnt),
|
|
|
|
sdkp->protection_type);
|
2008-07-17 02:28:35 -06:00
|
|
|
|
2005-04-16 16:20:36 -06: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.
|
|
|
|
*/
|
|
|
|
SCpnt->transfersize = sdp->sector_size;
|
|
|
|
SCpnt->underflow = this_count << 9;
|
|
|
|
SCpnt->allowed = SD_MAX_RETRIES;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This indicates that the command is ready from our end to be
|
|
|
|
* queued.
|
|
|
|
*/
|
2007-08-04 09:06:25 -06:00
|
|
|
ret = BLKPREP_OK;
|
|
|
|
out:
|
|
|
|
return scsi_prep_return(q, rq, ret);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sd_open - open a scsi disk device
|
|
|
|
* @inode: only i_rdev member may be used
|
|
|
|
* @filp: only f_mode and f_flags may be used
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
**/
|
2008-03-02 08:41:04 -07:00
|
|
|
static int sd_open(struct block_device *bdev, fmode_t mode)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-03-02 08:41:04 -07:00
|
|
|
struct scsi_disk *sdkp = scsi_disk_get(bdev->bd_disk);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct scsi_device *sdev;
|
|
|
|
int retval;
|
|
|
|
|
2008-03-02 08:41:04 -07:00
|
|
|
if (!sdkp)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENXIO;
|
|
|
|
|
2007-02-27 20:41:19 -07:00
|
|
|
SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
sdev = sdkp->device;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
if (sdev->removable || sdkp->write_prot)
|
2008-03-02 08:41:04 -07:00
|
|
|
check_disk_change(bdev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the drive is empty, just let the open fail.
|
|
|
|
*/
|
|
|
|
retval = -ENOMEDIUM;
|
2008-03-02 08:41:04 -07:00
|
|
|
if (sdev->removable && !sdkp->media_present && !(mode & FMODE_NDELAY))
|
2005-04-16 16:20:36 -06: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;
|
2008-03-02 08:41:04 -07:00
|
|
|
if (sdkp->write_prot && (mode & FMODE_WRITE))
|
2005-04-16 16:20:36 -06: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;
|
|
|
|
|
|
|
|
if (!sdkp->openers++ && sdev->removable) {
|
|
|
|
if (scsi_block_when_processing_errors(sdev))
|
|
|
|
scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error_out:
|
|
|
|
scsi_disk_put(sdkp);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sd_release - invoked when the (last) close(2) is called on this
|
|
|
|
* scsi disk.
|
|
|
|
* @inode: only i_rdev member may be used
|
|
|
|
* @filp: only f_mode and f_flags may be used
|
|
|
|
*
|
|
|
|
* Returns 0.
|
|
|
|
*
|
|
|
|
* Note: may block (uninterruptible) if error recovery is underway
|
|
|
|
* on this disk.
|
|
|
|
**/
|
2008-03-02 08:41:04 -07:00
|
|
|
static int sd_release(struct gendisk *disk, fmode_t mode)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = scsi_disk(disk);
|
|
|
|
struct scsi_device *sdev = sdkp->device;
|
|
|
|
|
2007-03-11 11:25:33 -06:00
|
|
|
SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n"));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!--sdkp->openers && sdev->removable) {
|
|
|
|
if (scsi_block_when_processing_errors(sdev))
|
|
|
|
scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX and what if there are packets in flight and this close()
|
|
|
|
* XXX is followed by a "rmmod sd_mod"?
|
|
|
|
*/
|
|
|
|
scsi_disk_put(sdkp);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-08 02:02:50 -07:00
|
|
|
static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
struct Scsi_Host *host = sdp->host;
|
|
|
|
int diskinfo[4];
|
|
|
|
|
|
|
|
/* default to most commonly used values */
|
|
|
|
diskinfo[0] = 0x40; /* 1 << 6 */
|
|
|
|
diskinfo[1] = 0x20; /* 1 << 5 */
|
|
|
|
diskinfo[2] = sdkp->capacity >> 11;
|
|
|
|
|
|
|
|
/* override with calculated, extended default, or driver values */
|
|
|
|
if (host->hostt->bios_param)
|
|
|
|
host->hostt->bios_param(sdp, bdev, sdkp->capacity, diskinfo);
|
|
|
|
else
|
|
|
|
scsicam_bios_param(bdev, sdkp->capacity, diskinfo);
|
|
|
|
|
2006-01-08 02:02:50 -07:00
|
|
|
geo->heads = diskinfo[0];
|
|
|
|
geo->sectors = diskinfo[1];
|
|
|
|
geo->cylinders = diskinfo[2];
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sd_ioctl - process an ioctl
|
|
|
|
* @inode: only i_rdev/i_bdev members may be used
|
|
|
|
* @filp: only f_mode and f_flags may be used
|
|
|
|
* @cmd: ioctl command number
|
|
|
|
* @arg: this is third argument given to ioctl(2) system call.
|
|
|
|
* Often contains a pointer.
|
|
|
|
*
|
|
|
|
* Returns 0 if successful (some ioctls return postive numbers on
|
|
|
|
* 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 15:10:43 -06:00
|
|
|
* down in the scsi subsystem.
|
2005-04-16 16:20:36 -06:00
|
|
|
**/
|
2008-03-02 08:41:04 -07:00
|
|
|
static int sd_ioctl(struct block_device *bdev, fmode_t mode,
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
struct gendisk *disk = bdev->bd_disk;
|
|
|
|
struct scsi_device *sdp = scsi_disk(disk)->device;
|
|
|
|
void __user *p = (void __user *)arg;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
SCSI_LOG_IOCTL(1, printk("sd_ioctl: disk=%s, cmd=0x%x\n",
|
|
|
|
disk->disk_name, cmd));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2008-03-02 06:15:49 -07:00
|
|
|
error = scsi_nonblockable_ioctl(sdp, cmd, p,
|
2008-03-02 08:41:04 -07:00
|
|
|
(mode & FMODE_NDELAY_NOW) != 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!scsi_block_when_processing_errors(sdp) || !error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Send SCSI addressing ioctls directly to mid level, send other
|
|
|
|
* ioctls to block level and then onto mid level if they can't be
|
|
|
|
* resolved.
|
|
|
|
*/
|
|
|
|
switch (cmd) {
|
|
|
|
case SCSI_IOCTL_GET_IDLUN:
|
|
|
|
case SCSI_IOCTL_GET_BUS_NUMBER:
|
|
|
|
return scsi_ioctl(sdp, cmd, p);
|
|
|
|
default:
|
2008-03-02 08:41:04 -07:00
|
|
|
error = scsi_cmd_ioctl(disk->queue, disk, mode, cmd, p);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (error != -ENOTTY)
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
return scsi_ioctl(sdp, cmd, p);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_media_not_present(struct scsi_disk *sdkp)
|
|
|
|
{
|
|
|
|
sdkp->media_present = 0;
|
|
|
|
sdkp->capacity = 0;
|
|
|
|
sdkp->device->changed = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sd_media_changed - check if our medium changed
|
|
|
|
* @disk: kernel device descriptor
|
|
|
|
*
|
|
|
|
* Returns 0 if not applicable or no change; 1 if change
|
|
|
|
*
|
|
|
|
* Note: this function is invoked from the block subsystem.
|
|
|
|
**/
|
|
|
|
static int sd_media_changed(struct gendisk *disk)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = scsi_disk(disk);
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2007-12-02 10:10:40 -07:00
|
|
|
struct scsi_sense_hdr *sshdr = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
int retval;
|
|
|
|
|
2007-02-27 20:41:19 -07:00
|
|
|
SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_media_changed\n"));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!sdp->removable)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 06:10:39 -06:00
|
|
|
if (!scsi_device_online(sdp)) {
|
|
|
|
set_media_not_present(sdkp);
|
|
|
|
retval = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 16:20:36 -06: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.
|
|
|
|
*/
|
|
|
|
retval = -ENODEV;
|
2007-08-14 06:10:39 -06:00
|
|
|
|
2007-12-02 10:10:40 -07:00
|
|
|
if (scsi_block_when_processing_errors(sdp)) {
|
|
|
|
sshdr = kzalloc(sizeof(*sshdr), GFP_KERNEL);
|
|
|
|
retval = scsi_test_unit_ready(sdp, SD_TIMEOUT, SD_MAX_RETRIES,
|
|
|
|
sshdr);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Unable to test, unit probably not ready. This usually
|
|
|
|
* means there is no disc in the drive. Mark as changed,
|
|
|
|
* and we will figure it out later once the drive is
|
|
|
|
* available again.
|
|
|
|
*/
|
2007-12-02 10:10:40 -07:00
|
|
|
if (retval || (scsi_sense_valid(sshdr) &&
|
|
|
|
/* 0x3a is medium not present */
|
|
|
|
sshdr->asc == 0x3a)) {
|
2007-08-14 06:10:39 -06:00
|
|
|
set_media_not_present(sdkp);
|
|
|
|
retval = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For removable scsi disk we have to recognise the presence
|
|
|
|
* of a disk in the drive. This is kept in the struct scsi_disk
|
|
|
|
* struct and tested at open ! Daniel Roche (dan@lectra.fr)
|
|
|
|
*/
|
|
|
|
sdkp->media_present = 1;
|
|
|
|
|
|
|
|
retval = sdp->changed;
|
|
|
|
sdp->changed = 0;
|
2007-08-14 06:10:39 -06:00
|
|
|
out:
|
|
|
|
if (retval != sdkp->previous_state)
|
|
|
|
sdev_evt_send_simple(sdp, SDEV_EVT_MEDIA_CHANGE, GFP_KERNEL);
|
|
|
|
sdkp->previous_state = retval;
|
2007-12-02 10:10:40 -07:00
|
|
|
kfree(sshdr);
|
2005-04-16 16:20:36 -06:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2007-02-27 20:40:55 -07:00
|
|
|
static int sd_sync_cache(struct scsi_disk *sdkp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int retries, res;
|
2007-02-27 20:40:55 -07:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2005-08-28 10:33:52 -06:00
|
|
|
struct scsi_sense_hdr sshdr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!scsi_device_online(sdp))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
|
|
|
|
for (retries = 3; retries > 0; --retries) {
|
|
|
|
unsigned char cmd[10] = { 0 };
|
|
|
|
|
|
|
|
cmd[0] = SYNCHRONIZE_CACHE;
|
|
|
|
/*
|
|
|
|
* Leave the rest of the command zero to indicate
|
|
|
|
* flush everything.
|
|
|
|
*/
|
2005-08-28 10:33:52 -06:00
|
|
|
res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
|
|
|
|
SD_TIMEOUT, SD_MAX_RETRIES);
|
|
|
|
if (res == 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-02-27 20:40:55 -07:00
|
|
|
if (res) {
|
|
|
|
sd_print_result(sdkp, res);
|
|
|
|
if (driver_byte(res) & DRIVER_SENSE)
|
|
|
|
sd_print_sense_hdr(sdkp, &sshdr);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-03-20 09:07:18 -06:00
|
|
|
if (res)
|
|
|
|
return -EIO;
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-07-24 01:28:11 -06:00
|
|
|
static void sd_prepare_flush(struct request_queue *q, struct request *rq)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-08-10 00:44:47 -06:00
|
|
|
rq->cmd_type = REQ_TYPE_BLOCK_PC;
|
2005-11-08 07:21:07 -07:00
|
|
|
rq->timeout = SD_TIMEOUT;
|
|
|
|
rq->cmd[0] = SYNCHRONIZE_CACHE;
|
2006-01-06 01:52:55 -07:00
|
|
|
rq->cmd_len = 10;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sd_rescan(struct device *dev)
|
|
|
|
{
|
2005-11-04 12:44:41 -07:00
|
|
|
struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
|
|
|
|
|
|
|
|
if (sdkp) {
|
2008-09-04 14:27:35 -06:00
|
|
|
revalidate_disk(sdkp->disk);
|
2005-11-04 12:44:41 -07:00
|
|
|
scsi_disk_put(sdkp);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
/*
|
|
|
|
* This gets directly called from VFS. When the ioctl
|
|
|
|
* is not recognized we go back to the other translation paths.
|
|
|
|
*/
|
2008-03-02 08:41:04 -07:00
|
|
|
static int sd_compat_ioctl(struct block_device *bdev, fmode_t mode,
|
|
|
|
unsigned int cmd, unsigned long arg)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-03-02 08:41:04 -07:00
|
|
|
struct scsi_device *sdev = scsi_disk(bdev->bd_disk)->device;
|
2005-04-16 16:20:36 -06: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.
|
|
|
|
*/
|
|
|
|
if (!scsi_block_when_processing_errors(sdev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (sdev->host->hostt->compat_ioctl) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Let the static ioctl translation table take care of it.
|
|
|
|
*/
|
|
|
|
return -ENOIOCTLCMD;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static struct block_device_operations sd_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
2008-03-02 08:41:04 -07:00
|
|
|
.open = sd_open,
|
|
|
|
.release = sd_release,
|
|
|
|
.locked_ioctl = sd_ioctl,
|
2006-01-08 02:02:50 -07:00
|
|
|
.getgeo = sd_getgeo,
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_COMPAT
|
2008-03-02 08:41:04 -07:00
|
|
|
.compat_ioctl = sd_compat_ioctl,
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
.media_changed = sd_media_changed,
|
|
|
|
.revalidate_disk = sd_revalidate_disk,
|
|
|
|
};
|
|
|
|
|
2008-07-17 02:28:35 -06:00
|
|
|
static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
|
|
|
|
{
|
|
|
|
u64 start_lba = scmd->request->sector;
|
|
|
|
u64 end_lba = scmd->request->sector + (scsi_bufflen(scmd) / 512);
|
|
|
|
u64 bad_lba;
|
|
|
|
int info_valid;
|
|
|
|
|
|
|
|
if (!blk_fs_request(scmd->request))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
info_valid = scsi_get_sense_info_fld(scmd->sense_buffer,
|
|
|
|
SCSI_SENSE_BUFFERSIZE,
|
|
|
|
&bad_lba);
|
|
|
|
if (!info_valid)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (scsi_bufflen(scmd) <= scmd->device->sector_size)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (scmd->device->sector_size < 512) {
|
|
|
|
/* only legitimate sector_size here is 256 */
|
|
|
|
start_lba <<= 1;
|
|
|
|
end_lba <<= 1;
|
|
|
|
} else {
|
|
|
|
/* be careful ... don't want any overflows */
|
|
|
|
u64 factor = scmd->device->sector_size / 512;
|
|
|
|
do_div(start_lba, factor);
|
|
|
|
do_div(end_lba, factor);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The bad lba was reported incorrectly, we have no idea where
|
|
|
|
* the error is.
|
|
|
|
*/
|
|
|
|
if (bad_lba < start_lba || bad_lba >= end_lba)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* This computation should always be done in terms of
|
|
|
|
* the resolution of the device's medium.
|
|
|
|
*/
|
|
|
|
return (bad_lba - start_lba) * scmd->device->sector_size;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06: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 11:17:12 -07:00
|
|
|
* sd_done - bottom half handler: called when the lower level
|
2005-04-16 16:20:36 -06: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 11:17:12 -07:00
|
|
|
static int sd_done(struct scsi_cmnd *SCpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int result = SCpnt->result;
|
2008-07-17 02:28:35 -06:00
|
|
|
unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct scsi_sense_hdr sshdr;
|
|
|
|
int sense_valid = 0;
|
|
|
|
int sense_deferred = 0;
|
|
|
|
|
|
|
|
if (result) {
|
|
|
|
sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
|
|
|
|
if (sense_valid)
|
|
|
|
sense_deferred = scsi_sense_is_deferred(&sshdr);
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_SCSI_LOGGING
|
2007-02-27 20:41:19 -07:00
|
|
|
SCSI_LOG_HLCOMPLETE(1, scsi_print_result(SCpnt));
|
2005-04-16 16:20:36 -06:00
|
|
|
if (sense_valid) {
|
2007-02-27 20:41:19 -07:00
|
|
|
SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, 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 11:17:12 -07:00
|
|
|
"sd_done: sb[respc,sk,asc,"
|
2007-02-27 20:41:19 -07:00
|
|
|
"ascq]=%x,%x,%x,%x\n",
|
|
|
|
sshdr.response_code,
|
|
|
|
sshdr.sense_key, sshdr.asc,
|
|
|
|
sshdr.ascq));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#endif
|
2006-06-23 10:39:09 -06:00
|
|
|
if (driver_byte(result) != DRIVER_SENSE &&
|
|
|
|
(!sense_valid || sense_deferred))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
switch (sshdr.sense_key) {
|
|
|
|
case HARDWARE_ERROR:
|
|
|
|
case MEDIUM_ERROR:
|
2008-07-17 02:28:35 -06:00
|
|
|
good_bytes = sd_completed_bytes(SCpnt);
|
2006-06-23 10:39:09 -06:00
|
|
|
break;
|
|
|
|
case RECOVERED_ERROR:
|
|
|
|
/* Inform the user, but make sure that it's not treated
|
|
|
|
* as a hard error.
|
|
|
|
*/
|
|
|
|
scsi_print_sense("sd", SCpnt);
|
|
|
|
SCpnt->result = 0;
|
|
|
|
memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
|
2008-07-17 02:28:35 -06:00
|
|
|
good_bytes = scsi_bufflen(SCpnt);
|
|
|
|
break;
|
2008-09-11 19:39:36 -06: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.
|
|
|
|
*/
|
|
|
|
scsi_print_sense("sd", SCpnt);
|
|
|
|
SCpnt->result = 0;
|
|
|
|
memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
|
|
|
|
break;
|
2008-07-17 02:28:35 -06:00
|
|
|
case ABORTED_COMMAND:
|
|
|
|
if (sshdr.asc == 0x10) { /* DIF: Disk detected corruption */
|
|
|
|
scsi_print_result(SCpnt);
|
|
|
|
scsi_print_sense("sd", SCpnt);
|
|
|
|
good_bytes = sd_completed_bytes(SCpnt);
|
|
|
|
}
|
2006-06-23 10:39:09 -06:00
|
|
|
break;
|
|
|
|
case ILLEGAL_REQUEST:
|
2008-07-17 02:28:35 -06:00
|
|
|
if (sshdr.asc == 0x10) { /* DIX: HBA detected corruption */
|
|
|
|
scsi_print_result(SCpnt);
|
|
|
|
scsi_print_sense("sd", SCpnt);
|
|
|
|
good_bytes = sd_completed_bytes(SCpnt);
|
|
|
|
}
|
2006-06-23 10:39:09 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-06-23 10:39:09 -06:00
|
|
|
out:
|
2008-07-17 02:28:35 -06:00
|
|
|
if (rq_data_dir(SCpnt->request) == READ && scsi_prot_sg_count(SCpnt))
|
|
|
|
sd_dif_complete(SCpnt, good_bytes);
|
|
|
|
|
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 11:17:12 -07:00
|
|
|
return good_bytes;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-28 10:33:52 -06:00
|
|
|
static int media_not_present(struct scsi_disk *sdkp,
|
|
|
|
struct scsi_sense_hdr *sshdr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
|
2005-08-28 10:33:52 -06:00
|
|
|
if (!scsi_sense_valid(sshdr))
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
/* not invoked for commands that could return deferred errors */
|
2005-08-28 10:33:52 -06:00
|
|
|
if (sshdr->sense_key != NOT_READY &&
|
|
|
|
sshdr->sense_key != UNIT_ATTENTION)
|
|
|
|
return 0;
|
|
|
|
if (sshdr->asc != 0x3A) /* medium not present */
|
|
|
|
return 0;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
set_media_not_present(sdkp);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* spinup disk - called only in sd_revalidate_disk()
|
|
|
|
*/
|
|
|
|
static void
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_spinup_disk(struct scsi_disk *sdkp)
|
2005-08-28 10:33:52 -06:00
|
|
|
{
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned char cmd[10];
|
2005-07-12 08:45:17 -06:00
|
|
|
unsigned long spintime_expire = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
int retries, spintime;
|
|
|
|
unsigned int the_result;
|
|
|
|
struct scsi_sense_hdr sshdr;
|
|
|
|
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 {
|
|
|
|
cmd[0] = TEST_UNIT_READY;
|
|
|
|
memset((void *) &cmd[1], 0, 9);
|
|
|
|
|
2005-08-28 10:33:52 -06:00
|
|
|
the_result = scsi_execute_req(sdkp->device, cmd,
|
|
|
|
DMA_NONE, NULL, 0,
|
|
|
|
&sshdr, SD_TIMEOUT,
|
|
|
|
SD_MAX_RETRIES);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-10-11 14:48:28 -06:00
|
|
|
/*
|
|
|
|
* If the drive has indicated to us that it
|
|
|
|
* doesn't have any media in it, don't bother
|
|
|
|
* with any more polling.
|
|
|
|
*/
|
|
|
|
if (media_not_present(sdkp, &sshdr))
|
|
|
|
return;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (the_result)
|
2005-08-28 10:33:52 -06:00
|
|
|
sense_valid = scsi_sense_valid(&sshdr);
|
2005-04-16 16:20:36 -06:00
|
|
|
retries++;
|
|
|
|
} while (retries < 3 &&
|
|
|
|
(!scsi_status_is_good(the_result) ||
|
|
|
|
((driver_byte(the_result) & DRIVER_SENSE) &&
|
|
|
|
sense_valid && sshdr.sense_key == UNIT_ATTENTION)));
|
|
|
|
|
|
|
|
if ((driver_byte(the_result) & DRIVER_SENSE) == 0) {
|
|
|
|
/* no sense, TUR either succeeded or failed
|
|
|
|
* with a status error */
|
2007-02-27 20:40:55 -07:00
|
|
|
if(!spintime && !scsi_status_is_good(the_result)) {
|
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
|
|
|
|
sd_print_result(sdkp, the_result);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The device does not want the automatic start to be issued.
|
|
|
|
*/
|
|
|
|
if (sdkp->device->no_start_on_add) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If manual intervention is required, or this is an
|
|
|
|
* absent USB storage device, a spinup is meaningless.
|
|
|
|
*/
|
|
|
|
if (sense_valid &&
|
|
|
|
sshdr.sense_key == NOT_READY &&
|
|
|
|
sshdr.asc == 4 && sshdr.ascq == 3) {
|
|
|
|
break; /* manual intervention required */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Issue command to spin up drive when not ready
|
|
|
|
*/
|
|
|
|
} else if (sense_valid && sshdr.sense_key == NOT_READY) {
|
|
|
|
if (!spintime) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Spinning up disk...");
|
2005-04-16 16:20:36 -06: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 16:34:07 -06:00
|
|
|
if (sdkp->device->start_stop_pwr_cond)
|
|
|
|
cmd[4] |= 1 << 4;
|
2005-08-28 10:33:52 -06:00
|
|
|
scsi_execute_req(sdkp->device, cmd, DMA_NONE,
|
|
|
|
NULL, 0, &sshdr,
|
|
|
|
SD_TIMEOUT, SD_MAX_RETRIES);
|
2005-07-12 08:45:17 -06:00
|
|
|
spintime_expire = jiffies + 100 * HZ;
|
|
|
|
spintime = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
/* Wait 1 second for next try */
|
|
|
|
msleep(1000);
|
|
|
|
printk(".");
|
2005-07-12 08:45:17 -06: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 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/* we don't understand the sense code, so it's
|
|
|
|
* probably pointless to loop */
|
|
|
|
if(!spintime) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
|
|
|
|
sd_print_sense_hdr(sdkp, &sshdr);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-07-12 08:45:17 -06:00
|
|
|
} while (spintime && time_before_eq(jiffies, spintime_expire));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (spintime) {
|
|
|
|
if (scsi_status_is_good(the_result))
|
|
|
|
printk("ready\n");
|
|
|
|
else
|
|
|
|
printk("not responding...\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-17 02:28:34 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine whether disk supports Data Integrity Field.
|
|
|
|
*/
|
|
|
|
void sd_read_protection_type(struct scsi_disk *sdkp, unsigned char *buffer)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
u8 type;
|
|
|
|
|
|
|
|
if (scsi_device_protection(sdp) == 0 || (buffer[12] & 1) == 0)
|
|
|
|
type = 0;
|
|
|
|
else
|
|
|
|
type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 */
|
|
|
|
|
2008-09-19 16:47:20 -06:00
|
|
|
sdkp->protection_type = type;
|
|
|
|
|
2008-07-17 02:28:34 -06:00
|
|
|
switch (type) {
|
|
|
|
case SD_DIF_TYPE0_PROTECTION:
|
|
|
|
case SD_DIF_TYPE1_PROTECTION:
|
|
|
|
case SD_DIF_TYPE3_PROTECTION:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SD_DIF_TYPE2_PROTECTION:
|
|
|
|
sd_printk(KERN_ERR, sdkp, "formatted with DIF Type 2 " \
|
|
|
|
"protection which is currently unsupported. " \
|
|
|
|
"Disabling disk!\n");
|
|
|
|
goto disable;
|
|
|
|
|
|
|
|
default:
|
|
|
|
sd_printk(KERN_ERR, sdkp, "formatted with unknown " \
|
|
|
|
"protection type %d. Disabling disk!\n", type);
|
|
|
|
goto disable;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
disable:
|
|
|
|
sdkp->capacity = 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* read disk capacity
|
|
|
|
*/
|
|
|
|
static void
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer)
|
2005-08-28 10:33:52 -06:00
|
|
|
{
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned char cmd[16];
|
|
|
|
int the_result, retries;
|
|
|
|
int sector_size = 0;
|
2008-07-17 02:28:34 -06:00
|
|
|
/* Force READ CAPACITY(16) when PROTECT=1 */
|
|
|
|
int longrc = scsi_device_protection(sdkp->device) ? 1 : 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct scsi_sense_hdr sshdr;
|
|
|
|
int sense_valid = 0;
|
2005-08-28 10:33:52 -06:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
repeat:
|
|
|
|
retries = 3;
|
|
|
|
do {
|
|
|
|
if (longrc) {
|
|
|
|
memset((void *) cmd, 0, 16);
|
|
|
|
cmd[0] = SERVICE_ACTION_IN;
|
|
|
|
cmd[1] = SAI_READ_CAPACITY_16;
|
2008-07-17 02:28:34 -06:00
|
|
|
cmd[13] = 13;
|
|
|
|
memset((void *) buffer, 0, 13);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
cmd[0] = READ_CAPACITY;
|
|
|
|
memset((void *) &cmd[1], 0, 9);
|
|
|
|
memset((void *) buffer, 0, 8);
|
|
|
|
}
|
|
|
|
|
2005-08-28 10:33:52 -06:00
|
|
|
the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
|
2008-07-17 02:28:34 -06:00
|
|
|
buffer, longrc ? 13 : 8, &sshdr,
|
2005-08-28 10:33:52 -06:00
|
|
|
SD_TIMEOUT, SD_MAX_RETRIES);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-28 10:33:52 -06:00
|
|
|
if (media_not_present(sdkp, &sshdr))
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (the_result)
|
2005-08-28 10:33:52 -06:00
|
|
|
sense_valid = scsi_sense_valid(&sshdr);
|
2005-04-16 16:20:36 -06:00
|
|
|
retries--;
|
|
|
|
|
|
|
|
} while (the_result && retries);
|
|
|
|
|
|
|
|
if (the_result && !longrc) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY failed\n");
|
|
|
|
sd_print_result(sdkp, the_result);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (driver_byte(the_result) & DRIVER_SENSE)
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_print_sense_hdr(sdkp, &sshdr);
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* 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)
|
|
|
|
sdp->changed = 1;
|
|
|
|
|
|
|
|
/* Either no media are present but the drive didn't tell us,
|
|
|
|
or they are present but the read capacity command fails */
|
|
|
|
/* sdkp->media_present = 0; -- not always correct */
|
2006-09-01 07:50:23 -06:00
|
|
|
sdkp->capacity = 0; /* unknown mapped to zero - as usual */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return;
|
|
|
|
} else if (the_result && longrc) {
|
|
|
|
/* READ CAPACITY(16) has been failed */
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY(16) failed\n");
|
|
|
|
sd_print_result(sdkp, the_result);
|
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Use 0xffffffff as device size\n");
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
sdkp->capacity = 1 + (sector_t) 0xffffffff;
|
|
|
|
goto got_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!longrc) {
|
|
|
|
sector_size = (buffer[4] << 24) |
|
|
|
|
(buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
|
|
|
|
if (buffer[0] == 0xff && buffer[1] == 0xff &&
|
|
|
|
buffer[2] == 0xff && buffer[3] == 0xff) {
|
|
|
|
if(sizeof(sdkp->capacity) > 4) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Very big device. "
|
|
|
|
"Trying to use READ CAPACITY(16).\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
longrc = 1;
|
|
|
|
goto repeat;
|
|
|
|
}
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use "
|
|
|
|
"a kernel compiled with support for large "
|
|
|
|
"block devices.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
sdkp->capacity = 0;
|
|
|
|
goto got_data;
|
|
|
|
}
|
|
|
|
sdkp->capacity = 1 + (((sector_t)buffer[0] << 24) |
|
|
|
|
(buffer[1] << 16) |
|
|
|
|
(buffer[2] << 8) |
|
|
|
|
buffer[3]);
|
|
|
|
} else {
|
|
|
|
sdkp->capacity = 1 + (((u64)buffer[0] << 56) |
|
|
|
|
((u64)buffer[1] << 48) |
|
|
|
|
((u64)buffer[2] << 40) |
|
|
|
|
((u64)buffer[3] << 32) |
|
|
|
|
((sector_t)buffer[4] << 24) |
|
|
|
|
((sector_t)buffer[5] << 16) |
|
|
|
|
((sector_t)buffer[6] << 8) |
|
|
|
|
(sector_t)buffer[7]);
|
|
|
|
|
|
|
|
sector_size = (buffer[8] << 24) |
|
|
|
|
(buffer[9] << 16) | (buffer[10] << 8) | buffer[11];
|
2008-07-17 02:28:34 -06:00
|
|
|
|
|
|
|
sd_read_protection_type(sdkp, buffer);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Some devices return the total number of sectors, not the
|
|
|
|
* highest sector number. Make the necessary adjustment. */
|
2007-02-08 01:04:48 -07:00
|
|
|
if (sdp->fix_capacity) {
|
2005-04-16 16:20:36 -06:00
|
|
|
--sdkp->capacity;
|
|
|
|
|
2007-02-08 01:04:48 -07:00
|
|
|
/* Some devices have version which report the correct sizes
|
|
|
|
* and others which do not. We guess size according to a heuristic
|
|
|
|
* and err on the side of lowering the capacity. */
|
|
|
|
} else {
|
|
|
|
if (sdp->guess_capacity)
|
|
|
|
if (sdkp->capacity & 0x01) /* odd sizes are odd */
|
|
|
|
--sdkp->capacity;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
got_data:
|
|
|
|
if (sector_size == 0) {
|
|
|
|
sector_size = 512;
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, "
|
|
|
|
"assuming 512.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sector_size != 512 &&
|
|
|
|
sector_size != 1024 &&
|
|
|
|
sector_size != 2048 &&
|
|
|
|
sector_size != 4096 &&
|
|
|
|
sector_size != 256) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n",
|
|
|
|
sector_size);
|
2005-04-16 16:20:36 -06: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;
|
|
|
|
}
|
2008-08-31 09:41:52 -06:00
|
|
|
blk_queue_hardsect_size(sdp->request_queue, sector_size);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-08-31 09:41:52 -06:00
|
|
|
char cap_str_2[10], cap_str_10[10];
|
2008-10-14 12:34:20 -06:00
|
|
|
u64 sz = (u64)sdkp->capacity << ilog2(sector_size);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-31 09:41:52 -06:00
|
|
|
string_get_size(sz, STRING_UNITS_2, cap_str_2,
|
|
|
|
sizeof(cap_str_2));
|
|
|
|
string_get_size(sz, STRING_UNITS_10, cap_str_10,
|
|
|
|
sizeof(cap_str_10));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp,
|
2008-08-31 09:41:52 -06:00
|
|
|
"%llu %d-byte hardware sectors: (%s/%s)\n",
|
2007-02-27 20:40:55 -07:00
|
|
|
(unsigned long long)sdkp->capacity,
|
2008-08-31 09:41:52 -06:00
|
|
|
sector_size, cap_str_10, cap_str_2);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Rescale capacity to 512-byte units */
|
|
|
|
if (sector_size == 4096)
|
|
|
|
sdkp->capacity <<= 3;
|
|
|
|
else if (sector_size == 2048)
|
|
|
|
sdkp->capacity <<= 2;
|
|
|
|
else if (sector_size == 1024)
|
|
|
|
sdkp->capacity <<= 1;
|
|
|
|
else if (sector_size == 256)
|
|
|
|
sdkp->capacity >>= 1;
|
|
|
|
|
|
|
|
sdkp->device->sector_size = sector_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* called with buffer of length 512 */
|
|
|
|
static inline int
|
2005-08-28 10:33:52 -06:00
|
|
|
sd_do_mode_sense(struct scsi_device *sdp, int dbd, int modepage,
|
|
|
|
unsigned char *buffer, int len, struct scsi_mode_data *data,
|
|
|
|
struct scsi_sense_hdr *sshdr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-28 10:33:52 -06:00
|
|
|
return scsi_mode_sense(sdp, dbd, modepage, buffer, len,
|
2005-08-28 10:27:01 -06:00
|
|
|
SD_TIMEOUT, SD_MAX_RETRIES, data,
|
2005-08-28 10:33:52 -06:00
|
|
|
sshdr);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* read write protect setting, if possible - called only in sd_revalidate_disk()
|
2006-02-26 07:34:10 -07:00
|
|
|
* called with buffer of length SD_BUF_SIZE
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static void
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer)
|
2005-08-28 10:33:52 -06:00
|
|
|
{
|
2005-04-16 16:20:36 -06:00
|
|
|
int res;
|
2005-08-28 10:33:52 -06:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct scsi_mode_data data;
|
|
|
|
|
|
|
|
set_disk_ro(sdkp->disk, 0);
|
2005-08-28 10:33:52 -06:00
|
|
|
if (sdp->skip_ms_page_3f) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Assuming Write Enabled\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-08-28 10:33:52 -06:00
|
|
|
if (sdp->use_192_bytes_for_3f) {
|
|
|
|
res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 192, &data, NULL);
|
2005-04-16 16:20:36 -06: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.
|
|
|
|
*/
|
2005-08-28 10:33:52 -06:00
|
|
|
res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 4, &data, NULL);
|
2005-04-16 16:20:36 -06: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.
|
|
|
|
*/
|
|
|
|
if (!scsi_status_is_good(res))
|
2005-08-28 10:33:52 -06:00
|
|
|
res = sd_do_mode_sense(sdp, 0, 0, buffer, 4, &data, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Third attempt: ask 255 bytes, as we did earlier.
|
|
|
|
*/
|
|
|
|
if (!scsi_status_is_good(res))
|
2005-08-28 10:33:52 -06:00
|
|
|
res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 255,
|
|
|
|
&data, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!scsi_status_is_good(res)) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_WARNING, sdkp,
|
|
|
|
"Test WP failed, assume Write Enabled\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
sdkp->write_prot = ((data.device_specific & 0x80) != 0);
|
|
|
|
set_disk_ro(sdkp->disk, sdkp->write_prot);
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n",
|
|
|
|
sdkp->write_prot ? "on" : "off");
|
|
|
|
sd_printk(KERN_DEBUG, sdkp,
|
|
|
|
"Mode Sense: %02x %02x %02x %02x\n",
|
|
|
|
buffer[0], buffer[1], buffer[2], buffer[3]);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* sd_read_cache_type - called only from sd_revalidate_disk()
|
2006-02-26 07:34:10 -07:00
|
|
|
* called with buffer of length SD_BUF_SIZE
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static void
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
|
2005-05-15 18:59:55 -06:00
|
|
|
{
|
2005-04-16 16:20:36 -06:00
|
|
|
int len = 0, res;
|
2005-08-28 10:33:52 -06:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-05-15 18:59:55 -06:00
|
|
|
int dbd;
|
|
|
|
int modepage;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct scsi_mode_data data;
|
|
|
|
struct scsi_sense_hdr sshdr;
|
|
|
|
|
2005-08-28 10:33:52 -06:00
|
|
|
if (sdp->skip_ms_page_8)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto defaults;
|
|
|
|
|
2005-08-28 10:33:52 -06:00
|
|
|
if (sdp->type == TYPE_RBC) {
|
2005-05-15 18:59:55 -06:00
|
|
|
modepage = 6;
|
|
|
|
dbd = 8;
|
|
|
|
} else {
|
|
|
|
modepage = 8;
|
|
|
|
dbd = 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* cautiously ask */
|
2005-08-28 10:33:52 -06:00
|
|
|
res = sd_do_mode_sense(sdp, dbd, modepage, buffer, 4, &data, &sshdr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!scsi_status_is_good(res))
|
|
|
|
goto bad_sense;
|
|
|
|
|
2006-02-22 18:03:16 -07:00
|
|
|
if (!data.header_length) {
|
|
|
|
modepage = 6;
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_ERR, sdkp, "Missing header in MODE_SENSE response\n");
|
2006-02-22 18:03:16 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06: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;
|
|
|
|
if (len > 20)
|
|
|
|
len = 20;
|
|
|
|
|
|
|
|
/* Take headers and block descriptors into account */
|
|
|
|
len += data.header_length + data.block_descriptor_length;
|
2006-02-26 07:34:10 -07:00
|
|
|
if (len > SD_BUF_SIZE)
|
|
|
|
goto bad_sense;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Get the data */
|
2005-08-28 10:33:52 -06:00
|
|
|
res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len, &data, &sshdr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (scsi_status_is_good(res)) {
|
2005-05-15 18:59:55 -06:00
|
|
|
int offset = data.header_length + data.block_descriptor_length;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-02-26 07:34:10 -07:00
|
|
|
if (offset >= SD_BUF_SIZE - 2) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_ERR, sdkp, "Malformed MODE SENSE response\n");
|
2006-02-26 07:34:10 -07:00
|
|
|
goto defaults;
|
|
|
|
}
|
|
|
|
|
2005-05-15 18:59:55 -06:00
|
|
|
if ((buffer[offset] & 0x3f) != modepage) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_ERR, sdkp, "Got wrong page\n");
|
2005-05-15 18:59:55 -06:00
|
|
|
goto defaults;
|
|
|
|
}
|
|
|
|
|
|
|
|
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 16:20:36 -06:00
|
|
|
|
2006-01-06 01:53:52 -07:00
|
|
|
sdkp->DPOFUA = (data.device_specific & 0x10) != 0;
|
|
|
|
if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp,
|
|
|
|
"Uses READ/WRITE(6), disabling FUA\n");
|
2006-01-06 01:53:52 -07:00
|
|
|
sdkp->DPOFUA = 0;
|
|
|
|
}
|
|
|
|
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp,
|
|
|
|
"Write cache: %s, read cache: %s, %s\n",
|
2006-11-15 13:47:08 -07:00
|
|
|
sdkp->WCE ? "enabled" : "disabled",
|
|
|
|
sdkp->RCD ? "disabled" : "enabled",
|
|
|
|
sdkp->DPOFUA ? "supports DPO and FUA"
|
|
|
|
: "doesn't support DPO or FUA");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
bad_sense:
|
2005-08-28 10:33:52 -06:00
|
|
|
if (scsi_sense_valid(&sshdr) &&
|
2005-04-16 16:20:36 -06:00
|
|
|
sshdr.sense_key == ILLEGAL_REQUEST &&
|
|
|
|
sshdr.asc == 0x24 && sshdr.ascq == 0x0)
|
2007-02-27 20:40:55 -07:00
|
|
|
/* Invalid field in CDB */
|
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_ERR, sdkp, "Asking for cache data failed\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
defaults:
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_ERR, sdkp, "Assuming drive cache: write through\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
sdkp->WCE = 0;
|
|
|
|
sdkp->RCD = 0;
|
2006-02-26 07:34:10 -07:00
|
|
|
sdkp->DPOFUA = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-07-17 02:28:34 -06:00
|
|
|
/*
|
|
|
|
* The ATO bit indicates whether the DIF application tag is available
|
|
|
|
* for use by the operating system.
|
|
|
|
*/
|
|
|
|
void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer)
|
|
|
|
{
|
|
|
|
int res, offset;
|
|
|
|
struct scsi_device *sdp = sdkp->device;
|
|
|
|
struct scsi_mode_data data;
|
|
|
|
struct scsi_sense_hdr sshdr;
|
|
|
|
|
|
|
|
if (sdp->type != TYPE_DISK)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (sdkp->protection_type == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
res = scsi_mode_sense(sdp, 1, 0x0a, buffer, 36, SD_TIMEOUT,
|
|
|
|
SD_MAX_RETRIES, &data, &sshdr);
|
|
|
|
|
|
|
|
if (!scsi_status_is_good(res) || !data.header_length ||
|
|
|
|
data.length < 6) {
|
|
|
|
sd_printk(KERN_WARNING, sdkp,
|
|
|
|
"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) {
|
|
|
|
sd_printk(KERN_ERR, sdkp, "ATO Got wrong page\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((buffer[offset + 5] & 0x80) == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sdkp->ATO = 1;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06: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;
|
|
|
|
unsigned char *buffer;
|
2006-01-06 01:52:55 -07:00
|
|
|
unsigned ordered;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-27 20:41:19 -07:00
|
|
|
SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp,
|
|
|
|
"sd_revalidate_disk\n"));
|
2005-04-16 16:20:36 -06: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 09:15:26 -06:00
|
|
|
buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!buffer) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_WARNING, sdkp, "sd_revalidate_disk: Memory "
|
|
|
|
"allocation failure.\n");
|
2005-08-28 10:33:52 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* defaults, until the device tells us otherwise */
|
|
|
|
sdp->sector_size = 512;
|
|
|
|
sdkp->capacity = 0;
|
|
|
|
sdkp->media_present = 1;
|
|
|
|
sdkp->write_prot = 0;
|
|
|
|
sdkp->WCE = 0;
|
|
|
|
sdkp->RCD = 0;
|
2008-07-17 02:28:34 -06:00
|
|
|
sdkp->ATO = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_spinup_disk(sdkp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Without media there is no reason to ask; moreover, some devices
|
|
|
|
* react badly if we do.
|
|
|
|
*/
|
|
|
|
if (sdkp->media_present) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_read_capacity(sdkp, buffer);
|
|
|
|
sd_read_write_protect_flag(sdkp, buffer);
|
|
|
|
sd_read_cache_type(sdkp, buffer);
|
2008-07-17 02:28:34 -06:00
|
|
|
sd_read_app_tag_own(sdkp, buffer);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-01-06 01:52:55 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We now have all cache related info, determine how we deal
|
|
|
|
* with ordered requests. Note that as the current SCSI
|
|
|
|
* dispatch function can alter request order, we cannot use
|
|
|
|
* QUEUE_ORDERED_TAG_* even when ordered tag is supported.
|
|
|
|
*/
|
|
|
|
if (sdkp->WCE)
|
2006-01-06 01:53:52 -07:00
|
|
|
ordered = sdkp->DPOFUA
|
|
|
|
? QUEUE_ORDERED_DRAIN_FUA : QUEUE_ORDERED_DRAIN_FLUSH;
|
2006-01-06 01:52:55 -07:00
|
|
|
else
|
|
|
|
ordered = QUEUE_ORDERED_DRAIN;
|
|
|
|
|
|
|
|
blk_queue_ordered(sdkp->disk->queue, ordered, sd_prepare_flush);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
set_capacity(disk, sdkp->capacity);
|
|
|
|
kfree(buffer);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-25 04:56:17 -06: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
|
|
|
|
* at the beggining from the second digit on and can be
|
|
|
|
* 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 16:20:36 -06: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.
|
|
|
|
*
|
|
|
|
* Assume sd_attach is not re-entrant (for time being)
|
|
|
|
* Also think about sd_attach() and sd_remove() running coincidentally.
|
|
|
|
**/
|
|
|
|
static int sd_probe(struct device *dev)
|
|
|
|
{
|
|
|
|
struct scsi_device *sdp = to_scsi_device(dev);
|
|
|
|
struct scsi_disk *sdkp;
|
|
|
|
struct gendisk *gd;
|
|
|
|
u32 index;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = -ENODEV;
|
2005-05-15 18:59:55 -06:00
|
|
|
if (sdp->type != TYPE_DISK && sdp->type != TYPE_MOD && sdp->type != TYPE_RBC)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
|
2005-10-02 10:45:08 -06:00
|
|
|
SCSI_LOG_HLQUEUE(3, sdev_printk(KERN_INFO, sdp,
|
|
|
|
"sd_attach\n"));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
error = -ENOMEM;
|
2006-01-16 08:31:18 -07:00
|
|
|
sdkp = kzalloc(sizeof(*sdkp), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!sdkp)
|
|
|
|
goto out;
|
|
|
|
|
2008-08-25 04:56:16 -06:00
|
|
|
gd = alloc_disk(SD_MINORS);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!gd)
|
|
|
|
goto out_free;
|
|
|
|
|
2008-07-13 23:59:30 -06:00
|
|
|
do {
|
|
|
|
if (!ida_pre_get(&sd_index_ida, GFP_KERNEL))
|
|
|
|
goto out_put;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-13 23:59:30 -06:00
|
|
|
error = ida_get_new(&sd_index_ida, &index);
|
|
|
|
} while (error == -EAGAIN);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (error)
|
|
|
|
goto out_put;
|
|
|
|
|
2008-08-25 04:56:17 -06:00
|
|
|
error = sd_format_disk_name("sd", index, gd->disk_name, DISK_NAME_LEN);
|
|
|
|
if (error)
|
2008-07-13 23:59:30 -06:00
|
|
|
goto out_free_index;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
sdkp->device = sdp;
|
|
|
|
sdkp->driver = &sd_template;
|
|
|
|
sdkp->disk = gd;
|
|
|
|
sdkp->index = index;
|
|
|
|
sdkp->openers = 0;
|
2008-03-19 06:09:56 -06:00
|
|
|
sdkp->previous_state = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-09-14 06:55:09 -06:00
|
|
|
if (!sdp->request_queue->rq_timeout) {
|
2005-05-15 18:59:55 -06:00
|
|
|
if (sdp->type != TYPE_MOD)
|
2008-09-14 06:55:09 -06:00
|
|
|
blk_queue_rq_timeout(sdp->request_queue, SD_TIMEOUT);
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2008-09-14 06:55:09 -06:00
|
|
|
blk_queue_rq_timeout(sdp->request_queue,
|
|
|
|
SD_MOD_TIMEOUT);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
device_initialize(&sdkp->dev);
|
|
|
|
sdkp->dev.parent = &sdp->sdev_gendev;
|
|
|
|
sdkp->dev.class = &sd_disk_class;
|
|
|
|
strncpy(sdkp->dev.bus_id, sdp->sdev_gendev.bus_id, BUS_ID_SIZE);
|
2007-02-02 05:04:56 -07:00
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
if (device_add(&sdkp->dev))
|
2008-07-13 23:59:30 -06:00
|
|
|
goto out_free_index;
|
2007-02-02 05:04:56 -07:00
|
|
|
|
|
|
|
get_device(&sdp->sdev_gendev);
|
|
|
|
|
2008-08-25 04:56:17 -06:00
|
|
|
if (index < SD_MAX_DISKS) {
|
|
|
|
gd->major = sd_major((index & 0xf0) >> 4);
|
|
|
|
gd->first_minor = ((index & 0xf) << 4) | (index & 0xfff00);
|
|
|
|
gd->minors = SD_MINORS;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-08-25 04:56:17 -06:00
|
|
|
gd->fops = &sd_fops;
|
2005-04-16 16:20:36 -06:00
|
|
|
gd->private_data = &sdkp->driver;
|
2006-01-06 01:52:55 -07:00
|
|
|
gd->queue = sdkp->device->request_queue;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
sd_revalidate_disk(gd);
|
|
|
|
|
2007-08-04 09:06:25 -06:00
|
|
|
blk_queue_prep_rq(sdp->request_queue, sd_prep_fn);
|
2007-08-03 15:41:11 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
gd->driverfs_dev = &sdp->sdev_gendev;
|
2008-08-25 04:56:16 -06:00
|
|
|
gd->flags = GENHD_FL_EXT_DEVT | GENHD_FL_DRIVERFS;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (sdp->removable)
|
|
|
|
gd->flags |= GENHD_FL_REMOVABLE;
|
|
|
|
|
|
|
|
dev_set_drvdata(dev, sdkp);
|
|
|
|
add_disk(gd);
|
2008-07-17 02:28:35 -06:00
|
|
|
sd_dif_config_host(sdkp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
|
|
|
|
sdp->removable ? "removable " : "");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2008-07-13 23:59:30 -06:00
|
|
|
out_free_index:
|
|
|
|
ida_remove(&sd_index_ida, index);
|
2006-03-18 13:14:21 -07:00
|
|
|
out_put:
|
2005-04-16 16:20:36 -06:00
|
|
|
put_disk(gd);
|
2006-03-18 13:14:21 -07:00
|
|
|
out_free:
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(sdkp);
|
2006-03-18 13:14:21 -07:00
|
|
|
out:
|
2005-04-16 16:20:36 -06: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.
|
|
|
|
* @sdp: pointer to mid level scsi device object
|
|
|
|
*
|
|
|
|
* 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)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = dev_get_drvdata(dev);
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
device_del(&sdkp->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
del_gendisk(sdkp->disk);
|
|
|
|
sd_shutdown(dev);
|
2005-11-04 12:44:41 -07:00
|
|
|
|
2006-01-11 05:16:10 -07:00
|
|
|
mutex_lock(&sd_ref_mutex);
|
2005-11-04 12:44:41 -07:00
|
|
|
dev_set_drvdata(dev, NULL);
|
2008-02-21 16:13:36 -07:00
|
|
|
put_device(&sdkp->dev);
|
2006-01-11 05:16:10 -07:00
|
|
|
mutex_unlock(&sd_ref_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* scsi_disk_release - Called to free the scsi_disk structure
|
2008-02-21 16:13:36 -07:00
|
|
|
* @dev: pointer to embedded class device
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2006-01-11 05:16:10 -07:00
|
|
|
* sd_ref_mutex must be held entering this routine. Because it is
|
2005-04-16 16:20:36 -06:00
|
|
|
* called on last put, you should always use the scsi_disk_get()
|
|
|
|
* scsi_disk_put() helpers which manipulate the semaphore directly
|
2008-02-21 16:13:36 -07:00
|
|
|
* and never do a direct put_device.
|
2005-04-16 16:20:36 -06:00
|
|
|
**/
|
2008-02-21 16:13:36 -07:00
|
|
|
static void scsi_disk_release(struct device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
struct scsi_disk *sdkp = to_scsi_disk(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct gendisk *disk = sdkp->disk;
|
|
|
|
|
2008-07-13 23:59:30 -06:00
|
|
|
ida_remove(&sd_index_ida, sdkp->index);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
disk->private_data = NULL;
|
|
|
|
put_disk(disk);
|
2005-11-04 12:44:41 -07:00
|
|
|
put_device(&sdkp->device->sdev_gendev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
kfree(sdkp);
|
|
|
|
}
|
|
|
|
|
2007-03-20 11:26:03 -06:00
|
|
|
static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
|
2007-03-20 09:13:59 -06:00
|
|
|
{
|
|
|
|
unsigned char cmd[6] = { START_STOP }; /* START_VALID */
|
|
|
|
struct scsi_sense_hdr sshdr;
|
2007-03-20 11:26:03 -06:00
|
|
|
struct scsi_device *sdp = sdkp->device;
|
2007-03-20 09:13:59 -06:00
|
|
|
int res;
|
|
|
|
|
|
|
|
if (start)
|
|
|
|
cmd[4] |= 1; /* START */
|
|
|
|
|
2008-05-10 16:34:07 -06:00
|
|
|
if (sdp->start_stop_pwr_cond)
|
|
|
|
cmd[4] |= start ? 1 << 4 : 3 << 4; /* Active or Standby */
|
|
|
|
|
2007-03-20 09:13:59 -06:00
|
|
|
if (!scsi_device_online(sdp))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
|
|
|
|
SD_TIMEOUT, SD_MAX_RETRIES);
|
|
|
|
if (res) {
|
2007-03-20 11:26:03 -06:00
|
|
|
sd_printk(KERN_WARNING, sdkp, "START_STOP FAILED\n");
|
|
|
|
sd_print_result(sdkp, res);
|
2007-03-20 09:13:59 -06:00
|
|
|
if (driver_byte(res) & DRIVER_SENSE)
|
2007-03-20 11:26:03 -06:00
|
|
|
sd_print_sense_hdr(sdkp, &sshdr);
|
2007-03-20 09:13:59 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06: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)
|
|
|
|
{
|
2005-11-04 12:44:41 -07:00
|
|
|
struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!sdkp)
|
|
|
|
return; /* this can happen */
|
|
|
|
|
2005-11-04 12:44:41 -07:00
|
|
|
if (sdkp->WCE) {
|
2007-02-27 20:40:55 -07:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
|
|
|
|
sd_sync_cache(sdkp);
|
2005-11-04 12:44:41 -07:00
|
|
|
}
|
2007-03-20 09:13:59 -06:00
|
|
|
|
2007-03-20 11:26:03 -06: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 09:13:59 -06:00
|
|
|
}
|
|
|
|
|
2005-11-04 12:44:41 -07:00
|
|
|
scsi_disk_put(sdkp);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-03-20 09:13:59 -06:00
|
|
|
static int sd_suspend(struct device *dev, pm_message_t mesg)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
|
2007-05-21 07:55:04 -06:00
|
|
|
int ret = 0;
|
2007-03-20 09:13:59 -06:00
|
|
|
|
|
|
|
if (!sdkp)
|
|
|
|
return 0; /* this can happen */
|
|
|
|
|
|
|
|
if (sdkp->WCE) {
|
2007-03-20 11:26:03 -06:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
|
2007-03-20 09:13:59 -06:00
|
|
|
ret = sd_sync_cache(sdkp);
|
|
|
|
if (ret)
|
2007-05-21 07:55:04 -06:00
|
|
|
goto done;
|
2007-03-20 09:13:59 -06:00
|
|
|
}
|
|
|
|
|
2008-02-23 11:13:25 -07:00
|
|
|
if ((mesg.event & PM_EVENT_SLEEP) && sdkp->device->manage_start_stop) {
|
2007-03-20 11:26:03 -06:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
|
|
|
|
ret = sd_start_stop_device(sdkp, 0);
|
2007-03-20 09:13:59 -06:00
|
|
|
}
|
|
|
|
|
2007-05-21 07:55:04 -06:00
|
|
|
done:
|
|
|
|
scsi_disk_put(sdkp);
|
|
|
|
return ret;
|
2007-03-20 09:13:59 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int sd_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
|
2007-05-21 07:55:04 -06:00
|
|
|
int ret = 0;
|
2007-03-20 09:13:59 -06:00
|
|
|
|
2007-03-20 11:26:03 -06:00
|
|
|
if (!sdkp->device->manage_start_stop)
|
2007-05-21 07:55:04 -06:00
|
|
|
goto done;
|
2007-03-20 09:13:59 -06:00
|
|
|
|
2007-03-20 11:26:03 -06:00
|
|
|
sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
|
2007-05-21 07:55:04 -06:00
|
|
|
ret = sd_start_stop_device(sdkp, 1);
|
2007-03-20 09:13:59 -06:00
|
|
|
|
2007-05-21 07:55:04 -06:00
|
|
|
done:
|
|
|
|
scsi_disk_put(sdkp);
|
|
|
|
return ret;
|
2007-03-20 09:13:59 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06: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 03:32:54 -06:00
|
|
|
int majors = 0, i, err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n"));
|
|
|
|
|
|
|
|
for (i = 0; i < SD_MAJORS; i++)
|
|
|
|
if (register_blkdev(sd_major(i), "sd") == 0)
|
|
|
|
majors++;
|
|
|
|
|
|
|
|
if (!majors)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2006-10-04 03:32:54 -06:00
|
|
|
err = class_register(&sd_disk_class);
|
|
|
|
if (err)
|
|
|
|
goto err_out;
|
2006-03-18 13:14:21 -07:00
|
|
|
|
2006-10-04 03:32:54 -06:00
|
|
|
err = scsi_register_driver(&sd_template.gendrv);
|
|
|
|
if (err)
|
|
|
|
goto err_out_class;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
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 16:20:36 -06: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"));
|
|
|
|
|
|
|
|
scsi_unregister_driver(&sd_template.gendrv);
|
2006-10-04 03:32:54 -06:00
|
|
|
class_unregister(&sd_disk_class);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
for (i = 0; i < SD_MAJORS; i++)
|
|
|
|
unregister_blkdev(sd_major(i), "sd");
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(init_sd);
|
|
|
|
module_exit(exit_sd);
|
2007-02-27 20:40:55 -07:00
|
|
|
|
|
|
|
static void sd_print_sense_hdr(struct scsi_disk *sdkp,
|
|
|
|
struct scsi_sense_hdr *sshdr)
|
|
|
|
{
|
|
|
|
sd_printk(KERN_INFO, sdkp, "");
|
|
|
|
scsi_show_sense_hdr(sshdr);
|
|
|
|
sd_printk(KERN_INFO, sdkp, "");
|
|
|
|
scsi_show_extd_sense(sshdr->asc, sshdr->ascq);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sd_print_result(struct scsi_disk *sdkp, int result)
|
|
|
|
{
|
|
|
|
sd_printk(KERN_INFO, sdkp, "");
|
|
|
|
scsi_show_result(result);
|
|
|
|
}
|
|
|
|
|