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/>. */
23 #include "syssignal.h"
25 #include "blockinput.h"
29 /* Free-list of atimer structures. */
31 static struct atimer
*free_atimers
;
33 /* List of currently not running timers due to a call to
36 static struct atimer
*stopped_atimers
;
38 /* List of active atimers, sorted by expiration time. The timer that
39 will become ripe next is always at the front of this list. */
41 static struct atimer
*atimers
;
43 /* Block/unblock SIGALRM. */
46 sigmask_atimers (int how
)
49 sigemptyset (&blocked
);
50 sigaddset (&blocked
, SIGALRM
);
51 pthread_sigmask (how
, &blocked
, 0);
56 sigmask_atimers (SIG_BLOCK
);
59 unblock_atimers (void)
61 sigmask_atimers (SIG_UNBLOCK
);
64 /* Function prototypes. */
66 static void set_alarm (void);
67 static void schedule_atimer (struct atimer
*);
68 static struct atimer
*append_atimer_lists (struct atimer
*,
71 /* Start a new atimer of type TYPE. TIME specifies when the timer is
72 ripe. FN is the function to call when the timer fires.
73 CLIENT_DATA is stored in the client_data member of the atimer
74 structure returned and so made available to FN when it is called.
76 If TYPE is ATIMER_ABSOLUTE, TIME is the absolute time at which the
79 If TYPE is ATIMER_RELATIVE, the timer is ripe TIME s/us in the
82 In both cases, the timer is automatically freed after it has fired.
84 If TYPE is ATIMER_CONTINUOUS, the timer fires every TIME s/us.
86 Value is a pointer to the atimer started. It can be used in calls
87 to cancel_atimer; don't free it yourself. */
90 start_atimer (enum atimer_type type
, EMACS_TIME timestamp
, atimer_callback fn
,
95 /* Round TIME up to the next full second if we don't have
97 #ifndef HAVE_SETITIMER
98 if (EMACS_NSECS (timestamp
) != 0
99 && EMACS_SECS (timestamp
) < TYPE_MAXIMUM (time_t))
100 timestamp
= make_emacs_time (EMACS_SECS (timestamp
) + 1, 0);
101 #endif /* not HAVE_SETITIMER */
103 /* Get an atimer structure from the free-list, or allocate
108 free_atimers
= t
->next
;
111 t
= xmalloc (sizeof *t
);
113 /* Fill the atimer structure. */
114 memset (t
, 0, sizeof *t
);
117 t
->client_data
= client_data
;
121 /* Compute the timer's expiration time. */
124 case ATIMER_ABSOLUTE
:
125 t
->expiration
= timestamp
;
128 case ATIMER_RELATIVE
:
129 t
->expiration
= add_emacs_time (current_emacs_time (), timestamp
);
132 case ATIMER_CONTINUOUS
:
133 t
->expiration
= add_emacs_time (current_emacs_time (), timestamp
);
134 t
->interval
= timestamp
;
138 /* Insert the timer in the list of active atimers. */
142 /* Arrange for a SIGALRM at the time the next atimer is ripe. */
149 /* Cancel and free atimer TIMER. */
152 cancel_atimer (struct atimer
*timer
)
158 for (i
= 0; i
< 2; ++i
)
160 struct atimer
*t
, *prev
;
161 struct atimer
**list
= i
? &stopped_atimers
: &atimers
;
163 /* See if TIMER is active or stopped. */
164 for (t
= *list
, prev
= NULL
; t
&& t
!= timer
; prev
= t
, t
= t
->next
)
167 /* If it is, take it off its list, and put in on the free-list.
168 We don't bother to arrange for setting a different alarm time,
169 since a too early one doesn't hurt. */
173 prev
->next
= t
->next
;
177 t
->next
= free_atimers
;
187 /* Append two lists of atimers LIST_1 and LIST_2 and return the
190 static struct atimer
*
191 append_atimer_lists (struct atimer
*list_1
, struct atimer
*list_2
)
195 else if (list_2
== NULL
)
201 for (p
= list_1
; p
->next
; p
= p
->next
)
209 /* Stop all timers except timer T. T null means stop all timers. */
212 stop_other_atimers (struct atimer
*t
)
218 struct atimer
*p
, *prev
;
220 /* See if T is active. */
221 for (p
= atimers
, prev
= NULL
; p
&& p
!= t
; prev
= p
, p
= p
->next
)
227 prev
->next
= t
->next
;
233 /* T is not active. Let's handle this like T == 0. */
237 stopped_atimers
= append_atimer_lists (atimers
, stopped_atimers
);
243 /* Run all timers again, if some have been stopped with a call to
244 stop_other_atimers. */
247 run_all_atimers (void)
251 struct atimer
*t
= atimers
;
255 atimers
= stopped_atimers
;
256 stopped_atimers
= NULL
;
270 /* A version of run_all_atimers suitable for a record_unwind_protect. */
273 unwind_stop_other_atimers (Lisp_Object dummy
)
280 /* Arrange for a SIGALRM to arrive when the next timer is ripe. */
287 #ifdef HAVE_SETITIMER
291 /* Determine s/us till the next timer is ripe. */
292 EMACS_TIME now
= current_emacs_time ();
294 /* Don't set the interval to 0; this disables the timer. */
295 EMACS_TIME interval
= (EMACS_TIME_LE (atimers
->expiration
, now
)
296 ? make_emacs_time (0, 1000 * 1000)
297 : sub_emacs_time (atimers
->expiration
, now
));
299 #ifdef HAVE_SETITIMER
301 memset (&it
, 0, sizeof it
);
302 it
.it_value
= make_timeval (interval
);
303 setitimer (ITIMER_REAL
, &it
, 0);
304 #else /* not HAVE_SETITIMER */
305 alarm (max (EMACS_SECS (interval
), 1));
306 #endif /* not HAVE_SETITIMER */
311 /* Insert timer T into the list of active atimers `atimers', keeping
312 the list sorted by expiration time. T must not be in this list
316 schedule_atimer (struct atimer
*t
)
318 struct atimer
*a
= atimers
, *prev
= NULL
;
320 /* Look for the first atimer that is ripe after T. */
321 while (a
&& EMACS_TIME_GT (t
->expiration
, a
->expiration
))
322 prev
= a
, a
= a
->next
;
324 /* Insert T in front of the atimer found, if any. */
336 EMACS_TIME now
= current_emacs_time ();
338 while (atimers
&& EMACS_TIME_LE (atimers
->expiration
, now
))
340 struct atimer
*t
= atimers
;
341 atimers
= atimers
->next
;
344 if (t
->type
== ATIMER_CONTINUOUS
)
346 t
->expiration
= add_emacs_time (now
, t
->interval
);
351 t
->next
= free_atimers
;
360 /* Signal handler for SIGALRM. SIGNO is the signal number, i.e.
364 handle_alarm_signal (int sig
)
370 /* Do pending timers. */
373 do_pending_atimers (void)
384 /* Turn alarms on/off. This seems to be temporarily necessary on
385 some systems like HPUX (see process.c). */
388 turn_on_atimers (bool on
)
400 struct sigaction action
;
401 free_atimers
= stopped_atimers
= atimers
= NULL
;
402 /* pending_signals is initialized in init_keyboard.*/
403 emacs_sigaction_init (&action
, handle_alarm_signal
);
404 sigaction (SIGALRM
, &action
, 0);