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 */
 20static 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
 34static void put_posix_clock(struct posix_clock *clk)
 35{
 36	up_read(&clk->rwsem);
 37}
 38
 39static 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
 56static __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
 72static 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
 90static 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
108static 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	}
129out:
130	up_read(&clk->rwsem);
131	return err;
132}
133
134static 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
149static 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
162int 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}
180EXPORT_SYMBOL_GPL(posix_clock_register);
181
 
 
 
 
 
 
 
 
182void 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}
192EXPORT_SYMBOL_GPL(posix_clock_unregister);
193
194struct posix_clock_desc {
195	struct file *fp;
196	struct posix_clock *clk;
197};
198
199static 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;
214out:
215	if (err)
216		fput(fp);
217	return err;
218}
219
220static void put_clock_desc(struct posix_clock_desc *cd)
221{
222	put_posix_clock(cd->clk);
223	fput(cd->fp);
224}
225
226static 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;
244out:
245	put_clock_desc(&cd);
246
247	return err;
248}
249
250static 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
269static 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
288static 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;
306out:
307	put_clock_desc(&cd);
308
309	return err;
310}
311
312const 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};

 
  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>
 21#include <linux/export.h>
 22#include <linux/file.h>
 23#include <linux/posix-clock.h>
 24#include <linux/slab.h>
 25#include <linux/syscalls.h>
 26#include <linux/uaccess.h>
 27
 28#include "posix-timers.h"
 29
 30static void delete_clock(struct kref *kref);
 31
 32/*
 33 * Returns NULL if the posix_clock instance attached to 'fp' is old and stale.
 34 */
 35static struct posix_clock *get_posix_clock(struct file *fp)
 36{
 37	struct posix_clock *clk = fp->private_data;
 38
 39	down_read(&clk->rwsem);
 40
 41	if (!clk->zombie)
 42		return clk;
 43
 44	up_read(&clk->rwsem);
 45
 46	return NULL;
 47}
 48
 49static void put_posix_clock(struct posix_clock *clk)
 50{
 51	up_read(&clk->rwsem);
 52}
 53
 54static 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
 71static __poll_t posix_clock_poll(struct file *fp, poll_table *wait)
 72{
 73	struct posix_clock *clk = get_posix_clock(fp);
 74	__poll_t result = 0;
 75
 76	if (!clk)
 77		return EPOLLERR;
 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
 87static 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
105static 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
123static 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
129	down_read(&clk->rwsem);
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	}
144out:
145	up_read(&clk->rwsem);
146	return err;
147}
148
149static 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
164static 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,
172#ifdef CONFIG_COMPAT
173	.compat_ioctl	= posix_clock_compat_ioctl,
174#endif
175};
176
177int posix_clock_register(struct posix_clock *clk, dev_t devid)
178{
179	int err;
180
181	kref_init(&clk->kref);
182	init_rwsem(&clk->rwsem);
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);
187
188	return err;
189}
190EXPORT_SYMBOL_GPL(posix_clock_register);
191
192static void delete_clock(struct kref *kref)
193{
194	struct posix_clock *clk = container_of(kref, struct posix_clock, kref);
195
196	if (clk->release)
197		clk->release(clk);
198}
199
200void posix_clock_unregister(struct posix_clock *clk)
201{
202	cdev_del(&clk->cdev);
203
204	down_write(&clk->rwsem);
205	clk->zombie = true;
206	up_write(&clk->rwsem);
207
208	kref_put(&clk->kref, delete_clock);
209}
210EXPORT_SYMBOL_GPL(posix_clock_unregister);
211
212struct posix_clock_desc {
213	struct file *fp;
214	struct posix_clock *clk;
215};
216
217static 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;
232out:
233	if (err)
234		fput(fp);
235	return err;
236}
237
238static void put_clock_desc(struct posix_clock_desc *cd)
239{
240	put_posix_clock(cd->clk);
241	fput(cd->fp);
242}
243
244static 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
253	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
254		err = -EACCES;
255		goto out;
256	}
257
258	if (cd.clk->ops.clock_adjtime)
259		err = cd.clk->ops.clock_adjtime(cd.clk, tx);
260	else
261		err = -EOPNOTSUPP;
262out:
263	put_clock_desc(&cd);
264
265	return err;
266}
267
268static int pc_clock_gettime(clockid_t id, struct timespec64 *ts)
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
277	if (cd.clk->ops.clock_gettime)
278		err = cd.clk->ops.clock_gettime(cd.clk, ts);
279	else
280		err = -EOPNOTSUPP;
281
282	put_clock_desc(&cd);
283
284	return err;
285}
286
287static int pc_clock_getres(clockid_t id, struct timespec64 *ts)
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
296	if (cd.clk->ops.clock_getres)
297		err = cd.clk->ops.clock_getres(cd.clk, ts);
298	else
299		err = -EOPNOTSUPP;
300
301	put_clock_desc(&cd);
302
303	return err;
304}
305
306static int pc_clock_settime(clockid_t id, const struct timespec64 *ts)
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
315	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
316		err = -EACCES;
317		goto out;
318	}
319
320	if (cd.clk->ops.clock_settime)
321		err = cd.clk->ops.clock_settime(cd.clk, ts);
322	else
323		err = -EOPNOTSUPP;
324out:
325	put_clock_desc(&cd);
326
327	return err;
328}
329
330const struct k_clock clock_posix_dynamic = {
331	.clock_getres	= pc_clock_getres,
332	.clock_set	= pc_clock_settime,
333	.clock_get	= pc_clock_gettime,
334	.clock_adj	= pc_clock_adjtime,
335};