drivers/scsi/st.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003    SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
0004    file Documentation/scsi/st.rst for more information.
0005
0006    History:
0007    Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.
0008    Contribution and ideas from several people including (in alphabetical
0009    order) Klaus Ehrenfried, Eugene Exarevsky, Eric Lee Green, Wolfgang Denk,
0010    Steve Hirsch, Andreas Koppenh"ofer, Michael Leodolter, Eyal Lebedinsky,
0011    Michael Schaefer, J"org Weule, and Eric Youngdale.
0012
0013    Copyright 1992 - 2016 Kai Makisara
0014    email Kai.Makisara@kolumbus.fi
0015
0016    Some small formal changes - aeb, 950809
0017
0018    Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
0019  */
0020
0021 static const char *verstr = "20160209";
0022
0023 #include <linux/module.h>
0024
0025 #include <linux/compat.h>
0026 #include <linux/fs.h>
0027 #include <linux/kernel.h>
0028 #include <linux/sched/signal.h>
0029 #include <linux/mm.h>
0030 #include <linux/init.h>
0031 #include <linux/string.h>
0032 #include <linux/slab.h>
0033 #include <linux/errno.h>
0034 #include <linux/mtio.h>
0035 #include <linux/major.h>
0036 #include <linux/cdrom.h>
0037 #include <linux/ioctl.h>
0038 #include <linux/fcntl.h>
0039 #include <linux/spinlock.h>
0040 #include <linux/blkdev.h>
0041 #include <linux/moduleparam.h>
0042 #include <linux/cdev.h>
0043 #include <linux/idr.h>
0044 #include <linux/delay.h>
0045 #include <linux/mutex.h>
0046
0047 #include <linux/uaccess.h>
0048 #include <asm/dma.h>
0049 #include <asm/unaligned.h>
0050
0051 #include <scsi/scsi.h>
0052 #include <scsi/scsi_dbg.h>
0053 #include <scsi/scsi_device.h>
0054 #include <scsi/scsi_driver.h>
0055 #include <scsi/scsi_eh.h>
0056 #include <scsi/scsi_host.h>
0057 #include <scsi/scsi_ioctl.h>
0058 #include <scsi/sg.h>
0059
0060
0061 /* The driver prints some debugging information on the console if DEBUG
0062    is defined and non-zero. */
0063 #define DEBUG 1
0064 #define NO_DEBUG 0
0065
0066 #define ST_DEB_MSG  KERN_NOTICE
0067 #if DEBUG
0068 /* The message level for the debug messages is currently set to KERN_NOTICE
0069    so that people can easily see the messages. Later when the debugging messages
0070    in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
0071 #define DEB(a) a
0072 #define DEBC(a) if (debugging) { a ; }
0073 #else
0074 #define DEB(a)
0075 #define DEBC(a)
0076 #endif
0077
0078 #define ST_KILOBYTE 1024
0079
0080 #include "st_options.h"
0081 #include "st.h"
0082
0083 static int buffer_kbs;
0084 static int max_sg_segs;
0085 static int try_direct_io = TRY_DIRECT_IO;
0086 static int try_rdio = 1;
0087 static int try_wdio = 1;
0088 static int debug_flag;
0089
0090 static struct class st_sysfs_class;
0091 static const struct attribute_group *st_dev_groups[];
0092 static const struct attribute_group *st_drv_groups[];
0093
0094 MODULE_AUTHOR("Kai Makisara");
0095 MODULE_DESCRIPTION("SCSI tape (st) driver");
0096 MODULE_LICENSE("GPL");
0097 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
0098 MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE);
0099
0100 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
0101  * of sysfs parameters (which module_param doesn't yet support).
0102  * Sysfs parameters defined explicitly later.
0103  */
0104 module_param_named(buffer_kbs, buffer_kbs, int, 0);
0105 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
0106 module_param_named(max_sg_segs, max_sg_segs, int, 0);
0107 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
0108 module_param_named(try_direct_io, try_direct_io, int, 0);
0109 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
0110 module_param_named(debug_flag, debug_flag, int, 0);
0111 MODULE_PARM_DESC(debug_flag, "Enable DEBUG, same as setting debugging=1");
0112
0113
0114 /* Extra parameters for testing */
0115 module_param_named(try_rdio, try_rdio, int, 0);
0116 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
0117 module_param_named(try_wdio, try_wdio, int, 0);
0118 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
0119
0120 #ifndef MODULE
0121 static int write_threshold_kbs;  /* retained for compatibility */
0122 static struct st_dev_parm {
0123     char *name;
0124     int *val;
0125 } parms[] __initdata = {
0126     {
0127         "buffer_kbs", &buffer_kbs
0128     },
0129     {       /* Retained for compatibility with 2.4 */
0130         "write_threshold_kbs", &write_threshold_kbs
0131     },
0132     {
0133         "max_sg_segs", NULL
0134     },
0135     {
0136         "try_direct_io", &try_direct_io
0137     },
0138     {
0139         "debug_flag", &debug_flag
0140     }
0141 };
0142 #endif
0143
0144 /* Restrict the number of modes so that names for all are assigned */
0145 #if ST_NBR_MODES > 16
0146 #error "Maximum number of modes is 16"
0147 #endif
0148 /* Bit reversed order to get same names for same minors with all
0149    mode counts */
0150 static const char *st_formats[] = {
0151     "",  "r", "k", "s", "l", "t", "o", "u",
0152     "m", "v", "p", "x", "a", "y", "q", "z"};
0153
0154 /* The default definitions have been moved to st_options.h */
0155
0156 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
0157
0158 /* The buffer size should fit into the 24 bits for length in the
0159    6-byte SCSI read and write commands. */
0160 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
0161 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
0162 #endif
0163
0164 static int debugging = DEBUG;
0165
0166 #define MAX_RETRIES 0
0167 #define MAX_WRITE_RETRIES 0
0168 #define MAX_READY_RETRIES 0
0169 #define NO_TAPE  NOT_READY
0170
0171 #define ST_TIMEOUT (900 * HZ)
0172 #define ST_LONG_TIMEOUT (14000 * HZ)
0173
0174 /* Remove mode bits and auto-rewind bit (7) */
0175 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
0176     (iminor(x) & ((1 << ST_MODE_SHIFT)-1)))
0177 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
0178
0179 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
0180 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
0181   (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
0182
0183 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
0184    24 bits) */
0185 #define SET_DENS_AND_BLK 0x10001
0186
0187 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
0188 static int st_max_sg_segs = ST_MAX_SG;
0189
0190 static int modes_defined;
0191
0192 static int enlarge_buffer(struct st_buffer *, int);
0193 static void clear_buffer(struct st_buffer *);
0194 static void normalize_buffer(struct st_buffer *);
0195 static int append_to_buffer(const char __user *, struct st_buffer *, int);
0196 static int from_buffer(struct st_buffer *, char __user *, int);
0197 static void move_buffer_data(struct st_buffer *, int);
0198
0199 static int sgl_map_user_pages(struct st_buffer *, const unsigned int,
0200                   unsigned long, size_t, int);
0201 static int sgl_unmap_user_pages(struct st_buffer *, const unsigned int, int);
0202
0203 static int st_probe(struct device *);
0204 static int st_remove(struct device *);
0205
0206 static struct scsi_driver st_template = {
0207     .gendrv = {
0208         .name       = "st",
0209         .owner      = THIS_MODULE,
0210         .probe      = st_probe,
0211         .remove     = st_remove,
0212         .groups     = st_drv_groups,
0213     },
0214 };
0215
0216 static int st_compression(struct scsi_tape *, int);
0217
0218 static int find_partition(struct scsi_tape *);
0219 static int switch_partition(struct scsi_tape *);
0220
0221 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
0222
0223 static void scsi_tape_release(struct kref *);
0224
0225 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
0226
0227 static DEFINE_MUTEX(st_ref_mutex);
0228 static DEFINE_SPINLOCK(st_index_lock);
0229 static DEFINE_SPINLOCK(st_use_lock);
0230 static DEFINE_IDR(st_index_idr);
0231
0232
0233
0234 #ifndef SIGS_FROM_OSST
0235 #define SIGS_FROM_OSST \
0236     {"OnStream", "SC-", "", "osst"}, \
0237     {"OnStream", "DI-", "", "osst"}, \
0238     {"OnStream", "DP-", "", "osst"}, \
0239     {"OnStream", "USB", "", "osst"}, \
0240     {"OnStream", "FW-", "", "osst"}
0241 #endif
0242
0243 static struct scsi_tape *scsi_tape_get(int dev)
0244 {
0245     struct scsi_tape *STp = NULL;
0246
0247     mutex_lock(&st_ref_mutex);
0248     spin_lock(&st_index_lock);
0249
0250     STp = idr_find(&st_index_idr, dev);
0251     if (!STp) goto out;
0252
0253     kref_get(&STp->kref);
0254
0255     if (!STp->device)
0256         goto out_put;
0257
0258     if (scsi_device_get(STp->device))
0259         goto out_put;
0260
0261     goto out;
0262
0263 out_put:
0264     kref_put(&STp->kref, scsi_tape_release);
0265     STp = NULL;
0266 out:
0267     spin_unlock(&st_index_lock);
0268     mutex_unlock(&st_ref_mutex);
0269     return STp;
0270 }
0271
0272 static void scsi_tape_put(struct scsi_tape *STp)
0273 {
0274     struct scsi_device *sdev = STp->device;
0275
0276     mutex_lock(&st_ref_mutex);
0277     kref_put(&STp->kref, scsi_tape_release);
0278     scsi_device_put(sdev);
0279     mutex_unlock(&st_ref_mutex);
0280 }
0281
0282 struct st_reject_data {
0283     char *vendor;
0284     char *model;
0285     char *rev;
0286     char *driver_hint; /* Name of the correct driver, NULL if unknown */
0287 };
0288
0289 static struct st_reject_data reject_list[] = {
0290     /* {"XXX", "Yy-", "", NULL},  example */
0291     SIGS_FROM_OSST,
0292     {NULL, }};
0293
0294 /* If the device signature is on the list of incompatible drives, the
0295    function returns a pointer to the name of the correct driver (if known) */
0296 static char * st_incompatible(struct scsi_device* SDp)
0297 {
0298     struct st_reject_data *rp;
0299
0300     for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
0301         if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
0302             !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
0303             !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
0304             if (rp->driver_hint)
0305                 return rp->driver_hint;
0306             else
0307                 return "unknown";
0308         }
0309     return NULL;
0310 }
0311
0312
0313 #define st_printk(prefix, t, fmt, a...) \
0314     sdev_prefix_printk(prefix, (t)->device, (t)->name, fmt, ##a)
0315 #ifdef DEBUG
0316 #define DEBC_printk(t, fmt, a...) \
0317     if (debugging) { st_printk(ST_DEB_MSG, t, fmt, ##a ); }
0318 #else
0319 #define DEBC_printk(t, fmt, a...)
0320 #endif
0321
0322 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
0323 {
0324     const u8 *ucp;
0325     const u8 *sense = SRpnt->sense;
0326
0327     s->have_sense = scsi_normalize_sense(SRpnt->sense,
0328                 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
0329     s->flags = 0;
0330
0331     if (s->have_sense) {
0332         s->deferred = 0;
0333         s->remainder_valid =
0334             scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
0335         switch (sense[0] & 0x7f) {
0336         case 0x71:
0337             s->deferred = 1;
0338             fallthrough;
0339         case 0x70:
0340             s->fixed_format = 1;
0341             s->flags = sense[2] & 0xe0;
0342             break;
0343         case 0x73:
0344             s->deferred = 1;
0345             fallthrough;
0346         case 0x72:
0347             s->fixed_format = 0;
0348             ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
0349             s->flags = ucp ? (ucp[3] & 0xe0) : 0;
0350             break;
0351         }
0352     }
0353 }
0354
0355
0356 /* Convert the result to success code */
0357 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
0358 {
0359     int result = SRpnt->result;
0360     u8 scode;
0361     DEB(const char *stp;)
0362     char *name = STp->name;
0363     struct st_cmdstatus *cmdstatp;
0364
0365     if (!result)
0366         return 0;
0367
0368     cmdstatp = &STp->buffer->cmdstat;
0369     st_analyze_sense(SRpnt, cmdstatp);
0370
0371     if (cmdstatp->have_sense)
0372         scode = STp->buffer->cmdstat.sense_hdr.sense_key;
0373     else
0374         scode = 0;
0375
0376     DEB(
0377     if (debugging) {
0378         st_printk(ST_DEB_MSG, STp,
0379                 "Error: %x, cmd: %x %x %x %x %x %x\n", result,
0380                 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
0381                 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
0382         if (cmdstatp->have_sense)
0383             __scsi_print_sense(STp->device, name,
0384                        SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
0385     } ) /* end DEB */
0386     if (!debugging) { /* Abnormal conditions for tape */
0387         if (!cmdstatp->have_sense)
0388             st_printk(KERN_WARNING, STp,
0389                    "Error %x (driver bt 0, host bt 0x%x).\n",
0390                    result, host_byte(result));
0391         else if (cmdstatp->have_sense &&
0392              scode != NO_SENSE &&
0393              scode != RECOVERED_ERROR &&
0394              /* scode != UNIT_ATTENTION && */
0395              scode != BLANK_CHECK &&
0396              scode != VOLUME_OVERFLOW &&
0397              SRpnt->cmd[0] != MODE_SENSE &&
0398              SRpnt->cmd[0] != TEST_UNIT_READY) {
0399
0400             __scsi_print_sense(STp->device, name,
0401                        SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
0402         }
0403     }
0404
0405     if (cmdstatp->fixed_format &&
0406         STp->cln_mode >= EXTENDED_SENSE_START) {  /* Only fixed format sense */
0407         if (STp->cln_sense_value)
0408             STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
0409                            STp->cln_sense_mask) == STp->cln_sense_value);
0410         else
0411             STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
0412                            STp->cln_sense_mask) != 0);
0413     }
0414     if (cmdstatp->have_sense &&
0415         cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
0416         STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
0417
0418     STp->pos_unknown |= STp->device->was_reset;
0419
0420     if (cmdstatp->have_sense &&
0421         scode == RECOVERED_ERROR
0422 #if ST_RECOVERED_WRITE_FATAL
0423         && SRpnt->cmd[0] != WRITE_6
0424         && SRpnt->cmd[0] != WRITE_FILEMARKS
0425 #endif
0426         ) {
0427         STp->recover_count++;
0428         STp->recover_reg++;
0429
0430         DEB(
0431         if (debugging) {
0432             if (SRpnt->cmd[0] == READ_6)
0433                 stp = "read";
0434             else if (SRpnt->cmd[0] == WRITE_6)
0435                 stp = "write";
0436             else
0437                 stp = "ioctl";
0438             st_printk(ST_DEB_MSG, STp,
0439                   "Recovered %s error (%d).\n",
0440                   stp, STp->recover_count);
0441         } ) /* end DEB */
0442
0443         if (cmdstatp->flags == 0)
0444             return 0;
0445     }
0446     return (-EIO);
0447 }
0448
0449 static struct st_request *st_allocate_request(struct scsi_tape *stp)
0450 {
0451     struct st_request *streq;
0452
0453     streq = kzalloc(sizeof(*streq), GFP_KERNEL);
0454     if (streq)
0455         streq->stp = stp;
0456     else {
0457         st_printk(KERN_ERR, stp,
0458               "Can't get SCSI request.\n");
0459         if (signal_pending(current))
0460             stp->buffer->syscall_result = -EINTR;
0461         else
0462             stp->buffer->syscall_result = -EBUSY;
0463     }
0464
0465     return streq;
0466 }
0467
0468 static void st_release_request(struct st_request *streq)
0469 {
0470     kfree(streq);
0471 }
0472
0473 static void st_do_stats(struct scsi_tape *STp, struct request *req)
0474 {
0475     struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(req);
0476     ktime_t now;
0477
0478     now = ktime_get();
0479     if (scmd->cmnd[0] == WRITE_6) {
0480         now = ktime_sub(now, STp->stats->write_time);
0481         atomic64_add(ktime_to_ns(now), &STp->stats->tot_write_time);
0482         atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
0483         atomic64_inc(&STp->stats->write_cnt);
0484         if (scmd->result) {
0485             atomic64_add(atomic_read(&STp->stats->last_write_size)
0486                 - STp->buffer->cmdstat.residual,
0487                 &STp->stats->write_byte_cnt);
0488             if (STp->buffer->cmdstat.residual > 0)
0489                 atomic64_inc(&STp->stats->resid_cnt);
0490         } else
0491             atomic64_add(atomic_read(&STp->stats->last_write_size),
0492                 &STp->stats->write_byte_cnt);
0493     } else if (scmd->cmnd[0] == READ_6) {
0494         now = ktime_sub(now, STp->stats->read_time);
0495         atomic64_add(ktime_to_ns(now), &STp->stats->tot_read_time);
0496         atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
0497         atomic64_inc(&STp->stats->read_cnt);
0498         if (scmd->result) {
0499             atomic64_add(atomic_read(&STp->stats->last_read_size)
0500                 - STp->buffer->cmdstat.residual,
0501                 &STp->stats->read_byte_cnt);
0502             if (STp->buffer->cmdstat.residual > 0)
0503                 atomic64_inc(&STp->stats->resid_cnt);
0504         } else
0505             atomic64_add(atomic_read(&STp->stats->last_read_size),
0506                 &STp->stats->read_byte_cnt);
0507     } else {
0508         now = ktime_sub(now, STp->stats->other_time);
0509         atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
0510         atomic64_inc(&STp->stats->other_cnt);
0511     }
0512     atomic64_dec(&STp->stats->in_flight);
0513 }
0514
0515 static void st_scsi_execute_end(struct request *req, blk_status_t status)
0516 {
0517     struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(req);
0518     struct st_request *SRpnt = req->end_io_data;
0519     struct scsi_tape *STp = SRpnt->stp;
0520     struct bio *tmp;
0521
0522     STp->buffer->cmdstat.midlevel_result = SRpnt->result = scmd->result;
0523     STp->buffer->cmdstat.residual = scmd->resid_len;
0524
0525     st_do_stats(STp, req);
0526
0527     tmp = SRpnt->bio;
0528     if (scmd->sense_len)
0529         memcpy(SRpnt->sense, scmd->sense_buffer, SCSI_SENSE_BUFFERSIZE);
0530     if (SRpnt->waiting)
0531         complete(SRpnt->waiting);
0532
0533     blk_rq_unmap_user(tmp);
0534     blk_mq_free_request(req);
0535 }
0536
0537 static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
0538                int data_direction, void *buffer, unsigned bufflen,
0539                int timeout, int retries)
0540 {
0541     struct request *req;
0542     struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
0543     int err = 0;
0544     struct scsi_tape *STp = SRpnt->stp;
0545     struct scsi_cmnd *scmd;
0546
0547     req = scsi_alloc_request(SRpnt->stp->device->request_queue,
0548             data_direction == DMA_TO_DEVICE ?
0549             REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
0550     if (IS_ERR(req))
0551         return PTR_ERR(req);
0552     scmd = blk_mq_rq_to_pdu(req);
0553     req->rq_flags |= RQF_QUIET;
0554
0555     mdata->null_mapped = 1;
0556
0557     if (bufflen) {
0558         err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen,
0559                       GFP_KERNEL);
0560         if (err) {
0561             blk_mq_free_request(req);
0562             return err;
0563         }
0564     }
0565
0566     atomic64_inc(&STp->stats->in_flight);
0567     if (cmd[0] == WRITE_6) {
0568         atomic_set(&STp->stats->last_write_size, bufflen);
0569         STp->stats->write_time = ktime_get();
0570     } else if (cmd[0] == READ_6) {
0571         atomic_set(&STp->stats->last_read_size, bufflen);
0572         STp->stats->read_time = ktime_get();
0573     } else {
0574         STp->stats->other_time = ktime_get();
0575     }
0576
0577     SRpnt->bio = req->bio;
0578     scmd->cmd_len = COMMAND_SIZE(cmd[0]);
0579     memcpy(scmd->cmnd, cmd, scmd->cmd_len);
0580     req->timeout = timeout;
0581     scmd->allowed = retries;
0582     req->end_io = st_scsi_execute_end;
0583     req->end_io_data = SRpnt;
0584
0585     blk_execute_rq_nowait(req, true);
0586     return 0;
0587 }
0588
0589 /* Do the scsi command. Waits until command performed if do_wait is true.
0590    Otherwise write_behind_check() is used to check that the command
0591    has finished. */
0592 static struct st_request *
0593 st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
0594        int bytes, int direction, int timeout, int retries, int do_wait)
0595 {
0596     struct completion *waiting;
0597     struct rq_map_data *mdata = &STp->buffer->map_data;
0598     int ret;
0599
0600     /* if async, make sure there's no command outstanding */
0601     if (!do_wait && ((STp->buffer)->last_SRpnt)) {
0602         st_printk(KERN_ERR, STp,
0603               "Async command already active.\n");
0604         if (signal_pending(current))
0605             (STp->buffer)->syscall_result = (-EINTR);
0606         else
0607             (STp->buffer)->syscall_result = (-EBUSY);
0608         return NULL;
0609     }
0610
0611     if (!SRpnt) {
0612         SRpnt = st_allocate_request(STp);
0613         if (!SRpnt)
0614             return NULL;
0615     }
0616
0617     /* If async IO, set last_SRpnt. This ptr tells write_behind_check
0618        which IO is outstanding. It's nulled out when the IO completes. */
0619     if (!do_wait)
0620         (STp->buffer)->last_SRpnt = SRpnt;
0621
0622     waiting = &STp->wait;
0623     init_completion(waiting);
0624     SRpnt->waiting = waiting;
0625
0626     if (STp->buffer->do_dio) {
0627         mdata->page_order = 0;
0628         mdata->nr_entries = STp->buffer->sg_segs;
0629         mdata->pages = STp->buffer->mapped_pages;
0630     } else {
0631         mdata->page_order = STp->buffer->reserved_page_order;
0632         mdata->nr_entries =
0633             DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order);
0634         mdata->pages = STp->buffer->reserved_pages;
0635         mdata->offset = 0;
0636     }
0637
0638     memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
0639     STp->buffer->cmdstat.have_sense = 0;
0640     STp->buffer->syscall_result = 0;
0641
0642     ret = st_scsi_execute(SRpnt, cmd, direction, NULL, bytes, timeout,
0643                   retries);
0644     if (ret) {
0645         /* could not allocate the buffer or request was too large */
0646         (STp->buffer)->syscall_result = (-EBUSY);
0647         (STp->buffer)->last_SRpnt = NULL;
0648     } else if (do_wait) {
0649         wait_for_completion(waiting);
0650         SRpnt->waiting = NULL;
0651         (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
0652     }
0653
0654     return SRpnt;
0655 }
0656
0657
0658 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
0659    write has been correct but EOM early warning reached, -EIO if write ended in
0660    error or zero if write successful. Asynchronous writes are used only in
0661    variable block mode. */
0662 static int write_behind_check(struct scsi_tape * STp)
0663 {
0664     int retval = 0;
0665     struct st_buffer *STbuffer;
0666     struct st_partstat *STps;
0667     struct st_cmdstatus *cmdstatp;
0668     struct st_request *SRpnt;
0669
0670     STbuffer = STp->buffer;
0671     if (!STbuffer->writing)
0672         return 0;
0673
0674     DEB(
0675     if (STp->write_pending)
0676         STp->nbr_waits++;
0677     else
0678         STp->nbr_finished++;
0679     ) /* end DEB */
0680
0681     wait_for_completion(&(STp->wait));
0682     SRpnt = STbuffer->last_SRpnt;
0683     STbuffer->last_SRpnt = NULL;
0684     SRpnt->waiting = NULL;
0685
0686     (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
0687     st_release_request(SRpnt);
0688
0689     STbuffer->buffer_bytes -= STbuffer->writing;
0690     STps = &(STp->ps[STp->partition]);
0691     if (STps->drv_block >= 0) {
0692         if (STp->block_size == 0)
0693             STps->drv_block++;
0694         else
0695             STps->drv_block += STbuffer->writing / STp->block_size;
0696     }
0697
0698     cmdstatp = &STbuffer->cmdstat;
0699     if (STbuffer->syscall_result) {
0700         retval = -EIO;
0701         if (cmdstatp->have_sense && !cmdstatp->deferred &&
0702             (cmdstatp->flags & SENSE_EOM) &&
0703             (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
0704              cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
0705             /* EOM at write-behind, has all data been written? */
0706             if (!cmdstatp->remainder_valid ||
0707                 cmdstatp->uremainder64 == 0)
0708                 retval = -ENOSPC;
0709         }
0710         if (retval == -EIO)
0711             STps->drv_block = -1;
0712     }
0713     STbuffer->writing = 0;
0714
0715     DEB(if (debugging && retval)
0716             st_printk(ST_DEB_MSG, STp,
0717                 "Async write error %x, return value %d.\n",
0718                 STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
0719
0720     return retval;
0721 }
0722
0723
0724 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
0725    it messes up the block number). */
0726 static int cross_eof(struct scsi_tape * STp, int forward)
0727 {
0728     struct st_request *SRpnt;
0729     unsigned char cmd[MAX_COMMAND_SIZE];
0730
0731     cmd[0] = SPACE;
0732     cmd[1] = 0x01;      /* Space FileMarks */
0733     if (forward) {
0734         cmd[2] = cmd[3] = 0;
0735         cmd[4] = 1;
0736     } else
0737         cmd[2] = cmd[3] = cmd[4] = 0xff;    /* -1 filemarks */
0738     cmd[5] = 0;
0739
0740     DEBC_printk(STp, "Stepping over filemark %s.\n",
0741             forward ? "forward" : "backward");
0742
0743     SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
0744                STp->device->request_queue->rq_timeout,
0745                MAX_RETRIES, 1);
0746     if (!SRpnt)
0747         return (STp->buffer)->syscall_result;
0748
0749     st_release_request(SRpnt);
0750     SRpnt = NULL;
0751
0752     if ((STp->buffer)->cmdstat.midlevel_result != 0)
0753         st_printk(KERN_ERR, STp,
0754               "Stepping over filemark %s failed.\n",
0755               forward ? "forward" : "backward");
0756
0757     return (STp->buffer)->syscall_result;
0758 }
0759
0760
0761 /* Flush the write buffer (never need to write if variable blocksize). */
0762 static int st_flush_write_buffer(struct scsi_tape * STp)
0763 {
0764     int transfer, blks;
0765     int result;
0766     unsigned char cmd[MAX_COMMAND_SIZE];
0767     struct st_request *SRpnt;
0768     struct st_partstat *STps;
0769
0770     result = write_behind_check(STp);
0771     if (result)
0772         return result;
0773
0774     result = 0;
0775     if (STp->dirty == 1) {
0776
0777         transfer = STp->buffer->buffer_bytes;
0778         DEBC_printk(STp, "Flushing %d bytes.\n", transfer);
0779
0780         memset(cmd, 0, MAX_COMMAND_SIZE);
0781         cmd[0] = WRITE_6;
0782         cmd[1] = 1;
0783         blks = transfer / STp->block_size;
0784         cmd[2] = blks >> 16;
0785         cmd[3] = blks >> 8;
0786         cmd[4] = blks;
0787
0788         SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
0789                    STp->device->request_queue->rq_timeout,
0790                    MAX_WRITE_RETRIES, 1);
0791         if (!SRpnt)
0792             return (STp->buffer)->syscall_result;
0793
0794         STps = &(STp->ps[STp->partition]);
0795         if ((STp->buffer)->syscall_result != 0) {
0796             struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
0797
0798             if (cmdstatp->have_sense && !cmdstatp->deferred &&
0799                 (cmdstatp->flags & SENSE_EOM) &&
0800                 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
0801                  cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
0802                 (!cmdstatp->remainder_valid ||
0803                  cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
0804                 STp->dirty = 0;
0805                 (STp->buffer)->buffer_bytes = 0;
0806                 if (STps->drv_block >= 0)
0807                     STps->drv_block += blks;
0808                 result = (-ENOSPC);
0809             } else {
0810                 st_printk(KERN_ERR, STp, "Error on flush.\n");
0811                 STps->drv_block = (-1);
0812                 result = (-EIO);
0813             }
0814         } else {
0815             if (STps->drv_block >= 0)
0816                 STps->drv_block += blks;
0817             STp->dirty = 0;
0818             (STp->buffer)->buffer_bytes = 0;
0819         }
0820         st_release_request(SRpnt);
0821         SRpnt = NULL;
0822     }
0823     return result;
0824 }
0825
0826
0827 /* Flush the tape buffer. The tape will be positioned correctly unless
0828    seek_next is true. */
0829 static int flush_buffer(struct scsi_tape *STp, int seek_next)
0830 {
0831     int backspace, result;
0832     struct st_partstat *STps;
0833
0834     /*
0835      * If there was a bus reset, block further access
0836      * to this device.
0837      */
0838     if (STp->pos_unknown)
0839         return (-EIO);
0840
0841     if (STp->ready != ST_READY)
0842         return 0;
0843     STps = &(STp->ps[STp->partition]);
0844     if (STps->rw == ST_WRITING) /* Writing */
0845         return st_flush_write_buffer(STp);
0846
0847     if (STp->block_size == 0)
0848         return 0;
0849
0850     backspace = ((STp->buffer)->buffer_bytes +
0851              (STp->buffer)->read_pointer) / STp->block_size -
0852         ((STp->buffer)->read_pointer + STp->block_size - 1) /
0853         STp->block_size;
0854     (STp->buffer)->buffer_bytes = 0;
0855     (STp->buffer)->read_pointer = 0;
0856     result = 0;
0857     if (!seek_next) {
0858         if (STps->eof == ST_FM_HIT) {
0859             result = cross_eof(STp, 0); /* Back over the EOF hit */
0860             if (!result)
0861                 STps->eof = ST_NOEOF;
0862             else {
0863                 if (STps->drv_file >= 0)
0864                     STps->drv_file++;
0865                 STps->drv_block = 0;
0866             }
0867         }
0868         if (!result && backspace > 0)
0869             result = st_int_ioctl(STp, MTBSR, backspace);
0870     } else if (STps->eof == ST_FM_HIT) {
0871         if (STps->drv_file >= 0)
0872             STps->drv_file++;
0873         STps->drv_block = 0;
0874         STps->eof = ST_NOEOF;
0875     }
0876     return result;
0877
0878 }
0879
0880 /* Set the mode parameters */
0881 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
0882 {
0883     int set_it = 0;
0884     unsigned long arg;
0885
0886     if (!STp->density_changed &&
0887         STm->default_density >= 0 &&
0888         STm->default_density != STp->density) {
0889         arg = STm->default_density;
0890         set_it = 1;
0891     } else
0892         arg = STp->density;
0893     arg <<= MT_ST_DENSITY_SHIFT;
0894     if (!STp->blksize_changed &&
0895         STm->default_blksize >= 0 &&
0896         STm->default_blksize != STp->block_size) {
0897         arg |= STm->default_blksize;
0898         set_it = 1;
0899     } else
0900         arg |= STp->block_size;
0901     if (set_it &&
0902         st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
0903         st_printk(KERN_WARNING, STp,
0904               "Can't set default block size to %d bytes "
0905               "and density %x.\n",
0906               STm->default_blksize, STm->default_density);
0907         if (modes_defined)
0908             return (-EINVAL);
0909     }
0910     return 0;
0911 }
0912
0913
0914 /* Lock or unlock the drive door. Don't use when st_request allocated. */
0915 static int do_door_lock(struct scsi_tape * STp, int do_lock)
0916 {
0917     int retval;
0918
0919     DEBC_printk(STp, "%socking drive door.\n", do_lock ? "L" : "Unl");
0920
0921     retval = scsi_set_medium_removal(STp->device,
0922             do_lock ? SCSI_REMOVAL_PREVENT : SCSI_REMOVAL_ALLOW);
0923     if (!retval)
0924         STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
0925     else
0926         STp->door_locked = ST_LOCK_FAILS;
0927     return retval;
0928 }
0929
0930
0931 /* Set the internal state after reset */
0932 static void reset_state(struct scsi_tape *STp)
0933 {
0934     int i;
0935     struct st_partstat *STps;
0936
0937     STp->pos_unknown = 0;
0938     for (i = 0; i < ST_NBR_PARTITIONS; i++) {
0939         STps = &(STp->ps[i]);
0940         STps->rw = ST_IDLE;
0941         STps->eof = ST_NOEOF;
0942         STps->at_sm = 0;
0943         STps->last_block_valid = 0;
0944         STps->drv_block = -1;
0945         STps->drv_file = -1;
0946     }
0947     if (STp->can_partitions) {
0948         STp->partition = find_partition(STp);
0949         if (STp->partition < 0)
0950             STp->partition = 0;
0951         STp->new_partition = STp->partition;
0952     }
0953 }
0954
0955 /* Test if the drive is ready. Returns either one of the codes below or a negative system
0956    error code. */
0957 #define CHKRES_READY       0
0958 #define CHKRES_NEW_SESSION 1
0959 #define CHKRES_NOT_READY   2
0960 #define CHKRES_NO_TAPE     3
0961
0962 #define MAX_ATTENTIONS    10
0963
0964 static int test_ready(struct scsi_tape *STp, int do_wait)
0965 {
0966     int attentions, waits, max_wait, scode;
0967     int retval = CHKRES_READY, new_session = 0;
0968     unsigned char cmd[MAX_COMMAND_SIZE];
0969     struct st_request *SRpnt = NULL;
0970     struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
0971
0972     max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
0973
0974     for (attentions=waits=0; ; ) {
0975         memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
0976         cmd[0] = TEST_UNIT_READY;
0977         SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
0978                    STp->long_timeout, MAX_READY_RETRIES, 1);
0979
0980         if (!SRpnt) {
0981             retval = (STp->buffer)->syscall_result;
0982             break;
0983         }
0984
0985         if (cmdstatp->have_sense) {
0986
0987             scode = cmdstatp->sense_hdr.sense_key;
0988
0989             if (scode == UNIT_ATTENTION) { /* New media? */
0990                 new_session = 1;
0991                 if (attentions < MAX_ATTENTIONS) {
0992                     attentions++;
0993                     continue;
0994                 }
0995                 else {
0996                     retval = (-EIO);
0997                     break;
0998                 }
0999             }
1000
1001             if (scode == NOT_READY) {
1002                 if (waits < max_wait) {
1003                     if (msleep_interruptible(1000)) {
1004                         retval = (-EINTR);
1005                         break;
1006                     }
1007                     waits++;
1008                     continue;
1009                 }
1010                 else {
1011                     if ((STp->device)->scsi_level >= SCSI_2 &&
1012                         cmdstatp->sense_hdr.asc == 0x3a)    /* Check ASC */
1013                         retval = CHKRES_NO_TAPE;
1014                     else
1015                         retval = CHKRES_NOT_READY;
1016                     break;
1017                 }
1018             }
1019         }
1020
1021         retval = (STp->buffer)->syscall_result;
1022         if (!retval)
1023             retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
1024         break;
1025     }
1026
1027     if (SRpnt != NULL)
1028         st_release_request(SRpnt);
1029     return retval;
1030 }
1031
1032
1033 /* See if the drive is ready and gather information about the tape. Return values:
1034    < 0   negative error code from errno.h
1035    0     drive ready
1036    1     drive not ready (possibly no tape)
1037 */
1038 static int check_tape(struct scsi_tape *STp, struct file *filp)
1039 {
1040     int i, retval, new_session = 0, do_wait;
1041     unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
1042     unsigned short st_flags = filp->f_flags;
1043     struct st_request *SRpnt = NULL;
1044     struct st_modedef *STm;
1045     struct st_partstat *STps;
1046     struct inode *inode = file_inode(filp);
1047     int mode = TAPE_MODE(inode);
1048
1049     STp->ready = ST_READY;
1050
1051     if (mode != STp->current_mode) {
1052         DEBC_printk(STp, "Mode change from %d to %d.\n",
1053                 STp->current_mode, mode);
1054         new_session = 1;
1055         STp->current_mode = mode;
1056     }
1057     STm = &(STp->modes[STp->current_mode]);
1058
1059     saved_cleaning = STp->cleaning_req;
1060     STp->cleaning_req = 0;
1061
1062     do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
1063     retval = test_ready(STp, do_wait);
1064
1065     if (retval < 0)
1066         goto err_out;
1067
1068     if (retval == CHKRES_NEW_SESSION) {
1069         STp->pos_unknown = 0;
1070         STp->partition = STp->new_partition = 0;
1071         if (STp->can_partitions)
1072             STp->nbr_partitions = 1; /* This guess will be updated later
1073                                                     if necessary */
1074         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1075             STps = &(STp->ps[i]);
1076             STps->rw = ST_IDLE;
1077             STps->eof = ST_NOEOF;
1078             STps->at_sm = 0;
1079             STps->last_block_valid = 0;
1080             STps->drv_block = 0;
1081             STps->drv_file = 0;
1082         }
1083         new_session = 1;
1084     }
1085     else {
1086         STp->cleaning_req |= saved_cleaning;
1087
1088         if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
1089             if (retval == CHKRES_NO_TAPE)
1090                 STp->ready = ST_NO_TAPE;
1091             else
1092                 STp->ready = ST_NOT_READY;
1093
1094             STp->density = 0;   /* Clear the erroneous "residue" */
1095             STp->write_prot = 0;
1096             STp->block_size = 0;
1097             STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
1098             STp->partition = STp->new_partition = 0;
1099             STp->door_locked = ST_UNLOCKED;
1100             return CHKRES_NOT_READY;
1101         }
1102     }
1103
1104     if (STp->omit_blklims)
1105         STp->min_block = STp->max_block = (-1);
1106     else {
1107         memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1108         cmd[0] = READ_BLOCK_LIMITS;
1109
1110         SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
1111                    STp->device->request_queue->rq_timeout,
1112                    MAX_READY_RETRIES, 1);
1113         if (!SRpnt) {
1114             retval = (STp->buffer)->syscall_result;
1115             goto err_out;
1116         }
1117
1118         if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
1119             STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1120                 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1121             STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1122                 (STp->buffer)->b_data[5];
1123             if ( DEB( debugging || ) !STp->inited)
1124                 st_printk(KERN_INFO, STp,
1125                       "Block limits %d - %d bytes.\n",
1126                       STp->min_block, STp->max_block);
1127         } else {
1128             STp->min_block = STp->max_block = (-1);
1129             DEBC_printk(STp, "Can't read block limits.\n");
1130         }
1131     }
1132
1133     memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1134     cmd[0] = MODE_SENSE;
1135     cmd[4] = 12;
1136
1137     SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1138                STp->device->request_queue->rq_timeout,
1139                MAX_READY_RETRIES, 1);
1140     if (!SRpnt) {
1141         retval = (STp->buffer)->syscall_result;
1142         goto err_out;
1143     }
1144
1145     if ((STp->buffer)->syscall_result != 0) {
1146         DEBC_printk(STp, "No Mode Sense.\n");
1147         STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
1148         (STp->buffer)->syscall_result = 0;  /* Prevent error propagation */
1149         STp->drv_write_prot = 0;
1150     } else {
1151         DEBC_printk(STp,"Mode sense. Length %d, "
1152                 "medium %x, WBS %x, BLL %d\n",
1153                 (STp->buffer)->b_data[0],
1154                 (STp->buffer)->b_data[1],
1155                 (STp->buffer)->b_data[2],
1156                 (STp->buffer)->b_data[3]);
1157
1158         if ((STp->buffer)->b_data[3] >= 8) {
1159             STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1160             STp->density = (STp->buffer)->b_data[4];
1161             STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1162                 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1163             DEBC_printk(STp, "Density %x, tape length: %x, "
1164                     "drv buffer: %d\n",
1165                     STp->density,
1166                     (STp->buffer)->b_data[5] * 65536 +
1167                     (STp->buffer)->b_data[6] * 256 +
1168                     (STp->buffer)->b_data[7],
1169                     STp->drv_buffer);
1170         }
1171         STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1172         if (!STp->drv_buffer && STp->immediate_filemark) {
1173             st_printk(KERN_WARNING, STp,
1174                   "non-buffered tape: disabling "
1175                   "writing immediate filemarks\n");
1176             STp->immediate_filemark = 0;
1177         }
1178     }
1179     st_release_request(SRpnt);
1180     SRpnt = NULL;
1181     STp->inited = 1;
1182
1183     if (STp->block_size > 0)
1184         (STp->buffer)->buffer_blocks =
1185             (STp->buffer)->buffer_size / STp->block_size;
1186     else
1187         (STp->buffer)->buffer_blocks = 1;
1188     (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1189
1190     DEBC_printk(STp, "Block size: %d, buffer size: %d (%d blocks).\n",
1191             STp->block_size, (STp->buffer)->buffer_size,
1192             (STp->buffer)->buffer_blocks);
1193
1194     if (STp->drv_write_prot) {
1195         STp->write_prot = 1;
1196
1197         DEBC_printk(STp, "Write protected\n");
1198
1199         if (do_wait &&
1200             ((st_flags & O_ACCMODE) == O_WRONLY ||
1201              (st_flags & O_ACCMODE) == O_RDWR)) {
1202             retval = (-EROFS);
1203             goto err_out;
1204         }
1205     }
1206
1207     if (STp->can_partitions && STp->nbr_partitions < 1) {
1208         /* This code is reached when the device is opened for the first time
1209            after the driver has been initialized with tape in the drive and the
1210            partition support has been enabled. */
1211         DEBC_printk(STp, "Updating partition number in status.\n");
1212         if ((STp->partition = find_partition(STp)) < 0) {
1213             retval = STp->partition;
1214             goto err_out;
1215         }
1216         STp->new_partition = STp->partition;
1217         STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1218     }
1219
1220     if (new_session) {  /* Change the drive parameters for the new mode */
1221         STp->density_changed = STp->blksize_changed = 0;
1222         STp->compression_changed = 0;
1223         if (!(STm->defaults_for_writes) &&
1224             (retval = set_mode_densblk(STp, STm)) < 0)
1225             goto err_out;
1226
1227         if (STp->default_drvbuffer != 0xff) {
1228             if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1229                 st_printk(KERN_WARNING, STp,
1230                       "Can't set default drive "
1231                       "buffering to %d.\n",
1232                       STp->default_drvbuffer);
1233         }
1234     }
1235
1236     return CHKRES_READY;
1237
1238  err_out:
1239     return retval;
1240 }
1241
1242
1243 /* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1244    module count. */
1245 static int st_open(struct inode *inode, struct file *filp)
1246 {
1247     int i, retval = (-EIO);
1248     int resumed = 0;
1249     struct scsi_tape *STp;
1250     struct st_partstat *STps;
1251     int dev = TAPE_NR(inode);
1252
1253     /*
1254      * We really want to do nonseekable_open(inode, filp); here, but some
1255      * versions of tar incorrectly call lseek on tapes and bail out if that
1256      * fails.  So we disallow pread() and pwrite(), but permit lseeks.
1257      */
1258     filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1259
1260     if (!(STp = scsi_tape_get(dev))) {
1261         return -ENXIO;
1262     }
1263
1264     filp->private_data = STp;
1265
1266     spin_lock(&st_use_lock);
1267     if (STp->in_use) {
1268         spin_unlock(&st_use_lock);
1269         DEBC_printk(STp, "Device already in use.\n");
1270         scsi_tape_put(STp);
1271         return (-EBUSY);
1272     }
1273
1274     STp->in_use = 1;
1275     spin_unlock(&st_use_lock);
1276     STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1277
1278     if (scsi_autopm_get_device(STp->device) < 0) {
1279         retval = -EIO;
1280         goto err_out;
1281     }
1282     resumed = 1;
1283     if (!scsi_block_when_processing_errors(STp->device)) {
1284         retval = (-ENXIO);
1285         goto err_out;
1286     }
1287
1288     /* See that we have at least a one page buffer available */
1289     if (!enlarge_buffer(STp->buffer, PAGE_SIZE)) {
1290         st_printk(KERN_WARNING, STp,
1291               "Can't allocate one page tape buffer.\n");
1292         retval = (-EOVERFLOW);
1293         goto err_out;
1294     }
1295
1296     (STp->buffer)->cleared = 0;
1297     (STp->buffer)->writing = 0;
1298     (STp->buffer)->syscall_result = 0;
1299
1300     STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1301
1302     STp->dirty = 0;
1303     for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1304         STps = &(STp->ps[i]);
1305         STps->rw = ST_IDLE;
1306     }
1307     STp->try_dio_now = STp->try_dio;
1308     STp->recover_count = 0;
1309     DEB( STp->nbr_waits = STp->nbr_finished = 0;
1310          STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
1311
1312     retval = check_tape(STp, filp);
1313     if (retval < 0)
1314         goto err_out;
1315     if ((filp->f_flags & O_NONBLOCK) == 0 &&
1316         retval != CHKRES_READY) {
1317         if (STp->ready == NO_TAPE)
1318             retval = (-ENOMEDIUM);
1319         else
1320             retval = (-EIO);
1321         goto err_out;
1322     }
1323     return 0;
1324
1325  err_out:
1326     normalize_buffer(STp->buffer);
1327     spin_lock(&st_use_lock);
1328     STp->in_use = 0;
1329     spin_unlock(&st_use_lock);
1330     if (resumed)
1331         scsi_autopm_put_device(STp->device);
1332     scsi_tape_put(STp);
1333     return retval;
1334
1335 }
1336
1337
1338 /* Flush the tape buffer before close */
1339 static int st_flush(struct file *filp, fl_owner_t id)
1340 {
1341     int result = 0, result2;
1342     unsigned char cmd[MAX_COMMAND_SIZE];
1343     struct st_request *SRpnt;
1344     struct scsi_tape *STp = filp->private_data;
1345     struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1346     struct st_partstat *STps = &(STp->ps[STp->partition]);
1347
1348     if (file_count(filp) > 1)
1349         return 0;
1350
1351     if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1352         result = st_flush_write_buffer(STp);
1353         if (result != 0 && result != (-ENOSPC))
1354             goto out;
1355     }
1356
1357     if (STp->can_partitions &&
1358         (result2 = switch_partition(STp)) < 0) {
1359         DEBC_printk(STp, "switch_partition at close failed.\n");
1360         if (result == 0)
1361             result = result2;
1362         goto out;
1363     }
1364
1365     DEBC( if (STp->nbr_requests)
1366         st_printk(KERN_DEBUG, STp,
1367               "Number of r/w requests %d, dio used in %d, "
1368               "pages %d.\n", STp->nbr_requests, STp->nbr_dio,
1369               STp->nbr_pages));
1370
1371     if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1372         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1373
1374 #if DEBUG
1375         DEBC_printk(STp, "Async write waits %d, finished %d.\n",
1376                 STp->nbr_waits, STp->nbr_finished);
1377 #endif
1378         memset(cmd, 0, MAX_COMMAND_SIZE);
1379         cmd[0] = WRITE_FILEMARKS;
1380         if (STp->immediate_filemark)
1381             cmd[1] = 1;
1382         cmd[4] = 1 + STp->two_fm;
1383
1384         SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1385                    STp->device->request_queue->rq_timeout,
1386                    MAX_WRITE_RETRIES, 1);
1387         if (!SRpnt) {
1388             result = (STp->buffer)->syscall_result;
1389             goto out;
1390         }
1391
1392         if (STp->buffer->syscall_result == 0 ||
1393             (cmdstatp->have_sense && !cmdstatp->deferred &&
1394              (cmdstatp->flags & SENSE_EOM) &&
1395              (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1396               cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1397              (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1398             /* Write successful at EOM */
1399             st_release_request(SRpnt);
1400             SRpnt = NULL;
1401             if (STps->drv_file >= 0)
1402                 STps->drv_file++;
1403             STps->drv_block = 0;
1404             if (STp->two_fm)
1405                 cross_eof(STp, 0);
1406             STps->eof = ST_FM;
1407         }
1408         else { /* Write error */
1409             st_release_request(SRpnt);
1410             SRpnt = NULL;
1411             st_printk(KERN_ERR, STp,
1412                   "Error on write filemark.\n");
1413             if (result == 0)
1414                 result = (-EIO);
1415         }
1416
1417         DEBC_printk(STp, "Buffer flushed, %d EOF(s) written\n", cmd[4]);
1418     } else if (!STp->rew_at_close) {
1419         STps = &(STp->ps[STp->partition]);
1420         if (!STm->sysv || STps->rw != ST_READING) {
1421             if (STp->can_bsr)
1422                 result = flush_buffer(STp, 0);
1423             else if (STps->eof == ST_FM_HIT) {
1424                 result = cross_eof(STp, 0);
1425                 if (result) {
1426                     if (STps->drv_file >= 0)
1427                         STps->drv_file++;
1428                     STps->drv_block = 0;
1429                     STps->eof = ST_FM;
1430                 } else
1431                     STps->eof = ST_NOEOF;
1432             }
1433         } else if ((STps->eof == ST_NOEOF &&
1434                 !(result = cross_eof(STp, 1))) ||
1435                STps->eof == ST_FM_HIT) {
1436             if (STps->drv_file >= 0)
1437                 STps->drv_file++;
1438             STps->drv_block = 0;
1439             STps->eof = ST_FM;
1440         }
1441     }
1442
1443       out:
1444     if (STp->rew_at_close) {
1445         result2 = st_int_ioctl(STp, MTREW, 1);
1446         if (result == 0)
1447             result = result2;
1448     }
1449     return result;
1450 }
1451
1452
1453 /* Close the device and release it. BKL is not needed: this is the only thread
1454    accessing this tape. */
1455 static int st_release(struct inode *inode, struct file *filp)
1456 {
1457     struct scsi_tape *STp = filp->private_data;
1458
1459     if (STp->door_locked == ST_LOCKED_AUTO)
1460         do_door_lock(STp, 0);
1461
1462     normalize_buffer(STp->buffer);
1463     spin_lock(&st_use_lock);
1464     STp->in_use = 0;
1465     spin_unlock(&st_use_lock);
1466     scsi_autopm_put_device(STp->device);
1467     scsi_tape_put(STp);
1468
1469     return 0;
1470 }
1471
1472 /* The checks common to both reading and writing */
1473 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1474 {
1475     ssize_t retval = 0;
1476
1477     /*
1478      * If we are in the middle of error recovery, don't let anyone
1479      * else try and use this device.  Also, if error recovery fails, it
1480      * may try and take the device offline, in which case all further
1481      * access to the device is prohibited.
1482      */
1483     if (!scsi_block_when_processing_errors(STp->device)) {
1484         retval = (-ENXIO);
1485         goto out;
1486     }
1487
1488     if (STp->ready != ST_READY) {
1489         if (STp->ready == ST_NO_TAPE)
1490             retval = (-ENOMEDIUM);
1491         else
1492             retval = (-EIO);
1493         goto out;
1494     }
1495
1496     if (! STp->modes[STp->current_mode].defined) {
1497         retval = (-ENXIO);
1498         goto out;
1499     }
1500
1501
1502     /*
1503      * If there was a bus reset, block further access
1504      * to this device.
1505      */
1506     if (STp->pos_unknown) {
1507         retval = (-EIO);
1508         goto out;
1509     }
1510
1511     if (count == 0)
1512         goto out;
1513
1514     DEB(
1515     if (!STp->in_use) {
1516         st_printk(ST_DEB_MSG, STp,
1517               "Incorrect device.\n");
1518         retval = (-EIO);
1519         goto out;
1520     } ) /* end DEB */
1521
1522     if (STp->can_partitions &&
1523         (retval = switch_partition(STp)) < 0)
1524         goto out;
1525
1526     if (STp->block_size == 0 && STp->max_block > 0 &&
1527         (count < STp->min_block || count > STp->max_block)) {
1528         retval = (-EINVAL);
1529         goto out;
1530     }
1531
1532     if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1533         !do_door_lock(STp, 1))
1534         STp->door_locked = ST_LOCKED_AUTO;
1535
1536  out:
1537     return retval;
1538 }
1539
1540
1541 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1542                size_t count, int is_read)
1543 {
1544     int i, bufsize, retval = 0;
1545     struct st_buffer *STbp = STp->buffer;
1546
1547     if (is_read)
1548         i = STp->try_dio_now && try_rdio;
1549     else
1550         i = STp->try_dio_now && try_wdio;
1551
1552     if (i && ((unsigned long)buf & queue_dma_alignment(
1553                     STp->device->request_queue)) == 0) {
1554         i = sgl_map_user_pages(STbp, STbp->use_sg, (unsigned long)buf,
1555                        count, (is_read ? READ : WRITE));
1556         if (i > 0) {
1557             STbp->do_dio = i;
1558             STbp->buffer_bytes = 0;   /* can be used as transfer counter */
1559         }
1560         else
1561             STbp->do_dio = 0;  /* fall back to buffering with any error */
1562         STbp->sg_segs = STbp->do_dio;
1563         DEB(
1564              if (STbp->do_dio) {
1565             STp->nbr_dio++;
1566             STp->nbr_pages += STbp->do_dio;
1567              }
1568         )
1569     } else
1570         STbp->do_dio = 0;
1571     DEB( STp->nbr_requests++; )
1572
1573     if (!STbp->do_dio) {
1574         if (STp->block_size)
1575             bufsize = STp->block_size > st_fixed_buffer_size ?
1576                 STp->block_size : st_fixed_buffer_size;
1577         else {
1578             bufsize = count;
1579             /* Make sure that data from previous user is not leaked even if
1580                HBA does not return correct residual */
1581             if (is_read && STp->sili && !STbp->cleared)
1582                 clear_buffer(STbp);
1583         }
1584
1585         if (bufsize > STbp->buffer_size &&
1586             !enlarge_buffer(STbp, bufsize)) {
1587             st_printk(KERN_WARNING, STp,
1588                   "Can't allocate %d byte tape buffer.\n",
1589                   bufsize);
1590             retval = (-EOVERFLOW);
1591             goto out;
1592         }
1593         if (STp->block_size)
1594             STbp->buffer_blocks = bufsize / STp->block_size;
1595     }
1596
1597  out:
1598     return retval;
1599 }
1600
1601
1602 /* Can be called more than once after each setup_buffer() */
1603 static void release_buffering(struct scsi_tape *STp, int is_read)
1604 {
1605     struct st_buffer *STbp;
1606
1607     STbp = STp->buffer;
1608     if (STbp->do_dio) {
1609         sgl_unmap_user_pages(STbp, STbp->do_dio, is_read);
1610         STbp->do_dio = 0;
1611         STbp->sg_segs = 0;
1612     }
1613 }
1614
1615
1616 /* Write command */
1617 static ssize_t
1618 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1619 {
1620     ssize_t total;
1621     ssize_t i, do_count, blks, transfer;
1622     ssize_t retval;
1623     int undone, retry_eot = 0, scode;
1624     int async_write;
1625     unsigned char cmd[MAX_COMMAND_SIZE];
1626     const char __user *b_point;
1627     struct st_request *SRpnt = NULL;
1628     struct scsi_tape *STp = filp->private_data;
1629     struct st_modedef *STm;
1630     struct st_partstat *STps;
1631     struct st_buffer *STbp;
1632
1633     if (mutex_lock_interruptible(&STp->lock))
1634         return -ERESTARTSYS;
1635
1636     retval = rw_checks(STp, filp, count);
1637     if (retval || count == 0)
1638         goto out;
1639
1640     /* Write must be integral number of blocks */
1641     if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1642         st_printk(KERN_WARNING, STp,
1643               "Write not multiple of tape block size.\n");
1644         retval = (-EINVAL);
1645         goto out;
1646     }
1647
1648     STm = &(STp->modes[STp->current_mode]);
1649     STps = &(STp->ps[STp->partition]);
1650
1651     if (STp->write_prot) {
1652         retval = (-EACCES);
1653         goto out;
1654     }
1655
1656
1657     if (STps->rw == ST_READING) {
1658         retval = flush_buffer(STp, 0);
1659         if (retval)
1660             goto out;
1661         STps->rw = ST_WRITING;
1662     } else if (STps->rw != ST_WRITING &&
1663            STps->drv_file == 0 && STps->drv_block == 0) {
1664         if ((retval = set_mode_densblk(STp, STm)) < 0)
1665             goto out;
1666         if (STm->default_compression != ST_DONT_TOUCH &&
1667             !(STp->compression_changed)) {
1668             if (st_compression(STp, (STm->default_compression == ST_YES))) {
1669                 st_printk(KERN_WARNING, STp,
1670                       "Can't set default compression.\n");
1671                 if (modes_defined) {
1672                     retval = (-EINVAL);
1673                     goto out;
1674                 }
1675             }
1676         }
1677     }
1678
1679     STbp = STp->buffer;
1680     i = write_behind_check(STp);
1681     if (i) {
1682         if (i == -ENOSPC)
1683             STps->eof = ST_EOM_OK;
1684         else
1685             STps->eof = ST_EOM_ERROR;
1686     }
1687
1688     if (STps->eof == ST_EOM_OK) {
1689         STps->eof = ST_EOD_1;  /* allow next write */
1690         retval = (-ENOSPC);
1691         goto out;
1692     }
1693     else if (STps->eof == ST_EOM_ERROR) {
1694         retval = (-EIO);
1695         goto out;
1696     }
1697
1698     /* Check the buffer readability in cases where copy_user might catch
1699        the problems after some tape movement. */
1700     if (STp->block_size != 0 &&
1701         !STbp->do_dio &&
1702         (copy_from_user(&i, buf, 1) != 0 ||
1703          copy_from_user(&i, buf + count - 1, 1) != 0)) {
1704         retval = (-EFAULT);
1705         goto out;
1706     }
1707
1708     retval = setup_buffering(STp, buf, count, 0);
1709     if (retval)
1710         goto out;
1711
1712     total = count;
1713
1714     memset(cmd, 0, MAX_COMMAND_SIZE);
1715     cmd[0] = WRITE_6;
1716     cmd[1] = (STp->block_size != 0);
1717
1718     STps->rw = ST_WRITING;
1719
1720     b_point = buf;
1721     while (count > 0 && !retry_eot) {
1722
1723         if (STbp->do_dio) {
1724             do_count = count;
1725         }
1726         else {
1727             if (STp->block_size == 0)
1728                 do_count = count;
1729             else {
1730                 do_count = STbp->buffer_blocks * STp->block_size -
1731                     STbp->buffer_bytes;
1732                 if (do_count > count)
1733                     do_count = count;
1734             }
1735
1736             i = append_to_buffer(b_point, STbp, do_count);
1737             if (i) {
1738                 retval = i;
1739                 goto out;
1740             }
1741         }
1742         count -= do_count;
1743         b_point += do_count;
1744
1745         async_write = STp->block_size == 0 && !STbp->do_dio &&
1746             STm->do_async_writes && STps->eof < ST_EOM_OK;
1747
1748         if (STp->block_size != 0 && STm->do_buffer_writes &&
1749             !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1750             STbp->buffer_bytes < STbp->buffer_size) {
1751             STp->dirty = 1;
1752             /* Don't write a buffer that is not full enough. */
1753             if (!async_write && count == 0)
1754                 break;
1755         }
1756
1757     retry_write:
1758         if (STp->block_size == 0)
1759             blks = transfer = do_count;
1760         else {
1761             if (!STbp->do_dio)
1762                 blks = STbp->buffer_bytes;
1763             else
1764                 blks = do_count;
1765             blks /= STp->block_size;
1766             transfer = blks * STp->block_size;
1767         }
1768         cmd[2] = blks >> 16;
1769         cmd[3] = blks >> 8;
1770         cmd[4] = blks;
1771
1772         SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1773                    STp->device->request_queue->rq_timeout,
1774                    MAX_WRITE_RETRIES, !async_write);
1775         if (!SRpnt) {
1776             retval = STbp->syscall_result;
1777             goto out;
1778         }
1779         if (async_write && !STbp->syscall_result) {
1780             STbp->writing = transfer;
1781             STp->dirty = !(STbp->writing ==
1782                        STbp->buffer_bytes);
1783             SRpnt = NULL;  /* Prevent releasing this request! */
1784             DEB( STp->write_pending = 1; )
1785             break;
1786         }
1787
1788         if (STbp->syscall_result != 0) {
1789             struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1790
1791             DEBC_printk(STp, "Error on write:\n");
1792             if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1793                 scode = cmdstatp->sense_hdr.sense_key;
1794                 if (cmdstatp->remainder_valid)
1795                     undone = (int)cmdstatp->uremainder64;
1796                 else if (STp->block_size == 0 &&
1797                      scode == VOLUME_OVERFLOW)
1798                     undone = transfer;
1799                 else
1800                     undone = 0;
1801                 if (STp->block_size != 0)
1802                     undone *= STp->block_size;
1803                 if (undone <= do_count) {
1804                     /* Only data from this write is not written */
1805                     count += undone;
1806                     b_point -= undone;
1807                     do_count -= undone;
1808                     if (STp->block_size)
1809                         blks = (transfer - undone) / STp->block_size;
1810                     STps->eof = ST_EOM_OK;
1811                     /* Continue in fixed block mode if all written
1812                        in this request but still something left to write
1813                        (retval left to zero)
1814                     */
1815                     if (STp->block_size == 0 ||
1816                         undone > 0 || count == 0)
1817                         retval = (-ENOSPC); /* EOM within current request */
1818                     DEBC_printk(STp, "EOM with %d "
1819                             "bytes unwritten.\n",
1820                             (int)count);
1821                 } else {
1822                     /* EOT within data buffered earlier (possible only
1823                        in fixed block mode without direct i/o) */
1824                     if (!retry_eot && !cmdstatp->deferred &&
1825                         (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1826                         move_buffer_data(STp->buffer, transfer - undone);
1827                         retry_eot = 1;
1828                         if (STps->drv_block >= 0) {
1829                             STps->drv_block += (transfer - undone) /
1830                                 STp->block_size;
1831                         }
1832                         STps->eof = ST_EOM_OK;
1833                         DEBC_printk(STp, "Retry "
1834                                 "write of %d "
1835                                 "bytes at EOM.\n",
1836                                 STp->buffer->buffer_bytes);
1837                         goto retry_write;
1838                     }
1839                     else {
1840                         /* Either error within data buffered by driver or
1841                            failed retry */
1842                         count -= do_count;
1843                         blks = do_count = 0;
1844                         STps->eof = ST_EOM_ERROR;
1845                         STps->drv_block = (-1); /* Too cautious? */
1846                         retval = (-EIO);    /* EOM for old data */
1847                         DEBC_printk(STp, "EOM with "
1848                                 "lost data.\n");
1849                     }
1850                 }
1851             } else {
1852                 count += do_count;
1853                 STps->drv_block = (-1);     /* Too cautious? */
1854                 retval = STbp->syscall_result;
1855             }
1856
1857         }
1858
1859         if (STps->drv_block >= 0) {
1860             if (STp->block_size == 0)
1861                 STps->drv_block += (do_count > 0);
1862             else
1863                 STps->drv_block += blks;
1864         }
1865
1866         STbp->buffer_bytes = 0;
1867         STp->dirty = 0;
1868
1869         if (retval || retry_eot) {
1870             if (count < total)
1871                 retval = total - count;
1872             goto out;
1873         }
1874     }
1875
1876     if (STps->eof == ST_EOD_1)
1877         STps->eof = ST_EOM_OK;
1878     else if (STps->eof != ST_EOM_OK)
1879         STps->eof = ST_NOEOF;
1880     retval = total - count;
1881
1882  out:
1883     if (SRpnt != NULL)
1884         st_release_request(SRpnt);
1885     release_buffering(STp, 0);
1886     mutex_unlock(&STp->lock);
1887
1888     return retval;
1889 }
1890
1891 /* Read data from the tape. Returns zero in the normal case, one if the
1892    eof status has changed, and the negative error code in case of a
1893    fatal error. Otherwise updates the buffer and the eof state.
1894
1895    Does release user buffer mapping if it is set.
1896 */
1897 static long read_tape(struct scsi_tape *STp, long count,
1898               struct st_request ** aSRpnt)
1899 {
1900     int transfer, blks, bytes;
1901     unsigned char cmd[MAX_COMMAND_SIZE];
1902     struct st_request *SRpnt;
1903     struct st_modedef *STm;
1904     struct st_partstat *STps;
1905     struct st_buffer *STbp;
1906     int retval = 0;
1907
1908     if (count == 0)
1909         return 0;
1910
1911     STm = &(STp->modes[STp->current_mode]);
1912     STps = &(STp->ps[STp->partition]);
1913     if (STps->eof == ST_FM_HIT)
1914         return 1;
1915     STbp = STp->buffer;
1916
1917     if (STp->block_size == 0)
1918         blks = bytes = count;
1919     else {
1920         if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1921             blks = (STp->buffer)->buffer_blocks;
1922             bytes = blks * STp->block_size;
1923         } else {
1924             bytes = count;
1925             if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1926                 bytes = (STp->buffer)->buffer_size;
1927             blks = bytes / STp->block_size;
1928             bytes = blks * STp->block_size;
1929         }
1930     }
1931
1932     memset(cmd, 0, MAX_COMMAND_SIZE);
1933     cmd[0] = READ_6;
1934     cmd[1] = (STp->block_size != 0);
1935     if (!cmd[1] && STp->sili)
1936         cmd[1] |= 2;
1937     cmd[2] = blks >> 16;
1938     cmd[3] = blks >> 8;
1939     cmd[4] = blks;
1940
1941     SRpnt = *aSRpnt;
1942     SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1943                STp->device->request_queue->rq_timeout,
1944                MAX_RETRIES, 1);
1945     release_buffering(STp, 1);
1946     *aSRpnt = SRpnt;
1947     if (!SRpnt)
1948         return STbp->syscall_result;
1949
1950     STbp->read_pointer = 0;
1951     STps->at_sm = 0;
1952
1953     /* Something to check */
1954     if (STbp->syscall_result) {
1955         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1956
1957         retval = 1;
1958         DEBC_printk(STp,
1959                 "Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1960                 SRpnt->sense[0], SRpnt->sense[1],
1961                 SRpnt->sense[2], SRpnt->sense[3],
1962                 SRpnt->sense[4], SRpnt->sense[5],
1963                 SRpnt->sense[6], SRpnt->sense[7]);
1964         if (cmdstatp->have_sense) {
1965
1966             if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1967                 cmdstatp->flags &= 0xcf;    /* No need for EOM in this case */
1968
1969             if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1970                 /* Compute the residual count */
1971                 if (cmdstatp->remainder_valid)
1972                     transfer = (int)cmdstatp->uremainder64;
1973                 else
1974                     transfer = 0;
1975                 if (cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR) {
1976                     if (STp->block_size == 0)
1977                         transfer = bytes;
1978                     /* Some drives set ILI with MEDIUM ERROR */
1979                     cmdstatp->flags &= ~SENSE_ILI;
1980                 }
1981
1982                 if (cmdstatp->flags & SENSE_ILI) {  /* ILI */
1983                     if (STp->block_size == 0 &&
1984                         transfer < 0) {
1985                         st_printk(KERN_NOTICE, STp,
1986                               "Failed to read %d "
1987                               "byte block with %d "
1988                               "byte transfer.\n",
1989                               bytes - transfer,
1990                               bytes);
1991                         if (STps->drv_block >= 0)
1992                             STps->drv_block += 1;
1993                         STbp->buffer_bytes = 0;
1994                         return (-ENOMEM);
1995                     } else if (STp->block_size == 0) {
1996                         STbp->buffer_bytes = bytes - transfer;
1997                     } else {
1998                         st_release_request(SRpnt);
1999                         SRpnt = *aSRpnt = NULL;
2000                         if (transfer == blks) { /* We did not get anything, error */
2001                             st_printk(KERN_NOTICE, STp,
2002                                   "Incorrect "
2003                                   "block size.\n");
2004                             if (STps->drv_block >= 0)
2005                                 STps->drv_block += blks - transfer + 1;
2006                             st_int_ioctl(STp, MTBSR, 1);
2007                             return (-EIO);
2008                         }
2009                         /* We have some data, deliver it */
2010                         STbp->buffer_bytes = (blks - transfer) *
2011                             STp->block_size;
2012                         DEBC_printk(STp, "ILI but "
2013                                 "enough data "
2014                                 "received %ld "
2015                                 "%d.\n", count,
2016                                 STbp->buffer_bytes);
2017                         if (STps->drv_block >= 0)
2018                             STps->drv_block += 1;
2019                         if (st_int_ioctl(STp, MTBSR, 1))
2020                             return (-EIO);
2021                     }
2022                 } else if (cmdstatp->flags & SENSE_FMK) {   /* FM overrides EOM */
2023                     if (STps->eof != ST_FM_HIT)
2024                         STps->eof = ST_FM_HIT;
2025                     else
2026                         STps->eof = ST_EOD_2;
2027                     if (STp->block_size == 0)
2028                         STbp->buffer_bytes = 0;
2029                     else
2030                         STbp->buffer_bytes =
2031                             bytes - transfer * STp->block_size;
2032                     DEBC_printk(STp, "EOF detected (%d "
2033                             "bytes read).\n",
2034                             STbp->buffer_bytes);
2035                 } else if (cmdstatp->flags & SENSE_EOM) {
2036                     if (STps->eof == ST_FM)
2037                         STps->eof = ST_EOD_1;
2038                     else
2039                         STps->eof = ST_EOM_OK;
2040                     if (STp->block_size == 0)
2041                         STbp->buffer_bytes = bytes - transfer;
2042                     else
2043                         STbp->buffer_bytes =
2044                             bytes - transfer * STp->block_size;
2045
2046                     DEBC_printk(STp, "EOM detected (%d "
2047                             "bytes read).\n",
2048                             STbp->buffer_bytes);
2049                 }
2050             }
2051             /* end of EOF, EOM, ILI test */
2052             else {  /* nonzero sense key */
2053                 DEBC_printk(STp, "Tape error while reading.\n");
2054                 STps->drv_block = (-1);
2055                 if (STps->eof == ST_FM &&
2056                     cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
2057                     DEBC_printk(STp, "Zero returned for "
2058                             "first BLANK CHECK "
2059                             "after EOF.\n");
2060                     STps->eof = ST_EOD_2;   /* First BLANK_CHECK after FM */
2061                 } else  /* Some other extended sense code */
2062                     retval = (-EIO);
2063             }
2064
2065             if (STbp->buffer_bytes < 0)  /* Caused by bogus sense data */
2066                 STbp->buffer_bytes = 0;
2067         }
2068         /* End of extended sense test */
2069         else {      /* Non-extended sense */
2070             retval = STbp->syscall_result;
2071         }
2072
2073     }
2074     /* End of error handling */
2075     else {          /* Read successful */
2076         STbp->buffer_bytes = bytes;
2077         if (STp->sili) /* In fixed block mode residual is always zero here */
2078             STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
2079     }
2080
2081     if (STps->drv_block >= 0) {
2082         if (STp->block_size == 0)
2083             STps->drv_block++;
2084         else
2085             STps->drv_block += STbp->buffer_bytes / STp->block_size;
2086     }
2087     return retval;
2088 }
2089
2090
2091 /* Read command */
2092 static ssize_t
2093 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
2094 {
2095     ssize_t total;
2096     ssize_t retval = 0;
2097     ssize_t i, transfer;
2098     int special, do_dio = 0;
2099     struct st_request *SRpnt = NULL;
2100     struct scsi_tape *STp = filp->private_data;
2101     struct st_modedef *STm;
2102     struct st_partstat *STps;
2103     struct st_buffer *STbp = STp->buffer;
2104
2105     if (mutex_lock_interruptible(&STp->lock))
2106         return -ERESTARTSYS;
2107
2108     retval = rw_checks(STp, filp, count);
2109     if (retval || count == 0)
2110         goto out;
2111
2112     STm = &(STp->modes[STp->current_mode]);
2113     if (STp->block_size != 0 && (count % STp->block_size) != 0) {
2114         if (!STm->do_read_ahead) {
2115             retval = (-EINVAL); /* Read must be integral number of blocks */
2116             goto out;
2117         }
2118         STp->try_dio_now = 0;  /* Direct i/o can't handle split blocks */
2119     }
2120
2121     STps = &(STp->ps[STp->partition]);
2122     if (STps->rw == ST_WRITING) {
2123         retval = flush_buffer(STp, 0);
2124         if (retval)
2125             goto out;
2126         STps->rw = ST_READING;
2127     }
2128     DEB(
2129     if (debugging && STps->eof != ST_NOEOF)
2130         st_printk(ST_DEB_MSG, STp,
2131               "EOF/EOM flag up (%d). Bytes %d\n",
2132               STps->eof, STbp->buffer_bytes);
2133     ) /* end DEB */
2134
2135     retval = setup_buffering(STp, buf, count, 1);
2136     if (retval)
2137         goto out;
2138     do_dio = STbp->do_dio;
2139
2140     if (STbp->buffer_bytes == 0 &&
2141         STps->eof >= ST_EOD_1) {
2142         if (STps->eof < ST_EOD) {
2143             STps->eof += 1;
2144             retval = 0;
2145             goto out;
2146         }
2147         retval = (-EIO);    /* EOM or Blank Check */
2148         goto out;
2149     }
2150
2151     if (do_dio) {
2152         /* Check the buffer writability before any tape movement. Don't alter
2153            buffer data. */
2154         if (copy_from_user(&i, buf, 1) != 0 ||
2155             copy_to_user(buf, &i, 1) != 0 ||
2156             copy_from_user(&i, buf + count - 1, 1) != 0 ||
2157             copy_to_user(buf + count - 1, &i, 1) != 0) {
2158             retval = (-EFAULT);
2159             goto out;
2160         }
2161     }
2162
2163     STps->rw = ST_READING;
2164
2165
2166     /* Loop until enough data in buffer or a special condition found */
2167     for (total = 0, special = 0; total < count && !special;) {
2168
2169         /* Get new data if the buffer is empty */
2170         if (STbp->buffer_bytes == 0) {
2171             special = read_tape(STp, count - total, &SRpnt);
2172             if (special < 0) {  /* No need to continue read */
2173                 retval = special;
2174                 goto out;
2175             }
2176         }
2177
2178         /* Move the data from driver buffer to user buffer */
2179         if (STbp->buffer_bytes > 0) {
2180             DEB(
2181             if (debugging && STps->eof != ST_NOEOF)
2182                 st_printk(ST_DEB_MSG, STp,
2183                       "EOF up (%d). Left %d, needed %d.\n",
2184                       STps->eof, STbp->buffer_bytes,
2185                       (int)(count - total));
2186             ) /* end DEB */
2187             transfer = STbp->buffer_bytes < count - total ?
2188                 STbp->buffer_bytes : count - total;
2189             if (!do_dio) {
2190                 i = from_buffer(STbp, buf, transfer);
2191                 if (i) {
2192                     retval = i;
2193                     goto out;
2194                 }
2195             }
2196             buf += transfer;
2197             total += transfer;
2198         }
2199
2200         if (STp->block_size == 0)
2201             break;  /* Read only one variable length block */
2202
2203     }           /* for (total = 0, special = 0;
2204                                    total < count && !special; ) */
2205
2206     /* Change the eof state if no data from tape or buffer */
2207     if (total == 0) {
2208         if (STps->eof == ST_FM_HIT) {
2209             STps->eof = ST_FM;
2210             STps->drv_block = 0;
2211             if (STps->drv_file >= 0)
2212                 STps->drv_file++;
2213         } else if (STps->eof == ST_EOD_1) {
2214             STps->eof = ST_EOD_2;
2215             STps->drv_block = 0;
2216             if (STps->drv_file >= 0)
2217                 STps->drv_file++;
2218         } else if (STps->eof == ST_EOD_2)
2219             STps->eof = ST_EOD;
2220     } else if (STps->eof == ST_FM)
2221         STps->eof = ST_NOEOF;
2222     retval = total;
2223
2224  out:
2225     if (SRpnt != NULL) {
2226         st_release_request(SRpnt);
2227         SRpnt = NULL;
2228     }
2229     if (do_dio) {
2230         release_buffering(STp, 1);
2231         STbp->buffer_bytes = 0;
2232     }
2233     mutex_unlock(&STp->lock);
2234
2235     return retval;
2236 }
2237
2238
2239
2240 DEB(
2241 /* Set the driver options */
2242 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm)
2243 {
2244     if (debugging) {
2245         st_printk(KERN_INFO, STp,
2246               "Mode %d options: buffer writes: %d, "
2247               "async writes: %d, read ahead: %d\n",
2248               STp->current_mode, STm->do_buffer_writes,
2249               STm->do_async_writes, STm->do_read_ahead);
2250         st_printk(KERN_INFO, STp,
2251               "    can bsr: %d, two FMs: %d, "
2252               "fast mteom: %d, auto lock: %d,\n",
2253               STp->can_bsr, STp->two_fm, STp->fast_mteom,
2254               STp->do_auto_lock);
2255         st_printk(KERN_INFO, STp,
2256               "    defs for wr: %d, no block limits: %d, "
2257               "partitions: %d, s2 log: %d\n",
2258               STm->defaults_for_writes, STp->omit_blklims,
2259               STp->can_partitions, STp->scsi2_logical);
2260         st_printk(KERN_INFO, STp,
2261               "    sysv: %d nowait: %d sili: %d "
2262               "nowait_filemark: %d\n",
2263               STm->sysv, STp->immediate, STp->sili,
2264               STp->immediate_filemark);
2265         st_printk(KERN_INFO, STp, "    debugging: %d\n", debugging);
2266     }
2267 }
2268     )
2269
2270
2271 static int st_set_options(struct scsi_tape *STp, long options)
2272 {
2273     int value;
2274     long code;
2275     struct st_modedef *STm;
2276     struct cdev *cd0, *cd1;
2277     struct device *d0, *d1;
2278
2279     STm = &(STp->modes[STp->current_mode]);
2280     if (!STm->defined) {
2281         cd0 = STm->cdevs[0];
2282         cd1 = STm->cdevs[1];
2283         d0  = STm->devs[0];
2284         d1  = STm->devs[1];
2285         memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2286         STm->cdevs[0] = cd0;
2287         STm->cdevs[1] = cd1;
2288         STm->devs[0]  = d0;
2289         STm->devs[1]  = d1;
2290         modes_defined = 1;
2291         DEBC_printk(STp, "Initialized mode %d definition from mode 0\n",
2292                 STp->current_mode);
2293     }
2294
2295     code = options & MT_ST_OPTIONS;
2296     if (code == MT_ST_BOOLEANS) {
2297         STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2298         STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2299         STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2300         STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2301         STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2302         STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2303         STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2304         STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2305         STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2306         if ((STp->device)->scsi_level >= SCSI_2)
2307             STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2308         STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2309         STp->immediate = (options & MT_ST_NOWAIT) != 0;
2310         STp->immediate_filemark = (options & MT_ST_NOWAIT_EOF) != 0;
2311         STm->sysv = (options & MT_ST_SYSV) != 0;
2312         STp->sili = (options & MT_ST_SILI) != 0;
2313         DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2314              st_log_options(STp, STm); )
2315     } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2316         value = (code == MT_ST_SETBOOLEANS);
2317         if ((options & MT_ST_BUFFER_WRITES) != 0)
2318             STm->do_buffer_writes = value;
2319         if ((options & MT_ST_ASYNC_WRITES) != 0)
2320             STm->do_async_writes = value;
2321         if ((options & MT_ST_DEF_WRITES) != 0)
2322             STm->defaults_for_writes = value;
2323         if ((options & MT_ST_READ_AHEAD) != 0)
2324             STm->do_read_ahead = value;
2325         if ((options & MT_ST_TWO_FM) != 0)
2326             STp->two_fm = value;
2327         if ((options & MT_ST_FAST_MTEOM) != 0)
2328             STp->fast_mteom = value;
2329         if ((options & MT_ST_AUTO_LOCK) != 0)
2330             STp->do_auto_lock = value;
2331         if ((options & MT_ST_CAN_BSR) != 0)
2332             STp->can_bsr = value;
2333         if ((options & MT_ST_NO_BLKLIMS) != 0)
2334             STp->omit_blklims = value;
2335         if ((STp->device)->scsi_level >= SCSI_2 &&
2336             (options & MT_ST_CAN_PARTITIONS) != 0)
2337             STp->can_partitions = value;
2338         if ((options & MT_ST_SCSI2LOGICAL) != 0)
2339             STp->scsi2_logical = value;
2340         if ((options & MT_ST_NOWAIT) != 0)
2341             STp->immediate = value;
2342         if ((options & MT_ST_NOWAIT_EOF) != 0)
2343             STp->immediate_filemark = value;
2344         if ((options & MT_ST_SYSV) != 0)
2345             STm->sysv = value;
2346         if ((options & MT_ST_SILI) != 0)
2347             STp->sili = value;
2348         DEB(
2349         if ((options & MT_ST_DEBUGGING) != 0)
2350             debugging = value;
2351             st_log_options(STp, STm); )
2352     } else if (code == MT_ST_WRITE_THRESHOLD) {
2353         /* Retained for compatibility */
2354     } else if (code == MT_ST_DEF_BLKSIZE) {
2355         value = (options & ~MT_ST_OPTIONS);
2356         if (value == ~MT_ST_OPTIONS) {
2357             STm->default_blksize = (-1);
2358             DEBC_printk(STp, "Default block size disabled.\n");
2359         } else {
2360             STm->default_blksize = value;
2361             DEBC_printk(STp,"Default block size set to "
2362                     "%d bytes.\n", STm->default_blksize);
2363             if (STp->ready == ST_READY) {
2364                 STp->blksize_changed = 0;
2365                 set_mode_densblk(STp, STm);
2366             }
2367         }
2368     } else if (code == MT_ST_TIMEOUTS) {
2369         value = (options & ~MT_ST_OPTIONS);
2370         if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2371             STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2372             DEBC_printk(STp, "Long timeout set to %d seconds.\n",
2373                     (value & ~MT_ST_SET_LONG_TIMEOUT));
2374         } else {
2375             blk_queue_rq_timeout(STp->device->request_queue,
2376                          value * HZ);
2377             DEBC_printk(STp, "Normal timeout set to %d seconds.\n",
2378                     value);
2379         }
2380     } else if (code == MT_ST_SET_CLN) {
2381         value = (options & ~MT_ST_OPTIONS) & 0xff;
2382         if (value != 0 &&
2383             (value < EXTENDED_SENSE_START ||
2384                 value >= SCSI_SENSE_BUFFERSIZE))
2385             return (-EINVAL);
2386         STp->cln_mode = value;
2387         STp->cln_sense_mask = (options >> 8) & 0xff;
2388         STp->cln_sense_value = (options >> 16) & 0xff;
2389         st_printk(KERN_INFO, STp,
2390               "Cleaning request mode %d, mask %02x, value %02x\n",
2391               value, STp->cln_sense_mask, STp->cln_sense_value);
2392     } else if (code == MT_ST_DEF_OPTIONS) {
2393         code = (options & ~MT_ST_CLEAR_DEFAULT);
2394         value = (options & MT_ST_CLEAR_DEFAULT);
2395         if (code == MT_ST_DEF_DENSITY) {
2396             if (value == MT_ST_CLEAR_DEFAULT) {
2397                 STm->default_density = (-1);
2398                 DEBC_printk(STp,
2399                         "Density default disabled.\n");
2400             } else {
2401                 STm->default_density = value & 0xff;
2402                 DEBC_printk(STp, "Density default set to %x\n",
2403                         STm->default_density);
2404                 if (STp->ready == ST_READY) {
2405                     STp->density_changed = 0;
2406                     set_mode_densblk(STp, STm);
2407                 }
2408             }
2409         } else if (code == MT_ST_DEF_DRVBUFFER) {
2410             if (value == MT_ST_CLEAR_DEFAULT) {
2411                 STp->default_drvbuffer = 0xff;
2412                 DEBC_printk(STp,
2413                         "Drive buffer default disabled.\n");
2414             } else {
2415                 STp->default_drvbuffer = value & 7;
2416                 DEBC_printk(STp,
2417                         "Drive buffer default set to %x\n",
2418                         STp->default_drvbuffer);
2419                 if (STp->ready == ST_READY)
2420                     st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2421             }
2422         } else if (code == MT_ST_DEF_COMPRESSION) {
2423             if (value == MT_ST_CLEAR_DEFAULT) {
2424                 STm->default_compression = ST_DONT_TOUCH;
2425                 DEBC_printk(STp,
2426                         "Compression default disabled.\n");
2427             } else {
2428                 if ((value & 0xff00) != 0) {
2429                     STp->c_algo = (value & 0xff00) >> 8;
2430                     DEBC_printk(STp, "Compression "
2431                             "algorithm set to 0x%x.\n",
2432                             STp->c_algo);
2433                 }
2434                 if ((value & 0xff) != 0xff) {
2435                     STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2436                     DEBC_printk(STp, "Compression default "
2437                             "set to %x\n",
2438                             (value & 1));
2439                     if (STp->ready == ST_READY) {
2440                         STp->compression_changed = 0;
2441                         st_compression(STp, (STm->default_compression == ST_YES));
2442                     }
2443                 }
2444             }
2445         }
2446     } else
2447         return (-EIO);
2448
2449     return 0;
2450 }
2451
2452 #define MODE_HEADER_LENGTH  4
2453
2454 /* Mode header and page byte offsets */
2455 #define MH_OFF_DATA_LENGTH     0
2456 #define MH_OFF_MEDIUM_TYPE     1
2457 #define MH_OFF_DEV_SPECIFIC    2
2458 #define MH_OFF_BDESCS_LENGTH   3
2459 #define MP_OFF_PAGE_NBR        0
2460 #define MP_OFF_PAGE_LENGTH     1
2461
2462 /* Mode header and page bit masks */
2463 #define MH_BIT_WP              0x80
2464 #define MP_MSK_PAGE_NBR        0x3f
2465
2466 /* Don't return block descriptors */
2467 #define MODE_SENSE_OMIT_BDESCS 0x08
2468
2469 #define MODE_SELECT_PAGE_FORMAT 0x10
2470
2471 /* Read a mode page into the tape buffer. The block descriptors are included
2472    if incl_block_descs is true. The page control is ored to the page number
2473    parameter, if necessary. */
2474 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2475 {
2476     unsigned char cmd[MAX_COMMAND_SIZE];
2477     struct st_request *SRpnt;
2478
2479     memset(cmd, 0, MAX_COMMAND_SIZE);
2480     cmd[0] = MODE_SENSE;
2481     if (omit_block_descs)
2482         cmd[1] = MODE_SENSE_OMIT_BDESCS;
2483     cmd[2] = page;
2484     cmd[4] = 255;
2485
2486     SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2487                STp->device->request_queue->rq_timeout, 0, 1);
2488     if (SRpnt == NULL)
2489         return (STp->buffer)->syscall_result;
2490
2491     st_release_request(SRpnt);
2492
2493     return STp->buffer->syscall_result;
2494 }
2495
2496
2497 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2498    in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2499 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2500 {
2501     int pgo;
2502     unsigned char cmd[MAX_COMMAND_SIZE];
2503     struct st_request *SRpnt;
2504     int timeout;
2505
2506     memset(cmd, 0, MAX_COMMAND_SIZE);
2507     cmd[0] = MODE_SELECT;
2508     cmd[1] = MODE_SELECT_PAGE_FORMAT;
2509     pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2510     cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2511
2512     /* Clear reserved fields */
2513     (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2514     (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2515     (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2516     (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2517
2518     timeout = slow ?
2519         STp->long_timeout : STp->device->request_queue->rq_timeout;
2520     SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_TO_DEVICE,
2521                timeout, 0, 1);
2522     if (SRpnt == NULL)
2523         return (STp->buffer)->syscall_result;
2524
2525     st_release_request(SRpnt);
2526
2527     return STp->buffer->syscall_result;
2528 }
2529
2530
2531 #define COMPRESSION_PAGE        0x0f
2532 #define COMPRESSION_PAGE_LENGTH 16
2533
2534 #define CP_OFF_DCE_DCC          2
2535 #define CP_OFF_C_ALGO           7
2536
2537 #define DCE_MASK  0x80
2538 #define DCC_MASK  0x40
2539 #define RED_MASK  0x60
2540
2541
2542 /* Control the compression with mode page 15. Algorithm not changed if zero.
2543
2544    The block descriptors are read and written because Sony SDT-7000 does not
2545    work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2546    Including block descriptors should not cause any harm to other drives. */
2547
2548 static int st_compression(struct scsi_tape * STp, int state)
2549 {
2550     int retval;
2551     int mpoffs;  /* Offset to mode page start */
2552     unsigned char *b_data = (STp->buffer)->b_data;
2553
2554     if (STp->ready != ST_READY)
2555         return (-EIO);
2556
2557     /* Read the current page contents */
2558     retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2559     if (retval) {
2560         DEBC_printk(STp, "Compression mode page not supported.\n");
2561         return (-EIO);
2562     }
2563
2564     mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2565     DEBC_printk(STp, "Compression state is %d.\n",
2566             (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0));
2567
2568     /* Check if compression can be changed */
2569     if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2570         DEBC_printk(STp, "Compression not supported.\n");
2571         return (-EIO);
2572     }
2573
2574     /* Do the change */
2575     if (state) {
2576         b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2577         if (STp->c_algo != 0)
2578             b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2579     }
2580     else {
2581         b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2582         if (STp->c_algo != 0)
2583             b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2584     }
2585
2586     retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2587     if (retval) {
2588         DEBC_printk(STp, "Compression change failed.\n");
2589         return (-EIO);
2590     }
2591     DEBC_printk(STp, "Compression state changed to %d.\n", state);
2592
2593     STp->compression_changed = 1;
2594     return 0;
2595 }
2596
2597
2598 /* Process the load and unload commands (does unload if the load code is zero) */
2599 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2600 {
2601     int retval = (-EIO), timeout;
2602     unsigned char cmd[MAX_COMMAND_SIZE];
2603     struct st_partstat *STps;
2604     struct st_request *SRpnt;
2605
2606     if (STp->ready != ST_READY && !load_code) {
2607         if (STp->ready == ST_NO_TAPE)
2608             return (-ENOMEDIUM);
2609         else
2610             return (-EIO);
2611     }
2612
2613     memset(cmd, 0, MAX_COMMAND_SIZE);
2614     cmd[0] = START_STOP;
2615     if (load_code)
2616         cmd[4] |= 1;
2617     /*
2618      * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2619      */
2620     if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2621         && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2622         DEBC_printk(STp, " Enhanced %sload slot %2d.\n",
2623                 (cmd[4]) ? "" : "un",
2624                 load_code - MT_ST_HPLOADER_OFFSET);
2625         cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2626     }
2627     if (STp->immediate) {
2628         cmd[1] = 1; /* Don't wait for completion */
2629         timeout = STp->device->request_queue->rq_timeout;
2630     }
2631     else
2632         timeout = STp->long_timeout;
2633
2634     DEBC(
2635         if (!load_code)
2636             st_printk(ST_DEB_MSG, STp, "Unloading tape.\n");
2637         else
2638             st_printk(ST_DEB_MSG, STp, "Loading tape.\n");
2639         );
2640
2641     SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2642                timeout, MAX_RETRIES, 1);
2643     if (!SRpnt)
2644         return (STp->buffer)->syscall_result;
2645
2646     retval = (STp->buffer)->syscall_result;
2647     st_release_request(SRpnt);
2648
2649     if (!retval) {  /* SCSI command successful */
2650
2651         if (!load_code) {
2652             STp->rew_at_close = 0;
2653             STp->ready = ST_NO_TAPE;
2654         }
2655         else {
2656             STp->rew_at_close = STp->autorew_dev;
2657             retval = check_tape(STp, filp);
2658             if (retval > 0)
2659                 retval = 0;
2660         }
2661     }
2662     else {
2663         STps = &(STp->ps[STp->partition]);
2664         STps->drv_file = STps->drv_block = (-1);
2665     }
2666
2667     return retval;
2668 }
2669
2670 #if DEBUG
2671 #define ST_DEB_FORWARD  0
2672 #define ST_DEB_BACKWARD 1
2673 static void deb_space_print(struct scsi_tape *STp, int direction, char *units, unsigned char *cmd)
2674 {
2675     s32 sc;
2676
2677     if (!debugging)
2678         return;
2679
2680     sc = sign_extend32(get_unaligned_be24(&cmd[2]), 23);
2681     if (direction)
2682         sc = -sc;
2683     st_printk(ST_DEB_MSG, STp, "Spacing tape %s over %d %s.\n",
2684           direction ? "backward" : "forward", sc, units);
2685 }
2686 #else
2687 #define ST_DEB_FORWARD  0
2688 #define ST_DEB_BACKWARD 1
2689 static void deb_space_print(struct scsi_tape *STp, int direction, char *units, unsigned char *cmd) {}
2690 #endif
2691
2692
2693 /* Internal ioctl function */
2694 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2695 {
2696     int timeout;
2697     long ltmp;
2698     int ioctl_result;
2699     int chg_eof = 1;
2700     unsigned char cmd[MAX_COMMAND_SIZE];
2701     struct st_request *SRpnt;
2702     struct st_partstat *STps;
2703     int fileno, blkno, at_sm, undone;
2704     int datalen = 0, direction = DMA_NONE;
2705
2706     WARN_ON(STp->buffer->do_dio != 0);
2707     if (STp->ready != ST_READY) {
2708         if (STp->ready == ST_NO_TAPE)
2709             return (-ENOMEDIUM);
2710         else
2711             return (-EIO);
2712     }
2713     timeout = STp->long_timeout;
2714     STps = &(STp->ps[STp->partition]);
2715     fileno = STps->drv_file;
2716     blkno = STps->drv_block;
2717     at_sm = STps->at_sm;
2718
2719     memset(cmd, 0, MAX_COMMAND_SIZE);
2720     switch (cmd_in) {
2721     case MTFSFM:
2722         chg_eof = 0;    /* Changed from the FSF after this */
2723         fallthrough;
2724     case MTFSF:
2725         cmd[0] = SPACE;
2726         cmd[1] = 0x01;  /* Space FileMarks */
2727         cmd[2] = (arg >> 16);
2728         cmd[3] = (arg >> 8);
2729         cmd[4] = arg;
2730         deb_space_print(STp, ST_DEB_FORWARD, "filemarks", cmd);
2731         if (fileno >= 0)
2732             fileno += arg;
2733         blkno = 0;
2734         at_sm &= (arg == 0);
2735         break;
2736     case MTBSFM:
2737         chg_eof = 0;    /* Changed from the FSF after this */
2738         fallthrough;
2739     case MTBSF:
2740         cmd[0] = SPACE;
2741         cmd[1] = 0x01;  /* Space FileMarks */
2742         ltmp = (-arg);
2743         cmd[2] = (ltmp >> 16);
2744         cmd[3] = (ltmp >> 8);
2745         cmd[4] = ltmp;
2746         deb_space_print(STp, ST_DEB_BACKWARD, "filemarks", cmd);
2747         if (fileno >= 0)
2748             fileno -= arg;
2749         blkno = (-1);   /* We can't know the block number */
2750         at_sm &= (arg == 0);
2751         break;
2752     case MTFSR:
2753         cmd[0] = SPACE;
2754         cmd[1] = 0x00;  /* Space Blocks */
2755         cmd[2] = (arg >> 16);
2756         cmd[3] = (arg >> 8);
2757         cmd[4] = arg;
2758         deb_space_print(STp, ST_DEB_FORWARD, "blocks", cmd);
2759         if (blkno >= 0)
2760             blkno += arg;
2761         at_sm &= (arg == 0);
2762         break;
2763     case MTBSR:
2764         cmd[0] = SPACE;
2765         cmd[1] = 0x00;  /* Space Blocks */
2766         ltmp = (-arg);
2767         cmd[2] = (ltmp >> 16);
2768         cmd[3] = (ltmp >> 8);
2769         cmd[4] = ltmp;
2770         deb_space_print(STp, ST_DEB_BACKWARD, "blocks", cmd);
2771         if (blkno >= 0)
2772             blkno -= arg;
2773         at_sm &= (arg == 0);
2774         break;
2775     case MTFSS:
2776         cmd[0] = SPACE;
2777         cmd[1] = 0x04;  /* Space Setmarks */
2778         cmd[2] = (arg >> 16);
2779         cmd[3] = (arg >> 8);
2780         cmd[4] = arg;
2781         deb_space_print(STp, ST_DEB_FORWARD, "setmarks", cmd);
2782         if (arg != 0) {
2783             blkno = fileno = (-1);
2784             at_sm = 1;
2785         }
2786         break;
2787     case MTBSS:
2788         cmd[0] = SPACE;
2789         cmd[1] = 0x04;  /* Space Setmarks */
2790         ltmp = (-arg);
2791         cmd[2] = (ltmp >> 16);
2792         cmd[3] = (ltmp >> 8);
2793         cmd[4] = ltmp;
2794         deb_space_print(STp, ST_DEB_BACKWARD, "setmarks", cmd);
2795         if (arg != 0) {
2796             blkno = fileno = (-1);
2797             at_sm = 1;
2798         }
2799         break;
2800     case MTWEOF:
2801     case MTWEOFI:
2802     case MTWSM:
2803         if (STp->write_prot)
2804             return (-EACCES);
2805         cmd[0] = WRITE_FILEMARKS;
2806         if (cmd_in == MTWSM)
2807             cmd[1] = 2;
2808         if (cmd_in == MTWEOFI ||
2809             (cmd_in == MTWEOF && STp->immediate_filemark))
2810             cmd[1] |= 1;
2811         cmd[2] = (arg >> 16);
2812         cmd[3] = (arg >> 8);
2813         cmd[4] = arg;
2814         timeout = STp->device->request_queue->rq_timeout;
2815         DEBC(
2816             if (cmd_in != MTWSM)
2817                 st_printk(ST_DEB_MSG, STp,
2818                       "Writing %d filemarks.\n",
2819                       cmd[2] * 65536 +
2820                       cmd[3] * 256 +
2821                       cmd[4]);
2822             else
2823                 st_printk(ST_DEB_MSG, STp,
2824                       "Writing %d setmarks.\n",
2825                       cmd[2] * 65536 +
2826                       cmd[3] * 256 +
2827                       cmd[4]);
2828         )
2829         if (fileno >= 0)
2830             fileno += arg;
2831         blkno = 0;
2832         at_sm = (cmd_in == MTWSM);
2833         break;
2834     case MTREW:
2835         cmd[0] = REZERO_UNIT;
2836         if (STp->immediate) {
2837             cmd[1] = 1; /* Don't wait for completion */
2838             timeout = STp->device->request_queue->rq_timeout;
2839         }
2840         DEBC_printk(STp, "Rewinding tape.\n");
2841         fileno = blkno = at_sm = 0;
2842         break;
2843     case MTNOP:
2844         DEBC_printk(STp, "No op on tape.\n");
2845         return 0;   /* Should do something ? */
2846     case MTRETEN:
2847         cmd[0] = START_STOP;
2848         if (STp->immediate) {
2849             cmd[1] = 1; /* Don't wait for completion */
2850             timeout = STp->device->request_queue->rq_timeout;
2851         }
2852         cmd[4] = 3;
2853         DEBC_printk(STp, "Retensioning tape.\n");
2854         fileno = blkno = at_sm = 0;
2855         break;
2856     case MTEOM:
2857         if (!STp->fast_mteom) {
2858             /* space to the end of tape */
2859             ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2860             fileno = STps->drv_file;
2861             if (STps->eof >= ST_EOD_1)
2862                 return 0;
2863             /* The next lines would hide the number of spaced FileMarks
2864                That's why I inserted the previous lines. I had no luck
2865                with detecting EOM with FSF, so we go now to EOM.
2866                Joerg Weule */
2867         } else
2868             fileno = (-1);
2869         cmd[0] = SPACE;
2870         cmd[1] = 3;
2871         DEBC_printk(STp, "Spacing to end of recorded medium.\n");
2872         blkno = -1;
2873         at_sm = 0;
2874         break;
2875     case MTERASE:
2876         if (STp->write_prot)
2877             return (-EACCES);
2878         cmd[0] = ERASE;
2879         cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2880         if (STp->immediate) {
2881             cmd[1] |= 2;    /* Don't wait for completion */
2882             timeout = STp->device->request_queue->rq_timeout;
2883         }
2884         else
2885             timeout = STp->long_timeout * 8;
2886
2887         DEBC_printk(STp, "Erasing tape.\n");
2888         fileno = blkno = at_sm = 0;
2889         break;
2890     case MTSETBLK:      /* Set block length */
2891     case MTSETDENSITY:  /* Set tape density */
2892     case MTSETDRVBUFFER:    /* Set drive buffering */
2893     case SET_DENS_AND_BLK:  /* Set density and block size */
2894         chg_eof = 0;
2895         if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2896             return (-EIO);  /* Not allowed if data in buffer */
2897         if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2898             (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2899             STp->max_block > 0 &&
2900             ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2901              (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2902             st_printk(KERN_WARNING, STp, "Illegal block size.\n");
2903             return (-EINVAL);
2904         }
2905         cmd[0] = MODE_SELECT;
2906         if ((STp->use_pf & USE_PF))
2907             cmd[1] = MODE_SELECT_PAGE_FORMAT;
2908         cmd[4] = datalen = 12;
2909         direction = DMA_TO_DEVICE;
2910
2911         memset((STp->buffer)->b_data, 0, 12);
2912         if (cmd_in == MTSETDRVBUFFER)
2913             (STp->buffer)->b_data[2] = (arg & 7) << 4;
2914         else
2915             (STp->buffer)->b_data[2] =
2916                 STp->drv_buffer << 4;
2917         (STp->buffer)->b_data[3] = 8;   /* block descriptor length */
2918         if (cmd_in == MTSETDENSITY) {
2919             (STp->buffer)->b_data[4] = arg;
2920             STp->density_changed = 1;   /* At least we tried ;-) */
2921         } else if (cmd_in == SET_DENS_AND_BLK)
2922             (STp->buffer)->b_data[4] = arg >> 24;
2923         else
2924             (STp->buffer)->b_data[4] = STp->density;
2925         if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2926             ltmp = arg & MT_ST_BLKSIZE_MASK;
2927             if (cmd_in == MTSETBLK)
2928                 STp->blksize_changed = 1; /* At least we tried ;-) */
2929         } else
2930             ltmp = STp->block_size;
2931         (STp->buffer)->b_data[9] = (ltmp >> 16);
2932         (STp->buffer)->b_data[10] = (ltmp >> 8);
2933         (STp->buffer)->b_data[11] = ltmp;
2934         timeout = STp->device->request_queue->rq_timeout;
2935         DEBC(
2936             if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2937                 st_printk(ST_DEB_MSG, STp,
2938                       "Setting block size to %d bytes.\n",
2939                       (STp->buffer)->b_data[9] * 65536 +
2940                       (STp->buffer)->b_data[10] * 256 +
2941                       (STp->buffer)->b_data[11]);
2942             if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2943                 st_printk(ST_DEB_MSG, STp,
2944                       "Setting density code to %x.\n",
2945                       (STp->buffer)->b_data[4]);
2946             if (cmd_in == MTSETDRVBUFFER)
2947                 st_printk(ST_DEB_MSG, STp,
2948                       "Setting drive buffer code to %d.\n",
2949                       ((STp->buffer)->b_data[2] >> 4) & 7);
2950         )
2951         break;
2952     default:
2953         return (-ENOSYS);
2954     }
2955
2956     SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2957                timeout, MAX_RETRIES, 1);
2958     if (!SRpnt)
2959         return (STp->buffer)->syscall_result;
2960
2961     ioctl_result = (STp->buffer)->syscall_result;
2962
2963     if (!ioctl_result) {    /* SCSI command successful */
2964         st_release_request(SRpnt);
2965         SRpnt = NULL;
2966         STps->drv_block = blkno;
2967         STps->drv_file = fileno;
2968         STps->at_sm = at_sm;
2969
2970         if (cmd_in == MTBSFM)
2971             ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2972         else if (cmd_in == MTFSFM)
2973             ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2974
2975         if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2976             STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2977             if (STp->block_size != 0) {
2978                 (STp->buffer)->buffer_blocks =
2979                     (STp->buffer)->buffer_size / STp->block_size;
2980             }
2981             (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2982             if (cmd_in == SET_DENS_AND_BLK)
2983                 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2984         } else if (cmd_in == MTSETDRVBUFFER)
2985             STp->drv_buffer = (arg & 7);
2986         else if (cmd_in == MTSETDENSITY)
2987             STp->density = arg;
2988
2989         if (cmd_in == MTEOM)
2990             STps->eof = ST_EOD;
2991         else if (cmd_in == MTFSF)
2992             STps->eof = ST_FM;
2993         else if (chg_eof)
2994             STps->eof = ST_NOEOF;
2995
2996         if (cmd_in == MTWEOF || cmd_in == MTWEOFI)
2997             STps->rw = ST_IDLE;  /* prevent automatic WEOF at close */
2998     } else { /* SCSI command was not completely successful. Don't return
2999                     from this block without releasing the SCSI command block! */
3000         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
3001
3002         if (cmdstatp->flags & SENSE_EOM) {
3003             if (cmd_in != MTBSF && cmd_in != MTBSFM &&
3004                 cmd_in != MTBSR && cmd_in != MTBSS)
3005                 STps->eof = ST_EOM_OK;
3006             STps->drv_block = 0;
3007         }
3008
3009         if (cmdstatp->remainder_valid)
3010             undone = (int)cmdstatp->uremainder64;
3011         else
3012             undone = 0;
3013
3014         if ((cmd_in == MTWEOF || cmd_in == MTWEOFI) &&
3015             cmdstatp->have_sense &&
3016             (cmdstatp->flags & SENSE_EOM)) {
3017             if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
3018                 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
3019                 ioctl_result = 0;   /* EOF(s) written successfully at EOM */
3020                 STps->eof = ST_NOEOF;
3021             } else {  /* Writing EOF(s) failed */
3022                 if (fileno >= 0)
3023                     fileno -= undone;
3024                 if (undone < arg)
3025                     STps->eof = ST_NOEOF;
3026             }
3027             STps->drv_file = fileno;
3028         } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
3029             if (fileno >= 0)
3030                 STps->drv_file = fileno - undone;
3031             else
3032                 STps->drv_file = fileno;
3033             STps->drv_block = -1;
3034             STps->eof = ST_NOEOF;
3035         } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
3036             if (arg > 0 && undone < 0)  /* Some drives get this wrong */
3037                 undone = (-undone);
3038             if (STps->drv_file >= 0)
3039                 STps->drv_file = fileno + undone;
3040             STps->drv_block = 0;
3041             STps->eof = ST_NOEOF;
3042         } else if (cmd_in == MTFSR) {
3043             if (cmdstatp->flags & SENSE_FMK) {  /* Hit filemark */
3044                 if (STps->drv_file >= 0)
3045                     STps->drv_file++;
3046                 STps->drv_block = 0;
3047                 STps->eof = ST_FM;
3048             } else {
3049                 if (blkno >= undone)
3050                     STps->drv_block = blkno - undone;
3051                 else
3052                     STps->drv_block = (-1);
3053                 STps->eof = ST_NOEOF;
3054             }
3055         } else if (cmd_in == MTBSR) {
3056             if (cmdstatp->flags & SENSE_FMK) {  /* Hit filemark */
3057                 STps->drv_file--;
3058                 STps->drv_block = (-1);
3059             } else {
3060                 if (arg > 0 && undone < 0)  /* Some drives get this wrong */
3061                     undone = (-undone);
3062                 if (STps->drv_block >= 0)
3063                     STps->drv_block = blkno + undone;
3064             }
3065             STps->eof = ST_NOEOF;
3066         } else if (cmd_in == MTEOM) {
3067             STps->drv_file = (-1);
3068             STps->drv_block = (-1);
3069             STps->eof = ST_EOD;
3070         } else if (cmd_in == MTSETBLK ||
3071                cmd_in == MTSETDENSITY ||
3072                cmd_in == MTSETDRVBUFFER ||
3073                cmd_in == SET_DENS_AND_BLK) {
3074             if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
3075                 !(STp->use_pf & PF_TESTED)) {
3076                 /* Try the other possible state of Page Format if not
3077                    already tried */
3078                 STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED;
3079                 st_release_request(SRpnt);
3080                 SRpnt = NULL;
3081                 return st_int_ioctl(STp, cmd_in, arg);
3082             }
3083         } else if (chg_eof)
3084             STps->eof = ST_NOEOF;
3085
3086         if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
3087             STps->eof = ST_EOD;
3088
3089         st_release_request(SRpnt);
3090         SRpnt = NULL;
3091     }
3092
3093     return ioctl_result;
3094 }
3095
3096
3097 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
3098    structure. */
3099
3100 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
3101             int logical)
3102 {
3103     int result;
3104     unsigned char scmd[MAX_COMMAND_SIZE];
3105     struct st_request *SRpnt;
3106
3107     if (STp->ready != ST_READY)
3108         return (-EIO);
3109
3110     memset(scmd, 0, MAX_COMMAND_SIZE);
3111     if ((STp->device)->scsi_level < SCSI_2) {
3112         scmd[0] = QFA_REQUEST_BLOCK;
3113         scmd[4] = 3;
3114     } else {
3115         scmd[0] = READ_POSITION;
3116         if (!logical && !STp->scsi2_logical)
3117             scmd[1] = 1;
3118     }
3119     SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
3120                STp->device->request_queue->rq_timeout,
3121                MAX_READY_RETRIES, 1);
3122     if (!SRpnt)
3123         return (STp->buffer)->syscall_result;
3124
3125     if ((STp->buffer)->syscall_result != 0 ||
3126         (STp->device->scsi_level >= SCSI_2 &&
3127          ((STp->buffer)->b_data[0] & 4) != 0)) {
3128         *block = *partition = 0;
3129         DEBC_printk(STp, " Can't read tape position.\n");
3130         result = (-EIO);
3131     } else {
3132         result = 0;
3133         if ((STp->device)->scsi_level < SCSI_2) {
3134             *block = ((STp->buffer)->b_data[0] << 16)
3135                 + ((STp->buffer)->b_data[1] << 8)
3136                 + (STp->buffer)->b_data[2];
3137             *partition = 0;
3138         } else {
3139             *block = ((STp->buffer)->b_data[4] << 24)
3140                 + ((STp->buffer)->b_data[5] << 16)
3141                 + ((STp->buffer)->b_data[6] << 8)
3142                 + (STp->buffer)->b_data[7];
3143             *partition = (STp->buffer)->b_data[1];
3144             if (((STp->buffer)->b_data[0] & 0x80) &&
3145                 (STp->buffer)->b_data[1] == 0)  /* BOP of partition 0 */
3146                 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3147         }
3148         DEBC_printk(STp, "Got tape pos. blk %d part %d.\n",
3149                 *block, *partition);
3150     }
3151     st_release_request(SRpnt);
3152     SRpnt = NULL;
3153
3154     return result;
3155 }
3156
3157
3158 /* Set the tape block and partition. Negative partition means that only the
3159    block should be set in vendor specific way. */
3160 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3161             int logical)
3162 {
3163     struct st_partstat *STps;
3164     int result, p;
3165     unsigned int blk;
3166     int timeout;
3167     unsigned char scmd[MAX_COMMAND_SIZE];
3168     struct st_request *SRpnt;
3169
3170     if (STp->ready != ST_READY)
3171         return (-EIO);
3172     timeout = STp->long_timeout;
3173     STps = &(STp->ps[STp->partition]);
3174
3175     DEBC_printk(STp, "Setting block to %d and partition to %d.\n",
3176             block, partition);
3177     DEB(if (partition < 0)
3178         return (-EIO); )
3179
3180     /* Update the location at the partition we are leaving */
3181     if ((!STp->can_partitions && partition != 0) ||
3182         partition >= ST_NBR_PARTITIONS)
3183         return (-EINVAL);
3184     if (partition != STp->partition) {
3185         if (get_location(STp, &blk, &p, 1))
3186             STps->last_block_valid = 0;
3187         else {
3188             STps->last_block_valid = 1;
3189             STps->last_block_visited = blk;
3190             DEBC_printk(STp, "Visited block %d for "
3191                     "partition %d saved.\n",
3192                     blk, STp->partition);
3193         }
3194     }
3195
3196     memset(scmd, 0, MAX_COMMAND_SIZE);
3197     if ((STp->device)->scsi_level < SCSI_2) {
3198         scmd[0] = QFA_SEEK_BLOCK;
3199         scmd[2] = (block >> 16);
3200         scmd[3] = (block >> 8);
3201         scmd[4] = block;
3202         scmd[5] = 0;
3203     } else {
3204         scmd[0] = SEEK_10;
3205         scmd[3] = (block >> 24);
3206         scmd[4] = (block >> 16);
3207         scmd[5] = (block >> 8);
3208         scmd[6] = block;
3209         if (!logical && !STp->scsi2_logical)
3210             scmd[1] = 4;
3211         if (STp->partition != partition) {
3212             scmd[1] |= 2;
3213             scmd[8] = partition;
3214             DEBC_printk(STp, "Trying to change partition "
3215                     "from %d to %d\n", STp->partition,
3216                     partition);
3217         }
3218     }
3219     if (STp->immediate) {
3220         scmd[1] |= 1;       /* Don't wait for completion */
3221         timeout = STp->device->request_queue->rq_timeout;
3222     }
3223
3224     SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3225                timeout, MAX_READY_RETRIES, 1);
3226     if (!SRpnt)
3227         return (STp->buffer)->syscall_result;
3228
3229     STps->drv_block = STps->drv_file = (-1);
3230     STps->eof = ST_NOEOF;
3231     if ((STp->buffer)->syscall_result != 0) {
3232         result = (-EIO);
3233         if (STp->can_partitions &&
3234             (STp->device)->scsi_level >= SCSI_2 &&
3235             (p = find_partition(STp)) >= 0)
3236             STp->partition = p;
3237     } else {
3238         if (STp->can_partitions) {
3239             STp->partition = partition;
3240             STps = &(STp->ps[partition]);
3241             if (!STps->last_block_valid ||
3242                 STps->last_block_visited != block) {
3243                 STps->at_sm = 0;
3244                 STps->rw = ST_IDLE;
3245             }
3246         } else
3247             STps->at_sm = 0;
3248         if (block == 0)
3249             STps->drv_block = STps->drv_file = 0;
3250         result = 0;
3251     }
3252
3253     st_release_request(SRpnt);
3254     SRpnt = NULL;
3255
3256     return result;
3257 }
3258
3259
3260 /* Find the current partition number for the drive status. Called from open and
3261    returns either partition number of negative error code. */
3262 static int find_partition(struct scsi_tape *STp)
3263 {
3264     int i, partition;
3265     unsigned int block;
3266
3267     if ((i = get_location(STp, &block, &partition, 1)) < 0)
3268         return i;
3269     if (partition >= ST_NBR_PARTITIONS)
3270         return (-EIO);
3271     return partition;
3272 }
3273
3274
3275 /* Change the partition if necessary */
3276 static int switch_partition(struct scsi_tape *STp)
3277 {
3278     struct st_partstat *STps;
3279
3280     if (STp->partition == STp->new_partition)
3281         return 0;
3282     STps = &(STp->ps[STp->new_partition]);
3283     if (!STps->last_block_valid)
3284         STps->last_block_visited = 0;
3285     return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3286 }
3287
3288 /* Functions for reading and writing the medium partition mode page. */
3289
3290 #define PART_PAGE   0x11
3291 #define PART_PAGE_FIXED_LENGTH 8
3292
3293 #define PP_OFF_MAX_ADD_PARTS   2
3294 #define PP_OFF_NBR_ADD_PARTS   3
3295 #define PP_OFF_FLAGS           4
3296 #define PP_OFF_PART_UNITS      6
3297 #define PP_OFF_RESERVED        7
3298
3299 #define PP_BIT_IDP             0x20
3300 #define PP_BIT_FDP             0x80
3301 #define PP_MSK_PSUM_MB         0x10
3302 #define PP_MSK_PSUM_UNITS      0x18
3303 #define PP_MSK_POFM            0x04
3304
3305 /* Get the number of partitions on the tape. As a side effect reads the
3306    mode page into the tape buffer. */
3307 static int nbr_partitions(struct scsi_tape *STp)
3308 {
3309     int result;
3310
3311     if (STp->ready != ST_READY)
3312         return (-EIO);
3313
3314     result = read_mode_page(STp, PART_PAGE, 1);
3315
3316     if (result) {
3317         DEBC_printk(STp, "Can't read medium partition page.\n");
3318         result = (-EIO);
3319     } else {
3320         result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3321                           PP_OFF_NBR_ADD_PARTS] + 1;
3322         DEBC_printk(STp, "Number of partitions %d.\n", result);
3323     }
3324
3325     return result;
3326 }
3327
3328
3329 static int format_medium(struct scsi_tape *STp, int format)
3330 {
3331     int result = 0;
3332     int timeout = STp->long_timeout;
3333     unsigned char scmd[MAX_COMMAND_SIZE];
3334     struct st_request *SRpnt;
3335
3336     memset(scmd, 0, MAX_COMMAND_SIZE);
3337     scmd[0] = FORMAT_UNIT;
3338     scmd[2] = format;
3339     if (STp->immediate) {
3340         scmd[1] |= 1;       /* Don't wait for completion */
3341         timeout = STp->device->request_queue->rq_timeout;
3342     }
3343     DEBC_printk(STp, "Sending FORMAT MEDIUM\n");
3344     SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3345                timeout, MAX_RETRIES, 1);
3346     if (!SRpnt)
3347         result = STp->buffer->syscall_result;
3348     return result;
3349 }
3350
3351
3352 /* Partition the tape into two partitions if size > 0 or one partition if
3353    size == 0.
3354
3355    The block descriptors are read and written because Sony SDT-7000 does not
3356    work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3357
3358    My HP C1533A drive returns only one partition size field. This is used to
3359    set the size of partition 1. There is no size field for the default partition.
3360    Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3361    used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3362    The following algorithm is used to accommodate both drives: if the number of
3363    partition size fields is greater than the maximum number of additional partitions
3364    in the mode page, the second field is used. Otherwise the first field is used.
3365
3366    For Seagate DDS drives the page length must be 8 when no partitions is defined
3367    and 10 when 1 partition is defined (information from Eric Lee Green). This is
3368    is acceptable also to some other old drives and enforced if the first partition
3369    size field is used for the first additional partition size.
3370
3371    For drives that advertize SCSI-3 or newer, use the SSC-3 methods.
3372  */
3373 static int partition_tape(struct scsi_tape *STp, int size)
3374 {
3375     int result;
3376     int target_partition;
3377     bool scsi3 = STp->device->scsi_level >= SCSI_3, needs_format = false;
3378     int pgo, psd_cnt, psdo;
3379     int psum = PP_MSK_PSUM_MB, units = 0;
3380     unsigned char *bp;
3381
3382     result = read_mode_page(STp, PART_PAGE, 0);
3383     if (result) {
3384         DEBC_printk(STp, "Can't read partition mode page.\n");
3385         return result;
3386     }
3387     target_partition = 1;
3388     if (size < 0) {
3389         target_partition = 0;
3390         size = -size;
3391     }
3392
3393     /* The mode page is in the buffer. Let's modify it and write it. */
3394     bp = (STp->buffer)->b_data;
3395     pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3396     DEBC_printk(STp, "Partition page length is %d bytes.\n",
3397             bp[pgo + MP_OFF_PAGE_LENGTH] + 2);
3398
3399     psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3400
3401     if (scsi3) {
3402         needs_format = (bp[pgo + PP_OFF_FLAGS] & PP_MSK_POFM) != 0;
3403         if (needs_format && size == 0) {
3404             /* No need to write the mode page when clearing
3405              *  partitioning
3406              */
3407             DEBC_printk(STp, "Formatting tape with one partition.\n");
3408             result = format_medium(STp, 0);
3409             goto out;
3410         }
3411         if (needs_format)  /* Leave the old value for HP DATs claiming SCSI_3 */
3412             psd_cnt = 2;
3413         if ((bp[pgo + PP_OFF_FLAGS] & PP_MSK_PSUM_UNITS) == PP_MSK_PSUM_UNITS) {
3414             /* Use units scaling for large partitions if the device
3415              * suggests it and no precision lost. Required for IBM
3416              * TS1140/50 drives that don't support MB units.
3417              */
3418             if (size >= 1000 && (size % 1000) == 0) {
3419                 size /= 1000;
3420                 psum = PP_MSK_PSUM_UNITS;
3421                 units = 9; /* GB */
3422             }
3423         }
3424         /* Try it anyway if too large to specify in MB */
3425         if (psum == PP_MSK_PSUM_MB && size >= 65534) {
3426             size /= 1000;
3427             psum = PP_MSK_PSUM_UNITS;
3428             units = 9;  /* GB */
3429         }
3430     }
3431
3432     if (size >= 65535 ||  /* Does not fit into two bytes */
3433         (target_partition == 0 && psd_cnt < 2)) {
3434         result = -EINVAL;
3435         goto out;
3436     }
3437
3438     psdo = pgo + PART_PAGE_FIXED_LENGTH;
3439     /* The second condition is for HP DDS which use only one partition size
3440      * descriptor
3441      */
3442     if (target_partition > 0 &&
3443         (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS] ||
3444          bp[pgo + PP_OFF_MAX_ADD_PARTS] != 1)) {
3445         bp[psdo] = bp[psdo + 1] = 0xff;  /* Rest to partition 0 */
3446         psdo += 2;
3447     }
3448     memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3449
3450     DEBC_printk(STp, "psd_cnt %d, max.parts %d, nbr_parts %d\n",
3451             psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3452             bp[pgo + PP_OFF_NBR_ADD_PARTS]);
3453
3454     if (size == 0) {
3455         bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3456         if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3457             bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3458         DEBC_printk(STp, "Formatting tape with one partition.\n");
3459     } else {
3460         bp[psdo] = (size >> 8) & 0xff;
3461         bp[psdo + 1] = size & 0xff;
3462         if (target_partition == 0)
3463             bp[psdo + 2] = bp[psdo + 3] = 0xff;
3464         bp[pgo + 3] = 1;
3465         if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3466             bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3467         DEBC_printk(STp,
3468                 "Formatting tape with two partitions (%i = %d MB).\n",
3469                 target_partition, units > 0 ? size * 1000 : size);
3470     }
3471     bp[pgo + PP_OFF_PART_UNITS] = 0;
3472     bp[pgo + PP_OFF_RESERVED] = 0;
3473     if (size != 1 || units != 0) {
3474         bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | psum |
3475             (bp[pgo + PP_OFF_FLAGS] & 0x07);
3476         bp[pgo + PP_OFF_PART_UNITS] = units;
3477     } else
3478         bp[pgo + PP_OFF_FLAGS] = PP_BIT_FDP |
3479             (bp[pgo + PP_OFF_FLAGS] & 0x1f);
3480     bp[pgo + MP_OFF_PAGE_LENGTH] = 6 + psd_cnt * 2;
3481
3482     result = write_mode_page(STp, PART_PAGE, 1);
3483
3484     if (!result && needs_format)
3485         result = format_medium(STp, 1);
3486
3487     if (result) {
3488         st_printk(KERN_INFO, STp, "Partitioning of tape failed.\n");
3489         result = (-EIO);
3490     }
3491
3492 out:
3493     return result;
3494 }
3495
3496
3497
3498 /* The ioctl command */
3499 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3500 {
3501     void __user *p = (void __user *)arg;
3502     int i, cmd_nr, cmd_type, bt;
3503     int retval = 0;
3504     unsigned int blk;
3505     struct scsi_tape *STp = file->private_data;
3506     struct st_modedef *STm;
3507     struct st_partstat *STps;
3508
3509     if (mutex_lock_interruptible(&STp->lock))
3510         return -ERESTARTSYS;
3511
3512     DEB(
3513     if (debugging && !STp->in_use) {
3514         st_printk(ST_DEB_MSG, STp, "Incorrect device.\n");
3515         retval = (-EIO);
3516         goto out;
3517     } ) /* end DEB */
3518
3519     STm = &(STp->modes[STp->current_mode]);
3520     STps = &(STp->ps[STp->partition]);
3521
3522     /*
3523      * If we are in the middle of error recovery, don't let anyone
3524      * else try and use this device.  Also, if error recovery fails, it
3525      * may try and take the device offline, in which case all further
3526      * access to the device is prohibited.
3527      */
3528     retval = scsi_ioctl_block_when_processing_errors(STp->device, cmd_in,
3529             file->f_flags & O_NDELAY);
3530     if (retval)
3531         goto out;
3532
3533     cmd_type = _IOC_TYPE(cmd_in);
3534     cmd_nr = _IOC_NR(cmd_in);
3535
3536     if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3537         struct mtop mtc;
3538
3539         if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3540             retval = (-EINVAL);
3541             goto out;
3542         }
3543
3544         i = copy_from_user(&mtc, p, sizeof(struct mtop));
3545         if (i) {
3546             retval = (-EFAULT);
3547             goto out;
3548         }
3549
3550         if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3551             st_printk(KERN_WARNING, STp,
3552                   "MTSETDRVBUFFER only allowed for root.\n");
3553             retval = (-EPERM);
3554             goto out;
3555         }
3556         if (!STm->defined &&
3557             (mtc.mt_op != MTSETDRVBUFFER &&
3558              (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3559             retval = (-ENXIO);
3560             goto out;
3561         }
3562
3563         if (!STp->pos_unknown) {
3564
3565             if (STps->eof == ST_FM_HIT) {
3566                 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3567                                     mtc.mt_op == MTEOM) {
3568                     mtc.mt_count -= 1;
3569                     if (STps->drv_file >= 0)
3570                         STps->drv_file += 1;
3571                 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3572                     mtc.mt_count += 1;
3573                     if (STps->drv_file >= 0)
3574                         STps->drv_file += 1;
3575                 }
3576             }
3577
3578             if (mtc.mt_op == MTSEEK) {
3579                 /* Old position must be restored if partition will be
3580                                    changed */
3581                 i = !STp->can_partitions ||
3582                     (STp->new_partition != STp->partition);
3583             } else {
3584                 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3585                     mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3586                     mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3587                     mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3588                     mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3589                     mtc.mt_op == MTCOMPRESSION;
3590             }
3591             i = flush_buffer(STp, i);
3592             if (i < 0) {
3593                 retval = i;
3594                 goto out;
3595             }
3596             if (STps->rw == ST_WRITING &&
3597                 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3598                  mtc.mt_op == MTSEEK ||
3599                  mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3600                 i = st_int_ioctl(STp, MTWEOF, 1);
3601                 if (i < 0) {
3602                     retval = i;
3603                     goto out;
3604                 }
3605                 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3606                     mtc.mt_count++;
3607                 STps->rw = ST_IDLE;
3608                  }
3609
3610         } else {
3611             /*
3612              * If there was a bus reset, block further access
3613              * to this device.  If the user wants to rewind the tape,
3614              * then reset the flag and allow access again.
3615              */
3616             if (mtc.mt_op != MTREW &&
3617                 mtc.mt_op != MTOFFL &&
3618                 mtc.mt_op != MTRETEN &&
3619                 mtc.mt_op != MTERASE &&
3620                 mtc.mt_op != MTSEEK &&
3621                 mtc.mt_op != MTEOM) {
3622                 retval = (-EIO);
3623                 goto out;
3624             }
3625             reset_state(STp);
3626             /* remove this when the midlevel properly clears was_reset */
3627             STp->device->was_reset = 0;
3628         }
3629
3630         if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3631             mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3632             mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3633             STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3634
3635         if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3636             do_door_lock(STp, 0);   /* Ignore result! */
3637
3638         if (mtc.mt_op == MTSETDRVBUFFER &&
3639             (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3640             retval = st_set_options(STp, mtc.mt_count);
3641             goto out;
3642         }
3643
3644         if (mtc.mt_op == MTSETPART) {
3645             if (!STp->can_partitions ||
3646                 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3647                 retval = (-EINVAL);
3648                 goto out;
3649             }
3650             if (mtc.mt_count >= STp->nbr_partitions &&
3651                 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3652                 retval = (-EIO);
3653                 goto out;
3654             }
3655             if (mtc.mt_count >= STp->nbr_partitions) {
3656                 retval = (-EINVAL);
3657                 goto out;
3658             }
3659             STp->new_partition = mtc.mt_count;
3660             retval = 0;
3661             goto out;
3662         }
3663
3664         if (mtc.mt_op == MTMKPART) {
3665             if (!STp->can_partitions) {
3666                 retval = (-EINVAL);
3667                 goto out;
3668             }
3669             i = do_load_unload(STp, file, 1);
3670             if (i < 0) {
3671                 retval = i;
3672                 goto out;
3673             }
3674             i = partition_tape(STp, mtc.mt_count);
3675             if (i < 0) {
3676                 retval = i;
3677                 goto out;
3678             }
3679             for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3680                 STp->ps[i].rw = ST_IDLE;
3681                 STp->ps[i].at_sm = 0;
3682                 STp->ps[i].last_block_valid = 0;
3683             }
3684             STp->partition = STp->new_partition = 0;
3685             STp->nbr_partitions = mtc.mt_count != 0 ? 2 : 1;
3686             STps->drv_block = STps->drv_file = 0;
3687             retval = 0;
3688             goto out;
3689         }
3690
3691         if (mtc.mt_op == MTSEEK) {
3692             i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3693             if (!STp->can_partitions)
3694                 STp->ps[0].rw = ST_IDLE;
3695             retval = i;
3696             goto out;
3697         }
3698
3699         if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3700             retval = do_load_unload(STp, file, 0);
3701             goto out;
3702         }
3703
3704         if (mtc.mt_op == MTLOAD) {
3705             retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3706             goto out;
3707         }
3708
3709         if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3710             retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3711             goto out;
3712         }
3713
3714         if (STp->can_partitions && STp->ready == ST_READY &&
3715             (i = switch_partition(STp)) < 0) {
3716             retval = i;
3717             goto out;
3718         }
3719
3720         if (mtc.mt_op == MTCOMPRESSION)
3721             retval = st_compression(STp, (mtc.mt_count & 1));
3722         else
3723             retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3724         goto out;
3725     }
3726     if (!STm->defined) {
3727         retval = (-ENXIO);
3728         goto out;
3729     }
3730
3731     if ((i = flush_buffer(STp, 0)) < 0) {
3732         retval = i;
3733         goto out;
3734     }
3735     if (STp->can_partitions &&
3736         (i = switch_partition(STp)) < 0) {
3737         retval = i;
3738         goto out;
3739     }
3740
3741     if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3742         struct mtget mt_status;
3743
3744         if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3745              retval = (-EINVAL);
3746              goto out;
3747         }
3748
3749         mt_status.mt_type = STp->tape_type;
3750         mt_status.mt_dsreg =
3751             ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3752             ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3753         mt_status.mt_blkno = STps->drv_block;
3754         mt_status.mt_fileno = STps->drv_file;
3755         if (STp->block_size != 0) {
3756             if (STps->rw == ST_WRITING)
3757                 mt_status.mt_blkno +=
3758                     (STp->buffer)->buffer_bytes / STp->block_size;
3759             else if (STps->rw == ST_READING)
3760                 mt_status.mt_blkno -=
3761                                         ((STp->buffer)->buffer_bytes +
3762                                          STp->block_size - 1) / STp->block_size;
3763         }
3764
3765         mt_status.mt_gstat = 0;
3766         if (STp->drv_write_prot)
3767             mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3768         if (mt_status.mt_blkno == 0) {
3769             if (mt_status.mt_fileno == 0)
3770                 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3771             else
3772                 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3773         }
3774         mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3775         mt_status.mt_resid = STp->partition;
3776         if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3777             mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3778         else if (STps->eof >= ST_EOM_OK)
3779             mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3780         if (STp->density == 1)
3781             mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3782         else if (STp->density == 2)
3783             mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3784         else if (STp->density == 3)
3785             mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3786         if (STp->ready == ST_READY)
3787             mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3788         if (STp->ready == ST_NO_TAPE)
3789             mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3790         if (STps->at_sm)
3791             mt_status.mt_gstat |= GMT_SM(0xffffffff);
3792         if (STm->do_async_writes ||
3793                     (STm->do_buffer_writes && STp->block_size != 0) ||
3794             STp->drv_buffer != 0)
3795             mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3796         if (STp->cleaning_req)
3797             mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3798
3799         retval = put_user_mtget(p, &mt_status);
3800         if (retval)
3801             goto out;
3802
3803         STp->recover_reg = 0;       /* Clear after read */
3804         goto out;
3805     }           /* End of MTIOCGET */
3806     if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3807         struct mtpos mt_pos;
3808         if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3809              retval = (-EINVAL);
3810              goto out;
3811         }
3812         if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3813             retval = i;
3814             goto out;
3815         }
3816         mt_pos.mt_blkno = blk;
3817         retval = put_user_mtpos(p, &mt_pos);
3818         goto out;
3819     }
3820     mutex_unlock(&STp->lock);
3821
3822     switch (cmd_in) {
3823     case SG_IO:
3824     case SCSI_IOCTL_SEND_COMMAND:
3825     case CDROM_SEND_PACKET:
3826         if (!capable(CAP_SYS_RAWIO))
3827             return -EPERM;
3828         break;
3829     default:
3830         break;
3831     }
3832
3833     retval = scsi_ioctl(STp->device, file->f_mode, cmd_in, p);
3834     if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) {
3835         /* unload */
3836         STp->rew_at_close = 0;
3837         STp->ready = ST_NO_TAPE;
3838     }
3839     return retval;
3840
3841  out:
3842     mutex_unlock(&STp->lock);
3843     return retval;
3844 }
3845
3846 #ifdef CONFIG_COMPAT
3847 static long st_compat_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3848 {
3849     /* argument conversion is handled using put_user_mtpos/put_user_mtget */
3850     switch (cmd_in) {
3851     case MTIOCPOS32:
3852         cmd_in = MTIOCPOS;
3853         break;
3854     case MTIOCGET32:
3855         cmd_in = MTIOCGET;
3856         break;
3857     }
3858
3859     return st_ioctl(file, cmd_in, arg);
3860 }
3861 #endif
3862
3863
3864
3865 /* Try to allocate a new tape buffer. Calling function must not hold
3866    dev_arr_lock. */
3867 static struct st_buffer *new_tape_buffer(int max_sg)
3868 {
3869     struct st_buffer *tb;
3870
3871     tb = kzalloc(sizeof(struct st_buffer), GFP_KERNEL);
3872     if (!tb) {
3873         printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3874         return NULL;
3875     }
3876     tb->frp_segs = 0;
3877     tb->use_sg = max_sg;
3878     tb->buffer_size = 0;
3879
3880     tb->reserved_pages = kcalloc(max_sg, sizeof(struct page *),
3881                      GFP_KERNEL);
3882     if (!tb->reserved_pages) {
3883         kfree(tb);
3884         return NULL;
3885     }
3886
3887     return tb;
3888 }
3889
3890
3891 /* Try to allocate enough space in the tape buffer */
3892 #define ST_MAX_ORDER 6
3893
3894 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size)
3895 {
3896     int segs, max_segs, b_size, order, got;
3897     gfp_t priority;
3898
3899     if (new_size <= STbuffer->buffer_size)
3900         return 1;
3901
3902     if (STbuffer->buffer_size <= PAGE_SIZE)
3903         normalize_buffer(STbuffer);  /* Avoid extra segment */
3904
3905     max_segs = STbuffer->use_sg;
3906
3907     priority = GFP_KERNEL | __GFP_NOWARN;
3908
3909     if (STbuffer->cleared)
3910         priority |= __GFP_ZERO;
3911
3912     if (STbuffer->frp_segs) {
3913         order = STbuffer->reserved_page_order;
3914         b_size = PAGE_SIZE << order;
3915     } else {
3916         for (b_size = PAGE_SIZE, order = 0;
3917              order < ST_MAX_ORDER &&
3918                  max_segs * (PAGE_SIZE << order) < new_size;
3919              order++, b_size *= 2)
3920             ;  /* empty */
3921         STbuffer->reserved_page_order = order;
3922     }
3923     if (max_segs * (PAGE_SIZE << order) < new_size) {
3924         if (order == ST_MAX_ORDER)
3925             return 0;
3926         normalize_buffer(STbuffer);
3927         return enlarge_buffer(STbuffer, new_size);
3928     }
3929
3930     for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3931          segs < max_segs && got < new_size;) {
3932         struct page *page;
3933
3934         page = alloc_pages(priority, order);
3935         if (!page) {
3936             DEB(STbuffer->buffer_size = got);
3937             normalize_buffer(STbuffer);
3938             return 0;
3939         }
3940
3941         STbuffer->frp_segs += 1;
3942         got += b_size;
3943         STbuffer->buffer_size = got;
3944         STbuffer->reserved_pages[segs] = page;
3945         segs++;
3946     }
3947     STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
3948
3949     return 1;
3950 }
3951
3952
3953 /* Make sure that no data from previous user is in the internal buffer */
3954 static void clear_buffer(struct st_buffer * st_bp)
3955 {
3956     int i;
3957
3958     for (i=0; i < st_bp->frp_segs; i++)
3959         memset(page_address(st_bp->reserved_pages[i]), 0,
3960                PAGE_SIZE << st_bp->reserved_page_order);
3961     st_bp->cleared = 1;
3962 }
3963
3964
3965 /* Release the extra buffer */
3966 static void normalize_buffer(struct st_buffer * STbuffer)
3967 {
3968     int i, order = STbuffer->reserved_page_order;
3969
3970     for (i = 0; i < STbuffer->frp_segs; i++) {
3971         __free_pages(STbuffer->reserved_pages[i], order);
3972         STbuffer->buffer_size -= (PAGE_SIZE << order);
3973     }
3974     STbuffer->frp_segs = 0;
3975     STbuffer->sg_segs = 0;
3976     STbuffer->reserved_page_order = 0;
3977     STbuffer->map_data.offset = 0;
3978 }
3979
3980
3981 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3982    negative error code. */
3983 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3984 {
3985     int i, cnt, res, offset;
3986     int length = PAGE_SIZE << st_bp->reserved_page_order;
3987
3988     for (i = 0, offset = st_bp->buffer_bytes;
3989          i < st_bp->frp_segs && offset >= length; i++)
3990         offset -= length;
3991     if (i == st_bp->frp_segs) { /* Should never happen */
3992         printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3993         return (-EIO);
3994     }
3995     for (; i < st_bp->frp_segs && do_count > 0; i++) {
3996         struct page *page = st_bp->reserved_pages[i];
3997         cnt = length - offset < do_count ? length - offset : do_count;
3998         res = copy_from_user(page_address(page) + offset, ubp, cnt);
3999         if (res)
4000             return (-EFAULT);
4001         do_count -= cnt;
4002         st_bp->buffer_bytes += cnt;
4003         ubp += cnt;
4004         offset = 0;
4005     }
4006     if (do_count) /* Should never happen */
4007         return (-EIO);
4008
4009     return 0;
4010 }
4011
4012
4013 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
4014    negative error code. */
4015 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
4016 {
4017     int i, cnt, res, offset;
4018     int length = PAGE_SIZE << st_bp->reserved_page_order;
4019
4020     for (i = 0, offset = st_bp->read_pointer;
4021          i < st_bp->frp_segs && offset >= length; i++)
4022         offset -= length;
4023     if (i == st_bp->frp_segs) { /* Should never happen */
4024         printk(KERN_WARNING "st: from_buffer offset overflow.\n");
4025         return (-EIO);
4026     }
4027     for (; i < st_bp->frp_segs && do_count > 0; i++) {
4028         struct page *page = st_bp->reserved_pages[i];
4029         cnt = length - offset < do_count ? length - offset : do_count;
4030         res = copy_to_user(ubp, page_address(page) + offset, cnt);
4031         if (res)
4032             return (-EFAULT);
4033         do_count -= cnt;
4034         st_bp->buffer_bytes -= cnt;
4035         st_bp->read_pointer += cnt;
4036         ubp += cnt;
4037         offset = 0;
4038     }
4039     if (do_count) /* Should never happen */
4040         return (-EIO);
4041
4042     return 0;
4043 }
4044
4045
4046 /* Move data towards start of buffer */
4047 static void move_buffer_data(struct st_buffer * st_bp, int offset)
4048 {
4049     int src_seg, dst_seg, src_offset = 0, dst_offset;
4050     int count, total;
4051     int length = PAGE_SIZE << st_bp->reserved_page_order;
4052
4053     if (offset == 0)
4054         return;
4055
4056     total=st_bp->buffer_bytes - offset;
4057     for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
4058         src_offset = offset;
4059         if (src_offset < length)
4060             break;
4061         offset -= length;
4062     }
4063
4064     st_bp->buffer_bytes = st_bp->read_pointer = total;
4065     for (dst_seg=dst_offset=0; total > 0; ) {
4066         struct page *dpage = st_bp->reserved_pages[dst_seg];
4067         struct page *spage = st_bp->reserved_pages[src_seg];
4068
4069         count = min(length - dst_offset, length - src_offset);
4070         memmove(page_address(dpage) + dst_offset,
4071             page_address(spage) + src_offset, count);
4072         src_offset += count;
4073         if (src_offset >= length) {
4074             src_seg++;
4075             src_offset = 0;
4076         }
4077         dst_offset += count;
4078         if (dst_offset >= length) {
4079             dst_seg++;
4080             dst_offset = 0;
4081         }
4082         total -= count;
4083     }
4084 }
4085
4086 /* Validate the options from command line or module parameters */
4087 static void validate_options(void)
4088 {
4089     if (buffer_kbs > 0)
4090         st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
4091     if (max_sg_segs >= ST_FIRST_SG)
4092         st_max_sg_segs = max_sg_segs;
4093 }
4094
4095 #ifndef MODULE
4096 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
4097  */
4098 static int __init st_setup(char *str)
4099 {
4100     int i, len, ints[5];
4101     char *stp;
4102
4103     stp = get_options(str, ARRAY_SIZE(ints), ints);
4104
4105     if (ints[0] > 0) {
4106         for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
4107             if (parms[i].val)
4108                 *parms[i].val = ints[i + 1];
4109     } else {
4110         while (stp != NULL) {
4111             for (i = 0; i < ARRAY_SIZE(parms); i++) {
4112                 len = strlen(parms[i].name);
4113                 if (!strncmp(stp, parms[i].name, len) &&
4114                     (*(stp + len) == ':' || *(stp + len) == '=')) {
4115                     if (parms[i].val)
4116                         *parms[i].val =
4117                             simple_strtoul(stp + len + 1, NULL, 0);
4118                     else
4119                         printk(KERN_WARNING "st: Obsolete parameter %s\n",
4120                                parms[i].name);
4121                     break;
4122                 }
4123             }
4124             if (i >= ARRAY_SIZE(parms))
4125                  printk(KERN_WARNING "st: invalid parameter in '%s'\n",
4126                     stp);
4127             stp = strchr(stp, ',');
4128             if (stp)
4129                 stp++;
4130         }
4131     }
4132
4133     validate_options();
4134
4135     return 1;
4136 }
4137
4138 __setup("st=", st_setup);
4139
4140 #endif
4141
4142 static const struct file_operations st_fops =
4143 {
4144     .owner =    THIS_MODULE,
4145     .read =     st_read,
4146     .write =    st_write,
4147     .unlocked_ioctl = st_ioctl,
4148 #ifdef CONFIG_COMPAT
4149     .compat_ioctl = st_compat_ioctl,
4150 #endif
4151     .open =     st_open,
4152     .flush =    st_flush,
4153     .release =  st_release,
4154     .llseek =   noop_llseek,
4155 };
4156
4157 static int create_one_cdev(struct scsi_tape *tape, int mode, int rew)
4158 {
4159     int i, error;
4160     dev_t cdev_devno;
4161     struct cdev *cdev;
4162     struct device *dev;
4163     struct st_modedef *STm = &(tape->modes[mode]);
4164     char name[10];
4165     int dev_num = tape->index;
4166
4167     cdev_devno = MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, rew));
4168
4169     cdev = cdev_alloc();
4170     if (!cdev) {
4171         pr_err("st%d: out of memory. Device not attached.\n", dev_num);
4172         error = -ENOMEM;
4173         goto out;
4174     }
4175     cdev->owner = THIS_MODULE;
4176     cdev->ops = &st_fops;
4177     STm->cdevs[rew] = cdev;
4178
4179     error = cdev_add(cdev, cdev_devno, 1);
4180     if (error) {
4181         pr_err("st%d: Can't add %s-rewind mode %d\n", dev_num,
4182                rew ? "non" : "auto", mode);
4183         pr_err("st%d: Device not attached.\n", dev_num);
4184         goto out_free;
4185     }
4186
4187     i = mode << (4 - ST_NBR_MODE_BITS);
4188     snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4189          tape->name, st_formats[i]);
4190
4191     dev = device_create(&st_sysfs_class, &tape->device->sdev_gendev,
4192                 cdev_devno, &tape->modes[mode], "%s", name);
4193     if (IS_ERR(dev)) {
4194         pr_err("st%d: device_create failed\n", dev_num);
4195         error = PTR_ERR(dev);
4196         goto out_free;
4197     }
4198
4199     STm->devs[rew] = dev;
4200
4201     return 0;
4202 out_free:
4203     cdev_del(STm->cdevs[rew]);
4204 out:
4205     STm->cdevs[rew] = NULL;
4206     STm->devs[rew] = NULL;
4207     return error;
4208 }
4209
4210 static int create_cdevs(struct scsi_tape *tape)
4211 {
4212     int mode, error;
4213     for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4214         error = create_one_cdev(tape, mode, 0);
4215         if (error)
4216             return error;
4217         error = create_one_cdev(tape, mode, 1);
4218         if (error)
4219             return error;
4220     }
4221
4222     return sysfs_create_link(&tape->device->sdev_gendev.kobj,
4223                  &tape->modes[0].devs[0]->kobj, "tape");
4224 }
4225
4226 static void remove_cdevs(struct scsi_tape *tape)
4227 {
4228     int mode, rew;
4229     sysfs_remove_link(&tape->device->sdev_gendev.kobj, "tape");
4230     for (mode = 0; mode < ST_NBR_MODES; mode++) {
4231         struct st_modedef *STm = &(tape->modes[mode]);
4232         for (rew = 0; rew < 2; rew++) {
4233             if (STm->cdevs[rew])
4234                 cdev_del(STm->cdevs[rew]);
4235             if (STm->devs[rew])
4236                 device_unregister(STm->devs[rew]);
4237         }
4238     }
4239 }
4240
4241 static int st_probe(struct device *dev)
4242 {
4243     struct scsi_device *SDp = to_scsi_device(dev);
4244     struct scsi_tape *tpnt = NULL;
4245     struct st_modedef *STm;
4246     struct st_partstat *STps;
4247     struct st_buffer *buffer;
4248     int i, error;
4249     char *stp;
4250
4251     if (SDp->type != TYPE_TAPE)
4252         return -ENODEV;
4253     if ((stp = st_incompatible(SDp))) {
4254         sdev_printk(KERN_INFO, SDp,
4255                 "OnStream tapes are no longer supported;\n");
4256         sdev_printk(KERN_INFO, SDp,
4257                 "please mail to linux-scsi@vger.kernel.org.\n");
4258         return -ENODEV;
4259     }
4260
4261     scsi_autopm_get_device(SDp);
4262     i = queue_max_segments(SDp->request_queue);
4263     if (st_max_sg_segs < i)
4264         i = st_max_sg_segs;
4265     buffer = new_tape_buffer(i);
4266     if (buffer == NULL) {
4267         sdev_printk(KERN_ERR, SDp,
4268                 "st: Can't allocate new tape buffer. "
4269                 "Device not attached.\n");
4270         goto out;
4271     }
4272
4273     tpnt = kzalloc(sizeof(struct scsi_tape), GFP_KERNEL);
4274     if (tpnt == NULL) {
4275         sdev_printk(KERN_ERR, SDp,
4276                 "st: Can't allocate device descriptor.\n");
4277         goto out_buffer_free;
4278     }
4279     kref_init(&tpnt->kref);
4280
4281     tpnt->device = SDp;
4282     if (SDp->scsi_level <= 2)
4283         tpnt->tape_type = MT_ISSCSI1;
4284     else
4285         tpnt->tape_type = MT_ISSCSI2;
4286
4287     tpnt->buffer = buffer;
4288     tpnt->buffer->last_SRpnt = NULL;
4289
4290     tpnt->inited = 0;
4291     tpnt->dirty = 0;
4292     tpnt->in_use = 0;
4293     tpnt->drv_buffer = 1;   /* Try buffering if no mode sense */
4294     tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4295     tpnt->density = 0;
4296     tpnt->do_auto_lock = ST_AUTO_LOCK;
4297     tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4298     tpnt->can_partitions = 0;
4299     tpnt->two_fm = ST_TWO_FM;
4300     tpnt->fast_mteom = ST_FAST_MTEOM;
4301     tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4302     tpnt->sili = ST_SILI;
4303     tpnt->immediate = ST_NOWAIT;
4304     tpnt->immediate_filemark = 0;
4305     tpnt->default_drvbuffer = 0xff;     /* No forced buffering */
4306     tpnt->partition = 0;
4307     tpnt->new_partition = 0;
4308     tpnt->nbr_partitions = 0;
4309     blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
4310     tpnt->long_timeout = ST_LONG_TIMEOUT;
4311     tpnt->try_dio = try_direct_io;
4312
4313     for (i = 0; i < ST_NBR_MODES; i++) {
4314         STm = &(tpnt->modes[i]);
4315         STm->defined = 0;
4316         STm->sysv = ST_SYSV;
4317         STm->defaults_for_writes = 0;
4318         STm->do_async_writes = ST_ASYNC_WRITES;
4319         STm->do_buffer_writes = ST_BUFFER_WRITES;
4320         STm->do_read_ahead = ST_READ_AHEAD;
4321         STm->default_compression = ST_DONT_TOUCH;
4322         STm->default_blksize = (-1);    /* No forced size */
4323         STm->default_density = (-1);    /* No forced density */
4324         STm->tape = tpnt;
4325     }
4326
4327     for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4328         STps = &(tpnt->ps[i]);
4329         STps->rw = ST_IDLE;
4330         STps->eof = ST_NOEOF;
4331         STps->at_sm = 0;
4332         STps->last_block_valid = 0;
4333         STps->drv_block = (-1);
4334         STps->drv_file = (-1);
4335     }
4336
4337     tpnt->current_mode = 0;
4338     tpnt->modes[0].defined = 1;
4339
4340     tpnt->density_changed = tpnt->compression_changed =
4341         tpnt->blksize_changed = 0;
4342     mutex_init(&tpnt->lock);
4343
4344     idr_preload(GFP_KERNEL);
4345     spin_lock(&st_index_lock);
4346     error = idr_alloc(&st_index_idr, tpnt, 0, ST_MAX_TAPES + 1, GFP_NOWAIT);
4347     spin_unlock(&st_index_lock);
4348     idr_preload_end();
4349     if (error < 0) {
4350         pr_warn("st: idr allocation failed: %d\n", error);
4351         goto out_free_tape;
4352     }
4353     tpnt->index = error;
4354     sprintf(tpnt->name, "st%d", tpnt->index);
4355     tpnt->stats = kzalloc(sizeof(struct scsi_tape_stats), GFP_KERNEL);
4356     if (tpnt->stats == NULL) {
4357         sdev_printk(KERN_ERR, SDp,
4358                 "st: Can't allocate statistics.\n");
4359         goto out_idr_remove;
4360     }
4361
4362     dev_set_drvdata(dev, tpnt);
4363
4364
4365     error = create_cdevs(tpnt);
4366     if (error)
4367         goto out_remove_devs;
4368     scsi_autopm_put_device(SDp);
4369
4370     sdev_printk(KERN_NOTICE, SDp,
4371             "Attached scsi tape %s\n", tpnt->name);
4372     sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4373             tpnt->name, tpnt->try_dio ? "yes" : "no",
4374             queue_dma_alignment(SDp->request_queue) + 1);
4375
4376     return 0;
4377
4378 out_remove_devs:
4379     remove_cdevs(tpnt);
4380     kfree(tpnt->stats);
4381 out_idr_remove:
4382     spin_lock(&st_index_lock);
4383     idr_remove(&st_index_idr, tpnt->index);
4384     spin_unlock(&st_index_lock);
4385 out_free_tape:
4386     kfree(tpnt);
4387 out_buffer_free:
4388     kfree(buffer);
4389 out:
4390     scsi_autopm_put_device(SDp);
4391     return -ENODEV;
4392 };
4393
4394
4395 static int st_remove(struct device *dev)
4396 {
4397     struct scsi_tape *tpnt = dev_get_drvdata(dev);
4398     int index = tpnt->index;
4399
4400     scsi_autopm_get_device(to_scsi_device(dev));
4401     remove_cdevs(tpnt);
4402
4403     mutex_lock(&st_ref_mutex);
4404     kref_put(&tpnt->kref, scsi_tape_release);
4405     mutex_unlock(&st_ref_mutex);
4406     spin_lock(&st_index_lock);
4407     idr_remove(&st_index_idr, index);
4408     spin_unlock(&st_index_lock);
4409     return 0;
4410 }
4411
4412 /**
4413  *      scsi_tape_release - Called to free the Scsi_Tape structure
4414  *      @kref: pointer to embedded kref
4415  *
4416  *      st_ref_mutex must be held entering this routine.  Because it is
4417  *      called on last put, you should always use the scsi_tape_get()
4418  *      scsi_tape_put() helpers which manipulate the semaphore directly
4419  *      and never do a direct kref_put().
4420  **/
4421 static void scsi_tape_release(struct kref *kref)
4422 {
4423     struct scsi_tape *tpnt = to_scsi_tape(kref);
4424
4425     tpnt->device = NULL;
4426
4427     if (tpnt->buffer) {
4428         normalize_buffer(tpnt->buffer);
4429         kfree(tpnt->buffer->reserved_pages);
4430         kfree(tpnt->buffer);
4431     }
4432
4433     kfree(tpnt->stats);
4434     kfree(tpnt);
4435     return;
4436 }
4437
4438 static struct class st_sysfs_class = {
4439     .name = "scsi_tape",
4440     .dev_groups = st_dev_groups,
4441 };
4442
4443 static int __init init_st(void)
4444 {
4445     int err;
4446
4447     validate_options();
4448
4449     printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4450         verstr, st_fixed_buffer_size, st_max_sg_segs);
4451
4452     debugging = (debug_flag > 0) ? debug_flag : NO_DEBUG;
4453     if (debugging) {
4454         printk(KERN_INFO "st: Debugging enabled debug_flag = %d\n",
4455             debugging);
4456     }
4457
4458     err = class_register(&st_sysfs_class);
4459     if (err) {
4460         pr_err("Unable register sysfs class for SCSI tapes\n");
4461         return err;
4462     }
4463
4464     err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4465                      ST_MAX_TAPE_ENTRIES, "st");
4466     if (err) {
4467         printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4468                SCSI_TAPE_MAJOR);
4469         goto err_class;
4470     }
4471
4472     err = scsi_register_driver(&st_template.gendrv);
4473     if (err)
4474         goto err_chrdev;
4475
4476     return 0;
4477
4478 err_chrdev:
4479     unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4480                  ST_MAX_TAPE_ENTRIES);
4481 err_class:
4482     class_unregister(&st_sysfs_class);
4483     return err;
4484 }
4485
4486 static void __exit exit_st(void)
4487 {
4488     scsi_unregister_driver(&st_template.gendrv);
4489     unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4490                  ST_MAX_TAPE_ENTRIES);
4491     class_unregister(&st_sysfs_class);
4492     idr_destroy(&st_index_idr);
4493     printk(KERN_INFO "st: Unloaded.\n");
4494 }
4495
4496 module_init(init_st);
4497 module_exit(exit_st);
4498
4499
4500 /* The sysfs driver interface. Read-only at the moment */
4501 static ssize_t try_direct_io_show(struct device_driver *ddp, char *buf)
4502 {
4503     return scnprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4504 }
4505 static DRIVER_ATTR_RO(try_direct_io);
4506
4507 static ssize_t fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4508 {
4509     return scnprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4510 }
4511 static DRIVER_ATTR_RO(fixed_buffer_size);
4512
4513 static ssize_t max_sg_segs_show(struct device_driver *ddp, char *buf)
4514 {
4515     return scnprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4516 }
4517 static DRIVER_ATTR_RO(max_sg_segs);
4518
4519 static ssize_t version_show(struct device_driver *ddd, char *buf)
4520 {
4521     return scnprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4522 }
4523 static DRIVER_ATTR_RO(version);
4524
4525 #if DEBUG
4526 static ssize_t debug_flag_store(struct device_driver *ddp,
4527     const char *buf, size_t count)
4528 {
4529 /* We only care what the first byte of the data is the rest is unused.
4530  * if it's a '1' we turn on debug and if it's a '0' we disable it. All
4531  * other values have -EINVAL returned if they are passed in.
4532  */
4533     if (count > 0) {
4534         if (buf[0] == '0') {
4535             debugging = NO_DEBUG;
4536             return count;
4537         } else if (buf[0] == '1') {
4538             debugging = 1;
4539             return count;
4540         }
4541     }
4542     return -EINVAL;
4543 }
4544
4545 static ssize_t debug_flag_show(struct device_driver *ddp, char *buf)
4546 {
4547     return scnprintf(buf, PAGE_SIZE, "%d\n", debugging);
4548 }
4549 static DRIVER_ATTR_RW(debug_flag);
4550 #endif
4551
4552 static struct attribute *st_drv_attrs[] = {
4553     &driver_attr_try_direct_io.attr,
4554     &driver_attr_fixed_buffer_size.attr,
4555     &driver_attr_max_sg_segs.attr,
4556     &driver_attr_version.attr,
4557 #if DEBUG
4558     &driver_attr_debug_flag.attr,
4559 #endif
4560     NULL,
4561 };
4562 ATTRIBUTE_GROUPS(st_drv);
4563
4564 /* The sysfs simple class interface */
4565 static ssize_t
4566 defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4567 {
4568     struct st_modedef *STm = dev_get_drvdata(dev);
4569     ssize_t l = 0;
4570
4571     l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4572     return l;
4573 }
4574 static DEVICE_ATTR_RO(defined);
4575
4576 static ssize_t
4577 default_blksize_show(struct device *dev, struct device_attribute *attr,
4578              char *buf)
4579 {
4580     struct st_modedef *STm = dev_get_drvdata(dev);
4581     ssize_t l = 0;
4582
4583     l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4584     return l;
4585 }
4586 static DEVICE_ATTR_RO(default_blksize);
4587
4588 static ssize_t
4589 default_density_show(struct device *dev, struct device_attribute *attr,
4590              char *buf)
4591 {
4592     struct st_modedef *STm = dev_get_drvdata(dev);
4593     ssize_t l = 0;
4594     char *fmt;
4595
4596     fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4597     l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4598     return l;
4599 }
4600 static DEVICE_ATTR_RO(default_density);
4601
4602 static ssize_t
4603 default_compression_show(struct device *dev, struct device_attribute *attr,
4604              char *buf)
4605 {
4606     struct st_modedef *STm = dev_get_drvdata(dev);
4607     ssize_t l = 0;
4608
4609     l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4610     return l;
4611 }
4612 static DEVICE_ATTR_RO(default_compression);
4613
4614 static ssize_t
4615 options_show(struct device *dev, struct device_attribute *attr, char *buf)
4616 {
4617     struct st_modedef *STm = dev_get_drvdata(dev);
4618     struct scsi_tape *STp = STm->tape;
4619     int options;
4620     ssize_t l = 0;
4621
4622     options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4623     options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4624     options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4625     DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4626     options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4627     options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4628     options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4629     options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4630     options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4631     options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4632     options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4633     options |= STm->sysv ? MT_ST_SYSV : 0;
4634     options |= STp->immediate ? MT_ST_NOWAIT : 0;
4635     options |= STp->immediate_filemark ? MT_ST_NOWAIT_EOF : 0;
4636     options |= STp->sili ? MT_ST_SILI : 0;
4637
4638     l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4639     return l;
4640 }
4641 static DEVICE_ATTR_RO(options);
4642
4643 /* Support for tape stats */
4644
4645 /**
4646  * read_cnt_show - return read count - count of reads made from tape drive
4647  * @dev: struct device
4648  * @attr: attribute structure
4649  * @buf: buffer to return formatted data in
4650  */
4651 static ssize_t read_cnt_show(struct device *dev,
4652     struct device_attribute *attr, char *buf)
4653 {
4654     struct st_modedef *STm = dev_get_drvdata(dev);
4655
4656     return sprintf(buf, "%lld",
4657                (long long)atomic64_read(&STm->tape->stats->read_cnt));
4658 }
4659 static DEVICE_ATTR_RO(read_cnt);
4660
4661 /**
4662  * read_byte_cnt_show - return read byte count - tape drives
4663  * may use blocks less than 512 bytes this gives the raw byte count of
4664  * of data read from the tape drive.
4665  * @dev: struct device
4666  * @attr: attribute structure
4667  * @buf: buffer to return formatted data in
4668  */
4669 static ssize_t read_byte_cnt_show(struct device *dev,
4670     struct device_attribute *attr, char *buf)
4671 {
4672     struct st_modedef *STm = dev_get_drvdata(dev);
4673
4674     return sprintf(buf, "%lld",
4675                (long long)atomic64_read(&STm->tape->stats->read_byte_cnt));
4676 }
4677 static DEVICE_ATTR_RO(read_byte_cnt);
4678
4679 /**
4680  * read_ns_show - return read ns - overall time spent waiting on reads in ns.
4681  * @dev: struct device
4682  * @attr: attribute structure
4683  * @buf: buffer to return formatted data in
4684  */
4685 static ssize_t read_ns_show(struct device *dev,
4686     struct device_attribute *attr, char *buf)
4687 {
4688     struct st_modedef *STm = dev_get_drvdata(dev);
4689
4690     return sprintf(buf, "%lld",
4691                (long long)atomic64_read(&STm->tape->stats->tot_read_time));
4692 }
4693 static DEVICE_ATTR_RO(read_ns);
4694
4695 /**
4696  * write_cnt_show - write count - number of user calls
4697  * to write(2) that have written data to tape.
4698  * @dev: struct device
4699  * @attr: attribute structure
4700  * @buf: buffer to return formatted data in
4701  */
4702 static ssize_t write_cnt_show(struct device *dev,
4703     struct device_attribute *attr, char *buf)
4704 {
4705     struct st_modedef *STm = dev_get_drvdata(dev);
4706
4707     return sprintf(buf, "%lld",
4708                (long long)atomic64_read(&STm->tape->stats->write_cnt));
4709 }
4710 static DEVICE_ATTR_RO(write_cnt);
4711
4712 /**
4713  * write_byte_cnt_show - write byte count - raw count of
4714  * bytes written to tape.
4715  * @dev: struct device
4716  * @attr: attribute structure
4717  * @buf: buffer to return formatted data in
4718  */
4719 static ssize_t write_byte_cnt_show(struct device *dev,
4720     struct device_attribute *attr, char *buf)
4721 {
4722     struct st_modedef *STm = dev_get_drvdata(dev);
4723
4724     return sprintf(buf, "%lld",
4725                (long long)atomic64_read(&STm->tape->stats->write_byte_cnt));
4726 }
4727 static DEVICE_ATTR_RO(write_byte_cnt);
4728
4729 /**
4730  * write_ns_show - write ns - number of nanoseconds waiting on write
4731  * requests to complete.
4732  * @dev: struct device
4733  * @attr: attribute structure
4734  * @buf: buffer to return formatted data in
4735  */
4736 static ssize_t write_ns_show(struct device *dev,
4737     struct device_attribute *attr, char *buf)
4738 {
4739     struct st_modedef *STm = dev_get_drvdata(dev);
4740
4741     return sprintf(buf, "%lld",
4742                (long long)atomic64_read(&STm->tape->stats->tot_write_time));
4743 }
4744 static DEVICE_ATTR_RO(write_ns);
4745
4746 /**
4747  * in_flight_show - number of I/Os currently in flight -
4748  * in most cases this will be either 0 or 1. It may be higher if someone
4749  * has also issued other SCSI commands such as via an ioctl.
4750  * @dev: struct device
4751  * @attr: attribute structure
4752  * @buf: buffer to return formatted data in
4753  */
4754 static ssize_t in_flight_show(struct device *dev,
4755     struct device_attribute *attr, char *buf)
4756 {
4757     struct st_modedef *STm = dev_get_drvdata(dev);
4758
4759     return sprintf(buf, "%lld",
4760                (long long)atomic64_read(&STm->tape->stats->in_flight));
4761 }
4762 static DEVICE_ATTR_RO(in_flight);
4763
4764 /**
4765  * io_ns_show - io wait ns - this is the number of ns spent
4766  * waiting on all I/O to complete. This includes tape movement commands
4767  * such as rewinding, seeking to end of file or tape, it also includes
4768  * read and write. To determine the time spent on tape movement
4769  * subtract the read and write ns from this value.
4770  * @dev: struct device
4771  * @attr: attribute structure
4772  * @buf: buffer to return formatted data in
4773  */
4774 static ssize_t io_ns_show(struct device *dev,
4775     struct device_attribute *attr, char *buf)
4776 {
4777     struct st_modedef *STm = dev_get_drvdata(dev);
4778
4779     return sprintf(buf, "%lld",
4780                (long long)atomic64_read(&STm->tape->stats->tot_io_time));
4781 }
4782 static DEVICE_ATTR_RO(io_ns);
4783
4784 /**
4785  * other_cnt_show - other io count - this is the number of
4786  * I/O requests other than read and write requests.
4787  * Typically these are tape movement requests but will include driver
4788  * tape movement. This includes only requests issued by the st driver.
4789  * @dev: struct device
4790  * @attr: attribute structure
4791  * @buf: buffer to return formatted data in
4792  */
4793 static ssize_t other_cnt_show(struct device *dev,
4794     struct device_attribute *attr, char *buf)
4795 {
4796     struct st_modedef *STm = dev_get_drvdata(dev);
4797
4798     return sprintf(buf, "%lld",
4799                (long long)atomic64_read(&STm->tape->stats->other_cnt));
4800 }
4801 static DEVICE_ATTR_RO(other_cnt);
4802
4803 /**
4804  * resid_cnt_show - A count of the number of times we get a residual
4805  * count - this should indicate someone issuing reads larger than the
4806  * block size on tape.
4807  * @dev: struct device
4808  * @attr: attribute structure
4809  * @buf: buffer to return formatted data in
4810  */
4811 static ssize_t resid_cnt_show(struct device *dev,
4812     struct device_attribute *attr, char *buf)
4813 {
4814     struct st_modedef *STm = dev_get_drvdata(dev);
4815
4816     return sprintf(buf, "%lld",
4817                (long long)atomic64_read(&STm->tape->stats->resid_cnt));
4818 }
4819 static DEVICE_ATTR_RO(resid_cnt);
4820
4821 static struct attribute *st_dev_attrs[] = {
4822     &dev_attr_defined.attr,
4823     &dev_attr_default_blksize.attr,
4824     &dev_attr_default_density.attr,
4825     &dev_attr_default_compression.attr,
4826     &dev_attr_options.attr,
4827     NULL,
4828 };
4829
4830 static struct attribute *st_stats_attrs[] = {
4831     &dev_attr_read_cnt.attr,
4832     &dev_attr_read_byte_cnt.attr,
4833     &dev_attr_read_ns.attr,
4834     &dev_attr_write_cnt.attr,
4835     &dev_attr_write_byte_cnt.attr,
4836     &dev_attr_write_ns.attr,
4837     &dev_attr_in_flight.attr,
4838     &dev_attr_io_ns.attr,
4839     &dev_attr_other_cnt.attr,
4840     &dev_attr_resid_cnt.attr,
4841     NULL,
4842 };
4843
4844 static struct attribute_group stats_group = {
4845     .name = "stats",
4846     .attrs = st_stats_attrs,
4847 };
4848
4849 static struct attribute_group st_group = {
4850     .attrs = st_dev_attrs,
4851 };
4852
4853 static const struct attribute_group *st_dev_groups[] = {
4854     &st_group,
4855     &stats_group,
4856     NULL,
4857 };
4858
4859 /* The following functions may be useful for a larger audience. */
4860 static int sgl_map_user_pages(struct st_buffer *STbp,
4861                   const unsigned int max_pages, unsigned long uaddr,
4862                   size_t count, int rw)
4863 {
4864     unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4865     unsigned long start = uaddr >> PAGE_SHIFT;
4866     const int nr_pages = end - start;
4867     int res, i;
4868     struct page **pages;
4869     struct rq_map_data *mdata = &STbp->map_data;
4870
4871     /* User attempted Overflow! */
4872     if ((uaddr + count) < uaddr)
4873         return -EINVAL;
4874
4875     /* Too big */
4876         if (nr_pages > max_pages)
4877         return -ENOMEM;
4878
4879     /* Hmm? */
4880     if (count == 0)
4881         return 0;
4882
4883     pages = kmalloc_array(max_pages, sizeof(*pages), GFP_KERNEL);
4884     if (pages == NULL)
4885         return -ENOMEM;
4886
4887         /* Try to fault in all of the necessary pages */
4888         /* rw==READ means read from drive, write into memory area */
4889     res = pin_user_pages_fast(uaddr, nr_pages, rw == READ ? FOLL_WRITE : 0,
4890                   pages);
4891
4892     /* Errors and no page mapped should return here */
4893     if (res < nr_pages)
4894         goto out_unmap;
4895
4896         for (i=0; i < nr_pages; i++) {
4897                 /* FIXME: flush superflous for rw==READ,
4898                  * probably wrong function for rw==WRITE
4899                  */
4900         flush_dcache_page(pages[i]);
4901         }
4902
4903     mdata->offset = uaddr & ~PAGE_MASK;
4904     STbp->mapped_pages = pages;
4905
4906     return nr_pages;
4907  out_unmap:
4908     if (res > 0) {
4909         unpin_user_pages(pages, res);
4910         res = 0;
4911     }
4912     kfree(pages);
4913     return res;
4914 }
4915
4916
4917 /* And unmap them... */
4918 static int sgl_unmap_user_pages(struct st_buffer *STbp,
4919                 const unsigned int nr_pages, int dirtied)
4920 {
4921     /* FIXME: cache flush missing for rw==READ */
4922     unpin_user_pages_dirty_lock(STbp->mapped_pages, nr_pages, dirtied);
4923
4924     kfree(STbp->mapped_pages);
4925     STbp->mapped_pages = NULL;
4926
4927     return 0;
4928 }