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