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 PRI_NSEC PRIu64
  33 #define PRI_USEC PRIu64
  34 #define NSEC_FMT "%" PRI_NSEC
  35 #define USEC_FMT "%" PRI_USEC
  36
  37 #include "macro.h"
  38
  39 typedef struct dual_timestamp {
  40         usec_t realtime;
  41         usec_t monotonic;
  42 } dual_timestamp;
  43
  44 typedef struct triple_timestamp {
  45         usec_t realtime;
  46         usec_t monotonic;
  47         usec_t boottime;
  48 } triple_timestamp;
  49
  50 #define USEC_INFINITY ((usec_t) -1)
  51 #define NSEC_INFINITY ((nsec_t) -1)
  52
  53 #define MSEC_PER_SEC  1000ULL
  54 #define USEC_PER_SEC  ((usec_t) 1000000ULL)
  55 #define USEC_PER_MSEC ((usec_t) 1000ULL)
  56 #define NSEC_PER_SEC  ((nsec_t) 1000000000ULL)
  57 #define NSEC_PER_MSEC ((nsec_t) 1000000ULL)
  58 #define NSEC_PER_USEC ((nsec_t) 1000ULL)
  59
  60 #define USEC_PER_MINUTE ((usec_t) (60ULL*USEC_PER_SEC))
  61 #define NSEC_PER_MINUTE ((nsec_t) (60ULL*NSEC_PER_SEC))
  62 #define USEC_PER_HOUR ((usec_t) (60ULL*USEC_PER_MINUTE))
  63 #define NSEC_PER_HOUR ((nsec_t) (60ULL*NSEC_PER_MINUTE))
  64 #define USEC_PER_DAY ((usec_t) (24ULL*USEC_PER_HOUR))
  65 #define NSEC_PER_DAY ((nsec_t) (24ULL*NSEC_PER_HOUR))
  66 #define USEC_PER_WEEK ((usec_t) (7ULL*USEC_PER_DAY))
  67 #define NSEC_PER_WEEK ((nsec_t) (7ULL*NSEC_PER_DAY))
  68 #define USEC_PER_MONTH ((usec_t) (2629800ULL*USEC_PER_SEC))
  69 #define NSEC_PER_MONTH ((nsec_t) (2629800ULL*NSEC_PER_SEC))
  70 #define USEC_PER_YEAR ((usec_t) (31557600ULL*USEC_PER_SEC))
  71 #define NSEC_PER_YEAR ((nsec_t) (31557600ULL*NSEC_PER_SEC))
  72
  73 /* We assume a maximum timezone length of 6. TZNAME_MAX is not defined on Linux, but glibc internally initializes this
  74  * to 6. Let's rely on that. */
  75 #define FORMAT_TIMESTAMP_MAX (3+1+10+1+8+1+6+1+6+1)
  76 #define FORMAT_TIMESTAMP_WIDTH 28 /* when outputting, assume this width */
  77 #define FORMAT_TIMESTAMP_RELATIVE_MAX 256
  78 #define FORMAT_TIMESPAN_MAX 64
  79
  80 #define TIME_T_MAX (time_t)((UINTMAX_C(1) << ((sizeof(time_t) << 3) - 1)) - 1)
  81
  82 #define DUAL_TIMESTAMP_NULL ((struct dual_timestamp) {})
  83 #define TRIPLE_TIMESTAMP_NULL ((struct triple_timestamp) {})
  84
  85 usec_t now(clockid_t clock);
  86 #if 0 /// UNNEEDED by elogind
  87 nsec_t now_nsec(clockid_t clock);
  88 #endif // 0
  89
  90 dual_timestamp* dual_timestamp_get(dual_timestamp *ts);
  91 dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u);
  92 #if 0 /// UNNEEDED by elogind
  93 dual_timestamp* dual_timestamp_from_monotonic(dual_timestamp *ts, usec_t u);
  94 dual_timestamp* dual_timestamp_from_boottime_or_monotonic(dual_timestamp *ts, usec_t u);
  95 #endif // 0
  96
  97 triple_timestamp* triple_timestamp_get(triple_timestamp *ts);
  98 triple_timestamp* triple_timestamp_from_realtime(triple_timestamp *ts, usec_t u);
  99
 100 #define DUAL_TIMESTAMP_HAS_CLOCK(clock)                               \
 101         IN_SET(clock, CLOCK_REALTIME, CLOCK_REALTIME_ALARM, CLOCK_MONOTONIC)
 102
 103 #define TRIPLE_TIMESTAMP_HAS_CLOCK(clock)                               \
 104         IN_SET(clock, CLOCK_REALTIME, CLOCK_REALTIME_ALARM, CLOCK_MONOTONIC, CLOCK_BOOTTIME, CLOCK_BOOTTIME_ALARM)
 105
 106 static inline bool dual_timestamp_is_set(dual_timestamp *ts) {
 107         return ((ts->realtime > 0 && ts->realtime != USEC_INFINITY) ||
 108                 (ts->monotonic > 0 && ts->monotonic != USEC_INFINITY));
 109 }
 110
 111 static inline bool triple_timestamp_is_set(triple_timestamp *ts) {
 112         return ((ts->realtime > 0 && ts->realtime != USEC_INFINITY) ||
 113                 (ts->monotonic > 0 && ts->monotonic != USEC_INFINITY) ||
 114                 (ts->boottime > 0 && ts->boottime != USEC_INFINITY));
 115 }
 116
 117 usec_t triple_timestamp_by_clock(triple_timestamp *ts, clockid_t clock);
 118
 119 usec_t timespec_load(const struct timespec *ts) _pure_;
 120 #if 0 /// UNNEEDED by elogind
 121 nsec_t timespec_load_nsec(const struct timespec *ts) _pure_;
 122 #endif // 0
 123 struct timespec *timespec_store(struct timespec *ts, usec_t u);
 124
 125 usec_t timeval_load(const struct timeval *tv) _pure_;
 126 struct timeval *timeval_store(struct timeval *tv, usec_t u);
 127
 128 char *format_timestamp(char *buf, size_t l, usec_t t);
 129 #if 0 /// UNNEEDED by elogind
 130 char *format_timestamp_utc(char *buf, size_t l, usec_t t);
 131 #endif // 0
 132 char *format_timestamp_us(char *buf, size_t l, usec_t t);
 133 #if 0 /// UNNEEDED by elogind
 134 char *format_timestamp_us_utc(char *buf, size_t l, usec_t t);
 135 #endif // 0
 136 char *format_timestamp_relative(char *buf, size_t l, usec_t t);
 137 char *format_timespan(char *buf, size_t l, usec_t t, usec_t accuracy);
 138
 139 #if 0 /// UNNEEDED by elogind
 140 void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t);
 141 int dual_timestamp_deserialize(const char *value, dual_timestamp *t);
 142 #endif // 0
 143 int timestamp_deserialize(const char *value, usec_t *timestamp);
 144
 145 #if 0 /// UNNEEDED by elogind
 146 int parse_timestamp(const char *t, usec_t *usec);
 147 #endif // 0
 148
 149 int parse_sec(const char *t, usec_t *usec);
 150 #if 0 /// UNNEEDED by elogind
 151 int parse_sec_fix_0(const char *t, usec_t *usec);
 152 #endif // 0
 153 int parse_time(const char *t, usec_t *usec, usec_t default_unit);
 154 #if 0 /// UNNEEDED by elogind
 155 int parse_nsec(const char *t, nsec_t *nsec);
 156
 157 bool ntp_synced(void);
 158
 159 int get_timezones(char ***l);
 160 bool timezone_is_valid(const char *name);
 161
 162 #endif // 0
 163 bool clock_boottime_supported(void);
 164 bool clock_supported(clockid_t clock);
 165 #if 0 /// UNNEEDED by elogind
 166 clockid_t clock_boottime_or_monotonic(void);
 167
 168 usec_t usec_shift_clock(usec_t, clockid_t from, clockid_t to);
 169 #endif // 0
 170
 171 #define xstrftime(buf, fmt, tm) \
 172         assert_message_se(strftime(buf, ELEMENTSOF(buf), fmt, tm) > 0, \
 173                           "xstrftime: " #buf "[] must be big enough")
 174
 175 #if 0 /// UNNEEDED by elogind
 176 int get_timezone(char **timezone);
 177
 178 time_t mktime_or_timegm(struct tm *tm, bool utc);
 179 #endif // 0
 180 struct tm *localtime_or_gmtime_r(const time_t *t, struct tm *tm, bool utc);
 181
 182 #if 0 /// UNNEEDED by elogind
 183 unsigned long usec_to_jiffies(usec_t usec);
 184 #endif // 0
 185
 186 static inline usec_t usec_add(usec_t a, usec_t b) {
 187         usec_t c;
 188
 189         /* Adds two time values, and makes sure USEC_INFINITY as input results as USEC_INFINITY in output, and doesn't
 190          * overflow. */
 191
 192         c = a + b;
 193         if (c < a || c < b) /* overflow check */
 194                 return USEC_INFINITY;
 195
 196         return c;
 197 }
 198
 199 static inline usec_t usec_sub_unsigned(usec_t timestamp, usec_t delta) {
 200
 201         if (timestamp == USEC_INFINITY) /* Make sure infinity doesn't degrade */
 202                 return USEC_INFINITY;
 203         if (timestamp < delta)
 204                 return 0;
 205
 206         return timestamp - delta;
 207 }
 208
 209 static inline usec_t usec_sub_signed(usec_t timestamp, int64_t delta) {
 210         if (delta < 0)
 211                 return usec_add(timestamp, (usec_t) (-delta));
 212         else
 213                 return usec_sub_unsigned(timestamp, (usec_t) delta);
 214 }
 215
 216 #if SIZEOF_TIME_T == 8
 217 /* The last second we can format is 31. Dec 9999, 1s before midnight, because otherwise we'd enter 5 digit year
 218  * territory. However, since we want to stay away from this in all timezones we take one day off. */
 219 #define USEC_TIMESTAMP_FORMATTABLE_MAX ((usec_t) 253402214399000000)
 220 #elif SIZEOF_TIME_T == 4
 221 /* With a 32bit time_t we can't go beyond 2038... */
 222 #define USEC_TIMESTAMP_FORMATTABLE_MAX ((usec_t) 2147483647000000)
 223 #else
 224 #error "Yuck, time_t is neither 4 not 8 bytes wide?"
 225 #endif