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.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>
37 #include <linux/module.h>
39 #include <asm/uaccess.h>
40 #include <asm/unistd.h>
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
)
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
)
85 if (get_user(tv
.tv_sec
, tptr
))
90 err
= security_settime(&tv
, NULL
);
98 #endif /* __ARCH_WANT_SYS_TIME */
100 asmlinkage
long sys_gettimeofday(struct timeval __user
*tv
, struct timezone __user
*tz
)
102 if (likely(tv
!= NULL
)) {
104 do_gettimeofday(&ktv
);
105 if (copy_to_user(tv
, &ktv
, sizeof(ktv
)))
108 if (unlikely(tz
!= NULL
)) {
109 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
116 * Adjust the time obtained from the CMOS to be UTC time instead of
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....
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
);
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;
157 if (tv
&& !timespec_valid(tv
))
160 error
= security_settime(tv
, tz
);
165 /* SMP safe, global irq locking makes it work. */
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
);
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
;
191 if (copy_from_user(&user_tv
, tv
, sizeof(*tv
)))
193 new_ts
.tv_sec
= user_tv
.tv_sec
;
194 new_ts
.tv_nsec
= user_tv
.tv_usec
* NSEC_PER_USEC
;
197 if (copy_from_user(&new_tz
, tz
, sizeof(*tz
)))
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 */
209 /* Copy the user data space into the kernel copy
210 * structure. But bear in mind that the structures
213 if(copy_from_user(&txc
, txc_p
, sizeof(struct timex
)))
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)
225 seq
= read_seqbegin(&xtime_lock
);
228 } while (read_seqretry(&xtime_lock
, seq
));
233 EXPORT_SYMBOL(current_kernel_time
);
236 * current_fs_time - Return FS time
239 * Return the current time truncated to the time granularity supported by
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
);
262 return (j
* MSEC_PER_SEC
) / HZ
;
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
);
274 return (j
* USEC_PER_SEC
) / HZ
;
277 EXPORT_SYMBOL(jiffies_to_usecs
);
280 * timespec_trunc - Truncate timespec to a granularity
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) {
300 } else if (gran
== 1000000000) {
303 t
.tv_nsec
-= t
.tv_nsec
% gran
;
307 EXPORT_SYMBOL(timespec_trunc
);
309 #ifdef CONFIG_TIME_INTERPOLATION
310 void getnstimeofday (struct timespec
*tv
)
312 unsigned long seq
,sec
,nsec
;
315 seq
= read_seqbegin(&xtime_lock
);
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
;
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
)
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
);
355 EXPORT_SYMBOL(do_settimeofday
);
357 void do_gettimeofday (struct timeval
*tv
)
359 unsigned long seq
, nsec
, usec
, sec
, offset
;
361 seq
= read_seqbegin(&xtime_lock
);
362 offset
= time_interpolator_get_offset();
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
;
378 * Make sure xtime.tv_sec [returned by sys_time()] always
379 * follows the gettimeofday() result precisely. This
380 * condition is extremely unlikely, it can hit at most
383 if (unlikely(xtime
.tv_sec
!= tv
->tv_sec
)) {
386 write_seqlock_irqsave(&xtime_lock
, flags
);
388 write_sequnlock_irqrestore(&xtime_lock
, flags
);
391 EXPORT_SYMBOL(do_gettimeofday
);
393 #else /* CONFIG_TIME_INTERPOLATION */
395 #ifndef CONFIG_GENERIC_TIME
397 * Simulate gettimeofday using do_gettimeofday which only allows a timeval
398 * and therefore only yields usec accuracy
400 void getnstimeofday(struct timespec
*tv
)
405 tv
->tv_sec
= x
.tv_sec
;
406 tv
->tv_nsec
= x
.tv_usec
* NSEC_PER_USEC
;
408 EXPORT_SYMBOL_GPL(getnstimeofday
);
410 #endif /* CONFIG_TIME_INTERPOLATION */
412 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
413 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
414 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
416 * [For the Julian calendar (which was used in Russia before 1917,
417 * Britain & colonies before 1752, anywhere else before 1582,
418 * and is still in use by some communities) leave out the
419 * -year/100+year/400 terms, and add 10.]
421 * This algorithm was first published by Gauss (I think).
423 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
424 * machines were long is 32-bit! (However, as time_t is signed, we
425 * will already get problems at other places on 2038-01-19 03:14:08)
428 mktime(const unsigned int year0
, const unsigned int mon0
,
429 const unsigned int day
, const unsigned int hour
,
430 const unsigned int min
, const unsigned int sec
)
432 unsigned int mon
= mon0
, year
= year0
;
434 /* 1..12 -> 11,12,1..10 */
435 if (0 >= (int) (mon
-= 2)) {
436 mon
+= 12; /* Puts Feb last since it has leap day */
440 return ((((unsigned long)
441 (year
/4 - year
/100 + year
/400 + 367*mon
/12 + day
) +
443 )*24 + hour
/* now have hours */
444 )*60 + min
/* now have minutes */
445 )*60 + sec
; /* finally seconds */
448 EXPORT_SYMBOL(mktime
);
451 * set_normalized_timespec - set timespec sec and nsec parts and normalize
453 * @ts: pointer to timespec variable to be set
454 * @sec: seconds to set
455 * @nsec: nanoseconds to set
457 * Set seconds and nanoseconds field of a timespec variable and
458 * normalize to the timespec storage format
460 * Note: The tv_nsec part is always in the range of
461 * 0 <= tv_nsec < NSEC_PER_SEC
462 * For negative values only the tv_sec field is negative !
464 void set_normalized_timespec(struct timespec
*ts
, time_t sec
, long nsec
)
466 while (nsec
>= NSEC_PER_SEC
) {
467 nsec
-= NSEC_PER_SEC
;
471 nsec
+= NSEC_PER_SEC
;
479 * ns_to_timespec - Convert nanoseconds to timespec
480 * @nsec: the nanoseconds value to be converted
482 * Returns the timespec representation of the nsec parameter.
484 struct timespec
ns_to_timespec(const s64 nsec
)
489 return (struct timespec
) {0, 0};
491 ts
.tv_sec
= div_long_long_rem_signed(nsec
, NSEC_PER_SEC
, &ts
.tv_nsec
);
492 if (unlikely(nsec
< 0))
493 set_normalized_timespec(&ts
, ts
.tv_sec
, ts
.tv_nsec
);
497 EXPORT_SYMBOL(ns_to_timespec
);
500 * ns_to_timeval - Convert nanoseconds to timeval
501 * @nsec: the nanoseconds value to be converted
503 * Returns the timeval representation of the nsec parameter.
505 struct timeval
ns_to_timeval(const s64 nsec
)
507 struct timespec ts
= ns_to_timespec(nsec
);
510 tv
.tv_sec
= ts
.tv_sec
;
511 tv
.tv_usec
= (suseconds_t
) ts
.tv_nsec
/ 1000;
515 EXPORT_SYMBOL(ns_to_timeval
);
518 * When we convert to jiffies then we interpret incoming values
521 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
523 * - 'too large' values [that would result in larger than
524 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
526 * - all other values are converted to jiffies by either multiplying
527 * the input value by a factor or dividing it with a factor
529 * We must also be careful about 32-bit overflows.
531 unsigned long msecs_to_jiffies(const unsigned int m
)
534 * Negative value, means infinite timeout:
537 return MAX_JIFFY_OFFSET
;
539 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
541 * HZ is equal to or smaller than 1000, and 1000 is a nice
542 * round multiple of HZ, divide with the factor between them,
545 return (m
+ (MSEC_PER_SEC
/ HZ
) - 1) / (MSEC_PER_SEC
/ HZ
);
546 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
548 * HZ is larger than 1000, and HZ is a nice round multiple of
549 * 1000 - simply multiply with the factor between them.
551 * But first make sure the multiplication result cannot
554 if (m
> jiffies_to_msecs(MAX_JIFFY_OFFSET
))
555 return MAX_JIFFY_OFFSET
;
557 return m
* (HZ
/ MSEC_PER_SEC
);
560 * Generic case - multiply, round and divide. But first
561 * check that if we are doing a net multiplication, that
562 * we wouldnt overflow:
564 if (HZ
> MSEC_PER_SEC
&& m
> jiffies_to_msecs(MAX_JIFFY_OFFSET
))
565 return MAX_JIFFY_OFFSET
;
567 return (m
* HZ
+ MSEC_PER_SEC
- 1) / MSEC_PER_SEC
;
570 EXPORT_SYMBOL(msecs_to_jiffies
);
572 unsigned long usecs_to_jiffies(const unsigned int u
)
574 if (u
> jiffies_to_usecs(MAX_JIFFY_OFFSET
))
575 return MAX_JIFFY_OFFSET
;
576 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
577 return (u
+ (USEC_PER_SEC
/ HZ
) - 1) / (USEC_PER_SEC
/ HZ
);
578 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
579 return u
* (HZ
/ USEC_PER_SEC
);
581 return (u
* HZ
+ USEC_PER_SEC
- 1) / USEC_PER_SEC
;
584 EXPORT_SYMBOL(usecs_to_jiffies
);
587 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
588 * that a remainder subtract here would not do the right thing as the
589 * resolution values don't fall on second boundries. I.e. the line:
590 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
592 * Rather, we just shift the bits off the right.
594 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
595 * value to a scaled second value.
598 timespec_to_jiffies(const struct timespec
*value
)
600 unsigned long sec
= value
->tv_sec
;
601 long nsec
= value
->tv_nsec
+ TICK_NSEC
- 1;
603 if (sec
>= MAX_SEC_IN_JIFFIES
){
604 sec
= MAX_SEC_IN_JIFFIES
;
607 return (((u64
)sec
* SEC_CONVERSION
) +
608 (((u64
)nsec
* NSEC_CONVERSION
) >>
609 (NSEC_JIFFIE_SC
- SEC_JIFFIE_SC
))) >> SEC_JIFFIE_SC
;
612 EXPORT_SYMBOL(timespec_to_jiffies
);
615 jiffies_to_timespec(const unsigned long jiffies
, struct timespec
*value
)
618 * Convert jiffies to nanoseconds and separate with
621 u64 nsec
= (u64
)jiffies
* TICK_NSEC
;
622 value
->tv_sec
= div_long_long_rem(nsec
, NSEC_PER_SEC
, &value
->tv_nsec
);
624 EXPORT_SYMBOL(jiffies_to_timespec
);
626 /* Same for "timeval"
628 * Well, almost. The problem here is that the real system resolution is
629 * in nanoseconds and the value being converted is in micro seconds.
630 * Also for some machines (those that use HZ = 1024, in-particular),
631 * there is a LARGE error in the tick size in microseconds.
633 * The solution we use is to do the rounding AFTER we convert the
634 * microsecond part. Thus the USEC_ROUND, the bits to be shifted off.
635 * Instruction wise, this should cost only an additional add with carry
636 * instruction above the way it was done above.
639 timeval_to_jiffies(const struct timeval
*value
)
641 unsigned long sec
= value
->tv_sec
;
642 long usec
= value
->tv_usec
;
644 if (sec
>= MAX_SEC_IN_JIFFIES
){
645 sec
= MAX_SEC_IN_JIFFIES
;
648 return (((u64
)sec
* SEC_CONVERSION
) +
649 (((u64
)usec
* USEC_CONVERSION
+ USEC_ROUND
) >>
650 (USEC_JIFFIE_SC
- SEC_JIFFIE_SC
))) >> SEC_JIFFIE_SC
;
652 EXPORT_SYMBOL(timeval_to_jiffies
);
654 void jiffies_to_timeval(const unsigned long jiffies
, struct timeval
*value
)
657 * Convert jiffies to nanoseconds and separate with
660 u64 nsec
= (u64
)jiffies
* TICK_NSEC
;
663 value
->tv_sec
= div_long_long_rem(nsec
, NSEC_PER_SEC
, &tv_usec
);
664 tv_usec
/= NSEC_PER_USEC
;
665 value
->tv_usec
= tv_usec
;
667 EXPORT_SYMBOL(jiffies_to_timeval
);
670 * Convert jiffies/jiffies_64 to clock_t and back.
672 clock_t jiffies_to_clock_t(long x
)
674 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
675 return x
/ (HZ
/ USER_HZ
);
677 u64 tmp
= (u64
)x
* TICK_NSEC
;
678 do_div(tmp
, (NSEC_PER_SEC
/ USER_HZ
));
682 EXPORT_SYMBOL(jiffies_to_clock_t
);
684 unsigned long clock_t_to_jiffies(unsigned long x
)
686 #if (HZ % USER_HZ)==0
687 if (x
>= ~0UL / (HZ
/ USER_HZ
))
689 return x
* (HZ
/ USER_HZ
);
693 /* Don't worry about loss of precision here .. */
694 if (x
>= ~0UL / HZ
* USER_HZ
)
697 /* .. but do try to contain it here */
699 do_div(jif
, USER_HZ
);
703 EXPORT_SYMBOL(clock_t_to_jiffies
);
705 u64
jiffies_64_to_clock_t(u64 x
)
707 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
708 do_div(x
, HZ
/ USER_HZ
);
711 * There are better ways that don't overflow early,
712 * but even this doesn't overflow in hundreds of years
716 do_div(x
, (NSEC_PER_SEC
/ USER_HZ
));
721 EXPORT_SYMBOL(jiffies_64_to_clock_t
);
723 u64
nsec_to_clock_t(u64 x
)
725 #if (NSEC_PER_SEC % USER_HZ) == 0
726 do_div(x
, (NSEC_PER_SEC
/ USER_HZ
));
727 #elif (USER_HZ % 512) == 0
729 do_div(x
, (NSEC_PER_SEC
/ 512));
732 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
733 * overflow after 64.99 years.
734 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
737 do_div(x
, (unsigned long)((9ull * NSEC_PER_SEC
+ (USER_HZ
/2)) /
743 #if (BITS_PER_LONG < 64)
744 u64
get_jiffies_64(void)
750 seq
= read_seqbegin(&xtime_lock
);
752 } while (read_seqretry(&xtime_lock
, seq
));
756 EXPORT_SYMBOL(get_jiffies_64
);
759 EXPORT_SYMBOL(jiffies
);