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

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

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ 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.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 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 
 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 
 49 static void put_posix_clock(struct posix_clock *clk)
 50 {
 51         up_read(&clk->rwsem);
 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 __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 
 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 
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         }
144 out:
145         up_read(&clk->rwsem);
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,
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);
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 }
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);
195 
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 
204         down_write(&clk->rwsem);
205         clk->zombie = true;
206         up_write(&clk->rwsem);
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 
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;
262 out:
263         put_clock_desc(&cd);
264 
265         return err;
266 }
267 
268 static 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 
287 static 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 
306 static 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;
324 out:
325         put_clock_desc(&cd);
326 
327         return err;
328 }
329 
330 const 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 };
336 

~ [ 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