root/kernel/time.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. mktime
  2. time_init
  3. sys_time
  4. sys_stime
  5. do_gettimeoffset
  6. do_gettimeofday
  7. sys_gettimeofday
  8. warp_clock
  9. sys_settimeofday
  10. sys_adjtimex
  11. set_rtc_mmss

   1 /*
   2  *  linux/kernel/time.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *
   6  *  This file contains the interface functions for the various
   7  *  time related system calls: time, stime, gettimeofday, settimeofday,
   8  *                             adjtime
   9  */
  10 /*
  11  * Modification history kernel/time.c
  12  * 
  13  * 1993-09-02    Philip Gladstone
  14  *      Created file with time related functions from sched.c and adjtimex() 
  15  * 1993-10-08    Torsten Duwe
  16  *      adjtime interface update and CMOS clock write code
  17  * 1994-07-02    Alan Modra
  18  *      fixed set_rtc_mmss, fixed time.year for >= 2000, new mktime
  19  * 1995-03-26    Markus Kuhn
  20  *      fixed 500 ms bug at call to set_rtc_mmss, fixed DS12887
  21  *      precision CMOS clock update
  22  *
  23  * to do: adjtimex() has to be updated to recent (1994-12-13) revision
  24  *        of David Mill's kernel clock model. For more information, check
  25  *        <ftp://louie.udel.edu/pub/ntp/kernel.tar.Z>. 
  26  */
  27 
  28 #include <linux/errno.h>
  29 #include <linux/sched.h>
  30 #include <linux/kernel.h>
  31 #include <linux/param.h>
  32 #include <linux/string.h>
  33 #include <linux/mm.h>
  34 
  35 #include <asm/segment.h>
  36 #include <asm/io.h>
  37 
  38 #include <linux/mc146818rtc.h>
  39 #include <linux/timex.h>
  40 
  41 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
  42  * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
  43  * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
  44  *
  45  * [For the Julian calendar (which was used in Russia before 1917,
  46  * Britain & colonies before 1752, anywhere else before 1582,
  47  * and is still in use by some communities) leave out the
  48  * -year/100+year/400 terms, and add 10.]
  49  *
  50  * This algorithm was first published by Gauss (I think).
  51  *
  52  * WARNING: this function will overflow on 2106-02-07 06:28:16 on
  53  * machines were long is 32-bit! (However, as time_t is signed, we
  54  * will already get problems at other places on 2038-01-19 03:14:08)
  55  */
  56 static inline unsigned long mktime(unsigned int year, unsigned int mon,
     /* [previous][next][first][last][top][bottom][index][help] */
  57         unsigned int day, unsigned int hour,
  58         unsigned int min, unsigned int sec)
  59 {
  60         if (0 >= (int) (mon -= 2)) {    /* 1..12 -> 11,12,1..10 */
  61                 mon += 12;      /* Puts Feb last since it has leap day */
  62                 year -= 1;
  63         }
  64         return (((
  65             (unsigned long)(year/4 - year/100 + year/400 + 367*mon/12 + day) +
  66               year*365 - 719499
  67             )*24 + hour /* now have hours */
  68            )*60 + min /* now have minutes */
  69           )*60 + sec; /* finally seconds */
  70 }
  71 
  72 void time_init(void)
     /* [previous][next][first][last][top][bottom][index][help] */
  73 {
  74         unsigned int year, mon, day, hour, min, sec;
  75         int i;
  76 
  77         /* The Linux interpretation of the CMOS clock register contents:
  78          * When the Update-In-Progress (UIP) flag goes from 1 to 0, the
  79          * RTC registers show the second which has precisely just started.
  80          * Let's hope other operating systems interpret the RTC the same way.
  81          */
  82         /* read RTC exactly on falling edge of update flag */
  83         for (i = 0 ; i < 1000000 ; i++) /* may take up to 1 second... */
  84                 if (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP)
  85                         break;
  86         for (i = 0 ; i < 1000000 ; i++) /* must try at least 2.228 ms */
  87                 if (!(CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP))
  88                         break;
  89         do { /* Isn't this overkill ? UIP above should guarantee consistency */
  90                 sec = CMOS_READ(RTC_SECONDS);
  91                 min = CMOS_READ(RTC_MINUTES);
  92                 hour = CMOS_READ(RTC_HOURS);
  93                 day = CMOS_READ(RTC_DAY_OF_MONTH);
  94                 mon = CMOS_READ(RTC_MONTH);
  95                 year = CMOS_READ(RTC_YEAR);
  96         } while (sec != CMOS_READ(RTC_SECONDS));
  97         if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
  98           {
  99             BCD_TO_BIN(sec);
 100             BCD_TO_BIN(min);
 101             BCD_TO_BIN(hour);
 102             BCD_TO_BIN(day);
 103             BCD_TO_BIN(mon);
 104             BCD_TO_BIN(year);
 105           }
 106 #if defined(__alpha__) && defined(CONFIG_PCI)
 107         /*
 108          * The meaning of life, the universe, and everything. Plus
 109          * this makes the year come out right.
 110          */
 111         year -= 42;
 112 #endif
 113         if ((year += 1900) < 1970)
 114                 year += 100;
 115         xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
 116         xtime.tv_usec = 0;
 117 }
 118 
 119 /* 
 120  * The timezone where the local system is located.  Used as a default by some
 121  * programs who obtain this value by using gettimeofday.
 122  */
 123 struct timezone sys_tz = { 0, 0};
 124 
 125 asmlinkage int sys_time(int * tloc)
     /* [previous][next][first][last][top][bottom][index][help] */
 126 {
 127         int i, error;
 128 
 129         i = CURRENT_TIME;
 130         if (tloc) {
 131                 error = verify_area(VERIFY_WRITE, tloc, sizeof(*tloc));
 132                 if (error)
 133                         return error;
 134                 put_user(i,tloc);
 135         }
 136         return i;
 137 }
 138 
 139 asmlinkage int sys_stime(int * tptr)
     /* [previous][next][first][last][top][bottom][index][help] */
 140 {
 141         int error, value;
 142 
 143         if (!suser())
 144                 return -EPERM;
 145         error = verify_area(VERIFY_READ, tptr, sizeof(*tptr));
 146         if (error)
 147                 return error;
 148         value = get_user(tptr);
 149         cli();
 150         xtime.tv_sec = value;
 151         xtime.tv_usec = 0;
 152         time_status = TIME_BAD;
 153         time_maxerror = 0x70000000;
 154         time_esterror = 0x70000000;
 155         sti();
 156         return 0;
 157 }
 158 
 159 /* This function must be called with interrupts disabled 
 160  * It was inspired by Steve McCanne's microtime-i386 for BSD.  -- jrs
 161  * 
 162  * However, the pc-audio speaker driver changes the divisor so that
 163  * it gets interrupted rather more often - it loads 64 into the
 164  * counter rather than 11932! This has an adverse impact on
 165  * do_gettimeoffset() -- it stops working! What is also not
 166  * good is that the interval that our timer function gets called
 167  * is no longer 10.0002 ms, but 9.9767 ms. To get around this
 168  * would require using a different timing source. Maybe someone
 169  * could use the RTC - I know that this can interrupt at frequencies
 170  * ranging from 8192Hz to 2Hz. If I had the energy, I'd somehow fix
 171  * it so that at startup, the timer code in sched.c would select
 172  * using either the RTC or the 8253 timer. The decision would be
 173  * based on whether there was any other device around that needed
 174  * to trample on the 8253. I'd set up the RTC to interrupt at 1024 Hz,
 175  * and then do some jiggery to have a version of do_timer that 
 176  * advanced the clock by 1/1024 s. Every time that reached over 1/100
 177  * of a second, then do all the old code. If the time was kept correct
 178  * then do_gettimeoffset could just return 0 - there is no low order
 179  * divider that can be accessed.
 180  *
 181  * Ideally, you would be able to use the RTC for the speaker driver,
 182  * but it appears that the speaker driver really needs interrupt more
 183  * often than every 120 us or so.
 184  *
 185  * Anyway, this needs more thought....          pjsg (1993-08-28)
 186  * 
 187  * If you are really that interested, you should be reading
 188  * comp.protocols.time.ntp!
 189  */
 190 
 191 #define TICK_SIZE tick
 192 
 193 static inline unsigned long do_gettimeoffset(void)
     /* [previous][next][first][last][top][bottom][index][help] */
 194 {
 195         int count;
 196         unsigned long offset = 0;
 197 
 198         /* timer count may underflow right here */
 199         outb_p(0x00, 0x43);     /* latch the count ASAP */
 200         count = inb_p(0x40);    /* read the latched count */
 201         count |= inb(0x40) << 8;
 202         /* we know probability of underflow is always MUCH less than 1% */
 203         if (count > (LATCH - LATCH/100)) {
 204                 /* check for pending timer interrupt */
 205                 outb_p(0x0a, 0x20);
 206                 if (inb(0x20) & 1)
 207                         offset = TICK_SIZE;
 208         }
 209         count = ((LATCH-1) - count) * TICK_SIZE;
 210         count = (count + LATCH/2) / LATCH;
 211         return offset + count;
 212 }
 213 
 214 /*
 215  * This version of gettimeofday has near microsecond resolution.
 216  */
 217 void do_gettimeofday(struct timeval *tv)
     /* [previous][next][first][last][top][bottom][index][help] */
 218 {
 219         unsigned long flags;
 220 
 221         save_flags(flags);
 222         cli();
 223         *tv = xtime;
 224 #if defined (__i386__) || defined (__mips__)
 225         tv->tv_usec += do_gettimeoffset();
 226         if (tv->tv_usec >= 1000000) {
 227                 tv->tv_usec -= 1000000;
 228                 tv->tv_sec++;
 229         }
 230 #endif /* !defined (__i386__) && !defined (__mips__) */
 231         restore_flags(flags);
 232 }
 233 
 234 asmlinkage int sys_gettimeofday(struct timeval *tv, struct timezone *tz)
     /* [previous][next][first][last][top][bottom][index][help] */
 235 {
 236         int error;
 237 
 238         if (tv) {
 239                 struct timeval ktv;
 240                 error = verify_area(VERIFY_WRITE, tv, sizeof *tv);
 241                 if (error)
 242                         return error;
 243                 do_gettimeofday(&ktv);
 244                 memcpy_tofs(tv, &ktv, sizeof(ktv));
 245         }
 246         if (tz) {
 247                 error = verify_area(VERIFY_WRITE, tz, sizeof *tz);
 248                 if (error)
 249                         return error;
 250                 memcpy_tofs(tz, &sys_tz, sizeof(sys_tz));
 251         }
 252         return 0;
 253 }
 254 
 255 /*
 256  * Adjust the time obtained from the CMOS to be UTC time instead of
 257  * local time.
 258  * 
 259  * This is ugly, but preferable to the alternatives.  Otherwise we
 260  * would either need to write a program to do it in /etc/rc (and risk
 261  * confusion if the program gets run more than once; it would also be 
 262  * hard to make the program warp the clock precisely n hours)  or
 263  * compile in the timezone information into the kernel.  Bad, bad....
 264  *
 265  *                                              - TYT, 1992-01-01
 266  *
 267  * The best thing to do is to keep the CMOS clock in universal time (UTC)
 268  * as real UNIX machines always do it. This avoids all headaches about
 269  * daylight saving times and warping kernel clocks.
 270  */
 271 inline static void warp_clock(void)
     /* [previous][next][first][last][top][bottom][index][help] */
 272 {
 273         cli();
 274         xtime.tv_sec += sys_tz.tz_minuteswest * 60;
 275         sti();
 276 }
 277 
 278 /*
 279  * In case for some reason the CMOS clock has not already been running
 280  * in UTC, but in some local time: The first time we set the timezone,
 281  * we will warp the clock so that it is ticking UTC time instead of
 282  * local time. Presumably, if someone is setting the timezone then we
 283  * are running in an environment where the programs understand about
 284  * timezones. This should be done at boot time in the /etc/rc script,
 285  * as soon as possible, so that the clock can be set right. Otherwise,
 286  * various programs will get confused when the clock gets warped.
 287  */
 288 asmlinkage int sys_settimeofday(struct timeval *tv, struct timezone *tz)
     /* [previous][next][first][last][top][bottom][index][help] */
 289 {
 290         static int      firsttime = 1;
 291         struct timeval  new_tv;
 292         struct timezone new_tz;
 293 
 294         if (!suser())
 295                 return -EPERM;
 296         if (tv) {
 297                 int error = verify_area(VERIFY_READ, tv, sizeof(*tv));
 298                 if (error)
 299                         return error;
 300                 memcpy_fromfs(&new_tv, tv, sizeof(*tv));
 301         }
 302         if (tz) {
 303                 int error = verify_area(VERIFY_READ, tz, sizeof(*tz));
 304                 if (error)
 305                         return error;
 306                 memcpy_fromfs(&new_tz, tz, sizeof(*tz));
 307         }
 308         if (tz) {
 309                 sys_tz = new_tz;
 310                 if (firsttime) {
 311                         firsttime = 0;
 312                         if (!tv)
 313                                 warp_clock();
 314                 }
 315         }
 316         if (tv) {
 317                 cli();
 318                 /* This is revolting. We need to set the xtime.tv_usec
 319                  * correctly. However, the value in this location is
 320                  * is value at the last tick.
 321                  * Discover what correction gettimeofday
 322                  * would have done, and then undo it!
 323                  */
 324                 new_tv.tv_usec -= do_gettimeoffset();
 325 
 326                 if (new_tv.tv_usec < 0) {
 327                         new_tv.tv_usec += 1000000;
 328                         new_tv.tv_sec--;
 329                 }
 330 
 331                 xtime = new_tv;
 332                 time_status = TIME_BAD;
 333                 time_maxerror = 0x70000000;
 334                 time_esterror = 0x70000000;
 335                 sti();
 336         }
 337         return 0;
 338 }
 339 
 340 /* adjtimex mainly allows reading (and writing, if superuser) of
 341  * kernel time-keeping variables. used by xntpd.
 342  */
 343 asmlinkage int sys_adjtimex(struct timex *txc_p)
     /* [previous][next][first][last][top][bottom][index][help] */
 344 {
 345         long ltemp, mtemp, save_adjust;
 346         int error;
 347 
 348         /* Local copy of parameter */
 349         struct timex txc;
 350 
 351         error = verify_area(VERIFY_WRITE, txc_p, sizeof(struct timex));
 352         if (error)
 353           return error;
 354 
 355         /* Copy the user data space into the kernel copy
 356          * structure. But bear in mind that the structures
 357          * may change
 358          */
 359         memcpy_fromfs(&txc, txc_p, sizeof(struct timex));
 360 
 361         /* In order to modify anything, you gotta be super-user! */
 362         if (txc.mode && !suser())
 363                 return -EPERM;
 364 
 365         /* Now we validate the data before disabling interrupts
 366          */
 367 
 368         if (txc.mode != ADJ_OFFSET_SINGLESHOT && (txc.mode & ADJ_OFFSET))
 369           /* Microsec field limited to -131000 .. 131000 usecs */
 370           if (txc.offset <= -(1 << (31 - SHIFT_UPDATE))
 371               || txc.offset >= (1 << (31 - SHIFT_UPDATE)))
 372             return -EINVAL;
 373 
 374         /* time_status must be in a fairly small range */
 375         if (txc.mode & ADJ_STATUS)
 376           if (txc.status < TIME_OK || txc.status > TIME_BAD)
 377             return -EINVAL;
 378 
 379         /* if the quartz is off by more than 10% something is VERY wrong ! */
 380         if (txc.mode & ADJ_TICK)
 381           if (txc.tick < 900000/HZ || txc.tick > 1100000/HZ)
 382             return -EINVAL;
 383 
 384         cli();
 385 
 386         /* Save for later - semantics of adjtime is to return old value */
 387         save_adjust = time_adjust;
 388 
 389         /* If there are input parameters, then process them */
 390         if (txc.mode)
 391         {
 392             if (time_status == TIME_BAD)
 393                 time_status = TIME_OK;
 394 
 395             if (txc.mode & ADJ_STATUS)
 396                 time_status = txc.status;
 397 
 398             if (txc.mode & ADJ_FREQUENCY)
 399                 time_freq = txc.frequency << (SHIFT_KF - 16);
 400 
 401             if (txc.mode & ADJ_MAXERROR)
 402                 time_maxerror = txc.maxerror;
 403 
 404             if (txc.mode & ADJ_ESTERROR)
 405                 time_esterror = txc.esterror;
 406 
 407             if (txc.mode & ADJ_TIMECONST)
 408                 time_constant = txc.time_constant;
 409 
 410             if (txc.mode & ADJ_OFFSET)
 411               if (txc.mode == ADJ_OFFSET_SINGLESHOT)
 412                 {
 413                   time_adjust = txc.offset;
 414                 }
 415               else /* XXX should give an error if other bits set */
 416                 {
 417                   time_offset = txc.offset << SHIFT_UPDATE;
 418                   mtemp = xtime.tv_sec - time_reftime;
 419                   time_reftime = xtime.tv_sec;
 420                   if (mtemp > (MAXSEC+2) || mtemp < 0)
 421                     mtemp = 0;
 422 
 423                   if (txc.offset < 0)
 424                     time_freq -= (-txc.offset * mtemp) >>
 425                       (time_constant + time_constant);
 426                   else
 427                     time_freq += (txc.offset * mtemp) >>
 428                       (time_constant + time_constant);
 429 
 430                   ltemp = time_tolerance << SHIFT_KF;
 431 
 432                   if (time_freq > ltemp)
 433                     time_freq = ltemp;
 434                   else if (time_freq < -ltemp)
 435                     time_freq = -ltemp;
 436                 }
 437             if (txc.mode & ADJ_TICK)
 438               tick = txc.tick;
 439 
 440         }
 441         txc.offset         = save_adjust;
 442         txc.frequency      = ((time_freq+1) >> (SHIFT_KF - 16));
 443         txc.maxerror       = time_maxerror;
 444         txc.esterror       = time_esterror;
 445         txc.status         = time_status;
 446         txc.time_constant  = time_constant;
 447         txc.precision      = time_precision;
 448         txc.tolerance      = time_tolerance;
 449         txc.time           = xtime;
 450         txc.tick           = tick;
 451 
 452         sti();
 453 
 454         memcpy_tofs(txc_p, &txc, sizeof(struct timex));
 455         return time_status;
 456 }
 457 
 458 /*
 459  * In order to set the CMOS clock precisely, set_rtc_mmss has to be
 460  * called 500 ms after the second nowtime has started, because when
 461  * nowtime is written into the registers of the CMOS clock, it will
 462  * jump to the next second precisely 500 ms later. Check the Motorola
 463  * MC146818A or Dallas DS12887 data sheet for details.
 464  */
 465 int set_rtc_mmss(unsigned long nowtime)
     /* [previous][next][first][last][top][bottom][index][help] */
 466 {
 467   int retval = 0;
 468   int real_seconds, real_minutes, cmos_minutes;
 469   unsigned char save_control, save_freq_select;
 470 
 471   save_control = CMOS_READ(RTC_CONTROL); /* tell the clock it's being set */
 472   CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
 473 
 474   save_freq_select = CMOS_READ(RTC_FREQ_SELECT); /* stop and reset prescaler */
 475   CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
 476 
 477   cmos_minutes = CMOS_READ(RTC_MINUTES);
 478   if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
 479     BCD_TO_BIN(cmos_minutes);
 480 
 481   /* since we're only adjusting minutes and seconds,
 482    * don't interfere with hour overflow. This avoids
 483    * messing with unknown time zones but requires your
 484    * RTC not to be off by more than 15 minutes
 485    */
 486   real_seconds = nowtime % 60;
 487   real_minutes = nowtime / 60;
 488   if (((abs(real_minutes - cmos_minutes) + 15)/30) & 1)
 489     real_minutes += 30;         /* correct for half hour time zone */
 490   real_minutes %= 60;
 491 
 492   if (abs(real_minutes - cmos_minutes) < 30)
 493     {
 494       if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
 495         {
 496           BIN_TO_BCD(real_seconds);
 497           BIN_TO_BCD(real_minutes);
 498         }
 499       CMOS_WRITE(real_seconds,RTC_SECONDS);
 500       CMOS_WRITE(real_minutes,RTC_MINUTES);
 501     }
 502   else
 503     retval = -1;
 504 
 505   /* The following flags have to be released exactly in this order,
 506    * otherwise the DS12887 (popular MC146818A clone with integrated
 507    * battery and quartz) will not reset the oscillator and will not
 508    * update precisely 500 ms later. You won't find this mentioned in
 509    * the Dallas Semiconductor data sheets, but who believes data
 510    * sheets anyway ...                           -- Markus Kuhn
 511    */
 512   CMOS_WRITE(save_control, RTC_CONTROL);
 513   CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
 514 
 515   return retval;
 516 }

/* [previous][next][first][last][top][bottom][index][help] */