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 <generated/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);
176 /* Verify we're witin the +-15 hrs range */
177 if (tz->tz_minuteswest > 15*60 || tz->tz_minuteswest < -15*60)
181 update_vsyscall_tz();
189 return do_settimeofday(tv);
193 SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
194 struct timezone __user *, tz)
196 struct timeval user_tv;
197 struct timespec new_ts;
198 struct timezone new_tz;
201 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
204 if (!timeval_valid(&user_tv))
207 new_ts.tv_sec = user_tv.tv_sec;
208 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
211 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
215 return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
218 SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
220 struct timex txc; /* Local copy of parameter */
223 /* Copy the user data space into the kernel copy
224 * structure. But bear in mind that the structures
227 if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
229 ret = do_adjtimex(&txc);
230 return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
234 * current_fs_time - Return FS time
237 * Return the current time truncated to the time granularity supported by
240 struct timespec current_fs_time(struct super_block *sb)
242 struct timespec now = current_kernel_time();
243 return timespec_trunc(now, sb->s_time_gran);
245 EXPORT_SYMBOL(current_fs_time);
248 * Convert jiffies to milliseconds and back.
250 * Avoid unnecessary multiplications/divisions in the
251 * two most common HZ cases:
253 unsigned int jiffies_to_msecs(const unsigned long j)
255 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
256 return (MSEC_PER_SEC / HZ) * j;
257 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
258 return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
260 # if BITS_PER_LONG == 32
261 return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32;
263 return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN;
267 EXPORT_SYMBOL(jiffies_to_msecs);
269 unsigned int jiffies_to_usecs(const unsigned long j)
272 * Hz usually doesn't go much further MSEC_PER_SEC.
273 * jiffies_to_usecs() and usecs_to_jiffies() depend on that.
275 BUILD_BUG_ON(HZ > USEC_PER_SEC);
277 #if !(USEC_PER_SEC % HZ)
278 return (USEC_PER_SEC / HZ) * j;
280 # if BITS_PER_LONG == 32
281 return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
283 return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
287 EXPORT_SYMBOL(jiffies_to_usecs);
290 * timespec_trunc - Truncate timespec to a granularity
292 * @gran: Granularity in ns.
294 * Truncate a timespec to a granularity. gran must be smaller than a second.
295 * Always rounds down.
297 * This function should be only used for timestamps returned by
298 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
299 * it doesn't handle the better resolution of the latter.
301 struct timespec timespec_trunc(struct timespec t, unsigned gran)
304 * Division is pretty slow so avoid it for common cases.
305 * Currently current_kernel_time() never returns better than
306 * jiffies resolution. Exploit that.
308 if (gran <= jiffies_to_usecs(1) * 1000) {
310 } else if (gran == 1000000000) {
313 t.tv_nsec -= t.tv_nsec % gran;
317 EXPORT_SYMBOL(timespec_trunc);
320 * mktime64 - Converts date to seconds.
321 * Converts Gregorian date to seconds since 1970-01-01 00:00:00.
322 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
323 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
325 * [For the Julian calendar (which was used in Russia before 1917,
326 * Britain & colonies before 1752, anywhere else before 1582,
327 * and is still in use by some communities) leave out the
328 * -year/100+year/400 terms, and add 10.]
330 * This algorithm was first published by Gauss (I think).
332 time64_t mktime64(const unsigned int year0, const unsigned int mon0,
333 const unsigned int day, const unsigned int hour,
334 const unsigned int min, const unsigned int sec)
336 unsigned int mon = mon0, year = year0;
338 /* 1..12 -> 11,12,1..10 */
339 if (0 >= (int) (mon -= 2)) {
340 mon += 12; /* Puts Feb last since it has leap day */
345 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
347 )*24 + hour /* now have hours */
348 )*60 + min /* now have minutes */
349 )*60 + sec; /* finally seconds */
351 EXPORT_SYMBOL(mktime64);
354 * set_normalized_timespec - set timespec sec and nsec parts and normalize
356 * @ts: pointer to timespec variable to be set
357 * @sec: seconds to set
358 * @nsec: nanoseconds to set
360 * Set seconds and nanoseconds field of a timespec variable and
361 * normalize to the timespec storage format
363 * Note: The tv_nsec part is always in the range of
364 * 0 <= tv_nsec < NSEC_PER_SEC
365 * For negative values only the tv_sec field is negative !
367 void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec)
369 while (nsec >= NSEC_PER_SEC) {
371 * The following asm() prevents the compiler from
372 * optimising this loop into a modulo operation. See
373 * also __iter_div_u64_rem() in include/linux/time.h
375 asm("" : "+rm"(nsec));
376 nsec -= NSEC_PER_SEC;
380 asm("" : "+rm"(nsec));
381 nsec += NSEC_PER_SEC;
387 EXPORT_SYMBOL(set_normalized_timespec);
390 * ns_to_timespec - Convert nanoseconds to timespec
391 * @nsec: the nanoseconds value to be converted
393 * Returns the timespec representation of the nsec parameter.
395 struct timespec ns_to_timespec(const s64 nsec)
401 return (struct timespec) {0, 0};
403 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
404 if (unlikely(rem < 0)) {
412 EXPORT_SYMBOL(ns_to_timespec);
415 * ns_to_timeval - Convert nanoseconds to timeval
416 * @nsec: the nanoseconds value to be converted
418 * Returns the timeval representation of the nsec parameter.
420 struct timeval ns_to_timeval(const s64 nsec)
422 struct timespec ts = ns_to_timespec(nsec);
425 tv.tv_sec = ts.tv_sec;
426 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
430 EXPORT_SYMBOL(ns_to_timeval);
432 #if BITS_PER_LONG == 32
434 * set_normalized_timespec - set timespec sec and nsec parts and normalize
436 * @ts: pointer to timespec variable to be set
437 * @sec: seconds to set
438 * @nsec: nanoseconds to set
440 * Set seconds and nanoseconds field of a timespec variable and
441 * normalize to the timespec storage format
443 * Note: The tv_nsec part is always in the range of
444 * 0 <= tv_nsec < NSEC_PER_SEC
445 * For negative values only the tv_sec field is negative !
447 void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec)
449 while (nsec >= NSEC_PER_SEC) {
451 * The following asm() prevents the compiler from
452 * optimising this loop into a modulo operation. See
453 * also __iter_div_u64_rem() in include/linux/time.h
455 asm("" : "+rm"(nsec));
456 nsec -= NSEC_PER_SEC;
460 asm("" : "+rm"(nsec));
461 nsec += NSEC_PER_SEC;
467 EXPORT_SYMBOL(set_normalized_timespec64);
470 * ns_to_timespec64 - Convert nanoseconds to timespec64
471 * @nsec: the nanoseconds value to be converted
473 * Returns the timespec64 representation of the nsec parameter.
475 struct timespec64 ns_to_timespec64(const s64 nsec)
477 struct timespec64 ts;
481 return (struct timespec64) {0, 0};
483 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
484 if (unlikely(rem < 0)) {
492 EXPORT_SYMBOL(ns_to_timespec64);
495 * msecs_to_jiffies: - convert milliseconds to jiffies
496 * @m: time in milliseconds
498 * conversion is done as follows:
500 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
502 * - 'too large' values [that would result in larger than
503 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
505 * - all other values are converted to jiffies by either multiplying
506 * the input value by a factor or dividing it with a factor and
507 * handling any 32-bit overflows.
508 * for the details see __msecs_to_jiffies()
510 * msecs_to_jiffies() checks for the passed in value being a constant
511 * via __builtin_constant_p() allowing gcc to eliminate most of the
512 * code, __msecs_to_jiffies() is called if the value passed does not
513 * allow constant folding and the actual conversion must be done at
515 * the _msecs_to_jiffies helpers are the HZ dependent conversion
516 * routines found in include/linux/jiffies.h
518 unsigned long __msecs_to_jiffies(const unsigned int m)
521 * Negative value, means infinite timeout:
524 return MAX_JIFFY_OFFSET;
525 return _msecs_to_jiffies(m);
527 EXPORT_SYMBOL(__msecs_to_jiffies);
529 unsigned long __usecs_to_jiffies(const unsigned int u)
531 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
532 return MAX_JIFFY_OFFSET;
533 return _usecs_to_jiffies(u);
535 EXPORT_SYMBOL(__usecs_to_jiffies);
538 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
539 * that a remainder subtract here would not do the right thing as the
540 * resolution values don't fall on second boundries. I.e. the line:
541 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
542 * Note that due to the small error in the multiplier here, this
543 * rounding is incorrect for sufficiently large values of tv_nsec, but
544 * well formed timespecs should have tv_nsec < NSEC_PER_SEC, so we're
547 * Rather, we just shift the bits off the right.
549 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
550 * value to a scaled second value.
553 __timespec_to_jiffies(unsigned long sec, long nsec)
555 nsec = nsec + TICK_NSEC - 1;
557 if (sec >= MAX_SEC_IN_JIFFIES){
558 sec = MAX_SEC_IN_JIFFIES;
561 return (((u64)sec * SEC_CONVERSION) +
562 (((u64)nsec * NSEC_CONVERSION) >>
563 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
568 timespec_to_jiffies(const struct timespec *value)
570 return __timespec_to_jiffies(value->tv_sec, value->tv_nsec);
573 EXPORT_SYMBOL(timespec_to_jiffies);
576 jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
579 * Convert jiffies to nanoseconds and separate with
583 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
585 value->tv_nsec = rem;
587 EXPORT_SYMBOL(jiffies_to_timespec);
590 * We could use a similar algorithm to timespec_to_jiffies (with a
591 * different multiplier for usec instead of nsec). But this has a
592 * problem with rounding: we can't exactly add TICK_NSEC - 1 to the
593 * usec value, since it's not necessarily integral.
595 * We could instead round in the intermediate scaled representation
596 * (i.e. in units of 1/2^(large scale) jiffies) but that's also
597 * perilous: the scaling introduces a small positive error, which
598 * combined with a division-rounding-upward (i.e. adding 2^(scale) - 1
599 * units to the intermediate before shifting) leads to accidental
600 * overflow and overestimates.
602 * At the cost of one additional multiplication by a constant, just
603 * use the timespec implementation.
606 timeval_to_jiffies(const struct timeval *value)
608 return __timespec_to_jiffies(value->tv_sec,
609 value->tv_usec * NSEC_PER_USEC);
611 EXPORT_SYMBOL(timeval_to_jiffies);
613 void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
616 * Convert jiffies to nanoseconds and separate with
621 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
623 value->tv_usec = rem / NSEC_PER_USEC;
625 EXPORT_SYMBOL(jiffies_to_timeval);
628 * Convert jiffies/jiffies_64 to clock_t and back.
630 clock_t jiffies_to_clock_t(unsigned long x)
632 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
634 return x * (USER_HZ / HZ);
636 return x / (HZ / USER_HZ);
639 return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
642 EXPORT_SYMBOL(jiffies_to_clock_t);
644 unsigned long clock_t_to_jiffies(unsigned long x)
646 #if (HZ % USER_HZ)==0
647 if (x >= ~0UL / (HZ / USER_HZ))
649 return x * (HZ / USER_HZ);
651 /* Don't worry about loss of precision here .. */
652 if (x >= ~0UL / HZ * USER_HZ)
655 /* .. but do try to contain it here */
656 return div_u64((u64)x * HZ, USER_HZ);
659 EXPORT_SYMBOL(clock_t_to_jiffies);
661 u64 jiffies_64_to_clock_t(u64 x)
663 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
665 x = div_u64(x * USER_HZ, HZ);
667 x = div_u64(x, HZ / USER_HZ);
673 * There are better ways that don't overflow early,
674 * but even this doesn't overflow in hundreds of years
677 x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
681 EXPORT_SYMBOL(jiffies_64_to_clock_t);
683 u64 nsec_to_clock_t(u64 x)
685 #if (NSEC_PER_SEC % USER_HZ) == 0
686 return div_u64(x, NSEC_PER_SEC / USER_HZ);
687 #elif (USER_HZ % 512) == 0
688 return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
691 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
692 * overflow after 64.99 years.
693 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
695 return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
700 * nsecs_to_jiffies64 - Convert nsecs in u64 to jiffies64
704 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
705 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
706 * for scheduler, not for use in device drivers to calculate timeout value.
709 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
710 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
712 u64 nsecs_to_jiffies64(u64 n)
714 #if (NSEC_PER_SEC % HZ) == 0
715 /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */
716 return div_u64(n, NSEC_PER_SEC / HZ);
717 #elif (HZ % 512) == 0
718 /* overflow after 292 years if HZ = 1024 */
719 return div_u64(n * HZ / 512, NSEC_PER_SEC / 512);
722 * Generic case - optimized for cases where HZ is a multiple of 3.
723 * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc.
725 return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ);
728 EXPORT_SYMBOL(nsecs_to_jiffies64);
731 * nsecs_to_jiffies - Convert nsecs in u64 to jiffies
735 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
736 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
737 * for scheduler, not for use in device drivers to calculate timeout value.
740 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
741 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
743 unsigned long nsecs_to_jiffies(u64 n)
745 return (unsigned long)nsecs_to_jiffies64(n);
747 EXPORT_SYMBOL_GPL(nsecs_to_jiffies);
750 * Add two timespec values and do a safety check for overflow.
751 * It's assumed that both values are valid (>= 0)
753 struct timespec timespec_add_safe(const struct timespec lhs,
754 const struct timespec rhs)
758 set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec,
759 lhs.tv_nsec + rhs.tv_nsec);
761 if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)
762 res.tv_sec = TIME_T_MAX;