src/basic/time-util.h

   1 #pragma once
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <inttypes.h>
  23 #include <stdbool.h>
  24 #include <stddef.h>
  25 #include <stdint.h>
  26 #include <stdio.h>
  27 #include <time.h>
  28
  29 typedef uint64_t usec_t;
  30 typedef uint64_t nsec_t;
  31
  32 #define NSEC_FMT "%" PRIu64
  33 #define USEC_FMT "%" PRIu64
  34
  35 #include "macro.h"
  36
  37 typedef struct dual_timestamp {
  38         usec_t realtime;
  39         usec_t monotonic;
  40 } dual_timestamp;
  41
  42 typedef struct triple_timestamp {
  43         usec_t realtime;
  44         usec_t monotonic;
  45         usec_t boottime;
  46 } triple_timestamp;
  47
  48 #define USEC_INFINITY ((usec_t) -1)
  49 #define NSEC_INFINITY ((nsec_t) -1)
  50
  51 #define MSEC_PER_SEC  1000ULL
  52 #define USEC_PER_SEC  ((usec_t) 1000000ULL)
  53 #define USEC_PER_MSEC ((usec_t) 1000ULL)
  54 #define NSEC_PER_SEC  ((nsec_t) 1000000000ULL)
  55 #define NSEC_PER_MSEC ((nsec_t) 1000000ULL)
  56 #define NSEC_PER_USEC ((nsec_t) 1000ULL)
  57
  58 #define USEC_PER_MINUTE ((usec_t) (60ULL*USEC_PER_SEC))
  59 #define NSEC_PER_MINUTE ((nsec_t) (60ULL*NSEC_PER_SEC))
  60 #define USEC_PER_HOUR ((usec_t) (60ULL*USEC_PER_MINUTE))
  61 #define NSEC_PER_HOUR ((nsec_t) (60ULL*NSEC_PER_MINUTE))
  62 #define USEC_PER_DAY ((usec_t) (24ULL*USEC_PER_HOUR))
  63 #define NSEC_PER_DAY ((nsec_t) (24ULL*NSEC_PER_HOUR))
  64 #define USEC_PER_WEEK ((usec_t) (7ULL*USEC_PER_DAY))
  65 #define NSEC_PER_WEEK ((nsec_t) (7ULL*NSEC_PER_DAY))
  66 #define USEC_PER_MONTH ((usec_t) (2629800ULL*USEC_PER_SEC))
  67 #define NSEC_PER_MONTH ((nsec_t) (2629800ULL*NSEC_PER_SEC))
  68 #define USEC_PER_YEAR ((usec_t) (31557600ULL*USEC_PER_SEC))
  69 #define NSEC_PER_YEAR ((nsec_t) (31557600ULL*NSEC_PER_SEC))
  70
  71 /* We assume a maximum timezone length of 6. TZNAME_MAX is not defined on Linux, but glibc internally initializes this
  72  * to 6. Let's rely on that. */
  73 #define FORMAT_TIMESTAMP_MAX (3+1+10+1+8+1+6+1+6+1)
  74 #define FORMAT_TIMESTAMP_WIDTH 28 /* when outputting, assume this width */
  75 #define FORMAT_TIMESTAMP_RELATIVE_MAX 256
  76 #define FORMAT_TIMESPAN_MAX 64
  77
  78 #define TIME_T_MAX (time_t)((UINTMAX_C(1) << ((sizeof(time_t) << 3) - 1)) - 1)
  79
  80 #define DUAL_TIMESTAMP_NULL ((struct dual_timestamp) {})
  81 #define TRIPLE_TIMESTAMP_NULL ((struct triple_timestamp) {})
  82
  83 usec_t now(clockid_t clock);
  84 #if 0 /// UNNEEDED by elogind
  85 nsec_t now_nsec(clockid_t clock);
  86 #endif // 0
  87
  88 dual_timestamp* dual_timestamp_get(dual_timestamp *ts);
  89 dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u);
  90 #if 0 /// UNNEEDED by elogind
  91 dual_timestamp* dual_timestamp_from_monotonic(dual_timestamp *ts, usec_t u);
  92 dual_timestamp* dual_timestamp_from_boottime_or_monotonic(dual_timestamp *ts, usec_t u);
  93 #endif // 0
  94
  95 triple_timestamp* triple_timestamp_get(triple_timestamp *ts);
  96 triple_timestamp* triple_timestamp_from_realtime(triple_timestamp *ts, usec_t u);
  97
  98 #define DUAL_TIMESTAMP_HAS_CLOCK(clock)                               \
  99         IN_SET(clock, CLOCK_REALTIME, CLOCK_REALTIME_ALARM, CLOCK_MONOTONIC)
 100
 101 #define TRIPLE_TIMESTAMP_HAS_CLOCK(clock)                               \
 102         IN_SET(clock, CLOCK_REALTIME, CLOCK_REALTIME_ALARM, CLOCK_MONOTONIC, CLOCK_BOOTTIME, CLOCK_BOOTTIME_ALARM)
 103
 104 static inline bool dual_timestamp_is_set(dual_timestamp *ts) {
 105         return ((ts->realtime > 0 && ts->realtime != USEC_INFINITY) ||
 106                 (ts->monotonic > 0 && ts->monotonic != USEC_INFINITY));
 107 }
 108
 109 static inline bool triple_timestamp_is_set(triple_timestamp *ts) {
 110         return ((ts->realtime > 0 && ts->realtime != USEC_INFINITY) ||
 111                 (ts->monotonic > 0 && ts->monotonic != USEC_INFINITY) ||
 112                 (ts->boottime > 0 && ts->boottime != USEC_INFINITY));
 113 }
 114
 115 usec_t triple_timestamp_by_clock(triple_timestamp *ts, clockid_t clock);
 116
 117 usec_t timespec_load(const struct timespec *ts) _pure_;
 118 #if 0 /// UNNEEDED by elogind
 119 nsec_t timespec_load_nsec(const struct timespec *ts) _pure_;
 120 #endif // 0
 121 struct timespec *timespec_store(struct timespec *ts, usec_t u);
 122
 123 usec_t timeval_load(const struct timeval *tv) _pure_;
 124 struct timeval *timeval_store(struct timeval *tv, usec_t u);
 125
 126 char *format_timestamp(char *buf, size_t l, usec_t t);
 127 #if 0 /// UNNEEDED by elogind
 128 char *format_timestamp_utc(char *buf, size_t l, usec_t t);
 129 #endif // 0
 130 char *format_timestamp_us(char *buf, size_t l, usec_t t);
 131 #if 0 /// UNNEEDED by elogind
 132 char *format_timestamp_us_utc(char *buf, size_t l, usec_t t);
 133 #endif // 0
 134 char *format_timestamp_relative(char *buf, size_t l, usec_t t);
 135 char *format_timespan(char *buf, size_t l, usec_t t, usec_t accuracy);
 136
 137 #if 0 /// UNNEEDED by elogind
 138 void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t);
 139 int dual_timestamp_deserialize(const char *value, dual_timestamp *t);
 140 #endif // 0
 141 int timestamp_deserialize(const char *value, usec_t *timestamp);
 142
 143 #if 0 /// UNNEEDED by elogind
 144 int parse_timestamp(const char *t, usec_t *usec);
 145 #endif // 0
 146
 147 int parse_sec(const char *t, usec_t *usec);
 148 int parse_time(const char *t, usec_t *usec, usec_t default_unit);
 149 #if 0 /// UNNEEDED by elogind
 150 int parse_nsec(const char *t, nsec_t *nsec);
 151
 152 bool ntp_synced(void);
 153
 154 int get_timezones(char ***l);
 155 bool timezone_is_valid(const char *name);
 156
 157 #endif // 0
 158 bool clock_boottime_supported(void);
 159 bool clock_supported(clockid_t clock);
 160 #if 0 /// UNNEEDED by elogind
 161 clockid_t clock_boottime_or_monotonic(void);
 162 #endif // 0
 163
 164 #define xstrftime(buf, fmt, tm) \
 165         assert_message_se(strftime(buf, ELEMENTSOF(buf), fmt, tm) > 0, \
 166                           "xstrftime: " #buf "[] must be big enough")
 167
 168 #if 0 /// UNNEEDED by elogind
 169 int get_timezone(char **timezone);
 170
 171 time_t mktime_or_timegm(struct tm *tm, bool utc);
 172 #endif // 0
 173 struct tm *localtime_or_gmtime_r(const time_t *t, struct tm *tm, bool utc);
 174
 175 #if 0 /// UNNEEDED by elogind
 176 unsigned long usec_to_jiffies(usec_t usec);
 177 #endif // 0
 178
 179 static inline usec_t usec_add(usec_t a, usec_t b) {
 180         usec_t c;
 181
 182         /* Adds two time values, and makes sure USEC_INFINITY as input results as USEC_INFINITY in output, and doesn't
 183          * overflow. */
 184
 185         c = a + b;
 186         if (c < a || c < b) /* overflow check */
 187                 return USEC_INFINITY;
 188
 189         return c;
 190 }
 191
 192 static inline usec_t usec_sub(usec_t timestamp, int64_t delta) {
 193         if (delta < 0)
 194                 return usec_add(timestamp, (usec_t) (-delta));
 195
 196         if (timestamp == USEC_INFINITY) /* Make sure infinity doesn't degrade */
 197                 return USEC_INFINITY;
 198
 199         if (timestamp < (usec_t) delta)
 200                 return 0;
 201
 202         return timestamp - delta;
 203 }