xref: /qemu/util/qemu-timer.c (revision 9a14b298bb9651488fb9ef3f619233e3fabb7621)
1 /*
2  * QEMU System Emulator
3  *
4  * Copyright (c) 2003-2008 Fabrice Bellard
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 
25 #include "sysemu.h"
26 #include "net.h"
27 #include "monitor.h"
28 #include "console.h"
29 
30 #include "hw/hw.h"
31 
32 #include "qemu-timer.h"
33 
34 #ifdef __FreeBSD__
35 #include <sys/param.h>
36 #endif
37 
38 #ifdef _WIN32
39 #include <mmsystem.h>
40 #endif
41 
42 /***********************************************************/
43 /* timers */
44 
45 #define QEMU_CLOCK_REALTIME 0
46 #define QEMU_CLOCK_VIRTUAL  1
47 #define QEMU_CLOCK_HOST     2
48 
49 struct QEMUClock {
50     QEMUTimer *active_timers;
51 
52     NotifierList reset_notifiers;
53     int64_t last;
54 
55     int type;
56     bool enabled;
57 };
58 
59 struct QEMUTimer {
60     int64_t expire_time;	/* in nanoseconds */
61     QEMUClock *clock;
62     QEMUTimerCB *cb;
63     void *opaque;
64     QEMUTimer *next;
65     int scale;
66 };
67 
68 struct qemu_alarm_timer {
69     char const *name;
70     int (*start)(struct qemu_alarm_timer *t);
71     void (*stop)(struct qemu_alarm_timer *t);
72     void (*rearm)(struct qemu_alarm_timer *t, int64_t nearest_delta_ns);
73 #if defined(__linux__)
74     timer_t timer;
75     int fd;
76 #elif defined(_WIN32)
77     HANDLE timer;
78 #endif
79     bool expired;
80     bool pending;
81 };
82 
83 static struct qemu_alarm_timer *alarm_timer;
84 
85 static bool qemu_timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
86 {
87     return timer_head && (timer_head->expire_time <= current_time);
88 }
89 
90 static int64_t qemu_next_alarm_deadline(void)
91 {
92     int64_t delta = INT64_MAX;
93     int64_t rtdelta;
94 
95     if (!use_icount && vm_clock->enabled && vm_clock->active_timers) {
96         delta = vm_clock->active_timers->expire_time -
97                      qemu_get_clock_ns(vm_clock);
98     }
99     if (host_clock->enabled && host_clock->active_timers) {
100         int64_t hdelta = host_clock->active_timers->expire_time -
101                  qemu_get_clock_ns(host_clock);
102         if (hdelta < delta) {
103             delta = hdelta;
104         }
105     }
106     if (rt_clock->enabled && rt_clock->active_timers) {
107         rtdelta = (rt_clock->active_timers->expire_time -
108                  qemu_get_clock_ns(rt_clock));
109         if (rtdelta < delta) {
110             delta = rtdelta;
111         }
112     }
113 
114     return delta;
115 }
116 
117 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
118 {
119     int64_t nearest_delta_ns;
120     if (!rt_clock->active_timers &&
121         !vm_clock->active_timers &&
122         !host_clock->active_timers) {
123         return;
124     }
125     nearest_delta_ns = qemu_next_alarm_deadline();
126     t->rearm(t, nearest_delta_ns);
127 }
128 
129 /* TODO: MIN_TIMER_REARM_NS should be optimized */
130 #define MIN_TIMER_REARM_NS 250000
131 
132 #ifdef _WIN32
133 
134 static int mm_start_timer(struct qemu_alarm_timer *t);
135 static void mm_stop_timer(struct qemu_alarm_timer *t);
136 static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
137 
138 static int win32_start_timer(struct qemu_alarm_timer *t);
139 static void win32_stop_timer(struct qemu_alarm_timer *t);
140 static void win32_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
141 
142 #else
143 
144 static int unix_start_timer(struct qemu_alarm_timer *t);
145 static void unix_stop_timer(struct qemu_alarm_timer *t);
146 static void unix_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
147 
148 #ifdef __linux__
149 
150 static int dynticks_start_timer(struct qemu_alarm_timer *t);
151 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
152 static void dynticks_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
153 
154 #endif /* __linux__ */
155 
156 #endif /* _WIN32 */
157 
158 static struct qemu_alarm_timer alarm_timers[] = {
159 #ifndef _WIN32
160 #ifdef __linux__
161     {"dynticks", dynticks_start_timer,
162      dynticks_stop_timer, dynticks_rearm_timer},
163 #endif
164     {"unix", unix_start_timer, unix_stop_timer, unix_rearm_timer},
165 #else
166     {"mmtimer", mm_start_timer, mm_stop_timer, mm_rearm_timer},
167     {"dynticks", win32_start_timer, win32_stop_timer, win32_rearm_timer},
168 #endif
169     {NULL, }
170 };
171 
172 static void show_available_alarms(void)
173 {
174     int i;
175 
176     printf("Available alarm timers, in order of precedence:\n");
177     for (i = 0; alarm_timers[i].name; i++)
178         printf("%s\n", alarm_timers[i].name);
179 }
180 
181 void configure_alarms(char const *opt)
182 {
183     int i;
184     int cur = 0;
185     int count = ARRAY_SIZE(alarm_timers) - 1;
186     char *arg;
187     char *name;
188     struct qemu_alarm_timer tmp;
189 
190     if (!strcmp(opt, "?")) {
191         show_available_alarms();
192         exit(0);
193     }
194 
195     arg = g_strdup(opt);
196 
197     /* Reorder the array */
198     name = strtok(arg, ",");
199     while (name) {
200         for (i = 0; i < count && alarm_timers[i].name; i++) {
201             if (!strcmp(alarm_timers[i].name, name))
202                 break;
203         }
204 
205         if (i == count) {
206             fprintf(stderr, "Unknown clock %s\n", name);
207             goto next;
208         }
209 
210         if (i < cur)
211             /* Ignore */
212             goto next;
213 
214 	/* Swap */
215         tmp = alarm_timers[i];
216         alarm_timers[i] = alarm_timers[cur];
217         alarm_timers[cur] = tmp;
218 
219         cur++;
220 next:
221         name = strtok(NULL, ",");
222     }
223 
224     g_free(arg);
225 
226     if (cur) {
227         /* Disable remaining timers */
228         for (i = cur; i < count; i++)
229             alarm_timers[i].name = NULL;
230     } else {
231         show_available_alarms();
232         exit(1);
233     }
234 }
235 
236 QEMUClock *rt_clock;
237 QEMUClock *vm_clock;
238 QEMUClock *host_clock;
239 
240 static QEMUClock *qemu_new_clock(int type)
241 {
242     QEMUClock *clock;
243 
244     clock = g_malloc0(sizeof(QEMUClock));
245     clock->type = type;
246     clock->enabled = true;
247     clock->last = INT64_MIN;
248     notifier_list_init(&clock->reset_notifiers);
249     return clock;
250 }
251 
252 void qemu_clock_enable(QEMUClock *clock, bool enabled)
253 {
254     bool old = clock->enabled;
255     clock->enabled = enabled;
256     if (enabled && !old) {
257         qemu_rearm_alarm_timer(alarm_timer);
258     }
259 }
260 
261 int64_t qemu_clock_has_timers(QEMUClock *clock)
262 {
263     return !!clock->active_timers;
264 }
265 
266 int64_t qemu_clock_expired(QEMUClock *clock)
267 {
268     return (clock->active_timers &&
269             clock->active_timers->expire_time < qemu_get_clock_ns(clock));
270 }
271 
272 int64_t qemu_clock_deadline(QEMUClock *clock)
273 {
274     /* To avoid problems with overflow limit this to 2^32.  */
275     int64_t delta = INT32_MAX;
276 
277     if (clock->active_timers) {
278         delta = clock->active_timers->expire_time - qemu_get_clock_ns(clock);
279     }
280     if (delta < 0) {
281         delta = 0;
282     }
283     return delta;
284 }
285 
286 QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
287                           QEMUTimerCB *cb, void *opaque)
288 {
289     QEMUTimer *ts;
290 
291     ts = g_malloc0(sizeof(QEMUTimer));
292     ts->clock = clock;
293     ts->cb = cb;
294     ts->opaque = opaque;
295     ts->scale = scale;
296     return ts;
297 }
298 
299 void qemu_free_timer(QEMUTimer *ts)
300 {
301     g_free(ts);
302 }
303 
304 /* stop a timer, but do not dealloc it */
305 void qemu_del_timer(QEMUTimer *ts)
306 {
307     QEMUTimer **pt, *t;
308 
309     /* NOTE: this code must be signal safe because
310        qemu_timer_expired() can be called from a signal. */
311     pt = &ts->clock->active_timers;
312     for(;;) {
313         t = *pt;
314         if (!t)
315             break;
316         if (t == ts) {
317             *pt = t->next;
318             break;
319         }
320         pt = &t->next;
321     }
322 }
323 
324 /* modify the current timer so that it will be fired when current_time
325    >= expire_time. The corresponding callback will be called. */
326 void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time)
327 {
328     QEMUTimer **pt, *t;
329 
330     qemu_del_timer(ts);
331 
332     /* add the timer in the sorted list */
333     /* NOTE: this code must be signal safe because
334        qemu_timer_expired() can be called from a signal. */
335     pt = &ts->clock->active_timers;
336     for(;;) {
337         t = *pt;
338         if (!qemu_timer_expired_ns(t, expire_time)) {
339             break;
340         }
341         pt = &t->next;
342     }
343     ts->expire_time = expire_time;
344     ts->next = *pt;
345     *pt = ts;
346 
347     /* Rearm if necessary  */
348     if (pt == &ts->clock->active_timers) {
349         if (!alarm_timer->pending) {
350             qemu_rearm_alarm_timer(alarm_timer);
351         }
352         /* Interrupt execution to force deadline recalculation.  */
353         qemu_clock_warp(ts->clock);
354         if (use_icount) {
355             qemu_notify_event();
356         }
357     }
358 }
359 
360 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
361 {
362     qemu_mod_timer_ns(ts, expire_time * ts->scale);
363 }
364 
365 bool qemu_timer_pending(QEMUTimer *ts)
366 {
367     QEMUTimer *t;
368     for (t = ts->clock->active_timers; t != NULL; t = t->next) {
369         if (t == ts) {
370             return true;
371         }
372     }
373     return false;
374 }
375 
376 bool qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
377 {
378     return qemu_timer_expired_ns(timer_head, current_time * timer_head->scale);
379 }
380 
381 void qemu_run_timers(QEMUClock *clock)
382 {
383     QEMUTimer **ptimer_head, *ts;
384     int64_t current_time;
385 
386     if (!clock->enabled)
387         return;
388 
389     current_time = qemu_get_clock_ns(clock);
390     ptimer_head = &clock->active_timers;
391     for(;;) {
392         ts = *ptimer_head;
393         if (!qemu_timer_expired_ns(ts, current_time)) {
394             break;
395         }
396         /* remove timer from the list before calling the callback */
397         *ptimer_head = ts->next;
398         ts->next = NULL;
399 
400         /* run the callback (the timer list can be modified) */
401         ts->cb(ts->opaque);
402     }
403 }
404 
405 int64_t qemu_get_clock_ns(QEMUClock *clock)
406 {
407     int64_t now, last;
408 
409     switch(clock->type) {
410     case QEMU_CLOCK_REALTIME:
411         return get_clock();
412     default:
413     case QEMU_CLOCK_VIRTUAL:
414         if (use_icount) {
415             return cpu_get_icount();
416         } else {
417             return cpu_get_clock();
418         }
419     case QEMU_CLOCK_HOST:
420         now = get_clock_realtime();
421         last = clock->last;
422         clock->last = now;
423         if (now < last) {
424             notifier_list_notify(&clock->reset_notifiers, &now);
425         }
426         return now;
427     }
428 }
429 
430 void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
431 {
432     notifier_list_add(&clock->reset_notifiers, notifier);
433 }
434 
435 void qemu_unregister_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
436 {
437     notifier_remove(notifier);
438 }
439 
440 void init_clocks(void)
441 {
442     rt_clock = qemu_new_clock(QEMU_CLOCK_REALTIME);
443     vm_clock = qemu_new_clock(QEMU_CLOCK_VIRTUAL);
444     host_clock = qemu_new_clock(QEMU_CLOCK_HOST);
445 }
446 
447 uint64_t qemu_timer_expire_time_ns(QEMUTimer *ts)
448 {
449     return qemu_timer_pending(ts) ? ts->expire_time : -1;
450 }
451 
452 void qemu_run_all_timers(void)
453 {
454     alarm_timer->pending = false;
455 
456     /* vm time timers */
457     qemu_run_timers(vm_clock);
458     qemu_run_timers(rt_clock);
459     qemu_run_timers(host_clock);
460 
461     /* rearm timer, if not periodic */
462     if (alarm_timer->expired) {
463         alarm_timer->expired = false;
464         qemu_rearm_alarm_timer(alarm_timer);
465     }
466 }
467 
468 #ifdef _WIN32
469 static void CALLBACK host_alarm_handler(PVOID lpParam, BOOLEAN unused)
470 #else
471 static void host_alarm_handler(int host_signum)
472 #endif
473 {
474     struct qemu_alarm_timer *t = alarm_timer;
475     if (!t)
476 	return;
477 
478     t->expired = true;
479     t->pending = true;
480     qemu_notify_event();
481 }
482 
483 #if defined(__linux__)
484 
485 #include "compatfd.h"
486 
487 static int dynticks_start_timer(struct qemu_alarm_timer *t)
488 {
489     struct sigevent ev;
490     timer_t host_timer;
491     struct sigaction act;
492 
493     sigfillset(&act.sa_mask);
494     act.sa_flags = 0;
495     act.sa_handler = host_alarm_handler;
496 
497     sigaction(SIGALRM, &act, NULL);
498 
499     /*
500      * Initialize ev struct to 0 to avoid valgrind complaining
501      * about uninitialized data in timer_create call
502      */
503     memset(&ev, 0, sizeof(ev));
504     ev.sigev_value.sival_int = 0;
505     ev.sigev_notify = SIGEV_SIGNAL;
506 #ifdef SIGEV_THREAD_ID
507     if (qemu_signalfd_available()) {
508         ev.sigev_notify = SIGEV_THREAD_ID;
509         ev._sigev_un._tid = qemu_get_thread_id();
510     }
511 #endif /* SIGEV_THREAD_ID */
512     ev.sigev_signo = SIGALRM;
513 
514     if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
515         perror("timer_create");
516         return -1;
517     }
518 
519     t->timer = host_timer;
520 
521     return 0;
522 }
523 
524 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
525 {
526     timer_t host_timer = t->timer;
527 
528     timer_delete(host_timer);
529 }
530 
531 static void dynticks_rearm_timer(struct qemu_alarm_timer *t,
532                                  int64_t nearest_delta_ns)
533 {
534     timer_t host_timer = t->timer;
535     struct itimerspec timeout;
536     int64_t current_ns;
537 
538     if (nearest_delta_ns < MIN_TIMER_REARM_NS)
539         nearest_delta_ns = MIN_TIMER_REARM_NS;
540 
541     /* check whether a timer is already running */
542     if (timer_gettime(host_timer, &timeout)) {
543         perror("gettime");
544         fprintf(stderr, "Internal timer error: aborting\n");
545         exit(1);
546     }
547     current_ns = timeout.it_value.tv_sec * 1000000000LL + timeout.it_value.tv_nsec;
548     if (current_ns && current_ns <= nearest_delta_ns)
549         return;
550 
551     timeout.it_interval.tv_sec = 0;
552     timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
553     timeout.it_value.tv_sec =  nearest_delta_ns / 1000000000;
554     timeout.it_value.tv_nsec = nearest_delta_ns % 1000000000;
555     if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
556         perror("settime");
557         fprintf(stderr, "Internal timer error: aborting\n");
558         exit(1);
559     }
560 }
561 
562 #endif /* defined(__linux__) */
563 
564 #if !defined(_WIN32)
565 
566 static int unix_start_timer(struct qemu_alarm_timer *t)
567 {
568     struct sigaction act;
569 
570     /* timer signal */
571     sigfillset(&act.sa_mask);
572     act.sa_flags = 0;
573     act.sa_handler = host_alarm_handler;
574 
575     sigaction(SIGALRM, &act, NULL);
576     return 0;
577 }
578 
579 static void unix_rearm_timer(struct qemu_alarm_timer *t,
580                              int64_t nearest_delta_ns)
581 {
582     struct itimerval itv;
583     int err;
584 
585     if (nearest_delta_ns < MIN_TIMER_REARM_NS)
586         nearest_delta_ns = MIN_TIMER_REARM_NS;
587 
588     itv.it_interval.tv_sec = 0;
589     itv.it_interval.tv_usec = 0; /* 0 for one-shot timer */
590     itv.it_value.tv_sec =  nearest_delta_ns / 1000000000;
591     itv.it_value.tv_usec = (nearest_delta_ns % 1000000000) / 1000;
592     err = setitimer(ITIMER_REAL, &itv, NULL);
593     if (err) {
594         perror("setitimer");
595         fprintf(stderr, "Internal timer error: aborting\n");
596         exit(1);
597     }
598 }
599 
600 static void unix_stop_timer(struct qemu_alarm_timer *t)
601 {
602     struct itimerval itv;
603 
604     memset(&itv, 0, sizeof(itv));
605     setitimer(ITIMER_REAL, &itv, NULL);
606 }
607 
608 #endif /* !defined(_WIN32) */
609 
610 
611 #ifdef _WIN32
612 
613 static MMRESULT mm_timer;
614 static unsigned mm_period;
615 
616 static void CALLBACK mm_alarm_handler(UINT uTimerID, UINT uMsg,
617                                       DWORD_PTR dwUser, DWORD_PTR dw1,
618                                       DWORD_PTR dw2)
619 {
620     struct qemu_alarm_timer *t = alarm_timer;
621     if (!t) {
622         return;
623     }
624     t->expired = true;
625     t->pending = true;
626     qemu_notify_event();
627 }
628 
629 static int mm_start_timer(struct qemu_alarm_timer *t)
630 {
631     TIMECAPS tc;
632 
633     memset(&tc, 0, sizeof(tc));
634     timeGetDevCaps(&tc, sizeof(tc));
635 
636     mm_period = tc.wPeriodMin;
637     timeBeginPeriod(mm_period);
638 
639     mm_timer = timeSetEvent(1,                  /* interval (ms) */
640                             mm_period,          /* resolution */
641                             mm_alarm_handler,   /* function */
642                             (DWORD_PTR)t,       /* parameter */
643                             TIME_ONESHOT | TIME_CALLBACK_FUNCTION);
644 
645     if (!mm_timer) {
646         fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
647                 GetLastError());
648         timeEndPeriod(mm_period);
649         return -1;
650     }
651 
652     return 0;
653 }
654 
655 static void mm_stop_timer(struct qemu_alarm_timer *t)
656 {
657     timeKillEvent(mm_timer);
658     timeEndPeriod(mm_period);
659 }
660 
661 static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta)
662 {
663     int64_t nearest_delta_ms = delta / 1000000;
664     if (nearest_delta_ms < 1) {
665         nearest_delta_ms = 1;
666     }
667     /* UINT_MAX can be 32 bit */
668     if (nearest_delta_ms > UINT_MAX) {
669         nearest_delta_ms = UINT_MAX;
670     }
671 
672     timeKillEvent(mm_timer);
673     mm_timer = timeSetEvent((unsigned int) nearest_delta_ms,
674                             mm_period,
675                             mm_alarm_handler,
676                             (DWORD_PTR)t,
677                             TIME_ONESHOT | TIME_CALLBACK_FUNCTION);
678 
679     if (!mm_timer) {
680         fprintf(stderr, "Failed to re-arm win32 alarm timer %ld\n",
681                 GetLastError());
682 
683         timeEndPeriod(mm_period);
684         exit(1);
685     }
686 }
687 
688 static int win32_start_timer(struct qemu_alarm_timer *t)
689 {
690     HANDLE hTimer;
691     BOOLEAN success;
692 
693     /* If you call ChangeTimerQueueTimer on a one-shot timer (its period
694        is zero) that has already expired, the timer is not updated.  Since
695        creating a new timer is relatively expensive, set a bogus one-hour
696        interval in the dynticks case.  */
697     success = CreateTimerQueueTimer(&hTimer,
698                           NULL,
699                           host_alarm_handler,
700                           t,
701                           1,
702                           3600000,
703                           WT_EXECUTEINTIMERTHREAD);
704 
705     if (!success) {
706         fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
707                 GetLastError());
708         return -1;
709     }
710 
711     t->timer = hTimer;
712     return 0;
713 }
714 
715 static void win32_stop_timer(struct qemu_alarm_timer *t)
716 {
717     HANDLE hTimer = t->timer;
718 
719     if (hTimer) {
720         DeleteTimerQueueTimer(NULL, hTimer, NULL);
721     }
722 }
723 
724 static void win32_rearm_timer(struct qemu_alarm_timer *t,
725                               int64_t nearest_delta_ns)
726 {
727     HANDLE hTimer = t->timer;
728     int64_t nearest_delta_ms;
729     BOOLEAN success;
730 
731     nearest_delta_ms = nearest_delta_ns / 1000000;
732     if (nearest_delta_ms < 1) {
733         nearest_delta_ms = 1;
734     }
735     /* ULONG_MAX can be 32 bit */
736     if (nearest_delta_ms > ULONG_MAX) {
737         nearest_delta_ms = ULONG_MAX;
738     }
739     success = ChangeTimerQueueTimer(NULL,
740                                     hTimer,
741                                     (unsigned long) nearest_delta_ms,
742                                     3600000);
743 
744     if (!success) {
745         fprintf(stderr, "Failed to rearm win32 alarm timer: %ld\n",
746                 GetLastError());
747         exit(-1);
748     }
749 
750 }
751 
752 #endif /* _WIN32 */
753 
754 static void quit_timers(void)
755 {
756     struct qemu_alarm_timer *t = alarm_timer;
757     alarm_timer = NULL;
758     t->stop(t);
759 }
760 
761 int init_timer_alarm(void)
762 {
763     struct qemu_alarm_timer *t = NULL;
764     int i, err = -1;
765 
766     for (i = 0; alarm_timers[i].name; i++) {
767         t = &alarm_timers[i];
768 
769         err = t->start(t);
770         if (!err)
771             break;
772     }
773 
774     if (err) {
775         err = -ENOENT;
776         goto fail;
777     }
778 
779     /* first event is at time 0 */
780     atexit(quit_timers);
781     t->pending = true;
782     alarm_timer = t;
783 
784     return 0;
785 
786 fail:
787     return err;
788 }
789 
790