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/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> 17 #include <linux/slab.h> 18 #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> 24 #include <linux/syscalls.h> 25 #include <linux/compat.h> 26 #include <linux/rcupdate.h> 27 28 struct timerfd_ctx { 29 struct hrtimer tmr; 30 ktime_t tintv; 31 ktime_t moffs; 32 wait_queue_head_t wqh; 33 u64 ticks; 34 int expired; 35 int clockid; 36 struct rcu_head rcu; 37 struct list_head clist; 38 bool might_cancel; 39 }; 40 41 static LIST_HEAD(cancel_list); 42 static DEFINE_SPINLOCK(cancel_lock); 43 44 /* 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, 47 * tintv.tv64 != 0) until the timer is accessed. 48 */ 49 static 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 54 spin_lock_irqsave(&ctx->wqh.lock, flags); 55 ctx->expired = 1; 56 ctx->ticks++; 57 wake_up_locked(&ctx->wqh); 58 spin_unlock_irqrestore(&ctx->wqh.lock, flags); 59 60 return HRTIMER_NORESTART; 61 } 62 63 /* 64 * Called when the clock was set to cancel the timers in the cancel 65 * 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(). 68 */ 69 void 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; 82 ctx->ticks++; 83 wake_up_locked(&ctx->wqh); 84 } 85 spin_unlock_irqrestore(&ctx->wqh.lock, flags); 86 } 87 rcu_read_unlock(); 88 } 89 90 static 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 100 static 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 108 static 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 123 static ktime_t timerfd_get_remaining(struct timerfd_ctx *ctx) 124 { 125 ktime_t remaining; 126 127 remaining = hrtimer_expires_remaining(&ctx->tmr); 128 return remaining.tv64 < 0 ? ktime_set(0, 0): remaining; 129 } 130 131 static int timerfd_setup(struct timerfd_ctx *ctx, int flags, 132 const struct itimerspec *ktmr) 133 { 134 enum hrtimer_mode htmode; 135 ktime_t texp; 136 int clockid = ctx->clockid; 137 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; 143 ctx->ticks = 0; 144 ctx->tintv = timespec_to_ktime(ktmr->it_interval); 145 hrtimer_init(&ctx->tmr, clockid, htmode); 146 hrtimer_set_expires(&ctx->tmr, texp); 147 ctx->tmr.function = timerfd_tmrproc; 148 if (texp.tv64 != 0) { 149 hrtimer_start(&ctx->tmr, texp, htmode); 150 if (timerfd_canceled(ctx)) 151 return -ECANCELED; 152 } 153 return 0; 154 } 155 156 static int timerfd_release(struct inode *inode, struct file *file) 157 { 158 struct timerfd_ctx *ctx = file->private_data; 159 160 timerfd_remove_cancel(ctx); 161 hrtimer_cancel(&ctx->tmr); 162 kfree_rcu(ctx, rcu); 163 return 0; 164 } 165 166 static 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 174 spin_lock_irqsave(&ctx->wqh.lock, flags); 175 if (ctx->ticks) 176 events |= POLLIN; 177 spin_unlock_irqrestore(&ctx->wqh.lock, flags); 178 179 return events; 180 } 181 182 static 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; 187 u64 ticks = 0; 188 189 if (count < sizeof(ticks)) 190 return -EINVAL; 191 spin_lock_irq(&ctx->wqh.lock); 192 if (file->f_flags & O_NONBLOCK) 193 res = -EAGAIN; 194 else 195 res = wait_event_interruptible_locked_irq(ctx->wqh, ctx->ticks); 196 197 /* 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 208 if (ctx->ticks) { 209 ticks = ctx->ticks; 210 211 if (ctx->expired && ctx->tintv.tv64) { 212 /* 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 */ 218 ticks += hrtimer_forward_now(&ctx->tmr, 219 ctx->tintv) - 1; 220 hrtimer_restart(&ctx->tmr); 221 } 222 ctx->expired = 0; 223 ctx->ticks = 0; 224 } 225 spin_unlock_irq(&ctx->wqh.lock); 226 if (ticks) 227 res = put_user(ticks, (u64 __user *) buf) ? -EFAULT: sizeof(ticks); 228 return res; 229 } 230 231 static const struct file_operations timerfd_fops = { 232 .release = timerfd_release, 233 .poll = timerfd_poll, 234 .read = timerfd_read, 235 .llseek = noop_llseek, 236 }; 237 238 static int timerfd_fget(int fd, struct fd *p) 239 { 240 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; 246 } 247 *p = f; 248 return 0; 249 } 250 251 SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags) 252 { 253 int ufd; 254 struct timerfd_ctx *ctx; 255 256 /* Check the TFD_* constants for consistency. */ 257 BUILD_BUG_ON(TFD_CLOEXEC != O_CLOEXEC); 258 BUILD_BUG_ON(TFD_NONBLOCK != O_NONBLOCK); 259 260 if ((flags & ~TFD_CREATE_FLAGS) || 261 (clockid != CLOCK_MONOTONIC && 262 clockid != CLOCK_REALTIME)) 263 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); 272 ctx->moffs = ktime_get_monotonic_offset(); 273 274 ufd = anon_inode_getfd("[timerfd]", &timerfd_fops, ctx, 275 O_RDWR | (flags & TFD_SHARED_FCNTL_FLAGS)); 276 if (ufd < 0) 277 kfree(ctx); 278 279 return ufd; 280 } 281 282 static int do_timerfd_settime(int ufd, int flags, 283 const struct itimerspec *new, 284 struct itimerspec *old) 285 { 286 struct fd f; 287 struct timerfd_ctx *ctx; 288 int ret; 289 290 if ((flags & ~TFD_SETTIME_FLAGS) || 291 !timespec_valid(&new->it_value) || 292 !timespec_valid(&new->it_interval)) 293 return -EINVAL; 294 295 ret = timerfd_fget(ufd, &f); 296 if (ret) 297 return ret; 298 ctx = f.file->private_data; 299 300 timerfd_setup_cancel(ctx, flags); 301 302 /* 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; 310 spin_unlock_irq(&ctx->wqh.lock); 311 cpu_relax(); 312 } 313 314 /* 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); 322 323 old->it_value = ktime_to_timespec(timerfd_get_remaining(ctx)); 324 old->it_interval = ktime_to_timespec(ctx->tintv); 325 326 /* 327 * Re-program the timer to the new value ... 328 */ 329 ret = timerfd_setup(ctx, flags, new); 330 331 spin_unlock_irq(&ctx->wqh.lock); 332 fdput(f); 333 return ret; 334 } 335 336 static int do_timerfd_gettime(int ufd, struct itimerspec *t) 337 { 338 struct fd f; 339 struct timerfd_ctx *ctx; 340 int ret = timerfd_fget(ufd, &f); 341 if (ret) 342 return ret; 343 ctx = f.file->private_data; 344 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 } 352 t->it_value = ktime_to_timespec(timerfd_get_remaining(ctx)); 353 t->it_interval = ktime_to_timespec(ctx->tintv); 354 spin_unlock_irq(&ctx->wqh.lock); 355 fdput(f); 356 return 0; 357 } 358 359 SYSCALL_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 377 SYSCALL_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; 383 return copy_to_user(otmr, &kotmr, sizeof(kotmr)) ? -EFAULT: 0; 384 } 385 386 #ifdef CONFIG_COMPAT 387 COMPAT_SYSCALL_DEFINE4(timerfd_settime, int, ufd, int, flags, 388 const struct compat_itimerspec __user *, utmr, 389 struct compat_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 404 COMPAT_SYSCALL_DEFINE2(timerfd_gettime, int, ufd, 405 struct compat_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, &kotmr) ? -EFAULT: 0; 412 } 413 #endif 414