| #ifndef _LINUX_TIME_H |
| #define _LINUX_TIME_H |
| |
| # include <linux/cache.h> |
| # include <linux/seqlock.h> |
| # include <linux/math64.h> |
| #include <uapi/linux/time.h> |
| |
| extern struct timezone sys_tz; |
| |
| /* Parameters used to convert the timespec values: */ |
| #define MSEC_PER_SEC 1000L |
| #define USEC_PER_MSEC 1000L |
| #define NSEC_PER_USEC 1000L |
| #define NSEC_PER_MSEC 1000000L |
| #define USEC_PER_SEC 1000000L |
| #define NSEC_PER_SEC 1000000000L |
| #define FSEC_PER_SEC 1000000000000000LL |
| |
| #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1) |
| |
| static inline int timespec_equal(const struct timespec *a, |
| const struct timespec *b) |
| { |
| return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec); |
| } |
| |
| /* |
| * lhs < rhs: return <0 |
| * lhs == rhs: return 0 |
| * lhs > rhs: return >0 |
| */ |
| static inline int timespec_compare(const struct timespec *lhs, const struct timespec *rhs) |
| { |
| if (lhs->tv_sec < rhs->tv_sec) |
| return -1; |
| if (lhs->tv_sec > rhs->tv_sec) |
| return 1; |
| return lhs->tv_nsec - rhs->tv_nsec; |
| } |
| |
| static inline int timeval_compare(const struct timeval *lhs, const struct timeval *rhs) |
| { |
| if (lhs->tv_sec < rhs->tv_sec) |
| return -1; |
| if (lhs->tv_sec > rhs->tv_sec) |
| return 1; |
| return lhs->tv_usec - rhs->tv_usec; |
| } |
| |
| extern unsigned long mktime(const unsigned int year, const unsigned int mon, |
| const unsigned int day, const unsigned int hour, |
| const unsigned int min, const unsigned int sec); |
| |
| extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec); |
| |
| /* |
| * timespec_add_safe assumes both values are positive and checks |
| * for overflow. It will return TIME_T_MAX if the reutrn would be |
| * smaller then either of the arguments. |
| */ |
| extern struct timespec timespec_add_safe(const struct timespec lhs, |
| const struct timespec rhs); |
| |
| |
| static inline struct timespec timespec_add(struct timespec lhs, |
| struct timespec rhs) |
| { |
| struct timespec ts_delta; |
| set_normalized_timespec(&ts_delta, lhs.tv_sec + rhs.tv_sec, |
| lhs.tv_nsec + rhs.tv_nsec); |
| return ts_delta; |
| } |
| |
| /* |
| * sub = lhs - rhs, in normalized form |
| */ |
| static inline struct timespec timespec_sub(struct timespec lhs, |
| struct timespec rhs) |
| { |
| struct timespec ts_delta; |
| set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec, |
| lhs.tv_nsec - rhs.tv_nsec); |
| return ts_delta; |
| } |
| |
| #define KTIME_MAX ((s64)~((u64)1 << 63)) |
| #if (BITS_PER_LONG == 64) |
| # define KTIME_SEC_MAX (KTIME_MAX / NSEC_PER_SEC) |
| #else |
| # define KTIME_SEC_MAX LONG_MAX |
| #endif |
| |
| /* |
| * Returns true if the timespec is norm, false if denorm: |
| */ |
| static inline bool timespec_valid(const struct timespec *ts) |
| { |
| /* Dates before 1970 are bogus */ |
| if (ts->tv_sec < 0) |
| return false; |
| /* Can't have more nanoseconds then a second */ |
| if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC) |
| return false; |
| return true; |
| } |
| |
| static inline bool timespec_valid_strict(const struct timespec *ts) |
| { |
| if (!timespec_valid(ts)) |
| return false; |
| /* Disallow values that could overflow ktime_t */ |
| if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX) |
| return false; |
| return true; |
| } |
| |
| extern bool persistent_clock_exist; |
| |
| #ifdef CONFIG_HAS_PERSISTENT_CLOCK |
| #define has_persistent_clock() true |
| #else |
| static inline bool has_persistent_clock(void) |
| { |
| return persistent_clock_exist; |
| } |
| #endif |
| |
| extern void read_persistent_clock(struct timespec *ts); |
| extern void read_boot_clock(struct timespec *ts); |
| extern int update_persistent_clock(struct timespec now); |
| void timekeeping_init(void); |
| extern int timekeeping_suspended; |
| |
| unsigned long get_seconds(void); |
| struct timespec current_kernel_time(void); |
| struct timespec __current_kernel_time(void); /* does not take xtime_lock */ |
| struct timespec get_monotonic_coarse(void); |
| void get_xtime_and_monotonic_and_sleep_offset(struct timespec *xtim, |
| struct timespec *wtom, struct timespec *sleep); |
| void timekeeping_inject_sleeptime(struct timespec *delta); |
| |
| #define CURRENT_TIME (current_kernel_time()) |
| #define CURRENT_TIME_SEC ((struct timespec) { get_seconds(), 0 }) |
| |
| /* Some architectures do not supply their own clocksource. |
| * This is mainly the case in architectures that get their |
| * inter-tick times by reading the counter on their interval |
| * timer. Since these timers wrap every tick, they're not really |
| * useful as clocksources. Wrapping them to act like one is possible |
| * but not very efficient. So we provide a callout these arches |
| * can implement for use with the jiffies clocksource to provide |
| * finer then tick granular time. |
| */ |
| #ifdef CONFIG_ARCH_USES_GETTIMEOFFSET |
| extern u32 arch_gettimeoffset(void); |
| #else |
| static inline u32 arch_gettimeoffset(void) { return 0; } |
| #endif |
| |
| extern void do_gettimeofday(struct timeval *tv); |
| extern int do_settimeofday(const struct timespec *tv); |
| extern int do_sys_settimeofday(const struct timespec *tv, |
| const struct timezone *tz); |
| #define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts) |
| extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags); |
| struct itimerval; |
| extern int do_setitimer(int which, struct itimerval *value, |
| struct itimerval *ovalue); |
| extern unsigned int alarm_setitimer(unsigned int seconds); |
| extern int do_getitimer(int which, struct itimerval *value); |
| extern int __getnstimeofday(struct timespec *tv); |
| extern void getnstimeofday(struct timespec *tv); |
| extern void getrawmonotonic(struct timespec *ts); |
| extern void getnstime_raw_and_real(struct timespec *ts_raw, |
| struct timespec *ts_real); |
| extern void getboottime(struct timespec *ts); |
| extern void monotonic_to_bootbased(struct timespec *ts); |
| extern void get_monotonic_boottime(struct timespec *ts); |
| |
| extern struct timespec timespec_trunc(struct timespec t, unsigned gran); |
| extern int timekeeping_valid_for_hres(void); |
| extern u64 timekeeping_max_deferment(void); |
| extern int timekeeping_inject_offset(struct timespec *ts); |
| |
| struct tms; |
| extern void do_sys_times(struct tms *); |
| |
| /* |
| * Similar to the struct tm in userspace <time.h>, but it needs to be here so |
| * that the kernel source is self contained. |
| */ |
| struct tm { |
| /* |
| * the number of seconds after the minute, normally in the range |
| * 0 to 59, but can be up to 60 to allow for leap seconds |
| */ |
| int tm_sec; |
| /* the number of minutes after the hour, in the range 0 to 59*/ |
| int tm_min; |
| /* the number of hours past midnight, in the range 0 to 23 */ |
| int tm_hour; |
| /* the day of the month, in the range 1 to 31 */ |
| int tm_mday; |
| /* the number of months since January, in the range 0 to 11 */ |
| int tm_mon; |
| /* the number of years since 1900 */ |
| long tm_year; |
| /* the number of days since Sunday, in the range 0 to 6 */ |
| int tm_wday; |
| /* the number of days since January 1, in the range 0 to 365 */ |
| int tm_yday; |
| }; |
| |
| void time_to_tm(time_t totalsecs, int offset, struct tm *result); |
| |
| /** |
| * timespec_to_ns - Convert timespec to nanoseconds |
| * @ts: pointer to the timespec variable to be converted |
| * |
| * Returns the scalar nanosecond representation of the timespec |
| * parameter. |
| */ |
| static inline s64 timespec_to_ns(const struct timespec *ts) |
| { |
| return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec; |
| } |
| |
| /** |
| * timeval_to_ns - Convert timeval to nanoseconds |
| * @ts: pointer to the timeval variable to be converted |
| * |
| * Returns the scalar nanosecond representation of the timeval |
| * parameter. |
| */ |
| static inline s64 timeval_to_ns(const struct timeval *tv) |
| { |
| return ((s64) tv->tv_sec * NSEC_PER_SEC) + |
| tv->tv_usec * NSEC_PER_USEC; |
| } |
| |
| /** |
| * ns_to_timespec - Convert nanoseconds to timespec |
| * @nsec: the nanoseconds value to be converted |
| * |
| * Returns the timespec representation of the nsec parameter. |
| */ |
| extern struct timespec ns_to_timespec(const s64 nsec); |
| |
| /** |
| * ns_to_timeval - Convert nanoseconds to timeval |
| * @nsec: the nanoseconds value to be converted |
| * |
| * Returns the timeval representation of the nsec parameter. |
| */ |
| extern struct timeval ns_to_timeval(const s64 nsec); |
| |
| /** |
| * timespec_add_ns - Adds nanoseconds to a timespec |
| * @a: pointer to timespec to be incremented |
| * @ns: unsigned nanoseconds value to be added |
| * |
| * This must always be inlined because its used from the x86-64 vdso, |
| * which cannot call other kernel functions. |
| */ |
| static __always_inline void timespec_add_ns(struct timespec *a, u64 ns) |
| { |
| a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns); |
| a->tv_nsec = ns; |
| } |
| |
| #endif |