15cee9645SThomas Gleixner /* 25cee9645SThomas Gleixner * Copyright (C) 1991, 1992 Linus Torvalds 35cee9645SThomas Gleixner * 458c5fc2bSThomas Gleixner * This file contains the interface functions for the various time related 558c5fc2bSThomas Gleixner * system calls: time, stime, gettimeofday, settimeofday, adjtime 658c5fc2bSThomas Gleixner * 758c5fc2bSThomas Gleixner * Modification history: 85cee9645SThomas Gleixner * 95cee9645SThomas Gleixner * 1993-09-02 Philip Gladstone 105cee9645SThomas Gleixner * Created file with time related functions from sched/core.c and adjtimex() 115cee9645SThomas Gleixner * 1993-10-08 Torsten Duwe 125cee9645SThomas Gleixner * adjtime interface update and CMOS clock write code 135cee9645SThomas Gleixner * 1995-08-13 Torsten Duwe 145cee9645SThomas Gleixner * kernel PLL updated to 1994-12-13 specs (rfc-1589) 155cee9645SThomas Gleixner * 1999-01-16 Ulrich Windl 165cee9645SThomas Gleixner * Introduced error checking for many cases in adjtimex(). 175cee9645SThomas Gleixner * Updated NTP code according to technical memorandum Jan '96 185cee9645SThomas Gleixner * "A Kernel Model for Precision Timekeeping" by Dave Mills 195cee9645SThomas Gleixner * Allow time_constant larger than MAXTC(6) for NTP v4 (MAXTC == 10) 205cee9645SThomas Gleixner * (Even though the technical memorandum forbids it) 215cee9645SThomas Gleixner * 2004-07-14 Christoph Lameter 225cee9645SThomas Gleixner * Added getnstimeofday to allow the posix timer functions to return 235cee9645SThomas Gleixner * with nanosecond accuracy 245cee9645SThomas Gleixner */ 255cee9645SThomas Gleixner 265cee9645SThomas Gleixner #include <linux/export.h> 27abcbcb80SGeert Uytterhoeven #include <linux/kernel.h> 285cee9645SThomas Gleixner #include <linux/timex.h> 295cee9645SThomas Gleixner #include <linux/capability.h> 305cee9645SThomas Gleixner #include <linux/timekeeper_internal.h> 315cee9645SThomas Gleixner #include <linux/errno.h> 325cee9645SThomas Gleixner #include <linux/syscalls.h> 335cee9645SThomas Gleixner #include <linux/security.h> 345cee9645SThomas Gleixner #include <linux/fs.h> 355cee9645SThomas Gleixner #include <linux/math64.h> 365cee9645SThomas Gleixner #include <linux/ptrace.h> 375cee9645SThomas Gleixner 387c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 393a4d44b6SAl Viro #include <linux/compat.h> 405cee9645SThomas Gleixner #include <asm/unistd.h> 415cee9645SThomas Gleixner 420a227985SNicholas Mc Guire #include <generated/timeconst.h> 438b094cd0SThomas Gleixner #include "timekeeping.h" 445cee9645SThomas Gleixner 455cee9645SThomas Gleixner /* 465cee9645SThomas Gleixner * The timezone where the local system is located. Used as a default by some 475cee9645SThomas Gleixner * programs who obtain this value by using gettimeofday. 485cee9645SThomas Gleixner */ 495cee9645SThomas Gleixner struct timezone sys_tz; 505cee9645SThomas Gleixner 515cee9645SThomas Gleixner EXPORT_SYMBOL(sys_tz); 525cee9645SThomas Gleixner 535cee9645SThomas Gleixner #ifdef __ARCH_WANT_SYS_TIME 545cee9645SThomas Gleixner 555cee9645SThomas Gleixner /* 565cee9645SThomas Gleixner * sys_time() can be implemented in user-level using 575cee9645SThomas Gleixner * sys_gettimeofday(). Is this for backwards compatibility? If so, 585cee9645SThomas Gleixner * why not move it into the appropriate arch directory (for those 595cee9645SThomas Gleixner * architectures that need it). 605cee9645SThomas Gleixner */ 615cee9645SThomas Gleixner SYSCALL_DEFINE1(time, time_t __user *, tloc) 625cee9645SThomas Gleixner { 63f5a89295SArnd Bergmann time_t i = (time_t)ktime_get_real_seconds(); 645cee9645SThomas Gleixner 655cee9645SThomas Gleixner if (tloc) { 665cee9645SThomas Gleixner if (put_user(i,tloc)) 675cee9645SThomas Gleixner return -EFAULT; 685cee9645SThomas Gleixner } 695cee9645SThomas Gleixner force_successful_syscall_return(); 705cee9645SThomas Gleixner return i; 715cee9645SThomas Gleixner } 725cee9645SThomas Gleixner 735cee9645SThomas Gleixner /* 745cee9645SThomas Gleixner * sys_stime() can be implemented in user-level using 755cee9645SThomas Gleixner * sys_settimeofday(). Is this for backwards compatibility? If so, 765cee9645SThomas Gleixner * why not move it into the appropriate arch directory (for those 775cee9645SThomas Gleixner * architectures that need it). 785cee9645SThomas Gleixner */ 795cee9645SThomas Gleixner 805cee9645SThomas Gleixner SYSCALL_DEFINE1(stime, time_t __user *, tptr) 815cee9645SThomas Gleixner { 824eb1bca1SArnd Bergmann struct timespec64 tv; 835cee9645SThomas Gleixner int err; 845cee9645SThomas Gleixner 855cee9645SThomas Gleixner if (get_user(tv.tv_sec, tptr)) 865cee9645SThomas Gleixner return -EFAULT; 875cee9645SThomas Gleixner 885cee9645SThomas Gleixner tv.tv_nsec = 0; 895cee9645SThomas Gleixner 904eb1bca1SArnd Bergmann err = security_settime64(&tv, NULL); 915cee9645SThomas Gleixner if (err) 925cee9645SThomas Gleixner return err; 935cee9645SThomas Gleixner 944eb1bca1SArnd Bergmann do_settimeofday64(&tv); 955cee9645SThomas Gleixner return 0; 965cee9645SThomas Gleixner } 975cee9645SThomas Gleixner 985cee9645SThomas Gleixner #endif /* __ARCH_WANT_SYS_TIME */ 995cee9645SThomas Gleixner 100b180db2cSAl Viro #ifdef CONFIG_COMPAT 101b180db2cSAl Viro #ifdef __ARCH_WANT_COMPAT_SYS_TIME 102b180db2cSAl Viro 1039afc5eeeSArnd Bergmann /* old_time32_t is a 32 bit "long" and needs to get converted. */ 1049afc5eeeSArnd Bergmann COMPAT_SYSCALL_DEFINE1(time, old_time32_t __user *, tloc) 105b180db2cSAl Viro { 1069afc5eeeSArnd Bergmann old_time32_t i; 107b180db2cSAl Viro 1089afc5eeeSArnd Bergmann i = (old_time32_t)ktime_get_real_seconds(); 109b180db2cSAl Viro 110b180db2cSAl Viro if (tloc) { 111b180db2cSAl Viro if (put_user(i,tloc)) 112b180db2cSAl Viro return -EFAULT; 113b180db2cSAl Viro } 114b180db2cSAl Viro force_successful_syscall_return(); 115b180db2cSAl Viro return i; 116b180db2cSAl Viro } 117b180db2cSAl Viro 1189afc5eeeSArnd Bergmann COMPAT_SYSCALL_DEFINE1(stime, old_time32_t __user *, tptr) 119b180db2cSAl Viro { 1204eb1bca1SArnd Bergmann struct timespec64 tv; 121b180db2cSAl Viro int err; 122b180db2cSAl Viro 123b180db2cSAl Viro if (get_user(tv.tv_sec, tptr)) 124b180db2cSAl Viro return -EFAULT; 125b180db2cSAl Viro 126b180db2cSAl Viro tv.tv_nsec = 0; 127b180db2cSAl Viro 1284eb1bca1SArnd Bergmann err = security_settime64(&tv, NULL); 129b180db2cSAl Viro if (err) 130b180db2cSAl Viro return err; 131b180db2cSAl Viro 1324eb1bca1SArnd Bergmann do_settimeofday64(&tv); 133b180db2cSAl Viro return 0; 134b180db2cSAl Viro } 135b180db2cSAl Viro 136b180db2cSAl Viro #endif /* __ARCH_WANT_COMPAT_SYS_TIME */ 137b180db2cSAl Viro #endif 138b180db2cSAl Viro 1395cee9645SThomas Gleixner SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv, 1405cee9645SThomas Gleixner struct timezone __user *, tz) 1415cee9645SThomas Gleixner { 1425cee9645SThomas Gleixner if (likely(tv != NULL)) { 14333e26418SArnd Bergmann struct timespec64 ts; 14433e26418SArnd Bergmann 14533e26418SArnd Bergmann ktime_get_real_ts64(&ts); 14633e26418SArnd Bergmann if (put_user(ts.tv_sec, &tv->tv_sec) || 14733e26418SArnd Bergmann put_user(ts.tv_nsec / 1000, &tv->tv_usec)) 1485cee9645SThomas Gleixner return -EFAULT; 1495cee9645SThomas Gleixner } 1505cee9645SThomas Gleixner if (unlikely(tz != NULL)) { 1515cee9645SThomas Gleixner if (copy_to_user(tz, &sys_tz, sizeof(sys_tz))) 1525cee9645SThomas Gleixner return -EFAULT; 1535cee9645SThomas Gleixner } 1545cee9645SThomas Gleixner return 0; 1555cee9645SThomas Gleixner } 1565cee9645SThomas Gleixner 1575cee9645SThomas Gleixner /* 1585cee9645SThomas Gleixner * In case for some reason the CMOS clock has not already been running 1595cee9645SThomas Gleixner * in UTC, but in some local time: The first time we set the timezone, 1605cee9645SThomas Gleixner * we will warp the clock so that it is ticking UTC time instead of 1615cee9645SThomas Gleixner * local time. Presumably, if someone is setting the timezone then we 1625cee9645SThomas Gleixner * are running in an environment where the programs understand about 1635cee9645SThomas Gleixner * timezones. This should be done at boot time in the /etc/rc script, 1645cee9645SThomas Gleixner * as soon as possible, so that the clock can be set right. Otherwise, 1655cee9645SThomas Gleixner * various programs will get confused when the clock gets warped. 1665cee9645SThomas Gleixner */ 1675cee9645SThomas Gleixner 16886d34732SBaolin Wang int do_sys_settimeofday64(const struct timespec64 *tv, const struct timezone *tz) 1695cee9645SThomas Gleixner { 1705cee9645SThomas Gleixner static int firsttime = 1; 1715cee9645SThomas Gleixner int error = 0; 1725cee9645SThomas Gleixner 17386d34732SBaolin Wang if (tv && !timespec64_valid(tv)) 1745cee9645SThomas Gleixner return -EINVAL; 1755cee9645SThomas Gleixner 17686d34732SBaolin Wang error = security_settime64(tv, tz); 1775cee9645SThomas Gleixner if (error) 1785cee9645SThomas Gleixner return error; 1795cee9645SThomas Gleixner 1805cee9645SThomas Gleixner if (tz) { 1816f7d7984SSasha Levin /* Verify we're witin the +-15 hrs range */ 1826f7d7984SSasha Levin if (tz->tz_minuteswest > 15*60 || tz->tz_minuteswest < -15*60) 1836f7d7984SSasha Levin return -EINVAL; 1846f7d7984SSasha Levin 1855cee9645SThomas Gleixner sys_tz = *tz; 1865cee9645SThomas Gleixner update_vsyscall_tz(); 1875cee9645SThomas Gleixner if (firsttime) { 1885cee9645SThomas Gleixner firsttime = 0; 1895cee9645SThomas Gleixner if (!tv) 190e0956dccSArnd Bergmann timekeeping_warp_clock(); 1915cee9645SThomas Gleixner } 1925cee9645SThomas Gleixner } 1935cee9645SThomas Gleixner if (tv) 19486d34732SBaolin Wang return do_settimeofday64(tv); 1955cee9645SThomas Gleixner return 0; 1965cee9645SThomas Gleixner } 1975cee9645SThomas Gleixner 1985cee9645SThomas Gleixner SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv, 1995cee9645SThomas Gleixner struct timezone __user *, tz) 2005cee9645SThomas Gleixner { 2012ac00f17SDeepa Dinamani struct timespec64 new_ts; 2025cee9645SThomas Gleixner struct timeval user_tv; 2035cee9645SThomas Gleixner struct timezone new_tz; 2045cee9645SThomas Gleixner 2055cee9645SThomas Gleixner if (tv) { 2065cee9645SThomas Gleixner if (copy_from_user(&user_tv, tv, sizeof(*tv))) 2075cee9645SThomas Gleixner return -EFAULT; 2086ada1fc0SSasha Levin 2096ada1fc0SSasha Levin if (!timeval_valid(&user_tv)) 2106ada1fc0SSasha Levin return -EINVAL; 2116ada1fc0SSasha Levin 2125cee9645SThomas Gleixner new_ts.tv_sec = user_tv.tv_sec; 2135cee9645SThomas Gleixner new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC; 2145cee9645SThomas Gleixner } 2155cee9645SThomas Gleixner if (tz) { 2165cee9645SThomas Gleixner if (copy_from_user(&new_tz, tz, sizeof(*tz))) 2175cee9645SThomas Gleixner return -EFAULT; 2185cee9645SThomas Gleixner } 2195cee9645SThomas Gleixner 2202ac00f17SDeepa Dinamani return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL); 2215cee9645SThomas Gleixner } 2225cee9645SThomas Gleixner 2232b2d0285SAl Viro #ifdef CONFIG_COMPAT 2249afc5eeeSArnd Bergmann COMPAT_SYSCALL_DEFINE2(gettimeofday, struct old_timeval32 __user *, tv, 2252b2d0285SAl Viro struct timezone __user *, tz) 2262b2d0285SAl Viro { 2272b2d0285SAl Viro if (tv) { 22833e26418SArnd Bergmann struct timespec64 ts; 2292b2d0285SAl Viro 23033e26418SArnd Bergmann ktime_get_real_ts64(&ts); 23133e26418SArnd Bergmann if (put_user(ts.tv_sec, &tv->tv_sec) || 23233e26418SArnd Bergmann put_user(ts.tv_nsec / 1000, &tv->tv_usec)) 2332b2d0285SAl Viro return -EFAULT; 2342b2d0285SAl Viro } 2352b2d0285SAl Viro if (tz) { 2362b2d0285SAl Viro if (copy_to_user(tz, &sys_tz, sizeof(sys_tz))) 2372b2d0285SAl Viro return -EFAULT; 2382b2d0285SAl Viro } 2392b2d0285SAl Viro 2402b2d0285SAl Viro return 0; 2412b2d0285SAl Viro } 2422b2d0285SAl Viro 2439afc5eeeSArnd Bergmann COMPAT_SYSCALL_DEFINE2(settimeofday, struct old_timeval32 __user *, tv, 2442b2d0285SAl Viro struct timezone __user *, tz) 2452b2d0285SAl Viro { 2462b2d0285SAl Viro struct timespec64 new_ts; 2472b2d0285SAl Viro struct timeval user_tv; 2482b2d0285SAl Viro struct timezone new_tz; 2492b2d0285SAl Viro 2502b2d0285SAl Viro if (tv) { 2512b2d0285SAl Viro if (compat_get_timeval(&user_tv, tv)) 2522b2d0285SAl Viro return -EFAULT; 2532b2d0285SAl Viro new_ts.tv_sec = user_tv.tv_sec; 2542b2d0285SAl Viro new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC; 2552b2d0285SAl Viro } 2562b2d0285SAl Viro if (tz) { 2572b2d0285SAl Viro if (copy_from_user(&new_tz, tz, sizeof(*tz))) 2582b2d0285SAl Viro return -EFAULT; 2592b2d0285SAl Viro } 2602b2d0285SAl Viro 2612b2d0285SAl Viro return do_sys_settimeofday64(tv ? &new_ts : NULL, tz ? &new_tz : NULL); 2622b2d0285SAl Viro } 2632b2d0285SAl Viro #endif 2642b2d0285SAl Viro 2655cee9645SThomas Gleixner SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p) 2665cee9645SThomas Gleixner { 2675cee9645SThomas Gleixner struct timex txc; /* Local copy of parameter */ 2685cee9645SThomas Gleixner int ret; 2695cee9645SThomas Gleixner 2705cee9645SThomas Gleixner /* Copy the user data space into the kernel copy 2715cee9645SThomas Gleixner * structure. But bear in mind that the structures 2725cee9645SThomas Gleixner * may change 2735cee9645SThomas Gleixner */ 2745cee9645SThomas Gleixner if (copy_from_user(&txc, txc_p, sizeof(struct timex))) 2755cee9645SThomas Gleixner return -EFAULT; 2765cee9645SThomas Gleixner ret = do_adjtimex(&txc); 2775cee9645SThomas Gleixner return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret; 2785cee9645SThomas Gleixner } 2795cee9645SThomas Gleixner 2803a4d44b6SAl Viro #ifdef CONFIG_COMPAT 2813a4d44b6SAl Viro 2823a4d44b6SAl Viro COMPAT_SYSCALL_DEFINE1(adjtimex, struct compat_timex __user *, utp) 2833a4d44b6SAl Viro { 2843a4d44b6SAl Viro struct timex txc; 2853a4d44b6SAl Viro int err, ret; 2863a4d44b6SAl Viro 2873a4d44b6SAl Viro err = compat_get_timex(&txc, utp); 2883a4d44b6SAl Viro if (err) 2893a4d44b6SAl Viro return err; 2903a4d44b6SAl Viro 2913a4d44b6SAl Viro ret = do_adjtimex(&txc); 2923a4d44b6SAl Viro 2933a4d44b6SAl Viro err = compat_put_timex(utp, &txc); 2943a4d44b6SAl Viro if (err) 2953a4d44b6SAl Viro return err; 2963a4d44b6SAl Viro 2973a4d44b6SAl Viro return ret; 2983a4d44b6SAl Viro } 2993a4d44b6SAl Viro #endif 3003a4d44b6SAl Viro 3015cee9645SThomas Gleixner /* 3025cee9645SThomas Gleixner * Convert jiffies to milliseconds and back. 3035cee9645SThomas Gleixner * 3045cee9645SThomas Gleixner * Avoid unnecessary multiplications/divisions in the 3055cee9645SThomas Gleixner * two most common HZ cases: 3065cee9645SThomas Gleixner */ 3075cee9645SThomas Gleixner unsigned int jiffies_to_msecs(const unsigned long j) 3085cee9645SThomas Gleixner { 3095cee9645SThomas Gleixner #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ) 3105cee9645SThomas Gleixner return (MSEC_PER_SEC / HZ) * j; 3115cee9645SThomas Gleixner #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC) 3125cee9645SThomas Gleixner return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC); 3135cee9645SThomas Gleixner #else 3145cee9645SThomas Gleixner # if BITS_PER_LONG == 32 315abcbcb80SGeert Uytterhoeven return (HZ_TO_MSEC_MUL32 * j + (1ULL << HZ_TO_MSEC_SHR32) - 1) >> 316abcbcb80SGeert Uytterhoeven HZ_TO_MSEC_SHR32; 3175cee9645SThomas Gleixner # else 318abcbcb80SGeert Uytterhoeven return DIV_ROUND_UP(j * HZ_TO_MSEC_NUM, HZ_TO_MSEC_DEN); 3195cee9645SThomas Gleixner # endif 3205cee9645SThomas Gleixner #endif 3215cee9645SThomas Gleixner } 3225cee9645SThomas Gleixner EXPORT_SYMBOL(jiffies_to_msecs); 3235cee9645SThomas Gleixner 3245cee9645SThomas Gleixner unsigned int jiffies_to_usecs(const unsigned long j) 3255cee9645SThomas Gleixner { 326e0758676SFrederic Weisbecker /* 327e0758676SFrederic Weisbecker * Hz usually doesn't go much further MSEC_PER_SEC. 328e0758676SFrederic Weisbecker * jiffies_to_usecs() and usecs_to_jiffies() depend on that. 329e0758676SFrederic Weisbecker */ 330e0758676SFrederic Weisbecker BUILD_BUG_ON(HZ > USEC_PER_SEC); 331e0758676SFrederic Weisbecker 332e0758676SFrederic Weisbecker #if !(USEC_PER_SEC % HZ) 3335cee9645SThomas Gleixner return (USEC_PER_SEC / HZ) * j; 3345cee9645SThomas Gleixner #else 3355cee9645SThomas Gleixner # if BITS_PER_LONG == 32 3365cee9645SThomas Gleixner return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32; 3375cee9645SThomas Gleixner # else 3385cee9645SThomas Gleixner return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN; 3395cee9645SThomas Gleixner # endif 3405cee9645SThomas Gleixner #endif 3415cee9645SThomas Gleixner } 3425cee9645SThomas Gleixner EXPORT_SYMBOL(jiffies_to_usecs); 3435cee9645SThomas Gleixner 34490b6ce9cSpang.xunlei /* 34590b6ce9cSpang.xunlei * mktime64 - Converts date to seconds. 34690b6ce9cSpang.xunlei * Converts Gregorian date to seconds since 1970-01-01 00:00:00. 3475cee9645SThomas Gleixner * Assumes input in normal date format, i.e. 1980-12-31 23:59:59 3485cee9645SThomas Gleixner * => year=1980, mon=12, day=31, hour=23, min=59, sec=59. 3495cee9645SThomas Gleixner * 3505cee9645SThomas Gleixner * [For the Julian calendar (which was used in Russia before 1917, 3515cee9645SThomas Gleixner * Britain & colonies before 1752, anywhere else before 1582, 3525cee9645SThomas Gleixner * and is still in use by some communities) leave out the 3535cee9645SThomas Gleixner * -year/100+year/400 terms, and add 10.] 3545cee9645SThomas Gleixner * 3555cee9645SThomas Gleixner * This algorithm was first published by Gauss (I think). 356ede5147dSDavid Howells * 357ede5147dSDavid Howells * A leap second can be indicated by calling this function with sec as 358ede5147dSDavid Howells * 60 (allowable under ISO 8601). The leap second is treated the same 359ede5147dSDavid Howells * as the following second since they don't exist in UNIX time. 360ede5147dSDavid Howells * 361ede5147dSDavid Howells * An encoding of midnight at the end of the day as 24:00:00 - ie. midnight 362ede5147dSDavid Howells * tomorrow - (allowable under ISO 8601) is supported. 3635cee9645SThomas Gleixner */ 36490b6ce9cSpang.xunlei time64_t mktime64(const unsigned int year0, const unsigned int mon0, 3655cee9645SThomas Gleixner const unsigned int day, const unsigned int hour, 3665cee9645SThomas Gleixner const unsigned int min, const unsigned int sec) 3675cee9645SThomas Gleixner { 3685cee9645SThomas Gleixner unsigned int mon = mon0, year = year0; 3695cee9645SThomas Gleixner 3705cee9645SThomas Gleixner /* 1..12 -> 11,12,1..10 */ 3715cee9645SThomas Gleixner if (0 >= (int) (mon -= 2)) { 3725cee9645SThomas Gleixner mon += 12; /* Puts Feb last since it has leap day */ 3735cee9645SThomas Gleixner year -= 1; 3745cee9645SThomas Gleixner } 3755cee9645SThomas Gleixner 37690b6ce9cSpang.xunlei return ((((time64_t) 3775cee9645SThomas Gleixner (year/4 - year/100 + year/400 + 367*mon/12 + day) + 3785cee9645SThomas Gleixner year*365 - 719499 379ede5147dSDavid Howells )*24 + hour /* now have hours - midnight tomorrow handled here */ 3805cee9645SThomas Gleixner )*60 + min /* now have minutes */ 3815cee9645SThomas Gleixner )*60 + sec; /* finally seconds */ 3825cee9645SThomas Gleixner } 38390b6ce9cSpang.xunlei EXPORT_SYMBOL(mktime64); 3845cee9645SThomas Gleixner 3855cee9645SThomas Gleixner /** 3865cee9645SThomas Gleixner * set_normalized_timespec - set timespec sec and nsec parts and normalize 3875cee9645SThomas Gleixner * 3885cee9645SThomas Gleixner * @ts: pointer to timespec variable to be set 3895cee9645SThomas Gleixner * @sec: seconds to set 3905cee9645SThomas Gleixner * @nsec: nanoseconds to set 3915cee9645SThomas Gleixner * 3925cee9645SThomas Gleixner * Set seconds and nanoseconds field of a timespec variable and 3935cee9645SThomas Gleixner * normalize to the timespec storage format 3945cee9645SThomas Gleixner * 3955cee9645SThomas Gleixner * Note: The tv_nsec part is always in the range of 3965cee9645SThomas Gleixner * 0 <= tv_nsec < NSEC_PER_SEC 3975cee9645SThomas Gleixner * For negative values only the tv_sec field is negative ! 3985cee9645SThomas Gleixner */ 3995cee9645SThomas Gleixner void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec) 4005cee9645SThomas Gleixner { 4015cee9645SThomas Gleixner while (nsec >= NSEC_PER_SEC) { 4025cee9645SThomas Gleixner /* 4035cee9645SThomas Gleixner * The following asm() prevents the compiler from 4045cee9645SThomas Gleixner * optimising this loop into a modulo operation. See 4055cee9645SThomas Gleixner * also __iter_div_u64_rem() in include/linux/time.h 4065cee9645SThomas Gleixner */ 4075cee9645SThomas Gleixner asm("" : "+rm"(nsec)); 4085cee9645SThomas Gleixner nsec -= NSEC_PER_SEC; 4095cee9645SThomas Gleixner ++sec; 4105cee9645SThomas Gleixner } 4115cee9645SThomas Gleixner while (nsec < 0) { 4125cee9645SThomas Gleixner asm("" : "+rm"(nsec)); 4135cee9645SThomas Gleixner nsec += NSEC_PER_SEC; 4145cee9645SThomas Gleixner --sec; 4155cee9645SThomas Gleixner } 4165cee9645SThomas Gleixner ts->tv_sec = sec; 4175cee9645SThomas Gleixner ts->tv_nsec = nsec; 4185cee9645SThomas Gleixner } 4195cee9645SThomas Gleixner EXPORT_SYMBOL(set_normalized_timespec); 4205cee9645SThomas Gleixner 4215cee9645SThomas Gleixner /** 4225cee9645SThomas Gleixner * ns_to_timespec - Convert nanoseconds to timespec 4235cee9645SThomas Gleixner * @nsec: the nanoseconds value to be converted 4245cee9645SThomas Gleixner * 4255cee9645SThomas Gleixner * Returns the timespec representation of the nsec parameter. 4265cee9645SThomas Gleixner */ 4275cee9645SThomas Gleixner struct timespec ns_to_timespec(const s64 nsec) 4285cee9645SThomas Gleixner { 4295cee9645SThomas Gleixner struct timespec ts; 4305cee9645SThomas Gleixner s32 rem; 4315cee9645SThomas Gleixner 4325cee9645SThomas Gleixner if (!nsec) 4335cee9645SThomas Gleixner return (struct timespec) {0, 0}; 4345cee9645SThomas Gleixner 4355cee9645SThomas Gleixner ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem); 4365cee9645SThomas Gleixner if (unlikely(rem < 0)) { 4375cee9645SThomas Gleixner ts.tv_sec--; 4385cee9645SThomas Gleixner rem += NSEC_PER_SEC; 4395cee9645SThomas Gleixner } 4405cee9645SThomas Gleixner ts.tv_nsec = rem; 4415cee9645SThomas Gleixner 4425cee9645SThomas Gleixner return ts; 4435cee9645SThomas Gleixner } 4445cee9645SThomas Gleixner EXPORT_SYMBOL(ns_to_timespec); 4455cee9645SThomas Gleixner 4465cee9645SThomas Gleixner /** 4475cee9645SThomas Gleixner * ns_to_timeval - Convert nanoseconds to timeval 4485cee9645SThomas Gleixner * @nsec: the nanoseconds value to be converted 4495cee9645SThomas Gleixner * 4505cee9645SThomas Gleixner * Returns the timeval representation of the nsec parameter. 4515cee9645SThomas Gleixner */ 4525cee9645SThomas Gleixner struct timeval ns_to_timeval(const s64 nsec) 4535cee9645SThomas Gleixner { 4545cee9645SThomas Gleixner struct timespec ts = ns_to_timespec(nsec); 4555cee9645SThomas Gleixner struct timeval tv; 4565cee9645SThomas Gleixner 4575cee9645SThomas Gleixner tv.tv_sec = ts.tv_sec; 4585cee9645SThomas Gleixner tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000; 4595cee9645SThomas Gleixner 4605cee9645SThomas Gleixner return tv; 4615cee9645SThomas Gleixner } 4625cee9645SThomas Gleixner EXPORT_SYMBOL(ns_to_timeval); 4635cee9645SThomas Gleixner 464a84d1169SArnd Bergmann struct __kernel_old_timeval ns_to_kernel_old_timeval(const s64 nsec) 465a84d1169SArnd Bergmann { 466a84d1169SArnd Bergmann struct timespec64 ts = ns_to_timespec64(nsec); 467a84d1169SArnd Bergmann struct __kernel_old_timeval tv; 468a84d1169SArnd Bergmann 469a84d1169SArnd Bergmann tv.tv_sec = ts.tv_sec; 470a84d1169SArnd Bergmann tv.tv_usec = (suseconds_t)ts.tv_nsec / 1000; 471a84d1169SArnd Bergmann 472a84d1169SArnd Bergmann return tv; 473a84d1169SArnd Bergmann } 474a84d1169SArnd Bergmann EXPORT_SYMBOL(ns_to_kernel_old_timeval); 475a84d1169SArnd Bergmann 47649cd6f86SJohn Stultz /** 47749cd6f86SJohn Stultz * set_normalized_timespec - set timespec sec and nsec parts and normalize 47849cd6f86SJohn Stultz * 47949cd6f86SJohn Stultz * @ts: pointer to timespec variable to be set 48049cd6f86SJohn Stultz * @sec: seconds to set 48149cd6f86SJohn Stultz * @nsec: nanoseconds to set 48249cd6f86SJohn Stultz * 48349cd6f86SJohn Stultz * Set seconds and nanoseconds field of a timespec variable and 48449cd6f86SJohn Stultz * normalize to the timespec storage format 48549cd6f86SJohn Stultz * 48649cd6f86SJohn Stultz * Note: The tv_nsec part is always in the range of 48749cd6f86SJohn Stultz * 0 <= tv_nsec < NSEC_PER_SEC 48849cd6f86SJohn Stultz * For negative values only the tv_sec field is negative ! 48949cd6f86SJohn Stultz */ 49049cd6f86SJohn Stultz void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec) 49149cd6f86SJohn Stultz { 49249cd6f86SJohn Stultz while (nsec >= NSEC_PER_SEC) { 49349cd6f86SJohn Stultz /* 49449cd6f86SJohn Stultz * The following asm() prevents the compiler from 49549cd6f86SJohn Stultz * optimising this loop into a modulo operation. See 49649cd6f86SJohn Stultz * also __iter_div_u64_rem() in include/linux/time.h 49749cd6f86SJohn Stultz */ 49849cd6f86SJohn Stultz asm("" : "+rm"(nsec)); 49949cd6f86SJohn Stultz nsec -= NSEC_PER_SEC; 50049cd6f86SJohn Stultz ++sec; 50149cd6f86SJohn Stultz } 50249cd6f86SJohn Stultz while (nsec < 0) { 50349cd6f86SJohn Stultz asm("" : "+rm"(nsec)); 50449cd6f86SJohn Stultz nsec += NSEC_PER_SEC; 50549cd6f86SJohn Stultz --sec; 50649cd6f86SJohn Stultz } 50749cd6f86SJohn Stultz ts->tv_sec = sec; 50849cd6f86SJohn Stultz ts->tv_nsec = nsec; 50949cd6f86SJohn Stultz } 51049cd6f86SJohn Stultz EXPORT_SYMBOL(set_normalized_timespec64); 51149cd6f86SJohn Stultz 51249cd6f86SJohn Stultz /** 51349cd6f86SJohn Stultz * ns_to_timespec64 - Convert nanoseconds to timespec64 51449cd6f86SJohn Stultz * @nsec: the nanoseconds value to be converted 51549cd6f86SJohn Stultz * 51649cd6f86SJohn Stultz * Returns the timespec64 representation of the nsec parameter. 51749cd6f86SJohn Stultz */ 51849cd6f86SJohn Stultz struct timespec64 ns_to_timespec64(const s64 nsec) 51949cd6f86SJohn Stultz { 52049cd6f86SJohn Stultz struct timespec64 ts; 52149cd6f86SJohn Stultz s32 rem; 52249cd6f86SJohn Stultz 52349cd6f86SJohn Stultz if (!nsec) 52449cd6f86SJohn Stultz return (struct timespec64) {0, 0}; 52549cd6f86SJohn Stultz 52649cd6f86SJohn Stultz ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem); 52749cd6f86SJohn Stultz if (unlikely(rem < 0)) { 52849cd6f86SJohn Stultz ts.tv_sec--; 52949cd6f86SJohn Stultz rem += NSEC_PER_SEC; 53049cd6f86SJohn Stultz } 53149cd6f86SJohn Stultz ts.tv_nsec = rem; 53249cd6f86SJohn Stultz 53349cd6f86SJohn Stultz return ts; 53449cd6f86SJohn Stultz } 53549cd6f86SJohn Stultz EXPORT_SYMBOL(ns_to_timespec64); 536abc8f96eSArnd Bergmann 537ca42aaf0SNicholas Mc Guire /** 538ca42aaf0SNicholas Mc Guire * msecs_to_jiffies: - convert milliseconds to jiffies 539ca42aaf0SNicholas Mc Guire * @m: time in milliseconds 540ca42aaf0SNicholas Mc Guire * 541ca42aaf0SNicholas Mc Guire * conversion is done as follows: 5425cee9645SThomas Gleixner * 5435cee9645SThomas Gleixner * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET) 5445cee9645SThomas Gleixner * 5455cee9645SThomas Gleixner * - 'too large' values [that would result in larger than 5465cee9645SThomas Gleixner * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too. 5475cee9645SThomas Gleixner * 5485cee9645SThomas Gleixner * - all other values are converted to jiffies by either multiplying 549ca42aaf0SNicholas Mc Guire * the input value by a factor or dividing it with a factor and 550ca42aaf0SNicholas Mc Guire * handling any 32-bit overflows. 551ca42aaf0SNicholas Mc Guire * for the details see __msecs_to_jiffies() 5525cee9645SThomas Gleixner * 553ca42aaf0SNicholas Mc Guire * msecs_to_jiffies() checks for the passed in value being a constant 554ca42aaf0SNicholas Mc Guire * via __builtin_constant_p() allowing gcc to eliminate most of the 555ca42aaf0SNicholas Mc Guire * code, __msecs_to_jiffies() is called if the value passed does not 556ca42aaf0SNicholas Mc Guire * allow constant folding and the actual conversion must be done at 557ca42aaf0SNicholas Mc Guire * runtime. 558ca42aaf0SNicholas Mc Guire * the _msecs_to_jiffies helpers are the HZ dependent conversion 559ca42aaf0SNicholas Mc Guire * routines found in include/linux/jiffies.h 5605cee9645SThomas Gleixner */ 561ca42aaf0SNicholas Mc Guire unsigned long __msecs_to_jiffies(const unsigned int m) 5625cee9645SThomas Gleixner { 5635cee9645SThomas Gleixner /* 5645cee9645SThomas Gleixner * Negative value, means infinite timeout: 5655cee9645SThomas Gleixner */ 5665cee9645SThomas Gleixner if ((int)m < 0) 5675cee9645SThomas Gleixner return MAX_JIFFY_OFFSET; 568ca42aaf0SNicholas Mc Guire return _msecs_to_jiffies(m); 5695cee9645SThomas Gleixner } 570ca42aaf0SNicholas Mc Guire EXPORT_SYMBOL(__msecs_to_jiffies); 5715cee9645SThomas Gleixner 572ae60d6a0SNicholas Mc Guire unsigned long __usecs_to_jiffies(const unsigned int u) 5735cee9645SThomas Gleixner { 5745cee9645SThomas Gleixner if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET)) 5755cee9645SThomas Gleixner return MAX_JIFFY_OFFSET; 576ae60d6a0SNicholas Mc Guire return _usecs_to_jiffies(u); 5775cee9645SThomas Gleixner } 578ae60d6a0SNicholas Mc Guire EXPORT_SYMBOL(__usecs_to_jiffies); 5795cee9645SThomas Gleixner 5805cee9645SThomas Gleixner /* 5815cee9645SThomas Gleixner * The TICK_NSEC - 1 rounds up the value to the next resolution. Note 5825cee9645SThomas Gleixner * that a remainder subtract here would not do the right thing as the 5835cee9645SThomas Gleixner * resolution values don't fall on second boundries. I.e. the line: 5845cee9645SThomas Gleixner * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding. 585d78c9300SAndrew Hunter * Note that due to the small error in the multiplier here, this 586d78c9300SAndrew Hunter * rounding is incorrect for sufficiently large values of tv_nsec, but 587d78c9300SAndrew Hunter * well formed timespecs should have tv_nsec < NSEC_PER_SEC, so we're 588d78c9300SAndrew Hunter * OK. 5895cee9645SThomas Gleixner * 5905cee9645SThomas Gleixner * Rather, we just shift the bits off the right. 5915cee9645SThomas Gleixner * 5925cee9645SThomas Gleixner * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec 5935cee9645SThomas Gleixner * value to a scaled second value. 5945cee9645SThomas Gleixner */ 595d78c9300SAndrew Hunter static unsigned long 5969ca30850SBaolin Wang __timespec64_to_jiffies(u64 sec, long nsec) 5975cee9645SThomas Gleixner { 598d78c9300SAndrew Hunter nsec = nsec + TICK_NSEC - 1; 5995cee9645SThomas Gleixner 6005cee9645SThomas Gleixner if (sec >= MAX_SEC_IN_JIFFIES){ 6015cee9645SThomas Gleixner sec = MAX_SEC_IN_JIFFIES; 6025cee9645SThomas Gleixner nsec = 0; 6035cee9645SThomas Gleixner } 6049ca30850SBaolin Wang return ((sec * SEC_CONVERSION) + 6055cee9645SThomas Gleixner (((u64)nsec * NSEC_CONVERSION) >> 6065cee9645SThomas Gleixner (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC; 6075cee9645SThomas Gleixner 6085cee9645SThomas Gleixner } 609d78c9300SAndrew Hunter 6109ca30850SBaolin Wang static unsigned long 6119ca30850SBaolin Wang __timespec_to_jiffies(unsigned long sec, long nsec) 612d78c9300SAndrew Hunter { 6139ca30850SBaolin Wang return __timespec64_to_jiffies((u64)sec, nsec); 614d78c9300SAndrew Hunter } 615d78c9300SAndrew Hunter 6169ca30850SBaolin Wang unsigned long 6179ca30850SBaolin Wang timespec64_to_jiffies(const struct timespec64 *value) 6189ca30850SBaolin Wang { 6199ca30850SBaolin Wang return __timespec64_to_jiffies(value->tv_sec, value->tv_nsec); 6209ca30850SBaolin Wang } 6219ca30850SBaolin Wang EXPORT_SYMBOL(timespec64_to_jiffies); 6225cee9645SThomas Gleixner 6235cee9645SThomas Gleixner void 6249ca30850SBaolin Wang jiffies_to_timespec64(const unsigned long jiffies, struct timespec64 *value) 6255cee9645SThomas Gleixner { 6265cee9645SThomas Gleixner /* 6275cee9645SThomas Gleixner * Convert jiffies to nanoseconds and separate with 6285cee9645SThomas Gleixner * one divide. 6295cee9645SThomas Gleixner */ 6305cee9645SThomas Gleixner u32 rem; 6315cee9645SThomas Gleixner value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC, 6325cee9645SThomas Gleixner NSEC_PER_SEC, &rem); 6335cee9645SThomas Gleixner value->tv_nsec = rem; 6345cee9645SThomas Gleixner } 6359ca30850SBaolin Wang EXPORT_SYMBOL(jiffies_to_timespec64); 6365cee9645SThomas Gleixner 637d78c9300SAndrew Hunter /* 638d78c9300SAndrew Hunter * We could use a similar algorithm to timespec_to_jiffies (with a 639d78c9300SAndrew Hunter * different multiplier for usec instead of nsec). But this has a 640d78c9300SAndrew Hunter * problem with rounding: we can't exactly add TICK_NSEC - 1 to the 641d78c9300SAndrew Hunter * usec value, since it's not necessarily integral. 6425cee9645SThomas Gleixner * 643d78c9300SAndrew Hunter * We could instead round in the intermediate scaled representation 644d78c9300SAndrew Hunter * (i.e. in units of 1/2^(large scale) jiffies) but that's also 645d78c9300SAndrew Hunter * perilous: the scaling introduces a small positive error, which 646d78c9300SAndrew Hunter * combined with a division-rounding-upward (i.e. adding 2^(scale) - 1 647d78c9300SAndrew Hunter * units to the intermediate before shifting) leads to accidental 648d78c9300SAndrew Hunter * overflow and overestimates. 649d78c9300SAndrew Hunter * 650d78c9300SAndrew Hunter * At the cost of one additional multiplication by a constant, just 651d78c9300SAndrew Hunter * use the timespec implementation. 6525cee9645SThomas Gleixner */ 6535cee9645SThomas Gleixner unsigned long 6545cee9645SThomas Gleixner timeval_to_jiffies(const struct timeval *value) 6555cee9645SThomas Gleixner { 656d78c9300SAndrew Hunter return __timespec_to_jiffies(value->tv_sec, 657d78c9300SAndrew Hunter value->tv_usec * NSEC_PER_USEC); 6585cee9645SThomas Gleixner } 6595cee9645SThomas Gleixner EXPORT_SYMBOL(timeval_to_jiffies); 6605cee9645SThomas Gleixner 6615cee9645SThomas Gleixner void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value) 6625cee9645SThomas Gleixner { 6635cee9645SThomas Gleixner /* 6645cee9645SThomas Gleixner * Convert jiffies to nanoseconds and separate with 6655cee9645SThomas Gleixner * one divide. 6665cee9645SThomas Gleixner */ 6675cee9645SThomas Gleixner u32 rem; 6685cee9645SThomas Gleixner 6695cee9645SThomas Gleixner value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC, 6705cee9645SThomas Gleixner NSEC_PER_SEC, &rem); 6715cee9645SThomas Gleixner value->tv_usec = rem / NSEC_PER_USEC; 6725cee9645SThomas Gleixner } 6735cee9645SThomas Gleixner EXPORT_SYMBOL(jiffies_to_timeval); 6745cee9645SThomas Gleixner 6755cee9645SThomas Gleixner /* 6765cee9645SThomas Gleixner * Convert jiffies/jiffies_64 to clock_t and back. 6775cee9645SThomas Gleixner */ 6785cee9645SThomas Gleixner clock_t jiffies_to_clock_t(unsigned long x) 6795cee9645SThomas Gleixner { 6805cee9645SThomas Gleixner #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0 6815cee9645SThomas Gleixner # if HZ < USER_HZ 6825cee9645SThomas Gleixner return x * (USER_HZ / HZ); 6835cee9645SThomas Gleixner # else 6845cee9645SThomas Gleixner return x / (HZ / USER_HZ); 6855cee9645SThomas Gleixner # endif 6865cee9645SThomas Gleixner #else 6875cee9645SThomas Gleixner return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ); 6885cee9645SThomas Gleixner #endif 6895cee9645SThomas Gleixner } 6905cee9645SThomas Gleixner EXPORT_SYMBOL(jiffies_to_clock_t); 6915cee9645SThomas Gleixner 6925cee9645SThomas Gleixner unsigned long clock_t_to_jiffies(unsigned long x) 6935cee9645SThomas Gleixner { 6945cee9645SThomas Gleixner #if (HZ % USER_HZ)==0 6955cee9645SThomas Gleixner if (x >= ~0UL / (HZ / USER_HZ)) 6965cee9645SThomas Gleixner return ~0UL; 6975cee9645SThomas Gleixner return x * (HZ / USER_HZ); 6985cee9645SThomas Gleixner #else 6995cee9645SThomas Gleixner /* Don't worry about loss of precision here .. */ 7005cee9645SThomas Gleixner if (x >= ~0UL / HZ * USER_HZ) 7015cee9645SThomas Gleixner return ~0UL; 7025cee9645SThomas Gleixner 7035cee9645SThomas Gleixner /* .. but do try to contain it here */ 7045cee9645SThomas Gleixner return div_u64((u64)x * HZ, USER_HZ); 7055cee9645SThomas Gleixner #endif 7065cee9645SThomas Gleixner } 7075cee9645SThomas Gleixner EXPORT_SYMBOL(clock_t_to_jiffies); 7085cee9645SThomas Gleixner 7095cee9645SThomas Gleixner u64 jiffies_64_to_clock_t(u64 x) 7105cee9645SThomas Gleixner { 7115cee9645SThomas Gleixner #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0 7125cee9645SThomas Gleixner # if HZ < USER_HZ 7135cee9645SThomas Gleixner x = div_u64(x * USER_HZ, HZ); 7145cee9645SThomas Gleixner # elif HZ > USER_HZ 7155cee9645SThomas Gleixner x = div_u64(x, HZ / USER_HZ); 7165cee9645SThomas Gleixner # else 7175cee9645SThomas Gleixner /* Nothing to do */ 7185cee9645SThomas Gleixner # endif 7195cee9645SThomas Gleixner #else 7205cee9645SThomas Gleixner /* 7215cee9645SThomas Gleixner * There are better ways that don't overflow early, 7225cee9645SThomas Gleixner * but even this doesn't overflow in hundreds of years 7235cee9645SThomas Gleixner * in 64 bits, so.. 7245cee9645SThomas Gleixner */ 7255cee9645SThomas Gleixner x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ)); 7265cee9645SThomas Gleixner #endif 7275cee9645SThomas Gleixner return x; 7285cee9645SThomas Gleixner } 7295cee9645SThomas Gleixner EXPORT_SYMBOL(jiffies_64_to_clock_t); 7305cee9645SThomas Gleixner 7315cee9645SThomas Gleixner u64 nsec_to_clock_t(u64 x) 7325cee9645SThomas Gleixner { 7335cee9645SThomas Gleixner #if (NSEC_PER_SEC % USER_HZ) == 0 7345cee9645SThomas Gleixner return div_u64(x, NSEC_PER_SEC / USER_HZ); 7355cee9645SThomas Gleixner #elif (USER_HZ % 512) == 0 7365cee9645SThomas Gleixner return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512); 7375cee9645SThomas Gleixner #else 7385cee9645SThomas Gleixner /* 7395cee9645SThomas Gleixner * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024, 7405cee9645SThomas Gleixner * overflow after 64.99 years. 7415cee9645SThomas Gleixner * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ... 7425cee9645SThomas Gleixner */ 7435cee9645SThomas Gleixner return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ); 7445cee9645SThomas Gleixner #endif 7455cee9645SThomas Gleixner } 7465cee9645SThomas Gleixner 74707e5f5e3SFrederic Weisbecker u64 jiffies64_to_nsecs(u64 j) 74807e5f5e3SFrederic Weisbecker { 74907e5f5e3SFrederic Weisbecker #if !(NSEC_PER_SEC % HZ) 75007e5f5e3SFrederic Weisbecker return (NSEC_PER_SEC / HZ) * j; 75107e5f5e3SFrederic Weisbecker # else 75207e5f5e3SFrederic Weisbecker return div_u64(j * HZ_TO_NSEC_NUM, HZ_TO_NSEC_DEN); 75307e5f5e3SFrederic Weisbecker #endif 75407e5f5e3SFrederic Weisbecker } 75507e5f5e3SFrederic Weisbecker EXPORT_SYMBOL(jiffies64_to_nsecs); 75607e5f5e3SFrederic Weisbecker 7575cee9645SThomas Gleixner /** 7585cee9645SThomas Gleixner * nsecs_to_jiffies64 - Convert nsecs in u64 to jiffies64 7595cee9645SThomas Gleixner * 7605cee9645SThomas Gleixner * @n: nsecs in u64 7615cee9645SThomas Gleixner * 7625cee9645SThomas Gleixner * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64. 7635cee9645SThomas Gleixner * And this doesn't return MAX_JIFFY_OFFSET since this function is designed 7645cee9645SThomas Gleixner * for scheduler, not for use in device drivers to calculate timeout value. 7655cee9645SThomas Gleixner * 7665cee9645SThomas Gleixner * note: 7675cee9645SThomas Gleixner * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512) 7685cee9645SThomas Gleixner * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years 7695cee9645SThomas Gleixner */ 7705cee9645SThomas Gleixner u64 nsecs_to_jiffies64(u64 n) 7715cee9645SThomas Gleixner { 7725cee9645SThomas Gleixner #if (NSEC_PER_SEC % HZ) == 0 7735cee9645SThomas Gleixner /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */ 7745cee9645SThomas Gleixner return div_u64(n, NSEC_PER_SEC / HZ); 7755cee9645SThomas Gleixner #elif (HZ % 512) == 0 7765cee9645SThomas Gleixner /* overflow after 292 years if HZ = 1024 */ 7775cee9645SThomas Gleixner return div_u64(n * HZ / 512, NSEC_PER_SEC / 512); 7785cee9645SThomas Gleixner #else 7795cee9645SThomas Gleixner /* 7805cee9645SThomas Gleixner * Generic case - optimized for cases where HZ is a multiple of 3. 7815cee9645SThomas Gleixner * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc. 7825cee9645SThomas Gleixner */ 7835cee9645SThomas Gleixner return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ); 7845cee9645SThomas Gleixner #endif 7855cee9645SThomas Gleixner } 7867bd0e226SDaniel Vetter EXPORT_SYMBOL(nsecs_to_jiffies64); 7875cee9645SThomas Gleixner 7885cee9645SThomas Gleixner /** 7895cee9645SThomas Gleixner * nsecs_to_jiffies - Convert nsecs in u64 to jiffies 7905cee9645SThomas Gleixner * 7915cee9645SThomas Gleixner * @n: nsecs in u64 7925cee9645SThomas Gleixner * 7935cee9645SThomas Gleixner * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64. 7945cee9645SThomas Gleixner * And this doesn't return MAX_JIFFY_OFFSET since this function is designed 7955cee9645SThomas Gleixner * for scheduler, not for use in device drivers to calculate timeout value. 7965cee9645SThomas Gleixner * 7975cee9645SThomas Gleixner * note: 7985cee9645SThomas Gleixner * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512) 7995cee9645SThomas Gleixner * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years 8005cee9645SThomas Gleixner */ 8015cee9645SThomas Gleixner unsigned long nsecs_to_jiffies(u64 n) 8025cee9645SThomas Gleixner { 8035cee9645SThomas Gleixner return (unsigned long)nsecs_to_jiffies64(n); 8045cee9645SThomas Gleixner } 805d560fed6SThomas Gleixner EXPORT_SYMBOL_GPL(nsecs_to_jiffies); 8065cee9645SThomas Gleixner 8075cee9645SThomas Gleixner /* 808bc2c53e5SDeepa Dinamani * Add two timespec64 values and do a safety check for overflow. 809bc2c53e5SDeepa Dinamani * It's assumed that both values are valid (>= 0). 810bc2c53e5SDeepa Dinamani * And, each timespec64 is in normalized form. 811bc2c53e5SDeepa Dinamani */ 812bc2c53e5SDeepa Dinamani struct timespec64 timespec64_add_safe(const struct timespec64 lhs, 813bc2c53e5SDeepa Dinamani const struct timespec64 rhs) 814bc2c53e5SDeepa Dinamani { 815bc2c53e5SDeepa Dinamani struct timespec64 res; 816bc2c53e5SDeepa Dinamani 817469e857fSVegard Nossum set_normalized_timespec64(&res, (timeu64_t) lhs.tv_sec + rhs.tv_sec, 818bc2c53e5SDeepa Dinamani lhs.tv_nsec + rhs.tv_nsec); 819bc2c53e5SDeepa Dinamani 820bc2c53e5SDeepa Dinamani if (unlikely(res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)) { 821bc2c53e5SDeepa Dinamani res.tv_sec = TIME64_MAX; 822bc2c53e5SDeepa Dinamani res.tv_nsec = 0; 823bc2c53e5SDeepa Dinamani } 824bc2c53e5SDeepa Dinamani 825bc2c53e5SDeepa Dinamani return res; 826bc2c53e5SDeepa Dinamani } 827f59dd9c8SDeepa Dinamani 828f59dd9c8SDeepa Dinamani int get_timespec64(struct timespec64 *ts, 829ea2ce8f3SDeepa Dinamani const struct __kernel_timespec __user *uts) 830f59dd9c8SDeepa Dinamani { 831ea2ce8f3SDeepa Dinamani struct __kernel_timespec kts; 832f59dd9c8SDeepa Dinamani int ret; 833f59dd9c8SDeepa Dinamani 834f59dd9c8SDeepa Dinamani ret = copy_from_user(&kts, uts, sizeof(kts)); 835f59dd9c8SDeepa Dinamani if (ret) 836f59dd9c8SDeepa Dinamani return -EFAULT; 837f59dd9c8SDeepa Dinamani 838f59dd9c8SDeepa Dinamani ts->tv_sec = kts.tv_sec; 839ea2ce8f3SDeepa Dinamani 840ea2ce8f3SDeepa Dinamani /* Zero out the padding for 32 bit systems or in compat mode */ 84198f76206SDmitry Safonov if (IS_ENABLED(CONFIG_64BIT_TIME) && in_compat_syscall()) 842ea2ce8f3SDeepa Dinamani kts.tv_nsec &= 0xFFFFFFFFUL; 843ea2ce8f3SDeepa Dinamani 844f59dd9c8SDeepa Dinamani ts->tv_nsec = kts.tv_nsec; 845f59dd9c8SDeepa Dinamani 846f59dd9c8SDeepa Dinamani return 0; 847f59dd9c8SDeepa Dinamani } 848f59dd9c8SDeepa Dinamani EXPORT_SYMBOL_GPL(get_timespec64); 849f59dd9c8SDeepa Dinamani 850f59dd9c8SDeepa Dinamani int put_timespec64(const struct timespec64 *ts, 851ea2ce8f3SDeepa Dinamani struct __kernel_timespec __user *uts) 852f59dd9c8SDeepa Dinamani { 853ea2ce8f3SDeepa Dinamani struct __kernel_timespec kts = { 854f59dd9c8SDeepa Dinamani .tv_sec = ts->tv_sec, 855f59dd9c8SDeepa Dinamani .tv_nsec = ts->tv_nsec 856f59dd9c8SDeepa Dinamani }; 857ea2ce8f3SDeepa Dinamani 858f59dd9c8SDeepa Dinamani return copy_to_user(uts, &kts, sizeof(kts)) ? -EFAULT : 0; 859f59dd9c8SDeepa Dinamani } 860f59dd9c8SDeepa Dinamani EXPORT_SYMBOL_GPL(put_timespec64); 861d5b7ffbfSDeepa Dinamani 862743f5cdbSkbuild test robot static int __get_old_timespec32(struct timespec64 *ts64, 8639afc5eeeSArnd Bergmann const struct old_timespec32 __user *cts) 8641c68adf6SDeepa Dinamani { 8659afc5eeeSArnd Bergmann struct old_timespec32 ts; 8661c68adf6SDeepa Dinamani int ret; 8671c68adf6SDeepa Dinamani 8681c68adf6SDeepa Dinamani ret = copy_from_user(&ts, cts, sizeof(ts)); 8691c68adf6SDeepa Dinamani if (ret) 8701c68adf6SDeepa Dinamani return -EFAULT; 8711c68adf6SDeepa Dinamani 8721c68adf6SDeepa Dinamani ts64->tv_sec = ts.tv_sec; 8731c68adf6SDeepa Dinamani ts64->tv_nsec = ts.tv_nsec; 8741c68adf6SDeepa Dinamani 8751c68adf6SDeepa Dinamani return 0; 8761c68adf6SDeepa Dinamani } 8771c68adf6SDeepa Dinamani 878743f5cdbSkbuild test robot static int __put_old_timespec32(const struct timespec64 *ts64, 8799afc5eeeSArnd Bergmann struct old_timespec32 __user *cts) 8801c68adf6SDeepa Dinamani { 8819afc5eeeSArnd Bergmann struct old_timespec32 ts = { 8821c68adf6SDeepa Dinamani .tv_sec = ts64->tv_sec, 8831c68adf6SDeepa Dinamani .tv_nsec = ts64->tv_nsec 8841c68adf6SDeepa Dinamani }; 8851c68adf6SDeepa Dinamani return copy_to_user(cts, &ts, sizeof(ts)) ? -EFAULT : 0; 8861c68adf6SDeepa Dinamani } 8871c68adf6SDeepa Dinamani 8889afc5eeeSArnd Bergmann int get_old_timespec32(struct timespec64 *ts, const void __user *uts) 8891c68adf6SDeepa Dinamani { 8901c68adf6SDeepa Dinamani if (COMPAT_USE_64BIT_TIME) 8911c68adf6SDeepa Dinamani return copy_from_user(ts, uts, sizeof(*ts)) ? -EFAULT : 0; 8921c68adf6SDeepa Dinamani else 8939afc5eeeSArnd Bergmann return __get_old_timespec32(ts, uts); 8941c68adf6SDeepa Dinamani } 8959afc5eeeSArnd Bergmann EXPORT_SYMBOL_GPL(get_old_timespec32); 8961c68adf6SDeepa Dinamani 8979afc5eeeSArnd Bergmann int put_old_timespec32(const struct timespec64 *ts, void __user *uts) 8981c68adf6SDeepa Dinamani { 8991c68adf6SDeepa Dinamani if (COMPAT_USE_64BIT_TIME) 9001c68adf6SDeepa Dinamani return copy_to_user(uts, ts, sizeof(*ts)) ? -EFAULT : 0; 9011c68adf6SDeepa Dinamani else 9029afc5eeeSArnd Bergmann return __put_old_timespec32(ts, uts); 9031c68adf6SDeepa Dinamani } 9049afc5eeeSArnd Bergmann EXPORT_SYMBOL_GPL(put_old_timespec32); 9051c68adf6SDeepa Dinamani 906d5b7ffbfSDeepa Dinamani int get_itimerspec64(struct itimerspec64 *it, 907d0dd63a8SDeepa Dinamani const struct __kernel_itimerspec __user *uit) 908d5b7ffbfSDeepa Dinamani { 909d5b7ffbfSDeepa Dinamani int ret; 910d5b7ffbfSDeepa Dinamani 911d5b7ffbfSDeepa Dinamani ret = get_timespec64(&it->it_interval, &uit->it_interval); 912d5b7ffbfSDeepa Dinamani if (ret) 913d5b7ffbfSDeepa Dinamani return ret; 914d5b7ffbfSDeepa Dinamani 915d5b7ffbfSDeepa Dinamani ret = get_timespec64(&it->it_value, &uit->it_value); 916d5b7ffbfSDeepa Dinamani 917d5b7ffbfSDeepa Dinamani return ret; 918d5b7ffbfSDeepa Dinamani } 919d5b7ffbfSDeepa Dinamani EXPORT_SYMBOL_GPL(get_itimerspec64); 920d5b7ffbfSDeepa Dinamani 921d5b7ffbfSDeepa Dinamani int put_itimerspec64(const struct itimerspec64 *it, 922d0dd63a8SDeepa Dinamani struct __kernel_itimerspec __user *uit) 923d5b7ffbfSDeepa Dinamani { 924d5b7ffbfSDeepa Dinamani int ret; 925d5b7ffbfSDeepa Dinamani 926d5b7ffbfSDeepa Dinamani ret = put_timespec64(&it->it_interval, &uit->it_interval); 927d5b7ffbfSDeepa Dinamani if (ret) 928d5b7ffbfSDeepa Dinamani return ret; 929d5b7ffbfSDeepa Dinamani 930d5b7ffbfSDeepa Dinamani ret = put_timespec64(&it->it_value, &uit->it_value); 931d5b7ffbfSDeepa Dinamani 932d5b7ffbfSDeepa Dinamani return ret; 933d5b7ffbfSDeepa Dinamani } 934d5b7ffbfSDeepa Dinamani EXPORT_SYMBOL_GPL(put_itimerspec64); 935afef05cfSDeepa Dinamani 9369afc5eeeSArnd Bergmann int get_old_itimerspec32(struct itimerspec64 *its, 9379afc5eeeSArnd Bergmann const struct old_itimerspec32 __user *uits) 938afef05cfSDeepa Dinamani { 939afef05cfSDeepa Dinamani 9409afc5eeeSArnd Bergmann if (__get_old_timespec32(&its->it_interval, &uits->it_interval) || 9419afc5eeeSArnd Bergmann __get_old_timespec32(&its->it_value, &uits->it_value)) 942afef05cfSDeepa Dinamani return -EFAULT; 943afef05cfSDeepa Dinamani return 0; 944afef05cfSDeepa Dinamani } 9459afc5eeeSArnd Bergmann EXPORT_SYMBOL_GPL(get_old_itimerspec32); 946afef05cfSDeepa Dinamani 9479afc5eeeSArnd Bergmann int put_old_itimerspec32(const struct itimerspec64 *its, 9489afc5eeeSArnd Bergmann struct old_itimerspec32 __user *uits) 949afef05cfSDeepa Dinamani { 9509afc5eeeSArnd Bergmann if (__put_old_timespec32(&its->it_interval, &uits->it_interval) || 9519afc5eeeSArnd Bergmann __put_old_timespec32(&its->it_value, &uits->it_value)) 952afef05cfSDeepa Dinamani return -EFAULT; 953afef05cfSDeepa Dinamani return 0; 954afef05cfSDeepa Dinamani } 9559afc5eeeSArnd Bergmann EXPORT_SYMBOL_GPL(put_old_itimerspec32); 956