~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/time/posix-clock.c

Version: ~ [ linux-5.19-rc3 ] ~ [ linux-5.18.5 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.48 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.123 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.199 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.248 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.284 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.319 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp