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/smp_lock.h>
35 #include <linux/syscalls.h>
36 #include <linux/security.h>
38 #include <linux/module.h>
40 #include <asm/uaccess.h>
41 #include <asm/unistd.h>
44 * The timezone where the local system is located. Used as a default by some
45 * programs who obtain this value by using gettimeofday.
47 struct timezone sys_tz
;
49 EXPORT_SYMBOL(sys_tz
);
51 #ifndef __ARCH_WANT_SYS_TIME
52 #error ICSA specification requires the logging of time changes. This architecture will not log changes.
55 static void print_time_change(const char *msg
, struct timeval new_tv
)
59 j
= new_tv
.tv_sec
/ 86400L + 719469;
60 s
= new_tv
.tv_sec
% 86400L;
62 if( s
< 0 ) { s
+= 86400L; j
--; }
64 y
= (4L * j
- 1L) / 146097L;
65 j
= 4L * j
- 1L - 146097L * y
;
67 j
= (4L * d
+ 3L) / 1461L;
68 d
= 4L * d
+ 3L - 1461L * j
;
70 m
= (5L * d
- 3L) / 153L;
71 d
= 5L * d
- 3 - 153L * m
;
81 printk(KERN_NOTICE
"Clock: %s time %04d/%02d/%02d - %02d:%02d:%02d GMT\n",
82 msg
, (int) y
, (int) m
+ 1, (int) d
, (int) (s
/ 3600 ), (int) (s
/ 60) % 60, (int) s
% 60);
86 #define ABS(X) ((X) < 0 ? -(X) : (X))
89 static void check_print_time_change(const struct timeval old_tv
, const struct timeval new_tv
)
91 static long accumulated_usecs
;
93 if (ABS(new_tv
.tv_sec
- old_tv
.tv_sec
) <= 2) {
94 /* No more than 2 seconds of change */
95 accumulated_usecs
+= (new_tv
.tv_sec
- old_tv
.tv_sec
) * 1000000L + (new_tv
.tv_usec
- old_tv
.tv_usec
);
96 if (ABS(accumulated_usecs
) < 1000000L) {
97 /* Less than 1 second of accumulated change */
102 accumulated_usecs
= 0;
104 print_time_change("old", old_tv
);
105 print_time_change("new", new_tv
);
108 #ifdef __ARCH_WANT_SYS_TIME
111 * sys_time() can be implemented in user-level using
112 * sys_gettimeofday(). Is this for backwards compatibility? If so,
113 * why not move it into the appropriate arch directory (for those
114 * architectures that need it).
116 asmlinkage
long sys_time(time_t __user
* tloc
)
121 do_gettimeofday(&tv
);
125 if (put_user(i
,tloc
))
132 * sys_stime() can be implemented in user-level using
133 * sys_settimeofday(). Is this for backwards compatibility? If so,
134 * why not move it into the appropriate arch directory (for those
135 * architectures that need it).
138 asmlinkage
long sys_stime(time_t __user
*tptr
)
142 struct timeval old_tv
, new_tv
;
144 if (get_user(tv
.tv_sec
, tptr
))
149 err
= security_settime(&tv
, NULL
);
153 do_gettimeofday(&old_tv
);
154 do_settimeofday(&tv
);
155 do_gettimeofday(&new_tv
);
156 check_print_time_change(old_tv
, new_tv
);
160 #endif /* __ARCH_WANT_SYS_TIME */
162 asmlinkage
long sys_gettimeofday(struct timeval __user
*tv
, struct timezone __user
*tz
)
164 if (likely(tv
!= NULL
)) {
166 do_gettimeofday(&ktv
);
167 if (copy_to_user(tv
, &ktv
, sizeof(ktv
)))
170 if (unlikely(tz
!= NULL
)) {
171 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
178 * Adjust the time obtained from the CMOS to be UTC time instead of
181 * This is ugly, but preferable to the alternatives. Otherwise we
182 * would either need to write a program to do it in /etc/rc (and risk
183 * confusion if the program gets run more than once; it would also be
184 * hard to make the program warp the clock precisely n hours) or
185 * compile in the timezone information into the kernel. Bad, bad....
189 * The best thing to do is to keep the CMOS clock in universal time (UTC)
190 * as real UNIX machines always do it. This avoids all headaches about
191 * daylight saving times and warping kernel clocks.
193 static inline void warp_clock(void)
195 write_seqlock_irq(&xtime_lock
);
196 wall_to_monotonic
.tv_sec
-= sys_tz
.tz_minuteswest
* 60;
197 xtime
.tv_sec
+= sys_tz
.tz_minuteswest
* 60;
198 time_interpolator_reset();
199 write_sequnlock_irq(&xtime_lock
);
204 * In case for some reason the CMOS clock has not already been running
205 * in UTC, but in some local time: The first time we set the timezone,
206 * we will warp the clock so that it is ticking UTC time instead of
207 * local time. Presumably, if someone is setting the timezone then we
208 * are running in an environment where the programs understand about
209 * timezones. This should be done at boot time in the /etc/rc script,
210 * as soon as possible, so that the clock can be set right. Otherwise,
211 * various programs will get confused when the clock gets warped.
214 int do_sys_settimeofday(struct timespec
*tv
, struct timezone
*tz
)
216 static int firsttime
= 1;
218 struct timeval old_tv
, new_tv
;
220 if (tv
&& !timespec_valid(tv
))
223 error
= security_settime(tv
, tz
);
228 /* SMP safe, global irq locking makes it work. */
238 /* SMP safe, again the code in arch/foo/time.c should
239 * globally block out interrupts when it runs.
241 do_gettimeofday(&old_tv
);
242 error
= do_settimeofday(tv
);
243 do_gettimeofday(&new_tv
);
244 check_print_time_change(old_tv
, new_tv
);
249 asmlinkage
long sys_settimeofday(struct timeval __user
*tv
,
250 struct timezone __user
*tz
)
252 struct timeval user_tv
;
253 struct timespec new_ts
;
254 struct timezone new_tz
;
257 if (copy_from_user(&user_tv
, tv
, sizeof(*tv
)))
259 new_ts
.tv_sec
= user_tv
.tv_sec
;
260 new_ts
.tv_nsec
= user_tv
.tv_usec
* NSEC_PER_USEC
;
263 if (copy_from_user(&new_tz
, tz
, sizeof(*tz
)))
267 return do_sys_settimeofday(tv
? &new_ts
: NULL
, tz
? &new_tz
: NULL
);
270 asmlinkage
long sys_adjtimex(struct timex __user
*txc_p
)
272 struct timex txc
; /* Local copy of parameter */
275 /* Copy the user data space into the kernel copy
276 * structure. But bear in mind that the structures
279 if(copy_from_user(&txc
, txc_p
, sizeof(struct timex
)))
281 ret
= do_adjtimex(&txc
);
282 return copy_to_user(txc_p
, &txc
, sizeof(struct timex
)) ? -EFAULT
: ret
;
285 inline struct timespec
current_kernel_time(void)
291 seq
= read_seqbegin(&xtime_lock
);
294 } while (read_seqretry(&xtime_lock
, seq
));
299 EXPORT_SYMBOL(current_kernel_time
);
302 * current_fs_time - Return FS time
305 * Return the current time truncated to the time granularity supported by
308 struct timespec
current_fs_time(struct super_block
*sb
)
310 struct timespec now
= current_kernel_time();
311 return timespec_trunc(now
, sb
->s_time_gran
);
313 EXPORT_SYMBOL(current_fs_time
);
316 * timespec_trunc - Truncate timespec to a granularity
318 * @gran: Granularity in ns.
320 * Truncate a timespec to a granularity. gran must be smaller than a second.
321 * Always rounds down.
323 * This function should be only used for timestamps returned by
324 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
325 * it doesn't handle the better resolution of the later.
327 struct timespec
timespec_trunc(struct timespec t
, unsigned gran
)
330 * Division is pretty slow so avoid it for common cases.
331 * Currently current_kernel_time() never returns better than
332 * jiffies resolution. Exploit that.
334 if (gran
<= jiffies_to_usecs(1) * 1000) {
336 } else if (gran
== 1000000000) {
339 t
.tv_nsec
-= t
.tv_nsec
% gran
;
343 EXPORT_SYMBOL(timespec_trunc
);
345 #ifdef CONFIG_TIME_INTERPOLATION
346 void getnstimeofday (struct timespec
*tv
)
348 unsigned long seq
,sec
,nsec
;
351 seq
= read_seqbegin(&xtime_lock
);
353 nsec
= xtime
.tv_nsec
+time_interpolator_get_offset();
354 } while (unlikely(read_seqretry(&xtime_lock
, seq
)));
356 while (unlikely(nsec
>= NSEC_PER_SEC
)) {
357 nsec
-= NSEC_PER_SEC
;
363 EXPORT_SYMBOL_GPL(getnstimeofday
);
365 int do_settimeofday (struct timespec
*tv
)
367 time_t wtm_sec
, sec
= tv
->tv_sec
;
368 long wtm_nsec
, nsec
= tv
->tv_nsec
;
370 if ((unsigned long)tv
->tv_nsec
>= NSEC_PER_SEC
)
373 write_seqlock_irq(&xtime_lock
);
375 wtm_sec
= wall_to_monotonic
.tv_sec
+ (xtime
.tv_sec
- sec
);
376 wtm_nsec
= wall_to_monotonic
.tv_nsec
+ (xtime
.tv_nsec
- nsec
);
378 set_normalized_timespec(&xtime
, sec
, nsec
);
379 set_normalized_timespec(&wall_to_monotonic
, wtm_sec
, wtm_nsec
);
381 time_adjust
= 0; /* stop active adjtime() */
382 time_status
|= STA_UNSYNC
;
383 time_maxerror
= NTP_PHASE_LIMIT
;
384 time_esterror
= NTP_PHASE_LIMIT
;
385 time_interpolator_reset();
387 write_sequnlock_irq(&xtime_lock
);
391 EXPORT_SYMBOL(do_settimeofday
);
393 void do_gettimeofday (struct timeval
*tv
)
395 unsigned long seq
, nsec
, usec
, sec
, offset
;
397 seq
= read_seqbegin(&xtime_lock
);
398 offset
= time_interpolator_get_offset();
400 nsec
= xtime
.tv_nsec
;
401 } while (unlikely(read_seqretry(&xtime_lock
, seq
)));
403 usec
= (nsec
+ offset
) / 1000;
405 while (unlikely(usec
>= USEC_PER_SEC
)) {
406 usec
-= USEC_PER_SEC
;
414 EXPORT_SYMBOL(do_gettimeofday
);
418 #ifndef CONFIG_GENERIC_TIME
420 * Simulate gettimeofday using do_gettimeofday which only allows a timeval
421 * and therefore only yields usec accuracy
423 void getnstimeofday(struct timespec
*tv
)
428 tv
->tv_sec
= x
.tv_sec
;
429 tv
->tv_nsec
= x
.tv_usec
* NSEC_PER_USEC
;
431 EXPORT_SYMBOL_GPL(getnstimeofday
);
435 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
436 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
437 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
439 * [For the Julian calendar (which was used in Russia before 1917,
440 * Britain & colonies before 1752, anywhere else before 1582,
441 * and is still in use by some communities) leave out the
442 * -year/100+year/400 terms, and add 10.]
444 * This algorithm was first published by Gauss (I think).
446 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
447 * machines were long is 32-bit! (However, as time_t is signed, we
448 * will already get problems at other places on 2038-01-19 03:14:08)
451 mktime(const unsigned int year0
, const unsigned int mon0
,
452 const unsigned int day
, const unsigned int hour
,
453 const unsigned int min
, const unsigned int sec
)
455 unsigned int mon
= mon0
, year
= year0
;
457 /* 1..12 -> 11,12,1..10 */
458 if (0 >= (int) (mon
-= 2)) {
459 mon
+= 12; /* Puts Feb last since it has leap day */
463 return ((((unsigned long)
464 (year
/4 - year
/100 + year
/400 + 367*mon
/12 + day
) +
466 )*24 + hour
/* now have hours */
467 )*60 + min
/* now have minutes */
468 )*60 + sec
; /* finally seconds */
471 EXPORT_SYMBOL(mktime
);
474 * set_normalized_timespec - set timespec sec and nsec parts and normalize
476 * @ts: pointer to timespec variable to be set
477 * @sec: seconds to set
478 * @nsec: nanoseconds to set
480 * Set seconds and nanoseconds field of a timespec variable and
481 * normalize to the timespec storage format
483 * Note: The tv_nsec part is always in the range of
484 * 0 <= tv_nsec < NSEC_PER_SEC
485 * For negative values only the tv_sec field is negative !
487 void set_normalized_timespec(struct timespec
*ts
, time_t sec
, long nsec
)
489 while (nsec
>= NSEC_PER_SEC
) {
490 nsec
-= NSEC_PER_SEC
;
494 nsec
+= NSEC_PER_SEC
;
502 * ns_to_timespec - Convert nanoseconds to timespec
503 * @nsec: the nanoseconds value to be converted
505 * Returns the timespec representation of the nsec parameter.
507 struct timespec
ns_to_timespec(const s64 nsec
)
512 return (struct timespec
) {0, 0};
514 ts
.tv_sec
= div_long_long_rem_signed(nsec
, NSEC_PER_SEC
, &ts
.tv_nsec
);
515 if (unlikely(nsec
< 0))
516 set_normalized_timespec(&ts
, ts
.tv_sec
, ts
.tv_nsec
);
522 * ns_to_timeval - Convert nanoseconds to timeval
523 * @nsec: the nanoseconds value to be converted
525 * Returns the timeval representation of the nsec parameter.
527 struct timeval
ns_to_timeval(const s64 nsec
)
529 struct timespec ts
= ns_to_timespec(nsec
);
532 tv
.tv_sec
= ts
.tv_sec
;
533 tv
.tv_usec
= (suseconds_t
) ts
.tv_nsec
/ 1000;
538 #if (BITS_PER_LONG < 64)
539 u64
get_jiffies_64(void)
545 seq
= read_seqbegin(&xtime_lock
);
547 } while (read_seqretry(&xtime_lock
, seq
));
551 EXPORT_SYMBOL(get_jiffies_64
);
554 EXPORT_SYMBOL(jiffies
);