drivers/scsi/st.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3    SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
   4    file Documentation/scsi/st.rst for more information.
   5
   6    History:
   7    Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.
   8    Contribution and ideas from several people including (in alphabetical
   9    order) Klaus Ehrenfried, Eugene Exarevsky, Eric Lee Green, Wolfgang Denk,
  10    Steve Hirsch, Andreas Koppenh"ofer, Michael Leodolter, Eyal Lebedinsky,
  11    Michael Schaefer, J"org Weule, and Eric Youngdale.
  12
  13    Copyright 1992 - 2016 Kai Makisara
  14    email Kai.Makisara@kolumbus.fi
  15
  16    Some small formal changes - aeb, 950809
  17
  18    Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
  19  */
  20
  21 static const char *verstr = "20160209";
  22
  23 #include <linux/module.h>
  24
  25 #include <linux/compat.h>
  26 #include <linux/fs.h>
  27 #include <linux/kernel.h>
  28 #include <linux/sched/signal.h>
  29 #include <linux/mm.h>
  30 #include <linux/init.h>
  31 #include <linux/string.h>
  32 #include <linux/slab.h>
  33 #include <linux/errno.h>
  34 #include <linux/mtio.h>
  35 #include <linux/major.h>
  36 #include <linux/cdrom.h>
  37 #include <linux/ioctl.h>
  38 #include <linux/fcntl.h>
  39 #include <linux/spinlock.h>
  40 #include <linux/blkdev.h>
  41 #include <linux/moduleparam.h>
  42 #include <linux/cdev.h>
  43 #include <linux/idr.h>
  44 #include <linux/delay.h>
  45 #include <linux/mutex.h>
  46
  47 #include <linux/uaccess.h>
  48 #include <asm/dma.h>
  49 #include <asm/unaligned.h>
  50
  51 #include <scsi/scsi.h>
  52 #include <scsi/scsi_dbg.h>
  53 #include <scsi/scsi_device.h>
  54 #include <scsi/scsi_driver.h>
  55 #include <scsi/scsi_eh.h>
  56 #include <scsi/scsi_host.h>
  57 #include <scsi/scsi_ioctl.h>
  58 #include <scsi/sg.h>
  59
  60
  61 /* The driver prints some debugging information on the console if DEBUG
  62    is defined and non-zero. */
  63 #define DEBUG 1
  64 #define NO_DEBUG 0
  65
  66 #define ST_DEB_MSG  KERN_NOTICE
  67 #if DEBUG
  68 /* The message level for the debug messages is currently set to KERN_NOTICE
  69    so that people can easily see the messages. Later when the debugging messages
  70    in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
  71 #define DEB(a) a
  72 #define DEBC(a) if (debugging) { a ; }
  73 #else
  74 #define DEB(a)
  75 #define DEBC(a)
  76 #endif
  77
  78 #define ST_KILOBYTE 1024
  79
  80 #include "st_options.h"
  81 #include "st.h"
  82
  83 static int buffer_kbs;
  84 static int max_sg_segs;
  85 static int try_direct_io = TRY_DIRECT_IO;
  86 static int try_rdio = 1;
  87 static int try_wdio = 1;
  88 static int debug_flag;
  89
  90 static struct class st_sysfs_class;
  91 static const struct attribute_group *st_dev_groups[];
  92 static const struct attribute_group *st_drv_groups[];
  93
  94 MODULE_AUTHOR("Kai Makisara");
  95 MODULE_DESCRIPTION("SCSI tape (st) driver");
  96 MODULE_LICENSE("GPL");
  97 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
  98 MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE);
  99
 100 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
 101  * of sysfs parameters (which module_param doesn't yet support).
 102  * Sysfs parameters defined explicitly later.
 103  */
 104 module_param_named(buffer_kbs, buffer_kbs, int, 0);
 105 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
 106 module_param_named(max_sg_segs, max_sg_segs, int, 0);
 107 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
 108 module_param_named(try_direct_io, try_direct_io, int, 0);
 109 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
 110 module_param_named(debug_flag, debug_flag, int, 0);
 111 MODULE_PARM_DESC(debug_flag, "Enable DEBUG, same as setting debugging=1");
 112
 113
 114 /* Extra parameters for testing */
 115 module_param_named(try_rdio, try_rdio, int, 0);
 116 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
 117 module_param_named(try_wdio, try_wdio, int, 0);
 118 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
 119
 120 #ifndef MODULE
 121 static int write_threshold_kbs;  /* retained for compatibility */
 122 static struct st_dev_parm {
 123         char *name;
 124         int *val;
 125 } parms[] __initdata = {
 126         {
 127                 "buffer_kbs", &buffer_kbs
 128         },
 129         {       /* Retained for compatibility with 2.4 */
 130                 "write_threshold_kbs", &write_threshold_kbs
 131         },
 132         {
 133                 "max_sg_segs", NULL
 134         },
 135         {
 136                 "try_direct_io", &try_direct_io
 137         },
 138         {
 139                 "debug_flag", &debug_flag
 140         }
 141 };
 142 #endif
 143
 144 /* Restrict the number of modes so that names for all are assigned */
 145 #if ST_NBR_MODES > 16
 146 #error "Maximum number of modes is 16"
 147 #endif
 148 /* Bit reversed order to get same names for same minors with all
 149    mode counts */
 150 static const char *st_formats[] = {
 151         "",  "r", "k", "s", "l", "t", "o", "u",
 152         "m", "v", "p", "x", "a", "y", "q", "z"};
 153
 154 /* The default definitions have been moved to st_options.h */
 155
 156 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
 157
 158 /* The buffer size should fit into the 24 bits for length in the
 159    6-byte SCSI read and write commands. */
 160 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
 161 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
 162 #endif
 163
 164 static int debugging = DEBUG;
 165
 166 #define MAX_RETRIES 0
 167 #define MAX_WRITE_RETRIES 0
 168 #define MAX_READY_RETRIES 0
 169 #define NO_TAPE  NOT_READY
 170
 171 #define ST_TIMEOUT (900 * HZ)
 172 #define ST_LONG_TIMEOUT (14000 * HZ)
 173
 174 /* Remove mode bits and auto-rewind bit (7) */
 175 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
 176         (iminor(x) & ((1 << ST_MODE_SHIFT)-1)))
 177 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
 178
 179 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
 180 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
 181   (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
 182
 183 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
 184    24 bits) */
 185 #define SET_DENS_AND_BLK 0x10001
 186
 187 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
 188 static int st_max_sg_segs = ST_MAX_SG;
 189
 190 static int modes_defined;
 191
 192 static int enlarge_buffer(struct st_buffer *, int);
 193 static void clear_buffer(struct st_buffer *);
 194 static void normalize_buffer(struct st_buffer *);
 195 static int append_to_buffer(const char __user *, struct st_buffer *, int);
 196 static int from_buffer(struct st_buffer *, char __user *, int);
 197 static void move_buffer_data(struct st_buffer *, int);
 198
 199 static int sgl_map_user_pages(struct st_buffer *, const unsigned int,
 200                               unsigned long, size_t, int);
 201 static int sgl_unmap_user_pages(struct st_buffer *, const unsigned int, int);
 202
 203 static int st_probe(struct device *);
 204 static int st_remove(struct device *);
 205
 206 static struct scsi_driver st_template = {
 207         .gendrv = {
 208                 .name           = "st",
 209                 .owner          = THIS_MODULE,
 210                 .probe          = st_probe,
 211                 .remove         = st_remove,
 212                 .groups         = st_drv_groups,
 213         },
 214 };
 215
 216 static int st_compression(struct scsi_tape *, int);
 217
 218 static int find_partition(struct scsi_tape *);
 219 static int switch_partition(struct scsi_tape *);
 220
 221 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
 222
 223 static void scsi_tape_release(struct kref *);
 224
 225 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
 226
 227 static DEFINE_MUTEX(st_ref_mutex);
 228 static DEFINE_SPINLOCK(st_index_lock);
 229 static DEFINE_SPINLOCK(st_use_lock);
 230 static DEFINE_IDR(st_index_idr);
 231
 232
 233 \f
 234 #ifndef SIGS_FROM_OSST
 235 #define SIGS_FROM_OSST \
 236         {"OnStream", "SC-", "", "osst"}, \
 237         {"OnStream", "DI-", "", "osst"}, \
 238         {"OnStream", "DP-", "", "osst"}, \
 239         {"OnStream", "USB", "", "osst"}, \
 240         {"OnStream", "FW-", "", "osst"}
 241 #endif
 242
 243 static struct scsi_tape *scsi_tape_get(int dev)
 244 {
 245         struct scsi_tape *STp = NULL;
 246
 247         mutex_lock(&st_ref_mutex);
 248         spin_lock(&st_index_lock);
 249
 250         STp = idr_find(&st_index_idr, dev);
 251         if (!STp) goto out;
 252
 253         kref_get(&STp->kref);
 254
 255         if (!STp->device)
 256                 goto out_put;
 257
 258         if (scsi_device_get(STp->device))
 259                 goto out_put;
 260
 261         goto out;
 262
 263 out_put:
 264         kref_put(&STp->kref, scsi_tape_release);
 265         STp = NULL;
 266 out:
 267         spin_unlock(&st_index_lock);
 268         mutex_unlock(&st_ref_mutex);
 269         return STp;
 270 }
 271
 272 static void scsi_tape_put(struct scsi_tape *STp)
 273 {
 274         struct scsi_device *sdev = STp->device;
 275
 276         mutex_lock(&st_ref_mutex);
 277         kref_put(&STp->kref, scsi_tape_release);
 278         scsi_device_put(sdev);
 279         mutex_unlock(&st_ref_mutex);
 280 }
 281
 282 struct st_reject_data {
 283         char *vendor;
 284         char *model;
 285         char *rev;
 286         char *driver_hint; /* Name of the correct driver, NULL if unknown */
 287 };
 288
 289 static struct st_reject_data reject_list[] = {
 290         /* {"XXX", "Yy-", "", NULL},  example */
 291         SIGS_FROM_OSST,
 292         {NULL, }};
 293
 294 /* If the device signature is on the list of incompatible drives, the
 295    function returns a pointer to the name of the correct driver (if known) */
 296 static char * st_incompatible(struct scsi_device* SDp)
 297 {
 298         struct st_reject_data *rp;
 299
 300         for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
 301                 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
 302                     !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
 303                     !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
 304                         if (rp->driver_hint)
 305                                 return rp->driver_hint;
 306                         else
 307                                 return "unknown";
 308                 }
 309         return NULL;
 310 }
 311 \f
 312
 313 #define st_printk(prefix, t, fmt, a...) \
 314         sdev_prefix_printk(prefix, (t)->device, (t)->name, fmt, ##a)
 315 #ifdef DEBUG
 316 #define DEBC_printk(t, fmt, a...) \
 317         if (debugging) { st_printk(ST_DEB_MSG, t, fmt, ##a ); }
 318 #else
 319 #define DEBC_printk(t, fmt, a...)
 320 #endif
 321
 322 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
 323 {
 324         const u8 *ucp;
 325         const u8 *sense = SRpnt->sense;
 326
 327         s->have_sense = scsi_normalize_sense(SRpnt->sense,
 328                                 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
 329         s->flags = 0;
 330
 331         if (s->have_sense) {
 332                 s->deferred = 0;
 333                 s->remainder_valid =
 334                         scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
 335                 switch (sense[0] & 0x7f) {
 336                 case 0x71:
 337                         s->deferred = 1;
 338                         fallthrough;
 339                 case 0x70:
 340                         s->fixed_format = 1;
 341                         s->flags = sense[2] & 0xe0;
 342                         break;
 343                 case 0x73:
 344                         s->deferred = 1;
 345                         fallthrough;
 346                 case 0x72:
 347                         s->fixed_format = 0;
 348                         ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
 349                         s->flags = ucp ? (ucp[3] & 0xe0) : 0;
 350                         break;
 351                 }
 352         }
 353 }
 354
 355
 356 /* Convert the result to success code */
 357 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
 358 {
 359         int result = SRpnt->result;
 360         u8 scode;
 361         DEB(const char *stp;)
 362         char *name = STp->name;
 363         struct st_cmdstatus *cmdstatp;
 364
 365         if (!result)
 366                 return 0;
 367
 368         cmdstatp = &STp->buffer->cmdstat;
 369         st_analyze_sense(SRpnt, cmdstatp);
 370
 371         if (cmdstatp->have_sense)
 372                 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
 373         else
 374                 scode = 0;
 375
 376         DEB(
 377         if (debugging) {
 378                 st_printk(ST_DEB_MSG, STp,
 379                             "Error: %x, cmd: %x %x %x %x %x %x\n", result,
 380                             SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
 381                             SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
 382                 if (cmdstatp->have_sense)
 383                         __scsi_print_sense(STp->device, name,
 384                                            SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
 385         } ) /* end DEB */
 386         if (!debugging) { /* Abnormal conditions for tape */
 387                 if (!cmdstatp->have_sense)
 388                         st_printk(KERN_WARNING, STp,
 389                                "Error %x (driver bt 0, host bt 0x%x).\n",
 390                                result, host_byte(result));
 391                 else if (cmdstatp->have_sense &&
 392                          scode != NO_SENSE &&
 393                          scode != RECOVERED_ERROR &&
 394                          /* scode != UNIT_ATTENTION && */
 395                          scode != BLANK_CHECK &&
 396                          scode != VOLUME_OVERFLOW &&
 397                          SRpnt->cmd[0] != MODE_SENSE &&
 398                          SRpnt->cmd[0] != TEST_UNIT_READY) {
 399
 400                         __scsi_print_sense(STp->device, name,
 401                                            SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
 402                 }
 403         }
 404
 405         if (cmdstatp->fixed_format &&
 406             STp->cln_mode >= EXTENDED_SENSE_START) {  /* Only fixed format sense */
 407                 if (STp->cln_sense_value)
 408                         STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
 409                                                STp->cln_sense_mask) == STp->cln_sense_value);
 410                 else
 411                         STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
 412                                                STp->cln_sense_mask) != 0);
 413         }
 414         if (cmdstatp->have_sense &&
 415             cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
 416                 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
 417
 418         STp->pos_unknown |= STp->device->was_reset;
 419
 420         if (cmdstatp->have_sense &&
 421             scode == RECOVERED_ERROR
 422 #if ST_RECOVERED_WRITE_FATAL
 423             && SRpnt->cmd[0] != WRITE_6
 424             && SRpnt->cmd[0] != WRITE_FILEMARKS
 425 #endif
 426             ) {
 427                 STp->recover_count++;
 428                 STp->recover_reg++;
 429
 430                 DEB(
 431                 if (debugging) {
 432                         if (SRpnt->cmd[0] == READ_6)
 433                                 stp = "read";
 434                         else if (SRpnt->cmd[0] == WRITE_6)
 435                                 stp = "write";
 436                         else
 437                                 stp = "ioctl";
 438                         st_printk(ST_DEB_MSG, STp,
 439                                   "Recovered %s error (%d).\n",
 440                                   stp, STp->recover_count);
 441                 } ) /* end DEB */
 442
 443                 if (cmdstatp->flags == 0)
 444                         return 0;
 445         }
 446         return (-EIO);
 447 }
 448
 449 static struct st_request *st_allocate_request(struct scsi_tape *stp)
 450 {
 451         struct st_request *streq;
 452
 453         streq = kzalloc(sizeof(*streq), GFP_KERNEL);
 454         if (streq)
 455                 streq->stp = stp;
 456         else {
 457                 st_printk(KERN_ERR, stp,
 458                           "Can't get SCSI request.\n");
 459                 if (signal_pending(current))
 460                         stp->buffer->syscall_result = -EINTR;
 461                 else
 462                         stp->buffer->syscall_result = -EBUSY;
 463         }
 464
 465         return streq;
 466 }
 467
 468 static void st_release_request(struct st_request *streq)
 469 {
 470         kfree(streq);
 471 }
 472
 473 static void st_do_stats(struct scsi_tape *STp, struct request *req)
 474 {
 475         struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(req);
 476         ktime_t now;
 477
 478         now = ktime_get();
 479         if (scmd->cmnd[0] == WRITE_6) {
 480                 now = ktime_sub(now, STp->stats->write_time);
 481                 atomic64_add(ktime_to_ns(now), &STp->stats->tot_write_time);
 482                 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
 483                 atomic64_inc(&STp->stats->write_cnt);
 484                 if (scmd->result) {
 485                         atomic64_add(atomic_read(&STp->stats->last_write_size)
 486                                 - STp->buffer->cmdstat.residual,
 487                                 &STp->stats->write_byte_cnt);
 488                         if (STp->buffer->cmdstat.residual > 0)
 489                                 atomic64_inc(&STp->stats->resid_cnt);
 490                 } else
 491                         atomic64_add(atomic_read(&STp->stats->last_write_size),
 492                                 &STp->stats->write_byte_cnt);
 493         } else if (scmd->cmnd[0] == READ_6) {
 494                 now = ktime_sub(now, STp->stats->read_time);
 495                 atomic64_add(ktime_to_ns(now), &STp->stats->tot_read_time);
 496                 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
 497                 atomic64_inc(&STp->stats->read_cnt);
 498                 if (scmd->result) {
 499                         atomic64_add(atomic_read(&STp->stats->last_read_size)
 500                                 - STp->buffer->cmdstat.residual,
 501                                 &STp->stats->read_byte_cnt);
 502                         if (STp->buffer->cmdstat.residual > 0)
 503                                 atomic64_inc(&STp->stats->resid_cnt);
 504                 } else
 505                         atomic64_add(atomic_read(&STp->stats->last_read_size),
 506                                 &STp->stats->read_byte_cnt);
 507         } else {
 508                 now = ktime_sub(now, STp->stats->other_time);
 509                 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
 510                 atomic64_inc(&STp->stats->other_cnt);
 511         }
 512         atomic64_dec(&STp->stats->in_flight);
 513 }
 514
 515 static void st_scsi_execute_end(struct request *req, blk_status_t status)
 516 {
 517         struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(req);
 518         struct st_request *SRpnt = req->end_io_data;
 519         struct scsi_tape *STp = SRpnt->stp;
 520         struct bio *tmp;
 521
 522         STp->buffer->cmdstat.midlevel_result = SRpnt->result = scmd->result;
 523         STp->buffer->cmdstat.residual = scmd->resid_len;
 524
 525         st_do_stats(STp, req);
 526
 527         tmp = SRpnt->bio;
 528         if (scmd->sense_len)
 529                 memcpy(SRpnt->sense, scmd->sense_buffer, SCSI_SENSE_BUFFERSIZE);
 530         if (SRpnt->waiting)
 531                 complete(SRpnt->waiting);
 532
 533         blk_rq_unmap_user(tmp);
 534         blk_mq_free_request(req);
 535 }
 536
 537 static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
 538                            int data_direction, void *buffer, unsigned bufflen,
 539                            int timeout, int retries)
 540 {
 541         struct request *req;
 542         struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
 543         int err = 0;
 544         struct scsi_tape *STp = SRpnt->stp;
 545         struct scsi_cmnd *scmd;
 546
 547         req = scsi_alloc_request(SRpnt->stp->device->request_queue,
 548                         data_direction == DMA_TO_DEVICE ?
 549                         REQ_OP_DRV_OUT : REQ_OP_DRV_IN, 0);
 550         if (IS_ERR(req))
 551                 return PTR_ERR(req);
 552         scmd = blk_mq_rq_to_pdu(req);
 553         req->rq_flags |= RQF_QUIET;
 554
 555         mdata->null_mapped = 1;
 556
 557         if (bufflen) {
 558                 err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen,
 559                                       GFP_KERNEL);
 560                 if (err) {
 561                         blk_mq_free_request(req);
 562                         return err;
 563                 }
 564         }
 565
 566         atomic64_inc(&STp->stats->in_flight);
 567         if (cmd[0] == WRITE_6) {
 568                 atomic_set(&STp->stats->last_write_size, bufflen);
 569                 STp->stats->write_time = ktime_get();
 570         } else if (cmd[0] == READ_6) {
 571                 atomic_set(&STp->stats->last_read_size, bufflen);
 572                 STp->stats->read_time = ktime_get();
 573         } else {
 574                 STp->stats->other_time = ktime_get();
 575         }
 576
 577         SRpnt->bio = req->bio;
 578         scmd->cmd_len = COMMAND_SIZE(cmd[0]);
 579         memcpy(scmd->cmnd, cmd, scmd->cmd_len);
 580         req->timeout = timeout;
 581         scmd->allowed = retries;
 582         req->end_io = st_scsi_execute_end;
 583         req->end_io_data = SRpnt;
 584
 585         blk_execute_rq_nowait(req, true);
 586         return 0;
 587 }
 588
 589 /* Do the scsi command. Waits until command performed if do_wait is true.
 590    Otherwise write_behind_check() is used to check that the command
 591    has finished. */
 592 static struct st_request *
 593 st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
 594            int bytes, int direction, int timeout, int retries, int do_wait)
 595 {
 596         struct completion *waiting;
 597         struct rq_map_data *mdata = &STp->buffer->map_data;
 598         int ret;
 599
 600         /* if async, make sure there's no command outstanding */
 601         if (!do_wait && ((STp->buffer)->last_SRpnt)) {
 602                 st_printk(KERN_ERR, STp,
 603                           "Async command already active.\n");
 604                 if (signal_pending(current))
 605                         (STp->buffer)->syscall_result = (-EINTR);
 606                 else
 607                         (STp->buffer)->syscall_result = (-EBUSY);
 608                 return NULL;
 609         }
 610
 611         if (!SRpnt) {
 612                 SRpnt = st_allocate_request(STp);
 613                 if (!SRpnt)
 614                         return NULL;
 615         }
 616
 617         /* If async IO, set last_SRpnt. This ptr tells write_behind_check
 618            which IO is outstanding. It's nulled out when the IO completes. */
 619         if (!do_wait)
 620                 (STp->buffer)->last_SRpnt = SRpnt;
 621
 622         waiting = &STp->wait;
 623         init_completion(waiting);
 624         SRpnt->waiting = waiting;
 625
 626         if (STp->buffer->do_dio) {
 627                 mdata->page_order = 0;
 628                 mdata->nr_entries = STp->buffer->sg_segs;
 629                 mdata->pages = STp->buffer->mapped_pages;
 630         } else {
 631                 mdata->page_order = STp->buffer->reserved_page_order;
 632                 mdata->nr_entries =
 633                         DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order);
 634                 mdata->pages = STp->buffer->reserved_pages;
 635                 mdata->offset = 0;
 636         }
 637
 638         memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
 639         STp->buffer->cmdstat.have_sense = 0;
 640         STp->buffer->syscall_result = 0;
 641
 642         ret = st_scsi_execute(SRpnt, cmd, direction, NULL, bytes, timeout,
 643                               retries);
 644         if (ret) {
 645                 /* could not allocate the buffer or request was too large */
 646                 (STp->buffer)->syscall_result = (-EBUSY);
 647                 (STp->buffer)->last_SRpnt = NULL;
 648         } else if (do_wait) {
 649                 wait_for_completion(waiting);
 650                 SRpnt->waiting = NULL;
 651                 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
 652         }
 653
 654         return SRpnt;
 655 }
 656
 657
 658 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
 659    write has been correct but EOM early warning reached, -EIO if write ended in
 660    error or zero if write successful. Asynchronous writes are used only in
 661    variable block mode. */
 662 static int write_behind_check(struct scsi_tape * STp)
 663 {
 664         int retval = 0;
 665         struct st_buffer *STbuffer;
 666         struct st_partstat *STps;
 667         struct st_cmdstatus *cmdstatp;
 668         struct st_request *SRpnt;
 669
 670         STbuffer = STp->buffer;
 671         if (!STbuffer->writing)
 672                 return 0;
 673
 674         DEB(
 675         if (STp->write_pending)
 676                 STp->nbr_waits++;
 677         else
 678                 STp->nbr_finished++;
 679         ) /* end DEB */
 680
 681         wait_for_completion(&(STp->wait));
 682         SRpnt = STbuffer->last_SRpnt;
 683         STbuffer->last_SRpnt = NULL;
 684         SRpnt->waiting = NULL;
 685
 686         (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
 687         st_release_request(SRpnt);
 688
 689         STbuffer->buffer_bytes -= STbuffer->writing;
 690         STps = &(STp->ps[STp->partition]);
 691         if (STps->drv_block >= 0) {
 692                 if (STp->block_size == 0)
 693                         STps->drv_block++;
 694                 else
 695                         STps->drv_block += STbuffer->writing / STp->block_size;
 696         }
 697
 698         cmdstatp = &STbuffer->cmdstat;
 699         if (STbuffer->syscall_result) {
 700                 retval = -EIO;
 701                 if (cmdstatp->have_sense && !cmdstatp->deferred &&
 702                     (cmdstatp->flags & SENSE_EOM) &&
 703                     (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
 704                      cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
 705                         /* EOM at write-behind, has all data been written? */
 706                         if (!cmdstatp->remainder_valid ||
 707                             cmdstatp->uremainder64 == 0)
 708                                 retval = -ENOSPC;
 709                 }
 710                 if (retval == -EIO)
 711                         STps->drv_block = -1;
 712         }
 713         STbuffer->writing = 0;
 714
 715         DEB(if (debugging && retval)
 716                     st_printk(ST_DEB_MSG, STp,
 717                                 "Async write error %x, return value %d.\n",
 718                                 STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
 719
 720         return retval;
 721 }
 722
 723
 724 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
 725    it messes up the block number). */
 726 static int cross_eof(struct scsi_tape * STp, int forward)
 727 {
 728         struct st_request *SRpnt;
 729         unsigned char cmd[MAX_COMMAND_SIZE];
 730
 731         cmd[0] = SPACE;
 732         cmd[1] = 0x01;          /* Space FileMarks */
 733         if (forward) {
 734                 cmd[2] = cmd[3] = 0;
 735                 cmd[4] = 1;
 736         } else
 737                 cmd[2] = cmd[3] = cmd[4] = 0xff;        /* -1 filemarks */
 738         cmd[5] = 0;
 739
 740         DEBC_printk(STp, "Stepping over filemark %s.\n",
 741                     forward ? "forward" : "backward");
 742
 743         SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
 744                            STp->device->request_queue->rq_timeout,
 745                            MAX_RETRIES, 1);
 746         if (!SRpnt)
 747                 return (STp->buffer)->syscall_result;
 748
 749         st_release_request(SRpnt);
 750         SRpnt = NULL;
 751
 752         if ((STp->buffer)->cmdstat.midlevel_result != 0)
 753                 st_printk(KERN_ERR, STp,
 754                           "Stepping over filemark %s failed.\n",
 755                           forward ? "forward" : "backward");
 756
 757         return (STp->buffer)->syscall_result;
 758 }
 759
 760
 761 /* Flush the write buffer (never need to write if variable blocksize). */
 762 static int st_flush_write_buffer(struct scsi_tape * STp)
 763 {
 764         int transfer, blks;
 765         int result;
 766         unsigned char cmd[MAX_COMMAND_SIZE];
 767         struct st_request *SRpnt;
 768         struct st_partstat *STps;
 769
 770         result = write_behind_check(STp);
 771         if (result)
 772                 return result;
 773
 774         result = 0;
 775         if (STp->dirty == 1) {
 776
 777                 transfer = STp->buffer->buffer_bytes;
 778                 DEBC_printk(STp, "Flushing %d bytes.\n", transfer);
 779
 780                 memset(cmd, 0, MAX_COMMAND_SIZE);
 781                 cmd[0] = WRITE_6;
 782                 cmd[1] = 1;
 783                 blks = transfer / STp->block_size;
 784                 cmd[2] = blks >> 16;
 785                 cmd[3] = blks >> 8;
 786                 cmd[4] = blks;
 787
 788                 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
 789                                    STp->device->request_queue->rq_timeout,
 790                                    MAX_WRITE_RETRIES, 1);
 791                 if (!SRpnt)
 792                         return (STp->buffer)->syscall_result;
 793
 794                 STps = &(STp->ps[STp->partition]);
 795                 if ((STp->buffer)->syscall_result != 0) {
 796                         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
 797
 798                         if (cmdstatp->have_sense && !cmdstatp->deferred &&
 799                             (cmdstatp->flags & SENSE_EOM) &&
 800                             (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
 801                              cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
 802                             (!cmdstatp->remainder_valid ||
 803                              cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
 804                                 STp->dirty = 0;
 805                                 (STp->buffer)->buffer_bytes = 0;
 806                                 if (STps->drv_block >= 0)
 807                                         STps->drv_block += blks;
 808                                 result = (-ENOSPC);
 809                         } else {
 810                                 st_printk(KERN_ERR, STp, "Error on flush.\n");
 811                                 STps->drv_block = (-1);
 812                                 result = (-EIO);
 813                         }
 814                 } else {
 815                         if (STps->drv_block >= 0)
 816                                 STps->drv_block += blks;
 817                         STp->dirty = 0;
 818                         (STp->buffer)->buffer_bytes = 0;
 819                 }
 820                 st_release_request(SRpnt);
 821                 SRpnt = NULL;
 822         }
 823         return result;
 824 }
 825
 826
 827 /* Flush the tape buffer. The tape will be positioned correctly unless
 828    seek_next is true. */
 829 static int flush_buffer(struct scsi_tape *STp, int seek_next)
 830 {
 831         int backspace, result;
 832         struct st_partstat *STps;
 833
 834         /*
 835          * If there was a bus reset, block further access
 836          * to this device.
 837          */
 838         if (STp->pos_unknown)
 839                 return (-EIO);
 840
 841         if (STp->ready != ST_READY)
 842                 return 0;
 843         STps = &(STp->ps[STp->partition]);
 844         if (STps->rw == ST_WRITING)     /* Writing */
 845                 return st_flush_write_buffer(STp);
 846
 847         if (STp->block_size == 0)
 848                 return 0;
 849
 850         backspace = ((STp->buffer)->buffer_bytes +
 851                      (STp->buffer)->read_pointer) / STp->block_size -
 852             ((STp->buffer)->read_pointer + STp->block_size - 1) /
 853             STp->block_size;
 854         (STp->buffer)->buffer_bytes = 0;
 855         (STp->buffer)->read_pointer = 0;
 856         result = 0;
 857         if (!seek_next) {
 858                 if (STps->eof == ST_FM_HIT) {
 859                         result = cross_eof(STp, 0);     /* Back over the EOF hit */
 860                         if (!result)
 861                                 STps->eof = ST_NOEOF;
 862                         else {
 863                                 if (STps->drv_file >= 0)
 864                                         STps->drv_file++;
 865                                 STps->drv_block = 0;
 866                         }
 867                 }
 868                 if (!result && backspace > 0)
 869                         result = st_int_ioctl(STp, MTBSR, backspace);
 870         } else if (STps->eof == ST_FM_HIT) {
 871                 if (STps->drv_file >= 0)
 872                         STps->drv_file++;
 873                 STps->drv_block = 0;
 874                 STps->eof = ST_NOEOF;
 875         }
 876         return result;
 877
 878 }
 879 \f
 880 /* Set the mode parameters */
 881 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
 882 {
 883         int set_it = 0;
 884         unsigned long arg;
 885
 886         if (!STp->density_changed &&
 887             STm->default_density >= 0 &&
 888             STm->default_density != STp->density) {
 889                 arg = STm->default_density;
 890                 set_it = 1;
 891         } else
 892                 arg = STp->density;
 893         arg <<= MT_ST_DENSITY_SHIFT;
 894         if (!STp->blksize_changed &&
 895             STm->default_blksize >= 0 &&
 896             STm->default_blksize != STp->block_size) {
 897                 arg |= STm->default_blksize;
 898                 set_it = 1;
 899         } else
 900                 arg |= STp->block_size;
 901         if (set_it &&
 902             st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
 903                 st_printk(KERN_WARNING, STp,
 904                           "Can't set default block size to %d bytes "
 905                           "and density %x.\n",
 906                           STm->default_blksize, STm->default_density);
 907                 if (modes_defined)
 908                         return (-EINVAL);
 909         }
 910         return 0;
 911 }
 912
 913
 914 /* Lock or unlock the drive door. Don't use when st_request allocated. */
 915 static int do_door_lock(struct scsi_tape * STp, int do_lock)
 916 {
 917         int retval;
 918
 919         DEBC_printk(STp, "%socking drive door.\n", do_lock ? "L" : "Unl");
 920
 921         retval = scsi_set_medium_removal(STp->device,
 922                         do_lock ? SCSI_REMOVAL_PREVENT : SCSI_REMOVAL_ALLOW);
 923         if (!retval)
 924                 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
 925         else
 926                 STp->door_locked = ST_LOCK_FAILS;
 927         return retval;
 928 }
 929
 930
 931 /* Set the internal state after reset */
 932 static void reset_state(struct scsi_tape *STp)
 933 {
 934         int i;
 935         struct st_partstat *STps;
 936
 937         STp->pos_unknown = 0;
 938         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
 939                 STps = &(STp->ps[i]);
 940                 STps->rw = ST_IDLE;
 941                 STps->eof = ST_NOEOF;
 942                 STps->at_sm = 0;
 943                 STps->last_block_valid = 0;
 944                 STps->drv_block = -1;
 945                 STps->drv_file = -1;
 946         }
 947         if (STp->can_partitions) {
 948                 STp->partition = find_partition(STp);
 949                 if (STp->partition < 0)
 950                         STp->partition = 0;
 951                 STp->new_partition = STp->partition;
 952         }
 953 }
 954 \f
 955 /* Test if the drive is ready. Returns either one of the codes below or a negative system
 956    error code. */
 957 #define CHKRES_READY       0
 958 #define CHKRES_NEW_SESSION 1
 959 #define CHKRES_NOT_READY   2
 960 #define CHKRES_NO_TAPE     3
 961
 962 #define MAX_ATTENTIONS    10
 963
 964 static int test_ready(struct scsi_tape *STp, int do_wait)
 965 {
 966         int attentions, waits, max_wait, scode;
 967         int retval = CHKRES_READY, new_session = 0;
 968         unsigned char cmd[MAX_COMMAND_SIZE];
 969         struct st_request *SRpnt = NULL;
 970         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
 971
 972         max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
 973
 974         for (attentions=waits=0; ; ) {
 975                 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
 976                 cmd[0] = TEST_UNIT_READY;
 977                 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
 978                                    STp->long_timeout, MAX_READY_RETRIES, 1);
 979
 980                 if (!SRpnt) {
 981                         retval = (STp->buffer)->syscall_result;
 982                         break;
 983                 }
 984
 985                 if (cmdstatp->have_sense) {
 986
 987                         scode = cmdstatp->sense_hdr.sense_key;
 988
 989                         if (scode == UNIT_ATTENTION) { /* New media? */
 990                                 new_session = 1;
 991                                 if (attentions < MAX_ATTENTIONS) {
 992                                         attentions++;
 993                                         continue;
 994                                 }
 995                                 else {
 996                                         retval = (-EIO);
 997                                         break;
 998                                 }
 999                         }
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 \f/* 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 \f
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 \f
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 \f
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 \f
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 \f
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 \f
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 \f
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 \f
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 \f
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 \f
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 }