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/timex.h>
32 #include <linux/capability.h>
33 #include <linux/timekeeper_internal.h>
34 #include <linux/errno.h>
35 #include <linux/syscalls.h>
36 #include <linux/security.h>
38 #include <linux/math64.h>
39 #include <linux/ptrace.h>
41 #include <linux/uaccess.h>
42 #include <linux/compat.h>
43 #include <asm/unistd.h>
45 #include <generated/timeconst.h>
46 #include "timekeeping.h"
49 * The timezone where the local system is located. Used as a default by some
50 * programs who obtain this value by using gettimeofday.
52 struct timezone sys_tz;
54 EXPORT_SYMBOL(sys_tz);
56 #ifdef __ARCH_WANT_SYS_TIME
59 * sys_time() can be implemented in user-level using
60 * sys_gettimeofday(). Is this for backwards compatibility? If so,
61 * why not move it into the appropriate arch directory (for those
62 * architectures that need it).
64 SYSCALL_DEFINE1(time, time_t __user *, tloc)
66 time_t i = get_seconds();
72 force_successful_syscall_return();
77 * sys_stime() can be implemented in user-level using
78 * sys_settimeofday(). Is this for backwards compatibility? If so,
79 * why not move it into the appropriate arch directory (for those
80 * architectures that need it).
83 SYSCALL_DEFINE1(stime, time_t __user *, tptr)
88 if (get_user(tv.tv_sec, tptr))
93 err = security_settime(&tv, NULL);
101 #endif /* __ARCH_WANT_SYS_TIME */
104 #ifdef __ARCH_WANT_COMPAT_SYS_TIME
106 /* compat_time_t is a 32 bit "long" and needs to get converted. */
107 COMPAT_SYSCALL_DEFINE1(time, compat_time_t __user *, tloc)
112 do_gettimeofday(&tv);
116 if (put_user(i,tloc))
119 force_successful_syscall_return();
123 COMPAT_SYSCALL_DEFINE1(stime, compat_time_t __user *, tptr)
128 if (get_user(tv.tv_sec, tptr))
133 err = security_settime(&tv, NULL);
137 do_settimeofday(&tv);
141 #endif /* __ARCH_WANT_COMPAT_SYS_TIME */
144 SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv,
145 struct timezone __user *, tz)
147 if (likely(tv != NULL)) {
149 do_gettimeofday(&ktv);
150 if (copy_to_user(tv, &ktv, sizeof(ktv)))
153 if (unlikely(tz != NULL)) {
154 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
161 * Indicates if there is an offset between the system clock and the hardware
162 * clock/persistent clock/rtc.
164 int persistent_clock_is_local;
167 * Adjust the time obtained from the CMOS to be UTC time instead of
170 * This is ugly, but preferable to the alternatives. Otherwise we
171 * would either need to write a program to do it in /etc/rc (and risk
172 * confusion if the program gets run more than once; it would also be
173 * hard to make the program warp the clock precisely n hours) or
174 * compile in the timezone information into the kernel. Bad, bad....
178 * The best thing to do is to keep the CMOS clock in universal time (UTC)
179 * as real UNIX machines always do it. This avoids all headaches about
180 * daylight saving times and warping kernel clocks.
182 static inline void warp_clock(void)
184 if (sys_tz.tz_minuteswest != 0) {
185 struct timespec adjust;
187 persistent_clock_is_local = 1;
188 adjust.tv_sec = sys_tz.tz_minuteswest * 60;
190 timekeeping_inject_offset(&adjust);
195 * In case for some reason the CMOS clock has not already been running
196 * in UTC, but in some local time: The first time we set the timezone,
197 * we will warp the clock so that it is ticking UTC time instead of
198 * local time. Presumably, if someone is setting the timezone then we
199 * are running in an environment where the programs understand about
200 * timezones. This should be done at boot time in the /etc/rc script,
201 * as soon as possible, so that the clock can be set right. Otherwise,
202 * various programs will get confused when the clock gets warped.
205 int do_sys_settimeofday64(const struct timespec64 *tv, const struct timezone *tz)
207 static int firsttime = 1;
210 if (tv && !timespec64_valid(tv))
213 error = security_settime64(tv, tz);
218 /* Verify we're witin the +-15 hrs range */
219 if (tz->tz_minuteswest > 15*60 || tz->tz_minuteswest < -15*60)
223 update_vsyscall_tz();
231 return do_settimeofday64(tv);
235 SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
236 struct timezone __user *, tz)
238 struct timespec64 new_ts;
239 struct timeval user_tv;
240 struct timezone new_tz;
243 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
246 if (!timeval_valid(&user_tv))
249 new_ts.tv_sec = user_tv.tv_sec;
250 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
253 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
257 return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
261 COMPAT_SYSCALL_DEFINE2(gettimeofday, struct compat_timeval __user *, tv,
262 struct timezone __user *, tz)
267 do_gettimeofday(&ktv);
268 if (compat_put_timeval(&ktv, tv))
272 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
279 COMPAT_SYSCALL_DEFINE2(settimeofday, struct compat_timeval __user *, tv,
280 struct timezone __user *, tz)
282 struct timespec64 new_ts;
283 struct timeval user_tv;
284 struct timezone new_tz;
287 if (compat_get_timeval(&user_tv, tv))
289 new_ts.tv_sec = user_tv.tv_sec;
290 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
293 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
297 return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
301 SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
303 struct timex txc; /* Local copy of parameter */
306 /* Copy the user data space into the kernel copy
307 * structure. But bear in mind that the structures
310 if (copy_from_user(&txc, txc_p, sizeof(struct timex)))
312 ret = do_adjtimex(&txc);
313 return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
318 COMPAT_SYSCALL_DEFINE1(adjtimex, struct compat_timex __user *, utp)
323 err = compat_get_timex(&txc, utp);
327 ret = do_adjtimex(&txc);
329 err = compat_put_timex(utp, &txc);
338 * Convert jiffies to milliseconds and back.
340 * Avoid unnecessary multiplications/divisions in the
341 * two most common HZ cases:
343 unsigned int jiffies_to_msecs(const unsigned long j)
345 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
346 return (MSEC_PER_SEC / HZ) * j;
347 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
348 return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
350 # if BITS_PER_LONG == 32
351 return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32;
353 return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN;
357 EXPORT_SYMBOL(jiffies_to_msecs);
359 unsigned int jiffies_to_usecs(const unsigned long j)
362 * Hz usually doesn't go much further MSEC_PER_SEC.
363 * jiffies_to_usecs() and usecs_to_jiffies() depend on that.
365 BUILD_BUG_ON(HZ > USEC_PER_SEC);
367 #if !(USEC_PER_SEC % HZ)
368 return (USEC_PER_SEC / HZ) * j;
370 # if BITS_PER_LONG == 32
371 return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
373 return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
377 EXPORT_SYMBOL(jiffies_to_usecs);
380 * timespec_trunc - Truncate timespec to a granularity
382 * @gran: Granularity in ns.
384 * Truncate a timespec to a granularity. Always rounds down. gran must
385 * not be 0 nor greater than a second (NSEC_PER_SEC, or 10^9 ns).
387 struct timespec timespec_trunc(struct timespec t, unsigned gran)
389 /* Avoid division in the common cases 1 ns and 1 s. */
392 } else if (gran == NSEC_PER_SEC) {
394 } else if (gran > 1 && gran < NSEC_PER_SEC) {
395 t.tv_nsec -= t.tv_nsec % gran;
397 WARN(1, "illegal file time granularity: %u", gran);
401 EXPORT_SYMBOL(timespec_trunc);
404 * mktime64 - Converts date to seconds.
405 * Converts Gregorian date to seconds since 1970-01-01 00:00:00.
406 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
407 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
409 * [For the Julian calendar (which was used in Russia before 1917,
410 * Britain & colonies before 1752, anywhere else before 1582,
411 * and is still in use by some communities) leave out the
412 * -year/100+year/400 terms, and add 10.]
414 * This algorithm was first published by Gauss (I think).
416 * A leap second can be indicated by calling this function with sec as
417 * 60 (allowable under ISO 8601). The leap second is treated the same
418 * as the following second since they don't exist in UNIX time.
420 * An encoding of midnight at the end of the day as 24:00:00 - ie. midnight
421 * tomorrow - (allowable under ISO 8601) is supported.
423 time64_t mktime64(const unsigned int year0, const unsigned int mon0,
424 const unsigned int day, const unsigned int hour,
425 const unsigned int min, const unsigned int sec)
427 unsigned int mon = mon0, year = year0;
429 /* 1..12 -> 11,12,1..10 */
430 if (0 >= (int) (mon -= 2)) {
431 mon += 12; /* Puts Feb last since it has leap day */
436 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
438 )*24 + hour /* now have hours - midnight tomorrow handled here */
439 )*60 + min /* now have minutes */
440 )*60 + sec; /* finally seconds */
442 EXPORT_SYMBOL(mktime64);
445 * set_normalized_timespec - set timespec sec and nsec parts and normalize
447 * @ts: pointer to timespec variable to be set
448 * @sec: seconds to set
449 * @nsec: nanoseconds to set
451 * Set seconds and nanoseconds field of a timespec variable and
452 * normalize to the timespec storage format
454 * Note: The tv_nsec part is always in the range of
455 * 0 <= tv_nsec < NSEC_PER_SEC
456 * For negative values only the tv_sec field is negative !
458 void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec)
460 while (nsec >= NSEC_PER_SEC) {
462 * The following asm() prevents the compiler from
463 * optimising this loop into a modulo operation. See
464 * also __iter_div_u64_rem() in include/linux/time.h
466 asm("" : "+rm"(nsec));
467 nsec -= NSEC_PER_SEC;
471 asm("" : "+rm"(nsec));
472 nsec += NSEC_PER_SEC;
478 EXPORT_SYMBOL(set_normalized_timespec);
481 * ns_to_timespec - Convert nanoseconds to timespec
482 * @nsec: the nanoseconds value to be converted
484 * Returns the timespec representation of the nsec parameter.
486 struct timespec ns_to_timespec(const s64 nsec)
492 return (struct timespec) {0, 0};
494 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
495 if (unlikely(rem < 0)) {
503 EXPORT_SYMBOL(ns_to_timespec);
506 * ns_to_timeval - Convert nanoseconds to timeval
507 * @nsec: the nanoseconds value to be converted
509 * Returns the timeval representation of the nsec parameter.
511 struct timeval ns_to_timeval(const s64 nsec)
513 struct timespec ts = ns_to_timespec(nsec);
516 tv.tv_sec = ts.tv_sec;
517 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
521 EXPORT_SYMBOL(ns_to_timeval);
523 #if BITS_PER_LONG == 32
525 * set_normalized_timespec - set timespec sec and nsec parts and normalize
527 * @ts: pointer to timespec variable to be set
528 * @sec: seconds to set
529 * @nsec: nanoseconds to set
531 * Set seconds and nanoseconds field of a timespec variable and
532 * normalize to the timespec storage format
534 * Note: The tv_nsec part is always in the range of
535 * 0 <= tv_nsec < NSEC_PER_SEC
536 * For negative values only the tv_sec field is negative !
538 void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec)
540 while (nsec >= NSEC_PER_SEC) {
542 * The following asm() prevents the compiler from
543 * optimising this loop into a modulo operation. See
544 * also __iter_div_u64_rem() in include/linux/time.h
546 asm("" : "+rm"(nsec));
547 nsec -= NSEC_PER_SEC;
551 asm("" : "+rm"(nsec));
552 nsec += NSEC_PER_SEC;
558 EXPORT_SYMBOL(set_normalized_timespec64);
561 * ns_to_timespec64 - Convert nanoseconds to timespec64
562 * @nsec: the nanoseconds value to be converted
564 * Returns the timespec64 representation of the nsec parameter.
566 struct timespec64 ns_to_timespec64(const s64 nsec)
568 struct timespec64 ts;
572 return (struct timespec64) {0, 0};
574 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
575 if (unlikely(rem < 0)) {
583 EXPORT_SYMBOL(ns_to_timespec64);
586 * msecs_to_jiffies: - convert milliseconds to jiffies
587 * @m: time in milliseconds
589 * conversion is done as follows:
591 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
593 * - 'too large' values [that would result in larger than
594 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
596 * - all other values are converted to jiffies by either multiplying
597 * the input value by a factor or dividing it with a factor and
598 * handling any 32-bit overflows.
599 * for the details see __msecs_to_jiffies()
601 * msecs_to_jiffies() checks for the passed in value being a constant
602 * via __builtin_constant_p() allowing gcc to eliminate most of the
603 * code, __msecs_to_jiffies() is called if the value passed does not
604 * allow constant folding and the actual conversion must be done at
606 * the _msecs_to_jiffies helpers are the HZ dependent conversion
607 * routines found in include/linux/jiffies.h
609 unsigned long __msecs_to_jiffies(const unsigned int m)
612 * Negative value, means infinite timeout:
615 return MAX_JIFFY_OFFSET;
616 return _msecs_to_jiffies(m);
618 EXPORT_SYMBOL(__msecs_to_jiffies);
620 unsigned long __usecs_to_jiffies(const unsigned int u)
622 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
623 return MAX_JIFFY_OFFSET;
624 return _usecs_to_jiffies(u);
626 EXPORT_SYMBOL(__usecs_to_jiffies);
629 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
630 * that a remainder subtract here would not do the right thing as the
631 * resolution values don't fall on second boundries. I.e. the line:
632 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
633 * Note that due to the small error in the multiplier here, this
634 * rounding is incorrect for sufficiently large values of tv_nsec, but
635 * well formed timespecs should have tv_nsec < NSEC_PER_SEC, so we're
638 * Rather, we just shift the bits off the right.
640 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
641 * value to a scaled second value.
644 __timespec64_to_jiffies(u64 sec, long nsec)
646 nsec = nsec + TICK_NSEC - 1;
648 if (sec >= MAX_SEC_IN_JIFFIES){
649 sec = MAX_SEC_IN_JIFFIES;
652 return ((sec * SEC_CONVERSION) +
653 (((u64)nsec * NSEC_CONVERSION) >>
654 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
659 __timespec_to_jiffies(unsigned long sec, long nsec)
661 return __timespec64_to_jiffies((u64)sec, nsec);
665 timespec64_to_jiffies(const struct timespec64 *value)
667 return __timespec64_to_jiffies(value->tv_sec, value->tv_nsec);
669 EXPORT_SYMBOL(timespec64_to_jiffies);
672 jiffies_to_timespec64(const unsigned long jiffies, struct timespec64 *value)
675 * Convert jiffies to nanoseconds and separate with
679 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
681 value->tv_nsec = rem;
683 EXPORT_SYMBOL(jiffies_to_timespec64);
686 * We could use a similar algorithm to timespec_to_jiffies (with a
687 * different multiplier for usec instead of nsec). But this has a
688 * problem with rounding: we can't exactly add TICK_NSEC - 1 to the
689 * usec value, since it's not necessarily integral.
691 * We could instead round in the intermediate scaled representation
692 * (i.e. in units of 1/2^(large scale) jiffies) but that's also
693 * perilous: the scaling introduces a small positive error, which
694 * combined with a division-rounding-upward (i.e. adding 2^(scale) - 1
695 * units to the intermediate before shifting) leads to accidental
696 * overflow and overestimates.
698 * At the cost of one additional multiplication by a constant, just
699 * use the timespec implementation.
702 timeval_to_jiffies(const struct timeval *value)
704 return __timespec_to_jiffies(value->tv_sec,
705 value->tv_usec * NSEC_PER_USEC);
707 EXPORT_SYMBOL(timeval_to_jiffies);
709 void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
712 * Convert jiffies to nanoseconds and separate with
717 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
719 value->tv_usec = rem / NSEC_PER_USEC;
721 EXPORT_SYMBOL(jiffies_to_timeval);
724 * Convert jiffies/jiffies_64 to clock_t and back.
726 clock_t jiffies_to_clock_t(unsigned long x)
728 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
730 return x * (USER_HZ / HZ);
732 return x / (HZ / USER_HZ);
735 return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
738 EXPORT_SYMBOL(jiffies_to_clock_t);
740 unsigned long clock_t_to_jiffies(unsigned long x)
742 #if (HZ % USER_HZ)==0
743 if (x >= ~0UL / (HZ / USER_HZ))
745 return x * (HZ / USER_HZ);
747 /* Don't worry about loss of precision here .. */
748 if (x >= ~0UL / HZ * USER_HZ)
751 /* .. but do try to contain it here */
752 return div_u64((u64)x * HZ, USER_HZ);
755 EXPORT_SYMBOL(clock_t_to_jiffies);
757 u64 jiffies_64_to_clock_t(u64 x)
759 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
761 x = div_u64(x * USER_HZ, HZ);
763 x = div_u64(x, HZ / USER_HZ);
769 * There are better ways that don't overflow early,
770 * but even this doesn't overflow in hundreds of years
773 x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
777 EXPORT_SYMBOL(jiffies_64_to_clock_t);
779 u64 nsec_to_clock_t(u64 x)
781 #if (NSEC_PER_SEC % USER_HZ) == 0
782 return div_u64(x, NSEC_PER_SEC / USER_HZ);
783 #elif (USER_HZ % 512) == 0
784 return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
787 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
788 * overflow after 64.99 years.
789 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
791 return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
795 u64 jiffies64_to_nsecs(u64 j)
797 #if !(NSEC_PER_SEC % HZ)
798 return (NSEC_PER_SEC / HZ) * j;
800 return div_u64(j * HZ_TO_NSEC_NUM, HZ_TO_NSEC_DEN);
803 EXPORT_SYMBOL(jiffies64_to_nsecs);
806 * nsecs_to_jiffies64 - Convert nsecs in u64 to jiffies64
810 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
811 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
812 * for scheduler, not for use in device drivers to calculate timeout value.
815 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
816 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
818 u64 nsecs_to_jiffies64(u64 n)
820 #if (NSEC_PER_SEC % HZ) == 0
821 /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */
822 return div_u64(n, NSEC_PER_SEC / HZ);
823 #elif (HZ % 512) == 0
824 /* overflow after 292 years if HZ = 1024 */
825 return div_u64(n * HZ / 512, NSEC_PER_SEC / 512);
828 * Generic case - optimized for cases where HZ is a multiple of 3.
829 * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc.
831 return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ);
834 EXPORT_SYMBOL(nsecs_to_jiffies64);
837 * nsecs_to_jiffies - Convert nsecs in u64 to jiffies
841 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
842 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
843 * for scheduler, not for use in device drivers to calculate timeout value.
846 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
847 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
849 unsigned long nsecs_to_jiffies(u64 n)
851 return (unsigned long)nsecs_to_jiffies64(n);
853 EXPORT_SYMBOL_GPL(nsecs_to_jiffies);
856 * Add two timespec values and do a safety check for overflow.
857 * It's assumed that both values are valid (>= 0)
859 struct timespec timespec_add_safe(const struct timespec lhs,
860 const struct timespec rhs)
864 set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec,
865 lhs.tv_nsec + rhs.tv_nsec);
867 if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)
868 res.tv_sec = TIME_T_MAX;
874 * Add two timespec64 values and do a safety check for overflow.
875 * It's assumed that both values are valid (>= 0).
876 * And, each timespec64 is in normalized form.
878 struct timespec64 timespec64_add_safe(const struct timespec64 lhs,
879 const struct timespec64 rhs)
881 struct timespec64 res;
883 set_normalized_timespec64(&res, (timeu64_t) lhs.tv_sec + rhs.tv_sec,
884 lhs.tv_nsec + rhs.tv_nsec);
886 if (unlikely(res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)) {
887 res.tv_sec = TIME64_MAX;
894 int get_timespec64(struct timespec64 *ts,
895 const struct timespec __user *uts)
900 ret = copy_from_user(&kts, uts, sizeof(kts));
904 ts->tv_sec = kts.tv_sec;
905 ts->tv_nsec = kts.tv_nsec;
909 EXPORT_SYMBOL_GPL(get_timespec64);
911 int put_timespec64(const struct timespec64 *ts,
912 struct timespec __user *uts)
914 struct timespec kts = {
915 .tv_sec = ts->tv_sec,
916 .tv_nsec = ts->tv_nsec
918 return copy_to_user(uts, &kts, sizeof(kts)) ? -EFAULT : 0;
920 EXPORT_SYMBOL_GPL(put_timespec64);
922 int get_itimerspec64(struct itimerspec64 *it,
923 const struct itimerspec __user *uit)
927 ret = get_timespec64(&it->it_interval, &uit->it_interval);
931 ret = get_timespec64(&it->it_value, &uit->it_value);
935 EXPORT_SYMBOL_GPL(get_itimerspec64);
937 int put_itimerspec64(const struct itimerspec64 *it,
938 struct itimerspec __user *uit)
942 ret = put_timespec64(&it->it_interval, &uit->it_interval);
946 ret = put_timespec64(&it->it_value, &uit->it_value);
950 EXPORT_SYMBOL_GPL(put_itimerspec64);