atimer.c 9.42 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, 2010  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

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

/* Function prototypes.  */

67 68 69 70
static void set_alarm (void);
static void schedule_atimer (struct atimer *);
static struct atimer *append_atimer_lists (struct atimer *,
                                           struct atimer *);
71
SIGTYPE alarm_signal_handler (int signo);
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


/* 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 *
Juanma Barranquero's avatar
Juanma Barranquero committed
93 94
start_atimer (enum atimer_type type, EMACS_TIME time, atimer_callback fn,
	      void *client_data)
Gerd Moellmann's avatar
Gerd Moellmann committed
95 96 97 98 99 100 101 102
{
  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)
    {
103 104
      EMACS_SET_USECS (time, 0);
      EMACS_SET_SECS (time, EMACS_SECS (time) + 1);
Gerd Moellmann's avatar
Gerd Moellmann committed
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
    }
#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;
132

Gerd Moellmann's avatar
Gerd Moellmann committed
133 134 135 136
    case ATIMER_RELATIVE:
      EMACS_GET_TIME (t->expiration);
      EMACS_ADD_TIME (t->expiration, t->expiration, time);
      break;
137

Gerd Moellmann's avatar
Gerd Moellmann committed
138 139 140 141 142 143 144 145 146 147 148 149 150
    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 ();
151

Gerd Moellmann's avatar
Gerd Moellmann committed
152 153 154 155 156 157 158
  return t;
}


/* Cancel and free atimer TIMER.  */

void
159
cancel_atimer (struct atimer *timer)
Gerd Moellmann's avatar
Gerd Moellmann committed
160
{
161
  int i;
162

Gerd Moellmann's avatar
Gerd Moellmann committed
163 164
  BLOCK_ATIMERS;

165
  for (i = 0; i < 2; ++i)
166
    {
167 168
      struct atimer *t, *prev;
      struct atimer **list = i ? &stopped_atimers : &atimers;
169

170
      /* See if TIMER is active or stopped.  */
171
      for (t = *list, prev = NULL; t && t != timer; prev = t, t = t->next)
172 173
	;

174
      /* If it is, take it off the its list, and put in on the
175 176 177 178 179 180 181 182
	 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;
183

184 185
	  t->next = free_atimers;
	  free_atimers = t;
186
	  break;
187
	}
Gerd Moellmann's avatar
Gerd Moellmann committed
188 189 190 191 192 193
    }

  UNBLOCK_ATIMERS;
}


194 195 196 197
/* Append two lists of atimers LIST1 and LIST2 and return the
   result list.  */

static struct atimer *
198
append_atimer_lists (struct atimer *list1, struct atimer *list2)
199 200 201 202 203 204 205 206
{
  if (list1 == NULL)
    return list2;
  else if (list2 == NULL)
    return list1;
  else
    {
      struct atimer *p;
207

208 209 210 211 212 213 214 215 216
      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.  */
217 218

void
219
stop_other_atimers (struct atimer *t)
220 221
{
  BLOCK_ATIMERS;
222

223 224
  if (t)
    {
225
      struct atimer *p, *prev;
226

227
      /* See if T is active.  */
228
      for (p = atimers, prev = NULL; p && p != t; prev = p, p = p->next)
229 230 231 232 233 234 235 236 237 238 239 240 241
	;

      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;
242
    }
243

244
  stopped_atimers = append_atimer_lists (atimers, stopped_atimers);
245 246 247 248 249 250 251 252 253
  atimers = t;
  UNBLOCK_ATIMERS;
}


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

void
254
run_all_atimers (void)
255 256 257 258
{
  if (stopped_atimers)
    {
      struct atimer *t = atimers;
259
      struct atimer *next;
260

261 262 263
      BLOCK_ATIMERS;
      atimers = stopped_atimers;
      stopped_atimers = NULL;
264

265 266 267 268 269 270
      while (t)
	{
	  next = t->next;
	  schedule_atimer (t);
	  t = next;
	}
271

272 273 274 275 276 277 278 279
      UNBLOCK_ATIMERS;
    }
}


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

Lisp_Object
280
unwind_stop_other_atimers (Lisp_Object dummy)
281 282 283 284 285 286
{
  run_all_atimers ();
  return Qnil;
}


Gerd Moellmann's avatar
Gerd Moellmann committed
287 288 289
/* Arrange for a SIGALRM to arrive when the next timer is ripe.  */

static void
290
set_alarm (void)
Gerd Moellmann's avatar
Gerd Moellmann committed
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
{
  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);
	}
310

Gerd Moellmann's avatar
Gerd Moellmann committed
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
      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
326
schedule_atimer (struct atimer *t)
Gerd Moellmann's avatar
Gerd Moellmann committed
327 328 329 330 331 332 333 334 335 336 337 338
{
  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;
339

Gerd Moellmann's avatar
Gerd Moellmann committed
340 341 342
  t->next = a;
}

343
static void
344
run_timers (void)
Gerd Moellmann's avatar
Gerd Moellmann committed
345 346
{
  EMACS_TIME now;
347

Gerd Moellmann's avatar
Gerd Moellmann committed
348
  EMACS_GET_TIME (now);
349

Gerd Moellmann's avatar
Gerd Moellmann committed
350 351 352 353 354
  while (atimers
	 && (pending_atimers = interrupt_input_blocked) == 0
	 && EMACS_TIME_LE (atimers->expiration, now))
    {
      struct atimer *t;
355

Gerd Moellmann's avatar
Gerd Moellmann committed
356 357 358
      t = atimers;
      atimers = atimers->next;
      t->fn (t);
359

Gerd Moellmann's avatar
Gerd Moellmann committed
360 361 362 363 364 365 366 367 368 369
      if (t->type == ATIMER_CONTINUOUS)
	{
	  EMACS_ADD_TIME (t->expiration, now, t->interval);
	  schedule_atimer (t);
	}
      else
	{
	  t->next = free_atimers;
	  free_atimers = t;
	}
370

Gerd Moellmann's avatar
Gerd Moellmann committed
371 372
      EMACS_GET_TIME (now);
    }
373

374 375 376
  if (! atimers)
    pending_atimers = 0;

377
#ifdef SYNC_INPUT
378 379 380 381 382 383 384
  if (pending_atimers)
    pending_signals = 1;
  else
    {
      pending_signals = interrupt_input_pending;
      set_alarm ();
    }
385 386 387 388
#else
  if (! pending_atimers)
    set_alarm ();
#endif
Gerd Moellmann's avatar
Gerd Moellmann committed
389 390 391
}


392 393 394 395
/* Signal handler for SIGALRM.  SIGNO is the signal number, i.e.
   SIGALRM.  */

SIGTYPE
396
alarm_signal_handler (int signo)
397
{
398 399 400 401
#ifndef SYNC_INPUT
  SIGNAL_THREAD_CHECK (signo);
#endif

402
  pending_atimers = 1;
403
#ifdef SYNC_INPUT
404
  pending_signals = 1;
405
#else
406 407 408 409 410
  run_timers ();
#endif
}


Gerd Moellmann's avatar
Gerd Moellmann committed
411 412 413
/* Call alarm_signal_handler for pending timers.  */

void
414
do_pending_atimers (void)
Gerd Moellmann's avatar
Gerd Moellmann committed
415 416 417 418
{
  if (pending_atimers)
    {
      BLOCK_ATIMERS;
419
      run_timers ();
Gerd Moellmann's avatar
Gerd Moellmann committed
420 421 422 423 424 425 426 427 428
      UNBLOCK_ATIMERS;
    }
}


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

void
429
turn_on_atimers (int on)
Gerd Moellmann's avatar
Gerd Moellmann committed
430 431 432 433 434 435 436 437 438 439 440 441
{
  if (on)
    {
      signal (SIGALRM, alarm_signal_handler);
      set_alarm ();
    }
  else
    alarm (0);
}


void
442
init_atimer (void)
Gerd Moellmann's avatar
Gerd Moellmann committed
443
{
444
  free_atimers = stopped_atimers = atimers = NULL;
Gerd Moellmann's avatar
Gerd Moellmann committed
445
  pending_atimers = 0;
446
  /* pending_signals is initialized in init_keyboard.*/
Gerd Moellmann's avatar
Gerd Moellmann committed
447 448
  signal (SIGALRM, alarm_signal_handler);
}
Miles Bader's avatar
Miles Bader committed
449 450 451

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