1 /* $NetBSD: kern_time.c,v 1.221 2023/02/23 02:57:17 riastradh Exp $ */ 2 3 /*- 4 * Copyright (c) 2000, 2004, 2005, 2007, 2008, 2009, 2020 5 * The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Christopher G. Demetriou, by Andrew Doran, and by Jason R. Thorpe. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * Copyright (c) 1982, 1986, 1989, 1993 35 * The Regents of the University of California. All rights reserved. 36 * 37 * Redistribution and use in source and binary forms, with or without 38 * modification, are permitted provided that the following conditions 39 * are met: 40 * 1. Redistributions of source code must retain the above copyright 41 * notice, this list of conditions and the following disclaimer. 42 * 2. Redistributions in binary form must reproduce the above copyright 43 * notice, this list of conditions and the following disclaimer in the 44 * documentation and/or other materials provided with the distribution. 45 * 3. Neither the name of the University nor the names of its contributors 46 * may be used to endorse or promote products derived from this software 47 * without specific prior written permission. 48 * 49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 52 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 59 * SUCH DAMAGE. 60 * 61 * @(#)kern_time.c 8.4 (Berkeley) 5/26/95 62 */ 63 64 #include <sys/cdefs.h> 65 __KERNEL_RCSID(0, "$NetBSD: kern_time.c,v 1.221 2023/02/23 02:57:17 riastradh Exp $"); 66 67 #include <sys/param.h> 68 #include <sys/resourcevar.h> 69 #include <sys/kernel.h> 70 #include <sys/systm.h> 71 #include <sys/proc.h> 72 #include <sys/vnode.h> 73 #include <sys/signalvar.h> 74 #include <sys/syslog.h> 75 #include <sys/timetc.h> 76 #include <sys/timevar.h> 77 #include <sys/timex.h> 78 #include <sys/kauth.h> 79 #include <sys/mount.h> 80 #include <sys/syscallargs.h> 81 #include <sys/cpu.h> 82 83 kmutex_t itimer_mutex __cacheline_aligned; /* XXX static */ 84 static struct itlist itimer_realtime_changed_notify; 85 86 static void itimer_callout(void *); 87 static void ptimer_intr(void *); 88 static void *ptimer_sih __read_mostly; 89 static TAILQ_HEAD(, ptimer) ptimer_queue; 90 91 #define CLOCK_VIRTUAL_P(clockid) \ 92 ((clockid) == CLOCK_VIRTUAL || (clockid) == CLOCK_PROF) 93 94 CTASSERT(ITIMER_REAL == CLOCK_REALTIME); 95 CTASSERT(ITIMER_VIRTUAL == CLOCK_VIRTUAL); 96 CTASSERT(ITIMER_PROF == CLOCK_PROF); 97 CTASSERT(ITIMER_MONOTONIC == CLOCK_MONOTONIC); 98 99 #define DELAYTIMER_MAX 32 100 101 /* 102 * Initialize timekeeping. 103 */ 104 void 105 time_init(void) 106 { 107 108 mutex_init(&itimer_mutex, MUTEX_DEFAULT, IPL_SCHED); 109 LIST_INIT(&itimer_realtime_changed_notify); 110 111 TAILQ_INIT(&ptimer_queue); 112 ptimer_sih = softint_establish(SOFTINT_CLOCK | SOFTINT_MPSAFE, 113 ptimer_intr, NULL); 114 } 115 116 /* 117 * Check if the time will wrap if set to ts. 118 * 119 * ts - timespec describing the new time 120 * delta - the delta between the current time and ts 121 */ 122 bool 123 time_wraps(struct timespec *ts, struct timespec *delta) 124 { 125 126 /* 127 * Don't allow the time to be set forward so far it 128 * will wrap and become negative, thus allowing an 129 * attacker to bypass the next check below. The 130 * cutoff is 1 year before rollover occurs, so even 131 * if the attacker uses adjtime(2) to move the time 132 * past the cutoff, it will take a very long time 133 * to get to the wrap point. 134 */ 135 if ((ts->tv_sec > LLONG_MAX - 365*24*60*60) || 136 (delta->tv_sec < 0 || delta->tv_nsec < 0)) 137 return true; 138 139 return false; 140 } 141 142 /* 143 * itimer_lock: 144 * 145 * Acquire the interval timer data lock. 146 */ 147 void 148 itimer_lock(void) 149 { 150 mutex_spin_enter(&itimer_mutex); 151 } 152 153 /* 154 * itimer_unlock: 155 * 156 * Release the interval timer data lock. 157 */ 158 void 159 itimer_unlock(void) 160 { 161 mutex_spin_exit(&itimer_mutex); 162 } 163 164 /* 165 * itimer_lock_held: 166 * 167 * Check that the interval timer lock is held for diagnostic 168 * assertions. 169 */ 170 inline bool __diagused 171 itimer_lock_held(void) 172 { 173 return mutex_owned(&itimer_mutex); 174 } 175 176 /* 177 * Time of day and interval timer support. 178 * 179 * These routines provide the kernel entry points to get and set 180 * the time-of-day and per-process interval timers. Subroutines 181 * here provide support for adding and subtracting timeval structures 182 * and decrementing interval timers, optionally reloading the interval 183 * timers when they expire. 184 */ 185 186 /* This function is used by clock_settime and settimeofday */ 187 static int 188 settime1(struct proc *p, const struct timespec *ts, bool check_kauth) 189 { 190 struct timespec delta, now; 191 192 /* 193 * The time being set to an unreasonable value will cause 194 * unreasonable system behaviour. 195 */ 196 if (ts->tv_sec < 0 || ts->tv_sec > (1LL << 36)) 197 return EINVAL; 198 199 nanotime(&now); 200 timespecsub(ts, &now, &delta); 201 202 if (check_kauth && kauth_authorize_system(kauth_cred_get(), 203 KAUTH_SYSTEM_TIME, KAUTH_REQ_SYSTEM_TIME_SYSTEM, __UNCONST(ts), 204 &delta, KAUTH_ARG(check_kauth ? false : true)) != 0) { 205 return EPERM; 206 } 207 208 #ifdef notyet 209 if ((delta.tv_sec < 86400) && securelevel > 0) { /* XXX elad - notyet */ 210 return EPERM; 211 } 212 #endif 213 214 tc_setclock(ts); 215 216 resettodr(); 217 218 /* 219 * Notify pending CLOCK_REALTIME timers about the real time change. 220 * There may be inactive timers on this list, but this happens 221 * comparatively less often than timers firing, and so it's better 222 * to put the extra checks here than to complicate the other code 223 * path. 224 */ 225 struct itimer *it; 226 itimer_lock(); 227 LIST_FOREACH(it, &itimer_realtime_changed_notify, it_rtchgq) { 228 KASSERT(it->it_ops->ito_realtime_changed != NULL); 229 if (timespecisset(&it->it_time.it_value)) { 230 (*it->it_ops->ito_realtime_changed)(it); 231 } 232 } 233 itimer_unlock(); 234 235 return 0; 236 } 237 238 int 239 settime(struct proc *p, struct timespec *ts) 240 { 241 return settime1(p, ts, true); 242 } 243 244 /* ARGSUSED */ 245 int 246 sys___clock_gettime50(struct lwp *l, 247 const struct sys___clock_gettime50_args *uap, register_t *retval) 248 { 249 /* { 250 syscallarg(clockid_t) clock_id; 251 syscallarg(struct timespec *) tp; 252 } */ 253 int error; 254 struct timespec ats; 255 256 error = clock_gettime1(SCARG(uap, clock_id), &ats); 257 if (error != 0) 258 return error; 259 260 return copyout(&ats, SCARG(uap, tp), sizeof(ats)); 261 } 262 263 /* ARGSUSED */ 264 int 265 sys___clock_settime50(struct lwp *l, 266 const struct sys___clock_settime50_args *uap, register_t *retval) 267 { 268 /* { 269 syscallarg(clockid_t) clock_id; 270 syscallarg(const struct timespec *) tp; 271 } */ 272 int error; 273 struct timespec ats; 274 275 if ((error = copyin(SCARG(uap, tp), &ats, sizeof(ats))) != 0) 276 return error; 277 278 return clock_settime1(l->l_proc, SCARG(uap, clock_id), &ats, true); 279 } 280 281 282 int 283 clock_settime1(struct proc *p, clockid_t clock_id, const struct timespec *tp, 284 bool check_kauth) 285 { 286 int error; 287 288 if (tp->tv_nsec < 0 || tp->tv_nsec >= 1000000000L) 289 return EINVAL; 290 291 switch (clock_id) { 292 case CLOCK_REALTIME: 293 if ((error = settime1(p, tp, check_kauth)) != 0) 294 return error; 295 break; 296 case CLOCK_MONOTONIC: 297 return EINVAL; /* read-only clock */ 298 default: 299 return EINVAL; 300 } 301 302 return 0; 303 } 304 305 int 306 sys___clock_getres50(struct lwp *l, const struct sys___clock_getres50_args *uap, 307 register_t *retval) 308 { 309 /* { 310 syscallarg(clockid_t) clock_id; 311 syscallarg(struct timespec *) tp; 312 } */ 313 struct timespec ts; 314 int error; 315 316 if ((error = clock_getres1(SCARG(uap, clock_id), &ts)) != 0) 317 return error; 318 319 if (SCARG(uap, tp)) 320 error = copyout(&ts, SCARG(uap, tp), sizeof(ts)); 321 322 return error; 323 } 324 325 int 326 clock_getres1(clockid_t clock_id, struct timespec *ts) 327 { 328 329 switch (clock_id) { 330 case CLOCK_REALTIME: 331 case CLOCK_MONOTONIC: 332 ts->tv_sec = 0; 333 if (tc_getfrequency() > 1000000000) 334 ts->tv_nsec = 1; 335 else 336 ts->tv_nsec = 1000000000 / tc_getfrequency(); 337 break; 338 default: 339 return EINVAL; 340 } 341 342 return 0; 343 } 344 345 /* ARGSUSED */ 346 int 347 sys___nanosleep50(struct lwp *l, const struct sys___nanosleep50_args *uap, 348 register_t *retval) 349 { 350 /* { 351 syscallarg(struct timespec *) rqtp; 352 syscallarg(struct timespec *) rmtp; 353 } */ 354 struct timespec rmt, rqt; 355 int error, error1; 356 357 error = copyin(SCARG(uap, rqtp), &rqt, sizeof(struct timespec)); 358 if (error) 359 return error; 360 361 error = nanosleep1(l, CLOCK_MONOTONIC, 0, &rqt, 362 SCARG(uap, rmtp) ? &rmt : NULL); 363 if (SCARG(uap, rmtp) == NULL || (error != 0 && error != EINTR)) 364 return error; 365 366 error1 = copyout(&rmt, SCARG(uap, rmtp), sizeof(rmt)); 367 return error1 ? error1 : error; 368 } 369 370 /* ARGSUSED */ 371 int 372 sys_clock_nanosleep(struct lwp *l, const struct sys_clock_nanosleep_args *uap, 373 register_t *retval) 374 { 375 /* { 376 syscallarg(clockid_t) clock_id; 377 syscallarg(int) flags; 378 syscallarg(struct timespec *) rqtp; 379 syscallarg(struct timespec *) rmtp; 380 } */ 381 struct timespec rmt, rqt; 382 int error, error1; 383 384 error = copyin(SCARG(uap, rqtp), &rqt, sizeof(struct timespec)); 385 if (error) 386 goto out; 387 388 error = nanosleep1(l, SCARG(uap, clock_id), SCARG(uap, flags), &rqt, 389 SCARG(uap, rmtp) ? &rmt : NULL); 390 if (SCARG(uap, rmtp) == NULL || (error != 0 && error != EINTR)) 391 goto out; 392 393 if ((SCARG(uap, flags) & TIMER_ABSTIME) == 0 && 394 (error1 = copyout(&rmt, SCARG(uap, rmtp), sizeof(rmt))) != 0) 395 error = error1; 396 out: 397 *retval = error; 398 return 0; 399 } 400 401 int 402 nanosleep1(struct lwp *l, clockid_t clock_id, int flags, struct timespec *rqt, 403 struct timespec *rmt) 404 { 405 struct timespec rmtstart; 406 int error, timo; 407 408 if ((error = ts2timo(clock_id, flags, rqt, &timo, &rmtstart)) != 0) { 409 if (error == ETIMEDOUT) { 410 error = 0; 411 if (rmt != NULL) 412 rmt->tv_sec = rmt->tv_nsec = 0; 413 } 414 return error; 415 } 416 417 /* 418 * Avoid inadvertently sleeping forever 419 */ 420 if (timo == 0) 421 timo = 1; 422 again: 423 error = kpause("nanoslp", true, timo, NULL); 424 if (error == EWOULDBLOCK) 425 error = 0; 426 if (rmt != NULL || error == 0) { 427 struct timespec rmtend; 428 struct timespec t0; 429 struct timespec *t; 430 int err; 431 432 err = clock_gettime1(clock_id, &rmtend); 433 if (err != 0) 434 return err; 435 436 t = (rmt != NULL) ? rmt : &t0; 437 if (flags & TIMER_ABSTIME) { 438 timespecsub(rqt, &rmtend, t); 439 } else { 440 if (timespeccmp(&rmtend, &rmtstart, <)) 441 timespecclear(t); /* clock wound back */ 442 else 443 timespecsub(&rmtend, &rmtstart, t); 444 if (timespeccmp(rqt, t, <)) 445 timespecclear(t); 446 else 447 timespecsub(rqt, t, t); 448 } 449 if (t->tv_sec < 0) 450 timespecclear(t); 451 if (error == 0) { 452 timo = tstohz(t); 453 if (timo > 0) 454 goto again; 455 } 456 } 457 458 if (error == ERESTART) 459 error = EINTR; 460 461 return error; 462 } 463 464 int 465 sys_clock_getcpuclockid2(struct lwp *l, 466 const struct sys_clock_getcpuclockid2_args *uap, 467 register_t *retval) 468 { 469 /* { 470 syscallarg(idtype_t idtype; 471 syscallarg(id_t id); 472 syscallarg(clockid_t *)clock_id; 473 } */ 474 pid_t pid; 475 lwpid_t lid; 476 clockid_t clock_id; 477 id_t id = SCARG(uap, id); 478 479 switch (SCARG(uap, idtype)) { 480 case P_PID: 481 pid = id == 0 ? l->l_proc->p_pid : id; 482 clock_id = CLOCK_PROCESS_CPUTIME_ID | pid; 483 break; 484 case P_LWPID: 485 lid = id == 0 ? l->l_lid : id; 486 clock_id = CLOCK_THREAD_CPUTIME_ID | lid; 487 break; 488 default: 489 return EINVAL; 490 } 491 return copyout(&clock_id, SCARG(uap, clock_id), sizeof(clock_id)); 492 } 493 494 /* ARGSUSED */ 495 int 496 sys___gettimeofday50(struct lwp *l, const struct sys___gettimeofday50_args *uap, 497 register_t *retval) 498 { 499 /* { 500 syscallarg(struct timeval *) tp; 501 syscallarg(void *) tzp; really "struct timezone *"; 502 } */ 503 struct timeval atv; 504 int error = 0; 505 struct timezone tzfake; 506 507 if (SCARG(uap, tp)) { 508 memset(&atv, 0, sizeof(atv)); 509 microtime(&atv); 510 error = copyout(&atv, SCARG(uap, tp), sizeof(atv)); 511 if (error) 512 return error; 513 } 514 if (SCARG(uap, tzp)) { 515 /* 516 * NetBSD has no kernel notion of time zone, so we just 517 * fake up a timezone struct and return it if demanded. 518 */ 519 tzfake.tz_minuteswest = 0; 520 tzfake.tz_dsttime = 0; 521 error = copyout(&tzfake, SCARG(uap, tzp), sizeof(tzfake)); 522 } 523 return error; 524 } 525 526 /* ARGSUSED */ 527 int 528 sys___settimeofday50(struct lwp *l, const struct sys___settimeofday50_args *uap, 529 register_t *retval) 530 { 531 /* { 532 syscallarg(const struct timeval *) tv; 533 syscallarg(const void *) tzp; really "const struct timezone *"; 534 } */ 535 536 return settimeofday1(SCARG(uap, tv), true, SCARG(uap, tzp), l, true); 537 } 538 539 int 540 settimeofday1(const struct timeval *utv, bool userspace, 541 const void *utzp, struct lwp *l, bool check_kauth) 542 { 543 struct timeval atv; 544 struct timespec ts; 545 int error; 546 547 /* Verify all parameters before changing time. */ 548 549 /* 550 * NetBSD has no kernel notion of time zone, and only an 551 * obsolete program would try to set it, so we log a warning. 552 */ 553 if (utzp) 554 log(LOG_WARNING, "pid %d attempted to set the " 555 "(obsolete) kernel time zone\n", l->l_proc->p_pid); 556 557 if (utv == NULL) 558 return 0; 559 560 if (userspace) { 561 if ((error = copyin(utv, &atv, sizeof(atv))) != 0) 562 return error; 563 utv = &atv; 564 } 565 566 if (utv->tv_usec < 0 || utv->tv_usec >= 1000000) 567 return EINVAL; 568 569 TIMEVAL_TO_TIMESPEC(utv, &ts); 570 return settime1(l->l_proc, &ts, check_kauth); 571 } 572 573 int time_adjusted; /* set if an adjustment is made */ 574 575 /* ARGSUSED */ 576 int 577 sys___adjtime50(struct lwp *l, const struct sys___adjtime50_args *uap, 578 register_t *retval) 579 { 580 /* { 581 syscallarg(const struct timeval *) delta; 582 syscallarg(struct timeval *) olddelta; 583 } */ 584 int error; 585 struct timeval atv, oldatv; 586 587 if ((error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_TIME, 588 KAUTH_REQ_SYSTEM_TIME_ADJTIME, NULL, NULL, NULL)) != 0) 589 return error; 590 591 if (SCARG(uap, delta)) { 592 error = copyin(SCARG(uap, delta), &atv, 593 sizeof(*SCARG(uap, delta))); 594 if (error) 595 return error; 596 } 597 adjtime1(SCARG(uap, delta) ? &atv : NULL, 598 SCARG(uap, olddelta) ? &oldatv : NULL, l->l_proc); 599 if (SCARG(uap, olddelta)) 600 error = copyout(&oldatv, SCARG(uap, olddelta), 601 sizeof(*SCARG(uap, olddelta))); 602 return error; 603 } 604 605 void 606 adjtime1(const struct timeval *delta, struct timeval *olddelta, struct proc *p) 607 { 608 609 if (olddelta) { 610 memset(olddelta, 0, sizeof(*olddelta)); 611 mutex_spin_enter(&timecounter_lock); 612 olddelta->tv_sec = time_adjtime / 1000000; 613 olddelta->tv_usec = time_adjtime % 1000000; 614 if (olddelta->tv_usec < 0) { 615 olddelta->tv_usec += 1000000; 616 olddelta->tv_sec--; 617 } 618 mutex_spin_exit(&timecounter_lock); 619 } 620 621 if (delta) { 622 mutex_spin_enter(&timecounter_lock); 623 /* 624 * XXX This should maybe just report failure to 625 * userland for nonsense deltas. 626 */ 627 if (delta->tv_sec > INT64_MAX/1000000 - 1) { 628 time_adjtime = INT64_MAX; 629 } else if (delta->tv_sec < INT64_MIN/1000000 + 1) { 630 time_adjtime = INT64_MIN; 631 } else { 632 time_adjtime = delta->tv_sec * 1000000 633 + MAX(-999999, MIN(999999, delta->tv_usec)); 634 } 635 636 if (time_adjtime) { 637 /* We need to save the system time during shutdown */ 638 time_adjusted |= 1; 639 } 640 mutex_spin_exit(&timecounter_lock); 641 } 642 } 643 644 /* 645 * Interval timer support. 646 * 647 * The itimer_*() routines provide generic support for interval timers, 648 * both real (CLOCK_REALTIME, CLOCK_MONOTIME), and virtual (CLOCK_VIRTUAL, 649 * CLOCK_PROF). 650 * 651 * Real timers keep their deadline as an absolute time, and are fired 652 * by a callout. Virtual timers are kept as a linked-list of deltas, 653 * and are processed by hardclock(). 654 * 655 * Because the real time timer callout may be delayed in real time due 656 * to interrupt processing on the system, it is possible for the real 657 * time timeout routine (itimer_callout()) run past after its deadline. 658 * It does not suffice, therefore, to reload the real timer .it_value 659 * from the timer's .it_interval. Rather, we compute the next deadline 660 * in absolute time based on the current time and the .it_interval value, 661 * and report any overruns. 662 * 663 * Note that while the virtual timers are supported in a generic fashion 664 * here, they only (currently) make sense as per-process timers, and thus 665 * only really work for that case. 666 */ 667 668 /* 669 * itimer_init: 670 * 671 * Initialize the common data for an interval timer. 672 */ 673 void 674 itimer_init(struct itimer * const it, const struct itimer_ops * const ops, 675 clockid_t const id, struct itlist * const itl) 676 { 677 678 KASSERT(itimer_lock_held()); 679 KASSERT(ops != NULL); 680 681 timespecclear(&it->it_time.it_value); 682 it->it_ops = ops; 683 it->it_clockid = id; 684 it->it_overruns = 0; 685 it->it_dying = false; 686 if (!CLOCK_VIRTUAL_P(id)) { 687 KASSERT(itl == NULL); 688 callout_init(&it->it_ch, CALLOUT_MPSAFE); 689 callout_setfunc(&it->it_ch, itimer_callout, it); 690 if (id == CLOCK_REALTIME && ops->ito_realtime_changed != NULL) { 691 LIST_INSERT_HEAD(&itimer_realtime_changed_notify, 692 it, it_rtchgq); 693 } 694 } else { 695 KASSERT(itl != NULL); 696 it->it_vlist = itl; 697 it->it_active = false; 698 } 699 } 700 701 /* 702 * itimer_poison: 703 * 704 * Poison an interval timer, preventing it from being scheduled 705 * or processed, in preparation for freeing the timer. 706 */ 707 void 708 itimer_poison(struct itimer * const it) 709 { 710 711 KASSERT(itimer_lock_held()); 712 713 it->it_dying = true; 714 715 /* 716 * For non-virtual timers, stop the callout, or wait for it to 717 * run if it has already fired. It cannot restart again after 718 * this point: the callout won't restart itself when dying, no 719 * other users holding the lock can restart it, and any other 720 * users waiting for callout_halt concurrently (itimer_settime) 721 * will restart from the top. 722 */ 723 if (!CLOCK_VIRTUAL_P(it->it_clockid)) { 724 callout_halt(&it->it_ch, &itimer_mutex); 725 if (it->it_clockid == CLOCK_REALTIME && 726 it->it_ops->ito_realtime_changed != NULL) { 727 LIST_REMOVE(it, it_rtchgq); 728 } 729 } 730 } 731 732 /* 733 * itimer_fini: 734 * 735 * Release resources used by an interval timer. 736 * 737 * N.B. itimer_lock must be held on entry, and is released on exit. 738 */ 739 void 740 itimer_fini(struct itimer * const it) 741 { 742 743 KASSERT(itimer_lock_held()); 744 745 /* All done with the global state. */ 746 itimer_unlock(); 747 748 /* Destroy the callout, if needed. */ 749 if (!CLOCK_VIRTUAL_P(it->it_clockid)) 750 callout_destroy(&it->it_ch); 751 } 752 753 /* 754 * itimer_decr: 755 * 756 * Decrement an interval timer by a specified number of nanoseconds, 757 * which must be less than a second, i.e. < 1000000000. If the timer 758 * expires, then reload it. In this case, carry over (nsec - old value) 759 * to reduce the value reloaded into the timer so that the timer does 760 * not drift. This routine assumes that it is called in a context where 761 * the timers on which it is operating cannot change in value. 762 * 763 * Returns true if the timer has expired. 764 */ 765 static bool 766 itimer_decr(struct itimer *it, int nsec) 767 { 768 struct itimerspec *itp; 769 int error __diagused; 770 771 KASSERT(itimer_lock_held()); 772 KASSERT(CLOCK_VIRTUAL_P(it->it_clockid)); 773 774 itp = &it->it_time; 775 if (itp->it_value.tv_nsec < nsec) { 776 if (itp->it_value.tv_sec == 0) { 777 /* expired, and already in next interval */ 778 nsec -= itp->it_value.tv_nsec; 779 goto expire; 780 } 781 itp->it_value.tv_nsec += 1000000000; 782 itp->it_value.tv_sec--; 783 } 784 itp->it_value.tv_nsec -= nsec; 785 nsec = 0; 786 if (timespecisset(&itp->it_value)) 787 return false; 788 /* expired, exactly at end of interval */ 789 expire: 790 if (timespecisset(&itp->it_interval)) { 791 itp->it_value = itp->it_interval; 792 itp->it_value.tv_nsec -= nsec; 793 if (itp->it_value.tv_nsec < 0) { 794 itp->it_value.tv_nsec += 1000000000; 795 itp->it_value.tv_sec--; 796 } 797 error = itimer_settime(it); 798 KASSERT(error == 0); /* virtual, never fails */ 799 } else 800 itp->it_value.tv_nsec = 0; /* sec is already 0 */ 801 return true; 802 } 803 804 /* 805 * itimer_arm_real: 806 * 807 * Arm a non-virtual timer. 808 */ 809 static void 810 itimer_arm_real(struct itimer * const it) 811 { 812 813 KASSERT(!it->it_dying); 814 KASSERT(!CLOCK_VIRTUAL_P(it->it_clockid)); 815 KASSERT(!callout_pending(&it->it_ch)); 816 817 /* 818 * Don't need to check tshzto() return value, here. 819 * callout_schedule() does it for us. 820 */ 821 callout_schedule(&it->it_ch, 822 (it->it_clockid == CLOCK_MONOTONIC 823 ? tshztoup(&it->it_time.it_value) 824 : tshzto(&it->it_time.it_value))); 825 } 826 827 /* 828 * itimer_callout: 829 * 830 * Callout to expire a non-virtual timer. Queue it up for processing, 831 * and then reload, if it is configured to do so. 832 * 833 * N.B. A delay in processing this callout causes multiple 834 * SIGALRM calls to be compressed into one. 835 */ 836 static void 837 itimer_callout(void *arg) 838 { 839 uint64_t last_val, next_val, interval, now_ns; 840 struct timespec now, next; 841 struct itimer * const it = arg; 842 int backwards; 843 844 itimer_lock(); 845 (*it->it_ops->ito_fire)(it); 846 847 if (!timespecisset(&it->it_time.it_interval)) { 848 timespecclear(&it->it_time.it_value); 849 itimer_unlock(); 850 return; 851 } 852 853 if (it->it_clockid == CLOCK_MONOTONIC) { 854 getnanouptime(&now); 855 } else { 856 getnanotime(&now); 857 } 858 859 backwards = (timespeccmp(&it->it_time.it_value, &now, >)); 860 861 /* Nonnegative interval guaranteed by itimerfix. */ 862 KASSERT(it->it_time.it_interval.tv_sec >= 0); 863 KASSERT(it->it_time.it_interval.tv_nsec >= 0); 864 865 /* Handle the easy case of non-overflown timers first. */ 866 if (!backwards && 867 timespecaddok(&it->it_time.it_value, &it->it_time.it_interval)) { 868 timespecadd(&it->it_time.it_value, &it->it_time.it_interval, 869 &next); 870 it->it_time.it_value = next; 871 } else { 872 now_ns = timespec2ns(&now); 873 last_val = timespec2ns(&it->it_time.it_value); 874 interval = timespec2ns(&it->it_time.it_interval); 875 876 next_val = now_ns + 877 (now_ns - last_val + interval - 1) % interval; 878 879 if (backwards) 880 next_val += interval; 881 else 882 it->it_overruns += (now_ns - last_val) / interval; 883 884 it->it_time.it_value.tv_sec = next_val / 1000000000; 885 it->it_time.it_value.tv_nsec = next_val % 1000000000; 886 } 887 888 /* 889 * Reset the callout, if it's not going away. 890 */ 891 if (!it->it_dying) 892 itimer_arm_real(it); 893 itimer_unlock(); 894 } 895 896 /* 897 * itimer_settime: 898 * 899 * Set up the given interval timer. The value in it->it_time.it_value 900 * is taken to be an absolute time for CLOCK_REALTIME/CLOCK_MONOTONIC 901 * timers and a relative time for CLOCK_VIRTUAL/CLOCK_PROF timers. 902 * 903 * If the callout had already fired but not yet run, fails with 904 * ERESTART -- caller must restart from the top to look up a timer. 905 */ 906 int 907 itimer_settime(struct itimer *it) 908 { 909 struct itimer *itn, *pitn; 910 struct itlist *itl; 911 912 KASSERT(itimer_lock_held()); 913 KASSERT(!it->it_dying); 914 915 if (!CLOCK_VIRTUAL_P(it->it_clockid)) { 916 /* 917 * Try to stop the callout. However, if it had already 918 * fired, we have to drop the lock to wait for it, so 919 * the world may have changed and pt may not be there 920 * any more. In that case, tell the caller to start 921 * over from the top. 922 */ 923 if (callout_halt(&it->it_ch, &itimer_mutex)) 924 return ERESTART; 925 KASSERT(!it->it_dying); 926 927 /* Now we can touch it and start it up again. */ 928 if (timespecisset(&it->it_time.it_value)) 929 itimer_arm_real(it); 930 } else { 931 if (it->it_active) { 932 itn = LIST_NEXT(it, it_list); 933 LIST_REMOVE(it, it_list); 934 for ( ; itn; itn = LIST_NEXT(itn, it_list)) 935 timespecadd(&it->it_time.it_value, 936 &itn->it_time.it_value, 937 &itn->it_time.it_value); 938 } 939 if (timespecisset(&it->it_time.it_value)) { 940 itl = it->it_vlist; 941 for (itn = LIST_FIRST(itl), pitn = NULL; 942 itn && timespeccmp(&it->it_time.it_value, 943 &itn->it_time.it_value, >); 944 pitn = itn, itn = LIST_NEXT(itn, it_list)) 945 timespecsub(&it->it_time.it_value, 946 &itn->it_time.it_value, 947 &it->it_time.it_value); 948 949 if (pitn) 950 LIST_INSERT_AFTER(pitn, it, it_list); 951 else 952 LIST_INSERT_HEAD(itl, it, it_list); 953 954 for ( ; itn ; itn = LIST_NEXT(itn, it_list)) 955 timespecsub(&itn->it_time.it_value, 956 &it->it_time.it_value, 957 &itn->it_time.it_value); 958 959 it->it_active = true; 960 } else { 961 it->it_active = false; 962 } 963 } 964 965 /* Success! */ 966 return 0; 967 } 968 969 /* 970 * itimer_gettime: 971 * 972 * Return the remaining time of an interval timer. 973 */ 974 void 975 itimer_gettime(const struct itimer *it, struct itimerspec *aits) 976 { 977 struct timespec now; 978 struct itimer *itn; 979 980 KASSERT(itimer_lock_held()); 981 KASSERT(!it->it_dying); 982 983 *aits = it->it_time; 984 if (!CLOCK_VIRTUAL_P(it->it_clockid)) { 985 /* 986 * Convert from absolute to relative time in .it_value 987 * part of real time timer. If time for real time 988 * timer has passed return 0, else return difference 989 * between current time and time for the timer to go 990 * off. 991 */ 992 if (timespecisset(&aits->it_value)) { 993 if (it->it_clockid == CLOCK_REALTIME) { 994 getnanotime(&now); 995 } else { /* CLOCK_MONOTONIC */ 996 getnanouptime(&now); 997 } 998 if (timespeccmp(&aits->it_value, &now, <)) 999 timespecclear(&aits->it_value); 1000 else 1001 timespecsub(&aits->it_value, &now, 1002 &aits->it_value); 1003 } 1004 } else if (it->it_active) { 1005 for (itn = LIST_FIRST(it->it_vlist); itn && itn != it; 1006 itn = LIST_NEXT(itn, it_list)) 1007 timespecadd(&aits->it_value, 1008 &itn->it_time.it_value, &aits->it_value); 1009 KASSERT(itn != NULL); /* it should be findable on the list */ 1010 } else 1011 timespecclear(&aits->it_value); 1012 } 1013 1014 /* 1015 * Per-process timer support. 1016 * 1017 * Both the BSD getitimer() family and the POSIX timer_*() family of 1018 * routines are supported. 1019 * 1020 * All timers are kept in an array pointed to by p_timers, which is 1021 * allocated on demand - many processes don't use timers at all. The 1022 * first four elements in this array are reserved for the BSD timers: 1023 * element 0 is ITIMER_REAL, element 1 is ITIMER_VIRTUAL, element 1024 * 2 is ITIMER_PROF, and element 3 is ITIMER_MONOTONIC. The rest may be 1025 * allocated by the timer_create() syscall. 1026 * 1027 * These timers are a "sub-class" of interval timer. 1028 */ 1029 1030 /* 1031 * ptimer_free: 1032 * 1033 * Free the per-process timer at the specified index. 1034 */ 1035 static void 1036 ptimer_free(struct ptimers *pts, int index) 1037 { 1038 struct itimer *it; 1039 struct ptimer *pt; 1040 1041 KASSERT(itimer_lock_held()); 1042 1043 it = pts->pts_timers[index]; 1044 pt = container_of(it, struct ptimer, pt_itimer); 1045 pts->pts_timers[index] = NULL; 1046 itimer_poison(it); 1047 1048 /* 1049 * Remove it from the queue to be signalled. Must be done 1050 * after itimer is poisoned, because we may have had to wait 1051 * for the callout to complete. 1052 */ 1053 if (pt->pt_queued) { 1054 TAILQ_REMOVE(&ptimer_queue, pt, pt_chain); 1055 pt->pt_queued = false; 1056 } 1057 1058 itimer_fini(it); /* releases itimer_lock */ 1059 kmem_free(pt, sizeof(*pt)); 1060 } 1061 1062 /* 1063 * ptimers_alloc: 1064 * 1065 * Allocate a ptimers for the specified process. 1066 */ 1067 static struct ptimers * 1068 ptimers_alloc(struct proc *p) 1069 { 1070 struct ptimers *pts; 1071 int i; 1072 1073 pts = kmem_alloc(sizeof(*pts), KM_SLEEP); 1074 LIST_INIT(&pts->pts_virtual); 1075 LIST_INIT(&pts->pts_prof); 1076 for (i = 0; i < TIMER_MAX; i++) 1077 pts->pts_timers[i] = NULL; 1078 itimer_lock(); 1079 if (p->p_timers == NULL) { 1080 p->p_timers = pts; 1081 itimer_unlock(); 1082 return pts; 1083 } 1084 itimer_unlock(); 1085 kmem_free(pts, sizeof(*pts)); 1086 return p->p_timers; 1087 } 1088 1089 /* 1090 * ptimers_free: 1091 * 1092 * Clean up the per-process timers. If "which" is set to TIMERS_ALL, 1093 * then clean up all timers and free all the data structures. If 1094 * "which" is set to TIMERS_POSIX, only clean up the timers allocated 1095 * by timer_create(), not the BSD setitimer() timers, and only free the 1096 * structure if none of those remain. 1097 * 1098 * This function is exported because it is needed in the exec and 1099 * exit code paths. 1100 */ 1101 void 1102 ptimers_free(struct proc *p, int which) 1103 { 1104 struct ptimers *pts; 1105 struct itimer *itn; 1106 struct timespec ts; 1107 int i; 1108 1109 if (p->p_timers == NULL) 1110 return; 1111 1112 pts = p->p_timers; 1113 itimer_lock(); 1114 if (which == TIMERS_ALL) { 1115 p->p_timers = NULL; 1116 i = 0; 1117 } else { 1118 timespecclear(&ts); 1119 for (itn = LIST_FIRST(&pts->pts_virtual); 1120 itn && itn != pts->pts_timers[ITIMER_VIRTUAL]; 1121 itn = LIST_NEXT(itn, it_list)) { 1122 KASSERT(itn->it_clockid == CLOCK_VIRTUAL); 1123 timespecadd(&ts, &itn->it_time.it_value, &ts); 1124 } 1125 LIST_FIRST(&pts->pts_virtual) = NULL; 1126 if (itn) { 1127 KASSERT(itn->it_clockid == CLOCK_VIRTUAL); 1128 timespecadd(&ts, &itn->it_time.it_value, 1129 &itn->it_time.it_value); 1130 LIST_INSERT_HEAD(&pts->pts_virtual, itn, it_list); 1131 } 1132 timespecclear(&ts); 1133 for (itn = LIST_FIRST(&pts->pts_prof); 1134 itn && itn != pts->pts_timers[ITIMER_PROF]; 1135 itn = LIST_NEXT(itn, it_list)) { 1136 KASSERT(itn->it_clockid == CLOCK_PROF); 1137 timespecadd(&ts, &itn->it_time.it_value, &ts); 1138 } 1139 LIST_FIRST(&pts->pts_prof) = NULL; 1140 if (itn) { 1141 KASSERT(itn->it_clockid == CLOCK_PROF); 1142 timespecadd(&ts, &itn->it_time.it_value, 1143 &itn->it_time.it_value); 1144 LIST_INSERT_HEAD(&pts->pts_prof, itn, it_list); 1145 } 1146 i = TIMER_MIN; 1147 } 1148 for ( ; i < TIMER_MAX; i++) { 1149 if (pts->pts_timers[i] != NULL) { 1150 /* Free the timer and release the lock. */ 1151 ptimer_free(pts, i); 1152 /* Reacquire the lock for the next one. */ 1153 itimer_lock(); 1154 } 1155 } 1156 if (pts->pts_timers[0] == NULL && pts->pts_timers[1] == NULL && 1157 pts->pts_timers[2] == NULL && pts->pts_timers[3] == NULL) { 1158 p->p_timers = NULL; 1159 itimer_unlock(); 1160 kmem_free(pts, sizeof(*pts)); 1161 } else 1162 itimer_unlock(); 1163 } 1164 1165 /* 1166 * ptimer_fire: 1167 * 1168 * Fire a per-process timer. 1169 */ 1170 static void 1171 ptimer_fire(struct itimer *it) 1172 { 1173 struct ptimer *pt = container_of(it, struct ptimer, pt_itimer); 1174 1175 KASSERT(itimer_lock_held()); 1176 1177 /* 1178 * XXX Can overrun, but we don't do signal queueing yet, anyway. 1179 * XXX Relying on the clock interrupt is stupid. 1180 */ 1181 if (pt->pt_ev.sigev_notify != SIGEV_SIGNAL) { 1182 return; 1183 } 1184 1185 if (!pt->pt_queued) { 1186 TAILQ_INSERT_TAIL(&ptimer_queue, pt, pt_chain); 1187 pt->pt_queued = true; 1188 softint_schedule(ptimer_sih); 1189 } 1190 } 1191 1192 /* 1193 * Operations vector for per-process timers (BSD and POSIX). 1194 */ 1195 static const struct itimer_ops ptimer_itimer_ops = { 1196 .ito_fire = ptimer_fire, 1197 }; 1198 1199 /* 1200 * sys_timer_create: 1201 * 1202 * System call to create a POSIX timer. 1203 */ 1204 int 1205 sys_timer_create(struct lwp *l, const struct sys_timer_create_args *uap, 1206 register_t *retval) 1207 { 1208 /* { 1209 syscallarg(clockid_t) clock_id; 1210 syscallarg(struct sigevent *) evp; 1211 syscallarg(timer_t *) timerid; 1212 } */ 1213 1214 return timer_create1(SCARG(uap, timerid), SCARG(uap, clock_id), 1215 SCARG(uap, evp), copyin, l); 1216 } 1217 1218 int 1219 timer_create1(timer_t *tid, clockid_t id, struct sigevent *evp, 1220 copyin_t fetch_event, struct lwp *l) 1221 { 1222 int error; 1223 timer_t timerid; 1224 struct itlist *itl; 1225 struct ptimers *pts; 1226 struct ptimer *pt; 1227 struct proc *p; 1228 1229 p = l->l_proc; 1230 1231 if ((u_int)id > CLOCK_MONOTONIC) 1232 return EINVAL; 1233 1234 if ((pts = p->p_timers) == NULL) 1235 pts = ptimers_alloc(p); 1236 1237 pt = kmem_zalloc(sizeof(*pt), KM_SLEEP); 1238 if (evp != NULL) { 1239 if (((error = 1240 (*fetch_event)(evp, &pt->pt_ev, sizeof(pt->pt_ev))) != 0) || 1241 ((pt->pt_ev.sigev_notify < SIGEV_NONE) || 1242 (pt->pt_ev.sigev_notify > SIGEV_SA)) || 1243 (pt->pt_ev.sigev_notify == SIGEV_SIGNAL && 1244 (pt->pt_ev.sigev_signo <= 0 || 1245 pt->pt_ev.sigev_signo >= NSIG))) { 1246 kmem_free(pt, sizeof(*pt)); 1247 return (error ? error : EINVAL); 1248 } 1249 } 1250 1251 /* Find a free timer slot, skipping those reserved for setitimer(). */ 1252 itimer_lock(); 1253 for (timerid = TIMER_MIN; timerid < TIMER_MAX; timerid++) 1254 if (pts->pts_timers[timerid] == NULL) 1255 break; 1256 if (timerid == TIMER_MAX) { 1257 itimer_unlock(); 1258 kmem_free(pt, sizeof(*pt)); 1259 return EAGAIN; 1260 } 1261 if (evp == NULL) { 1262 pt->pt_ev.sigev_notify = SIGEV_SIGNAL; 1263 switch (id) { 1264 case CLOCK_REALTIME: 1265 case CLOCK_MONOTONIC: 1266 pt->pt_ev.sigev_signo = SIGALRM; 1267 break; 1268 case CLOCK_VIRTUAL: 1269 pt->pt_ev.sigev_signo = SIGVTALRM; 1270 break; 1271 case CLOCK_PROF: 1272 pt->pt_ev.sigev_signo = SIGPROF; 1273 break; 1274 } 1275 pt->pt_ev.sigev_value.sival_int = timerid; 1276 } 1277 1278 switch (id) { 1279 case CLOCK_VIRTUAL: 1280 itl = &pts->pts_virtual; 1281 break; 1282 case CLOCK_PROF: 1283 itl = &pts->pts_prof; 1284 break; 1285 default: 1286 itl = NULL; 1287 } 1288 1289 itimer_init(&pt->pt_itimer, &ptimer_itimer_ops, id, itl); 1290 pt->pt_proc = p; 1291 pt->pt_poverruns = 0; 1292 pt->pt_entry = timerid; 1293 pt->pt_queued = false; 1294 1295 pts->pts_timers[timerid] = &pt->pt_itimer; 1296 itimer_unlock(); 1297 1298 return copyout(&timerid, tid, sizeof(timerid)); 1299 } 1300 1301 /* 1302 * sys_timer_delete: 1303 * 1304 * System call to delete a POSIX timer. 1305 */ 1306 int 1307 sys_timer_delete(struct lwp *l, const struct sys_timer_delete_args *uap, 1308 register_t *retval) 1309 { 1310 /* { 1311 syscallarg(timer_t) timerid; 1312 } */ 1313 struct proc *p = l->l_proc; 1314 timer_t timerid; 1315 struct ptimers *pts; 1316 struct itimer *it, *itn; 1317 1318 timerid = SCARG(uap, timerid); 1319 pts = p->p_timers; 1320 1321 if (pts == NULL || timerid < 2 || timerid >= TIMER_MAX) 1322 return EINVAL; 1323 1324 itimer_lock(); 1325 if ((it = pts->pts_timers[timerid]) == NULL) { 1326 itimer_unlock(); 1327 return EINVAL; 1328 } 1329 1330 if (CLOCK_VIRTUAL_P(it->it_clockid)) { 1331 if (it->it_active) { 1332 itn = LIST_NEXT(it, it_list); 1333 LIST_REMOVE(it, it_list); 1334 for ( ; itn; itn = LIST_NEXT(itn, it_list)) 1335 timespecadd(&it->it_time.it_value, 1336 &itn->it_time.it_value, 1337 &itn->it_time.it_value); 1338 it->it_active = false; 1339 } 1340 } 1341 1342 /* Free the timer and release the lock. */ 1343 ptimer_free(pts, timerid); 1344 1345 return 0; 1346 } 1347 1348 /* 1349 * sys___timer_settime50: 1350 * 1351 * System call to set/arm a POSIX timer. 1352 */ 1353 int 1354 sys___timer_settime50(struct lwp *l, 1355 const struct sys___timer_settime50_args *uap, 1356 register_t *retval) 1357 { 1358 /* { 1359 syscallarg(timer_t) timerid; 1360 syscallarg(int) flags; 1361 syscallarg(const struct itimerspec *) value; 1362 syscallarg(struct itimerspec *) ovalue; 1363 } */ 1364 int error; 1365 struct itimerspec value, ovalue, *ovp = NULL; 1366 1367 if ((error = copyin(SCARG(uap, value), &value, 1368 sizeof(struct itimerspec))) != 0) 1369 return error; 1370 1371 if (SCARG(uap, ovalue)) 1372 ovp = &ovalue; 1373 1374 if ((error = dotimer_settime(SCARG(uap, timerid), &value, ovp, 1375 SCARG(uap, flags), l->l_proc)) != 0) 1376 return error; 1377 1378 if (ovp) 1379 return copyout(&ovalue, SCARG(uap, ovalue), 1380 sizeof(struct itimerspec)); 1381 return 0; 1382 } 1383 1384 int 1385 dotimer_settime(int timerid, struct itimerspec *value, 1386 struct itimerspec *ovalue, int flags, struct proc *p) 1387 { 1388 struct timespec now; 1389 struct itimerspec val, oval; 1390 struct ptimers *pts; 1391 struct itimer *it; 1392 int error; 1393 1394 pts = p->p_timers; 1395 1396 if (pts == NULL || timerid < 2 || timerid >= TIMER_MAX) 1397 return EINVAL; 1398 val = *value; 1399 if ((error = itimespecfix(&val.it_value)) != 0 || 1400 (error = itimespecfix(&val.it_interval)) != 0) 1401 return error; 1402 1403 itimer_lock(); 1404 restart: 1405 if ((it = pts->pts_timers[timerid]) == NULL) { 1406 itimer_unlock(); 1407 return EINVAL; 1408 } 1409 1410 oval = it->it_time; 1411 it->it_time = val; 1412 1413 /* 1414 * If we've been passed a relative time for a realtime timer, 1415 * convert it to absolute; if an absolute time for a virtual 1416 * timer, convert it to relative and make sure we don't set it 1417 * to zero, which would cancel the timer, or let it go 1418 * negative, which would confuse the comparison tests. 1419 */ 1420 if (timespecisset(&it->it_time.it_value)) { 1421 if (!CLOCK_VIRTUAL_P(it->it_clockid)) { 1422 if ((flags & TIMER_ABSTIME) == 0) { 1423 if (it->it_clockid == CLOCK_REALTIME) { 1424 getnanotime(&now); 1425 } else { /* CLOCK_MONOTONIC */ 1426 getnanouptime(&now); 1427 } 1428 timespecadd(&it->it_time.it_value, &now, 1429 &it->it_time.it_value); 1430 } 1431 } else { 1432 if ((flags & TIMER_ABSTIME) != 0) { 1433 getnanotime(&now); 1434 timespecsub(&it->it_time.it_value, &now, 1435 &it->it_time.it_value); 1436 if (!timespecisset(&it->it_time.it_value) || 1437 it->it_time.it_value.tv_sec < 0) { 1438 it->it_time.it_value.tv_sec = 0; 1439 it->it_time.it_value.tv_nsec = 1; 1440 } 1441 } 1442 } 1443 } 1444 1445 error = itimer_settime(it); 1446 if (error == ERESTART) { 1447 KASSERT(!CLOCK_VIRTUAL_P(it->it_clockid)); 1448 goto restart; 1449 } 1450 KASSERT(error == 0); 1451 itimer_unlock(); 1452 1453 if (ovalue) 1454 *ovalue = oval; 1455 1456 return 0; 1457 } 1458 1459 /* 1460 * sys___timer_gettime50: 1461 * 1462 * System call to return the time remaining until a POSIX timer fires. 1463 */ 1464 int 1465 sys___timer_gettime50(struct lwp *l, 1466 const struct sys___timer_gettime50_args *uap, register_t *retval) 1467 { 1468 /* { 1469 syscallarg(timer_t) timerid; 1470 syscallarg(struct itimerspec *) value; 1471 } */ 1472 struct itimerspec its; 1473 int error; 1474 1475 if ((error = dotimer_gettime(SCARG(uap, timerid), l->l_proc, 1476 &its)) != 0) 1477 return error; 1478 1479 return copyout(&its, SCARG(uap, value), sizeof(its)); 1480 } 1481 1482 int 1483 dotimer_gettime(int timerid, struct proc *p, struct itimerspec *its) 1484 { 1485 struct itimer *it; 1486 struct ptimers *pts; 1487 1488 pts = p->p_timers; 1489 if (pts == NULL || timerid < 2 || timerid >= TIMER_MAX) 1490 return EINVAL; 1491 itimer_lock(); 1492 if ((it = pts->pts_timers[timerid]) == NULL) { 1493 itimer_unlock(); 1494 return EINVAL; 1495 } 1496 itimer_gettime(it, its); 1497 itimer_unlock(); 1498 1499 return 0; 1500 } 1501 1502 /* 1503 * sys_timer_getoverrun: 1504 * 1505 * System call to return the number of times a POSIX timer has 1506 * expired while a notification was already pending. The counter 1507 * is reset when a timer expires and a notification can be posted. 1508 */ 1509 int 1510 sys_timer_getoverrun(struct lwp *l, const struct sys_timer_getoverrun_args *uap, 1511 register_t *retval) 1512 { 1513 /* { 1514 syscallarg(timer_t) timerid; 1515 } */ 1516 struct proc *p = l->l_proc; 1517 struct ptimers *pts; 1518 int timerid; 1519 struct itimer *it; 1520 struct ptimer *pt; 1521 1522 timerid = SCARG(uap, timerid); 1523 1524 pts = p->p_timers; 1525 if (pts == NULL || timerid < 2 || timerid >= TIMER_MAX) 1526 return EINVAL; 1527 itimer_lock(); 1528 if ((it = pts->pts_timers[timerid]) == NULL) { 1529 itimer_unlock(); 1530 return EINVAL; 1531 } 1532 pt = container_of(it, struct ptimer, pt_itimer); 1533 *retval = pt->pt_poverruns; 1534 if (*retval >= DELAYTIMER_MAX) 1535 *retval = DELAYTIMER_MAX; 1536 itimer_unlock(); 1537 1538 return 0; 1539 } 1540 1541 /* 1542 * sys___getitimer50: 1543 * 1544 * System call to get the time remaining before a BSD timer fires. 1545 */ 1546 int 1547 sys___getitimer50(struct lwp *l, const struct sys___getitimer50_args *uap, 1548 register_t *retval) 1549 { 1550 /* { 1551 syscallarg(int) which; 1552 syscallarg(struct itimerval *) itv; 1553 } */ 1554 struct proc *p = l->l_proc; 1555 struct itimerval aitv; 1556 int error; 1557 1558 memset(&aitv, 0, sizeof(aitv)); 1559 error = dogetitimer(p, SCARG(uap, which), &aitv); 1560 if (error) 1561 return error; 1562 return copyout(&aitv, SCARG(uap, itv), sizeof(struct itimerval)); 1563 } 1564 1565 int 1566 dogetitimer(struct proc *p, int which, struct itimerval *itvp) 1567 { 1568 struct ptimers *pts; 1569 struct itimer *it; 1570 struct itimerspec its; 1571 1572 if ((u_int)which > ITIMER_MONOTONIC) 1573 return EINVAL; 1574 1575 itimer_lock(); 1576 pts = p->p_timers; 1577 if (pts == NULL || (it = pts->pts_timers[which]) == NULL) { 1578 timerclear(&itvp->it_value); 1579 timerclear(&itvp->it_interval); 1580 } else { 1581 itimer_gettime(it, &its); 1582 TIMESPEC_TO_TIMEVAL(&itvp->it_value, &its.it_value); 1583 TIMESPEC_TO_TIMEVAL(&itvp->it_interval, &its.it_interval); 1584 } 1585 itimer_unlock(); 1586 1587 return 0; 1588 } 1589 1590 /* 1591 * sys___setitimer50: 1592 * 1593 * System call to set/arm a BSD timer. 1594 */ 1595 int 1596 sys___setitimer50(struct lwp *l, const struct sys___setitimer50_args *uap, 1597 register_t *retval) 1598 { 1599 /* { 1600 syscallarg(int) which; 1601 syscallarg(const struct itimerval *) itv; 1602 syscallarg(struct itimerval *) oitv; 1603 } */ 1604 struct proc *p = l->l_proc; 1605 int which = SCARG(uap, which); 1606 struct sys___getitimer50_args getargs; 1607 const struct itimerval *itvp; 1608 struct itimerval aitv; 1609 int error; 1610 1611 itvp = SCARG(uap, itv); 1612 if (itvp && 1613 (error = copyin(itvp, &aitv, sizeof(struct itimerval))) != 0) 1614 return error; 1615 if (SCARG(uap, oitv) != NULL) { 1616 SCARG(&getargs, which) = which; 1617 SCARG(&getargs, itv) = SCARG(uap, oitv); 1618 if ((error = sys___getitimer50(l, &getargs, retval)) != 0) 1619 return error; 1620 } 1621 if (itvp == 0) 1622 return 0; 1623 1624 return dosetitimer(p, which, &aitv); 1625 } 1626 1627 int 1628 dosetitimer(struct proc *p, int which, struct itimerval *itvp) 1629 { 1630 struct timespec now; 1631 struct ptimers *pts; 1632 struct ptimer *spare; 1633 struct itimer *it; 1634 struct itlist *itl; 1635 int error; 1636 1637 if ((u_int)which > ITIMER_MONOTONIC) 1638 return EINVAL; 1639 if (itimerfix(&itvp->it_value) || itimerfix(&itvp->it_interval)) 1640 return EINVAL; 1641 1642 /* 1643 * Don't bother allocating data structures if the process just 1644 * wants to clear the timer. 1645 */ 1646 spare = NULL; 1647 pts = p->p_timers; 1648 retry: 1649 if (!timerisset(&itvp->it_value) && (pts == NULL || 1650 pts->pts_timers[which] == NULL)) 1651 return 0; 1652 if (pts == NULL) 1653 pts = ptimers_alloc(p); 1654 itimer_lock(); 1655 restart: 1656 it = pts->pts_timers[which]; 1657 if (it == NULL) { 1658 struct ptimer *pt; 1659 1660 if (spare == NULL) { 1661 itimer_unlock(); 1662 spare = kmem_zalloc(sizeof(*spare), KM_SLEEP); 1663 goto retry; 1664 } 1665 pt = spare; 1666 spare = NULL; 1667 1668 it = &pt->pt_itimer; 1669 pt->pt_ev.sigev_notify = SIGEV_SIGNAL; 1670 pt->pt_ev.sigev_value.sival_int = which; 1671 1672 switch (which) { 1673 case ITIMER_REAL: 1674 case ITIMER_MONOTONIC: 1675 itl = NULL; 1676 pt->pt_ev.sigev_signo = SIGALRM; 1677 break; 1678 case ITIMER_VIRTUAL: 1679 itl = &pts->pts_virtual; 1680 pt->pt_ev.sigev_signo = SIGVTALRM; 1681 break; 1682 case ITIMER_PROF: 1683 itl = &pts->pts_prof; 1684 pt->pt_ev.sigev_signo = SIGPROF; 1685 break; 1686 default: 1687 panic("%s: can't happen %d", __func__, which); 1688 } 1689 itimer_init(it, &ptimer_itimer_ops, which, itl); 1690 pt->pt_proc = p; 1691 pt->pt_entry = which; 1692 1693 pts->pts_timers[which] = it; 1694 } 1695 1696 TIMEVAL_TO_TIMESPEC(&itvp->it_value, &it->it_time.it_value); 1697 TIMEVAL_TO_TIMESPEC(&itvp->it_interval, &it->it_time.it_interval); 1698 1699 error = 0; 1700 if (timespecisset(&it->it_time.it_value)) { 1701 /* Convert to absolute time */ 1702 /* XXX need to wrap in splclock for timecounters case? */ 1703 switch (which) { 1704 case ITIMER_REAL: 1705 getnanotime(&now); 1706 if (!timespecaddok(&it->it_time.it_value, &now)) { 1707 error = EINVAL; 1708 goto out; 1709 } 1710 timespecadd(&it->it_time.it_value, &now, 1711 &it->it_time.it_value); 1712 break; 1713 case ITIMER_MONOTONIC: 1714 getnanouptime(&now); 1715 if (!timespecaddok(&it->it_time.it_value, &now)) { 1716 error = EINVAL; 1717 goto out; 1718 } 1719 timespecadd(&it->it_time.it_value, &now, 1720 &it->it_time.it_value); 1721 break; 1722 default: 1723 break; 1724 } 1725 } 1726 1727 error = itimer_settime(it); 1728 if (error == ERESTART) { 1729 KASSERT(!CLOCK_VIRTUAL_P(it->it_clockid)); 1730 goto restart; 1731 } 1732 KASSERT(error == 0); 1733 out: 1734 itimer_unlock(); 1735 if (spare != NULL) 1736 kmem_free(spare, sizeof(*spare)); 1737 1738 return error; 1739 } 1740 1741 /* 1742 * ptimer_tick: 1743 * 1744 * Called from hardclock() to decrement per-process virtual timers. 1745 */ 1746 void 1747 ptimer_tick(lwp_t *l, bool user) 1748 { 1749 struct ptimers *pts; 1750 struct itimer *it; 1751 proc_t *p; 1752 1753 p = l->l_proc; 1754 if (p->p_timers == NULL) 1755 return; 1756 1757 itimer_lock(); 1758 if ((pts = l->l_proc->p_timers) != NULL) { 1759 /* 1760 * Run current process's virtual and profile time, as needed. 1761 */ 1762 if (user && (it = LIST_FIRST(&pts->pts_virtual)) != NULL) 1763 if (itimer_decr(it, tick * 1000)) 1764 (*it->it_ops->ito_fire)(it); 1765 if ((it = LIST_FIRST(&pts->pts_prof)) != NULL) 1766 if (itimer_decr(it, tick * 1000)) 1767 (*it->it_ops->ito_fire)(it); 1768 } 1769 itimer_unlock(); 1770 } 1771 1772 /* 1773 * ptimer_intr: 1774 * 1775 * Software interrupt handler for processing per-process 1776 * timer expiration. 1777 */ 1778 static void 1779 ptimer_intr(void *cookie) 1780 { 1781 ksiginfo_t ksi; 1782 struct itimer *it; 1783 struct ptimer *pt; 1784 proc_t *p; 1785 1786 mutex_enter(&proc_lock); 1787 itimer_lock(); 1788 while ((pt = TAILQ_FIRST(&ptimer_queue)) != NULL) { 1789 it = &pt->pt_itimer; 1790 1791 TAILQ_REMOVE(&ptimer_queue, pt, pt_chain); 1792 KASSERT(pt->pt_queued); 1793 pt->pt_queued = false; 1794 1795 p = pt->pt_proc; 1796 if (p->p_timers == NULL) { 1797 /* Process is dying. */ 1798 continue; 1799 } 1800 if (pt->pt_ev.sigev_notify != SIGEV_SIGNAL) { 1801 continue; 1802 } 1803 if (sigismember(&p->p_sigpend.sp_set, pt->pt_ev.sigev_signo)) { 1804 it->it_overruns++; 1805 continue; 1806 } 1807 1808 KSI_INIT(&ksi); 1809 ksi.ksi_signo = pt->pt_ev.sigev_signo; 1810 ksi.ksi_code = SI_TIMER; 1811 ksi.ksi_value = pt->pt_ev.sigev_value; 1812 pt->pt_poverruns = it->it_overruns; 1813 it->it_overruns = 0; 1814 itimer_unlock(); 1815 kpsignal(p, &ksi, NULL); 1816 itimer_lock(); 1817 } 1818 itimer_unlock(); 1819 mutex_exit(&proc_lock); 1820 } 1821