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 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * @(#)kern_time.c 8.1 (Berkeley) 6/10/93 34 * $FreeBSD: src/sys/kern/kern_time.c,v 1.68.2.1 2002/10/01 08:00:41 bde Exp $ 35 * $DragonFly: src/sys/kern/kern_time.c,v 1.2 2003/06/17 04:28:41 dillon Exp $ 36 */ 37 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/buf.h> 41 #include <sys/sysproto.h> 42 #include <sys/resourcevar.h> 43 #include <sys/signalvar.h> 44 #include <sys/kernel.h> 45 #include <sys/systm.h> 46 #include <sys/sysent.h> 47 #include <sys/proc.h> 48 #include <sys/time.h> 49 #include <sys/vnode.h> 50 #include <vm/vm.h> 51 #include <vm/vm_extern.h> 52 53 struct timezone tz; 54 55 /* 56 * Time of day and interval timer support. 57 * 58 * These routines provide the kernel entry points to get and set 59 * the time-of-day and per-process interval timers. Subroutines 60 * here provide support for adding and subtracting timeval structures 61 * and decrementing interval timers, optionally reloading the interval 62 * timers when they expire. 63 */ 64 65 static int nanosleep1 __P((struct proc *p, struct timespec *rqt, 66 struct timespec *rmt)); 67 static int settime __P((struct timeval *)); 68 static void timevalfix __P((struct timeval *)); 69 static void no_lease_updatetime __P((int)); 70 71 static void 72 no_lease_updatetime(deltat) 73 int deltat; 74 { 75 } 76 77 void (*lease_updatetime) __P((int)) = no_lease_updatetime; 78 79 static int 80 settime(tv) 81 struct timeval *tv; 82 { 83 struct timeval delta, tv1, tv2; 84 static struct timeval maxtime, laststep; 85 struct timespec ts; 86 int s; 87 88 s = splclock(); 89 microtime(&tv1); 90 delta = *tv; 91 timevalsub(&delta, &tv1); 92 93 /* 94 * If the system is secure, we do not allow the time to be 95 * set to a value earlier than 1 second less than the highest 96 * time we have yet seen. The worst a miscreant can do in 97 * this circumstance is "freeze" time. He couldn't go 98 * back to the past. 99 * 100 * We similarly do not allow the clock to be stepped more 101 * than one second, nor more than once per second. This allows 102 * a miscreant to make the clock march double-time, but no worse. 103 */ 104 if (securelevel > 1) { 105 if (delta.tv_sec < 0 || delta.tv_usec < 0) { 106 /* 107 * Update maxtime to latest time we've seen. 108 */ 109 if (tv1.tv_sec > maxtime.tv_sec) 110 maxtime = tv1; 111 tv2 = *tv; 112 timevalsub(&tv2, &maxtime); 113 if (tv2.tv_sec < -1) { 114 tv->tv_sec = maxtime.tv_sec - 1; 115 printf("Time adjustment clamped to -1 second\n"); 116 } 117 } else { 118 if (tv1.tv_sec == laststep.tv_sec) { 119 splx(s); 120 return (EPERM); 121 } 122 if (delta.tv_sec > 1) { 123 tv->tv_sec = tv1.tv_sec + 1; 124 printf("Time adjustment clamped to +1 second\n"); 125 } 126 laststep = *tv; 127 } 128 } 129 130 ts.tv_sec = tv->tv_sec; 131 ts.tv_nsec = tv->tv_usec * 1000; 132 set_timecounter(&ts); 133 (void) splsoftclock(); 134 lease_updatetime(delta.tv_sec); 135 splx(s); 136 resettodr(); 137 return (0); 138 } 139 140 #ifndef _SYS_SYSPROTO_H_ 141 struct clock_gettime_args { 142 clockid_t clock_id; 143 struct timespec *tp; 144 }; 145 #endif 146 147 /* ARGSUSED */ 148 int 149 clock_gettime(p, uap) 150 struct proc *p; 151 struct clock_gettime_args *uap; 152 { 153 struct timespec ats; 154 155 if (SCARG(uap, clock_id) != CLOCK_REALTIME) 156 return (EINVAL); 157 nanotime(&ats); 158 return (copyout(&ats, SCARG(uap, tp), sizeof(ats))); 159 } 160 161 #ifndef _SYS_SYSPROTO_H_ 162 struct clock_settime_args { 163 clockid_t clock_id; 164 const struct timespec *tp; 165 }; 166 #endif 167 168 /* ARGSUSED */ 169 int 170 clock_settime(p, uap) 171 struct proc *p; 172 struct clock_settime_args *uap; 173 { 174 struct timeval atv; 175 struct timespec ats; 176 int error; 177 178 if ((error = suser(p)) != 0) 179 return (error); 180 if (SCARG(uap, clock_id) != CLOCK_REALTIME) 181 return (EINVAL); 182 if ((error = copyin(SCARG(uap, tp), &ats, sizeof(ats))) != 0) 183 return (error); 184 if (ats.tv_nsec < 0 || ats.tv_nsec >= 1000000000) 185 return (EINVAL); 186 /* XXX Don't convert nsec->usec and back */ 187 TIMESPEC_TO_TIMEVAL(&atv, &ats); 188 if ((error = settime(&atv))) 189 return (error); 190 return (0); 191 } 192 193 #ifndef _SYS_SYSPROTO_H_ 194 struct clock_getres_args { 195 clockid_t clock_id; 196 struct timespec *tp; 197 }; 198 #endif 199 200 int 201 clock_getres(p, uap) 202 struct proc *p; 203 struct clock_getres_args *uap; 204 { 205 struct timespec ts; 206 int error; 207 208 if (SCARG(uap, clock_id) != CLOCK_REALTIME) 209 return (EINVAL); 210 error = 0; 211 if (SCARG(uap, tp)) { 212 ts.tv_sec = 0; 213 /* 214 * Round up the result of the division cheaply by adding 1. 215 * Rounding up is especially important if rounding down 216 * would give 0. Perfect rounding is unimportant. 217 */ 218 ts.tv_nsec = 1000000000 / timecounter->tc_frequency + 1; 219 error = copyout(&ts, SCARG(uap, tp), sizeof(ts)); 220 } 221 return (error); 222 } 223 224 static int nanowait; 225 226 static int 227 nanosleep1(p, rqt, rmt) 228 struct proc *p; 229 struct timespec *rqt, *rmt; 230 { 231 struct timespec ts, ts2, ts3; 232 struct timeval tv; 233 int error; 234 235 if (rqt->tv_nsec < 0 || rqt->tv_nsec >= 1000000000) 236 return (EINVAL); 237 if (rqt->tv_sec < 0 || (rqt->tv_sec == 0 && rqt->tv_nsec == 0)) 238 return (0); 239 getnanouptime(&ts); 240 timespecadd(&ts, rqt); 241 TIMESPEC_TO_TIMEVAL(&tv, rqt); 242 for (;;) { 243 error = tsleep(&nanowait, PWAIT | PCATCH, "nanslp", 244 tvtohz(&tv)); 245 getnanouptime(&ts2); 246 if (error != EWOULDBLOCK) { 247 if (error == ERESTART) 248 error = EINTR; 249 if (rmt != NULL) { 250 timespecsub(&ts, &ts2); 251 if (ts.tv_sec < 0) 252 timespecclear(&ts); 253 *rmt = ts; 254 } 255 return (error); 256 } 257 if (timespeccmp(&ts2, &ts, >=)) 258 return (0); 259 ts3 = ts; 260 timespecsub(&ts3, &ts2); 261 TIMESPEC_TO_TIMEVAL(&tv, &ts3); 262 } 263 } 264 265 #ifndef _SYS_SYSPROTO_H_ 266 struct nanosleep_args { 267 struct timespec *rqtp; 268 struct timespec *rmtp; 269 }; 270 #endif 271 272 /* ARGSUSED */ 273 int 274 nanosleep(p, uap) 275 struct proc *p; 276 struct nanosleep_args *uap; 277 { 278 struct timespec rmt, rqt; 279 int error, error2; 280 281 error = copyin(SCARG(uap, rqtp), &rqt, sizeof(rqt)); 282 if (error) 283 return (error); 284 if (SCARG(uap, rmtp)) 285 if (!useracc((caddr_t)SCARG(uap, rmtp), sizeof(rmt), 286 VM_PROT_WRITE)) 287 return (EFAULT); 288 error = nanosleep1(p, &rqt, &rmt); 289 if (error && SCARG(uap, rmtp)) { 290 error2 = copyout(&rmt, SCARG(uap, rmtp), sizeof(rmt)); 291 if (error2) /* XXX shouldn't happen, did useracc() above */ 292 return (error2); 293 } 294 return (error); 295 } 296 297 #ifndef _SYS_SYSPROTO_H_ 298 struct gettimeofday_args { 299 struct timeval *tp; 300 struct timezone *tzp; 301 }; 302 #endif 303 /* ARGSUSED */ 304 int 305 gettimeofday(p, uap) 306 struct proc *p; 307 register struct gettimeofday_args *uap; 308 { 309 struct timeval atv; 310 int error = 0; 311 312 if (uap->tp) { 313 microtime(&atv); 314 if ((error = copyout((caddr_t)&atv, (caddr_t)uap->tp, 315 sizeof (atv)))) 316 return (error); 317 } 318 if (uap->tzp) 319 error = copyout((caddr_t)&tz, (caddr_t)uap->tzp, 320 sizeof (tz)); 321 return (error); 322 } 323 324 #ifndef _SYS_SYSPROTO_H_ 325 struct settimeofday_args { 326 struct timeval *tv; 327 struct timezone *tzp; 328 }; 329 #endif 330 /* ARGSUSED */ 331 int 332 settimeofday(p, uap) 333 struct proc *p; 334 struct settimeofday_args *uap; 335 { 336 struct timeval atv; 337 struct timezone atz; 338 int error; 339 340 if ((error = suser(p))) 341 return (error); 342 /* Verify all parameters before changing time. */ 343 if (uap->tv) { 344 if ((error = copyin((caddr_t)uap->tv, (caddr_t)&atv, 345 sizeof(atv)))) 346 return (error); 347 if (atv.tv_usec < 0 || atv.tv_usec >= 1000000) 348 return (EINVAL); 349 } 350 if (uap->tzp && 351 (error = copyin((caddr_t)uap->tzp, (caddr_t)&atz, sizeof(atz)))) 352 return (error); 353 if (uap->tv && (error = settime(&atv))) 354 return (error); 355 if (uap->tzp) 356 tz = atz; 357 return (0); 358 } 359 360 int tickdelta; /* current clock skew, us. per tick */ 361 long timedelta; /* unapplied time correction, us. */ 362 static long bigadj = 1000000; /* use 10x skew above bigadj us. */ 363 364 #ifndef _SYS_SYSPROTO_H_ 365 struct adjtime_args { 366 struct timeval *delta; 367 struct timeval *olddelta; 368 }; 369 #endif 370 /* ARGSUSED */ 371 int 372 adjtime(p, uap) 373 struct proc *p; 374 register struct adjtime_args *uap; 375 { 376 struct timeval atv; 377 register long ndelta, ntickdelta, odelta; 378 int s, error; 379 380 if ((error = suser(p))) 381 return (error); 382 if ((error = 383 copyin((caddr_t)uap->delta, (caddr_t)&atv, sizeof(struct timeval)))) 384 return (error); 385 386 /* 387 * Compute the total correction and the rate at which to apply it. 388 * Round the adjustment down to a whole multiple of the per-tick 389 * delta, so that after some number of incremental changes in 390 * hardclock(), tickdelta will become zero, lest the correction 391 * overshoot and start taking us away from the desired final time. 392 */ 393 ndelta = atv.tv_sec * 1000000 + atv.tv_usec; 394 if (ndelta > bigadj || ndelta < -bigadj) 395 ntickdelta = 10 * tickadj; 396 else 397 ntickdelta = tickadj; 398 if (ndelta % ntickdelta) 399 ndelta = ndelta / ntickdelta * ntickdelta; 400 401 /* 402 * To make hardclock()'s job easier, make the per-tick delta negative 403 * if we want time to run slower; then hardclock can simply compute 404 * tick + tickdelta, and subtract tickdelta from timedelta. 405 */ 406 if (ndelta < 0) 407 ntickdelta = -ntickdelta; 408 s = splclock(); 409 odelta = timedelta; 410 timedelta = ndelta; 411 tickdelta = ntickdelta; 412 splx(s); 413 414 if (uap->olddelta) { 415 atv.tv_sec = odelta / 1000000; 416 atv.tv_usec = odelta % 1000000; 417 (void) copyout((caddr_t)&atv, (caddr_t)uap->olddelta, 418 sizeof(struct timeval)); 419 } 420 return (0); 421 } 422 423 /* 424 * Get value of an interval timer. The process virtual and 425 * profiling virtual time timers are kept in the p_stats area, since 426 * they can be swapped out. These are kept internally in the 427 * way they are specified externally: in time until they expire. 428 * 429 * The real time interval timer is kept in the process table slot 430 * for the process, and its value (it_value) is kept as an 431 * absolute time rather than as a delta, so that it is easy to keep 432 * periodic real-time signals from drifting. 433 * 434 * Virtual time timers are processed in the hardclock() routine of 435 * kern_clock.c. The real time timer is processed by a timeout 436 * routine, called from the softclock() routine. Since a callout 437 * may be delayed in real time due to interrupt processing in the system, 438 * it is possible for the real time timeout routine (realitexpire, given below), 439 * to be delayed in real time past when it is supposed to occur. It 440 * does not suffice, therefore, to reload the real timer .it_value from the 441 * real time timers .it_interval. Rather, we compute the next time in 442 * absolute time the timer should go off. 443 */ 444 #ifndef _SYS_SYSPROTO_H_ 445 struct getitimer_args { 446 u_int which; 447 struct itimerval *itv; 448 }; 449 #endif 450 /* ARGSUSED */ 451 int 452 getitimer(p, uap) 453 struct proc *p; 454 register struct getitimer_args *uap; 455 { 456 struct timeval ctv; 457 struct itimerval aitv; 458 int s; 459 460 if (uap->which > ITIMER_PROF) 461 return (EINVAL); 462 s = splclock(); /* XXX still needed ? */ 463 if (uap->which == ITIMER_REAL) { 464 /* 465 * Convert from absolute to relative time in .it_value 466 * part of real time timer. If time for real time timer 467 * has passed return 0, else return difference between 468 * current time and time for the timer to go off. 469 */ 470 aitv = p->p_realtimer; 471 if (timevalisset(&aitv.it_value)) { 472 getmicrouptime(&ctv); 473 if (timevalcmp(&aitv.it_value, &ctv, <)) 474 timevalclear(&aitv.it_value); 475 else 476 timevalsub(&aitv.it_value, &ctv); 477 } 478 } else 479 aitv = p->p_stats->p_timer[uap->which]; 480 splx(s); 481 return (copyout((caddr_t)&aitv, (caddr_t)uap->itv, 482 sizeof (struct itimerval))); 483 } 484 485 #ifndef _SYS_SYSPROTO_H_ 486 struct setitimer_args { 487 u_int which; 488 struct itimerval *itv, *oitv; 489 }; 490 #endif 491 /* ARGSUSED */ 492 int 493 setitimer(p, uap) 494 struct proc *p; 495 register struct setitimer_args *uap; 496 { 497 struct itimerval aitv; 498 struct timeval ctv; 499 register struct itimerval *itvp; 500 int s, error; 501 502 if (uap->which > ITIMER_PROF) 503 return (EINVAL); 504 itvp = uap->itv; 505 if (itvp && (error = copyin((caddr_t)itvp, (caddr_t)&aitv, 506 sizeof(struct itimerval)))) 507 return (error); 508 if ((uap->itv = uap->oitv) && 509 (error = getitimer(p, (struct getitimer_args *)uap))) 510 return (error); 511 if (itvp == 0) 512 return (0); 513 if (itimerfix(&aitv.it_value)) 514 return (EINVAL); 515 if (!timevalisset(&aitv.it_value)) 516 timevalclear(&aitv.it_interval); 517 else if (itimerfix(&aitv.it_interval)) 518 return (EINVAL); 519 s = splclock(); /* XXX: still needed ? */ 520 if (uap->which == ITIMER_REAL) { 521 if (timevalisset(&p->p_realtimer.it_value)) 522 untimeout(realitexpire, (caddr_t)p, p->p_ithandle); 523 if (timevalisset(&aitv.it_value)) 524 p->p_ithandle = timeout(realitexpire, (caddr_t)p, 525 tvtohz(&aitv.it_value)); 526 getmicrouptime(&ctv); 527 timevaladd(&aitv.it_value, &ctv); 528 p->p_realtimer = aitv; 529 } else 530 p->p_stats->p_timer[uap->which] = aitv; 531 splx(s); 532 return (0); 533 } 534 535 /* 536 * Real interval timer expired: 537 * send process whose timer expired an alarm signal. 538 * If time is not set up to reload, then just return. 539 * Else compute next time timer should go off which is > current time. 540 * This is where delay in processing this timeout causes multiple 541 * SIGALRM calls to be compressed into one. 542 * tvtohz() always adds 1 to allow for the time until the next clock 543 * interrupt being strictly less than 1 clock tick, but we don't want 544 * that here since we want to appear to be in sync with the clock 545 * interrupt even when we're delayed. 546 */ 547 void 548 realitexpire(arg) 549 void *arg; 550 { 551 register struct proc *p; 552 struct timeval ctv, ntv; 553 int s; 554 555 p = (struct proc *)arg; 556 psignal(p, SIGALRM); 557 if (!timevalisset(&p->p_realtimer.it_interval)) { 558 timevalclear(&p->p_realtimer.it_value); 559 return; 560 } 561 for (;;) { 562 s = splclock(); /* XXX: still neeeded ? */ 563 timevaladd(&p->p_realtimer.it_value, 564 &p->p_realtimer.it_interval); 565 getmicrouptime(&ctv); 566 if (timevalcmp(&p->p_realtimer.it_value, &ctv, >)) { 567 ntv = p->p_realtimer.it_value; 568 timevalsub(&ntv, &ctv); 569 p->p_ithandle = timeout(realitexpire, (caddr_t)p, 570 tvtohz(&ntv) - 1); 571 splx(s); 572 return; 573 } 574 splx(s); 575 } 576 } 577 578 /* 579 * Check that a proposed value to load into the .it_value or 580 * .it_interval part of an interval timer is acceptable, and 581 * fix it to have at least minimal value (i.e. if it is less 582 * than the resolution of the clock, round it up.) 583 */ 584 int 585 itimerfix(tv) 586 struct timeval *tv; 587 { 588 589 if (tv->tv_sec < 0 || tv->tv_sec > 100000000 || 590 tv->tv_usec < 0 || tv->tv_usec >= 1000000) 591 return (EINVAL); 592 if (tv->tv_sec == 0 && tv->tv_usec != 0 && tv->tv_usec < tick) 593 tv->tv_usec = tick; 594 return (0); 595 } 596 597 /* 598 * Decrement an interval timer by a specified number 599 * of microseconds, which must be less than a second, 600 * i.e. < 1000000. If the timer expires, then reload 601 * it. In this case, carry over (usec - old value) to 602 * reduce the value reloaded into the timer so that 603 * the timer does not drift. This routine assumes 604 * that it is called in a context where the timers 605 * on which it is operating cannot change in value. 606 */ 607 int 608 itimerdecr(itp, usec) 609 register struct itimerval *itp; 610 int usec; 611 { 612 613 if (itp->it_value.tv_usec < usec) { 614 if (itp->it_value.tv_sec == 0) { 615 /* expired, and already in next interval */ 616 usec -= itp->it_value.tv_usec; 617 goto expire; 618 } 619 itp->it_value.tv_usec += 1000000; 620 itp->it_value.tv_sec--; 621 } 622 itp->it_value.tv_usec -= usec; 623 usec = 0; 624 if (timevalisset(&itp->it_value)) 625 return (1); 626 /* expired, exactly at end of interval */ 627 expire: 628 if (timevalisset(&itp->it_interval)) { 629 itp->it_value = itp->it_interval; 630 itp->it_value.tv_usec -= usec; 631 if (itp->it_value.tv_usec < 0) { 632 itp->it_value.tv_usec += 1000000; 633 itp->it_value.tv_sec--; 634 } 635 } else 636 itp->it_value.tv_usec = 0; /* sec is already 0 */ 637 return (0); 638 } 639 640 /* 641 * Add and subtract routines for timevals. 642 * N.B.: subtract routine doesn't deal with 643 * results which are before the beginning, 644 * it just gets very confused in this case. 645 * Caveat emptor. 646 */ 647 void 648 timevaladd(t1, t2) 649 struct timeval *t1, *t2; 650 { 651 652 t1->tv_sec += t2->tv_sec; 653 t1->tv_usec += t2->tv_usec; 654 timevalfix(t1); 655 } 656 657 void 658 timevalsub(t1, t2) 659 struct timeval *t1, *t2; 660 { 661 662 t1->tv_sec -= t2->tv_sec; 663 t1->tv_usec -= t2->tv_usec; 664 timevalfix(t1); 665 } 666 667 static void 668 timevalfix(t1) 669 struct timeval *t1; 670 { 671 672 if (t1->tv_usec < 0) { 673 t1->tv_sec--; 674 t1->tv_usec += 1000000; 675 } 676 if (t1->tv_usec >= 1000000) { 677 t1->tv_sec++; 678 t1->tv_usec -= 1000000; 679 } 680 } 681