1 /* Asynchronous timers.
2 Copyright (C) 2000-2014 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 /* The alarm timer and whether it was properly initialized, if
44 POSIX timers are available. */
45 #ifdef HAVE_ITIMERSPEC
46 static timer_t alarm_timer
;
47 static bool alarm_timer_ok
;
50 /* Block/unblock SIGALRM. */
53 block_atimers (sigset_t
*oldset
)
56 sigemptyset (&blocked
);
57 sigaddset (&blocked
, SIGALRM
);
58 sigaddset (&blocked
, SIGINT
);
59 pthread_sigmask (SIG_BLOCK
, &blocked
, oldset
);
62 unblock_atimers (sigset_t
const *oldset
)
64 pthread_sigmask (SIG_SETMASK
, oldset
, 0);
67 /* Function prototypes. */
69 static void set_alarm (void);
70 static void schedule_atimer (struct atimer
*);
71 static struct atimer
*append_atimer_lists (struct atimer
*,
74 /* Start a new atimer of type TYPE. TIME specifies when the timer is
75 ripe. FN is the function to call when the timer fires.
76 CLIENT_DATA is stored in the client_data member of the atimer
77 structure returned and so made available to FN when it is called.
79 If TYPE is ATIMER_ABSOLUTE, TIME is the absolute time at which the
82 If TYPE is ATIMER_RELATIVE, the timer is ripe TIME s/us in the
85 In both cases, the timer is automatically freed after it has fired.
87 If TYPE is ATIMER_CONTINUOUS, the timer fires every TIME s/us.
89 Value is a pointer to the atimer started. It can be used in calls
90 to cancel_atimer; don't free it yourself. */
93 start_atimer (enum atimer_type type
, struct timespec timestamp
,
94 atimer_callback fn
, void *client_data
)
99 /* Round TIME up to the next full second if we don't have
101 #ifndef HAVE_SETITIMER
102 if (timestamp
.tv_nsec
!= 0 && timestamp
.tv_sec
< TYPE_MAXIMUM (time_t))
103 timestamp
= make_timespec (timestamp
.tv_sec
+ 1, 0);
104 #endif /* not HAVE_SETITIMER */
106 /* Get an atimer structure from the free-list, or allocate
111 free_atimers
= t
->next
;
114 t
= xmalloc (sizeof *t
);
116 /* Fill the atimer structure. */
117 memset (t
, 0, sizeof *t
);
120 t
->client_data
= client_data
;
122 block_atimers (&oldset
);
124 /* Compute the timer's expiration time. */
127 case ATIMER_ABSOLUTE
:
128 t
->expiration
= timestamp
;
131 case ATIMER_RELATIVE
:
132 t
->expiration
= timespec_add (current_timespec (), timestamp
);
135 case ATIMER_CONTINUOUS
:
136 t
->expiration
= timespec_add (current_timespec (), timestamp
);
137 t
->interval
= timestamp
;
141 /* Insert the timer in the list of active atimers. */
143 unblock_atimers (&oldset
);
145 /* Arrange for a SIGALRM at the time the next atimer is ripe. */
152 /* Cancel and free atimer TIMER. */
155 cancel_atimer (struct atimer
*timer
)
160 block_atimers (&oldset
);
162 for (i
= 0; i
< 2; ++i
)
164 struct atimer
*t
, *prev
;
165 struct atimer
**list
= i
? &stopped_atimers
: &atimers
;
167 /* See if TIMER is active or stopped. */
168 for (t
= *list
, prev
= NULL
; t
&& t
!= timer
; prev
= t
, t
= t
->next
)
171 /* If it is, take it off its list, and put in on the free-list.
172 We don't bother to arrange for setting a different alarm time,
173 since a too early one doesn't hurt. */
177 prev
->next
= t
->next
;
181 t
->next
= free_atimers
;
187 unblock_atimers (&oldset
);
191 /* Append two lists of atimers LIST_1 and LIST_2 and return the
194 static struct atimer
*
195 append_atimer_lists (struct atimer
*list_1
, struct atimer
*list_2
)
199 else if (list_2
== NULL
)
205 for (p
= list_1
; p
->next
; p
= p
->next
)
213 /* Stop all timers except timer T. T null means stop all timers. */
216 stop_other_atimers (struct atimer
*t
)
219 block_atimers (&oldset
);
223 struct atimer
*p
, *prev
;
225 /* See if T is active. */
226 for (p
= atimers
, prev
= NULL
; p
&& p
!= t
; prev
= p
, p
= p
->next
)
232 prev
->next
= t
->next
;
238 /* T is not active. Let's handle this like T == 0. */
242 stopped_atimers
= append_atimer_lists (atimers
, stopped_atimers
);
244 unblock_atimers (&oldset
);
248 /* Run all timers again, if some have been stopped with a call to
249 stop_other_atimers. */
252 run_all_atimers (void)
256 struct atimer
*t
= atimers
;
260 block_atimers (&oldset
);
261 atimers
= stopped_atimers
;
262 stopped_atimers
= NULL
;
271 unblock_atimers (&oldset
);
276 /* Arrange for a SIGALRM to arrive when the next timer is ripe. */
283 #ifdef HAVE_SETITIMER
286 struct timespec now
, interval
;
288 #ifdef HAVE_ITIMERSPEC
291 struct itimerspec ispec
;
292 ispec
.it_value
= atimers
->expiration
;
293 ispec
.it_interval
.tv_sec
= ispec
.it_interval
.tv_nsec
= 0;
294 if (timer_settime (alarm_timer
, 0, &ispec
, 0) == 0)
299 /* Determine interval till the next timer is ripe.
300 Don't set the interval to 0; this disables the timer. */
301 now
= current_timespec ();
302 interval
= (timespec_cmp (atimers
->expiration
, now
) <= 0
303 ? make_timespec (0, 1000 * 1000)
304 : timespec_sub (atimers
->expiration
, now
));
306 #ifdef HAVE_SETITIMER
308 memset (&it
, 0, sizeof it
);
309 it
.it_value
= make_timeval (interval
);
310 setitimer (ITIMER_REAL
, &it
, 0);
311 #else /* not HAVE_SETITIMER */
312 alarm (max (interval
.tv_sec
, 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
&& timespec_cmp (a
->expiration
, t
->expiration
) < 0)
329 prev
= a
, a
= a
->next
;
331 /* Insert T in front of the atimer found, if any. */
343 struct timespec now
= current_timespec ();
345 while (atimers
&& timespec_cmp (atimers
->expiration
, now
) <= 0)
347 struct atimer
*t
= atimers
;
348 atimers
= atimers
->next
;
351 if (t
->type
== ATIMER_CONTINUOUS
)
353 t
->expiration
= timespec_add (now
, t
->interval
);
358 t
->next
= free_atimers
;
367 /* Signal handler for SIGALRM. SIGNO is the signal number, i.e.
371 handle_alarm_signal (int sig
)
377 /* Do pending timers. */
380 do_pending_atimers (void)
385 block_atimers (&oldset
);
387 unblock_atimers (&oldset
);
392 /* Turn alarms on/off. This seems to be temporarily necessary on
393 some systems like HPUX (see process.c). */
396 turn_on_atimers (bool on
)
408 #ifdef HAVE_ITIMERSPEC
409 struct sigevent sigev
;
410 sigev
.sigev_notify
= SIGEV_SIGNAL
;
411 sigev
.sigev_signo
= SIGALRM
;
412 sigev
.sigev_value
.sival_ptr
= &alarm_timer
;
413 alarm_timer_ok
= timer_create (CLOCK_REALTIME
, &sigev
, &alarm_timer
) == 0;
415 free_atimers
= stopped_atimers
= atimers
= NULL
;
417 /* pending_signals is initialized in init_keyboard. */
418 struct sigaction action
;
419 emacs_sigaction_init (&action
, handle_alarm_signal
);
420 sigaction (SIGALRM
, &action
, 0);