scsi: target: core: Get rid of warning in compare_and_write_do_cmp()
[linux-2.6-microblaze.git] / fs / timerfd.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  fs/timerfd.c
4  *
5  *  Copyright (C) 2007  Davide Libenzi <davidel@xmailserver.org>
6  *
7  *
8  *  Thanks to Thomas Gleixner for code reviews and useful comments.
9  *
10  */
11
12 #include <linux/alarmtimer.h>
13 #include <linux/file.h>
14 #include <linux/poll.h>
15 #include <linux/init.h>
16 #include <linux/fs.h>
17 #include <linux/sched.h>
18 #include <linux/kernel.h>
19 #include <linux/slab.h>
20 #include <linux/list.h>
21 #include <linux/spinlock.h>
22 #include <linux/time.h>
23 #include <linux/hrtimer.h>
24 #include <linux/anon_inodes.h>
25 #include <linux/timerfd.h>
26 #include <linux/syscalls.h>
27 #include <linux/compat.h>
28 #include <linux/rcupdate.h>
29 #include <linux/time_namespace.h>
30
31 struct timerfd_ctx {
32         union {
33                 struct hrtimer tmr;
34                 struct alarm alarm;
35         } t;
36         ktime_t tintv;
37         ktime_t moffs;
38         wait_queue_head_t wqh;
39         u64 ticks;
40         int clockid;
41         short unsigned expired;
42         short unsigned settime_flags;   /* to show in fdinfo */
43         struct rcu_head rcu;
44         struct list_head clist;
45         spinlock_t cancel_lock;
46         bool might_cancel;
47 };
48
49 static LIST_HEAD(cancel_list);
50 static DEFINE_SPINLOCK(cancel_lock);
51
52 static inline bool isalarm(struct timerfd_ctx *ctx)
53 {
54         return ctx->clockid == CLOCK_REALTIME_ALARM ||
55                 ctx->clockid == CLOCK_BOOTTIME_ALARM;
56 }
57
58 /*
59  * This gets called when the timer event triggers. We set the "expired"
60  * flag, but we do not re-arm the timer (in case it's necessary,
61  * tintv != 0) until the timer is accessed.
62  */
63 static void timerfd_triggered(struct timerfd_ctx *ctx)
64 {
65         unsigned long flags;
66
67         spin_lock_irqsave(&ctx->wqh.lock, flags);
68         ctx->expired = 1;
69         ctx->ticks++;
70         wake_up_locked_poll(&ctx->wqh, EPOLLIN);
71         spin_unlock_irqrestore(&ctx->wqh.lock, flags);
72 }
73
74 static enum hrtimer_restart timerfd_tmrproc(struct hrtimer *htmr)
75 {
76         struct timerfd_ctx *ctx = container_of(htmr, struct timerfd_ctx,
77                                                t.tmr);
78         timerfd_triggered(ctx);
79         return HRTIMER_NORESTART;
80 }
81
82 static enum alarmtimer_restart timerfd_alarmproc(struct alarm *alarm,
83         ktime_t now)
84 {
85         struct timerfd_ctx *ctx = container_of(alarm, struct timerfd_ctx,
86                                                t.alarm);
87         timerfd_triggered(ctx);
88         return ALARMTIMER_NORESTART;
89 }
90
91 /*
92  * Called when the clock was set to cancel the timers in the cancel
93  * list. This will wake up processes waiting on these timers. The
94  * wake-up requires ctx->ticks to be non zero, therefore we increment
95  * it before calling wake_up_locked().
96  */
97 void timerfd_clock_was_set(void)
98 {
99         ktime_t moffs = ktime_mono_to_real(0);
100         struct timerfd_ctx *ctx;
101         unsigned long flags;
102
103         rcu_read_lock();
104         list_for_each_entry_rcu(ctx, &cancel_list, clist) {
105                 if (!ctx->might_cancel)
106                         continue;
107                 spin_lock_irqsave(&ctx->wqh.lock, flags);
108                 if (ctx->moffs != moffs) {
109                         ctx->moffs = KTIME_MAX;
110                         ctx->ticks++;
111                         wake_up_locked_poll(&ctx->wqh, EPOLLIN);
112                 }
113                 spin_unlock_irqrestore(&ctx->wqh.lock, flags);
114         }
115         rcu_read_unlock();
116 }
117
118 static void __timerfd_remove_cancel(struct timerfd_ctx *ctx)
119 {
120         if (ctx->might_cancel) {
121                 ctx->might_cancel = false;
122                 spin_lock(&cancel_lock);
123                 list_del_rcu(&ctx->clist);
124                 spin_unlock(&cancel_lock);
125         }
126 }
127
128 static void timerfd_remove_cancel(struct timerfd_ctx *ctx)
129 {
130         spin_lock(&ctx->cancel_lock);
131         __timerfd_remove_cancel(ctx);
132         spin_unlock(&ctx->cancel_lock);
133 }
134
135 static bool timerfd_canceled(struct timerfd_ctx *ctx)
136 {
137         if (!ctx->might_cancel || ctx->moffs != KTIME_MAX)
138                 return false;
139         ctx->moffs = ktime_mono_to_real(0);
140         return true;
141 }
142
143 static void timerfd_setup_cancel(struct timerfd_ctx *ctx, int flags)
144 {
145         spin_lock(&ctx->cancel_lock);
146         if ((ctx->clockid == CLOCK_REALTIME ||
147              ctx->clockid == CLOCK_REALTIME_ALARM) &&
148             (flags & TFD_TIMER_ABSTIME) && (flags & TFD_TIMER_CANCEL_ON_SET)) {
149                 if (!ctx->might_cancel) {
150                         ctx->might_cancel = true;
151                         spin_lock(&cancel_lock);
152                         list_add_rcu(&ctx->clist, &cancel_list);
153                         spin_unlock(&cancel_lock);
154                 }
155         } else {
156                 __timerfd_remove_cancel(ctx);
157         }
158         spin_unlock(&ctx->cancel_lock);
159 }
160
161 static ktime_t timerfd_get_remaining(struct timerfd_ctx *ctx)
162 {
163         ktime_t remaining;
164
165         if (isalarm(ctx))
166                 remaining = alarm_expires_remaining(&ctx->t.alarm);
167         else
168                 remaining = hrtimer_expires_remaining_adjusted(&ctx->t.tmr);
169
170         return remaining < 0 ? 0: remaining;
171 }
172
173 static int timerfd_setup(struct timerfd_ctx *ctx, int flags,
174                          const struct itimerspec64 *ktmr)
175 {
176         enum hrtimer_mode htmode;
177         ktime_t texp;
178         int clockid = ctx->clockid;
179
180         htmode = (flags & TFD_TIMER_ABSTIME) ?
181                 HRTIMER_MODE_ABS: HRTIMER_MODE_REL;
182
183         texp = timespec64_to_ktime(ktmr->it_value);
184         ctx->expired = 0;
185         ctx->ticks = 0;
186         ctx->tintv = timespec64_to_ktime(ktmr->it_interval);
187
188         if (isalarm(ctx)) {
189                 alarm_init(&ctx->t.alarm,
190                            ctx->clockid == CLOCK_REALTIME_ALARM ?
191                            ALARM_REALTIME : ALARM_BOOTTIME,
192                            timerfd_alarmproc);
193         } else {
194                 hrtimer_init(&ctx->t.tmr, clockid, htmode);
195                 hrtimer_set_expires(&ctx->t.tmr, texp);
196                 ctx->t.tmr.function = timerfd_tmrproc;
197         }
198
199         if (texp != 0) {
200                 if (flags & TFD_TIMER_ABSTIME)
201                         texp = timens_ktime_to_host(clockid, texp);
202                 if (isalarm(ctx)) {
203                         if (flags & TFD_TIMER_ABSTIME)
204                                 alarm_start(&ctx->t.alarm, texp);
205                         else
206                                 alarm_start_relative(&ctx->t.alarm, texp);
207                 } else {
208                         hrtimer_start(&ctx->t.tmr, texp, htmode);
209                 }
210
211                 if (timerfd_canceled(ctx))
212                         return -ECANCELED;
213         }
214
215         ctx->settime_flags = flags & TFD_SETTIME_FLAGS;
216         return 0;
217 }
218
219 static int timerfd_release(struct inode *inode, struct file *file)
220 {
221         struct timerfd_ctx *ctx = file->private_data;
222
223         timerfd_remove_cancel(ctx);
224
225         if (isalarm(ctx))
226                 alarm_cancel(&ctx->t.alarm);
227         else
228                 hrtimer_cancel(&ctx->t.tmr);
229         kfree_rcu(ctx, rcu);
230         return 0;
231 }
232
233 static __poll_t timerfd_poll(struct file *file, poll_table *wait)
234 {
235         struct timerfd_ctx *ctx = file->private_data;
236         __poll_t events = 0;
237         unsigned long flags;
238
239         poll_wait(file, &ctx->wqh, wait);
240
241         spin_lock_irqsave(&ctx->wqh.lock, flags);
242         if (ctx->ticks)
243                 events |= EPOLLIN;
244         spin_unlock_irqrestore(&ctx->wqh.lock, flags);
245
246         return events;
247 }
248
249 static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count,
250                             loff_t *ppos)
251 {
252         struct timerfd_ctx *ctx = file->private_data;
253         ssize_t res;
254         u64 ticks = 0;
255
256         if (count < sizeof(ticks))
257                 return -EINVAL;
258         spin_lock_irq(&ctx->wqh.lock);
259         if (file->f_flags & O_NONBLOCK)
260                 res = -EAGAIN;
261         else
262                 res = wait_event_interruptible_locked_irq(ctx->wqh, ctx->ticks);
263
264         /*
265          * If clock has changed, we do not care about the
266          * ticks and we do not rearm the timer. Userspace must
267          * reevaluate anyway.
268          */
269         if (timerfd_canceled(ctx)) {
270                 ctx->ticks = 0;
271                 ctx->expired = 0;
272                 res = -ECANCELED;
273         }
274
275         if (ctx->ticks) {
276                 ticks = ctx->ticks;
277
278                 if (ctx->expired && ctx->tintv) {
279                         /*
280                          * If tintv != 0, this is a periodic timer that
281                          * needs to be re-armed. We avoid doing it in the timer
282                          * callback to avoid DoS attacks specifying a very
283                          * short timer period.
284                          */
285                         if (isalarm(ctx)) {
286                                 ticks += alarm_forward_now(
287                                         &ctx->t.alarm, ctx->tintv) - 1;
288                                 alarm_restart(&ctx->t.alarm);
289                         } else {
290                                 ticks += hrtimer_forward_now(&ctx->t.tmr,
291                                                              ctx->tintv) - 1;
292                                 hrtimer_restart(&ctx->t.tmr);
293                         }
294                 }
295                 ctx->expired = 0;
296                 ctx->ticks = 0;
297         }
298         spin_unlock_irq(&ctx->wqh.lock);
299         if (ticks)
300                 res = put_user(ticks, (u64 __user *) buf) ? -EFAULT: sizeof(ticks);
301         return res;
302 }
303
304 #ifdef CONFIG_PROC_FS
305 static void timerfd_show(struct seq_file *m, struct file *file)
306 {
307         struct timerfd_ctx *ctx = file->private_data;
308         struct timespec64 value, interval;
309
310         spin_lock_irq(&ctx->wqh.lock);
311         value = ktime_to_timespec64(timerfd_get_remaining(ctx));
312         interval = ktime_to_timespec64(ctx->tintv);
313         spin_unlock_irq(&ctx->wqh.lock);
314
315         seq_printf(m,
316                    "clockid: %d\n"
317                    "ticks: %llu\n"
318                    "settime flags: 0%o\n"
319                    "it_value: (%llu, %llu)\n"
320                    "it_interval: (%llu, %llu)\n",
321                    ctx->clockid,
322                    (unsigned long long)ctx->ticks,
323                    ctx->settime_flags,
324                    (unsigned long long)value.tv_sec,
325                    (unsigned long long)value.tv_nsec,
326                    (unsigned long long)interval.tv_sec,
327                    (unsigned long long)interval.tv_nsec);
328 }
329 #else
330 #define timerfd_show NULL
331 #endif
332
333 #ifdef CONFIG_CHECKPOINT_RESTORE
334 static long timerfd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
335 {
336         struct timerfd_ctx *ctx = file->private_data;
337         int ret = 0;
338
339         switch (cmd) {
340         case TFD_IOC_SET_TICKS: {
341                 u64 ticks;
342
343                 if (copy_from_user(&ticks, (u64 __user *)arg, sizeof(ticks)))
344                         return -EFAULT;
345                 if (!ticks)
346                         return -EINVAL;
347
348                 spin_lock_irq(&ctx->wqh.lock);
349                 if (!timerfd_canceled(ctx)) {
350                         ctx->ticks = ticks;
351                         wake_up_locked_poll(&ctx->wqh, EPOLLIN);
352                 } else
353                         ret = -ECANCELED;
354                 spin_unlock_irq(&ctx->wqh.lock);
355                 break;
356         }
357         default:
358                 ret = -ENOTTY;
359                 break;
360         }
361
362         return ret;
363 }
364 #else
365 #define timerfd_ioctl NULL
366 #endif
367
368 static const struct file_operations timerfd_fops = {
369         .release        = timerfd_release,
370         .poll           = timerfd_poll,
371         .read           = timerfd_read,
372         .llseek         = noop_llseek,
373         .show_fdinfo    = timerfd_show,
374         .unlocked_ioctl = timerfd_ioctl,
375 };
376
377 static int timerfd_fget(int fd, struct fd *p)
378 {
379         struct fd f = fdget(fd);
380         if (!f.file)
381                 return -EBADF;
382         if (f.file->f_op != &timerfd_fops) {
383                 fdput(f);
384                 return -EINVAL;
385         }
386         *p = f;
387         return 0;
388 }
389
390 SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags)
391 {
392         int ufd;
393         struct timerfd_ctx *ctx;
394
395         /* Check the TFD_* constants for consistency.  */
396         BUILD_BUG_ON(TFD_CLOEXEC != O_CLOEXEC);
397         BUILD_BUG_ON(TFD_NONBLOCK != O_NONBLOCK);
398
399         if ((flags & ~TFD_CREATE_FLAGS) ||
400             (clockid != CLOCK_MONOTONIC &&
401              clockid != CLOCK_REALTIME &&
402              clockid != CLOCK_REALTIME_ALARM &&
403              clockid != CLOCK_BOOTTIME &&
404              clockid != CLOCK_BOOTTIME_ALARM))
405                 return -EINVAL;
406
407         if ((clockid == CLOCK_REALTIME_ALARM ||
408              clockid == CLOCK_BOOTTIME_ALARM) &&
409             !capable(CAP_WAKE_ALARM))
410                 return -EPERM;
411
412         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
413         if (!ctx)
414                 return -ENOMEM;
415
416         init_waitqueue_head(&ctx->wqh);
417         spin_lock_init(&ctx->cancel_lock);
418         ctx->clockid = clockid;
419
420         if (isalarm(ctx))
421                 alarm_init(&ctx->t.alarm,
422                            ctx->clockid == CLOCK_REALTIME_ALARM ?
423                            ALARM_REALTIME : ALARM_BOOTTIME,
424                            timerfd_alarmproc);
425         else
426                 hrtimer_init(&ctx->t.tmr, clockid, HRTIMER_MODE_ABS);
427
428         ctx->moffs = ktime_mono_to_real(0);
429
430         ufd = anon_inode_getfd("[timerfd]", &timerfd_fops, ctx,
431                                O_RDWR | (flags & TFD_SHARED_FCNTL_FLAGS));
432         if (ufd < 0)
433                 kfree(ctx);
434
435         return ufd;
436 }
437
438 static int do_timerfd_settime(int ufd, int flags, 
439                 const struct itimerspec64 *new,
440                 struct itimerspec64 *old)
441 {
442         struct fd f;
443         struct timerfd_ctx *ctx;
444         int ret;
445
446         if ((flags & ~TFD_SETTIME_FLAGS) ||
447                  !itimerspec64_valid(new))
448                 return -EINVAL;
449
450         ret = timerfd_fget(ufd, &f);
451         if (ret)
452                 return ret;
453         ctx = f.file->private_data;
454
455         if (isalarm(ctx) && !capable(CAP_WAKE_ALARM)) {
456                 fdput(f);
457                 return -EPERM;
458         }
459
460         timerfd_setup_cancel(ctx, flags);
461
462         /*
463          * We need to stop the existing timer before reprogramming
464          * it to the new values.
465          */
466         for (;;) {
467                 spin_lock_irq(&ctx->wqh.lock);
468
469                 if (isalarm(ctx)) {
470                         if (alarm_try_to_cancel(&ctx->t.alarm) >= 0)
471                                 break;
472                 } else {
473                         if (hrtimer_try_to_cancel(&ctx->t.tmr) >= 0)
474                                 break;
475                 }
476                 spin_unlock_irq(&ctx->wqh.lock);
477
478                 if (isalarm(ctx))
479                         hrtimer_cancel_wait_running(&ctx->t.alarm.timer);
480                 else
481                         hrtimer_cancel_wait_running(&ctx->t.tmr);
482         }
483
484         /*
485          * If the timer is expired and it's periodic, we need to advance it
486          * because the caller may want to know the previous expiration time.
487          * We do not update "ticks" and "expired" since the timer will be
488          * re-programmed again in the following timerfd_setup() call.
489          */
490         if (ctx->expired && ctx->tintv) {
491                 if (isalarm(ctx))
492                         alarm_forward_now(&ctx->t.alarm, ctx->tintv);
493                 else
494                         hrtimer_forward_now(&ctx->t.tmr, ctx->tintv);
495         }
496
497         old->it_value = ktime_to_timespec64(timerfd_get_remaining(ctx));
498         old->it_interval = ktime_to_timespec64(ctx->tintv);
499
500         /*
501          * Re-program the timer to the new value ...
502          */
503         ret = timerfd_setup(ctx, flags, new);
504
505         spin_unlock_irq(&ctx->wqh.lock);
506         fdput(f);
507         return ret;
508 }
509
510 static int do_timerfd_gettime(int ufd, struct itimerspec64 *t)
511 {
512         struct fd f;
513         struct timerfd_ctx *ctx;
514         int ret = timerfd_fget(ufd, &f);
515         if (ret)
516                 return ret;
517         ctx = f.file->private_data;
518
519         spin_lock_irq(&ctx->wqh.lock);
520         if (ctx->expired && ctx->tintv) {
521                 ctx->expired = 0;
522
523                 if (isalarm(ctx)) {
524                         ctx->ticks +=
525                                 alarm_forward_now(
526                                         &ctx->t.alarm, ctx->tintv) - 1;
527                         alarm_restart(&ctx->t.alarm);
528                 } else {
529                         ctx->ticks +=
530                                 hrtimer_forward_now(&ctx->t.tmr, ctx->tintv)
531                                 - 1;
532                         hrtimer_restart(&ctx->t.tmr);
533                 }
534         }
535         t->it_value = ktime_to_timespec64(timerfd_get_remaining(ctx));
536         t->it_interval = ktime_to_timespec64(ctx->tintv);
537         spin_unlock_irq(&ctx->wqh.lock);
538         fdput(f);
539         return 0;
540 }
541
542 SYSCALL_DEFINE4(timerfd_settime, int, ufd, int, flags,
543                 const struct __kernel_itimerspec __user *, utmr,
544                 struct __kernel_itimerspec __user *, otmr)
545 {
546         struct itimerspec64 new, old;
547         int ret;
548
549         if (get_itimerspec64(&new, utmr))
550                 return -EFAULT;
551         ret = do_timerfd_settime(ufd, flags, &new, &old);
552         if (ret)
553                 return ret;
554         if (otmr && put_itimerspec64(&old, otmr))
555                 return -EFAULT;
556
557         return ret;
558 }
559
560 SYSCALL_DEFINE2(timerfd_gettime, int, ufd, struct __kernel_itimerspec __user *, otmr)
561 {
562         struct itimerspec64 kotmr;
563         int ret = do_timerfd_gettime(ufd, &kotmr);
564         if (ret)
565                 return ret;
566         return put_itimerspec64(&kotmr, otmr) ? -EFAULT : 0;
567 }
568
569 #ifdef CONFIG_COMPAT_32BIT_TIME
570 SYSCALL_DEFINE4(timerfd_settime32, int, ufd, int, flags,
571                 const struct old_itimerspec32 __user *, utmr,
572                 struct old_itimerspec32 __user *, otmr)
573 {
574         struct itimerspec64 new, old;
575         int ret;
576
577         if (get_old_itimerspec32(&new, utmr))
578                 return -EFAULT;
579         ret = do_timerfd_settime(ufd, flags, &new, &old);
580         if (ret)
581                 return ret;
582         if (otmr && put_old_itimerspec32(&old, otmr))
583                 return -EFAULT;
584         return ret;
585 }
586
587 SYSCALL_DEFINE2(timerfd_gettime32, int, ufd,
588                 struct old_itimerspec32 __user *, otmr)
589 {
590         struct itimerspec64 kotmr;
591         int ret = do_timerfd_gettime(ufd, &kotmr);
592         if (ret)
593                 return ret;
594         return put_old_itimerspec32(&kotmr, otmr) ? -EFAULT : 0;
595 }
596 #endif