mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-04 18:09:57 +00:00
![Arnd Bergmann](/assets/img/avatar_default.png)
On 64-bit architectures, the timespec64 based helpers in linux/time.h are defined as macros pointing to their timespec based counterparts. This made sense when they were first introduced, but as we are migrating away from timespec in general, it's much less intuitive now. This changes the macros to work in the exact opposite way: we always provide the timespec64 based helpers and define the old interfaces as macros for them. Now we can move those macros into linux/time32.h, which already contains the respective helpers for 32-bit architectures. Cc: Thomas Gleixner <tglx@linutronix.de> Cc: Ingo Molnar <mingo@kernel.org> Cc: Miroslav Lichvar <mlichvar@redhat.com> Cc: Richard Cochran <richardcochran@gmail.com> Cc: Prarit Bhargava <prarit@redhat.com> Cc: Stephen Boyd <stephen.boyd@linaro.org> Signed-off-by: Arnd Bergmann <arnd@arndb.de> Signed-off-by: John Stultz <john.stultz@linaro.org>
221 lines
5.6 KiB
C
221 lines
5.6 KiB
C
#ifndef _LINUX_TIME32_H
|
|
#define _LINUX_TIME32_H
|
|
/*
|
|
* These are all interfaces based on the old time_t definition
|
|
* that overflows in 2038 on 32-bit architectures. New code
|
|
* should use the replacements based on time64_t and timespec64.
|
|
*
|
|
* Any interfaces in here that become unused as we migrate
|
|
* code to time64_t should get removed.
|
|
*/
|
|
|
|
#include <linux/time64.h>
|
|
|
|
#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
|
|
|
|
#if __BITS_PER_LONG == 64
|
|
|
|
/* timespec64 is defined as timespec here */
|
|
static inline struct timespec timespec64_to_timespec(const struct timespec64 ts64)
|
|
{
|
|
return ts64;
|
|
}
|
|
|
|
static inline struct timespec64 timespec_to_timespec64(const struct timespec ts)
|
|
{
|
|
return ts;
|
|
}
|
|
|
|
# define timespec_equal timespec64_equal
|
|
# define timespec_compare timespec64_compare
|
|
# define set_normalized_timespec set_normalized_timespec64
|
|
# define timespec_add timespec64_add
|
|
# define timespec_sub timespec64_sub
|
|
# define timespec_valid timespec64_valid
|
|
# define timespec_valid_strict timespec64_valid_strict
|
|
# define timespec_to_ns timespec64_to_ns
|
|
# define ns_to_timespec ns_to_timespec64
|
|
# define timespec_add_ns timespec64_add_ns
|
|
|
|
#else
|
|
static inline struct timespec timespec64_to_timespec(const struct timespec64 ts64)
|
|
{
|
|
struct timespec ret;
|
|
|
|
ret.tv_sec = (time_t)ts64.tv_sec;
|
|
ret.tv_nsec = ts64.tv_nsec;
|
|
return ret;
|
|
}
|
|
|
|
static inline struct timespec64 timespec_to_timespec64(const struct timespec ts)
|
|
{
|
|
struct timespec64 ret;
|
|
|
|
ret.tv_sec = ts.tv_sec;
|
|
ret.tv_nsec = ts.tv_nsec;
|
|
return ret;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
|
|
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* 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
|
|
|
|
/**
|
|
* time_to_tm - converts the calendar time to local broken-down time
|
|
*
|
|
* @totalsecs the number of seconds elapsed since 00:00:00 on January 1, 1970,
|
|
* Coordinated Universal Time (UTC).
|
|
* @offset offset seconds adding to totalsecs.
|
|
* @result pointer to struct tm variable to receive broken-down time
|
|
*/
|
|
static inline void time_to_tm(time_t totalsecs, int offset, struct tm *result)
|
|
{
|
|
time64_to_tm(totalsecs, offset, result);
|
|
}
|
|
|
|
static inline 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)
|
|
{
|
|
return mktime64(year, mon, day, hour, min, sec);
|
|
}
|
|
|
|
static inline bool timeval_valid(const struct timeval *tv)
|
|
{
|
|
/* Dates before 1970 are bogus */
|
|
if (tv->tv_sec < 0)
|
|
return false;
|
|
|
|
/* Can't have more microseconds then a second */
|
|
if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
extern struct timespec timespec_trunc(struct timespec t, unsigned int gran);
|
|
|
|
/**
|
|
* 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_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);
|
|
|
|
#endif
|