15cee9645SThomas Gleixner /* 25cee9645SThomas Gleixner * linux/kernel/time.c 35cee9645SThomas Gleixner * 45cee9645SThomas Gleixner * Copyright (C) 1991, 1992 Linus Torvalds 55cee9645SThomas Gleixner * 65cee9645SThomas Gleixner * This file contains the interface functions for the various 75cee9645SThomas Gleixner * time related system calls: time, stime, gettimeofday, settimeofday, 85cee9645SThomas Gleixner * adjtime 95cee9645SThomas Gleixner */ 105cee9645SThomas Gleixner /* 115cee9645SThomas Gleixner * Modification history kernel/time.c 125cee9645SThomas Gleixner * 135cee9645SThomas Gleixner * 1993-09-02 Philip Gladstone 145cee9645SThomas Gleixner * Created file with time related functions from sched/core.c and adjtimex() 155cee9645SThomas Gleixner * 1993-10-08 Torsten Duwe 165cee9645SThomas Gleixner * adjtime interface update and CMOS clock write code 175cee9645SThomas Gleixner * 1995-08-13 Torsten Duwe 185cee9645SThomas Gleixner * kernel PLL updated to 1994-12-13 specs (rfc-1589) 195cee9645SThomas Gleixner * 1999-01-16 Ulrich Windl 205cee9645SThomas Gleixner * Introduced error checking for many cases in adjtimex(). 215cee9645SThomas Gleixner * Updated NTP code according to technical memorandum Jan '96 225cee9645SThomas Gleixner * "A Kernel Model for Precision Timekeeping" by Dave Mills 235cee9645SThomas Gleixner * Allow time_constant larger than MAXTC(6) for NTP v4 (MAXTC == 10) 245cee9645SThomas Gleixner * (Even though the technical memorandum forbids it) 255cee9645SThomas Gleixner * 2004-07-14 Christoph Lameter 265cee9645SThomas Gleixner * Added getnstimeofday to allow the posix timer functions to return 275cee9645SThomas Gleixner * with nanosecond accuracy 285cee9645SThomas Gleixner */ 295cee9645SThomas Gleixner 305cee9645SThomas Gleixner #include <linux/export.h> 315cee9645SThomas Gleixner #include <linux/timex.h> 325cee9645SThomas Gleixner #include <linux/capability.h> 335cee9645SThomas Gleixner #include <linux/timekeeper_internal.h> 345cee9645SThomas Gleixner #include <linux/errno.h> 355cee9645SThomas Gleixner #include <linux/syscalls.h> 365cee9645SThomas Gleixner #include <linux/security.h> 375cee9645SThomas Gleixner #include <linux/fs.h> 385cee9645SThomas Gleixner #include <linux/math64.h> 395cee9645SThomas Gleixner #include <linux/ptrace.h> 405cee9645SThomas Gleixner 415cee9645SThomas Gleixner #include <asm/uaccess.h> 425cee9645SThomas Gleixner #include <asm/unistd.h> 435cee9645SThomas Gleixner 445cee9645SThomas Gleixner #include "timeconst.h" 458b094cd0SThomas Gleixner #include "timekeeping.h" 465cee9645SThomas Gleixner 475cee9645SThomas Gleixner /* 485cee9645SThomas Gleixner * The timezone where the local system is located. Used as a default by some 495cee9645SThomas Gleixner * programs who obtain this value by using gettimeofday. 505cee9645SThomas Gleixner */ 515cee9645SThomas Gleixner struct timezone sys_tz; 525cee9645SThomas Gleixner 535cee9645SThomas Gleixner EXPORT_SYMBOL(sys_tz); 545cee9645SThomas Gleixner 555cee9645SThomas Gleixner #ifdef __ARCH_WANT_SYS_TIME 565cee9645SThomas Gleixner 575cee9645SThomas Gleixner /* 585cee9645SThomas Gleixner * sys_time() can be implemented in user-level using 595cee9645SThomas Gleixner * sys_gettimeofday(). Is this for backwards compatibility? If so, 605cee9645SThomas Gleixner * why not move it into the appropriate arch directory (for those 615cee9645SThomas Gleixner * architectures that need it). 625cee9645SThomas Gleixner */ 635cee9645SThomas Gleixner SYSCALL_DEFINE1(time, time_t __user *, tloc) 645cee9645SThomas Gleixner { 655cee9645SThomas Gleixner time_t i = get_seconds(); 665cee9645SThomas Gleixner 675cee9645SThomas Gleixner if (tloc) { 685cee9645SThomas Gleixner if (put_user(i,tloc)) 695cee9645SThomas Gleixner return -EFAULT; 705cee9645SThomas Gleixner } 715cee9645SThomas Gleixner force_successful_syscall_return(); 725cee9645SThomas Gleixner return i; 735cee9645SThomas Gleixner } 745cee9645SThomas Gleixner 755cee9645SThomas Gleixner /* 765cee9645SThomas Gleixner * sys_stime() can be implemented in user-level using 775cee9645SThomas Gleixner * sys_settimeofday(). Is this for backwards compatibility? If so, 785cee9645SThomas Gleixner * why not move it into the appropriate arch directory (for those 795cee9645SThomas Gleixner * architectures that need it). 805cee9645SThomas Gleixner */ 815cee9645SThomas Gleixner 825cee9645SThomas Gleixner SYSCALL_DEFINE1(stime, time_t __user *, tptr) 835cee9645SThomas Gleixner { 845cee9645SThomas Gleixner struct timespec tv; 855cee9645SThomas Gleixner int err; 865cee9645SThomas Gleixner 875cee9645SThomas Gleixner if (get_user(tv.tv_sec, tptr)) 885cee9645SThomas Gleixner return -EFAULT; 895cee9645SThomas Gleixner 905cee9645SThomas Gleixner tv.tv_nsec = 0; 915cee9645SThomas Gleixner 925cee9645SThomas Gleixner err = security_settime(&tv, NULL); 935cee9645SThomas Gleixner if (err) 945cee9645SThomas Gleixner return err; 955cee9645SThomas Gleixner 965cee9645SThomas Gleixner do_settimeofday(&tv); 975cee9645SThomas Gleixner return 0; 985cee9645SThomas Gleixner } 995cee9645SThomas Gleixner 1005cee9645SThomas Gleixner #endif /* __ARCH_WANT_SYS_TIME */ 1015cee9645SThomas Gleixner 1025cee9645SThomas Gleixner SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv, 1035cee9645SThomas Gleixner struct timezone __user *, tz) 1045cee9645SThomas Gleixner { 1055cee9645SThomas Gleixner if (likely(tv != NULL)) { 1065cee9645SThomas Gleixner struct timeval ktv; 1075cee9645SThomas Gleixner do_gettimeofday(&ktv); 1085cee9645SThomas Gleixner if (copy_to_user(tv, &ktv, sizeof(ktv))) 1095cee9645SThomas Gleixner return -EFAULT; 1105cee9645SThomas Gleixner } 1115cee9645SThomas Gleixner if (unlikely(tz != NULL)) { 1125cee9645SThomas Gleixner if (copy_to_user(tz, &sys_tz, sizeof(sys_tz))) 1135cee9645SThomas Gleixner return -EFAULT; 1145cee9645SThomas Gleixner } 1155cee9645SThomas Gleixner return 0; 1165cee9645SThomas Gleixner } 1175cee9645SThomas Gleixner 1185cee9645SThomas Gleixner /* 1195cee9645SThomas Gleixner * Indicates if there is an offset between the system clock and the hardware 1205cee9645SThomas Gleixner * clock/persistent clock/rtc. 1215cee9645SThomas Gleixner */ 1225cee9645SThomas Gleixner int persistent_clock_is_local; 1235cee9645SThomas Gleixner 1245cee9645SThomas Gleixner /* 1255cee9645SThomas Gleixner * Adjust the time obtained from the CMOS to be UTC time instead of 1265cee9645SThomas Gleixner * local time. 1275cee9645SThomas Gleixner * 1285cee9645SThomas Gleixner * This is ugly, but preferable to the alternatives. Otherwise we 1295cee9645SThomas Gleixner * would either need to write a program to do it in /etc/rc (and risk 1305cee9645SThomas Gleixner * confusion if the program gets run more than once; it would also be 1315cee9645SThomas Gleixner * hard to make the program warp the clock precisely n hours) or 1325cee9645SThomas Gleixner * compile in the timezone information into the kernel. Bad, bad.... 1335cee9645SThomas Gleixner * 1345cee9645SThomas Gleixner * - TYT, 1992-01-01 1355cee9645SThomas Gleixner * 1365cee9645SThomas Gleixner * The best thing to do is to keep the CMOS clock in universal time (UTC) 1375cee9645SThomas Gleixner * as real UNIX machines always do it. This avoids all headaches about 1385cee9645SThomas Gleixner * daylight saving times and warping kernel clocks. 1395cee9645SThomas Gleixner */ 1405cee9645SThomas Gleixner static inline void warp_clock(void) 1415cee9645SThomas Gleixner { 1425cee9645SThomas Gleixner if (sys_tz.tz_minuteswest != 0) { 1435cee9645SThomas Gleixner struct timespec adjust; 1445cee9645SThomas Gleixner 1455cee9645SThomas Gleixner persistent_clock_is_local = 1; 1465cee9645SThomas Gleixner adjust.tv_sec = sys_tz.tz_minuteswest * 60; 1475cee9645SThomas Gleixner adjust.tv_nsec = 0; 1485cee9645SThomas Gleixner timekeeping_inject_offset(&adjust); 1495cee9645SThomas Gleixner } 1505cee9645SThomas Gleixner } 1515cee9645SThomas Gleixner 1525cee9645SThomas Gleixner /* 1535cee9645SThomas Gleixner * In case for some reason the CMOS clock has not already been running 1545cee9645SThomas Gleixner * in UTC, but in some local time: The first time we set the timezone, 1555cee9645SThomas Gleixner * we will warp the clock so that it is ticking UTC time instead of 1565cee9645SThomas Gleixner * local time. Presumably, if someone is setting the timezone then we 1575cee9645SThomas Gleixner * are running in an environment where the programs understand about 1585cee9645SThomas Gleixner * timezones. This should be done at boot time in the /etc/rc script, 1595cee9645SThomas Gleixner * as soon as possible, so that the clock can be set right. Otherwise, 1605cee9645SThomas Gleixner * various programs will get confused when the clock gets warped. 1615cee9645SThomas Gleixner */ 1625cee9645SThomas Gleixner 1635cee9645SThomas Gleixner int do_sys_settimeofday(const struct timespec *tv, const struct timezone *tz) 1645cee9645SThomas Gleixner { 1655cee9645SThomas Gleixner static int firsttime = 1; 1665cee9645SThomas Gleixner int error = 0; 1675cee9645SThomas Gleixner 1685cee9645SThomas Gleixner if (tv && !timespec_valid(tv)) 1695cee9645SThomas Gleixner return -EINVAL; 1705cee9645SThomas Gleixner 1715cee9645SThomas Gleixner error = security_settime(tv, tz); 1725cee9645SThomas Gleixner if (error) 1735cee9645SThomas Gleixner return error; 1745cee9645SThomas Gleixner 1755cee9645SThomas Gleixner if (tz) { 1765cee9645SThomas Gleixner sys_tz = *tz; 1775cee9645SThomas Gleixner update_vsyscall_tz(); 1785cee9645SThomas Gleixner if (firsttime) { 1795cee9645SThomas Gleixner firsttime = 0; 1805cee9645SThomas Gleixner if (!tv) 1815cee9645SThomas Gleixner warp_clock(); 1825cee9645SThomas Gleixner } 1835cee9645SThomas Gleixner } 1845cee9645SThomas Gleixner if (tv) 1855cee9645SThomas Gleixner return do_settimeofday(tv); 1865cee9645SThomas Gleixner return 0; 1875cee9645SThomas Gleixner } 1885cee9645SThomas Gleixner 1895cee9645SThomas Gleixner SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv, 1905cee9645SThomas Gleixner struct timezone __user *, tz) 1915cee9645SThomas Gleixner { 1925cee9645SThomas Gleixner struct timeval user_tv; 1935cee9645SThomas Gleixner struct timespec new_ts; 1945cee9645SThomas Gleixner struct timezone new_tz; 1955cee9645SThomas Gleixner 1965cee9645SThomas Gleixner if (tv) { 1975cee9645SThomas Gleixner if (copy_from_user(&user_tv, tv, sizeof(*tv))) 1985cee9645SThomas Gleixner return -EFAULT; 1996ada1fc0SSasha Levin 2006ada1fc0SSasha Levin if (!timeval_valid(&user_tv)) 2016ada1fc0SSasha Levin return -EINVAL; 2026ada1fc0SSasha Levin 2035cee9645SThomas Gleixner new_ts.tv_sec = user_tv.tv_sec; 2045cee9645SThomas Gleixner new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC; 2055cee9645SThomas Gleixner } 2065cee9645SThomas Gleixner if (tz) { 2075cee9645SThomas Gleixner if (copy_from_user(&new_tz, tz, sizeof(*tz))) 2085cee9645SThomas Gleixner return -EFAULT; 2095cee9645SThomas Gleixner } 2105cee9645SThomas Gleixner 2115cee9645SThomas Gleixner return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL); 2125cee9645SThomas Gleixner } 2135cee9645SThomas Gleixner 2145cee9645SThomas Gleixner SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p) 2155cee9645SThomas Gleixner { 2165cee9645SThomas Gleixner struct timex txc; /* Local copy of parameter */ 2175cee9645SThomas Gleixner int ret; 2185cee9645SThomas Gleixner 2195cee9645SThomas Gleixner /* Copy the user data space into the kernel copy 2205cee9645SThomas Gleixner * structure. But bear in mind that the structures 2215cee9645SThomas Gleixner * may change 2225cee9645SThomas Gleixner */ 2235cee9645SThomas Gleixner if(copy_from_user(&txc, txc_p, sizeof(struct timex))) 2245cee9645SThomas Gleixner return -EFAULT; 2255cee9645SThomas Gleixner ret = do_adjtimex(&txc); 2265cee9645SThomas Gleixner return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret; 2275cee9645SThomas Gleixner } 2285cee9645SThomas Gleixner 2295cee9645SThomas Gleixner /** 2305cee9645SThomas Gleixner * current_fs_time - Return FS time 2315cee9645SThomas Gleixner * @sb: Superblock. 2325cee9645SThomas Gleixner * 2335cee9645SThomas Gleixner * Return the current time truncated to the time granularity supported by 2345cee9645SThomas Gleixner * the fs. 2355cee9645SThomas Gleixner */ 2365cee9645SThomas Gleixner struct timespec current_fs_time(struct super_block *sb) 2375cee9645SThomas Gleixner { 2385cee9645SThomas Gleixner struct timespec now = current_kernel_time(); 2395cee9645SThomas Gleixner return timespec_trunc(now, sb->s_time_gran); 2405cee9645SThomas Gleixner } 2415cee9645SThomas Gleixner EXPORT_SYMBOL(current_fs_time); 2425cee9645SThomas Gleixner 2435cee9645SThomas Gleixner /* 2445cee9645SThomas Gleixner * Convert jiffies to milliseconds and back. 2455cee9645SThomas Gleixner * 2465cee9645SThomas Gleixner * Avoid unnecessary multiplications/divisions in the 2475cee9645SThomas Gleixner * two most common HZ cases: 2485cee9645SThomas Gleixner */ 2495cee9645SThomas Gleixner unsigned int jiffies_to_msecs(const unsigned long j) 2505cee9645SThomas Gleixner { 2515cee9645SThomas Gleixner #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ) 2525cee9645SThomas Gleixner return (MSEC_PER_SEC / HZ) * j; 2535cee9645SThomas Gleixner #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC) 2545cee9645SThomas Gleixner return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC); 2555cee9645SThomas Gleixner #else 2565cee9645SThomas Gleixner # if BITS_PER_LONG == 32 2575cee9645SThomas Gleixner return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32; 2585cee9645SThomas Gleixner # else 2595cee9645SThomas Gleixner return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN; 2605cee9645SThomas Gleixner # endif 2615cee9645SThomas Gleixner #endif 2625cee9645SThomas Gleixner } 2635cee9645SThomas Gleixner EXPORT_SYMBOL(jiffies_to_msecs); 2645cee9645SThomas Gleixner 2655cee9645SThomas Gleixner unsigned int jiffies_to_usecs(const unsigned long j) 2665cee9645SThomas Gleixner { 2675cee9645SThomas Gleixner #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ) 2685cee9645SThomas Gleixner return (USEC_PER_SEC / HZ) * j; 2695cee9645SThomas Gleixner #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC) 2705cee9645SThomas Gleixner return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC); 2715cee9645SThomas Gleixner #else 2725cee9645SThomas Gleixner # if BITS_PER_LONG == 32 2735cee9645SThomas Gleixner return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32; 2745cee9645SThomas Gleixner # else 2755cee9645SThomas Gleixner return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN; 2765cee9645SThomas Gleixner # endif 2775cee9645SThomas Gleixner #endif 2785cee9645SThomas Gleixner } 2795cee9645SThomas Gleixner EXPORT_SYMBOL(jiffies_to_usecs); 2805cee9645SThomas Gleixner 2815cee9645SThomas Gleixner /** 2825cee9645SThomas Gleixner * timespec_trunc - Truncate timespec to a granularity 2835cee9645SThomas Gleixner * @t: Timespec 2845cee9645SThomas Gleixner * @gran: Granularity in ns. 2855cee9645SThomas Gleixner * 2865cee9645SThomas Gleixner * Truncate a timespec to a granularity. gran must be smaller than a second. 2875cee9645SThomas Gleixner * Always rounds down. 2885cee9645SThomas Gleixner * 2895cee9645SThomas Gleixner * This function should be only used for timestamps returned by 2905cee9645SThomas Gleixner * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because 2915cee9645SThomas Gleixner * it doesn't handle the better resolution of the latter. 2925cee9645SThomas Gleixner */ 2935cee9645SThomas Gleixner struct timespec timespec_trunc(struct timespec t, unsigned gran) 2945cee9645SThomas Gleixner { 2955cee9645SThomas Gleixner /* 2965cee9645SThomas Gleixner * Division is pretty slow so avoid it for common cases. 2975cee9645SThomas Gleixner * Currently current_kernel_time() never returns better than 2985cee9645SThomas Gleixner * jiffies resolution. Exploit that. 2995cee9645SThomas Gleixner */ 3005cee9645SThomas Gleixner if (gran <= jiffies_to_usecs(1) * 1000) { 3015cee9645SThomas Gleixner /* nothing */ 3025cee9645SThomas Gleixner } else if (gran == 1000000000) { 3035cee9645SThomas Gleixner t.tv_nsec = 0; 3045cee9645SThomas Gleixner } else { 3055cee9645SThomas Gleixner t.tv_nsec -= t.tv_nsec % gran; 3065cee9645SThomas Gleixner } 3075cee9645SThomas Gleixner return t; 3085cee9645SThomas Gleixner } 3095cee9645SThomas Gleixner EXPORT_SYMBOL(timespec_trunc); 3105cee9645SThomas Gleixner 3115cee9645SThomas Gleixner /* Converts Gregorian date to seconds since 1970-01-01 00:00:00. 3125cee9645SThomas Gleixner * Assumes input in normal date format, i.e. 1980-12-31 23:59:59 3135cee9645SThomas Gleixner * => year=1980, mon=12, day=31, hour=23, min=59, sec=59. 3145cee9645SThomas Gleixner * 3155cee9645SThomas Gleixner * [For the Julian calendar (which was used in Russia before 1917, 3165cee9645SThomas Gleixner * Britain & colonies before 1752, anywhere else before 1582, 3175cee9645SThomas Gleixner * and is still in use by some communities) leave out the 3185cee9645SThomas Gleixner * -year/100+year/400 terms, and add 10.] 3195cee9645SThomas Gleixner * 3205cee9645SThomas Gleixner * This algorithm was first published by Gauss (I think). 3215cee9645SThomas Gleixner * 3225cee9645SThomas Gleixner * WARNING: this function will overflow on 2106-02-07 06:28:16 on 3235cee9645SThomas Gleixner * machines where long is 32-bit! (However, as time_t is signed, we 3245cee9645SThomas Gleixner * will already get problems at other places on 2038-01-19 03:14:08) 3255cee9645SThomas Gleixner */ 3265cee9645SThomas Gleixner unsigned long 3275cee9645SThomas Gleixner mktime(const unsigned int year0, const unsigned int mon0, 3285cee9645SThomas Gleixner const unsigned int day, const unsigned int hour, 3295cee9645SThomas Gleixner const unsigned int min, const unsigned int sec) 3305cee9645SThomas Gleixner { 3315cee9645SThomas Gleixner unsigned int mon = mon0, year = year0; 3325cee9645SThomas Gleixner 3335cee9645SThomas Gleixner /* 1..12 -> 11,12,1..10 */ 3345cee9645SThomas Gleixner if (0 >= (int) (mon -= 2)) { 3355cee9645SThomas Gleixner mon += 12; /* Puts Feb last since it has leap day */ 3365cee9645SThomas Gleixner year -= 1; 3375cee9645SThomas Gleixner } 3385cee9645SThomas Gleixner 3395cee9645SThomas Gleixner return ((((unsigned long) 3405cee9645SThomas Gleixner (year/4 - year/100 + year/400 + 367*mon/12 + day) + 3415cee9645SThomas Gleixner year*365 - 719499 3425cee9645SThomas Gleixner )*24 + hour /* now have hours */ 3435cee9645SThomas Gleixner )*60 + min /* now have minutes */ 3445cee9645SThomas Gleixner )*60 + sec; /* finally seconds */ 3455cee9645SThomas Gleixner } 3465cee9645SThomas Gleixner 3475cee9645SThomas Gleixner EXPORT_SYMBOL(mktime); 3485cee9645SThomas Gleixner 3495cee9645SThomas Gleixner /** 3505cee9645SThomas Gleixner * set_normalized_timespec - set timespec sec and nsec parts and normalize 3515cee9645SThomas Gleixner * 3525cee9645SThomas Gleixner * @ts: pointer to timespec variable to be set 3535cee9645SThomas Gleixner * @sec: seconds to set 3545cee9645SThomas Gleixner * @nsec: nanoseconds to set 3555cee9645SThomas Gleixner * 3565cee9645SThomas Gleixner * Set seconds and nanoseconds field of a timespec variable and 3575cee9645SThomas Gleixner * normalize to the timespec storage format 3585cee9645SThomas Gleixner * 3595cee9645SThomas Gleixner * Note: The tv_nsec part is always in the range of 3605cee9645SThomas Gleixner * 0 <= tv_nsec < NSEC_PER_SEC 3615cee9645SThomas Gleixner * For negative values only the tv_sec field is negative ! 3625cee9645SThomas Gleixner */ 3635cee9645SThomas Gleixner void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec) 3645cee9645SThomas Gleixner { 3655cee9645SThomas Gleixner while (nsec >= NSEC_PER_SEC) { 3665cee9645SThomas Gleixner /* 3675cee9645SThomas Gleixner * The following asm() prevents the compiler from 3685cee9645SThomas Gleixner * optimising this loop into a modulo operation. See 3695cee9645SThomas Gleixner * also __iter_div_u64_rem() in include/linux/time.h 3705cee9645SThomas Gleixner */ 3715cee9645SThomas Gleixner asm("" : "+rm"(nsec)); 3725cee9645SThomas Gleixner nsec -= NSEC_PER_SEC; 3735cee9645SThomas Gleixner ++sec; 3745cee9645SThomas Gleixner } 3755cee9645SThomas Gleixner while (nsec < 0) { 3765cee9645SThomas Gleixner asm("" : "+rm"(nsec)); 3775cee9645SThomas Gleixner nsec += NSEC_PER_SEC; 3785cee9645SThomas Gleixner --sec; 3795cee9645SThomas Gleixner } 3805cee9645SThomas Gleixner ts->tv_sec = sec; 3815cee9645SThomas Gleixner ts->tv_nsec = nsec; 3825cee9645SThomas Gleixner } 3835cee9645SThomas Gleixner EXPORT_SYMBOL(set_normalized_timespec); 3845cee9645SThomas Gleixner 3855cee9645SThomas Gleixner /** 3865cee9645SThomas Gleixner * ns_to_timespec - Convert nanoseconds to timespec 3875cee9645SThomas Gleixner * @nsec: the nanoseconds value to be converted 3885cee9645SThomas Gleixner * 3895cee9645SThomas Gleixner * Returns the timespec representation of the nsec parameter. 3905cee9645SThomas Gleixner */ 3915cee9645SThomas Gleixner struct timespec ns_to_timespec(const s64 nsec) 3925cee9645SThomas Gleixner { 3935cee9645SThomas Gleixner struct timespec ts; 3945cee9645SThomas Gleixner s32 rem; 3955cee9645SThomas Gleixner 3965cee9645SThomas Gleixner if (!nsec) 3975cee9645SThomas Gleixner return (struct timespec) {0, 0}; 3985cee9645SThomas Gleixner 3995cee9645SThomas Gleixner ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem); 4005cee9645SThomas Gleixner if (unlikely(rem < 0)) { 4015cee9645SThomas Gleixner ts.tv_sec--; 4025cee9645SThomas Gleixner rem += NSEC_PER_SEC; 4035cee9645SThomas Gleixner } 4045cee9645SThomas Gleixner ts.tv_nsec = rem; 4055cee9645SThomas Gleixner 4065cee9645SThomas Gleixner return ts; 4075cee9645SThomas Gleixner } 4085cee9645SThomas Gleixner EXPORT_SYMBOL(ns_to_timespec); 4095cee9645SThomas Gleixner 4105cee9645SThomas Gleixner /** 4115cee9645SThomas Gleixner * ns_to_timeval - Convert nanoseconds to timeval 4125cee9645SThomas Gleixner * @nsec: the nanoseconds value to be converted 4135cee9645SThomas Gleixner * 4145cee9645SThomas Gleixner * Returns the timeval representation of the nsec parameter. 4155cee9645SThomas Gleixner */ 4165cee9645SThomas Gleixner struct timeval ns_to_timeval(const s64 nsec) 4175cee9645SThomas Gleixner { 4185cee9645SThomas Gleixner struct timespec ts = ns_to_timespec(nsec); 4195cee9645SThomas Gleixner struct timeval tv; 4205cee9645SThomas Gleixner 4215cee9645SThomas Gleixner tv.tv_sec = ts.tv_sec; 4225cee9645SThomas Gleixner tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000; 4235cee9645SThomas Gleixner 4245cee9645SThomas Gleixner return tv; 4255cee9645SThomas Gleixner } 4265cee9645SThomas Gleixner EXPORT_SYMBOL(ns_to_timeval); 4275cee9645SThomas Gleixner 42849cd6f86SJohn Stultz #if BITS_PER_LONG == 32 42949cd6f86SJohn Stultz /** 43049cd6f86SJohn Stultz * set_normalized_timespec - set timespec sec and nsec parts and normalize 43149cd6f86SJohn Stultz * 43249cd6f86SJohn Stultz * @ts: pointer to timespec variable to be set 43349cd6f86SJohn Stultz * @sec: seconds to set 43449cd6f86SJohn Stultz * @nsec: nanoseconds to set 43549cd6f86SJohn Stultz * 43649cd6f86SJohn Stultz * Set seconds and nanoseconds field of a timespec variable and 43749cd6f86SJohn Stultz * normalize to the timespec storage format 43849cd6f86SJohn Stultz * 43949cd6f86SJohn Stultz * Note: The tv_nsec part is always in the range of 44049cd6f86SJohn Stultz * 0 <= tv_nsec < NSEC_PER_SEC 44149cd6f86SJohn Stultz * For negative values only the tv_sec field is negative ! 44249cd6f86SJohn Stultz */ 44349cd6f86SJohn Stultz void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec) 44449cd6f86SJohn Stultz { 44549cd6f86SJohn Stultz while (nsec >= NSEC_PER_SEC) { 44649cd6f86SJohn Stultz /* 44749cd6f86SJohn Stultz * The following asm() prevents the compiler from 44849cd6f86SJohn Stultz * optimising this loop into a modulo operation. See 44949cd6f86SJohn Stultz * also __iter_div_u64_rem() in include/linux/time.h 45049cd6f86SJohn Stultz */ 45149cd6f86SJohn Stultz asm("" : "+rm"(nsec)); 45249cd6f86SJohn Stultz nsec -= NSEC_PER_SEC; 45349cd6f86SJohn Stultz ++sec; 45449cd6f86SJohn Stultz } 45549cd6f86SJohn Stultz while (nsec < 0) { 45649cd6f86SJohn Stultz asm("" : "+rm"(nsec)); 45749cd6f86SJohn Stultz nsec += NSEC_PER_SEC; 45849cd6f86SJohn Stultz --sec; 45949cd6f86SJohn Stultz } 46049cd6f86SJohn Stultz ts->tv_sec = sec; 46149cd6f86SJohn Stultz ts->tv_nsec = nsec; 46249cd6f86SJohn Stultz } 46349cd6f86SJohn Stultz EXPORT_SYMBOL(set_normalized_timespec64); 46449cd6f86SJohn Stultz 46549cd6f86SJohn Stultz /** 46649cd6f86SJohn Stultz * ns_to_timespec64 - Convert nanoseconds to timespec64 46749cd6f86SJohn Stultz * @nsec: the nanoseconds value to be converted 46849cd6f86SJohn Stultz * 46949cd6f86SJohn Stultz * Returns the timespec64 representation of the nsec parameter. 47049cd6f86SJohn Stultz */ 47149cd6f86SJohn Stultz struct timespec64 ns_to_timespec64(const s64 nsec) 47249cd6f86SJohn Stultz { 47349cd6f86SJohn Stultz struct timespec64 ts; 47449cd6f86SJohn Stultz s32 rem; 47549cd6f86SJohn Stultz 47649cd6f86SJohn Stultz if (!nsec) 47749cd6f86SJohn Stultz return (struct timespec64) {0, 0}; 47849cd6f86SJohn Stultz 47949cd6f86SJohn Stultz ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem); 48049cd6f86SJohn Stultz if (unlikely(rem < 0)) { 48149cd6f86SJohn Stultz ts.tv_sec--; 48249cd6f86SJohn Stultz rem += NSEC_PER_SEC; 48349cd6f86SJohn Stultz } 48449cd6f86SJohn Stultz ts.tv_nsec = rem; 48549cd6f86SJohn Stultz 48649cd6f86SJohn Stultz return ts; 48749cd6f86SJohn Stultz } 48849cd6f86SJohn Stultz EXPORT_SYMBOL(ns_to_timespec64); 48949cd6f86SJohn Stultz #endif 4905cee9645SThomas Gleixner /* 4915cee9645SThomas Gleixner * When we convert to jiffies then we interpret incoming values 4925cee9645SThomas Gleixner * the following way: 4935cee9645SThomas Gleixner * 4945cee9645SThomas Gleixner * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET) 4955cee9645SThomas Gleixner * 4965cee9645SThomas Gleixner * - 'too large' values [that would result in larger than 4975cee9645SThomas Gleixner * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too. 4985cee9645SThomas Gleixner * 4995cee9645SThomas Gleixner * - all other values are converted to jiffies by either multiplying 5005cee9645SThomas Gleixner * the input value by a factor or dividing it with a factor 5015cee9645SThomas Gleixner * 5025cee9645SThomas Gleixner * We must also be careful about 32-bit overflows. 5035cee9645SThomas Gleixner */ 5045cee9645SThomas Gleixner unsigned long msecs_to_jiffies(const unsigned int m) 5055cee9645SThomas Gleixner { 5065cee9645SThomas Gleixner /* 5075cee9645SThomas Gleixner * Negative value, means infinite timeout: 5085cee9645SThomas Gleixner */ 5095cee9645SThomas Gleixner if ((int)m < 0) 5105cee9645SThomas Gleixner return MAX_JIFFY_OFFSET; 5115cee9645SThomas Gleixner 5125cee9645SThomas Gleixner #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ) 5135cee9645SThomas Gleixner /* 5145cee9645SThomas Gleixner * HZ is equal to or smaller than 1000, and 1000 is a nice 5155cee9645SThomas Gleixner * round multiple of HZ, divide with the factor between them, 5165cee9645SThomas Gleixner * but round upwards: 5175cee9645SThomas Gleixner */ 5185cee9645SThomas Gleixner return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ); 5195cee9645SThomas Gleixner #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC) 5205cee9645SThomas Gleixner /* 5215cee9645SThomas Gleixner * HZ is larger than 1000, and HZ is a nice round multiple of 5225cee9645SThomas Gleixner * 1000 - simply multiply with the factor between them. 5235cee9645SThomas Gleixner * 5245cee9645SThomas Gleixner * But first make sure the multiplication result cannot 5255cee9645SThomas Gleixner * overflow: 5265cee9645SThomas Gleixner */ 5275cee9645SThomas Gleixner if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET)) 5285cee9645SThomas Gleixner return MAX_JIFFY_OFFSET; 5295cee9645SThomas Gleixner 5305cee9645SThomas Gleixner return m * (HZ / MSEC_PER_SEC); 5315cee9645SThomas Gleixner #else 5325cee9645SThomas Gleixner /* 5335cee9645SThomas Gleixner * Generic case - multiply, round and divide. But first 5345cee9645SThomas Gleixner * check that if we are doing a net multiplication, that 5355cee9645SThomas Gleixner * we wouldn't overflow: 5365cee9645SThomas Gleixner */ 5375cee9645SThomas Gleixner if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET)) 5385cee9645SThomas Gleixner return MAX_JIFFY_OFFSET; 5395cee9645SThomas Gleixner 5405cee9645SThomas Gleixner return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32) 5415cee9645SThomas Gleixner >> MSEC_TO_HZ_SHR32; 5425cee9645SThomas Gleixner #endif 5435cee9645SThomas Gleixner } 5445cee9645SThomas Gleixner EXPORT_SYMBOL(msecs_to_jiffies); 5455cee9645SThomas Gleixner 5465cee9645SThomas Gleixner unsigned long usecs_to_jiffies(const unsigned int u) 5475cee9645SThomas Gleixner { 5485cee9645SThomas Gleixner if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET)) 5495cee9645SThomas Gleixner return MAX_JIFFY_OFFSET; 5505cee9645SThomas Gleixner #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ) 5515cee9645SThomas Gleixner return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ); 5525cee9645SThomas Gleixner #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC) 5535cee9645SThomas Gleixner return u * (HZ / USEC_PER_SEC); 5545cee9645SThomas Gleixner #else 5555cee9645SThomas Gleixner return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32) 5565cee9645SThomas Gleixner >> USEC_TO_HZ_SHR32; 5575cee9645SThomas Gleixner #endif 5585cee9645SThomas Gleixner } 5595cee9645SThomas Gleixner EXPORT_SYMBOL(usecs_to_jiffies); 5605cee9645SThomas Gleixner 5615cee9645SThomas Gleixner /* 5625cee9645SThomas Gleixner * The TICK_NSEC - 1 rounds up the value to the next resolution. Note 5635cee9645SThomas Gleixner * that a remainder subtract here would not do the right thing as the 5645cee9645SThomas Gleixner * resolution values don't fall on second boundries. I.e. the line: 5655cee9645SThomas Gleixner * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding. 566d78c9300SAndrew Hunter * Note that due to the small error in the multiplier here, this 567d78c9300SAndrew Hunter * rounding is incorrect for sufficiently large values of tv_nsec, but 568d78c9300SAndrew Hunter * well formed timespecs should have tv_nsec < NSEC_PER_SEC, so we're 569d78c9300SAndrew Hunter * OK. 5705cee9645SThomas Gleixner * 5715cee9645SThomas Gleixner * Rather, we just shift the bits off the right. 5725cee9645SThomas Gleixner * 5735cee9645SThomas Gleixner * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec 5745cee9645SThomas Gleixner * value to a scaled second value. 5755cee9645SThomas Gleixner */ 576d78c9300SAndrew Hunter static unsigned long 577d78c9300SAndrew Hunter __timespec_to_jiffies(unsigned long sec, long nsec) 5785cee9645SThomas Gleixner { 579d78c9300SAndrew Hunter nsec = nsec + TICK_NSEC - 1; 5805cee9645SThomas Gleixner 5815cee9645SThomas Gleixner if (sec >= MAX_SEC_IN_JIFFIES){ 5825cee9645SThomas Gleixner sec = MAX_SEC_IN_JIFFIES; 5835cee9645SThomas Gleixner nsec = 0; 5845cee9645SThomas Gleixner } 5855cee9645SThomas Gleixner return (((u64)sec * SEC_CONVERSION) + 5865cee9645SThomas Gleixner (((u64)nsec * NSEC_CONVERSION) >> 5875cee9645SThomas Gleixner (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC; 5885cee9645SThomas Gleixner 5895cee9645SThomas Gleixner } 590d78c9300SAndrew Hunter 591d78c9300SAndrew Hunter unsigned long 592d78c9300SAndrew Hunter timespec_to_jiffies(const struct timespec *value) 593d78c9300SAndrew Hunter { 594d78c9300SAndrew Hunter return __timespec_to_jiffies(value->tv_sec, value->tv_nsec); 595d78c9300SAndrew Hunter } 596d78c9300SAndrew Hunter 5975cee9645SThomas Gleixner EXPORT_SYMBOL(timespec_to_jiffies); 5985cee9645SThomas Gleixner 5995cee9645SThomas Gleixner void 6005cee9645SThomas Gleixner jiffies_to_timespec(const unsigned long jiffies, struct timespec *value) 6015cee9645SThomas Gleixner { 6025cee9645SThomas Gleixner /* 6035cee9645SThomas Gleixner * Convert jiffies to nanoseconds and separate with 6045cee9645SThomas Gleixner * one divide. 6055cee9645SThomas Gleixner */ 6065cee9645SThomas Gleixner u32 rem; 6075cee9645SThomas Gleixner value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC, 6085cee9645SThomas Gleixner NSEC_PER_SEC, &rem); 6095cee9645SThomas Gleixner value->tv_nsec = rem; 6105cee9645SThomas Gleixner } 6115cee9645SThomas Gleixner EXPORT_SYMBOL(jiffies_to_timespec); 6125cee9645SThomas Gleixner 613d78c9300SAndrew Hunter /* 614d78c9300SAndrew Hunter * We could use a similar algorithm to timespec_to_jiffies (with a 615d78c9300SAndrew Hunter * different multiplier for usec instead of nsec). But this has a 616d78c9300SAndrew Hunter * problem with rounding: we can't exactly add TICK_NSEC - 1 to the 617d78c9300SAndrew Hunter * usec value, since it's not necessarily integral. 6185cee9645SThomas Gleixner * 619d78c9300SAndrew Hunter * We could instead round in the intermediate scaled representation 620d78c9300SAndrew Hunter * (i.e. in units of 1/2^(large scale) jiffies) but that's also 621d78c9300SAndrew Hunter * perilous: the scaling introduces a small positive error, which 622d78c9300SAndrew Hunter * combined with a division-rounding-upward (i.e. adding 2^(scale) - 1 623d78c9300SAndrew Hunter * units to the intermediate before shifting) leads to accidental 624d78c9300SAndrew Hunter * overflow and overestimates. 625d78c9300SAndrew Hunter * 626d78c9300SAndrew Hunter * At the cost of one additional multiplication by a constant, just 627d78c9300SAndrew Hunter * use the timespec implementation. 6285cee9645SThomas Gleixner */ 6295cee9645SThomas Gleixner unsigned long 6305cee9645SThomas Gleixner timeval_to_jiffies(const struct timeval *value) 6315cee9645SThomas Gleixner { 632d78c9300SAndrew Hunter return __timespec_to_jiffies(value->tv_sec, 633d78c9300SAndrew Hunter value->tv_usec * NSEC_PER_USEC); 6345cee9645SThomas Gleixner } 6355cee9645SThomas Gleixner EXPORT_SYMBOL(timeval_to_jiffies); 6365cee9645SThomas Gleixner 6375cee9645SThomas Gleixner void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value) 6385cee9645SThomas Gleixner { 6395cee9645SThomas Gleixner /* 6405cee9645SThomas Gleixner * Convert jiffies to nanoseconds and separate with 6415cee9645SThomas Gleixner * one divide. 6425cee9645SThomas Gleixner */ 6435cee9645SThomas Gleixner u32 rem; 6445cee9645SThomas Gleixner 6455cee9645SThomas Gleixner value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC, 6465cee9645SThomas Gleixner NSEC_PER_SEC, &rem); 6475cee9645SThomas Gleixner value->tv_usec = rem / NSEC_PER_USEC; 6485cee9645SThomas Gleixner } 6495cee9645SThomas Gleixner EXPORT_SYMBOL(jiffies_to_timeval); 6505cee9645SThomas Gleixner 6515cee9645SThomas Gleixner /* 6525cee9645SThomas Gleixner * Convert jiffies/jiffies_64 to clock_t and back. 6535cee9645SThomas Gleixner */ 6545cee9645SThomas Gleixner clock_t jiffies_to_clock_t(unsigned long x) 6555cee9645SThomas Gleixner { 6565cee9645SThomas Gleixner #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0 6575cee9645SThomas Gleixner # if HZ < USER_HZ 6585cee9645SThomas Gleixner return x * (USER_HZ / HZ); 6595cee9645SThomas Gleixner # else 6605cee9645SThomas Gleixner return x / (HZ / USER_HZ); 6615cee9645SThomas Gleixner # endif 6625cee9645SThomas Gleixner #else 6635cee9645SThomas Gleixner return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ); 6645cee9645SThomas Gleixner #endif 6655cee9645SThomas Gleixner } 6665cee9645SThomas Gleixner EXPORT_SYMBOL(jiffies_to_clock_t); 6675cee9645SThomas Gleixner 6685cee9645SThomas Gleixner unsigned long clock_t_to_jiffies(unsigned long x) 6695cee9645SThomas Gleixner { 6705cee9645SThomas Gleixner #if (HZ % USER_HZ)==0 6715cee9645SThomas Gleixner if (x >= ~0UL / (HZ / USER_HZ)) 6725cee9645SThomas Gleixner return ~0UL; 6735cee9645SThomas Gleixner return x * (HZ / USER_HZ); 6745cee9645SThomas Gleixner #else 6755cee9645SThomas Gleixner /* Don't worry about loss of precision here .. */ 6765cee9645SThomas Gleixner if (x >= ~0UL / HZ * USER_HZ) 6775cee9645SThomas Gleixner return ~0UL; 6785cee9645SThomas Gleixner 6795cee9645SThomas Gleixner /* .. but do try to contain it here */ 6805cee9645SThomas Gleixner return div_u64((u64)x * HZ, USER_HZ); 6815cee9645SThomas Gleixner #endif 6825cee9645SThomas Gleixner } 6835cee9645SThomas Gleixner EXPORT_SYMBOL(clock_t_to_jiffies); 6845cee9645SThomas Gleixner 6855cee9645SThomas Gleixner u64 jiffies_64_to_clock_t(u64 x) 6865cee9645SThomas Gleixner { 6875cee9645SThomas Gleixner #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0 6885cee9645SThomas Gleixner # if HZ < USER_HZ 6895cee9645SThomas Gleixner x = div_u64(x * USER_HZ, HZ); 6905cee9645SThomas Gleixner # elif HZ > USER_HZ 6915cee9645SThomas Gleixner x = div_u64(x, HZ / USER_HZ); 6925cee9645SThomas Gleixner # else 6935cee9645SThomas Gleixner /* Nothing to do */ 6945cee9645SThomas Gleixner # endif 6955cee9645SThomas Gleixner #else 6965cee9645SThomas Gleixner /* 6975cee9645SThomas Gleixner * There are better ways that don't overflow early, 6985cee9645SThomas Gleixner * but even this doesn't overflow in hundreds of years 6995cee9645SThomas Gleixner * in 64 bits, so.. 7005cee9645SThomas Gleixner */ 7015cee9645SThomas Gleixner x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ)); 7025cee9645SThomas Gleixner #endif 7035cee9645SThomas Gleixner return x; 7045cee9645SThomas Gleixner } 7055cee9645SThomas Gleixner EXPORT_SYMBOL(jiffies_64_to_clock_t); 7065cee9645SThomas Gleixner 7075cee9645SThomas Gleixner u64 nsec_to_clock_t(u64 x) 7085cee9645SThomas Gleixner { 7095cee9645SThomas Gleixner #if (NSEC_PER_SEC % USER_HZ) == 0 7105cee9645SThomas Gleixner return div_u64(x, NSEC_PER_SEC / USER_HZ); 7115cee9645SThomas Gleixner #elif (USER_HZ % 512) == 0 7125cee9645SThomas Gleixner return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512); 7135cee9645SThomas Gleixner #else 7145cee9645SThomas Gleixner /* 7155cee9645SThomas Gleixner * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024, 7165cee9645SThomas Gleixner * overflow after 64.99 years. 7175cee9645SThomas Gleixner * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ... 7185cee9645SThomas Gleixner */ 7195cee9645SThomas Gleixner return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ); 7205cee9645SThomas Gleixner #endif 7215cee9645SThomas Gleixner } 7225cee9645SThomas Gleixner 7235cee9645SThomas Gleixner /** 7245cee9645SThomas Gleixner * nsecs_to_jiffies64 - Convert nsecs in u64 to jiffies64 7255cee9645SThomas Gleixner * 7265cee9645SThomas Gleixner * @n: nsecs in u64 7275cee9645SThomas Gleixner * 7285cee9645SThomas Gleixner * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64. 7295cee9645SThomas Gleixner * And this doesn't return MAX_JIFFY_OFFSET since this function is designed 7305cee9645SThomas Gleixner * for scheduler, not for use in device drivers to calculate timeout value. 7315cee9645SThomas Gleixner * 7325cee9645SThomas Gleixner * note: 7335cee9645SThomas Gleixner * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512) 7345cee9645SThomas Gleixner * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years 7355cee9645SThomas Gleixner */ 7365cee9645SThomas Gleixner u64 nsecs_to_jiffies64(u64 n) 7375cee9645SThomas Gleixner { 7385cee9645SThomas Gleixner #if (NSEC_PER_SEC % HZ) == 0 7395cee9645SThomas Gleixner /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */ 7405cee9645SThomas Gleixner return div_u64(n, NSEC_PER_SEC / HZ); 7415cee9645SThomas Gleixner #elif (HZ % 512) == 0 7425cee9645SThomas Gleixner /* overflow after 292 years if HZ = 1024 */ 7435cee9645SThomas Gleixner return div_u64(n * HZ / 512, NSEC_PER_SEC / 512); 7445cee9645SThomas Gleixner #else 7455cee9645SThomas Gleixner /* 7465cee9645SThomas Gleixner * Generic case - optimized for cases where HZ is a multiple of 3. 7475cee9645SThomas Gleixner * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc. 7485cee9645SThomas Gleixner */ 7495cee9645SThomas Gleixner return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ); 7505cee9645SThomas Gleixner #endif 7515cee9645SThomas Gleixner } 7525cee9645SThomas Gleixner 7535cee9645SThomas Gleixner /** 7545cee9645SThomas Gleixner * nsecs_to_jiffies - Convert nsecs in u64 to jiffies 7555cee9645SThomas Gleixner * 7565cee9645SThomas Gleixner * @n: nsecs in u64 7575cee9645SThomas Gleixner * 7585cee9645SThomas Gleixner * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64. 7595cee9645SThomas Gleixner * And this doesn't return MAX_JIFFY_OFFSET since this function is designed 7605cee9645SThomas Gleixner * for scheduler, not for use in device drivers to calculate timeout value. 7615cee9645SThomas Gleixner * 7625cee9645SThomas Gleixner * note: 7635cee9645SThomas Gleixner * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512) 7645cee9645SThomas Gleixner * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years 7655cee9645SThomas Gleixner */ 7665cee9645SThomas Gleixner unsigned long nsecs_to_jiffies(u64 n) 7675cee9645SThomas Gleixner { 7685cee9645SThomas Gleixner return (unsigned long)nsecs_to_jiffies64(n); 7695cee9645SThomas Gleixner } 770d560fed6SThomas Gleixner EXPORT_SYMBOL_GPL(nsecs_to_jiffies); 7715cee9645SThomas Gleixner 7725cee9645SThomas Gleixner /* 7735cee9645SThomas Gleixner * Add two timespec values and do a safety check for overflow. 7745cee9645SThomas Gleixner * It's assumed that both values are valid (>= 0) 7755cee9645SThomas Gleixner */ 7765cee9645SThomas Gleixner struct timespec timespec_add_safe(const struct timespec lhs, 7775cee9645SThomas Gleixner const struct timespec rhs) 7785cee9645SThomas Gleixner { 7795cee9645SThomas Gleixner struct timespec res; 7805cee9645SThomas Gleixner 7815cee9645SThomas Gleixner set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec, 7825cee9645SThomas Gleixner lhs.tv_nsec + rhs.tv_nsec); 7835cee9645SThomas Gleixner 7845cee9645SThomas Gleixner if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec) 7855cee9645SThomas Gleixner res.tv_sec = TIME_T_MAX; 7865cee9645SThomas Gleixner 7875cee9645SThomas Gleixner return res; 7885cee9645SThomas Gleixner } 789