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  */
get_posix_clock(struct file * fp)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 
put_posix_clock(struct posix_clock * clk)34 static void put_posix_clock(struct posix_clock *clk)
35 {
36 	up_read(&clk->rwsem);
37 }
38 
posix_clock_read(struct file * fp,char __user * buf,size_t count,loff_t * ppos)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 
posix_clock_poll(struct file * fp,poll_table * wait)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 
posix_clock_ioctl(struct file * fp,unsigned int cmd,unsigned long arg)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
posix_clock_compat_ioctl(struct file * fp,unsigned int cmd,unsigned long arg)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 
posix_clock_open(struct inode * inode,struct file * fp)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 
posix_clock_release(struct inode * inode,struct file * fp)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 
posix_clock_register(struct posix_clock * clk,struct device * dev)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 
posix_clock_unregister(struct posix_clock * clk)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 
get_clock_desc(const clockid_t id,struct posix_clock_desc * cd)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 
put_clock_desc(struct posix_clock_desc * cd)220 static void put_clock_desc(struct posix_clock_desc *cd)
221 {
222 	put_posix_clock(cd->clk);
223 	fput(cd->fp);
224 }
225 
pc_clock_adjtime(clockid_t id,struct __kernel_timex * tx)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 
pc_clock_gettime(clockid_t id,struct timespec64 * ts)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 
pc_clock_getres(clockid_t id,struct timespec64 * ts)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 
pc_clock_settime(clockid_t id,const struct timespec64 * ts)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 };
318