drivers/scsi/st.c

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