time: split absolute and relative times.
authorRusty Russell <rusty@rustcorp.com.au>
Tue, 3 Jun 2014 03:56:13 +0000 (13:26 +0930)
committerRusty Russell <rusty@rustcorp.com.au>
Tue, 10 Jun 2014 06:00:28 +0000 (15:30 +0930)
As suggested by David Gibson.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
ccan/time/_info
ccan/time/test/run-check.c
ccan/time/test/run.c
ccan/time/time.c
ccan/time/time.h

index 9d1301c7385f9e375d241c13009fdee5d2281d5e..5cf20f79611a85e3322b4b08b0ae57dadd547efb 100644 (file)
@@ -5,7 +5,8 @@
  * time - routines for dealing with time
  *
  * This code provides convenient functions for working with time, in the
- * form of 'struct timespec'.
+ * form of 'struct timerel' for durations and 'struct timeabs' for timestamps
+ * which are light wrappers around struct timespec.
  *
  * Author: Rusty Russell <rusty@rustcorp.com.au>
  * License: BSD-MIT
  *
  *     int main(int argc, char *argv[])
  *     {
- *             struct timespec t;
+ *             struct timeabs t;
  *
  *             if (argc != 2)
  *                     errx(1, "Usage: %s <diff in millisec>", argv[0]);
  *
  *             t = time_now();
  *             if (argv[1][0] == '-')
- *                     t = time_sub(t, time_from_msec(atol(argv[1]+1)));
+ *                     t = timeabs_sub(t, time_from_msec(atol(argv[1]+1)));
  *             else
- *                     t = time_add(t, time_from_msec(atol(argv[1])));
+ *                     t = timeabs_add(t, time_from_msec(atol(argv[1])));
  *
  *             printf("%lu.%09u\n",
- *                    (unsigned long)t.tv_sec, (unsigned)t.tv_nsec);
+ *                    (unsigned long)t.ts.tv_sec, (unsigned)t.ts.tv_nsec);
  *             return 0;
  *     }
  */
index 37763ab46b211e3a8bc24a9a4edc755d24306750..3c2e282fd4b4b40e47962066b6c45d6ef018ffc7 100644 (file)
@@ -16,140 +16,145 @@ void abort(void)
 
 int main(void)
 {
-       struct timespec t1, t2, t3, zero = { 0, 0 };
+       struct timeabs t1, t2, epoch = { { 0, 0 } };
+       struct timerel t3, t4, zero = { { 0, 0 } };
        int fds[2];
 
-       plan_tests(62);
+       plan_tests(64);
 
        /* Test time_now */
        t1 = time_now();
        t2 = time_now();
 
-       /* Test time_sub. */
-       t3 = time_sub(t2, t1);
-       ok1(t3.tv_sec > 0 || t3.tv_nsec >= 0);
-       t3 = time_sub(t2, t2);
-       ok1(t3.tv_sec == 0 && t3.tv_nsec == 0);
-       t3 = time_sub(t1, t1);
-       ok1(t3.tv_sec == 0 && t3.tv_nsec == 0);
-
-       /* Test time_eq */
-       ok1(time_eq(t1, t1));
-       ok1(time_eq(t2, t2));
-       ok1(!time_eq(t1, t3));
-       ok1(!time_eq(t2, t3));
+       /* Test time_between. */
+       t3 = time_between(t2, t1);
+       ok1(t3.ts.tv_sec > 0 || t3.ts.tv_nsec >= 0);
+       t3 = time_between(t2, t2);
+       ok1(t3.ts.tv_sec == 0 && t3.ts.tv_nsec == 0);
+       t3 = time_between(t1, t1);
+       ok1(t3.ts.tv_sec == 0 && t3.ts.tv_nsec == 0);
+
+       /* Test timeabs_eq / timerel_eq */
+       ok1(timeabs_eq(t1, t1));
+       ok1(timeabs_eq(t2, t2));
+       ok1(!timeabs_eq(t1, epoch));
+       ok1(!timeabs_eq(t2, epoch));
+       t3.ts.tv_sec = 1;
+       ok1(timerel_eq(t3, t3));
+       ok1(!timerel_eq(t3, zero));
 
        /* Make sure t2 > t1. */
-       t3.tv_sec = 0;
-       t3.tv_nsec = 1;
-       t2 = time_add(t2, t3);
-
-       /* Test time_less and time_greater. */
-       ok1(!time_eq(t1, t2));
-       ok1(!time_greater(t1, t2));
-       ok1(time_less(t1, t2));
-       ok1(time_greater(t2, t1));
-       ok1(!time_less(t2, t1));
-       t3.tv_sec = 0;
-       t3.tv_nsec = 999999999;
-       t2 = time_add(t2, t3);
-       ok1(!time_eq(t1, t2));
-       ok1(!time_greater(t1, t2));
-       ok1(time_less(t1, t2));
-       ok1(time_greater(t2, t1));
-       ok1(!time_less(t2, t1));
-
-       t3 = time_sub(t2, zero);
-       ok1(time_eq(t3, t2));
-       t3 = time_sub(t2, t2);
-       ok1(time_eq(t3, zero));
+       t3.ts.tv_sec = 0;
+       t3.ts.tv_nsec = 1;
+       t2 = timeabs_add(t2, t3);
+
+       /* Test time_before and time_after. */
+       ok1(!timeabs_eq(t1, t2));
+       ok1(!time_after(t1, t2));
+       ok1(time_before(t1, t2));
+       ok1(time_after(t2, t1));
+       ok1(!time_before(t2, t1));
+       t3.ts.tv_sec = 0;
+       t3.ts.tv_nsec = 999999999;
+       t2 = timeabs_add(t2, t3);
+       ok1(!timeabs_eq(t1, t2));
+       ok1(!time_after(t1, t2));
+       ok1(time_before(t1, t2));
+       ok1(time_after(t2, t1));
+       ok1(!time_before(t2, t1));
+
+       t3 = time_between(t2, epoch);
+       ok1(t2.ts.tv_sec == t3.ts.tv_sec && t2.ts.tv_nsec == t3.ts.tv_nsec);
+       t3 = time_between(t2, t2);
+       ok1(timerel_eq(t3, zero));
 
        /* time_from_msec / time_to_msec */
        t3 = time_from_msec(500);
-       ok1(t3.tv_sec == 0);
-       ok1(t3.tv_nsec == 500000000);
+       ok1(t3.ts.tv_sec == 0);
+       ok1(t3.ts.tv_nsec == 500000000);
        ok1(time_to_msec(t3) == 500);
 
        t3 = time_from_msec(1000);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 0);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 0);
        ok1(time_to_msec(t3) == 1000);
 
        t3 = time_from_msec(1500);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 500000000);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 500000000);
        ok1(time_to_msec(t3) == 1500);
 
        /* time_from_usec */
        t3 = time_from_usec(500000);
-       ok1(t3.tv_sec == 0);
-       ok1(t3.tv_nsec == 500000000);
+       ok1(t3.ts.tv_sec == 0);
+       ok1(t3.ts.tv_nsec == 500000000);
        ok1(time_to_usec(t3) == 500000);
 
        t3 = time_from_usec(1000000);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 0);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 0);
        ok1(time_to_usec(t3) == 1000000);
 
        t3 = time_from_usec(1500000);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 500000000);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 500000000);
        ok1(time_to_usec(t3) == 1500000);
 
        /* time_from_nsec */
        t3 = time_from_nsec(500000000);
-       ok1(t3.tv_sec == 0);
-       ok1(t3.tv_nsec == 500000000);
+       ok1(t3.ts.tv_sec == 0);
+       ok1(t3.ts.tv_nsec == 500000000);
        ok1(time_to_nsec(t3) == 500000000);
 
        t3 = time_from_nsec(1000000000);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 0);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 0);
        ok1(time_to_nsec(t3) == 1000000000);
 
        t3 = time_from_nsec(1500000000);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 500000000);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 500000000);
        ok1(time_to_nsec(t3) == 1500000000);
 
        /* Test wrapunder */
-       t3 = time_sub(time_sub(t2, time_from_msec(500)), time_from_msec(500));
-       ok1(t3.tv_sec == t2.tv_sec - 1);
-       ok1(t3.tv_nsec == t2.tv_nsec);
+       t1 = timeabs_sub(timeabs_sub(t2, time_from_msec(500)),
+                        time_from_msec(500));
+       ok1(t1.ts.tv_sec == t2.ts.tv_sec - 1);
+       ok1(t1.ts.tv_nsec == t2.ts.tv_nsec);
 
        /* time_divide and time_multiply */
-       t1.tv_nsec = 100;
-       t1.tv_sec = 100;
+       t4.ts.tv_nsec = 100;
+       t4.ts.tv_sec = 100;
 
-       t3 = time_divide(t1, 2);
-       ok1(t3.tv_sec == 50);
-       ok1(t3.tv_nsec == 50);
+       t3 = time_divide(t4, 2);
+       ok1(t3.ts.tv_sec == 50);
+       ok1(t3.ts.tv_nsec == 50);
 
-       t3 = time_divide(t1, 100);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 1);
+       t3 = time_divide(t4, 100);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 1);
 
        t3 = time_multiply(t3, 100);
-       ok1(time_eq(t3, t1));
+       ok1(timerel_eq(t3, t4));
 
-       t3 = time_divide(t1, 200);
-       ok1(t3.tv_sec == 0);
-       ok1(t3.tv_nsec == 500000000);
+       t3 = time_divide(t4, 200);
+       ok1(t3.ts.tv_sec == 0);
+       ok1(t3.ts.tv_nsec == 500000000);
 
        /* Divide by huge number. */
-       t1.tv_sec = (1U << 31) - 1;
-       t1.tv_nsec = 999999999;
-       t2 = time_divide(t1, 1 << 30);
+       t4.ts.tv_sec = (1U << 31) - 1;
+       t4.ts.tv_nsec = 999999999;
+       t3 = time_divide(t4, 1 << 30);
        /* Allow us to round either way. */
-       ok1((t2.tv_sec == 2 && t2.tv_nsec == 0)
-           || (t2.tv_sec == 1 && t2.tv_nsec == 999999999));
+       ok1((t3.ts.tv_sec == 2 && t3.ts.tv_nsec == 0)
+           || (t3.ts.tv_sec == 1 && t3.ts.tv_nsec == 999999999));
 
        /* Multiply by huge number. */
-       t1.tv_sec = 0;
-       t1.tv_nsec = 1;
-       t2 = time_multiply(t1, 1UL << 31);
-       ok1(t2.tv_sec == 2);
-       ok1(t2.tv_nsec == 147483648);
+       t4.ts.tv_sec = 0;
+       t4.ts.tv_nsec = 1;
+       t3 = time_multiply(t4, 1UL << 31);
+       ok1(t3.ts.tv_sec == 2);
+       ok1(t3.ts.tv_nsec == 147483648);
 
        pipe(fds);
 
@@ -159,20 +164,20 @@ int main(void)
                close(fds[0]);
                dup2(fds[1], 1);
                dup2(fds[1], 2);
-               t1.tv_sec = 7;
-               t1.tv_nsec = 1000000001;
-               t2 = time_check(t1, NULL);
-               if (t2.tv_sec != 8 || t2.tv_nsec != 1)
+               t1.ts.tv_sec = 7;
+               t1.ts.tv_nsec = 1000000001;
+               t2 = timeabs_check(t1, NULL);
+               if (t2.ts.tv_sec != 8 || t2.ts.tv_nsec != 1)
                        exit(1);
-               t1.tv_sec = -1;
-               t1.tv_nsec = 5;
-               t2 = time_check(t1, NULL);
-               if (t2.tv_sec != 0 || t2.tv_nsec != 5)
+               t1.ts.tv_sec = -1;
+               t1.ts.tv_nsec = 5;
+               t2 = timeabs_check(t1, NULL);
+               if (t2.ts.tv_sec != 0 || t2.ts.tv_nsec != 5)
                        exit(1);
-               t1.tv_sec = 8;
-               t1.tv_nsec = 1000000002;
+               t1.ts.tv_sec = 8;
+               t1.ts.tv_nsec = 1000000002;
                /* We expect this to abort! */
-               t2 = time_check(t1, "abortstr");
+               t2 = timeabs_check(t1, "abortstr");
                exit(1);
                
        default: {
index 21c722134865a919175ed69c6eefd45fcb8ccb63..63f397aa964b2781698628f0735b133d1f9f284e 100644 (file)
 
 int main(void)
 {
-       struct timespec t1, t2, t3, zero = { 0, 0 };
+       struct timeabs t1, t2;
+       struct timerel t3, t4, zero = { { 0, 0 } };
 
-       plan_tests(61);
+       plan_tests(66);
 
        /* Test time_now */
        t1 = time_now();
        t2 = time_now();
 
-       /* Test time_sub. */
-       t3 = time_sub(t2, t1);
-       ok1(t3.tv_sec > 0 || t3.tv_nsec >= 0);
-       t3 = time_sub(t2, t2);
-       ok1(t3.tv_sec == 0 && t3.tv_nsec == 0);
-       t3 = time_sub(t1, t1);
-       ok1(t3.tv_sec == 0 && t3.tv_nsec == 0);
-
-       /* Test time_eq */
-       ok1(time_eq(t1, t1));
-       ok1(time_eq(t2, t2));
-       ok1(!time_eq(t1, t3));
-       ok1(!time_eq(t2, t3));
+       /* Test time_between. */
+       t3 = time_between(t2, t1);
+       ok1(t3.ts.tv_sec > 0 || t3.ts.tv_nsec >= 0);
+       t3 = time_between(t2, t2);
+       ok1(t3.ts.tv_sec == 0 && t3.ts.tv_nsec == 0);
+       t3 = time_between(t1, t1);
+       ok1(t3.ts.tv_sec == 0 && t3.ts.tv_nsec == 0);
+
+       /* Test timeabs_eq / timerel_eq */
+       ok1(timeabs_eq(t1, t1));
+       ok1(timeabs_eq(t2, t2));
+       t3.ts.tv_sec = 0;
+       t3.ts.tv_nsec = 1;
+       ok1(!timerel_eq(t3, zero));
+       ok1(!timerel_eq(t3, zero));
 
        /* Make sure t2 > t1. */
-       t3.tv_sec = 0;
-       t3.tv_nsec = 1;
-       t2 = time_add(t2, t3);
+       t2 = timeabs_add(t2, t3);
+
+       /* Test time_after and time_before. */
+       ok1(!timeabs_eq(t1, t2));
+       ok1(!time_after(t1, t2));
+       ok1(time_before(t1, t2));
+       ok1(time_after(t2, t1));
+       ok1(!time_before(t2, t1));
+       t3.ts.tv_sec = 0;
+       t3.ts.tv_nsec = 999999999;
+       t2 = timeabs_add(t2, t3);
+       ok1(!timeabs_eq(t1, t2));
+       ok1(!time_after(t1, t2));
+       ok1(time_before(t1, t2));
+       ok1(time_after(t2, t1));
+       ok1(!time_before(t2, t1));
 
        /* Test time_less and time_greater. */
-       ok1(!time_eq(t1, t2));
-       ok1(!time_greater(t1, t2));
-       ok1(time_less(t1, t2));
-       ok1(time_greater(t2, t1));
-       ok1(!time_less(t2, t1));
-       t3.tv_sec = 0;
-       t3.tv_nsec = 999999999;
-       t2 = time_add(t2, t3);
-       ok1(!time_eq(t1, t2));
-       ok1(!time_greater(t1, t2));
-       ok1(time_less(t1, t2));
-       ok1(time_greater(t2, t1));
-       ok1(!time_less(t2, t1));
-
-       t3 = time_sub(t2, zero);
-       ok1(time_eq(t3, t2));
-       t3 = time_sub(t2, t2);
-       ok1(time_eq(t3, zero));
+       ok1(time_less(zero, t3));
+       ok1(!time_greater(zero, t3));
+       ok1(!time_less(t3, zero));
+       ok1(time_greater(t3, zero));
+
+       /* Test time_sub */
+       t3 = time_sub(t3, t3);
+       ok1(timerel_eq(t3, zero));
+
+       /* Test time_between */
+       t3 = time_between(t2, t2);
+       ok1(timerel_eq(t3, zero));
+       t3.ts.tv_sec = 0;
+       t3.ts.tv_nsec = 999999999;
+       t1 = timeabs_add(t2, t3);
+       t3 = time_between(t1, t2);
+       ok1(t3.ts.tv_sec == 0 && t3.ts.tv_nsec == 999999999);
 
        /* time_from_sec / time_to_sec */
        t3 = time_from_sec(500);
-       ok1(t3.tv_sec == 500);
-       ok1(t3.tv_nsec == 0);
+       ok1(t3.ts.tv_sec == 500);
+       ok1(t3.ts.tv_nsec == 0);
        ok1(time_to_sec(t3) == 500);
 
        /* time_from_msec / time_to_msec */
        t3 = time_from_msec(500);
-       ok1(t3.tv_sec == 0);
-       ok1(t3.tv_nsec == 500000000);
+       ok1(t3.ts.tv_sec == 0);
+       ok1(t3.ts.tv_nsec == 500000000);
        ok1(time_to_msec(t3) == 500);
 
        t3 = time_from_msec(1000);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 0);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 0);
        ok1(time_to_msec(t3) == 1000);
 
        t3 = time_from_msec(1500);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 500000000);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 500000000);
        ok1(time_to_msec(t3) == 1500);
 
        /* time_from_usec */
        t3 = time_from_usec(500000);
-       ok1(t3.tv_sec == 0);
-       ok1(t3.tv_nsec == 500000000);
+       ok1(t3.ts.tv_sec == 0);
+       ok1(t3.ts.tv_nsec == 500000000);
        ok1(time_to_usec(t3) == 500000);
 
        t3 = time_from_usec(1000000);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 0);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 0);
        ok1(time_to_usec(t3) == 1000000);
 
        t3 = time_from_usec(1500000);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 500000000);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 500000000);
        ok1(time_to_usec(t3) == 1500000);
 
        /* time_from_nsec */
        t3 = time_from_nsec(500000000);
-       ok1(t3.tv_sec == 0);
-       ok1(t3.tv_nsec == 500000000);
+       ok1(t3.ts.tv_sec == 0);
+       ok1(t3.ts.tv_nsec == 500000000);
        ok1(time_to_nsec(t3) == 500000000);
 
        t3 = time_from_nsec(1000000000);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 0);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 0);
        ok1(time_to_nsec(t3) == 1000000000);
 
        t3 = time_from_nsec(1500000000);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 500000000);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 500000000);
        ok1(time_to_nsec(t3) == 1500000000);
 
        /* Test wrapunder */
-       t3 = time_sub(time_sub(t2, time_from_msec(500)), time_from_msec(500));
-       ok1(t3.tv_sec == t2.tv_sec - 1);
-       ok1(t3.tv_nsec == t2.tv_nsec);
+       t1 = timeabs_sub(timeabs_sub(t2, time_from_msec(500)), time_from_msec(500));
+       ok1(t1.ts.tv_sec == t2.ts.tv_sec - 1);
+       ok1(t1.ts.tv_nsec == t2.ts.tv_nsec);
 
        /* time_divide and time_multiply */
-       t1.tv_nsec = 100;
-       t1.tv_sec = 100;
+       t4.ts.tv_nsec = 100;
+       t4.ts.tv_sec = 100;
 
-       t3 = time_divide(t1, 2);
-       ok1(t3.tv_sec == 50);
-       ok1(t3.tv_nsec == 50);
+       t3 = time_divide(t4, 2);
+       ok1(t3.ts.tv_sec == 50);
+       ok1(t3.ts.tv_nsec == 50);
 
-       t3 = time_divide(t1, 100);
-       ok1(t3.tv_sec == 1);
-       ok1(t3.tv_nsec == 1);
+       t3 = time_divide(t4, 100);
+       ok1(t3.ts.tv_sec == 1);
+       ok1(t3.ts.tv_nsec == 1);
 
        t3 = time_multiply(t3, 100);
-       ok1(time_eq(t3, t1));
+       ok1(timerel_eq(t3, t4));
 
-       t3 = time_divide(t1, 200);
-       ok1(t3.tv_sec == 0);
-       ok1(t3.tv_nsec == 500000000);
+       t3 = time_divide(t4, 200);
+       ok1(t3.ts.tv_sec == 0);
+       ok1(t3.ts.tv_nsec == 500000000);
 
        /* Divide by huge number. */
-       t1.tv_sec = (1U << 31) - 1;
-       t1.tv_nsec = 999999999;
-       t2 = time_divide(t1, 1 << 30);
+       t4.ts.tv_sec = (1U << 31) - 1;
+       t4.ts.tv_nsec = 999999999;
+       t3 = time_divide(t4, 1 << 30);
        /* Allow us to round either way. */
-       ok1((t2.tv_sec == 2 && t2.tv_nsec == 0)
-           || (t2.tv_sec == 1 && t2.tv_nsec == 999999999));
+       ok1((t3.ts.tv_sec == 2 && t3.ts.tv_nsec == 0)
+           || (t3.ts.tv_sec == 1 && t3.ts.tv_nsec == 999999999));
 
        /* Multiply by huge number. */
-       t1.tv_sec = 0;
-       t1.tv_nsec = 1;
-       t2 = time_multiply(t1, 1UL << 31);
-       ok1(t2.tv_sec == 2);
-       ok1(t2.tv_nsec == 147483648);
+       t4.ts.tv_sec = 0;
+       t4.ts.tv_nsec = 1;
+       t3 = time_multiply(t4, 1UL << 31);
+       ok1(t3.ts.tv_sec == 2);
+       ok1(t3.ts.tv_nsec == 147483648);
 
        return exit_status();
 }
index 166832d8a961d56b8ebcf9ebd4b58c62d1b1e4ed..54cb3f4b73ae601cf469592237bc165748593e4c 100644 (file)
@@ -6,33 +6,33 @@
 #if !HAVE_CLOCK_GETTIME && !HAVE_CLOCK_GETTIME_IN_LIBRT
 #include <sys/time.h>
 
-struct timespec time_now(void)
+struct timeabs time_now(void)
 {
        struct timeval now;
-       struct timespec ret;
+       struct timeabs ret;
        gettimeofday(&now, NULL);
-       ret.tv_sec = now.tv_sec;
-       ret.tv_nsec = now.tv_usec * 1000;
-       return TIME_CHECK(ret);
+       ret.ts.tv_sec = now.tv_sec;
+       ret.ts.tv_nsec = now.tv_usec * 1000;
+       return TIMEABS_CHECK(ret);
 }
 #else
 #include <time.h>
-struct timespec time_now(void)
+struct timeabs time_now(void)
 {
-       struct timespec ret;
-       clock_gettime(CLOCK_REALTIME, &ret);
-       return TIME_CHECK(ret);
+       struct timeabs ret;
+       clock_gettime(CLOCK_REALTIME, &ret.ts);
+       return TIMEABS_CHECK(ret);
 }
 #endif /* HAVE_CLOCK_GETTIME || HAVE_CLOCK_GETTIME_IN_LIBRT */
 
-struct timespec time_divide(struct timespec t, unsigned long div)
+struct timerel time_divide(struct timerel t, unsigned long div)
 {
-       struct timespec res;
+       struct timerel res;
        uint64_t rem, ns;
 
        /* Dividing seconds is simple. */
-       res.tv_sec = TIME_CHECK(t).tv_sec / div;
-       rem = t.tv_sec % div;
+       res.ts.tv_sec = TIMEREL_CHECK(t).ts.tv_sec / div;
+       rem = t.ts.tv_sec % div;
 
        /* If we can't fit remainder * 1,000,000,000 in 64 bits? */
 #if 0 /* ilog is great, but we use fp for multiply anyway. */
@@ -45,37 +45,37 @@ struct timespec time_divide(struct timespec t, unsigned long div)
 #endif
        if (rem & ~(((uint64_t)1 << 30) - 1)) {
                /* FIXME: fp is cheating! */
-               double nsec = rem * 1000000000.0 + t.tv_nsec;
-               res.tv_nsec = nsec / div;
+               double nsec = rem * 1000000000.0 + t.ts.tv_nsec;
+               res.ts.tv_nsec = nsec / div;
        } else {
-               ns = rem * 1000000000 + t.tv_nsec;
-               res.tv_nsec = ns / div;
+               ns = rem * 1000000000 + t.ts.tv_nsec;
+               res.ts.tv_nsec = ns / div;
        }
-       return TIME_CHECK(res);
+       return TIMEREL_CHECK(res);
 }
 
-struct timespec time_multiply(struct timespec t, unsigned long mult)
+struct timerel time_multiply(struct timerel t, unsigned long mult)
 {
-       struct timespec res;
+       struct timerel res;
 
        /* Are we going to overflow if we multiply nsec? */
        if (mult & ~((1UL << 30) - 1)) {
                /* FIXME: fp is cheating! */
-               double nsec = (double)t.tv_nsec * mult;
+               double nsec = (double)t.ts.tv_nsec * mult;
 
-               res.tv_sec = nsec / 1000000000.0;
-               res.tv_nsec = nsec - (res.tv_sec * 1000000000.0);
+               res.ts.tv_sec = nsec / 1000000000.0;
+               res.ts.tv_nsec = nsec - (res.ts.tv_sec * 1000000000.0);
        } else {
-               uint64_t nsec = t.tv_nsec * mult;
+               uint64_t nsec = t.ts.tv_nsec * mult;
 
-               res.tv_nsec = nsec % 1000000000;
-               res.tv_sec = nsec / 1000000000;
+               res.ts.tv_nsec = nsec % 1000000000;
+               res.ts.tv_sec = nsec / 1000000000;
        }
-       res.tv_sec += TIME_CHECK(t).tv_sec * mult;
-       return TIME_CHECK(res);
+       res.ts.tv_sec += TIMEREL_CHECK(t).ts.tv_sec * mult;
+       return TIMEREL_CHECK(res);
 }
 
-struct timespec time_check(struct timespec t, const char *abortstr)
+struct timespec time_check_(struct timespec t, const char *abortstr)
 {
        if (t.tv_sec < 0 || t.tv_nsec >= 1000000000) {
                if (abortstr) {
@@ -101,3 +101,19 @@ struct timespec time_check(struct timespec t, const char *abortstr)
        }
        return t;
 }
+
+struct timerel timerel_check(struct timerel t, const char *abortstr)
+{
+       struct timerel ret;
+
+       ret.ts = time_check_(t.ts, abortstr);
+       return ret;
+}
+
+struct timeabs timeabs_check(struct timeabs t, const char *abortstr)
+{
+       struct timeabs ret;
+
+       ret.ts = time_check_(t.ts, abortstr);
+       return ret;
+}
index e4298d07055d1ab66ad816a042ede0bcf9720b26..7bb3547d6227630fb5eb682544dc7e2eb4c2e6aa 100644 (file)
@@ -17,52 +17,89 @@ struct timespec {
 #ifdef DEBUG
 #include <ccan/str/str.h>
 #define TIME_CHECK(t) \
-       time_check((t), __FILE__ ":" stringify(__LINE__) " (" stringify(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
 
 /**
- * time_check - check if a time is malformed.
- * @in: the time to check (returned)
+ * 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 timespec will be normalized and
+ * @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("Now is %lu seconds since epoch\n",
- *             (long)time_check(time_now(), "time_now() failed?").tv_sec);
+ *     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 timespec time_check(struct timespec in, const char *abortstr);
+struct timerel timerel_check(struct timerel in, const char *abortstr);
 
 /**
- * time_now - return the current time
+ * 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)time_now().tv_sec);
+ *     printf("Now is %lu seconds since epoch\n",
+ *             (long)timeabs_check(time_now(), "time_now failed?").ts.tv_sec);
  */
-struct timespec time_now(void);
+struct timeabs timeabs_check(struct timeabs in, const char *abortstr);
 
 /**
- * time_greater - is a after b?
- * @a: one time.
- * @b: another time.
+ * time_now - return the current time
  *
  * Example:
- *     static bool timed_out(const struct timespec *start)
- *     {
- *     #define TIMEOUT time_from_msec(1000)
- *             return time_greater(time_now(), time_add(*start, TIMEOUT));
- *     }
+ *     printf("Now is %lu seconds since epoch\n", (long)time_now().ts.tv_sec);
  */
-static inline bool time_greater(struct timespec a, struct timespec b)
+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;
@@ -73,18 +110,33 @@ static inline bool time_greater(struct timespec a, struct timespec b)
 }
 
 /**
- * time_less - is a before b?
- * @a: one time.
- * @b: another time.
+ * time_after - is a after b?
+ * @a: one abstime.
+ * @b: another abstime.
  *
  * Example:
- *     static bool still_valid(const struct timespec *start)
+ *     static bool timed_out(const struct timeabs *start)
  *     {
  *     #define TIMEOUT time_from_msec(1000)
- *             return time_less(time_now(), time_add(*start, TIMEOUT));
+ *             return time_after(time_now(), timeabs_add(*start, TIMEOUT));
  *     }
  */
-static inline bool time_less(struct timespec a, struct timespec b)
+static inline bool time_after(struct timeabs a, struct timeabs b)
+{
+       return time_greater_(a.ts, b.ts);
+}
+
+/**
+ * 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;
@@ -95,9 +147,36 @@ static inline bool time_less(struct timespec a, struct timespec b)
 }
 
 /**
- * time_eq - is a equal to b?
- * @a: one time.
- * @b: another time.
+ * time_before - is a before b?
+ * @a: one absolute time.
+ * @b: another absolute time.
+ *
+ * Example:
+ *     static bool still_valid(const struct timeabs *start)
+ *     {
+ *     #define TIMEOUT time_from_msec(1000)
+ *             return time_before(time_now(), timeabs_add(*start, TIMEOUT));
+ *     }
+ */
+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);
+}
+
+/**
+ * timeabs_eq - is a equal to b?
+ * @a: one absolute time.
+ * @b: another absolute time.
  *
  * Example:
  *     #include <sys/types.h>
@@ -106,35 +185,50 @@ static inline bool time_less(struct timespec a, struct timespec b)
  *     // Can we fork in under a nanosecond?
  *     static bool fast_fork(void)
  *     {
- *             struct timespec 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());
  *     }
  */
-static inline bool time_eq(struct timespec a, struct timespec b)
+static inline bool timeabs_eq(struct timeabs a, struct timeabs b)
 {
-       return TIME_CHECK(a).tv_sec == TIME_CHECK(b).tv_sec
-               && a.tv_nsec == b.tv_nsec;
+       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.
- *
- * This returns a well formed struct timespec.
+ * timerel_eq - is a equal to b?
+ * @a: one relative time.
+ * @b: another relative time.
  *
  * Example:
- *     static bool was_recent(const struct timespec *start)
+ *     #include <sys/types.h>
+ *     #include <sys/wait.h>
+ *
+ *     // Can we fork in under a nanosecond?
+ *     static bool fast_fork(void)
  *     {
- *             return time_sub(time_now(), *start).tv_sec < 1;
+ *             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 struct timespec time_sub(struct timespec recent,
-                                      struct timespec old)
+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;
 
@@ -149,20 +243,58 @@ static inline struct timespec time_sub(struct timespec recent,
 }
 
 /**
- * time_add - add two times
- * @a: one time.
- * @b: another time.
+ * time_sub - subtract two relative times
+ * @a: the larger time.
+ * @b: the smaller time.
  *
- * The times must not overflow, or the results are undefined.
+ * 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:
  *     // We do one every second.
- *     static struct timespec next_time(void)
+ *     static struct timeabs previous_time(void)
  *     {
- *             return time_add(time_now(), time_from_msec(1000));
+ *             return timeabs_sub(time_now(), time_from_msec(1000));
  *     }
  */
-static inline struct timespec time_add(struct timespec a, struct timespec b)
+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;
 
@@ -175,6 +307,49 @@ static inline struct timespec time_add(struct timespec a, struct timespec b)
        return TIME_CHECK(sum);
 }
 
+/**
+ * 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 timeabs next_time(void)
+ *     {
+ *             return timeabs_add(time_now(), time_from_msec(1000));
+ *     }
+ */
+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.
  * @t: a time.
@@ -182,9 +357,9 @@ static inline struct timespec time_add(struct timespec a, struct timespec b)
  *
  * Example:
  *     // How long does it take to do a fork?
- *     static struct timespec forking_time(void)
+ *     static struct timerel forking_time(void)
  *     {
- *             struct timespec start = time_now();
+ *             struct timeabs start = time_now();
  *             unsigned int i;
  *
  *             for (i = 0; i < 1000; i++) {
@@ -193,22 +368,22 @@ static inline struct timespec time_add(struct timespec a, struct timespec b)
  *                     }
  *                     wait(NULL);
  *             }
- *             return time_divide(time_sub(time_now(), start), i);
+ *             return time_divide(time_between(time_now(), start), i);
  *     }
  */
-struct timespec time_divide(struct timespec 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 timespec time_multiply(struct timespec t, unsigned long mult);
+struct timerel time_multiply(struct timerel t, unsigned long mult);
 
 /**
  * time_to_sec - return number of seconds
@@ -223,14 +398,14 @@ struct timespec time_multiply(struct timespec t, unsigned long mult);
  *     printf("Forking time is %u sec\n",
  *            (unsigned)time_to_sec(forking_time()));
  */
-static inline uint64_t time_to_sec(struct timespec t)
+static inline uint64_t time_to_sec(struct timerel t)
 {
-       return t.tv_sec;
+       return t.ts.tv_sec;
 }
 
 /**
  * time_to_msec - return number of milliseconds
- * @t: a time
+ * @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
@@ -241,17 +416,17 @@ static inline uint64_t time_to_sec(struct timespec t)
  *     printf("Forking time is %u msec\n",
  *            (unsigned)time_to_msec(forking_time()));
  */
-static inline uint64_t time_to_msec(struct timespec t)
+static inline uint64_t time_to_msec(struct timerel t)
 {
        uint64_t msec;
 
-       msec = TIME_CHECK(t).tv_nsec / 1000000 + (uint64_t)t.tv_sec * 1000;
+       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
@@ -263,17 +438,17 @@ static inline uint64_t time_to_msec(struct timespec t)
  *            (unsigned)time_to_usec(forking_time()));
  *
  */
-static inline uint64_t time_to_usec(struct timespec t)
+static inline uint64_t time_to_usec(struct timerel t)
 {
        uint64_t usec;
 
-       usec = TIME_CHECK(t).tv_nsec / 1000 + (uint64_t)t.tv_sec * 1000000;
+       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 time
+ * @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
@@ -285,111 +460,121 @@ static inline uint64_t time_to_usec(struct timespec t)
  *            (unsigned)time_to_nsec(forking_time()));
  *
  */
-static inline uint64_t time_to_nsec(struct timespec t)
+static inline uint64_t time_to_nsec(struct timerel t)
 {
        uint64_t nsec;
 
-       nsec = TIME_CHECK(t).tv_nsec + (uint64_t)t.tv_sec * 1000000000;
+       nsec = TIMEREL_CHECK(t).ts.tv_nsec + (uint64_t)t.ts.tv_sec * 1000000000;
        return nsec;
 }
 
 /**
- * time_from_sec - convert seconds to a timespec
+ * 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 timespec time_from_sec(uint64_t sec)
+static inline struct timerel time_from_sec(uint64_t sec)
 {
-       struct timespec t;
+       struct timerel t;
 
-       t.tv_nsec = 0;
-       t.tv_sec = sec;
-       return TIME_CHECK(t);
+       t.ts.tv_nsec = 0;
+       t.ts.tv_sec = sec;
+       return TIMEREL_CHECK(t);
 }
 
 /**
- * time_from_msec - convert milliseconds to a timespec
+ * time_from_msec - convert milliseconds to a relative time
  * @msec: time in milliseconds
  *
  * Example:
  *     // 1/2 second timeout
  *     #define TIMEOUT time_from_msec(500)
  */
-static inline struct timespec time_from_msec(uint64_t msec)
+static inline struct timerel time_from_msec(uint64_t msec)
 {
-       struct timespec t;
+       struct timerel t;
 
-       t.tv_nsec = (msec % 1000) * 1000000;
-       t.tv_sec = msec / 1000;
-       return TIME_CHECK(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 timespec
+ * time_from_usec - convert microseconds to a relative time
  * @usec: time in microseconds
  *
  * Example:
  *     // 1/2 second timeout
  *     #define TIMEOUT time_from_usec(500000)
  */
-static inline struct timespec time_from_usec(uint64_t usec)
+static inline struct timerel time_from_usec(uint64_t usec)
 {
-       struct timespec t;
+       struct timerel t;
 
-       t.tv_nsec = (usec % 1000000) * 1000;
-       t.tv_sec = usec / 1000000;
-       return TIME_CHECK(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 timespec
+ * 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 timespec time_from_nsec(uint64_t nsec)
+static inline struct timerel time_from_nsec(uint64_t nsec)
 {
-       struct timespec t;
+       struct timerel t;
 
-       t.tv_nsec = nsec % 1000000000;
-       t.tv_sec = nsec / 1000000000;
-       return TIME_CHECK(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;
 }
 
 /**
- * timespec_to_timeval - convert a timespec to a timeval.
- * @ts: a timespec.
+ * 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 = timespec_to_timeval(time_now());
+ *     tv = timerel_to_timeval(t);
  *     printf("time = %lu.%06u\n", (long)tv.tv_sec, (int)tv.tv_usec);
  */
-static inline struct timeval timespec_to_timeval(struct timespec ts)
+static inline struct timeval timerel_to_timeval(struct timerel t)
 {
-       struct timeval tv;
-       tv.tv_sec = ts.tv_sec;
-       tv.tv_usec = ts.tv_nsec / 1000;
-       return tv;
+       return timespec_to_timeval(t.ts);
 }
 
 /**
- * timeval_to_timespec - convert a timeval to a timespec.
- * @tv: a timeval.
+ * timeabs_to_timeval - convert an absolute time to a timeval.
+ * @t: an absolute time.
  *
  * Example:
- *     struct timeval tv = { 0, 500 };
- *     struct timespec ts;
+ *     struct timeval tv;
  *
- *     ts = timeval_to_timespec(tv);
- *     printf("timespec = %lu.%09lu\n", (long)ts.tv_sec, (long)ts.tv_nsec);
+ *     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;
@@ -397,4 +582,40 @@ static inline struct timespec timeval_to_timespec(struct timeval tv)
        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 */