1 /*- 2 * Copyright (c) 1982, 1986, 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 4. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * @(#)kern_time.c 8.1 (Berkeley) 6/10/93 30 */ 31 32 #include <sys/cdefs.h> 33 __FBSDID("$FreeBSD$"); 34 35 #include "opt_ktrace.h" 36 37 #include <sys/param.h> 38 #include <sys/systm.h> 39 #include <sys/limits.h> 40 #include <sys/clock.h> 41 #include <sys/lock.h> 42 #include <sys/mutex.h> 43 #include <sys/sysproto.h> 44 #include <sys/eventhandler.h> 45 #include <sys/resourcevar.h> 46 #include <sys/signalvar.h> 47 #include <sys/kernel.h> 48 #include <sys/sleepqueue.h> 49 #include <sys/syscallsubr.h> 50 #include <sys/sysctl.h> 51 #include <sys/sysent.h> 52 #include <sys/priv.h> 53 #include <sys/proc.h> 54 #include <sys/posix4.h> 55 #include <sys/time.h> 56 #include <sys/timers.h> 57 #include <sys/timetc.h> 58 #include <sys/vnode.h> 59 #ifdef KTRACE 60 #include <sys/ktrace.h> 61 #endif 62 63 #include <vm/vm.h> 64 #include <vm/vm_extern.h> 65 66 #define MAX_CLOCKS (CLOCK_MONOTONIC+1) 67 #define CPUCLOCK_BIT 0x80000000 68 #define CPUCLOCK_PROCESS_BIT 0x40000000 69 #define CPUCLOCK_ID_MASK (~(CPUCLOCK_BIT|CPUCLOCK_PROCESS_BIT)) 70 #define MAKE_THREAD_CPUCLOCK(tid) (CPUCLOCK_BIT|(tid)) 71 #define MAKE_PROCESS_CPUCLOCK(pid) \ 72 (CPUCLOCK_BIT|CPUCLOCK_PROCESS_BIT|(pid)) 73 74 static struct kclock posix_clocks[MAX_CLOCKS]; 75 static uma_zone_t itimer_zone = NULL; 76 77 /* 78 * Time of day and interval timer support. 79 * 80 * These routines provide the kernel entry points to get and set 81 * the time-of-day and per-process interval timers. Subroutines 82 * here provide support for adding and subtracting timeval structures 83 * and decrementing interval timers, optionally reloading the interval 84 * timers when they expire. 85 */ 86 87 static int settime(struct thread *, struct timeval *); 88 static void timevalfix(struct timeval *); 89 90 static void itimer_start(void); 91 static int itimer_init(void *, int, int); 92 static void itimer_fini(void *, int); 93 static void itimer_enter(struct itimer *); 94 static void itimer_leave(struct itimer *); 95 static struct itimer *itimer_find(struct proc *, int); 96 static void itimers_alloc(struct proc *); 97 static void itimers_event_hook_exec(void *arg, struct proc *p, struct image_params *imgp); 98 static void itimers_event_hook_exit(void *arg, struct proc *p); 99 static int realtimer_create(struct itimer *); 100 static int realtimer_gettime(struct itimer *, struct itimerspec *); 101 static int realtimer_settime(struct itimer *, int, 102 struct itimerspec *, struct itimerspec *); 103 static int realtimer_delete(struct itimer *); 104 static void realtimer_clocktime(clockid_t, struct timespec *); 105 static void realtimer_expire(void *); 106 107 int register_posix_clock(int, struct kclock *); 108 void itimer_fire(struct itimer *it); 109 int itimespecfix(struct timespec *ts); 110 111 #define CLOCK_CALL(clock, call, arglist) \ 112 ((*posix_clocks[clock].call) arglist) 113 114 SYSINIT(posix_timer, SI_SUB_P1003_1B, SI_ORDER_FIRST+4, itimer_start, NULL); 115 116 117 static int 118 settime(struct thread *td, struct timeval *tv) 119 { 120 struct timeval delta, tv1, tv2; 121 static struct timeval maxtime, laststep; 122 struct timespec ts; 123 124 microtime(&tv1); 125 delta = *tv; 126 timevalsub(&delta, &tv1); 127 128 /* 129 * If the system is secure, we do not allow the time to be 130 * set to a value earlier than 1 second less than the highest 131 * time we have yet seen. The worst a miscreant can do in 132 * this circumstance is "freeze" time. He couldn't go 133 * back to the past. 134 * 135 * We similarly do not allow the clock to be stepped more 136 * than one second, nor more than once per second. This allows 137 * a miscreant to make the clock march double-time, but no worse. 138 */ 139 if (securelevel_gt(td->td_ucred, 1) != 0) { 140 if (delta.tv_sec < 0 || delta.tv_usec < 0) { 141 /* 142 * Update maxtime to latest time we've seen. 143 */ 144 if (tv1.tv_sec > maxtime.tv_sec) 145 maxtime = tv1; 146 tv2 = *tv; 147 timevalsub(&tv2, &maxtime); 148 if (tv2.tv_sec < -1) { 149 tv->tv_sec = maxtime.tv_sec - 1; 150 printf("Time adjustment clamped to -1 second\n"); 151 } 152 } else { 153 if (tv1.tv_sec == laststep.tv_sec) 154 return (EPERM); 155 if (delta.tv_sec > 1) { 156 tv->tv_sec = tv1.tv_sec + 1; 157 printf("Time adjustment clamped to +1 second\n"); 158 } 159 laststep = *tv; 160 } 161 } 162 163 ts.tv_sec = tv->tv_sec; 164 ts.tv_nsec = tv->tv_usec * 1000; 165 tc_setclock(&ts); 166 resettodr(); 167 return (0); 168 } 169 170 #ifndef _SYS_SYSPROTO_H_ 171 struct clock_getcpuclockid2_args { 172 id_t id; 173 int which, 174 clockid_t *clock_id; 175 }; 176 #endif 177 /* ARGSUSED */ 178 int 179 sys_clock_getcpuclockid2(struct thread *td, struct clock_getcpuclockid2_args *uap) 180 { 181 clockid_t clk_id; 182 int error; 183 184 error = kern_clock_getcpuclockid2(td, uap->id, uap->which, &clk_id); 185 if (error == 0) 186 error = copyout(&clk_id, uap->clock_id, sizeof(clockid_t)); 187 return (error); 188 } 189 190 int 191 kern_clock_getcpuclockid2(struct thread *td, id_t id, int which, 192 clockid_t *clk_id) 193 { 194 struct proc *p; 195 pid_t pid; 196 lwpid_t tid; 197 int error; 198 199 switch (which) { 200 case CPUCLOCK_WHICH_PID: 201 if (id != 0) { 202 error = pget(id, PGET_CANSEE | PGET_NOTID, &p); 203 if (error != 0) 204 return (error); 205 PROC_UNLOCK(p); 206 pid = id; 207 } else { 208 pid = td->td_proc->p_pid; 209 } 210 *clk_id = MAKE_PROCESS_CPUCLOCK(pid); 211 return (0); 212 case CPUCLOCK_WHICH_TID: 213 tid = id == 0 ? td->td_tid : id; 214 *clk_id = MAKE_THREAD_CPUCLOCK(tid); 215 return (0); 216 default: 217 return (EINVAL); 218 } 219 } 220 221 #ifndef _SYS_SYSPROTO_H_ 222 struct clock_gettime_args { 223 clockid_t clock_id; 224 struct timespec *tp; 225 }; 226 #endif 227 /* ARGSUSED */ 228 int 229 sys_clock_gettime(struct thread *td, struct clock_gettime_args *uap) 230 { 231 struct timespec ats; 232 int error; 233 234 error = kern_clock_gettime(td, uap->clock_id, &ats); 235 if (error == 0) 236 error = copyout(&ats, uap->tp, sizeof(ats)); 237 238 return (error); 239 } 240 241 static inline void 242 cputick2timespec(uint64_t runtime, struct timespec *ats) 243 { 244 runtime = cputick2usec(runtime); 245 ats->tv_sec = runtime / 1000000; 246 ats->tv_nsec = runtime % 1000000 * 1000; 247 } 248 249 static void 250 get_thread_cputime(struct thread *targettd, struct timespec *ats) 251 { 252 uint64_t runtime, curtime, switchtime; 253 254 if (targettd == NULL) { /* current thread */ 255 critical_enter(); 256 switchtime = PCPU_GET(switchtime); 257 curtime = cpu_ticks(); 258 runtime = curthread->td_runtime; 259 critical_exit(); 260 runtime += curtime - switchtime; 261 } else { 262 thread_lock(targettd); 263 runtime = targettd->td_runtime; 264 thread_unlock(targettd); 265 } 266 cputick2timespec(runtime, ats); 267 } 268 269 static void 270 get_process_cputime(struct proc *targetp, struct timespec *ats) 271 { 272 uint64_t runtime; 273 struct rusage ru; 274 275 PROC_STATLOCK(targetp); 276 rufetch(targetp, &ru); 277 runtime = targetp->p_rux.rux_runtime; 278 PROC_STATUNLOCK(targetp); 279 cputick2timespec(runtime, ats); 280 } 281 282 static int 283 get_cputime(struct thread *td, clockid_t clock_id, struct timespec *ats) 284 { 285 struct proc *p, *p2; 286 struct thread *td2; 287 lwpid_t tid; 288 pid_t pid; 289 int error; 290 291 p = td->td_proc; 292 if ((clock_id & CPUCLOCK_PROCESS_BIT) == 0) { 293 tid = clock_id & CPUCLOCK_ID_MASK; 294 td2 = tdfind(tid, p->p_pid); 295 if (td2 == NULL) 296 return (EINVAL); 297 get_thread_cputime(td2, ats); 298 PROC_UNLOCK(td2->td_proc); 299 } else { 300 pid = clock_id & CPUCLOCK_ID_MASK; 301 error = pget(pid, PGET_CANSEE, &p2); 302 if (error != 0) 303 return (EINVAL); 304 get_process_cputime(p2, ats); 305 PROC_UNLOCK(p2); 306 } 307 return (0); 308 } 309 310 int 311 kern_clock_gettime(struct thread *td, clockid_t clock_id, struct timespec *ats) 312 { 313 struct timeval sys, user; 314 struct proc *p; 315 316 p = td->td_proc; 317 switch (clock_id) { 318 case CLOCK_REALTIME: /* Default to precise. */ 319 case CLOCK_REALTIME_PRECISE: 320 nanotime(ats); 321 break; 322 case CLOCK_REALTIME_FAST: 323 getnanotime(ats); 324 break; 325 case CLOCK_VIRTUAL: 326 PROC_LOCK(p); 327 PROC_STATLOCK(p); 328 calcru(p, &user, &sys); 329 PROC_STATUNLOCK(p); 330 PROC_UNLOCK(p); 331 TIMEVAL_TO_TIMESPEC(&user, ats); 332 break; 333 case CLOCK_PROF: 334 PROC_LOCK(p); 335 PROC_STATLOCK(p); 336 calcru(p, &user, &sys); 337 PROC_STATUNLOCK(p); 338 PROC_UNLOCK(p); 339 timevaladd(&user, &sys); 340 TIMEVAL_TO_TIMESPEC(&user, ats); 341 break; 342 case CLOCK_MONOTONIC: /* Default to precise. */ 343 case CLOCK_MONOTONIC_PRECISE: 344 case CLOCK_UPTIME: 345 case CLOCK_UPTIME_PRECISE: 346 nanouptime(ats); 347 break; 348 case CLOCK_UPTIME_FAST: 349 case CLOCK_MONOTONIC_FAST: 350 getnanouptime(ats); 351 break; 352 case CLOCK_SECOND: 353 ats->tv_sec = time_second; 354 ats->tv_nsec = 0; 355 break; 356 case CLOCK_THREAD_CPUTIME_ID: 357 get_thread_cputime(NULL, ats); 358 break; 359 case CLOCK_PROCESS_CPUTIME_ID: 360 PROC_LOCK(p); 361 get_process_cputime(p, ats); 362 PROC_UNLOCK(p); 363 break; 364 default: 365 if ((int)clock_id >= 0) 366 return (EINVAL); 367 return (get_cputime(td, clock_id, ats)); 368 } 369 return (0); 370 } 371 372 #ifndef _SYS_SYSPROTO_H_ 373 struct clock_settime_args { 374 clockid_t clock_id; 375 const struct timespec *tp; 376 }; 377 #endif 378 /* ARGSUSED */ 379 int 380 sys_clock_settime(struct thread *td, struct clock_settime_args *uap) 381 { 382 struct timespec ats; 383 int error; 384 385 if ((error = copyin(uap->tp, &ats, sizeof(ats))) != 0) 386 return (error); 387 return (kern_clock_settime(td, uap->clock_id, &ats)); 388 } 389 390 int 391 kern_clock_settime(struct thread *td, clockid_t clock_id, struct timespec *ats) 392 { 393 struct timeval atv; 394 int error; 395 396 if ((error = priv_check(td, PRIV_CLOCK_SETTIME)) != 0) 397 return (error); 398 if (clock_id != CLOCK_REALTIME) 399 return (EINVAL); 400 if (ats->tv_nsec < 0 || ats->tv_nsec >= 1000000000 || 401 ats->tv_sec < 0) 402 return (EINVAL); 403 /* XXX Don't convert nsec->usec and back */ 404 TIMESPEC_TO_TIMEVAL(&atv, ats); 405 error = settime(td, &atv); 406 return (error); 407 } 408 409 #ifndef _SYS_SYSPROTO_H_ 410 struct clock_getres_args { 411 clockid_t clock_id; 412 struct timespec *tp; 413 }; 414 #endif 415 int 416 sys_clock_getres(struct thread *td, struct clock_getres_args *uap) 417 { 418 struct timespec ts; 419 int error; 420 421 if (uap->tp == NULL) 422 return (0); 423 424 error = kern_clock_getres(td, uap->clock_id, &ts); 425 if (error == 0) 426 error = copyout(&ts, uap->tp, sizeof(ts)); 427 return (error); 428 } 429 430 int 431 kern_clock_getres(struct thread *td, clockid_t clock_id, struct timespec *ts) 432 { 433 434 ts->tv_sec = 0; 435 switch (clock_id) { 436 case CLOCK_REALTIME: 437 case CLOCK_REALTIME_FAST: 438 case CLOCK_REALTIME_PRECISE: 439 case CLOCK_MONOTONIC: 440 case CLOCK_MONOTONIC_FAST: 441 case CLOCK_MONOTONIC_PRECISE: 442 case CLOCK_UPTIME: 443 case CLOCK_UPTIME_FAST: 444 case CLOCK_UPTIME_PRECISE: 445 /* 446 * Round up the result of the division cheaply by adding 1. 447 * Rounding up is especially important if rounding down 448 * would give 0. Perfect rounding is unimportant. 449 */ 450 ts->tv_nsec = 1000000000 / tc_getfrequency() + 1; 451 break; 452 case CLOCK_VIRTUAL: 453 case CLOCK_PROF: 454 /* Accurately round up here because we can do so cheaply. */ 455 ts->tv_nsec = howmany(1000000000, hz); 456 break; 457 case CLOCK_SECOND: 458 ts->tv_sec = 1; 459 ts->tv_nsec = 0; 460 break; 461 case CLOCK_THREAD_CPUTIME_ID: 462 case CLOCK_PROCESS_CPUTIME_ID: 463 cputime: 464 /* sync with cputick2usec */ 465 ts->tv_nsec = 1000000 / cpu_tickrate(); 466 if (ts->tv_nsec == 0) 467 ts->tv_nsec = 1000; 468 break; 469 default: 470 if ((int)clock_id < 0) 471 goto cputime; 472 return (EINVAL); 473 } 474 return (0); 475 } 476 477 static uint8_t nanowait[MAXCPU]; 478 479 int 480 kern_nanosleep(struct thread *td, struct timespec *rqt, struct timespec *rmt) 481 { 482 struct timespec ts; 483 sbintime_t sbt, sbtt, prec, tmp; 484 time_t over; 485 int error; 486 487 if (rqt->tv_nsec < 0 || rqt->tv_nsec >= 1000000000) 488 return (EINVAL); 489 if (rqt->tv_sec < 0 || (rqt->tv_sec == 0 && rqt->tv_nsec == 0)) 490 return (0); 491 ts = *rqt; 492 if (ts.tv_sec > INT32_MAX / 2) { 493 over = ts.tv_sec - INT32_MAX / 2; 494 ts.tv_sec -= over; 495 } else 496 over = 0; 497 tmp = tstosbt(ts); 498 prec = tmp; 499 prec >>= tc_precexp; 500 if (TIMESEL(&sbt, tmp)) 501 sbt += tc_tick_sbt; 502 sbt += tmp; 503 error = tsleep_sbt(&nanowait[curcpu], PWAIT | PCATCH, "nanslp", 504 sbt, prec, C_ABSOLUTE); 505 if (error != EWOULDBLOCK) { 506 if (error == ERESTART) 507 error = EINTR; 508 TIMESEL(&sbtt, tmp); 509 if (rmt != NULL) { 510 ts = sbttots(sbt - sbtt); 511 ts.tv_sec += over; 512 if (ts.tv_sec < 0) 513 timespecclear(&ts); 514 *rmt = ts; 515 } 516 if (sbtt >= sbt) 517 return (0); 518 return (error); 519 } 520 return (0); 521 } 522 523 #ifndef _SYS_SYSPROTO_H_ 524 struct nanosleep_args { 525 struct timespec *rqtp; 526 struct timespec *rmtp; 527 }; 528 #endif 529 /* ARGSUSED */ 530 int 531 sys_nanosleep(struct thread *td, struct nanosleep_args *uap) 532 { 533 struct timespec rmt, rqt; 534 int error; 535 536 error = copyin(uap->rqtp, &rqt, sizeof(rqt)); 537 if (error) 538 return (error); 539 540 if (uap->rmtp && 541 !useracc((caddr_t)uap->rmtp, sizeof(rmt), VM_PROT_WRITE)) 542 return (EFAULT); 543 error = kern_nanosleep(td, &rqt, &rmt); 544 if (error && uap->rmtp) { 545 int error2; 546 547 error2 = copyout(&rmt, uap->rmtp, sizeof(rmt)); 548 if (error2) 549 error = error2; 550 } 551 return (error); 552 } 553 554 #ifndef _SYS_SYSPROTO_H_ 555 struct gettimeofday_args { 556 struct timeval *tp; 557 struct timezone *tzp; 558 }; 559 #endif 560 /* ARGSUSED */ 561 int 562 sys_gettimeofday(struct thread *td, struct gettimeofday_args *uap) 563 { 564 struct timeval atv; 565 struct timezone rtz; 566 int error = 0; 567 568 if (uap->tp) { 569 microtime(&atv); 570 error = copyout(&atv, uap->tp, sizeof (atv)); 571 } 572 if (error == 0 && uap->tzp != NULL) { 573 rtz.tz_minuteswest = tz_minuteswest; 574 rtz.tz_dsttime = tz_dsttime; 575 error = copyout(&rtz, uap->tzp, sizeof (rtz)); 576 } 577 return (error); 578 } 579 580 #ifndef _SYS_SYSPROTO_H_ 581 struct settimeofday_args { 582 struct timeval *tv; 583 struct timezone *tzp; 584 }; 585 #endif 586 /* ARGSUSED */ 587 int 588 sys_settimeofday(struct thread *td, struct settimeofday_args *uap) 589 { 590 struct timeval atv, *tvp; 591 struct timezone atz, *tzp; 592 int error; 593 594 if (uap->tv) { 595 error = copyin(uap->tv, &atv, sizeof(atv)); 596 if (error) 597 return (error); 598 tvp = &atv; 599 } else 600 tvp = NULL; 601 if (uap->tzp) { 602 error = copyin(uap->tzp, &atz, sizeof(atz)); 603 if (error) 604 return (error); 605 tzp = &atz; 606 } else 607 tzp = NULL; 608 return (kern_settimeofday(td, tvp, tzp)); 609 } 610 611 int 612 kern_settimeofday(struct thread *td, struct timeval *tv, struct timezone *tzp) 613 { 614 int error; 615 616 error = priv_check(td, PRIV_SETTIMEOFDAY); 617 if (error) 618 return (error); 619 /* Verify all parameters before changing time. */ 620 if (tv) { 621 if (tv->tv_usec < 0 || tv->tv_usec >= 1000000 || 622 tv->tv_sec < 0) 623 return (EINVAL); 624 error = settime(td, tv); 625 } 626 if (tzp && error == 0) { 627 tz_minuteswest = tzp->tz_minuteswest; 628 tz_dsttime = tzp->tz_dsttime; 629 } 630 return (error); 631 } 632 633 /* 634 * Get value of an interval timer. The process virtual and profiling virtual 635 * time timers are kept in the p_stats area, since they can be swapped out. 636 * These are kept internally in the way they are specified externally: in 637 * time until they expire. 638 * 639 * The real time interval timer is kept in the process table slot for the 640 * process, and its value (it_value) is kept as an absolute time rather than 641 * as a delta, so that it is easy to keep periodic real-time signals from 642 * drifting. 643 * 644 * Virtual time timers are processed in the hardclock() routine of 645 * kern_clock.c. The real time timer is processed by a timeout routine, 646 * called from the softclock() routine. Since a callout may be delayed in 647 * real time due to interrupt processing in the system, it is possible for 648 * the real time timeout routine (realitexpire, given below), to be delayed 649 * in real time past when it is supposed to occur. It does not suffice, 650 * therefore, to reload the real timer .it_value from the real time timers 651 * .it_interval. Rather, we compute the next time in absolute time the timer 652 * should go off. 653 */ 654 #ifndef _SYS_SYSPROTO_H_ 655 struct getitimer_args { 656 u_int which; 657 struct itimerval *itv; 658 }; 659 #endif 660 int 661 sys_getitimer(struct thread *td, struct getitimer_args *uap) 662 { 663 struct itimerval aitv; 664 int error; 665 666 error = kern_getitimer(td, uap->which, &aitv); 667 if (error != 0) 668 return (error); 669 return (copyout(&aitv, uap->itv, sizeof (struct itimerval))); 670 } 671 672 int 673 kern_getitimer(struct thread *td, u_int which, struct itimerval *aitv) 674 { 675 struct proc *p = td->td_proc; 676 struct timeval ctv; 677 678 if (which > ITIMER_PROF) 679 return (EINVAL); 680 681 if (which == ITIMER_REAL) { 682 /* 683 * Convert from absolute to relative time in .it_value 684 * part of real time timer. If time for real time timer 685 * has passed return 0, else return difference between 686 * current time and time for the timer to go off. 687 */ 688 PROC_LOCK(p); 689 *aitv = p->p_realtimer; 690 PROC_UNLOCK(p); 691 if (timevalisset(&aitv->it_value)) { 692 microuptime(&ctv); 693 if (timevalcmp(&aitv->it_value, &ctv, <)) 694 timevalclear(&aitv->it_value); 695 else 696 timevalsub(&aitv->it_value, &ctv); 697 } 698 } else { 699 PROC_ITIMLOCK(p); 700 *aitv = p->p_stats->p_timer[which]; 701 PROC_ITIMUNLOCK(p); 702 } 703 #ifdef KTRACE 704 if (KTRPOINT(td, KTR_STRUCT)) 705 ktritimerval(aitv); 706 #endif 707 return (0); 708 } 709 710 #ifndef _SYS_SYSPROTO_H_ 711 struct setitimer_args { 712 u_int which; 713 struct itimerval *itv, *oitv; 714 }; 715 #endif 716 int 717 sys_setitimer(struct thread *td, struct setitimer_args *uap) 718 { 719 struct itimerval aitv, oitv; 720 int error; 721 722 if (uap->itv == NULL) { 723 uap->itv = uap->oitv; 724 return (sys_getitimer(td, (struct getitimer_args *)uap)); 725 } 726 727 if ((error = copyin(uap->itv, &aitv, sizeof(struct itimerval)))) 728 return (error); 729 error = kern_setitimer(td, uap->which, &aitv, &oitv); 730 if (error != 0 || uap->oitv == NULL) 731 return (error); 732 return (copyout(&oitv, uap->oitv, sizeof(struct itimerval))); 733 } 734 735 int 736 kern_setitimer(struct thread *td, u_int which, struct itimerval *aitv, 737 struct itimerval *oitv) 738 { 739 struct proc *p = td->td_proc; 740 struct timeval ctv; 741 sbintime_t sbt, pr; 742 743 if (aitv == NULL) 744 return (kern_getitimer(td, which, oitv)); 745 746 if (which > ITIMER_PROF) 747 return (EINVAL); 748 #ifdef KTRACE 749 if (KTRPOINT(td, KTR_STRUCT)) 750 ktritimerval(aitv); 751 #endif 752 if (itimerfix(&aitv->it_value) || 753 aitv->it_value.tv_sec > INT32_MAX / 2) 754 return (EINVAL); 755 if (!timevalisset(&aitv->it_value)) 756 timevalclear(&aitv->it_interval); 757 else if (itimerfix(&aitv->it_interval) || 758 aitv->it_interval.tv_sec > INT32_MAX / 2) 759 return (EINVAL); 760 761 if (which == ITIMER_REAL) { 762 PROC_LOCK(p); 763 if (timevalisset(&p->p_realtimer.it_value)) 764 callout_stop(&p->p_itcallout); 765 microuptime(&ctv); 766 if (timevalisset(&aitv->it_value)) { 767 pr = tvtosbt(aitv->it_value) >> tc_precexp; 768 timevaladd(&aitv->it_value, &ctv); 769 sbt = tvtosbt(aitv->it_value); 770 callout_reset_sbt(&p->p_itcallout, sbt, pr, 771 realitexpire, p, C_ABSOLUTE); 772 } 773 *oitv = p->p_realtimer; 774 p->p_realtimer = *aitv; 775 PROC_UNLOCK(p); 776 if (timevalisset(&oitv->it_value)) { 777 if (timevalcmp(&oitv->it_value, &ctv, <)) 778 timevalclear(&oitv->it_value); 779 else 780 timevalsub(&oitv->it_value, &ctv); 781 } 782 } else { 783 if (aitv->it_interval.tv_sec == 0 && 784 aitv->it_interval.tv_usec != 0 && 785 aitv->it_interval.tv_usec < tick) 786 aitv->it_interval.tv_usec = tick; 787 if (aitv->it_value.tv_sec == 0 && 788 aitv->it_value.tv_usec != 0 && 789 aitv->it_value.tv_usec < tick) 790 aitv->it_value.tv_usec = tick; 791 PROC_ITIMLOCK(p); 792 *oitv = p->p_stats->p_timer[which]; 793 p->p_stats->p_timer[which] = *aitv; 794 PROC_ITIMUNLOCK(p); 795 } 796 #ifdef KTRACE 797 if (KTRPOINT(td, KTR_STRUCT)) 798 ktritimerval(oitv); 799 #endif 800 return (0); 801 } 802 803 /* 804 * Real interval timer expired: 805 * send process whose timer expired an alarm signal. 806 * If time is not set up to reload, then just return. 807 * Else compute next time timer should go off which is > current time. 808 * This is where delay in processing this timeout causes multiple 809 * SIGALRM calls to be compressed into one. 810 * tvtohz() always adds 1 to allow for the time until the next clock 811 * interrupt being strictly less than 1 clock tick, but we don't want 812 * that here since we want to appear to be in sync with the clock 813 * interrupt even when we're delayed. 814 */ 815 void 816 realitexpire(void *arg) 817 { 818 struct proc *p; 819 struct timeval ctv; 820 sbintime_t isbt; 821 822 p = (struct proc *)arg; 823 kern_psignal(p, SIGALRM); 824 if (!timevalisset(&p->p_realtimer.it_interval)) { 825 timevalclear(&p->p_realtimer.it_value); 826 if (p->p_flag & P_WEXIT) 827 wakeup(&p->p_itcallout); 828 return; 829 } 830 isbt = tvtosbt(p->p_realtimer.it_interval); 831 if (isbt >= sbt_timethreshold) 832 getmicrouptime(&ctv); 833 else 834 microuptime(&ctv); 835 do { 836 timevaladd(&p->p_realtimer.it_value, 837 &p->p_realtimer.it_interval); 838 } while (timevalcmp(&p->p_realtimer.it_value, &ctv, <=)); 839 callout_reset_sbt(&p->p_itcallout, tvtosbt(p->p_realtimer.it_value), 840 isbt >> tc_precexp, realitexpire, p, C_ABSOLUTE); 841 } 842 843 /* 844 * Check that a proposed value to load into the .it_value or 845 * .it_interval part of an interval timer is acceptable, and 846 * fix it to have at least minimal value (i.e. if it is less 847 * than the resolution of the clock, round it up.) 848 */ 849 int 850 itimerfix(struct timeval *tv) 851 { 852 853 if (tv->tv_sec < 0 || tv->tv_usec < 0 || tv->tv_usec >= 1000000) 854 return (EINVAL); 855 if (tv->tv_sec == 0 && tv->tv_usec != 0 && 856 tv->tv_usec < (u_int)tick / 16) 857 tv->tv_usec = (u_int)tick / 16; 858 return (0); 859 } 860 861 /* 862 * Decrement an interval timer by a specified number 863 * of microseconds, which must be less than a second, 864 * i.e. < 1000000. If the timer expires, then reload 865 * it. In this case, carry over (usec - old value) to 866 * reduce the value reloaded into the timer so that 867 * the timer does not drift. This routine assumes 868 * that it is called in a context where the timers 869 * on which it is operating cannot change in value. 870 */ 871 int 872 itimerdecr(struct itimerval *itp, int usec) 873 { 874 875 if (itp->it_value.tv_usec < usec) { 876 if (itp->it_value.tv_sec == 0) { 877 /* expired, and already in next interval */ 878 usec -= itp->it_value.tv_usec; 879 goto expire; 880 } 881 itp->it_value.tv_usec += 1000000; 882 itp->it_value.tv_sec--; 883 } 884 itp->it_value.tv_usec -= usec; 885 usec = 0; 886 if (timevalisset(&itp->it_value)) 887 return (1); 888 /* expired, exactly at end of interval */ 889 expire: 890 if (timevalisset(&itp->it_interval)) { 891 itp->it_value = itp->it_interval; 892 itp->it_value.tv_usec -= usec; 893 if (itp->it_value.tv_usec < 0) { 894 itp->it_value.tv_usec += 1000000; 895 itp->it_value.tv_sec--; 896 } 897 } else 898 itp->it_value.tv_usec = 0; /* sec is already 0 */ 899 return (0); 900 } 901 902 /* 903 * Add and subtract routines for timevals. 904 * N.B.: subtract routine doesn't deal with 905 * results which are before the beginning, 906 * it just gets very confused in this case. 907 * Caveat emptor. 908 */ 909 void 910 timevaladd(struct timeval *t1, const struct timeval *t2) 911 { 912 913 t1->tv_sec += t2->tv_sec; 914 t1->tv_usec += t2->tv_usec; 915 timevalfix(t1); 916 } 917 918 void 919 timevalsub(struct timeval *t1, const struct timeval *t2) 920 { 921 922 t1->tv_sec -= t2->tv_sec; 923 t1->tv_usec -= t2->tv_usec; 924 timevalfix(t1); 925 } 926 927 static void 928 timevalfix(struct timeval *t1) 929 { 930 931 if (t1->tv_usec < 0) { 932 t1->tv_sec--; 933 t1->tv_usec += 1000000; 934 } 935 if (t1->tv_usec >= 1000000) { 936 t1->tv_sec++; 937 t1->tv_usec -= 1000000; 938 } 939 } 940 941 /* 942 * ratecheck(): simple time-based rate-limit checking. 943 */ 944 int 945 ratecheck(struct timeval *lasttime, const struct timeval *mininterval) 946 { 947 struct timeval tv, delta; 948 int rv = 0; 949 950 getmicrouptime(&tv); /* NB: 10ms precision */ 951 delta = tv; 952 timevalsub(&delta, lasttime); 953 954 /* 955 * check for 0,0 is so that the message will be seen at least once, 956 * even if interval is huge. 957 */ 958 if (timevalcmp(&delta, mininterval, >=) || 959 (lasttime->tv_sec == 0 && lasttime->tv_usec == 0)) { 960 *lasttime = tv; 961 rv = 1; 962 } 963 964 return (rv); 965 } 966 967 /* 968 * ppsratecheck(): packets (or events) per second limitation. 969 * 970 * Return 0 if the limit is to be enforced (e.g. the caller 971 * should drop a packet because of the rate limitation). 972 * 973 * maxpps of 0 always causes zero to be returned. maxpps of -1 974 * always causes 1 to be returned; this effectively defeats rate 975 * limiting. 976 * 977 * Note that we maintain the struct timeval for compatibility 978 * with other bsd systems. We reuse the storage and just monitor 979 * clock ticks for minimal overhead. 980 */ 981 int 982 ppsratecheck(struct timeval *lasttime, int *curpps, int maxpps) 983 { 984 int now; 985 986 /* 987 * Reset the last time and counter if this is the first call 988 * or more than a second has passed since the last update of 989 * lasttime. 990 */ 991 now = ticks; 992 if (lasttime->tv_sec == 0 || (u_int)(now - lasttime->tv_sec) >= hz) { 993 lasttime->tv_sec = now; 994 *curpps = 1; 995 return (maxpps != 0); 996 } else { 997 (*curpps)++; /* NB: ignore potential overflow */ 998 return (maxpps < 0 || *curpps <= maxpps); 999 } 1000 } 1001 1002 static void 1003 itimer_start(void) 1004 { 1005 struct kclock rt_clock = { 1006 .timer_create = realtimer_create, 1007 .timer_delete = realtimer_delete, 1008 .timer_settime = realtimer_settime, 1009 .timer_gettime = realtimer_gettime, 1010 .event_hook = NULL 1011 }; 1012 1013 itimer_zone = uma_zcreate("itimer", sizeof(struct itimer), 1014 NULL, NULL, itimer_init, itimer_fini, UMA_ALIGN_PTR, 0); 1015 register_posix_clock(CLOCK_REALTIME, &rt_clock); 1016 register_posix_clock(CLOCK_MONOTONIC, &rt_clock); 1017 p31b_setcfg(CTL_P1003_1B_TIMERS, 200112L); 1018 p31b_setcfg(CTL_P1003_1B_DELAYTIMER_MAX, INT_MAX); 1019 p31b_setcfg(CTL_P1003_1B_TIMER_MAX, TIMER_MAX); 1020 EVENTHANDLER_REGISTER(process_exit, itimers_event_hook_exit, 1021 (void *)ITIMER_EV_EXIT, EVENTHANDLER_PRI_ANY); 1022 EVENTHANDLER_REGISTER(process_exec, itimers_event_hook_exec, 1023 (void *)ITIMER_EV_EXEC, EVENTHANDLER_PRI_ANY); 1024 } 1025 1026 int 1027 register_posix_clock(int clockid, struct kclock *clk) 1028 { 1029 if ((unsigned)clockid >= MAX_CLOCKS) { 1030 printf("%s: invalid clockid\n", __func__); 1031 return (0); 1032 } 1033 posix_clocks[clockid] = *clk; 1034 return (1); 1035 } 1036 1037 static int 1038 itimer_init(void *mem, int size, int flags) 1039 { 1040 struct itimer *it; 1041 1042 it = (struct itimer *)mem; 1043 mtx_init(&it->it_mtx, "itimer lock", NULL, MTX_DEF); 1044 return (0); 1045 } 1046 1047 static void 1048 itimer_fini(void *mem, int size) 1049 { 1050 struct itimer *it; 1051 1052 it = (struct itimer *)mem; 1053 mtx_destroy(&it->it_mtx); 1054 } 1055 1056 static void 1057 itimer_enter(struct itimer *it) 1058 { 1059 1060 mtx_assert(&it->it_mtx, MA_OWNED); 1061 it->it_usecount++; 1062 } 1063 1064 static void 1065 itimer_leave(struct itimer *it) 1066 { 1067 1068 mtx_assert(&it->it_mtx, MA_OWNED); 1069 KASSERT(it->it_usecount > 0, ("invalid it_usecount")); 1070 1071 if (--it->it_usecount == 0 && (it->it_flags & ITF_WANTED) != 0) 1072 wakeup(it); 1073 } 1074 1075 #ifndef _SYS_SYSPROTO_H_ 1076 struct ktimer_create_args { 1077 clockid_t clock_id; 1078 struct sigevent * evp; 1079 int * timerid; 1080 }; 1081 #endif 1082 int 1083 sys_ktimer_create(struct thread *td, struct ktimer_create_args *uap) 1084 { 1085 struct sigevent *evp, ev; 1086 int id; 1087 int error; 1088 1089 if (uap->evp == NULL) { 1090 evp = NULL; 1091 } else { 1092 error = copyin(uap->evp, &ev, sizeof(ev)); 1093 if (error != 0) 1094 return (error); 1095 evp = &ev; 1096 } 1097 error = kern_ktimer_create(td, uap->clock_id, evp, &id, -1); 1098 if (error == 0) { 1099 error = copyout(&id, uap->timerid, sizeof(int)); 1100 if (error != 0) 1101 kern_ktimer_delete(td, id); 1102 } 1103 return (error); 1104 } 1105 1106 int 1107 kern_ktimer_create(struct thread *td, clockid_t clock_id, struct sigevent *evp, 1108 int *timerid, int preset_id) 1109 { 1110 struct proc *p = td->td_proc; 1111 struct itimer *it; 1112 int id; 1113 int error; 1114 1115 if (clock_id < 0 || clock_id >= MAX_CLOCKS) 1116 return (EINVAL); 1117 1118 if (posix_clocks[clock_id].timer_create == NULL) 1119 return (EINVAL); 1120 1121 if (evp != NULL) { 1122 if (evp->sigev_notify != SIGEV_NONE && 1123 evp->sigev_notify != SIGEV_SIGNAL && 1124 evp->sigev_notify != SIGEV_THREAD_ID) 1125 return (EINVAL); 1126 if ((evp->sigev_notify == SIGEV_SIGNAL || 1127 evp->sigev_notify == SIGEV_THREAD_ID) && 1128 !_SIG_VALID(evp->sigev_signo)) 1129 return (EINVAL); 1130 } 1131 1132 if (p->p_itimers == NULL) 1133 itimers_alloc(p); 1134 1135 it = uma_zalloc(itimer_zone, M_WAITOK); 1136 it->it_flags = 0; 1137 it->it_usecount = 0; 1138 it->it_active = 0; 1139 timespecclear(&it->it_time.it_value); 1140 timespecclear(&it->it_time.it_interval); 1141 it->it_overrun = 0; 1142 it->it_overrun_last = 0; 1143 it->it_clockid = clock_id; 1144 it->it_timerid = -1; 1145 it->it_proc = p; 1146 ksiginfo_init(&it->it_ksi); 1147 it->it_ksi.ksi_flags |= KSI_INS | KSI_EXT; 1148 error = CLOCK_CALL(clock_id, timer_create, (it)); 1149 if (error != 0) 1150 goto out; 1151 1152 PROC_LOCK(p); 1153 if (preset_id != -1) { 1154 KASSERT(preset_id >= 0 && preset_id < 3, ("invalid preset_id")); 1155 id = preset_id; 1156 if (p->p_itimers->its_timers[id] != NULL) { 1157 PROC_UNLOCK(p); 1158 error = 0; 1159 goto out; 1160 } 1161 } else { 1162 /* 1163 * Find a free timer slot, skipping those reserved 1164 * for setitimer(). 1165 */ 1166 for (id = 3; id < TIMER_MAX; id++) 1167 if (p->p_itimers->its_timers[id] == NULL) 1168 break; 1169 if (id == TIMER_MAX) { 1170 PROC_UNLOCK(p); 1171 error = EAGAIN; 1172 goto out; 1173 } 1174 } 1175 it->it_timerid = id; 1176 p->p_itimers->its_timers[id] = it; 1177 if (evp != NULL) 1178 it->it_sigev = *evp; 1179 else { 1180 it->it_sigev.sigev_notify = SIGEV_SIGNAL; 1181 switch (clock_id) { 1182 default: 1183 case CLOCK_REALTIME: 1184 it->it_sigev.sigev_signo = SIGALRM; 1185 break; 1186 case CLOCK_VIRTUAL: 1187 it->it_sigev.sigev_signo = SIGVTALRM; 1188 break; 1189 case CLOCK_PROF: 1190 it->it_sigev.sigev_signo = SIGPROF; 1191 break; 1192 } 1193 it->it_sigev.sigev_value.sival_int = id; 1194 } 1195 1196 if (it->it_sigev.sigev_notify == SIGEV_SIGNAL || 1197 it->it_sigev.sigev_notify == SIGEV_THREAD_ID) { 1198 it->it_ksi.ksi_signo = it->it_sigev.sigev_signo; 1199 it->it_ksi.ksi_code = SI_TIMER; 1200 it->it_ksi.ksi_value = it->it_sigev.sigev_value; 1201 it->it_ksi.ksi_timerid = id; 1202 } 1203 PROC_UNLOCK(p); 1204 *timerid = id; 1205 return (0); 1206 1207 out: 1208 ITIMER_LOCK(it); 1209 CLOCK_CALL(it->it_clockid, timer_delete, (it)); 1210 ITIMER_UNLOCK(it); 1211 uma_zfree(itimer_zone, it); 1212 return (error); 1213 } 1214 1215 #ifndef _SYS_SYSPROTO_H_ 1216 struct ktimer_delete_args { 1217 int timerid; 1218 }; 1219 #endif 1220 int 1221 sys_ktimer_delete(struct thread *td, struct ktimer_delete_args *uap) 1222 { 1223 1224 return (kern_ktimer_delete(td, uap->timerid)); 1225 } 1226 1227 static struct itimer * 1228 itimer_find(struct proc *p, int timerid) 1229 { 1230 struct itimer *it; 1231 1232 PROC_LOCK_ASSERT(p, MA_OWNED); 1233 if ((p->p_itimers == NULL) || 1234 (timerid < 0) || (timerid >= TIMER_MAX) || 1235 (it = p->p_itimers->its_timers[timerid]) == NULL) { 1236 return (NULL); 1237 } 1238 ITIMER_LOCK(it); 1239 if ((it->it_flags & ITF_DELETING) != 0) { 1240 ITIMER_UNLOCK(it); 1241 it = NULL; 1242 } 1243 return (it); 1244 } 1245 1246 int 1247 kern_ktimer_delete(struct thread *td, int timerid) 1248 { 1249 struct proc *p = td->td_proc; 1250 struct itimer *it; 1251 1252 PROC_LOCK(p); 1253 it = itimer_find(p, timerid); 1254 if (it == NULL) { 1255 PROC_UNLOCK(p); 1256 return (EINVAL); 1257 } 1258 PROC_UNLOCK(p); 1259 1260 it->it_flags |= ITF_DELETING; 1261 while (it->it_usecount > 0) { 1262 it->it_flags |= ITF_WANTED; 1263 msleep(it, &it->it_mtx, PPAUSE, "itimer", 0); 1264 } 1265 it->it_flags &= ~ITF_WANTED; 1266 CLOCK_CALL(it->it_clockid, timer_delete, (it)); 1267 ITIMER_UNLOCK(it); 1268 1269 PROC_LOCK(p); 1270 if (KSI_ONQ(&it->it_ksi)) 1271 sigqueue_take(&it->it_ksi); 1272 p->p_itimers->its_timers[timerid] = NULL; 1273 PROC_UNLOCK(p); 1274 uma_zfree(itimer_zone, it); 1275 return (0); 1276 } 1277 1278 #ifndef _SYS_SYSPROTO_H_ 1279 struct ktimer_settime_args { 1280 int timerid; 1281 int flags; 1282 const struct itimerspec * value; 1283 struct itimerspec * ovalue; 1284 }; 1285 #endif 1286 int 1287 sys_ktimer_settime(struct thread *td, struct ktimer_settime_args *uap) 1288 { 1289 struct itimerspec val, oval, *ovalp; 1290 int error; 1291 1292 error = copyin(uap->value, &val, sizeof(val)); 1293 if (error != 0) 1294 return (error); 1295 ovalp = uap->ovalue != NULL ? &oval : NULL; 1296 error = kern_ktimer_settime(td, uap->timerid, uap->flags, &val, ovalp); 1297 if (error == 0 && uap->ovalue != NULL) 1298 error = copyout(ovalp, uap->ovalue, sizeof(*ovalp)); 1299 return (error); 1300 } 1301 1302 int 1303 kern_ktimer_settime(struct thread *td, int timer_id, int flags, 1304 struct itimerspec *val, struct itimerspec *oval) 1305 { 1306 struct proc *p; 1307 struct itimer *it; 1308 int error; 1309 1310 p = td->td_proc; 1311 PROC_LOCK(p); 1312 if (timer_id < 3 || (it = itimer_find(p, timer_id)) == NULL) { 1313 PROC_UNLOCK(p); 1314 error = EINVAL; 1315 } else { 1316 PROC_UNLOCK(p); 1317 itimer_enter(it); 1318 error = CLOCK_CALL(it->it_clockid, timer_settime, (it, 1319 flags, val, oval)); 1320 itimer_leave(it); 1321 ITIMER_UNLOCK(it); 1322 } 1323 return (error); 1324 } 1325 1326 #ifndef _SYS_SYSPROTO_H_ 1327 struct ktimer_gettime_args { 1328 int timerid; 1329 struct itimerspec * value; 1330 }; 1331 #endif 1332 int 1333 sys_ktimer_gettime(struct thread *td, struct ktimer_gettime_args *uap) 1334 { 1335 struct itimerspec val; 1336 int error; 1337 1338 error = kern_ktimer_gettime(td, uap->timerid, &val); 1339 if (error == 0) 1340 error = copyout(&val, uap->value, sizeof(val)); 1341 return (error); 1342 } 1343 1344 int 1345 kern_ktimer_gettime(struct thread *td, int timer_id, struct itimerspec *val) 1346 { 1347 struct proc *p; 1348 struct itimer *it; 1349 int error; 1350 1351 p = td->td_proc; 1352 PROC_LOCK(p); 1353 if (timer_id < 3 || (it = itimer_find(p, timer_id)) == NULL) { 1354 PROC_UNLOCK(p); 1355 error = EINVAL; 1356 } else { 1357 PROC_UNLOCK(p); 1358 itimer_enter(it); 1359 error = CLOCK_CALL(it->it_clockid, timer_gettime, (it, val)); 1360 itimer_leave(it); 1361 ITIMER_UNLOCK(it); 1362 } 1363 return (error); 1364 } 1365 1366 #ifndef _SYS_SYSPROTO_H_ 1367 struct timer_getoverrun_args { 1368 int timerid; 1369 }; 1370 #endif 1371 int 1372 sys_ktimer_getoverrun(struct thread *td, struct ktimer_getoverrun_args *uap) 1373 { 1374 1375 return (kern_ktimer_getoverrun(td, uap->timerid)); 1376 } 1377 1378 int 1379 kern_ktimer_getoverrun(struct thread *td, int timer_id) 1380 { 1381 struct proc *p = td->td_proc; 1382 struct itimer *it; 1383 int error ; 1384 1385 PROC_LOCK(p); 1386 if (timer_id < 3 || 1387 (it = itimer_find(p, timer_id)) == NULL) { 1388 PROC_UNLOCK(p); 1389 error = EINVAL; 1390 } else { 1391 td->td_retval[0] = it->it_overrun_last; 1392 ITIMER_UNLOCK(it); 1393 PROC_UNLOCK(p); 1394 error = 0; 1395 } 1396 return (error); 1397 } 1398 1399 static int 1400 realtimer_create(struct itimer *it) 1401 { 1402 callout_init_mtx(&it->it_callout, &it->it_mtx, 0); 1403 return (0); 1404 } 1405 1406 static int 1407 realtimer_delete(struct itimer *it) 1408 { 1409 mtx_assert(&it->it_mtx, MA_OWNED); 1410 1411 /* 1412 * clear timer's value and interval to tell realtimer_expire 1413 * to not rearm the timer. 1414 */ 1415 timespecclear(&it->it_time.it_value); 1416 timespecclear(&it->it_time.it_interval); 1417 ITIMER_UNLOCK(it); 1418 callout_drain(&it->it_callout); 1419 ITIMER_LOCK(it); 1420 return (0); 1421 } 1422 1423 static int 1424 realtimer_gettime(struct itimer *it, struct itimerspec *ovalue) 1425 { 1426 struct timespec cts; 1427 1428 mtx_assert(&it->it_mtx, MA_OWNED); 1429 1430 realtimer_clocktime(it->it_clockid, &cts); 1431 *ovalue = it->it_time; 1432 if (ovalue->it_value.tv_sec != 0 || ovalue->it_value.tv_nsec != 0) { 1433 timespecsub(&ovalue->it_value, &cts); 1434 if (ovalue->it_value.tv_sec < 0 || 1435 (ovalue->it_value.tv_sec == 0 && 1436 ovalue->it_value.tv_nsec == 0)) { 1437 ovalue->it_value.tv_sec = 0; 1438 ovalue->it_value.tv_nsec = 1; 1439 } 1440 } 1441 return (0); 1442 } 1443 1444 static int 1445 realtimer_settime(struct itimer *it, int flags, 1446 struct itimerspec *value, struct itimerspec *ovalue) 1447 { 1448 struct timespec cts, ts; 1449 struct timeval tv; 1450 struct itimerspec val; 1451 1452 mtx_assert(&it->it_mtx, MA_OWNED); 1453 1454 val = *value; 1455 if (itimespecfix(&val.it_value)) 1456 return (EINVAL); 1457 1458 if (timespecisset(&val.it_value)) { 1459 if (itimespecfix(&val.it_interval)) 1460 return (EINVAL); 1461 } else { 1462 timespecclear(&val.it_interval); 1463 } 1464 1465 if (ovalue != NULL) 1466 realtimer_gettime(it, ovalue); 1467 1468 it->it_time = val; 1469 if (timespecisset(&val.it_value)) { 1470 realtimer_clocktime(it->it_clockid, &cts); 1471 ts = val.it_value; 1472 if ((flags & TIMER_ABSTIME) == 0) { 1473 /* Convert to absolute time. */ 1474 timespecadd(&it->it_time.it_value, &cts); 1475 } else { 1476 timespecsub(&ts, &cts); 1477 /* 1478 * We don't care if ts is negative, tztohz will 1479 * fix it. 1480 */ 1481 } 1482 TIMESPEC_TO_TIMEVAL(&tv, &ts); 1483 callout_reset(&it->it_callout, tvtohz(&tv), 1484 realtimer_expire, it); 1485 } else { 1486 callout_stop(&it->it_callout); 1487 } 1488 1489 return (0); 1490 } 1491 1492 static void 1493 realtimer_clocktime(clockid_t id, struct timespec *ts) 1494 { 1495 if (id == CLOCK_REALTIME) 1496 getnanotime(ts); 1497 else /* CLOCK_MONOTONIC */ 1498 getnanouptime(ts); 1499 } 1500 1501 int 1502 itimer_accept(struct proc *p, int timerid, ksiginfo_t *ksi) 1503 { 1504 struct itimer *it; 1505 1506 PROC_LOCK_ASSERT(p, MA_OWNED); 1507 it = itimer_find(p, timerid); 1508 if (it != NULL) { 1509 ksi->ksi_overrun = it->it_overrun; 1510 it->it_overrun_last = it->it_overrun; 1511 it->it_overrun = 0; 1512 ITIMER_UNLOCK(it); 1513 return (0); 1514 } 1515 return (EINVAL); 1516 } 1517 1518 int 1519 itimespecfix(struct timespec *ts) 1520 { 1521 1522 if (ts->tv_sec < 0 || ts->tv_nsec < 0 || ts->tv_nsec >= 1000000000) 1523 return (EINVAL); 1524 if (ts->tv_sec == 0 && ts->tv_nsec != 0 && ts->tv_nsec < tick * 1000) 1525 ts->tv_nsec = tick * 1000; 1526 return (0); 1527 } 1528 1529 /* Timeout callback for realtime timer */ 1530 static void 1531 realtimer_expire(void *arg) 1532 { 1533 struct timespec cts, ts; 1534 struct timeval tv; 1535 struct itimer *it; 1536 1537 it = (struct itimer *)arg; 1538 1539 realtimer_clocktime(it->it_clockid, &cts); 1540 /* Only fire if time is reached. */ 1541 if (timespeccmp(&cts, &it->it_time.it_value, >=)) { 1542 if (timespecisset(&it->it_time.it_interval)) { 1543 timespecadd(&it->it_time.it_value, 1544 &it->it_time.it_interval); 1545 while (timespeccmp(&cts, &it->it_time.it_value, >=)) { 1546 if (it->it_overrun < INT_MAX) 1547 it->it_overrun++; 1548 else 1549 it->it_ksi.ksi_errno = ERANGE; 1550 timespecadd(&it->it_time.it_value, 1551 &it->it_time.it_interval); 1552 } 1553 } else { 1554 /* single shot timer ? */ 1555 timespecclear(&it->it_time.it_value); 1556 } 1557 if (timespecisset(&it->it_time.it_value)) { 1558 ts = it->it_time.it_value; 1559 timespecsub(&ts, &cts); 1560 TIMESPEC_TO_TIMEVAL(&tv, &ts); 1561 callout_reset(&it->it_callout, tvtohz(&tv), 1562 realtimer_expire, it); 1563 } 1564 itimer_enter(it); 1565 ITIMER_UNLOCK(it); 1566 itimer_fire(it); 1567 ITIMER_LOCK(it); 1568 itimer_leave(it); 1569 } else if (timespecisset(&it->it_time.it_value)) { 1570 ts = it->it_time.it_value; 1571 timespecsub(&ts, &cts); 1572 TIMESPEC_TO_TIMEVAL(&tv, &ts); 1573 callout_reset(&it->it_callout, tvtohz(&tv), realtimer_expire, 1574 it); 1575 } 1576 } 1577 1578 void 1579 itimer_fire(struct itimer *it) 1580 { 1581 struct proc *p = it->it_proc; 1582 struct thread *td; 1583 1584 if (it->it_sigev.sigev_notify == SIGEV_SIGNAL || 1585 it->it_sigev.sigev_notify == SIGEV_THREAD_ID) { 1586 if (sigev_findtd(p, &it->it_sigev, &td) != 0) { 1587 ITIMER_LOCK(it); 1588 timespecclear(&it->it_time.it_value); 1589 timespecclear(&it->it_time.it_interval); 1590 callout_stop(&it->it_callout); 1591 ITIMER_UNLOCK(it); 1592 return; 1593 } 1594 if (!KSI_ONQ(&it->it_ksi)) { 1595 it->it_ksi.ksi_errno = 0; 1596 ksiginfo_set_sigev(&it->it_ksi, &it->it_sigev); 1597 tdsendsignal(p, td, it->it_ksi.ksi_signo, &it->it_ksi); 1598 } else { 1599 if (it->it_overrun < INT_MAX) 1600 it->it_overrun++; 1601 else 1602 it->it_ksi.ksi_errno = ERANGE; 1603 } 1604 PROC_UNLOCK(p); 1605 } 1606 } 1607 1608 static void 1609 itimers_alloc(struct proc *p) 1610 { 1611 struct itimers *its; 1612 int i; 1613 1614 its = malloc(sizeof (struct itimers), M_SUBPROC, M_WAITOK | M_ZERO); 1615 LIST_INIT(&its->its_virtual); 1616 LIST_INIT(&its->its_prof); 1617 TAILQ_INIT(&its->its_worklist); 1618 for (i = 0; i < TIMER_MAX; i++) 1619 its->its_timers[i] = NULL; 1620 PROC_LOCK(p); 1621 if (p->p_itimers == NULL) { 1622 p->p_itimers = its; 1623 PROC_UNLOCK(p); 1624 } 1625 else { 1626 PROC_UNLOCK(p); 1627 free(its, M_SUBPROC); 1628 } 1629 } 1630 1631 static void 1632 itimers_event_hook_exec(void *arg, struct proc *p, struct image_params *imgp __unused) 1633 { 1634 itimers_event_hook_exit(arg, p); 1635 } 1636 1637 /* Clean up timers when some process events are being triggered. */ 1638 static void 1639 itimers_event_hook_exit(void *arg, struct proc *p) 1640 { 1641 struct itimers *its; 1642 struct itimer *it; 1643 int event = (int)(intptr_t)arg; 1644 int i; 1645 1646 if (p->p_itimers != NULL) { 1647 its = p->p_itimers; 1648 for (i = 0; i < MAX_CLOCKS; ++i) { 1649 if (posix_clocks[i].event_hook != NULL) 1650 CLOCK_CALL(i, event_hook, (p, i, event)); 1651 } 1652 /* 1653 * According to susv3, XSI interval timers should be inherited 1654 * by new image. 1655 */ 1656 if (event == ITIMER_EV_EXEC) 1657 i = 3; 1658 else if (event == ITIMER_EV_EXIT) 1659 i = 0; 1660 else 1661 panic("unhandled event"); 1662 for (; i < TIMER_MAX; ++i) { 1663 if ((it = its->its_timers[i]) != NULL) 1664 kern_ktimer_delete(curthread, i); 1665 } 1666 if (its->its_timers[0] == NULL && 1667 its->its_timers[1] == NULL && 1668 its->its_timers[2] == NULL) { 1669 free(its, M_SUBPROC); 1670 p->p_itimers = NULL; 1671 } 1672 } 1673 } 1674