![Heiko Carstens](/assets/img/avatar_default.png)
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com> Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
513 lines
12 KiB
C
513 lines
12 KiB
C
/*
|
|
* drivers/s390/char/tape_char.c
|
|
* character device frontend for tape device driver
|
|
*
|
|
* S390 and zSeries version
|
|
* Copyright IBM Corp. 2001,2006
|
|
* Author(s): Carsten Otte <cotte@de.ibm.com>
|
|
* Michael Holzheu <holzheu@de.ibm.com>
|
|
* Tuan Ngo-Anh <ngoanh@de.ibm.com>
|
|
* Martin Schwidefsky <schwidefsky@de.ibm.com>
|
|
*/
|
|
|
|
#define KMSG_COMPONENT "tape"
|
|
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/types.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/mtio.h>
|
|
#include <linux/smp_lock.h>
|
|
#include <linux/compat.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#define TAPE_DBF_AREA tape_core_dbf
|
|
|
|
#include "tape.h"
|
|
#include "tape_std.h"
|
|
#include "tape_class.h"
|
|
|
|
#define TAPECHAR_MAJOR 0 /* get dynamic major */
|
|
|
|
/*
|
|
* file operation structure for tape character frontend
|
|
*/
|
|
static ssize_t tapechar_read(struct file *, char __user *, size_t, loff_t *);
|
|
static ssize_t tapechar_write(struct file *, const char __user *, size_t, loff_t *);
|
|
static int tapechar_open(struct inode *,struct file *);
|
|
static int tapechar_release(struct inode *,struct file *);
|
|
static long tapechar_ioctl(struct file *, unsigned int, unsigned long);
|
|
#ifdef CONFIG_COMPAT
|
|
static long tapechar_compat_ioctl(struct file *, unsigned int, unsigned long);
|
|
#endif
|
|
|
|
static const struct file_operations tape_fops =
|
|
{
|
|
.owner = THIS_MODULE,
|
|
.read = tapechar_read,
|
|
.write = tapechar_write,
|
|
.unlocked_ioctl = tapechar_ioctl,
|
|
#ifdef CONFIG_COMPAT
|
|
.compat_ioctl = tapechar_compat_ioctl,
|
|
#endif
|
|
.open = tapechar_open,
|
|
.release = tapechar_release,
|
|
};
|
|
|
|
static int tapechar_major = TAPECHAR_MAJOR;
|
|
|
|
/*
|
|
* This function is called for every new tapedevice
|
|
*/
|
|
int
|
|
tapechar_setup_device(struct tape_device * device)
|
|
{
|
|
char device_name[20];
|
|
|
|
sprintf(device_name, "ntibm%i", device->first_minor / 2);
|
|
device->nt = register_tape_dev(
|
|
&device->cdev->dev,
|
|
MKDEV(tapechar_major, device->first_minor),
|
|
&tape_fops,
|
|
device_name,
|
|
"non-rewinding"
|
|
);
|
|
device_name[0] = 'r';
|
|
device->rt = register_tape_dev(
|
|
&device->cdev->dev,
|
|
MKDEV(tapechar_major, device->first_minor + 1),
|
|
&tape_fops,
|
|
device_name,
|
|
"rewinding"
|
|
);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
tapechar_cleanup_device(struct tape_device *device)
|
|
{
|
|
unregister_tape_dev(&device->cdev->dev, device->rt);
|
|
device->rt = NULL;
|
|
unregister_tape_dev(&device->cdev->dev, device->nt);
|
|
device->nt = NULL;
|
|
}
|
|
|
|
static int
|
|
tapechar_check_idalbuffer(struct tape_device *device, size_t block_size)
|
|
{
|
|
struct idal_buffer *new;
|
|
|
|
if (device->char_data.idal_buf != NULL &&
|
|
device->char_data.idal_buf->size == block_size)
|
|
return 0;
|
|
|
|
if (block_size > MAX_BLOCKSIZE) {
|
|
DBF_EVENT(3, "Invalid blocksize (%zd > %d)\n",
|
|
block_size, MAX_BLOCKSIZE);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* The current idal buffer is not correct. Allocate a new one. */
|
|
new = idal_buffer_alloc(block_size, 0);
|
|
if (IS_ERR(new))
|
|
return -ENOMEM;
|
|
|
|
if (device->char_data.idal_buf != NULL)
|
|
idal_buffer_free(device->char_data.idal_buf);
|
|
|
|
device->char_data.idal_buf = new;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Tape device read function
|
|
*/
|
|
static ssize_t
|
|
tapechar_read(struct file *filp, char __user *data, size_t count, loff_t *ppos)
|
|
{
|
|
struct tape_device *device;
|
|
struct tape_request *request;
|
|
size_t block_size;
|
|
int rc;
|
|
|
|
DBF_EVENT(6, "TCHAR:read\n");
|
|
device = (struct tape_device *) filp->private_data;
|
|
|
|
/*
|
|
* If the tape isn't terminated yet, do it now. And since we then
|
|
* are at the end of the tape there wouldn't be anything to read
|
|
* anyways. So we return immediatly.
|
|
*/
|
|
if(device->required_tapemarks) {
|
|
return tape_std_terminate_write(device);
|
|
}
|
|
|
|
/* Find out block size to use */
|
|
if (device->char_data.block_size != 0) {
|
|
if (count < device->char_data.block_size) {
|
|
DBF_EVENT(3, "TCHAR:read smaller than block "
|
|
"size was requested\n");
|
|
return -EINVAL;
|
|
}
|
|
block_size = device->char_data.block_size;
|
|
} else {
|
|
block_size = count;
|
|
}
|
|
|
|
rc = tapechar_check_idalbuffer(device, block_size);
|
|
if (rc)
|
|
return rc;
|
|
|
|
#ifdef CONFIG_S390_TAPE_BLOCK
|
|
/* Changes position. */
|
|
device->blk_data.medium_changed = 1;
|
|
#endif
|
|
|
|
DBF_EVENT(6, "TCHAR:nbytes: %lx\n", block_size);
|
|
/* Let the discipline build the ccw chain. */
|
|
request = device->discipline->read_block(device, block_size);
|
|
if (IS_ERR(request))
|
|
return PTR_ERR(request);
|
|
/* Execute it. */
|
|
rc = tape_do_io(device, request);
|
|
if (rc == 0) {
|
|
rc = block_size - request->rescnt;
|
|
DBF_EVENT(6, "TCHAR:rbytes: %x\n", rc);
|
|
/* Copy data from idal buffer to user space. */
|
|
if (idal_buffer_to_user(device->char_data.idal_buf,
|
|
data, rc) != 0)
|
|
rc = -EFAULT;
|
|
}
|
|
tape_free_request(request);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Tape device write function
|
|
*/
|
|
static ssize_t
|
|
tapechar_write(struct file *filp, const char __user *data, size_t count, loff_t *ppos)
|
|
{
|
|
struct tape_device *device;
|
|
struct tape_request *request;
|
|
size_t block_size;
|
|
size_t written;
|
|
int nblocks;
|
|
int i, rc;
|
|
|
|
DBF_EVENT(6, "TCHAR:write\n");
|
|
device = (struct tape_device *) filp->private_data;
|
|
/* Find out block size and number of blocks */
|
|
if (device->char_data.block_size != 0) {
|
|
if (count < device->char_data.block_size) {
|
|
DBF_EVENT(3, "TCHAR:write smaller than block "
|
|
"size was requested\n");
|
|
return -EINVAL;
|
|
}
|
|
block_size = device->char_data.block_size;
|
|
nblocks = count / block_size;
|
|
} else {
|
|
block_size = count;
|
|
nblocks = 1;
|
|
}
|
|
|
|
rc = tapechar_check_idalbuffer(device, block_size);
|
|
if (rc)
|
|
return rc;
|
|
|
|
#ifdef CONFIG_S390_TAPE_BLOCK
|
|
/* Changes position. */
|
|
device->blk_data.medium_changed = 1;
|
|
#endif
|
|
|
|
DBF_EVENT(6,"TCHAR:nbytes: %lx\n", block_size);
|
|
DBF_EVENT(6, "TCHAR:nblocks: %x\n", nblocks);
|
|
/* Let the discipline build the ccw chain. */
|
|
request = device->discipline->write_block(device, block_size);
|
|
if (IS_ERR(request))
|
|
return PTR_ERR(request);
|
|
rc = 0;
|
|
written = 0;
|
|
for (i = 0; i < nblocks; i++) {
|
|
/* Copy data from user space to idal buffer. */
|
|
if (idal_buffer_from_user(device->char_data.idal_buf,
|
|
data, block_size)) {
|
|
rc = -EFAULT;
|
|
break;
|
|
}
|
|
rc = tape_do_io(device, request);
|
|
if (rc)
|
|
break;
|
|
DBF_EVENT(6, "TCHAR:wbytes: %lx\n",
|
|
block_size - request->rescnt);
|
|
written += block_size - request->rescnt;
|
|
if (request->rescnt != 0)
|
|
break;
|
|
data += block_size;
|
|
}
|
|
tape_free_request(request);
|
|
if (rc == -ENOSPC) {
|
|
/*
|
|
* Ok, the device has no more space. It has NOT written
|
|
* the block.
|
|
*/
|
|
if (device->discipline->process_eov)
|
|
device->discipline->process_eov(device);
|
|
if (written > 0)
|
|
rc = 0;
|
|
|
|
}
|
|
|
|
/*
|
|
* After doing a write we always need two tapemarks to correctly
|
|
* terminate the tape (one to terminate the file, the second to
|
|
* flag the end of recorded data.
|
|
* Since process_eov positions the tape in front of the written
|
|
* tapemark it doesn't hurt to write two marks again.
|
|
*/
|
|
if (!rc)
|
|
device->required_tapemarks = 2;
|
|
|
|
return rc ? rc : written;
|
|
}
|
|
|
|
/*
|
|
* Character frontend tape device open function.
|
|
*/
|
|
static int
|
|
tapechar_open (struct inode *inode, struct file *filp)
|
|
{
|
|
struct tape_device *device;
|
|
int minor, rc;
|
|
|
|
DBF_EVENT(6, "TCHAR:open: %i:%i\n",
|
|
imajor(filp->f_path.dentry->d_inode),
|
|
iminor(filp->f_path.dentry->d_inode));
|
|
|
|
if (imajor(filp->f_path.dentry->d_inode) != tapechar_major)
|
|
return -ENODEV;
|
|
|
|
minor = iminor(filp->f_path.dentry->d_inode);
|
|
device = tape_find_device(minor / TAPE_MINORS_PER_DEV);
|
|
if (IS_ERR(device)) {
|
|
DBF_EVENT(3, "TCHAR:open: tape_find_device() failed\n");
|
|
return PTR_ERR(device);
|
|
}
|
|
|
|
rc = tape_open(device);
|
|
if (rc == 0) {
|
|
filp->private_data = device;
|
|
nonseekable_open(inode, filp);
|
|
} else
|
|
tape_put_device(device);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Character frontend tape device release function.
|
|
*/
|
|
|
|
static int
|
|
tapechar_release(struct inode *inode, struct file *filp)
|
|
{
|
|
struct tape_device *device;
|
|
|
|
DBF_EVENT(6, "TCHAR:release: %x\n", iminor(inode));
|
|
device = (struct tape_device *) filp->private_data;
|
|
|
|
/*
|
|
* If this is the rewinding tape minor then rewind. In that case we
|
|
* write all required tapemarks. Otherwise only one to terminate the
|
|
* file.
|
|
*/
|
|
if ((iminor(inode) & 1) != 0) {
|
|
if (device->required_tapemarks)
|
|
tape_std_terminate_write(device);
|
|
tape_mtop(device, MTREW, 1);
|
|
} else {
|
|
if (device->required_tapemarks > 1) {
|
|
if (tape_mtop(device, MTWEOF, 1) == 0)
|
|
device->required_tapemarks--;
|
|
}
|
|
}
|
|
|
|
if (device->char_data.idal_buf != NULL) {
|
|
idal_buffer_free(device->char_data.idal_buf);
|
|
device->char_data.idal_buf = NULL;
|
|
}
|
|
tape_release(device);
|
|
filp->private_data = NULL;
|
|
tape_put_device(device);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Tape device io controls.
|
|
*/
|
|
static int
|
|
__tapechar_ioctl(struct tape_device *device,
|
|
unsigned int no, unsigned long data)
|
|
{
|
|
int rc;
|
|
|
|
if (no == MTIOCTOP) {
|
|
struct mtop op;
|
|
|
|
if (copy_from_user(&op, (char __user *) data, sizeof(op)) != 0)
|
|
return -EFAULT;
|
|
if (op.mt_count < 0)
|
|
return -EINVAL;
|
|
|
|
/*
|
|
* Operations that change tape position should write final
|
|
* tapemarks.
|
|
*/
|
|
switch (op.mt_op) {
|
|
case MTFSF:
|
|
case MTBSF:
|
|
case MTFSR:
|
|
case MTBSR:
|
|
case MTREW:
|
|
case MTOFFL:
|
|
case MTEOM:
|
|
case MTRETEN:
|
|
case MTBSFM:
|
|
case MTFSFM:
|
|
case MTSEEK:
|
|
#ifdef CONFIG_S390_TAPE_BLOCK
|
|
device->blk_data.medium_changed = 1;
|
|
#endif
|
|
if (device->required_tapemarks)
|
|
tape_std_terminate_write(device);
|
|
default:
|
|
;
|
|
}
|
|
rc = tape_mtop(device, op.mt_op, op.mt_count);
|
|
|
|
if (op.mt_op == MTWEOF && rc == 0) {
|
|
if (op.mt_count > device->required_tapemarks)
|
|
device->required_tapemarks = 0;
|
|
else
|
|
device->required_tapemarks -= op.mt_count;
|
|
}
|
|
return rc;
|
|
}
|
|
if (no == MTIOCPOS) {
|
|
/* MTIOCPOS: query the tape position. */
|
|
struct mtpos pos;
|
|
|
|
rc = tape_mtop(device, MTTELL, 1);
|
|
if (rc < 0)
|
|
return rc;
|
|
pos.mt_blkno = rc;
|
|
if (copy_to_user((char __user *) data, &pos, sizeof(pos)) != 0)
|
|
return -EFAULT;
|
|
return 0;
|
|
}
|
|
if (no == MTIOCGET) {
|
|
/* MTIOCGET: query the tape drive status. */
|
|
struct mtget get;
|
|
|
|
memset(&get, 0, sizeof(get));
|
|
get.mt_type = MT_ISUNKNOWN;
|
|
get.mt_resid = 0 /* device->devstat.rescnt */;
|
|
get.mt_dsreg = device->tape_state;
|
|
/* FIXME: mt_gstat, mt_erreg, mt_fileno */
|
|
get.mt_gstat = 0;
|
|
get.mt_erreg = 0;
|
|
get.mt_fileno = 0;
|
|
get.mt_gstat = device->tape_generic_status;
|
|
|
|
if (device->medium_state == MS_LOADED) {
|
|
rc = tape_mtop(device, MTTELL, 1);
|
|
|
|
if (rc < 0)
|
|
return rc;
|
|
|
|
if (rc == 0)
|
|
get.mt_gstat |= GMT_BOT(~0);
|
|
|
|
get.mt_blkno = rc;
|
|
}
|
|
|
|
if (copy_to_user((char __user *) data, &get, sizeof(get)) != 0)
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
}
|
|
/* Try the discipline ioctl function. */
|
|
if (device->discipline->ioctl_fn == NULL)
|
|
return -EINVAL;
|
|
return device->discipline->ioctl_fn(device, no, data);
|
|
}
|
|
|
|
static long
|
|
tapechar_ioctl(struct file *filp, unsigned int no, unsigned long data)
|
|
{
|
|
struct tape_device *device;
|
|
long rc;
|
|
|
|
DBF_EVENT(6, "TCHAR:ioct\n");
|
|
|
|
device = (struct tape_device *) filp->private_data;
|
|
mutex_lock(&device->mutex);
|
|
rc = __tapechar_ioctl(device, no, data);
|
|
mutex_unlock(&device->mutex);
|
|
return rc;
|
|
}
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
static long
|
|
tapechar_compat_ioctl(struct file *filp, unsigned int no, unsigned long data)
|
|
{
|
|
struct tape_device *device = filp->private_data;
|
|
int rval = -ENOIOCTLCMD;
|
|
unsigned long argp;
|
|
|
|
/* The 'arg' argument of any ioctl function may only be used for
|
|
* pointers because of the compat pointer conversion.
|
|
* Consider this when adding new ioctls.
|
|
*/
|
|
argp = (unsigned long) compat_ptr(data);
|
|
if (device->discipline->ioctl_fn) {
|
|
mutex_lock(&device->mutex);
|
|
rval = device->discipline->ioctl_fn(device, no, argp);
|
|
mutex_unlock(&device->mutex);
|
|
if (rval == -EINVAL)
|
|
rval = -ENOIOCTLCMD;
|
|
}
|
|
|
|
return rval;
|
|
}
|
|
#endif /* CONFIG_COMPAT */
|
|
|
|
/*
|
|
* Initialize character device frontend.
|
|
*/
|
|
int
|
|
tapechar_init (void)
|
|
{
|
|
dev_t dev;
|
|
|
|
if (alloc_chrdev_region(&dev, 0, 256, "tape") != 0)
|
|
return -1;
|
|
|
|
tapechar_major = MAJOR(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* cleanup
|
|
*/
|
|
void
|
|
tapechar_exit(void)
|
|
{
|
|
unregister_chrdev_region(MKDEV(tapechar_major, 0), 256);
|
|
}
|