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);