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