code.delx.au - gnu-emacs/blob - src/atimer.c

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