2005-04-16 16:20:36 -06:00
|
|
|
|
/*
|
|
|
|
|
SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
|
|
|
|
|
file Documentation/scsi/st.txt for more information.
|
|
|
|
|
|
|
|
|
|
History:
|
|
|
|
|
|
|
|
|
|
OnStream SCSI Tape support (osst) cloned from st.c by
|
|
|
|
|
Willem Riede (osst@riede.org) Feb 2000
|
|
|
|
|
Fixes ... Kurt Garloff <garloff@suse.de> Mar 2000
|
|
|
|
|
|
|
|
|
|
Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.
|
|
|
|
|
Contribution and ideas from several people including (in alphabetical
|
|
|
|
|
order) Klaus Ehrenfried, Wolfgang Denk, Steve Hirsch, Andreas Koppenh"ofer,
|
|
|
|
|
Michael Leodolter, Eyal Lebedinsky, J"org Weule, and Eric Youngdale.
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
Copyright 1992 - 2002 Kai Makisara / 2000 - 2006 Willem Riede
|
2005-04-16 16:20:36 -06:00
|
|
|
|
email osst@riede.org
|
|
|
|
|
|
|
|
|
|
$Header: /cvsroot/osst/Driver/osst.c,v 1.73 2005/01/01 21:13:34 wriede Exp $
|
|
|
|
|
|
|
|
|
|
Microscopic alterations - Rik Ling, 2000/12/21
|
|
|
|
|
Last st.c sync: Tue Oct 15 22:01:04 2002 by makisara
|
|
|
|
|
Some small formal changes - aeb, 950809
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static const char * cvsid = "$Id: osst.c,v 1.73 2005/01/01 21:13:34 wriede Exp $";
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static const char * osst_version = "0.99.4";
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
/* The "failure to reconnect" firmware bug */
|
|
|
|
|
#define OSST_FW_NEED_POLL_MIN 10601 /*(107A)*/
|
|
|
|
|
#define OSST_FW_NEED_POLL_MAX 10704 /*(108D)*/
|
|
|
|
|
#define OSST_FW_NEED_POLL(x,d) ((x) >= OSST_FW_NEED_POLL_MIN && (x) <= OSST_FW_NEED_POLL_MAX && d->host->this_id != 7)
|
|
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
|
|
|
|
|
#include <linux/fs.h>
|
|
|
|
|
#include <linux/kernel.h>
|
2017-02-02 11:15:33 -07:00
|
|
|
|
#include <linux/sched/signal.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
|
#include <linux/mm.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/string.h>
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <linux/mtio.h>
|
|
|
|
|
#include <linux/ioctl.h>
|
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
|
#include <linux/vmalloc.h>
|
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
|
#include <linux/delay.h>
|
2006-03-28 02:56:47 -07:00
|
|
|
|
#include <linux/jiffies.h>
|
2010-06-02 06:28:52 -06:00
|
|
|
|
#include <linux/mutex.h>
|
2016-12-24 12:46:01 -07:00
|
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#include <asm/dma.h>
|
|
|
|
|
|
|
|
|
|
/* The driver prints some debugging information on the console if DEBUG
|
|
|
|
|
is defined and non-zero. */
|
|
|
|
|
#define DEBUG 0
|
|
|
|
|
|
|
|
|
|
/* The message level for the debug messages is currently set to KERN_NOTICE
|
|
|
|
|
so that people can easily see the messages. Later when the debugging messages
|
|
|
|
|
in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
|
|
|
|
|
#define OSST_DEB_MSG KERN_NOTICE
|
|
|
|
|
|
|
|
|
|
#include <scsi/scsi.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>
|
|
|
|
|
|
|
|
|
|
#define ST_KILOBYTE 1024
|
|
|
|
|
|
|
|
|
|
#include "st.h"
|
|
|
|
|
#include "osst.h"
|
|
|
|
|
#include "osst_options.h"
|
|
|
|
|
#include "osst_detect.h"
|
|
|
|
|
|
2010-06-02 06:28:52 -06:00
|
|
|
|
static DEFINE_MUTEX(osst_int_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
static int max_dev = 0;
|
|
|
|
|
static int write_threshold_kbs = 0;
|
|
|
|
|
static int max_sg_segs = 0;
|
|
|
|
|
|
|
|
|
|
#ifdef MODULE
|
|
|
|
|
MODULE_AUTHOR("Willem Riede");
|
|
|
|
|
MODULE_DESCRIPTION("OnStream {DI-|FW-|SC-|USB}{30|50} Tape Driver");
|
|
|
|
|
MODULE_LICENSE("GPL");
|
2006-03-08 01:14:20 -07:00
|
|
|
|
MODULE_ALIAS_CHARDEV_MAJOR(OSST_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_TAPE);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
module_param(max_dev, int, 0444);
|
|
|
|
|
MODULE_PARM_DESC(max_dev, "Maximum number of OnStream Tape Drives to attach (4)");
|
|
|
|
|
|
|
|
|
|
module_param(write_threshold_kbs, int, 0644);
|
|
|
|
|
MODULE_PARM_DESC(write_threshold_kbs, "Asynchronous write threshold (KB; 32)");
|
|
|
|
|
|
|
|
|
|
module_param(max_sg_segs, int, 0644);
|
|
|
|
|
MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (9)");
|
|
|
|
|
#else
|
|
|
|
|
static struct osst_dev_parm {
|
|
|
|
|
char *name;
|
|
|
|
|
int *val;
|
|
|
|
|
} parms[] __initdata = {
|
|
|
|
|
{ "max_dev", &max_dev },
|
|
|
|
|
{ "write_threshold_kbs", &write_threshold_kbs },
|
|
|
|
|
{ "max_sg_segs", &max_sg_segs }
|
|
|
|
|
};
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Some default definitions have been moved to osst_options.h */
|
|
|
|
|
#define OSST_BUFFER_SIZE (OSST_BUFFER_BLOCKS * ST_KILOBYTE)
|
|
|
|
|
#define OSST_WRITE_THRESHOLD (OSST_WRITE_THRESHOLD_BLOCKS * ST_KILOBYTE)
|
|
|
|
|
|
|
|
|
|
/* The buffer size should fit into the 24 bits for length in the
|
|
|
|
|
6-byte SCSI read and write commands. */
|
|
|
|
|
#if OSST_BUFFER_SIZE >= (2 << 24 - 1)
|
|
|
|
|
#error "Buffer size should not exceed (2 << 24 - 1) bytes!"
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
static int debugging = 1;
|
|
|
|
|
/* uncomment define below to test error recovery */
|
|
|
|
|
// #define OSST_INJECT_ERRORS 1
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Do not retry! The drive firmware already retries when appropriate,
|
|
|
|
|
and when it tries to tell us something, we had better listen... */
|
|
|
|
|
#define MAX_RETRIES 0
|
|
|
|
|
|
|
|
|
|
#define NO_TAPE NOT_READY
|
|
|
|
|
|
|
|
|
|
#define OSST_WAIT_POSITION_COMPLETE (HZ > 200 ? HZ / 200 : 1)
|
|
|
|
|
#define OSST_WAIT_WRITE_COMPLETE (HZ / 12)
|
|
|
|
|
#define OSST_WAIT_LONG_WRITE_COMPLETE (HZ / 2)
|
|
|
|
|
|
|
|
|
|
#define OSST_TIMEOUT (200 * HZ)
|
|
|
|
|
#define OSST_LONG_TIMEOUT (1800 * HZ)
|
|
|
|
|
|
|
|
|
|
#define TAPE_NR(x) (iminor(x) & ~(-1 << ST_MODE_SHIFT))
|
|
|
|
|
#define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
|
|
|
|
|
#define TAPE_REWIND(x) ((iminor(x) & 0x80) == 0)
|
|
|
|
|
#define TAPE_IS_RAW(x) (TAPE_MODE(x) & (ST_NBR_MODES >> 1))
|
|
|
|
|
|
|
|
|
|
/* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
|
|
|
|
|
24 bits) */
|
|
|
|
|
#define SET_DENS_AND_BLK 0x10001
|
|
|
|
|
|
|
|
|
|
static int osst_buffer_size = OSST_BUFFER_SIZE;
|
|
|
|
|
static int osst_write_threshold = OSST_WRITE_THRESHOLD;
|
|
|
|
|
static int osst_max_sg_segs = OSST_MAX_SG;
|
|
|
|
|
static int osst_max_dev = OSST_MAX_TAPES;
|
|
|
|
|
static int osst_nr_dev;
|
|
|
|
|
|
|
|
|
|
static struct osst_tape **os_scsi_tapes = NULL;
|
|
|
|
|
static DEFINE_RWLOCK(os_scsi_tapes_lock);
|
|
|
|
|
|
|
|
|
|
static int modes_defined = 0;
|
|
|
|
|
|
|
|
|
|
static struct osst_buffer *new_tape_buffer(int, int, int);
|
|
|
|
|
static int enlarge_buffer(struct osst_buffer *, int);
|
|
|
|
|
static void normalize_buffer(struct osst_buffer *);
|
|
|
|
|
static int append_to_buffer(const char __user *, struct osst_buffer *, int);
|
|
|
|
|
static int from_buffer(struct osst_buffer *, char __user *, int);
|
|
|
|
|
static int osst_zero_buffer_tail(struct osst_buffer *);
|
|
|
|
|
static int osst_copy_to_buffer(struct osst_buffer *, unsigned char *);
|
|
|
|
|
static int osst_copy_from_buffer(struct osst_buffer *, unsigned char *);
|
|
|
|
|
|
|
|
|
|
static int osst_probe(struct device *);
|
|
|
|
|
static int osst_remove(struct device *);
|
|
|
|
|
|
|
|
|
|
static struct scsi_driver osst_template = {
|
|
|
|
|
.gendrv = {
|
|
|
|
|
.name = "osst",
|
2014-11-12 10:34:51 -07:00
|
|
|
|
.owner = THIS_MODULE,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
.probe = osst_probe,
|
|
|
|
|
.remove = osst_remove,
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_int_ioctl(struct osst_tape *STp, struct osst_request ** aSRpnt,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned int cmd_in, unsigned long arg);
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_set_frame_position(struct osst_tape *STp, struct osst_request ** aSRpnt, int frame, int skip);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_get_frame_position(struct osst_tape *STp, struct osst_request ** aSRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_flush_write_buffer(struct osst_tape *STp, struct osst_request ** aSRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_write_error_recovery(struct osst_tape * STp, struct osst_request ** aSRpnt, int pending);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
static inline char *tape_name(struct osst_tape *tape)
|
|
|
|
|
{
|
|
|
|
|
return tape->drive->disk_name;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Routines that handle the interaction with mid-layer SCSI routines */
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
|
|
|
|
|
/* Normalize Sense */
|
|
|
|
|
static void osst_analyze_sense(struct osst_request *SRpnt, struct st_cmdstatus *s)
|
|
|
|
|
{
|
|
|
|
|
const u8 *ucp;
|
|
|
|
|
const u8 *sense = SRpnt->sense;
|
|
|
|
|
|
|
|
|
|
s->have_sense = scsi_normalize_sense(SRpnt->sense,
|
|
|
|
|
SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
|
|
|
|
|
s->flags = 0;
|
|
|
|
|
|
|
|
|
|
if (s->have_sense) {
|
|
|
|
|
s->deferred = 0;
|
|
|
|
|
s->remainder_valid =
|
|
|
|
|
scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
|
|
|
|
|
switch (sense[0] & 0x7f) {
|
|
|
|
|
case 0x71:
|
|
|
|
|
s->deferred = 1;
|
|
|
|
|
case 0x70:
|
|
|
|
|
s->fixed_format = 1;
|
|
|
|
|
s->flags = sense[2] & 0xe0;
|
|
|
|
|
break;
|
|
|
|
|
case 0x73:
|
|
|
|
|
s->deferred = 1;
|
|
|
|
|
case 0x72:
|
|
|
|
|
s->fixed_format = 0;
|
|
|
|
|
ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
|
|
|
|
|
s->flags = ucp ? (ucp[3] & 0xe0) : 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
/* Convert the result to success code */
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_chk_result(struct osst_tape * STp, struct osst_request * SRpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
char *name = tape_name(STp);
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
int result = SRpnt->result;
|
|
|
|
|
u8 * sense = SRpnt->sense, scode;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#if DEBUG
|
|
|
|
|
const char *stp;
|
|
|
|
|
#endif
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct st_cmdstatus *cmdstatp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (!result)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return 0;
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
|
|
|
|
|
cmdstatp = &STp->buffer->cmdstat;
|
|
|
|
|
osst_analyze_sense(SRpnt, cmdstatp);
|
|
|
|
|
|
|
|
|
|
if (cmdstatp->have_sense)
|
|
|
|
|
scode = STp->buffer->cmdstat.sense_hdr.sense_key;
|
|
|
|
|
else
|
2005-04-16 16:20:36 -06:00
|
|
|
|
scode = 0;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging) {
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Error: %x, cmd: %x %x %x %x %x %x\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
|
name, result,
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
|
|
|
|
|
SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (scode) printk(OSST_DEB_MSG "%s:D: Sense: %02x, ASC: %02x, ASCQ: %02x\n",
|
2014-10-24 06:26:45 -06:00
|
|
|
|
name, scode, sense[12], sense[13]);
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (cmdstatp->have_sense)
|
2014-10-24 06:26:45 -06:00
|
|
|
|
__scsi_print_sense(STp->device, name,
|
|
|
|
|
SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
#endif
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (cmdstatp->have_sense && (
|
2005-04-16 16:20:36 -06:00
|
|
|
|
scode != NO_SENSE &&
|
|
|
|
|
scode != RECOVERED_ERROR &&
|
|
|
|
|
/* scode != UNIT_ATTENTION && */
|
|
|
|
|
scode != BLANK_CHECK &&
|
|
|
|
|
scode != VOLUME_OVERFLOW &&
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
SRpnt->cmd[0] != MODE_SENSE &&
|
|
|
|
|
SRpnt->cmd[0] != TEST_UNIT_READY)) { /* Abnormal conditions for tape */
|
|
|
|
|
if (cmdstatp->have_sense) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk(KERN_WARNING "%s:W: Command with sense data:\n", name);
|
2014-10-24 06:26:45 -06:00
|
|
|
|
__scsi_print_sense(STp->device, name,
|
|
|
|
|
SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
static int notyetprinted = 1;
|
|
|
|
|
|
|
|
|
|
printk(KERN_WARNING
|
2009-01-25 14:09:42 -07:00
|
|
|
|
"%s:W: Warning %x (driver bt 0x%x, host bt 0x%x).\n",
|
|
|
|
|
name, result, driver_byte(result),
|
2005-04-16 16:20:36 -06:00
|
|
|
|
host_byte(result));
|
|
|
|
|
if (notyetprinted) {
|
|
|
|
|
notyetprinted = 0;
|
|
|
|
|
printk(KERN_INFO
|
|
|
|
|
"%s:I: This warning may be caused by your scsi controller,\n", name);
|
|
|
|
|
printk(KERN_INFO
|
|
|
|
|
"%s:I: it has been reported with some Buslogic cards.\n", name);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
STp->pos_unknown |= STp->device->was_reset;
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (cmdstatp->have_sense && scode == RECOVERED_ERROR) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STp->recover_count++;
|
|
|
|
|
STp->recover_erreg++;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging) {
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (SRpnt->cmd[0] == READ_6)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
stp = "read";
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
else if (SRpnt->cmd[0] == WRITE_6)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
stp = "write";
|
|
|
|
|
else
|
|
|
|
|
stp = "ioctl";
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Recovered %s error (%d).\n", name, stp,
|
|
|
|
|
STp->recover_count);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
if ((sense[2] & 0xe0) == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Wakeup from interrupt */
|
2017-06-03 01:38:04 -06:00
|
|
|
|
static void osst_end_async(struct request *req, blk_status_t status)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2017-01-27 01:46:29 -07:00
|
|
|
|
struct scsi_request *rq = scsi_req(req);
|
2008-12-13 08:55:18 -07:00
|
|
|
|
struct osst_request *SRpnt = req->end_io_data;
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_tape *STp = SRpnt->stp;
|
2008-12-13 08:55:18 -07:00
|
|
|
|
struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2017-04-20 08:03:01 -06:00
|
|
|
|
STp->buffer->cmdstat.midlevel_result = SRpnt->result = rq->result;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#if DEBUG
|
|
|
|
|
STp->write_pending = 0;
|
|
|
|
|
#endif
|
2017-01-27 01:46:29 -07:00
|
|
|
|
if (rq->sense_len)
|
|
|
|
|
memcpy(SRpnt->sense, rq->sense, SCSI_SENSE_BUFFERSIZE);
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (SRpnt->waiting)
|
|
|
|
|
complete(SRpnt->waiting);
|
2008-12-13 08:55:18 -07:00
|
|
|
|
|
|
|
|
|
if (SRpnt->bio) {
|
|
|
|
|
kfree(mdata->pages);
|
|
|
|
|
blk_rq_unmap_user(SRpnt->bio);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
__blk_put_request(req->q, req);
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* osst_request memory management */
|
|
|
|
|
static struct osst_request *osst_allocate_request(void)
|
|
|
|
|
{
|
|
|
|
|
return kzalloc(sizeof(struct osst_request), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static void osst_release_request(struct osst_request *streq)
|
|
|
|
|
{
|
|
|
|
|
kfree(streq);
|
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2008-12-13 08:55:18 -07:00
|
|
|
|
static int osst_execute(struct osst_request *SRpnt, const unsigned char *cmd,
|
|
|
|
|
int cmd_len, int data_direction, void *buffer, unsigned bufflen,
|
|
|
|
|
int use_sg, int timeout, int retries)
|
|
|
|
|
{
|
|
|
|
|
struct request *req;
|
2017-01-27 01:46:29 -07:00
|
|
|
|
struct scsi_request *rq;
|
2008-12-13 08:55:18 -07:00
|
|
|
|
struct page **pages = NULL;
|
|
|
|
|
struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
|
|
|
|
|
|
|
|
|
|
int err = 0;
|
|
|
|
|
int write = (data_direction == DMA_TO_DEVICE);
|
|
|
|
|
|
2017-01-31 08:57:31 -07:00
|
|
|
|
req = blk_get_request(SRpnt->stp->device->request_queue,
|
2018-05-09 01:54:05 -06:00
|
|
|
|
write ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
|
2014-08-28 08:15:21 -06:00
|
|
|
|
if (IS_ERR(req))
|
2008-12-13 08:55:18 -07:00
|
|
|
|
return DRIVER_ERROR << 24;
|
|
|
|
|
|
2017-01-27 01:46:29 -07:00
|
|
|
|
rq = scsi_req(req);
|
2016-10-20 07:12:13 -06:00
|
|
|
|
req->rq_flags |= RQF_QUIET;
|
2008-12-13 08:55:18 -07:00
|
|
|
|
|
|
|
|
|
SRpnt->bio = NULL;
|
|
|
|
|
|
|
|
|
|
if (use_sg) {
|
|
|
|
|
struct scatterlist *sg, *sgl = (struct scatterlist *)buffer;
|
|
|
|
|
int i;
|
|
|
|
|
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 15:03:40 -06:00
|
|
|
|
pages = kcalloc(use_sg, sizeof(struct page *), GFP_KERNEL);
|
2008-12-13 08:55:18 -07:00
|
|
|
|
if (!pages)
|
|
|
|
|
goto free_req;
|
|
|
|
|
|
|
|
|
|
for_each_sg(sgl, sg, use_sg, i)
|
|
|
|
|
pages[i] = sg_page(sg);
|
|
|
|
|
|
|
|
|
|
mdata->null_mapped = 1;
|
|
|
|
|
|
|
|
|
|
mdata->page_order = get_order(sgl[0].length);
|
|
|
|
|
mdata->nr_entries =
|
|
|
|
|
DIV_ROUND_UP(bufflen, PAGE_SIZE << mdata->page_order);
|
|
|
|
|
mdata->offset = 0;
|
|
|
|
|
|
|
|
|
|
err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen, GFP_KERNEL);
|
|
|
|
|
if (err) {
|
|
|
|
|
kfree(pages);
|
|
|
|
|
goto free_req;
|
|
|
|
|
}
|
|
|
|
|
SRpnt->bio = req->bio;
|
|
|
|
|
mdata->pages = pages;
|
|
|
|
|
|
|
|
|
|
} else if (bufflen) {
|
|
|
|
|
err = blk_rq_map_kern(req->q, req, buffer, bufflen, GFP_KERNEL);
|
|
|
|
|
if (err)
|
|
|
|
|
goto free_req;
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-27 01:46:29 -07:00
|
|
|
|
rq->cmd_len = cmd_len;
|
|
|
|
|
memset(rq->cmd, 0, BLK_MAX_CDB); /* ATAPI hates garbage after CDB */
|
|
|
|
|
memcpy(rq->cmd, cmd, rq->cmd_len);
|
2008-12-13 08:55:18 -07:00
|
|
|
|
req->timeout = timeout;
|
2017-04-05 11:18:12 -06:00
|
|
|
|
rq->retries = retries;
|
2008-12-13 08:55:18 -07:00
|
|
|
|
req->end_io_data = SRpnt;
|
|
|
|
|
|
|
|
|
|
blk_execute_rq_nowait(req->q, NULL, req, 1, osst_end_async);
|
|
|
|
|
return 0;
|
|
|
|
|
free_req:
|
|
|
|
|
blk_put_request(req);
|
|
|
|
|
return DRIVER_ERROR << 24;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
/* Do the scsi command. Waits until command performed if do_wait is true.
|
|
|
|
|
Otherwise osst_write_behind_check() is used to check that the command
|
|
|
|
|
has finished. */
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static struct osst_request * osst_do_scsi(struct osst_request *SRpnt, struct osst_tape *STp,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned char *cmd, int bytes, int direction, int timeout, int retries, int do_wait)
|
|
|
|
|
{
|
|
|
|
|
unsigned char *bp;
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
unsigned short use_sg;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#ifdef OSST_INJECT_ERRORS
|
|
|
|
|
static int inject = 0;
|
|
|
|
|
static int repeat = 0;
|
|
|
|
|
#endif
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct completion *waiting;
|
|
|
|
|
|
|
|
|
|
/* if async, make sure there's no command outstanding */
|
|
|
|
|
if (!do_wait && ((STp->buffer)->last_SRpnt)) {
|
|
|
|
|
printk(KERN_ERR "%s: Async command already active.\n",
|
|
|
|
|
tape_name(STp));
|
|
|
|
|
if (signal_pending(current))
|
|
|
|
|
(STp->buffer)->syscall_result = (-EINTR);
|
|
|
|
|
else
|
|
|
|
|
(STp->buffer)->syscall_result = (-EBUSY);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (SRpnt == NULL) {
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
SRpnt = osst_allocate_request();
|
|
|
|
|
if (SRpnt == NULL) {
|
|
|
|
|
printk(KERN_ERR "%s: Can't allocate SCSI request.\n",
|
|
|
|
|
tape_name(STp));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (signal_pending(current))
|
|
|
|
|
(STp->buffer)->syscall_result = (-EINTR);
|
|
|
|
|
else
|
|
|
|
|
(STp->buffer)->syscall_result = (-EBUSY);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
SRpnt->stp = STp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
/* If async IO, set last_SRpnt. This ptr tells write_behind_check
|
|
|
|
|
which IO is outstanding. It's nulled out when the IO completes. */
|
|
|
|
|
if (!do_wait)
|
|
|
|
|
(STp->buffer)->last_SRpnt = SRpnt;
|
|
|
|
|
|
|
|
|
|
waiting = &STp->wait;
|
|
|
|
|
init_completion(waiting);
|
|
|
|
|
SRpnt->waiting = waiting;
|
|
|
|
|
|
|
|
|
|
use_sg = (bytes > STp->buffer->sg[0].length) ? STp->buffer->use_sg : 0;
|
|
|
|
|
if (use_sg) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
bp = (char *)&(STp->buffer->sg[0]);
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (STp->buffer->sg_segs < use_sg)
|
|
|
|
|
use_sg = STp->buffer->sg_segs;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
bp = (STp->buffer)->b_data;
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
|
|
|
|
|
STp->buffer->cmdstat.have_sense = 0;
|
|
|
|
|
STp->buffer->syscall_result = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2008-12-13 08:55:18 -07:00
|
|
|
|
if (osst_execute(SRpnt, cmd, COMMAND_SIZE(cmd[0]), direction, bp, bytes,
|
|
|
|
|
use_sg, timeout, retries))
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
/* could not allocate the buffer or request was too large */
|
|
|
|
|
(STp->buffer)->syscall_result = (-EBUSY);
|
|
|
|
|
else if (do_wait) {
|
|
|
|
|
wait_for_completion(waiting);
|
|
|
|
|
SRpnt->waiting = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STp->buffer->syscall_result = osst_chk_result(STp, SRpnt);
|
|
|
|
|
#ifdef OSST_INJECT_ERRORS
|
|
|
|
|
if (STp->buffer->syscall_result == 0 &&
|
|
|
|
|
cmd[0] == READ_6 &&
|
|
|
|
|
cmd[4] &&
|
|
|
|
|
( (++ inject % 83) == 29 ||
|
|
|
|
|
(STp->first_frame_position == 240
|
|
|
|
|
/* or STp->read_error_frame to fail again on the block calculated above */ &&
|
|
|
|
|
++repeat < 3))) {
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Injecting read error\n", tape_name(STp));
|
|
|
|
|
STp->buffer->last_result_fatal = 1;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
return SRpnt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Handle the write-behind checking (downs the semaphore) */
|
|
|
|
|
static void osst_write_behind_check(struct osst_tape *STp)
|
|
|
|
|
{
|
|
|
|
|
struct osst_buffer * STbuffer;
|
|
|
|
|
|
|
|
|
|
STbuffer = STp->buffer;
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (STp->write_pending)
|
|
|
|
|
STp->nbr_waits++;
|
|
|
|
|
else
|
|
|
|
|
STp->nbr_finished++;
|
|
|
|
|
#endif
|
|
|
|
|
wait_for_completion(&(STp->wait));
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
STp->buffer->last_SRpnt->waiting = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
STp->buffer->syscall_result = osst_chk_result(STp, STp->buffer->last_SRpnt);
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (STp->buffer->syscall_result)
|
|
|
|
|
STp->buffer->syscall_result =
|
|
|
|
|
osst_write_error_recovery(STp, &(STp->buffer->last_SRpnt), 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
else
|
|
|
|
|
STp->first_frame_position++;
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
osst_release_request(STp->buffer->last_SRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
if (STbuffer->writing < STbuffer->buffer_bytes)
|
|
|
|
|
printk(KERN_WARNING "osst :A: write_behind_check: something left in buffer!\n");
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
STbuffer->last_SRpnt = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STbuffer->buffer_bytes -= STbuffer->writing;
|
|
|
|
|
STbuffer->writing = 0;
|
|
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Onstream specific Routines */
|
|
|
|
|
/*
|
|
|
|
|
* Initialize the OnStream AUX
|
|
|
|
|
*/
|
|
|
|
|
static void osst_init_aux(struct osst_tape * STp, int frame_type, int frame_seq_number,
|
|
|
|
|
int logical_blk_num, int blk_sz, int blk_cnt)
|
|
|
|
|
{
|
|
|
|
|
os_aux_t *aux = STp->buffer->aux;
|
|
|
|
|
os_partition_t *par = &aux->partition;
|
|
|
|
|
os_dat_t *dat = &aux->dat;
|
|
|
|
|
|
|
|
|
|
if (STp->raw) return;
|
|
|
|
|
|
|
|
|
|
memset(aux, 0, sizeof(*aux));
|
|
|
|
|
aux->format_id = htonl(0);
|
|
|
|
|
memcpy(aux->application_sig, "LIN4", 4);
|
|
|
|
|
aux->hdwr = htonl(0);
|
|
|
|
|
aux->frame_type = frame_type;
|
|
|
|
|
|
|
|
|
|
switch (frame_type) {
|
|
|
|
|
case OS_FRAME_TYPE_HEADER:
|
|
|
|
|
aux->update_frame_cntr = htonl(STp->update_frame_cntr);
|
|
|
|
|
par->partition_num = OS_CONFIG_PARTITION;
|
|
|
|
|
par->par_desc_ver = OS_PARTITION_VERSION;
|
|
|
|
|
par->wrt_pass_cntr = htons(0xffff);
|
|
|
|
|
/* 0-4 = reserved, 5-9 = header, 2990-2994 = header, 2995-2999 = reserved */
|
|
|
|
|
par->first_frame_ppos = htonl(0);
|
|
|
|
|
par->last_frame_ppos = htonl(0xbb7);
|
|
|
|
|
aux->frame_seq_num = htonl(0);
|
|
|
|
|
aux->logical_blk_num_high = htonl(0);
|
|
|
|
|
aux->logical_blk_num = htonl(0);
|
|
|
|
|
aux->next_mark_ppos = htonl(STp->first_mark_ppos);
|
|
|
|
|
break;
|
|
|
|
|
case OS_FRAME_TYPE_DATA:
|
|
|
|
|
case OS_FRAME_TYPE_MARKER:
|
|
|
|
|
dat->dat_sz = 8;
|
|
|
|
|
dat->reserved1 = 0;
|
|
|
|
|
dat->entry_cnt = 1;
|
|
|
|
|
dat->reserved3 = 0;
|
|
|
|
|
dat->dat_list[0].blk_sz = htonl(blk_sz);
|
|
|
|
|
dat->dat_list[0].blk_cnt = htons(blk_cnt);
|
|
|
|
|
dat->dat_list[0].flags = frame_type==OS_FRAME_TYPE_MARKER?
|
|
|
|
|
OS_DAT_FLAGS_MARK:OS_DAT_FLAGS_DATA;
|
|
|
|
|
dat->dat_list[0].reserved = 0;
|
|
|
|
|
case OS_FRAME_TYPE_EOD:
|
|
|
|
|
aux->update_frame_cntr = htonl(0);
|
|
|
|
|
par->partition_num = OS_DATA_PARTITION;
|
|
|
|
|
par->par_desc_ver = OS_PARTITION_VERSION;
|
|
|
|
|
par->wrt_pass_cntr = htons(STp->wrt_pass_cntr);
|
|
|
|
|
par->first_frame_ppos = htonl(STp->first_data_ppos);
|
|
|
|
|
par->last_frame_ppos = htonl(STp->capacity);
|
|
|
|
|
aux->frame_seq_num = htonl(frame_seq_number);
|
|
|
|
|
aux->logical_blk_num_high = htonl(0);
|
|
|
|
|
aux->logical_blk_num = htonl(logical_blk_num);
|
|
|
|
|
break;
|
|
|
|
|
default: ; /* probably FILL */
|
|
|
|
|
}
|
2007-02-09 09:39:45 -07:00
|
|
|
|
aux->filemark_cnt = htonl(STp->filemark_cnt);
|
|
|
|
|
aux->phys_fm = htonl(0xffffffff);
|
|
|
|
|
aux->last_mark_ppos = htonl(STp->last_mark_ppos);
|
|
|
|
|
aux->last_mark_lbn = htonl(STp->last_mark_lbn);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Verify that we have the correct tape frame
|
|
|
|
|
*/
|
|
|
|
|
static int osst_verify_frame(struct osst_tape * STp, int frame_seq_number, int quiet)
|
|
|
|
|
{
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
os_aux_t * aux = STp->buffer->aux;
|
|
|
|
|
os_partition_t * par = &(aux->partition);
|
|
|
|
|
struct st_partstat * STps = &(STp->ps[STp->partition]);
|
2017-08-04 02:17:33 -06:00
|
|
|
|
unsigned int blk_cnt, blk_sz, i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
if (STp->raw) {
|
|
|
|
|
if (STp->buffer->syscall_result) {
|
|
|
|
|
for (i=0; i < STp->buffer->sg_segs; i++)
|
2007-10-22 13:19:53 -06:00
|
|
|
|
memset(page_address(sg_page(&STp->buffer->sg[i])),
|
2005-04-16 16:20:36 -06:00
|
|
|
|
0, STp->buffer->sg[i].length);
|
|
|
|
|
strcpy(STp->buffer->b_data, "READ ERROR ON FRAME");
|
|
|
|
|
} else
|
|
|
|
|
STp->buffer->buffer_bytes = OS_FRAME_SIZE;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
if (STp->buffer->syscall_result) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping frame, read error\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (ntohl(aux->format_id) != 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping frame, format_id %u\n", name, ntohl(aux->format_id));
|
|
|
|
|
#endif
|
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
|
|
|
|
if (memcmp(aux->application_sig, STp->application_sig, 4) != 0 &&
|
|
|
|
|
(memcmp(aux->application_sig, "LIN3", 4) != 0 || STp->linux_media_version != 4)) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping frame, incorrect application signature\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
|
|
|
|
if (par->partition_num != OS_DATA_PARTITION) {
|
|
|
|
|
if (!STp->linux_media || STp->linux_media_version != 2) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping frame, partition num %d\n",
|
|
|
|
|
name, par->partition_num);
|
|
|
|
|
#endif
|
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (par->par_desc_ver != OS_PARTITION_VERSION) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping frame, partition version %d\n", name, par->par_desc_ver);
|
|
|
|
|
#endif
|
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
|
|
|
|
if (ntohs(par->wrt_pass_cntr) != STp->wrt_pass_cntr) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping frame, wrt_pass_cntr %d (expected %d)\n",
|
|
|
|
|
name, ntohs(par->wrt_pass_cntr), STp->wrt_pass_cntr);
|
|
|
|
|
#endif
|
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
|
|
|
|
if (aux->frame_type != OS_FRAME_TYPE_DATA &&
|
|
|
|
|
aux->frame_type != OS_FRAME_TYPE_EOD &&
|
|
|
|
|
aux->frame_type != OS_FRAME_TYPE_MARKER) {
|
2007-10-23 14:42:04 -06:00
|
|
|
|
if (!quiet) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping frame, frame type %x\n", name, aux->frame_type);
|
|
|
|
|
#endif
|
2007-10-23 14:42:04 -06:00
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
|
|
|
|
if (aux->frame_type == OS_FRAME_TYPE_EOD &&
|
|
|
|
|
STp->first_frame_position < STp->eod_frame_ppos) {
|
|
|
|
|
printk(KERN_INFO "%s:I: Skipping premature EOD frame %d\n", name,
|
|
|
|
|
STp->first_frame_position);
|
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
|
|
|
|
if (frame_seq_number != -1 && ntohl(aux->frame_seq_num) != frame_seq_number) {
|
2007-10-23 14:42:04 -06:00
|
|
|
|
if (!quiet) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping frame, sequence number %u (expected %d)\n",
|
|
|
|
|
name, ntohl(aux->frame_seq_num), frame_seq_number);
|
|
|
|
|
#endif
|
2007-10-23 14:42:04 -06:00
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
|
|
|
|
if (aux->frame_type == OS_FRAME_TYPE_MARKER) {
|
|
|
|
|
STps->eof = ST_FM_HIT;
|
|
|
|
|
|
|
|
|
|
i = ntohl(aux->filemark_cnt);
|
|
|
|
|
if (STp->header_cache != NULL && i < OS_FM_TAB_MAX && (i > STp->filemark_cnt ||
|
|
|
|
|
STp->first_frame_position - 1 != ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[i]))) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: %s filemark %d at frame pos %d\n", name,
|
|
|
|
|
STp->header_cache->dat_fm_tab.fm_tab_ent[i] == 0?"Learned":"Corrected",
|
|
|
|
|
i, STp->first_frame_position - 1);
|
|
|
|
|
#endif
|
|
|
|
|
STp->header_cache->dat_fm_tab.fm_tab_ent[i] = htonl(STp->first_frame_position - 1);
|
|
|
|
|
if (i >= STp->filemark_cnt)
|
|
|
|
|
STp->filemark_cnt = i+1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (aux->frame_type == OS_FRAME_TYPE_EOD) {
|
|
|
|
|
STps->eof = ST_EOD_1;
|
|
|
|
|
STp->frame_in_buffer = 1;
|
|
|
|
|
}
|
|
|
|
|
if (aux->frame_type == OS_FRAME_TYPE_DATA) {
|
|
|
|
|
blk_cnt = ntohs(aux->dat.dat_list[0].blk_cnt);
|
|
|
|
|
blk_sz = ntohl(aux->dat.dat_list[0].blk_sz);
|
|
|
|
|
STp->buffer->buffer_bytes = blk_cnt * blk_sz;
|
|
|
|
|
STp->buffer->read_pointer = 0;
|
|
|
|
|
STp->frame_in_buffer = 1;
|
|
|
|
|
|
|
|
|
|
/* See what block size was used to write file */
|
|
|
|
|
if (STp->block_size != blk_sz && blk_sz > 0) {
|
|
|
|
|
printk(KERN_INFO
|
|
|
|
|
"%s:I: File was written with block size %d%c, currently %d%c, adjusted to match.\n",
|
|
|
|
|
name, blk_sz<1024?blk_sz:blk_sz/1024,blk_sz<1024?'b':'k',
|
|
|
|
|
STp->block_size<1024?STp->block_size:STp->block_size/1024,
|
|
|
|
|
STp->block_size<1024?'b':'k');
|
|
|
|
|
STp->block_size = blk_sz;
|
|
|
|
|
STp->buffer->buffer_blocks = OS_DATA_SIZE / blk_sz;
|
|
|
|
|
}
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
}
|
|
|
|
|
STp->frame_seq_number = ntohl(aux->frame_seq_num);
|
|
|
|
|
STp->logical_blk_num = ntohl(aux->logical_blk_num);
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
err_out:
|
|
|
|
|
if (STp->read_error_frame == 0)
|
|
|
|
|
STp->read_error_frame = STp->first_frame_position - 1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Wait for the unit to become Ready
|
|
|
|
|
*/
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_wait_ready(struct osst_tape * STp, struct osst_request ** aSRpnt,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned timeout, int initial_delay)
|
|
|
|
|
{
|
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned long startwait = jiffies;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
int dbg = debugging;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reached onstream wait ready\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (initial_delay > 0)
|
|
|
|
|
msleep(jiffies_to_msecs(initial_delay));
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = TEST_UNIT_READY;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
if (!SRpnt) return (-EBUSY);
|
|
|
|
|
|
|
|
|
|
while ( STp->buffer->syscall_result && time_before(jiffies, startwait + timeout*HZ) &&
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
(( SRpnt->sense[2] == 2 && SRpnt->sense[12] == 4 &&
|
|
|
|
|
(SRpnt->sense[13] == 1 || SRpnt->sense[13] == 8) ) ||
|
|
|
|
|
( SRpnt->sense[2] == 6 && SRpnt->sense[12] == 0x28 &&
|
|
|
|
|
SRpnt->sense[13] == 0 ) )) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging) {
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Sleeping in onstream wait ready\n", name);
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name);
|
|
|
|
|
debugging = 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
msleep(100);
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = TEST_UNIT_READY;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
}
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
debugging = dbg;
|
|
|
|
|
#endif
|
|
|
|
|
if ( STp->buffer->syscall_result &&
|
|
|
|
|
osst_write_error_recovery(STp, aSRpnt, 0) ) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Abnormal exit from onstream wait ready\n", name);
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Result = %d, Sense: 0=%02x, 2=%02x, 12=%02x, 13=%02x\n", name,
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
STp->buffer->syscall_result, SRpnt->sense[0], SRpnt->sense[2],
|
|
|
|
|
SRpnt->sense[12], SRpnt->sense[13]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Normal exit from onstream wait ready\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Wait for a tape to be inserted in the unit
|
|
|
|
|
*/
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_wait_for_medium(struct osst_tape * STp, struct osst_request ** aSRpnt, unsigned timeout)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned long startwait = jiffies;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
int dbg = debugging;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reached onstream wait for medium\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = TEST_UNIT_READY;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
if (!SRpnt) return (-EBUSY);
|
|
|
|
|
|
|
|
|
|
while ( STp->buffer->syscall_result && time_before(jiffies, startwait + timeout*HZ) &&
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
SRpnt->sense[2] == 2 && SRpnt->sense[12] == 0x3a && SRpnt->sense[13] == 0 ) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging) {
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Sleeping in onstream wait medium\n", name);
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name);
|
|
|
|
|
debugging = 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
msleep(100);
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = TEST_UNIT_READY;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
}
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
debugging = dbg;
|
|
|
|
|
#endif
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ( STp->buffer->syscall_result && SRpnt->sense[2] != 2 &&
|
|
|
|
|
SRpnt->sense[12] != 4 && SRpnt->sense[13] == 1) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Abnormal exit from onstream wait medium\n", name);
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Result = %d, Sense: 0=%02x, 2=%02x, 12=%02x, 13=%02x\n", name,
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
STp->buffer->syscall_result, SRpnt->sense[0], SRpnt->sense[2],
|
|
|
|
|
SRpnt->sense[12], SRpnt->sense[13]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Normal exit from onstream wait medium\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_position_tape_and_confirm(struct osst_tape * STp, struct osst_request ** aSRpnt, int frame)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
|
|
osst_wait_ready(STp, aSRpnt, 15 * 60, 0); /* TODO - can this catch a write error? */
|
|
|
|
|
retval = osst_set_frame_position(STp, aSRpnt, frame, 0);
|
|
|
|
|
if (retval) return (retval);
|
|
|
|
|
osst_wait_ready(STp, aSRpnt, 15 * 60, OSST_WAIT_POSITION_COMPLETE);
|
|
|
|
|
return (osst_get_frame_position(STp, aSRpnt));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Wait for write(s) to complete
|
|
|
|
|
*/
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_flush_drive_buffer(struct osst_tape * STp, struct osst_request ** aSRpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
int result = 0;
|
|
|
|
|
int delay = OSST_WAIT_WRITE_COMPLETE;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reached onstream flush drive buffer (write filemark)\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = WRITE_FILEMARKS;
|
|
|
|
|
cmd[1] = 1;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
if (!SRpnt) return (-EBUSY);
|
|
|
|
|
if (STp->buffer->syscall_result) {
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ((SRpnt->sense[2] & 0x0f) == 2 && SRpnt->sense[12] == 4) {
|
|
|
|
|
if (SRpnt->sense[13] == 8) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
delay = OSST_WAIT_LONG_WRITE_COMPLETE;
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
result = osst_write_error_recovery(STp, aSRpnt, 0);
|
|
|
|
|
}
|
|
|
|
|
result |= osst_wait_ready(STp, aSRpnt, 5 * 60, delay);
|
|
|
|
|
STp->ps[STp->partition].rw = OS_WRITING_COMPLETE;
|
|
|
|
|
|
|
|
|
|
return (result);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define OSST_POLL_PER_SEC 10
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_wait_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, int curr, int minlast, int to)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
unsigned long startwait = jiffies;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
char notyetprinted = 1;
|
|
|
|
|
#endif
|
|
|
|
|
if (minlast >= 0 && STp->ps[STp->partition].rw != ST_READING)
|
|
|
|
|
printk(KERN_ERR "%s:A: Waiting for frame without having initialized read!\n", name);
|
|
|
|
|
|
|
|
|
|
while (time_before (jiffies, startwait + to*HZ))
|
|
|
|
|
{
|
|
|
|
|
int result;
|
|
|
|
|
result = osst_get_frame_position(STp, aSRpnt);
|
|
|
|
|
if (result == -EIO)
|
|
|
|
|
if ((result = osst_write_error_recovery(STp, aSRpnt, 0)) == 0)
|
|
|
|
|
return 0; /* successful recovery leaves drive ready for frame */
|
|
|
|
|
if (result < 0) break;
|
|
|
|
|
if (STp->first_frame_position == curr &&
|
|
|
|
|
((minlast < 0 &&
|
|
|
|
|
(signed)STp->last_frame_position > (signed)curr + minlast) ||
|
|
|
|
|
(minlast >= 0 && STp->cur_frames > minlast)
|
|
|
|
|
) && result >= 0)
|
|
|
|
|
{
|
|
|
|
|
#if DEBUG
|
2006-03-28 02:56:47 -07:00
|
|
|
|
if (debugging || time_after_eq(jiffies, startwait + 2*HZ/OSST_POLL_PER_SEC))
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk (OSST_DEB_MSG
|
|
|
|
|
"%s:D: Succ wait f fr %i (>%i): %i-%i %i (%i): %3li.%li s\n",
|
|
|
|
|
name, curr, curr+minlast, STp->first_frame_position,
|
|
|
|
|
STp->last_frame_position, STp->cur_frames,
|
|
|
|
|
result, (jiffies-startwait)/HZ,
|
|
|
|
|
(((jiffies-startwait)%HZ)*10)/HZ);
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
2006-03-28 02:56:47 -07:00
|
|
|
|
if (time_after_eq(jiffies, startwait + 2*HZ/OSST_POLL_PER_SEC) && notyetprinted)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
printk (OSST_DEB_MSG "%s:D: Wait for frame %i (>%i): %i-%i %i (%i)\n",
|
|
|
|
|
name, curr, curr+minlast, STp->first_frame_position,
|
|
|
|
|
STp->last_frame_position, STp->cur_frames, result);
|
|
|
|
|
notyetprinted--;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
msleep(1000 / OSST_POLL_PER_SEC);
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk (OSST_DEB_MSG "%s:D: Fail wait f fr %i (>%i): %i-%i %i: %3li.%li s\n",
|
|
|
|
|
name, curr, curr+minlast, STp->first_frame_position,
|
|
|
|
|
STp->last_frame_position, STp->cur_frames,
|
|
|
|
|
(jiffies-startwait)/HZ, (((jiffies-startwait)%HZ)*10)/HZ);
|
|
|
|
|
#endif
|
|
|
|
|
return -EBUSY;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_recover_wait_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, int writing)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
|
|
|
|
unsigned long startwait = jiffies;
|
|
|
|
|
int retval = 1;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
if (writing) {
|
|
|
|
|
char mybuf[24];
|
|
|
|
|
char * olddata = STp->buffer->b_data;
|
|
|
|
|
int oldsize = STp->buffer->buffer_size;
|
|
|
|
|
|
|
|
|
|
/* write zero fm then read pos - if shows write error, try to recover - if no progress, wait */
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = WRITE_FILEMARKS;
|
|
|
|
|
cmd[1] = 1;
|
|
|
|
|
SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout,
|
|
|
|
|
MAX_RETRIES, 1);
|
|
|
|
|
|
|
|
|
|
while (retval && time_before (jiffies, startwait + 5*60*HZ)) {
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (STp->buffer->syscall_result && (SRpnt->sense[2] & 0x0f) != 2) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
/* some failure - not just not-ready */
|
|
|
|
|
retval = osst_write_error_recovery(STp, aSRpnt, 0);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2005-11-07 02:01:20 -07:00
|
|
|
|
schedule_timeout_interruptible(HZ / OSST_POLL_PER_SEC);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
STp->buffer->b_data = mybuf; STp->buffer->buffer_size = 24;
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = READ_POSITION;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, 20, DMA_FROM_DEVICE, STp->timeout,
|
|
|
|
|
MAX_RETRIES, 1);
|
|
|
|
|
|
|
|
|
|
retval = ( STp->buffer->syscall_result || (STp->buffer)->b_data[15] > 25 );
|
|
|
|
|
STp->buffer->b_data = olddata; STp->buffer->buffer_size = oldsize;
|
|
|
|
|
}
|
|
|
|
|
if (retval)
|
|
|
|
|
printk(KERN_ERR "%s:E: Device did not succeed to write buffered data\n", name);
|
|
|
|
|
} else
|
|
|
|
|
/* TODO - figure out which error conditions can be handled */
|
|
|
|
|
if (STp->buffer->syscall_result)
|
|
|
|
|
printk(KERN_WARNING
|
|
|
|
|
"%s:W: Recover_wait_frame(read) cannot handle %02x:%02x:%02x\n", name,
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
(*aSRpnt)->sense[ 2] & 0x0f,
|
|
|
|
|
(*aSRpnt)->sense[12],
|
|
|
|
|
(*aSRpnt)->sense[13]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Read the next OnStream tape frame at the current location
|
|
|
|
|
*/
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_read_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, int timeout)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
int retval = 0;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
os_aux_t * aux = STp->buffer->aux;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (STp->poll)
|
|
|
|
|
if (osst_wait_frame (STp, aSRpnt, STp->first_frame_position, 0, timeout))
|
|
|
|
|
retval = osst_recover_wait_frame(STp, aSRpnt, 0);
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = READ_6;
|
|
|
|
|
cmd[1] = 1;
|
|
|
|
|
cmd[4] = 1;
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reading frame from OnStream tape\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, OS_FRAME_SIZE, DMA_FROM_DEVICE,
|
|
|
|
|
STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
if (!SRpnt)
|
|
|
|
|
return (-EBUSY);
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->syscall_result) {
|
|
|
|
|
retval = 1;
|
|
|
|
|
if (STp->read_error_frame == 0) {
|
|
|
|
|
STp->read_error_frame = STp->first_frame_position;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Recording read error at %d\n", name, STp->read_error_frame);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
|
|
|
|
|
name,
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
SRpnt->sense[0], SRpnt->sense[1],
|
|
|
|
|
SRpnt->sense[2], SRpnt->sense[3],
|
|
|
|
|
SRpnt->sense[4], SRpnt->sense[5],
|
|
|
|
|
SRpnt->sense[6], SRpnt->sense[7]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
STp->first_frame_position++;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging) {
|
|
|
|
|
char sig[8]; int i;
|
|
|
|
|
for (i=0;i<4;i++)
|
|
|
|
|
sig[i] = aux->application_sig[i]<32?'^':aux->application_sig[i];
|
|
|
|
|
sig[4] = '\0';
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: AUX: %s UpdFrCt#%d Wpass#%d %s FrSeq#%d LogBlk#%d Qty=%d Sz=%d\n", name, sig,
|
|
|
|
|
ntohl(aux->update_frame_cntr), ntohs(aux->partition.wrt_pass_cntr),
|
|
|
|
|
aux->frame_type==1?"EOD":aux->frame_type==2?"MARK":
|
|
|
|
|
aux->frame_type==8?"HEADR":aux->frame_type==0x80?"DATA":"FILL",
|
|
|
|
|
ntohl(aux->frame_seq_num), ntohl(aux->logical_blk_num),
|
|
|
|
|
ntohs(aux->dat.dat_list[0].blk_cnt), ntohl(aux->dat.dat_list[0].blk_sz) );
|
|
|
|
|
if (aux->frame_type==2)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: mark_cnt=%d, last_mark_ppos=%d, last_mark_lbn=%d\n", name,
|
|
|
|
|
ntohl(aux->filemark_cnt), ntohl(aux->last_mark_ppos), ntohl(aux->last_mark_lbn));
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Exit read frame from OnStream tape with code %d\n", name, retval);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
return (retval);
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_initiate_read(struct osst_tape * STp, struct osst_request ** aSRpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
struct st_partstat * STps = &(STp->ps[STp->partition]);
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt ;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
|
|
|
|
int retval = 0;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
if (STps->rw != ST_READING) { /* Initialize read operation */
|
|
|
|
|
if (STps->rw == ST_WRITING || STp->dirty) {
|
|
|
|
|
STp->write_type = OS_WRITE_DATA;
|
|
|
|
|
osst_flush_write_buffer(STp, aSRpnt);
|
|
|
|
|
osst_flush_drive_buffer(STp, aSRpnt);
|
|
|
|
|
}
|
|
|
|
|
STps->rw = ST_READING;
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Issue a read 0 command to get the OnStream drive
|
|
|
|
|
* read frames into its buffer.
|
|
|
|
|
*/
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = READ_6;
|
|
|
|
|
cmd[1] = 1;
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Start Read Ahead on OnStream tape\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
if ((retval = STp->buffer->syscall_result))
|
|
|
|
|
printk(KERN_WARNING "%s:W: Error starting read ahead\n", name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_get_logical_frame(struct osst_tape * STp, struct osst_request ** aSRpnt,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
int frame_seq_number, int quiet)
|
|
|
|
|
{
|
|
|
|
|
struct st_partstat * STps = &(STp->ps[STp->partition]);
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
int cnt = 0,
|
|
|
|
|
bad = 0,
|
|
|
|
|
past = 0,
|
|
|
|
|
x,
|
|
|
|
|
position;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If we want just any frame (-1) and there is a frame in the buffer, return it
|
|
|
|
|
*/
|
|
|
|
|
if (frame_seq_number == -1 && STp->frame_in_buffer) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Frame %d still in buffer\n", name, STp->frame_seq_number);
|
|
|
|
|
#endif
|
|
|
|
|
return (STps->eof);
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
* Search and wait for the next logical tape frame
|
|
|
|
|
*/
|
|
|
|
|
while (1) {
|
|
|
|
|
if (cnt++ > 400) {
|
|
|
|
|
printk(KERN_ERR "%s:E: Couldn't find logical frame %d, aborting\n",
|
|
|
|
|
name, frame_seq_number);
|
|
|
|
|
if (STp->read_error_frame) {
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, STp->read_error_frame, 0);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Repositioning tape to bad frame %d\n",
|
|
|
|
|
name, STp->read_error_frame);
|
|
|
|
|
#endif
|
|
|
|
|
STp->read_error_frame = 0;
|
|
|
|
|
STp->abort_count++;
|
|
|
|
|
}
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Looking for frame %d, attempt %d\n",
|
|
|
|
|
name, frame_seq_number, cnt);
|
|
|
|
|
#endif
|
|
|
|
|
if ( osst_initiate_read(STp, aSRpnt)
|
|
|
|
|
|| ( (!STp->frame_in_buffer) && osst_read_frame(STp, aSRpnt, 30) ) ) {
|
|
|
|
|
if (STp->raw)
|
|
|
|
|
return (-EIO);
|
|
|
|
|
position = osst_get_frame_position(STp, aSRpnt);
|
|
|
|
|
if (position >= 0xbae && position < 0xbb8)
|
|
|
|
|
position = 0xbb8;
|
|
|
|
|
else if (position > STp->eod_frame_ppos || ++bad == 10) {
|
|
|
|
|
position = STp->read_error_frame - 1;
|
|
|
|
|
bad = 0;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
position += 29;
|
|
|
|
|
cnt += 19;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Bad frame detected, positioning tape to block %d\n",
|
|
|
|
|
name, position);
|
|
|
|
|
#endif
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, position, 0);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (osst_verify_frame(STp, frame_seq_number, quiet))
|
|
|
|
|
break;
|
|
|
|
|
if (osst_verify_frame(STp, -1, quiet)) {
|
|
|
|
|
x = ntohl(STp->buffer->aux->frame_seq_num);
|
|
|
|
|
if (STp->fast_open) {
|
|
|
|
|
printk(KERN_WARNING
|
|
|
|
|
"%s:W: Found logical frame %d instead of %d after fast open\n",
|
|
|
|
|
name, x, frame_seq_number);
|
|
|
|
|
STp->header_ok = 0;
|
|
|
|
|
STp->read_error_frame = 0;
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (x > frame_seq_number) {
|
|
|
|
|
if (++past > 3) {
|
|
|
|
|
/* positioning backwards did not bring us to the desired frame */
|
|
|
|
|
position = STp->read_error_frame - 1;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
position = osst_get_frame_position(STp, aSRpnt)
|
|
|
|
|
+ frame_seq_number - x - 1;
|
|
|
|
|
|
|
|
|
|
if (STp->first_frame_position >= 3000 && position < 3000)
|
|
|
|
|
position -= 10;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: Found logical frame %d while looking for %d: back up %d\n",
|
|
|
|
|
name, x, frame_seq_number,
|
|
|
|
|
STp->first_frame_position - position);
|
|
|
|
|
#endif
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, position, 0);
|
|
|
|
|
cnt += 10;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
past = 0;
|
|
|
|
|
}
|
|
|
|
|
if (osst_get_frame_position(STp, aSRpnt) == 0xbaf) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping config partition\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, 0xbb8, 0);
|
|
|
|
|
cnt--;
|
|
|
|
|
}
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
}
|
|
|
|
|
if (cnt > 1) {
|
|
|
|
|
STp->recover_count++;
|
|
|
|
|
STp->recover_erreg++;
|
|
|
|
|
printk(KERN_WARNING "%s:I: Don't worry, Read error at position %d recovered\n",
|
|
|
|
|
name, STp->read_error_frame);
|
|
|
|
|
}
|
|
|
|
|
STp->read_count++;
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging || STps->eof)
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: Exit get logical frame (%d=>%d) from OnStream tape with code %d\n",
|
|
|
|
|
name, frame_seq_number, STp->frame_seq_number, STps->eof);
|
|
|
|
|
#endif
|
|
|
|
|
STp->fast_open = 0;
|
|
|
|
|
STp->read_error_frame = 0;
|
|
|
|
|
return (STps->eof);
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_seek_logical_blk(struct osst_tape * STp, struct osst_request ** aSRpnt, int logical_blk_num)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
struct st_partstat * STps = &(STp->ps[STp->partition]);
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
int retries = 0;
|
|
|
|
|
int frame_seq_estimate, ppos_estimate, move;
|
|
|
|
|
|
|
|
|
|
if (logical_blk_num < 0) logical_blk_num = 0;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Seeking logical block %d (now at %d, size %d%c)\n",
|
|
|
|
|
name, logical_blk_num, STp->logical_blk_num,
|
|
|
|
|
STp->block_size<1024?STp->block_size:STp->block_size/1024,
|
|
|
|
|
STp->block_size<1024?'b':'k');
|
|
|
|
|
#endif
|
|
|
|
|
/* Do we know where we are? */
|
|
|
|
|
if (STps->drv_block >= 0) {
|
|
|
|
|
move = logical_blk_num - STp->logical_blk_num;
|
|
|
|
|
if (move < 0) move -= (OS_DATA_SIZE / STp->block_size) - 1;
|
|
|
|
|
move /= (OS_DATA_SIZE / STp->block_size);
|
|
|
|
|
frame_seq_estimate = STp->frame_seq_number + move;
|
|
|
|
|
} else
|
|
|
|
|
frame_seq_estimate = logical_blk_num * STp->block_size / OS_DATA_SIZE;
|
|
|
|
|
|
|
|
|
|
if (frame_seq_estimate < 2980) ppos_estimate = frame_seq_estimate + 10;
|
|
|
|
|
else ppos_estimate = frame_seq_estimate + 20;
|
|
|
|
|
while (++retries < 10) {
|
|
|
|
|
if (ppos_estimate > STp->eod_frame_ppos-2) {
|
|
|
|
|
frame_seq_estimate += STp->eod_frame_ppos - 2 - ppos_estimate;
|
|
|
|
|
ppos_estimate = STp->eod_frame_ppos - 2;
|
|
|
|
|
}
|
|
|
|
|
if (frame_seq_estimate < 0) {
|
|
|
|
|
frame_seq_estimate = 0;
|
|
|
|
|
ppos_estimate = 10;
|
|
|
|
|
}
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, ppos_estimate, 0);
|
|
|
|
|
if (osst_get_logical_frame(STp, aSRpnt, frame_seq_estimate, 1) >= 0) {
|
|
|
|
|
/* we've located the estimated frame, now does it have our block? */
|
|
|
|
|
if (logical_blk_num < STp->logical_blk_num ||
|
|
|
|
|
logical_blk_num >= STp->logical_blk_num + ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt)) {
|
|
|
|
|
if (STps->eof == ST_FM_HIT)
|
|
|
|
|
move = logical_blk_num < STp->logical_blk_num? -2 : 1;
|
|
|
|
|
else {
|
|
|
|
|
move = logical_blk_num - STp->logical_blk_num;
|
|
|
|
|
if (move < 0) move -= (OS_DATA_SIZE / STp->block_size) - 1;
|
|
|
|
|
move /= (OS_DATA_SIZE / STp->block_size);
|
|
|
|
|
}
|
|
|
|
|
if (!move) move = logical_blk_num > STp->logical_blk_num ? 1 : -1;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: Seek retry %d at ppos %d fsq %d (est %d) lbn %d (need %d) move %d\n",
|
|
|
|
|
name, retries, ppos_estimate, STp->frame_seq_number, frame_seq_estimate,
|
|
|
|
|
STp->logical_blk_num, logical_blk_num, move);
|
|
|
|
|
#endif
|
|
|
|
|
frame_seq_estimate += move;
|
|
|
|
|
ppos_estimate += move;
|
|
|
|
|
continue;
|
|
|
|
|
} else {
|
|
|
|
|
STp->buffer->read_pointer = (logical_blk_num - STp->logical_blk_num) * STp->block_size;
|
|
|
|
|
STp->buffer->buffer_bytes -= STp->buffer->read_pointer;
|
|
|
|
|
STp->logical_blk_num = logical_blk_num;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: Seek success at ppos %d fsq %d in_buf %d, bytes %d, ptr %d*%d\n",
|
|
|
|
|
name, ppos_estimate, STp->frame_seq_number, STp->frame_in_buffer,
|
|
|
|
|
STp->buffer->buffer_bytes, STp->buffer->read_pointer / STp->block_size,
|
|
|
|
|
STp->block_size);
|
|
|
|
|
#endif
|
|
|
|
|
STps->drv_file = ntohl(STp->buffer->aux->filemark_cnt);
|
|
|
|
|
if (STps->eof == ST_FM_HIT) {
|
|
|
|
|
STps->drv_file++;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
} else {
|
|
|
|
|
STps->drv_block = ntohl(STp->buffer->aux->last_mark_lbn)?
|
|
|
|
|
STp->logical_blk_num -
|
|
|
|
|
(STps->drv_file ? ntohl(STp->buffer->aux->last_mark_lbn) + 1 : 0):
|
|
|
|
|
-1;
|
|
|
|
|
}
|
|
|
|
|
STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD:ST_NOEOF;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (osst_get_logical_frame(STp, aSRpnt, -1, 1) < 0)
|
|
|
|
|
goto error;
|
|
|
|
|
/* we are not yet at the estimated frame, adjust our estimate of its physical position */
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Seek retry %d at ppos %d fsq %d (est %d) lbn %d (need %d)\n",
|
|
|
|
|
name, retries, ppos_estimate, STp->frame_seq_number, frame_seq_estimate,
|
|
|
|
|
STp->logical_blk_num, logical_blk_num);
|
|
|
|
|
#endif
|
|
|
|
|
if (frame_seq_estimate != STp->frame_seq_number)
|
|
|
|
|
ppos_estimate += frame_seq_estimate - STp->frame_seq_number;
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
error:
|
|
|
|
|
printk(KERN_ERR "%s:E: Couldn't seek to logical block %d (at %d), %d retries\n",
|
|
|
|
|
name, logical_blk_num, STp->logical_blk_num, retries);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* The values below are based on the OnStream frame payload size of 32K == 2**15,
|
|
|
|
|
* that is, OSST_FRAME_SHIFT + OSST_SECTOR_SHIFT must be 15. With a minimum block
|
|
|
|
|
* size of 512 bytes, we need to be able to resolve 32K/512 == 64 == 2**6 positions
|
2011-03-30 19:57:33 -06:00
|
|
|
|
* inside each frame. Finally, OSST_SECTOR_MASK == 2**OSST_FRAME_SHIFT - 1.
|
2005-04-16 16:20:36 -06:00
|
|
|
|
*/
|
|
|
|
|
#define OSST_FRAME_SHIFT 6
|
|
|
|
|
#define OSST_SECTOR_SHIFT 9
|
|
|
|
|
#define OSST_SECTOR_MASK 0x03F
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_get_sector(struct osst_tape * STp, struct osst_request ** aSRpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
int sector;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: Positioned at ppos %d, frame %d, lbn %d, file %d, blk %d, %cptr %d, eof %d\n",
|
|
|
|
|
name, STp->first_frame_position, STp->frame_seq_number, STp->logical_blk_num,
|
|
|
|
|
STp->ps[STp->partition].drv_file, STp->ps[STp->partition].drv_block,
|
|
|
|
|
STp->ps[STp->partition].rw == ST_WRITING?'w':'r',
|
|
|
|
|
STp->ps[STp->partition].rw == ST_WRITING?STp->buffer->buffer_bytes:
|
|
|
|
|
STp->buffer->read_pointer, STp->ps[STp->partition].eof);
|
|
|
|
|
#endif
|
|
|
|
|
/* do we know where we are inside a file? */
|
|
|
|
|
if (STp->ps[STp->partition].drv_block >= 0) {
|
|
|
|
|
sector = (STp->frame_in_buffer ? STp->first_frame_position-1 :
|
|
|
|
|
STp->first_frame_position) << OSST_FRAME_SHIFT;
|
|
|
|
|
if (STp->ps[STp->partition].rw == ST_WRITING)
|
|
|
|
|
sector |= (STp->buffer->buffer_bytes >> OSST_SECTOR_SHIFT) & OSST_SECTOR_MASK;
|
|
|
|
|
else
|
|
|
|
|
sector |= (STp->buffer->read_pointer >> OSST_SECTOR_SHIFT) & OSST_SECTOR_MASK;
|
|
|
|
|
} else {
|
|
|
|
|
sector = osst_get_frame_position(STp, aSRpnt);
|
|
|
|
|
if (sector > 0)
|
|
|
|
|
sector <<= OSST_FRAME_SHIFT;
|
|
|
|
|
}
|
|
|
|
|
return sector;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_seek_sector(struct osst_tape * STp, struct osst_request ** aSRpnt, int sector)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
struct st_partstat * STps = &(STp->ps[STp->partition]);
|
|
|
|
|
int frame = sector >> OSST_FRAME_SHIFT,
|
|
|
|
|
offset = (sector & OSST_SECTOR_MASK) << OSST_SECTOR_SHIFT,
|
|
|
|
|
r;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Seeking sector %d in frame %d at offset %d\n",
|
|
|
|
|
name, sector, frame, offset);
|
|
|
|
|
#endif
|
|
|
|
|
if (frame < 0 || frame >= STp->capacity) return (-ENXIO);
|
|
|
|
|
|
|
|
|
|
if (frame <= STp->first_data_ppos) {
|
|
|
|
|
STp->frame_seq_number = STp->logical_blk_num = STps->drv_file = STps->drv_block = 0;
|
|
|
|
|
return (osst_set_frame_position(STp, aSRpnt, frame, 0));
|
|
|
|
|
}
|
|
|
|
|
r = osst_set_frame_position(STp, aSRpnt, offset?frame:frame-1, 0);
|
|
|
|
|
if (r < 0) return r;
|
|
|
|
|
|
|
|
|
|
r = osst_get_logical_frame(STp, aSRpnt, -1, 1);
|
|
|
|
|
if (r < 0) return r;
|
|
|
|
|
|
|
|
|
|
if (osst_get_frame_position(STp, aSRpnt) != (offset?frame+1:frame)) return (-EIO);
|
|
|
|
|
|
|
|
|
|
if (offset) {
|
|
|
|
|
STp->logical_blk_num += offset / STp->block_size;
|
|
|
|
|
STp->buffer->read_pointer = offset;
|
|
|
|
|
STp->buffer->buffer_bytes -= offset;
|
|
|
|
|
} else {
|
|
|
|
|
STp->frame_seq_number++;
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
STp->logical_blk_num += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
|
|
|
|
|
STp->buffer->buffer_bytes = STp->buffer->read_pointer = 0;
|
|
|
|
|
}
|
|
|
|
|
STps->drv_file = ntohl(STp->buffer->aux->filemark_cnt);
|
|
|
|
|
if (STps->eof == ST_FM_HIT) {
|
|
|
|
|
STps->drv_file++;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
} else {
|
|
|
|
|
STps->drv_block = ntohl(STp->buffer->aux->last_mark_lbn)?
|
|
|
|
|
STp->logical_blk_num -
|
|
|
|
|
(STps->drv_file ? ntohl(STp->buffer->aux->last_mark_lbn) + 1 : 0):
|
|
|
|
|
-1;
|
|
|
|
|
}
|
|
|
|
|
STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD:ST_NOEOF;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: Now positioned at ppos %d, frame %d, lbn %d, file %d, blk %d, rptr %d, eof %d\n",
|
|
|
|
|
name, STp->first_frame_position, STp->frame_seq_number, STp->logical_blk_num,
|
|
|
|
|
STps->drv_file, STps->drv_block, STp->buffer->read_pointer, STps->eof);
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Read back the drive's internal buffer contents, as a part
|
|
|
|
|
* of the write error recovery mechanism for old OnStream
|
|
|
|
|
* firmware revisions.
|
|
|
|
|
* Precondition for this function to work: all frames in the
|
|
|
|
|
* drive's buffer must be of one type (DATA, MARK or EOD)!
|
|
|
|
|
*/
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_read_back_buffer_and_rewrite(struct osst_tape * STp, struct osst_request ** aSRpnt,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned int frame, unsigned int skip, int pending)
|
|
|
|
|
{
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt = * aSRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned char * buffer, * p;
|
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
|
|
|
|
int flag, new_frame, i;
|
|
|
|
|
int nframes = STp->cur_frames;
|
|
|
|
|
int blks_per_frame = ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
|
|
|
|
|
int frame_seq_number = ntohl(STp->buffer->aux->frame_seq_num)
|
|
|
|
|
- (nframes + pending - 1);
|
|
|
|
|
int logical_blk_num = ntohl(STp->buffer->aux->logical_blk_num)
|
|
|
|
|
- (nframes + pending - 1) * blks_per_frame;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
unsigned long startwait = jiffies;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
int dbg = debugging;
|
|
|
|
|
#endif
|
|
|
|
|
|
treewide: Use array_size() in vmalloc()
The vmalloc() function has no 2-factor argument form, so multiplication
factors need to be wrapped in array_size(). This patch replaces cases of:
vmalloc(a * b)
with:
vmalloc(array_size(a, b))
as well as handling cases of:
vmalloc(a * b * c)
with:
vmalloc(array3_size(a, b, c))
This does, however, attempt to ignore constant size factors like:
vmalloc(4 * 1024)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
vmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
vmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
vmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
vmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
vmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
vmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
vmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
vmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
vmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
vmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
vmalloc(
- sizeof(TYPE) * (COUNT_ID)
+ array_size(COUNT_ID, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * COUNT_ID
+ array_size(COUNT_ID, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * (COUNT_CONST)
+ array_size(COUNT_CONST, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * COUNT_CONST
+ array_size(COUNT_CONST, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(THING) * (COUNT_ID)
+ array_size(COUNT_ID, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * COUNT_ID
+ array_size(COUNT_ID, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * (COUNT_CONST)
+ array_size(COUNT_CONST, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * COUNT_CONST
+ array_size(COUNT_CONST, sizeof(THING))
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
vmalloc(
- SIZE * COUNT
+ array_size(COUNT, SIZE)
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
vmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
vmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
vmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
vmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
vmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
vmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
vmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
vmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
vmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
vmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
vmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
vmalloc(C1 * C2 * C3, ...)
|
vmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants.
@@
expression E1, E2;
constant C1, C2;
@@
(
vmalloc(C1 * C2, ...)
|
vmalloc(
- E1 * E2
+ array_size(E1, E2)
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 15:27:11 -06:00
|
|
|
|
if ((buffer = vmalloc(array_size((nframes + 1), OS_DATA_SIZE))) == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return (-EIO);
|
|
|
|
|
|
|
|
|
|
printk(KERN_INFO "%s:I: Reading back %d frames from drive buffer%s\n",
|
|
|
|
|
name, nframes, pending?" and one that was pending":"");
|
|
|
|
|
|
|
|
|
|
osst_copy_from_buffer(STp->buffer, (p = &buffer[nframes * OS_DATA_SIZE]));
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (pending && debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Pending frame %d (lblk %d), data %02x %02x %02x %02x\n",
|
|
|
|
|
name, frame_seq_number + nframes,
|
|
|
|
|
logical_blk_num + nframes * blks_per_frame,
|
|
|
|
|
p[0], p[1], p[2], p[3]);
|
|
|
|
|
#endif
|
|
|
|
|
for (i = 0, p = buffer; i < nframes; i++, p += OS_DATA_SIZE) {
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = 0x3C; /* Buffer Read */
|
|
|
|
|
cmd[1] = 6; /* Retrieve Faulty Block */
|
|
|
|
|
cmd[7] = 32768 >> 8;
|
|
|
|
|
cmd[8] = 32768 & 0xff;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, OS_FRAME_SIZE, DMA_FROM_DEVICE,
|
|
|
|
|
STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->syscall_result || !SRpnt) {
|
|
|
|
|
printk(KERN_ERR "%s:E: Failed to read frame back from OnStream buffer\n", name);
|
2005-09-10 01:26:54 -06:00
|
|
|
|
vfree(buffer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
osst_copy_from_buffer(STp->buffer, p);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Read back logical frame %d, data %02x %02x %02x %02x\n",
|
|
|
|
|
name, frame_seq_number + i, p[0], p[1], p[2], p[3]);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
osst_get_frame_position(STp, aSRpnt);
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Frames left in buffer: %d\n", name, STp->cur_frames);
|
|
|
|
|
#endif
|
|
|
|
|
/* Write synchronously so we can be sure we're OK again and don't have to recover recursively */
|
|
|
|
|
/* In the header we don't actually re-write the frames that fail, just the ones after them */
|
|
|
|
|
|
|
|
|
|
for (flag=1, new_frame=frame, p=buffer, i=0; i < nframes + pending; ) {
|
|
|
|
|
|
|
|
|
|
if (flag) {
|
|
|
|
|
if (STp->write_type == OS_WRITE_HEADER) {
|
|
|
|
|
i += skip;
|
|
|
|
|
p += skip * OS_DATA_SIZE;
|
|
|
|
|
}
|
|
|
|
|
else if (new_frame < 2990 && new_frame+skip+nframes+pending >= 2990)
|
|
|
|
|
new_frame = 3000-i;
|
|
|
|
|
else
|
|
|
|
|
new_frame += skip;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Position to frame %d, write fseq %d\n",
|
|
|
|
|
name, new_frame+i, frame_seq_number+i);
|
|
|
|
|
#endif
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, new_frame + i, 0);
|
|
|
|
|
osst_wait_ready(STp, aSRpnt, 60, OSST_WAIT_POSITION_COMPLETE);
|
|
|
|
|
osst_get_frame_position(STp, aSRpnt);
|
|
|
|
|
SRpnt = * aSRpnt;
|
|
|
|
|
|
|
|
|
|
if (new_frame > frame + 1000) {
|
|
|
|
|
printk(KERN_ERR "%s:E: Failed to find writable tape media\n", name);
|
2005-09-10 01:26:54 -06:00
|
|
|
|
vfree(buffer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if ( i >= nframes + pending ) break;
|
|
|
|
|
flag = 0;
|
|
|
|
|
}
|
|
|
|
|
osst_copy_to_buffer(STp->buffer, p);
|
|
|
|
|
/*
|
|
|
|
|
* IMPORTANT: for error recovery to work, _never_ queue frames with mixed frame type!
|
|
|
|
|
*/
|
|
|
|
|
osst_init_aux(STp, STp->buffer->aux->frame_type, frame_seq_number+i,
|
|
|
|
|
logical_blk_num + i*blks_per_frame,
|
|
|
|
|
ntohl(STp->buffer->aux->dat.dat_list[0].blk_sz), blks_per_frame);
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = WRITE_6;
|
|
|
|
|
cmd[1] = 1;
|
|
|
|
|
cmd[4] = 1;
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: About to write frame %d, seq %d, lbn %d, data %02x %02x %02x %02x\n",
|
|
|
|
|
name, new_frame+i, frame_seq_number+i, logical_blk_num + i*blks_per_frame,
|
|
|
|
|
p[0], p[1], p[2], p[3]);
|
|
|
|
|
#endif
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, OS_FRAME_SIZE, DMA_TO_DEVICE,
|
|
|
|
|
STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
|
|
|
|
|
if (STp->buffer->syscall_result)
|
|
|
|
|
flag = 1;
|
|
|
|
|
else {
|
|
|
|
|
p += OS_DATA_SIZE; i++;
|
|
|
|
|
|
|
|
|
|
/* if we just sent the last frame, wait till all successfully written */
|
|
|
|
|
if ( i == nframes + pending ) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Check re-write successful\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = WRITE_FILEMARKS;
|
|
|
|
|
cmd[1] = 1;
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
|
|
|
|
|
STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging) {
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Sleeping in re-write wait ready\n", name);
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name);
|
|
|
|
|
debugging = 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
flag = STp->buffer->syscall_result;
|
|
|
|
|
while ( !flag && time_before(jiffies, startwait + 60*HZ) ) {
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = TEST_UNIT_READY;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, STp->timeout,
|
|
|
|
|
MAX_RETRIES, 1);
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (SRpnt->sense[2] == 2 && SRpnt->sense[12] == 4 &&
|
|
|
|
|
(SRpnt->sense[13] == 1 || SRpnt->sense[13] == 8)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
/* in the process of becoming ready */
|
|
|
|
|
msleep(100);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (STp->buffer->syscall_result)
|
|
|
|
|
flag = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
debugging = dbg;
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Wait re-write finished\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
if (flag) {
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ((SRpnt->sense[ 2] & 0x0f) == 13 &&
|
|
|
|
|
SRpnt->sense[12] == 0 &&
|
|
|
|
|
SRpnt->sense[13] == 2) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk(KERN_ERR "%s:E: Volume overflow in write error recovery\n", name);
|
2005-09-10 01:26:54 -06:00
|
|
|
|
vfree(buffer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return (-EIO); /* hit end of tape = fail */
|
|
|
|
|
}
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
i = ((SRpnt->sense[3] << 24) |
|
|
|
|
|
(SRpnt->sense[4] << 16) |
|
|
|
|
|
(SRpnt->sense[5] << 8) |
|
|
|
|
|
SRpnt->sense[6] ) - new_frame;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
p = &buffer[i * OS_DATA_SIZE];
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Additional write error at %d\n", name, new_frame+i);
|
|
|
|
|
#endif
|
|
|
|
|
osst_get_frame_position(STp, aSRpnt);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: reported frame positions: host = %d, tape = %d, buffer = %d\n",
|
|
|
|
|
name, STp->first_frame_position, STp->last_frame_position, STp->cur_frames);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (flag) {
|
|
|
|
|
/* error recovery did not successfully complete */
|
|
|
|
|
printk(KERN_ERR "%s:D: Write error recovery failed in %s\n", name,
|
|
|
|
|
STp->write_type == OS_WRITE_HEADER?"header":"body");
|
|
|
|
|
}
|
|
|
|
|
if (!pending)
|
|
|
|
|
osst_copy_to_buffer(STp->buffer, p); /* so buffer content == at entry in all cases */
|
2005-09-10 01:26:54 -06:00
|
|
|
|
vfree(buffer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_reposition_and_retry(struct osst_tape * STp, struct osst_request ** aSRpnt,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned int frame, unsigned int skip, int pending)
|
|
|
|
|
{
|
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
int expected = 0;
|
|
|
|
|
int attempts = 1000 / skip;
|
|
|
|
|
int flag = 1;
|
|
|
|
|
unsigned long startwait = jiffies;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
int dbg = debugging;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
while (attempts && time_before(jiffies, startwait + 60*HZ)) {
|
|
|
|
|
if (flag) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
debugging = dbg;
|
|
|
|
|
#endif
|
|
|
|
|
if (frame < 2990 && frame+skip+STp->cur_frames+pending >= 2990)
|
|
|
|
|
frame = 3000-skip;
|
|
|
|
|
expected = frame+skip+STp->cur_frames+pending;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Position to fppos %d, re-write from fseq %d\n",
|
|
|
|
|
name, frame+skip, STp->frame_seq_number-STp->cur_frames-pending);
|
|
|
|
|
#endif
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, frame + skip, 1);
|
|
|
|
|
flag = 0;
|
|
|
|
|
attempts--;
|
2005-11-07 02:01:20 -07:00
|
|
|
|
schedule_timeout_interruptible(msecs_to_jiffies(100));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
if (osst_get_frame_position(STp, aSRpnt) < 0) { /* additional write error */
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Addl error, host %d, tape %d, buffer %d\n",
|
|
|
|
|
name, STp->first_frame_position,
|
|
|
|
|
STp->last_frame_position, STp->cur_frames);
|
|
|
|
|
#endif
|
|
|
|
|
frame = STp->last_frame_position;
|
|
|
|
|
flag = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (pending && STp->cur_frames < 50) {
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = WRITE_6;
|
|
|
|
|
cmd[1] = 1;
|
|
|
|
|
cmd[4] = 1;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: About to write pending fseq %d at fppos %d\n",
|
|
|
|
|
name, STp->frame_seq_number-1, STp->first_frame_position);
|
|
|
|
|
#endif
|
|
|
|
|
SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, OS_FRAME_SIZE, DMA_TO_DEVICE,
|
|
|
|
|
STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
|
|
|
|
|
if (STp->buffer->syscall_result) { /* additional write error */
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ((SRpnt->sense[ 2] & 0x0f) == 13 &&
|
|
|
|
|
SRpnt->sense[12] == 0 &&
|
|
|
|
|
SRpnt->sense[13] == 2) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk(KERN_ERR
|
|
|
|
|
"%s:E: Volume overflow in write error recovery\n",
|
|
|
|
|
name);
|
|
|
|
|
break; /* hit end of tape = fail */
|
|
|
|
|
}
|
|
|
|
|
flag = 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
pending = 0;
|
|
|
|
|
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (STp->cur_frames == 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
debugging = dbg;
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Wait re-write finished\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
if (STp->first_frame_position != expected) {
|
|
|
|
|
printk(KERN_ERR "%s:A: Actual position %d - expected %d\n",
|
|
|
|
|
name, STp->first_frame_position, expected);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging) {
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Sleeping in re-write wait ready\n", name);
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name);
|
|
|
|
|
debugging = 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2005-11-07 02:01:20 -07:00
|
|
|
|
schedule_timeout_interruptible(msecs_to_jiffies(100));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
printk(KERN_ERR "%s:E: Failed to find valid tape media\n", name);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
debugging = dbg;
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Error recovery algorithm for the OnStream tape.
|
|
|
|
|
*/
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_write_error_recovery(struct osst_tape * STp, struct osst_request ** aSRpnt, int pending)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt = * aSRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
struct st_partstat * STps = & STp->ps[STp->partition];
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
int retval = 0;
|
|
|
|
|
int rw_state;
|
|
|
|
|
unsigned int frame, skip;
|
|
|
|
|
|
|
|
|
|
rw_state = STps->rw;
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ((SRpnt->sense[ 2] & 0x0f) != 3
|
|
|
|
|
|| SRpnt->sense[12] != 12
|
|
|
|
|
|| SRpnt->sense[13] != 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Write error recovery cannot handle %02x:%02x:%02x\n", name,
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
SRpnt->sense[2], SRpnt->sense[12], SRpnt->sense[13]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
frame = (SRpnt->sense[3] << 24) |
|
|
|
|
|
(SRpnt->sense[4] << 16) |
|
|
|
|
|
(SRpnt->sense[5] << 8) |
|
|
|
|
|
SRpnt->sense[6];
|
|
|
|
|
skip = SRpnt->sense[9];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Detected physical bad frame at %u, advised to skip %d\n", name, frame, skip);
|
|
|
|
|
#endif
|
|
|
|
|
osst_get_frame_position(STp, aSRpnt);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: reported frame positions: host = %d, tape = %d\n",
|
|
|
|
|
name, STp->first_frame_position, STp->last_frame_position);
|
|
|
|
|
#endif
|
|
|
|
|
switch (STp->write_type) {
|
|
|
|
|
case OS_WRITE_DATA:
|
|
|
|
|
case OS_WRITE_EOD:
|
|
|
|
|
case OS_WRITE_NEW_MARK:
|
|
|
|
|
printk(KERN_WARNING
|
|
|
|
|
"%s:I: Relocating %d buffered logical frames from position %u to %u\n",
|
|
|
|
|
name, STp->cur_frames, frame, (frame + skip > 3000 && frame < 3000)?3000:frame + skip);
|
|
|
|
|
if (STp->os_fw_rev >= 10600)
|
|
|
|
|
retval = osst_reposition_and_retry(STp, aSRpnt, frame, skip, pending);
|
|
|
|
|
else
|
|
|
|
|
retval = osst_read_back_buffer_and_rewrite(STp, aSRpnt, frame, skip, pending);
|
|
|
|
|
printk(KERN_WARNING "%s:%s: %sWrite error%srecovered\n", name,
|
|
|
|
|
retval?"E" :"I",
|
|
|
|
|
retval?"" :"Don't worry, ",
|
|
|
|
|
retval?" not ":" ");
|
|
|
|
|
break;
|
|
|
|
|
case OS_WRITE_LAST_MARK:
|
|
|
|
|
printk(KERN_ERR "%s:E: Bad frame in update last marker, fatal\n", name);
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, frame + STp->cur_frames + pending, 0);
|
|
|
|
|
retval = -EIO;
|
|
|
|
|
break;
|
|
|
|
|
case OS_WRITE_HEADER:
|
|
|
|
|
printk(KERN_WARNING "%s:I: Bad frame in header partition, skipped\n", name);
|
|
|
|
|
retval = osst_read_back_buffer_and_rewrite(STp, aSRpnt, frame, 1, pending);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
printk(KERN_INFO "%s:I: Bad frame in filler, ignored\n", name);
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, frame + STp->cur_frames + pending, 0);
|
|
|
|
|
}
|
|
|
|
|
osst_get_frame_position(STp, aSRpnt);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Positioning complete, cur_frames %d, pos %d, tape pos %d\n",
|
|
|
|
|
name, STp->cur_frames, STp->first_frame_position, STp->last_frame_position);
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: next logical frame to write: %d\n", name, STp->logical_blk_num);
|
|
|
|
|
#endif
|
|
|
|
|
if (retval == 0) {
|
|
|
|
|
STp->recover_count++;
|
|
|
|
|
STp->recover_erreg++;
|
|
|
|
|
} else
|
|
|
|
|
STp->abort_count++;
|
|
|
|
|
|
|
|
|
|
STps->rw = rw_state;
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_space_over_filemarks_backward(struct osst_tape * STp, struct osst_request ** aSRpnt,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
int mt_op, int mt_count)
|
|
|
|
|
{
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
int cnt;
|
|
|
|
|
int last_mark_ppos = -1;
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reached space_over_filemarks_backwards %d %d\n", name, mt_op, mt_count);
|
|
|
|
|
#endif
|
|
|
|
|
if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks_bwd\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return -EIO;
|
|
|
|
|
}
|
|
|
|
|
if (STp->linux_media_version >= 4) {
|
|
|
|
|
/*
|
|
|
|
|
* direct lookup in header filemark list
|
|
|
|
|
*/
|
|
|
|
|
cnt = ntohl(STp->buffer->aux->filemark_cnt);
|
|
|
|
|
if (STp->header_ok &&
|
|
|
|
|
STp->header_cache != NULL &&
|
|
|
|
|
(cnt - mt_count) >= 0 &&
|
|
|
|
|
(cnt - mt_count) < OS_FM_TAB_MAX &&
|
|
|
|
|
(cnt - mt_count) < STp->filemark_cnt &&
|
|
|
|
|
STp->header_cache->dat_fm_tab.fm_tab_ent[cnt-1] == STp->buffer->aux->last_mark_ppos)
|
|
|
|
|
|
|
|
|
|
last_mark_ppos = ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[cnt - mt_count]);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (STp->header_cache == NULL || (cnt - mt_count) < 0 || (cnt - mt_count) >= OS_FM_TAB_MAX)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Filemark lookup fail due to %s\n", name,
|
|
|
|
|
STp->header_cache == NULL?"lack of header cache":"count out of range");
|
|
|
|
|
else
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Filemark lookup: prev mark %d (%s), skip %d to %d\n",
|
|
|
|
|
name, cnt,
|
|
|
|
|
((cnt == -1 && ntohl(STp->buffer->aux->last_mark_ppos) == -1) ||
|
|
|
|
|
(STp->header_cache->dat_fm_tab.fm_tab_ent[cnt-1] ==
|
|
|
|
|
STp->buffer->aux->last_mark_ppos))?"match":"error",
|
|
|
|
|
mt_count, last_mark_ppos);
|
|
|
|
|
#endif
|
|
|
|
|
if (last_mark_ppos > 10 && last_mark_ppos < STp->eod_frame_ppos) {
|
|
|
|
|
osst_position_tape_and_confirm(STp, aSRpnt, last_mark_ppos);
|
|
|
|
|
if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: Couldn't get logical blk num in space_filemarks\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
|
|
|
|
|
printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n",
|
|
|
|
|
name, last_mark_ppos);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
goto found;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reverting to scan filemark backwards\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
cnt = 0;
|
|
|
|
|
while (cnt != mt_count) {
|
|
|
|
|
last_mark_ppos = ntohl(STp->buffer->aux->last_mark_ppos);
|
|
|
|
|
if (last_mark_ppos == -1)
|
|
|
|
|
return (-EIO);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Positioning to last mark at %d\n", name, last_mark_ppos);
|
|
|
|
|
#endif
|
|
|
|
|
osst_position_tape_and_confirm(STp, aSRpnt, last_mark_ppos);
|
|
|
|
|
cnt++;
|
|
|
|
|
if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
|
|
|
|
|
printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n",
|
|
|
|
|
name, last_mark_ppos);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
found:
|
|
|
|
|
if (mt_op == MTBSFM) {
|
|
|
|
|
STp->frame_seq_number++;
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
STp->buffer->buffer_bytes = 0;
|
|
|
|
|
STp->buffer->read_pointer = 0;
|
|
|
|
|
STp->logical_blk_num += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* ADRL 1.1 compatible "slow" space filemarks fwd version
|
|
|
|
|
*
|
|
|
|
|
* Just scans for the filemark sequentially.
|
|
|
|
|
*/
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_space_over_filemarks_forward_slow(struct osst_tape * STp, struct osst_request ** aSRpnt,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
int mt_op, int mt_count)
|
|
|
|
|
{
|
|
|
|
|
int cnt = 0;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reached space_over_filemarks_forward_slow %d %d\n", name, mt_op, mt_count);
|
|
|
|
|
#endif
|
|
|
|
|
if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks_fwd\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
while (1) {
|
|
|
|
|
if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_MARKER)
|
|
|
|
|
cnt++;
|
|
|
|
|
if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_EOD) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: space_fwd: EOD reached\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
if (STp->first_frame_position > STp->eod_frame_ppos+1) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: EOD position corrected (%d=>%d)\n",
|
|
|
|
|
name, STp->eod_frame_ppos, STp->first_frame_position-1);
|
|
|
|
|
#endif
|
|
|
|
|
STp->eod_frame_ppos = STp->first_frame_position-1;
|
|
|
|
|
}
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (cnt == mt_count)
|
|
|
|
|
break;
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
}
|
|
|
|
|
if (mt_op == MTFSF) {
|
|
|
|
|
STp->frame_seq_number++;
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
STp->buffer->buffer_bytes = 0;
|
|
|
|
|
STp->buffer->read_pointer = 0;
|
|
|
|
|
STp->logical_blk_num += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Fast linux specific version of OnStream FSF
|
|
|
|
|
*/
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_space_over_filemarks_forward_fast(struct osst_tape * STp, struct osst_request ** aSRpnt,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
int mt_op, int mt_count)
|
|
|
|
|
{
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
int cnt = 0,
|
|
|
|
|
next_mark_ppos = -1;
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reached space_over_filemarks_forward_fast %d %d\n", name, mt_op, mt_count);
|
|
|
|
|
#endif
|
|
|
|
|
if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks_fwd\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (STp->linux_media_version >= 4) {
|
|
|
|
|
/*
|
|
|
|
|
* direct lookup in header filemark list
|
|
|
|
|
*/
|
|
|
|
|
cnt = ntohl(STp->buffer->aux->filemark_cnt) - 1;
|
|
|
|
|
if (STp->header_ok &&
|
|
|
|
|
STp->header_cache != NULL &&
|
|
|
|
|
(cnt + mt_count) < OS_FM_TAB_MAX &&
|
|
|
|
|
(cnt + mt_count) < STp->filemark_cnt &&
|
|
|
|
|
((cnt == -1 && ntohl(STp->buffer->aux->last_mark_ppos) == -1) ||
|
|
|
|
|
(STp->header_cache->dat_fm_tab.fm_tab_ent[cnt] == STp->buffer->aux->last_mark_ppos)))
|
|
|
|
|
|
|
|
|
|
next_mark_ppos = ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[cnt + mt_count]);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (STp->header_cache == NULL || (cnt + mt_count) >= OS_FM_TAB_MAX)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Filemark lookup fail due to %s\n", name,
|
|
|
|
|
STp->header_cache == NULL?"lack of header cache":"count out of range");
|
|
|
|
|
else
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Filemark lookup: prev mark %d (%s), skip %d to %d\n",
|
|
|
|
|
name, cnt,
|
|
|
|
|
((cnt == -1 && ntohl(STp->buffer->aux->last_mark_ppos) == -1) ||
|
|
|
|
|
(STp->header_cache->dat_fm_tab.fm_tab_ent[cnt] ==
|
|
|
|
|
STp->buffer->aux->last_mark_ppos))?"match":"error",
|
|
|
|
|
mt_count, next_mark_ppos);
|
|
|
|
|
#endif
|
|
|
|
|
if (next_mark_ppos <= 10 || next_mark_ppos > STp->eod_frame_ppos) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reverting to slow filemark space\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return osst_space_over_filemarks_forward_slow(STp, aSRpnt, mt_op, mt_count);
|
|
|
|
|
} else {
|
|
|
|
|
osst_position_tape_and_confirm(STp, aSRpnt, next_mark_ppos);
|
|
|
|
|
if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n",
|
|
|
|
|
name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
|
|
|
|
|
printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n",
|
|
|
|
|
name, next_mark_ppos);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (ntohl(STp->buffer->aux->filemark_cnt) != cnt + mt_count) {
|
|
|
|
|
printk(KERN_WARNING "%s:W: Expected to find marker %d at ppos %d, not %d\n",
|
|
|
|
|
name, cnt+mt_count, next_mark_ppos,
|
|
|
|
|
ntohl(STp->buffer->aux->filemark_cnt));
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/*
|
|
|
|
|
* Find nearest (usually previous) marker, then jump from marker to marker
|
|
|
|
|
*/
|
|
|
|
|
while (1) {
|
|
|
|
|
if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_MARKER)
|
|
|
|
|
break;
|
|
|
|
|
if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_EOD) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: space_fwd: EOD reached\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (ntohl(STp->buffer->aux->filemark_cnt) == 0) {
|
|
|
|
|
if (STp->first_mark_ppos == -1) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reverting to slow filemark space\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return osst_space_over_filemarks_forward_slow(STp, aSRpnt, mt_op, mt_count);
|
|
|
|
|
}
|
|
|
|
|
osst_position_tape_and_confirm(STp, aSRpnt, STp->first_mark_ppos);
|
|
|
|
|
if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: Couldn't get logical blk num in space_filemarks_fwd_fast\n",
|
|
|
|
|
name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
|
|
|
|
|
printk(KERN_WARNING "%s:W: Expected to find filemark at %d\n",
|
|
|
|
|
name, STp->first_mark_ppos);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (osst_space_over_filemarks_backward(STp, aSRpnt, MTBSF, 1) < 0)
|
|
|
|
|
return (-EIO);
|
|
|
|
|
mt_count++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
cnt++;
|
|
|
|
|
while (cnt != mt_count) {
|
|
|
|
|
next_mark_ppos = ntohl(STp->buffer->aux->next_mark_ppos);
|
|
|
|
|
if (!next_mark_ppos || next_mark_ppos > STp->eod_frame_ppos) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reverting to slow filemark space\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return osst_space_over_filemarks_forward_slow(STp, aSRpnt, mt_op, mt_count - cnt);
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
else printk(OSST_DEB_MSG "%s:D: Positioning to next mark at %d\n", name, next_mark_ppos);
|
|
|
|
|
#endif
|
|
|
|
|
osst_position_tape_and_confirm(STp, aSRpnt, next_mark_ppos);
|
|
|
|
|
cnt++;
|
|
|
|
|
if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n",
|
|
|
|
|
name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
|
|
|
|
|
printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n",
|
|
|
|
|
name, next_mark_ppos);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (mt_op == MTFSF) {
|
|
|
|
|
STp->frame_seq_number++;
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
STp->buffer->buffer_bytes = 0;
|
|
|
|
|
STp->buffer->read_pointer = 0;
|
|
|
|
|
STp->logical_blk_num += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* In debug mode, we want to see as many errors as possible
|
|
|
|
|
* to test the error recovery mechanism.
|
|
|
|
|
*/
|
|
|
|
|
#if DEBUG
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static void osst_set_retries(struct osst_tape * STp, struct osst_request ** aSRpnt, int retries)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt = * aSRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = MODE_SELECT;
|
|
|
|
|
cmd[1] = 0x10;
|
|
|
|
|
cmd[4] = NUMBER_RETRIES_PAGE_LENGTH + MODE_HEADER_LENGTH;
|
|
|
|
|
|
|
|
|
|
(STp->buffer)->b_data[0] = cmd[4] - 1;
|
|
|
|
|
(STp->buffer)->b_data[1] = 0; /* Medium Type - ignoring */
|
|
|
|
|
(STp->buffer)->b_data[2] = 0; /* Reserved */
|
|
|
|
|
(STp->buffer)->b_data[3] = 0; /* Block Descriptor Length */
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 0] = NUMBER_RETRIES_PAGE | (1 << 7);
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 1] = 2;
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] = 4;
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 3] = retries;
|
|
|
|
|
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Setting number of retries on OnStream tape to %d\n", name, retries);
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->syscall_result)
|
|
|
|
|
printk (KERN_ERR "%s:D: Couldn't set retries to %d\n", name, retries);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_write_filemark(struct osst_tape * STp, struct osst_request ** aSRpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
int result;
|
|
|
|
|
int this_mark_ppos = STp->first_frame_position;
|
|
|
|
|
int this_mark_lbn = STp->logical_blk_num;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (STp->raw) return 0;
|
|
|
|
|
|
|
|
|
|
STp->write_type = OS_WRITE_NEW_MARK;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Writing Filemark %i at fppos %d (fseq %d, lblk %d)\n",
|
|
|
|
|
name, STp->filemark_cnt, this_mark_ppos, STp->frame_seq_number, this_mark_lbn);
|
|
|
|
|
#endif
|
|
|
|
|
STp->dirty = 1;
|
|
|
|
|
result = osst_flush_write_buffer(STp, aSRpnt);
|
|
|
|
|
result |= osst_flush_drive_buffer(STp, aSRpnt);
|
|
|
|
|
STp->last_mark_ppos = this_mark_ppos;
|
|
|
|
|
STp->last_mark_lbn = this_mark_lbn;
|
|
|
|
|
if (STp->header_cache != NULL && STp->filemark_cnt < OS_FM_TAB_MAX)
|
|
|
|
|
STp->header_cache->dat_fm_tab.fm_tab_ent[STp->filemark_cnt] = htonl(this_mark_ppos);
|
|
|
|
|
if (STp->filemark_cnt++ == 0)
|
|
|
|
|
STp->first_mark_ppos = this_mark_ppos;
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_write_eod(struct osst_tape * STp, struct osst_request ** aSRpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
int result;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (STp->raw) return 0;
|
|
|
|
|
|
|
|
|
|
STp->write_type = OS_WRITE_EOD;
|
|
|
|
|
STp->eod_frame_ppos = STp->first_frame_position;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Writing EOD at fppos %d (fseq %d, lblk %d)\n", name,
|
|
|
|
|
STp->eod_frame_ppos, STp->frame_seq_number, STp->logical_blk_num);
|
|
|
|
|
#endif
|
|
|
|
|
STp->dirty = 1;
|
|
|
|
|
|
|
|
|
|
result = osst_flush_write_buffer(STp, aSRpnt);
|
|
|
|
|
result |= osst_flush_drive_buffer(STp, aSRpnt);
|
|
|
|
|
STp->eod_frame_lfa = --(STp->frame_seq_number);
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_write_filler(struct osst_tape * STp, struct osst_request ** aSRpnt, int where, int count)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reached onstream write filler group %d\n", name, where);
|
|
|
|
|
#endif
|
|
|
|
|
osst_wait_ready(STp, aSRpnt, 60 * 5, 0);
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, where, 0);
|
|
|
|
|
STp->write_type = OS_WRITE_FILLER;
|
|
|
|
|
while (count--) {
|
|
|
|
|
memcpy(STp->buffer->b_data, "Filler", 6);
|
|
|
|
|
STp->buffer->buffer_bytes = 6;
|
|
|
|
|
STp->dirty = 1;
|
|
|
|
|
if (osst_flush_write_buffer(STp, aSRpnt)) {
|
|
|
|
|
printk(KERN_INFO "%s:I: Couldn't write filler frame\n", name);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Exiting onstream write filler group\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return osst_flush_drive_buffer(STp, aSRpnt);
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int __osst_write_header(struct osst_tape * STp, struct osst_request ** aSRpnt, int where, int count)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
int result;
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reached onstream write header group %d\n", name, where);
|
|
|
|
|
#endif
|
|
|
|
|
osst_wait_ready(STp, aSRpnt, 60 * 5, 0);
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, where, 0);
|
|
|
|
|
STp->write_type = OS_WRITE_HEADER;
|
|
|
|
|
while (count--) {
|
|
|
|
|
osst_copy_to_buffer(STp->buffer, (unsigned char *)STp->header_cache);
|
|
|
|
|
STp->buffer->buffer_bytes = sizeof(os_header_t);
|
|
|
|
|
STp->dirty = 1;
|
|
|
|
|
if (osst_flush_write_buffer(STp, aSRpnt)) {
|
|
|
|
|
printk(KERN_INFO "%s:I: Couldn't write header frame\n", name);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
result = osst_flush_drive_buffer(STp, aSRpnt);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Write onstream header group %s\n", name, result?"failed":"done");
|
|
|
|
|
#endif
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_write_header(struct osst_tape * STp, struct osst_request ** aSRpnt, int locate_eod)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
os_header_t * header;
|
|
|
|
|
int result;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Writing tape header\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
if (STp->raw) return 0;
|
|
|
|
|
|
|
|
|
|
if (STp->header_cache == NULL) {
|
2010-11-08 16:09:25 -07:00
|
|
|
|
if ((STp->header_cache = vmalloc(sizeof(os_header_t))) == NULL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk(KERN_ERR "%s:E: Failed to allocate header cache\n", name);
|
|
|
|
|
return (-ENOMEM);
|
|
|
|
|
}
|
|
|
|
|
memset(STp->header_cache, 0, sizeof(os_header_t));
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Allocated and cleared memory for header cache\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
if (STp->header_ok) STp->update_frame_cntr++;
|
|
|
|
|
else STp->update_frame_cntr = 0;
|
|
|
|
|
|
|
|
|
|
header = STp->header_cache;
|
|
|
|
|
strcpy(header->ident_str, "ADR_SEQ");
|
|
|
|
|
header->major_rev = 1;
|
|
|
|
|
header->minor_rev = 4;
|
|
|
|
|
header->ext_trk_tb_off = htons(17192);
|
|
|
|
|
header->pt_par_num = 1;
|
|
|
|
|
header->partition[0].partition_num = OS_DATA_PARTITION;
|
|
|
|
|
header->partition[0].par_desc_ver = OS_PARTITION_VERSION;
|
|
|
|
|
header->partition[0].wrt_pass_cntr = htons(STp->wrt_pass_cntr);
|
|
|
|
|
header->partition[0].first_frame_ppos = htonl(STp->first_data_ppos);
|
|
|
|
|
header->partition[0].last_frame_ppos = htonl(STp->capacity);
|
|
|
|
|
header->partition[0].eod_frame_ppos = htonl(STp->eod_frame_ppos);
|
|
|
|
|
header->cfg_col_width = htonl(20);
|
|
|
|
|
header->dat_col_width = htonl(1500);
|
|
|
|
|
header->qfa_col_width = htonl(0);
|
|
|
|
|
header->ext_track_tb.nr_stream_part = 1;
|
|
|
|
|
header->ext_track_tb.et_ent_sz = 32;
|
|
|
|
|
header->ext_track_tb.dat_ext_trk_ey.et_part_num = 0;
|
|
|
|
|
header->ext_track_tb.dat_ext_trk_ey.fmt = 1;
|
|
|
|
|
header->ext_track_tb.dat_ext_trk_ey.fm_tab_off = htons(17736);
|
|
|
|
|
header->ext_track_tb.dat_ext_trk_ey.last_hlb_hi = 0;
|
|
|
|
|
header->ext_track_tb.dat_ext_trk_ey.last_hlb = htonl(STp->eod_frame_lfa);
|
|
|
|
|
header->ext_track_tb.dat_ext_trk_ey.last_pp = htonl(STp->eod_frame_ppos);
|
|
|
|
|
header->dat_fm_tab.fm_part_num = 0;
|
|
|
|
|
header->dat_fm_tab.fm_tab_ent_sz = 4;
|
|
|
|
|
header->dat_fm_tab.fm_tab_ent_cnt = htons(STp->filemark_cnt<OS_FM_TAB_MAX?
|
|
|
|
|
STp->filemark_cnt:OS_FM_TAB_MAX);
|
|
|
|
|
|
|
|
|
|
result = __osst_write_header(STp, aSRpnt, 0xbae, 5);
|
|
|
|
|
if (STp->update_frame_cntr == 0)
|
|
|
|
|
osst_write_filler(STp, aSRpnt, 0xbb3, 5);
|
|
|
|
|
result &= __osst_write_header(STp, aSRpnt, 5, 5);
|
|
|
|
|
|
|
|
|
|
if (locate_eod) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Locating back to eod frame addr %d\n", name, STp->eod_frame_ppos);
|
|
|
|
|
#endif
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, STp->eod_frame_ppos, 0);
|
|
|
|
|
}
|
|
|
|
|
if (result)
|
|
|
|
|
printk(KERN_ERR "%s:E: Write header failed\n", name);
|
|
|
|
|
else {
|
|
|
|
|
memcpy(STp->application_sig, "LIN4", 4);
|
|
|
|
|
STp->linux_media = 1;
|
|
|
|
|
STp->linux_media_version = 4;
|
|
|
|
|
STp->header_ok = 1;
|
|
|
|
|
}
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_reset_header(struct osst_tape * STp, struct osst_request ** aSRpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
if (STp->header_cache != NULL)
|
|
|
|
|
memset(STp->header_cache, 0, sizeof(os_header_t));
|
|
|
|
|
|
|
|
|
|
STp->logical_blk_num = STp->frame_seq_number = 0;
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
STp->eod_frame_ppos = STp->first_data_ppos = 0x0000000A;
|
|
|
|
|
STp->filemark_cnt = 0;
|
|
|
|
|
STp->first_mark_ppos = STp->last_mark_ppos = STp->last_mark_lbn = -1;
|
|
|
|
|
return osst_write_header(STp, aSRpnt, 1);
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int __osst_analyze_headers(struct osst_tape * STp, struct osst_request ** aSRpnt, int ppos)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
os_header_t * header;
|
|
|
|
|
os_aux_t * aux;
|
|
|
|
|
char id_string[8];
|
|
|
|
|
int linux_media_version,
|
|
|
|
|
update_frame_cntr;
|
|
|
|
|
|
|
|
|
|
if (STp->raw)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
if (ppos == 5 || ppos == 0xbae || STp->buffer->syscall_result) {
|
|
|
|
|
if (osst_set_frame_position(STp, aSRpnt, ppos, 0))
|
|
|
|
|
printk(KERN_WARNING "%s:W: Couldn't position tape\n", name);
|
|
|
|
|
osst_wait_ready(STp, aSRpnt, 60 * 15, 0);
|
|
|
|
|
if (osst_initiate_read (STp, aSRpnt)) {
|
|
|
|
|
printk(KERN_WARNING "%s:W: Couldn't initiate read\n", name);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (osst_read_frame(STp, aSRpnt, 180)) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Couldn't read header frame\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
header = (os_header_t *) STp->buffer->b_data; /* warning: only first segment addressable */
|
|
|
|
|
aux = STp->buffer->aux;
|
|
|
|
|
if (aux->frame_type != OS_FRAME_TYPE_HEADER) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping non-header frame (%d)\n", name, ppos);
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (ntohl(aux->frame_seq_num) != 0 ||
|
|
|
|
|
ntohl(aux->logical_blk_num) != 0 ||
|
|
|
|
|
aux->partition.partition_num != OS_CONFIG_PARTITION ||
|
|
|
|
|
ntohl(aux->partition.first_frame_ppos) != 0 ||
|
|
|
|
|
ntohl(aux->partition.last_frame_ppos) != 0xbb7 ) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Invalid header frame (%d,%d,%d,%d,%d)\n", name,
|
|
|
|
|
ntohl(aux->frame_seq_num), ntohl(aux->logical_blk_num),
|
|
|
|
|
aux->partition.partition_num, ntohl(aux->partition.first_frame_ppos),
|
|
|
|
|
ntohl(aux->partition.last_frame_ppos));
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (strncmp(header->ident_str, "ADR_SEQ", 7) != 0 &&
|
|
|
|
|
strncmp(header->ident_str, "ADR-SEQ", 7) != 0) {
|
|
|
|
|
strlcpy(id_string, header->ident_str, 8);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Invalid header identification string %s\n", name, id_string);
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
update_frame_cntr = ntohl(aux->update_frame_cntr);
|
|
|
|
|
if (update_frame_cntr < STp->update_frame_cntr) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping frame %d with update_frame_counter %d<%d\n",
|
|
|
|
|
name, ppos, update_frame_cntr, STp->update_frame_cntr);
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (header->major_rev != 1 || header->minor_rev != 4 ) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: %s revision %d.%d detected (1.4 supported)\n",
|
|
|
|
|
name, (header->major_rev != 1 || header->minor_rev < 2 ||
|
|
|
|
|
header->minor_rev > 4 )? "Invalid" : "Warning:",
|
|
|
|
|
header->major_rev, header->minor_rev);
|
|
|
|
|
#endif
|
|
|
|
|
if (header->major_rev != 1 || header->minor_rev < 2 || header->minor_rev > 4)
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (header->pt_par_num != 1)
|
|
|
|
|
printk(KERN_INFO "%s:W: %d partitions defined, only one supported\n",
|
|
|
|
|
name, header->pt_par_num);
|
|
|
|
|
#endif
|
|
|
|
|
memcpy(id_string, aux->application_sig, 4);
|
|
|
|
|
id_string[4] = 0;
|
|
|
|
|
if (memcmp(id_string, "LIN", 3) == 0) {
|
|
|
|
|
STp->linux_media = 1;
|
|
|
|
|
linux_media_version = id_string[3] - '0';
|
|
|
|
|
if (linux_media_version != 4)
|
|
|
|
|
printk(KERN_INFO "%s:I: Linux media version %d detected (current 4)\n",
|
|
|
|
|
name, linux_media_version);
|
|
|
|
|
} else {
|
|
|
|
|
printk(KERN_WARNING "%s:W: Non Linux media detected (%s)\n", name, id_string);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (linux_media_version < STp->linux_media_version) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping frame %d with linux_media_version %d\n",
|
|
|
|
|
name, ppos, linux_media_version);
|
|
|
|
|
#endif
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (linux_media_version > STp->linux_media_version) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Frame %d sets linux_media_version to %d\n",
|
|
|
|
|
name, ppos, linux_media_version);
|
|
|
|
|
#endif
|
|
|
|
|
memcpy(STp->application_sig, id_string, 5);
|
|
|
|
|
STp->linux_media_version = linux_media_version;
|
|
|
|
|
STp->update_frame_cntr = -1;
|
|
|
|
|
}
|
|
|
|
|
if (update_frame_cntr > STp->update_frame_cntr) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Frame %d sets update_frame_counter to %d\n",
|
|
|
|
|
name, ppos, update_frame_cntr);
|
|
|
|
|
#endif
|
|
|
|
|
if (STp->header_cache == NULL) {
|
2010-11-08 16:09:25 -07:00
|
|
|
|
if ((STp->header_cache = vmalloc(sizeof(os_header_t))) == NULL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk(KERN_ERR "%s:E: Failed to allocate header cache\n", name);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Allocated memory for header cache\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
osst_copy_from_buffer(STp->buffer, (unsigned char *)STp->header_cache);
|
|
|
|
|
header = STp->header_cache; /* further accesses from cached (full) copy */
|
|
|
|
|
|
|
|
|
|
STp->wrt_pass_cntr = ntohs(header->partition[0].wrt_pass_cntr);
|
|
|
|
|
STp->first_data_ppos = ntohl(header->partition[0].first_frame_ppos);
|
|
|
|
|
STp->eod_frame_ppos = ntohl(header->partition[0].eod_frame_ppos);
|
|
|
|
|
STp->eod_frame_lfa = ntohl(header->ext_track_tb.dat_ext_trk_ey.last_hlb);
|
|
|
|
|
STp->filemark_cnt = ntohl(aux->filemark_cnt);
|
|
|
|
|
STp->first_mark_ppos = ntohl(aux->next_mark_ppos);
|
|
|
|
|
STp->last_mark_ppos = ntohl(aux->last_mark_ppos);
|
|
|
|
|
STp->last_mark_lbn = ntohl(aux->last_mark_lbn);
|
|
|
|
|
STp->update_frame_cntr = update_frame_cntr;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Detected write pass %d, update frame counter %d, filemark counter %d\n",
|
|
|
|
|
name, STp->wrt_pass_cntr, STp->update_frame_cntr, STp->filemark_cnt);
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: first data frame on tape = %d, last = %d, eod frame = %d\n", name,
|
|
|
|
|
STp->first_data_ppos,
|
|
|
|
|
ntohl(header->partition[0].last_frame_ppos),
|
|
|
|
|
ntohl(header->partition[0].eod_frame_ppos));
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: first mark on tape = %d, last = %d, eod frame = %d\n",
|
|
|
|
|
name, STp->first_mark_ppos, STp->last_mark_ppos, STp->eod_frame_ppos);
|
|
|
|
|
#endif
|
|
|
|
|
if (header->minor_rev < 4 && STp->linux_media_version == 4) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Moving filemark list to ADR 1.4 location\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
memcpy((void *)header->dat_fm_tab.fm_tab_ent,
|
|
|
|
|
(void *)header->old_filemark_list, sizeof(header->dat_fm_tab.fm_tab_ent));
|
|
|
|
|
memset((void *)header->old_filemark_list, 0, sizeof(header->old_filemark_list));
|
|
|
|
|
}
|
|
|
|
|
if (header->minor_rev == 4 &&
|
|
|
|
|
(header->ext_trk_tb_off != htons(17192) ||
|
|
|
|
|
header->partition[0].partition_num != OS_DATA_PARTITION ||
|
|
|
|
|
header->partition[0].par_desc_ver != OS_PARTITION_VERSION ||
|
|
|
|
|
header->partition[0].last_frame_ppos != htonl(STp->capacity) ||
|
|
|
|
|
header->cfg_col_width != htonl(20) ||
|
|
|
|
|
header->dat_col_width != htonl(1500) ||
|
|
|
|
|
header->qfa_col_width != htonl(0) ||
|
|
|
|
|
header->ext_track_tb.nr_stream_part != 1 ||
|
|
|
|
|
header->ext_track_tb.et_ent_sz != 32 ||
|
|
|
|
|
header->ext_track_tb.dat_ext_trk_ey.et_part_num != OS_DATA_PARTITION ||
|
|
|
|
|
header->ext_track_tb.dat_ext_trk_ey.fmt != 1 ||
|
|
|
|
|
header->ext_track_tb.dat_ext_trk_ey.fm_tab_off != htons(17736) ||
|
|
|
|
|
header->ext_track_tb.dat_ext_trk_ey.last_hlb_hi != 0 ||
|
|
|
|
|
header->ext_track_tb.dat_ext_trk_ey.last_pp != htonl(STp->eod_frame_ppos) ||
|
|
|
|
|
header->dat_fm_tab.fm_part_num != OS_DATA_PARTITION ||
|
|
|
|
|
header->dat_fm_tab.fm_tab_ent_sz != 4 ||
|
|
|
|
|
header->dat_fm_tab.fm_tab_ent_cnt !=
|
|
|
|
|
htons(STp->filemark_cnt<OS_FM_TAB_MAX?STp->filemark_cnt:OS_FM_TAB_MAX)))
|
|
|
|
|
printk(KERN_WARNING "%s:W: Failed consistency check ADR 1.4 format\n", name);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_analyze_headers(struct osst_tape * STp, struct osst_request ** aSRpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
int position, ppos;
|
|
|
|
|
int first, last;
|
|
|
|
|
int valid = 0;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
position = osst_get_frame_position(STp, aSRpnt);
|
|
|
|
|
|
|
|
|
|
if (STp->raw) {
|
|
|
|
|
STp->header_ok = STp->linux_media = 1;
|
|
|
|
|
STp->linux_media_version = 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
STp->header_ok = STp->linux_media = STp->linux_media_version = 0;
|
|
|
|
|
STp->wrt_pass_cntr = STp->update_frame_cntr = -1;
|
|
|
|
|
STp->eod_frame_ppos = STp->first_data_ppos = -1;
|
|
|
|
|
STp->first_mark_ppos = STp->last_mark_ppos = STp->last_mark_lbn = -1;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reading header\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* optimization for speed - if we are positioned at ppos 10, read second group first */
|
|
|
|
|
/* TODO try the ADR 1.1 locations for the second group if we have no valid one yet... */
|
|
|
|
|
|
|
|
|
|
first = position==10?0xbae: 5;
|
|
|
|
|
last = position==10?0xbb3:10;
|
|
|
|
|
|
|
|
|
|
for (ppos = first; ppos < last; ppos++)
|
|
|
|
|
if (__osst_analyze_headers(STp, aSRpnt, ppos))
|
|
|
|
|
valid = 1;
|
|
|
|
|
|
|
|
|
|
first = position==10? 5:0xbae;
|
|
|
|
|
last = position==10?10:0xbb3;
|
|
|
|
|
|
|
|
|
|
for (ppos = first; ppos < last; ppos++)
|
|
|
|
|
if (__osst_analyze_headers(STp, aSRpnt, ppos))
|
|
|
|
|
valid = 1;
|
|
|
|
|
|
|
|
|
|
if (!valid) {
|
|
|
|
|
printk(KERN_ERR "%s:E: Failed to find valid ADRL header, new media?\n", name);
|
|
|
|
|
STp->eod_frame_ppos = STp->first_data_ppos = 0;
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, 10, 0);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (position <= STp->first_data_ppos) {
|
|
|
|
|
position = STp->first_data_ppos;
|
|
|
|
|
STp->ps[0].drv_file = STp->ps[0].drv_block = STp->frame_seq_number = STp->logical_blk_num = 0;
|
|
|
|
|
}
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, position, 0);
|
|
|
|
|
STp->header_ok = 1;
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_verify_position(struct osst_tape * STp, struct osst_request ** aSRpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
int frame_position = STp->first_frame_position;
|
|
|
|
|
int frame_seq_numbr = STp->frame_seq_number;
|
|
|
|
|
int logical_blk_num = STp->logical_blk_num;
|
|
|
|
|
int halfway_frame = STp->frame_in_buffer;
|
|
|
|
|
int read_pointer = STp->buffer->read_pointer;
|
|
|
|
|
int prev_mark_ppos = -1;
|
|
|
|
|
int actual_mark_ppos, i, n;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Verify that the tape is really the one we think before writing\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, frame_position - 1, 0);
|
|
|
|
|
if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in verify_position\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (STp->linux_media_version >= 4) {
|
|
|
|
|
for (i=0; i<STp->filemark_cnt; i++)
|
|
|
|
|
if ((n=ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[i])) < frame_position)
|
|
|
|
|
prev_mark_ppos = n;
|
|
|
|
|
} else
|
|
|
|
|
prev_mark_ppos = frame_position - 1; /* usually - we don't really know */
|
|
|
|
|
actual_mark_ppos = STp->buffer->aux->frame_type == OS_FRAME_TYPE_MARKER ?
|
|
|
|
|
frame_position - 1 : ntohl(STp->buffer->aux->last_mark_ppos);
|
|
|
|
|
if (frame_position != STp->first_frame_position ||
|
|
|
|
|
frame_seq_numbr != STp->frame_seq_number + (halfway_frame?0:1) ||
|
|
|
|
|
prev_mark_ppos != actual_mark_ppos ) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Block mismatch: fppos %d-%d, fseq %d-%d, mark %d-%d\n", name,
|
|
|
|
|
STp->first_frame_position, frame_position,
|
|
|
|
|
STp->frame_seq_number + (halfway_frame?0:1),
|
|
|
|
|
frame_seq_numbr, actual_mark_ppos, prev_mark_ppos);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (halfway_frame) {
|
|
|
|
|
/* prepare buffer for append and rewrite on top of original */
|
|
|
|
|
osst_set_frame_position(STp, aSRpnt, frame_position - 1, 0);
|
|
|
|
|
STp->buffer->buffer_bytes = read_pointer;
|
|
|
|
|
STp->ps[STp->partition].rw = ST_WRITING;
|
|
|
|
|
STp->dirty = 1;
|
|
|
|
|
}
|
|
|
|
|
STp->frame_in_buffer = halfway_frame;
|
|
|
|
|
STp->frame_seq_number = frame_seq_numbr;
|
|
|
|
|
STp->logical_blk_num = logical_blk_num;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Acc. to OnStream, the vers. numbering is the following:
|
|
|
|
|
* X.XX for released versions (X=digit),
|
|
|
|
|
* XXXY for unreleased versions (Y=letter)
|
|
|
|
|
* Ordering 1.05 < 106A < 106B < ... < 106a < ... < 1.06
|
|
|
|
|
* This fn makes monoton numbers out of this scheme ...
|
|
|
|
|
*/
|
|
|
|
|
static unsigned int osst_parse_firmware_rev (const char * str)
|
|
|
|
|
{
|
|
|
|
|
if (str[1] == '.') {
|
|
|
|
|
return (str[0]-'0')*10000
|
|
|
|
|
+(str[2]-'0')*1000
|
|
|
|
|
+(str[3]-'0')*100;
|
|
|
|
|
} else {
|
|
|
|
|
return (str[0]-'0')*10000
|
|
|
|
|
+(str[1]-'0')*1000
|
|
|
|
|
+(str[2]-'0')*100 - 100
|
|
|
|
|
+(str[3]-'@');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Configure the OnStream SCII tape drive for default operation
|
|
|
|
|
*/
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_configure_onstream(struct osst_tape *STp, struct osst_request ** aSRpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
|
|
|
|
char * name = tape_name(STp);
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt = * aSRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
osst_mode_parameter_header_t * header;
|
|
|
|
|
osst_block_size_page_t * bs;
|
|
|
|
|
osst_capabilities_page_t * cp;
|
|
|
|
|
osst_tape_paramtr_page_t * prm;
|
|
|
|
|
int drive_buffer_size;
|
|
|
|
|
|
|
|
|
|
if (STp->ready != ST_READY) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Not Ready\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (STp->os_fw_rev < 10600) {
|
|
|
|
|
printk(KERN_INFO "%s:I: Old OnStream firmware revision detected (%s),\n", name, STp->device->rev);
|
|
|
|
|
printk(KERN_INFO "%s:I: an upgrade to version 1.06 or above is recommended\n", name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Configure 32.5KB (data+aux) frame size.
|
|
|
|
|
* Get the current frame size from the block size mode page
|
|
|
|
|
*/
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = MODE_SENSE;
|
|
|
|
|
cmd[1] = 8;
|
|
|
|
|
cmd[2] = BLOCK_SIZE_PAGE;
|
|
|
|
|
cmd[4] = BLOCK_SIZE_PAGE_LENGTH + MODE_HEADER_LENGTH;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1);
|
|
|
|
|
if (SRpnt == NULL) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "osst :D: Busy\n");
|
|
|
|
|
#endif
|
|
|
|
|
return (-EBUSY);
|
|
|
|
|
}
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
if ((STp->buffer)->syscall_result != 0) {
|
|
|
|
|
printk (KERN_ERR "%s:E: Can't get tape block size mode page\n", name);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
header = (osst_mode_parameter_header_t *) (STp->buffer)->b_data;
|
|
|
|
|
bs = (osst_block_size_page_t *) ((STp->buffer)->b_data + sizeof(osst_mode_parameter_header_t) + header->bdl);
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: 32KB play back: %s\n", name, bs->play32 ? "Yes" : "No");
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: 32.5KB play back: %s\n", name, bs->play32_5 ? "Yes" : "No");
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: 32KB record: %s\n", name, bs->record32 ? "Yes" : "No");
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: 32.5KB record: %s\n", name, bs->record32_5 ? "Yes" : "No");
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Configure default auto columns mode, 32.5KB transfer mode
|
|
|
|
|
*/
|
|
|
|
|
bs->one = 1;
|
|
|
|
|
bs->play32 = 0;
|
|
|
|
|
bs->play32_5 = 1;
|
|
|
|
|
bs->record32 = 0;
|
|
|
|
|
bs->record32_5 = 1;
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = MODE_SELECT;
|
|
|
|
|
cmd[1] = 0x10;
|
|
|
|
|
cmd[4] = BLOCK_SIZE_PAGE_LENGTH + MODE_HEADER_LENGTH;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
if ((STp->buffer)->syscall_result != 0) {
|
|
|
|
|
printk (KERN_ERR "%s:E: Couldn't set tape block size mode page\n", name);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(KERN_INFO "%s:D: Drive Block Size changed to 32.5K\n", name);
|
|
|
|
|
/*
|
|
|
|
|
* In debug mode, we want to see as many errors as possible
|
|
|
|
|
* to test the error recovery mechanism.
|
|
|
|
|
*/
|
|
|
|
|
osst_set_retries(STp, aSRpnt, 0);
|
|
|
|
|
SRpnt = * aSRpnt;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Set vendor name to 'LIN4' for "Linux support version 4".
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = MODE_SELECT;
|
|
|
|
|
cmd[1] = 0x10;
|
|
|
|
|
cmd[4] = VENDOR_IDENT_PAGE_LENGTH + MODE_HEADER_LENGTH;
|
|
|
|
|
|
|
|
|
|
header->mode_data_length = VENDOR_IDENT_PAGE_LENGTH + MODE_HEADER_LENGTH - 1;
|
|
|
|
|
header->medium_type = 0; /* Medium Type - ignoring */
|
|
|
|
|
header->dsp = 0; /* Reserved */
|
|
|
|
|
header->bdl = 0; /* Block Descriptor Length */
|
|
|
|
|
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 0] = VENDOR_IDENT_PAGE | (1 << 7);
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 1] = 6;
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] = 'L';
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 3] = 'I';
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 4] = 'N';
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 5] = '4';
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 6] = 0;
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 7] = 0;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->syscall_result != 0) {
|
|
|
|
|
printk (KERN_ERR "%s:E: Couldn't set vendor name to %s\n", name,
|
|
|
|
|
(char *) ((STp->buffer)->b_data + MODE_HEADER_LENGTH + 2));
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = MODE_SENSE;
|
|
|
|
|
cmd[1] = 8;
|
|
|
|
|
cmd[2] = CAPABILITIES_PAGE;
|
|
|
|
|
cmd[4] = CAPABILITIES_PAGE_LENGTH + MODE_HEADER_LENGTH;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->syscall_result != 0) {
|
|
|
|
|
printk (KERN_ERR "%s:E: Can't get capabilities page\n", name);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
header = (osst_mode_parameter_header_t *) (STp->buffer)->b_data;
|
|
|
|
|
cp = (osst_capabilities_page_t *) ((STp->buffer)->b_data +
|
|
|
|
|
sizeof(osst_mode_parameter_header_t) + header->bdl);
|
|
|
|
|
|
|
|
|
|
drive_buffer_size = ntohs(cp->buffer_size) / 2;
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = MODE_SENSE;
|
|
|
|
|
cmd[1] = 8;
|
|
|
|
|
cmd[2] = TAPE_PARAMTR_PAGE;
|
|
|
|
|
cmd[4] = TAPE_PARAMTR_PAGE_LENGTH + MODE_HEADER_LENGTH;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->syscall_result != 0) {
|
|
|
|
|
printk (KERN_ERR "%s:E: Can't get tape parameter page\n", name);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
header = (osst_mode_parameter_header_t *) (STp->buffer)->b_data;
|
|
|
|
|
prm = (osst_tape_paramtr_page_t *) ((STp->buffer)->b_data +
|
|
|
|
|
sizeof(osst_mode_parameter_header_t) + header->bdl);
|
|
|
|
|
|
|
|
|
|
STp->density = prm->density;
|
|
|
|
|
STp->capacity = ntohs(prm->segtrk) * ntohs(prm->trks);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Density %d, tape length: %dMB, drive buffer size: %dKB\n",
|
|
|
|
|
name, STp->density, STp->capacity / 32, drive_buffer_size);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Step over EOF if it has been inadvertently crossed (ioctl not used because
|
|
|
|
|
it messes up the block number). */
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int cross_eof(struct osst_tape *STp, struct osst_request ** aSRpnt, int forward)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
int result;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Stepping over filemark %s.\n",
|
|
|
|
|
name, forward ? "forward" : "backward");
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (forward) {
|
|
|
|
|
/* assumes that the filemark is already read by the drive, so this is low cost */
|
|
|
|
|
result = osst_space_over_filemarks_forward_slow(STp, aSRpnt, MTFSF, 1);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
/* assumes this is only called if we just read the filemark! */
|
|
|
|
|
result = osst_seek_logical_blk(STp, aSRpnt, STp->logical_blk_num - 1);
|
|
|
|
|
|
|
|
|
|
if (result < 0)
|
|
|
|
|
printk(KERN_WARNING "%s:W: Stepping over filemark %s failed.\n",
|
|
|
|
|
name, forward ? "forward" : "backward");
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Get the tape position. */
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_get_frame_position(struct osst_tape *STp, struct osst_request ** aSRpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
unsigned char scmd[MAX_COMMAND_SIZE];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
int result = 0;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
/* KG: We want to be able to use it for checking Write Buffer availability
|
|
|
|
|
* and thus don't want to risk to overwrite anything. Exchange buffers ... */
|
|
|
|
|
char mybuf[24];
|
|
|
|
|
char * olddata = STp->buffer->b_data;
|
|
|
|
|
int oldsize = STp->buffer->buffer_size;
|
|
|
|
|
|
|
|
|
|
if (STp->ready != ST_READY) return (-EIO);
|
|
|
|
|
|
|
|
|
|
memset (scmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
scmd[0] = READ_POSITION;
|
|
|
|
|
|
|
|
|
|
STp->buffer->b_data = mybuf; STp->buffer->buffer_size = 24;
|
|
|
|
|
SRpnt = osst_do_scsi(*aSRpnt, STp, scmd, 20, DMA_FROM_DEVICE,
|
|
|
|
|
STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
if (!SRpnt) {
|
|
|
|
|
STp->buffer->b_data = olddata; STp->buffer->buffer_size = oldsize;
|
|
|
|
|
return (-EBUSY);
|
|
|
|
|
}
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
|
|
|
|
|
if (STp->buffer->syscall_result)
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
result = ((SRpnt->sense[2] & 0x0f) == 3) ? -EIO : -EINVAL; /* 3: Write Error */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
if (result == -EINVAL)
|
|
|
|
|
printk(KERN_ERR "%s:E: Can't read tape position.\n", name);
|
|
|
|
|
else {
|
|
|
|
|
if (result == -EIO) { /* re-read position - this needs to preserve media errors */
|
|
|
|
|
unsigned char mysense[16];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
memcpy (mysense, SRpnt->sense, 16);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
memset (scmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
scmd[0] = READ_POSITION;
|
|
|
|
|
STp->buffer->b_data = mybuf; STp->buffer->buffer_size = 24;
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, scmd, 20, DMA_FROM_DEVICE,
|
|
|
|
|
STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reread position, reason=[%02x:%02x:%02x], result=[%s%02x:%02x:%02x]\n",
|
|
|
|
|
name, mysense[2], mysense[12], mysense[13], STp->buffer->syscall_result?"":"ok:",
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
SRpnt->sense[2],SRpnt->sense[12],SRpnt->sense[13]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#endif
|
|
|
|
|
if (!STp->buffer->syscall_result)
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
memcpy (SRpnt->sense, mysense, 16);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
else
|
|
|
|
|
printk(KERN_WARNING "%s:W: Double error in get position\n", name);
|
|
|
|
|
}
|
|
|
|
|
STp->first_frame_position = ((STp->buffer)->b_data[4] << 24)
|
|
|
|
|
+ ((STp->buffer)->b_data[5] << 16)
|
|
|
|
|
+ ((STp->buffer)->b_data[6] << 8)
|
|
|
|
|
+ (STp->buffer)->b_data[7];
|
|
|
|
|
STp->last_frame_position = ((STp->buffer)->b_data[ 8] << 24)
|
|
|
|
|
+ ((STp->buffer)->b_data[ 9] << 16)
|
|
|
|
|
+ ((STp->buffer)->b_data[10] << 8)
|
|
|
|
|
+ (STp->buffer)->b_data[11];
|
|
|
|
|
STp->cur_frames = (STp->buffer)->b_data[15];
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging) {
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Drive Positions: host %d, tape %d%s, buffer %d\n", name,
|
|
|
|
|
STp->first_frame_position, STp->last_frame_position,
|
|
|
|
|
((STp->buffer)->b_data[0]&0x80)?" (BOP)":
|
|
|
|
|
((STp->buffer)->b_data[0]&0x40)?" (EOP)":"",
|
|
|
|
|
STp->cur_frames);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
if (STp->cur_frames == 0 && STp->first_frame_position != STp->last_frame_position) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Correcting read position %d, %d, %d\n", name,
|
|
|
|
|
STp->first_frame_position, STp->last_frame_position, STp->cur_frames);
|
|
|
|
|
#endif
|
|
|
|
|
STp->first_frame_position = STp->last_frame_position;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
STp->buffer->b_data = olddata; STp->buffer->buffer_size = oldsize;
|
|
|
|
|
|
|
|
|
|
return (result == 0 ? STp->first_frame_position : result);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Set the tape block */
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_set_frame_position(struct osst_tape *STp, struct osst_request ** aSRpnt, int ppos, int skip)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
unsigned char scmd[MAX_COMMAND_SIZE];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
struct st_partstat * STps;
|
|
|
|
|
int result = 0;
|
|
|
|
|
int pp = (ppos == 3000 && !skip)? 0 : ppos;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
if (STp->ready != ST_READY) return (-EIO);
|
|
|
|
|
|
|
|
|
|
STps = &(STp->ps[STp->partition]);
|
|
|
|
|
|
|
|
|
|
if (ppos < 0 || ppos > STp->capacity) {
|
|
|
|
|
printk(KERN_WARNING "%s:W: Reposition request %d out of range\n", name, ppos);
|
|
|
|
|
pp = ppos = ppos < 0 ? 0 : (STp->capacity - 1);
|
|
|
|
|
result = (-EINVAL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Setting ppos to %d.\n", name, pp);
|
|
|
|
|
#endif
|
|
|
|
|
memset (scmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
scmd[0] = SEEK_10;
|
|
|
|
|
scmd[1] = 1;
|
|
|
|
|
scmd[3] = (pp >> 24);
|
|
|
|
|
scmd[4] = (pp >> 16);
|
|
|
|
|
scmd[5] = (pp >> 8);
|
|
|
|
|
scmd[6] = pp;
|
|
|
|
|
if (skip)
|
|
|
|
|
scmd[9] = 0x80;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(*aSRpnt, STp, scmd, 0, DMA_NONE, STp->long_timeout,
|
|
|
|
|
MAX_RETRIES, 1);
|
|
|
|
|
if (!SRpnt)
|
|
|
|
|
return (-EBUSY);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->syscall_result != 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: SEEK command from %d to %d failed.\n",
|
|
|
|
|
name, STp->first_frame_position, pp);
|
|
|
|
|
#endif
|
|
|
|
|
result = (-EIO);
|
|
|
|
|
}
|
|
|
|
|
if (pp != ppos)
|
|
|
|
|
osst_wait_ready(STp, aSRpnt, 5 * 60, OSST_WAIT_POSITION_COMPLETE);
|
|
|
|
|
} while ((pp != ppos) && (pp = ppos));
|
|
|
|
|
STp->first_frame_position = STp->last_frame_position = ppos;
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
STps->at_sm = 0;
|
|
|
|
|
STps->rw = ST_IDLE;
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_write_trailer(struct osst_tape *STp, struct osst_request ** aSRpnt, int leave_at_EOT)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
struct st_partstat * STps = &(STp->ps[STp->partition]);
|
|
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
|
|
if (STp->write_type != OS_WRITE_NEW_MARK) {
|
|
|
|
|
/* true unless the user wrote the filemark for us */
|
|
|
|
|
result = osst_flush_drive_buffer(STp, aSRpnt);
|
|
|
|
|
if (result < 0) goto out;
|
|
|
|
|
result = osst_write_filemark(STp, aSRpnt);
|
|
|
|
|
if (result < 0) goto out;
|
|
|
|
|
|
|
|
|
|
if (STps->drv_file >= 0)
|
|
|
|
|
STps->drv_file++ ;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
}
|
|
|
|
|
result = osst_write_eod(STp, aSRpnt);
|
|
|
|
|
osst_write_header(STp, aSRpnt, leave_at_EOT);
|
|
|
|
|
|
|
|
|
|
STps->eof = ST_FM;
|
|
|
|
|
out:
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* osst versions of st functions - augmented and stripped to suit OnStream only */
|
|
|
|
|
|
|
|
|
|
/* Flush the write buffer (never need to write if variable blocksize). */
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_flush_write_buffer(struct osst_tape *STp, struct osst_request ** aSRpnt)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
int offset, transfer, blks = 0;
|
|
|
|
|
int result = 0;
|
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt = *aSRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
struct st_partstat * STps;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->writing) {
|
|
|
|
|
if (SRpnt == (STp->buffer)->last_SRpnt)
|
|
|
|
|
#if DEBUG
|
|
|
|
|
{ printk(OSST_DEB_MSG
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
"%s:D: aSRpnt points to osst_request that write_behind_check will release -- cleared\n", name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#endif
|
|
|
|
|
*aSRpnt = SRpnt = NULL;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
} else if (SRpnt)
|
|
|
|
|
printk(OSST_DEB_MSG
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
"%s:D: aSRpnt does not point to osst_request that write_behind_check will release -- strange\n", name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#endif
|
|
|
|
|
osst_write_behind_check(STp);
|
|
|
|
|
if ((STp->buffer)->syscall_result) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Async write error (flush) %x.\n",
|
|
|
|
|
name, (STp->buffer)->midlevel_result);
|
|
|
|
|
#endif
|
|
|
|
|
if ((STp->buffer)->midlevel_result == INT_MAX)
|
|
|
|
|
return (-ENOSPC);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
result = 0;
|
|
|
|
|
if (STp->dirty == 1) {
|
|
|
|
|
|
|
|
|
|
STp->write_count++;
|
|
|
|
|
STps = &(STp->ps[STp->partition]);
|
|
|
|
|
STps->rw = ST_WRITING;
|
|
|
|
|
offset = STp->buffer->buffer_bytes;
|
|
|
|
|
blks = (offset + STp->block_size - 1) / STp->block_size;
|
|
|
|
|
transfer = OS_FRAME_SIZE;
|
|
|
|
|
|
|
|
|
|
if (offset < OS_DATA_SIZE)
|
|
|
|
|
osst_zero_buffer_tail(STp->buffer);
|
|
|
|
|
|
|
|
|
|
if (STp->poll)
|
|
|
|
|
if (osst_wait_frame (STp, aSRpnt, STp->first_frame_position, -50, 120))
|
|
|
|
|
result = osst_recover_wait_frame(STp, aSRpnt, 1);
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = WRITE_6;
|
|
|
|
|
cmd[1] = 1;
|
|
|
|
|
cmd[4] = 1;
|
|
|
|
|
|
|
|
|
|
switch (STp->write_type) {
|
|
|
|
|
case OS_WRITE_DATA:
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Writing %d blocks to frame %d, lblks %d-%d\n",
|
|
|
|
|
name, blks, STp->frame_seq_number,
|
|
|
|
|
STp->logical_blk_num - blks, STp->logical_blk_num - 1);
|
|
|
|
|
#endif
|
|
|
|
|
osst_init_aux(STp, OS_FRAME_TYPE_DATA, STp->frame_seq_number++,
|
|
|
|
|
STp->logical_blk_num - blks, STp->block_size, blks);
|
|
|
|
|
break;
|
|
|
|
|
case OS_WRITE_EOD:
|
|
|
|
|
osst_init_aux(STp, OS_FRAME_TYPE_EOD, STp->frame_seq_number++,
|
|
|
|
|
STp->logical_blk_num, 0, 0);
|
|
|
|
|
break;
|
|
|
|
|
case OS_WRITE_NEW_MARK:
|
|
|
|
|
osst_init_aux(STp, OS_FRAME_TYPE_MARKER, STp->frame_seq_number++,
|
|
|
|
|
STp->logical_blk_num++, 0, blks=1);
|
|
|
|
|
break;
|
|
|
|
|
case OS_WRITE_HEADER:
|
|
|
|
|
osst_init_aux(STp, OS_FRAME_TYPE_HEADER, 0, 0, 0, blks=0);
|
|
|
|
|
break;
|
|
|
|
|
default: /* probably FILLER */
|
|
|
|
|
osst_init_aux(STp, OS_FRAME_TYPE_FILL, 0, 0, 0, 0);
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
2011-03-30 19:57:33 -06:00
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Flushing %d bytes, Transferring %d bytes in %d lblocks.\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
|
name, offset, transfer, blks);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
|
|
|
|
|
STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
if (!SRpnt)
|
|
|
|
|
return (-EBUSY);
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->syscall_result != 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: write sense [0]=0x%02x [2]=%02x [12]=%02x [13]=%02x\n",
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
name, SRpnt->sense[0], SRpnt->sense[2],
|
|
|
|
|
SRpnt->sense[12], SRpnt->sense[13]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#endif
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ((SRpnt->sense[0] & 0x70) == 0x70 &&
|
|
|
|
|
(SRpnt->sense[2] & 0x40) && /* FIXME - SC-30 drive doesn't assert EOM bit */
|
|
|
|
|
(SRpnt->sense[2] & 0x0f) == NO_SENSE) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STp->dirty = 0;
|
|
|
|
|
(STp->buffer)->buffer_bytes = 0;
|
|
|
|
|
result = (-ENOSPC);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
if (osst_write_error_recovery(STp, aSRpnt, 1)) {
|
|
|
|
|
printk(KERN_ERR "%s:E: Error on flush write.\n", name);
|
|
|
|
|
result = (-EIO);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
STps->drv_block = (-1); /* FIXME - even if write recovery succeeds? */
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
STp->first_frame_position++;
|
|
|
|
|
STp->dirty = 0;
|
|
|
|
|
(STp->buffer)->buffer_bytes = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Exit flush write buffer with code %d\n", name, result);
|
|
|
|
|
#endif
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Flush the tape buffer. The tape will be positioned correctly unless
|
|
|
|
|
seek_next is true. */
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_flush_buffer(struct osst_tape * STp, struct osst_request ** aSRpnt, int seek_next)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
struct st_partstat * STps;
|
|
|
|
|
int backspace = 0, result = 0;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If there was a bus reset, block further access
|
|
|
|
|
* to this device.
|
|
|
|
|
*/
|
|
|
|
|
if( STp->pos_unknown)
|
|
|
|
|
return (-EIO);
|
|
|
|
|
|
|
|
|
|
if (STp->ready != ST_READY)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
STps = &(STp->ps[STp->partition]);
|
|
|
|
|
if (STps->rw == ST_WRITING || STp->dirty) { /* Writing */
|
|
|
|
|
STp->write_type = OS_WRITE_DATA;
|
|
|
|
|
return osst_flush_write_buffer(STp, aSRpnt);
|
|
|
|
|
}
|
|
|
|
|
if (STp->block_size == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reached flush (read) buffer\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (!STp->can_bsr) {
|
|
|
|
|
backspace = ((STp->buffer)->buffer_bytes + (STp->buffer)->read_pointer) / STp->block_size -
|
|
|
|
|
((STp->buffer)->read_pointer + STp->block_size - 1 ) / STp->block_size ;
|
|
|
|
|
(STp->buffer)->buffer_bytes = 0;
|
|
|
|
|
(STp->buffer)->read_pointer = 0;
|
|
|
|
|
STp->frame_in_buffer = 0; /* FIXME is this relevant w. OSST? */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!seek_next) {
|
|
|
|
|
if (STps->eof == ST_FM_HIT) {
|
|
|
|
|
result = cross_eof(STp, aSRpnt, 0); /* Back over the EOF hit */
|
|
|
|
|
if (!result)
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
else {
|
|
|
|
|
if (STps->drv_file >= 0)
|
|
|
|
|
STps->drv_file++;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (!result && backspace > 0) /* TODO -- design and run a test case for this */
|
|
|
|
|
result = osst_seek_logical_blk(STp, aSRpnt, STp->logical_blk_num - backspace);
|
|
|
|
|
}
|
|
|
|
|
else if (STps->eof == ST_FM_HIT) {
|
|
|
|
|
if (STps->drv_file >= 0)
|
|
|
|
|
STps->drv_file++;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_write_frame(struct osst_tape * STp, struct osst_request ** aSRpnt, int synchronous)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
int blks;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if ((!STp-> raw) && (STp->first_frame_position == 0xbae)) { /* _must_ preserve buffer! */
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Reaching config partition.\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
if (osst_flush_drive_buffer(STp, aSRpnt) < 0) {
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
/* error recovery may have bumped us past the header partition */
|
|
|
|
|
if (osst_get_frame_position(STp, aSRpnt) < 0xbb8) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping over config partition.\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
osst_position_tape_and_confirm(STp, aSRpnt, 0xbb8);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (STp->poll)
|
|
|
|
|
if (osst_wait_frame (STp, aSRpnt, STp->first_frame_position, -48, 120))
|
|
|
|
|
if (osst_recover_wait_frame(STp, aSRpnt, 1))
|
|
|
|
|
return (-EIO);
|
|
|
|
|
|
|
|
|
|
// osst_build_stats(STp, &SRpnt);
|
|
|
|
|
|
|
|
|
|
STp->ps[STp->partition].rw = ST_WRITING;
|
|
|
|
|
STp->write_type = OS_WRITE_DATA;
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = WRITE_6;
|
|
|
|
|
cmd[1] = 1;
|
|
|
|
|
cmd[4] = 1; /* one frame at a time... */
|
|
|
|
|
blks = STp->buffer->buffer_bytes / STp->block_size;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Writing %d blocks to frame %d, lblks %d-%d\n", name, blks,
|
|
|
|
|
STp->frame_seq_number, STp->logical_blk_num - blks, STp->logical_blk_num - 1);
|
|
|
|
|
#endif
|
|
|
|
|
osst_init_aux(STp, OS_FRAME_TYPE_DATA, STp->frame_seq_number++,
|
|
|
|
|
STp->logical_blk_num - blks, STp->block_size, blks);
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (!synchronous)
|
|
|
|
|
STp->write_pending = 1;
|
|
|
|
|
#endif
|
|
|
|
|
SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, OS_FRAME_SIZE, DMA_TO_DEVICE, STp->timeout,
|
|
|
|
|
MAX_RETRIES, synchronous);
|
|
|
|
|
if (!SRpnt)
|
|
|
|
|
return (-EBUSY);
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
|
|
|
|
|
if (synchronous) {
|
|
|
|
|
if (STp->buffer->syscall_result != 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Error on write:\n", name);
|
|
|
|
|
#endif
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ((SRpnt->sense[0] & 0x70) == 0x70 &&
|
|
|
|
|
(SRpnt->sense[2] & 0x40)) {
|
|
|
|
|
if ((SRpnt->sense[2] & 0x0f) == VOLUME_OVERFLOW)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return (-ENOSPC);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
if (osst_write_error_recovery(STp, aSRpnt, 1))
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
STp->first_frame_position++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
STp->write_count++;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
/* Lock or unlock the drive door. Don't use when struct osst_request allocated. */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
static int do_door_lock(struct osst_tape * STp, int do_lock)
|
|
|
|
|
{
|
2014-10-11 08:00:33 -06:00
|
|
|
|
int retval;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: %socking drive door.\n", tape_name(STp), do_lock ? "L" : "Unl");
|
|
|
|
|
#endif
|
2014-10-11 08:00:33 -06:00
|
|
|
|
|
|
|
|
|
retval = scsi_set_medium_removal(STp->device,
|
|
|
|
|
do_lock ? SCSI_REMOVAL_PREVENT : SCSI_REMOVAL_ALLOW);
|
|
|
|
|
if (!retval)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
|
2014-10-11 08:00:33 -06:00
|
|
|
|
else
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STp->door_locked = ST_LOCK_FAILS;
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set the internal state after reset */
|
|
|
|
|
static void reset_state(struct osst_tape *STp)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
struct st_partstat *STps;
|
|
|
|
|
|
|
|
|
|
STp->pos_unknown = 0;
|
|
|
|
|
for (i = 0; i < ST_NBR_PARTITIONS; i++) {
|
|
|
|
|
STps = &(STp->ps[i]);
|
|
|
|
|
STps->rw = ST_IDLE;
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
STps->at_sm = 0;
|
|
|
|
|
STps->last_block_valid = 0;
|
|
|
|
|
STps->drv_block = -1;
|
|
|
|
|
STps->drv_file = -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Entry points to osst */
|
|
|
|
|
|
|
|
|
|
/* Write command */
|
|
|
|
|
static ssize_t osst_write(struct file * filp, const char __user * buf, size_t count, loff_t *ppos)
|
|
|
|
|
{
|
|
|
|
|
ssize_t total, retval = 0;
|
|
|
|
|
ssize_t i, do_count, blks, transfer;
|
|
|
|
|
int write_threshold;
|
|
|
|
|
int doing_write = 0;
|
|
|
|
|
const char __user * b_point;
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
struct st_modedef * STm;
|
|
|
|
|
struct st_partstat * STps;
|
|
|
|
|
struct osst_tape * STp = filp->private_data;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
|
2007-08-10 15:50:44 -06:00
|
|
|
|
if (mutex_lock_interruptible(&STp->lock))
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return (-ERESTARTSYS);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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(STp->device) ) {
|
|
|
|
|
retval = (-ENXIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (STp->ready != ST_READY) {
|
|
|
|
|
if (STp->ready == ST_NO_TAPE)
|
|
|
|
|
retval = (-ENOMEDIUM);
|
|
|
|
|
else
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
STm = &(STp->modes[STp->current_mode]);
|
|
|
|
|
if (!STm->defined) {
|
|
|
|
|
retval = (-ENXIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if (count == 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If there was a bus reset, block further access
|
|
|
|
|
* to this device.
|
|
|
|
|
*/
|
|
|
|
|
if (STp->pos_unknown) {
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (!STp->in_use) {
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Incorrect device.\n", name);
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (STp->write_prot) {
|
|
|
|
|
retval = (-EACCES);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Write must be integral number of blocks */
|
|
|
|
|
if (STp->block_size != 0 && (count % STp->block_size) != 0) {
|
2017-02-27 15:30:02 -07:00
|
|
|
|
printk(KERN_ERR "%s:E: Write (%zd bytes) not multiple of tape block size (%d%c).\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
|
name, count, STp->block_size<1024?
|
|
|
|
|
STp->block_size:STp->block_size/1024, STp->block_size<1024?'b':'k');
|
|
|
|
|
retval = (-EINVAL);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (STp->first_frame_position >= STp->capacity - OSST_EOM_RESERVE) {
|
|
|
|
|
printk(KERN_ERR "%s:E: Write truncated at EOM early warning (frame %d).\n",
|
|
|
|
|
name, STp->first_frame_position);
|
|
|
|
|
retval = (-ENOSPC);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && !do_door_lock(STp, 1))
|
|
|
|
|
STp->door_locked = ST_LOCKED_AUTO;
|
|
|
|
|
|
|
|
|
|
STps = &(STp->ps[STp->partition]);
|
|
|
|
|
|
|
|
|
|
if (STps->rw == ST_READING) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Switching from read to write at file %d, block %d\n", name,
|
|
|
|
|
STps->drv_file, STps->drv_block);
|
|
|
|
|
#endif
|
|
|
|
|
retval = osst_flush_buffer(STp, &SRpnt, 0);
|
|
|
|
|
if (retval)
|
|
|
|
|
goto out;
|
|
|
|
|
STps->rw = ST_IDLE;
|
|
|
|
|
}
|
|
|
|
|
if (STps->rw != ST_WRITING) {
|
|
|
|
|
/* Are we totally rewriting this tape? */
|
|
|
|
|
if (!STp->header_ok ||
|
|
|
|
|
(STp->first_frame_position == STp->first_data_ppos && STps->drv_block < 0) ||
|
|
|
|
|
(STps->drv_file == 0 && STps->drv_block == 0)) {
|
|
|
|
|
STp->wrt_pass_cntr++;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Allocating next write pass counter: %d\n",
|
|
|
|
|
name, STp->wrt_pass_cntr);
|
|
|
|
|
#endif
|
|
|
|
|
osst_reset_header(STp, &SRpnt);
|
|
|
|
|
STps->drv_file = STps->drv_block = 0;
|
|
|
|
|
}
|
|
|
|
|
/* Do we know where we'll be writing on the tape? */
|
|
|
|
|
else {
|
|
|
|
|
if ((STp->fast_open && osst_verify_position(STp, &SRpnt)) ||
|
|
|
|
|
STps->drv_file < 0 || STps->drv_block < 0) {
|
|
|
|
|
if (STp->first_frame_position == STp->eod_frame_ppos) { /* at EOD */
|
|
|
|
|
STps->drv_file = STp->filemark_cnt;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* We have no idea where the tape is positioned - give up */
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: Cannot write at indeterminate position.\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if ((STps->drv_file + STps->drv_block) > 0 && STps->drv_file < STp->filemark_cnt) {
|
|
|
|
|
STp->filemark_cnt = STps->drv_file;
|
|
|
|
|
STp->last_mark_ppos =
|
|
|
|
|
ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[STp->filemark_cnt-1]);
|
|
|
|
|
printk(KERN_WARNING
|
|
|
|
|
"%s:W: Overwriting file %d with old write pass counter %d\n",
|
|
|
|
|
name, STps->drv_file, STp->wrt_pass_cntr);
|
|
|
|
|
printk(KERN_WARNING
|
|
|
|
|
"%s:W: may lead to stale data being accepted on reading back!\n",
|
|
|
|
|
name);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"%s:D: resetting filemark count to %d and last mark ppos,lbn to %d,%d\n",
|
|
|
|
|
name, STp->filemark_cnt, STp->last_mark_ppos, STp->last_mark_lbn);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
STp->fast_open = 0;
|
|
|
|
|
}
|
|
|
|
|
if (!STp->header_ok) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Write cannot proceed without valid headers\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->writing) {
|
|
|
|
|
if (SRpnt) printk(KERN_ERR "%s:A: Not supposed to have SRpnt at line %d\n", name, __LINE__);
|
|
|
|
|
osst_write_behind_check(STp);
|
|
|
|
|
if ((STp->buffer)->syscall_result) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Async write error (write) %x.\n", name,
|
|
|
|
|
(STp->buffer)->midlevel_result);
|
|
|
|
|
#endif
|
|
|
|
|
if ((STp->buffer)->midlevel_result == INT_MAX)
|
|
|
|
|
STps->eof = ST_EOM_OK;
|
|
|
|
|
else
|
|
|
|
|
STps->eof = ST_EOM_ERROR;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (STps->eof == ST_EOM_OK) {
|
|
|
|
|
retval = (-ENOSPC);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
else if (STps->eof == ST_EOM_ERROR) {
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Check the buffer readability in cases where copy_user might catch
|
|
|
|
|
the problems after some tape movement. */
|
|
|
|
|
if ((copy_from_user(&i, buf, 1) != 0 ||
|
|
|
|
|
copy_from_user(&i, buf + count - 1, 1) != 0)) {
|
|
|
|
|
retval = (-EFAULT);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!STm->do_buffer_writes) {
|
|
|
|
|
write_threshold = 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
write_threshold = (STp->buffer)->buffer_blocks * STp->block_size;
|
|
|
|
|
if (!STm->do_async_writes)
|
|
|
|
|
write_threshold--;
|
|
|
|
|
|
|
|
|
|
total = count;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Writing %d bytes to file %d block %d lblk %d fseq %d fppos %d\n",
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
name, (int) count, STps->drv_file, STps->drv_block,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STp->logical_blk_num, STp->frame_seq_number, STp->first_frame_position);
|
|
|
|
|
#endif
|
|
|
|
|
b_point = buf;
|
|
|
|
|
while ((STp->buffer)->buffer_bytes + count > write_threshold)
|
|
|
|
|
{
|
|
|
|
|
doing_write = 1;
|
|
|
|
|
do_count = (STp->buffer)->buffer_blocks * STp->block_size -
|
|
|
|
|
(STp->buffer)->buffer_bytes;
|
|
|
|
|
if (do_count > count)
|
|
|
|
|
do_count = count;
|
|
|
|
|
|
|
|
|
|
i = append_to_buffer(b_point, STp->buffer, do_count);
|
|
|
|
|
if (i) {
|
|
|
|
|
retval = i;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
blks = do_count / STp->block_size;
|
|
|
|
|
STp->logical_blk_num += blks; /* logical_blk_num is incremented as data is moved from user */
|
|
|
|
|
|
|
|
|
|
i = osst_write_frame(STp, &SRpnt, 1);
|
|
|
|
|
|
|
|
|
|
if (i == (-ENOSPC)) {
|
|
|
|
|
transfer = STp->buffer->writing; /* FIXME -- check this logic */
|
|
|
|
|
if (transfer <= do_count) {
|
2010-05-26 15:44:44 -06:00
|
|
|
|
*ppos += do_count - transfer;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
count -= do_count - transfer;
|
|
|
|
|
if (STps->drv_block >= 0) {
|
|
|
|
|
STps->drv_block += (do_count - transfer) / STp->block_size;
|
|
|
|
|
}
|
|
|
|
|
STps->eof = ST_EOM_OK;
|
|
|
|
|
retval = (-ENOSPC); /* EOM within current request */
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: EOM with %d bytes unwritten.\n",
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
name, (int) transfer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
STps->eof = ST_EOM_ERROR;
|
|
|
|
|
STps->drv_block = (-1); /* Too cautious? */
|
|
|
|
|
retval = (-EIO); /* EOM for old data */
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: EOM with lost data.\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
retval = i;
|
|
|
|
|
|
|
|
|
|
if (retval < 0) {
|
|
|
|
|
if (SRpnt != NULL) {
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
osst_release_request(SRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
SRpnt = NULL;
|
|
|
|
|
}
|
|
|
|
|
STp->buffer->buffer_bytes = 0;
|
|
|
|
|
STp->dirty = 0;
|
|
|
|
|
if (count < total)
|
|
|
|
|
retval = total - count;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2010-05-26 15:44:44 -06:00
|
|
|
|
*ppos += do_count;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
b_point += do_count;
|
|
|
|
|
count -= do_count;
|
|
|
|
|
if (STps->drv_block >= 0) {
|
|
|
|
|
STps->drv_block += blks;
|
|
|
|
|
}
|
|
|
|
|
STp->buffer->buffer_bytes = 0;
|
|
|
|
|
STp->dirty = 0;
|
|
|
|
|
} /* end while write threshold exceeded */
|
|
|
|
|
|
|
|
|
|
if (count != 0) {
|
|
|
|
|
STp->dirty = 1;
|
|
|
|
|
i = append_to_buffer(b_point, STp->buffer, count);
|
|
|
|
|
if (i) {
|
|
|
|
|
retval = i;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
blks = count / STp->block_size;
|
|
|
|
|
STp->logical_blk_num += blks;
|
|
|
|
|
if (STps->drv_block >= 0) {
|
|
|
|
|
STps->drv_block += blks;
|
|
|
|
|
}
|
2010-05-26 15:44:44 -06:00
|
|
|
|
*ppos += count;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
count = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (doing_write && (STp->buffer)->syscall_result != 0) {
|
|
|
|
|
retval = (STp->buffer)->syscall_result;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (STm->do_async_writes && ((STp->buffer)->buffer_bytes >= STp->write_threshold)) {
|
|
|
|
|
/* Schedule an asynchronous write */
|
|
|
|
|
(STp->buffer)->writing = ((STp->buffer)->buffer_bytes /
|
|
|
|
|
STp->block_size) * STp->block_size;
|
|
|
|
|
STp->dirty = !((STp->buffer)->writing ==
|
|
|
|
|
(STp->buffer)->buffer_bytes);
|
|
|
|
|
|
|
|
|
|
i = osst_write_frame(STp, &SRpnt, 0);
|
|
|
|
|
if (i < 0) {
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
SRpnt = NULL; /* Prevent releasing this request! */
|
|
|
|
|
}
|
|
|
|
|
STps->at_sm &= (total == 0);
|
|
|
|
|
if (total > 0)
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
|
|
|
|
|
retval = total;
|
|
|
|
|
|
|
|
|
|
out:
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (SRpnt != NULL) osst_release_request(SRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-08-10 15:50:44 -06:00
|
|
|
|
mutex_unlock(&STp->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Read command */
|
|
|
|
|
static ssize_t osst_read(struct file * filp, char __user * buf, size_t count, loff_t *ppos)
|
|
|
|
|
{
|
|
|
|
|
ssize_t total, retval = 0;
|
|
|
|
|
ssize_t i, transfer;
|
|
|
|
|
int special;
|
|
|
|
|
struct st_modedef * STm;
|
|
|
|
|
struct st_partstat * STps;
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
struct osst_tape * STp = filp->private_data;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
|
2007-08-10 15:50:44 -06:00
|
|
|
|
if (mutex_lock_interruptible(&STp->lock))
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return (-ERESTARTSYS);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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(STp->device) ) {
|
|
|
|
|
retval = (-ENXIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (STp->ready != ST_READY) {
|
|
|
|
|
if (STp->ready == ST_NO_TAPE)
|
|
|
|
|
retval = (-ENOMEDIUM);
|
|
|
|
|
else
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
STm = &(STp->modes[STp->current_mode]);
|
|
|
|
|
if (!STm->defined) {
|
|
|
|
|
retval = (-ENXIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (!STp->in_use) {
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Incorrect device.\n", name);
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
/* Must have initialized medium */
|
|
|
|
|
if (!STp->header_ok) {
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && !do_door_lock(STp, 1))
|
|
|
|
|
STp->door_locked = ST_LOCKED_AUTO;
|
|
|
|
|
|
|
|
|
|
STps = &(STp->ps[STp->partition]);
|
|
|
|
|
if (STps->rw == ST_WRITING) {
|
|
|
|
|
retval = osst_flush_buffer(STp, &SRpnt, 0);
|
|
|
|
|
if (retval)
|
|
|
|
|
goto out;
|
|
|
|
|
STps->rw = ST_IDLE;
|
|
|
|
|
/* FIXME -- this may leave the tape without EOD and up2date headers */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((count % STp->block_size) != 0) {
|
|
|
|
|
printk(KERN_WARNING
|
2017-02-27 15:30:02 -07:00
|
|
|
|
"%s:W: Read (%zd bytes) not multiple of tape block size (%d%c).\n", name, count,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STp->block_size<1024?STp->block_size:STp->block_size/1024, STp->block_size<1024?'b':'k');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging && STps->eof != ST_NOEOF)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: EOF/EOM flag up (%d). Bytes %d\n", name,
|
|
|
|
|
STps->eof, (STp->buffer)->buffer_bytes);
|
|
|
|
|
#endif
|
|
|
|
|
if ((STp->buffer)->buffer_bytes == 0 &&
|
|
|
|
|
STps->eof >= ST_EOD_1) {
|
|
|
|
|
if (STps->eof < ST_EOD) {
|
|
|
|
|
STps->eof += 1;
|
|
|
|
|
retval = 0;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
retval = (-EIO); /* EOM or Blank Check */
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Check the buffer writability before any tape movement. Don't alter
|
|
|
|
|
buffer data. */
|
|
|
|
|
if (copy_from_user(&i, buf, 1) != 0 ||
|
|
|
|
|
copy_to_user (buf, &i, 1) != 0 ||
|
|
|
|
|
copy_from_user(&i, buf + count - 1, 1) != 0 ||
|
|
|
|
|
copy_to_user (buf + count - 1, &i, 1) != 0) {
|
|
|
|
|
retval = (-EFAULT);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Loop until enough data in buffer or a special condition found */
|
|
|
|
|
for (total = 0, special = 0; total < count - STp->block_size + 1 && !special; ) {
|
|
|
|
|
|
|
|
|
|
/* Get new data if the buffer is empty */
|
|
|
|
|
if ((STp->buffer)->buffer_bytes == 0) {
|
|
|
|
|
if (STps->eof == ST_FM_HIT)
|
|
|
|
|
break;
|
|
|
|
|
special = osst_get_logical_frame(STp, &SRpnt, STp->frame_seq_number, 0);
|
|
|
|
|
if (special < 0) { /* No need to continue read */
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
retval = special;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Move the data from driver buffer to user buffer */
|
|
|
|
|
if ((STp->buffer)->buffer_bytes > 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging && STps->eof != ST_NOEOF)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: EOF up (%d). Left %d, needed %d.\n", name,
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
STps->eof, (STp->buffer)->buffer_bytes, (int) (count - total));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#endif
|
|
|
|
|
/* force multiple of block size, note block_size may have been adjusted */
|
|
|
|
|
transfer = (((STp->buffer)->buffer_bytes < count - total ?
|
|
|
|
|
(STp->buffer)->buffer_bytes : count - total)/
|
|
|
|
|
STp->block_size) * STp->block_size;
|
|
|
|
|
|
|
|
|
|
if (transfer == 0) {
|
|
|
|
|
printk(KERN_WARNING
|
2017-02-27 15:30:02 -07:00
|
|
|
|
"%s:W: Nothing can be transferred, requested %zd, tape block size (%d%c).\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
|
name, count, STp->block_size < 1024?
|
|
|
|
|
STp->block_size:STp->block_size/1024,
|
|
|
|
|
STp->block_size<1024?'b':'k');
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
i = from_buffer(STp->buffer, buf, transfer);
|
|
|
|
|
if (i) {
|
|
|
|
|
retval = i;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
STp->logical_blk_num += transfer / STp->block_size;
|
|
|
|
|
STps->drv_block += transfer / STp->block_size;
|
2010-05-26 15:44:44 -06:00
|
|
|
|
*ppos += transfer;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
buf += transfer;
|
|
|
|
|
total += transfer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->buffer_bytes == 0) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Finished with frame %d\n",
|
|
|
|
|
name, STp->frame_seq_number);
|
|
|
|
|
#endif
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
STp->frame_seq_number++; /* frame to look for next time */
|
|
|
|
|
}
|
|
|
|
|
} /* for (total = 0, special = 0; total < count && !special; ) */
|
|
|
|
|
|
|
|
|
|
/* Change the eof state if no data from tape or buffer */
|
|
|
|
|
if (total == 0) {
|
|
|
|
|
if (STps->eof == ST_FM_HIT) {
|
|
|
|
|
STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD_2:ST_FM;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
if (STps->drv_file >= 0)
|
|
|
|
|
STps->drv_file++;
|
|
|
|
|
}
|
|
|
|
|
else if (STps->eof == ST_EOD_1) {
|
|
|
|
|
STps->eof = ST_EOD_2;
|
|
|
|
|
if (STps->drv_block > 0 && STps->drv_file >= 0)
|
|
|
|
|
STps->drv_file++;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
}
|
|
|
|
|
else if (STps->eof == ST_EOD_2)
|
|
|
|
|
STps->eof = ST_EOD;
|
|
|
|
|
}
|
|
|
|
|
else if (STps->eof == ST_FM)
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
|
|
|
|
|
retval = total;
|
|
|
|
|
|
|
|
|
|
out:
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (SRpnt != NULL) osst_release_request(SRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-08-10 15:50:44 -06:00
|
|
|
|
mutex_unlock(&STp->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Set the driver options */
|
|
|
|
|
static void osst_log_options(struct osst_tape *STp, struct st_modedef *STm, char *name)
|
|
|
|
|
{
|
|
|
|
|
printk(KERN_INFO
|
|
|
|
|
"%s:I: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
|
|
|
|
|
name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
|
|
|
|
|
STm->do_read_ahead);
|
|
|
|
|
printk(KERN_INFO
|
|
|
|
|
"%s:I: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
|
|
|
|
|
name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
|
|
|
|
|
printk(KERN_INFO
|
|
|
|
|
"%s:I: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
|
|
|
|
|
name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
|
|
|
|
|
STp->scsi2_logical);
|
|
|
|
|
printk(KERN_INFO
|
|
|
|
|
"%s:I: sysv: %d\n", name, STm->sysv);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(KERN_INFO
|
|
|
|
|
"%s:D: debugging: %d\n",
|
|
|
|
|
name, debugging);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int osst_set_options(struct osst_tape *STp, long options)
|
|
|
|
|
{
|
|
|
|
|
int value;
|
|
|
|
|
long code;
|
|
|
|
|
struct st_modedef * STm;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
STm = &(STp->modes[STp->current_mode]);
|
|
|
|
|
if (!STm->defined) {
|
|
|
|
|
memcpy(STm, &(STp->modes[0]), sizeof(*STm));
|
|
|
|
|
modes_defined = 1;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Initialized mode %d definition from mode 0\n",
|
|
|
|
|
name, STp->current_mode);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
code = options & MT_ST_OPTIONS;
|
|
|
|
|
if (code == MT_ST_BOOLEANS) {
|
|
|
|
|
STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
|
|
|
|
|
STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
|
|
|
|
|
STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
|
|
|
|
|
STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
|
|
|
|
|
STp->two_fm = (options & MT_ST_TWO_FM) != 0;
|
|
|
|
|
STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
|
|
|
|
|
STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
|
|
|
|
|
STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
|
|
|
|
|
STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
|
|
|
|
|
if ((STp->device)->scsi_level >= SCSI_2)
|
|
|
|
|
STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
|
|
|
|
|
STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
|
|
|
|
|
STm->sysv = (options & MT_ST_SYSV) != 0;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
debugging = (options & MT_ST_DEBUGGING) != 0;
|
|
|
|
|
#endif
|
|
|
|
|
osst_log_options(STp, STm, name);
|
|
|
|
|
}
|
|
|
|
|
else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
|
|
|
|
|
value = (code == MT_ST_SETBOOLEANS);
|
|
|
|
|
if ((options & MT_ST_BUFFER_WRITES) != 0)
|
|
|
|
|
STm->do_buffer_writes = value;
|
|
|
|
|
if ((options & MT_ST_ASYNC_WRITES) != 0)
|
|
|
|
|
STm->do_async_writes = value;
|
|
|
|
|
if ((options & MT_ST_DEF_WRITES) != 0)
|
|
|
|
|
STm->defaults_for_writes = value;
|
|
|
|
|
if ((options & MT_ST_READ_AHEAD) != 0)
|
|
|
|
|
STm->do_read_ahead = value;
|
|
|
|
|
if ((options & MT_ST_TWO_FM) != 0)
|
|
|
|
|
STp->two_fm = value;
|
|
|
|
|
if ((options & MT_ST_FAST_MTEOM) != 0)
|
|
|
|
|
STp->fast_mteom = value;
|
|
|
|
|
if ((options & MT_ST_AUTO_LOCK) != 0)
|
|
|
|
|
STp->do_auto_lock = value;
|
|
|
|
|
if ((options & MT_ST_CAN_BSR) != 0)
|
|
|
|
|
STp->can_bsr = value;
|
|
|
|
|
if ((options & MT_ST_NO_BLKLIMS) != 0)
|
|
|
|
|
STp->omit_blklims = value;
|
|
|
|
|
if ((STp->device)->scsi_level >= SCSI_2 &&
|
|
|
|
|
(options & MT_ST_CAN_PARTITIONS) != 0)
|
|
|
|
|
STp->can_partitions = value;
|
|
|
|
|
if ((options & MT_ST_SCSI2LOGICAL) != 0)
|
|
|
|
|
STp->scsi2_logical = value;
|
|
|
|
|
if ((options & MT_ST_SYSV) != 0)
|
|
|
|
|
STm->sysv = value;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if ((options & MT_ST_DEBUGGING) != 0)
|
|
|
|
|
debugging = value;
|
|
|
|
|
#endif
|
|
|
|
|
osst_log_options(STp, STm, name);
|
|
|
|
|
}
|
|
|
|
|
else if (code == MT_ST_WRITE_THRESHOLD) {
|
|
|
|
|
value = (options & ~MT_ST_OPTIONS) * ST_KILOBYTE;
|
|
|
|
|
if (value < 1 || value > osst_buffer_size) {
|
|
|
|
|
printk(KERN_WARNING "%s:W: Write threshold %d too small or too large.\n",
|
|
|
|
|
name, value);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
STp->write_threshold = value;
|
|
|
|
|
printk(KERN_INFO "%s:I: Write threshold set to %d bytes.\n",
|
|
|
|
|
name, value);
|
|
|
|
|
}
|
|
|
|
|
else if (code == MT_ST_DEF_BLKSIZE) {
|
|
|
|
|
value = (options & ~MT_ST_OPTIONS);
|
|
|
|
|
if (value == ~MT_ST_OPTIONS) {
|
|
|
|
|
STm->default_blksize = (-1);
|
|
|
|
|
printk(KERN_INFO "%s:I: Default block size disabled.\n", name);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
if (value < 512 || value > OS_DATA_SIZE || OS_DATA_SIZE % value) {
|
|
|
|
|
printk(KERN_WARNING "%s:W: Default block size cannot be set to %d.\n",
|
|
|
|
|
name, value);
|
|
|
|
|
return (-EINVAL);
|
|
|
|
|
}
|
|
|
|
|
STm->default_blksize = value;
|
|
|
|
|
printk(KERN_INFO "%s:I: Default block size set to %d bytes.\n",
|
|
|
|
|
name, STm->default_blksize);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (code == MT_ST_TIMEOUTS) {
|
|
|
|
|
value = (options & ~MT_ST_OPTIONS);
|
|
|
|
|
if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
|
|
|
|
|
STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
|
|
|
|
|
printk(KERN_INFO "%s:I: Long timeout set to %d seconds.\n", name,
|
|
|
|
|
(value & ~MT_ST_SET_LONG_TIMEOUT));
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
STp->timeout = value * HZ;
|
|
|
|
|
printk(KERN_INFO "%s:I: Normal timeout set to %d seconds.\n", name, value);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (code == MT_ST_DEF_OPTIONS) {
|
|
|
|
|
code = (options & ~MT_ST_CLEAR_DEFAULT);
|
|
|
|
|
value = (options & MT_ST_CLEAR_DEFAULT);
|
|
|
|
|
if (code == MT_ST_DEF_DENSITY) {
|
|
|
|
|
if (value == MT_ST_CLEAR_DEFAULT) {
|
|
|
|
|
STm->default_density = (-1);
|
|
|
|
|
printk(KERN_INFO "%s:I: Density default disabled.\n", name);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
STm->default_density = value & 0xff;
|
|
|
|
|
printk(KERN_INFO "%s:I: Density default set to %x\n",
|
|
|
|
|
name, STm->default_density);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (code == MT_ST_DEF_DRVBUFFER) {
|
|
|
|
|
if (value == MT_ST_CLEAR_DEFAULT) {
|
|
|
|
|
STp->default_drvbuffer = 0xff;
|
|
|
|
|
printk(KERN_INFO "%s:I: Drive buffer default disabled.\n", name);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
STp->default_drvbuffer = value & 7;
|
|
|
|
|
printk(KERN_INFO "%s:I: Drive buffer default set to %x\n",
|
|
|
|
|
name, STp->default_drvbuffer);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (code == MT_ST_DEF_COMPRESSION) {
|
|
|
|
|
if (value == MT_ST_CLEAR_DEFAULT) {
|
|
|
|
|
STm->default_compression = ST_DONT_TOUCH;
|
|
|
|
|
printk(KERN_INFO "%s:I: Compression default disabled.\n", name);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
STm->default_compression = (value & 1 ? ST_YES : ST_NO);
|
|
|
|
|
printk(KERN_INFO "%s:I: Compression default set to %x\n",
|
|
|
|
|
name, (value & 1));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return (-EIO);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Internal ioctl function */
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
static int osst_int_ioctl(struct osst_tape * STp, struct osst_request ** aSRpnt,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned int cmd_in, unsigned long arg)
|
|
|
|
|
{
|
|
|
|
|
int timeout;
|
|
|
|
|
long ltmp;
|
|
|
|
|
int i, ioctl_result;
|
|
|
|
|
int chg_eof = 1;
|
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt = * aSRpnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
struct st_partstat * STps;
|
|
|
|
|
int fileno, blkno, at_sm, frame_seq_numbr, logical_blk_num;
|
|
|
|
|
int datalen = 0, direction = DMA_NONE;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
if (STp->ready != ST_READY && cmd_in != MTLOAD) {
|
|
|
|
|
if (STp->ready == ST_NO_TAPE)
|
|
|
|
|
return (-ENOMEDIUM);
|
|
|
|
|
else
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
timeout = STp->long_timeout;
|
|
|
|
|
STps = &(STp->ps[STp->partition]);
|
|
|
|
|
fileno = STps->drv_file;
|
|
|
|
|
blkno = STps->drv_block;
|
|
|
|
|
at_sm = STps->at_sm;
|
|
|
|
|
frame_seq_numbr = STp->frame_seq_number;
|
|
|
|
|
logical_blk_num = STp->logical_blk_num;
|
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
switch (cmd_in) {
|
|
|
|
|
case MTFSFM:
|
|
|
|
|
chg_eof = 0; /* Changed from the FSF after this */
|
|
|
|
|
case MTFSF:
|
|
|
|
|
if (STp->raw)
|
|
|
|
|
return (-EIO);
|
|
|
|
|
if (STp->linux_media)
|
|
|
|
|
ioctl_result = osst_space_over_filemarks_forward_fast(STp, &SRpnt, cmd_in, arg);
|
|
|
|
|
else
|
|
|
|
|
ioctl_result = osst_space_over_filemarks_forward_slow(STp, &SRpnt, cmd_in, arg);
|
|
|
|
|
if (fileno >= 0)
|
|
|
|
|
fileno += arg;
|
|
|
|
|
blkno = 0;
|
|
|
|
|
at_sm &= (arg == 0);
|
|
|
|
|
goto os_bypass;
|
|
|
|
|
|
|
|
|
|
case MTBSF:
|
|
|
|
|
chg_eof = 0; /* Changed from the FSF after this */
|
|
|
|
|
case MTBSFM:
|
|
|
|
|
if (STp->raw)
|
|
|
|
|
return (-EIO);
|
|
|
|
|
ioctl_result = osst_space_over_filemarks_backward(STp, &SRpnt, cmd_in, arg);
|
|
|
|
|
if (fileno >= 0)
|
|
|
|
|
fileno -= arg;
|
|
|
|
|
blkno = (-1); /* We can't know the block number */
|
|
|
|
|
at_sm &= (arg == 0);
|
|
|
|
|
goto os_bypass;
|
|
|
|
|
|
|
|
|
|
case MTFSR:
|
|
|
|
|
case MTBSR:
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Skipping %lu blocks %s from logical block %d\n",
|
|
|
|
|
name, arg, cmd_in==MTFSR?"forward":"backward", logical_blk_num);
|
|
|
|
|
#endif
|
|
|
|
|
if (cmd_in == MTFSR) {
|
|
|
|
|
logical_blk_num += arg;
|
|
|
|
|
if (blkno >= 0) blkno += arg;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
logical_blk_num -= arg;
|
|
|
|
|
if (blkno >= 0) blkno -= arg;
|
|
|
|
|
}
|
|
|
|
|
ioctl_result = osst_seek_logical_blk(STp, &SRpnt, logical_blk_num);
|
|
|
|
|
fileno = STps->drv_file;
|
|
|
|
|
blkno = STps->drv_block;
|
|
|
|
|
at_sm &= (arg == 0);
|
|
|
|
|
goto os_bypass;
|
|
|
|
|
|
|
|
|
|
case MTFSS:
|
|
|
|
|
cmd[0] = SPACE;
|
|
|
|
|
cmd[1] = 0x04; /* Space Setmarks */ /* FIXME -- OS can't do this? */
|
|
|
|
|
cmd[2] = (arg >> 16);
|
|
|
|
|
cmd[3] = (arg >> 8);
|
|
|
|
|
cmd[4] = arg;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Spacing tape forward %d setmarks.\n", name,
|
|
|
|
|
cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
|
|
|
|
|
#endif
|
|
|
|
|
if (arg != 0) {
|
|
|
|
|
blkno = fileno = (-1);
|
|
|
|
|
at_sm = 1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case MTBSS:
|
|
|
|
|
cmd[0] = SPACE;
|
|
|
|
|
cmd[1] = 0x04; /* Space Setmarks */ /* FIXME -- OS can't do this? */
|
|
|
|
|
ltmp = (-arg);
|
|
|
|
|
cmd[2] = (ltmp >> 16);
|
|
|
|
|
cmd[3] = (ltmp >> 8);
|
|
|
|
|
cmd[4] = ltmp;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging) {
|
|
|
|
|
if (cmd[2] & 0x80)
|
|
|
|
|
ltmp = 0xff000000;
|
|
|
|
|
ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Spacing tape backward %ld setmarks.\n",
|
|
|
|
|
name, (-ltmp));
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
if (arg != 0) {
|
|
|
|
|
blkno = fileno = (-1);
|
|
|
|
|
at_sm = 1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case MTWEOF:
|
|
|
|
|
if ((STps->rw == ST_WRITING || STp->dirty) && !STp->pos_unknown) {
|
|
|
|
|
STp->write_type = OS_WRITE_DATA;
|
|
|
|
|
ioctl_result = osst_flush_write_buffer(STp, &SRpnt);
|
|
|
|
|
} else
|
|
|
|
|
ioctl_result = 0;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Writing %ld filemark(s).\n", name, arg);
|
|
|
|
|
#endif
|
|
|
|
|
for (i=0; i<arg; i++)
|
|
|
|
|
ioctl_result |= osst_write_filemark(STp, &SRpnt);
|
|
|
|
|
if (fileno >= 0) fileno += arg;
|
|
|
|
|
if (blkno >= 0) blkno = 0;
|
|
|
|
|
goto os_bypass;
|
|
|
|
|
|
|
|
|
|
case MTWSM:
|
|
|
|
|
if (STp->write_prot)
|
|
|
|
|
return (-EACCES);
|
|
|
|
|
if (!STp->raw)
|
|
|
|
|
return 0;
|
|
|
|
|
cmd[0] = WRITE_FILEMARKS; /* FIXME -- need OS version */
|
|
|
|
|
if (cmd_in == MTWSM)
|
|
|
|
|
cmd[1] = 2;
|
|
|
|
|
cmd[2] = (arg >> 16);
|
|
|
|
|
cmd[3] = (arg >> 8);
|
|
|
|
|
cmd[4] = arg;
|
|
|
|
|
timeout = STp->timeout;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Writing %d setmark(s).\n", name,
|
|
|
|
|
cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
|
|
|
|
|
#endif
|
|
|
|
|
if (fileno >= 0)
|
|
|
|
|
fileno += arg;
|
|
|
|
|
blkno = 0;
|
|
|
|
|
at_sm = (cmd_in == MTWSM);
|
|
|
|
|
break;
|
|
|
|
|
case MTOFFL:
|
|
|
|
|
case MTLOAD:
|
|
|
|
|
case MTUNLOAD:
|
|
|
|
|
case MTRETEN:
|
|
|
|
|
cmd[0] = START_STOP;
|
|
|
|
|
cmd[1] = 1; /* Don't wait for completion */
|
|
|
|
|
if (cmd_in == MTLOAD) {
|
|
|
|
|
if (STp->ready == ST_NO_TAPE)
|
|
|
|
|
cmd[4] = 4; /* open tray */
|
|
|
|
|
else
|
|
|
|
|
cmd[4] = 1; /* load */
|
|
|
|
|
}
|
|
|
|
|
if (cmd_in == MTRETEN)
|
|
|
|
|
cmd[4] = 3; /* retension then mount */
|
|
|
|
|
if (cmd_in == MTOFFL)
|
|
|
|
|
cmd[4] = 4; /* rewind then eject */
|
|
|
|
|
timeout = STp->timeout;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging) {
|
|
|
|
|
switch (cmd_in) {
|
|
|
|
|
case MTUNLOAD:
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Unloading tape.\n", name);
|
|
|
|
|
break;
|
|
|
|
|
case MTLOAD:
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Loading tape.\n", name);
|
|
|
|
|
break;
|
|
|
|
|
case MTRETEN:
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Retensioning tape.\n", name);
|
|
|
|
|
break;
|
|
|
|
|
case MTOFFL:
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Ejecting tape.\n", name);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
fileno = blkno = at_sm = frame_seq_numbr = logical_blk_num = 0 ;
|
|
|
|
|
break;
|
|
|
|
|
case MTNOP:
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: No-op on tape.\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return 0; /* Should do something ? */
|
|
|
|
|
break;
|
|
|
|
|
case MTEOM:
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Spacing to end of recorded medium.\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
if ((osst_position_tape_and_confirm(STp, &SRpnt, STp->eod_frame_ppos) < 0) ||
|
|
|
|
|
(osst_get_logical_frame(STp, &SRpnt, -1, 0) < 0)) {
|
|
|
|
|
ioctl_result = -EIO;
|
|
|
|
|
goto os_bypass;
|
|
|
|
|
}
|
|
|
|
|
if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_EOD) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: No EOD frame found where expected.\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
ioctl_result = -EIO;
|
|
|
|
|
goto os_bypass;
|
|
|
|
|
}
|
|
|
|
|
ioctl_result = osst_set_frame_position(STp, &SRpnt, STp->eod_frame_ppos, 0);
|
|
|
|
|
fileno = STp->filemark_cnt;
|
|
|
|
|
blkno = at_sm = 0;
|
|
|
|
|
goto os_bypass;
|
|
|
|
|
|
|
|
|
|
case MTERASE:
|
|
|
|
|
if (STp->write_prot)
|
|
|
|
|
return (-EACCES);
|
|
|
|
|
ioctl_result = osst_reset_header(STp, &SRpnt);
|
|
|
|
|
i = osst_write_eod(STp, &SRpnt);
|
|
|
|
|
if (i < ioctl_result) ioctl_result = i;
|
|
|
|
|
i = osst_position_tape_and_confirm(STp, &SRpnt, STp->eod_frame_ppos);
|
|
|
|
|
if (i < ioctl_result) ioctl_result = i;
|
|
|
|
|
fileno = blkno = at_sm = 0 ;
|
|
|
|
|
goto os_bypass;
|
|
|
|
|
|
|
|
|
|
case MTREW:
|
|
|
|
|
cmd[0] = REZERO_UNIT; /* rewind */
|
|
|
|
|
cmd[1] = 1;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Rewinding tape, Immed=%d.\n", name, cmd[1]);
|
|
|
|
|
#endif
|
|
|
|
|
fileno = blkno = at_sm = frame_seq_numbr = logical_blk_num = 0 ;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case MTSETBLK: /* Set block length */
|
|
|
|
|
if ((STps->drv_block == 0 ) &&
|
|
|
|
|
!STp->dirty &&
|
|
|
|
|
((STp->buffer)->buffer_bytes == 0) &&
|
|
|
|
|
((arg & MT_ST_BLKSIZE_MASK) >= 512 ) &&
|
|
|
|
|
((arg & MT_ST_BLKSIZE_MASK) <= OS_DATA_SIZE) &&
|
|
|
|
|
!(OS_DATA_SIZE % (arg & MT_ST_BLKSIZE_MASK)) ) {
|
|
|
|
|
/*
|
|
|
|
|
* Only allowed to change the block size if you opened the
|
|
|
|
|
* device at the beginning of a file before writing anything.
|
|
|
|
|
* Note, that when reading, changing block_size is futile,
|
|
|
|
|
* as the size used when writing overrides it.
|
|
|
|
|
*/
|
|
|
|
|
STp->block_size = (arg & MT_ST_BLKSIZE_MASK);
|
|
|
|
|
printk(KERN_INFO "%s:I: Block size set to %d bytes.\n",
|
|
|
|
|
name, STp->block_size);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
case MTSETDENSITY: /* Set tape density */
|
|
|
|
|
case MTSETDRVBUFFER: /* Set drive buffering */
|
|
|
|
|
case SET_DENS_AND_BLK: /* Set density and block size */
|
|
|
|
|
chg_eof = 0;
|
|
|
|
|
if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
|
|
|
|
|
return (-EIO); /* Not allowed if data in buffer */
|
|
|
|
|
if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
|
|
|
|
|
(arg & MT_ST_BLKSIZE_MASK) != 0 &&
|
|
|
|
|
(arg & MT_ST_BLKSIZE_MASK) != STp->block_size ) {
|
|
|
|
|
printk(KERN_WARNING "%s:W: Illegal to set block size to %d%s.\n",
|
|
|
|
|
name, (int)(arg & MT_ST_BLKSIZE_MASK),
|
|
|
|
|
(OS_DATA_SIZE % (arg & MT_ST_BLKSIZE_MASK))?"":" now");
|
|
|
|
|
return (-EINVAL);
|
|
|
|
|
}
|
|
|
|
|
return 0; /* FIXME silently ignore if block size didn't change */
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
return (-ENOSYS);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, datalen, direction, timeout, MAX_RETRIES, 1);
|
|
|
|
|
|
|
|
|
|
ioctl_result = (STp->buffer)->syscall_result;
|
|
|
|
|
|
|
|
|
|
if (!SRpnt) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Couldn't exec scsi cmd for IOCTL\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return ioctl_result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!ioctl_result) { /* SCSI command successful */
|
|
|
|
|
STp->frame_seq_number = frame_seq_numbr;
|
|
|
|
|
STp->logical_blk_num = logical_blk_num;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
os_bypass:
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: IOCTL (%d) Result=%d\n", name, cmd_in, ioctl_result);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (!ioctl_result) { /* success */
|
|
|
|
|
|
|
|
|
|
if (cmd_in == MTFSFM) {
|
|
|
|
|
fileno--;
|
|
|
|
|
blkno--;
|
|
|
|
|
}
|
|
|
|
|
if (cmd_in == MTBSFM) {
|
|
|
|
|
fileno++;
|
|
|
|
|
blkno++;
|
|
|
|
|
}
|
|
|
|
|
STps->drv_block = blkno;
|
|
|
|
|
STps->drv_file = fileno;
|
|
|
|
|
STps->at_sm = at_sm;
|
|
|
|
|
|
|
|
|
|
if (cmd_in == MTEOM)
|
|
|
|
|
STps->eof = ST_EOD;
|
|
|
|
|
else if ((cmd_in == MTFSFM || cmd_in == MTBSF) && STps->eof == ST_FM_HIT) {
|
|
|
|
|
ioctl_result = osst_seek_logical_blk(STp, &SRpnt, STp->logical_blk_num-1);
|
|
|
|
|
STps->drv_block++;
|
|
|
|
|
STp->logical_blk_num++;
|
|
|
|
|
STp->frame_seq_number++;
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
STp->buffer->read_pointer = 0;
|
|
|
|
|
}
|
|
|
|
|
else if (cmd_in == MTFSF)
|
|
|
|
|
STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD:ST_FM;
|
|
|
|
|
else if (chg_eof)
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
|
|
|
|
|
if (cmd_in == MTOFFL || cmd_in == MTUNLOAD)
|
|
|
|
|
STp->rew_at_close = 0;
|
|
|
|
|
else if (cmd_in == MTLOAD) {
|
|
|
|
|
for (i=0; i < ST_NBR_PARTITIONS; i++) {
|
|
|
|
|
STp->ps[i].rw = ST_IDLE;
|
|
|
|
|
STp->ps[i].last_block_valid = 0;/* FIXME - where else is this field maintained? */
|
|
|
|
|
}
|
|
|
|
|
STp->partition = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (cmd_in == MTREW) {
|
|
|
|
|
ioctl_result = osst_position_tape_and_confirm(STp, &SRpnt, STp->first_data_ppos);
|
|
|
|
|
if (ioctl_result > 0)
|
|
|
|
|
ioctl_result = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} else if (cmd_in == MTBSF || cmd_in == MTBSFM ) {
|
|
|
|
|
if (osst_position_tape_and_confirm(STp, &SRpnt, STp->first_data_ppos) < 0)
|
|
|
|
|
STps->drv_file = STps->drv_block = -1;
|
|
|
|
|
else
|
|
|
|
|
STps->drv_file = STps->drv_block = 0;
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
} else if (cmd_in == MTFSF || cmd_in == MTFSFM) {
|
|
|
|
|
if (osst_position_tape_and_confirm(STp, &SRpnt, STp->eod_frame_ppos) < 0)
|
|
|
|
|
STps->drv_file = STps->drv_block = -1;
|
|
|
|
|
else {
|
|
|
|
|
STps->drv_file = STp->filemark_cnt;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
}
|
|
|
|
|
STps->eof = ST_EOD;
|
|
|
|
|
} else if (cmd_in == MTBSR || cmd_in == MTFSR || cmd_in == MTWEOF || cmd_in == MTEOM) {
|
|
|
|
|
STps->drv_file = STps->drv_block = (-1);
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
STp->header_ok = 0;
|
|
|
|
|
} else if (cmd_in == MTERASE) {
|
|
|
|
|
STp->header_ok = 0;
|
|
|
|
|
} else if (SRpnt) { /* SCSI command was not completely successful. */
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (SRpnt->sense[2] & 0x40) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STps->eof = ST_EOM_OK;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
}
|
|
|
|
|
if (chg_eof)
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ((SRpnt->sense[2] & 0x0f) == BLANK_CHECK)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STps->eof = ST_EOD;
|
|
|
|
|
|
|
|
|
|
if (cmd_in == MTLOAD && osst_wait_for_medium(STp, &SRpnt, 60))
|
|
|
|
|
ioctl_result = osst_wait_ready(STp, &SRpnt, 5 * 60, OSST_WAIT_POSITION_COMPLETE);
|
|
|
|
|
}
|
|
|
|
|
*aSRpnt = SRpnt;
|
|
|
|
|
|
|
|
|
|
return ioctl_result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Open the device */
|
2008-05-15 12:23:19 -06:00
|
|
|
|
static int __os_scsi_tape_open(struct inode * inode, struct file * filp)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
unsigned short flags;
|
|
|
|
|
int i, b_size, new_session = 0, retval = 0;
|
|
|
|
|
unsigned char cmd[MAX_COMMAND_SIZE];
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
struct osst_tape * STp;
|
|
|
|
|
struct st_modedef * STm;
|
|
|
|
|
struct st_partstat * STps;
|
|
|
|
|
char * name;
|
|
|
|
|
int dev = TAPE_NR(inode);
|
|
|
|
|
int mode = TAPE_MODE(inode);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We really want to do nonseekable_open(inode, filp); here, but some
|
|
|
|
|
* versions of tar incorrectly call lseek on tapes and bail out if that
|
|
|
|
|
* fails. So we disallow pread() and pwrite(), but permit lseeks.
|
|
|
|
|
*/
|
|
|
|
|
filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
|
|
|
|
|
|
|
|
|
|
write_lock(&os_scsi_tapes_lock);
|
|
|
|
|
if (dev >= osst_max_dev || os_scsi_tapes == NULL ||
|
|
|
|
|
(STp = os_scsi_tapes[dev]) == NULL || !STp->device) {
|
|
|
|
|
write_unlock(&os_scsi_tapes_lock);
|
|
|
|
|
return (-ENXIO);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
if (STp->in_use) {
|
|
|
|
|
write_unlock(&os_scsi_tapes_lock);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Device already in use.\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-EBUSY);
|
|
|
|
|
}
|
|
|
|
|
if (scsi_device_get(STp->device)) {
|
|
|
|
|
write_unlock(&os_scsi_tapes_lock);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Failed scsi_device_get.\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
return (-ENXIO);
|
|
|
|
|
}
|
|
|
|
|
filp->private_data = STp;
|
|
|
|
|
STp->in_use = 1;
|
|
|
|
|
write_unlock(&os_scsi_tapes_lock);
|
|
|
|
|
STp->rew_at_close = TAPE_REWIND(inode);
|
|
|
|
|
|
|
|
|
|
if( !scsi_block_when_processing_errors(STp->device) ) {
|
|
|
|
|
return -ENXIO;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mode != STp->current_mode) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Mode change from %d to %d.\n",
|
|
|
|
|
name, STp->current_mode, mode);
|
|
|
|
|
#endif
|
|
|
|
|
new_session = 1;
|
|
|
|
|
STp->current_mode = mode;
|
|
|
|
|
}
|
|
|
|
|
STm = &(STp->modes[STp->current_mode]);
|
|
|
|
|
|
|
|
|
|
flags = filp->f_flags;
|
|
|
|
|
STp->write_prot = ((flags & O_ACCMODE) == O_RDONLY);
|
|
|
|
|
|
|
|
|
|
STp->raw = TAPE_IS_RAW(inode);
|
|
|
|
|
if (STp->raw)
|
|
|
|
|
STp->header_ok = 0;
|
|
|
|
|
|
|
|
|
|
/* Allocate data segments for this device's tape buffer */
|
|
|
|
|
if (!enlarge_buffer(STp->buffer, STp->restr_dma)) {
|
|
|
|
|
printk(KERN_ERR "%s:E: Unable to allocate memory segments for tape buffer.\n", name);
|
|
|
|
|
retval = (-EOVERFLOW);
|
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
|
|
|
|
if (STp->buffer->buffer_size >= OS_FRAME_SIZE) {
|
|
|
|
|
for (i = 0, b_size = 0;
|
|
|
|
|
(i < STp->buffer->sg_segs) && ((b_size + STp->buffer->sg[i].length) <= OS_DATA_SIZE);
|
|
|
|
|
b_size += STp->buffer->sg[i++].length);
|
2007-10-22 13:19:53 -06:00
|
|
|
|
STp->buffer->aux = (os_aux_t *) (page_address(sg_page(&STp->buffer->sg[i])) + OS_DATA_SIZE - b_size);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: b_data points to %p in segment 0 at %p\n", name,
|
|
|
|
|
STp->buffer->b_data, page_address(STp->buffer->sg[0].page));
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: AUX points to %p in segment %d at %p\n", name,
|
|
|
|
|
STp->buffer->aux, i, page_address(STp->buffer->sg[i].page));
|
|
|
|
|
#endif
|
|
|
|
|
} else {
|
|
|
|
|
STp->buffer->aux = NULL; /* this had better never happen! */
|
|
|
|
|
printk(KERN_NOTICE "%s:A: Framesize %d too large for buffer.\n", name, OS_FRAME_SIZE);
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
|
|
|
|
STp->buffer->writing = 0;
|
|
|
|
|
STp->buffer->syscall_result = 0;
|
|
|
|
|
STp->dirty = 0;
|
|
|
|
|
for (i=0; i < ST_NBR_PARTITIONS; i++) {
|
|
|
|
|
STps = &(STp->ps[i]);
|
|
|
|
|
STps->rw = ST_IDLE;
|
|
|
|
|
}
|
|
|
|
|
STp->ready = ST_READY;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
STp->nbr_waits = STp->nbr_finished = 0;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
memset (cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = TEST_UNIT_READY;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(NULL, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
if (!SRpnt) {
|
|
|
|
|
retval = (STp->buffer)->syscall_result; /* FIXME - valid? */
|
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ((SRpnt->sense[0] & 0x70) == 0x70 &&
|
|
|
|
|
(SRpnt->sense[2] & 0x0f) == NOT_READY &&
|
|
|
|
|
SRpnt->sense[12] == 4 ) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#if DEBUG
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Unit not ready, cause %x\n", name, SRpnt->sense[13]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#endif
|
|
|
|
|
if (filp->f_flags & O_NONBLOCK) {
|
|
|
|
|
retval = -EAGAIN;
|
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (SRpnt->sense[13] == 2) { /* initialize command required (LOAD) */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
memset (cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = START_STOP;
|
|
|
|
|
cmd[1] = 1;
|
|
|
|
|
cmd[4] = 1;
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
|
|
|
|
|
STp->timeout, MAX_RETRIES, 1);
|
|
|
|
|
}
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
osst_wait_ready(STp, &SRpnt, (SRpnt->sense[13]==1?15:3) * 60, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ((SRpnt->sense[0] & 0x70) == 0x70 &&
|
|
|
|
|
(SRpnt->sense[2] & 0x0f) == UNIT_ATTENTION) { /* New media? */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Unit wants attention\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
STp->header_ok = 0;
|
|
|
|
|
|
|
|
|
|
for (i=0; i < 10; i++) {
|
|
|
|
|
|
|
|
|
|
memset (cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = TEST_UNIT_READY;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
|
|
|
|
|
STp->timeout, MAX_RETRIES, 1);
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ((SRpnt->sense[0] & 0x70) != 0x70 ||
|
|
|
|
|
(SRpnt->sense[2] & 0x0f) != UNIT_ATTENTION)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
STp->pos_unknown = 0;
|
|
|
|
|
STp->partition = STp->new_partition = 0;
|
|
|
|
|
if (STp->can_partitions)
|
|
|
|
|
STp->nbr_partitions = 1; /* This guess will be updated later if necessary */
|
|
|
|
|
for (i=0; i < ST_NBR_PARTITIONS; i++) {
|
|
|
|
|
STps = &(STp->ps[i]);
|
|
|
|
|
STps->rw = ST_IDLE; /* FIXME - seems to be redundant... */
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
STps->at_sm = 0;
|
|
|
|
|
STps->last_block_valid = 0;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
STps->drv_file = 0 ;
|
|
|
|
|
}
|
|
|
|
|
new_session = 1;
|
|
|
|
|
STp->recover_count = 0;
|
|
|
|
|
STp->abort_count = 0;
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
* if we have valid headers from before, and the drive/tape seem untouched,
|
|
|
|
|
* open without reconfiguring and re-reading the headers
|
|
|
|
|
*/
|
|
|
|
|
if (!STp->buffer->syscall_result && STp->header_ok &&
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
!SRpnt->result && SRpnt->sense[0] == 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = MODE_SENSE;
|
|
|
|
|
cmd[1] = 8;
|
|
|
|
|
cmd[2] = VENDOR_IDENT_PAGE;
|
|
|
|
|
cmd[4] = VENDOR_IDENT_PAGE_LENGTH + MODE_HEADER_LENGTH;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1);
|
|
|
|
|
|
|
|
|
|
if (STp->buffer->syscall_result ||
|
|
|
|
|
STp->buffer->b_data[MODE_HEADER_LENGTH + 2] != 'L' ||
|
|
|
|
|
STp->buffer->b_data[MODE_HEADER_LENGTH + 3] != 'I' ||
|
|
|
|
|
STp->buffer->b_data[MODE_HEADER_LENGTH + 4] != 'N' ||
|
|
|
|
|
STp->buffer->b_data[MODE_HEADER_LENGTH + 5] != '4' ) {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Signature was changed to %c%c%c%c\n", name,
|
|
|
|
|
STp->buffer->b_data[MODE_HEADER_LENGTH + 2],
|
|
|
|
|
STp->buffer->b_data[MODE_HEADER_LENGTH + 3],
|
|
|
|
|
STp->buffer->b_data[MODE_HEADER_LENGTH + 4],
|
|
|
|
|
STp->buffer->b_data[MODE_HEADER_LENGTH + 5]);
|
|
|
|
|
#endif
|
|
|
|
|
STp->header_ok = 0;
|
|
|
|
|
}
|
|
|
|
|
i = STp->first_frame_position;
|
|
|
|
|
if (STp->header_ok && i == osst_get_frame_position(STp, &SRpnt)) {
|
|
|
|
|
if (STp->door_locked == ST_UNLOCKED) {
|
|
|
|
|
if (do_door_lock(STp, 1))
|
|
|
|
|
printk(KERN_INFO "%s:I: Can't lock drive door\n", name);
|
|
|
|
|
else
|
|
|
|
|
STp->door_locked = ST_LOCKED_AUTO;
|
|
|
|
|
}
|
|
|
|
|
if (!STp->frame_in_buffer) {
|
|
|
|
|
STp->block_size = (STm->default_blksize > 0) ?
|
|
|
|
|
STm->default_blksize : OS_DATA_SIZE;
|
|
|
|
|
STp->buffer->buffer_bytes = STp->buffer->read_pointer = 0;
|
|
|
|
|
}
|
|
|
|
|
STp->buffer->buffer_blocks = OS_DATA_SIZE / STp->block_size;
|
|
|
|
|
STp->fast_open = 1;
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
osst_release_request(SRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (i != STp->first_frame_position)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Tape position changed from %d to %d\n",
|
|
|
|
|
name, i, STp->first_frame_position);
|
|
|
|
|
#endif
|
|
|
|
|
STp->header_ok = 0;
|
|
|
|
|
}
|
|
|
|
|
STp->fast_open = 0;
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->syscall_result != 0 && /* in all error conditions except no medium */
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
(SRpnt->sense[2] != 2 || SRpnt->sense[12] != 0x3A) ) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
memset(cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = MODE_SELECT;
|
|
|
|
|
cmd[1] = 0x10;
|
|
|
|
|
cmd[4] = 4 + MODE_HEADER_LENGTH;
|
|
|
|
|
|
|
|
|
|
(STp->buffer)->b_data[0] = cmd[4] - 1;
|
|
|
|
|
(STp->buffer)->b_data[1] = 0; /* Medium Type - ignoring */
|
|
|
|
|
(STp->buffer)->b_data[2] = 0; /* Reserved */
|
|
|
|
|
(STp->buffer)->b_data[3] = 0; /* Block Descriptor Length */
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 0] = 0x3f;
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 1] = 1;
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] = 2;
|
|
|
|
|
(STp->buffer)->b_data[MODE_HEADER_LENGTH + 3] = 3;
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Applying soft reset\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1);
|
|
|
|
|
|
|
|
|
|
STp->header_ok = 0;
|
|
|
|
|
|
|
|
|
|
for (i=0; i < 10; i++) {
|
|
|
|
|
|
|
|
|
|
memset (cmd, 0, MAX_COMMAND_SIZE);
|
|
|
|
|
cmd[0] = TEST_UNIT_READY;
|
|
|
|
|
|
|
|
|
|
SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
|
|
|
|
|
STp->timeout, MAX_RETRIES, 1);
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ((SRpnt->sense[0] & 0x70) != 0x70 ||
|
|
|
|
|
(SRpnt->sense[2] & 0x0f) == NOT_READY)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
break;
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if ((SRpnt->sense[2] & 0x0f) == UNIT_ATTENTION) {
|
2011-05-23 16:29:13 -06:00
|
|
|
|
int j;
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STp->pos_unknown = 0;
|
|
|
|
|
STp->partition = STp->new_partition = 0;
|
|
|
|
|
if (STp->can_partitions)
|
|
|
|
|
STp->nbr_partitions = 1; /* This guess will be updated later if necessary */
|
2011-05-23 16:29:12 -06:00
|
|
|
|
for (j = 0; j < ST_NBR_PARTITIONS; j++) {
|
|
|
|
|
STps = &(STp->ps[j]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STps->rw = ST_IDLE;
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
STps->at_sm = 0;
|
|
|
|
|
STps->last_block_valid = 0;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
STps->drv_file = 0 ;
|
|
|
|
|
}
|
|
|
|
|
new_session = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (osst_wait_ready(STp, &SRpnt, 15 * 60, 0)) /* FIXME - not allowed with NOBLOCK */
|
|
|
|
|
printk(KERN_INFO "%s:I: Device did not become Ready in open\n", name);
|
|
|
|
|
|
|
|
|
|
if ((STp->buffer)->syscall_result != 0) {
|
|
|
|
|
if ((STp->device)->scsi_level >= SCSI_2 &&
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
(SRpnt->sense[0] & 0x70) == 0x70 &&
|
|
|
|
|
(SRpnt->sense[2] & 0x0f) == NOT_READY &&
|
|
|
|
|
SRpnt->sense[12] == 0x3a) { /* Check ASC */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STp->ready = ST_NO_TAPE;
|
|
|
|
|
} else
|
|
|
|
|
STp->ready = ST_NOT_READY;
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
osst_release_request(SRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
SRpnt = NULL;
|
|
|
|
|
STp->density = 0; /* Clear the erroneous "residue" */
|
|
|
|
|
STp->write_prot = 0;
|
|
|
|
|
STp->block_size = 0;
|
|
|
|
|
STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
|
|
|
|
|
STp->partition = STp->new_partition = 0;
|
|
|
|
|
STp->door_locked = ST_UNLOCKED;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
osst_configure_onstream(STp, &SRpnt);
|
|
|
|
|
|
|
|
|
|
STp->block_size = STp->raw ? OS_FRAME_SIZE : (
|
|
|
|
|
(STm->default_blksize > 0) ? STm->default_blksize : OS_DATA_SIZE);
|
|
|
|
|
STp->buffer->buffer_blocks = STp->raw ? 1 : OS_DATA_SIZE / STp->block_size;
|
|
|
|
|
STp->buffer->buffer_bytes =
|
|
|
|
|
STp->buffer->read_pointer =
|
|
|
|
|
STp->frame_in_buffer = 0;
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Block size: %d, frame size: %d, buffer size: %d (%d blocks).\n",
|
|
|
|
|
name, STp->block_size, OS_FRAME_SIZE, (STp->buffer)->buffer_size,
|
|
|
|
|
(STp->buffer)->buffer_blocks);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (STp->drv_write_prot) {
|
|
|
|
|
STp->write_prot = 1;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Write protected\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
if ((flags & O_ACCMODE) == O_WRONLY || (flags & O_ACCMODE) == O_RDWR) {
|
|
|
|
|
retval = (-EROFS);
|
|
|
|
|
goto err_out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (new_session) { /* Change the drive parameters for the new mode */
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: New Session\n", name);
|
|
|
|
|
#endif
|
|
|
|
|
STp->density_changed = STp->blksize_changed = 0;
|
|
|
|
|
STp->compression_changed = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* properly position the tape and check the ADR headers
|
|
|
|
|
*/
|
|
|
|
|
if (STp->door_locked == ST_UNLOCKED) {
|
|
|
|
|
if (do_door_lock(STp, 1))
|
|
|
|
|
printk(KERN_INFO "%s:I: Can't lock drive door\n", name);
|
|
|
|
|
else
|
|
|
|
|
STp->door_locked = ST_LOCKED_AUTO;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
osst_analyze_headers(STp, &SRpnt);
|
|
|
|
|
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
osst_release_request(SRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
SRpnt = NULL;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
err_out:
|
|
|
|
|
if (SRpnt != NULL)
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
osst_release_request(SRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
normalize_buffer(STp->buffer);
|
|
|
|
|
STp->header_ok = 0;
|
|
|
|
|
STp->in_use = 0;
|
|
|
|
|
scsi_device_put(STp->device);
|
|
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-15 12:23:19 -06:00
|
|
|
|
/* BKL pushdown: spaghetti avoidance wrapper */
|
|
|
|
|
static int os_scsi_tape_open(struct inode * inode, struct file * filp)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
2010-06-02 06:28:52 -06:00
|
|
|
|
mutex_lock(&osst_int_mutex);
|
2008-05-15 12:23:19 -06:00
|
|
|
|
ret = __os_scsi_tape_open(inode, filp);
|
2010-06-02 06:28:52 -06:00
|
|
|
|
mutex_unlock(&osst_int_mutex);
|
2008-05-15 12:23:19 -06:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
/* Flush the tape buffer before close */
|
2006-06-23 03:05:12 -06:00
|
|
|
|
static int os_scsi_tape_flush(struct file * filp, fl_owner_t id)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
int result = 0, result2;
|
|
|
|
|
struct osst_tape * STp = filp->private_data;
|
|
|
|
|
struct st_modedef * STm = &(STp->modes[STp->current_mode]);
|
|
|
|
|
struct st_partstat * STps = &(STp->ps[STp->partition]);
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
|
|
|
|
|
if (file_count(filp) > 1)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if ((STps->rw == ST_WRITING || STp->dirty) && !STp->pos_unknown) {
|
|
|
|
|
STp->write_type = OS_WRITE_DATA;
|
|
|
|
|
result = osst_flush_write_buffer(STp, &SRpnt);
|
|
|
|
|
if (result != 0 && result != (-ENOSPC))
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if ( STps->rw >= ST_WRITING && !STp->pos_unknown) {
|
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging) {
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: File length %ld bytes.\n",
|
|
|
|
|
name, (long)(filp->f_pos));
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Async write waits %d, finished %d.\n",
|
|
|
|
|
name, STp->nbr_waits, STp->nbr_finished);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
result = osst_write_trailer(STp, &SRpnt, !(STp->rew_at_close));
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Buffer flushed, %d EOF(s) written\n",
|
|
|
|
|
name, 1+STp->two_fm);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
else if (!STp->rew_at_close) {
|
|
|
|
|
STps = &(STp->ps[STp->partition]);
|
|
|
|
|
if (!STm->sysv || STps->rw != ST_READING) {
|
|
|
|
|
if (STp->can_bsr)
|
|
|
|
|
result = osst_flush_buffer(STp, &SRpnt, 0); /* this is the default path */
|
|
|
|
|
else if (STps->eof == ST_FM_HIT) {
|
|
|
|
|
result = cross_eof(STp, &SRpnt, 0);
|
|
|
|
|
if (result) {
|
|
|
|
|
if (STps->drv_file >= 0)
|
|
|
|
|
STps->drv_file++;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
STps->eof = ST_FM;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if ((STps->eof == ST_NOEOF &&
|
|
|
|
|
!(result = cross_eof(STp, &SRpnt, 1))) ||
|
|
|
|
|
STps->eof == ST_FM_HIT) {
|
|
|
|
|
if (STps->drv_file >= 0)
|
|
|
|
|
STps->drv_file++;
|
|
|
|
|
STps->drv_block = 0;
|
|
|
|
|
STps->eof = ST_FM;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
if (STp->rew_at_close) {
|
|
|
|
|
result2 = osst_position_tape_and_confirm(STp, &SRpnt, STp->first_data_ppos);
|
|
|
|
|
STps->drv_file = STps->drv_block = STp->frame_seq_number = STp->logical_blk_num = 0;
|
|
|
|
|
if (result == 0 && result2 < 0)
|
|
|
|
|
result = result2;
|
|
|
|
|
}
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (SRpnt) osst_release_request(SRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
if (STp->abort_count || STp->recover_count) {
|
|
|
|
|
printk(KERN_INFO "%s:I:", name);
|
|
|
|
|
if (STp->abort_count)
|
|
|
|
|
printk(" %d unrecovered errors", STp->abort_count);
|
|
|
|
|
if (STp->recover_count)
|
|
|
|
|
printk(" %d recovered errors", STp->recover_count);
|
|
|
|
|
if (STp->write_count)
|
|
|
|
|
printk(" in %d frames written", STp->write_count);
|
|
|
|
|
if (STp->read_count)
|
|
|
|
|
printk(" in %d frames read", STp->read_count);
|
|
|
|
|
printk("\n");
|
|
|
|
|
STp->recover_count = 0;
|
|
|
|
|
STp->abort_count = 0;
|
|
|
|
|
}
|
|
|
|
|
STp->write_count = 0;
|
|
|
|
|
STp->read_count = 0;
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Close the device and release it */
|
|
|
|
|
static int os_scsi_tape_close(struct inode * inode, struct file * filp)
|
|
|
|
|
{
|
|
|
|
|
int result = 0;
|
|
|
|
|
struct osst_tape * STp = filp->private_data;
|
|
|
|
|
|
|
|
|
|
if (STp->door_locked == ST_LOCKED_AUTO)
|
|
|
|
|
do_door_lock(STp, 0);
|
|
|
|
|
|
|
|
|
|
if (STp->raw)
|
|
|
|
|
STp->header_ok = 0;
|
|
|
|
|
|
|
|
|
|
normalize_buffer(STp->buffer);
|
|
|
|
|
write_lock(&os_scsi_tapes_lock);
|
|
|
|
|
STp->in_use = 0;
|
|
|
|
|
write_unlock(&os_scsi_tapes_lock);
|
|
|
|
|
|
|
|
|
|
scsi_device_put(STp->device);
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* The ioctl command */
|
2010-04-26 16:24:01 -06:00
|
|
|
|
static long osst_ioctl(struct file * file,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
unsigned int cmd_in, unsigned long arg)
|
|
|
|
|
{
|
2006-09-25 17:59:08 -06:00
|
|
|
|
int i, cmd_nr, cmd_type, blk, retval = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
struct st_modedef * STm;
|
|
|
|
|
struct st_partstat * STps;
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
struct osst_request * SRpnt = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
struct osst_tape * STp = file->private_data;
|
|
|
|
|
char * name = tape_name(STp);
|
|
|
|
|
void __user * p = (void __user *)arg;
|
|
|
|
|
|
2010-06-02 06:28:52 -06:00
|
|
|
|
mutex_lock(&osst_int_mutex);
|
2010-04-26 16:24:01 -06:00
|
|
|
|
if (mutex_lock_interruptible(&STp->lock)) {
|
2010-06-02 06:28:52 -06:00
|
|
|
|
mutex_unlock(&osst_int_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
return -ERESTARTSYS;
|
2010-04-26 16:24:01 -06:00
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging && !STp->in_use) {
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Incorrect device.\n", name);
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
STm = &(STp->modes[STp->current_mode]);
|
|
|
|
|
STps = &(STp->ps[STp->partition]);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If we are in the middle of error recovery, don't let anyone
|
|
|
|
|
* else try and use this device. Also, if error recovery fails, it
|
|
|
|
|
* may try and take the device offline, in which case all further
|
|
|
|
|
* access to the device is prohibited.
|
|
|
|
|
*/
|
2014-10-11 08:25:31 -06:00
|
|
|
|
retval = scsi_ioctl_block_when_processing_errors(STp->device, cmd_in,
|
|
|
|
|
file->f_flags & O_NDELAY);
|
|
|
|
|
if (retval)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
cmd_type = _IOC_TYPE(cmd_in);
|
|
|
|
|
cmd_nr = _IOC_NR(cmd_in);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "%s:D: Ioctl %d,%d in %s mode\n", name,
|
|
|
|
|
cmd_type, cmd_nr, STp->raw?"raw":"normal");
|
|
|
|
|
#endif
|
|
|
|
|
if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
|
|
|
|
|
struct mtop mtc;
|
|
|
|
|
int auto_weof = 0;
|
|
|
|
|
|
|
|
|
|
if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
|
|
|
|
|
retval = (-EINVAL);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
i = copy_from_user((char *) &mtc, p, sizeof(struct mtop));
|
|
|
|
|
if (i) {
|
|
|
|
|
retval = (-EFAULT);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
|
|
|
|
|
printk(KERN_WARNING "%s:W: MTSETDRVBUFFER only allowed for root.\n", name);
|
|
|
|
|
retval = (-EPERM);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!STm->defined && (mtc.mt_op != MTSETDRVBUFFER && (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
|
|
|
|
|
retval = (-ENXIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!STp->pos_unknown) {
|
|
|
|
|
|
|
|
|
|
if (STps->eof == ST_FM_HIT) {
|
|
|
|
|
if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM|| mtc.mt_op == MTEOM) {
|
|
|
|
|
mtc.mt_count -= 1;
|
|
|
|
|
if (STps->drv_file >= 0)
|
|
|
|
|
STps->drv_file += 1;
|
|
|
|
|
}
|
|
|
|
|
else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
|
|
|
|
|
mtc.mt_count += 1;
|
|
|
|
|
if (STps->drv_file >= 0)
|
|
|
|
|
STps->drv_file += 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mtc.mt_op == MTSEEK) {
|
|
|
|
|
/* Old position must be restored if partition will be changed */
|
|
|
|
|
i = !STp->can_partitions || (STp->new_partition != STp->partition);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
|
|
|
|
|
mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
|
|
|
|
|
mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
|
|
|
|
|
mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
|
|
|
|
|
mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
|
|
|
|
|
mtc.mt_op == MTCOMPRESSION;
|
|
|
|
|
}
|
|
|
|
|
i = osst_flush_buffer(STp, &SRpnt, i);
|
|
|
|
|
if (i < 0) {
|
|
|
|
|
retval = i;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/*
|
|
|
|
|
* If there was a bus reset, block further access
|
|
|
|
|
* to this device. If the user wants to rewind the tape,
|
|
|
|
|
* then reset the flag and allow access again.
|
|
|
|
|
*/
|
|
|
|
|
if(mtc.mt_op != MTREW &&
|
|
|
|
|
mtc.mt_op != MTOFFL &&
|
|
|
|
|
mtc.mt_op != MTRETEN &&
|
|
|
|
|
mtc.mt_op != MTERASE &&
|
|
|
|
|
mtc.mt_op != MTSEEK &&
|
|
|
|
|
mtc.mt_op != MTEOM) {
|
|
|
|
|
retval = (-EIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
reset_state(STp);
|
|
|
|
|
/* remove this when the midlevel properly clears was_reset */
|
|
|
|
|
STp->device->was_reset = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mtc.mt_op != MTCOMPRESSION && mtc.mt_op != MTLOCK &&
|
|
|
|
|
mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
|
|
|
|
|
mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTSETDRVBUFFER &&
|
|
|
|
|
mtc.mt_op != MTMKPART && mtc.mt_op != MTSETPART &&
|
|
|
|
|
mtc.mt_op != MTWEOF && mtc.mt_op != MTWSM ) {
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The user tells us to move to another position on the tape.
|
|
|
|
|
* If we were appending to the tape content, that would leave
|
|
|
|
|
* the tape without proper end, in that case write EOD and
|
|
|
|
|
* update the header to reflect its position.
|
|
|
|
|
*/
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(KERN_WARNING "%s:D: auto_weod %s at ffp=%d,efp=%d,fsn=%d,lbn=%d,fn=%d,bn=%d\n", name,
|
|
|
|
|
STps->rw >= ST_WRITING ? "write" : STps->rw == ST_READING ? "read" : "idle",
|
|
|
|
|
STp->first_frame_position, STp->eod_frame_ppos, STp->frame_seq_number,
|
|
|
|
|
STp->logical_blk_num, STps->drv_file, STps->drv_block );
|
|
|
|
|
#endif
|
|
|
|
|
if (STps->rw >= ST_WRITING && STp->first_frame_position >= STp->eod_frame_ppos) {
|
|
|
|
|
auto_weof = ((STp->write_type != OS_WRITE_NEW_MARK) &&
|
|
|
|
|
!(mtc.mt_op == MTREW || mtc.mt_op == MTOFFL));
|
|
|
|
|
i = osst_write_trailer(STp, &SRpnt,
|
|
|
|
|
!(mtc.mt_op == MTREW || mtc.mt_op == MTOFFL));
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(KERN_WARNING "%s:D: post trailer xeof=%d,ffp=%d,efp=%d,fsn=%d,lbn=%d,fn=%d,bn=%d\n",
|
|
|
|
|
name, auto_weof, STp->first_frame_position, STp->eod_frame_ppos,
|
|
|
|
|
STp->frame_seq_number, STp->logical_blk_num, STps->drv_file, STps->drv_block );
|
|
|
|
|
#endif
|
|
|
|
|
if (i < 0) {
|
|
|
|
|
retval = i;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
STps->rw = ST_IDLE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
|
|
|
|
|
do_door_lock(STp, 0); /* Ignore result! */
|
|
|
|
|
|
|
|
|
|
if (mtc.mt_op == MTSETDRVBUFFER &&
|
|
|
|
|
(mtc.mt_count & MT_ST_OPTIONS) != 0) {
|
|
|
|
|
retval = osst_set_options(STp, mtc.mt_count);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mtc.mt_op == MTSETPART) {
|
|
|
|
|
if (mtc.mt_count >= STp->nbr_partitions)
|
|
|
|
|
retval = -EINVAL;
|
|
|
|
|
else {
|
|
|
|
|
STp->new_partition = mtc.mt_count;
|
|
|
|
|
retval = 0;
|
|
|
|
|
}
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mtc.mt_op == MTMKPART) {
|
|
|
|
|
if (!STp->can_partitions) {
|
|
|
|
|
retval = (-EINVAL);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if ((i = osst_int_ioctl(STp, &SRpnt, MTREW, 0)) < 0 /*||
|
|
|
|
|
(i = partition_tape(inode, mtc.mt_count)) < 0*/) {
|
|
|
|
|
retval = i;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
for (i=0; i < ST_NBR_PARTITIONS; i++) {
|
|
|
|
|
STp->ps[i].rw = ST_IDLE;
|
|
|
|
|
STp->ps[i].at_sm = 0;
|
|
|
|
|
STp->ps[i].last_block_valid = 0;
|
|
|
|
|
}
|
|
|
|
|
STp->partition = STp->new_partition = 0;
|
|
|
|
|
STp->nbr_partitions = 1; /* Bad guess ?-) */
|
|
|
|
|
STps->drv_block = STps->drv_file = 0;
|
|
|
|
|
retval = 0;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mtc.mt_op == MTSEEK) {
|
|
|
|
|
if (STp->raw)
|
|
|
|
|
i = osst_set_frame_position(STp, &SRpnt, mtc.mt_count, 0);
|
|
|
|
|
else
|
|
|
|
|
i = osst_seek_sector(STp, &SRpnt, mtc.mt_count);
|
|
|
|
|
if (!STp->can_partitions)
|
|
|
|
|
STp->ps[0].rw = ST_IDLE;
|
|
|
|
|
retval = i;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
|
|
|
|
|
retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (auto_weof)
|
|
|
|
|
cross_eof(STp, &SRpnt, 0);
|
|
|
|
|
|
|
|
|
|
if (mtc.mt_op == MTCOMPRESSION)
|
|
|
|
|
retval = -EINVAL; /* OnStream drives don't have compression hardware */
|
|
|
|
|
else
|
|
|
|
|
/* MTBSF MTBSFM MTBSR MTBSS MTEOM MTERASE MTFSF MTFSFB MTFSR MTFSS
|
|
|
|
|
* MTLOAD MTOFFL MTRESET MTRETEN MTREW MTUNLOAD MTWEOF MTWSM */
|
|
|
|
|
retval = osst_int_ioctl(STp, &SRpnt, mtc.mt_op, mtc.mt_count);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!STm->defined) {
|
|
|
|
|
retval = (-ENXIO);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((i = osst_flush_buffer(STp, &SRpnt, 0)) < 0) {
|
|
|
|
|
retval = i;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
|
|
|
|
|
struct mtget mt_status;
|
|
|
|
|
|
|
|
|
|
if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
|
|
|
|
|
retval = (-EINVAL);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mt_status.mt_type = MT_ISONSTREAM_SC;
|
|
|
|
|
mt_status.mt_erreg = STp->recover_erreg << MT_ST_SOFTERR_SHIFT;
|
|
|
|
|
mt_status.mt_dsreg =
|
|
|
|
|
((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
|
|
|
|
|
((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
|
|
|
|
|
mt_status.mt_blkno = STps->drv_block;
|
|
|
|
|
mt_status.mt_fileno = STps->drv_file;
|
|
|
|
|
if (STp->block_size != 0) {
|
|
|
|
|
if (STps->rw == ST_WRITING)
|
|
|
|
|
mt_status.mt_blkno += (STp->buffer)->buffer_bytes / STp->block_size;
|
|
|
|
|
else if (STps->rw == ST_READING)
|
|
|
|
|
mt_status.mt_blkno -= ((STp->buffer)->buffer_bytes +
|
|
|
|
|
STp->block_size - 1) / STp->block_size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mt_status.mt_gstat = 0;
|
|
|
|
|
if (STp->drv_write_prot)
|
|
|
|
|
mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
|
|
|
|
|
if (mt_status.mt_blkno == 0) {
|
|
|
|
|
if (mt_status.mt_fileno == 0)
|
|
|
|
|
mt_status.mt_gstat |= GMT_BOT(0xffffffff);
|
|
|
|
|
else
|
|
|
|
|
mt_status.mt_gstat |= GMT_EOF(0xffffffff);
|
|
|
|
|
}
|
|
|
|
|
mt_status.mt_resid = STp->partition;
|
|
|
|
|
if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
|
|
|
|
|
mt_status.mt_gstat |= GMT_EOT(0xffffffff);
|
|
|
|
|
else if (STps->eof >= ST_EOM_OK)
|
|
|
|
|
mt_status.mt_gstat |= GMT_EOD(0xffffffff);
|
|
|
|
|
if (STp->density == 1)
|
|
|
|
|
mt_status.mt_gstat |= GMT_D_800(0xffffffff);
|
|
|
|
|
else if (STp->density == 2)
|
|
|
|
|
mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
|
|
|
|
|
else if (STp->density == 3)
|
|
|
|
|
mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
|
|
|
|
|
if (STp->ready == ST_READY)
|
|
|
|
|
mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
|
|
|
|
|
if (STp->ready == ST_NO_TAPE)
|
|
|
|
|
mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
|
|
|
|
|
if (STps->at_sm)
|
|
|
|
|
mt_status.mt_gstat |= GMT_SM(0xffffffff);
|
|
|
|
|
if (STm->do_async_writes || (STm->do_buffer_writes && STp->block_size != 0) ||
|
|
|
|
|
STp->drv_buffer != 0)
|
|
|
|
|
mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
|
|
|
|
|
|
|
|
|
|
i = copy_to_user(p, &mt_status, sizeof(struct mtget));
|
|
|
|
|
if (i) {
|
|
|
|
|
retval = (-EFAULT);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
STp->recover_erreg = 0; /* Clear after read */
|
|
|
|
|
retval = 0;
|
|
|
|
|
goto out;
|
|
|
|
|
} /* End of MTIOCGET */
|
|
|
|
|
|
|
|
|
|
if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
|
|
|
|
|
struct mtpos mt_pos;
|
|
|
|
|
|
|
|
|
|
if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
|
|
|
|
|
retval = (-EINVAL);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if (STp->raw)
|
|
|
|
|
blk = osst_get_frame_position(STp, &SRpnt);
|
|
|
|
|
else
|
|
|
|
|
blk = osst_get_sector(STp, &SRpnt);
|
|
|
|
|
if (blk < 0) {
|
|
|
|
|
retval = blk;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
mt_pos.mt_blkno = blk;
|
|
|
|
|
i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
|
|
|
|
|
if (i)
|
|
|
|
|
retval = -EFAULT;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (SRpnt) osst_release_request(SRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-08-10 15:50:44 -06:00
|
|
|
|
mutex_unlock(&STp->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2010-04-26 16:24:01 -06:00
|
|
|
|
retval = scsi_ioctl(STp->device, cmd_in, p);
|
2010-06-02 06:28:52 -06:00
|
|
|
|
mutex_unlock(&osst_int_mutex);
|
2010-04-26 16:24:01 -06:00
|
|
|
|
return retval;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
out:
|
[SCSI] osst: changes required to move forward to block request
On 02/07/2006 04:12:55 AM, Christoph Hellwig wrote:
> On Mon, Feb 06, 2006 at 08:02:21PM -0500, Willem Riede wrote:
>
> > But I will certainly help retire scsi_request. And anything else that is
> > needed to keep up with proper kernel style. Let me know what those are, if
> > you would? I'll start looking at how st has changed, and will be back with
> > any questions I may have.
>
> right now the above is the most urgent bit. What would be nice but not
> required is a conversion to the sense handling helpers, similar to what
> st got (aka using the *normalize_sense functions and then dealing with the
> parsed sense buffer instead of the raw sense data)
Ok, so here is my first take at satisfying this request.
Be warned, that beyond compiling, and checking that the new module
doesn't immediately blow up, there hasn't yet been a lot of testing.
But this should allow you to comment on the changes, and move forward
with dropping scsi_request from the kernel code.
Signed-off-by: Willem Riede <osst@riede.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-02-11 12:46:56 -07:00
|
|
|
|
if (SRpnt) osst_release_request(SRpnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-08-10 15:50:44 -06:00
|
|
|
|
mutex_unlock(&STp->lock);
|
2010-06-02 06:28:52 -06:00
|
|
|
|
mutex_unlock(&osst_int_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
|
static long osst_compat_ioctl(struct file * file, unsigned int cmd_in, unsigned long arg)
|
|
|
|
|
{
|
|
|
|
|
struct osst_tape *STp = file->private_data;
|
|
|
|
|
struct scsi_device *sdev = STp->device;
|
|
|
|
|
int ret = -ENOIOCTLCMD;
|
|
|
|
|
if (sdev->host->hostt->compat_ioctl) {
|
|
|
|
|
|
|
|
|
|
ret = sdev->host->hostt->compat_ioctl(sdev, cmd_in, (void __user *)arg);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Memory handling routines */
|
|
|
|
|
|
|
|
|
|
/* Try to allocate a new tape buffer skeleton. Caller must not hold os_scsi_tapes_lock */
|
|
|
|
|
static struct osst_buffer * new_tape_buffer( int from_initialization, int need_dma, int max_sg )
|
|
|
|
|
{
|
2005-10-21 01:22:08 -06:00
|
|
|
|
int i;
|
|
|
|
|
gfp_t priority;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
struct osst_buffer *tb;
|
|
|
|
|
|
|
|
|
|
if (from_initialization)
|
|
|
|
|
priority = GFP_ATOMIC;
|
|
|
|
|
else
|
|
|
|
|
priority = GFP_KERNEL;
|
|
|
|
|
|
|
|
|
|
i = sizeof(struct osst_buffer) + (osst_max_sg_segs - 1) * sizeof(struct scatterlist);
|
2006-10-04 03:23:04 -06:00
|
|
|
|
tb = kzalloc(i, priority);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (!tb) {
|
|
|
|
|
printk(KERN_NOTICE "osst :I: Can't allocate new tape buffer.\n");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2006-10-04 03:23:04 -06:00
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
tb->sg_segs = tb->orig_sg_segs = 0;
|
|
|
|
|
tb->use_sg = max_sg;
|
|
|
|
|
tb->in_use = 1;
|
|
|
|
|
tb->dma = need_dma;
|
|
|
|
|
tb->buffer_size = 0;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging)
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"osst :D: Allocated tape buffer skeleton (%d bytes, %d segments, dma: %d).\n",
|
|
|
|
|
i, max_sg, need_dma);
|
|
|
|
|
#endif
|
|
|
|
|
return tb;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Try to allocate a temporary (while a user has the device open) enlarged tape buffer */
|
|
|
|
|
static int enlarge_buffer(struct osst_buffer *STbuffer, int need_dma)
|
|
|
|
|
{
|
2005-10-21 01:22:08 -06:00
|
|
|
|
int segs, nbr, max_segs, b_size, order, got;
|
|
|
|
|
gfp_t priority;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
if (STbuffer->buffer_size >= OS_FRAME_SIZE)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
if (STbuffer->sg_segs) {
|
|
|
|
|
printk(KERN_WARNING "osst :A: Buffer not previously normalized.\n");
|
|
|
|
|
normalize_buffer(STbuffer);
|
|
|
|
|
}
|
|
|
|
|
/* See how many segments we can use -- need at least two */
|
|
|
|
|
nbr = max_segs = STbuffer->use_sg;
|
|
|
|
|
if (nbr <= 2)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
priority = GFP_KERNEL /* | __GFP_NOWARN */;
|
|
|
|
|
if (need_dma)
|
|
|
|
|
priority |= GFP_DMA;
|
|
|
|
|
|
|
|
|
|
/* Try to allocate the first segment up to OS_DATA_SIZE and the others
|
|
|
|
|
big enough to reach the goal (code assumes no segments in place) */
|
|
|
|
|
for (b_size = OS_DATA_SIZE, order = OSST_FIRST_ORDER; b_size >= PAGE_SIZE; order--, b_size /= 2) {
|
2007-10-22 13:19:53 -06:00
|
|
|
|
struct page *page = alloc_pages(priority, order);
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STbuffer->sg[0].offset = 0;
|
2007-10-22 13:19:53 -06:00
|
|
|
|
if (page != NULL) {
|
2007-10-24 03:20:47 -06:00
|
|
|
|
sg_set_page(&STbuffer->sg[0], page, b_size, 0);
|
2007-10-22 13:19:53 -06:00
|
|
|
|
STbuffer->b_data = page_address(page);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2007-10-22 13:19:53 -06:00
|
|
|
|
if (sg_page(&STbuffer->sg[0]) == NULL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk(KERN_NOTICE "osst :I: Can't allocate tape buffer main segment.\n");
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
/* Got initial segment of 'bsize,order', continue with same size if possible, except for AUX */
|
|
|
|
|
for (segs=STbuffer->sg_segs=1, got=b_size;
|
|
|
|
|
segs < max_segs && got < OS_FRAME_SIZE; ) {
|
2007-10-22 13:19:53 -06:00
|
|
|
|
struct page *page = alloc_pages(priority, (OS_FRAME_SIZE - got <= PAGE_SIZE) ? 0 : order);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STbuffer->sg[segs].offset = 0;
|
2007-10-22 13:19:53 -06:00
|
|
|
|
if (page == NULL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk(KERN_WARNING "osst :W: Failed to enlarge buffer to %d bytes.\n",
|
|
|
|
|
OS_FRAME_SIZE);
|
|
|
|
|
#if DEBUG
|
|
|
|
|
STbuffer->buffer_size = got;
|
|
|
|
|
#endif
|
|
|
|
|
normalize_buffer(STbuffer);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2007-10-24 03:20:47 -06:00
|
|
|
|
sg_set_page(&STbuffer->sg[segs], page, (OS_FRAME_SIZE - got <= PAGE_SIZE / 2) ? (OS_FRAME_SIZE - got) : b_size, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
got += STbuffer->sg[segs].length;
|
|
|
|
|
STbuffer->buffer_size = got;
|
|
|
|
|
STbuffer->sg_segs = ++segs;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging) {
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"osst :D: Expanded tape buffer (%d bytes, %d->%d segments, dma: %d, at: %p).\n",
|
|
|
|
|
got, STbuffer->orig_sg_segs, STbuffer->sg_segs, need_dma, STbuffer->b_data);
|
|
|
|
|
printk(OSST_DEB_MSG
|
|
|
|
|
"osst :D: segment sizes: first %d at %p, last %d bytes at %p.\n",
|
|
|
|
|
STbuffer->sg[0].length, page_address(STbuffer->sg[0].page),
|
|
|
|
|
STbuffer->sg[segs-1].length, page_address(STbuffer->sg[segs-1].page));
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Release the segments */
|
|
|
|
|
static void normalize_buffer(struct osst_buffer *STbuffer)
|
|
|
|
|
{
|
|
|
|
|
int i, order, b_size;
|
|
|
|
|
|
|
|
|
|
for (i=0; i < STbuffer->sg_segs; i++) {
|
|
|
|
|
|
|
|
|
|
for (b_size = PAGE_SIZE, order = 0;
|
|
|
|
|
b_size < STbuffer->sg[i].length;
|
|
|
|
|
b_size *= 2, order++);
|
|
|
|
|
|
2007-10-22 13:19:53 -06:00
|
|
|
|
__free_pages(sg_page(&STbuffer->sg[i]), order);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
STbuffer->buffer_size -= STbuffer->sg[i].length;
|
|
|
|
|
}
|
|
|
|
|
#if DEBUG
|
|
|
|
|
if (debugging && STbuffer->orig_sg_segs < STbuffer->sg_segs)
|
|
|
|
|
printk(OSST_DEB_MSG "osst :D: Buffer at %p normalized to %d bytes (segs %d).\n",
|
|
|
|
|
STbuffer->b_data, STbuffer->buffer_size, STbuffer->sg_segs);
|
|
|
|
|
#endif
|
|
|
|
|
STbuffer->sg_segs = STbuffer->orig_sg_segs = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Move data from the user buffer to the tape buffer. Returns zero (success) or
|
|
|
|
|
negative error code. */
|
|
|
|
|
static int append_to_buffer(const char __user *ubp, struct osst_buffer *st_bp, int do_count)
|
|
|
|
|
{
|
|
|
|
|
int i, cnt, res, offset;
|
|
|
|
|
|
|
|
|
|
for (i=0, offset=st_bp->buffer_bytes;
|
|
|
|
|
i < st_bp->sg_segs && offset >= st_bp->sg[i].length; i++)
|
2017-08-15 08:08:28 -06:00
|
|
|
|
offset -= st_bp->sg[i].length;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (i == st_bp->sg_segs) { /* Should never happen */
|
|
|
|
|
printk(KERN_WARNING "osst :A: Append_to_buffer offset overflow.\n");
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
for ( ; i < st_bp->sg_segs && do_count > 0; i++) {
|
|
|
|
|
cnt = st_bp->sg[i].length - offset < do_count ?
|
|
|
|
|
st_bp->sg[i].length - offset : do_count;
|
2007-10-22 13:19:53 -06:00
|
|
|
|
res = copy_from_user(page_address(sg_page(&st_bp->sg[i])) + offset, ubp, cnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (res)
|
|
|
|
|
return (-EFAULT);
|
|
|
|
|
do_count -= cnt;
|
|
|
|
|
st_bp->buffer_bytes += cnt;
|
|
|
|
|
ubp += cnt;
|
|
|
|
|
offset = 0;
|
|
|
|
|
}
|
|
|
|
|
if (do_count) { /* Should never happen */
|
|
|
|
|
printk(KERN_WARNING "osst :A: Append_to_buffer overflow (left %d).\n",
|
|
|
|
|
do_count);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Move data from the tape buffer to the user buffer. Returns zero (success) or
|
|
|
|
|
negative error code. */
|
|
|
|
|
static int from_buffer(struct osst_buffer *st_bp, char __user *ubp, int do_count)
|
|
|
|
|
{
|
|
|
|
|
int i, cnt, res, offset;
|
|
|
|
|
|
|
|
|
|
for (i=0, offset=st_bp->read_pointer;
|
|
|
|
|
i < st_bp->sg_segs && offset >= st_bp->sg[i].length; i++)
|
|
|
|
|
offset -= st_bp->sg[i].length;
|
|
|
|
|
if (i == st_bp->sg_segs) { /* Should never happen */
|
|
|
|
|
printk(KERN_WARNING "osst :A: From_buffer offset overflow.\n");
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
for ( ; i < st_bp->sg_segs && do_count > 0; i++) {
|
|
|
|
|
cnt = st_bp->sg[i].length - offset < do_count ?
|
|
|
|
|
st_bp->sg[i].length - offset : do_count;
|
2007-10-22 13:19:53 -06:00
|
|
|
|
res = copy_to_user(ubp, page_address(sg_page(&st_bp->sg[i])) + offset, cnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (res)
|
|
|
|
|
return (-EFAULT);
|
|
|
|
|
do_count -= cnt;
|
|
|
|
|
st_bp->buffer_bytes -= cnt;
|
|
|
|
|
st_bp->read_pointer += cnt;
|
|
|
|
|
ubp += cnt;
|
|
|
|
|
offset = 0;
|
|
|
|
|
}
|
|
|
|
|
if (do_count) { /* Should never happen */
|
|
|
|
|
printk(KERN_WARNING "osst :A: From_buffer overflow (left %d).\n", do_count);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Sets the tail of the buffer after fill point to zero.
|
|
|
|
|
Returns zero (success) or negative error code. */
|
|
|
|
|
static int osst_zero_buffer_tail(struct osst_buffer *st_bp)
|
|
|
|
|
{
|
|
|
|
|
int i, offset, do_count, cnt;
|
|
|
|
|
|
|
|
|
|
for (i = 0, offset = st_bp->buffer_bytes;
|
|
|
|
|
i < st_bp->sg_segs && offset >= st_bp->sg[i].length; i++)
|
|
|
|
|
offset -= st_bp->sg[i].length;
|
|
|
|
|
if (i == st_bp->sg_segs) { /* Should never happen */
|
|
|
|
|
printk(KERN_WARNING "osst :A: Zero_buffer offset overflow.\n");
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
for (do_count = OS_DATA_SIZE - st_bp->buffer_bytes;
|
|
|
|
|
i < st_bp->sg_segs && do_count > 0; i++) {
|
|
|
|
|
cnt = st_bp->sg[i].length - offset < do_count ?
|
|
|
|
|
st_bp->sg[i].length - offset : do_count ;
|
2007-10-22 13:19:53 -06:00
|
|
|
|
memset(page_address(sg_page(&st_bp->sg[i])) + offset, 0, cnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
do_count -= cnt;
|
|
|
|
|
offset = 0;
|
|
|
|
|
}
|
|
|
|
|
if (do_count) { /* Should never happen */
|
|
|
|
|
printk(KERN_WARNING "osst :A: Zero_buffer overflow (left %d).\n", do_count);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Copy a osst 32K chunk of memory into the buffer.
|
|
|
|
|
Returns zero (success) or negative error code. */
|
|
|
|
|
static int osst_copy_to_buffer(struct osst_buffer *st_bp, unsigned char *ptr)
|
|
|
|
|
{
|
|
|
|
|
int i, cnt, do_count = OS_DATA_SIZE;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < st_bp->sg_segs && do_count > 0; i++) {
|
|
|
|
|
cnt = st_bp->sg[i].length < do_count ?
|
|
|
|
|
st_bp->sg[i].length : do_count ;
|
2007-10-22 13:19:53 -06:00
|
|
|
|
memcpy(page_address(sg_page(&st_bp->sg[i])), ptr, cnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
do_count -= cnt;
|
|
|
|
|
ptr += cnt;
|
|
|
|
|
}
|
|
|
|
|
if (do_count || i != st_bp->sg_segs-1) { /* Should never happen */
|
|
|
|
|
printk(KERN_WARNING "osst :A: Copy_to_buffer overflow (left %d at sg %d).\n",
|
|
|
|
|
do_count, i);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Copy a osst 32K chunk of memory from the buffer.
|
|
|
|
|
Returns zero (success) or negative error code. */
|
|
|
|
|
static int osst_copy_from_buffer(struct osst_buffer *st_bp, unsigned char *ptr)
|
|
|
|
|
{
|
|
|
|
|
int i, cnt, do_count = OS_DATA_SIZE;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < st_bp->sg_segs && do_count > 0; i++) {
|
|
|
|
|
cnt = st_bp->sg[i].length < do_count ?
|
|
|
|
|
st_bp->sg[i].length : do_count ;
|
2007-10-22 13:19:53 -06:00
|
|
|
|
memcpy(ptr, page_address(sg_page(&st_bp->sg[i])), cnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
do_count -= cnt;
|
|
|
|
|
ptr += cnt;
|
|
|
|
|
}
|
|
|
|
|
if (do_count || i != st_bp->sg_segs-1) { /* Should never happen */
|
|
|
|
|
printk(KERN_WARNING "osst :A: Copy_from_buffer overflow (left %d at sg %d).\n",
|
|
|
|
|
do_count, i);
|
|
|
|
|
return (-EIO);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Module housekeeping */
|
|
|
|
|
|
|
|
|
|
static void validate_options (void)
|
|
|
|
|
{
|
|
|
|
|
if (max_dev > 0)
|
|
|
|
|
osst_max_dev = max_dev;
|
|
|
|
|
if (write_threshold_kbs > 0)
|
|
|
|
|
osst_write_threshold = write_threshold_kbs * ST_KILOBYTE;
|
|
|
|
|
if (osst_write_threshold > osst_buffer_size)
|
|
|
|
|
osst_write_threshold = osst_buffer_size;
|
|
|
|
|
if (max_sg_segs >= OSST_FIRST_SG)
|
|
|
|
|
osst_max_sg_segs = max_sg_segs;
|
|
|
|
|
#if DEBUG
|
|
|
|
|
printk(OSST_DEB_MSG "osst :D: max tapes %d, write threshold %d, max s/g segs %d.\n",
|
|
|
|
|
osst_max_dev, osst_write_threshold, osst_max_sg_segs);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifndef MODULE
|
|
|
|
|
/* Set the boot options. Syntax: osst=xxx,yyy,...
|
|
|
|
|
where xxx is write threshold in 1024 byte blocks,
|
|
|
|
|
and yyy is number of s/g segments to use. */
|
|
|
|
|
static int __init osst_setup (char *str)
|
|
|
|
|
{
|
|
|
|
|
int i, ints[5];
|
|
|
|
|
char *stp;
|
|
|
|
|
|
|
|
|
|
stp = get_options(str, ARRAY_SIZE(ints), ints);
|
2006-06-08 23:23:48 -06:00
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (ints[0] > 0) {
|
|
|
|
|
for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
|
|
|
|
|
*parms[i].val = ints[i + 1];
|
|
|
|
|
} else {
|
|
|
|
|
while (stp != NULL) {
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(parms); i++) {
|
|
|
|
|
int len = strlen(parms[i].name);
|
|
|
|
|
if (!strncmp(stp, parms[i].name, len) &&
|
|
|
|
|
(*(stp + len) == ':' || *(stp + len) == '=')) {
|
|
|
|
|
*parms[i].val =
|
|
|
|
|
simple_strtoul(stp + len + 1, NULL, 0);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2006-06-08 23:23:48 -06:00
|
|
|
|
if (i >= ARRAY_SIZE(parms))
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk(KERN_INFO "osst :I: Illegal parameter in '%s'\n",
|
|
|
|
|
stp);
|
|
|
|
|
stp = strchr(stp, ',');
|
|
|
|
|
if (stp)
|
|
|
|
|
stp++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
__setup("osst=", osst_setup);
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
2007-02-12 01:55:34 -07:00
|
|
|
|
static const struct file_operations osst_fops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
|
.read = osst_read,
|
|
|
|
|
.write = osst_write,
|
2010-04-26 16:24:01 -06:00
|
|
|
|
.unlocked_ioctl = osst_ioctl,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
|
.compat_ioctl = osst_compat_ioctl,
|
|
|
|
|
#endif
|
|
|
|
|
.open = os_scsi_tape_open,
|
|
|
|
|
.flush = os_scsi_tape_flush,
|
|
|
|
|
.release = os_scsi_tape_close,
|
2010-05-26 15:44:50 -06:00
|
|
|
|
.llseek = noop_llseek,
|
2005-04-16 16:20:36 -06:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int osst_supports(struct scsi_device * SDp)
|
|
|
|
|
{
|
|
|
|
|
struct osst_support_data {
|
|
|
|
|
char *vendor;
|
|
|
|
|
char *model;
|
|
|
|
|
char *rev;
|
|
|
|
|
char *driver_hint; /* Name of the correct driver, NULL if unknown */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct osst_support_data support_list[] = {
|
|
|
|
|
/* {"XXX", "Yy-", "", NULL}, example */
|
|
|
|
|
SIGS_FROM_OSST,
|
|
|
|
|
{NULL, }};
|
|
|
|
|
|
|
|
|
|
struct osst_support_data *rp;
|
|
|
|
|
|
|
|
|
|
/* We are willing to drive OnStream SC-x0 as well as the
|
|
|
|
|
* * IDE, ParPort, FireWire, USB variants, if accessible by
|
|
|
|
|
* * emulation layer (ide-scsi, usb-storage, ...) */
|
|
|
|
|
|
|
|
|
|
for (rp=&(support_list[0]); rp->vendor != NULL; rp++)
|
|
|
|
|
if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
|
|
|
|
|
!strncmp(rp->model, SDp->model, strlen(rp->model)) &&
|
|
|
|
|
!strncmp(rp->rev, SDp->rev, strlen(rp->rev)))
|
|
|
|
|
return 1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* sysfs support for osst driver parameter information
|
|
|
|
|
*/
|
|
|
|
|
|
2017-07-19 06:50:06 -06:00
|
|
|
|
static ssize_t version_show(struct device_driver *ddd, char *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n", osst_version);
|
|
|
|
|
}
|
|
|
|
|
|
2017-07-19 06:50:06 -06:00
|
|
|
|
static DRIVER_ATTR_RO(version);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2007-02-17 11:13:42 -07:00
|
|
|
|
static int osst_create_sysfs_files(struct device_driver *sysfs)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2007-02-17 11:13:42 -07:00
|
|
|
|
return driver_create_file(sysfs, &driver_attr_version);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
2007-02-17 11:13:42 -07:00
|
|
|
|
static void osst_remove_sysfs_files(struct device_driver *sysfs)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2007-02-17 11:13:42 -07:00
|
|
|
|
driver_remove_file(sysfs, &driver_attr_version);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* sysfs support for accessing ADR header information
|
|
|
|
|
*/
|
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
static ssize_t osst_adr_rev_show(struct device *dev,
|
|
|
|
|
struct device_attribute *attr, char *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
|
struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ssize_t l = 0;
|
|
|
|
|
|
|
|
|
|
if (STp && STp->header_ok && STp->linux_media)
|
|
|
|
|
l = snprintf(buf, PAGE_SIZE, "%d.%d\n", STp->header_cache->major_rev, STp->header_cache->minor_rev);
|
|
|
|
|
return l;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
DEVICE_ATTR(ADR_rev, S_IRUGO, osst_adr_rev_show, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
static ssize_t osst_linux_media_version_show(struct device *dev,
|
|
|
|
|
struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
|
struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ssize_t l = 0;
|
|
|
|
|
|
|
|
|
|
if (STp && STp->header_ok && STp->linux_media)
|
|
|
|
|
l = snprintf(buf, PAGE_SIZE, "LIN%d\n", STp->linux_media_version);
|
|
|
|
|
return l;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
DEVICE_ATTR(media_version, S_IRUGO, osst_linux_media_version_show, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
static ssize_t osst_capacity_show(struct device *dev,
|
|
|
|
|
struct device_attribute *attr, char *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
|
struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ssize_t l = 0;
|
|
|
|
|
|
|
|
|
|
if (STp && STp->header_ok && STp->linux_media)
|
|
|
|
|
l = snprintf(buf, PAGE_SIZE, "%d\n", STp->capacity);
|
|
|
|
|
return l;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
DEVICE_ATTR(capacity, S_IRUGO, osst_capacity_show, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
static ssize_t osst_first_data_ppos_show(struct device *dev,
|
|
|
|
|
struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
|
struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ssize_t l = 0;
|
|
|
|
|
|
|
|
|
|
if (STp && STp->header_ok && STp->linux_media)
|
|
|
|
|
l = snprintf(buf, PAGE_SIZE, "%d\n", STp->first_data_ppos);
|
|
|
|
|
return l;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
DEVICE_ATTR(BOT_frame, S_IRUGO, osst_first_data_ppos_show, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
static ssize_t osst_eod_frame_ppos_show(struct device *dev,
|
|
|
|
|
struct device_attribute *attr,
|
|
|
|
|
char *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
|
struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ssize_t l = 0;
|
|
|
|
|
|
|
|
|
|
if (STp && STp->header_ok && STp->linux_media)
|
|
|
|
|
l = snprintf(buf, PAGE_SIZE, "%d\n", STp->eod_frame_ppos);
|
|
|
|
|
return l;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
DEVICE_ATTR(EOD_frame, S_IRUGO, osst_eod_frame_ppos_show, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
static ssize_t osst_filemark_cnt_show(struct device *dev,
|
|
|
|
|
struct device_attribute *attr, char *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
|
struct osst_tape * STp = (struct osst_tape *) dev_get_drvdata (dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ssize_t l = 0;
|
|
|
|
|
|
|
|
|
|
if (STp && STp->header_ok && STp->linux_media)
|
|
|
|
|
l = snprintf(buf, PAGE_SIZE, "%d\n", STp->filemark_cnt);
|
|
|
|
|
return l;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
DEVICE_ATTR(file_count, S_IRUGO, osst_filemark_cnt_show, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2005-03-23 10:55:22 -07:00
|
|
|
|
static struct class *osst_sysfs_class;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2006-10-04 03:23:04 -06:00
|
|
|
|
static int osst_sysfs_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2005-03-23 10:55:22 -07:00
|
|
|
|
osst_sysfs_class = class_create(THIS_MODULE, "onstream_tape");
|
2006-10-04 03:23:04 -06:00
|
|
|
|
if (IS_ERR(osst_sysfs_class)) {
|
|
|
|
|
printk(KERN_ERR "osst :W: Unable to register sysfs class\n");
|
|
|
|
|
return PTR_ERR(osst_sysfs_class);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
2006-10-04 03:23:04 -06:00
|
|
|
|
static void osst_sysfs_destroy(dev_t dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
|
device_destroy(osst_sysfs_class, dev);
|
2006-10-04 03:23:04 -06:00
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2006-10-04 03:23:04 -06:00
|
|
|
|
static int osst_sysfs_add(dev_t dev, struct device *device, struct osst_tape * STp, char * name)
|
|
|
|
|
{
|
2008-02-21 16:13:36 -07:00
|
|
|
|
struct device *osst_member;
|
2006-10-04 03:23:04 -06:00
|
|
|
|
int err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2008-07-21 21:03:34 -06:00
|
|
|
|
osst_member = device_create(osst_sysfs_class, device, dev, STp,
|
|
|
|
|
"%s", name);
|
2008-02-21 16:13:36 -07:00
|
|
|
|
if (IS_ERR(osst_member)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk(KERN_WARNING "osst :W: Unable to add sysfs class member %s\n", name);
|
2008-02-21 16:13:36 -07:00
|
|
|
|
return PTR_ERR(osst_member);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2006-10-04 03:23:04 -06:00
|
|
|
|
|
2008-02-21 16:13:36 -07:00
|
|
|
|
err = device_create_file(osst_member, &dev_attr_ADR_rev);
|
2006-10-04 03:23:04 -06:00
|
|
|
|
if (err)
|
|
|
|
|
goto err_out;
|
2008-02-21 16:13:36 -07:00
|
|
|
|
err = device_create_file(osst_member, &dev_attr_media_version);
|
2006-10-04 03:23:04 -06:00
|
|
|
|
if (err)
|
|
|
|
|
goto err_out;
|
2008-02-21 16:13:36 -07:00
|
|
|
|
err = device_create_file(osst_member, &dev_attr_capacity);
|
2006-10-04 03:23:04 -06:00
|
|
|
|
if (err)
|
|
|
|
|
goto err_out;
|
2008-02-21 16:13:36 -07:00
|
|
|
|
err = device_create_file(osst_member, &dev_attr_BOT_frame);
|
2006-10-04 03:23:04 -06:00
|
|
|
|
if (err)
|
|
|
|
|
goto err_out;
|
2008-02-21 16:13:36 -07:00
|
|
|
|
err = device_create_file(osst_member, &dev_attr_EOD_frame);
|
2006-10-04 03:23:04 -06:00
|
|
|
|
if (err)
|
|
|
|
|
goto err_out;
|
2008-02-21 16:13:36 -07:00
|
|
|
|
err = device_create_file(osst_member, &dev_attr_file_count);
|
2006-10-04 03:23:04 -06:00
|
|
|
|
if (err)
|
|
|
|
|
goto err_out;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2006-10-04 03:23:04 -06:00
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
2006-10-04 03:23:04 -06:00
|
|
|
|
err_out:
|
|
|
|
|
osst_sysfs_destroy(dev);
|
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void osst_sysfs_cleanup(void)
|
|
|
|
|
{
|
2006-10-04 03:23:04 -06:00
|
|
|
|
class_destroy(osst_sysfs_class);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* osst startup / cleanup code
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static int osst_probe(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct scsi_device * SDp = to_scsi_device(dev);
|
|
|
|
|
struct osst_tape * tpnt;
|
|
|
|
|
struct st_modedef * STm;
|
|
|
|
|
struct st_partstat * STps;
|
|
|
|
|
struct osst_buffer * buffer;
|
|
|
|
|
struct gendisk * drive;
|
2006-10-04 03:23:04 -06:00
|
|
|
|
int i, dev_num, err = -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
if (SDp->type != TYPE_TAPE || !osst_supports(SDp))
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
|
|
drive = alloc_disk(1);
|
|
|
|
|
if (!drive) {
|
|
|
|
|
printk(KERN_ERR "osst :E: Out of memory. Device not attached.\n");
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* if this is the first attach, build the infrastructure */
|
|
|
|
|
write_lock(&os_scsi_tapes_lock);
|
|
|
|
|
if (os_scsi_tapes == NULL) {
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 14:55:00 -06:00
|
|
|
|
os_scsi_tapes = kmalloc_array(osst_max_dev,
|
|
|
|
|
sizeof(struct osst_tape *),
|
|
|
|
|
GFP_ATOMIC);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (os_scsi_tapes == NULL) {
|
|
|
|
|
write_unlock(&os_scsi_tapes_lock);
|
|
|
|
|
printk(KERN_ERR "osst :E: Unable to allocate array for OnStream SCSI tapes.\n");
|
|
|
|
|
goto out_put_disk;
|
|
|
|
|
}
|
|
|
|
|
for (i=0; i < osst_max_dev; ++i) os_scsi_tapes[i] = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (osst_nr_dev >= osst_max_dev) {
|
|
|
|
|
write_unlock(&os_scsi_tapes_lock);
|
|
|
|
|
printk(KERN_ERR "osst :E: Too many tape devices (max. %d).\n", osst_max_dev);
|
|
|
|
|
goto out_put_disk;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* find a free minor number */
|
2010-08-10 19:01:10 -06:00
|
|
|
|
for (i = 0; i < osst_max_dev && os_scsi_tapes[i]; i++)
|
|
|
|
|
;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if(i >= osst_max_dev) panic ("Scsi_devices corrupt (osst)");
|
|
|
|
|
dev_num = i;
|
|
|
|
|
|
|
|
|
|
/* allocate a struct osst_tape for this device */
|
[SCSI] kmalloc + memset conversion to kzalloc
In NCR_D700, a4000t, aic7xxx_old, bvme6000, dpt_i2o, gdth, lpfc,
megaraid, mvme16x osst, pluto, qla2xxx, zorro7xx
Signed-off-by: Mariusz Kozlowski <m.kozlowski@tuxland.pl>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2007-08-11 02:13:24 -06:00
|
|
|
|
tpnt = kzalloc(sizeof(struct osst_tape), GFP_ATOMIC);
|
|
|
|
|
if (!tpnt) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
write_unlock(&os_scsi_tapes_lock);
|
|
|
|
|
printk(KERN_ERR "osst :E: Can't allocate device descriptor, device not attached.\n");
|
|
|
|
|
goto out_put_disk;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* allocate a buffer for this device */
|
|
|
|
|
i = SDp->host->sg_tablesize;
|
|
|
|
|
if (osst_max_sg_segs < i)
|
|
|
|
|
i = osst_max_sg_segs;
|
|
|
|
|
buffer = new_tape_buffer(1, SDp->host->unchecked_isa_dma, i);
|
|
|
|
|
if (buffer == NULL) {
|
|
|
|
|
write_unlock(&os_scsi_tapes_lock);
|
|
|
|
|
printk(KERN_ERR "osst :E: Unable to allocate a tape buffer, device not attached.\n");
|
|
|
|
|
kfree(tpnt);
|
|
|
|
|
goto out_put_disk;
|
|
|
|
|
}
|
|
|
|
|
os_scsi_tapes[dev_num] = tpnt;
|
|
|
|
|
tpnt->buffer = buffer;
|
|
|
|
|
tpnt->device = SDp;
|
|
|
|
|
drive->private_data = &tpnt->driver;
|
|
|
|
|
sprintf(drive->disk_name, "osst%d", dev_num);
|
|
|
|
|
tpnt->driver = &osst_template;
|
|
|
|
|
tpnt->drive = drive;
|
|
|
|
|
tpnt->in_use = 0;
|
|
|
|
|
tpnt->capacity = 0xfffff;
|
|
|
|
|
tpnt->dirty = 0;
|
|
|
|
|
tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
|
|
|
|
|
tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
|
|
|
|
|
tpnt->density = 0;
|
|
|
|
|
tpnt->do_auto_lock = OSST_AUTO_LOCK;
|
|
|
|
|
tpnt->can_bsr = OSST_IN_FILE_POS;
|
|
|
|
|
tpnt->can_partitions = 0;
|
|
|
|
|
tpnt->two_fm = OSST_TWO_FM;
|
|
|
|
|
tpnt->fast_mteom = OSST_FAST_MTEOM;
|
|
|
|
|
tpnt->scsi2_logical = OSST_SCSI2LOGICAL; /* FIXME */
|
|
|
|
|
tpnt->write_threshold = osst_write_threshold;
|
|
|
|
|
tpnt->default_drvbuffer = 0xff; /* No forced buffering */
|
|
|
|
|
tpnt->partition = 0;
|
|
|
|
|
tpnt->new_partition = 0;
|
|
|
|
|
tpnt->nbr_partitions = 0;
|
|
|
|
|
tpnt->min_block = 512;
|
|
|
|
|
tpnt->max_block = OS_DATA_SIZE;
|
|
|
|
|
tpnt->timeout = OSST_TIMEOUT;
|
|
|
|
|
tpnt->long_timeout = OSST_LONG_TIMEOUT;
|
|
|
|
|
|
|
|
|
|
/* Recognize OnStream tapes */
|
|
|
|
|
/* We don't need to test for OnStream, as this has been done in detect () */
|
|
|
|
|
tpnt->os_fw_rev = osst_parse_firmware_rev (SDp->rev);
|
|
|
|
|
tpnt->omit_blklims = 1;
|
|
|
|
|
|
|
|
|
|
tpnt->poll = (strncmp(SDp->model, "DI-", 3) == 0) ||
|
|
|
|
|
(strncmp(SDp->model, "FW-", 3) == 0) || OSST_FW_NEED_POLL(tpnt->os_fw_rev,SDp);
|
|
|
|
|
tpnt->frame_in_buffer = 0;
|
|
|
|
|
tpnt->header_ok = 0;
|
|
|
|
|
tpnt->linux_media = 0;
|
|
|
|
|
tpnt->header_cache = NULL;
|
|
|
|
|
|
|
|
|
|
for (i=0; i < ST_NBR_MODES; i++) {
|
|
|
|
|
STm = &(tpnt->modes[i]);
|
|
|
|
|
STm->defined = 0;
|
|
|
|
|
STm->sysv = OSST_SYSV;
|
|
|
|
|
STm->defaults_for_writes = 0;
|
|
|
|
|
STm->do_async_writes = OSST_ASYNC_WRITES;
|
|
|
|
|
STm->do_buffer_writes = OSST_BUFFER_WRITES;
|
|
|
|
|
STm->do_read_ahead = OSST_READ_AHEAD;
|
|
|
|
|
STm->default_compression = ST_DONT_TOUCH;
|
|
|
|
|
STm->default_blksize = 512;
|
|
|
|
|
STm->default_density = (-1); /* No forced density */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i=0; i < ST_NBR_PARTITIONS; i++) {
|
|
|
|
|
STps = &(tpnt->ps[i]);
|
|
|
|
|
STps->rw = ST_IDLE;
|
|
|
|
|
STps->eof = ST_NOEOF;
|
|
|
|
|
STps->at_sm = 0;
|
|
|
|
|
STps->last_block_valid = 0;
|
|
|
|
|
STps->drv_block = (-1);
|
|
|
|
|
STps->drv_file = (-1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tpnt->current_mode = 0;
|
|
|
|
|
tpnt->modes[0].defined = 1;
|
|
|
|
|
tpnt->modes[2].defined = 1;
|
|
|
|
|
tpnt->density_changed = tpnt->compression_changed = tpnt->blksize_changed = 0;
|
|
|
|
|
|
2007-08-10 15:50:44 -06:00
|
|
|
|
mutex_init(&tpnt->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
osst_nr_dev++;
|
|
|
|
|
write_unlock(&os_scsi_tapes_lock);
|
2006-10-04 03:23:04 -06:00
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
{
|
|
|
|
|
char name[8];
|
2006-10-04 03:23:04 -06:00
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
/* Rewind entry */
|
2006-10-04 03:23:04 -06:00
|
|
|
|
err = osst_sysfs_add(MKDEV(OSST_MAJOR, dev_num), dev, tpnt, tape_name(tpnt));
|
|
|
|
|
if (err)
|
|
|
|
|
goto out_free_buffer;
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
/* No-rewind entry */
|
|
|
|
|
snprintf(name, 8, "%s%s", "n", tape_name(tpnt));
|
2006-10-04 03:23:04 -06:00
|
|
|
|
err = osst_sysfs_add(MKDEV(OSST_MAJOR, dev_num + 128), dev, tpnt, name);
|
|
|
|
|
if (err)
|
|
|
|
|
goto out_free_sysfs1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
2005-10-29 08:42:17 -06:00
|
|
|
|
sdev_printk(KERN_INFO, SDp,
|
2005-10-02 10:45:08 -06:00
|
|
|
|
"osst :I: Attached OnStream %.5s tape as %s\n",
|
|
|
|
|
SDp->model, tape_name(tpnt));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
2006-10-04 03:23:04 -06:00
|
|
|
|
out_free_sysfs1:
|
|
|
|
|
osst_sysfs_destroy(MKDEV(OSST_MAJOR, dev_num));
|
|
|
|
|
out_free_buffer:
|
|
|
|
|
kfree(buffer);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
out_put_disk:
|
|
|
|
|
put_disk(drive);
|
2006-10-04 03:23:04 -06:00
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int osst_remove(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct scsi_device * SDp = to_scsi_device(dev);
|
|
|
|
|
struct osst_tape * tpnt;
|
2006-01-18 17:17:46 -07:00
|
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
if ((SDp->type != TYPE_TAPE) || (osst_nr_dev <= 0))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
write_lock(&os_scsi_tapes_lock);
|
|
|
|
|
for(i=0; i < osst_max_dev; i++) {
|
|
|
|
|
if((tpnt = os_scsi_tapes[i]) && (tpnt->device == SDp)) {
|
|
|
|
|
osst_sysfs_destroy(MKDEV(OSST_MAJOR, i));
|
|
|
|
|
osst_sysfs_destroy(MKDEV(OSST_MAJOR, i+128));
|
|
|
|
|
tpnt->device = NULL;
|
|
|
|
|
put_disk(tpnt->drive);
|
|
|
|
|
os_scsi_tapes[i] = NULL;
|
|
|
|
|
osst_nr_dev--;
|
|
|
|
|
write_unlock(&os_scsi_tapes_lock);
|
2005-09-10 01:26:54 -06:00
|
|
|
|
vfree(tpnt->header_cache);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (tpnt->buffer) {
|
|
|
|
|
normalize_buffer(tpnt->buffer);
|
|
|
|
|
kfree(tpnt->buffer);
|
|
|
|
|
}
|
|
|
|
|
kfree(tpnt);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
write_unlock(&os_scsi_tapes_lock);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init init_osst(void)
|
|
|
|
|
{
|
2006-10-04 03:23:04 -06:00
|
|
|
|
int err;
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk(KERN_INFO "osst :I: Tape driver with OnStream support version %s\nosst :I: %s\n", osst_version, cvsid);
|
|
|
|
|
|
|
|
|
|
validate_options();
|
|
|
|
|
|
2006-10-04 03:23:04 -06:00
|
|
|
|
err = osst_sysfs_init();
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
err = register_chrdev(OSST_MAJOR, "osst", &osst_fops);
|
|
|
|
|
if (err < 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
printk(KERN_ERR "osst :E: Unable to register major %d for OnStream tapes\n", OSST_MAJOR);
|
2006-10-04 03:23:04 -06:00
|
|
|
|
goto err_out;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
2006-10-04 03:23:04 -06:00
|
|
|
|
|
|
|
|
|
err = scsi_register_driver(&osst_template.gendrv);
|
|
|
|
|
if (err)
|
|
|
|
|
goto err_out_chrdev;
|
|
|
|
|
|
2007-02-17 11:13:42 -07:00
|
|
|
|
err = osst_create_sysfs_files(&osst_template.gendrv);
|
2006-10-04 03:23:04 -06:00
|
|
|
|
if (err)
|
|
|
|
|
goto err_out_scsidrv;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
return 0;
|
2006-10-04 03:23:04 -06:00
|
|
|
|
|
|
|
|
|
err_out_scsidrv:
|
|
|
|
|
scsi_unregister_driver(&osst_template.gendrv);
|
|
|
|
|
err_out_chrdev:
|
|
|
|
|
unregister_chrdev(OSST_MAJOR, "osst");
|
|
|
|
|
err_out:
|
|
|
|
|
osst_sysfs_cleanup();
|
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __exit exit_osst (void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
struct osst_tape * STp;
|
|
|
|
|
|
2007-02-17 11:13:42 -07:00
|
|
|
|
osst_remove_sysfs_files(&osst_template.gendrv);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
scsi_unregister_driver(&osst_template.gendrv);
|
|
|
|
|
unregister_chrdev(OSST_MAJOR, "osst");
|
|
|
|
|
osst_sysfs_cleanup();
|
|
|
|
|
|
|
|
|
|
if (os_scsi_tapes) {
|
|
|
|
|
for (i=0; i < osst_max_dev; ++i) {
|
|
|
|
|
if (!(STp = os_scsi_tapes[i])) continue;
|
|
|
|
|
/* This is defensive, supposed to happen during detach */
|
2005-09-10 01:26:54 -06:00
|
|
|
|
vfree(STp->header_cache);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
if (STp->buffer) {
|
|
|
|
|
normalize_buffer(STp->buffer);
|
|
|
|
|
kfree(STp->buffer);
|
|
|
|
|
}
|
|
|
|
|
put_disk(STp->drive);
|
|
|
|
|
kfree(STp);
|
|
|
|
|
}
|
|
|
|
|
kfree(os_scsi_tapes);
|
|
|
|
|
}
|
|
|
|
|
printk(KERN_INFO "osst :I: Unloaded.\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
module_init(init_osst);
|
|
|
|
|
module_exit(exit_osst);
|