blob: 86c2469878ddfeb9d4442ebd50e241d1252180a1 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Time calculation functions.
3 *
Willy Tarreau45a12512011-09-10 16:56:42 +02004 * Copyright 2000-2011 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreaued72d822018-10-17 19:01:24 +020013#include <unistd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020014#include <sys/time.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020015
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020016#include <haproxy/api.h>
Willy Tarreau5e8f0662007-02-12 00:59:08 +010017#include <common/standard.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020018#include <common/time.h>
Willy Tarreau3f567e42020-05-28 15:29:19 +020019#include <haproxy/thread-t.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020020
Christopher Faulet9a655712017-05-11 11:00:15 +020021THREAD_LOCAL unsigned int ms_left_scaled; /* milliseconds left for current second (0..2^32-1) */
22THREAD_LOCAL unsigned int now_ms; /* internal date in milliseconds (may wrap) */
23THREAD_LOCAL unsigned int samp_time; /* total elapsed time over current sample */
24THREAD_LOCAL unsigned int idle_time; /* total idle time over current sample */
Christopher Faulet9a655712017-05-11 11:00:15 +020025THREAD_LOCAL struct timeval now; /* internal date is a monotonic function of real clock */
26THREAD_LOCAL struct timeval date; /* the real current date */
Willy Tarreaubaaee002006-06-26 02:48:02 +020027struct timeval start_date; /* the process's start date */
Christopher Faulet9a655712017-05-11 11:00:15 +020028THREAD_LOCAL struct timeval before_poll; /* system date before calling poll() */
29THREAD_LOCAL struct timeval after_poll; /* system date after leaving poll() */
Willy Tarreaubaaee002006-06-26 02:48:02 +020030
Willy Tarreau9fefc512017-11-23 14:52:28 +010031static THREAD_LOCAL struct timeval tv_offset; /* per-thread time ofsset relative to global time */
Willy Tarreau43091ed2019-06-06 16:50:39 +020032static volatile unsigned long long global_now; /* common date between all threads (32:32) */
Willy Tarreau9fefc512017-11-23 14:52:28 +010033
Willy Tarreau93acfa22019-09-26 08:00:23 +020034static THREAD_LOCAL unsigned int iso_time_sec; /* last iso time value for this thread */
35static THREAD_LOCAL char iso_time_str[28]; /* ISO time representation of gettimeofday() */
36
Willy Tarreaubaaee002006-06-26 02:48:02 +020037/*
38 * adds <ms> ms to <from>, set the result to <tv> and returns a pointer <tv>
39 */
Willy Tarreau03e78532020-02-25 07:38:05 +010040struct timeval *_tv_ms_add(struct timeval *tv, const struct timeval *from, int ms)
Willy Tarreaubaaee002006-06-26 02:48:02 +020041{
Willy Tarreau42aae5c2007-04-29 17:43:56 +020042 tv->tv_usec = from->tv_usec + (ms % 1000) * 1000;
43 tv->tv_sec = from->tv_sec + (ms / 1000);
Willy Tarreaubaaee002006-06-26 02:48:02 +020044 while (tv->tv_usec >= 1000000) {
45 tv->tv_usec -= 1000000;
46 tv->tv_sec++;
47 }
48 return tv;
49}
50
51/*
52 * compares <tv1> and <tv2> modulo 1ms: returns 0 if equal, -1 if tv1 < tv2, 1 if tv1 > tv2
Willy Tarreau42aae5c2007-04-29 17:43:56 +020053 * Must not be used when either argument is eternity. Use tv_ms_cmp2() for that.
Willy Tarreaubaaee002006-06-26 02:48:02 +020054 */
Willy Tarreau03e78532020-02-25 07:38:05 +010055int _tv_ms_cmp(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreaubaaee002006-06-26 02:48:02 +020056{
Willy Tarreau42aae5c2007-04-29 17:43:56 +020057 return __tv_ms_cmp(tv1, tv2);
Willy Tarreaubaaee002006-06-26 02:48:02 +020058}
59
60/*
Willy Tarreaubaaee002006-06-26 02:48:02 +020061 * compares <tv1> and <tv2> modulo 1 ms: returns 0 if equal, -1 if tv1 < tv2, 1 if tv1 > tv2,
Willy Tarreaua6a6a932007-04-28 22:40:08 +020062 * assuming that TV_ETERNITY is greater than everything.
Willy Tarreaubaaee002006-06-26 02:48:02 +020063 */
Willy Tarreau03e78532020-02-25 07:38:05 +010064int _tv_ms_cmp2(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreaubaaee002006-06-26 02:48:02 +020065{
Willy Tarreau42aae5c2007-04-29 17:43:56 +020066 return __tv_ms_cmp2(tv1, tv2);
Willy Tarreau8d7d1492007-04-29 10:50:43 +020067}
68
69/*
70 * compares <tv1> and <tv2> modulo 1 ms: returns 1 if tv1 <= tv2, 0 if tv1 > tv2,
71 * assuming that TV_ETERNITY is greater than everything. Returns 0 if tv1 is
72 * TV_ETERNITY, and always assumes that tv2 != TV_ETERNITY. Designed to replace
Willy Tarreau42aae5c2007-04-29 17:43:56 +020073 * occurrences of (tv_ms_cmp2(tv,now) <= 0).
Willy Tarreau8d7d1492007-04-29 10:50:43 +020074 */
Willy Tarreau03e78532020-02-25 07:38:05 +010075int _tv_ms_le2(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreau8d7d1492007-04-29 10:50:43 +020076{
Willy Tarreau42aae5c2007-04-29 17:43:56 +020077 return __tv_ms_le2(tv1, tv2);
78}
Willy Tarreau8d7d1492007-04-29 10:50:43 +020079
Willy Tarreau42aae5c2007-04-29 17:43:56 +020080/*
81 * returns the remaining time between tv1=now and event=tv2
82 * if tv2 is passed, 0 is returned.
83 * Must not be used when either argument is eternity.
84 */
Willy Tarreau03e78532020-02-25 07:38:05 +010085unsigned long _tv_ms_remain(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreau42aae5c2007-04-29 17:43:56 +020086{
87 return __tv_ms_remain(tv1, tv2);
Willy Tarreaubaaee002006-06-26 02:48:02 +020088}
89
90/*
91 * returns the remaining time between tv1=now and event=tv2
92 * if tv2 is passed, 0 is returned.
93 * Returns TIME_ETERNITY if tv2 is eternity.
94 */
Willy Tarreau03e78532020-02-25 07:38:05 +010095unsigned long _tv_ms_remain2(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreaubaaee002006-06-26 02:48:02 +020096{
Willy Tarreaubaaee002006-06-26 02:48:02 +020097 if (tv_iseternity(tv2))
98 return TIME_ETERNITY;
99
Willy Tarreau42aae5c2007-04-29 17:43:56 +0200100 return __tv_ms_remain(tv1, tv2);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200101}
102
Willy Tarreaubaaee002006-06-26 02:48:02 +0200103/*
Willy Tarreau42aae5c2007-04-29 17:43:56 +0200104 * Returns the time in ms elapsed between tv1 and tv2, assuming that tv1<=tv2.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200105 * Must not be used when either argument is eternity.
106 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100107unsigned long _tv_ms_elapsed(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200108{
Willy Tarreau42aae5c2007-04-29 17:43:56 +0200109 return __tv_ms_elapsed(tv1, tv2);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200110}
111
112/*
Willy Tarreaud825eef2007-05-12 22:35:00 +0200113 * adds <inc> to <from>, set the result to <tv> and returns a pointer <tv>
114 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100115struct timeval *_tv_add(struct timeval *tv, const struct timeval *from, const struct timeval *inc)
Willy Tarreaud825eef2007-05-12 22:35:00 +0200116{
117 return __tv_add(tv, from, inc);
118}
119
120/*
Willy Tarreau0481c202007-05-13 16:03:27 +0200121 * If <inc> is set, then add it to <from> and set the result to <tv>, then
122 * return 1, otherwise return 0. It is meant to be used in if conditions.
123 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100124int _tv_add_ifset(struct timeval *tv, const struct timeval *from, const struct timeval *inc)
Willy Tarreau0481c202007-05-13 16:03:27 +0200125{
126 return __tv_add_ifset(tv, from, inc);
127}
128
129/*
Willy Tarreaud825eef2007-05-12 22:35:00 +0200130 * Computes the remaining time between tv1=now and event=tv2. if tv2 is passed,
131 * 0 is returned. The result is stored into tv.
132 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100133struct timeval *_tv_remain(const struct timeval *tv1, const struct timeval *tv2, struct timeval *tv)
Willy Tarreaud825eef2007-05-12 22:35:00 +0200134{
135 return __tv_remain(tv1, tv2, tv);
136}
137
138/*
139 * Computes the remaining time between tv1=now and event=tv2. if tv2 is passed,
140 * 0 is returned. The result is stored into tv. Returns ETERNITY if tv2 is
141 * eternity.
142 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100143struct timeval *_tv_remain2(const struct timeval *tv1, const struct timeval *tv2, struct timeval *tv)
Willy Tarreaud825eef2007-05-12 22:35:00 +0200144{
145 return __tv_remain2(tv1, tv2, tv);
146}
147
Willy Tarreau0481c202007-05-13 16:03:27 +0200148/* tv_isle: compares <tv1> and <tv2> : returns 1 if tv1 <= tv2, otherwise 0 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100149int _tv_isle(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreau0481c202007-05-13 16:03:27 +0200150{
151 return __tv_isle(tv1, tv2);
152}
153
154/* tv_isgt: compares <tv1> and <tv2> : returns 1 if tv1 > tv2, otherwise 0 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100155int _tv_isgt(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreau0481c202007-05-13 16:03:27 +0200156{
157 return __tv_isgt(tv1, tv2);
158}
159
Willy Tarreau7649aac2017-11-23 11:52:55 +0100160/* tv_update_date: sets <date> to system time, and sets <now> to something as
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200161 * close as possible to real time, following a monotonic function. The main
162 * principle consists in detecting backwards and forwards time jumps and adjust
163 * an offset to correct them. This function should be called once after each
164 * poll, and never farther apart than MAX_DELAY_MS*2. The poll's timeout should
165 * be passed in <max_wait>, and the return value in <interrupted> (a non-zero
166 * value means that we have not expired the timeout). Calling it with (-1,*)
167 * sets both <date> and <now> to current date, and calling it with (0,1) simply
168 * updates the values.
Christopher Faulet99aad922017-10-31 09:03:51 +0100169 *
Willy Tarreau7649aac2017-11-23 11:52:55 +0100170 * An offset is used to adjust the current time (date), to have a monotonic time
Christopher Faulet99aad922017-10-31 09:03:51 +0100171 * (now). It must be global and thread-safe. But a timeval cannot be atomically
Willy Tarreau7649aac2017-11-23 11:52:55 +0100172 * updated. So instead, we store it in a 64-bits integer (offset) whose 32 MSB
173 * contain the signed seconds adjustment andthe 32 LSB contain the unsigned
174 * microsecond adjustment. We cannot use a timeval for this since it's never
175 * clearly specified whether a timeval may hold negative values or not.
Willy Tarreaub7f694f2008-06-22 17:18:02 +0200176 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100177void tv_update_date(int max_wait, int interrupted)
Willy Tarreaub7f694f2008-06-22 17:18:02 +0200178{
Willy Tarreaua3315442018-02-05 20:11:38 +0100179 struct timeval adjusted, deadline, tmp_now, tmp_adj;
Willy Tarreau351b3a12017-03-29 15:24:33 +0200180 unsigned int curr_sec_ms; /* millisecond of current second (0..999) */
Willy Tarreau9fefc512017-11-23 14:52:28 +0100181 unsigned long long old_now;
182 unsigned long long new_now;
Willy Tarreaub7f694f2008-06-22 17:18:02 +0200183
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200184 gettimeofday(&date, NULL);
185 if (unlikely(max_wait < 0)) {
Willy Tarreau9fefc512017-11-23 14:52:28 +0100186 tv_zero(&tv_offset);
Willy Tarreau75590582009-03-05 14:54:50 +0100187 adjusted = date;
Willy Tarreau45a12512011-09-10 16:56:42 +0200188 after_poll = date;
189 samp_time = idle_time = 0;
Willy Tarreau81036f22019-05-20 19:24:50 +0200190 ti->idle_pct = 100;
Willy Tarreau43091ed2019-06-06 16:50:39 +0200191 old_now = global_now;
192 if (!old_now) { // never set
193 new_now = (((unsigned long long)adjusted.tv_sec) << 32) + (unsigned int)adjusted.tv_usec;
194 _HA_ATOMIC_CAS(&global_now, &old_now, new_now);
195 }
Willy Tarreaue6313a32008-06-29 13:47:25 +0200196 goto to_ms;
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200197 }
Willy Tarreau7649aac2017-11-23 11:52:55 +0100198
Willy Tarreau9fefc512017-11-23 14:52:28 +0100199 __tv_add(&adjusted, &date, &tv_offset);
Willy Tarreau7649aac2017-11-23 11:52:55 +0100200
Willy Tarreau9fefc512017-11-23 14:52:28 +0100201 /* compute the minimum and maximum local date we may have reached based
202 * on our past date and the associated timeout.
203 */
204 _tv_ms_add(&deadline, &now, max_wait + MAX_DELAY_MS);
Willy Tarreau7649aac2017-11-23 11:52:55 +0100205
Willy Tarreau9fefc512017-11-23 14:52:28 +0100206 if (unlikely(__tv_islt(&adjusted, &now) || __tv_islt(&deadline, &adjusted))) {
207 /* Large jump. If the poll was interrupted, we consider that the
208 * date has not changed (immediate wake-up), otherwise we add
209 * the poll time-out to the previous date. The new offset is
210 * recomputed.
211 */
212 _tv_ms_add(&adjusted, &now, interrupted ? 0 : max_wait);
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200213 }
214
Willy Tarreau9fefc512017-11-23 14:52:28 +0100215 /* now that we have bounded the local time, let's check if it's
216 * realistic regarding the global date, which only moves forward,
217 * otherwise catch up.
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200218 */
Willy Tarreau9fefc512017-11-23 14:52:28 +0100219 old_now = global_now;
Willy Tarreau75590582009-03-05 14:54:50 +0100220
Willy Tarreau9fefc512017-11-23 14:52:28 +0100221 do {
222 tmp_now.tv_sec = (unsigned int)(old_now >> 32);
223 tmp_now.tv_usec = old_now & 0xFFFFFFFFU;
Willy Tarreaua3315442018-02-05 20:11:38 +0100224 tmp_adj = adjusted;
Willy Tarreau7649aac2017-11-23 11:52:55 +0100225
Willy Tarreaua3315442018-02-05 20:11:38 +0100226 if (__tv_islt(&tmp_adj, &tmp_now))
227 tmp_adj = tmp_now;
Willy Tarreau9fefc512017-11-23 14:52:28 +0100228
229 /* now <adjusted> is expected to be the most accurate date,
230 * equal to <global_now> or newer.
231 */
Willy Tarreaua3315442018-02-05 20:11:38 +0100232 new_now = (((unsigned long long)tmp_adj.tv_sec) << 32) + (unsigned int)tmp_adj.tv_usec;
Willy Tarreau9fefc512017-11-23 14:52:28 +0100233
234 /* let's try to update the global <now> or loop again */
Olivier Houchardcab0f0b2019-03-08 18:55:31 +0100235 } while (!_HA_ATOMIC_CAS(&global_now, &old_now, new_now));
Willy Tarreau9fefc512017-11-23 14:52:28 +0100236
Willy Tarreaua3315442018-02-05 20:11:38 +0100237 adjusted = tmp_adj;
238
Willy Tarreau9fefc512017-11-23 14:52:28 +0100239 /* the new global date when we looked was old_now, and the new one is
240 * new_now == adjusted. We can recompute our local offset.
241 */
242 tv_offset.tv_sec = adjusted.tv_sec - date.tv_sec;
243 tv_offset.tv_usec = adjusted.tv_usec - date.tv_usec;
244 if (tv_offset.tv_usec < 0) {
245 tv_offset.tv_usec += 1000000;
246 tv_offset.tv_sec--;
247 }
Willy Tarreau7649aac2017-11-23 11:52:55 +0100248
Willy Tarreaue6313a32008-06-29 13:47:25 +0200249 to_ms:
Willy Tarreau75590582009-03-05 14:54:50 +0100250 now = adjusted;
251 curr_sec_ms = now.tv_usec / 1000; /* ms of current second */
Willy Tarreaueab777c2012-12-29 21:50:07 +0100252
253 /* For frequency counters, we'll need to know the ratio of the previous
254 * value to add to current value depending on the current millisecond.
255 * The principle is that during the first millisecond, we use 999/1000
256 * of the past value and that during the last millisecond we use 0/1000
257 * of the past value. In summary, we only use the past value during the
258 * first 999 ms of a second, and the last ms is used to complete the
259 * current measure. The value is scaled to (2^32-1) so that a simple
260 * multiply followed by a shift gives us the final value.
261 */
262 ms_left_scaled = (999U - curr_sec_ms) * 4294967U;
Willy Tarreau75590582009-03-05 14:54:50 +0100263 now_ms = now.tv_sec * 1000 + curr_sec_ms;
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200264 return;
Willy Tarreaub7f694f2008-06-22 17:18:02 +0200265}
266
Willy Tarreau93acfa22019-09-26 08:00:23 +0200267/* returns the current date as returned by gettimeofday() in ISO+microsecond
268 * format. It uses a thread-local static variable that the reader can consume
269 * for as long as it wants until next call. Thus, do not call it from a signal
270 * handler. If <pad> is non-0, a trailing space will be added. It will always
271 * return exactly 26 or 27 characters (depending on padding) and will always be
272 * zero-terminated, thus it will always fit into a 28 bytes buffer.
273 */
274char *timeofday_as_iso_us(int pad)
275{
276 struct timeval new_date;
277 struct tm tm;
278
279 gettimeofday(&new_date, NULL);
280 if (new_date.tv_sec != iso_time_sec || !new_date.tv_sec) {
281 get_localtime(new_date.tv_sec, &tm);
282 if (unlikely(strftime(iso_time_str, sizeof(iso_time_str), "%Y-%m-%dT%H:%M:%S.000000", &tm) != 26))
283 strcpy(iso_time_str, "YYYY-mm-ddTHH:MM:SS.000000"); // make the failure visible but respect format.
284 iso_time_sec = new_date.tv_sec;
285 }
286 utoa_pad(new_date.tv_usec, iso_time_str + 20, 7);
287 if (pad) {
288 iso_time_str[26] = ' ';
289 iso_time_str[27] = 0;
290 }
291 return iso_time_str;
292}
293
Willy Tarreaud825eef2007-05-12 22:35:00 +0200294/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200295 * Local variables:
296 * c-indent-level: 8
297 * c-basic-offset: 8
298 * End:
299 */