[mirror_frr.git] / lib / monotime.h

// SPDX-License-Identifier: ISC
/*
 * Copyright (c) 2017  David Lamparter, for NetDEF, Inc.
 */

#ifndef _FRR_MONOTIME_H
#define _FRR_MONOTIME_H

#include <stdint.h>
#include <time.h>
#include <sys/time.h>

#ifdef __cplusplus
extern "C" {
#endif

struct fbuf;
struct printfrr_eargs;

#ifndef TIMESPEC_TO_TIMEVAL
/* should be in sys/time.h on BSD & Linux libcs */
#define TIMESPEC_TO_TIMEVAL(tv, ts)                                            \
	do {                                                                   \
		(tv)->tv_sec = (ts)->tv_sec;                                   \
		(tv)->tv_usec = (ts)->tv_nsec / 1000;                          \
	} while (0)
#endif
#ifndef TIMEVAL_TO_TIMESPEC
/* should be in sys/time.h on BSD & Linux libcs */
#define TIMEVAL_TO_TIMESPEC(tv, ts)                                            \
	do {                                                                   \
		(ts)->tv_sec = (tv)->tv_sec;                                   \
		(ts)->tv_nsec = (tv)->tv_usec * 1000;                          \
	} while (0)
#endif

/* Linux/glibc is sadly missing these timespec helpers */
#ifndef timespecadd
#define timespecadd(tsp, usp, vsp)                                             \
	do {                                                                   \
		(vsp)->tv_sec = (tsp)->tv_sec + (usp)->tv_sec;                 \
		(vsp)->tv_nsec = (tsp)->tv_nsec + (usp)->tv_nsec;              \
		if ((vsp)->tv_nsec >= 1000000000L) {                           \
			(vsp)->tv_sec++;                                       \
			(vsp)->tv_nsec -= 1000000000L;                         \
		}                                                              \
	} while (0)
#endif

#ifndef timespecsub
#define timespecsub(tsp, usp, vsp)                                             \
	do {                                                                   \
		(vsp)->tv_sec = (tsp)->tv_sec - (usp)->tv_sec;                 \
		(vsp)->tv_nsec = (tsp)->tv_nsec - (usp)->tv_nsec;              \
		if ((vsp)->tv_nsec < 0) {                                      \
			(vsp)->tv_sec--;                                       \
			(vsp)->tv_nsec += 1000000000L;                         \
		}                                                              \
	} while (0)
#endif

static inline time_t monotime(struct timeval *tvo)
{
	struct timespec ts;

	clock_gettime(CLOCK_MONOTONIC, &ts);
	if (tvo) {
		TIMESPEC_TO_TIMEVAL(tvo, &ts);
	}
	return ts.tv_sec;
}

#define ONE_DAY_SECOND (60 * 60 * 24)
#define ONE_WEEK_SECOND (ONE_DAY_SECOND * 7)
#define ONE_YEAR_SECOND (ONE_DAY_SECOND * 365)

/* the following two return microseconds, not time_t!
 *
 * also, they're negative forms of each other, but having both makes the
 * code more readable
 */
static inline int64_t monotime_since(const struct timeval *ref,
				     struct timeval *out)
{
	struct timeval tv;
	monotime(&tv);
	timersub(&tv, ref, &tv);
	if (out)
		*out = tv;
	return (int64_t)tv.tv_sec * 1000000LL + tv.tv_usec;
}

static inline int64_t monotime_until(const struct timeval *ref,
				     struct timeval *out)
{
	struct timeval tv;
	monotime(&tv);
	timersub(ref, &tv, &tv);
	if (out)
		*out = tv;
	return (int64_t)tv.tv_sec * 1000000LL + tv.tv_usec;
}

static inline time_t monotime_to_realtime(const struct timeval *mono,
					  struct timeval *realout)
{
	struct timeval delta, real;

	monotime_since(mono, &delta);
	gettimeofday(&real, NULL);

	timersub(&real, &delta, &real);
	if (realout)
		*realout = real;
	return real.tv_sec;
}

/* Char buffer size for time-to-string api */
#define MONOTIME_STRLEN 32

static inline char *time_to_string(time_t ts, char *buf)
{
	struct timeval tv;
	time_t tbuf;

	monotime(&tv);
	tbuf = time(NULL) - (tv.tv_sec - ts);

	return ctime_r(&tbuf, buf);
}

/* Convert interval to human-friendly string, used in cli output e.g. */
static inline const char *frrtime_to_interval(time_t t, char *buf,
					      size_t buflen)
{
	struct tm tm;

	gmtime_r(&t, &tm);

	if (t < ONE_DAY_SECOND)
		snprintf(buf, buflen, "%02d:%02d:%02d", tm.tm_hour, tm.tm_min,
			 tm.tm_sec);
	else if (t < ONE_WEEK_SECOND)
		snprintf(buf, buflen, "%dd%02dh%02dm", tm.tm_yday, tm.tm_hour,
			 tm.tm_min);
	else
		snprintf(buf, buflen, "%02dw%dd%02dh", tm.tm_yday / 7,
			 tm.tm_yday - ((tm.tm_yday / 7) * 7), tm.tm_hour);
	return buf;
}

enum {
	/* n/a - input was seconds precision, don't print any fractional */
	TIMEFMT_SECONDS = (1 << 0),
	/* caller is directly invoking printfrr_time and has pre-specified
	 * I/Iu/Is/M/Mu/Ms/R/Ru/Rs (for printing timers)
	 */
	TIMEFMT_PRESELECT = (1 << 1),
	/* don't print any output - this is needed for invoking printfrr_time
	 * from another printfrr extensions to skip over flag characters
	 */
	TIMEFMT_SKIP = (1 << 2),
	/* use spaces in appropriate places */
	TIMEFMT_SPACE = (1 << 3),

	/* input interpretations: */
	TIMEFMT_REALTIME = (1 << 8),
	TIMEFMT_MONOTONIC = (1 << 9),
	TIMEFMT_SINCE = (1 << 10),
	TIMEFMT_UNTIL = (1 << 11),

	TIMEFMT_ABSOLUTE = TIMEFMT_REALTIME | TIMEFMT_MONOTONIC,
	TIMEFMT_ANCHORS = TIMEFMT_SINCE | TIMEFMT_UNTIL,

	/* calendaric formats: */
	TIMEFMT_ISO8601 = (1 << 16),

	/* interval formats: */
	/* 't' - use [t]raditional 3-block format */
	TIMEFMT_BASIC = (1 << 24),
	/* 'm' - select mm:ss */
	TIMEFMT_MMSS = (1 << 25),
	/* 'h' - select hh:mm:ss */
	TIMEFMT_HHMMSS = (1 << 26),
	/* 'd' - print as decimal number of seconds */
	TIMEFMT_DECIMAL = (1 << 27),
	/* 'mx'/'hx' - replace zero value with "--:--" or "--:--:--" */
	TIMEFMT_DASHES = (1 << 31),

	/* helpers for reference */
	TIMEFMT_TIMER_DEADLINE =
		TIMEFMT_PRESELECT | TIMEFMT_MONOTONIC | TIMEFMT_UNTIL,
	TIMEFMT_TIMER_INTERVAL = TIMEFMT_PRESELECT,
};

extern ssize_t printfrr_time(struct fbuf *buf, struct printfrr_eargs *ea,
			     const struct timespec *ts, unsigned int flags);

#ifdef __cplusplus
}
#endif

#endif /* _FRR_MONOTIME_H */
Commit	Line	Data
acddc0ed	1	// SPDX-License-Identifier: ISC
7790a2d6 DL	2	/*
7790a2d6 DL	3	* Copyright (c) 2017 David Lamparter, for NetDEF, Inc.
7790a2d6 DL	4	*/
	5
	6	#ifndef _FRR_MONOTIME_H
	7	#define _FRR_MONOTIME_H
	8
	9	#include <stdint.h>
	10	#include <time.h>
	11	#include <sys/time.h>
	12
5e244469 RW	13	#ifdef __cplusplus
	14	extern "C" {
	15	#endif
	16
2c76ba43 DL	17	struct fbuf;
	18	struct printfrr_eargs;
	19
7790a2d6 DL	20	#ifndef TIMESPEC_TO_TIMEVAL
7790a2d6 DL	21	/* should be in sys/time.h on BSD & Linux libcs */
d62a17ae	22	#define TIMESPEC_TO_TIMEVAL(tv, ts) \
	23	do { \
	24	(tv)->tv_sec = (ts)->tv_sec; \
	25	(tv)->tv_usec = (ts)->tv_nsec / 1000; \
	26	} while (0)
7790a2d6	27	#endif
39cea822 DL	28	#ifndef TIMEVAL_TO_TIMESPEC
39cea822 DL	29	/* should be in sys/time.h on BSD & Linux libcs */
d62a17ae	30	#define TIMEVAL_TO_TIMESPEC(tv, ts) \
	31	do { \
	32	(ts)->tv_sec = (tv)->tv_sec; \
	33	(ts)->tv_nsec = (tv)->tv_usec * 1000; \
	34	} while (0)
39cea822	35	#endif
7790a2d6	36
2c76ba43 DL	37	/* Linux/glibc is sadly missing these timespec helpers */
	38	#ifndef timespecadd
	39	#define timespecadd(tsp, usp, vsp) \
	40	do { \
	41	(vsp)->tv_sec = (tsp)->tv_sec + (usp)->tv_sec; \
	42	(vsp)->tv_nsec = (tsp)->tv_nsec + (usp)->tv_nsec; \
	43	if ((vsp)->tv_nsec >= 1000000000L) { \
	44	(vsp)->tv_sec++; \
	45	(vsp)->tv_nsec -= 1000000000L; \
	46	} \
	47	} while (0)
	48	#endif
	49
	50	#ifndef timespecsub
	51	#define timespecsub(tsp, usp, vsp) \
	52	do { \
	53	(vsp)->tv_sec = (tsp)->tv_sec - (usp)->tv_sec; \
	54	(vsp)->tv_nsec = (tsp)->tv_nsec - (usp)->tv_nsec; \
	55	if ((vsp)->tv_nsec < 0) { \
	56	(vsp)->tv_sec--; \
	57	(vsp)->tv_nsec += 1000000000L; \
	58	} \
	59	} while (0)
	60	#endif
	61
7790a2d6 DL	62	static inline time_t monotime(struct timeval *tvo)
7790a2d6 DL	63	{
d62a17ae	64	struct timespec ts;
7790a2d6	65
d62a17ae	66	clock_gettime(CLOCK_MONOTONIC, &ts);
	67	if (tvo) {
	68	TIMESPEC_TO_TIMEVAL(tvo, &ts);
	69	}
	70	return ts.tv_sec;
7790a2d6 DL	71	}
7790a2d6 DL	72
bddfc297 DS	73	#define ONE_DAY_SECOND (60 * 60 * 24)
	74	#define ONE_WEEK_SECOND (ONE_DAY_SECOND * 7)
	75	#define ONE_YEAR_SECOND (ONE_DAY_SECOND * 365)
99a6a31e	76
7790a2d6 DL	77	/* the following two return microseconds, not time_t!
	78	*
	79	* also, they're negative forms of each other, but having both makes the
	80	* code more readable
	81	*/
	82	static inline int64_t monotime_since(const struct timeval *ref,
d62a17ae	83	struct timeval *out)
7790a2d6	84	{
d62a17ae	85	struct timeval tv;
	86	monotime(&tv);
	87	timersub(&tv, ref, &tv);
	88	if (out)
	89	*out = tv;
	90	return (int64_t)tv.tv_sec * 1000000LL + tv.tv_usec;
7790a2d6 DL	91	}
	92
	93	static inline int64_t monotime_until(const struct timeval *ref,
d62a17ae	94	struct timeval *out)
7790a2d6	95	{
d62a17ae	96	struct timeval tv;
	97	monotime(&tv);
	98	timersub(ref, &tv, &tv);
	99	if (out)
	100	*out = tv;
	101	return (int64_t)tv.tv_sec * 1000000LL + tv.tv_usec;
7790a2d6 DL	102	}
7790a2d6 DL	103
8defc5be DL	104	static inline time_t monotime_to_realtime(const struct timeval *mono,
	105	struct timeval *realout)
	106	{
	107	struct timeval delta, real;
	108
	109	monotime_since(mono, &delta);
	110	gettimeofday(&real, NULL);
	111
	112	timersub(&real, &delta, &real);
	113	if (realout)
	114	*realout = real;
	115	return real.tv_sec;
	116	}
	117
c9049b92 MS	118	/* Char buffer size for time-to-string api */
	119	#define MONOTIME_STRLEN 32
	120
	121	static inline char time_to_string(time_t ts, char buf)
87454e6b CS	122	{
	123	struct timeval tv;
	124	time_t tbuf;
	125
	126	monotime(&tv);
	127	tbuf = time(NULL) - (tv.tv_sec - ts);
	128
c9049b92	129	return ctime_r(&tbuf, buf);
87454e6b CS	130	}
87454e6b CS	131
d0636ead MS	132	/* Convert interval to human-friendly string, used in cli output e.g. */
	133	static inline const char frrtime_to_interval(time_t t, char buf,
	134	size_t buflen)
	135	{
	136	struct tm tm;
	137
	138	gmtime_r(&t, &tm);
	139
	140	if (t < ONE_DAY_SECOND)
	141	snprintf(buf, buflen, "%02d:%02d:%02d", tm.tm_hour, tm.tm_min,
	142	tm.tm_sec);
	143	else if (t < ONE_WEEK_SECOND)
	144	snprintf(buf, buflen, "%dd%02dh%02dm", tm.tm_yday, tm.tm_hour,
	145	tm.tm_min);
	146	else
	147	snprintf(buf, buflen, "%02dw%dd%02dh", tm.tm_yday / 7,
	148	tm.tm_yday - ((tm.tm_yday / 7) * 7), tm.tm_hour);
	149	return buf;
	150	}
	151
2c76ba43 DL	152	enum {
	153	/* n/a - input was seconds precision, don't print any fractional */
	154	TIMEFMT_SECONDS = (1 << 0),
	155	/* caller is directly invoking printfrr_time and has pre-specified
	156	* I/Iu/Is/M/Mu/Ms/R/Ru/Rs (for printing timers)
	157	*/
	158	TIMEFMT_PRESELECT = (1 << 1),
	159	/* don't print any output - this is needed for invoking printfrr_time
	160	* from another printfrr extensions to skip over flag characters
	161	*/
	162	TIMEFMT_SKIP = (1 << 2),
	163	/* use spaces in appropriate places */
	164	TIMEFMT_SPACE = (1 << 3),
	165
	166	/* input interpretations: */
	167	TIMEFMT_REALTIME = (1 << 8),
	168	TIMEFMT_MONOTONIC = (1 << 9),
	169	TIMEFMT_SINCE = (1 << 10),
	170	TIMEFMT_UNTIL = (1 << 11),
	171
	172	TIMEFMT_ABSOLUTE = TIMEFMT_REALTIME \| TIMEFMT_MONOTONIC,
	173	TIMEFMT_ANCHORS = TIMEFMT_SINCE \| TIMEFMT_UNTIL,
	174
	175	/* calendaric formats: */
	176	TIMEFMT_ISO8601 = (1 << 16),
	177
	178	/* interval formats: */
	179	/* 't' - use [t]raditional 3-block format */
	180	TIMEFMT_BASIC = (1 << 24),
	181	/* 'm' - select mm:ss */
	182	TIMEFMT_MMSS = (1 << 25),
	183	/* 'h' - select hh:mm:ss */
	184	TIMEFMT_HHMMSS = (1 << 26),
	185	/* 'd' - print as decimal number of seconds */
	186	TIMEFMT_DECIMAL = (1 << 27),
	187	/* 'mx'/'hx' - replace zero value with "--:--" or "--:--:--" */
	188	TIMEFMT_DASHES = (1 << 31),
	189
	190	/* helpers for reference */
	191	TIMEFMT_TIMER_DEADLINE =
	192	TIMEFMT_PRESELECT \| TIMEFMT_MONOTONIC \| TIMEFMT_UNTIL,
	193	TIMEFMT_TIMER_INTERVAL = TIMEFMT_PRESELECT,
	194	};
	195
	196	extern ssize_t printfrr_time(struct fbuf buf, struct printfrr_eargs ea,
	197	const struct timespec *ts, unsigned int flags);
	198
5e244469 RW	199	#ifdef __cplusplus
	200	}
	201	#endif
	202
7790a2d6	203	#endif /* _FRR_MONOTIME_H */