1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Copyright (c) 1982, 1986 Regents of the University of California. 29 * All rights reserved. The Berkeley software License Agreement 30 * specifies the terms and conditions for redistribution. 31 */ 32 33 #include <sys/param.h> 34 #include <sys/user.h> 35 #include <sys/vnode.h> 36 #include <sys/proc.h> 37 #include <sys/time.h> 38 #include <sys/systm.h> 39 #include <sys/kmem.h> 40 #include <sys/cmn_err.h> 41 #include <sys/cpuvar.h> 42 #include <sys/timer.h> 43 #include <sys/debug.h> 44 #include <sys/sysmacros.h> 45 #include <sys/cyclic.h> 46 47 static void realitexpire(void *); 48 static void realprofexpire(void *); 49 static void timeval_advance(struct timeval *, struct timeval *); 50 51 kmutex_t tod_lock; /* protects time-of-day stuff */ 52 53 /* 54 * Constant to define the minimum interval value of the ITIMER_REALPROF timer. 55 * Value is in microseconds; defaults to 500 usecs. Setting this value 56 * significantly lower may allow for denial-of-service attacks. 57 */ 58 int itimer_realprof_minimum = 500; 59 60 /* 61 * macro to compare a timeval to a timestruc 62 */ 63 64 #define TVTSCMP(tvp, tsp, cmp) \ 65 /* CSTYLED */ \ 66 ((tvp)->tv_sec cmp (tsp)->tv_sec || \ 67 ((tvp)->tv_sec == (tsp)->tv_sec && \ 68 /* CSTYLED */ \ 69 (tvp)->tv_usec * 1000 cmp (tsp)->tv_nsec)) 70 71 /* 72 * Time of day and interval timer support. 73 * 74 * These routines provide the kernel entry points to get and set 75 * the time-of-day and per-process interval timers. Subroutines 76 * here provide support for adding and subtracting timeval structures 77 * and decrementing interval timers, optionally reloading the interval 78 * timers when they expire. 79 */ 80 81 /* 82 * SunOS function to generate monotonically increasing time values. 83 */ 84 void 85 uniqtime(struct timeval *tv) 86 { 87 static struct timeval last; 88 static int last_timechanged; 89 timestruc_t ts; 90 time_t sec; 91 int usec, nsec; 92 93 /* 94 * protect modification of last 95 */ 96 mutex_enter(&tod_lock); 97 gethrestime(&ts); 98 99 /* 100 * Fast algorithm to convert nsec to usec -- see hrt2ts() 101 * in common/os/timers.c for a full description. 102 */ 103 nsec = ts.tv_nsec; 104 usec = nsec + (nsec >> 2); 105 usec = nsec + (usec >> 1); 106 usec = nsec + (usec >> 2); 107 usec = nsec + (usec >> 4); 108 usec = nsec - (usec >> 3); 109 usec = nsec + (usec >> 2); 110 usec = nsec + (usec >> 3); 111 usec = nsec + (usec >> 4); 112 usec = nsec + (usec >> 1); 113 usec = nsec + (usec >> 6); 114 usec = usec >> 10; 115 sec = ts.tv_sec; 116 117 /* 118 * If the system hres time has been changed since the last time 119 * we are called. then all bets are off; just update our 120 * local copy of timechanged and accept the reported time as is. 121 */ 122 if (last_timechanged != timechanged) { 123 last_timechanged = timechanged; 124 } 125 /* 126 * Try to keep timestamps unique, but don't be obsessive about 127 * it in the face of large differences. 128 */ 129 else if ((sec <= last.tv_sec) && /* same or lower seconds, and */ 130 ((sec != last.tv_sec) || /* either different second or */ 131 (usec <= last.tv_usec)) && /* lower microsecond, and */ 132 ((last.tv_sec - sec) <= 5)) { /* not way back in time */ 133 sec = last.tv_sec; 134 usec = last.tv_usec + 1; 135 if (usec >= MICROSEC) { 136 usec -= MICROSEC; 137 sec++; 138 } 139 } 140 last.tv_sec = sec; 141 last.tv_usec = usec; 142 mutex_exit(&tod_lock); 143 144 tv->tv_sec = sec; 145 tv->tv_usec = usec; 146 } 147 148 /* 149 * Timestamps are exported from the kernel in several places. 150 * Such timestamps are commonly used for either uniqueness or for 151 * sequencing - truncation to 32-bits is fine for uniqueness, 152 * but sequencing is going to take more work as we get closer to 2038! 153 */ 154 void 155 uniqtime32(struct timeval32 *tv32p) 156 { 157 struct timeval tv; 158 159 uniqtime(&tv); 160 TIMEVAL_TO_TIMEVAL32(tv32p, &tv); 161 } 162 163 int 164 gettimeofday(struct timeval *tp) 165 { 166 struct timeval atv; 167 168 if (tp) { 169 uniqtime(&atv); 170 if (get_udatamodel() == DATAMODEL_NATIVE) { 171 if (copyout(&atv, tp, sizeof (atv))) 172 return (set_errno(EFAULT)); 173 } else { 174 struct timeval32 tv32; 175 176 if (TIMEVAL_OVERFLOW(&atv)) 177 return (set_errno(EOVERFLOW)); 178 TIMEVAL_TO_TIMEVAL32(&tv32, &atv); 179 180 if (copyout(&tv32, tp, sizeof (tv32))) 181 return (set_errno(EFAULT)); 182 } 183 } 184 return (0); 185 } 186 187 int 188 getitimer(uint_t which, struct itimerval *itv) 189 { 190 int error; 191 192 if (get_udatamodel() == DATAMODEL_NATIVE) 193 error = xgetitimer(which, itv, 0); 194 else { 195 struct itimerval kitv; 196 197 if ((error = xgetitimer(which, &kitv, 1)) == 0) { 198 if (ITIMERVAL_OVERFLOW(&kitv)) { 199 error = EOVERFLOW; 200 } else { 201 struct itimerval32 itv32; 202 203 ITIMERVAL_TO_ITIMERVAL32(&itv32, &kitv); 204 if (copyout(&itv32, itv, sizeof (itv32)) != 0) 205 error = EFAULT; 206 } 207 } 208 } 209 210 return (error ? (set_errno(error)) : 0); 211 } 212 213 int 214 xgetitimer(uint_t which, struct itimerval *itv, int iskaddr) 215 { 216 struct proc *p = curproc; 217 struct timeval now; 218 struct itimerval aitv; 219 hrtime_t ts, first, interval, remain; 220 221 mutex_enter(&p->p_lock); 222 223 switch (which) { 224 case ITIMER_VIRTUAL: 225 case ITIMER_PROF: 226 aitv = ttolwp(curthread)->lwp_timer[which]; 227 break; 228 229 case ITIMER_REAL: 230 uniqtime(&now); 231 aitv = p->p_realitimer; 232 233 if (timerisset(&aitv.it_value)) { 234 /*CSTYLED*/ 235 if (timercmp(&aitv.it_value, &now, <)) { 236 timerclear(&aitv.it_value); 237 } else { 238 timevalsub(&aitv.it_value, &now); 239 } 240 } 241 break; 242 243 case ITIMER_REALPROF: 244 if (curproc->p_rprof_cyclic == CYCLIC_NONE) { 245 bzero(&aitv, sizeof (aitv)); 246 break; 247 } 248 249 aitv = curproc->p_rprof_timer; 250 251 first = tv2hrt(&aitv.it_value); 252 interval = tv2hrt(&aitv.it_interval); 253 254 if ((ts = gethrtime()) < first) { 255 /* 256 * We haven't gone off for the first time; the time 257 * remaining is simply the first time we will go 258 * off minus the current time. 259 */ 260 remain = first - ts; 261 } else { 262 if (interval == 0) { 263 /* 264 * This was set as a one-shot, and we've 265 * already gone off; there is no time 266 * remaining. 267 */ 268 remain = 0; 269 } else { 270 /* 271 * We have a non-zero interval; we need to 272 * determine how far we are into the current 273 * interval, and subtract that from the 274 * interval to determine the time remaining. 275 */ 276 remain = interval - ((ts - first) % interval); 277 } 278 } 279 280 hrt2tv(remain, &aitv.it_value); 281 break; 282 283 default: 284 mutex_exit(&p->p_lock); 285 return (EINVAL); 286 } 287 288 mutex_exit(&p->p_lock); 289 290 if (iskaddr) { 291 bcopy(&aitv, itv, sizeof (*itv)); 292 } else { 293 ASSERT(get_udatamodel() == DATAMODEL_NATIVE); 294 if (copyout(&aitv, itv, sizeof (*itv))) 295 return (EFAULT); 296 } 297 298 return (0); 299 } 300 301 302 int 303 setitimer(uint_t which, struct itimerval *itv, struct itimerval *oitv) 304 { 305 int error; 306 307 if (oitv != NULL) 308 if ((error = getitimer(which, oitv)) != 0) 309 return (error); 310 311 if (itv == NULL) 312 return (0); 313 314 if (get_udatamodel() == DATAMODEL_NATIVE) 315 error = xsetitimer(which, itv, 0); 316 else { 317 struct itimerval32 itv32; 318 struct itimerval kitv; 319 320 if (copyin(itv, &itv32, sizeof (itv32))) 321 error = EFAULT; 322 ITIMERVAL32_TO_ITIMERVAL(&kitv, &itv32); 323 error = xsetitimer(which, &kitv, 1); 324 } 325 326 return (error ? (set_errno(error)) : 0); 327 } 328 329 int 330 xsetitimer(uint_t which, struct itimerval *itv, int iskaddr) 331 { 332 struct itimerval aitv; 333 struct timeval now; 334 struct proc *p = curproc; 335 kthread_t *t; 336 timeout_id_t tmp_id; 337 cyc_handler_t hdlr; 338 cyc_time_t when; 339 cyclic_id_t cyclic; 340 hrtime_t ts; 341 int min; 342 343 if (itv == NULL) 344 return (0); 345 346 if (iskaddr) { 347 bcopy(itv, &aitv, sizeof (aitv)); 348 } else { 349 ASSERT(get_udatamodel() == DATAMODEL_NATIVE); 350 if (copyin(itv, &aitv, sizeof (aitv))) 351 return (EFAULT); 352 } 353 354 if (which == ITIMER_REALPROF) { 355 min = MAX((int)(cyclic_getres() / (NANOSEC / MICROSEC)), 356 itimer_realprof_minimum); 357 } else { 358 min = usec_per_tick; 359 } 360 361 if (itimerfix(&aitv.it_value, min) || 362 (itimerfix(&aitv.it_interval, min) && timerisset(&aitv.it_value))) 363 return (EINVAL); 364 365 mutex_enter(&p->p_lock); 366 switch (which) { 367 case ITIMER_REAL: 368 /* 369 * The SITBUSY flag prevents conflicts with multiple 370 * threads attempting to perform setitimer(ITIMER_REAL) 371 * at the same time, even when we drop p->p_lock below. 372 * Any blocked thread returns successfully because the 373 * effect is the same as if it got here first, finished, 374 * and the other thread then came through and destroyed 375 * what it did. We are just protecting the system from 376 * malfunctioning due to the race condition. 377 */ 378 if (p->p_flag & SITBUSY) { 379 mutex_exit(&p->p_lock); 380 return (0); 381 } 382 p->p_flag |= SITBUSY; 383 while ((tmp_id = p->p_itimerid) != 0) { 384 /* 385 * Avoid deadlock in callout_delete (called from 386 * untimeout) which may go to sleep (while holding 387 * p_lock). Drop p_lock and re-acquire it after 388 * untimeout returns. Need to clear p_itimerid 389 * while holding p_lock. 390 */ 391 p->p_itimerid = 0; 392 mutex_exit(&p->p_lock); 393 (void) untimeout(tmp_id); 394 mutex_enter(&p->p_lock); 395 } 396 if (timerisset(&aitv.it_value)) { 397 uniqtime(&now); 398 timevaladd(&aitv.it_value, &now); 399 p->p_itimerid = realtime_timeout(realitexpire, 400 p, hzto(&aitv.it_value)); 401 } 402 p->p_realitimer = aitv; 403 p->p_flag &= ~SITBUSY; 404 break; 405 406 case ITIMER_REALPROF: 407 cyclic = p->p_rprof_cyclic; 408 p->p_rprof_cyclic = CYCLIC_NONE; 409 410 mutex_exit(&p->p_lock); 411 412 /* 413 * We're now going to acquire cpu_lock, remove the old cyclic 414 * if necessary, and add our new cyclic. 415 */ 416 mutex_enter(&cpu_lock); 417 418 if (cyclic != CYCLIC_NONE) 419 cyclic_remove(cyclic); 420 421 if (!timerisset(&aitv.it_value)) { 422 /* 423 * If we were passed a value of 0, we're done. 424 */ 425 mutex_exit(&cpu_lock); 426 return (0); 427 } 428 429 hdlr.cyh_func = realprofexpire; 430 hdlr.cyh_arg = p; 431 hdlr.cyh_level = CY_LOW_LEVEL; 432 433 when.cyt_when = (ts = gethrtime() + tv2hrt(&aitv.it_value)); 434 when.cyt_interval = tv2hrt(&aitv.it_interval); 435 436 if (when.cyt_interval == 0) { 437 /* 438 * Using the same logic as for CLOCK_HIGHRES timers, we 439 * set the interval to be INT64_MAX - when.cyt_when to 440 * effect a one-shot; see the comment in clock_highres.c 441 * for more details on why this works. 442 */ 443 when.cyt_interval = INT64_MAX - when.cyt_when; 444 } 445 446 cyclic = cyclic_add(&hdlr, &when); 447 448 mutex_exit(&cpu_lock); 449 450 /* 451 * We have now successfully added the cyclic. Reacquire 452 * p_lock, and see if anyone has snuck in. 453 */ 454 mutex_enter(&p->p_lock); 455 456 if (p->p_rprof_cyclic != CYCLIC_NONE) { 457 /* 458 * We're racing with another thread establishing an 459 * ITIMER_REALPROF interval timer. We'll let the other 460 * thread win (this is a race at the application level, 461 * so letting the other thread win is acceptable). 462 */ 463 mutex_exit(&p->p_lock); 464 mutex_enter(&cpu_lock); 465 cyclic_remove(cyclic); 466 mutex_exit(&cpu_lock); 467 468 return (0); 469 } 470 471 /* 472 * Success. Set our tracking variables in the proc structure, 473 * cancel any outstanding ITIMER_PROF, and allocate the 474 * per-thread SIGPROF buffers, if possible. 475 */ 476 hrt2tv(ts, &aitv.it_value); 477 p->p_rprof_timer = aitv; 478 p->p_rprof_cyclic = cyclic; 479 480 t = p->p_tlist; 481 do { 482 struct itimerval *itvp; 483 484 itvp = &ttolwp(t)->lwp_timer[ITIMER_PROF]; 485 timerclear(&itvp->it_interval); 486 timerclear(&itvp->it_value); 487 488 if (t->t_rprof != NULL) 489 continue; 490 491 t->t_rprof = 492 kmem_zalloc(sizeof (struct rprof), KM_NOSLEEP); 493 aston(t); 494 } while ((t = t->t_forw) != p->p_tlist); 495 496 break; 497 498 case ITIMER_VIRTUAL: 499 ttolwp(curthread)->lwp_timer[ITIMER_VIRTUAL] = aitv; 500 break; 501 502 case ITIMER_PROF: 503 if (p->p_rprof_cyclic != CYCLIC_NONE) { 504 /* 505 * Silently ignore ITIMER_PROF if ITIMER_REALPROF 506 * is in effect. 507 */ 508 break; 509 } 510 511 ttolwp(curthread)->lwp_timer[ITIMER_PROF] = aitv; 512 break; 513 514 default: 515 mutex_exit(&p->p_lock); 516 return (EINVAL); 517 } 518 mutex_exit(&p->p_lock); 519 return (0); 520 } 521 522 /* 523 * Delete the ITIMER_REALPROF interval timer. 524 * Called only from exec_args() when exec occurs. 525 * The other ITIMER_* interval timers are specified 526 * to be inherited across exec(), so leave them alone. 527 */ 528 void 529 delete_itimer_realprof(void) 530 { 531 kthread_t *t = curthread; 532 struct proc *p = ttoproc(t); 533 klwp_t *lwp = ttolwp(t); 534 cyclic_id_t cyclic; 535 536 mutex_enter(&p->p_lock); 537 538 /* we are performing execve(); assert we are single-threaded */ 539 ASSERT(t == p->p_tlist && t == t->t_forw); 540 541 if ((cyclic = p->p_rprof_cyclic) == CYCLIC_NONE) { 542 mutex_exit(&p->p_lock); 543 } else { 544 p->p_rprof_cyclic = CYCLIC_NONE; 545 /* 546 * Delete any current instance of SIGPROF. 547 */ 548 if (lwp->lwp_cursig == SIGPROF) { 549 lwp->lwp_cursig = 0; 550 lwp->lwp_extsig = 0; 551 if (lwp->lwp_curinfo) { 552 siginfofree(lwp->lwp_curinfo); 553 lwp->lwp_curinfo = NULL; 554 } 555 } 556 /* 557 * Delete any pending instances of SIGPROF. 558 */ 559 sigdelset(&p->p_sig, SIGPROF); 560 sigdelset(&p->p_extsig, SIGPROF); 561 sigdelq(p, NULL, SIGPROF); 562 sigdelset(&t->t_sig, SIGPROF); 563 sigdelset(&t->t_extsig, SIGPROF); 564 sigdelq(p, t, SIGPROF); 565 566 mutex_exit(&p->p_lock); 567 568 /* 569 * Remove the ITIMER_REALPROF cyclic. 570 */ 571 mutex_enter(&cpu_lock); 572 cyclic_remove(cyclic); 573 mutex_exit(&cpu_lock); 574 } 575 } 576 577 /* 578 * Real interval timer expired: 579 * send process whose timer expired an alarm signal. 580 * If time is not set up to reload, then just return. 581 * Else compute next time timer should go off which is > current time. 582 * This is where delay in processing this timeout causes multiple 583 * SIGALRM calls to be compressed into one. 584 */ 585 static void 586 realitexpire(void *arg) 587 { 588 struct proc *p = arg; 589 struct timeval *valp = &p->p_realitimer.it_value; 590 struct timeval *intervalp = &p->p_realitimer.it_interval; 591 #if !defined(_LP64) 592 clock_t ticks; 593 #endif 594 595 mutex_enter(&p->p_lock); 596 #if !defined(_LP64) 597 if ((ticks = hzto(valp)) > 1) { 598 /* 599 * If we are executing before we were meant to, it must be 600 * because of an overflow in a prior hzto() calculation. 601 * In this case, we want to go to sleep for the recalculated 602 * number of ticks. For the special meaning of the value "1" 603 * see comment in timespectohz(). 604 */ 605 p->p_itimerid = realtime_timeout(realitexpire, p, ticks); 606 mutex_exit(&p->p_lock); 607 return; 608 } 609 #endif 610 sigtoproc(p, NULL, SIGALRM); 611 if (!timerisset(intervalp)) { 612 timerclear(valp); 613 p->p_itimerid = 0; 614 } else { 615 /* advance timer value past current time */ 616 timeval_advance(valp, intervalp); 617 p->p_itimerid = realtime_timeout(realitexpire, p, hzto(valp)); 618 } 619 mutex_exit(&p->p_lock); 620 } 621 622 /* 623 * Real time profiling interval timer expired: 624 * Increment microstate counters for each lwp in the process 625 * and ensure that running lwps are kicked into the kernel. 626 * If time is not set up to reload, then just return. 627 * Else compute next time timer should go off which is > current time, 628 * as above. 629 */ 630 static void 631 realprofexpire(void *arg) 632 { 633 struct proc *p = arg; 634 kthread_t *t; 635 636 mutex_enter(&p->p_lock); 637 if (p->p_rprof_cyclic == CYCLIC_NONE || 638 (t = p->p_tlist) == NULL) { 639 mutex_exit(&p->p_lock); 640 return; 641 } 642 do { 643 int mstate; 644 645 /* 646 * Attempt to allocate the SIGPROF buffer, but don't sleep. 647 */ 648 if (t->t_rprof == NULL) 649 t->t_rprof = kmem_zalloc(sizeof (struct rprof), 650 KM_NOSLEEP); 651 if (t->t_rprof == NULL) 652 continue; 653 654 thread_lock(t); 655 switch (t->t_state) { 656 case TS_SLEEP: 657 switch (mstate = ttolwp(t)->lwp_mstate.ms_prev) { 658 case LMS_TFAULT: 659 case LMS_DFAULT: 660 case LMS_KFAULT: 661 case LMS_USER_LOCK: 662 break; 663 default: 664 mstate = LMS_SLEEP; 665 break; 666 } 667 break; 668 case TS_RUN: 669 case TS_WAIT: 670 mstate = LMS_WAIT_CPU; 671 break; 672 case TS_ONPROC: 673 switch (mstate = t->t_mstate) { 674 case LMS_USER: 675 case LMS_SYSTEM: 676 case LMS_TRAP: 677 break; 678 default: 679 mstate = LMS_SYSTEM; 680 break; 681 } 682 break; 683 default: 684 mstate = t->t_mstate; 685 break; 686 } 687 t->t_rprof->rp_anystate = 1; 688 t->t_rprof->rp_state[mstate]++; 689 aston(t); 690 /* 691 * force the thread into the kernel 692 * if it is not already there. 693 */ 694 if (t->t_state == TS_ONPROC && t->t_cpu != CPU) 695 poke_cpu(t->t_cpu->cpu_id); 696 thread_unlock(t); 697 } while ((t = t->t_forw) != p->p_tlist); 698 699 mutex_exit(&p->p_lock); 700 } 701 702 /* 703 * Advances timer value past the current time of day. See the detailed 704 * comment for this logic in realitsexpire(), above. 705 */ 706 static void 707 timeval_advance(struct timeval *valp, struct timeval *intervalp) 708 { 709 int cnt2nth; 710 struct timeval interval2nth; 711 712 for (;;) { 713 interval2nth = *intervalp; 714 for (cnt2nth = 0; ; cnt2nth++) { 715 timevaladd(valp, &interval2nth); 716 /*CSTYLED*/ 717 if (TVTSCMP(valp, &hrestime, >)) 718 break; 719 timevaladd(&interval2nth, &interval2nth); 720 } 721 if (cnt2nth == 0) 722 break; 723 timevalsub(valp, &interval2nth); 724 } 725 } 726 727 /* 728 * Check that a proposed value to load into the .it_value or .it_interval 729 * part of an interval timer is acceptable, and set it to at least a 730 * specified minimal value. 731 */ 732 int 733 itimerfix(struct timeval *tv, int minimum) 734 { 735 if (tv->tv_sec < 0 || tv->tv_sec > 100000000 || 736 tv->tv_usec < 0 || tv->tv_usec >= MICROSEC) 737 return (EINVAL); 738 if (tv->tv_sec == 0 && tv->tv_usec != 0 && tv->tv_usec < minimum) 739 tv->tv_usec = minimum; 740 return (0); 741 } 742 743 /* 744 * Same as itimerfix, except a) it takes a timespec instead of a timeval and 745 * b) it doesn't truncate based on timeout granularity; consumers of this 746 * interface (e.g. timer_settime()) depend on the passed timespec not being 747 * modified implicitly. 748 */ 749 int 750 itimerspecfix(timespec_t *tv) 751 { 752 if (tv->tv_sec < 0 || tv->tv_nsec < 0 || tv->tv_nsec >= NANOSEC) 753 return (EINVAL); 754 return (0); 755 } 756 757 /* 758 * Decrement an interval timer by a specified number 759 * of microseconds, which must be less than a second, 760 * i.e. < 1000000. If the timer expires, then reload 761 * it. In this case, carry over (usec - old value) to 762 * reducint the value reloaded into the timer so that 763 * the timer does not drift. This routine assumes 764 * that it is called in a context where the timers 765 * on which it is operating cannot change in value. 766 */ 767 int 768 itimerdecr(struct itimerval *itp, int usec) 769 { 770 if (itp->it_value.tv_usec < usec) { 771 if (itp->it_value.tv_sec == 0) { 772 /* expired, and already in next interval */ 773 usec -= itp->it_value.tv_usec; 774 goto expire; 775 } 776 itp->it_value.tv_usec += MICROSEC; 777 itp->it_value.tv_sec--; 778 } 779 itp->it_value.tv_usec -= usec; 780 usec = 0; 781 if (timerisset(&itp->it_value)) 782 return (1); 783 /* expired, exactly at end of interval */ 784 expire: 785 if (timerisset(&itp->it_interval)) { 786 itp->it_value = itp->it_interval; 787 itp->it_value.tv_usec -= usec; 788 if (itp->it_value.tv_usec < 0) { 789 itp->it_value.tv_usec += MICROSEC; 790 itp->it_value.tv_sec--; 791 } 792 } else 793 itp->it_value.tv_usec = 0; /* sec is already 0 */ 794 return (0); 795 } 796 797 /* 798 * Add and subtract routines for timevals. 799 * N.B.: subtract routine doesn't deal with 800 * results which are before the beginning, 801 * it just gets very confused in this case. 802 * Caveat emptor. 803 */ 804 void 805 timevaladd(struct timeval *t1, struct timeval *t2) 806 { 807 t1->tv_sec += t2->tv_sec; 808 t1->tv_usec += t2->tv_usec; 809 timevalfix(t1); 810 } 811 812 void 813 timevalsub(struct timeval *t1, struct timeval *t2) 814 { 815 t1->tv_sec -= t2->tv_sec; 816 t1->tv_usec -= t2->tv_usec; 817 timevalfix(t1); 818 } 819 820 void 821 timevalfix(struct timeval *t1) 822 { 823 if (t1->tv_usec < 0) { 824 t1->tv_sec--; 825 t1->tv_usec += MICROSEC; 826 } 827 if (t1->tv_usec >= MICROSEC) { 828 t1->tv_sec++; 829 t1->tv_usec -= MICROSEC; 830 } 831 } 832 833 /* 834 * Same as the routines above. These routines take a timespec instead 835 * of a timeval. 836 */ 837 void 838 timespecadd(timespec_t *t1, timespec_t *t2) 839 { 840 t1->tv_sec += t2->tv_sec; 841 t1->tv_nsec += t2->tv_nsec; 842 timespecfix(t1); 843 } 844 845 void 846 timespecsub(timespec_t *t1, timespec_t *t2) 847 { 848 t1->tv_sec -= t2->tv_sec; 849 t1->tv_nsec -= t2->tv_nsec; 850 timespecfix(t1); 851 } 852 853 void 854 timespecfix(timespec_t *t1) 855 { 856 if (t1->tv_nsec < 0) { 857 t1->tv_sec--; 858 t1->tv_nsec += NANOSEC; 859 } else { 860 if (t1->tv_nsec >= NANOSEC) { 861 t1->tv_sec++; 862 t1->tv_nsec -= NANOSEC; 863 } 864 } 865 } 866 867 /* 868 * Compute number of hz until specified time. 869 * Used to compute third argument to timeout() from an absolute time. 870 */ 871 clock_t 872 hzto(struct timeval *tv) 873 { 874 timespec_t ts, now; 875 876 ts.tv_sec = tv->tv_sec; 877 ts.tv_nsec = tv->tv_usec * 1000; 878 gethrestime_lasttick(&now); 879 880 return (timespectohz(&ts, now)); 881 } 882 883 /* 884 * Compute number of hz until specified time for a given timespec value. 885 * Used to compute third argument to timeout() from an absolute time. 886 */ 887 clock_t 888 timespectohz(timespec_t *tv, timespec_t now) 889 { 890 clock_t ticks; 891 time_t sec; 892 int nsec; 893 894 /* 895 * Compute number of ticks we will see between now and 896 * the target time; returns "1" if the destination time 897 * is before the next tick, so we always get some delay, 898 * and returns LONG_MAX ticks if we would overflow. 899 */ 900 sec = tv->tv_sec - now.tv_sec; 901 nsec = tv->tv_nsec - now.tv_nsec + nsec_per_tick - 1; 902 903 if (nsec < 0) { 904 sec--; 905 nsec += NANOSEC; 906 } else if (nsec >= NANOSEC) { 907 sec++; 908 nsec -= NANOSEC; 909 } 910 911 ticks = NSEC_TO_TICK(nsec); 912 913 /* 914 * Compute ticks, accounting for negative and overflow as above. 915 * Overflow protection kicks in at about 70 weeks for hz=50 916 * and at about 35 weeks for hz=100. (Rather longer for the 64-bit 917 * kernel :-) 918 */ 919 if (sec < 0 || (sec == 0 && ticks < 1)) 920 ticks = 1; /* protect vs nonpositive */ 921 else if (sec > (LONG_MAX - ticks) / hz) 922 ticks = LONG_MAX; /* protect vs overflow */ 923 else 924 ticks += sec * hz; /* common case */ 925 926 return (ticks); 927 } 928 929 /* 930 * Compute number of hz with the timespec tv specified. 931 * The return type must be 64 bit integer. 932 */ 933 int64_t 934 timespectohz64(timespec_t *tv) 935 { 936 int64_t ticks; 937 int64_t sec; 938 int64_t nsec; 939 940 sec = tv->tv_sec; 941 nsec = tv->tv_nsec + nsec_per_tick - 1; 942 943 if (nsec < 0) { 944 sec--; 945 nsec += NANOSEC; 946 } else if (nsec >= NANOSEC) { 947 sec++; 948 nsec -= NANOSEC; 949 } 950 951 ticks = NSEC_TO_TICK(nsec); 952 953 /* 954 * Compute ticks, accounting for negative and overflow as above. 955 * Overflow protection kicks in at about 70 weeks for hz=50 956 * and at about 35 weeks for hz=100. (Rather longer for the 64-bit 957 * kernel 958 */ 959 if (sec < 0 || (sec == 0 && ticks < 1)) 960 ticks = 1; /* protect vs nonpositive */ 961 else if (sec > (((~0ULL) >> 1) - ticks) / hz) 962 ticks = (~0ULL) >> 1; /* protect vs overflow */ 963 else 964 ticks += sec * hz; /* common case */ 965 966 return (ticks); 967 } 968 969 /* 970 * hrt2ts(): convert from hrtime_t to timestruc_t. 971 * 972 * All this routine really does is: 973 * 974 * tsp->sec = hrt / NANOSEC; 975 * tsp->nsec = hrt % NANOSEC; 976 * 977 * The black magic below avoids doing a 64-bit by 32-bit integer divide, 978 * which is quite expensive. There's actually much more going on here than 979 * it might first appear -- don't try this at home. 980 * 981 * For the adventuresome, here's an explanation of how it works. 982 * 983 * Multiplication by a fixed constant is easy -- you just do the appropriate 984 * shifts and adds. For example, to multiply by 10, we observe that 985 * 986 * x * 10 = x * (8 + 2) 987 * = (x * 8) + (x * 2) 988 * = (x << 3) + (x << 1). 989 * 990 * In general, you can read the algorithm right off the bits: the number 10 991 * is 1010 in binary; bits 1 and 3 are ones, so x * 10 = (x << 1) + (x << 3). 992 * 993 * Sometimes you can do better. For example, 15 is 1111 binary, so the normal 994 * shift/add computation is x * 15 = (x << 0) + (x << 1) + (x << 2) + (x << 3). 995 * But, it's cheaper if you capitalize on the fact that you have a run of ones: 996 * 1111 = 10000 - 1, hence x * 15 = (x << 4) - (x << 0). [You would never 997 * actually perform the operation << 0, since it's a no-op; I'm just writing 998 * it that way for clarity.] 999 * 1000 * The other way you can win is if you get lucky with the prime factorization 1001 * of your constant. The number 1,000,000,000, which we have to multiply 1002 * by below, is a good example. One billion is 111011100110101100101000000000 1003 * in binary. If you apply the bit-grouping trick, it doesn't buy you very 1004 * much, because it's only a win for groups of three or more equal bits: 1005 * 1006 * 111011100110101100101000000000 = 1000000000000000000000000000000 1007 * - 000100011001010011011000000000 1008 * 1009 * Thus, instead of the 13 shift/add pairs (26 operations) implied by the LHS, 1010 * we have reduced this to 10 shift/add pairs (20 operations) on the RHS. 1011 * This is better, but not great. 1012 * 1013 * However, we can factor 1,000,000,000 = 2^9 * 5^9 = 2^9 * 125 * 125 * 125, 1014 * and multiply by each factor. Multiplication by 125 is particularly easy, 1015 * since 128 is nearby: x * 125 = (x << 7) - x - x - x, which is just four 1016 * operations. So, to multiply by 1,000,000,000, we perform three multipli- 1017 * cations by 125, then << 9, a total of only 3 * 4 + 1 = 13 operations. 1018 * This is the algorithm we actually use in both hrt2ts() and ts2hrt(). 1019 * 1020 * Division is harder; there is no equivalent of the simple shift-add algorithm 1021 * we used for multiplication. However, we can convert the division problem 1022 * into a multiplication problem by pre-computing the binary representation 1023 * of the reciprocal of the divisor. For the case of interest, we have 1024 * 1025 * 1 / 1,000,000,000 = 1.0001001011100000101111101000001B-30, 1026 * 1027 * to 32 bits of precision. (The notation B-30 means "* 2^-30", just like 1028 * E-18 means "* 10^-18".) 1029 * 1030 * So, to compute x / 1,000,000,000, we just multiply x by the 32-bit 1031 * integer 10001001011100000101111101000001, then normalize (shift) the 1032 * result. This constant has several large bits runs, so the multiply 1033 * is relatively cheap: 1034 * 1035 * 10001001011100000101111101000001 = 10001001100000000110000001000001 1036 * - 00000000000100000000000100000000 1037 * 1038 * Again, you can just read the algorithm right off the bits: 1039 * 1040 * sec = hrt; 1041 * sec += (hrt << 6); 1042 * sec -= (hrt << 8); 1043 * sec += (hrt << 13); 1044 * sec += (hrt << 14); 1045 * sec -= (hrt << 20); 1046 * sec += (hrt << 23); 1047 * sec += (hrt << 24); 1048 * sec += (hrt << 27); 1049 * sec += (hrt << 31); 1050 * sec >>= (32 + 30); 1051 * 1052 * Voila! The only problem is, since hrt is 64 bits, we need to use 96-bit 1053 * arithmetic to perform this calculation. That's a waste, because ultimately 1054 * we only need the highest 32 bits of the result. 1055 * 1056 * The first thing we do is to realize that we don't need to use all of hrt 1057 * in the calculation. The lowest 30 bits can contribute at most 1 to the 1058 * quotient (2^30 / 1,000,000,000 = 1.07...), so we'll deal with them later. 1059 * The highest 2 bits have to be zero, or hrt won't fit in a timestruc_t. 1060 * Thus, the only bits of hrt that matter for division are bits 30..61. 1061 * These 32 bits are just the lower-order word of (hrt >> 30). This brings 1062 * us down from 96-bit math to 64-bit math, and our algorithm becomes: 1063 * 1064 * tmp = (uint32_t) (hrt >> 30); 1065 * sec = tmp; 1066 * sec += (tmp << 6); 1067 * sec -= (tmp << 8); 1068 * sec += (tmp << 13); 1069 * sec += (tmp << 14); 1070 * sec -= (tmp << 20); 1071 * sec += (tmp << 23); 1072 * sec += (tmp << 24); 1073 * sec += (tmp << 27); 1074 * sec += (tmp << 31); 1075 * sec >>= 32; 1076 * 1077 * Next, we're going to reduce this 64-bit computation to a 32-bit 1078 * computation. We begin by rewriting the above algorithm to use relative 1079 * shifts instead of absolute shifts. That is, instead of computing 1080 * tmp << 6, tmp << 8, tmp << 13, etc, we'll just shift incrementally: 1081 * tmp <<= 6, tmp <<= 2 (== 8 - 6), tmp <<= 5 (== 13 - 8), etc: 1082 * 1083 * tmp = (uint32_t) (hrt >> 30); 1084 * sec = tmp; 1085 * tmp <<= 6; sec += tmp; 1086 * tmp <<= 2; sec -= tmp; 1087 * tmp <<= 5; sec += tmp; 1088 * tmp <<= 1; sec += tmp; 1089 * tmp <<= 6; sec -= tmp; 1090 * tmp <<= 3; sec += tmp; 1091 * tmp <<= 1; sec += tmp; 1092 * tmp <<= 3; sec += tmp; 1093 * tmp <<= 4; sec += tmp; 1094 * sec >>= 32; 1095 * 1096 * Now for the final step. Instead of throwing away the low 32 bits at 1097 * the end, we can throw them away as we go, only keeping the high 32 bits 1098 * of the product at each step. So, for example, where we now have 1099 * 1100 * tmp <<= 6; sec = sec + tmp; 1101 * we will instead have 1102 * tmp <<= 6; sec = (sec + tmp) >> 6; 1103 * which is equivalent to 1104 * sec = (sec >> 6) + tmp; 1105 * 1106 * The final shift ("sec >>= 32") goes away. 1107 * 1108 * All we're really doing here is long multiplication, just like we learned in 1109 * grade school, except that at each step, we only look at the leftmost 32 1110 * columns. The cumulative error is, at most, the sum of all the bits we 1111 * throw away, which is 2^-32 + 2^-31 + ... + 2^-2 + 2^-1 == 1 - 2^-32. 1112 * Thus, the final result ("sec") is correct to +/- 1. 1113 * 1114 * It turns out to be important to keep "sec" positive at each step, because 1115 * we don't want to have to explicitly extend the sign bit. Therefore, 1116 * starting with the last line of code above, each line that would have read 1117 * "sec = (sec >> n) - tmp" must be changed to "sec = tmp - (sec >> n)", and 1118 * the operators (+ or -) in all previous lines must be toggled accordingly. 1119 * Thus, we end up with: 1120 * 1121 * tmp = (uint32_t) (hrt >> 30); 1122 * sec = tmp + (sec >> 6); 1123 * sec = tmp - (tmp >> 2); 1124 * sec = tmp - (sec >> 5); 1125 * sec = tmp + (sec >> 1); 1126 * sec = tmp - (sec >> 6); 1127 * sec = tmp - (sec >> 3); 1128 * sec = tmp + (sec >> 1); 1129 * sec = tmp + (sec >> 3); 1130 * sec = tmp + (sec >> 4); 1131 * 1132 * This yields a value for sec that is accurate to +1/-1, so we have two 1133 * cases to deal with. The mysterious-looking "+ 7" in the code below biases 1134 * the rounding toward zero, so that sec is always less than or equal to 1135 * the correct value. With this modified code, sec is accurate to +0/-2, with 1136 * the -2 case being very rare in practice. With this change, we only have to 1137 * deal with one case (sec too small) in the cleanup code. 1138 * 1139 * The other modification we make is to delete the second line above 1140 * ("sec = tmp + (sec >> 6);"), since it only has an effect when bit 31 is 1141 * set, and the cleanup code can handle that rare case. This reduces the 1142 * *guaranteed* accuracy of sec to +0/-3, but speeds up the common cases. 1143 * 1144 * Finally, we compute nsec = hrt - (sec * 1,000,000,000). nsec will always 1145 * be positive (since sec is never too large), and will at most be equal to 1146 * the error in sec (times 1,000,000,000) plus the low-order 30 bits of hrt. 1147 * Thus, nsec < 3 * 1,000,000,000 + 2^30, which is less than 2^32, so we can 1148 * safely assume that nsec fits in 32 bits. Consequently, when we compute 1149 * sec * 1,000,000,000, we only need the low 32 bits, so we can just do 32-bit 1150 * arithmetic and let the high-order bits fall off the end. 1151 * 1152 * Since nsec < 3 * 1,000,000,000 + 2^30 == 4,073,741,824, the cleanup loop: 1153 * 1154 * while (nsec >= NANOSEC) { 1155 * nsec -= NANOSEC; 1156 * sec++; 1157 * } 1158 * 1159 * is guaranteed to complete in at most 4 iterations. In practice, the loop 1160 * completes in 0 or 1 iteration over 95% of the time. 1161 * 1162 * On an SS2, this implementation of hrt2ts() takes 1.7 usec, versus about 1163 * 35 usec for software division -- about 20 times faster. 1164 */ 1165 void 1166 hrt2ts(hrtime_t hrt, timestruc_t *tsp) 1167 { 1168 uint32_t sec, nsec, tmp; 1169 1170 tmp = (uint32_t)(hrt >> 30); 1171 sec = tmp - (tmp >> 2); 1172 sec = tmp - (sec >> 5); 1173 sec = tmp + (sec >> 1); 1174 sec = tmp - (sec >> 6) + 7; 1175 sec = tmp - (sec >> 3); 1176 sec = tmp + (sec >> 1); 1177 sec = tmp + (sec >> 3); 1178 sec = tmp + (sec >> 4); 1179 tmp = (sec << 7) - sec - sec - sec; 1180 tmp = (tmp << 7) - tmp - tmp - tmp; 1181 tmp = (tmp << 7) - tmp - tmp - tmp; 1182 nsec = (uint32_t)hrt - (tmp << 9); 1183 while (nsec >= NANOSEC) { 1184 nsec -= NANOSEC; 1185 sec++; 1186 } 1187 tsp->tv_sec = (time_t)sec; 1188 tsp->tv_nsec = nsec; 1189 } 1190 1191 /* 1192 * Convert from timestruc_t to hrtime_t. 1193 * 1194 * The code below is equivalent to: 1195 * 1196 * hrt = tsp->tv_sec * NANOSEC + tsp->tv_nsec; 1197 * 1198 * but requires no integer multiply. 1199 */ 1200 hrtime_t 1201 ts2hrt(const timestruc_t *tsp) 1202 { 1203 hrtime_t hrt; 1204 1205 hrt = tsp->tv_sec; 1206 hrt = (hrt << 7) - hrt - hrt - hrt; 1207 hrt = (hrt << 7) - hrt - hrt - hrt; 1208 hrt = (hrt << 7) - hrt - hrt - hrt; 1209 hrt = (hrt << 9) + tsp->tv_nsec; 1210 return (hrt); 1211 } 1212 1213 /* 1214 * For the various 32-bit "compatibility" paths in the system. 1215 */ 1216 void 1217 hrt2ts32(hrtime_t hrt, timestruc32_t *ts32p) 1218 { 1219 timestruc_t ts; 1220 1221 hrt2ts(hrt, &ts); 1222 TIMESPEC_TO_TIMESPEC32(ts32p, &ts); 1223 } 1224 1225 /* 1226 * If this ever becomes performance critical (ha!), we can borrow the 1227 * code from ts2hrt(), above, to multiply tv_sec by 1,000,000 and the 1228 * straightforward (x << 10) - (x << 5) + (x << 3) to multiply tv_usec by 1229 * 1,000. For now, we'll opt for readability (besides, the compiler does 1230 * a passable job of optimizing constant multiplication into shifts and adds). 1231 */ 1232 hrtime_t 1233 tv2hrt(struct timeval *tvp) 1234 { 1235 return ((hrtime_t)tvp->tv_sec * NANOSEC + 1236 (hrtime_t)tvp->tv_usec * (NANOSEC / MICROSEC)); 1237 } 1238 1239 void 1240 hrt2tv(hrtime_t hrt, struct timeval *tvp) 1241 { 1242 uint32_t sec, nsec, tmp; 1243 uint32_t q, r, t; 1244 1245 tmp = (uint32_t)(hrt >> 30); 1246 sec = tmp - (tmp >> 2); 1247 sec = tmp - (sec >> 5); 1248 sec = tmp + (sec >> 1); 1249 sec = tmp - (sec >> 6) + 7; 1250 sec = tmp - (sec >> 3); 1251 sec = tmp + (sec >> 1); 1252 sec = tmp + (sec >> 3); 1253 sec = tmp + (sec >> 4); 1254 tmp = (sec << 7) - sec - sec - sec; 1255 tmp = (tmp << 7) - tmp - tmp - tmp; 1256 tmp = (tmp << 7) - tmp - tmp - tmp; 1257 nsec = (uint32_t)hrt - (tmp << 9); 1258 while (nsec >= NANOSEC) { 1259 nsec -= NANOSEC; 1260 sec++; 1261 } 1262 tvp->tv_sec = (time_t)sec; 1263 /* 1264 * this routine is very similar to hr2ts, but requires microseconds 1265 * instead of nanoseconds, so an interger divide by 1000 routine 1266 * completes the conversion 1267 */ 1268 t = (nsec >> 7) + (nsec >> 8) + (nsec >> 12); 1269 q = (nsec >> 1) + t + (nsec >> 15) + (t >> 11) + (t >> 14); 1270 q = q >> 9; 1271 r = nsec - q*1000; 1272 tvp->tv_usec = q + ((r + 24) >> 10); 1273 1274 } 1275 1276 int 1277 nanosleep(timespec_t *rqtp, timespec_t *rmtp) 1278 { 1279 timespec_t rqtime; 1280 timespec_t rmtime; 1281 timespec_t now; 1282 int timecheck; 1283 int ret = 1; 1284 model_t datamodel = get_udatamodel(); 1285 1286 timecheck = timechanged; 1287 gethrestime(&now); 1288 1289 if (datamodel == DATAMODEL_NATIVE) { 1290 if (copyin(rqtp, &rqtime, sizeof (rqtime))) 1291 return (set_errno(EFAULT)); 1292 } else { 1293 timespec32_t rqtime32; 1294 1295 if (copyin(rqtp, &rqtime32, sizeof (rqtime32))) 1296 return (set_errno(EFAULT)); 1297 TIMESPEC32_TO_TIMESPEC(&rqtime, &rqtime32); 1298 } 1299 1300 if (rqtime.tv_sec < 0 || rqtime.tv_nsec < 0 || 1301 rqtime.tv_nsec >= NANOSEC) 1302 return (set_errno(EINVAL)); 1303 1304 if (timerspecisset(&rqtime)) { 1305 timespecadd(&rqtime, &now); 1306 mutex_enter(&curthread->t_delay_lock); 1307 while ((ret = cv_waituntil_sig(&curthread->t_delay_cv, 1308 &curthread->t_delay_lock, &rqtime, timecheck)) > 0) 1309 continue; 1310 mutex_exit(&curthread->t_delay_lock); 1311 } 1312 1313 if (rmtp) { 1314 /* 1315 * If cv_waituntil_sig() returned due to a signal, and 1316 * there is time remaining, then set the time remaining. 1317 * Else set time remaining to zero 1318 */ 1319 rmtime.tv_sec = rmtime.tv_nsec = 0; 1320 if (ret == 0) { 1321 timespec_t delta = rqtime; 1322 1323 gethrestime(&now); 1324 timespecsub(&delta, &now); 1325 if (delta.tv_sec > 0 || (delta.tv_sec == 0 && 1326 delta.tv_nsec > 0)) 1327 rmtime = delta; 1328 } 1329 1330 if (datamodel == DATAMODEL_NATIVE) { 1331 if (copyout(&rmtime, rmtp, sizeof (rmtime))) 1332 return (set_errno(EFAULT)); 1333 } else { 1334 timespec32_t rmtime32; 1335 1336 TIMESPEC_TO_TIMESPEC32(&rmtime32, &rmtime); 1337 if (copyout(&rmtime32, rmtp, sizeof (rmtime32))) 1338 return (set_errno(EFAULT)); 1339 } 1340 } 1341 1342 if (ret == 0) 1343 return (set_errno(EINTR)); 1344 return (0); 1345 } 1346 1347 /* 1348 * Routines to convert standard UNIX time (seconds since Jan 1, 1970) 1349 * into year/month/day/hour/minute/second format, and back again. 1350 * Note: these routines require tod_lock held to protect cached state. 1351 */ 1352 static int days_thru_month[64] = { 1353 0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366, 0, 0, 1354 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365, 0, 0, 1355 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365, 0, 0, 1356 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365, 0, 0, 1357 }; 1358 1359 todinfo_t saved_tod; 1360 int saved_utc = -60; 1361 1362 todinfo_t 1363 utc_to_tod(time_t utc) 1364 { 1365 long dse, day, month, year; 1366 todinfo_t tod; 1367 1368 ASSERT(MUTEX_HELD(&tod_lock)); 1369 1370 /* 1371 * Note that tod_set_prev() assumes utc will be set to zero in 1372 * the case of it being negative. Consequently, any change made 1373 * to this behavior would have to be reflected in that function 1374 * as well. 1375 */ 1376 if (utc < 0) /* should never happen */ 1377 utc = 0; 1378 1379 saved_tod.tod_sec += utc - saved_utc; 1380 saved_utc = utc; 1381 if (saved_tod.tod_sec >= 0 && saved_tod.tod_sec < 60) 1382 return (saved_tod); /* only the seconds changed */ 1383 1384 dse = utc / 86400; /* days since epoch */ 1385 1386 tod.tod_sec = utc % 60; 1387 tod.tod_min = (utc % 3600) / 60; 1388 tod.tod_hour = (utc % 86400) / 3600; 1389 tod.tod_dow = (dse + 4) % 7 + 1; /* epoch was a Thursday */ 1390 1391 year = dse / 365 + 72; /* first guess -- always a bit too large */ 1392 do { 1393 year--; 1394 day = dse - 365 * (year - 70) - ((year - 69) >> 2); 1395 } while (day < 0); 1396 1397 month = ((year & 3) << 4) + 1; 1398 while (day >= days_thru_month[month + 1]) 1399 month++; 1400 1401 tod.tod_day = day - days_thru_month[month] + 1; 1402 tod.tod_month = month & 15; 1403 tod.tod_year = year; 1404 1405 saved_tod = tod; 1406 return (tod); 1407 } 1408 1409 time_t 1410 tod_to_utc(todinfo_t tod) 1411 { 1412 time_t utc; 1413 int year = tod.tod_year; 1414 int month = tod.tod_month + ((year & 3) << 4); 1415 #ifdef DEBUG 1416 /* only warn once, not each time called */ 1417 static int year_warn = 1; 1418 static int month_warn = 1; 1419 static int day_warn = 1; 1420 static int hour_warn = 1; 1421 static int min_warn = 1; 1422 static int sec_warn = 1; 1423 int days_diff = days_thru_month[month + 1] - days_thru_month[month]; 1424 #endif 1425 1426 ASSERT(MUTEX_HELD(&tod_lock)); 1427 1428 #ifdef DEBUG 1429 if (year_warn && (year < 70 || year > 8029)) { 1430 cmn_err(CE_WARN, 1431 "The hardware real-time clock appears to have the " 1432 "wrong years value %d -- time needs to be reset\n", 1433 year); 1434 year_warn = 0; 1435 } 1436 1437 if (month_warn && (tod.tod_month < 1 || tod.tod_month > 12)) { 1438 cmn_err(CE_WARN, 1439 "The hardware real-time clock appears to have the " 1440 "wrong months value %d -- time needs to be reset\n", 1441 tod.tod_month); 1442 month_warn = 0; 1443 } 1444 1445 if (day_warn && (tod.tod_day < 1 || tod.tod_day > days_diff)) { 1446 cmn_err(CE_WARN, 1447 "The hardware real-time clock appears to have the " 1448 "wrong days value %d -- time needs to be reset\n", 1449 tod.tod_day); 1450 day_warn = 0; 1451 } 1452 1453 if (hour_warn && (tod.tod_hour < 0 || tod.tod_hour > 23)) { 1454 cmn_err(CE_WARN, 1455 "The hardware real-time clock appears to have the " 1456 "wrong hours value %d -- time needs to be reset\n", 1457 tod.tod_hour); 1458 hour_warn = 0; 1459 } 1460 1461 if (min_warn && (tod.tod_min < 0 || tod.tod_min > 59)) { 1462 cmn_err(CE_WARN, 1463 "The hardware real-time clock appears to have the " 1464 "wrong minutes value %d -- time needs to be reset\n", 1465 tod.tod_min); 1466 min_warn = 0; 1467 } 1468 1469 if (sec_warn && (tod.tod_sec < 0 || tod.tod_sec > 59)) { 1470 cmn_err(CE_WARN, 1471 "The hardware real-time clock appears to have the " 1472 "wrong seconds value %d -- time needs to be reset\n", 1473 tod.tod_sec); 1474 sec_warn = 0; 1475 } 1476 #endif 1477 1478 utc = (year - 70); /* next 3 lines: utc = 365y + y/4 */ 1479 utc += (utc << 3) + (utc << 6); 1480 utc += (utc << 2) + ((year - 69) >> 2); 1481 utc += days_thru_month[month] + tod.tod_day - 1; 1482 utc = (utc << 3) + (utc << 4) + tod.tod_hour; /* 24 * day + hour */ 1483 utc = (utc << 6) - (utc << 2) + tod.tod_min; /* 60 * hour + min */ 1484 utc = (utc << 6) - (utc << 2) + tod.tod_sec; /* 60 * min + sec */ 1485 1486 return (utc); 1487 }