1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 1991, 1992 Linus Torvalds
5 * This file contains the interface functions for the various time related
6 * system calls: time, stime, gettimeofday, settimeofday, adjtime
8 * Modification history:
10 * 1993-09-02 Philip Gladstone
11 * Created file with time related functions from sched/core.c and adjtimex()
12 * 1993-10-08 Torsten Duwe
13 * adjtime interface update and CMOS clock write code
14 * 1995-08-13 Torsten Duwe
15 * kernel PLL updated to 1994-12-13 specs (rfc-1589)
16 * 1999-01-16 Ulrich Windl
17 * Introduced error checking for many cases in adjtimex().
18 * Updated NTP code according to technical memorandum Jan '96
19 * "A Kernel Model for Precision Timekeeping" by Dave Mills
20 * Allow time_constant larger than MAXTC(6) for NTP v4 (MAXTC == 10)
21 * (Even though the technical memorandum forbids it)
22 * 2004-07-14 Christoph Lameter
23 * Added getnstimeofday to allow the posix timer functions to return
24 * with nanosecond accuracy
27 #include <linux/export.h>
28 #include <linux/kernel.h>
29 #include <linux/timex.h>
30 #include <linux/capability.h>
31 #include <linux/timekeeper_internal.h>
32 #include <linux/errno.h>
33 #include <linux/syscalls.h>
34 #include <linux/security.h>
36 #include <linux/math64.h>
37 #include <linux/ptrace.h>
39 #include <linux/uaccess.h>
40 #include <linux/compat.h>
41 #include <asm/unistd.h>
43 #include <generated/timeconst.h>
44 #include "timekeeping.h"
47 * The timezone where the local system is located. Used as a default by some
48 * programs who obtain this value by using gettimeofday.
50 struct timezone sys_tz
;
52 EXPORT_SYMBOL(sys_tz
);
54 #ifdef __ARCH_WANT_SYS_TIME
57 * sys_time() can be implemented in user-level using
58 * sys_gettimeofday(). Is this for backwards compatibility? If so,
59 * why not move it into the appropriate arch directory (for those
60 * architectures that need it).
62 SYSCALL_DEFINE1(time
, time_t __user
*, tloc
)
64 time_t i
= (time_t)ktime_get_real_seconds();
70 force_successful_syscall_return();
75 * sys_stime() can be implemented in user-level using
76 * sys_settimeofday(). Is this for backwards compatibility? If so,
77 * why not move it into the appropriate arch directory (for those
78 * architectures that need it).
81 SYSCALL_DEFINE1(stime
, time_t __user
*, tptr
)
86 if (get_user(tv
.tv_sec
, tptr
))
91 err
= security_settime64(&tv
, NULL
);
95 do_settimeofday64(&tv
);
99 #endif /* __ARCH_WANT_SYS_TIME */
102 #ifdef __ARCH_WANT_COMPAT_SYS_TIME
104 /* old_time32_t is a 32 bit "long" and needs to get converted. */
105 COMPAT_SYSCALL_DEFINE1(time
, old_time32_t __user
*, tloc
)
109 i
= (old_time32_t
)ktime_get_real_seconds();
112 if (put_user(i
,tloc
))
115 force_successful_syscall_return();
119 COMPAT_SYSCALL_DEFINE1(stime
, old_time32_t __user
*, tptr
)
121 struct timespec64 tv
;
124 if (get_user(tv
.tv_sec
, tptr
))
129 err
= security_settime64(&tv
, NULL
);
133 do_settimeofday64(&tv
);
137 #endif /* __ARCH_WANT_COMPAT_SYS_TIME */
140 SYSCALL_DEFINE2(gettimeofday
, struct timeval __user
*, tv
,
141 struct timezone __user
*, tz
)
143 if (likely(tv
!= NULL
)) {
144 struct timespec64 ts
;
146 ktime_get_real_ts64(&ts
);
147 if (put_user(ts
.tv_sec
, &tv
->tv_sec
) ||
148 put_user(ts
.tv_nsec
/ 1000, &tv
->tv_usec
))
151 if (unlikely(tz
!= NULL
)) {
152 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
159 * In case for some reason the CMOS clock has not already been running
160 * in UTC, but in some local time: The first time we set the timezone,
161 * we will warp the clock so that it is ticking UTC time instead of
162 * local time. Presumably, if someone is setting the timezone then we
163 * are running in an environment where the programs understand about
164 * timezones. This should be done at boot time in the /etc/rc script,
165 * as soon as possible, so that the clock can be set right. Otherwise,
166 * various programs will get confused when the clock gets warped.
169 int do_sys_settimeofday64(const struct timespec64
*tv
, const struct timezone
*tz
)
171 static int firsttime
= 1;
174 if (tv
&& !timespec64_valid(tv
))
177 error
= security_settime64(tv
, tz
);
182 /* Verify we're witin the +-15 hrs range */
183 if (tz
->tz_minuteswest
> 15*60 || tz
->tz_minuteswest
< -15*60)
187 update_vsyscall_tz();
191 timekeeping_warp_clock();
195 return do_settimeofday64(tv
);
199 SYSCALL_DEFINE2(settimeofday
, struct timeval __user
*, tv
,
200 struct timezone __user
*, tz
)
202 struct timespec64 new_ts
;
203 struct timeval user_tv
;
204 struct timezone new_tz
;
207 if (copy_from_user(&user_tv
, tv
, sizeof(*tv
)))
210 if (!timeval_valid(&user_tv
))
213 new_ts
.tv_sec
= user_tv
.tv_sec
;
214 new_ts
.tv_nsec
= user_tv
.tv_usec
* NSEC_PER_USEC
;
217 if (copy_from_user(&new_tz
, tz
, sizeof(*tz
)))
221 return do_sys_settimeofday64(tv
? &new_ts
: NULL
, tz
? &new_tz
: NULL
);
225 COMPAT_SYSCALL_DEFINE2(gettimeofday
, struct old_timeval32 __user
*, tv
,
226 struct timezone __user
*, tz
)
229 struct timespec64 ts
;
231 ktime_get_real_ts64(&ts
);
232 if (put_user(ts
.tv_sec
, &tv
->tv_sec
) ||
233 put_user(ts
.tv_nsec
/ 1000, &tv
->tv_usec
))
237 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
244 COMPAT_SYSCALL_DEFINE2(settimeofday
, struct old_timeval32 __user
*, tv
,
245 struct timezone __user
*, tz
)
247 struct timespec64 new_ts
;
248 struct timeval user_tv
;
249 struct timezone new_tz
;
252 if (compat_get_timeval(&user_tv
, tv
))
254 new_ts
.tv_sec
= user_tv
.tv_sec
;
255 new_ts
.tv_nsec
= user_tv
.tv_usec
* NSEC_PER_USEC
;
258 if (copy_from_user(&new_tz
, tz
, sizeof(*tz
)))
262 return do_sys_settimeofday64(tv
? &new_ts
: NULL
, tz
? &new_tz
: NULL
);
266 SYSCALL_DEFINE1(adjtimex
, struct timex __user
*, txc_p
)
268 struct timex txc
; /* Local copy of parameter */
271 /* Copy the user data space into the kernel copy
272 * structure. But bear in mind that the structures
275 if (copy_from_user(&txc
, txc_p
, sizeof(struct timex
)))
277 ret
= do_adjtimex(&txc
);
278 return copy_to_user(txc_p
, &txc
, sizeof(struct timex
)) ? -EFAULT
: ret
;
283 COMPAT_SYSCALL_DEFINE1(adjtimex
, struct compat_timex __user
*, utp
)
288 err
= compat_get_timex(&txc
, utp
);
292 ret
= do_adjtimex(&txc
);
294 err
= compat_put_timex(utp
, &txc
);
303 * Convert jiffies to milliseconds and back.
305 * Avoid unnecessary multiplications/divisions in the
306 * two most common HZ cases:
308 unsigned int jiffies_to_msecs(const unsigned long j
)
310 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
311 return (MSEC_PER_SEC
/ HZ
) * j
;
312 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
313 return (j
+ (HZ
/ MSEC_PER_SEC
) - 1)/(HZ
/ MSEC_PER_SEC
);
315 # if BITS_PER_LONG == 32
316 return (HZ_TO_MSEC_MUL32
* j
+ (1ULL << HZ_TO_MSEC_SHR32
) - 1) >>
319 return DIV_ROUND_UP(j
* HZ_TO_MSEC_NUM
, HZ_TO_MSEC_DEN
);
323 EXPORT_SYMBOL(jiffies_to_msecs
);
325 unsigned int jiffies_to_usecs(const unsigned long j
)
328 * Hz usually doesn't go much further MSEC_PER_SEC.
329 * jiffies_to_usecs() and usecs_to_jiffies() depend on that.
331 BUILD_BUG_ON(HZ
> USEC_PER_SEC
);
333 #if !(USEC_PER_SEC % HZ)
334 return (USEC_PER_SEC
/ HZ
) * j
;
336 # if BITS_PER_LONG == 32
337 return (HZ_TO_USEC_MUL32
* j
) >> HZ_TO_USEC_SHR32
;
339 return (j
* HZ_TO_USEC_NUM
) / HZ_TO_USEC_DEN
;
343 EXPORT_SYMBOL(jiffies_to_usecs
);
346 * mktime64 - Converts date to seconds.
347 * Converts Gregorian date to seconds since 1970-01-01 00:00:00.
348 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
349 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
351 * [For the Julian calendar (which was used in Russia before 1917,
352 * Britain & colonies before 1752, anywhere else before 1582,
353 * and is still in use by some communities) leave out the
354 * -year/100+year/400 terms, and add 10.]
356 * This algorithm was first published by Gauss (I think).
358 * A leap second can be indicated by calling this function with sec as
359 * 60 (allowable under ISO 8601). The leap second is treated the same
360 * as the following second since they don't exist in UNIX time.
362 * An encoding of midnight at the end of the day as 24:00:00 - ie. midnight
363 * tomorrow - (allowable under ISO 8601) is supported.
365 time64_t
mktime64(const unsigned int year0
, const unsigned int mon0
,
366 const unsigned int day
, const unsigned int hour
,
367 const unsigned int min
, const unsigned int sec
)
369 unsigned int mon
= mon0
, year
= year0
;
371 /* 1..12 -> 11,12,1..10 */
372 if (0 >= (int) (mon
-= 2)) {
373 mon
+= 12; /* Puts Feb last since it has leap day */
378 (year
/4 - year
/100 + year
/400 + 367*mon
/12 + day
) +
380 )*24 + hour
/* now have hours - midnight tomorrow handled here */
381 )*60 + min
/* now have minutes */
382 )*60 + sec
; /* finally seconds */
384 EXPORT_SYMBOL(mktime64
);
387 * ns_to_timespec - Convert nanoseconds to timespec
388 * @nsec: the nanoseconds value to be converted
390 * Returns the timespec representation of the nsec parameter.
392 struct timespec
ns_to_timespec(const s64 nsec
)
398 return (struct timespec
) {0, 0};
400 ts
.tv_sec
= div_s64_rem(nsec
, NSEC_PER_SEC
, &rem
);
401 if (unlikely(rem
< 0)) {
409 EXPORT_SYMBOL(ns_to_timespec
);
412 * ns_to_timeval - Convert nanoseconds to timeval
413 * @nsec: the nanoseconds value to be converted
415 * Returns the timeval representation of the nsec parameter.
417 struct timeval
ns_to_timeval(const s64 nsec
)
419 struct timespec ts
= ns_to_timespec(nsec
);
422 tv
.tv_sec
= ts
.tv_sec
;
423 tv
.tv_usec
= (suseconds_t
) ts
.tv_nsec
/ 1000;
427 EXPORT_SYMBOL(ns_to_timeval
);
429 struct __kernel_old_timeval
ns_to_kernel_old_timeval(const s64 nsec
)
431 struct timespec64 ts
= ns_to_timespec64(nsec
);
432 struct __kernel_old_timeval tv
;
434 tv
.tv_sec
= ts
.tv_sec
;
435 tv
.tv_usec
= (suseconds_t
)ts
.tv_nsec
/ 1000;
439 EXPORT_SYMBOL(ns_to_kernel_old_timeval
);
442 * set_normalized_timespec - set timespec sec and nsec parts and normalize
444 * @ts: pointer to timespec variable to be set
445 * @sec: seconds to set
446 * @nsec: nanoseconds to set
448 * Set seconds and nanoseconds field of a timespec variable and
449 * normalize to the timespec storage format
451 * Note: The tv_nsec part is always in the range of
452 * 0 <= tv_nsec < NSEC_PER_SEC
453 * For negative values only the tv_sec field is negative !
455 void set_normalized_timespec64(struct timespec64
*ts
, time64_t sec
, s64 nsec
)
457 while (nsec
>= NSEC_PER_SEC
) {
459 * The following asm() prevents the compiler from
460 * optimising this loop into a modulo operation. See
461 * also __iter_div_u64_rem() in include/linux/time.h
463 asm("" : "+rm"(nsec
));
464 nsec
-= NSEC_PER_SEC
;
468 asm("" : "+rm"(nsec
));
469 nsec
+= NSEC_PER_SEC
;
475 EXPORT_SYMBOL(set_normalized_timespec64
);
478 * ns_to_timespec64 - Convert nanoseconds to timespec64
479 * @nsec: the nanoseconds value to be converted
481 * Returns the timespec64 representation of the nsec parameter.
483 struct timespec64
ns_to_timespec64(const s64 nsec
)
485 struct timespec64 ts
;
489 return (struct timespec64
) {0, 0};
491 ts
.tv_sec
= div_s64_rem(nsec
, NSEC_PER_SEC
, &rem
);
492 if (unlikely(rem
< 0)) {
500 EXPORT_SYMBOL(ns_to_timespec64
);
503 * msecs_to_jiffies: - convert milliseconds to jiffies
504 * @m: time in milliseconds
506 * conversion is done as follows:
508 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
510 * - 'too large' values [that would result in larger than
511 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
513 * - all other values are converted to jiffies by either multiplying
514 * the input value by a factor or dividing it with a factor and
515 * handling any 32-bit overflows.
516 * for the details see __msecs_to_jiffies()
518 * msecs_to_jiffies() checks for the passed in value being a constant
519 * via __builtin_constant_p() allowing gcc to eliminate most of the
520 * code, __msecs_to_jiffies() is called if the value passed does not
521 * allow constant folding and the actual conversion must be done at
523 * the _msecs_to_jiffies helpers are the HZ dependent conversion
524 * routines found in include/linux/jiffies.h
526 unsigned long __msecs_to_jiffies(const unsigned int m
)
529 * Negative value, means infinite timeout:
532 return MAX_JIFFY_OFFSET
;
533 return _msecs_to_jiffies(m
);
535 EXPORT_SYMBOL(__msecs_to_jiffies
);
537 unsigned long __usecs_to_jiffies(const unsigned int u
)
539 if (u
> jiffies_to_usecs(MAX_JIFFY_OFFSET
))
540 return MAX_JIFFY_OFFSET
;
541 return _usecs_to_jiffies(u
);
543 EXPORT_SYMBOL(__usecs_to_jiffies
);
546 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
547 * that a remainder subtract here would not do the right thing as the
548 * resolution values don't fall on second boundries. I.e. the line:
549 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
550 * Note that due to the small error in the multiplier here, this
551 * rounding is incorrect for sufficiently large values of tv_nsec, but
552 * well formed timespecs should have tv_nsec < NSEC_PER_SEC, so we're
555 * Rather, we just shift the bits off the right.
557 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
558 * value to a scaled second value.
561 __timespec64_to_jiffies(u64 sec
, long nsec
)
563 nsec
= nsec
+ TICK_NSEC
- 1;
565 if (sec
>= MAX_SEC_IN_JIFFIES
){
566 sec
= MAX_SEC_IN_JIFFIES
;
569 return ((sec
* SEC_CONVERSION
) +
570 (((u64
)nsec
* NSEC_CONVERSION
) >>
571 (NSEC_JIFFIE_SC
- SEC_JIFFIE_SC
))) >> SEC_JIFFIE_SC
;
576 __timespec_to_jiffies(unsigned long sec
, long nsec
)
578 return __timespec64_to_jiffies((u64
)sec
, nsec
);
582 timespec64_to_jiffies(const struct timespec64
*value
)
584 return __timespec64_to_jiffies(value
->tv_sec
, value
->tv_nsec
);
586 EXPORT_SYMBOL(timespec64_to_jiffies
);
589 jiffies_to_timespec64(const unsigned long jiffies
, struct timespec64
*value
)
592 * Convert jiffies to nanoseconds and separate with
596 value
->tv_sec
= div_u64_rem((u64
)jiffies
* TICK_NSEC
,
598 value
->tv_nsec
= rem
;
600 EXPORT_SYMBOL(jiffies_to_timespec64
);
603 * We could use a similar algorithm to timespec_to_jiffies (with a
604 * different multiplier for usec instead of nsec). But this has a
605 * problem with rounding: we can't exactly add TICK_NSEC - 1 to the
606 * usec value, since it's not necessarily integral.
608 * We could instead round in the intermediate scaled representation
609 * (i.e. in units of 1/2^(large scale) jiffies) but that's also
610 * perilous: the scaling introduces a small positive error, which
611 * combined with a division-rounding-upward (i.e. adding 2^(scale) - 1
612 * units to the intermediate before shifting) leads to accidental
613 * overflow and overestimates.
615 * At the cost of one additional multiplication by a constant, just
616 * use the timespec implementation.
619 timeval_to_jiffies(const struct timeval
*value
)
621 return __timespec_to_jiffies(value
->tv_sec
,
622 value
->tv_usec
* NSEC_PER_USEC
);
624 EXPORT_SYMBOL(timeval_to_jiffies
);
626 void jiffies_to_timeval(const unsigned long jiffies
, struct timeval
*value
)
629 * Convert jiffies to nanoseconds and separate with
634 value
->tv_sec
= div_u64_rem((u64
)jiffies
* TICK_NSEC
,
636 value
->tv_usec
= rem
/ NSEC_PER_USEC
;
638 EXPORT_SYMBOL(jiffies_to_timeval
);
641 * Convert jiffies/jiffies_64 to clock_t and back.
643 clock_t jiffies_to_clock_t(unsigned long x
)
645 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
647 return x
* (USER_HZ
/ HZ
);
649 return x
/ (HZ
/ USER_HZ
);
652 return div_u64((u64
)x
* TICK_NSEC
, NSEC_PER_SEC
/ USER_HZ
);
655 EXPORT_SYMBOL(jiffies_to_clock_t
);
657 unsigned long clock_t_to_jiffies(unsigned long x
)
659 #if (HZ % USER_HZ)==0
660 if (x
>= ~0UL / (HZ
/ USER_HZ
))
662 return x
* (HZ
/ USER_HZ
);
664 /* Don't worry about loss of precision here .. */
665 if (x
>= ~0UL / HZ
* USER_HZ
)
668 /* .. but do try to contain it here */
669 return div_u64((u64
)x
* HZ
, USER_HZ
);
672 EXPORT_SYMBOL(clock_t_to_jiffies
);
674 u64
jiffies_64_to_clock_t(u64 x
)
676 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
678 x
= div_u64(x
* USER_HZ
, HZ
);
680 x
= div_u64(x
, HZ
/ USER_HZ
);
686 * There are better ways that don't overflow early,
687 * but even this doesn't overflow in hundreds of years
690 x
= div_u64(x
* TICK_NSEC
, (NSEC_PER_SEC
/ USER_HZ
));
694 EXPORT_SYMBOL(jiffies_64_to_clock_t
);
696 u64
nsec_to_clock_t(u64 x
)
698 #if (NSEC_PER_SEC % USER_HZ) == 0
699 return div_u64(x
, NSEC_PER_SEC
/ USER_HZ
);
700 #elif (USER_HZ % 512) == 0
701 return div_u64(x
* USER_HZ
/ 512, NSEC_PER_SEC
/ 512);
704 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
705 * overflow after 64.99 years.
706 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
708 return div_u64(x
* 9, (9ull * NSEC_PER_SEC
+ (USER_HZ
/ 2)) / USER_HZ
);
712 u64
jiffies64_to_nsecs(u64 j
)
714 #if !(NSEC_PER_SEC % HZ)
715 return (NSEC_PER_SEC
/ HZ
) * j
;
717 return div_u64(j
* HZ_TO_NSEC_NUM
, HZ_TO_NSEC_DEN
);
720 EXPORT_SYMBOL(jiffies64_to_nsecs
);
723 * nsecs_to_jiffies64 - Convert nsecs in u64 to jiffies64
727 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
728 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
729 * for scheduler, not for use in device drivers to calculate timeout value.
732 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
733 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
735 u64
nsecs_to_jiffies64(u64 n
)
737 #if (NSEC_PER_SEC % HZ) == 0
738 /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */
739 return div_u64(n
, NSEC_PER_SEC
/ HZ
);
740 #elif (HZ % 512) == 0
741 /* overflow after 292 years if HZ = 1024 */
742 return div_u64(n
* HZ
/ 512, NSEC_PER_SEC
/ 512);
745 * Generic case - optimized for cases where HZ is a multiple of 3.
746 * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc.
748 return div_u64(n
* 9, (9ull * NSEC_PER_SEC
+ HZ
/ 2) / HZ
);
751 EXPORT_SYMBOL(nsecs_to_jiffies64
);
754 * nsecs_to_jiffies - Convert nsecs in u64 to jiffies
758 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
759 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
760 * for scheduler, not for use in device drivers to calculate timeout value.
763 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
764 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
766 unsigned long nsecs_to_jiffies(u64 n
)
768 return (unsigned long)nsecs_to_jiffies64(n
);
770 EXPORT_SYMBOL_GPL(nsecs_to_jiffies
);
773 * Add two timespec64 values and do a safety check for overflow.
774 * It's assumed that both values are valid (>= 0).
775 * And, each timespec64 is in normalized form.
777 struct timespec64
timespec64_add_safe(const struct timespec64 lhs
,
778 const struct timespec64 rhs
)
780 struct timespec64 res
;
782 set_normalized_timespec64(&res
, (timeu64_t
) lhs
.tv_sec
+ rhs
.tv_sec
,
783 lhs
.tv_nsec
+ rhs
.tv_nsec
);
785 if (unlikely(res
.tv_sec
< lhs
.tv_sec
|| res
.tv_sec
< rhs
.tv_sec
)) {
786 res
.tv_sec
= TIME64_MAX
;
793 int get_timespec64(struct timespec64
*ts
,
794 const struct __kernel_timespec __user
*uts
)
796 struct __kernel_timespec kts
;
799 ret
= copy_from_user(&kts
, uts
, sizeof(kts
));
803 ts
->tv_sec
= kts
.tv_sec
;
805 /* Zero out the padding for 32 bit systems or in compat mode */
806 if (IS_ENABLED(CONFIG_64BIT_TIME
) && in_compat_syscall())
807 kts
.tv_nsec
&= 0xFFFFFFFFUL
;
809 ts
->tv_nsec
= kts
.tv_nsec
;
813 EXPORT_SYMBOL_GPL(get_timespec64
);
815 int put_timespec64(const struct timespec64
*ts
,
816 struct __kernel_timespec __user
*uts
)
818 struct __kernel_timespec kts
= {
819 .tv_sec
= ts
->tv_sec
,
820 .tv_nsec
= ts
->tv_nsec
823 return copy_to_user(uts
, &kts
, sizeof(kts
)) ? -EFAULT
: 0;
825 EXPORT_SYMBOL_GPL(put_timespec64
);
827 static int __get_old_timespec32(struct timespec64
*ts64
,
828 const struct old_timespec32 __user
*cts
)
830 struct old_timespec32 ts
;
833 ret
= copy_from_user(&ts
, cts
, sizeof(ts
));
837 ts64
->tv_sec
= ts
.tv_sec
;
838 ts64
->tv_nsec
= ts
.tv_nsec
;
843 static int __put_old_timespec32(const struct timespec64
*ts64
,
844 struct old_timespec32 __user
*cts
)
846 struct old_timespec32 ts
= {
847 .tv_sec
= ts64
->tv_sec
,
848 .tv_nsec
= ts64
->tv_nsec
850 return copy_to_user(cts
, &ts
, sizeof(ts
)) ? -EFAULT
: 0;
853 int get_old_timespec32(struct timespec64
*ts
, const void __user
*uts
)
855 if (COMPAT_USE_64BIT_TIME
)
856 return copy_from_user(ts
, uts
, sizeof(*ts
)) ? -EFAULT
: 0;
858 return __get_old_timespec32(ts
, uts
);
860 EXPORT_SYMBOL_GPL(get_old_timespec32
);
862 int put_old_timespec32(const struct timespec64
*ts
, void __user
*uts
)
864 if (COMPAT_USE_64BIT_TIME
)
865 return copy_to_user(uts
, ts
, sizeof(*ts
)) ? -EFAULT
: 0;
867 return __put_old_timespec32(ts
, uts
);
869 EXPORT_SYMBOL_GPL(put_old_timespec32
);
871 int get_itimerspec64(struct itimerspec64
*it
,
872 const struct __kernel_itimerspec __user
*uit
)
876 ret
= get_timespec64(&it
->it_interval
, &uit
->it_interval
);
880 ret
= get_timespec64(&it
->it_value
, &uit
->it_value
);
884 EXPORT_SYMBOL_GPL(get_itimerspec64
);
886 int put_itimerspec64(const struct itimerspec64
*it
,
887 struct __kernel_itimerspec __user
*uit
)
891 ret
= put_timespec64(&it
->it_interval
, &uit
->it_interval
);
895 ret
= put_timespec64(&it
->it_value
, &uit
->it_value
);
899 EXPORT_SYMBOL_GPL(put_itimerspec64
);
901 int get_old_itimerspec32(struct itimerspec64
*its
,
902 const struct old_itimerspec32 __user
*uits
)
905 if (__get_old_timespec32(&its
->it_interval
, &uits
->it_interval
) ||
906 __get_old_timespec32(&its
->it_value
, &uits
->it_value
))
910 EXPORT_SYMBOL_GPL(get_old_itimerspec32
);
912 int put_old_itimerspec32(const struct itimerspec64
*its
,
913 struct old_itimerspec32 __user
*uits
)
915 if (__put_old_timespec32(&its
->it_interval
, &uits
->it_interval
) ||
916 __put_old_timespec32(&its
->it_value
, &uits
->it_value
))
920 EXPORT_SYMBOL_GPL(put_old_itimerspec32
);