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 write_sequnlock_irq(&xtime_lock
);
141 * In case for some reason the CMOS clock has not already been running
142 * in UTC, but in some local time: The first time we set the timezone,
143 * we will warp the clock so that it is ticking UTC time instead of
144 * local time. Presumably, if someone is setting the timezone then we
145 * are running in an environment where the programs understand about
146 * timezones. This should be done at boot time in the /etc/rc script,
147 * as soon as possible, so that the clock can be set right. Otherwise,
148 * various programs will get confused when the clock gets warped.
151 int do_sys_settimeofday(struct timespec
*tv
, struct timezone
*tz
)
153 static int firsttime
= 1;
156 if (tv
&& !timespec_valid(tv
))
159 error
= security_settime(tv
, tz
);
164 /* SMP safe, global irq locking makes it work. */
174 /* SMP safe, again the code in arch/foo/time.c should
175 * globally block out interrupts when it runs.
177 return do_settimeofday(tv
);
182 asmlinkage
long sys_settimeofday(struct timeval __user
*tv
,
183 struct timezone __user
*tz
)
185 struct timeval user_tv
;
186 struct timespec new_ts
;
187 struct timezone new_tz
;
190 if (copy_from_user(&user_tv
, tv
, sizeof(*tv
)))
192 new_ts
.tv_sec
= user_tv
.tv_sec
;
193 new_ts
.tv_nsec
= user_tv
.tv_usec
* NSEC_PER_USEC
;
196 if (copy_from_user(&new_tz
, tz
, sizeof(*tz
)))
200 return do_sys_settimeofday(tv
? &new_ts
: NULL
, tz
? &new_tz
: NULL
);
203 asmlinkage
long sys_adjtimex(struct timex __user
*txc_p
)
205 struct timex txc
; /* Local copy of parameter */
208 /* Copy the user data space into the kernel copy
209 * structure. But bear in mind that the structures
212 if(copy_from_user(&txc
, txc_p
, sizeof(struct timex
)))
214 ret
= do_adjtimex(&txc
);
215 return copy_to_user(txc_p
, &txc
, sizeof(struct timex
)) ? -EFAULT
: ret
;
219 * current_fs_time - Return FS time
222 * Return the current time truncated to the time granularity supported by
225 struct timespec
current_fs_time(struct super_block
*sb
)
227 struct timespec now
= current_kernel_time();
228 return timespec_trunc(now
, sb
->s_time_gran
);
230 EXPORT_SYMBOL(current_fs_time
);
233 * Convert jiffies to milliseconds and back.
235 * Avoid unnecessary multiplications/divisions in the
236 * two most common HZ cases:
238 unsigned int inline jiffies_to_msecs(const unsigned long j
)
240 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
241 return (MSEC_PER_SEC
/ HZ
) * j
;
242 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
243 return (j
+ (HZ
/ MSEC_PER_SEC
) - 1)/(HZ
/ MSEC_PER_SEC
);
245 return (j
* MSEC_PER_SEC
) / HZ
;
248 EXPORT_SYMBOL(jiffies_to_msecs
);
250 unsigned int inline jiffies_to_usecs(const unsigned long j
)
252 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
253 return (USEC_PER_SEC
/ HZ
) * j
;
254 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
255 return (j
+ (HZ
/ USEC_PER_SEC
) - 1)/(HZ
/ USEC_PER_SEC
);
257 return (j
* USEC_PER_SEC
) / HZ
;
260 EXPORT_SYMBOL(jiffies_to_usecs
);
263 * timespec_trunc - Truncate timespec to a granularity
265 * @gran: Granularity in ns.
267 * Truncate a timespec to a granularity. gran must be smaller than a second.
268 * Always rounds down.
270 * This function should be only used for timestamps returned by
271 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
272 * it doesn't handle the better resolution of the later.
274 struct timespec
timespec_trunc(struct timespec t
, unsigned gran
)
277 * Division is pretty slow so avoid it for common cases.
278 * Currently current_kernel_time() never returns better than
279 * jiffies resolution. Exploit that.
281 if (gran
<= jiffies_to_usecs(1) * 1000) {
283 } else if (gran
== 1000000000) {
286 t
.tv_nsec
-= t
.tv_nsec
% gran
;
290 EXPORT_SYMBOL(timespec_trunc
);
292 #ifndef CONFIG_GENERIC_TIME
294 * Simulate gettimeofday using do_gettimeofday which only allows a timeval
295 * and therefore only yields usec accuracy
297 void getnstimeofday(struct timespec
*tv
)
302 tv
->tv_sec
= x
.tv_sec
;
303 tv
->tv_nsec
= x
.tv_usec
* NSEC_PER_USEC
;
305 EXPORT_SYMBOL_GPL(getnstimeofday
);
308 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
309 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
310 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
312 * [For the Julian calendar (which was used in Russia before 1917,
313 * Britain & colonies before 1752, anywhere else before 1582,
314 * and is still in use by some communities) leave out the
315 * -year/100+year/400 terms, and add 10.]
317 * This algorithm was first published by Gauss (I think).
319 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
320 * machines were long is 32-bit! (However, as time_t is signed, we
321 * will already get problems at other places on 2038-01-19 03:14:08)
324 mktime(const unsigned int year0
, const unsigned int mon0
,
325 const unsigned int day
, const unsigned int hour
,
326 const unsigned int min
, const unsigned int sec
)
328 unsigned int mon
= mon0
, year
= year0
;
330 /* 1..12 -> 11,12,1..10 */
331 if (0 >= (int) (mon
-= 2)) {
332 mon
+= 12; /* Puts Feb last since it has leap day */
336 return ((((unsigned long)
337 (year
/4 - year
/100 + year
/400 + 367*mon
/12 + day
) +
339 )*24 + hour
/* now have hours */
340 )*60 + min
/* now have minutes */
341 )*60 + sec
; /* finally seconds */
344 EXPORT_SYMBOL(mktime
);
347 * set_normalized_timespec - set timespec sec and nsec parts and normalize
349 * @ts: pointer to timespec variable to be set
350 * @sec: seconds to set
351 * @nsec: nanoseconds to set
353 * Set seconds and nanoseconds field of a timespec variable and
354 * normalize to the timespec storage format
356 * Note: The tv_nsec part is always in the range of
357 * 0 <= tv_nsec < NSEC_PER_SEC
358 * For negative values only the tv_sec field is negative !
360 void set_normalized_timespec(struct timespec
*ts
, time_t sec
, long nsec
)
362 while (nsec
>= NSEC_PER_SEC
) {
363 nsec
-= NSEC_PER_SEC
;
367 nsec
+= NSEC_PER_SEC
;
375 * ns_to_timespec - Convert nanoseconds to timespec
376 * @nsec: the nanoseconds value to be converted
378 * Returns the timespec representation of the nsec parameter.
380 struct timespec
ns_to_timespec(const s64 nsec
)
385 return (struct timespec
) {0, 0};
387 ts
.tv_sec
= div_long_long_rem_signed(nsec
, NSEC_PER_SEC
, &ts
.tv_nsec
);
388 if (unlikely(nsec
< 0))
389 set_normalized_timespec(&ts
, ts
.tv_sec
, ts
.tv_nsec
);
393 EXPORT_SYMBOL(ns_to_timespec
);
396 * ns_to_timeval - Convert nanoseconds to timeval
397 * @nsec: the nanoseconds value to be converted
399 * Returns the timeval representation of the nsec parameter.
401 struct timeval
ns_to_timeval(const s64 nsec
)
403 struct timespec ts
= ns_to_timespec(nsec
);
406 tv
.tv_sec
= ts
.tv_sec
;
407 tv
.tv_usec
= (suseconds_t
) ts
.tv_nsec
/ 1000;
411 EXPORT_SYMBOL(ns_to_timeval
);
414 * When we convert to jiffies then we interpret incoming values
417 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
419 * - 'too large' values [that would result in larger than
420 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
422 * - all other values are converted to jiffies by either multiplying
423 * the input value by a factor or dividing it with a factor
425 * We must also be careful about 32-bit overflows.
427 unsigned long msecs_to_jiffies(const unsigned int m
)
430 * Negative value, means infinite timeout:
433 return MAX_JIFFY_OFFSET
;
435 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
437 * HZ is equal to or smaller than 1000, and 1000 is a nice
438 * round multiple of HZ, divide with the factor between them,
441 return (m
+ (MSEC_PER_SEC
/ HZ
) - 1) / (MSEC_PER_SEC
/ HZ
);
442 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
444 * HZ is larger than 1000, and HZ is a nice round multiple of
445 * 1000 - simply multiply with the factor between them.
447 * But first make sure the multiplication result cannot
450 if (m
> jiffies_to_msecs(MAX_JIFFY_OFFSET
))
451 return MAX_JIFFY_OFFSET
;
453 return m
* (HZ
/ MSEC_PER_SEC
);
456 * Generic case - multiply, round and divide. But first
457 * check that if we are doing a net multiplication, that
458 * we wouldnt overflow:
460 if (HZ
> MSEC_PER_SEC
&& m
> jiffies_to_msecs(MAX_JIFFY_OFFSET
))
461 return MAX_JIFFY_OFFSET
;
463 return (m
* HZ
+ MSEC_PER_SEC
- 1) / MSEC_PER_SEC
;
466 EXPORT_SYMBOL(msecs_to_jiffies
);
468 unsigned long usecs_to_jiffies(const unsigned int u
)
470 if (u
> jiffies_to_usecs(MAX_JIFFY_OFFSET
))
471 return MAX_JIFFY_OFFSET
;
472 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
473 return (u
+ (USEC_PER_SEC
/ HZ
) - 1) / (USEC_PER_SEC
/ HZ
);
474 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
475 return u
* (HZ
/ USEC_PER_SEC
);
477 return (u
* HZ
+ USEC_PER_SEC
- 1) / USEC_PER_SEC
;
480 EXPORT_SYMBOL(usecs_to_jiffies
);
483 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
484 * that a remainder subtract here would not do the right thing as the
485 * resolution values don't fall on second boundries. I.e. the line:
486 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
488 * Rather, we just shift the bits off the right.
490 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
491 * value to a scaled second value.
494 timespec_to_jiffies(const struct timespec
*value
)
496 unsigned long sec
= value
->tv_sec
;
497 long nsec
= value
->tv_nsec
+ TICK_NSEC
- 1;
499 if (sec
>= MAX_SEC_IN_JIFFIES
){
500 sec
= MAX_SEC_IN_JIFFIES
;
503 return (((u64
)sec
* SEC_CONVERSION
) +
504 (((u64
)nsec
* NSEC_CONVERSION
) >>
505 (NSEC_JIFFIE_SC
- SEC_JIFFIE_SC
))) >> SEC_JIFFIE_SC
;
508 EXPORT_SYMBOL(timespec_to_jiffies
);
511 jiffies_to_timespec(const unsigned long jiffies
, struct timespec
*value
)
514 * Convert jiffies to nanoseconds and separate with
517 u64 nsec
= (u64
)jiffies
* TICK_NSEC
;
518 value
->tv_sec
= div_long_long_rem(nsec
, NSEC_PER_SEC
, &value
->tv_nsec
);
520 EXPORT_SYMBOL(jiffies_to_timespec
);
522 /* Same for "timeval"
524 * Well, almost. The problem here is that the real system resolution is
525 * in nanoseconds and the value being converted is in micro seconds.
526 * Also for some machines (those that use HZ = 1024, in-particular),
527 * there is a LARGE error in the tick size in microseconds.
529 * The solution we use is to do the rounding AFTER we convert the
530 * microsecond part. Thus the USEC_ROUND, the bits to be shifted off.
531 * Instruction wise, this should cost only an additional add with carry
532 * instruction above the way it was done above.
535 timeval_to_jiffies(const struct timeval
*value
)
537 unsigned long sec
= value
->tv_sec
;
538 long usec
= value
->tv_usec
;
540 if (sec
>= MAX_SEC_IN_JIFFIES
){
541 sec
= MAX_SEC_IN_JIFFIES
;
544 return (((u64
)sec
* SEC_CONVERSION
) +
545 (((u64
)usec
* USEC_CONVERSION
+ USEC_ROUND
) >>
546 (USEC_JIFFIE_SC
- SEC_JIFFIE_SC
))) >> SEC_JIFFIE_SC
;
548 EXPORT_SYMBOL(timeval_to_jiffies
);
550 void jiffies_to_timeval(const unsigned long jiffies
, struct timeval
*value
)
553 * Convert jiffies to nanoseconds and separate with
556 u64 nsec
= (u64
)jiffies
* TICK_NSEC
;
559 value
->tv_sec
= div_long_long_rem(nsec
, NSEC_PER_SEC
, &tv_usec
);
560 tv_usec
/= NSEC_PER_USEC
;
561 value
->tv_usec
= tv_usec
;
563 EXPORT_SYMBOL(jiffies_to_timeval
);
566 * Convert jiffies/jiffies_64 to clock_t and back.
568 clock_t jiffies_to_clock_t(long x
)
570 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
571 return x
/ (HZ
/ USER_HZ
);
573 u64 tmp
= (u64
)x
* TICK_NSEC
;
574 do_div(tmp
, (NSEC_PER_SEC
/ USER_HZ
));
578 EXPORT_SYMBOL(jiffies_to_clock_t
);
580 unsigned long clock_t_to_jiffies(unsigned long x
)
582 #if (HZ % USER_HZ)==0
583 if (x
>= ~0UL / (HZ
/ USER_HZ
))
585 return x
* (HZ
/ USER_HZ
);
589 /* Don't worry about loss of precision here .. */
590 if (x
>= ~0UL / HZ
* USER_HZ
)
593 /* .. but do try to contain it here */
595 do_div(jif
, USER_HZ
);
599 EXPORT_SYMBOL(clock_t_to_jiffies
);
601 u64
jiffies_64_to_clock_t(u64 x
)
603 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
604 do_div(x
, HZ
/ USER_HZ
);
607 * There are better ways that don't overflow early,
608 * but even this doesn't overflow in hundreds of years
612 do_div(x
, (NSEC_PER_SEC
/ USER_HZ
));
617 EXPORT_SYMBOL(jiffies_64_to_clock_t
);
619 u64
nsec_to_clock_t(u64 x
)
621 #if (NSEC_PER_SEC % USER_HZ) == 0
622 do_div(x
, (NSEC_PER_SEC
/ USER_HZ
));
623 #elif (USER_HZ % 512) == 0
625 do_div(x
, (NSEC_PER_SEC
/ 512));
628 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
629 * overflow after 64.99 years.
630 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
633 do_div(x
, (unsigned long)((9ull * NSEC_PER_SEC
+ (USER_HZ
/2)) /
639 #if (BITS_PER_LONG < 64)
640 u64
get_jiffies_64(void)
646 seq
= read_seqbegin(&xtime_lock
);
648 } while (read_seqretry(&xtime_lock
, seq
));
652 EXPORT_SYMBOL(get_jiffies_64
);
655 EXPORT_SYMBOL(jiffies
);