blob: 0e606b12a59df966b5509e87016d6782034ee473 [file] [log] [blame]
Davide Libenzib215e282007-05-10 22:23:16 -07001/*
2 * fs/timerfd.c
3 *
4 * Copyright (C) 2007 Davide Libenzi <davidel@xmailserver.org>
5 *
6 *
7 * Thanks to Thomas Gleixner for code reviews and useful comments.
8 *
9 */
10
11#include <linux/file.h>
12#include <linux/poll.h>
13#include <linux/init.h>
14#include <linux/fs.h>
15#include <linux/sched.h>
16#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090017#include <linux/slab.h>
Davide Libenzib215e282007-05-10 22:23:16 -070018#include <linux/list.h>
19#include <linux/spinlock.h>
20#include <linux/time.h>
21#include <linux/hrtimer.h>
22#include <linux/anon_inodes.h>
23#include <linux/timerfd.h>
Adrian Bunk45cc2b92008-04-29 00:58:59 -070024#include <linux/syscalls.h>
Al Viro9d94b9e2012-12-27 16:52:33 -050025#include <linux/compat.h>
Thomas Gleixner9ec26902011-05-20 16:18:50 +020026#include <linux/rcupdate.h>
Davide Libenzib215e282007-05-10 22:23:16 -070027
28struct timerfd_ctx {
29 struct hrtimer tmr;
30 ktime_t tintv;
Thomas Gleixner99ee5312011-04-27 14:16:42 +020031 ktime_t moffs;
Davide Libenzib215e282007-05-10 22:23:16 -070032 wait_queue_head_t wqh;
Davide Libenzi4d672e72008-02-04 22:27:26 -080033 u64 ticks;
Davide Libenzib215e282007-05-10 22:23:16 -070034 int expired;
Davide Libenzi4d672e72008-02-04 22:27:26 -080035 int clockid;
Thomas Gleixner9ec26902011-05-20 16:18:50 +020036 struct rcu_head rcu;
37 struct list_head clist;
Thomas Gleixner99ee5312011-04-27 14:16:42 +020038 bool might_cancel;
Davide Libenzib215e282007-05-10 22:23:16 -070039};
40
Thomas Gleixner9ec26902011-05-20 16:18:50 +020041static LIST_HEAD(cancel_list);
42static DEFINE_SPINLOCK(cancel_lock);
43
Davide Libenzib215e282007-05-10 22:23:16 -070044/*
45 * This gets called when the timer event triggers. We set the "expired"
46 * flag, but we do not re-arm the timer (in case it's necessary,
Davide Libenzi4d672e72008-02-04 22:27:26 -080047 * tintv.tv64 != 0) until the timer is accessed.
Davide Libenzib215e282007-05-10 22:23:16 -070048 */
49static enum hrtimer_restart timerfd_tmrproc(struct hrtimer *htmr)
50{
51 struct timerfd_ctx *ctx = container_of(htmr, struct timerfd_ctx, tmr);
52 unsigned long flags;
53
Davide Libenzi18963c02007-05-18 12:02:33 -070054 spin_lock_irqsave(&ctx->wqh.lock, flags);
Davide Libenzib215e282007-05-10 22:23:16 -070055 ctx->expired = 1;
Davide Libenzi4d672e72008-02-04 22:27:26 -080056 ctx->ticks++;
Davide Libenzib215e282007-05-10 22:23:16 -070057 wake_up_locked(&ctx->wqh);
Davide Libenzi18963c02007-05-18 12:02:33 -070058 spin_unlock_irqrestore(&ctx->wqh.lock, flags);
Davide Libenzib215e282007-05-10 22:23:16 -070059
60 return HRTIMER_NORESTART;
61}
62
Thomas Gleixner9ec26902011-05-20 16:18:50 +020063/*
64 * Called when the clock was set to cancel the timers in the cancel
Max Asbock1123d9392011-06-13 10:18:32 -070065 * list. This will wake up processes waiting on these timers. The
66 * wake-up requires ctx->ticks to be non zero, therefore we increment
67 * it before calling wake_up_locked().
Thomas Gleixner9ec26902011-05-20 16:18:50 +020068 */
69void timerfd_clock_was_set(void)
70{
71 ktime_t moffs = ktime_get_monotonic_offset();
72 struct timerfd_ctx *ctx;
73 unsigned long flags;
74
75 rcu_read_lock();
76 list_for_each_entry_rcu(ctx, &cancel_list, clist) {
77 if (!ctx->might_cancel)
78 continue;
79 spin_lock_irqsave(&ctx->wqh.lock, flags);
80 if (ctx->moffs.tv64 != moffs.tv64) {
81 ctx->moffs.tv64 = KTIME_MAX;
Max Asbock1123d9392011-06-13 10:18:32 -070082 ctx->ticks++;
Thomas Gleixner9ec26902011-05-20 16:18:50 +020083 wake_up_locked(&ctx->wqh);
84 }
85 spin_unlock_irqrestore(&ctx->wqh.lock, flags);
86 }
87 rcu_read_unlock();
88}
89
90static void timerfd_remove_cancel(struct timerfd_ctx *ctx)
91{
92 if (ctx->might_cancel) {
93 ctx->might_cancel = false;
94 spin_lock(&cancel_lock);
95 list_del_rcu(&ctx->clist);
96 spin_unlock(&cancel_lock);
97 }
98}
99
100static bool timerfd_canceled(struct timerfd_ctx *ctx)
101{
102 if (!ctx->might_cancel || ctx->moffs.tv64 != KTIME_MAX)
103 return false;
104 ctx->moffs = ktime_get_monotonic_offset();
105 return true;
106}
107
108static void timerfd_setup_cancel(struct timerfd_ctx *ctx, int flags)
109{
110 if (ctx->clockid == CLOCK_REALTIME && (flags & TFD_TIMER_ABSTIME) &&
111 (flags & TFD_TIMER_CANCEL_ON_SET)) {
112 if (!ctx->might_cancel) {
113 ctx->might_cancel = true;
114 spin_lock(&cancel_lock);
115 list_add_rcu(&ctx->clist, &cancel_list);
116 spin_unlock(&cancel_lock);
117 }
118 } else if (ctx->might_cancel) {
119 timerfd_remove_cancel(ctx);
120 }
121}
122
Davide Libenzi4d672e72008-02-04 22:27:26 -0800123static ktime_t timerfd_get_remaining(struct timerfd_ctx *ctx)
124{
Arjan van de Ven76369472008-09-01 15:00:14 -0700125 ktime_t remaining;
Davide Libenzi4d672e72008-02-04 22:27:26 -0800126
Arjan van de Ven76369472008-09-01 15:00:14 -0700127 remaining = hrtimer_expires_remaining(&ctx->tmr);
Davide Libenzi4d672e72008-02-04 22:27:26 -0800128 return remaining.tv64 < 0 ? ktime_set(0, 0): remaining;
129}
130
Thomas Gleixner99ee5312011-04-27 14:16:42 +0200131static int timerfd_setup(struct timerfd_ctx *ctx, int flags,
132 const struct itimerspec *ktmr)
Davide Libenzib215e282007-05-10 22:23:16 -0700133{
134 enum hrtimer_mode htmode;
135 ktime_t texp;
Thomas Gleixner99ee5312011-04-27 14:16:42 +0200136 int clockid = ctx->clockid;
Davide Libenzib215e282007-05-10 22:23:16 -0700137
138 htmode = (flags & TFD_TIMER_ABSTIME) ?
139 HRTIMER_MODE_ABS: HRTIMER_MODE_REL;
140
141 texp = timespec_to_ktime(ktmr->it_value);
142 ctx->expired = 0;
Davide Libenzi4d672e72008-02-04 22:27:26 -0800143 ctx->ticks = 0;
Davide Libenzib215e282007-05-10 22:23:16 -0700144 ctx->tintv = timespec_to_ktime(ktmr->it_interval);
Thomas Gleixner99ee5312011-04-27 14:16:42 +0200145 hrtimer_init(&ctx->tmr, clockid, htmode);
Arjan van de Ven76369472008-09-01 15:00:14 -0700146 hrtimer_set_expires(&ctx->tmr, texp);
Davide Libenzib215e282007-05-10 22:23:16 -0700147 ctx->tmr.function = timerfd_tmrproc;
Thomas Gleixner99ee5312011-04-27 14:16:42 +0200148 if (texp.tv64 != 0) {
Davide Libenzib215e282007-05-10 22:23:16 -0700149 hrtimer_start(&ctx->tmr, texp, htmode);
Thomas Gleixner99ee5312011-04-27 14:16:42 +0200150 if (timerfd_canceled(ctx))
151 return -ECANCELED;
152 }
153 return 0;
Davide Libenzib215e282007-05-10 22:23:16 -0700154}
155
156static int timerfd_release(struct inode *inode, struct file *file)
157{
158 struct timerfd_ctx *ctx = file->private_data;
159
Thomas Gleixner9ec26902011-05-20 16:18:50 +0200160 timerfd_remove_cancel(ctx);
Davide Libenzib215e282007-05-10 22:23:16 -0700161 hrtimer_cancel(&ctx->tmr);
Thomas Gleixner9ec26902011-05-20 16:18:50 +0200162 kfree_rcu(ctx, rcu);
Davide Libenzib215e282007-05-10 22:23:16 -0700163 return 0;
164}
165
166static unsigned int timerfd_poll(struct file *file, poll_table *wait)
167{
168 struct timerfd_ctx *ctx = file->private_data;
169 unsigned int events = 0;
170 unsigned long flags;
171
172 poll_wait(file, &ctx->wqh, wait);
173
Davide Libenzi18963c02007-05-18 12:02:33 -0700174 spin_lock_irqsave(&ctx->wqh.lock, flags);
Davide Libenzi4d672e72008-02-04 22:27:26 -0800175 if (ctx->ticks)
Davide Libenzib215e282007-05-10 22:23:16 -0700176 events |= POLLIN;
Davide Libenzi18963c02007-05-18 12:02:33 -0700177 spin_unlock_irqrestore(&ctx->wqh.lock, flags);
Davide Libenzib215e282007-05-10 22:23:16 -0700178
179 return events;
180}
181
182static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count,
183 loff_t *ppos)
184{
185 struct timerfd_ctx *ctx = file->private_data;
186 ssize_t res;
Davide Libenzi09828402007-07-26 10:41:07 -0700187 u64 ticks = 0;
Davide Libenzib215e282007-05-10 22:23:16 -0700188
189 if (count < sizeof(ticks))
190 return -EINVAL;
Davide Libenzi18963c02007-05-18 12:02:33 -0700191 spin_lock_irq(&ctx->wqh.lock);
Michal Nazarewicz8120a8a2010-05-05 12:53:12 +0200192 if (file->f_flags & O_NONBLOCK)
193 res = -EAGAIN;
194 else
195 res = wait_event_interruptible_locked_irq(ctx->wqh, ctx->ticks);
Thomas Gleixner99ee5312011-04-27 14:16:42 +0200196
Thomas Gleixner9ec26902011-05-20 16:18:50 +0200197 /*
198 * If clock has changed, we do not care about the
199 * ticks and we do not rearm the timer. Userspace must
200 * reevaluate anyway.
201 */
202 if (timerfd_canceled(ctx)) {
203 ctx->ticks = 0;
204 ctx->expired = 0;
205 res = -ECANCELED;
206 }
207
Davide Libenzi4d672e72008-02-04 22:27:26 -0800208 if (ctx->ticks) {
209 ticks = ctx->ticks;
Thomas Gleixner99ee5312011-04-27 14:16:42 +0200210
Davide Libenzi4d672e72008-02-04 22:27:26 -0800211 if (ctx->expired && ctx->tintv.tv64) {
Davide Libenzib215e282007-05-10 22:23:16 -0700212 /*
213 * If tintv.tv64 != 0, this is a periodic timer that
214 * needs to be re-armed. We avoid doing it in the timer
215 * callback to avoid DoS attacks specifying a very
216 * short timer period.
217 */
Davide Libenzi4d672e72008-02-04 22:27:26 -0800218 ticks += hrtimer_forward_now(&ctx->tmr,
219 ctx->tintv) - 1;
Davide Libenzib215e282007-05-10 22:23:16 -0700220 hrtimer_restart(&ctx->tmr);
Davide Libenzi4d672e72008-02-04 22:27:26 -0800221 }
222 ctx->expired = 0;
223 ctx->ticks = 0;
Davide Libenzib215e282007-05-10 22:23:16 -0700224 }
Davide Libenzi18963c02007-05-18 12:02:33 -0700225 spin_unlock_irq(&ctx->wqh.lock);
Davide Libenzib215e282007-05-10 22:23:16 -0700226 if (ticks)
Davide Libenzi09828402007-07-26 10:41:07 -0700227 res = put_user(ticks, (u64 __user *) buf) ? -EFAULT: sizeof(ticks);
Davide Libenzib215e282007-05-10 22:23:16 -0700228 return res;
229}
230
231static const struct file_operations timerfd_fops = {
232 .release = timerfd_release,
233 .poll = timerfd_poll,
234 .read = timerfd_read,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200235 .llseek = noop_llseek,
Davide Libenzib215e282007-05-10 22:23:16 -0700236};
237
Al Viro2903ff02012-08-28 12:52:22 -0400238static int timerfd_fget(int fd, struct fd *p)
Davide Libenzib215e282007-05-10 22:23:16 -0700239{
Al Viro2903ff02012-08-28 12:52:22 -0400240 struct fd f = fdget(fd);
241 if (!f.file)
242 return -EBADF;
243 if (f.file->f_op != &timerfd_fops) {
244 fdput(f);
245 return -EINVAL;
Davide Libenzi4d672e72008-02-04 22:27:26 -0800246 }
Al Viro2903ff02012-08-28 12:52:22 -0400247 *p = f;
248 return 0;
Davide Libenzi4d672e72008-02-04 22:27:26 -0800249}
250
Heiko Carstens836f92a2009-01-14 14:14:33 +0100251SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags)
Davide Libenzi4d672e72008-02-04 22:27:26 -0800252{
Al Viro2030a422008-02-23 06:46:49 -0500253 int ufd;
Davide Libenzib215e282007-05-10 22:23:16 -0700254 struct timerfd_ctx *ctx;
Davide Libenzi4d672e72008-02-04 22:27:26 -0800255
Ulrich Dreppere38b36f2008-07-23 21:29:42 -0700256 /* Check the TFD_* constants for consistency. */
257 BUILD_BUG_ON(TFD_CLOEXEC != O_CLOEXEC);
258 BUILD_BUG_ON(TFD_NONBLOCK != O_NONBLOCK);
259
Davide Libenzi610d18f2009-02-18 14:48:18 -0800260 if ((flags & ~TFD_CREATE_FLAGS) ||
261 (clockid != CLOCK_MONOTONIC &&
262 clockid != CLOCK_REALTIME))
Davide Libenzi4d672e72008-02-04 22:27:26 -0800263 return -EINVAL;
264
265 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
266 if (!ctx)
267 return -ENOMEM;
268
269 init_waitqueue_head(&ctx->wqh);
270 ctx->clockid = clockid;
271 hrtimer_init(&ctx->tmr, clockid, HRTIMER_MODE_ABS);
Thomas Gleixner99ee5312011-04-27 14:16:42 +0200272 ctx->moffs = ktime_get_monotonic_offset();
Davide Libenzi4d672e72008-02-04 22:27:26 -0800273
Ulrich Drepper11fcb6c2008-07-23 21:29:26 -0700274 ufd = anon_inode_getfd("[timerfd]", &timerfd_fops, ctx,
Roland Dreier628ff7c2009-12-18 09:41:24 -0800275 O_RDWR | (flags & TFD_SHARED_FCNTL_FLAGS));
Al Viro2030a422008-02-23 06:46:49 -0500276 if (ufd < 0)
Davide Libenzi4d672e72008-02-04 22:27:26 -0800277 kfree(ctx);
Davide Libenzi4d672e72008-02-04 22:27:26 -0800278
279 return ufd;
280}
281
Al Viro9d94b9e2012-12-27 16:52:33 -0500282static int do_timerfd_settime(int ufd, int flags,
283 const struct itimerspec *new,
284 struct itimerspec *old)
Davide Libenzi4d672e72008-02-04 22:27:26 -0800285{
Al Viro2903ff02012-08-28 12:52:22 -0400286 struct fd f;
Davide Libenzi4d672e72008-02-04 22:27:26 -0800287 struct timerfd_ctx *ctx;
Al Viro2903ff02012-08-28 12:52:22 -0400288 int ret;
Davide Libenzib215e282007-05-10 22:23:16 -0700289
Davide Libenzi610d18f2009-02-18 14:48:18 -0800290 if ((flags & ~TFD_SETTIME_FLAGS) ||
Al Viro9d94b9e2012-12-27 16:52:33 -0500291 !timespec_valid(&new->it_value) ||
292 !timespec_valid(&new->it_interval))
Davide Libenzib215e282007-05-10 22:23:16 -0700293 return -EINVAL;
294
Al Viro2903ff02012-08-28 12:52:22 -0400295 ret = timerfd_fget(ufd, &f);
296 if (ret)
297 return ret;
298 ctx = f.file->private_data;
Davide Libenzib215e282007-05-10 22:23:16 -0700299
Thomas Gleixner9ec26902011-05-20 16:18:50 +0200300 timerfd_setup_cancel(ctx, flags);
301
Davide Libenzi4d672e72008-02-04 22:27:26 -0800302 /*
303 * We need to stop the existing timer before reprogramming
304 * it to the new values.
305 */
306 for (;;) {
307 spin_lock_irq(&ctx->wqh.lock);
308 if (hrtimer_try_to_cancel(&ctx->tmr) >= 0)
309 break;
Davide Libenzi18963c02007-05-18 12:02:33 -0700310 spin_unlock_irq(&ctx->wqh.lock);
Davide Libenzi4d672e72008-02-04 22:27:26 -0800311 cpu_relax();
Davide Libenzib215e282007-05-10 22:23:16 -0700312 }
313
Davide Libenzi4d672e72008-02-04 22:27:26 -0800314 /*
315 * If the timer is expired and it's periodic, we need to advance it
316 * because the caller may want to know the previous expiration time.
317 * We do not update "ticks" and "expired" since the timer will be
318 * re-programmed again in the following timerfd_setup() call.
319 */
320 if (ctx->expired && ctx->tintv.tv64)
321 hrtimer_forward_now(&ctx->tmr, ctx->tintv);
Davide Libenzib215e282007-05-10 22:23:16 -0700322
Al Viro9d94b9e2012-12-27 16:52:33 -0500323 old->it_value = ktime_to_timespec(timerfd_get_remaining(ctx));
324 old->it_interval = ktime_to_timespec(ctx->tintv);
Davide Libenzi4d672e72008-02-04 22:27:26 -0800325
326 /*
327 * Re-program the timer to the new value ...
328 */
Al Viro9d94b9e2012-12-27 16:52:33 -0500329 ret = timerfd_setup(ctx, flags, new);
Davide Libenzi4d672e72008-02-04 22:27:26 -0800330
331 spin_unlock_irq(&ctx->wqh.lock);
Al Viro2903ff02012-08-28 12:52:22 -0400332 fdput(f);
Thomas Gleixner99ee5312011-04-27 14:16:42 +0200333 return ret;
Davide Libenzi4d672e72008-02-04 22:27:26 -0800334}
335
Al Viro9d94b9e2012-12-27 16:52:33 -0500336static int do_timerfd_gettime(int ufd, struct itimerspec *t)
Davide Libenzi4d672e72008-02-04 22:27:26 -0800337{
Al Viro2903ff02012-08-28 12:52:22 -0400338 struct fd f;
Davide Libenzi4d672e72008-02-04 22:27:26 -0800339 struct timerfd_ctx *ctx;
Al Viro2903ff02012-08-28 12:52:22 -0400340 int ret = timerfd_fget(ufd, &f);
341 if (ret)
342 return ret;
343 ctx = f.file->private_data;
Davide Libenzi4d672e72008-02-04 22:27:26 -0800344
345 spin_lock_irq(&ctx->wqh.lock);
346 if (ctx->expired && ctx->tintv.tv64) {
347 ctx->expired = 0;
348 ctx->ticks +=
349 hrtimer_forward_now(&ctx->tmr, ctx->tintv) - 1;
350 hrtimer_restart(&ctx->tmr);
351 }
Al Viro9d94b9e2012-12-27 16:52:33 -0500352 t->it_value = ktime_to_timespec(timerfd_get_remaining(ctx));
353 t->it_interval = ktime_to_timespec(ctx->tintv);
Davide Libenzi4d672e72008-02-04 22:27:26 -0800354 spin_unlock_irq(&ctx->wqh.lock);
Al Viro2903ff02012-08-28 12:52:22 -0400355 fdput(f);
Al Viro9d94b9e2012-12-27 16:52:33 -0500356 return 0;
357}
Davide Libenzi4d672e72008-02-04 22:27:26 -0800358
Al Viro9d94b9e2012-12-27 16:52:33 -0500359SYSCALL_DEFINE4(timerfd_settime, int, ufd, int, flags,
360 const struct itimerspec __user *, utmr,
361 struct itimerspec __user *, otmr)
362{
363 struct itimerspec new, old;
364 int ret;
365
366 if (copy_from_user(&new, utmr, sizeof(new)))
367 return -EFAULT;
368 ret = do_timerfd_settime(ufd, flags, &new, &old);
369 if (ret)
370 return ret;
371 if (otmr && copy_to_user(otmr, &old, sizeof(old)))
372 return -EFAULT;
373
374 return ret;
375}
376
377SYSCALL_DEFINE2(timerfd_gettime, int, ufd, struct itimerspec __user *, otmr)
378{
379 struct itimerspec kotmr;
380 int ret = do_timerfd_gettime(ufd, &kotmr);
381 if (ret)
382 return ret;
Davide Libenzi4d672e72008-02-04 22:27:26 -0800383 return copy_to_user(otmr, &kotmr, sizeof(kotmr)) ? -EFAULT: 0;
Davide Libenzib215e282007-05-10 22:23:16 -0700384}
385
Al Viro9d94b9e2012-12-27 16:52:33 -0500386#ifdef COMPAT
387COMPAT_SYSCALL_DEFINE4(timerfd_settime, int, ufd, int, flags,
388 const struct itimerspec __user *, utmr,
389 struct itimerspec __user *, otmr)
390{
391 struct itimerspec new, old;
392 int ret;
393
394 if (get_compat_itimerspec(&new, utmr))
395 return -EFAULT;
396 ret = do_timerfd_settime(ufd, flags, &new, &old);
397 if (ret)
398 return ret;
399 if (otmr && put_compat_itimerspec(otmr, &old))
400 return -EFAULT;
401 return ret;
402}
403
404COMPAT_SYSCALL_DEFINE2(timerfd_gettime, int, ufd,
405 struct itimerspec __user *, otmr)
406{
407 struct itimerspec kotmr;
408 int ret = do_timerfd_gettime(ufd, &kotmr);
409 if (ret)
410 return ret;
411 return put_compat_itimerspec(otmr, &t) ? -EFAULT: 0;
412}
413#endif