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/core.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/export.h>
31 #include <linux/kernel.h>
32 #include <linux/timex.h>
33 #include <linux/capability.h>
34 #include <linux/timekeeper_internal.h>
35 #include <linux/errno.h>
36 #include <linux/syscalls.h>
37 #include <linux/security.h>
39 #include <linux/math64.h>
40 #include <linux/ptrace.h>
42 #include <linux/uaccess.h>
43 #include <linux/compat.h>
44 #include <asm/unistd.h>
46 #include <generated/timeconst.h>
47 #include "timekeeping.h"
50 * The timezone where the local system is located. Used as a default by some
51 * programs who obtain this value by using gettimeofday.
53 struct timezone sys_tz;
55 EXPORT_SYMBOL(sys_tz);
57 #ifdef __ARCH_WANT_SYS_TIME
60 * sys_time() can be implemented in user-level using
61 * sys_gettimeofday(). Is this for backwards compatibility? If so,
62 * why not move it into the appropriate arch directory (for those
63 * architectures that need it).
65 SYSCALL_DEFINE1(time, time_t __user *, tloc)
67 time_t i = get_seconds();
73 force_successful_syscall_return();
78 * sys_stime() can be implemented in user-level using
79 * sys_settimeofday(). Is this for backwards compatibility? If so,
80 * why not move it into the appropriate arch directory (for those
81 * architectures that need it).
84 SYSCALL_DEFINE1(stime, time_t __user *, tptr)
89 if (get_user(tv.tv_sec, tptr))
94 err = security_settime(&tv, NULL);
102 #endif /* __ARCH_WANT_SYS_TIME */
105 #ifdef __ARCH_WANT_COMPAT_SYS_TIME
107 /* compat_time_t is a 32 bit "long" and needs to get converted. */
108 COMPAT_SYSCALL_DEFINE1(time, compat_time_t __user *, tloc)
113 do_gettimeofday(&tv);
117 if (put_user(i,tloc))
120 force_successful_syscall_return();
124 COMPAT_SYSCALL_DEFINE1(stime, compat_time_t __user *, tptr)
129 if (get_user(tv.tv_sec, tptr))
134 err = security_settime(&tv, NULL);
138 do_settimeofday(&tv);
142 #endif /* __ARCH_WANT_COMPAT_SYS_TIME */
145 SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv,
146 struct timezone __user *, tz)
148 if (likely(tv != NULL)) {
150 do_gettimeofday(&ktv);
151 if (copy_to_user(tv, &ktv, sizeof(ktv)))
154 if (unlikely(tz != NULL)) {
155 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
162 * Indicates if there is an offset between the system clock and the hardware
163 * clock/persistent clock/rtc.
165 int persistent_clock_is_local;
168 * Adjust the time obtained from the CMOS to be UTC time instead of
171 * This is ugly, but preferable to the alternatives. Otherwise we
172 * would either need to write a program to do it in /etc/rc (and risk
173 * confusion if the program gets run more than once; it would also be
174 * hard to make the program warp the clock precisely n hours) or
175 * compile in the timezone information into the kernel. Bad, bad....
179 * The best thing to do is to keep the CMOS clock in universal time (UTC)
180 * as real UNIX machines always do it. This avoids all headaches about
181 * daylight saving times and warping kernel clocks.
183 static inline void warp_clock(void)
185 if (sys_tz.tz_minuteswest != 0) {
186 struct timespec adjust;
188 persistent_clock_is_local = 1;
189 adjust.tv_sec = sys_tz.tz_minuteswest * 60;
191 timekeeping_inject_offset(&adjust);
196 * In case for some reason the CMOS clock has not already been running
197 * in UTC, but in some local time: The first time we set the timezone,
198 * we will warp the clock so that it is ticking UTC time instead of
199 * local time. Presumably, if someone is setting the timezone then we
200 * are running in an environment where the programs understand about
201 * timezones. This should be done at boot time in the /etc/rc script,
202 * as soon as possible, so that the clock can be set right. Otherwise,
203 * various programs will get confused when the clock gets warped.
206 int do_sys_settimeofday64(const struct timespec64 *tv, const struct timezone *tz)
208 static int firsttime = 1;
211 if (tv && !timespec64_valid(tv))
214 error = security_settime64(tv, tz);
219 /* Verify we're witin the +-15 hrs range */
220 if (tz->tz_minuteswest > 15*60 || tz->tz_minuteswest < -15*60)
224 update_vsyscall_tz();
232 return do_settimeofday64(tv);
236 SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
237 struct timezone __user *, tz)
239 struct timespec64 new_ts;
240 struct timeval user_tv;
241 struct timezone new_tz;
244 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
247 if (!timeval_valid(&user_tv))
250 new_ts.tv_sec = user_tv.tv_sec;
251 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
254 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
258 return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
262 COMPAT_SYSCALL_DEFINE2(gettimeofday, struct compat_timeval __user *, tv,
263 struct timezone __user *, tz)
268 do_gettimeofday(&ktv);
269 if (compat_put_timeval(&ktv, tv))
273 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
280 COMPAT_SYSCALL_DEFINE2(settimeofday, struct compat_timeval __user *, tv,
281 struct timezone __user *, tz)
283 struct timespec64 new_ts;
284 struct timeval user_tv;
285 struct timezone new_tz;
288 if (compat_get_timeval(&user_tv, tv))
290 new_ts.tv_sec = user_tv.tv_sec;
291 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
294 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
298 return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
302 SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
304 struct timex txc; /* Local copy of parameter */
307 /* Copy the user data space into the kernel copy
308 * structure. But bear in mind that the structures
311 if (copy_from_user(&txc, txc_p, sizeof(struct timex)))
313 ret = do_adjtimex(&txc);
314 return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
319 COMPAT_SYSCALL_DEFINE1(adjtimex, struct compat_timex __user *, utp)
324 err = compat_get_timex(&txc, utp);
328 ret = do_adjtimex(&txc);
330 err = compat_put_timex(utp, &txc);
339 * Convert jiffies to milliseconds and back.
341 * Avoid unnecessary multiplications/divisions in the
342 * two most common HZ cases:
344 unsigned int jiffies_to_msecs(const unsigned long j)
346 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
347 return (MSEC_PER_SEC / HZ) * j;
348 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
349 return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
351 # if BITS_PER_LONG == 32
352 return (HZ_TO_MSEC_MUL32 * j + (1ULL << HZ_TO_MSEC_SHR32) - 1) >>
355 return DIV_ROUND_UP(j * HZ_TO_MSEC_NUM, HZ_TO_MSEC_DEN);
359 EXPORT_SYMBOL(jiffies_to_msecs);
361 unsigned int jiffies_to_usecs(const unsigned long j)
364 * Hz usually doesn't go much further MSEC_PER_SEC.
365 * jiffies_to_usecs() and usecs_to_jiffies() depend on that.
367 BUILD_BUG_ON(HZ > USEC_PER_SEC);
369 #if !(USEC_PER_SEC % HZ)
370 return (USEC_PER_SEC / HZ) * j;
372 # if BITS_PER_LONG == 32
373 return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
375 return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
379 EXPORT_SYMBOL(jiffies_to_usecs);
382 * timespec_trunc - Truncate timespec to a granularity
384 * @gran: Granularity in ns.
386 * Truncate a timespec to a granularity. Always rounds down. gran must
387 * not be 0 nor greater than a second (NSEC_PER_SEC, or 10^9 ns).
389 struct timespec timespec_trunc(struct timespec t, unsigned gran)
391 /* Avoid division in the common cases 1 ns and 1 s. */
394 } else if (gran == NSEC_PER_SEC) {
396 } else if (gran > 1 && gran < NSEC_PER_SEC) {
397 t.tv_nsec -= t.tv_nsec % gran;
399 WARN(1, "illegal file time granularity: %u", gran);
403 EXPORT_SYMBOL(timespec_trunc);
406 * mktime64 - Converts date to seconds.
407 * Converts Gregorian date to seconds since 1970-01-01 00:00:00.
408 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
409 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
411 * [For the Julian calendar (which was used in Russia before 1917,
412 * Britain & colonies before 1752, anywhere else before 1582,
413 * and is still in use by some communities) leave out the
414 * -year/100+year/400 terms, and add 10.]
416 * This algorithm was first published by Gauss (I think).
418 * A leap second can be indicated by calling this function with sec as
419 * 60 (allowable under ISO 8601). The leap second is treated the same
420 * as the following second since they don't exist in UNIX time.
422 * An encoding of midnight at the end of the day as 24:00:00 - ie. midnight
423 * tomorrow - (allowable under ISO 8601) is supported.
425 time64_t mktime64(const unsigned int year0, const unsigned int mon0,
426 const unsigned int day, const unsigned int hour,
427 const unsigned int min, const unsigned int sec)
429 unsigned int mon = mon0, year = year0;
431 /* 1..12 -> 11,12,1..10 */
432 if (0 >= (int) (mon -= 2)) {
433 mon += 12; /* Puts Feb last since it has leap day */
438 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
440 )*24 + hour /* now have hours - midnight tomorrow handled here */
441 )*60 + min /* now have minutes */
442 )*60 + sec; /* finally seconds */
444 EXPORT_SYMBOL(mktime64);
447 * set_normalized_timespec - set timespec sec and nsec parts and normalize
449 * @ts: pointer to timespec variable to be set
450 * @sec: seconds to set
451 * @nsec: nanoseconds to set
453 * Set seconds and nanoseconds field of a timespec variable and
454 * normalize to the timespec storage format
456 * Note: The tv_nsec part is always in the range of
457 * 0 <= tv_nsec < NSEC_PER_SEC
458 * For negative values only the tv_sec field is negative !
460 void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec)
462 while (nsec >= NSEC_PER_SEC) {
464 * The following asm() prevents the compiler from
465 * optimising this loop into a modulo operation. See
466 * also __iter_div_u64_rem() in include/linux/time.h
468 asm("" : "+rm"(nsec));
469 nsec -= NSEC_PER_SEC;
473 asm("" : "+rm"(nsec));
474 nsec += NSEC_PER_SEC;
480 EXPORT_SYMBOL(set_normalized_timespec);
483 * ns_to_timespec - Convert nanoseconds to timespec
484 * @nsec: the nanoseconds value to be converted
486 * Returns the timespec representation of the nsec parameter.
488 struct timespec ns_to_timespec(const s64 nsec)
494 return (struct timespec) {0, 0};
496 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
497 if (unlikely(rem < 0)) {
505 EXPORT_SYMBOL(ns_to_timespec);
508 * ns_to_timeval - Convert nanoseconds to timeval
509 * @nsec: the nanoseconds value to be converted
511 * Returns the timeval representation of the nsec parameter.
513 struct timeval ns_to_timeval(const s64 nsec)
515 struct timespec ts = ns_to_timespec(nsec);
518 tv.tv_sec = ts.tv_sec;
519 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
523 EXPORT_SYMBOL(ns_to_timeval);
525 #if BITS_PER_LONG == 32
527 * set_normalized_timespec - set timespec sec and nsec parts and normalize
529 * @ts: pointer to timespec variable to be set
530 * @sec: seconds to set
531 * @nsec: nanoseconds to set
533 * Set seconds and nanoseconds field of a timespec variable and
534 * normalize to the timespec storage format
536 * Note: The tv_nsec part is always in the range of
537 * 0 <= tv_nsec < NSEC_PER_SEC
538 * For negative values only the tv_sec field is negative !
540 void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec)
542 while (nsec >= NSEC_PER_SEC) {
544 * The following asm() prevents the compiler from
545 * optimising this loop into a modulo operation. See
546 * also __iter_div_u64_rem() in include/linux/time.h
548 asm("" : "+rm"(nsec));
549 nsec -= NSEC_PER_SEC;
553 asm("" : "+rm"(nsec));
554 nsec += NSEC_PER_SEC;
560 EXPORT_SYMBOL(set_normalized_timespec64);
563 * ns_to_timespec64 - Convert nanoseconds to timespec64
564 * @nsec: the nanoseconds value to be converted
566 * Returns the timespec64 representation of the nsec parameter.
568 struct timespec64 ns_to_timespec64(const s64 nsec)
570 struct timespec64 ts;
574 return (struct timespec64) {0, 0};
576 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
577 if (unlikely(rem < 0)) {
585 EXPORT_SYMBOL(ns_to_timespec64);
588 * msecs_to_jiffies: - convert milliseconds to jiffies
589 * @m: time in milliseconds
591 * conversion is done as follows:
593 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
595 * - 'too large' values [that would result in larger than
596 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
598 * - all other values are converted to jiffies by either multiplying
599 * the input value by a factor or dividing it with a factor and
600 * handling any 32-bit overflows.
601 * for the details see __msecs_to_jiffies()
603 * msecs_to_jiffies() checks for the passed in value being a constant
604 * via __builtin_constant_p() allowing gcc to eliminate most of the
605 * code, __msecs_to_jiffies() is called if the value passed does not
606 * allow constant folding and the actual conversion must be done at
608 * the _msecs_to_jiffies helpers are the HZ dependent conversion
609 * routines found in include/linux/jiffies.h
611 unsigned long __msecs_to_jiffies(const unsigned int m)
614 * Negative value, means infinite timeout:
617 return MAX_JIFFY_OFFSET;
618 return _msecs_to_jiffies(m);
620 EXPORT_SYMBOL(__msecs_to_jiffies);
622 unsigned long __usecs_to_jiffies(const unsigned int u)
624 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
625 return MAX_JIFFY_OFFSET;
626 return _usecs_to_jiffies(u);
628 EXPORT_SYMBOL(__usecs_to_jiffies);
631 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
632 * that a remainder subtract here would not do the right thing as the
633 * resolution values don't fall on second boundries. I.e. the line:
634 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
635 * Note that due to the small error in the multiplier here, this
636 * rounding is incorrect for sufficiently large values of tv_nsec, but
637 * well formed timespecs should have tv_nsec < NSEC_PER_SEC, so we're
640 * Rather, we just shift the bits off the right.
642 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
643 * value to a scaled second value.
646 __timespec64_to_jiffies(u64 sec, long nsec)
648 nsec = nsec + TICK_NSEC - 1;
650 if (sec >= MAX_SEC_IN_JIFFIES){
651 sec = MAX_SEC_IN_JIFFIES;
654 return ((sec * SEC_CONVERSION) +
655 (((u64)nsec * NSEC_CONVERSION) >>
656 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
661 __timespec_to_jiffies(unsigned long sec, long nsec)
663 return __timespec64_to_jiffies((u64)sec, nsec);
667 timespec64_to_jiffies(const struct timespec64 *value)
669 return __timespec64_to_jiffies(value->tv_sec, value->tv_nsec);
671 EXPORT_SYMBOL(timespec64_to_jiffies);
674 jiffies_to_timespec64(const unsigned long jiffies, struct timespec64 *value)
677 * Convert jiffies to nanoseconds and separate with
681 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
683 value->tv_nsec = rem;
685 EXPORT_SYMBOL(jiffies_to_timespec64);
688 * We could use a similar algorithm to timespec_to_jiffies (with a
689 * different multiplier for usec instead of nsec). But this has a
690 * problem with rounding: we can't exactly add TICK_NSEC - 1 to the
691 * usec value, since it's not necessarily integral.
693 * We could instead round in the intermediate scaled representation
694 * (i.e. in units of 1/2^(large scale) jiffies) but that's also
695 * perilous: the scaling introduces a small positive error, which
696 * combined with a division-rounding-upward (i.e. adding 2^(scale) - 1
697 * units to the intermediate before shifting) leads to accidental
698 * overflow and overestimates.
700 * At the cost of one additional multiplication by a constant, just
701 * use the timespec implementation.
704 timeval_to_jiffies(const struct timeval *value)
706 return __timespec_to_jiffies(value->tv_sec,
707 value->tv_usec * NSEC_PER_USEC);
709 EXPORT_SYMBOL(timeval_to_jiffies);
711 void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
714 * Convert jiffies to nanoseconds and separate with
719 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
721 value->tv_usec = rem / NSEC_PER_USEC;
723 EXPORT_SYMBOL(jiffies_to_timeval);
726 * Convert jiffies/jiffies_64 to clock_t and back.
728 clock_t jiffies_to_clock_t(unsigned long x)
730 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
732 return x * (USER_HZ / HZ);
734 return x / (HZ / USER_HZ);
737 return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
740 EXPORT_SYMBOL(jiffies_to_clock_t);
742 unsigned long clock_t_to_jiffies(unsigned long x)
744 #if (HZ % USER_HZ)==0
745 if (x >= ~0UL / (HZ / USER_HZ))
747 return x * (HZ / USER_HZ);
749 /* Don't worry about loss of precision here .. */
750 if (x >= ~0UL / HZ * USER_HZ)
753 /* .. but do try to contain it here */
754 return div_u64((u64)x * HZ, USER_HZ);
757 EXPORT_SYMBOL(clock_t_to_jiffies);
759 u64 jiffies_64_to_clock_t(u64 x)
761 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
763 x = div_u64(x * USER_HZ, HZ);
765 x = div_u64(x, HZ / USER_HZ);
771 * There are better ways that don't overflow early,
772 * but even this doesn't overflow in hundreds of years
775 x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
779 EXPORT_SYMBOL(jiffies_64_to_clock_t);
781 u64 nsec_to_clock_t(u64 x)
783 #if (NSEC_PER_SEC % USER_HZ) == 0
784 return div_u64(x, NSEC_PER_SEC / USER_HZ);
785 #elif (USER_HZ % 512) == 0
786 return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
789 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
790 * overflow after 64.99 years.
791 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
793 return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
797 u64 jiffies64_to_nsecs(u64 j)
799 #if !(NSEC_PER_SEC % HZ)
800 return (NSEC_PER_SEC / HZ) * j;
802 return div_u64(j * HZ_TO_NSEC_NUM, HZ_TO_NSEC_DEN);
805 EXPORT_SYMBOL(jiffies64_to_nsecs);
808 * nsecs_to_jiffies64 - Convert nsecs in u64 to jiffies64
812 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
813 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
814 * for scheduler, not for use in device drivers to calculate timeout value.
817 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
818 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
820 u64 nsecs_to_jiffies64(u64 n)
822 #if (NSEC_PER_SEC % HZ) == 0
823 /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */
824 return div_u64(n, NSEC_PER_SEC / HZ);
825 #elif (HZ % 512) == 0
826 /* overflow after 292 years if HZ = 1024 */
827 return div_u64(n * HZ / 512, NSEC_PER_SEC / 512);
830 * Generic case - optimized for cases where HZ is a multiple of 3.
831 * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc.
833 return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ);
836 EXPORT_SYMBOL(nsecs_to_jiffies64);
839 * nsecs_to_jiffies - Convert nsecs in u64 to jiffies
843 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
844 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
845 * for scheduler, not for use in device drivers to calculate timeout value.
848 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
849 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
851 unsigned long nsecs_to_jiffies(u64 n)
853 return (unsigned long)nsecs_to_jiffies64(n);
855 EXPORT_SYMBOL_GPL(nsecs_to_jiffies);
858 * Add two timespec values and do a safety check for overflow.
859 * It's assumed that both values are valid (>= 0)
861 struct timespec timespec_add_safe(const struct timespec lhs,
862 const struct timespec rhs)
866 set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec,
867 lhs.tv_nsec + rhs.tv_nsec);
869 if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)
870 res.tv_sec = TIME_T_MAX;
876 * Add two timespec64 values and do a safety check for overflow.
877 * It's assumed that both values are valid (>= 0).
878 * And, each timespec64 is in normalized form.
880 struct timespec64 timespec64_add_safe(const struct timespec64 lhs,
881 const struct timespec64 rhs)
883 struct timespec64 res;
885 set_normalized_timespec64(&res, (timeu64_t) lhs.tv_sec + rhs.tv_sec,
886 lhs.tv_nsec + rhs.tv_nsec);
888 if (unlikely(res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)) {
889 res.tv_sec = TIME64_MAX;
896 int get_timespec64(struct timespec64 *ts,
897 const struct timespec __user *uts)
902 ret = copy_from_user(&kts, uts, sizeof(kts));
906 ts->tv_sec = kts.tv_sec;
907 ts->tv_nsec = kts.tv_nsec;
911 EXPORT_SYMBOL_GPL(get_timespec64);
913 int put_timespec64(const struct timespec64 *ts,
914 struct timespec __user *uts)
916 struct timespec kts = {
917 .tv_sec = ts->tv_sec,
918 .tv_nsec = ts->tv_nsec
920 return copy_to_user(uts, &kts, sizeof(kts)) ? -EFAULT : 0;
922 EXPORT_SYMBOL_GPL(put_timespec64);
924 int get_itimerspec64(struct itimerspec64 *it,
925 const struct itimerspec __user *uit)
929 ret = get_timespec64(&it->it_interval, &uit->it_interval);
933 ret = get_timespec64(&it->it_value, &uit->it_value);
937 EXPORT_SYMBOL_GPL(get_itimerspec64);
939 int put_itimerspec64(const struct itimerspec64 *it,
940 struct itimerspec __user *uit)
944 ret = put_timespec64(&it->it_interval, &uit->it_interval);
948 ret = put_timespec64(&it->it_value, &uit->it_value);
952 EXPORT_SYMBOL_GPL(put_itimerspec64);