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