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/clocksource.h>
34 #include <linux/errno.h>
35 #include <linux/syscalls.h>
36 #include <linux/security.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
)
60 time_t i
= get_seconds();
70 * sys_stime() can be implemented in user-level using
71 * sys_settimeofday(). Is this for backwards compatibility? If so,
72 * why not move it into the appropriate arch directory (for those
73 * architectures that need it).
76 asmlinkage
long sys_stime(time_t __user
*tptr
)
81 if (get_user(tv
.tv_sec
, tptr
))
86 err
= security_settime(&tv
, NULL
);
94 #endif /* __ARCH_WANT_SYS_TIME */
96 asmlinkage
long sys_gettimeofday(struct timeval __user
*tv
, struct timezone __user
*tz
)
98 if (likely(tv
!= NULL
)) {
100 do_gettimeofday(&ktv
);
101 if (copy_to_user(tv
, &ktv
, sizeof(ktv
)))
104 if (unlikely(tz
!= NULL
)) {
105 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
112 * Adjust the time obtained from the CMOS to be UTC time instead of
115 * This is ugly, but preferable to the alternatives. Otherwise we
116 * would either need to write a program to do it in /etc/rc (and risk
117 * confusion if the program gets run more than once; it would also be
118 * hard to make the program warp the clock precisely n hours) or
119 * compile in the timezone information into the kernel. Bad, bad....
123 * The best thing to do is to keep the CMOS clock in universal time (UTC)
124 * as real UNIX machines always do it. This avoids all headaches about
125 * daylight saving times and warping kernel clocks.
127 static inline void warp_clock(void)
129 write_seqlock_irq(&xtime_lock
);
130 wall_to_monotonic
.tv_sec
-= sys_tz
.tz_minuteswest
* 60;
131 xtime
.tv_sec
+= sys_tz
.tz_minuteswest
* 60;
132 update_xtime_cache(0);
133 write_sequnlock_irq(&xtime_lock
);
138 * In case for some reason the CMOS clock has not already been running
139 * in UTC, but in some local time: The first time we set the timezone,
140 * we will warp the clock so that it is ticking UTC time instead of
141 * local time. Presumably, if someone is setting the timezone then we
142 * are running in an environment where the programs understand about
143 * timezones. This should be done at boot time in the /etc/rc script,
144 * as soon as possible, so that the clock can be set right. Otherwise,
145 * various programs will get confused when the clock gets warped.
148 int do_sys_settimeofday(struct timespec
*tv
, struct timezone
*tz
)
150 static int firsttime
= 1;
153 if (tv
&& !timespec_valid(tv
))
156 error
= security_settime(tv
, tz
);
161 /* SMP safe, global irq locking makes it work. */
163 update_vsyscall_tz();
172 /* SMP safe, again the code in arch/foo/time.c should
173 * globally block out interrupts when it runs.
175 return do_settimeofday(tv
);
180 asmlinkage
long sys_settimeofday(struct timeval __user
*tv
,
181 struct timezone __user
*tz
)
183 struct timeval user_tv
;
184 struct timespec new_ts
;
185 struct timezone new_tz
;
188 if (copy_from_user(&user_tv
, tv
, sizeof(*tv
)))
190 new_ts
.tv_sec
= user_tv
.tv_sec
;
191 new_ts
.tv_nsec
= user_tv
.tv_usec
* NSEC_PER_USEC
;
194 if (copy_from_user(&new_tz
, tz
, sizeof(*tz
)))
198 return do_sys_settimeofday(tv
? &new_ts
: NULL
, tz
? &new_tz
: NULL
);
201 asmlinkage
long sys_adjtimex(struct timex __user
*txc_p
)
203 struct timex txc
; /* Local copy of parameter */
206 /* Copy the user data space into the kernel copy
207 * structure. But bear in mind that the structures
210 if(copy_from_user(&txc
, txc_p
, sizeof(struct timex
)))
212 ret
= do_adjtimex(&txc
);
213 return copy_to_user(txc_p
, &txc
, sizeof(struct timex
)) ? -EFAULT
: ret
;
217 * current_fs_time - Return FS time
220 * Return the current time truncated to the time granularity supported by
223 struct timespec
current_fs_time(struct super_block
*sb
)
225 struct timespec now
= current_kernel_time();
226 return timespec_trunc(now
, sb
->s_time_gran
);
228 EXPORT_SYMBOL(current_fs_time
);
231 * Convert jiffies to milliseconds and back.
233 * Avoid unnecessary multiplications/divisions in the
234 * two most common HZ cases:
236 unsigned int inline jiffies_to_msecs(const unsigned long j
)
238 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
239 return (MSEC_PER_SEC
/ HZ
) * j
;
240 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
241 return (j
+ (HZ
/ MSEC_PER_SEC
) - 1)/(HZ
/ MSEC_PER_SEC
);
243 return (j
* MSEC_PER_SEC
) / HZ
;
246 EXPORT_SYMBOL(jiffies_to_msecs
);
248 unsigned int inline jiffies_to_usecs(const unsigned long j
)
250 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
251 return (USEC_PER_SEC
/ HZ
) * j
;
252 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
253 return (j
+ (HZ
/ USEC_PER_SEC
) - 1)/(HZ
/ USEC_PER_SEC
);
255 return (j
* USEC_PER_SEC
) / HZ
;
258 EXPORT_SYMBOL(jiffies_to_usecs
);
261 * timespec_trunc - Truncate timespec to a granularity
263 * @gran: Granularity in ns.
265 * Truncate a timespec to a granularity. gran must be smaller than a second.
266 * Always rounds down.
268 * This function should be only used for timestamps returned by
269 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
270 * it doesn't handle the better resolution of the later.
272 struct timespec
timespec_trunc(struct timespec t
, unsigned gran
)
275 * Division is pretty slow so avoid it for common cases.
276 * Currently current_kernel_time() never returns better than
277 * jiffies resolution. Exploit that.
279 if (gran
<= jiffies_to_usecs(1) * 1000) {
281 } else if (gran
== 1000000000) {
284 t
.tv_nsec
-= t
.tv_nsec
% gran
;
288 EXPORT_SYMBOL(timespec_trunc
);
290 #ifndef CONFIG_GENERIC_TIME
292 * Simulate gettimeofday using do_gettimeofday which only allows a timeval
293 * and therefore only yields usec accuracy
295 void getnstimeofday(struct timespec
*tv
)
300 tv
->tv_sec
= x
.tv_sec
;
301 tv
->tv_nsec
= x
.tv_usec
* NSEC_PER_USEC
;
303 EXPORT_SYMBOL_GPL(getnstimeofday
);
306 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
307 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
308 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
310 * [For the Julian calendar (which was used in Russia before 1917,
311 * Britain & colonies before 1752, anywhere else before 1582,
312 * and is still in use by some communities) leave out the
313 * -year/100+year/400 terms, and add 10.]
315 * This algorithm was first published by Gauss (I think).
317 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
318 * machines were long is 32-bit! (However, as time_t is signed, we
319 * will already get problems at other places on 2038-01-19 03:14:08)
322 mktime(const unsigned int year0
, const unsigned int mon0
,
323 const unsigned int day
, const unsigned int hour
,
324 const unsigned int min
, const unsigned int sec
)
326 unsigned int mon
= mon0
, year
= year0
;
328 /* 1..12 -> 11,12,1..10 */
329 if (0 >= (int) (mon
-= 2)) {
330 mon
+= 12; /* Puts Feb last since it has leap day */
334 return ((((unsigned long)
335 (year
/4 - year
/100 + year
/400 + 367*mon
/12 + day
) +
337 )*24 + hour
/* now have hours */
338 )*60 + min
/* now have minutes */
339 )*60 + sec
; /* finally seconds */
342 EXPORT_SYMBOL(mktime
);
345 * set_normalized_timespec - set timespec sec and nsec parts and normalize
347 * @ts: pointer to timespec variable to be set
348 * @sec: seconds to set
349 * @nsec: nanoseconds to set
351 * Set seconds and nanoseconds field of a timespec variable and
352 * normalize to the timespec storage format
354 * Note: The tv_nsec part is always in the range of
355 * 0 <= tv_nsec < NSEC_PER_SEC
356 * For negative values only the tv_sec field is negative !
358 void set_normalized_timespec(struct timespec
*ts
, time_t sec
, long nsec
)
360 while (nsec
>= NSEC_PER_SEC
) {
361 nsec
-= NSEC_PER_SEC
;
365 nsec
+= NSEC_PER_SEC
;
373 * ns_to_timespec - Convert nanoseconds to timespec
374 * @nsec: the nanoseconds value to be converted
376 * Returns the timespec representation of the nsec parameter.
378 struct timespec
ns_to_timespec(const s64 nsec
)
383 return (struct timespec
) {0, 0};
385 ts
.tv_sec
= div_long_long_rem_signed(nsec
, NSEC_PER_SEC
, &ts
.tv_nsec
);
386 if (unlikely(nsec
< 0))
387 set_normalized_timespec(&ts
, ts
.tv_sec
, ts
.tv_nsec
);
391 EXPORT_SYMBOL(ns_to_timespec
);
394 * ns_to_timeval - Convert nanoseconds to timeval
395 * @nsec: the nanoseconds value to be converted
397 * Returns the timeval representation of the nsec parameter.
399 struct timeval
ns_to_timeval(const s64 nsec
)
401 struct timespec ts
= ns_to_timespec(nsec
);
404 tv
.tv_sec
= ts
.tv_sec
;
405 tv
.tv_usec
= (suseconds_t
) ts
.tv_nsec
/ 1000;
409 EXPORT_SYMBOL(ns_to_timeval
);
412 * When we convert to jiffies then we interpret incoming values
415 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
417 * - 'too large' values [that would result in larger than
418 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
420 * - all other values are converted to jiffies by either multiplying
421 * the input value by a factor or dividing it with a factor
423 * We must also be careful about 32-bit overflows.
425 unsigned long msecs_to_jiffies(const unsigned int m
)
428 * Negative value, means infinite timeout:
431 return MAX_JIFFY_OFFSET
;
433 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
435 * HZ is equal to or smaller than 1000, and 1000 is a nice
436 * round multiple of HZ, divide with the factor between them,
439 return (m
+ (MSEC_PER_SEC
/ HZ
) - 1) / (MSEC_PER_SEC
/ HZ
);
440 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
442 * HZ is larger than 1000, and HZ is a nice round multiple of
443 * 1000 - simply multiply with the factor between them.
445 * But first make sure the multiplication result cannot
448 if (m
> jiffies_to_msecs(MAX_JIFFY_OFFSET
))
449 return MAX_JIFFY_OFFSET
;
451 return m
* (HZ
/ MSEC_PER_SEC
);
454 * Generic case - multiply, round and divide. But first
455 * check that if we are doing a net multiplication, that
456 * we wouldnt overflow:
458 if (HZ
> MSEC_PER_SEC
&& m
> jiffies_to_msecs(MAX_JIFFY_OFFSET
))
459 return MAX_JIFFY_OFFSET
;
461 return (m
* HZ
+ MSEC_PER_SEC
- 1) / MSEC_PER_SEC
;
464 EXPORT_SYMBOL(msecs_to_jiffies
);
466 unsigned long usecs_to_jiffies(const unsigned int u
)
468 if (u
> jiffies_to_usecs(MAX_JIFFY_OFFSET
))
469 return MAX_JIFFY_OFFSET
;
470 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
471 return (u
+ (USEC_PER_SEC
/ HZ
) - 1) / (USEC_PER_SEC
/ HZ
);
472 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
473 return u
* (HZ
/ USEC_PER_SEC
);
475 return (u
* HZ
+ USEC_PER_SEC
- 1) / USEC_PER_SEC
;
478 EXPORT_SYMBOL(usecs_to_jiffies
);
481 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
482 * that a remainder subtract here would not do the right thing as the
483 * resolution values don't fall on second boundries. I.e. the line:
484 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
486 * Rather, we just shift the bits off the right.
488 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
489 * value to a scaled second value.
492 timespec_to_jiffies(const struct timespec
*value
)
494 unsigned long sec
= value
->tv_sec
;
495 long nsec
= value
->tv_nsec
+ TICK_NSEC
- 1;
497 if (sec
>= MAX_SEC_IN_JIFFIES
){
498 sec
= MAX_SEC_IN_JIFFIES
;
501 return (((u64
)sec
* SEC_CONVERSION
) +
502 (((u64
)nsec
* NSEC_CONVERSION
) >>
503 (NSEC_JIFFIE_SC
- SEC_JIFFIE_SC
))) >> SEC_JIFFIE_SC
;
506 EXPORT_SYMBOL(timespec_to_jiffies
);
509 jiffies_to_timespec(const unsigned long jiffies
, struct timespec
*value
)
512 * Convert jiffies to nanoseconds and separate with
515 u64 nsec
= (u64
)jiffies
* TICK_NSEC
;
516 value
->tv_sec
= div_long_long_rem(nsec
, NSEC_PER_SEC
, &value
->tv_nsec
);
518 EXPORT_SYMBOL(jiffies_to_timespec
);
520 /* Same for "timeval"
522 * Well, almost. The problem here is that the real system resolution is
523 * in nanoseconds and the value being converted is in micro seconds.
524 * Also for some machines (those that use HZ = 1024, in-particular),
525 * there is a LARGE error in the tick size in microseconds.
527 * The solution we use is to do the rounding AFTER we convert the
528 * microsecond part. Thus the USEC_ROUND, the bits to be shifted off.
529 * Instruction wise, this should cost only an additional add with carry
530 * instruction above the way it was done above.
533 timeval_to_jiffies(const struct timeval
*value
)
535 unsigned long sec
= value
->tv_sec
;
536 long usec
= value
->tv_usec
;
538 if (sec
>= MAX_SEC_IN_JIFFIES
){
539 sec
= MAX_SEC_IN_JIFFIES
;
542 return (((u64
)sec
* SEC_CONVERSION
) +
543 (((u64
)usec
* USEC_CONVERSION
+ USEC_ROUND
) >>
544 (USEC_JIFFIE_SC
- SEC_JIFFIE_SC
))) >> SEC_JIFFIE_SC
;
546 EXPORT_SYMBOL(timeval_to_jiffies
);
548 void jiffies_to_timeval(const unsigned long jiffies
, struct timeval
*value
)
551 * Convert jiffies to nanoseconds and separate with
554 u64 nsec
= (u64
)jiffies
* TICK_NSEC
;
557 value
->tv_sec
= div_long_long_rem(nsec
, NSEC_PER_SEC
, &tv_usec
);
558 tv_usec
/= NSEC_PER_USEC
;
559 value
->tv_usec
= tv_usec
;
561 EXPORT_SYMBOL(jiffies_to_timeval
);
564 * Convert jiffies/jiffies_64 to clock_t and back.
566 clock_t jiffies_to_clock_t(long x
)
568 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
570 return x
* (USER_HZ
/ HZ
);
572 return x
/ (HZ
/ USER_HZ
);
575 u64 tmp
= (u64
)x
* TICK_NSEC
;
576 do_div(tmp
, (NSEC_PER_SEC
/ USER_HZ
));
580 EXPORT_SYMBOL(jiffies_to_clock_t
);
582 unsigned long clock_t_to_jiffies(unsigned long x
)
584 #if (HZ % USER_HZ)==0
585 if (x
>= ~0UL / (HZ
/ USER_HZ
))
587 return x
* (HZ
/ USER_HZ
);
591 /* Don't worry about loss of precision here .. */
592 if (x
>= ~0UL / HZ
* USER_HZ
)
595 /* .. but do try to contain it here */
597 do_div(jif
, USER_HZ
);
601 EXPORT_SYMBOL(clock_t_to_jiffies
);
603 u64
jiffies_64_to_clock_t(u64 x
)
605 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
610 do_div(x
, HZ
/ USER_HZ
);
616 * There are better ways that don't overflow early,
617 * but even this doesn't overflow in hundreds of years
621 do_div(x
, (NSEC_PER_SEC
/ USER_HZ
));
625 EXPORT_SYMBOL(jiffies_64_to_clock_t
);
627 u64
nsec_to_clock_t(u64 x
)
629 #if (NSEC_PER_SEC % USER_HZ) == 0
630 do_div(x
, (NSEC_PER_SEC
/ USER_HZ
));
631 #elif (USER_HZ % 512) == 0
633 do_div(x
, (NSEC_PER_SEC
/ 512));
636 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
637 * overflow after 64.99 years.
638 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
641 do_div(x
, (unsigned long)((9ull * NSEC_PER_SEC
+ (USER_HZ
/2)) /
647 #if (BITS_PER_LONG < 64)
648 u64
get_jiffies_64(void)
654 seq
= read_seqbegin(&xtime_lock
);
656 } while (read_seqretry(&xtime_lock
, seq
));
659 EXPORT_SYMBOL(get_jiffies_64
);
662 EXPORT_SYMBOL(jiffies
);
This page took 0.044379 seconds and 5 git commands to generate.