[MIPS] Always install the DSP exception handler.
[linux-2.6/linux-mips/linux-dm7025.git] / kernel / time.c
blobf04791f694081d16dab799ae16f5b3f405683e4d
1 /*
2 * linux/kernel/time.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
6 * This file contains the interface functions for the various
7 * time related system calls: time, stime, gettimeofday, settimeofday,
8 * adjtime
9 */
11 * Modification history kernel/time.c
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 * 1995-08-13 Torsten Duwe
18 * kernel PLL updated to 1994-12-13 specs (rfc-1589)
19 * 1999-01-16 Ulrich Windl
20 * Introduced error checking for many cases in adjtimex().
21 * Updated NTP code according to technical memorandum Jan '96
22 * "A Kernel Model for Precision Timekeeping" by Dave Mills
23 * Allow time_constant larger than MAXTC(6) for NTP v4 (MAXTC == 10)
24 * (Even though the technical memorandum forbids it)
25 * 2004-07-14 Christoph Lameter
26 * Added getnstimeofday to allow the posix timer functions to return
27 * with nanosecond accuracy
30 #include <linux/module.h>
31 #include <linux/timex.h>
32 #include <linux/capability.h>
33 #include <linux/errno.h>
34 #include <linux/syscalls.h>
35 #include <linux/security.h>
36 #include <linux/fs.h>
37 #include <linux/module.h>
39 #include <asm/uaccess.h>
40 #include <asm/unistd.h>
42 /*
43 * The timezone where the local system is located. Used as a default by some
44 * programs who obtain this value by using gettimeofday.
46 struct timezone sys_tz;
48 EXPORT_SYMBOL(sys_tz);
50 #ifdef __ARCH_WANT_SYS_TIME
53 * sys_time() can be implemented in user-level using
54 * sys_gettimeofday(). Is this for backwards compatibility? If so,
55 * why not move it into the appropriate arch directory (for those
56 * architectures that need it).
58 asmlinkage long sys_time(time_t __user * tloc)
60 time_t i;
61 struct timeval tv;
63 do_gettimeofday(&tv);
64 i = tv.tv_sec;
66 if (tloc) {
67 if (put_user(i,tloc))
68 i = -EFAULT;
70 return i;
74 * sys_stime() can be implemented in user-level using
75 * sys_settimeofday(). Is this for backwards compatibility? If so,
76 * why not move it into the appropriate arch directory (for those
77 * architectures that need it).
80 asmlinkage long sys_stime(time_t __user *tptr)
82 struct timespec tv;
83 int err;
85 if (get_user(tv.tv_sec, tptr))
86 return -EFAULT;
88 tv.tv_nsec = 0;
90 err = security_settime(&tv, NULL);
91 if (err)
92 return err;
94 do_settimeofday(&tv);
95 return 0;
98 #endif /* __ARCH_WANT_SYS_TIME */
100 asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __user *tz)
102 if (likely(tv != NULL)) {
103 struct timeval ktv;
104 do_gettimeofday(&ktv);
105 if (copy_to_user(tv, &ktv, sizeof(ktv)))
106 return -EFAULT;
108 if (unlikely(tz != NULL)) {
109 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
110 return -EFAULT;
112 return 0;
116 * Adjust the time obtained from the CMOS to be UTC time instead of
117 * local time.
119 * This is ugly, but preferable to the alternatives. Otherwise we
120 * would either need to write a program to do it in /etc/rc (and risk
121 * confusion if the program gets run more than once; it would also be
122 * hard to make the program warp the clock precisely n hours) or
123 * compile in the timezone information into the kernel. Bad, bad....
125 * - TYT, 1992-01-01
127 * The best thing to do is to keep the CMOS clock in universal time (UTC)
128 * as real UNIX machines always do it. This avoids all headaches about
129 * daylight saving times and warping kernel clocks.
131 static inline void warp_clock(void)
133 write_seqlock_irq(&xtime_lock);
134 wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
135 xtime.tv_sec += sys_tz.tz_minuteswest * 60;
136 time_interpolator_reset();
137 write_sequnlock_irq(&xtime_lock);
138 clock_was_set();
142 * In case for some reason the CMOS clock has not already been running
143 * in UTC, but in some local time: The first time we set the timezone,
144 * we will warp the clock so that it is ticking UTC time instead of
145 * local time. Presumably, if someone is setting the timezone then we
146 * are running in an environment where the programs understand about
147 * timezones. This should be done at boot time in the /etc/rc script,
148 * as soon as possible, so that the clock can be set right. Otherwise,
149 * various programs will get confused when the clock gets warped.
152 int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
154 static int firsttime = 1;
155 int error = 0;
157 if (tv && !timespec_valid(tv))
158 return -EINVAL;
160 error = security_settime(tv, tz);
161 if (error)
162 return error;
164 if (tz) {
165 /* SMP safe, global irq locking makes it work. */
166 sys_tz = *tz;
167 if (firsttime) {
168 firsttime = 0;
169 if (!tv)
170 warp_clock();
173 if (tv)
175 /* SMP safe, again the code in arch/foo/time.c should
176 * globally block out interrupts when it runs.
178 return do_settimeofday(tv);
180 return 0;
183 asmlinkage long sys_settimeofday(struct timeval __user *tv,
184 struct timezone __user *tz)
186 struct timeval user_tv;
187 struct timespec new_ts;
188 struct timezone new_tz;
190 if (tv) {
191 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
192 return -EFAULT;
193 new_ts.tv_sec = user_tv.tv_sec;
194 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
196 if (tz) {
197 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
198 return -EFAULT;
201 return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
204 asmlinkage long sys_adjtimex(struct timex __user *txc_p)
206 struct timex txc; /* Local copy of parameter */
207 int ret;
209 /* Copy the user data space into the kernel copy
210 * structure. But bear in mind that the structures
211 * may change
213 if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
214 return -EFAULT;
215 ret = do_adjtimex(&txc);
216 return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
219 inline struct timespec current_kernel_time(void)
221 struct timespec now;
222 unsigned long seq;
224 do {
225 seq = read_seqbegin(&xtime_lock);
227 now = xtime;
228 } while (read_seqretry(&xtime_lock, seq));
230 return now;
233 EXPORT_SYMBOL(current_kernel_time);
236 * current_fs_time - Return FS time
237 * @sb: Superblock.
239 * Return the current time truncated to the time granularity supported by
240 * the fs.
242 struct timespec current_fs_time(struct super_block *sb)
244 struct timespec now = current_kernel_time();
245 return timespec_trunc(now, sb->s_time_gran);
247 EXPORT_SYMBOL(current_fs_time);
250 * Convert jiffies to milliseconds and back.
252 * Avoid unnecessary multiplications/divisions in the
253 * two most common HZ cases:
255 unsigned int inline jiffies_to_msecs(const unsigned long j)
257 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
258 return (MSEC_PER_SEC / HZ) * j;
259 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
260 return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
261 #else
262 return (j * MSEC_PER_SEC) / HZ;
263 #endif
265 EXPORT_SYMBOL(jiffies_to_msecs);
267 unsigned int inline jiffies_to_usecs(const unsigned long j)
269 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
270 return (USEC_PER_SEC / HZ) * j;
271 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
272 return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
273 #else
274 return (j * USEC_PER_SEC) / HZ;
275 #endif
277 EXPORT_SYMBOL(jiffies_to_usecs);
280 * timespec_trunc - Truncate timespec to a granularity
281 * @t: Timespec
282 * @gran: Granularity in ns.
284 * Truncate a timespec to a granularity. gran must be smaller than a second.
285 * Always rounds down.
287 * This function should be only used for timestamps returned by
288 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
289 * it doesn't handle the better resolution of the later.
291 struct timespec timespec_trunc(struct timespec t, unsigned gran)
294 * Division is pretty slow so avoid it for common cases.
295 * Currently current_kernel_time() never returns better than
296 * jiffies resolution. Exploit that.
298 if (gran <= jiffies_to_usecs(1) * 1000) {
299 /* nothing */
300 } else if (gran == 1000000000) {
301 t.tv_nsec = 0;
302 } else {
303 t.tv_nsec -= t.tv_nsec % gran;
305 return t;
307 EXPORT_SYMBOL(timespec_trunc);
309 #ifdef CONFIG_TIME_INTERPOLATION
310 void getnstimeofday (struct timespec *tv)
312 unsigned long seq,sec,nsec;
314 do {
315 seq = read_seqbegin(&xtime_lock);
316 sec = xtime.tv_sec;
317 nsec = xtime.tv_nsec+time_interpolator_get_offset();
318 } while (unlikely(read_seqretry(&xtime_lock, seq)));
320 while (unlikely(nsec >= NSEC_PER_SEC)) {
321 nsec -= NSEC_PER_SEC;
322 ++sec;
324 tv->tv_sec = sec;
325 tv->tv_nsec = nsec;
327 EXPORT_SYMBOL_GPL(getnstimeofday);
329 int do_settimeofday (struct timespec *tv)
331 time_t wtm_sec, sec = tv->tv_sec;
332 long wtm_nsec, nsec = tv->tv_nsec;
334 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
335 return -EINVAL;
337 write_seqlock_irq(&xtime_lock);
339 wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
340 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
342 set_normalized_timespec(&xtime, sec, nsec);
343 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
345 time_adjust = 0; /* stop active adjtime() */
346 time_status |= STA_UNSYNC;
347 time_maxerror = NTP_PHASE_LIMIT;
348 time_esterror = NTP_PHASE_LIMIT;
349 time_interpolator_reset();
351 write_sequnlock_irq(&xtime_lock);
352 clock_was_set();
353 return 0;
355 EXPORT_SYMBOL(do_settimeofday);
357 void do_gettimeofday (struct timeval *tv)
359 unsigned long seq, nsec, usec, sec, offset;
360 do {
361 seq = read_seqbegin(&xtime_lock);
362 offset = time_interpolator_get_offset();
363 sec = xtime.tv_sec;
364 nsec = xtime.tv_nsec;
365 } while (unlikely(read_seqretry(&xtime_lock, seq)));
367 usec = (nsec + offset) / 1000;
369 while (unlikely(usec >= USEC_PER_SEC)) {
370 usec -= USEC_PER_SEC;
371 ++sec;
374 tv->tv_sec = sec;
375 tv->tv_usec = usec;
378 EXPORT_SYMBOL(do_gettimeofday);
381 #else
382 #ifndef CONFIG_GENERIC_TIME
384 * Simulate gettimeofday using do_gettimeofday which only allows a timeval
385 * and therefore only yields usec accuracy
387 void getnstimeofday(struct timespec *tv)
389 struct timeval x;
391 do_gettimeofday(&x);
392 tv->tv_sec = x.tv_sec;
393 tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
395 EXPORT_SYMBOL_GPL(getnstimeofday);
396 #endif
397 #endif
399 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
400 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
401 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
403 * [For the Julian calendar (which was used in Russia before 1917,
404 * Britain & colonies before 1752, anywhere else before 1582,
405 * and is still in use by some communities) leave out the
406 * -year/100+year/400 terms, and add 10.]
408 * This algorithm was first published by Gauss (I think).
410 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
411 * machines were long is 32-bit! (However, as time_t is signed, we
412 * will already get problems at other places on 2038-01-19 03:14:08)
414 unsigned long
415 mktime(const unsigned int year0, const unsigned int mon0,
416 const unsigned int day, const unsigned int hour,
417 const unsigned int min, const unsigned int sec)
419 unsigned int mon = mon0, year = year0;
421 /* 1..12 -> 11,12,1..10 */
422 if (0 >= (int) (mon -= 2)) {
423 mon += 12; /* Puts Feb last since it has leap day */
424 year -= 1;
427 return ((((unsigned long)
428 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
429 year*365 - 719499
430 )*24 + hour /* now have hours */
431 )*60 + min /* now have minutes */
432 )*60 + sec; /* finally seconds */
435 EXPORT_SYMBOL(mktime);
438 * set_normalized_timespec - set timespec sec and nsec parts and normalize
440 * @ts: pointer to timespec variable to be set
441 * @sec: seconds to set
442 * @nsec: nanoseconds to set
444 * Set seconds and nanoseconds field of a timespec variable and
445 * normalize to the timespec storage format
447 * Note: The tv_nsec part is always in the range of
448 * 0 <= tv_nsec < NSEC_PER_SEC
449 * For negative values only the tv_sec field is negative !
451 void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
453 while (nsec >= NSEC_PER_SEC) {
454 nsec -= NSEC_PER_SEC;
455 ++sec;
457 while (nsec < 0) {
458 nsec += NSEC_PER_SEC;
459 --sec;
461 ts->tv_sec = sec;
462 ts->tv_nsec = nsec;
466 * ns_to_timespec - Convert nanoseconds to timespec
467 * @nsec: the nanoseconds value to be converted
469 * Returns the timespec representation of the nsec parameter.
471 struct timespec ns_to_timespec(const s64 nsec)
473 struct timespec ts;
475 if (!nsec)
476 return (struct timespec) {0, 0};
478 ts.tv_sec = div_long_long_rem_signed(nsec, NSEC_PER_SEC, &ts.tv_nsec);
479 if (unlikely(nsec < 0))
480 set_normalized_timespec(&ts, ts.tv_sec, ts.tv_nsec);
482 return ts;
484 EXPORT_SYMBOL(ns_to_timespec);
487 * ns_to_timeval - Convert nanoseconds to timeval
488 * @nsec: the nanoseconds value to be converted
490 * Returns the timeval representation of the nsec parameter.
492 struct timeval ns_to_timeval(const s64 nsec)
494 struct timespec ts = ns_to_timespec(nsec);
495 struct timeval tv;
497 tv.tv_sec = ts.tv_sec;
498 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
500 return tv;
502 EXPORT_SYMBOL(ns_to_timeval);
505 * When we convert to jiffies then we interpret incoming values
506 * the following way:
508 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
510 * - 'too large' values [that would result in larger than
511 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
513 * - all other values are converted to jiffies by either multiplying
514 * the input value by a factor or dividing it with a factor
516 * We must also be careful about 32-bit overflows.
518 unsigned long msecs_to_jiffies(const unsigned int m)
521 * Negative value, means infinite timeout:
523 if ((int)m < 0)
524 return MAX_JIFFY_OFFSET;
526 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
528 * HZ is equal to or smaller than 1000, and 1000 is a nice
529 * round multiple of HZ, divide with the factor between them,
530 * but round upwards:
532 return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
533 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
535 * HZ is larger than 1000, and HZ is a nice round multiple of
536 * 1000 - simply multiply with the factor between them.
538 * But first make sure the multiplication result cannot
539 * overflow:
541 if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
542 return MAX_JIFFY_OFFSET;
544 return m * (HZ / MSEC_PER_SEC);
545 #else
547 * Generic case - multiply, round and divide. But first
548 * check that if we are doing a net multiplication, that
549 * we wouldnt overflow:
551 if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
552 return MAX_JIFFY_OFFSET;
554 return (m * HZ + MSEC_PER_SEC - 1) / MSEC_PER_SEC;
555 #endif
557 EXPORT_SYMBOL(msecs_to_jiffies);
559 unsigned long usecs_to_jiffies(const unsigned int u)
561 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
562 return MAX_JIFFY_OFFSET;
563 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
564 return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
565 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
566 return u * (HZ / USEC_PER_SEC);
567 #else
568 return (u * HZ + USEC_PER_SEC - 1) / USEC_PER_SEC;
569 #endif
571 EXPORT_SYMBOL(usecs_to_jiffies);
574 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
575 * that a remainder subtract here would not do the right thing as the
576 * resolution values don't fall on second boundries. I.e. the line:
577 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
579 * Rather, we just shift the bits off the right.
581 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
582 * value to a scaled second value.
584 unsigned long
585 timespec_to_jiffies(const struct timespec *value)
587 unsigned long sec = value->tv_sec;
588 long nsec = value->tv_nsec + TICK_NSEC - 1;
590 if (sec >= MAX_SEC_IN_JIFFIES){
591 sec = MAX_SEC_IN_JIFFIES;
592 nsec = 0;
594 return (((u64)sec * SEC_CONVERSION) +
595 (((u64)nsec * NSEC_CONVERSION) >>
596 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
599 EXPORT_SYMBOL(timespec_to_jiffies);
601 void
602 jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
605 * Convert jiffies to nanoseconds and separate with
606 * one divide.
608 u64 nsec = (u64)jiffies * TICK_NSEC;
609 value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &value->tv_nsec);
611 EXPORT_SYMBOL(jiffies_to_timespec);
613 /* Same for "timeval"
615 * Well, almost. The problem here is that the real system resolution is
616 * in nanoseconds and the value being converted is in micro seconds.
617 * Also for some machines (those that use HZ = 1024, in-particular),
618 * there is a LARGE error in the tick size in microseconds.
620 * The solution we use is to do the rounding AFTER we convert the
621 * microsecond part. Thus the USEC_ROUND, the bits to be shifted off.
622 * Instruction wise, this should cost only an additional add with carry
623 * instruction above the way it was done above.
625 unsigned long
626 timeval_to_jiffies(const struct timeval *value)
628 unsigned long sec = value->tv_sec;
629 long usec = value->tv_usec;
631 if (sec >= MAX_SEC_IN_JIFFIES){
632 sec = MAX_SEC_IN_JIFFIES;
633 usec = 0;
635 return (((u64)sec * SEC_CONVERSION) +
636 (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
637 (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
639 EXPORT_SYMBOL(timeval_to_jiffies);
641 void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
644 * Convert jiffies to nanoseconds and separate with
645 * one divide.
647 u64 nsec = (u64)jiffies * TICK_NSEC;
648 long tv_usec;
650 value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &tv_usec);
651 tv_usec /= NSEC_PER_USEC;
652 value->tv_usec = tv_usec;
654 EXPORT_SYMBOL(jiffies_to_timeval);
657 * Convert jiffies/jiffies_64 to clock_t and back.
659 clock_t jiffies_to_clock_t(long x)
661 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
662 return x / (HZ / USER_HZ);
663 #else
664 u64 tmp = (u64)x * TICK_NSEC;
665 do_div(tmp, (NSEC_PER_SEC / USER_HZ));
666 return (long)tmp;
667 #endif
669 EXPORT_SYMBOL(jiffies_to_clock_t);
671 unsigned long clock_t_to_jiffies(unsigned long x)
673 #if (HZ % USER_HZ)==0
674 if (x >= ~0UL / (HZ / USER_HZ))
675 return ~0UL;
676 return x * (HZ / USER_HZ);
677 #else
678 u64 jif;
680 /* Don't worry about loss of precision here .. */
681 if (x >= ~0UL / HZ * USER_HZ)
682 return ~0UL;
684 /* .. but do try to contain it here */
685 jif = x * (u64) HZ;
686 do_div(jif, USER_HZ);
687 return jif;
688 #endif
690 EXPORT_SYMBOL(clock_t_to_jiffies);
692 u64 jiffies_64_to_clock_t(u64 x)
694 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
695 do_div(x, HZ / USER_HZ);
696 #else
698 * There are better ways that don't overflow early,
699 * but even this doesn't overflow in hundreds of years
700 * in 64 bits, so..
702 x *= TICK_NSEC;
703 do_div(x, (NSEC_PER_SEC / USER_HZ));
704 #endif
705 return x;
708 EXPORT_SYMBOL(jiffies_64_to_clock_t);
710 u64 nsec_to_clock_t(u64 x)
712 #if (NSEC_PER_SEC % USER_HZ) == 0
713 do_div(x, (NSEC_PER_SEC / USER_HZ));
714 #elif (USER_HZ % 512) == 0
715 x *= USER_HZ/512;
716 do_div(x, (NSEC_PER_SEC / 512));
717 #else
719 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
720 * overflow after 64.99 years.
721 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
723 x *= 9;
724 do_div(x, (unsigned long)((9ull * NSEC_PER_SEC + (USER_HZ/2)) /
725 USER_HZ));
726 #endif
727 return x;
730 #if (BITS_PER_LONG < 64)
731 u64 get_jiffies_64(void)
733 unsigned long seq;
734 u64 ret;
736 do {
737 seq = read_seqbegin(&xtime_lock);
738 ret = jiffies_64;
739 } while (read_seqretry(&xtime_lock, seq));
740 return ret;
743 EXPORT_SYMBOL(get_jiffies_64);
744 #endif
746 EXPORT_SYMBOL(jiffies);