1 /* Asynchronous timers.
2 Copyright (C) 2000-2012 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
24 #include "syssignal.h"
26 #include "blockinput.h"
30 /* Free-list of atimer structures. */
32 static struct atimer
*free_atimers
;
34 /* List of currently not running timers due to a call to
37 static struct atimer
*stopped_atimers
;
39 /* List of active atimers, sorted by expiration time. The timer that
40 will become ripe next is always at the front of this list. */
42 static struct atimer
*atimers
;
44 /* Non-zero means alarm signal handler has found ripe timers but
45 interrupt_input_blocked was non-zero. In this case, timer
46 functions are not called until the next UNBLOCK_INPUT because timer
47 functions are expected to call X, and X cannot be assumed to be
52 /* Block/unblock SIGALRM. */
54 #define BLOCK_ATIMERS sigblock (sigmask (SIGALRM))
55 #define UNBLOCK_ATIMERS sigunblock (sigmask (SIGALRM))
57 /* Function prototypes. */
59 static void set_alarm (void);
60 static void schedule_atimer (struct atimer
*);
61 static struct atimer
*append_atimer_lists (struct atimer
*,
64 /* Start a new atimer of type TYPE. TIME specifies when the timer is
65 ripe. FN is the function to call when the timer fires.
66 CLIENT_DATA is stored in the client_data member of the atimer
67 structure returned and so made available to FN when it is called.
69 If TYPE is ATIMER_ABSOLUTE, TIME is the absolute time at which the
72 If TYPE is ATIMER_RELATIVE, the timer is ripe TIME s/us in the
75 In both cases, the timer is automatically freed after it has fired.
77 If TYPE is ATIMER_CONTINUOUS, the timer fires every TIME s/us.
79 Value is a pointer to the atimer started. It can be used in calls
80 to cancel_atimer; don't free it yourself. */
83 start_atimer (enum atimer_type type
, EMACS_TIME timestamp
, atimer_callback fn
,
88 /* Round TIME up to the next full second if we don't have
90 #ifndef HAVE_SETITIMER
91 if (EMACS_NSECS (timestamp
) != 0
92 && EMACS_SECS (timestamp
) < TYPE_MAXIMUM (time_t))
93 timestamp
= make_emacs_time (EMACS_SECS (timestamp
) + 1, 0);
94 #endif /* not HAVE_SETITIMER */
96 /* Get an atimer structure from the free-list, or allocate
101 free_atimers
= t
->next
;
104 t
= xmalloc (sizeof *t
);
106 /* Fill the atimer structure. */
107 memset (t
, 0, sizeof *t
);
110 t
->client_data
= client_data
;
114 /* Compute the timer's expiration time. */
117 case ATIMER_ABSOLUTE
:
118 t
->expiration
= timestamp
;
121 case ATIMER_RELATIVE
:
122 t
->expiration
= add_emacs_time (current_emacs_time (), timestamp
);
125 case ATIMER_CONTINUOUS
:
126 t
->expiration
= add_emacs_time (current_emacs_time (), timestamp
);
127 t
->interval
= timestamp
;
131 /* Insert the timer in the list of active atimers. */
135 /* Arrange for a SIGALRM at the time the next atimer is ripe. */
142 /* Cancel and free atimer TIMER. */
145 cancel_atimer (struct atimer
*timer
)
151 for (i
= 0; i
< 2; ++i
)
153 struct atimer
*t
, *prev
;
154 struct atimer
**list
= i
? &stopped_atimers
: &atimers
;
156 /* See if TIMER is active or stopped. */
157 for (t
= *list
, prev
= NULL
; t
&& t
!= timer
; prev
= t
, t
= t
->next
)
160 /* If it is, take it off its list, and put in on the free-list.
161 We don't bother to arrange for setting a different alarm time,
162 since a too early one doesn't hurt. */
166 prev
->next
= t
->next
;
170 t
->next
= free_atimers
;
180 /* Append two lists of atimers LIST_1 and LIST_2 and return the
183 static struct atimer
*
184 append_atimer_lists (struct atimer
*list_1
, struct atimer
*list_2
)
188 else if (list_2
== NULL
)
194 for (p
= list_1
; p
->next
; p
= p
->next
)
202 /* Stop all timers except timer T. T null means stop all timers. */
205 stop_other_atimers (struct atimer
*t
)
211 struct atimer
*p
, *prev
;
213 /* See if T is active. */
214 for (p
= atimers
, prev
= NULL
; p
&& p
!= t
; prev
= p
, p
= p
->next
)
220 prev
->next
= t
->next
;
226 /* T is not active. Let's handle this like T == 0. */
230 stopped_atimers
= append_atimer_lists (atimers
, stopped_atimers
);
236 /* Run all timers again, if some have been stopped with a call to
237 stop_other_atimers. */
240 run_all_atimers (void)
244 struct atimer
*t
= atimers
;
248 atimers
= stopped_atimers
;
249 stopped_atimers
= NULL
;
263 /* A version of run_all_atimers suitable for a record_unwind_protect. */
266 unwind_stop_other_atimers (Lisp_Object dummy
)
273 /* Arrange for a SIGALRM to arrive when the next timer is ripe. */
280 #ifdef HAVE_SETITIMER
284 /* Determine s/us till the next timer is ripe. */
285 EMACS_TIME now
= current_emacs_time ();
287 /* Don't set the interval to 0; this disables the timer. */
288 EMACS_TIME interval
= (EMACS_TIME_LE (atimers
->expiration
, now
)
289 ? make_emacs_time (0, 1000 * 1000)
290 : sub_emacs_time (atimers
->expiration
, now
));
292 #ifdef HAVE_SETITIMER
294 memset (&it
, 0, sizeof it
);
295 it
.it_value
= make_timeval (interval
);
296 setitimer (ITIMER_REAL
, &it
, 0);
297 #else /* not HAVE_SETITIMER */
298 alarm (max (EMACS_SECS (interval
), 1));
299 #endif /* not HAVE_SETITIMER */
304 /* Insert timer T into the list of active atimers `atimers', keeping
305 the list sorted by expiration time. T must not be in this list
309 schedule_atimer (struct atimer
*t
)
311 struct atimer
*a
= atimers
, *prev
= NULL
;
313 /* Look for the first atimer that is ripe after T. */
314 while (a
&& EMACS_TIME_GT (t
->expiration
, a
->expiration
))
315 prev
= a
, a
= a
->next
;
317 /* Insert T in front of the atimer found, if any. */
332 && (pending_atimers
= interrupt_input_blocked
) == 0
333 && (now
= current_emacs_time (),
334 EMACS_TIME_LE (atimers
->expiration
, now
)))
339 atimers
= atimers
->next
;
342 if (t
->type
== ATIMER_CONTINUOUS
)
344 t
->expiration
= add_emacs_time (now
, t
->interval
);
349 t
->next
= free_atimers
;
362 pending_signals
= interrupt_input_pending
;
366 if (! pending_atimers
)
372 /* Signal handler for SIGALRM. SIGNO is the signal number, i.e.
376 handle_alarm_signal (int sig
)
387 deliver_alarm_signal (int sig
)
389 handle_on_main_thread (sig
, handle_alarm_signal
);
393 /* Call alarm signal handler for pending timers. */
396 do_pending_atimers (void)
407 /* Turn alarms on/off. This seems to be temporarily necessary on
408 some systems like HPUX (see process.c). */
411 turn_on_atimers (bool on
)
415 signal (SIGALRM
, deliver_alarm_signal
);
426 free_atimers
= stopped_atimers
= atimers
= NULL
;
428 /* pending_signals is initialized in init_keyboard.*/
429 signal (SIGALRM
, deliver_alarm_signal
);