1 /* 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/alarmtimer.h> 12 #include <linux/file.h> 13 #include <linux/poll.h> 14 #include <linux/init.h> 15 #include <linux/fs.h> 16 #include <linux/sched.h> 17 #include <linux/kernel.h> 18 #include <linux/slab.h> 19 #include <linux/list.h> 20 #include <linux/spinlock.h> 21 #include <linux/time.h> 22 #include <linux/hrtimer.h> 23 #include <linux/anon_inodes.h> 24 #include <linux/timerfd.h> 25 #include <linux/syscalls.h> 26 #include <linux/compat.h> 27 #include <linux/rcupdate.h> 28 29 struct timerfd_ctx { 30 union { 31 struct hrtimer tmr; 32 struct alarm alarm; 33 } t; 34 ktime_t tintv; 35 ktime_t moffs; 36 wait_queue_head_t wqh; 37 u64 ticks; 38 int expired; 39 int clockid; 40 struct rcu_head rcu; 41 struct list_head clist; 42 bool might_cancel; 43 }; 44 45 static LIST_HEAD(cancel_list); 46 static DEFINE_SPINLOCK(cancel_lock); 47 48 static inline bool isalarm(struct timerfd_ctx *ctx) 49 { 50 return ctx->clockid == CLOCK_REALTIME_ALARM || 51 ctx->clockid == CLOCK_BOOTTIME_ALARM; 52 } 53 54 /* 55 * This gets called when the timer event triggers. We set the "expired" 56 * flag, but we do not re-arm the timer (in case it's necessary, 57 * tintv.tv64 != 0) until the timer is accessed. 58 */ 59 static void timerfd_triggered(struct timerfd_ctx *ctx) 60 { 61 unsigned long flags; 62 63 spin_lock_irqsave(&ctx->wqh.lock, flags); 64 ctx->expired = 1; 65 ctx->ticks++; 66 wake_up_locked(&ctx->wqh); 67 spin_unlock_irqrestore(&ctx->wqh.lock, flags); 68 } 69 70 static enum hrtimer_restart timerfd_tmrproc(struct hrtimer *htmr) 71 { 72 struct timerfd_ctx *ctx = container_of(htmr, struct timerfd_ctx, 73 t.tmr); 74 timerfd_triggered(ctx); 75 return HRTIMER_NORESTART; 76 } 77 78 static enum alarmtimer_restart timerfd_alarmproc(struct alarm *alarm, 79 ktime_t now) 80 { 81 struct timerfd_ctx *ctx = container_of(alarm, struct timerfd_ctx, 82 t.alarm); 83 timerfd_triggered(ctx); 84 return ALARMTIMER_NORESTART; 85 } 86 87 /* 88 * Called when the clock was set to cancel the timers in the cancel 89 * list. This will wake up processes waiting on these timers. The 90 * wake-up requires ctx->ticks to be non zero, therefore we increment 91 * it before calling wake_up_locked(). 92 */ 93 void timerfd_clock_was_set(void) 94 { 95 ktime_t moffs = ktime_get_monotonic_offset(); 96 struct timerfd_ctx *ctx; 97 unsigned long flags; 98 99 rcu_read_lock(); 100 list_for_each_entry_rcu(ctx, &cancel_list, clist) { 101 if (!ctx->might_cancel) 102 continue; 103 spin_lock_irqsave(&ctx->wqh.lock, flags); 104 if (ctx->moffs.tv64 != moffs.tv64) { 105 ctx->moffs.tv64 = KTIME_MAX; 106 ctx->ticks++; 107 wake_up_locked(&ctx->wqh); 108 } 109 spin_unlock_irqrestore(&ctx->wqh.lock, flags); 110 } 111 rcu_read_unlock(); 112 } 113 114 static void timerfd_remove_cancel(struct timerfd_ctx *ctx) 115 { 116 if (ctx->might_cancel) { 117 ctx->might_cancel = false; 118 spin_lock(&cancel_lock); 119 list_del_rcu(&ctx->clist); 120 spin_unlock(&cancel_lock); 121 } 122 } 123 124 static bool timerfd_canceled(struct timerfd_ctx *ctx) 125 { 126 if (!ctx->might_cancel || ctx->moffs.tv64 != KTIME_MAX) 127 return false; 128 ctx->moffs = ktime_get_monotonic_offset(); 129 return true; 130 } 131 132 static void timerfd_setup_cancel(struct timerfd_ctx *ctx, int flags) 133 { 134 if ((ctx->clockid == CLOCK_REALTIME || 135 ctx->clockid == CLOCK_REALTIME_ALARM) && 136 (flags & TFD_TIMER_ABSTIME) && (flags & TFD_TIMER_CANCEL_ON_SET)) { 137 if (!ctx->might_cancel) { 138 ctx->might_cancel = true; 139 spin_lock(&cancel_lock); 140 list_add_rcu(&ctx->clist, &cancel_list); 141 spin_unlock(&cancel_lock); 142 } 143 } else if (ctx->might_cancel) { 144 timerfd_remove_cancel(ctx); 145 } 146 } 147 148 static ktime_t timerfd_get_remaining(struct timerfd_ctx *ctx) 149 { 150 ktime_t remaining; 151 152 if (isalarm(ctx)) 153 remaining = alarm_expires_remaining(&ctx->t.alarm); 154 else 155 remaining = hrtimer_expires_remaining(&ctx->t.tmr); 156 157 return remaining.tv64 < 0 ? ktime_set(0, 0): remaining; 158 } 159 160 static int timerfd_setup(struct timerfd_ctx *ctx, int flags, 161 const struct itimerspec *ktmr) 162 { 163 enum hrtimer_mode htmode; 164 ktime_t texp; 165 int clockid = ctx->clockid; 166 167 htmode = (flags & TFD_TIMER_ABSTIME) ? 168 HRTIMER_MODE_ABS: HRTIMER_MODE_REL; 169 170 texp = timespec_to_ktime(ktmr->it_value); 171 ctx->expired = 0; 172 ctx->ticks = 0; 173 ctx->tintv = timespec_to_ktime(ktmr->it_interval); 174 175 if (isalarm(ctx)) { 176 alarm_init(&ctx->t.alarm, 177 ctx->clockid == CLOCK_REALTIME_ALARM ? 178 ALARM_REALTIME : ALARM_BOOTTIME, 179 timerfd_alarmproc); 180 } else { 181 hrtimer_init(&ctx->t.tmr, clockid, htmode); 182 hrtimer_set_expires(&ctx->t.tmr, texp); 183 ctx->t.tmr.function = timerfd_tmrproc; 184 } 185 186 if (texp.tv64 != 0) { 187 if (isalarm(ctx)) { 188 if (flags & TFD_TIMER_ABSTIME) 189 alarm_start(&ctx->t.alarm, texp); 190 else 191 alarm_start_relative(&ctx->t.alarm, texp); 192 } else { 193 hrtimer_start(&ctx->t.tmr, texp, htmode); 194 } 195 196 if (timerfd_canceled(ctx)) 197 return -ECANCELED; 198 } 199 return 0; 200 } 201 202 static int timerfd_release(struct inode *inode, struct file *file) 203 { 204 struct timerfd_ctx *ctx = file->private_data; 205 206 timerfd_remove_cancel(ctx); 207 208 if (isalarm(ctx)) 209 alarm_cancel(&ctx->t.alarm); 210 else 211 hrtimer_cancel(&ctx->t.tmr); 212 kfree_rcu(ctx, rcu); 213 return 0; 214 } 215 216 static unsigned int timerfd_poll(struct file *file, poll_table *wait) 217 { 218 struct timerfd_ctx *ctx = file->private_data; 219 unsigned int events = 0; 220 unsigned long flags; 221 222 poll_wait(file, &ctx->wqh, wait); 223 224 spin_lock_irqsave(&ctx->wqh.lock, flags); 225 if (ctx->ticks) 226 events |= POLLIN; 227 spin_unlock_irqrestore(&ctx->wqh.lock, flags); 228 229 return events; 230 } 231 232 static ssize_t timerfd_read(struct file *file, char __user *buf, size_t count, 233 loff_t *ppos) 234 { 235 struct timerfd_ctx *ctx = file->private_data; 236 ssize_t res; 237 u64 ticks = 0; 238 239 if (count < sizeof(ticks)) 240 return -EINVAL; 241 spin_lock_irq(&ctx->wqh.lock); 242 if (file->f_flags & O_NONBLOCK) 243 res = -EAGAIN; 244 else 245 res = wait_event_interruptible_locked_irq(ctx->wqh, ctx->ticks); 246 247 /* 248 * If clock has changed, we do not care about the 249 * ticks and we do not rearm the timer. Userspace must 250 * reevaluate anyway. 251 */ 252 if (timerfd_canceled(ctx)) { 253 ctx->ticks = 0; 254 ctx->expired = 0; 255 res = -ECANCELED; 256 } 257 258 if (ctx->ticks) { 259 ticks = ctx->ticks; 260 261 if (ctx->expired && ctx->tintv.tv64) { 262 /* 263 * If tintv.tv64 != 0, this is a periodic timer that 264 * needs to be re-armed. We avoid doing it in the timer 265 * callback to avoid DoS attacks specifying a very 266 * short timer period. 267 */ 268 if (isalarm(ctx)) { 269 ticks += alarm_forward_now( 270 &ctx->t.alarm, ctx->tintv) - 1; 271 alarm_restart(&ctx->t.alarm); 272 } else { 273 ticks += hrtimer_forward_now(&ctx->t.tmr, 274 ctx->tintv) - 1; 275 hrtimer_restart(&ctx->t.tmr); 276 } 277 } 278 ctx->expired = 0; 279 ctx->ticks = 0; 280 } 281 spin_unlock_irq(&ctx->wqh.lock); 282 if (ticks) 283 res = put_user(ticks, (u64 __user *) buf) ? -EFAULT: sizeof(ticks); 284 return res; 285 } 286 287 static const struct file_operations timerfd_fops = { 288 .release = timerfd_release, 289 .poll = timerfd_poll, 290 .read = timerfd_read, 291 .llseek = noop_llseek, 292 }; 293 294 static int timerfd_fget(int fd, struct fd *p) 295 { 296 struct fd f = fdget(fd); 297 if (!f.file) 298 return -EBADF; 299 if (f.file->f_op != &timerfd_fops) { 300 fdput(f); 301 return -EINVAL; 302 } 303 *p = f; 304 return 0; 305 } 306 307 SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags) 308 { 309 int ufd; 310 struct timerfd_ctx *ctx; 311 312 /* Check the TFD_* constants for consistency. */ 313 BUILD_BUG_ON(TFD_CLOEXEC != O_CLOEXEC); 314 BUILD_BUG_ON(TFD_NONBLOCK != O_NONBLOCK); 315 316 if ((flags & ~TFD_CREATE_FLAGS) || 317 (clockid != CLOCK_MONOTONIC && 318 clockid != CLOCK_REALTIME && 319 clockid != CLOCK_REALTIME_ALARM && 320 clockid != CLOCK_BOOTTIME_ALARM)) 321 return -EINVAL; 322 323 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 324 if (!ctx) 325 return -ENOMEM; 326 327 init_waitqueue_head(&ctx->wqh); 328 ctx->clockid = clockid; 329 330 if (isalarm(ctx)) 331 alarm_init(&ctx->t.alarm, 332 ctx->clockid == CLOCK_REALTIME_ALARM ? 333 ALARM_REALTIME : ALARM_BOOTTIME, 334 timerfd_alarmproc); 335 else 336 hrtimer_init(&ctx->t.tmr, clockid, HRTIMER_MODE_ABS); 337 338 ctx->moffs = ktime_get_monotonic_offset(); 339 340 ufd = anon_inode_getfd("[timerfd]", &timerfd_fops, ctx, 341 O_RDWR | (flags & TFD_SHARED_FCNTL_FLAGS)); 342 if (ufd < 0) 343 kfree(ctx); 344 345 return ufd; 346 } 347 348 static int do_timerfd_settime(int ufd, int flags, 349 const struct itimerspec *new, 350 struct itimerspec *old) 351 { 352 struct fd f; 353 struct timerfd_ctx *ctx; 354 int ret; 355 356 if ((flags & ~TFD_SETTIME_FLAGS) || 357 !timespec_valid(&new->it_value) || 358 !timespec_valid(&new->it_interval)) 359 return -EINVAL; 360 361 ret = timerfd_fget(ufd, &f); 362 if (ret) 363 return ret; 364 ctx = f.file->private_data; 365 366 timerfd_setup_cancel(ctx, flags); 367 368 /* 369 * We need to stop the existing timer before reprogramming 370 * it to the new values. 371 */ 372 for (;;) { 373 spin_lock_irq(&ctx->wqh.lock); 374 375 if (isalarm(ctx)) { 376 if (alarm_try_to_cancel(&ctx->t.alarm) >= 0) 377 break; 378 } else { 379 if (hrtimer_try_to_cancel(&ctx->t.tmr) >= 0) 380 break; 381 } 382 spin_unlock_irq(&ctx->wqh.lock); 383 cpu_relax(); 384 } 385 386 /* 387 * If the timer is expired and it's periodic, we need to advance it 388 * because the caller may want to know the previous expiration time. 389 * We do not update "ticks" and "expired" since the timer will be 390 * re-programmed again in the following timerfd_setup() call. 391 */ 392 if (ctx->expired && ctx->tintv.tv64) { 393 if (isalarm(ctx)) 394 alarm_forward_now(&ctx->t.alarm, ctx->tintv); 395 else 396 hrtimer_forward_now(&ctx->t.tmr, ctx->tintv); 397 } 398 399 old->it_value = ktime_to_timespec(timerfd_get_remaining(ctx)); 400 old->it_interval = ktime_to_timespec(ctx->tintv); 401 402 /* 403 * Re-program the timer to the new value ... 404 */ 405 ret = timerfd_setup(ctx, flags, new); 406 407 spin_unlock_irq(&ctx->wqh.lock); 408 fdput(f); 409 return ret; 410 } 411 412 static int do_timerfd_gettime(int ufd, struct itimerspec *t) 413 { 414 struct fd f; 415 struct timerfd_ctx *ctx; 416 int ret = timerfd_fget(ufd, &f); 417 if (ret) 418 return ret; 419 ctx = f.file->private_data; 420 421 spin_lock_irq(&ctx->wqh.lock); 422 if (ctx->expired && ctx->tintv.tv64) { 423 ctx->expired = 0; 424 425 if (isalarm(ctx)) { 426 ctx->ticks += 427 alarm_forward_now( 428 &ctx->t.alarm, ctx->tintv) - 1; 429 alarm_restart(&ctx->t.alarm); 430 } else { 431 ctx->ticks += 432 hrtimer_forward_now(&ctx->t.tmr, ctx->tintv) 433 - 1; 434 hrtimer_restart(&ctx->t.tmr); 435 } 436 } 437 t->it_value = ktime_to_timespec(timerfd_get_remaining(ctx)); 438 t->it_interval = ktime_to_timespec(ctx->tintv); 439 spin_unlock_irq(&ctx->wqh.lock); 440 fdput(f); 441 return 0; 442 } 443 444 SYSCALL_DEFINE4(timerfd_settime, int, ufd, int, flags, 445 const struct itimerspec __user *, utmr, 446 struct itimerspec __user *, otmr) 447 { 448 struct itimerspec new, old; 449 int ret; 450 451 if (copy_from_user(&new, utmr, sizeof(new))) 452 return -EFAULT; 453 ret = do_timerfd_settime(ufd, flags, &new, &old); 454 if (ret) 455 return ret; 456 if (otmr && copy_to_user(otmr, &old, sizeof(old))) 457 return -EFAULT; 458 459 return ret; 460 } 461 462 SYSCALL_DEFINE2(timerfd_gettime, int, ufd, struct itimerspec __user *, otmr) 463 { 464 struct itimerspec kotmr; 465 int ret = do_timerfd_gettime(ufd, &kotmr); 466 if (ret) 467 return ret; 468 return copy_to_user(otmr, &kotmr, sizeof(kotmr)) ? -EFAULT: 0; 469 } 470 471 #ifdef CONFIG_COMPAT 472 COMPAT_SYSCALL_DEFINE4(timerfd_settime, int, ufd, int, flags, 473 const struct compat_itimerspec __user *, utmr, 474 struct compat_itimerspec __user *, otmr) 475 { 476 struct itimerspec new, old; 477 int ret; 478 479 if (get_compat_itimerspec(&new, utmr)) 480 return -EFAULT; 481 ret = do_timerfd_settime(ufd, flags, &new, &old); 482 if (ret) 483 return ret; 484 if (otmr && put_compat_itimerspec(otmr, &old)) 485 return -EFAULT; 486 return ret; 487 } 488 489 COMPAT_SYSCALL_DEFINE2(timerfd_gettime, int, ufd, 490 struct compat_itimerspec __user *, otmr) 491 { 492 struct itimerspec kotmr; 493 int ret = do_timerfd_gettime(ufd, &kotmr); 494 if (ret) 495 return ret; 496 return put_compat_itimerspec(otmr, &kotmr) ? -EFAULT: 0; 497 } 498 #endif 499