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/errno.h>
33 #include <linux/smp_lock.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 (!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 long pps_offset
; /* pps time offset (us) */
205 long pps_jitter
= MAXTIME
; /* time dispersion (jitter) (us) */
207 long pps_freq
; /* frequency offset (scaled ppm) */
208 long pps_stabil
= MAXFREQ
; /* frequency dispersion (scaled ppm) */
210 long pps_valid
= PPS_VALID
; /* pps signal watchdog counter */
212 int pps_shift
= PPS_SHIFT
; /* interval duration (s) (shift) */
214 long pps_jitcnt
; /* jitter limit exceeded */
215 long pps_calcnt
; /* calibration intervals */
216 long pps_errcnt
; /* calibration errors */
217 long pps_stbcnt
; /* stability limit exceeded */
219 /* hook for a loadable hardpps kernel module */
220 void (*hardpps_ptr
)(struct timeval
*);
222 /* we call this to notify the arch when the clock is being
223 * controlled. If no such arch routine, do nothing.
225 void __attribute__ ((weak
)) notify_arch_cmos_timer(void)
230 /* adjtimex mainly allows reading (and writing, if superuser) of
231 * kernel time-keeping variables. used by xntpd.
233 int do_adjtimex(struct timex
*txc
)
235 long ltemp
, mtemp
, save_adjust
;
238 /* In order to modify anything, you gotta be super-user! */
239 if (txc
->modes
&& !capable(CAP_SYS_TIME
))
242 /* Now we validate the data before disabling interrupts */
244 if ((txc
->modes
& ADJ_OFFSET_SINGLESHOT
) == ADJ_OFFSET_SINGLESHOT
)
245 /* singleshot must not be used with any other mode bits */
246 if (txc
->modes
!= ADJ_OFFSET_SINGLESHOT
)
249 if (txc
->modes
!= ADJ_OFFSET_SINGLESHOT
&& (txc
->modes
& ADJ_OFFSET
))
250 /* adjustment Offset limited to +- .512 seconds */
251 if (txc
->offset
<= - MAXPHASE
|| txc
->offset
>= MAXPHASE
)
254 /* if the quartz is off by more than 10% something is VERY wrong ! */
255 if (txc
->modes
& ADJ_TICK
)
256 if (txc
->tick
< 900000/USER_HZ
||
257 txc
->tick
> 1100000/USER_HZ
)
260 write_seqlock_irq(&xtime_lock
);
261 result
= time_state
; /* mostly `TIME_OK' */
263 /* Save for later - semantics of adjtime is to return old value */
264 save_adjust
= time_next_adjust
? time_next_adjust
: time_adjust
;
266 #if 0 /* STA_CLOCKERR is never set yet */
267 time_status
&= ~STA_CLOCKERR
; /* reset STA_CLOCKERR */
269 /* If there are input parameters, then process them */
272 if (txc
->modes
& ADJ_STATUS
) /* only set allowed bits */
273 time_status
= (txc
->status
& ~STA_RONLY
) |
274 (time_status
& STA_RONLY
);
276 if (txc
->modes
& ADJ_FREQUENCY
) { /* p. 22 */
277 if (txc
->freq
> MAXFREQ
|| txc
->freq
< -MAXFREQ
) {
281 time_freq
= txc
->freq
- pps_freq
;
284 if (txc
->modes
& ADJ_MAXERROR
) {
285 if (txc
->maxerror
< 0 || txc
->maxerror
>= NTP_PHASE_LIMIT
) {
289 time_maxerror
= txc
->maxerror
;
292 if (txc
->modes
& ADJ_ESTERROR
) {
293 if (txc
->esterror
< 0 || txc
->esterror
>= NTP_PHASE_LIMIT
) {
297 time_esterror
= txc
->esterror
;
300 if (txc
->modes
& ADJ_TIMECONST
) { /* p. 24 */
301 if (txc
->constant
< 0) { /* NTP v4 uses values > 6 */
305 time_constant
= txc
->constant
;
308 if (txc
->modes
& ADJ_OFFSET
) { /* values checked earlier */
309 if (txc
->modes
== ADJ_OFFSET_SINGLESHOT
) {
310 /* adjtime() is independent from ntp_adjtime() */
311 if ((time_next_adjust
= txc
->offset
) == 0)
314 else if ( time_status
& (STA_PLL
| STA_PPSTIME
) ) {
315 ltemp
= (time_status
& (STA_PPSTIME
| STA_PPSSIGNAL
)) ==
316 (STA_PPSTIME
| STA_PPSSIGNAL
) ?
317 pps_offset
: txc
->offset
;
320 * Scale the phase adjustment and
321 * clamp to the operating range.
323 if (ltemp
> MAXPHASE
)
324 time_offset
= MAXPHASE
<< SHIFT_UPDATE
;
325 else if (ltemp
< -MAXPHASE
)
326 time_offset
= -(MAXPHASE
<< SHIFT_UPDATE
);
328 time_offset
= ltemp
<< SHIFT_UPDATE
;
331 * Select whether the frequency is to be controlled
332 * and in which mode (PLL or FLL). Clamp to the operating
333 * range. Ugly multiply/divide should be replaced someday.
336 if (time_status
& STA_FREQHOLD
|| time_reftime
== 0)
337 time_reftime
= xtime
.tv_sec
;
338 mtemp
= xtime
.tv_sec
- time_reftime
;
339 time_reftime
= xtime
.tv_sec
;
340 if (time_status
& STA_FLL
) {
341 if (mtemp
>= MINSEC
) {
342 ltemp
= (time_offset
/ mtemp
) << (SHIFT_USEC
-
344 time_freq
+= shift_right(ltemp
, SHIFT_KH
);
345 } else /* calibration interval too short (p. 12) */
347 } else { /* PLL mode */
348 if (mtemp
< MAXSEC
) {
350 time_freq
+= shift_right(ltemp
,(time_constant
+
352 SHIFT_KF
- SHIFT_USEC
));
353 } else /* calibration interval too long (p. 12) */
356 time_freq
= min(time_freq
, time_tolerance
);
357 time_freq
= max(time_freq
, -time_tolerance
);
358 } /* STA_PLL || STA_PPSTIME */
359 } /* txc->modes & ADJ_OFFSET */
360 if (txc
->modes
& ADJ_TICK
) {
361 tick_usec
= txc
->tick
;
362 tick_nsec
= TICK_USEC_TO_NSEC(tick_usec
);
365 leave
: if ((time_status
& (STA_UNSYNC
|STA_CLOCKERR
)) != 0
366 || ((time_status
& (STA_PPSFREQ
|STA_PPSTIME
)) != 0
367 && (time_status
& STA_PPSSIGNAL
) == 0)
369 || ((time_status
& (STA_PPSTIME
|STA_PPSJITTER
))
370 == (STA_PPSTIME
|STA_PPSJITTER
))
372 || ((time_status
& STA_PPSFREQ
) != 0
373 && (time_status
& (STA_PPSWANDER
|STA_PPSERROR
)) != 0))
377 if ((txc
->modes
& ADJ_OFFSET_SINGLESHOT
) == ADJ_OFFSET_SINGLESHOT
)
378 txc
->offset
= save_adjust
;
380 txc
->offset
= shift_right(time_offset
, SHIFT_UPDATE
);
382 txc
->freq
= time_freq
+ pps_freq
;
383 txc
->maxerror
= time_maxerror
;
384 txc
->esterror
= time_esterror
;
385 txc
->status
= time_status
;
386 txc
->constant
= time_constant
;
387 txc
->precision
= time_precision
;
388 txc
->tolerance
= time_tolerance
;
389 txc
->tick
= tick_usec
;
390 txc
->ppsfreq
= pps_freq
;
391 txc
->jitter
= pps_jitter
>> PPS_AVG
;
392 txc
->shift
= pps_shift
;
393 txc
->stabil
= pps_stabil
;
394 txc
->jitcnt
= pps_jitcnt
;
395 txc
->calcnt
= pps_calcnt
;
396 txc
->errcnt
= pps_errcnt
;
397 txc
->stbcnt
= pps_stbcnt
;
398 write_sequnlock_irq(&xtime_lock
);
399 do_gettimeofday(&txc
->time
);
400 notify_arch_cmos_timer();
404 asmlinkage
long sys_adjtimex(struct timex __user
*txc_p
)
406 struct timex txc
; /* Local copy of parameter */
409 /* Copy the user data space into the kernel copy
410 * structure. But bear in mind that the structures
413 if(copy_from_user(&txc
, txc_p
, sizeof(struct timex
)))
415 ret
= do_adjtimex(&txc
);
416 return copy_to_user(txc_p
, &txc
, sizeof(struct timex
)) ? -EFAULT
: ret
;
419 inline struct timespec
current_kernel_time(void)
425 seq
= read_seqbegin(&xtime_lock
);
428 } while (read_seqretry(&xtime_lock
, seq
));
433 EXPORT_SYMBOL(current_kernel_time
);
436 * current_fs_time - Return FS time
439 * Return the current time truncated to the time granuality supported by
442 struct timespec
current_fs_time(struct super_block
*sb
)
444 struct timespec now
= current_kernel_time();
445 return timespec_trunc(now
, sb
->s_time_gran
);
447 EXPORT_SYMBOL(current_fs_time
);
450 * timespec_trunc - Truncate timespec to a granuality
452 * @gran: Granuality in ns.
454 * Truncate a timespec to a granuality. gran must be smaller than a second.
455 * Always rounds down.
457 * This function should be only used for timestamps returned by
458 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
459 * it doesn't handle the better resolution of the later.
461 struct timespec
timespec_trunc(struct timespec t
, unsigned gran
)
464 * Division is pretty slow so avoid it for common cases.
465 * Currently current_kernel_time() never returns better than
466 * jiffies resolution. Exploit that.
468 if (gran
<= jiffies_to_usecs(1) * 1000) {
470 } else if (gran
== 1000000000) {
473 t
.tv_nsec
-= t
.tv_nsec
% gran
;
477 EXPORT_SYMBOL(timespec_trunc
);
479 #ifdef CONFIG_TIME_INTERPOLATION
480 void getnstimeofday (struct timespec
*tv
)
482 unsigned long seq
,sec
,nsec
;
485 seq
= read_seqbegin(&xtime_lock
);
487 nsec
= xtime
.tv_nsec
+time_interpolator_get_offset();
488 } while (unlikely(read_seqretry(&xtime_lock
, seq
)));
490 while (unlikely(nsec
>= NSEC_PER_SEC
)) {
491 nsec
-= NSEC_PER_SEC
;
497 EXPORT_SYMBOL_GPL(getnstimeofday
);
499 int do_settimeofday (struct timespec
*tv
)
501 time_t wtm_sec
, sec
= tv
->tv_sec
;
502 long wtm_nsec
, nsec
= tv
->tv_nsec
;
504 if ((unsigned long)tv
->tv_nsec
>= NSEC_PER_SEC
)
507 write_seqlock_irq(&xtime_lock
);
509 wtm_sec
= wall_to_monotonic
.tv_sec
+ (xtime
.tv_sec
- sec
);
510 wtm_nsec
= wall_to_monotonic
.tv_nsec
+ (xtime
.tv_nsec
- nsec
);
512 set_normalized_timespec(&xtime
, sec
, nsec
);
513 set_normalized_timespec(&wall_to_monotonic
, wtm_sec
, wtm_nsec
);
515 time_adjust
= 0; /* stop active adjtime() */
516 time_status
|= STA_UNSYNC
;
517 time_maxerror
= NTP_PHASE_LIMIT
;
518 time_esterror
= NTP_PHASE_LIMIT
;
519 time_interpolator_reset();
521 write_sequnlock_irq(&xtime_lock
);
525 EXPORT_SYMBOL(do_settimeofday
);
527 void do_gettimeofday (struct timeval
*tv
)
529 unsigned long seq
, nsec
, usec
, sec
, offset
;
531 seq
= read_seqbegin(&xtime_lock
);
532 offset
= time_interpolator_get_offset();
534 nsec
= xtime
.tv_nsec
;
535 } while (unlikely(read_seqretry(&xtime_lock
, seq
)));
537 usec
= (nsec
+ offset
) / 1000;
539 while (unlikely(usec
>= USEC_PER_SEC
)) {
540 usec
-= USEC_PER_SEC
;
548 EXPORT_SYMBOL(do_gettimeofday
);
553 * Simulate gettimeofday using do_gettimeofday which only allows a timeval
554 * and therefore only yields usec accuracy
556 void getnstimeofday(struct timespec
*tv
)
561 tv
->tv_sec
= x
.tv_sec
;
562 tv
->tv_nsec
= x
.tv_usec
* NSEC_PER_USEC
;
564 EXPORT_SYMBOL_GPL(getnstimeofday
);
567 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
568 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
569 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
571 * [For the Julian calendar (which was used in Russia before 1917,
572 * Britain & colonies before 1752, anywhere else before 1582,
573 * and is still in use by some communities) leave out the
574 * -year/100+year/400 terms, and add 10.]
576 * This algorithm was first published by Gauss (I think).
578 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
579 * machines were long is 32-bit! (However, as time_t is signed, we
580 * will already get problems at other places on 2038-01-19 03:14:08)
583 mktime(const unsigned int year0
, const unsigned int mon0
,
584 const unsigned int day
, const unsigned int hour
,
585 const unsigned int min
, const unsigned int sec
)
587 unsigned int mon
= mon0
, year
= year0
;
589 /* 1..12 -> 11,12,1..10 */
590 if (0 >= (int) (mon
-= 2)) {
591 mon
+= 12; /* Puts Feb last since it has leap day */
595 return ((((unsigned long)
596 (year
/4 - year
/100 + year
/400 + 367*mon
/12 + day
) +
598 )*24 + hour
/* now have hours */
599 )*60 + min
/* now have minutes */
600 )*60 + sec
; /* finally seconds */
603 EXPORT_SYMBOL(mktime
);
606 * set_normalized_timespec - set timespec sec and nsec parts and normalize
608 * @ts: pointer to timespec variable to be set
609 * @sec: seconds to set
610 * @nsec: nanoseconds to set
612 * Set seconds and nanoseconds field of a timespec variable and
613 * normalize to the timespec storage format
615 * Note: The tv_nsec part is always in the range of
616 * 0 <= tv_nsec < NSEC_PER_SEC
617 * For negative values only the tv_sec field is negative !
619 void set_normalized_timespec(struct timespec
*ts
, time_t sec
, long nsec
)
621 while (nsec
>= NSEC_PER_SEC
) {
622 nsec
-= NSEC_PER_SEC
;
626 nsec
+= NSEC_PER_SEC
;
634 * ns_to_timespec - Convert nanoseconds to timespec
635 * @nsec: the nanoseconds value to be converted
637 * Returns the timespec representation of the nsec parameter.
639 inline struct timespec
ns_to_timespec(const nsec_t nsec
)
644 ts
.tv_sec
= div_long_long_rem_signed(nsec
, NSEC_PER_SEC
,
647 ts
.tv_sec
= ts
.tv_nsec
= 0;
653 * ns_to_timeval - Convert nanoseconds to timeval
654 * @nsec: the nanoseconds value to be converted
656 * Returns the timeval representation of the nsec parameter.
658 struct timeval
ns_to_timeval(const nsec_t nsec
)
660 struct timespec ts
= ns_to_timespec(nsec
);
663 tv
.tv_sec
= ts
.tv_sec
;
664 tv
.tv_usec
= (suseconds_t
) ts
.tv_nsec
/ 1000;
669 #if (BITS_PER_LONG < 64)
670 u64
get_jiffies_64(void)
676 seq
= read_seqbegin(&xtime_lock
);
678 } while (read_seqretry(&xtime_lock
, seq
));
682 EXPORT_SYMBOL(get_jiffies_64
);
685 EXPORT_SYMBOL(jiffies
);