[mirror_ubuntu-bionic-kernel.git] / kernel / time / posix-clock.c

/*
 * posix-clock.c - support for dynamic clock devices
 *
 * Copyright (C) 2010 OMICRON electronics GmbH
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#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"

static void delete_clock(struct kref *kref);

/*
 * 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 unsigned int posix_clock_poll(struct file *fp, poll_table *wait)
{
	struct posix_clock *clk = get_posix_clock(fp);
	unsigned int result = 0;

	if (!clk)
		return POLLERR;

	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) {
		kref_get(&clk->kref);
		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);

	kref_put(&clk->kref, delete_clock);

	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, dev_t devid)
{
	int err;

	kref_init(&clk->kref);
	init_rwsem(&clk->rwsem);

	cdev_init(&clk->cdev, &posix_clock_file_operations);
	clk->cdev.owner = clk->ops.owner;
	err = cdev_add(&clk->cdev, devid, 1);

	return err;
}
EXPORT_SYMBOL_GPL(posix_clock_register);

static void delete_clock(struct kref *kref)
{
	struct posix_clock *clk = container_of(kref, struct posix_clock, kref);

	if (clk->release)
		clk->release(clk);
}

void posix_clock_unregister(struct posix_clock *clk)
{
	cdev_del(&clk->cdev);

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

	kref_put(&clk->kref, delete_clock);
}
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 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	= pc_clock_gettime,
	.clock_adj	= pc_clock_adjtime,
};
Commit	Line	Data
0606f422 RC	1	/*
	2	* posix-clock.c - support for dynamic clock devices
	3	*
	4	* Copyright (C) 2010 OMICRON electronics GmbH
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	19	*/
	20	#include <linux/device.h>
6e5fdeed	21	#include <linux/export.h>
0606f422	22	#include <linux/file.h>
0606f422 RC	23	#include <linux/posix-clock.h>
	24	#include <linux/slab.h>
	25	#include <linux/syscalls.h>
	26	#include <linux/uaccess.h>
	27
bab0aae9 TG	28	#include "posix-timers.h"
bab0aae9 TG	29
0606f422 RC	30	static void delete_clock(struct kref *kref);
	31
	32	/*
	33	* Returns NULL if the posix_clock instance attached to 'fp' is old and stale.
	34	*/
	35	static struct posix_clock get_posix_clock(struct file fp)
	36	{
	37	struct posix_clock *clk = fp->private_data;
	38
1791f881	39	down_read(&clk->rwsem);
0606f422 RC	40
	41	if (!clk->zombie)
	42	return clk;
	43
1791f881	44	up_read(&clk->rwsem);
0606f422 RC	45
	46	return NULL;
	47	}
	48
	49	static void put_posix_clock(struct posix_clock *clk)
	50	{
1791f881	51	up_read(&clk->rwsem);
0606f422 RC	52	}
	53
	54	static ssize_t posix_clock_read(struct file fp, char __user buf,
	55	size_t count, loff_t *ppos)
	56	{
	57	struct posix_clock *clk = get_posix_clock(fp);
	58	int err = -EINVAL;
	59
	60	if (!clk)
	61	return -ENODEV;
	62
	63	if (clk->ops.read)
	64	err = clk->ops.read(clk, fp->f_flags, buf, count);
	65
	66	put_posix_clock(clk);
	67
	68	return err;
	69	}
	70
	71	static unsigned int posix_clock_poll(struct file fp, poll_table wait)
	72	{
	73	struct posix_clock *clk = get_posix_clock(fp);
1b9f2372	74	unsigned int result = 0;
0606f422 RC	75
0606f422 RC	76	if (!clk)
1b9f2372	77	return POLLERR;
0606f422 RC	78
	79	if (clk->ops.poll)
	80	result = clk->ops.poll(clk, fp, wait);
	81
	82	put_posix_clock(clk);
	83
	84	return result;
	85	}
	86
0606f422 RC	87	static long posix_clock_ioctl(struct file *fp,
	88	unsigned int cmd, unsigned long arg)
	89	{
	90	struct posix_clock *clk = get_posix_clock(fp);
	91	int err = -ENOTTY;
	92
	93	if (!clk)
	94	return -ENODEV;
	95
	96	if (clk->ops.ioctl)
	97	err = clk->ops.ioctl(clk, cmd, arg);
	98
	99	put_posix_clock(clk);
	100
	101	return err;
	102	}
	103
	104	#ifdef CONFIG_COMPAT
	105	static long posix_clock_compat_ioctl(struct file *fp,
	106	unsigned int cmd, unsigned long arg)
	107	{
	108	struct posix_clock *clk = get_posix_clock(fp);
	109	int err = -ENOTTY;
	110
	111	if (!clk)
	112	return -ENODEV;
	113
	114	if (clk->ops.ioctl)
	115	err = clk->ops.ioctl(clk, cmd, arg);
	116
	117	put_posix_clock(clk);
	118
	119	return err;
	120	}
	121	#endif
	122
	123	static int posix_clock_open(struct inode inode, struct file fp)
	124	{
	125	int err;
	126	struct posix_clock *clk =
	127	container_of(inode->i_cdev, struct posix_clock, cdev);
	128
1791f881	129	down_read(&clk->rwsem);
0606f422 RC	130
	131	if (clk->zombie) {
	132	err = -ENODEV;
	133	goto out;
	134	}
	135	if (clk->ops.open)
	136	err = clk->ops.open(clk, fp->f_mode);
	137	else
	138	err = 0;
	139
	140	if (!err) {
	141	kref_get(&clk->kref);
	142	fp->private_data = clk;
	143	}
	144	out:
1791f881	145	up_read(&clk->rwsem);
0606f422 RC	146	return err;
	147	}
	148
	149	static int posix_clock_release(struct inode inode, struct file fp)
	150	{
	151	struct posix_clock *clk = fp->private_data;
	152	int err = 0;
	153
	154	if (clk->ops.release)
	155	err = clk->ops.release(clk);
	156
	157	kref_put(&clk->kref, delete_clock);
	158
	159	fp->private_data = NULL;
	160
	161	return err;
	162	}
	163
	164	static const struct file_operations posix_clock_file_operations = {
	165	.owner = THIS_MODULE,
	166	.llseek = no_llseek,
	167	.read = posix_clock_read,
	168	.poll = posix_clock_poll,
	169	.unlocked_ioctl = posix_clock_ioctl,
	170	.open = posix_clock_open,
	171	.release = posix_clock_release,
0606f422 RC	172	#ifdef CONFIG_COMPAT
	173	.compat_ioctl = posix_clock_compat_ioctl,
	174	#endif
	175	};
	176
	177	int posix_clock_register(struct posix_clock *clk, dev_t devid)
	178	{
	179	int err;
	180
	181	kref_init(&clk->kref);
1791f881	182	init_rwsem(&clk->rwsem);
0606f422 RC	183
	184	cdev_init(&clk->cdev, &posix_clock_file_operations);
	185	clk->cdev.owner = clk->ops.owner;
	186	err = cdev_add(&clk->cdev, devid, 1);
0606f422 RC	187
0606f422 RC	188	return err;
0606f422 RC	189	}
	190	EXPORT_SYMBOL_GPL(posix_clock_register);
	191
	192	static void delete_clock(struct kref *kref)
	193	{
	194	struct posix_clock *clk = container_of(kref, struct posix_clock, kref);
1791f881	195
0606f422 RC	196	if (clk->release)
	197	clk->release(clk);
	198	}
	199
	200	void posix_clock_unregister(struct posix_clock *clk)
	201	{
	202	cdev_del(&clk->cdev);
	203
1791f881	204	down_write(&clk->rwsem);
0606f422	205	clk->zombie = true;
1791f881	206	up_write(&clk->rwsem);
0606f422 RC	207
	208	kref_put(&clk->kref, delete_clock);
	209	}
	210	EXPORT_SYMBOL_GPL(posix_clock_unregister);
	211
	212	struct posix_clock_desc {
	213	struct file *fp;
	214	struct posix_clock *clk;
	215	};
	216
	217	static int get_clock_desc(const clockid_t id, struct posix_clock_desc *cd)
	218	{
	219	struct file *fp = fget(CLOCKID_TO_FD(id));
	220	int err = -EINVAL;
	221
	222	if (!fp)
	223	return err;
	224
	225	if (fp->f_op->open != posix_clock_open \|\| !fp->private_data)
	226	goto out;
	227
	228	cd->fp = fp;
	229	cd->clk = get_posix_clock(fp);
	230
	231	err = cd->clk ? 0 : -ENODEV;
	232	out:
	233	if (err)
	234	fput(fp);
	235	return err;
	236	}
	237
	238	static void put_clock_desc(struct posix_clock_desc *cd)
	239	{
	240	put_posix_clock(cd->clk);
	241	fput(cd->fp);
	242	}
	243
	244	static int pc_clock_adjtime(clockid_t id, struct timex *tx)
	245	{
	246	struct posix_clock_desc cd;
	247	int err;
	248
	249	err = get_clock_desc(id, &cd);
	250	if (err)
	251	return err;
	252
6e6823d1 TH	253	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
	254	err = -EACCES;
	255	goto out;
	256	}
	257
0606f422 RC	258	if (cd.clk->ops.clock_adjtime)
	259	err = cd.clk->ops.clock_adjtime(cd.clk, tx);
	260	else
	261	err = -EOPNOTSUPP;
6e6823d1	262	out:
0606f422 RC	263	put_clock_desc(&cd);
	264
	265	return err;
	266	}
	267
3c9c12f4	268	static int pc_clock_gettime(clockid_t id, struct timespec64 *ts)
0606f422 RC	269	{
	270	struct posix_clock_desc cd;
	271	int err;
	272
	273	err = get_clock_desc(id, &cd);
	274	if (err)
	275	return err;
	276
3c9c12f4 DD	277	if (cd.clk->ops.clock_gettime)
3c9c12f4 DD	278	err = cd.clk->ops.clock_gettime(cd.clk, ts);
0606f422 RC	279	else
	280	err = -EOPNOTSUPP;
	281
	282	put_clock_desc(&cd);
	283
	284	return err;
	285	}
	286
d2e3e0ca	287	static int pc_clock_getres(clockid_t id, struct timespec64 *ts)
0606f422 RC	288	{
	289	struct posix_clock_desc cd;
	290	int err;
	291
	292	err = get_clock_desc(id, &cd);
	293	if (err)
	294	return err;
	295
d2e3e0ca DD	296	if (cd.clk->ops.clock_getres)
d2e3e0ca DD	297	err = cd.clk->ops.clock_getres(cd.clk, ts);
0606f422 RC	298	else
	299	err = -EOPNOTSUPP;
	300
	301	put_clock_desc(&cd);
	302
	303	return err;
	304	}
	305
0fe6afe3	306	static int pc_clock_settime(clockid_t id, const struct timespec64 *ts)
0606f422 RC	307	{
	308	struct posix_clock_desc cd;
	309	int err;
	310
	311	err = get_clock_desc(id, &cd);
	312	if (err)
	313	return err;
	314
6e6823d1 TH	315	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
	316	err = -EACCES;
	317	goto out;
	318	}
	319
0606f422	320	if (cd.clk->ops.clock_settime)
0fe6afe3	321	err = cd.clk->ops.clock_settime(cd.clk, ts);
0606f422 RC	322	else
0606f422 RC	323	err = -EOPNOTSUPP;
6e6823d1	324	out:
0606f422 RC	325	put_clock_desc(&cd);
	326
	327	return err;
	328	}
	329
d3ba5a9a	330	const struct k_clock clock_posix_dynamic = {
0606f422 RC	331	.clock_getres = pc_clock_getres,
	332	.clock_set = pc_clock_settime,
	333	.clock_get = pc_clock_gettime,
	334	.clock_adj = pc_clock_adjtime,
0606f422	335	};