Annotation of embedaddon/bird2/lib/timer.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD -- Timers
3: *
4: * (c) 2013--2017 Ondrej Zajicek <santiago@crfreenet.org>
5: * (c) 2013--2017 CZ.NIC z.s.p.o.
6: *
7: * Can be freely distributed and used under the terms of the GNU GPL.
8: */
9:
10: /**
11: * DOC: Timers
12: *
13: * Timers are resources which represent a wish of a module to call a function at
14: * the specified time. The timer code does not guarantee exact timing, only that
15: * a timer function will not be called before the requested time.
16: *
17: * In BIRD, time is represented by values of the &btime type which is signed
18: * 64-bit integer interpreted as a relative number of microseconds since some
19: * fixed time point in past. The current time can be obtained by current_time()
20: * function with reasonable accuracy and is monotonic. There is also a current
21: * 'wall-clock' real time obtainable by current_real_time() reported by OS.
22: *
23: * Each timer is described by a &timer structure containing a pointer to the
24: * handler function (@hook), data private to this function (@data), time the
25: * function should be called at (@expires, 0 for inactive timers), for the other
26: * fields see |timer.h|.
27: */
28:
29: #include <stdio.h>
30: #include <stdlib.h>
31: #include <time.h>
32:
33: #include "nest/bird.h"
34:
35: #include "lib/heap.h"
36: #include "lib/resource.h"
37: #include "lib/timer.h"
38:
39:
40: struct timeloop main_timeloop;
41:
42:
43: #ifdef USE_PTHREADS
44:
45: #include <pthread.h>
46:
47: /* Data accessed and modified from proto/bfd/io.c */
48: pthread_key_t current_time_key;
49:
50: static inline struct timeloop *
51: timeloop_current(void)
52: {
53: return pthread_getspecific(current_time_key);
54: }
55:
56: static inline void
57: timeloop_init_current(void)
58: {
59: pthread_key_create(¤t_time_key, NULL);
60: pthread_setspecific(current_time_key, &main_timeloop);
61: }
62:
63: void wakeup_kick_current(void);
64:
65: #else
66:
67: /* Just use main timelooop */
68: static inline struct timeloop * timeloop_current(void) { return &main_timeloop; }
69: static inline void timeloop_init_current(void) { }
70:
71: #endif
72:
73: btime
74: current_time(void)
75: {
76: return timeloop_current()->last_time;
77: }
78:
79: btime
80: current_real_time(void)
81: {
82: struct timeloop *loop = timeloop_current();
83:
84: if (!loop->real_time)
85: times_update_real_time(loop);
86:
87: return loop->real_time;
88: }
89:
90:
91: #define TIMER_LESS(a,b) ((a)->expires < (b)->expires)
92: #define TIMER_SWAP(heap,a,b,t) (t = heap[a], heap[a] = heap[b], heap[b] = t, \
93: heap[a]->index = (a), heap[b]->index = (b))
94:
95:
96: static void
97: tm_free(resource *r)
98: {
99: timer *t = (void *) r;
100:
101: tm_stop(t);
102: }
103:
104: static void
105: tm_dump(resource *r)
106: {
107: timer *t = (void *) r;
108:
109: debug("(code %p, data %p, ", t->hook, t->data);
110: if (t->randomize)
111: debug("rand %d, ", t->randomize);
112: if (t->recurrent)
113: debug("recur %d, ", t->recurrent);
114: if (t->expires)
115: debug("expires in %d ms)\n", (t->expires - current_time()) TO_MS);
116: else
117: debug("inactive)\n");
118: }
119:
120:
121: static struct resclass tm_class = {
122: "Timer",
123: sizeof(timer),
124: tm_free,
125: tm_dump,
126: NULL,
127: NULL
128: };
129:
130: timer *
131: tm_new(pool *p)
132: {
133: timer *t = ralloc(p, &tm_class);
134: t->index = -1;
135: return t;
136: }
137:
138: void
139: tm_set(timer *t, btime when)
140: {
141: struct timeloop *loop = timeloop_current();
142: uint tc = timers_count(loop);
143:
144: if (!t->expires)
145: {
146: t->index = ++tc;
147: t->expires = when;
148: BUFFER_PUSH(loop->timers) = t;
149: HEAP_INSERT(loop->timers.data, tc, timer *, TIMER_LESS, TIMER_SWAP);
150: }
151: else if (t->expires < when)
152: {
153: t->expires = when;
154: HEAP_INCREASE(loop->timers.data, tc, timer *, TIMER_LESS, TIMER_SWAP, t->index);
155: }
156: else if (t->expires > when)
157: {
158: t->expires = when;
159: HEAP_DECREASE(loop->timers.data, tc, timer *, TIMER_LESS, TIMER_SWAP, t->index);
160: }
161:
162: #ifdef CONFIG_BFD
163: /* Hack to notify BFD loops */
164: if ((loop != &main_timeloop) && (t->index == 1))
165: wakeup_kick_current();
166: #endif
167: }
168:
169: void
170: tm_start(timer *t, btime after)
171: {
172: tm_set(t, current_time() + MAX(after, 0));
173: }
174:
175: void
176: tm_stop(timer *t)
177: {
178: if (!t->expires)
179: return;
180:
181: struct timeloop *loop = timeloop_current();
182: uint tc = timers_count(loop);
183:
184: HEAP_DELETE(loop->timers.data, tc, timer *, TIMER_LESS, TIMER_SWAP, t->index);
185: BUFFER_POP(loop->timers);
186:
187: t->index = -1;
188: t->expires = 0;
189: }
190:
191: void
192: timers_init(struct timeloop *loop, pool *p)
193: {
194: times_init(loop);
195:
196: BUFFER_INIT(loop->timers, p, 4);
197: BUFFER_PUSH(loop->timers) = NULL;
198: }
199:
200: void io_log_event(void *hook, void *data);
201:
202: void
203: timers_fire(struct timeloop *loop)
204: {
205: btime base_time;
206: timer *t;
207:
208: times_update(loop);
209: base_time = loop->last_time;
210:
211: while (t = timers_first(loop))
212: {
213: if (t->expires > base_time)
214: return;
215:
216: if (t->recurrent)
217: {
218: btime when = t->expires + t->recurrent;
219:
220: if (when <= loop->last_time)
221: when = loop->last_time + t->recurrent;
222:
223: if (t->randomize)
224: when += random() % (t->randomize + 1);
225:
226: tm_set(t, when);
227: }
228: else
229: tm_stop(t);
230:
231: /* This is ugly hack, we want to log just timers executed from the main I/O loop */
232: if (loop == &main_timeloop)
233: io_log_event(t->hook, t->data);
234:
235: t->hook(t);
236: }
237: }
238:
239: void
240: timer_init(void)
241: {
242: timers_init(&main_timeloop, &root_pool);
243: timeloop_init_current();
244: }
245:
246:
247: /**
248: * tm_parse_time - parse a date and time
249: * @x: time string
250: *
251: * tm_parse_time() takes a textual representation of a date and time
252: * (yyyy-mm-dd[ hh:mm:ss[.sss]]) and converts it to the corresponding value of
253: * type &btime.
254: */
255: btime
256: tm_parse_time(char *x)
257: {
258: struct tm tm;
259: int usec, n1, n2, n3, r;
260:
261: r = sscanf(x, "%d-%d-%d%n %d:%d:%d%n.%d%n",
262: &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &n1,
263: &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &n2,
264: &usec, &n3);
265:
266: if ((r == 3) && !x[n1])
267: tm.tm_hour = tm.tm_min = tm.tm_sec = usec = 0;
268: else if ((r == 6) && !x[n2])
269: usec = 0;
270: else if ((r == 7) && !x[n3])
271: {
272: /* Convert subsecond digits to proper precision */
273: int digits = n3 - n2 - 1;
274: if ((usec < 0) || (usec > 999999) || (digits < 1) || (digits > 6))
275: return 0;
276:
277: while (digits++ < 6)
278: usec *= 10;
279: }
280: else
281: return 0;
282:
283: tm.tm_mon--;
284: tm.tm_year -= 1900;
285: s64 ts = mktime(&tm);
286: if ((ts == (s64) (time_t) -1) || (ts < 0) || (ts > ((s64) 1 << 40)))
287: return 0;
288:
289: return ts S + usec;
290: }
291:
292: /**
293: * tm_format_time - convert date and time to textual representation
294: * @x: destination buffer of size %TM_DATETIME_BUFFER_SIZE
295: * @fmt: specification of resulting textual representation of the time
296: * @t: time
297: *
298: * This function formats the given relative time value @t to a textual
299: * date/time representation (dd-mm-yyyy hh:mm:ss) in real time.
300: */
301: void
302: tm_format_time(char *x, struct timeformat *fmt, btime t)
303: {
304: btime dt = current_time() - t;
305: btime rt = current_real_time() - dt;
306: int v1 = !fmt->limit || (dt < fmt->limit);
307:
308: if (!tm_format_real_time(x, TM_DATETIME_BUFFER_SIZE, v1 ? fmt->fmt1 : fmt->fmt2, rt))
309: strcpy(x, "<error>");
310: }
311:
312: /* Replace %f in format string with usec scaled to requested precision */
313: static int
314: strfusec(char *buf, int size, const char *fmt, uint usec)
315: {
316: char *str = buf;
317: int parity = 0;
318:
319: while (*fmt)
320: {
321: if (!size)
322: return 0;
323:
324: if ((fmt[0] == '%') && (!parity) &&
325: ((fmt[1] == 'f') || (fmt[1] >= '1') && (fmt[1] <= '6') && (fmt[2] == 'f')))
326: {
327: int digits = (fmt[1] == 'f') ? 6 : (fmt[1] - '0');
328: uint d = digits, u = usec;
329:
330: /* Convert microseconds to requested precision */
331: while (d++ < 6)
332: u /= 10;
333:
334: int num = bsnprintf(str, size, "%0*u", digits, u);
335: if (num < 0)
336: return 0;
337:
338: fmt += (fmt[1] == 'f') ? 2 : 3;
339: ADVANCE(str, size, num);
340: }
341: else
342: {
343: /* Handle '%%' expression */
344: parity = (*fmt == '%') ? !parity : 0;
345: *str++ = *fmt++;
346: size--;
347: }
348: }
349:
350: if (!size)
351: return 0;
352:
353: *str = 0;
354: return str - buf;
355: }
356:
357: int
358: tm_format_real_time(char *x, size_t max, const char *fmt, btime t)
359: {
360: s64 t1 = t TO_S;
361: s64 t2 = t - t1 S;
362:
363: time_t ts = t1;
364: struct tm tm;
365: if (!localtime_r(&ts, &tm))
366: return 0;
367:
368: byte tbuf[TM_DATETIME_BUFFER_SIZE];
369: if (!strfusec(tbuf, max, fmt, t2))
370: return 0;
371:
372: if (!strftime(x, max, tbuf, &tm))
373: return 0;
374:
375: return 1;
376: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to timer.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / lib