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,
11 * Modification history kernel/time.c
13 * 1993-09-02 Philip Gladstone
14 * Created file with time related functions from sched/core.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/export.h>
31 #include <linux/timex.h>
32 #include <linux/capability.h>
33 #include <linux/timekeeper_internal.h>
34 #include <linux/errno.h>
35 #include <linux/syscalls.h>
36 #include <linux/security.h>
38 #include <linux/math64.h>
39 #include <linux/ptrace.h>
41 #include <asm/uaccess.h>
42 #include <asm/unistd.h>
44 #include "timeconst.h"
45 #include "timekeeping.h"
48 * The timezone where the local system is located. Used as a default by some
49 * programs who obtain this value by using gettimeofday.
51 struct timezone sys_tz;
53 EXPORT_SYMBOL(sys_tz);
55 #ifdef __ARCH_WANT_SYS_TIME
58 * sys_time() can be implemented in user-level using
59 * sys_gettimeofday(). Is this for backwards compatibility? If so,
60 * why not move it into the appropriate arch directory (for those
61 * architectures that need it).
63 SYSCALL_DEFINE1(time, time_t __user *, tloc)
65 time_t i = get_seconds();
71 force_successful_syscall_return();
76 * sys_stime() can be implemented in user-level using
77 * sys_settimeofday(). Is this for backwards compatibility? If so,
78 * why not move it into the appropriate arch directory (for those
79 * architectures that need it).
82 SYSCALL_DEFINE1(stime, time_t __user *, tptr)
87 if (get_user(tv.tv_sec, tptr))
92 err = security_settime(&tv, NULL);
100 #endif /* __ARCH_WANT_SYS_TIME */
102 SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv,
103 struct timezone __user *, tz)
105 if (likely(tv != NULL)) {
107 do_gettimeofday(&ktv);
108 if (copy_to_user(tv, &ktv, sizeof(ktv)))
111 if (unlikely(tz != NULL)) {
112 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
119 * Indicates if there is an offset between the system clock and the hardware
120 * clock/persistent clock/rtc.
122 int persistent_clock_is_local;
125 * Adjust the time obtained from the CMOS to be UTC time instead of
128 * This is ugly, but preferable to the alternatives. Otherwise we
129 * would either need to write a program to do it in /etc/rc (and risk
130 * confusion if the program gets run more than once; it would also be
131 * hard to make the program warp the clock precisely n hours) or
132 * compile in the timezone information into the kernel. Bad, bad....
136 * The best thing to do is to keep the CMOS clock in universal time (UTC)
137 * as real UNIX machines always do it. This avoids all headaches about
138 * daylight saving times and warping kernel clocks.
140 static inline void warp_clock(void)
142 if (sys_tz.tz_minuteswest != 0) {
143 struct timespec adjust;
145 persistent_clock_is_local = 1;
146 adjust.tv_sec = sys_tz.tz_minuteswest * 60;
148 timekeeping_inject_offset(&adjust);
153 * In case for some reason the CMOS clock has not already been running
154 * in UTC, but in some local time: The first time we set the timezone,
155 * we will warp the clock so that it is ticking UTC time instead of
156 * local time. Presumably, if someone is setting the timezone then we
157 * are running in an environment where the programs understand about
158 * timezones. This should be done at boot time in the /etc/rc script,
159 * as soon as possible, so that the clock can be set right. Otherwise,
160 * various programs will get confused when the clock gets warped.
163 int do_sys_settimeofday(const struct timespec *tv, const struct timezone *tz)
165 static int firsttime = 1;
168 if (tv && !timespec_valid(tv))
171 error = security_settime(tv, tz);
177 update_vsyscall_tz();
185 return do_settimeofday(tv);
189 SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
190 struct timezone __user *, tz)
192 struct timeval user_tv;
193 struct timespec new_ts;
194 struct timezone new_tz;
197 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
200 if (!timeval_valid(&user_tv))
203 new_ts.tv_sec = user_tv.tv_sec;
204 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
207 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
211 return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
214 SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
216 struct timex txc; /* Local copy of parameter */
219 /* Copy the user data space into the kernel copy
220 * structure. But bear in mind that the structures
223 if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
225 ret = do_adjtimex(&txc);
226 return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
230 * current_fs_time - Return FS time
233 * Return the current time truncated to the time granularity supported by
236 struct timespec current_fs_time(struct super_block *sb)
238 struct timespec now = current_kernel_time();
239 return timespec_trunc(now, sb->s_time_gran);
241 EXPORT_SYMBOL(current_fs_time);
244 * Convert jiffies to milliseconds and back.
246 * Avoid unnecessary multiplications/divisions in the
247 * two most common HZ cases:
249 unsigned int jiffies_to_msecs(const unsigned long j)
251 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
252 return (MSEC_PER_SEC / HZ) * j;
253 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
254 return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
256 # if BITS_PER_LONG == 32
257 return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32;
259 return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN;
263 EXPORT_SYMBOL(jiffies_to_msecs);
265 unsigned int jiffies_to_usecs(const unsigned long j)
267 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
268 return (USEC_PER_SEC / HZ) * j;
269 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
270 return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
272 # if BITS_PER_LONG == 32
273 return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
275 return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
279 EXPORT_SYMBOL(jiffies_to_usecs);
282 * timespec_trunc - Truncate timespec to a granularity
284 * @gran: Granularity in ns.
286 * Truncate a timespec to a granularity. gran must be smaller than a second.
287 * Always rounds down.
289 * This function should be only used for timestamps returned by
290 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
291 * it doesn't handle the better resolution of the latter.
293 struct timespec timespec_trunc(struct timespec t, unsigned gran)
296 * Division is pretty slow so avoid it for common cases.
297 * Currently current_kernel_time() never returns better than
298 * jiffies resolution. Exploit that.
300 if (gran <= jiffies_to_usecs(1) * 1000) {
302 } else if (gran == 1000000000) {
305 t.tv_nsec -= t.tv_nsec % gran;
309 EXPORT_SYMBOL(timespec_trunc);
311 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
312 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
313 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
315 * [For the Julian calendar (which was used in Russia before 1917,
316 * Britain & colonies before 1752, anywhere else before 1582,
317 * and is still in use by some communities) leave out the
318 * -year/100+year/400 terms, and add 10.]
320 * This algorithm was first published by Gauss (I think).
322 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
323 * machines where long is 32-bit! (However, as time_t is signed, we
324 * will already get problems at other places on 2038-01-19 03:14:08)
327 mktime(const unsigned int year0, const unsigned int mon0,
328 const unsigned int day, const unsigned int hour,
329 const unsigned int min, const unsigned int sec)
331 unsigned int mon = mon0, year = year0;
333 /* 1..12 -> 11,12,1..10 */
334 if (0 >= (int) (mon -= 2)) {
335 mon += 12; /* Puts Feb last since it has leap day */
339 return ((((unsigned long)
340 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
342 )*24 + hour /* now have hours */
343 )*60 + min /* now have minutes */
344 )*60 + sec; /* finally seconds */
347 EXPORT_SYMBOL(mktime);
350 * set_normalized_timespec - set timespec sec and nsec parts and normalize
352 * @ts: pointer to timespec variable to be set
353 * @sec: seconds to set
354 * @nsec: nanoseconds to set
356 * Set seconds and nanoseconds field of a timespec variable and
357 * normalize to the timespec storage format
359 * Note: The tv_nsec part is always in the range of
360 * 0 <= tv_nsec < NSEC_PER_SEC
361 * For negative values only the tv_sec field is negative !
363 void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec)
365 while (nsec >= NSEC_PER_SEC) {
367 * The following asm() prevents the compiler from
368 * optimising this loop into a modulo operation. See
369 * also __iter_div_u64_rem() in include/linux/time.h
371 asm("" : "+rm"(nsec));
372 nsec -= NSEC_PER_SEC;
376 asm("" : "+rm"(nsec));
377 nsec += NSEC_PER_SEC;
383 EXPORT_SYMBOL(set_normalized_timespec);
386 * ns_to_timespec - Convert nanoseconds to timespec
387 * @nsec: the nanoseconds value to be converted
389 * Returns the timespec representation of the nsec parameter.
391 struct timespec ns_to_timespec(const s64 nsec)
397 return (struct timespec) {0, 0};
399 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
400 if (unlikely(rem < 0)) {
408 EXPORT_SYMBOL(ns_to_timespec);
411 * ns_to_timeval - Convert nanoseconds to timeval
412 * @nsec: the nanoseconds value to be converted
414 * Returns the timeval representation of the nsec parameter.
416 struct timeval ns_to_timeval(const s64 nsec)
418 struct timespec ts = ns_to_timespec(nsec);
421 tv.tv_sec = ts.tv_sec;
422 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
426 EXPORT_SYMBOL(ns_to_timeval);
428 #if BITS_PER_LONG == 32
430 * set_normalized_timespec - set timespec sec and nsec parts and normalize
432 * @ts: pointer to timespec variable to be set
433 * @sec: seconds to set
434 * @nsec: nanoseconds to set
436 * Set seconds and nanoseconds field of a timespec variable and
437 * normalize to the timespec storage format
439 * Note: The tv_nsec part is always in the range of
440 * 0 <= tv_nsec < NSEC_PER_SEC
441 * For negative values only the tv_sec field is negative !
443 void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec)
445 while (nsec >= NSEC_PER_SEC) {
447 * The following asm() prevents the compiler from
448 * optimising this loop into a modulo operation. See
449 * also __iter_div_u64_rem() in include/linux/time.h
451 asm("" : "+rm"(nsec));
452 nsec -= NSEC_PER_SEC;
456 asm("" : "+rm"(nsec));
457 nsec += NSEC_PER_SEC;
463 EXPORT_SYMBOL(set_normalized_timespec64);
466 * ns_to_timespec64 - Convert nanoseconds to timespec64
467 * @nsec: the nanoseconds value to be converted
469 * Returns the timespec64 representation of the nsec parameter.
471 struct timespec64 ns_to_timespec64(const s64 nsec)
473 struct timespec64 ts;
477 return (struct timespec64) {0, 0};
479 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
480 if (unlikely(rem < 0)) {
488 EXPORT_SYMBOL(ns_to_timespec64);
491 * When we convert to jiffies then we interpret incoming values
494 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
496 * - 'too large' values [that would result in larger than
497 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
499 * - all other values are converted to jiffies by either multiplying
500 * the input value by a factor or dividing it with a factor
502 * We must also be careful about 32-bit overflows.
504 unsigned long msecs_to_jiffies(const unsigned int m)
507 * Negative value, means infinite timeout:
510 return MAX_JIFFY_OFFSET;
512 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
514 * HZ is equal to or smaller than 1000, and 1000 is a nice
515 * round multiple of HZ, divide with the factor between them,
518 return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
519 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
521 * HZ is larger than 1000, and HZ is a nice round multiple of
522 * 1000 - simply multiply with the factor between them.
524 * But first make sure the multiplication result cannot
527 if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
528 return MAX_JIFFY_OFFSET;
530 return m * (HZ / MSEC_PER_SEC);
533 * Generic case - multiply, round and divide. But first
534 * check that if we are doing a net multiplication, that
535 * we wouldn't overflow:
537 if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
538 return MAX_JIFFY_OFFSET;
540 return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32)
544 EXPORT_SYMBOL(msecs_to_jiffies);
546 unsigned long usecs_to_jiffies(const unsigned int u)
548 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
549 return MAX_JIFFY_OFFSET;
550 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
551 return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
552 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
553 return u * (HZ / USEC_PER_SEC);
555 return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
559 EXPORT_SYMBOL(usecs_to_jiffies);
562 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
563 * that a remainder subtract here would not do the right thing as the
564 * resolution values don't fall on second boundries. I.e. the line:
565 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
566 * Note that due to the small error in the multiplier here, this
567 * rounding is incorrect for sufficiently large values of tv_nsec, but
568 * well formed timespecs should have tv_nsec < NSEC_PER_SEC, so we're
571 * Rather, we just shift the bits off the right.
573 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
574 * value to a scaled second value.
577 __timespec_to_jiffies(unsigned long sec, long nsec)
579 nsec = nsec + TICK_NSEC - 1;
581 if (sec >= MAX_SEC_IN_JIFFIES){
582 sec = MAX_SEC_IN_JIFFIES;
585 return (((u64)sec * SEC_CONVERSION) +
586 (((u64)nsec * NSEC_CONVERSION) >>
587 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
592 timespec_to_jiffies(const struct timespec *value)
594 return __timespec_to_jiffies(value->tv_sec, value->tv_nsec);
597 EXPORT_SYMBOL(timespec_to_jiffies);
600 jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
603 * Convert jiffies to nanoseconds and separate with
607 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
609 value->tv_nsec = rem;
611 EXPORT_SYMBOL(jiffies_to_timespec);
614 * We could use a similar algorithm to timespec_to_jiffies (with a
615 * different multiplier for usec instead of nsec). But this has a
616 * problem with rounding: we can't exactly add TICK_NSEC - 1 to the
617 * usec value, since it's not necessarily integral.
619 * We could instead round in the intermediate scaled representation
620 * (i.e. in units of 1/2^(large scale) jiffies) but that's also
621 * perilous: the scaling introduces a small positive error, which
622 * combined with a division-rounding-upward (i.e. adding 2^(scale) - 1
623 * units to the intermediate before shifting) leads to accidental
624 * overflow and overestimates.
626 * At the cost of one additional multiplication by a constant, just
627 * use the timespec implementation.
630 timeval_to_jiffies(const struct timeval *value)
632 return __timespec_to_jiffies(value->tv_sec,
633 value->tv_usec * NSEC_PER_USEC);
635 EXPORT_SYMBOL(timeval_to_jiffies);
637 void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
640 * Convert jiffies to nanoseconds and separate with
645 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
647 value->tv_usec = rem / NSEC_PER_USEC;
649 EXPORT_SYMBOL(jiffies_to_timeval);
652 * Convert jiffies/jiffies_64 to clock_t and back.
654 clock_t jiffies_to_clock_t(unsigned long x)
656 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
658 return x * (USER_HZ / HZ);
660 return x / (HZ / USER_HZ);
663 return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
666 EXPORT_SYMBOL(jiffies_to_clock_t);
668 unsigned long clock_t_to_jiffies(unsigned long x)
670 #if (HZ % USER_HZ)==0
671 if (x >= ~0UL / (HZ / USER_HZ))
673 return x * (HZ / USER_HZ);
675 /* Don't worry about loss of precision here .. */
676 if (x >= ~0UL / HZ * USER_HZ)
679 /* .. but do try to contain it here */
680 return div_u64((u64)x * HZ, USER_HZ);
683 EXPORT_SYMBOL(clock_t_to_jiffies);
685 u64 jiffies_64_to_clock_t(u64 x)
687 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
689 x = div_u64(x * USER_HZ, HZ);
691 x = div_u64(x, HZ / USER_HZ);
697 * There are better ways that don't overflow early,
698 * but even this doesn't overflow in hundreds of years
701 x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
705 EXPORT_SYMBOL(jiffies_64_to_clock_t);
707 u64 nsec_to_clock_t(u64 x)
709 #if (NSEC_PER_SEC % USER_HZ) == 0
710 return div_u64(x, NSEC_PER_SEC / USER_HZ);
711 #elif (USER_HZ % 512) == 0
712 return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
715 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
716 * overflow after 64.99 years.
717 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
719 return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
724 * nsecs_to_jiffies64 - Convert nsecs in u64 to jiffies64
728 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
729 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
730 * for scheduler, not for use in device drivers to calculate timeout value.
733 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
734 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
736 u64 nsecs_to_jiffies64(u64 n)
738 #if (NSEC_PER_SEC % HZ) == 0
739 /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */
740 return div_u64(n, NSEC_PER_SEC / HZ);
741 #elif (HZ % 512) == 0
742 /* overflow after 292 years if HZ = 1024 */
743 return div_u64(n * HZ / 512, NSEC_PER_SEC / 512);
746 * Generic case - optimized for cases where HZ is a multiple of 3.
747 * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc.
749 return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ);
754 * nsecs_to_jiffies - Convert nsecs in u64 to jiffies
758 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
759 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
760 * for scheduler, not for use in device drivers to calculate timeout value.
763 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
764 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
766 unsigned long nsecs_to_jiffies(u64 n)
768 return (unsigned long)nsecs_to_jiffies64(n);
770 EXPORT_SYMBOL_GPL(nsecs_to_jiffies);
773 * Add two timespec values and do a safety check for overflow.
774 * It's assumed that both values are valid (>= 0)
776 struct timespec timespec_add_safe(const struct timespec lhs,
777 const struct timespec rhs)
781 set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec,
782 lhs.tv_nsec + rhs.tv_nsec);
784 if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)
785 res.tv_sec = TIME_T_MAX;