#define CCAN_TIME_H
#include "config.h"
#include <sys/time.h>
+#if HAVE_STRUCT_TIMESPEC
+#include <time.h>
+#else
+struct timespec {
+ time_t tv_sec; /* seconds */
+ long tv_nsec; /* nanoseconds */
+};
+#endif
#include <stdint.h>
#include <stdbool.h>
+#ifdef DEBUG
+#include <ccan/str/str.h>
+#define TIME_CHECK(t) \
+ time_check_((t), __FILE__ ":" stringify(__LINE__) " (" stringify(t) ") ")
+#define TIMEREL_CHECK(t) \
+ timerel_check((t), __FILE__ ":" stringify(__LINE__) " (" stringify(t) ") ")
+#define TIMEABS_CHECK(t) \
+ timeabs_check((t), __FILE__ ":" stringify(__LINE__) " (" stringify(t) ") ")
+#else
+#define TIME_CHECK(t) (t)
+#define TIMEREL_CHECK(t) (t)
+#define TIMEABS_CHECK(t) (t)
+#endif
+
+/**
+ * struct timerel - a relative time.
+ * @ts: the actual timespec value.
+ *
+ * For example, 1 second: ts.tv_sec = 1, ts.tv_nsec = 0
+ */
+struct timerel {
+ struct timespec ts;
+};
+
+/**
+ * struct timeabs - an absolue time.
+ * @ts: the actual timespec value.
+ *
+ * For example, Midnight UTC January 1st, 1970: ts.tv_sec = 0, ts.tv_nsec = 0
+ */
+struct timeabs {
+ struct timespec ts;
+};
+
+struct timespec time_check_(struct timespec in, const char *abortstr);
+
+/**
+ * timerel_check - check if a relative time is malformed.
+ * @in: the relative time to check (returned)
+ * @abortstr: the string to print to stderr before aborting (if set).
+ *
+ * This can be used to make sure a time isn't negative and doesn't
+ * have a tv_nsec >= 1000000000. If it is, and @abortstr is non-NULL,
+ * that will be printed and abort() is called. Otherwise, if
+ * @abortstr is NULL then the returned timerel will be normalized and
+ * tv_sec set to 0 if it was negative.
+ *
+ * Note that if ccan/time is compiled with DEBUG, then it will call this
+ * for all passed and returned times.
+ *
+ * Example:
+ * printf("Time to calc this was %lu nanoseconds\n",
+ * (long)timerel_check(time_between(time_now(), time_now()),
+ * "time_now() failed?").ts.tv_nsec);
+ */
+struct timerel timerel_check(struct timerel in, const char *abortstr);
+
+/**
+ * timeabs_check - check if an absolute time is malformed.
+ * @in: the relative time to check (returned)
+ * @abortstr: the string to print to stderr before aborting (if set).
+ *
+ * This can be used to make sure a time isn't negative and doesn't
+ * have a tv_nsec >= 1000000000. If it is, and @abortstr is non-NULL,
+ * that will be printed and abort() is called. Otherwise, if
+ * @abortstr is NULL then the returned timeabs will be normalized and
+ * tv_sec set to 0 if it was negative.
+ *
+ * Note that if ccan/time is compiled with DEBUG, then it will call this
+ * for all passed and returned times.
+ *
+ * Example:
+ * printf("Now is %lu seconds since epoch\n",
+ * (long)timeabs_check(time_now(), "time_now failed?").ts.tv_sec);
+ */
+struct timeabs timeabs_check(struct timeabs in, const char *abortstr);
+
/**
* time_now - return the current time
*
* Example:
- * printf("Now is %lu seconds since epoch\n", (long)time_now().tv_sec);
+ * printf("Now is %lu seconds since epoch\n", (long)time_now().ts.tv_sec);
*/
-struct timeval time_now(void);
+struct timeabs time_now(void);
+
+static inline bool time_greater_(struct timespec a, struct timespec b)
+{
+ if (TIME_CHECK(a).tv_sec > TIME_CHECK(b).tv_sec)
+ return true;
+ else if (a.tv_sec < b.tv_sec)
+ return false;
+
+ return a.tv_nsec > b.tv_nsec;
+}
/**
- * time_greater - is a after b?
- * @a: one time.
- * @b: another time.
+ * time_after - is a after b?
+ * @a: one abstime.
+ * @b: another abstime.
*
* Example:
- * static bool timed_out(const struct timeval *start)
+ * static bool timed_out(const struct timeabs *start)
* {
* #define TIMEOUT time_from_msec(1000)
- * return time_greater(time_now(), time_add(*start, TIMEOUT));
+ * return time_after(time_now(), timeabs_add(*start, TIMEOUT));
* }
*/
-bool time_greater(struct timeval a, struct timeval b);
+static inline bool time_after(struct timeabs a, struct timeabs b)
+{
+ return time_greater_(a.ts, b.ts);
+}
/**
- * time_less - is a before b?
- * @a: one time.
- * @b: another time.
+ * time_greater - is a greater than b?
+ * @a: one reltime.
+ * @b: another reltime.
+ */
+static inline bool time_greater(struct timerel a, struct timerel b)
+{
+ return time_greater_(a.ts, b.ts);
+}
+
+static inline bool time_less_(struct timespec a, struct timespec b)
+{
+ if (TIME_CHECK(a).tv_sec < TIME_CHECK(b).tv_sec)
+ return true;
+ else if (a.tv_sec > b.tv_sec)
+ return false;
+
+ return a.tv_nsec < b.tv_nsec;
+}
+
+/**
+ * time_before - is a before b?
+ * @a: one absolute time.
+ * @b: another absolute time.
*
* Example:
- * static bool still_valid(const struct timeval *start)
+ * static bool still_valid(const struct timeabs *start)
* {
* #define TIMEOUT time_from_msec(1000)
- * return time_less(time_now(), time_add(*start, TIMEOUT));
+ * return time_before(time_now(), timeabs_add(*start, TIMEOUT));
* }
*/
-bool time_less(struct timeval a, struct timeval b);
+static inline bool time_before(struct timeabs a, struct timeabs b)
+{
+ return time_less_(a.ts, b.ts);
+}
+
+/**
+ * time_less - is a before b?
+ * @a: one relative time.
+ * @b: another relative time.
+ */
+static inline bool time_less(struct timerel a, struct timerel b)
+{
+ return time_less_(a.ts, b.ts);
+}
/**
- * time_eq - is a equal to b?
- * @a: one time.
- * @b: another time.
+ * timeabs_eq - is a equal to b?
+ * @a: one absolute time.
+ * @b: another absolute time.
*
* Example:
* #include <sys/types.h>
* #include <sys/wait.h>
*
- * // Can we fork in under a microsecond?
+ * // Can we fork in under a nanosecond?
* static bool fast_fork(void)
* {
- * struct timeval start = time_now();
+ * struct timeabs start = time_now();
* if (fork() != 0) {
* exit(0);
* }
* wait(NULL);
- * return time_eq(start, time_now());
+ * return timeabs_eq(start, time_now());
* }
*/
-bool time_eq(struct timeval a, struct timeval b);
+static inline bool timeabs_eq(struct timeabs a, struct timeabs b)
+{
+ return TIMEABS_CHECK(a).ts.tv_sec == TIMEABS_CHECK(b).ts.tv_sec
+ && a.ts.tv_nsec == b.ts.tv_nsec;
+}
/**
- * time_sub - subtract two times
- * @recent: the larger (more recent) time.
- * @old: the smaller (less recent) time.
+ * timerel_eq - is a equal to b?
+ * @a: one relative time.
+ * @b: another relative time.
*
- * This returns a well formed struct timeval.
+ * Example:
+ * #include <sys/types.h>
+ * #include <sys/wait.h>
+ *
+ * // Can we fork in under a nanosecond?
+ * static bool fast_fork(void)
+ * {
+ * struct timeabs start = time_now();
+ * struct timerel diff, zero = { .ts = { 0, 0 } };
+ * if (fork() != 0) {
+ * exit(0);
+ * }
+ * wait(NULL);
+ * diff = time_between(start, time_now());
+ * return timerel_eq(diff, zero);
+ * }
+ */
+static inline bool timerel_eq(struct timerel a, struct timerel b)
+{
+ return TIMEREL_CHECK(a).ts.tv_sec == TIMEREL_CHECK(b).ts.tv_sec
+ && a.ts.tv_nsec == b.ts.tv_nsec;
+}
+
+static inline struct timespec time_sub_(struct timespec recent,
+ struct timespec old)
+{
+ struct timespec diff;
+
+ diff.tv_sec = TIME_CHECK(recent).tv_sec - TIME_CHECK(old).tv_sec;
+ if (old.tv_nsec > recent.tv_nsec) {
+ diff.tv_sec--;
+ diff.tv_nsec = 1000000000 + recent.tv_nsec - old.tv_nsec;
+ } else
+ diff.tv_nsec = recent.tv_nsec - old.tv_nsec;
+
+ return TIME_CHECK(diff);
+}
+
+/**
+ * time_sub - subtract two relative times
+ * @a: the larger time.
+ * @b: the smaller time.
+ *
+ * This returns a well formed struct timerel of @a - @b.
+ */
+static inline struct timerel time_sub(struct timerel a, struct timerel b)
+{
+ struct timerel t;
+
+ t.ts = time_sub_(a.ts, b.ts);
+ return t;
+}
+
+/**
+ * time_between - time between two absolute times
+ * @recent: the larger time.
+ * @old: the smaller time.
+ *
+ * This returns a well formed struct timerel of @a - @b.
+ */
+static inline struct timerel time_between(struct timeabs recent, struct timeabs old)
+{
+ struct timerel t;
+
+ t.ts = time_sub_(recent.ts, old.ts);
+ return t;
+}
+
+/**
+ * timeabs_sub - subtract a relative time from an absolute time
+ * @abs: the absolute time.
+ * @rel: the relative time.
+ *
+ * This returns a well formed struct timeabs of @a - @b.
*
* Example:
- * static bool was_recent(const struct timeval *start)
+ * // We do one every second.
+ * static struct timeabs previous_time(void)
* {
- * return time_sub(time_now(), *start).tv_sec < 1;
+ * return timeabs_sub(time_now(), time_from_msec(1000));
* }
*/
-struct timeval time_sub(struct timeval recent, struct timeval old);
+static inline struct timeabs timeabs_sub(struct timeabs abs, struct timerel rel)
+{
+ struct timeabs t;
+
+ t.ts = time_sub_(abs.ts, rel.ts);
+ return t;
+}
+
+static inline struct timespec time_add_(struct timespec a, struct timespec b)
+{
+ struct timespec sum;
+
+ sum.tv_sec = TIME_CHECK(a).tv_sec + TIME_CHECK(b).tv_sec;
+ sum.tv_nsec = a.tv_nsec + b.tv_nsec;
+ if (sum.tv_nsec >= 1000000000) {
+ sum.tv_sec++;
+ sum.tv_nsec -= 1000000000;
+ }
+ return TIME_CHECK(sum);
+}
/**
- * time_add - add two times
- * @a: one time.
- * @b: another time.
+ * timeabs_add - add a relative to an absolute time
+ * @a: the absolute time.
+ * @b: a relative time.
*
* The times must not overflow, or the results are undefined.
*
* Example:
* // We do one every second.
- * static struct timeval next_time(void)
+ * static struct timeabs next_time(void)
* {
- * return time_add(time_now(), time_from_msec(1000));
+ * return timeabs_add(time_now(), time_from_msec(1000));
* }
*/
-struct timeval time_add(struct timeval a, struct timeval b);
+static inline struct timeabs timeabs_add(struct timeabs a, struct timerel b)
+{
+ struct timeabs t;
+
+ t.ts = time_add_(a.ts, b.ts);
+ return t;
+}
+
+/**
+ * timerel_add - add two relative times
+ * @a: one relative time.
+ * @b: another relative time.
+ *
+ * The times must not overflow, or the results are undefined.
+ *
+ * Example:
+ * static struct timerel double_time(struct timerel a)
+ * {
+ * return timerel_add(a, a);
+ * }
+ */
+static inline struct timerel timerel_add(struct timerel a, struct timerel b)
+{
+ struct timerel t;
+
+ t.ts = time_add_(a.ts, b.ts);
+ return t;
+}
/**
* time_divide - divide a time by a value.
*
* Example:
* // How long does it take to do a fork?
- * static struct timeval forking_time(void)
+ * static struct timerel forking_time(void)
* {
- * struct timeval start = time_now();
+ * struct timeabs start = time_now();
* unsigned int i;
*
* for (i = 0; i < 1000; i++) {
* }
* wait(NULL);
* }
- * return time_divide(time_sub(time_now(), start), i);
+ * return time_divide(time_between(time_now(), start), i);
* }
*/
-struct timeval time_divide(struct timeval t, unsigned long div);
+struct timerel time_divide(struct timerel t, unsigned long div);
/**
* time_multiply - multiply a time by a value.
- * @t: a time.
+ * @t: a relative time.
* @mult: number to multiply it by.
*
* Example:
* ...
* printf("Time to do 100000 forks would be %u sec\n",
- * (unsigned)time_multiply(forking_time(), 1000000).tv_sec);
+ * (unsigned)time_multiply(forking_time(), 1000000).ts.tv_sec);
*/
-struct timeval time_multiply(struct timeval t, unsigned long mult);
+struct timerel time_multiply(struct timerel t, unsigned long mult);
/**
- * time_to_msec - return number of milliseconds
+ * time_to_sec - return number of seconds
* @t: a time
*
+ * It's often more convenient to deal with time values as seconds.
+ * Note that this will fit into an unsigned 32-bit variable if it's a
+ * time of less than about 136 years.
+ *
+ * Example:
+ * ...
+ * printf("Forking time is %u sec\n",
+ * (unsigned)time_to_sec(forking_time()));
+ */
+static inline uint64_t time_to_sec(struct timerel t)
+{
+ return t.ts.tv_sec;
+}
+
+/**
+ * time_to_msec - return number of milliseconds
+ * @t: a relative time
+ *
* It's often more convenient to deal with time values as
* milliseconds. Note that this will fit into a 32-bit variable if
* it's a time difference of less than ~7 weeks.
* printf("Forking time is %u msec\n",
* (unsigned)time_to_msec(forking_time()));
*/
-uint64_t time_to_msec(struct timeval t);
+static inline uint64_t time_to_msec(struct timerel t)
+{
+ uint64_t msec;
+
+ msec = TIMEREL_CHECK(t).ts.tv_nsec/1000000 + (uint64_t)t.ts.tv_sec*1000;
+ return msec;
+}
/**
* time_to_usec - return number of microseconds
- * @t: a time
+ * @t: a relative time
*
* It's often more convenient to deal with time values as
* microseconds. Note that this will fit into a 32-bit variable if
* (unsigned)time_to_usec(forking_time()));
*
*/
-uint64_t time_to_usec(struct timeval t);
+static inline uint64_t time_to_usec(struct timerel t)
+{
+ uint64_t usec;
+
+ usec = TIMEREL_CHECK(t).ts.tv_nsec/1000 + (uint64_t)t.ts.tv_sec*1000000;
+ return usec;
+}
+
+/**
+ * time_to_nsec - return number of nanoseconds
+ * @t: a relative time
+ *
+ * It's sometimes more convenient to deal with time values as
+ * nanoseconds. Note that this will fit into a 32-bit variable if
+ * it's a time difference of less than ~4 seconds.
+ *
+ * Example:
+ * ...
+ * printf("Forking time is %u nsec\n",
+ * (unsigned)time_to_nsec(forking_time()));
+ *
+ */
+static inline uint64_t time_to_nsec(struct timerel t)
+{
+ uint64_t nsec;
+
+ nsec = TIMEREL_CHECK(t).ts.tv_nsec + (uint64_t)t.ts.tv_sec * 1000000000;
+ return nsec;
+}
+
+/**
+ * time_from_sec - convert seconds to a relative time
+ * @msec: time in seconds
+ *
+ * Example:
+ * // 1 minute timeout
+ * #define TIMEOUT time_from_sec(60)
+ */
+static inline struct timerel time_from_sec(uint64_t sec)
+{
+ struct timerel t;
+
+ t.ts.tv_nsec = 0;
+ t.ts.tv_sec = sec;
+ return TIMEREL_CHECK(t);
+}
/**
- * time_from_msec - convert milliseconds to a timeval
+ * time_from_msec - convert milliseconds to a relative time
* @msec: time in milliseconds
*
* Example:
* // 1/2 second timeout
* #define TIMEOUT time_from_msec(500)
*/
-struct timeval time_from_msec(uint64_t msec);
+static inline struct timerel time_from_msec(uint64_t msec)
+{
+ struct timerel t;
+
+ t.ts.tv_nsec = (msec % 1000) * 1000000;
+ t.ts.tv_sec = msec / 1000;
+ return TIMEREL_CHECK(t);
+}
/**
- * time_from_usec - convert microseconds to a timeval
+ * time_from_usec - convert microseconds to a relative time
* @usec: time in microseconds
*
* Example:
* // 1/2 second timeout
* #define TIMEOUT time_from_usec(500000)
*/
-struct timeval time_from_usec(uint64_t usec);
+static inline struct timerel time_from_usec(uint64_t usec)
+{
+ struct timerel t;
+
+ t.ts.tv_nsec = (usec % 1000000) * 1000;
+ t.ts.tv_sec = usec / 1000000;
+ return TIMEREL_CHECK(t);
+}
+
+/**
+ * time_from_nsec - convert nanoseconds to a relative time
+ * @nsec: time in nanoseconds
+ *
+ * Example:
+ * // 1/2 second timeout
+ * #define TIMEOUT time_from_nsec(500000000)
+ */
+static inline struct timerel time_from_nsec(uint64_t nsec)
+{
+ struct timerel t;
+ t.ts.tv_nsec = nsec % 1000000000;
+ t.ts.tv_sec = nsec / 1000000000;
+ return TIMEREL_CHECK(t);
+}
+
+static inline struct timeval timespec_to_timeval(struct timespec ts)
+{
+ struct timeval tv;
+ tv.tv_sec = ts.tv_sec;
+ tv.tv_usec = ts.tv_nsec / 1000;
+ return tv;
+}
+
+/**
+ * timerel_to_timeval - convert a relative time to a timeval.
+ * @t: a relative time.
+ *
+ * Example:
+ * struct timerel t = { { 100, 0 } }; // 100 seconds
+ * struct timeval tv;
+ *
+ * tv = timerel_to_timeval(t);
+ * printf("time = %lu.%06u\n", (long)tv.tv_sec, (int)tv.tv_usec);
+ */
+static inline struct timeval timerel_to_timeval(struct timerel t)
+{
+ return timespec_to_timeval(t.ts);
+}
+
+/**
+ * timeabs_to_timeval - convert an absolute time to a timeval.
+ * @t: an absolute time.
+ *
+ * Example:
+ * struct timeval tv;
+ *
+ * tv = timeabs_to_timeval(time_now());
+ * printf("time = %lu.%06u\n", (long)tv.tv_sec, (int)tv.tv_usec);
+ */
+static inline struct timeval timeabs_to_timeval(struct timeabs t)
+{
+ return timespec_to_timeval(t.ts);
+}
+
+static inline struct timespec timeval_to_timespec(struct timeval tv)
+{
+ struct timespec ts;
+ ts.tv_sec = tv.tv_sec;
+ ts.tv_nsec = tv.tv_usec * 1000;
+ return ts;
+}
+
+/**
+ * timeval_to_timerel - convert a timeval to a relative time.
+ * @tv: a timeval.
+ *
+ * Example:
+ * struct timeval tv = { 0, 500 };
+ * struct timerel t;
+ *
+ * t = timeval_to_timerel(tv);
+ * printf("timerel = %lu.%09lu\n", (long)t.ts.tv_sec, (long)t.ts.tv_nsec);
+ */
+static inline struct timerel timeval_to_timerel(struct timeval tv)
+{
+ struct timerel t;
+ t.ts = timeval_to_timespec(tv);
+ return TIMEREL_CHECK(t);
+}
+
+/**
+ * timeval_to_timeabs - convert a timeval to an absolute time.
+ * @tv: a timeval.
+ *
+ * Example:
+ * struct timeval tv = { 1401762008, 500 };
+ * struct timeabs t;
+ *
+ * t = timeval_to_timeabs(tv);
+ * printf("timeabs = %lu.%09lu\n", (long)t.ts.tv_sec, (long)t.ts.tv_nsec);
+ */
+static inline struct timeabs timeval_to_timeabs(struct timeval tv)
+{
+ struct timeabs t;
+ t.ts = timeval_to_timespec(tv);
+ return TIMEABS_CHECK(t);
+}
#endif /* CCAN_TIME_H */
projects / ccan / blobdiff