drivers/scsi/st.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3    SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
   4    file Documentation/scsi/st.txt 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/fs.h>
  26 #include <linux/kernel.h>
  27 #include <linux/sched/signal.h>
  28 #include <linux/mm.h>
  29 #include <linux/init.h>
  30 #include <linux/string.h>
  31 #include <linux/slab.h>
  32 #include <linux/errno.h>
  33 #include <linux/mtio.h>
  34 #include <linux/cdrom.h>
  35 #include <linux/ioctl.h>
  36 #include <linux/fcntl.h>
  37 #include <linux/spinlock.h>
  38 #include <linux/blkdev.h>
  39 #include <linux/moduleparam.h>
  40 #include <linux/cdev.h>
  41 #include <linux/idr.h>
  42 #include <linux/delay.h>
  43 #include <linux/mutex.h>
  44
  45 #include <linux/uaccess.h>
  46 #include <asm/dma.h>
  47
  48 #include <scsi/scsi.h>
  49 #include <scsi/scsi_dbg.h>
  50 #include <scsi/scsi_device.h>
  51 #include <scsi/scsi_driver.h>
  52 #include <scsi/scsi_eh.h>
  53 #include <scsi/scsi_host.h>
  54 #include <scsi/scsi_ioctl.h>
  55 #include <scsi/sg.h>
  56
  57
  58 /* The driver prints some debugging information on the console if DEBUG
  59    is defined and non-zero. */
  60 #define DEBUG 1
  61 #define NO_DEBUG 0
  62
  63 #define ST_DEB_MSG  KERN_NOTICE
  64 #if DEBUG
  65 /* The message level for the debug messages is currently set to KERN_NOTICE
  66    so that people can easily see the messages. Later when the debugging messages
  67    in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
  68 #define DEB(a) a
  69 #define DEBC(a) if (debugging) { a ; }
  70 #else
  71 #define DEB(a)
  72 #define DEBC(a)
  73 #endif
  74
  75 #define ST_KILOBYTE 1024
  76
  77 #include "st_options.h"
  78 #include "st.h"
  79
  80 static int buffer_kbs;
  81 static int max_sg_segs;
  82 static int try_direct_io = TRY_DIRECT_IO;
  83 static int try_rdio = 1;
  84 static int try_wdio = 1;
  85 static int debug_flag;
  86
  87 static struct class st_sysfs_class;
  88 static const struct attribute_group *st_dev_groups[];
  89 static const struct attribute_group *st_drv_groups[];
  90
  91 MODULE_AUTHOR("Kai Makisara");
  92 MODULE_DESCRIPTION("SCSI tape (st) driver");
  93 MODULE_LICENSE("GPL");
  94 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
  95 MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE);
  96
  97 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
  98  * of sysfs parameters (which module_param doesn't yet support).
  99  * Sysfs parameters defined explicitly later.
 100  */
 101 module_param_named(buffer_kbs, buffer_kbs, int, 0);
 102 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
 103 module_param_named(max_sg_segs, max_sg_segs, int, 0);
 104 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
 105 module_param_named(try_direct_io, try_direct_io, int, 0);
 106 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
 107 module_param_named(debug_flag, debug_flag, int, 0);
 108 MODULE_PARM_DESC(debug_flag, "Enable DEBUG, same as setting debugging=1");
 109
 110
 111 /* Extra parameters for testing */
 112 module_param_named(try_rdio, try_rdio, int, 0);
 113 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
 114 module_param_named(try_wdio, try_wdio, int, 0);
 115 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
 116
 117 #ifndef MODULE
 118 static int write_threshold_kbs;  /* retained for compatibility */
 119 static struct st_dev_parm {
 120         char *name;
 121         int *val;
 122 } parms[] __initdata = {
 123         {
 124                 "buffer_kbs", &buffer_kbs
 125         },
 126         {       /* Retained for compatibility with 2.4 */
 127                 "write_threshold_kbs", &write_threshold_kbs
 128         },
 129         {
 130                 "max_sg_segs", NULL
 131         },
 132         {
 133                 "try_direct_io", &try_direct_io
 134         },
 135         {
 136                 "debug_flag", &debug_flag
 137         }
 138 };
 139 #endif
 140
 141 /* Restrict the number of modes so that names for all are assigned */
 142 #if ST_NBR_MODES > 16
 143 #error "Maximum number of modes is 16"
 144 #endif
 145 /* Bit reversed order to get same names for same minors with all
 146    mode counts */
 147 static const char *st_formats[] = {
 148         "",  "r", "k", "s", "l", "t", "o", "u",
 149         "m", "v", "p", "x", "a", "y", "q", "z"};
 150
 151 /* The default definitions have been moved to st_options.h */
 152
 153 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
 154
 155 /* The buffer size should fit into the 24 bits for length in the
 156    6-byte SCSI read and write commands. */
 157 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
 158 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
 159 #endif
 160
 161 static int debugging = DEBUG;
 162
 163 #define MAX_RETRIES 0
 164 #define MAX_WRITE_RETRIES 0
 165 #define MAX_READY_RETRIES 0
 166 #define NO_TAPE  NOT_READY
 167
 168 #define ST_TIMEOUT (900 * HZ)
 169 #define ST_LONG_TIMEOUT (14000 * HZ)
 170
 171 /* Remove mode bits and auto-rewind bit (7) */
 172 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
 173         (iminor(x) & ((1 << ST_MODE_SHIFT)-1)))
 174 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
 175
 176 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
 177 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
 178   (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
 179
 180 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
 181    24 bits) */
 182 #define SET_DENS_AND_BLK 0x10001
 183
 184 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
 185 static int st_max_sg_segs = ST_MAX_SG;
 186
 187 static int modes_defined;
 188
 189 static int enlarge_buffer(struct st_buffer *, int, int);
 190 static void clear_buffer(struct st_buffer *);
 191 static void normalize_buffer(struct st_buffer *);
 192 static int append_to_buffer(const char __user *, struct st_buffer *, int);
 193 static int from_buffer(struct st_buffer *, char __user *, int);
 194 static void move_buffer_data(struct st_buffer *, int);
 195
 196 static int sgl_map_user_pages(struct st_buffer *, const unsigned int,
 197                               unsigned long, size_t, int);
 198 static int sgl_unmap_user_pages(struct st_buffer *, const unsigned int, int);
 199
 200 static int st_probe(struct device *);
 201 static int st_remove(struct device *);
 202
 203 static struct scsi_driver st_template = {
 204         .gendrv = {
 205                 .name           = "st",
 206                 .owner          = THIS_MODULE,
 207                 .probe          = st_probe,
 208                 .remove         = st_remove,
 209                 .groups         = st_drv_groups,
 210         },
 211 };
 212
 213 static int st_compression(struct scsi_tape *, int);
 214
 215 static int find_partition(struct scsi_tape *);
 216 static int switch_partition(struct scsi_tape *);
 217
 218 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
 219
 220 static void scsi_tape_release(struct kref *);
 221
 222 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
 223
 224 static DEFINE_MUTEX(st_ref_mutex);
 225 static DEFINE_SPINLOCK(st_index_lock);
 226 static DEFINE_SPINLOCK(st_use_lock);
 227 static DEFINE_IDR(st_index_idr);
 228
 229
 230 \f
 231 #ifndef SIGS_FROM_OSST
 232 #define SIGS_FROM_OSST \
 233         {"OnStream", "SC-", "", "osst"}, \
 234         {"OnStream", "DI-", "", "osst"}, \
 235         {"OnStream", "DP-", "", "osst"}, \
 236         {"OnStream", "USB", "", "osst"}, \
 237         {"OnStream", "FW-", "", "osst"}
 238 #endif
 239
 240 static struct scsi_tape *scsi_tape_get(int dev)
 241 {
 242         struct scsi_tape *STp = NULL;
 243
 244         mutex_lock(&st_ref_mutex);
 245         spin_lock(&st_index_lock);
 246
 247         STp = idr_find(&st_index_idr, dev);
 248         if (!STp) goto out;
 249
 250         kref_get(&STp->kref);
 251
 252         if (!STp->device)
 253                 goto out_put;
 254
 255         if (scsi_device_get(STp->device))
 256                 goto out_put;
 257
 258         goto out;
 259
 260 out_put:
 261         kref_put(&STp->kref, scsi_tape_release);
 262         STp = NULL;
 263 out:
 264         spin_unlock(&st_index_lock);
 265         mutex_unlock(&st_ref_mutex);
 266         return STp;
 267 }
 268
 269 static void scsi_tape_put(struct scsi_tape *STp)
 270 {
 271         struct scsi_device *sdev = STp->device;
 272
 273         mutex_lock(&st_ref_mutex);
 274         kref_put(&STp->kref, scsi_tape_release);
 275         scsi_device_put(sdev);
 276         mutex_unlock(&st_ref_mutex);
 277 }
 278
 279 struct st_reject_data {
 280         char *vendor;
 281         char *model;
 282         char *rev;
 283         char *driver_hint; /* Name of the correct driver, NULL if unknown */
 284 };
 285
 286 static struct st_reject_data reject_list[] = {
 287         /* {"XXX", "Yy-", "", NULL},  example */
 288         SIGS_FROM_OSST,
 289         {NULL, }};
 290
 291 /* If the device signature is on the list of incompatible drives, the
 292    function returns a pointer to the name of the correct driver (if known) */
 293 static char * st_incompatible(struct scsi_device* SDp)
 294 {
 295         struct st_reject_data *rp;
 296
 297         for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
 298                 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
 299                     !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
 300                     !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
 301                         if (rp->driver_hint)
 302                                 return rp->driver_hint;
 303                         else
 304                                 return "unknown";
 305                 }
 306         return NULL;
 307 }
 308 \f
 309
 310 static inline char *tape_name(struct scsi_tape *tape)
 311 {
 312         return tape->disk->disk_name;
 313 }
 314
 315 #define st_printk(prefix, t, fmt, a...) \
 316         sdev_prefix_printk(prefix, (t)->device, tape_name(t), fmt, ##a)
 317 #ifdef DEBUG
 318 #define DEBC_printk(t, fmt, a...) \
 319         if (debugging) { st_printk(ST_DEB_MSG, t, fmt, ##a ); }
 320 #else
 321 #define DEBC_printk(t, fmt, a...)
 322 #endif
 323
 324 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
 325 {
 326         const u8 *ucp;
 327         const u8 *sense = SRpnt->sense;
 328
 329         s->have_sense = scsi_normalize_sense(SRpnt->sense,
 330                                 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
 331         s->flags = 0;
 332
 333         if (s->have_sense) {
 334                 s->deferred = 0;
 335                 s->remainder_valid =
 336                         scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
 337                 switch (sense[0] & 0x7f) {
 338                 case 0x71:
 339                         s->deferred = 1;
 340                         /* fall through */
 341                 case 0x70:
 342                         s->fixed_format = 1;
 343                         s->flags = sense[2] & 0xe0;
 344                         break;
 345                 case 0x73:
 346                         s->deferred = 1;
 347                         /* fall through */
 348                 case 0x72:
 349                         s->fixed_format = 0;
 350                         ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
 351                         s->flags = ucp ? (ucp[3] & 0xe0) : 0;
 352                         break;
 353                 }
 354         }
 355 }
 356
 357
 358 /* Convert the result to success code */
 359 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
 360 {
 361         int result = SRpnt->result;
 362         u8 scode;
 363         DEB(const char *stp;)
 364         char *name = tape_name(STp);
 365         struct st_cmdstatus *cmdstatp;
 366
 367         if (!result)
 368                 return 0;
 369
 370         cmdstatp = &STp->buffer->cmdstat;
 371         st_analyze_sense(SRpnt, cmdstatp);
 372
 373         if (cmdstatp->have_sense)
 374                 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
 375         else
 376                 scode = 0;
 377
 378         DEB(
 379         if (debugging) {
 380                 st_printk(ST_DEB_MSG, STp,
 381                             "Error: %x, cmd: %x %x %x %x %x %x\n", result,
 382                             SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
 383                             SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
 384                 if (cmdstatp->have_sense)
 385                         __scsi_print_sense(STp->device, name,
 386                                            SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
 387         } ) /* end DEB */
 388         if (!debugging) { /* Abnormal conditions for tape */
 389                 if (!cmdstatp->have_sense)
 390                         st_printk(KERN_WARNING, STp,
 391                                "Error %x (driver bt 0x%x, host bt 0x%x).\n",
 392                                result, driver_byte(result), host_byte(result));
 393                 else if (cmdstatp->have_sense &&
 394                          scode != NO_SENSE &&
 395                          scode != RECOVERED_ERROR &&
 396                          /* scode != UNIT_ATTENTION && */
 397                          scode != BLANK_CHECK &&
 398                          scode != VOLUME_OVERFLOW &&
 399                          SRpnt->cmd[0] != MODE_SENSE &&
 400                          SRpnt->cmd[0] != TEST_UNIT_READY) {
 401
 402                         __scsi_print_sense(STp->device, name,
 403                                            SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
 404                 }
 405         }
 406
 407         if (cmdstatp->fixed_format &&
 408             STp->cln_mode >= EXTENDED_SENSE_START) {  /* Only fixed format sense */
 409                 if (STp->cln_sense_value)
 410                         STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
 411                                                STp->cln_sense_mask) == STp->cln_sense_value);
 412                 else
 413                         STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
 414                                                STp->cln_sense_mask) != 0);
 415         }
 416         if (cmdstatp->have_sense &&
 417             cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
 418                 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
 419
 420         STp->pos_unknown |= STp->device->was_reset;
 421
 422         if (cmdstatp->have_sense &&
 423             scode == RECOVERED_ERROR
 424 #if ST_RECOVERED_WRITE_FATAL
 425             && SRpnt->cmd[0] != WRITE_6
 426             && SRpnt->cmd[0] != WRITE_FILEMARKS
 427 #endif
 428             ) {
 429                 STp->recover_count++;
 430                 STp->recover_reg++;
 431
 432                 DEB(
 433                 if (debugging) {
 434                         if (SRpnt->cmd[0] == READ_6)
 435                                 stp = "read";
 436                         else if (SRpnt->cmd[0] == WRITE_6)
 437                                 stp = "write";
 438                         else
 439                                 stp = "ioctl";
 440                         st_printk(ST_DEB_MSG, STp,
 441                                   "Recovered %s error (%d).\n",
 442                                   stp, STp->recover_count);
 443                 } ) /* end DEB */
 444
 445                 if (cmdstatp->flags == 0)
 446                         return 0;
 447         }
 448         return (-EIO);
 449 }
 450
 451 static struct st_request *st_allocate_request(struct scsi_tape *stp)
 452 {
 453         struct st_request *streq;
 454
 455         streq = kzalloc(sizeof(*streq), GFP_KERNEL);
 456         if (streq)
 457                 streq->stp = stp;
 458         else {
 459                 st_printk(KERN_ERR, stp,
 460                           "Can't get SCSI request.\n");
 461                 if (signal_pending(current))
 462                         stp->buffer->syscall_result = -EINTR;
 463                 else
 464                         stp->buffer->syscall_result = -EBUSY;
 465         }
 466
 467         return streq;
 468 }
 469
 470 static void st_release_request(struct st_request *streq)
 471 {
 472         kfree(streq);
 473 }
 474
 475 static void st_do_stats(struct scsi_tape *STp, struct request *req)
 476 {
 477         ktime_t now;
 478
 479         now = ktime_get();
 480         if (scsi_req(req)->cmd[0] == WRITE_6) {
 481                 now = ktime_sub(now, STp->stats->write_time);
 482                 atomic64_add(ktime_to_ns(now), &STp->stats->tot_write_time);
 483                 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
 484                 atomic64_inc(&STp->stats->write_cnt);
 485                 if (scsi_req(req)->result) {
 486                         atomic64_add(atomic_read(&STp->stats->last_write_size)
 487                                 - STp->buffer->cmdstat.residual,
 488                                 &STp->stats->write_byte_cnt);
 489                         if (STp->buffer->cmdstat.residual > 0)
 490                                 atomic64_inc(&STp->stats->resid_cnt);
 491                 } else
 492                         atomic64_add(atomic_read(&STp->stats->last_write_size),
 493                                 &STp->stats->write_byte_cnt);
 494         } else if (scsi_req(req)->cmd[0] == READ_6) {
 495                 now = ktime_sub(now, STp->stats->read_time);
 496                 atomic64_add(ktime_to_ns(now), &STp->stats->tot_read_time);
 497                 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
 498                 atomic64_inc(&STp->stats->read_cnt);
 499                 if (scsi_req(req)->result) {
 500                         atomic64_add(atomic_read(&STp->stats->last_read_size)
 501                                 - STp->buffer->cmdstat.residual,
 502                                 &STp->stats->read_byte_cnt);
 503                         if (STp->buffer->cmdstat.residual > 0)
 504                                 atomic64_inc(&STp->stats->resid_cnt);
 505                 } else
 506                         atomic64_add(atomic_read(&STp->stats->last_read_size),
 507                                 &STp->stats->read_byte_cnt);
 508         } else {
 509                 now = ktime_sub(now, STp->stats->other_time);
 510                 atomic64_add(ktime_to_ns(now), &STp->stats->tot_io_time);
 511                 atomic64_inc(&STp->stats->other_cnt);
 512         }
 513         atomic64_dec(&STp->stats->in_flight);
 514 }
 515
 516 static void st_scsi_execute_end(struct request *req, blk_status_t status)
 517 {
 518         struct st_request *SRpnt = req->end_io_data;
 519         struct scsi_request *rq = scsi_req(req);
 520         struct scsi_tape *STp = SRpnt->stp;
 521         struct bio *tmp;
 522
 523         STp->buffer->cmdstat.midlevel_result = SRpnt->result = rq->result;
 524         STp->buffer->cmdstat.residual = rq->resid_len;
 525
 526         st_do_stats(STp, req);
 527
 528         tmp = SRpnt->bio;
 529         if (rq->sense_len)
 530                 memcpy(SRpnt->sense, rq->sense, SCSI_SENSE_BUFFERSIZE);
 531         if (SRpnt->waiting)
 532                 complete(SRpnt->waiting);
 533
 534         blk_rq_unmap_user(tmp);
 535         blk_put_request(req);
 536 }
 537
 538 static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
 539                            int data_direction, void *buffer, unsigned bufflen,
 540                            int timeout, int retries)
 541 {
 542         struct request *req;
 543         struct scsi_request *rq;
 544         struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
 545         int err = 0;
 546         struct scsi_tape *STp = SRpnt->stp;
 547
 548         req = blk_get_request(SRpnt->stp->device->request_queue,
 549                         data_direction == DMA_TO_DEVICE ?
 550                         REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
 551         if (IS_ERR(req))
 552                 return DRIVER_ERROR << 24;
 553         rq = scsi_req(req);
 554         req->rq_flags |= RQF_QUIET;
 555
 556         mdata->null_mapped = 1;
 557
 558         if (bufflen) {
 559                 err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen,
 560                                       GFP_KERNEL);
 561                 if (err) {
 562                         blk_put_request(req);
 563                         return DRIVER_ERROR << 24;
 564                 }
 565         }
 566
 567         atomic64_inc(&STp->stats->in_flight);
 568         if (cmd[0] == WRITE_6) {
 569                 atomic_set(&STp->stats->last_write_size, bufflen);
 570                 STp->stats->write_time = ktime_get();
 571         } else if (cmd[0] == READ_6) {
 572                 atomic_set(&STp->stats->last_read_size, bufflen);
 573                 STp->stats->read_time = ktime_get();
 574         } else {
 575                 STp->stats->other_time = ktime_get();
 576         }
 577
 578         SRpnt->bio = req->bio;
 579         rq->cmd_len = COMMAND_SIZE(cmd[0]);
 580         memset(rq->cmd, 0, BLK_MAX_CDB);
 581         memcpy(rq->cmd, cmd, rq->cmd_len);
 582         req->timeout = timeout;
 583         rq->retries = retries;
 584         req->end_io_data = SRpnt;
 585
 586         blk_execute_rq_nowait(req->q, NULL, req, 1, st_scsi_execute_end);
 587         return 0;
 588 }
 589
 590 /* Do the scsi command. Waits until command performed if do_wait is true.
 591    Otherwise write_behind_check() is used to check that the command
 592    has finished. */
 593 static struct st_request *
 594 st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
 595            int bytes, int direction, int timeout, int retries, int do_wait)
 596 {
 597         struct completion *waiting;
 598         struct rq_map_data *mdata = &STp->buffer->map_data;
 599         int ret;
 600
 601         /* if async, make sure there's no command outstanding */
 602         if (!do_wait && ((STp->buffer)->last_SRpnt)) {
 603                 st_printk(KERN_ERR, STp,
 604                           "Async command already active.\n");
 605                 if (signal_pending(current))
 606                         (STp->buffer)->syscall_result = (-EINTR);
 607                 else
 608                         (STp->buffer)->syscall_result = (-EBUSY);
 609                 return NULL;
 610         }
 611
 612         if (!SRpnt) {
 613                 SRpnt = st_allocate_request(STp);
 614                 if (!SRpnt)
 615                         return NULL;
 616         }
 617
 618         /* If async IO, set last_SRpnt. This ptr tells write_behind_check
 619            which IO is outstanding. It's nulled out when the IO completes. */
 620         if (!do_wait)
 621                 (STp->buffer)->last_SRpnt = SRpnt;
 622
 623         waiting = &STp->wait;
 624         init_completion(waiting);
 625         SRpnt->waiting = waiting;
 626
 627         if (STp->buffer->do_dio) {
 628                 mdata->page_order = 0;
 629                 mdata->nr_entries = STp->buffer->sg_segs;
 630                 mdata->pages = STp->buffer->mapped_pages;
 631         } else {
 632                 mdata->page_order = STp->buffer->reserved_page_order;
 633                 mdata->nr_entries =
 634                         DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order);
 635                 mdata->pages = STp->buffer->reserved_pages;
 636                 mdata->offset = 0;
 637         }
 638
 639         memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
 640         STp->buffer->cmdstat.have_sense = 0;
 641         STp->buffer->syscall_result = 0;
 642
 643         ret = st_scsi_execute(SRpnt, cmd, direction, NULL, bytes, timeout,
 644                               retries);
 645         if (ret) {
 646                 /* could not allocate the buffer or request was too large */
 647                 (STp->buffer)->syscall_result = (-EBUSY);
 648                 (STp->buffer)->last_SRpnt = NULL;
 649         } else if (do_wait) {
 650                 wait_for_completion(waiting);
 651                 SRpnt->waiting = NULL;
 652                 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
 653         }
 654
 655         return SRpnt;
 656 }
 657
 658
 659 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
 660    write has been correct but EOM early warning reached, -EIO if write ended in
 661    error or zero if write successful. Asynchronous writes are used only in
 662    variable block mode. */
 663 static int write_behind_check(struct scsi_tape * STp)
 664 {
 665         int retval = 0;
 666         struct st_buffer *STbuffer;
 667         struct st_partstat *STps;
 668         struct st_cmdstatus *cmdstatp;
 669         struct st_request *SRpnt;
 670
 671         STbuffer = STp->buffer;
 672         if (!STbuffer->writing)
 673                 return 0;
 674
 675         DEB(
 676         if (STp->write_pending)
 677                 STp->nbr_waits++;
 678         else
 679                 STp->nbr_finished++;
 680         ) /* end DEB */
 681
 682         wait_for_completion(&(STp->wait));
 683         SRpnt = STbuffer->last_SRpnt;
 684         STbuffer->last_SRpnt = NULL;
 685         SRpnt->waiting = NULL;
 686
 687         (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
 688         st_release_request(SRpnt);
 689
 690         STbuffer->buffer_bytes -= STbuffer->writing;
 691         STps = &(STp->ps[STp->partition]);
 692         if (STps->drv_block >= 0) {
 693                 if (STp->block_size == 0)
 694                         STps->drv_block++;
 695                 else
 696                         STps->drv_block += STbuffer->writing / STp->block_size;
 697         }
 698
 699         cmdstatp = &STbuffer->cmdstat;
 700         if (STbuffer->syscall_result) {
 701                 retval = -EIO;
 702                 if (cmdstatp->have_sense && !cmdstatp->deferred &&
 703                     (cmdstatp->flags & SENSE_EOM) &&
 704                     (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
 705                      cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
 706                         /* EOM at write-behind, has all data been written? */
 707                         if (!cmdstatp->remainder_valid ||
 708                             cmdstatp->uremainder64 == 0)
 709                                 retval = -ENOSPC;
 710                 }
 711                 if (retval == -EIO)
 712                         STps->drv_block = -1;
 713         }
 714         STbuffer->writing = 0;
 715
 716         DEB(if (debugging && retval)
 717                     st_printk(ST_DEB_MSG, STp,
 718                                 "Async write error %x, return value %d.\n",
 719                                 STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
 720
 721         return retval;
 722 }
 723
 724
 725 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
 726    it messes up the block number). */
 727 static int cross_eof(struct scsi_tape * STp, int forward)
 728 {
 729         struct st_request *SRpnt;
 730         unsigned char cmd[MAX_COMMAND_SIZE];
 731
 732         cmd[0] = SPACE;
 733         cmd[1] = 0x01;          /* Space FileMarks */
 734         if (forward) {
 735                 cmd[2] = cmd[3] = 0;
 736                 cmd[4] = 1;
 737         } else
 738                 cmd[2] = cmd[3] = cmd[4] = 0xff;        /* -1 filemarks */
 739         cmd[5] = 0;
 740
 741         DEBC_printk(STp, "Stepping over filemark %s.\n",
 742                     forward ? "forward" : "backward");
 743
 744         SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
 745                            STp->device->request_queue->rq_timeout,
 746                            MAX_RETRIES, 1);
 747         if (!SRpnt)
 748                 return (STp->buffer)->syscall_result;
 749
 750         st_release_request(SRpnt);
 751         SRpnt = NULL;
 752
 753         if ((STp->buffer)->cmdstat.midlevel_result != 0)
 754                 st_printk(KERN_ERR, STp,
 755                           "Stepping over filemark %s failed.\n",
 756                           forward ? "forward" : "backward");
 757
 758         return (STp->buffer)->syscall_result;
 759 }
 760
 761
 762 /* Flush the write buffer (never need to write if variable blocksize). */
 763 static int st_flush_write_buffer(struct scsi_tape * STp)
 764 {
 765         int transfer, blks;
 766         int result;
 767         unsigned char cmd[MAX_COMMAND_SIZE];
 768         struct st_request *SRpnt;
 769         struct st_partstat *STps;
 770
 771         result = write_behind_check(STp);
 772         if (result)
 773                 return result;
 774
 775         result = 0;
 776         if (STp->dirty == 1) {
 777
 778                 transfer = STp->buffer->buffer_bytes;
 779                 DEBC_printk(STp, "Flushing %d bytes.\n", transfer);
 780
 781                 memset(cmd, 0, MAX_COMMAND_SIZE);
 782                 cmd[0] = WRITE_6;
 783                 cmd[1] = 1;
 784                 blks = transfer / STp->block_size;
 785                 cmd[2] = blks >> 16;
 786                 cmd[3] = blks >> 8;
 787                 cmd[4] = blks;
 788
 789                 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
 790                                    STp->device->request_queue->rq_timeout,
 791                                    MAX_WRITE_RETRIES, 1);
 792                 if (!SRpnt)
 793                         return (STp->buffer)->syscall_result;
 794
 795                 STps = &(STp->ps[STp->partition]);
 796                 if ((STp->buffer)->syscall_result != 0) {
 797                         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
 798
 799                         if (cmdstatp->have_sense && !cmdstatp->deferred &&
 800                             (cmdstatp->flags & SENSE_EOM) &&
 801                             (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
 802                              cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
 803                             (!cmdstatp->remainder_valid ||
 804                              cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
 805                                 STp->dirty = 0;
 806                                 (STp->buffer)->buffer_bytes = 0;
 807                                 if (STps->drv_block >= 0)
 808                                         STps->drv_block += blks;
 809                                 result = (-ENOSPC);
 810                         } else {
 811                                 st_printk(KERN_ERR, STp, "Error on flush.\n");
 812                                 STps->drv_block = (-1);
 813                                 result = (-EIO);
 814                         }
 815                 } else {
 816                         if (STps->drv_block >= 0)
 817                                 STps->drv_block += blks;
 818                         STp->dirty = 0;
 819                         (STp->buffer)->buffer_bytes = 0;
 820                 }
 821                 st_release_request(SRpnt);
 822                 SRpnt = NULL;
 823         }
 824         return result;
 825 }
 826
 827
 828 /* Flush the tape buffer. The tape will be positioned correctly unless
 829    seek_next is true. */
 830 static int flush_buffer(struct scsi_tape *STp, int seek_next)
 831 {
 832         int backspace, result;
 833         struct st_partstat *STps;
 834
 835         /*
 836          * If there was a bus reset, block further access
 837          * to this device.
 838          */
 839         if (STp->pos_unknown)
 840                 return (-EIO);
 841
 842         if (STp->ready != ST_READY)
 843                 return 0;
 844         STps = &(STp->ps[STp->partition]);
 845         if (STps->rw == ST_WRITING)     /* Writing */
 846                 return st_flush_write_buffer(STp);
 847
 848         if (STp->block_size == 0)
 849                 return 0;
 850
 851         backspace = ((STp->buffer)->buffer_bytes +
 852                      (STp->buffer)->read_pointer) / STp->block_size -
 853             ((STp->buffer)->read_pointer + STp->block_size - 1) /
 854             STp->block_size;
 855         (STp->buffer)->buffer_bytes = 0;
 856         (STp->buffer)->read_pointer = 0;
 857         result = 0;
 858         if (!seek_next) {
 859                 if (STps->eof == ST_FM_HIT) {
 860                         result = cross_eof(STp, 0);     /* Back over the EOF hit */
 861                         if (!result)
 862                                 STps->eof = ST_NOEOF;
 863                         else {
 864                                 if (STps->drv_file >= 0)
 865                                         STps->drv_file++;
 866                                 STps->drv_block = 0;
 867                         }
 868                 }
 869                 if (!result && backspace > 0)
 870                         result = st_int_ioctl(STp, MTBSR, backspace);
 871         } else if (STps->eof == ST_FM_HIT) {
 872                 if (STps->drv_file >= 0)
 873                         STps->drv_file++;
 874                 STps->drv_block = 0;
 875                 STps->eof = ST_NOEOF;
 876         }
 877         return result;
 878
 879 }
 880 \f
 881 /* Set the mode parameters */
 882 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
 883 {
 884         int set_it = 0;
 885         unsigned long arg;
 886
 887         if (!STp->density_changed &&
 888             STm->default_density >= 0 &&
 889             STm->default_density != STp->density) {
 890                 arg = STm->default_density;
 891                 set_it = 1;
 892         } else
 893                 arg = STp->density;
 894         arg <<= MT_ST_DENSITY_SHIFT;
 895         if (!STp->blksize_changed &&
 896             STm->default_blksize >= 0 &&
 897             STm->default_blksize != STp->block_size) {
 898                 arg |= STm->default_blksize;
 899                 set_it = 1;
 900         } else
 901                 arg |= STp->block_size;
 902         if (set_it &&
 903             st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
 904                 st_printk(KERN_WARNING, STp,
 905                           "Can't set default block size to %d bytes "
 906                           "and density %x.\n",
 907                           STm->default_blksize, STm->default_density);
 908                 if (modes_defined)
 909                         return (-EINVAL);
 910         }
 911         return 0;
 912 }
 913
 914
 915 /* Lock or unlock the drive door. Don't use when st_request allocated. */
 916 static int do_door_lock(struct scsi_tape * STp, int do_lock)
 917 {
 918         int retval;
 919
 920         DEBC_printk(STp, "%socking drive door.\n", do_lock ? "L" : "Unl");
 921
 922         retval = scsi_set_medium_removal(STp->device,
 923                         do_lock ? SCSI_REMOVAL_PREVENT : SCSI_REMOVAL_ALLOW);
 924         if (!retval)
 925                 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
 926         else
 927                 STp->door_locked = ST_LOCK_FAILS;
 928         return retval;
 929 }
 930
 931
 932 /* Set the internal state after reset */
 933 static void reset_state(struct scsi_tape *STp)
 934 {
 935         int i;
 936         struct st_partstat *STps;
 937
 938         STp->pos_unknown = 0;
 939         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
 940                 STps = &(STp->ps[i]);
 941                 STps->rw = ST_IDLE;
 942                 STps->eof = ST_NOEOF;
 943                 STps->at_sm = 0;
 944                 STps->last_block_valid = 0;
 945                 STps->drv_block = -1;
 946                 STps->drv_file = -1;
 947         }
 948         if (STp->can_partitions) {
 949                 STp->partition = find_partition(STp);
 950                 if (STp->partition < 0)
 951                         STp->partition = 0;
 952                 STp->new_partition = STp->partition;
 953         }
 954 }
 955 \f
 956 /* Test if the drive is ready. Returns either one of the codes below or a negative system
 957    error code. */
 958 #define CHKRES_READY       0
 959 #define CHKRES_NEW_SESSION 1
 960 #define CHKRES_NOT_READY   2
 961 #define CHKRES_NO_TAPE     3
 962
 963 #define MAX_ATTENTIONS    10
 964
 965 static int test_ready(struct scsi_tape *STp, int do_wait)
 966 {
 967         int attentions, waits, max_wait, scode;
 968         int retval = CHKRES_READY, new_session = 0;
 969         unsigned char cmd[MAX_COMMAND_SIZE];
 970         struct st_request *SRpnt = NULL;
 971         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
 972
 973         max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
 974
 975         for (attentions=waits=0; ; ) {
 976                 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
 977                 cmd[0] = TEST_UNIT_READY;
 978                 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
 979                                    STp->long_timeout, MAX_READY_RETRIES, 1);
 980
 981                 if (!SRpnt) {
 982                         retval = (STp->buffer)->syscall_result;
 983                         break;
 984                 }
 985
 986                 if (cmdstatp->have_sense) {
 987
 988                         scode = cmdstatp->sense_hdr.sense_key;
 989
 990                         if (scode == UNIT_ATTENTION) { /* New media? */
 991                                 new_session = 1;
 992                                 if (attentions < MAX_ATTENTIONS) {
 993                                         attentions++;
 994                                         continue;
 995                                 }
 996                                 else {
 997                                         retval = (-EIO);
 998                                         break;
 999                                 }
1000                         }
1001
1002                         if (scode == NOT_READY) {
1003                                 if (waits < max_wait) {
1004                                         if (msleep_interruptible(1000)) {
1005                                                 retval = (-EINTR);
1006                                                 break;
1007                                         }
1008                                         waits++;
1009                                         continue;
1010                                 }
1011                                 else {
1012                                         if ((STp->device)->scsi_level >= SCSI_2 &&
1013                                             cmdstatp->sense_hdr.asc == 0x3a)    /* Check ASC */
1014                                                 retval = CHKRES_NO_TAPE;
1015                                         else
1016                                                 retval = CHKRES_NOT_READY;
1017                                         break;
1018                                 }
1019                         }
1020                 }
1021
1022                 retval = (STp->buffer)->syscall_result;
1023                 if (!retval)
1024                         retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
1025                 break;
1026         }
1027
1028         if (SRpnt != NULL)
1029                 st_release_request(SRpnt);
1030         return retval;
1031 }
1032
1033
1034 /* See if the drive is ready and gather information about the tape. Return values:
1035    < 0   negative error code from errno.h
1036    0     drive ready
1037    1     drive not ready (possibly no tape)
1038 */
1039 static int check_tape(struct scsi_tape *STp, struct file *filp)
1040 {
1041         int i, retval, new_session = 0, do_wait;
1042         unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
1043         unsigned short st_flags = filp->f_flags;
1044         struct st_request *SRpnt = NULL;
1045         struct st_modedef *STm;
1046         struct st_partstat *STps;
1047         struct inode *inode = file_inode(filp);
1048         int mode = TAPE_MODE(inode);
1049
1050         STp->ready = ST_READY;
1051
1052         if (mode != STp->current_mode) {
1053                 DEBC_printk(STp, "Mode change from %d to %d.\n",
1054                             STp->current_mode, mode);
1055                 new_session = 1;
1056                 STp->current_mode = mode;
1057         }
1058         STm = &(STp->modes[STp->current_mode]);
1059
1060         saved_cleaning = STp->cleaning_req;
1061         STp->cleaning_req = 0;
1062
1063         do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
1064         retval = test_ready(STp, do_wait);
1065
1066         if (retval < 0)
1067             goto err_out;
1068
1069         if (retval == CHKRES_NEW_SESSION) {
1070                 STp->pos_unknown = 0;
1071                 STp->partition = STp->new_partition = 0;
1072                 if (STp->can_partitions)
1073                         STp->nbr_partitions = 1; /* This guess will be updated later
1074                                                     if necessary */
1075                 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1076                         STps = &(STp->ps[i]);
1077                         STps->rw = ST_IDLE;
1078                         STps->eof = ST_NOEOF;
1079                         STps->at_sm = 0;
1080                         STps->last_block_valid = 0;
1081                         STps->drv_block = 0;
1082                         STps->drv_file = 0;
1083                 }
1084                 new_session = 1;
1085         }
1086         else {
1087                 STp->cleaning_req |= saved_cleaning;
1088
1089                 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
1090                         if (retval == CHKRES_NO_TAPE)
1091                                 STp->ready = ST_NO_TAPE;
1092                         else
1093                                 STp->ready = ST_NOT_READY;
1094
1095                         STp->density = 0;       /* Clear the erroneous "residue" */
1096                         STp->write_prot = 0;
1097                         STp->block_size = 0;
1098                         STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
1099                         STp->partition = STp->new_partition = 0;
1100                         STp->door_locked = ST_UNLOCKED;
1101                         return CHKRES_NOT_READY;
1102                 }
1103         }
1104
1105         if (STp->omit_blklims)
1106                 STp->min_block = STp->max_block = (-1);
1107         else {
1108                 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1109                 cmd[0] = READ_BLOCK_LIMITS;
1110
1111                 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
1112                                    STp->device->request_queue->rq_timeout,
1113                                    MAX_READY_RETRIES, 1);
1114                 if (!SRpnt) {
1115                         retval = (STp->buffer)->syscall_result;
1116                         goto err_out;
1117                 }
1118
1119                 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
1120                         STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1121                             ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1122                         STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1123                             (STp->buffer)->b_data[5];
1124                         if ( DEB( debugging || ) !STp->inited)
1125                                 st_printk(KERN_INFO, STp,
1126                                           "Block limits %d - %d bytes.\n",
1127                                           STp->min_block, STp->max_block);
1128                 } else {
1129                         STp->min_block = STp->max_block = (-1);
1130                         DEBC_printk(STp, "Can't read block limits.\n");
1131                 }
1132         }
1133
1134         memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1135         cmd[0] = MODE_SENSE;
1136         cmd[4] = 12;
1137
1138         SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1139                            STp->device->request_queue->rq_timeout,
1140                            MAX_READY_RETRIES, 1);
1141         if (!SRpnt) {
1142                 retval = (STp->buffer)->syscall_result;
1143                 goto err_out;
1144         }
1145
1146         if ((STp->buffer)->syscall_result != 0) {
1147                 DEBC_printk(STp, "No Mode Sense.\n");
1148                 STp->block_size = ST_DEFAULT_BLOCK;     /* Educated guess (?) */
1149                 (STp->buffer)->syscall_result = 0;      /* Prevent error propagation */
1150                 STp->drv_write_prot = 0;
1151         } else {
1152                 DEBC_printk(STp,"Mode sense. Length %d, "
1153                             "medium %x, WBS %x, BLL %d\n",
1154                             (STp->buffer)->b_data[0],
1155                             (STp->buffer)->b_data[1],
1156                             (STp->buffer)->b_data[2],
1157                             (STp->buffer)->b_data[3]);
1158
1159                 if ((STp->buffer)->b_data[3] >= 8) {
1160                         STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1161                         STp->density = (STp->buffer)->b_data[4];
1162                         STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1163                             (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1164                         DEBC_printk(STp, "Density %x, tape length: %x, "
1165                                     "drv buffer: %d\n",
1166                                     STp->density,
1167                                     (STp->buffer)->b_data[5] * 65536 +
1168                                     (STp->buffer)->b_data[6] * 256 +
1169                                     (STp->buffer)->b_data[7],
1170                                     STp->drv_buffer);
1171                 }
1172                 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1173                 if (!STp->drv_buffer && STp->immediate_filemark) {
1174                         st_printk(KERN_WARNING, STp,
1175                                   "non-buffered tape: disabling "
1176                                   "writing immediate filemarks\n");
1177                         STp->immediate_filemark = 0;
1178                 }
1179         }
1180         st_release_request(SRpnt);
1181         SRpnt = NULL;
1182         STp->inited = 1;
1183
1184         if (STp->block_size > 0)
1185                 (STp->buffer)->buffer_blocks =
1186                         (STp->buffer)->buffer_size / STp->block_size;
1187         else
1188                 (STp->buffer)->buffer_blocks = 1;
1189         (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1190
1191         DEBC_printk(STp, "Block size: %d, buffer size: %d (%d blocks).\n",
1192                     STp->block_size, (STp->buffer)->buffer_size,
1193                     (STp->buffer)->buffer_blocks);
1194
1195         if (STp->drv_write_prot) {
1196                 STp->write_prot = 1;
1197
1198                 DEBC_printk(STp, "Write protected\n");
1199
1200                 if (do_wait &&
1201                     ((st_flags & O_ACCMODE) == O_WRONLY ||
1202                      (st_flags & O_ACCMODE) == O_RDWR)) {
1203                         retval = (-EROFS);
1204                         goto err_out;
1205                 }
1206         }
1207
1208         if (STp->can_partitions && STp->nbr_partitions < 1) {
1209                 /* This code is reached when the device is opened for the first time
1210                    after the driver has been initialized with tape in the drive and the
1211                    partition support has been enabled. */
1212                 DEBC_printk(STp, "Updating partition number in status.\n");
1213                 if ((STp->partition = find_partition(STp)) < 0) {
1214                         retval = STp->partition;
1215                         goto err_out;
1216                 }
1217                 STp->new_partition = STp->partition;
1218                 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1219         }
1220
1221         if (new_session) {      /* Change the drive parameters for the new mode */
1222                 STp->density_changed = STp->blksize_changed = 0;
1223                 STp->compression_changed = 0;
1224                 if (!(STm->defaults_for_writes) &&
1225                     (retval = set_mode_densblk(STp, STm)) < 0)
1226                     goto err_out;
1227
1228                 if (STp->default_drvbuffer != 0xff) {
1229                         if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1230                                 st_printk(KERN_WARNING, STp,
1231                                           "Can't set default drive "
1232                                           "buffering to %d.\n",
1233                                           STp->default_drvbuffer);
1234                 }
1235         }
1236
1237         return CHKRES_READY;
1238
1239  err_out:
1240         return retval;
1241 }
1242
1243
1244 \f/* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1245    module count. */
1246 static int st_open(struct inode *inode, struct file *filp)
1247 {
1248         int i, retval = (-EIO);
1249         int resumed = 0;
1250         struct scsi_tape *STp;
1251         struct st_partstat *STps;
1252         int dev = TAPE_NR(inode);
1253
1254         /*
1255          * We really want to do nonseekable_open(inode, filp); here, but some
1256          * versions of tar incorrectly call lseek on tapes and bail out if that
1257          * fails.  So we disallow pread() and pwrite(), but permit lseeks.
1258          */
1259         filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1260
1261         if (!(STp = scsi_tape_get(dev))) {
1262                 return -ENXIO;
1263         }
1264
1265         filp->private_data = STp;
1266
1267         spin_lock(&st_use_lock);
1268         if (STp->in_use) {
1269                 spin_unlock(&st_use_lock);
1270                 scsi_tape_put(STp);
1271                 DEBC_printk(STp, "Device already in use.\n");
1272                 return (-EBUSY);
1273         }
1274
1275         STp->in_use = 1;
1276         spin_unlock(&st_use_lock);
1277         STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1278
1279         if (scsi_autopm_get_device(STp->device) < 0) {
1280                 retval = -EIO;
1281                 goto err_out;
1282         }
1283         resumed = 1;
1284         if (!scsi_block_when_processing_errors(STp->device)) {
1285                 retval = (-ENXIO);
1286                 goto err_out;
1287         }
1288
1289         /* See that we have at least a one page buffer available */
1290         if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1291                 st_printk(KERN_WARNING, STp,
1292                           "Can't allocate one page tape buffer.\n");
1293                 retval = (-EOVERFLOW);
1294                 goto err_out;
1295         }
1296
1297         (STp->buffer)->cleared = 0;
1298         (STp->buffer)->writing = 0;
1299         (STp->buffer)->syscall_result = 0;
1300
1301         STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1302
1303         STp->dirty = 0;
1304         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1305                 STps = &(STp->ps[i]);
1306                 STps->rw = ST_IDLE;
1307         }
1308         STp->try_dio_now = STp->try_dio;
1309         STp->recover_count = 0;
1310         DEB( STp->nbr_waits = STp->nbr_finished = 0;
1311              STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
1312
1313         retval = check_tape(STp, filp);
1314         if (retval < 0)
1315                 goto err_out;
1316         if ((filp->f_flags & O_NONBLOCK) == 0 &&
1317             retval != CHKRES_READY) {
1318                 if (STp->ready == NO_TAPE)
1319                         retval = (-ENOMEDIUM);
1320                 else
1321                         retval = (-EIO);
1322                 goto err_out;
1323         }
1324         return 0;
1325
1326  err_out:
1327         normalize_buffer(STp->buffer);
1328         spin_lock(&st_use_lock);
1329         STp->in_use = 0;
1330         spin_unlock(&st_use_lock);
1331         if (resumed)
1332                 scsi_autopm_put_device(STp->device);
1333         scsi_tape_put(STp);
1334         return retval;
1335
1336 }
1337 \f
1338
1339 /* Flush the tape buffer before close */
1340 static int st_flush(struct file *filp, fl_owner_t id)
1341 {
1342         int result = 0, result2;
1343         unsigned char cmd[MAX_COMMAND_SIZE];
1344         struct st_request *SRpnt;
1345         struct scsi_tape *STp = filp->private_data;
1346         struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1347         struct st_partstat *STps = &(STp->ps[STp->partition]);
1348
1349         if (file_count(filp) > 1)
1350                 return 0;
1351
1352         if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1353                 result = st_flush_write_buffer(STp);
1354                 if (result != 0 && result != (-ENOSPC))
1355                         goto out;
1356         }
1357
1358         if (STp->can_partitions &&
1359             (result2 = switch_partition(STp)) < 0) {
1360                 DEBC_printk(STp, "switch_partition at close failed.\n");
1361                 if (result == 0)
1362                         result = result2;
1363                 goto out;
1364         }
1365
1366         DEBC( if (STp->nbr_requests)
1367                 st_printk(KERN_DEBUG, STp,
1368                           "Number of r/w requests %d, dio used in %d, "
1369                           "pages %d.\n", STp->nbr_requests, STp->nbr_dio,
1370                           STp->nbr_pages));
1371
1372         if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1373                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1374
1375 #if DEBUG
1376                 DEBC_printk(STp, "Async write waits %d, finished %d.\n",
1377                             STp->nbr_waits, STp->nbr_finished);
1378 #endif
1379                 memset(cmd, 0, MAX_COMMAND_SIZE);
1380                 cmd[0] = WRITE_FILEMARKS;
1381                 if (STp->immediate_filemark)
1382                         cmd[1] = 1;
1383                 cmd[4] = 1 + STp->two_fm;
1384
1385                 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1386                                    STp->device->request_queue->rq_timeout,
1387                                    MAX_WRITE_RETRIES, 1);
1388                 if (!SRpnt) {
1389                         result = (STp->buffer)->syscall_result;
1390                         goto out;
1391                 }
1392
1393                 if (STp->buffer->syscall_result == 0 ||
1394                     (cmdstatp->have_sense && !cmdstatp->deferred &&
1395                      (cmdstatp->flags & SENSE_EOM) &&
1396                      (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1397                       cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1398                      (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1399                         /* Write successful at EOM */
1400                         st_release_request(SRpnt);
1401                         SRpnt = NULL;
1402                         if (STps->drv_file >= 0)
1403                                 STps->drv_file++;
1404                         STps->drv_block = 0;
1405                         if (STp->two_fm)
1406                                 cross_eof(STp, 0);
1407                         STps->eof = ST_FM;
1408                 }
1409                 else { /* Write error */
1410                         st_release_request(SRpnt);
1411                         SRpnt = NULL;
1412                         st_printk(KERN_ERR, STp,
1413                                   "Error on write filemark.\n");
1414                         if (result == 0)
1415                                 result = (-EIO);
1416                 }
1417
1418                 DEBC_printk(STp, "Buffer flushed, %d EOF(s) written\n", cmd[4]);
1419         } else if (!STp->rew_at_close) {
1420                 STps = &(STp->ps[STp->partition]);
1421                 if (!STm->sysv || STps->rw != ST_READING) {
1422                         if (STp->can_bsr)
1423                                 result = flush_buffer(STp, 0);
1424                         else if (STps->eof == ST_FM_HIT) {
1425                                 result = cross_eof(STp, 0);
1426                                 if (result) {
1427                                         if (STps->drv_file >= 0)
1428                                                 STps->drv_file++;
1429                                         STps->drv_block = 0;
1430                                         STps->eof = ST_FM;
1431                                 } else
1432                                         STps->eof = ST_NOEOF;
1433                         }
1434                 } else if ((STps->eof == ST_NOEOF &&
1435                             !(result = cross_eof(STp, 1))) ||
1436                            STps->eof == ST_FM_HIT) {
1437                         if (STps->drv_file >= 0)
1438                                 STps->drv_file++;
1439                         STps->drv_block = 0;
1440                         STps->eof = ST_FM;
1441                 }
1442         }
1443
1444       out:
1445         if (STp->rew_at_close) {
1446                 result2 = st_int_ioctl(STp, MTREW, 1);
1447                 if (result == 0)
1448                         result = result2;
1449         }
1450         return result;
1451 }
1452
1453
1454 /* Close the device and release it. BKL is not needed: this is the only thread
1455    accessing this tape. */
1456 static int st_release(struct inode *inode, struct file *filp)
1457 {
1458         int result = 0;
1459         struct scsi_tape *STp = filp->private_data;
1460
1461         if (STp->door_locked == ST_LOCKED_AUTO)
1462                 do_door_lock(STp, 0);
1463
1464         normalize_buffer(STp->buffer);
1465         spin_lock(&st_use_lock);
1466         STp->in_use = 0;
1467         spin_unlock(&st_use_lock);
1468         scsi_autopm_put_device(STp->device);
1469         scsi_tape_put(STp);
1470
1471         return result;
1472 }
1473 \f
1474 /* The checks common to both reading and writing */
1475 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1476 {
1477         ssize_t retval = 0;
1478
1479         /*
1480          * If we are in the middle of error recovery, don't let anyone
1481          * else try and use this device.  Also, if error recovery fails, it
1482          * may try and take the device offline, in which case all further
1483          * access to the device is prohibited.
1484          */
1485         if (!scsi_block_when_processing_errors(STp->device)) {
1486                 retval = (-ENXIO);
1487                 goto out;
1488         }
1489
1490         if (STp->ready != ST_READY) {
1491                 if (STp->ready == ST_NO_TAPE)
1492                         retval = (-ENOMEDIUM);
1493                 else
1494                         retval = (-EIO);
1495                 goto out;
1496         }
1497
1498         if (! STp->modes[STp->current_mode].defined) {
1499                 retval = (-ENXIO);
1500                 goto out;
1501         }
1502
1503
1504         /*
1505          * If there was a bus reset, block further access
1506          * to this device.
1507          */
1508         if (STp->pos_unknown) {
1509                 retval = (-EIO);
1510                 goto out;
1511         }
1512
1513         if (count == 0)
1514                 goto out;
1515
1516         DEB(
1517         if (!STp->in_use) {
1518                 st_printk(ST_DEB_MSG, STp,
1519                           "Incorrect device.\n");
1520                 retval = (-EIO);
1521                 goto out;
1522         } ) /* end DEB */
1523
1524         if (STp->can_partitions &&
1525             (retval = switch_partition(STp)) < 0)
1526                 goto out;
1527
1528         if (STp->block_size == 0 && STp->max_block > 0 &&
1529             (count < STp->min_block || count > STp->max_block)) {
1530                 retval = (-EINVAL);
1531                 goto out;
1532         }
1533
1534         if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1535             !do_door_lock(STp, 1))
1536                 STp->door_locked = ST_LOCKED_AUTO;
1537
1538  out:
1539         return retval;
1540 }
1541
1542
1543 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1544                            size_t count, int is_read)
1545 {
1546         int i, bufsize, retval = 0;
1547         struct st_buffer *STbp = STp->buffer;
1548
1549         if (is_read)
1550                 i = STp->try_dio_now && try_rdio;
1551         else
1552                 i = STp->try_dio_now && try_wdio;
1553
1554         if (i && ((unsigned long)buf & queue_dma_alignment(
1555                                         STp->device->request_queue)) == 0) {
1556                 i = sgl_map_user_pages(STbp, STbp->use_sg, (unsigned long)buf,
1557                                        count, (is_read ? READ : WRITE));
1558                 if (i > 0) {
1559                         STbp->do_dio = i;
1560                         STbp->buffer_bytes = 0;   /* can be used as transfer counter */
1561                 }
1562                 else
1563                         STbp->do_dio = 0;  /* fall back to buffering with any error */
1564                 STbp->sg_segs = STbp->do_dio;
1565                 DEB(
1566                      if (STbp->do_dio) {
1567                         STp->nbr_dio++;
1568                         STp->nbr_pages += STbp->do_dio;
1569                      }
1570                 )
1571         } else
1572                 STbp->do_dio = 0;
1573         DEB( STp->nbr_requests++; )
1574
1575         if (!STbp->do_dio) {
1576                 if (STp->block_size)
1577                         bufsize = STp->block_size > st_fixed_buffer_size ?
1578                                 STp->block_size : st_fixed_buffer_size;
1579                 else {
1580                         bufsize = count;
1581                         /* Make sure that data from previous user is not leaked even if
1582                            HBA does not return correct residual */
1583                         if (is_read && STp->sili && !STbp->cleared)
1584                                 clear_buffer(STbp);
1585                 }
1586
1587                 if (bufsize > STbp->buffer_size &&
1588                     !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1589                         st_printk(KERN_WARNING, STp,
1590                                   "Can't allocate %d byte tape buffer.\n",
1591                                   bufsize);
1592                         retval = (-EOVERFLOW);
1593                         goto out;
1594                 }
1595                 if (STp->block_size)
1596                         STbp->buffer_blocks = bufsize / STp->block_size;
1597         }
1598
1599  out:
1600         return retval;
1601 }
1602
1603
1604 /* Can be called more than once after each setup_buffer() */
1605 static void release_buffering(struct scsi_tape *STp, int is_read)
1606 {
1607         struct st_buffer *STbp;
1608
1609         STbp = STp->buffer;
1610         if (STbp->do_dio) {
1611                 sgl_unmap_user_pages(STbp, STbp->do_dio, is_read);
1612                 STbp->do_dio = 0;
1613                 STbp->sg_segs = 0;
1614         }
1615 }
1616
1617
1618 /* Write command */
1619 static ssize_t
1620 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1621 {
1622         ssize_t total;
1623         ssize_t i, do_count, blks, transfer;
1624         ssize_t retval;
1625         int undone, retry_eot = 0, scode;
1626         int async_write;
1627         unsigned char cmd[MAX_COMMAND_SIZE];
1628         const char __user *b_point;
1629         struct st_request *SRpnt = NULL;
1630         struct scsi_tape *STp = filp->private_data;
1631         struct st_modedef *STm;
1632         struct st_partstat *STps;
1633         struct st_buffer *STbp;
1634
1635         if (mutex_lock_interruptible(&STp->lock))
1636                 return -ERESTARTSYS;
1637
1638         retval = rw_checks(STp, filp, count);
1639         if (retval || count == 0)
1640                 goto out;
1641
1642         /* Write must be integral number of blocks */
1643         if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1644                 st_printk(KERN_WARNING, STp,
1645                           "Write not multiple of tape block size.\n");
1646                 retval = (-EINVAL);
1647                 goto out;
1648         }
1649
1650         STm = &(STp->modes[STp->current_mode]);
1651         STps = &(STp->ps[STp->partition]);
1652
1653         if (STp->write_prot) {
1654                 retval = (-EACCES);
1655                 goto out;
1656         }
1657
1658
1659         if (STps->rw == ST_READING) {
1660                 retval = flush_buffer(STp, 0);
1661                 if (retval)
1662                         goto out;
1663                 STps->rw = ST_WRITING;
1664         } else if (STps->rw != ST_WRITING &&
1665                    STps->drv_file == 0 && STps->drv_block == 0) {
1666                 if ((retval = set_mode_densblk(STp, STm)) < 0)
1667                         goto out;
1668                 if (STm->default_compression != ST_DONT_TOUCH &&
1669                     !(STp->compression_changed)) {
1670                         if (st_compression(STp, (STm->default_compression == ST_YES))) {
1671                                 st_printk(KERN_WARNING, STp,
1672                                           "Can't set default compression.\n");
1673                                 if (modes_defined) {
1674                                         retval = (-EINVAL);
1675                                         goto out;
1676                                 }
1677                         }
1678                 }
1679         }
1680
1681         STbp = STp->buffer;
1682         i = write_behind_check(STp);
1683         if (i) {
1684                 if (i == -ENOSPC)
1685                         STps->eof = ST_EOM_OK;
1686                 else
1687                         STps->eof = ST_EOM_ERROR;
1688         }
1689
1690         if (STps->eof == ST_EOM_OK) {
1691                 STps->eof = ST_EOD_1;  /* allow next write */
1692                 retval = (-ENOSPC);
1693                 goto out;
1694         }
1695         else if (STps->eof == ST_EOM_ERROR) {
1696                 retval = (-EIO);
1697                 goto out;
1698         }
1699
1700         /* Check the buffer readability in cases where copy_user might catch
1701            the problems after some tape movement. */
1702         if (STp->block_size != 0 &&
1703             !STbp->do_dio &&
1704             (copy_from_user(&i, buf, 1) != 0 ||
1705              copy_from_user(&i, buf + count - 1, 1) != 0)) {
1706                 retval = (-EFAULT);
1707                 goto out;
1708         }
1709
1710         retval = setup_buffering(STp, buf, count, 0);
1711         if (retval)
1712                 goto out;
1713
1714         total = count;
1715
1716         memset(cmd, 0, MAX_COMMAND_SIZE);
1717         cmd[0] = WRITE_6;
1718         cmd[1] = (STp->block_size != 0);
1719
1720         STps->rw = ST_WRITING;
1721
1722         b_point = buf;
1723         while (count > 0 && !retry_eot) {
1724
1725                 if (STbp->do_dio) {
1726                         do_count = count;
1727                 }
1728                 else {
1729                         if (STp->block_size == 0)
1730                                 do_count = count;
1731                         else {
1732                                 do_count = STbp->buffer_blocks * STp->block_size -
1733                                         STbp->buffer_bytes;
1734                                 if (do_count > count)
1735                                         do_count = count;
1736                         }
1737
1738                         i = append_to_buffer(b_point, STbp, do_count);
1739                         if (i) {
1740                                 retval = i;
1741                                 goto out;
1742                         }
1743                 }
1744                 count -= do_count;
1745                 b_point += do_count;
1746
1747                 async_write = STp->block_size == 0 && !STbp->do_dio &&
1748                         STm->do_async_writes && STps->eof < ST_EOM_OK;
1749
1750                 if (STp->block_size != 0 && STm->do_buffer_writes &&
1751                     !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1752                     STbp->buffer_bytes < STbp->buffer_size) {
1753                         STp->dirty = 1;
1754                         /* Don't write a buffer that is not full enough. */
1755                         if (!async_write && count == 0)
1756                                 break;
1757                 }
1758
1759         retry_write:
1760                 if (STp->block_size == 0)
1761                         blks = transfer = do_count;
1762                 else {
1763                         if (!STbp->do_dio)
1764                                 blks = STbp->buffer_bytes;
1765                         else
1766                                 blks = do_count;
1767                         blks /= STp->block_size;
1768                         transfer = blks * STp->block_size;
1769                 }
1770                 cmd[2] = blks >> 16;
1771                 cmd[3] = blks >> 8;
1772                 cmd[4] = blks;
1773
1774                 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1775                                    STp->device->request_queue->rq_timeout,
1776                                    MAX_WRITE_RETRIES, !async_write);
1777                 if (!SRpnt) {
1778                         retval = STbp->syscall_result;
1779                         goto out;
1780                 }
1781                 if (async_write && !STbp->syscall_result) {
1782                         STbp->writing = transfer;
1783                         STp->dirty = !(STbp->writing ==
1784                                        STbp->buffer_bytes);
1785                         SRpnt = NULL;  /* Prevent releasing this request! */
1786                         DEB( STp->write_pending = 1; )
1787                         break;
1788                 }
1789
1790                 if (STbp->syscall_result != 0) {
1791                         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1792
1793                         DEBC_printk(STp, "Error on write:\n");
1794                         if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1795                                 scode = cmdstatp->sense_hdr.sense_key;
1796                                 if (cmdstatp->remainder_valid)
1797                                         undone = (int)cmdstatp->uremainder64;
1798                                 else if (STp->block_size == 0 &&
1799                                          scode == VOLUME_OVERFLOW)
1800                                         undone = transfer;
1801                                 else
1802                                         undone = 0;
1803                                 if (STp->block_size != 0)
1804                                         undone *= STp->block_size;
1805                                 if (undone <= do_count) {
1806                                         /* Only data from this write is not written */
1807                                         count += undone;
1808                                         b_point -= undone;
1809                                         do_count -= undone;
1810                                         if (STp->block_size)
1811                                                 blks = (transfer - undone) / STp->block_size;
1812                                         STps->eof = ST_EOM_OK;
1813                                         /* Continue in fixed block mode if all written
1814                                            in this request but still something left to write
1815                                            (retval left to zero)
1816                                         */
1817                                         if (STp->block_size == 0 ||
1818                                             undone > 0 || count == 0)
1819                                                 retval = (-ENOSPC); /* EOM within current request */
1820                                         DEBC_printk(STp, "EOM with %d "
1821                                                     "bytes unwritten.\n",
1822                                                     (int)count);
1823                                 } else {
1824                                         /* EOT within data buffered earlier (possible only
1825                                            in fixed block mode without direct i/o) */
1826                                         if (!retry_eot && !cmdstatp->deferred &&
1827                                             (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1828                                                 move_buffer_data(STp->buffer, transfer - undone);
1829                                                 retry_eot = 1;
1830                                                 if (STps->drv_block >= 0) {
1831                                                         STps->drv_block += (transfer - undone) /
1832                                                                 STp->block_size;
1833                                                 }
1834                                                 STps->eof = ST_EOM_OK;
1835                                                 DEBC_printk(STp, "Retry "
1836                                                             "write of %d "
1837                                                             "bytes at EOM.\n",
1838                                                             STp->buffer->buffer_bytes);
1839                                                 goto retry_write;
1840                                         }
1841                                         else {
1842                                                 /* Either error within data buffered by driver or
1843                                                    failed retry */
1844                                                 count -= do_count;
1845                                                 blks = do_count = 0;
1846                                                 STps->eof = ST_EOM_ERROR;
1847                                                 STps->drv_block = (-1); /* Too cautious? */
1848                                                 retval = (-EIO);        /* EOM for old data */
1849                                                 DEBC_printk(STp, "EOM with "
1850                                                             "lost data.\n");
1851                                         }
1852                                 }
1853                         } else {
1854                                 count += do_count;
1855                                 STps->drv_block = (-1);         /* Too cautious? */
1856                                 retval = STbp->syscall_result;
1857                         }
1858
1859                 }
1860
1861                 if (STps->drv_block >= 0) {
1862                         if (STp->block_size == 0)
1863                                 STps->drv_block += (do_count > 0);
1864                         else
1865                                 STps->drv_block += blks;
1866                 }
1867
1868                 STbp->buffer_bytes = 0;
1869                 STp->dirty = 0;
1870
1871                 if (retval || retry_eot) {
1872                         if (count < total)
1873                                 retval = total - count;
1874                         goto out;
1875                 }
1876         }
1877
1878         if (STps->eof == ST_EOD_1)
1879                 STps->eof = ST_EOM_OK;
1880         else if (STps->eof != ST_EOM_OK)
1881                 STps->eof = ST_NOEOF;
1882         retval = total - count;
1883
1884  out:
1885         if (SRpnt != NULL)
1886                 st_release_request(SRpnt);
1887         release_buffering(STp, 0);
1888         mutex_unlock(&STp->lock);
1889
1890         return retval;
1891 }
1892 \f
1893 /* Read data from the tape. Returns zero in the normal case, one if the
1894    eof status has changed, and the negative error code in case of a
1895    fatal error. Otherwise updates the buffer and the eof state.
1896
1897    Does release user buffer mapping if it is set.
1898 */
1899 static long read_tape(struct scsi_tape *STp, long count,
1900                       struct st_request ** aSRpnt)
1901 {
1902         int transfer, blks, bytes;
1903         unsigned char cmd[MAX_COMMAND_SIZE];
1904         struct st_request *SRpnt;
1905         struct st_modedef *STm;
1906         struct st_partstat *STps;
1907         struct st_buffer *STbp;
1908         int retval = 0;
1909
1910         if (count == 0)
1911                 return 0;
1912
1913         STm = &(STp->modes[STp->current_mode]);
1914         STps = &(STp->ps[STp->partition]);
1915         if (STps->eof == ST_FM_HIT)
1916                 return 1;
1917         STbp = STp->buffer;
1918
1919         if (STp->block_size == 0)
1920                 blks = bytes = count;
1921         else {
1922                 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1923                         blks = (STp->buffer)->buffer_blocks;
1924                         bytes = blks * STp->block_size;
1925                 } else {
1926                         bytes = count;
1927                         if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1928                                 bytes = (STp->buffer)->buffer_size;
1929                         blks = bytes / STp->block_size;
1930                         bytes = blks * STp->block_size;
1931                 }
1932         }
1933
1934         memset(cmd, 0, MAX_COMMAND_SIZE);
1935         cmd[0] = READ_6;
1936         cmd[1] = (STp->block_size != 0);
1937         if (!cmd[1] && STp->sili)
1938                 cmd[1] |= 2;
1939         cmd[2] = blks >> 16;
1940         cmd[3] = blks >> 8;
1941         cmd[4] = blks;
1942
1943         SRpnt = *aSRpnt;
1944         SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1945                            STp->device->request_queue->rq_timeout,
1946                            MAX_RETRIES, 1);
1947         release_buffering(STp, 1);
1948         *aSRpnt = SRpnt;
1949         if (!SRpnt)
1950                 return STbp->syscall_result;
1951
1952         STbp->read_pointer = 0;
1953         STps->at_sm = 0;
1954
1955         /* Something to check */
1956         if (STbp->syscall_result) {
1957                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1958
1959                 retval = 1;
1960                 DEBC_printk(STp,
1961                             "Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1962                             SRpnt->sense[0], SRpnt->sense[1],
1963                             SRpnt->sense[2], SRpnt->sense[3],
1964                             SRpnt->sense[4], SRpnt->sense[5],
1965                             SRpnt->sense[6], SRpnt->sense[7]);
1966                 if (cmdstatp->have_sense) {
1967
1968                         if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1969                                 cmdstatp->flags &= 0xcf;        /* No need for EOM in this case */
1970
1971                         if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1972                                 /* Compute the residual count */
1973                                 if (cmdstatp->remainder_valid)
1974                                         transfer = (int)cmdstatp->uremainder64;
1975                                 else
1976                                         transfer = 0;
1977                                 if (cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR) {
1978                                         if (STp->block_size == 0)
1979                                                 transfer = bytes;
1980                                         /* Some drives set ILI with MEDIUM ERROR */
1981                                         cmdstatp->flags &= ~SENSE_ILI;
1982                                 }
1983
1984                                 if (cmdstatp->flags & SENSE_ILI) {      /* ILI */
1985                                         if (STp->block_size == 0 &&
1986                                             transfer < 0) {
1987                                                 st_printk(KERN_NOTICE, STp,
1988                                                           "Failed to read %d "
1989                                                           "byte block with %d "
1990                                                           "byte transfer.\n",
1991                                                           bytes - transfer,
1992                                                           bytes);
1993                                                 if (STps->drv_block >= 0)
1994                                                         STps->drv_block += 1;
1995                                                 STbp->buffer_bytes = 0;
1996                                                 return (-ENOMEM);
1997                                         } else if (STp->block_size == 0) {
1998                                                 STbp->buffer_bytes = bytes - transfer;
1999                                         } else {
2000                                                 st_release_request(SRpnt);
2001                                                 SRpnt = *aSRpnt = NULL;
2002                                                 if (transfer == blks) { /* We did not get anything, error */
2003                                                         st_printk(KERN_NOTICE, STp,
2004                                                                   "Incorrect "
2005                                                                   "block size.\n");
2006                                                         if (STps->drv_block >= 0)
2007                                                                 STps->drv_block += blks - transfer + 1;
2008                                                         st_int_ioctl(STp, MTBSR, 1);
2009                                                         return (-EIO);
2010                                                 }
2011                                                 /* We have some data, deliver it */
2012                                                 STbp->buffer_bytes = (blks - transfer) *
2013                                                     STp->block_size;
2014                                                 DEBC_printk(STp, "ILI but "
2015                                                             "enough data "
2016                                                             "received %ld "
2017                                                             "%d.\n", count,
2018                                                             STbp->buffer_bytes);
2019                                                 if (STps->drv_block >= 0)
2020                                                         STps->drv_block += 1;
2021                                                 if (st_int_ioctl(STp, MTBSR, 1))
2022                                                         return (-EIO);
2023                                         }
2024                                 } else if (cmdstatp->flags & SENSE_FMK) {       /* FM overrides EOM */
2025                                         if (STps->eof != ST_FM_HIT)
2026                                                 STps->eof = ST_FM_HIT;
2027                                         else
2028                                                 STps->eof = ST_EOD_2;
2029                                         if (STp->block_size == 0)
2030                                                 STbp->buffer_bytes = 0;
2031                                         else
2032                                                 STbp->buffer_bytes =
2033                                                     bytes - transfer * STp->block_size;
2034                                         DEBC_printk(STp, "EOF detected (%d "
2035                                                     "bytes read).\n",
2036                                                     STbp->buffer_bytes);
2037                                 } else if (cmdstatp->flags & SENSE_EOM) {
2038                                         if (STps->eof == ST_FM)
2039                                                 STps->eof = ST_EOD_1;
2040                                         else
2041                                                 STps->eof = ST_EOM_OK;
2042                                         if (STp->block_size == 0)
2043                                                 STbp->buffer_bytes = bytes - transfer;
2044                                         else
2045                                                 STbp->buffer_bytes =
2046                                                     bytes - transfer * STp->block_size;
2047
2048                                         DEBC_printk(STp, "EOM detected (%d "
2049                                                     "bytes read).\n",
2050                                                     STbp->buffer_bytes);
2051                                 }
2052                         }
2053                         /* end of EOF, EOM, ILI test */
2054                         else {  /* nonzero sense key */
2055                                 DEBC_printk(STp, "Tape error while reading.\n");
2056                                 STps->drv_block = (-1);
2057                                 if (STps->eof == ST_FM &&
2058                                     cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
2059                                         DEBC_printk(STp, "Zero returned for "
2060                                                     "first BLANK CHECK "
2061                                                     "after EOF.\n");
2062                                         STps->eof = ST_EOD_2;   /* First BLANK_CHECK after FM */
2063                                 } else  /* Some other extended sense code */
2064                                         retval = (-EIO);
2065                         }
2066
2067                         if (STbp->buffer_bytes < 0)  /* Caused by bogus sense data */
2068                                 STbp->buffer_bytes = 0;
2069                 }
2070                 /* End of extended sense test */
2071                 else {          /* Non-extended sense */
2072                         retval = STbp->syscall_result;
2073                 }
2074
2075         }
2076         /* End of error handling */
2077         else {                  /* Read successful */
2078                 STbp->buffer_bytes = bytes;
2079                 if (STp->sili) /* In fixed block mode residual is always zero here */
2080                         STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
2081         }
2082
2083         if (STps->drv_block >= 0) {
2084                 if (STp->block_size == 0)
2085                         STps->drv_block++;
2086                 else
2087                         STps->drv_block += STbp->buffer_bytes / STp->block_size;
2088         }
2089         return retval;
2090 }
2091 \f
2092
2093 /* Read command */
2094 static ssize_t
2095 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
2096 {
2097         ssize_t total;
2098         ssize_t retval = 0;
2099         ssize_t i, transfer;
2100         int special, do_dio = 0;
2101         struct st_request *SRpnt = NULL;
2102         struct scsi_tape *STp = filp->private_data;
2103         struct st_modedef *STm;
2104         struct st_partstat *STps;
2105         struct st_buffer *STbp = STp->buffer;
2106
2107         if (mutex_lock_interruptible(&STp->lock))
2108                 return -ERESTARTSYS;
2109
2110         retval = rw_checks(STp, filp, count);
2111         if (retval || count == 0)
2112                 goto out;
2113
2114         STm = &(STp->modes[STp->current_mode]);
2115         if (STp->block_size != 0 && (count % STp->block_size) != 0) {
2116                 if (!STm->do_read_ahead) {
2117                         retval = (-EINVAL);     /* Read must be integral number of blocks */
2118                         goto out;
2119                 }
2120                 STp->try_dio_now = 0;  /* Direct i/o can't handle split blocks */
2121         }
2122
2123         STps = &(STp->ps[STp->partition]);
2124         if (STps->rw == ST_WRITING) {
2125                 retval = flush_buffer(STp, 0);
2126                 if (retval)
2127                         goto out;
2128                 STps->rw = ST_READING;
2129         }
2130         DEB(
2131         if (debugging && STps->eof != ST_NOEOF)
2132                 st_printk(ST_DEB_MSG, STp,
2133                           "EOF/EOM flag up (%d). Bytes %d\n",
2134                           STps->eof, STbp->buffer_bytes);
2135         ) /* end DEB */
2136
2137         retval = setup_buffering(STp, buf, count, 1);
2138         if (retval)
2139                 goto out;
2140         do_dio = STbp->do_dio;
2141
2142         if (STbp->buffer_bytes == 0 &&
2143             STps->eof >= ST_EOD_1) {
2144                 if (STps->eof < ST_EOD) {
2145                         STps->eof += 1;
2146                         retval = 0;
2147                         goto out;
2148                 }
2149                 retval = (-EIO);        /* EOM or Blank Check */
2150                 goto out;
2151         }
2152
2153         if (do_dio) {
2154                 /* Check the buffer writability before any tape movement. Don't alter
2155                    buffer data. */
2156                 if (copy_from_user(&i, buf, 1) != 0 ||
2157                     copy_to_user(buf, &i, 1) != 0 ||
2158                     copy_from_user(&i, buf + count - 1, 1) != 0 ||
2159                     copy_to_user(buf + count - 1, &i, 1) != 0) {
2160                         retval = (-EFAULT);
2161                         goto out;
2162                 }
2163         }
2164
2165         STps->rw = ST_READING;
2166
2167
2168         /* Loop until enough data in buffer or a special condition found */
2169         for (total = 0, special = 0; total < count && !special;) {
2170
2171                 /* Get new data if the buffer is empty */
2172                 if (STbp->buffer_bytes == 0) {
2173                         special = read_tape(STp, count - total, &SRpnt);
2174                         if (special < 0) {      /* No need to continue read */
2175                                 retval = special;
2176                                 goto out;
2177                         }
2178                 }
2179
2180                 /* Move the data from driver buffer to user buffer */
2181                 if (STbp->buffer_bytes > 0) {
2182                         DEB(
2183                         if (debugging && STps->eof != ST_NOEOF)
2184                                 st_printk(ST_DEB_MSG, STp,
2185                                           "EOF up (%d). Left %d, needed %d.\n",
2186                                           STps->eof, STbp->buffer_bytes,
2187                                           (int)(count - total));
2188                         ) /* end DEB */
2189                         transfer = STbp->buffer_bytes < count - total ?
2190                             STbp->buffer_bytes : count - total;
2191                         if (!do_dio) {
2192                                 i = from_buffer(STbp, buf, transfer);
2193                                 if (i) {
2194                                         retval = i;
2195                                         goto out;
2196                                 }
2197                         }
2198                         buf += transfer;
2199                         total += transfer;
2200                 }
2201
2202                 if (STp->block_size == 0)
2203                         break;  /* Read only one variable length block */
2204
2205         }                       /* for (total = 0, special = 0;
2206                                    total < count && !special; ) */
2207
2208         /* Change the eof state if no data from tape or buffer */
2209         if (total == 0) {
2210                 if (STps->eof == ST_FM_HIT) {
2211                         STps->eof = ST_FM;
2212                         STps->drv_block = 0;
2213                         if (STps->drv_file >= 0)
2214                                 STps->drv_file++;
2215                 } else if (STps->eof == ST_EOD_1) {
2216                         STps->eof = ST_EOD_2;
2217                         STps->drv_block = 0;
2218                         if (STps->drv_file >= 0)
2219                                 STps->drv_file++;
2220                 } else if (STps->eof == ST_EOD_2)
2221                         STps->eof = ST_EOD;
2222         } else if (STps->eof == ST_FM)
2223                 STps->eof = ST_NOEOF;
2224         retval = total;
2225
2226  out:
2227         if (SRpnt != NULL) {
2228                 st_release_request(SRpnt);
2229                 SRpnt = NULL;
2230         }
2231         if (do_dio) {
2232                 release_buffering(STp, 1);
2233                 STbp->buffer_bytes = 0;
2234         }
2235         mutex_unlock(&STp->lock);
2236
2237         return retval;
2238 }
2239 \f
2240
2241
2242 DEB(
2243 /* Set the driver options */
2244 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm)
2245 {
2246         if (debugging) {
2247                 st_printk(KERN_INFO, STp,
2248                           "Mode %d options: buffer writes: %d, "
2249                           "async writes: %d, read ahead: %d\n",
2250                           STp->current_mode, STm->do_buffer_writes,
2251                           STm->do_async_writes, STm->do_read_ahead);
2252                 st_printk(KERN_INFO, STp,
2253                           "    can bsr: %d, two FMs: %d, "
2254                           "fast mteom: %d, auto lock: %d,\n",
2255                           STp->can_bsr, STp->two_fm, STp->fast_mteom,
2256                           STp->do_auto_lock);
2257                 st_printk(KERN_INFO, STp,
2258                           "    defs for wr: %d, no block limits: %d, "
2259                           "partitions: %d, s2 log: %d\n",
2260                           STm->defaults_for_writes, STp->omit_blklims,
2261                           STp->can_partitions, STp->scsi2_logical);
2262                 st_printk(KERN_INFO, STp,
2263                           "    sysv: %d nowait: %d sili: %d "
2264                           "nowait_filemark: %d\n",
2265                           STm->sysv, STp->immediate, STp->sili,
2266                           STp->immediate_filemark);
2267                 st_printk(KERN_INFO, STp, "    debugging: %d\n", debugging);
2268         }
2269 }
2270         )
2271
2272
2273 static int st_set_options(struct scsi_tape *STp, long options)
2274 {
2275         int value;
2276         long code;
2277         struct st_modedef *STm;
2278         struct cdev *cd0, *cd1;
2279         struct device *d0, *d1;
2280
2281         STm = &(STp->modes[STp->current_mode]);
2282         if (!STm->defined) {
2283                 cd0 = STm->cdevs[0];
2284                 cd1 = STm->cdevs[1];
2285                 d0  = STm->devs[0];
2286                 d1  = STm->devs[1];
2287                 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2288                 STm->cdevs[0] = cd0;
2289                 STm->cdevs[1] = cd1;
2290                 STm->devs[0]  = d0;
2291                 STm->devs[1]  = d1;
2292                 modes_defined = 1;
2293                 DEBC_printk(STp, "Initialized mode %d definition from mode 0\n",
2294                             STp->current_mode);
2295         }
2296
2297         code = options & MT_ST_OPTIONS;
2298         if (code == MT_ST_BOOLEANS) {
2299                 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2300                 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2301                 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2302                 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2303                 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2304                 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2305                 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2306                 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2307                 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2308                 if ((STp->device)->scsi_level >= SCSI_2)
2309                         STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2310                 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2311                 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2312                 STp->immediate_filemark = (options & MT_ST_NOWAIT_EOF) != 0;
2313                 STm->sysv = (options & MT_ST_SYSV) != 0;
2314                 STp->sili = (options & MT_ST_SILI) != 0;
2315                 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2316                      st_log_options(STp, STm); )
2317         } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2318                 value = (code == MT_ST_SETBOOLEANS);
2319                 if ((options & MT_ST_BUFFER_WRITES) != 0)
2320                         STm->do_buffer_writes = value;
2321                 if ((options & MT_ST_ASYNC_WRITES) != 0)
2322                         STm->do_async_writes = value;
2323                 if ((options & MT_ST_DEF_WRITES) != 0)
2324                         STm->defaults_for_writes = value;
2325                 if ((options & MT_ST_READ_AHEAD) != 0)
2326                         STm->do_read_ahead = value;
2327                 if ((options & MT_ST_TWO_FM) != 0)
2328                         STp->two_fm = value;
2329                 if ((options & MT_ST_FAST_MTEOM) != 0)
2330                         STp->fast_mteom = value;
2331                 if ((options & MT_ST_AUTO_LOCK) != 0)
2332                         STp->do_auto_lock = value;
2333                 if ((options & MT_ST_CAN_BSR) != 0)
2334                         STp->can_bsr = value;
2335                 if ((options & MT_ST_NO_BLKLIMS) != 0)
2336                         STp->omit_blklims = value;
2337                 if ((STp->device)->scsi_level >= SCSI_2 &&
2338                     (options & MT_ST_CAN_PARTITIONS) != 0)
2339                         STp->can_partitions = value;
2340                 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2341                         STp->scsi2_logical = value;
2342                 if ((options & MT_ST_NOWAIT) != 0)
2343                         STp->immediate = value;
2344                 if ((options & MT_ST_NOWAIT_EOF) != 0)
2345                         STp->immediate_filemark = value;
2346                 if ((options & MT_ST_SYSV) != 0)
2347                         STm->sysv = value;
2348                 if ((options & MT_ST_SILI) != 0)
2349                         STp->sili = value;
2350                 DEB(
2351                 if ((options & MT_ST_DEBUGGING) != 0)
2352                         debugging = value;
2353                         st_log_options(STp, STm); )
2354         } else if (code == MT_ST_WRITE_THRESHOLD) {
2355                 /* Retained for compatibility */
2356         } else if (code == MT_ST_DEF_BLKSIZE) {
2357                 value = (options & ~MT_ST_OPTIONS);
2358                 if (value == ~MT_ST_OPTIONS) {
2359                         STm->default_blksize = (-1);
2360                         DEBC_printk(STp, "Default block size disabled.\n");
2361                 } else {
2362                         STm->default_blksize = value;
2363                         DEBC_printk(STp,"Default block size set to "
2364                                     "%d bytes.\n", STm->default_blksize);
2365                         if (STp->ready == ST_READY) {
2366                                 STp->blksize_changed = 0;
2367                                 set_mode_densblk(STp, STm);
2368                         }
2369                 }
2370         } else if (code == MT_ST_TIMEOUTS) {
2371                 value = (options & ~MT_ST_OPTIONS);
2372                 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2373                         STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2374                         DEBC_printk(STp, "Long timeout set to %d seconds.\n",
2375                                     (value & ~MT_ST_SET_LONG_TIMEOUT));
2376                 } else {
2377                         blk_queue_rq_timeout(STp->device->request_queue,
2378                                              value * HZ);
2379                         DEBC_printk(STp, "Normal timeout set to %d seconds.\n",
2380                                     value);
2381                 }
2382         } else if (code == MT_ST_SET_CLN) {
2383                 value = (options & ~MT_ST_OPTIONS) & 0xff;
2384                 if (value != 0 &&
2385                         (value < EXTENDED_SENSE_START ||
2386                                 value >= SCSI_SENSE_BUFFERSIZE))
2387                         return (-EINVAL);
2388                 STp->cln_mode = value;
2389                 STp->cln_sense_mask = (options >> 8) & 0xff;
2390                 STp->cln_sense_value = (options >> 16) & 0xff;
2391                 st_printk(KERN_INFO, STp,
2392                           "Cleaning request mode %d, mask %02x, value %02x\n",
2393                           value, STp->cln_sense_mask, STp->cln_sense_value);
2394         } else if (code == MT_ST_DEF_OPTIONS) {
2395                 code = (options & ~MT_ST_CLEAR_DEFAULT);
2396                 value = (options & MT_ST_CLEAR_DEFAULT);
2397                 if (code == MT_ST_DEF_DENSITY) {
2398                         if (value == MT_ST_CLEAR_DEFAULT) {
2399                                 STm->default_density = (-1);
2400                                 DEBC_printk(STp,
2401                                             "Density default disabled.\n");
2402                         } else {
2403                                 STm->default_density = value & 0xff;
2404                                 DEBC_printk(STp, "Density default set to %x\n",
2405                                             STm->default_density);
2406                                 if (STp->ready == ST_READY) {
2407                                         STp->density_changed = 0;
2408                                         set_mode_densblk(STp, STm);
2409                                 }
2410                         }
2411                 } else if (code == MT_ST_DEF_DRVBUFFER) {
2412                         if (value == MT_ST_CLEAR_DEFAULT) {
2413                                 STp->default_drvbuffer = 0xff;
2414                                 DEBC_printk(STp,
2415                                             "Drive buffer default disabled.\n");
2416                         } else {
2417                                 STp->default_drvbuffer = value & 7;
2418                                 DEBC_printk(STp,
2419                                             "Drive buffer default set to %x\n",
2420                                             STp->default_drvbuffer);
2421                                 if (STp->ready == ST_READY)
2422                                         st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2423                         }
2424                 } else if (code == MT_ST_DEF_COMPRESSION) {
2425                         if (value == MT_ST_CLEAR_DEFAULT) {
2426                                 STm->default_compression = ST_DONT_TOUCH;
2427                                 DEBC_printk(STp,
2428                                             "Compression default disabled.\n");
2429                         } else {
2430                                 if ((value & 0xff00) != 0) {
2431                                         STp->c_algo = (value & 0xff00) >> 8;
2432                                         DEBC_printk(STp, "Compression "
2433                                                     "algorithm set to 0x%x.\n",
2434                                                     STp->c_algo);
2435                                 }
2436                                 if ((value & 0xff) != 0xff) {
2437                                         STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2438                                         DEBC_printk(STp, "Compression default "
2439                                                     "set to %x\n",
2440                                                     (value & 1));
2441                                         if (STp->ready == ST_READY) {
2442                                                 STp->compression_changed = 0;
2443                                                 st_compression(STp, (STm->default_compression == ST_YES));
2444                                         }
2445                                 }
2446                         }
2447                 }
2448         } else
2449                 return (-EIO);
2450
2451         return 0;
2452 }
2453 \f
2454 #define MODE_HEADER_LENGTH  4
2455
2456 /* Mode header and page byte offsets */
2457 #define MH_OFF_DATA_LENGTH     0
2458 #define MH_OFF_MEDIUM_TYPE     1
2459 #define MH_OFF_DEV_SPECIFIC    2
2460 #define MH_OFF_BDESCS_LENGTH   3
2461 #define MP_OFF_PAGE_NBR        0
2462 #define MP_OFF_PAGE_LENGTH     1
2463
2464 /* Mode header and page bit masks */
2465 #define MH_BIT_WP              0x80
2466 #define MP_MSK_PAGE_NBR        0x3f
2467
2468 /* Don't return block descriptors */
2469 #define MODE_SENSE_OMIT_BDESCS 0x08
2470
2471 #define MODE_SELECT_PAGE_FORMAT 0x10
2472
2473 /* Read a mode page into the tape buffer. The block descriptors are included
2474    if incl_block_descs is true. The page control is ored to the page number
2475    parameter, if necessary. */
2476 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2477 {
2478         unsigned char cmd[MAX_COMMAND_SIZE];
2479         struct st_request *SRpnt;
2480
2481         memset(cmd, 0, MAX_COMMAND_SIZE);
2482         cmd[0] = MODE_SENSE;
2483         if (omit_block_descs)
2484                 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2485         cmd[2] = page;
2486         cmd[4] = 255;
2487
2488         SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2489                            STp->device->request_queue->rq_timeout, 0, 1);
2490         if (SRpnt == NULL)
2491                 return (STp->buffer)->syscall_result;
2492
2493         st_release_request(SRpnt);
2494
2495         return STp->buffer->syscall_result;
2496 }
2497
2498
2499 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2500    in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2501 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2502 {
2503         int pgo;
2504         unsigned char cmd[MAX_COMMAND_SIZE];
2505         struct st_request *SRpnt;
2506         int timeout;
2507
2508         memset(cmd, 0, MAX_COMMAND_SIZE);
2509         cmd[0] = MODE_SELECT;
2510         cmd[1] = MODE_SELECT_PAGE_FORMAT;
2511         pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2512         cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2513
2514         /* Clear reserved fields */
2515         (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2516         (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2517         (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2518         (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2519
2520         timeout = slow ?
2521                 STp->long_timeout : STp->device->request_queue->rq_timeout;
2522         SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_TO_DEVICE,
2523                            timeout, 0, 1);
2524         if (SRpnt == NULL)
2525                 return (STp->buffer)->syscall_result;
2526
2527         st_release_request(SRpnt);
2528
2529         return STp->buffer->syscall_result;
2530 }
2531
2532
2533 #define COMPRESSION_PAGE        0x0f
2534 #define COMPRESSION_PAGE_LENGTH 16
2535
2536 #define CP_OFF_DCE_DCC          2
2537 #define CP_OFF_C_ALGO           7
2538
2539 #define DCE_MASK  0x80
2540 #define DCC_MASK  0x40
2541 #define RED_MASK  0x60
2542
2543
2544 /* Control the compression with mode page 15. Algorithm not changed if zero.
2545
2546    The block descriptors are read and written because Sony SDT-7000 does not
2547    work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2548    Including block descriptors should not cause any harm to other drives. */
2549
2550 static int st_compression(struct scsi_tape * STp, int state)
2551 {
2552         int retval;
2553         int mpoffs;  /* Offset to mode page start */
2554         unsigned char *b_data = (STp->buffer)->b_data;
2555
2556         if (STp->ready != ST_READY)
2557                 return (-EIO);
2558
2559         /* Read the current page contents */
2560         retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2561         if (retval) {
2562                 DEBC_printk(STp, "Compression mode page not supported.\n");
2563                 return (-EIO);
2564         }
2565
2566         mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2567         DEBC_printk(STp, "Compression state is %d.\n",
2568                     (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0));
2569
2570         /* Check if compression can be changed */
2571         if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2572                 DEBC_printk(STp, "Compression not supported.\n");
2573                 return (-EIO);
2574         }
2575
2576         /* Do the change */
2577         if (state) {
2578                 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2579                 if (STp->c_algo != 0)
2580                         b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2581         }
2582         else {
2583                 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2584                 if (STp->c_algo != 0)
2585                         b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2586         }
2587
2588         retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2589         if (retval) {
2590                 DEBC_printk(STp, "Compression change failed.\n");
2591                 return (-EIO);
2592         }
2593         DEBC_printk(STp, "Compression state changed to %d.\n", state);
2594
2595         STp->compression_changed = 1;
2596         return 0;
2597 }
2598
2599
2600 /* Process the load and unload commands (does unload if the load code is zero) */
2601 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2602 {
2603         int retval = (-EIO), timeout;
2604         unsigned char cmd[MAX_COMMAND_SIZE];
2605         struct st_partstat *STps;
2606         struct st_request *SRpnt;
2607
2608         if (STp->ready != ST_READY && !load_code) {
2609                 if (STp->ready == ST_NO_TAPE)
2610                         return (-ENOMEDIUM);
2611                 else
2612                         return (-EIO);
2613         }
2614
2615         memset(cmd, 0, MAX_COMMAND_SIZE);
2616         cmd[0] = START_STOP;
2617         if (load_code)
2618                 cmd[4] |= 1;
2619         /*
2620          * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2621          */
2622         if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2623             && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2624                 DEBC_printk(STp, " Enhanced %sload slot %2d.\n",
2625                             (cmd[4]) ? "" : "un",
2626                             load_code - MT_ST_HPLOADER_OFFSET);
2627                 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2628         }
2629         if (STp->immediate) {
2630                 cmd[1] = 1;     /* Don't wait for completion */
2631                 timeout = STp->device->request_queue->rq_timeout;
2632         }
2633         else
2634                 timeout = STp->long_timeout;
2635
2636         DEBC(
2637                 if (!load_code)
2638                         st_printk(ST_DEB_MSG, STp, "Unloading tape.\n");
2639                 else
2640                         st_printk(ST_DEB_MSG, STp, "Loading tape.\n");
2641                 );
2642
2643         SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2644                            timeout, MAX_RETRIES, 1);
2645         if (!SRpnt)
2646                 return (STp->buffer)->syscall_result;
2647
2648         retval = (STp->buffer)->syscall_result;
2649         st_release_request(SRpnt);
2650
2651         if (!retval) {  /* SCSI command successful */
2652
2653                 if (!load_code) {
2654                         STp->rew_at_close = 0;
2655                         STp->ready = ST_NO_TAPE;
2656                 }
2657                 else {
2658                         STp->rew_at_close = STp->autorew_dev;
2659                         retval = check_tape(STp, filp);
2660                         if (retval > 0)
2661                                 retval = 0;
2662                 }
2663         }
2664         else {
2665                 STps = &(STp->ps[STp->partition]);
2666                 STps->drv_file = STps->drv_block = (-1);
2667         }
2668
2669         return retval;
2670 }
2671 \f
2672 #if DEBUG
2673 #define ST_DEB_FORWARD  0
2674 #define ST_DEB_BACKWARD 1
2675 static void deb_space_print(struct scsi_tape *STp, int direction, char *units, unsigned char *cmd)
2676 {
2677         s32 sc;
2678
2679         if (!debugging)
2680                 return;
2681
2682         sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2683         sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2684         if (direction)
2685                 sc = -sc;
2686         st_printk(ST_DEB_MSG, STp, "Spacing tape %s over %d %s.\n",
2687                   direction ? "backward" : "forward", sc, units);
2688 }
2689 #else
2690 #define ST_DEB_FORWARD  0
2691 #define ST_DEB_BACKWARD 1
2692 static void deb_space_print(struct scsi_tape *STp, int direction, char *units, unsigned char *cmd) {}
2693 #endif
2694
2695
2696 /* Internal ioctl function */
2697 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2698 {
2699         int timeout;
2700         long ltmp;
2701         int ioctl_result;
2702         int chg_eof = 1;
2703         unsigned char cmd[MAX_COMMAND_SIZE];
2704         struct st_request *SRpnt;
2705         struct st_partstat *STps;
2706         int fileno, blkno, at_sm, undone;
2707         int datalen = 0, direction = DMA_NONE;
2708
2709         WARN_ON(STp->buffer->do_dio != 0);
2710         if (STp->ready != ST_READY) {
2711                 if (STp->ready == ST_NO_TAPE)
2712                         return (-ENOMEDIUM);
2713                 else
2714                         return (-EIO);
2715         }
2716         timeout = STp->long_timeout;
2717         STps = &(STp->ps[STp->partition]);
2718         fileno = STps->drv_file;
2719         blkno = STps->drv_block;
2720         at_sm = STps->at_sm;
2721
2722         memset(cmd, 0, MAX_COMMAND_SIZE);
2723         switch (cmd_in) {
2724         case MTFSFM:
2725                 chg_eof = 0;    /* Changed from the FSF after this */
2726                 /* fall through */
2727         case MTFSF:
2728                 cmd[0] = SPACE;
2729                 cmd[1] = 0x01;  /* Space FileMarks */
2730                 cmd[2] = (arg >> 16);
2731                 cmd[3] = (arg >> 8);
2732                 cmd[4] = arg;
2733                 deb_space_print(STp, ST_DEB_FORWARD, "filemarks", cmd);
2734                 if (fileno >= 0)
2735                         fileno += arg;
2736                 blkno = 0;
2737                 at_sm &= (arg == 0);
2738                 break;
2739         case MTBSFM:
2740                 chg_eof = 0;    /* Changed from the FSF after this */
2741                 /* fall through */
2742         case MTBSF:
2743                 cmd[0] = SPACE;
2744                 cmd[1] = 0x01;  /* Space FileMarks */
2745                 ltmp = (-arg);
2746                 cmd[2] = (ltmp >> 16);
2747                 cmd[3] = (ltmp >> 8);
2748                 cmd[4] = ltmp;
2749                 deb_space_print(STp, ST_DEB_BACKWARD, "filemarks", cmd);
2750                 if (fileno >= 0)
2751                         fileno -= arg;
2752                 blkno = (-1);   /* We can't know the block number */
2753                 at_sm &= (arg == 0);
2754                 break;
2755         case MTFSR:
2756                 cmd[0] = SPACE;
2757                 cmd[1] = 0x00;  /* Space Blocks */
2758                 cmd[2] = (arg >> 16);
2759                 cmd[3] = (arg >> 8);
2760                 cmd[4] = arg;
2761                 deb_space_print(STp, ST_DEB_FORWARD, "blocks", cmd);
2762                 if (blkno >= 0)
2763                         blkno += arg;
2764                 at_sm &= (arg == 0);
2765                 break;
2766         case MTBSR:
2767                 cmd[0] = SPACE;
2768                 cmd[1] = 0x00;  /* Space Blocks */
2769                 ltmp = (-arg);
2770                 cmd[2] = (ltmp >> 16);
2771                 cmd[3] = (ltmp >> 8);
2772                 cmd[4] = ltmp;
2773                 deb_space_print(STp, ST_DEB_BACKWARD, "blocks", cmd);
2774                 if (blkno >= 0)
2775                         blkno -= arg;
2776                 at_sm &= (arg == 0);
2777                 break;
2778         case MTFSS:
2779                 cmd[0] = SPACE;
2780                 cmd[1] = 0x04;  /* Space Setmarks */
2781                 cmd[2] = (arg >> 16);
2782                 cmd[3] = (arg >> 8);
2783                 cmd[4] = arg;
2784                 deb_space_print(STp, ST_DEB_FORWARD, "setmarks", cmd);
2785                 if (arg != 0) {
2786                         blkno = fileno = (-1);
2787                         at_sm = 1;
2788                 }
2789                 break;
2790         case MTBSS:
2791                 cmd[0] = SPACE;
2792                 cmd[1] = 0x04;  /* Space Setmarks */
2793                 ltmp = (-arg);
2794                 cmd[2] = (ltmp >> 16);
2795                 cmd[3] = (ltmp >> 8);
2796                 cmd[4] = ltmp;
2797                 deb_space_print(STp, ST_DEB_BACKWARD, "setmarks", cmd);
2798                 if (arg != 0) {
2799                         blkno = fileno = (-1);
2800                         at_sm = 1;
2801                 }
2802                 break;
2803         case MTWEOF:
2804         case MTWEOFI:
2805         case MTWSM:
2806                 if (STp->write_prot)
2807                         return (-EACCES);
2808                 cmd[0] = WRITE_FILEMARKS;
2809                 if (cmd_in == MTWSM)
2810                         cmd[1] = 2;
2811                 if (cmd_in == MTWEOFI ||
2812                     (cmd_in == MTWEOF && STp->immediate_filemark))
2813                         cmd[1] |= 1;
2814                 cmd[2] = (arg >> 16);
2815                 cmd[3] = (arg >> 8);
2816                 cmd[4] = arg;
2817                 timeout = STp->device->request_queue->rq_timeout;
2818                 DEBC(
2819                         if (cmd_in != MTWSM)
2820                                 st_printk(ST_DEB_MSG, STp,
2821                                           "Writing %d filemarks.\n",
2822                                           cmd[2] * 65536 +
2823                                           cmd[3] * 256 +
2824                                           cmd[4]);
2825                         else
2826                                 st_printk(ST_DEB_MSG, STp,
2827                                           "Writing %d setmarks.\n",
2828                                           cmd[2] * 65536 +
2829                                           cmd[3] * 256 +
2830                                           cmd[4]);
2831                 )
2832                 if (fileno >= 0)
2833                         fileno += arg;
2834                 blkno = 0;
2835                 at_sm = (cmd_in == MTWSM);
2836                 break;
2837         case MTREW:
2838                 cmd[0] = REZERO_UNIT;
2839                 if (STp->immediate) {
2840                         cmd[1] = 1;     /* Don't wait for completion */
2841                         timeout = STp->device->request_queue->rq_timeout;
2842                 }
2843                 DEBC_printk(STp, "Rewinding tape.\n");
2844                 fileno = blkno = at_sm = 0;
2845                 break;
2846         case MTNOP:
2847                 DEBC_printk(STp, "No op on tape.\n");
2848                 return 0;       /* Should do something ? */
2849                 break;
2850         case MTRETEN:
2851                 cmd[0] = START_STOP;
2852                 if (STp->immediate) {
2853                         cmd[1] = 1;     /* Don't wait for completion */
2854                         timeout = STp->device->request_queue->rq_timeout;
2855                 }
2856                 cmd[4] = 3;
2857                 DEBC_printk(STp, "Retensioning tape.\n");
2858                 fileno = blkno = at_sm = 0;
2859                 break;
2860         case MTEOM:
2861                 if (!STp->fast_mteom) {
2862                         /* space to the end of tape */
2863                         ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2864                         fileno = STps->drv_file;
2865                         if (STps->eof >= ST_EOD_1)
2866                                 return 0;
2867                         /* The next lines would hide the number of spaced FileMarks
2868                            That's why I inserted the previous lines. I had no luck
2869                            with detecting EOM with FSF, so we go now to EOM.
2870                            Joerg Weule */
2871                 } else
2872                         fileno = (-1);
2873                 cmd[0] = SPACE;
2874                 cmd[1] = 3;
2875                 DEBC_printk(STp, "Spacing to end of recorded medium.\n");
2876                 blkno = -1;
2877                 at_sm = 0;
2878                 break;
2879         case MTERASE:
2880                 if (STp->write_prot)
2881                         return (-EACCES);
2882                 cmd[0] = ERASE;
2883                 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2884                 if (STp->immediate) {
2885                         cmd[1] |= 2;    /* Don't wait for completion */
2886                         timeout = STp->device->request_queue->rq_timeout;
2887                 }
2888                 else
2889                         timeout = STp->long_timeout * 8;
2890
2891                 DEBC_printk(STp, "Erasing tape.\n");
2892                 fileno = blkno = at_sm = 0;
2893                 break;
2894         case MTSETBLK:          /* Set block length */
2895         case MTSETDENSITY:      /* Set tape density */
2896         case MTSETDRVBUFFER:    /* Set drive buffering */
2897         case SET_DENS_AND_BLK:  /* Set density and block size */
2898                 chg_eof = 0;
2899                 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2900                         return (-EIO);  /* Not allowed if data in buffer */
2901                 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2902                     (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2903                     STp->max_block > 0 &&
2904                     ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2905                      (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2906                         st_printk(KERN_WARNING, STp, "Illegal block size.\n");
2907                         return (-EINVAL);
2908                 }
2909                 cmd[0] = MODE_SELECT;
2910                 if ((STp->use_pf & USE_PF))
2911                         cmd[1] = MODE_SELECT_PAGE_FORMAT;
2912                 cmd[4] = datalen = 12;
2913                 direction = DMA_TO_DEVICE;
2914
2915                 memset((STp->buffer)->b_data, 0, 12);
2916                 if (cmd_in == MTSETDRVBUFFER)
2917                         (STp->buffer)->b_data[2] = (arg & 7) << 4;
2918                 else
2919                         (STp->buffer)->b_data[2] =
2920                             STp->drv_buffer << 4;
2921                 (STp->buffer)->b_data[3] = 8;   /* block descriptor length */
2922                 if (cmd_in == MTSETDENSITY) {
2923                         (STp->buffer)->b_data[4] = arg;
2924                         STp->density_changed = 1;       /* At least we tried ;-) */
2925                 } else if (cmd_in == SET_DENS_AND_BLK)
2926                         (STp->buffer)->b_data[4] = arg >> 24;
2927                 else
2928                         (STp->buffer)->b_data[4] = STp->density;
2929                 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2930                         ltmp = arg & MT_ST_BLKSIZE_MASK;
2931                         if (cmd_in == MTSETBLK)
2932                                 STp->blksize_changed = 1; /* At least we tried ;-) */
2933                 } else
2934                         ltmp = STp->block_size;
2935                 (STp->buffer)->b_data[9] = (ltmp >> 16);
2936                 (STp->buffer)->b_data[10] = (ltmp >> 8);
2937                 (STp->buffer)->b_data[11] = ltmp;
2938                 timeout = STp->device->request_queue->rq_timeout;
2939                 DEBC(
2940                         if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2941                                 st_printk(ST_DEB_MSG, STp,
2942                                           "Setting block size to %d bytes.\n",
2943                                           (STp->buffer)->b_data[9] * 65536 +
2944                                           (STp->buffer)->b_data[10] * 256 +
2945                                           (STp->buffer)->b_data[11]);
2946                         if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2947                                 st_printk(ST_DEB_MSG, STp,
2948                                           "Setting density code to %x.\n",
2949                                           (STp->buffer)->b_data[4]);
2950                         if (cmd_in == MTSETDRVBUFFER)
2951                                 st_printk(ST_DEB_MSG, STp,
2952                                           "Setting drive buffer code to %d.\n",
2953                                           ((STp->buffer)->b_data[2] >> 4) & 7);
2954                 )
2955                 break;
2956         default:
2957                 return (-ENOSYS);
2958         }
2959
2960         SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2961                            timeout, MAX_RETRIES, 1);
2962         if (!SRpnt)
2963                 return (STp->buffer)->syscall_result;
2964
2965         ioctl_result = (STp->buffer)->syscall_result;
2966
2967         if (!ioctl_result) {    /* SCSI command successful */
2968                 st_release_request(SRpnt);
2969                 SRpnt = NULL;
2970                 STps->drv_block = blkno;
2971                 STps->drv_file = fileno;
2972                 STps->at_sm = at_sm;
2973
2974                 if (cmd_in == MTBSFM)
2975                         ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2976                 else if (cmd_in == MTFSFM)
2977                         ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2978
2979                 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2980                         STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2981                         if (STp->block_size != 0) {
2982                                 (STp->buffer)->buffer_blocks =
2983                                     (STp->buffer)->buffer_size / STp->block_size;
2984                         }
2985                         (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2986                         if (cmd_in == SET_DENS_AND_BLK)
2987                                 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2988                 } else if (cmd_in == MTSETDRVBUFFER)
2989                         STp->drv_buffer = (arg & 7);
2990                 else if (cmd_in == MTSETDENSITY)
2991                         STp->density = arg;
2992
2993                 if (cmd_in == MTEOM)
2994                         STps->eof = ST_EOD;
2995                 else if (cmd_in == MTFSF)
2996                         STps->eof = ST_FM;
2997                 else if (chg_eof)
2998                         STps->eof = ST_NOEOF;
2999
3000                 if (cmd_in == MTWEOF || cmd_in == MTWEOFI)
3001                         STps->rw = ST_IDLE;  /* prevent automatic WEOF at close */
3002         } else { /* SCSI command was not completely successful. Don't return
3003                     from this block without releasing the SCSI command block! */
3004                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
3005
3006                 if (cmdstatp->flags & SENSE_EOM) {
3007                         if (cmd_in != MTBSF && cmd_in != MTBSFM &&
3008                             cmd_in != MTBSR && cmd_in != MTBSS)
3009                                 STps->eof = ST_EOM_OK;
3010                         STps->drv_block = 0;
3011                 }
3012
3013                 if (cmdstatp->remainder_valid)
3014                         undone = (int)cmdstatp->uremainder64;
3015                 else
3016                         undone = 0;
3017
3018                 if ((cmd_in == MTWEOF || cmd_in == MTWEOFI) &&
3019                     cmdstatp->have_sense &&
3020                     (cmdstatp->flags & SENSE_EOM)) {
3021                         if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
3022                             cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
3023                                 ioctl_result = 0;       /* EOF(s) written successfully at EOM */
3024                                 STps->eof = ST_NOEOF;
3025                         } else {  /* Writing EOF(s) failed */
3026                                 if (fileno >= 0)
3027                                         fileno -= undone;
3028                                 if (undone < arg)
3029                                         STps->eof = ST_NOEOF;
3030                         }
3031                         STps->drv_file = fileno;
3032                 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
3033                         if (fileno >= 0)
3034                                 STps->drv_file = fileno - undone;
3035                         else
3036                                 STps->drv_file = fileno;
3037                         STps->drv_block = -1;
3038                         STps->eof = ST_NOEOF;
3039                 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
3040                         if (arg > 0 && undone < 0)  /* Some drives get this wrong */
3041                                 undone = (-undone);
3042                         if (STps->drv_file >= 0)
3043                                 STps->drv_file = fileno + undone;
3044                         STps->drv_block = 0;
3045                         STps->eof = ST_NOEOF;
3046                 } else if (cmd_in == MTFSR) {
3047                         if (cmdstatp->flags & SENSE_FMK) {      /* Hit filemark */
3048                                 if (STps->drv_file >= 0)
3049                                         STps->drv_file++;
3050                                 STps->drv_block = 0;
3051                                 STps->eof = ST_FM;
3052                         } else {
3053                                 if (blkno >= undone)
3054                                         STps->drv_block = blkno - undone;
3055                                 else
3056                                         STps->drv_block = (-1);
3057                                 STps->eof = ST_NOEOF;
3058                         }
3059                 } else if (cmd_in == MTBSR) {
3060                         if (cmdstatp->flags & SENSE_FMK) {      /* Hit filemark */
3061                                 STps->drv_file--;
3062                                 STps->drv_block = (-1);
3063                         } else {
3064                                 if (arg > 0 && undone < 0)  /* Some drives get this wrong */
3065                                         undone = (-undone);
3066                                 if (STps->drv_block >= 0)
3067                                         STps->drv_block = blkno + undone;
3068                         }
3069                         STps->eof = ST_NOEOF;
3070                 } else if (cmd_in == MTEOM) {
3071                         STps->drv_file = (-1);
3072                         STps->drv_block = (-1);
3073                         STps->eof = ST_EOD;
3074                 } else if (cmd_in == MTSETBLK ||
3075                            cmd_in == MTSETDENSITY ||
3076                            cmd_in == MTSETDRVBUFFER ||
3077                            cmd_in == SET_DENS_AND_BLK) {
3078                         if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
3079                             !(STp->use_pf & PF_TESTED)) {
3080                                 /* Try the other possible state of Page Format if not
3081                                    already tried */
3082                                 STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED;
3083                                 st_release_request(SRpnt);
3084                                 SRpnt = NULL;
3085                                 return st_int_ioctl(STp, cmd_in, arg);
3086                         }
3087                 } else if (chg_eof)
3088                         STps->eof = ST_NOEOF;
3089
3090                 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
3091                         STps->eof = ST_EOD;
3092
3093                 st_release_request(SRpnt);
3094                 SRpnt = NULL;
3095         }
3096
3097         return ioctl_result;
3098 }
3099 \f
3100
3101 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
3102    structure. */
3103
3104 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
3105                         int logical)
3106 {
3107         int result;
3108         unsigned char scmd[MAX_COMMAND_SIZE];
3109         struct st_request *SRpnt;
3110
3111         if (STp->ready != ST_READY)
3112                 return (-EIO);
3113
3114         memset(scmd, 0, MAX_COMMAND_SIZE);
3115         if ((STp->device)->scsi_level < SCSI_2) {
3116                 scmd[0] = QFA_REQUEST_BLOCK;
3117                 scmd[4] = 3;
3118         } else {
3119                 scmd[0] = READ_POSITION;
3120                 if (!logical && !STp->scsi2_logical)
3121                         scmd[1] = 1;
3122         }
3123         SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
3124                            STp->device->request_queue->rq_timeout,
3125                            MAX_READY_RETRIES, 1);
3126         if (!SRpnt)
3127                 return (STp->buffer)->syscall_result;
3128
3129         if ((STp->buffer)->syscall_result != 0 ||
3130             (STp->device->scsi_level >= SCSI_2 &&
3131              ((STp->buffer)->b_data[0] & 4) != 0)) {
3132                 *block = *partition = 0;
3133                 DEBC_printk(STp, " Can't read tape position.\n");
3134                 result = (-EIO);
3135         } else {
3136                 result = 0;
3137                 if ((STp->device)->scsi_level < SCSI_2) {
3138                         *block = ((STp->buffer)->b_data[0] << 16)
3139                             + ((STp->buffer)->b_data[1] << 8)
3140                             + (STp->buffer)->b_data[2];
3141                         *partition = 0;
3142                 } else {
3143                         *block = ((STp->buffer)->b_data[4] << 24)
3144                             + ((STp->buffer)->b_data[5] << 16)
3145                             + ((STp->buffer)->b_data[6] << 8)
3146                             + (STp->buffer)->b_data[7];
3147                         *partition = (STp->buffer)->b_data[1];
3148                         if (((STp->buffer)->b_data[0] & 0x80) &&
3149                             (STp->buffer)->b_data[1] == 0)      /* BOP of partition 0 */
3150                                 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3151                 }
3152                 DEBC_printk(STp, "Got tape pos. blk %d part %d.\n",
3153                             *block, *partition);
3154         }
3155         st_release_request(SRpnt);
3156         SRpnt = NULL;
3157
3158         return result;
3159 }
3160
3161
3162 /* Set the tape block and partition. Negative partition means that only the
3163    block should be set in vendor specific way. */
3164 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3165                         int logical)
3166 {
3167         struct st_partstat *STps;
3168         int result, p;
3169         unsigned int blk;
3170         int timeout;
3171         unsigned char scmd[MAX_COMMAND_SIZE];
3172         struct st_request *SRpnt;
3173
3174         if (STp->ready != ST_READY)
3175                 return (-EIO);
3176         timeout = STp->long_timeout;
3177         STps = &(STp->ps[STp->partition]);
3178
3179         DEBC_printk(STp, "Setting block to %d and partition to %d.\n",
3180                     block, partition);
3181         DEB(if (partition < 0)
3182                 return (-EIO); )
3183
3184         /* Update the location at the partition we are leaving */
3185         if ((!STp->can_partitions && partition != 0) ||
3186             partition >= ST_NBR_PARTITIONS)
3187                 return (-EINVAL);
3188         if (partition != STp->partition) {
3189                 if (get_location(STp, &blk, &p, 1))
3190                         STps->last_block_valid = 0;
3191                 else {
3192                         STps->last_block_valid = 1;
3193                         STps->last_block_visited = blk;
3194                         DEBC_printk(STp, "Visited block %d for "
3195                                     "partition %d saved.\n",
3196                                     blk, STp->partition);
3197                 }
3198         }
3199
3200         memset(scmd, 0, MAX_COMMAND_SIZE);
3201         if ((STp->device)->scsi_level < SCSI_2) {
3202                 scmd[0] = QFA_SEEK_BLOCK;
3203                 scmd[2] = (block >> 16);
3204                 scmd[3] = (block >> 8);
3205                 scmd[4] = block;
3206                 scmd[5] = 0;
3207         } else {
3208                 scmd[0] = SEEK_10;
3209                 scmd[3] = (block >> 24);
3210                 scmd[4] = (block >> 16);
3211                 scmd[5] = (block >> 8);
3212                 scmd[6] = block;
3213                 if (!logical && !STp->scsi2_logical)
3214                         scmd[1] = 4;
3215                 if (STp->partition != partition) {
3216                         scmd[1] |= 2;
3217                         scmd[8] = partition;
3218                         DEBC_printk(STp, "Trying to change partition "
3219                                     "from %d to %d\n", STp->partition,
3220                                     partition);
3221                 }
3222         }
3223         if (STp->immediate) {
3224                 scmd[1] |= 1;           /* Don't wait for completion */
3225                 timeout = STp->device->request_queue->rq_timeout;
3226         }
3227
3228         SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3229                            timeout, MAX_READY_RETRIES, 1);
3230         if (!SRpnt)
3231                 return (STp->buffer)->syscall_result;
3232
3233         STps->drv_block = STps->drv_file = (-1);
3234         STps->eof = ST_NOEOF;
3235         if ((STp->buffer)->syscall_result != 0) {
3236                 result = (-EIO);
3237                 if (STp->can_partitions &&
3238                     (STp->device)->scsi_level >= SCSI_2 &&
3239                     (p = find_partition(STp)) >= 0)
3240                         STp->partition = p;
3241         } else {
3242                 if (STp->can_partitions) {
3243                         STp->partition = partition;
3244                         STps = &(STp->ps[partition]);
3245                         if (!STps->last_block_valid ||
3246                             STps->last_block_visited != block) {
3247                                 STps->at_sm = 0;
3248                                 STps->rw = ST_IDLE;
3249                         }
3250                 } else
3251                         STps->at_sm = 0;
3252                 if (block == 0)
3253                         STps->drv_block = STps->drv_file = 0;
3254                 result = 0;
3255         }
3256
3257         st_release_request(SRpnt);
3258         SRpnt = NULL;
3259
3260         return result;
3261 }
3262
3263
3264 /* Find the current partition number for the drive status. Called from open and
3265    returns either partition number of negative error code. */
3266 static int find_partition(struct scsi_tape *STp)
3267 {
3268         int i, partition;
3269         unsigned int block;
3270
3271         if ((i = get_location(STp, &block, &partition, 1)) < 0)
3272                 return i;
3273         if (partition >= ST_NBR_PARTITIONS)
3274                 return (-EIO);
3275         return partition;
3276 }
3277
3278
3279 /* Change the partition if necessary */
3280 static int switch_partition(struct scsi_tape *STp)
3281 {
3282         struct st_partstat *STps;
3283
3284         if (STp->partition == STp->new_partition)
3285                 return 0;
3286         STps = &(STp->ps[STp->new_partition]);
3287         if (!STps->last_block_valid)
3288                 STps->last_block_visited = 0;
3289         return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3290 }
3291 \f
3292 /* Functions for reading and writing the medium partition mode page. */
3293
3294 #define PART_PAGE   0x11
3295 #define PART_PAGE_FIXED_LENGTH 8
3296
3297 #define PP_OFF_MAX_ADD_PARTS   2
3298 #define PP_OFF_NBR_ADD_PARTS   3
3299 #define PP_OFF_FLAGS           4
3300 #define PP_OFF_PART_UNITS      6
3301 #define PP_OFF_RESERVED        7
3302
3303 #define PP_BIT_IDP             0x20
3304 #define PP_BIT_FDP             0x80
3305 #define PP_MSK_PSUM_MB         0x10
3306 #define PP_MSK_PSUM_UNITS      0x18
3307 #define PP_MSK_POFM            0x04
3308
3309 /* Get the number of partitions on the tape. As a side effect reads the
3310    mode page into the tape buffer. */
3311 static int nbr_partitions(struct scsi_tape *STp)
3312 {
3313         int result;
3314
3315         if (STp->ready != ST_READY)
3316                 return (-EIO);
3317
3318         result = read_mode_page(STp, PART_PAGE, 1);
3319
3320         if (result) {
3321                 DEBC_printk(STp, "Can't read medium partition page.\n");
3322                 result = (-EIO);
3323         } else {
3324                 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3325                                               PP_OFF_NBR_ADD_PARTS] + 1;
3326                 DEBC_printk(STp, "Number of partitions %d.\n", result);
3327         }
3328
3329         return result;
3330 }
3331
3332
3333 static int format_medium(struct scsi_tape *STp, int format)
3334 {
3335         int result = 0;
3336         int timeout = STp->long_timeout;
3337         unsigned char scmd[MAX_COMMAND_SIZE];
3338         struct st_request *SRpnt;
3339
3340         memset(scmd, 0, MAX_COMMAND_SIZE);
3341         scmd[0] = FORMAT_UNIT;
3342         scmd[2] = format;
3343         if (STp->immediate) {
3344                 scmd[1] |= 1;           /* Don't wait for completion */
3345                 timeout = STp->device->request_queue->rq_timeout;
3346         }
3347         DEBC_printk(STp, "Sending FORMAT MEDIUM\n");
3348         SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3349                            timeout, MAX_RETRIES, 1);
3350         if (!SRpnt)
3351                 result = STp->buffer->syscall_result;
3352         return result;
3353 }
3354
3355
3356 /* Partition the tape into two partitions if size > 0 or one partition if
3357    size == 0.
3358
3359    The block descriptors are read and written because Sony SDT-7000 does not
3360    work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3361
3362    My HP C1533A drive returns only one partition size field. This is used to
3363    set the size of partition 1. There is no size field for the default partition.
3364    Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3365    used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3366    The following algorithm is used to accommodate both drives: if the number of
3367    partition size fields is greater than the maximum number of additional partitions
3368    in the mode page, the second field is used. Otherwise the first field is used.
3369
3370    For Seagate DDS drives the page length must be 8 when no partitions is defined
3371    and 10 when 1 partition is defined (information from Eric Lee Green). This is
3372    is acceptable also to some other old drives and enforced if the first partition
3373    size field is used for the first additional partition size.
3374
3375    For drives that advertize SCSI-3 or newer, use the SSC-3 methods.
3376  */
3377 static int partition_tape(struct scsi_tape *STp, int size)
3378 {
3379         int result;
3380         int target_partition;
3381         bool scsi3 = STp->device->scsi_level >= SCSI_3, needs_format = false;
3382         int pgo, psd_cnt, psdo;
3383         int psum = PP_MSK_PSUM_MB, units = 0;
3384         unsigned char *bp;
3385
3386         result = read_mode_page(STp, PART_PAGE, 0);
3387         if (result) {
3388                 DEBC_printk(STp, "Can't read partition mode page.\n");
3389                 return result;
3390         }
3391         target_partition = 1;
3392         if (size < 0) {
3393                 target_partition = 0;
3394                 size = -size;
3395         }
3396
3397         /* The mode page is in the buffer. Let's modify it and write it. */
3398         bp = (STp->buffer)->b_data;
3399         pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3400         DEBC_printk(STp, "Partition page length is %d bytes.\n",
3401                     bp[pgo + MP_OFF_PAGE_LENGTH] + 2);
3402
3403         psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3404
3405         if (scsi3) {
3406                 needs_format = (bp[pgo + PP_OFF_FLAGS] & PP_MSK_POFM) != 0;
3407                 if (needs_format && size == 0) {
3408                         /* No need to write the mode page when clearing
3409                          *  partitioning
3410                          */
3411                         DEBC_printk(STp, "Formatting tape with one partition.\n");
3412                         result = format_medium(STp, 0);
3413                         goto out;
3414                 }
3415                 if (needs_format)  /* Leave the old value for HP DATs claiming SCSI_3 */
3416                         psd_cnt = 2;
3417                 if ((bp[pgo + PP_OFF_FLAGS] & PP_MSK_PSUM_UNITS) == PP_MSK_PSUM_UNITS) {
3418                         /* Use units scaling for large partitions if the device
3419                          * suggests it and no precision lost. Required for IBM
3420                          * TS1140/50 drives that don't support MB units.
3421                          */
3422                         if (size >= 1000 && (size % 1000) == 0) {
3423                                 size /= 1000;
3424                                 psum = PP_MSK_PSUM_UNITS;
3425                                 units = 9; /* GB */
3426                         }
3427                 }
3428                 /* Try it anyway if too large to specify in MB */
3429                 if (psum == PP_MSK_PSUM_MB && size >= 65534) {
3430                         size /= 1000;
3431                         psum = PP_MSK_PSUM_UNITS;
3432                         units = 9;  /* GB */
3433                 }
3434         }
3435
3436         if (size >= 65535 ||  /* Does not fit into two bytes */
3437             (target_partition == 0 && psd_cnt < 2)) {
3438                 result = -EINVAL;
3439                 goto out;
3440         }
3441
3442         psdo = pgo + PART_PAGE_FIXED_LENGTH;
3443         /* The second condition is for HP DDS which use only one partition size
3444          * descriptor
3445          */
3446         if (target_partition > 0 &&
3447             (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS] ||
3448              bp[pgo + PP_OFF_MAX_ADD_PARTS] != 1)) {
3449                 bp[psdo] = bp[psdo + 1] = 0xff;  /* Rest to partition 0 */
3450                 psdo += 2;
3451         }
3452         memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3453
3454         DEBC_printk(STp, "psd_cnt %d, max.parts %d, nbr_parts %d\n",
3455                     psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3456                     bp[pgo + PP_OFF_NBR_ADD_PARTS]);
3457
3458         if (size == 0) {
3459                 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3460                 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3461                     bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3462                 DEBC_printk(STp, "Formatting tape with one partition.\n");
3463         } else {
3464                 bp[psdo] = (size >> 8) & 0xff;
3465                 bp[psdo + 1] = size & 0xff;
3466                 if (target_partition == 0)
3467                         bp[psdo + 2] = bp[psdo + 3] = 0xff;
3468                 bp[pgo + 3] = 1;
3469                 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3470                     bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3471                 DEBC_printk(STp,
3472                             "Formatting tape with two partitions (%i = %d MB).\n",
3473                             target_partition, units > 0 ? size * 1000 : size);
3474         }
3475         bp[pgo + PP_OFF_PART_UNITS] = 0;
3476         bp[pgo + PP_OFF_RESERVED] = 0;
3477         if (size != 1 || units != 0) {
3478                 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | psum |
3479                         (bp[pgo + PP_OFF_FLAGS] & 0x07);
3480                 bp[pgo + PP_OFF_PART_UNITS] = units;
3481         } else
3482                 bp[pgo + PP_OFF_FLAGS] = PP_BIT_FDP |
3483                         (bp[pgo + PP_OFF_FLAGS] & 0x1f);
3484         bp[pgo + MP_OFF_PAGE_LENGTH] = 6 + psd_cnt * 2;
3485
3486         result = write_mode_page(STp, PART_PAGE, 1);
3487
3488         if (!result && needs_format)
3489                 result = format_medium(STp, 1);
3490
3491         if (result) {
3492                 st_printk(KERN_INFO, STp, "Partitioning of tape failed.\n");
3493                 result = (-EIO);
3494         }
3495
3496 out:
3497         return result;
3498 }
3499 \f
3500
3501
3502 /* The ioctl command */
3503 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3504 {
3505         int i, cmd_nr, cmd_type, bt;
3506         int retval = 0;
3507         unsigned int blk;
3508         struct scsi_tape *STp = file->private_data;
3509         struct st_modedef *STm;
3510         struct st_partstat *STps;
3511         void __user *p = (void __user *)arg;
3512
3513         if (mutex_lock_interruptible(&STp->lock))
3514                 return -ERESTARTSYS;
3515
3516         DEB(
3517         if (debugging && !STp->in_use) {
3518                 st_printk(ST_DEB_MSG, STp, "Incorrect device.\n");
3519                 retval = (-EIO);
3520                 goto out;
3521         } ) /* end DEB */
3522
3523         STm = &(STp->modes[STp->current_mode]);
3524         STps = &(STp->ps[STp->partition]);
3525
3526         /*
3527          * If we are in the middle of error recovery, don't let anyone
3528          * else try and use this device.  Also, if error recovery fails, it
3529          * may try and take the device offline, in which case all further
3530          * access to the device is prohibited.
3531          */
3532         retval = scsi_ioctl_block_when_processing_errors(STp->device, cmd_in,
3533                         file->f_flags & O_NDELAY);
3534         if (retval)
3535                 goto out;
3536
3537         cmd_type = _IOC_TYPE(cmd_in);
3538         cmd_nr = _IOC_NR(cmd_in);
3539
3540         if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3541                 struct mtop mtc;
3542
3543                 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3544                         retval = (-EINVAL);
3545                         goto out;
3546                 }
3547
3548                 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3549                 if (i) {
3550                         retval = (-EFAULT);
3551                         goto out;
3552                 }
3553
3554                 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3555                         st_printk(KERN_WARNING, STp,
3556                                   "MTSETDRVBUFFER only allowed for root.\n");
3557                         retval = (-EPERM);
3558                         goto out;
3559                 }
3560                 if (!STm->defined &&
3561                     (mtc.mt_op != MTSETDRVBUFFER &&
3562                      (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3563                         retval = (-ENXIO);
3564                         goto out;
3565                 }
3566
3567                 if (!STp->pos_unknown) {
3568
3569                         if (STps->eof == ST_FM_HIT) {
3570                                 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3571                                     mtc.mt_op == MTEOM) {
3572                                         mtc.mt_count -= 1;
3573                                         if (STps->drv_file >= 0)
3574                                                 STps->drv_file += 1;
3575                                 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3576                                         mtc.mt_count += 1;
3577                                         if (STps->drv_file >= 0)
3578                                                 STps->drv_file += 1;
3579                                 }
3580                         }
3581
3582                         if (mtc.mt_op == MTSEEK) {
3583                                 /* Old position must be restored if partition will be
3584                                    changed */
3585                                 i = !STp->can_partitions ||
3586                                     (STp->new_partition != STp->partition);
3587                         } else {
3588                                 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3589                                     mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3590                                     mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3591                                     mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3592                                     mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3593                                     mtc.mt_op == MTCOMPRESSION;
3594                         }
3595                         i = flush_buffer(STp, i);
3596                         if (i < 0) {
3597                                 retval = i;
3598                                 goto out;
3599                         }
3600                         if (STps->rw == ST_WRITING &&
3601                             (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3602                              mtc.mt_op == MTSEEK ||
3603                              mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3604                                 i = st_int_ioctl(STp, MTWEOF, 1);
3605                                 if (i < 0) {
3606                                         retval = i;
3607                                         goto out;
3608                                 }
3609                                 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3610                                         mtc.mt_count++;
3611                                 STps->rw = ST_IDLE;
3612                              }
3613
3614                 } else {
3615                         /*
3616                          * If there was a bus reset, block further access
3617                          * to this device.  If the user wants to rewind the tape,
3618                          * then reset the flag and allow access again.
3619                          */
3620                         if (mtc.mt_op != MTREW &&
3621                             mtc.mt_op != MTOFFL &&
3622                             mtc.mt_op != MTRETEN &&
3623                             mtc.mt_op != MTERASE &&
3624                             mtc.mt_op != MTSEEK &&
3625                             mtc.mt_op != MTEOM) {
3626                                 retval = (-EIO);
3627                                 goto out;
3628                         }
3629                         reset_state(STp);
3630                         /* remove this when the midlevel properly clears was_reset */
3631                         STp->device->was_reset = 0;
3632                 }
3633
3634                 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3635                     mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3636                     mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3637                         STps->rw = ST_IDLE;     /* Prevent automatic WEOF and fsf */
3638
3639                 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3640                         do_door_lock(STp, 0);   /* Ignore result! */
3641
3642                 if (mtc.mt_op == MTSETDRVBUFFER &&
3643                     (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3644                         retval = st_set_options(STp, mtc.mt_count);
3645                         goto out;
3646                 }
3647
3648                 if (mtc.mt_op == MTSETPART) {
3649                         if (!STp->can_partitions ||
3650                             mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3651                                 retval = (-EINVAL);
3652                                 goto out;
3653                         }
3654                         if (mtc.mt_count >= STp->nbr_partitions &&
3655                             (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3656                                 retval = (-EIO);
3657                                 goto out;
3658                         }
3659                         if (mtc.mt_count >= STp->nbr_partitions) {
3660                                 retval = (-EINVAL);
3661                                 goto out;
3662                         }
3663                         STp->new_partition = mtc.mt_count;
3664                         retval = 0;
3665                         goto out;
3666                 }
3667
3668                 if (mtc.mt_op == MTMKPART) {
3669                         if (!STp->can_partitions) {
3670                                 retval = (-EINVAL);
3671                                 goto out;
3672                         }
3673                         i = do_load_unload(STp, file, 1);
3674                         if (i < 0) {
3675                                 retval = i;
3676                                 goto out;
3677                         }
3678                         i = partition_tape(STp, mtc.mt_count);
3679                         if (i < 0) {
3680                                 retval = i;
3681                                 goto out;
3682                         }
3683                         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3684                                 STp->ps[i].rw = ST_IDLE;
3685                                 STp->ps[i].at_sm = 0;
3686                                 STp->ps[i].last_block_valid = 0;
3687                         }
3688                         STp->partition = STp->new_partition = 0;
3689                         STp->nbr_partitions = mtc.mt_count != 0 ? 2 : 1;
3690                         STps->drv_block = STps->drv_file = 0;
3691                         retval = 0;
3692                         goto out;
3693                 }
3694
3695                 if (mtc.mt_op == MTSEEK) {
3696                         i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3697                         if (!STp->can_partitions)
3698                                 STp->ps[0].rw = ST_IDLE;
3699                         retval = i;
3700                         goto out;
3701                 }
3702
3703                 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3704                         retval = do_load_unload(STp, file, 0);
3705                         goto out;
3706                 }
3707
3708                 if (mtc.mt_op == MTLOAD) {
3709                         retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3710                         goto out;
3711                 }
3712
3713                 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3714                         retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3715                         goto out;
3716                 }
3717
3718                 if (STp->can_partitions && STp->ready == ST_READY &&
3719                     (i = switch_partition(STp)) < 0) {
3720                         retval = i;
3721                         goto out;
3722                 }
3723
3724                 if (mtc.mt_op == MTCOMPRESSION)
3725                         retval = st_compression(STp, (mtc.mt_count & 1));
3726                 else
3727                         retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3728                 goto out;
3729         }
3730         if (!STm->defined) {
3731                 retval = (-ENXIO);
3732                 goto out;
3733         }
3734
3735         if ((i = flush_buffer(STp, 0)) < 0) {
3736                 retval = i;
3737                 goto out;
3738         }
3739         if (STp->can_partitions &&
3740             (i = switch_partition(STp)) < 0) {
3741                 retval = i;
3742                 goto out;
3743         }
3744
3745         if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3746                 struct mtget mt_status;
3747
3748                 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3749                          retval = (-EINVAL);
3750                          goto out;
3751                 }
3752
3753                 mt_status.mt_type = STp->tape_type;
3754                 mt_status.mt_dsreg =
3755                     ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3756                     ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3757                 mt_status.mt_blkno = STps->drv_block;
3758                 mt_status.mt_fileno = STps->drv_file;
3759                 if (STp->block_size != 0) {
3760                         if (STps->rw == ST_WRITING)
3761                                 mt_status.mt_blkno +=
3762                                     (STp->buffer)->buffer_bytes / STp->block_size;
3763                         else if (STps->rw == ST_READING)
3764                                 mt_status.mt_blkno -=
3765                                         ((STp->buffer)->buffer_bytes +
3766                                          STp->block_size - 1) / STp->block_size;
3767                 }
3768
3769                 mt_status.mt_gstat = 0;
3770                 if (STp->drv_write_prot)
3771                         mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3772                 if (mt_status.mt_blkno == 0) {
3773                         if (mt_status.mt_fileno == 0)
3774                                 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3775                         else
3776                                 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3777                 }
3778                 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3779                 mt_status.mt_resid = STp->partition;
3780                 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3781                         mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3782                 else if (STps->eof >= ST_EOM_OK)
3783                         mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3784                 if (STp->density == 1)
3785                         mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3786                 else if (STp->density == 2)
3787                         mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3788                 else if (STp->density == 3)
3789                         mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3790                 if (STp->ready == ST_READY)
3791                         mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3792                 if (STp->ready == ST_NO_TAPE)
3793                         mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3794                 if (STps->at_sm)
3795                         mt_status.mt_gstat |= GMT_SM(0xffffffff);
3796                 if (STm->do_async_writes ||
3797                     (STm->do_buffer_writes && STp->block_size != 0) ||
3798                     STp->drv_buffer != 0)
3799                         mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3800                 if (STp->cleaning_req)
3801                         mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3802
3803                 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3804                 if (i) {
3805                         retval = (-EFAULT);
3806                         goto out;
3807                 }
3808
3809                 STp->recover_reg = 0;           /* Clear after read */
3810                 retval = 0;
3811                 goto out;
3812         }                       /* End of MTIOCGET */
3813         if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3814                 struct mtpos mt_pos;
3815                 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3816                          retval = (-EINVAL);
3817                          goto out;
3818                 }
3819                 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3820                         retval = i;
3821                         goto out;
3822                 }
3823                 mt_pos.mt_blkno = blk;
3824                 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3825                 if (i)
3826                         retval = (-EFAULT);
3827                 goto out;
3828         }
3829         mutex_unlock(&STp->lock);
3830         switch (cmd_in) {
3831                 case SCSI_IOCTL_GET_IDLUN:
3832                 case SCSI_IOCTL_GET_BUS_NUMBER:
3833                         break;
3834                 default:
3835                         if ((cmd_in == SG_IO ||
3836                              cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3837                              cmd_in == CDROM_SEND_PACKET) &&
3838                             !capable(CAP_SYS_RAWIO))
3839                                 i = -EPERM;
3840                         else
3841                                 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3842                                                    file->f_mode, cmd_in, p);
3843                         if (i != -ENOTTY)
3844                                 return i;
3845                         break;
3846         }
3847         retval = scsi_ioctl(STp->device, cmd_in, p);
3848         if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3849                 STp->rew_at_close = 0;
3850                 STp->ready = ST_NO_TAPE;
3851         }
3852         return retval;
3853
3854  out:
3855         mutex_unlock(&STp->lock);
3856         return retval;
3857 }
3858
3859 #ifdef CONFIG_COMPAT
3860 static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3861 {
3862         struct scsi_tape *STp = file->private_data;
3863         struct scsi_device *sdev = STp->device;
3864         int ret = -ENOIOCTLCMD;
3865         if (sdev->host->hostt->compat_ioctl) {
3866
3867                 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3868
3869         }
3870         return ret;
3871 }
3872 #endif
3873
3874 \f
3875
3876 /* Try to allocate a new tape buffer. Calling function must not hold
3877    dev_arr_lock. */
3878 static struct st_buffer *new_tape_buffer(int need_dma, int max_sg)
3879 {
3880         struct st_buffer *tb;
3881
3882         tb = kzalloc(sizeof(struct st_buffer), GFP_KERNEL);
3883         if (!tb) {
3884                 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3885                 return NULL;
3886         }
3887         tb->frp_segs = 0;
3888         tb->use_sg = max_sg;
3889         tb->dma = need_dma;
3890         tb->buffer_size = 0;
3891
3892         tb->reserved_pages = kcalloc(max_sg, sizeof(struct page *),
3893                                      GFP_KERNEL);
3894         if (!tb->reserved_pages) {
3895                 kfree(tb);
3896                 return NULL;
3897         }
3898
3899         return tb;
3900 }
3901
3902
3903 /* Try to allocate enough space in the tape buffer */
3904 #define ST_MAX_ORDER 6
3905
3906 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3907 {
3908         int segs, max_segs, b_size, order, got;
3909         gfp_t priority;
3910
3911         if (new_size <= STbuffer->buffer_size)
3912                 return 1;
3913
3914         if (STbuffer->buffer_size <= PAGE_SIZE)
3915                 normalize_buffer(STbuffer);  /* Avoid extra segment */
3916
3917         max_segs = STbuffer->use_sg;
3918
3919         priority = GFP_KERNEL | __GFP_NOWARN;
3920         if (need_dma)
3921                 priority |= GFP_DMA;
3922
3923         if (STbuffer->cleared)
3924                 priority |= __GFP_ZERO;
3925
3926         if (STbuffer->frp_segs) {
3927                 order = STbuffer->reserved_page_order;
3928                 b_size = PAGE_SIZE << order;
3929         } else {
3930                 for (b_size = PAGE_SIZE, order = 0;
3931                      order < ST_MAX_ORDER &&
3932                              max_segs * (PAGE_SIZE << order) < new_size;
3933                      order++, b_size *= 2)
3934                         ;  /* empty */
3935                 STbuffer->reserved_page_order = order;
3936         }
3937         if (max_segs * (PAGE_SIZE << order) < new_size) {
3938                 if (order == ST_MAX_ORDER)
3939                         return 0;
3940                 normalize_buffer(STbuffer);
3941                 return enlarge_buffer(STbuffer, new_size, need_dma);
3942         }
3943
3944         for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3945              segs < max_segs && got < new_size;) {
3946                 struct page *page;
3947
3948                 page = alloc_pages(priority, order);
3949                 if (!page) {
3950                         DEB(STbuffer->buffer_size = got);
3951                         normalize_buffer(STbuffer);
3952                         return 0;
3953                 }
3954
3955                 STbuffer->frp_segs += 1;
3956                 got += b_size;
3957                 STbuffer->buffer_size = got;
3958                 STbuffer->reserved_pages[segs] = page;
3959                 segs++;
3960         }
3961         STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
3962
3963         return 1;
3964 }
3965
3966
3967 /* Make sure that no data from previous user is in the internal buffer */
3968 static void clear_buffer(struct st_buffer * st_bp)
3969 {
3970         int i;
3971
3972         for (i=0; i < st_bp->frp_segs; i++)
3973                 memset(page_address(st_bp->reserved_pages[i]), 0,
3974                        PAGE_SIZE << st_bp->reserved_page_order);
3975         st_bp->cleared = 1;
3976 }
3977
3978
3979 /* Release the extra buffer */
3980 static void normalize_buffer(struct st_buffer * STbuffer)
3981 {
3982         int i, order = STbuffer->reserved_page_order;
3983
3984         for (i = 0; i < STbuffer->frp_segs; i++) {
3985                 __free_pages(STbuffer->reserved_pages[i], order);
3986                 STbuffer->buffer_size -= (PAGE_SIZE << order);
3987         }
3988         STbuffer->frp_segs = 0;
3989         STbuffer->sg_segs = 0;
3990         STbuffer->reserved_page_order = 0;
3991         STbuffer->map_data.offset = 0;
3992 }
3993
3994
3995 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3996    negative error code. */
3997 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3998 {
3999         int i, cnt, res, offset;
4000         int length = PAGE_SIZE << st_bp->reserved_page_order;
4001
4002         for (i = 0, offset = st_bp->buffer_bytes;
4003              i < st_bp->frp_segs && offset >= length; i++)
4004                 offset -= length;
4005         if (i == st_bp->frp_segs) {     /* Should never happen */
4006                 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
4007                 return (-EIO);
4008         }
4009         for (; i < st_bp->frp_segs && do_count > 0; i++) {
4010                 struct page *page = st_bp->reserved_pages[i];
4011                 cnt = length - offset < do_count ? length - offset : do_count;
4012                 res = copy_from_user(page_address(page) + offset, ubp, cnt);
4013                 if (res)
4014                         return (-EFAULT);
4015                 do_count -= cnt;
4016                 st_bp->buffer_bytes += cnt;
4017                 ubp += cnt;
4018                 offset = 0;
4019         }
4020         if (do_count) /* Should never happen */
4021                 return (-EIO);
4022
4023         return 0;
4024 }
4025
4026
4027 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
4028    negative error code. */
4029 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
4030 {
4031         int i, cnt, res, offset;
4032         int length = PAGE_SIZE << st_bp->reserved_page_order;
4033
4034         for (i = 0, offset = st_bp->read_pointer;
4035              i < st_bp->frp_segs && offset >= length; i++)
4036                 offset -= length;
4037         if (i == st_bp->frp_segs) {     /* Should never happen */
4038                 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
4039                 return (-EIO);
4040         }
4041         for (; i < st_bp->frp_segs && do_count > 0; i++) {
4042                 struct page *page = st_bp->reserved_pages[i];
4043                 cnt = length - offset < do_count ? length - offset : do_count;
4044                 res = copy_to_user(ubp, page_address(page) + offset, cnt);
4045                 if (res)
4046                         return (-EFAULT);
4047                 do_count -= cnt;
4048                 st_bp->buffer_bytes -= cnt;
4049                 st_bp->read_pointer += cnt;
4050                 ubp += cnt;
4051                 offset = 0;
4052         }
4053         if (do_count) /* Should never happen */
4054                 return (-EIO);
4055
4056         return 0;
4057 }
4058
4059
4060 /* Move data towards start of buffer */
4061 static void move_buffer_data(struct st_buffer * st_bp, int offset)
4062 {
4063         int src_seg, dst_seg, src_offset = 0, dst_offset;
4064         int count, total;
4065         int length = PAGE_SIZE << st_bp->reserved_page_order;
4066
4067         if (offset == 0)
4068                 return;
4069
4070         total=st_bp->buffer_bytes - offset;
4071         for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
4072                 src_offset = offset;
4073                 if (src_offset < length)
4074                         break;
4075                 offset -= length;
4076         }
4077
4078         st_bp->buffer_bytes = st_bp->read_pointer = total;
4079         for (dst_seg=dst_offset=0; total > 0; ) {
4080                 struct page *dpage = st_bp->reserved_pages[dst_seg];
4081                 struct page *spage = st_bp->reserved_pages[src_seg];
4082
4083                 count = min(length - dst_offset, length - src_offset);
4084                 memmove(page_address(dpage) + dst_offset,
4085                         page_address(spage) + src_offset, count);
4086                 src_offset += count;
4087                 if (src_offset >= length) {
4088                         src_seg++;
4089                         src_offset = 0;
4090                 }
4091                 dst_offset += count;
4092                 if (dst_offset >= length) {
4093                         dst_seg++;
4094                         dst_offset = 0;
4095                 }
4096                 total -= count;
4097         }
4098 }
4099
4100 /* Validate the options from command line or module parameters */
4101 static void validate_options(void)
4102 {
4103         if (buffer_kbs > 0)
4104                 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
4105         if (max_sg_segs >= ST_FIRST_SG)
4106                 st_max_sg_segs = max_sg_segs;
4107 }
4108
4109 #ifndef MODULE
4110 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
4111  */
4112 static int __init st_setup(char *str)
4113 {
4114         int i, len, ints[5];
4115         char *stp;
4116
4117         stp = get_options(str, ARRAY_SIZE(ints), ints);
4118
4119         if (ints[0] > 0) {
4120                 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
4121                         if (parms[i].val)
4122                                 *parms[i].val = ints[i + 1];
4123         } else {
4124                 while (stp != NULL) {
4125                         for (i = 0; i < ARRAY_SIZE(parms); i++) {
4126                                 len = strlen(parms[i].name);
4127                                 if (!strncmp(stp, parms[i].name, len) &&
4128                                     (*(stp + len) == ':' || *(stp + len) == '=')) {
4129                                         if (parms[i].val)
4130                                                 *parms[i].val =
4131                                                         simple_strtoul(stp + len + 1, NULL, 0);
4132                                         else
4133                                                 printk(KERN_WARNING "st: Obsolete parameter %s\n",
4134                                                        parms[i].name);
4135                                         break;
4136                                 }
4137                         }
4138                         if (i >= ARRAY_SIZE(parms))
4139                                  printk(KERN_WARNING "st: invalid parameter in '%s'\n",
4140                                         stp);
4141                         stp = strchr(stp, ',');
4142                         if (stp)
4143                                 stp++;
4144                 }
4145         }
4146
4147         validate_options();
4148
4149         return 1;
4150 }
4151
4152 __setup("st=", st_setup);
4153
4154 #endif
4155
4156 static const struct file_operations st_fops =
4157 {
4158         .owner =        THIS_MODULE,
4159         .read =         st_read,
4160         .write =        st_write,
4161         .unlocked_ioctl = st_ioctl,
4162 #ifdef CONFIG_COMPAT
4163         .compat_ioctl = st_compat_ioctl,
4164 #endif
4165         .open =         st_open,
4166         .flush =        st_flush,
4167         .release =      st_release,
4168         .llseek =       noop_llseek,
4169 };
4170
4171 static int create_one_cdev(struct scsi_tape *tape, int mode, int rew)
4172 {
4173         int i, error;
4174         dev_t cdev_devno;
4175         struct cdev *cdev;
4176         struct device *dev;
4177         struct st_modedef *STm = &(tape->modes[mode]);
4178         char name[10];
4179         int dev_num = tape->index;
4180
4181         cdev_devno = MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, rew));
4182
4183         cdev = cdev_alloc();
4184         if (!cdev) {
4185                 pr_err("st%d: out of memory. Device not attached.\n", dev_num);
4186                 error = -ENOMEM;
4187                 goto out;
4188         }
4189         cdev->owner = THIS_MODULE;
4190         cdev->ops = &st_fops;
4191         STm->cdevs[rew] = cdev;
4192
4193         error = cdev_add(cdev, cdev_devno, 1);
4194         if (error) {
4195                 pr_err("st%d: Can't add %s-rewind mode %d\n", dev_num,
4196                        rew ? "non" : "auto", mode);
4197                 pr_err("st%d: Device not attached.\n", dev_num);
4198                 goto out_free;
4199         }
4200
4201         i = mode << (4 - ST_NBR_MODE_BITS);
4202         snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4203                  tape->disk->disk_name, st_formats[i]);
4204
4205         dev = device_create(&st_sysfs_class, &tape->device->sdev_gendev,
4206                             cdev_devno, &tape->modes[mode], "%s", name);
4207         if (IS_ERR(dev)) {
4208                 pr_err("st%d: device_create failed\n", dev_num);
4209                 error = PTR_ERR(dev);
4210                 goto out_free;
4211         }
4212
4213         STm->devs[rew] = dev;
4214
4215         return 0;
4216 out_free:
4217         cdev_del(STm->cdevs[rew]);
4218 out:
4219         STm->cdevs[rew] = NULL;
4220         STm->devs[rew] = NULL;
4221         return error;
4222 }
4223
4224 static int create_cdevs(struct scsi_tape *tape)
4225 {
4226         int mode, error;
4227         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4228                 error = create_one_cdev(tape, mode, 0);
4229                 if (error)
4230                         return error;
4231                 error = create_one_cdev(tape, mode, 1);
4232                 if (error)
4233                         return error;
4234         }
4235
4236         return sysfs_create_link(&tape->device->sdev_gendev.kobj,
4237                                  &tape->modes[0].devs[0]->kobj, "tape");
4238 }
4239
4240 static void remove_cdevs(struct scsi_tape *tape)
4241 {
4242         int mode, rew;
4243         sysfs_remove_link(&tape->device->sdev_gendev.kobj, "tape");
4244         for (mode = 0; mode < ST_NBR_MODES; mode++) {
4245                 struct st_modedef *STm = &(tape->modes[mode]);
4246                 for (rew = 0; rew < 2; rew++) {
4247                         if (STm->cdevs[rew])
4248                                 cdev_del(STm->cdevs[rew]);
4249                         if (STm->devs[rew])
4250                                 device_unregister(STm->devs[rew]);
4251                 }
4252         }
4253 }
4254
4255 static int st_probe(struct device *dev)
4256 {
4257         struct scsi_device *SDp = to_scsi_device(dev);
4258         struct gendisk *disk = NULL;
4259         struct scsi_tape *tpnt = NULL;
4260         struct st_modedef *STm;
4261         struct st_partstat *STps;
4262         struct st_buffer *buffer;
4263         int i, error;
4264         char *stp;
4265
4266         if (SDp->type != TYPE_TAPE)
4267                 return -ENODEV;
4268         if ((stp = st_incompatible(SDp))) {
4269                 sdev_printk(KERN_INFO, SDp,
4270                             "OnStream tapes are no longer supported;\n");
4271                 sdev_printk(KERN_INFO, SDp,
4272                             "please mail to linux-scsi@vger.kernel.org.\n");
4273                 return -ENODEV;
4274         }
4275
4276         scsi_autopm_get_device(SDp);
4277         i = queue_max_segments(SDp->request_queue);
4278         if (st_max_sg_segs < i)
4279                 i = st_max_sg_segs;
4280         buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
4281         if (buffer == NULL) {
4282                 sdev_printk(KERN_ERR, SDp,
4283                             "st: Can't allocate new tape buffer. "
4284                             "Device not attached.\n");
4285                 goto out;
4286         }
4287
4288         disk = alloc_disk(1);
4289         if (!disk) {
4290                 sdev_printk(KERN_ERR, SDp,
4291                             "st: out of memory. Device not attached.\n");
4292                 goto out_buffer_free;
4293         }
4294
4295         tpnt = kzalloc(sizeof(struct scsi_tape), GFP_KERNEL);
4296         if (tpnt == NULL) {
4297                 sdev_printk(KERN_ERR, SDp,
4298                             "st: Can't allocate device descriptor.\n");
4299                 goto out_put_disk;
4300         }
4301         kref_init(&tpnt->kref);
4302         tpnt->disk = disk;
4303         disk->private_data = &tpnt->driver;
4304         /* SCSI tape doesn't register this gendisk via add_disk().  Manually
4305          * take queue reference that release_disk() expects. */
4306         if (!blk_get_queue(SDp->request_queue))
4307                 goto out_put_disk;
4308         disk->queue = SDp->request_queue;
4309         tpnt->driver = &st_template;
4310
4311         tpnt->device = SDp;
4312         if (SDp->scsi_level <= 2)
4313                 tpnt->tape_type = MT_ISSCSI1;
4314         else
4315                 tpnt->tape_type = MT_ISSCSI2;
4316
4317         tpnt->buffer = buffer;
4318         tpnt->buffer->last_SRpnt = NULL;
4319
4320         tpnt->inited = 0;
4321         tpnt->dirty = 0;
4322         tpnt->in_use = 0;
4323         tpnt->drv_buffer = 1;   /* Try buffering if no mode sense */
4324         tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4325         tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4326         tpnt->density = 0;
4327         tpnt->do_auto_lock = ST_AUTO_LOCK;
4328         tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4329         tpnt->can_partitions = 0;
4330         tpnt->two_fm = ST_TWO_FM;
4331         tpnt->fast_mteom = ST_FAST_MTEOM;
4332         tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4333         tpnt->sili = ST_SILI;
4334         tpnt->immediate = ST_NOWAIT;
4335         tpnt->immediate_filemark = 0;
4336         tpnt->default_drvbuffer = 0xff;         /* No forced buffering */
4337         tpnt->partition = 0;
4338         tpnt->new_partition = 0;
4339         tpnt->nbr_partitions = 0;
4340         blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
4341         tpnt->long_timeout = ST_LONG_TIMEOUT;
4342         tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4343
4344         for (i = 0; i < ST_NBR_MODES; i++) {
4345                 STm = &(tpnt->modes[i]);
4346                 STm->defined = 0;
4347                 STm->sysv = ST_SYSV;
4348                 STm->defaults_for_writes = 0;
4349                 STm->do_async_writes = ST_ASYNC_WRITES;
4350                 STm->do_buffer_writes = ST_BUFFER_WRITES;
4351                 STm->do_read_ahead = ST_READ_AHEAD;
4352                 STm->default_compression = ST_DONT_TOUCH;
4353                 STm->default_blksize = (-1);    /* No forced size */
4354                 STm->default_density = (-1);    /* No forced density */
4355                 STm->tape = tpnt;
4356         }
4357
4358         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4359                 STps = &(tpnt->ps[i]);
4360                 STps->rw = ST_IDLE;
4361                 STps->eof = ST_NOEOF;
4362                 STps->at_sm = 0;
4363                 STps->last_block_valid = 0;
4364                 STps->drv_block = (-1);
4365                 STps->drv_file = (-1);
4366         }
4367
4368         tpnt->current_mode = 0;
4369         tpnt->modes[0].defined = 1;
4370
4371         tpnt->density_changed = tpnt->compression_changed =
4372             tpnt->blksize_changed = 0;
4373         mutex_init(&tpnt->lock);
4374
4375         idr_preload(GFP_KERNEL);
4376         spin_lock(&st_index_lock);
4377         error = idr_alloc(&st_index_idr, tpnt, 0, ST_MAX_TAPES + 1, GFP_NOWAIT);
4378         spin_unlock(&st_index_lock);
4379         idr_preload_end();
4380         if (error < 0) {
4381                 pr_warn("st: idr allocation failed: %d\n", error);
4382                 goto out_put_queue;
4383         }
4384         tpnt->index = error;
4385         sprintf(disk->disk_name, "st%d", tpnt->index);
4386         tpnt->stats = kzalloc(sizeof(struct scsi_tape_stats), GFP_KERNEL);
4387         if (tpnt->stats == NULL) {
4388                 sdev_printk(KERN_ERR, SDp,
4389                             "st: Can't allocate statistics.\n");
4390                 goto out_idr_remove;
4391         }
4392
4393         dev_set_drvdata(dev, tpnt);
4394
4395
4396         error = create_cdevs(tpnt);
4397         if (error)
4398                 goto out_remove_devs;
4399         scsi_autopm_put_device(SDp);
4400
4401         sdev_printk(KERN_NOTICE, SDp,
4402                     "Attached scsi tape %s\n", tape_name(tpnt));
4403         sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4404                     tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4405                     queue_dma_alignment(SDp->request_queue) + 1);
4406
4407         return 0;
4408
4409 out_remove_devs:
4410         remove_cdevs(tpnt);
4411         kfree(tpnt->stats);
4412 out_idr_remove:
4413         spin_lock(&st_index_lock);
4414         idr_remove(&st_index_idr, tpnt->index);
4415         spin_unlock(&st_index_lock);
4416 out_put_queue:
4417         blk_put_queue(disk->queue);
4418 out_put_disk:
4419         put_disk(disk);
4420         kfree(tpnt);
4421 out_buffer_free:
4422         kfree(buffer);
4423 out:
4424         scsi_autopm_put_device(SDp);
4425         return -ENODEV;
4426 };
4427
4428
4429 static int st_remove(struct device *dev)
4430 {
4431         struct scsi_tape *tpnt = dev_get_drvdata(dev);
4432         int index = tpnt->index;
4433
4434         scsi_autopm_get_device(to_scsi_device(dev));
4435         remove_cdevs(tpnt);
4436
4437         mutex_lock(&st_ref_mutex);
4438         kref_put(&tpnt->kref, scsi_tape_release);
4439         mutex_unlock(&st_ref_mutex);
4440         spin_lock(&st_index_lock);
4441         idr_remove(&st_index_idr, index);
4442         spin_unlock(&st_index_lock);
4443         return 0;
4444 }
4445
4446 /**
4447  *      scsi_tape_release - Called to free the Scsi_Tape structure
4448  *      @kref: pointer to embedded kref
4449  *
4450  *      st_ref_mutex must be held entering this routine.  Because it is
4451  *      called on last put, you should always use the scsi_tape_get()
4452  *      scsi_tape_put() helpers which manipulate the semaphore directly
4453  *      and never do a direct kref_put().
4454  **/
4455 static void scsi_tape_release(struct kref *kref)
4456 {
4457         struct scsi_tape *tpnt = to_scsi_tape(kref);
4458         struct gendisk *disk = tpnt->disk;
4459
4460         tpnt->device = NULL;
4461
4462         if (tpnt->buffer) {
4463                 normalize_buffer(tpnt->buffer);
4464                 kfree(tpnt->buffer->reserved_pages);
4465                 kfree(tpnt->buffer);
4466         }
4467
4468         disk->private_data = NULL;
4469         put_disk(disk);
4470         kfree(tpnt->stats);
4471         kfree(tpnt);
4472         return;
4473 }
4474
4475 static struct class st_sysfs_class = {
4476         .name = "scsi_tape",
4477         .dev_groups = st_dev_groups,
4478 };
4479
4480 static int __init init_st(void)
4481 {
4482         int err;
4483
4484         validate_options();
4485
4486         printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4487                 verstr, st_fixed_buffer_size, st_max_sg_segs);
4488
4489         debugging = (debug_flag > 0) ? debug_flag : NO_DEBUG;
4490         if (debugging) {
4491                 printk(KERN_INFO "st: Debugging enabled debug_flag = %d\n",
4492                         debugging);
4493         }
4494
4495         err = class_register(&st_sysfs_class);
4496         if (err) {
4497                 pr_err("Unable register sysfs class for SCSI tapes\n");
4498                 return err;
4499         }
4500
4501         err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4502                                      ST_MAX_TAPE_ENTRIES, "st");
4503         if (err) {
4504                 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4505                        SCSI_TAPE_MAJOR);
4506                 goto err_class;
4507         }
4508
4509         err = scsi_register_driver(&st_template.gendrv);
4510         if (err)
4511                 goto err_chrdev;
4512
4513         return 0;
4514
4515 err_chrdev:
4516         unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4517                                  ST_MAX_TAPE_ENTRIES);
4518 err_class:
4519         class_unregister(&st_sysfs_class);
4520         return err;
4521 }
4522
4523 static void __exit exit_st(void)
4524 {
4525         scsi_unregister_driver(&st_template.gendrv);
4526         unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4527                                  ST_MAX_TAPE_ENTRIES);
4528         class_unregister(&st_sysfs_class);
4529         idr_destroy(&st_index_idr);
4530         printk(KERN_INFO "st: Unloaded.\n");
4531 }
4532
4533 module_init(init_st);
4534 module_exit(exit_st);
4535
4536
4537 /* The sysfs driver interface. Read-only at the moment */
4538 static ssize_t try_direct_io_show(struct device_driver *ddp, char *buf)
4539 {
4540         return scnprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4541 }
4542 static DRIVER_ATTR_RO(try_direct_io);
4543
4544 static ssize_t fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4545 {
4546         return scnprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4547 }
4548 static DRIVER_ATTR_RO(fixed_buffer_size);
4549
4550 static ssize_t max_sg_segs_show(struct device_driver *ddp, char *buf)
4551 {
4552         return scnprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4553 }
4554 static DRIVER_ATTR_RO(max_sg_segs);
4555
4556 static ssize_t version_show(struct device_driver *ddd, char *buf)
4557 {
4558         return scnprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4559 }
4560 static DRIVER_ATTR_RO(version);
4561
4562 #if DEBUG
4563 static ssize_t debug_flag_store(struct device_driver *ddp,
4564         const char *buf, size_t count)
4565 {
4566 /* We only care what the first byte of the data is the rest is unused.
4567  * if it's a '1' we turn on debug and if it's a '0' we disable it. All
4568  * other values have -EINVAL returned if they are passed in.
4569  */
4570         if (count > 0) {
4571                 if (buf[0] == '0') {
4572                         debugging = NO_DEBUG;
4573                         return count;
4574                 } else if (buf[0] == '1') {
4575                         debugging = 1;
4576                         return count;
4577                 }
4578         }
4579         return -EINVAL;
4580 }
4581
4582 static ssize_t debug_flag_show(struct device_driver *ddp, char *buf)
4583 {
4584         return scnprintf(buf, PAGE_SIZE, "%d\n", debugging);
4585 }
4586 static DRIVER_ATTR_RW(debug_flag);
4587 #endif
4588
4589 static struct attribute *st_drv_attrs[] = {
4590         &driver_attr_try_direct_io.attr,
4591         &driver_attr_fixed_buffer_size.attr,
4592         &driver_attr_max_sg_segs.attr,
4593         &driver_attr_version.attr,
4594 #if DEBUG
4595         &driver_attr_debug_flag.attr,
4596 #endif
4597         NULL,
4598 };
4599 ATTRIBUTE_GROUPS(st_drv);
4600
4601 /* The sysfs simple class interface */
4602 static ssize_t
4603 defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4604 {
4605         struct st_modedef *STm = dev_get_drvdata(dev);
4606         ssize_t l = 0;
4607
4608         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4609         return l;
4610 }
4611 static DEVICE_ATTR_RO(defined);
4612
4613 static ssize_t
4614 default_blksize_show(struct device *dev, struct device_attribute *attr,
4615                      char *buf)
4616 {
4617         struct st_modedef *STm = dev_get_drvdata(dev);
4618         ssize_t l = 0;
4619
4620         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4621         return l;
4622 }
4623 static DEVICE_ATTR_RO(default_blksize);
4624
4625 static ssize_t
4626 default_density_show(struct device *dev, struct device_attribute *attr,
4627                      char *buf)
4628 {
4629         struct st_modedef *STm = dev_get_drvdata(dev);
4630         ssize_t l = 0;
4631         char *fmt;
4632
4633         fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4634         l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4635         return l;
4636 }
4637 static DEVICE_ATTR_RO(default_density);
4638
4639 static ssize_t
4640 default_compression_show(struct device *dev, struct device_attribute *attr,
4641                          char *buf)
4642 {
4643         struct st_modedef *STm = dev_get_drvdata(dev);
4644         ssize_t l = 0;
4645
4646         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4647         return l;
4648 }
4649 static DEVICE_ATTR_RO(default_compression);
4650
4651 static ssize_t
4652 options_show(struct device *dev, struct device_attribute *attr, char *buf)
4653 {
4654         struct st_modedef *STm = dev_get_drvdata(dev);
4655         struct scsi_tape *STp = STm->tape;
4656         int options;
4657         ssize_t l = 0;
4658
4659         options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4660         options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4661         options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4662         DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4663         options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4664         options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4665         options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4666         options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4667         options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4668         options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4669         options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4670         options |= STm->sysv ? MT_ST_SYSV : 0;
4671         options |= STp->immediate ? MT_ST_NOWAIT : 0;
4672         options |= STp->immediate_filemark ? MT_ST_NOWAIT_EOF : 0;
4673         options |= STp->sili ? MT_ST_SILI : 0;
4674
4675         l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4676         return l;
4677 }
4678 static DEVICE_ATTR_RO(options);
4679
4680 /* Support for tape stats */
4681
4682 /**
4683  * read_cnt_show - return read count - count of reads made from tape drive
4684  * @dev: struct device
4685  * @attr: attribute structure
4686  * @buf: buffer to return formatted data in
4687  */
4688 static ssize_t read_cnt_show(struct device *dev,
4689         struct device_attribute *attr, char *buf)
4690 {
4691         struct st_modedef *STm = dev_get_drvdata(dev);
4692
4693         return sprintf(buf, "%lld",
4694                        (long long)atomic64_read(&STm->tape->stats->read_cnt));
4695 }
4696 static DEVICE_ATTR_RO(read_cnt);
4697
4698 /**
4699  * read_byte_cnt_show - return read byte count - tape drives
4700  * may use blocks less than 512 bytes this gives the raw byte count of
4701  * of data read from the tape drive.
4702  * @dev: struct device
4703  * @attr: attribute structure
4704  * @buf: buffer to return formatted data in
4705  */
4706 static ssize_t read_byte_cnt_show(struct device *dev,
4707         struct device_attribute *attr, char *buf)
4708 {
4709         struct st_modedef *STm = dev_get_drvdata(dev);
4710
4711         return sprintf(buf, "%lld",
4712                        (long long)atomic64_read(&STm->tape->stats->read_byte_cnt));
4713 }
4714 static DEVICE_ATTR_RO(read_byte_cnt);
4715
4716 /**
4717  * read_ns_show - return read ns - overall time spent waiting on reads in ns.
4718  * @dev: struct device
4719  * @attr: attribute structure
4720  * @buf: buffer to return formatted data in
4721  */
4722 static ssize_t read_ns_show(struct device *dev,
4723         struct device_attribute *attr, char *buf)
4724 {
4725         struct st_modedef *STm = dev_get_drvdata(dev);
4726
4727         return sprintf(buf, "%lld",
4728                        (long long)atomic64_read(&STm->tape->stats->tot_read_time));
4729 }
4730 static DEVICE_ATTR_RO(read_ns);
4731
4732 /**
4733  * write_cnt_show - write count - number of user calls
4734  * to write(2) that have written data to tape.
4735  * @dev: struct device
4736  * @attr: attribute structure
4737  * @buf: buffer to return formatted data in
4738  */
4739 static ssize_t write_cnt_show(struct device *dev,
4740         struct device_attribute *attr, char *buf)
4741 {
4742         struct st_modedef *STm = dev_get_drvdata(dev);
4743
4744         return sprintf(buf, "%lld",
4745                        (long long)atomic64_read(&STm->tape->stats->write_cnt));
4746 }
4747 static DEVICE_ATTR_RO(write_cnt);
4748
4749 /**
4750  * write_byte_cnt_show - write byte count - raw count of
4751  * bytes written to tape.
4752  * @dev: struct device
4753  * @attr: attribute structure
4754  * @buf: buffer to return formatted data in
4755  */
4756 static ssize_t write_byte_cnt_show(struct device *dev,
4757         struct device_attribute *attr, char *buf)
4758 {
4759         struct st_modedef *STm = dev_get_drvdata(dev);
4760
4761         return sprintf(buf, "%lld",
4762                        (long long)atomic64_read(&STm->tape->stats->write_byte_cnt));
4763 }
4764 static DEVICE_ATTR_RO(write_byte_cnt);
4765
4766 /**
4767  * write_ns_show - write ns - number of nanoseconds waiting on write
4768  * requests to complete.
4769  * @dev: struct device
4770  * @attr: attribute structure
4771  * @buf: buffer to return formatted data in
4772  */
4773 static ssize_t write_ns_show(struct device *dev,
4774         struct device_attribute *attr, char *buf)
4775 {
4776         struct st_modedef *STm = dev_get_drvdata(dev);
4777
4778         return sprintf(buf, "%lld",
4779                        (long long)atomic64_read(&STm->tape->stats->tot_write_time));
4780 }
4781 static DEVICE_ATTR_RO(write_ns);
4782
4783 /**
4784  * in_flight_show - number of I/Os currently in flight -
4785  * in most cases this will be either 0 or 1. It may be higher if someone
4786  * has also issued other SCSI commands such as via an ioctl.
4787  * @dev: struct device
4788  * @attr: attribute structure
4789  * @buf: buffer to return formatted data in
4790  */
4791 static ssize_t in_flight_show(struct device *dev,
4792         struct device_attribute *attr, char *buf)
4793 {
4794         struct st_modedef *STm = dev_get_drvdata(dev);
4795
4796         return sprintf(buf, "%lld",
4797                        (long long)atomic64_read(&STm->tape->stats->in_flight));
4798 }
4799 static DEVICE_ATTR_RO(in_flight);
4800
4801 /**
4802  * io_ns_show - io wait ns - this is the number of ns spent
4803  * waiting on all I/O to complete. This includes tape movement commands
4804  * such as rewinding, seeking to end of file or tape, it also includes
4805  * read and write. To determine the time spent on tape movement
4806  * subtract the read and write ns from this value.
4807  * @dev: struct device
4808  * @attr: attribute structure
4809  * @buf: buffer to return formatted data in
4810  */
4811 static ssize_t io_ns_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->tot_io_time));
4818 }
4819 static DEVICE_ATTR_RO(io_ns);
4820
4821 /**
4822  * other_cnt_show - other io count - this is the number of
4823  * I/O requests other than read and write requests.
4824  * Typically these are tape movement requests but will include driver
4825  * tape movement. This includes only requests issued by the st driver.
4826  * @dev: struct device
4827  * @attr: attribute structure
4828  * @buf: buffer to return formatted data in
4829  */
4830 static ssize_t other_cnt_show(struct device *dev,
4831         struct device_attribute *attr, char *buf)
4832 {
4833         struct st_modedef *STm = dev_get_drvdata(dev);
4834
4835         return sprintf(buf, "%lld",
4836                        (long long)atomic64_read(&STm->tape->stats->other_cnt));
4837 }
4838 static DEVICE_ATTR_RO(other_cnt);
4839
4840 /**
4841  * resid_cnt_show - A count of the number of times we get a residual
4842  * count - this should indicate someone issuing reads larger than the
4843  * block size on tape.
4844  * @dev: struct device
4845  * @attr: attribute structure
4846  * @buf: buffer to return formatted data in
4847  */
4848 static ssize_t resid_cnt_show(struct device *dev,
4849         struct device_attribute *attr, char *buf)
4850 {
4851         struct st_modedef *STm = dev_get_drvdata(dev);
4852
4853         return sprintf(buf, "%lld",
4854                        (long long)atomic64_read(&STm->tape->stats->resid_cnt));
4855 }
4856 static DEVICE_ATTR_RO(resid_cnt);
4857
4858 static struct attribute *st_dev_attrs[] = {
4859         &dev_attr_defined.attr,
4860         &dev_attr_default_blksize.attr,
4861         &dev_attr_default_density.attr,
4862         &dev_attr_default_compression.attr,
4863         &dev_attr_options.attr,
4864         NULL,
4865 };
4866
4867 static struct attribute *st_stats_attrs[] = {
4868         &dev_attr_read_cnt.attr,
4869         &dev_attr_read_byte_cnt.attr,
4870         &dev_attr_read_ns.attr,
4871         &dev_attr_write_cnt.attr,
4872         &dev_attr_write_byte_cnt.attr,
4873         &dev_attr_write_ns.attr,
4874         &dev_attr_in_flight.attr,
4875         &dev_attr_io_ns.attr,
4876         &dev_attr_other_cnt.attr,
4877         &dev_attr_resid_cnt.attr,
4878         NULL,
4879 };
4880
4881 static struct attribute_group stats_group = {
4882         .name = "stats",
4883         .attrs = st_stats_attrs,
4884 };
4885
4886 static struct attribute_group st_group = {
4887         .attrs = st_dev_attrs,
4888 };
4889
4890 static const struct attribute_group *st_dev_groups[] = {
4891         &st_group,
4892         &stats_group,
4893         NULL,
4894 };
4895
4896 /* The following functions may be useful for a larger audience. */
4897 static int sgl_map_user_pages(struct st_buffer *STbp,
4898                               const unsigned int max_pages, unsigned long uaddr,
4899                               size_t count, int rw)
4900 {
4901         unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4902         unsigned long start = uaddr >> PAGE_SHIFT;
4903         const int nr_pages = end - start;
4904         int res, i, j;
4905         struct page **pages;
4906         struct rq_map_data *mdata = &STbp->map_data;
4907
4908         /* User attempted Overflow! */
4909         if ((uaddr + count) < uaddr)
4910                 return -EINVAL;
4911
4912         /* Too big */
4913         if (nr_pages > max_pages)
4914                 return -ENOMEM;
4915
4916         /* Hmm? */
4917         if (count == 0)
4918                 return 0;
4919
4920         pages = kmalloc_array(max_pages, sizeof(*pages), GFP_KERNEL);
4921         if (pages == NULL)
4922                 return -ENOMEM;
4923
4924         /* Try to fault in all of the necessary pages */
4925         /* rw==READ means read from drive, write into memory area */
4926         res = get_user_pages_fast(uaddr, nr_pages, rw == READ ? FOLL_WRITE : 0,
4927                                   pages);
4928
4929         /* Errors and no page mapped should return here */
4930         if (res < nr_pages)
4931                 goto out_unmap;
4932
4933         for (i=0; i < nr_pages; i++) {
4934                 /* FIXME: flush superflous for rw==READ,
4935                  * probably wrong function for rw==WRITE
4936                  */
4937                 flush_dcache_page(pages[i]);
4938         }
4939
4940         mdata->offset = uaddr & ~PAGE_MASK;
4941         STbp->mapped_pages = pages;
4942
4943         return nr_pages;
4944  out_unmap:
4945         if (res > 0) {
4946                 for (j=0; j < res; j++)
4947                         put_page(pages[j]);
4948                 res = 0;
4949         }
4950         kfree(pages);
4951         return res;
4952 }
4953
4954
4955 /* And unmap them... */
4956 static int sgl_unmap_user_pages(struct st_buffer *STbp,
4957                                 const unsigned int nr_pages, int dirtied)
4958 {
4959         int i;
4960
4961         for (i=0; i < nr_pages; i++) {
4962                 struct page *page = STbp->mapped_pages[i];
4963
4964                 if (dirtied)
4965                         SetPageDirty(page);
4966                 /* FIXME: cache flush missing for rw==READ
4967                  * FIXME: call the correct reference counting function
4968                  */
4969                 put_page(page);
4970         }
4971         kfree(STbp->mapped_pages);
4972         STbp->mapped_pages = NULL;
4973
4974         return 0;
4975 }