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