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, __kernel_old_time_t __user *, tloc)
64 __kernel_old_time_t i = (__kernel_old_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, __kernel_old_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 */
101 #ifdef CONFIG_COMPAT_32BIT_TIME
102 #ifdef __ARCH_WANT_SYS_TIME32
104 /* old_time32_t is a 32 bit "long" and needs to get converted. */
105 SYSCALL_DEFINE1(time32, 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 SYSCALL_DEFINE1(stime32, 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_SYS_TIME32 */
140 SYSCALL_DEFINE2(gettimeofday, struct __kernel_old_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_settod(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 __kernel_old_timeval __user *, tv,
200 struct timezone __user *, tz)
202 struct timespec64 new_ts;
203 struct timezone new_tz;
206 if (get_user(new_ts.tv_sec, &tv->tv_sec) ||
207 get_user(new_ts.tv_nsec, &tv->tv_usec))
210 if (new_ts.tv_nsec > USEC_PER_SEC || new_ts.tv_nsec < 0)
213 new_ts.tv_nsec *= NSEC_PER_USEC;
216 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
220 return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
224 COMPAT_SYSCALL_DEFINE2(gettimeofday, struct old_timeval32 __user *, tv,
225 struct timezone __user *, tz)
228 struct timespec64 ts;
230 ktime_get_real_ts64(&ts);
231 if (put_user(ts.tv_sec, &tv->tv_sec) ||
232 put_user(ts.tv_nsec / 1000, &tv->tv_usec))
236 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
243 COMPAT_SYSCALL_DEFINE2(settimeofday, struct old_timeval32 __user *, tv,
244 struct timezone __user *, tz)
246 struct timespec64 new_ts;
247 struct timezone new_tz;
250 if (get_user(new_ts.tv_sec, &tv->tv_sec) ||
251 get_user(new_ts.tv_nsec, &tv->tv_usec))
254 if (new_ts.tv_nsec > USEC_PER_SEC || new_ts.tv_nsec < 0)
257 new_ts.tv_nsec *= NSEC_PER_USEC;
260 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
264 return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
269 SYSCALL_DEFINE1(adjtimex, struct __kernel_timex __user *, txc_p)
271 struct __kernel_timex txc; /* Local copy of parameter */
274 /* Copy the user data space into the kernel copy
275 * structure. But bear in mind that the structures
278 if (copy_from_user(&txc, txc_p, sizeof(struct __kernel_timex)))
280 ret = do_adjtimex(&txc);
281 return copy_to_user(txc_p, &txc, sizeof(struct __kernel_timex)) ? -EFAULT : ret;
285 #ifdef CONFIG_COMPAT_32BIT_TIME
286 int get_old_timex32(struct __kernel_timex *txc, const struct old_timex32 __user *utp)
288 struct old_timex32 tx32;
290 memset(txc, 0, sizeof(struct __kernel_timex));
291 if (copy_from_user(&tx32, utp, sizeof(struct old_timex32)))
294 txc->modes = tx32.modes;
295 txc->offset = tx32.offset;
296 txc->freq = tx32.freq;
297 txc->maxerror = tx32.maxerror;
298 txc->esterror = tx32.esterror;
299 txc->status = tx32.status;
300 txc->constant = tx32.constant;
301 txc->precision = tx32.precision;
302 txc->tolerance = tx32.tolerance;
303 txc->time.tv_sec = tx32.time.tv_sec;
304 txc->time.tv_usec = tx32.time.tv_usec;
305 txc->tick = tx32.tick;
306 txc->ppsfreq = tx32.ppsfreq;
307 txc->jitter = tx32.jitter;
308 txc->shift = tx32.shift;
309 txc->stabil = tx32.stabil;
310 txc->jitcnt = tx32.jitcnt;
311 txc->calcnt = tx32.calcnt;
312 txc->errcnt = tx32.errcnt;
313 txc->stbcnt = tx32.stbcnt;
318 int put_old_timex32(struct old_timex32 __user *utp, const struct __kernel_timex *txc)
320 struct old_timex32 tx32;
322 memset(&tx32, 0, sizeof(struct old_timex32));
323 tx32.modes = txc->modes;
324 tx32.offset = txc->offset;
325 tx32.freq = txc->freq;
326 tx32.maxerror = txc->maxerror;
327 tx32.esterror = txc->esterror;
328 tx32.status = txc->status;
329 tx32.constant = txc->constant;
330 tx32.precision = txc->precision;
331 tx32.tolerance = txc->tolerance;
332 tx32.time.tv_sec = txc->time.tv_sec;
333 tx32.time.tv_usec = txc->time.tv_usec;
334 tx32.tick = txc->tick;
335 tx32.ppsfreq = txc->ppsfreq;
336 tx32.jitter = txc->jitter;
337 tx32.shift = txc->shift;
338 tx32.stabil = txc->stabil;
339 tx32.jitcnt = txc->jitcnt;
340 tx32.calcnt = txc->calcnt;
341 tx32.errcnt = txc->errcnt;
342 tx32.stbcnt = txc->stbcnt;
344 if (copy_to_user(utp, &tx32, sizeof(struct old_timex32)))
349 SYSCALL_DEFINE1(adjtimex_time32, struct old_timex32 __user *, utp)
351 struct __kernel_timex txc;
354 err = get_old_timex32(&txc, utp);
358 ret = do_adjtimex(&txc);
360 err = put_old_timex32(utp, &txc);
369 * Convert jiffies to milliseconds and back.
371 * Avoid unnecessary multiplications/divisions in the
372 * two most common HZ cases:
374 unsigned int jiffies_to_msecs(const unsigned long j)
376 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
377 return (MSEC_PER_SEC / HZ) * j;
378 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
379 return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
381 # if BITS_PER_LONG == 32
382 return (HZ_TO_MSEC_MUL32 * j + (1ULL << HZ_TO_MSEC_SHR32) - 1) >>
385 return DIV_ROUND_UP(j * HZ_TO_MSEC_NUM, HZ_TO_MSEC_DEN);
389 EXPORT_SYMBOL(jiffies_to_msecs);
391 unsigned int jiffies_to_usecs(const unsigned long j)
394 * Hz usually doesn't go much further MSEC_PER_SEC.
395 * jiffies_to_usecs() and usecs_to_jiffies() depend on that.
397 BUILD_BUG_ON(HZ > USEC_PER_SEC);
399 #if !(USEC_PER_SEC % HZ)
400 return (USEC_PER_SEC / HZ) * j;
402 # if BITS_PER_LONG == 32
403 return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
405 return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
409 EXPORT_SYMBOL(jiffies_to_usecs);
412 * mktime64 - Converts date to seconds.
413 * Converts Gregorian date to seconds since 1970-01-01 00:00:00.
414 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
415 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
417 * [For the Julian calendar (which was used in Russia before 1917,
418 * Britain & colonies before 1752, anywhere else before 1582,
419 * and is still in use by some communities) leave out the
420 * -year/100+year/400 terms, and add 10.]
422 * This algorithm was first published by Gauss (I think).
424 * A leap second can be indicated by calling this function with sec as
425 * 60 (allowable under ISO 8601). The leap second is treated the same
426 * as the following second since they don't exist in UNIX time.
428 * An encoding of midnight at the end of the day as 24:00:00 - ie. midnight
429 * tomorrow - (allowable under ISO 8601) is supported.
431 time64_t mktime64(const unsigned int year0, const unsigned int mon0,
432 const unsigned int day, const unsigned int hour,
433 const unsigned int min, const unsigned int sec)
435 unsigned int mon = mon0, year = year0;
437 /* 1..12 -> 11,12,1..10 */
438 if (0 >= (int) (mon -= 2)) {
439 mon += 12; /* Puts Feb last since it has leap day */
444 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
446 )*24 + hour /* now have hours - midnight tomorrow handled here */
447 )*60 + min /* now have minutes */
448 )*60 + sec; /* finally seconds */
450 EXPORT_SYMBOL(mktime64);
453 * ns_to_timespec - Convert nanoseconds to timespec
454 * @nsec: the nanoseconds value to be converted
456 * Returns the timespec representation of the nsec parameter.
458 struct timespec ns_to_timespec(const s64 nsec)
464 return (struct timespec) {0, 0};
466 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
467 if (unlikely(rem < 0)) {
475 EXPORT_SYMBOL(ns_to_timespec);
478 * ns_to_timeval - Convert nanoseconds to timeval
479 * @nsec: the nanoseconds value to be converted
481 * Returns the timeval representation of the nsec parameter.
483 struct timeval ns_to_timeval(const s64 nsec)
485 struct timespec ts = ns_to_timespec(nsec);
488 tv.tv_sec = ts.tv_sec;
489 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
493 EXPORT_SYMBOL(ns_to_timeval);
495 struct __kernel_old_timeval ns_to_kernel_old_timeval(const s64 nsec)
497 struct timespec64 ts = ns_to_timespec64(nsec);
498 struct __kernel_old_timeval tv;
500 tv.tv_sec = ts.tv_sec;
501 tv.tv_usec = (suseconds_t)ts.tv_nsec / 1000;
505 EXPORT_SYMBOL(ns_to_kernel_old_timeval);
508 * set_normalized_timespec - set timespec sec and nsec parts and normalize
510 * @ts: pointer to timespec variable to be set
511 * @sec: seconds to set
512 * @nsec: nanoseconds to set
514 * Set seconds and nanoseconds field of a timespec variable and
515 * normalize to the timespec storage format
517 * Note: The tv_nsec part is always in the range of
518 * 0 <= tv_nsec < NSEC_PER_SEC
519 * For negative values only the tv_sec field is negative !
521 void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec)
523 while (nsec >= NSEC_PER_SEC) {
525 * The following asm() prevents the compiler from
526 * optimising this loop into a modulo operation. See
527 * also __iter_div_u64_rem() in include/linux/time.h
529 asm("" : "+rm"(nsec));
530 nsec -= NSEC_PER_SEC;
534 asm("" : "+rm"(nsec));
535 nsec += NSEC_PER_SEC;
541 EXPORT_SYMBOL(set_normalized_timespec64);
544 * ns_to_timespec64 - Convert nanoseconds to timespec64
545 * @nsec: the nanoseconds value to be converted
547 * Returns the timespec64 representation of the nsec parameter.
549 struct timespec64 ns_to_timespec64(const s64 nsec)
551 struct timespec64 ts;
555 return (struct timespec64) {0, 0};
557 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
558 if (unlikely(rem < 0)) {
566 EXPORT_SYMBOL(ns_to_timespec64);
569 * msecs_to_jiffies: - convert milliseconds to jiffies
570 * @m: time in milliseconds
572 * conversion is done as follows:
574 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
576 * - 'too large' values [that would result in larger than
577 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
579 * - all other values are converted to jiffies by either multiplying
580 * the input value by a factor or dividing it with a factor and
581 * handling any 32-bit overflows.
582 * for the details see __msecs_to_jiffies()
584 * msecs_to_jiffies() checks for the passed in value being a constant
585 * via __builtin_constant_p() allowing gcc to eliminate most of the
586 * code, __msecs_to_jiffies() is called if the value passed does not
587 * allow constant folding and the actual conversion must be done at
589 * the _msecs_to_jiffies helpers are the HZ dependent conversion
590 * routines found in include/linux/jiffies.h
592 unsigned long __msecs_to_jiffies(const unsigned int m)
595 * Negative value, means infinite timeout:
598 return MAX_JIFFY_OFFSET;
599 return _msecs_to_jiffies(m);
601 EXPORT_SYMBOL(__msecs_to_jiffies);
603 unsigned long __usecs_to_jiffies(const unsigned int u)
605 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
606 return MAX_JIFFY_OFFSET;
607 return _usecs_to_jiffies(u);
609 EXPORT_SYMBOL(__usecs_to_jiffies);
612 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
613 * that a remainder subtract here would not do the right thing as the
614 * resolution values don't fall on second boundries. I.e. the line:
615 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
616 * Note that due to the small error in the multiplier here, this
617 * rounding is incorrect for sufficiently large values of tv_nsec, but
618 * well formed timespecs should have tv_nsec < NSEC_PER_SEC, so we're
621 * Rather, we just shift the bits off the right.
623 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
624 * value to a scaled second value.
627 __timespec64_to_jiffies(u64 sec, long nsec)
629 nsec = nsec + TICK_NSEC - 1;
631 if (sec >= MAX_SEC_IN_JIFFIES){
632 sec = MAX_SEC_IN_JIFFIES;
635 return ((sec * SEC_CONVERSION) +
636 (((u64)nsec * NSEC_CONVERSION) >>
637 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
642 __timespec_to_jiffies(unsigned long sec, long nsec)
644 return __timespec64_to_jiffies((u64)sec, nsec);
648 timespec64_to_jiffies(const struct timespec64 *value)
650 return __timespec64_to_jiffies(value->tv_sec, value->tv_nsec);
652 EXPORT_SYMBOL(timespec64_to_jiffies);
655 jiffies_to_timespec64(const unsigned long jiffies, struct timespec64 *value)
658 * Convert jiffies to nanoseconds and separate with
662 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
664 value->tv_nsec = rem;
666 EXPORT_SYMBOL(jiffies_to_timespec64);
669 * We could use a similar algorithm to timespec_to_jiffies (with a
670 * different multiplier for usec instead of nsec). But this has a
671 * problem with rounding: we can't exactly add TICK_NSEC - 1 to the
672 * usec value, since it's not necessarily integral.
674 * We could instead round in the intermediate scaled representation
675 * (i.e. in units of 1/2^(large scale) jiffies) but that's also
676 * perilous: the scaling introduces a small positive error, which
677 * combined with a division-rounding-upward (i.e. adding 2^(scale) - 1
678 * units to the intermediate before shifting) leads to accidental
679 * overflow and overestimates.
681 * At the cost of one additional multiplication by a constant, just
682 * use the timespec implementation.
685 timeval_to_jiffies(const struct timeval *value)
687 return __timespec_to_jiffies(value->tv_sec,
688 value->tv_usec * NSEC_PER_USEC);
690 EXPORT_SYMBOL(timeval_to_jiffies);
692 void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
695 * Convert jiffies to nanoseconds and separate with
700 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
702 value->tv_usec = rem / NSEC_PER_USEC;
704 EXPORT_SYMBOL(jiffies_to_timeval);
707 * Convert jiffies/jiffies_64 to clock_t and back.
709 clock_t jiffies_to_clock_t(unsigned long x)
711 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
713 return x * (USER_HZ / HZ);
715 return x / (HZ / USER_HZ);
718 return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
721 EXPORT_SYMBOL(jiffies_to_clock_t);
723 unsigned long clock_t_to_jiffies(unsigned long x)
725 #if (HZ % USER_HZ)==0
726 if (x >= ~0UL / (HZ / USER_HZ))
728 return x * (HZ / USER_HZ);
730 /* Don't worry about loss of precision here .. */
731 if (x >= ~0UL / HZ * USER_HZ)
734 /* .. but do try to contain it here */
735 return div_u64((u64)x * HZ, USER_HZ);
738 EXPORT_SYMBOL(clock_t_to_jiffies);
740 u64 jiffies_64_to_clock_t(u64 x)
742 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
744 x = div_u64(x * USER_HZ, HZ);
746 x = div_u64(x, HZ / USER_HZ);
752 * There are better ways that don't overflow early,
753 * but even this doesn't overflow in hundreds of years
756 x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
760 EXPORT_SYMBOL(jiffies_64_to_clock_t);
762 u64 nsec_to_clock_t(u64 x)
764 #if (NSEC_PER_SEC % USER_HZ) == 0
765 return div_u64(x, NSEC_PER_SEC / USER_HZ);
766 #elif (USER_HZ % 512) == 0
767 return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
770 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
771 * overflow after 64.99 years.
772 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
774 return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
778 u64 jiffies64_to_nsecs(u64 j)
780 #if !(NSEC_PER_SEC % HZ)
781 return (NSEC_PER_SEC / HZ) * j;
783 return div_u64(j * HZ_TO_NSEC_NUM, HZ_TO_NSEC_DEN);
786 EXPORT_SYMBOL(jiffies64_to_nsecs);
788 u64 jiffies64_to_msecs(const u64 j)
790 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
791 return (MSEC_PER_SEC / HZ) * j;
793 return div_u64(j * HZ_TO_MSEC_NUM, HZ_TO_MSEC_DEN);
796 EXPORT_SYMBOL(jiffies64_to_msecs);
799 * nsecs_to_jiffies64 - Convert nsecs in u64 to jiffies64
803 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
804 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
805 * for scheduler, not for use in device drivers to calculate timeout value.
808 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
809 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
811 u64 nsecs_to_jiffies64(u64 n)
813 #if (NSEC_PER_SEC % HZ) == 0
814 /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */
815 return div_u64(n, NSEC_PER_SEC / HZ);
816 #elif (HZ % 512) == 0
817 /* overflow after 292 years if HZ = 1024 */
818 return div_u64(n * HZ / 512, NSEC_PER_SEC / 512);
821 * Generic case - optimized for cases where HZ is a multiple of 3.
822 * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc.
824 return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ);
827 EXPORT_SYMBOL(nsecs_to_jiffies64);
830 * nsecs_to_jiffies - Convert nsecs in u64 to jiffies
834 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
835 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
836 * for scheduler, not for use in device drivers to calculate timeout value.
839 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
840 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
842 unsigned long nsecs_to_jiffies(u64 n)
844 return (unsigned long)nsecs_to_jiffies64(n);
846 EXPORT_SYMBOL_GPL(nsecs_to_jiffies);
849 * Add two timespec64 values and do a safety check for overflow.
850 * It's assumed that both values are valid (>= 0).
851 * And, each timespec64 is in normalized form.
853 struct timespec64 timespec64_add_safe(const struct timespec64 lhs,
854 const struct timespec64 rhs)
856 struct timespec64 res;
858 set_normalized_timespec64(&res, (timeu64_t) lhs.tv_sec + rhs.tv_sec,
859 lhs.tv_nsec + rhs.tv_nsec);
861 if (unlikely(res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)) {
862 res.tv_sec = TIME64_MAX;
869 int get_timespec64(struct timespec64 *ts,
870 const struct __kernel_timespec __user *uts)
872 struct __kernel_timespec kts;
875 ret = copy_from_user(&kts, uts, sizeof(kts));
879 ts->tv_sec = kts.tv_sec;
881 /* Zero out the padding for 32 bit systems or in compat mode */
882 if (in_compat_syscall())
883 kts.tv_nsec &= 0xFFFFFFFFUL;
885 ts->tv_nsec = kts.tv_nsec;
889 EXPORT_SYMBOL_GPL(get_timespec64);
891 int put_timespec64(const struct timespec64 *ts,
892 struct __kernel_timespec __user *uts)
894 struct __kernel_timespec kts = {
895 .tv_sec = ts->tv_sec,
896 .tv_nsec = ts->tv_nsec
899 return copy_to_user(uts, &kts, sizeof(kts)) ? -EFAULT : 0;
901 EXPORT_SYMBOL_GPL(put_timespec64);
903 static int __get_old_timespec32(struct timespec64 *ts64,
904 const struct old_timespec32 __user *cts)
906 struct old_timespec32 ts;
909 ret = copy_from_user(&ts, cts, sizeof(ts));
913 ts64->tv_sec = ts.tv_sec;
914 ts64->tv_nsec = ts.tv_nsec;
919 static int __put_old_timespec32(const struct timespec64 *ts64,
920 struct old_timespec32 __user *cts)
922 struct old_timespec32 ts = {
923 .tv_sec = ts64->tv_sec,
924 .tv_nsec = ts64->tv_nsec
926 return copy_to_user(cts, &ts, sizeof(ts)) ? -EFAULT : 0;
929 int get_old_timespec32(struct timespec64 *ts, const void __user *uts)
931 if (COMPAT_USE_64BIT_TIME)
932 return copy_from_user(ts, uts, sizeof(*ts)) ? -EFAULT : 0;
934 return __get_old_timespec32(ts, uts);
936 EXPORT_SYMBOL_GPL(get_old_timespec32);
938 int put_old_timespec32(const struct timespec64 *ts, void __user *uts)
940 if (COMPAT_USE_64BIT_TIME)
941 return copy_to_user(uts, ts, sizeof(*ts)) ? -EFAULT : 0;
943 return __put_old_timespec32(ts, uts);
945 EXPORT_SYMBOL_GPL(put_old_timespec32);
947 int get_itimerspec64(struct itimerspec64 *it,
948 const struct __kernel_itimerspec __user *uit)
952 ret = get_timespec64(&it->it_interval, &uit->it_interval);
956 ret = get_timespec64(&it->it_value, &uit->it_value);
960 EXPORT_SYMBOL_GPL(get_itimerspec64);
962 int put_itimerspec64(const struct itimerspec64 *it,
963 struct __kernel_itimerspec __user *uit)
967 ret = put_timespec64(&it->it_interval, &uit->it_interval);
971 ret = put_timespec64(&it->it_value, &uit->it_value);
975 EXPORT_SYMBOL_GPL(put_itimerspec64);
977 int get_old_itimerspec32(struct itimerspec64 *its,
978 const struct old_itimerspec32 __user *uits)
981 if (__get_old_timespec32(&its->it_interval, &uits->it_interval) ||
982 __get_old_timespec32(&its->it_value, &uits->it_value))
986 EXPORT_SYMBOL_GPL(get_old_itimerspec32);
988 int put_old_itimerspec32(const struct itimerspec64 *its,
989 struct old_itimerspec32 __user *uits)
991 if (__put_old_timespec32(&its->it_interval, &uits->it_interval) ||
992 __put_old_timespec32(&its->it_value, &uits->it_value))
996 EXPORT_SYMBOL_GPL(put_old_itimerspec32);