Release 4.7 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/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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
andrew morton
andrew morton
97
96.04%
3
75.00%
martin schwidefsky
martin schwidefsky
4
3.96%
1
25.00%
Total
101
100.00%
4
100.00%


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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
andrew morton
andrew morton
28
56.00%
2
50.00%
michael holzheu
michael holzheu
14
28.00%
1
25.00%
martin schwidefsky
martin schwidefsky
8
16.00%
1
25.00%
Total
50
100.00%
4
100.00%


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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
martin schwidefsky
martin schwidefsky
88
75.86%
1
33.33%
andrew morton
andrew morton
25
21.55%
1
33.33%
julien brunel
julien brunel
3
2.59%
1
33.33%
Total
116
100.00%
3
100.00%

/*
 * 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
martin schwidefsky
martin schwidefsky
224
92.56%
1
20.00%
andrew morton
andrew morton
16
6.61%
2
40.00%
heiko carstens
heiko carstens
1
0.41%
1
20.00%
lucas de marchi
lucas de marchi
1
0.41%
1
20.00%
Total
242
100.00%
5
100.00%

/*
 * 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
martin schwidefsky
martin schwidefsky
326
94.49%
1
25.00%
andrew morton
andrew morton
18
5.22%
2
50.00%
heiko carstens
heiko carstens
1
0.29%
1
25.00%
Total
345
100.00%
4
100.00%

/*
 * 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(file_inode(filp)),
		iminor(file_inode(filp)));

	if (imajor(file_inode(filp)) != tapechar_major)
		return -ENODEV;

	minor = iminor(file_inode(filp));
	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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
martin schwidefsky
martin schwidefsky
99
69.23%
3
30.00%
andrew morton
andrew morton
21
14.69%
1
10.00%
al viro
al viro
14
9.79%
3
30.00%
linus torvalds
linus torvalds
6
4.20%
1
10.00%
jonathan corbet
jonathan corbet
2
1.40%
1
10.00%
heiko carstens
heiko carstens
1
0.70%
1
10.00%
Total
143
100.00%
10
100.00%

/*
 * 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
martin schwidefsky
martin schwidefsky
96
60.38%
2
40.00%
andrew morton
andrew morton
60
37.74%
1
20.00%
al viro
al viro
2
1.26%
1
20.00%
heiko carstens
heiko carstens
1
0.63%
1
20.00%
Total
159
100.00%
5
100.00%

/*
 * 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->char_data.block_size << MT_ST_BLKSIZE_SHIFT)
			 & MT_ST_BLKSIZE_MASK);
		/* 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
martin schwidefsky
martin schwidefsky
274
61.43%
2
40.00%
andrew morton
andrew morton
161
36.10%
2
40.00%
stefan haberland
stefan haberland
11
2.47%
1
20.00%
Total
446
100.00%
5
100.00%


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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
martin schwidefsky
martin schwidefsky
73
97.33%
1
50.00%
christoph hellwig
christoph hellwig
2
2.67%
1
50.00%
Total
75
100.00%
2
100.00%

#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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
christoph hellwig
christoph hellwig
73
68.87%
1
33.33%
heiko carstens
heiko carstens
17
16.04%
1
33.33%
martin schwidefsky
martin schwidefsky
16
15.09%
1
33.33%
Total
106
100.00%
3
100.00%

#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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
martin schwidefsky
martin schwidefsky
24
60.00%
1
50.00%
andrew morton
andrew morton
16
40.00%
1
50.00%
Total
40
100.00%
2
100.00%

/*
 * cleanup
 */

void

tapechar_exit(void)
{
	unregister_chrdev_region(MKDEV(tapechar_major, 0), 256);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
martin schwidefsky
martin schwidefsky
12
63.16%
1
50.00%
andrew morton
andrew morton
7
36.84%
1
50.00%
Total
19
100.00%
2
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
martin schwidefsky
martin schwidefsky
1394
67.60%
4
16.00%
andrew morton
andrew morton
462
22.41%
5
20.00%
christoph hellwig
christoph hellwig
95
4.61%
1
4.00%
heiko carstens
heiko carstens
41
1.99%
3
12.00%
michael holzheu
michael holzheu
25
1.21%
2
8.00%
al viro
al viro
16
0.78%
3
12.00%
stefan haberland
stefan haberland
11
0.53%
1
4.00%
linus torvalds
linus torvalds
6
0.29%
1
4.00%
arnd bergmann
arnd bergmann
5
0.24%
1
4.00%
julien brunel
julien brunel
3
0.15%
1
4.00%
jonathan corbet
jonathan corbet
2
0.10%
1
4.00%
arjan van de ven
arjan van de ven
1
0.05%
1
4.00%
lucas de marchi
lucas de marchi
1
0.05%
1
4.00%
Total
2062
100.00%
25
100.00%
  
Directory: drivers/s390/char

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.