drivers/scsi/st.c

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