1 /* Asynchronous timers.
  2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005,
  3                  2006, 2007, 2008, 2009, 2010  Free Software Foundation, Inc.
  4 
  5 This file is part of GNU Emacs.
  6 
  7 GNU Emacs is free software: you can redistribute it and/or modify
  8 it under the terms of the GNU General Public License as published by
  9 the Free Software Foundation, either version 3 of the License, or
 10 (at your option) any later version.
 11 
 12 GNU Emacs is distributed in the hope that it will be useful,
 13 but WITHOUT ANY WARRANTY; without even the implied warranty of
 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15 GNU General Public License for more details.
 16 
 17 You should have received a copy of the GNU General Public License
 18 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 19 
 20 #include <config.h>
 21 #include <signal.h>
 22 #include <stdio.h>
 23 #include <setjmp.h>
 24 #include <lisp.h>
 25 #include <syssignal.h>
 26 #include <systime.h>
 27 #include <blockinput.h>
 28 #include <atimer.h>
 29 
 30 #ifdef HAVE_UNISTD_H
 31 #include <unistd.h>
 32 #endif
 33 
 34 #ifdef HAVE_SYS_TIME_H
 35 #include <sys/time.h>
 36 #endif
 37 
 38 /* Free-list of atimer structures.  */
 39 
 40 static struct atimer *free_atimers;
 41 
 42 /* List of currently not running timers due to a call to
 43    lock_atimer.  */
 44 
 45 static struct atimer *stopped_atimers;
 46 
 47 /* List of active atimers, sorted by expiration time.  The timer that
 48    will become ripe next is always at the front of this list.  */
 49 
 50 static struct atimer *atimers;
 51 
 52 /* Non-zero means alarm_signal_handler has found ripe timers but
 53    interrupt_input_blocked was non-zero.  In this case, timer
 54    functions are not called until the next UNBLOCK_INPUT because timer
 55    functions are expected to call X, and X cannot be assumed to be
 56    reentrant.  */
 57 
 58 int pending_atimers;
 59 
 60 /* Block/unblock SIGALRM.  */
 61 
 62 #define BLOCK_ATIMERS   sigblock (sigmask (SIGALRM))
 63 #define UNBLOCK_ATIMERS sigunblock (sigmask (SIGALRM))
 64 
 65 /* Function prototypes.  */
 66 
 67 static void set_alarm P_ ((void));
 68 static void schedule_atimer P_ ((struct atimer *));
 69 static struct atimer *append_atimer_lists P_ ((struct atimer *,
 70                                                struct atimer *));
 71 SIGTYPE alarm_signal_handler ();
 72 
 73 
 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.
 78 
 79    If TYPE is ATIMER_ABSOLUTE, TIME is the absolute time at which the
 80    timer fires.
 81 
 82    If TYPE is ATIMER_RELATIVE, the timer is ripe TIME s/us in the
 83    future.
 84 
 85    In both cases, the timer is automatically freed after it has fired.
 86 
 87    If TYPE is ATIMER_CONTINUOUS, the timer fires every TIME s/us.
 88 
 89    Value is a pointer to the atimer started.  It can be used in calls
 90    to cancel_atimer; don't free it yourself.  */
 91 
 92 struct atimer *
 93 start_atimer (type, time, fn, client_data)
 94      enum atimer_type type;
 95      EMACS_TIME time;
 96      atimer_callback fn;
 97      void *client_data;
 98 {
 99   struct atimer *t;
100 
101   /* Round TIME up to the next full second if we don't have
102      itimers.  */
103 #ifndef HAVE_SETITIMER
104   if (EMACS_USECS (time) != 0)
105     {
106       EMACS_SET_USECS (time, 0);
107       EMACS_SET_SECS (time, EMACS_SECS (time) + 1);
108     }
109 #endif /* not HAVE_SETITIMER */
110 
111   /* Get an atimer structure from the free-list, or allocate
112      a new one.  */
113   if (free_atimers)
114     {
115       t = free_atimers;
116       free_atimers = t->next;
117     }
118   else
119     t = (struct atimer *) xmalloc (sizeof *t);
120 
121   /* Fill the atimer structure.  */
122   bzero (t, sizeof *t);
123   t->type = type;
124   t->fn = fn;
125   t->client_data = client_data;
126 
127   BLOCK_ATIMERS;
128 
129   /* Compute the timer's expiration time.  */
130   switch (type)
131     {
132     case ATIMER_ABSOLUTE:
133       t->expiration = time;
134       break;
135 
136     case ATIMER_RELATIVE:
137       EMACS_GET_TIME (t->expiration);
138       EMACS_ADD_TIME (t->expiration, t->expiration, time);
139       break;
140 
141     case ATIMER_CONTINUOUS:
142       EMACS_GET_TIME (t->expiration);
143       EMACS_ADD_TIME (t->expiration, t->expiration, time);
144       t->interval = time;
145       break;
146     }
147 
148   /* Insert the timer in the list of active atimers.  */
149   schedule_atimer (t);
150   UNBLOCK_ATIMERS;
151 
152   /* Arrange for a SIGALRM at the time the next atimer is ripe.  */
153   set_alarm ();
154 
155   return t;
156 }
157 
158 
159 /* Cancel and free atimer TIMER.  */
160 
161 void
162 cancel_atimer (timer)
163      struct atimer *timer;
164 {
165   int i;
166 
167   BLOCK_ATIMERS;
168 
169   for (i = 0; i < 2; ++i)
170     {
171       struct atimer *t, *prev;
172       struct atimer **list = i ? &stopped_atimers : &atimers;
173 
174       /* See if TIMER is active or stopped.  */
175       for (t = *list, prev = NULL; t && t != timer; prev = t, t = t->next)
176         ;
177 
178       /* If it is, take it off the its list, and put in on the
179          free-list.  We don't bother to arrange for setting a
180          different alarm time, since a too early one doesn't hurt.  */
181       if (t)
182         {
183           if (prev)
184             prev->next = t->next;
185           else
186             *list = t->next;
187 
188           t->next = free_atimers;
189           free_atimers = t;
190           break;
191         }
192     }
193 
194   UNBLOCK_ATIMERS;
195 }
196 
197 
198 /* Append two lists of atimers LIST1 and LIST2 and return the
199    result list.  */
200 
201 static struct atimer *
202 append_atimer_lists (list1, list2)
203      struct atimer *list1, *list2;
204 {
205   if (list1 == NULL)
206     return list2;
207   else if (list2 == NULL)
208     return list1;
209   else
210     {
211       struct atimer *p;
212 
213       for (p = list1; p->next; p = p->next)
214         ;
215       p->next = list2;
216       return list1;
217     }
218 }
219 
220 
221 /* Stop all timers except timer T.  T null means stop all timers.  */
222 
223 void
224 stop_other_atimers (t)
225      struct atimer *t;
226 {
227   BLOCK_ATIMERS;
228 
229   if (t)
230     {
231       struct atimer *p, *prev;
232 
233       /* See if T is active.  */
234       for (p = atimers, prev = NULL; p && p != t; prev = p, p = p->next)
235         ;
236 
237       if (p == t)
238         {
239           if (prev)
240             prev->next = t->next;
241           else
242             atimers = t->next;
243           t->next = NULL;
244         }
245       else
246         /* T is not active.  Let's handle this like T == 0.  */
247         t = NULL;
248     }
249 
250   stopped_atimers = append_atimer_lists (atimers, stopped_atimers);
251   atimers = t;
252   UNBLOCK_ATIMERS;
253 }
254 
255 
256 /* Run all timers again, if some have been stopped with a call to
257    stop_other_atimers.  */
258 
259 void
260 run_all_atimers ()
261 {
262   if (stopped_atimers)
263     {
264       struct atimer *t = atimers;
265       struct atimer *next;
266 
267       BLOCK_ATIMERS;
268       atimers = stopped_atimers;
269       stopped_atimers = NULL;
270 
271       while (t)
272         {
273           next = t->next;
274           schedule_atimer (t);
275           t = next;
276         }
277 
278       UNBLOCK_ATIMERS;
279     }
280 }
281 
282 
283 /* A version of run_all_timers suitable for a record_unwind_protect.  */
284 
285 Lisp_Object
286 unwind_stop_other_atimers (dummy)
287      Lisp_Object dummy;
288 {
289   run_all_atimers ();
290   return Qnil;
291 }
292 
293 
294 /* Arrange for a SIGALRM to arrive when the next timer is ripe.  */
295 
296 static void
297 set_alarm ()
298 {
299   if (atimers)
300     {
301       EMACS_TIME now, time;
302 #ifdef HAVE_SETITIMER
303       struct itimerval it;
304 #endif
305 
306       /* Determine s/us till the next timer is ripe.  */
307       EMACS_GET_TIME (now);
308       EMACS_SUB_TIME (time, atimers->expiration, now);
309 
310 #ifdef HAVE_SETITIMER
311       /* Don't set the interval to 0; this disables the timer.  */
312       if (EMACS_TIME_LE (atimers->expiration, now))
313         {
314           EMACS_SET_SECS (time, 0);
315           EMACS_SET_USECS (time, 1000);
316         }
317 
318       bzero (&it, sizeof it);
319       it.it_value = time;
320       setitimer (ITIMER_REAL, &it, 0);
321 #else /* not HAVE_SETITIMER */
322       alarm (max (EMACS_SECS (time), 1));
323 #endif /* not HAVE_SETITIMER */
324     }
325 }
326 
327 
328 /* Insert timer T into the list of active atimers `atimers', keeping
329    the list sorted by expiration time.  T must not be in this list
330    already.  */
331 
332 static void
333 schedule_atimer (t)
334      struct atimer *t;
335 {
336   struct atimer *a = atimers, *prev = NULL;
337 
338   /* Look for the first atimer that is ripe after T.  */
339   while (a && EMACS_TIME_GT (t->expiration, a->expiration))
340     prev = a, a = a->next;
341 
342   /* Insert T in front of the atimer found, if any.  */
343   if (prev)
344     prev->next = t;
345   else
346     atimers = t;
347 
348   t->next = a;
349 }
350 
351 static void
352 run_timers ()
353 {
354   EMACS_TIME now;
355 
356   EMACS_GET_TIME (now);
357 
358   while (atimers
359          && (pending_atimers = interrupt_input_blocked) == 0
360          && EMACS_TIME_LE (atimers->expiration, now))
361     {
362       struct atimer *t;
363 
364       t = atimers;
365       atimers = atimers->next;
366       t->fn (t);
367 
368       if (t->type == ATIMER_CONTINUOUS)
369         {
370           EMACS_ADD_TIME (t->expiration, now, t->interval);
371           schedule_atimer (t);
372         }
373       else
374         {
375           t->next = free_atimers;
376           free_atimers = t;
377         }
378 
379       EMACS_GET_TIME (now);
380     }
381 
382   if (! atimers)
383     pending_atimers = 0;
384 
385 #ifdef SYNC_INPUT
386   if (pending_atimers)
387     pending_signals = 1;
388   else
389     {
390       pending_signals = interrupt_input_pending;
391       set_alarm ();
392     }
393 #else
394   if (! pending_atimers)
395     set_alarm ();
396 #endif
397 }
398 
399 
400 /* Signal handler for SIGALRM.  SIGNO is the signal number, i.e.
401    SIGALRM.  */
402 
403 SIGTYPE
404 alarm_signal_handler (signo)
405      int signo;
406 {
407 #ifndef SYNC_INPUT
408   SIGNAL_THREAD_CHECK (signo);
409 #endif
410 
411   pending_atimers = 1;
412 #ifdef SYNC_INPUT
413   pending_signals = 1;
414 #else
415   run_timers ();
416 #endif
417 }
418 
419 
420 /* Call alarm_signal_handler for pending timers.  */
421 
422 void
423 do_pending_atimers ()
424 {
425   if (pending_atimers)
426     {
427       BLOCK_ATIMERS;
428       run_timers ();
429       UNBLOCK_ATIMERS;
430     }
431 }
432 
433 
434 /* Turn alarms on/off.  This seems to be temporarily necessary on
435    some systems like HPUX (see process.c).  */
436 
437 void
438 turn_on_atimers (on)
439      int on;
440 {
441   if (on)
442     {
443       signal (SIGALRM, alarm_signal_handler);
444       set_alarm ();
445     }
446   else
447     alarm (0);
448 }
449 
450 
451 void
452 init_atimer ()
453 {
454   free_atimers = stopped_atimers = atimers = NULL;
455   pending_atimers = 0;
456   /* pending_signals is initialized in init_keyboard.*/
457   signal (SIGALRM, alarm_signal_handler);
458 }
459 
460 /* arch-tag: e6308261-eec6-404b-89fb-6e5909518d70
461    (do not change this comment) */