atimer.c 9.67 KB
Newer Older
Gerd Moellmann's avatar
Gerd Moellmann committed
1
/* Asynchronous timers.
2
   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005,
Glenn Morris's avatar
Glenn Morris committed
3
                 2006, 2007, 2008, 2009  Free Software Foundation, Inc.
Gerd Moellmann's avatar
Gerd Moellmann committed
4 5 6

This file is part of GNU Emacs.

7
GNU Emacs is free software: you can redistribute it and/or modify
Gerd Moellmann's avatar
Gerd Moellmann committed
8
it under the terms of the GNU General Public License as published by
9 10
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Gerd Moellmann's avatar
Gerd Moellmann committed
11 12 13 14 15 16 17

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

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/>.  */
Gerd Moellmann's avatar
Gerd Moellmann committed
19 20 21

#include <config.h>
#include <signal.h>
22
#include <stdio.h>
23
#include <setjmp.h>
24
#include <lisp.h>
Gerd Moellmann's avatar
Gerd Moellmann committed
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
#include <syssignal.h>
#include <systime.h>
#include <blockinput.h>
#include <atimer.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif

/* Free-list of atimer structures.  */

static struct atimer *free_atimers;

42 43 44 45 46
/* List of currently not running timers due to a call to
   lock_atimer.  */

static struct atimer *stopped_atimers;

Gerd Moellmann's avatar
Gerd Moellmann committed
47 48 49 50 51 52 53 54 55 56 57 58 59
/* List of active atimers, sorted by expiration time.  The timer that
   will become ripe next is always at the front of this list.  */

static struct atimer *atimers;

/* Non-zero means alarm_signal_handler has found ripe timers but
   interrupt_input_blocked was non-zero.  In this case, timer
   functions are not called until the next UNBLOCK_INPUT because timer
   functions are expected to call X, and X cannot be assumed to be
   reentrant.  */

int pending_atimers;

Pavel Janík's avatar
Pavel Janík committed
60
/* Block/unblock SIGALRM.  */
Gerd Moellmann's avatar
Gerd Moellmann committed
61 62 63 64 65 66 67 68

#define BLOCK_ATIMERS   sigblock (sigmask (SIGALRM))
#define UNBLOCK_ATIMERS sigunblock (sigmask (SIGALRM))

/* Function prototypes.  */

static void set_alarm P_ ((void));
static void schedule_atimer P_ ((struct atimer *));
69 70
static struct atimer *append_atimer_lists P_ ((struct atimer *,
					       struct atimer *));
71
SIGTYPE alarm_signal_handler ();
Gerd Moellmann's avatar
Gerd Moellmann committed
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105


/* Start a new atimer of type TYPE.  TIME specifies when the timer is
   ripe.  FN is the function to call when the timer fires.
   CLIENT_DATA is stored in the client_data member of the atimer
   structure returned and so made available to FN when it is called.

   If TYPE is ATIMER_ABSOLUTE, TIME is the absolute time at which the
   timer fires.

   If TYPE is ATIMER_RELATIVE, the timer is ripe TIME s/us in the
   future.

   In both cases, the timer is automatically freed after it has fired.

   If TYPE is ATIMER_CONTINUOUS, the timer fires every TIME s/us.

   Value is a pointer to the atimer started.  It can be used in calls
   to cancel_atimer; don't free it yourself.  */

struct atimer *
start_atimer (type, time, fn, client_data)
     enum atimer_type type;
     EMACS_TIME time;
     atimer_callback fn;
     void *client_data;
{
  struct atimer *t;

  /* Round TIME up to the next full second if we don't have
     itimers.  */
#ifndef HAVE_SETITIMER
  if (EMACS_USECS (time) != 0)
    {
106 107
      EMACS_SET_USECS (time, 0);
      EMACS_SET_SECS (time, EMACS_SECS (time) + 1);
Gerd Moellmann's avatar
Gerd Moellmann committed
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
    }
#endif /* not HAVE_SETITIMER */

  /* Get an atimer structure from the free-list, or allocate
     a new one.  */
  if (free_atimers)
    {
      t = free_atimers;
      free_atimers = t->next;
    }
  else
    t = (struct atimer *) xmalloc (sizeof *t);

  /* Fill the atimer structure.  */
  bzero (t, sizeof *t);
  t->type = type;
  t->fn = fn;
  t->client_data = client_data;

  BLOCK_ATIMERS;

  /* Compute the timer's expiration time.  */
  switch (type)
    {
    case ATIMER_ABSOLUTE:
      t->expiration = time;
      break;
135

Gerd Moellmann's avatar
Gerd Moellmann committed
136 137 138 139
    case ATIMER_RELATIVE:
      EMACS_GET_TIME (t->expiration);
      EMACS_ADD_TIME (t->expiration, t->expiration, time);
      break;
140

Gerd Moellmann's avatar
Gerd Moellmann committed
141 142 143 144 145 146 147 148 149 150 151 152 153
    case ATIMER_CONTINUOUS:
      EMACS_GET_TIME (t->expiration);
      EMACS_ADD_TIME (t->expiration, t->expiration, time);
      t->interval = time;
      break;
    }

  /* Insert the timer in the list of active atimers.  */
  schedule_atimer (t);
  UNBLOCK_ATIMERS;

  /* Arrange for a SIGALRM at the time the next atimer is ripe.  */
  set_alarm ();
154

Gerd Moellmann's avatar
Gerd Moellmann committed
155 156 157 158 159 160 161 162 163 164
  return t;
}


/* Cancel and free atimer TIMER.  */

void
cancel_atimer (timer)
     struct atimer *timer;
{
165
  int i;
166

Gerd Moellmann's avatar
Gerd Moellmann committed
167 168
  BLOCK_ATIMERS;

169
  for (i = 0; i < 2; ++i)
170
    {
171 172
      struct atimer *t, *prev;
      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 180 181 182 183 184 185 186
	 free-list.  We don't bother to arrange for setting a
	 different alarm time, since a too early one doesn't hurt.  */
      if (t)
	{
	  if (prev)
	    prev->next = t->next;
	  else
	    *list = t->next;
187

188 189
	  t->next = free_atimers;
	  free_atimers = t;
190
	  break;
191
	}
Gerd Moellmann's avatar
Gerd Moellmann committed
192 193 194 195 196 197
    }

  UNBLOCK_ATIMERS;
}


198 199 200 201 202 203 204 205 206 207 208 209 210 211
/* Append two lists of atimers LIST1 and LIST2 and return the
   result list.  */

static struct atimer *
append_atimer_lists (list1, list2)
     struct atimer *list1, *list2;
{
  if (list1 == NULL)
    return list2;
  else if (list2 == NULL)
    return list1;
  else
    {
      struct atimer *p;
212

213 214 215 216 217 218 219 220 221
      for (p = list1; p->next; p = p->next)
	;
      p->next = list2;
      return list1;
    }
}


/* Stop all timers except timer T.  T null means stop all timers.  */
222 223 224 225 226 227

void
stop_other_atimers (t)
     struct atimer *t;
{
  BLOCK_ATIMERS;
228

229 230
  if (t)
    {
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 238 239 240 241 242 243 244 245 246 247
	;

      if (p == t)
	{
	  if (prev)
	    prev->next = t->next;
	  else
	    atimers = t->next;
	  t->next = NULL;
	}
      else
	/* T is not active.  Let's handle this like T == 0.  */
	t = NULL;
248
    }
249

250
  stopped_atimers = append_atimer_lists (atimers, stopped_atimers);
251 252 253 254 255 256 257 258 259 260 261 262 263 264
  atimers = t;
  UNBLOCK_ATIMERS;
}


/* Run all timers again, if some have been stopped with a call to
   stop_other_atimers.  */

void
run_all_atimers ()
{
  if (stopped_atimers)
    {
      struct atimer *t = atimers;
265
      struct atimer *next;
266

267 268 269
      BLOCK_ATIMERS;
      atimers = stopped_atimers;
      stopped_atimers = NULL;
270

271 272 273 274 275 276
      while (t)
	{
	  next = t->next;
	  schedule_atimer (t);
	  t = next;
	}
277

278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
      UNBLOCK_ATIMERS;
    }
}


/* A version of run_all_timers suitable for a record_unwind_protect.  */

Lisp_Object
unwind_stop_other_atimers (dummy)
     Lisp_Object dummy;
{
  run_all_atimers ();
  return Qnil;
}


Gerd Moellmann's avatar
Gerd Moellmann committed
294 295 296 297 298 299 300 301 302 303
/* Arrange for a SIGALRM to arrive when the next timer is ripe.  */

static void
set_alarm ()
{
#if defined (USG) && !defined (POSIX_SIGNALS)
  /* USG systems forget handlers when they are used;
     must reestablish each time.  */
  signal (SIGALRM, alarm_signal_handler);
#endif /* USG */
304

Gerd Moellmann's avatar
Gerd Moellmann committed
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
  if (atimers)
    {
      EMACS_TIME now, time;
#ifdef HAVE_SETITIMER
      struct itimerval it;
#endif

      /* Determine s/us till the next timer is ripe.  */
      EMACS_GET_TIME (now);
      EMACS_SUB_TIME (time, atimers->expiration, now);

#ifdef HAVE_SETITIMER
      /* Don't set the interval to 0; this disables the timer.  */
      if (EMACS_TIME_LE (atimers->expiration, now))
	{
	  EMACS_SET_SECS (time, 0);
	  EMACS_SET_USECS (time, 1000);
	}
323

Gerd Moellmann's avatar
Gerd Moellmann committed
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
      bzero (&it, sizeof it);
      it.it_value = time;
      setitimer (ITIMER_REAL, &it, 0);
#else /* not HAVE_SETITIMER */
      alarm (max (EMACS_SECS (time), 1));
#endif /* not HAVE_SETITIMER */
    }
}


/* Insert timer T into the list of active atimers `atimers', keeping
   the list sorted by expiration time.  T must not be in this list
   already.  */

static void
schedule_atimer (t)
     struct atimer *t;
{
  struct atimer *a = atimers, *prev = NULL;

  /* Look for the first atimer that is ripe after T.  */
  while (a && EMACS_TIME_GT (t->expiration, a->expiration))
    prev = a, a = a->next;

  /* Insert T in front of the atimer found, if any.  */
  if (prev)
    prev->next = t;
  else
    atimers = t;
353

Gerd Moellmann's avatar
Gerd Moellmann committed
354 355 356
  t->next = a;
}

357 358
static void
run_timers ()
Gerd Moellmann's avatar
Gerd Moellmann committed
359 360
{
  EMACS_TIME now;
361

Gerd Moellmann's avatar
Gerd Moellmann committed
362
  EMACS_GET_TIME (now);
363

Gerd Moellmann's avatar
Gerd Moellmann committed
364 365 366 367 368
  while (atimers
	 && (pending_atimers = interrupt_input_blocked) == 0
	 && EMACS_TIME_LE (atimers->expiration, now))
    {
      struct atimer *t;
369

Gerd Moellmann's avatar
Gerd Moellmann committed
370 371 372
      t = atimers;
      atimers = atimers->next;
      t->fn (t);
373

Gerd Moellmann's avatar
Gerd Moellmann committed
374 375 376 377 378 379 380 381 382 383
      if (t->type == ATIMER_CONTINUOUS)
	{
	  EMACS_ADD_TIME (t->expiration, now, t->interval);
	  schedule_atimer (t);
	}
      else
	{
	  t->next = free_atimers;
	  free_atimers = t;
	}
384

Gerd Moellmann's avatar
Gerd Moellmann committed
385 386
      EMACS_GET_TIME (now);
    }
387

388 389 390
  if (! atimers)
    pending_atimers = 0;

391
#ifdef SYNC_INPUT
392 393 394 395 396 397 398
  if (pending_atimers)
    pending_signals = 1;
  else
    {
      pending_signals = interrupt_input_pending;
      set_alarm ();
    }
399 400 401 402
#else
  if (! pending_atimers)
    set_alarm ();
#endif
Gerd Moellmann's avatar
Gerd Moellmann committed
403 404 405
}


406 407 408 409 410 411 412
/* Signal handler for SIGALRM.  SIGNO is the signal number, i.e.
   SIGALRM.  */

SIGTYPE
alarm_signal_handler (signo)
     int signo;
{
413 414 415 416
#ifndef SYNC_INPUT
  SIGNAL_THREAD_CHECK (signo);
#endif

417
  pending_atimers = 1;
418
#ifdef SYNC_INPUT
419
  pending_signals = 1;
420
#else
421 422 423 424 425
  run_timers ();
#endif
}


Gerd Moellmann's avatar
Gerd Moellmann committed
426 427 428 429 430 431 432 433
/* Call alarm_signal_handler for pending timers.  */

void
do_pending_atimers ()
{
  if (pending_atimers)
    {
      BLOCK_ATIMERS;
434
      run_timers ();
Gerd Moellmann's avatar
Gerd Moellmann committed
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
      UNBLOCK_ATIMERS;
    }
}


/* Turn alarms on/off.  This seems to be temporarily necessary on
   some systems like HPUX (see process.c).  */

void
turn_on_atimers (on)
     int on;
{
  if (on)
    {
      signal (SIGALRM, alarm_signal_handler);
      set_alarm ();
    }
  else
    alarm (0);
}


void
init_atimer ()
{
460
  free_atimers = stopped_atimers = atimers = NULL;
Gerd Moellmann's avatar
Gerd Moellmann committed
461
  pending_atimers = 0;
462
  /* pending_signals is initialized in init_keyboard.*/
Gerd Moellmann's avatar
Gerd Moellmann committed
463 464
  signal (SIGALRM, alarm_signal_handler);
}
Miles Bader's avatar
Miles Bader committed
465 466 467

/* arch-tag: e6308261-eec6-404b-89fb-6e5909518d70
   (do not change this comment) */