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"
31 /* Free-list of atimer structures. */
33 static struct atimer
*free_atimers
;
35 /* List of currently not running timers due to a call to
38 static struct atimer
*stopped_atimers
;
40 /* List of active atimers, sorted by expiration time. The timer that
41 will become ripe next is always at the front of this list. */
43 static struct atimer
*atimers
;
45 /* Non-zero means alarm_signal_handler has found ripe timers but
46 interrupt_input_blocked was non-zero. In this case, timer
47 functions are not called until the next UNBLOCK_INPUT because timer
48 functions are expected to call X, and X cannot be assumed to be
53 /* Block/unblock SIGALRM. */
55 #define BLOCK_ATIMERS sigblock (sigmask (SIGALRM))
56 #define UNBLOCK_ATIMERS sigunblock (sigmask (SIGALRM))
58 /* Function prototypes. */
60 static void set_alarm (void);
61 static void schedule_atimer (struct atimer
*);
62 static struct atimer
*append_atimer_lists (struct atimer
*,
64 static void alarm_signal_handler (int signo
);
67 /* Start a new atimer of type TYPE. TIME specifies when the timer is
68 ripe. FN is the function to call when the timer fires.
69 CLIENT_DATA is stored in the client_data member of the atimer
70 structure returned and so made available to FN when it is called.
72 If TYPE is ATIMER_ABSOLUTE, TIME is the absolute time at which the
75 If TYPE is ATIMER_RELATIVE, the timer is ripe TIME s/us in the
78 In both cases, the timer is automatically freed after it has fired.
80 If TYPE is ATIMER_CONTINUOUS, the timer fires every TIME s/us.
82 Value is a pointer to the atimer started. It can be used in calls
83 to cancel_atimer; don't free it yourself. */
86 start_atimer (enum atimer_type type
, EMACS_TIME timestamp
, atimer_callback fn
,
91 /* Round TIME up to the next full second if we don't have
93 #ifndef HAVE_SETITIMER
94 if (EMACS_NSECS (timestamp
) != 0
95 && EMACS_SECS (timestamp
) < TYPE_MAXIMUM (time_t))
97 EMACS_SET_USECS (timestamp
, 0);
98 EMACS_SET_SECS (timestamp
, EMACS_SECS (timestamp
) + 1);
100 #endif /* not HAVE_SETITIMER */
102 /* Get an atimer structure from the free-list, or allocate
107 free_atimers
= t
->next
;
110 t
= (struct atimer
*) xmalloc (sizeof *t
);
112 /* Fill the atimer structure. */
113 memset (t
, 0, sizeof *t
);
116 t
->client_data
= client_data
;
120 /* Compute the timer's expiration time. */
123 case ATIMER_ABSOLUTE
:
124 t
->expiration
= timestamp
;
127 case ATIMER_RELATIVE
:
128 EMACS_GET_TIME (t
->expiration
);
129 EMACS_ADD_TIME (t
->expiration
, t
->expiration
, timestamp
);
132 case ATIMER_CONTINUOUS
:
133 EMACS_GET_TIME (t
->expiration
);
134 EMACS_ADD_TIME (t
->expiration
, t
->expiration
, timestamp
);
135 t
->interval
= timestamp
;
139 /* Insert the timer in the list of active atimers. */
143 /* Arrange for a SIGALRM at the time the next atimer is ripe. */
150 /* Cancel and free atimer TIMER. */
153 cancel_atimer (struct atimer
*timer
)
159 for (i
= 0; i
< 2; ++i
)
161 struct atimer
*t
, *prev
;
162 struct atimer
**list
= i
? &stopped_atimers
: &atimers
;
164 /* See if TIMER is active or stopped. */
165 for (t
= *list
, prev
= NULL
; t
&& t
!= timer
; prev
= t
, t
= t
->next
)
168 /* If it is, take it off its list, and put in on the free-list.
169 We don't bother to arrange for setting a different alarm time,
170 since a too early one doesn't hurt. */
174 prev
->next
= t
->next
;
178 t
->next
= free_atimers
;
188 /* Append two lists of atimers LIST_1 and LIST_2 and return the
191 static struct atimer
*
192 append_atimer_lists (struct atimer
*list_1
, struct atimer
*list_2
)
196 else if (list_2
== NULL
)
202 for (p
= list_1
; p
->next
; p
= p
->next
)
210 /* Stop all timers except timer T. T null means stop all timers. */
213 stop_other_atimers (struct atimer
*t
)
219 struct atimer
*p
, *prev
;
221 /* See if T is active. */
222 for (p
= atimers
, prev
= NULL
; p
&& p
!= t
; prev
= p
, p
= p
->next
)
228 prev
->next
= t
->next
;
234 /* T is not active. Let's handle this like T == 0. */
238 stopped_atimers
= append_atimer_lists (atimers
, stopped_atimers
);
244 /* Run all timers again, if some have been stopped with a call to
245 stop_other_atimers. */
248 run_all_atimers (void)
252 struct atimer
*t
= atimers
;
256 atimers
= stopped_atimers
;
257 stopped_atimers
= NULL
;
271 /* A version of run_all_atimers suitable for a record_unwind_protect. */
274 unwind_stop_other_atimers (Lisp_Object dummy
)
281 /* Arrange for a SIGALRM to arrive when the next timer is ripe. */
288 EMACS_TIME now
, timestamp
;
289 #ifdef HAVE_SETITIMER
293 /* Determine s/us till the next timer is ripe. */
294 EMACS_GET_TIME (now
);
296 /* Don't set the interval to 0; this disables the timer. */
297 if (EMACS_TIME_LE (atimers
->expiration
, now
))
299 EMACS_SET_SECS (timestamp
, 0);
300 EMACS_SET_USECS (timestamp
, 1000);
303 EMACS_SUB_TIME (timestamp
, atimers
->expiration
, now
);
306 #ifdef HAVE_SETITIMER
308 memset (&it
, 0, sizeof it
);
309 it
.it_value
= make_timeval (timestamp
);
310 setitimer (ITIMER_REAL
, &it
, 0);
311 #else /* not HAVE_SETITIMER */
312 alarm (max (EMACS_SECS (timestamp
), 1));
313 #endif /* not HAVE_SETITIMER */
318 /* Insert timer T into the list of active atimers `atimers', keeping
319 the list sorted by expiration time. T must not be in this list
323 schedule_atimer (struct atimer
*t
)
325 struct atimer
*a
= atimers
, *prev
= NULL
;
327 /* Look for the first atimer that is ripe after T. */
328 while (a
&& EMACS_TIME_GT (t
->expiration
, a
->expiration
))
329 prev
= a
, a
= a
->next
;
331 /* Insert T in front of the atimer found, if any. */
346 && (pending_atimers
= interrupt_input_blocked
) == 0
347 && (EMACS_GET_TIME (now
),
348 EMACS_TIME_LE (atimers
->expiration
, now
)))
353 atimers
= atimers
->next
;
356 if (t
->type
== ATIMER_CONTINUOUS
)
358 EMACS_ADD_TIME (t
->expiration
, now
, t
->interval
);
363 t
->next
= free_atimers
;
376 pending_signals
= interrupt_input_pending
;
380 if (! pending_atimers
)
386 /* Signal handler for SIGALRM. SIGNO is the signal number, i.e.
390 alarm_signal_handler (int signo
)
393 SIGNAL_THREAD_CHECK (signo
);
405 /* Call alarm_signal_handler for pending timers. */
408 do_pending_atimers (void)
419 /* Turn alarms on/off. This seems to be temporarily necessary on
420 some systems like HPUX (see process.c). */
423 turn_on_atimers (int on
)
427 signal (SIGALRM
, alarm_signal_handler
);
438 free_atimers
= stopped_atimers
= atimers
= NULL
;
440 /* pending_signals is initialized in init_keyboard.*/
441 signal (SIGALRM
, alarm_signal_handler
);