Linux Audio

Check our new training course

Loading...
v4.6
 
  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
 28static void delete_clock(struct kref *kref);
 29
 30/*
 31 * Returns NULL if the posix_clock instance attached to 'fp' is old and stale.
 32 */
 33static struct posix_clock *get_posix_clock(struct file *fp)
 34{
 35	struct posix_clock *clk = fp->private_data;
 
 36
 37	down_read(&clk->rwsem);
 38
 39	if (!clk->zombie)
 40		return clk;
 41
 42	up_read(&clk->rwsem);
 43
 44	return NULL;
 45}
 46
 47static void put_posix_clock(struct posix_clock *clk)
 48{
 49	up_read(&clk->rwsem);
 50}
 51
 52static ssize_t posix_clock_read(struct file *fp, char __user *buf,
 53				size_t count, loff_t *ppos)
 54{
 
 55	struct posix_clock *clk = get_posix_clock(fp);
 56	int err = -EINVAL;
 57
 58	if (!clk)
 59		return -ENODEV;
 60
 61	if (clk->ops.read)
 62		err = clk->ops.read(clk, fp->f_flags, buf, count);
 63
 64	put_posix_clock(clk);
 65
 66	return err;
 67}
 68
 69static unsigned int posix_clock_poll(struct file *fp, poll_table *wait)
 70{
 
 71	struct posix_clock *clk = get_posix_clock(fp);
 72	unsigned int result = 0;
 73
 74	if (!clk)
 75		return POLLERR;
 76
 77	if (clk->ops.poll)
 78		result = clk->ops.poll(clk, fp, wait);
 79
 80	put_posix_clock(clk);
 81
 82	return result;
 83}
 84
 85static int posix_clock_fasync(int fd, struct file *fp, int on)
 86{
 87	struct posix_clock *clk = get_posix_clock(fp);
 88	int err = 0;
 89
 90	if (!clk)
 91		return -ENODEV;
 92
 93	if (clk->ops.fasync)
 94		err = clk->ops.fasync(clk, fd, fp, on);
 95
 96	put_posix_clock(clk);
 97
 98	return err;
 99}
100
101static int posix_clock_mmap(struct file *fp, struct vm_area_struct *vma)
102{
103	struct posix_clock *clk = get_posix_clock(fp);
104	int err = -ENODEV;
105
106	if (!clk)
107		return -ENODEV;
108
109	if (clk->ops.mmap)
110		err = clk->ops.mmap(clk, vma);
111
112	put_posix_clock(clk);
113
114	return err;
115}
116
117static long posix_clock_ioctl(struct file *fp,
118			      unsigned int cmd, unsigned long arg)
119{
 
120	struct posix_clock *clk = get_posix_clock(fp);
121	int err = -ENOTTY;
122
123	if (!clk)
124		return -ENODEV;
125
126	if (clk->ops.ioctl)
127		err = clk->ops.ioctl(clk, cmd, arg);
128
129	put_posix_clock(clk);
130
131	return err;
132}
133
134#ifdef CONFIG_COMPAT
135static long posix_clock_compat_ioctl(struct file *fp,
136				     unsigned int cmd, unsigned long arg)
137{
 
138	struct posix_clock *clk = get_posix_clock(fp);
139	int err = -ENOTTY;
140
141	if (!clk)
142		return -ENODEV;
143
144	if (clk->ops.ioctl)
145		err = clk->ops.ioctl(clk, cmd, arg);
146
147	put_posix_clock(clk);
148
149	return err;
150}
151#endif
152
153static int posix_clock_open(struct inode *inode, struct file *fp)
154{
155	int err;
156	struct posix_clock *clk =
157		container_of(inode->i_cdev, struct posix_clock, cdev);
 
158
159	down_read(&clk->rwsem);
160
161	if (clk->zombie) {
162		err = -ENODEV;
163		goto out;
164	}
165	if (clk->ops.open)
166		err = clk->ops.open(clk, fp->f_mode);
167	else
168		err = 0;
169
170	if (!err) {
171		kref_get(&clk->kref);
172		fp->private_data = clk;
 
 
 
 
173	}
 
 
 
 
174out:
175	up_read(&clk->rwsem);
176	return err;
177}
178
179static int posix_clock_release(struct inode *inode, struct file *fp)
180{
181	struct posix_clock *clk = fp->private_data;
 
182	int err = 0;
183
 
 
 
 
184	if (clk->ops.release)
185		err = clk->ops.release(clk);
186
187	kref_put(&clk->kref, delete_clock);
188
 
189	fp->private_data = NULL;
190
191	return err;
192}
193
194static const struct file_operations posix_clock_file_operations = {
195	.owner		= THIS_MODULE,
196	.llseek		= no_llseek,
197	.read		= posix_clock_read,
198	.poll		= posix_clock_poll,
199	.unlocked_ioctl	= posix_clock_ioctl,
200	.open		= posix_clock_open,
201	.release	= posix_clock_release,
202	.fasync		= posix_clock_fasync,
203	.mmap		= posix_clock_mmap,
204#ifdef CONFIG_COMPAT
205	.compat_ioctl	= posix_clock_compat_ioctl,
206#endif
207};
208
209int posix_clock_register(struct posix_clock *clk, dev_t devid)
210{
211	int err;
212
213	kref_init(&clk->kref);
214	init_rwsem(&clk->rwsem);
215
216	cdev_init(&clk->cdev, &posix_clock_file_operations);
 
 
 
 
 
 
217	clk->cdev.owner = clk->ops.owner;
218	err = cdev_add(&clk->cdev, devid, 1);
219
220	return err;
221}
222EXPORT_SYMBOL_GPL(posix_clock_register);
223
224static void delete_clock(struct kref *kref)
225{
226	struct posix_clock *clk = container_of(kref, struct posix_clock, kref);
227
228	if (clk->release)
229		clk->release(clk);
230}
231
232void posix_clock_unregister(struct posix_clock *clk)
233{
234	cdev_del(&clk->cdev);
235
236	down_write(&clk->rwsem);
237	clk->zombie = true;
238	up_write(&clk->rwsem);
239
240	kref_put(&clk->kref, delete_clock);
241}
242EXPORT_SYMBOL_GPL(posix_clock_unregister);
243
244struct posix_clock_desc {
245	struct file *fp;
246	struct posix_clock *clk;
247};
248
249static int get_clock_desc(const clockid_t id, struct posix_clock_desc *cd)
250{
251	struct file *fp = fget(CLOCKID_TO_FD(id));
252	int err = -EINVAL;
253
254	if (!fp)
255		return err;
256
257	if (fp->f_op->open != posix_clock_open || !fp->private_data)
258		goto out;
259
260	cd->fp = fp;
261	cd->clk = get_posix_clock(fp);
262
263	err = cd->clk ? 0 : -ENODEV;
264out:
265	if (err)
266		fput(fp);
267	return err;
268}
269
270static void put_clock_desc(struct posix_clock_desc *cd)
271{
272	put_posix_clock(cd->clk);
273	fput(cd->fp);
274}
275
276static int pc_clock_adjtime(clockid_t id, struct timex *tx)
277{
278	struct posix_clock_desc cd;
279	int err;
280
281	err = get_clock_desc(id, &cd);
282	if (err)
283		return err;
284
285	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
286		err = -EACCES;
287		goto out;
288	}
289
290	if (cd.clk->ops.clock_adjtime)
291		err = cd.clk->ops.clock_adjtime(cd.clk, tx);
292	else
293		err = -EOPNOTSUPP;
294out:
295	put_clock_desc(&cd);
296
297	return err;
298}
299
300static int pc_clock_gettime(clockid_t id, struct timespec *ts)
301{
302	struct posix_clock_desc cd;
303	int err;
304
305	err = get_clock_desc(id, &cd);
306	if (err)
307		return err;
308
309	if (cd.clk->ops.clock_gettime)
310		err = cd.clk->ops.clock_gettime(cd.clk, ts);
311	else
312		err = -EOPNOTSUPP;
313
314	put_clock_desc(&cd);
315
316	return err;
317}
318
319static int pc_clock_getres(clockid_t id, struct timespec *ts)
320{
321	struct posix_clock_desc cd;
322	int err;
323
324	err = get_clock_desc(id, &cd);
325	if (err)
326		return err;
327
328	if (cd.clk->ops.clock_getres)
329		err = cd.clk->ops.clock_getres(cd.clk, ts);
330	else
331		err = -EOPNOTSUPP;
332
333	put_clock_desc(&cd);
334
335	return err;
336}
337
338static int pc_clock_settime(clockid_t id, const struct timespec *ts)
339{
340	struct posix_clock_desc cd;
341	int err;
342
 
 
 
343	err = get_clock_desc(id, &cd);
344	if (err)
345		return err;
346
347	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
348		err = -EACCES;
349		goto out;
350	}
351
352	if (cd.clk->ops.clock_settime)
353		err = cd.clk->ops.clock_settime(cd.clk, ts);
354	else
355		err = -EOPNOTSUPP;
356out:
357	put_clock_desc(&cd);
358
359	return err;
360}
361
362static int pc_timer_create(struct k_itimer *kit)
363{
364	clockid_t id = kit->it_clock;
365	struct posix_clock_desc cd;
366	int err;
367
368	err = get_clock_desc(id, &cd);
369	if (err)
370		return err;
371
372	if (cd.clk->ops.timer_create)
373		err = cd.clk->ops.timer_create(cd.clk, kit);
374	else
375		err = -EOPNOTSUPP;
376
377	put_clock_desc(&cd);
378
379	return err;
380}
381
382static int pc_timer_delete(struct k_itimer *kit)
383{
384	clockid_t id = kit->it_clock;
385	struct posix_clock_desc cd;
386	int err;
387
388	err = get_clock_desc(id, &cd);
389	if (err)
390		return err;
391
392	if (cd.clk->ops.timer_delete)
393		err = cd.clk->ops.timer_delete(cd.clk, kit);
394	else
395		err = -EOPNOTSUPP;
396
397	put_clock_desc(&cd);
398
399	return err;
400}
401
402static void pc_timer_gettime(struct k_itimer *kit, struct itimerspec *ts)
403{
404	clockid_t id = kit->it_clock;
405	struct posix_clock_desc cd;
406
407	if (get_clock_desc(id, &cd))
408		return;
409
410	if (cd.clk->ops.timer_gettime)
411		cd.clk->ops.timer_gettime(cd.clk, kit, ts);
412
413	put_clock_desc(&cd);
414}
415
416static int pc_timer_settime(struct k_itimer *kit, int flags,
417			    struct itimerspec *ts, struct itimerspec *old)
418{
419	clockid_t id = kit->it_clock;
420	struct posix_clock_desc cd;
421	int err;
422
423	err = get_clock_desc(id, &cd);
424	if (err)
425		return err;
426
427	if (cd.clk->ops.timer_settime)
428		err = cd.clk->ops.timer_settime(cd.clk, kit, flags, ts, old);
429	else
430		err = -EOPNOTSUPP;
431
432	put_clock_desc(&cd);
433
434	return err;
435}
436
437struct k_clock clock_posix_dynamic = {
438	.clock_getres	= pc_clock_getres,
439	.clock_set	= pc_clock_settime,
440	.clock_get	= pc_clock_gettime,
441	.clock_adj	= pc_clock_adjtime,
442	.timer_create	= pc_timer_create,
443	.timer_set	= pc_timer_settime,
444	.timer_del	= pc_timer_delete,
445	.timer_get	= pc_timer_gettime,
446};
v6.13.7
  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_context *pccontext = fp->private_data;
 23	struct posix_clock *clk = pccontext->clk;
 24
 25	down_read(&clk->rwsem);
 26
 27	if (!clk->zombie)
 28		return clk;
 29
 30	up_read(&clk->rwsem);
 31
 32	return NULL;
 33}
 34
 35static void put_posix_clock(struct posix_clock *clk)
 36{
 37	up_read(&clk->rwsem);
 38}
 39
 40static ssize_t posix_clock_read(struct file *fp, char __user *buf,
 41				size_t count, loff_t *ppos)
 42{
 43	struct posix_clock_context *pccontext = fp->private_data;
 44	struct posix_clock *clk = get_posix_clock(fp);
 45	int err = -EINVAL;
 46
 47	if (!clk)
 48		return -ENODEV;
 49
 50	if (clk->ops.read)
 51		err = clk->ops.read(pccontext, fp->f_flags, buf, count);
 52
 53	put_posix_clock(clk);
 54
 55	return err;
 56}
 57
 58static __poll_t posix_clock_poll(struct file *fp, poll_table *wait)
 59{
 60	struct posix_clock_context *pccontext = fp->private_data;
 61	struct posix_clock *clk = get_posix_clock(fp);
 62	__poll_t result = 0;
 63
 64	if (!clk)
 65		return EPOLLERR;
 66
 67	if (clk->ops.poll)
 68		result = clk->ops.poll(pccontext, fp, wait);
 69
 70	put_posix_clock(clk);
 71
 72	return result;
 73}
 74
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 75static long posix_clock_ioctl(struct file *fp,
 76			      unsigned int cmd, unsigned long arg)
 77{
 78	struct posix_clock_context *pccontext = fp->private_data;
 79	struct posix_clock *clk = get_posix_clock(fp);
 80	int err = -ENOTTY;
 81
 82	if (!clk)
 83		return -ENODEV;
 84
 85	if (clk->ops.ioctl)
 86		err = clk->ops.ioctl(pccontext, cmd, arg);
 87
 88	put_posix_clock(clk);
 89
 90	return err;
 91}
 92
 93#ifdef CONFIG_COMPAT
 94static long posix_clock_compat_ioctl(struct file *fp,
 95				     unsigned int cmd, unsigned long arg)
 96{
 97	struct posix_clock_context *pccontext = fp->private_data;
 98	struct posix_clock *clk = get_posix_clock(fp);
 99	int err = -ENOTTY;
100
101	if (!clk)
102		return -ENODEV;
103
104	if (clk->ops.ioctl)
105		err = clk->ops.ioctl(pccontext, cmd, arg);
106
107	put_posix_clock(clk);
108
109	return err;
110}
111#endif
112
113static int posix_clock_open(struct inode *inode, struct file *fp)
114{
115	int err;
116	struct posix_clock *clk =
117		container_of(inode->i_cdev, struct posix_clock, cdev);
118	struct posix_clock_context *pccontext;
119
120	down_read(&clk->rwsem);
121
122	if (clk->zombie) {
123		err = -ENODEV;
124		goto out;
125	}
126	pccontext = kzalloc(sizeof(*pccontext), GFP_KERNEL);
127	if (!pccontext) {
128		err = -ENOMEM;
129		goto out;
130	}
131	pccontext->clk = clk;
132	if (clk->ops.open) {
133		err = clk->ops.open(pccontext, fp->f_mode);
134		if (err) {
135			kfree(pccontext);
136			goto out;
137		}
138	}
139
140	fp->private_data = pccontext;
141	get_device(clk->dev);
142	err = 0;
143out:
144	up_read(&clk->rwsem);
145	return err;
146}
147
148static int posix_clock_release(struct inode *inode, struct file *fp)
149{
150	struct posix_clock_context *pccontext = fp->private_data;
151	struct posix_clock *clk;
152	int err = 0;
153
154	if (!pccontext)
155		return -ENODEV;
156	clk = pccontext->clk;
157
158	if (clk->ops.release)
159		err = clk->ops.release(pccontext);
160
161	put_device(clk->dev);
162
163	kfree(pccontext);
164	fp->private_data = NULL;
165
166	return err;
167}
168
169static const struct file_operations posix_clock_file_operations = {
170	.owner		= THIS_MODULE,
 
171	.read		= posix_clock_read,
172	.poll		= posix_clock_poll,
173	.unlocked_ioctl	= posix_clock_ioctl,
174	.open		= posix_clock_open,
175	.release	= posix_clock_release,
 
 
176#ifdef CONFIG_COMPAT
177	.compat_ioctl	= posix_clock_compat_ioctl,
178#endif
179};
180
181int posix_clock_register(struct posix_clock *clk, struct device *dev)
182{
183	int err;
184
 
185	init_rwsem(&clk->rwsem);
186
187	cdev_init(&clk->cdev, &posix_clock_file_operations);
188	err = cdev_device_add(&clk->cdev, dev);
189	if (err) {
190		pr_err("%s unable to add device %d:%d\n",
191			dev_name(dev), MAJOR(dev->devt), MINOR(dev->devt));
192		return err;
193	}
194	clk->cdev.owner = clk->ops.owner;
195	clk->dev = dev;
196
197	return 0;
198}
199EXPORT_SYMBOL_GPL(posix_clock_register);
200
 
 
 
 
 
 
 
 
201void posix_clock_unregister(struct posix_clock *clk)
202{
203	cdev_device_del(&clk->cdev, clk->dev);
204
205	down_write(&clk->rwsem);
206	clk->zombie = true;
207	up_write(&clk->rwsem);
208
209	put_device(clk->dev);
210}
211EXPORT_SYMBOL_GPL(posix_clock_unregister);
212
213struct posix_clock_desc {
214	struct file *fp;
215	struct posix_clock *clk;
216};
217
218static int get_clock_desc(const clockid_t id, struct posix_clock_desc *cd)
219{
220	struct file *fp = fget(clockid_to_fd(id));
221	int err = -EINVAL;
222
223	if (!fp)
224		return err;
225
226	if (fp->f_op->open != posix_clock_open || !fp->private_data)
227		goto out;
228
229	cd->fp = fp;
230	cd->clk = get_posix_clock(fp);
231
232	err = cd->clk ? 0 : -ENODEV;
233out:
234	if (err)
235		fput(fp);
236	return err;
237}
238
239static void put_clock_desc(struct posix_clock_desc *cd)
240{
241	put_posix_clock(cd->clk);
242	fput(cd->fp);
243}
244
245static int pc_clock_adjtime(clockid_t id, struct __kernel_timex *tx)
246{
247	struct posix_clock_desc cd;
248	int err;
249
250	err = get_clock_desc(id, &cd);
251	if (err)
252		return err;
253
254	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
255		err = -EACCES;
256		goto out;
257	}
258
259	if (cd.clk->ops.clock_adjtime)
260		err = cd.clk->ops.clock_adjtime(cd.clk, tx);
261	else
262		err = -EOPNOTSUPP;
263out:
264	put_clock_desc(&cd);
265
266	return err;
267}
268
269static int pc_clock_gettime(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_gettime)
279		err = cd.clk->ops.clock_gettime(cd.clk, ts);
280	else
281		err = -EOPNOTSUPP;
282
283	put_clock_desc(&cd);
284
285	return err;
286}
287
288static int pc_clock_getres(clockid_t id, 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.clk->ops.clock_getres)
298		err = cd.clk->ops.clock_getres(cd.clk, ts);
299	else
300		err = -EOPNOTSUPP;
301
302	put_clock_desc(&cd);
303
304	return err;
305}
306
307static int pc_clock_settime(clockid_t id, const struct timespec64 *ts)
308{
309	struct posix_clock_desc cd;
310	int err;
311
312	if (!timespec64_valid_strict(ts))
313		return -EINVAL;
314
315	err = get_clock_desc(id, &cd);
316	if (err)
317		return err;
318
319	if ((cd.fp->f_mode & FMODE_WRITE) == 0) {
320		err = -EACCES;
321		goto out;
322	}
323
324	if (cd.clk->ops.clock_settime)
325		err = cd.clk->ops.clock_settime(cd.clk, ts);
326	else
327		err = -EOPNOTSUPP;
328out:
329	put_clock_desc(&cd);
330
331	return err;
332}
333
334const struct k_clock clock_posix_dynamic = {
335	.clock_getres		= pc_clock_getres,
336	.clock_set		= pc_clock_settime,
337	.clock_get_timespec	= pc_clock_gettime,
338	.clock_adj		= pc_clock_adjtime,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
339};