[mirror_ubuntu-eoan-kernel.git] / include / linux / time64.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_TIME64_H
#define _LINUX_TIME64_H

#include <linux/math64.h>

typedef __s64 time64_t;
typedef __u64 timeu64_t;

/* CONFIG_64BIT_TIME enables new 64 bit time_t syscalls in the compat path
 * and 32-bit emulation.
 */
#ifndef CONFIG_64BIT_TIME
#define __kernel_timespec timespec
#define __kernel_itimerspec itimerspec
#endif

#include <uapi/linux/time.h>

struct timespec64 {
	time64_t	tv_sec;			/* seconds */
	long		tv_nsec;		/* nanoseconds */
};

struct itimerspec64 {
	struct timespec64 it_interval;
	struct timespec64 it_value;
};

/* 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

/* Located here for timespec[64]_valid_strict */
#define TIME64_MAX			((s64)~((u64)1 << 63))
#define KTIME_MAX			((s64)~((u64)1 << 63))
#define KTIME_SEC_MAX			(KTIME_MAX / NSEC_PER_SEC)

static inline int timespec64_equal(const struct timespec64 *a,
				   const struct timespec64 *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 timespec64_compare(const struct timespec64 *lhs, const struct timespec64 *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_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec);

static inline struct timespec64 timespec64_add(struct timespec64 lhs,
						struct timespec64 rhs)
{
	struct timespec64 ts_delta;
	set_normalized_timespec64(&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 timespec64 timespec64_sub(struct timespec64 lhs,
						struct timespec64 rhs)
{
	struct timespec64 ts_delta;
	set_normalized_timespec64(&ts_delta, lhs.tv_sec - rhs.tv_sec,
				lhs.tv_nsec - rhs.tv_nsec);
	return ts_delta;
}

/*
 * Returns true if the timespec64 is norm, false if denorm:
 */
static inline bool timespec64_valid(const struct timespec64 *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 timespec64_valid_strict(const struct timespec64 *ts)
{
	if (!timespec64_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;
}

/**
 * timespec64_to_ns - Convert timespec64 to nanoseconds
 * @ts:		pointer to the timespec64 variable to be converted
 *
 * Returns the scalar nanosecond representation of the timespec64
 * parameter.
 */
static inline s64 timespec64_to_ns(const struct timespec64 *ts)
{
	return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
}

/**
 * ns_to_timespec64 - Convert nanoseconds to timespec64
 * @nsec:	the nanoseconds value to be converted
 *
 * Returns the timespec64 representation of the nsec parameter.
 */
extern struct timespec64 ns_to_timespec64(const s64 nsec);

/**
 * timespec64_add_ns - Adds nanoseconds to a timespec64
 * @a:		pointer to timespec64 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 timespec64_add_ns(struct timespec64 *a, u64 ns)
{
	a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
	a->tv_nsec = ns;
}

/*
 * timespec64_add_safe assumes both values are positive and checks for
 * overflow. It will return TIME64_MAX in case of overflow.
 */
extern struct timespec64 timespec64_add_safe(const struct timespec64 lhs,
					 const struct timespec64 rhs);

#endif /* _LINUX_TIME64_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
361a3bf0 JS	2	#ifndef _LINUX_TIME64_H
	3	#define _LINUX_TIME64_H
	4
30f3b3f9	5	#include <linux/math64.h>
361a3bf0 JS	6
361a3bf0 JS	7	typedef __s64 time64_t;
469e857f	8	typedef __u64 timeu64_t;
361a3bf0	9
acf8870a DD	10	/* CONFIG_64BIT_TIME enables new 64 bit time_t syscalls in the compat path
	11	* and 32-bit emulation.
	12	*/
	13	#ifndef CONFIG_64BIT_TIME
	14	#define __kernel_timespec timespec
d0dd63a8	15	#define __kernel_itimerspec itimerspec
acf8870a DD	16	#endif
	17
	18	#include <uapi/linux/time.h>
	19
361a3bf0 JS	20	struct timespec64 {
	21	time64_t tv_sec; /* seconds */
	22	long tv_nsec; /* nanoseconds */
	23	};
19a46fe5 BW	24
	25	struct itimerspec64 {
	26	struct timespec64 it_interval;
	27	struct timespec64 it_value;
	28	};
	29
361a3bf0 JS	30	/* Parameters used to convert the timespec values: */
	31	#define MSEC_PER_SEC 1000L
	32	#define USEC_PER_MSEC 1000L
	33	#define NSEC_PER_USEC 1000L
	34	#define NSEC_PER_MSEC 1000000L
	35	#define USEC_PER_SEC 1000000L
	36	#define NSEC_PER_SEC 1000000000L
	37	#define FSEC_PER_SEC 1000000000000000LL
	38
	39	/* Located here for timespec[64]_valid_strict */
833f32d7	40	#define TIME64_MAX ((s64)~((u64)1 << 63))
361a3bf0 JS	41	#define KTIME_MAX ((s64)~((u64)1 << 63))
	42	#define KTIME_SEC_MAX (KTIME_MAX / NSEC_PER_SEC)
	43
361a3bf0 JS	44	static inline int timespec64_equal(const struct timespec64 *a,
	45	const struct timespec64 *b)
	46	{
	47	return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
	48	}
	49
	50	/*
	51	* lhs < rhs: return <0
	52	* lhs == rhs: return 0
	53	* lhs > rhs: return >0
	54	*/
	55	static inline int timespec64_compare(const struct timespec64 lhs, const struct timespec64 rhs)
	56	{
	57	if (lhs->tv_sec < rhs->tv_sec)
	58	return -1;
	59	if (lhs->tv_sec > rhs->tv_sec)
	60	return 1;
	61	return lhs->tv_nsec - rhs->tv_nsec;
	62	}
	63
	64	extern void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec);
	65
361a3bf0 JS	66	static inline struct timespec64 timespec64_add(struct timespec64 lhs,
	67	struct timespec64 rhs)
	68	{
	69	struct timespec64 ts_delta;
	70	set_normalized_timespec64(&ts_delta, lhs.tv_sec + rhs.tv_sec,
	71	lhs.tv_nsec + rhs.tv_nsec);
	72	return ts_delta;
	73	}
	74
	75	/*
	76	* sub = lhs - rhs, in normalized form
	77	*/
	78	static inline struct timespec64 timespec64_sub(struct timespec64 lhs,
	79	struct timespec64 rhs)
	80	{
	81	struct timespec64 ts_delta;
	82	set_normalized_timespec64(&ts_delta, lhs.tv_sec - rhs.tv_sec,
	83	lhs.tv_nsec - rhs.tv_nsec);
	84	return ts_delta;
	85	}
	86
	87	/*
	88	* Returns true if the timespec64 is norm, false if denorm:
	89	*/
	90	static inline bool timespec64_valid(const struct timespec64 *ts)
	91	{
	92	/* Dates before 1970 are bogus */
	93	if (ts->tv_sec < 0)
	94	return false;
	95	/* Can't have more nanoseconds then a second */
	96	if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
	97	return false;
	98	return true;
	99	}
	100
	101	static inline bool timespec64_valid_strict(const struct timespec64 *ts)
	102	{
	103	if (!timespec64_valid(ts))
	104	return false;
	105	/* Disallow values that could overflow ktime_t */
	106	if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
	107	return false;
	108	return true;
	109	}
	110
	111	/**
	112	* timespec64_to_ns - Convert timespec64 to nanoseconds
	113	* @ts: pointer to the timespec64 variable to be converted
	114	*
	115	* Returns the scalar nanosecond representation of the timespec64
	116	* parameter.
	117	*/
	118	static inline s64 timespec64_to_ns(const struct timespec64 *ts)
	119	{
	120	return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
	121	}
	122
	123	/**
	124	* ns_to_timespec64 - Convert nanoseconds to timespec64
	125	* @nsec: the nanoseconds value to be converted
	126	*
	127	* Returns the timespec64 representation of the nsec parameter.
	128	*/
	129	extern struct timespec64 ns_to_timespec64(const s64 nsec);
130
131	/**
132	* timespec64_add_ns - Adds nanoseconds to a timespec64
133	* @a: pointer to timespec64 to be incremented
134	* @ns: unsigned nanoseconds value to be added
135	*
136	* This must always be inlined because its used from the x86-64 vdso,
137	* which cannot call other kernel functions.
138	*/
139	static __always_inline void timespec64_add_ns(struct timespec64 *a, u64 ns)
140	{
141	a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
142	a->tv_nsec = ns;
143	}
144
8e4f70e2 DD	145	/*
	146	* timespec64_add_safe assumes both values are positive and checks for
	147	* overflow. It will return TIME64_MAX in case of overflow.
	148	*/
	149	extern struct timespec64 timespec64_add_safe(const struct timespec64 lhs,
	150	const struct timespec64 rhs);
	151
361a3bf0	152	#endif /* _LINUX_TIME64_H */