forked from Minki/linux
a53c8fab3f
Remove the file name from the comment at top of many files. In most cases the file name was wrong anyway, so it's rather pointless. Also unify the IBM copyright statement. We did have a lot of sightly different statements and wanted to change them one after another whenever a file gets touched. However that never happened. Instead people start to take the old/"wrong" statements to use as a template for new files. So unify all of them in one go. Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
499 lines
11 KiB
C
499 lines
11 KiB
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/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,
|
|
.llseek = no_llseek,
|
|
};
|
|
|
|
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 immediately.
|
|
*/
|
|
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;
|
|
|
|
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;
|
|
|
|
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:
|
|
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);
|
|
}
|