drivers/s390/char/tape_char.c

   1 /*
   2  *  drivers/s390/char/tape_char.c
   3  *    character device frontend for tape device driver
   4  *
   5  *  S390 and zSeries version
   6  *    Copyright (C) 2001,2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
   7  *    Author(s): Carsten Otte <cotte@de.ibm.com>
   8  *               Michael Holzheu <holzheu@de.ibm.com>
   9  *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
  10  *               Martin Schwidefsky <schwidefsky@de.ibm.com>
  11  */
  12
  13 #include <linux/config.h>
  14 #include <linux/module.h>
  15 #include <linux/types.h>
  16 #include <linux/proc_fs.h>
  17 #include <linux/mtio.h>
  18
  19 #include <asm/uaccess.h>
  20
  21 #define TAPE_DBF_AREA   tape_core_dbf
  22
  23 #include "tape.h"
  24 #include "tape_std.h"
  25 #include "tape_class.h"
  26
  27 #define PRINTK_HEADER "TAPE_CHAR: "
  28
  29 #define TAPECHAR_MAJOR          0       /* get dynamic major */
  30
  31 /*
  32  * file operation structure for tape character frontend
  33  */
  34 static ssize_t tapechar_read(struct file *, char __user *, size_t, loff_t *);
  35 static ssize_t tapechar_write(struct file *, const char __user *, size_t, loff_t *);
  36 static int tapechar_open(struct inode *,struct file *);
  37 static int tapechar_release(struct inode *,struct file *);
  38 static int tapechar_ioctl(struct inode *, struct file *, unsigned int,
  39                           unsigned long);
  40 static long tapechar_compat_ioctl(struct file *, unsigned int,
  41                           unsigned long);
  42
  43 static struct file_operations tape_fops =
  44 {
  45         .owner = THIS_MODULE,
  46         .read = tapechar_read,
  47         .write = tapechar_write,
  48         .ioctl = tapechar_ioctl,
  49         .compat_ioctl = tapechar_compat_ioctl,
  50         .open = tapechar_open,
  51         .release = tapechar_release,
  52 };
  53
  54 static int tapechar_major = TAPECHAR_MAJOR;
  55
  56 /*
  57  * This function is called for every new tapedevice
  58  */
  59 int
  60 tapechar_setup_device(struct tape_device * device)
  61 {
  62         char    device_name[20];
  63
  64         sprintf(device_name, "ntibm%i", device->first_minor / 2);
  65         device->nt = register_tape_dev(
  66                 &device->cdev->dev,
  67                 MKDEV(tapechar_major, device->first_minor),
  68                 &tape_fops,
  69                 device_name,
  70                 "non-rewinding"
  71         );
  72         device_name[0] = 'r';
  73         device->rt = register_tape_dev(
  74                 &device->cdev->dev,
  75                 MKDEV(tapechar_major, device->first_minor + 1),
  76                 &tape_fops,
  77                 device_name,
  78                 "rewinding"
  79         );
  80
  81         return 0;
  82 }
  83
  84 void
  85 tapechar_cleanup_device(struct tape_device *device)
  86 {
  87         unregister_tape_dev(device->rt);
  88         device->rt = NULL;
  89         unregister_tape_dev(device->nt);
  90         device->nt = NULL;
  91 }
  92
  93 /*
  94  * Terminate write command (we write two TMs and skip backward over last)
  95  * This ensures that the tape is always correctly terminated.
  96  * When the user writes afterwards a new file, he will overwrite the
  97  * second TM and therefore one TM will remain to separate the
  98  * two files on the tape...
  99  */
 100 static inline void
 101 tapechar_terminate_write(struct tape_device *device)
 102 {
 103         if (tape_mtop(device, MTWEOF, 1) == 0 &&
 104             tape_mtop(device, MTWEOF, 1) == 0)
 105                 tape_mtop(device, MTBSR, 1);
 106 }
 107
 108 static inline int
 109 tapechar_check_idalbuffer(struct tape_device *device, size_t block_size)
 110 {
 111         struct idal_buffer *new;
 112
 113         if (device->char_data.idal_buf != NULL &&
 114             device->char_data.idal_buf->size == block_size)
 115                 return 0;
 116
 117         if (block_size > MAX_BLOCKSIZE) {
 118                 DBF_EVENT(3, "Invalid blocksize (%zd > %d)\n",
 119                         block_size, MAX_BLOCKSIZE);
 120                 PRINT_ERR("Invalid blocksize (%zd> %d)\n",
 121                         block_size, MAX_BLOCKSIZE);
 122                 return -EINVAL;
 123         }
 124
 125         /* The current idal buffer is not correct. Allocate a new one. */
 126         new = idal_buffer_alloc(block_size, 0);
 127         if (new == NULL)
 128                 return -ENOMEM;
 129
 130         if (device->char_data.idal_buf != NULL)
 131                 idal_buffer_free(device->char_data.idal_buf);
 132
 133         device->char_data.idal_buf = new;
 134
 135         return 0;
 136 }
 137
 138 /*
 139  * Tape device read function
 140  */
 141 ssize_t
 142 tapechar_read(struct file *filp, char __user *data, size_t count, loff_t *ppos)
 143 {
 144         struct tape_device *device;
 145         struct tape_request *request;
 146         size_t block_size;
 147         int rc;
 148
 149         DBF_EVENT(6, "TCHAR:read\n");
 150         device = (struct tape_device *) filp->private_data;
 151
 152         /*
 153          * If the tape isn't terminated yet, do it now. And since we then
 154          * are at the end of the tape there wouldn't be anything to read
 155          * anyways. So we return immediatly.
 156          */
 157         if(device->required_tapemarks) {
 158                 return tape_std_terminate_write(device);
 159         }
 160
 161         /* Find out block size to use */
 162         if (device->char_data.block_size != 0) {
 163                 if (count < device->char_data.block_size) {
 164                         DBF_EVENT(3, "TCHAR:read smaller than block "
 165                                   "size was requested\n");
 166                         return -EINVAL;
 167                 }
 168                 block_size = device->char_data.block_size;
 169         } else {
 170                 block_size = count;
 171         }
 172
 173         rc = tapechar_check_idalbuffer(device, block_size);
 174         if (rc)
 175                 return rc;
 176
 177 #ifdef CONFIG_S390_TAPE_BLOCK
 178         /* Changes position. */
 179         device->blk_data.medium_changed = 1;
 180 #endif
 181
 182         DBF_EVENT(6, "TCHAR:nbytes: %lx\n", block_size);
 183         /* Let the discipline build the ccw chain. */
 184         request = device->discipline->read_block(device, block_size);
 185         if (IS_ERR(request))
 186                 return PTR_ERR(request);
 187         /* Execute it. */
 188         rc = tape_do_io(device, request);
 189         if (rc == 0) {
 190                 rc = block_size - request->rescnt;
 191                 DBF_EVENT(6, "TCHAR:rbytes:  %x\n", rc);
 192                 filp->f_pos += rc;
 193                 /* Copy data from idal buffer to user space. */
 194                 if (idal_buffer_to_user(device->char_data.idal_buf,
 195                                         data, rc) != 0)
 196                         rc = -EFAULT;
 197         }
 198         tape_free_request(request);
 199         return rc;
 200 }
 201
 202 /*
 203  * Tape device write function
 204  */
 205 ssize_t
 206 tapechar_write(struct file *filp, const char __user *data, size_t count, loff_t *ppos)
 207 {
 208         struct tape_device *device;
 209         struct tape_request *request;
 210         size_t block_size;
 211         size_t written;
 212         int nblocks;
 213         int i, rc;
 214
 215         DBF_EVENT(6, "TCHAR:write\n");
 216         device = (struct tape_device *) filp->private_data;
 217         /* Find out block size and number of blocks */
 218         if (device->char_data.block_size != 0) {
 219                 if (count < device->char_data.block_size) {
 220                         DBF_EVENT(3, "TCHAR:write smaller than block "
 221                                   "size was requested\n");
 222                         return -EINVAL;
 223                 }
 224                 block_size = device->char_data.block_size;
 225                 nblocks = count / block_size;
 226         } else {
 227                 block_size = count;
 228                 nblocks = 1;
 229         }
 230
 231         rc = tapechar_check_idalbuffer(device, block_size);
 232         if (rc)
 233                 return rc;
 234
 235 #ifdef CONFIG_S390_TAPE_BLOCK
 236         /* Changes position. */
 237         device->blk_data.medium_changed = 1;
 238 #endif
 239
 240         DBF_EVENT(6,"TCHAR:nbytes: %lx\n", block_size);
 241         DBF_EVENT(6, "TCHAR:nblocks: %x\n", nblocks);
 242         /* Let the discipline build the ccw chain. */
 243         request = device->discipline->write_block(device, block_size);
 244         if (IS_ERR(request))
 245                 return PTR_ERR(request);
 246         rc = 0;
 247         written = 0;
 248         for (i = 0; i < nblocks; i++) {
 249                 /* Copy data from user space to idal buffer. */
 250                 if (idal_buffer_from_user(device->char_data.idal_buf,
 251                                           data, block_size)) {
 252                         rc = -EFAULT;
 253                         break;
 254                 }
 255                 rc = tape_do_io(device, request);
 256                 if (rc)
 257                         break;
 258                 DBF_EVENT(6, "TCHAR:wbytes: %lx\n",
 259                           block_size - request->rescnt);
 260                 filp->f_pos += block_size - request->rescnt;
 261                 written += block_size - request->rescnt;
 262                 if (request->rescnt != 0)
 263                         break;
 264                 data += block_size;
 265         }
 266         tape_free_request(request);
 267         if (rc == -ENOSPC) {
 268                 /*
 269                  * Ok, the device has no more space. It has NOT written
 270                  * the block.
 271                  */
 272                 if (device->discipline->process_eov)
 273                         device->discipline->process_eov(device);
 274                 if (written > 0)
 275                         rc = 0;
 276
 277         }
 278
 279         /*
 280          * After doing a write we always need two tapemarks to correctly
 281          * terminate the tape (one to terminate the file, the second to
 282          * flag the end of recorded data.
 283          * Since process_eov positions the tape in front of the written
 284          * tapemark it doesn't hurt to write two marks again.
 285          */
 286         if (!rc)
 287                 device->required_tapemarks = 2;
 288
 289         return rc ? rc : written;
 290 }
 291
 292 /*
 293  * Character frontend tape device open function.
 294  */
 295 int
 296 tapechar_open (struct inode *inode, struct file *filp)
 297 {
 298         struct tape_device *device;
 299         int minor, rc;
 300
 301         DBF_EVENT(6, "TCHAR:open: %i:%i\n",
 302                 imajor(filp->f_dentry->d_inode),
 303                 iminor(filp->f_dentry->d_inode));
 304
 305         if (imajor(filp->f_dentry->d_inode) != tapechar_major)
 306                 return -ENODEV;
 307
 308         minor = iminor(filp->f_dentry->d_inode);
 309         device = tape_get_device(minor / TAPE_MINORS_PER_DEV);
 310         if (IS_ERR(device)) {
 311                 DBF_EVENT(3, "TCHAR:open: tape_get_device() failed\n");
 312                 return PTR_ERR(device);
 313         }
 314
 315
 316         rc = tape_open(device);
 317         if (rc == 0) {
 318                 filp->private_data = device;
 319                 return nonseekable_open(inode, filp);
 320         }
 321         tape_put_device(device);
 322
 323         return rc;
 324 }
 325
 326 /*
 327  * Character frontend tape device release function.
 328  */
 329
 330 int
 331 tapechar_release(struct inode *inode, struct file *filp)
 332 {
 333         struct tape_device *device;
 334
 335         DBF_EVENT(6, "TCHAR:release: %x\n", iminor(inode));
 336         device = (struct tape_device *) filp->private_data;
 337
 338         /*
 339          * If this is the rewinding tape minor then rewind. In that case we
 340          * write all required tapemarks. Otherwise only one to terminate the
 341          * file.
 342          */
 343         if ((iminor(inode) & 1) != 0) {
 344                 if (device->required_tapemarks)
 345                         tape_std_terminate_write(device);
 346                 tape_mtop(device, MTREW, 1);
 347         } else {
 348                 if (device->required_tapemarks > 1) {
 349                         if (tape_mtop(device, MTWEOF, 1) == 0)
 350                                 device->required_tapemarks--;
 351                 }
 352         }
 353
 354         if (device->char_data.idal_buf != NULL) {
 355                 idal_buffer_free(device->char_data.idal_buf);
 356                 device->char_data.idal_buf = NULL;
 357         }
 358         tape_release(device);
 359         filp->private_data = tape_put_device(device);
 360
 361         return 0;
 362 }
 363
 364 /*
 365  * Tape device io controls.
 366  */
 367 static int
 368 tapechar_ioctl(struct inode *inp, struct file *filp,
 369                unsigned int no, unsigned long data)
 370 {
 371         struct tape_device *device;
 372         int rc;
 373
 374         DBF_EVENT(6, "TCHAR:ioct\n");
 375
 376         device = (struct tape_device *) filp->private_data;
 377
 378         if (no == MTIOCTOP) {
 379                 struct mtop op;
 380
 381                 if (copy_from_user(&op, (char __user *) data, sizeof(op)) != 0)
 382                         return -EFAULT;
 383                 if (op.mt_count < 0)
 384                         return -EINVAL;
 385
 386                 /*
 387                  * Operations that change tape position should write final
 388                  * tapemarks.
 389                  */
 390                 switch (op.mt_op) {
 391                         case MTFSF:
 392                         case MTBSF:
 393                         case MTFSR:
 394                         case MTBSR:
 395                         case MTREW:
 396                         case MTOFFL:
 397                         case MTEOM:
 398                         case MTRETEN:
 399                         case MTBSFM:
 400                         case MTFSFM:
 401                         case MTSEEK:
 402 #ifdef CONFIG_S390_TAPE_BLOCK
 403                                 device->blk_data.medium_changed = 1;
 404 #endif
 405                                 if (device->required_tapemarks)
 406                                         tape_std_terminate_write(device);
 407                         default:
 408                                 ;
 409                 }
 410                 rc = tape_mtop(device, op.mt_op, op.mt_count);
 411
 412                 if (op.mt_op == MTWEOF && rc == 0) {
 413                         if (op.mt_count > device->required_tapemarks)
 414                                 device->required_tapemarks = 0;
 415                         else
 416                                 device->required_tapemarks -= op.mt_count;
 417                 }
 418                 return rc;
 419         }
 420         if (no == MTIOCPOS) {
 421                 /* MTIOCPOS: query the tape position. */
 422                 struct mtpos pos;
 423
 424                 rc = tape_mtop(device, MTTELL, 1);
 425                 if (rc < 0)
 426                         return rc;
 427                 pos.mt_blkno = rc;
 428                 if (copy_to_user((char __user *) data, &pos, sizeof(pos)) != 0)
 429                         return -EFAULT;
 430                 return 0;
 431         }
 432         if (no == MTIOCGET) {
 433                 /* MTIOCGET: query the tape drive status. */
 434                 struct mtget get;
 435
 436                 memset(&get, 0, sizeof(get));
 437                 get.mt_type = MT_ISUNKNOWN;
 438                 get.mt_resid = 0 /* device->devstat.rescnt */;
 439                 get.mt_dsreg = device->tape_state;
 440                 /* FIXME: mt_gstat, mt_erreg, mt_fileno */
 441                 get.mt_gstat = 0;
 442                 get.mt_erreg = 0;
 443                 get.mt_fileno = 0;
 444                 get.mt_gstat  = device->tape_generic_status;
 445
 446                 if (device->medium_state == MS_LOADED) {
 447                         rc = tape_mtop(device, MTTELL, 1);
 448
 449                         if (rc < 0)
 450                                 return rc;
 451
 452                         if (rc == 0)
 453                                 get.mt_gstat |= GMT_BOT(~0);
 454
 455                         get.mt_blkno = rc;
 456                 }
 457
 458                 if (copy_to_user((char __user *) data, &get, sizeof(get)) != 0)
 459                         return -EFAULT;
 460
 461                 return 0;
 462         }
 463         /* Try the discipline ioctl function. */
 464         if (device->discipline->ioctl_fn == NULL)
 465                 return -EINVAL;
 466         return device->discipline->ioctl_fn(device, no, data);
 467 }
 468
 469 static long
 470 tapechar_compat_ioctl(struct file *filp, unsigned int no, unsigned long data)
 471 {
 472         struct tape_device *device = filp->private_data;
 473         int rval = -ENOIOCTLCMD;
 474
 475         if (device->discipline->ioctl_fn) {
 476                 lock_kernel();
 477                 rval = device->discipline->ioctl_fn(device, no, data);
 478                 unlock_kernel();
 479                 if (rval == -EINVAL)
 480                         rval = -ENOIOCTLCMD;
 481         }
 482
 483         return rval;
 484 }
 485
 486 /*
 487  * Initialize character device frontend.
 488  */
 489 int
 490 tapechar_init (void)
 491 {
 492         dev_t   dev;
 493
 494         if (alloc_chrdev_region(&dev, 0, 256, "tape") != 0)
 495                 return -1;
 496
 497         tapechar_major = MAJOR(dev);
 498         PRINT_INFO("tape gets major %d for character devices\n", MAJOR(dev));
 499
 500         return 0;
 501 }
 502
 503 /*
 504  * cleanup
 505  */
 506 void
 507 tapechar_exit(void)
 508 {
 509         PRINT_INFO("tape releases major %d for character devices\n",
 510                 tapechar_major);
 511         unregister_chrdev_region(MKDEV(tapechar_major, 0), 256);
 512 }