1 /* 2 * linux/kernel/posix-timers.c 3 * 4 * 5 * 2002-10-15 Posix Clocks & timers 6 * by George Anzinger george@mvista.com 7 * 8 * Copyright (C) 2002 2003 by MontaVista Software. 9 * 10 * 2004-06-01 Fix CLOCK_REALTIME clock/timer TIMER_ABSTIME bug. 11 * Copyright (C) 2004 Boris Hu 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2 of the License, or (at 16 * your option) any later version. 17 * 18 * This program is distributed in the hope that it will be useful, but 19 * WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 * General Public License for more details. 22 23 * You should have received a copy of the GNU General Public License 24 * along with this program; if not, write to the Free Software 25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 26 * 27 * MontaVista Software | 1237 East Arques Avenue | Sunnyvale | CA 94085 | USA 28 */ 29 30 /* These are all the functions necessary to implement 31 * POSIX clocks & timers 32 */ 33 #include <linux/mm.h> 34 #include <linux/interrupt.h> 35 #include <linux/slab.h> 36 #include <linux/time.h> 37 #include <linux/mutex.h> 38 #include <linux/sched/task.h> 39 40 #include <linux/uaccess.h> 41 #include <linux/list.h> 42 #include <linux/init.h> 43 #include <linux/compiler.h> 44 #include <linux/hash.h> 45 #include <linux/posix-clock.h> 46 #include <linux/posix-timers.h> 47 #include <linux/syscalls.h> 48 #include <linux/wait.h> 49 #include <linux/workqueue.h> 50 #include <linux/export.h> 51 #include <linux/hashtable.h> 52 53 #include "timekeeping.h" 54 55 /* 56 * Management arrays for POSIX timers. Timers are now kept in static hash table 57 * with 512 entries. 58 * Timer ids are allocated by local routine, which selects proper hash head by 59 * key, constructed from current->signal address and per signal struct counter. 60 * This keeps timer ids unique per process, but now they can intersect between 61 * processes. 62 */ 63 64 /* 65 * Lets keep our timers in a slab cache :-) 66 */ 67 static struct kmem_cache *posix_timers_cache; 68 69 static DEFINE_HASHTABLE(posix_timers_hashtable, 9); 70 static DEFINE_SPINLOCK(hash_lock); 71 72 /* 73 * we assume that the new SIGEV_THREAD_ID shares no bits with the other 74 * SIGEV values. Here we put out an error if this assumption fails. 75 */ 76 #if SIGEV_THREAD_ID != (SIGEV_THREAD_ID & \ 77 ~(SIGEV_SIGNAL | SIGEV_NONE | SIGEV_THREAD)) 78 #error "SIGEV_THREAD_ID must not share bit with other SIGEV values!" 79 #endif 80 81 /* 82 * parisc wants ENOTSUP instead of EOPNOTSUPP 83 */ 84 #ifndef ENOTSUP 85 # define ENANOSLEEP_NOTSUP EOPNOTSUPP 86 #else 87 # define ENANOSLEEP_NOTSUP ENOTSUP 88 #endif 89 90 /* 91 * The timer ID is turned into a timer address by idr_find(). 92 * Verifying a valid ID consists of: 93 * 94 * a) checking that idr_find() returns other than -1. 95 * b) checking that the timer id matches the one in the timer itself. 96 * c) that the timer owner is in the callers thread group. 97 */ 98 99 /* 100 * CLOCKs: The POSIX standard calls for a couple of clocks and allows us 101 * to implement others. This structure defines the various 102 * clocks. 103 * 104 * RESOLUTION: Clock resolution is used to round up timer and interval 105 * times, NOT to report clock times, which are reported with as 106 * much resolution as the system can muster. In some cases this 107 * resolution may depend on the underlying clock hardware and 108 * may not be quantifiable until run time, and only then is the 109 * necessary code is written. The standard says we should say 110 * something about this issue in the documentation... 111 * 112 * FUNCTIONS: The CLOCKs structure defines possible functions to 113 * handle various clock functions. 114 * 115 * The standard POSIX timer management code assumes the 116 * following: 1.) The k_itimer struct (sched.h) is used for 117 * the timer. 2.) The list, it_lock, it_clock, it_id and 118 * it_pid fields are not modified by timer code. 119 * 120 * Permissions: It is assumed that the clock_settime() function defined 121 * for each clock will take care of permission checks. Some 122 * clocks may be set able by any user (i.e. local process 123 * clocks) others not. Currently the only set able clock we 124 * have is CLOCK_REALTIME and its high res counter part, both of 125 * which we beg off on and pass to do_sys_settimeofday(). 126 */ 127 128 static struct k_clock posix_clocks[MAX_CLOCKS]; 129 130 /* 131 * These ones are defined below. 132 */ 133 static int common_nsleep(const clockid_t, int flags, struct timespec *t, 134 struct timespec __user *rmtp); 135 static int common_timer_create(struct k_itimer *new_timer); 136 static void common_timer_get(struct k_itimer *, struct itimerspec *); 137 static int common_timer_set(struct k_itimer *, int, 138 struct itimerspec *, struct itimerspec *); 139 static int common_timer_del(struct k_itimer *timer); 140 141 static enum hrtimer_restart posix_timer_fn(struct hrtimer *data); 142 143 static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags); 144 145 #define lock_timer(tid, flags) \ 146 ({ struct k_itimer *__timr; \ 147 __cond_lock(&__timr->it_lock, __timr = __lock_timer(tid, flags)); \ 148 __timr; \ 149 }) 150 151 static int hash(struct signal_struct *sig, unsigned int nr) 152 { 153 return hash_32(hash32_ptr(sig) ^ nr, HASH_BITS(posix_timers_hashtable)); 154 } 155 156 static struct k_itimer *__posix_timers_find(struct hlist_head *head, 157 struct signal_struct *sig, 158 timer_t id) 159 { 160 struct k_itimer *timer; 161 162 hlist_for_each_entry_rcu(timer, head, t_hash) { 163 if ((timer->it_signal == sig) && (timer->it_id == id)) 164 return timer; 165 } 166 return NULL; 167 } 168 169 static struct k_itimer *posix_timer_by_id(timer_t id) 170 { 171 struct signal_struct *sig = current->signal; 172 struct hlist_head *head = &posix_timers_hashtable[hash(sig, id)]; 173 174 return __posix_timers_find(head, sig, id); 175 } 176 177 static int posix_timer_add(struct k_itimer *timer) 178 { 179 struct signal_struct *sig = current->signal; 180 int first_free_id = sig->posix_timer_id; 181 struct hlist_head *head; 182 int ret = -ENOENT; 183 184 do { 185 spin_lock(&hash_lock); 186 head = &posix_timers_hashtable[hash(sig, sig->posix_timer_id)]; 187 if (!__posix_timers_find(head, sig, sig->posix_timer_id)) { 188 hlist_add_head_rcu(&timer->t_hash, head); 189 ret = sig->posix_timer_id; 190 } 191 if (++sig->posix_timer_id < 0) 192 sig->posix_timer_id = 0; 193 if ((sig->posix_timer_id == first_free_id) && (ret == -ENOENT)) 194 /* Loop over all possible ids completed */ 195 ret = -EAGAIN; 196 spin_unlock(&hash_lock); 197 } while (ret == -ENOENT); 198 return ret; 199 } 200 201 static inline void unlock_timer(struct k_itimer *timr, unsigned long flags) 202 { 203 spin_unlock_irqrestore(&timr->it_lock, flags); 204 } 205 206 /* Get clock_realtime */ 207 static int posix_clock_realtime_get(clockid_t which_clock, struct timespec *tp) 208 { 209 ktime_get_real_ts(tp); 210 return 0; 211 } 212 213 /* Set clock_realtime */ 214 static int posix_clock_realtime_set(const clockid_t which_clock, 215 const struct timespec *tp) 216 { 217 return do_sys_settimeofday(tp, NULL); 218 } 219 220 static int posix_clock_realtime_adj(const clockid_t which_clock, 221 struct timex *t) 222 { 223 return do_adjtimex(t); 224 } 225 226 /* 227 * Get monotonic time for posix timers 228 */ 229 static int posix_ktime_get_ts(clockid_t which_clock, struct timespec *tp) 230 { 231 ktime_get_ts(tp); 232 return 0; 233 } 234 235 /* 236 * Get monotonic-raw time for posix timers 237 */ 238 static int posix_get_monotonic_raw(clockid_t which_clock, struct timespec *tp) 239 { 240 getrawmonotonic(tp); 241 return 0; 242 } 243 244 245 static int posix_get_realtime_coarse(clockid_t which_clock, struct timespec *tp) 246 { 247 *tp = current_kernel_time(); 248 return 0; 249 } 250 251 static int posix_get_monotonic_coarse(clockid_t which_clock, 252 struct timespec *tp) 253 { 254 *tp = get_monotonic_coarse(); 255 return 0; 256 } 257 258 static int posix_get_coarse_res(const clockid_t which_clock, struct timespec *tp) 259 { 260 *tp = ktime_to_timespec(KTIME_LOW_RES); 261 return 0; 262 } 263 264 static int posix_get_boottime(const clockid_t which_clock, struct timespec *tp) 265 { 266 get_monotonic_boottime(tp); 267 return 0; 268 } 269 270 static int posix_get_tai(clockid_t which_clock, struct timespec *tp) 271 { 272 timekeeping_clocktai(tp); 273 return 0; 274 } 275 276 static int posix_get_hrtimer_res(clockid_t which_clock, struct timespec *tp) 277 { 278 tp->tv_sec = 0; 279 tp->tv_nsec = hrtimer_resolution; 280 return 0; 281 } 282 283 /* 284 * Initialize everything, well, just everything in Posix clocks/timers ;) 285 */ 286 static __init int init_posix_timers(void) 287 { 288 struct k_clock clock_realtime = { 289 .clock_getres = posix_get_hrtimer_res, 290 .clock_get = posix_clock_realtime_get, 291 .clock_set = posix_clock_realtime_set, 292 .clock_adj = posix_clock_realtime_adj, 293 .nsleep = common_nsleep, 294 .nsleep_restart = hrtimer_nanosleep_restart, 295 .timer_create = common_timer_create, 296 .timer_set = common_timer_set, 297 .timer_get = common_timer_get, 298 .timer_del = common_timer_del, 299 }; 300 struct k_clock clock_monotonic = { 301 .clock_getres = posix_get_hrtimer_res, 302 .clock_get = posix_ktime_get_ts, 303 .nsleep = common_nsleep, 304 .nsleep_restart = hrtimer_nanosleep_restart, 305 .timer_create = common_timer_create, 306 .timer_set = common_timer_set, 307 .timer_get = common_timer_get, 308 .timer_del = common_timer_del, 309 }; 310 struct k_clock clock_monotonic_raw = { 311 .clock_getres = posix_get_hrtimer_res, 312 .clock_get = posix_get_monotonic_raw, 313 }; 314 struct k_clock clock_realtime_coarse = { 315 .clock_getres = posix_get_coarse_res, 316 .clock_get = posix_get_realtime_coarse, 317 }; 318 struct k_clock clock_monotonic_coarse = { 319 .clock_getres = posix_get_coarse_res, 320 .clock_get = posix_get_monotonic_coarse, 321 }; 322 struct k_clock clock_tai = { 323 .clock_getres = posix_get_hrtimer_res, 324 .clock_get = posix_get_tai, 325 .nsleep = common_nsleep, 326 .nsleep_restart = hrtimer_nanosleep_restart, 327 .timer_create = common_timer_create, 328 .timer_set = common_timer_set, 329 .timer_get = common_timer_get, 330 .timer_del = common_timer_del, 331 }; 332 struct k_clock clock_boottime = { 333 .clock_getres = posix_get_hrtimer_res, 334 .clock_get = posix_get_boottime, 335 .nsleep = common_nsleep, 336 .nsleep_restart = hrtimer_nanosleep_restart, 337 .timer_create = common_timer_create, 338 .timer_set = common_timer_set, 339 .timer_get = common_timer_get, 340 .timer_del = common_timer_del, 341 }; 342 343 posix_timers_register_clock(CLOCK_REALTIME, &clock_realtime); 344 posix_timers_register_clock(CLOCK_MONOTONIC, &clock_monotonic); 345 posix_timers_register_clock(CLOCK_MONOTONIC_RAW, &clock_monotonic_raw); 346 posix_timers_register_clock(CLOCK_REALTIME_COARSE, &clock_realtime_coarse); 347 posix_timers_register_clock(CLOCK_MONOTONIC_COARSE, &clock_monotonic_coarse); 348 posix_timers_register_clock(CLOCK_BOOTTIME, &clock_boottime); 349 posix_timers_register_clock(CLOCK_TAI, &clock_tai); 350 351 posix_timers_cache = kmem_cache_create("posix_timers_cache", 352 sizeof (struct k_itimer), 0, SLAB_PANIC, 353 NULL); 354 return 0; 355 } 356 357 __initcall(init_posix_timers); 358 359 static void schedule_next_timer(struct k_itimer *timr) 360 { 361 struct hrtimer *timer = &timr->it.real.timer; 362 363 if (timr->it.real.interval == 0) 364 return; 365 366 timr->it_overrun += (unsigned int) hrtimer_forward(timer, 367 timer->base->get_time(), 368 timr->it.real.interval); 369 370 timr->it_overrun_last = timr->it_overrun; 371 timr->it_overrun = -1; 372 ++timr->it_requeue_pending; 373 hrtimer_restart(timer); 374 } 375 376 /* 377 * This function is exported for use by the signal deliver code. It is 378 * called just prior to the info block being released and passes that 379 * block to us. It's function is to update the overrun entry AND to 380 * restart the timer. It should only be called if the timer is to be 381 * restarted (i.e. we have flagged this in the sys_private entry of the 382 * info block). 383 * 384 * To protect against the timer going away while the interrupt is queued, 385 * we require that the it_requeue_pending flag be set. 386 */ 387 void do_schedule_next_timer(struct siginfo *info) 388 { 389 struct k_itimer *timr; 390 unsigned long flags; 391 392 timr = lock_timer(info->si_tid, &flags); 393 394 if (timr && timr->it_requeue_pending == info->si_sys_private) { 395 if (timr->it_clock < 0) 396 posix_cpu_timer_schedule(timr); 397 else 398 schedule_next_timer(timr); 399 400 info->si_overrun += timr->it_overrun_last; 401 } 402 403 if (timr) 404 unlock_timer(timr, flags); 405 } 406 407 int posix_timer_event(struct k_itimer *timr, int si_private) 408 { 409 struct task_struct *task; 410 int shared, ret = -1; 411 /* 412 * FIXME: if ->sigq is queued we can race with 413 * dequeue_signal()->do_schedule_next_timer(). 414 * 415 * If dequeue_signal() sees the "right" value of 416 * si_sys_private it calls do_schedule_next_timer(). 417 * We re-queue ->sigq and drop ->it_lock(). 418 * do_schedule_next_timer() locks the timer 419 * and re-schedules it while ->sigq is pending. 420 * Not really bad, but not that we want. 421 */ 422 timr->sigq->info.si_sys_private = si_private; 423 424 rcu_read_lock(); 425 task = pid_task(timr->it_pid, PIDTYPE_PID); 426 if (task) { 427 shared = !(timr->it_sigev_notify & SIGEV_THREAD_ID); 428 ret = send_sigqueue(timr->sigq, task, shared); 429 } 430 rcu_read_unlock(); 431 /* If we failed to send the signal the timer stops. */ 432 return ret > 0; 433 } 434 EXPORT_SYMBOL_GPL(posix_timer_event); 435 436 /* 437 * This function gets called when a POSIX.1b interval timer expires. It 438 * is used as a callback from the kernel internal timer. The 439 * run_timer_list code ALWAYS calls with interrupts on. 440 441 * This code is for CLOCK_REALTIME* and CLOCK_MONOTONIC* timers. 442 */ 443 static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer) 444 { 445 struct k_itimer *timr; 446 unsigned long flags; 447 int si_private = 0; 448 enum hrtimer_restart ret = HRTIMER_NORESTART; 449 450 timr = container_of(timer, struct k_itimer, it.real.timer); 451 spin_lock_irqsave(&timr->it_lock, flags); 452 453 if (timr->it.real.interval != 0) 454 si_private = ++timr->it_requeue_pending; 455 456 if (posix_timer_event(timr, si_private)) { 457 /* 458 * signal was not sent because of sig_ignor 459 * we will not get a call back to restart it AND 460 * it should be restarted. 461 */ 462 if (timr->it.real.interval != 0) { 463 ktime_t now = hrtimer_cb_get_time(timer); 464 465 /* 466 * FIXME: What we really want, is to stop this 467 * timer completely and restart it in case the 468 * SIG_IGN is removed. This is a non trivial 469 * change which involves sighand locking 470 * (sigh !), which we don't want to do late in 471 * the release cycle. 472 * 473 * For now we just let timers with an interval 474 * less than a jiffie expire every jiffie to 475 * avoid softirq starvation in case of SIG_IGN 476 * and a very small interval, which would put 477 * the timer right back on the softirq pending 478 * list. By moving now ahead of time we trick 479 * hrtimer_forward() to expire the timer 480 * later, while we still maintain the overrun 481 * accuracy, but have some inconsistency in 482 * the timer_gettime() case. This is at least 483 * better than a starved softirq. A more 484 * complex fix which solves also another related 485 * inconsistency is already in the pipeline. 486 */ 487 #ifdef CONFIG_HIGH_RES_TIMERS 488 { 489 ktime_t kj = NSEC_PER_SEC / HZ; 490 491 if (timr->it.real.interval < kj) 492 now = ktime_add(now, kj); 493 } 494 #endif 495 timr->it_overrun += (unsigned int) 496 hrtimer_forward(timer, now, 497 timr->it.real.interval); 498 ret = HRTIMER_RESTART; 499 ++timr->it_requeue_pending; 500 } 501 } 502 503 unlock_timer(timr, flags); 504 return ret; 505 } 506 507 static struct pid *good_sigevent(sigevent_t * event) 508 { 509 struct task_struct *rtn = current->group_leader; 510 511 if ((event->sigev_notify & SIGEV_THREAD_ID ) && 512 (!(rtn = find_task_by_vpid(event->sigev_notify_thread_id)) || 513 !same_thread_group(rtn, current) || 514 (event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_SIGNAL)) 515 return NULL; 516 517 if (((event->sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) && 518 ((event->sigev_signo <= 0) || (event->sigev_signo > SIGRTMAX))) 519 return NULL; 520 521 return task_pid(rtn); 522 } 523 524 void posix_timers_register_clock(const clockid_t clock_id, 525 struct k_clock *new_clock) 526 { 527 if ((unsigned) clock_id >= MAX_CLOCKS) { 528 printk(KERN_WARNING "POSIX clock register failed for clock_id %d\n", 529 clock_id); 530 return; 531 } 532 533 if (!new_clock->clock_get) { 534 printk(KERN_WARNING "POSIX clock id %d lacks clock_get()\n", 535 clock_id); 536 return; 537 } 538 if (!new_clock->clock_getres) { 539 printk(KERN_WARNING "POSIX clock id %d lacks clock_getres()\n", 540 clock_id); 541 return; 542 } 543 544 posix_clocks[clock_id] = *new_clock; 545 } 546 EXPORT_SYMBOL_GPL(posix_timers_register_clock); 547 548 static struct k_itimer * alloc_posix_timer(void) 549 { 550 struct k_itimer *tmr; 551 tmr = kmem_cache_zalloc(posix_timers_cache, GFP_KERNEL); 552 if (!tmr) 553 return tmr; 554 if (unlikely(!(tmr->sigq = sigqueue_alloc()))) { 555 kmem_cache_free(posix_timers_cache, tmr); 556 return NULL; 557 } 558 memset(&tmr->sigq->info, 0, sizeof(siginfo_t)); 559 return tmr; 560 } 561 562 static void k_itimer_rcu_free(struct rcu_head *head) 563 { 564 struct k_itimer *tmr = container_of(head, struct k_itimer, it.rcu); 565 566 kmem_cache_free(posix_timers_cache, tmr); 567 } 568 569 #define IT_ID_SET 1 570 #define IT_ID_NOT_SET 0 571 static void release_posix_timer(struct k_itimer *tmr, int it_id_set) 572 { 573 if (it_id_set) { 574 unsigned long flags; 575 spin_lock_irqsave(&hash_lock, flags); 576 hlist_del_rcu(&tmr->t_hash); 577 spin_unlock_irqrestore(&hash_lock, flags); 578 } 579 put_pid(tmr->it_pid); 580 sigqueue_free(tmr->sigq); 581 call_rcu(&tmr->it.rcu, k_itimer_rcu_free); 582 } 583 584 static struct k_clock *clockid_to_kclock(const clockid_t id) 585 { 586 if (id < 0) 587 return (id & CLOCKFD_MASK) == CLOCKFD ? 588 &clock_posix_dynamic : &clock_posix_cpu; 589 590 if (id >= MAX_CLOCKS || !posix_clocks[id].clock_getres) 591 return NULL; 592 return &posix_clocks[id]; 593 } 594 595 static int common_timer_create(struct k_itimer *new_timer) 596 { 597 hrtimer_init(&new_timer->it.real.timer, new_timer->it_clock, 0); 598 return 0; 599 } 600 601 /* Create a POSIX.1b interval timer. */ 602 603 SYSCALL_DEFINE3(timer_create, const clockid_t, which_clock, 604 struct sigevent __user *, timer_event_spec, 605 timer_t __user *, created_timer_id) 606 { 607 struct k_clock *kc = clockid_to_kclock(which_clock); 608 struct k_itimer *new_timer; 609 int error, new_timer_id; 610 sigevent_t event; 611 int it_id_set = IT_ID_NOT_SET; 612 613 if (!kc) 614 return -EINVAL; 615 if (!kc->timer_create) 616 return -EOPNOTSUPP; 617 618 new_timer = alloc_posix_timer(); 619 if (unlikely(!new_timer)) 620 return -EAGAIN; 621 622 spin_lock_init(&new_timer->it_lock); 623 new_timer_id = posix_timer_add(new_timer); 624 if (new_timer_id < 0) { 625 error = new_timer_id; 626 goto out; 627 } 628 629 it_id_set = IT_ID_SET; 630 new_timer->it_id = (timer_t) new_timer_id; 631 new_timer->it_clock = which_clock; 632 new_timer->it_overrun = -1; 633 634 if (timer_event_spec) { 635 if (copy_from_user(&event, timer_event_spec, sizeof (event))) { 636 error = -EFAULT; 637 goto out; 638 } 639 rcu_read_lock(); 640 new_timer->it_pid = get_pid(good_sigevent(&event)); 641 rcu_read_unlock(); 642 if (!new_timer->it_pid) { 643 error = -EINVAL; 644 goto out; 645 } 646 } else { 647 memset(&event.sigev_value, 0, sizeof(event.sigev_value)); 648 event.sigev_notify = SIGEV_SIGNAL; 649 event.sigev_signo = SIGALRM; 650 event.sigev_value.sival_int = new_timer->it_id; 651 new_timer->it_pid = get_pid(task_tgid(current)); 652 } 653 654 new_timer->it_sigev_notify = event.sigev_notify; 655 new_timer->sigq->info.si_signo = event.sigev_signo; 656 new_timer->sigq->info.si_value = event.sigev_value; 657 new_timer->sigq->info.si_tid = new_timer->it_id; 658 new_timer->sigq->info.si_code = SI_TIMER; 659 660 if (copy_to_user(created_timer_id, 661 &new_timer_id, sizeof (new_timer_id))) { 662 error = -EFAULT; 663 goto out; 664 } 665 666 error = kc->timer_create(new_timer); 667 if (error) 668 goto out; 669 670 spin_lock_irq(¤t->sighand->siglock); 671 new_timer->it_signal = current->signal; 672 list_add(&new_timer->list, ¤t->signal->posix_timers); 673 spin_unlock_irq(¤t->sighand->siglock); 674 675 return 0; 676 /* 677 * In the case of the timer belonging to another task, after 678 * the task is unlocked, the timer is owned by the other task 679 * and may cease to exist at any time. Don't use or modify 680 * new_timer after the unlock call. 681 */ 682 out: 683 release_posix_timer(new_timer, it_id_set); 684 return error; 685 } 686 687 /* 688 * Locking issues: We need to protect the result of the id look up until 689 * we get the timer locked down so it is not deleted under us. The 690 * removal is done under the idr spinlock so we use that here to bridge 691 * the find to the timer lock. To avoid a dead lock, the timer id MUST 692 * be release with out holding the timer lock. 693 */ 694 static struct k_itimer *__lock_timer(timer_t timer_id, unsigned long *flags) 695 { 696 struct k_itimer *timr; 697 698 /* 699 * timer_t could be any type >= int and we want to make sure any 700 * @timer_id outside positive int range fails lookup. 701 */ 702 if ((unsigned long long)timer_id > INT_MAX) 703 return NULL; 704 705 rcu_read_lock(); 706 timr = posix_timer_by_id(timer_id); 707 if (timr) { 708 spin_lock_irqsave(&timr->it_lock, *flags); 709 if (timr->it_signal == current->signal) { 710 rcu_read_unlock(); 711 return timr; 712 } 713 spin_unlock_irqrestore(&timr->it_lock, *flags); 714 } 715 rcu_read_unlock(); 716 717 return NULL; 718 } 719 720 /* 721 * Get the time remaining on a POSIX.1b interval timer. This function 722 * is ALWAYS called with spin_lock_irq on the timer, thus it must not 723 * mess with irq. 724 * 725 * We have a couple of messes to clean up here. First there is the case 726 * of a timer that has a requeue pending. These timers should appear to 727 * be in the timer list with an expiry as if we were to requeue them 728 * now. 729 * 730 * The second issue is the SIGEV_NONE timer which may be active but is 731 * not really ever put in the timer list (to save system resources). 732 * This timer may be expired, and if so, we will do it here. Otherwise 733 * it is the same as a requeue pending timer WRT to what we should 734 * report. 735 */ 736 static void 737 common_timer_get(struct k_itimer *timr, struct itimerspec *cur_setting) 738 { 739 ktime_t now, remaining, iv; 740 struct hrtimer *timer = &timr->it.real.timer; 741 742 memset(cur_setting, 0, sizeof(struct itimerspec)); 743 744 iv = timr->it.real.interval; 745 746 /* interval timer ? */ 747 if (iv) 748 cur_setting->it_interval = ktime_to_timespec(iv); 749 else if (!hrtimer_active(timer) && 750 (timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) 751 return; 752 753 now = timer->base->get_time(); 754 755 /* 756 * When a requeue is pending or this is a SIGEV_NONE 757 * timer move the expiry time forward by intervals, so 758 * expiry is > now. 759 */ 760 if (iv && (timr->it_requeue_pending & REQUEUE_PENDING || 761 (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) 762 timr->it_overrun += (unsigned int) hrtimer_forward(timer, now, iv); 763 764 remaining = __hrtimer_expires_remaining_adjusted(timer, now); 765 /* Return 0 only, when the timer is expired and not pending */ 766 if (remaining <= 0) { 767 /* 768 * A single shot SIGEV_NONE timer must return 0, when 769 * it is expired ! 770 */ 771 if ((timr->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE) 772 cur_setting->it_value.tv_nsec = 1; 773 } else 774 cur_setting->it_value = ktime_to_timespec(remaining); 775 } 776 777 /* Get the time remaining on a POSIX.1b interval timer. */ 778 SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id, 779 struct itimerspec __user *, setting) 780 { 781 struct itimerspec cur_setting; 782 struct k_itimer *timr; 783 struct k_clock *kc; 784 unsigned long flags; 785 int ret = 0; 786 787 timr = lock_timer(timer_id, &flags); 788 if (!timr) 789 return -EINVAL; 790 791 kc = clockid_to_kclock(timr->it_clock); 792 if (WARN_ON_ONCE(!kc || !kc->timer_get)) 793 ret = -EINVAL; 794 else 795 kc->timer_get(timr, &cur_setting); 796 797 unlock_timer(timr, flags); 798 799 if (!ret && copy_to_user(setting, &cur_setting, sizeof (cur_setting))) 800 return -EFAULT; 801 802 return ret; 803 } 804 805 /* 806 * Get the number of overruns of a POSIX.1b interval timer. This is to 807 * be the overrun of the timer last delivered. At the same time we are 808 * accumulating overruns on the next timer. The overrun is frozen when 809 * the signal is delivered, either at the notify time (if the info block 810 * is not queued) or at the actual delivery time (as we are informed by 811 * the call back to do_schedule_next_timer(). So all we need to do is 812 * to pick up the frozen overrun. 813 */ 814 SYSCALL_DEFINE1(timer_getoverrun, timer_t, timer_id) 815 { 816 struct k_itimer *timr; 817 int overrun; 818 unsigned long flags; 819 820 timr = lock_timer(timer_id, &flags); 821 if (!timr) 822 return -EINVAL; 823 824 overrun = timr->it_overrun_last; 825 unlock_timer(timr, flags); 826 827 return overrun; 828 } 829 830 /* Set a POSIX.1b interval timer. */ 831 /* timr->it_lock is taken. */ 832 static int 833 common_timer_set(struct k_itimer *timr, int flags, 834 struct itimerspec *new_setting, struct itimerspec *old_setting) 835 { 836 struct hrtimer *timer = &timr->it.real.timer; 837 enum hrtimer_mode mode; 838 839 if (old_setting) 840 common_timer_get(timr, old_setting); 841 842 /* disable the timer */ 843 timr->it.real.interval = 0; 844 /* 845 * careful here. If smp we could be in the "fire" routine which will 846 * be spinning as we hold the lock. But this is ONLY an SMP issue. 847 */ 848 if (hrtimer_try_to_cancel(timer) < 0) 849 return TIMER_RETRY; 850 851 timr->it_requeue_pending = (timr->it_requeue_pending + 2) & 852 ~REQUEUE_PENDING; 853 timr->it_overrun_last = 0; 854 855 /* switch off the timer when it_value is zero */ 856 if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec) 857 return 0; 858 859 mode = flags & TIMER_ABSTIME ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL; 860 hrtimer_init(&timr->it.real.timer, timr->it_clock, mode); 861 timr->it.real.timer.function = posix_timer_fn; 862 863 hrtimer_set_expires(timer, timespec_to_ktime(new_setting->it_value)); 864 865 /* Convert interval */ 866 timr->it.real.interval = timespec_to_ktime(new_setting->it_interval); 867 868 /* SIGEV_NONE timers are not queued ! See common_timer_get */ 869 if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) { 870 /* Setup correct expiry time for relative timers */ 871 if (mode == HRTIMER_MODE_REL) { 872 hrtimer_add_expires(timer, timer->base->get_time()); 873 } 874 return 0; 875 } 876 877 hrtimer_start_expires(timer, mode); 878 return 0; 879 } 880 881 /* Set a POSIX.1b interval timer */ 882 SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags, 883 const struct itimerspec __user *, new_setting, 884 struct itimerspec __user *, old_setting) 885 { 886 struct k_itimer *timr; 887 struct itimerspec new_spec, old_spec; 888 int error = 0; 889 unsigned long flag; 890 struct itimerspec *rtn = old_setting ? &old_spec : NULL; 891 struct k_clock *kc; 892 893 if (!new_setting) 894 return -EINVAL; 895 896 if (copy_from_user(&new_spec, new_setting, sizeof (new_spec))) 897 return -EFAULT; 898 899 if (!timespec_valid(&new_spec.it_interval) || 900 !timespec_valid(&new_spec.it_value)) 901 return -EINVAL; 902 retry: 903 timr = lock_timer(timer_id, &flag); 904 if (!timr) 905 return -EINVAL; 906 907 kc = clockid_to_kclock(timr->it_clock); 908 if (WARN_ON_ONCE(!kc || !kc->timer_set)) 909 error = -EINVAL; 910 else 911 error = kc->timer_set(timr, flags, &new_spec, rtn); 912 913 unlock_timer(timr, flag); 914 if (error == TIMER_RETRY) { 915 rtn = NULL; // We already got the old time... 916 goto retry; 917 } 918 919 if (old_setting && !error && 920 copy_to_user(old_setting, &old_spec, sizeof (old_spec))) 921 error = -EFAULT; 922 923 return error; 924 } 925 926 static int common_timer_del(struct k_itimer *timer) 927 { 928 timer->it.real.interval = 0; 929 930 if (hrtimer_try_to_cancel(&timer->it.real.timer) < 0) 931 return TIMER_RETRY; 932 return 0; 933 } 934 935 static inline int timer_delete_hook(struct k_itimer *timer) 936 { 937 struct k_clock *kc = clockid_to_kclock(timer->it_clock); 938 939 if (WARN_ON_ONCE(!kc || !kc->timer_del)) 940 return -EINVAL; 941 return kc->timer_del(timer); 942 } 943 944 /* Delete a POSIX.1b interval timer. */ 945 SYSCALL_DEFINE1(timer_delete, timer_t, timer_id) 946 { 947 struct k_itimer *timer; 948 unsigned long flags; 949 950 retry_delete: 951 timer = lock_timer(timer_id, &flags); 952 if (!timer) 953 return -EINVAL; 954 955 if (timer_delete_hook(timer) == TIMER_RETRY) { 956 unlock_timer(timer, flags); 957 goto retry_delete; 958 } 959 960 spin_lock(¤t->sighand->siglock); 961 list_del(&timer->list); 962 spin_unlock(¤t->sighand->siglock); 963 /* 964 * This keeps any tasks waiting on the spin lock from thinking 965 * they got something (see the lock code above). 966 */ 967 timer->it_signal = NULL; 968 969 unlock_timer(timer, flags); 970 release_posix_timer(timer, IT_ID_SET); 971 return 0; 972 } 973 974 /* 975 * return timer owned by the process, used by exit_itimers 976 */ 977 static void itimer_delete(struct k_itimer *timer) 978 { 979 unsigned long flags; 980 981 retry_delete: 982 spin_lock_irqsave(&timer->it_lock, flags); 983 984 if (timer_delete_hook(timer) == TIMER_RETRY) { 985 unlock_timer(timer, flags); 986 goto retry_delete; 987 } 988 list_del(&timer->list); 989 /* 990 * This keeps any tasks waiting on the spin lock from thinking 991 * they got something (see the lock code above). 992 */ 993 timer->it_signal = NULL; 994 995 unlock_timer(timer, flags); 996 release_posix_timer(timer, IT_ID_SET); 997 } 998 999 /* 1000 * This is called by do_exit or de_thread, only when there are no more 1001 * references to the shared signal_struct. 1002 */ 1003 void exit_itimers(struct signal_struct *sig) 1004 { 1005 struct k_itimer *tmr; 1006 1007 while (!list_empty(&sig->posix_timers)) { 1008 tmr = list_entry(sig->posix_timers.next, struct k_itimer, list); 1009 itimer_delete(tmr); 1010 } 1011 } 1012 1013 SYSCALL_DEFINE2(clock_settime, const clockid_t, which_clock, 1014 const struct timespec __user *, tp) 1015 { 1016 struct k_clock *kc = clockid_to_kclock(which_clock); 1017 struct timespec new_tp; 1018 1019 if (!kc || !kc->clock_set) 1020 return -EINVAL; 1021 1022 if (copy_from_user(&new_tp, tp, sizeof (*tp))) 1023 return -EFAULT; 1024 1025 return kc->clock_set(which_clock, &new_tp); 1026 } 1027 1028 SYSCALL_DEFINE2(clock_gettime, const clockid_t, which_clock, 1029 struct timespec __user *,tp) 1030 { 1031 struct k_clock *kc = clockid_to_kclock(which_clock); 1032 struct timespec kernel_tp; 1033 int error; 1034 1035 if (!kc) 1036 return -EINVAL; 1037 1038 error = kc->clock_get(which_clock, &kernel_tp); 1039 1040 if (!error && copy_to_user(tp, &kernel_tp, sizeof (kernel_tp))) 1041 error = -EFAULT; 1042 1043 return error; 1044 } 1045 1046 SYSCALL_DEFINE2(clock_adjtime, const clockid_t, which_clock, 1047 struct timex __user *, utx) 1048 { 1049 struct k_clock *kc = clockid_to_kclock(which_clock); 1050 struct timex ktx; 1051 int err; 1052 1053 if (!kc) 1054 return -EINVAL; 1055 if (!kc->clock_adj) 1056 return -EOPNOTSUPP; 1057 1058 if (copy_from_user(&ktx, utx, sizeof(ktx))) 1059 return -EFAULT; 1060 1061 err = kc->clock_adj(which_clock, &ktx); 1062 1063 if (err >= 0 && copy_to_user(utx, &ktx, sizeof(ktx))) 1064 return -EFAULT; 1065 1066 return err; 1067 } 1068 1069 SYSCALL_DEFINE2(clock_getres, const clockid_t, which_clock, 1070 struct timespec __user *, tp) 1071 { 1072 struct k_clock *kc = clockid_to_kclock(which_clock); 1073 struct timespec rtn_tp; 1074 int error; 1075 1076 if (!kc) 1077 return -EINVAL; 1078 1079 error = kc->clock_getres(which_clock, &rtn_tp); 1080 1081 if (!error && tp && copy_to_user(tp, &rtn_tp, sizeof (rtn_tp))) 1082 error = -EFAULT; 1083 1084 return error; 1085 } 1086 1087 /* 1088 * nanosleep for monotonic and realtime clocks 1089 */ 1090 static int common_nsleep(const clockid_t which_clock, int flags, 1091 struct timespec *tsave, struct timespec __user *rmtp) 1092 { 1093 return hrtimer_nanosleep(tsave, rmtp, flags & TIMER_ABSTIME ? 1094 HRTIMER_MODE_ABS : HRTIMER_MODE_REL, 1095 which_clock); 1096 } 1097 1098 SYSCALL_DEFINE4(clock_nanosleep, const clockid_t, which_clock, int, flags, 1099 const struct timespec __user *, rqtp, 1100 struct timespec __user *, rmtp) 1101 { 1102 struct k_clock *kc = clockid_to_kclock(which_clock); 1103 struct timespec t; 1104 1105 if (!kc) 1106 return -EINVAL; 1107 if (!kc->nsleep) 1108 return -ENANOSLEEP_NOTSUP; 1109 1110 if (copy_from_user(&t, rqtp, sizeof (struct timespec))) 1111 return -EFAULT; 1112 1113 if (!timespec_valid(&t)) 1114 return -EINVAL; 1115 1116 return kc->nsleep(which_clock, flags, &t, rmtp); 1117 } 1118 1119 /* 1120 * This will restart clock_nanosleep. This is required only by 1121 * compat_clock_nanosleep_restart for now. 1122 */ 1123 long clock_nanosleep_restart(struct restart_block *restart_block) 1124 { 1125 clockid_t which_clock = restart_block->nanosleep.clockid; 1126 struct k_clock *kc = clockid_to_kclock(which_clock); 1127 1128 if (WARN_ON_ONCE(!kc || !kc->nsleep_restart)) 1129 return -EINVAL; 1130 1131 return kc->nsleep_restart(restart_block); 1132 } 1133