[linux-2.6-block.git] / kernel / time / posix-clock.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Support for dynamic clock devices
 *
 * Copyright (C) 2010 OMICRON electronics GmbH
 */
#include <linux/device.h>
#include <linux/export.h>
#include <linux/file.h>
#include <linux/posix-clock.h>
#include <linux/slab.h>
#include <linux/syscalls.h>
#include <linux/uaccess.h>

#include "posix-timers.h"

/*
 * Returns NULL if the posix_clock instance attached to 'fp' is old and stale.
 */
static struct posix_clock *get_posix_clock(struct file *fp)
{
	struct posix_clock *clk = fp->private_data;

	down_read(&clk->rwsem);

	if (!clk->zombie)
		return clk;

	up_read(&clk->rwsem);

	return NULL;
}

static void put_posix_clock(struct posix_clock *clk)
{
	up_read(&clk->rwsem);
}

static ssize_t posix_clock_read(struct file *fp, char __user *buf,
				size_t count, loff_t *ppos)
{
	struct posix_clock *clk = get_posix_clock(fp);
	int err = -EINVAL;

	if (!clk)
		return -ENODEV;

	if (clk->ops.read)
		err = clk->ops.read(clk, fp->f_flags, buf, count);

	put_posix_clock(clk);

	return err;
}

static __poll_t posix_clock_poll(struct file *fp, poll_table *wait)
{
	struct posix_clock *clk = get_posix_clock(fp);
	__poll_t result = 0;

	if (!clk)
		return EPOLLERR;

	if (clk->ops.poll)
		result = clk->ops.poll(clk, fp, wait);

	put_posix_clock(clk);

	return result;
}

static long posix_clock_ioctl(struct file *fp,
			      unsigned int cmd, unsigned long arg)
{
	struct posix_clock *clk = get_posix_clock(fp);
	int err = -ENOTTY;

	if (!clk)
		return -ENODEV;

	if (clk->ops.ioctl)
		err = clk->ops.ioctl(clk, cmd, arg);

	put_posix_clock(clk);

	return err;
}

#ifdef CONFIG_COMPAT
static long posix_clock_compat_ioctl(struct file *fp,
				     unsigned int cmd, unsigned long arg)
{
	struct posix_clock *clk = get_posix_clock(fp);
	int err = -ENOTTY;

	if (!clk)
		return -ENODEV;

	if (clk->ops.ioctl)
		err = clk->ops.ioctl(clk, cmd, arg);

	put_posix_clock(clk);

	return err;
}
#endif

static int posix_clock_open(struct inode *inode, struct file *fp)
{
	int err;
	struct posix_clock *clk =
		container_of(inode->i_cdev, struct posix_clock, cdev);

	down_read(&clk->rwsem);

	if (clk->zombie) {
		err = -ENODEV;
		goto out;
	}
	if (clk->ops.open)
		err = clk->ops.open(clk, fp->f_mode);
	else
		err = 0;

	if (!err) {
		get_device(clk->dev);
		fp->private_data = clk;
	}
out:
	up_read(&clk->rwsem);
	return err;
}

static int posix_clock_release(struct inode *inode, struct file *fp)
{
	struct posix_clock *clk = fp->private_data;
	int err = 0;

	if (clk->ops.release)
		err = clk->ops.release(clk);

	put_device(clk->dev);

	fp->private_data = NULL;

	return err;
}

static const struct file_operations posix_clock_file_operations = {
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.read		= posix_clock_read,
	.poll		= posix_clock_poll,
	.unlocked_ioctl	= posix_clock_ioctl,
	.open		= posix_clock_open,
	.release	= posix_clock_release,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= posix_clock_compat_ioctl,
#endif
};

int posix_clock_register(struct posix_clock *clk, struct device *dev)
{
	int err;

	init_rwsem(&clk->rwsem);

	cdev_init(&clk->cdev, &posix_clock_file_operations);
	err = cdev_device_add(&clk->cdev, dev);
	if (err) {
		pr_err("%s unable to add device %d:%d\n",
			dev_name(dev), MAJOR(dev->devt), MINOR(dev->devt));
		return err;
	}
	clk->cdev.owner = clk->ops.owner;
	clk->dev = dev;

	return 0;
}
EXPORT_SYMBOL_GPL(posix_clock_register);

void posix_clock_unregister(struct posix_clock *clk)
{
	cdev_device_del(&clk->cdev, clk->dev);

	down_write(&clk->rwsem);
	clk->zombie = true;
	up_write(&clk->rwsem);

	put_device(clk->dev);
}
EXPORT_SYMBOL_GPL(posix_clock_unregister);

struct posix_clock_desc {
	struct file *fp;
	struct posix_clock *clk;
};

static int get_clock_desc(const clockid_t id, struct posix_clock_desc *cd)
{
	struct file *fp = fget(clockid_to_fd(id));
	int err = -EINVAL;

	if (!fp)
		return err;

	if (fp->f_op->open != posix_clock_open || !fp->private_data)
		goto out;

	cd->fp = fp;
	cd->clk = get_posix_clock(fp);

	err = cd->clk ? 0 : -ENODEV;
out:
	if (err)
		fput(fp);
	return err;
}

static void put_clock_desc(struct posix_clock_desc *cd)
{
	put_posix_clock(cd->clk);
	fput(cd->fp);
}

static int pc_clock_adjtime(clockid_t id, struct __kernel_timex *tx)
{
	struct posix_clock_desc cd;
	int err;

	err = get_clock_desc(id, &cd);
	if (err)
		return err;

	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
		err = -EACCES;
		goto out;
	}

	if (cd.clk->ops.clock_adjtime)
		err = cd.clk->ops.clock_adjtime(cd.clk, tx);
	else
		err = -EOPNOTSUPP;
out:
	put_clock_desc(&cd);

	return err;
}

static int pc_clock_gettime(clockid_t id, struct timespec64 *ts)
{
	struct posix_clock_desc cd;
	int err;

	err = get_clock_desc(id, &cd);
	if (err)
		return err;

	if (cd.clk->ops.clock_gettime)
		err = cd.clk->ops.clock_gettime(cd.clk, ts);
	else
		err = -EOPNOTSUPP;

	put_clock_desc(&cd);

	return err;
}

static int pc_clock_getres(clockid_t id, struct timespec64 *ts)
{
	struct posix_clock_desc cd;
	int err;

	err = get_clock_desc(id, &cd);
	if (err)
		return err;

	if (cd.clk->ops.clock_getres)
		err = cd.clk->ops.clock_getres(cd.clk, ts);
	else
		err = -EOPNOTSUPP;

	put_clock_desc(&cd);

	return err;
}

static int pc_clock_settime(clockid_t id, const struct timespec64 *ts)
{
	struct posix_clock_desc cd;
	int err;

	err = get_clock_desc(id, &cd);
	if (err)
		return err;

	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
		err = -EACCES;
		goto out;
	}

	if (cd.clk->ops.clock_settime)
		err = cd.clk->ops.clock_settime(cd.clk, ts);
	else
		err = -EOPNOTSUPP;
out:
	put_clock_desc(&cd);

	return err;
}

const struct k_clock clock_posix_dynamic = {
	.clock_getres		= pc_clock_getres,
	.clock_set		= pc_clock_settime,
	.clock_get_timespec	= pc_clock_gettime,
	.clock_adj		= pc_clock_adjtime,
};
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Support for dynamic clock devices
	4	*
	5	* Copyright (C) 2010 OMICRON electronics GmbH
	6	*/
	7	#include <linux/device.h>
	8	#include <linux/export.h>
	9	#include <linux/file.h>
	10	#include <linux/posix-clock.h>
	11	#include <linux/slab.h>
	12	#include <linux/syscalls.h>
	13	#include <linux/uaccess.h>
	14
	15	#include "posix-timers.h"
	16
	17	/*
	18	* Returns NULL if the posix_clock instance attached to 'fp' is old and stale.
	19	*/
	20	static struct posix_clock get_posix_clock(struct file fp)
	21	{
	22	struct posix_clock *clk = fp->private_data;
	23
	24	down_read(&clk->rwsem);
	25
	26	if (!clk->zombie)
	27	return clk;
	28
	29	up_read(&clk->rwsem);
	30
	31	return NULL;
	32	}
	33
	34	static void put_posix_clock(struct posix_clock *clk)
	35	{
	36	up_read(&clk->rwsem);
	37	}
	38
	39	static ssize_t posix_clock_read(struct file fp, char __user buf,
	40	size_t count, loff_t *ppos)
	41	{
	42	struct posix_clock *clk = get_posix_clock(fp);
	43	int err = -EINVAL;
	44
	45	if (!clk)
	46	return -ENODEV;
	47
	48	if (clk->ops.read)
	49	err = clk->ops.read(clk, fp->f_flags, buf, count);
	50
	51	put_posix_clock(clk);
	52
	53	return err;
	54	}
	55
	56	static __poll_t posix_clock_poll(struct file fp, poll_table wait)
	57	{
	58	struct posix_clock *clk = get_posix_clock(fp);
	59	__poll_t result = 0;
	60
	61	if (!clk)
	62	return EPOLLERR;
	63
	64	if (clk->ops.poll)
	65	result = clk->ops.poll(clk, fp, wait);
	66
	67	put_posix_clock(clk);
	68
	69	return result;
	70	}
	71
	72	static long posix_clock_ioctl(struct file *fp,
	73	unsigned int cmd, unsigned long arg)
	74	{
	75	struct posix_clock *clk = get_posix_clock(fp);
	76	int err = -ENOTTY;
	77
	78	if (!clk)
	79	return -ENODEV;
	80
	81	if (clk->ops.ioctl)
	82	err = clk->ops.ioctl(clk, cmd, arg);
	83
	84	put_posix_clock(clk);
	85
	86	return err;
	87	}
	88
	89	#ifdef CONFIG_COMPAT
	90	static long posix_clock_compat_ioctl(struct file *fp,
	91	unsigned int cmd, unsigned long arg)
	92	{
	93	struct posix_clock *clk = get_posix_clock(fp);
	94	int err = -ENOTTY;
	95
	96	if (!clk)
	97	return -ENODEV;
	98
	99	if (clk->ops.ioctl)
	100	err = clk->ops.ioctl(clk, cmd, arg);
	101
	102	put_posix_clock(clk);
	103
	104	return err;
	105	}
	106	#endif
	107
	108	static int posix_clock_open(struct inode inode, struct file fp)
	109	{
	110	int err;
	111	struct posix_clock *clk =
	112	container_of(inode->i_cdev, struct posix_clock, cdev);
	113
	114	down_read(&clk->rwsem);
	115
	116	if (clk->zombie) {
	117	err = -ENODEV;
	118	goto out;
	119	}
	120	if (clk->ops.open)
	121	err = clk->ops.open(clk, fp->f_mode);
	122	else
	123	err = 0;
	124
	125	if (!err) {
	126	get_device(clk->dev);
	127	fp->private_data = clk;
	128	}
	129	out:
	130	up_read(&clk->rwsem);
	131	return err;
	132	}
	133
	134	static int posix_clock_release(struct inode inode, struct file fp)
	135	{
	136	struct posix_clock *clk = fp->private_data;
	137	int err = 0;
	138
	139	if (clk->ops.release)
	140	err = clk->ops.release(clk);
	141
	142	put_device(clk->dev);
	143
	144	fp->private_data = NULL;
	145
	146	return err;
	147	}
	148
	149	static const struct file_operations posix_clock_file_operations = {
	150	.owner = THIS_MODULE,
	151	.llseek = no_llseek,
	152	.read = posix_clock_read,
	153	.poll = posix_clock_poll,
	154	.unlocked_ioctl = posix_clock_ioctl,
	155	.open = posix_clock_open,
	156	.release = posix_clock_release,
	157	#ifdef CONFIG_COMPAT
	158	.compat_ioctl = posix_clock_compat_ioctl,
	159	#endif
	160	};
	161
	162	int posix_clock_register(struct posix_clock clk, struct device dev)
	163	{
	164	int err;
	165
	166	init_rwsem(&clk->rwsem);
	167
	168	cdev_init(&clk->cdev, &posix_clock_file_operations);
	169	err = cdev_device_add(&clk->cdev, dev);
	170	if (err) {
	171	pr_err("%s unable to add device %d:%d\n",
	172	dev_name(dev), MAJOR(dev->devt), MINOR(dev->devt));
	173	return err;
	174	}
	175	clk->cdev.owner = clk->ops.owner;
	176	clk->dev = dev;
	177
	178	return 0;
	179	}
	180	EXPORT_SYMBOL_GPL(posix_clock_register);
	181
	182	void posix_clock_unregister(struct posix_clock *clk)
	183	{
	184	cdev_device_del(&clk->cdev, clk->dev);
	185
	186	down_write(&clk->rwsem);
	187	clk->zombie = true;
	188	up_write(&clk->rwsem);
	189
	190	put_device(clk->dev);
	191	}
	192	EXPORT_SYMBOL_GPL(posix_clock_unregister);
	193
	194	struct posix_clock_desc {
	195	struct file *fp;
	196	struct posix_clock *clk;
	197	};
	198
	199	static int get_clock_desc(const clockid_t id, struct posix_clock_desc *cd)
	200	{
	201	struct file *fp = fget(clockid_to_fd(id));
	202	int err = -EINVAL;
	203
	204	if (!fp)
	205	return err;
	206
	207	if (fp->f_op->open != posix_clock_open \|\| !fp->private_data)
	208	goto out;
	209
	210	cd->fp = fp;
	211	cd->clk = get_posix_clock(fp);
	212
	213	err = cd->clk ? 0 : -ENODEV;
	214	out:
	215	if (err)
	216	fput(fp);
	217	return err;
	218	}
	219
	220	static void put_clock_desc(struct posix_clock_desc *cd)
	221	{
	222	put_posix_clock(cd->clk);
	223	fput(cd->fp);
	224	}
	225
	226	static int pc_clock_adjtime(clockid_t id, struct __kernel_timex *tx)
	227	{
	228	struct posix_clock_desc cd;
	229	int err;
	230
	231	err = get_clock_desc(id, &cd);
	232	if (err)
	233	return err;
	234
	235	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
	236	err = -EACCES;
	237	goto out;
	238	}
	239
	240	if (cd.clk->ops.clock_adjtime)
	241	err = cd.clk->ops.clock_adjtime(cd.clk, tx);
	242	else
	243	err = -EOPNOTSUPP;
	244	out:
	245	put_clock_desc(&cd);
	246
	247	return err;
	248	}
	249
	250	static int pc_clock_gettime(clockid_t id, struct timespec64 *ts)
	251	{
	252	struct posix_clock_desc cd;
	253	int err;
	254
	255	err = get_clock_desc(id, &cd);
	256	if (err)
	257	return err;
	258
	259	if (cd.clk->ops.clock_gettime)
	260	err = cd.clk->ops.clock_gettime(cd.clk, ts);
	261	else
	262	err = -EOPNOTSUPP;
	263
	264	put_clock_desc(&cd);
	265
	266	return err;
	267	}
	268
	269	static int pc_clock_getres(clockid_t id, struct timespec64 *ts)
	270	{
	271	struct posix_clock_desc cd;
	272	int err;
	273
	274	err = get_clock_desc(id, &cd);
	275	if (err)
	276	return err;
	277
	278	if (cd.clk->ops.clock_getres)
	279	err = cd.clk->ops.clock_getres(cd.clk, ts);
	280	else
	281	err = -EOPNOTSUPP;
	282
	283	put_clock_desc(&cd);
	284
	285	return err;
	286	}
	287
	288	static int pc_clock_settime(clockid_t id, const struct timespec64 *ts)
	289	{
	290	struct posix_clock_desc cd;
	291	int err;
	292
	293	err = get_clock_desc(id, &cd);
	294	if (err)
	295	return err;
	296
	297	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
	298	err = -EACCES;
	299	goto out;
	300	}
	301
	302	if (cd.clk->ops.clock_settime)
	303	err = cd.clk->ops.clock_settime(cd.clk, ts);
	304	else
	305	err = -EOPNOTSUPP;
	306	out:
	307	put_clock_desc(&cd);
	308
	309	return err;
	310	}
	311
	312	const struct k_clock clock_posix_dynamic = {
	313	.clock_getres = pc_clock_getres,
	314	.clock_set = pc_clock_settime,
	315	.clock_get_timespec = pc_clock_gettime,
	316	.clock_adj = pc_clock_adjtime,
	317	};